@kylecheng3146/agent-ops 0.6.0 → 0.7.1

package/README.md

@@ -56,6 +56,43 @@ Native authorization decisions retain redacted command scope and rationale;
 missing provider decisions remain unknown. Repair compares actual check outcomes
 and outstanding finding pins rather than source fingerprints.
 
+Office is a Preview feature, disabled by default. Enable it in the init/update
+selector (update keeps your current choice), or use explicit flags:
+
+```sh
+agent-ops update --office on
+agent-ops office
+# Disable later: agent-ops update --office off
+```
+
+It prints a tokened `http://127.0.0.1:<port>/` URL (also shown by `run start` and
+`run status`) to a read-only pixel office with cream walls, oak floors
+and sage furniture. The overview fits the viewport without scrolling: each run
+team shares a room, and each ordinary session has its own room, including sessions
+without a task or worktree. The furnished floorplan fills the page below the
+header, with a shared hallway between rooms. You control the Supervisor using
+arrow keys or WASD and can walk into each room; clicking a room also opens its
+larger detail view, with a return control. Characters move between planning, development,
+verification, review and integration areas. Short nameplates show their current
+work; room whiteboards show criteria progress, verification and review results,
+and questions waiting for an answer. Clicking a character shows task details,
+changed files and copyable commands. Chinese and English can be switched in the
+header; the viewer badge reads “You” in English and “你” in Chinese. The page remembers the choice and respects reduced-motion preferences.
+Supervisor movement and character animation run locally without model requests.
+Completed rooms move to Recently completed and remain for at most two hours.
+The page reads agent-ops state and `git diff` paths only, never transcripts or file
+contents. One Office serves every repository you work in: each Office-enabled
+repository registers itself when its sessions report, rooms wear their
+repository's nameplate, and a header menu filters the building to one
+repository. Repositories that are removed, opt out, or stay quiet for two hours
+leave the building. When enabled, managed ordinary sessions start your one
+server automatically; a newly started Office opens the browser once, and
+subsequent sessions in any repository reuse it. A finished worktree's room
+moves to Recently completed as soon as `worktree finish` merges it. The server exits after ten minutes without active runs or
+ordinary sessions. Ordinary-session presence follows hook activity; a crashed
+or silent session expires after 30 minutes without an event. Office failures
+remain advisory and never block session work.
+
 Native lifecycle reachability and framework probe conditions are recorded in
 [the capability probe](docs/harness/native-goal-probe.md); these observations do not
 establish external adoption or a reduction in review cost.
@@ -83,7 +120,7 @@ installation plan.
 
 The interactive multi-select screens start with no harness or profile selected.
 Choose at least one of `agy`, `codex`, `claude`, and `opencode`, and at least one of
-the `core`, `advisory`, `guardrails`, and `loop` profiles before confirming. For
+the `core`, `advisory`, `guardrails`, `loop`, and `run` profiles before confirming. For
 scripted use, `--harness all` selects all four harnesses; comma-separated
 selections such as `codex,opencode` are also supported. The legacy `both` value
 remains an alias for `codex,claude`.
@@ -200,6 +237,28 @@ agent-ops update \
   --dry-run --json
 ```
 
+### Automatic runs (`run` profile)
+
+`run` is an opt-in profile that also selects `core` and `loop`. With it, the
+Claude Code and Codex rules hand a change that needs more than five acceptance
+criteria to `agent-ops run` instead of splitting it into subtasks; five or fewer
+stay in the session. The agent writes the prompt verbatim plus its proposed
+criteria to the gitignored `.agent-ops/state/run-goal.md` from the main checkout
+(the worktree guard lets exactly that write through), then starts
+`agent-ops run --goal-file .agent-ops/state/run-goal.md --host claude --wait`
+(or `--host codex`, escalated like review) in the background and relays any
+question through `agent-ops run respond`. A start refused with
+`RUN_TARGET_REQUIRED`, `RUN_BACKGROUND_UNSUPPORTED`, `RUN_TARGET_DIRTY`, or
+`WORKTREE_NESTED` falls back to the subtask flow; `RUN_REPO_UNTRUSTED` stops and
+asks you. A run that ends without completing is reported with its status, last
+log events, and the `agent-ops run resume <id>` / `agent-ops run stop <id>`
+commands; it is never resumed automatically. agy keeps the subtask flow.
+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
+```
+
 ## Quick start from a source checkout
 
 For development or to run the repository version directly, use a source

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

@@ -12,11 +12,12 @@ export const COMMAND_NAMES = [
     "batch",
     "allow-stop",
     "worktree",
-    "run"
+    "run",
+    "office"
 ];
 const COMMAND_SET = new Set(COMMAND_NAMES);
 const SCOPES = new Set(["project", "user"]);
-const PROFILES = new Set(["advisory", "core", "guardrails", "loop"]);
+const PROFILES = new Set(["advisory", "core", "guardrails", "loop", "run"]);
 // opencode is absent: it has no read-only flag, so it cannot review.
 const REVIEW_TARGETS = new Set(["agy", "claude", "codex"]);
 export const WORKTREE_ACTIONS = ["add", "commit", "finish", "list", "resume", "remove"];
@@ -93,6 +94,7 @@ export function parseArgs(argv) {
     let checkAuth = false;
     const checkAuthTargets = [];
     let completionGate;
+    let office;
     let dryRun = false;
     let json = false;
     let yes = false;
@@ -316,6 +318,16 @@ export function parseArgs(argv) {
                 }
                 completionGate = true;
                 break;
+            case "--office": {
+                if (office !== undefined)
+                    duplicate(token);
+                const value = readOptionValue(argv, index, token);
+                if (value !== "on" && value !== "off")
+                    invalidValue(token, value);
+                office = value;
+                index += 1;
+                break;
+            }
             case "--worktree": {
                 if (worktree !== undefined) {
                     duplicate(token);
@@ -510,6 +522,7 @@ export function parseArgs(argv) {
             evidence.length > 0 ||
             reviewTargets.length > 0 ||
             completionGate !== undefined ||
+            office !== undefined ||
             sessionId !== undefined ||
             base !== undefined ||
             parentBase !== undefined ||
@@ -600,6 +613,9 @@ export function parseArgs(argv) {
     if (completionGate !== undefined && command !== "init") {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--completion-gate may be used only with init.");
     }
+    if (office !== undefined && command !== "init" && command !== "update") {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--office may be used only with init or update.");
+    }
     if (worktree !== undefined && command !== "init" && command !== "update") {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--worktree may be used only with init or update.");
     }
@@ -776,6 +792,7 @@ export function parseArgs(argv) {
         ...(intent === undefined ? {} : { intent }),
         ...(reviewTargets.length === 0 ? {} : { reviewTargets }),
         ...(completionGate === undefined ? {} : { completionGate }),
+        ...(office === undefined ? {} : { office }),
         ...(criteria.length === 0 ? {} : { criteria }),
         ...(criterionFiles.length === 0 ? {} : { criterionFiles }),
         ...(criteriaFile === undefined ? {} : { criteriaFile }),

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

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
-import { productionRunContext } from "./run-deps.js";
+import { productionRunContext, runPhaseObserver } 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 { readFile, readdir, stat } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
@@ -223,7 +225,7 @@ else if (argv[0] === "hook") {
         stdin: process.stdin,
         writeStdout: (value) => process.stdout.write(value),
         writeStderr: (value) => process.stderr.write(value)
-    }, CLI_VERSION, { worktree: worktreeDependencies() });
+    }, CLI_VERSION, { worktree: worktreeDependencies(), office: observeOfficeSession });
 }
 else {
     process.exitCode = await runCli(argv, {
@@ -249,7 +251,11 @@ else {
                     throw new AgentOpsError("RUN_POLICY_COORDINATOR_REQUIRED", "Run workers must request scoped policy review from the coordinator; permanent trust and host rules cannot be changed by the run.");
                 if (args.command === "run") {
                     const context = await productionRunContext(root);
-                    return await runRunCommand({ args, ...context, root: context.mainRoot });
+                    return await runRunCommand({ args, ...context, root: context.mainRoot, office: async () => await ensureBackgroundOffice(root, undefined, openOfficeBrowser) });
+                }
+                if (args.command === "office") {
+                    return await runOfficeCommand({ ensure: async () => await ensureBackgroundOffice(root, undefined, openOfficeBrowser),
+                        foreground: async (onUrl) => await serveOffice(root, onUrl), writeStdout: (text) => { process.stdout.write(text); } });
                 }
                 if (args.command === "init") {
                     const store = trustStore();
@@ -406,6 +412,7 @@ else {
                         trustStore: store,
                         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),
                         promptWorktree: async (message) => await selectYesNo(message, { input: process.stdin, output: process.stdout }, true),
                         ...(updateArgs.targetVersion === undefined
                             ? {}
@@ -447,7 +454,9 @@ else {
                             cwd: root,
                             sessionId: sessionId ?? await resolveCommandSessionId(root),
                             parentTaskId: args.taskId,
-                            deps: worktreeDependencies()
+                            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) })
                         });
                     }
                     const createConfig = args.action === "create"
@@ -517,6 +526,7 @@ else {
                         : async (request) => await withReviewSlot({
                             dir: slotDir,
                             signal,
+                            holder: { root, ...(reviewArgs.taskId === undefined ? {} : { taskId: reviewArgs.taskId }) },
                             onWait: (line) => {
                                 process.stderr.write(`${progressPrefix}${line}\n`);
                             }

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

@@ -30,6 +30,7 @@ Commands:
   verify     Run configured verification
   review     Run an independent review or show recorded reports
   run        Start or control a supervised Claude/Codex native goal
+  office     Open the local pixel office (Preview; opt-in)
   batch      Verify and review a parent task's subtasks together
   allow-stop Grant one fingerprint-bound completion-gate Stop permit (requires --session)
   agy-run    Run headless agy with a process-exit completion recheck
@@ -40,9 +41,10 @@ Options:
   --scope <project|user>
   --harness <all|both|agy|claude|codex|opencode|comma-separated>  Init/update/uninstall; review uses configured targets
   --hook-target <harness=surface-id>  Repeatable advanced init/update option
-  --profile <core|advisory|guardrails|loop>  Repeatable
+  --profile <core|advisory|guardrails|loop|run>  Repeatable
   --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)
   --worktree <auto|off>              Init/update: configure session worktree isolation
   --check-auth                        Doctor only: probe selected review targets'
                                       authentication with one real call
@@ -72,6 +74,20 @@ Options:
  * rejected.
  */
 export const COMMAND_HELP_TEXT = {
+    office: `Usage: agent-ops office [--json]
+
+Office (Preview) is opt-in: select it during init/update or run
+agent-ops update --office on. Disable with --office off. A missing choice is off.
+
+Print the URL of this repository's office: a read-only pixel page on
+127.0.0.1. All run teams and ordinary sessions appear in a single-screen room
+overview; walk the Supervisor with arrows/WASD or click a room for details.
+Switch Chinese/English in the header. Movement and animation run locally.
+When enabled, managed sessions start the shared server automatically. A new Office opens the
+browser once; later sessions reuse it. It exits after 10 minutes without active
+runs or sessions. Recently completed rooms remain for at most 2 hours.
+The URL carries an access token; do not share it.
+`,
     run: `Usage: agent-ops run [start] "<goal>" --host <claude|codex> [--jobs <1|2>] [--time-budget <60m>] [--wait] [--json]
        agent-ops run [start] --goal-file <path> --host <claude|codex>
        agent-ops run <status|logs|resume|stop> <run-id> [--json]
@@ -88,9 +104,10 @@ Options:
   --scope <project|user>
   --harness <all|both|agy|claude|codex|opencode|comma-separated>
   --hook-target <harness=surface-id>   Repeatable
-  --profile <core|advisory|guardrails|loop>  Repeatable
+  --profile <core|advisory|guardrails|loop|run>  Repeatable
   --review-target <codex|agy|claude>   Repeatable, in fallback-chain order
   --completion-gate                    Enable the project-loop completion gate
+  --office <on|off>                   Office (Preview); default off, update preserves choice
   --worktree <auto|off>                Configure session worktree isolation
   --dry-run                            Print the plan without writing
   --json
@@ -134,6 +151,7 @@ Options:
   --scope <project|user>
   --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
   --worktree <auto|off>        Configure session worktree isolation
   --dry-run
   --json

package/dist/packages/cli/src/codex-loop-process.js

@@ -1,4 +1,5 @@
-import { PROJECT_LOOP_EVENTS, runProjectLoop } from "../../../runtime/src/hooks/codex-loop.js";
+import { PROJECT_LOOP_EVENTS, resolveProjectLoopRoot, runProjectLoop } from "../../../runtime/src/hooks/codex-loop.js";
+import { officeEnabled, officeLoopPhaseHint } from "./office-entry.js";
 const MAX_LOOP_INPUT_BYTES = 64 * 1024;
 function isLoopHarness(value) {
     return value === "claude" || value === "codex";
@@ -43,10 +44,26 @@ export async function runLoopProcess(argv, io, dependencies = {}) {
         return 0;
     }
     try {
+        const input = parseInput(await readStdin(io.stdin));
+        const inputIsObject = typeof input === "object" && input !== null && !Array.isArray(input);
+        const managedRoot = inputIsObject
+            ? await resolveProjectLoopRoot(input, dependencies.root ?? process.cwd(), harness).catch(() => null)
+            : null;
+        if (dependencies.office !== undefined && managedRoot !== null && await officeEnabled(managedRoot)) {
+            const phase = officeLoopPhaseHint(input, managedRoot);
+            void dependencies.office({
+                root: managedRoot,
+                harness,
+                event,
+                input,
+                validated: true,
+                ...(phase === undefined ? {} : { phase })
+            }).catch(() => undefined);
+        }
         const result = await runProjectLoop({
             harness,
             event,
-            input: parseInput(await readStdin(io.stdin)),
+            input,
             root: dependencies.root ?? process.cwd(),
             ...(dependencies.now === undefined ? {} : { now: dependencies.now }),
             ...(dependencies.gitStatus === undefined

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

@@ -9,6 +9,7 @@ import { renderReviewDetails, renderReviewHighlights } from "../../../../runtime
 import { calculateSourceFingerprint } from "../../../../runtime/src/verify/source-fingerprint.js";
 import { okEnvelope } from "../output.js";
 import { readFinishedReview } from "./review-show.js";
+import { criteriaProgress } from "../../../../runtime/src/run/phase.js";
 import { prepareRunIntegration, readRunIntegrationProof, abandonPreparedRunIntegration } from "../../../../runtime/src/run/integration.js";
 /** The child process runs the existing CLI in the candidate checkout. */
 export async function runAdvanceStep(cwd, args) {
@@ -132,10 +133,26 @@ export async function runAdvanceCommand(options) {
         if (noChangePaths !== undefined)
             for (const task of ordered)
                 await deps.tasks(record.path).recordEvidence(task.task.id, {}, undefined, noChangePaths);
+        const onPhase = options.onPhase ?? (async () => { });
+        await onPhase("verifying");
         for (const task of ordered) {
-            requirePass(await step(record.path, ["verify", "--task", task.task.id, "--base", target]), `Verify ${task.task.id}`);
+            const verified = await step(record.path, ["verify", "--task", task.task.id, "--base", target]);
+            await onPhase("verifying", { taskId: task.task.id, update: { verify: verified.status === "ok" ? "PASS" : "FAIL",
+                    ...criteriaProgress(task.task.criteria, verified.data?.report ?? {}) } });
+            requirePass(verified, `Verify ${task.task.id}`);
         }
-        const reviewMode = await reviewFinalTree(step, record.path, parent.task.id, ordered.map(({ task }) => task.id), target);
+        await onPhase("reviewing");
+        let reviewMode;
+        try {
+            reviewMode = await reviewFinalTree(step, record.path, parent.task.id, ordered.map(({ task }) => task.id), target);
+        }
+        catch (failure) {
+            for (const { task } of ordered)
+                await onPhase("reviewing", { taskId: task.id, update: { review: "FAIL" } });
+            throw failure;
+        }
+        for (const { task } of ordered)
+            await onPhase("integrating", { taskId: task.id, update: { review: "PASS", passed: task.criteria.length, total: task.criteria.length } });
         const scope = await resolveReviewScope({ root: record.path, runner: runner(deps, record.path), base: target,
             ...(noChangePaths === undefined ? {} : { noChangePaths }) });
         const sourceFingerprint = await calculateSourceFingerprint(record.path, scope, runner(deps, record.path));

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

@@ -13,6 +13,7 @@ export function formatInstallPlan(plan, trust, warnings = []) {
         title: "Installation plan",
         metadata: [
             `Scope: ${plan.scope}`,
+            `Office (Preview): ${plan.config.features.office?.enabled === true ? "enabled" : "disabled"}`,
             `Harness: ${plan.harness}`,
             `Profiles: ${plan.profiles.join(", ")}`,
             ...(plan.config.worktree === undefined
@@ -103,6 +104,7 @@ export async function runInitCommand(options) {
         scope: args.scope,
         harness: args.harness,
         profiles: args.profiles,
+        ...(args.office === undefined ? {} : { officeEnabled: args.office === "on" }),
         adapters: options.adapters,
         ...(options.toolkitVersion === undefined
             ? {}

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

@@ -0,0 +1,20 @@
+import { AgentOpsError } from "../../../../runtime/src/fs/paths.js";
+import { errorEnvelope, okEnvelope } from "../output.js";
+export async function runOfficeCommand(options) {
+    try {
+        const url = await options.ensure();
+        if (url !== null)
+            return okEnvelope("OFFICE_READY", { url, text: `Office (Preview): ${url}` });
+        let shown = "";
+        await options.foreground((served) => {
+            shown = served;
+            options.writeStdout(`Office (Preview): ${served}\nServing in the foreground; it exits 10 minutes after no run or session is active.\n`);
+        });
+        return okEnvelope("OFFICE_CLOSED", { url: shown, text: "Office closed: no run was active for 10 minutes." });
+    }
+    catch (cause) {
+        if (cause instanceof AgentOpsError)
+            return errorEnvelope(cause.code, cause.message);
+        throw cause;
+    }
+}

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

@@ -203,17 +203,23 @@ async function preflightReview(options, context, sourceFingerprint) {
         options.gitRunner === undefined) {
         return { ok: false, reason: "stale-verification" };
     }
-    if (context.criteria.some((criterion) => !options.config.verification.commands.some(({ id, required }) => required && (criterion.verifierIds ?? []).includes(id)))) {
+    const typed = (criterion) => {
+        const owner = context.criterionOwners?.get(criterion.id);
+        return context.records.find(r => r.task.id === (owner?.taskId ?? context.taskId))?.task.criteria
+            .find(c => c.id === (owner?.criterionId ?? criterion.id))?.acceptance !== undefined;
+    };
+    // A typed criterion (review-only included) is held to every required
+    // repository command below, so only a legacy one must name its own.
+    if (context.criteria.some((criterion) => !typed(criterion) && !options.config.verification.commands.some(({ id, required }) => required && (criterion.verifierIds ?? []).includes(id)))) {
         return { ok: false, reason: "missing-verification-evidence" };
     }
     const configHash = calculateConfigHash(options.config);
     const commands = [];
     for (const criterion of context.criteria) {
         const owner = context.criterionOwners?.get(criterion.id);
-        const typed = context.records.find(r => r.task.id === (owner?.taskId ?? context.taskId))?.task.criteria
-            .find(c => c.id === (owner?.criterionId ?? criterion.id))?.acceptance !== undefined;
+        const isTyped = typed(criterion);
         for (const commandId of new Set([...(criterion.verifierIds ?? []),
-            ...(typed ? options.config.verification.commands.filter(c => c.required).map(c => c.id) : [])])) {
+            ...(isTyped ? options.config.verification.commands.filter(c => c.required).map(c => c.id) : [])])) {
             const command = options.config.verification.commands.find((candidate) => candidate.id === commandId);
             if (command === undefined) {
                 return { ok: false, reason: "missing-verification-evidence" };

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

@@ -66,6 +66,10 @@ async function answerFromArgs(args, root) {
  * External lifecycle surface. The command only starts/controls a supervisor;
  * it never marks the task complete or treats a native process exit as proof.
  */
+async function withOffice(options, response) {
+    const url = await options.office?.().catch(() => null) ?? null;
+    return url === null ? response : { ...response, officeUrl: url, text: `${response.text}\nOffice (Preview): ${url}` };
+}
 export async function runRunCommand(options) {
     const action = actionOf(options.args);
     try {
@@ -83,12 +87,12 @@ export async function runRunCommand(options) {
             const state = options.args.wait === true && options.waitForCompletion !== undefined
                 ? await options.waitForCompletion(result.state.runId)
                 : result.state;
-            const response = data(action, { ...result, state });
+            const response = await withOffice(options, data(action, { ...result, state }));
             return okEnvelope(options.args.wait === true ? "RUN_FINISHED" : "RUN_STARTED", response);
         }
         const runId = runIdOf(options.args);
         if (action === "status")
-            return okEnvelope("RUN_STATUS", stateData(action, await options.service.status(runId), `Read run ${runId}.`));
+            return okEnvelope("RUN_STATUS", await withOffice(options, stateData(action, await options.service.status(runId), `Read run ${runId}.`)));
         if (action === "logs") {
             const state = await options.service.status(runId);
             const events = await options.service.logs(runId);

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

@@ -1,5 +1,6 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
+import { loadConfigFile } from "../../../../runtime/src/config/load.js";
 import { detectWorktreeSetup } from "../../../../runtime/src/install/parallel-setup.js";
 import { applyUpdatePlan, createUpdatePlan } from "../../../../runtime/src/install/update.js";
 import { okEnvelope } from "../output.js";
@@ -15,6 +16,7 @@ export function formatUpdatePlan(plan, trust) {
         title: "Update plan",
         metadata: [
             `Target version: ${plan.targetVersion}`,
+            `Office (Preview): ${plan.installation.config.features.office?.enabled === true ? "enabled" : "disabled"}`,
             `Harness: ${plan.installation.harness.join(", ")}`,
             ...(plan.installation.config.worktree === undefined
                 ? []
@@ -95,9 +97,15 @@ export async function runUpdateCommand(options) {
             };
         }
     }
+    let officeEnabled = options.args.office === undefined ? undefined : options.args.office === "on";
+    if (officeEnabled === undefined && options.promptOffice !== undefined && options.isTTY && !options.args.yes) {
+        const { config } = await loadConfigFile(join(options.root, ".agent-ops", "config.json"));
+        officeEnabled = await options.promptOffice("Enable Office (Preview)?", config.features.office?.enabled === true);
+    }
     const plan = await createUpdatePlan({
         root: options.root,
         adapters: options.adapters,
+        ...(officeEnabled === undefined ? {} : { officeEnabled }),
         ...(options.args.harness === undefined
             ? {}
             : { harness: options.args.harness }),

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

@@ -16,6 +16,7 @@ export const DEFAULT_CONFIG = {
     profiles: [],
     verification: { commands: [] },
     features: {
+        office: { enabled: false },
         stopVerification: {
             enabled: false
         },
@@ -35,7 +36,7 @@ export const DEFAULT_CONFIG = {
  */
 export function projectConfigRoot(root) {
     try {
-        const common = execFileSync("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+        const common = execFileSync("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], windowsHide: true }).trim();
         if (basename(common) !== ".git") {
             return root;
         }
@@ -183,7 +184,8 @@ export function repositoryRemoteUrl(root) {
     try {
         return execFileSync("git", ["config", "--get", "remote.origin.url"], {
             cwd: root,
-            encoding: "utf8"
+            encoding: "utf8",
+            windowsHide: true
         }).trim();
     }
     catch {
@@ -213,7 +215,7 @@ export async function repositoryTrust(root, config, cliVersion) {
 export async function runPolicyContext(root) {
     let common;
     try {
-        common = execFileSync("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+        common = execFileSync("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], windowsHide: true }).trim();
     }
     catch {
         return null;
@@ -233,8 +235,8 @@ export async function runPolicyContext(root) {
     let proof = false;
     if (proofProcess != null && String(proofProcess.processId) === process.env.AGENT_OPS_RUN_PROOF_PID) {
         try {
-            proof = execFileSync("ps", ["-o", "pgid=", "-p", String(process.pid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() === String(proofProcess.processId) &&
-                execFileSync("ps", ["-o", "lstart=", "-p", String(proofProcess.processId)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() === proofProcess.processIdentity;
+            proof = execFileSync("ps", ["-o", "pgid=", "-p", String(process.pid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], windowsHide: true }).trim() === String(proofProcess.processId) &&
+                execFileSync("ps", ["-o", "lstart=", "-p", String(proofProcess.processId)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], windowsHide: true }).trim() === proofProcess.processIdentity;
         }
         catch {
             proof = false;

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

@@ -4,8 +4,9 @@
 import { CLI_VERSION } from "./version.js";
 import { runHookProcess } from "./hook-process.js";
 import { worktreeDependencies } from "./parallel-deps.js";
+import { observeOfficeSession } from "./office-entry.js";
 process.exitCode = await runHookProcess(process.argv.slice(2), {
     stdin: process.stdin,
     writeStdout: (value) => process.stdout.write(value),
     writeStderr: (value) => process.stderr.write(value)
-}, CLI_VERSION, { worktree: worktreeDependencies() });
+}, CLI_VERSION, { worktree: worktreeDependencies(), office: observeOfficeSession });

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

@@ -9,6 +9,7 @@ import { resolveContainedPath } from "../../../runtime/src/fs/paths.js";
 import { redactSecrets } from "../../../runtime/src/security/redact.js";
 import { claudeStopRecursionMarker } from "../../../runtime/src/adapters/claude/input.js";
 import { HARNESS_IDS, harnessDescriptor } from "../../../runtime/src/install/harness.js";
+import { officePhaseHint } from "./office-entry.js";
 import { evaluateWorktreeEnter } from "../../../runtime/src/parallel/enter.js";
 import { evaluateWorktreeWrite, resolveMainRoot } from "../../../runtime/src/parallel/guard.js";
 import { ensureSessionWorktree, recordSessionOrigin } from "../../../runtime/src/parallel/service.js";
@@ -284,7 +285,11 @@ export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
                     parsedInput !== null &&
                     typeof parsedInput.projectRoot === "string"
                     ? parsedInput.projectRoot
-                    : undefined;
+                    : typeof parsedInput === "object" &&
+                        parsedInput !== null &&
+                        typeof parsedInput.cwd === "string"
+                        ? parsedInput.cwd
+                        : undefined;
             if (inputRoot !== undefined) {
                 root = inputRoot;
             }
@@ -326,6 +331,22 @@ export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
             ? await repositoryTrust(root, config, cliVersion)
             : await dependencies.trust(root, config, cliVersion);
         const trusted = trustStatus === "TRUSTED";
+        if (dependencies.office !== undefined && config.features.office?.enabled === true) {
+            const normalized = normalizeHookInput(harnessId, parsedInput);
+            if (normalized !== null) {
+                const phase = officePhaseHint(normalized);
+                void dependencies.office({
+                    root,
+                    harness: harnessId,
+                    event: hookEvent,
+                    input: parsedInput,
+                    validated: true,
+                    ...(normalized.sessionId === undefined ? {} : { sessionId: normalized.sessionId }),
+                    ...(normalized.agentId === undefined ? {} : { agentId: normalized.agentId }),
+                    ...(phase === undefined ? {} : { phase })
+                }).catch(() => undefined);
+            }
+        }
         const gitRunner = dependencies.gitRunner ?? defaultGitRunner(root);
         const processRunner = dependencies.processRunner ?? new NodeVerificationProcessRunner();
         const stopVerification = shouldBuildStopVerification(harnessId, event, config, parsedInput)
@@ -383,7 +404,7 @@ export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
                     ? { action: "continue", status: "UNKNOWN", code: "WORKTREE_GUARD_UNAVAILABLE" }
                     : await evaluateWorktreeWrite(mainRoot, write.paths, write.sessionId, dependencies.worktree === undefined
                         ? undefined
-                        : async (sessionId, agentId) => (await ensureSessionWorktree(dependencies.worktree, { cwd: mainRoot, sessionId, ...(agentId === undefined ? {} : { agentId }) })).path, write.agentId);
+                        : async (sessionId, agentId) => (await ensureSessionWorktree(dependencies.worktree, { cwd: mainRoot, sessionId, ...(agentId === undefined ? {} : { agentId }) })).path, write.agentId, config.profiles.includes("run"));
             }
             : undefined;
         const worktreeEnter = config.worktree?.mode === "auto"

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

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 // Entry point used only by the generated project-local loop launchers.
 import { runLoopProcess } from "./codex-loop-process.js";
+import { observeOfficeSession } from "./office-entry.js";
 process.exitCode = await runLoopProcess(process.argv.slice(2), {
     stdin: process.stdin,
     writeStdout: (value) => process.stdout.write(value),
     writeStderr: (value) => process.stderr.write(value)
-});
+}, { office: observeOfficeSession });