@kylecheng3146/agent-ops 0.6.0 → 0.7.0

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

@@ -0,0 +1,230 @@
+import { fileURLToPath } from "node:url";
+import { basename, join } from "node:path";
+import { createHash } from "node:crypto";
+import { spawn } from "node:child_process";
+import { collectOfficeInput } from "../../../runtime/src/office/collect.js";
+import { claimOffice, createOfficeServer, ensureOffice, readLiveOffice, officeUrl, releaseOffice } from "../../../runtime/src/office/server.js";
+import { buildOfficeSnapshot } from "../../../runtime/src/office/snapshot.js";
+import { recordOfficeSession } 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 } from "../../../runtime/src/security/permissions.js";
+import { worktreeDependencies } from "./parallel-deps.js";
+import { normalizeShellHookEvent } from "../../../runtime/src/hooks/shell.js";
+import { AgentOpsError } from "../../../runtime/src/fs/paths.js";
+import { loadEffectiveConfig } from "./context.js";
+const entry = fileURLToPath(import.meta.url);
+/** Missing or invalid config keeps this Preview disabled. */
+export async function officeEnabled(cwd) {
+    if (process.env.AGENT_OPS_DISABLE === "1")
+        return false;
+    try {
+        return (await loadEffectiveConfig(cwd, "project")).config.features.office?.enabled === true;
+    }
+    catch {
+        return false;
+    }
+}
+async function requireOffice(cwd) {
+    if (!(await officeEnabled(cwd))) {
+        throw new AgentOpsError("OFFICE_PREVIEW_DISABLED", "Office (Preview) is disabled. Enable it with agent-ops update --office on.");
+    }
+}
+function recordValue(input, key) {
+    if (typeof input !== "object" || input === null || Array.isArray(input))
+        return undefined;
+    return input[key];
+}
+function observationInput(input) {
+    return typeof input === "object" && input !== null && !Array.isArray(input);
+}
+function firstText(...values) {
+    return values.find((value) => typeof value === "string" && value.length > 0 && value.length <= 256 && !/[\0\r\n]/u.test(value));
+}
+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" : "activity";
+}
+/** Phase hints come only from normalized native event kinds and exact agent-ops argv. */
+export function officePhaseHint(event) {
+    if (event.event === "file-write" || event.event === "content")
+        return "implementing";
+    const commands = event.event === "command"
+        ? [event]
+        : event.event === "command-batch"
+            ? event.commands
+            : [];
+    let phase;
+    for (const command of commands) {
+        if (basename(command.command) !== "agent-ops")
+            continue;
+        const action = command.args[0];
+        const next = action === "verify"
+            ? "verifying"
+            : action === "review"
+                ? "reviewing"
+                : action === "worktree" && command.args[1] === "finish"
+                    ? "integrating"
+                    : action === "task" && command.args[1] === "complete"
+                        ? "integrating"
+                        : action === "task"
+                            ? "planning"
+                            : undefined;
+        if (next === "integrating" || next === "reviewing" || next === "verifying")
+            phase = next;
+        else if (phase === undefined && next !== undefined)
+            phase = next;
+    }
+    return phase;
+}
+/** Loop adapters expose Bash and native edit events with the same safe shape. */
+export function officeLoopPhaseHint(input, root) {
+    if (!observationInput(input))
+        return undefined;
+    const tool = input.tool_name;
+    if (tool === "Edit" || tool === "Write" || tool === "NotebookEdit" || tool === "FileWrite")
+        return "implementing";
+    if (tool !== "Bash")
+        return undefined;
+    const toolInput = recordValue(input, "tool_input");
+    const command = recordValue(toolInput, "command");
+    return typeof command === "string" ? officePhaseHint(normalizeShellHookEvent(command, root)) : undefined;
+}
+/** Records hook presence and starts Office at the production process boundary. */
+export async function observeOfficeSession(options) {
+    if (process.env.AGENT_OPS_DISABLE === "1")
+        return;
+    if (options.validated !== true)
+        return;
+    // Host hooks with malformed or absent input are fail-open and must not
+    // create a server from an unrelated process cwd.
+    if (!observationInput(options.input))
+        return;
+    const identity = sessionIdentity(options);
+    if (identity === undefined)
+        return;
+    try {
+        if (!(await officeEnabled(options.root)))
+            return;
+        const { mainRoot, commonDir } = await checkouts(options.root);
+        if (identity !== undefined) {
+            await recordOfficeSession({
+                sessionId: identity,
+                harness: options.harness,
+                projectRoot: mainRoot,
+                commonDir,
+                event: officeEvent(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 }),
+                ...(process.env.AGENT_OPS_TASK_ID === undefined ? {} : { taskId: process.env.AGENT_OPS_TASK_ID }),
+                ...(options.phase === undefined ? {} : { phase: options.phase }),
+                host: options.harness
+            });
+        }
+        // A resumed session may outlive the ten-minute idle shutdown. Reusing the
+        // same ensure path revives that repository server without creating a tab
+        // unless this call actually wins a new-server start claim.
+        if (options.event !== "Stop")
+            await ensureBackgroundOffice(options.root, undefined, openOfficeBrowser);
+    }
+    catch {
+        // Office is display-only; a missing Git checkout, lock or launcher never blocks a host hook.
+    }
+}
+async function checkouts(cwd) {
+    return await resolveCheckouts(worktreeDependencies(), cwd);
+}
+/** Serve the office until no run has been active for the idle window. */
+export async function serveOffice(cwd, onUrl = () => { }, openBrowser) {
+    await requireOffice(cwd);
+    const { mainRoot, commonDir } = await checkouts(cwd);
+    // ponytail: one shared 1s snapshot so several polling tabs cost one git scan
+    let cached = null;
+    const snapshot = () => {
+        if (cached === null || Date.now() - cached.at > 1000)
+            cached = { at: Date.now(), value: collectOfficeInput(mainRoot, commonDir).then(buildOfficeSnapshot) };
+        return cached.value;
+    };
+    let finish = () => { };
+    const idle = new Promise((resolve) => { finish = resolve; });
+    const office = createOfficeServer({ snapshot, onIdle: () => finish() });
+    const record = await claimOffice(commonDir, office);
+    if (record === null) {
+        const live = await readLiveOffice(commonDir);
+        if (live !== null)
+            onUrl(officeUrl(live));
+        return;
+    }
+    onUrl(officeUrl(record));
+    if (openBrowser !== undefined)
+        void openBrowser(officeUrl(record)).catch(() => undefined);
+    const timer = setInterval(() => {
+        void officeEnabled(cwd).then(enabled => enabled ? office.tick() : finish());
+    }, 15_000);
+    await idle;
+    clearInterval(timer);
+    await releaseOffice(commonDir, record);
+    await office.close();
+}
+/** Reuse the live server or start one under launchd; null where launchd is unavailable. */
+export async function ensureBackgroundOffice(cwd, launchd = new LaunchdController(), openBrowser) {
+    await requireOffice(cwd);
+    const { mainRoot, commonDir } = await checkouts(cwd);
+    const live = await readLiveOffice(commonDir);
+    if (live !== null)
+        return officeUrl(live);
+    let started = false;
+    const args = [entry, mainRoot];
+    if (!launchd.supported) {
+        const url = await ensureOffice(commonDir, async () => {
+            started = true;
+            await new Promise((resolve, reject) => {
+                const child = spawn(process.execPath, args, { cwd: mainRoot, detached: true, stdio: "ignore", windowsHide: true });
+                child.once("error", reject);
+                child.once("spawn", () => { child.unref(); resolve(); });
+            });
+        });
+        if (started && openBrowser !== undefined)
+            void openBrowser(url).catch(() => undefined);
+        return url;
+    }
+    const privateDirectory = join(commonDir, "agent-ops", "office");
+    const descriptor = createLaunchdDescriptor({
+        runId: "office-" + createHash("sha256").update(commonDir).digest("hex").slice(0, 12), workerId: "server",
+        privateDirectory, command: process.execPath, args,
+        cwd: mainRoot, pathEnvironment: process.env.PATH
+    });
+    const url = await ensureOffice(commonDir, async () => {
+        started = true;
+        // The descriptor write anchors on this directory, so it must exist first.
+        await ensurePrivateDirectory(privateDirectory, commonDir);
+        await launchd.writeDescriptor(descriptor);
+        // A server that exited idle stays loaded in launchd; reload it with the current descriptor.
+        await launchd.bootout(descriptor).catch(() => { });
+        await launchd.bootstrap(descriptor);
+    });
+    if (started && openBrowser !== undefined)
+        void openBrowser(url).catch(() => undefined);
+    return url;
+}
+export function openOfficeBrowser(url) {
+    const command = process.platform === "darwin"
+        ? "open"
+        : process.platform === "win32"
+            ? "rundll32.exe"
+            : "xdg-open";
+    const args = process.platform === "win32" ? ["url.dll,FileProtocolHandler", url] : [url];
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { detached: true, stdio: "ignore", windowsHide: true });
+        child.once("error", reject);
+        child.once("spawn", () => { child.unref(); resolve(); });
+    });
+}
+if (process.argv[1] === entry) {
+    await serveOffice(process.argv[2] ?? process.cwd(), () => { }, process.argv[3] === "--open" ? openOfficeBrowser : undefined);
+    process.exit(0);
+}

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

@@ -26,6 +26,7 @@ import { discoverPendingPolicyTransition, renewBoundPolicyTransition, currentPol
 import { nativeProcessIdentity } from "../../../runtime/src/run/transport.js";
 import { redactSecrets } from "../../../runtime/src/security/redact.js";
 import { RunControlService } from "../../../runtime/src/run/controls.js";
+import { recordRunPhase } from "../../../runtime/src/run/phase.js";
 /** Worktree construction happens before a native lease exists; it must never write global trust. */
 export async function runWorktreeDependencies(deps, state) {
     const policy = await readRunPolicy(state, await runRuntimeHash());
@@ -138,6 +139,12 @@ export async function renewPendingRunPolicy(repository, runId, journal) {
         renewedPolicyArtifact: currentPolicyArtifact(current), expectedJournalDigest: journal.artifactDigest, now: new Date(now).toISOString()
     });
 }
+/** The supervisor's final proof reports its stages into the run it belongs to. */
+export async function runPhaseObserver(cwd, runId, workerId) {
+    const { commonDir } = await resolveCheckouts(worktreeDependencies(), cwd);
+    const repository = new FileRunRepository(join(commonDir, "agent-ops", "runs"), commonDir);
+    return async (phase, progress) => await recordRunPhase(repository, runId, workerId, phase, progress);
+}
 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),
@@ -172,14 +179,14 @@ export async function productionRunContext(cwd, options = {}) {
             const workerId = `coordinator-${result.state.runId}`;
             const workerRoot = join(checkouts.mainRoot, ".worktrees", sessionWorktreeName(ownerSessionId));
             const now = new Date().toISOString();
-            const state = await repository.mutate(result.state.runId, current => ({ ...current,
+            const state = await repository.mutate(result.state.runId, current => ({ ...current, phase: "planning",
                 currentContractHash: current.goalHash,
                 tasks: [{ taskId: "planning-" + current.runId, dependencies: [], status: "ready", workerId,
                         deliveryDigest: null, sourceCommit: null, blockedReason: null }],
                 workers: [{ workerId, taskId: "planning-" + current.runId, host: current.host, ownerSessionId,
                         nativeSessionId: null, nativeJobId: null, worktree: workerRoot, processId: null, processIdentity: null,
                         generation: 1, status: "assigned", leaseExpiresAt: null, heartbeatAt: null, stopIntent: null,
-                        nativeGoalState: "inactive", lastFailure: null }],
+                        nativeGoalState: "inactive", lastFailure: null, phase: "planning" }],
                 budget: { ...current.budget, activeIntervals: [{ startMs: Date.parse(current.createdAt), endMs: null }], lastObservedAt: now } }));
             await mkdir(runDescriptor(state).privateDirectory, { recursive: true });
             await launchd.writeDescriptor(runDescriptor(state));

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

@@ -6,6 +6,7 @@ import { writeNoChangeDelivery, integrateSessionChildren } from "../../../runtim
 import { recordNativeRunUsage, recordReviewRunUsage, recordSavedReviewRunUsage } from "../../../runtime/src/run/usage.js";
 import { recordNativeRunAuthorization } from "../../../runtime/src/run/authorization.js";
 import { observeRunFailure } from "../../../runtime/src/run/verification.js";
+import { criteriaProgress, recordRunPhase } from "../../../runtime/src/run/phase.js";
 import { compareFailureObservations } from "../../../runtime/src/run/convergence.js";
 import { RunControlService } from "../../../runtime/src/run/controls.js";
 import { beginPolicyTransition, markPolicyTransitionStage, completePolicyTransition, discoverPendingPolicyTransition } from "../../../runtime/src/run/policy-transition.js";
@@ -195,6 +196,7 @@ export async function superviseNativeRun(root, runId) {
             await writeWorktreeRecord({ ...record, workerGeneration: worker.generation });
             const goal = await instructions(worker, diagnostic);
             const running = await supervisor.startWorker(runId, worker.workerId, worker.generation, goal);
+            await recordRunPhase(repository, runId, worker.workerId, (await repository.read(runId)).rootTaskId === null ? "planning" : "implementing");
             try {
                 await transport.activateRegistered(runId, running, goal);
             }
@@ -793,6 +795,7 @@ export async function superviseNativeRun(root, runId) {
                                 tasks: saved.tasks.map(node => node.taskId === worker.taskId ? { ...node, taskId: task.task.id } : node),
                                 workers: saved.workers.map(w => w.workerId === worker.workerId ? { ...w, taskId: task.task.id } : w) }));
                             response = { requestId: request.requestId, code: "RUN_PLAN_CREATED", task: task.task, contractHash: treeContractHash([task.task]) };
+                            await recordRunPhase(repository, runId, worker.workerId, "implementing", { taskId: task.task.id, update: { passed: 0, total: task.task.criteria.length } });
                             await instructions((await repository.read(runId)).workers.find(w => w.workerId === worker.workerId));
                         }
                         else if (request.action === "worker") {
@@ -829,10 +832,14 @@ export async function superviseNativeRun(root, runId) {
                             await supervisor.confirmHandoff(runId, handoff, { processDead: !observation.processAlive });
                             await assertRunDeliverySnapshot(worker.worktree, worker.taskId, head, contract, tasks);
                             const artifactRefs = [];
+                            await recordRunPhase(repository, runId, worker.workerId, "verifying");
                             for (const localTask of (await tasks.list()).filter(task => task.supersededBy === undefined && task.status !== "archived")) {
                                 if (head === record.base)
                                     await tasks.recordEvidence(localTask.task.id, {}, undefined, (await tasks.status({ taskId: worker.taskId })).noChangePaths);
                                 const result = await step(worker.worktree, ["verify", "--task", localTask.task.id, "--base", record.base], current);
+                                if (localTask.task.id === worker.taskId)
+                                    await recordRunPhase(repository, runId, worker.workerId, "verifying", { taskId: worker.taskId,
+                                        update: { verify: result.status === "ok" ? "PASS" : "FAIL", ...criteriaProgress(localTask.task.criteria, plain(result.data) && plain(result.data.report) ? result.data.report : {}) } });
                                 if (result.status !== "ok")
                                     throw new AgentOpsError(result.code, "Local verifier did not pass. Preserve the failed check diagnostics for repair.");
                                 artifactRefs.push(...Object.values((await tasks.status({ taskId: localTask.task.id })).evidence).flat());
@@ -847,6 +854,7 @@ export async function superviseNativeRun(root, runId) {
                             }
                             await supervisor.publishDelivery(runId, handoff, { noChange: head === record.base, artifactRefs });
                             await scheduler.markDelivered(runId, worker.taskId, deliveryDigest, head);
+                            await recordRunPhase(repository, runId, worker.workerId, "integrating");
                             response = { requestId: request.requestId, code: "RUN_WORKER_DELIVERED", taskId: worker.taskId, sourceCommit: head };
                         }
                         else if (request.action === "question") {
@@ -875,6 +883,7 @@ export async function superviseNativeRun(root, runId) {
                                     .recordEvidence(current.rootTaskId, {}, undefined, scope.changedFiles);
                             }
                             await stopAll("stop", false);
+                            await recordRunPhase(repository, runId, worker.workerId, "verifying");
                             const result = await advance(current);
                             if (result.status !== "ok")
                                 throw new AgentOpsError(result.code, "Final proof failed; inspect saved verifier and fresh review reports before repair.");

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

@@ -3,7 +3,7 @@ import { DEFAULT_REVIEW_TARGETS, REVIEW_TARGET_ORDER } from "../../../runtime/sr
 import { HARNESS_IDS, resolveHarnessSelection } from "../../../runtime/src/install/harness.js";
 import { selectOption, selectOptions } from "./ui.js";
 const SCOPES = new Set(["project", "user"]);
-const PROFILES = new Set(["advisory", "core", "guardrails", "loop"]);
+const PROFILES = new Set(["advisory", "core", "guardrails", "loop", "run"]);
 const DEFAULT_HARNESS = [];
 const REVIEW_TARGET_SET = new Set(REVIEW_TARGET_ORDER);
 const REVIEW_TARGET_CHOICES = DEFAULT_REVIEW_TARGETS.map((id) => ({
@@ -77,6 +77,11 @@ const PROFILE_CHOICES = [
         label: "loop",
         value: "loop",
         description: "Installs the local loop; agy uses its supported lifecycle subset and is reported as degraded."
+    },
+    {
+        label: "run",
+        value: "run",
+        description: "Adds loop; Claude Code and Codex hand changes needing more than five acceptance criteria to agent-ops run."
     }
 ];
 const WIZARD_SUBTITLE = "Safe setup for agy, Codex, Claude Code, and opencode with profile-driven rules, verification, and hooks.";
@@ -207,12 +212,17 @@ export async function completeInitChoices(args, io, setup = {}) {
                 }
             ], selectorIo))
             : undefined);
+        const office = args.office ?? (await selectOption("Enable Office (Preview)?", [
+            { label: "no", value: "off", description: "Default. Keep the pixel office disabled." },
+            { label: "yes", value: "on", description: "Show sessions and teams in a local, read-only pixel office." }
+        ], selectorIo));
         await probeReviewTargets(reviewTargets, setup);
         return {
             ...args,
             scope,
             harness,
             profiles,
+            office,
             ...(completionGate ? { completionGate: true } : {}),
             ...(reviewTargets.length === 0 ? {} : { reviewTargets }),
             ...(worktree !== undefined ? { worktree } : {})
@@ -226,7 +236,7 @@ export async function completeInitChoices(args, io, setup = {}) {
             selectHarness(await session.question(`Harness (${HARNESS_IDS.join(",")}): `));
         const profiles = args.profiles.length > 0
             ? args.profiles
-            : selectProfiles(await session.question("Profiles (core,advisory,guardrails,loop) [core]: "));
+            : selectProfiles(await session.question("Profiles (core,advisory,guardrails,loop,run) [core]: "));
         const completionGate = args.completionGate ?? (completionGateEligible(scope, harness, profiles)
             ? !/^(n|no)$/i.test((await session.question("Enable the recommended agy completion gate? [Y/n]: ")).trim())
             : false);
@@ -238,11 +248,13 @@ export async function completeInitChoices(args, io, setup = {}) {
         const worktree = args.worktree ?? (scope === "project"
             ? (!/^(n|no)$/i.test((await session.question("Enable Git worktree isolation for parallel agent sessions? [Y/n]: ")).trim()) ? "auto" : "off")
             : undefined);
+        const office = args.office ?? (affirmative(await session.question("Enable Office (Preview)? [y/N]: ")) ? "on" : "off");
         return {
             ...args,
             scope,
             harness,
             profiles,
+            office,
             ...(completionGate ? { completionGate: true } : {}),
             ...(reviewTargets.length === 0 ? {} : { reviewTargets }),
             ...(worktree !== undefined ? { worktree } : {})

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

@@ -54,13 +54,14 @@ export function buildAgyHookSettings(capabilities, runtimePath, platform = proce
         throw new AgentOpsError("AGY_HOOK_PATH_INVALID", "agy hook runtime path is invalid.");
     }
     const hooks = {};
-    if (capabilities.includes("lifecycle-summary") || capabilities.includes("project-loop")) {
+    if ((capabilities.includes("lifecycle-summary") || capabilities.includes("office-presence")) || capabilities.includes("project-loop")) {
         hooks.PreInvocation = [handler(runtimePath, "SessionStart", platform)];
     }
-    if (capabilities.includes("command-policy") || capabilities.includes("project-loop")) {
+    if ((capabilities.includes("command-policy") || capabilities.includes("office-presence")) || capabilities.includes("project-loop")) {
         hooks.PreToolUse = [{ matcher: "run_command", hooks: [handler(runtimePath, "PreToolUse", platform)] }];
     }
-    if (capabilities.includes("optional-stop-verify") ||
+    if (capabilities.includes("office-presence") ||
+        capabilities.includes("optional-stop-verify") ||
         capabilities.includes("completion-gate")) {
         hooks.Stop = [handler(runtimePath, "Stop", platform, capabilities.includes("completion-gate"))];
     }

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

@@ -1,4 +1,13 @@
 export const AGY_CAPABILITY_REGISTRATIONS = [
+    {
+        capability: "office-presence",
+        normalizedEvent: "session-start",
+        nativeEvent: "SessionStart",
+        hostEvent: "PreInvocation",
+        surfaceId: "agy-hooks",
+        support: "degraded",
+        runtimeFailure: "fail-open"
+    },
     {
         capability: "lifecycle-summary",
         normalizedEvent: "session-start",

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

@@ -110,10 +110,10 @@ export function buildClaudeHookSettings(capabilities, runtimePath, platform = pr
         }
     }
     else {
-        if (capabilities.includes("lifecycle-summary")) {
+        if (capabilities.includes("lifecycle-summary") || capabilities.includes("office-presence")) {
             hooks.SessionStart = [matcherGroup("SessionStart", runtimePath)];
         }
-        if (capabilities.includes("command-policy")) {
+        if (capabilities.includes("command-policy") || capabilities.includes("office-presence")) {
             hooks.PreToolUse = [matcherGroup("PreToolUse", runtimePath)];
         }
     }
@@ -122,7 +122,7 @@ export function buildClaudeHookSettings(capabilities, runtimePath, platform = pr
     if (capabilities.includes("completion-gate")) {
         hooks.Stop = [matcherGroup("Stop", runtimePath, true)];
     }
-    else if (capabilities.includes("optional-stop-verify")) {
+    else if (capabilities.includes("optional-stop-verify") || capabilities.includes("office-presence")) {
         hooks.Stop = [matcherGroup("Stop", runtimePath)];
     }
     return { hooks };

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

@@ -14,6 +14,14 @@ export function claudeNonInteractiveTrust(printMode) {
     return printMode ? "dialog-skipped" : "interactive-dialog";
 }
 export const CLAUDE_CAPABILITY_REGISTRATIONS = [
+    {
+        capability: "office-presence",
+        normalizedEvent: "session-start",
+        nativeEvent: "SessionStart",
+        surfaceId: "claude-settings",
+        support: "supported",
+        runtimeFailure: "fail-open"
+    },
     {
         capability: "lifecycle-summary",
         normalizedEvent: "session-start",

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

@@ -79,14 +79,14 @@ export function buildCodexHookConfig(capabilities, runtimePath) {
         }
     }
     else {
-        if (capabilities.includes("lifecycle-summary")) {
+        if (capabilities.includes("lifecycle-summary") || capabilities.includes("office-presence")) {
             hooks.SessionStart = [matcherGroup("SessionStart", runtimePath)];
         }
-        if (capabilities.includes("command-policy")) {
+        if (capabilities.includes("command-policy") || capabilities.includes("office-presence")) {
             hooks.PreToolUse = [matcherGroup("PreToolUse", runtimePath)];
         }
     }
-    if (capabilities.includes("optional-stop-verify")) {
+    if (capabilities.includes("optional-stop-verify") || capabilities.includes("office-presence")) {
         hooks.Stop = [matcherGroup("Stop", runtimePath)];
     }
     return {

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

@@ -14,6 +14,14 @@ export function codexMatcherSupport(event) {
     return event === "PreToolUse" ? "tool-name" : "unsupported";
 }
 export const CODEX_CAPABILITY_REGISTRATIONS = [
+    {
+        capability: "office-presence",
+        normalizedEvent: "session-start",
+        nativeEvent: "SessionStart",
+        surfaceId: "codex-hooks",
+        support: "degraded",
+        runtimeFailure: "fail-open"
+    },
     {
         capability: "lifecycle-summary",
         normalizedEvent: "session-start",

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

@@ -67,13 +67,13 @@ function assertRuntimePath(runtimePath) {
 }
 export function opencodePluginEvents(capabilities) {
     const events = [];
-    if (capabilities.includes("lifecycle-summary")) {
+    if (capabilities.includes("lifecycle-summary") || capabilities.includes("office-presence")) {
         events.push("SessionStart");
     }
-    if (capabilities.includes("command-policy")) {
+    if (capabilities.includes("command-policy") || capabilities.includes("office-presence")) {
         events.push("PreToolUse");
     }
-    if (capabilities.includes("optional-stop-verify")) {
+    if (capabilities.includes("optional-stop-verify") || capabilities.includes("office-presence")) {
         events.push("Stop");
     }
     return events;
@@ -91,6 +91,7 @@ export function buildOpencodePlugin(capabilities, runtimePath) {
         return null;
     }
     assertRuntimePath(runtimePath);
+    const displayOnly = capabilities.includes("office-presence") && !capabilities.includes("command-policy");
     const lines = [
         "// Managed by agent-ops. Do not edit: `agent-ops update` rewrites this file.",
         `const RUNTIME_PATH = ${JSON.stringify(runtimePath)};`,
@@ -115,7 +116,7 @@ export function buildOpencodePlugin(capabilities, runtimePath) {
         "async function runManagedHook($, event, payload) {",
         "  const decision = await invokeRuntime($, event, payload, payload.projectRoot);",
         "  if (decision === null) {",
-        "    if (event === \"PreToolUse\") throw new Error(\"agent-ops: command policy is unavailable\");",
+        ...(displayOnly ? [] : ["    if (event === \"PreToolUse\") throw new Error(\"agent-ops: command policy is unavailable\");"]),
         "    return;",
         "  }",
         "  if (decision.decision === \"deny\") {",

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

@@ -22,6 +22,14 @@ export const OPENCODE_STOP_BLOCKING = "UNKNOWN";
  */
 export const OPENCODE_SESSION_START_FIDELITY = "app-init";
 export const OPENCODE_CAPABILITY_REGISTRATIONS = [
+    {
+        capability: "office-presence",
+        normalizedEvent: "session-start",
+        nativeEvent: "SessionStart",
+        surfaceId: "opencode-plugin",
+        support: "degraded",
+        runtimeFailure: "fail-open"
+    },
     {
         capability: "lifecycle-summary",
         normalizedEvent: "session-start",

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

@@ -2,6 +2,11 @@ export function explainConfig(merged) {
     return {
         schemaVersion: merged.config.schemaVersion,
         features: {
+            office: {
+                enabled: merged.config.features.office?.enabled === true,
+                source: merged.provenance.features.source,
+                sourcePath: merged.provenance.features.sourcePath
+            },
             completionGate: {
                 enabled: merged.config.features.completionGate.enabled,
                 source: merged.provenance.features.source,

package/dist/runtime/src/hooks/codex-loop.js

@@ -278,6 +278,10 @@ async function resolveLoopRoot(input, fallback, harness) {
     }
     return null;
 }
+/** Validated project-local loop root for display-only observers. */
+export async function resolveProjectLoopRoot(input, fallback, harness) {
+    return await resolveLoopRoot(input, fallback, harness);
+}
 function loopPath(root, harness, name) {
     return join(root, `.${harness}`, name);
 }