opensip-cli 0.1.0

package/dist/bootstrap/pre-action-messages.d.ts

@@ -0,0 +1,32 @@
+/**
+ * pre-action-messages — pure message formatters for the bootstrap
+ * `preAction` hook.
+ *
+ * Extracted from `pre-action-hook.ts` to keep that file focused on the
+ * hook's control flow. Everything here is a pure string builder: no
+ * logging, no process exit, no IO — given the same input it returns the
+ * same text. The hook owns the side effects (writing these to stderr and
+ * exiting); these functions only render.
+ */
+/** Inputs for {@link formatCliTooOldMessage}. */
+export interface CliTooOldInput {
+    readonly root: string;
+    readonly configVersion: number;
+    readonly cliVersion: number;
+}
+/**
+ * Render the "your CLI is too old" message. Direction-correct: when the
+ * config schema is newer than the CLI knows about, the USER UPGRADES
+ * THE CLI — not "run migrate" (migrate goes the OTHER direction, taking
+ * an old config UP to the current CLI's version).
+ */
+export declare function formatCliTooOldMessage(input: CliTooOldInput): string;
+/**
+ * Render the human "no opensip-cli project found" explainer — the actionable
+ * walked-up-to-root message with the `init` hint. The `--json` shape is no longer
+ * rendered here: a no-project failure is a `BootstrapError` the top-level boundary
+ * turns into a structured `bootstrap.error` `CommandOutcome` (launch,
+ * §4.7), so this formatter is the human path only.
+ */
+export declare function formatNoProjectFoundMessage(cwd: string): string;
+//# sourceMappingURL=pre-action-messages.d.ts.map

package/dist/bootstrap/pre-action-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pre-action-messages.d.ts","sourceRoot":"","sources":["../../src/bootstrap/pre-action-messages.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,iDAAiD;AACjD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAapE;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAU/D"}

package/dist/bootstrap/pre-action-messages.js

@@ -0,0 +1,49 @@
+/**
+ * pre-action-messages — pure message formatters for the bootstrap
+ * `preAction` hook.
+ *
+ * Extracted from `pre-action-hook.ts` to keep that file focused on the
+ * hook's control flow. Everything here is a pure string builder: no
+ * logging, no process exit, no IO — given the same input it returns the
+ * same text. The hook owns the side effects (writing these to stderr and
+ * exiting); these functions only render.
+ */
+/**
+ * Render the "your CLI is too old" message. Direction-correct: when the
+ * config schema is newer than the CLI knows about, the USER UPGRADES
+ * THE CLI — not "run migrate" (migrate goes the OTHER direction, taking
+ * an old config UP to the current CLI's version).
+ */
+export function formatCliTooOldMessage(input) {
+    return [
+        `✗ This project's opensip-cli.config.yml uses a newer schema than your CLI supports.`,
+        ``,
+        `  Project:        ${input.root}`,
+        `  Config schema:  v${input.configVersion}`,
+        `  CLI supports:   v${input.cliVersion}`,
+        ``,
+        `  Update your CLI to continue:`,
+        `    curl -fsSL https://opensip.ai/cli/install.sh | bash`,
+        ``,
+        `  (Or, if installed locally to the project: pnpm up opensip-cli@latest)`,
+    ].join('\n');
+}
+/**
+ * Render the human "no opensip-cli project found" explainer — the actionable
+ * walked-up-to-root message with the `init` hint. The `--json` shape is no longer
+ * rendered here: a no-project failure is a `BootstrapError` the top-level boundary
+ * turns into a structured `bootstrap.error` `CommandOutcome` (launch,
+ * §4.7), so this formatter is the human path only.
+ */
+export function formatNoProjectFoundMessage(cwd) {
+    return [
+        '✗ No OpenSIP CLI project found.',
+        '',
+        '  Searched from: ' + cwd,
+        '  Walked up to: /',
+        '',
+        '  To get started:',
+        '    opensip init',
+    ].join('\n');
+}
+//# sourceMappingURL=pre-action-messages.js.map

package/dist/bootstrap/pre-action-messages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pre-action-messages.js","sourceRoot":"","sources":["../../src/bootstrap/pre-action-messages.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AASH;;;;;GAKG;AACH,MAAM,UAAU,sBAAsB,CAAC,KAAqB;IAC1D,OAAO;QACL,qFAAqF;QACrF,EAAE;QACF,qBAAqB,KAAK,CAAC,IAAI,EAAE;QACjC,sBAAsB,KAAK,CAAC,aAAa,EAAE;QAC3C,sBAAsB,KAAK,CAAC,UAAU,EAAE;QACxC,EAAE;QACF,gCAAgC;QAChC,yDAAyD;QACzD,EAAE;QACF,yEAAyE;KAC1E,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,2BAA2B,CAAC,GAAW;IACrD,OAAO;QACL,iCAAiC;QACjC,EAAE;QACF,mBAAmB,GAAG,GAAG;QACzB,mBAAmB;QACnB,EAAE;QACF,mBAAmB;QACnB,kBAAkB;KACnB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC"}

package/dist/bootstrap/process-idempotency.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @fileoverview Small module to isolate process-scoped idempotency globals.
+ *
+ * The `initializedToolIds` Set is intentionally process-scoped (for "at most once per process"
+ * semantics of Tool.initialize(), as per the Tool contract).
+ *
+ * This module centralizes the global and its reset, making it easier to audit and test.
+ * Resets are called on per-invocation context setup (aligning with RunScope isolation).
+ *
+ * This addresses the "process-scoped globals" Low from the architecture review.
+ *
+ * See pre-action-hook.ts and the GA roadmap item 5.
+ */
+export declare const initializedToolIds: Set<string>;
+/** Reset for test harnesses and fresh invocations. */
+export declare function resetInitializedToolIdsForTest(): void;
+//# sourceMappingURL=process-idempotency.d.ts.map

package/dist/bootstrap/process-idempotency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-idempotency.d.ts","sourceRoot":"","sources":["../../src/bootstrap/process-idempotency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,eAAO,MAAM,kBAAkB,aAAoB,CAAC;AAEpD,sDAAsD;AACtD,wBAAgB,8BAA8B,IAAI,IAAI,CAErD"}

package/dist/bootstrap/process-idempotency.js

@@ -0,0 +1,20 @@
+/**
+ * @fileoverview Small module to isolate process-scoped idempotency globals.
+ *
+ * The `initializedToolIds` Set is intentionally process-scoped (for "at most once per process"
+ * semantics of Tool.initialize(), as per the Tool contract).
+ *
+ * This module centralizes the global and its reset, making it easier to audit and test.
+ * Resets are called on per-invocation context setup (aligning with RunScope isolation).
+ *
+ * This addresses the "process-scoped globals" Low from the architecture review.
+ *
+ * See pre-action-hook.ts and the GA roadmap item 5.
+ */
+/* eslint-disable sonarjs/no-empty-collection -- intentionally starts empty; populated on tool initialize, cleared per-run for isolation (GA Low hygiene) */
+export const initializedToolIds = new Set();
+/** Reset for test harnesses and fresh invocations. */
+export function resetInitializedToolIdsForTest() {
+    initializedToolIds.clear();
+}
+//# sourceMappingURL=process-idempotency.js.map

package/dist/bootstrap/process-idempotency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-idempotency.js","sourceRoot":"","sources":["../../src/bootstrap/process-idempotency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,4JAA4J;AAC5J,MAAM,CAAC,MAAM,kBAAkB,GAAG,IAAI,GAAG,EAAU,CAAC;AAEpD,sDAAsD;AACtD,MAAM,UAAU,8BAA8B;IAC5C,kBAAkB,CAAC,KAAK,EAAE,CAAC;AAC7B,CAAC"}

package/dist/bootstrap/register-language-adapters.d.ts

@@ -0,0 +1,23 @@
+/**
+ * register-language-adapters — register the bundled language adapters
+ * into a kernel-level `LanguageRegistry`.
+ *
+ * Extracted from `index.ts` so the registration list is not a
+ * module-load side effect but a pure function the composition root
+ * calls explicitly. Each adapter ships with a layered language pack
+ * (`@opensip-cli/lang-*`); the CLI is the single component that
+ * wires them in — fitness/simulation must not take a hard dep on
+ * every language pack (would invert the layered architecture).
+ *
+ * The order below is presentational only; the registry is keyed by
+ * adapter id so duplicates short-circuit and order does not affect
+ * resolution.
+ */
+import type { LanguageRegistry } from '@opensip-cli/core';
+/**
+ * Register the six bundled language adapters into the supplied
+ * registry. Idempotent w.r.t. duplicate registrations: the kernel
+ * registry is first-writer-wins.
+ */
+export declare function registerLanguageAdapters(registry: LanguageRegistry): void;
+//# sourceMappingURL=register-language-adapters.d.ts.map

package/dist/bootstrap/register-language-adapters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-language-adapters.d.ts","sourceRoot":"","sources":["../../src/bootstrap/register-language-adapters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AASH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI,CAOzE"}

package/dist/bootstrap/register-language-adapters.js

@@ -0,0 +1,35 @@
+/**
+ * register-language-adapters — register the bundled language adapters
+ * into a kernel-level `LanguageRegistry`.
+ *
+ * Extracted from `index.ts` so the registration list is not a
+ * module-load side effect but a pure function the composition root
+ * calls explicitly. Each adapter ships with a layered language pack
+ * (`@opensip-cli/lang-*`); the CLI is the single component that
+ * wires them in — fitness/simulation must not take a hard dep on
+ * every language pack (would invert the layered architecture).
+ *
+ * The order below is presentational only; the registry is keyed by
+ * adapter id so duplicates short-circuit and order does not affect
+ * resolution.
+ */
+import { cppAdapter } from '@opensip-cli/lang-cpp';
+import { goAdapter } from '@opensip-cli/lang-go';
+import { javaAdapter } from '@opensip-cli/lang-java';
+import { pythonAdapter } from '@opensip-cli/lang-python';
+import { rustAdapter } from '@opensip-cli/lang-rust';
+import { typescriptAdapter } from '@opensip-cli/lang-typescript';
+/**
+ * Register the six bundled language adapters into the supplied
+ * registry. Idempotent w.r.t. duplicate registrations: the kernel
+ * registry is first-writer-wins.
+ */
+export function registerLanguageAdapters(registry) {
+    registry.register(typescriptAdapter);
+    registry.register(rustAdapter);
+    registry.register(pythonAdapter);
+    registry.register(javaAdapter);
+    registry.register(goAdapter);
+    registry.register(cppAdapter);
+}
+//# sourceMappingURL=register-language-adapters.js.map

package/dist/bootstrap/register-language-adapters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-language-adapters.js","sourceRoot":"","sources":["../../src/bootstrap/register-language-adapters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAIjE;;;;GAIG;AACH,MAAM,UAAU,wBAAwB,CAAC,QAA0B;IACjE,QAAQ,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAC;IACrC,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;IAC/B,QAAQ,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;IACjC,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;IAC/B,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;AAChC,CAAC"}

package/dist/bootstrap/register-tools.d.ts

@@ -0,0 +1,228 @@
+/**
+ * register-tools — populate the kernel `ToolRegistry` with first-party
+ * tools (fitness / simulation / graph) plus any third-party tool
+ * packages discovered on disk.
+ *
+ * Extracted from `index.ts`. The bundled-id skip below is defense in
+ * depth: as of Layer 1 Phase 1 the registry itself enforces
+ * first-writer-wins on duplicate ids and logs a structured
+ * `tool.registry.duplicate` warning. Keeping the explicit guard avoids
+ * a noisy warning when a third-party package happens to ship under a
+ * built-in id.
+ */
+import { type CliProgram } from '@opensip-cli/contracts';
+import { type ToolCliContext, type ToolDiscoverySource, type ToolPluginManifest, type ToolProvenance, type ToolRegistry } from '@opensip-cli/core';
+/**
+ * Bundled first-party tool PACKAGES — declared as direct deps of
+ * opensip-cli. Order is registration order (and thus help/listing order).
+ *
+ * launch cutover: these are package NAMES, not imported tool runtimes. The
+ * host no longer statically `import`s `fitnessTool`/`graphTool`/`simulationTool`
+ * — bundled tools are resolved on disk and loaded by DYNAMIC IMPORT through the
+ * exact same manifest → `admitTool` → import → register path an installed or
+ * project-local tool travels (north-star §2.1, Figure 7). "Bundled" is now a
+ * provenance/trust posture, not a privileged load path: install-source
+ * independence is structural, not merely tested (`no-bootstrap-tool-import`
+ * guards this file against a static tool-runtime import creeping back).
+ */
+export declare const BUNDLED_TOOL_PACKAGES: readonly string[];
+/**
+ * The ADR-0038 back-compat pin: the tool IDS whose `init` scaffold dirs the
+ * pre-registry-driven CLI ALWAYS created (fit/sim). The composition root warns
+ * (`cli.tool.expected_bundled_absent`) when one of these is missing from the
+ * populated registry, so a build whose {@link BUNDLED_TOOL_PACKAGES} drifted
+ * (a tool removed, a packaging variant) under-scaffolds LOUDLY instead of
+ * silently.
+ *
+ * Deliberately a HISTORICAL CONSTANT, not derived from the loaded bundled
+ * manifests: bundled tools fail CLOSED in {@link registerFirstPartyTools}
+ * (every load failure throws before the warning could run), so "bundled
+ * manifests absent from the registry" is structurally empty — a derived list
+ * could never fire. The only drift this diagnostic exists to catch is an edit
+ * to the package list itself, which is precisely what a derivation would
+ * follow rather than flag. Co-located with the package list (one module owns
+ * both encodings) so an editor of either sees the other. `graph` is correctly
+ * absent: it never scaffolded (`pluginLayout` undefined).
+ */
+export declare const EXPECTED_SCAFFOLDING_TOOL_IDS: readonly string[];
+/**
+ * Register the bundled first-party tools into the supplied registry, each one
+ * flowing through the SAME admit → dynamic-import → register path the external
+ * path uses (launch cutover — replaces the static-import + gate path).
+ *
+ * Per package name: `resolveBundledPackageDir` → `loadToolManifest('bundled')`
+ * → `admitTool({ source: 'bundled', explicitlyRequested: true })` →
+ * `importToolRuntime` (dynamic import + shape validation) → drift guard →
+ * `registry.register`. A bundled tool ships with the CLI, so it is always
+ * explicitly present: a missing/incompatible manifest or a runtime that fails
+ * to load is FAIL-CLOSED (never a silent skip). The recorded `ToolProvenance`
+ * (source `'bundled'`, trusted-by-shipping) and manifest are pushed onto the
+ * optional collectors so the composition root can surface provenance
+ * (`plugin list`) and seed the per-run capability registry (§5.3).
+ *
+ * @param registry The per-invocation tool registry to populate.
+ * @param provenance Optional sink for the admitted tools' provenance records.
+ * @param manifests Optional sink for the admitted tools' manifests (§5.3).
+ * @param packages The bundled package names to load (defaults to
+ *   {@link BUNDLED_TOOL_PACKAGES}; injectable so the fail-closed paths are
+ *   testable with fixture packages).
+ * @throws {PluginIncompatibleError} when a bundled tool cannot be resolved,
+ *   has no conformant manifest, is out of range, or its runtime fails to load
+ *   — mapped to `EXIT_CODES.PLUGIN_INCOMPATIBLE` (exit 5) by the CLI boundary.
+ */
+export declare function registerFirstPartyTools(registry: ToolRegistry, provenance?: ToolProvenance[], manifests?: ToolPluginManifest[], packages?: readonly string[]): Promise<void>;
+export interface DiscoveryOptions {
+    /**
+     * Ordered tool-discovery sources (precedence: first wins on duplicate
+     * name). Built by {@link buildToolDiscoverySources} at the composition
+     * root; passed in here so this function reads no ambient HOME/cwd state
+     * and stays unit-testable with explicit anchors.
+     */
+    readonly sources: readonly ToolDiscoverySource[];
+}
+/**
+ * Build the ordered tool-discovery sources. Order is precedence
+ * (first-occurrence-wins on duplicate name):
+ *
+ *   1. project-local `.runtime/plugins/tool`  — `plugin add --project`
+ *   2. project tree (walk up from cwd)          — plain `npm install @tool`
+ *   3. user-global `~/.opensip-cli/plugins/tool` — `plugin add` (default)
+ *   4. CLI install dir (walk up)                 — `npm i -g @tool`
+ *
+ * A project-local pin therefore shadows a user-global install of the same
+ * tool. Project-root resolution is best-effort: an unresolvable context
+ * (e.g. running outside any project) simply contributes no `.runtime`
+ * source.
+ */
+export declare function buildToolDiscoverySources(cwd: string, cliInstallDir: string): ToolDiscoverySource[];
+export declare function discoverAndRegisterToolPackages(registry: ToolRegistry, opts: DiscoveryOptions, builtInIds: ReadonlySet<string>, provenance?: ToolProvenance[], manifests?: ToolPluginManifest[]): Promise<void>;
+/**
+ * The outcome of admitting a tool — the recorded `ToolProvenance` plus the
+ * loaded `ToolPluginManifest`. Returned by the authored legs
+ * ({@link admitUserGlobalTool} / {@link admitProjectLocalTool}) and the
+ * installed leg ({@link admitInstalledTool}) alike. The manifest is returned
+ * (not re-read) so the register step can run the drift guard
+ * (`assertManifestMatchesTool`) against the imported runtime and seed the
+ * per-run capability registry, without a second filesystem read.
+ */
+export interface AuthoredAdmission {
+    readonly provenance: ToolProvenance;
+    readonly manifest: ToolPluginManifest;
+}
+/**
+ * Admit (or reject) a single PROJECT-LOCAL authored tool under the
+ * deny-by-default trust policy (launch, Phase 3 Task 3.2; wired into
+ * production discovery in the launch contract).
+ *
+ * A project-local tool is authored code under
+ * `<project>/opensip-cli/tools/<name>/` declaring its identity via a JSON
+ * sidecar (`opensip-tool.manifest.json`). It is read + gated WITHOUT importing
+ * its module:
+ *
+ *   1. `loadToolManifest('project-local', dir)` — identity only, no code run.
+ *   2. Trust check — {@link isProjectLocalToolTrusted}. Not allowlisted ⇒
+ *      throw {@link PluginIncompatibleError} (fail-closed, exit 5) before any
+ *      import. Allowlisted ⇒ run the shared compatibility tail; an incompatible
+ *      explicitly-trusted tool is likewise fail-closed.
+ *
+ * Returns the admitted tool's `{ provenance, manifest }` on success. The trust
+ * decision always precedes import (it is the FIRST statement here, ahead of the
+ * shared {@link admitAuthoredTool} tail).
+ *
+ * @throws {PluginIncompatibleError} when the tool has no conformant sidecar
+ *   manifest, is not allowlisted, or is compatibility-incompatible.
+ */
+export declare function admitProjectLocalTool(args: {
+    readonly dir: string;
+    readonly env?: NodeJS.ProcessEnv;
+}): AuthoredAdmission;
+/**
+ * Admit a single USER-GLOBAL authored tool — the trusted-by-default sibling of
+ * {@link admitProjectLocalTool}.
+ *
+ * A user-global tool is an authored sidecar under
+ * `~/.opensip-cli/tools/<name>/`. The user deliberately placed it in their
+ * own home dir (the `npm i -g` analogue for authored code), so there is **no
+ * allowlist gate** — it is trusted-by-default. It still reads the static
+ * sidecar and runs `admitTool` BEFORE the module could be imported (the shared
+ * {@link admitAuthoredTool} tail), so trust-before-import holds for this leg
+ * too: a global tool the user explicitly authored is fail-closed on a
+ * missing/incompatible manifest, never a silent skip.
+ *
+ * @throws {PluginIncompatibleError} when the tool has no conformant sidecar
+ *   manifest or is compatibility-incompatible.
+ */
+export declare function admitUserGlobalTool(args: {
+    readonly dir: string;
+}): AuthoredAdmission;
+/**
+ * Discover + admit + register AUTHORED Tool sidecars from the two authored
+ * roots, then dynamic-import each admitted runtime through the shared
+ * `importToolRuntime` seam — the same admit → import → register path the
+ * bundled and installed legs travel (ADR-0027; this is the leg that makes the
+ * dormant {@link admitProjectLocalTool} live).
+ *
+ * Two roots, two trust postures:
+ *   - **global** (`~/.opensip-cli/tools/`) → {@link admitUserGlobalTool},
+ *     trusted-by-default.
+ *   - **project** (`<project>/opensip-cli/tools/`) → {@link admitProjectLocalTool},
+ *     deny-by-default (allowlist via `OPENSIP_CLI_ALLOW_PROJECT_TOOLS`).
+ *
+ * Global is processed FIRST so a project-authored tool cannot shadow a same-id
+ * global one — matching the `~/.opensip-cli/plugins` precedence note in
+ * {@link buildToolDiscoverySources} (first-writer-wins via the registry).
+ * `builtInIds` are skipped so an authored tool never shadows a bundled one.
+ *
+ * **Trust-before-import.** For each candidate, the admit step (which EMBEDS the
+ * trust decision — deny-by-default inside `admitProjectLocalTool`) runs to
+ * completion BEFORE `importToolRuntime`. A non-allowlisted project tool THROWS
+ * `PluginIncompatibleError` (exit 5) here, propagated out of the walk: it must
+ * fail the run loudly — that is the clone-protection contract.
+ *
+ * **Error-posture asymmetry (deliberate).** An un-allowlisted *project* tool is
+ * fail-closed by policy (clone-risk; the user must opt in). A *global* tool that
+ * fails to load is also fail-closed (the user explicitly authored it into
+ * `$HOME`). This differs from the *installed* npm leg, where a stray bad plugin
+ * skips-with-diagnostic so it can't take fit/graph/sim down — authored tools are
+ * first-party-intent, installed tools are ambient.
+ *
+ * @param registry The per-invocation tool registry to populate.
+ * @param opts.projectAuthoredDir `resolveProjectPaths(root).authoredToolsDir`,
+ *   or `undefined` when there is no resolvable project context.
+ * @param opts.globalAuthoredDir `resolveUserPaths().authoredToolsDir`.
+ * @param opts.env Environment carrying the project allowlist (default
+ *   `process.env`); injectable for tests.
+ * @param builtInIds Bundled-tool ids to skip on a name collision.
+ * @param provenance Sink for admitted authored tools' provenance records.
+ * @param manifests Sink for admitted authored tools' manifests (§5.3).
+ * @throws {PluginIncompatibleError} for an un-allowlisted project tool, or any
+ *   authored tool whose sidecar/runtime is missing/incompatible (fail-closed).
+ */
+export declare function discoverAndRegisterAuthoredTools(registry: ToolRegistry, opts: {
+    readonly projectAuthoredDir?: string;
+    readonly globalAuthoredDir: string;
+    readonly env?: NodeJS.ProcessEnv;
+}, builtInIds: ReadonlySet<string>, provenance?: ToolProvenance[], manifests?: ToolPluginManifest[]): Promise<void>;
+/**
+ * Walk the registry and mount each tool's commands onto `program`. This is
+ * **step 8** of the tool lifecycle (launch, §5.4) — see
+ * {@link runToolLifecycle}.
+ *
+ * Public launch: there is ONE command surface — the tool's declared `commandSpecs`,
+ * mounted by `mountCommandSpec`. `register()` and the raw-Commander `program`
+ * handle on the tool context are gone, so the host owns `program` and passes it
+ * in here (the tool never touches Commander). A tool with no `commandSpecs` is a
+ * mis-declaration: it contributes no commands, surfaced loudly via
+ * `cli.tool.no_command_surface`.
+ *
+ * Failures are isolated per tool — one tool whose spec fails to mount must not
+ * take the whole CLI down. The failure is logged + stderr-warned, then we
+ * continue with the next tool.
+ *
+ * @param registry The per-invocation tool registry to walk.
+ * @param program The root Commander program (host-owned; the composition root
+ *   passes it — it is no longer reachable through the tool context, §8).
+ * @param ctx The per-invocation handler context (render/emit/scope — no program).
+ */
+export declare function mountAllToolCommands(registry: ToolRegistry, program: CliProgram, ctx: ToolCliContext): void;
+//# sourceMappingURL=register-tools.d.ts.map

package/dist/bootstrap/register-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-tools.d.ts","sourceRoot":"","sources":["../../src/bootstrap/register-tools.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AAMH,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAaL,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,YAAY,EAElB,MAAM,mBAAmB,CAAC;AAe3B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAIlD,CAAC;AAKF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,6BAA6B,EAAE,SAAS,MAAM,EAA8B,CAAC;AA6E1F;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,YAAY,EACtB,UAAU,GAAE,cAAc,EAAO,EACjC,SAAS,GAAE,kBAAkB,EAAO,EACpC,QAAQ,GAAE,SAAS,MAAM,EAA0B,GAClD,OAAO,CAAC,IAAI,CAAC,CAwCf;AA8DD,MAAM,WAAW,gBAAgB;IAC/B;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,mBAAmB,EAAE,CAAC;CAClD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,MAAM,EACX,aAAa,EAAE,MAAM,GACpB,mBAAmB,EAAE,CAqBvB;AAiHD,wBAAsB,+BAA+B,CACnD,QAAQ,EAAE,YAAY,EACtB,IAAI,EAAE,gBAAgB,EACtB,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,EAC/B,UAAU,GAAE,cAAc,EAAO,EACjC,SAAS,GAAE,kBAAkB,EAAO,GACnC,OAAO,CAAC,IAAI,CAAC,CAoDf;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,CAAC;CACvC;AAgDD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CAClC,GAAG,iBAAiB,CAuBpB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,iBAAiB,CAGrF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAsB,gCAAgC,CACpD,QAAQ,EAAE,YAAY,EACtB,IAAI,EAAE;IACJ,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CAClC,EACD,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,EAC/B,UAAU,GAAE,cAAc,EAAO,EACjC,SAAS,GAAE,kBAAkB,EAAO,GACnC,OAAO,CAAC,IAAI,CAAC,CA0Bf;AAqDD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,YAAY,EACtB,OAAO,EAAE,UAAU,EACnB,GAAG,EAAE,cAAc,GAClB,IAAI,CAqBN"}