@sema-agent/server 7.150.0 → 7.152.0

package/dist/http/routes/runs.js

@@ -15,9 +15,9 @@ import { defaultSubagentTailBus } from "../../fleet/subagent-tail-bus.js";
 import { idemCallerOf, idemKeyOf, inflightKeyOf, submissionIdemOf } from "../idempotency.js";
 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 { buildApprovalPreamble, buildApprovalPreambleSseFrames, readClosedWordSeat } from "../../approval-card.js";
+import { heldAskOf, readDecider, retiredDecisionKeyFacts, DECIDED_BY_NOT_IN_PROOF, POLICY_CANNOT_ALLOW_PERSON_ASK } from "../../host-decision.js";
+import { ASK_DECISION_CONSUMER_ABSENT, ASK_NOT_FOUND_UNDER_TASK, approvalPreambleReplays, decidedRowFacts, outcomeOfDecidedRow, parkSessionOf, presentedApprovalFrameFamily, readPersistRuleSlot, readReadRootGrantSlot, resolveStreamApprovalGate, READ_ROOT_GRANT_LIVE_ONLY, READ_ROOT_GRANT_NOT_ACCEPTED } 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";
@@ -28,13 +28,14 @@ import { INJECTION_TIERS } from "../../trace/injection-tier.js";
 import { headerStr, gatedSubject, explicitOperatorOk, sendPrincipalRefusal, runIdentityOf } from "../principal-gate.js";
 import { ActorAssertionWire } from "@sema-agent/settings-schema";
 import * as facts from "../../capability-facts.js";
-import { assertNever } from "../route-ctx.js";
+import { assertNever, readRememberSlot } from "../route-ctx.js";
 import { readRunFace } from "../run-read-face.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, 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";
@@ -48,7 +49,13 @@ const STEER_PRIORITY_UNION = STEER_PRIORITY_WORDS.join(" | ");
 const STEER_PRIORITY_CHOICES = STEER_PRIORITY_WORDS.length <= 2 ? STEER_PRIORITY_WORDS.join(" or ") : `${STEER_PRIORITY_WORDS.slice(0, -1).join(", ")}, or ${STEER_PRIORITY_WORDS[STEER_PRIORITY_WORDS.length - 1]}`;
 const ASK_PARKING_RETRY_AFTER_SEC = 2;
 const ASK_ACTOR_LABEL_MAX = 256;
+const ASK_LEDGER_DISABLED = "the durable stream-approval ask ledger is not enabled on this worker (needs a store backend (DB_BACKEND) and DURABLE_APPROVAL)";
 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"]),
@@ -63,6 +70,9 @@ const AskDecisionBodySchema = z
     actor: z.object({ label: z.string().max(ASK_ACTOR_LABEL_MAX) }).strict().optional(),
     decidedBy: z.unknown().optional(),
     decidedVia: z.unknown().optional(),
+    remember: z.unknown().optional(),
+    persistRule: z.unknown().optional(),
+    readRootGrant: z.unknown().optional(),
 })
     .strict();
 const ASK_DECISION_CONFIRM_TIMEOUT_MS = 2_000;
@@ -110,18 +120,19 @@ async function streamRunEvents(req, res, deps, runStore, entry, taskId) {
         preamble: async (signal) => {
             const gate = resolveStreamApprovalGate({
                 toolApprovalEnabled: Boolean(deps.toolApproval),
-                streamApprovalEnabled: deps.config.streamApproval?.enabled === true,
                 backend: deps.backend,
                 checkpointStore: deps.checkpointStore,
             });
             if (!gate.active)
                 return [];
-            if (!approvalPreambleReplays({
-                streamApprovalOn: gate.active,
-                windowMs: deps.config.streamApproval?.windowMs,
-                windowMarginMs: deps.config.streamAskWindowMarginMs,
-                declaredFamilies: new Set([presentedApprovalFrameFamily(gate.active)]),
-            })) {
+            const presented = presentedApprovalFrameFamily(gate.active);
+            if (presented === undefined ||
+                !approvalPreambleReplays({
+                    streamApprovalOn: gate.active,
+                    windowMs: deps.config.streamApproval?.windowMs,
+                    windowMarginMs: deps.config.streamAskWindowMarginMs,
+                    declaredFamilies: new Set([presented]),
+                })) {
                 return [];
             }
             const store = gate.askStore;
@@ -885,7 +896,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))
@@ -914,7 +925,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?.();
@@ -982,7 +993,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;
@@ -1168,12 +1179,12 @@ export async function handleRunVerbs(req, res, match, ctx) {
         sendJson(res, status, respBody);
         return;
     }
-    if (match.decl.id === "tool-approval-respond" || match.decl.id === "tool-approval-read") {
+    if (match.decl.id === "task-ask-read") {
         if (rateLimited(req, res))
             return;
-        const approvalFact = facts.toolApproval(deps);
-        if (!approvalFact.available) {
-            sendError(res, 501, "feature.tool_approval_disabled", "live tool-approval HITL is not enabled on this worker (TOOL_APPROVAL_ENABLED)");
+        const streamFact = facts.streamApproval(deps);
+        if (!streamFact.available) {
+            sendError(res, 501, "feature.approval_ask_disabled", ASK_LEDGER_DISABLED);
             return;
         }
         const principal = gatedSubject(req, deps.config);
@@ -1181,18 +1192,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
             sendPrincipalRefusal(res, req, deps.config);
             return;
         }
-        const id = match.params.id;
-        if (match.decl.id === "tool-approval-read") {
-            const { status, body: respBody } = await approvalFact.coordinator.readApproval(id, principal);
-            sendJson(res, status, respBody);
-            return;
-        }
-        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)));
-        }
+        const { status, body: respBody } = await streamFact.coordinator.readAsk(match.params.taskId, match.params.askId, principal);
         sendJson(res, status, respBody);
         return;
     }
@@ -1201,10 +1201,11 @@ export async function handleRunVerbs(req, res, match, ctx) {
             return;
         const streamFact = facts.streamApproval(deps);
         if (!streamFact.available) {
-            sendError(res, 501, "feature.approval_ask_disabled", "the durable stream-approval ask ledger is not enabled on this worker (needs STREAM_APPROVAL_ENABLED plus a DURABLE store backend — the local backend keeps asks in memory and would lose accepted decisions on restart)");
+            sendError(res, 501, "feature.approval_ask_disabled", ASK_LEDGER_DISABLED);
             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);
@@ -1218,7 +1219,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
                 sendError(res, 400, "request.body_shape", retired.error, retired.extra);
                 return;
             }
-            sendError(res, 400, "request.body_shape", "invalid ask decision body — expected decision=approve|deny plus optional updatedInput / note / idempotencyKey / actor.label / decidedBy / decidedVia");
+            sendError(res, 400, "request.body_shape", "invalid ask decision body — expected decision=approve|deny plus optional updatedInput / note / idempotencyKey / actor.label / decidedBy / decidedVia / remember / persistRule / readRootGrant");
             return;
         }
         const body = parsedBody.data;
@@ -1238,16 +1239,39 @@ export async function handleRunVerbs(req, res, match, ctx) {
             }
         }
         const decider = decidedByReading.decider;
+        const rememberSlot = readRememberSlot(body.remember, body.decision);
+        if (rememberSlot.kind === "refused") {
+            sendError(res, 400, rememberSlot.refusal.errorCode, rememberSlot.refusal.message, rememberSlot.refusal.facts);
+            return;
+        }
+        const remember = rememberSlot.kind === "session" ? "session" : undefined;
+        const ruleSlot = readPersistRuleSlot(body.persistRule, body.decision === "approve" ? "allow" : "deny");
+        if (!ruleSlot.ok) {
+            sendError(res, 400, "request.body_shape", ruleSlot.error);
+            return;
+        }
+        const persistRule = ruleSlot.slot;
+        const grantSlot = readReadRootGrantSlot(body.readRootGrant, body.decision === "approve" && remember === undefined);
+        if (!grantSlot.ok) {
+            sendError(res, 400, "request.body_shape", grantSlot.error);
+            return;
+        }
+        if (grantSlot.grant !== undefined && !facts.readRootGrant(deps).available) {
+            sendError(res, 400, "request.body_shape", READ_ROOT_GRANT_NOT_ACCEPTED);
+            return;
+        }
+        const readRootGrant = grantSlot.grant;
         const hasUpdatedInput = typeof rawBody === "object" && rawBody !== null && "updatedInput" in rawBody;
         const taskId = match.params.taskId;
         const askId = match.params.askId;
-        const askNotFound = () => sendError(res, 404, "not_found.ask", "no such approval ask under this task (never existed, belongs to another task, or is not yours)");
+        const askNotFound = () => sendError(res, 404, "not_found.ask", ASK_NOT_FOUND_UNDER_TASK);
         const row0 = await askStore.getAsk(askId);
         if (!row0 || row0.taskId !== taskId) {
             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, "operate");
+        const askAdmission = keyAdmission("ask.decide", { subject: principal, operator: callerIsOperator }, ownerCellOf(row0.owner));
         if (askAdmission === undefined) {
             askNotFound();
             return;
@@ -1259,7 +1283,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,
@@ -1290,8 +1314,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 } : {}),
@@ -1299,7 +1323,83 @@ export async function handleRunVerbs(req, res, match, ctx) {
                 ...noteReceipt(row),
             });
         };
-        const sendTerminal = (row) => {
+        const heldLeg = coordinator.holdLiveLeg(askId);
+        const policyMayNotApprove = (row) => body.decision === "approve" && policyCannotAnswer(heldAskOf(coordinator.askDemandsAPerson(row, heldLeg)), 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 } : {}),
+                ...(remember !== undefined ? { remember } : {}),
+                ...(persistRule !== undefined ? { persistRule } : {}),
+                ...(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),
+                        ...(answer.rememberApplied !== undefined ? { rememberApplied: answer.rememberApplied } : {}),
+                        ...(answer.rule ?? {}),
+                    });
+                    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))
@@ -1308,21 +1408,15 @@ 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,
-                    });
+                    if (readRootGrant !== undefined) {
+                        sendError(res, 400, "request.body_shape", READ_ROOT_GRANT_LIVE_ONLY);
+                        return;
+                    }
+                    await answerParked(row);
                     return;
                 case "DENIED":
                 case "VOID": {
@@ -1367,23 +1461,28 @@ 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;
+        }
+        const ruleTextRefusal = persistRule !== undefined ? coordinator.precheckEditedRuleOfAskRow(row0, row0.owner, persistRule, hasUpdatedInput) : undefined;
+        if (ruleTextRefusal !== undefined) {
+            sendError(res, 400, "request.body_shape", ruleTextRefusal.message, ruleTextRefusal.ruleRejectCode !== undefined ? { ruleRejectCode: ruleTextRefusal.ruleRejectCode } : undefined);
             return;
         }
         let outcome;
-        const releaseEditMark = body.decision === "approve" && hasUpdatedInput ? deps.toolApproval?.markEditedDecisionInFlight(askId) : undefined;
+        const releaseEditMark = body.decision === "approve" && (hasUpdatedInput || readRootGrant !== undefined) ? 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) {
@@ -1407,7 +1506,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
                         confirmed.decision === body.decision &&
                         confirmed.idempotencyKey === body.idempotencyKey &&
                         !confirmed.provisional) {
-                        const settledNow = deps.toolApproval.notifyExternalDecision(askId, outcomeOfDecidedRow(confirmed)).settled;
+                        const settledNow = deps.toolApproval.notifyExternalDecision(askId, outcomeOfDecidedRow(confirmed), readRootGrant).settled;
                         deps.logger?.warn?.("ask_decision_edit_settled_after_ambiguous_commit", { taskId, askId, settled: settledNow });
                     }
                 }
@@ -1443,7 +1542,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
                 askNotFound();
                 return;
             }
-            sendTerminal(outcome.row);
+            await sendTerminal(outcome.row);
             return;
         }
         if (!decidedRowIsAuthoritative(outcome.row))
@@ -1454,7 +1553,13 @@ export async function handleRunVerbs(req, res, match, ctx) {
             sendError(res, 500, "internal.error", "the ask row was rewritten between commit and read-back — the decision that stands is not the one this request submitted; re-read the ask before acting on it");
             return;
         }
-        const settled = deps.toolApproval?.notifyExternalDecision(outcome.row.askId, outcomeOfDecidedRow(outcome.row)).settled ?? 0;
+        const live = await coordinator.settleLiveDecision(outcome.row, heldLeg, row0.owner, principal, {
+            ...(remember !== undefined ? { remember } : {}),
+            ...(readRootGrant !== undefined ? { readRootGrant } : {}),
+            ...(persistRule !== undefined ? { persistRule } : {}),
+            inputWasEdited: hasUpdatedInput,
+        });
+        const settled = live.settled;
         const forwarded = outcome.row.decision === "approve" && outcome.row.updatedInput !== undefined && settled > 0;
         sendJson(res, 200, {
             askId: outcome.row.askId,
@@ -1466,6 +1571,8 @@ export async function handleRunVerbs(req, res, match, ctx) {
             ...(settled === 0 ? { consumerState: ASK_DECISION_CONSUMER_ABSENT } : {}),
             ...decisionNoteEcho(outcome.row),
             ...noteReceipt(outcome.row),
+            ...(live.rememberApplied !== undefined ? { rememberApplied: live.rememberApplied } : {}),
+            ...(live.rule ?? {}),
         });
         return;
     }
@@ -1554,8 +1661,7 @@ export const RUN_VERBS_ROUTES = [
     { id: "run-task-stop", pattern: /^\/v1\/runs\/(?<runId>[^/]+)\/tasks\/(?<tid>[^/]+)\/stop$/, label: "/v1/runs/:id/tasks/:tid/*", methods: ["POST"] },
     { id: "elicitation-respond", pattern: /^\/v1\/elicitations\/(?<id>[^/]+)\/respond$/, label: "/v1/elicitations/:id/respond", methods: ["POST"] },
     { id: "question-respond", pattern: /^\/v1\/questions\/(?<id>[^/]+)\/respond$/, label: "/v1/questions/:id/respond", methods: ["POST"] },
-    { id: "tool-approval-respond", pattern: /^\/v1\/tool-approvals\/(?<id>[^/]+)\/respond$/, label: "/v1/tool-approvals/:id/respond", methods: ["POST"] },
-    { id: "tool-approval-read", pattern: /^\/v1\/tool-approvals\/(?<id>[^/]+)$/, label: "/v1/tool-approvals/:id", methods: ["GET"] },
     { id: "task-ask-decision", pattern: /^\/v1\/tasks\/(?<taskId>[^/]+)\/asks\/(?<askId>[^/]+)\/decision$/, label: "/v1/tasks/:id/asks/:askId/decision", methods: ["POST"] },
+    { id: "task-ask-read", pattern: /^\/v1\/tasks\/(?<taskId>[^/]+)\/asks\/(?<askId>[^/]+)$/, label: "/v1/tasks/:id/asks/:askId", methods: ["GET"] },
 ];
 //# sourceMappingURL=runs.js.map

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

@@ -9,10 +9,14 @@
  */
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { type SessionRulesRecord, type FileHistoryExport } from "@sema-agent/core";
+import { type VisibleBlobs } from "../../session-sync.js";
 import { type ImportAnchor, type StagingHandle } from "../../session-sync-kernel.js";
+import { type ListFilter } from "../../owner-faces.js";
 import type { DurableOwnerKey } from "../../owner-brands.js";
+import type { SyncLanding } from "../../plugins/store-backend.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,20 +37,29 @@ 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;
+    /** 第一阶段那一次可见性读的答案(落点 = 开暂存时门判的那一格):提交臂的文件历史重放只经它的取值口取字节 —— 许可集在第一阶段定,覆盖写的擦除不改它。 */
+    visible: VisibleBlobs;
 };
 /**
- * 导入租约的键 = 这次导入**落在哪一格属主上**(与提交的属主 CAS 同一格)+ 会话 id。一条读法:
- *  · id 被占着(活行 ∪ 在删行 —— 「被占着」的唯一读法,门读的 `occupant`)⇒ 落点是住客的属主格(`null` = 无主):所有碰得到这一行的调用方(属主、fleet、存量无主互认)共一把 —— 同一份会话上第二份在飞导入,谁发起的都 409;
- *  · id 空闲 ⇒ 还没有谁的会话,落点是这位调用方自己将成的属主(`importingPrincipal`):各占各的,先提交者得(提交的属主 CAS 要求那一格仍空着,输的那一份
- *    在提交前复判被拒)。一个主体的在飞导入既不挡、也不透给另一个主体 —— 租约键不含主体时,空闲 id 上任一主体都能占位,并从 409 读到「此 id 此刻有人在导」。
- * 键的主体只来自门读的 `occupant` 与 `importingPrincipal`(两者都派生自属主存取器的 `listFilterOf` 与门读的会话面,不另读调用方),且占租约在 `pushGateOk` 之后。
+ * 这次推送 / 拉取**落在哪一格**(落点)的唯一读法 —— 导入租约的键、blob 授予(`PUT …/sync/blobs/:hash`)、blob 可见性(第一阶段预检 · 重放取值 · `GET …/sync/history/blobs/:hash`)同读它:
+ *  · id 被占着(活行 ∪ 在删行 —— 「被占着」的唯一读法,门读的 `occupant`)⇒ 落点是住客的属主格(`null` = 无主):所有碰得到这一行的调用方(属主、fleet、存量无主互认)落在同一格;
+ *  · id 空闲 ⇒ 还没有谁的会话,落点是这位调用方自己将成的属主(fleet ⇒ 无主格;主体 ⇒ 主体):各落各的,先提交者得(提交的属主 CAS 要求那一格仍空着)。
+ * `occupied` 随落点走:只有被占着的 id,它的历史图才是 blob 的来历(空闲 id 上残留的图不是任何一位调用方持有过字节的证明)。
+ * 落点的主体只来自门读的 `occupant` 与 `listFilterOf` 的派生,不另读调用方;拉取口只在活行上放行(`pullGateOk`),那时 `occupant` 就是活行。
  */
-export declare function importLeaseKey(landingOwner: string | null, sessionId: string): string;
+export declare function landingOf(gate: {
+    readonly occupant: SessionFace | undefined;
+}, scope: ListFilter, sessionId: string): SyncLanding;
+/**
+ * 导入租约的键 = 这次导入的落点({@link landingOf}):落点属主格 + 会话 id。同一份会话上第二份在飞导入,谁发起的都 409(同一格);空闲 id 上一个主体的在飞导入既不挡、也不透给
+ * 另一个主体 —— 租约键不含落点属主格时,空闲 id 上任一主体都能占位,并从 409 读到「此 id 此刻有人在导」。占租约在 `pushGateOk` 之后。
+ */
+export declare function importLeaseKey(landing: SyncLanding): string;
 /** 一把导入租约:最后活动时刻 + 持有它的暂存 + 它守的会话 id(清扫与运维日志用,不从键里反解)。 */
 export type ImportLease = {
     at: number;