@tea-agent/loop-agent 0.40.0-next.9 → 0.41.0-beta.1

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

@@ -24,7 +24,7 @@ import { ResourcePreferencesError, setSkillAutoInvocationPreference, } from "./r
 import { ComposerDraftStore } from "./composer-draft-store.js";
 import { walkRepoFiles } from "./repo-walk.js";
 import { isSensitivePath, scrubSecrets } from "./explore-tools.js";
-import { listRepoDirectory, readRepoPreview, RepoBrowserError, } from "./repo-browser.js";
+import { listRepoDirectory, matchRepoHtmlPreviewRoute, readRepoHtmlAsset, readRepoPreview, RepoBrowserError, } from "./repo-browser.js";
 import { projectRuntimeContext } from "./runtime-context.js";
 import { patchModelsConfig, readModelsConfig, readPackageInventory, } from "./pi-console-config.js";
 import { ChatInterviewAdapter, projectChatInterviewState, } from "./interview-adapter.js";
@@ -34,11 +34,76 @@ 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 { deriveChatSessionTelemetry, deriveChatTurnTelemetry } 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";
+import { buildGoalCompactionInstructions, buildGoalContinuationContext, } from "./goals.js";
+import { classifyGoalRoundAdmission, } from "./goal-round-driver.js";
+import { isTerminalOperationState } from "../../../infrastructure/console/operation-store.js";
+/**
+ * Reattach the durable event-ring order to session-store rows. The session
+ * store remains the content authority; the ring only supplies chronology.
+ * This makes refresh hydration use the same turnId/seq ordering as live SSE.
+ */
+export function projectStoredMessagesWithEventOrder(messages, events) {
+    let assistantCursor = 0;
+    const nextAssistantEvent = (message) => {
+        const expectedKind = message.kind === "provider-error" ? "error" : "message_end";
+        const messageAt = Date.parse(message.at);
+        for (let index = assistantCursor; index < events.length; index += 1) {
+            const event = events[index];
+            if (event.kind !== expectedKind)
+                continue;
+            const data = event.data;
+            const eventText = typeof data.text === "string"
+                ? data.text
+                : typeof data.message === "string"
+                    ? data.message
+                    : undefined;
+            const closeInTime = Number.isFinite(messageAt) && Number.isFinite(Date.parse(event.at))
+                ? Math.abs(Date.parse(event.at) - messageAt) <= 30_000
+                : true;
+            if (eventText === message.text && closeInTime) {
+                assistantCursor = index + 1;
+                return event;
+            }
+        }
+        // The bounded ring may no longer contain this old message. Leave it on the
+        // legacy timestamp fallback; never steal a newer event just to fill a seq.
+        return undefined;
+    };
+    return messages.map((message) => {
+        let start;
+        let finish;
+        if (message.role === "user") {
+            start = events.find((event) => {
+                if (event.kind !== "user_message")
+                    return false;
+                const payload = event.data;
+                return payload.message?.id === message.id;
+            });
+        }
+        else if (message.role === "assistant") {
+            start = nextAssistantEvent(message);
+        }
+        else if (message.role === "tool" && message.toolCallId) {
+            start = events.find((event) => event.kind === "tool_call" &&
+                event.data.toolCallId ===
+                    message.toolCallId);
+            finish = events.find((event) => event.kind === "tool_result" &&
+                event.data.toolCallId ===
+                    message.toolCallId);
+            start ??= finish;
+        }
+        return {
+            ...message,
+            ...(start ? { eventSeq: start.seq, turnId: start.turnId } : {}),
+            ...(finish ? { finishedSeq: finish.seq } : {}),
+        };
+    });
+}
 function turnSummary(turn) {
     return {
         turnId: turn.turnId,
@@ -514,6 +579,7 @@ workspaceId) {
             // a fallback for direct (non-dispatcher) handler tests.
             workspaceId: workspaceId ?? (typeof body.workspaceId === "string" && body.workspaceId ? body.workspaceId : undefined),
         });
+        await deps.attachSession?.(handle.sessionId).catch(() => undefined);
         if (snapshot)
             deps.events.append(handle.sessionId, `${handle.sessionId}:snapshot`, {
                 kind: "compact",
@@ -595,6 +661,7 @@ export async function handleForkChatSession(req, res, deps, sourceSessionId) {
             targetSessionId: handle.sessionId,
             targetSessionFile: handle.sessionFile,
         });
+        await deps.attachSession?.(handle.sessionId).catch(() => undefined);
         const copied = deps.events.forkContextRefs({
             sourceSessionId,
             targetSessionId: handle.sessionId,
@@ -746,6 +813,7 @@ export async function handleGetChatSession(_req, res, deps, sessionId) {
         eventEpoch: deps.events.epoch(sessionId),
         session: {
             ...record,
+            messages: projectStoredMessagesWithEventOrder(record.messages, snapshot),
             composerDraft,
             activeTurnId: activeTurn?.turnId,
             turnPhase: activeTurn
@@ -755,10 +823,15 @@ export async function handleGetChatSession(_req, res, deps, sessionId) {
                 : "idle",
             pendingQuestion: pendingQuestion ?? null,
             todos: projectCurrentTodos(snapshot) ?? [],
+            goal: deps.goalRegistry?.get(sessionId) ?? null,
         },
         hasBash: true,
         sessionStats: telemetry.stats,
         usage: telemetry.usage,
+        turnTelemetry: deriveChatTurnTelemetry(snapshot),
+        contextPressure: typeof deps.runtime.getContextPressureTelemetry === "function"
+            ? deps.runtime.getContextPressureTelemetry(sessionId)
+            : undefined,
         compactions: snapshot
             .filter((event) => event.kind === "compact" ||
             event.kind === "compaction_start" ||
@@ -767,6 +840,8 @@ export async function handleGetChatSession(_req, res, deps, sessionId) {
             eventId: event.eventId,
             kind: event.kind,
             at: event.at,
+            seq: event.seq,
+            turnId: event.turnId,
             data: event.data,
         })),
         lastEventId: lastEvent?.eventId ?? null,
@@ -1070,9 +1145,162 @@ export async function handleGetChatSessionState(_req, res, deps, sessionId) {
             deferredTurns: projectDeferredTurnSummaries(record.deferredTurns ?? []),
             pendingQuestion: pendingQuestion ?? null,
             todos: projectCurrentTodos(deps.events.snapshot(sessionId)) ?? [],
+            goal: deps.goalRegistry?.get(sessionId) ?? null,
         },
     });
 }
+function goalHttpStatus(code) {
+    if (code === "GOAL_NOT_FOUND")
+        return 404;
+    if (code === "GOAL_INVALID_INPUT")
+        return 400;
+    return 409;
+}
+export async function handleChatGoal(req, res, deps, sessionId) {
+    const registry = deps.goalRegistry;
+    if (!registry) {
+        sendJson(res, 503, {
+            ok: false,
+            error: { code: "GOAL_UNAVAILABLE", message: "Goal runtime is unavailable" },
+        });
+        return;
+    }
+    if (!(await deps.store.get(sessionId))) {
+        sendJson(res, 404, {
+            ok: false,
+            error: { code: "NOT_FOUND", message: `chat session not found: ${sessionId}` },
+        });
+        return;
+    }
+    if (req.method === "GET") {
+        sendJson(res, 200, { ok: true, goal: registry.get(sessionId) });
+        return;
+    }
+    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: "GOAL_INVALID_INPUT",
+                message: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return;
+    }
+    if (req.method === "POST") {
+        const result = registry.create({
+            sessionId,
+            objective: body.objective,
+            maxRounds: typeof body.maxRounds === "number" ? body.maxRounds : undefined,
+            arm: true,
+        });
+        if (!result.ok) {
+            sendJson(res, goalHttpStatus(result.code), {
+                ok: false,
+                error: { code: result.code, message: result.message },
+                goal: result.goal,
+            });
+            return;
+        }
+        deps.goalRoundDriver?.wake(sessionId);
+        sendJson(res, 201, { ok: true, goal: result.goal });
+        return;
+    }
+    const current = registry.get(sessionId);
+    const goalId = typeof body.goalId === "string" ? body.goalId : "";
+    const revision = typeof body.revision === "number" ? body.revision : Number.NaN;
+    if (!current || !goalId || !Number.isSafeInteger(revision)) {
+        sendJson(res, current ? 400 : 404, {
+            ok: false,
+            error: {
+                code: current ? "GOAL_INVALID_INPUT" : "GOAL_NOT_FOUND",
+                message: current
+                    ? "goalId and integer revision are required"
+                    : "Goal not found",
+            },
+        });
+        return;
+    }
+    if (req.method === "DELETE") {
+        const result = registry.clear({
+            sessionId,
+            goalId,
+            expectedRevision: revision,
+        });
+        if (!result.ok) {
+            sendJson(res, goalHttpStatus(result.code), {
+                ok: false,
+                error: { code: result.code, message: result.message },
+                goal: result.goal,
+            });
+            return;
+        }
+        deps.goalRoundDriver?.cancel(sessionId);
+        sendJson(res, 200, { ok: true, goal: null });
+        return;
+    }
+    if (req.method === "PATCH") {
+        const action = typeof body.action === "string" ? body.action : "edit";
+        let phase;
+        let arm;
+        if (action === "pause") {
+            phase = "paused";
+            arm = false;
+        }
+        else if (action === "resume") {
+            phase = "active";
+            arm = true;
+        }
+        else if (action === "edit") {
+            phase = current.phase;
+            arm = current.armed;
+        }
+        else {
+            sendJson(res, 400, {
+                ok: false,
+                error: { code: "GOAL_INVALID_INPUT", message: "unsupported Goal action" },
+            });
+            return;
+        }
+        const result = registry.update({
+            sessionId,
+            goalId,
+            expectedRevision: revision,
+            phase,
+            arm,
+            ...(body.objective !== undefined ? { objective: body.objective } : {}),
+        });
+        if (!result.ok) {
+            sendJson(res, goalHttpStatus(result.code), {
+                ok: false,
+                error: { code: result.code, message: result.message },
+                goal: result.goal,
+            });
+            return;
+        }
+        if (action === "resume")
+            deps.goalRoundDriver?.wake(sessionId);
+        else if (action === "pause")
+            deps.goalRoundDriver?.cancel(sessionId);
+        sendJson(res, 200, { ok: true, goal: result.goal });
+        return;
+    }
+    sendJson(res, 405, {
+        ok: false,
+        error: { code: "METHOD_NOT_ALLOWED", message: "method not allowed" },
+    });
+}
 export async function handleAnswerUserQuestion(req, res, deps, sessionId, requestId) {
     const gate = gateMutation(req, deps);
     if (!gate.ok) {
@@ -1121,27 +1349,53 @@ export async function handleCancelUserQuestion(req, res, deps, sessionId, reques
     }
 }
 export async function handleListChatSessions(_req, res, deps) {
-    const sessions = await deps.store.list({ includeArchived: true });
+    const sessions = await listChatSessionSummaries(deps);
     sendJson(res, 200, {
         ok: true,
         schemaVersion: 2,
-        sessions: sessions.map((session) => {
-            const active = deps.events.getActiveTurn(session.sessionId);
-            return {
-                ...session,
-                activeTurnId: active?.turnId,
-                turnPhase: active?.abortRequestedAt
-                    ? "stopping"
-                    : active
-                        ? "running"
-                        : "idle",
-                deferredTurn: projectDeferredTurnSummary(session.deferredTurns?.[0]),
-                deferredTurns: projectDeferredTurnSummaries(session.deferredTurns ?? []),
-            };
-        }),
+        sessions,
         hasBash: true,
     });
 }
+/**
+ * Build sidebar-only summaries from one Workspace store without opening a
+ * runtime. Message bodies, Pi session paths and tool audit rows belong to the
+ * detail endpoint; returning them here makes the global multi-Workspace index
+ * grow with the entire chat history.
+ */
+export async function listChatSessionSummaries(deps, ownerWorkspaceId) {
+    const sessions = await deps.store.list({ includeArchived: true });
+    return sessions.map((session) => {
+        const active = deps.events?.getActiveTurn(session.sessionId);
+        const workspaceId = ownerWorkspaceId ?? session.workspaceId;
+        return {
+            sessionId: session.sessionId,
+            ...(workspaceId ? { workspaceId } : {}),
+            state: session.state,
+            createdAt: session.createdAt,
+            updatedAt: session.updatedAt,
+            ...(session.title !== undefined ? { title: session.title } : {}),
+            ...(session.displayTitle !== undefined
+                ? { displayTitle: session.displayTitle }
+                : {}),
+            ...(session.modelProvider !== undefined
+                ? { modelProvider: session.modelProvider }
+                : {}),
+            ...(session.modelId !== undefined ? { modelId: session.modelId } : {}),
+            ...(session.thinkingLevel !== undefined
+                ? { thinkingLevel: session.thinkingLevel }
+                : {}),
+            activeTurnId: active?.turnId,
+            turnPhase: active?.abortRequestedAt
+                ? "stopping"
+                : active
+                    ? "running"
+                    : "idle",
+            deferredTurn: projectDeferredTurnSummary(session.deferredTurns?.[0]),
+            deferredTurns: projectDeferredTurnSummaries(session.deferredTurns ?? []),
+        };
+    });
+}
 export async function handlePatchChatSession(req, res, deps, sessionId) {
     const gate = gateMutation(req, deps);
     if (!gate.ok) {
@@ -1644,6 +1898,22 @@ export async function handleCreateChatTurn(req, res, deps, sessionId, trustedPay
         });
         return;
     }
+    try {
+        trustedPayload?.onTurnCreated?.(turn.turnId);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        deps.events.setTurnState(sessionId, turn.turnId, "failed", {
+            code: "GOAL_ADMISSION_STALE",
+            message,
+        });
+        sendJson(res, 409, {
+            ok: false,
+            accepted: false,
+            error: { code: "GOAL_ADMISSION_STALE", message },
+        });
+        return;
+    }
     const controller = new AbortController();
     const execution = deps.turnExecutions?.register({
         sessionId,
@@ -1693,6 +1963,7 @@ export async function handleCreateChatTurn(req, res, deps, sessionId, trustedPay
                     if (placeholder)
                         emitSessionTitle(deps, sessionId, turn.turnId, placeholder);
                 },
+                persistUserMessage: trustedPayload?.persistUserMessage,
                 onOperationAccepted: (accepted) => deps.operationLinker.link({
                     sessionId,
                     turnId: turn.turnId,
@@ -1755,16 +2026,139 @@ export async function handleCreateChatTurn(req, res, deps, sessionId, trustedPay
             }
         }
         finally {
+            if (terminalState !== "settled") {
+                pauseGoalForSafety(deps, sessionId, turn.turnId);
+                deps.goalRoundDriver?.cancel(sessionId);
+            }
             execution?.resolveCompletion({
                 ok: terminalState === "settled",
                 state: terminalState,
                 error: terminalError,
             });
             deps.turnExecutions?.clear(sessionId, turn.turnId);
-            void dispatchDeferredTurn(deps, sessionId);
+            void dispatchDeferredTurn(deps, sessionId).finally(() => {
+                deps.goalRoundDriver?.wake(sessionId);
+            });
         }
     })();
 }
+function buildGoalRoundPrompt(goal) {
+    const remaining = Math.max(0, goal.maxRounds - goal.round);
+    return [
+        buildGoalContinuationContext(goal),
+        `This is autonomous Goal round ${goal.round + 1} of at most ${goal.maxRounds} (${remaining} rounds remain before this one).`,
+        "Continue from the current session state. Prefer the user's queued or newly supplied instructions when present. Use todo_write for multi-step work.",
+        "Before ending this round, call get_goal. If the objective is fully achieved, call update_goal(status=complete). If no safe progress remains, call update_goal(status=blocked) with the concrete blocker. Otherwise leave it active for the next bounded round.",
+    ].filter(Boolean).join("\n\n");
+}
+function pauseGoalForSafety(deps, sessionId, turnId) {
+    const current = deps.goalRegistry?.get(sessionId);
+    if (!current || current.phase !== "active") {
+        deps.goalRegistry?.disarm(sessionId);
+        return;
+    }
+    deps.goalRegistry?.update({
+        sessionId,
+        goalId: current.goalId,
+        expectedRevision: current.revision,
+        phase: "paused",
+        arm: false,
+        turnId,
+    });
+}
+export function linkedOperationIdsForGoal(events) {
+    const linked = new Set();
+    for (const event of events) {
+        const operationId = event.data && typeof event.data === "object"
+            ? event.data.operationId
+            : undefined;
+        if (typeof operationId !== "string" || !operationId)
+            continue;
+        if (event.kind === "operation-ref" || event.kind === "operation-status")
+            linked.add(operationId);
+        if (event.kind === "operation-unlinked")
+            linked.delete(operationId);
+    }
+    return [...linked];
+}
+/** One admission attempt used by the process-local GoalRoundDriver. */
+export async function driveGoalRound(deps, sessionId) {
+    const registry = deps.goalRegistry;
+    if (!registry || !registry.isArmed(sessionId))
+        return "idle";
+    const goal = registry.get(sessionId);
+    if (!goal || goal.phase !== "active" || !goal.armed)
+        return "idle";
+    if (goal.round >= goal.maxRounds) {
+        registry.update({
+            sessionId,
+            goalId: goal.goalId,
+            expectedRevision: goal.revision,
+            phase: "paused",
+            arm: false,
+        });
+        return "idle";
+    }
+    const record = await deps.store.get(sessionId);
+    if (!record) {
+        registry.disarm(sessionId);
+        return "idle";
+    }
+    const runtimeFacts = deps.runtime.getSessionBusyFacts(sessionId);
+    const operationStore = deps.runtime.actionContext?.operations;
+    const linkedOperationIds = linkedOperationIdsForGoal(deps.events.snapshot(sessionId));
+    const operations = operationStore
+        ? await Promise.all(linkedOperationIds.map((operationId) => operationStore.get(operationId)))
+        : [];
+    const admission = classifyGoalRoundAdmission({
+        phase: goal.phase,
+        armed: goal.armed,
+        round: goal.round,
+        maxRounds: goal.maxRounds,
+        hasQueuedUserTurn: (record.deferredTurns ?? []).some((item) => item.state === "queued" || item.state === "dispatching"),
+        hasActiveTurn: Boolean(deps.events.getActiveTurn(sessionId)),
+        runtimeBusy: Object.values(runtimeFacts).some((value) => value === true),
+        operationBusy: operations.some((operation) => Boolean(operation) && !isTerminalOperationState(operation.state)),
+    });
+    if (admission.action === "wait")
+        return "wait";
+    if (admission.action === "idle")
+        return "idle";
+    const expectedRound = goal.round + 1;
+    const clientRequestId = `goal:${goal.goalId}:${expectedRound}`;
+    const started = await startTrustedChatTurn(deps, sessionId, {
+        clientRequestId,
+        text: buildGoalRoundPrompt(goal),
+        images: [],
+        persistUserMessage: false,
+        onTurnCreated: (turnId) => {
+            const advanced = registry.beginRound({
+                sessionId,
+                goalId: goal.goalId,
+                expectedRevision: goal.revision,
+                turnId,
+            });
+            if (!advanced.ok) {
+                registry.disarm(sessionId);
+                throw new Error(advanced.message);
+            }
+        },
+    });
+    const accepted = started.body.accepted === true;
+    const turnId = started.body.turn && typeof started.body.turn === "object"
+        ? started.body.turn.turnId
+        : undefined;
+    if (!accepted || !turnId) {
+        const code = started.body.error && typeof started.body.error === "object"
+            ? String(started.body.error.code ?? "")
+            : "";
+        if (code === "TURN_ACTIVE")
+            return "wait";
+        registry.disarm(sessionId);
+        return "idle";
+    }
+    return "started";
+}
 async function emitDeferredTurnUpdate(deps, sessionId, turnId, _deferredTurn, _revision) {
     const record = await deps.store.get(sessionId);
     if (!record)
@@ -1985,6 +2379,8 @@ export async function handleAbortChatTurn(req, res, deps, sessionId, turnId) {
         });
         return;
     }
+    pauseGoalForSafety(deps, sessionId, turnId);
+    deps.goalRoundDriver?.cancel(sessionId);
     if (isTerminalTurnState(turn.state)) {
         sendJson(res, 200, {
             ok: true,
@@ -2155,6 +2551,8 @@ export async function handleDeleteChatSession(req, res, deps, sessionId) {
     }
     await deps.questionRegistry?.cancelForSession(sessionId, "SESSION_DELETED").catch(() => undefined);
     deps.todoRegistry?.clear(sessionId);
+    deps.goalRegistry?.clearRuntime(sessionId);
+    deps.goalRoundDriver?.cancel(sessionId);
     deps.runtime.dispose(sessionId);
     deps.operationLinker.clearSession(sessionId);
     deps.events.clear(sessionId);
@@ -2170,6 +2568,7 @@ export async function handleDeleteChatSession(req, res, deps, sessionId) {
         });
         return;
     }
+    await deps.detachSession?.(sessionId).catch(() => undefined);
     sendJson(res, 200, { ok: true, sessionId, disposed: true, removed: true });
 }
 export async function handleGetTaskContext(_res, res, deps, sessionId) {
@@ -2229,6 +2628,46 @@ async function handleRepoBrowser(res, deps, kind, rawPath) {
         });
     }
 }
+async function handleRepoHtmlPreview(res, deps, rawPath) {
+    try {
+        const asset = await readRepoHtmlAsset(deps.appData.repoRoot, rawPath);
+        const origin = deps.getConsoleOrigin();
+        res.writeHead(200, {
+            "Content-Type": asset.contentType,
+            "Content-Length": asset.body.byteLength,
+            "Cache-Control": "no-store",
+            "X-Content-Type-Options": "nosniff",
+            "Referrer-Policy": "no-referrer",
+            // The iframe also has an empty sandbox attribute. This response-level
+            // sandbox keeps direct/popup loads isolated, while explicit local-origin
+            // style/image/font/media sources let relative project assets render.
+            "Content-Security-Policy": [
+                "sandbox",
+                "default-src 'none'",
+                "script-src 'none'",
+                "object-src 'none'",
+                "frame-src 'none'",
+                "form-action 'none'",
+                "base-uri 'none'",
+                "connect-src 'none'",
+                `style-src 'unsafe-inline' ${origin}`,
+                `img-src data: blob: ${origin}`,
+                `font-src data: ${origin}`,
+                `media-src blob: ${origin}`,
+            ].join("; "),
+        });
+        res.end(asset.body);
+    }
+    catch (error) {
+        const failure = error instanceof RepoBrowserError
+            ? error
+            : new RepoBrowserError(500, "READ_FAILED", error instanceof Error ? error.message : String(error));
+        sendJson(res, failure.status, {
+            ok: false,
+            error: { code: failure.code, message: failure.message },
+        });
+    }
+}
 async function handlePiConfig(req, res, deps, resource) {
     try {
         if (resource === "models") {
@@ -2974,7 +3413,7 @@ async function ctxConfirmationCard(deps, sessionId, turnId, confirmationId) {
         taskId,
         confirmationId,
         expiresAt: confirmation.expiresAt,
-        inspectHref: `/inspect/?taskId=${encodeURIComponent(taskId)}#/`,
+        inspectHref: `/#/inspect?taskId=${encodeURIComponent(taskId)}`,
         humanGateToken: confirmation.humanGateToken,
         displayOnlyChallenges: [
             "source",
@@ -3000,7 +3439,7 @@ async function ctxMutationGateCard(deps, sessionId, receiptId) {
         receiptId: receipt.receiptId,
         expiresAt: receipt.expiresAt,
         humanGateToken: receipt.humanGateToken,
-        inspectHref: `/inspect/#/`,
+        inspectHref: `/#/inspect`,
     }));
 }
 function actionResultBody(result) {
@@ -3089,7 +3528,7 @@ async function handleContractApplyHumanGate(req, res, deps, sessionId, step) {
                 humanGateToken,
                 contractRevision: binding.revision,
                 contractDiffSummary: `revision ${binding.revision}; draft ${binding.draftSha256.slice(0, 12)}; observed ${binding.expectedObservedHash.slice(0, 12)}`,
-                inspectHref: `/inspect/?taskId=${encodeURIComponent(taskId)}#/`,
+                inspectHref: `/#/inspect?taskId=${encodeURIComponent(taskId)}`,
             });
             appendHumanGateCard(deps, sessionId, card);
             sendJson(res, 201, { ok: true, card });
@@ -3143,8 +3582,8 @@ async function handleContractApplyHumanGate(req, res, deps, sessionId, step) {
                 contractRevision: receipt.revision,
                 operationId,
                 inspectHref: operationId
-                    ? `/inspect/?operationId=${encodeURIComponent(operationId)}#/`
-                    : `/inspect/?taskId=${encodeURIComponent(receipt.taskId)}#/`,
+                    ? `/#/inspect?operationId=${encodeURIComponent(operationId)}`
+                    : `/#/inspect?taskId=${encodeURIComponent(receipt.taskId)}`,
             });
             appendHumanGateCard(deps, sessionId, card);
             sendJson(res, 202, {
@@ -3190,8 +3629,8 @@ async function handleContractApplyHumanGate(req, res, deps, sessionId, step) {
             contractRevision: receipt.revision,
             operationId,
             inspectHref: operationId
-                ? `/inspect/?operationId=${encodeURIComponent(operationId)}#/`
-                : `/inspect/?taskId=${encodeURIComponent(receipt.taskId)}#/`,
+                ? `/#/inspect?operationId=${encodeURIComponent(operationId)}`
+                : `/#/inspect?taskId=${encodeURIComponent(receipt.taskId)}`,
         });
         appendHumanGateCard(deps, sessionId, card);
         if (operationId)
@@ -3292,8 +3731,8 @@ async function handleDagHumanGate(req, res, deps, sessionId, step) {
             confirmationId,
             expiresAt: String(confirmation?.expiresAt ?? new Date().toISOString()),
             inspectHref: operationId
-                ? `/inspect/?operationId=${encodeURIComponent(operationId)}#/`
-                : `/inspect/?taskId=${encodeURIComponent(taskId)}#/`,
+                ? `/#/inspect?operationId=${encodeURIComponent(operationId)}`
+                : `/#/inspect?taskId=${encodeURIComponent(taskId)}`,
             ...(confirmation?.humanGateToken
                 ? { humanGateToken: confirmation.humanGateToken }
                 : {}),
@@ -3387,8 +3826,8 @@ async function handleMutationHumanGate(req, res, deps, sessionId) {
             expiresAt: receipt.expiresAt,
             operationId,
             inspectHref: operationId
-                ? `/inspect/?operationId=${encodeURIComponent(operationId)}#/`
-                : `/inspect/#/`,
+                ? `/#/inspect?operationId=${encodeURIComponent(operationId)}`
+                : `/#/inspect`,
         });
         appendHumanGateCard(deps, sessionId, card);
         if (operationId) {
@@ -3512,7 +3951,8 @@ export async function handleChatCompact(req, res, deps, sessionId) {
     }
     const rawInstructions = typeof body.instructions === "string" ? body.instructions : undefined;
     const currentTodos = projectCurrentTodos(deps.events.snapshot(sessionId));
-    const customInstructions = buildTodoCompactionInstructions(rawInstructions, currentTodos);
+    const todoInstructions = buildTodoCompactionInstructions(rawInstructions, currentTodos);
+    const customInstructions = buildGoalCompactionInstructions(todoInstructions, deps.goalRegistry?.get(sessionId) ?? null);
     const turnId = deps.events.latestTurnId(sessionId) ?? `${sessionId}:compact`;
     const compactionId = `${sessionId}:compaction:${randomUUID()}`;
     deps.events.append(sessionId, turnId, {
@@ -3649,6 +4089,17 @@ export async function handleChatRequest(req, res, deps, pathname, workspaceScope
         await handleChatCapabilities(req, res, deps);
         return true;
     }
+    const htmlPreviewRoute = matchRepoHtmlPreviewRoute(pathname);
+    if (method === "GET" && htmlPreviewRoute) {
+        if (!htmlPreviewRoute.rawPath)
+            sendJson(res, 400, {
+                ok: false,
+                error: { code: "INVALID_PATH", message: "path is required" },
+            });
+        else
+            await handleRepoHtmlPreview(res, deps, htmlPreviewRoute.rawPath);
+        return true;
+    }
     if (method === "GET" && pathname === "/api/operator/v1/chat/repo/tree") {
         await handleRepoBrowser(res, deps, "tree", url.searchParams.get("path") ?? "");
         return true;
@@ -3780,6 +4231,12 @@ export async function handleChatRequest(req, res, deps, pathname, workspaceScope
         await handleCreateChatTurn(req, res, deps, decodeURIComponent(sessionTurn[1]));
         return true;
     }
+    const sessionGoal = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/goal$/);
+    if (sessionGoal &&
+        (method === "GET" || method === "POST" || method === "PATCH" || method === "DELETE")) {
+        await handleChatGoal(req, res, deps, decodeURIComponent(sessionGoal[1]));
+        return true;
+    }
     const deferredTurn = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/deferred-turn$/);
     if (method === "PUT" && deferredTurn) {
         await handlePutDeferredTurn(req, res, deps, decodeURIComponent(deferredTurn[1]));