@kylecheng3146/agent-ops 0.3.3 → 0.3.4

package/dist/packages/cli/src/args.js

@@ -86,6 +86,8 @@ export function parseArgs(argv) {
     let versionSeen = false;
     let worktreeName;
     let force = false;
+    let worktreeFrom;
+    let worktreeTargetBranch;
     let worktree;
     for (let index = 0; index < argv.length; index += 1) {
         const token = argv[index];
@@ -266,6 +268,22 @@ export function parseArgs(argv) {
                 }
                 force = true;
                 break;
+            case "--from": {
+                if (worktreeFrom !== undefined) {
+                    duplicate(token);
+                }
+                worktreeFrom = readOptionValue(argv, index, token);
+                index += 1;
+                break;
+            }
+            case "--target-branch": {
+                if (worktreeTargetBranch !== undefined) {
+                    duplicate(token);
+                }
+                worktreeTargetBranch = readOptionValue(argv, index, token);
+                index += 1;
+                break;
+            }
             case "--rerun":
                 if (rerun) {
                     duplicate(token);
@@ -381,6 +399,8 @@ export function parseArgs(argv) {
             yes ||
             rerun ||
             worktree !== undefined ||
+            worktreeFrom !== undefined ||
+            worktreeTargetBranch !== undefined ||
             force) {
             throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Only --json may be combined with global help or version.");
         }
@@ -536,11 +556,22 @@ export function parseArgs(argv) {
             dryRun ||
             yes ||
             rerun)) {
-        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "worktree accepts only a name, --session and --json.");
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "worktree accepts only a name, --session, --from, --target-branch and --json.");
     }
     if (force && !(command === "worktree" && action === "remove")) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--force may be used only with worktree remove.");
     }
+    if ((worktreeFrom !== undefined || worktreeTargetBranch !== undefined) &&
+        !(command === "worktree" && action === "add")) {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--from and --target-branch may be used only with worktree add.");
+    }
+    if (worktreeFrom !== undefined && worktreeFrom.trim() === "") {
+        throw new CliArgumentError("CLI_INVALID_VALUE", "Invalid value for --from.", "--from");
+    }
+    if (worktreeTargetBranch !== undefined &&
+        !/^[A-Za-z0-9._/-]{1,128}$/u.test(worktreeTargetBranch)) {
+        throw new CliArgumentError("CLI_INVALID_VALUE", `Invalid value for --target-branch: ${worktreeTargetBranch}`, "--target-branch");
+    }
     if (command === "worktree" && action !== "add" && action !== "resume" && sessionId !== undefined) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", `worktree ${action} takes the session from the worktree; omit --session.`);
     }
@@ -563,6 +594,8 @@ export function parseArgs(argv) {
         ...(evidence.length === 0 ? {} : { evidence }),
         ...(sessionId === undefined ? {} : { sessionId }),
         ...(base === undefined ? {} : { base }),
+        ...(worktreeFrom === undefined ? {} : { worktreeFrom }),
+        ...(worktreeTargetBranch === undefined ? {} : { worktreeTargetBranch }),
         ...(checkAuth ? { checkAuth } : {}),
         ...(checkAuthTargets.length === 0 ? {} : { checkAuthTargets }),
         rerun,

package/dist/packages/cli/src/bin.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { readFile } from "node:fs/promises";
+import { readFile, readdir, stat } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -43,7 +43,8 @@ import { errorEnvelope } from "./output.js";
 import { runAgyHeadless } from "./agy-headless.js";
 import { runWorktreeCommand } from "./commands/parallel.js";
 import { ensureSessionWorktree, resolveCheckouts } from "../../../runtime/src/parallel/service.js";
-import { listWorktrees, worktreeDoctorResult } from "../../../runtime/src/parallel/manage.js";
+import { listWorktrees, branchLockDoctorResult, worktreeDoctorResult } from "../../../runtime/src/parallel/manage.js";
+import { detectGhostFiles, ghostFilesDoctorResult } from "../../../runtime/src/install/doctor.js";
 const HOOK_RUNTIME_PATH = fileURLToPath(new URL("./hook-entry.js", import.meta.url));
 async function readOptionalText(path) {
     try {
@@ -106,6 +107,48 @@ async function worktreeDoctorProbe(root) {
     }
     return worktreeDoctorResult(statuses, Date.now());
 }
+const GHOST_SCAN_ALLOWLIST = new Set([
+    ".git", ".worktrees", ".agent-ops", ".tmp", "node_modules", "dist"
+]);
+async function worktreeBranchLockProbe(root) {
+    try {
+        const result = await worktreeDependencies().git(root, ["worktree", "list", "--porcelain"]);
+        if (result.exitCode !== 0) {
+            return { status: "UNKNOWN", message: "Git could not list worktrees." };
+        }
+        return branchLockDoctorResult(result.stdout);
+    }
+    catch {
+        return { status: "UNKNOWN", message: "Git could not list worktrees." };
+    }
+}
+async function rootGhostFilesProbe(root) {
+    try {
+        const listing = await worktreeDependencies().git(root, ["ls-files", "--others", "--exclude-standard", "-z"]);
+        const untracked = listing.exitCode === 0
+            ? new Set(listing.stdout.split("\0").filter((entry) => entry.length > 0 && !entry.includes("/")))
+            : new Set();
+        const names = (await readdir(root)).filter((name) => !GHOST_SCAN_ALLOWLIST.has(name)).slice(0, 512);
+        const candidates = await Promise.all(names.map(async (name) => {
+            try {
+                const info = await stat(join(root, name));
+                return {
+                    name,
+                    size: info.size,
+                    isFile: info.isFile(),
+                    tracked: !untracked.has(name)
+                };
+            }
+            catch {
+                return { name, size: -1, isFile: false, tracked: true };
+            }
+        }));
+        return ghostFilesDoctorResult(detectGhostFiles(candidates.filter((candidate) => candidate.size >= 0)));
+    }
+    catch {
+        return { status: "UNKNOWN", message: "The repository root could not be scanned." };
+    }
+}
 const argv = process.argv.slice(2);
 function runAgy(args, options = {}) {
     return execFileSync("agy", [...args], {
@@ -301,7 +344,9 @@ else {
                                     : { status };
                             },
                             reviewTarget: async (target, deep) => await probeReviewTarget(target, { cwd: root, deep }),
-                            worktrees: async () => await worktreeDoctorProbe(root)
+                            worktrees: async () => await worktreeDoctorProbe(root),
+                            worktreeBranchLock: async () => await worktreeBranchLockProbe(root),
+                            rootGhostFiles: async () => await rootGhostFilesProbe(root)
                         },
                         ...(args.checkAuth === true
                             ? { checkReviewTargetAuth: true }

package/dist/packages/cli/src/cli.js

@@ -191,10 +191,15 @@ Options:
 Give one writing session its own Git worktree, so parallel sessions stop
 voiding each other's verification and review. Run it from the main checkout.
 
-  add <name>   Create .worktrees/<name> on branch agent-ops/<name> from HEAD,
-               copy the ignored agent-ops files and .worktreeinclude matches,
-               inherit trust for an identical config, run worktree.setup, and
-               point the session's completion gate at the new worktree.
+  add <name>   Create .worktrees/<name> on branch agent-ops/<name> from HEAD
+               (or --from <commit|branch|tag>), copy the ignored agent-ops
+               files and .worktreeinclude matches, inherit trust for an
+               identical config, run worktree.setup, and point the session's
+               completion gate at the new worktree. When the main checkout is
+               detached, --target-branch <branch> is required and names the
+               branch finish merges back into.
+               A branch already checked out in another worktree is rejected
+               before Git runs; see agent-ops worktree list.
   finish <name>
                Once its task is complete, fast-forward the main checkout's
                branch to the worktree's (after a clean rebase and
@@ -211,6 +216,10 @@ voiding each other's verification and review. Run it from the main checkout.
 
 Options:
   --session <id>   add, resume: the conversation that will work there (required)
+  --from <ref>     add: branch the new worktree from this commit, branch or tag (default HEAD)
+  --target-branch <branch>
+                   add: branch finish merges back into (defaults to the current
+                   branch; required when the main checkout is detached)
   --force          remove: discard uncommitted or unmerged work
   --json
 `

package/dist/packages/cli/src/commands/parallel.js

@@ -82,7 +82,9 @@ export async function runWorktreeCommand(options) {
     const result = await addWorktree(options.deps, {
         cwd: options.cwd,
         name: args.worktreeName,
-        sessionId
+        sessionId,
+        ...(args.worktreeFrom === undefined ? {} : { from: args.worktreeFrom }),
+        ...(args.worktreeTargetBranch === undefined ? {} : { targetBranch: args.worktreeTargetBranch })
     });
     return okEnvelope("WORKTREE_CREATED", { ...result, text: addText(result) });
 }

package/dist/packages/cli/src/commands/review.js

@@ -111,8 +111,7 @@ async function currentEvidence(options, context, criterionId, commandId, configH
             continue;
         }
         const evidence = validation.value;
-        if (evidence.schemaVersion !== 2 ||
-            evidence.taskId !== context.taskId ||
+        if (evidence.taskId !== context.taskId ||
             evidence.criterionId !== criterionId ||
             evidence.commandId !== commandId ||
             evidence.configHash !== configHash ||
@@ -137,6 +136,9 @@ async function preflightReview(options, context, sourceFingerprint) {
         options.gitRunner === undefined) {
         return { ok: false, reason: "stale-verification" };
     }
+    if (context.criteria.some((criterion) => !options.config.verification.commands.some(({ id, required }) => required && (criterion.verifierIds ?? []).includes(id)))) {
+        return { ok: false, reason: "missing-verification-evidence" };
+    }
     const configHash = calculateConfigHash(options.config);
     const commands = [];
     for (const criterion of context.criteria) {
@@ -146,7 +148,13 @@ async function preflightReview(options, context, sourceFingerprint) {
                 return { ok: false, reason: "missing-verification-evidence" };
             }
             const found = await currentEvidence(options, context, criterion.id, commandId, configHash, sourceFingerprint);
-            const selected = newestEvidence(found.current);
+            const compatible = command.evidence.kind === "test-count"
+                ? found.current.filter(({ evidence }) => evidence.schemaVersion === 3)
+                : found.current;
+            if (command.required && found.current.length > 0 && compatible.length === 0) {
+                return { ok: false, reason: "stale-verification" };
+            }
+            const selected = newestEvidence(compatible);
             if (command.required !== true) {
                 if (selected !== undefined) {
                     commands.push({

package/dist/packages/cli/src/commands/verify.js

@@ -57,7 +57,7 @@ function publicReport(report) {
     };
 }
 function formatResult(result) {
-    const testCount = result.testCount === null ? "" : ` (tests: ${result.testCount})`;
+    const testCount = result.testCount === null ? "" : ` (passed tests: ${result.testCount})`;
     const lines = [
         `- ${result.status} ${safe(result.commandId)}${testCount}`
     ];

package/dist/runtime/src/contracts.js

@@ -1,6 +1,6 @@
 export const CONFIG_SCHEMA_VERSION = 3;
 export const TASK_SCHEMA_VERSION = 1;
-export const EVIDENCE_SCHEMA_VERSION = 2;
+export const EVIDENCE_SCHEMA_VERSION = 3;
 /** @deprecated Use the document-specific schema version constants. */
 export const SCHEMA_VERSION = CONFIG_SCHEMA_VERSION;
 /**

package/dist/runtime/src/install/doctor.js

@@ -396,6 +396,30 @@ function checkVerificationCommands(config) {
     }
     return check("verification-commands", "PASS", `Required verifiers: ${required.map(({ id }) => id).join(", ")}.`);
 }
+const GHOST_NAME_PATTERN = /[\s\x00-\x1f\x7f\u2000-\u206f\ufeff]/u;
+/** Names doctor treats as unparseable pollution rather than user files. Contentful tracked files never reach this predicate. */
+export function isGhostFileName(name) {
+    return name.length === 0 || GHOST_NAME_PATTERN.test(name);
+}
+/** Root entries worth flagging: untracked regular files that are empty or unparseably named. Warns, never blocks. */
+export function detectGhostFiles(entries) {
+    return entries
+        .filter((entry) => entry.isFile && !entry.tracked && (entry.size === 0 || isGhostFileName(entry.name)))
+        .map((entry) => entry.name)
+        .sort();
+}
+/** Doctor's reading of the repository root: stray pollution is worth a look, not a failure. */
+export function ghostFilesDoctorResult(names) {
+    if (names.length === 0) {
+        return { status: "PASS", message: "No stray files at the repository root." };
+    }
+    return {
+        status: "DEGRADED",
+        message: `Unexpected file(s) at the repository root: ${names.join(", ")}.`,
+        code: "ROOT_GHOST_FILE",
+        remediation: `Inspect and remove them: ${names.map((name) => `rm ${JSON.stringify(name)}`).join("; ")}.`
+    };
+}
 /**
  * What the surrounding host withholds from a reviewer. Reported separately
  * from `review-targets` on purpose: a sandbox that blocks the network makes an
@@ -498,7 +522,13 @@ export async function doctorInstallation(options) {
         checkVerificationCommands(config.config),
         ...(options.probes?.worktrees === undefined
             ? []
-            : [await checkProbe("worktrees", options.probes.worktrees)])
+            : [await checkProbe("worktrees", options.probes.worktrees)]),
+        ...(options.probes?.worktreeBranchLock === undefined
+            ? []
+            : [await checkProbe("worktree-branch-lock", options.probes.worktreeBranchLock)]),
+        ...(options.probes?.rootGhostFiles === undefined
+            ? []
+            : [await checkProbe("root-ghost-files", options.probes.rootGhostFiles)])
     ];
     return {
         checks,

package/dist/runtime/src/parallel/manage.js

@@ -3,7 +3,7 @@ import { join, resolve } from "node:path";
 import { sha256 } from "../fs/hash.js";
 import { AgentOpsError } from "../fs/paths.js";
 import { collectChangeSurface } from "../verify/change-surface.js";
-import { assertSessionId, assertWorktreeName, bindSession, insideWorktreeDirectory, readWorktreeRecord, removeCheckout, resolveCheckouts, worktreePath, writeWorktreeRecord } from "./service.js";
+import { assertSessionId, assertWorktreeName, bindSession, insideWorktreeDirectory, parseWorktreeListPorcelain, readWorktreeRecord, removeCheckout, resolveCheckouts, worktreePath, writeWorktreeRecord } from "./service.js";
 /**
  * A baseline no source state hashes to. A resumed session inherits whatever
  * the last one left in the worktree, so none of it counts as "unchanged".
@@ -95,6 +95,35 @@ export function worktreeDoctorResult(statuses, now) {
             remediation: "Resume, finish or remove them; see agent-ops worktree list."
         };
 }
+/** Branches checked out in more than one worktree. Scans every worktree: Git's branch lock does not distinguish agent-ops checkouts from foreign ones. */
+export function detectDuplicateBranchCheckouts(porcelain) {
+    const byBranch = new Map();
+    for (const entry of parseWorktreeListPorcelain(porcelain)) {
+        if (entry.branch === null)
+            continue;
+        const paths = byBranch.get(entry.branch) ?? [];
+        paths.push(entry.path);
+        byBranch.set(entry.branch, paths);
+    }
+    return [...byBranch]
+        .filter(([, paths]) => paths.length > 1)
+        .map(([branch, paths]) => ({ branch, paths: [...paths].sort() }))
+        .sort((left, right) => left.branch.localeCompare(right.branch));
+}
+/** Doctor's reading of the branch lock: a duplicated checkout blocks switching back, so it fails. */
+export function branchLockDoctorResult(porcelain) {
+    const duplicates = detectDuplicateBranchCheckouts(porcelain);
+    if (duplicates.length === 0) {
+        return { status: "PASS", message: "No branch is checked out in more than one worktree." };
+    }
+    const detail = duplicates.map(({ branch, paths }) => `${branch} (${paths.join(", ")})`).join("; ");
+    return {
+        status: "FAIL",
+        message: `Branch checked out more than once: ${detail}.`,
+        code: "WORKTREE_BRANCH_LOCKED",
+        remediation: "Run git worktree list; switch the extra checkout to another branch, or remove it (agent-ops worktree remove <name> --force discards that work)."
+    };
+}
 async function requireRecord(mainRoot, name) {
     const record = await readWorktreeRecord(worktreePath(mainRoot, name));
     if (record === null) {

package/dist/runtime/src/parallel/service.js

@@ -17,6 +17,7 @@ export const WORKTREE_RECORD_PATH = ".agent-ops/tasks/worktree.json";
 const EXCLUDE_LINE = `/${WORKTREE_DIRECTORY}/`;
 const NAME = /^[a-z0-9](?:[a-z0-9._-]{0,62}[a-z0-9])?$/u;
 const SESSION = /^[^\0\r\n]{1,256}$/u;
+const TARGET_BRANCH = /^[A-Za-z0-9._/-]{1,128}$/u;
 const DEFAULT_SETUP_TIMEOUT_MS = 10 * 60 * 1000;
 function worktreeError(code, message) {
     return new AgentOpsError(code, message);
@@ -61,6 +62,40 @@ export function worktreePath(mainRoot, name) {
 export function insideWorktreeDirectory(mainRoot, path) {
     return path.startsWith(`${join(mainRoot, WORKTREE_DIRECTORY)}${sep}`);
 }
+/**
+ * Parses `git worktree list --porcelain` into path/branch pairs.
+ * Detached checkouts yield a null branch.
+ */
+export function parseWorktreeListPorcelain(output) {
+    const entries = [];
+    let currentPath;
+    let currentBranch;
+    const flush = () => {
+        if (currentPath !== undefined) {
+            entries.push({ path: currentPath, branch: currentBranch ?? null });
+        }
+        currentPath = undefined;
+        currentBranch = undefined;
+    };
+    for (const line of output.split("\n")) {
+        if (line.startsWith("worktree ")) {
+            flush();
+            currentPath = line.slice("worktree ".length).trim();
+        }
+        else if (line.startsWith("branch ")) {
+            const ref = line.slice("branch ".length).trim();
+            currentBranch = ref.startsWith("refs/heads/") ? ref.slice("refs/heads/".length) : ref;
+        }
+        else if (line === "detached") {
+            currentBranch = null;
+        }
+        else if (line === "") {
+            flush();
+        }
+    }
+    flush();
+    return entries.filter((entry) => entry.path.length > 0);
+}
 async function exists(path) {
     try {
         await lstat(path);
@@ -186,18 +221,37 @@ export async function removeCheckout(deps, record, force) {
     await git(deps, record.mainRoot, ["branch", force ? "-D" : "-d", record.branch], "WORKTREE_REMOVE_FAILED", `Git could not delete ${record.branch}.`);
 }
 /**
- * Creates `.worktrees/<name>` on `agent-ops/<name>` from the main checkout's
- * HEAD and makes it a working agent-ops checkout for `sessionId`.
+ * Creates `.worktrees/<name>` on `agent-ops/<name>` from `from` (default HEAD)
+ * and makes it a working agent-ops checkout for `sessionId`. When the main
+ * checkout is detached, `targetBranch` names the branch `finish` merges back
+ * into. A branch already checked out in another worktree is rejected before
+ * Git runs, so the failure names the conflicting path.
  */
 export async function addWorktree(deps, options) {
     const name = assertWorktreeName(options.name);
     const sessionId = assertSessionId(options.sessionId);
+    if (options.targetBranch !== undefined && !TARGET_BRANCH.test(options.targetBranch)) {
+        throw worktreeError("WORKTREE_TARGET_INVALID", `Invalid --target-branch ${options.targetBranch}; use 1-128 letters, digits, '.', '_', '/' or '-'.`);
+    }
+    if (options.from !== undefined && options.from.trim() === "") {
+        throw worktreeError("WORKTREE_BASE_INVALID", "Invalid --from: a commit hash, branch or tag is required.");
+    }
     const { mainRoot, currentRoot, commonDir } = await resolveCheckouts(deps, options.cwd);
     if (currentRoot !== mainRoot) {
         throw worktreeError("WORKTREE_NESTED", `Run worktree commands from the main checkout (${mainRoot}), not from inside a worktree.`);
     }
-    const targetBranch = await git(deps, mainRoot, ["symbolic-ref", "--short", "-q", "HEAD"], "WORKTREE_DETACHED_HEAD", "The main checkout must be on a branch to merge back into.");
-    const base = await git(deps, mainRoot, ["rev-parse", "--verify", "HEAD^{commit}"], "WORKTREE_NO_COMMIT", "The main checkout has no commit to branch from.");
+    const headRef = await deps.git(mainRoot, ["symbolic-ref", "--short", "-q", "HEAD"]);
+    const targetBranch = options.targetBranch ?? headRef.stdout.trim();
+    if (targetBranch === "") {
+        throw worktreeError("WORKTREE_TARGET_REQUIRED", "The main checkout is detached; pass --target-branch <branch> naming the branch finish merges back into.");
+    }
+    if (!TARGET_BRANCH.test(targetBranch)) {
+        throw worktreeError("WORKTREE_TARGET_INVALID", `Invalid target branch ${targetBranch}; use 1-128 letters, digits, '.', '_', '/' or '-'.`);
+    }
+    const fromRef = options.from ?? "HEAD";
+    const base = await git(deps, mainRoot, ["rev-parse", "--verify", `${fromRef}^{commit}`], options.from === undefined ? "WORKTREE_NO_COMMIT" : "WORKTREE_BASE_INVALID", options.from === undefined
+        ? "The main checkout has no commit to branch from."
+        : `Cannot resolve --from ${options.from} to a commit.`);
     const path = worktreePath(mainRoot, name);
     const branch = `${WORKTREE_BRANCH_PREFIX}${name}`;
     if (await exists(path)) {
@@ -206,6 +260,17 @@ export async function addWorktree(deps, options) {
     if ((await deps.git(mainRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`])).exitCode === 0) {
         throw worktreeError("WORKTREE_EXISTS", `Branch ${branch} already exists; pick another name.`);
     }
+    const listing = await deps.git(mainRoot, ["worktree", "list", "--porcelain"]);
+    if (listing.exitCode === 0) {
+        for (const entry of parseWorktreeListPorcelain(listing.stdout)) {
+            if (entry.branch !== targetBranch && entry.branch !== branch)
+                continue;
+            const listed = await realpath(entry.path).catch(() => entry.path);
+            if (listed === mainRoot)
+                continue;
+            throw worktreeError("WORKTREE_BRANCH_CHECKED_OUT", `Branch ${entry.branch} is already checked out at ${entry.path}; switch it back, finish or remove that worktree first (see agent-ops worktree list).`);
+        }
+    }
     const mainConfig = await deps.loadConfig(mainRoot);
     const mainTrust = await deps.trust.status(mainRoot, mainConfig);
     const setupSteps = mainConfig.worktree?.setup ?? [];

package/dist/runtime/src/schema/validate.js

@@ -593,7 +593,7 @@ export function validateEvidence(value) {
         "taskId",
         "testCount",
         "toolVersions"
-    ], EVIDENCE_SCHEMA_VERSION);
+    ], isRecord(value) && value.schemaVersion === 2 ? 2 : EVIDENCE_SCHEMA_VERSION);
     if (isFailure(root)) {
         return root;
     }

package/dist/runtime/src/task/completion.js

@@ -25,6 +25,8 @@ export async function checkTaskCompletionEvidence(stored, options) {
                 if (!validation.ok)
                     continue;
                 const evidence = validation.value;
+                if (command.evidence.kind === "test-count" && evidence.schemaVersion === 2)
+                    continue;
                 if (evidence.taskId === stored.task.id && evidence.criterionId === criterion.id &&
                     evidence.commandId === command.id && evidence.configHash === configHash &&
                     evidence.sourceFingerprint === sourceFingerprint &&

package/dist/runtime/src/task/service.js

@@ -4,7 +4,7 @@ import { AgentOpsError } from "../fs/paths.js";
 import { validateEvidence, validateTask } from "../schema/validate.js";
 import { renderTaskMarkdown } from "./render.js";
 import { checkTaskCompletionEvidence, findIncompleteSubtask } from "./completion.js";
-import { calculateConfigHash, FileEvidenceStore } from "../verify/evidence.js";
+import { calculateConfigHash, FileEvidenceStore, isPassingVerificationEvidence } from "../verify/evidence.js";
 import { resolveReviewScope } from "../review/scope.js";
 import { calculateSourceFingerprint } from "../verify/source-fingerprint.js";
 import { advanceFailureFingerprint } from "../verify/fingerprint.js";
@@ -353,6 +353,82 @@ export class TaskService {
             return cloneRecord(updated);
         });
     }
+    /** Append a fresh verification to a completed task without reopening it. */
+    async recordVerificationEvidence(snapshot, evidenceInput, sourceFingerprint) {
+        if (snapshot.status === "active") {
+            const result = await this.recordEvidence(snapshot.task.id, evidenceInput);
+            await this.clearFailure(snapshot.task.id);
+            return result;
+        }
+        const completion = this.#completion;
+        if (snapshot.status !== "complete" || completion === undefined) {
+            throw taskError("TASK_NOT_ACTIVE", "Completed reverification requires repository context; archived tasks are immutable.");
+        }
+        const config = await completion.loadConfig();
+        const configHash = calculateConfigHash(config);
+        if (snapshot.policyConfigHash !== configHash) {
+            throw taskError("TASK_REVERIFICATION_CHANGED", "Completed task config changed; create a new task for the new scope.");
+        }
+        const store = new FileEvidenceStore(completion.root, completion.root);
+        const matches = (value, criterionId, commandId) => {
+            const validation = validateEvidence(value);
+            return validation.ok && validation.value.taskId === snapshot.task.id &&
+                validation.value.criterionId === criterionId && validation.value.commandId === commandId &&
+                validation.value.configHash === configHash && validation.value.sourceFingerprint === sourceFingerprint
+                ? validation.value : null;
+        };
+        for (const criterion of snapshot.task.criteria) {
+            const commands = config.verification.commands.filter(({ id, required }) => required && criterion.verifierIds.includes(id));
+            if (commands.length === 0)
+                throw taskError("TASK_REVERIFICATION_CHANGED", "Completed task criteria lack required coverage.");
+            for (const command of commands) {
+                let original = false;
+                let fresh = false;
+                for (const reference of snapshot.evidence[criterion.id] ?? []) {
+                    if (reference.startsWith("review:"))
+                        continue;
+                    const evidence = matches(await store.load(reference), criterion.id, command.id);
+                    // Legacy counts identify the original scope only; they do not prove fresh PASS.
+                    if (evidence !== null && isPassingVerificationEvidence({ ...command, evidence: { kind: "exit-code" } }, evidence))
+                        original = true;
+                }
+                for (const reference of evidenceInput[criterion.id] ?? []) {
+                    const evidence = matches(await store.load(reference), criterion.id, command.id);
+                    if (evidence !== null && evidence.schemaVersion === 3 &&
+                        !snapshot.evidence[criterion.id]?.includes(reference) && isPassingVerificationEvidence(command, evidence))
+                        fresh = true;
+                }
+                if (!original || !fresh)
+                    throw taskError("TASK_REVERIFICATION_CHANGED", "Completed task source or evidence changed; fresh PASS must cover the original scope and every required verifier.");
+            }
+        }
+        const appended = normalizeEvidence(snapshot.task, evidenceInput);
+        for (const [criterionId, references] of Object.entries(appended)) {
+            for (const reference of references) {
+                const validation = validateEvidence(await store.load(reference));
+                if (!validation.ok || !snapshot.task.criteria.find(({ id }) => id === criterionId)?.verifierIds.includes(validation.value.commandId) || matches(validation.value, criterionId, validation.value.commandId) === null) {
+                    throw taskError("TASK_EVIDENCE_INVALID", "Fresh verification references must belong to this task, criterion, source and config.");
+                }
+            }
+        }
+        const scope = await resolveReviewScope({ root: completion.root, runner: completion.gitRunner,
+            ...(completion.base === undefined ? {} : { base: completion.base }) });
+        if (sourceFingerprint !== await calculateSourceFingerprint(completion.root, scope, completion.gitRunner) ||
+            configHash !== calculateConfigHash(await completion.loadConfig())) {
+            throw taskError("TASK_REVERIFICATION_CHANGED", "Source or config changed during reverification.");
+        }
+        const now = assertTimestamp(this.#now());
+        return await this.#store.mutate((state) => {
+            if (JSON.stringify(findTask(state, snapshot.task.id)) !== JSON.stringify(snapshot)) {
+                throw taskError("TASK_REVERIFICATION_STATE_CHANGED", "Task changed during reverification; retry without discarding the concurrent state.");
+            }
+            const updated = { ...snapshot, updatedAt: now, failureFingerprint: null,
+                evidence: Object.fromEntries(snapshot.task.criteria.map(({ id }) => [id,
+                    [...new Set([...(snapshot.evidence[id] ?? []), ...appended[id]])]])) };
+            replaceTask(state, updated);
+            return cloneRecord(updated);
+        });
+    }
     async archive(taskId) {
         const now = assertTimestamp(this.#now());
         return await this.#store.mutate((state) => {

package/dist/runtime/src/verify/command-executor.js

@@ -1,5 +1,5 @@
 import { runVerificationCommand } from "./spawn.js";
-import { evaluateTestCount, parseTestCount } from "./test-count.js";
+import { evaluateTestCount, parseTestSummary } from "./test-count.js";
 function classifyTestCountCode(code) {
     const classes = {
         TEST_COUNT_BELOW_MINIMUM: "test-count-below-minimum",
@@ -43,7 +43,8 @@ function classifyCommand(command, spawned) {
             testCount: null
         };
     }
-    const testCount = parseTestCount(`${spawned.stdout}\n${spawned.stderr}`);
+    const summary = parseTestSummary(`${spawned.stdout}\n${spawned.stderr}`);
+    const testCount = summary.passed;
     if (spawned.status !== "PASS") {
         return {
             status: spawned.status,
@@ -51,6 +52,9 @@ function classifyCommand(command, spawned) {
             testCount
         };
     }
+    if (summary.failed > 0) {
+        return { status: "FAIL", failureClass: "test-failures", testCount };
+    }
     const evaluation = evaluateTestCount(testCount, command.evidence.minimum);
     return {
         status: evaluation.status,

package/dist/runtime/src/verify/evidence.js

@@ -54,7 +54,8 @@ export function isPassingVerificationEvidence(command, evidence) {
         return false;
     }
     return command.evidence.kind !== "test-count" ||
-        evaluateTestCount(evidence.testCount, command.evidence.minimum).status === "PASS";
+        (evidence.schemaVersion === EVIDENCE_SCHEMA_VERSION &&
+            evaluateTestCount(evidence.testCount, command.evidence.minimum).status === "PASS");
 }
 export class FileEvidenceStore {
     #root;

package/dist/runtime/src/verify/service.js

@@ -113,6 +113,10 @@ export class VerificationService {
             throw verificationError("VERIFICATION_INPUT_INVALID", validation.errors[0]?.message ??
                 "Task and verification configuration are incompatible.");
         }
+        const missingCriteria = validation.value.criteria.filter((criterion) => !this.#options.config.verification.commands.some(({ id, required }) => required && criterion.verifierIds.includes(id)));
+        if (missingCriteria.length > 0) {
+            throw verificationError("VERIFICATION_UNKNOWN", `Criteria without required coverage: ${missingCriteria.map(({ id }) => id).join(", ")}. Configure at least one required verifier for each criterion and recreate the task; no verifier commands were run.`);
+        }
         const reviewScope = await resolveReviewScope({
             root: this.#options.root,
             runner: this.#options.gitRunner,
@@ -167,9 +171,8 @@ export class VerificationService {
                 }
             }
             if (Object.keys(taskEvidence).length > 0) {
-                await this.#options.taskService.recordEvidence(taskId, taskEvidence);
+                await this.#options.taskService.recordVerificationEvidence(stored, taskEvidence, sourceFingerprint);
             }
-            await this.#options.taskService.clearFailure(taskId);
         }
         else {
             const required = results.filter((result) => result.required);

package/dist/runtime/src/verify/test-count.js

@@ -1,108 +1,108 @@
 const MAX_SUMMARY_BYTES = 1024 * 1024;
-const NUMBER_SOURCE = String.raw `\d{1,16}`;
+const NUMBER_SOURCE = String.raw `\d+`;
 function safeCount(value) {
     const parsed = Number(value);
     return Number.isSafeInteger(parsed) && parsed >= 0
         ? parsed
         : null;
 }
-function addCandidate(candidates, source) {
-    const parsed = safeCount(source);
-    if (parsed !== null) {
-        candidates.push(parsed);
+/** Counts outcomes, never discovery totals. Conflicting summaries fail closed. */
+export function parseTestSummary(output) {
+    if (output.includes("\0") || Buffer.byteLength(output, "utf8") > MAX_SUMMARY_BYTES) {
+        return { passed: null, failed: 0 };
     }
-}
-function parsePytestSummary(line) {
-    if (!/\bin \d+(?:\.\d+)?s(?:\s|$)/u.test(line)) {
-        return null;
-    }
-    const statusPattern = new RegExp(`(${NUMBER_SOURCE}) (passed|failed|skipped|error|errors|xfailed|xpassed|deselected)`, "gu");
-    let total = 0;
-    let matched = false;
-    for (const match of line.matchAll(statusPattern)) {
-        const source = match[1];
-        const status = match[2];
-        if (source === undefined || status === undefined) {
-            return null;
+    const summaries = [];
+    let nodePassed = null;
+    let nodeFailed = 0;
+    let nodeSeen = false;
+    let invalid = false;
+    const nodeCounts = new Map();
+    for (const raw of output.replace(/\u001b\[[0-9;]*m/gu, "").split(/\r?\n/u)) {
+        const line = raw.trim();
+        const node = new RegExp(`^(?:#|ℹ) (tests|pass|fail|cancelled|skipped|todo) (${NUMBER_SOURCE})$`, "u").exec(line);
+        if (node !== null) {
+            nodeSeen = true;
+            const count = safeCount(node[2]);
+            if (count === null || (nodeCounts.has(node[1]) && nodeCounts.get(node[1]) !== count))
+                invalid = true;
+            else
+                nodeCounts.set(node[1], count);
+            continue;
         }
-        const count = safeCount(source);
-        if (count === null ||
-            (status !== "deselected" &&
-                total > Number.MAX_SAFE_INTEGER - count)) {
-            return null;
+        if (/^(?:#|ℹ) (?:tests|pass|fail|cancelled|skipped|todo)\b/u.test(line)) {
+            invalid = true;
+            continue;
         }
-        if (status !== "deselected") {
-            total += count;
+        const rust = new RegExp(`^test result: (ok|FAILED)\\. (${NUMBER_SOURCE}) passed; (${NUMBER_SOURCE}) failed;`, "u").exec(line);
+        if (rust !== null) {
+            const passed = safeCount(rust[2]);
+            const failed = safeCount(rust[3]);
+            if (passed === null || failed === null)
+                invalid = true;
+            summaries.push({ passed, failed: Math.max(failed ?? 0, rust[1] === "FAILED" ? 1 : 0) });
+            continue;
         }
-        matched = true;
-    }
-    return matched ? total : null;
-}
-function parseRustSummary(line) {
-    const match = new RegExp(`^test result: (?:ok|FAILED)\\. (${NUMBER_SOURCE}) passed; (${NUMBER_SOURCE}) failed; ${NUMBER_SOURCE} ignored; ${NUMBER_SOURCE} measured; ${NUMBER_SOURCE} filtered out$`, "u").exec(line);
-    if (match === null) {
-        return null;
+        const isJest = /^Tests:/u.test(line);
+        const isVitest = /^Tests\s+/u.test(line) && /\(\d+\)\s*$/u.test(line);
+        const isPytest = /\bin \d+(?:\.\d+)?s(?:\s|=|$)/u.test(line);
+        if (isJest || isVitest || isPytest) {
+            let passed = 0;
+            let failed = 0;
+            let matched = false;
+            let total = 0;
+            const seen = new Set();
+            for (const match of line.matchAll(new RegExp(`(${NUMBER_SOURCE}) (passed|failed|skipped|todo|error|errors|cancelled|xfailed|xpassed|deselected)\\b`, "gu"))) {
+                matched = true;
+                const count = safeCount(match[1]);
+                const status = match[2];
+                if (count === null || seen.has(status)) {
+                    invalid = true;
+                    continue;
+                }
+                seen.add(status);
+                if (status !== "deselected")
+                    total += count;
+                if (!Number.isSafeInteger(total))
+                    invalid = true;
+                if (status === "passed")
+                    passed = count;
+                if (["failed", "error", "errors", "cancelled"].includes(status)) {
+                    failed += count;
+                    if (!Number.isSafeInteger(failed))
+                        invalid = true;
+                }
+            }
+            const totalMatch = isJest ? /\b(\d+) total(?:\s|$)/u.exec(line) : isVitest ? /\((\d+)\)\s*$/u.exec(line) : null;
+            if (matched && totalMatch !== null && safeCount(totalMatch[1]) !== total)
+                invalid = true;
+            // Missing passed in a recognized outcome summary means zero passes;
+            // a discovery/total-only line gives no outcome evidence.
+            summaries.push({ passed: matched ? passed : null, failed });
+            continue;
+        }
+        if (/^collected 0 items?$/u.test(line))
+            summaries.push({ passed: 0, failed: 0 });
     }
-    const passedSource = match[1];
-    const failedSource = match[2];
-    if (passedSource === undefined || failedSource === undefined) {
-        return null;
+    if (nodeSeen) {
+        nodePassed = nodeCounts.get("pass") ?? (nodeCounts.get("tests") === 0 ? 0 : null);
+        nodeFailed = (nodeCounts.get("fail") ?? 0) + (nodeCounts.get("cancelled") ?? 0);
+        if (!Number.isSafeInteger(nodeFailed))
+            invalid = true;
+        const total = nodeCounts.get("tests");
+        const outcomes = (nodePassed ?? 0) + nodeFailed + (nodeCounts.get("skipped") ?? 0) + (nodeCounts.get("todo") ?? 0);
+        if (!Number.isSafeInteger(outcomes) || (total !== undefined && outcomes > total))
+            invalid = true;
+        summaries.push({ passed: nodePassed, failed: nodeFailed });
     }
-    const passed = safeCount(passedSource);
-    const failed = safeCount(failedSource);
-    if (passed === null ||
-        failed === null ||
-        passed > Number.MAX_SAFE_INTEGER - failed) {
-        return null;
+    const first = summaries[0];
+    const failed = summaries.some((summary) => summary.failed > 0) ? 1 : 0;
+    if (invalid || first === undefined || summaries.some((summary) => summary.passed !== first.passed || summary.failed !== first.failed)) {
+        return { passed: null, failed };
     }
-    return passed + failed;
+    return { passed: first.passed, failed: first.failed };
 }
 export function parseTestCount(output) {
-    if (output.includes("\0") ||
-        Buffer.byteLength(output, "utf8") > MAX_SUMMARY_BYTES) {
-        return null;
-    }
-    const candidates = [];
-    const nodePattern = new RegExp(`^# tests (${NUMBER_SOURCE})$`, "u");
-    const collectedPattern = new RegExp(`^collected (${NUMBER_SOURCE}) items?$`, "u");
-    const jestPattern = new RegExp(`^Tests:\\s+.*\\b(${NUMBER_SOURCE}) total(?:\\s|$)`, "u");
-    const vitestPattern = new RegExp(`^Tests\\s+.*\\((${NUMBER_SOURCE})\\)\\s*$`, "u");
-    for (const rawLine of output.split(/\r?\n/u)) {
-        const line = rawLine.trim();
-        if (line.length === 0) {
-            continue;
-        }
-        const node = nodePattern.exec(line);
-        if (node?.[1] !== undefined) {
-            addCandidate(candidates, node[1]);
-        }
-        const collected = collectedPattern.exec(line);
-        if (collected?.[1] !== undefined) {
-            addCandidate(candidates, collected[1]);
-        }
-        const jest = jestPattern.exec(line);
-        if (jest?.[1] !== undefined) {
-            addCandidate(candidates, jest[1]);
-        }
-        const vitest = vitestPattern.exec(line);
-        if (vitest?.[1] !== undefined) {
-            addCandidate(candidates, vitest[1]);
-        }
-        const pytest = parsePytestSummary(line);
-        if (pytest !== null) {
-            candidates.push(pytest);
-        }
-        const rust = parseRustSummary(line);
-        if (rust !== null) {
-            candidates.push(rust);
-        }
-    }
-    const first = candidates[0];
-    if (first === undefined ||
-        candidates.some((candidate) => candidate !== first)) {
-        return null;
-    }
-    return first;
+    return parseTestSummary(output).passed;
 }
 export function evaluateTestCount(testCount, minimum = 1) {
     if (!Number.isSafeInteger(minimum) || minimum < 0) {

package/docs/en/spec/acceptance-and-evidence.md

@@ -33,10 +33,14 @@ The verifier MUST return FAIL when a criterion is missing, duplicated, unknown,
 - Every criterion needs at least one required verifier and current PASS evidence for every required verifier it names. Verify always includes those task-required commands, even when path mappings select a narrower set. Supply the evidence file references produced by `agent-ops verify --task <id>`, not command strings or a written assertion of PASS.
 - The task's config baseline and evidence must match the current effective config and source fingerprint in the selected scope. Outstanding verification failures block completion. A newer failing result cannot be replaced by an older PASS; contradictory results at the same timestamp fail closed.
 - Run `agent-ops review --task <id> --yes` for the whole task. Completion requires its current, task-bound PASS attestation; generic reviews and partial-criterion reviews do not satisfy it.
-- Starting an authorized review invalidates the previous attestation for that source fingerprint. If the reviewer cannot run or does not pass, run a fresh successful whole-task review before completion.
+- An unchanged task, source, criteria and config may reuse its recorded PASS review after fresh verification. Starting a fresh authorized review (`--rerun`) invalidates the previous attestation for that source fingerprint. If the reviewer cannot run or does not pass, run a fresh successful whole-task review before completion.
 - All subtasks and descendants must have completed without an outstanding failure. Archiving unfinished work does not satisfy this requirement. A completed or archived parent cannot accept new subtasks. If a subtask is abandoned, recreate the parent task without that cancelled branch and verify/review the new task tree.
 - Evidence, source and config validation run outside the task store lock. After rechecking source and config, completion briefly locks state, rejects a changed task snapshot (`TASK_COMPLETION_STATE_CHANGED`), rechecks descendants, and writes completion atomically. Slow validation does not block task reads or other task mutations; a concurrent mutation remains intact when completion is rejected.
 
+`test-count.minimum` counts explicitly passed tests, excluding skipped, todo, expected failures and discovery totals. Zero passed tests fail even with minimum zero; an unrecognizable passed summary is UNKNOWN. Explicit failed, error or cancelled outcomes fail even when the process exits zero. Exit-code verifiers retain their existing behavior. Task verify returns `VERIFICATION_UNKNOWN`, names uncovered criteria and runs no verifier commands when any criterion lacks a required verifier; optional-only results cannot establish formal task verification.
+
+New verification evidence uses schema 3. Schema 2 remains readable and its exit-code evidence remains valid; schema 2 test-count evidence cannot establish PASS and requires fresh verification. Old references are retained. A completed task may append fresh verification only for its original source, criteria and config, preserving completedAt and review references. Its entire state snapshot is compared atomically before appending and clearing failure; concurrent changes are preserved and rejected. Fresh FAIL or UNKNOWN blocks completion until resolved; archived tasks remain immutable. Source or config changes require a new task.
+
 Existing task files remain readable without migration. Legacy tasks without a config baseline, arbitrary evidence references, or unfinished archived children must be recreated and verified/reviewed before completion. Repeating completion also revalidates the evidence; an old completed status alone is insufficient. Runtime callers must supply `TaskServiceOptions.completion`; omitting this repository context fails closed for completion while leaving read-only task operations available.
 
 Before committing, use the default worktree scope for verify, review and completion. After committing, use the same `--base <git-ref>` on all three commands to produce fresh proof for that committed range; `TaskServiceOptions.completion.base` selects it for runtime callers. Base mode requires a clean worktree. Without a worktree change surface or an explicit base, completion returns `TASK_COMPLETION_SCOPE_REQUIRED`. The agy Stop gate still checks worktree-scoped proof: complete and stop before committing, or use its user-approved one-time permit after inspecting a completed base-scoped task.

package/docs/zh-TW/spec/acceptance-and-evidence.md

@@ -1,6 +1,6 @@
 # 驗收與證據
 
-English source version: 2026-09-07. Revalidate: when the English specification changes.
+English source version: 2026-09-27. Revalidate: when the English specification changes.
 
 ## EVIDENCE-CRITERION-001
 
@@ -35,10 +35,14 @@ English source version: 2026-09-07. Revalidate: when the English specification c
 - 每項 criterion 至少需要一個 required verifier，且其列出的每個 required verifier 都要有目前有效的 PASS evidence。即使 path mapping 選出較小範圍，verify 也會包含 task 明列的 required 命令。請提供 `agent-ops verify --task <id>` 產生的證據檔參照，不能只填命令文字或自行宣稱 PASS。
 - 任務的 config baseline、evidence 必須符合目前有效設定與所選 scope 的來源指紋。尚未解決的驗證失敗會阻擋完成；舊 PASS 不能蓋過較新的失敗，同時間戳的矛盾結果也會阻擋。
 - 使用 `agent-ops review --task <id> --yes` 審查整個任務。完成時必須有目前有效且綁定該 task 的 PASS attestation；generic review 與只涵蓋部分 criterion 的 review 不算。
-- 開始一次已授權的 review 會撤銷該來源指紋先前的 attestation。若 reviewer 未能執行或未通過，完成前必須重新取得成功的全任務 review。
+- task、來源、criteria 與 config 不變時，重新驗證後可沿用原 PASS review。開始新的已授權 review（`--rerun`）才會撤銷該來源指紋先前的 attestation。若 reviewer 未能執行或未通過，完成前必須重新取得成功的全任務 review。
 - 所有子任務與後代任務都必須已完成，且沒有尚未解決的失敗。封存未完成工作不算完成；已完成或封存的 parent 不能新增子任務。若放棄某個 subtask，請重建不含該取消分支的 parent task，並重新驗證與審查新的 task tree。
 - 證據、來源與設定檢查在 task store 鎖外執行。再次確認來源與設定後，完成操作才短暫鎖住狀態，比對 task 快照（改變時回傳 `TASK_COMPLETION_STATE_CHANGED`）、重查後代任務並原子寫入。慢速檢查不會阻擋 task 讀取或其他修改；完成被拒絕時，併發修改仍會保留。
 
+`test-count.minimum` 只計明確 passed 的測試，排除 skipped、todo、預期失敗與 discovery total。零 passed 即使 minimum 為零也會 FAIL；無法辨識 passed 摘要時為 UNKNOWN。摘要有 failed、error 或 cancelled，即使 process exit code 為零也會 FAIL。exit-code verifier 保留既有行為。任一 criterion 缺少 required verifier 時，task verify 回傳 `VERIFICATION_UNKNOWN`、列出缺少 coverage 的 criterion，且不執行 verifier 命令；只有 optional 結果不能建立正式 task 的驗證 PASS。
+
+新 verification evidence 使用 schema 3。Schema 2 仍可讀取，其 exit-code 證據仍有效；schema 2 test-count 證據不能建立 PASS，必須重新驗證。舊參照會保留。Completed task 只可為原來源、criteria 與 config 追加 fresh verification，保留 completedAt 與 review 參照。追加與清除 failure 前，會原子比對完整狀態快照；併發修改保留並拒絕本次追加。Fresh FAIL 或 UNKNOWN 在修正前阻擋完成；archived task 不可修改。來源或 config 改變時必須建立新 task。
+
 既有 task 檔案仍可直接讀取，不需資料格式遷移。缺少 config baseline、使用任意文字證據，或含有未完成但已封存子任務的舊任務，必須重建並完成驗證與審查。重複執行 complete 也會重新驗證證據；舊的 completed 狀態本身不夠。Runtime 呼叫端必須提供 `TaskServiceOptions.completion`；缺少此 repository context 時，complete 會拒絕執行，但仍可讀取任務。
 
 Commit 前，verify、review、complete 使用預設 worktree scope。Commit 後，三個命令都使用相同的 `--base <git-ref>`，為已提交範圍重新產生證據；runtime 呼叫端使用 `TaskServiceOptions.completion.base`。Base 模式要求 worktree 乾淨。沒有 worktree 變更又未指定 base 時，complete 會回傳 `TASK_COMPLETION_SCOPE_REQUIRED`。agy Stop gate 仍檢查 worktree scope 的證據：請在 commit 前完成並停止，或由使用者檢查已完成的 base-scope 任務後，核准一次性的 Stop permit。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kylecheng3146/agent-ops",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "Evidence-driven development loops for agy, Codex, Claude Code, and opencode",
   "type": "module",
   "license": "MIT",

package/schemas/evidence.schema.json

@@ -24,7 +24,7 @@
   ],
   "properties": {
     "schemaVersion": {
-      "const": 2
+      "enum": [2, 3]
     },
     "taskId": {
       "$ref": "#/$defs/id"