@gkorepanov/ccodex 0.4.19 → 0.4.23

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"
@@ -1283,7 +1286,7 @@ export class ClaudeSession {
             return handled ? "projected" : "retainedOnly";
         }
         if (message.type === "system" && message.subtype === "task_started") {
-            if (message.skip_transcript)
+            if (message.skip_transcript || message.ambient)
                 return "stateOnly";
             const owner = await this.providerInteractionOwner(runtimeGeneration, message.tool_use_id, undefined);
             await this.applyProviderMainStream(projection, runtimeGeneration, {
@@ -1315,6 +1318,8 @@ export class ClaudeSession {
             return "projected";
         }
         if (message.type === "system" && message.subtype === "task_notification") {
+            if (message.skip_transcript || message.ambient)
+                return "stateOnly";
             const owner = await this.providerInteractionOwner(runtimeGeneration, message.tool_use_id ?? message.task_id, undefined);
             await this.applyProviderMainStream(projection, runtimeGeneration, {
                 kind: "taskStart",
@@ -1333,6 +1338,13 @@ export class ClaudeSession {
                 status: message.status,
                 summary: message.summary,
                 outputFile: message.output_file,
+                ...(message.resource_links?.length
+                    ? {
+                        resourceLinks: message.resource_links.map((link) => ({
+                            uri: link.uri, name: link.name, ...(link.title ? { title: link.title } : {}),
+                        })),
+                    }
+                    : {}),
                 ...(message.usage?.duration_ms === undefined
                     ? {}
                     : { durationMs: message.usage.duration_ms }),
@@ -1342,7 +1354,7 @@ export class ClaudeSession {
         if (message.type === "system" && message.subtype === "background_tasks_changed") {
             await this.applyProviderMainStream(projection, runtimeGeneration, {
                 kind: "taskMembership",
-                taskIds: message.tasks.map((task) => task.task_id),
+                taskIds: message.tasks.filter((task) => !task.ambient).map((task) => task.task_id),
             });
             return "stateOnly";
         }
@@ -1437,6 +1449,7 @@ export class ClaudeSession {
                     });
                     if (message.error === "authentication_failed"
                         || message.error === "oauth_org_not_allowed"
+                        || message.error === "account_on_hold"
                         || message.error === "model_not_found") {
                         void this.submitLineage({
                             type: "runtimeLineage",
@@ -1602,13 +1615,17 @@ export class ClaudeSession {
             if (message.retracted_message_uuids?.length) {
                 await this.providerEvictMessages(projection, runtimeGeneration, message.retracted_message_uuids);
             }
-            await this.submitProviderProjection(runtimeGeneration, {
-                type: "modelFallback",
-                runtimeGeneration,
-                model: message.fallback_model,
-                fromModel: message.original_model,
-                source,
-            });
+            // scope "local" means only one subagent/side-question response used the
+            // fallback; the session model is unchanged (absent scope means session).
+            if (message.scope !== "local") {
+                await this.submitProviderProjection(runtimeGeneration, {
+                    type: "modelFallback",
+                    runtimeGeneration,
+                    model: message.fallback_model,
+                    fromModel: message.original_model,
+                    source,
+                });
+            }
             await this.providerSystemMessage(projection, runtimeGeneration, message.content
                 || `Claude switched from ${message.original_model} to ${message.fallback_model} after a refusal.`);
             return "projected";
@@ -1888,6 +1905,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,
@@ -2008,6 +2026,8 @@ export class ClaudeSession {
                 itemId: options.toolUseID,
                 questions,
                 autoResolutionMs: null,
+                // The Claude callback blocks until the user answers.
+                isBlocking: true,
             },
         }, options.signal);
         if (!response || typeof response !== "object" || "cancelled" in response) {
@@ -3421,6 +3441,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()) {
@@ -3556,7 +3578,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 }
@@ -4061,7 +4083,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", {
@@ -4473,7 +4495,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":
@@ -4654,10 +4676,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: () => {
@@ -4666,7 +4690,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) => {
@@ -4677,11 +4702,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());
                 },
             });
@@ -4746,7 +4773,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: {
@@ -4756,7 +4783,7 @@ export class ClaudeSession {
                     completedAtMs: Date.now(),
                 },
             }]);
-        this.emitLifecycle();
+        this.emitLifecycle(completed);
         shell.resolve();
         return true;
     }
@@ -4824,7 +4851,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: {
@@ -4834,7 +4861,7 @@ export class ClaudeSession {
                     completedAtMs: Date.now(),
                 },
             }]);
-        this.emitLifecycle();
+        this.emitLifecycle(completed);
         shell.resolve();
         return true;
     }
@@ -4999,7 +5026,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",
@@ -5025,7 +5052,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) {
@@ -5122,9 +5149,10 @@ export class ClaudeSession {
             items.push({
                 type: "agentMessage",
                 id: uuidv7(),
+                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")
@@ -5145,7 +5173,7 @@ export class ClaudeSession {
             error: {
                 message: "Gateway restarted while the Claude turn was active.",
                 codexErrorInfo: { responseStreamDisconnected: { httpStatusCode: null } },
-                additionalDetails: null,
+                additionalDetails: null, misalignment: null,
             },
         };
     }
@@ -5177,7 +5205,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(),
@@ -5194,7 +5222,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,
         };
     }
@@ -5479,10 +5507,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);
@@ -5690,6 +5715,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()
@@ -5766,6 +5866,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
@@ -5926,8 +6044,8 @@ export class ClaudeSession {
                 throw invalidParams(`Claude thread '${this.threadId}' has an active ${this.adminOperation.kind} operation.`);
             }
             const record = this.requireRecord(false);
-            if (record.thread.ephemeral && command.isPinned !== undefined && command.isPinned !== null) {
-                throw invalidParams("Ephemeral Claude side chats cannot be pinned.");
+            if (record.thread.ephemeral && command.section !== undefined) {
+                throw invalidParams("Ephemeral Claude side chats cannot be sectioned.");
             }
             const previous = record.thread.gitInfo ?? { sha: null, branch: null, originUrl: null };
             const patch = command.gitInfo;
@@ -5941,7 +6059,10 @@ export class ClaudeSession {
                 thread: {
                     ...record.thread,
                     gitInfo,
-                    isPinned: command.isPinned ?? record.thread.isPinned,
+                    ...(command.section === undefined ? {} : {
+                        section: command.section,
+                        sectionEnteredAt: command.section ? Math.floor(Date.now() / 1_000) : null,
+                    }),
                     updatedAt: Math.floor(Date.now() / 1_000),
                 },
             };
@@ -6343,7 +6464,8 @@ export class ClaudeSession {
             id: uuidv7(),
             text: value,
             phase: null,
-            memoryCitation: null,
+            memoryCitation: null, questions: null,
+            delivery: null,
         };
         const turn = {
             id: uuidv7(),
@@ -6361,13 +6483,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 } },
             {
@@ -6446,7 +6562,8 @@ export class ClaudeSession {
                     id: uuidv7(),
                     text: fact.text,
                     phase: null,
-                    memoryCitation: null,
+                    memoryCitation: null, questions: null,
+                    delivery: null,
                 };
                 turn.items.push(item);
                 this.publishTurn(turn, "item/started", {
@@ -6876,7 +6993,11 @@ export class ClaudeSession {
                         ...(exit ? { exit_code: Number(exit) } : {}) }, source, false);
                 }
                 else if (item?.type === "mcpToolCall" && tool) {
-                    this.completeTool(ownerTurn, ownerState, tool, fact.summary, fact.status !== "completed", fact.durationMs === undefined ? undefined : { duration_ms: fact.durationMs }, source, false);
+                    const links = fact.resourceLinks?.length
+                        ? `${fact.summary ? "\n" : ""}${fact.resourceLinks
+                            .map((link) => `${link.title ?? link.name}: ${link.uri}`).join("\n")}`
+                        : "";
+                    this.completeTool(ownerTurn, ownerState, tool, `${fact.summary}${links}`, fact.status !== "completed", fact.durationMs === undefined ? undefined : { duration_ms: fact.durationMs }, source, false);
                 }
                 else if (item?.type === "collabAgentToolCall") {
                     item.status = fact.status === "completed" ? "completed" : "failed";
@@ -7067,7 +7188,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;
@@ -7107,7 +7228,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);
@@ -7134,7 +7255,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, [
@@ -7178,7 +7299,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);
@@ -7214,7 +7335,8 @@ export class ClaudeSession {
         state.blockItems.delete(index);
         if (block === "text") {
             const item = {
-                type: "agentMessage", id: uuidv7(), text: "", phase: null, memoryCitation: 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);