@tea-agent/loop-agent 0.44.0-next.12 → 0.44.0-next.14

package/dist/commands/operator-guide.js

@@ -0,0 +1,99 @@
+import { access } from "node:fs/promises";
+import path from "node:path";
+import { checkInitUpdate } from "./init.js";
+import { loadNormalizedProjectConfig } from "../governance/project-config.js";
+import { CONTROLLER_RESOURCE_IDS, createControllerContextProvider, } from "../governance/resource-catalog.js";
+import { LOOP_AGENT_PACKAGE_NAME, readPackageVersion } from "../shared/package-metadata.js";
+async function exists(file) {
+    try {
+        await access(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function buildOperatorGuideDocument(repoRootInput) {
+    const repoRoot = path.resolve(repoRootInput);
+    const provider = await createControllerContextProvider();
+    const packageRoot = path.dirname(provider.list().length > 0
+        ? (await provider.readText(CONTROLLER_RESOURCE_IDS.loopAgentBridgeSkill)).absolutePath
+        : repoRoot);
+    const version = readPackageVersion(path.resolve(packageRoot, "..", "..", "..")) ?? "unknown";
+    let reproducibility = "unavailable";
+    try {
+        reproducibility = (await loadNormalizedProjectConfig(repoRoot)).verification.reproducibility;
+    }
+    catch {
+        // An uninitialized or malformed project is classified below by init assessment.
+    }
+    let status = "uninitialized";
+    let bridge = "missing";
+    let next = {
+        command: "loop-agent init --repo-root .",
+        reason: "initialize the minimal project surface",
+    };
+    if (await exists(path.join(repoRoot, "harness.json"))) {
+        const report = await checkInitUpdate({ repoRoot });
+        const bridgeDecision = report.humanDecisions.find((item) => item.reason.includes("bridge-path-conflict"));
+        bridge = bridgeDecision
+            ? "conflict"
+            : await exists(path.join(repoRoot, ".agents", "skills", "loop-agent", "SKILL.md"))
+                ? "ready"
+                : "missing";
+        if (report.humanDecisions.length > 0 || report.modelMergeTasks.length > 0) {
+            status = "blocked";
+            next = {
+                command: "loop-agent init upgrade --repo-root . --json",
+                reason: "complete the bounded migration decisions before starting new work",
+            };
+        }
+        else if (report.deterministicActions.length > 0) {
+            status = "needs-update";
+            next = {
+                command: "loop-agent init update --repo-root . --apply-safe --json",
+                reason: "apply the deterministic minimal-surface update",
+            };
+        }
+        else {
+            status = "ready";
+            next = {
+                command: "loop-agent task advance <task-id> --profile auto --json",
+                reason: "prepare or continue a governed task",
+            };
+        }
+    }
+    return {
+        schemaVersion: 1,
+        kind: "loop-agent-operator-guide",
+        controller: {
+            packageName: LOOP_AGENT_PACKAGE_NAME,
+            version,
+            resourceCatalogSha256: provider.identity.catalogDigest,
+        },
+        project: { repoRoot, status, configReproducibility: reproducibility, bridge },
+        dag: {
+            entry: "loop-agent task advance",
+            longRunningOwner: "console-operation-required",
+            builtinSkillSource: "builtin",
+        },
+        next,
+    };
+}
+export function renderOperatorGuideMarkdown(document) {
+    return [
+        "# loop-agent operator guide",
+        "",
+        `- Controller: \`${document.controller.packageName}@${document.controller.version}\``,
+        `- Project: \`${document.project.status}\``,
+        `- Bridge: \`${document.project.bridge}\``,
+        `- Verification: \`${document.project.configReproducibility}\``,
+        "",
+        "## Next",
+        "",
+        `\`${document.next.command}\``,
+        "",
+        document.next.reason,
+        "",
+    ].join("\n");
+}

package/dist/commands/operator.js

@@ -1,4 +1,5 @@
 import { buildOperatorCapabilitiesDocument, operatorFailed, operatorSucceeded, processExitCodeForOutcome, writeOperatorJson, } from "../shared/operator/index.js";
+import { buildOperatorGuideDocument, renderOperatorGuideMarkdown, } from "./operator-guide.js";
 export function parseOperatorArgs(args) {
     const options = {};
     const positional = [];
@@ -7,19 +8,31 @@ export function parseOperatorArgs(args) {
             options.json = true;
             continue;
         }
+        if (token === "--markdown") {
+            options.markdown = true;
+            continue;
+        }
         if (token.startsWith("-")) {
-            throw new Error(`unknown flag ${token}\nusage: operator capabilities --json`);
+            throw new Error(`unknown flag ${token}\nusage: operator <capabilities|guide> [--json|--markdown]`);
         }
         positional.push(token);
     }
     const subcommand = positional[0];
     if (!subcommand) {
-        throw new Error("usage: operator <capabilities> --json");
+        throw new Error("usage: operator <capabilities|guide> [--json|--markdown]");
     }
     return { subcommand, options };
 }
-export async function runOperator(_repoRoot, args) {
+export async function runOperator(repoRoot, args) {
     const { subcommand, options } = parseOperatorArgs(args);
+    if (subcommand === "guide") {
+        const guide = await buildOperatorGuideDocument(repoRoot);
+        if (options.markdown)
+            console.log(renderOperatorGuideMarkdown(guide));
+        else
+            emit(operatorSucceeded("operator guide", guide), true);
+        return;
+    }
     if (subcommand !== "capabilities") {
         const result = operatorFailed({
             command: "operator",

package/dist/executors/dag-pi-executor.js

@@ -38,7 +38,7 @@ import { isTargetTemplateTransientRetryNode, isWriterEmptyDiffRetryCandidate, is
 import { assessBackendTestMdPlanCompleteness, assessBackendTestMdWriterCompleteness, assessBackendTestPytestPlanCompleteness, assessBackendTestPytestWriterCompleteness, assessBackendTestShardChildCompleteness, backendTestWriterProgressRoleForTask, classifyBackendTestWriterCompletenessFailure, isBackendTestCompletenessRetryCandidate, isBackendTestMdPlanTask, isBackendTestPytestCollectionRepairOutcomeRecoveryCandidate, isBackendTestPytestPlanTask, isBackendTestShardChildTask, writeBackendTestWriterProgressArtifacts, } from "../workflows/dag/backend-test-writer-completeness.js";
 import { resolveBackendTestLayout } from "../workflows/dag/backend-test-layout.js";
 import { assessBackendTestPlanProtocol } from "../workflows/dag/backend-test-plan-protocol.js";
-import { frontendTestLayoutFromSpec } from "../workflows/dag/frontend-test-layout.js";
+import { frontendTestContextRel, frontendTestLayoutFromSpec, } from "../workflows/dag/frontend-test-layout.js";
 import { redactSecrets, truncateUtf8Preview } from "../shared/preview.js";
 import { writeEffectiveContextReceipt } from "../workflows/dag/context-receipt.js";
 import { estimateFrontendPlanRequirementRecordCalls, isWriterThinkingExhausted, readWriterThinkingExhaustionEvidence, WRITER_BUDGET_EXHAUSTED_CATEGORY, WRITER_TOKEN_BUDGET, FRONTEND_PLAN_COVERAGE_MAX_CONCURRENCY, mapWithConcurrency, buildFrontendPlanWorkload, loadOrCreateFrontendPlanCoverageLayout, collectFrontendVerificationCommandFiles, aggregateParallelPiResults, combineSequentialPiResults, runFrontendScoutParallelSessions, runFrontendContractSegmentedSessions, runFrontendPlanSegmentedSessions, runFrontendReviewSegmentedSessions, runFrontendScoutSegmentedSessions, } from "./dag-pi/sessions/index.js";
@@ -1552,7 +1552,7 @@ async function writePiExtensionsArtifact(nodeArtifactsDir, requested, resolved,
         // best-effort run fact; node execution continues
     }
 }
-async function resolveValidatedFrontendBaseUrlFromContext(workspaceRoot, runDir) {
+async function resolveValidatedFrontendBaseUrlFromContext(workspaceRoot, runDir, layout) {
     try {
         const capability = JSON.parse(await readFile(path.join(runDir, "preflight-frontend-browser-tool-shell", "frontend-browser-capability.json"), "utf8"));
         if (capability.status !== "ready" ||
@@ -1563,7 +1563,7 @@ async function resolveValidatedFrontendBaseUrlFromContext(workspaceRoot, runDir)
     catch {
         throw new Error("browser-command-capability-unavailable: missing or invalid frontend browser capability artifact");
     }
-    const contextPath = path.join(workspaceRoot, "testcase", "frontend", "rag", "context.md");
+    const contextPath = path.join(workspaceRoot, ...frontendTestContextRel(layout).split("/"));
     let markdown;
     try {
         markdown = await readFile(contextPath, "utf8");
@@ -1759,8 +1759,13 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
     let beforeStatus;
     let beforeWorkspaceSnapshot;
     let beforePathFingerprints;
-    /** tools-only and filesystem-only keep the tool sandbox but skip Git baseline. */
-    const filesystemOnly = isWriteTask && meta.spec.backendTestWorkspaceControl === "filesystem-only";
+    /** tools-only and filesystem-only keep the tool sandbox but skip Git baseline.
+     * filesystem-only applies when the node froze it in writeGuardPolicy (D4:
+     * any dedicated test writer under an ignored root) OR the backend-test spec
+     * explicitly selected workspaceControl=filesystem-only. */
+    const filesystemOnly = isWriteTask &&
+        (input.task.writeGuardPolicy === "filesystem-only" ||
+            meta.spec.backendTestWorkspaceControl === "filesystem-only");
     const skipGitWriteGuard = isWriteTask && (input.task.writeGuardPolicy === "tools-only" || filesystemOnly);
     if (isWriteTask && filesystemOnly) {
         try {
@@ -1880,7 +1885,7 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
                             nodeId: input.task.id,
                             caseId,
                             evidenceDir,
-                            baseUrl: await resolveValidatedFrontendBaseUrlFromContext(input.cwd, meta.runDir),
+                            baseUrl: await resolveValidatedFrontendBaseUrlFromContext(input.cwd, meta.runDir, layout),
                             inputRoot: layout.fixturesDir,
                             layout,
                         };

package/dist/executors/pi-sdk-executor.js

@@ -8,7 +8,7 @@ import { computeExtensionToolAllowlistExtras } from "./pi-extension-resolver.js"
 import { BoundedTextPreview, classifyPiFailure, createPiJsonlStreamCollector, DEFAULT_ABORT_GRACE_MS, DEFAULT_STALL_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, extractPiEventStopReason, extractAssistantTextFromPiJson, } from "./pi-executor.js";
 import { serializeSessionEvent } from "./pi-event-serializer.js";
 import { PI_RECOMMENDED_COMPACTION, PI_RECOMMENDED_RETRY, } from "../shared/pi-retry-settings.js";
-import { createCompactionController, createContextPressureExtension, createSiftBridgeState, inMemoryCompactionSettings, isDagSiftEnabled, parseCompactionPolicy, parseSiftBridgeConfig, SIFT_RETRIEVE_TOOL_NAME, } from "../shared/pi-context-pressure/index.js";
+import { createCompactionController, createContextPressureExtension, createSiftBridgeState, inMemoryCompactionSettings, isDagSiftEnabled, parseCompactionPolicy, parsePiToolResultPruneConfig, parseSiftBridgeConfig, SIFT_RETRIEVE_TOOL_NAME, } from "../shared/pi-context-pressure/index.js";
 import { DAG_TELEMETRY_SESSION_ID_ENV, injectWizardLocalTelemetryHeaders, isTelemetrySessionId, } from "../shared/wizard-local-telemetry.js";
 /** Maximum number of same-session continuations after provider output truncation. */
 export const PI_SDK_OUTPUT_LIMIT_CONTINUE_MAX = 3;
@@ -292,6 +292,7 @@ async function createSdkSession(sdk, input, shared) {
     // Prefer SettingsManager.inMemory so harness runs do not depend on ~/.pi or
     // project .pi/settings.json being present/trusted.
     const policy = parseCompactionPolicy();
+    const pruneSettings = parsePiToolResultPruneConfig();
     const compaction = {
         ...PI_RECOMMENDED_COMPACTION,
         ...inMemoryCompactionSettings(policy),
@@ -321,6 +322,7 @@ async function createSdkSession(sdk, input, shared) {
         policy,
         controller,
         sift,
+        ...(pruneSettings.enabled && policy.mode !== "off" ? { prune: pruneSettings.config } : {}),
     });
     const telemetryExtension = createDagWizardLocalTelemetryHeadersExtension(input.telemetrySessionId);
     const extensionFactories = [pressureExtension, telemetryExtension].filter((extension) => Boolean(extension));

package/dist/executors/pi-writer-tool-policy.js

@@ -1,6 +1,7 @@
 import { access as fsAccess, lstat, mkdir as fsMkdir, readFile as fsReadFile, realpath, writeFile as fsWriteFile, } from "node:fs/promises";
 import path from "node:path";
 import { pathMatchesPattern } from "../shared/git-progress.js";
+import { isAnyTestArtifactPath, isHarnessBaselineForbiddenPattern, } from "../workflows/dag/test-artifact-namespace.js";
 export class PiWriterPathDeniedError extends Error {
     code;
     targetPath;
@@ -105,12 +106,60 @@ function repoRelativePath(root, absoluteTarget, raw, allowRoot) {
     }
     return relative;
 }
+/**
+ * D3 test-artifact exception at the tool layer: a write target inside the
+ * canonical `.harness/testcase` namespace that the task's exclusive writeSet
+ * (or, for mkdir, a writeSet entry at/above it) explicitly owns is exempt
+ * from the BASELINE harness guard patterns (`.harness` / `.harness/**`) only.
+ * Explicit deeper forbidden patterns and the hard controller-facts guard stay
+ * authoritative, matching the DAG validator and the post-hoc write guard.
+ */
+function testArtifactWriteExempt(relative, ctx) {
+    const forbidden = ctx.forbiddenPaths ?? [];
+    let baselineHit = false;
+    for (const pattern of forbidden) {
+        if (!matchesAnyPattern(relative, [pattern]))
+            continue;
+        if (!isHarnessBaselineForbiddenPattern(pattern))
+            return false;
+        baselineHit = true;
+    }
+    if (!baselineHit)
+        return false;
+    if (!isAnyTestArtifactPath(relative))
+        return false;
+    const writeSet = ctx.writeSet ?? [];
+    if ((ctx.writePolicy ?? "exclusive") === "exclusive") {
+        return matchesAnyPattern(relative, writeSet);
+    }
+    return writeSet.length === 0 || matchesAnyPattern(relative, writeSet);
+}
+function testArtifactMkdirExempt(relative, ctx) {
+    const forbidden = ctx.forbiddenPaths ?? [];
+    let baselineHit = false;
+    for (const pattern of forbidden) {
+        if (!pathMatchesPattern(relative, pattern))
+            continue;
+        if (!isHarnessBaselineForbiddenPattern(pattern))
+            return false;
+        baselineHit = true;
+    }
+    if (!baselineHit)
+        return false;
+    if (!isAnyTestArtifactPath(relative))
+        return false;
+    const writeSet = (ctx.writeSet ?? []).map(normalizeRepoRelative);
+    return writeSet.some((candidate) => isPathAtOrBelowDirectory(candidate, relative) ||
+        (relative.length > 0 && pathMatchesPattern(relative, candidate)));
+}
 function assertWritableRelative(relative, ctx) {
     if (isHardForbidden(relative)) {
         throw new PiWriterPathDeniedError("hard-forbidden", relative, "writes under .harness/tasks/** or .harness/dag-runs/** are never allowed for Pi writers");
     }
     const forbidden = ctx.forbiddenPaths ?? [];
-    if (forbidden.length > 0 && matchesAnyPattern(relative, forbidden)) {
+    if (forbidden.length > 0 &&
+        matchesAnyPattern(relative, forbidden) &&
+        !testArtifactWriteExempt(relative, ctx)) {
         throw new PiWriterPathDeniedError("forbidden", relative);
     }
     const writeSet = ctx.writeSet ?? [];
@@ -130,7 +179,8 @@ function assertMkdirRelative(relative, ctx) {
     const forbidden = ctx.forbiddenPaths ?? [];
     if (relative &&
         forbidden.length > 0 &&
-        matchesAnyPattern(relative, forbidden)) {
+        matchesAnyPattern(relative, forbidden) &&
+        !testArtifactMkdirExempt(relative, ctx)) {
         throw new PiWriterPathDeniedError("forbidden", relative);
     }
     const writeSetCandidates = (ctx.writeSet ?? [])
@@ -149,8 +199,14 @@ function assertMkdirRelative(relative, ctx) {
     if (nonHardForbiddenCandidates.length === 0) {
         throw new PiWriterPathDeniedError("hard-forbidden", relative || ".");
     }
-    if (forbidden.length > 0 &&
-        nonHardForbiddenCandidates.every((candidate) => matchesAnyPattern(candidate, forbidden))) {
+    // D3 test-artifact exception: when the target directory is a canonical
+    // namespace root owned by the writeSet, baseline harness guard patterns do
+    // not disqualify allowedPaths candidates either.
+    const effectiveForbidden = testArtifactMkdirExempt(relative, ctx)
+        ? forbidden.filter((pattern) => !isHarnessBaselineForbiddenPattern(pattern))
+        : forbidden;
+    if (effectiveForbidden.length > 0 &&
+        nonHardForbiddenCandidates.every((candidate) => matchesAnyPattern(candidate, effectiveForbidden))) {
         throw new PiWriterPathDeniedError("forbidden", relative || ".");
     }
 }

package/dist/executors/playwright-cli-launcher.js

@@ -1,57 +1,43 @@
-import { existsSync, readFileSync } from "node:fs";
+import { readFileSync, realpathSync, statSync } from "node:fs";
 import path from "node:path";
 import { createRequire } from "node:module";
 const PACKAGE_NAME = "@playwright/cli";
+const PACKAGE_VERSION = "0.1.20";
 function launcherFromManifest(manifestPath) {
-    try {
-        const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
-        if (manifest.name !== PACKAGE_NAME)
-            return undefined;
-        const bin = typeof manifest.bin === "string"
-            ? manifest.bin
-            : manifest.bin && typeof manifest.bin === "object"
-                ? manifest.bin["playwright-cli"]
-                : undefined;
-        if (typeof bin !== "string" || !bin || path.isAbsolute(bin) || bin.split(/[\\/]+/).includes(".."))
-            return undefined;
-        const packageRoot = path.dirname(manifestPath);
-        const entryPath = path.resolve(packageRoot, bin);
-        const relative = path.relative(packageRoot, entryPath);
-        if (relative.startsWith("..") || path.isAbsolute(relative) || !existsSync(entryPath))
-            return undefined;
-        return { executable: process.execPath, argvPrefix: [entryPath], entryPath };
-    }
-    catch {
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    if (manifest.name !== PACKAGE_NAME)
         return undefined;
+    if (manifest.version !== PACKAGE_VERSION) {
+        throw new Error(`expected ${PACKAGE_NAME}@${PACKAGE_VERSION}, found ${String(manifest.version)}`);
     }
+    const bin = typeof manifest.bin === "string"
+        ? manifest.bin
+        : manifest.bin && typeof manifest.bin === "object"
+            ? manifest.bin["playwright-cli"]
+            : undefined;
+    if (typeof bin !== "string" || !bin || path.isAbsolute(bin) || path.win32.isAbsolute(bin) || bin.split(/[\\/]+/).includes(".."))
+        return undefined;
+    if (!/\.(?:c|m)?js$/i.test(bin))
+        return undefined;
+    const packageRoot = realpathSync(path.dirname(manifestPath));
+    const entryPath = realpathSync(path.resolve(packageRoot, bin));
+    const relative = path.relative(packageRoot, entryPath);
+    if (relative.startsWith("..") || path.isAbsolute(relative) || !statSync(entryPath).isFile())
+        return undefined;
+    return { executable: process.execPath, argvPrefix: [entryPath], entryPath };
 }
-function candidateManifestPaths(cwd) {
-    const paths = new Set();
-    for (const root of [cwd, process.cwd()]) {
-        try {
-            paths.add(createRequire(path.join(path.resolve(root), "package.json")).resolve(`${PACKAGE_NAME}/package.json`));
-        }
-        catch {
-            // Keep searching controller-known module roots.
-        }
-    }
-    // Npm's Windows/global shim is paired with node_modules in either the shim
-    // directory or its parent (.bin). We read package metadata directly; the
-    // .cmd file itself is never executed or parsed as a command string.
-    for (const binDir of (process.env.PATH ?? "").split(path.delimiter).filter(Boolean)) {
-        paths.add(path.join(binDir, "node_modules", ...PACKAGE_NAME.split("/"), "package.json"));
-        paths.add(path.join(binDir, "..", ...PACKAGE_NAME.split("/"), "package.json"));
-    }
-    return [...paths];
-}
-/** Resolve only a package-declared entry; throws instead of falling back to a PATH executable. */
-export function resolvePlaywrightCliLauncher(cwd) {
-    for (const manifestPath of candidateManifestPaths(cwd)) {
+/** Resolve from this installation, independently of the target project's cwd/PATH. */
+export function resolvePlaywrightCliLauncher(_cwd) {
+    try {
+        const manifestPath = createRequire(import.meta.url).resolve(`${PACKAGE_NAME}/package.json`);
         const launcher = launcherFromManifest(manifestPath);
-        if (launcher)
-            return launcher;
+        if (!launcher)
+            throw new Error("invalid package manifest or JavaScript entry");
+        return launcher;
+    }
+    catch (error) {
+        throw new Error(`playwright-cli-unavailable: bundled ${PACKAGE_NAME} installation is missing or invalid; reinstall loop-agent. ${error instanceof Error ? error.message : String(error)}`);
     }
-    throw new Error("playwright-cli-unavailable: verified @playwright/cli JavaScript entry was not found");
 }
 export function checkPlaywrightCliLauncher(cwd) {
     try {

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

@@ -1,11 +1,11 @@
-import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
-import { constants, createReadStream } from "node:fs";
-import { access, lstat, readlink, unlink } from "node:fs/promises";
+import { createReadStream } from "node:fs";
+import { lstat, readlink, unlink } from "node:fs/promises";
 import path from "node:path";
 import { pathMatchesPattern } from "../shared/git-progress.js";
 import { expandWorkspaceStatus, hasGitmodulesFile, synthesizeExpandedPorcelain, } from "../shared/git-workspace-status.js";
 import { ResilientGitCommandError, runResilientGitCommand, } from "../shared/resilient-git.js";
+import { isAnyTestArtifactPath, isHarnessBaselineForbiddenPattern, } from "../workflows/dag/test-artifact-namespace.js";
 async function sha256File(filePath) {
     const hash = createHash("sha256");
     for await (const chunk of createReadStream(filePath)) {
@@ -149,7 +149,27 @@ export function validateShellWriteGuard(input) {
             continue;
         }
         if (matchesAnyPattern(filePath, forbiddenPaths)) {
-            violations.push(filePath);
+            // D3 test-artifact exception: a changed file inside the canonical
+            // `.harness/testcase` namespace that the task's exclusive writeSet
+            // explicitly owns is exempt from the BASELINE harness guard patterns
+            // (`.harness` / `.harness/**`) only — spec-level validation gates such
+            // writeSets behind a frozen dedicated-test layout. Any explicit
+            // (deeper or out-of-tree) matching forbidden pattern still wins.
+            const baselinePatternHit = forbiddenPaths.some((forbidden) => isHarnessBaselineForbiddenPattern(forbidden) &&
+                pathMatchesPattern(filePath, forbidden));
+            const explicitPatternHit = forbiddenPaths.some((forbidden) => !isHarnessBaselineForbiddenPattern(forbidden) &&
+                pathMatchesPattern(filePath, forbidden));
+            const ownedByWriteSet = writePolicy === "exclusive" &&
+                writeSet.length > 0 &&
+                matchesAnyPattern(filePath, writeSet);
+            if (explicitPatternHit ||
+                !baselinePatternHit ||
+                !isAnyTestArtifactPath(filePath) ||
+                !ownedByWriteSet) {
+                violations.push(filePath);
+                continue;
+            }
+            // Exempted: canonical test-artifact file owned by the writeSet.
             continue;
         }
         if (writePolicy === "read-only" || writePolicy === "none") {
@@ -380,37 +400,6 @@ export function deriveSameInstallationGitCandidates(primary) {
     }
     return Array.from(new Set([normalized, ...(fallback ? [fallback] : [])]));
 }
-async function resolveGitExecutableCandidates(platform, env) {
-    if (platform !== "win32")
-        return ["git"];
-    const pathValue = env.PATH ?? env.Path ?? "";
-    for (const rawEntry of pathValue.split(path.delimiter)) {
-        const entry = rawEntry.trim().replace(/^"|"$/g, "");
-        if (!entry)
-            continue;
-        const candidate = path.win32.join(entry, "git.exe");
-        try {
-            await access(candidate, constants.X_OK);
-            const sameInstallation = deriveSameInstallationGitCandidates(candidate);
-            const existing = [];
-            for (const executable of sameInstallation) {
-                try {
-                    await access(executable, constants.X_OK);
-                    existing.push(executable);
-                }
-                catch {
-                    // Optional same-installation fallback is absent.
-                }
-            }
-            if (existing.length > 0)
-                return existing;
-        }
-        catch {
-            // Keep searching PATH entries.
-        }
-    }
-    return ["git"];
-}
 export async function readGitStatusPorcelain(cwd, options = {}) {
     let parentPorcelain;
     try {
@@ -510,38 +499,6 @@ export async function readGitStatusPorcelainWithDependencies(cwd, options, depen
         attempts: attemptDiagnostics,
     });
 }
-function readGitStatusPorcelainOnce(cwd, executable) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(executable, ["status", "--porcelain=v1", "--untracked-files=all"], {
-            cwd,
-            env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" },
-            stdio: ["ignore", "pipe", "pipe"],
-            windowsHide: true,
-        });
-        let stdout = "";
-        let stderr = "";
-        child.stdout.setEncoding("utf-8");
-        child.stderr.setEncoding("utf-8");
-        child.stdout.on("data", (chunk) => {
-            stdout += chunk;
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr += chunk;
-        });
-        child.on("error", reject);
-        child.on("close", (code, signal) => {
-            if (code === 0) {
-                resolve(stdout);
-                return;
-            }
-            const detail = stderr.trim() || stdout.trim() || "no stderr/stdout";
-            const error = new Error(`git status failed: ${detail}`);
-            error.exitCode = code;
-            error.signal = signal;
-            reject(error);
-        });
-    });
-}
 export async function runPostRunWriteGuard(input) {
     const afterStatus = await readGitStatusPorcelain(input.rootCwd);
     const beforeSnapshot = snapshotGitStatusPorcelain(input.beforeStatus);

package/dist/governance/exec-plans.js

@@ -191,12 +191,21 @@ function extractIndexReferences(indexContent) {
         // `(${base})` and `` `base` ``. Bare mentions are intentionally NOT
         // treated as references to avoid false positives from partial matches.
         const linkMatches = [...line.matchAll(/\[[^\]]*\]\(([^)]+\.md)\)/g)];
+        // Link spans are blanked before the backtick scan: the index convention
+        // `[`archived.md`](../completed/archived.md)` puts a bare basename in the
+        // link TEXT, which is not an entry for this directory. Reading it as one
+        // reported every archived link as a stale active entry. Blanking (rather
+        // than filtering by content) keeps `[`local.md`](local.md)`, standalone
+        // `local.md` mentions, and mixed lines working, because those still
+        // contribute through their link target or an untouched backtick span.
+        let remainder = line;
         for (const match of linkMatches) {
             const reference = match[1] ? localIndexReference(match[1]) : null;
             if (reference)
                 references.add(reference);
+            remainder = remainder.replace(match[0], " ".repeat(match[0].length));
         }
-        const backtickMatches = [...line.matchAll(/`([^`]+\.md)`/g)];
+        const backtickMatches = [...remainder.matchAll(/`([^`]+\.md)`/g)];
         for (const match of backtickMatches) {
             const reference = match[1] ? localIndexReference(match[1]) : null;
             if (reference)

package/dist/governance/harness.js

@@ -1,9 +1,4 @@
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
-import { harnessManifestSchema } from '../shared/types.js';
+import { loadNormalizedProjectConfig } from './project-config.js';
 export async function loadHarnessManifest(repoRoot) {
-    const manifestPath = path.join(repoRoot, 'harness.json');
-    const raw = await readFile(manifestPath, 'utf-8');
-    const parsed = JSON.parse(raw);
-    return harnessManifestSchema.parse(parsed);
+    return (await loadNormalizedProjectConfig(repoRoot)).manifest;
 }

package/dist/governance/manifest-types.js

@@ -209,14 +209,18 @@ export const nightSchedulerPolicySchema = z.object({
 export const workerPolicySchema = z.object({
     nightScheduler: nightSchedulerPolicySchema.optional().default({}),
 });
-export const CURSOR_HARNESS_EXECUTOR_REMOVED_ERROR = "harness executors.cursor is no longer supported; remove it and use executors.pi only (Cursor is available only via cursor-prompt sidecar)";
-export const harnessManifestSchema = z
+export const verificationCommandsSchema = z
     .object({
+    quick: z.array(z.string().trim().min(1)).optional().default([]),
+    standard: z.array(z.string().trim().min(1)).optional().default([]),
+    full: z.array(z.string().trim().min(1)).optional().default([]),
+})
+    .strict();
+export const CURSOR_HARNESS_EXECUTOR_REMOVED_ERROR = "harness executors.cursor is no longer supported; remove it and use executors.pi only (Cursor is available only via cursor-prompt sidecar)";
+const harnessManifestCommonShape = {
     $schema: z.string().optional(),
-    version: z.number(),
     project: z.string(),
     adapter: z.string().optional(),
-    governanceRoot: z.string(),
     features: z
         .object({
         goals: z.boolean().optional().default(true),
@@ -225,9 +229,7 @@ export const harnessManifestSchema = z
         .default({
         goals: true,
     }),
-    entrypoints: z.record(z.string(), z.string().nullable()),
-    artifacts: z.record(z.string(), z.string().nullable()),
-    scripts: z.record(z.string(), z.string().nullable()),
+    verification: verificationCommandsSchema.optional().default({}),
     workflowPolicy: workflowPolicySchema,
     /** Optional; absent means Night Scheduler uses package defaults when enabled by callers. */
     workerPolicy: workerPolicySchema.optional(),
@@ -237,8 +239,25 @@ export const harnessManifestSchema = z
         .strict()
         .optional()
         .default({}),
-})
-    .strict()
+};
+const harnessManifestV1Schema = z.object({
+    ...harnessManifestCommonShape,
+    version: z.literal(1),
+    governanceRoot: z.string(),
+    entrypoints: z.record(z.string(), z.string().nullable()),
+    artifacts: z.record(z.string(), z.string().nullable()),
+    scripts: z.record(z.string(), z.string().nullable()),
+}).strict();
+const harnessManifestV2Schema = z.object({
+    ...harnessManifestCommonShape,
+    version: z.literal(2),
+    governanceRoot: z.string().optional().default("docs"),
+    entrypoints: z.record(z.string(), z.string().nullable()).optional().default({}),
+    artifacts: z.record(z.string(), z.string().nullable()).optional().default({}),
+    scripts: z.record(z.string(), z.string().nullable()).optional().default({}),
+}).strict();
+export const harnessManifestSchema = z
+    .discriminatedUnion("version", [harnessManifestV1Schema, harnessManifestV2Schema])
     .superRefine((manifest, ctx) => {
     // Preserve the empty read-only compatibility projection for callers that
     // inspect parsed manifests, while rejecting this field in JSON input.