ctxr-cli 0.33.0 → 0.35.0

package/dist/run.js

@@ -19,9 +19,17 @@ 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';
+import * as sharedStoresSyncCommand from './commands/shared-stores-sync.js';
 import * as sessionCaptureCommand from './commands/session-capture.js';
+import * as sessionDiscardCommand from './commands/session-discard.js';
 import * as sessionListCommand from './commands/session-list.js';
+import * as sessionRebaseCommand from './commands/session-rebase.js';
+import * as sessionStatusCommand from './commands/session-status.js';
+import * as sessionSubmitCommand from './commands/session-submit.js';
 import * as serveCommand from './commands/serve.js';
 import * as sessionStartCommand from './commands/session-start.js';
 import * as rollupGatherCommand from './commands/rollup-gather.js';
@@ -161,12 +169,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')
@@ -178,7 +186,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')
@@ -187,7 +195,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')
@@ -195,7 +203,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 });
         });
@@ -208,7 +216,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 });
         });
@@ -219,7 +227,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);
         });
@@ -230,7 +238,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 });
         });
@@ -241,7 +249,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 });
         });
@@ -260,7 +268,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,
@@ -281,7 +289,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 });
         });
@@ -297,7 +305,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);
@@ -312,7 +320,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,
@@ -327,7 +335,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 });
         });
@@ -337,7 +345,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 });
         });
@@ -348,7 +356,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 });
         });
@@ -358,7 +366,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, {});
         });
@@ -369,7 +377,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 });
         });
@@ -379,7 +387,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, {});
         });
@@ -392,7 +400,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,
@@ -408,7 +416,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 });
         });
@@ -419,7 +427,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 });
         });
@@ -431,7 +439,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 });
         });
@@ -442,7 +450,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 });
         });
@@ -452,7 +460,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);
         });
@@ -462,7 +470,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 });
         });
@@ -473,7 +481,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 });
         });
@@ -484,7 +492,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 });
         });
@@ -495,7 +503,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 });
         });
@@ -509,7 +517,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,
@@ -524,7 +532,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 });
         });
@@ -534,7 +542,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 });
         });
@@ -544,7 +552,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 });
         });
@@ -556,7 +564,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 });
         });
@@ -567,7 +575,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);
         });
@@ -579,7 +587,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 });
         });
@@ -590,7 +598,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')
@@ -598,7 +606,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
@@ -612,7 +620,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 });
         });
@@ -623,11 +631,25 @@ export async function run(argv, env) {
         .argument('[pr]', 'the pull request number to land', (v) => Number.parseInt(v, 10))
         .option('--pending', 'land every open session pull request whose current head carries an approval from the approval page')
         .option('--confirm', 'the caller already has an explicit go for this pull request; land it without a recorded approval')
+        .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) });
+            return landCommand.execute(runEnv, store, { pr, pending: Boolean(cmdOpts.pending), confirm: Boolean(cmdOpts.confirm), session: cmdOpts.session });
+        });
+    });
+    // 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');
@@ -636,21 +658,73 @@ export async function run(argv, env) {
         .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);
         });
     });
+    // run-the-second-opinion-from-the-cli D1: the one command group that invokes a model CLI. Its options are
+    // contexture's own; the model CLIs' flags stay inside src/core/second-opinion/. It opens no store.
+    const secondOpinionGroup = program
+        .command('second-opinion')
+        .description('a cross-model second opinion: the same plan or question sent to three model families\' command-line tools in parallel');
+    const commonSecondOpinionOptions = (sub) => sub
+        .option('--tier <tier>', 'strong (each family\'s frontier model, the default) or fast (each family\'s workhorse)')
+        .option('--only <clis>', 'comma-separated model CLIs to use (claude, codex, agy); a critique or poll needs at least two')
+        .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);
+        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)')
+        .option('--out <dir>', 'where to write the critiques and the manifest (default: a new temporary directory)')
+        .option('--seed <n>', 'seed the letter assignment, for a reproducible mapping')
+        .action(async (cmdOpts, cmd) => {
+        const { runEnv, jsonMode } = deriveRunEnv(env, cmd);
+        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)')
+        .option('--out <dir>', 'where to write the answers and the manifest (default: a new temporary directory)')
+        .option('--lens <lenses>', 'two or three comma-separated taste lenses: built-in names or Name:description')
+        .option('--no-wrap', 'send the question as written, without the answer scaffold')
+        .action(async (cmdOpts, cmd) => {
+        const { runEnv, jsonMode } = deriveRunEnv(env, cmd);
+        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
+        .command('sync')
+        .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);
+        state.result = await runCommand('shared-stores.sync', runEnv, jsonMode, async () => {
+            const store = await openStore(runEnv, { root });
+            return sharedStoresSyncCommand.execute(runEnv, store);
+        });
+    });
+    sharedStoresCommand
+        .command('status')
+        .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);
+        state.result = await runCommand('shared-stores.status', runEnv, jsonMode, async () => {
+            const store = await openStore(runEnv, { root });
+            return sharedStoresStatusCommand.execute(runEnv, store);
+        });
+    });
     const sessionCommand = program.command('session').description('manage session worktrees');
     sessionCommand
         .command('start')
         .description('create a new session worktree off a freshly fetched default branch')
         .argument('[label]', 'a short name for what the session is for — becomes part of the branch and worktree name')
-        .action(async (label, _cmdOpts, cmd) => {
+        .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 });
+            return sessionStartCommand.execute(runEnv, store, { label, ...(cmdOpts.joins === undefined ? {} : { joins: cmdOpts.joins }) });
         });
     });
     sessionCommand
@@ -659,21 +733,86 @@ 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);
         });
     });
     sessionCommand
         .command('list')
-        .description('list active session worktrees')
-        .action(async (_cmdOpts, cmd) => {
+        .description("list active session worktrees, each with its uncommitted state and commits ahead, read locally")
+        .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);
+        state.result = await runCommand('session.list', runEnv, jsonMode, async () => {
+            const store = await openStore(runEnv, { root });
+            return sessionListCommand.execute(runEnv, store, { review: Boolean(cmdOpts.review) });
+        });
+    });
+    // bring-the-session-lifecycle-into-the-cli D3: the lifecycle's mechanical steps, shared with the MCP surface.
+    sessionCommand
+        .command('status')
+        .description('re-scan a session: its uncommitted changes, the diff stat of committed and uncommitted work, and its commits ahead of the default branch')
+        .argument('[session]', 'the session worktree\'s directory name, as `session list` prints it (default: the session containing the working directory)')
+        .option('--diff', 'also print the unified diff of uncommitted work')
+        .action(async (session, cmdOpts, cmd) => {
+        const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
+        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) });
+        });
+    });
+    sessionCommand
+        .command('submit')
+        .description('stage a session\'s changes outside derived paths, gate on doctor, commit, name the branch, push, and open or update its pull request with the Pages and Knowledge changes sections appended')
+        .argument('<session>', 'the session worktree\'s directory name, as `session list` prints it')
+        .requiredOption('--branch <name>', 'the branch name the pull request carries; the session\'s branch is renamed to it')
+        .requiredOption('--message <msg>', 'the commit message')
+        .requiredOption('--title <title>', 'the pull request title')
+        .option('--body <body>', 'the pull request body: why, what changed, route, verification and follow-ups')
+        .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);
+        state.result = await runCommand('session.submit', runEnv, jsonMode, async () => {
+            const store = await openStore(runEnv, { root });
+            return sessionSubmitCommand.execute(runEnv, store, { session, ...cmdOpts });
+        });
+    });
+    sessionCommand
+        .command('rebase')
+        .description('fetch the default branch and rebase a session onto it, reporting each conflicting path with both sides')
+        .argument('<session>', 'the session worktree\'s directory name, as `session list` prints it')
+        .option('--continue', 'stage the resolved paths and continue the rebase')
+        .option('--abort', 'abort the rebase and restore the session as it was')
+        .action(async (session, cmdOpts, cmd) => {
+        const { runEnv, jsonMode, root } = deriveRunEnv(env, cmd);
+        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 });
+        });
+    });
+    sessionCommand
+        .command('discard')
+        .description('remove a session worktree and its local branch, refusing uncommitted or unpushed work unless forced')
+        .argument('<session>', 'the session worktree\'s directory name, as `session list` prints it')
+        .option('--force', 'discard uncommitted changes and commits the remote branch lacks')
+        .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.list', runEnv, jsonMode, async () => {
+        state.result = await runCommand('session.discard', runEnv, jsonMode, async () => {
             const store = await openStore(runEnv, { root });
-            return sessionListCommand.execute(runEnv, store);
+            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' });
     }
@@ -711,6 +850,6 @@ export async function run(argv, env) {
         }
         throw err;
     }
-    return result;
+    return state.result;
 }
 //# sourceMappingURL=run.js.map