@gkorepanov/ccodex 0.4.20 → 0.4.24

package/dist/claude/session/session.js

@@ -1,7 +1,8 @@
 import { v7 as uuidv7 } from "uuid";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { startedTurn } from "../../protocol/turnPagination.js";
 import { MetricsRegistry } from "../../observability/metrics.js";
-import { invalidParams, RpcError } from "../../protocol/errors.js";
+import { invalidParams, invalidRequest, RpcError } from "../../protocol/errors.js";
 import { classifyClaudeResult, classifyClaudeRuntimeError, } from "../resultClassifier.js";
 import { runtimeWorkspaceRoots, settingsGeneration, withSettingsFrom } from "../../store/HybridStore.js";
 import { addUsage } from "./usage.js";
@@ -21,7 +22,7 @@ import { stat } from "node:fs/promises";
 import { readBackgroundOutput } from "./backgroundOutput.js";
 import { CODEX_MCP_MESSAGE_LABEL, CODEX_MCP_PROMPT_LABEL, CODEX_MCP_REASONING_LABEL, CODEX_MCP_TOOLS, defaultCodexRolloutLocator, parseRolloutChunk, } from "./codexRollout.js";
 import { createGoalMcpServer } from "../goalTools.js";
-import { mapUserInput } from "../inputMapper.js";
+import { mapUserInput, normalizeUserInput } from "../inputMapper.js";
 import { bashCommandActions } from "../commandActions.js";
 import { safeSessionPermissionUpdates } from "./permissionUpdates.js";
 import { threadSettings } from "../threadSettings.js";
@@ -84,6 +85,8 @@ function childProjectionIds(turns) {
         return [];
     })));
 }
+/** Stock app-server caps the per-thread submission queue at 100 entries. */
+const MAX_QUEUED_SUBMISSIONS = 100;
 function commandLane(command) {
     if (command.type === "runtimeLineage"
         || command.type === "completeSynthetic" || command.type === "resolveInteraction"
@@ -670,7 +673,7 @@ export class ClaudeSession {
                 runtimeGeneration: startup.runtimeGeneration,
                 fact: { type: "sync" },
                 source: { providerEventId: null, providerEventType: null },
-            });
+            }).catch(() => undefined);
             return candidate;
         }
         catch (error) {
@@ -1214,13 +1217,23 @@ export class ClaudeSession {
                 });
             }
             if (failure) {
+                this.runtimeDependencies?.logger.error("claude.provider.projection-failed", {
+                    threadId: this.threadId, providerEventType: fact.providerEventType, error: failure,
+                });
                 await this.submitProviderProjection(fact.runtimeGeneration, {
-                    type: "runtimeExited",
+                    type: "runtimeFailed",
                     runtimeGeneration: fact.runtimeGeneration,
                     message: `Claude provider projection failed: ${failure}`,
                     codexErrorInfo: null,
                 });
                 runtime.beginClose();
+                // Retire outside the provider consumer: close() drains that same
+                // consumer, so awaiting it here would deadlock.
+                void this.retireRuntime(`Claude provider projection failed: ${failure}`).catch((error) => {
+                    this.runtimeDependencies?.logger.error("claude.runtime.retirement-failed", {
+                        threadId: this.threadId, error: String(error),
+                    });
+                });
             }
         });
     }
@@ -1452,7 +1465,7 @@ export class ClaudeSession {
                             type: "runtimeLineage",
                             action: "catalogInvalidated",
                             runtimeGeneration,
-                        });
+                        }).catch(() => undefined);
                     }
                 }
                 await this.submitProviderProjection(runtimeGeneration, {
@@ -1530,7 +1543,7 @@ export class ClaudeSession {
                     type: "runtimeLineage",
                     action: "catalogInvalidated",
                     runtimeGeneration,
-                });
+                }).catch(() => undefined);
             }
             if (result.status === "completed" && message.subtype === "success") {
                 if (message.structured_output !== undefined) {
@@ -1582,7 +1595,7 @@ export class ClaudeSession {
                     action: "authFailure",
                     runtimeGeneration,
                     reason: message.error,
-                });
+                }).catch(() => undefined);
                 await this.providerSystemMessage(projection, runtimeGeneration, `Claude authentication failed: ${message.error}`, "error");
             }
             else if (message.output.length > 0) {
@@ -1902,6 +1915,7 @@ export class ClaudeSession {
             method = "item/commandExecution/requestApproval";
             params = {
                 ...common,
+                kind: "command",
                 environmentId: null,
                 reason: options.decisionReason ?? options.description ?? null,
                 command: typeof input.command === "string" ? input.command : null,
@@ -3437,6 +3451,8 @@ export class ClaudeSession {
                         + `retry the ${this.adminOperation.kind} request after cleanup completes.`);
                 }
                 return dispatchGoal(this.goal, this.goalContext(), command.command);
+            case "queue":
+                return this.handleQueue(command.command);
             case "runtimeDetached": {
                 const detached = this.runtimeGeneration === command.runtimeGeneration;
                 if (detached && command.requireQuiescent && !this.isQuiescent()) {
@@ -3572,7 +3588,7 @@ export class ClaudeSession {
                     type: "userMessage",
                     id: command.review ? turnId : uuidv7(),
                     clientId: command.params.clientUserMessageId ?? null,
-                    content: command.params.input,
+                    content: normalizeUserInput(command.params.input),
                 };
                 const reviewItem = command.review
                     ? { type: "enteredReviewMode", id: uuidv7(), review: command.review }
@@ -3781,7 +3797,9 @@ export class ClaudeSession {
                         ...record,
                         thread: {
                             ...record.thread,
-                            status: { type: command.type === "runtimeFailed" ? "systemError" : "notLoaded" },
+                            status: { type: command.type === "runtimeFailed" ? "systemError"
+                                    : record.thread.ephemeral && record.thread.threadSource === "user" && !record.thread.parentThreadId
+                                        ? "idle" : "notLoaded" },
                             updatedAt: Math.floor(Date.now() / 1_000),
                         },
                     };
@@ -4077,7 +4095,7 @@ export class ClaudeSession {
                     type: "userMessage",
                     id: uuidv7(),
                     clientId: command.clientUserMessageId ?? null,
-                    content: command.input,
+                    content: normalizeUserInput(command.input),
                 };
                 turn.items.push(item);
                 this.publishTurn(turn, "item/started", {
@@ -4449,7 +4467,7 @@ export class ClaudeSession {
                         type: "cancelInteraction",
                         runtimeGeneration: command.runtimeGeneration,
                         requestId: command.requestId,
-                    });
+                    }).catch(() => undefined);
                 };
                 if (command.signal?.aborted)
                     queueMicrotask(cancel);
@@ -4489,7 +4507,7 @@ export class ClaudeSession {
             case "threadAdmin":
                 return this.dispatchThreadAdmin(command.command);
             case "runShell":
-                return this.runShell(command.command);
+                return this.runShell(command.command, command.timeoutMs);
             case "startShell":
                 return this.startShell(command.command);
             case "admitShellEffect":
@@ -4670,10 +4688,12 @@ export class ClaudeSession {
         this.emitLifecycle();
         return { operationId, turnId: turn.id, cwd: record.thread.cwd };
     }
-    runShell(command) {
+    runShell(command, timeoutMs) {
         const started = this.startShell(command);
         const shell = this.shell;
         let processHandle;
+        let timer;
+        let timedOut = false;
         try {
             processHandle = this.shellRunner.launch(started.cwd, command, {
                 ready: () => {
@@ -4682,7 +4702,8 @@ export class ClaudeSession {
                         operationId: started.operationId,
                     }).then((admitted) => {
                         if (!admitted)
-                            processHandle.kill();
+                            return processHandle.kill();
+                        timer = setTimeout(() => { timedOut = true; processHandle.kill(); }, timeoutMs);
                     }, () => processHandle.kill());
                 },
                 output: (bytes) => {
@@ -4693,11 +4714,13 @@ export class ClaudeSession {
                     }).catch(() => undefined);
                 },
                 terminal: (exitCode, errorMessage) => {
+                    clearTimeout(timer);
+                    const message = errorMessage ?? (timedOut ? `command timed out after ${timeoutMs}ms` : undefined);
                     void this.submit({
                         type: "finishShell",
                         operationId: started.operationId,
                         exitCode,
-                        ...(errorMessage ? { errorMessage } : {}),
+                        ...(message ? { errorMessage: message } : {}),
                     }).catch(() => shell.resolve());
                 },
             });
@@ -4762,7 +4785,7 @@ export class ClaudeSession {
             items: active.items.map((candidate) => candidate.id === item.id ? updatedItem : candidate),
         }, status, errorMessage ?? (status === "failed" ? `Shell command exited with code ${exitCode}.` : undefined), null);
         this.shell = undefined;
-        this.finishTurn(turn, nullSource, false, [{
+        const completed = this.finishTurn(turn, nullSource, false, [{
                 turnId: turn.id,
                 method: "item/completed",
                 params: {
@@ -4772,7 +4795,7 @@ export class ClaudeSession {
                     completedAtMs: Date.now(),
                 },
             }]);
-        this.emitLifecycle();
+        this.emitLifecycle(completed);
         shell.resolve();
         return true;
     }
@@ -4840,7 +4863,7 @@ export class ClaudeSession {
             items: active.items.map((candidate) => candidate.id === item.id ? updatedItem : candidate),
         }, "interrupted", undefined, null);
         this.shell = undefined;
-        this.finishTurn(turn, nullSource, false, [{
+        const completed = this.finishTurn(turn, nullSource, false, [{
                 turnId: turn.id,
                 method: "item/completed",
                 params: {
@@ -4850,7 +4873,7 @@ export class ClaudeSession {
                     completedAtMs: Date.now(),
                 },
             }]);
-        this.emitLifecycle();
+        this.emitLifecycle(completed);
         shell.resolve();
         return true;
     }
@@ -5015,7 +5038,7 @@ export class ClaudeSession {
         const active = this.repository.readTurn(this.threadId, operation.turnId);
         const item = active.items[0];
         const turn = this.terminalTurn(active, status, errorMessage, codexErrorInfo);
-        this.finishTurn(turn, source, true, [
+        const completed = this.finishTurn(turn, source, true, [
             {
                 turnId: turn.id,
                 method: "item/completed",
@@ -5041,7 +5064,7 @@ export class ClaudeSession {
                 operation.hidden.completion.reject(new Error(errorMessage ?? `Claude compaction ${status}.`));
             }
         }
-        this.emitLifecycle();
+        this.emitLifecycle(operation.hidden ? undefined : completed, Boolean(operation.hidden));
         return { turnId: turn.id, terminal: true, ...(operation.hidden ? { hidden: true } : {}) };
     }
     compactionProjection(terminal = false, cancelOperationId, transportAction) {
@@ -5141,7 +5164,7 @@ export class ClaudeSession {
                 delivery: null,
                 text: systemNoticeText(`Gateway restarted while the CCodex ${state ? "state" : "status"} request was active.`, "error"),
                 phase: "final_answer",
-                memoryCitation: null,
+                memoryCitation: null, questions: null,
             });
         }
         if (items.some((item) => item.type === "enteredReviewMode")
@@ -5162,7 +5185,7 @@ export class ClaudeSession {
             error: {
                 message: "Gateway restarted while the Claude turn was active.",
                 codexErrorInfo: { responseStreamDisconnected: { httpStatusCode: null } },
-                additionalDetails: null,
+                additionalDetails: null, misalignment: null,
             },
         };
     }
@@ -5194,7 +5217,7 @@ export class ClaudeSession {
         if (this.announcedTurns.has(turn.id))
             return;
         this.announcedTurns.add(turn.id);
-        this.publish(turn.id, "turn/started", { threadId: this.threadId, turn }, `turn/started:${turn.id}`);
+        this.publish(turn.id, "turn/started", { threadId: this.threadId, turn: startedTurn(turn) }, `turn/started:${turn.id}`);
         for (const item of turn.items) {
             this.publish(turn.id, "item/started", {
                 item, threadId: this.threadId, turnId: turn.id, startedAtMs: Date.now(),
@@ -5211,7 +5234,7 @@ export class ClaudeSession {
             ...active, status, completedAt,
             durationMs: Math.max(0, (completedAt - (active.startedAt ?? completedAt)) * 1_000),
             error: status === "failed"
-                ? { message: errorMessage ?? "Claude turn failed.", codexErrorInfo, additionalDetails: null }
+                ? { message: errorMessage ?? "Claude turn failed.", codexErrorInfo, additionalDetails: null, misalignment: null }
                 : null,
         };
     }
@@ -5359,26 +5382,21 @@ export class ClaudeSession {
         }
         else if (fact.type === "taskNotification" && active) {
             active.notifications += 1;
-            if (active.request && !active.request.started)
-                active.request.covers = active.notifications;
             if (active.result && (!active.commandObserved || active.commandCompleted))
                 this.scheduleContinuation(true);
         }
         else if (fact.type === "request" && active) {
-            if (!fact.messageStarted && active.request?.started
-                && active.notifications > active.request.covers) {
-                active.request = { covers: active.notifications, started: false };
-                this.cancelContinuation();
-            }
-            else if (!active.request && (this.hasNotifications() || active.result)) {
-                active.request = { covers: active.notifications, started: false };
+            if (!fact.messageStarted || !active.request) {
+                active.request = { covers: active.notifications, beforeFirstToken: active.notifications, started: false };
                 this.cancelContinuation();
             }
             if (fact.messageStarted) {
                 if (active.result && (this.hasNotifications() || active.goals > 0))
                     delete active.result;
-                if (active.request)
+                if (active.request && !active.request.started) {
+                    active.request.beforeFirstToken = active.notifications;
                     active.request.started = true;
+                }
                 active.goalInFlight = active.goals > 0;
                 this.cancelContinuation();
             }
@@ -5402,7 +5420,11 @@ export class ClaudeSession {
                 active.goalInFlight = false;
             }
             if (active.request) {
-                active.acknowledged = Math.max(active.acknowledged, active.request.covers);
+                // A human request cannot consume notifications that arrive while it is
+                // already in flight. A task-notification request may announce its own
+                // notification after requesting, but before its first streamed token.
+                const covers = fact.origin === "task-notification" ? active.request.beforeFirstToken : active.request.covers;
+                active.acknowledged = Math.max(active.acknowledged, covers);
                 delete active.request;
             }
             else if (fact.origin === "task-notification")
@@ -5496,10 +5518,7 @@ export class ClaudeSession {
         this.lifecycle = undefined;
         this.cancelContinuation();
         this.metrics.turnCompleted(active.result.status);
-        if (active.synthetic)
-            this.emitLifecycle(undefined, true);
-        else
-            this.emitLifecycle(completed);
+        this.emitLifecycle(completed, Boolean(active.synthetic));
     }
     hasNotifications() {
         return Boolean(this.lifecycle && this.lifecycle.notifications > this.lifecycle.acknowledged);
@@ -5707,6 +5726,81 @@ export class ClaudeSession {
                 }).catch(() => undefined);
         }
     }
+    handleQueue(command) {
+        const queue = this.repository.listQueue(this.threadId);
+        const changed = (items) => {
+            this.repository.setQueue(this.threadId, items);
+            this.output.emit(this.threadId, "thread/queue/changed", { threadId: this.threadId });
+        };
+        const find = (id) => {
+            const index = queue.findIndex((entry) => entry.id === id);
+            if (index < 0)
+                throw invalidRequest(`queued submission not found: ${id}`);
+            return index;
+        };
+        const validInput = (input) => {
+            if (input.length === 0)
+                throw invalidRequest("only user input can be added to the user-message queue");
+            return normalizeUserInput(input);
+        };
+        switch (command.kind) {
+            case "add": {
+                if (this.requireRecord(false).thread.ephemeral) {
+                    throw invalidRequest(`ephemeral thread does not support queued submissions: ${this.threadId}`);
+                }
+                if (queue.length >= MAX_QUEUED_SUBMISSIONS) {
+                    throw invalidRequest(`queue cannot contain more than ${MAX_QUEUED_SUBMISSIONS} submissions`);
+                }
+                const entry = {
+                    id: uuidv7(), input: validInput(command.input), clientUserMessageId: command.clientUserMessageId,
+                };
+                changed([...queue, entry]);
+                return entry;
+            }
+            case "update": {
+                const index = find(command.queuedSubmissionId);
+                const entry = { ...queue[index], input: validInput(command.input) };
+                changed(queue.with(index, entry));
+                return entry;
+            }
+            case "delete": {
+                const remaining = queue.filter((entry) => entry.id !== command.queuedSubmissionId);
+                if (remaining.length !== queue.length)
+                    changed(remaining);
+                return remaining.length !== queue.length;
+            }
+            case "reorder": {
+                const ids = new Set(command.queuedSubmissionIds);
+                if (ids.size !== command.queuedSubmissionIds.length || ids.size !== queue.length
+                    || !queue.every((entry) => ids.has(entry.id))) {
+                    throw invalidRequest("queue reorder must include every queued submission exactly once");
+                }
+                changed(command.queuedSubmissionIds.map((id) => queue[find(id)]));
+                return undefined;
+            }
+            case "take": {
+                const idle = this.isQuiescent() && this.goal.pendingTurns === 0;
+                let index = 0;
+                if (command.manual) {
+                    if (queue.length === 0)
+                        throw invalidRequest("queue is empty");
+                    index = command.queuedSubmissionId === undefined ? 0 : find(command.queuedSubmissionId);
+                    if (!idle)
+                        throw invalidRequest("thread already has an active or pending turn");
+                }
+                else if (queue.length === 0 || !idle
+                    || this.requireRecord(true).thread.turns.at(-1)?.status === "interrupted") {
+                    return undefined;
+                }
+                changed(queue.toSpliced(index, 1));
+                return queue[index];
+            }
+            case "restore": {
+                changed([command.entry, ...queue]);
+                return undefined;
+            }
+        }
+    }
     isQuiescent() {
         return !this.lifecycle && !this.compaction && !this.interruptFence && !this.transportStopFence
             && this.pendingNoQuery === 0 && this.pendingInputs === 0 && !this.hasOutputDrains()
@@ -5722,7 +5816,7 @@ export class ClaudeSession {
         const generation = this.lifecycle.notifications;
         this.continuationTimer = setTimeout(() => {
             void this.submit({ type: "lifecycle", runtimeGeneration: this.runtimeGeneration,
-                fact: { type: "timer", generation }, source: nullSource });
+                fact: { type: "timer", generation }, source: nullSource }).catch(() => undefined);
         }, 5_000);
         this.continuationTimer.unref();
     }
@@ -5783,6 +5877,24 @@ export class ClaudeSession {
         return waiter;
     }
     dispatchThreadAdmin(command) {
+        if (command.kind === "generatedName") {
+            const record = this.requireRecord(false);
+            if (record.thread.name || record.thread.ephemeral || this.adminOperation)
+                return;
+            const user = this.requireRecord(true).thread.turns[0]?.items.find((item) => item.type === "userMessage");
+            const text = user?.content.flatMap((input) => input.type === "text" ? [input.text] : []).join("\n").trim();
+            // iOS truncates the title worker's user prompt to 2,000 characters.
+            const prompt = command.userPrompt.trim();
+            if (!prompt || (text !== prompt && !(command.userPrompt.length >= 2_000 && text?.startsWith(prompt))))
+                return;
+            const updated = {
+                ...record,
+                thread: { ...record.thread, name: command.name, updatedAt: Math.floor(Date.now() / 1_000) },
+            };
+            const params = { threadId: this.threadId, threadName: command.name };
+            this.commitState(updated, [{ turnId: null, method: "thread/name/updated", params }]);
+            return;
+        }
         if (command.kind === "renameProjection") {
             const record = this.repository.read(command.threadId, false);
             if (!record?.thread.parentThreadId
@@ -6363,7 +6475,7 @@ export class ClaudeSession {
             id: uuidv7(),
             text: value,
             phase: null,
-            memoryCitation: null,
+            memoryCitation: null, questions: null,
             delivery: null,
         };
         const turn = {
@@ -6382,13 +6494,7 @@ export class ClaudeSession {
             lastCompletedTurnId: turn.id,
             thread: { ...record.thread, updatedAt: now, recencyAt: now },
         };
-        const started = {
-            ...turn,
-            items: [],
-            status: "inProgress",
-            completedAt: null,
-            durationMs: null,
-        };
+        const started = startedTurn({ ...turn, status: "inProgress", completedAt: null, durationMs: null });
         this.commitState(updated, [
             { turnId: turn.id, method: "turn/started", params: { threadId: this.threadId, turn: started } },
             {
@@ -6467,7 +6573,7 @@ export class ClaudeSession {
                     id: uuidv7(),
                     text: fact.text,
                     phase: null,
-                    memoryCitation: null,
+                    memoryCitation: null, questions: null,
                     delivery: null,
                 };
                 turn.items.push(item);
@@ -7093,7 +7199,7 @@ export class ClaudeSession {
         state.completedItems.add(item.id);
         this.scopes.set(childThreadId, state);
         this.publishAt(childThreadId, turn.id, "thread/started", { thread }, source);
-        this.publishAt(childThreadId, turn.id, "turn/started", { threadId: childThreadId, turn }, source);
+        this.publishAt(childThreadId, turn.id, "turn/started", { threadId: childThreadId, turn: startedTurn(turn) }, source);
         this.publishAt(childThreadId, turn.id, "item/started", { item, threadId: childThreadId, turnId: turn.id, startedAtMs: Date.now() }, source);
         this.publishAt(childThreadId, turn.id, "item/completed", { item, threadId: childThreadId, turnId: turn.id, completedAtMs: Date.now() }, source);
         return thread;
@@ -7133,7 +7239,7 @@ export class ClaudeSession {
         const state = newMainStreamState(childThreadId, turn.id, updated);
         state.completedItems.add(item.id);
         this.scopes.set(childThreadId, state);
-        this.publishAt(childThreadId, turn.id, "turn/started", { threadId: childThreadId, turn }, source);
+        this.publishAt(childThreadId, turn.id, "turn/started", { threadId: childThreadId, turn: startedTurn(turn) }, source);
         this.publishAt(childThreadId, turn.id, "item/started", {
             item, threadId: childThreadId, turnId: turn.id, startedAtMs: Date.now(),
         }, source);
@@ -7160,7 +7266,7 @@ export class ClaudeSession {
         turn.status = status === "completed" ? "completed" : status === "stopped" ? "interrupted" : "failed";
         turn.completedAt = completedAt;
         turn.durationMs = Math.max(0, (completedAt - (turn.startedAt ?? completedAt)) * 1_000);
-        turn.error = status === "failed" ? { message: summary, codexErrorInfo: null, additionalDetails: null } : null;
+        turn.error = status === "failed" ? { message: summary, codexErrorInfo: null, additionalDetails: null, misalignment: null } : null;
         const updated = { ...record, lastCompletedTurnId: turn.id,
             thread: { ...record.thread, status: { type: "idle" }, updatedAt: completedAt } };
         this.commitState(updated, [
@@ -7204,7 +7310,7 @@ export class ClaudeSession {
                     }
                 }
                 if (item.type === "agentMessage") {
-                    item.phase = completeAsCommentary ? "commentary" : null;
+                    item.phase = completeAsCommentary ? "commentary" : "final_answer";
                     if (completeAsCommentary) {
                         state.pendingAgentItemIds.delete(item.id);
                         this.completeStreamItem(turn, state, item.id, source);
@@ -7240,7 +7346,8 @@ export class ClaudeSession {
         state.blockItems.delete(index);
         if (block === "text") {
             const item = {
-                type: "agentMessage", id: uuidv7(), text: "", phase: null, memoryCitation: null, delivery: null,
+                // Stock never announces a phase-less message; stream as the answer and relabel to commentary if tools follow.
+                type: "agentMessage", id: uuidv7(), text: "", phase: "final_answer", memoryCitation: null, questions: null, delivery: null,
             };
             state.blockItems.set(index, item.id);
             turn.items.push(item);