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

package/dist/commands/init.js

@@ -1414,70 +1414,6 @@ 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.
  *
@@ -1522,20 +1458,10 @@ 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,
@@ -1584,7 +1510,7 @@ async function buildCurrentSurfaceState(input) {
         if (targetRelativePath === "harness.json" &&
             desired.content !== undefined) {
             try {
-                semanticallyMatchesGeneratedJson = harnessJsonShapeMatches(JSON.parse(current.toString("utf-8")), JSON.parse(desired.content));
+                semanticallyMatchesGeneratedJson = isDeepStrictEqual(JSON.parse(current.toString("utf-8")), JSON.parse(desired.content));
             }
             catch {
                 // Invalid JSON remains local-existing-unknown for model merge / doctor.
@@ -1637,9 +1563,6 @@ async function writeInitSurfaceState(input) {
             harness.acceptedMerge = {
                 currentSha256: harness.currentSha256,
                 desiredSha256: harness.sourceSha256,
-                ...(harness.sourceAnchorSha256 !== undefined
-                    ? { sourceAnchorSha256: harness.sourceAnchorSha256 }
-                    : {}),
             };
         }
     }
@@ -2806,7 +2729,6 @@ function modelMergeTaskFor(pathName, state, allPaths, recordedState) {
             baseSha256: recordedState?.files[pathName]?.currentSha256,
             currentSha256: state.currentSha256,
             desiredSha256: state.sourceSha256,
-            sourceAnchorSha256: state.sourceAnchorSha256,
         },
     };
 }
@@ -2925,16 +2847,8 @@ 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 &&
-                    (anchorAccepted ||
-                        acceptedMerge.desiredSha256 === state.sourceSha256)) {
+                    acceptedMerge.desiredSha256 === state.sourceSha256) {
                     continue;
                 }
                 // A previously accepted semantic merge is user-preserving ownership.
@@ -2992,12 +2906,7 @@ export async function checkInitUpdate(input) {
                     reason: `replace the legacy default governanceRoot docs with ${governanceRoot}`,
                 });
             }
-            // 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") {
+            if (isRecord(harness)) {
                 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, materializeBackendTestExecutionReadiness, materializeEffectiveBackendPytestCollection, readBackendPytestCollectionFacts, readBackendTestExecutionReadiness, writeBackendPytestCollectionArtifacts, } from "../workflows/dag/backend-test-pytest-collection.js";
+import { assessBackendPytestCollection, assessMissingBackendPytestScripts, assessPriorityOnlyBackendPytestModules, assertBackendTestExecutionReadinessFresh, buildBackendPytestAssetInventory, buildBackendTestItemEligibility, 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,6 +678,42 @@ 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",
@@ -776,12 +812,56 @@ 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,
@@ -792,6 +872,8 @@ 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,
@@ -890,7 +972,8 @@ async function executeBackendTestPipeline(input, meta) {
             await assertBackendTestExecutionReadinessFresh(input.cwd, executionReadiness);
             const mappedScripts = await collectBackendTestMappedPytestScripts(input.cwd);
             const shellQuote = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
-            const pytestTargets = mappedScripts.map(shellQuote).join(" ");
+            const eligibleItemIds = executionReadiness.eligibleItemIds;
+            const pytestTargets = eligibleItemIds.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/
@@ -967,7 +1050,9 @@ 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 ${mappedScripts.join(" ")} -v -p no:cacheprovider --html=reports/backend-test.html --self-contained-html" >> "\${DIAG_FILE}"`,
+                `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}"`,
                 `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"',
@@ -1057,7 +1142,9 @@ 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 correspondenceSummary = await readAdvisoryRunReport(reportsDir, "backend-test-markdown-pytest-correspondence.md", "Backend Test Markdown → pytest Correspondence");
+            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 htmlContent = renderBackendTestHtml({
                 title: meta.spec.title,
                 parsed,

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

@@ -4,7 +4,6 @@ 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)) {
@@ -402,31 +401,14 @@ async function resolveGitExecutableCandidates(platform, env) {
     return ["git"];
 }
 export async function readGitStatusPorcelain(cwd, options = {}) {
-    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;
-    }
+    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,
+    });
 }
 export async function readGitStatusPorcelainWithDependencies(cwd, options, dependencies) {
     const candidates = await dependencies.resolveExecutableCandidates();

package/dist/shared/operator/capabilities.js

@@ -699,36 +699,6 @@ 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)",
@@ -931,7 +901,7 @@ export function buildOperatorCapabilitiesDocument() {
         },
         {
             action: "runDag",
-            cli: "loop-agent task advance <taskId> --approve-gate <id:digest> --json | dag execute --dag <staged-path>",
+            cli: "loop-agent task advance <taskId> --approve-gate <id:digest> --json | dag execute --dag <path>",
             kind: "long-running",
             inputSchemaVersion: 1,
             resultSchemaVersion: 1,
@@ -941,20 +911,19 @@ export function buildOperatorCapabilitiesDocument() {
                 "CONTROLLER_MISMATCH",
                 "INVALID_INPUT",
             ],
-            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.",
+            description: "Execute reviewed DAG after human confirmation (prefer task advance --approve-gate when gate token present).",
             inputParams: [
                 {
-                    name: "executionId",
+                    name: "confirmationId",
                     type: "string",
                     required: true,
-                    description: "execution id (from prepareDagExecution) — raw dag path is never accepted from the model",
+                    description: "confirmation id (from prepareDagConfirmation) — 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",
+            // 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",
         },
         {
             action: "dagRerunPlan",
@@ -994,7 +963,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. Server enforces planHash/binding/fingerprint freshness.",
+            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.",
             inputParams: [
                 {
                     name: "runId",
@@ -1021,11 +990,8 @@ export function buildOperatorCapabilitiesDocument() {
                     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",
+            modelCallable: "prepare-only",
+            humanConfirmation: "required",
         },
         {
             action: "prepareMutationGate",
@@ -1035,13 +1001,13 @@ export function buildOperatorCapabilitiesDocument() {
             resultSchemaVersion: 1,
             envelopeSchemaVersion: 1,
             requiredErrorCodes: ["INVALID_INPUT", "NOT_FOUND"],
-            description: "Prepare a one-shot Human Gate receipt for Night Scheduler mutations. Model may prepare; only the browser mutation gate may consume.",
+            description: "Prepare a one-shot Human Gate receipt for standaloneTaskRerun / workerTaskRetry / Night Scheduler mutations. Model may prepare; only the browser mutation gate may consume.",
             inputParams: [
                 {
                     name: "action",
                     type: "string",
                     required: true,
-                    description: "target action: workerAdmissionPrepare | workerSchedulerAdd | workerSchedulerCancel | workerSchedulerHarvest | workerSchedulerDiscard",
+                    description: "target action: standaloneTaskRerun | workerTaskRetry | workerAdmissionPrepare | workerSchedulerAdd | workerSchedulerCancel | workerSchedulerHarvest | workerSchedulerDiscard",
                 },
                 {
                     name: "actionParams",
@@ -1293,7 +1259,7 @@ export function buildOperatorCapabilitiesDocument() {
                 "INVALID_INPUT",
                 "HUMAN_CONFIRMATION_REQUIRED",
             ],
-            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.",
+            description: "Full standalone task regenerate → validate → execute with parent lineage.",
             inputParams: [
                 {
                     name: "runId",
@@ -1308,22 +1274,20 @@ export function buildOperatorCapabilitiesDocument() {
                     description: "rerun reason",
                 },
                 {
-                    name: "profile",
+                    name: "confirmationId",
                     type: "string",
-                    required: false,
-                    description: "DAG profile (defaults to auto)",
+                    required: true,
+                    description: "mutation-gate receipt id 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)",
+                    name: "humanGateToken",
+                    type: "object",
+                    required: true,
+                    description: "server-signed human-gate token from prepareMutationGate",
                 },
             ],
-            // 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",
+            modelCallable: "prepare-only",
+            humanConfirmation: "required",
         },
         {
             action: "workerTaskRetry",
@@ -1337,7 +1301,7 @@ export function buildOperatorCapabilitiesDocument() {
                 "INVALID_INPUT",
                 "HUMAN_CONFIRMATION_REQUIRED",
             ],
-            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.",
+            description: "Requeue failed Task Pool task (Failed → Ready) via in-package pool store.",
             inputParams: [
                 {
                     name: "taskId",
@@ -1357,11 +1321,21 @@ 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",
+                },
             ],
-            // 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",
+            modelCallable: "prepare-only",
+            humanConfirmation: "required",
         },
         ...OFFICIAL_ACTIONS,
     ];
@@ -1437,10 +1411,9 @@ export const OPERATOR_COMMAND_COVERAGE = Object.freeze([
     },
     {
         command: "loop-agent dag execute",
-        coverage: "model-callable",
+        coverage: "human-gated-required",
         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",
@@ -1856,17 +1829,15 @@ export const OPERATOR_COMMAND_COVERAGE = Object.freeze([
     },
     {
         command: "loop-agent dag rerun",
-        coverage: "model-callable",
+        coverage: "human-gated-required",
         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",
+        coverage: "human-gated-required",
         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",
@@ -2098,10 +2069,9 @@ export const OPERATOR_COMMAND_COVERAGE = Object.freeze([
     },
     {
         command: "agent-worker task retry",
-        coverage: "model-callable",
+        coverage: "human-gated-required",
         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",

package/dist/task/source-prepare/index.js

@@ -1,8 +1,6 @@
 export * from "./types.js";
 export * from "./path-policy.js";
 export * from "./parse-intent.js";
-export * from "./artifact-meta.js";
-export * from "./semantic-intake.js";
 export * from "./reference-integrity.js";
 export * from "./completeness.js";
 export * from "./build-draft.js";