@phnx-labs/agents-cli 1.22.107 → 1.22.109

package/dist/lib/session/parse.js

@@ -12,6 +12,7 @@ import * as path from 'path';
 import Database from '../sqlite.js';
 import { isSyntheticUserMessage, extractSlashCommandName, extractSlashCommandFromToolInput, unwrapUserQuery } from './prompt.js';
 import { structuredToolResult, commandsFromCodexExec } from './tool-calls.js';
+import { isCloudSessionPath } from './cloud.js';
 /**
  * Largest session file we will load into memory. Above this we throw a clean
  * error instead of OOMing or hitting V8's ERR_STRING_TOO_LONG. Aligns with
@@ -143,7 +144,11 @@ const TRANSCRIPT_PARSERS = {
     codex: (filePath) => parseCodex(filePath),
     gemini: (filePath) => parseGemini(filePath),
     antigravity: (filePath) => parseAntigravity(filePath),
-    opencode: (filePath) => parseOpenCode(filePath),
+    // Cloud-captured opencode sessions are normalized JSONL (produced by the
+    // factory at capture time), NOT the local `opencode.db#<session>` SQLite
+    // composite the offline parser reads — route by whether the path is in the
+    // cloud session cache (PHNX-3845).
+    opencode: (filePath) => isCloudSessionPath(filePath) ? parseOpencodeCloud(filePath) : parseOpenCode(filePath),
     grok: (filePath) => parseGrok(filePath),
     rush: (filePath) => parseRush(filePath),
     openclaw: () => [], // OpenClaw sessions don't have parseable files yet
@@ -206,7 +211,7 @@ export function detectAgent(filePath) {
         return 'muse';
     }
     // Cloud convention: cloud-sessions/<id>/session.<format>.jsonl
-    const cloudMatch = filePath.match(/session\.(claude|codex|rush)\.jsonl(?:$|[?#])/);
+    const cloudMatch = filePath.match(/session\.(claude|codex|rush|opencode)\.jsonl(?:$|[?#])/);
     if (cloudMatch)
         return cloudMatch[1];
     if (filePath.includes('opencode.db'))
@@ -1832,6 +1837,135 @@ export function parseOpenCode(filePath) {
     return events;
 }
 // ---------------------------------------------------------------------------
+// OpenCode parser — cloud (normalized JSONL)
+// ---------------------------------------------------------------------------
+//
+// OpenCode stores sessions in a SQLite DB, so the offline path reads a
+// `opencode.db#<session>` composite (parseOpenCode above). The CLOUD path is
+// different: the factory converts that DB into a flat, normalized JSONL
+// transcript at capture time (prix/factory opencode-capture.ts, PHNX-3845), so
+// the whole cloud pipeline stays SQLite-free downstream. This parser reads that
+// JSONL; it's routed from TRANSCRIPT_PARSERS only when the file lives in the
+// cloud session cache (isCloudSessionPath).
+//
+// Each line is one of:
+//   transcript row:
+//     { role: "user"|"assistant", part_type: "text"|"reasoning"|"tool",
+//       part_data: <json string>, time_created: <ms number> }
+//   todo snapshot (at most one, emitted last):
+//     { part_type: "todo", todos: [{content,status}], time_created: <ms> }
+//
+// The per-part logic mirrors parseOpenCode's post-query switch (and prix/api's
+// server-side parseOpencode) so the event stream is identical to the offline
+// path. NOTE: the shell tool is named `bash` on real opencode (>=1.18.x), not
+// `shell` — map `command` for both so a shell step reads by its command line.
+export function parseOpencodeCloud(filePath) {
+    const content = safeReadSessionFile(filePath);
+    const lines = content.split('\n').filter(l => l.trim());
+    const events = [];
+    for (const line of lines) {
+        let raw;
+        try {
+            raw = JSON.parse(line);
+        }
+        catch {
+            /* malformed JSONL line, skip */
+            continue;
+        }
+        const partType = typeof raw.part_type === 'string' ? raw.part_type : '';
+        const timeMs = typeof raw.time_created === 'number'
+            ? raw.time_created
+            : parseInt(String(raw.time_created), 10);
+        const timestamp = Number.isFinite(timeMs)
+            ? new Date(timeMs).toISOString()
+            : new Date().toISOString();
+        // Todo snapshot: emit one `todo_write` tool_use so the shared enrichment
+        // (`extractTodoProgressFromEvents`) derives `todos` the same way it does for
+        // every other harness — the offline parser emits the identical event.
+        if (partType === 'todo') {
+            const todos = Array.isArray(raw.todos) ? raw.todos : [];
+            if (todos.length) {
+                events.push({
+                    type: 'tool_use',
+                    agent: 'opencode',
+                    timestamp,
+                    tool: 'todo_write',
+                    args: { todos },
+                });
+            }
+            continue;
+        }
+        let partData;
+        try {
+            partData = JSON.parse(typeof raw.part_data === 'string' ? raw.part_data : '');
+        }
+        catch {
+            /* malformed part data, skip */
+            continue;
+        }
+        switch (partType) {
+            case 'text': {
+                const text = (partData.text || '').trim();
+                if (text) {
+                    events.push({
+                        type: 'message',
+                        agent: 'opencode',
+                        timestamp,
+                        role: raw.role === 'user' ? 'user' : 'assistant',
+                        content: text,
+                    });
+                }
+                break;
+            }
+            case 'reasoning': {
+                const text = (partData.text || '').trim();
+                if (text) {
+                    events.push({
+                        type: 'thinking',
+                        agent: 'opencode',
+                        timestamp,
+                        content: text,
+                    });
+                }
+                break;
+            }
+            case 'tool': {
+                const toolName = partData.tool || 'unknown';
+                const state = partData.state || {};
+                const input = state.input || {};
+                const output = state.output || '';
+                const callId = typeof partData.callID === 'string' ? partData.callID : undefined;
+                events.push({
+                    type: 'tool_use',
+                    agent: 'opencode',
+                    timestamp,
+                    tool: toolName,
+                    callId,
+                    args: input,
+                    command: toolName === 'bash' || toolName === 'shell' ? input.command : undefined,
+                    path: input.filePath || input.path || undefined,
+                });
+                if (state.status === 'completed' || state.status === 'error') {
+                    const outputStr = typeof output === 'string' ? output : JSON.stringify(output);
+                    events.push({
+                        type: state.status === 'error' ? 'error' : 'tool_result',
+                        agent: 'opencode',
+                        timestamp,
+                        tool: toolName,
+                        callId,
+                        success: state.status === 'completed',
+                        output: outputStr,
+                    });
+                }
+                break;
+            }
+            // step-start / step-finish / patch / file never reach the JSONL (dropped
+            // at capture time) — nothing to handle here.
+        }
+    }
+    return events;
+}
+// ---------------------------------------------------------------------------
 // Rush parser
 //
 // Rush messages.jsonl format is flat: one JSON object per line with

package/dist/lib/session/recovery.d.ts

@@ -68,7 +68,15 @@ export declare function sessionMatchesAccount(session: Pick<SessionMeta, 'agent'
 export declare function inspectNativeResumeSession(session: SessionMeta, versionHome: string): NativeResumeInspection;
 /** Keep the native conversation where possible; replay remains a separate choice. */
 export declare function resolveSessionRecoveryFromCandidates(session: SessionMeta, candidates: RotateCandidate[], supportsNative?: (agent: AgentId, version?: string) => boolean, nativeInspection?: NativeResumeInspection, options?: SessionRecoverySelection): SessionRecoveryTarget;
-/** A mirror digest or live registry entry is not conversation content. */
+/**
+ * Whether recovery has conversation content to replay for this session: a
+ * non-empty transcript file, or archived content in the index for a row this
+ * device owns. A mirror digest or live registry entry is not conversation
+ * content. The picker consults this before spending a terminal tab on a pick
+ * that {@link assertRecoverableTranscript} would refuse one hop later.
+ */
+export declare function sessionTranscriptReadable(session: SessionMeta): boolean;
+/** Refuse recovery for a session with nothing to replay (PHNX-4080). */
 export declare function assertRecoverableTranscript(session: SessionMeta): void;
 /**
  * Resolve recovery for a durable session, reading the live account pool.

package/dist/lib/session/recovery.js

@@ -365,16 +365,26 @@ export function resolveSessionRecoveryFromCandidates(session, candidates, suppor
         reason: `${sourceReason(session, source, options.model ?? session.model)}; continuing with ${continueWith}`,
     };
 }
-/** A mirror digest or live registry entry is not conversation content. */
-export function assertRecoverableTranscript(session) {
+/**
+ * Whether recovery has conversation content to replay for this session: a
+ * non-empty transcript file, or archived content in the index for a row this
+ * device owns. A mirror digest or live registry entry is not conversation
+ * content. The picker consults this before spending a terminal tab on a pick
+ * that {@link assertRecoverableTranscript} would refuse one hop later.
+ */
+export function sessionTranscriptReadable(session) {
     const file = splitSessionFilePath(session.filePath).container;
     try {
         if (file && fs.statSync(file).isFile() && fs.statSync(file).size > 0
             && (session.agent !== 'opencode' || parseOpenCode(session.filePath).length > 0))
-            return;
+            return true;
     }
     catch { /* The canonical scan already tried to repair this path. */ }
-    if (!session.mirrorSyncedAt && !session.mirrorSource && readSessionContent(session.id)?.trim())
+    return !session.mirrorSyncedAt && !session.mirrorSource && Boolean(readSessionContent(session.id)?.trim());
+}
+/** Refuse recovery for a session with nothing to replay (PHNX-4080). */
+export function assertRecoverableTranscript(session) {
+    if (sessionTranscriptReadable(session))
         return;
     throw new SessionRecoveryError(`Session ${session.shortId} has no readable transcript after checking its account homes and index. ` +
         `No agent was started. Start a new conversation with: agents run ${session.agent}`);

package/dist/lib/session/tool-calls.d.ts

@@ -10,7 +10,7 @@ export declare const TOOL_CHANGED_MAX_CALLS = 10000;
 export declare const TOOL_INDEX_LIMIT_ORDINAL: number;
 export declare const TOOL_TEXT_PROCESSING_MAX_BYTES: number;
 export declare const TOOL_SHELL_PARSE_MAX_BYTES: number;
-export declare const TOOL_INDEX_VERSION = 8;
+export declare const TOOL_INDEX_VERSION = 9;
 export type ToolCallOutcome = 'ok' | 'error' | 'unknown';
 export interface IndexedToolCall {
     ordinal: number;

package/dist/lib/session/tool-calls.js

@@ -12,10 +12,12 @@ export const TOOL_CHANGED_MAX_CALLS = 10_000;
 export const TOOL_INDEX_LIMIT_ORDINAL = Number.MAX_SAFE_INTEGER;
 export const TOOL_TEXT_PROCESSING_MAX_BYTES = 64 * 1024;
 export const TOOL_SHELL_PARSE_MAX_BYTES = 64 * 1024;
-// Bumped to 8 for the per-call end timestamp (PHNX-3437): the extractor now
-// records when a call's result arrived, so a re-index re-derives it for rows
-// stored by an older extractor.
-export const TOOL_INDEX_VERSION = 8;
+// Bumped to 9 for Codex tool-outcome classification (PHNX-3761): Codex results
+// arrive as a string or input_text[] rather than an object, so every one used to
+// store as 'unknown' and error rates read 0%. A re-index re-derives outcome for
+// rows stored by an older extractor.
+// (8 added the per-call end timestamp, PHNX-3437.)
+export const TOOL_INDEX_VERSION = 9;
 const BASE64_BLOCK = /(?:[A-Za-z0-9+/]{256,}={0,2})/g;
 const SECRET_FIELD = /(?:token|secret|password|authorization|cookie|api[_-]?key|private[_-]?key)$/i;
 const KNOWN_SECRET_VALUES = knownSecretValuesFromEnv();
@@ -258,9 +260,37 @@ function structuredString(source, name) {
     const value = structuredField(source, name);
     return typeof value === 'string' ? value : undefined;
 }
+// Codex tool results arrive as a plain string or an array of {type:'input_text',
+// text} blocks (never a plain object), so the text lives across the blocks and
+// the only outcome signal is the leading "Script completed"/"Script failed"
+// marker the exec harness prefixes onto the first block.
+function textSegments(value) {
+    if (typeof value === 'string')
+        return [value];
+    if (Array.isArray(value)) {
+        return value
+            .map((block) => block && typeof block === 'object' && typeof block.text === 'string'
+            ? block.text
+            : '')
+            .filter((text) => text.length > 0);
+    }
+    return [];
+}
+function codexScriptOutcome(value) {
+    const lead = textSegments(value)[0]?.trimStart();
+    if (!lead)
+        return undefined;
+    if (lead.startsWith('Script failed'))
+        return 'error';
+    if (lead.startsWith('Script completed'))
+        return 'ok';
+    return undefined;
+}
 function resultText(value) {
     if (typeof value === 'string')
         return value;
+    if (Array.isArray(value))
+        return textSegments(value).join('\n');
     const object = resultObject(value);
     if (object) {
         for (const key of ['output', 'stdout', 'content', 'text', 'message']) {
@@ -280,9 +310,14 @@ export function structuredToolResult(value) {
     const structured = resultObject(value);
     const success = structuredField(structured, 'success');
     const isError = success === false || structuredField(structured, 'is_error') === true;
+    const outcome = isError
+        ? 'error'
+        : success === true
+            ? 'ok'
+            : codexScriptOutcome(value) ?? 'unknown';
     return {
         text: resultText(value),
-        outcome: isError ? 'error' : success === true ? 'ok' : 'unknown',
+        outcome,
         exitCode: structuredNumber(structured, 'exit_code'),
         statusCode: structuredNumber(structured, 'status_code'),
         errorCode: structuredString(structured, 'error_code'),

package/dist/lib/share/backend.d.ts

@@ -89,6 +89,29 @@ export declare function phoenixIdBaseForDeploy(opts?: {
     baseUrl?: string;
     domain?: string;
 }): string | undefined;
+/**
+ * Managed collaboration backend config to bind on a managed Worker deploy
+ * (PHNX-3835): `PRIX_ARTIFACT_COLLAB_BASE` (the Prix artifact-collaboration API
+ * base) and `ARTIFACT_COLLAB_SERVICE_TOKEN` (the service credential the Worker
+ * sends as `Authorization: Bearer`, NEVER surfaced to the browser). Both are read
+ * from the deploy environment.
+ *
+ * Deliberately dormant-by-default: the two secrets are applied ONLY when BOTH are
+ * present. Until the Prix API counterpart is live an operator leaves them unset,
+ * and the Worker fails `/__collab` closed (404) with the artifact page GET
+ * unaffected. A pure-BYO endpoint never gets them (it has no Phoenix identity).
+ * Unlike `phoenixIdBaseForDeploy` this never throws on absence — collaboration is
+ * additive, not required for a working managed deploy.
+ */
+export declare function collabConfigForDeploy(opts?: {
+    managed?: boolean;
+}, cfg?: {
+    baseUrl?: string;
+    domain?: string;
+}): {
+    collabBase?: string;
+    collabServiceToken?: string;
+};
 /**
  * Pick the principal via the shared selection policy. Signed-in AND no explicit
  * BYO override → managed; otherwise BYO.

package/dist/lib/share/backend.js

@@ -84,6 +84,30 @@ export function phoenixIdBaseForDeploy(opts = {}, cfg) {
     }
     return base;
 }
+/**
+ * Managed collaboration backend config to bind on a managed Worker deploy
+ * (PHNX-3835): `PRIX_ARTIFACT_COLLAB_BASE` (the Prix artifact-collaboration API
+ * base) and `ARTIFACT_COLLAB_SERVICE_TOKEN` (the service credential the Worker
+ * sends as `Authorization: Bearer`, NEVER surfaced to the browser). Both are read
+ * from the deploy environment.
+ *
+ * Deliberately dormant-by-default: the two secrets are applied ONLY when BOTH are
+ * present. Until the Prix API counterpart is live an operator leaves them unset,
+ * and the Worker fails `/__collab` closed (404) with the artifact page GET
+ * unaffected. A pure-BYO endpoint never gets them (it has no Phoenix identity).
+ * Unlike `phoenixIdBaseForDeploy` this never throws on absence — collaboration is
+ * additive, not required for a working managed deploy.
+ */
+export function collabConfigForDeploy(opts = {}, cfg) {
+    const managed = opts.managed === true || (cfg != null && isManagedShareEndpoint(cfg));
+    if (!managed)
+        return {};
+    const base = (process.env.PRIX_ARTIFACT_COLLAB_BASE || '').replace(/\/+$/, '').trim();
+    const token = (process.env.ARTIFACT_COLLAB_SERVICE_TOKEN || '').trim();
+    if (!base || !token)
+        return {};
+    return { collabBase: base, collabServiceToken: token };
+}
 /**
  * The share surface's BYO-override signals: an explicit `--byo`, a
  * caller-supplied static write token, or `AGENTS_SHARE_BACKEND=byo`. Detecting

package/dist/lib/share/provision.d.ts

@@ -64,6 +64,10 @@ export interface UpdateWorkerResult {
 }
 /** Cloudflare `secret_text` name the Worker reads as `env.PHOENIX_ID_BASE`. */
 export declare const WORKER_PHOENIX_ID_BASE_SECRET = "PHOENIX_ID_BASE";
+/** Cloudflare `secret_text` name the Worker reads as `env.PRIX_ARTIFACT_COLLAB_BASE`. */
+export declare const WORKER_COLLAB_BASE_SECRET = "PRIX_ARTIFACT_COLLAB_BASE";
+/** Cloudflare `secret_text` name the Worker reads as `env.ARTIFACT_COLLAB_SERVICE_TOKEN`. */
+export declare const WORKER_COLLAB_SERVICE_TOKEN_SECRET = "ARTIFACT_COLLAB_SERVICE_TOKEN";
 export type UpdateWorkerOpts = ProvisionOptions & {
     force?: boolean;
     /**
@@ -73,6 +77,14 @@ export type UpdateWorkerOpts = ProvisionOptions & {
      * fails loud — do not pass a blank to "skip".
      */
     phoenixIdBase?: string;
+    /**
+     * Managed collaboration backend (PHNX-3835). BOTH must be present to enable
+     * `/__collab`; pass neither to leave the surface disabled (the Worker fails it
+     * closed). The service token rides Cloudflare's Secrets API, never rendered
+     * HTML or browser JS. Applied like `phoenixIdBase` — only when defined.
+     */
+    collabBase?: string;
+    collabServiceToken?: string;
 };
 /**
  * Re-deploy the Worker script against an ALREADY-provisioned endpoint (same

package/dist/lib/share/provision.js

@@ -107,6 +107,10 @@ export function hashWorkerScript(script) {
 }
 /** Cloudflare `secret_text` name the Worker reads as `env.PHOENIX_ID_BASE`. */
 export const WORKER_PHOENIX_ID_BASE_SECRET = 'PHOENIX_ID_BASE';
+/** Cloudflare `secret_text` name the Worker reads as `env.PRIX_ARTIFACT_COLLAB_BASE`. */
+export const WORKER_COLLAB_BASE_SECRET = 'PRIX_ARTIFACT_COLLAB_BASE';
+/** Cloudflare `secret_text` name the Worker reads as `env.ARTIFACT_COLLAB_SERVICE_TOKEN`. */
+export const WORKER_COLLAB_SERVICE_TOKEN_SECRET = 'ARTIFACT_COLLAB_SERVICE_TOKEN';
 /**
  * Re-deploy the Worker script against an ALREADY-provisioned endpoint (same
  * account/worker/bucket `deployWorker` was first called with) and idempotently
@@ -145,6 +149,7 @@ export async function updateWorker(apiToken, accountId, workerName, bucketName,
         if (opts.phoenixIdBase !== undefined) {
             await applyPhoenixIdBaseSecret(apiToken, accountId, workerName, opts.phoenixIdBase, opts);
         }
+        await applyCollabSecrets(apiToken, accountId, workerName, opts);
         return { templateHash, skipped: true };
     }
     await deployWorker(apiToken, accountId, workerName, worker, bucketName, opts);
@@ -168,8 +173,33 @@ export async function updateWorker(apiToken, accountId, workerName, bucketName,
             throw new Error(`Worker deployed but PHOENIX_ID_BASE failed to re-apply — Phoenix-bearer publishes will 401 until you re-run \`agents artifacts share update\`. (${detail})`);
         }
     }
+    // The script upload wiped bindings/secrets (see JSDoc above), so re-apply the
+    // collaboration secrets too — but only when the caller provided them. An
+    // ordinary deploy with collaboration still dormant passes neither and the
+    // Worker keeps failing `/__collab` closed.
+    try {
+        await applyCollabSecrets(apiToken, accountId, workerName, opts);
+    }
+    catch (e) {
+        const detail = e instanceof Error ? e.message : String(e);
+        throw new Error(`Worker deployed but the collaboration secrets failed to re-apply — \`/__collab\` stays disabled until you re-run \`agents artifacts share update\`. (${detail})`);
+    }
     return { templateHash, skipped: false };
 }
+/**
+ * Bind the managed collaboration secrets (PHNX-3835) — both or neither. A no-op
+ * when the caller passed neither (collaboration dormant), so a plain managed
+ * deploy never touches them; fails loud on a half-config (one without the other).
+ */
+async function applyCollabSecrets(apiToken, accountId, workerName, opts) {
+    if (opts.collabBase === undefined && opts.collabServiceToken === undefined)
+        return;
+    if (opts.collabBase === undefined || opts.collabServiceToken === undefined) {
+        throw new Error('Managed collaboration needs BOTH PRIX_ARTIFACT_COLLAB_BASE and ARTIFACT_COLLAB_SERVICE_TOKEN — set both or neither.');
+    }
+    await putWorkerSecret(apiToken, accountId, workerName, WORKER_COLLAB_BASE_SECRET, opts.collabBase, opts);
+    await putWorkerSecret(apiToken, accountId, workerName, WORKER_COLLAB_SERVICE_TOKEN_SECRET, opts.collabServiceToken, opts);
+}
 /** Add/update a secret_text binding using Cloudflare's Workers Secrets API. */
 export async function putWorkerSecret(apiToken, accountId, workerName, name, text, opts = {}) {
     const request = opts.request ?? defaultCloudflareRequester;