@kylecheng3146/agent-ops 0.7.2 → 0.8.0

package/README.md

@@ -257,6 +257,8 @@ Init and update pre-authorize `agent-ops run` for Claude Code and Codex.
 
 ```bash
 agent-ops init --scope project --harness codex,claude --profile run --yes
+# an existing installation: add it, or later remove it (loop stays)
+agent-ops update --auto-run on
 ```
 
 ## Quick start from a source checkout

package/dist/packages/cli/src/args.js

@@ -95,6 +95,7 @@ export function parseArgs(argv) {
     const checkAuthTargets = [];
     let completionGate;
     let office;
+    let autoRun;
     let dryRun = false;
     let json = false;
     let yes = false;
@@ -328,6 +329,16 @@ export function parseArgs(argv) {
                 index += 1;
                 break;
             }
+            case "--auto-run": {
+                if (autoRun !== undefined)
+                    duplicate(token);
+                const value = readOptionValue(argv, index, token);
+                if (value !== "on" && value !== "off")
+                    invalidValue(token, value);
+                autoRun = value;
+                index += 1;
+                break;
+            }
             case "--worktree": {
                 if (worktree !== undefined) {
                     duplicate(token);
@@ -523,6 +534,7 @@ export function parseArgs(argv) {
             reviewTargets.length > 0 ||
             completionGate !== undefined ||
             office !== undefined ||
+            autoRun !== undefined ||
             sessionId !== undefined ||
             base !== undefined ||
             parentBase !== undefined ||
@@ -616,6 +628,9 @@ export function parseArgs(argv) {
     if (office !== undefined && command !== "init" && command !== "update") {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--office may be used only with init or update.");
     }
+    if (autoRun !== undefined && command !== "update") {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--auto-run may be used only with update; init selects the run profile.");
+    }
     if (worktree !== undefined && command !== "init" && command !== "update") {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--worktree may be used only with init or update.");
     }
@@ -793,6 +808,7 @@ export function parseArgs(argv) {
         ...(reviewTargets.length === 0 ? {} : { reviewTargets }),
         ...(completionGate === undefined ? {} : { completionGate }),
         ...(office === undefined ? {} : { office }),
+        ...(autoRun === undefined ? {} : { autoRun }),
         ...(criteria.length === 0 ? {} : { criteria }),
         ...(criterionFiles.length === 0 ? {} : { criterionFiles }),
         ...(criteriaFile === undefined ? {} : { criteriaFile }),

package/dist/packages/cli/src/bin.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { productionRunContext, runPhaseObserver } from "./run-deps.js";
+import { advancePhaseObserver, productionRunContext } from "./run-deps.js";
 import { AgentOpsError } from "../../../runtime/src/fs/paths.js";
 import { recordRunVerification } from "../../../runtime/src/run/verification.js";
 import { runOwnedLocalProof } from "./owned-run-step.js";
 import { runRunCommand } from "./commands/run.js";
 import { runOfficeCommand } from "./commands/office.js";
-import { ensureBackgroundOffice, observeOfficeSession, openOfficeBrowser, serveOffice } from "./office-entry.js";
+import { ensureBackgroundOffice, observeOfficeSession, officePhaseReporter, openOfficeBrowser, serveOffice } from "./office-entry.js";
 import { readFile, readdir, stat } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
@@ -42,6 +42,7 @@ import { hasFreshVerification, runReviewCommand } from "./commands/review.js";
 import { runBatchCommand } from "./commands/batch.js";
 import { createSourceGuard } from "../../../runtime/src/review/batch-guard.js";
 import { withReviewSlot } from "../../../runtime/src/review/slots.js";
+import { withActivity } from "../../../runtime/src/office/activity.js";
 import { memoizePreflight } from "../../../runtime/src/review/batch.js";
 import { createReviewExecutor, ReviewInterruptedError } from "../../../runtime/src/review/execute.js";
 import { probeReviewTargetDetailed } from "../../../runtime/src/review/probe.js";
@@ -60,6 +61,16 @@ import { runWorktreeCommand } from "./commands/parallel.js";
 import { ensureSessionWorktree, readWorktreeRecord, resolveCheckouts } from "../../../runtime/src/parallel/service.js";
 import { listWorktrees, branchLockDoctorResult, worktreeDoctorResult } from "../../../runtime/src/parallel/manage.js";
 import { detectGhostFiles, ghostFilesDoctorResult } from "../../../runtime/src/install/doctor.js";
+/** The repository's common Git directory, where display-only office records live; undefined when git cannot say. */
+async function officeCommonDir(dir) {
+    try {
+        const result = await gitRunner(dir).run(["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+        return result.exitCode === 0 ? new TextDecoder().decode(result.stdout).trim() || undefined : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 const HOOK_RUNTIME_PATH = fileURLToPath(new URL("./hook-entry.js", import.meta.url));
 async function readOptionalText(path) {
     try {
@@ -413,6 +424,7 @@ else {
                         calculateTrustBinding: async (config) => await plannedTrustBinding(root, config),
                         confirm: async (plan, trust) => await confirmPlan(formatUpdatePlan(plan, trust)),
                         promptOffice: async (message, enabled) => await selectYesNo(message, { input: process.stdin, output: process.stdout }, enabled),
+                        promptAutoRun: async (message, enabled) => await selectYesNo(message, { input: process.stdin, output: process.stdout }, enabled),
                         promptWorktree: async (message) => await selectYesNo(message, { input: process.stdin, output: process.stdout }, true),
                         ...(updateArgs.targetVersion === undefined
                             ? {}
@@ -450,13 +462,13 @@ else {
                         ? await resolveCommandSessionId(root)
                         : sessionIdFromEnvironment() ?? await readRecordedSessionId(root));
                     if (args.action === "advance") {
+                        const advanceSession = sessionId ?? await resolveCommandSessionId(root);
                         return await runAdvanceCommand({
                             cwd: root,
-                            sessionId: sessionId ?? await resolveCommandSessionId(root),
+                            sessionId: advanceSession,
                             parentTaskId: args.taskId,
                             deps: worktreeDependencies(),
-                            ...(process.env.AGENT_OPS_RUN_ID === undefined || process.env.AGENT_OPS_WORKER_ID === undefined ? {} :
-                                { onPhase: await runPhaseObserver(root, process.env.AGENT_OPS_RUN_ID, process.env.AGENT_OPS_WORKER_ID) })
+                            onPhase: await advancePhaseObserver(root, advanceSession)
                         });
                     }
                     const createConfig = args.action === "create"
@@ -521,6 +533,18 @@ else {
                     const slotDir = commonDirResult.exitCode === 0
                         ? new TextDecoder().decode(commonDirResult.stdout).trim()
                         : undefined;
+                    let reviewActivity;
+                    const inActivity = (executor) => async (request) => await withActivity(slotDir, { kind: "review", root,
+                        ...(reviewArgs.taskId === undefined ? {} : { taskId: reviewArgs.taskId }),
+                        ...(reviewSessionId === undefined ? {} : { sessionId: reviewSessionId }) }, async (handle) => {
+                        reviewActivity = handle;
+                        try {
+                            return await executor(request);
+                        }
+                        finally {
+                            reviewActivity = undefined;
+                        }
+                    });
                     const inSlot = (executor) => slotDir === undefined
                         ? executor
                         : async (request) => await withReviewSlot({
@@ -549,7 +573,7 @@ else {
                         currentPolicyConfigHash: async () => calculateConfigHash((await loadEffectiveConfig(root, reviewArgs.scope === "user" ? "user" : "project")).config),
                         config: reviewConfig,
                         evidenceStore: new FileEvidenceStore(root, root),
-                        execute: inSlot(createReviewExecutor({
+                        execute: inActivity(inSlot(createReviewExecutor({
                             runner: registeredRunProofRunner(),
                             targets: configuredReviewTargets,
                             cwd: root,
@@ -575,8 +599,11 @@ else {
                             signal,
                             onProgress: (line) => {
                                 process.stderr.write(`${progressPrefix}${line}\n`);
+                            },
+                            onRound: (round, target, targets) => {
+                                void reviewActivity?.update({ round, target, targets });
                             }
-                        }))
+                        })))
                     };
                 };
                 if (args.command === "review") {
@@ -662,7 +689,10 @@ else {
                             signal: controller.signal,
                             onProgress: (line) => {
                                 process.stderr.write(`batch: ${line}\n`);
-                            }
+                            },
+                            // The batch's tasks name the sessions whose people follow its steps.
+                            phaseReporter: async (taskIds) => await officePhaseReporter(root, (await new FileTaskStore(join(root, ".agent-ops", "tasks", "state.json"), root).read()).sessions
+                                .filter(({ taskId }) => taskIds.includes(taskId)).map(({ sessionId }) => sessionId))
                         });
                         if (interruptedBy !== undefined) {
                             process.exit(interruptedBy === "SIGINT" ? 130 : 143);
@@ -681,9 +711,11 @@ else {
                     const merged = await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project");
                     const config = merged.config;
                     const trustStatus = await repositoryTrust(root, config, CLI_VERSION);
+                    const verifySessionId = sessionIdFromEnvironment();
                     return await runVerifyCommand({
                         args,
                         taskService,
+                        activity: { commonDir: await officeCommonDir(root), root, ...(verifySessionId === undefined ? {} : { sessionId: verifySessionId }) },
                         service: { verify: async (taskId) => {
                                 const run = await runPolicyContext(root);
                                 const report = await new VerificationService({

package/dist/packages/cli/src/cli.js

@@ -45,6 +45,7 @@ Options:
   --review-target <codex|agy|claude>  Repeatable init option; review pair order
   --completion-gate                  Init only: enable the project-loop completion gate
   --office <on|off>                   Init/update: enable or disable Office (Preview)
+  --auto-run <on|off>                 Update: add or remove the run profile (loop stays)
   --worktree <auto|off>              Init/update: configure session worktree isolation
   --check-auth                        Doctor only: probe selected review targets'
                                       authentication with one real call
@@ -152,6 +153,7 @@ Options:
   --harness <all|both|agy|claude|codex|opencode|comma-separated>
   --target-version <version>   Offline-capable update target
   --office <on|off>           Office (Preview); preserve choice unless supplied
+  --auto-run <on|off>          Add or remove the run profile (loop stays); preserve unless supplied
   --worktree <auto|off>        Configure session worktree isolation
   --dry-run
   --json

package/dist/packages/cli/src/commands/batch.js

@@ -66,6 +66,7 @@ export async function runBatchCommand(options) {
         };
     }
     const width = args.width ?? DEFAULT_BATCH_WIDTH;
+    const report = await options.phaseReporter?.(plan.map((item) => item.record.task.id)).catch(() => undefined);
     const outcomes = await runBatch(plan.map((item) => item.record.task.id), {
         isVerified: (id) => options.isVerified(id, base(id)),
         verify: (id, signal) => options.verify(id, base(id), signal),
@@ -74,7 +75,8 @@ export async function runBatchCommand(options) {
     }, {
         width,
         ...(options.signal === undefined ? {} : { signal: options.signal }),
-        ...(options.onProgress === undefined ? {} : { onProgress: options.onProgress })
+        ...(options.onProgress === undefined ? {} : { onProgress: options.onProgress }),
+        ...(report === undefined ? {} : { onPhase: (phase) => void report(phase).catch(() => { }) })
     });
     const byId = new Map(outcomes.map((outcome) => [outcome.id, outcome]));
     const tasks = plan.map((item) => {

package/dist/packages/cli/src/commands/update.js

@@ -1,6 +1,7 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { loadConfigFile } from "../../../../runtime/src/config/load.js";
+import { parseInstallManifest } from "../../../../runtime/src/fs/manifest.js";
 import { detectWorktreeSetup } from "../../../../runtime/src/install/parallel-setup.js";
 import { applyUpdatePlan, createUpdatePlan } from "../../../../runtime/src/install/update.js";
 import { okEnvelope } from "../output.js";
@@ -17,6 +18,7 @@ export function formatUpdatePlan(plan, trust) {
         metadata: [
             `Target version: ${plan.targetVersion}`,
             `Office (Preview): ${plan.installation.config.features.office?.enabled === true ? "enabled" : "disabled"}`,
+            `Auto-run: ${plan.installation.config.profiles.includes("run") ? "enabled" : "disabled"}`,
             `Harness: ${plan.installation.harness.join(", ")}`,
             ...(plan.installation.config.worktree === undefined
                 ? []
@@ -73,6 +75,14 @@ async function existingConfigHasWorktree(root) {
         return false;
     }
 }
+async function installedHarness(root) {
+    try {
+        return parseInstallManifest(await readFile(join(root, ".agent-ops", "manifest.json"), "utf8")).harness;
+    }
+    catch {
+        return [];
+    }
+}
 export async function runUpdateCommand(options) {
     let worktree;
     if (options.args.worktree === "auto") {
@@ -102,10 +112,18 @@ export async function runUpdateCommand(options) {
         const { config } = await loadConfigFile(join(options.root, ".agent-ops", "config.json"));
         officeEnabled = await options.promptOffice("Enable Office (Preview)?", config.features.office?.enabled === true);
     }
+    let autoRun = options.args.autoRun === undefined ? undefined : options.args.autoRun === "on";
+    if (autoRun === undefined && options.promptAutoRun !== undefined && options.isTTY && !options.args.yes &&
+        (options.platform ?? process.platform) === "darwin" &&
+        (options.args.harness ?? await installedHarness(options.root)).some((harness) => harness === "claude" || harness === "codex")) {
+        const { config } = await loadConfigFile(join(options.root, ".agent-ops", "config.json"));
+        autoRun = await options.promptAutoRun("Enable auto-run (hand changes needing more than five acceptance criteria to agent-ops run)?", config.profiles.includes("run"));
+    }
     const plan = await createUpdatePlan({
         root: options.root,
         adapters: options.adapters,
         ...(officeEnabled === undefined ? {} : { officeEnabled }),
+        ...(autoRun === undefined ? {} : { autoRun }),
         ...(options.args.harness === undefined
             ? {}
             : { harness: options.args.harness }),

package/dist/packages/cli/src/commands/verify.js

@@ -1,3 +1,4 @@
+import { withActivity } from "../../../../runtime/src/office/activity.js";
 import { AgentOpsError } from "../../../../runtime/src/fs/paths.js";
 import { redactSecrets } from "../../../../runtime/src/security/redact.js";
 import { safeTaskText } from "../../../../runtime/src/task/render.js";
@@ -90,7 +91,8 @@ async function resolveTaskId(options) {
 }
 export async function runVerifyCommand(options) {
     try {
-        const report = publicReport(await options.service.verify(await resolveTaskId(options)));
+        const taskId = await resolveTaskId(options), activity = options.activity;
+        const report = publicReport(await withActivity(activity?.commonDir, { kind: "verify", root: activity?.root ?? "", taskId, ...(activity?.sessionId === undefined ? {} : { sessionId: activity.sessionId }) }, async () => await options.service.verify(taskId)));
         const text = formatReport(report);
         if (report.status === "PASS") {
             return okEnvelope("VERIFICATION_PASSED", {

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

@@ -20,6 +20,8 @@ import { FileEvidenceStore } from "../../../runtime/src/verify/evidence.js";
 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";
@@ -266,10 +268,56 @@ async function closeOfficeSession(io, dependencies) {
     }
     return 0;
 }
+/**
+ * A prompt submitted outside the project loop: Office records the turn's work
+ * starting, and command policy refuses a literal credential the way the loop
+ * does. Every runtime failure lets the prompt through.
+ */
+async function promptSubmitted(harness, io, dependencies) {
+    try {
+        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))
+            return 0;
+        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")
+            return 0;
+        const config = outcome.config;
+        if (dependencies.office !== undefined && config.features.office?.enabled === true) {
+            await dependencies.office({
+                root, harness, event: "UserPromptSubmit", input, validated: true,
+                ...(typeof fields.session_id === "string" ? { sessionId: fields.session_id } : {})
+            }).catch(() => undefined);
+        }
+        if (config.profiles.length === 0 || !resolveCapabilities(config).capabilities.includes("command-policy"))
+            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")
+            return 0;
+        const reason = "agent-ops blocked a suspected secret.";
+        if (harness === "claude") {
+            io.writeStdout(JSON.stringify({ decision: "block", reason }));
+            return 0;
+        }
+        io.writeStderr(reason + "\n");
+        return 2;
+    }
+    catch {
+        return 0;
+    }
+}
 export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
     const [harness, event] = argv;
     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

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

@@ -7,7 +7,7 @@ import { spawn } from "node:child_process";
 import { collectOfficeBuilding } from "../../../runtime/src/office/collect.js";
 import { claimOffice, createOfficeServer, ensureOffice, legacyOfficeHome, officeRecordPath, readLiveOffice, officeUrl, releaseOffice, userOfficeHome } from "../../../runtime/src/office/server.js";
 import { registerOfficeRepo } from "../../../runtime/src/office/repos.js";
-import { recordOfficeSession } from "../../../runtime/src/office/sessions.js";
+import { recordOfficeSession, recordOfficeSessionPhase } from "../../../runtime/src/office/sessions.js";
 import { resolveCheckouts } from "../../../runtime/src/parallel/service.js";
 import { createLaunchdDescriptor, LaunchdController } from "../../../runtime/src/run/macOS.js";
 import { ensurePrivateDirectory, readPrivateFile } from "../../../runtime/src/security/permissions.js";
@@ -47,8 +47,11 @@ function sessionIdentity(options) {
     const nested = recordValue(options.input, "input");
     return firstText(options.sessionId, recordValue(options.input, "session_id"), recordValue(options.input, "sessionId"), recordValue(options.input, "conversationId"), recordValue(options.input, "thread_id"), recordValue(options.input, "threadId"), recordValue(nested, "sessionID"), recordValue(nested, "session_id"), process.env.AGENT_OPS_SESSION_ID, process.env.CODEX_THREAD_ID);
 }
-function officeEvent(event) {
-    return event === "SessionStart" ? "start" : event === "Stop" ? "stop" : event === "SessionEnd" ? "end" : "activity";
+/** agy's SessionStart is its native PreInvocation, sent as each invocation's work begins. */
+export function officeEvent(harness, event) {
+    if (event === "SessionStart")
+        return harness === "agy" ? "activity" : "start";
+    return event === "Stop" ? "stop" : event === "SessionEnd" ? "end" : "activity";
 }
 /** Phase hints come only from normalized native event kinds and exact agent-ops argv. */
 export function officePhaseHint(event) {
@@ -64,13 +67,14 @@ export function officePhaseHint(event) {
         if (basename(command.command) !== "agent-ops")
             continue;
         const action = command.args[0];
-        const next = action === "verify"
+        // batch and advance report their later steps themselves; this is their first.
+        const next = action === "verify" || action === "batch"
             ? "verifying"
             : action === "review"
                 ? "reviewing"
                 : action === "worktree" && command.args[1] === "finish"
                     ? "integrating"
-                    : action === "task" && command.args[1] === "complete"
+                    : action === "task" && (command.args[1] === "complete" || command.args[1] === "advance")
                         ? "integrating"
                         : action === "task"
                             ? "planning"
@@ -117,7 +121,7 @@ export async function observeOfficeSession(options) {
             harness: options.harness,
             projectRoot: mainRoot,
             commonDir,
-            event: officeEvent(options.event),
+            event: officeEvent(options.harness, options.event),
             ...(options.agentId === undefined ? {} : { agentId: options.agentId }),
             ...(process.env.AGENT_OPS_RUN_ID === undefined ? {} : { runId: process.env.AGENT_OPS_RUN_ID }),
             ...(process.env.AGENT_OPS_WORKER_ID === undefined ? {} : { workerId: process.env.AGENT_OPS_WORKER_ID }),
@@ -136,6 +140,30 @@ export async function observeOfficeSession(options) {
         // Office is display-only; a missing Git checkout, lock or launcher never blocks a host hook.
     }
 }
+/**
+ * Moves these sessions' people as a batch or advance reaches each step.
+ * Display only: a disabled Office, an unknown session or a failed write records nothing.
+ */
+export async function officePhaseReporter(cwd, sessionIds) {
+    const none = async () => { };
+    try {
+        if (sessionIds.length === 0 || !(await officeEnabled(cwd)))
+            return none;
+        const { commonDir } = await checkouts(cwd);
+        // One write at a time, in order, so the latest step is the one that stays.
+        let chain = Promise.resolve();
+        return async (phase) => {
+            chain = chain.then(async () => {
+                for (const sessionId of sessionIds)
+                    await recordOfficeSessionPhase(commonDir, sessionId, phase).catch(() => { });
+            });
+            await chain;
+        };
+    }
+    catch {
+        return none;
+    }
+}
 async function checkouts(cwd) {
     return await resolveCheckouts(worktreeDependencies(), cwd);
 }

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

@@ -13,6 +13,7 @@ import { FileRunRepository, RunService } from "../../../runtime/src/run/service.
 import { readPrivateFile, writePrivateFile } from "../../../runtime/src/security/permissions.js";
 import { collectChangeSurface } from "../../../runtime/src/verify/change-surface.js";
 import { worktreeDependencies, gitRunner, trustStore } from "./parallel-deps.js";
+import { officePhaseReporter } from "./office-entry.js";
 import { NativeRunTransport } from "../../../runtime/src/run/transport.js";
 import { ClaudeGoalHost } from "../../../runtime/src/run/hosts/claude.js";
 import { CodexGoalHost } from "../../../runtime/src/run/hosts/codex.js";
@@ -145,6 +146,13 @@ export async function runPhaseObserver(cwd, runId, workerId) {
     const repository = new FileRunRepository(join(commonDir, "agent-ops", "runs"), commonDir);
     return async (phase, progress) => await recordRunPhase(repository, runId, workerId, phase, progress);
 }
+/** A run worker's advance reports to its run; an ordinary session's moves its own person in Office. */
+export async function advancePhaseObserver(cwd, sessionId, env = process.env) {
+    if (env.AGENT_OPS_RUN_ID !== undefined && env.AGENT_OPS_WORKER_ID !== undefined)
+        return await runPhaseObserver(cwd, env.AGENT_OPS_RUN_ID, env.AGENT_OPS_WORKER_ID);
+    const office = await officePhaseReporter(cwd, sessionId === undefined ? [] : [sessionId]);
+    return async (phase) => await office(phase);
+}
 export const runEntry = fileURLToPath(new URL("./run-entry.js", import.meta.url));
 export function runDescriptor(state) {
     return createLaunchdDescriptor({ runId: state.runId, workerId: "supervisor", privateDirectory: join(state.commonDir, "agent-ops", "runs", state.runId),

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

@@ -113,7 +113,10 @@ export function buildClaudeHookSettings(capabilities, runtimePath, platform = pr
         if (capabilities.includes("lifecycle-summary") || capabilities.includes("office-presence")) {
             hooks.SessionStart = [matcherGroup("SessionStart", 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")) {
+            hooks.UserPromptSubmit = [matcherGroup("UserPromptSubmit", runtimePath)];
             hooks.PreToolUse = [matcherGroup("PreToolUse", runtimePath)];
         }
     }

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

@@ -82,7 +82,10 @@ export function buildCodexHookConfig(capabilities, runtimePath) {
         if (capabilities.includes("lifecycle-summary") || capabilities.includes("office-presence")) {
             hooks.SessionStart = [matcherGroup("SessionStart", 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")) {
+            hooks.UserPromptSubmit = [matcherGroup("UserPromptSubmit", runtimePath)];
             hooks.PreToolUse = [matcherGroup("PreToolUse", runtimePath)];
         }
     }

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

@@ -106,11 +106,19 @@ export async function createUpdatePlan(options) {
         configPreview.steps.length === 0) {
         throw new AgentOpsError("UPDATE_INSTALLATION_INVALID", "Update requires a passing config doctor check.");
     }
+    const current = configPreview.migrated.profiles;
+    // `run` implies `loop`; turning run off keeps the loop it brought, since
+    // the config cannot tell an implied loop from a chosen one.
+    const profiles = options.autoRun === true
+        ? current.includes("run") ? current : [...current, "run"]
+        : options.autoRun === false && current.includes("run")
+            ? [...current.filter((profile) => profile !== "run"), ...(current.includes("loop") ? [] : ["loop"])]
+            : current;
     const installation = await createInstallPlan({
         root: options.root,
         scope: report.manifest.scope,
         harness: options.harness ?? report.manifest.harness,
-        profiles: configPreview.migrated.profiles,
+        profiles,
         adapters: options.adapters,
         toolkitVersion: options.toolkitVersion ?? targetVersion,
         allowHarnessChange: true,
@@ -122,7 +130,7 @@ export async function createUpdatePlan(options) {
             ? {}
             : { hookTargets: options.hookTargets }),
         existingConfig: {
-            value: configPreview.migrated,
+            value: profiles === current ? configPreview.migrated : { ...configPreview.migrated, profiles },
             sourceHash: configPreview.sourceHash
         },
         ...(options.codexHome === undefined ? {} : { codexHome: options.codexHome }),

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

@@ -0,0 +1,105 @@
+import { readdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { readPrivateFile, writePrivateFile } from "../security/permissions.js";
+const KINDS = new Set(["verify", "review", "finish"]);
+const ID = /^[A-Za-z0-9._-]{1,128}$/u;
+const TARGET = /^[a-z][a-z0-9-]{0,31}$/u;
+const FILE = /^(verify|review|finish)-(\d{1,10})-(\d{1,10})\.json$/u;
+const NOOP = { update: async () => { }, end: async () => { } };
+export function activityDirectory(commonDir) {
+    return join(commonDir, "agent-ops", "office-activity");
+}
+/** Keeps only the allowlisted, well-formed fields; null when the record cannot stand. */
+export function activityValue(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return null;
+    const item = value;
+    if (!KINDS.has(item.kind) || typeof item.pid !== "number" || !Number.isInteger(item.pid) || item.pid <= 0 ||
+        typeof item.root !== "string" || item.root.length === 0 || item.root.length > 4096 ||
+        typeof item.startedAt !== "string" || Number.isNaN(Date.parse(item.startedAt)))
+        return null;
+    const id = (field) => typeof field === "string" && ID.test(field) ? field : undefined;
+    const targets = Array.isArray(item.targets) ? item.targets.filter((t) => typeof t === "string" && TARGET.test(t)).slice(0, 2) : undefined;
+    const round = item.round === 1 || item.round === 2 ? item.round : undefined;
+    const target = typeof item.target === "string" && TARGET.test(item.target) ? item.target : undefined;
+    const taskId = id(item.taskId), sessionId = id(item.sessionId), worktree = id(item.worktree);
+    return { kind: item.kind, pid: item.pid, root: item.root, startedAt: item.startedAt,
+        ...(taskId === undefined ? {} : { taskId }), ...(sessionId === undefined ? {} : { sessionId }), ...(worktree === undefined ? {} : { worktree }),
+        ...(targets === undefined || targets.length === 0 ? {} : { targets }), ...(round === undefined ? {} : { round }), ...(target === undefined ? {} : { target }) };
+}
+let sequence = 0;
+/** Starts a record; returns a handle whose writes never throw. No common dir means no record. */
+export async function beginActivity(commonDir, start, options = {}) {
+    if (commonDir === undefined || commonDir.length === 0)
+        return NOOP;
+    const pid = options.pid ?? process.pid, startedAt = (options.now ?? (() => new Date()))().toISOString();
+    let current = activityValue({ ...start, pid, startedAt });
+    if (current === null)
+        return NOOP;
+    // One process may run several reviews at once (batch), so the name carries a sequence too.
+    const path = join(activityDirectory(commonDir), `${current.kind}-${pid}-${++sequence}.json`);
+    // Writes run one after another in call order, so a slow early write never lands over a later one,
+    // and none runs after end() has removed the record.
+    let queue = Promise.resolve(), ended = false;
+    const write = () => (queue = queue.then(async () => {
+        if (ended)
+            return;
+        try {
+            await writePrivateFile(path, JSON.stringify(current) + "\n", commonDir);
+        }
+        catch { /* display only */ }
+    }));
+    await write();
+    return {
+        update: async (patch) => { const next = activityValue({ ...current, ...patch }); if (next !== null) {
+            current = next;
+            await write();
+        } },
+        end: async () => { ended = true; await queue; try {
+            await rm(path, { force: true });
+        }
+        catch { /* display only */ } }
+    };
+}
+/** Runs `work` with a record present; the record goes when the work ends, however it ends. */
+export async function withActivity(commonDir, start, work) {
+    const handle = await beginActivity(commonDir, start).catch(() => NOOP);
+    try {
+        return await work(handle);
+    }
+    finally {
+        await handle.end().catch(() => undefined);
+    }
+}
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+/** Live records only: malformed files, files whose name disagrees with their content and dead processes are skipped. */
+export async function readActivities(commonDir, alive = processAlive) {
+    const directory = activityDirectory(commonDir);
+    const names = (await readdir(directory).catch(() => [])).filter(name => FILE.test(name)).sort().slice(0, 200);
+    const records = [];
+    for (const name of names) {
+        const match = FILE.exec(name);
+        const source = await readPrivateFile(join(directory, name), commonDir).catch(() => null);
+        if (source === null || source.length > 16 * 1024)
+            continue;
+        let value;
+        try {
+            value = activityValue(JSON.parse(source));
+        }
+        catch {
+            continue;
+        }
+        if (value === null || value.kind !== match[1] || value.pid !== Number(match[2]) || !alive(value.pid))
+            continue;
+        records.push(value);
+    }
+    return records;
+}