@kylecheng3146/agent-ops 0.1.21 → 0.1.24

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

@@ -336,8 +336,9 @@ export function parseArgs(argv) {
     if (command !== "update" && targetVersion !== undefined) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--target-version may be used only with update.");
     }
-    if (base !== undefined && command !== "verify" && command !== "review") {
-        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--base may be used only with verify or review.");
+    if (base !== undefined && command !== "verify" && command !== "review" &&
+        !(command === "task" && action === "complete")) {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--base may be used only with verify, review or task complete.");
     }
     if (hookTargets.length > 0 &&
         command !== "init" &&
@@ -348,7 +349,9 @@ export function parseArgs(argv) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--check-auth may be used only with doctor.");
     }
     if (reviewTargets.length > 0 && command !== "init") {
-        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--review-target may be used only with init.");
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", command === "review"
+            ? "--review-target configures init; for one review run, use --harness <target>."
+            : "--review-target may be used only with init.");
     }
     if (completionGate !== undefined && command !== "init") {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--completion-gate may be used only with init.");
@@ -399,9 +402,8 @@ export function parseArgs(argv) {
             evidence.length > 0 ||
             dryRun ||
             yes ||
-            base !== undefined ||
             (taskId !== undefined && sessionId !== undefined))) {
-        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Verify accepts only scope, task or session, and json options.");
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Verify accepts only scope, task or session, base, and json options.");
     }
     if (command === "review" &&
         (title !== undefined || sessionId !== undefined)) {
@@ -412,7 +414,9 @@ export function parseArgs(argv) {
         (criteria.length > 0 || evidence.length > 0)) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Review criteria and evidence require --task.");
     }
-    if (command === "review" && harness !== undefined && harness.length !== 1) {
+    if (command === "review" &&
+        harness !== undefined &&
+        (harness.length !== 1 || !REVIEW_TARGETS.has(harness[0] ?? ""))) {
         invalidValue("--harness", harness.join(","));
     }
     if (command === "allow-stop" &&

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

@@ -29,9 +29,9 @@ import { formatInstallPlan, runInitCommand } from "./commands/init.js";
 import { formatUninstallPlan, runUninstallCommand } from "./commands/uninstall.js";
 import { runTaskCommand } from "./commands/task.js";
 import { runReviewCommand } from "./commands/review.js";
-import { createReviewExecutor } from "../../../runtime/src/review/execute.js";
+import { createReviewExecutor, ReviewInterruptedError } from "../../../runtime/src/review/execute.js";
 import { probeReviewTarget } from "../../../runtime/src/review/probe.js";
-import { resolveReviewRole } from "../../../runtime/src/review/roles.js";
+import { detectHostTarget, orderChain, resolveReviewRole } from "../../../runtime/src/review/roles.js";
 import { runTrustCommand } from "./commands/trust.js";
 import { runVerifyCommand } from "./commands/verify.js";
 import { runAllowStopCommand } from "./commands/allow-stop.js";
@@ -353,7 +353,12 @@ else {
                             : { targetVersion: updateArgs.targetVersion })
                     });
                 }
-                const taskService = new TaskService(new FileTaskStore(join(root, ".agent-ops", "tasks", "state.json"), root));
+                const taskService = new TaskService(new FileTaskStore(join(root, ".agent-ops", "tasks", "state.json"), root), { completion: {
+                        root,
+                        gitRunner: gitRunner(root),
+                        ...(args.base === undefined ? {} : { base: args.base }),
+                        loadConfig: async () => (await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project")).config
+                    } });
                 if (args.command === "allow-stop") {
                     const config = (await loadEffectiveConfig(root, "project")).config;
                     return await runAllowStopCommand({
@@ -383,42 +388,69 @@ else {
                     const reviewSessionId = process.env.AGENT_OPS_SESSION_ID;
                     const reviewConfig = (await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project")).config;
                     const reviewRole = resolveReviewRole("independent-review", reviewConfig.reviewRoles ?? []);
-                    return await runReviewCommand({
-                        args,
-                        authorized: args.yes,
-                        tasks: taskService,
-                        ...(args.taskId === undefined ? {} : { taskId: args.taskId }),
-                        ...(reviewSessionId === undefined
-                            ? {}
-                            : { sessionId: reviewSessionId }),
-                        ...(reviewConfig.reviewRoles === undefined
-                            ? {}
-                            : { roles: reviewConfig.reviewRoles }),
-                        root,
-                        gitRunner: gitRunner(root),
-                        policyConfigHash: calculateConfigHash(reviewConfig),
-                        currentPolicyConfigHash: async () => calculateConfigHash((await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project")).config),
-                        config: reviewConfig,
-                        evidenceStore: new FileEvidenceStore(root, root),
-                        execute: createReviewExecutor({
-                            targets: reviewRole?.targets ?? [],
-                            cwd: root,
-                            ...(reviewRole?.model === undefined
+                    const selectedReviewTarget = args.harness?.[0];
+                    const plannedReviewTargets = orderChain(selectedReviewTarget === undefined
+                        ? reviewRole?.targets ?? []
+                        : [selectedReviewTarget], detectHostTarget(process.env));
+                    const controller = new AbortController();
+                    let interruptedBy;
+                    const interrupt = (signal) => {
+                        interruptedBy ??= signal;
+                        controller.abort(signal);
+                    };
+                    const onSigint = () => interrupt("SIGINT");
+                    const onSigterm = () => interrupt("SIGTERM");
+                    process.once("SIGINT", onSigint);
+                    process.once("SIGTERM", onSigterm);
+                    try {
+                        return await runReviewCommand({
+                            args,
+                            authorized: args.yes,
+                            tasks: taskService,
+                            ...(args.taskId === undefined ? {} : { taskId: args.taskId }),
+                            ...(reviewSessionId === undefined
                                 ? {}
-                                : { model: reviewRole.model }),
-                            ...(reviewRole?.effort === undefined
+                                : { sessionId: reviewSessionId }),
+                            ...(reviewConfig.reviewRoles === undefined
                                 ? {}
-                                : { effort: reviewRole.effort }),
-                            ...(reviewRole?.timeoutMs === undefined
-                                ? {}
-                                : { timeoutMs: reviewRole.timeoutMs }),
-                            onProgress: (line) => {
-                                if (!args.json) {
+                                : { roles: reviewConfig.reviewRoles }),
+                            targets: plannedReviewTargets,
+                            root,
+                            gitRunner: gitRunner(root),
+                            policyConfigHash: calculateConfigHash(reviewConfig),
+                            currentPolicyConfigHash: async () => calculateConfigHash((await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project")).config),
+                            config: reviewConfig,
+                            evidenceStore: new FileEvidenceStore(root, root),
+                            execute: createReviewExecutor({
+                                targets: plannedReviewTargets,
+                                cwd: root,
+                                ...(reviewRole?.model === undefined
+                                    ? {}
+                                    : { model: reviewRole.model }),
+                                ...(reviewRole?.effort === undefined
+                                    ? {}
+                                    : { effort: reviewRole.effort }),
+                                ...(reviewRole?.timeoutMs === undefined
+                                    ? {}
+                                    : { timeoutMs: reviewRole.timeoutMs }),
+                                signal: controller.signal,
+                                onProgress: (line) => {
                                     process.stderr.write(`${line}\n`);
                                 }
-                            }
-                        })
-                    });
+                            })
+                        });
+                    }
+                    catch (error) {
+                        if (error instanceof ReviewInterruptedError &&
+                            interruptedBy !== undefined) {
+                            process.exit(interruptedBy === "SIGINT" ? 130 : 143);
+                        }
+                        throw error;
+                    }
+                    finally {
+                        process.removeListener("SIGINT", onSigint);
+                        process.removeListener("SIGTERM", onSigterm);
+                    }
                 }
                 if (args.command === "config") {
                     return explainConfigCommand(await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project"));

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

@@ -32,7 +32,7 @@ Commands:
 
 Options:
   --scope <project|user>
-  --harness <all|both|agy|claude|codex|opencode|comma-separated>  Init/update/uninstall
+  --harness <all|both|agy|claude|codex|opencode|comma-separated>  Init/update/uninstall; review accepts one configured target
   --hook-target <harness=surface-id>  Repeatable advanced init/update option
   --profile <core|advisory|guardrails|loop>  Repeatable
   --review-target <codex|agy|claude>  Repeatable init option; external review
@@ -48,7 +48,7 @@ Options:
   --criterion <json>                    Repeatable
   --evidence <criterion-id=reference>   Repeatable
   --session <id>
-  --base <git-ref>                    Verify/review a clean committed range
+  --base <git-ref>                    Verify/review/complete a clean committed range
   --dry-run
   --json
   --yes

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

@@ -20,25 +20,20 @@ export function normalizeHookInput(harness, input) {
     }
 }
 /**
- * Hooks are advisory infrastructure: every failure path stays fail-open with
- * exit code 0 so a broken toolkit can never wedge the harness.
+ * Advisory failures stay fail-open; an enabled completion Stop fails closed
+ * through the host's native decision protocol (still exit code 0).
  */
 export async function runHookCommand(options) {
     try {
         const { capabilities } = options.config.profiles.length === 0
             ? { capabilities: [] }
             : resolveCapabilities(options.config);
-        let input;
-        try {
-            input = JSON.parse(options.stdin);
-        }
-        catch {
-            return { exitCode: 0, stdout: "", stderr: "" };
-        }
+        const input = JSON.parse(options.stdin);
         const descriptor = harnessDescriptor(options.harness);
         const normalized = normalizeHookInput(options.harness, input);
-        if (normalized === null) {
-            return { exitCode: 0, stdout: "", stderr: "" };
+        if (normalized === null ||
+            (options.completionGate !== undefined && options.event === "Stop" && normalized.event !== "stop")) {
+            throw new Error("Invalid hook input.");
         }
         const stopRegistration = descriptor.control.registrations.find(({ capability }) => capability === "optional-stop-verify");
         const stopVerification = options.stopVerification !== undefined &&
@@ -57,7 +52,7 @@ export async function runHookCommand(options) {
         return descriptor.runtime.formatOutput(options.event, result);
     }
     catch {
-        if (options.harness === "agy" && options.completionGate !== undefined) {
+        if (options.harness === "agy" && options.event === "Stop" && options.completionGate !== undefined) {
             return harnessDescriptor("agy").runtime.formatOutput(options.event, {
                 action: "block",
                 status: "UNKNOWN",

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

@@ -1,7 +1,7 @@
 import { buildReviewPacket } from "../../../../runtime/src/review/packet.js";
 import { runIndependentReview } from "../../../../runtime/src/review/runner.js";
 import { renderReviewResult } from "../../../../runtime/src/review/render.js";
-import { saveReviewAttestation } from "../../../../runtime/src/review/attestation.js";
+import { invalidateReviewAttestation, saveReviewAttestation } from "../../../../runtime/src/review/attestation.js";
 import { resolveReviewRole } from "../../../../runtime/src/review/roles.js";
 import { AgentOpsError } from "../../../../runtime/src/fs/paths.js";
 import { assertSafeSupportingPaths, isReviewerPolicyPath, resolveReviewScope, reviewScopeSignature } from "../../../../runtime/src/review/scope.js";
@@ -75,7 +75,8 @@ async function taskContext(options) {
         policyConfigHash: record.policyConfigHash,
         evidence: record.evidence,
         failureFingerprint: record.failureFingerprint,
-        criteria
+        criteria,
+        allCriteriaReviewed: criteria.length === record.task.criteria.length
     };
 }
 function newestEvidence(values) {
@@ -213,6 +214,9 @@ function sourceChangedResult(result) {
         model: result.model,
         effort: result.effort,
         prompt: result.prompt,
+        ...(result.plannedTargets === undefined
+            ? {}
+            : { plannedTargets: result.plannedTargets }),
         ...(result.scope === undefined ? {} : { scope: result.scope }),
         ...(result.independence === undefined
             ? {}
@@ -229,7 +233,22 @@ function sourceChangedResult(result) {
 export async function runReviewCommand(options) {
     const role = resolveReviewRole(options.role ?? "independent-review", options.roles ?? []);
     const selectedHarness = harness(options.args.harness);
-    const target = role?.targets[0] ?? selectedHarness ?? "codex";
+    const configuredTargets = role?.targets ?? [];
+    if (selectedHarness !== undefined &&
+        !configuredTargets.includes(selectedHarness)) {
+        throw new AgentOpsError("REVIEW_TARGET_NOT_CONFIGURED", `${selectedHarness} is not enabled for independent-review. Configure it with init --review-target ${selectedHarness}.`);
+    }
+    const plannedTargets = selectedHarness === undefined
+        ? options.targets ?? configuredTargets
+        : [selectedHarness];
+    const target = plannedTargets[0] ?? selectedHarness ?? "codex";
+    const resultBase = {
+        harness: target,
+        plannedTargets,
+        model: role?.model ?? options.model ?? "configured",
+        effort: role?.effort ?? options.effort ?? "configured",
+        prompt: ""
+    };
     const context = await taskContext(options);
     const evidenceRequirements = (options.args.evidence ?? []).map((value) => {
         const separator = value.indexOf("=");
@@ -253,41 +272,38 @@ export async function runReviewCommand(options) {
             const reason = scopeReason(error);
             if (reason !== undefined) {
                 return notRunEnvelope({
+                    ...resultBase,
                     status: "NOT_RUN",
-                    reason,
-                    harness: target,
-                    model: role?.model ?? options.model ?? "configured",
-                    effort: role?.effort ?? options.effort ?? "configured",
-                    prompt: ""
+                    reason
                 });
             }
             throw error;
         }
         if (scope.changedFiles.some(isReviewerPolicyPath)) {
             return notRunEnvelope({
+                ...resultBase,
                 status: "NOT_RUN",
                 reason: "reviewer-policy-changed",
-                harness: target,
-                model: role?.model ?? options.model ?? "configured",
-                effort: role?.effort ?? options.effort ?? "configured",
-                prompt: "",
                 scope
             });
         }
         sourceFingerprint = await calculateSourceFingerprint(options.root, scope, options.gitRunner);
+        if (options.authorized) {
+            await invalidateReviewAttestation(options.root, sourceFingerprint);
+        }
         if (context !== undefined && options.policyConfigHash !== undefined) {
             if (context.policyConfigHash === null) {
                 return notRunEnvelope({
+                    ...resultBase,
                     status: "NOT_RUN", reason: "reviewer-policy-baseline-missing",
-                    harness: target, model: role?.model ?? options.model ?? "configured",
-                    effort: role?.effort ?? options.effort ?? "configured", prompt: "", scope
+                    scope
                 });
             }
             if (context.policyConfigHash !== options.policyConfigHash) {
                 return notRunEnvelope({
+                    ...resultBase,
                     status: "NOT_RUN", reason: "reviewer-policy-changed",
-                    harness: target, model: role?.model ?? options.model ?? "configured",
-                    effort: role?.effort ?? options.effort ?? "configured", prompt: "", scope
+                    scope
                 });
             }
         }
@@ -295,9 +311,9 @@ export async function runReviewCommand(options) {
             const preflight = await preflightReview(options, context, sourceFingerprint);
             if (!preflight.ok) {
                 return notRunEnvelope({
+                    ...resultBase,
                     status: "NOT_RUN", reason: preflight.reason,
-                    harness: target, model: role?.model ?? options.model ?? "configured",
-                    effort: role?.effort ?? options.effort ?? "configured", prompt: "", scope
+                    scope
                 });
             }
             verification = preflight.summary;
@@ -324,12 +340,9 @@ export async function runReviewCommand(options) {
                     : undefined;
             if (reason !== undefined) {
                 return notRunEnvelope({
+                    ...resultBase,
                     status: "NOT_RUN",
-                    reason,
-                    harness: target,
-                    model: role?.model ?? options.model ?? "configured",
-                    effort: role?.effort ?? options.effort ?? "configured",
-                    prompt: ""
+                    reason
                 });
             }
         }
@@ -338,6 +351,7 @@ export async function runReviewCommand(options) {
     const result = await runIndependentReview({
         invocation: {
             harness: target,
+            plannedTargets,
             model: role?.model ?? options.model ?? "configured",
             effort: role?.effort ?? options.effort ?? "configured",
             packet,
@@ -412,7 +426,8 @@ export async function runReviewCommand(options) {
     // changes again.
     if (options.root !== undefined &&
         result.status === "PASS" &&
-        sourceFingerprint !== undefined) {
+        sourceFingerprint !== undefined &&
+        (context === undefined || context.allCriteriaReviewed)) {
         await saveReviewAttestation(options.root, {
             schemaVersion: 1,
             ...(context === undefined ? {} : { taskId: context.taskId }),

package/dist/packages/cli/src/hook-process.js

@@ -267,6 +267,15 @@ export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
             return 0;
         }
         const config = configOutcome.config;
+        if (completionGateInstalled && !config.features.completionGate.enabled) {
+            writeHookOutput(io, harnessDescriptor("agy").runtime.formatOutput("Stop", {
+                action: "block",
+                status: "UNKNOWN",
+                code: "COMPLETION_GATE_CONFIG_DISABLED",
+                remedy: "Restore completionGate.enabled or explicitly uninstall the completion gate."
+            }));
+            return 0;
+        }
         const trustStatus = dependencies.trust === undefined
             ? await repositoryTrust(root, config, cliVersion)
             : await dependencies.trust(root, config, cliVersion);

package/dist/runtime/src/hooks/completion-gate.js

@@ -1,11 +1,8 @@
 import { join } from "node:path";
-import { calculateConfigHash } from "../config/hash.js";
 import { sha256 } from "../fs/hash.js";
 import { AgentOpsError } from "../fs/paths.js";
-import { findReviewAttestation } from "../review/attestation.js";
-import { validateEvidence, validateTaskAgainstConfig } from "../schema/validate.js";
 import { readPrivateFile, withPrivateFileLock, writePrivateFile } from "../security/permissions.js";
-import { isPassingVerificationEvidence } from "../verify/evidence.js";
+import { checkTaskCompletionEvidence, findIncompleteSubtask } from "../task/completion.js";
 import { collectChangeSurface } from "../verify/change-surface.js";
 import { calculateSourceFingerprint } from "../verify/source-fingerprint.js";
 const FINGERPRINT = /^[a-f0-9]{64}$/u;
@@ -101,34 +98,10 @@ export class CompletionGateService {
             return { ...state, permitFingerprint: fingerprint };
         });
     }
-    #isPermitCommand(event, sessionId) {
-        if (event.event !== "command")
-            return false;
-        const tokens = [event.command, ...event.args];
-        const commandIndex = tokens.indexOf("allow-stop");
-        return commandIndex >= 0 &&
-            tokens[commandIndex + 1] === "--session" &&
-            (tokens[commandIndex + 2] === sessionId ||
-                tokens[commandIndex + 2] === "$AGENT_OPS_SESSION_ID");
-    }
-    async #hasCurrentEvidence(taskId, criterionId, command, references, configHash, sourceFingerprint) {
-        for (const reference of references) {
-            if (reference.startsWith("review:"))
-                continue;
-            const validation = validateEvidence(await this.#options.evidenceStore.load(reference));
-            if (!validation.ok)
-                continue;
-            const evidence = validation.value;
-            if (evidence.taskId === taskId &&
-                evidence.criterionId === criterionId &&
-                evidence.commandId === command.id &&
-                evidence.configHash === configHash &&
-                evidence.sourceFingerprint === sourceFingerprint &&
-                isPassingVerificationEvidence(command, evidence)) {
-                return true;
-            }
-        }
-        return false;
+    #isPermitCommand(event) {
+        const commands = event.event === "command" ? [event] :
+            event.event === "command-batch" ? event.commands : [];
+        return commands.some(({ command, args }) => [command, ...args].includes("allow-stop"));
     }
     async #validateTask(sessionId, sourceFingerprint) {
         let stored;
@@ -143,30 +116,20 @@ export class CompletionGateService {
         if (stored.status !== "complete") {
             return gateResult("block", "FAIL", "COMPLETION_GATE_TASK_INCOMPLETE", "Complete the attached task after verification and review.");
         }
-        const taskValidation = validateTaskAgainstConfig(stored.task, this.#options.config);
-        const configHash = calculateConfigHash(this.#options.config);
-        if (!taskValidation.ok || stored.policyConfigHash !== configHash) {
-            return gateResult("block", "FAIL", "COMPLETION_GATE_TASK_STALE", "Recreate or re-verify the task against the current config.");
-        }
-        for (const criterion of stored.task.criteria) {
-            for (const commandId of criterion.verifierIds) {
-                const command = this.#options.config.verification.commands.find(({ id }) => id === commandId);
-                if (command === undefined) {
-                    return gateResult("block", "UNKNOWN", "COMPLETION_GATE_EVIDENCE_UNAVAILABLE", "Configured task evidence cannot be resolved.");
-                }
-                if (command.required &&
-                    !(await this.#hasCurrentEvidence(stored.task.id, criterion.id, command, stored.evidence[criterion.id] ?? [], configHash, sourceFingerprint))) {
-                    return gateResult("block", "FAIL", "COMPLETION_GATE_EVIDENCE_REQUIRED", "Run agent-ops verify and complete the task with current PASS evidence.");
-                }
-            }
+        const unfinished = findIncompleteSubtask(await this.#options.taskService.list(), stored.task.id);
+        if (unfinished !== undefined) {
+            return gateResult("block", "FAIL", "COMPLETION_GATE_SUBTASK_INCOMPLETE", `Complete subtask ${unfinished.task.id} before its parent.`);
         }
-        const attestation = await findReviewAttestation(this.#options.root, sourceFingerprint);
-        if (attestation === null || attestation.taskId !== stored.task.id) {
-            return gateResult("block", "FAIL", "COMPLETION_GATE_REVIEW_REQUIRED", "Run agent-ops review --yes for the attached task and current source.");
+        const problem = await checkTaskCompletionEvidence(stored, { ...this.#options, sourceFingerprint });
+        if (problem !== null) {
+            return gateResult("block", problem.status, `COMPLETION_GATE_${problem.code}`, problem.remedy);
         }
         return null;
     }
     async handle(event) {
+        if (this.#isPermitCommand(event)) {
+            return gateResult("block", "UNKNOWN", "COMPLETION_GATE_PERMIT_CONFIRMATION", "Allow this command only to grant one Stop for the current source fingerprint.");
+        }
         const sessionId = event.sessionId;
         if (sessionId === undefined) {
             return event.event === "stop"
@@ -176,11 +139,12 @@ export class CompletionGateService {
         if (event.event === "session-start") {
             return await this.initialize(sessionId);
         }
-        if (this.#isPermitCommand(event, sessionId)) {
-            return gateResult("block", "UNKNOWN", "COMPLETION_GATE_PERMIT_CONFIRMATION", "Allow this command only to grant one Stop for the current source fingerprint.");
-        }
         if (event.event !== "stop")
             return null;
+        if (event.terminationReason === undefined ||
+            (event.terminationReason === "model_stop" && event.fullyIdle === undefined)) {
+            return gateResult("block", "UNKNOWN", "COMPLETION_GATE_STOP_INPUT_INVALID", "Restore the Stop termination reason and fullyIdle metadata before stopping.");
+        }
         if (event.terminationReason !== "model_stop" || event.fullyIdle !== true) {
             return gateResult("continue", "PASS", "COMPLETION_GATE_NON_FINAL_STOP");
         }

package/dist/runtime/src/hooks/dispatch.js

@@ -1,3 +1,4 @@
+import { AgentOpsError } from "../fs/paths.js";
 import { evaluateGuardrail } from "../guardrails/evaluate.js";
 import { runStopVerification } from "./stop-verify.js";
 function continueWith(status, code) {
@@ -36,9 +37,16 @@ function evaluateCommands(commands, scope) {
 }
 export async function dispatchHookEvent(event, options) {
     if (options.completionGate !== undefined) {
-        const result = await options.completionGate.handle(event);
-        if (result !== null) {
-            return result;
+        try {
+            const result = await options.completionGate.handle(event);
+            if (result !== null)
+                return result;
+        }
+        catch (error) {
+            if (error instanceof AgentOpsError && error.code === "CHANGE_SURFACE_TRACKED_RUNTIME") {
+                return { action: "block", status: "FAIL", code: "COMPLETION_GATE_TRACKED_RUNTIME", remedy: error.message };
+            }
+            throw error;
         }
     }
     if (event.event === "unsupported") {

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

@@ -86,6 +86,13 @@ export function assertSupportedManifestOwnership(manifest, root) {
         pathKey(".agent-ops/config.json")
     ]);
     const optionalArtifactPaths = new Set();
+    // Optional for manifests installed before runtime output was ignored.
+    if (manifest.scope === "project") {
+        expectedArtifactPaths.set(".agent-ops/.gitignore", {
+            path: ".agent-ops/.gitignore", ids: new Set(["runtime-ignore"])
+        });
+        optionalArtifactPaths.add(".agent-ops/.gitignore");
+    }
     const expectedMarkers = new Map();
     const expectedMarkerPaths = new Set();
     const loopHarnesses = selectedLoopHarnesses(harnesses);

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

@@ -435,6 +435,7 @@ export async function createInstallPlan(options) {
     });
     const contribution = {
         artifacts: [
+            ...(options.scope === "project" ? [{ id: "runtime-ignore", path: ".agent-ops/.gitignore", content: "/tasks/\n/reviews/\n" }] : []),
             ...baseContribution.artifacts,
             ...loopContribution.artifacts
         ],

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

@@ -22,6 +22,8 @@ function selectedSet(harnesses) {
 function artifactOwners(manifest, artifact) {
     if (artifact.id === "config")
         return [];
+    if (artifact.id === "runtime-ignore")
+        return manifest.harness;
     if (artifact.id === "opencode-plugin")
         return ["opencode"];
     if (artifact.id === "claude-loop-launcher" ||

package/dist/runtime/src/review/attestation.js

@@ -57,9 +57,20 @@ export async function findReviewAttestation(root, sourceFingerprint) {
         return null;
     }
     try {
-        return parseAttestation(JSON.parse(source));
+        const attestation = parseAttestation(JSON.parse(source));
+        return attestation?.sourceFingerprint === sourceFingerprint ? attestation : null;
     }
     catch {
         return null;
     }
 }
+/** A new authorized attempt supersedes any earlier PASS for this source. */
+export async function invalidateReviewAttestation(root, sourceFingerprint) {
+    if (!FINGERPRINT_PATTERN.test(sourceFingerprint)) {
+        throw new AgentOpsError("REVIEW_ATTESTATION_INVALID", "Invalid source fingerprint.");
+    }
+    const path = attestationPath(root, sourceFingerprint);
+    if (await readPrivateFile(path, root) !== null) {
+        await writePrivateFile(path, "null\n", root);
+    }
+}