oh-my-super-agent 0.1.0

package/dist/src/cli.js

@@ -0,0 +1,2096 @@
+#!/usr/bin/env node
+import { createHash } from "node:crypto";
+import { existsSync, lstatSync, readdirSync, readSync, realpathSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { pathToFileURL } from "node:url";
+import { runConductorBridge } from "./conductor/bridge.js";
+import { inspectConductorRuntimeBinding, requireStoredConductorAuthorization, startConductor, wakeConductorWithNotification, } from "./conductor/start.js";
+import { recoverConductorNotification } from "./conductor/recovery.js";
+import { waitForConductorNotification } from "./conductor/waiter.js";
+import { normalizeProviderHook, SUPPORTED_PROVIDER_HOOK_VERSIONS, } from "./hooks/provider.js";
+import { createDurableProviderBindingResolver, publishAndProjectProviderObservations, } from "./hooks/provider-runtime.js";
+import { runGithubQueueProbeCommand, } from "./commands/github-queue-probe.js";
+import { runTraceFixture } from "./commands/trace-fixture.js";
+import { ingestNativeHook, projectNativeHook } from "./hooks/native.js";
+import { reconcileMinute } from "./scheduler/minute.js";
+import { installUserSchedule, readInstalledUserSchedulePlanBinding, removeUserSchedule, statusUserSchedule, } from "./schedule/user-installation.js";
+import { generateUserSchedule } from "./schedule/user-plan.js";
+import { createEnduranceAuthorities } from "./runtime/endurance-authorities.js";
+import { linuxProcessIdentityIsLive, readLinuxProcessIdentity } from "./runtime/process-identity.js";
+import { systemClockSample } from "./runtime/system-clock.js";
+import { createHudSnapshot, renderHud } from "./status/hud.js";
+import { reconcileWatchdog } from "./watchdog/reconcile.js";
+import { runDoctor } from "./doctor.js";
+import { readOmsConfig } from "./config.js";
+import { projectClaudeStructuredRoleCompletion, recoverClaudeStructuredRoleCompletions, } from "./providers/claude-structured-completion.js";
+import { assessRelease } from "./health/release-assessment.js";
+import { createGoal, readGoal } from "./goals/authority.js";
+import { normalizeGithubRemoteRepository, normalizeGithubSyncTarget } from "./github/adapter.js";
+import { projectGithubSyncBatch } from "./github/projector.js";
+import { syncGithubEventsOnce } from "./github/sync.js";
+import { createReviewDeliveryService, OMS_REVIEW_REQUIRED_CHECK, } from "./github/review.js";
+import { createRuntimeGoalAuthority } from "./goals/runtime-authority.js";
+import { discloseLiveContact, LIVE_CONTACT_OPERATIONS, PRE_DISPATCH_ADVICE_OPERATION, readLiveDeliveryAuthorization, readPreDispatchAdviceAuthorization, } from "./live/contact-journal.js";
+import { findPackageRoot } from "./package-root.js";
+import { projectWorkspace } from "./projection/project-workspace.js";
+import { initializeState, readStateSummary, resolveStateRoot } from "./state.js";
+import { generateExecutorGroupManifest, persistExecutorGroupManifest } from "./team/plan.js";
+import { errorMessage, isRecord, lstatIfExists, readJsonFileNoFollow, validateExistingDirectory } from "./utils/fs.js";
+import { runVerification } from "./verify.js";
+import { assertSchema, loadJsonSchema } from "./runtime/schema.js";
+import { createStableId } from "./runtime/stable-id.js";
+import { writeDailyTrustReport } from "./reports/daily-trust.js";
+import { createRuntimeTicketAuthorities } from "./tickets/runtime-authority.js";
+import { abortAuditRun, closeTimedAuditRun, conductorNext, listRunStatuses, readRunStatus, recoverRunControllerAuthority, startAuditRun, tickAuditRun, } from "./runs/controller.js";
+import { createRuntimeDispatchAuthorities } from "./dispatch/runtime-authority.js";
+import { createDispatchAdviceService } from "./dispatch/advice.js";
+import { createWorkerDeliveryService } from "./workers/delivery.js";
+import { runWorkerBridge } from "./workers/bridge.js";
+import { runClaudeStructuredRoleBridge } from "./providers/claude-structured-bridge.js";
+import { createRuntimeWorkerAuthorities } from "./workers/runtime.js";
+import { createWorkerPaneAdapter } from "./workers/panes.js";
+import { runProcess } from "./providers/process.js";
+import { createResultGateService } from "./verification/result-gate.js";
+const USAGE = `Usage: oms [command] [options]
+
+With no command in an interactive terminal, OMS starts or attaches the conductor.
+With no command outside a terminal, OMS prints this help and contacts no provider.
+
+Commands:
+  init [--state-root PATH]    Initialize local runtime state idempotently
+  doctor                     Run offline dependency and configuration checks
+  status [--state-root PATH] Print a deterministic local state summary
+  project                    Project rules, concrete agents, and skills from .agents
+  probe github-queue --repository OWNER/REPO --run-id ID [--confirm-live]
+                             Disclose, then optionally contact GitHub and sync ready issues
+  trace fixture [--state-root PATH]
+                             Run the offline one-ticket contributor fixture
+  hook ingest [--state-root PATH]
+                             Ingest one bounded native-hook JSON object from stdin
+  hook provider --provider claude|codex --provider-version VERSION --dispatch-id ID --session-id ID
+                --state-root PATH --workspace-root PATH --config-root PATH
+                             Project one pinned provider hook; completion is observational only
+  events sync github --repository OWNER/REPO [--state-root PATH] [--workspace-root PATH]
+                             Run one typed, deduplicated GitHub observation pass
+  reconcile minute|watchdog [--state-root PATH] [--workspace-root PATH]
+                             Run one idempotent reconciliation pass
+  schedule generate|install|status|remove --manager cron|systemd|launchd --repository OWNER/REPO
+           [--github-poll-seconds N] [--manager-executable PATH] [--state-root PATH]
+                             Manage the exact user-scoped GitHub/watchdog schedule
+  run start (--until-empty | --for 12h|24h) --manager cron|systemd|launchd [--state-root PATH]
+                             Start a non-certifying audit run; workers remain OMS-managed interactive
+  run tick --run-id ID [--state-root PATH]
+                             Record one deterministic run/control-loop tick
+  run close --run-id ID [--state-root PATH]
+                             Close a fully elapsed 12h/24h audit run; never certifies release
+  run abort --run-id ID --reason-file PATH [--state-root PATH]
+                             Abort a run with one immutable bounded JSON reason
+  run recover-controller --generation-id ID --reason-file PATH [--state-root PATH]
+                             Explicitly recover one crashed controller-lock generation
+  run status [--run-id ID] [--state-root PATH]
+                             Read audit run status without launching providers
+  conductor start [--state-root PATH] [--repository OWNER/REPO --confirm-live-delivery]
+                             Advanced recovery/state override for the conductor pane
+  conductor wait-event --session-id ID --hook-event SessionStart|Stop --provider-version VERSION [--state-root PATH]
+                             Wait in a pinned asyncRewake hook; emits only one opaque notice ID
+  conductor next --run-id ID [--state-root PATH]
+                             Persist the next opaque, read-only conductor route
+  goal create --file PATH [--state-root PATH]
+                             Create one canonical goal from a bounded JSON file
+  goal status --goal-id ID [--state-root PATH]
+                             Read canonical goal lifecycle status
+  worker deliver --event-id ID [--state-root PATH]
+                             Deliver one accepted dispatch to its interactive pane
+  worker status --dispatch-id ID [--state-root PATH]
+                             Read typed worker/session/pane status
+  worker park --dispatch-id ID --until TIME --reason-file PATH [--state-root PATH]
+  worker resume --dispatch-id ID [--state-root PATH]
+  worker stop --dispatch-id ID --reason-file PATH [--state-root PATH]
+                             Manage one worker through typed OMS lifecycle commands
+  team start --dispatch-id ID [--dispatch-id ID...] [--state-root PATH]
+                             Persist and start one OMS-native executor group
+  structured-role bridge --request-id ID --session-id UUID --state-root PATH --workspace-root PATH
+                             Serve one two-tool fresh interactive Claude role bridge
+  trust report --date YYYY-MM-DD [--state-root PATH]
+                             Write one immutable closed-day trust report
+  hud [--state-root PATH]    Print one read-only runtime HUD snapshot
+  release status             Print the offline negative-only release assessment
+  verify                     Run the offline package and workspace gate`;
+export async function runCli(argv = process.argv.slice(2), context = {}) {
+    const packageRoot = context.packageRoot ?? findPackageRoot();
+    let workspaceRoot = resolve(context.workspaceRoot ?? context.cwd ?? process.cwd());
+    const interactive = context.isInteractive ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    const automaticConductorStart = argv.length === 0 && interactive;
+    const command = automaticConductorStart ? "conductor" : argv[0];
+    let args = automaticConductorStart ? ["start"] : argv.slice(1);
+    try {
+        if (command === undefined || command === "help" || command === "-h" || command === "--help") {
+            return { ok: true, exitCode: 0, message: USAGE };
+        }
+        if (automaticConductorStart) {
+            if (!isOmsGitWorkspace(workspaceRoot)) {
+                if (!isGitWorkspace(workspaceRoot)) {
+                    if (!isOmsGitWorkspace(packageRoot)) {
+                        throw new Error("bare oms must run from the root of a Git repository");
+                    }
+                    workspaceRoot = packageRoot;
+                }
+            }
+            const authorizedStateRoot = discoverAuthorizedConductorStateRoot({
+                workspaceRoot,
+                env: context.env,
+                cwd: context.cwd ?? workspaceRoot,
+            });
+            const stateRoot = authorizedStateRoot ?? resolveStateRoot({
+                workspaceRoot,
+                env: context.env,
+                cwd: context.cwd ?? workspaceRoot,
+            });
+            const state = readStateSummary({
+                workspaceRoot,
+                override: stateRoot,
+                env: context.env,
+                cwd: context.cwd ?? workspaceRoot,
+            });
+            const liveAuthorization = state.initialized ? readLiveDeliveryAuthorization(stateRoot) : undefined;
+            const adviceAuthorization = state.initialized ? readPreDispatchAdviceAuthorization(stateRoot) : undefined;
+            if (liveAuthorization && adviceAuthorization) {
+                args = ["start", "--state-root", stateRoot];
+            }
+            else {
+                const requestAuthorization = context.requestBareLiveDeliveryAuthorization;
+                if (!requestAuthorization) {
+                    throw new Error("bare oms requires the human authorization prompt before starting a conductor");
+                }
+                const suggestedRepository = liveAuthorization?.repository ?? inferBareGithubRepository({
+                    workspaceRoot,
+                    env: context.env,
+                    runner: context.bareStartRunner ?? runProcess,
+                });
+                const confirmedRepository = await requestAuthorization({
+                    state_root: stateRoot,
+                    suggested_repository: suggestedRepository,
+                    required_repository: liveAuthorization?.repository ?? null,
+                });
+                if (!confirmedRepository) {
+                    throw new Error("live delivery authorization was not confirmed; no conductor was started");
+                }
+                const repository = normalizeGithubSyncTarget(confirmedRepository).repository;
+                const requiredRepository = liveAuthorization?.repository ?? suggestedRepository;
+                if (requiredRepository && repository !== requiredRepository) {
+                    throw new Error(`live delivery authorization must match repository ${requiredRepository}`);
+                }
+                args = [
+                    "start",
+                    "--state-root",
+                    stateRoot,
+                    "--repository",
+                    repository,
+                    "--confirm-live-delivery",
+                ];
+            }
+        }
+        const sourceRoot = hasOmsConfiguration(workspaceRoot) ? workspaceRoot : packageRoot;
+        switch (command) {
+            case "init": {
+                const override = parseStateRoot(args);
+                const stateRoot = initializeState({
+                    workspaceRoot,
+                    override,
+                    env: context.env,
+                    cwd: context.cwd ?? workspaceRoot,
+                });
+                return { ok: true, exitCode: 0, message: `initialized: ${stateRoot}` };
+            }
+            case "status": {
+                const override = activeStateRootOverride({
+                    workspaceRoot,
+                    override: parseStateRoot(args),
+                    env: context.env,
+                    cwd: context.cwd ?? workspaceRoot,
+                });
+                const summary = readStateSummary({
+                    workspaceRoot,
+                    override,
+                    env: context.env,
+                    cwd: context.cwd ?? workspaceRoot,
+                });
+                return { ok: true, exitCode: 0, output: summary };
+            }
+            case "doctor": {
+                requireNoOptions("doctor", args);
+                const report = runDoctor({ root: sourceRoot });
+                return { ok: report.ok, exitCode: report.ok ? 0 : 1, message: report.lines.join("\n") };
+            }
+            case "project":
+                requireNoOptions("project", args);
+                return {
+                    ok: true,
+                    exitCode: 0,
+                    message: `projected: ${projectWorkspace(sourceRoot, workspaceRoot).projected.join(" ")}`,
+                };
+            case "probe": {
+                const probe = parseGithubQueueProbeArgs(args);
+                const runProbe = context.githubQueueProbe ?? runGithubQueueProbeCommand;
+                const emitDisclosure = context.emitLiveDisclosure ?? ((disclosure, evidence) => {
+                    process.stderr.write(`${JSON.stringify({ live_contact_disclosure: disclosure, evidence })}\n`);
+                });
+                const output = runProbe({
+                    packageRoot,
+                    configRoot: sourceRoot,
+                    workspaceRoot,
+                    stateRootOverride: probe.stateRoot,
+                    cwd: context.cwd ?? workspaceRoot,
+                    env: context.env,
+                    runId: probe.runId,
+                    repository: probe.repository,
+                    readyLabel: probe.readyLabel,
+                    limit: probe.limit,
+                    confirmLive: probe.confirmLive,
+                    emitDisclosure,
+                });
+                return { ok: true, exitCode: 0, output };
+            }
+            case "trace": {
+                if (args[0] !== "fixture")
+                    throw new Error("trace requires the explicit fixture subcommand");
+                const override = parseStateRoot(args.slice(1));
+                const traceFixture = context.traceFixture ?? runTraceFixture;
+                const output = traceFixture({
+                    packageRoot,
+                    configRoot: sourceRoot,
+                    workspaceRoot,
+                    stateRootOverride: override,
+                    cwd: context.cwd ?? workspaceRoot,
+                    env: context.env,
+                });
+                if (output.state !== "verifying") {
+                    throw new Error(`offline trace fixture stopped in ${output.state}`);
+                }
+                return { ok: true, exitCode: 0, output };
+            }
+            case "hook": {
+                const raw = context.readStdin ? context.readStdin() : readBoundedUtf8(0, 64 * 1024);
+                if (Buffer.byteLength(raw, "utf8") > 64 * 1024)
+                    throw new Error("native hook input exceeds 65536 bytes");
+                const input = JSON.parse(raw);
+                if (args[0] === "ingest") {
+                    const override = parseStateRoot(args.slice(1));
+                    const stateRoot = requireInitializedState({ workspaceRoot, override, env: context.env, cwd: context.cwd ?? workspaceRoot });
+                    const runtime = createEnduranceAuthorities({ packageRoot, configRoot: sourceRoot, stateRoot });
+                    try {
+                        const published = ingestNativeHook({ input, bus: runtime.eventBus, queue: runtime.tickets.queue });
+                        const sampled = (context.clockSample ?? systemClockSample)();
+                        const projected = await projectNativeHook({
+                            eventId: published.event.event_id,
+                            processedAt: sampled.wallTime,
+                            bus: runtime.eventBus,
+                            processor: runtime.outboxProcessor,
+                            sessions: runtime.sessions,
+                            quota: runtime.quota,
+                            queue: runtime.tickets.queue,
+                            packageRoot,
+                            configRoot: sourceRoot,
+                            stateRoot,
+                            auditLedger: runtime.auditLedger,
+                        });
+                        const notification = runtime.notifications.assignProjected({
+                            eventIds: [published.event.event_id],
+                            projectorId: "native-hook-projector",
+                            createdAt: sampled.wallTime,
+                        });
+                        return {
+                            ok: true,
+                            exitCode: 0,
+                            output: {
+                                event_id: published.event.event_id,
+                                publish_status: published.status,
+                                projection_status: projected.status,
+                                notification_id: notification.record?.record_id ?? null,
+                            },
+                        };
+                    }
+                    finally {
+                        runtime.close();
+                    }
+                }
+                const provider = parseProviderHookArgs(args);
+                const providerWorkspace = validateExistingDirectory(provider.workspaceRoot, "provider hook workspace root");
+                const providerConfig = validateExistingDirectory(provider.configRoot, "provider hook config root");
+                const stateRoot = requireInitializedState({
+                    workspaceRoot: providerWorkspace,
+                    override: provider.stateRoot,
+                    env: context.env,
+                    cwd: providerWorkspace,
+                });
+                const endurance = createEnduranceAuthorities({ packageRoot, configRoot: providerConfig, stateRoot });
+                try {
+                    const workers = createRuntimeWorkerAuthorities({
+                        packageRoot,
+                        configRoot: providerConfig,
+                        workspaceRoot: providerWorkspace,
+                        stateRoot,
+                        actorId: "native-hook",
+                    });
+                    const bindings = createDurableProviderBindingResolver({
+                        provider: provider.provider,
+                        dispatch: workers.dispatch,
+                        workers: workers.workers,
+                        sessions: workers.sessions,
+                        tickets: workers.tickets.lifecycle,
+                    });
+                    const sampled = (context.clockSample ?? systemClockSample)();
+                    const observations = normalizeProviderHook({
+                        packageRoot,
+                        provider: provider.provider,
+                        providerVersion: provider.providerVersion,
+                        dispatchId: provider.dispatchId,
+                        sessionId: provider.sessionId,
+                        observedAt: sampled.wallTime,
+                        input,
+                        bindings,
+                    });
+                    await publishAndProjectProviderObservations({
+                        observations,
+                        processedAt: sampled.wallTime,
+                        packageRoot,
+                        configRoot: providerConfig,
+                        bus: endurance.eventBus,
+                        processor: endurance.outboxProcessor,
+                        outbox: endurance.outbox,
+                        notifications: endurance.notifications,
+                        bindings,
+                        workers: workers.workers,
+                        sessions: workers.sessions,
+                    });
+                    const isCodexStop = provider.provider === "codex" && observations[0]?.hook_event === "Stop";
+                    return { ok: true, exitCode: 0, ...(isCodexStop ? { output: {} } : {}) };
+                }
+                finally {
+                    endurance.close();
+                }
+            }
+            case "events": {
+                const events = parseEventsArgs(args);
+                const eventsWorkspace = events.workspaceRoot
+                    ? validateExistingDirectory(resolve(events.workspaceRoot), "GitHub sync workspace root")
+                    : workspaceRoot;
+                const eventsConfig = existsSync(join(eventsWorkspace, ".agents")) ? eventsWorkspace : packageRoot;
+                const stateRoot = requireInitializedState({
+                    workspaceRoot: eventsWorkspace,
+                    override: events.stateRoot,
+                    env: context.env,
+                    cwd: eventsWorkspace,
+                });
+                const runtime = createEnduranceAuthorities({ packageRoot, configRoot: eventsConfig, stateRoot });
+                const sampled = (context.clockSample ?? systemClockSample)();
+                const target = normalizeGithubSyncTarget(events.repository);
+                const contacts = [];
+                let projection;
+                try {
+                    const authorization = readLiveDeliveryAuthorization(stateRoot);
+                    if (!authorization || authorization.repository !== target.repository) {
+                        throw new Error("GitHub event sync lacks matching human-started live authorization");
+                    }
+                    const githubRunner = context.githubRunner ?? runProcess;
+                    const disclosedRunner = (request) => {
+                        contacts.push(discloseLiveContact({
+                            stateRoot,
+                            authorization,
+                            operation: "github-event-sync",
+                            contactSurface: "github-api-via-gh",
+                            subjectId: createStableId("gh-sync-call", target.repository, sampled.wallTime, String(contacts.length)),
+                            request: publicGithubSyncRequest(request),
+                            disclosedAt: sampled.wallTime,
+                        }));
+                        return githubRunner(request);
+                    };
+                    const result = await syncGithubEventsOnce({
+                        target,
+                        cwd: eventsWorkspace,
+                        watermarkRoot: join(stateRoot, "github-watermarks"),
+                        locksRoot: join(stateRoot, "locks"),
+                        env: context.env,
+                        runner: disclosedRunner,
+                        clock: () => sampled.wallTime,
+                        project: async (batch) => {
+                            projection = await projectGithubSyncBatch({
+                                batch,
+                                processedAt: sampled.wallTime,
+                                packageRoot,
+                                snapshotsRoot: join(stateRoot, "github-snapshots"),
+                                bus: runtime.eventBus,
+                                processor: runtime.outboxProcessor,
+                                outbox: runtime.outbox,
+                                notifications: runtime.notifications,
+                                ticketMaterializer: runtime.tickets.materializer,
+                            });
+                        },
+                    });
+                    if (!projection)
+                        throw new Error("GitHub sync completed without projection evidence");
+                    return {
+                        ok: true,
+                        exitCode: 0,
+                        output: {
+                            repository: result.watermark.repository,
+                            generation: result.watermark.generation,
+                            observation_count: result.observations.length,
+                            event_ids: projection.event_ids,
+                            notification_id: projection.notification_id,
+                            notification_ids: projection.notification_ids,
+                            watermark_path: result.watermark_path,
+                            contact_disclosure: contacts[0] ?? null,
+                            contact_disclosures: contacts,
+                        },
+                    };
+                }
+                finally {
+                    runtime.close();
+                }
+            }
+            case "reconcile": {
+                const reconcile = parseReconcileArgs(args);
+                const reconcileWorkspace = resolve(reconcile.workspaceRoot ?? workspaceRoot);
+                const reconcileConfig = existsSync(join(reconcileWorkspace, ".agents")) ? reconcileWorkspace : packageRoot;
+                const stateRoot = requireInitializedState({
+                    workspaceRoot: reconcileWorkspace,
+                    override: reconcile.stateRoot,
+                    env: context.env,
+                    cwd: context.cwd ?? reconcileWorkspace,
+                });
+                const runtime = createEnduranceAuthorities({ packageRoot, configRoot: reconcileConfig, stateRoot });
+                try {
+                    const at = (context.clockSample ?? systemClockSample)().wallTime;
+                    const output = reconcile.kind === "minute"
+                        ? await reconcileMinute({
+                            at,
+                            bus: runtime.eventBus,
+                            processor: runtime.outboxProcessor,
+                            outbox: runtime.outbox,
+                            queue: runtime.tickets.queue,
+                            sessions: runtime.sessions,
+                            quota: runtime.quota,
+                            auditLedger: runtime.auditLedger,
+                            packageRoot,
+                            configRoot: reconcileConfig,
+                            stateRoot,
+                        })
+                        : await reconcileWatchdog({
+                            at,
+                            bus: runtime.eventBus,
+                            processor: runtime.outboxProcessor,
+                            outbox: runtime.outbox,
+                            queue: runtime.tickets.queue,
+                            sessions: runtime.sessions,
+                            workers: runtime.workers,
+                            workerPanes: createWorkerPaneAdapter({ env: context.env }),
+                            packageRoot,
+                            configRoot: reconcileConfig,
+                            stateRoot,
+                            auditLedger: runtime.auditLedger,
+                            stallMs: runtime.policy.outbox_stall_seconds * 1_000,
+                            recoverStructuredRoleCompletions: () => {
+                                const recovered = recoverClaudeStructuredRoleCompletions({ packageRoot, stateRoot });
+                                return Object.freeze({
+                                    recoveredRequestIds: recovered.projections.map((projection) => projection.request_id),
+                                    failedRequestIds: recovered.failed_request_ids,
+                                });
+                            },
+                            recoverConductor: () => {
+                                const recover = context.conductorRecovery ?? recoverConductorNotification;
+                                return recover({
+                                    at,
+                                    locksRoot: join(stateRoot, "locks"),
+                                    activity: runtime.conductorActivity,
+                                    notifications: runtime.notifications,
+                                    waiters: runtime.waiters,
+                                    ensureConductor: () => {
+                                        const launched = (context.conductorStart ?? startConductor)({
+                                            packageRoot,
+                                            configRoot: reconcileConfig,
+                                            workspaceRoot: reconcileWorkspace,
+                                            stateRoot,
+                                            executablePath: context.executablePath ?? resolveDefaultExecutable(packageRoot),
+                                            env: context.env,
+                                            attach: false,
+                                            resumeOnly: true,
+                                        });
+                                        const binding = inspectConductorRuntimeBinding({
+                                            workspaceRoot: reconcileWorkspace,
+                                            stateRoot,
+                                            sessionId: launched.claude_session_id,
+                                            env: context.env,
+                                        });
+                                        return Object.freeze({
+                                            action: launched.action,
+                                            binding: Object.freeze({
+                                                session_id: binding.session_id,
+                                                launch_generation: binding.launch_generation,
+                                                pane_id: binding.pane_id,
+                                                conductor_process: readLinuxProcessIdentity(binding.process_id),
+                                            }),
+                                        });
+                                    },
+                                    wakeConductor: (binding, notificationId) => wakeConductorWithNotification({
+                                        workspaceRoot: reconcileWorkspace,
+                                        stateRoot,
+                                        sessionId: binding.session_id,
+                                        launchGeneration: binding.launch_generation,
+                                        paneId: binding.pane_id,
+                                        conductorProcess: binding.conductor_process,
+                                        notificationId,
+                                        env: context.env,
+                                    }),
+                                });
+                            },
+                        });
+                    return { ok: true, exitCode: 0, output };
+                }
+                finally {
+                    runtime.close();
+                }
+            }
+            case "schedule": {
+                const schedule = parseScheduleArgs(args);
+                const runtimeEnv = context.env ?? process.env;
+                const stateRoot = requireInitializedState({
+                    workspaceRoot,
+                    override: schedule.stateRoot,
+                    env: context.env,
+                    cwd: context.cwd ?? workspaceRoot,
+                });
+                const installationsRoot = join(stateRoot, "schedule-installations");
+                const installedBinding = schedule.command === "generate"
+                    ? undefined
+                    : readInstalledUserSchedulePlanBinding({ installationsRoot, packageRoot });
+                if (installedBinding && installedBinding.manager !== schedule.manager) {
+                    throw new Error("recorded user schedule uses another manager");
+                }
+                const installedPlan = installedBinding?.schema_version === 2 ? installedBinding : undefined;
+                if (installedPlan) {
+                    const requestedRepository = normalizeGithubSyncTarget(schedule.repository).repository;
+                    if (installedPlan.state_root !== stateRoot)
+                        throw new Error("recorded user schedule uses another state root");
+                    if (installedPlan.repository !== requestedRepository)
+                        throw new Error("recorded user schedule uses another repository");
+                    if (schedule.githubPollSeconds !== undefined
+                        && schedule.githubPollSeconds !== installedPlan.github_poll_seconds)
+                        throw new Error("recorded user schedule uses another GitHub poll interval");
+                }
+                const executablePath = installedPlan?.executable_path
+                    ?? resolve(context.executablePath ?? process.argv[1] ?? join(packageRoot, "bin", "oms"));
+                const generated = generateUserSchedule({
+                    manager: schedule.manager,
+                    executablePath,
+                    environmentPath: installedPlan?.environment_path
+                        ?? (installedBinding?.schema_version === 1 ? dirname(executablePath) : runtimeEnv.PATH ?? ""),
+                    stateRoot,
+                    workspaceRoot: installedPlan?.workspace_root ?? workspaceRoot,
+                    repository: installedPlan?.repository ?? schedule.repository,
+                    githubPollSeconds: installedPlan?.github_poll_seconds ?? schedule.githubPollSeconds,
+                    packageRoot,
+                });
+                if (schedule.command === "generate") {
+                    return { ok: true, exitCode: 0, output: generated };
+                }
+                if (!runtimeEnv.HOME)
+                    throw new Error(`schedule ${schedule.command} requires HOME`);
+                const lifecycle = {
+                    generated,
+                    packageRoot,
+                    homeDirectory: runtimeEnv.HOME,
+                    installationsRoot,
+                    managerExecutablePath: schedule.managerExecutable ?? defaultManagerExecutable(schedule.manager),
+                    env: runtimeEnv,
+                    ...(context.scheduleRunner ? { runner: context.scheduleRunner } : {}),
+                };
+                if (schedule.command === "install") {
+                    return { ok: true, exitCode: 0, output: installUserSchedule(lifecycle) };
+                }
+                if (schedule.command === "status") {
+                    return { ok: true, exitCode: 0, output: statusUserSchedule(lifecycle) };
+                }
+                return { ok: true, exitCode: 0, output: removeUserSchedule(lifecycle) };
+            }
+            case "run": {
+                const run = parseRunArgs(args);
+                const stateRoot = requireInitializedState({
+                    workspaceRoot,
+                    override: run.stateRoot,
+                    env: context.env,
+                    cwd: context.cwd ?? workspaceRoot,
+                });
+                if (run.command === "start") {
+                    const output = startAuditRun({
+                        packageRoot,
+                        configRoot: sourceRoot,
+                        stateRoot,
+                        workspaceRoot,
+                        executablePath: resolve(context.executablePath ?? process.argv[1] ?? join(packageRoot, "bin", "oms")),
+                        manager: run.manager,
+                        runKind: run.runKind,
+                    });
+                    return { ok: true, exitCode: 0, output };
+                }
+                if (run.command === "tick") {
+                    return {
+                        ok: true,
+                        exitCode: 0,
+                        output: tickAuditRun({ packageRoot, configRoot: sourceRoot, stateRoot, runId: run.runId }),
+                    };
+                }
+                if (run.command === "close") {
+                    return {
+                        ok: true,
+                        exitCode: 0,
+                        output: closeTimedAuditRun({ packageRoot, configRoot: sourceRoot, stateRoot, runId: run.runId }),
+                    };
+                }
+                if (run.command === "abort") {
+                    const inputPath = resolve(context.cwd ?? workspaceRoot, run.reasonFile);
+                    const input = readJsonFileNoFollow(inputPath, 16 * 1024);
+                    assertSchema(input, loadJsonSchema(join(packageRoot, "schemas", "run-abort-input.schema.json")), "run abort input");
+                    return {
+                        ok: true,
+                        exitCode: 0,
+                        output: abortAuditRun({
+                            packageRoot,
+                            configRoot: sourceRoot,
+                            stateRoot,
+                            runId: run.runId,
+                            reason: input.reason,
+                        }),
+                    };
+                }
+                if (run.command === "recover-controller") {
+                    const inputPath = resolve(context.cwd ?? workspaceRoot, run.reasonFile);
+                    const input = readJsonFileNoFollow(inputPath, 16 * 1024);
+                    assertSchema(input, loadJsonSchema(join(packageRoot, "schemas", "run-abort-input.schema.json")), "run recovery input");
+                    return {
+                        ok: true,
+                        exitCode: 0,
+                        output: recoverRunControllerAuthority({
+                            packageRoot,
+                            stateRoot,
+                            expectedGenerationId: run.generationId,
+                            reason: input.reason,
+                        }),
+                    };
+                }
+                return {
+                    ok: true,
+                    exitCode: 0,
+                    output: run.runId
+                        ? readRunStatus({ packageRoot, configRoot: sourceRoot, stateRoot, runId: run.runId })
+                        : listRunStatuses({ packageRoot, configRoot: sourceRoot, stateRoot }),
+                };
+            }
+            case "conductor": {
+                const conductor = parseConductorArgs(args);
+                if (conductor.command === "start") {
+                    if (!interactive)
+                        throw new Error("conductor start requires an interactive terminal");
+                    const selectedStateRoot = resolveStateRoot({
+                        workspaceRoot,
+                        override: conductor.stateRoot,
+                        env: context.env,
+                        cwd: context.cwd ?? workspaceRoot,
+                    });
+                    if (conductor.repository === undefined) {
+                        const state = readStateSummary({
+                            workspaceRoot,
+                            override: selectedStateRoot,
+                            env: context.env,
+                            cwd: context.cwd ?? workspaceRoot,
+                        });
+                        if (!state.initialized) {
+                            throw new Error("conductor recovery requires an already authorized state root; run bare oms for first start");
+                        }
+                        requireStoredConductorAuthorization(selectedStateRoot, workspaceRoot);
+                    }
+                    const stateRoot = initializeState({
+                        workspaceRoot,
+                        override: selectedStateRoot,
+                        env: context.env,
+                        cwd: context.cwd ?? workspaceRoot,
+                    });
+                    const runStart = context.conductorStart ?? startConductor;
+                    return {
+                        ok: true,
+                        exitCode: 0,
+                        output: runStart({
+                            packageRoot,
+                            configRoot: sourceRoot,
+                            workspaceRoot,
+                            stateRoot,
+                            executablePath: context.executablePath ?? resolveDefaultExecutable(packageRoot),
+                            env: context.env,
+                            ...(conductor.repository === undefined ? {} : {
+                                liveDeliveryRepository: conductor.repository,
+                                confirmLiveDelivery: true,
+                            }),
+                        }),
+                    };
+                }
+                const stateRoot = requireInitializedState({
+                    workspaceRoot,
+                    override: conductor.stateRoot,
+                    env: context.env,
+                    cwd: context.cwd ?? workspaceRoot,
+                });
+                if (conductor.command === "bridge") {
+                    const serve = context.conductorBridge ?? runConductorBridge;
+                    const createAdvice = context.dispatchAdvice ?? createDispatchAdviceService;
+                    const createDelivery = context.workerDelivery ?? createWorkerDeliveryService;
+                    let advice;
+                    let delivery;
+                    let resultGate;
+                    let reviewDelivery;
+                    const getAdvice = () => {
+                        advice ??= createAdvice({
+                            packageRoot,
+                            configRoot: sourceRoot,
+                            workspaceRoot,
+                            stateRoot,
+                            env: context.env,
+                        });
+                        return advice;
+                    };
+                    const getDelivery = () => {
+                        delivery ??= createDelivery({
+                            packageRoot,
+                            configRoot: sourceRoot,
+                            workspaceRoot,
+                            stateRoot,
+                            executablePath: context.executablePath ?? resolveDefaultExecutable(packageRoot),
+                            env: context.env,
+                        });
+                        return delivery;
+                    };
+                    const getResultGate = () => {
+                        resultGate ??= createResultGateService({
+                            packageRoot,
+                            configRoot: sourceRoot,
+                            workspaceRoot,
+                            stateRoot,
+                            executablePath: context.executablePath ?? resolveDefaultExecutable(packageRoot),
+                            env: context.env,
+                        });
+                        return resultGate;
+                    };
+                    const getReviewDelivery = () => {
+                        reviewDelivery ??= createReviewDeliveryService({
+                            packageRoot,
+                            configRoot: sourceRoot,
+                            workspaceRoot,
+                            stateRoot,
+                            requiredCheckName: OMS_REVIEW_REQUIRED_CHECK,
+                            env: context.env,
+                        });
+                        return reviewDelivery;
+                    };
+                    await serve({
+                        packageRoot,
+                        configRoot: sourceRoot,
+                        workspaceRoot,
+                        stateRoot,
+                        sessionId: conductor.sessionId,
+                        actorId: "oms-conductor",
+                        adviseDispatch: (intent) => getAdvice().advise(intent),
+                        deliverAcceptedDispatch: (eventId) => getDelivery().deliver(eventId),
+                        manageWorker: (request) => manageWorker(getDelivery(), request),
+                        startTeam: (dispatchIds) => startExecutorGroup({
+                            packageRoot,
+                            configRoot: sourceRoot,
+                            workspaceRoot,
+                            stateRoot,
+                            dispatchIds,
+                            delivery: getDelivery(),
+                        }),
+                        processResult: (dispatchId) => {
+                            const resultGateProgress = getResultGate().process(dispatchId);
+                            return {
+                                result_gate: resultGateProgress,
+                                review_delivery: resultGateProgress.status === "completed"
+                                    ? getReviewDelivery().advance(dispatchId, resultGateProgress)
+                                    : null,
+                            };
+                        },
+                        input: process.stdin,
+                        output: process.stdout,
+                    });
+                    return { ok: true, exitCode: 0 };
+                }
+                if (conductor.command === "observe") {
+                    const raw = context.readStdin ? context.readStdin() : readBoundedUtf8(0, 64 * 1024);
+                    const input = JSON.parse(raw);
+                    const hook = parseConductorActivityHook(input, conductor.sessionId, conductor.hookEvent, workspaceRoot);
+                    const binding = inspectConductorRuntimeBinding({
+                        workspaceRoot,
+                        stateRoot,
+                        sessionId: conductor.sessionId,
+                        env: context.env,
+                    });
+                    const runtime = createEnduranceAuthorities({ packageRoot, configRoot: sourceRoot, stateRoot });
+                    try {
+                        runtime.conductorActivity.observe({
+                            conductorSessionId: binding.session_id,
+                            launchGeneration: binding.launch_generation,
+                            paneId: binding.pane_id,
+                            conductorProcess: readLinuxProcessIdentity(binding.process_id),
+                            providerVersion: conductor.providerVersion,
+                            hookEvent: hook.hook_event_name,
+                            sourceSha256: sha256Canonical(input),
+                            observedAt: (context.clockSample ?? systemClockSample)().wallTime,
+                        });
+                    }
+                    finally {
+                        runtime.close();
+                    }
+                    return { ok: true, exitCode: 0 };
+                }
+                if (conductor.command === "consume-event") {
+                    const raw = context.readStdin ? context.readStdin() : readBoundedUtf8(0, 64 * 1024);
+                    const input = JSON.parse(raw);
+                    const runtime = createEnduranceAuthorities({ packageRoot, configRoot: sourceRoot, stateRoot });
+                    try {
+                        const delivered = runtime.notifications.list().filter((record) => (record.state === "delivered"
+                            && record.payload.delivered_to_session_id === conductor.sessionId));
+                        if (delivered.length > 1)
+                            throw new Error("conductor has multiple delivered notifications");
+                        if (delivered[0] && isMatchingConductorNotificationRead(input, conductor.sessionId, workspaceRoot, stateRoot, delivered[0].record_id)) {
+                            runtime.notifications.consume({
+                                notificationId: delivered[0].record_id,
+                                sessionId: conductor.sessionId,
+                                observedAt: (context.clockSample ?? systemClockSample)().wallTime,
+                            });
+                        }
+                    }
+                    finally {
+                        runtime.close();
+                    }
+                    return { ok: true, exitCode: 0 };
+                }
+                if (conductor.command === "wait-event") {
+                    const raw = context.readStdin ? context.readStdin() : readBoundedUtf8(0, 64 * 1024);
+                    const hook = parseConductorWaitHook(JSON.parse(raw), conductor.sessionId, conductor.hookEvent, workspaceRoot);
+                    const binding = inspectConductorRuntimeBinding({
+                        workspaceRoot,
+                        stateRoot,
+                        sessionId: conductor.sessionId,
+                        env: context.env,
+                    });
+                    const wait = context.conductorWait ?? waitForConductorNotification;
+                    const runtime = createEnduranceAuthorities({ packageRoot, configRoot: sourceRoot, stateRoot });
+                    let result;
+                    try {
+                        result = await wait({
+                            waiterStore: runtime.waiters,
+                            notificationStore: runtime.notifications,
+                            arm: {
+                                conductorSessionId: binding.session_id,
+                                launchGeneration: binding.launch_generation,
+                                paneId: binding.pane_id,
+                                conductorProcess: readLinuxProcessIdentity(binding.process_id),
+                                waiterProcess: readLinuxProcessIdentity(),
+                                armedBy: hook.hook_event_name,
+                                observedAt: (context.clockSample ?? systemClockSample)().wallTime,
+                            },
+                            canDeliver: () => runtime.conductorActivity.readIfExists(binding.session_id, binding.launch_generation)?.state === "idle",
+                            conductorIsLive: linuxProcessIdentityIsLive,
+                            onNotificationClaimed: (notificationId, observedAt) => {
+                                runtime.conductorActivity.observe({
+                                    conductorSessionId: binding.session_id,
+                                    launchGeneration: binding.launch_generation,
+                                    paneId: binding.pane_id,
+                                    conductorProcess: readLinuxProcessIdentity(binding.process_id),
+                                    providerVersion: conductor.providerVersion,
+                                    hookEvent: "NotificationWake",
+                                    sourceSha256: createHash("sha256").update(notificationId, "utf8").digest("hex"),
+                                    observedAt,
+                                });
+                            },
+                        });
+                    }
+                    finally {
+                        runtime.close();
+                    }
+                    if (result.notificationId !== null) {
+                        (context.writeStderr ?? ((value) => process.stderr.write(value)))(`${result.notificationId}\n`);
+                    }
+                    return { ok: result.exitCode !== 1, exitCode: result.exitCode };
+                }
+                return {
+                    ok: true,
+                    exitCode: 0,
+                    output: conductorNext({
+                        packageRoot,
+                        configRoot: sourceRoot,
+                        stateRoot,
+                        runId: conductor.runId,
+                    }),
+                };
+            }
+            case "structured-role": {
+                const structuredRole = parseStructuredRoleArgs(args);
+                const roleWorkspaceRoot = validateExistingDirectory(resolve(structuredRole.workspaceRoot), "structured-role workspace root");
+                const stateRoot = requireInitializedState({
+                    workspaceRoot: roleWorkspaceRoot,
+                    override: structuredRole.stateRoot,
+                    env: context.env,
+                    cwd: context.cwd ?? workspaceRoot,
+                });
+                const serve = context.structuredRoleBridge ?? runClaudeStructuredRoleBridge;
+                await serve({
+                    packageRoot,
+                    stateRoot,
+                    requestId: structuredRole.requestId,
+                    sessionId: structuredRole.sessionId,
+                    onResultSubmitted: (result) => {
+                        projectClaudeStructuredRoleCompletion({
+                            packageRoot,
+                            stateRoot,
+                            requestId: result.request_id,
+                        });
+                    },
+                    onResultProjectionFailure: (requestId, error) => {
+                        const write = context.writeStderr ?? ((value) => process.stderr.write(value));
+                        const reason = errorMessage(error).trim().replace(/[\0\r\n]+/gu, " ").slice(0, 512) || "unknown projection error";
+                        write(`oms: structured completion ${requestId} awaits watchdog recovery: ${reason}\n`);
+                    },
+                    input: process.stdin,
+                    output: process.stdout,
+                });
+                return { ok: true, exitCode: 0 };
+            }
+            case "worker": {
+                const worker = parseWorkerArgs(args);
+                const workerWorkspaceRoot = worker.workspaceRoot
+                    ? validateExistingDirectory(resolve(worker.workspaceRoot), "worker workspace root")
+                    : workspaceRoot;
+                const workerConfigRoot = worker.configRoot
+                    ? validateExistingDirectory(resolve(worker.configRoot), "worker configuration root")
+                    : sourceRoot;
+                const stateRoot = requireInitializedState({
+                    workspaceRoot: workerWorkspaceRoot,
+                    override: worker.stateRoot,
+                    env: context.env,
+                    cwd: context.cwd ?? workspaceRoot,
+                });
+                if (worker.command === "bridge") {
+                    const serve = context.workerBridge ?? runWorkerBridge;
+                    await serve({
+                        packageRoot,
+                        configRoot: workerConfigRoot,
+                        workspaceRoot: workerWorkspaceRoot,
+                        stateRoot,
+                        dispatchId: worker.dispatchId,
+                        sessionId: worker.sessionId,
+                        cwd: context.cwd ?? process.cwd(),
+                        env: context.env,
+                        input: process.stdin,
+                        output: process.stdout,
+                    });
+                    return { ok: true, exitCode: 0 };
+                }
+                const createDelivery = context.workerDelivery ?? createWorkerDeliveryService;
+                const delivery = createDelivery({
+                    packageRoot,
+                    configRoot: workerConfigRoot,
+                    workspaceRoot: workerWorkspaceRoot,
+                    stateRoot,
+                    executablePath: context.executablePath ?? resolveDefaultExecutable(packageRoot),
+                    env: context.env,
+                });
+                if (worker.command === "deliver") {
+                    return { ok: true, exitCode: 0, output: delivery.deliver(worker.eventId) };
+                }
+                if (worker.command === "status") {
+                    return { ok: true, exitCode: 0, output: delivery.observe(worker.dispatchId) };
+                }
+                if (worker.command === "resume") {
+                    return { ok: true, exitCode: 0, output: delivery.resume(worker.dispatchId) };
+                }
+                if (worker.command !== "park" && worker.command !== "stop")
+                    throw new Error("unsupported worker lifecycle command");
+                const reason = readReasonInput(resolve(context.cwd ?? workspaceRoot, worker.reasonFile), packageRoot);
+                return {
+                    ok: true,
+                    exitCode: 0,
+                    output: worker.command === "park"
+                        ? delivery.park(worker.dispatchId, reason, worker.parkedUntil)
+                        : delivery.stop(worker.dispatchId, reason),
+                };
+            }
+            case "goal": {
+                const goal = parseGoalArgs(args);
+                const stateRoot = requireInitializedState({
+                    workspaceRoot,
+                    override: goal.stateRoot,
+                    env: context.env,
+                    cwd: context.cwd ?? workspaceRoot,
+                });
+                const runtime = createRuntimeGoalAuthority({ packageRoot, stateRoot });
+                if (goal.command === "create") {
+                    const inputPath = resolve(context.cwd ?? workspaceRoot, goal.file);
+                    const input = readJsonFileNoFollow(inputPath, 128 * 1024);
+                    assertSchema(input, loadJsonSchema(join(packageRoot, "schemas", "goal-create-input.schema.json")), "goal create input");
+                    const candidate = input;
+                    const created = createGoal(runtime.authority, {
+                        objective: candidate.objective,
+                        stoppingCondition: candidate.stopping_condition,
+                        repositoryScope: workspaceRoot,
+                        leaderId: candidate.leader_id,
+                        createdAt: candidate.created_at,
+                    });
+                    return { ok: true, exitCode: 0, output: goalSummary(created) };
+                }
+                return { ok: true, exitCode: 0, output: goalSummary(readGoal(runtime.authority, goal.goalId)) };
+            }
+            case "team": {
+                const team = parseTeamArgs(args);
+                const stateRoot = requireInitializedState({
+                    workspaceRoot,
+                    override: team.stateRoot,
+                    env: context.env,
+                    cwd: context.cwd ?? workspaceRoot,
+                });
+                const createDelivery = context.workerDelivery ?? createWorkerDeliveryService;
+                const delivery = createDelivery({
+                    packageRoot,
+                    configRoot: sourceRoot,
+                    workspaceRoot,
+                    stateRoot,
+                    executablePath: context.executablePath ?? resolveDefaultExecutable(packageRoot),
+                    env: context.env,
+                });
+                return {
+                    ok: true,
+                    exitCode: 0,
+                    output: startExecutorGroup({
+                        packageRoot,
+                        configRoot: sourceRoot,
+                        workspaceRoot,
+                        stateRoot,
+                        dispatchIds: team.dispatchIds,
+                        delivery,
+                    }),
+                };
+            }
+            case "trust": {
+                const trust = parseTrustArgs(args);
+                const stateRoot = requireInitializedState({
+                    workspaceRoot,
+                    override: trust.stateRoot,
+                    env: context.env,
+                    cwd: context.cwd ?? workspaceRoot,
+                });
+                const tickets = createRuntimeTicketAuthorities({
+                    packageRoot,
+                    configRoot: sourceRoot,
+                    stateRoot,
+                    actorId: "oms-system",
+                });
+                return {
+                    ok: true,
+                    exitCode: 0,
+                    output: writeDailyTrustReport({
+                        evidenceStore: tickets.evidenceStore,
+                        utcDate: trust.utcDate,
+                        packageRoot: sourceRoot,
+                    }),
+                };
+            }
+            case "hud": {
+                const override = parseStateRoot(args);
+                const stateRoot = requireInitializedState({ workspaceRoot, override, env: context.env, cwd: context.cwd ?? workspaceRoot });
+                const runtime = createEnduranceAuthorities({ packageRoot, configRoot: sourceRoot, stateRoot });
+                try {
+                    const snapshot = createHudSnapshot({
+                        queue: runtime.tickets.queue,
+                        sessions: runtime.sessions,
+                        quota: runtime.quota,
+                        outbox: runtime.outbox,
+                        workers: runtime.workers,
+                        conductorActivity: runtime.conductorActivity,
+                        conductorProcessIsLive: linuxProcessIdentityIsLive,
+                    });
+                    return { ok: true, exitCode: 0, message: renderHud(snapshot), output: snapshot };
+                }
+                finally {
+                    runtime.close();
+                }
+            }
+            case "release": {
+                if (args[0] !== "status")
+                    throw new Error("release requires the status subcommand");
+                requireNoOptions("release status", args.slice(1));
+                return { ok: true, exitCode: 0, output: assessRelease(packageRoot) };
+            }
+            case "verify": {
+                requireNoOptions("verify", args);
+                const lines = context.verify
+                    ? context.verify(packageRoot, workspaceRoot, sourceRoot)
+                    : runVerification(packageRoot, { workspaceRoot, configRoot: sourceRoot });
+                return { ok: true, exitCode: 0, message: lines.join("\n") };
+            }
+            default:
+                throw new Error(`command not implemented in M0: ${command}`);
+        }
+    }
+    catch (error) {
+        return { ok: false, exitCode: 1, message: `oms: ${errorMessage(error)}` };
+    }
+}
+function hasOmsConfiguration(root) {
+    const configPath = join(root, ".agents", "config", "oms-config.json");
+    const entry = lstatIfExists(configPath);
+    if (!entry)
+        return false;
+    if (!entry.isFile() || entry.isSymbolicLink()) {
+        throw new Error(`OMS configuration must be a non-symbolic regular file: ${configPath}`);
+    }
+    return true;
+}
+function isOmsGitWorkspace(root) {
+    if (!hasOmsConfiguration(root))
+        return false;
+    readOmsConfig(root);
+    return isGitWorkspace(root);
+}
+function isGitWorkspace(root) {
+    const gitPath = join(root, ".git");
+    const entry = lstatIfExists(gitPath);
+    if (!entry)
+        return false;
+    if (entry.isSymbolicLink() || (!entry.isDirectory() && !entry.isFile())) {
+        throw new Error(`OMS Git marker must be a non-symbolic file or directory: ${gitPath}`);
+    }
+    return true;
+}
+function discoverAuthorizedConductorStateRoot(options) {
+    const env = options.env ?? process.env;
+    if (env.OMS_STATE_ROOT)
+        return undefined;
+    const defaultRoot = join(options.workspaceRoot, ".oms");
+    if (!existsSync(defaultRoot))
+        return undefined;
+    const rootEntry = lstatSync(defaultRoot);
+    if (!rootEntry.isDirectory() || rootEntry.isSymbolicLink()) {
+        throw new Error("OMS requires .oms to be a non-symbolic directory");
+    }
+    const candidates = [
+        defaultRoot,
+        ...readdirSync(defaultRoot, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => join(defaultRoot, entry.name)),
+    ];
+    const authorized = candidates.filter((candidate) => {
+        const authorizationPath = join(candidate, "conductors", "live-delivery-authorization.json");
+        if (!existsSync(authorizationPath))
+            return false;
+        const state = readStateSummary({
+            workspaceRoot: options.workspaceRoot,
+            override: candidate,
+            env,
+            cwd: options.cwd,
+        });
+        if (!state.initialized)
+            throw new Error(`authorized OMS state is not initialized: ${candidate}`);
+        return readLiveDeliveryAuthorization(candidate) !== undefined;
+    });
+    if (authorized.length > 1) {
+        throw new Error("OMS found multiple repository-authorized state roots; set OMS_STATE_ROOT explicitly");
+    }
+    return authorized[0];
+}
+export function printResult(result) {
+    if (result.output !== undefined)
+        process.stdout.write(`${JSON.stringify(result.output, null, 2)}\n`);
+    if (result.message) {
+        const stream = result.ok ? process.stdout : process.stderr;
+        stream.write(`${result.message}\n`);
+    }
+}
+export async function main(argv = process.argv.slice(2)) {
+    const result = await runCli(argv, {
+        requestBareLiveDeliveryAuthorization: requestBareLiveDeliveryAuthorization,
+    });
+    printResult(result);
+    process.exitCode = result.exitCode;
+}
+export async function requestBareLiveDeliveryAuthorization(request, io = {}) {
+    const expectedRepository = request.required_repository ?? request.suggested_repository;
+    const exampleRepository = expectedRepository ?? "OWNER/REPO";
+    const input = io.input ?? process.stdin;
+    const output = io.output ?? process.stdout;
+    output.write([
+        "OMS requires one human confirmation before its first live conductor session.",
+        `Repository: ${expectedRepository ?? "not detected; enter the actual OWNER/REPO"}`,
+        "Provider spend: subscription",
+        "GitHub spend: none",
+        `Allowed operations: ${[...LIVE_CONTACT_OPERATIONS, PRE_DISPATCH_ADVICE_OPERATION].join(", ")}`,
+        "OMS cannot merge, release, publish, or modify branch protection.",
+    ].join("\n") + "\n");
+    const terminal = createInterface({ input, output });
+    try {
+        const prompt = expectedRepository
+            ? `Type \"authorize ${exampleRepository}\" to continue: `
+            : "Type \"authorize OWNER/REPO\" with the actual repository to continue: ";
+        const answer = await Promise.race([
+            terminal.question(prompt),
+            new Promise((resolveClosed) => terminal.once("close", () => resolveClosed(null))),
+        ]);
+        if (answer === null)
+            return null;
+        const match = /^authorize ([^\s]+)$/u.exec(answer.trim());
+        return match?.[1] ?? null;
+    }
+    finally {
+        terminal.close();
+    }
+}
+function inferBareGithubRepository(options) {
+    const result = options.runner({
+        command: "git",
+        args: ["remote", "get-url", "--push", "origin"],
+        cwd: options.workspaceRoot,
+        env: bareGitEnvironment(options.env ?? process.env),
+        timeoutMs: 10_000,
+        maxBufferBytes: 64 * 1024,
+    });
+    if (result.error || result.status !== 0 || result.signal !== null)
+        return null;
+    try {
+        return normalizeGithubRemoteRepository(result.stdout.trim());
+    }
+    catch {
+        return null;
+    }
+}
+function bareGitEnvironment(source) {
+    const env = {};
+    for (const key of ["PATH", "HOME", "TMPDIR", "TMP", "TEMP", "LANG", "LC_ALL", "SYSTEMROOT"]) {
+        if (source[key] !== undefined)
+            env[key] = source[key];
+    }
+    env.GIT_TERMINAL_PROMPT = "0";
+    env.GIT_CONFIG_NOSYSTEM = "1";
+    env.GIT_CONFIG_GLOBAL = "/dev/null";
+    return env;
+}
+function parseStateRoot(args) {
+    let value;
+    for (let index = 0; index < args.length; index += 1) {
+        const argument = args[index];
+        if (argument !== "--state-root")
+            throw new Error(`unknown option: ${argument ?? ""}`);
+        const next = args[index + 1];
+        if (!next)
+            throw new Error("--state-root requires a path");
+        value = next;
+        index += 1;
+    }
+    return value;
+}
+function parseProviderHookArgs(args) {
+    if (args[0] !== "provider")
+        throw new Error("hook requires ingest or provider");
+    const values = new Map();
+    const allowed = new Set([
+        "--provider",
+        "--provider-version",
+        "--dispatch-id",
+        "--session-id",
+        "--state-root",
+        "--workspace-root",
+        "--config-root",
+    ]);
+    for (let index = 1; index < args.length; index += 2) {
+        const option = args[index];
+        const value = args[index + 1];
+        if (!option || !allowed.has(option))
+            throw new Error(`unknown option: ${option ?? ""}`);
+        if (values.has(option))
+            throw new Error(`duplicate option: ${option}`);
+        if (!value || value.startsWith("--"))
+            throw new Error(`${option} requires a value`);
+        values.set(option, value);
+    }
+    const provider = values.get("--provider");
+    if (provider !== "claude" && provider !== "codex")
+        throw new Error("hook provider requires --provider claude|codex");
+    const providerVersion = values.get("--provider-version");
+    if (providerVersion !== SUPPORTED_PROVIDER_HOOK_VERSIONS[provider]) {
+        throw new Error(`unsupported ${provider} provider version`);
+    }
+    const dispatchId = values.get("--dispatch-id");
+    const sessionId = values.get("--session-id");
+    const stateRoot = values.get("--state-root");
+    const workspaceRoot = values.get("--workspace-root");
+    const configRoot = values.get("--config-root");
+    if (!dispatchId || !sessionId || !stateRoot || !workspaceRoot || !configRoot) {
+        throw new Error("hook provider requires dispatch, session, state, workspace, and config bindings");
+    }
+    return { provider, providerVersion, dispatchId, sessionId, stateRoot, workspaceRoot, configRoot };
+}
+function requireNoOptions(command, args) {
+    if (args.length > 0)
+        throw new Error(`${command} takes no options`);
+}
+function resolveDefaultExecutable(packageRoot) {
+    const sourceShim = join(packageRoot, "bin", "oms");
+    if (existsSync(sourceShim))
+        return realpathSync(sourceShim);
+    const entrypoint = process.argv[1];
+    if (!entrypoint)
+        throw new Error("unable to resolve the installed OMS executable");
+    return realpathSync(entrypoint);
+}
+export function readBoundedUtf8(fileDescriptor, maxBytes) {
+    if (!Number.isSafeInteger(fileDescriptor) || fileDescriptor < 0)
+        throw new Error("invalid bounded input descriptor");
+    if (!Number.isSafeInteger(maxBytes) || maxBytes < 1)
+        throw new Error("invalid bounded input limit");
+    const chunks = [];
+    let total = 0;
+    while (true) {
+        const chunk = Buffer.allocUnsafe(Math.min(8 * 1024, maxBytes - total + 1));
+        const count = readSync(fileDescriptor, chunk, 0, chunk.byteLength, null);
+        if (count === 0)
+            break;
+        total += count;
+        if (total > maxBytes)
+            throw new Error(`native hook input exceeds ${maxBytes} bytes`);
+        chunks.push(chunk.subarray(0, count));
+    }
+    return Buffer.concat(chunks, total).toString("utf8");
+}
+function requireInitializedState(options) {
+    const summary = readStateSummary({
+        ...options,
+        override: activeStateRootOverride(options),
+    });
+    if (!summary.initialized)
+        throw new Error(`runtime state is not initialized: ${summary.state_root}`);
+    return summary.state_root;
+}
+function activeStateRootOverride(options) {
+    return options.override ?? discoverAuthorizedConductorStateRoot(options);
+}
+function parseReconcileArgs(args) {
+    const kind = args[0];
+    if (kind !== "minute" && kind !== "watchdog")
+        throw new Error("reconcile requires minute or watchdog");
+    let stateRoot;
+    let workspaceRoot;
+    const seen = new Set();
+    for (let index = 1; index < args.length; index += 1) {
+        const option = args[index];
+        if (option === "--scheduled") {
+            if (seen.has(option))
+                throw new Error(`duplicate option: ${option}`);
+            seen.add(option);
+            continue;
+        }
+        if (option !== "--state-root" && option !== "--workspace-root")
+            throw new Error(`unknown option: ${option ?? ""}`);
+        if (seen.has(option))
+            throw new Error(`duplicate option: ${option}`);
+        seen.add(option);
+        const value = args[index + 1];
+        if (!value || value.startsWith("--"))
+            throw new Error(`${option} requires a path`);
+        if (option === "--state-root")
+            stateRoot = value;
+        if (option === "--workspace-root")
+            workspaceRoot = value;
+        index += 1;
+    }
+    return { kind, stateRoot, workspaceRoot };
+}
+function parseEventsArgs(args) {
+    if (args[0] !== "sync" || args[1] !== "github")
+        throw new Error("events requires sync github");
+    let repository;
+    let stateRoot;
+    let workspaceRoot;
+    const seen = new Set();
+    for (let index = 2; index < args.length; index += 1) {
+        const option = args[index];
+        if (option !== "--repository" && option !== "--state-root" && option !== "--workspace-root") {
+            throw new Error(`unknown option: ${option ?? ""}`);
+        }
+        if (seen.has(option))
+            throw new Error(`duplicate option: ${option}`);
+        seen.add(option);
+        const value = args[index + 1];
+        if (!value || value.startsWith("--"))
+            throw new Error(`${option} requires a value`);
+        if (option === "--repository")
+            repository = value;
+        if (option === "--state-root")
+            stateRoot = value;
+        if (option === "--workspace-root")
+            workspaceRoot = value;
+        index += 1;
+    }
+    if (!repository)
+        throw new Error("events sync github requires --repository");
+    return { repository, stateRoot, workspaceRoot };
+}
+function parseScheduleArgs(args) {
+    const command = args[0];
+    if (command !== "generate" && command !== "install" && command !== "status" && command !== "remove") {
+        throw new Error("schedule requires generate, install, status, or remove");
+    }
+    let manager;
+    let repository;
+    let githubPollSeconds;
+    let managerExecutable;
+    let stateRoot;
+    const seen = new Set();
+    for (let index = 1; index < args.length; index += 1) {
+        const option = args[index];
+        if (option !== "--manager"
+            && option !== "--repository"
+            && option !== "--github-poll-seconds"
+            && option !== "--manager-executable"
+            && option !== "--state-root") {
+            throw new Error(`unknown option: ${option ?? ""}`);
+        }
+        if (seen.has(option))
+            throw new Error(`duplicate option: ${option}`);
+        seen.add(option);
+        const value = args[index + 1];
+        if (!value || value.startsWith("--"))
+            throw new Error(`${option} requires a value`);
+        if (option === "--manager") {
+            if (value !== "cron" && value !== "systemd" && value !== "launchd")
+                throw new Error("invalid service manager");
+            manager = value;
+        }
+        if (option === "--repository")
+            repository = value;
+        if (option === "--github-poll-seconds") {
+            if (!/^[1-9][0-9]{1,3}$/u.test(value))
+                throw new Error("invalid GitHub poll interval");
+            githubPollSeconds = Number(value);
+        }
+        if (option === "--manager-executable")
+            managerExecutable = value;
+        if (option === "--state-root")
+            stateRoot = value;
+        index += 1;
+    }
+    if (!manager || !repository)
+        throw new Error(`schedule ${command} requires --manager and --repository`);
+    return { command, manager, repository, githubPollSeconds, managerExecutable, stateRoot };
+}
+function defaultManagerExecutable(manager) {
+    if (manager === "systemd")
+        return "/usr/bin/systemctl";
+    if (manager === "launchd")
+        return "/bin/launchctl";
+    return "/usr/bin/crontab";
+}
+function parseRunArgs(args) {
+    const command = args[0];
+    if (command !== "start" && command !== "tick" && command !== "close" && command !== "abort" && command !== "recover-controller" && command !== "status") {
+        throw new Error("run requires start, tick, close, abort, recover-controller, or status");
+    }
+    let runId;
+    let stateRoot;
+    let manager;
+    let runKind;
+    let reasonFile;
+    let generationId;
+    const seen = new Set();
+    for (let index = 1; index < args.length; index += 1) {
+        const option = args[index];
+        if (!option)
+            throw new Error("invalid empty run option");
+        if (seen.has(option))
+            throw new Error(`duplicate option: ${option}`);
+        seen.add(option);
+        if (option === "--until-empty") {
+            if (command !== "start")
+                throw new Error("--until-empty is valid only for run start");
+            if (runKind)
+                throw new Error("run start requires exactly one terminal mode");
+            runKind = "until-empty";
+            continue;
+        }
+        if (!["--for", "--generation-id", "--manager", "--run-id", "--reason-file", "--state-root"].includes(option)) {
+            throw new Error(`unknown option: ${option}`);
+        }
+        const value = args[index + 1];
+        if (!value || value.startsWith("--"))
+            throw new Error(`${option} requires a value`);
+        index += 1;
+        if (option === "--state-root")
+            stateRoot = value;
+        if (option === "--run-id")
+            runId = value;
+        if (option === "--reason-file")
+            reasonFile = value;
+        if (option === "--generation-id")
+            generationId = value;
+        if (option === "--for") {
+            if (command !== "start")
+                throw new Error("--for is valid only for run start");
+            if (runKind)
+                throw new Error("run start requires exactly one terminal mode");
+            if (value !== "12h" && value !== "24h")
+                throw new Error("run --for requires 12h or 24h");
+            runKind = value;
+        }
+        if (option === "--manager") {
+            if (command !== "start")
+                throw new Error("--manager is valid only for run start");
+            if (value !== "cron" && value !== "systemd" && value !== "launchd")
+                throw new Error("invalid service manager");
+            manager = value;
+        }
+    }
+    if (command === "start") {
+        if (!runKind)
+            throw new Error("run start requires --until-empty or --for 12h|24h");
+        if (!manager)
+            throw new Error("run start requires --manager");
+        if (runId || reasonFile || generationId)
+            throw new Error("run start accepts only its terminal mode, manager, and state root");
+        return { command, runKind, manager, stateRoot };
+    }
+    if (manager || runKind)
+        throw new Error(`run ${command} does not accept a terminal mode or manager`);
+    if (command === "recover-controller") {
+        if (runId || !generationId || !reasonFile) {
+            throw new Error("run recover-controller requires --generation-id and --reason-file and does not accept --run-id");
+        }
+        return { command, generationId, reasonFile, stateRoot };
+    }
+    if (generationId)
+        throw new Error(`run ${command} does not accept --generation-id`);
+    if (command === "abort") {
+        if (!runId || !reasonFile)
+            throw new Error("run abort requires --run-id and --reason-file");
+        return { command, runId, reasonFile, stateRoot };
+    }
+    if (reasonFile)
+        throw new Error(`run ${command} does not accept --reason-file`);
+    if (command === "tick" || command === "close") {
+        if (!runId)
+            throw new Error(`run ${command} requires --run-id`);
+        return { command, runId, stateRoot };
+    }
+    return { command, runId, stateRoot };
+}
+function parseConductorArgs(args) {
+    const command = args[0];
+    if (command !== "start"
+        && command !== "bridge"
+        && command !== "observe"
+        && command !== "consume-event"
+        && command !== "wait-event"
+        && command !== "next") {
+        throw new Error("conductor requires start, bridge, observe, consume-event, wait-event, or next");
+    }
+    let runId;
+    let sessionId;
+    let stateRoot;
+    let hookEvent;
+    let providerVersion;
+    let repository;
+    let confirmLiveDelivery = false;
+    const seen = new Set();
+    for (let index = 1; index < args.length; index += 1) {
+        const option = args[index];
+        if (option === "--confirm-live-delivery") {
+            if (seen.has(option))
+                throw new Error(`duplicate option: ${option}`);
+            seen.add(option);
+            confirmLiveDelivery = true;
+            continue;
+        }
+        if (option !== "--run-id"
+            && option !== "--session-id"
+            && option !== "--state-root"
+            && option !== "--hook-event"
+            && option !== "--provider-version"
+            && option !== "--repository") {
+            throw new Error(`unknown option: ${option ?? ""}`);
+        }
+        if (seen.has(option))
+            throw new Error(`duplicate option: ${option}`);
+        seen.add(option);
+        const value = args[index + 1];
+        if (!value || value.startsWith("--"))
+            throw new Error(`${option} requires a value`);
+        if (option === "--run-id")
+            runId = value;
+        if (option === "--session-id")
+            sessionId = value;
+        if (option === "--state-root")
+            stateRoot = value;
+        if (option === "--hook-event") {
+            if (!["SessionStart", "UserPromptSubmit", "Stop", "StopFailure", "SessionEnd"].includes(value)) {
+                throw new Error("invalid conductor hook event");
+            }
+            hookEvent = value;
+        }
+        if (option === "--provider-version") {
+            if (value !== SUPPORTED_PROVIDER_HOOK_VERSIONS.claude)
+                throw new Error("unsupported conductor provider version");
+            providerVersion = value;
+        }
+        if (option === "--repository")
+            repository = value;
+        index += 1;
+    }
+    if (command === "start") {
+        if (runId || sessionId || hookEvent || providerVersion) {
+            throw new Error("conductor start accepts only --state-root and paired live-delivery options");
+        }
+        if (confirmLiveDelivery !== (repository !== undefined)) {
+            throw new Error("conductor start live delivery requires --repository and --confirm-live-delivery together");
+        }
+        return { command, stateRoot, repository };
+    }
+    if (repository || confirmLiveDelivery)
+        throw new Error(`conductor ${command} does not accept live-delivery options`);
+    if (command === "bridge") {
+        if (!sessionId || runId || hookEvent || providerVersion)
+            throw new Error("conductor bridge requires --session-id and does not accept --run-id");
+        return { command, sessionId, stateRoot };
+    }
+    if (command === "observe") {
+        if (!sessionId || !hookEvent || !providerVersion || runId) {
+            throw new Error("conductor observe requires --session-id, --hook-event, and --provider-version");
+        }
+        return { command, sessionId, hookEvent, providerVersion, stateRoot };
+    }
+    if (command === "consume-event") {
+        if (!sessionId || !providerVersion || runId || hookEvent) {
+            throw new Error("conductor consume-event requires --session-id and --provider-version");
+        }
+        return { command, sessionId, providerVersion, stateRoot };
+    }
+    if (command === "wait-event") {
+        if (!sessionId || !providerVersion || (hookEvent !== "SessionStart" && hookEvent !== "Stop") || runId) {
+            throw new Error("conductor wait-event requires --session-id, SessionStart|Stop, and --provider-version");
+        }
+        return { command, sessionId, hookEvent, providerVersion, stateRoot };
+    }
+    if (!runId || sessionId || hookEvent || providerVersion)
+        throw new Error("conductor next requires --run-id and does not accept --session-id");
+    return { command, runId, stateRoot };
+}
+function parseConductorWaitHook(value, expectedSessionId, expectedEvent, workspaceRoot) {
+    if (!isRecord(value))
+        throw new Error("conductor waiter hook input must be an object");
+    if (value.session_id !== expectedSessionId || value.hook_event_name !== expectedEvent) {
+        throw new Error("conductor waiter hook binding mismatch");
+    }
+    if (typeof value.cwd !== "string" || resolve(value.cwd) !== workspaceRoot) {
+        throw new Error("conductor waiter hook workspace mismatch");
+    }
+    return Object.freeze({ session_id: expectedSessionId, hook_event_name: expectedEvent });
+}
+function parseConductorActivityHook(value, expectedSessionId, expectedEvent, workspaceRoot) {
+    if (!isRecord(value))
+        throw new Error("conductor activity hook input must be an object");
+    if (value.session_id !== expectedSessionId || value.hook_event_name !== expectedEvent) {
+        throw new Error("conductor activity hook binding mismatch");
+    }
+    if (typeof value.cwd !== "string" || resolve(value.cwd) !== workspaceRoot) {
+        throw new Error("conductor activity hook workspace mismatch");
+    }
+    return Object.freeze({ session_id: expectedSessionId, hook_event_name: expectedEvent });
+}
+function isMatchingConductorNotificationRead(value, expectedSessionId, workspaceRoot, stateRoot, notificationId) {
+    if (!isRecord(value) || value.session_id !== expectedSessionId || value.hook_event_name !== "PostToolUse") {
+        throw new Error("conductor read hook binding mismatch");
+    }
+    if (typeof value.cwd !== "string" || resolve(value.cwd) !== workspaceRoot || value.tool_name !== "Read") {
+        throw new Error("conductor read hook context mismatch");
+    }
+    if (!isRecord(value.tool_input) || typeof value.tool_input.file_path !== "string")
+        return false;
+    const candidate = resolve(value.tool_input.file_path);
+    const expected = join(realpathSync.native(stateRoot), "conductor-notifications", `${notificationId}.json`);
+    if (candidate !== expected)
+        return false;
+    if (!existsSync(candidate))
+        return false;
+    const entry = lstatSync(candidate);
+    if (entry.isSymbolicLink() || !entry.isFile())
+        return false;
+    return realpathSync.native(candidate) === expected;
+}
+function sha256Canonical(value) {
+    return createHash("sha256").update(canonicalJson(value), "utf8").digest("hex");
+}
+function publicGithubSyncRequest(request) {
+    return {
+        command: request.command,
+        args: [...request.args],
+        cwd_sha256: createHash("sha256").update(request.cwd, "utf8").digest("hex"),
+        input_sha256: request.input === undefined
+            ? null
+            : createHash("sha256").update(request.input, "utf8").digest("hex"),
+        timeout_ms: request.timeoutMs,
+        max_buffer_bytes: request.maxBufferBytes,
+    };
+}
+function canonicalJson(value) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return JSON.stringify(value);
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new Error("hook input contains a non-finite number");
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (isRecord(value)) {
+        return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
+    }
+    throw new Error("hook input must contain only JSON values");
+}
+function parseGoalArgs(args) {
+    const command = args[0];
+    if (command !== "create" && command !== "status")
+        throw new Error("goal requires create or status");
+    let file;
+    let goalId;
+    let stateRoot;
+    const seen = new Set();
+    for (let index = 1; index < args.length; index += 1) {
+        const option = args[index];
+        if (option !== "--file" && option !== "--goal-id" && option !== "--state-root") {
+            throw new Error(`unknown option: ${option ?? ""}`);
+        }
+        if (seen.has(option))
+            throw new Error(`duplicate option: ${option}`);
+        seen.add(option);
+        const value = args[index + 1];
+        if (!value || value.startsWith("--"))
+            throw new Error(`${option} requires a value`);
+        if (option === "--file")
+            file = value;
+        if (option === "--goal-id")
+            goalId = value;
+        if (option === "--state-root")
+            stateRoot = value;
+        index += 1;
+    }
+    if (command === "create") {
+        if (!file || goalId)
+            throw new Error("goal create requires --file and does not accept --goal-id");
+        return { command, file, stateRoot };
+    }
+    if (!goalId || file)
+        throw new Error("goal status requires --goal-id and does not accept --file");
+    return { command, goalId, stateRoot };
+}
+function parseStructuredRoleArgs(args) {
+    if (args[0] !== "bridge")
+        throw new Error("structured-role requires the bridge subcommand");
+    let requestId;
+    let sessionId;
+    let stateRoot;
+    let workspaceRoot;
+    const seen = new Set();
+    for (let index = 1; index < args.length; index += 1) {
+        const option = args[index];
+        if (option !== "--request-id" && option !== "--session-id" && option !== "--state-root" && option !== "--workspace-root") {
+            throw new Error(`unknown option: ${option ?? ""}`);
+        }
+        if (seen.has(option))
+            throw new Error(`duplicate option: ${option}`);
+        seen.add(option);
+        const value = args[index + 1];
+        if (!value || value.startsWith("--"))
+            throw new Error(`${option} requires a value`);
+        if (option === "--request-id")
+            requestId = value;
+        if (option === "--session-id")
+            sessionId = value;
+        if (option === "--state-root")
+            stateRoot = value;
+        if (option === "--workspace-root")
+            workspaceRoot = value;
+        index += 1;
+    }
+    if (!requestId || !sessionId || !stateRoot || !workspaceRoot) {
+        throw new Error("structured-role bridge requires --request-id, --session-id, --state-root, and --workspace-root");
+    }
+    return { command: "bridge", requestId, sessionId, stateRoot, workspaceRoot };
+}
+function parseWorkerArgs(args) {
+    const command = args[0];
+    if (command !== "deliver"
+        && command !== "status"
+        && command !== "park"
+        && command !== "resume"
+        && command !== "stop"
+        && command !== "bridge") {
+        throw new Error("worker requires deliver, status, park, resume, stop, or bridge");
+    }
+    let eventId;
+    let dispatchId;
+    let sessionId;
+    let stateRoot;
+    let workspaceRoot;
+    let configRoot;
+    let parkedUntil;
+    let reasonFile;
+    const seen = new Set();
+    for (let index = 1; index < args.length; index += 1) {
+        const option = args[index];
+        if (!option || ![
+            "--event-id",
+            "--dispatch-id",
+            "--session-id",
+            "--state-root",
+            "--workspace-root",
+            "--config-root",
+            "--until",
+            "--reason-file",
+        ].includes(option))
+            throw new Error(`unknown option: ${option ?? ""}`);
+        if (seen.has(option))
+            throw new Error(`duplicate option: ${option}`);
+        seen.add(option);
+        const value = args[index + 1];
+        if (!value || value.startsWith("--"))
+            throw new Error(`${option} requires a value`);
+        if (option === "--event-id")
+            eventId = value;
+        if (option === "--dispatch-id")
+            dispatchId = value;
+        if (option === "--session-id")
+            sessionId = value;
+        if (option === "--state-root")
+            stateRoot = value;
+        if (option === "--workspace-root")
+            workspaceRoot = value;
+        if (option === "--config-root")
+            configRoot = value;
+        if (option === "--until")
+            parkedUntil = value;
+        if (option === "--reason-file")
+            reasonFile = value;
+        index += 1;
+    }
+    if (command === "deliver") {
+        if (!eventId || dispatchId || sessionId || parkedUntil || reasonFile)
+            throw new Error("worker deliver requires only --event-id");
+        return { command, eventId, stateRoot, workspaceRoot, configRoot };
+    }
+    if (!dispatchId || eventId)
+        throw new Error(`worker ${command} requires --dispatch-id`);
+    if (command === "bridge") {
+        if (!sessionId || !stateRoot || !workspaceRoot || !configRoot || parkedUntil || reasonFile) {
+            throw new Error("worker bridge requires --dispatch-id, --session-id, --state-root, --workspace-root, and --config-root");
+        }
+        return { command, dispatchId, sessionId, stateRoot, workspaceRoot, configRoot };
+    }
+    if (sessionId)
+        throw new Error(`worker ${command} does not accept --session-id`);
+    if (command === "park") {
+        if (!parkedUntil || !reasonFile)
+            throw new Error("worker park requires --until and --reason-file");
+        return { command, dispatchId, parkedUntil, reasonFile, stateRoot, workspaceRoot, configRoot };
+    }
+    if (command === "stop") {
+        if (!reasonFile || parkedUntil)
+            throw new Error("worker stop requires --reason-file and does not accept --until");
+        return { command, dispatchId, reasonFile, stateRoot, workspaceRoot, configRoot };
+    }
+    if (parkedUntil || reasonFile)
+        throw new Error(`worker ${command} does not accept --until or --reason-file`);
+    return { command, dispatchId, stateRoot, workspaceRoot, configRoot };
+}
+function parseTeamArgs(args) {
+    if (args[0] !== "start")
+        throw new Error("team requires the start subcommand");
+    const dispatchIds = [];
+    let stateRoot;
+    for (let index = 1; index < args.length; index += 1) {
+        const option = args[index];
+        if (option !== "--dispatch-id" && option !== "--state-root")
+            throw new Error(`unknown option: ${option ?? ""}`);
+        const value = args[index + 1];
+        if (!value || value.startsWith("--"))
+            throw new Error(`${option} requires a value`);
+        if (option === "--dispatch-id")
+            dispatchIds.push(value);
+        else {
+            if (stateRoot)
+                throw new Error("duplicate option: --state-root");
+            stateRoot = value;
+        }
+        index += 1;
+    }
+    if (dispatchIds.length < 1 || dispatchIds.length > 20)
+        throw new Error("team start requires from 1 to 20 --dispatch-id values");
+    return { dispatchIds, stateRoot };
+}
+function manageWorker(delivery, request) {
+    switch (request.action) {
+        case "observe":
+            return delivery.observe(request.dispatch_id);
+        case "resume":
+            return delivery.resume(request.dispatch_id);
+        case "park":
+            if (request.reason === null || request.parked_until === null)
+                throw new Error("park requires reason and parked_until");
+            return delivery.park(request.dispatch_id, request.reason, request.parked_until);
+        case "stop":
+            if (request.reason === null)
+                throw new Error("stop requires reason");
+            return delivery.stop(request.dispatch_id, request.reason);
+    }
+}
+function startExecutorGroup(options) {
+    const runtime = createRuntimeDispatchAuthorities({
+        packageRoot: options.packageRoot,
+        configRoot: options.configRoot,
+        workspaceRoot: options.workspaceRoot,
+        stateRoot: options.stateRoot,
+        actorId: "oms-conductor",
+    });
+    const generated = generateExecutorGroupManifest({
+        dispatchIds: options.dispatchIds,
+        dispatchAuthority: runtime.dispatch,
+        teamPlansRoot: join(options.stateRoot, "team-plans"),
+        packageRoot: options.packageRoot,
+    });
+    const persisted = persistExecutorGroupManifest({ generated });
+    const workers = generated.plan.dispatch_ids.map((dispatchId) => {
+        const eventId = runtime.dispatch.read(dispatchId).payload.delivery_event_id;
+        if (!eventId)
+            throw new Error(`accepted Team dispatch has no delivery event: ${dispatchId}`);
+        return options.delivery.deliver(eventId);
+    });
+    return Object.freeze({
+        status: persisted.status,
+        path: persisted.path,
+        digest: generated.digest,
+        manifest: generated.plan,
+        workers,
+    });
+}
+function readReasonInput(path, packageRoot) {
+    const input = readJsonFileNoFollow(path, 16 * 1024);
+    assertSchema(input, loadJsonSchema(join(packageRoot, "schemas", "run-abort-input.schema.json")), "worker reason input");
+    return input.reason;
+}
+function parseTrustArgs(args) {
+    if (args[0] !== "report")
+        throw new Error("trust requires the report subcommand");
+    let utcDate;
+    let stateRoot;
+    const seen = new Set();
+    for (let index = 1; index < args.length; index += 1) {
+        const option = args[index];
+        if (option !== "--date" && option !== "--state-root")
+            throw new Error(`unknown option: ${option ?? ""}`);
+        if (seen.has(option))
+            throw new Error(`duplicate option: ${option}`);
+        seen.add(option);
+        const value = args[index + 1];
+        if (!value || value.startsWith("--"))
+            throw new Error(`${option} requires a value`);
+        if (option === "--date")
+            utcDate = value;
+        if (option === "--state-root")
+            stateRoot = value;
+        index += 1;
+    }
+    if (!utcDate)
+        throw new Error("trust report requires --date");
+    return { utcDate, stateRoot };
+}
+function goalSummary(goal) {
+    return Object.freeze({
+        goal_id: goal.record_id,
+        state: goal.state,
+        leader_id: goal.actor,
+        version: goal.version,
+        created_at: goal.payload.created_at,
+        updated_at: goal.payload.updated_at,
+        park_reason: goal.payload.park_reason,
+        release: "not_stable",
+    });
+}
+function parseGithubQueueProbeArgs(args) {
+    if (args[0] !== "github-queue")
+        throw new Error("probe requires the github-queue subcommand");
+    let runId;
+    let repository;
+    let readyLabel;
+    let limit;
+    let stateRoot;
+    let confirmLive = false;
+    const seen = new Set();
+    for (let index = 1; index < args.length; index += 1) {
+        const argument = args[index];
+        if (!argument)
+            throw new Error("invalid empty probe option");
+        if (seen.has(argument))
+            throw new Error(`duplicate option: ${argument}`);
+        seen.add(argument);
+        if (argument === "--confirm-live") {
+            confirmLive = true;
+            continue;
+        }
+        if (!["--run-id", "--repository", "--ready-label", "--limit", "--state-root"].includes(argument)) {
+            throw new Error(`unknown option: ${argument}`);
+        }
+        const value = args[index + 1];
+        if (!value || value.startsWith("--"))
+            throw new Error(`${argument} requires a value`);
+        index += 1;
+        if (argument === "--run-id")
+            runId = value;
+        if (argument === "--repository")
+            repository = value;
+        if (argument === "--ready-label")
+            readyLabel = value;
+        if (argument === "--state-root")
+            stateRoot = value;
+        if (argument === "--limit") {
+            if (!/^[1-9][0-9]{0,2}$/.test(value))
+                throw new Error("--limit must be an integer from 1 to 100");
+            limit = Number(value);
+            if (limit > 100)
+                throw new Error("--limit must be an integer from 1 to 100");
+        }
+    }
+    if (!runId)
+        throw new Error("probe github-queue requires --run-id");
+    if (!repository)
+        throw new Error("probe github-queue requires --repository");
+    return { runId, repository, readyLabel, limit, stateRoot, confirmLive };
+}
+function isEntrypoint() {
+    const argv1 = process.argv[1];
+    if (!argv1)
+        return false;
+    if (import.meta.url === pathToFileURL(argv1).href)
+        return true;
+    try {
+        return import.meta.url === pathToFileURL(realpathSync(argv1)).href;
+    }
+    catch {
+        return false;
+    }
+}
+if (isEntrypoint())
+    await main();
+//# sourceMappingURL=cli.js.map