@tea-agent/loop-agent 0.39.0-next.3 → 0.39.0-next.30

package/dist/worker/console/operator-actions.js

@@ -1,5 +1,6 @@
 import { access, readFile } from "node:fs/promises";
-import { buildOperatorCapabilitiesDocument } from "../../shared/operator/capabilities.js";
+import { buildOperatorCapabilitiesDocument, OFFICIAL_TAIL_ACTION_IDS, } from "../../shared/operator/capabilities.js";
+import { DAG_RERUN_PROMPT_OVERRIDE_ENV, isDagRerunPromptOverrideEnabled, MAX_DAG_RERUN_PROMPT_OVERRIDE_CHARS, } from "../../shared/dag-prompt-override.js";
 import { buildOperatorResult, operatorFailed, operatorSucceeded, } from "../../shared/operator/envelope.js";
 import { CANONICAL_TASK_ID_PATTERN, formatLocalBusinessDate, getTaskPaths, loadTaskConfig, } from "../../task/runtime.js";
 import { diffTaskContract, validateDraftForTask, } from "../../task/contract/index.js";
@@ -11,6 +12,7 @@ import { resolveLatestDagRunIdForTask } from "./resolve-dag-run-for-task.js";
 import { repoFingerprintV1 } from "./repo-fingerprint.js";
 import { scheduleOperation, } from "./operation-runner.js";
 import { readinessGateFailure, } from "./pi-readiness.js";
+import { validatePiModelMatrixTiers, writePiModelMatrix, } from "./harness-pi-model-matrix.js";
 import { isAssessmentFreshForDraft } from "./interview/assessment.js";
 import { applyGrillMeAnswer, draftSummary, emptyDraft, isDraftStructurallyComplete, nextGrillMeQuestion, } from "./interview/grill-me.js";
 import { toCanonicalDraftForCli, } from "./draft-store.js";
@@ -400,6 +402,85 @@ async function runReadCli(ctx, args, command) {
         });
     }
 }
+/**
+ * Parse and bound the experimental promptOverrides action param. The env
+ * switch is checked separately so disabled deployments fail closed before any
+ * staging happens. `mode` defaults to "replace"; "append" keeps the frozen
+ * base prompt and only appends the operator text as a marked addendum.
+ */
+function parsePromptOverrideParams(raw) {
+    if (raw === undefined || raw === null)
+        return { kind: "ok", overrides: [] };
+    if (!Array.isArray(raw)) {
+        return {
+            kind: "error",
+            message: "promptOverrides must be an array of {nodeId, prompt, mode?}",
+        };
+    }
+    if (raw.length === 0)
+        return { kind: "ok", overrides: [] };
+    if (raw.length > 8) {
+        return { kind: "error", message: "promptOverrides supports at most 8 nodes" };
+    }
+    const overrides = [];
+    const seen = new Set();
+    for (const item of raw) {
+        if (!item || typeof item !== "object") {
+            return {
+                kind: "error",
+                message: "promptOverrides entries must be objects {nodeId, prompt, mode?}",
+            };
+        }
+        const record = item;
+        const nodeId = typeof record.nodeId === "string" ? record.nodeId.trim() : "";
+        const prompt = typeof record.prompt === "string" ? record.prompt : "";
+        const mode = record.mode === undefined || record.mode === null
+            ? undefined
+            : typeof record.mode === "string"
+                ? record.mode
+                : "invalid";
+        if (!nodeId) {
+            return { kind: "error", message: "promptOverrides nodeId is required" };
+        }
+        if (seen.has(nodeId)) {
+            return {
+                kind: "error",
+                message: `promptOverrides contains duplicate nodeId: ${nodeId}`,
+            };
+        }
+        seen.add(nodeId);
+        if (mode !== undefined && mode !== "append" && mode !== "replace") {
+            return {
+                kind: "error",
+                message: `promptOverrides mode for ${nodeId} must be append or replace`,
+            };
+        }
+        if (!prompt.trim() || prompt.length > MAX_DAG_RERUN_PROMPT_OVERRIDE_CHARS) {
+            return {
+                kind: "error",
+                message: `promptOverrides prompt for ${nodeId} must be 1-${MAX_DAG_RERUN_PROMPT_OVERRIDE_CHARS} characters`,
+            };
+        }
+        overrides.push(mode === undefined ? { nodeId, prompt } : { nodeId, prompt, mode });
+    }
+    return { kind: "ok", overrides };
+}
+/** Stage override bodies under app-data and build `--prompt-override` CLI
+ *  args. The flag carries the mode: `--prompt-override-append` for append. */
+async function buildPromptOverrideCliArgs(ctx, overrides) {
+    const args = [];
+    for (const override of overrides) {
+        const staged = await stageUtf8Text(ctx.appData, override.prompt, {
+            extension: ".md",
+            label: `prompt-override-${override.nodeId}`,
+        });
+        const flag = override.mode === "append"
+            ? "--prompt-override-append"
+            : "--prompt-override";
+        args.push(flag, `${override.nodeId}@${staged.path}`);
+    }
+    return args;
+}
 async function acceptOperation(ctx, input) {
     const created = await ctx.operations.create({
         clientRequestId: input.clientRequestId,
@@ -671,6 +752,80 @@ export async function dispatchOperatorAction(ctx, req) {
             const body = await runReadCli(ctx, ["dag", "report", "--run-id", runId, "--json"], "dag report");
             return { kind: "sync", status: body.ok ? 200 : 400, body };
         }
+        case "dagDoctor": {
+            const runId = str(p.runId) ?? str(p.dagRunId);
+            const args = ["dag", "doctor"];
+            if (runId)
+                args.push("--run-id", runId);
+            const body = await runReadCli(ctx, args, "dag doctor");
+            return { kind: "sync", status: body.ok ? 200 : 400, body };
+        }
+        case "dagStatus": {
+            const runId = str(p.runId) ?? str(p.dagRunId);
+            if (!runId)
+                return invalid(action, "runId is required");
+            const body = await runReadCli(ctx, ["dag", "status", "--run-id", runId], "dag status");
+            return { kind: "sync", status: body.ok ? 200 : 400, body };
+        }
+        case "workerPoolDoctor": {
+            const taskId = str(p.taskId);
+            const run = ctx.runCommand ??
+                ((args, options) => ctx.client.runExternal
+                    ? ctx.client.runExternal(resolveSiblingAgentWorkerBin(), args, options)
+                    : ctx.client.run(args, options));
+            let result;
+            try {
+                result = await run(["pool", "doctor", "--repo", ctx.repoRoot, "--json"], {
+                    cwd: ctx.repoRoot,
+                    artifactName: "read-pool-doctor",
+                    expectJson: true,
+                });
+            }
+            catch (error) {
+                return {
+                    kind: "error",
+                    status: 400,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "invalid",
+                        code: "INVALID_INPUT",
+                        message: `cannot read pool doctor facts: ${error instanceof Error ? error.message : String(error)}`,
+                    }),
+                };
+            }
+            if (!result.ok || result.exitCode !== 0 || !result.json) {
+                return {
+                    kind: "error",
+                    status: 400,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "invalid",
+                        code: "INVALID_INPUT",
+                        message: summarizeReadCliFailure(result),
+                    }),
+                };
+            }
+            const inventory = result.json;
+            if (!taskId) {
+                return {
+                    kind: "sync",
+                    status: 200,
+                    body: operatorSucceeded(action, inventory),
+                };
+            }
+            const v2 = (inventory.v2 ?? []).filter((entry) => entry.taskId === taskId);
+            const legacy = (inventory.legacy ?? []).filter((entry) => entry.taskId === taskId);
+            return {
+                kind: "sync",
+                status: 200,
+                body: operatorSucceeded(action, {
+                    ...inventory,
+                    v2,
+                    legacy,
+                    focusedTaskId: taskId,
+                }),
+            };
+        }
         case "status": {
             const taskId = str(p.taskId);
             if (!taskId) {
@@ -985,7 +1140,7 @@ export async function dispatchOperatorAction(ctx, req) {
             }
             if (operatorAction) {
                 const target = buildOperatorCapabilitiesDocument().actions.find((entry) => entry.action === operatorAction &&
-                    entry.description.startsWith("Official CLI action coverage") &&
+                    OFFICIAL_TAIL_ACTION_IDS.has(entry.action) &&
                     entry.humanConfirmation === "required");
                 if (!target)
                     return invalid(action, "operatorAction must name a required official action");
@@ -2003,12 +2158,35 @@ export async function dispatchOperatorAction(ctx, req) {
             }
             return accepted;
         }
+        case "dagPromptOverrideConfig": {
+            // Experimental internal switch; the browser UI hides the prompt-edit
+            // entry unless this reports enabled=true.
+            return {
+                kind: "sync",
+                status: 200,
+                body: operatorSucceeded(action, {
+                    enabled: isDagRerunPromptOverrideEnabled(),
+                    envVar: DAG_RERUN_PROMPT_OVERRIDE_ENV,
+                }),
+            };
+        }
         case "dagRerunPlan": {
             const runId = str(p.runId);
             const fromNode = str(p.fromNode);
             if (!runId || !fromNode) {
                 return invalid(action, "runId and fromNode are required");
             }
+            const parsedOverrides = parsePromptOverrideParams(p.promptOverrides);
+            if (parsedOverrides.kind === "error") {
+                return invalid(action, parsedOverrides.message);
+            }
+            if (parsedOverrides.overrides.length > 0 &&
+                !isDagRerunPromptOverrideEnabled()) {
+                return invalid(action, `prompt override rerun is disabled; set ${DAG_RERUN_PROMPT_OVERRIDE_ENV}=1 to enable this experimental capability`);
+            }
+            const overrideArgs = parsedOverrides.overrides.length > 0
+                ? await buildPromptOverrideCliArgs(ctx, parsedOverrides.overrides)
+                : [];
             const body = await runReadCli(ctx, [
                 "dag",
                 "rerun",
@@ -2017,6 +2195,7 @@ export async function dispatchOperatorAction(ctx, req) {
                 "--from-node",
                 fromNode,
                 "--plan",
+                ...overrideArgs,
                 "--json",
             ], "dag rerun plan");
             return { kind: "sync", status: body.ok ? 200 : 400, body };
@@ -2030,6 +2209,17 @@ export async function dispatchOperatorAction(ctx, req) {
             if (!runId || !fromNode || !planHash || !reason || !clientRequestId) {
                 return invalid(action, "runId, fromNode, planHash, reason, and clientRequestId are required");
             }
+            const parsedOverrides = parsePromptOverrideParams(p.promptOverrides);
+            if (parsedOverrides.kind === "error") {
+                return invalid(action, parsedOverrides.message);
+            }
+            if (parsedOverrides.overrides.length > 0 &&
+                !isDagRerunPromptOverrideEnabled()) {
+                return invalid(action, `prompt override rerun is disabled; set ${DAG_RERUN_PROMPT_OVERRIDE_ENV}=1 to enable this experimental capability`);
+            }
+            const overrideArgs = parsedOverrides.overrides.length > 0
+                ? await buildPromptOverrideCliArgs(ctx, parsedOverrides.overrides)
+                : [];
             return acceptOperation(ctx, {
                 action,
                 actionParams: p,
@@ -2047,6 +2237,7 @@ export async function dispatchOperatorAction(ctx, req) {
                     clientRequestId,
                     "--reason",
                     reason,
+                    ...overrideArgs,
                     "--json",
                 ],
             });
@@ -2483,12 +2674,61 @@ export async function dispatchOperatorAction(ctx, req) {
                 }),
             };
         }
+        case "savePiModelMatrix": {
+            // 「模型与认证」页模型矩阵编辑器：三档字符串值经校验后原子写入
+            // harness.json executors.pi，并自动重测 readiness。写路径本身由 HTTP
+            // 层 evaluateMutationGate 拦截（cookie + confirmation 头 + origin）。
+            const matrixInput = p.matrix ?? p;
+            const validation = validatePiModelMatrixTiers(matrixInput);
+            if (!validation.ok) {
+                return {
+                    kind: "error",
+                    status: 400,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "invalid",
+                        code: validation.code,
+                        message: validation.message,
+                        ...(validation.tier ? { details: { tier: validation.tier } } : {}),
+                    }),
+                };
+            }
+            try {
+                await writePiModelMatrix(ctx.repoRoot, validation.tiers);
+            }
+            catch (error) {
+                return {
+                    kind: "error",
+                    status: 500,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "blocked",
+                        code: "PI_MODEL_MATRIX_WRITE_FAILED",
+                        message: error instanceof Error ? error.message : String(error),
+                    }),
+                };
+            }
+            // 保存成功自动重测 readiness（复用 probePiReadiness），让页面立即
+            // 展示新的 modelsAvailable / modelsMessage / piModelMatrix（AC-4）。
+            const report = ctx.refreshReadiness
+                ? await ctx.refreshReadiness()
+                : ctx.getReadiness?.() ?? ctx.readiness;
+            return {
+                kind: "sync",
+                status: 200,
+                body: operatorSucceeded("savePiModelMatrix", {
+                    tiers: validation.tiers,
+                    readiness: report,
+                }),
+            };
+        }
         default: {
             // M5 official-command coverage uses one generic tail for newly registered
             // CLI actions. It remains inside dispatchOperatorAction (the sole dispatch
             // surface) and only accepts argv arrays declared by the capability schema.
-            const capability = buildOperatorCapabilitiesDocument().actions.find((entry) => entry.action === action &&
-                entry.description.startsWith("Official CLI action coverage"));
+            // 2026-08-18: high-frequency entries got real descriptions; membership is
+            // now derived from OFFICIAL_TAIL_ACTION_IDS, not description prefixes.
+            const capability = buildOperatorCapabilitiesDocument().actions.find((entry) => entry.action === action && OFFICIAL_TAIL_ACTION_IDS.has(entry.action));
             if (capability) {
                 const rawArgs = p.args;
                 if (rawArgs !== undefined &&

package/dist/worker/console/operator-user-error.js

@@ -1,4 +1,19 @@
 import { rewriteRecoveryOperatorError } from "./recovery-error-copy.js";
+/** Mutation-gate raw English messages (worker/console/security.ts) → copy. */
+const MUTATION_GATE_COPY = [
+    {
+        pattern: /invalid (boot capability|confirmation header) token/i,
+        copy: "页面凭证已失效（控制台可能已重启），请刷新页面（F5）后重试。",
+    },
+    {
+        pattern: /mutation requires boot capability cookie|mutation requires confirmation header token/i,
+        copy: "页面状态异常，请刷新页面（F5）后重试。",
+    },
+    {
+        pattern: /Host header is required for non-loopback/i,
+        copy: "请求主机校验失败：非回环绑定时要求 Host 头，请刷新页面或检查访问地址。",
+    },
+];
 /** Map internal spawn/controller errors to actionable Chinese copy. */
 export function formatOperatorUserError(message) {
     const raw = (message ?? "").trim();
@@ -22,5 +37,9 @@ export function formatOperatorUserError(message) {
     if (/force-required|requires --force/i.test(raw)) {
         return "该终态需要强制 Discard。请确认后勾选强制再试。";
     }
+    for (const entry of MUTATION_GATE_COPY) {
+        if (entry.pattern.test(raw))
+            return entry.copy;
+    }
     return raw;
 }

package/dist/worker/console/pi-readiness.js

@@ -4,6 +4,7 @@
  */
 import path from "node:path";
 import { mapSnapshotAvailableModels, resolveHarnessPiExecutorMatrix, } from "./chat/model-resolver.js";
+import { readPiModelMatrixProjection, } from "./harness-pi-model-matrix.js";
 const SETUP_BLOCKED = Object.freeze([
     "newTask",
     "importPrd",
@@ -84,7 +85,7 @@ function hasProviderConfig(snapshot) {
 /**
  * Discover live Pi SDK / auth / model readiness via ModelRuntime.
  * Kept inside worker/console (dynamic import) so Worker does not depend on
- * executors; contract matches pi-sdk-executor 0.80.10.
+ * executors; contract matches pi-sdk-executor 0.83.0.
  */
 export async function discoverPiReadinessProbe(options) {
     const repoRoot = options?.repoRoot ?? process.cwd();
@@ -117,7 +118,7 @@ export async function discoverPiReadinessProbe(options) {
             modelsAvailable: false,
             interviewSessionOk: false,
             details: {
-                sdkMessage: "Pi SDK incompatible: requires createAgentSession, getAgentDir, and ModelRuntime.create (0.80.10)",
+                sdkMessage: "Pi SDK incompatible: requires createAgentSession, getAgentDir, and ModelRuntime.create (0.83.0)",
                 authMessage: "skipped (sdk incompatible)",
                 modelsMessage: "skipped (sdk incompatible)",
                 sessionMessage: "skipped (sdk incompatible)",
@@ -158,7 +159,7 @@ export async function discoverPiReadinessProbe(options) {
             modelsAvailable: false,
             interviewSessionOk: false,
             details: {
-                sdkMessage: "Pi SDK 0.80.10 contract available",
+                sdkMessage: "Pi SDK 0.83.0 contract available",
                 authMessage: `ModelRuntime.create failed: ${message}`,
                 modelsMessage: "skipped (runtime init failed)",
                 sessionMessage: "skipped (runtime init failed)",
@@ -221,8 +222,9 @@ export async function discoverPiReadinessProbe(options) {
         authReady,
         modelsAvailable,
         interviewSessionOk,
+        piAvailableModels: availableModels,
         details: {
-            sdkMessage: `Pi SDK 0.80.10 contract available (agentDir=${agentDir})`,
+            sdkMessage: `Pi SDK 0.83.0 contract available (agentDir=${agentDir})`,
             authMessage: authReady
                 ? `credentials/providers ready (available=${availableCount}, providerConfig=${providerConfigured})`
                 : "no available models and no stored/configured provider credentials (set Pi auth or provider API keys)",
@@ -238,13 +240,18 @@ export async function discoverPiReadinessProbe(options) {
  * override is injected. Tests inject override for determinism.
  */
 export async function probePiReadiness(options) {
+    const repoRoot = options?.repoRoot ?? process.cwd();
+    // 模型矩阵投影与 SDK 探测解耦：即使 SDK 不可用 / 测试注入 override，仍要
+    // 投影 harness.json 三档值供模型矩阵编辑器预填（AC-1 / AC-4）。
+    const piModelMatrix = await readPiModelMatrixProjection(repoRoot);
     if (options?.override) {
-        return buildPiReadinessReport(options.override);
+        return buildPiReadinessReport({ ...options.override, piModelMatrix });
     }
     try {
         const probe = await discoverPiReadinessProbe({
             repoRoot: options?.repoRoot,
         });
+        probe.piModelMatrix = piModelMatrix;
         if (options?.siblingControllerOk && !probe.details) {
             probe.details = {};
         }

package/dist/worker/console/recovery-cta.js

@@ -59,20 +59,20 @@ const CTA = {
     },
     dagRerun: {
         id: "dagRerun",
-        label: "从节点重跑",
+        label: "从失败节点恢复",
         requiresReason: true,
         action: "dagRerun",
         lane: "dag",
-        guide: "终端失败默认首选：先 dagRerunPlan，plan 合格后直接执行（无需 Human Gate）。Worker 持有的 run、workspace/controller 漂移或含 unsafe shell 时不要强跑子图",
+        guide: "Provider、网络、限流或超时等非代码问题的首选：先评估安全子图，合格后创建 continuation run 从有效节点恢复（无需 Human Gate）。Worker 持有的 run、workspace/controller 漂移或含 unsafe shell 时不要强跑子图",
         commandHint: "loop-agent dag rerun --run-id <run-id> --from-node <node-id> --plan",
     },
     standaloneTaskRerun: {
         id: "standaloneTaskRerun",
-        label: "完整重跑任务",
+        label: "带反馈重新执行任务",
         requiresReason: true,
         action: "standaloneTaskRerun",
         lane: "dag",
-        guide: "独立 DAG run 整单重跑：仅当 from-node plan 不合格时直调执行，服务端校验 run facts，无需 Human Gate。Worker 持有的 run 请用下方「重新排队 Worker Task」",
+        guide: "独立 DAG run 无法安全从节点恢复时，重新生成完整 DAG，并带入上一轮仍未解决的 verify/review 反馈；没有可继承反馈时会明确说明（无需 Human Gate）。Worker 持有的 run 请用下方「重新排队 Worker Task」",
         commandHint: "loop-agent dag rerun-task --run-id <run-id> --reason <text> --json",
     },
     workerTaskRetry: {

package/dist/worker/console/recovery-error-copy.js

@@ -107,7 +107,7 @@ export function nextActionForIneligibleRerun(reasons) {
             "worker-managed-rerun-unsupported")) {
         return "下一步：请点下方「重新排队 Worker Task」，从头完整执行。";
     }
-    return "下一步：请改用「完整重跑任务」，从头完整执行。";
+    return "下一步：请改用「带反馈重新执行任务」，重新生成完整 DAG。";
 }
 export function formatIneligibleRerunMessage(input) {
     const fallback = input.fallbackMessage?.trim();
@@ -141,16 +141,16 @@ export function rewriteRecoveryOperatorError(raw) {
         return formatIneligibleRerunMessage({ fallbackMessage: text });
     }
     if (/action must be a mutation-gate target/i.test(text)) {
-        return "这个操作不能再走确认门。Worker 启动的任务请直接点「重新排队 Worker Task」；独立运行请点「完整重跑任务」。";
+        return "这个操作不能再走确认门。Worker 启动的任务请直接点「重新排队 Worker Task」；独立运行请点「带反馈重新执行任务」。";
     }
     if (/cannot read dagReport run facts/i.test(text)) {
         return "读不到这次运行的失败报告，不能完整重跑。请先点「查看报告」或「Doctor 诊断」。";
     }
     if (/dagRerunPlan run facts unavailable/i.test(text)) {
-        return "读不到从节点续跑的资格结果，不能改走完整重跑。请先点「从节点重跑」查看资格，或先「查看报告」。";
+        return "读不到节点恢复资格，不能直接改走完整重跑。请先点「从失败节点恢复」查看资格，或先「查看报告」。";
     }
     if (/node rerun plan is eligible/i.test(text)) {
-        return "从节点续跑是安全的，请改用「从节点重跑」，不必完整重跑整单。";
+        return "节点恢复是安全的，请改用「从失败节点恢复」，不必重新执行完整任务。";
     }
     if (/does not support autonomous standaloneTaskRerun/i.test(text)) {
         return "当前失败不适合自动完整重跑。请先点「查看报告」，按建议操作。";

package/dist/worker/console/routes.js

@@ -116,6 +116,7 @@ async function handleRecoveryCandidates(_req, res, ctx, url) {
 }
 async function handleSessionPing(req, res, ctx) {
     const failure = evaluateMutationGate(req, {
+        cookieName: ctx.bootToken.cookieName,
         bootToken: ctx.bootToken.value,
         confirmationToken: ctx.bootToken.confirmationToken,
         consoleOrigin: ctx.getConsoleOrigin(),
@@ -130,6 +131,16 @@ async function handleSessionPing(req, res, ctx) {
     }
     sendJson(res, 200, { ok: true, pong: true });
 }
+/**
+ * Actions the inspect-scoped mutation token may dispatch. Deliberately
+ * minimal: the experimental prompt-override rerun tab needs plan preflight +
+ * execution only. Everything else (task creation, runDag, reconcile, chat,
+ * worker actions…) requires the general Console token.
+ */
+export const INSPECT_MUTATION_ALLOWED_ACTIONS = new Set([
+    "dagRerunPlan",
+    "dagRerun",
+]);
 async function handleCreateOperation(req, res, ctx) {
     if (!ctx.operator) {
         sendJson(res, 503, {
@@ -141,12 +152,31 @@ async function handleCreateOperation(req, res, ctx) {
         });
         return;
     }
-    const failure = evaluateMutationGate(req, {
+    const generalGateContext = {
+        cookieName: ctx.bootToken.cookieName,
         bootToken: ctx.bootToken.value,
         confirmationToken: ctx.bootToken.confirmationToken,
         consoleOrigin: ctx.getConsoleOrigin(),
         allowNonLoopbackAccess: ctx.allowNonLoopbackAccess === true,
-    });
+    };
+    let failure = evaluateMutationGate(req, generalGateContext);
+    let inspectScoped = false;
+    if (failure && ctx.inspectBootToken) {
+        // Scoped /inspect credentials: try the inspect gate before failing. The
+        // general gate already rejected, so passing here only ever yields the
+        // allowlisted actions below — never general write capability.
+        const scopedFailure = evaluateMutationGate(req, {
+            cookieName: ctx.inspectBootToken.cookieName,
+            bootToken: ctx.inspectBootToken.value,
+            confirmationToken: ctx.inspectBootToken.confirmationToken,
+            consoleOrigin: ctx.getConsoleOrigin(),
+            allowNonLoopbackAccess: ctx.allowNonLoopbackAccess === true,
+        });
+        if (!scopedFailure) {
+            inspectScoped = true;
+            failure = undefined;
+        }
+    }
     if (failure) {
         sendJson(res, failure.status, {
             ok: false,
@@ -173,6 +203,16 @@ async function handleCreateOperation(req, res, ctx) {
         ? body.actionParams
         : {};
     const clientRequestId = typeof body.clientRequestId === "string" ? body.clientRequestId : undefined;
+    if (inspectScoped && !INSPECT_MUTATION_ALLOWED_ACTIONS.has(action)) {
+        sendJson(res, 403, {
+            ok: false,
+            error: {
+                code: "ACTION_NOT_IN_INSPECT_SCOPE",
+                message: `inspect-scoped token only allows: ${[...INSPECT_MUTATION_ALLOWED_ACTIONS].join(", ")}`,
+            },
+        });
+        return;
+    }
     const result = await dispatchOperatorAction(ctx.operator.actionContext, {
         action,
         actionParams,
@@ -428,6 +468,7 @@ export async function handleConsoleOperatorRequest(req, res, ctx) {
     }
     if (isMutationMethod(method)) {
         const failure = evaluateMutationGate(req, {
+            cookieName: ctx.bootToken.cookieName,
             bootToken: ctx.bootToken.value,
             confirmationToken: ctx.bootToken.confirmationToken,
             consoleOrigin: ctx.getConsoleOrigin(),