@sema-agent/server 7.151.0 → 7.152.0

package/dist/http/routes/diagnostics.js

@@ -5,6 +5,7 @@ import { readOutboundWiring } from "../../outbound-dispatcher.js";
 import { resolveStreamApprovalGate } from "../../tool-approval.js";
 import { sendJson, sendError } from "../send.js";
 import { gatedPerson, explicitOperatorOk, isLoopbackAddress, sendOperatorPrincipalsRequired, verifiedIdentitySource } from "../principal-gate.js";
+import { requestChannelOf } from "../request-channel.js";
 import * as facts from "../../capability-facts.js";
 import { assertNever } from "../route-ctx.js";
 import { STORE_NOT_DURABLE_CODE, StoreNotDurableError, describeStoreRoot, projectStoreDurabilityWiring, unwiredStorePosture } from "../../store-posture.js";
@@ -12,7 +13,6 @@ import { describeLocalStoreDeclaration } from "../../local-store-declaration.js"
 export function buildServerWiringGates(input) {
     const gate = resolveStreamApprovalGate({
         toolApprovalEnabled: input.toolApprovalEnabled,
-        streamApprovalEnabled: input.streamApprovalEnabled,
         backend: input.backend,
         checkpointStore: input.checkpointStore,
     });
@@ -126,17 +126,30 @@ export function assertStaticWiringConsistent(facts, logger) {
     return audit;
 }
 export function remoteWithoutVerifiedIdentity(req, config) {
-    return !isLoopbackAddress(req.socket.remoteAddress) && verifiedIdentitySource(req, config) === undefined;
+    return !requestFromThisHost(req) && verifiedIdentitySource(req, config) === undefined;
+}
+function requestFromThisHost(req) {
+    const channel = requestChannelOf(req);
+    switch (channel) {
+        case "tcp":
+            return isLoopbackAddress(req.socket.remoteAddress);
+        case "control-socket":
+            return true;
+        default: {
+            const unknownChannel = channel;
+            throw new Error(`diagnostics: request channel ${String(unknownChannel)} has no locality reading`);
+        }
+    }
 }
 export async function handleDiagnostics(req, res, match, ctx) {
     const { deps } = ctx;
     switch (match.decl.id) {
         case "diagnostics-wiring": {
-            if (!facts.operatorLane(deps).available) {
-                sendOperatorPrincipalsRequired(res);
+            if (!facts.operatorLane(deps, "operate").available) {
+                sendOperatorPrincipalsRequired(res, "operate");
                 return;
             }
-            if (!explicitOperatorOk(gatedPerson(req, deps.config), deps.config)) {
+            if (!explicitOperatorOk(gatedPerson(req, deps.config), deps.config, "operate")) {
                 sendError(res, 403, "auth.operator_only", "wiring diagnostics are operator-only");
                 return;
             }
@@ -156,8 +169,7 @@ export async function handleDiagnostics(req, res, match, ctx) {
                 configApply: deps.configApplyState?.() ?? null,
                 mcpRevocations: deps.mcpRevocationState?.() ?? null,
                 serverGates: buildServerWiringGates({
-                    toolApprovalEnabled: deps.toolApproval !== undefined,
-                    streamApprovalEnabled: deps.config.streamApproval?.enabled === true,
+                    toolApprovalEnabled: deps.config.toolApprovalEnabled === true,
                     backend: deps.backend,
                     checkpointStore: deps.checkpointStore,
                     durableApproval: deps.config.durableApproval === true,

package/dist/http/routes/images.js

@@ -49,13 +49,13 @@ export async function handleImages(req, res, match, ctx) {
         const bakes = deps.imageBakes;
         const idx = deps.imageIndex;
         const principal = gatedPerson(req, deps.config);
-        const isExplicitOperator = explicitOperatorOk(principal, deps.config);
-        const operatorLane = facts.operatorLane(deps);
+        const isExplicitOperator = explicitOperatorOk(principal, deps.config, "operate");
+        const operatorLane = facts.operatorLane(deps, "operate");
         const cfg = deps.config.imageBakes;
         const isRunner = source !== undefined && source !== null && source === cfg.runnerPrincipal;
         if (match.decl.id === "image-bake-submit") {
             if (!operatorLane.available) {
-                sendOperatorPrincipalsRequired(res);
+                sendOperatorPrincipalsRequired(res, "operate");
                 return;
             }
             if (!isExplicitOperator) {
@@ -130,7 +130,7 @@ export async function handleImages(req, res, match, ctx) {
         }
         if (match.decl.id === "image-bake-events") {
             if (!operatorLane.available) {
-                sendOperatorPrincipalsRequired(res);
+                sendOperatorPrincipalsRequired(res, "operate");
                 return;
             }
             if (!isExplicitOperator) {
@@ -152,7 +152,7 @@ export async function handleImages(req, res, match, ctx) {
         }
         if (match.decl.id === "image-bake-cancel") {
             if (!operatorLane.available) {
-                sendOperatorPrincipalsRequired(res);
+                sendOperatorPrincipalsRequired(res, "operate");
                 return;
             }
             if (!isExplicitOperator) {
@@ -264,7 +264,7 @@ export async function handleImages(req, res, match, ctx) {
         }
         if (match.decl.id === "image-bake-detail") {
             if (!operatorLane.available) {
-                sendOperatorPrincipalsRequired(res);
+                sendOperatorPrincipalsRequired(res, "operate");
                 return;
             }
             if (!isExplicitOperator) {
@@ -290,7 +290,7 @@ export async function handleImages(req, res, match, ctx) {
     if (pool.available && isIndexRouteId(match.decl.id)) {
         const idx = pool.imageIndex;
         const principal = gatedPerson(req, deps.config);
-        const operator = explicitOperatorOk(principal, deps.config);
+        const operator = explicitOperatorOk(principal, deps.config, "operate");
         const viewer = { operator, tenantId: principal ?? null };
         const q = new URLSearchParams(match.search);
         if (match.decl.id === "images-index") {
@@ -340,11 +340,11 @@ export async function handleImages(req, res, match, ctx) {
             return;
         }
         if (match.decl.id === "image-register") {
-            if (!facts.operatorLane(deps).available) {
-                sendOperatorPrincipalsRequired(res);
+            if (!facts.operatorLane(deps, "operate").available) {
+                sendOperatorPrincipalsRequired(res, "operate");
                 return;
             }
-            if (!explicitOperatorOk(principal, deps.config)) {
+            if (!explicitOperatorOk(principal, deps.config, "operate")) {
                 sendError(res, 403, "auth.operator_only", "operator only");
                 return;
             }

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

@@ -73,10 +73,10 @@ export async function handleMemoryBundle(req, res, match, ctx) {
     }
     const fact = facts.memoryBundle(deps);
     if (!fact.available && fact.why === "operator_principals_empty") {
-        sendOperatorPrincipalsRequired(res);
+        sendOperatorPrincipalsRequired(res, "operate");
         return;
     }
-    if (!explicitOperatorOk(principal, deps.config)) {
+    if (!explicitOperatorOk(principal, deps.config, "operate")) {
         sendError(res, 403, "auth.operator_only", "memory governance bundles are an operator-only deployment action");
         return;
     }
@@ -86,7 +86,7 @@ export async function handleMemoryBundle(req, res, match, ctx) {
                 sendError(res, 501, "capability.memory_engine_required", "memory governance bundles are not available on this deployment — they require a wired memory engine (MEMORY_ENGINE=on) whose backend implements the v2-c bundle composite (exportSnapshotOf / importBundleCommit); the file memory backend does, the pg/mysql memory backends do not");
                 return;
             case "operator_principals_empty":
-                sendOperatorPrincipalsRequired(res);
+                sendOperatorPrincipalsRequired(res, "operate");
                 return;
             default:
                 return assertNever(fact.why);

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

@@ -29,10 +29,10 @@ export async function handleMemoryCompliance(req, res, match, ctx) {
     }
     const fact = facts.memoryCompliance(deps);
     if (!fact.available && fact.why === "operator_principals_empty") {
-        sendOperatorPrincipalsRequired(res);
+        sendOperatorPrincipalsRequired(res, "operate");
         return;
     }
-    if (!explicitOperatorOk(principal, deps.config)) {
+    if (!explicitOperatorOk(principal, deps.config, "operate")) {
         sendError(res, 403, "auth.operator_only", "memory provenance and erasure are operator-only deployment actions");
         return;
     }
@@ -42,7 +42,7 @@ export async function handleMemoryCompliance(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/mysql memory backends do not (their control plane would land on a replica's local disk)");
                 return;
             case "operator_principals_empty":
-                sendOperatorPrincipalsRequired(res);
+                sendOperatorPrincipalsRequired(res, "operate");
                 return;
             default:
                 return assertNever(fact.why);

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

@@ -85,14 +85,14 @@ export async function handleMemoryConsolidation(req, res, match, ctx) {
                 sendError(res, 501, "feature.memory_consolidation_disabled", "memory consolidation is switched off on this deployment (MEMORY_CONSOLIDATION_DRIVER is off, or its default derived off because no cheap model is configured); turn it on to use these endpoints");
                 return;
             case "operator_principals_empty":
-                sendOperatorPrincipalsRequired(res);
+                sendOperatorPrincipalsRequired(res, "operate");
                 return;
             default:
                 return assertNever(fact.why);
         }
     }
     const faces = fact.valve;
-    if (!explicitOperatorOk(principal, deps.config)) {
+    if (!explicitOperatorOk(principal, deps.config, "operate")) {
         sendError(res, 403, "auth.operator_only", "memory consolidation is operator-only: the caller principal is not in OPERATOR_PRINCIPALS");
         return;
     }

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

@@ -118,10 +118,10 @@ export async function handleMemoryOrigin(req, res, match, ctx) {
     }
     const fact = facts.memoryOrigin(deps);
     if (!fact.available && fact.why === "operator_principals_empty") {
-        sendOperatorPrincipalsRequired(res);
+        sendOperatorPrincipalsRequired(res, "operate");
         return;
     }
-    if (!explicitOperatorOk(principal, deps.config)) {
+    if (!explicitOperatorOk(principal, deps.config, "operate")) {
         sendError(res, 403, "auth.operator_only", "memory origin marking and clearance are operator-only deployment actions");
         return;
     }
@@ -131,7 +131,7 @@ export async function handleMemoryOrigin(req, res, match, ctx) {
                 sendError(res, 501, "capability.memory_engine_required", "memory origin marking and clearance are not available on this deployment — they require a wired memory engine (MEMORY_ENGINE=on) whose backend owns the engine control plane (controlPlaneRoot); the clearance ledger and its write-ahead custody rows live in that plane, and on a backend without it they would land on one replica's local disk");
                 return;
             case "operator_principals_empty":
-                sendOperatorPrincipalsRequired(res);
+                sendOperatorPrincipalsRequired(res, "operate");
                 return;
             default:
                 return assertNever(fact.why);

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

@@ -9,7 +9,7 @@ import { gatedPerson, explicitOperatorOk, sendPrincipalRefusal, sendUnauthorized
 import { assertNever } from "../route-ctx.js";
 import { sentMemoryFaceFault } from "../memory-face-fault-reply.js";
 function layerFaceAudience(deps, principal, face, scope) {
-    if (explicitOperatorOk(principal, deps.config))
+    if (explicitOperatorOk(principal, deps.config, "operate"))
         return { kind: "operator" };
     return { kind: "layer_owner", face, withheld: (coreMessage) => deps.logger?.warn?.(face === "export" ? "memory_export_refused" : "memory_sync_refused", { scope, err: coreMessage }) };
 }
@@ -44,7 +44,7 @@ function directoryDecidesThisFace(mode) {
 async function gateMemoryScope(deps, person, scope, need) {
     if (scope === formatUserScope(person) || parseProjectLayerKey(scope)?.owner === person)
         return { kind: "allow" };
-    if (explicitOperatorOk(person, deps.config))
+    if (explicitOperatorOk(person, deps.config, "operate"))
         return { kind: "allow" };
     const directory = deps.orgMemoryDirectory;
     if (!scope.startsWith(ORG_PREFIX) || directory === undefined || !directoryDecidesThisFace(deps.config.memoryOrgAdmissionMode)) {

package/dist/http/routes/observability.js

@@ -9,10 +9,10 @@ export async function handleObservability(req, res, match, ctx) {
         case "outcomes": {
             const fact = facts.outcomeLedger(deps);
             if (!fact.available && fact.why === "operator_principals_empty") {
-                sendOperatorPrincipalsRequired(res);
+                sendOperatorPrincipalsRequired(res, "operate");
                 return;
             }
-            if (!explicitOperatorOk(gatedPerson(req, deps.config), deps.config)) {
+            if (!explicitOperatorOk(gatedPerson(req, deps.config), deps.config, "operate")) {
                 sendError(res, 403, "auth.operator_only", "the outcomes view is operator-only");
                 return;
             }
@@ -22,7 +22,7 @@ export async function handleObservability(req, res, match, ctx) {
                         sendError(res, 501, "capability.outcome_ledger_required", "no queryable outcome ledger on this worker (File sink — read the JSONL dataset directly)");
                         return;
                     case "operator_principals_empty":
-                        sendOperatorPrincipalsRequired(res);
+                        sendOperatorPrincipalsRequired(res, "operate");
                         return;
                     default:
                         return assertNever(fact.why);

package/dist/http/routes/retention-ops.js

@@ -33,11 +33,11 @@ export async function handleRetention(req, res, match, ctx) {
         sendPrincipalRefusal(res, req, deps.config);
         return;
     }
-    if (!facts.operatorLane(deps).available) {
-        sendOperatorPrincipalsRequired(res);
+    if (!facts.operatorLane(deps, "operate").available) {
+        sendOperatorPrincipalsRequired(res, "operate");
         return;
     }
-    if (!explicitOperatorOk(principal, deps.config)) {
+    if (!explicitOperatorOk(principal, deps.config, "operate")) {
         sendError(res, 403, "auth.operator_only", OPERATOR_ONLY_MESSAGE);
         return;
     }

package/dist/http/routes/rules.js

@@ -242,9 +242,9 @@ function sendImportReceipt(res, outcome) {
 function resolveTargetPrincipal(requested, caller, config) {
     if (requested === undefined || requested === caller)
         return { ok: true, principal: caller };
-    if (!facts.operatorLane({ config }).available)
+    if (!facts.operatorLane({ config }, "operate").available)
         return { ok: false, why: "operator_principals_empty" };
-    if (!explicitOperatorOk(caller, config))
+    if (!explicitOperatorOk(caller, config, "operate"))
         return { ok: false, why: "not_operator" };
     if (principalShapeProblem(requested) !== undefined)
         return { ok: false, why: "not_a_principal" };
@@ -259,7 +259,7 @@ async function handleRuleList(res, search, caller, lane, config) {
     if (!target.ok) {
         switch (target.why) {
             case "operator_principals_empty":
-                sendOperatorPrincipalsRequired(res);
+                sendOperatorPrincipalsRequired(res, "operate");
                 return;
             case "not_operator":
                 sendError(res, 403, "auth.operator_only", "reading another principal's rules is an operator-only action");
@@ -382,7 +382,7 @@ async function handleRuleWrite(res, rawBody, caller, lane, config) {
     if (!target.ok) {
         switch (target.why) {
             case "operator_principals_empty":
-                sendOperatorPrincipalsRequired(res);
+                sendOperatorPrincipalsRequired(res, "operate");
                 return;
             case "not_operator":
                 sendError(res, 403, "auth.operator_only", "writing another principal's rules is an operator-only action");
@@ -434,7 +434,7 @@ async function handleRuleRevoke(res, rawBody, caller, lane, config) {
     if (!target.ok) {
         switch (target.why) {
             case "operator_principals_empty":
-                sendOperatorPrincipalsRequired(res);
+                sendOperatorPrincipalsRequired(res, "operate");
                 return;
             case "not_operator":
                 sendError(res, 403, "auth.operator_only", "revoking another principal's rules is an operator-only action");

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

@@ -15,7 +15,8 @@
  * 拒 ⇒ 422 `request.host_posture_refused`(与提交口同码同句)。
  *
  * ── 回写:准入的词写回存储体(run 模式词的唯一来源)────────────────────────────────────────────────────────
- * 续跑腿(停驻后续跑 / 重启后续跑)按存储体顶层 `permissionMode` 重建 spec;不写回 = 下一腿回到切档前的词。写回走**认领栅栏**
+ * 续跑腿(停驻后续跑 / 重启后续跑)按存储体顶层 `permissionMode` 重建 spec;不写回 = 下一腿回到切档前的词。词与写据经改写口一笔换(写据 `switch`:
+ * 切档写下的词不是任何地板的出口,运维事后改严时续跑口照钳 —— `permission-mode-admission.ts` 顶注「写据」)。写回走**认领栅栏**
  * (checkpoint 店的 `rewriteCtxWhileClaimed`:只在**接下切档的那条腿**此刻仍持有这条 run 时写,只改既有行)—— 这条 run 终局放掉认领、同会话新 run
  * 已写下它自己的存储体之后,或这条 run 停驻、续跑的新腿(同一个 taskId 回到 running、认领仍在)已写下它续跑用的体之后,迟到的回写零写,
  * 不会拿旧腿的体盖掉新腿的。腿身份 = {@link switchLegHolds}(栅栏里问)。同一条腿上的切档在本进程按活流对象串行(引擎受理序 = 落盘序;活流只在本副本)。

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

@@ -5,7 +5,7 @@ import { admitRunById, enter } from "../owner-access.js";
 import { assertNever } from "../route-ctx.js";
 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 { admitPermissionModeWord, withStoredPermissionMode } from "../../permission-mode-admission.js";
 import { readResumeCtx, resumeCtxCorruptAnswer, resumeCtxUnreadableAnswer, resumeCtxUnsealableAnswer } from "../resume-ctx-read.js";
 import { sealCheckpointCtx } from "../checkpoint-ctx.js";
 import { serviceVersion } from "../../service-version.js";
@@ -114,7 +114,7 @@ export async function handlePermissionMode(req, res, match, ctx) {
                 }
                 let persistMiss;
                 try {
-                    const next = sealCheckpointCtx({ ...stored, body: { ...stored.body, permissionMode: admitted }, writerVersion: serviceVersion() }, deps.checkpointCtxSealing, sessionId);
+                    const next = sealCheckpointCtx({ ...withStoredPermissionMode(stored, admitted, "switch"), 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

@@ -129,20 +129,15 @@ export declare const RUN_VERBS_ROUTES: readonly [{
     readonly label: "/v1/questions/:id/respond";
     readonly methods: readonly ["POST"];
 }, {
-    readonly id: "tool-approval-respond";
+    readonly id: "task-ask-decision";
     readonly pattern: RegExp;
-    readonly label: "/v1/tool-approvals/:id/respond";
+    readonly label: "/v1/tasks/:id/asks/:askId/decision";
     readonly methods: readonly ["POST"];
 }, {
-    readonly id: "tool-approval-read";
+    readonly id: "task-ask-read";
     readonly pattern: RegExp;
-    readonly label: "/v1/tool-approvals/:id";
+    readonly label: "/v1/tasks/:id/asks/:askId";
     readonly methods: readonly ["GET"];
-}, {
-    readonly id: "task-ask-decision";
-    readonly pattern: RegExp;
-    readonly label: "/v1/tasks/:id/asks/:askId/decision";
-    readonly methods: readonly ["POST"];
 }];
 export type RunVerbsRouteId = RouteIdsOf<typeof RUN_VERBS_ROUTES>;
 //# sourceMappingURL=runs.d.ts.map

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 { 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, approvalPreambleReplays, decidedRowFacts, outcomeOfDecidedRow, parkSessionOf, presentedApprovalFrameFamily, resolveStreamApprovalGate } from "../../tool-approval.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,7 +28,7 @@ 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";
@@ -49,6 +49,7 @@ 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;
@@ -69,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;
@@ -116,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;
@@ -1174,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);
@@ -1187,15 +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 });
-        mirrorRetryAfter(res, respBody);
+        const { status, body: respBody } = await streamFact.coordinator.readAsk(match.params.taskId, match.params.askId, principal);
         sendJson(res, status, respBody);
         return;
     }
@@ -1204,7 +1201,7 @@ 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;
@@ -1222,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;
@@ -1242,16 +1239,38 @@ 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 callerIsOperator = explicitOperatorOk(principal === undefined ? undefined : personOf(principal), deps.config);
+        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();
@@ -1304,7 +1323,8 @@ export async function handleRunVerbs(req, res, match, ctx) {
                 ...noteReceipt(row),
             });
         };
-        const policyMayNotApprove = (row) => body.decision === "approve" && policyCannotAnswer(heldAskOf(storedCardDemandsAPerson(row.cardJson)), decider.decidedBy);
+        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);
@@ -1319,6 +1339,8 @@ export async function handleRunVerbs(req, res, match, ctx) {
             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),
@@ -1366,6 +1388,8 @@ export async function handleRunVerbs(req, res, match, ctx) {
                         accepted: "parked_redeemed",
                         ...decisionNoteEcho(recorded),
                         ...noteReceipt(recorded),
+                        ...(answer.rememberApplied !== undefined ? { rememberApplied: answer.rememberApplied } : {}),
+                        ...(answer.rule ?? {}),
                     });
                     return;
                 }
@@ -1388,6 +1412,10 @@ export async function handleRunVerbs(req, res, match, ctx) {
                     return;
                 }
                 case "PARKED":
+                    if (readRootGrant !== undefined) {
+                        sendError(res, 400, "request.body_shape", READ_ROOT_GRANT_LIVE_ONLY);
+                        return;
+                    }
                     await answerParked(row);
                     return;
                 case "DENIED":
@@ -1440,8 +1468,13 @@ export async function handleRunVerbs(req, res, match, ctx) {
             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 coordinator.writeAskDecision(askStore, askId, { kind: "live", batchId: row0.batchId }, row0.owner, {
                 decision: body.decision,
@@ -1473,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 });
                     }
                 }
@@ -1520,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,
@@ -1532,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;
     }
@@ -1620,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