@tea-agent/loop-agent 0.40.0-next.4 → 0.40.0-next.5

package/dist/worker/console/chat/routes.js

@@ -17,7 +17,7 @@ import { OPERATOR_CHAT_ALLOWED_TOOLS, OPERATOR_CHAT_DENIED_TOOLS, OPERATOR_CHAT_
 import { buildModelCallableToolSchemas } from "./tool-adapter.js";
 import { cleanChatTitle, acceptedOperationIdFromResult } from "./session-store.js";
 import { hashChatTurnPayload, projectChatToolEventPayload, projectCompactSnapshot, } from "./chat-event-store.js";
-import { projectDeferredTurnSummary, } from "./deferred-turn.js";
+import { projectDeferredTurnSummary, projectDeferredTurnSummaries, } from "./deferred-turn.js";
 import { THINKING_LEVELS, RuntimeSnapshotUnavailableError, } from "./pi-runtime.js";
 import { ResourcePreferencesError, setSkillAutoInvocationPreference, } from "./resource-preferences-store.js";
 import { ComposerDraftStore } from "./composer-draft-store.js";
@@ -33,9 +33,11 @@ import { dispatchOperatorAction } from "../operator-actions.js";
 import { makeHumanGateCard, } from "./human-gate-card.js";
 import { ContractApplyReceiptStore } from "./contract-apply-receipt-store.js";
 import { projectTaskContext } from "./context-panel.js";
+import { deriveChatSessionTelemetry } from "./session-stats.js";
 import { contractApplyPayloadHash, issueHumanGateToken, verifyHumanGateToken, } from "../human-gate-token.js";
 import { sendJson } from "../routes.js";
 import { openSseResponse, writeSseEvent } from "../operation-sse.js";
+import { buildTodoCompactionInstructions, projectCurrentTodos } from "./todos.js";
 function turnSummary(turn) {
     return {
         turnId: turn.turnId,
@@ -87,11 +89,38 @@ function turnEventToStorePartial(event) {
         case "message_update":
         case "message_end": {
             const content = parseAssistantContent(event.content);
+            const timingSource = event.type === "message_end" &&
+                event.timing &&
+                typeof event.timing === "object"
+                ? event.timing
+                : undefined;
+            const timing = timingSource &&
+                typeof timingSource.llmMs === "number" &&
+                Number.isFinite(timingSource.llmMs)
+                ? {
+                    llmMs: Math.max(0, timingSource.llmMs),
+                    ...(typeof timingSource.ttftMs === "number" &&
+                        Number.isFinite(timingSource.ttftMs)
+                        ? { ttftMs: Math.max(0, timingSource.ttftMs) }
+                        : {}),
+                    ...(typeof timingSource.decodeMs === "number" &&
+                        Number.isFinite(timingSource.decodeMs)
+                        ? { decodeMs: Math.max(0, timingSource.decodeMs) }
+                        : {}),
+                    ...(typeof timingSource.outputTokens === "number" &&
+                        Number.isFinite(timingSource.outputTokens)
+                        ? {
+                            outputTokens: Math.max(0, timingSource.outputTokens),
+                        }
+                        : {}),
+                }
+                : undefined;
             return {
                 kind: event.type,
                 data: {
                     text: String(event.text ?? ""),
                     ...(content ? { content } : {}),
+                    ...(timing ? { timing } : {}),
                 },
             };
         }
@@ -123,6 +152,9 @@ function turnEventToStorePartial(event) {
                 }),
             };
         }
+        case "todo_updated":
+        case "todo_cleared":
+            return { kind: event.type, data: { todos: Array.isArray(event.todos) ? event.todos : [], ...(event.toolCallId ? { toolCallId: String(event.toolCallId) } : {}) } };
         case "agent_end":
             return {
                 kind: "agent_end",
@@ -130,8 +162,19 @@ function turnEventToStorePartial(event) {
             };
         case "agent_settled":
             return { kind: "agent_settled", data: {} };
-        case "error":
-            return { kind: "error", data: { message: String(event.message ?? "") } };
+        case "error": {
+            const content = parseAssistantContent(event.content);
+            return {
+                kind: "error",
+                data: {
+                    message: String(event.message ?? ""),
+                    ...(content ? { content } : {}),
+                    ...(event.providerError && typeof event.providerError === "object"
+                        ? { providerError: event.providerError }
+                        : {}),
+                },
+            };
+        }
         default:
             return undefined;
     }
@@ -197,6 +240,13 @@ function ensureAgentEndEvent(deps, sessionId, turnId) {
     }
 }
 async function readJsonBody(req, maxBytes = 2 * 1024 * 1024) {
+    // AC-R5-003: the multi-workspace dispatcher (server.ts readBodyOnce)
+    // pre-reads and JSON-parses the body for workspaceId resolution, stashing
+    // it on req.__preReadBody. Consume it first so the body is parsed exactly
+    // once per request; re-reading the consumed stream would yield {}.
+    const preRead = req.__preReadBody;
+    if (preRead !== undefined)
+        return preRead;
     const chunks = [];
     let total = 0;
     for await (const chunk of req) {
@@ -344,7 +394,10 @@ export async function handleChatCapabilities(_req, res, deps) {
         hasBash: true,
     });
 }
-export async function handleCreateChatSession(req, res, deps) {
+export async function handleCreateChatSession(req, res, deps, 
+/** Explicit owning workspaceId from the multi-workspace dispatcher
+ * (AC-R7-002). The body still parses exactly once via req.__preReadBody. */
+workspaceId) {
     const gate = gateMutation(req, deps);
     if (!gate.ok) {
         sendJson(res, gate.status, {
@@ -422,6 +475,10 @@ export async function handleCreateChatSession(req, res, deps) {
             sessionFile: handle.sessionFile,
             modelProvider: handle.model?.provider,
             modelId: handle.model?.modelId,
+            // AC-R7-002: explicit parameter from the dispatcher — the runtime
+            // store.create wrapper is gone; body workspaceId (if any) only acts as
+            // a fallback for direct (non-dispatcher) handler tests.
+            workspaceId: workspaceId ?? (typeof body.workspaceId === "string" && body.workspaceId ? body.workspaceId : undefined),
         });
         if (snapshot)
             deps.events.append(handle.sessionId, `${handle.sessionId}:snapshot`, {
@@ -646,8 +703,10 @@ export async function handleGetChatSession(_req, res, deps, sessionId) {
     await deps.operationLinker.recoverSession(sessionId);
     const composerDraft = await new ComposerDraftStore(deps.appData).get(sessionId);
     const snapshot = deps.events.snapshot(sessionId);
+    const telemetry = deriveChatSessionTelemetry(snapshot);
     const lastEvent = snapshot.at(-1);
     const activeTurn = deps.events.getActiveTurn(sessionId);
+    const pendingQuestion = await deps.questionRegistry?.get(sessionId);
     sendJson(res, 200, {
         ok: true,
         eventEpoch: deps.events.epoch(sessionId),
@@ -660,8 +719,19 @@ export async function handleGetChatSession(_req, res, deps, sessionId) {
                     ? "stopping"
                     : "running"
                 : "idle",
+            pendingQuestion: pendingQuestion ?? null,
+            todos: projectCurrentTodos(snapshot) ?? [],
         },
         hasBash: true,
+        sessionStats: telemetry.stats,
+        usage: telemetry.usage,
+        compactions: snapshot
+            .filter((event) => event.kind === "compact")
+            .map((event) => ({
+            eventId: event.eventId,
+            at: event.at,
+            data: event.data,
+        })),
         lastEventId: lastEvent?.eventId ?? null,
         lastEventSeq: lastEvent?.seq ?? 0,
     });
@@ -769,11 +839,12 @@ export async function handlePutDeferredTurn(req, res, deps, sessionId) {
                             : "待发送消息无效或会话不存在",
             },
             deferredTurn: result.deferredTurn ?? null,
+            deferredTurns: projectDeferredTurnSummaries(await deps.store.listDeferredTurns(sessionId)),
             summary: projectDeferredTurnSummary(result.deferredTurn),
         });
         return;
     }
-    emitDeferredTurnUpdate(deps, sessionId, blockedByTurnId, result.deferredTurn, result.deferredTurn.revision);
+    await emitDeferredTurnUpdate(deps, sessionId, blockedByTurnId, result.deferredTurn, result.deferredTurn.revision);
     sendJson(res, 200, {
         ok: true,
         accepted: true,
@@ -781,6 +852,7 @@ export async function handlePutDeferredTurn(req, res, deps, sessionId) {
         state: result.deferredTurn.state,
         revision: result.deferredTurn.revision,
         deferredTurn: result.deferredTurn,
+        deferredTurns: projectDeferredTurnSummaries(await deps.store.listDeferredTurns(sessionId)),
         summary: projectDeferredTurnSummary(result.deferredTurn),
     });
     void dispatchDeferredTurn(deps, sessionId);
@@ -826,18 +898,90 @@ export async function handleDeleteDeferredTurn(req, res, deps, sessionId) {
                     : "待发送消息已变化，请刷新后重试",
             },
             deferredTurn: result.deferredTurn ?? null,
+            deferredTurns: projectDeferredTurnSummaries(await deps.store.listDeferredTurns(sessionId)),
         });
         return;
     }
     const clearedRevision = result.deferredTurn.revision + 1;
-    emitDeferredTurnUpdate(deps, sessionId, result.deferredTurn.blockedByTurnId, undefined, clearedRevision);
+    await emitDeferredTurnUpdate(deps, sessionId, result.deferredTurn.blockedByTurnId, undefined, clearedRevision);
     sendJson(res, 200, {
         ok: true,
         cancelled: true,
         deferredTurn: result.deferredTurn,
+        deferredTurns: projectDeferredTurnSummaries(await deps.store.listDeferredTurns(sessionId)),
         revision: clearedRevision,
     });
 }
+/** Move one addressed FIFO item into Pi's live steering queue. */
+export async function handleSteerDeferredTurn(req, res, deps, sessionId, clientRequestId) {
+    const gate = gateMutation(req, deps);
+    if (!gate.ok) {
+        sendJson(res, gate.status, { ok: false, error: { code: gate.code, message: gate.message } });
+        return;
+    }
+    let body = {};
+    try {
+        body = await readJsonBody(req);
+    }
+    catch (error) {
+        sendJson(res, 400, { ok: false, error: { code: "INVALID_INPUT", message: error instanceof Error ? error.message : String(error) } });
+        return;
+    }
+    const expectedRevision = typeof body.expectedRevision === "number" && Number.isSafeInteger(body.expectedRevision)
+        ? body.expectedRevision
+        : -1;
+    const active = deps.events.getActiveTurn(sessionId);
+    if (!active) {
+        sendJson(res, 409, { ok: false, error: { code: "TURN_NOT_ACTIVE", message: "当前没有可插话的运行中回合" } });
+        return;
+    }
+    const claim = await deps.store.claimDeferredTurn(sessionId, expectedRevision, clientRequestId);
+    if (!claim.ok) {
+        sendJson(res, claim.code === "NOT_FOUND" ? 404 : 409, {
+            ok: false,
+            error: { code: claim.code, message: "排队消息已变化，请刷新后重试" },
+        });
+        return;
+    }
+    const item = claim.deferredTurn;
+    try {
+        await deps.runtime.steer(sessionId, item.text, item.images);
+        const userMessage = await deps.store.appendMessage(sessionId, {
+            role: "user",
+            text: item.text,
+        });
+        deps.events.append(sessionId, active.turnId, {
+            kind: "user_message",
+            data: {
+                clientRequestId: item.clientRequestId,
+                message: { id: userMessage.id, text: userMessage.text, at: userMessage.at },
+            },
+        });
+        await deps.store.clearDeferredTurnForRequest(sessionId, item.clientRequestId);
+        await emitDeferredTurnUpdate(deps, sessionId, active.turnId, undefined, item.revision + 2);
+        sendJson(res, 200, {
+            ok: true,
+            accepted: true,
+            deferredTurns: projectDeferredTurnSummaries(await deps.store.listDeferredTurns(sessionId)),
+        });
+    }
+    catch (error) {
+        const restored = await deps.store.transitionDeferredTurn(sessionId, {
+            expectedRevision: item.revision,
+            clientRequestId: item.clientRequestId,
+            state: "queued",
+        });
+        if (restored)
+            await emitDeferredTurnUpdate(deps, sessionId, active.turnId, restored, restored.revision);
+        sendJson(res, 409, {
+            ok: false,
+            error: {
+                code: "STEER_FAILED",
+                message: error instanceof Error ? error.message : "插话发送失败",
+            },
+        });
+    }
+}
 /** Lightweight busy-truth endpoint for the client reconcile loop (pi-web
  *  get_state equivalent): exposes the active turn + the latest turn's durable
  *  outcome WITHOUT the full message payload, so the UI can poll it on an
@@ -865,6 +1009,7 @@ export async function handleGetChatSessionState(_req, res, deps, sessionId) {
             isBashRunning: false,
         };
     const runtimeBusy = Object.values(runtimeFacts).some((value) => value === true);
+    const pendingQuestion = await deps.questionRegistry?.get(sessionId);
     const turnPhase = active
         ? active.abortRequestedAt
             ? "stopping"
@@ -884,10 +1029,60 @@ export async function handleGetChatSessionState(_req, res, deps, sessionId) {
             latestTurn: latest ? turnSummary(latest) : null,
             runtime: runtimeFacts,
             turnPhase,
-            deferredTurn: projectDeferredTurnSummary(record.deferredTurn),
+            deferredTurn: projectDeferredTurnSummary(record.deferredTurns?.[0]),
+            deferredTurns: projectDeferredTurnSummaries(record.deferredTurns ?? []),
+            pendingQuestion: pendingQuestion ?? null,
+            todos: projectCurrentTodos(deps.events.snapshot(sessionId)) ?? [],
         },
     });
 }
+export async function handleAnswerUserQuestion(req, res, deps, sessionId, requestId) {
+    const gate = gateMutation(req, deps);
+    if (!gate.ok) {
+        sendJson(res, gate.status, { ok: false, error: { code: gate.code, message: gate.message } });
+        return;
+    }
+    if (!(await requireChatSession(res, deps, sessionId)))
+        return;
+    if (!deps.questionRegistry) {
+        sendJson(res, 503, { ok: false, error: { code: "USER_QUESTIONS_UNAVAILABLE", message: "user question capability is unavailable" } });
+        return;
+    }
+    try {
+        const body = await readJsonBody(req);
+        const question = await deps.questionRegistry.answer(sessionId, requestId, body);
+        sendJson(res, 200, { ok: true, resolved: true, question });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const status = message === "USER_QUESTION_NOT_FOUND" ? 404 : message === "USER_QUESTION_STALE" ? 409 : 400;
+        sendJson(res, status, { ok: false, error: { code: message, message } });
+    }
+}
+export async function handleCancelUserQuestion(req, res, deps, sessionId, requestId) {
+    const gate = gateMutation(req, deps);
+    if (!gate.ok) {
+        sendJson(res, gate.status, { ok: false, error: { code: gate.code, message: gate.message } });
+        return;
+    }
+    if (!(await requireChatSession(res, deps, sessionId)))
+        return;
+    if (!deps.questionRegistry) {
+        sendJson(res, 503, { ok: false, error: { code: "USER_QUESTIONS_UNAVAILABLE", message: "user question capability is unavailable" } });
+        return;
+    }
+    try {
+        const body = await readJsonBody(req).catch(() => ({}));
+        const reason = typeof body.reason === "string" && body.reason.trim() ? body.reason.trim().slice(0, 120) : "USER_CANCELLED";
+        const question = await deps.questionRegistry.cancel(sessionId, requestId, reason);
+        sendJson(res, 200, { ok: true, cancelled: true, question });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const status = message === "USER_QUESTION_NOT_FOUND" ? 404 : 409;
+        sendJson(res, status, { ok: false, error: { code: message, message } });
+    }
+}
 export async function handleListChatSessions(_req, res, deps) {
     const sessions = await deps.store.list({ includeArchived: true });
     sendJson(res, 200, {
@@ -903,7 +1098,8 @@ export async function handleListChatSessions(_req, res, deps) {
                     : active
                         ? "running"
                         : "idle",
-                deferredTurn: projectDeferredTurnSummary(session.deferredTurn),
+                deferredTurn: projectDeferredTurnSummary(session.deferredTurns?.[0]),
+                deferredTurns: projectDeferredTurnSummaries(session.deferredTurns ?? []),
             };
         }),
         hasBash: true,
@@ -1150,6 +1346,7 @@ export async function handleChatPrompt(req, res, deps, sessionId) {
             store: deps.store,
             actionContext,
             sessionId,
+            turnId,
             text,
             images,
             signal: ac.signal,
@@ -1445,6 +1642,7 @@ export async function handleCreateChatTurn(req, res, deps, sessionId, trustedPay
                 store: deps.store,
                 actionContext,
                 sessionId,
+                turnId: turn.turnId,
                 text,
                 images,
                 signal: controller.signal,
@@ -1530,12 +1728,16 @@ export async function handleCreateChatTurn(req, res, deps, sessionId, trustedPay
         }
     })();
 }
-function emitDeferredTurnUpdate(deps, sessionId, turnId, deferredTurn, revision) {
+async function emitDeferredTurnUpdate(deps, sessionId, turnId, _deferredTurn, _revision) {
+    const record = await deps.store.get(sessionId);
+    if (!record)
+        return;
     deps.events.append(sessionId, turnId, {
         kind: "queue_update",
         data: {
-            deferredTurn: projectDeferredTurnSummary(deferredTurn),
-            revision,
+            deferredTurn: projectDeferredTurnSummary(record.deferredTurns?.[0]),
+            deferredTurns: projectDeferredTurnSummaries(record.deferredTurns ?? []),
+            revision: record.deferredQueueRevision ?? 0,
         },
     });
 }
@@ -1571,7 +1773,7 @@ export async function dispatchDeferredTurn(deps, sessionId) {
     deferredDispatchingSessions.add(sessionId);
     try {
         let record = await deps.store.get(sessionId);
-        let deferred = record?.deferredTurn;
+        let deferred = record?.deferredTurns?.find((item) => item.state === "dispatching" || item.state === "queued");
         if (!deferred)
             return;
         if (deferred.state === "accepted")
@@ -1583,17 +1785,19 @@ export async function dispatchDeferredTurn(deps, sessionId) {
             if (existing) {
                 const accepted = await deps.store.transitionDeferredTurn(sessionId, {
                     expectedRevision: deferred.revision,
+                    clientRequestId: deferred.clientRequestId,
                     state: "accepted",
                     acceptedTurnId: existing.turnId,
                 });
                 if (accepted)
-                    emitDeferredTurnUpdate(deps, sessionId, existing.turnId, accepted, accepted.revision);
+                    await emitDeferredTurnUpdate(deps, sessionId, existing.turnId, accepted, accepted.revision);
                 return;
             }
             if (deps.events.getActiveTurn(sessionId))
                 return;
             const requeued = await deps.store.transitionDeferredTurn(sessionId, {
                 expectedRevision: deferred.revision,
+                clientRequestId: deferred.clientRequestId,
                 state: "queued",
             });
             if (!requeued)
@@ -1604,11 +1808,11 @@ export async function dispatchDeferredTurn(deps, sessionId) {
         const runtimeBusy = Boolean(runtimeFacts && Object.values(runtimeFacts).some((value) => value === true));
         if (deps.events.getActiveTurn(sessionId) || runtimeBusy)
             return;
-        const claim = await deps.store.claimDeferredTurn(sessionId, deferred.revision);
+        const claim = await deps.store.claimDeferredTurn(sessionId, deferred.revision, deferred.clientRequestId);
         if (!claim.ok)
             return;
         deferred = claim.deferredTurn;
-        emitDeferredTurnUpdate(deps, sessionId, deferred.blockedByTurnId, deferred, deferred.revision);
+        await emitDeferredTurnUpdate(deps, sessionId, deferred.blockedByTurnId, deferred, deferred.revision);
         const started = await startTrustedChatTurn(deps, sessionId, {
             clientRequestId: deferred.clientRequestId,
             text: deferred.text,
@@ -1627,7 +1831,7 @@ export async function dispatchDeferredTurn(deps, sessionId) {
                 });
                 const cleared = await deps.store.clearDeferredTurnForRequest(sessionId, deferred.clientRequestId);
                 if (cleared)
-                    emitDeferredTurnUpdate(deps, sessionId, turnId, undefined, cleared.clearedRevision);
+                    await emitDeferredTurnUpdate(deps, sessionId, turnId, undefined, cleared.clearedRevision);
             },
         });
         const accepted = started.body.accepted === true;
@@ -1637,11 +1841,12 @@ export async function dispatchDeferredTurn(deps, sessionId) {
         if (accepted && turn?.turnId) {
             const next = await deps.store.transitionDeferredTurn(sessionId, {
                 expectedRevision: deferred.revision,
+                clientRequestId: deferred.clientRequestId,
                 state: "accepted",
                 acceptedTurnId: turn.turnId,
             });
             if (next)
-                emitDeferredTurnUpdate(deps, sessionId, turn.turnId, next, next.revision);
+                await emitDeferredTurnUpdate(deps, sessionId, turn.turnId, next, next.revision);
             return;
         }
         const error = started.body.error && typeof started.body.error === "object"
@@ -1650,14 +1855,16 @@ export async function dispatchDeferredTurn(deps, sessionId) {
         if (error.code === "TURN_ACTIVE") {
             const next = await deps.store.transitionDeferredTurn(sessionId, {
                 expectedRevision: deferred.revision,
+                clientRequestId: deferred.clientRequestId,
                 state: "queued",
             });
             if (next)
-                emitDeferredTurnUpdate(deps, sessionId, deferred.blockedByTurnId, next, next.revision);
+                await emitDeferredTurnUpdate(deps, sessionId, deferred.blockedByTurnId, next, next.revision);
             return;
         }
         const failed = await deps.store.transitionDeferredTurn(sessionId, {
             expectedRevision: deferred.revision,
+            clientRequestId: deferred.clientRequestId,
             state: "failed",
             lastError: {
                 code: error.code ?? `HTTP_${started.status}`,
@@ -1665,17 +1872,18 @@ export async function dispatchDeferredTurn(deps, sessionId) {
             },
         });
         if (failed)
-            emitDeferredTurnUpdate(deps, sessionId, deferred.blockedByTurnId, failed, failed.revision);
+            await emitDeferredTurnUpdate(deps, sessionId, deferred.blockedByTurnId, failed, failed.revision);
     }
     catch (error) {
         // Keep fire-and-forget callers safe and make a dispatch failure visible and
         // recoverable from the composer instead of leaving the slot indefinitely
         // in an ambiguous queued/dispatching state.
         try {
-            const current = (await deps.store.get(sessionId))?.deferredTurn;
+            const current = (await deps.store.get(sessionId))?.deferredTurns?.find((item) => item.state === "queued" || item.state === "dispatching");
             if (current && (current.state === "queued" || current.state === "dispatching")) {
                 const failed = await deps.store.transitionDeferredTurn(sessionId, {
                     expectedRevision: current.revision,
+                    clientRequestId: current.clientRequestId,
                     state: "failed",
                     lastError: {
                         code: "DEFERRED_TURN_DISPATCH_FAILED",
@@ -1683,7 +1891,7 @@ export async function dispatchDeferredTurn(deps, sessionId) {
                     },
                 });
                 if (failed)
-                    emitDeferredTurnUpdate(deps, sessionId, failed.blockedByTurnId, failed, failed.revision);
+                    await emitDeferredTurnUpdate(deps, sessionId, failed.blockedByTurnId, failed, failed.revision);
             }
         }
         catch {
@@ -1698,12 +1906,9 @@ export async function dispatchDeferredTurn(deps, sessionId) {
 export async function recoverDeferredTurns(deps) {
     const sessions = await deps.store.list({ includeArchived: false });
     await Promise.all(sessions
-        .filter((session) => session.deferredTurn
-        ? session.deferredTurn.state === "queued" ||
-            session.deferredTurn.state === "dispatching"
-        : false)
+        .filter((session) => (session.deferredTurns ?? []).some((item) => item.state === "queued" || item.state === "dispatching"))
         .map(async (session) => {
-        const deferred = session.deferredTurn;
+        const deferred = session.deferredTurns.find((item) => item.state === "dispatching" || item.state === "queued");
         const active = deps.events.getActiveTurn(session.sessionId);
         // A process restart cannot retain AbortController ownership. When the
         // durable blocker was already stopping and no execution owns it now,
@@ -1771,6 +1976,7 @@ export async function handleAbortChatTurn(req, res, deps, sessionId, turnId) {
         return;
     }
     deps.events.markAbortRequested?.(sessionId, turnId);
+    await deps.questionRegistry?.cancelForSession(sessionId, "TURN_ABORTED").catch(() => undefined);
     if (!execution.controller.signal.aborted)
         execution.controller.abort();
     const waited = await (deps.turnExecutions?.waitForCompletion(sessionId, turnId, DEFAULT_ABORT_WAIT_MS) ?? Promise.resolve({ status: "missing" }));
@@ -1921,6 +2127,8 @@ export async function handleDeleteChatSession(req, res, deps, sessionId) {
         });
         return;
     }
+    await deps.questionRegistry?.cancelForSession(sessionId, "SESSION_DELETED").catch(() => undefined);
+    deps.todoRegistry?.clear(sessionId);
     deps.runtime.dispose(sessionId);
     deps.operationLinker.clearSession(sessionId);
     deps.events.clear(sessionId);
@@ -2595,6 +2803,36 @@ async function handleLinkWorkspaceOperation(req, res, deps, sessionId) {
         });
     }
 }
+async function handleUnlinkWorkspaceOperation(req, res, deps, sessionId, operationId) {
+    const gate = gateMutation(req, deps);
+    if (!gate.ok) {
+        sendJson(res, gate.status, {
+            ok: false,
+            error: { code: gate.code, message: gate.message },
+        });
+        return;
+    }
+    if (!(await requireChatSession(res, deps, sessionId)))
+        return;
+    // AC-R7-001 (2026-08-23): removing a workspace-linked DAG association is
+    // idempotent — a missing link is already-removed (200), never an error.
+    try {
+        const removed = await deps.operationLinker.unlink({
+            sessionId,
+            operationId,
+        });
+        sendJson(res, 200, { ok: true, removed });
+    }
+    catch (error) {
+        sendJson(res, 400, {
+            ok: false,
+            error: {
+                code: "INVALID_INPUT",
+                message: error instanceof Error ? error.message : String(error),
+            },
+        });
+    }
+}
 async function handleStartInterview(req, res, deps, sessionId) {
     const gate = gateMutation(req, deps);
     if (!gate.ok) {
@@ -3247,7 +3485,8 @@ export async function handleChatCompact(req, res, deps, sessionId) {
         return;
     }
     const rawInstructions = typeof body.instructions === "string" ? body.instructions : undefined;
-    const customInstructions = rawInstructions?.trim() || undefined;
+    const currentTodos = projectCurrentTodos(deps.events.snapshot(sessionId));
+    const customInstructions = buildTodoCompactionInstructions(rawInstructions, currentTodos);
     try {
         const snapshot = await deps.runtime.compact(sessionId, customInstructions);
         const event = deps.events.append(sessionId, deps.events.latestTurnId(sessionId) ?? `${sessionId}:compact`, { kind: "compact", data: snapshot });
@@ -3283,8 +3522,10 @@ export async function handleChatMessages(res, deps, sessionId, url) {
 /**
  * Dispatch a chat HTTP request. Returns true if handled.
  * Mounted under /api/operator/v1/chat/*.
+ * workspaceScope (AC-R7-002): the explicit owning workspaceId for session
+ * create, forwarded to handleCreateChatSession → store.create.
  */
-export async function handleChatRequest(req, res, deps, pathname) {
+export async function handleChatRequest(req, res, deps, pathname, workspaceScope) {
     if (!deps)
         return false;
     if (!pathname.startsWith("/api/operator/v1/chat/") &&
@@ -3362,6 +3603,16 @@ export async function handleChatRequest(req, res, deps, pathname) {
         await handleStartInterview(req, res, deps, decodeURIComponent(interviewStart[1]));
         return true;
     }
+    const userQuestionAnswer = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/questions\/([^/]+)\/answer$/);
+    if (method === "POST" && userQuestionAnswer) {
+        await handleAnswerUserQuestion(req, res, deps, decodeURIComponent(userQuestionAnswer[1]), decodeURIComponent(userQuestionAnswer[2]));
+        return true;
+    }
+    const userQuestionCancel = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/questions\/([^/]+)\/cancel$/);
+    if (method === "POST" && userQuestionCancel) {
+        await handleCancelUserQuestion(req, res, deps, decodeURIComponent(userQuestionCancel[1]), decodeURIComponent(userQuestionCancel[2]));
+        return true;
+    }
     const interviewAnswer = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/interviews\/([^/]+)\/answers$/);
     if (method === "POST" && interviewAnswer) {
         await handleAnswerInterview(req, res, deps, decodeURIComponent(interviewAnswer[1]), decodeURIComponent(interviewAnswer[2]));
@@ -3468,6 +3719,11 @@ export async function handleChatRequest(req, res, deps, pathname) {
         await handleDeleteDeferredTurn(req, res, deps, decodeURIComponent(deferredTurn[1]));
         return true;
     }
+    const deferredTurnSteer = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/deferred-turn\/([^/]+)\/steer$/);
+    if (method === "POST" && deferredTurnSteer) {
+        await handleSteerDeferredTurn(req, res, deps, decodeURIComponent(deferredTurnSteer[1]), decodeURIComponent(deferredTurnSteer[2]));
+        return true;
+    }
     const sessionTurnAbort = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/turns\/([^/]+)\/abort$/);
     if (method === "POST" && sessionTurnAbort) {
         await handleAbortChatTurn(req, res, deps, decodeURIComponent(sessionTurnAbort[1]), decodeURIComponent(sessionTurnAbort[2]));
@@ -3483,6 +3739,13 @@ export async function handleChatRequest(req, res, deps, pathname) {
         await handleLinkWorkspaceOperation(req, res, deps, decodeURIComponent(operationLink[1]));
         return true;
     }
+    const operationLinkItem = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/operation-links\/([^/]+)$/);
+    if (method === "DELETE" && operationLinkItem) {
+        // AC-R7-001: Details rail DAG remove — real DELETE of the workspace
+        // operation-link association (idempotent).
+        await handleUnlinkWorkspaceOperation(req, res, deps, decodeURIComponent(operationLinkItem[1]), decodeURIComponent(operationLinkItem[2]));
+        return true;
+    }
     const sessionCompact = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/compact$/);
     if (method === "POST" && sessionCompact) {
         await handleChatCompact(req, res, deps, decodeURIComponent(sessionCompact[1]));
@@ -3530,7 +3793,7 @@ export async function handleChatRequest(req, res, deps, pathname) {
         }
     }
     if (method === "POST" && pathname === "/api/operator/v1/chat/sessions") {
-        await handleCreateChatSession(req, res, deps);
+        await handleCreateChatSession(req, res, deps, workspaceScope);
         return true;
     }
     if (isMutationMethod(method)) {