wingfoil 0.2.1

package/dist/cli/init-command.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInit = runInit;
+exports.createReadlinePrompt = createReadlinePrompt;
+/**
+ * `wingfoil init` command handler (task-029-implement-wingfoil-init, P5.1.1, spec-008-cli-grammar §4,
+ * spec-005-cli-command-contract §1). `init` is a SPECIAL bootstrap command: it runs BEFORE any config
+ * exists, so it is not a standard noun-verb `CORE_MODULES` operation that loads config first — it is
+ * wired directly onto the program (see ./program.ts) and drives the `initWingfoilProject` core flow.
+ *
+ * `runInit` owns the spec-008 §4 prompt matrix (present/missing template x TTY/non-TTY x
+ * `--interactive`) and the spec-005 §1 exit-code contract, and takes its side-effecting pieces —
+ * the resolved `root`, TTY detection, the wizard `prompt`, and the `init` core function — as injected
+ * `deps` so the whole matrix is unit-testable without a real TTY, readline, or git repo. The only
+ * un-injected concern (a real readline prompt) lives in {@link createReadlinePrompt}, mirroring how
+ * ./program.ts's `commander` wiring is the one un-unit-tested mechanical seam.
+ */
+const node_readline_1 = require("node:readline");
+const core_1 = require("../core");
+const storage_1 = require("../storage");
+const error_1 = require("./error");
+const exit_1 = require("./exit");
+const output_1 = require("./output");
+/** The wizard question, listing the available templates and the default (spec-008 §4). */
+function templateQuestion() {
+    return `Select a methodology template [${storage_1.TEMPLATE_NAMES.join(', ')}] (default: ${storage_1.DEFAULT_TEMPLATE}): `;
+}
+/**
+ * Decide the canonical template name to initialize with, applying the spec-008 §4 matrix. Returns the
+ * canonical name on success, or `null` after it has already emitted the usage error and exited `2`
+ * (the caller must stop) — so a `null` return is a terminal, already-handled state.
+ */
+async function selectTemplate(options, deps, format) {
+    // 1. --template present: resolve it (an unknown value is a usage error, exit 2).
+    if (options.template !== undefined && options.template.trim() !== '') {
+        const def = (0, storage_1.resolveTemplate)(options.template);
+        if (!def) {
+            (0, error_1.emitError)(`unknown template "${options.template}", expected one of: ${storage_1.TEMPLATE_NAMES.join(', ')}`, { format });
+            (0, exit_1.exitWith)(2);
+            return null;
+        }
+        return def.name;
+    }
+    // 2. --template absent + (non-interactive OR not a TTY): fail immediately (spec-008 §4).
+    if (!options.interactive || !deps.isTTY) {
+        (0, error_1.emitError)('missing required argument: --template', { format });
+        (0, exit_1.exitWith)(2);
+        return null;
+    }
+    // 3. Interactive TTY: run the wizard. Empty answer -> the default template.
+    const answer = (await deps.prompt(templateQuestion())).trim();
+    if (answer === '')
+        return storage_1.DEFAULT_TEMPLATE;
+    const def = (0, storage_1.resolveTemplate)(answer);
+    if (!def) {
+        (0, error_1.emitError)(`unknown template "${answer}", expected one of: ${storage_1.TEMPLATE_NAMES.join(', ')}`, { format });
+        (0, exit_1.exitWith)(2);
+        return null;
+    }
+    return def.name;
+}
+/**
+ * Execute `wingfoil init`. Terminates through the single spec-005 §1 exit path (`exitWith`) exactly
+ * once: `2` on any usage error (invalid `--format`, unknown/omitted-required `--template`), otherwise
+ * the code the core `CoreResult` maps to (`0` success / `1` already-initialized or other logic error).
+ */
+async function runInit(options, deps) {
+    // Usage error first (pre-core), same as the registrar: an invalid --format never reaches core.
+    if (!(0, output_1.isValidFormat)(options.format)) {
+        (0, exit_1.exitWith)(2, `error: invalid --format value "${options.format}", expected one of: console, json, yaml`);
+        return;
+    }
+    const format = options.format;
+    const template = await selectTemplate(options, deps, format);
+    if (template === null)
+        return; // usage error already emitted + exited (2)
+    const init = deps.init ?? core_1.initWingfoilProject;
+    const result = init(deps.root, template);
+    if (result.ok) {
+        process.stdout.write((0, output_1.renderSuccess)(result.value, format));
+    }
+    else {
+        (0, error_1.emitError)(result.error.message, { format });
+    }
+    (0, exit_1.exitWith)((0, core_1.exitCodeForResult)(result));
+}
+/**
+ * A real readline-backed wizard prompt (used by ./program.ts's `init` command; not unit-tested — the
+ * same seam as `commander` wiring). Reads one line from stdin, resolves it, and closes the interface.
+ */
+function createReadlinePrompt() {
+    return (question) => new Promise((resolve) => {
+        const rl = (0, node_readline_1.createInterface)({ input: process.stdin, output: process.stdout });
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+//# sourceMappingURL=init-command.js.map

package/dist/cli/init-command.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-command.js","sourceRoot":"","sources":["../../src/cli/init-command.ts"],"names":[],"mappings":"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"}

package/dist/cli/mcp-command.d.ts

@@ -0,0 +1,24 @@
+import { type OutputFormat } from './output';
+/** The options `runMcp` acts on (injected so the resolve-root/error path needs no real stdio server). */
+export interface McpCliDeps {
+    /** Resolve the project (git) root; throws when the cwd is not inside an initialized WingFoil project. */
+    readonly resolveRoot: () => string;
+    /** The CLI version to advertise as the MCP server's identity `version` (read from `package.json`). */
+    readonly version: string;
+    /** The output format for the pre-flight error path; defaults to `console`. */
+    readonly format?: OutputFormat;
+    /** Start the server; defaults to {@link startMcpServer} (overridden in tests to avoid real stdio). */
+    readonly start?: (options: {
+        resolveRoot: () => string;
+        name: string;
+        version: string;
+    }) => Promise<unknown>;
+}
+/**
+ * Execute `wingfoil mcp`. Resolves the project root once, up front (fail-fast: an unresolvable root
+ * emits `error: <reason>` on stderr and exits `1`, never starting the server), then hands the server
+ * start a closure returning that already-resolved root. On success it does not exit — the server runs
+ * over stdio until the transport closes.
+ */
+export declare function runMcp(deps: McpCliDeps): Promise<void>;
+//# sourceMappingURL=mcp-command.d.ts.map

package/dist/cli/mcp-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-command.d.ts","sourceRoot":"","sources":["../../src/cli/mcp-command.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,UAAU,CAAC;AAE5D,yGAAyG;AACzG,MAAM,WAAW,UAAU;IACzB,yGAAyG;IACzG,QAAQ,CAAC,WAAW,EAAE,MAAM,MAAM,CAAC;IACnC,sGAAsG;IACtG,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,8EAA8E;IAC9E,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B,sGAAsG;IACtG,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,WAAW,EAAE,MAAM,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC9G;AAED;;;;;GAKG;AACH,wBAAsB,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAc5D"}

package/dist/cli/mcp-command.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMcp = runMcp;
+/**
+ * `wingfoil mcp` command handler (task-030-implement-mcp-resources, P5.2.1,
+ * spec-014-mcp-server-entry-point §1). `mcp` is a SPECIAL command: it does not wrap a single `src/core`
+ * `CoreOperation` (so it is not a `CORE_MODULES` noun-verb op) — it owns a long-running process
+ * lifecycle, starting the production MCP server over stdio. It is wired directly onto the program
+ * (see ./program.ts), exactly like `wingfoil init` (task-029).
+ *
+ * `runMcp` owns the spec-014 §1 pre-flight: resolve the project root, and on failure emit the standard
+ * `error: <reason>` line and exit `1` (a user/logic error — not inside a WingFoil project) WITHOUT
+ * starting a partially-wired server. The side-effecting server start (`startMcpServer`, which opens a
+ * real `StdioServerTransport`) is injected as `deps.start`, so this whole pre-flight is unit-testable
+ * without ever opening a real stdio channel against a repo — the same seam `init-command.ts`'s
+ * injectable `runInit` uses.
+ */
+const server_1 = require("../mcp/server");
+const error_1 = require("./error");
+const exit_1 = require("./exit");
+const output_1 = require("./output");
+/**
+ * Execute `wingfoil mcp`. Resolves the project root once, up front (fail-fast: an unresolvable root
+ * emits `error: <reason>` on stderr and exits `1`, never starting the server), then hands the server
+ * start a closure returning that already-resolved root. On success it does not exit — the server runs
+ * over stdio until the transport closes.
+ */
+async function runMcp(deps) {
+    const format = deps.format && (0, output_1.isValidFormat)(deps.format) ? deps.format : 'console';
+    let root;
+    try {
+        root = deps.resolveRoot();
+    }
+    catch (error) {
+        (0, error_1.emitError)(error instanceof Error ? error.message : String(error), { format });
+        (0, exit_1.exitWith)(1);
+        return;
+    }
+    const start = deps.start ?? server_1.startMcpServer;
+    await start({ resolveRoot: () => root, name: 'wingfoil', version: deps.version });
+}
+//# sourceMappingURL=mcp-command.js.map

package/dist/cli/mcp-command.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-command.js","sourceRoot":"","sources":["../../src/cli/mcp-command.ts"],"names":[],"mappings":";;AAsCA,wBAcC;AApDD;;;;;;;;;;;;;GAaG;AACH,0CAA+C;AAE/C,mCAAoC;AACpC,iCAAkC;AAClC,qCAA4D;AAc5D;;;;;GAKG;AACI,KAAK,UAAU,MAAM,CAAC,IAAgB;IAC3C,MAAM,MAAM,GAAiB,IAAI,CAAC,MAAM,IAAI,IAAA,sBAAa,EAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;IAEjG,IAAI,IAAY,CAAC;IACjB,IAAI,CAAC;QACH,IAAI,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;IAC5B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAA,iBAAS,EAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;QAC9E,IAAA,eAAQ,EAAC,CAAC,CAAC,CAAC;QACZ,OAAO;IACT,CAAC;IAED,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,uBAAc,CAAC;IAC3C,MAAM,KAAK,CAAC,EAAE,WAAW,EAAE,GAAG,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;AACpF,CAAC"}

package/dist/cli/output.d.ts

@@ -0,0 +1,13 @@
+/** The accepted `--format` values (spec-005 §2); `console` is the default when the flag is omitted. */
+export type OutputFormat = 'console' | 'json' | 'yaml';
+/** Type guard: `true` (narrowing to {@link OutputFormat}) when `value` is one of the accepted `--format` values. */
+export declare function isValidFormat(value: string): value is OutputFormat;
+/**
+ * Render a successful `CoreResult.value` to stdout text, per the envelope rules in spec-005 §2:
+ * `json`/`yaml` carry only the structured payload (no banners/colour); `console` payload *shape*
+ * is otherwise owned by each command's own spec (none exists yet for today's read-only pillar
+ * queries — see task-006 Execution Notes — so `console` falls back to pretty-printed JSON, the
+ * same structure as `json`/`yaml`, until a command-specific spec defines a human-facing rendering).
+ */
+export declare function renderSuccess(value: unknown, format: OutputFormat): string;
+//# sourceMappingURL=output.d.ts.map

package/dist/cli/output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../src/cli/output.ts"],"names":[],"mappings":"AAMA,uGAAuG;AACvG,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC;AAEvD,oHAAoH;AACpH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,YAAY,CAElE;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,GAAG,MAAM,CAI1E"}

package/dist/cli/output.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidFormat = isValidFormat;
+exports.renderSuccess = renderSuccess;
+/**
+ * Machine-readable output formats (spec-005-cli-command-contract §2, REQ-INT-05). `console` is the
+ * default when `--format` is omitted.
+ */
+const js_yaml_1 = require("js-yaml");
+/** Type guard: `true` (narrowing to {@link OutputFormat}) when `value` is one of the accepted `--format` values. */
+function isValidFormat(value) {
+    return value === 'console' || value === 'json' || value === 'yaml';
+}
+/**
+ * Render a successful `CoreResult.value` to stdout text, per the envelope rules in spec-005 §2:
+ * `json`/`yaml` carry only the structured payload (no banners/colour); `console` payload *shape*
+ * is otherwise owned by each command's own spec (none exists yet for today's read-only pillar
+ * queries — see task-006 Execution Notes — so `console` falls back to pretty-printed JSON, the
+ * same structure as `json`/`yaml`, until a command-specific spec defines a human-facing rendering).
+ */
+function renderSuccess(value, format) {
+    if (format === 'json')
+        return JSON.stringify(value) + '\n';
+    if (format === 'yaml')
+        return (0, js_yaml_1.dump)(value);
+    return JSON.stringify(value, null, 2) + '\n';
+}
+//# sourceMappingURL=output.js.map

package/dist/cli/output.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.js","sourceRoot":"","sources":["../../src/cli/output.ts"],"names":[],"mappings":";;AAUA,sCAEC;AASD,sCAIC;AAzBD;;;GAGG;AACH,qCAA2C;AAK3C,oHAAoH;AACpH,SAAgB,aAAa,CAAC,KAAa;IACzC,OAAO,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,MAAM,IAAI,KAAK,KAAK,MAAM,CAAC;AACrE,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,aAAa,CAAC,KAAc,EAAE,MAAoB;IAChE,IAAI,MAAM,KAAK,MAAM;QAAE,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IAC3D,IAAI,MAAM,KAAK,MAAM;QAAE,OAAO,IAAA,cAAQ,EAAC,KAAK,CAAC,CAAC;IAC9C,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC;AAC/C,CAAC"}

package/dist/cli/program.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from 'commander' with { 'resolution-mode': 'import' };
+import type { CoreModule } from '../core/registry';
+import { type BuildCommandsOptions } from './registrar';
+/**
+ * Build the root `commander` program: register the global flags, the special `init`/`mcp` bootstrap
+ * commands, and one `wingfoil <noun> <verb>` (or flat `<noun>`) command per `CoreModule` operation
+ * derived through {@link BuildCommandsOptions}. Async because `commander` is imported dynamically
+ * (see the module doc). The command *behaviour* lives in `./registrar.ts`; this only wires it onto
+ * Commander.
+ */
+export declare function buildProgram(modules: readonly CoreModule[], options: BuildCommandsOptions): Promise<Command>;
+//# sourceMappingURL=program.d.ts.map

package/dist/cli/program.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"program.d.ts","sourceRoot":"","sources":["../../src/cli/program.ts"],"names":[],"mappings":"AAqCA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC,OAAO,iBAAiB,EAAE,QAAQ,EAAE,CAAC;AAE9E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAKnD,OAAO,EAAoB,KAAK,oBAAoB,EAAmB,MAAM,aAAa,CAAC;AAkB3F;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,EAAE,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,OAAO,CAAC,CAwHlH"}

package/dist/cli/program.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProgram = buildProgram;
+/**
+ * Wires `./registrar.ts`'s Commander-independent command model onto a real `commander` `Command`
+ * tree — the only place this module (or any module reachable from a test file) imports `commander`.
+ *
+ * ENVIRONMENT NOTE (task-006, see the task's Execution Notes for the full write-up): `commander`
+ * v15 ships ESM-only (no CJS build — its `package.json` has `"type": "module"` and a single
+ * `"default": "./index.js"` export). This project's `tsconfig.json` (`module: Node16`, no
+ * top-level `"type": "module"` in `package.json`) compiles `.ts` files as CommonJS by default, and
+ * a *static* `import { Command } from 'commander'` from a CJS-resolved file is downleveled to a
+ * `require()` call — which `tsc --noEmit` itself refuses to emit for an ESM-only target (TS1479),
+ * and which, even if suppressed, would crash at Jest-test runtime (`ts-jest`'s CommonJS test
+ * environment cannot `require()` an ESM module; confirmed empirically — this predates task-006, a
+ * consequence of task-001's dependency pick, not something in this task's scope to fix
+ * project-wide, e.g. by migrating the whole Jest config to ESM or downgrading `commander`).
+ *
+ * The fix that keeps `commander` as the real, declared CLI dependency (per `dna.yaml` /
+ * spec-005/008) without touching the project's Jest/tsconfig setup: a *dynamic* `import('commander')`
+ * here, inside an async function. Dynamic `import()` is never downleveled by `tsc` regardless of
+ * module target, so it does not trigger TS1479, and it resolves correctly at real `node`/`wingfoil`
+ * runtime (Node 22's ESM-aware module loader).
+ *
+ * TESTING (task-065-fix-commander-esm-jest-harness, `bug-007-commander-esm-jest-untestable`): this
+ * file's wiring — construct the global flags, register a noun/verb `Command` per `CliCommand`,
+ * forward to `command.run` — used to be verified by hand, because a test importing it hit that same
+ * Jest-runtime wall (`module: Node16` *preserves* the dynamic `import()`, and jest's CommonJS runtime
+ * has no dynamic-import callback). It is now covered two ways, with no change to this file: in-process
+ * by `test/cli/program.test.ts` — jest compiles the test runtime as CommonJS against
+ * `tsconfig.test.json` and transforms `commander`'s ESM on the way in, see `jest.config.js` — and
+ * black-box by `test/cli/program.integration.test.ts`, which spawns the compiled `dist/` and so
+ * exercises the real ESM `import()` this file actually ships with.
+ * `buildCliCommands`/`listRegisteredCliCommands` (`./registrar.ts`) still carry 100% of the
+ * AC-relevant behavior; this file adds no logic of its own beyond Commander's own API calls.
+ */
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+// Direct module import, not the `../core` barrel — the same path `./registrar.ts` already uses for the
+// other two exit-code mappings (task-101; keeps this file out of the barrel's merge surface).
+const exit_code_1 = require("../core/exit-code");
+const registrar_1 = require("./registrar");
+const init_command_1 = require("./init-command");
+const mcp_command_1 = require("./mcp-command");
+const error_1 = require("./error");
+const exit_1 = require("./exit");
+const output_1 = require("./output");
+/**
+ * The CLI version, read from `package.json` deterministically (REQ-SYS-07 — no wall-clock, no
+ * inference): the manifest sits two levels up from this module in both the `src/cli/` source layout
+ * and the compiled `dist/cli/` layout, and npm always ships `package.json` at the package root, so
+ * the same relative path resolves for `wingfoil --version` after a global install.
+ */
+function readPackageVersion() {
+    const manifestPath = (0, node_path_1.join)(__dirname, '..', '..', 'package.json');
+    return JSON.parse((0, node_fs_1.readFileSync)(manifestPath, 'utf-8')).version;
+}
+/**
+ * Build the root `commander` program: register the global flags, the special `init`/`mcp` bootstrap
+ * commands, and one `wingfoil <noun> <verb>` (or flat `<noun>`) command per `CoreModule` operation
+ * derived through {@link BuildCommandsOptions}. Async because `commander` is imported dynamically
+ * (see the module doc). The command *behaviour* lives in `./registrar.ts`; this only wires it onto
+ * Commander.
+ */
+async function buildProgram(modules, options) {
+    const { Command: CommandCtor } = await import('commander');
+    const program = new CommandCtor('wingfoil');
+    // Route Commander's OWN terminations through the spec-005 §1 exit-code contract
+    // (task-101-route-commander-parse-errors-through-the-exit-code-contract, `bug-098`). Commander
+    // detects an unknown command / unknown option / missing option argument before any WingFoil code
+    // runs and, left alone, ends the process itself at its suggested exit code — `1` for every error it
+    // raises, which is the code spec-005 §1 reserves for a well-formed invocation that failed. The
+    // callback is the whole interception: the *code* is chosen by `classifyParseOutcome`
+    // (`src/core/exit-code.ts`, beside the other two mappings — this file adds no second decision site),
+    // and the process ends through `exitWith`, the single exit seam of `./exit.ts`, like every other
+    // outcome.
+    //
+    // COMMANDER'S OWN MESSAGES ARE UNAFFECTED: for every error it raises, Commander has already written
+    // its `error: …` line before calling this, so nothing is added on top of it. The ONE outcome where
+    // it writes no error message at all is an invocation it found incomplete — a noun with no verb —
+    // where it prints help to stderr and nothing else; `spec-005` §1 requires a non-zero exit to carry
+    // an error message *always*, so that outcome (and only that one, flagged by `needsErrorLine`) gets
+    // the line composed here by `incompleteInvocationReason`
+    // (task-103-a-missing-verb-exits-2-with-an-error-line, `bug-103`).
+    //
+    // ORDER MATTERS: `.command()` copies the parent's `_exitCallback` into each subcommand at
+    // *registration* time (`Command#copyInheritedSettings`, commander@15.0.0), so this must be installed
+    // before the first `.command()` call below or a subcommand's parse errors would still bypass it.
+    // The same fact is why the callback reads `program.args` rather than the erroring command: the
+    // *root* program is the one object every copy of this closure shares, and Commander has already put
+    // the invocation's operands there (`Command#_parseCommand`'s `this.args = operands.concat(unknown)`,
+    // set before it dispatches) with the global options removed.
+    program.exitOverride((error) => {
+        const termination = (0, exit_code_1.classifyParseOutcome)(error);
+        if (termination.needsErrorLine)
+            (0, error_1.emitError)(incompleteInvocationReason(program.args), { format: 'console' });
+        (0, exit_1.exitWith)(termination.exitCode);
+    });
+    // Register `-V, --version` so `wingfoil --version` prints the version and exits 0
+    // (spec-008-cli-grammar §1, bug-001-cli-version-flag) — Commander handles it before any command.
+    program.version(readPackageVersion());
+    program
+        .option('--format <format>', 'output format (console|json|yaml)', 'console')
+        .option('--verbose', 'emit diagnostic logs to stderr')
+        .option('--no-color', 'disable ANSI colors')
+        .option('--no-interactive', 'fail on missing args instead of prompting');
+    // `wingfoil init` is a SPECIAL bootstrap command (task-029, P5.1.1): it runs BEFORE config exists,
+    // so it is NOT a `CORE_MODULES` noun-verb op — it is wired directly here and drives `runInit`
+    // (./init-command.ts). The wizard/`--template`/prompt-matrix logic is fully unit-tested in
+    // ./init-command.ts; this registration is the same thin, un-unit-tested `commander` seam as the
+    // rest of this file (see the module doc).
+    program
+        .command('init')
+        .description('initialize WingFoil in the current git repository')
+        .option('--template <name>', 'methodology template to initialize with (non-interactive)')
+        .action(async (localOpts) => {
+        const globalOpts = program.opts();
+        let root;
+        try {
+            root = options.resolveRoot();
+        }
+        catch (error) {
+            (0, error_1.emitError)(error instanceof Error ? error.message : String(error), { format: 'console' });
+            (0, exit_1.exitWith)(1);
+            return;
+        }
+        await (0, init_command_1.runInit)({ template: localOpts.template, interactive: globalOpts.interactive, format: globalOpts.format }, { root, isTTY: Boolean(process.stdout.isTTY), prompt: (0, init_command_1.createReadlinePrompt)() });
+    });
+    // `wingfoil mcp` is a SPECIAL command (task-030, P5.2.1, spec-014-mcp-server-entry-point §1): it
+    // starts the long-running production MCP server over stdio rather than wrapping a `CORE_MODULES`
+    // noun-verb op, so — like `init` above — it is wired directly here and drives `runMcp`
+    // (./mcp-command.ts). The pre-flight (resolve-root / error / exit 1) is unit-tested in
+    // ./mcp-command.ts with an injected server-start; this registration is the same thin, un-unit-tested
+    // `commander` seam as the rest of this file (see the module doc).
+    program
+        .command('mcp')
+        .description('start the WingFoil MCP server (read-only Resources and role Prompts) over stdio')
+        .action(async () => {
+        const globalOpts = program.opts();
+        const format = (0, output_1.isValidFormat)(globalOpts.format) ? globalOpts.format : 'console';
+        await (0, mcp_command_1.runMcp)({ resolveRoot: options.resolveRoot, version: readPackageVersion(), format });
+    });
+    const nounCommands = new Map();
+    for (const command of (0, registrar_1.buildCliCommands)(modules, options)) {
+        const target = resolveCommandTarget(program, nounCommands, command);
+        // A variadic optional bare positional list (task-025-implement-dna-set's `positionals` seam,
+        // generalizing task-026's single `[positional]`) — registered on every command regardless of how
+        // many positionals its operation reads (harmless if ignored), so `dna show [section]`,
+        // `paths [category]`, `memory approve [id]` and `dna set|add|remove|update <path>` share ONE
+        // positional mechanism. Every one of them now reads at most ONE positional: `dl-082-cli-parameter-shape`
+        // states the rule the nine older commands already followed — a positional carries the identity of
+        // the command's target, an option a named attribute — and task-093 moved `dna set`'s second
+        // positional into `--value` to match. The list stays variadic so an operation can refuse an extra
+        // positional with its own message rather than have Commander refuse it with an arity error.
+        // Plus this command's own `--{flag}` options (task-028-implement-paths-category's
+        // `CoreOperation.flags`, e.g. `paths`'s `--list`): Commander rejects an unknown option, so each
+        // declared flag must be registered explicitly.
+        target.argument('[positionals...]', 'optional positional arguments (the command target — e.g. a section/category name, a document id, or a `dna` field path)');
+        for (const name of command.flags ?? []) {
+            target.option(`--${name}`, `${name} flag`);
+        }
+        // Value-bearing `--{name} <value>` options (task-020-implement-memory-add's `memory add
+        // --type/--title/--tags`): Commander rejects an unknown option, so each declared option must be
+        // registered explicitly with a `<value>` operand (distinguishing it from a boolean `--flag`).
+        for (const option of command.options ?? []) {
+            target.option(`--${option.name} <value>`, option.description ?? `${option.name} value`);
+        }
+        // Commander's action callback for a `[positionals...]` variadic + options command is
+        // `(positionalsArray, optionsObject, commandObject)`. Forward the whole array (task-025),
+        // collapse this command's declared flags into a `{ name: boolean }` record (task-028) and its
+        // declared value options into a `{ name: value }` record (task-020) for `run`.
+        target.action(async (positionals = [], options = {}) => {
+            const globalOpts = program.opts();
+            await command.run(globalOpts.format, positionals, buildFlagValues(command, options), buildOptionValues(command, options));
+        });
+    }
+    return program;
+}
+/**
+ * The `error: <reason>` text (spec-005 §3.1) for an invocation Commander found incomplete —
+ * task-103-a-missing-verb-exits-2-with-an-error-line (`bug-103`). Commander supplies no message on
+ * this path, so the wording is a **ruling**, recorded here rather than left to the reader:
+ *
+ * - `wingfoil dna`, `wingfoil memory`, and `wingfoil` with no arguments at all →
+ *   `missing required argument: wingfoil dna <command>` / `missing required argument: wingfoil
+ *   <command>`. The key is the one `spec-005` §1 already lists among its malformed invocations, and
+ *   the shape is the one WingFoil already emits for a missing positional (`src/core/index.ts`'s
+ *   `missing required argument: wingfoil dna set <path> --value <value>`, task-093): the incomplete
+ *   invocation echoed back with the token that would complete it. `<command>` rather than `<verb>`
+ *   matches Commander's own placeholder in the usage line printed directly above it.
+ * - `wingfoil help nosuchnoun` → `unknown command 'nosuchnoun'`, byte-for-byte what `wingfoil
+ *   nosuchnoun` already emits (Commander's `unknownCommand()`), because asking about an unknown noun
+ *   through `help` is the same mistake and a script should have one shape to grep. The single quotes
+ *   are Commander's; `spec-005` §4's example shows double ones, and reconciling the two spellings
+ *   (along with the missing `hint:` suggestion) is `bug-104`'s, which owns both lines at once. Picking
+ *   a third spelling here would make that reconciliation harder, not easier.
+ *
+ * @param operands - the root program's `args`: the invocation's operands, global options already
+ *   removed by Commander itself. This function never re-parses argv.
+ */
+function incompleteInvocationReason(operands) {
+    const [first, second] = operands;
+    // `help <name>` reaches the incomplete-invocation path only when `<name>` matched no command —
+    // `Command#_dispatchHelpCommand` falls through to `_dispatchSubcommand`, whose `if (!subCommand)`
+    // raises it. `help` alone and `help <known-noun>` exit 0 and never arrive here.
+    if (first === 'help' && second !== undefined)
+        return `unknown command '${second}'`;
+    return `missing required argument: ${['wingfoil', ...operands].join(' ')} <command>`;
+}
+/**
+ * The Commander `Command` a `CliCommand` registers itself on: a flat, no-verb command
+ * (`command.verb === ''` — `deriveVerb`'s self-named-operation case, spec-008-cli-grammar §1's
+ * `wingfoil <noun> [args] [flags]` form, e.g. `wingfoil paths [category]` —
+ * task-028-implement-paths-category) registers directly on the noun `Command` itself; every other
+ * (`<noun> <verb>`) command keeps nesting under it exactly as before task-028.
+ */
+function resolveCommandTarget(program, nounCommands, command) {
+    if (!command.verb)
+        return program.command(command.noun);
+    let nounCommand = nounCommands.get(command.noun);
+    if (!nounCommand) {
+        nounCommand = program.command(command.noun);
+        nounCommands.set(command.noun, nounCommand);
+    }
+    return nounCommand.command(command.verb);
+}
+/**
+ * Collapse this command's declared `CoreOperation.flags` names (`./registrar.ts`'s `CliCommand.flags`)
+ * into a `{ name: boolean }` record read from Commander's parsed options object, so `command.run`
+ * (Commander-independent) never has to know Commander's option-object shape. Returns `undefined` when
+ * the command declares no flags (every command before task-028-implement-paths-category), matching
+ * `CliCommand.run`'s already-optional `flags` parameter.
+ */
+function buildFlagValues(command, options) {
+    const flagNames = command.flags ?? [];
+    if (flagNames.length === 0)
+        return undefined;
+    const flagValues = {};
+    for (const name of flagNames) {
+        flagValues[name] = Boolean(options[name]);
+    }
+    return flagValues;
+}
+/**
+ * Collapse this command's declared `CoreOperation.options` (`./registrar.ts`'s `CliCommand.options`)
+ * into a `{ name: value }` record read from Commander's parsed options object (task-020), so
+ * `command.run` never has to know Commander's option-object shape. An option the invocation omitted is
+ * simply absent from the record (not present-as-`undefined`), so a core op can distinguish "not given"
+ * from an empty string. Returns `undefined` when the command declares no value options (every command
+ * before task-020-implement-memory-add), matching `CliCommand.run`'s already-optional `options` param.
+ */
+function buildOptionValues(command, options) {
+    const declared = command.options ?? [];
+    if (declared.length === 0)
+        return undefined;
+    const optionValues = {};
+    for (const { name } of declared) {
+        const value = options[commanderKey(name)];
+        if (typeof value === 'string')
+            optionValues[name] = value;
+    }
+    return optionValues;
+}
+/**
+ * The property Commander stores a `--{name} <value>` option under: it camel-cases across `-`
+ * (`--entry-executes_as` -> `entryExecutes_as`) and leaves every other character alone.
+ *
+ * `CoreOption.name` is the declared name, and `CliCommand.run` hands core its options keyed by THAT,
+ * so this is the one place the two spellings meet. Before task-093 the lookup used the declared name
+ * directly, which worked only because every option declared so far happened to be a single word: a
+ * dashed name would have been read as `undefined` and dropped in silence — the same failure mode as
+ * the shadowing this task fixes, one layer further in. `test/cli/derived-option-namespace.test.ts`
+ * drives every dashed option the registry declares through the real CLI, so neither can return
+ * unnoticed.
+ */
+function commanderKey(name) {
+    return name.replace(/-([a-zA-Z0-9])/g, (_match, char) => char.toUpperCase());
+}
+//# sourceMappingURL=program.js.map

package/dist/cli/program.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"program.js","sourceRoot":"","sources":["../../src/cli/program.ts"],"names":[],"mappings":"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"}

package/dist/cli/registrar.d.ts

@@ -0,0 +1,69 @@
+/**
+ * The CLI adapter's command registrar (spec-006-core-domain-api §2/§4, spec-005-cli-command-contract,
+ * spec-008-cli-grammar — task-006). `buildCliCommands` is the "command registrar" spec-006 §4.1
+ * refers to: it imports nothing but the `CoreModule[]` it is given, iterates `enumerateOperations`
+ * (never a hand-copied operation list), and derives **every** operation it finds into a
+ * `wingfoil <noun> <verb>` command descriptor — regardless of `mutates` (§2: "CLI exposes every
+ * operation regardless of `mutates`"). No business logic lives outside `run`: it only (a)
+ * validates the global `--format` flag, (b) turns the invocation into typed params via the
+ * caller-supplied `buildParams`, (c) calls the one core function, (d) renders the resulting
+ * `CoreResult` via `renderSuccess`/`emitError` and terminates via `exitWith` — matching spec-005
+ * §1's "exactly one process exit call per invocation".
+ *
+ * Deliberately Commander-independent (see `./program.ts`'s module doc for why): this module owns
+ * 100% of the AC-relevant behavior — naming, dispatch, exit codes, output rendering — and is fully
+ * unit-testable; wiring this command model onto a real `commander` `Command` tree is a separate,
+ * thin, mechanical concern.
+ */
+import type { CoreModule, CoreOption, ParamsBuilder } from '../core/registry';
+/** Ambient dependencies {@link buildCliCommands} needs: how to resolve the project root and how to shape each operation's params. */
+export interface BuildCommandsOptions {
+    /** Resolves the project root a core call needs — an ambient/environment concern, not a CLI flag. */
+    readonly resolveRoot: () => string;
+    /** Turns a `ParamsContext` into one operation's typed params (`../core/registry.ts`'s {@link ParamsBuilder}). */
+    readonly buildParams: ParamsBuilder;
+}
+/**
+ * One derived `wingfoil <noun> <verb>` command (or, when `verb === ''`, a flat `wingfoil <noun>`
+ * command — spec-008-cli-grammar §1, task-028-implement-paths-category): its dispatch is a pure
+ * function of the ambient `--format` value plus this operation's own positional/flag values, if any.
+ */
+export interface CliCommand {
+    readonly noun: string;
+    readonly verb: string;
+    readonly mutates: boolean;
+    /** Copied from `CoreOperation.flags` (`../core/registry.ts`) — the boolean flag names `program.ts`
+     * registers as Commander `--{name}` options for this command (empty/absent for every command
+     * before task-028-implement-paths-category; `['list']` for `paths`). */
+    readonly flags?: readonly string[];
+    /** Copied from `CoreOperation.options` (`../core/registry.ts`) — the value-bearing `--{name} <value>`
+     * options `program.ts` registers for this command (task-020-implement-memory-add; empty/absent for
+     * every command before it). */
+    readonly options?: readonly CoreOption[];
+    /**
+     * Execute this command given the resolved `--format` flag value (still unvalidated at this point),
+     * the FULL list of bare positional arguments the invocation supplied (task-025-implement-dna-set's
+     * additive `positionals` seam — e.g. `wingfoil dna show tech_stack` -> `['tech_stack']`,
+     * `wingfoil dna set project.license --value MIT` -> `['project.license']`, one positional per
+     * command since `dl-082-cli-parameter-shape`), this command's own parsed `--{flag}`
+     * values (task-028, e.g. `{ list: true }`), and its parsed value-bearing `--{name} <value>` OPTIONS
+     * (task-020, e.g. `{ type: 'decision', title: 'Use PostgreSQL' }`). All are additive/optional — a
+     * command that reads no positional and declares no flags/options is still called exactly as before:
+     * `run(format)`. The single-positional read ops (`dna show`, `paths`) read `positionals[0]` via
+     * `ParamsContext.positional`.
+     */
+    readonly run: (formatValue: string, positionals?: readonly string[], flags?: Readonly<Record<string, boolean>>, options?: Readonly<Record<string, string>>) => Promise<void>;
+}
+/**
+ * Derive one `CliCommand` per operation in `modules`, in `enumerateOperations`'s deterministic
+ * order (REQ-SYS-07). The verb is derived via `deriveVerb` (spec-006 §5).
+ */
+export declare function buildCliCommands(modules: readonly CoreModule[], options: BuildCommandsOptions): CliCommand[];
+/**
+ * Every `"{noun} {verb}"` command derived from `commands`, sorted (REQ-SYS-07) — the CLI-side
+ * enumeration the REQ-SYS-05 parity test (`test/core/parity.test.ts`) diffs against the MCP Tool
+ * list. A flat, no-verb command (`verb === ''`, task-028-implement-paths-category) renders as the
+ * bare noun (`"paths"`), not `"paths "` with a trailing space.
+ */
+export declare function listRegisteredCliCommands(commands: readonly CliCommand[]): string[];
+//# sourceMappingURL=registrar.d.ts.map

package/dist/cli/registrar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registrar.d.ts","sourceRoot":"","sources":["../../src/cli/registrar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAS9E,qIAAqI;AACrI,MAAM,WAAW,oBAAoB;IACnC,oGAAoG;IACpG,QAAQ,CAAC,WAAW,EAAE,MAAM,MAAM,CAAC;IACnC,iHAAiH;IACjH,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC;CACrC;AAED;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B;;4EAEwE;IACxE,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC;;mCAE+B;IAC/B,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;IACzC;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,GAAG,EAAE,CACZ,WAAW,EAAE,MAAM,EACnB,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,EAC/B,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACzC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,KACvC,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,EAAE,OAAO,EAAE,oBAAoB,GAAG,UAAU,EAAE,CA+D5G;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,GAAG,MAAM,EAAE,CAEnF"}