ctxr-cli 0.34.0 → 0.36.0

package/dist/run.js

@@ -7,6 +7,7 @@ import * as archiveCommand from './commands/archive.js';
 import * as doctorCommand from './commands/doctor.js';
 import * as ingestCommand from './commands/ingest.js';
 import * as landCommand from './commands/land.js';
+import * as syncCommand from './commands/sync.js';
 import * as lintCommand from './commands/lint.js';
 import * as contextGatherCommand from './commands/context-gather.js';
 import * as graphBuildCommand from './commands/graph-build.js';
@@ -19,6 +20,7 @@ import * as publishCheckCommand from './commands/publish-check.js';
 import * as publishUrlsCommand from './commands/publish-urls.js';
 import * as publishNewCommand from './commands/publish-new.js';
 import * as publishStampCommand from './commands/publish-stamp.js';
+import * as pluginBuildCommand from './commands/plugin-build.js';
 import * as reviewListCommand from './commands/review-list.js';
 import * as secondOpinionCommand from './commands/second-opinion.js';
 import * as sharedStoresStatusCommand from './commands/shared-stores-status.js';
@@ -168,12 +170,12 @@ function commandPathFor(program, argv) {
 function collect(value, previous) {
     return [...previous, value];
 }
-export async function run(argv, env) {
-    if (isGlobalVersionRequest(argv)) {
-        const jsonMode = argv.includes('--json');
-        const runEnv = { ...env, noInput: env.noInput || argv.includes('--no-input') || jsonMode };
-        return runCommand('version', runEnv, jsonMode, () => versionCommand.execute(runEnv));
-    }
+/**
+ * The command tree, built once per invocation. Exported so the MCP surface's
+ * tool/command alignment check (serve-the-session-lifecycle-to-chat-apps D9)
+ * reads the CLI's real command registry rather than a copy of it.
+ */
+export function buildProgram(env) {
     const program = new Command();
     program
         .name('ctxr')
@@ -185,7 +187,7 @@ export async function run(argv, env) {
         .option('--root <path>', 'store root (overrides CONTEXTURE_STORE_ROOT)')
         .option('--json', 'emit machine-readable output')
         .option('--no-input', 'never prompt; fail loud instead of blocking');
-    let result = ExitCode.Ok;
+    const state = { result: ExitCode.Ok };
     program
         .command('init')
         .description('create a new context store, or reconcile an existing one')
@@ -194,7 +196,7 @@ export async function run(argv, env) {
         .option('--harness <ids>', `comma-separated harness-generation adapters to target (${initCommand.SELECTABLE_HARNESS_IDS.join(', ')}), or "none"`)
         .action(async (cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('init', runEnv, jsonMode, () => initCommand.execute(runEnv, { root, profile: cmdOpts.profile, taxonomy: cmdOpts.taxonomy, harness: cmdOpts.harness }));
+        state.result = await runCommand('init', runEnv, jsonMode, () => initCommand.execute(runEnv, { root, profile: cmdOpts.profile, taxonomy: cmdOpts.taxonomy, harness: cmdOpts.harness }));
     });
     program
         .command('doctor')
@@ -202,7 +204,7 @@ export async function run(argv, env) {
         .option('--staged', 'check staged changes only (used by the pre-commit hook)')
         .action(async (cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('doctor', runEnv, jsonMode, async () => {
+        state.result = await runCommand('doctor', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return doctorCommand.execute(runEnv, store, { staged: cmdOpts.staged });
         });
@@ -215,7 +217,7 @@ export async function run(argv, env) {
         .requiredOption('--text <text>', 'the line to append')
         .action(async (notePath, cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('entry.append', runEnv, jsonMode, async () => {
+        state.result = await runCommand('entry.append', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return entryAppendCommand.execute(runEnv, store, { path: notePath, region: cmdOpts.region, text: cmdOpts.text });
         });
@@ -226,7 +228,7 @@ export async function run(argv, env) {
         .description('regenerate every catalog section, preserving authored glosses')
         .action(async (_cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('catalog.build', runEnv, jsonMode, async () => {
+        state.result = await runCommand('catalog.build', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return catalogBuildCommand.execute(store);
         });
@@ -237,7 +239,7 @@ export async function run(argv, env) {
         .option('--stale', 'also report entries whose note has changed since the gloss was confirmed')
         .action(async (cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('catalog.check', runEnv, jsonMode, async () => {
+        state.result = await runCommand('catalog.check', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return catalogCheckCommand.execute(store, { stale: cmdOpts.stale });
         });
@@ -248,7 +250,7 @@ export async function run(argv, env) {
         .requiredOption('--section <id>', 'the section id to print')
         .action(async (cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('catalog.show', runEnv, jsonMode, async () => {
+        state.result = await runCommand('catalog.show', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return catalogShowCommand.execute(store, { section: cmdOpts.section });
         });
@@ -267,7 +269,7 @@ export async function run(argv, env) {
         .option('--max-notes <n>', 'cap the returned set; truncation is reported, never silent', (v) => Number.parseInt(v, 10))
         .action(async (cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('context.gather', runEnv, jsonMode, async () => {
+        state.result = await runCommand('context.gather', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return contextGatherCommand.execute(store, {
                 seed: cmdOpts.seed,
@@ -288,7 +290,7 @@ export async function run(argv, env) {
         .option('--emit-records', 'also emit a stable per-note record list {id, path, gloss, hash}')
         .action(async (cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('graph.build', runEnv, jsonMode, async () => {
+        state.result = await runCommand('graph.build', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return graphBuildCommand.execute(store, { emitRecords: cmdOpts.emitRecords });
         });
@@ -304,7 +306,7 @@ export async function run(argv, env) {
         const flags = { since: cmdOpts.since, until: cmdOpts.until, format: cmdOpts.format };
         // review-the-knowledge-diff (D9): `--format markdown` is the whole stdout — the
         // block rides as the human summary, which the reporter writes verbatim and alone.
-        result = await runCommand('graph.diff', runEnv, jsonMode, async () => {
+        state.result = await runCommand('graph.diff', runEnv, jsonMode, async () => {
             graphDiffCommand.checkFlags(flags, jsonMode);
             const store = await openStore(runEnv, { root });
             return graphDiffCommand.execute(store, flags, jsonMode);
@@ -319,7 +321,7 @@ export async function run(argv, env) {
         .option('--type <name>', 'follow only edges of this type (a configured relation name, or link)')
         .action(async (node, cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('graph.query.neighbors', runEnv, jsonMode, async () => {
+        state.result = await runCommand('graph.query.neighbors', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return graphQueryCommand.executeNeighbors(store, {
                 node,
@@ -334,7 +336,7 @@ export async function run(argv, env) {
         .description('shortest path between two nodes, if one exists')
         .action(async (from, to, _cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('graph.query.path', runEnv, jsonMode, async () => {
+        state.result = await runCommand('graph.query.path', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return graphQueryCommand.executePath(store, { from, to });
         });
@@ -344,7 +346,7 @@ export async function run(argv, env) {
         .description('the induced subgraph over the given node ids')
         .action(async (ids, _cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('graph.query.subgraph', runEnv, jsonMode, async () => {
+        state.result = await runCommand('graph.query.subgraph', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return graphQueryCommand.executeSubgraph(store, { ids });
         });
@@ -355,7 +357,7 @@ export async function run(argv, env) {
         .option('--top <n>', 'how many to list', (v) => Number.parseInt(v, 10), 10)
         .action(async (cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('graph.query.hubs', runEnv, jsonMode, async () => {
+        state.result = await runCommand('graph.query.hubs', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return graphQueryCommand.executeHubs(store, { top: cmdOpts.top });
         });
@@ -365,7 +367,7 @@ export async function run(argv, env) {
         .description('every positional cluster with its note count')
         .action(async (_cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('graph.query.clusters', runEnv, jsonMode, async () => {
+        state.result = await runCommand('graph.query.clusters', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return graphQueryCommand.executeClusters(store, {});
         });
@@ -376,7 +378,7 @@ export async function run(argv, env) {
         .option('--top <n>', 'how many to list (default: the configured bridge limit)', (v) => Number.parseInt(v, 10))
         .action(async (cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('graph.query.bridges', runEnv, jsonMode, async () => {
+        state.result = await runCommand('graph.query.bridges', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return graphQueryCommand.executeBridges(store, { top: cmdOpts.top });
         });
@@ -386,7 +388,7 @@ export async function run(argv, env) {
         .description('nodes with no links in or out')
         .action(async (_cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('graph.query.orphans', runEnv, jsonMode, async () => {
+        state.result = await runCommand('graph.query.orphans', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return graphQueryCommand.executeOrphans(store, {});
         });
@@ -399,7 +401,7 @@ export async function run(argv, env) {
         .requiredOption('--source-id <id>', 'a stable identifier for this specific source')
         .action(async (capturePath, cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('ingest', runEnv, jsonMode, async () => {
+        state.result = await runCommand('ingest', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return ingestCommand.execute(runEnv, store, {
                 path: capturePath,
@@ -415,7 +417,7 @@ export async function run(argv, env) {
         .description('the canonicalized-content hash of a file')
         .action(async (notePath, _cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('source.hash', runEnv, jsonMode, async () => {
+        state.result = await runCommand('source.hash', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return sourceHashCommand.execute(runEnv, store, { path: notePath });
         });
@@ -426,7 +428,7 @@ export async function run(argv, env) {
         .requiredOption('--source-id <id>', "the candidate material's source identifier")
         .action(async (notePath, cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('source.check', runEnv, jsonMode, async () => {
+        state.result = await runCommand('source.check', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return sourceCheckCommand.execute(runEnv, store, { path: notePath, sourceId: cmdOpts.sourceId });
         });
@@ -438,7 +440,7 @@ export async function run(argv, env) {
         .option('--hash <hash>', 'the content hash to record (default: computed from the note\'s current body)')
         .action(async (notePath, cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('source.stamp', runEnv, jsonMode, async () => {
+        state.result = await runCommand('source.stamp', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return sourceStampCommand.execute(runEnv, store, { path: notePath, id: cmdOpts.id, hash: cmdOpts.hash });
         });
@@ -449,7 +451,7 @@ export async function run(argv, env) {
         .requiredOption('--id <id>', 'the alternative source identifier')
         .action(async (notePath, cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('source.add-alt', runEnv, jsonMode, async () => {
+        state.result = await runCommand('source.add-alt', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return sourceAddAltCommand.execute(runEnv, store, { path: notePath, id: cmdOpts.id });
         });
@@ -459,7 +461,7 @@ export async function run(argv, env) {
         .description('health observations that never fail the run: orphans, broken links, uningested inbox material, catalog gaps')
         .action(async (_cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('lint', runEnv, jsonMode, async () => {
+        state.result = await runCommand('lint', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return lintCommand.execute(runEnv, store);
         });
@@ -469,7 +471,7 @@ export async function run(argv, env) {
         .description('retire a note, or a folder of notes whole, to its same path beneath the archive destination via a single tracked rename, reporting every note that links to it')
         .action(async (notePath, _cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('archive', runEnv, jsonMode, async () => {
+        state.result = await runCommand('archive', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return archiveCommand.execute(runEnv, store, { path: notePath });
         });
@@ -480,7 +482,7 @@ export async function run(argv, env) {
         .description('enumerate candidate source notes (notes linking to <entity>) for a rollup')
         .action(async (entity, _cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('rollup.gather', runEnv, jsonMode, async () => {
+        state.result = await runCommand('rollup.gather', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return rollupGatherCommand.execute(runEnv, store, { entity });
         });
@@ -491,7 +493,7 @@ export async function run(argv, env) {
         .requiredOption('--content-file <path>', 'a file containing the rollup text to write')
         .action(async (entity, cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('rollup.write', runEnv, jsonMode, async () => {
+        state.result = await runCommand('rollup.write', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return rollupWriteCommand.execute(runEnv, store, { entity, contentFile: cmdOpts.contentFile });
         });
@@ -502,7 +504,7 @@ export async function run(argv, env) {
         .option('--for <entity>', 'check only this entity')
         .action(async (cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('rollup.stale', runEnv, jsonMode, async () => {
+        state.result = await runCommand('rollup.stale', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return rollupStaleCommand.execute(runEnv, store, { for: cmdOpts.for });
         });
@@ -516,7 +518,7 @@ export async function run(argv, env) {
         .option('--entity <name>', 'every note linking to this entity (same enumeration as rollup gather)')
         .action(async (cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('publish.gather', runEnv, jsonMode, async () => {
+        state.result = await runCommand('publish.gather', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return publishGatherCommand.execute(runEnv, store, {
                 under: cmdOpts.under,
@@ -531,7 +533,7 @@ export async function run(argv, env) {
         .option('--disposable', 'scaffold a disposable page at disposable/<YYYY-MM-DD>-<slug>, dated today by the command (two-kinds-of-published-page)')
         .action(async (slug, cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('publish.new', runEnv, jsonMode, async () => {
+        state.result = await runCommand('publish.new', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return publishNewCommand.execute(store, { slug, disposable: cmdOpts.disposable === true });
         });
@@ -541,7 +543,7 @@ export async function run(argv, env) {
         .description("record the hash of the note a permanent page represents (its README's lead link) as a marker on that line — once; never overwrites a marker, and refuses a disposable page")
         .action(async (pagePath, _cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('publish.stamp', runEnv, jsonMode, async () => {
+        state.result = await runCommand('publish.stamp', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return publishStampCommand.execute(store, { path: pagePath });
         });
@@ -551,7 +553,7 @@ export async function run(argv, env) {
         .description("the mechanized structural checks a published page must pass (no external references, viewport meta, print rule, provenance, sibling README, script syntax; a disposable page's shape; a permanent page's represented note and its hash), and the page's address and lifespan")
         .action(async (pagePath, _cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('publish.check', runEnv, jsonMode, async () => {
+        state.result = await runCommand('publish.check', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return publishCheckCommand.execute(store, { path: pagePath });
         });
@@ -563,7 +565,7 @@ export async function run(argv, env) {
         .option('--since <ref>', 'the changes since this ref, as a pull request against it would show')
         .action(async (cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('publish.urls', runEnv, jsonMode, async () => {
+        state.result = await runCommand('publish.urls', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return publishUrlsCommand.execute(store, { staged: cmdOpts.staged === true, since: cmdOpts.since });
         });
@@ -574,7 +576,7 @@ export async function run(argv, env) {
         .description('(re)generate every configured harness-generation adapter\'s output')
         .action(async (_cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('adapters.generate', runEnv, jsonMode, async () => {
+        state.result = await runCommand('adapters.generate', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return adaptersGenerateCommand.execute(runEnv, store);
         });
@@ -586,7 +588,7 @@ export async function run(argv, env) {
         .option('--host <address>', 'address to bind — widening beyond the default exposes the server, with no requester filtering of its own, to whatever can reach that address', serveCommand.DEFAULT_HOST)
         .action(async (cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('serve', runEnv, jsonMode, async () => {
+        state.result = await runCommand('serve', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return serveCommand.execute(runEnv, store, { port: cmdOpts.port, host: cmdOpts.host });
         });
@@ -597,7 +599,7 @@ export async function run(argv, env) {
         .option('--check', 'resolve the latest published release and compare it against the installed one')
         .action(async (cmdOpts, cmd) => {
         const { runEnv, jsonMode } = deriveRunEnv(env, cmd);
-        result = await runCommand('version', runEnv, jsonMode, () => versionCommand.execute(runEnv, { check: cmdOpts.check }));
+        state.result = await runCommand('version', runEnv, jsonMode, () => versionCommand.execute(runEnv, { check: cmdOpts.check }));
     });
     program
         .command('update')
@@ -605,7 +607,7 @@ export async function run(argv, env) {
         .option('--worktree', 'work in a new worktree on a branch named for this release, never in this checkout; commits nothing')
         .action(async (cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('update', runEnv, jsonMode, async () => {
+        state.result = await runCommand('update', runEnv, jsonMode, async () => {
             // The one command allowed past the schema gate on an older store (migrate-stores-on-update).
             const store = await openStoreMigrating(runEnv, { root });
             return cmdOpts.worktree
@@ -619,7 +621,7 @@ export async function run(argv, env) {
         .option('--portable', "verify the store's recorded commit in a disposable checkout, in a child process with no harness state reachable")
         .action(async (cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('verify', runEnv, jsonMode, async () => {
+        state.result = await runCommand('verify', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return verifyCommand.execute(runEnv, store, { portable: cmdOpts.portable });
         });
@@ -633,18 +635,42 @@ export async function run(argv, env) {
         .option('--session <session>', 'with --confirm: land every pull request of a session homed here (worktree name or branch), parts in mounted stores first, stopping at the first that does not land')
         .action(async (pr, cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('land', runEnv, jsonMode, async () => {
+        state.result = await runCommand('land', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return landCommand.execute(runEnv, store, { pr, pending: Boolean(cmdOpts.pending), confirm: Boolean(cmdOpts.confirm), session: cmdOpts.session });
         });
     });
+    program
+        .command('sync')
+        .description("bring the canonical clone up to date with the forge's default branch by landing's fast-forward rule, leaving a clone with local work alone; with --every, keep doing so, mounts included")
+        .option('--every <minutes>', 'keep running: every this many whole minutes, sync the canonical clone and then refresh the mounts as `ctxr shared-stores sync` does', (v) => Number(v))
+        .action(async (cmdOpts, cmd) => {
+        const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
+        state.result = await runCommand('sync', runEnv, jsonMode, async () => {
+            const store = await openStore(runEnv, { root });
+            return syncCommand.execute(runEnv, store, cmdOpts.every === undefined ? {} : { every: cmdOpts.every });
+        });
+    });
+    // serve-the-session-lifecycle-to-chat-apps D7: the chat-app plugins, built from the MCP render of the owned skills.
+    const pluginCommand = program.command('plugin').description("build the store's Claude and ChatGPT plugins: its skills and its MCP server");
+    pluginCommand
+        .command('build')
+        .description('write the Claude and ChatGPT plugins, each as a directory and a zip archive, from the MCP render of the owned skills and serve.base_url')
+        .option('--out <dir>', 'where to write them (default: .contexture/cache/plugin/ under the store root)')
+        .action(async (cmdOpts, cmd) => {
+        const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
+        state.result = await runCommand('plugin.build', runEnv, jsonMode, async () => {
+            const store = await openStore(runEnv, { root });
+            return pluginBuildCommand.execute(runEnv, store, { out: cmdOpts.out });
+        });
+    });
     const reviewCommand = program.command('review').description('read the decisions people made on session pull requests from the approval page');
     reviewCommand
         .command('list')
         .description('report each open session pull request with its decision state: awaiting, approved, changes-requested, needs-reapproval or blocked')
         .action(async (_cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('review.list', runEnv, jsonMode, async () => {
+        state.result = await runCommand('review.list', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return reviewListCommand.execute(runEnv, store);
         });
@@ -660,7 +686,7 @@ export async function run(argv, env) {
         .option('--timeout <seconds>', 'per-CLI time limit in seconds (default 600)');
     commonSecondOpinionOptions(secondOpinionGroup.command('preflight').description('check each model CLI answers, at the tier the run will use, and still accepts the flags this command passes')).action(async (cmdOpts, cmd) => {
         const { runEnv, jsonMode } = deriveRunEnv(env, cmd);
-        result = await runCommand('second-opinion.preflight', runEnv, jsonMode, () => secondOpinionCommand.executePreflight(runEnv, cmdOpts));
+        state.result = await runCommand('second-opinion.preflight', runEnv, jsonMode, () => secondOpinionCommand.executePreflight(runEnv, cmdOpts));
     });
     commonSecondOpinionOptions(secondOpinionGroup.command('critique').description('send a written plan to three critic roles, each on a different model family, and write anonymised letters and a manifest'))
         .option('--plan-file <path>', 'the plan to critique (default: read from stdin)')
@@ -668,7 +694,7 @@ export async function run(argv, env) {
         .option('--seed <n>', 'seed the letter assignment, for a reproducible mapping')
         .action(async (cmdOpts, cmd) => {
         const { runEnv, jsonMode } = deriveRunEnv(env, cmd);
-        result = await runCommand('second-opinion.critique', runEnv, jsonMode, () => secondOpinionCommand.executeCritique(runEnv, cmdOpts));
+        state.result = await runCommand('second-opinion.critique', runEnv, jsonMode, () => secondOpinionCommand.executeCritique(runEnv, cmdOpts));
     });
     commonSecondOpinionOptions(secondOpinionGroup.command('poll').description('send one question to the same model families, optionally answered through two or three taste lenses'))
         .option('--prompt-file <path>', 'the question and its options (default: read from stdin)')
@@ -677,7 +703,7 @@ export async function run(argv, env) {
         .option('--no-wrap', 'send the question as written, without the answer scaffold')
         .action(async (cmdOpts, cmd) => {
         const { runEnv, jsonMode } = deriveRunEnv(env, cmd);
-        result = await runCommand('second-opinion.poll', runEnv, jsonMode, () => secondOpinionCommand.executePoll(runEnv, cmdOpts));
+        state.result = await runCommand('second-opinion.poll', runEnv, jsonMode, () => secondOpinionCommand.executePoll(runEnv, cmdOpts));
     });
     const sharedStoresCommand = program.command('shared-stores').description('the stores this store mounts under shared/');
     sharedStoresCommand
@@ -685,7 +711,7 @@ export async function run(argv, env) {
         .description('clone each declared mount that is missing and fast-forward the others, leaving any with local work alone')
         .action(async (_cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('shared-stores.sync', runEnv, jsonMode, async () => {
+        state.result = await runCommand('shared-stores.sync', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return sharedStoresSyncCommand.execute(runEnv, store);
         });
@@ -695,7 +721,7 @@ export async function run(argv, env) {
         .description('report each declared mount: present, a store, branch, commit, uncommitted changes — no writes, no network')
         .action(async (_cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('shared-stores.status', runEnv, jsonMode, async () => {
+        state.result = await runCommand('shared-stores.status', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return sharedStoresStatusCommand.execute(runEnv, store);
         });
@@ -708,7 +734,7 @@ export async function run(argv, env) {
         .option('--joins <session>', 'run inside a mounted store: start a session that belongs to this live session of the store that mounts it (worktree name or branch)')
         .action(async (label, cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('session.start', runEnv, jsonMode, async () => {
+        state.result = await runCommand('session.start', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return sessionStartCommand.execute(runEnv, store, { label, ...(cmdOpts.joins === undefined ? {} : { joins: cmdOpts.joins }) });
         });
@@ -719,7 +745,7 @@ export async function run(argv, env) {
         .requiredOption('--proposal <path>', 'a YAML file of approved note items')
         .action(async (cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('session.capture', runEnv, jsonMode, async () => {
+        state.result = await runCommand('session.capture', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return sessionCaptureCommand.execute(store, cmdOpts);
         });
@@ -730,7 +756,7 @@ export async function run(argv, env) {
         .option('--review', "also read each session's open pull request and, when the store declares change_approval, its decision state from the forge")
         .action(async (cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('session.list', runEnv, jsonMode, async () => {
+        state.result = await runCommand('session.list', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return sessionListCommand.execute(runEnv, store, { review: Boolean(cmdOpts.review) });
         });
@@ -743,7 +769,7 @@ export async function run(argv, env) {
         .option('--diff', 'also print the unified diff of uncommitted work')
         .action(async (session, cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('session.status', runEnv, jsonMode, async () => {
+        state.result = await runCommand('session.status', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return sessionStatusCommand.execute(runEnv, store, { session, diff: Boolean(cmdOpts.diff) });
         });
@@ -759,7 +785,7 @@ export async function run(argv, env) {
         .option('--body-file <path>', 'read the pull request body from a file instead')
         .action(async (session, cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('session.submit', runEnv, jsonMode, async () => {
+        state.result = await runCommand('session.submit', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return sessionSubmitCommand.execute(runEnv, store, { session, ...cmdOpts });
         });
@@ -772,7 +798,7 @@ export async function run(argv, env) {
         .option('--abort', 'abort the rebase and restore the session as it was')
         .action(async (session, cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('session.rebase', runEnv, jsonMode, async () => {
+        state.result = await runCommand('session.rebase', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return sessionRebaseCommand.execute(runEnv, store, { session, continue: cmdOpts.continue, abort: cmdOpts.abort });
         });
@@ -785,11 +811,20 @@ export async function run(argv, env) {
         .option('--close-pull-request', 'also close the session\'s open pull request')
         .action(async (session, cmdOpts, cmd) => {
         const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
-        result = await runCommand('session.discard', runEnv, jsonMode, async () => {
+        state.result = await runCommand('session.discard', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
             return sessionDiscardCommand.execute(runEnv, store, { session, force: cmdOpts.force, closePullRequest: cmdOpts.closePullRequest });
         });
     });
+    return { program, state };
+}
+export async function run(argv, env) {
+    if (isGlobalVersionRequest(argv)) {
+        const jsonMode = argv.includes('--json');
+        const runEnv = { ...env, noInput: env.noInput || argv.includes('--no-input') || jsonMode };
+        return runCommand('version', runEnv, jsonMode, () => versionCommand.execute(runEnv));
+    }
+    const { program, state } = buildProgram(env);
     try {
         await program.parseAsync(argv, { from: 'user' });
     }
@@ -827,6 +862,6 @@ export async function run(argv, env) {
         }
         throw err;
     }
-    return result;
+    return state.result;
 }
 //# sourceMappingURL=run.js.map