@kylecheng3146/agent-ops 0.10.2 → 0.11.0

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

@@ -14,7 +14,6 @@ import { evaluateWorktreeEnter } from "../../../runtime/src/parallel/enter.js";
 import { evaluateWorktreeWrite, resolveMainRoot } from "../../../runtime/src/parallel/guard.js";
 import { ensureSessionWorktree, recordSessionOrigin } from "../../../runtime/src/parallel/service.js";
 import { CompletionGateService } from "../../../runtime/src/hooks/completion-gate.js";
-import { closeDebugSession, debugStopGate, interruptDebugSession, routeDebugPrompt, startDebugSession } from "./debug-intake.js";
 import { TaskService } from "../../../runtime/src/task/service.js";
 import { FileTaskStore } from "../../../runtime/src/task/store.js";
 import { FileEvidenceStore } from "../../../runtime/src/verify/evidence.js";
@@ -269,8 +268,6 @@ async function closeOfficeSession(io, dependencies) {
                 root, harness: "claude", event: "SessionEnd", input, validated: true,
                 ...(typeof fields.session_id === "string" ? { sessionId: fields.session_id } : {})
             });
-        if (typeof fields.session_id === "string")
-            await closeDebugSession(root, fields.session_id, "claude").catch(() => undefined);
     }
     catch {
         // Office never blocks a session, least of all one that is ending.
@@ -307,12 +304,8 @@ async function promptSubmitted(harness, io, dependencies) {
         const prompt = fields.prompt;
         if (typeof prompt !== "string" || prompt.length === 0 || prompt.length > 64 * 1024 || prompt.includes("\0"))
             return 0;
-        if (evaluateGuardrail({ kind: "content", content: prompt, scope: root }).action !== "block") {
-            const context = await routeDebugPrompt(root, input, harness).catch(error => `DEBUG intake unavailable: ${error instanceof Error ? error.message : "preserve current state"}`);
-            if (context !== null)
-                io.writeStdout(harness === "claude" ? JSON.stringify({ hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: context } }) : context + "\n");
+        if (evaluateGuardrail({ kind: "content", content: prompt, scope: root }).action !== "block")
             return 0;
-        }
         if (!config.profiles.includes("guardrails") && !config.profiles.includes("loop") && !config.profiles.includes("run"))
             return 0;
         const reason = "agent-ops blocked a suspected secret.";
@@ -329,28 +322,14 @@ async function promptSubmitted(harness, io, dependencies) {
 }
 export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
     const [harness, event] = argv;
-    if (harness === "codex" && event === "Interrupt") {
-        try {
-            const raw = await readStdin(io.stdin), input = parseInput(raw);
-            if (typeof input !== "object" || input === null || Array.isArray(input))
-                return 0;
-            const fields = input;
-            if (typeof fields.session_id !== "string" || fields.session_id.length === 0)
-                return 0;
-            const root = dependencies.root ?? (typeof fields.cwd === "string" ? fields.cwd : process.cwd());
-            await interruptDebugSession(root, fields.session_id, raw);
-        }
-        catch {
-            io.writeStdout(JSON.stringify({ systemMessage: "agent-ops: DEBUG interrupt progress could not be sealed; preserve the task and run agent-ops doctor before resuming." }));
-        }
+    // Pre-0.11 installs registered Interrupt only for DEBUG; it is now a no-op until update removes it.
+    if (harness === "codex" && event === "Interrupt")
         return 0;
-    }
     if (harness === "claude" && event === "SessionEnd")
         return await closeOfficeSession(io, dependencies);
     if ((harness === "claude" || harness === "codex") && event === "UserPromptSubmit")
         return await promptSubmitted(harness, io, dependencies);
-    // The generic completion gate requires an approval escape hatch. Codex
-    // only enforces DEBUG through runtime checkpoints and native human control.
+    // The generic completion gate requires an approval escape hatch, which Codex lacks.
     const completionGateInstalled = (harness === "agy" || harness === "claude") &&
         event === "Stop" &&
         argv.includes("--completion-gate");
@@ -400,18 +379,7 @@ export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
             }
         }
         let configOutcome = await hookConfigOutcome(root, dependencies.loadConfig);
-        const nativeStop = normalizeHookInput(harnessId, parsedInput);
-        if (harnessId === "codex" && hookEvent === "Stop" && configOutcome.kind === "invalid")
-            configOutcome = await hookConfigOutcome(root, dependencies.loadConfig);
         if (configOutcome.kind === "invalid") {
-            if (harnessId === "codex" && nativeStop?.event === "stop" && nativeStop.sessionId !== undefined) {
-                writeHookOutput(io, harnessDescriptor(harnessId).runtime.formatOutput("Stop", {
-                    action: "continue", status: "UNKNOWN", code: "TASK_DEBUG_GATE_UNAVAILABLE",
-                    remedy: "DEBUG remains incomplete: configuration failed after one targeted reload. Preserve the task, evidence and budgets; fix .agent-ops/config.json and run agent-ops doctor. No completion is attested."
-                }));
-                await closeDebugSession(root, nativeStop.sessionId, harnessId).catch(() => undefined);
-                return 0;
-            }
             if (completionGateInstalled) {
                 writeHookOutput(io, harnessDescriptor(harness).runtime.formatOutput("Stop", {
                     action: "block",
@@ -434,15 +402,6 @@ export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
             return 0;
         }
         const config = configOutcome.config;
-        if (harnessId === "codex" && hookEvent === "Stop" && nativeStop !== null && config.features.debug?.enabled === true) {
-            const result = await debugStopGate(root, config).handle(nativeStop);
-            if (result !== null) {
-                writeHookOutput(io, harnessDescriptor(harnessId).runtime.formatOutput("Stop", result));
-                if (result.action === "continue" && nativeStop.sessionId !== undefined)
-                    await closeDebugSession(root, nativeStop.sessionId, harnessId).catch(() => undefined);
-                return 0;
-            }
-        }
         if (completionGateInstalled && !config.features.completionGate.enabled) {
             writeHookOutput(io, harnessDescriptor(harness).runtime.formatOutput("Stop", {
                 action: "block",
@@ -457,8 +416,6 @@ export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
             : await dependencies.trust(root, config, cliVersion);
         const trusted = trustStatus === "TRUSTED";
         const normalized = normalizeHookInput(harnessId, parsedInput);
-        if (normalized?.event === "session-start" && normalized.sessionId !== undefined)
-            await startDebugSession(root, normalized.sessionId, harnessId).catch(() => undefined);
         if (dependencies.office !== undefined && config.features.office?.enabled === true) {
             if (normalized !== null) {
                 const phase = officePhaseHint(normalized) ?? (harnessId === "codex" ? officeLoopPhaseHint(parsedInput, root) : undefined);
@@ -554,43 +511,22 @@ export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
                 await recordSessionOrigin(dependencies.worktree, { cwd: root, sessionId }).catch(() => undefined);
             }
         }
-        let hookResult;
-        // Without the gate, DEBUG still refuses a Stop that has no valid stop
-        // checkpoint. Its own failure stays advisory, so it never blocks other work.
-        const debugStop = completionGate === undefined && hookEvent === "Stop" && normalized !== null &&
-            (harnessId === "agy" || harnessId === "claude" || harnessId === "codex") && config.features.debug?.enabled === true
-            ? await debugStopGate(root, config).handle(normalized)
-            : null;
-        if (debugStop !== null)
-            hookResult = debugStop;
-        const output = debugStop !== null
-            ? harnessDescriptor(harnessId).runtime.formatOutput("Stop", debugStop)
-            : await runHookCommand({
-                harness: harness,
-                event: hookEvent,
-                stdin: rawInput,
-                input: parsedInput,
-                config,
-                trusted,
-                onResult: result => { hookResult = result; },
-                ...(worktreeGuard === undefined ? {} : { worktreeGuard }),
-                ...(worktreeEnter === undefined ? {} : { worktreeEnter }),
-                ...(dependencies.advisory === undefined
-                    ? {}
-                    : { advisory: dependencies.advisory }),
-                ...(stopVerification === undefined ? {} : { stopVerification }),
-                ...(completionGate === undefined ? {} : { completionGate })
-            });
+        const output = await runHookCommand({
+            harness: harness,
+            event: hookEvent,
+            stdin: rawInput,
+            input: parsedInput,
+            config,
+            trusted,
+            ...(worktreeGuard === undefined ? {} : { worktreeGuard }),
+            ...(worktreeEnter === undefined ? {} : { worktreeEnter }),
+            ...(dependencies.advisory === undefined
+                ? {}
+                : { advisory: dependencies.advisory }),
+            ...(stopVerification === undefined ? {} : { stopVerification }),
+            ...(completionGate === undefined ? {} : { completionGate })
+        });
         writeHookOutput(io, output);
-        // A Stop can be advisory or gated, but the foreground clock only ends on
-        // the same trusted idle model_stop that the native decision accepted.
-        if (normalized?.event === "stop" &&
-            normalized.sessionId !== undefined &&
-            normalized.terminationReason === "model_stop" &&
-            normalized.fullyIdle === true &&
-            hookResult?.action === "continue") {
-            await closeDebugSession(root, normalized.sessionId, harnessId).catch(() => undefined);
-        }
     }
     catch {
         if (completionGateInstalled) {

package/dist/packages/cli/src/run-entry.js

@@ -43,25 +43,69 @@ const exec = promisify(execFile);
 const plain = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const active = (worker) => ["assigned", "starting", "running", "idle", "handing-off"].includes(worker.status);
 const cli = fileURLToPath(new URL("./bin.js", import.meta.url));
-/** Release the sole native slot only after confirmed coordinator death. */
+const pendingChildren = (state) => state.tasks.filter(task => task.taskId !== state.rootTaskId && !["delivered", "complete", "blocked"].includes(task.status));
+// Only a coordinator wait stops the coordinator with a handoff reason; it never delivers itself.
+const yielded = (worker) => worker.status === "stopped" && worker.stopIntent?.reason === "handoff";
+/**
+ * Stop a coordinator that asked to wait for its children, instead of letting it
+ * poll run status. Its native thread is dropped so the wake starts fresh.
+ */
+export async function waitForChildren(repository, supervisor, runId, workerId, generation) {
+    const current = await repository.read(runId);
+    if (current === null || workerId !== current.coordinatorId)
+        throw new AgentOpsError("RUN_COORDINATOR_REQUIRED", "Only the coordinator can wait for child deliveries.");
+    if (current.rootTaskId === null || pendingChildren(current).length === 0)
+        throw new AgentOpsError("RUN_WAIT_NOTHING_PENDING", "Wait requires at least one planned child that has not finished.");
+    await yieldCoordinator(repository, supervisor, runId, workerId, generation, current.rootTaskId);
+}
+async function yieldCoordinator(repository, supervisor, runId, workerId, generation, taskId) {
+    await supervisor.stopWorker(runId, workerId, generation, "handoff");
+    await repository.mutate(runId, saved => ({ ...saved, workers: saved.workers.map(w => w.workerId === workerId && w.generation === generation && w.status === "stopped" ? { ...w, nativeSessionId: null, nativeJobId: null } : w) }));
+    await repository.appendEvent(runId, { type: "diagnostic", code: "RUN_COORDINATOR_YIELDED", workerId, taskId,
+        detail: "Coordinator waited; process death confirmed and its slot released until every child finishes." });
+}
+/** Finish an unconfirmed wait, then return the stopped coordinator once every child has finished. */
 export async function prepareSerialSchedule(repository, supervisor, runId) {
     const current = await repository.read(runId);
-    if (current === null || current.jobs !== 1 || current.rootTaskId === null || current.status !== "active" || current.disableRestart || current.awaitingResume)
+    if (current === null || current.rootTaskId === null || current.status !== "active" || current.disableRestart || current.awaitingResume)
         return null;
-    const children = current.tasks.filter(task => task.taskId !== current.rootTaskId);
     const coordinator = current.workers.find(worker => worker.workerId === current.coordinatorId);
-    if (children.length === 0 || coordinator === undefined)
-        return null;
-    if (children.some(task => !["delivered", "complete", "blocked"].includes(task.status))) {
-        if (active(coordinator)) {
-            await supervisor.stopWorker(runId, coordinator.workerId, coordinator.generation, "handoff");
-            await repository.appendEvent(runId, { type: "diagnostic", code: "RUN_COORDINATOR_YIELDED", workerId: coordinator.workerId,
-                taskId: coordinator.taskId, detail: "Coordinator process death confirmed before assigning the sole slot to children." });
+    if (coordinator?.status === "handing-off" && coordinator.stopIntent?.reason === "handoff") {
+        try {
+            await yieldCoordinator(repository, supervisor, runId, coordinator.workerId, coordinator.generation, current.rootTaskId);
+        }
+        catch (cause) {
+            // The slot stays held until death is confirmed; retry on the next supervisor pass.
+            if (cause instanceof AgentOpsError && ["RUN_HANDOFF_PROCESS_ALIVE", "RUN_WRITER_STILL_ALIVE"].includes(cause.code))
+                return null;
+            throw cause;
         }
         return null;
     }
+    if (coordinator === undefined || current.tasks.every(task => task.taskId === current.rootTaskId) || pendingChildren(current).length > 0)
+        return null;
     return coordinator.status === "stopped" && !current.workers.some(worker => worker.workerId !== coordinator.workerId && active(worker)) ? coordinator : null;
 }
+/** Recovery leaves a waiting coordinator stopped, and with jobs=1 starts only a child whose dependencies are delivered. */
+export function recoverySkips(state, worker) {
+    if (state.rootTaskId === null)
+        return false;
+    const pending = pendingChildren(state);
+    if (pending.length === 0)
+        return false;
+    if (worker.workerId === state.coordinatorId)
+        return yielded(worker);
+    const node = pending.find(task => task.taskId === worker.taskId);
+    return state.jobs === 1 && (node === undefined ||
+        node.dependencies.some(id => !state.tasks.some(task => task.taskId === id && ["delivered", "complete"].includes(task.status))));
+}
+/** Child status handed to a woken coordinator, which may have lost its conversation. */
+export function coordinatorWakeNote(state, coordinator) {
+    const children = state.tasks.filter(task => task.taskId !== state.rootTaskId)
+        .map(task => `${task.taskId} ${task.status}${task.sourceCommit === null ? "" : " " + task.sourceCommit}`);
+    return (coordinator.nativeSessionId === null ? "Fresh native session after wait; the earlier conversation is unavailable. " : "") +
+        `Children: ${children.join("; ")}. Review deliveries, then plan follow-up workers and wait again, or request finalization.`;
+}
 /** Retain the structured child failure instead of hiding it behind recovery text. */
 export function runStepError(result, fallback) {
     const details = Array.isArray(result.errors) ? result.errors.filter(plain)
@@ -200,11 +244,11 @@ export async function superviseNativeRun(root, runId) {
                     "Requests require requestId (unique alphanumeric or hyphen, max 64), workerId, generation and current contractHash.",
                     "Plan fields: action=plan,title,intent,criteria,surface (the EVIDENCE-SURFACE-001 audit object, same shape as task create --surface-file). Worker fields: action=worker,title,intent,criteria,dependencies (known worker task IDs; omit all acceptance baselines until dependencies are delivered),covers (parent included surface IDs this worker delivers; every included surface needs one worker).",
                     "Only the coordinator may change execution policy: submit action=policy, configFile (relative proposed JSON), expectedPolicyHash, approvals (each changed capabilityId command:<id>/runner:<id>/setup:<index>, classification=non-dangerous, reason assessing the entire fixed definition including setup/build). Commit source changes and wait until every writer is clean before requesting policy synchronization. Never use init/update/trust grant to create permanent execution authorization. Explicit native or organization denial must not be bypassed.",
-                    "Worker task baselines are frozen after dependency commits enter its checkout. Handoff fields: action=handoff,sourceFiles (explicit existing source paths when unchanged). Question fields: action=question,prompt. Coordinator finalize fields: action=finalize.",
+                    "Worker task baselines are frozen after dependency commits enter its checkout. Handoff fields: action=handoff,sourceFiles (explicit existing source paths when unchanged). Question fields: action=question,prompt. Coordinator wait fields: action=wait, sent once every worker is planned instead of polling run status; the supervisor stops the coordinator and starts it again, in a fresh session with a child-status diagnostic, after every child is delivered, complete or blocked. Coordinator finalize fields: action=finalize.",
                     "The supervisor, after stopping writers, runs final verification, two fresh reviews and finish. A native completed goal is never final proof."], diagnostic };
             const path = join(worker.worktree, ".agent-ops", "tasks", "run-instructions.json");
             await writePrivateFile(path, JSON.stringify(content, null, 2), worker.worktree);
-            return "Read .agent-ops/tasks/run-instructions.json and carry its immutable original goal through the evidence loop. Submit a plan if rootTaskId is null; otherwise implement and repair the assigned task. A child requests handoff after local green; the coordinator waits for all child deliveries, then requests finalization. Never substitute native goal completion for agent-ops evidence.";
+            return "Read .agent-ops/tasks/run-instructions.json and carry its immutable original goal through the evidence loop. Submit a plan if rootTaskId is null; otherwise implement and repair the assigned task. A child requests handoff after local green; the coordinator submits action=wait after planning its children, then requests finalization once all have delivered. Never substitute native goal completion for agent-ops evidence.";
         }
         async function start(worker, diagnostic, resumeAt) {
             if (await discoverPendingPolicyTransition(repository, runId) !== null)
@@ -243,7 +287,7 @@ export async function superviseNativeRun(root, runId) {
         async function schedule() {
             const coordinator = await prepareSerialSchedule(repository, supervisor, runId);
             if (coordinator !== null) {
-                await start(coordinator);
+                await start(coordinator, coordinatorWakeNote((await repository.read(runId)), coordinator));
                 return;
             }
             const current = (await repository.read(runId));
@@ -682,18 +726,13 @@ export async function superviseNativeRun(root, runId) {
                 await synchronizePolicy();
             state = (await repository.read(runId));
             for (const worker of state.workers.filter(w => active(w) || w.status === "stopped")) {
-                if (state.jobs === 1 && state.rootTaskId !== null) {
-                    const pending = state.tasks.filter(task => task.taskId !== state.rootTaskId && !["delivered", "complete", "blocked"].includes(task.status));
-                    const node = pending.find(task => task.taskId === worker.taskId);
-                    if (pending.length > 0 && (worker.workerId === state.coordinatorId || node === undefined ||
-                        node.dependencies.some(id => !state.tasks.some(task => task.taskId === id && ["delivered", "complete"].includes(task.status)))))
-                        continue;
-                }
+                if (recoverySkips(state, worker))
+                    continue;
                 if (worker.workerId !== state.coordinatorId && (worker.worktree === null ||
                     !(await deps.tasks(worker.worktree).list()).some(r => r.task.id === worker.taskId)))
                     continue;
                 try {
-                    await start(worker, undefined, manualResumeAt);
+                    await start(worker, worker.workerId === state.coordinatorId && yielded(worker) ? coordinatorWakeNote(state, worker) : undefined, manualResumeAt);
                     if (state.jobs === 1)
                         break;
                 }
@@ -927,6 +966,12 @@ export async function superviseNativeRun(root, runId) {
                                     { questionId: request.requestId, prompt: request.prompt, askedAt: new Date().toISOString(), answeredAt: null, answerDigest: null }] }));
                             response = { requestId: request.requestId, code: "RUN_AWAITING_INPUT" };
                         }
+                        else if (request.action === "wait") {
+                            if ((await collectChangeSurface(gitRunner(worker.worktree))).paths.length > 0)
+                                throw new AgentOpsError("RUN_WAIT_DIRTY", "Commit coordinator changes before waiting; a stopped checkout must be clean to restart.");
+                            await waitForChildren(repository, supervisor, runId, worker.workerId, worker.generation);
+                            response = { requestId: request.requestId, code: "RUN_COORDINATOR_WAITING" };
+                        }
                         else if (request.action === "finalize") {
                             if (worker.workerId !== current.coordinatorId || current.tasks.some(task => task.taskId !== current.rootTaskId && task.status !== "delivered"))
                                 throw new AgentOpsError("RUN_DELIVERIES_PENDING", "The coordinator must wait for every planned child delivery before final integration.");

package/dist/runtime/src/adapters/agy/config.js

@@ -54,7 +54,7 @@ export function buildAgyHookSettings(capabilities, runtimePath, platform = proce
         throw new AgentOpsError("AGY_HOOK_PATH_INVALID", "agy hook runtime path is invalid.");
     }
     const hooks = {};
-    if ((capabilities.includes("lifecycle-summary") || capabilities.includes("office-presence") || capabilities.includes("task-debug")) || capabilities.includes("project-loop")) {
+    if ((capabilities.includes("lifecycle-summary") || capabilities.includes("office-presence")) || capabilities.includes("project-loop")) {
         hooks.PreInvocation = [handler(runtimePath, "SessionStart", platform)];
     }
     if ((capabilities.includes("command-policy") || capabilities.includes("office-presence")) || capabilities.includes("project-loop")) {
@@ -62,8 +62,7 @@ export function buildAgyHookSettings(capabilities, runtimePath, platform = proce
     }
     if (capabilities.includes("office-presence") ||
         capabilities.includes("optional-stop-verify") ||
-        capabilities.includes("completion-gate") ||
-        capabilities.includes("task-debug")) {
+        capabilities.includes("completion-gate")) {
         hooks.Stop = [handler(runtimePath, "Stop", platform, capabilities.includes("completion-gate"))];
     }
     return { hooks };

package/dist/runtime/src/adapters/claude/config.js

@@ -115,7 +115,7 @@ export function buildClaudeHookSettings(capabilities, runtimePath, platform = pr
         }
         // The loop has its own prompt hook. Outside it, a prompt is both the
         // turn's start for Office and content for command policy.
-        if (capabilities.includes("command-policy") || capabilities.includes("office-presence") || capabilities.includes("task-debug")) {
+        if (capabilities.includes("command-policy") || capabilities.includes("office-presence")) {
             hooks.UserPromptSubmit = [matcherGroup("UserPromptSubmit", runtimePath)];
             if (capabilities.includes("command-policy") || capabilities.includes("office-presence"))
                 hooks.PreToolUse = [matcherGroup("PreToolUse", runtimePath)];
@@ -126,7 +126,7 @@ export function buildClaudeHookSettings(capabilities, runtimePath, platform = pr
     if (capabilities.includes("completion-gate")) {
         hooks.Stop = [matcherGroup("Stop", runtimePath, true)];
     }
-    else if (capabilities.includes("task-debug") || capabilities.includes("optional-stop-verify") || capabilities.includes("office-presence")) {
+    else if (capabilities.includes("optional-stop-verify") || capabilities.includes("office-presence")) {
         hooks.Stop = [matcherGroup("Stop", runtimePath)];
     }
     // Stop only ends a turn. SessionEnd is the one signal that the conversation

package/dist/runtime/src/adapters/codex/config.js

@@ -84,18 +84,15 @@ export function buildCodexHookConfig(capabilities, runtimePath) {
         }
         // The loop has its own prompt hook. Outside it, a prompt is both the
         // turn's start for Office and content for command policy.
-        if (capabilities.includes("command-policy") || capabilities.includes("office-presence") || capabilities.includes("task-debug")) {
+        if (capabilities.includes("command-policy") || capabilities.includes("office-presence")) {
             hooks.UserPromptSubmit = [matcherGroup("UserPromptSubmit", runtimePath)];
             if (capabilities.includes("command-policy") || capabilities.includes("office-presence"))
                 hooks.PreToolUse = [matcherGroup("PreToolUse", runtimePath)];
         }
     }
-    if (capabilities.includes("task-debug") || capabilities.includes("optional-stop-verify") || capabilities.includes("office-presence")) {
+    if (capabilities.includes("optional-stop-verify") || capabilities.includes("office-presence")) {
         hooks.Stop = [matcherGroup("Stop", runtimePath)];
     }
-    if (capabilities.includes("task-debug")) {
-        hooks.Interrupt = [{ hooks: [{ ...commandHook("Interrupt", runtimePath), timeout: 3 }] }];
-    }
     if (capabilities.includes("office-presence") && hooks.PreToolUse !== undefined) {
         hooks.PreToolUse = hooks.PreToolUse.map(group => ({ ...group, matcher: "^(Bash|apply_patch)$" }));
     }

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

@@ -260,9 +260,6 @@ export class CompletionGateService {
         }
     }
     async grantPermit(sessionId) {
-        const attached = await this.#options.taskService.status({ sessionId }).catch(() => null);
-        if (attached?.task.debug !== undefined && attached.status === "active")
-            throw new AgentOpsError("TASK_DEBUG_CHECKPOINT_REQUIRED", "Active debug issues require a runtime stop checkpoint; allow-stop does not grant budget or success.");
         const fingerprint = await this.#fingerprint();
         const granted = await this.#store.mutate(sessionId, (state) => {
             if (state === null) {
@@ -488,18 +485,6 @@ export class CompletionGateService {
             }
             return last;
         }
-        const debugTask = await this.#options.taskService.status({ sessionId }).catch(() => null);
-        if (debugTask?.task.debug !== undefined) {
-            if (debugTask.status === "active") {
-                await this.#options.taskService.debugService().prepareStop(debugTask.task.id, sessionId);
-                const valid = await this.#options.taskService.debugService().validCheckpoint(debugTask.task.id, sessionId, fingerprint);
-                return valid ? gateResult("continue", "UNKNOWN", "COMPLETION_GATE_TASK_DEBUG_STOPPED", "Original issue remains active with a runtime-bound non-success checkpoint.") :
-                    gateResult("block", "FAIL", "COMPLETION_GATE_TASK_DEBUG_ACTIVE", "Continue the investigation/evidence loop or record a current runtime stop checkpoint, even when Git has no net diff.");
-            }
-            const failure = await this.#validateTask(sessionId);
-            if (failure !== null)
-                return failure;
-        }
         if (changed) {
             const failure = await this.#validateTask(sessionId);
             if (failure !== null)

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

@@ -342,7 +342,7 @@ function autoRunInstruction(descriptor, context) {
         "`RUN_REPO_UNTRUSTED` means stop and ask the user; never work",
         "around trust. New runs have no total time cap; legacy finite runs upgrade",
         "only on manual resume, preserving accounting and independent blockers.",
-        "Command/review timeouts, provider limits and DEBUG budgets remain effective.",
+        "Command/review timeouts and provider limits remain effective.",
         "If the run ends without completing (blocked, stopped, failing review),",
         "report the `agent-ops run status",
         "<id>` state and code, the last `agent-ops run logs <id>` events, and the",
@@ -364,8 +364,8 @@ export function managedRules(descriptor, context) {
             : [`Toolkit version: ${context.toolkitVersion}`]),
         ""
     ];
-    if (context.capabilities.includes("task-debug"))
-        lines.push("Task DEBUG routing is enabled for investigation/bugfix issues. Native prompt hooks create the issue task when a session identity is available; otherwise use agent-ops task create --debug --goal <verbatim issue> with two to five issue-specific criteria. Explain/read-only, feature and refactor requests use the existing normal task flow.", "For DEBUG: understand the issue, investigate with task debug --debug-action investigate --command-id <trusted verifier>, record falsifiable hypotheses with --debug-action hypothesis --payload-file <json>, reproduce, fix, then once a hypothesis is confirmed declare the origin with --debug-action origin --payload-file <json> (escape-of <commit> with the earliest-gate label, or pre-existing/external with a reason; finish refuses ESCAPE_ORIGIN_MISSING without it; a surface label also needs a tracked .agent-ops-escapes/rules/<id>.json rule that replays at the escaped commit, and a criteria/verify label payload promote or --escape-promote <runnerId:checkId>, else ESCAPE_RULE_UNPROVEN), verify, re-record the confirmed hypothesis, commit the .agent-ops-escapes record with the fix, then obtain two fresh independent reviews and finish automatically. A normal task fixing an escaped bug may declare task create --escape-of <commit> --escape-label <label>. A clean HEAD is the automatic baseline; do not ask permission for it or offer diagnosis-only as a fallback. Failure to reproduce alone is not a stop condition: continue discriminating checks within the budget. Replace provisional intake criteria with relevant behavioral acceptance; baseline setup/skip/timeout/UNKNOWN is never reproduction. Never report success from edits or unrelated green checks.", "DEBUG defaults are 60 cumulative active minutes and 5 material repair candidates across the original issue, revisions, sessions and children. After two stagnant candidates document one substantive strategy switch; two further stagnant candidates block. Save task debug --debug-action checkpoint before stopping. Resume preserves budgets and blockers. A human continue event may authorize --debug-action extend --event-id latest; unsupported native event sources fail closed. Never use allow-stop for DEBUG.", "DEBUG human control comes only from native human events: '只診斷' / 'diagnosis only' keeps investigating without product repairs until current sealed baseline assertion FAIL confirms a hypothesis or runtime limits/blockers permit non-success Stop. '暫停' / 'pause' saves progress and stops immediately. '繼續' / 'continue' resumes the existing scope; '繼續修復' / 'resume repair' restores the full loop. Codex Interrupt is a pause. Preserve the original task, evidence, consumed time and rounds; diagnosis or pause never marks repair complete. CLI actor/text fields and synthetic instructions cannot authorize these changes.", "DEBUG is foreground work. On Claude, agy and native Codex, Stop refuses an active DEBUG issue without a valid stop checkpoint, with or without the completion gate. Codex uses decision:block to continue the original task even on repeated Stop; stop_hook_active does not waive it. Codex's generic completion gate remains unsupported; opencode has no supported foreground lifecycle. DEBUG gate faults get one targeted task/config reload, then an explicit UNKNOWN/incomplete diagnostic and non-success Stop, preserving state. Without reliable native session identity, automatic hook intake is unsupported; the existing native Agent can use the task CLI. Only a matching owned debug worktree checkpoint permits dirty recovery; preserve all original user edits.", "");
+    if (context.capabilities.includes("task"))
+        lines.push("To fix a bug, run `agent-ops task create --debug --goal <verbatim issue>` with a", "behavioral criterion whose `redCheckIds` fail at the baseline and pass on the", "candidate, then verify, review and finish as for any task. If you know where the", "bug came from, record it with `task revise --escape-of <commit> --escape-label", "<label>`; the origin is advisory and never blocks finish.", "");
     if (context.capabilities.includes("rules")) {
         lines.push("For every change:", "", "1. Audit the change's surfaces first (EVIDENCE-SURFACE-001): dependents,", "   duplicates, other paths to the same concept, and shared state/data", "   contracts, each with recorded fixed-string queries or n/a: reason; pass", "   them with `task create --surface-file <json>`. An exclusion says why", "   the surface is unaffected; \"out of scope\" is not a reason. A derived", "   discovery query whose hits are all incidental may be dismissed once with", "   a reason in `dismissed` instead of excluding each file. Then define", "   two to five mechanically verifiable acceptance criteria.", "2. Inspect the smallest relevant scope within the audited surfaces and", "   preserve unrelated changes.", "3. Apply the smallest safe change.", "4. Run evidence-producing verification for every criterion.", "5. Obtain complete independent review before claiming completion, via", "   `agent-ops review --task <task-id> --yes` (or the CLI's equivalent invocation).", "   Never call a", "   review-target CLI (agy, codex, claude) directly — direct calls skip", "   the enforced read-only sandbox flags and can hang or fail on command", "   permission prompts.", "   Start this command through the trusted outer host runner as its first", "   and only invocation. On Codex, the outer tool request must use", "   `sandbox_permissions: \"require_escalated\"` so network and loopback", "   are available; in that same request, unset", "   `CODEX_SANDBOX_NETWORK_DISABLED` and set `AGENT_OPS_HOST` when three", "   targets are configured. The Codex shell form is", "   `env -u CODEX_SANDBOX_NETWORK_DISABLED AGENT_OPS_HOST=<current-host> agent-ops review --task <task-id> --yes`.", "   Keep it a plain command line: to keep the output add `--output <file>`", "   (the JSON envelope is written there and one line is printed) instead of", "   a shell redirect, which the host can only allow by matching the whole", "   command string, task id included.", "   Do not run it once in the restricted sandbox and retry; changing the", "   variable inside that sandbox is not elevation.", "   Review runs exactly two fresh sessions: with three configured targets,", "   set `AGENT_OPS_HOST` to the current CLI id so it is excluded; with two", "   targets both run in configured order; with one target it runs twice.", "   The first session is necessary; a PASS then requires an adversarial", "   re-check carrying the first report. A first FAIL or NOT_RUN stops.", "", "Treat `.agent-ops/config.json` as verifier authority. Discovery output is", "only a proposal until a user confirms it. Repository commands require an", "exact matching trust record. Confirmed project init/update grants it", "automatically when verification commands are configured.", "");
     }

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

@@ -1,5 +1,4 @@
 import { lstat, readFile } from "node:fs/promises";
-import { DEBUG_DEFAULTS } from "../task/debug-state.js";
 import { CONFIG_SCHEMA_VERSION, MANIFEST_SCHEMA_VERSION } from "../contracts.js";
 import { discoverProject } from "../discovery/index.js";
 import { sha256 } from "../fs/hash.js";
@@ -90,6 +89,8 @@ function buildConfig(profiles, existing, reviewTargets = [], detectedCommands =
         existing.verification.commands.length > 0
         ? existing.verification
         : { commands: [...detectedCommands] };
+    // Pre-0.11 DEBUG budget settings are dropped on rewrite.
+    const existingFeatures = existing === undefined ? undefined : (({ debug: _legacyDebug, ...rest }) => rest)(existing.features);
     const effectiveWorktree = worktree !== undefined
         ? (worktree === null ? undefined : structuredClone(worktree))
         : (existing?.worktree === undefined ? undefined : structuredClone(existing.worktree));
@@ -98,8 +99,7 @@ function buildConfig(profiles, existing, reviewTargets = [], detectedCommands =
         profiles: [...profiles],
         verification,
         features: {
-            debug: existing?.features.debug ?? { ...DEBUG_DEFAULTS },
-            ...(existing?.features ?? {
+            ...(existingFeatures ?? {
                 stopVerification: { enabled: false },
                 completionGate: { enabled: completionGateEnabled }
             }),

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

@@ -34,8 +34,6 @@ export function resolveProfiles(inputProfiles) {
 }
 export function resolveCapabilities(config) {
     const resolved = resolveProfiles(config.profiles);
-    if (config.features.debug?.enabled === true)
-        resolved.capabilities.push("task-debug");
     if (config.features.office?.enabled === true)
         resolved.capabilities.push("office-presence");
     if (config.features.stopVerification.enabled) {

package/dist/runtime/src/office/snapshot.js

@@ -1,6 +1,9 @@
 import { activeWallTimeMs } from "../run/scheduler.js";
 const COMPLETED_RETENTION_MS = 2 * 60 * 60 * 1000;
 const LIVE = new Set(["assigned", "starting", "running", "idle", "handing-off", "fenced", "delivered", "blocked"]);
+// Every other run status is idle: nothing moves a paused, stopping, blocked or
+// budget-limited run on, so it leaves the Office like a finished one.
+const RUNNING = new Set(["active", "awaiting-input"]);
 const PHASES = new Set(["planning", "implementing", "verifying", "reviewing", "integrating", "unknown"]);
 function phaseOf(value) {
     return value !== undefined && PHASES.has(value) ? value : "unknown";
@@ -23,7 +26,7 @@ function quote(text) {
 export function buildOfficeSnapshot(input) {
     const byPath = new Map(input.worktrees.map(w => [w.path, w]));
     const claimed = new Set();
-    const runs = input.runs.filter(run => !["complete", "failed"].includes(run.status) || input.now - Date.parse(run.updatedAt) < COMPLETED_RETENTION_MS)
+    const runs = input.runs.filter(run => RUNNING.has(run.status) || input.now - Date.parse(run.updatedAt) < COMPLETED_RETENTION_MS)
         .map((run) => {
         const roots = new Set(run.workers.map(w => w.worktree).filter((p) => p !== null));
         const reviewers = input.reviews.filter(r => r.root !== null && roots.has(r.root)).slice(0, 2);

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

@@ -192,11 +192,8 @@ export async function resumeWorktree(deps, options) {
     const sessionId = assertSessionId(options.sessionId);
     const mainRoot = await mainCheckout(deps, options.cwd);
     const previous = await requireRecord(mainRoot, name);
-    // A base gives the service repository context, which debug resume needs.
     const tasks = deps.tasks(previous.path, previous.base);
     const attached = await tasks.status({ sessionId: previous.sessionId }).catch(() => null);
-    if (attached?.task.debug !== undefined)
-        await tasks.debugService().resume(attached.task.id, sessionId);
     if (attached !== null)
         await tasks.attach(sessionId, attached.task.id);
     const record = { ...previous, sessionId };