doer-agent 0.9.10 → 0.9.12

package/dist/agent-codex-app-rpc.js

@@ -190,20 +190,27 @@ async function handleCodexAppRpcMessage(args) {
 }
 export function subscribeToCodexAppRpc(args) {
     const handoffJobs = new CodexThreadHandoffJobManager(async (input, onProgress) => {
-        try {
-            const result = await createCodexThreadHandoff({
-                manager: args.manager,
-                ...input,
-                onProgress,
-                onLog: args.onInfo,
-            });
-            args.onInfo(`thread handoff completed sourceThreadId=${input.sourceThreadId} targetThreadId=${result.threadId}`);
-            return result;
-        }
-        catch (error) {
-            args.onError(`thread handoff failed sourceThreadId=${input.sourceThreadId} error=${error instanceof Error ? error.message : String(error)}`);
-            throw error;
-        }
+        return await createCodexThreadHandoff({
+            manager: args.manager,
+            ...input,
+            onProgress,
+            onLog: args.onInfo,
+        });
+    }, {
+        onStatus: (job) => {
+            const elapsedMs = Math.max(0, Date.parse(job.updatedAt) - Date.parse(job.createdAt));
+            const target = job.result?.threadId ? ` targetThreadId=${job.result.threadId}` : "";
+            const error = job.error
+                ? ` error=${JSON.stringify(job.error.replace(/\s+/g, " ").slice(0, 500))}`
+                : "";
+            const message = `thread handoff job status jobId=${job.jobId} sourceThreadId=${job.sourceThreadId} phase=${job.phase} elapsedMs=${elapsedMs}${target}${error}`;
+            if (job.phase === "failed") {
+                args.onError(message);
+            }
+            else {
+                args.onInfo(message);
+            }
+        },
     });
     args.nc.closed().finally(() => {
         void args.manager.stop().catch(() => undefined);

package/dist/codex-text-task.js

@@ -37,14 +37,17 @@ function buildCodexUserInput(prompt) {
         }];
 }
 export async function runCodexTextTask(args) {
+    const startedAt = Date.now();
     let threadId = "";
     let turnId = "";
     let output = "";
+    let outputStarted = false;
     let settled = false;
     let cleanupNotification = () => { };
     let settle = (_callback) => { };
     const completed = new Promise((resolve, reject) => {
         const timeout = setTimeout(() => {
+            args.onLog?.(`codex text task status phase=timed_out threadId=${threadId || "pending"} turnId=${turnId || "pending"} elapsedMs=${Date.now() - startedAt} outputChars=${output.length}`);
             settle(() => reject(new Error("Timed out while waiting for Codex text task")));
         }, args.timeoutMs ?? DEFAULT_TIMEOUT_MS);
         settle = (callback) => {
@@ -69,11 +72,16 @@ export async function runCodexTextTask(args) {
             if (method === "item/agentMessage/delta") {
                 const record = recordValue(params);
                 output += stringValue(record?.delta) || stringValue(record?.text);
+                if (!outputStarted && output) {
+                    outputStarted = true;
+                    args.onLog?.(`codex text task status phase=responding threadId=${threadId} turnId=${turnId || eventTurnId || "pending"} elapsedMs=${Date.now() - startedAt}`);
+                }
                 return;
             }
             if (!isTerminalTurnMethod(method)) {
                 return;
             }
+            args.onLog?.(`codex text task status phase=terminal_notification method=${method} threadId=${threadId} turnId=${turnId || eventTurnId || "pending"} elapsedMs=${Date.now() - startedAt} outputChars=${output.length}`);
             if (method === "turn/completed") {
                 settle(resolve);
                 return;
@@ -92,6 +100,7 @@ export async function runCodexTextTask(args) {
         if (!threadId) {
             throw new Error("Codex app-server did not return a text task thread id");
         }
+        args.onLog?.(`codex text task status phase=thread_started threadId=${threadId} elapsedMs=${Date.now() - startedAt}`);
         const turnResult = recordValue(await args.manager.request("turn/start", {
             threadId,
             input: buildCodexUserInput(args.prompt),
@@ -100,16 +109,25 @@ export async function runCodexTextTask(args) {
         if (!turnId) {
             throw new Error("Codex app-server did not return a text task turn id");
         }
+        args.onLog?.(`codex text task status phase=turn_started threadId=${threadId} turnId=${turnId} elapsedMs=${Date.now() - startedAt}`);
         await completed.finally(() => cleanupNotification());
+        args.onLog?.(`codex text task status phase=completed threadId=${threadId} turnId=${turnId} elapsedMs=${Date.now() - startedAt} outputChars=${output.length}`);
         return output;
     }
     catch (error) {
         settle(() => { });
+        args.onLog?.(`codex text task status phase=failed threadId=${threadId || "pending"} turnId=${turnId || "pending"} elapsedMs=${Date.now() - startedAt} error=${JSON.stringify((error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").slice(0, 500))}`);
         throw error;
     }
     finally {
         if (threadId) {
-            await args.manager.request("thread/unsubscribe", { threadId }, 30_000).catch(() => undefined);
+            await args.manager.request("thread/unsubscribe", { threadId }, 30_000)
+                .then(() => {
+                args.onLog?.(`codex text task status phase=unsubscribed threadId=${threadId} turnId=${turnId || "pending"} elapsedMs=${Date.now() - startedAt}`);
+            })
+                .catch((error) => {
+                args.onLog?.(`codex text task status phase=unsubscribe_failed threadId=${threadId} turnId=${turnId || "pending"} elapsedMs=${Date.now() - startedAt} error=${JSON.stringify((error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").slice(0, 500))}`);
+            });
         }
     }
 }

package/dist/codex-thread-handoff-jobs.js

@@ -8,14 +8,16 @@ function copySnapshot(job) {
 }
 export class CodexThreadHandoffJobManager {
     run;
-    terminalTtlMs;
-    maxJobs;
     jobs = new Map();
     activeJobBySourceThreadId = new Map();
-    constructor(run, terminalTtlMs = 30 * 60_000, maxJobs = 100) {
+    terminalTtlMs;
+    maxJobs;
+    onStatus;
+    constructor(run, options = {}) {
         this.run = run;
-        this.terminalTtlMs = terminalTtlMs;
-        this.maxJobs = maxJobs;
+        this.terminalTtlMs = options.terminalTtlMs ?? 30 * 60_000;
+        this.maxJobs = options.maxJobs ?? 100;
+        this.onStatus = options.onStatus;
     }
     start(input) {
         this.cleanup();
@@ -37,6 +39,7 @@ export class CodexThreadHandoffJobManager {
         };
         this.jobs.set(job.jobId, job);
         this.activeJobBySourceThreadId.set(input.sourceThreadId, job.jobId);
+        this.emitStatus(job);
         setImmediate(() => {
             void this.execute(job.jobId, input);
         });
@@ -55,6 +58,7 @@ export class CodexThreadHandoffJobManager {
             }
             current.phase = phase;
             current.updatedAt = new Date().toISOString();
+            this.emitStatus(current);
         };
         try {
             const result = await this.run(input, updatePhase);
@@ -63,6 +67,7 @@ export class CodexThreadHandoffJobManager {
                 current.phase = "completed";
                 current.result = result;
                 current.updatedAt = new Date().toISOString();
+                this.emitStatus(current);
             }
         }
         catch (error) {
@@ -71,6 +76,7 @@ export class CodexThreadHandoffJobManager {
                 current.phase = "failed";
                 current.error = error instanceof Error ? error.message : String(error);
                 current.updatedAt = new Date().toISOString();
+                this.emitStatus(current);
             }
         }
         finally {
@@ -79,6 +85,9 @@ export class CodexThreadHandoffJobManager {
             }
         }
     }
+    emitStatus(job) {
+        this.onStatus?.(copySnapshot(job));
+    }
     cleanup() {
         const cutoff = Date.now() - this.terminalTtlMs;
         for (const [jobId, job] of this.jobs) {

package/dist/codex-thread-handoff-jobs.test.js

@@ -17,11 +17,14 @@ async function nextTick() {
 }
 test("starts handoff work asynchronously and reports progress", async () => {
     let finish;
+    const statuses = [];
     const manager = new CodexThreadHandoffJobManager(async (input, onProgress) => {
         onProgress("collecting");
         return await new Promise((resolve) => {
             finish = resolve;
         });
+    }, {
+        onStatus: (job) => statuses.push(job.phase),
     });
     const started = manager.start({ sourceThreadId: "source-thread" });
     assert.equal(started.job.phase, "queued");
@@ -33,6 +36,7 @@ test("starts handoff work asynchronously and reports progress", async () => {
     const completed = manager.get(started.job.jobId);
     assert.equal(completed?.phase, "completed");
     assert.equal(completed?.result?.threadId, "target-thread");
+    assert.deepEqual(statuses, ["queued", "collecting", "completed"]);
 });
 test("deduplicates active jobs for the same source thread", () => {
     const manager = new CodexThreadHandoffJobManager(async () => {
@@ -44,8 +48,11 @@ test("deduplicates active jobs for the same source thread", () => {
     assert.equal(second.job.jobId, first.job.jobId);
 });
 test("keeps a failed job status for polling", async () => {
+    const statuses = [];
     const manager = new CodexThreadHandoffJobManager(async () => {
         throw new Error("summary failed");
+    }, {
+        onStatus: (job) => statuses.push({ phase: job.phase, error: job.error }),
     });
     const started = manager.start({ sourceThreadId: "source-thread" });
     await nextTick();
@@ -53,4 +60,8 @@ test("keeps a failed job status for polling", async () => {
     const failed = manager.get(started.job.jobId);
     assert.equal(failed?.phase, "failed");
     assert.equal(failed?.error, "summary failed");
+    assert.deepEqual(statuses, [
+        { phase: "queued", error: undefined },
+        { phase: "failed", error: "summary failed" },
+    ]);
 });

package/dist/codex-thread-handoff.js

@@ -6,6 +6,50 @@ const MAX_ITEM_TEXT_CHARS = 4_000;
 const MAX_TURN_TEXT_CHARS = 8_000;
 const MAX_TRANSCRIPT_CHARS = 160_000;
 const MAX_HANDOFF_CHARS = 20_000;
+const HANDOFF_USER_MARKER = "Continue from the handoff summary above and wait for my next request.";
+export function buildThreadHandoffInjectionItems(handoff) {
+    return [
+        {
+            type: "message",
+            role: "assistant",
+            content: [{
+                    type: "output_text",
+                    text: handoff,
+                }],
+        },
+    ];
+}
+export function buildThreadHandoffSeedInput() {
+    return [{
+            type: "text",
+            text: HANDOFF_USER_MARKER,
+        }];
+}
+async function waitForThreadTurnStarted(manager, threadId, timeoutMs = 1_000) {
+    await new Promise((resolve) => {
+        let settled = false;
+        let cleanup = () => { };
+        const finish = () => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            cleanup();
+            resolve();
+        };
+        const timer = setTimeout(finish, timeoutMs);
+        cleanup = manager.onNotification((method, params) => {
+            if (method !== "turn/started") {
+                return;
+            }
+            const event = recordValue(params);
+            if (stringValue(event?.threadId) === threadId) {
+                finish();
+            }
+        });
+    });
+}
 function recordValue(value) {
     return value && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -319,6 +363,7 @@ export async function createCodexThreadHandoff(args) {
             turnsCollected: collected.turnCount,
             turnsOmitted,
         }),
+        onLog: args.onLog,
     });
     const handoff = boundedText(handoffRaw, MAX_HANDOFF_CHARS);
     if (!handoff) {
@@ -338,16 +383,26 @@ export async function createCodexThreadHandoff(args) {
     }
     try {
         args.onProgress?.("injecting");
+        // Raw injected items do not make a new thread discoverable through thread/list.
+        const seedStarted = waitForThreadTurnStarted(args.manager, threadId);
+        const seedResult = recordValue(await args.manager.request("turn/start", {
+            threadId,
+            input: buildThreadHandoffSeedInput(),
+        }, 30_000));
+        const seedTurnId = stringValue(recordValue(seedResult?.turn)?.id);
+        if (!seedTurnId) {
+            throw new Error("Codex app-server did not return a handoff seed turn");
+        }
+        await seedStarted;
+        await args.manager.request("turn/interrupt", {
+            threadId,
+            turnId: seedTurnId,
+        }, 30_000).catch((error) => {
+            warnings.push(`Could not interrupt handoff seed turn: ${error instanceof Error ? error.message : String(error)}`);
+        });
         await args.manager.request("thread/inject_items", {
             threadId,
-            items: [{
-                    type: "message",
-                    role: "assistant",
-                    content: [{
-                            type: "output_text",
-                            text: handoff,
-                        }],
-                }],
+            items: buildThreadHandoffInjectionItems(handoff),
         }, 90_000);
     }
     catch (error) {

package/dist/codex-thread-handoff.test.js

@@ -1,6 +1,24 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { buildBoundedHandoffTranscript, summarizeThreadTurn, } from "./codex-thread-handoff.js";
+import { buildBoundedHandoffTranscript, buildThreadHandoffInjectionItems, buildThreadHandoffSeedInput, summarizeThreadTurn, } from "./codex-thread-handoff.js";
+test("buildThreadHandoffInjectionItems adds the summary to model-visible history", () => {
+    assert.deepEqual(buildThreadHandoffInjectionItems("# Thread handoff\n\nContinue the work."), [
+        {
+            type: "message",
+            role: "assistant",
+            content: [{
+                    type: "output_text",
+                    text: "# Thread handoff\n\nContinue the work.",
+                }],
+        },
+    ]);
+});
+test("buildThreadHandoffSeedInput creates a real user turn for thread indexing", () => {
+    assert.deepEqual(buildThreadHandoffSeedInput(), [{
+            type: "text",
+            text: "Continue from the handoff summary above and wait for my next request.",
+        }]);
+});
 test("summarizeThreadTurn omits raw command output, diffs, images, and MCP results", () => {
     const summary = summarizeThreadTurn({
         id: "turn-1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doer-agent",
-  "version": "0.9.10",
+  "version": "0.9.12",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",