@kylecheng3146/agent-ops 0.8.0 → 0.8.3

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

@@ -14,6 +14,7 @@ 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";
@@ -21,7 +22,6 @@ 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 { evaluateGuardrail } from "../../../runtime/src/guardrails/evaluate.js";
-import { resolveCapabilities } from "../../../runtime/src/install/profiles.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";
@@ -55,13 +55,19 @@ function parseInput(source) {
 }
 function withInjectedSession(harness, input) {
     const sessionId = process.env.AGENT_OPS_SESSION_ID;
-    return harness === "agy" &&
-        sessionId !== undefined &&
-        typeof input === "object" &&
-        input !== null &&
-        !Array.isArray(input)
-        ? { ...input, conversationId: sessionId }
-        : input;
+    const codexSession = sessionId ?? process.env.CODEX_THREAD_ID;
+    if ((harness !== "agy" && harness !== "codex") ||
+        typeof input !== "object" || input === null || Array.isArray(input))
+        return input;
+    const fields = input;
+    if (harness === "agy") {
+        return (typeof fields.conversationId === "string" && fields.conversationId.length > 0) || sessionId === undefined
+            ? input
+            : { ...fields, conversationId: sessionId };
+    }
+    return (typeof fields.session_id === "string" && fields.session_id.length > 0) || codexSession === undefined
+        ? input
+        : { ...fields, session_id: codexSession };
 }
 function writeHookOutput(io, output) {
     if (output.stdout.length > 0) {
@@ -227,7 +233,7 @@ function completionGateFor(root, config, gitRunner, harness) {
         config,
         gitRunner,
         ...(harness === undefined ? {} : { harness }),
-        taskService: new TaskService(new FileTaskStore(join(root, ".agent-ops", "tasks", "state.json"), root)),
+        taskService: new TaskService(new FileTaskStore(join(root, ".agent-ops", "tasks", "state.json"), root), { completion: { root, gitRunner, loadConfig: async () => config } }),
         evidenceStore: new FileEvidenceStore(root, root),
         forRoot: async (worktree) => {
             const outcome = await loadProjectHookConfig(worktree);
@@ -248,7 +254,7 @@ function completionGateFor(root, config, gitRunner, harness) {
  */
 async function closeOfficeSession(io, dependencies) {
     try {
-        if (process.env.AGENT_OPS_DISABLE === "1" || dependencies.office === undefined)
+        if (process.env.AGENT_OPS_DISABLE === "1")
             return 0;
         const input = parseInput(await readStdin(io.stdin));
         if (typeof input !== "object" || input === null || Array.isArray(input))
@@ -256,12 +262,15 @@ async function closeOfficeSession(io, dependencies) {
         const fields = input;
         const root = dependencies.root ?? (typeof fields.cwd === "string" ? fields.cwd : process.cwd());
         const outcome = await hookConfigOutcome(root, dependencies.loadConfig);
-        if (outcome.kind === "invalid" || outcome.config.features.office?.enabled !== true)
+        if (outcome.kind === "invalid")
             return 0;
-        await dependencies.office({
-            root, harness: "claude", event: "SessionEnd", input, validated: true,
-            ...(typeof fields.session_id === "string" ? { sessionId: fields.session_id } : {})
-        });
+        if (dependencies.office !== undefined && outcome.config.features.office?.enabled === true)
+            await dependencies.office({
+                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.
@@ -292,13 +301,19 @@ async function promptSubmitted(harness, io, dependencies) {
                 ...(typeof fields.session_id === "string" ? { sessionId: fields.session_id } : {})
             }).catch(() => undefined);
         }
-        if (config.profiles.length === 0 || !resolveCapabilities(config).capabilities.includes("command-policy"))
+        if (config.profiles.length === 0)
             return 0;
         // ponytail: the loop's 64 KiB prompt bound; a larger prompt goes unchecked.
         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")
+        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");
+            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.";
         if (harness === "claude") {
@@ -314,14 +329,28 @@ 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." }));
+        }
+        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);
-    // Both hosts whose Stop hook can actually refuse a stop. codex never fires
-    // Stop under `codex exec` and rejects `permissionDecision:ask`, so its
-    // escape hatch could not be user-approved; opencode can only deny a tool
-    // call, never a stop.
+    // The generic completion gate requires an approval escape hatch. Codex
+    // only enforces DEBUG through runtime checkpoints and native human control.
     const completionGateInstalled = (harness === "agy" || harness === "claude") &&
         event === "Stop" &&
         argv.includes("--completion-gate");
@@ -370,8 +399,19 @@ export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
                 root = inputRoot;
             }
         }
-        const configOutcome = await hookConfigOutcome(root, dependencies.loadConfig);
+        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",
@@ -394,6 +434,15 @@ 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",
@@ -407,8 +456,10 @@ export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
             ? await repositoryTrust(root, config, cliVersion)
             : 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) {
-            const normalized = normalizeHookInput(harnessId, parsedInput);
             if (normalized !== null) {
                 const phase = officePhaseHint(normalized);
                 void dependencies.office({
@@ -500,21 +551,43 @@ export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
                 await recordSessionOrigin(dependencies.worktree, { cwd: root, sessionId }).catch(() => undefined);
             }
         }
-        const output = await runHookCommand({
-            harness: harness,
-            event: hookEvent,
-            stdin: rawInput,
-            config,
-            trusted,
-            ...(worktreeGuard === undefined ? {} : { worktreeGuard }),
-            ...(worktreeEnter === undefined ? {} : { worktreeEnter }),
-            ...(dependencies.advisory === undefined
-                ? {}
-                : { advisory: dependencies.advisory }),
-            ...(stopVerification === undefined ? {} : { stopVerification }),
-            ...(completionGate === undefined ? {} : { completionGate })
-        });
+        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 })
+            });
         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/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("project-loop")) {
+    if ((capabilities.includes("lifecycle-summary") || capabilities.includes("office-presence") || capabilities.includes("task-debug")) || capabilities.includes("project-loop")) {
         hooks.PreInvocation = [handler(runtimePath, "SessionStart", platform)];
     }
     if ((capabilities.includes("command-policy") || capabilities.includes("office-presence")) || capabilities.includes("project-loop")) {
@@ -62,7 +62,8 @@ export function buildAgyHookSettings(capabilities, runtimePath, platform = proce
     }
     if (capabilities.includes("office-presence") ||
         capabilities.includes("optional-stop-verify") ||
-        capabilities.includes("completion-gate")) {
+        capabilities.includes("completion-gate") ||
+        capabilities.includes("task-debug")) {
         hooks.Stop = [handler(runtimePath, "Stop", platform, capabilities.includes("completion-gate"))];
     }
     return { hooks };

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

@@ -115,9 +115,10 @@ 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")) {
+        if (capabilities.includes("command-policy") || capabilities.includes("office-presence") || capabilities.includes("task-debug")) {
             hooks.UserPromptSubmit = [matcherGroup("UserPromptSubmit", runtimePath)];
-            hooks.PreToolUse = [matcherGroup("PreToolUse", runtimePath)];
+            if (capabilities.includes("command-policy") || capabilities.includes("office-presence"))
+                hooks.PreToolUse = [matcherGroup("PreToolUse", runtimePath)];
         }
     }
     // The gate supersedes report-only Stop verification: one managed Stop
@@ -125,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("optional-stop-verify") || capabilities.includes("office-presence")) {
+    else if (capabilities.includes("task-debug") || 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,14 +84,18 @@ 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")) {
+        if (capabilities.includes("command-policy") || capabilities.includes("office-presence") || capabilities.includes("task-debug")) {
             hooks.UserPromptSubmit = [matcherGroup("UserPromptSubmit", runtimePath)];
-            hooks.PreToolUse = [matcherGroup("PreToolUse", runtimePath)];
+            if (capabilities.includes("command-policy") || capabilities.includes("office-presence"))
+                hooks.PreToolUse = [matcherGroup("PreToolUse", runtimePath)];
         }
     }
-    if (capabilities.includes("optional-stop-verify") || capabilities.includes("office-presence")) {
+    if (capabilities.includes("task-debug") || 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 }] }];
+    }
     return {
         description: "agent-ops lifecycle hooks.",
         hooks

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

@@ -8,7 +8,8 @@ export const CODEX_SUPPORTED_EVENTS = [
     "PostCompact",
     "SubagentStart",
     "SubagentStop",
-    "Stop"
+    "Stop",
+    "Interrupt"
 ];
 export function codexMatcherSupport(event) {
     return event === "PreToolUse" ? "tool-name" : "unsupported";

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

@@ -15,17 +15,35 @@ export function normalizeCodexHookInput(input) {
         return normalizeHookEvent(input);
     }
     const projectRoot = input.cwd;
+    const sessionId = typeof input.session_id === "string" && input.session_id.length > 0
+        ? input.session_id
+        : undefined;
     if (input.hook_event_name === "SessionStart") {
-        return normalizeHookEvent({
+        const start = normalizeHookEvent({
             event: "session-start",
             projectRoot
         });
+        return {
+            event: "session-start",
+            projectRoot: start.projectRoot,
+            ...(sessionId === undefined ? {} : { sessionId })
+        };
     }
     if (input.hook_event_name === "Stop") {
-        return normalizeHookEvent({
+        const stop = normalizeHookEvent({
             event: "stop",
             projectRoot
         });
+        return {
+            event: "stop",
+            projectRoot: stop.projectRoot,
+            ...(sessionId === undefined ? {} : { sessionId }),
+            terminationReason: typeof input.termination_reason === "string"
+                ? input.termination_reason
+                : "model_stop",
+            // stop_hook_active means a prior continuation, not a non-idle Stop.
+            fullyIdle: true
+        };
     }
     if (input.hook_event_name === "PreToolUse" &&
         input.tool_name === "Bash") {

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

@@ -1,6 +1,9 @@
 export const CODEX_NON_ZERO_EXIT_BEHAVIOR = "UNKNOWN";
 export const CODEX_PRE_TOOL_BLOCKING = "UNKNOWN";
 export function codexHookOutput(event, result) {
+    if (event === "Stop" && result.action === "block") {
+        return { exitCode: 0, stdout: JSON.stringify({ decision: "block", reason: `agent-ops: ${result.code}. ${result.remedy ?? "Continue the unfinished task."}` }) };
+    }
     if (event === "Stop" && result.evidence !== undefined) {
         return {
             exitCode: 0,
@@ -28,7 +31,7 @@ export function codexHookOutput(event, result) {
             continue: result.action !== "block",
             ...(result.action === "block"
                 ? { stopReason: result.code }
-                : { systemMessage: `agent-ops: ${result.code}` })
+                : { systemMessage: `agent-ops: ${result.code}${result.remedy === undefined ? "" : ". " + result.remedy}` })
         })
     };
 }

package/dist/runtime/src/config/merge.js

@@ -114,7 +114,7 @@ export function mergeConfigLayers(inputLayers) {
     let worktree;
     for (const layer of layers) {
         schemaVersion = effective(layer.config.schemaVersion, layer);
-        features = effective(layer.config.features, layer);
+        features = effective({ ...layer.config.features, ...(layer.config.features.debug === undefined && features?.value.debug !== undefined ? { debug: features.value.debug } : {}) }, layer);
         // Whole-block override: a workflow choice, not a guardrail, so a project
         // may turn a user-level `auto` off.
         if (layer.config.worktree !== undefined) {

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

@@ -260,6 +260,9 @@ 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) {
@@ -485,6 +488,18 @@ 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

@@ -361,6 +361,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, verify, then obtain two fresh independent reviews and finish automatically. 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("rules")) {
         lines.push("For every change:", "", "1. Define two to five mechanically verifiable acceptance criteria.", "2. Inspect the smallest relevant scope 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,4 +1,5 @@
 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";
@@ -97,6 +98,7 @@ function buildConfig(profiles, existing, reviewTargets = [], detectedCommands =
         profiles: [...profiles],
         verification,
         features: {
+            debug: existing?.features.debug ?? { ...DEBUG_DEFAULTS },
             ...(existing?.features ?? {
                 stopVerification: { enabled: false },
                 completionGate: { enabled: completionGateEnabled }
@@ -439,9 +441,7 @@ export async function createInstallPlan(options) {
     const existing = await readExistingManifest(options.root);
     assertCompatibleManifest(existing?.manifest ?? null, options.scope, options.harness, options.allowHarnessChange === true);
     const config = await planConfig(options.root, resolved.profiles, existing?.manifest ?? null, options.existingConfig, options.reviewTargets ?? [], completionGateEnabled, options.worktree, options.officeEnabled);
-    resolved.capabilities = resolved.capabilities.filter(capability => capability !== "office-presence");
-    if (config.config.features.office?.enabled === true)
-        resolved.capabilities.push("office-presence");
+    resolved.capabilities = resolveCapabilities(config.config).capabilities;
     const existingOpencodePluginPath = existing?.manifest.artifacts.find(({ id }) => id === "opencode-plugin")?.path;
     const explicitHookTargets = new Map();
     for (const target of options.hookTargets ?? []) {

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

@@ -34,6 +34,8 @@ 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/art.js

@@ -293,7 +293,8 @@ export function avatarColors(identity, role) {
     let hash = 0;
     for (let i = 0; i < identity.length; i++)
         hash = (Math.imul(hash, 31) + identity.charCodeAt(i)) >>> 0;
-    const hair = hairs[hash % 3], skin = skins[Math.floor(hash / 3) % 3], shirt = clothes[role] ?? clothes.visitor;
+    // The viewer always wears the lightest skin; everyone else follows their identity.
+    const hair = hairs[hash % 3], skin = skins[role === "viewer" ? 0 : Math.floor(hash / 3) % 3], shirt = clothes[role] ?? clothes.visitor;
     return { O: "#292633", H: hair[0], I: hair[1], J: hair[2], S: skin[0], T: skin[1], U: skin[2],
         C: shirt[0], D: shirt[1], E: shirt[2], P: "#404958", Q: "#626e7f", B: "#2e3443", K: "#292633", R: "#e39a86" };
 }

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

@@ -116,10 +116,13 @@ export function officeLayout() {
         board: { x: 118, y: 42 },
         staff: {
             stations: { qa: rooms[2].slots[0], desk: rooms[3].slots[0], armchair: rooms[3].slots[1], integrator: rooms[4].slots[0] },
-            // Two sit on the sofa, in front of its back; two stand chatting at the cafe table.
-            rest: [seat(83, 212, "sit", 262, { x: 100, y: 268 }), seat(101, 212, "sit", 262, { x: 118, y: 268 }),
-                seat(88, 241, "right0", 291, { x: 106, y: 290 }), seat(148, 241, "left0", 291, { x: 166, y: 290 })]
+            // Where idle staff spend time: the sofa, both sides of the cafe table, then the cooler,
+            // vending machine, fridge and counter, seen from behind.
+            spots: [seat(83, 212, "sit", 262, { x: 100, y: 268 }), seat(101, 212, "sit", 262, { x: 118, y: 268 }),
+                seat(88, 241, "right0", 291, { x: 106, y: 290 }), seat(148, 241, "left0", 291, { x: 166, y: 290 }),
+                stand(137, 183, "up0"), stand(113, 181, "up0"), stand(87, 181, "up0"), stand(49, 181, "up0")]
         },
+        look: { board: stand(134, 64, "up0"), status: stand(414, 100, "up0") },
         hotspots: [
             { kind: "task", room: "planning", rects: [area("board", 118, 42)] },
             // The monitor sits at (30, 1) inside a cubicle, one pixel further in once outlined.