@sema-agent/server 7.149.0 → 7.151.0

package/dist/http/routes/projects.js

@@ -4,6 +4,7 @@ import { sendUnauthorized } from "../principal-gate.js";
 import { routeListFilter } from "../owner-access.js";
 import { assertNever } from "../route-ctx.js";
 import * as facts from "../../capability-facts.js";
+import { projectVisibleTo, visibleProjectOf } from "../../project-registry.js";
 import { projectByTable } from "../../trace/projection-table.js";
 export const PROJECT_NOT_FOUND_MESSAGE = "no such project";
 export const PROJECT_ROW_DISPOSITIONS = {
@@ -19,6 +20,7 @@ export const PROJECT_ROW_DISPOSITIONS = {
     registeredBy: "forward",
     registeredAt: "forward",
     archivedAt: "forward",
+    contentAttestedAt: "forward",
 };
 export function projectRowOf(id, registration) {
     return projectByTable("project", PROJECT_ROW_DISPOSITIONS, registration, { id });
@@ -37,8 +39,8 @@ function readArchivedQuery(raw) {
 export async function handleProjects(req, res, match, ctx) {
     const { deps } = ctx;
     const { safeDecode } = ctx.helpers;
-    const { fleetWide, gateOwner } = routeListFilter(req, deps, match.decl.id);
-    if (!fleetWide && gateOwner === null) {
+    const viewer = routeListFilter(req, deps, match.decl.id);
+    if (!viewer.fleetWide && viewer.gateOwner === null) {
         sendUnauthorized(res, "identity");
         return;
     }
@@ -47,7 +49,6 @@ export async function handleProjects(req, res, match, ctx) {
         sendError(res, 501, "capability.unavailable", "the project registry is not available on this deployment: projects are published only by the configuration center, and no center configuration is applied here");
         return;
     }
-    const visible = (registration) => fleetWide || registration.registeredBy === gateOwner;
     switch (match.decl.id) {
         case "projects-list": {
             const archived = readArchivedQuery(new URLSearchParams(match.search).get("archived"));
@@ -56,7 +57,7 @@ export async function handleProjects(req, res, match, ctx) {
                 return;
             }
             const projects = Object.entries(registry.registry)
-                .filter(([, registration]) => visible(registration) && (registration.archivedAt !== undefined) === archived)
+                .filter(([, registration]) => projectVisibleTo(viewer, registration) && (registration.archivedAt !== undefined) === archived)
                 .map(([id, registration]) => projectRowOf(id, registration));
             sendJson(res, 200, { projects });
             return;
@@ -68,8 +69,8 @@ export async function handleProjects(req, res, match, ctx) {
                 return;
             }
             const id = raw.toLowerCase();
-            const registration = Object.hasOwn(registry.registry, id) ? registry.registry[id] : undefined;
-            if (registration === undefined || !visible(registration)) {
+            const registration = visibleProjectOf(registry.registry, id, viewer);
+            if (registration === undefined) {
                 sendError(res, 404, "not_found.project", PROJECT_NOT_FOUND_MESSAGE);
                 return;
             }

package/dist/http/routes/retention-ops.d.ts

@@ -1,5 +1,5 @@
 /**
- * [ref] 车2 —— **托管留存的 operator 治理面**(设计稿 `docs/DESIGN-270-retention-lane.md` §5/§6)。
+ * [ref] 车2 —— **托管留存的 operator 治理面**(设计稿 `docs/[ref]-retention-lane.md` §5/§6)。
  *
  *   · `PUT    /v1/ops/retention/holds/:domain` —— 放置 legal hold;
  *   · `DELETE /v1/ops/retention/holds/:domain` —— 解除;

package/dist/http/routes/run-permission-mode.d.ts

@@ -43,7 +43,7 @@ export type PermissionModePersistMiss = (typeof PERMISSION_MODE_PERSIST_MISSES)[
  *  · run 行仍在本副本(`runProvenElsewhere` 的反面 —— 别的副本续跑了它,续跑的 CAS 赢点把行上的副本改成它自己);
  *  · 本副本这条 run 此刻登记的活流仍是接下切档的那一只(本副本上续跑的新腿登记的是另一只流对象;腿收场时按对象身份摘掉自己的)。
  */
-export declare function switchLegHolds<S extends object>(fenced: FencedRun, thisInstanceId: string | undefined, liveNow: S | undefined, switched: S): boolean;
+export declare function switchLegHolds<S extends object>(fenced: Pick<FencedRun, "instanceId">, thisInstanceId: string | undefined, liveNow: S | undefined, switched: S): boolean;
 /** 本判官改了词时回执旁的那一格(`admission`)。 */
 interface PermissionModeAdmissionNote {
     readonly requested: PermissionMode;

package/dist/http/routes/run-permission-mode.js

@@ -7,7 +7,7 @@ import * as facts from "../../capability-facts.js";
 import { PERMISSION_MODE_WORDS, coercePermissionModeStrict, parseTaskSettings } from "../../task-settings.js";
 import { admitPermissionModeWord } from "../../permission-mode-admission.js";
 import { readResumeCtx, resumeCtxCorruptAnswer, resumeCtxUnreadableAnswer, resumeCtxUnsealableAnswer } from "../resume-ctx-read.js";
-import { sealCheckpointCtx, withPermissionModeRewritten } from "../checkpoint-ctx.js";
+import { sealCheckpointCtx } from "../checkpoint-ctx.js";
 import { serviceVersion } from "../../service-version.js";
 import { recordFailOpen } from "../../observability/fail-open.js";
 export const PERMISSION_MODE_PERSIST_MISSES = ["claim_released", "context_absent", "store_failed"];
@@ -114,7 +114,7 @@ export async function handlePermissionMode(req, res, match, ctx) {
                 }
                 let persistMiss;
                 try {
-                    const next = sealCheckpointCtx({ ...withPermissionModeRewritten(stored, { ...stored.body, permissionMode: admitted }), writerVersion: serviceVersion() }, deps.checkpointCtxSealing, sessionId);
+                    const next = sealCheckpointCtx({ ...stored, body: { ...stored.body, permissionMode: admitted }, writerVersion: serviceVersion() }, deps.checkpointCtxSealing, sessionId);
                     const rewrite = await checkpointStore.rewriteCtxWhileClaimed(sessionId, next, { fence: runStore, taskId, legHolds: (fenced) => switchLegHolds(fenced, deps.instanceId, ctx.registry.steerableRuns.get(taskId), live) });
                     persistMiss = rewrite === "written" ? undefined : rewrite;
                 }

package/dist/http/routes/runs.d.ts

@@ -13,7 +13,7 @@ export declare function handleRuns(req: IncomingMessage, res: ServerResponse, ma
 /** 同上纪律(子代理 / 任务句柄 / HITL 应答段)。 */
 export declare function handleRunVerbs(req: IncomingMessage, res: ServerResponse, match: RouteMatch<RunVerbsRouteId>, ctx: RouteCtx): Promise<void>;
 /**
- * DESIGN-269 车2 件2 —— `POST /v1/runs` 的**建行 + 驱动**段,从路由体里原样搬出来的具名腿。
+ * [ref] 车2 件2 —— `POST /v1/runs` 的**建行 + 驱动**段,从路由体里原样搬出来的具名腿。
  *
  * 🔴 为什么提取:A2A 的 `message/send`(routes/a2a-serve.ts)必须走**同一条**提交链 —— 第二条提交
  * 路径就是第二个写者,而这条链上挂着 durable taskId 幂等重放、lease/治理窗 pre-admission、

package/dist/http/routes/runs.js

@@ -16,8 +16,8 @@ import { idemCallerOf, idemKeyOf, inflightKeyOf, submissionIdemOf } from "../ide
 import { streamSseLog } from "../sse-log.js";
 import { bindSseLifecycle } from "../sse-lifecycle.js";
 import { buildApprovalPreamble, buildApprovalPreambleSseFrames, readClosedWordSeat, storedCardDemandsAPerson } from "../../approval-card.js";
-import { heldAskOf, liveHostSource, readDecider, retiredDecisionKeyFacts, DECIDED_BY_NOT_IN_PROOF, POLICY_CANNOT_ALLOW_PERSON_ASK } from "../../host-decision.js";
-import { ASK_DECISION_CONSUMER_ABSENT, approvalPreambleReplays, outcomeOfDecidedRow, parkSessionOf, presentedApprovalFrameFamily, resolveStreamApprovalGate } from "../../tool-approval.js";
+import { heldAskOf, readDecider, retiredDecisionKeyFacts, DECIDED_BY_NOT_IN_PROOF, POLICY_CANNOT_ALLOW_PERSON_ASK } from "../../host-decision.js";
+import { ASK_DECISION_CONSUMER_ABSENT, approvalPreambleReplays, decidedRowFacts, outcomeOfDecidedRow, parkSessionOf, presentedApprovalFrameFamily, resolveStreamApprovalGate } from "../../tool-approval.js";
 import { MAX_DECISION_NOTE_CHARS, noteLandedOnRow, noteRecordedReceipt } from "../../approval-ask-machine.js";
 import { askRowEndingCause } from "../../approval-deny-reasons.js";
 import { normalizeRunEventType, screenedStoredEventData } from "../../trace/project.js";
@@ -30,16 +30,16 @@ import { ActorAssertionWire } from "@sema-agent/settings-schema";
 import * as facts from "../../capability-facts.js";
 import { assertNever } from "../route-ctx.js";
 import { readRunFace } from "../run-read-face.js";
-import { replayOfExistingRun } from "../submit-replay.js";
+import { replayOfExistingRun, replayOfKey } from "../submit-replay.js";
 import { mintAndDriveDurableRun } from "../durable-run-leg.js";
 import { SUBMISSION_CLAIM_FACE } from "../execution-context.js";
-import { admitRunById, admitRunRow, enter, runRowAt } from "../owner-access.js";
+import { admitRunById, admitRunByIdem, enter, readVisibleRun, sessionFactsReadOf } from "../owner-access.js";
 import { keyAdmission, ownerCellOf, recoveredSubject } from "../../owner-faces.js";
+import { engineScopeOfOwner } from "../../engine-identity.js";
 import { personOf } from "../../owner-brands.js";
 import { withSubject } from "../../observability/principal-context.js";
 import { readResumeCtx, resumeCtxUnreadableAnswer } from "../resume-ctx-read.js";
 import { storedBodyReplayAnswer, storedBodyReplayLogFields } from "../checkpoint-ctx.js";
-import { headReadOf } from "../../session-incarnation.js";
 import { serviceVersion } from "../../service-version.js";
 import { storedBodyReplayRefusal } from "../stored-body-replay.js";
 import { haltBodyIssue, steerBodyKeyIssue } from "../../request-key-closure.js";
@@ -50,6 +50,11 @@ const STEER_PRIORITY_CHOICES = STEER_PRIORITY_WORDS.length <= 2 ? STEER_PRIORITY
 const ASK_PARKING_RETRY_AFTER_SEC = 2;
 const ASK_ACTOR_LABEL_MAX = 256;
 const AskDecisionActorSchema = ActorAssertionWire.strip();
+function mirrorRetryAfter(res, body) {
+    const retryAfterSec = body !== null && typeof body === "object" ? body.retryAfterSec : undefined;
+    if (typeof retryAfterSec === "number" && Number.isFinite(retryAfterSec) && retryAfterSec >= 0)
+        res.setHeader("retry-after", String(Math.ceil(retryAfterSec)));
+}
 const AskDecisionBodySchema = z
     .object({
     decision: z.enum(["approve", "deny"]),
@@ -106,7 +111,7 @@ function sendHandleMiss(res, run, thisInstanceId) {
     }
     return false;
 }
-async function streamRunEvents(req, res, deps, runStore, taskId) {
+async function streamRunEvents(req, res, deps, runStore, entry, taskId) {
     await streamSseLog(req, res, {
         preamble: async (signal) => {
             const gate = resolveStreamApprovalGate({
@@ -135,10 +140,7 @@ async function streamRunEvents(req, res, deps, runStore, taskId) {
             return buildApprovalPreambleSseFrames(frames);
         },
         onPreambleFailure: (reason, err) => deps.logger?.warn?.("approval_preamble_failed", { taskId, reason, face: "run.events", error: err instanceof Error ? err.message : String(err ?? "") }),
-        statusOf: async (id) => {
-            const run = await runStore.getRun(id);
-            return run ? runRowAt("run-events", runStore, run) : undefined;
-        },
+        statusOf: async (id) => (await readVisibleRun(entry, runStore, id))?.row,
         getEvents: (id, after) => runStore.getEvents(id, after),
         formatEvent: (ev) => {
             const type = normalizeRunEventType(ev.type);
@@ -208,9 +210,9 @@ export async function handleRuns(req, res, match, ctx) {
                 return;
             }
             const inflight = idemCache.peek(inflightKeyOf(idem, "durable", clientTaskId));
-            const keyedRow = inflight ? undefined : await runStore.getRunByIdem(idem.key);
-            if (inflight || keyedRow) {
-                const resp = inflight ? await inflight : await replayOfExistingRun(keyedRow, { subject: submitter, idem, ...(clientTaskId !== undefined ? { clientTaskId } : {}) }, "durable", deps, runStore);
+            const replayed = inflight ? undefined : await replayOfKey({ idemKey: idem.key }, { subject: submitter, idem, ...(clientTaskId !== undefined ? { clientTaskId } : {}) }, "durable", deps, runStore);
+            const resp = inflight ? await inflight : replayed;
+            if (resp !== undefined) {
                 sendJson(res, resp.status, resp.body);
                 return;
             }
@@ -246,26 +248,23 @@ export async function handleRuns(req, res, match, ctx) {
         const entry = enter(req, res, deps, match.decl.id);
         if (entry === undefined)
             return;
-        let run;
-        let pathId;
+        let admitted;
         if (match.decl.id === "runs-by-idem") {
             const rawKey = new URLSearchParams(match.search).get("idempotencyKey");
             if (!rawKey) {
                 sendError(res, 400, "request.query_invalid", "idempotencyKey is required: pass the raw Idempotency-Key the submission was sent with");
                 return;
             }
-            run = await runStore.getRunByIdem(idemKeyOf(rawKey, idemCallerOf(req, ctx), "run"));
+            admitted = await admitRunByIdem(entry, res, runStore, idemKeyOf(rawKey, idemCallerOf(req, ctx), "run"));
         }
         else {
-            pathId = match.params.taskId;
-            run = await runStore.getRun(pathId);
+            admitted = await admitRunById(entry, res, runStore, match.params.taskId);
         }
-        const admitted = await admitRunRow(entry, res, runStore, run, pathId);
         if (admitted === undefined)
             return;
         const taskId = admitted.row.taskId;
         if (match.decl.id === "run-events") {
-            await streamRunEvents(req, res, deps, runStore, taskId);
+            await streamRunEvents(req, res, deps, runStore, entry, taskId);
         }
         else {
             sendJson(res, 200, await readRunFace(deps, runStore, admitted.row));
@@ -296,7 +295,7 @@ export async function handleRuns(req, res, match, ctx) {
                 if (token) {
                     const won = (await expireCardUnderStoredScope(cs, token)) === CARD_EXPIRE_OUTCOME.expired;
                     if (!won) {
-                        const now = await rs.getRun(taskId);
+                        const now = (await readVisibleRun(entry, rs, taskId))?.row;
                         const st = now?.status;
                         if (st !== undefined && (isParkedRunStatus(st) || st === "running")) {
                             sendError(res, 409, "conflict.approval_settled", "pending approval was settled concurrently (decided or expired) — re-check the run and retry cancel if it is still active", { taskId, status: st });
@@ -310,7 +309,7 @@ export async function handleRuns(req, res, match, ctx) {
                 else {
                     const claimed = await rs.markResuming(taskId, deps.instanceId ?? "default");
                     if (!claimed) {
-                        const now = await rs.getRun(taskId);
+                        const now = (await readVisibleRun(entry, rs, taskId))?.row;
                         const st = now?.status;
                         if (st !== undefined && (st === "running" || isParkedRunStatus(st))) {
                             sendError(res, 409, "conflict.approval_settled", "pending approval was settled concurrently (decided or expired) — re-check the run and retry cancel if it is still active", { taskId, status: st });
@@ -350,7 +349,7 @@ export async function handleRuns(req, res, match, ctx) {
                 sendError(res, 500, "internal.cancel_not_terminalized", `cancel progressed (${note}) but could not terminalize the run row (retried) — retry cancel; a stuck row is reaped after the stale window (${e instanceof Error ? e.message : String(e)})`, { taskId });
                 return;
             }
-            const finalRow = await rs.getRun(taskId).catch(() => undefined);
+            const finalRow = (await readVisibleRun(entry, rs, taskId).catch(() => undefined))?.row;
             if (finalRow && finalRow.errorCode !== "cancelled" && isTerminalRunStatus(finalRow.status)) {
                 sendJson(res, 202, { taskId, status: finalRow.status, errorCode: finalRow.errorCode ?? null, cancelRequested: finalRow.cancelRequested, note: `session unlocked; the run was terminalized concurrently (${finalRow.errorCode ?? finalRow.status}) before this cancel's write — reporting the actual ledger state` });
                 return;
@@ -361,7 +360,7 @@ export async function handleRuns(req, res, match, ctx) {
             let flagged = await runStore.requestCancel(taskId, run.owner);
             const CANCEL_RECLASSIFY_ATTEMPTS = 3;
             for (let attempt = 0; !flagged; attempt++) {
-                const now = await runStore.getRun(taskId);
+                const now = (await readVisibleRun(entry, runStore, taskId))?.row;
                 if (now !== undefined && isParkedRunStatus(now.status)) {
                     await cancelSuspended(now.result);
                     return;
@@ -505,7 +504,7 @@ export async function handleRuns(req, res, match, ctx) {
                 }
                 if (code !== "steering.not_running")
                     throw e;
-                const freshBeforePark = await runStore.getRun(taskId).catch(() => undefined);
+                const freshBeforePark = (await readVisibleRun(entry, runStore, taskId).catch(() => undefined))?.row;
                 const raced = await tryPark();
                 if (raced === "parked") {
                     sendParked(freshBeforePark?.status ?? run.status);
@@ -554,8 +553,8 @@ export async function handleRuns(req, res, match, ctx) {
             }
             return;
         }
-        const sessionHeadOf = headReadOf(deps.sessionStorage);
-        if (deps.checkpointStore && sessionHeadOf) {
+        const sessionFactsOf = sessionFactsReadOf(deps.sessionStorage);
+        if (deps.checkpointStore && sessionFactsOf) {
             const activeTaskId = await runStore.getActiveTaskId?.(run.sessionId).catch(() => undefined);
             if (activeTaskId !== undefined && activeTaskId !== null && activeTaskId !== taskId) {
                 sendNotRunning(`run is ${run.status} and its session has an ACTIVE run (${activeTaskId}) — steer that run instead`);
@@ -605,7 +604,7 @@ export async function handleRuns(req, res, match, ctx) {
                     mintResult.duplicateKey = true;
                     return;
                 }
-                const leafId = await sessionHeadOf(run.sessionId).then((h) => h?.leafId).catch(() => undefined);
+                const leafId = await sessionFactsOf(run.sessionId).then((h) => h?.leafId).catch(() => undefined);
                 if (leafId === undefined || leafId === null)
                     return;
                 const resumeRead = await readResumeCtx(cs.getCtx(run.sessionId), { sessionId: run.sessionId, opener: deps.checkpointCtxSealing });
@@ -779,7 +778,7 @@ export async function handleRuns(req, res, match, ctx) {
         catch (e) {
             if (e.code !== "steering.not_running")
                 throw e;
-            const freshRun = await runStore.getRun(taskId).catch(() => undefined);
+            const freshRun = (await readVisibleRun(entry, runStore, taskId).catch(() => undefined))?.row;
             sendNoLiveTurn(freshRun?.status ?? run.status, true);
             return;
         }
@@ -892,7 +891,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
         if (!gated)
             return;
         const { run } = gated;
-        const out = await subagentTaskOutput(target, { owner: runId, scope: run.owner ?? "default", ...(run.sessionId ? { sessionId: run.sessionId } : {}) });
+        const out = await subagentTaskOutput(target, { owner: runId, scope: engineScopeOfOwner(run.owner), ...(run.sessionId ? { sessionId: run.sessionId } : {}) });
         const details = out.details;
         if (details?.error === "not_found" || details?.type !== "background_agent") {
             if (!sendHandleMiss(res, run, deps.instanceId))
@@ -921,7 +920,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
             return;
         const { run } = gatedTail;
         const it = defaultSubagentTailBus.subscribe(target);
-        const probe = await subagentTaskOutput(target, { owner: runId, scope: run.owner ?? "default", ...(run.sessionId ? { sessionId: run.sessionId } : {}) });
+        const probe = await subagentTaskOutput(target, { owner: runId, scope: engineScopeOfOwner(run.owner), ...(run.sessionId ? { sessionId: run.sessionId } : {}) });
         const probeDetails = probe.details;
         if (probeDetails?.error === "not_found" || probeDetails?.type !== "background_agent") {
             void it.return?.();
@@ -989,7 +988,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
             return;
         const { run } = gatedB;
         const q = new URLSearchParams(match.search);
-        const access = { owner: runId, scope: run.owner ?? "default", ...(run.sessionId ? { sessionId: run.sessionId } : {}) };
+        const access = { owner: runId, scope: engineScopeOfOwner(run.owner), ...(run.sessionId ? { sessionId: run.sessionId } : {}) };
         if (q.get("filter") !== null) {
             sendError(res, 400, "request.param_unsupported", "filter is not accepted on the wire — fetch the output and filter client-side (note: the wire serves the clipped projection)");
             return;
@@ -1196,10 +1195,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
         }
         const body = await readJson(req);
         const { status, body: respBody } = await approvalFact.coordinator.respond(id, principal, body, req, { readRootGrantAccepted: facts.readRootGrant(deps).available });
-        const retryAfterSec = respBody.retryAfterSec;
-        if (typeof retryAfterSec === "number" && Number.isFinite(retryAfterSec) && retryAfterSec >= 0) {
-            res.setHeader("retry-after", String(Math.ceil(retryAfterSec)));
-        }
+        mirrorRetryAfter(res, respBody);
         sendJson(res, status, respBody);
         return;
     }
@@ -1212,6 +1208,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
             return;
         }
         const askStore = streamFact.askStore;
+        const coordinator = streamFact.coordinator;
         const principal = gatedSubject(req, deps.config);
         if (deps.config.requirePrincipal && principal === undefined) {
             sendPrincipalRefusal(res, req, deps.config);
@@ -1254,7 +1251,8 @@ export async function handleRunVerbs(req, res, match, ctx) {
             askNotFound();
             return;
         }
-        const askAdmission = keyAdmission("ask.decide", { subject: principal, operator: explicitOperatorOk(principal === undefined ? undefined : personOf(principal), deps.config) }, ownerCellOf(row0.owner));
+        const callerIsOperator = explicitOperatorOk(principal === undefined ? undefined : personOf(principal), deps.config);
+        const askAdmission = keyAdmission("ask.decide", { subject: principal, operator: callerIsOperator }, ownerCellOf(row0.owner));
         if (askAdmission === undefined) {
             askNotFound();
             return;
@@ -1266,7 +1264,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
             via: askAdmission === "row" ? "owner" : "operator",
         };
         const decidedRowIsAuthoritative = (row) => {
-            if (row.state !== "DECIDED" || row.decision !== "approve" && row.decision !== "deny" || row.provisional || row.decidedAtMs === null) {
+            if (decidedRowFacts(row) === undefined) {
                 deps.logger?.error?.("ask_decision_row_not_authoritative", {
                     taskId,
                     askId,
@@ -1297,8 +1295,8 @@ export async function handleRunVerbs(req, res, match, ctx) {
         const replayDecided = (row) => {
             const storedActor = projectDecisionActor(row.decisionActor);
             sendJson(res, 200, {
-                askId: row.askId,
-                taskId: row.taskId,
+                askId,
+                taskId,
                 decision: row.decision,
                 decidedAtMs: row.decidedAtMs,
                 ...(storedActor ? { actor: storedActor } : {}),
@@ -1306,7 +1304,78 @@ export async function handleRunVerbs(req, res, match, ctx) {
                 ...noteReceipt(row),
             });
         };
-        const sendTerminal = (row) => {
+        const policyMayNotApprove = (row) => body.decision === "approve" && policyCannotAnswer(heldAskOf(storedCardDemandsAPerson(row.cardJson)), decider.decidedBy);
+        const refusePolicyApprove = () => sendError(res, 400, "request.field_conflict", POLICY_CANNOT_ALLOW_PERSON_ASK, fieldConflictFacts("policy_person_ask", ["decidedBy", "decision"]));
+        const conflictWithFirst = (row) => {
+            const first = projectDecisionActor(row.decisionActor);
+            sendError(res, 409, "conflict.ask_decided", "this ask was already decided — the first decision stands and is echoed here", {
+                decision: row.decision,
+                decidedAtMs: row.decidedAtMs,
+                ...(first ? { actor: first } : {}),
+                ...decisionNoteEcho(row),
+            });
+        };
+        const answerParked = async (row) => {
+            const answer = await coordinator.decideParkedAsk(askStore, row, {
+                write: { decision: body.decision, decider, ...(body.note !== undefined ? { note: body.note } : {}), actor, ...(body.idempotencyKey !== undefined ? { idempotencyKey: body.idempotencyKey } : {}) },
+                ...(body.decision === "approve" && hasUpdatedInput ? { updatedInput: body.updatedInput } : {}),
+                ...(principal !== undefined ? { principal } : {}),
+                operator: callerIsOperator,
+                policyMayNotApprove: policyMayNotApprove(row),
+                httpReq: req,
+            }, body.idempotencyKey);
+            switch (answer.kind) {
+                case "standing": {
+                    const first = { decision: answer.decision, decidedAtMs: answer.decidedAtMs, decisionActor: answer.actor ?? null, decisionNote: answer.decisionNote ?? null };
+                    if (answer.byThisRequest)
+                        replayDecided(first);
+                    else
+                        conflictWithFirst(first);
+                    return;
+                }
+                case "refused":
+                    if (answer.status === 404) {
+                        askNotFound();
+                        return;
+                    }
+                    mirrorRetryAfter(res, answer.body);
+                    sendJson(res, answer.status, answer.body);
+                    return;
+                case "gone":
+                    askNotFound();
+                    return;
+                case "policy_refused":
+                    refusePolicyApprove();
+                    return;
+                case "gate_only":
+                    sendError(res, 410, "gone.ask_parked", "the in-stream window closed and this ask was parked onto the durable approval gate — decide it through that gate for the session echoed here", {
+                        sessionId: parkSessionOf(row),
+                        gateBoundCallId: row.gateBoundCallId,
+                        gateBoundInputHash: row.gateBoundInputHash,
+                    });
+                    return;
+                case "accepted": {
+                    const recorded = answer.recorded ?? { decisionNote: null };
+                    sendJson(res, 200, {
+                        ...answer.body,
+                        askId,
+                        taskId,
+                        decision: body.decision,
+                        decidedAtMs: answer.recorded?.decidedAtMs ?? Date.now(),
+                        actor,
+                        accepted: "parked_redeemed",
+                        ...decisionNoteEcho(recorded),
+                        ...noteReceipt(recorded),
+                    });
+                    return;
+                }
+                default: {
+                    const unhandled = answer;
+                    throw new Error(`unhandled parked ask answer: ${JSON.stringify(unhandled)}`);
+                }
+            }
+        };
+        const sendTerminal = async (row) => {
             switch (row.state) {
                 case "DECIDED": {
                     if (!syncLiveFromDecidedRow(row))
@@ -1315,21 +1384,11 @@ export async function handleRunVerbs(req, res, match, ctx) {
                         replayDecided(row);
                         return;
                     }
-                    const first = projectDecisionActor(row.decisionActor);
-                    sendError(res, 409, "conflict.ask_decided", "this ask was already decided — the first decision stands and is echoed here", {
-                        decision: row.decision,
-                        decidedAtMs: row.decidedAtMs,
-                        ...(first ? { actor: first } : {}),
-                        ...decisionNoteEcho(row),
-                    });
+                    conflictWithFirst(row);
                     return;
                 }
                 case "PARKED":
-                    sendError(res, 410, "gone.ask_parked", "the in-stream window closed and this ask was parked onto the durable approval gate — decide it through that gate for the session echoed here", {
-                        sessionId: parkSessionOf(row),
-                        gateBoundCallId: row.gateBoundCallId,
-                        gateBoundInputHash: row.gateBoundInputHash,
-                    });
+                    await answerParked(row);
                     return;
                 case "DENIED":
                 case "VOID": {
@@ -1374,23 +1433,23 @@ export async function handleRunVerbs(req, res, match, ctx) {
             }
         }
         if (row0.state !== "STREAM_PENDING") {
-            sendTerminal(row0);
+            await sendTerminal(row0);
             return;
         }
-        if (body.decision === "approve" && policyCannotAnswer(heldAskOf(storedCardDemandsAPerson(row0.cardJson)), decider.decidedBy)) {
-            sendError(res, 400, "request.field_conflict", POLICY_CANNOT_ALLOW_PERSON_ASK, fieldConflictFacts("policy_person_ask", ["decidedBy", "decision"]));
+        if (policyMayNotApprove(row0)) {
+            refusePolicyApprove();
             return;
         }
         let outcome;
         const releaseEditMark = body.decision === "approve" && hasUpdatedInput ? deps.toolApproval?.markEditedDecisionInFlight(askId) : undefined;
         try {
-            outcome = await askStore.decideAsk(askId, row0.batchId, row0.owner, {
+            outcome = await coordinator.writeAskDecision(askStore, askId, { kind: "live", batchId: row0.batchId }, row0.owner, {
                 decision: body.decision,
-                decisionActor: actor,
-                decisionNote: body.note ?? null,
-                idempotencyKey: body.idempotencyKey ?? null,
-                ...liveHostSource(decider),
-                ...(body.decision === "approve" && hasUpdatedInput ? { updatedInput: body.updatedInput } : {}),
+                decider,
+                actor,
+                ...(body.note !== undefined ? { note: body.note } : {}),
+                ...(body.idempotencyKey !== undefined ? { idempotencyKey: body.idempotencyKey } : {}),
+                ...(hasUpdatedInput ? { updatedInput: body.updatedInput } : {}),
             });
         }
         catch (err) {
@@ -1450,7 +1509,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
                 askNotFound();
                 return;
             }
-            sendTerminal(outcome.row);
+            await sendTerminal(outcome.row);
             return;
         }
         if (!decidedRowIsAuthoritative(outcome.row))
@@ -1509,9 +1568,9 @@ async function createDurableRunHeld(req, res, ctx, prepared, idem) {
     const submitter = gatedSubject(req, deps.config);
     const caller = { subject: submitter, idem, ...(clientTaskId !== undefined ? { clientTaskId } : {}) };
     if (clientTaskId) {
-        const existing = await runStore.getRun(clientTaskId);
-        if (existing)
-            return await replayOfExistingRun(existing, caller, "durable", deps, runStore);
+        const replayed = await replayOfKey({ taskId: clientTaskId }, caller, "durable", deps, runStore);
+        if (replayed !== undefined)
+            return replayed;
     }
     if ((await leaseDenied(req, res, seat)) || (await usageWindowDenied(req, res, seat)))
         return null;

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

@@ -1,6 +1,6 @@
 import { memorySyncReportOf } from "@sema-agent/core";
 import { sendJson, sendError } from "../send.js";
-import { admitSessionById, enter } from "../owner-access.js";
+import { admitSessionById, enter, latestRunIdOf, readVisibleSession } from "../owner-access.js";
 import { assertNever } from "../route-ctx.js";
 import * as facts from "../../capability-facts.js";
 import { leafOfAdmittedHead } from "../../session-incarnation.js";
@@ -94,7 +94,6 @@ export async function handleSessionMemorySync(req, res, match, ctx) {
                 sendError(res, 400, "request.path_malformed", "session id segment is not valid percent-encoding");
                 return;
             }
-            const readHead = () => sessionStorage.headOf(sessionId);
             const admitted = await admitSessionById(entry, res, sessionStorage, sessionId);
             if (admitted === undefined)
                 return;
@@ -122,10 +121,10 @@ export async function handleSessionMemorySync(req, res, match, ctx) {
             const quiet = async () => {
                 if ((await runStore.getActiveTaskId(sessionId)) !== undefined)
                     return false;
-                if ((await runStore.latestRunForSession(sessionId))?.taskId !== observedTaskId)
+                if ((await latestRunIdOf(runStore, sessionId)) !== observedTaskId)
                     return false;
-                const now = await readHead();
-                return now !== undefined && leafOfAdmittedHead(now) === sourceRevision;
+                const now = await readVisibleSession(entry, sessionStorage, sessionId);
+                return now !== undefined && leafOfAdmittedHead(now.row) === sourceRevision;
             };
             const fenced = () => reportOf({ target, sourceRevision, scopes, refused: { code: "session_active", message: SESSION_ACTIVE_SYNC_MESSAGE } });
             let report;

package/dist/http/routes/session-sync.d.ts

@@ -13,6 +13,7 @@ import { type ImportAnchor, type StagingHandle } from "../../session-sync-kernel
 import type { DurableOwnerKey } from "../../owner-brands.js";
 import type { RouteCtx, RouteMatch, RouteIdsOf } from "../route-ctx.js";
 import { type SessionRowPatch } from "../../session-row.js";
+import { type SessionFace } from "../../session-incarnation.js";
 export type PendingStaging = {
     handle: StagingHandle;
     realSessionId: string;
@@ -33,9 +34,9 @@ export type PendingStaging = {
     /** The principal that opened this staging, kept as the handle's owner key (`null` = a fleet caller opened it) — a different caller may not drive it
      *  (404, no oracle; compared through `owner-faces.ts` `sameKey` only). */
     openedBy: DurableOwnerKey | null;
-    /** The owner cell the gate judged when it opened this staging (head-read reading `headOf(id)?.owner`: `undefined` = no such session) — the commit lands only on
-     *  this same cell (`StagedCommitOptions.expectedOwner`, `session-sync-kernel.ts`); `owner` above (the re-stamped importing principal) is derived from it for a fleet caller. */
-    expectedOwner: string | null | undefined;
+    /** The live occupant the gate judged when it opened this staging (owner ∧ incarnation, the head read: `undefined` = no live session) — the commit lands only on
+     *  this same occupant (`StagedCommitOptions.expectedOccupant`, `session-sync-kernel.ts`); `owner` above (the re-stamped importing principal) is derived from its owner for a fleet caller. */
+    expectedOccupant: SessionFace | undefined;
     /** 开这张暂存时占下的导入租约的键({@link importLeaseKey});续期与放掉都按它,不再从会话 id 重算。 */
     leaseKey: string;
 };