openplanr 1.25.3 → 2.0.1

package/dist/cli/commands/operate.js

@@ -1,1021 +1,206 @@
-import { readFile } from 'node:fs/promises';
-import { isNonInteractive } from '../../services/interactive-state.js';
-import { writeOperatingDecisionBriefArtifact } from '../../services/operate/decision-brief.js';
-import { executeOperateAction, } from '../../services/operate/index.js';
-import { evaluateOperatingInitQuestions, mergeOperatingInitAnswersIntoOptions, operatingInitAnswersFromOptions, } from '../../services/operate/interaction/question-engine.js';
-import { detectOperatingQuestionContext, renderOperatingInitQuestions, } from '../../services/operate/interaction/terminal-renderer.js';
-import { writeOperatingReportHtml } from '../../services/operate/report-html.js';
-import { readOperatingDecisionBriefSource } from '../../services/operate/reports.js';
-import { promptConfirm } from '../../services/prompt-service.js';
-import { display, logger } from '../../utils/logger.js';
-// Runtime-authored Protocol v1.4 reports can carry rich Markdown and typed
-// sidecars. This bounds only the returned report document; agents inspect the
-// workspace directly, so repository size is never serialized through stdin.
-const MAX_GUIDED_ANSWER_BYTES = 64 * 1024;
-const MAX_AGENT_REPORT_BYTES = 256 * 1024;
-// FND-002: a non-TTY human running `operate init` cannot answer the guided
-// questionnaire and has no `--json` machine channel to continue on, so an
-// input-required handoff is a genuine dead-end there — never a silent success.
-// This mirrors the service's own `E_OPERATE_INPUT_REQUIRED` class in
-// `OPERATE_EXIT_CODES` (services/operate/index.ts), where input-required maps to
-// exit 4; a machine reading `--json` still receives the `ok: true` handoff at
-// exit 0 and continues via the questionnaire.
-const OPERATE_INPUT_REQUIRED_EXIT_CODE = 4;
-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, maxBytes = MAX_GUIDED_ANSWER_BYTES) {
-    if (!enabled)
-        return undefined;
-    if (process.stdin.isTTY) {
-        const error = new Error('No piped JSON input is connected. Attach the complete bounded document and EOF before launching a --stdin action.');
-        error.name = 'E_OPERATE_STDIN_REQUIRED';
-        throw error;
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { verifyDashboardAssets } from '../../../lib/dashboard-verifier.mjs';
+import { CliBoundaryError } from '../error-boundary.js';
+import { registerOperateCommandDefinition, } from './operate/registration.js';
+export { renderOperateExperienceSurfaceHuman } from './operate/render.js';
+const PIPELINE_ROOT_MODULE = 'planr-pipeline';
+const OPERATE_CLIENT_MODULE = '../../services/operate/client.js';
+const OPERATE_GATEWAY_MODULE = '../../services/operate/command-gateway.js';
+const OPERATE_PACKET_MODULE = '../../services/operate/assignment-packet-service.js';
+const OPERATE_DOMAIN_CATALOG_MODULE = '../../services/operate/domain-catalog-service.js';
+const OPERATE_REVIEW_NOTE_MODULE = '../../../lib/skill-runtime/operate-review-note.mjs';
+export function installedOpenPlanrDashboardRoot() {
+    if (typeof process.env.OPENPLANR_DASHBOARD_ROOT === 'string' &&
+        process.env.OPENPLANR_DASHBOARD_ROOT.length > 0) {
+        return resolve(process.env.OPENPLANR_DASHBOARD_ROOT);
+    }
+    const commandModuleDirectory = dirname(fileURLToPath(import.meta.url));
+    const packageRoot = resolve(commandModuleDirectory, '../../..');
+    const localDashboard = join(packageRoot, 'dist', 'dashboard');
+    if (existsSync(join(localDashboard, 'dashboard-manifest.json'))) {
+        return localDashboard;
     }
-    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 > maxBytes) {
-            const error = new Error(`Standard input exceeds the ${maxBytes}-byte limit.`);
-            error.name = 'E_OPERATE_INPUT_TOO_LARGE';
-            throw error;
+    try {
+        const require = createRequire(import.meta.url);
+        const packageName = ['open', 'planr'].join('');
+        const packageJson = require.resolve(`${packageName}/package.json`);
+        const installedDashboard = resolve(dirname(packageJson), 'dist', 'dashboard');
+        if (existsSync(join(installedDashboard, 'dashboard-manifest.json'))) {
+            return installedDashboard;
         }
-        chunks.push(chunk);
     }
-    return Buffer.concat(chunks).toString('utf8').trimEnd();
-}
-/**
- * Resolve one bounded guided-answer document for the init flow. `--answers-file
- * <path>` is a stdin-parity alias: it reads the same 64 KiB-bounded UTF-8 string
- * `--stdin` would, so the downstream strict parser and digest binding are
- * identical — it never introduces an inline-JSON code path. TTY-guard semantics
- * are preserved: only `--stdin` requires a connected non-TTY pipe. This transport
- * is now discoverable: the questionnaire advertises it in
- * `submission.transport.alternates` (kind `answers-file`) alongside the stdin
- * entry, so a contract-conformant runtime never has to assume stdin is the only
- * channel. Exported for direct parity testing.
- */
-export async function readBoundedInitAnswers(options, maxBytes = MAX_GUIDED_ANSWER_BYTES) {
-    const answersFile = typeof options.answersFile === 'string' && options.answersFile.trim()
-        ? options.answersFile
-        : undefined;
-    if (answersFile === undefined)
-        return readBoundedStdin(Boolean(options.stdin), maxBytes);
-    const buffer = await readFile(answersFile).catch(() => {
-        const error = new Error(`Unable to read the answers file at ${answersFile}. Provide a readable bounded JSON document.`);
-        error.name = 'E_OPERATE_STDIN_REQUIRED';
-        throw error;
-    });
-    if (buffer.byteLength > maxBytes) {
-        const error = new Error(`The answers file exceeds the ${maxBytes}-byte limit.`);
-        error.name = 'E_OPERATE_INPUT_TOO_LARGE';
-        throw error;
+    catch {
+        // Installed package graph may not include OpenPlanr.
     }
-    return buffer.toString('utf8').trimEnd();
+    return localDashboard;
 }
-export function renderHuman(result) {
-    // FND-002 (level 2): track whether any recognized field produced output. A
-    // last-resort branch below prints something actionable for any payload whose
-    // shape this renderer does not otherwise surface, so an `ok: true` result — a
-    // handoff, or a future shape — can never render as silent success. Wrap the
-    // real sinks so every emission is counted exactly once.
-    let emitted = false;
-    const line = (text) => {
-        display.line(text);
-        emitted = true;
-    };
-    const heading = (text) => {
-        display.heading(text);
-        emitted = true;
-    };
-    const success = (text) => {
-        logger.success(text);
-        emitted = true;
-    };
-    const warn = (text) => {
-        logger.warn(text);
-        emitted = true;
-    };
-    if (result.message) {
-        if (result.ok)
-            success(result.message);
-        else
-            warn(result.message);
-    }
-    if (result.lines) {
-        for (const value of result.lines)
-            line(value);
-    }
-    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
-                : {};
-            line(`Project context: ${data.project === true ? 'detected' : 'not detected'}`);
-            line(`Initialization: ${data.initialized === true ? 'configured' : 'not configured'}`);
-            line(pipeline.available === true
-                ? `Pipeline: Protocol ${String(pipeline.protocolVersion ?? 'compatible')} ready`
-                : 'Pipeline: not installed (read-only inspection remains available)');
-            if (typeof data.commitSafeRoot === 'string') {
-                line(`Commit-safe state: ${data.commitSafeRoot}`);
-            }
-            if (typeof data.machineLocalState === 'string') {
-                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')
-                line(data.brief);
-            const evidenceCount = Array.isArray(data.evidence) ? data.evidence.length : 0;
-            line(`Evidence: ${evidenceCount} sanitized deterministic record${evidenceCount === 1 ? '' : 's'}`);
-            if (typeof data.note === 'string')
-                line(data.note);
-        }
-        else if (typeof result.data === 'string')
-            line(result.data);
-        else
-            line(JSON.stringify(result.data, null, 2));
-    }
-    // FR10 / T-008: surface the adapter session lease (expiry + remaining) as a
-    // plain human line so an operator inspecting a lifecycle result sees, without
-    // reading raw JSON, how long the prepared session is still valid.
-    if (typeof result.action === 'string' &&
-        (result.action.startsWith('adapter.') || result.action.startsWith('harness.')) &&
-        result.data &&
-        typeof result.data === 'object' &&
-        !Array.isArray(result.data)) {
-        const lease = result.data.leaseStatus;
-        if (lease && typeof lease === 'object' && !Array.isArray(lease)) {
-            const status = lease;
-            const remaining = typeof status.remainingSeconds === 'number' ? `${status.remainingSeconds}s` : 'unknown';
-            line(status.expired === true
-                ? `Adapter lease: expired at ${String(status.expiresAt)}`
-                : `Adapter lease: expires ${String(status.expiresAt)} (${remaining} remaining)`);
-        }
-    }
-    if (result.preview !== undefined) {
-        heading('Preview:');
-        line(JSON.stringify(result.preview, null, 2));
-    }
-    if (result.next?.length) {
-        display.blank();
-        heading('Next:');
-        for (const command of result.next)
-            line(`  ${command}`);
+export function installedOpenPlanrDashboardBuildId() {
+    const root = installedOpenPlanrDashboardRoot();
+    const report = verifyDashboardAssets(root);
+    if (!report.ok || typeof report.buildId !== 'string') {
+        throw new CliBoundaryError(report.code ?? 'E_DASHBOARD_MANIFEST_INVALID', report.problem ?? 'The installed OpenPlanr dashboard manifest is invalid.', {
+            recovery: 'Reinstall OpenPlanr from a complete verified package archive.',
+            ...(report.code === 'E_DASHBOARD_ASSETS_MISSING' ? { missing: ['dashboardAssets'] } : {}),
+        });
     }
-    // FND-002 (level 2): the generic last-resort branch. If nothing above produced
-    // any output, this result carried a shape the renderer does not recognize — most
-    // often an `input_required`/authority handoff in a non-interactive shell, whose
-    // legible guidance the service deliberately leaves to the transport (see
-    // `initialize`). Printing here makes silent success on an unrecognized `ok: true`
-    // shape impossible, which is the "no silent success" rule this batch enforces.
-    if (!emitted) {
-        if (result.flow === 'handoff' && result.code === 'E_OPERATE_INPUT_REQUIRED') {
-            const subject = result.action === 'input_required' ? 'Operating Board initialization' : result.action;
-            warn(`${subject} needs more input than this non-interactive session can provide.`);
-            line('Re-run with --json to receive the guided questionnaire, or run this command in an interactive terminal.');
-        }
-        else if (result.ok) {
-            line(`${result.action}: completed with no printable summary. Re-run with --json for the full machine-readable result.`);
-        }
-        else {
-            warn(`${result.action} did not complete. Re-run with --json for the machine-readable error detail.`);
-        }
+    return report.buildId;
+}
+function operateDependencyUnavailable(error) {
+    const candidate = error;
+    const message = typeof candidate?.message === 'string' ? candidate.message : '';
+    const missingModule = candidate?.code === 'ERR_MODULE_NOT_FOUND' || candidate?.code === 'MODULE_NOT_FOUND';
+    if (!missingModule || !message.includes('planr-pipeline')) {
+        return error instanceof Error ? error : new Error('The Operate runtime could not be loaded.');
     }
+    return Object.assign(new Error('Operate requires the optional planr-pipeline package. Reinstall OpenPlanr with optional dependencies (do not use --omit=optional).'), { code: 'E_OPERATE_PIPELINE_MISSING' });
 }
-async function executeForResult(program, command, action, args, options) {
-    // Commander keeps options declared on `planr operate` (focus/depth/research/
-    // runtime) on the parent command. Merge the complete command chain here so a
-    // subcommand never silently loses an explicitly selected runtime and falls
-    // back to `auto`/`unknown`. Leaf options retain precedence.
-    const resolvedOptions = { ...command.optsWithGlobals(), ...options };
-    const json = wantsJson(command, resolvedOptions);
-    let stdin;
+async function loadOperateClientModule() {
     try {
-        const richAgentDocument = [
-            'context.review',
-            'harness.record',
-            'adapter.record',
-            'harness.validate',
-            'adapter.validate',
-        ].includes(action);
-        stdin = await readBoundedInitAnswers(resolvedOptions, richAgentDocument ? MAX_AGENT_REPORT_BYTES : MAX_GUIDED_ANSWER_BYTES);
+        return await import(OPERATE_CLIENT_MODULE);
     }
     catch (error) {
-        const code = error instanceof Error && error.name.startsWith('E_')
-            ? error.name
-            : 'E_OPERATE_INPUT_TOO_LARGE';
-        const recovery = code === 'E_OPERATE_STDIN_REQUIRED'
-            ? 'Attach one bounded JSON document to stdin before launching this exact command.'
-            : `Reduce the stdin payload to ${[
-                'context.review',
-                'harness.record',
-                'adapter.record',
-                'harness.validate',
-                'adapter.validate',
-            ].includes(action)
-                ? MAX_AGENT_REPORT_BYTES
-                : MAX_GUIDED_ANSWER_BYTES} bytes or fewer and retry.`;
-        const result = {
-            schemaVersion: '1.0.0',
-            protocolVersion: '1.2.0',
-            ok: false,
-            action,
-            code,
-            message: error instanceof Error ? error.message : String(error),
-            state: null,
-            paths: {},
-            counts: {},
-            warnings: [],
-            nextActions: [recovery],
-            next: [recovery],
-            exitCode: 2,
-        };
-        if (json)
-            display.line(JSON.stringify(result));
-        else
-            renderHuman(result);
-        process.exitCode = result.exitCode;
-        return result;
+        throw operateDependencyUnavailable(error);
     }
-    const request = {
-        action,
-        projectRoot: projectDir(program),
-        arguments: Object.fromEntries(Object.entries(args).filter((entry) => entry[1] !== undefined)),
-        options: {
-            ...resolvedOptions,
-            ...(Array.isArray(resolvedOptions.component)
-                ? { components: resolvedOptions.component }
-                : {}),
-            json,
-            yes: Boolean(resolvedOptions.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);
 }
-/**
- * FR14 (T-005): before the human review gate presents a cycle as reviewable, the
- * CLI — not the orchestrating model — verifies from on-disk artifacts which
- * completion phase the cycle actually reached. When phase F is not met it prints
- * the real current phase, the next required phase, and the exact missing
- * artifacts first, so a cycle is never presented as review-ready on the strength
- * of a successful `run`, a successful `harness prepare`, or launched advisors
- * alone. `--json` is untouched: it keeps returning the exact raw state object.
- */
-async function reviewWithCompletionGate(program, command, cycleId, options) {
-    if (!wantsJson(command, options)) {
-        try {
-            const { inspectOperatingCompletion, renderOperatingReviewGateNotice } = await import('../../services/operate/completion.js');
-            const completion = await inspectOperatingCompletion({
-                projectRoot: projectDir(program),
-                cycleId,
-                localRoot: typeof options.localRoot === 'string' ? options.localRoot : undefined,
-            });
-            if (completion) {
-                for (const line of renderOperatingReviewGateNotice(completion))
-                    display.line(line);
-            }
-        }
-        catch {
-            // If committed state cannot be read here, the review execution below
-            // surfaces the real, actionable error rather than a phase banner.
-        }
+async function loadOperateGatewayModule() {
+    try {
+        return await import(OPERATE_GATEWAY_MODULE);
+    }
+    catch (error) {
+        throw operateDependencyUnavailable(error);
     }
-    return execute(program, command, 'review', { cycleId }, options);
 }
-/**
- * FR7 / E-007 — render `operate brief` / `operate decisions show` into a
- * self-contained, offline artifact via the pipeline builder, then write it to
- * the operator-supplied `--render <path>`. This is a share-on-request boundary:
- * it runs only when `--render` is present and never publishes. Sensitivity
- * ceilings are enforced during rendering (above-ceiling evidence is dropped),
- * and an external `http(s)://` reference fails closed via the pipeline error.
- */
-async function renderDecisionBriefArtifact(program, command, target, options) {
-    const action = target.decisionId ? 'decisions.render' : 'brief.render';
-    const json = wantsJson(command, options);
-    const localRoot = typeof options.localRoot === 'string' ? { localRoot: options.localRoot } : {};
+async function loadOperatePacketModule() {
     try {
-        const source = await readOperatingDecisionBriefSource({
-            projectRoot: projectDir(program),
-            ...(target.cycleId ? { cycleId: target.cycleId } : {}),
-            ...(target.decisionId ? { decisionId: target.decisionId } : {}),
-            ...localRoot,
-        });
-        const written = await writeOperatingDecisionBriefArtifact({
-            projectRoot: projectDir(program),
-            destination: target.destination,
-            source,
-            ...localRoot,
-        });
-        const result = {
-            schemaVersion: '1.0.0',
-            protocolVersion: '1.2.0',
-            ok: true,
-            action,
-            message: `Rendered a self-contained offline decision brief to ${target.destination}.`,
-            cycleId: source.cycleId || null,
-            state: null,
-            paths: { artifact: written.path },
-            counts: { redactedEvidence: written.redactedEvidenceRefs.length },
-            warnings: written.redactedEvidenceRefs.length > 0
-                ? [
-                    `Withheld ${written.redactedEvidenceRefs.length} citation(s) above the ${written.sensitivityCeiling} sensitivity ceiling.`,
-                ]
-                : [],
-            nextActions: [`Open ${target.destination} in a browser to review it offline.`],
-            next: [],
-            data: {
-                path: written.path,
-                sha256: written.sha256,
-                offline: written.offline,
-                sandbox: written.sandbox,
-                sensitivityCeiling: written.sensitivityCeiling,
-                redactedEvidenceRefs: written.redactedEvidenceRefs,
-            },
-            exitCode: 0,
-        };
-        if (json)
-            display.line(JSON.stringify(result));
-        else
-            renderHuman(result);
-        return result;
+        return await import(OPERATE_PACKET_MODULE);
     }
     catch (error) {
-        const code = error &&
-            typeof error === 'object' &&
-            'code' in error &&
-            typeof error.code === 'string' &&
-            /^E_[A-Z0-9_]+$/.test(error.code)
-            ? error.code
-            : 'E_OPERATE_INTERNAL';
-        const result = {
-            schemaVersion: '1.0.0',
-            protocolVersion: '1.2.0',
-            ok: false,
-            action,
-            code,
-            message: error instanceof Error ? error.message : String(error),
-            state: null,
-            paths: {},
-            counts: {},
-            warnings: [],
-            nextActions: [],
-            next: [],
-            exitCode: 1,
-        };
-        if (json)
-            display.line(JSON.stringify(result));
-        else
-            renderHuman(result);
-        process.exitCode = result.exitCode;
-        return result;
+        throw operateDependencyUnavailable(error);
     }
 }
-/**
- * `operate report [cycleId] --html` — render a finished cycle report into a
- * single, self-contained, offline HTML file (inline CSS, real tables, no remote
- * hrefs) that opens cleanly in `planr artifact open`. On success it prints the
- * written path and the exact `planr artifact open` command; `--json` returns
- * `{ path, suggestedNext }`. This is a share-on-request boundary — it writes only
- * the one HTML file, to `--out` or a default alongside the cycle dir / tmp.
- */
-async function renderReportHtmlArtifact(program, command, cycleId, options) {
-    const action = 'report.html';
-    const json = wantsJson(command, options);
+async function loadOperateDomainCatalogModule() {
     try {
-        const written = await writeOperatingReportHtml({
-            projectRoot: projectDir(program),
-            ...(cycleId ? { cycleId } : {}),
-            ...(typeof options.lens === 'string' ? { lens: options.lens } : {}),
-            ...(typeof options.out === 'string' ? { out: options.out } : {}),
-            ...(typeof options.localRoot === 'string' ? { localRoot: options.localRoot } : {}),
-        });
-        const result = {
-            schemaVersion: '1.0.0',
-            protocolVersion: '1.2.0',
-            ok: true,
-            action,
-            message: `Rendered the operating report for ${written.cycleId} to ${written.path}.`,
-            cycleId: written.cycleId,
-            state: null,
-            paths: { artifact: written.path },
-            counts: {},
-            warnings: [],
-            nextActions: [written.suggestedNext],
-            next: [written.suggestedNext],
-            data: { path: written.path, suggestedNext: written.suggestedNext },
-            exitCode: 0,
-        };
-        if (json)
-            display.line(JSON.stringify(result));
-        else
-            renderHuman(result);
-        return result;
+        return await import(OPERATE_DOMAIN_CATALOG_MODULE);
     }
     catch (error) {
-        const code = error &&
-            typeof error === 'object' &&
-            'code' in error &&
-            typeof error.code === 'string' &&
-            /^E_[A-Z0-9_]+$/.test(error.code)
-            ? error.code
-            : 'E_OPERATE_INTERNAL';
-        const result = {
-            schemaVersion: '1.0.0',
-            protocolVersion: '1.2.0',
-            ok: false,
-            action,
-            code,
-            message: error instanceof Error ? error.message : String(error),
-            state: null,
-            paths: {},
-            counts: {},
-            warnings: [],
-            nextActions: [],
-            next: [],
-            exitCode: 1,
-        };
-        if (json)
-            display.line(JSON.stringify(result));
-        else
-            renderHuman(result);
-        process.exitCode = result.exitCode;
-        return result;
+        throw operateDependencyUnavailable(error);
     }
 }
-async function executeRunWithProviderConsent(program, command, options) {
-    const first = await executeForResult(program, command, 'run', {}, options);
-    // FR7/E-007: first-use provider consent now returns an `ok: true` handoff
-    // (`flow: 'handoff'`, code `E_OPERATE_AUTHORITY_REQUIRED`), not a failure.
-    // Detect that continuation to disclose the policy and retry with authority.
-    const consentHandoff = first.flow === 'handoff' && first.code === 'E_OPERATE_AUTHORITY_REQUIRED';
-    if (!consentHandoff || wantsJson(command, options) || isNonInteractive()) {
-        return first;
+async function loadOperateReviewNoteModule() {
+    try {
+        const loaded = (await import(OPERATE_REVIEW_NOTE_MODULE));
+        if (typeof loaded.inspectOperateReviewNote !== 'function')
+            throw new Error('Missing inspector.');
+        return loaded;
     }
-    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(program, options) {
-    if (options.resume || options.cancelSession || options.stdin || options.answersFile)
-        return options;
-    if (isNonInteractive() || options.json === true || program.opts().json === true)
-        return options;
-    const answers = operatingInitAnswersFromOptions(options);
-    const context = await detectOperatingQuestionContext(projectDir(program));
-    const state = await evaluateOperatingInitQuestions({
-        answers,
-        context,
-        requireCharter: true,
-    });
-    if (state.status === 'preview-ready') {
-        return mergeOperatingInitAnswersIntoOptions(options, state.answers);
+    catch (error) {
+        throw new CliBoundaryError('E_OPERATE_NOTE_VALIDATOR_UNAVAILABLE', 'The installed OpenPlanr package does not contain the Operate note validator.', {
+            cause: error,
+            recovery: 'Reinstall OpenPlanr from a complete verified package archive.',
+        });
     }
-    const resolved = await renderOperatingInitQuestions({ initialAnswers: answers, context });
-    return mergeOperatingInitAnswersIntoOptions(options, resolved);
-}
-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 one runtime-authored document from standard input (maximum ${MAX_AGENT_REPORT_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');
+async function installedDashboardStarter() {
+    const installed = (await import(PIPELINE_ROOT_MODULE));
+    if (typeof installed.startDashboard !== 'function') {
+        throw Object.assign(new Error('The installed planr-pipeline package does not expose the Operate dashboard.'), { code: 'E_OPERATE_DASHBOARD_UNAVAILABLE' });
+    }
+    return installed.startDashboard;
+}
+function operatingExperienceRead(view) {
+    const status = typeof view.status === 'string' ? view.status : 'invalid';
+    return {
+        available: true,
+        readOnly: status !== 'ready',
+        status,
+        view: structuredClone(view),
+        reasonCodes: status === 'ready' ? [] : ['OPERATE_READ_ONLY'],
+        recovery: status === 'ready'
+            ? null
+            : 'Resume the durable cycle through OpenPlanr before submitting a command.',
+    };
 }
-function readGroup(program, parent, noun, singularArgument, configure = {}) {
-    json(parent.command('list').description(`List ${noun}`)).action(function (opts) {
-        return execute(program, this, `${noun}.list`, {}, opts);
+/**
+ * Production Operate command-center seam. The browser receives only public
+ * projections and opaque action references; all state and command authority
+ * remain in the installed OpenPlanr client/runtime in this loopback process.
+ */
+export async function startOperateDashboard(input) {
+    const [{ createOperateClient }, { createOperateClientCommandRuntime, createOperateCommandGateway, createOperatingReviewReadGatewayV1, },] = await Promise.all([loadOperateClientModule(), loadOperateGatewayModule()]);
+    const { createOperatePlanningGateway } = await import('../../services/operate/planning-handoff-gateway.js');
+    const client = input.client ?? createOperateClient(input.projectDir);
+    const actor = { actorId: input.actorId, kind: 'human', runtime: 'openplanr' };
+    const envelope = await client.dispatch({
+        operation: 'operate.experience.get',
+        request: {
+            cycleId: input.cycleId,
+            actor,
+            actionBinding: { cycleId: input.cycleId, actorId: input.actorId },
+        },
     });
-    const showCommand = parent
-        .command(`show <${singularArgument}>`)
-        .description(`Show one ${noun.replace(/s$/, '')}`);
-    json(configure.augmentShow ? configure.augmentShow(showCommand) : showCommand).action(function (id, opts) {
-        if (configure.showAction) {
-            return (async () => {
-                const handled = await configure.showAction?.({ command: this, id, opts });
-                if (!handled)
-                    await execute(program, this, `${noun}.show`, { id }, opts);
-            })();
-        }
-        return execute(program, this, `${noun}.show`, { id }, opts);
+    if (!envelope.ok) {
+        throw Object.assign(new Error(envelope.error.message), { code: envelope.error.code });
+    }
+    let projection = operatingExperienceRead(envelope.data);
+    const getOperatingReviewRead = createOperatingReviewReadGatewayV1({ client });
+    const gateway = createOperateCommandGateway({
+        client,
+        runtime: createOperateClientCommandRuntime(client, getOperatingReviewRead),
+        getOperatingReviewRead,
+        onView: (view) => {
+            projection = operatingExperienceRead(view);
+        },
+    });
+    const planningGateway = createOperatePlanningGateway({
+        client,
+        projectDir: input.projectDir,
+    });
+    const startDashboard = input.startDashboard ?? (await installedDashboardStarter());
+    const staticRoot = installedOpenPlanrDashboardRoot();
+    const dashboard = startDashboard({
+        planrDir: join(input.projectDir, '.planr'),
+        staticRoot,
+        dashboardBuildId: installedOpenPlanrDashboardBuildId(),
+        watch: input.watch ?? true,
+        planningActorId: input.actorId,
+        getOperatingExperience: () => structuredClone(projection),
+        getOperatingCycleRead: async ({ cycleId }) => structuredClone((await client.dispatch({
+            operation: 'operate.cycle.get',
+            request: { cycleId },
+        }))),
+        getOperatingReviewRead: async (request) => structuredClone((await getOperatingReviewRead(request))),
+        getOperatingCommandGateway: () => gateway,
+        getOperatingPlanningGateway: () => planningGateway,
+    });
+    const port = await dashboard.listen(input.port ?? 7473, { env: input.env });
+    return Object.freeze({
+        url: `http://127.0.0.1:${port}/#/operate/today`,
+        port,
+        close: async () => await dashboard.close(),
     });
-    return parent;
 }
 export function registerOperateCommand(program) {
-    const operate = json(program
-        .command('operate')
-        .description('Turn verified product evidence into governed DEV, OWNER, and AGENT routes through the agent-native Operating Board')
-        .option('--focus <lens>', 'evaluate one lens (repeatable)', collect, [])
-        .option('--depth <depth>', 'standard or deep', 'standard')
-        .option('--research <mode>', 'local or connected', 'local')
-        .option('--runtime <runtime>', 'auto, claude, codex, or cursor', 'auto'));
-    operate.action(function (opts) {
-        return (async () => {
-            const inspected = await executeOperateAction({
-                action: 'inspect',
-                projectRoot: projectDir(program),
-                options: {},
-                interactive: false,
-            });
-            const initialized = Boolean(inspected.data &&
-                typeof inspected.data === 'object' &&
-                inspected.data.initialized);
-            if (initialized) {
-                await executeRunWithProviderConsent(program, this, opts);
-                return;
-            }
-            await execute(program, this, 'context.refresh', {}, {
-                ...opts,
-                preview: false,
-                yes: opts.research === 'connected' ? Boolean(opts.yes) : true,
-            });
-        })();
-    });
-    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(operate
-        .command('report [cycleId]')
-        .description('Print the cycle brief and CEO/CTO/CPO/CMO/COO/Chair reports')
-        .option('--lens <lens>', 'CEO, CTO, CPO, CMO, COO, Chair, or all', 'all')
-        .option('--format <format>', 'markdown or json')
-        .option('--html', 'render the cycle report to a self-contained, offline HTML file', false)
-        .option('--out <path>', 'HTML output path (default: alongside the cycle dir, else tmp)')).action(function (cycleId, opts) {
-        if (opts.html) {
-            return renderReportHtmlArtifact(program, this, cycleId, opts).then(() => undefined);
-        }
-        return execute(program, this, 'report', { cycleId }, 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('--sensitivity-ceiling <class>', 'public, internal, confidential, or restricted')
-        .option('--purpose <text>', 'product outcome for the operating charter')
-        .option('--product-stage <stage>', 'current product stage')
-        .option('--business-model <model>', 'explicit business model')
-        .option('--ideal-customer <profile>', 'explicit ideal customer profile')
-        .option('--goal <text>', 'current product goal (repeatable)', collect, [])
-        .option('--success-metric <text>', 'success metric (repeatable)', collect, [])
-        .option('--guardrail <text>', 'human authority or product guardrail (repeatable)', collect, [])
-        .option('--known-unknown <text>', 'known unknown (repeatable)', collect, [])
-        .option('--resume <session-id>', 'resume a machine-local guided initialization session')
-        .option('--stdin', `read one guided answer envelope (maximum ${MAX_GUIDED_ANSWER_BYTES} bytes)`, false)
-        .option('--answers-file <path>', `read one guided answer envelope from a file (stdin parity, maximum ${MAX_GUIDED_ANSWER_BYTES} bytes)`)
-        .option('--cancel-session', 'cancel and remove the resumed guided session', false)
-        .option('--preview-created-at <timestamp>', 'bind a direct flag-based apply to the timestamp returned by its preview')
-        .option('--answers-token <token>', 'replay the exact non-secret initialization answers returned by a preview')
-        .option('--confirm <digest>', 'confirm the exact session preview digest')))).action(function (opts) {
-        return (async () => {
-            const resolved = await guidedInitOptions(program, 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,
-                });
-                // A guided-stage advance is now an `ok: true` handoff (FR7/E-007), not a
-                // failure: it still carries no apply action, so stop before confirming.
-                if (!previewResult.ok || previewResult.flow === 'handoff')
-                    return;
-                if (!(await promptConfirm('Apply this exact Operating Board configuration?', true))) {
-                    return;
-                }
-                const confirmationDigest = (previewResult.actions?.find((action) => action.id === 'operate.init.apply') ?? null)?.confirmationDigest;
-                const previewCreatedAt = previewResult.preview?.previewCreatedAt;
-                if (!confirmationDigest) {
-                    throw new Error('Initialization preview did not return a confirmation digest.');
-                }
-                result = await executeForResult(program, this, 'init', {}, {
-                    ...resolved,
-                    preview: false,
-                    yes: true,
-                    confirm: confirmationDigest,
-                    previewCreatedAt,
-                });
-            }
-            else {
-                result = await executeForResult(program, this, 'init', {}, resolved);
-            }
-            // FND-002: a non-TTY human hit the input-required handoff. `renderHuman`
-            // (invoked inside executeForResult) has already printed the actionable
-            // `--json` guidance; set the exit code so automation sees the dead-end rather
-            // than a spurious success, and stop before the interactive follow-up prompts.
-            // A `--json` caller keeps the `ok: true` handoff at exit 0 and continues.
-            if (result.flow === 'handoff' &&
-                result.code === 'E_OPERATE_INPUT_REQUIRED' &&
-                !wantsJson(this, resolved) &&
-                isNonInteractive()) {
-                process.exitCode = OPERATE_INPUT_REQUIRED_EXIT_CODE;
-                return;
-            }
-            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);
-    });
-    // FR10 / T-009: a distinct legacy operating-profile field migration under the
-    // `profiles` namespace. This is NOT the unrelated `operate migrate` command
-    // (legacy PLAN-era board-data import); it reconciles a stale
-    // `.planr/operate-profile.json` whose `enabledProviders`/`budgets` the current
-    // CLI would otherwise reject.
-    const profilesMigrate = profiles
-        .command('migrate')
-        .description('Inspect or apply legacy operating-profile field migration');
-    json(profilesMigrate.command('inspect')).action(function (opts) {
-        return execute(program, this, 'profiles.migrate.inspect', {}, opts);
-    });
-    // T-018: route apply through the action map so it receives the storage-layout
-    // auto-migration guard. The interactive preview/confirm flow mirrors the sibling
-    // `operate migrate apply` command; the migration's idempotent backup/rollback
-    // semantics are unchanged (still enforced in profile-migration.ts).
-    json(confirmed(profilesMigrate.command('apply'))).action(function (opts) {
-        return (async () => {
-            const interactive = !wantsJson(this, opts) && !isNonInteractive() && !opts.yes && !program.opts().yes;
-            if (!interactive) {
-                await execute(program, this, 'profiles.migrate.apply', {}, opts);
-                return;
-            }
-            const inspection = await executeForResult(program, this, 'profiles.migrate.inspect', {}, opts);
-            if (!inspection.ok)
-                return;
-            const data = inspection.data;
-            if (!data?.present || !data.changed)
-                return;
-            if (!(await promptConfirm(`Migrate ${data.sourcePath ?? '.planr/operate-profile.json'}? The exact pre-migration bytes are backed up first.`, false))) {
-                return;
-            }
-            await execute(program, this, 'profiles.migrate.apply', {}, { ...opts, yes: true });
-        })();
-    });
-    const context = operate
-        .command('context')
-        .description('Research, validate, and review runtime-authored product context');
-    json(context.command('show')).action(function (opts) {
-        return execute(program, this, 'context.show', {}, opts);
-    });
-    json(preview(confirmed(context
-        .command('refresh')
-        .option('--research <mode>', 'local or connected', 'local')
-        .option('--runtime <runtime>', 'auto, claude, codex, or cursor', 'auto')
-        .option('--confirm <digest>', 'confirm the exact connected-research preview')))).action(function (opts) {
-        return execute(program, this, 'context.refresh', {}, opts);
-    });
-    json(stdin(context
-        .command('review')
-        .description('Validate runtime-authored context claims against the prepared workspace'))).action(function (opts) {
-        return execute(program, this, 'context.review', {}, opts);
-    });
-    const drafts = readGroup(program, operate.command('drafts').description('Inspect and govern provisional Operate drafts'), 'drafts', 'draftId');
-    json(confirmed(drafts.command('approve <draftId>').description('Approve one proposed draft'))).action(function (draftId, opts) {
-        return execute(program, this, 'drafts.approve', { draftId }, opts);
-    });
-    json(confirmed(drafts.command('discard <draftId>').description('Discard one proposed draft'))).action(function (draftId, opts) {
-        return execute(program, this, 'drafts.discard', { draftId }, opts);
-    });
-    json(confirmed(preview(operate
-        .command('run')
-        .description('Collect evidence and produce a reviewable operating cycle')
-        .option('--cycle-id <cycleId>', 'resume exactly this operating cycle')
-        .option('--offline', 'use local evidence and deterministic providers only', false)
-        .option('--review-only', 'reconcile existing routes and outcomes only', false)))).action(function (_opts) {
-        // Commander passes parent option values when a subcommand repeats option
-        // names declared on `operate`. Read the concrete `run` command directly so
-        // explicit focus/depth/runtime flags are never replaced by parent defaults.
-        return executeRunWithProviderConsent(program, this, {
-            ...operate.opts(),
-            ...this.opts(),
-        }).then(() => undefined);
-    });
-    json(operate.command('review [cycleId]').description('Review a cycle at the human gate')).action(function (cycleId, opts) {
-        return reviewWithCompletionGate(program, this, 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')
-        .option('--render <path>', 'render a self-contained, offline decision brief to <path> (project-relative)')).action(function (cycleId, opts) {
-        if (typeof opts.render === 'string' && opts.render.trim()) {
-            return renderDecisionBriefArtifact(program, this, { cycleId, destination: opts.render }, opts).then(() => undefined);
-        }
-        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);
-        });
-    }
-    // SPEC-005 T-020: the operator escape for a cycle stranded at the advisors phase
-    // because a runtime dispatched a lens and reported nothing. Valid once the
-    // adapter lease has lapsed; terminally governs the still-unrecorded lenses
-    // `not_evaluated` so consolidation can reach a reviewable cycle without discarding
-    // the recorded siblings. Omit `--role` to reap every stalled lens at once.
-    json(confirmed(cycles
-        .command('abandon-role <cycleId>')
-        .description('Terminally mark stalled lenses not_evaluated after the adapter lease lapsed')
-        .option('--role <role>', 'a single stalled lens to abandon (default: every stalled lens)')
-        .option('--reason <text>', 'why the lens is recorded not_evaluated'))).action(function (cycleId, opts) {
-        return execute(program, this, 'cycles.abandon-role', { 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', {
-        augmentShow: (command) => command.option('--render <path>', 'render a self-contained, offline decision brief to <path> (project-relative)'),
-        showAction: async ({ command, id, opts }) => {
-            if (typeof opts.render !== 'string' || !opts.render.trim())
-                return false;
-            await renderDecisionBriefArtifact(program, command, { decisionId: id, destination: opts.render }, opts);
-            return true;
+    registerOperateCommandDefinition(program, {
+        createClient: async (projectDir) => {
+            const { createOperateClient } = await loadOperateClientModule();
+            return createOperateClient(projectDir);
         },
+        createAssignmentPacketService: async (projectDir) => {
+            const { createOperateAssignmentPacketService } = await loadOperatePacketModule();
+            return createOperateAssignmentPacketService(projectDir);
+        },
+        listDomains: async () => {
+            const { listInstalledPublicOperatingDomains } = await loadOperateDomainCatalogModule();
+            return await listInstalledPublicOperatingDomains();
+        },
+        inspectOperateReviewNote: async (markdown, options) => {
+            const { inspectOperateReviewNote } = await loadOperateReviewNoteModule();
+            return inspectOperateReviewNote(markdown, options);
+        },
+        startDashboard: startOperateDashboard,
     });
-    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 lifecycle = (namespace, description) => {
-        const group = operate.command(namespace).description(description);
-        json(machineBinding(group
-            .command('prepare')
-            .description('Prepare immutable Protocol v1.4 runtime-native role mandates')).option('--role <roles>', 'comma-separated operating roles bound to this dispatch')).action(function (opts) {
-            return execute(program, this, `${namespace}.prepare`, {}, { ...opts, json: true });
-        });
-        json(stdin(machineBinding(group
-            .command('record')
-            .description('Record one cited runtime-authored result for its prepared mandate')
-            .requiredOption('--role <role>', 'operating advisor role')))).action(function (opts) {
-            return execute(program, this, `${namespace}.record`, {}, { ...opts, json: true });
-        });
-        // `validate` (US-T1) is the read-only twin of `record`: it checks the SAME
-        // stdin payload against the SAME disclosed advisor contract and returns the
-        // SAME complete-issues shape, but consumes no lease, needs no idempotency key,
-        // and mutates nothing — so a runtime can iterate on its draft response at zero
-        // state cost. It needs only `--cycle-id` to locate the prepared session and
-        // `--role`; the full lease/idempotency machine binding is deliberately absent.
-        json(stdin(group
-            .command('validate')
-            .description('Dry-run one advisor response against its contract; no lease, no writes')
-            .requiredOption('--role <role>', 'operating advisor role')
-            .option('--cycle-id <cycleId>', 'prepared operating cycle'))).action(function (opts) {
-            return execute(program, this, `${namespace}.validate`, {}, { ...opts, json: true });
-        });
-        // `abandon` (FR13/SPEC-005 T-020) governs one dispatched-but-unrecorded lens
-        // terminal `not_evaluated` with a reason, so a genuinely stalled lens no longer
-        // strands the cycle. Same lease-bound machine binding as record; the runtime
-        // invokes it when a lens exceeds its budget and never returns.
-        json(machineBinding(group
-            .command('abandon')
-            .description('Govern one stalled runtime-dispatched lens terminal not_evaluated')
-            .requiredOption('--role <role>', 'the stalled operating advisor role')
-            .requiredOption('--reason <text>', 'why the lens is recorded not_evaluated'))).action(function (opts) {
-            return execute(program, this, `${namespace}.abandon`, {}, { ...opts, json: true });
-        });
-        // `heartbeat` (FR2/SPEC-005) renews the lease with no role result and no
-        // stdin — same lease-bound machine binding as resume/cancel/finalize.
-        for (const action of ['finalize', 'resume', 'cancel', 'heartbeat']) {
-            json(machineBinding(group.command(action))).action(function (opts) {
-                return execute(program, this, `${namespace}.${action}`, {}, { ...opts, json: true });
-            });
-        }
-    };
-    lifecycle('harness', 'Machine-only, runtime-bound agent harness lifecycle');
-    lifecycle('adapter', 'Deprecated Protocol v1.3 lifecycle alias; use harness');
 }
 //# sourceMappingURL=operate.js.map