pantheon-opencode 1.5.0-beta.1 → 1.5.0-beta.2

package/src/pantheon/cost-command.ts

@@ -1,12 +1,12 @@
 /**
- * Cost Command (Wave 4, PR #46) — `pantheon_cost` structural tool: cost +
- * token visibility for delegation traffic, straight from opencode.db.
+ * Token Command — `pantheon_cost` structural tool: token visibility for
+ * delegation traffic, straight from opencode.db.
  *
- * Reads the opencode session database READ-ONLY (sum cost + tokens by
- * agent over the last N days → markdown table). Zero new dependencies:
+ * Reads the opencode session database READ-ONLY (sum tokens by agent and
+ * phase over the last N days → markdown table). Zero new dependencies:
  *   - primary path: node:sqlite (DatabaseSync, readOnly) — node ≥ 22.5;
- *   - fallback: spawn scripts/cost.mjs (node:sqlite, prints JSON) when the
- *     direct import is unavailable;
+ *   - CLI fallback: spawn scripts/cost.mjs with its explicit flag-based
+ *     interface when the direct import is unavailable;
  *   - missing/unreadable db → FRIENDLY error string, never a crash (tools
  *     return errors as TEXT).
  *
@@ -29,12 +29,13 @@ import type { ToolContextLike } from './delegation.ts'
 
 const execFileAsync = promisify(execFile)
 
-/** One aggregated cost row (per agent). */
+/** One aggregated token row (per agent and phase). */
 export interface CostRow {
   agent: string
-  costUsd: number
+  phase: string
   tokensInput: number
   tokensOutput: number
+  tokensTotal: number
 }
 
 export interface CostCommandOptions {
@@ -123,7 +124,7 @@ function assertCompatibleSchema(db: {
   }
 }
 
-/** Aggregate cost + tokens by agent via node:sqlite (read-only). */
+/** Aggregate tokens by agent and phase via node:sqlite (read-only). */
 async function queryWithNodeSqlite(dbPath: string, days: number): Promise<CostRow[]> {
   const sqlite = await import('node:sqlite')
   const db = new sqlite.DatabaseSync(dbPath, { readOnly: true })
@@ -141,24 +142,28 @@ async function queryWithNodeSqlite(dbPath: string, days: number): Promise<CostRo
   }
 }
 
-/** Fallback: delegate the same aggregation to scripts/cost.mjs (node:sqlite). */
+/** CLI fallback: delegate the same aggregation to scripts/cost.mjs. */
 async function queryWithScript(
   scriptPath: string,
   dbPath: string,
   days: number,
 ): Promise<CostRow[]> {
-  const { stdout } = await execFileAsync(process.execPath, [scriptPath, dbPath, String(days)], {
-    timeout: 15_000,
-    encoding: 'utf8',
-  })
+  const { stdout } = await execFileAsync(
+    process.execPath,
+    [scriptPath, '--db-path', dbPath, '--days', String(days)],
+    {
+      timeout: 15_000,
+      encoding: 'utf8',
+    },
+  )
   const parsed = JSON.parse(stdout) as { ok: boolean; rows?: CostRow[]; error?: string }
   if (!parsed.ok) throw new Error(parsed.error ?? 'cost.mjs failed')
   return parsed.rows ?? []
 }
 
-/** Parse message.data JSON rows and aggregate cost + tokens by assistant agent. */
+/** Parse message.data JSON rows and aggregate tokens by assistant agent/phase. */
 function aggregateMessages(dataValues: readonly string[]): CostRow[] {
-  const byAgent = new Map<string, CostRow>()
+  const byAgentAndPhase = new Map<string, CostRow>()
   for (const value of dataValues) {
     try {
       const outer = JSON.parse(value) as Record<string, unknown>
@@ -169,45 +174,57 @@ function aggregateMessages(dataValues: readonly string[]): CostRow[] {
       if (info.role !== 'assistant') continue
       const agent = typeof info.agent === 'string' && info.agent !== '' ? info.agent : null
       if (agent === null) continue
-      const costUsd = Number(info.cost) || 0
+      const metadata = info.metadata as Record<string, unknown> | undefined
+      const phase =
+        (typeof info.phase === 'string' && info.phase) ||
+        (typeof metadata?.phase === 'string' && metadata.phase) ||
+        'unknown'
       const tokens = (info.tokens ?? {}) as Record<string, unknown>
       const tokensInput = Number(tokens.input) || 0
       const tokensOutput = Number(tokens.output) || 0
-      const acc = byAgent.get(agent) ?? { agent, costUsd: 0, tokensInput: 0, tokensOutput: 0 }
-      acc.costUsd += costUsd
+      const key = `${agent}\u0000${phase}`
+      const acc = byAgentAndPhase.get(key) ?? {
+        agent,
+        phase,
+        tokensInput: 0,
+        tokensOutput: 0,
+        tokensTotal: 0,
+      }
       acc.tokensInput += tokensInput
       acc.tokensOutput += tokensOutput
-      byAgent.set(agent, acc)
+      acc.tokensTotal += tokensInput + tokensOutput
+      byAgentAndPhase.set(key, acc)
     } catch {
       // Skip malformed rows — a partial ledger never breaks the report.
     }
   }
-  return [...byAgent.values()].sort((a, b) => b.costUsd - a.costUsd)
+  return [...byAgentAndPhase.values()].sort((a, b) => b.tokensTotal - a.tokensTotal)
 }
 
 /** Render the aggregate as a markdown table with a total row. */
 function renderMarkdown(rows: readonly CostRow[], days: number): string {
   if (rows.length === 0) {
-    return `## Cost by agent (last ${days} days)\n\nNo cost records in the last ${days} days.`
+    return `## Token usage by agent and phase (last ${days} days)\n\nNo token records in the last ${days} days.`
   }
   const total = rows.reduce(
     (acc, r) => {
-      acc.costUsd += r.costUsd
       acc.tokensInput += r.tokensInput
       acc.tokensOutput += r.tokensOutput
+      acc.tokensTotal += r.tokensTotal
       return acc
     },
-    { costUsd: 0, tokensInput: 0, tokensOutput: 0 },
+    { tokensInput: 0, tokensOutput: 0, tokensTotal: 0 },
   )
   const lines = [
-    `## Cost by agent (last ${days} days)`,
+    `## Token usage by agent and phase (last ${days} days)`,
     '',
-    '| Agent | Cost (USD) | Tokens In | Tokens Out |',
-    '|-------|-----------:|----------:|-----------:|',
+    '| Agent | Phase | Tokens In | Tokens Out | Tokens Total |',
+    '|-------|-------|----------:|-----------:|-------------:|',
     ...rows.map(
-      (r) => `| ${r.agent} | $${r.costUsd.toFixed(6)} | ${r.tokensInput} | ${r.tokensOutput} |`,
+      (r) =>
+        `| ${r.agent} | ${r.phase} | ${r.tokensInput} | ${r.tokensOutput} | ${r.tokensTotal} |`,
     ),
-    `| **Total** | **$${total.costUsd.toFixed(6)}** | **${total.tokensInput}** | **${total.tokensOutput}** |`,
+    `| **Total** | — | **${total.tokensInput}** | **${total.tokensOutput}** | **${total.tokensTotal}** |`,
     '',
     `Source: opencode.db (read-only)`,
   ]
@@ -218,14 +235,14 @@ export function createCostCommand(options?: CostCommandOptions): CostCommand {
   const scriptPath = new URL('../../scripts/cost.mjs', import.meta.url).pathname
 
   const execute = async (args: { days?: number }, _ctx: ToolContextLike): Promise<string> => {
-    const days = args.days ?? 7
+    const days = args?.days ?? 7
     try {
       const dbPath = findExistingDb(options?.dbPath)
       if (dbPath === undefined) {
         const expected = resolveCostDbPath(options)
         return (
           `pantheon_cost failed: opencode.db not found (expected at ${expected}). ` +
-          `No cost history is available until opencode has stored session data.`
+          `No token history is available until opencode has stored session data.`
         )
       }
       const rows = await queryWithNodeSqlite(dbPath, days).catch(async (err: unknown) => {
@@ -243,7 +260,7 @@ export function createCostCommand(options?: CostCommandOptions): CostCommand {
   return {
     pantheon_cost: {
       description:
-        'Report delegation cost + token usage by agent over the last N days, read from opencode.db (read-only, no writes).',
+        'Report input, output, and total token usage by agent and phase over the last N days, read from opencode.db (read-only, no monetary values).',
       args: costArgs,
       execute,
     },

package/src/pantheon/delegate-manager.ts

@@ -23,7 +23,14 @@
  * @module delegate-manager
  */
 
+import { z } from 'zod'
 import type { BackgroundJobBoard, BackgroundJobRecord } from './background-job-board.ts'
+import type { DelegationToolset } from './delegation.ts'
+import {
+  DELEGATION_DEFAULTS,
+  type DelegationClient,
+  readDelegationReport,
+} from './delegation-finalize.ts'
 import {
   buildStopInstruction,
   cappedSummary,
@@ -113,6 +120,13 @@ export function isDelegationEnabled(
   return (env.PANTHEON_DELEGATION ?? '').trim().toLowerCase() !== 'off'
 }
 
+export type DelegateMode = 'native' | 'legacy'
+export function resolveDelegateMode(
+  env: Record<string, string | undefined> = process.env,
+): DelegateMode {
+  return (env.PANTHEON_DELEGATE_MODE ?? '').trim().toLowerCase() === 'native' ? 'native' : 'legacy'
+}
+
 // ─── Helpers ───────────────────────────────────────────────────────────
 
 const LINE_MAX = 160
@@ -382,3 +396,274 @@ export function createDelegateManager(options: DelegateManagerOptions): Delegate
     },
   }
 }
+
+// Native delegation tools live with the manager so the plugin mounts the
+// manager directly; there is intentionally no adapter or kill-switch wrapper.
+const delegateArgs = {
+  prompt: z.string().min(1),
+  agent: z.string().min(1),
+  description: z.string().optional(),
+  read_only: z.boolean().optional(),
+  model: z.string().optional(),
+} satisfies z.ZodRawShape
+const readArgs = { id: z.string().min(1) } satisfies z.ZodRawShape
+const listArgs = {} satisfies z.ZodRawShape
+export interface ToolContextLike {
+  sessionID: string
+  agent?: string
+}
+export interface SessionTaskOptions {
+  client: DelegationClient
+  board: BackgroundJobBoard
+  outputDir?: string
+  promptTimeoutMs?: number
+  settleTimeoutMs?: number
+}
+export function parseModelRef(model: string): { id: string; providerID: string } | undefined {
+  const idx = model.indexOf('/')
+  return idx > 0 && idx < model.length - 1
+    ? { providerID: model.slice(0, idx), id: model.slice(idx + 1) }
+    : undefined
+}
+export function extractOutputSection(md: string | undefined): string {
+  if (md === undefined) return ''
+  const at = md.indexOf('## Output')
+  const body = at < 0 ? md : md.slice(at + 9)
+  const errAt = body.indexOf('\n**Error**:')
+  return (errAt < 0 ? body : body.slice(0, errAt)).trim()
+}
+async function promptAccept(
+  client: DelegationClient,
+  taskID: string,
+  agent: string,
+  prompt: string,
+  model: string | undefined,
+  signal: AbortSignal | undefined,
+  timeoutMs: number,
+): Promise<void> {
+  const modelRef = model === undefined ? undefined : parseModelRef(model)
+  let timer: ReturnType<typeof setTimeout> | undefined
+  try {
+    await Promise.race([
+      client.session
+        .promptAsync({
+          path: { id: taskID },
+          body: {
+            agent,
+            ...(modelRef === undefined ? {} : { model: modelRef }),
+            parts: [{ type: 'text', text: prompt }],
+          },
+          ...(signal === undefined ? {} : { signal }),
+        })
+        .then(undefined, (error: unknown) => {
+          throw new Error(
+            `promptAsync rejected: ${error instanceof Error ? error.message : String(error)}`,
+          )
+        }),
+      new Promise<never>((_, reject) => {
+        timer = setTimeout(
+          () => reject(new Error(`promptAsync timed out after ${timeoutMs}ms`)),
+          timeoutMs,
+        )
+        timer.unref?.()
+      }),
+    ])
+  } finally {
+    if (timer !== undefined) clearTimeout(timer)
+  }
+}
+export function createSessionTaskFn(options: SessionTaskOptions): NativeTaskFn {
+  const {
+    client,
+    board,
+    outputDir = DELEGATION_DEFAULTS.outputDir,
+    promptTimeoutMs = 60_000,
+    settleTimeoutMs = DELEGATION_DEFAULTS.timeoutMs,
+  } = options
+  return async ({ agent, prompt, model, signal, taskID }) => {
+    await promptAccept(client, taskID, agent, prompt, model, signal, promptTimeoutMs)
+    const terminal = await board.waitForTerminal(taskID, settleTimeoutMs)
+    const md = await readDelegationReport(outputDir, terminal)
+    return { content: extractOutputSection(md) || terminal.resultSummary || '' }
+  }
+}
+export interface NativeDelegateWiring {
+  board: BackgroundJobBoard
+  client: DelegationClient
+  outputDir?: string
+  env?: Record<string, string | undefined>
+  isRootSession: (sessionID: string) => boolean
+  registerChildSession?: (sessionID: string, parentID: string) => void
+  registerReadOnlySession?: (
+    sessionID: string,
+    info: { agent: string; readOnlyFlag?: boolean },
+  ) => void
+  isReadOnlyAgent?: (agent: string) => boolean
+  agentModel?: (agent: string) => string | undefined
+  managerOptions?: Partial<
+    Omit<DelegateManagerOptions, 'board' | 'task' | 'parentSessionID' | 'env'>
+  >
+  stepCap?: StepCapTracker
+}
+export interface NativeDelegateToolset {
+  pantheon_delegate: {
+    description: string
+    args: typeof delegateArgs
+    execute(args: z.infer<z.ZodObject<typeof delegateArgs>>, ctx: ToolContextLike): Promise<string>
+  }
+  pantheon_delegation_read: {
+    description: string
+    args: typeof readArgs
+    execute(args: z.infer<z.ZodObject<typeof readArgs>>, ctx: ToolContextLike): Promise<string>
+  }
+  pantheon_delegation_list: {
+    description: string
+    args: typeof listArgs
+    execute(args: z.infer<z.ZodObject<typeof listArgs>>, ctx: ToolContextLike): Promise<string>
+  }
+}
+function shortFirstLine(text: string, max = 60): string {
+  const line =
+    text
+      .split('\n')
+      .map((item) => item.trim())
+      .find(Boolean) ?? ''
+  return line.length > max ? `${line.slice(0, max - 1)}…` : line
+}
+export function createNativeDelegateTools(wiring: NativeDelegateWiring): NativeDelegateToolset {
+  const {
+    board,
+    client,
+    env = process.env,
+    isRootSession,
+    registerChildSession,
+    registerReadOnlySession,
+    isReadOnlyAgent,
+    agentModel,
+    managerOptions = {},
+    stepCap,
+  } = wiring
+  const task = createSessionTaskFn({
+    client,
+    board,
+    ...(wiring.outputDir === undefined ? {} : { outputDir: wiring.outputDir }),
+    ...(managerOptions.timeoutMs === undefined
+      ? {}
+      : { promptTimeoutMs: managerOptions.timeoutMs }),
+  })
+  const managers = new Map<string, DelegateManager>()
+  const managerFor = (parentSessionID: string): DelegateManager => {
+    const existing = managers.get(parentSessionID)
+    if (existing !== undefined) return existing
+    const manager = createDelegateManager({
+      ...managerOptions,
+      board,
+      task,
+      parentSessionID,
+      env,
+      ...(stepCap === undefined ? {} : { stepCap }),
+    })
+    managers.set(parentSessionID, manager)
+    return manager
+  }
+  return {
+    pantheon_delegate: {
+      description: 'Dispatch a background agent as a child session and return a verified receipt.',
+      args: delegateArgs,
+      execute: async (args, ctx) => {
+        if (!isDelegationEnabled(env))
+          throw new Error('pantheon delegation disabled (PANTHEON_DELEGATION=off)')
+        if (!isRootSession(ctx.sessionID))
+          throw new Error(
+            `pantheon_delegate rejected: session ${ctx.sessionID} is a sub-session — only root sessions can delegate`,
+          )
+        const model = args.model ?? agentModel?.(args.agent)
+        let childID: string
+        try {
+          const modelRef = model === undefined ? undefined : parseModelRef(model)
+          const created = await client.session.create({
+            body: {
+              parentID: ctx.sessionID,
+              title: args.description ?? shortFirstLine(args.prompt),
+              ...(modelRef === undefined ? {} : { model: modelRef }),
+            },
+          })
+          childID = created.id
+        } catch (error) {
+          return `pantheon_delegate failed: session.create rejected: ${error instanceof Error ? error.message : String(error)}`
+        }
+        registerChildSession?.(childID, ctx.sessionID)
+        if (args.read_only === true || isReadOnlyAgent?.(args.agent) === true)
+          registerReadOnlySession?.(childID, {
+            agent: args.agent,
+            ...(args.read_only === undefined ? {} : { readOnlyFlag: args.read_only }),
+          })
+        const receipt = await managerFor(ctx.sessionID).launch({
+          agent: args.agent,
+          prompt: args.prompt,
+          ...(args.description === undefined ? {} : { description: args.description }),
+          ...(args.model === undefined ? {} : { model: args.model }),
+          taskID: childID,
+        })
+        return receipt.line
+      },
+    },
+    pantheon_delegation_read: {
+      description: 'Block until a delegation finishes, then return its verified report.',
+      args: readArgs,
+      execute: async (args, ctx) => {
+        if (!isDelegationEnabled(env))
+          throw new Error('pantheon delegation disabled (PANTHEON_DELEGATION=off)')
+        return managerFor(ctx.sessionID).read(args.id)
+      },
+    },
+    pantheon_delegation_list: {
+      description: 'List background delegations.',
+      args: listArgs,
+      execute: async (_args, ctx) => {
+        if (!isDelegationEnabled(env))
+          throw new Error('pantheon delegation disabled (PANTHEON_DELEGATION=off)')
+        const lines = await managerFor(ctx.sessionID).list()
+        return lines.length > 0 ? lines.join('\n') : 'No delegations.'
+      },
+    },
+  }
+}
+export interface PluginNativeDelegationWiring {
+  board: BackgroundJobBoard
+  client: DelegationClient
+  isRootSession: (sessionID: string) => boolean
+  registerChildSession: (sessionID: string, parentID: string) => void
+  registerReadOnlySession: (
+    sessionID: string,
+    info: { agent: string; readOnlyFlag?: boolean },
+  ) => void
+  readOnlyAgents: ReadonlySet<string>
+  agentModels: Record<string, string | undefined>
+  stepCap: StepCapTracker
+  wallClockTimeoutMs?: number
+  finalizeDelegation: DelegationToolset['finalizeDelegation']
+}
+export type PluginNativeDelegation = NativeDelegateToolset & {
+  finalizeDelegation: DelegationToolset['finalizeDelegation']
+}
+export function buildPluginNativeDelegation(
+  wiring: PluginNativeDelegationWiring,
+): PluginNativeDelegation {
+  return {
+    ...createNativeDelegateTools({
+      board: wiring.board,
+      client: wiring.client,
+      isRootSession: wiring.isRootSession,
+      registerChildSession: wiring.registerChildSession,
+      registerReadOnlySession: wiring.registerReadOnlySession,
+      isReadOnlyAgent: (agent) => wiring.readOnlyAgents.has(agent.toLowerCase()),
+      agentModel: (agent) => wiring.agentModels[agent.toLowerCase()],
+      stepCap: wiring.stepCap,
+      ...(wiring.wallClockTimeoutMs === undefined
+        ? {}
+        : { managerOptions: { timeoutMs: wiring.wallClockTimeoutMs } }),
+    }),
+    finalizeDelegation: wiring.finalizeDelegation,
+  }
+}