@kylecheng3146/agent-ops 0.5.3 → 0.6.0

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

@@ -4,6 +4,12 @@ import { renderReviewResult } from "../../../../runtime/src/review/render.js";
 import { reviewReportResults } from "../../../../runtime/src/review/report.js";
 import { findPriorFailingFindings, findReviewAttestation, invalidateReviewAttestation, readReviewReportArtifact, reviewReportDigest, saveReviewAttestation, saveReviewReportArtifact } from "../../../../runtime/src/review/attestation.js";
 import { detectHostTarget, planReviewTargets, resolveReviewRole } from "../../../../runtime/src/review/roles.js";
+import { taskContractHash, treeContractHash, goalHash } from "../../../../runtime/src/task/contract.js";
+import { acceptanceCoverage, coverageDigest } from "../../../../runtime/src/verify/acceptance-coverage.js";
+import { resolveGitCommit } from "../../../../runtime/src/verify/change-surface.js";
+import { sha256 } from "../../../../runtime/src/fs/hash.js";
+import { readPrivateFile, writePrivateFile } from "../../../../runtime/src/security/permissions.js";
+import { redactSecrets } from "../../../../runtime/src/security/redact.js";
 import { AgentOpsError } from "../../../../runtime/src/fs/paths.js";
 import { assertSafeSupportingPaths, isReviewerPolicyPath, resolveReviewScope, reviewScopeSignature } from "../../../../runtime/src/review/scope.js";
 import { calculateSourceFingerprint } from "../../../../runtime/src/verify/source-fingerprint.js";
@@ -70,6 +76,7 @@ async function taskContext(options) {
         throw new AgentOpsError("REVIEW_CRITERIA_NOT_FOUND", "Every requested review criterion must exist on the selected task.");
     }
     return {
+        records: [record],
         taskId: record.task.id,
         title: record.task.intent === undefined
             ? record.task.title
@@ -114,7 +121,16 @@ async function treeContext(options) {
     if (treeTasks.some(({ policyConfigHash }) => policyConfigHash !== root.policyConfigHash)) {
         throw new AgentOpsError("REVIEW_TREE_POLICY_MISMATCH", "Tree tasks must share one verifier policy.");
     }
+    const historical = new Set([root.task.id]);
+    for (let size = 0; size !== historical.size;) {
+        size = historical.size;
+        for (const record of all)
+            if (record.task.parentTaskId !== undefined && historical.has(record.task.parentTaskId))
+                historical.add(record.task.id);
+    }
     return {
+        historyRecords: all.filter(record => historical.has(record.task.id) && record.supersededBy !== undefined),
+        records: treeTasks,
         taskId: root.task.id,
         title: [root.task.title, ...treeTasks.map(({ task }) => `Task ${task.id}${task.parentTaskId === undefined ? "" : ` under ${task.parentTaskId}`}: ${task.title}\nModification intent: ${task.intent ?? task.title}`)].join("\n\n"),
         active: treeTasks.every(({ status }) => status === "active"),
@@ -163,7 +179,10 @@ async function currentEvidence(options, context, criterionId, commandId, configH
             evidence.criterionId !== (owner?.criterionId ?? criterionId) ||
             evidence.commandId !== commandId ||
             evidence.configHash !== configHash ||
-            evidence.sourceFingerprint !== sourceFingerprint) {
+            evidence.sourceFingerprint !== sourceFingerprint ||
+            (context.records.some(r => r.task.id === (owner?.taskId ?? context.taskId) &&
+                (r.task.goal !== undefined || (r.task.contractRevision ?? 0) > 0 || r.task.criteria.some(c => c.acceptance !== undefined))) &&
+                evidence.taskContractHash !== taskContractHash(context.records.find(r => r.task.id === (owner?.taskId ?? context.taskId)).task))) {
             stale = true;
             continue;
         }
@@ -190,14 +209,18 @@ async function preflightReview(options, context, sourceFingerprint) {
     const configHash = calculateConfigHash(options.config);
     const commands = [];
     for (const criterion of context.criteria) {
-        for (const commandId of criterion.verifierIds ?? []) {
+        const owner = context.criterionOwners?.get(criterion.id);
+        const typed = context.records.find(r => r.task.id === (owner?.taskId ?? context.taskId))?.task.criteria
+            .find(c => c.id === (owner?.criterionId ?? criterion.id))?.acceptance !== undefined;
+        for (const commandId of new Set([...(criterion.verifierIds ?? []),
+            ...(typed ? options.config.verification.commands.filter(c => c.required).map(c => c.id) : [])])) {
             const command = options.config.verification.commands.find((candidate) => candidate.id === commandId);
             if (command === undefined) {
                 return { ok: false, reason: "missing-verification-evidence" };
             }
             const found = await currentEvidence(options, context, criterion.id, commandId, configHash, sourceFingerprint);
             const compatible = command.evidence.kind === "test-count"
-                ? found.current.filter(({ evidence }) => evidence.schemaVersion === 3)
+                ? 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" };
@@ -258,9 +281,11 @@ export async function hasFreshVerification(options, taskId, base) {
     if (context === undefined) {
         return false;
     }
+    options = { ...options, noChangePaths: options.noChangePaths ?? context.records.find(r => r.task.id === context.taskId)?.noChangePaths };
     const scope = await resolveReviewScope({
         root: options.root,
         runner: options.gitRunner,
+        ...(options.noChangePaths === undefined ? {} : { noChangePaths: options.noChangePaths }),
         ...(base === undefined ? {} : { base })
     });
     const fingerprint = await calculateSourceFingerprint(options.root, scope, options.gitRunner);
@@ -352,7 +377,10 @@ async function reusableReview(options, sourceFingerprint, context) {
         return null;
     }
     const attestation = await findReviewAttestation(options.root, sourceFingerprint, context?.taskId);
-    if (attestation === null || attestation.taskId !== context?.taskId) {
+    if (attestation === null || attestation.taskId !== context?.taskId ||
+        (context?.binding !== undefined && (attestation.schemaVersion !== 3 ||
+            JSON.stringify(attestation.taskContracts) !== JSON.stringify(context.binding.taskContracts) ||
+            attestation.coverageDigest !== context.binding.coverageDigest))) {
         return null;
     }
     if (context?.treeTasks !== undefined &&
@@ -420,7 +448,7 @@ async function persistReviewEvidence(options, result, sourceFingerprint, context
     const reportArtifacts = [];
     try {
         for (const taskId of taskIds) {
-            reportArtifacts.push({ taskId, path: await saveReviewReportArtifact(options.root, artifactResult, sourceFingerprint, taskId, complete ? tree : undefined) });
+            reportArtifacts.push({ taskId, path: await saveReviewReportArtifact(options.root, artifactResult, sourceFingerprint, taskId, complete ? tree : undefined, context?.binding === undefined ? undefined : { ...context.binding, taskContractHash: context.binding.taskContracts[taskId ?? context.taskId] }, context?.coverage) });
         }
     }
     catch {
@@ -441,7 +469,8 @@ async function persistReviewEvidence(options, result, sourceFingerprint, context
         const plannedTargets = result.plannedTargets;
         for (const artifact of reportArtifacts) {
             await saveReviewAttestation(options.root, {
-                schemaVersion: 2,
+                schemaVersion: context?.binding === undefined ? 2 : 3,
+                ...(context?.binding === undefined ? {} : { ...context.binding, taskContractHash: context.binding.taskContracts[artifact.taskId ?? context.taskId] }),
                 ...(artifact.taskId === undefined ? {} : { taskId: artifact.taskId }),
                 ...(tree === undefined ? {} : { tree }),
                 harness: result.harness,
@@ -502,6 +531,7 @@ export async function runReviewCommand(options) {
     const context = options.args.tree === true
         ? await treeContext(options)
         : await taskContext(options);
+    options = { ...options, noChangePaths: options.noChangePaths ?? context?.records.find(r => r.task.id === context.taskId)?.noChangePaths };
     const evidenceRequirements = (options.args.evidence ?? []).map((value) => {
         const separator = value.indexOf("=");
         return {
@@ -517,6 +547,7 @@ export async function runReviewCommand(options) {
             scope = await resolveReviewScope({
                 root: options.root,
                 runner: options.gitRunner,
+                ...(options.noChangePaths === undefined ? {} : { noChangePaths: options.noChangePaths }),
                 ...(options.args.base === undefined ? {} : { base: options.args.base })
             });
         }
@@ -574,7 +605,7 @@ export async function runReviewCommand(options) {
             // source was reviewed; it says nothing about the policy in force now or
             // about verification that has failed since, and both of those are
             // decided above.
-            const reused = options.args.rerun || context?.treeTasks !== undefined
+            const reused = options.args.rerun || context?.treeTasks !== undefined || context?.records.some(r => r.task.goal !== undefined || r.task.criteria.some(c => c.acceptance !== undefined) || (r.task.contractRevision ?? 0) > 0)
                 ? null
                 : await reusableReview(options, sourceFingerprint, context);
             if (reused !== null) {
@@ -593,6 +624,23 @@ export async function runReviewCommand(options) {
             pendingInvalidation = false;
         }
     }
+    if (context !== undefined && sourceFingerprint !== undefined && options.config !== undefined &&
+        options.evidenceStore !== undefined && options.gitRunner !== undefined) {
+        const rows = [];
+        for (const record of context.records) {
+            const coverage = await acceptanceCoverage(record, options.config, sourceFingerprint, options.evidenceStore);
+            rows.push(...coverage.map(row => ({ ...row, criterionId: context.treeTasks === undefined
+                    ? row.criterionId : record.task.id + ":" + row.criterionId })));
+        }
+        context.coverage = rows;
+        context.binding = {
+            taskContractHash: taskContractHash(context.records.find(r => r.task.id === context.taskId).task),
+            taskContracts: Object.fromEntries(context.records.map(r => [r.task.id, taskContractHash(r.task)])),
+            ...(context.treeTasks === undefined ? {} : { treeContractHash: treeContractHash(context.records.map(r => r.task)) }),
+            goalHash: goalHash(context.records.find(r => r.task.id === context.taskId).task),
+            candidateCommit: await resolveGitCommit(options.gitRunner, "HEAD"), coverageDigest: coverageDigest(rows)
+        };
+    }
     const criteria = [
         ...(context?.criteria ?? GENERIC_CRITERIA)
     ];
@@ -601,7 +649,44 @@ export async function runReviewCommand(options) {
     }
     let packet;
     try {
+        let contractManifest;
+        const contractArtifacts = [];
+        if (context?.binding !== undefined && options.root !== undefined) {
+            const historicalRefs = new Set([
+                ...[...context.records, ...(context.historyRecords ?? [])].flatMap(r => (r.revisions ?? []).flatMap(revision => Object.values(revision.previousEvidence).flat())),
+                ...(context.historyRecords ?? []).flatMap(r => Object.values(r.evidence).flat())
+            ]);
+            const refs = new Set([...context.records.flatMap(r => Object.values(r.evidence).flat()), ...historicalRefs].filter(ref => !ref.startsWith("review:")));
+            for (const path of refs) {
+                const loaded = await options.evidenceStore?.load(path);
+                if (loaded == null)
+                    continue;
+                if (!historicalRefs.has(path) && loaded.sourceFingerprint !== sourceFingerprint)
+                    continue;
+                const content = await readPrivateFile(options.root + "/" + path, options.root);
+                if (content !== null)
+                    contractArtifacts.push({ path, digest: sha256(content), content });
+                const executionPath = loaded.acceptance?.executionArtifact;
+                if (executionPath !== undefined && !contractArtifacts.some(artifact => artifact.path === executionPath)) {
+                    const execution = await readPrivateFile(options.root + "/" + executionPath, options.root);
+                    if (execution !== null)
+                        contractArtifacts.push({ path: executionPath, digest: sha256(execution), content: execution });
+                }
+            }
+            const content = redactSecrets(JSON.stringify({ binding: context.binding, coverage: context.coverage,
+                executionPolicy: options.config,
+                artifacts: contractArtifacts.map(({ path, digest }) => ({ path, digest })),
+                tasks: context.records.map(r => ({ task: r.task, revisions: r.revisions ?? [] })),
+                superseded: context.historyRecords ?? [] }, null, 2));
+            const digest = sha256(content);
+            const path = ".agent-ops/tasks/review-contracts/" + digest + ".json";
+            contractManifest = { path, digest, content };
+            // Validated before any manifest is written or handed to a snapshot.
+            buildReviewPacket({ request: context.title, criteria, artifactRefs: [], evidenceRequirements, contractManifest, contractArtifacts });
+            await writePrivateFile(options.root + "/" + path, content, options.root);
+        }
         packet = buildReviewPacket({
+            ...(contractManifest === undefined ? {} : { contractManifest, contractArtifacts }),
             request: context?.title ?? GENERIC_REQUEST,
             criteria,
             artifactRefs: scope?.changedFiles ?? [],
@@ -676,6 +761,7 @@ export async function runReviewCommand(options) {
             const postflight = await resolveReviewScope({
                 root: options.root,
                 runner: options.gitRunner,
+                ...(options.noChangePaths === undefined ? {} : { noChangePaths: options.noChangePaths }),
                 ...(options.args.base === undefined ? {} : { base: options.args.base })
             });
             const currentHash = options.currentPolicyConfigHash === undefined
@@ -684,7 +770,12 @@ export async function runReviewCommand(options) {
             const postflightFingerprint = await calculateSourceFingerprint(options.root, postflight, options.gitRunner);
             if (reviewScopeSignature(scope) !== reviewScopeSignature(postflight) ||
                 (options.policyConfigHash !== undefined && currentHash !== options.policyConfigHash) ||
-                postflightFingerprint !== sourceFingerprint) {
+                postflightFingerprint !== sourceFingerprint ||
+                (context?.binding?.treeContractHash !== undefined && options.tasks !== undefined &&
+                    await options.tasks.treeContract(context.taskId) !== context.binding.treeContractHash) ||
+                (context !== undefined && options.tasks !== undefined &&
+                    (await Promise.all(context.records.map(async (r) => taskContractHash((await options.tasks.status({ taskId: r.task.id })).task))))
+                        .some((hash, i) => hash !== taskContractHash(context.records[i].task)))) {
                 const changed = await persistReviewEvidence(options, sourceChangedResult(result), sourceFingerprint, context);
                 return notRunEnvelope(changed);
             }
@@ -712,7 +803,7 @@ export async function runReviewCommand(options) {
                     ? criterion.id : `${record.task.id}:${criterion.id}`;
                 const result = finalResult.results?.find((item) => item.criterionId === id);
                 return [criterion.id, (result?.evidence ?? []).map((reference) => `review:${finalResult.harness}:${reference}`)];
-            })), scope?.mode === "base" ? scope.resolvedBase : null);
+            })), scope?.mode === "base" ? scope.resolvedBase : null, scope?.mode === "base" && scope.noChange === true ? scope.changedFiles : undefined);
         }
     }
     const message = finalResult.status === "PASS"

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

@@ -0,0 +1,111 @@
+import { readFile } from "node:fs/promises";
+import { AgentOpsError, resolveContainedPath } from "../../../../runtime/src/fs/paths.js";
+import { errorEnvelope, okEnvelope } from "../output.js";
+function dynamic(args) {
+    return args;
+}
+function actionOf(args) {
+    const value = dynamic(args).runAction ?? dynamic(args).action;
+    if (value === undefined || value === "start")
+        return "start";
+    if (["status", "logs", "resume", "stop", "respond"].includes(String(value)))
+        return value;
+    throw new AgentOpsError("RUN_ACTION_INVALID", `Unsupported run action: ${String(value)}`);
+}
+function runIdOf(args) {
+    const runId = args.runId ?? dynamic(args).taskId;
+    if (typeof runId !== "string" || runId.length === 0)
+        throw new AgentOpsError("RUN_ID_REQUIRED", "This run action requires a run id.");
+    return runId;
+}
+function textFor(action, state, message) {
+    const active = state.workers.filter((worker) => ["assigned", "starting", "running", "idle", "handing-off"].includes(worker.status)).length;
+    return [
+        message,
+        `Status: ${state.status}`,
+        `Host: ${state.host}`,
+        `Workers: ${active}/${state.jobs}`,
+        `Budget: ${Math.max(0, state.budget.limitMs - state.budget.accumulatedMs)}ms remaining`,
+        `Usage: ${state.budget.usage.tokens ?? "unknown"} tokens; ${state.budget.usage.usd === null ? "unknown" : "$" + state.budget.usage.usd} cost (${state.budget.usage.completeness})`,
+        action === "logs" ? "" : "Native goal completion is not final proof; verify, review, task state, and receipt are still required."
+    ].filter((line) => line.length > 0).join("\n");
+}
+function data(action, result) {
+    return {
+        action,
+        runId: result.state.runId,
+        state: result.state,
+        message: result.message,
+        text: textFor(action, result.state, result.message)
+    };
+}
+function stateData(action, state, message) {
+    return { action, runId: state.runId, state, message, text: textFor(action, state, message) };
+}
+async function goalFromArgs(args, root) {
+    if (args.goal !== undefined && args.goalFile !== undefined)
+        throw new AgentOpsError("RUN_GOAL_CONFLICT", "Use either a positional goal or --goal-file, not both.");
+    if (args.goalFile !== undefined) {
+        const path = await resolveContainedPath(root, args.goalFile);
+        return (await readFile(path, "utf8")).trim();
+    }
+    if (args.goal === undefined || args.goal.trim() === "")
+        throw new AgentOpsError("RUN_GOAL_REQUIRED", "Run start requires a non-empty goal.");
+    return args.goal.trim();
+}
+async function answerFromArgs(args, root) {
+    if (args.answer !== undefined && args.answerFile !== undefined)
+        throw new AgentOpsError("RUN_ANSWER_CONFLICT", "Use either --answer or --answer-file, not both.");
+    if (args.answerFile !== undefined)
+        return (await readFile(await resolveContainedPath(root, args.answerFile), "utf8")).trim();
+    if (args.answer === undefined || args.answer.trim() === "")
+        throw new AgentOpsError("RUN_ANSWER_REQUIRED", "Run respond requires a non-empty answer.");
+    return args.answer.trim();
+}
+/**
+ * External lifecycle surface. The command only starts/controls a supervisor;
+ * it never marks the task complete or treats a native process exit as proof.
+ */
+export async function runRunCommand(options) {
+    const action = actionOf(options.args);
+    try {
+        if (action === "start") {
+            const result = await options.service.start({
+                root: options.root,
+                commonDir: options.commonDir,
+                targetBranch: options.targetBranch,
+                goal: await goalFromArgs(options.args, options.root),
+                host: options.args.host ?? "codex",
+                ownerSessionId: options.ownerSessionId,
+                jobs: options.args.jobs,
+                timeBudgetMs: options.args.timeBudgetMs
+            });
+            const state = options.args.wait === true && options.waitForCompletion !== undefined
+                ? await options.waitForCompletion(result.state.runId)
+                : result.state;
+            const response = data(action, { ...result, state });
+            return okEnvelope(options.args.wait === true ? "RUN_FINISHED" : "RUN_STARTED", response);
+        }
+        const runId = runIdOf(options.args);
+        if (action === "status")
+            return okEnvelope("RUN_STATUS", stateData(action, await options.service.status(runId), `Read run ${runId}.`));
+        if (action === "logs") {
+            const state = await options.service.status(runId);
+            const events = await options.service.logs(runId);
+            return okEnvelope("RUN_LOGS", { ...stateData(action, state, `Read ${events.length} event(s) for run ${runId}.`), events });
+        }
+        if (action === "resume")
+            return okEnvelope("RUN_RESUMED", data(action, await options.service.resume(runId)));
+        if (action === "stop")
+            return okEnvelope("RUN_STOP_REQUESTED", data(action, await options.service.stop(runId, options.args.answer ?? "user requested stop")));
+        const questionId = options.args.questionId;
+        if (questionId === undefined || questionId.trim() === "")
+            throw new AgentOpsError("RUN_QUESTION_REQUIRED", "Run respond requires --question-id.");
+        return okEnvelope("RUN_RESPONDED", data(action, await options.service.respond(runId, questionId, await answerFromArgs(options.args, options.root))));
+    }
+    catch (cause) {
+        if (cause instanceof AgentOpsError)
+            return errorEnvelope(cause.code, cause.message);
+        throw cause;
+    }
+}

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

@@ -1,3 +1,5 @@
+import { lstat, readFile } from "node:fs/promises";
+import { taskContractHash } from "../../../../runtime/src/task/contract.js";
 import { AgentOpsError } from "../../../../runtime/src/fs/paths.js";
 import { renderTaskMarkdown, safeTaskText } from "../../../../runtime/src/task/render.js";
 import { errorEnvelope, okEnvelope } from "../output.js";
@@ -12,20 +14,21 @@ function parseCriterion(source) {
     catch {
         throw new AgentOpsError("TASK_CRITERION_INVALID", "Each --criterion value must be a JSON criterion object.");
     }
-    if (!isRecord(value) ||
-        Object.keys(value).sort().join(",") !==
-            "description,id,verifierIds" ||
-        typeof value.id !== "string" ||
-        typeof value.description !== "string" ||
-        !Array.isArray(value.verifierIds) ||
-        value.verifierIds.some((id) => typeof id !== "string")) {
-        throw new AgentOpsError("TASK_CRITERION_INVALID", "Each criterion requires only id, description, and verifierIds.");
+    if (!isRecord(value))
+        throw new AgentOpsError("TASK_CRITERION_INVALID", "Criterion must be an object.");
+    // TaskService normalizes the creation baseline, then uses the shared strict validator.
+    return value;
+}
+async function jsonFile(path) {
+    const status = await lstat(path);
+    if (!status.isFile() || status.isSymbolicLink() || status.size > 65536)
+        throw new AgentOpsError("TASK_PAYLOAD_INVALID", "Payload must be a regular JSON file at most 64 KiB.");
+    try {
+        return JSON.parse(await readFile(path, "utf8"));
+    }
+    catch {
+        throw new AgentOpsError("TASK_PAYLOAD_INVALID", "Invalid JSON payload.");
     }
-    return {
-        id: value.id,
-        description: value.description,
-        verifierIds: [...value.verifierIds]
-    };
 }
 function parseEvidence(values) {
     const evidence = {};
@@ -57,7 +60,7 @@ function taskAction(args) {
             "complete",
             "create",
             "export",
-            "status"
+            "status", "revise", "replan", "pin-finding"
         ].includes(args.action)) {
         throw new AgentOpsError("TASK_ACTION_INVALID", "A supported task action is required.");
     }
@@ -68,7 +71,8 @@ function taskEnvelope(action, code, message, record) {
         action,
         message,
         record,
-        text: renderTaskMarkdown(record)
+        contractHash: taskContractHash(record.task),
+        text: renderTaskMarkdown(record) + "\nContract: " + taskContractHash(record.task)
     });
 }
 function renderTaskList(records) {
@@ -93,7 +97,10 @@ export async function runTaskCommand(options) {
             const record = await (worktree?.service ?? options.service).create({
                 title: options.args.title,
                 ...(options.args.intent === undefined ? {} : { intent: options.args.intent }),
-                criteria: (options.args.criteria ?? []).map(parseCriterion),
+                criteria: [...(options.args.criteria ?? []).map(parseCriterion),
+                    ...await Promise.all((options.args.criterionFiles ?? []).map(async (path) => await jsonFile(path)))]
+                    .map(c => c.acceptance === undefined || options.args.baseline === undefined ? c :
+                    { ...c, acceptance: { ...c.acceptance, baselineCommit: c.acceptance.baselineCommit ?? options.args.baseline } }),
                 ...(options.policyConfigHash === undefined
                     ? {}
                     : { policyConfigHash: options.policyConfigHash }),
@@ -127,6 +134,35 @@ export async function runTaskCommand(options) {
                 }
             };
         }
+        if (action === "revise") {
+            const payload = await jsonFile(options.args.criteriaFile);
+            if (!Array.isArray(payload))
+                throw new AgentOpsError("TASK_PAYLOAD_INVALID", "Criteria file must contain an array.");
+            const record = await options.service.revise(requireTaskId(options.args), {
+                expectedContractHash: options.args.expectedContract, criteria: payload,
+                reason: options.args.reason, ...(options.args.baseline === undefined ? {} : { baseline: options.args.baseline })
+            });
+            return taskEnvelope(action, "TASK_REVISED", "Contract revised; obtain new verification and fresh review.", record);
+        }
+        if (action === "replan") {
+            const payload = await jsonFile(options.args.planFile);
+            if (!Array.isArray(payload))
+                throw new AgentOpsError("TASK_PAYLOAD_INVALID", "Plan file must contain split task objects.");
+            const records = await options.service.replan(requireTaskId(options.args), {
+                expectedTreeContractHash: options.args.expectedTreeContract, reason: options.args.reason,
+                tasks: payload
+            });
+            return okEnvelope("TASK_REPLANNED", { action, message: "Task tree split atomically; reverify and review.", records, text: renderTaskList(records) });
+        }
+        if (action === "pin-finding") {
+            const criterion = parseCriterion(JSON.stringify(await jsonFile(options.args.criterionFiles[0])));
+            const pinned = await options.service.pinFinding(requireTaskId(options.args), options.args.expectedContract, options.args.findingReference, criterion, options.args.reason);
+            if (pinned.record === null)
+                return { code: "NEEDS_REPLAN", status: "error",
+                    data: { action, message: "Pin requires atomic replan to retain two to five criteria.", pendingCriterion: pinned.pendingCriterion, text: "NEEDS_REPLAN: include the pending criterion in task replan; no task was changed." },
+                    errors: [{ code: "NEEDS_REPLAN", message: "Replan the full current tree and pending pin." }] };
+            return taskEnvelope(action, "TASK_FINDING_PINNED", "Pinned saved finding; reverify and review the new contract.", pinned.record);
+        }
         if (action === "status") {
             if (options.args.taskId === undefined && sessionId === undefined) {
                 const parentTaskId = options.args.parentTaskId;
@@ -143,7 +179,15 @@ export async function runTaskCommand(options) {
             const record = await options.service.status(options.args.taskId === undefined
                 ? { sessionId }
                 : { taskId: options.args.taskId });
-            return taskEnvelope(action, "TASK_STATUS", `Read task ${record.task.id}.`, record);
+            const coverage = await options.service.coverage(record.task.id);
+            const proven = coverage.rows.filter(row => row.status === "proven").length;
+            const mechanical = coverage.rows.filter(row => row.mode === "behavioral" || row.mode === "invariant").length;
+            const reviewOnly = coverage.rows.filter(row => row.mode === "review-only").length;
+            const legacy = coverage.rows.filter(row => row.mode === "legacy").length;
+            const envelope = taskEnvelope(action, "TASK_STATUS", `Read task ${record.task.id}.`, record);
+            return { ...envelope, data: { ...envelope.data, coverage, treeContractHash: await options.service.treeContract(record.task.id),
+                    text: envelope.data.text + "\nAcceptance: " + proven + "/" + mechanical + " mechanical proven; " + reviewOnly + " review-only; " + legacy + " legacy; originally mechanical " + coverage.originalMechanical +
+                        "; reviewed " + coverage.reviewed + "; undischarged " + coverage.rows.filter(row => row.status !== "proven" && !coverage.reviewed).length } };
         }
         if (action === "attach") {
             if (sessionId === undefined) {

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

@@ -7,6 +7,7 @@ function safe(value) {
 }
 function publicReport(report) {
     return {
+        ...(report.acceptance === undefined ? {} : { acceptance: report.acceptance }),
         taskId: report.taskId,
         status: report.status,
         surface: {

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

@@ -7,7 +7,9 @@ import { sha256 } from "../../../runtime/src/fs/hash.js";
 import { loadConfigFile } from "../../../runtime/src/config/load.js";
 import { mergeConfigLayers } from "../../../runtime/src/config/merge.js";
 import { AgentOpsError } from "../../../runtime/src/fs/paths.js";
-import { localStatePaths } from "../../../runtime/src/security/permissions.js";
+import { localStatePaths, readPrivateFile } from "../../../runtime/src/security/permissions.js";
+import { FileRunRepository } from "../../../runtime/src/run/service.js";
+import { readRunPolicy, runRuntimeHash } from "../../../runtime/src/run/policy.js";
 import { calculateTrustBinding, FileTrustStore } from "../../../runtime/src/security/trust.js";
 export const DEFAULT_CONFIG = {
     schemaVersion: 3,
@@ -72,6 +74,14 @@ async function loadOptionalConfig(path) {
     }
 }
 export async function loadEffectiveConfig(root, scope, projectOverride) {
+    if (scope === "project" && projectOverride === undefined) {
+        const run = await runPolicyContext(root);
+        if (run !== null)
+            return mergeConfigLayers([defaultConfigLayer(), {
+                    source: "project", sourcePath: join(run.state.commonDir, "agent-ops/runs", run.state.runId, "policies", run.state.policyBinding.artifactDigest + ".json"),
+                    config: run.policy.config
+                }]);
+    }
     const home = process.env.AGENT_OPS_HOME ?? homedir();
     const userPath = join(home, ".agent-ops", "config.json");
     const projectPath = join(scope === "user" ? root : projectConfigRoot(root), ".agent-ops", "config.json");
@@ -184,6 +194,14 @@ export async function repositoryTrust(root, config, cliVersion) {
     const home = process.env.AGENT_OPS_HOME ?? homedir();
     const state = localStatePaths(home);
     try {
+        const run = await runPolicyContext(root);
+        if (run !== null) {
+            if (run.state.status !== "active" || run.state.disableRestart || run.state.awaitingResume ||
+                Date.parse(run.policy.expiresAt) <= Date.now() || calculateConfigHash(config) !== run.state.policyBinding.configHash)
+                return "STALE";
+            const store = new FileTrustStore(state.trustStore, state.anchorDirectory);
+            return (await store.status(run.policy.baseTrustBinding)).status;
+        }
         const binding = await repositoryTrustBinding(root, config, cliVersion);
         return (await new FileTrustStore(state.trustStore, state.anchorDirectory).status(binding)).status;
     }
@@ -191,6 +209,50 @@ export async function repositoryTrust(root, config, cliVersion) {
         return "UNTRUSTED";
     }
 }
+/** A run-private capability is usable only by its registered checkout or proof group. */
+export async function runPolicyContext(root) {
+    let common;
+    try {
+        common = execFileSync("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    }
+    catch {
+        return null;
+    }
+    const source = await readPrivateFile(join(root, ".agent-ops/tasks/worktree.json"), root);
+    const record = source === null ? null : JSON.parse(source);
+    const runId = process.env.AGENT_OPS_RUN_ID ?? record?.runId;
+    if (runId === undefined)
+        return null;
+    const repository = new FileRunRepository(join(common, "agent-ops/runs"), common);
+    const saved = await repository.read(runId);
+    if (saved === null || saved.policyBinding === undefined)
+        return null;
+    const here = realpathSync(root);
+    const worker = saved.workers.find(w => w.worktree === here);
+    const proofProcess = worker?.proofProcess ?? saved.proofProcess;
+    let proof = false;
+    if (proofProcess != null && String(proofProcess.processId) === process.env.AGENT_OPS_RUN_PROOF_PID) {
+        try {
+            proof = execFileSync("ps", ["-o", "pgid=", "-p", String(process.pid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() === String(proofProcess.processId) &&
+                execFileSync("ps", ["-o", "lstart=", "-p", String(proofProcess.processId)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() === proofProcess.processIdentity;
+        }
+        catch {
+            proof = false;
+        }
+    }
+    if ((!proof && (worker === undefined || record?.runId !== runId || record.workerId !== worker.workerId ||
+        record.ownerSessionId !== worker.ownerSessionId || record.coordinatorId !== saved.coordinatorId || record.workerGeneration !== worker.generation)) ||
+        (worker === undefined && !(proof && saved.root === here)) ||
+        (process.env.AGENT_OPS_WORKER_ID !== undefined && (process.env.AGENT_OPS_WORKER_ID !== (worker?.workerId ?? saved.coordinatorId) ||
+            process.env.AGENT_OPS_WORKER_GENERATION !== String((worker ?? saved.workers.find(w => w.workerId === saved.coordinatorId))?.generation))))
+        throw new AgentOpsError("RUN_WORKER_STALE", "Run policy requires the current registered worker generation or proof process.");
+    if (saved.status !== "active" || saved.disableRestart || saved.awaitingResume)
+        throw new AgentOpsError("RUN_POLICY_DISABLED", "Run execution policy is inactive; explicit resume is required.");
+    const policy = await readRunPolicy(saved, await runRuntimeHash());
+    if (policy === null)
+        return null;
+    return { repository, state: saved, policy, worker };
+}
 export async function repositoryTrustBinding(root, config, cliVersion) {
     return await calculateTrustBinding({
         repositoryPath: root,

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

@@ -16,6 +16,9 @@ import { CompletionGateService } from "../../../runtime/src/hooks/completion-gat
 import { TaskService } from "../../../runtime/src/task/service.js";
 import { FileTaskStore } from "../../../runtime/src/task/store.js";
 import { FileEvidenceStore } from "../../../runtime/src/verify/evidence.js";
+import { readWorktreeRecord } from "../../../runtime/src/parallel/service.js";
+import { FileRunRepository } from "../../../runtime/src/run/service.js";
+import { validateWorkerStopHandoff } from "../../../runtime/src/run/worker-gate.js";
 import { STOP_VERIFICATION_ENV, StopVerificationService } from "../../../runtime/src/hooks/stop-service.js";
 import { NodeVerificationProcessRunner } from "../../../runtime/src/verify/spawn.js";
 import { normalizeHookInput, runHookCommand, HOOK_EVENTS } from "./commands/hook.js";
@@ -343,7 +346,34 @@ export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
         const completionGate = (harnessId === "agy" || harnessId === "claude") &&
             config.features.completionGate.enabled
             ? dependencies.completionGate ?? {
-                handle: async (normalized) => await completionGateFor(root, config, gitRunner, harnessId).handle(normalized)
+                handle: async (normalized) => {
+                    if (normalized.event === "stop" && normalized.terminationReason === "model_stop" && normalized.fullyIdle === true && normalized.sessionId !== undefined) {
+                        const record = await readWorktreeRecord(root);
+                        if (record?.runId !== undefined && record.workerId !== undefined && record.workerGeneration !== undefined) {
+                            const common = await gitRunner.run(["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+                            if (common.exitCode === 0) {
+                                const commonDir = Buffer.from(common.stdout).toString("utf8").trim();
+                                const repository = new FileRunRepository(join(commonDir, "agent-ops", "runs"), commonDir);
+                                const state = await repository.read(record.runId);
+                                const worker = state?.workers.find(worker => worker.workerId === record.workerId);
+                                if (worker !== undefined && worker.workerId !== state.coordinatorId && worker.stopIntent !== null) {
+                                    const head = await gitRunner.run(["rev-parse", "HEAD"]);
+                                    const tasks = new TaskService(new FileTaskStore(join(root, ".agent-ops", "tasks", "state.json"), root));
+                                    if (head.exitCode === 0 && Buffer.from(head.stdout).toString("utf8").trim() === worker.stopIntent.sourceCommit &&
+                                        await tasks.treeContract(worker.taskId) === worker.stopIntent.contractDigest) {
+                                        const handoff = await validateWorkerStopHandoff(repository, { root, sessionId: normalized.sessionId,
+                                            ...(normalized.agentId === undefined ? {} : { agentId: normalized.agentId }), runId: record.runId,
+                                            workerId: record.workerId, generation: record.workerGeneration,
+                                            deliveryDigest: worker.stopIntent.deliveryDigest ?? undefined, contractDigest: worker.stopIntent.contractDigest ?? undefined });
+                                        if (handoff !== null)
+                                            return handoff;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    return await completionGateFor(root, config, gitRunner, harnessId).handle(normalized);
+                }
             }
             : undefined;
         const worktreeGuard = config.worktree?.mode === "auto"