@sema-agent/server 7.103.2 → 7.105.0

package/dist/http/routes/runs.js

@@ -1,6 +1,5 @@
 import { persistedPlaneOf } from "../../terminal.js";
-import { memoRedactedRead, memoRedactTerminalResult, redactErrorMessage, redactHead, redactLedgerEventData, redactTerminalResult } from "../../observability/run-terminal.js";
-import { isModelTextLedgerEventType } from "../../trace/ledger-events.js";
+import { memoRedactedRead, memoRedactTerminalResult, redactErrorMessage, redactHead, redactLedgerEventForRead, redactTerminalResult } from "../../observability/run-terminal.js";
 import { z } from "zod";
 import { uuidv7, mintCheckpointToken, CheckpointError, validatePendingSteer, TASK_OUTPUT_REPLAY_KINDS } from "@sema-agent/core";
 import { isTerminalRunStatus, isParkedRunStatus, runProvenElsewhere } from "../../plugins/store-contracts.js";
@@ -16,7 +15,7 @@ import { scopedIdempotencyKey } from "../idempotency.js";
 import { streamSseLog } from "../sse-log.js";
 import { bindSseLifecycle } from "../sse-lifecycle.js";
 import { buildApprovalPreamble, buildApprovalPreambleSseFrames } from "../../approval-card.js";
-import { ASK_DECISION_CONSUMER_ABSENT, outcomeOfDecidedRow, resolveStreamApprovalGate } from "../../tool-approval.js";
+import { ASK_DECISION_CONSUMER_ABSENT, SETTLED_BY_DENY_ONLY, SETTLED_BY_MUST_BE_STRING, SETTLED_BY_TOO_WIDE, judgeSettledByBody, outcomeOfDecidedRow, resolveStreamApprovalGate, respondSettledBy } from "../../tool-approval.js";
 import { MAX_DECISION_NOTE_CHARS } from "../../approval-ask-machine.js";
 import { normalizeRunEventType, screenedStoredEventData } from "../../trace/project.js";
 import { sendJson, sendError, httpErrorCode, sseHeaders } from "../send.js";
@@ -45,6 +44,7 @@ const AskDecisionBodySchema = z
         .refine((k) => k.trim() === k, { message: "idempotency key must not have leading/trailing whitespace" })
         .optional(),
     actor: z.object({ label: z.string().max(ASK_ACTOR_LABEL_MAX) }).strict().optional(),
+    settledBy: z.unknown().optional(),
 })
     .strict();
 const ASK_DECISION_CONFIRM_TIMEOUT_MS = 2_000;
@@ -125,14 +125,9 @@ async function streamRunEvents(req, res, deps, runStore, taskId, staleMs) {
             return run ? { status: run.status, updatedAt: run.updatedAt } : undefined;
         },
         getEvents: (id, after) => runStore.getEvents(id, after),
-        retainedFrom: (id) => runStore.retainedFrom(id),
         formatEvent: (ev) => {
             const type = normalizeRunEventType(ev.type);
-            const redacted = type === "done" && ev.data && typeof ev.data === "object" && ev.data.result && typeof ev.data.result === "object"
-                ? { ...ev.data, result: memoRedactTerminalResult("ev.done.result", ev.data.result) }
-                : type === "failed" ? memoRedactedRead("ev.failed", ev.data, (d) => redactLedgerEventData(type, d))
-                    : isModelTextLedgerEventType(type) ? memoRedactedRead("ev.model-text", ev.data, (d) => redactLedgerEventData(type, d))
-                        : redactLedgerEventData(type, ev.data);
+            const redacted = redactLedgerEventForRead(type, ev.data);
             const data = screenedStoredEventData(type, redacted);
             return { id: ev.seq, event: type, data: { type, ...(data ?? {}) } };
         },
@@ -1287,10 +1282,33 @@ export async function handleRunVerbs(req, res, match, ctx) {
         }
         const parsedBody = AskDecisionBodySchema.safeParse(rawBody);
         if (!parsedBody.success) {
-            sendError(res, 400, "request.body_shape", "invalid ask decision body — expected decision=approve|deny plus optional updatedInput / note / idempotencyKey / actor.label");
+            sendError(res, 400, "request.body_shape", "invalid ask decision body — expected decision=approve|deny plus optional updatedInput / note / idempotencyKey / actor.label / settledBy");
             return;
         }
         const body = parsedBody.data;
+        const settledByVerdict = judgeSettledByBody(body.settledBy, body.decision, deps.config.directDoorActive);
+        switch (settledByVerdict.kind) {
+            case "not_in_proof":
+                sendError(res, 400, "settled_by_not_in_proof", "settledBy is not supported on a direct-door worker (not covered by the decision proof)");
+                return;
+            case "deny_only":
+                sendError(res, 400, "request.field_conflict", SETTLED_BY_DENY_ONLY);
+                return;
+            case "not_string":
+                sendError(res, 400, "request.field_invalid", SETTLED_BY_MUST_BE_STRING);
+                return;
+            case "too_wide":
+                sendError(res, 400, "request.field_invalid", SETTLED_BY_TOO_WIDE);
+                return;
+            case "absent":
+            case "accepted":
+                break;
+            default: {
+                const unreachable = settledByVerdict;
+                throw new Error(`unhandled settledBy verdict: ${JSON.stringify(unreachable)}`);
+            }
+        }
+        const settledBy = settledByVerdict.kind === "accepted" ? settledByVerdict.settledBy : undefined;
         const hasUpdatedInput = typeof rawBody === "object" && rawBody !== null && "updatedInput" in rawBody;
         const taskId = match.params.taskId;
         const askId = match.params.askId;
@@ -1424,6 +1442,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
                 decisionActor: actor,
                 decisionNote: body.note ?? null,
                 idempotencyKey: body.idempotencyKey ?? null,
+                ...(settledBy !== undefined ? { settledBy: respondSettledBy({ settledBy }) } : {}),
                 ...(body.decision === "approve" && hasUpdatedInput ? { updatedInput: body.updatedInput } : {}),
             });
         }

package/dist/http/routes/session-sync.js

@@ -1,19 +1,19 @@
 import { once } from "node:events";
 import { randomBytes, createHash } from "node:crypto";
-import { sessionLogDigest, sessionLogDigestsComparable, StreamingImportValidator, SessionError, validateFileHistoryExport } from "@sema-agent/core";
+import { sessionLogDigest, sessionLogDigestsComparable, StreamingImportValidator, validateFileHistoryExport } from "@sema-agent/core";
 import { StringDecoder } from "node:string_decoder";
 import { exportSessionManifest, fileHistoryImportFace, replayFileHistory, replayPolicyRecords, overwriteWipeIncapable, wipeSessionAttendants } from "../../session-sync.js";
 import { classifySyncRelationshipByIds, SyncConflictError } from "../../session-sync-kernel.js";
 import { isUuidShape } from "../../security.js";
-import { sendJson, sendError, sendSessionPolicyError, msg } from "../send.js";
+import { sendJson, sendError, sendSessionError, sendSessionPolicyError, msg } from "../send.js";
 import { buildDisplaySafeUrl } from "../../trace/redact.js";
-import { gatedPrincipal, explicitOperatorOk } from "../principal-gate.js";
+import { gatedPrincipal, explicitOperatorOk, sendUnauthorized } from "../principal-gate.js";
 const SYNC_BLOB_MAX_BYTES = 64 * 1024 * 1024;
 const SYNC_NDJSON_LINE_MAX_BYTES = 8 * 1024 * 1024;
 const SYNC_IMPORT_BATCH = 500;
 import { SHA256_HEX_RE } from "../../digest-form.js";
 import { assertNever } from "../route-ctx.js";
-import { readSessionRulesRecords, describeSessionRulesRecordProblem } from "../../session-policy-wire.js";
+import { readSessionRulesRecords, describeSessionRulesRecordProblem, legacyToolNameProblemOf } from "../../session-policy-wire.js";
 export function createSessionSyncLocal() {
     const pendingStagings = new Map();
     const importLeases = new Map();
@@ -43,12 +43,12 @@ export async function handleSessionSync(req, res, match, ctx) {
             }
             const historyStore = deps.fileHistoryStore;
             if (historyStore === undefined) {
-                sendError(res, 501, "capability.snapshot_store_required", "session sync is not available on this deployment: file-history capture is turned off (FILE_HISTORY_CAPTURE=false), so there is no file history to export or import");
+                sendError(res, 501, "capability.snapshot_store_required", "session sync is not available on this deployment: no file-history store is wired, so there is no file history to export or import");
                 return;
             }
             const scope = sessionOwnerScopeForWrite(req);
             if (!scope.fleetWide && scope.gateOwner === null) {
-                sendError(res, 401, "auth.unauthorized", "unauthorized");
+                sendUnauthorized(res, "identity");
                 return;
             }
             const sessionId = safeDecode(match.params.sessionId);
@@ -235,6 +235,11 @@ export async function handleSessionSync(req, res, match, ctx) {
                 }
                 const policyRead = readSessionRulesRecords(body.policy);
                 if (policyRead.problem !== undefined) {
+                    const legacy = legacyToolNameProblemOf(policyRead.problem);
+                    if (legacy !== undefined) {
+                        sendError(res, 400, "rules.legacy_tool_name", `policy: ${describeSessionRulesRecordProblem(policyRead.problem)}`, { field: legacy.field, name: legacy.name });
+                        return;
+                    }
                     sendError(res, 400, "request.field_invalid", `policy: ${describeSessionRulesRecordProblem(policyRead.problem)}`);
                     return;
                 }
@@ -459,20 +464,14 @@ export async function handleSessionSync(req, res, match, ctx) {
                     }
                 }
                 catch (e) {
+                    await pending.handle.abort().catch(() => undefined);
+                    cleanupStaging(stagingId);
                     if (e instanceof PrecheckError) {
-                        await pending.handle.abort().catch(() => undefined);
-                        cleanupStaging(stagingId);
                         sendError(res, e.status, "invalid_entries", e.message);
                         return;
                     }
-                    if (e instanceof SessionError && e.code === "invalid_session") {
-                        await pending.handle.abort().catch(() => undefined);
-                        cleanupStaging(stagingId);
-                        sendError(res, 422, "invalid_entries", "staged session log failed validation");
+                    if (sendSessionError(res, e, "import"))
                         return;
-                    }
-                    await pending.handle.abort().catch(() => undefined);
-                    cleanupStaging(stagingId);
                     throw e;
                 }
                 const activeAtCommit = await deps.runStore?.getActiveTaskId(sessionId);

package/dist/http/routes/sessions-list.js

@@ -1,5 +1,6 @@
 import { isUuidV7, legacyUnownedAmnestyOpen } from "../../security.js";
 import { sendJson, sendError } from "../send.js";
+import { sendUnauthorized } from "../principal-gate.js";
 import { filterFingerprint } from "../cursor-fingerprint.js";
 import { sessionTempoOfRunStatus } from "../../plugins/store-contracts.js";
 import { assertNever } from "../route-ctx.js";
@@ -10,7 +11,7 @@ export async function handleSessionsList(req, res, match, ctx) {
         case "sessions-list": {
             const { fleetWide, gateOwner } = sessionOwnerScope(req);
             if (!fleetWide && gateOwner === null) {
-                sendError(res, 401, "auth.unauthorized", "unauthorized");
+                sendUnauthorized(res, "identity");
                 return;
             }
             const lister = deps.sessionStorage?.listSessions?.bind(deps.sessionStorage) ?? deps.runStore?.listSessions?.bind(deps.runStore);
@@ -25,7 +26,7 @@ export async function handleSessionsList(req, res, match, ctx) {
         case "sendfile-links": {
             const { fleetWide, gateOwner } = sessionOwnerScope(req);
             if (!fleetWide && gateOwner === null) {
-                sendError(res, 401, "auth.unauthorized", "unauthorized");
+                sendUnauthorized(res, "identity");
                 return;
             }
             if (!deps.sendFileLedger) {

package/dist/http/routes/sessions.js

@@ -6,10 +6,11 @@ import { redactSecrets } from "../../trace/redact.js";
 import { recordFailOpen } from "../../observability/fail-open.js";
 import { targetOutsideStoreOf } from "../../memory-store-refusal.js";
 import { MAX_SETTINGS_OUTPUT_STYLE_CHARS, MAX_SETTINGS_PERMISSION_RULES, MAX_SETTINGS_ENV_VARS, MAX_SETTINGS_ENV_KEY_CHARS, MAX_SETTINGS_ENV_VALUE_CHARS } from "../../task-settings.js";
-import { readSessionPermissionRules, describeSessionPermissionRulesProblem } from "../../session-policy-wire.js";
-import { sendJson, sendError, sendSessionPolicyError, sseHeaders } from "../send.js";
-import { gatedPrincipal, explicitOperatorOk, runOwnerReadable, sendPrincipalRefusal } from "../principal-gate.js";
+import { readWritableSessionPermissionRules, describeSessionPermissionRulesProblem } from "../../session-policy-wire.js";
+import { sendJson, sendError, sendSessionError, sendSessionPolicyError, sseHeaders } from "../send.js";
+import { gatedPrincipal, explicitOperatorOk, runOwnerReadable, sendPrincipalRefusal, sendUnauthorized } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
+import { rosterAgentId } from "./agents-roster.js";
 const MCP_STATUS_TTL_MS = 5_000;
 const MCP_MATERIALIZE_TIMEOUT_MS = 10_000;
 const A2A_STATUS_TTL_MS = 5_000;
@@ -67,6 +68,34 @@ async function readLastLegMcp(deps, sessionId, principal) {
 export async function handleSessions(req, res, match, ctx) {
     const { deps } = ctx;
     const { readJson, safeDecode, runOwnerOk, sessionOwnerScope, sessionOwnerScopeForWrite } = ctx.helpers;
+    const readOwnedSessionView = async (sessionAudit, sessionId, notFoundForm) => {
+        const ownerOf = deps.sessionStorage?.ownerOf?.bind(deps.sessionStorage);
+        if (ownerOf !== undefined) {
+            const owner = await ownerOf(sessionId);
+            if (owner === undefined) {
+                sendError(res, 404, "not_found.session", "session not found");
+                return undefined;
+            }
+            if (!runOwnerOk(req, res, owner, notFoundForm))
+                return undefined;
+        }
+        let audit;
+        try {
+            audit = await sessionAudit(sessionId);
+        }
+        catch (e) {
+            if (ownerOf !== undefined)
+                throw e;
+            throw new Error(`session view read failed before ownership could be established: ${e instanceof Error ? e.message : String(e)}`, { cause: e });
+        }
+        if (!audit) {
+            sendError(res, 404, "not_found.session", "session not found");
+            return undefined;
+        }
+        if (!runOwnerOk(req, res, audit.owner, notFoundForm))
+            return undefined;
+        return audit;
+    };
     const sse = ctx.local.sessions;
     const { mcpStatusCache, a2aStatusCache } = ctx.local.sessions;
     {
@@ -441,6 +470,8 @@ export async function handleSessions(req, res, match, ctx) {
             }
             catch (e) {
                 cleanup();
+                if (!res.headersSent && sendSessionError(res, e, "open"))
+                    return;
                 if (!res.headersSent)
                     sendError(res, 500, "internal.error", `session events failed: ${e instanceof Error ? e.message : "unknown"}`);
                 else
@@ -467,12 +498,7 @@ export async function handleSessions(req, res, match, ctx) {
                 sendError(res, 501, "capability.memory_engine_required", "memory provenance and erasure are not available on this deployment — they require a wired memory engine (MEMORY_ENGINE=on) whose backend owns the engine control plane (controlPlaneRoot); the file memory backend does, the pg/tidb memory backends do not (their control plane would land on a replica's local disk)");
                 return;
             }
-            const audit = await deps.sessionAudit(sessionId);
-            if (!audit) {
-                sendError(res, 404, "not_found.session", "session not found");
-                return;
-            }
-            if (!runOwnerOk(req, res, audit.owner, "session"))
+            if ((await readOwnedSessionView(deps.sessionAudit, sessionId, "session")) === undefined)
                 return;
             const faces = deps.memoryCompliance;
             if (faces === undefined) {
@@ -532,12 +558,7 @@ export async function handleSessions(req, res, match, ctx) {
                 sendError(res, 501, "capability.memory_engine_required", "session memory status is not available on this deployment — it requires a wired memory engine (MEMORY_ENGINE=on) whose backend owns the engine control plane (controlPlaneRoot); the file memory backend does, the pg/tidb memory backends do not (their control plane would land on a replica's local disk)");
                 return;
             }
-            const audit = await deps.sessionAudit(sessionId);
-            if (!audit) {
-                sendError(res, 404, "not_found.session", "session not found");
-                return;
-            }
-            if (!runOwnerOk(req, res, audit.owner, "session"))
+            if ((await readOwnedSessionView(deps.sessionAudit, sessionId, "session")) === undefined)
                 return;
             const face = deps.sessionMemoryStatus;
             if (face === undefined) {
@@ -581,12 +602,8 @@ export async function handleSessions(req, res, match, ctx) {
                 sendError(res, 404, "not_found.route", "not found");
                 return;
             }
-            const audit = await deps.sessionAudit(match.params.sessionId);
-            if (!audit) {
-                sendError(res, 404, "not_found.session", "session not found");
-                return;
-            }
-            if (!runOwnerOk(req, res, audit.owner))
+            const audit = await readOwnedSessionView(deps.sessionAudit, match.params.sessionId, "run");
+            if (audit === undefined)
                 return;
             const q = new URLSearchParams(match.search);
             const qi = (k) => {
@@ -636,7 +653,7 @@ export async function handleSessions(req, res, match, ctx) {
             }
             const scope = sessionOwnerScopeForWrite(req);
             if (!scope.fleetWide && scope.gateOwner === null) {
-                sendError(res, 401, "auth.unauthorized", "unauthorized");
+                sendUnauthorized(res, "identity");
                 return;
             }
             const sourceId = safeDecode(match.params.sessionId);
@@ -673,7 +690,7 @@ export async function handleSessions(req, res, match, ctx) {
             }
             const scope = sessionOwnerScopeForWrite(req);
             if (!scope.fleetWide && scope.gateOwner === null) {
-                sendError(res, 401, "auth.unauthorized", "unauthorized");
+                sendUnauthorized(res, "identity");
                 return;
             }
             const sessionId = safeDecode(match.params.sessionId);
@@ -700,6 +717,10 @@ export async function handleSessions(req, res, match, ctx) {
                 sendError(res, 409, "conflict.session_active_run", "session has an active run; cancel it before deleting", { activeTaskId: result.active });
                 return;
             }
+            if ("childrenAlive" in result) {
+                sendError(res, 409, "conflict.session_children_alive", "this session still has background agents running where this replica cannot stop them (on another replica, for example), so the delete was refused before anything was deleted — `remaining` lists their ids (the same ids `GET /v1/agents/roster` shows); retry the delete once they finish, or stop them where they run", { remaining: result.childrenAlive.map((handle) => rosterAgentId({ handle })) });
+                return;
+            }
             sendJson(res, 200, result);
             return;
         }
@@ -714,7 +735,7 @@ export async function handleSessions(req, res, match, ctx) {
             }
             const principal = gatedPrincipal(req, deps.config);
             if (deps.config.requirePrincipal && principal === undefined) {
-                sendError(res, 401, "auth.unauthorized", "unauthorized");
+                sendUnauthorized(res, "identity");
                 return;
             }
             const sessionId = safeDecode(match.params.sessionId);
@@ -756,7 +777,7 @@ export async function handleSessions(req, res, match, ctx) {
                 sendError(res, 400, "request.invalid_json", "invalid JSON body");
                 return;
             }
-            const read = readSessionPermissionRules(body.rules);
+            const read = readWritableSessionPermissionRules(body.rules);
             if (read.problem !== undefined) {
                 switch (read.problem.kind) {
                     case "not-an-object":
@@ -765,6 +786,9 @@ export async function handleSessions(req, res, match, ctx) {
                     case "field-not-string-array":
                         sendError(res, 400, "request.field_invalid", describeSessionPermissionRulesProblem(read.problem));
                         return;
+                    case "legacy-tool-name":
+                        sendError(res, 400, "rules.legacy_tool_name", describeSessionPermissionRulesProblem(read.problem), { field: read.problem.field, name: read.problem.name });
+                        return;
                     default: {
                         const unhandled = read.problem;
                         throw new Error(`unhandled SessionPermissionRules problem: ${JSON.stringify(unhandled)}`);

package/dist/http/routes/shared-memory.js

@@ -1,6 +1,6 @@
 import { SHARED_MEMORY_READ_CAP_BYTES, SharedMemoryStoreError } from "@sema-agent/core";
 import { sendJson, sendError } from "../send.js";
-import { gatedPrincipal } from "../principal-gate.js";
+import { gatedPrincipal, sendUnauthorized } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
 const RETRY_AFTER_SEC = 10;
 const HTTP_LIST_LIMIT = 100;
@@ -29,7 +29,7 @@ async function bindSnapshot(req, res, ctx) {
     const { deps } = ctx;
     const principal = gatedPrincipal(req, deps.config);
     if (!principal && deps.config.requirePrincipal === true) {
-        sendError(res, 401, "auth.unauthorized", "unauthorized");
+        sendUnauthorized(res, "identity");
         return undefined;
     }
     const provider = deps.sharedMemoryStore;

package/dist/http/routes/side-query.js

@@ -3,6 +3,7 @@ import { HttpError } from "../../security.js";
 import { isModelAllowlisted, matchCatalogModel, refusedCatalogEntry, selectableCatalog } from "../../model-select.js";
 import { modelUnavailableMessage } from "../../model-entry-refusal.js";
 import { redactSecrets } from "../../trace/redact.js";
+import { admitProviderEcho } from "../../observability/run-terminal.js";
 import { sendJson, sendError, httpErrorCode, msg } from "../send.js";
 import { gatedPrincipal, sendPrincipalRefusal } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
@@ -28,6 +29,12 @@ function isModelRole(value) {
 function passthroughModelRole(value) {
     return value;
 }
+function shapeSideQueryEcho(result) {
+    if (result.responseModel === undefined || admitProviderEcho(result.responseModel, "side-query.responseModel"))
+        return result;
+    const { responseModel: _outOfShape, ...admitted } = result;
+    return admitted;
+}
 export async function handleSideQuery(req, res, match, ctx) {
     const { deps } = ctx;
     const { readJson, rateLimited, quotaExceeded, leaseDenied } = ctx.helpers;
@@ -100,7 +107,7 @@ export async function handleSideQuery(req, res, match, ctx) {
                     deps.sideQueryAccounting?.(principal, { model: modelId, usage: rr.usage });
                     deps.metrics?.inc?.("side_query_total", { result: "ok" });
                     if (!res.writableEnded)
-                        sendJson(res, 200, result);
+                        sendJson(res, 200, shapeSideQueryEcho(result));
                 }
                 catch (e) {
                     deps.metrics?.inc?.("side_query_total", { result: "error" });

package/dist/http/routes/tasks.js

@@ -1,6 +1,6 @@
 import { redactErrorMessage, redactHead, redactTerminalResult } from "../../observability/run-terminal.js";
 import { runWithVerification, runCascade, taskNotificationDedupKey, uuidv7 } from "@sema-agent/core";
-import { graftParkToolCallId, markChildrenStoppedByUserOnAbort, resumeAtHttpStatus, HEARTBEAT_MS } from "../../runs.js";
+import { graftParkToolCallId, markChildrenStoppedByUserOnAbort, syncRefusalHttpStatus, HEARTBEAT_MS } from "../../runs.js";
 import { sealResultForExit, outwardPlane } from "../../terminal.js";
 import { withPrincipal } from "../../observability/principal-context.js";
 import { fleetRunPublisher, fleetRunLabels, fleetRunResiduals, isFleetAgentTerminalNotification } from "../../fleet/fleet-bus.js";
@@ -24,6 +24,7 @@ import { buildActiveRunConflict, toDoneFrameResult } from "../active-run-conflic
 import { commitPlacement, devicePlacementErrorBody } from "../device-placement.js";
 import { headerStr, gatedPrincipal, explicitOperatorOk } from "../principal-gate.js";
 import { failOpenTagForDroppedFrame, recordFailOpen } from "../../observability/fail-open.js";
+import { buildSyncSubmitBody } from "../sync-submit-body.js";
 import { assertNever } from "../route-ctx.js";
 const DISCONNECT_PARK_GRACE_MS = 10_000;
 function sseData(res, payload) {
@@ -31,6 +32,9 @@ function sseData(res, payload) {
     const idLine = typeof anchor === "string" && anchor.length > 0 ? `id: ${anchor}\n` : "";
     res.write(`${idLine}data: ${JSON.stringify(payload)}\n\n`);
 }
+async function mintSubmitExitResult(result, checkpoints) {
+    return redactTerminalResult(sealResultForExit(await graftParkToolCallId(result, checkpoints)));
+}
 function sendSubmitResult(res, resp) {
     const raw = resp.body;
     if (typeof raw === "object" && raw !== null && Object.hasOwn(raw, "retryAfterSec") && "retryAfterSec" in raw) {
@@ -421,7 +425,7 @@ export async function handleTasks(req, res, match, ctx) {
                                     userMsgEntryId = ev.entryId;
                                 const cancelVerbAtDone = ev.type === "done" && durableTaskId !== undefined && cancelledViaVerb.has(durableTaskId);
                                 if (ev.type === "done") {
-                                    finalResult = redactTerminalResult(sealResultForExit(await graftParkToolCallId(ev.result, deps.checkpointStore)));
+                                    finalResult = await mintSubmitExitResult(ev.result, deps.checkpointStore);
                                     if (durableTaskId && finalResult)
                                         finalResult = { ...finalResult, taskId: durableTaskId };
                                     if (cancelVerbAtDone && finalResult !== undefined) {
@@ -652,10 +656,10 @@ export async function handleTasks(req, res, match, ctx) {
                         : withApproval());
                     if (durableTaskId && deps.runStore) {
                         const finalPlane = finalResult ? outwardPlane(finalResult.terminal) : undefined;
-                        if (finalPlane?.status === "suspended" && deps.checkpointStore)
-                            await deps.runStore.setSuspended(durableTaskId);
-                        else if (finalPlane?.status === "needs_review" && deps.checkpointStore)
-                            await deps.runStore.setNeedsReview(durableTaskId);
+                        if (finalResult && finalPlane?.status === "suspended" && deps.checkpointStore)
+                            await deps.runStore.setSuspended(durableTaskId, finalResult);
+                        else if (finalResult && finalPlane?.status === "needs_review" && deps.checkpointStore)
+                            await deps.runStore.setNeedsReview(durableTaskId, finalResult);
                         else if (finalResult && finalPlane)
                             await deps.runStore.setTerminal(durableTaskId, finalPlane.status, finalResult, finalPlane.errorMessage ?? null);
                         else {
@@ -667,7 +671,7 @@ export async function handleTasks(req, res, match, ctx) {
                                     await ledgerSink.flush().catch(() => undefined);
                                     await ledgerSink.appendParked("suspended", {}).catch(() => undefined);
                                 }
-                                await deps.runStore.setSuspended(durableTaskId);
+                                await deps.runStore.setSuspended(durableTaskId, null);
                                 settleFleet("suspended");
                             }
                             else {
@@ -710,7 +714,7 @@ export async function handleTasks(req, res, match, ctx) {
                                         await ledgerSink.flush().catch(() => undefined);
                                         await ledgerSink.appendParked("suspended", {}).catch(() => undefined);
                                     }
-                                    await deps.runStore.setSuspended(durableTaskId);
+                                    await deps.runStore.setSuspended(durableTaskId, null);
                                     settleFleet("suspended");
                                 }
                                 else if (finalResult) {
@@ -859,7 +863,7 @@ export async function handleTasks(req, res, match, ctx) {
                         engineResult: result,
                     });
                 }
-                const resumeAtStatus = resumeAtHttpStatus(result);
+                const resumeAtStatus = syncRefusalHttpStatus(result);
                 if (resumeAtStatus) {
                     const resumeAtPlane = outwardPlane(result.terminal);
                     if (durableTaskId && deps.runStore)
@@ -869,22 +873,21 @@ export async function handleTasks(req, res, match, ctx) {
                         : undefined;
                     return { status: resumeAtStatus, body: { errorCode: resumeAtPlane.errorCode, error: redactErrorMessage(resumeAtPlane.errorMessage) ?? "resume-at failed", ...(retryAfterSec !== undefined ? { retryAfterSec } : {}) } };
                 }
+                const exitResult = await mintSubmitExitResult(result, deps.checkpointStore);
                 const syncPlane = outwardPlane(result.terminal);
-                if (syncPlane.status === "suspended" && deps.checkpointStore && deps.runStore && prepared.spec.sessionId) {
-                    if (durableTaskId)
-                        await deps.runStore.setSuspended(durableTaskId);
-                    return { status: 200, body: withSyncSubmitKeys({ taskId: durableTaskId, sessionId: prepared.spec.sessionId, status: "suspended" }) };
+                if (syncPlane.status === "suspended" && deps.checkpointStore && deps.runStore && durableTaskId && prepared.spec.sessionId) {
+                    await deps.runStore.setSuspended(durableTaskId, exitResult);
+                    return { status: 200, body: withSyncSubmitKeys(buildSyncSubmitBody(exitResult, { taskId: durableTaskId, sessionId: prepared.spec.sessionId, status: "suspended" })) };
                 }
-                if (syncPlane.status === "needs_review" && deps.checkpointStore && deps.runStore && prepared.spec.sessionId) {
-                    if (durableTaskId)
-                        await deps.runStore.setNeedsReview(durableTaskId);
-                    return { status: 200, body: withSyncSubmitKeys({ taskId: durableTaskId, sessionId: prepared.spec.sessionId, status: "needs_review" }) };
+                if (syncPlane.status === "needs_review" && deps.checkpointStore && deps.runStore && durableTaskId && prepared.spec.sessionId) {
+                    await deps.runStore.setNeedsReview(durableTaskId, exitResult);
+                    return { status: 200, body: withSyncSubmitKeys(buildSyncSubmitBody(exitResult, { taskId: durableTaskId, sessionId: prepared.spec.sessionId, status: "needs_review" })) };
                 }
                 if (durableTaskId && deps.runStore)
-                    await deps.runStore.setTerminal(durableTaskId, syncPlane.status, sealResultForExit(result), syncPlane.errorMessage ?? null);
+                    await deps.runStore.setTerminal(durableTaskId, syncPlane.status, exitResult, syncPlane.errorMessage ?? null);
                 finalizeTaskResult(result, principal, prepared.spec.objective, prepared.spec.sessionId);
                 noteRunOutcome(result);
-                return { status: 200, body: withSyncSubmitKeys(redactTerminalResult(sealResultForExit(result))) };
+                return { status: 200, body: withSyncSubmitKeys(buildSyncSubmitBody(exitResult)) };
             };
             const resp = await idemCache.run(idemKey, async () => withRunReceipt(await runSyncSubmitLeg()), (r) => r.status < 400);
             sendSubmitResult(res, resp);

package/dist/http/routes/trace-usage.d.ts

@@ -6,6 +6,8 @@
  *
  * ⚠️ 三块都跑在全局 service-credential 门**之前**(与 /metrics 同款待遇)——只读 traceToken 单凭据的调用方
  * (registry 中继的姿势)在全局门会被 401,挂门后=门内 traceToken 支持成死代码(1.148 a2 实机抓获)。
+ * S-672(7.105.0):门前不等于不设防 —— 本域坐在读路谓词段,先过 `dispatch.ts` 的 `readCredentialOk`
+ * (部署配了 service 凭据时要「service token / traceToken / 已验 principal」之一),块内这几道门在它之后。
  * 因此本域在 `handle()` 里的位置就是契约的一部分:必须留在鉴权门上方,顺序不可与其他域对调。本域零可变状态。
  */
 import type { IncomingMessage, ServerResponse } from "node:http";

package/dist/http/routes/trace-usage.js

@@ -1,11 +1,12 @@
 import { projectEvents, taskSummary, mapTraceEvent } from "../../trace/project.js";
+import { redactLedgerEventForRead } from "../../observability/run-terminal.js";
 import { projectArtifacts } from "../../trace/artifacts.js";
 import { usageSummary, usageSeries, usageBreakdown } from "../../usage-analytics.js";
 import { sleep } from "../sse-log.js";
 import { bindSseLifecycle } from "../sse-lifecycle.js";
 import { sendJson, sendError, sseHeaders, SSE_MAX_STREAM_MS, SSE_HEARTBEAT_IDLE_MS } from "../send.js";
 import { filterFingerprint } from "../cursor-fingerprint.js";
-import { gatedPrincipal } from "../principal-gate.js";
+import { gatedPrincipal, sendUnauthorized } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
 const TOOL_RESULT_LIMIT_CAP = 262_144;
 const TOOL_RESULT_OFFSET_CAP = 2_147_483_646;
@@ -14,7 +15,7 @@ export async function handleTraceUsage(req, res, match, ctx) {
     const { isFleetWide, safeDecode } = ctx.helpers;
     if (match.decl.id === "tasks-source-summary") {
         if (!isFleetWide(req)) {
-            sendError(res, 401, "auth.unauthorized", "unauthorized");
+            sendUnauthorized(res, "operator");
             return;
         }
         if (!deps.runStore) {
@@ -34,7 +35,7 @@ export async function handleTraceUsage(req, res, match, ctx) {
         const fleetWide = isFleetWide(req);
         const gateOwner = fleetWide ? null : (gatedPrincipal(req, deps.config) || null);
         if (!fleetWide && gateOwner === null) {
-            sendError(res, 401, "auth.unauthorized", "unauthorized");
+            sendUnauthorized(res, "identity");
             return;
         }
         if (!deps.runStore) {
@@ -84,7 +85,7 @@ export async function handleTraceUsage(req, res, match, ctx) {
             const fleetWide = isFleetWide(req);
             const jwtOwner = fleetWide ? undefined : gatedPrincipal(req, deps.config);
             if (!fleetWide && !jwtOwner) {
-                sendError(res, 401, "auth.unauthorized", "unauthorized");
+                sendUnauthorized(res, "identity");
                 return;
             }
             const q = new URLSearchParams(match.search);
@@ -220,6 +221,7 @@ async function handleToolResult(res, store, runStore, taskId, ownedRun, ref, que
         return notFound();
     sendJson(res, 200, { content: slice.content, offset: slice.offset, totalChars: slice.totalChars });
 }
+const readFaceEvent = (ev) => ({ ...ev, data: redactLedgerEventForRead(ev.type, ev.data) });
 async function handleTaskTurns(res, runStore, taskId, query) {
     const run = await runStore.getRun(taskId);
     if (!run) {
@@ -229,7 +231,7 @@ async function handleTaskTurns(res, runStore, taskId, query) {
     const limit = Math.min(100, Math.max(1, Number(query.get("limit") ?? 20) || 20));
     const cursorSeq = Number(query.get("cursor") ?? 0) || 0;
     const [events, retainedFrom] = await Promise.all([runStore.getEvents(taskId, 0), runStore.retainedFrom(taskId)]);
-    const all = projectEvents(events);
+    const all = projectEvents(events.map(readFaceEvent));
     const eligible = cursorSeq > 0 ? all.filter((t) => t.seq < cursorSeq) : all;
     const turns = eligible.slice(Math.max(0, eligible.length - limit));
     const oldest = turns[0];
@@ -244,13 +246,6 @@ async function streamTaskTrace(req, res, runStore, taskId, staleMs, search) {
     }
     const lastId = Number(req.headers["last-event-id"] ?? new URLSearchParams(search).get("from") ?? 0);
     let from = Number.isFinite(lastId) ? lastId : 0;
-    if (from > 0) {
-        const retainedFrom = await runStore.retainedFrom(taskId);
-        if (retainedFrom > from + 1) {
-            sendError(res, 416, "limit.retention_evicted", "resume point evicted past retention", { retainedFrom });
-            return;
-        }
-    }
     sseHeaders(res);
     res.write(`event: meta\ndata: ${JSON.stringify({ type: "meta", version: 1, mode: "delta", resumeFrom: from })}\n\n`);
     let closed = false;
@@ -261,7 +256,7 @@ async function streamTaskTrace(req, res, runStore, taskId, staleMs, search) {
     let lastBeat = Date.now();
     const write = (events) => {
         for (const ev of events) {
-            const out = mapTraceEvent(ev.type, ev.seq, (ev.data ?? {}));
+            const out = mapTraceEvent(ev.type, ev.seq, (readFaceEvent(ev).data ?? {}));
             if (out)
                 res.write(`id: ${ev.seq}\nevent: ${out.event}\ndata: ${JSON.stringify(out.data)}\n\n`);
             from = ev.seq;

package/dist/http/send.d.ts

@@ -8,6 +8,7 @@
  * now imports them from here, so all ~500 existing `sendJson(...)` call sites are unchanged text.
  */
 import type { ServerResponse } from "node:http";
+import { type SessionErrorFace } from "../session-error-wire.js";
 /**
  * [ref](黑板 [ref]②)—— 一条响应「是 SSE 流」的**在场标记**。
  *
@@ -71,5 +72,16 @@ export declare function httpErrorCode(status: number, code?: string): string;
  * `500 corrupt` 并点名那一列)。一只腿之后,新站点只会忘记调它,不会再各自发明一份映射。
  */
 export declare function sendSessionPolicyError(res: ServerResponse, e: unknown): boolean;
+/**
+ * S-612 —— core `SessionError` → 应答,经 {@link sessionErrorHttp} 那**一只**映射(`src/session-error-wire.ts`)。
+ * 回 `true` = 已应答,调用点 `return`;`false` = 不是 `SessionError`,或这个词在这一面上是登记过的留白(站点的既有
+ * 处置照旧 —— 通常是继续上抛到全局兜底)。
+ *
+ * 句子:属主给了固定句就发它(import 面 `invalid_session` 那一句),否则发 core 的原句过既有脱敏(`redactErrorMessage`:
+ * 不抛、有上限)。core 的 `corrupt_session` 原句只点名会话 id 与跳过计数(「Session <id> is unreadable: its log has no
+ * meta header (N of M records skipped as corrupt)」),SQL 两店的原句点名 `<表>.<列>` 与行号 —— 两者都不含盘上路径
+ * (路径只进运维日志:`session_repo_corrupt_read` 行)。
+ */
+export declare function sendSessionError(res: ServerResponse, e: unknown, face: SessionErrorFace): boolean;
 export declare function msg(e: unknown): string;
 //# sourceMappingURL=send.d.ts.map

package/dist/http/send.js

@@ -1,5 +1,7 @@
-import { SessionPolicyError } from "@sema-agent/core";
+import { SessionError, SessionPolicyError } from "@sema-agent/core";
 import { sessionPolicyErrorHttp } from "../session-policy-wire.js";
+import { sessionErrorHttp } from "../session-error-wire.js";
+import { redactErrorMessage } from "../observability/run-terminal.js";
 export const SSE_RESPONSE_MARK = Symbol("sema.http.sse-response");
 export function isSseResponse(res) {
     return res[SSE_RESPONSE_MARK] === true;
@@ -44,6 +46,15 @@ export function sendSessionPolicyError(res, e) {
     sendError(res, h.status, h.errorCode, e.message);
     return true;
 }
+export function sendSessionError(res, e, face) {
+    if (!(e instanceof SessionError))
+        return false;
+    const wire = sessionErrorHttp(e.code, face);
+    if (wire === undefined)
+        return false;
+    sendError(res, wire.status, wire.errorCode, wire.sentence ?? redactErrorMessage(e.message) ?? "session store error");
+    return true;
+}
 export function msg(e) {
     return e instanceof Error ? e.message : String(e);
 }