@tea-agent/loop-agent 0.33.7-beta.0 → 0.34.0

package/dist/commands/init.js

@@ -1414,6 +1414,70 @@ async function readExistingSurfaceState(repoRoot) {
         return undefined;
     return parsed;
 }
+/** The IDE schema reference remains a structural update signal. */
+const HARNESS_STRUCTURAL_VALUE_KEYS = new Set(["$schema"]);
+const PI_MODEL_ROUTING_KEYS = new Set(["LOW", "MED", "HIGH", "defaultModel"]);
+function isPiModelRoutingPath(path) {
+    return path.length === 2 && path[0] === "executors" && path[1] === "pi";
+}
+/**
+ * Attribute-set iteration comparison for harness.json: object key shapes must
+ * agree at every level, except that the Pi model-routing fields are opaque
+ * project-owned configuration. Scalars and array contents may otherwise differ
+ * freely unless the key is structurally sensitive.
+ */
+function harnessJsonShapeMatches(current, desired, path = []) {
+    if (isRecord(current) || isRecord(desired)) {
+        if (!isRecord(current) || !isRecord(desired))
+            return false;
+        const filterKeys = (value) => Object.keys(value)
+            .filter((key) => !isPiModelRoutingPath(path) || !PI_MODEL_ROUTING_KEYS.has(key))
+            .sort();
+        const currentKeys = filterKeys(current);
+        const desiredKeys = filterKeys(desired);
+        if (currentKeys.length !== desiredKeys.length)
+            return false;
+        for (let index = 0; index < currentKeys.length; index += 1) {
+            const key = currentKeys[index];
+            if (key !== desiredKeys[index])
+                return false;
+            if (HARNESS_STRUCTURAL_VALUE_KEYS.has(key)) {
+                if (!isDeepStrictEqual(current[key], desired[key]))
+                    return false;
+                continue;
+            }
+            if (!harnessJsonShapeMatches(current[key], desired[key], [...path, key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return true;
+}
+/**
+ * Stable package/source anchor for generated desired content: sha256 of the
+ * desired content re-rendered through buildDesiredSurfaceContent with fixed
+ * sentinel identity values (PROJECT_NAME_TOKEN / GOVERNANCE_ROOT_TOKEN). The
+ * anchor is therefore deterministic and invariant to the real project name and
+ * governance root: a project rename or governance-root change never invalidates
+ * a previously accepted semantic merge, while package/template content changes
+ * still do. Rendering with sentinels (instead of reverse split/join replacement
+ * on already-rendered bytes) avoids false drift when a real project name is a
+ * common substring such as `init` or `docs`.
+ */
+async function stableDesiredSourceAnchor(input) {
+    const manifestPath = targetPathToManifestPath(input.entry.path, input.governanceRoot);
+    const sentinel = await buildDesiredSurfaceContent({
+        assetRoot: input.assetRoot,
+        repoRoot: input.repoRoot,
+        projectName: PROJECT_NAME_TOKEN,
+        governanceRoot: GOVERNANCE_ROOT_TOKEN,
+        entry: { ...input.entry, path: manifestPath },
+    });
+    return sentinel.content === undefined
+        ? undefined
+        : sha256Text(sentinel.content);
+}
 /**
  * Lightweight read-only preflight for the post-upgrade init surface notifier.
  *
@@ -1458,10 +1522,20 @@ async function buildCurrentSurfaceState(input) {
             entry: manifestEntry,
         });
         const sourceSha256 = desired.content === undefined ? undefined : sha256Text(desired.content);
+        const sourceAnchorSha256 = entry.mode !== "generated" || desired.content === undefined
+            ? undefined
+            : await stableDesiredSourceAnchor({
+                assetRoot,
+                repoRoot: input.repoRoot,
+                projectName: input.projectName,
+                governanceRoot: input.governanceRoot,
+                entry,
+            });
         const base = {
             status: targetStat ? "present" : "missing",
             relationship: "missing-from-target",
             sourceSha256,
+            sourceAnchorSha256,
             sourcePath: desired.sourcePath
                 ? repoRelative(assetRoot, desired.sourcePath)
                 : undefined,
@@ -1510,7 +1584,7 @@ async function buildCurrentSurfaceState(input) {
         if (targetRelativePath === "harness.json" &&
             desired.content !== undefined) {
             try {
-                semanticallyMatchesGeneratedJson = isDeepStrictEqual(JSON.parse(current.toString("utf-8")), JSON.parse(desired.content));
+                semanticallyMatchesGeneratedJson = harnessJsonShapeMatches(JSON.parse(current.toString("utf-8")), JSON.parse(desired.content));
             }
             catch {
                 // Invalid JSON remains local-existing-unknown for model merge / doctor.
@@ -1563,6 +1637,9 @@ async function writeInitSurfaceState(input) {
             harness.acceptedMerge = {
                 currentSha256: harness.currentSha256,
                 desiredSha256: harness.sourceSha256,
+                ...(harness.sourceAnchorSha256 !== undefined
+                    ? { sourceAnchorSha256: harness.sourceAnchorSha256 }
+                    : {}),
             };
         }
     }
@@ -2729,6 +2806,7 @@ function modelMergeTaskFor(pathName, state, allPaths, recordedState) {
             baseSha256: recordedState?.files[pathName]?.currentSha256,
             currentSha256: state.currentSha256,
             desiredSha256: state.sourceSha256,
+            sourceAnchorSha256: state.sourceAnchorSha256,
         },
     };
 }
@@ -2847,8 +2925,16 @@ export async function checkInitUpdate(input) {
         if (state.relationship === "local-existing-unknown") {
             const acceptedMerge = recordedState?.files[pathName]?.acceptedMerge;
             if (acceptedMerge) {
+                // Generated acceptance is bound to the stable source anchor so that
+                // project-derived desired drift (projectName/governanceRoot changes)
+                // cannot invalidate an already accepted merge. Copied files remain
+                // byte-strict; desiredSha256 stays the audit receipt in both cases.
+                const anchorAccepted = state.mode === "generated" &&
+                    state.sourceAnchorSha256 !== undefined &&
+                    acceptedMerge.sourceAnchorSha256 === state.sourceAnchorSha256;
                 if (acceptedMerge.currentSha256 === state.currentSha256 &&
-                    acceptedMerge.desiredSha256 === state.sourceSha256) {
+                    (anchorAccepted ||
+                        acceptedMerge.desiredSha256 === state.sourceSha256)) {
                     continue;
                 }
                 // A previously accepted semantic merge is user-preserving ownership.
@@ -2906,7 +2992,12 @@ export async function checkInitUpdate(input) {
                     reason: `replace the legacy default governanceRoot docs with ${governanceRoot}`,
                 });
             }
-            if (isRecord(harness)) {
+            // A harness that already matches the current generated surface except for
+            // opaque Pi routing fields is modern, not a legacy-routing candidate.
+            // Keep the explicit migration assessment for every other harness shape.
+            if (isRecord(harness) &&
+                currentState.files["harness.json"]?.relationship !==
+                    "matches-current-generated") {
                 const modelMigration = assessHarnessModelMigration(harness);
                 if (modelMigration.kind === "safe") {
                     deterministicActions.push({

package/dist/executors/shell-executor.js

@@ -31,7 +31,7 @@ import { analyzeBackendTestCaseCoverage, analyzeBackendTestMarkdownPytestCorresp
 import { materializeBackendTestResultFromPytestHtml, materializeBackendTestResultFromRunDir, parsePytestHtmlReport, } from "../workflows/dag/backend-test-result-contract.js";
 import { collectBackendTestHumanCaseCatalog, collectBackendTestMappedPytestScripts, resolveBackendTestMappedPytestScripts, collectJacocoCoverage, hasBlockingBackendMarkdownSafetyFindings, hasBlockingBackendMarkdownModuleStemFindings, inspectBackendTestEnvironment, requiredBackendMarkdownCaseAcIds, renderBackendTestFacts, renderBackendTestHtml, renderBackendTestL5Dashboard, redactBackendTestOutput, validateBackendMarkdownCases, validateBackendMarkdownTraceability, writeRunReport, } from "../workflows/dag/backend-test-markdown-workflow.js";
 import { applyDeterministicScenarioParamRepairs, assessBackendScenarioParamConsistency, classifyBackendTestFailureWithScenarioParam, readBackendScenarioParamFacts, renderBackendTestFailureAnalysis, writeBackendScenarioParamArtifacts, writeScenarioParamRepairAudit, } from "../workflows/dag/backend-test-scenario-param.js";
-import { assessBackendPytestCollection, assessMissingBackendPytestScripts, assessPriorityOnlyBackendPytestModules, assertBackendTestExecutionReadinessFresh, buildBackendPytestAssetInventory, buildBackendTestItemEligibility, materializeBackendTestExecutionReadiness, materializeEffectiveBackendPytestCollection, readBackendPytestCollectionFacts, readBackendTestExecutionReadiness, writeBackendPytestCollectionArtifacts, } from "../workflows/dag/backend-test-pytest-collection.js";
+import { assessBackendPytestCollection, assessMissingBackendPytestScripts, assessPriorityOnlyBackendPytestModules, assertBackendTestExecutionReadinessFresh, buildBackendPytestAssetInventory, materializeBackendTestExecutionReadiness, materializeEffectiveBackendPytestCollection, readBackendPytestCollectionFacts, readBackendTestExecutionReadiness, writeBackendPytestCollectionArtifacts, } from "../workflows/dag/backend-test-pytest-collection.js";
 import { computeL5ReportMetrics } from "../workflows/dag/l5-report-metrics.js";
 import { buildBackendTestCanonicalResultFromInitialShellSnippet, materializeBackendTestClassification, } from "../workflows/dag/backend-test-classification-contract.js";
 import { backendTestSemanticReviewSchema, materializeBackendTestSemanticReview, } from "../workflows/dag/backend-test-semantic-review-contract.js";
@@ -678,42 +678,6 @@ async function executeBackendTestPipeline(input, meta) {
                     fixtureResolution,
                 });
             }
-            try {
-                const correspondence = await analyzeBackendTestMarkdownPytestCorrespondence({
-                    workspaceRoot: input.cwd,
-                    taskId: meta.spec.sourceBinding?.taskId ?? "unbound",
-                });
-                const correspondenceReportPath = await writeRunReport(meta.runDir, "backend-test-markdown-pytest-correspondence-initial.md", correspondence.markdown);
-                const contractsDir = path.join(meta.runDir, "contracts");
-                await mkdir(contractsDir, { recursive: true });
-                const correspondenceFactsPath = path.join(contractsDir, "backend-test-markdown-pytest-correspondence-initial.json");
-                await writeFile(correspondenceFactsPath, JSON.stringify(correspondence.facts, null, 2), "utf8");
-                outputs.push(`initialCorrespondence=${correspondenceReportPath}`, `initialCorrespondenceFacts=${correspondenceFactsPath}`);
-                if (correspondence.facts.status === "FAIL" && facts.status === "PASS") {
-                    const correspondenceRepairPaths = Array.from(new Set(correspondence.facts.entries
-                        .filter((entry) => entry.status !== "EXACT_1_TO_1")
-                        .flatMap((entry) => [entry.expectedScript, ...entry.actualScripts])
-                        .filter((candidate) => candidate.startsWith("testcase/") && candidate.endsWith(".py")))).sort();
-                    if (correspondenceRepairPaths.length > 0) {
-                        facts.status = "REPAIRABLE";
-                        facts.repairEligible = true;
-                        facts.repairPaths = Array.from(new Set([...facts.repairPaths, ...correspondenceRepairPaths])).sort();
-                        facts.findings.push({
-                            kind: "markdown-pytest-correspondence",
-                            classification: "test-asset-defect",
-                            repairability: "repairable",
-                            detail: correspondence.facts.entries
-                                .filter((entry) => entry.status !== "EXACT_1_TO_1")
-                                .flatMap((entry) => entry.findings)
-                                .join("; ")
-                                .slice(0, 12_000) || "Markdown-to-pytest correspondence is incomplete",
-                        });
-                    }
-                }
-            }
-            catch (error) {
-                outputs.push(`initialCorrespondence=UNAVAILABLE: ${error instanceof Error ? error.message : String(error)}`);
-            }
             const artifacts = await writeBackendPytestCollectionArtifacts({
                 runDir: meta.runDir,
                 stem: "initial",
@@ -812,56 +776,12 @@ async function executeBackendTestPipeline(input, meta) {
                 facts: effective,
             });
             const scenarioFacts = await readBackendScenarioParamFacts(path.join(meta.runDir, "contracts", "backend-test-scenario-param-consistency-facts.json"));
-            const correspondence = meta.spec.sourceBinding
-                ? await analyzeBackendTestMarkdownPytestCorrespondence({
-                    workspaceRoot: input.cwd,
-                    taskId: meta.spec.sourceBinding.taskId,
-                })
-                : undefined;
-            const eligibility = correspondence
-                ? buildBackendTestItemEligibility(effective.collectedItemIds, {
-                    correspondenceEntries: correspondence.facts.entries,
-                    scenarioEntries: scenarioFacts.entries,
-                })
-                : { eligibleItemIds: effective.collectedItemIds, excludedItems: [] };
-            const eligibilityInputHashes = Object.fromEntries((correspondence?.facts.inputFiles ?? []).map((item) => [item.path, item.sha256]));
-            const eligibilityFactsPath = path.join(meta.runDir, "contracts", "backend-test-execution-eligibility.json");
-            await mkdir(path.dirname(eligibilityFactsPath), { recursive: true });
-            await writeFile(eligibilityFactsPath, `${JSON.stringify({
-                schemaId: "backend-test-execution-eligibility-v1",
-                status: eligibility.eligibleItemIds.length === 0 ? "BLOCKED" : eligibility.excludedItems.length > 0 ? "PARTIAL" : "PASS",
-                collectedItemCount: effective.collectedItemIds.length,
-                eligibleItemCount: eligibility.eligibleItemIds.length,
-                excludedItemCount: eligibility.excludedItems.length,
-                eligibleItemIds: eligibility.eligibleItemIds,
-                excludedItems: eligibility.excludedItems,
-                inputHashes: eligibilityInputHashes,
-            }, null, 2)}\n`, "utf8");
-            const eligibilityReportPath = await writeRunReport(meta.runDir, "backend-test-execution-eligibility.md", [
-                "# Backend Test Execution Eligibility",
-                "",
-                "## Status",
-                "",
-                eligibility.eligibleItemIds.length === 0 ? "BLOCKED" : eligibility.excludedItems.length > 0 ? "PARTIAL" : "PASS",
-                "",
-                `- Collected items: ${effective.collectedItemIds.length}`,
-                `- Eligible items: ${eligibility.eligibleItemIds.length}`,
-                `- Excluded items: ${eligibility.excludedItems.length}`,
-                "",
-                "## Excluded Items",
-                "",
-                ...(eligibility.excludedItems.length > 0 ? eligibility.excludedItems.map((item) => `- \`${item.itemId}\` (${item.caseId ?? "unknown Case"}): ${item.reasons.join("; ")}`) : ["- None"]),
-                "",
-            ].join("\n"));
-            outputs.push(`executionEligibility=${eligibilityReportPath}`, `executionEligibilityFacts=${eligibilityFactsPath}`);
             const readiness = await materializeBackendTestExecutionReadiness({
                 runDir: meta.runDir,
                 workspaceRoot: input.cwd,
                 effective,
                 scenarioParamStatus: scenarioFacts.overallStatus,
                 scenarioParamRepairAttempt: scenarioFacts.repairAttempt,
-                eligibility,
-                eligibilityInputHashes,
             });
             return {
                 ok: true,
@@ -872,8 +792,6 @@ async function executeBackendTestPipeline(input, meta) {
                     collectedItemCount: effective.collectedItemCount,
                     fixtureResolutionStatus: effective.fixtureResolutionStatus,
                     executionReadinessStatus: readiness.status,
-                    eligibleItemCount: readiness.eligibleItemIds.length,
-                    excludedItemCount: readiness.excludedItems.length,
                     factsPath: "contracts/backend-test-pytest-collection-effective.json",
                     readinessPath: "contracts/backend-test-execution-readiness.json",
                     reportPath: artifacts.reportPath,
@@ -972,8 +890,7 @@ async function executeBackendTestPipeline(input, meta) {
             await assertBackendTestExecutionReadinessFresh(input.cwd, executionReadiness);
             const mappedScripts = await collectBackendTestMappedPytestScripts(input.cwd);
             const shellQuote = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
-            const eligibleItemIds = executionReadiness.eligibleItemIds;
-            const pytestTargets = eligibleItemIds.map(shellQuote).join(" ");
+            const pytestTargets = mappedScripts.map(shellQuote).join(" ");
             // Split into short bash -c commands (aligned with markdown-environment).
             // A single ultra-long compound command has been observed on Windows to
             // exit 0xC0000142 (STATUS_DLL_INIT_FAILED) in ~40ms with empty stdout/
@@ -1050,9 +967,7 @@ async function executeBackendTestPipeline(input, meta) {
                 'PYTHON_BIN="$(command -v python || command -v python3 || true)"',
                 'if [ -z "${PYTHON_BIN}" ]; then echo "python/python3 is required for backend-test execution" | tee -a "${DIAG_FILE}" >&2; exit 127; fi',
                 'echo "STEP=pytest-run"',
-                `echo "- pytestCommand: python -m pytest <${eligibleItemIds.length} eligibility-authorized-items> -v -p no:cacheprovider --html=reports/backend-test.html --self-contained-html" >> "\${DIAG_FILE}"`,
-                `echo "- eligibleItemCount: ${eligibleItemIds.length}" >> "\${DIAG_FILE}"`,
-                `echo "- excludedItemCount: ${executionReadiness.excludedItems.length}" >> "\${DIAG_FILE}"`,
+                `echo "- pytestCommand: python -m pytest ${mappedScripts.join(" ")} -v -p no:cacheprovider --html=reports/backend-test.html --self-contained-html" >> "\${DIAG_FILE}"`,
                 `PYTHONUTF8=1 PYTHONIOENCODING=utf-8 PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 "\${PYTHON_BIN}" -m pytest ${pytestTargets} -v -p no:cacheprovider --html="\${HARNESS_DAG_RUN_DIR}/reports/backend-test.html" --self-contained-html`,
                 "STATUS=$?",
                 'printf "%s" "${STATUS}" > "${HARNESS_DAG_RUN_DIR}/reports/backend-test-pytest-exit.txt"',
@@ -1142,9 +1057,7 @@ async function executeBackendTestPipeline(input, meta) {
             const caseValidationSummary = await readRequiredRunReport(reportsDir, "backend-md-case-validation.md");
             const caseCoverageSummary = await readAdvisoryRunReport(reportsDir, "backend-test-case-coverage-analysis.md", "Backend Test Case Coverage Analysis");
             const traceabilitySummary = await readRequiredRunReport(reportsDir, "backend-test-traceability.md");
-            const correspondenceSummaryBase = await readAdvisoryRunReport(reportsDir, "backend-test-markdown-pytest-correspondence.md", "Backend Test Markdown → pytest Correspondence");
-            const eligibilitySummary = await readAdvisoryRunReport(reportsDir, "backend-test-execution-eligibility.md", "Backend Test Execution Eligibility");
-            const correspondenceSummary = `${correspondenceSummaryBase.trim()}\n\n${eligibilitySummary.trim()}\n`;
+            const correspondenceSummary = await readAdvisoryRunReport(reportsDir, "backend-test-markdown-pytest-correspondence.md", "Backend Test Markdown → pytest Correspondence");
             const htmlContent = renderBackendTestHtml({
                 title: meta.spec.title,
                 parsed,

package/dist/executors/shell-write-guard.js

@@ -4,6 +4,7 @@ import { constants, createReadStream } from "node:fs";
 import { access, lstat, readlink, unlink } from "node:fs/promises";
 import path from "node:path";
 import { pathMatchesPattern } from "../shared/git-progress.js";
+import { ResilientGitCommandError, runResilientGitCommand, } from "../shared/resilient-git.js";
 async function sha256File(filePath) {
     const hash = createHash("sha256");
     for await (const chunk of createReadStream(filePath)) {
@@ -401,14 +402,31 @@ async function resolveGitExecutableCandidates(platform, env) {
     return ["git"];
 }
 export async function readGitStatusPorcelain(cwd, options = {}) {
-    return readGitStatusPorcelainWithDependencies(cwd, options, {
-        platform: process.platform,
-        resolveExecutableCandidates: () => resolveGitExecutableCandidates(process.platform, process.env),
-        runAttempt: readGitStatusPorcelainOnce,
-        sleep: async (delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs)),
-        now: Date.now,
-        env: process.env,
-    });
+    try {
+        const result = await runResilientGitCommand({
+            cwd,
+            args: ["status", "--porcelain=v1", "--untracked-files=all"],
+            readOnly: true,
+            attempts: options.attempts,
+            retryDelayMs: options.retryDelayMs,
+        });
+        if (result.code === 0)
+            return result.stdout;
+        throw new Error(result.stderr.trim() || result.stdout.trim() || `exit ${result.code}`);
+    }
+    catch (error) {
+        if (error instanceof ResilientGitCommandError) {
+            throw new GitStatusUnavailableError({
+                cwd,
+                phase: options.phase,
+                platform: error.diagnostics.platform,
+                executableCandidates: error.diagnostics.executableCandidates,
+                attempts: error.diagnostics.attempts,
+                requiredWindowsEnvironment: requiredWindowsEnvironment(process.env),
+            });
+        }
+        throw error;
+    }
 }
 export async function readGitStatusPorcelainWithDependencies(cwd, options, dependencies) {
     const candidates = await dependencies.resolveExecutableCandidates();

package/dist/shared/operator/capabilities.js

@@ -699,6 +699,36 @@ export function buildOperatorCapabilitiesDocument() {
             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)",
@@ -901,7 +931,7 @@ export function buildOperatorCapabilitiesDocument() {
         },
         {
             action: "runDag",
-            cli: "loop-agent task advance <taskId> --approve-gate <id:digest> --json | dag execute --dag <path>",
+            cli: "loop-agent task advance <taskId> --approve-gate <id:digest> --json | dag execute --dag <staged-path>",
             kind: "long-running",
             inputSchemaVersion: 1,
             resultSchemaVersion: 1,
@@ -911,19 +941,20 @@ export function buildOperatorCapabilitiesDocument() {
                 "CONTROLLER_MISMATCH",
                 "INVALID_INPUT",
             ],
-            description: "Execute reviewed DAG after human confirmation (prefer task advance --approve-gate when gate token present).",
+            description: "Consume a single-use execution receipt and execute the reviewed DAG (prefer task advance --approve-gate when gate token present). accepted/queued/running/operationId are NOT completion — supervise via operationGet/status/dagReport/dagDoctor.",
             inputParams: [
                 {
-                    name: "confirmationId",
+                    name: "executionId",
                     type: "string",
                     required: true,
-                    description: "confirmation id (from prepareDagConfirmation) — raw dag path is never accepted from the model",
+                    description: "execution id (from prepareDagExecution) — raw dag path is never accepted from the model",
                 },
             ],
-            // prepare-only: the model can invoke runDag but it MUST carry a
-            // confirmationId that was consumed by a human-origin confirm (M0-B).
-            modelCallable: "prepare-only",
-            humanConfirmation: "required",
+            // 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",
@@ -963,7 +994,7 @@ export function buildOperatorCapabilitiesDocument() {
                 "BINDING_DRIFT",
                 "INVALID_INPUT",
             ],
-            description: "Execute R1 continuation from effective node. Requires planHash from a fresh dagRerunPlan (eligible=true). Prefer this over new task / standaloneTaskRerun for provider flake and safe downstream failures. Human Gate required.",
+            description: "Execute R1 continuation from effective node. Requires planHash from a fresh dagRerunPlan (eligible=true). Prefer this over new task / standaloneTaskRerun for provider flake and safe downstream failures. Server enforces planHash/binding/fingerprint freshness.",
             inputParams: [
                 {
                     name: "runId",
@@ -990,8 +1021,11 @@ export function buildOperatorCapabilitiesDocument() {
                     description: "why continue from this node (e.g. provider flake; resume from review-pi)",
                 },
             ],
-            modelCallable: "prepare-only",
-            humanConfirmation: "required",
+            // 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: "prepareMutationGate",
@@ -1001,13 +1035,13 @@ export function buildOperatorCapabilitiesDocument() {
             resultSchemaVersion: 1,
             envelopeSchemaVersion: 1,
             requiredErrorCodes: ["INVALID_INPUT", "NOT_FOUND"],
-            description: "Prepare a one-shot Human Gate receipt for standaloneTaskRerun / workerTaskRetry / Night Scheduler mutations. Model may prepare; only the browser mutation gate may consume.",
+            description: "Prepare a one-shot Human Gate receipt for Night Scheduler mutations. Model may prepare; only the browser mutation gate may consume.",
             inputParams: [
                 {
                     name: "action",
                     type: "string",
                     required: true,
-                    description: "target action: standaloneTaskRerun | workerTaskRetry | workerAdmissionPrepare | workerSchedulerAdd | workerSchedulerCancel | workerSchedulerHarvest | workerSchedulerDiscard",
+                    description: "target action: workerAdmissionPrepare | workerSchedulerAdd | workerSchedulerCancel | workerSchedulerHarvest | workerSchedulerDiscard",
                 },
                 {
                     name: "actionParams",
@@ -1259,7 +1293,7 @@ export function buildOperatorCapabilitiesDocument() {
                 "INVALID_INPUT",
                 "HUMAN_CONFIRMATION_REQUIRED",
             ],
-            description: "Full standalone task regenerate → validate → execute with parent lineage.",
+            description: "Full standalone task regenerate → validate → execute with parent lineage. Only when node rerun plan is ineligible or primaryRecovery recommends rerun-task; the server checks read-only run facts before accepting.",
             inputParams: [
                 {
                     name: "runId",
@@ -1274,20 +1308,22 @@ export function buildOperatorCapabilitiesDocument() {
                     description: "rerun reason",
                 },
                 {
-                    name: "confirmationId",
+                    name: "profile",
                     type: "string",
-                    required: true,
-                    description: "mutation-gate receipt id from prepareMutationGate",
+                    required: false,
+                    description: "DAG profile (defaults to auto)",
                 },
                 {
-                    name: "humanGateToken",
-                    type: "object",
-                    required: true,
-                    description: "server-signed human-gate token from prepareMutationGate",
+                    name: "taskId",
+                    type: "string",
+                    required: false,
+                    description: "original task id (must match the run's task binding; never invent a new task-id)",
                 },
             ],
-            modelCallable: "prepare-only",
-            humanConfirmation: "required",
+            // 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",
@@ -1301,7 +1337,7 @@ export function buildOperatorCapabilitiesDocument() {
                 "INVALID_INPUT",
                 "HUMAN_CONFIRMATION_REQUIRED",
             ],
-            description: "Requeue failed Task Pool task (Failed → Ready) via in-package pool store.",
+            description: "Requeue failed Task Pool task (Failed → Ready) via in-package pool store. Only when read-only validation confirms the task exists in Failed state; the server checks this before accepting.",
             inputParams: [
                 {
                     name: "taskId",
@@ -1321,21 +1357,11 @@ export function buildOperatorCapabilitiesDocument() {
                     required: true,
                     description: "retry 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",
+            // 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",
         },
         ...OFFICIAL_ACTIONS,
     ];
@@ -1411,9 +1437,10 @@ export const OPERATOR_COMMAND_COVERAGE = Object.freeze([
     },
     {
         command: "loop-agent dag execute",
-        coverage: "human-gated-required",
+        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",
@@ -1829,15 +1856,17 @@ export const OPERATOR_COMMAND_COVERAGE = Object.freeze([
     },
     {
         command: "loop-agent dag rerun",
-        coverage: "human-gated-required",
+        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: "human-gated-required",
+        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",
@@ -2069,9 +2098,10 @@ export const OPERATOR_COMMAND_COVERAGE = Object.freeze([
     },
     {
         command: "agent-worker task retry",
-        coverage: "human-gated-required",
+        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",