@kylecheng3146/agent-ops 0.10.2 → 0.11.1

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

@@ -6,18 +6,14 @@ import { validateEvidence, validateTask, validateTaskAgainstConfig } from "../sc
 import { renderTaskMarkdown } from "./render.js";
 import { checkTaskCompletionEvidence, findIncompleteSubtask } from "./completion.js";
 import { calculateConfigHash, FileEvidenceStore, isPassingVerificationEvidence } from "../verify/evidence.js";
-import { collectChangeSurface } from "../verify/change-surface.js";
 import { resolveReviewScope } from "../review/scope.js";
 import { calculateSourceFingerprint } from "../verify/source-fingerprint.js";
 import { acceptanceCoverage } from "../verify/acceptance-coverage.js";
 import { loadFindingPin } from "./pin-finding.js";
 import { findReviewAttestation } from "../review/attestation.js";
 import { advanceFailureFingerprint } from "../verify/fingerprint.js";
-import { taskContractHash, treeContractHash } from "./contract.js";
+import { evidenceMatchesContract, executionContractHash, taskContractHash, treeContractHash } from "./contract.js";
 import { commitIdentity } from "../schema/acceptance.js";
-import { createDebugState, DEBUG_DEFAULTS } from "./debug-state.js";
-import { DebugService } from "./debug.js";
-import { sameDebugText } from "./debug-intake.js";
 import { isCovers, parseSurface } from "../surface/schema.js";
 import { declareEscape, resolveOrigin } from "../escape/link.js";
 import { configProposal } from "../escape/rules.js";
@@ -92,15 +88,6 @@ export class TaskService {
         this.#now = options.now ?? (() => new Date().toISOString());
         this.#completion = options.completion;
     }
-    debugService() {
-        if (this.#completion === undefined)
-            throw taskError("TASK_DEBUG_CONTEXT_REQUIRED", "Debug operations require repository context.");
-        return new DebugService({ store: this.#store, tasks: this, ...this.#completion });
-    }
-    async assertDebugBaseline() {
-        if (this.#completion === undefined || (await collectChangeSurface(this.#completion.gitRunner)).paths.length > 0)
-            throw taskError("TASK_DEBUG_BASELINE_DIRTY", "Preserve user edits; debug intake needs a clean committed baseline before worktree allocation.");
-    }
     async create(input) {
         if (input.policyConfigHash !== undefined &&
             !/^[a-f0-9]{64}$/u.test(input.policyConfigHash)) {
@@ -109,12 +96,6 @@ export class TaskService {
         if (input.sessionId !== undefined) {
             assertSessionId(input.sessionId);
         }
-        // A new session must not restart an active issue's budget and rounds.
-        if (input.debug !== undefined && input.parentTaskId === undefined && input.goal !== undefined) {
-            const existing = await this.activeDebugRoot(input.goal);
-            if (existing !== null)
-                return input.sessionId === undefined ? existing : await this.attach(input.sessionId, existing.task.id);
-        }
         let createdSourceCommit = input.createdSourceCommit;
         if (createdSourceCommit === undefined && this.#completion !== undefined) {
             const head = await this.#completion.gitRunner.run(["rev-parse", "--verify", "HEAD"]);
@@ -142,21 +123,11 @@ export class TaskService {
                 ? {}
                 : { parentTaskId: input.parentTaskId })
         };
-        let debugSettings;
-        if (input.debug !== undefined) {
-            if (input.goal === undefined || createdSourceCommit === undefined || this.#completion === undefined)
-                throw taskError("TASK_DEBUG_CONTEXT_REQUIRED", "Debug intake requires the original issue and a committed baseline.");
-            if ((await collectChangeSurface(this.#completion.gitRunner)).paths.length > 0)
-                throw taskError("TASK_DEBUG_BASELINE_DIRTY", "Preserve original user edits; investigate read-only or ask for an explicit committed baseline.");
-            const config = await this.#completion.loadConfig();
-            if (config.features.debug?.enabled === false)
-                throw taskError("TASK_DEBUG_DISABLED", "Task debug routing is explicitly disabled.");
-            debugSettings = config.features.debug ?? DEBUG_DEFAULTS;
+        // DEBUG = an ordinary task whose original regression is proven red at the baseline and green on the candidate.
+        if (input.debug !== undefined && input.parentTaskId === undefined) {
+            if (!criteria.some(c => c.acceptance?.mode === "behavioral" && c.acceptance.bindings.some(b => (b.redCheckIds ?? []).length > 0)))
+                throw taskError("TASK_DEBUG_RED_CHECK_REQUIRED", "A DEBUG task needs a behavioral criterion whose redCheckIds fail at the baseline and pass on the candidate.");
             task.debug = { rootTaskId: task.id, facts: [...(input.debug.facts ?? [])], unknowns: [...(input.debug.unknowns ?? [])] };
-            if (input.origin !== undefined)
-                throw taskError("ESCAPE_ORIGIN_DEBUG_ACTION", "A DEBUG issue declares its origin with task debug --debug-action origin after a confirmed hypothesis.");
-            if (input.parentTaskId === undefined)
-                task.originRequired = true;
         }
         const validation = validateTask(task);
         if (!validation.ok) {
@@ -192,13 +163,10 @@ export class TaskService {
                         throw taskError("TASK_GOAL_IMMUTABLE", "Subtasks must retain their parent original goal.");
                     validation.value.goal = parent.task.goal;
                 }
-                if (parent.task.debug !== undefined) {
-                    if (input.debug !== undefined)
-                        throw taskError("TASK_DEBUG_ROOT_IMMUTABLE", "A child cannot create a new issue budget.");
+                if (parent.task.debug !== undefined)
                     validation.value.debug = structuredClone(parent.task.debug);
-                }
             }
-            if (input.requireSurface === true && validation.value.debug === undefined) {
+            if (input.requireSurface === true) {
                 const parentSurface = state.tasks.find(record => record.task.id === input.parentTaskId)?.task.surface;
                 const surfacedParent = parentSurface !== undefined && !isCovers(parentSurface);
                 if (surface === undefined || isCovers(surface) !== surfacedParent)
@@ -208,7 +176,6 @@ export class TaskService {
             }
             const record = {
                 task: validation.value,
-                ...(input.debug === undefined ? {} : { debug: createDebugState(task.id, createdSourceCommit, debugSettings, this.#completion.root) }),
                 ...(createdSourceCommit === undefined ? {} : { createdSourceCommit }),
                 status: "active",
                 evidence: {},
@@ -271,26 +238,28 @@ export class TaskService {
         if (taskContractHash(previous.task) !== input.expectedContractHash)
             throw taskError("TASK_CONTRACT_CHANGED", "Task contract changed.");
         // With none of them, a revision only rebinds the task to the current configuration (checked below).
-        const rebindOnly = input.criteria === undefined && input.surface === undefined && input.origin === undefined;
+        const rebindOnly = input.criteria === undefined && input.surface === undefined && input.origin === undefined && input.baseline === undefined;
         if (rebindOnly && this.#completion === undefined)
             throw taskError("TASK_REVISION_INVALID", "Revision requires criteria, a surface, an origin, or a combination.");
-        if (input.origin !== undefined && previous.task.debug !== undefined && input.debugOrigin !== true)
-            throw taskError("ESCAPE_ORIGIN_DEBUG_ACTION", "A DEBUG issue declares its origin with task debug --debug-action origin after a confirmed hypothesis.");
         // Re-declaring the same origin only refreshes its ledger record; the contract and its proof stand.
         if (input.criteria === undefined && input.surface === undefined && input.origin !== undefined &&
             canonicalJson(input.origin) === canonicalJson(previous.task.origin ?? null))
             return previous;
         const surface = input.surface === undefined ? previous.task.surface : parseSurface(input.surface);
-        const baseline = input.baseline ?? previous.createdSourceCommit;
-        const criteria = input.criteria === undefined ? structuredClone(previous.task.criteria) : structuredClone(input.criteria).map(criterion => {
+        // An explicit --baseline moves every typed criterion (e.g. a task opened on the wrong branch); its evidence is then void.
+        const moved = input.baseline === undefined ? undefined : await this.#resolveCommit(input.baseline);
+        const baseline = moved ?? previous.createdSourceCommit;
+        const criteria = (input.criteria === undefined ? structuredClone(previous.task.criteria) : structuredClone(input.criteria)).map(criterion => {
             if (criterion.acceptance === undefined)
                 return criterion;
-            const sha = criterion.acceptance.baselineCommit ?? baseline;
+            if (input.criteria === undefined && moved === undefined)
+                return criterion;
+            const sha = moved ?? criterion.acceptance.baselineCommit ?? baseline;
             if (sha === undefined)
                 throw taskError("BASELINE_REQUIRED", "Legacy tasks need an explicit baseline before typed acceptance.");
             const old = previous.task.criteria.find(c => c.id === criterion.id)?.acceptance;
-            if (old !== undefined && sha !== old.baselineCommit)
-                throw taskError("BASELINE_IMMUTABLE", "Create a replacement criterion instead of changing its baseline.");
+            if (moved === undefined && old !== undefined && sha !== old.baselineCommit)
+                throw taskError("BASELINE_IMMUTABLE", "Create a replacement criterion, or move every baseline with --baseline.");
             return { ...criterion, acceptance: { ...criterion.acceptance, baselineCommit: sha } };
         });
         const next = { ...previous.task, schemaVersion: TASK_SCHEMA_VERSION,
@@ -319,7 +288,13 @@ export class TaskService {
             const current = findTask(state, taskId);
             if (current.status !== "active" || JSON.stringify(current) !== JSON.stringify(previous))
                 throw taskError("TASK_CONTRACT_CHANGED", "Concurrent revision preserved; retry from current task.");
-            const result = { ...current, task: next, evidence: {}, failureFingerprint: null,
+            // Surface, origin or goal-only revisions keep what verification ran; review is still voided by the new contract hash.
+            const sameExecution = executionContractHash(next) === executionContractHash(current.task) && policyConfigHash === current.policyConfigHash;
+            // Review references never carry over: the new contract needs fresh review.
+            const verified = Object.fromEntries(Object.entries(current.evidence)
+                .map(([id, refs]) => [id, refs.filter(ref => !ref.startsWith("review:"))]).filter(([, refs]) => refs.length > 0));
+            const result = { ...current, task: next, evidence: sameExecution ? verified : {},
+                failureFingerprint: sameExecution ? current.failureFingerprint : null, ...(moved === undefined ? {} : { createdSourceCommit: moved }),
                 policyConfigHash, completionBase: null, updatedAt: now,
                 revisions: [...(current.revisions ?? []), { previousTask: current.task, previousEvidence: current.evidence,
                         previousFailure: current.failureFingerprint, previousHash: input.expectedContractHash,
@@ -329,6 +304,15 @@ export class TaskService {
             return cloneRecord(withoutReview);
         });
     }
+    /** A moved baseline must be a real commit in the candidate's history, so red-to-green still proves this change. */
+    async #resolveCommit(ref) {
+        const git = this.#completion?.gitRunner;
+        const resolved = git === undefined ? undefined : await git.run(["rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`]);
+        const sha = resolved?.exitCode === 0 ? resolved.stdout.toString().trim() : "";
+        if (!commitIdentity(sha) || (await git.run(["merge-base", "--is-ancestor", sha, "HEAD"])).exitCode !== 0)
+            throw taskError("TASK_BASELINE_INVALID", "--baseline must resolve to a commit that is an ancestor of HEAD.");
+        return sha;
+    }
     async replan(taskId, input) {
         if (input.reason.trim() === "" || input.reason.includes("\0") || input.reason.length > 8192 ||
             input.tasks.length === 0 || input.tasks.length > 128)
@@ -461,8 +445,6 @@ export class TaskService {
                 if (record.policyConfigHash !== parent.policyConfigHash || !validateTask(task).ok) {
                     throw taskError("TASK_DELIVERY_INVALID", `Task ${task.id} has an incompatible policy or definition.`);
                 }
-                if (parent.task.debug !== undefined && (task.goal !== parent.task.goal || JSON.stringify(task.debug) !== JSON.stringify(parent.task.debug) || record.debug !== undefined))
-                    throw taskError("TASK_DEBUG_ROOT_MISMATCH", "A delivery must retain the original issue identity and cannot import an independent debug budget.");
                 const existing = state.tasks.find((item) => item.task.id === task.id);
                 if (existing !== undefined) {
                     if (JSON.stringify(existing.task) !== JSON.stringify(task)) {
@@ -488,11 +470,6 @@ export class TaskService {
             }
         });
     }
-    /** The active DEBUG root already holding this original issue, if any. */
-    async activeDebugRoot(goal) {
-        return (await this.list()).find((record) => record.status === "active" && record.task.debug?.rootTaskId === record.task.id &&
-            record.task.goal !== undefined && sameDebugText(record.task.goal, goal)) ?? null;
-    }
     async list(filter = {}) {
         const state = await this.#store.read();
         return state.tasks
@@ -721,7 +698,7 @@ export class TaskService {
                 validation.value.criterionId === criterionId && validation.value.commandId === commandId &&
                 validation.value.configHash === configHash && validation.value.sourceFingerprint === sourceFingerprint &&
                 (!(snapshot.task.goal !== undefined || (snapshot.task.contractRevision ?? 0) > 0 || snapshot.task.criteria.some(c => c.acceptance !== undefined)) ||
-                    validation.value.taskContractHash === taskContractHash(snapshot.task))
+                    evidenceMatchesContract(validation.value.taskContractHash, snapshot.task))
                 ? validation.value : null;
         };
         for (const criterion of snapshot.task.criteria) {

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

@@ -4,7 +4,6 @@ import { AgentOpsError } from "../fs/paths.js";
 import { validateTask } from "../schema/validate.js";
 import { readPrivateFile, withPrivateFileLock, writePrivateFile } from "../security/permissions.js";
 import { taskContractHash } from "./contract.js";
-import { assertDebugState } from "./debug-state.js";
 import { commitIdentity, acceptanceSourcePath } from "../schema/acceptance.js";
 const DEFAULT_MAX_BYTES = 1024 * 1024;
 const SESSION_ID_PATTERN = /^[^\0\r\n]{1,256}$/u;
@@ -78,11 +77,9 @@ function parseTaskRecord(value) {
     if (!task.ok) {
         return invalidState("Task state contains an invalid task.");
     }
-    if (value.debug !== undefined) {
-        assertDebugState(value.debug);
-        if (value.debug.rootTaskId !== task.value.id || task.value.debug?.rootTaskId !== task.value.id)
-            return invalidState("Debug counters belong only to the original issue root.");
-    }
+    // Pre-0.11 DEBUG budget/hypothesis state: accepted, then dropped on load.
+    if (value.debug !== undefined && !isRecord(value.debug))
+        return invalidState("Task state contains an invalid task record.");
     if (!["active", "archived", "complete"].includes(String(value.status)) ||
         !isTimestamp(value.createdAt) ||
         !isTimestamp(value.updatedAt) ||
@@ -188,7 +185,6 @@ function parseTaskRecord(value) {
     }
     return {
         task: task.value,
-        ...(value.debug === undefined ? {} : { debug: value.debug }),
         ...(value.noChangePaths === undefined ? {} : { noChangePaths: value.noChangePaths }),
         ...(value.createdSourceCommit === undefined ? {} : { createdSourceCommit: value.createdSourceCommit }),
         ...(value.revisions === undefined ? {} : { revisions: value.revisions }),

package/dist/runtime/src/verify/acceptance-coverage.js

@@ -2,10 +2,9 @@ import { calculateConfigHash, canonicalJson } from "../config/hash.js";
 import { readPrivateFile } from "../security/permissions.js";
 import { join } from "node:path";
 import { sha256 } from "../fs/hash.js";
-import { criterionContractHash, taskContractHash } from "../task/contract.js";
+import { criterionContractHash, evidenceMatchesContract } from "../task/contract.js";
 /** Only current, paired check evidence discharges a mechanical contract. */
 export async function acceptanceCoverage(record, config, sourceFingerprint, store) {
-    const contract = taskContractHash(record.task);
     const configHash = calculateConfigHash(config);
     const rows = [];
     for (const criterion of record.task.criteria) {
@@ -18,7 +17,7 @@ export async function acceptanceCoverage(record, config, sourceFingerprint, stor
             const evidence = await store.load(reference);
             if (evidence?.schemaVersion === 4 && evidence.taskId === record.task.id &&
                 evidence.criterionId === criterion.id && evidence.configHash === configHash &&
-                evidence.sourceFingerprint === sourceFingerprint && evidence.taskContractHash === contract &&
+                evidence.sourceFingerprint === sourceFingerprint && evidenceMatchesContract(evidence.taskContractHash, record.task) &&
                 evidence.acceptance?.criterionContractHash === criterionContractHash(criterion)) {
                 matching.push({ reference, evidence });
             }

package/dist/runtime/src/verify/acceptance-protocol.js

@@ -167,9 +167,10 @@ export function aggregateAcceptanceRun(run, requestedCheckIds) {
     const duplicateCheckIds = sortedUnique([...counts.entries()].filter(([, count]) => count > 1).map(([id]) => id));
     const unexpectedCheckIds = sortedUnique(run.results.filter((result) => !expected.has(result.checkId)).map((result) => result.checkId));
     const missingCheckIds = requested.filter((id) => !counts.has(id));
-    if (duplicateCheckIds.length > 0 || unexpectedCheckIds.length > 0 || missingCheckIds.length > 0) {
-        return unknown(run, run.results, duplicateCheckIds.length > 0 ? ACCEPTANCE_FAILURE.duplicate :
-            missingCheckIds.length > 0 ? ACCEPTANCE_FAILURE.missing : ACCEPTANCE_FAILURE.unexpected, ["The observed checks do not match the requested checks exactly."], missingCheckIds, duplicateCheckIds, unexpectedCheckIds);
+    // Checks the runner emits beyond the requested ones are ignored: a binding may list only its red checks.
+    // An unrequested failure still surfaces through the runner's exit code, which replay reconciles.
+    if (duplicateCheckIds.length > 0 || missingCheckIds.length > 0) {
+        return unknown(run, run.results, duplicateCheckIds.length > 0 ? ACCEPTANCE_FAILURE.duplicate : ACCEPTANCE_FAILURE.missing, ["The observed checks do not include every requested check exactly once."], missingCheckIds, duplicateCheckIds, unexpectedCheckIds);
     }
     const requestedResults = requested.map((id) => run.results.find((result) => result.checkId === id));
     if (run.diagnostics.length > 0) {

package/dist/runtime/src/verify/acceptance-replay.js

@@ -8,7 +8,7 @@ import { canonicalJson } from "../config/hash.js";
 import { sha256 } from "../fs/hash.js";
 import { removeTemporary } from "../fs/temporary.js";
 import { AgentOpsError, resolveContainedPath } from "../fs/paths.js";
-import { criterionContractHash, taskContractHash } from "../task/contract.js";
+import { criterionContractHash, executionContractHash } from "../task/contract.js";
 import { aggregateAcceptanceRun, makeAcceptanceCheck, makeAcceptanceRun } from "./acceptance-protocol.js";
 import { collectNodeAcceptance, collectJestAcceptance, collectVitestAcceptance, collectPytestAcceptance, collectRustAcceptance } from "./adapters/index.js";
 import { buildVerificationEvidence } from "./evidence.js";
@@ -118,12 +118,9 @@ export async function replayAcceptance(options) {
             const env = replayEnvironment(checkout, phase, executionId);
             let timedOut;
             const command = async (executable, args, cwd, stage, own) => {
-                const remaining = await options.remainingMs?.();
-                if (remaining === 0)
-                    throw new AgentOpsError("TASK_DEBUG_BUDGET_EXHAUSTED", "The original issue's active budget is exhausted.");
                 const limit = own ?? ACCEPTANCE_TIMEOUTS[stage];
                 const result = await runVerificationCommand({ id: group.runner.id, command: executable, args: [...args], cwd: ".", required: true,
-                    evidence: { kind: "exit-code" }, timeoutMs: Math.min(limit, remaining ?? Infinity) }, { cwd, runner: options.processRunner, env, replaceEnv: true,
+                    evidence: { kind: "exit-code" }, timeoutMs: limit }, { cwd, runner: options.processRunner, env, replaceEnv: true,
                     outputLimitBytes: 1024 * 1024, ...(options.signal === undefined ? {} : { signal: options.signal }) });
                 if (result.failureClass === "timeout" && timedOut === undefined)
                     timedOut = stage === "git"
@@ -217,7 +214,7 @@ export async function replayAcceptance(options) {
                 failure = aggregate?.failureClass ?? output.failureClass;
             }
             catch (error) {
-                failure = error instanceof AgentOpsError && error.code === "TASK_DEBUG_BUDGET_EXHAUSTED" ? "debug-budget-exhausted" : error instanceof Error && /^[a-z-]+$/u.test(error.message) ? error.message : "replay-unavailable";
+                failure = error instanceof Error && /^[a-z-]+$/u.test(error.message) ? error.message : "replay-unavailable";
             }
             finally {
                 await removeTemporary(temp);
@@ -245,7 +242,7 @@ export async function replayAcceptance(options) {
                     scope: options.scope, startedAt, finishedAt, exitCode: output?.exitCode ?? null, testCount: checks.length,
                     status, failureClass: status === "PASS" ? "none" : phase === "baseline" && aggregate?.status === "PASS" ? "non-discriminating" : failure,
                     sourceFingerprint: options.sourceFingerprint, toolVersions: { node: process.version }, config: options.config,
-                    taskContractHash: taskContractHash(options.task), acceptance: { criterionContractHash: criterionContractHash(criterion),
+                    taskContractHash: executionContractHash(options.task), acceptance: { criterionContractHash: criterionContractHash(criterion),
                         bindingHash: sha256(canonicalJson({ runnerId: group.runner.id, materials: group.binding.materials })), phase, commit, pairedCommit: phase === "baseline" ? candidate : group.baseline, materialDigest, executionDigest, executionArtifact, checks } });
                 const reference = await options.evidenceStore.save(evidence);
                 reports.push({ criterionId: criterion.id, runnerId: group.runner.id, phase, status, failureClass: evidence.failureClass, reference,

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

@@ -1,4 +1,4 @@
-import { taskContractHash } from "../task/contract.js";
+import { executionContractHash, taskContractHash } from "../task/contract.js";
 import { replayAcceptance } from "./acceptance-replay.js";
 import { AgentOpsError, resolveContainedPath } from "../fs/paths.js";
 import { validateTaskAgainstConfig } from "../schema/validate.js";
@@ -61,7 +61,9 @@ export class VerificationService {
                 failureClass: result.failureClass,
                 sourceFingerprint,
                 toolVersions: this.#options.toolVersions ?? {},
-                ...(task.goal === undefined && (task.contractRevision ?? 0) === 0 && task.criteria.every(c => c.acceptance === undefined) ? {} : { taskContractHash: taskContractHash(task) }),
+                // Surfaced tasks are always bound, so a later surface-only revision of a goal-less one keeps it; legacy tasks stay unbound.
+                ...(task.goal === undefined && (task.contractRevision ?? 0) === 0 && task.criteria.every(c => c.acceptance === undefined) &&
+                    task.surfaceRequired === undefined ? {} : { taskContractHash: executionContractHash(task) }),
                 config: this.#options.config
             });
             references.push(await this.#options.evidenceStore.save(evidence));
@@ -70,10 +72,7 @@ export class VerificationService {
     }
     async #runCommand(task, command) {
         const startedAt = (this.#options.now ?? (() => new Date().toISOString()))();
-        const remaining = task.debug === undefined ? undefined : await this.#options.taskService.debugService().remaining(task.id);
-        if (remaining === 0)
-            throw verificationError("TASK_DEBUG_BUDGET_EXHAUSTED", "The original issue's active budget is exhausted.");
-        const result = await executeConfiguredCommand(remaining === undefined ? command : { ...command, timeoutMs: Math.min(command.timeoutMs ?? 300_000, remaining) }, {
+        const result = await executeConfiguredCommand(command, {
             cwd: await this.#commandCwd(command),
             runner: this.#options.processRunner,
             trusted: this.#options.trusted
@@ -110,11 +109,6 @@ export class VerificationService {
         };
     }
     async verify(taskId) {
-        const stored = await this.#options.taskService.status({ taskId });
-        return stored.task.debug === undefined ? await this.#verify(taskId) :
-            await this.#options.taskService.debugService().verification(taskId, () => this.#verify(taskId));
-    }
-    async #verify(taskId) {
         const stored = await this.#options.taskService.status({ taskId });
         if (stored.status === "archived") {
             throw verificationError("TASK_NOT_ACTIVE", "An archived task cannot be verified.");
@@ -153,8 +147,7 @@ export class VerificationService {
             results.push(await this.#runCommand(validation.value, commandById(this.#options.config, commandId)));
         }
         const acceptance = validation.value.criteria.some(c => c.acceptance !== undefined && c.acceptance.mode !== "review-only")
-            ? await replayAcceptance({ ...this.#options, task: validation.value, sourceFingerprint,
-                ...(stored.task.debug === undefined ? {} : { remainingMs: () => this.#options.taskService.debugService().remaining(taskId) }) }) : [];
+            ? await replayAcceptance({ ...this.#options, task: validation.value, sourceFingerprint }) : [];
         let status = aggregateVerificationStatus([...results, ...acceptance.map(a => ({ required: true, status: a.status }))]);
         let sourceChanged = false;
         const postflightScope = await resolveReviewScope({
@@ -197,16 +190,6 @@ export class VerificationService {
             }
         }
         else {
-            if (stored.task.debug !== undefined && !sourceChanged) {
-                const failures = {};
-                for (const result of results) {
-                    const references = await this.#persistEvidence(validation.value, commandById(this.#options.config, result.commandId), result.startedAt, result.finishedAt, result, sourceFingerprint);
-                    relevantCriteria(validation.value, result.commandId).forEach((criterion, index) => { const reference = references[index]; if (reference !== undefined)
-                        failures[criterion.id] = [...(failures[criterion.id] ?? []), reference]; });
-                }
-                if (Object.keys(failures).length > 0)
-                    await this.#options.taskService.recordEvidence(taskId, failures);
-            }
             const required = [...results.filter((result) => result.required), ...acceptance.map(a => ({ commandId: a.runnerId, required: true,
                     status: a.status, failureClass: a.failureClass, exitCode: null, timedOut: false, testCount: null,
                     diagnostic: a.criterionId + ":" + a.phase + ":" + a.failureClass, evidenceReferences: [a.reference], startedAt: "", finishedAt: "" }))];

package/dist/runtime/src/verify/source-fingerprint.js

@@ -3,17 +3,30 @@ import { join } from "node:path";
 import { sha256 } from "../fs/hash.js";
 import { AgentOpsError } from "../fs/paths.js";
 import { resolveGitCommit } from "./change-surface.js";
+/**
+ * Escape-ledger records are committed after the fix; a commit touching only them leaves the base-mode fingerprint alone.
+ * Only top-level task records qualify: rules/ steer the surface gate and stay fingerprinted.
+ */
+const ledgerRecord = (path) => /^\.agent-ops-escapes\/task-[A-Za-z0-9-]+\.json$/u.test(path);
+/** HEAD's tree without the ledger, so a ledger-only commit yields the same digest. */
+async function ledgerFreeTree(runner) {
+    const result = await runner.run(["ls-tree", "-r", "--full-tree", "-z", "HEAD"]);
+    if (result.exitCode !== 0)
+        throw new AgentOpsError("CHANGE_SURFACE_GIT_FAILED", "Git could not list the HEAD tree.");
+    const entries = Buffer.from(result.stdout).toString("utf8").split("\0").filter(entry => entry !== "" && !ledgerRecord(entry.split("\t", 2)[1]));
+    return sha256(entries.join("\0"));
+}
 export async function calculateSourceFingerprint(root, scope, runner) {
-    const head = await resolveGitCommit(runner, "HEAD");
     if (scope.mode === "base") {
         return sha256(JSON.stringify({
-            domain: "agent-ops-source-v1",
+            domain: "agent-ops-source-v2",
             mode: scope.noChange === true ? "goal-no-change" : "base",
-            head,
+            tree: await ledgerFreeTree(runner),
             base: scope.resolvedBase,
-            paths: [...scope.changedFiles]
+            paths: scope.changedFiles.filter(path => !ledgerRecord(path))
         }));
     }
+    const head = await resolveGitCommit(runner, "HEAD");
     const paths = [];
     for (const path of scope.changedFiles) {
         const absolute = join(root, ...path.split("/"));

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

@@ -283,7 +283,7 @@ export async function runVerificationCommand(command, options) {
     }
     const outputLimit = boundedPositiveInteger(options.outputLimitBytes ?? DEFAULT_OUTPUT_LIMIT_BYTES, MAX_OUTPUT_LIMIT_BYTES, "outputLimitBytes");
     const terminationGrace = boundedPositiveInteger(options.terminationGraceMs ?? DEFAULT_TERMINATION_GRACE_MS, MAX_TERMINATION_GRACE_MS, "terminationGraceMs");
-    const timeoutMs = boundedPositiveInteger(command.timeoutMs ?? DEFAULT_TIMEOUT_MS, 2_147_483_647, "timeoutMs");
+    const timeoutMs = options.timeoutMs === null ? null : boundedPositiveInteger(options.timeoutMs ?? command.timeoutMs ?? DEFAULT_TIMEOUT_MS, 2_147_483_647, "timeoutMs");
     const runner = options.runner ?? new NodeVerificationProcessRunner();
     let running;
     try {
@@ -304,7 +304,8 @@ export async function runVerificationCommand(command, options) {
     const stderr = captureOutput(running.stderr, outputLimit, options.onActivity);
     let timer;
     const timeout = new Promise((resolve) => {
-        timer = setTimeout(() => resolve({ kind: "timeout" }), timeoutMs);
+        if (timeoutMs !== null)
+            timer = setTimeout(() => resolve({ kind: "timeout" }), timeoutMs);
     });
     let removeAbortListener = () => { };
     const aborted = new Promise((resolve) => {

package/docs/en/guides/task-debug.md

@@ -1,135 +1,41 @@
 # Task DEBUG investigations
 
-Project `init` and `update` add `features.debug` by default:
-`{"enabled":true,"budgetMs":3600000,"maxRounds":5}` (sixty minutes). Explicit disabled and custom
-settings survive subsequent installs. Old configurations and ordinary tasks
-remain readable. DEBUG is an optional task intake field, not a new run mode.
-
-Claude and Codex native prompt hooks conservatively recognize investigation and
-bug-fix requests. They retain the issue verbatim as `goal`, record uncertain
-facts/unknowns, and create an existing isolated task. Explain, feature and
-refactor requests retain their ordinary behavior. A reliable native session ID
-is required; agy does not provide this prompt intake. Its native agent can use
-`task create --debug --goal '<original issue>'` with two to five criteria, which
-starts the same foreground clock when the native session is available.
-An original dirty checkout is refused before any worktree snapshot is created.
-
-The intake criteria are provisional. The native agent investigates via trusted
-configured commands, records hypotheses, replaces the criteria with relevant
-behavioral acceptance, fixes the product, and uses existing `verify`, `review`
-and worktree finish commands. There is no additional model or background worker.
-The default is the full repair loop. A clean HEAD fixes the baseline automatically;
-do not request redundant approval or offer diagnosis-only as a fallback. Failure
-to reproduce alone does not permit Stop: continue discriminating checks within
-the original budget.
-
-## Human control
-
-Native human transcript events control the existing task; CLI actor/text fields,
-assistant messages and injected instructions cannot authorize a scope change.
-Codex supports current `response_item` human messages and native async answers,
-as well as legacy `event_msg` transcripts.
-
-- `只診斷` / `diagnosis only`: investigate without product repairs. Non-success
-  Stop requires a confirmed hypothesis supported by a current sealed baseline
-  assertion FAIL for the original regression, or an existing runtime blocker/limit.
-- `暫停` / `pause`: save progress and stop immediately. Native Codex `Interrupt`
-  also pauses, with a three-second hook timeout; it never blocks or restarts an interrupt.
-- `繼續` / `continue`: resume the same task and scope. An exhausted time budget
-  still needs the existing native time grant; other blockers remain authoritative.
-- `繼續修復` / `resume repair`: restore the full repair loop on the existing task.
-
-Pauses retain evidence, consumed time and rounds, exclude waiting time, and do not
-reset budgets. Diagnosis and pause cannot complete a repair task. Ambiguous free
-text is not inferred as permission; use an explicit command above.
-
-Use `task debug --task <id> --debug-action <action>`:
-
-- `status` displays root-wide hypotheses, receipts and remaining state.
-- `investigate --command-id <id>` runs a trusted configured verifier. Actual
-  subprocess outcomes/time are recorded; reproduction-only work is not a fix round.
-- `hypothesis --payload-file <json>` records `id`, `statement`, `method`,
-  `expected`, `checkId`, `expectedStatus` (`PASS` or `FAIL`). Add `reference` to
-  resolve it from actual sealed acceptance evidence. `--action investigate` may
-  only run a declared unresolved behavioral red check; `--action observe` may
-  only classify the current matching runtime `UNKNOWN` receipt as inconclusive.
-  Neither action lets an agent assign a status. A rejected hypothesis needs a
-  new reference and `reason`.
-- `strategy --payload-file <json>` records a different `from`/`to` method,
-  substantive `reason` and discriminating `reference`. Only one switch is allowed.
-- `origin --payload-file <json>` declares where the bug came from once a
-  hypothesis is confirmed: `{"kind": "escape-of", "commit": "<commit>", "label":
-  "<earliest gate>"}` (optional `"receipt"`) or `{"kind": "pre-existing" |
-  "external", "reason": "..."}`. It revises the contract, so re-verify and
-  re-record the confirmed hypothesis before review; finish refuses
-  `ESCAPE_ORIGIN_MISSING` without it. `escape-of` prints the link state and
-  `git blame` hints and writes `.agent-ops-escapes/<task-id>.json`, which is
-  committed with the fix (see `EVIDENCE-ESCAPE-001`). A surface label also
-  needs a tracked `.agent-ops-escapes/rules/<rule-id>.json` rule that replays
-  at the escaped commit, and a criteria/verify label needs `"promote":
-  "<runnerId:checkId>"`; finish refuses `ESCAPE_RULE_UNPROVEN` otherwise (see
-  `EVIDENCE-ESCAPE-002`).
-- `checkpoint --session <id>` saves the current bound source/policy/stop cause.
-- `resume --session <id>` recovers a matching owned worktree checkpoint. Mismatches
-  require human confirmation and remain preserved; this command cannot waive them.
-- `extend --session <native-id> --event-id latest` reads the current native human
-  continue or resume-repair event. After time exhaustion it grants a full twenty
-  minutes from that event, retaining consumed time and overrun in the grant snapshot
-  without waiving any other blocker. No actor/text flag can
-  authorize a grant. Missing native transcripts fail closed as unsupported.
-
-Limits belong to the original root across revisions, children and sessions.
-Repeating an active issue's text from a new session reattaches that root (or
-resumes the worktree holding it) instead of starting a fresh budget. A
-resolved hypothesis cannot return under a new id with the same statement and
-method; reopen the original with new discriminating evidence.
-Controlled investigation, verification and acquired review execution consume
-active time; observable review-slot waiting is excluded. Claude, Codex, and agy
-use their native session lifecycle to account foreground reasoning, tool use,
-and edits. Accepted idle Stop closes the foreground clock. Rejected Codex Stop
-keeps the clock running, including repeated Stop (`stop_hook_active: true`). OpenCode has no supported
-foreground lifecycle and remains unsupported. Time between stopped turns is
-paused. An interrupted unsealed operation remains blocked until its persisted process
-identity proves death; only then is an UNKNOWN environment receipt sealed and
-the elapsed interval retained.
-
-Only changed product candidates followed by verification count toward repair
-rounds. Test/fixture edits do not. New paired original-regression outcomes or
-new discriminating hypothesis outcomes count as progress; renaming a task or
-hypothesis does not. Two stagnant rounds require the strategy switch; two more
-stop, subject to the global round/time ceilings.
-The switch may cite this issue's own sealed regression evidence from an earlier
-contract revision, because a scope revision stales current evidence while
-verification stays stopped; hypotheses and delivery still need fresh evidence.
-At the round limit an unchanged candidate may still be reviewed, and re-verified
-when its last verification passed; a failing or changed candidate stays stopped.
-
-Success requires baseline assertion red and candidate green for the original
-regression, required related checks, a supported confirmed hypothesis, and two
-fresh independent reviews bound to the current source, contract, config and
-meaningful DEBUG proof. Missing IDs, setup failure, skip, timeout and UNKNOWN
-never prove reproduction. Proof changes invalidate review. Completed tasks and
-worktree finish retain the existing attestation/integration requirements.
-
-On Claude, agy and native Codex, Stop checks an active DEBUG issue even without Git net diff,
-with or without the completion gate. Without the gate this check alone runs,
-with one targeted task/config reload on a gate fault. A second failure emits an
-explicit `UNKNOWN` / incomplete diagnostic with `agent-ops doctor` recovery,
-permits non-success Stop and preserves the task, evidence and budgets. It never
-attests completion or retries indefinitely.
-A valid runtime stop checkpoint permits non-success Stop while retaining the
-active task. `allow-stop` cannot waive DEBUG. Gates are never automatically
-enabled for unsupported hosts: the generic Codex completion gate remains
-unsupported, while its DEBUG-specific Stop uses native `decision: "block"`
-with a continuation reason. `continue: false` would stop the harness and is not
-used to continue DEBUG. OpenCode Stop is unsupported. This feature
-persists foreground progress, and does not promise
-execution after the native conversation closes. Native transcripts are trusted
-host evidence, not protection against an attacker with the same filesystem
-authority.
-
-An explicit native human `no time limit` / `取消時間限制` instruction removes the
-original issue time cap via the same native-only `extend --event-id latest`
-authority. The grant records `grantedMs: null` and the spent snapshot; original
-budget, consumption, prior grants, iteration limits and evidence gates remain.
-Ordinary command and review stall timeouts remain in force.
+A DEBUG task is an ordinary task whose acceptance proves the original
+regression: a behavioral criterion whose `redCheckIds` fail with an assertion at
+the baseline commit and pass on the candidate. Nothing else is special about it.
+
+```sh
+agent-ops task create --debug --title "Fix cart scroll" \
+  --goal '<the issue, verbatim>' \
+  --surface-file surface.json \
+  --criterion-file regression.json --criterion-file related.json
+```
+
+- `--debug` needs `--goal` and at least one behavioral criterion with
+  `redCheckIds`; otherwise creation fails with `TASK_DEBUG_RED_CHECK_REQUIRED`.
+  The surface audit is required as for any task.
+- The baseline is the commit the task was created on; `task revise --baseline
+  <ref>` moves it (for example off the wrong branch) and voids earlier evidence.
+- Then fix, commit, `verify`, two-round `review` and `worktree finish` exactly
+  as for any task. Setup failure, skip, timeout and UNKNOWN never prove
+  reproduction; the red check must fail on an assertion at the baseline.
+
+## Escape origin (advisory)
+
+If you know where the bug came from, record it like any task:
+`task revise --escape-of <commit> --escape-label <label>`. It writes `.agent-ops-escapes/<task-id>.json` and
+prints the link state, `git blame` hints and any rule proof
+(`ESCAPE_RULE_UNPROVEN` and friends). None of it blocks finish; see
+`EVIDENCE-ESCAPE-001` and `EVIDENCE-ESCAPE-002`.
+
+## Removed in 0.11.0
+
+`task debug` (hypotheses, strategy switches, investigate, checkpoint, resume,
+extend, origin), the 60-minute budget and five-round limit, native control
+words (只診斷, 暫停, 繼續, 繼續修復, 取消時間限制), automatic DEBUG intake from
+prompt hooks, the DEBUG-specific Stop block and the Codex `Interrupt` hook are
+gone. `task debug` now fails with `TASK_DEBUG_REMOVED`.
+
+Older state still loads: tasks keep their `debug` tag, stored budget and
+hypothesis state is ignored, `originRequired` no longer blocks finish, and a
+config's `features.debug` is accepted and dropped by the next `update`.