opensip-cli 0.1.0

package/dist/bootstrap/index.js

@@ -0,0 +1,109 @@
+// @fitness-ignore-file detached-promises -- bootstrap calls the synchronous registerLanguageAdapters and awaits the async tool registration helpers (registerFirstPartyTools, discoverAndRegisterToolPackages) that the heuristic flags
+/**
+ * bootstrap — performs the one-time (per-process) STARTUP phase registrations
+ * (language adapters + tool admission via the uniform dynamic path) and
+ * returns the populated registries + provenance/manifests to the composition
+ * root.
+ *
+ * The full 10-step canonical lifecycle (including the PER-RUN steps that
+ * happen later in the preAction hook) is documented in `tool-lifecycle.ts`.
+ * This module owns steps 1-4 (discover/compat/trust/import for bundled +
+ * installed + authored) plus the mount seam re-export.
+ *
+ * See tool-lifecycle.ts for the ordered steps and phase split.
+ */
+import { resolveProjectContext, resolveProjectPaths, resolveUserPaths, } from '@opensip-cli/core';
+import { hostEnv } from '../env/host-env-specs.js';
+import { initTelemetry } from '../telemetry/sdk-init.js';
+import { registerLanguageAdapters } from './register-language-adapters.js';
+import { BUNDLED_TOOL_PACKAGES, registerFirstPartyTools, discoverAndRegisterToolPackages, discoverAndRegisterAuthoredTools, buildToolDiscoverySources, } from './register-tools.js';
+// Re-export only the symbols the CLI composition root (`index.ts`) consumes.
+// `mountToolCommands` is the named step-8 seam of the tool lifecycle (release
+// launch, §5.4); it delegates to `mountAllToolCommands` (kept exported for the
+// existing direct unit tests).
+export { mountAllToolCommands, EXPECTED_SCAFFOLDING_TOOL_IDS } from './register-tools.js';
+// The shared admission callable (ADR-0041: one validator, four consumers) —
+// consumed by the tools command group (validate/install) and the
+// admission-parity / bundled-conformance tests.
+export { admitToolPackage, importToolRuntime, } from './admit-tool-package.js';
+export { mountToolCommands } from './tool-lifecycle.js';
+export { renderResult } from './render.js';
+export { maybeOpenReport } from './report.js';
+export { installPreActionHook } from './pre-action-hook.js';
+export { buildCommandRegistrationInput } from './build-command-registration-input.js';
+export { buildHostPlanes } from './host-planes.js';
+/**
+ * One-shot bootstrap: register language adapters, register the first-
+ * party tools, and discover-and-register every third-party tool +
+ * @opensip-cli/graph-* adapter pack. Datastore is NOT opened here —
+ * it's a lazy getter on ToolCliContext (cli-context.ts), so dry-runs
+ * and error paths that never read `cli.datastore` don't materialise
+ * `.runtime/datastore.sqlite`.
+ *
+ * Graph adapter discovery runs BEFORE `mountAllToolCommands`: the
+ * graph tool's `register()` method assumes adapters are already
+ * available so its lang-adapter registry isn't empty when the first
+ * `pickAdapter()` lands during a real run. PR 1a of plan
+ * docs/plans/architecture/2026-05-23-plan-graph-adapter-package-split.md.
+ */
+export async function bootstrapCli(opts) {
+    // Telemetry first — before any tool runs — so provider registration happens
+    // once per process ahead of the first stage span. Hard no-op unless the OTLP
+    // endpoint env var is set (see telemetry/sdk-init.ts), so standalone startup
+    // is byte-for-byte unaffected.
+    initTelemetry(opts.cliEntryUrl);
+    registerLanguageAdapters(opts.langRegistry);
+    // Launch: bundled + installed tools both flow through the shared
+    // `admitTool` gate (register-tools.ts) and contribute a `ToolProvenance`
+    // record into this collector. It's a plain array threaded by value — no
+    // module singleton — handed back to the composition root so Phase 4's
+    // `plugin list` can surface source / identity / manifestHash.
+    const provenance = [];
+    // §5.3 (launch): collect the admitted tools' manifests alongside provenance
+    // so the composition root can seed the per-run capability registry with each
+    // manifest's declared domains.
+    const manifests = [];
+    // Launch: bundled tools load through the same dynamic-import path as installed
+    // tools, so registration is async — awaited before discovery so the bundled
+    // manifests are loaded before we derive the built-in skip-set from them.
+    // A bundled tool listed in OPENSIP_CLI_SKIP_BUNDLED is NOT loaded as bundled,
+    // so an installed/project-local copy of the same id can take over — the
+    // install-source-independence escape hatch (the bundled tool is one provenance,
+    // not a privilege).
+    // `.get` returns the spec's `default: []` when unset, so the list is always an
+    // array (never undefined).
+    const skipBundled = new Set(hostEnv.get('OPENSIP_CLI_SKIP_BUNDLED'));
+    const bundledPackages = BUNDLED_TOOL_PACKAGES.filter((pkg) => !skipBundled.has(pkg.replace('@opensip-cli/', '')));
+    await registerFirstPartyTools(opts.toolRegistry, provenance, manifests, bundledPackages);
+    // The bundled-tool ids discovery must skip on a name collision, derived from
+    // the manifests just loaded (not from an imported tool runtime — the host
+    // holds none in the launch contract).
+    const builtInIds = new Set(manifests.map((m) => m.id));
+    await discoverAndRegisterToolPackages(opts.toolRegistry, { sources: buildToolDiscoverySources(opts.cwd, opts.projectDir) }, builtInIds, provenance, manifests);
+    // Authored Tool sidecars (ADR-0027 realization): global trusted-by-default +
+    // project deny-by-default. Resolve the two authored roots — the global root
+    // is always present; the project root is best-effort (an unresolvable
+    // context contributes no project authored leg, mirroring
+    // buildToolDiscoverySources). `builtInIds` stays the BUNDLED set (matching
+    // the installed leg's contract); the registry's first-writer-wins dedupes an
+    // authored-vs-installed same-id collision with a structured warning.
+    const globalAuthoredDir = resolveUserPaths().authoredToolsDir;
+    let projectAuthoredDir;
+    try {
+        const project = resolveProjectContext({ cwd: opts.cwd, cwdExplicit: false });
+        if (project.scope === 'project') {
+            projectAuthoredDir = resolveProjectPaths(project.projectRoot).authoredToolsDir;
+        }
+    }
+    catch {
+        // @swallow-ok no resolvable project context → no project authored leg
+        // (best-effort, same contract as buildToolDiscoverySources).
+    }
+    await discoverAndRegisterAuthoredTools(opts.toolRegistry, { projectAuthoredDir, globalAuthoredDir, env: process.env }, builtInIds, provenance, manifests);
+    // Graph adapters (and every other tool's capability domains) are no longer
+    // discovered here. The pre-action hook drives the generic capability loader
+    // per command for the invoked tool's declared domains (§5.3/§4.5) — no
+    // host-coupled, eager, per-tool discovery at bootstrap.
+    return { provenance, manifests };
+}
+//# sourceMappingURL=index.js.map

package/dist/bootstrap/index.js.map

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

package/dist/bootstrap/live-plane.d.ts

@@ -0,0 +1,51 @@
+/**
+ * live-plane — the host's interactive live-view plane
+ * (host-owned-run-timing Phase 6 §6.1).
+ *
+ * Two pieces:
+ *  1. {@link createLiveViewRegistry} — the pure key→renderer registry backing
+ *     `cli.registerLiveView`. First-writer-wins on duplicate keys; an
+ *     unregistered key throws {@link UnknownLiveViewError} rather than masking a
+ *     mistyped key with a static render. The host builds ONE registry per
+ *     invocation (in `main()`) and hands it to the context assembler.
+ *  2. {@link createLivePlane} — binds that registry to the run plane so the
+ *     `cli.renderLive` seam owns the live run lifecycle (Phase 2): it times the
+ *     TTY occupancy and persists the renderer's returned `session` contribution
+ *     after `await render()`. The renderer no longer writes the session itself.
+ *
+ * The host ALWAYS supplies the {@link LiveViewContext} (carrying the run seam +
+ * timer) as the renderer's second argument, so tools that call `renderLive`
+ * directly (fit/sim/graph `runLiveMode`) get it without threading it themselves;
+ * a renderer that declares only one parameter simply ignores the extra arg.
+ */
+import { type LiveViewContext, type LiveViewRenderer, type Logger, type ToolRunCompletion, type ToolRunSessions } from '@opensip-cli/core';
+import type { RunPlaneFactory } from './run-plane.js';
+export interface LiveViewRegistry {
+    readonly register: (key: string, renderer: LiveViewRenderer) => void;
+    /**
+     * Render the live view. The optional third parameter is the LiveViewContext
+     * (carrying runSession) to forward as the *second* argument to the renderer
+     * function itself. This lets the host dispatch site (mount) supply the
+     * shared run timer without changing the public ToolCliContext.renderLive
+     * (tools still call renderLive(key, args)).
+     */
+    readonly render: (key: string, args: unknown, liveContext?: LiveViewContext) => Promise<ToolRunCompletion | void>;
+    readonly has: (key: string) => boolean;
+}
+export declare function createLiveViewRegistry(log?: Logger): LiveViewRegistry;
+/** Stable dependencies the live plane binds together. */
+export interface LivePlaneDeps {
+    /** The per-invocation registry built in `main()` and passed to the assembler. */
+    readonly liveViews: LiveViewRegistry;
+    /** The run plane — `renderLive` runs the render through its `completeLiveRender`. */
+    readonly runPlane: RunPlaneFactory;
+    /** The host run seam, used to build the default {@link LiveViewContext}. */
+    readonly runSession: ToolRunSessions;
+}
+/** The live plane's public surface (the two `ToolCliContext` live-view seams). */
+export interface LivePlane {
+    readonly register: LiveViewRegistry['register'];
+    readonly renderLive: (key: string, args: unknown, liveContext?: LiveViewContext) => Promise<ToolRunCompletion | void>;
+}
+export declare function createLivePlane(deps: LivePlaneDeps): LivePlane;
+//# sourceMappingURL=live-plane.d.ts.map

package/dist/bootstrap/live-plane.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-plane.d.ts","sourceRoot":"","sources":["../../src/bootstrap/live-plane.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,MAAM,EACX,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACrB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEtD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrE;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,CACf,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,OAAO,EACb,WAAW,CAAC,EAAE,eAAe,KAC1B,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;IACvC,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;CACxC;AAED,wBAAgB,sBAAsB,CAAC,GAAG,GAAE,MAAsB,GAAG,gBAAgB,CAmCpF;AAED,yDAAyD;AACzD,MAAM,WAAW,aAAa;IAC5B,iFAAiF;IACjF,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAC;IACrC,qFAAqF;IACrF,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC,4EAA4E;IAC5E,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC;CACtC;AAED,kFAAkF;AAClF,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAC;IAChD,QAAQ,CAAC,UAAU,EAAE,CACnB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,OAAO,EACb,WAAW,CAAC,EAAE,eAAe,KAC1B,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;CACxC;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,CAgB9D"}

package/dist/bootstrap/live-plane.js

@@ -0,0 +1,72 @@
+/**
+ * live-plane — the host's interactive live-view plane
+ * (host-owned-run-timing Phase 6 §6.1).
+ *
+ * Two pieces:
+ *  1. {@link createLiveViewRegistry} — the pure key→renderer registry backing
+ *     `cli.registerLiveView`. First-writer-wins on duplicate keys; an
+ *     unregistered key throws {@link UnknownLiveViewError} rather than masking a
+ *     mistyped key with a static render. The host builds ONE registry per
+ *     invocation (in `main()`) and hands it to the context assembler.
+ *  2. {@link createLivePlane} — binds that registry to the run plane so the
+ *     `cli.renderLive` seam owns the live run lifecycle (Phase 2): it times the
+ *     TTY occupancy and persists the renderer's returned `session` contribution
+ *     after `await render()`. The renderer no longer writes the session itself.
+ *
+ * The host ALWAYS supplies the {@link LiveViewContext} (carrying the run seam +
+ * timer) as the renderer's second argument, so tools that call `renderLive`
+ * directly (fit/sim/graph `runLiveMode`) get it without threading it themselves;
+ * a renderer that declares only one parameter simply ignores the extra arg.
+ */
+import { UnknownLiveViewError, logger as defaultLogger, } from '@opensip-cli/core';
+export function createLiveViewRegistry(log = defaultLogger) {
+    const renderers = new Map();
+    return {
+        register(key, renderer) {
+            if (renderers.has(key)) {
+                log.warn({
+                    evt: 'cli.live_view.duplicate',
+                    module: 'cli:bootstrap',
+                    key,
+                    msg: `Duplicate live-view registration for key '${key}' — first registration wins.`,
+                });
+                return;
+            }
+            renderers.set(key, renderer);
+        },
+        /**
+         * @throws {UnknownLiveViewError} When `key` has no registered live-view renderer.
+         */
+        async render(key, args, liveContext) {
+            const renderer = renderers.get(key);
+            if (!renderer) {
+                // async so the throw surfaces as a rejected promise (the contract
+                // callers `await` / assert `.rejects` against).
+                throw new UnknownLiveViewError(key);
+            }
+            // Always pass the host-supplied LiveViewContext (host-owned-run-timing
+            // Phase 2): live tool commands receive it; JS safely ignores the extra arg
+            // for any renderer that declares only one parameter. Return the renderer's
+            // ToolRunCompletion so the host can complete the lifecycle + persist.
+            return renderer(args, liveContext);
+        },
+        has(key) {
+            return renderers.has(key);
+        },
+    };
+}
+export function createLivePlane(deps) {
+    return {
+        register: deps.liveViews.register,
+        // Host owns the live run lifecycle (host-owned-run-timing Phase 2): time
+        // the TTY occupancy, then complete the lifecycle + persist the renderer's
+        // returned `session` contribution. The host always supplies the
+        // LiveViewContext (carrying the run seam + timer) so tools that call
+        // renderLive directly (fit/sim/graph runLiveMode) get it without passing
+        // it themselves. The renderer no longer writes the session itself.
+        renderLive: (key, args, liveContext) => deps.runPlane
+            .current()
+            .completeLiveRender(() => deps.liveViews.render(key, args, liveContext ?? { runSession: deps.runSession })),
+    };
+}
+//# sourceMappingURL=live-plane.js.map

package/dist/bootstrap/live-plane.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-plane.js","sourceRoot":"","sources":["../../src/bootstrap/live-plane.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EACL,oBAAoB,EACpB,MAAM,IAAI,aAAa,GAMxB,MAAM,mBAAmB,CAAC;AAqB3B,MAAM,UAAU,sBAAsB,CAAC,MAAc,aAAa;IAChE,MAAM,SAAS,GAAG,IAAI,GAAG,EAA4B,CAAC;IACtD,OAAO;QACL,QAAQ,CAAC,GAAG,EAAE,QAAQ;YACpB,IAAI,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;gBACvB,GAAG,CAAC,IAAI,CAAC;oBACP,GAAG,EAAE,yBAAyB;oBAC9B,MAAM,EAAE,eAAe;oBACvB,GAAG;oBACH,GAAG,EAAE,6CAA6C,GAAG,8BAA8B;iBACpF,CAAC,CAAC;gBACH,OAAO;YACT,CAAC;YACD,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QAC/B,CAAC;QACD;;WAEG;QACH,KAAK,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,EAAE,WAAW;YACjC,MAAM,QAAQ,GAAG,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACpC,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,kEAAkE;gBAClE,gDAAgD;gBAChD,MAAM,IAAI,oBAAoB,CAAC,GAAG,CAAC,CAAC;YACtC,CAAC;YACD,uEAAuE;YACvE,2EAA2E;YAC3E,2EAA2E;YAC3E,sEAAsE;YACtE,OAAO,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;QACrC,CAAC;QACD,GAAG,CAAC,GAAG;YACL,OAAO,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC5B,CAAC;KACF,CAAC;AACJ,CAAC;AAsBD,MAAM,UAAU,eAAe,CAAC,IAAmB;IACjD,OAAO;QACL,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ;QACjC,yEAAyE;QACzE,0EAA0E;QAC1E,gEAAgE;QAChE,qEAAqE;QACrE,yEAAyE;QACzE,mEAAmE;QACnE,UAAU,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,WAAW,EAAE,EAAE,CACrC,IAAI,CAAC,QAAQ;aACV,OAAO,EAAE;aACT,kBAAkB,CAAC,GAAG,EAAE,CACvB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,EAAE,WAAW,IAAI,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,CAAC,CACjF;KACN,CAAC;AACJ,CAAC"}

package/dist/bootstrap/load-tool-capabilities.d.ts

@@ -0,0 +1,42 @@
+/**
+ * load-tool-capabilities — the composition-root seam that drives the generic
+ * capability loader (§5.3, §4.5) for the invoked tool's declared domains.
+ *
+ * Replaces the host-coupled, eager `register-graph-adapters.ts` (which statically
+ * imported graph's discover functions + stashed adapters in a module global).
+ * Here the host stays tool-agnostic: for the tool that owns the running command,
+ * it reads each declared capability domain's discovery descriptor off the
+ * per-run capability registry, resolves that domain's preferences from the
+ * project config through the keys the descriptor declares, and calls the generic
+ * `loadCapabilityDomain` — which walks node_modules, imports each contributing
+ * package, and routes every contribution through the owner's registrar. No tool
+ * import; no module singleton; lazy per command (only the invoked tool's domains
+ * load, so `graph` does not load fit-packs).
+ *
+ * This module is one of the few places the CLI imports `@opensip-cli/config`
+ * (the preference resolver) — tools never do.
+ */
+import { type Tool } from '@opensip-cli/core';
+/** Options for {@link loadOwningToolCapabilities}. */
+export interface LoadOwningToolCapabilitiesOptions {
+    /** The tool that owns the invoked command (from `resolveOwningTool`); `undefined` for CLI-only commands. */
+    readonly owningTool: Tool | undefined;
+    /** Discovery anchor for consumer-owned packages (the project root). */
+    readonly projectDir: string;
+    /** The resolved project config path (for the `plugins` preference block), or `undefined`. */
+    readonly configPath: string | undefined;
+    /** Discovery anchor for built-in packs (those under a descriptor's `builtinScope`). */
+    readonly cliDir?: string;
+}
+/**
+ * Discover + route every contribution for each capability domain the invoked
+ * tool declares, through the generic loader. Must run AFTER the scope is entered
+ * (the registrars register into the scope's registries) and the per-run
+ * capability registry is attached. A CLI-only command (no owning tool) loads
+ * nothing.
+ *
+ * Returns the number of domains driven (0 when the tool declares none / is
+ * CLI-only), for diagnostics.
+ */
+export declare function loadOwningToolCapabilities(options: LoadOwningToolCapabilitiesOptions): Promise<number>;
+//# sourceMappingURL=load-tool-capabilities.d.ts.map

package/dist/bootstrap/load-tool-capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-tool-capabilities.d.ts","sourceRoot":"","sources":["../../src/bootstrap/load-tool-capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAMH,OAAO,EAIL,KAAK,IAAI,EACV,MAAM,mBAAmB,CAAC;AAqB3B,sDAAsD;AACtD,MAAM,WAAW,iCAAiC;IAChD,4GAA4G;IAC5G,QAAQ,CAAC,UAAU,EAAE,IAAI,GAAG,SAAS,CAAC;IACtC,uEAAuE;IACvE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,6FAA6F;IAC7F,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC,uFAAuF;IACvF,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;GASG;AACH,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,iCAAiC,GACzC,OAAO,CAAC,MAAM,CAAC,CAwBjB"}

package/dist/bootstrap/load-tool-capabilities.js

@@ -0,0 +1,76 @@
+/**
+ * load-tool-capabilities — the composition-root seam that drives the generic
+ * capability loader (§5.3, §4.5) for the invoked tool's declared domains.
+ *
+ * Replaces the host-coupled, eager `register-graph-adapters.ts` (which statically
+ * imported graph's discover functions + stashed adapters in a module global).
+ * Here the host stays tool-agnostic: for the tool that owns the running command,
+ * it reads each declared capability domain's discovery descriptor off the
+ * per-run capability registry, resolves that domain's preferences from the
+ * project config through the keys the descriptor declares, and calls the generic
+ * `loadCapabilityDomain` — which walks node_modules, imports each contributing
+ * package, and routes every contribution through the owner's registrar. No tool
+ * import; no module singleton; lazy per command (only the invoked tool's domains
+ * load, so `graph` does not load fit-packs).
+ *
+ * This module is one of the few places the CLI imports `@opensip-cli/config`
+ * (the preference resolver) — tools never do.
+ */
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { resolveCapabilityPreferences } from '@opensip-cli/config';
+import { currentCapabilityRegistry, loadCapabilityDomain, readYamlFile, } from '@opensip-cli/core';
+/**
+ * Resolve the directory the CLI was installed into. BUILT-IN capability packs
+ * (the bundled `@opensip-cli/*` check packs + graph adapters, declared as CLI
+ * dependencies) always resolve from here — a project never carries them, and a
+ * globally-installed CLI runs ITS OWN bundled packs. This file lives at
+ * `cli/dist/bootstrap/`, so the package root is three directories up.
+ */
+function cliInstallDir() {
+    return dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+}
+/** Read the raw `plugins` block from a project config file (or `{}` when absent). */
+function readPluginsBlock(configPath) {
+    if (configPath === undefined)
+        return {};
+    const doc = readYamlFile(configPath);
+    if (doc === null || typeof doc !== 'object')
+        return {};
+    return doc.plugins ?? {};
+}
+/**
+ * Discover + route every contribution for each capability domain the invoked
+ * tool declares, through the generic loader. Must run AFTER the scope is entered
+ * (the registrars register into the scope's registries) and the per-run
+ * capability registry is attached. A CLI-only command (no owning tool) loads
+ * nothing.
+ *
+ * Returns the number of domains driven (0 when the tool declares none / is
+ * CLI-only), for diagnostics.
+ */
+export async function loadOwningToolCapabilities(options) {
+    const { owningTool, projectDir, configPath } = options;
+    if (!owningTool)
+        return 0;
+    // Built-in packs (those under a descriptor's `builtinScope`, e.g. the bundled
+    // @opensip-cli/graph-* adapters) resolve from the CLI's own install tree.
+    const cliDir = options.cliDir ?? cliInstallDir();
+    // The per-run capability registry is read off the current scope (the loader's
+    // registrars register into this same scope's tool registries).
+    const registry = currentCapabilityRegistry();
+    const ownedDomains = registry
+        .listDomains()
+        .filter((d) => d.ownerToolId === owningTool.metadata.id);
+    const pluginsConfig = readPluginsBlock(configPath);
+    let driven = 0;
+    for (const domain of ownedDomains) {
+        if (domain.discovery === undefined)
+            continue;
+        const preferences = resolveCapabilityPreferences(domain.discovery, pluginsConfig);
+        await loadCapabilityDomain({ registry, domainId: domain.id, projectDir, cliDir, preferences });
+        driven++;
+    }
+    return driven;
+}
+//# sourceMappingURL=load-tool-capabilities.js.map

package/dist/bootstrap/load-tool-capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-tool-capabilities.js","sourceRoot":"","sources":["../../src/bootstrap/load-tool-capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,OAAO,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,EACL,yBAAyB,EACzB,oBAAoB,EACpB,YAAY,GAEb,MAAM,mBAAmB,CAAC;AAE3B;;;;;;GAMG;AACH,SAAS,aAAa;IACpB,OAAO,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACnE,CAAC;AAED,qFAAqF;AACrF,SAAS,gBAAgB,CAAC,UAA8B;IACtD,IAAI,UAAU,KAAK,SAAS;QAAE,OAAO,EAAE,CAAC;IACxC,MAAM,GAAG,GAAG,YAAY,CAAC,UAAU,CAAC,CAAC;IACrC,IAAI,GAAG,KAAK,IAAI,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,EAAE,CAAC;IACvD,OAAQ,GAA+B,CAAC,OAAO,IAAI,EAAE,CAAC;AACxD,CAAC;AAcD;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,0BAA0B,CAC9C,OAA0C;IAE1C,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC;IACvD,IAAI,CAAC,UAAU;QAAE,OAAO,CAAC,CAAC;IAC1B,8EAA8E;IAC9E,0EAA0E;IAC1E,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,aAAa,EAAE,CAAC;IAEjD,8EAA8E;IAC9E,+DAA+D;IAC/D,MAAM,QAAQ,GAAG,yBAAyB,EAAE,CAAC;IAE7C,MAAM,YAAY,GAAG,QAAQ;SAC1B,WAAW,EAAE;SACb,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,KAAK,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IAC3D,MAAM,aAAa,GAAG,gBAAgB,CAAC,UAAU,CAAC,CAAC;IAEnD,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,KAAK,MAAM,MAAM,IAAI,YAAY,EAAE,CAAC;QAClC,IAAI,MAAM,CAAC,SAAS,KAAK,SAAS;YAAE,SAAS;QAC7C,MAAM,WAAW,GAAG,4BAA4B,CAAC,MAAM,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;QAClF,MAAM,oBAAoB,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC,CAAC;QAC/F,MAAM,EAAE,CAAC;IACX,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/bootstrap/output-plane.d.ts

@@ -0,0 +1,37 @@
+/**
+ * output-plane — the host's machine-output + exit-code plane
+ * (host-owned-run-timing Phase 6 §6.1).
+ *
+ * Owns:
+ *  - the single `process.exitCode` write path (`setExitCode`) and the captured
+ *    in-memory mirror (`getExitCode`), so the run's exit code has exactly one
+ *    author;
+ *  - the four `--json`-path emit seams (`emitJson`, `emitEnvelope`, `emitError`,
+ *    `emitRaw`), each wrapping the tool's pure-domain payload in a
+ *    `CommandOutcome` through the single {@link renderOutcome} serialization seam
+ *    (launch §5.5) — except `emitRaw`, which deliberately writes the unwrapped
+ *    payload via {@link renderRaw}.
+ *
+ * Extracted verbatim from `buildToolCliContext`: the behaviour (outcome
+ * builders, render-failure fallbacks, exit-code threading) is unchanged — this
+ * module just gives the concern its own home and a narrow, testable surface.
+ */
+import { type Logger, type ToolCliContext } from '@opensip-cli/core';
+import type { CommandResult } from '@opensip-cli/contracts';
+/** Stable dependencies the output plane captures. */
+export interface OutputPlaneDeps {
+    /** The human renderer (Ink/text) the emit seams pass through on the non-JSON path. */
+    readonly render: (result: CommandResult) => Promise<void>;
+    readonly logger?: Logger;
+}
+/** The output plane's public surface. */
+export interface OutputPlane {
+    /** The single `process.exitCode` write path (mirrors into the captured value). */
+    readonly setExitCode: (code: number) => void;
+    /** The captured exit code, or `undefined` if never set this run. */
+    readonly getExitCode: () => number | undefined;
+    /** The four `ToolCliContext` machine-output seams, ready to spread into the context. */
+    readonly emits: Pick<ToolCliContext, 'emitJson' | 'emitEnvelope' | 'emitError' | 'emitRaw'>;
+}
+export declare function createOutputPlane(deps: OutputPlaneDeps): OutputPlane;
+//# sourceMappingURL=output-plane.d.ts.map

package/dist/bootstrap/output-plane.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-plane.d.ts","sourceRoot":"","sources":["../../src/bootstrap/output-plane.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAA2B,KAAK,MAAM,EAAE,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAS9F,OAAO,KAAK,EAAE,aAAa,EAAkB,MAAM,wBAAwB,CAAC;AAK5E,qDAAqD;AACrD,MAAM,WAAW,eAAe;IAC9B,sFAAsF;IACtF,QAAQ,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1D,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,yCAAyC;AACzC,MAAM,WAAW,WAAW;IAC1B,kFAAkF;IAClF,QAAQ,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7C,oEAAoE;IACpE,QAAQ,CAAC,WAAW,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IAC/C,wFAAwF;IACxF,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,cAAc,EAAE,UAAU,GAAG,cAAc,GAAG,WAAW,GAAG,SAAS,CAAC,CAAC;CAC7F;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,eAAe,GAAG,WAAW,CA+FpE"}

package/dist/bootstrap/output-plane.js

@@ -0,0 +1,114 @@
+/**
+ * output-plane — the host's machine-output + exit-code plane
+ * (host-owned-run-timing Phase 6 §6.1).
+ *
+ * Owns:
+ *  - the single `process.exitCode` write path (`setExitCode`) and the captured
+ *    in-memory mirror (`getExitCode`), so the run's exit code has exactly one
+ *    author;
+ *  - the four `--json`-path emit seams (`emitJson`, `emitEnvelope`, `emitError`,
+ *    `emitRaw`), each wrapping the tool's pure-domain payload in a
+ *    `CommandOutcome` through the single {@link renderOutcome} serialization seam
+ *    (launch §5.5) — except `emitRaw`, which deliberately writes the unwrapped
+ *    payload via {@link renderRaw}.
+ *
+ * Extracted verbatim from `buildToolCliContext`: the behaviour (outcome
+ * builders, render-failure fallbacks, exit-code threading) is unchanged — this
+ * module just gives the concern its own home and a narrow, testable surface.
+ */
+import { logger as defaultLogger } from '@opensip-cli/core';
+import { outcomeFromEnvelope, outcomeFromErrorMessage, outcomeFromResult, } from '../commands/assemble-outcome.js';
+import { renderOutcome, renderRaw } from '../commands/render-outcome.js';
+/** Structured-log `module` tag for the output plane. */
+const MODULE_TAG = 'cli:output-plane';
+export function createOutputPlane(deps) {
+    const log = deps.logger ?? defaultLogger;
+    let exitCode;
+    const setExitCode = (code) => {
+        exitCode = code;
+        process.exitCode = code;
+    };
+    const emits = {
+        // launch (§5.5): every machine output the host emits is wrapped in a
+        // `CommandOutcome` through the single `renderOutcome` seam — `emitJson`
+        // (general-purpose `.data`), `emitEnvelope` (run `.envelope`), and
+        // `emitError` (`status:'error'` `.errors`). The host STAMPS the outer
+        // currency; the tool only hands over its pure-domain payload. `--json` is
+        // implicit here: these seams are only ever called on the `--json` path, so
+        // they always serialize the outcome (the `render` arg is inert).
+        //
+        // Errors during renderOutcome are attached to a catch so they are not
+        // completely swallowed by the `void` (they surface in logs and as
+        // unhandled-rejection diagnostics instead of silent loss).
+        emitJson: (value) => {
+            renderOutcome(outcomeFromResult(value, exitCode ?? 0), {
+                jsonRequested: true,
+                render: deps.render,
+            }).catch((error) => {
+                // Primary machine output path failed — do not swallow silently.
+                // Only force a non-success exit if the primary run had not already
+                // decided on a failure code (preserve specific codes like REPORT_FAILED,
+                // RUNTIME_ERROR, etc.). Render failure of the outcome is secondary.
+                if ((exitCode ?? 0) === 0) {
+                    setExitCode(1);
+                }
+                log.error({
+                    evt: 'cli.emit_json.render_failed',
+                    module: MODULE_TAG,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            });
+        },
+        emitEnvelope: (envelope) => {
+            renderOutcome(outcomeFromEnvelope(envelope, exitCode ?? 0), {
+                jsonRequested: true,
+                render: deps.render,
+            }).catch((error) => {
+                if ((exitCode ?? 0) === 0) {
+                    setExitCode(1);
+                }
+                log.error({
+                    evt: 'cli.emit_envelope.render_failed',
+                    module: MODULE_TAG,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            });
+        },
+        // Structured error machine-output (retires the bare `emitJson({ error })`
+        // shape the `one-outcome-shape` guardrail forbids). The handler hands a
+        // diagnosed failure (message + exit code, optional suggestion); the host
+        // wraps it as a `status:'error'` outcome. `exitCode` is also threaded to
+        // `setExitCode` so the process exit and the reported outcome agree.
+        emitError: (detail) => {
+            setExitCode(detail.exitCode);
+            renderOutcome(outcomeFromErrorMessage({
+                message: detail.message,
+                exitCode: detail.exitCode,
+                ...(detail.suggestion === undefined ? {} : { suggestion: detail.suggestion }),
+                ...(detail.code === undefined ? {} : { code: detail.code }),
+            }), { jsonRequested: true, render: deps.render }).catch((error) => {
+                // Even error emission failing is fatal for the json contract.
+                // Only force 1 if the error detail itself indicated success (edge).
+                if ((exitCode ?? 0) === 0) {
+                    setExitCode(1);
+                }
+                log.error({
+                    evt: 'cli.emit_error.render_failed',
+                    module: MODULE_TAG,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            });
+        },
+        // RAW_STREAM seam (§5.5): emit the bare, unwrapped value for a command that
+        // declares `output:'raw-stream'` (e.g. `sessions show --raw`). The single
+        // sanctioned write lives in `renderRaw` (the one stdout-JSON seam), so the
+        // command body never hand-rolls `process.stdout.write(JSON.stringify(...))`.
+        emitRaw: (value) => renderRaw(value),
+    };
+    return {
+        setExitCode,
+        getExitCode: () => exitCode,
+        emits,
+    };
+}
+//# sourceMappingURL=output-plane.js.map

package/dist/bootstrap/output-plane.js.map

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

package/dist/bootstrap/owning-tool-init.d.ts

@@ -0,0 +1,32 @@
+/**
+ * owning-tool-init — resolve the tool that owns the invoked subcommand and run
+ * its lazy, once-per-process `Tool.initialize()`.
+ *
+ * Extracted from `pre-action-hook.ts` so that hook stays the high-level
+ * per-invocation SEQUENCER; the owning-tool resolution + fail-fast init
+ * semantics live here as a cohesive unit (see also `tool-lifecycle.ts`).
+ */
+import { type Tool, type ToolRegistry } from '@opensip-cli/core';
+/**
+ * Find the registered tool that owns the invoked subcommand, matching the
+ * descriptor's canonical name or any alias. Returns undefined for
+ * CLI-only commands (init/sessions/configure/plugin/...) — they belong to
+ * no tool, so no `initialize()` runs for them.
+ */
+export declare function resolveOwningTool(tools: ToolRegistry, cmdName: string): Tool | undefined;
+/**
+ * Lazy, memoized Tool.initialize() (P1a). Resolve the tool owning the
+ * invoked subcommand and run its initialize() exactly once per process,
+ * after the scope is entered and immediately before the action body. Tools
+ * not invoked this run pay nothing; `--help`/welcome run no initialize().
+ *
+ * Fail-fast: a throwing initialize() fails the run closed rather than letting a
+ * half-initialised tool run its command and silently appear to work. The
+ * id is recorded only on success, so a transient failure can retry in a
+ * long-lived host.
+ *
+ * @throws {BootstrapError} (exit 1) when the owning tool's initialize() throws —
+ *   the top-level boundary renders it (human stderr / structured `--json`).
+ */
+export declare function maybeInitializeOwningTool(tools: ToolRegistry, cmdName: string, runId: string): Promise<void>;
+//# sourceMappingURL=owning-tool-init.d.ts.map

package/dist/bootstrap/owning-tool-init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"owning-tool-init.d.ts","sourceRoot":"","sources":["../../src/bootstrap/owning-tool-init.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAU,KAAK,IAAI,EAAE,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAOzE;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAMxF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,yBAAyB,CAC7C,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CA2Bf"}