@tea-agent/loop-agent 0.39.3 → 0.40.0-beta.1

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

@@ -12,12 +12,13 @@
  * Mutation routes go through the Console mutation gate (boot token + Origin).
  * Read routes (GET capabilities / sessions) are open to loopback.
  */
+import { randomUUID } from "node:crypto";
 import { parseAssistantContent } from "./assistant-content.js";
 import { OPERATOR_CHAT_ALLOWED_TOOLS, OPERATOR_CHAT_DENIED_TOOLS, OPERATOR_CHAT_DENIED_OPERATOR_ACTIONS, } from "./tools.js";
 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 +34,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,
@@ -52,7 +55,6 @@ function turnSummary(turn) {
 function isTerminalTurnState(state) {
     return state === "settled" || state === "aborted" || state === "failed";
 }
-const DEFAULT_ABORT_WAIT_MS = 2_500;
 /** Parse Chat's `<epoch>:<seq>` SSE cursor. Legacy `<sessionId>:<seq>` has
  * the same wire shape; its prefix intentionally fails the current process
  * epoch comparison and triggers safe snapshot recovery (M5.1). */
@@ -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,53 @@ function turnEventToStorePartial(event) {
             };
         case "agent_settled":
             return { kind: "agent_settled", data: {} };
-        case "error":
-            return { kind: "error", data: { message: String(event.message ?? "") } };
+        case "compaction_start":
+        case "compaction_end": {
+            const reason = event.reason === "threshold" || event.reason === "overflow"
+                ? event.reason
+                : "manual";
+            const status = event.type === "compaction_start"
+                ? "running"
+                : event.status === "aborted" || event.status === "failed"
+                    ? event.status
+                    : "completed";
+            const data = {
+                schemaVersion: 1,
+                compactionId: String(event.compactionId ?? ""),
+                reason,
+                status,
+                ...(typeof event.summary === "string"
+                    ? { summary: event.summary }
+                    : {}),
+                ...(typeof event.firstKeptEntryId === "string"
+                    ? { firstKeptEntryId: event.firstKeptEntryId }
+                    : {}),
+                ...(typeof event.tokensBefore === "number"
+                    ? { tokensBefore: event.tokensBefore }
+                    : {}),
+                ...(typeof event.estimatedTokensAfter === "number"
+                    ? { estimatedTokensAfter: event.estimatedTokensAfter }
+                    : {}),
+                willRetry: Boolean(event.willRetry),
+                ...(typeof event.errorMessage === "string"
+                    ? { errorMessage: event.errorMessage }
+                    : {}),
+            };
+            return { kind: event.type, data };
+        }
+        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 +274,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 +428,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 +509,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 +737,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 +753,22 @@ 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" ||
+            event.kind === "compaction_start" ||
+            event.kind === "compaction_end")
+            .map((event) => ({
+            eventId: event.eventId,
+            kind: event.kind,
+            at: event.at,
+            data: event.data,
+        })),
         lastEventId: lastEvent?.eventId ?? null,
         lastEventSeq: lastEvent?.seq ?? 0,
     });
@@ -769,11 +876,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 +889,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 +935,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 +1046,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 +1066,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 +1135,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 +1383,7 @@ export async function handleChatPrompt(req, res, deps, sessionId) {
             store: deps.store,
             actionContext,
             sessionId,
+            turnId,
             text,
             images,
             signal: ac.signal,
@@ -1445,6 +1679,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 +1765,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 +1810,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 +1822,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 +1845,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 +1868,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 +1878,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 +1892,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 +1909,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 +1928,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 +1943,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,
@@ -1770,34 +2012,24 @@ export async function handleAbortChatTurn(req, res, deps, sessionId, turnId) {
         });
         return;
     }
-    deps.events.markAbortRequested?.(sessionId, turnId);
+    const stopping = deps.events.markAbortRequested?.(sessionId, turnId) ?? turn;
+    // DSH-style acknowledgement: deliver the AbortSignal synchronously, then let
+    // the detached Turn closeout own SDK/process cleanup and terminal persistence.
+    // The HTTP request reports that Stop was accepted; it does not wait for Pi to
+    // become idle. This keeps cancellation latency independent of slow providers,
+    // tools and process-tree cleanup while preserving the active-Turn lease.
     if (!execution.controller.signal.aborted)
         execution.controller.abort();
-    const waited = await (deps.turnExecutions?.waitForCompletion(sessionId, turnId, DEFAULT_ABORT_WAIT_MS) ?? Promise.resolve({ status: "missing" }));
-    if (waited.status === "completed") {
-        const finalTurn = deps.events.getTurn(sessionId, turnId) ??
-            {
-                ...turn,
-                state: waited.outcome.state,
-            };
-        sendJson(res, 200, {
-            ok: true,
-            accepted: true,
-            idempotent: false,
-            turn: turnSummary(finalTurn),
-        });
-        return;
-    }
-    // Timeout or missing completion: keep non-terminal; client reconciles via /state.
-    const pending = deps.events.getTurn(sessionId, turnId) ?? turn;
+    const questionCancellation = deps.questionRegistry?.cancelForSession(sessionId, "TURN_ABORTED");
+    if (questionCancellation)
+        void questionCancellation.catch(() => undefined);
+    const acceptedTurn = deps.events.getTurn(sessionId, turnId) ?? stopping;
     sendJson(res, 202, {
-        ok: false,
-        accepted: false,
-        error: {
-            code: "TURN_ABORT_PENDING",
-            message: "abort requested; turn has not yet reached a terminal state",
-        },
-        turn: turnSummary(pending),
+        ok: true,
+        accepted: true,
+        idempotent: false,
+        cleanupPending: !isTerminalTurnState(acceptedTurn.state),
+        turn: turnSummary(acceptedTurn),
     });
 }
 export async function handleGetChatTurn(_req, res, deps, sessionId, turnId) {
@@ -1921,6 +2153,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 +2829,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,14 +3511,59 @@ 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);
+    const turnId = deps.events.latestTurnId(sessionId) ?? `${sessionId}:compact`;
+    const compactionId = `${sessionId}:compaction:${randomUUID()}`;
+    deps.events.append(sessionId, turnId, {
+        kind: "compaction_start",
+        data: {
+            schemaVersion: 1,
+            compactionId,
+            reason: "manual",
+            status: "running",
+            willRetry: false,
+        },
+    });
     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 });
+        const event = deps.events.append(sessionId, turnId, {
+            kind: "compaction_end",
+            data: {
+                schemaVersion: 1,
+                compactionId,
+                reason: "manual",
+                status: "completed",
+                summary: snapshot.summary,
+                ...(snapshot.firstKeptEntryId
+                    ? { firstKeptEntryId: snapshot.firstKeptEntryId }
+                    : {}),
+                ...(snapshot.tokensBefore === undefined
+                    ? {}
+                    : { tokensBefore: snapshot.tokensBefore }),
+                ...(snapshot.estimatedTokensAfter === undefined
+                    ? {}
+                    : { estimatedTokensAfter: snapshot.estimatedTokensAfter }),
+                willRetry: false,
+            },
+        });
         sendJson(res, 200, { ok: true, snapshot, eventId: event.eventId });
     }
     catch (error) {
         const classified = classifyChatCompactionFailure(error);
+        const aborted = error instanceof Error &&
+            (error.name === "AbortError" || /cancel(?:led|ed)|aborted/i.test(error.message));
+        deps.events.append(sessionId, turnId, {
+            kind: "compaction_end",
+            data: {
+                schemaVersion: 1,
+                compactionId,
+                reason: "manual",
+                status: aborted ? "aborted" : "failed",
+                willRetry: false,
+                ...(aborted ? {} : { errorMessage: classified.message }),
+            },
+        });
         sendJson(res, classified.status, {
             ok: false,
             error: { code: classified.code, message: classified.message },
@@ -3283,8 +3592,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 +3673,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 +3789,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 +3809,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 +3863,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)) {