/** ~/.agent paths, config, history trim, man digest (preamble for /bin/agent). */

/**
 * @param {Record<string, unknown>} ctx
 * @returns {string}
 */
function bareAgentResolveHome(ctx) {
  const env =
    ctx && typeof ctx === 'object' && ctx.env && typeof ctx.env === 'object'
      ? /** @type {Record<string, string>} */ (ctx.env)
      : {}
  const vfsHome =
    ctx &&
    typeof ctx === 'object' &&
    ctx.vfs &&
    typeof ctx.vfs === 'object' &&
    typeof /** @type {{ home?: string }} */ (ctx.vfs).home === 'string'
      ? String(/** @type {{ home?: string }} */ (ctx.vfs).home)
      : ''
  const h = env.HOME || vfsHome || '/home/guest'
  return h.replace(/\/+$/, '') || '/home/guest'
}

/**
 * @param {string} home
 */
function bareAgentPaths(home) {
  const base = home + '/.agent'
  return {
    dir: base,
    config: base + '/config.json',
    history: base + '/history.json',
    progress: base + '/progress.txt',
    instructions: base + '/instructions.md',
    context: base + '/context.md',
    cmdOut: base + '/last_command_out.txt',
    workspace: base + '/workspace',
    workspaceMemory: base + '/workspace/memory',
    workspaceSkills: base + '/workspace/skills',
    skillsGlobal: base + '/skills'
  }
}

function bareAgentDefaultConfig() {
  return {
    backend: 'qvac',
    rest_base_url: 'https://api.groq.com/openai/v1',
    rest_api_key: '',
    model: 'QWEN3_1_7B_INST_Q4',
    qvac_model: 'QWEN3_1_7B_INST_Q4',
    qvac_profile: 'recommended',
    qvac_ctx_size: 0,
    qvac_device: '',
    qvac_main_gpu: 'auto',
    qvac_gpu_layers: -1,
    max_tokens: 4096,
    temperature: 0.7,
    provider: 'qvac',
    max_iterations: 64,
    stream: true,
    tool_parallelism: 1,
    request_timeout_ms: 120000,
    extra_headers: /** @type {Record<string, string>} */ ({}),
    allow_delete: false,
    require_confirm_token: '',
    owner_name: '',
    agent_label: '',
    show_reasoning: false,
    reasoning_mode: 'off',
    reasoning_max_chars: 4000,
    reasoning_include_tools: true,
    allow_bridge_mutations: false,
    allow_host_notifications: false,
    allow_host_actions: false,
    emergency_stop_mutations: false,
    autonomous_mode_enabled: false,
    autonomous_max_runtime_ms: 1800000,
    autonomous_completion_required_checks: [],
    autonomous_allow_paths: ['*'],
    autonomous_deny_ops: [
      'delete_path',
      'request_host_action',
      'emit_host_notification',
      'list_verification_scripts',
      'run_maintenance_gate',
      'run_contract_checks',
      'summarize_build_drift'
    ],
    autonomous_active: false,
    autonomous_started_at_ms: 0,
    autonomous_stop_requested: false,
    autonomous_goal: '',
    autonomous_status: 'idle',
    autonomous_last_error: ''
  }
}

/**
 * @param {unknown} v
 * @returns {v is Record<string, unknown>}
 */
function bareAgentIsPlainObject(v) {
  return v != null && typeof v === 'object' && !Array.isArray(v)
}

/**
 * Shallow merge known keys from src into defaults.
 * @param {Record<string, unknown>} defaults
 * @param {Record<string, unknown>} src
 */
function bareAgentMergeConfig(defaults, src) {
  const out = { ...defaults }
  const known = new Set([
    'backend',
    'rest_base_url',
    'rest_api_key',
    'model',
    'qvac_model',
    'qvac_profile',
    'qvac_ctx_size',
    'qvac_device',
    'qvac_main_gpu',
    'qvac_gpu_layers',
    'max_tokens',
    'temperature',
    'provider',
    'max_iterations',
    'stream',
    'tool_parallelism',
    'request_timeout_ms',
    'extra_headers',
    'allow_delete',
    'require_confirm_token',
    'owner_name',
    'agent_label',
    'show_reasoning',
    'reasoning_mode',
    'reasoning_max_chars',
    'reasoning_include_tools',
    'allow_bridge_mutations',
    'allow_host_notifications',
    'allow_host_actions',
    'emergency_stop_mutations',
    'autonomous_mode_enabled',
    'autonomous_max_runtime_ms',
    'autonomous_completion_required_checks',
    'autonomous_allow_paths',
    'autonomous_deny_ops',
    'autonomous_active',
    'autonomous_started_at_ms',
    'autonomous_stop_requested',
    'autonomous_goal',
    'autonomous_status',
    'autonomous_last_error'
  ])
  for (const k of Object.keys(src)) {
    if (k.startsWith('x-')) continue
    if (!known.has(k)) continue
    const val = src[k]
    if (k === 'extra_headers' && bareAgentIsPlainObject(val)) {
      out.extra_headers = /** @type {Record<string, string>} */ ({ ...val })
      continue
    }
    if (k === 'backend') {
      const b = String(val ?? '').trim().toLowerCase()
      out.backend = b === 'rest' || b === 'openai' || b === 'http' ? 'rest' : 'qvac'
      continue
    }
    if (
      k === 'rest_base_url' ||
      k === 'rest_api_key' ||
      k === 'model' ||
      k === 'qvac_model' ||
      k === 'qvac_profile' ||
      k === 'provider' ||
      k === 'owner_name' ||
      k === 'agent_label' ||
      k === 'autonomous_goal' ||
      k === 'autonomous_status' ||
      k === 'autonomous_last_error'
    ) {
      out[k] = String(val ?? '')
      continue
    }
    if (k === 'reasoning_mode') {
      const mode = String(val ?? '').trim().toLowerCase()
      out.reasoning_mode =
        mode === 'summary' || mode === 'trace' ? mode : 'off'
      continue
    }
    if (
      k === 'max_tokens' ||
      k === 'temperature' ||
      k === 'max_iterations' ||
      k === 'tool_parallelism' ||
      k === 'request_timeout_ms' ||
      k === 'reasoning_max_chars' ||
      k === 'qvac_ctx_size' ||
      k === 'qvac_gpu_layers' ||
      k === 'autonomous_max_runtime_ms' ||
      k === 'autonomous_started_at_ms'
    ) {
      const n = Number(val)
      out[k] = Number.isFinite(n) ? n : defaults[k]
      continue
    }
    if (
      k === 'autonomous_completion_required_checks' ||
      k === 'autonomous_allow_paths' ||
      k === 'autonomous_deny_ops'
    ) {
      out[k] = Array.isArray(val) ? val.map((x) => String(x ?? '')).filter(Boolean) : defaults[k]
      continue
    }
    if (
      k === 'stream' ||
      k === 'allow_delete' ||
      k === 'show_reasoning' ||
      k === 'reasoning_include_tools' ||
      k === 'allow_bridge_mutations' ||
      k === 'allow_host_notifications' ||
      k === 'allow_host_actions' ||
      k === 'emergency_stop_mutations' ||
      k === 'autonomous_mode_enabled' ||
      k === 'autonomous_active' ||
      k === 'autonomous_stop_requested'
    ) {
      out[k] = Boolean(val)
      continue
    }
    if (k === 'require_confirm_token') {
      out.require_confirm_token = String(val ?? '')
      continue
    }
  }
  return out
}

/**
 * @param {Record<string, unknown>} raw
 */
function bareAgentValidateConfigShape(raw) {
  if (!bareAgentIsPlainObject(raw)) throw new Error('config must be a JSON object')
  for (const k of Object.keys(raw)) {
    if (k.startsWith('x-')) continue
    const known = [
      'backend',
      'rest_base_url',
      'rest_api_key',
      'model',
      'qvac_model',
      'qvac_profile',
      'qvac_ctx_size',
      'qvac_device',
      'qvac_main_gpu',
      'qvac_gpu_layers',
      'max_tokens',
      'temperature',
      'provider',
      'max_iterations',
      'stream',
      'tool_parallelism',
      'request_timeout_ms',
      'extra_headers',
      'allow_delete',
      'require_confirm_token',
      'owner_name',
      'agent_label',
      'show_reasoning',
      'reasoning_mode',
      'reasoning_max_chars',
      'reasoning_include_tools',
      'allow_bridge_mutations',
      'allow_host_notifications',
      'allow_host_actions',
      'emergency_stop_mutations',
      'autonomous_mode_enabled',
      'autonomous_max_runtime_ms',
      'autonomous_completion_required_checks',
      'autonomous_allow_paths',
      'autonomous_deny_ops',
      'autonomous_active',
      'autonomous_started_at_ms',
      'autonomous_stop_requested',
      'autonomous_goal',
      'autonomous_status',
      'autonomous_last_error'
    ]
    if (!known.includes(k)) {
      throw new Error('unknown config key: ' + k)
    }
  }
}

/**
 * @param {Record<string, unknown>} ctx
 * @param {{ dir: string, config: string }} paths
 * @returns {Promise<{ config: ReturnType<typeof bareAgentDefaultConfig>, created: boolean }>}
 */
async function bareAgentLoadOrCreateConfig(ctx, paths) {
  const vfs = ctx.vfs
  if (!vfs || typeof vfs.mkdir !== 'function')
    throw new Error('agent: vfs.mkdir unavailable')
  await vfs.mkdir(paths.dir, { recursive: true })

  let missingOrEmpty = false
  /** @type {Record<string, unknown>} */
  let raw = {}
  try {
    if (typeof vfs.readFile === 'function') {
      const buf = await vfs.readFile(paths.config)
      if (!buf || !buf.length) missingOrEmpty = true
      else {
        const t =
          typeof ctx.b4a !== 'undefined' && ctx.b4a && typeof ctx.b4a.toString === 'function'
            ? ctx.b4a.toString(buf)
            : String(new TextDecoder().decode(buf))
        raw = JSON.parse(t)
      }
    } else missingOrEmpty = true
  } catch {
    missingOrEmpty = true
    raw = {}
  }

  if (!bareAgentIsPlainObject(raw)) raw = {}

  if (missingOrEmpty || Object.keys(raw).length === 0) {
    raw = bareAgentDefaultConfig()
    await bareAgentSaveConfig(ctx, paths, /** @type {any} */ (raw))
    return { config: /** @type {any} */ (raw), created: true }
  }

  bareAgentValidateConfigShape(raw)
  const merged = bareAgentMergeConfig(bareAgentDefaultConfig(), raw)
  return { config: /** @type {any} */ (merged), created: false }
}

/**
 * @param {Record<string, unknown>} ctx
 * @param {{ config: string }} paths
 * @param {Record<string, unknown>} config
 */
async function bareAgentSaveConfig(ctx, paths, config) {
  const vfs = ctx.vfs
  if (!vfs || typeof vfs.writeFile !== 'function')
    throw new Error('agent: vfs.writeFile unavailable')
  bareAgentValidateConfigShape(config)
  const json = JSON.stringify(config, null, 2) + '\n'
  const body =
    typeof ctx.b4a !== 'undefined' && ctx.b4a && typeof ctx.b4a.from === 'function'
      ? ctx.b4a.from(json)
      : new TextEncoder().encode(json)
  await vfs.writeFile(paths.config, body)
}

/**
 * Drop middle messages until JSON size fits (keep first system + recent tail).
 * @param {unknown[]} msgs
 * @param {number} maxBytes
 */
function bareAgentTrimMessages(msgs, maxBytes) {
  if (!Array.isArray(msgs) || maxBytes <= 0) return []
  /** @type {unknown[]} */
  let out = msgs.slice()
  while (JSON.stringify(out).length > maxBytes && out.length > 3) {
    out.splice(2, 1)
  }
  return out
}

/**
 * Rough token estimate (chars/4). Good enough for local ctx budgeting.
 * @param {unknown} value
 */
function bareAgentEstimateTokens(value) {
  try {
    const n = JSON.stringify(value == null ? '' : value).length
    return Math.max(0, Math.ceil(n / 4))
  } catch {
    return 0
  }
}

/**
 * Trim history + shrink system content so prompt fits a QVAC ctx window.
 * Reserves room for completion and optional tools JSON.
 * @param {unknown[]} msgs
 * @param {number} ctxSize
 * @param {{ tools?: unknown[], reserveCompletion?: number }} [opts]
 */
function bareAgentTrimMessagesForCtx(msgs, ctxSize, opts) {
  const ctx = Math.max(2048, Math.floor(Number(ctxSize) || 4096))
  const reserve =
    opts && Number.isFinite(Number(opts.reserveCompletion))
      ? Math.max(256, Math.floor(Number(opts.reserveCompletion)))
      : Math.min(1024, Math.max(256, Math.floor(ctx * 0.15)))
  const toolsTok = bareAgentEstimateTokens(
    opts && Array.isArray(opts.tools) && opts.tools.length ? opts.tools : []
  )
  const budget = Math.max(512, ctx - reserve - toolsTok)

  /** @type {unknown[]} */
  let out = Array.isArray(msgs) ? msgs.slice() : []
  // Drop middle turns first (keep system + recent).
  while (bareAgentEstimateTokens(out) > budget && out.length > 3) {
    out.splice(2, 1)
  }
  // Shrink system blob if still over (workspace/man/skills dominate).
  if (bareAgentEstimateTokens(out) > budget && out[0] && typeof out[0] === 'object') {
    const sys = /** @type {Record<string, unknown>} */ (out[0])
    if (sys.role === 'system' && typeof sys.content === 'string') {
      let content = sys.content
      let guard = 0
      while (
        bareAgentEstimateTokens(out) > budget &&
        content.length > 800 &&
        guard < 24
      ) {
        content =
          content.slice(0, Math.floor(content.length * 0.82)) + '\n… truncated'
        out[0] = { ...sys, content }
        guard++
      }
    }
  }
  return out
}

/**
 * Best-effort load instruction files.
 * @param {Record<string, unknown>} ctx
 * @param {{ instructions: string, context: string }} paths
 */
async function bareAgentLoadInstructionFiles(ctx, paths) {
  const vfs = ctx.vfs
  const parts = []
  if (!vfs || typeof vfs.readFile !== 'function') return ''
  try {
    const b = await vfs.readFile(paths.instructions)
    if (b && b.length) {
      const t =
        typeof ctx.b4a !== 'undefined' && ctx.b4a && typeof ctx.b4a.toString === 'function'
          ? ctx.b4a.toString(b)
          : String(new TextDecoder().decode(b))
      if (t.trim()) parts.push('## User instructions (~/.agent/instructions.md)\n' + t.trim())
    }
  } catch {
    /* ignore */
  }
  try {
    const b = await vfs.readFile(paths.context)
    if (b && b.length) {
      const t =
        typeof ctx.b4a !== 'undefined' && ctx.b4a && typeof ctx.b4a.toString === 'function'
          ? ctx.b4a.toString(b)
          : String(new TextDecoder().decode(b))
      if (t.trim()) parts.push('## Agent context (~/.agent/context.md)\n' + t.trim())
    }
  } catch {
    /* ignore */
  }
  return parts.join('\n\n')
}

/**
 * One-time compact index from man.json for system prompt.
 * @param {Record<string, unknown>} ctx
 */
async function bareAgentManDigest(ctx) {
  const vfs = ctx.vfs
  if (!vfs || typeof vfs.readFile !== 'function') return ''
  try {
    const buf = await vfs.readFile('/share/man/man.json')
    if (!buf || !buf.length) return ''
    const t =
      typeof ctx.b4a !== 'undefined' && ctx.b4a && typeof ctx.b4a.toString === 'function'
        ? ctx.b4a.toString(buf)
        : String(new TextDecoder().decode(buf))
    const j = JSON.parse(t)
    const pages = Array.isArray(j.pages) ? j.pages : []
    /** @type {string[]} */
    const lines = []
    const max = Math.min(pages.length, 400)
    for (let i = 0; i < max; i++) {
      const p = pages[i]
      if (!p || typeof p !== 'object') continue
      const name = typeof p.name === 'string' ? p.name : ''
      const title = typeof p.title === 'string' ? p.title : ''
      if (name) lines.push('- ' + name + (title ? ': ' + title : ''))
    }
    let s = lines.join('\n')
    if (s.length > 24000) s = s.slice(0, 24000) + '\n…'
    return (
      'Manual page index (see `man <name>` for full text). Sample entries:\n' + s
    )
  } catch {
    return '(man digest unavailable)'
  }
}

/**
 * @param {Record<string, unknown>} ctx
 * @param {string} path
 */
async function bareAgentAppendProgress(ctx, path, line) {
  const vfs = ctx.vfs
  if (!vfs || typeof vfs.readFile !== 'function' || typeof vfs.writeFile !== 'function')
    return
  let prev = ''
  try {
    const b = await vfs.readFile(path)
    if (b && b.length) {
      prev =
        typeof ctx.b4a !== 'undefined' && ctx.b4a && typeof ctx.b4a.toString === 'function'
          ? ctx.b4a.toString(b)
          : String(new TextDecoder().decode(b))
    }
  } catch {
    /* ignore */
  }
  const chunk =
    new Date().toISOString() +
    ' ' +
    line.replace(/\r?\n/g, ' ') +
    '\n'
  const maxKeep = 120_000
  let next = prev + chunk
  if (next.length > maxKeep) next = next.slice(-maxKeep)
  const body =
    typeof ctx.b4a !== 'undefined' && ctx.b4a && typeof ctx.b4a.from === 'function'
      ? ctx.b4a.from(next)
      : new TextEncoder().encode(next)
  await vfs.writeFile(path, body)
}

/**
 * @param {Record<string, unknown>} ctx
 * @param {string} path
 * @param {unknown[]} messages
 */
async function bareAgentSaveHistory(ctx, path, messages) {
  const vfs = ctx.vfs
  if (!vfs || typeof vfs.writeFile !== 'function') return
  const trimmed = bareAgentTrimMessages(messages, 500_000)
  const json = JSON.stringify(trimmed, null, 2) + '\n'
  const body =
    typeof ctx.b4a !== 'undefined' && ctx.b4a && typeof ctx.b4a.from === 'function'
      ? ctx.b4a.from(json)
      : new TextEncoder().encode(json)
  await vfs.writeFile(path, body)
}

/**
 * @param {Record<string, unknown>} ctx
 * @param {string} path
 * @returns {Promise<unknown[]>}
 */
async function bareAgentLoadHistory(ctx, path) {
  const vfs = ctx.vfs
  if (!vfs || typeof vfs.readFile !== 'function') return []
  try {
    const buf = await vfs.readFile(path)
    if (!buf || !buf.length) return []
    const t =
      typeof ctx.b4a !== 'undefined' && ctx.b4a && typeof ctx.b4a.toString === 'function'
        ? ctx.b4a.toString(buf)
        : String(new TextDecoder().decode(buf))
    const j = JSON.parse(t)
    return Array.isArray(j) ? j : []
  } catch {
    return []
  }
}

/**
 * Clear persisted chat session (history + progress log; keeps config and instructions).
 * @param {Record<string, unknown>} ctx
 * @param {ReturnType<typeof bareAgentPaths>} paths
 * @param {string} argv0
 */
async function bareAgentResetChatSession(ctx, paths, argv0) {
  const vfs = ctx.vfs
  if (!vfs || typeof vfs.mkdir !== 'function' || typeof vfs.writeFile !== 'function') {
    throw new Error('agent reset: vfs unavailable')
  }
  await vfs.mkdir(paths.dir, { recursive: true })
  const emptyHist =
    typeof ctx.b4a !== 'undefined' && ctx.b4a && typeof ctx.b4a.from === 'function'
      ? ctx.b4a.from('[]\n')
      : new TextEncoder().encode('[]\n')
  await vfs.writeFile(paths.history, emptyHist)
  const stamp = new Date().toISOString() + ' chat session reset\n'
  const progBody =
    typeof ctx.b4a !== 'undefined' && ctx.b4a && typeof ctx.b4a.from === 'function'
      ? ctx.b4a.from(stamp)
      : new TextEncoder().encode(stamp)
  await vfs.writeFile(paths.progress, progBody)
  try {
    const z =
      typeof ctx.b4a !== 'undefined' && ctx.b4a && typeof ctx.b4a.from === 'function'
        ? ctx.b4a.from('')
        : new TextEncoder().encode('')
    await vfs.writeFile(paths.cmdOut, z)
  } catch {
    /* ignore */
  }
  try {
    ctx.console.log(
      argv0 + ': chat session cleared (' + paths.history + ', ' + paths.progress + ')'
    )
  } catch {
    /* ignore */
  }
}