@kylecheng3146/agent-ops 0.5.3 → 0.7.0

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

@@ -1,3 +1,5 @@
+import { lstat, readFile } from "node:fs/promises";
+import { taskContractHash } from "../../../../runtime/src/task/contract.js";
 import { AgentOpsError } from "../../../../runtime/src/fs/paths.js";
 import { renderTaskMarkdown, safeTaskText } from "../../../../runtime/src/task/render.js";
 import { errorEnvelope, okEnvelope } from "../output.js";
@@ -12,20 +14,21 @@ function parseCriterion(source) {
     catch {
         throw new AgentOpsError("TASK_CRITERION_INVALID", "Each --criterion value must be a JSON criterion object.");
     }
-    if (!isRecord(value) ||
-        Object.keys(value).sort().join(",") !==
-            "description,id,verifierIds" ||
-        typeof value.id !== "string" ||
-        typeof value.description !== "string" ||
-        !Array.isArray(value.verifierIds) ||
-        value.verifierIds.some((id) => typeof id !== "string")) {
-        throw new AgentOpsError("TASK_CRITERION_INVALID", "Each criterion requires only id, description, and verifierIds.");
+    if (!isRecord(value))
+        throw new AgentOpsError("TASK_CRITERION_INVALID", "Criterion must be an object.");
+    // TaskService normalizes the creation baseline, then uses the shared strict validator.
+    return value;
+}
+async function jsonFile(path) {
+    const status = await lstat(path);
+    if (!status.isFile() || status.isSymbolicLink() || status.size > 65536)
+        throw new AgentOpsError("TASK_PAYLOAD_INVALID", "Payload must be a regular JSON file at most 64 KiB.");
+    try {
+        return JSON.parse(await readFile(path, "utf8"));
+    }
+    catch {
+        throw new AgentOpsError("TASK_PAYLOAD_INVALID", "Invalid JSON payload.");
     }
-    return {
-        id: value.id,
-        description: value.description,
-        verifierIds: [...value.verifierIds]
-    };
 }
 function parseEvidence(values) {
     const evidence = {};
@@ -57,7 +60,7 @@ function taskAction(args) {
             "complete",
             "create",
             "export",
-            "status"
+            "status", "revise", "replan", "pin-finding"
         ].includes(args.action)) {
         throw new AgentOpsError("TASK_ACTION_INVALID", "A supported task action is required.");
     }
@@ -68,7 +71,8 @@ function taskEnvelope(action, code, message, record) {
         action,
         message,
         record,
-        text: renderTaskMarkdown(record)
+        contractHash: taskContractHash(record.task),
+        text: renderTaskMarkdown(record) + "\nContract: " + taskContractHash(record.task)
     });
 }
 function renderTaskList(records) {
@@ -93,7 +97,10 @@ export async function runTaskCommand(options) {
             const record = await (worktree?.service ?? options.service).create({
                 title: options.args.title,
                 ...(options.args.intent === undefined ? {} : { intent: options.args.intent }),
-                criteria: (options.args.criteria ?? []).map(parseCriterion),
+                criteria: [...(options.args.criteria ?? []).map(parseCriterion),
+                    ...await Promise.all((options.args.criterionFiles ?? []).map(async (path) => await jsonFile(path)))]
+                    .map(c => c.acceptance === undefined || options.args.baseline === undefined ? c :
+                    { ...c, acceptance: { ...c.acceptance, baselineCommit: c.acceptance.baselineCommit ?? options.args.baseline } }),
                 ...(options.policyConfigHash === undefined
                     ? {}
                     : { policyConfigHash: options.policyConfigHash }),
@@ -127,6 +134,35 @@ export async function runTaskCommand(options) {
                 }
             };
         }
+        if (action === "revise") {
+            const payload = await jsonFile(options.args.criteriaFile);
+            if (!Array.isArray(payload))
+                throw new AgentOpsError("TASK_PAYLOAD_INVALID", "Criteria file must contain an array.");
+            const record = await options.service.revise(requireTaskId(options.args), {
+                expectedContractHash: options.args.expectedContract, criteria: payload,
+                reason: options.args.reason, ...(options.args.baseline === undefined ? {} : { baseline: options.args.baseline })
+            });
+            return taskEnvelope(action, "TASK_REVISED", "Contract revised; obtain new verification and fresh review.", record);
+        }
+        if (action === "replan") {
+            const payload = await jsonFile(options.args.planFile);
+            if (!Array.isArray(payload))
+                throw new AgentOpsError("TASK_PAYLOAD_INVALID", "Plan file must contain split task objects.");
+            const records = await options.service.replan(requireTaskId(options.args), {
+                expectedTreeContractHash: options.args.expectedTreeContract, reason: options.args.reason,
+                tasks: payload
+            });
+            return okEnvelope("TASK_REPLANNED", { action, message: "Task tree split atomically; reverify and review.", records, text: renderTaskList(records) });
+        }
+        if (action === "pin-finding") {
+            const criterion = parseCriterion(JSON.stringify(await jsonFile(options.args.criterionFiles[0])));
+            const pinned = await options.service.pinFinding(requireTaskId(options.args), options.args.expectedContract, options.args.findingReference, criterion, options.args.reason);
+            if (pinned.record === null)
+                return { code: "NEEDS_REPLAN", status: "error",
+                    data: { action, message: "Pin requires atomic replan to retain two to five criteria.", pendingCriterion: pinned.pendingCriterion, text: "NEEDS_REPLAN: include the pending criterion in task replan; no task was changed." },
+                    errors: [{ code: "NEEDS_REPLAN", message: "Replan the full current tree and pending pin." }] };
+            return taskEnvelope(action, "TASK_FINDING_PINNED", "Pinned saved finding; reverify and review the new contract.", pinned.record);
+        }
         if (action === "status") {
             if (options.args.taskId === undefined && sessionId === undefined) {
                 const parentTaskId = options.args.parentTaskId;
@@ -143,7 +179,15 @@ export async function runTaskCommand(options) {
             const record = await options.service.status(options.args.taskId === undefined
                 ? { sessionId }
                 : { taskId: options.args.taskId });
-            return taskEnvelope(action, "TASK_STATUS", `Read task ${record.task.id}.`, record);
+            const coverage = await options.service.coverage(record.task.id);
+            const proven = coverage.rows.filter(row => row.status === "proven").length;
+            const mechanical = coverage.rows.filter(row => row.mode === "behavioral" || row.mode === "invariant").length;
+            const reviewOnly = coverage.rows.filter(row => row.mode === "review-only").length;
+            const legacy = coverage.rows.filter(row => row.mode === "legacy").length;
+            const envelope = taskEnvelope(action, "TASK_STATUS", `Read task ${record.task.id}.`, record);
+            return { ...envelope, data: { ...envelope.data, coverage, treeContractHash: await options.service.treeContract(record.task.id),
+                    text: envelope.data.text + "\nAcceptance: " + proven + "/" + mechanical + " mechanical proven; " + reviewOnly + " review-only; " + legacy + " legacy; originally mechanical " + coverage.originalMechanical +
+                        "; reviewed " + coverage.reviewed + "; undischarged " + coverage.rows.filter(row => row.status !== "proven" && !coverage.reviewed).length } };
         }
         if (action === "attach") {
             if (sessionId === undefined) {

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/commands/verify.js

@@ -7,6 +7,7 @@ function safe(value) {
 }
 function publicReport(report) {
     return {
+        ...(report.acceptance === undefined ? {} : { acceptance: report.acceptance }),
         taskId: report.taskId,
         status: report.status,
         surface: {

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

@@ -7,13 +7,16 @@ import { sha256 } from "../../../runtime/src/fs/hash.js";
 import { loadConfigFile } from "../../../runtime/src/config/load.js";
 import { mergeConfigLayers } from "../../../runtime/src/config/merge.js";
 import { AgentOpsError } from "../../../runtime/src/fs/paths.js";
-import { localStatePaths } from "../../../runtime/src/security/permissions.js";
+import { localStatePaths, readPrivateFile } from "../../../runtime/src/security/permissions.js";
+import { FileRunRepository } from "../../../runtime/src/run/service.js";
+import { readRunPolicy, runRuntimeHash } from "../../../runtime/src/run/policy.js";
 import { calculateTrustBinding, FileTrustStore } from "../../../runtime/src/security/trust.js";
 export const DEFAULT_CONFIG = {
     schemaVersion: 3,
     profiles: [],
     verification: { commands: [] },
     features: {
+        office: { enabled: false },
         stopVerification: {
             enabled: false
         },
@@ -72,6 +75,14 @@ async function loadOptionalConfig(path) {
     }
 }
 export async function loadEffectiveConfig(root, scope, projectOverride) {
+    if (scope === "project" && projectOverride === undefined) {
+        const run = await runPolicyContext(root);
+        if (run !== null)
+            return mergeConfigLayers([defaultConfigLayer(), {
+                    source: "project", sourcePath: join(run.state.commonDir, "agent-ops/runs", run.state.runId, "policies", run.state.policyBinding.artifactDigest + ".json"),
+                    config: run.policy.config
+                }]);
+    }
     const home = process.env.AGENT_OPS_HOME ?? homedir();
     const userPath = join(home, ".agent-ops", "config.json");
     const projectPath = join(scope === "user" ? root : projectConfigRoot(root), ".agent-ops", "config.json");
@@ -184,6 +195,14 @@ export async function repositoryTrust(root, config, cliVersion) {
     const home = process.env.AGENT_OPS_HOME ?? homedir();
     const state = localStatePaths(home);
     try {
+        const run = await runPolicyContext(root);
+        if (run !== null) {
+            if (run.state.status !== "active" || run.state.disableRestart || run.state.awaitingResume ||
+                Date.parse(run.policy.expiresAt) <= Date.now() || calculateConfigHash(config) !== run.state.policyBinding.configHash)
+                return "STALE";
+            const store = new FileTrustStore(state.trustStore, state.anchorDirectory);
+            return (await store.status(run.policy.baseTrustBinding)).status;
+        }
         const binding = await repositoryTrustBinding(root, config, cliVersion);
         return (await new FileTrustStore(state.trustStore, state.anchorDirectory).status(binding)).status;
     }
@@ -191,6 +210,50 @@ export async function repositoryTrust(root, config, cliVersion) {
         return "UNTRUSTED";
     }
 }
+/** A run-private capability is usable only by its registered checkout or proof group. */
+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();
+    }
+    catch {
+        return null;
+    }
+    const source = await readPrivateFile(join(root, ".agent-ops/tasks/worktree.json"), root);
+    const record = source === null ? null : JSON.parse(source);
+    const runId = process.env.AGENT_OPS_RUN_ID ?? record?.runId;
+    if (runId === undefined)
+        return null;
+    const repository = new FileRunRepository(join(common, "agent-ops/runs"), common);
+    const saved = await repository.read(runId);
+    if (saved === null || saved.policyBinding === undefined)
+        return null;
+    const here = realpathSync(root);
+    const worker = saved.workers.find(w => w.worktree === here);
+    const proofProcess = worker?.proofProcess ?? saved.proofProcess;
+    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;
+        }
+        catch {
+            proof = false;
+        }
+    }
+    if ((!proof && (worker === undefined || record?.runId !== runId || record.workerId !== worker.workerId ||
+        record.ownerSessionId !== worker.ownerSessionId || record.coordinatorId !== saved.coordinatorId || record.workerGeneration !== worker.generation)) ||
+        (worker === undefined && !(proof && saved.root === here)) ||
+        (process.env.AGENT_OPS_WORKER_ID !== undefined && (process.env.AGENT_OPS_WORKER_ID !== (worker?.workerId ?? saved.coordinatorId) ||
+            process.env.AGENT_OPS_WORKER_GENERATION !== String((worker ?? saved.workers.find(w => w.workerId === saved.coordinatorId))?.generation))))
+        throw new AgentOpsError("RUN_WORKER_STALE", "Run policy requires the current registered worker generation or proof process.");
+    if (saved.status !== "active" || saved.disableRestart || saved.awaitingResume)
+        throw new AgentOpsError("RUN_POLICY_DISABLED", "Run execution policy is inactive; explicit resume is required.");
+    const policy = await readRunPolicy(saved, await runRuntimeHash());
+    if (policy === null)
+        return null;
+    return { repository, state: saved, policy, worker };
+}
 export async function repositoryTrustBinding(root, config, cliVersion) {
     return await calculateTrustBinding({
         repositoryPath: root,

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";
@@ -16,6 +17,9 @@ import { CompletionGateService } from "../../../runtime/src/hooks/completion-gat
 import { TaskService } from "../../../runtime/src/task/service.js";
 import { FileTaskStore } from "../../../runtime/src/task/store.js";
 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 { 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";
@@ -281,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;
             }
@@ -323,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)
@@ -343,7 +367,34 @@ export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
         const completionGate = (harnessId === "agy" || harnessId === "claude") &&
             config.features.completionGate.enabled
             ? dependencies.completionGate ?? {
-                handle: async (normalized) => await completionGateFor(root, config, gitRunner, harnessId).handle(normalized)
+                handle: async (normalized) => {
+                    if (normalized.event === "stop" && normalized.terminationReason === "model_stop" && normalized.fullyIdle === true && normalized.sessionId !== undefined) {
+                        const record = await readWorktreeRecord(root);
+                        if (record?.runId !== undefined && record.workerId !== undefined && record.workerGeneration !== undefined) {
+                            const common = await gitRunner.run(["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+                            if (common.exitCode === 0) {
+                                const commonDir = Buffer.from(common.stdout).toString("utf8").trim();
+                                const repository = new FileRunRepository(join(commonDir, "agent-ops", "runs"), commonDir);
+                                const state = await repository.read(record.runId);
+                                const worker = state?.workers.find(worker => worker.workerId === record.workerId);
+                                if (worker !== undefined && worker.workerId !== state.coordinatorId && worker.stopIntent !== null) {
+                                    const head = await gitRunner.run(["rev-parse", "HEAD"]);
+                                    const tasks = new TaskService(new FileTaskStore(join(root, ".agent-ops", "tasks", "state.json"), root));
+                                    if (head.exitCode === 0 && Buffer.from(head.stdout).toString("utf8").trim() === worker.stopIntent.sourceCommit &&
+                                        await tasks.treeContract(worker.taskId) === worker.stopIntent.contractDigest) {
+                                        const handoff = await validateWorkerStopHandoff(repository, { root, sessionId: normalized.sessionId,
+                                            ...(normalized.agentId === undefined ? {} : { agentId: normalized.agentId }), runId: record.runId,
+                                            workerId: record.workerId, generation: record.workerGeneration,
+                                            deliveryDigest: worker.stopIntent.deliveryDigest ?? undefined, contractDigest: worker.stopIntent.contractDigest ?? undefined });
+                                        if (handoff !== null)
+                                            return handoff;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    return await completionGateFor(root, config, gitRunner, harnessId).handle(normalized);
+                }
             }
             : undefined;
         const worktreeGuard = config.worktree?.mode === "auto"
@@ -353,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 });

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);
+}