openplanr 1.13.3 → 1.14.0

package/README.md

@@ -4,15 +4,17 @@
 
 ### Dedicated planning CLI and cross-runtime workflow control plane
 
-**Plan continuously. Route feature delivery anywhere.** Certified first for **Claude Code**, **Cursor**, and **Codex** through Protocol v1.0 artifacts plus v1.1 runtime contracts.
+**Plan continuously. Operate from evidence. Route feature delivery anywhere.**
+Certified first for **Claude Code**, **Cursor**, and **Codex** through Protocol
+v1.0 artifacts plus additive v1.1/v1.2 runtime and operating contracts.
 
 [![npm version](https://img.shields.io/npm/v/openplanr.svg?style=flat-square&color=cb3837&logo=npm)](https://www.npmjs.com/package/openplanr)
 [![node](https://img.shields.io/node/v/openplanr.svg?style=flat-square&color=339933&logo=node.js&logoColor=white)](https://nodejs.org)
 [![license](https://img.shields.io/npm/l/openplanr.svg?style=flat-square&color=blue)](https://github.com/openplanr/OpenPlanr/blob/main/LICENSE)
-[![protocol](https://img.shields.io/badge/protocol-v1.0.0-7c3aed?style=flat-square)](https://github.com/openplanr/planr-pipeline/tree/main/docs/protocol)
+[![protocol](https://img.shields.io/badge/protocol-v1.2.0-7c3aed?style=flat-square)](https://github.com/openplanr/planr-pipeline/tree/main/docs/protocol)
 [![runtimes](https://img.shields.io/badge/runtimes-Claude%20Code%20%7C%20Cursor%20%7C%20Codex-f97316?style=flat-square)](https://github.com/openplanr/planr-pipeline/blob/main/docs/compatibility-matrix.md)
 
-**[Website](https://openplanr.dev)** · **[Setup guide](docs/CROSS_RUNTIME_SETUP.md)** · **[Artifact review](docs/ARTIFACT_REVIEW.md)** · **[Compatibility matrix](https://github.com/openplanr/planr-pipeline/blob/main/docs/compatibility-matrix.md)** · **[Protocol spec](https://github.com/openplanr/planr-pipeline/tree/main/docs/protocol)** · **[CLI reference](docs/CLI.md)**
+**[Website](https://openplanr.dev)** · **[Setup guide](docs/CROSS_RUNTIME_SETUP.md)** · **[Operating Board](docs/OPERATING_BOARD.md)** · **[Artifact review](docs/ARTIFACT_REVIEW.md)** · **[Compatibility matrix](https://github.com/openplanr/planr-pipeline/blob/main/docs/compatibility-matrix.md)** · **[Protocol spec](https://github.com/openplanr/planr-pipeline/tree/main/docs/protocol)** · **[CLI reference](docs/CLI.md)**
 
 </div>
 
@@ -45,9 +47,12 @@ installations use `--minimal`; the full pipeline is the default.
 AI coding agents are powerful but lack structured planning context. Without a clear plan, they generate code that drifts from requirements, churn on the same problem across sessions, and can't be audited. OpenPlanr fixes this with four properties:
 
 1. **Markdown artifacts in your repo** — plans live next to your code, version-controlled, gittable, gradable. No external SaaS, no DB.
-2. **One contract, every runtime** — Claude Code, Cursor, and Codex consume the same v1.0 artifacts while locks, adapter capabilities, and provenance use additive v1.1 contracts.
+2. **One contract, every runtime** — Claude Code, Cursor, and Codex consume the same v1.0 planning artifacts while locks, adapter capabilities, and provenance use additive v1.1 contracts and Operating Board uses Protocol v1.2.
 3. **Three planning postures** — agile, quick task, or spec-driven planning, independent from the pipeline's feature-local PO phase.
 4. **Safe runtime migration** — setup previews exact changes, preserves hand-written content, records ownership, backs up exact bytes, and supports rollback.
+5. **Evidence-to-decision operations** — `planr operate` produces cited,
+   reviewable DEV, OWNER, and AGENT routes while preserving human authority and
+   the PLAN→SHIP gate.
 
 ---
 
@@ -163,10 +168,47 @@ room. Immutable fragments and encrypted short links remain available with
 `--snapshot`; the service stores ciphertext only.
 See the [artifact review and privacy guide](docs/ARTIFACT_REVIEW.md).
 
+### Run an operating cycle
+
+```bash
+planr operate inspect     # no initialization or credentials required
+planr operate demo        # deterministic, credential-free, no project writes
+planr operate init
+planr operate run --preview # no writes and no provider/model calls
+planr operate run           # provider calls require disclosed consent
+planr operate review
+```
+
+Operating Board governs direction; it never deploys, publishes, spends,
+contacts customers, or invokes SHIP. Missing evidence marks a lens
+`not_evaluated`. Accepting a finding records governance only; the exact route is
+previewed and applied separately. Planning-only installations retain
+`operate --help`, `inspect`, and `demo`; commands that require Protocol v1.2
+return `E_PIPELINE_NOT_INSTALLED` with the full-install recovery command. See the
+[Operating Board guide](docs/OPERATING_BOARD.md).
+
 ---
 
 ## Commands
 
+### Operating Board
+
+| Command | Description |
+|---|---|
+| `planr operate inspect` | Inspect workspace, runtime, evidence, and package readiness without initialization |
+| `planr operate demo` | Produce a real cited brief from sanitized deterministic fixtures |
+| `planr operate init` | Guide charter, workspace, runtime, privacy, and source setup |
+| `planr operate run` | Collect evidence and stop at a reviewable operating cycle |
+| `planr operate review` / `brief` / `status` | Review the concise brief and canonical lifecycle state |
+| `planr operate findings accept <id>` | Record governance without applying a route |
+| `planr operate routes apply <id>` | Apply one confirmed, digest-bound local route; Pipeline-PO DEV routes may return `awaiting-plan` and an exact native PLAN command |
+| `planr operate decisions decide <id>` | Record an owner decision |
+| `planr operate gaps answer <id>` | Supply missing evidence or charter context |
+| `planr operate gaps verify <id> --evidence-ref <id>` | Verify an answered gap against explicit evidence before closing it |
+| `planr operate run --review-only` | Reconcile verified shipment proofs and due outcome observations without evidence collection or model calls |
+| `planr operate cache status` / `purge` | Inspect or purge machine-local evidence |
+| `planr operate integrity status` / `enable` | Inspect integrity or enable externally keyed signed checkpoints |
+
 ### Spec-driven mode
 
 Third planning posture — designed for handing features to AI coding agents. Specs decompose into User Stories and Tasks with explicit file Create / Modify / Preserve lists, `Type: UI | Tech`, agent assignment, and DoD with build / test commands. Schema matches [OpenPlanr Protocol v1.0.0](https://github.com/openplanr/planr-pipeline/tree/main/docs/protocol); canonical JSON Schemas for this cleanup cycle live in `openplanr/planr-pipeline` under `schemas/v1.0.0/`.

package/dist/cli/commands/operate.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+export declare function registerOperateCommand(program: Command): void;
+//# sourceMappingURL=operate.d.ts.map

package/dist/cli/commands/operate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operate.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/operate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAgB,MAAM,WAAW,CAAC;AAkXvD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAwe7D"}

package/dist/cli/commands/operate.js

@@ -0,0 +1,568 @@
+import { isNonInteractive } from '../../services/interactive-state.js';
+import { executeOperateAction, } from '../../services/operate/index.js';
+import { promptCheckbox, promptConfirm, promptMultiText, promptSelect, promptText, } from '../../services/prompt-service.js';
+import { display, logger } from '../../utils/logger.js';
+const MAX_STDIN_BYTES = 64 * 1024;
+function collect(value, previous) {
+    return [...previous, value];
+}
+function projectDir(program) {
+    return String(program.opts().projectDir);
+}
+function wantsJson(command, options) {
+    return Boolean(options.json || command.optsWithGlobals().json);
+}
+async function readBoundedStdin(enabled) {
+    if (!enabled)
+        return undefined;
+    const chunks = [];
+    let bytes = 0;
+    for await (const value of process.stdin) {
+        const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+        bytes += chunk.byteLength;
+        if (bytes > MAX_STDIN_BYTES) {
+            const error = new Error(`Standard input exceeds the ${MAX_STDIN_BYTES}-byte limit.`);
+            error.name = 'E_OPERATE_INPUT_TOO_LARGE';
+            throw error;
+        }
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString('utf8').trimEnd();
+}
+function renderHuman(result) {
+    if (result.message) {
+        if (result.ok)
+            logger.success(result.message);
+        else
+            logger.warn(result.message);
+    }
+    if (result.lines) {
+        for (const line of result.lines)
+            display.line(line);
+    }
+    if (result.data !== undefined) {
+        if (result.action === 'inspect' &&
+            typeof result.data === 'object' &&
+            result.data !== null &&
+            !Array.isArray(result.data)) {
+            const data = result.data;
+            const pipeline = typeof data.pipeline === 'object' && data.pipeline !== null
+                ? data.pipeline
+                : {};
+            display.line(`Project context: ${data.project === true ? 'detected' : 'not detected'}`);
+            display.line(`Initialization: ${data.initialized === true ? 'configured' : 'not configured'}`);
+            display.line(pipeline.available === true
+                ? `Pipeline: Protocol ${String(pipeline.protocolVersion ?? 'compatible')} ready`
+                : 'Pipeline: not installed (read-only inspection remains available)');
+            if (typeof data.commitSafeRoot === 'string') {
+                display.line(`Commit-safe state: ${data.commitSafeRoot}`);
+            }
+            if (typeof data.machineLocalState === 'string') {
+                display.line(`Machine-local data: ${data.machineLocalState}`);
+            }
+        }
+        else if (result.action === 'demo' &&
+            typeof result.data === 'object' &&
+            result.data !== null &&
+            !Array.isArray(result.data)) {
+            const data = result.data;
+            if (typeof data.brief === 'string')
+                display.line(data.brief);
+            const evidenceCount = Array.isArray(data.evidence) ? data.evidence.length : 0;
+            display.line(`Evidence: ${evidenceCount} sanitized deterministic record${evidenceCount === 1 ? '' : 's'}`);
+            if (typeof data.note === 'string')
+                display.line(data.note);
+        }
+        else if (typeof result.data === 'string')
+            display.line(result.data);
+        else
+            display.line(JSON.stringify(result.data, null, 2));
+    }
+    if (result.preview !== undefined) {
+        display.heading('Preview:');
+        display.line(JSON.stringify(result.preview, null, 2));
+    }
+    if (result.next?.length) {
+        display.blank();
+        display.heading('Next:');
+        for (const command of result.next)
+            display.line(`  ${command}`);
+    }
+}
+async function executeForResult(program, command, action, args, options) {
+    const json = wantsJson(command, options);
+    let stdin;
+    try {
+        stdin = await readBoundedStdin(Boolean(options.stdin));
+    }
+    catch (error) {
+        const result = {
+            schemaVersion: '1.0.0',
+            protocolVersion: '1.2.0',
+            ok: false,
+            action,
+            code: error instanceof Error && error.name.startsWith('E_')
+                ? error.name
+                : 'E_OPERATE_INPUT_TOO_LARGE',
+            message: error instanceof Error ? error.message : String(error),
+            state: null,
+            paths: {},
+            counts: {},
+            warnings: [],
+            nextActions: ['Reduce the stdin payload to 65536 bytes or fewer and retry.'],
+            next: ['Reduce the stdin payload to 65536 bytes or fewer and retry.'],
+            exitCode: 2,
+        };
+        if (json)
+            display.line(JSON.stringify(result));
+        else
+            renderHuman(result);
+        process.exitCode = result.exitCode;
+        return result;
+    }
+    const request = {
+        action,
+        projectRoot: projectDir(program),
+        arguments: Object.fromEntries(Object.entries(args).filter((entry) => entry[1] !== undefined)),
+        options: {
+            ...options,
+            ...(Array.isArray(options.source) ? { sources: options.source } : {}),
+            ...(Array.isArray(options.component) ? { components: options.component } : {}),
+            json,
+            yes: Boolean(options.yes || program.opts().yes),
+        },
+        interactive: !json && !isNonInteractive(),
+        ...(stdin === undefined ? {} : { stdin }),
+    };
+    const result = await executeOperateAction(request);
+    if (json)
+        display.line(JSON.stringify(result));
+    else
+        renderHuman(result);
+    if (!result.ok)
+        process.exitCode = result.exitCode ?? 1;
+    return result;
+}
+async function execute(program, command, action, args, options) {
+    await executeForResult(program, command, action, args, options);
+}
+async function executeRunWithProviderConsent(program, command, options) {
+    const first = await executeForResult(program, command, 'run', {}, options);
+    if (first.ok ||
+        first.code !== 'E_OPERATE_AUTHORITY_REQUIRED' ||
+        wantsJson(command, options) ||
+        isNonInteractive()) {
+        return first;
+    }
+    const approved = await promptConfirm('Approve the disclosed provider policy for this operating run?', false);
+    if (!approved)
+        return first;
+    process.exitCode = undefined;
+    return executeForResult(program, command, 'run', {}, {
+        ...options,
+        yes: true,
+    });
+}
+async function guidedInitOptions(options) {
+    if (isNonInteractive())
+        return options;
+    const noChoices = options.profile === undefined &&
+        options.profileFile === undefined &&
+        options.decisionOwner === undefined &&
+        options.planningEngine === undefined &&
+        options.runtime === undefined &&
+        options.cadence === undefined &&
+        options.timezone === undefined &&
+        (!Array.isArray(options.component) || options.component.length === 0) &&
+        (!Array.isArray(options.source) || options.source.length === 0) &&
+        (!Array.isArray(options.evidenceFile) || options.evidenceFile.length === 0) &&
+        options.sensitivityCeiling === undefined;
+    if (!noChoices)
+        return options;
+    logger.heading('OpenPlanr Operating Board');
+    logger.dim('Configure one product workspace. Component repositories remain read-only.');
+    const profile = await promptSelect('Operating profile:', [
+        { name: 'SaaS — balanced product, growth, risk, and operations', value: 'saas' },
+        { name: 'Product — activation and customer outcomes', value: 'product' },
+        { name: 'Engineering — delivery, reliability, and risk', value: 'engineering' },
+        { name: 'Custom — validated profile file', value: 'custom' },
+    ], 'saas');
+    const profileFile = profile === 'custom' ? await promptText('Validated custom profile file:') : undefined;
+    const decisionOwner = await promptText('Who owns final operating decisions?');
+    const planningEngine = await promptSelect('Which engine creates accepted DEV specs?', [
+        { name: 'OpenPlanr — dedicated planning CLI', value: 'openplanr' },
+        { name: 'Pipeline PO — feature-local planning handoff', value: 'pipeline-po' },
+    ], 'openplanr');
+    const runtime = await promptSelect('Preferred coding runtime:', [
+        { name: 'Auto-detect a compatible runtime', value: 'auto' },
+        { name: 'Claude Code', value: 'claude' },
+        { name: 'Codex', value: 'codex' },
+        { name: 'Cursor', value: 'cursor' },
+    ], 'auto');
+    const cadence = await promptSelect('Operating cadence:', [
+        { name: 'Manual — run only when requested', value: 'manual' },
+        { name: 'Weekly display cadence', value: 'weekly' },
+        { name: 'Monthly display cadence', value: 'monthly' },
+    ], 'manual');
+    const timezone = await promptText('Display timezone (IANA):', Intl.DateTimeFormat().resolvedOptions().timeZone);
+    const sensitivityCeiling = await promptSelect('Highest evidence class allowed in this workspace:', [
+        { name: 'Internal — recommended', value: 'internal' },
+        { name: 'Public only', value: 'public' },
+        { name: 'Confidential', value: 'confidential' },
+        { name: 'Restricted', value: 'restricted' },
+    ], 'internal');
+    const sources = await promptCheckbox('Evidence sources:', [
+        { name: 'Repository files and metadata', value: 'repository', checked: true },
+        { name: 'OpenPlanr planning and delivery records', value: 'planr', checked: true },
+        { name: 'Git history and working-tree metadata', value: 'git', checked: true },
+        { name: 'GitHub (read-only; requires configured credentials)', value: 'github' },
+        { name: 'Linear (read-only; requires configured credentials)', value: 'linear' },
+        { name: 'Local JSON/CSV files (workspace-contained)', value: 'file-import' },
+    ]);
+    const evidenceFiles = sources.includes('file-import')
+        ? await promptMultiText('Workspace-contained JSON/CSV evidence paths', 'comma-separated paths')
+        : [];
+    const components = await promptMultiText('Read-only component repository paths (leave empty for this repository only)', 'comma-separated paths');
+    const charter = {
+        purpose: await promptText('What product outcome does this workspace exist to create?'),
+        stage: await promptText('Current product stage:'),
+        businessModel: await promptText('Business model:', 'Not yet specified'),
+        idealCustomer: await promptText('Ideal customer profile:', 'Not yet specified'),
+        goals: await promptMultiText('Current goals', 'comma-separated'),
+        successMetrics: await promptMultiText('Success metrics', 'comma-separated'),
+        guardrails: await promptMultiText('Human authority and product guardrails', 'comma-separated'),
+        knownUnknowns: await promptMultiText('Known unknowns', 'comma-separated'),
+    };
+    return {
+        ...options,
+        profile,
+        ...(profileFile ? { profileFile } : {}),
+        decisionOwner,
+        planningEngine,
+        runtime,
+        cadence,
+        timezone,
+        sensitivityCeiling,
+        sources,
+        evidenceFile: evidenceFiles,
+        components,
+        charter,
+    };
+}
+function json(command) {
+    return command.option('--json', 'emit one versioned machine-readable result', false);
+}
+function preview(command) {
+    return command
+        .option('--preview', 'inspect without writes or provider/model calls', false)
+        .option('--dry-run', 'allow disclosed model calls but commit no state', false);
+}
+function confirmed(command) {
+    return command.option('--yes', 'confirm this named action non-interactively', false);
+}
+function stdin(command) {
+    return command.option('--stdin', `read the sensitive answer from standard input (maximum ${MAX_STDIN_BYTES} bytes)`, false);
+}
+function machineBinding(command) {
+    return command
+        .option('--cycle-id <cycleId>', 'prepared operating cycle')
+        .option('--evidence-digest <digest>', 'immutable evidence snapshot digest')
+        .option('--lease <lease>', 'active adapter lease')
+        .option('--idempotency-key <key>', 'idempotent lifecycle call key');
+}
+function readGroup(program, parent, noun, singularArgument) {
+    json(parent.command('list').description(`List ${noun}`)).action(function (opts) {
+        return execute(program, this, `${noun}.list`, {}, opts);
+    });
+    json(parent.command(`show <${singularArgument}>`).description(`Show one ${noun.replace(/s$/, '')}`)).action(function (id, opts) {
+        return execute(program, this, `${noun}.show`, { id }, opts);
+    });
+    return parent;
+}
+export function registerOperateCommand(program) {
+    const operate = program
+        .command('operate')
+        .description('Turn verified product evidence into governed DEV, OWNER, and AGENT routes');
+    json(operate
+        .command('inspect')
+        .description('Inspect Operating Board readiness without initialization or credentials')).action(function (opts) {
+        return execute(program, this, 'inspect', {}, opts);
+    });
+    json(operate
+        .command('demo')
+        .description('Produce a deterministic credential-free operating brief without project writes')).action(function (opts) {
+        return execute(program, this, 'demo', {}, opts);
+    });
+    json(confirmed(preview(operate
+        .command('init')
+        .description('Initialize the product charter, workspace, privacy, and runtime policy')
+        .option('--profile <profile>', 'saas, product, engineering, or custom')
+        .option('--profile-file <path>', 'custom operating profile')
+        .option('--decision-owner <name>', 'human decision owner')
+        .option('--planning-engine <engine>', 'openplanr or pipeline-po')
+        .option('--runtime <runtime>', 'auto, claude, codex, or cursor')
+        .option('--cadence <cadence>', 'manual, weekly, or monthly')
+        .option('--timezone <zone>', 'IANA display timezone')
+        .option('--component <path>', 'read-only component repository (repeatable)', collect, [])
+        .option('--source <source>', 'evidence source (repeatable)', collect, [])
+        .option('--evidence-file <path>', 'workspace-contained JSON/CSV evidence file (repeatable)', collect, [])
+        .option('--sensitivity-ceiling <class>', 'public, internal, confidential, or restricted')))).action(function (opts) {
+        return (async () => {
+            const resolved = await guidedInitOptions(opts);
+            const interactive = !wantsJson(this, resolved) && !isNonInteractive() && !resolved.yes && !program.opts().yes;
+            let result;
+            if (interactive && !resolved.preview && !resolved.dryRun) {
+                const previewResult = await executeForResult(program, this, 'init', {}, {
+                    ...resolved,
+                    preview: true,
+                });
+                if (!previewResult.ok)
+                    return;
+                if (!(await promptConfirm('Apply this exact Operating Board configuration?', true))) {
+                    return;
+                }
+                result = await executeForResult(program, this, 'init', {}, {
+                    ...resolved,
+                    preview: false,
+                    yes: true,
+                });
+            }
+            else {
+                result = await executeForResult(program, this, 'init', {}, resolved);
+            }
+            const legacyMigration = result.data?.legacyMigration;
+            if (result.ok &&
+                !resolved.preview &&
+                !resolved.dryRun &&
+                !resolved.json &&
+                !isNonInteractive() &&
+                legacyMigration?.record?.state === 'previewed') {
+                const count = legacyMigration.counts?.importable ?? 0;
+                if (await promptConfirm(`Import ${count} unambiguous legacy .planr/board record(s) now? Original files will remain untouched.`, false)) {
+                    const migrationResult = await executeForResult(program, this, 'migrate.apply', {}, { yes: true });
+                    if (!migrationResult.ok)
+                        return;
+                }
+            }
+            if (result.ok &&
+                !resolved.preview &&
+                !resolved.dryRun &&
+                !resolved.json &&
+                !isNonInteractive() &&
+                (await promptConfirm('Run the first operating cycle now?', true))) {
+                await executeRunWithProviderConsent(program, this, {
+                    runtime: resolved.runtime ?? 'auto',
+                    depth: 'standard',
+                    focus: [],
+                    offline: false,
+                    reviewOnly: false,
+                    preview: false,
+                    dryRun: false,
+                    yes: false,
+                    json: false,
+                });
+            }
+        })();
+    });
+    const config = operate
+        .command('config')
+        .description('Inspect or validate operating configuration');
+    json(config.command('show')).action(function (opts) {
+        return execute(program, this, 'config.show', {}, opts);
+    });
+    json(config.command('edit')).action(function (opts) {
+        return execute(program, this, 'config.edit', {}, opts);
+    });
+    json(config.command('validate')).action(function (opts) {
+        return execute(program, this, 'config.validate', {}, opts);
+    });
+    const profiles = operate.command('profiles').description('Inspect operating profiles');
+    json(profiles.command('list')).action(function (opts) {
+        return execute(program, this, 'profiles.list', {}, opts);
+    });
+    json(profiles.command('show <profile>')).action(function (profile, opts) {
+        return execute(program, this, 'profiles.show', { profile }, opts);
+    });
+    json(profiles.command('validate <path>')).action(function (file, opts) {
+        return execute(program, this, 'profiles.validate', { file }, opts);
+    });
+    const sources = operate.command('sources').description('Inspect and test evidence sources');
+    json(sources.command('list')).action(function (opts) {
+        return execute(program, this, 'sources.list', {}, opts);
+    });
+    json(sources.command('show <source>')).action(function (source, opts) {
+        return execute(program, this, 'sources.show', { source }, opts);
+    });
+    json(sources.command('test <source>')).action(function (source, opts) {
+        return execute(program, this, 'sources.test', { source }, opts);
+    });
+    json(confirmed(preview(operate
+        .command('run')
+        .description('Collect evidence and produce a reviewable operating cycle')
+        .option('--focus <lens>', 'evaluate one lens (repeatable)', collect, [])
+        .option('--depth <depth>', 'standard or deep', 'standard')
+        .option('--runtime <runtime>', 'auto, claude, codex, or cursor', 'auto')
+        .option('--offline', 'use local evidence and deterministic providers only', false)
+        .option('--review-only', 'reconcile existing routes and outcomes only', false)))).action(function (opts) {
+        return executeRunWithProviderConsent(program, this, opts).then(() => undefined);
+    });
+    json(operate.command('review [cycleId]').description('Review a cycle at the human gate')).action(function (cycleId, opts) {
+        return execute(program, this, 'review', { cycleId }, opts);
+    });
+    json(operate.command('status').description('Show current operating status')).action(function (opts) {
+        return execute(program, this, 'status', {}, opts);
+    });
+    json(operate.command('brief [cycleId]').description('Render the concise operating brief')).action(function (cycleId, opts) {
+        return execute(program, this, 'brief', { cycleId }, opts);
+    });
+    const cycles = readGroup(program, operate.command('cycles').description('Manage operating cycle lifecycle'), 'cycles', 'cycleId');
+    for (const action of ['resume', 'cancel', 'recover', 'close']) {
+        json(confirmed(cycles.command(`${action} <cycleId>`).description(`${action} an operating cycle`))).action(function (cycleId, opts) {
+            return execute(program, this, `cycles.${action}`, { cycleId }, opts);
+        });
+    }
+    const findings = readGroup(program, operate.command('findings').description('Govern operating findings'), 'findings', 'findingId');
+    for (const action of ['accept', 'reject', 'supersede']) {
+        json(confirmed(findings
+            .command(`${action} <findingId>`)
+            .description(action === 'accept'
+            ? 'Accept governance for a finding without applying its route'
+            : `${action} a finding`)
+            .option('--impact <score>', 'audited Impact amendment')
+            .option('--confidence <score>', 'audited Confidence amendment')
+            .option('--ease <score>', 'audited Ease amendment')
+            .option('--reason <text>', 'audit reason for the decision'))).action(function (findingId, opts) {
+            return execute(program, this, `findings.${action}`, { findingId }, opts);
+        });
+    }
+    const routes = readGroup(program, operate.command('routes').description('Preview, apply, or roll back governed routes'), 'routes', 'routeId');
+    json(confirmed(preview(routes
+        .command('apply <routeId>')
+        .description('Preview or apply the exact digest-bound route')
+        .option('--preview-digest <digest>', 'digest returned by the route preview')))).action(function (routeId, opts) {
+        return (async () => {
+            const interactive = !wantsJson(this, opts) && !isNonInteractive() && !opts.yes && !program.opts().yes;
+            if (!interactive || opts.preview || opts.dryRun) {
+                await execute(program, this, 'routes.apply', { routeId }, opts);
+                return;
+            }
+            let previewDigest = opts.previewDigest;
+            if (!previewDigest) {
+                const previewResult = await executeForResult(program, this, 'routes.apply', { routeId }, { ...opts, preview: true });
+                if (!previewResult.ok)
+                    return;
+                previewDigest = previewResult.data
+                    ?.previewDigest;
+            }
+            if (!previewDigest ||
+                !(await promptConfirm(`Apply route ${routeId} using this exact preview digest?`, true))) {
+                return;
+            }
+            await execute(program, this, 'routes.apply', { routeId }, {
+                ...opts,
+                preview: false,
+                previewDigest,
+                yes: true,
+            });
+        })();
+    });
+    json(confirmed(routes.command('rollback <routeId>'))).action(function (routeId, opts) {
+        return execute(program, this, 'routes.rollback', { routeId }, opts);
+    });
+    const decisions = readGroup(program, operate.command('decisions').description('Inspect and answer owner decisions'), 'decisions', 'decisionId');
+    json(confirmed(stdin(decisions
+        .command('decide <decisionId>')
+        .description('Record an owner decision')
+        .option('--value <value>', 'decision value')
+        .option('--reason <text>', 'decision rationale')))).action(function (decisionId, opts) {
+        return execute(program, this, 'decisions.decide', { decisionId }, opts);
+    });
+    const gaps = readGroup(program, operate.command('gaps').description('Inspect and answer evidence gaps'), 'gaps', 'gapId');
+    json(confirmed(stdin(gaps
+        .command('answer <gapId>')
+        .description('Answer an evidence or charter gap')
+        .option('--value <value>', 'answer value')))).action(function (gapId, opts) {
+        return execute(program, this, 'gaps.answer', { gapId }, opts);
+    });
+    json(confirmed(gaps
+        .command('verify <gapId>')
+        .description('Verify an answered gap against collected evidence')
+        .option('--evidence-ref <id>', 'verified evidence identifier (repeatable)', collect, []))).action(function (gapId, opts) {
+        return execute(program, this, 'gaps.verify', { gapId }, opts);
+    });
+    readGroup(program, operate.command('evidence').description('Inspect sanitized evidence metadata'), 'evidence', 'evidenceId');
+    const migrate = operate.command('migrate').description('Inspect or apply legacy board migration');
+    json(migrate.command('inspect')).action(function (opts) {
+        return execute(program, this, 'migrate.inspect', {}, opts);
+    });
+    json(confirmed(migrate.command('apply'))).action(function (opts) {
+        return (async () => {
+            const interactive = !wantsJson(this, opts) && !isNonInteractive() && !opts.yes && !program.opts().yes;
+            if (!interactive) {
+                await execute(program, this, 'migrate.apply', {}, opts);
+                return;
+            }
+            const inspection = await executeForResult(program, this, 'migrate.inspect', {}, opts);
+            if (!inspection.ok)
+                return;
+            const record = inspection.data?.record;
+            if (!record)
+                return;
+            if (record.state !== 'previewed' ||
+                !(await promptConfirm(`Apply legacy migration ${record.id}? Exact source bytes will be backed up and left untouched.`, false))) {
+                return;
+            }
+            await execute(program, this, 'migrate.apply', {}, { ...opts, yes: true });
+        })();
+    });
+    const migrations = readGroup(program, operate.command('migrations').description('Inspect or roll back operating migrations'), 'migrations', 'migrationId');
+    json(confirmed(migrations.command('rollback <migrationId>'))).action(function (migrationId, opts) {
+        return (async () => {
+            const interactive = !wantsJson(this, opts) && !isNonInteractive() && !opts.yes && !program.opts().yes;
+            if (interactive &&
+                !(await promptConfirm(`Roll back imported state for ${migrationId}? Legacy source files will not be changed.`, false))) {
+                return;
+            }
+            await execute(program, this, 'migrations.rollback', { migrationId }, interactive ? { ...opts, yes: true } : opts);
+        })();
+    });
+    const cache = operate.command('cache').description('Inspect or purge machine-local evidence');
+    json(cache.command('status')).action(function (opts) {
+        return execute(program, this, 'cache.status', {}, opts);
+    });
+    json(confirmed(cache.command('purge'))).action(function (opts) {
+        return execute(program, this, 'cache.purge', {}, opts);
+    });
+    const integrity = operate
+        .command('integrity')
+        .description('Inspect or enable signed checkpoints');
+    json(integrity.command('status')).action(function (opts) {
+        return execute(program, this, 'integrity.status', {}, opts);
+    });
+    json(confirmed(integrity.command('enable'))).action(function (opts) {
+        return execute(program, this, 'integrity.enable', {}, opts);
+    });
+    const diagnostics = operate.command('diagnostics').description('Export redacted diagnostics');
+    json(diagnostics.command('export').option('--output <path>', 'output archive or JSON path')).action(function (opts) {
+        return execute(program, this, 'diagnostics.export', {}, opts);
+    });
+    const security = operate.command('security').description('Exceptional sensitive-data repair');
+    json(confirmed(security.command('repair'))).action(function (opts) {
+        return execute(program, this, 'security.repair', {}, opts);
+    });
+    const adapter = operate
+        .command('adapter')
+        .description('Machine-only, lease-bound runtime adapter lifecycle');
+    json(machineBinding(adapter.command('prepare')).option('--role <roles>', 'comma-separated advisor roles bound to this isolated dispatch')).action(function (opts) {
+        return execute(program, this, 'adapter.prepare', {}, { ...opts, json: true });
+    });
+    json(stdin(machineBinding(adapter.command('record').requiredOption('--role <role>', 'operating advisor role')))).action(function (opts) {
+        return execute(program, this, 'adapter.record', {}, { ...opts, json: true });
+    });
+    for (const action of ['finalize', 'resume', 'cancel']) {
+        json(machineBinding(adapter.command(action))).action(function (opts) {
+            return execute(program, this, `adapter.${action}`, {}, { ...opts, json: true });
+        });
+    }
+}
+//# sourceMappingURL=operate.js.map