doer-agent 0.9.10 → 0.9.11

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

@@ -319,6 +319,7 @@ export async function createCodexThreadHandoff(args) {
             turnsCollected: collected.turnCount,
             turnsOmitted,
         }),
+        onLog: args.onLog,
     });
     const handoff = boundedText(handoffRaw, MAX_HANDOFF_CHARS);
     if (!handoff) {

package/package.json

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