@tea-agent/loop-agent 0.1.0-fe-test.0

package/dist/shared/operator/capabilities.js

@@ -0,0 +1,2659 @@
+import { createRequire } from "node:module";
+import { OPERATOR_ERROR_CODES_V1, OPERATOR_OUTCOMES_V1 } from "./registry.js";
+import { WORKER_ADAPTER_PROTOCOL_RANGE } from "../../worker/loop-agent/controller-protocol.js";
+const require = createRequire(import.meta.url);
+const PACKAGE_VERSION = require("../../../package.json").version ?? "0.0.0";
+/** Keep aligned with WORKER_CONTROLLER_REQUIREMENTS_V1 in controller-protocol.ts */
+const CONTROLLER_PROTOCOL_CAPABILITIES = [
+    "task-advance-managed-contract-v2",
+    "worker-association-v1",
+    "events-jsonl-v1",
+    "document-index-closure-v1",
+    "worker-attempt-owner-v1",
+    "worker-attempt-revision-v1",
+    "recovery-decision-v2",
+];
+function officialModelCallable(coverage, _kind) {
+    if (coverage === "human-gated-required")
+        return "prepare-only";
+    // 2026-08-18: advanced actions (read or mutation) stay OUT of the model
+    // tool surface — low-frequency/forensic commands with generic args[] params
+    // diluted model attention. They remain dispatchable via UI capabilities.
+    if (coverage === "advanced")
+        return "never";
+    return "always";
+}
+const OFFICIAL_ACTION_DESCRIPTIONS = {
+    dagDecisionInspect: "Inspect a pending DAG decision envelope (inputs, options, chosen branch). Use before advising the operator on approve/reject; read-only.",
+    dagDecisionValidate: "Validate a DAG decision envelope against its schema. Use when a decision payload looks malformed or a writer emitted a suspect envelope; read-only.",
+    dagCloseoutDraft: "Draft the closeout handoff document for a finished DAG run. Use when the run is FINISHED and you need the handoff text; read-only.",
+    planList: "List execution plans in the repository. Use to discover plan ids before plan create/complete/check.",
+    planCreate: "Create an execution plan from a summary. Use to record the next work block before starting it.",
+    planComplete: "Mark an execution plan complete with a summary of what was delivered. Use after a work block is done and verified.",
+    planCheck: "Check execution-plan health and drift. Use to audit plan state without mutating anything.",
+    docsAudit: "Audit docs freshness and links (document catalog policy). Use when asked whether docs are stale or need review.",
+    handoffCheck: "Check handoff document completeness against the verification matrix. Use before claiming a task is fully handed off.",
+    handoffCoverage: "Show verification coverage across tests/docs/links for the repo. Use when asked what is verified and what is not.",
+    coverageReport: "Produce the verification coverage report. Use for a structured view of tests vs requirements.",
+    stats: "Repository workflow statistics (tasks, runs, durations). Use for quantitative status questions.",
+    promoteRun: "Task advance alias; passes a task id and flags through to task advance to promote a run. Does not pre-verify run state here — confirm with dagReport that the run is FINISHED before calling.",
+    closeoutTask: "Task advance alias; passes a task id and flags through to task advance to close out a task. Confirm the task's work is delivered and verified before calling.",
+    knowledgeCurate: "Generate knowledge-base curation proposals (may write a proposal file when --output is passed). Write-capable; use via the operator CLI, not as a model tool.",
+    knowledgeQuery: "Query the repository knowledge base. Use instead of re-reading files when a curated answer may exist.",
+    workerFeatureReview: "Review worker feature status and checkpoints (agent-worker). Use to see where a feature line stands.",
+    workerFeatureDoctor: "Diagnose worker feature health (agent-worker). Use when a feature line looks stuck or inconsistent.",
+    workerTaskValidate: "Validate a worker task spec (agent-worker). Use before queuing or when a task looks malformed.",
+    workerBatchPlanReady: "Show which batch tasks are ready to run (agent-worker). Use for queue triage before workerBatchRunReady.",
+    workerReportMorning: "Morning report for overnight worker activity (agent-worker). Use at the start of a session to catch overnight failures.",
+    workerReportMetrics: "Worker throughput and failure metrics (agent-worker). Use for quantitative worker questions.",
+    workerAdmissionShow: "Show night admission queue state (agent-worker). Use before night-scheduler mutations.",
+    workerSchedulerList: "List night-scheduler schedules (agent-worker). Use to discover schedule ids.",
+    workerSchedulerStatus: "Night-scheduler status overview (agent-worker). Use to check whether overnight jobs are healthy.",
+    workerSchedulerLedger: "Night-scheduler harvest ledger (agent-worker). Use to audit what overnight runs produced.",
+    workerSchedulerDoctor: "Diagnose night-scheduler health (agent-worker). Use when overnight jobs fail to fire or harvest.",
+};
+const officialAction = (action, cli, kind, coverage) => ({
+    action,
+    cli,
+    kind,
+    inputSchemaVersion: 1,
+    resultSchemaVersion: 1,
+    envelopeSchemaVersion: 1,
+    requiredErrorCodes: kind === "read"
+        ? ["INVALID_INPUT", "NOT_FOUND"]
+        : [
+            "INVALID_INPUT",
+            "REQUEST_ID_REUSE_CONFLICT",
+            "REVISION_CONFLICT",
+            "OBSERVED_HASH_CONFLICT",
+            "LEASE_HELD",
+            "TRANSACTION_INCOMPLETE",
+            "NOT_FOUND",
+        ],
+    description: OFFICIAL_ACTION_DESCRIPTIONS[action] ??
+        `Official CLI action coverage for ${cli}.`,
+    inputParams: [
+        {
+            name: "args",
+            type: "array",
+            itemsType: "string",
+            required: false,
+            description: "validated trailing CLI arguments",
+        },
+        ...(coverage === "human-gated-required"
+            ? [
+                {
+                    name: "confirmationId",
+                    type: "string",
+                    required: true,
+                    description: "human confirmation receipt id",
+                },
+            ]
+            : []),
+    ],
+    modelCallable: officialModelCallable(coverage, kind),
+    humanConfirmation: coverage === "human-gated-required" ? "required" : "none",
+});
+const OFFICIAL_ACTIONS = [
+    ...[
+        [
+            "dagDecisionInspect",
+            "loop-agent dag decision inspect",
+            "read",
+            "model-callable",
+        ],
+        [
+            "dagDecisionValidate",
+            "loop-agent dag decision validate",
+            "read",
+            "model-callable",
+        ],
+        [
+            "dagCloseoutDraft",
+            "loop-agent dag closeout-draft",
+            "read",
+            "model-callable",
+        ],
+        [
+            "dagApprove",
+            "loop-agent dag approve",
+            "mutation",
+            "human-gated-required",
+        ],
+        ["dagReject", "loop-agent dag reject", "mutation", "human-gated-required"],
+        [
+            "dagResume",
+            "loop-agent dag resume",
+            "long-running",
+            "human-gated-required",
+        ],
+        [
+            "dagReconcileRun",
+            "loop-agent dag reconcile-run",
+            "mutation",
+            "human-gated-required",
+        ],
+        [
+            "dagReconcileTasks",
+            "loop-agent dag reconcile-tasks",
+            "mutation",
+            "human-gated-required",
+        ],
+        [
+            "dagFinalVerification",
+            "loop-agent dag final-verification",
+            "long-running",
+            "human-gated-required",
+        ],
+        ["dagInitHybrid", "loop-agent dag init-hybrid", "mutation", "advanced"],
+        ["dagWorkflowPlan", "loop-agent dag workflow-plan", "read", "advanced"],
+        [
+            "dagWorkflowValidate",
+            "loop-agent dag workflow-validate",
+            "read",
+            "advanced",
+        ],
+        [
+            "dagWorkflowCompile",
+            "loop-agent dag workflow-compile",
+            "mutation",
+            "advanced",
+        ],
+        ["planList", "loop-agent plan list", "read", "model-callable"],
+        ["planCreate", "loop-agent plan create", "mutation", "model-callable"],
+        ["planComplete", "loop-agent plan complete", "mutation", "model-callable"],
+        ["planCheck", "loop-agent plan check", "read", "model-callable"],
+        ["docsAudit", "loop-agent docs audit", "read", "model-callable"],
+        ["docsArchive", "loop-agent docs archive", "mutation", "advanced"],
+        ["handoffCheck", "loop-agent handoff check", "read", "model-callable"],
+        [
+            "handoffCoverage",
+            "loop-agent handoff coverage",
+            "read",
+            "model-callable",
+        ],
+        ["coverageReport", "loop-agent coverage report", "read", "model-callable"],
+        ["stats", "loop-agent stats", "read", "model-callable"],
+        [
+            "promoteRun",
+            "loop-agent task advance",
+            "mutation",
+            "model-callable",
+        ],
+        [
+            "closeoutTask",
+            "loop-agent task advance",
+            "mutation",
+            "model-callable",
+        ],
+        ["piReuseBenchmark", "loop-agent pi-reuse-benchmark", "read", "advanced"],
+        ["loopBenchmark", "loop-agent loop-benchmark", "read", "advanced"],
+        [
+            "knowledgeCurate",
+            "loop-agent knowledge curate",
+            "mutation",
+            "advanced",
+        ],
+        ["knowledgeQuery", "loop-agent knowledge query", "read", "model-callable"],
+        [
+            "knowledgeGraphInit",
+            "loop-agent knowledge graph-init",
+            "mutation",
+            "advanced",
+        ],
+        [
+            "knowledgeGraphMaterialize",
+            "loop-agent knowledge graph-materialize",
+            "mutation",
+            "advanced",
+        ],
+        [
+            "knowledgeGraphPromote",
+            "loop-agent knowledge graph-promote",
+            "mutation",
+            "advanced",
+        ],
+        [
+            "knowledgeGraphIncrementalPrepare",
+            "loop-agent knowledge graph-incremental-prepare",
+            "mutation",
+            "advanced",
+        ],
+        ...["init", "status", "run", "record-round", "add-signal", "closeout"].map((leaf) => [
+            `loop${leaf.replace(/(^|-)(.)/g, (_m, _d, c) => c.toUpperCase())}`,
+            `loop-agent loop ${leaf}`,
+            leaf === "status" ? "read" : "mutation",
+            "advanced",
+        ]),
+        ...["list", "inspect", "save", "run", "diff", "replay"].map((leaf) => [
+            `workflow${leaf[0].toUpperCase()}${leaf.slice(1)}`,
+            `loop-agent workflow ${leaf}`,
+            ["list", "inspect", "diff"].includes(leaf) ? "read" : "mutation",
+            "advanced",
+        ]),
+        [
+            "workerFeatureReview",
+            "agent-worker feature review",
+            "read",
+            "model-callable",
+        ],
+        [
+            "workerFeatureScaffold",
+            "agent-worker feature scaffold",
+            "mutation",
+            "advanced",
+        ],
+        [
+            "workerFeatureRun",
+            "agent-worker feature run",
+            "long-running",
+            "human-gated-required",
+        ],
+        [
+            "workerFeatureAdvance",
+            "agent-worker feature advance",
+            "long-running",
+            "human-gated-required",
+        ],
+        [
+            "workerFeatureDoctor",
+            "agent-worker feature doctor",
+            "read",
+            "model-callable",
+        ],
+        [
+            "workerFeatureVerifyFinal",
+            "agent-worker feature verify-final",
+            "long-running",
+            "human-gated-required",
+        ],
+        [
+            "workerFeatureDelivery",
+            "agent-worker feature delivery",
+            "mutation",
+            "human-gated-required",
+        ],
+        [
+            "workerFeatureCloseout",
+            "agent-worker feature closeout",
+            "mutation",
+            "human-gated-required",
+        ],
+        [
+            "workerTaskValidate",
+            "agent-worker task validate",
+            "read",
+            "model-callable",
+        ],
+        [
+            "workerTaskReconcile",
+            "agent-worker task reconcile",
+            "mutation",
+            "human-gated-required",
+        ],
+        [
+            "workerTaskDraftFollowup",
+            "agent-worker task draft-followup",
+            "mutation",
+            "advanced",
+        ],
+        [
+            "workerFeatureApproveFollowup",
+            "agent-worker feature approve-followup",
+            "mutation",
+            "advanced",
+        ],
+        [
+            "workerBatchPlanReady",
+            "agent-worker batch plan-ready",
+            "read",
+            "model-callable",
+        ],
+        [
+            "workerBatchRunReady",
+            "agent-worker batch run-ready",
+            "long-running",
+            "advanced",
+        ],
+        [
+            "workerPoolMarkFailed",
+            "agent-worker pool mark-failed",
+            "mutation",
+            "human-gated-required",
+        ],
+        [
+            "workerReportMorning",
+            "agent-worker report morning",
+            "read",
+            "model-callable",
+        ],
+        [
+            "workerReportMetrics",
+            "agent-worker report metrics",
+            "read",
+            "model-callable",
+        ],
+        // Night Scheduler (Phase 5) — read surfaces via official CLI coverage;
+        // mutations use dedicated capability entries below (mutation-gate).
+        [
+            "workerAdmissionShow",
+            "agent-worker admission show",
+            "read",
+            "model-callable",
+        ],
+        [
+            "workerSchedulerList",
+            "agent-worker scheduler list",
+            "read",
+            "model-callable",
+        ],
+        [
+            "workerSchedulerStatus",
+            "agent-worker scheduler status",
+            "read",
+            "model-callable",
+        ],
+        [
+            "workerSchedulerLedger",
+            "agent-worker scheduler ledger",
+            "read",
+            "model-callable",
+        ],
+        [
+            "workerSchedulerDoctor",
+            "agent-worker scheduler doctor",
+            "read",
+            "model-callable",
+        ],
+    ],
+].map(([action, cli, kind, coverage]) => officialAction(action, cli, kind, coverage));
+/**
+ * Action ids produced by the officialAction() factory (the generic CLI
+ * coverage tail). Derived from the same tuple table so dispatcher / gate
+ * checks do not string-match descriptions.
+ */
+export const OFFICIAL_TAIL_ACTION_IDS = new Set(OFFICIAL_ACTIONS.map((entry) => entry.action));
+/** Shared constants so dag + dagSpecVersions cannot diverge. */
+const DAG_SPEC_SUPPORTED_PARSE = [1, 2, 3, 4];
+const DAG_SPEC_NEW_WRITER_DEFAULT = 4;
+const DAG_SPEC_HISTORICAL_TERMINAL_READ_ONLY = [1, 2, 3];
+const TASK_CONTRACT_BINDING_SCHEMA_VERSION = 1;
+const REQUIRES_TASK_CONTRACT_BINDING = true;
+const COMMON_MUTATION_ERRORS = [
+    "INVALID_INPUT",
+    "REQUEST_ID_REUSE_CONFLICT",
+    "REVISION_CONFLICT",
+    "OBSERVED_HASH_CONFLICT",
+    "LEASE_HELD",
+    "TRANSACTION_INCOMPLETE",
+    "NOT_FOUND",
+];
+export function buildOperatorCapabilitiesDocument() {
+    const actions = [
+        {
+            action: "operatorCapabilities",
+            cli: "loop-agent operator capabilities --json",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["UNSUPPORTED_SCHEMA_VERSION", "INVALID_INPUT"],
+            description: "Publish action/schema/error registry for Console negotiation.",
+            inputParams: [],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "operationGet",
+            cli: "console canonical operation read model (single operation)",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            resultPolicy: { readOnly: true, bounded: true, redacted: true },
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["NOT_FOUND", "INVALID_INPUT"],
+            description: "Read one canonical Console operation as a bounded redacted projection.",
+            inputParams: [
+                {
+                    name: "operationId",
+                    type: "string",
+                    required: true,
+                    description: "canonical operation id",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "operationList",
+            cli: "console canonical operation read model (bounded list)",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            resultPolicy: { readOnly: true, bounded: true, redacted: true },
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["INVALID_INPUT"],
+            description: "List canonical Console operations using bounded read-only filters.",
+            inputParams: [
+                {
+                    name: "limit",
+                    type: "number",
+                    required: false,
+                    description: "maximum results (1-50, default 20)",
+                },
+                {
+                    name: "state",
+                    type: "string",
+                    required: false,
+                    description: "optional operation state filter",
+                },
+                {
+                    name: "action",
+                    type: "string",
+                    required: false,
+                    description: "optional exact action filter",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "operationEventSummary",
+            cli: "console canonical operation event store (bounded summary)",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            resultPolicy: { readOnly: true, bounded: true, redacted: true },
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["NOT_FOUND", "INVALID_INPUT"],
+            description: "Read a bounded redacted summary from the canonical operation event ring.",
+            inputParams: [
+                {
+                    name: "operationId",
+                    type: "string",
+                    required: true,
+                    description: "canonical operation id",
+                },
+                {
+                    name: "limit",
+                    type: "number",
+                    required: false,
+                    description: "maximum newest events (1-100, default 20)",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "operationWait",
+            cli: "console canonical operation wait (read-only event-driven long poll)",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            resultPolicy: { readOnly: true, bounded: true, redacted: true },
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [
+                "NOT_FOUND",
+                "INVALID_INPUT",
+                "EVENT_CURSOR_EXPIRED",
+            ],
+            description: "Read-only event-driven wait on the canonical operation event ring. Default wakeOn=meaningful: heartbeats never settle the wait and are never returned as event payload (nextSeq still covers them); state/result/stdout/stderr/reconcile/error settle immediately; terminal or needs-reconcile flushes immediately. Every subsequent wait MUST pass afterSeq equal to the previous response nextSeq; omitting or reusing an older cursor replays already-consumed startup events. The response includes recommendedNextCall with the safe cursor. wakeOn=all (diagnostic compatibility) resolves on the first new event including heartbeats. maxWaitMs elapsing returns timedOut:true (a success summary, not a command failure).",
+            inputParams: [
+                {
+                    name: "operationId",
+                    type: "string",
+                    required: true,
+                    description: "canonical operation id",
+                },
+                {
+                    name: "afterSeq",
+                    type: "number",
+                    required: false,
+                    description: "event cursor; first wait may use 0, every later wait MUST use the previous response nextSeq (>= 0)",
+                },
+                {
+                    name: "maxWaitMs",
+                    type: "number",
+                    required: false,
+                    description: "bounded wait budget; clamped server-side (default 180000, floor 60000)",
+                },
+                {
+                    name: "wakeOn",
+                    type: "string",
+                    required: false,
+                    description: "wake policy: meaningful (default; heartbeats are cursor-only liveness) | all (first event settles, diagnostics)",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "contractShow",
+            cli: "loop-agent task status <taskId> --json",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["NOT_FOUND", "INVALID_INPUT"],
+            description: "Return TaskContractStateV1 + observed hashes.",
+            inputParams: [
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: true,
+                    description: "task id",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "contractValidate",
+            cli: "loop-agent task status --task <id> --input <path> --json",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["INVALID_INPUT", "NOT_FOUND", "PATH_OUTSIDE_REPO"],
+            description: "Schema/path/traceability validation for a Draft (read-only).",
+            // Dispatcher reads draftJson/inputText (a JSON string staged to a file),
+            // NOT a `draft` object. draftJson is optional — dispatcher falls back to
+            // the saved draft.
+            inputParams: [
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: true,
+                    description: "task id",
+                },
+                {
+                    name: "draftJson",
+                    type: "string",
+                    required: false,
+                    description: "draft JSON string (optional; omit to validate the saved draft)",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "contractDiff",
+            cli: "loop-agent task status --task <id> --input <path> --json",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["INVALID_INPUT", "NOT_FOUND", "PATH_OUTSIDE_REPO"],
+            description: "Risk-classified diff against current managed/legacy state.",
+            inputParams: [
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: true,
+                    description: "task id",
+                },
+                {
+                    name: "draftJson",
+                    type: "string",
+                    required: false,
+                    description: "draft JSON string (optional; omit to diff the saved draft)",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "contractApply",
+            cli: "loop-agent task advance <id> --from-draft <path> --json",
+            kind: "mutation",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [...COMMON_MUTATION_ERRORS, "EXTERNALLY_MODIFIED"],
+            description: "Journaled apply of Draft to canonical task facts.",
+            inputParams: [
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: true,
+                    description: "task id",
+                },
+                {
+                    name: "assessmentId",
+                    type: "string",
+                    required: false,
+                    description: "assessment id binding (defaults to the draft's bound assessment)",
+                },
+                {
+                    name: "expectedRevision",
+                    type: "string",
+                    required: false,
+                    description: "expected contract revision (defaults to live observed)",
+                },
+                {
+                    name: "expectedObservedHash",
+                    type: "string",
+                    required: false,
+                    description: "expected observed hash (defaults to live observed)",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "conditional",
+        },
+        {
+            action: "newTask",
+            cli: "loop-agent task advance <id> <title> --json",
+            kind: "mutation",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [...COMMON_MUTATION_ERRORS],
+            description: "Create a new task (lifecycle entry). Prefer taskAdvance for the standard flow (PRD import, taskKind, boundaries, DAG generation); newTask only bootstraps a task id + title.",
+            inputParams: [
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: true,
+                    description: "task id",
+                },
+                {
+                    name: "title",
+                    type: "string",
+                    required: false,
+                    description: "task title (defaults to taskId)",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "importPrd",
+            cli: "loop-agent task advance <id> --prd <server-staged-path> --json (+ intake bridge)",
+            kind: "mutation",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [...COMMON_MUTATION_ERRORS, "PATH_OUTSIDE_REPO"],
+            description: "Archive PRD via task advance, run intake bridge (deterministic/semantic), rewrite Console draft.",
+            inputParams: [
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: true,
+                    description: "task id",
+                },
+                {
+                    name: "content",
+                    type: "string",
+                    required: true,
+                    description: "PRD markdown content",
+                },
+                {
+                    name: "taskKind",
+                    type: "string",
+                    required: false,
+                    description: "workflow kind (human-selected)",
+                },
+                {
+                    name: "allowedPaths",
+                    type: "array",
+                    required: false,
+                    description: "optional engineering allowedPaths (human-confirmed)",
+                },
+                {
+                    name: "forbiddenPaths",
+                    type: "array",
+                    required: false,
+                    description: "optional engineering forbiddenPaths",
+                },
+                {
+                    name: "verifyCommands",
+                    type: "array",
+                    required: false,
+                    description: "optional verify commands (label:command or shell)",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "sourceInstructions",
+            cli: "loop-agent instructions source --task <id> --json",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["NOT_FOUND", "INVALID_INPUT"],
+            description: "Read the task's source instruction contract (需求.md/执行约束.md projection: requirements, constraints, allowed/forbidden paths). Use before drafting or revising a contract to stay aligned with the source.",
+            inputParams: [
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: true,
+                    description: "task id",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "contractDraftSave",
+            cli: "console application-data draft save (non-canonical)",
+            kind: "mutation",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["INVALID_INPUT"],
+            description: "Save TaskContractDraftV1 to Console application data only (not repo .harness).",
+            inputParams: [
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: false,
+                    description: "task id (defaults to draft.taskId)",
+                },
+                {
+                    name: "draft",
+                    type: "object",
+                    required: true,
+                    description: "TaskContractDraftV1 object",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "prepareDagConfirmation",
+            cli: "console aggregate confirmation receipt (server-side)",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [
+                "INVALID_INPUT",
+                "BINDING_DRIFT",
+                "HUMAN_CONFIRMATION_REQUIRED",
+            ],
+            description: "Prepare server-side DagConfirmationV1 receipt for human challenge.",
+            inputParams: [
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: true,
+                    description: "task id",
+                },
+                {
+                    name: "dagPath",
+                    type: "string",
+                    required: false,
+                    description: "staged DAG path (optional; resolved from the last dagRunTask result)",
+                },
+                {
+                    name: "operatorAction",
+                    type: "string",
+                    required: false,
+                    description: "required official action to bind to this single-use human confirmation receipt",
+                },
+                {
+                    name: "operatorActionArgs",
+                    type: "array",
+                    itemsType: "string",
+                    required: false,
+                    description: "exact trailing CLI arguments bound to the official action receipt",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "prepareDagExecution",
+            cli: "console aggregate execution receipt (server-side G2 assessment)",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [
+                "INVALID_INPUT",
+                "BINDING_DRIFT",
+                "HUMAN_CONFIRMATION_REQUIRED",
+            ],
+            description: "Issue a session-bound single-use execution receipt after server-side G2 assessment (bounded writeSet ⊆ allowedPaths, no forbidden overlap, no broad/destructive risk, structured verification). The model never passes a raw DAG path.",
+            inputParams: [
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: true,
+                    description: "task id",
+                },
+                {
+                    name: "profile",
+                    type: "string",
+                    required: false,
+                    description: "DAG profile (defaults to auto)",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "confirmDagConfirmation",
+            cli: "console aggregate confirmation human challenge (server-side)",
+            kind: "mutation",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [
+                "INVALID_INPUT",
+                "NOT_FOUND",
+                "CONFIRMATION_STALE",
+                "CONFIRMATION_EXPIRED",
+                "CONFIRMATION_CONSUMED",
+                "HUMAN_CONFIRMATION_REQUIRED",
+            ],
+            description: "Human challenge confirm of DagConfirmationV1 using server-derived current bindings.",
+            // M0-B: confirmDagConfirmation is NEVER model-callable. It IS the human
+            // confirmation — the model cannot self-confirm (roadmap G03). The model
+            // only prepares via prepareDagConfirmation; the browser mutation gate
+            // executes the confirm with a server-signed confirmationToken.
+            inputParams: [
+                {
+                    name: "confirmationId",
+                    type: "string",
+                    required: true,
+                    description: "confirmation id from prepareDagConfirmation",
+                },
+            ],
+            modelCallable: "never",
+            humanConfirmation: "required",
+        },
+        {
+            action: "observeLink",
+            cli: "console observe deep-link builder (read-only navigation)",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["INVALID_INPUT"],
+            description: "Build Observe deep link from stable object identity. Pass exactly one of dagRunId (preferred), taskId (resolves to latest run), featureId, or workerRunId; omit all for the Console home link.",
+            inputParams: [
+                {
+                    name: "dagRunId",
+                    type: "string",
+                    required: false,
+                    description: "dag run id; deep-links to #/dag/<runId> (preferred when known)",
+                },
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: false,
+                    description: "task id; resolves to the latest dag run when one exists, else #/task/<taskId>",
+                },
+                {
+                    name: "featureId",
+                    type: "string",
+                    required: false,
+                    description: "feature line id; deep-links to the feature view",
+                },
+                {
+                    name: "workerRunId",
+                    type: "string",
+                    required: false,
+                    description: "worker run id; deep-links to the worker run view",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "inspect",
+            cli: "loop-agent inspect --json",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["INVALID_INPUT"],
+            description: "Preflight a repository for loop-agent: checks harness presence, task-pool layout, and reports what the Console can operate on. Use at session start on an unfamiliar repo, before init/upgrade decisions.",
+            inputParams: [],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "doctor",
+            cli: "loop-agent doctor --json",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["INVALID_INPUT", "OPERATION_NEEDS_RECONCILE"],
+            description: "Repo health doctor with machine-readable report and read-only context audit (--context).",
+            inputParams: [],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "statsContext",
+            cli: "loop-agent stats context --last 50 --json",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["INVALID_INPUT"],
+            description: "Bounded skill-resolution / node-outcome telemetry over recent DAG runs (not compliance rates).",
+            inputParams: [],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "dagReport",
+            cli: "loop-agent dag report --run-id <runId> --json",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["NOT_FOUND", "INVALID_INPUT"],
+            description: "DAG run handoff report by run id. On failure, read primaryFailure.nodeId + primaryRecovery first; prefer dagRerunPlan from that node before standaloneTaskRerun or a new task.",
+            inputParams: [
+                {
+                    name: "runId",
+                    type: "string",
+                    required: true,
+                    description: "dag run id",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "status",
+            cli: "loop-agent task status <taskId> --json",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["NOT_FOUND", "INVALID_INPUT"],
+            description: "Read one task's lifecycle status: state, blockers, gates, contract revision, run associations. Use for task-level questions; use dagStatus for a specific DAG run's live node/liveness.",
+            inputParams: [
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: true,
+                    description: "task id",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "spineCheck",
+            cli: "loop-agent spine audit <taskId> --json",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["NOT_FOUND", "INVALID_INPUT"],
+            description: "Audit a task's minimal spec spine: source docs, path ownership, requirement ids, final verification coverage. Use before closing out a task to confirm every AC is verified.",
+            inputParams: [
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: true,
+                    description: "task id",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "taskAdvance",
+            cli: "loop-agent task advance <taskId> [title] --task-kind <kind> --allowed-path <glob> --forbidden-path <glob> --verify <label:command> --json",
+            kind: "long-running",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [
+                ...COMMON_MUTATION_ERRORS,
+                "INVALID_INPUT",
+            ],
+            description: "Canonical typed task advance mutation. Use after task creation/PRD import to apply explicit taskKind and engineering boundaries, generate + strict-validate the DAG, and stop at the writeSet gate. Never pass placeholder ids such as <id>. A successful child process may still return a blocked business outcome; inspect lifecycleState, blockers, gate, and next.",
+            inputParams: [
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: true,
+                    description: "canonical YYYY-MM-DD-<slug> task id; placeholders are rejected",
+                },
+                {
+                    name: "title",
+                    type: "string",
+                    required: false,
+                    description: "optional task title for create/first advance",
+                },
+                {
+                    name: "taskKind",
+                    type: "string",
+                    required: false,
+                    description: "business DAG template; ordinary fixes/docs use standard",
+                },
+                {
+                    name: "featureId",
+                    type: "string",
+                    required: false,
+                    description: "required only by feature-scoped task kinds such as knowledge-sync",
+                },
+                {
+                    name: "profile",
+                    type: "string",
+                    required: false,
+                    description: "governance profile auto|minimal|standard|reviewed|supervised",
+                },
+                {
+                    name: "allowedPaths",
+                    type: "array",
+                    itemsType: "string",
+                    required: false,
+                    description: "explicit writer boundary globs",
+                },
+                {
+                    name: "forbiddenPaths",
+                    type: "array",
+                    itemsType: "string",
+                    required: false,
+                    description: "explicit forbidden path globs",
+                },
+                {
+                    name: "verifyCommands",
+                    type: "array",
+                    itemsType: "string",
+                    required: false,
+                    description: "verification entries as label:command strings",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "dagRunTask",
+            cli: "loop-agent task advance <taskId> --profile auto --dag-output <path> --json",
+            kind: "long-running",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [
+                "NOT_MANAGED",
+                "BINDING_DRIFT",
+                "EXTERNALLY_MODIFIED",
+                "INVALID_INPUT",
+            ],
+            description: "Generate + strict-validate a task's DAG (via task advance, stops at the writeSet gate). Legacy entry; the standard flow is taskAdvance then prepareDagExecution + runDag.",
+            inputParams: [
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: true,
+                    description: "task id to run as a DAG",
+                },
+                {
+                    name: "profile",
+                    type: "string",
+                    required: false,
+                    description: "DAG profile (defaults to auto)",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "dagValidate",
+            cli: "loop-agent dag validate --dag <path> --json",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["INVALID_INPUT", "BINDING_DRIFT"],
+            description: "Validate DAG including taskContractBinding drift checks.",
+            inputParams: [
+                {
+                    name: "dagPath",
+                    type: "string",
+                    required: true,
+                    description: "DAG file path to validate",
+                },
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: false,
+                    description: "spine task id (optional, for strict-governance spine check)",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "runDag",
+            cli: "loop-agent task advance <taskId> --approve-gate <id:digest> --json | dag execute --dag <staged-path>",
+            kind: "long-running",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [
+                "BINDING_DRIFT",
+                "CONTROLLER_MISMATCH",
+                "INVALID_INPUT",
+            ],
+            description: "Consume a single-use executionId from prepareDagExecution and execute the reviewed DAG. Do not pass a DAG path and do not bash `task advance --approve-gate`. accepted/queued/running/operationId are NOT completion — supervise via operationGet/status/dagReport/dagDoctor/operationWait.",
+            inputParams: [
+                {
+                    name: "executionId",
+                    type: "string",
+                    required: true,
+                    description: "execution id (from prepareDagExecution) — raw dag path is never accepted from the model",
+                },
+            ],
+            // always: the model can invoke runDag with a server-issued executionId.
+            // The server re-validates staged bytes/hash + bindings at consume time
+            // (2026-08-11 autonomous DAG supervision; receipt replaces browser gate).
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "dagRerunPlan",
+            cli: "loop-agent dag rerun --run-id <id> --from-node <node> --plan --json",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["INVALID_INPUT", "NOT_FOUND"],
+            description: "Read-only check: can this failed run continue from fromNode? Call after dagReport; pass primaryFailure.nodeId. Does not execute. eligible=true returns planHash for dagRerun. eligible=false: Worker/Task Pool Failed → workerTaskRetry; standalone Console run → standaloneTaskRerun after any required contract adopt. Do not call dagRerun or invent a new task.",
+            inputParams: [
+                {
+                    name: "runId",
+                    type: "string",
+                    required: true,
+                    description: "completed failed|partial_failed parent dag run id",
+                },
+                {
+                    name: "fromNode",
+                    type: "string",
+                    required: true,
+                    description: "node id to rerun from (prefer failed/attention node from dagReport primaryFailure.nodeId)",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "dagRerun",
+            cli: "loop-agent dag rerun --run-id <id> --from-node <node> --plan-hash <hash> --request-id <id> --reason <text> --json",
+            kind: "long-running",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [
+                ...COMMON_MUTATION_ERRORS,
+                "BINDING_DRIFT",
+                "INVALID_INPUT",
+            ],
+            description: "Continue the same DAG from fromNode. Requires a fresh dagRerunPlan with eligible=true and that exact planHash. Prefer this for provider flake / safe downstream failures. Not a full task regenerate (that is standaloneTaskRerun). Server rejects stale planHash or binding drift.",
+            inputParams: [
+                {
+                    name: "runId",
+                    type: "string",
+                    required: true,
+                    description: "parent dag run id (same as dagRerunPlan)",
+                },
+                {
+                    name: "fromNode",
+                    type: "string",
+                    required: true,
+                    description: "node id matching the planned dagRerunPlan",
+                },
+                {
+                    name: "planHash",
+                    type: "string",
+                    required: true,
+                    description: "sha256 plan hash from dagRerunPlan (must match exactly)",
+                },
+                {
+                    name: "reason",
+                    type: "string",
+                    required: true,
+                    description: "why continue from this node (e.g. provider flake; resume from review-pi)",
+                },
+            ],
+            // always: fresh eligible dagRerun plans are model-callable (2026-08-11).
+            // The CLI keeps enforcing parent lifecycle, fromNode, planHash,
+            // binding/fingerprint and request idempotency.
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "dagInterruptEligibility",
+            cli: "console dag-interrupt-eligibility",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["INVALID_INPUT", "NOT_FOUND"],
+            description: "Read-only eligibility for cooperative live-DAG interrupt. v1 only Console-owned active running operations. Worker-managed / unknown owner / orphaned / terminal runs return eligible=false with stable reasonCodes. Does not create a Human Gate receipt or mutate the run.",
+            inputParams: [
+                {
+                    name: "runId",
+                    type: "string",
+                    required: true,
+                    description: "active dag run id to inspect for interrupt eligibility",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "dagRequestInterrupt",
+            cli: "loop-agent dag request-interrupt --run-id <id> --request-id <id> --target-operation-id <id> --reason-code <code> --reason <detail> --json",
+            kind: "mutation",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [
+                ...COMMON_MUTATION_ERRORS,
+                "HUMAN_CONFIRMATION_REQUIRED",
+                "RUN_NOT_ACTIVE",
+                "RUN_NOT_CONSOLE_OWNED",
+                "RUNNER_IDENTITY_MISMATCH",
+                "INTERRUPT_ALREADY_PENDING",
+                "RUN_ALREADY_TERMINAL",
+                "INTERRUPT_NEEDS_RECONCILE",
+            ],
+            description: "Request cooperative abort of a Console-owned running DAG. Success means interrupt.json is requested, not that the run has already stopped. Browser Human Gate only; model must not call this action.",
+            inputParams: [
+                {
+                    name: "runId",
+                    type: "string",
+                    required: true,
+                    description: "active dag run id",
+                },
+                {
+                    name: "reasonCode",
+                    type: "string",
+                    required: true,
+                    description: "requirements-changed | suspected-runaway | resource-protection | operator-request | other",
+                },
+                {
+                    name: "reasonDetail",
+                    type: "string",
+                    required: true,
+                    description: "10–500 character operator reason; do not auto-fill placeholders",
+                },
+                {
+                    name: "confirmationId",
+                    type: "string",
+                    required: true,
+                    description: "human confirmation receipt id from prepareMutationGate",
+                },
+            ],
+            modelCallable: "prepare-only",
+            humanConfirmation: "required",
+        },
+        {
+            action: "prepareMutationGate",
+            cli: "console prepare-mutation-gate",
+            kind: "mutation",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["INVALID_INPUT", "NOT_FOUND"],
+            description: "Prepare a one-shot Human Gate receipt for destructive reconcile, live DAG interrupt, and Night Scheduler mutations. Model may prepare; only the browser mutation gate may consume. Do not use for dagRerun / standaloneTaskRerun / workerTaskRetry.",
+            inputParams: [
+                {
+                    name: "action",
+                    type: "string",
+                    required: true,
+                    description: "target action: dagReconcileRun | dagRequestInterrupt | workerAdmissionPrepare | workerSchedulerAdd | workerSchedulerCancel | workerSchedulerHarvest | workerSchedulerDiscard. Not for standaloneTaskRerun / workerTaskRetry / dagRerun (those are autonomous).",
+                },
+                {
+                    name: "actionParams",
+                    type: "object",
+                    required: true,
+                    description: "params that will be bound into the receipt hash",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "workerAdmissionPrepare",
+            cli: 'agent-worker admission prepare --repo . --feature-dir <path> --task-id <id> --at "YYYY-MM-DD HH:mm" [--tz Asia/Shanghai] [--task-card <ref>]',
+            kind: "long-running",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [
+                ...COMMON_MUTATION_ERRORS,
+                "INVALID_INPUT",
+                "HUMAN_CONFIRMATION_REQUIRED",
+            ],
+            description: "Daytime Night Scheduler admission prepare: freeze worktree + DAG writeSet gate receipt (no execute).",
+            inputParams: [
+                {
+                    name: "featureDir",
+                    type: "string",
+                    required: true,
+                    description: "feature directory path",
+                },
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: true,
+                    description: "task id",
+                },
+                {
+                    name: "at",
+                    type: "string",
+                    required: true,
+                    description: 'local execute time "YYYY-MM-DD HH:mm"',
+                },
+                {
+                    name: "tz",
+                    type: "string",
+                    required: false,
+                    description: "IANA timezone (default Asia/Shanghai)",
+                },
+                {
+                    name: "taskCard",
+                    type: "string",
+                    required: false,
+                    description: "company task card / work item ref",
+                },
+                {
+                    name: "confirmationId",
+                    type: "string",
+                    required: true,
+                    description: "mutation-gate receipt id from prepareMutationGate",
+                },
+                {
+                    name: "humanGateToken",
+                    type: "object",
+                    required: true,
+                    description: "server-signed human-gate token from prepareMutationGate",
+                },
+            ],
+            modelCallable: "prepare-only",
+            humanConfirmation: "required",
+        },
+        {
+            action: "workerSchedulerAdd",
+            cli: "agent-worker scheduler add <schedule-id> --repo . --approve-gate <token>",
+            kind: "mutation",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [
+                ...COMMON_MUTATION_ERRORS,
+                "INVALID_INPUT",
+                "HUMAN_CONFIRMATION_REQUIRED",
+            ],
+            description: "Approve frozen night admission gate and reserve Task Pool Queued (no DAG execute).",
+            inputParams: [
+                {
+                    name: "scheduleId",
+                    type: "string",
+                    required: true,
+                    description: "schedule id",
+                },
+                {
+                    name: "approveGate",
+                    type: "string",
+                    required: true,
+                    description: "gate token from admission prepare review packet",
+                },
+                {
+                    name: "confirmationId",
+                    type: "string",
+                    required: true,
+                    description: "mutation-gate receipt id from prepareMutationGate",
+                },
+                {
+                    name: "humanGateToken",
+                    type: "object",
+                    required: true,
+                    description: "server-signed human-gate token from prepareMutationGate",
+                },
+            ],
+            modelCallable: "prepare-only",
+            humanConfirmation: "required",
+        },
+        {
+            action: "workerSchedulerCancel",
+            cli: "agent-worker scheduler cancel <schedule-id> --repo . [--reason <text>]",
+            kind: "mutation",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [
+                ...COMMON_MUTATION_ERRORS,
+                "INVALID_INPUT",
+                "HUMAN_CONFIRMATION_REQUIRED",
+            ],
+            description: "Cancel a non-dispatched night schedule and release Task Pool Queued reservation when bound.",
+            inputParams: [
+                {
+                    name: "scheduleId",
+                    type: "string",
+                    required: true,
+                    description: "schedule id",
+                },
+                {
+                    name: "reason",
+                    type: "string",
+                    required: false,
+                    description: "cancel reason",
+                },
+                {
+                    name: "confirmationId",
+                    type: "string",
+                    required: true,
+                    description: "mutation-gate receipt id from prepareMutationGate",
+                },
+                {
+                    name: "humanGateToken",
+                    type: "object",
+                    required: true,
+                    description: "server-signed human-gate token from prepareMutationGate",
+                },
+            ],
+            modelCallable: "prepare-only",
+            humanConfirmation: "required",
+        },
+        {
+            action: "workerSchedulerHarvest",
+            cli: "agent-worker scheduler harvest <schedule-id> --repo .",
+            kind: "mutation",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [
+                ...COMMON_MUTATION_ERRORS,
+                "INVALID_INPUT",
+                "HUMAN_CONFIRMATION_REQUIRED",
+            ],
+            description: "Morning harvest of a succeeded night branch via exact-base fast-forward only.",
+            inputParams: [
+                {
+                    name: "scheduleId",
+                    type: "string",
+                    required: true,
+                    description: "schedule id",
+                },
+                {
+                    name: "confirmationId",
+                    type: "string",
+                    required: true,
+                    description: "mutation-gate receipt id from prepareMutationGate",
+                },
+                {
+                    name: "humanGateToken",
+                    type: "object",
+                    required: true,
+                    description: "server-signed human-gate token from prepareMutationGate",
+                },
+            ],
+            modelCallable: "prepare-only",
+            humanConfirmation: "required",
+        },
+        {
+            action: "workerSchedulerDiscard",
+            cli: 'agent-worker scheduler discard <schedule-id> --repo . --reason "..." [--force]',
+            kind: "mutation",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [
+                ...COMMON_MUTATION_ERRORS,
+                "INVALID_INPUT",
+                "HUMAN_CONFIRMATION_REQUIRED",
+            ],
+            description: "Discard night worktree/branch after retaining evidence; --force required for failed/human_required.",
+            inputParams: [
+                {
+                    name: "scheduleId",
+                    type: "string",
+                    required: true,
+                    description: "schedule id",
+                },
+                {
+                    name: "reason",
+                    type: "string",
+                    required: true,
+                    description: "discard reason",
+                },
+                {
+                    name: "force",
+                    type: "boolean",
+                    required: false,
+                    description: "force discard for failed/human_required",
+                },
+                {
+                    name: "confirmationId",
+                    type: "string",
+                    required: true,
+                    description: "mutation-gate receipt id from prepareMutationGate",
+                },
+                {
+                    name: "humanGateToken",
+                    type: "object",
+                    required: true,
+                    description: "server-signed human-gate token from prepareMutationGate",
+                },
+            ],
+            modelCallable: "prepare-only",
+            humanConfirmation: "required",
+        },
+        {
+            action: "standaloneTaskRerun",
+            cli: "loop-agent dag rerun-task --run-id <id> --reason <text> --request-id <id> [--profile auto] [--task-id <id>] --json",
+            kind: "long-running",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [
+                ...COMMON_MUTATION_ERRORS,
+                "INVALID_INPUT",
+                "HUMAN_CONFIRMATION_REQUIRED",
+            ],
+            description: "Regenerate the whole standalone DAG from the CURRENT contract, then validate and execute a new run (parent lineage kept). This is NOT continue-from-failed-node — that is dagRerun. Server rejects the call when dagRerunPlan is eligible, when primaryRecovery.humanRequired=true, or when run facts do not recommend rerun-task. Adopt contract changes before calling or the new DAG repeats the same failure.",
+            inputParams: [
+                {
+                    name: "runId",
+                    type: "string",
+                    required: true,
+                    description: "dag run id",
+                },
+                {
+                    name: "reason",
+                    type: "string",
+                    required: true,
+                    description: "rerun reason",
+                },
+                {
+                    name: "profile",
+                    type: "string",
+                    required: false,
+                    description: "DAG profile (defaults to auto)",
+                },
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: false,
+                    description: "original task id (must match the run's task binding; never invent a new task-id)",
+                },
+            ],
+            // always: the server gate is the read-only run-facts check (2026-08-11);
+            // no browser Human Gate token is required for safe same-task rerun.
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "workerTaskRetry",
+            cli: "agent-worker task retry <task-id> --feature-id <feature-id> --repo . --reason <text>",
+            kind: "mutation",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [
+                ...COMMON_MUTATION_ERRORS,
+                "INVALID_INPUT",
+                "HUMAN_CONFIRMATION_REQUIRED",
+            ],
+            description: "Requeue a Worker Task Pool task Failed → Ready. Not a DAG node rerun (use dagRerun) and not a standalone DAG regenerate (use standaloneTaskRerun). Confirm with workerPoolDoctor first; server accepts only Failed pool tasks. Pass featureId when known — it must match the pool record.",
+            inputParams: [
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: true,
+                    description: "task id",
+                },
+                {
+                    name: "featureId",
+                    type: "string",
+                    required: false,
+                    description: "feature id (canonical retry carries Feature identity; passed to the CLI as --feature-id when present)",
+                },
+                {
+                    name: "reason",
+                    type: "string",
+                    required: true,
+                    description: "retry reason",
+                },
+            ],
+            // always: the server gate is the read-only worker task facts check
+            // (2026-08-11); no browser Human Gate token is required.
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "dagDoctor",
+            cli: "loop-agent dag doctor [--run-id <id>] --json",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["NOT_FOUND", "INVALID_INPUT"],
+            description: "Diagnose DAG run health. Omit runId for a repo-wide inventory (active/paused/completed + health issues). Pass runId for one run's liveness, heartbeat, failure node, and recovery hints. Use this to supervise stalls; it does not mutate the run.",
+            inputParams: [
+                {
+                    name: "runId",
+                    type: "string",
+                    required: false,
+                    description: "optional dag run id; omit to inventory all runs, pass to diagnose one run",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "dagStatus",
+            cli: "loop-agent dag status --run-id <id>",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["NOT_FOUND", "INVALID_INPUT"],
+            description: "Read one DAG run's live status, current node, and liveness. Requires runId. Complements dagReport (terminal handoff) and dagDoctor (health diagnosis). Does not mutate the run.",
+            inputParams: [
+                {
+                    name: "runId",
+                    type: "string",
+                    required: true,
+                    description: "dag run id",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "workerPoolDoctor",
+            cli: "agent-worker pool doctor --repo . --json",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["INVALID_INPUT", "NOT_FOUND"],
+            description: "Read-only Task Pool inventory (legacy + v2). Use before workerTaskRetry to confirm the task exists and status is Failed. Optional taskId filters the returned inventory to that task.",
+            inputParams: [
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: false,
+                    description: "optional task id to focus the inventory",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        ...OFFICIAL_ACTIONS,
+    ];
+    return {
+        schemaVersion: 1,
+        envelopeSchemaVersion: 1,
+        outcomes: OPERATOR_OUTCOMES_V1,
+        errorCodes: OPERATOR_ERROR_CODES_V1,
+        dagSpecVersions: {
+            supportedParse: DAG_SPEC_SUPPORTED_PARSE,
+            newWriterDefault: DAG_SPEC_NEW_WRITER_DEFAULT,
+            historicalTerminalReadOnly: DAG_SPEC_HISTORICAL_TERMINAL_READ_ONLY,
+        },
+        dag: {
+            supportedSpecVersions: DAG_SPEC_SUPPORTED_PARSE,
+            generatedSpecVersion: DAG_SPEC_NEW_WRITER_DEFAULT,
+            requiresTaskContractBinding: REQUIRES_TASK_CONTRACT_BINDING,
+            taskContractBindingSchemaVersion: TASK_CONTRACT_BINDING_SCHEMA_VERSION,
+        },
+        taskContract: {
+            draftSchemaVersion: 1,
+            refSchemaVersion: 1,
+            projectionVersion: 1,
+            canonicalizerVersion: 1,
+            taskConfigSchemaVersion: 1,
+        },
+        controllerProtocol: {
+            schemaVersion: 1,
+            controllerProtocolVersion: 1,
+            workerAdapterProtocolRange: WORKER_ADAPTER_PROTOCOL_RANGE,
+            capabilities: CONTROLLER_PROTOCOL_CAPABILITIES,
+            packageVersion: PACKAGE_VERSION,
+        },
+        actions,
+    };
+}
+export const OPERATOR_COMMAND_COVERAGE = Object.freeze([
+    {
+        command: "loop-agent inspect",
+        coverage: "model-callable",
+        action: "inspect",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent doctor",
+        coverage: "model-callable",
+        action: "doctor",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent task advance",
+        coverage: "model-callable",
+        action: "taskAdvance",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent task status",
+        coverage: "model-callable",
+        action: "status",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent pi-reuse-benchmark",
+        coverage: "advanced",
+        action: "piReuseBenchmark",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent loop-benchmark",
+        coverage: "advanced",
+        action: "loopBenchmark",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent dag execute",
+        coverage: "model-callable",
+        action: "runDag",
+        source: "loop-agent",
+        note: "runDag consumes a server-issued single-use execution receipt (prepareDagExecution); browser Human Gate no longer required for bounded DAGs (2026-08-11).",
+    },
+    {
+        command: "loop-agent cursor-prompt",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent pi-prompt",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent delegate",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent harvest",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent goal",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent docs audit",
+        coverage: "model-callable",
+        action: "docsAudit",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent docs archive",
+        coverage: "advanced",
+        action: "docsArchive",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent init instructions",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent init doctor",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent init check-update",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent init update",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent init reconcile",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent init upgrade",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent examples list",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent examples show",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent examples copy",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent eval replay",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent eval report",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent eval candidate",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent eval alias",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent eval promote",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent eval rollback",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent eval corpus",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent eval context-policy",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent eval budget",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent eval private-verifier",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent eval campaign",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent eval experiment",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent eval propose",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent eval outer-loop",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent eval ignition",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent plan list",
+        coverage: "model-callable",
+        action: "planList",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent plan create",
+        coverage: "model-callable",
+        action: "planCreate",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent plan complete",
+        coverage: "model-callable",
+        action: "planComplete",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent plan check",
+        coverage: "model-callable",
+        action: "planCheck",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent spine audit",
+        coverage: "model-callable",
+        action: "spineCheck",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent handoff check",
+        coverage: "model-callable",
+        action: "handoffCheck",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent handoff coverage",
+        coverage: "model-callable",
+        action: "handoffCoverage",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent coverage report",
+        coverage: "model-callable",
+        action: "coverageReport",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent reference index",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent study init",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent worktree create",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent worktree list",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent worktree remove",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent knowledge curate",
+        coverage: "advanced",
+        action: "knowledgeCurate",
+        source: "loop-agent",
+        note: "Writes knowledge proposals (conditional on --output); not model-callable.",
+    },
+    { command: "loop-agent knowledge query",
+        coverage: "model-callable",
+        action: "knowledgeQuery",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent knowledge graph-init",
+        coverage: "advanced",
+        action: "knowledgeGraphInit",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent knowledge graph-materialize",
+        coverage: "advanced",
+        action: "knowledgeGraphMaterialize",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent knowledge graph-promote",
+        coverage: "advanced",
+        action: "knowledgeGraphPromote",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent knowledge graph-incremental-prepare",
+        coverage: "advanced",
+        action: "knowledgeGraphIncrementalPrepare",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent dag init-hybrid",
+        coverage: "advanced",
+        action: "dagInitHybrid",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent dag validate",
+        coverage: "model-callable",
+        action: "dagValidate",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent dag workflow-plan",
+        coverage: "advanced",
+        action: "dagWorkflowPlan",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent dag workflow-validate",
+        coverage: "advanced",
+        action: "dagWorkflowValidate",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent dag workflow-compile",
+        coverage: "advanced",
+        action: "dagWorkflowCompile",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent dag approve",
+        coverage: "human-gated-required",
+        action: "dagApprove",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent dag reject",
+        coverage: "human-gated-required",
+        action: "dagReject",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent dag resume",
+        coverage: "human-gated-required",
+        action: "dagResume",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent dag status",
+        coverage: "model-callable",
+        action: "dagStatus",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent dag doctor",
+        coverage: "model-callable",
+        action: "dagDoctor",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent dag report",
+        coverage: "model-callable",
+        action: "dagReport",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent dag closeout-draft",
+        coverage: "model-callable",
+        action: "dagCloseoutDraft",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent dag reconcile-run",
+        coverage: "human-gated-required",
+        action: "dagReconcileRun",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent dag request-interrupt",
+        coverage: "human-gated-required",
+        action: "dagRequestInterrupt",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent dag rerun",
+        coverage: "model-callable",
+        action: "dagRerun",
+        source: "loop-agent",
+        note: "fresh eligible dagRerunPlan (planHash) is model-callable; the CLI still enforces plan/binding/fingerprint freshness (2026-08-11).",
+    },
+    {
+        command: "loop-agent dag rerun-task",
+        coverage: "model-callable",
+        action: "standaloneTaskRerun",
+        source: "loop-agent",
+        note: "server-side read-only run-facts check (ineligible plan / explicit rerun-task recommendation) replaces the browser Human Gate (2026-08-11).",
+    },
+    {
+        command: "loop-agent dag reconcile-tasks",
+        coverage: "human-gated-required",
+        action: "dagReconcileTasks",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent dag final-verification",
+        coverage: "human-gated-required",
+        action: "dagFinalVerification",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent workflow list",
+        coverage: "advanced",
+        action: "workflowList",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent workflow inspect",
+        coverage: "advanced",
+        action: "workflowInspect",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent workflow save",
+        coverage: "advanced",
+        action: "workflowSave",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent workflow run",
+        coverage: "advanced",
+        action: "workflowRun",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent workflow diff",
+        coverage: "advanced",
+        action: "workflowDiff",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent workflow replay",
+        coverage: "advanced",
+        action: "workflowReplay",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent loop init",
+        coverage: "advanced",
+        action: "loopInit",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent loop status",
+        coverage: "advanced",
+        action: "loopStatus",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent loop run",
+        coverage: "advanced",
+        action: "loopRun",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent loop record-round",
+        coverage: "advanced",
+        action: "loopRecordRound",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent loop add-signal",
+        coverage: "advanced",
+        action: "loopAddSignal",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent loop closeout",
+        coverage: "advanced",
+        action: "loopCloseout",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent dag decision inspect",
+        coverage: "model-callable",
+        action: "dagDecisionInspect",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent dag decision validate",
+        coverage: "model-callable",
+        action: "dagDecisionValidate",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent operator capabilities",
+        coverage: "model-callable",
+        action: "operatorCapabilities",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent instructions source",
+        coverage: "model-callable",
+        action: "sourceInstructions",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent instructions dag-draft",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent instructions task-artifacts",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent instructions promotion",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent instructions closeout",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "loop-agent stats",
+        coverage: "model-callable",
+        action: "stats",
+        source: "loop-agent",
+    },
+    {
+        command: "loop-agent stats context",
+        coverage: "model-callable",
+        action: "statsContext",
+        source: "loop-agent",
+    },
+    {
+        command: "agent-worker feature review",
+        coverage: "model-callable",
+        action: "workerFeatureReview",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker feature scaffold",
+        coverage: "advanced",
+        action: "workerFeatureScaffold",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker feature run",
+        coverage: "human-gated-required",
+        action: "workerFeatureRun",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker feature advance",
+        coverage: "human-gated-required",
+        action: "workerFeatureAdvance",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker feature doctor",
+        coverage: "model-callable",
+        action: "workerFeatureDoctor",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker feature verify-final",
+        coverage: "human-gated-required",
+        action: "workerFeatureVerifyFinal",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker feature delivery",
+        coverage: "human-gated-required",
+        action: "workerFeatureDelivery",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker feature closeout",
+        coverage: "human-gated-required",
+        action: "workerFeatureCloseout",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker feature approve-followup",
+        coverage: "advanced",
+        action: "workerFeatureApproveFollowup",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker task validate",
+        coverage: "model-callable",
+        action: "workerTaskValidate",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker task explain-profile",
+        coverage: "excluded",
+        action: null,
+        source: "agent-worker",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "agent-worker task validate-feature",
+        coverage: "excluded",
+        action: null,
+        source: "agent-worker",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "agent-worker task reconcile",
+        coverage: "human-gated-required",
+        action: "workerTaskReconcile",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker task retry",
+        coverage: "model-callable",
+        action: "workerTaskRetry",
+        source: "agent-worker",
+        note: "server-side read-only pool doctor facts check (Failed state) replaces the browser Human Gate (2026-08-11).",
+    },
+    {
+        command: "agent-worker task draft-followup",
+        coverage: "advanced",
+        action: "workerTaskDraftFollowup",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker batch plan-ready",
+        coverage: "model-callable",
+        action: "workerBatchPlanReady",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker batch run-ready",
+        coverage: "advanced",
+        action: "workerBatchRunReady",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker pool mark-failed",
+        coverage: "human-gated-required",
+        action: "workerPoolMarkFailed",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker pool doctor",
+        coverage: "model-callable",
+        action: "workerPoolDoctor",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker pool migrate-state",
+        coverage: "excluded",
+        action: null,
+        source: "agent-worker",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "agent-worker feature git advance-checkpoint",
+        coverage: "excluded",
+        action: null,
+        source: "agent-worker",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "agent-worker report morning",
+        coverage: "model-callable",
+        action: "workerReportMorning",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker report metrics",
+        coverage: "model-callable",
+        action: "workerReportMetrics",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker admission prepare",
+        coverage: "human-gated-required",
+        action: "workerAdmissionPrepare",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker admission show",
+        coverage: "model-callable",
+        action: "workerAdmissionShow",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker scheduler list",
+        coverage: "model-callable",
+        action: "workerSchedulerList",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker scheduler status",
+        coverage: "model-callable",
+        action: "workerSchedulerStatus",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker scheduler ledger",
+        coverage: "model-callable",
+        action: "workerSchedulerLedger",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker scheduler doctor",
+        coverage: "model-callable",
+        action: "workerSchedulerDoctor",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker scheduler add",
+        coverage: "human-gated-required",
+        action: "workerSchedulerAdd",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker scheduler cancel",
+        coverage: "human-gated-required",
+        action: "workerSchedulerCancel",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker scheduler harvest",
+        coverage: "human-gated-required",
+        action: "workerSchedulerHarvest",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker scheduler discard",
+        coverage: "human-gated-required",
+        action: "workerSchedulerDiscard",
+        source: "agent-worker",
+    },
+    {
+        command: "agent-worker scheduler tick",
+        coverage: "excluded",
+        action: null,
+        source: "agent-worker",
+        exclusionReason: "Daemon/clock path; not exposed to Operator Chat (use CLI/cron).",
+    },
+    {
+        command: "agent-worker scheduler clock install",
+        coverage: "excluded",
+        action: null,
+        source: "agent-worker",
+        exclusionReason: "OS timer install is CLI-only; Operator Console does not manage launchd/systemd/schtasks.",
+    },
+    {
+        command: "agent-worker scheduler clock status",
+        coverage: "excluded",
+        action: null,
+        source: "agent-worker",
+        exclusionReason: "Clock status is CLI-only in MVP; use scheduler doctor for Console-facing health.",
+    },
+    {
+        command: "agent-worker scheduler clock uninstall",
+        coverage: "excluded",
+        action: null,
+        source: "agent-worker",
+        exclusionReason: "OS timer uninstall is CLI-only; not exposed to Operator Chat.",
+    },
+    {
+        command: "agent-worker scheduler submit",
+        coverage: "excluded",
+        action: null,
+        source: "agent-worker",
+        exclusionReason: "Low-level planning fact; use admission prepare.",
+    },
+    {
+        command: "agent-worker scheduler transition",
+        coverage: "excluded",
+        action: null,
+        source: "agent-worker",
+        exclusionReason: "Internal lifecycle mutation; not Operator-facing.",
+    },
+    {
+        command: "agent-worker observe serve",
+        coverage: "excluded",
+        action: null,
+        source: "agent-worker",
+        exclusionReason: "Removed (Wave 5): OBSERVE_SERVE_REMOVED + exit 2; use agent-worker console + /inspect/.",
+    },
+    {
+        command: "agent-worker observe snapshot",
+        coverage: "excluded",
+        action: null,
+        source: "agent-worker",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+    {
+        command: "agent-worker console doctor",
+        coverage: "excluded",
+        action: null,
+        source: "agent-worker",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
+]);
+export function assertCoverageManifestConsistent() {
+    const actions = new Map(buildOperatorCapabilitiesDocument().actions.map((entry) => [
+        entry.action,
+        entry,
+    ]));
+    const seen = new Set();
+    for (const entry of OPERATOR_COMMAND_COVERAGE) {
+        if (seen.has(entry.command))
+            throw new Error(`duplicate operator command coverage: ${entry.command}`);
+        seen.add(entry.command);
+        if (entry.action === null) {
+            if (entry.coverage !== "excluded")
+                throw new Error(`non-excluded command has no action: ${entry.command}`);
+            continue;
+        }
+        const capability = actions.get(entry.action);
+        if (!capability)
+            throw new Error(`coverage references unknown action: ${entry.action}`);
+        if (entry.coverage === "excluded" && capability.modelCallable !== "never")
+            throw new Error(`excluded action is model-callable: ${entry.action}`);
+        if (entry.coverage === "model-callable" &&
+            (capability.modelCallable !== "always" ||
+                capability.humanConfirmation !== "none"))
+            throw new Error(`invalid model-callable classification: ${entry.action}`);
+        if (entry.coverage === "human-gated-conditional" &&
+            (capability.modelCallable !== "always" ||
+                capability.humanConfirmation !== "conditional"))
+            throw new Error(`invalid conditional gate classification: ${entry.action}`);
+        if (entry.coverage === "human-gated-required" &&
+            (capability.modelCallable !== "prepare-only" ||
+                capability.humanConfirmation !== "required"))
+            throw new Error(`invalid required gate classification: ${entry.action}`);
+        if (entry.coverage === "advanced") {
+            // 2026-08-18: advanced actions are never model-callable (read or
+            // mutation) — see officialModelCallable. UI dispatch stays available.
+            if (capability.modelCallable !== "never") {
+                throw new Error(`invalid advanced classification: ${entry.action} (expected modelCallable=never)`);
+            }
+        }
+    }
+}
+assertCoverageManifestConsistent();