@kylecheng3146/agent-ops 0.7.3 → 0.8.0

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,34 @@ 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 = { passed, total, verify, review };
         const 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,
+        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: passed, total },
             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 +135,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 +155,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

@@ -57,6 +57,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 +79,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 +107,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 +127,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/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);
@@ -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/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.0"
             }
         });
         session.notify("initialized", {});

package/docs/en/guides/configuration.md

@@ -448,6 +448,13 @@ To narrow an existing installation, pass the desired list to `agent-ops update
 --harness`; shared paths remain managed while removed harness-owned artifacts,
 markers, and hooks are reconciled.
 
+Update keeps the configured profiles. To add or remove the opt-in `run`
+profile on an existing installation, pass `agent-ops update --auto-run on` or
+`--auto-run off`; `off` removes only `run`, and the `loop` it brought stays
+(use `init` to change other profiles). Without the flag, an interactive update
+on macOS with Claude Code or Codex installed asks once, defaulting to the
+current choice; `--yes` and non-interactive updates preserve it.
+
 To remove only one integrated harness, use `agent-ops uninstall --harness agy`
 (or another installed id). The remaining manifest and shared paths stay in
 place; omit `--harness` to remove the complete managed installation.

package/docs/en/spec/harness-adapters.md

@@ -145,7 +145,10 @@ The `run` profile MUST be opt-in, select `core` and `loop` with it, and add only
 the `auto-run` capability. With it, the Claude Code and Codex managed rules hand
 a change that needs more than five acceptance criteria to `agent-ops run`; five
 or fewer stay in the session. agy rules, and every rule file without `auto-run`,
-MUST stay byte-identical to the rules without the profile.
+MUST stay byte-identical to the rules without the profile. Update MUST preserve
+the profile unless `--auto-run on|off` is supplied or an interactive update on
+macOS with Claude Code or Codex asks (default: the current choice); `off`
+removes only `run` and keeps `loop`.
 
 - Trigger: A project selects `run`, and a Claude Code or Codex session meets a
   change that needs more than five acceptance criteria.
@@ -221,7 +224,18 @@ Claude or Codex transcripts or file contents.
   Claude Code also gets a managed `SessionEnd` hook: when the conversation
   closes, its room closes too, even without a task. It writes no output and
   never fails the host. Other hosts publish no end event and rely on the
-  activity timeout. A room without a task shows a no-task board rather than
+  activity timeout. A session that has only started is idle; a submitted
+  prompt or tool activity marks it active, and agy's per-invocation start
+  counts as activity. Outside the project loop, Claude Code and Codex get a
+  managed `UserPromptSubmit` hook whenever Office or command policy is enabled:
+  Office records the turn's start, and command policy refuses a prompt carrying
+  a literal credential in the host's native shape (Claude `decision: "block"`,
+  Codex exit code 2). Its runtime failures let the prompt through. Hooks see
+  only a command's start, so `agent-ops batch` reports each verify or review
+  as it starts to the sessions attached to its tasks (the newest step shows),
+  and `task advance` outside a run reports verify, review and integration to
+  its own session. These reports update only a known session, never fail the
+  command, and record nothing while Office is disabled. A room without a task shows a no-task board rather than
   pending verification and review. Session metadata contains bounded
   identifiers, known work state and activity times, never native transcripts,
   prompts or tool/file contents. Startup and observation failures are advisory.

package/docs/zh-TW/guides/configuration.md

@@ -395,6 +395,12 @@ config-hash 與 timestamp evidence，且永遠不會完成 task。Config v1 會
 `agent-ops update --harness`；shared path 會繼續受管理，被移除 harness
 擁有的 artifact、marker 與 hook 則會被安全同步。
 
+Update 會保留已設定的 profile。若要在既有 installation 加入或移除 opt-in 的
+`run` profile，請使用 `agent-ops update --auto-run on` 或 `--auto-run off`；
+`off` 只移除 `run`，它帶入的 `loop` 會保留（其他 profile 請用 `init` 變更）。
+未提供此旗標時，在已安裝 Claude Code 或 Codex 的 macOS 上互動式 update 會詢問
+一次，預設為目前的選擇；`--yes` 與非互動式 update 會保留原設定。
+
 若只要移除單一已整合 harness，可使用
 `agent-ops uninstall --harness agy`（或其他已安裝 id）。剩餘 manifest 與
 shared path 會保留；省略 `--harness` 才會移除整套 managed installation。

package/docs/zh-TW/spec/harness-adapters.md

@@ -126,7 +126,9 @@ event metadata、回傳有界且 redacted 的 session context，並在 update
 capability。啟用後，Claude Code 與 Codex 的 managed rules 會將需要超過五項
 acceptance criteria 的變更交給 `agent-ops run`；五項以內仍留在 session 中處理。
 agy rules，以及所有未含 `auto-run` 的 rule file，MUST 與未啟用此 profile 時
-byte-identical。
+byte-identical。Update MUST 保留此 profile，除非提供 `--auto-run on|off`，或在已
+安裝 Claude Code 或 Codex 的 macOS 上互動式 update 詢問（預設為目前選擇）；
+`off` 只移除 `run`，保留 `loop`。
 
 - Trigger: Project 選擇 `run`，且 Claude Code 或 Codex session 遇到需要超過五項
   acceptance criteria 的變更。
@@ -189,7 +191,15 @@ base 的 `git diff`；旁白只使用路徑（`docs/**` 為「writing docs」、
   刪除該紀錄，絕不對其 pid 發送訊號。`worktree finish` 成功後會記錄 session
   完成，使房間關閉；只有新的啟動或 active task 會重新開啟。啟用 Office 時，Claude Code
   另有受管理的 `SessionEnd` hook：對話關閉時房間也隨之關閉，即使沒有 task。它不輸出
-  任何內容，也絕不讓 host 失敗。其他 host 沒有結束事件，依活動逾時處理。沒有 task 的
+  任何內容，也絕不讓 host 失敗。其他 host 沒有結束事件，依活動逾時處理。只有啟動的
+  session 為閒置；送出 prompt 或 tool 活動才標為 active，agy 以 invocation 為單位
+  的啟動視為活動。不在 project loop 時，只要啟用 Office 或 command policy，Claude
+  Code 與 Codex 會有受管理的 `UserPromptSubmit` hook：Office 記錄該輪開始，command
+  policy 以 host 原生格式拒絕含字面憑證的 prompt（Claude `decision: "block"`、Codex
+  exit code 2）。其 runtime 失敗時放行 prompt。Hook 只看得到指令開始，因此
+  `agent-ops batch` 在每個 verify 或 review 開始時回報給其 task 綁定的 session
+  （顯示最新一步），不在 run 內的 `task advance` 則把驗證、審查、整合回報給自己
+  的 session。這些回報只更新已知 session，絕不讓指令失敗，Office 關閉時不記錄。沒有 task 的
   房間白板顯示「無任務」，而非待驗證與待審查。Session metadata
   只記錄有界限的識別資訊、已知工作狀態與活動時間，不包含 native transcript、
   prompt、tool 或檔案內容。啟動與活動觀察失敗均為 advisory。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kylecheng3146/agent-ops",
-  "version": "0.7.3",
+  "version": "0.8.0",
   "description": "Evidence-driven development loops for agy, Codex, Claude Code, and opencode",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",