@kylecheng3146/agent-ops 0.7.3 → 0.8.3

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

@@ -35,7 +35,7 @@ export function sceneModel(snapshot) {
         return { passed: typeof p.passed === "number" ? p.passed : 0, total: typeof p.total === "number" ? p.total : 0,
             verify: p.verify === "PASS" || p.verify === "FAIL" ? p.verify : null, review: p.review === "PASS" || p.review === "FAIL" ? p.review : null };
     };
-    const short = (value, limit = 18) => value.length > limit ? value.slice(0, limit - 1) + "…" : value;
+    const short = (value, limit = 18) => value.length > limit ? value.slice(0, limit - 6) + "…" + value.slice(-5) : value;
     const optional = (value) => value !== null && typeof value === "object" ? value : {};
     const boardFor = (progress, status, taskId, pending) => ({
         passed: progress?.passed ?? 0, total: progress?.total ?? 0,
@@ -49,7 +49,7 @@ export function sceneModel(snapshot) {
         return typeof repo === "string" && repo.length > 0 ? repo : null;
     };
     const scoped = (repo, key) => repo === null ? key : "repo:" + repo + "|" + key;
-    const titled = (repo, title) => short(repo === null ? title : repo + " · " + title, 34);
+    const titled = (repo, title) => repo === null ? title : repo + " · " + title;
     const makeAreas = () => PHASES.map(phase => {
         const area = areas[phase];
         return { phase, x: area.x, y: area.y, width: area.width, height: area.height, prop: area.prop, label: labels[phase] };
@@ -70,7 +70,7 @@ export function sceneModel(snapshot) {
         { kind: "plant", x: 57, y: 34, key: key + ":plant-bottom" },
         { kind: "door", x: 65, y: 33, key: key + ":door" }
     ];
-    const makeRun = (run) => {
+    const makeRun = (run, index) => {
         const extra = optional(run);
         const completedAt = typeof extra.completedAt === "string" ? extra.completedAt : null;
         const questions = run.questions;
@@ -95,34 +95,43 @@ export function sceneModel(snapshot) {
             total += p?.total ?? 0;
             if (p?.verify === "FAIL")
                 verify = "FAIL";
-            else if (p?.verify === "PASS" && verify === null)
-                verify = "PASS";
             if (p?.review === "FAIL")
                 review = "FAIL";
-            else if (p?.review === "PASS" && review === null)
-                review = "PASS";
             actors.push({ key: key + ":" + agent.id, id: agent.id, kind: agent.role, x: point.x, y: point.y, alert: agent.role === "coordinator" && questions.length > 0,
                 label: short(agent.id), status: agent.status, phase, taskId: agent.taskId || "unassigned", progress: p,
                 narration: agent.narration, questionCount: agent.role === "coordinator" ? questions.length : 0, host: "unknown" });
             dialogue.push(`${run.title}: ${agent.id} ${agent.narration}.`);
         });
-        run.reviewers.forEach((reviewer, index) => {
-            const reviewerIndex = actors.filter(actor => actor.phase === "reviewing").length;
-            const reviewerCount = run.agents.filter(agent => agent.phase === "reviewing").length + run.reviewers.length;
-            const point = position("reviewing", reviewerIndex, reviewerCount);
-            actors.push({ key: key + ":review:" + reviewer.slot, id: "reviewer " + reviewer.slot, kind: "reviewer", x: point.x, y: point.y, alert: false,
-                label: "reviewer " + reviewer.slot, status: "reviewing", phase: "reviewing", taskId: reviewer.taskId ?? "unassigned",
-                progress: null, narration: "reviewing", questionCount: 0, host: "unknown" });
+        if (verify === null && run.agents.length && run.agents.every(agent => agent.progress?.verify === "PASS"))
+            verify = "PASS";
+        if (review === null && run.agents.length && run.agents.every(agent => agent.progress?.review === "PASS"))
+            review = "PASS";
+        const rootProgress = Object.prototype.hasOwnProperty.call(extra, "progress") ? progressOf(extra.progress) : { passed, total, verify, review };
+        const criteria = (Array.isArray(extra.criteria) ? extra.criteria : []).map(value => {
+            const item = optional(value);
+            return { id: typeof item.id === "string" ? item.id : "unknown", description: typeof item.description === "string" ? item.description : "",
+                status: item.status === "PASS" || item.status === "FAIL" || item.status === "UNKNOWN" ? item.status : null,
+                finishedAt: typeof item.finishedAt === "string" ? item.finishedAt : null,
+                failureClass: typeof item.failureClass === "string" ? item.failureClass : null,
+                exitCode: typeof item.exitCode === "number" ? item.exitCode : null, output: typeof item.output === "string" ? item.output : null };
         });
-        const rootProgress = { passed, total, verify, review };
-        const taskId = run.agents.find(agent => agent.role === "coordinator")?.taskId ?? "unassigned";
+        const taskId = typeof extra.taskId === "string" && extra.taskId.length > 0
+            ? extra.taskId : run.agents.find(agent => agent.role === "coordinator")?.taskId ?? "unassigned";
         if (questions.length > 0)
             dialogue.push(`${run.title}: waiting for your answer — ${questions[0].prompt}`);
-        return { key, sourceIndex: null, kind: "run", title: titled(repo, run.title), top: 0, props, actors, phaseAreas: makeAreas(), questions,
-            board: boardFor(rootProgress, run.status, taskId, questions.length), papers, books: { lit: passed, total },
+        return { key, sourceIndex: index, kind: "run", title: titled(repo, run.title), top: 0, props, actors, phaseAreas: makeAreas(), questions, criteria,
+            activities: activitiesOf(optional(run).activities),
+            board: boardFor(rootProgress, run.status, taskId, questions.length), papers, books: { lit: rootProgress?.passed ?? 0, total: rootProgress?.total ?? 0 },
             clock: run.budget.limitMs > 0 ? run.budget.remainingMs / run.budget.limitMs : 0, phase: run.phase, status: run.status,
             completedAt, repo, overview: { x: 0, y: 0, width: 0, height: 0 } };
     };
+    const activitiesOf = (value) => (Array.isArray(value) ? value : []).map(raw => {
+        const item = optional(raw);
+        return { kind: item.kind === "verify" || item.kind === "review" || item.kind === "finish" ? item.kind : "verify",
+            startedAt: typeof item.startedAt === "string" ? item.startedAt : "",
+            targets: Array.isArray(item.targets) ? item.targets.filter((t) => typeof t === "string").slice(0, 2) : [],
+            round: item.round === 1 || item.round === 2 ? item.round : null, target: typeof item.target === "string" ? item.target : null };
+    });
     const makeDesk = (desk, index) => {
         const extra = optional(desk);
         const phase = extra.phase === "planning" || extra.phase === "implementing" || extra.phase === "verifying" || extra.phase === "reviewing" || extra.phase === "integrating" ? extra.phase : "unknown";
@@ -135,6 +144,15 @@ export function sceneModel(snapshot) {
             return { questionId: typeof item.questionId === "string" ? item.questionId : "unknown", prompt: typeof item.prompt === "string" ? item.prompt : "" };
         });
         const completedAt = typeof extra.completedAt === "string" ? extra.completedAt : null;
+        // Inline checks, no named helper: the page embeds sceneModel via toString, so it cannot carry bundler helpers.
+        const criteria = (Array.isArray(extra.criteria) ? extra.criteria : []).map(value => {
+            const item = optional(value);
+            return { id: typeof item.id === "string" ? item.id : "unknown", description: typeof item.description === "string" ? item.description : "",
+                status: item.status === "PASS" || item.status === "FAIL" || item.status === "UNKNOWN" ? item.status : null,
+                finishedAt: typeof item.finishedAt === "string" ? item.finishedAt : null,
+                failureClass: typeof item.failureClass === "string" ? item.failureClass : null,
+                exitCode: typeof item.exitCode === "number" ? item.exitCode : null, output: typeof item.output === "string" ? item.output : null };
+        });
         const repo = repoOf(desk);
         const key = scoped(repo, "session:" + [desk.sessionId || "unknown", desk.branch || "unknown", desk.name || "session"].join(":"));
         const props = makeProps(key);
@@ -146,24 +164,11 @@ export function sceneModel(snapshot) {
             dialogue.push(`${desk.name}: waiting for your answer.`);
         dialogue.push(`${desk.name}: ${desk.narration}.`);
         return { key, sourceIndex: index, kind: "desk", title: titled(repo, desk.name), top: 0, props, actors: [actor], phaseAreas: makeAreas(),
-            board: boardFor(p, status, taskId, questions.length), questions, papers: { [key + ":implementing"]: Math.min(8, desk.diff.files) }, books: { lit: p?.passed ?? 0, total: p?.total ?? 0 },
+            board: boardFor(p, status, taskId, questions.length), questions, criteria, activities: activitiesOf(extra.activities), papers: { [key + ":implementing"]: Math.min(8, desk.diff.files) }, books: { lit: p?.passed ?? 0, total: p?.total ?? 0 },
             clock: 1, phase, status, completedAt, repo, overview: { x: 0, y: 0, width: 0, height: 0 } };
     };
-    snapshot.runs.forEach(run => floors.push(makeRun(run)));
+    snapshot.runs.forEach((run, index) => floors.push(makeRun(run, index)));
     snapshot.lobby.forEach((desk, index) => floors.push(makeDesk(desk, index)));
-    snapshot.reviews.forEach((review, index) => {
-        const repo = repoOf(review);
-        const key = scoped(repo, "review:" + review.slot + ":" + index);
-        const props = makeProps(key);
-        const point = position("reviewing", 0);
-        const actor = { key: key + ":actor", id: "reviewer " + review.slot, kind: "reviewer", x: point.x, y: point.y, alert: false, label: "reviewer " + review.slot,
-            status: "reviewing", phase: "reviewing", taskId: review.taskId ?? "unassigned", progress: null,
-            narration: "reviewing", questionCount: 0, host: "unknown" };
-        dialogue.push(`Review slot ${review.slot}: ${review.taskId ?? "unassigned"}.`);
-        floors.push({ key, sourceIndex: index, kind: "review", title: titled(repo, "Review slot " + review.slot), top: 0, props, actors: [actor], phaseAreas: makeAreas(), questions: [],
-            board: boardFor(null, "reviewing", review.taskId ?? "unassigned", 0), papers: {}, books: { lit: 0, total: 0 }, clock: 1,
-            phase: "reviewing", status: "reviewing", completedAt: null, repo, overview: { x: 0, y: 0, width: 0, height: 0 } });
-    });
     // Rooms of one repository sit together; the sort is stable inside each.
     floors.sort((a, b) => (a.repo ?? "").localeCompare(b.repo ?? ""));
     if (dialogue.length === 0)

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

@@ -99,7 +99,8 @@ export async function recordOfficeSession(options) {
             root: options.projectRoot,
             firstSeenAt: previous?.firstSeenAt ?? at,
             lastSeenAt: at,
-            status: options.event === "stop" || options.event === "end" ? "idle" : "active",
+            // A session that only started is waiting at its prompt; work begins with activity.
+            status: options.event === "activity" ? "active" : "idle",
             ...(options.agentId ?? previous?.agentId ? { agentId: options.agentId ?? previous?.agentId } : {}),
             ...(options.runId ?? previous?.runId ? { runId: options.runId ?? previous?.runId } : {}),
             ...(options.workerId ?? previous?.workerId ? { workerId: options.workerId ?? previous?.workerId } : {}),
@@ -116,6 +117,22 @@ export async function recordOfficeSession(options) {
         await writePrivateFile(path, JSON.stringify({ schemaVersion: 1, sessions: [...without, next].slice(-MAX_SESSIONS) }) + "\n", options.commonDir);
     });
 }
+/**
+ * A long command's later step (batch, advance) on the session that runs it,
+ * which hooks only see start. Unknown sessions stay unknown.
+ */
+export async function recordOfficeSessionPhase(commonDir, sessionId, phase, now = Date.now()) {
+    const path = officeSessionsPath(commonDir);
+    await withPrivateFileLock(path, commonDir, async () => {
+        const records = prune(await readRecords(commonDir), now);
+        if (!records.some(record => record.sessionId === sessionId))
+            return;
+        const at = new Date(now).toISOString();
+        const next = records.map(record => record.sessionId === sessionId
+            ? { ...record, status: "active", phase, lastSeenAt: at } : record);
+        await writePrivateFile(path, JSON.stringify({ schemaVersion: OFFICE_SESSION_SCHEMA_VERSION, sessions: next }) + "\n", commonDir);
+    });
+}
 /** Closes a session's room once `worktree finish` merged its work. Unknown sessions stay unknown. */
 export async function markOfficeSessionCompleted(commonDir, sessionId, now = Date.now()) {
     const path = officeSessionsPath(commonDir);

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

@@ -29,6 +29,13 @@ export function buildOfficeSnapshot(input) {
         const reviewers = input.reviews.filter(r => r.root !== null && roots.has(r.root)).slice(0, 2);
         reviewers.forEach(r => claimed.add(r));
         const usedMs = activeWallTimeMs(run.budget.activeIntervals, input.now);
+        const coordinator = run.workers.find(worker => worker.workerId === run.coordinatorId);
+        // rootTaskId is the persisted run authority. Only legacy runs without it
+        // fall back to the coordinator's task id.
+        const rootTaskId = run.rootTaskId ?? (coordinator?.taskId || null);
+        const rootTask = rootTaskId === null ? undefined : run.tasks.find(task => task.taskId === rootTaskId);
+        const rootTree = rootTaskId === null ? undefined : input.worktrees.find(tree => tree.taskId === rootTaskId &&
+            (tree.runId === run.runId || tree.path === coordinator?.worktree));
         const agents = run.workers.filter(w => w.workerId === run.coordinatorId || LIVE.has(w.status)).map((w) => {
             const tree = w.worktree === null ? undefined : byPath.get(w.worktree);
             const phase = w.phase ?? "unknown";
@@ -39,6 +46,11 @@ export function buildOfficeSnapshot(input) {
         });
         const questions = run.questions.filter(q => q.answeredAt === null).map(q => ({ questionId: q.questionId, prompt: q.prompt }));
         return { runId: run.runId, title: run.rootTaskId ?? run.runId,
+            ...(rootTaskId === null ? {} : { taskId: rootTaskId }),
+            // The root task is the only source of run-level proof. A
+            // missing proof stays null; worker progress must never become root proof.
+            ...(rootTaskId === null ? {} : { progress: rootTree?.progress ?? rootTask?.progress ?? null,
+                ...(rootTree?.criteria === undefined ? {} : { criteria: rootTree.criteria }) }),
             status: run.status, phase: run.phase ?? "unknown",
             budget: { limitMs: run.budget.limitMs, usedMs, remainingMs: Math.max(0, run.budget.limitMs - usedMs) },
             questions, agents, reviewers,
@@ -57,6 +69,7 @@ export function buildOfficeSnapshot(input) {
             runSessionIds.add(worker.nativeSessionId);
     });
     const lobby = [];
+    const deskPaths = new Map();
     const represented = new Set();
     for (const worktree of input.worktrees) {
         if (worktree.runId !== undefined)
@@ -78,9 +91,15 @@ export function buildOfficeSnapshot(input) {
             ...(worktree.status === undefined && session?.taskStatus === undefined && session?.status === undefined ? {} : { status: worktree.status ?? session?.taskStatus ?? session?.status }),
             ...(worktree.taskId === undefined && session?.taskId === undefined ? {} : { taskId: worktree.taskId ?? session?.taskId ?? null }),
             ...(worktree.progress === undefined && session?.progress === undefined ? {} : { progress: worktree.progress ?? session?.progress ?? null }),
+            ...(worktree.title === undefined && session?.title === undefined ? {} : { title: worktree.title ?? session?.title }),
+            ...(worktree.criteria === undefined && session?.criteria === undefined ? {} : { criteria: worktree.criteria ?? session?.criteria ?? [] }),
+            ...(worktree.review === undefined && session?.review === undefined ? {} : { review: worktree.review ?? session?.review ?? null }),
+            ...(worktree.base === undefined ? {} : { base: worktree.base }),
+            ...(worktree.ahead === undefined ? {} : { ahead: worktree.ahead }),
             ...(completedAt === null && session?.completedAt === undefined ? {} : { completedAt }),
             ...(worktree.host === undefined && session?.host === undefined ? {} : { host: worktree.host ?? session?.host }),
         });
+        deskPaths.set(lobby.length - 1, worktree.path);
         represented.add(worktree.sessionId);
     }
     for (const session of sessions) {
@@ -100,11 +119,16 @@ export function buildOfficeSnapshot(input) {
             status: session.taskStatus ?? session.status,
             ...(session.taskId === undefined ? {} : { taskId: session.taskId }),
             ...(session.progress === undefined ? {} : { progress: session.progress }),
+            ...(session.title === undefined ? {} : { title: session.title }),
+            ...(session.criteria === undefined ? {} : { criteria: session.criteria }),
+            ...(session.review === undefined ? {} : { review: session.review }),
             ...(completedAt === null ? {} : { completedAt }),
             ...(session.host === undefined ? {} : { host: session.host })
         });
     }
-    return { generatedAt: new Date(input.now).toISOString(), runs, lobby, reviews: input.reviews.filter(r => !claimed.has(r)) };
+    attachActivities(input, runs, lobby, deskPaths);
+    // Review slots no longer make rooms: a running review shows up as reviewers in its own room.
+    return { generatedAt: new Date(input.now).toISOString(), runs, lobby, reviews: [] };
 }
 /** One building from several repositories' snapshots; every room names its repository. */
 export function mergeOfficeSnapshots(parts, now) {
@@ -115,3 +139,52 @@ export function mergeOfficeSnapshots(parts, now) {
         reviews: parts.flatMap(({ repo, snapshot }) => snapshot.reviews.map(review => ({ ...review, repo })))
     };
 }
+const ACTIVITY_PHASE = { verify: "verifying", review: "reviewing", finish: "integrating" };
+function activityView(activity) {
+    return { kind: activity.kind, startedAt: activity.startedAt, ...(activity.targets === undefined ? {} : { targets: activity.targets }),
+        ...(activity.round === undefined ? {} : { round: activity.round }), ...(activity.target === undefined ? {} : { target: activity.target }) };
+}
+/**
+ * Puts each live activity in its room: the same session, else the same task,
+ * else the worktree it runs in. One that matches no room gets a room of its
+ * own for as long as it runs, so nothing that is running goes unseen.
+ */
+function attachActivities(input, runs, lobby, deskPaths) {
+    const runSessions = (run) => new Set(run.workers.flatMap(worker => [worker.ownerSessionId, worker.nativeSessionId].filter((id) => id !== null)));
+    for (const activity of input.activities ?? []) {
+        const view = activityView(activity);
+        const toDesk = (index) => { const desk = lobby[index]; lobby[index] = { ...desk, activities: [...(desk.activities ?? []), view] }; };
+        const toRun = (index) => { const run = runs[index]; runs[index] = { ...run, activities: [...(run.activities ?? []), view] }; };
+        const sourceRun = (run) => input.runs.find(state => state.runId === run.runId);
+        const matchers = [
+            [desk => activity.sessionId !== undefined && desk.sessionId === activity.sessionId,
+                run => activity.sessionId !== undefined && runSessions(sourceRun(run)).has(activity.sessionId)],
+            [desk => activity.taskId !== undefined && desk.taskId === activity.taskId,
+                run => activity.taskId !== undefined && run.agents.some(agent => agent.taskId === activity.taskId)],
+            [(_, index) => deskPaths.get(index) === activity.root,
+                run => sourceRun(run).workers.some(worker => worker.worktree === activity.root)]
+        ];
+        let placed = false;
+        for (const [deskMatch, runMatch] of matchers) {
+            const desk = lobby.findIndex(deskMatch);
+            if (desk >= 0) {
+                toDesk(desk);
+                placed = true;
+                break;
+            }
+            const run = runs.findIndex(candidate => sourceRun(candidate) !== undefined && runMatch(candidate));
+            if (run >= 0) {
+                toRun(run);
+                placed = true;
+                break;
+            }
+        }
+        if (placed)
+            continue;
+        const name = activity.taskId ?? activity.worktree ?? activity.kind;
+        lobby.push({ name, branch: "(no worktree)", sessionId: activity.sessionId ?? `activity-${activity.kind}-${activity.pid}`, sessionActive: true,
+            diff: { files: 0, insertions: 0, deletions: 0, paths: [], recent: null }, narration: ACTIVITY_PHASE[activity.kind],
+            commands: activity.taskId === undefined ? [] : [`agent-ops task status --task ${quote(activity.taskId)}`],
+            phase: ACTIVITY_PHASE[activity.kind], status: "active", ...(activity.taskId === undefined ? {} : { taskId: activity.taskId }), activities: [view] });
+    }
+}

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

@@ -1,3 +1,4 @@
+import { withActivity } from "../office/activity.js";
 import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
@@ -233,7 +234,8 @@ export async function finishWorktree(deps, options) {
     if (record === null) {
         throw finishError("WORKTREE_NOT_FOUND", `No agent-ops worktree named ${name}; see agent-ops worktree list.`);
     }
-    return await withFinishLock(deps, commonDir, async () => {
+    // Display only: the integrator is at work while the finish runs.
+    return await withActivity(commonDir, { kind: "finish", root: record.path, sessionId: record.sessionId, worktree: name }, async () => await withFinishLock(deps, commonDir, async () => {
         const sessionChildren = (await listWorktrees(deps, mainRoot))
             .map(({ record: child }) => child)
             .filter((child) => child.path !== record.path && child.sessionId === record.sessionId &&
@@ -507,5 +509,5 @@ export async function finishWorktree(deps, options) {
             await markRunIntegration(commonDir, record, "cleaned", "coordinator");
         return { record, mergedHead, rebased: !fastForward, taskIds: tree.map(({ task }) => task.task.id), warnings,
             ...(receipt === undefined ? {} : { receipt: receipt.path }) };
-    });
+    }));
 }

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

@@ -3,6 +3,7 @@ import { join, resolve } from "node:path";
 import { sha256 } from "../fs/hash.js";
 import { AgentOpsError } from "../fs/paths.js";
 import { collectChangeSurface } from "../verify/change-surface.js";
+import { FileRunRepository } from "../run/service.js";
 import { assertSessionId, assertWorktreeName, bindSession, insideWorktreeDirectory, parseWorktreeListPorcelain, readWorktreeRecord, assertRunWorktreeOwnership, removeCheckout, resolveCheckouts, worktreePath, writeWorktreeRecord } from "./service.js";
 /**
  * A baseline no source state hashes to. A resumed session inherits whatever
@@ -141,8 +142,11 @@ export async function resumeWorktree(deps, options) {
     const sessionId = assertSessionId(options.sessionId);
     const mainRoot = await mainCheckout(deps, options.cwd);
     const previous = await requireRecord(mainRoot, name);
-    const tasks = deps.tasks(previous.path);
+    // 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 };
@@ -206,6 +210,15 @@ export async function removeWorktree(deps, options) {
     const name = assertWorktreeName(options.name);
     const mainRoot = await mainCheckout(deps, options.cwd);
     const status = await describe(deps, await requireRecord(mainRoot, name));
+    // A running run still writes here; --force discards work, it does not stop the run.
+    const runId = status.record.runId;
+    if (runId !== undefined) {
+        const commonDir = join(mainRoot, ".git");
+        const run = await new FileRunRepository(join(commonDir, "agent-ops", "runs"), commonDir).read(runId).catch(() => null);
+        if (run !== null && ["active", "awaiting-input", "stopping"].includes(run.status)) {
+            throw manageError("WORKTREE_RUN_ACTIVE", `${name} belongs to run ${runId}, which is ${run.status}. Stop it first: agent-ops run stop ${runId}.`);
+        }
+    }
     if ((status.dirty || status.ahead > 0) && !options.force) {
         throw manageError("WORKTREE_UNMERGED", `${name} has ${status.dirty ? "uncommitted changes" : ""}${status.dirty && status.ahead > 0 ? " and " : ""}${status.ahead > 0 ? `${status.ahead} commit(s) not in ${status.record.targetBranch}` : ""}. Finish it, or remove it with --force to discard that work (the user is asked).`);
     }
@@ -217,7 +230,11 @@ export async function removeWorktree(deps, options) {
             ? mainGate.redirect(record.sessionId, null)
             : mainGate.removeRoot(record.sessionId, record.path));
     }
-    await deps.trust.revoke(record.path, await deps.loadConfig(record.path)).catch(() => undefined);
+    // A paused or stopped run's worktree has no loadable policy config; its trust
+    // was never this checkout's to revoke, so removal must not depend on it.
+    const config = await deps.loadConfig(record.path).catch(() => null);
+    if (config !== null)
+        await deps.trust.revoke(record.path, config).catch(() => undefined);
     await removeCheckout(deps, record, true);
     return status;
 }

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

@@ -17,7 +17,9 @@ const SESSION_ID_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/u;
 const REPORT_ARTIFACT_MAX_BYTES = 512 * 1024;
 function validContractBinding(value) {
     const hashes = [value.taskContractHash, value.goalHash, value.coverageDigest];
-    return hashes.every(v => typeof v === "string" && DIGEST_PATTERN.test(v)) &&
+    return (value.debugProofs === undefined || typeof value.debugProofs === "object" && value.debugProofs !== null && !Array.isArray(value.debugProofs) &&
+        Object.entries(value.debugProofs).every(([id, hash]) => TASK_ID_PATTERN.test(id) && typeof hash === "string" && DIGEST_PATTERN.test(hash))) &&
+        hashes.every(v => typeof v === "string" && DIGEST_PATTERN.test(v)) &&
         (value.treeContractHash === undefined || typeof value.treeContractHash === "string" && DIGEST_PATTERN.test(value.treeContractHash)) &&
         typeof value.candidateCommit === "string" && /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/u.test(value.candidateCommit) &&
         typeof value.taskContracts === "object" && value.taskContracts !== null && !Array.isArray(value.taskContracts) &&
@@ -26,6 +28,7 @@ function validContractBinding(value) {
 }
 function contractBinding(value) {
     return validContractBinding(value) ? {
+        ...(value.debugProofs === undefined ? {} : { debugProofs: value.debugProofs }),
         taskContractHash: value.taskContractHash, taskContracts: value.taskContracts,
         ...(value.treeContractHash === undefined ? {} : { treeContractHash: value.treeContractHash }),
         goalHash: value.goalHash, candidateCommit: value.candidateCommit, coverageDigest: value.coverageDigest

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

@@ -25,6 +25,14 @@ export async function runBatch(ids, deps, options) {
         throw new AgentOpsError("BATCH_INVALID_WIDTH", "Batch width must be a positive integer.");
     }
     const progress = options.onProgress ?? (() => { });
+    const phase = (value) => {
+        try {
+            options.onPhase?.(value);
+        }
+        catch {
+            // Display only.
+        }
+    };
     const controller = new AbortController();
     const outer = options.signal;
     if (outer?.aborted === true) {
@@ -71,6 +79,7 @@ export async function runBatch(ids, deps, options) {
             entry.retried = true;
         }
         let result;
+        phase("reviewing");
         try {
             result = await deps.review(id, controller.signal);
         }
@@ -127,6 +136,7 @@ export async function runBatch(ids, deps, options) {
                 break;
             }
             let status;
+            phase("verifying");
             try {
                 status = await deps.verify(id, controller.signal);
             }

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

@@ -690,6 +690,13 @@ async function attemptTargetWithRetry(request, options) {
     return attemptTarget({ ...request, resumeLostTurn: false }, options);
 }
 /** Builds the `execute` callback with one necessary and one adversarial review. */
+/** Display only: a failing listener never touches the review. */
+function announceRound(options, round, target, targets) {
+    try {
+        options.onRound?.(round, target, targets);
+    }
+    catch { /* display only */ }
+}
 export function createReviewExecutor(options) {
     const report = options.onProgress ?? (() => { });
     const host = detectHostTarget(options.env ?? process.env);
@@ -698,7 +705,7 @@ export function createReviewExecutor(options) {
     const clock = options.now ?? (() => Date.now());
     return async (request) => {
         const deadlineAt = clock() +
-            (options.chainTimeoutMs ?? DEFAULT_REVIEW_CHAIN_TIMEOUT_MS);
+            Math.min(options.chainTimeoutMs ?? DEFAULT_REVIEW_CHAIN_TIMEOUT_MS, await options.remainingBudgetMs?.() ?? Infinity);
         const remainingMs = () => deadlineAt - clock();
         /**
          * The options one stage runs under: its own timeout, or what is left of
@@ -802,6 +809,7 @@ export function createReviewExecutor(options) {
             report("chain: review deadline reached before the first round");
             return { status: "NOT_RUN", reason: "timeout", attempts: [] };
         }
+        announceRound(options, 1, primaryTarget, plannedTargets);
         const primaryOutcome = await attemptTargetWithRetry({
             ...shared,
             target: primaryTarget,
@@ -911,6 +919,7 @@ export function createReviewExecutor(options) {
             };
         }
         // The second round draws on what is left, never a fresh full budget.
+        announceRound(options, 2, adversarialTarget, plannedTargets);
         const adversarialOutcome = await attemptTargetWithRetry({
             ...shared,
             target: adversarialTarget,

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

@@ -48,62 +48,77 @@ export async function withReviewSlot(options, action) {
     }
     const sleep = options.sleep ?? (async (ms) => await new Promise((resolve) => setTimeout(resolve, ms)));
     let waiting = false;
+    let waitEnded = false;
     let held;
     const token = randomUUID();
-    while (held === undefined) {
-        if (options.signal?.aborted === true)
-            throw new ReviewInterruptedError(String(options.signal.reason ?? ""));
-        for (let index = 0; index < width && held === undefined; index += 1) {
-            const path = join(options.dir, `agent-ops-review-slot-${index}.lock`);
-            try {
-                const claimed = await withPrivateFileLock(path + ".state", options.dir, async () => {
-                    if (options.signal?.aborted === true)
-                        throw new ReviewInterruptedError(String(options.signal.reason ?? ""));
-                    for (;;) {
-                        try {
-                            await mkdir(path);
-                            await writeFile(join(path, "owner.json"), JSON.stringify({ ...options.holder, pid: process.pid, at: Date.now(), token }));
-                            return true;
-                        }
-                        catch (error) {
-                            if (error.code !== "EEXIST")
-                                throw error;
-                            if (!await stale(path, options.staleMs ?? STALE_MS))
-                                return false;
-                            await rm(path, { recursive: true, force: true });
+    try {
+        while (held === undefined) {
+            if (options.signal?.aborted === true)
+                throw new ReviewInterruptedError(String(options.signal.reason ?? ""));
+            for (let index = 0; index < width && held === undefined; index += 1) {
+                const path = join(options.dir, `agent-ops-review-slot-${index}.lock`);
+                try {
+                    const claimed = await withPrivateFileLock(path + ".state", options.dir, async () => {
+                        if (options.signal?.aborted === true)
+                            throw new ReviewInterruptedError(String(options.signal.reason ?? ""));
+                        for (;;) {
+                            try {
+                                await mkdir(path);
+                                await writeFile(join(path, "owner.json"), JSON.stringify({ ...options.holder, pid: process.pid, at: Date.now(), token }));
+                                return true;
+                            }
+                            catch (error) {
+                                if (error.code !== "EEXIST")
+                                    throw error;
+                                if (!await stale(path, options.staleMs ?? STALE_MS))
+                                    return false;
+                                await rm(path, { recursive: true, force: true });
+                            }
                         }
-                    }
-                });
-                if (claimed)
-                    held = path;
+                    });
+                    if (claimed)
+                        held = path;
+                }
+                catch (error) {
+                    if (!(error instanceof AgentOpsError) || error.code !== "PRIVATE_STATE_LOCK_TIMEOUT")
+                        throw error;
+                }
             }
-            catch (error) {
-                if (!(error instanceof AgentOpsError) || error.code !== "PRIVATE_STATE_LOCK_TIMEOUT")
-                    throw error;
+            if (held === undefined) {
+                if (!waiting) {
+                    waiting = true;
+                    await options.onWaitStart?.();
+                    options.onWait?.(`review: waiting for one of ${String(width)} shared review slots`);
+                }
+                await sleep(options.pollMs ?? POLL_MS);
             }
         }
-        if (held === undefined) {
-            if (!waiting) {
-                waiting = true;
-                options.onWait?.(`review: waiting for one of ${String(width)} shared review slots`);
-            }
-            await sleep(options.pollMs ?? POLL_MS);
+        if (waiting) {
+            waitEnded = true;
+            await options.onWaitEnd?.(true);
         }
-    }
-    try {
         if (options.signal?.aborted === true)
             throw new ReviewInterruptedError(String(options.signal.reason ?? ""));
         return await action();
     }
     finally {
-        await withPrivateFileLock(held + ".state", options.dir, async () => {
-            const owner = await readFile(join(held, "owner.json"), "utf8").catch(error => {
-                if (error.code === "ENOENT")
-                    return null;
-                throw error;
+        if (waiting && !waitEnded) {
+            waitEnded = true;
+            try {
+                await options.onWaitEnd?.(false);
+            }
+            catch { /* preserve the original wait/abort failure */ }
+        }
+        if (held !== undefined) {
+            await withPrivateFileLock(held + ".state", options.dir, async () => {
+                const owner = await readFile(join(held, "owner.json"), "utf8").catch(error => {
+                    if (error.code === "ENOENT")
+                        return null;
+                    throw error;
+                });
+                if (owner !== null && JSON.parse(owner)?.token === token)
+                    await rm(held, { recursive: true, force: true });
             });
-            if (owner !== null && JSON.parse(owner)?.token === token)
-                await rm(held, { recursive: true, force: true });
-        });
+        }
     }
 }

package/dist/runtime/src/run/hosts/codex.js

@@ -236,7 +236,7 @@ export class CodexGoalHost {
             clientInfo: {
                 name: "agent-ops",
                 title: "agent-ops native goal host",
-                version: "0.7.3"
+                version: "0.8.2"
             }
         });
         session.notify("initialized", {});

package/dist/runtime/src/run/transport.js

@@ -2,10 +2,13 @@ import { nativeProcessGroupAlive, signalNativeProcessGroup } from "./hosts/util.
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { AgentOpsError } from "../fs/paths.js";
+import { readWindowsProcessIdentity } from "../security/permissions.js";
 const exec = promisify(execFile);
 export async function nativeProcessIdentity(pid) {
     if (!Number.isSafeInteger(pid) || pid < 1)
         return null;
+    if (process.platform === "win32")
+        return await readWindowsProcessIdentity(pid);
     try {
         const { stdout } = await exec("ps", ["-p", String(pid), "-o", "lstart="], { maxBuffer: 8192 });
         return stdout.trim() || null;