pantheon-opencode 1.5.0-beta.3 → 1.5.0-beta.4

package/src/pantheon/cost-command.ts

@@ -4,11 +4,8 @@
  *
  * 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;
- *   - 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).
+ *   - only path: node:sqlite (DatabaseSync, readOnly) — node ≥ 22.5;
+ *   - missing/unreadable db → a diagnostic contract status as TEXT.
  *
  * dbPath resolution: explicit option > env PANTHEON_COST_DB > the version-aware
  * default selected by PANTHEON_OPENCODE_VERSION (v1 or v2). An unset version
@@ -18,16 +15,13 @@
  *
  * @module cost-command
  */
-import { execFile } from 'node:child_process'
 import { existsSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
-import { promisify } from 'node:util'
 import { z } from 'zod'
 
 import type { ToolContextLike } from './delegation.ts'
-
-const execFileAsync = promisify(execFile)
+import type { NativeTaskStatus } from './native-task-status.ts'
 
 /** One aggregated token row (per agent and phase). */
 export interface CostRow {
@@ -41,10 +35,21 @@ export interface CostRow {
 export interface CostCommandOptions {
   /** Explicit db path (testability / unusual installs). Default: resolved candidates. */
   dbPath?: string
+  /** Injectable loader for tests; production always loads node:sqlite. */
+  sqliteLoader?: () => Promise<SqliteModule>
 }
 
 export type OpenCodeVersion = 'v1' | 'v2'
 
+interface SqliteDatabase {
+  prepare(sql: string): { get(): unknown; all(...args: unknown[]): unknown[] }
+  close(): void
+}
+
+export interface SqliteModule {
+  DatabaseSync: new (path: string, options: { readOnly: boolean }) => SqliteDatabase
+}
+
 /** One cost tool: description + zod args shape + execute (delegation.ts shape). */
 export interface CostTool<Args extends z.ZodRawShape = typeof costArgs> {
   description: string
@@ -125,8 +130,11 @@ function assertCompatibleSchema(db: {
 }
 
 /** 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')
+async function queryWithNodeSqlite(
+  dbPath: string,
+  days: number,
+  sqlite: SqliteModule,
+): Promise<CostRow[]> {
   const db = new sqlite.DatabaseSync(dbPath, { readOnly: true })
   try {
     assertCompatibleSchema(db)
@@ -142,25 +150,6 @@ async function queryWithNodeSqlite(dbPath: string, days: number): Promise<CostRo
   }
 }
 
-/** 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, '--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 tokens by assistant agent/phase. */
 function aggregateMessages(dataValues: readonly string[]): CostRow[] {
   const byAgentAndPhase = new Map<string, CostRow>()
@@ -232,7 +221,42 @@ function renderMarkdown(rows: readonly CostRow[], days: number): string {
 }
 
 export function createCostCommand(options?: CostCommandOptions): CostCommand {
-  const scriptPath = new URL('../../scripts/cost.mjs', import.meta.url).pathname
+  const loadSqlite =
+    options?.sqliteLoader ?? (async () => (await import('node:sqlite')) as SqliteModule)
+
+  const failure = (status: NativeTaskStatus, detail: string): string =>
+    `status: ${status}\npantheon_cost failed: ${detail}`
+
+  const diagnostic = (err: unknown): string => {
+    if (err instanceof Error) {
+      const stderr = (err as Error & { stderr?: unknown }).stderr
+      const suffix =
+        typeof stderr === 'string' && stderr.trim() !== '' ? `; stderr: ${stderr.trim()}` : ''
+      return `${err.message}${suffix}`
+    }
+    return String(err)
+  }
+
+  const statusForError = (err: unknown): NativeTaskStatus => {
+    const detail = diagnostic(err).toLowerCase()
+    if (
+      detail.includes('not found') ||
+      detail.includes('unknown builtin') ||
+      detail.includes('no such built-in') ||
+      detail.includes('cannot find module')
+    ) {
+      return 'UNSUPPORTED'
+    }
+    if (
+      detail.includes('not a database') ||
+      detail.includes('malformed') ||
+      detail.includes('corrupt') ||
+      detail.includes('incompatible opencode.db schema')
+    ) {
+      return 'CORRUPT_DATA'
+    }
+    return 'UNAVAILABLE'
+  }
 
   const execute = async (args: { days?: number }, _ctx: ToolContextLike): Promise<string> => {
     const days = args?.days ?? 7
@@ -240,20 +264,16 @@ export function createCostCommand(options?: CostCommandOptions): CostCommand {
       const dbPath = findExistingDb(options?.dbPath)
       if (dbPath === undefined) {
         const expected = resolveCostDbPath(options)
-        return (
-          `pantheon_cost failed: opencode.db not found (expected at ${expected}). ` +
-          `No token history is available until opencode has stored session data.`
+        return failure(
+          'UNAVAILABLE',
+          `opencode.db not found (expected at ${expected}). No token history is available until opencode has stored session data.`,
         )
       }
-      const rows = await queryWithNodeSqlite(dbPath, days).catch(async (err: unknown) => {
-        if (err instanceof Error && err.message.startsWith('incompatible opencode.db schema'))
-          throw err
-        return queryWithScript(scriptPath, dbPath, days)
-      })
-      return renderMarkdown(rows, days)
+      const sqlite = await loadSqlite()
+      const rows = await queryWithNodeSqlite(dbPath, days, sqlite)
+      return `status: OK\n${renderMarkdown(rows, days)}`
     } catch (err: unknown) {
-      const reason = err instanceof Error ? err.message : String(err)
-      return `pantheon_cost failed: ${reason}`
+      return failure(statusForError(err), diagnostic(err))
     }
   }
 

package/src/pantheon/delegate-manager.ts

@@ -31,6 +31,8 @@ import {
   type DelegationClient,
   readDelegationReport,
 } from './delegation-finalize.ts'
+import { createNativeProbe, type NativeProbeFn, type ProbeClient } from './native-probe.ts'
+import { classifyNativeResult, type NativeTaskStatus } from './native-task-status.ts'
 import {
   buildStopInstruction,
   cappedSummary,
@@ -66,6 +68,7 @@ export interface ManagerReceipt {
   id: string
   agent: string
   state: 'reconciled' | 'error'
+  status: NativeTaskStatus
   line: string
 }
 
@@ -102,10 +105,15 @@ export interface DelegateManagerOptions {
   keepCompleted?: number
   /** Per-agent step budgets (routing.yml max_steps). */
   stepCap?: StepCapTracker
+  /** Lazy capability probe, invoked once before the first native dispatch. */
+  nativeProbe?: NativeProbeFn
+  /** V1 client used by the lazy capability probe. */
+  probeClient?: ProbeClient
 }
 
 export interface DelegateManager {
   launch(args: LaunchArgs): Promise<ManagerReceipt>
+  ensureNativeAvailable(): Promise<NativeTaskStatus | undefined>
   read(idOrAlias: string): Promise<string>
   list(): Promise<string[]>
   recover(): Promise<void>
@@ -131,9 +139,29 @@ export function resolveDelegateMode(
 
 const LINE_MAX = 160
 
+/** Remove terminal escapes and control characters from untrusted child output. */
+export function sanitizeReceiptText(text: string): string {
+  let clean = ''
+  let skippingAnsi = false
+  for (const char of text) {
+    const code = char.charCodeAt(0)
+    if (skippingAnsi) {
+      if (code === 0x5b) continue
+      if (code >= 0x40 && code <= 0x7e) skippingAnsi = false
+      continue
+    }
+    if (code === 0x1b) {
+      skippingAnsi = true
+      continue
+    }
+    if (char === '\n' || char === '\t' || (code >= 0x20 && code <= 0x7e)) clean += char
+  }
+  return clean
+}
+
 function firstLine(text: string, max = 80): string {
   const line =
-    (text ?? '')
+    sanitizeReceiptText(text ?? '')
       .split('\n')
       .map((l) => l.trim())
       .find((l) => l !== '') ?? ''
@@ -182,21 +210,30 @@ export function createDelegateManager(options: DelegateManagerOptions): Delegate
     task,
     parentSessionID,
     env = process.env,
-    models = [],
+    models: modelsOpt = [],
     timeoutMs = 120_000,
     readTimeoutMs = 60_000,
-    foregroundFallback = true,
+    foregroundFallback: fgFallbackOpt = true,
     maxEntries = 50,
     keepCompleted = 10,
     stepCap,
+    nativeProbe,
+    probeClient,
   } = options
 
+  // Strict native mode: foregroundFallback and models are overridden.
+  // The user-facing options are ignored when PANTHEON_DELEGATE_MODE=native.
+  const isNativeMode = resolveDelegateMode(env) === 'native'
+  const foregroundFallback = isNativeMode ? false : fgFallbackOpt
+  const models = isNativeMode ? [] : modelsOpt
+
   // Synchronous in-flight reservations per agent: launch() must decide
   // background vs foreground BEFORE its first await, otherwise concurrent
   // launches without interleaved awaits would all see an empty board.
   const pendingByAgent = new Map<string, number>()
   let seq = 0
   const foregroundRecent: { agent: string; line: string; at: number }[] = []
+  let probeResult: Awaited<ReturnType<NativeProbeFn>> | null = null
 
   function pending(agent: string): number {
     return pendingByAgent.get(agent.toLowerCase()) ?? 0
@@ -208,6 +245,12 @@ export function createDelegateManager(options: DelegateManagerOptions): Delegate
     }
   }
 
+  async function ensureNativeAvailable(): Promise<NativeTaskStatus | undefined> {
+    if (!isNativeMode || nativeProbe === undefined || probeClient === undefined) return undefined
+    probeResult ??= await nativeProbe({ client: probeClient, parentSessionID })
+    return probeResult.status === 'AVAILABLE' ? undefined : probeResult.status
+  }
+
   async function runTask(
     agent: string,
     prompt: string,
@@ -253,6 +296,7 @@ export function createDelegateManager(options: DelegateManagerOptions): Delegate
     // acknowledgment that the result was consumed.
     const terminalState = job.state
     const failed = verifyError !== undefined || terminalState === 'error'
+    const status = classifyNativeResult(job, verifyError)
     // Auto-reconcile + delete the signal file on the spot.
     if (job.state !== 'reconciled') await board.markReconciled(taskID)
     await board.deleteSignal(alias)
@@ -266,7 +310,7 @@ export function createDelegateManager(options: DelegateManagerOptions): Delegate
           LINE_MAX,
         )
       : boardLine(settled ?? job)
-    return { id: taskID, agent: job.agent, state: failed ? 'error' : 'reconciled', line }
+    return { id: taskID, agent: job.agent, state: failed ? 'error' : 'reconciled', status, line }
   }
 
   /** Apply a terminal transition best-effort: a racing hook may have gotten there first. */
@@ -333,7 +377,33 @@ export function createDelegateManager(options: DelegateManagerOptions): Delegate
     )
     foregroundRecent.push({ agent: args.agent, line, at: Date.now() })
     if (foregroundRecent.length > 20) foregroundRecent.splice(0, foregroundRecent.length - 20)
-    return { id, agent: args.agent, state: ok ? 'reconciled' : 'error', line }
+    const status = classifyNativeResult(
+      {
+        taskID: id,
+        parentSessionID,
+        agent: args.agent,
+        description: args.description ?? firstLine(args.prompt, 120),
+        state: ok ? 'completed' : 'error',
+        timedOut: false,
+        alias: id,
+        launchedAt: Date.now(),
+        updatedAt: Date.now(),
+        totalErrors: 0,
+        timeoutCount: 0,
+        terminalUnreconciled: false,
+        contextFiles: [],
+        ...(ok
+          ? {
+              resultSummary: firstLine(
+                (outcome as { ok: true; result: NativeTaskResult }).result.content ?? '',
+                500,
+              ),
+            }
+          : {}),
+      },
+      ok ? undefined : (outcome as { ok: false; error?: string }).error,
+    )
+    return { id, agent: args.agent, state: ok ? 'reconciled' : 'error', status, line }
   }
 
   return {
@@ -346,13 +416,31 @@ export function createDelegateManager(options: DelegateManagerOptions): Delegate
         const maxSteps = stepCap.maxStepsFor(args.agent)
         if (stepCap.isCapped(args.agent)) {
           const line = cappedSummary(args.agent, maxSteps ?? DEFAULT_MAX_STEPS).slice(0, LINE_MAX)
-          return { id: `cap-${Date.now()}`, agent: args.agent, state: 'reconciled', line }
+          return {
+            id: `cap-${Date.now()}`,
+            agent: args.agent,
+            state: 'reconciled',
+            status: 'ESCALATE',
+            line,
+          }
         }
         const rec = stepCap.recordStep(args.agent)
         if (rec.capped && rec.maxSteps !== undefined) {
           prompt = `${args.prompt}${buildStopInstruction(args.agent, rec.maxSteps)}`
         }
       }
+      if (isNativeMode) {
+        const unavailableStatus = await ensureNativeAvailable()
+        if (unavailableStatus !== undefined) {
+          return {
+            id: `probe-${parentSessionID}`,
+            agent: args.agent,
+            state: 'error',
+            status: unavailableStatus,
+            line: `[native] ${args.agent} — native API ${unavailableStatus.toLowerCase()} — ERR`,
+          }
+        }
+      }
       // Synchronous routing decision: background when a slot is free,
       // foreground fallback when full, clean rejection otherwise.
       const free =
@@ -363,6 +451,7 @@ export function createDelegateManager(options: DelegateManagerOptions): Delegate
         `pantheon_delegate rejected: concurrency limit reached for agent "${args.agent}"`,
       )
     },
+    ensureNativeAvailable,
 
     async read(idOrAlias: string): Promise<string> {
       guardEnabled()
@@ -376,11 +465,11 @@ export function createDelegateManager(options: DelegateManagerOptions): Delegate
       if (terminal.state !== 'reconciled') await board.markReconciled(terminal.taskID)
       await board.deleteSignal(terminal.alias)
       if (terminal.state === 'error' && !terminal.resultSummary) {
-        return `# Delegation Report — ${terminal.alias}\n\nERROR: ${terminal.lastStatusError ?? 'failed'}\n`
+        return `# Delegation Report — ${terminal.alias}\n\nERROR: ${sanitizeReceiptText(terminal.lastStatusError ?? 'failed')}\n`
       }
       return (
         `# Delegation Report — ${terminal.alias}\n\n` +
-        `${terminal.resultSummary ?? terminal.lastStatusError ?? terminal.state}\n`
+        `${sanitizeReceiptText(terminal.resultSummary ?? terminal.lastStatusError ?? terminal.state)}\n`
       )
     },
 
@@ -524,7 +613,7 @@ export interface NativeDelegateToolset {
 }
 function shortFirstLine(text: string, max = 60): string {
   const line =
-    text
+    sanitizeReceiptText(text)
       .split('\n')
       .map((item) => item.trim())
       .find(Boolean) ?? ''
@@ -555,6 +644,7 @@ export function createNativeDelegateTools(wiring: NativeDelegateWiring): NativeD
   const managerFor = (parentSessionID: string): DelegateManager => {
     const existing = managers.get(parentSessionID)
     if (existing !== undefined) return existing
+    const nativeProbe = createNativeProbe()
     const manager = createDelegateManager({
       ...managerOptions,
       board,
@@ -562,6 +652,8 @@ export function createNativeDelegateTools(wiring: NativeDelegateWiring): NativeD
       parentSessionID,
       env,
       ...(stepCap === undefined ? {} : { stepCap }),
+      nativeProbe,
+      probeClient: client,
     })
     managers.set(parentSessionID, manager)
     return manager
@@ -577,6 +669,11 @@ export function createNativeDelegateTools(wiring: NativeDelegateWiring): NativeD
           throw new Error(
             `pantheon_delegate rejected: session ${ctx.sessionID} is a sub-session — only root sessions can delegate`,
           )
+        const manager = managerFor(ctx.sessionID)
+        const unavailableStatus = await manager.ensureNativeAvailable()
+        if (unavailableStatus !== undefined) {
+          return `status: ${unavailableStatus}\n[native] ${args.agent} — native API ${unavailableStatus.toLowerCase()} — ERR`
+        }
         const model = args.model ?? agentModel?.(args.agent)
         let childID: string
         try {
@@ -590,7 +687,7 @@ export function createNativeDelegateTools(wiring: NativeDelegateWiring): NativeD
           })
           childID = created.id
         } catch (error) {
-          return `pantheon_delegate failed: session.create rejected: ${error instanceof Error ? error.message : String(error)}`
+          return `pantheon_delegate failed: session.create rejected: ${sanitizeReceiptText(error instanceof Error ? error.message : String(error))}`
         }
         registerChildSession?.(childID, ctx.sessionID)
         if (args.read_only === true || isReadOnlyAgent?.(args.agent) === true)
@@ -598,14 +695,14 @@ export function createNativeDelegateTools(wiring: NativeDelegateWiring): NativeD
             agent: args.agent,
             ...(args.read_only === undefined ? {} : { readOnlyFlag: args.read_only }),
           })
-        const receipt = await managerFor(ctx.sessionID).launch({
+        const receipt = await manager.launch({
           agent: args.agent,
           prompt: args.prompt,
           ...(args.description === undefined ? {} : { description: args.description }),
           ...(args.model === undefined ? {} : { model: args.model }),
           taskID: childID,
         })
-        return receipt.line
+        return `status: ${receipt.status}\n${receipt.line}`
       },
     },
     pantheon_delegation_read: {

package/src/pantheon/native-probe.ts

@@ -0,0 +1,234 @@
+/**
+ * Native Probe — lazy capability detection for native task() delegation.
+ *
+ * The probe is invoked on the FIRST native delegation of a session (not at
+ * startup). It creates a child session with a minimal "ping" prompt, waits
+ * for idle, and classifies the output.
+ *
+ * Results are cached per probe instance (singleton guard):
+ *   - UNAVAILABLE is TERMINAL — no retry.
+ *   - AVAILABLE is also cached — no re-probe.
+ *
+ * Uses the OpenCode V1 session API (session.create + promptAsync) injected via
+ * the parent context.
+ *
+ * @module native-probe
+ */
+
+import { createPantheonLogger } from './logger.ts'
+
+const log = createPantheonLogger({ module: 'native-probe' })
+
+// ─── Types ─────────────────────────────────────────────────────────────
+
+/** Possible outcomes of a native capability probe. */
+export type NativeProbeResult = {
+  status: 'AVAILABLE' | 'UNAVAILABLE' | 'UNSUPPORTED'
+}
+
+/** Minimal V1 client shape needed by the probe (session.create + promptAsync). */
+export interface ProbeClient {
+  session: {
+    create: (input: { body: { parentID: string } }) => Promise<{ id: string }>
+    promptAsync: (input: {
+      path: { id: string }
+      body: { agent: string; parts: Array<{ type: 'text'; text: string }> }
+    }) => Promise<unknown>
+  }
+}
+
+/** Context injected into the probe function. */
+export interface NativeProbeContext {
+  client: ProbeClient
+  parentSessionID: string
+}
+
+/** Options for a single probe invocation. */
+export interface NativeProbeOptions {
+  /** Timeout in milliseconds. Default: 30000. */
+  timeoutMs?: number
+}
+
+/** The probe function signature. */
+export type NativeProbeFn = (
+  ctx: NativeProbeContext,
+  options?: NativeProbeOptions,
+) => Promise<NativeProbeResult>
+
+// ─── Helpers ───────────────────────────────────────────────────────────
+
+/** Default timeout for the probe. */
+const DEFAULT_TIMEOUT_MS = 30_000
+
+/** Sentinel value indicating a timeout occurred. */
+const TIMEOUT_SENTINEL = Symbol('timeout')
+
+/**
+ * Wrap a promise with a timeout.
+ * Returns the value on success, throws the original error on rejection,
+ * or returns TIMEOUT_SENTINEL if the timeout fires first.
+ */
+async function withTimeout<T>(
+  promise: Promise<T>,
+  ms: number,
+): Promise<T | typeof TIMEOUT_SENTINEL> {
+  return new Promise<T | typeof TIMEOUT_SENTINEL>((resolve, reject) => {
+    const timer = setTimeout(() => resolve(TIMEOUT_SENTINEL), ms)
+    void promise.then(
+      (value) => {
+        clearTimeout(timer)
+        resolve(value)
+      },
+      (err: unknown) => {
+        clearTimeout(timer)
+        reject(err)
+      },
+    )
+  })
+}
+
+/**
+ * Extract text content from a promptAsync response.
+ * Returns empty string if no recognizable content found.
+ */
+function extractOutput(result: unknown): string {
+  if (result == null) return ''
+  if (typeof result === 'string') return result
+  if (typeof result === 'object') {
+    const obj = result as Record<string, unknown>
+    // Check common shapes: { output }, { content }, { text }
+    if (typeof obj.output === 'string') return obj.output
+    if (typeof obj.content === 'string') return obj.content
+    if (typeof obj.text === 'string') return obj.text
+  }
+  // Non-empty object → treat as content (accepted message, etc.)
+  if (typeof result === 'object' && result !== null) {
+    return 'acknowledged'
+  }
+  return ''
+}
+
+function isUnsupportedError(message: string): boolean {
+  const lower = message.toLowerCase()
+  return (
+    lower.includes('not available') ||
+    lower.includes('not supported') ||
+    lower.includes('unsupported') ||
+    lower.includes('method not found')
+  )
+}
+
+// ─── Implementation ────────────────────────────────────────────────────
+
+/**
+ * Create a native probe function with per-instance caching.
+ *
+ * The probe is LAZY: it does not run at startup. Call it on the first
+ * native delegation of the session. The result is cached — subsequent
+ * calls return the cached value without re-probing.
+ *
+ * @returns A probe function that caches results per instance.
+ */
+export function createNativeProbe(): NativeProbeFn {
+  let cachedResult: NativeProbeResult | null = null
+  let inFlight: Promise<NativeProbeResult> | null = null
+
+  return async (
+    ctx: NativeProbeContext,
+    options?: NativeProbeOptions,
+  ): Promise<NativeProbeResult> => {
+    // Return cached result if available (singleton guard)
+    if (cachedResult !== null) {
+      return cachedResult
+    }
+    // Concurrent first dispatches share one probe instead of creating multiple
+    // child sessions. The promise is cleared only after a terminal result.
+    if (inFlight !== null) return inFlight
+
+    inFlight = probe(ctx, options)
+    try {
+      return await inFlight
+    } finally {
+      inFlight = null
+    }
+  }
+
+  async function probe(
+    ctx: NativeProbeContext,
+    options?: NativeProbeOptions,
+  ): Promise<NativeProbeResult> {
+    const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS
+
+    // ── Phase 1: create child session ──────────────────────────────
+    let childID: string
+    try {
+      const createResult = await withTimeout(
+        ctx.client.session.create({ body: { parentID: ctx.parentSessionID } }),
+        timeoutMs,
+      )
+      if (createResult === TIMEOUT_SENTINEL) {
+        // Timeout during session.create → UNAVAILABLE
+        log.warn('[Native Probe] session.create timed out after', timeoutMs, 'ms')
+        const result: NativeProbeResult = { status: 'UNAVAILABLE' }
+        cachedResult = result
+        return result
+      }
+      childID = createResult.id
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err)
+      log.error('[Native Probe] session.create failed:', msg)
+      // Check for unsupported API patterns
+      if (isUnsupportedError(msg)) {
+        const result: NativeProbeResult = { status: 'UNSUPPORTED' }
+        cachedResult = result
+        return result
+      }
+      // Other creation failures → UNAVAILABLE
+      const result: NativeProbeResult = { status: 'UNAVAILABLE' }
+      cachedResult = result
+      return result
+    }
+
+    // ── Phase 2: send probe prompt ─────────────────────────────────
+    let promptResult: unknown
+    try {
+      const raw = await withTimeout(
+        ctx.client.session.promptAsync({
+          path: { id: childID },
+          body: { agent: 'probe', parts: [{ type: 'text', text: 'Reply with PONG.' }] },
+        }),
+        timeoutMs,
+      )
+      if (raw === TIMEOUT_SENTINEL) {
+        // Timeout during promptAsync → UNAVAILABLE
+        log.warn('[Native Probe] promptAsync timed out after', timeoutMs, 'ms')
+        const result: NativeProbeResult = { status: 'UNAVAILABLE' }
+        cachedResult = result
+        return result
+      }
+      promptResult = raw
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err)
+      log.error('[Native Probe] promptAsync failed:', msg)
+      if (isUnsupportedError(msg)) {
+        const result: NativeProbeResult = { status: 'UNSUPPORTED' }
+        cachedResult = result
+        return result
+      }
+      // promptAsync error → UNAVAILABLE
+      const result: NativeProbeResult = { status: 'UNAVAILABLE' }
+      cachedResult = result
+      return result
+    }
+
+    // ── Phase 3: classify output ───────────────────────────────────
+    const output = extractOutput(promptResult)
+    const hasContent = output.trim() !== ''
+
+    const result: NativeProbeResult = {
+      status: hasContent ? 'AVAILABLE' : 'UNAVAILABLE',
+    }
+    cachedResult = result
+    return result
+  }
+}