opensip-cli 0.1.8 → 0.1.9

package/dist/bootstrap/tool-command-worker-config-pass.d.ts

@@ -0,0 +1,24 @@
+/**
+ * tool-command-worker-config-pass — the ADR-0054 M4-E DEEP config validation pass
+ * the dispatch worker runs against a tool's OWN config schema.
+ *
+ * Extracted from `tool-command-worker-entry.ts` to keep that file within the
+ * file-length budget. The host coarse pass (pre-fork) validated only the
+ * serializable manifest descriptor shape; this is the semantic, authoritative
+ * validation the host (which must not import the tool's Zod) could not perform —
+ * legitimate HERE, inside the worker isolation boundary, where the runtime is
+ * already loaded.
+ */
+import { type Tool } from '@opensip-cli/core';
+/**
+ * Run the dispatched tool's OWN config schema against its coarse-validated config
+ * namespace block.
+ *
+ * Returns `undefined` on success (or when there is nothing to validate); returns a
+ * human-readable `Invalid configuration …` MESSAGE on a schema failure. The caller
+ * (the worker entry) wraps the message in a `config-invalid` IPC error message —
+ * the worker does NOT throw/crash; the supervisor maps it to the SAME typed config
+ * error + exit code the host coarse pass uses (single config-error contract).
+ */
+export declare function runDeepConfigPass(tool: Tool, config: unknown): string | undefined;
+//# sourceMappingURL=tool-command-worker-config-pass.d.ts.map

package/dist/bootstrap/tool-command-worker-config-pass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-command-worker-config-pass.d.ts","sourceRoot":"","sources":["../../src/bootstrap/tool-command-worker-config-pass.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAoB,KAAK,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAqBhE;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAwBjF"}

package/dist/bootstrap/tool-command-worker-config-pass.js

@@ -0,0 +1,52 @@
+/**
+ * tool-command-worker-config-pass — the ADR-0054 M4-E DEEP config validation pass
+ * the dispatch worker runs against a tool's OWN config schema.
+ *
+ * Extracted from `tool-command-worker-entry.ts` to keep that file within the
+ * file-length budget. The host coarse pass (pre-fork) validated only the
+ * serializable manifest descriptor shape; this is the semantic, authoritative
+ * validation the host (which must not import the tool's Zod) could not perform —
+ * legitimate HERE, inside the worker isolation boundary, where the runtime is
+ * already loaded.
+ */
+import { resolveToolHooks } from '@opensip-cli/core';
+/** Structural guard: the loaded tool's config schema exposes a `safeParse` method. */
+function isSafeParseable(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.safeParse === 'function');
+}
+/**
+ * Run the dispatched tool's OWN config schema against its coarse-validated config
+ * namespace block.
+ *
+ * Returns `undefined` on success (or when there is nothing to validate); returns a
+ * human-readable `Invalid configuration …` MESSAGE on a schema failure. The caller
+ * (the worker entry) wraps the message in a `config-invalid` IPC error message —
+ * the worker does NOT throw/crash; the supervisor maps it to the SAME typed config
+ * error + exit code the host coarse pass uses (single config-error contract).
+ */
+export function runDeepConfigPass(tool, config) {
+    // No config block in the document for this tool's namespace → nothing to
+    // deep-validate (the host coarse pass already accepted its absence).
+    if (config === undefined)
+        return undefined;
+    const declaration = resolveToolHooks(tool).config;
+    // No Zod declaration on the runtime → defer to the coarse pass's verdict (the
+    // host already accepted the block as an opaque object); nothing deeper to run.
+    if (declaration === undefined || !isSafeParseable(declaration.schema))
+        return undefined;
+    const result = declaration.schema.safeParse(config);
+    if (result.success)
+        return undefined;
+    const summary = (result.error?.issues ?? [])
+        .map((issue) => {
+        const path = issue.path !== undefined && issue.path.length > 0
+            ? issue.path.join('.')
+            : declaration.namespace;
+        return `${declaration.namespace}.${path}: ${issue.message}`;
+    })
+        .join('; ');
+    return `Invalid configuration for '${tool.metadata.name ?? tool.metadata.id}': ${summary.length > 0 ? summary : 'config did not satisfy the tool schema'}`;
+}
+//# sourceMappingURL=tool-command-worker-config-pass.js.map

package/dist/bootstrap/tool-command-worker-config-pass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-command-worker-config-pass.js","sourceRoot":"","sources":["../../src/bootstrap/tool-command-worker-config-pass.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,gBAAgB,EAAa,MAAM,mBAAmB,CAAC;AAYhE,sFAAsF;AACtF,SAAS,eAAe,CAAC,KAAc;IACrC,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,OAAQ,KAAiC,CAAC,SAAS,KAAK,UAAU,CACnE,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAU,EAAE,MAAe;IAC3D,yEAAyE;IACzE,qEAAqE;IACrE,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC3C,MAAM,WAAW,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC;IAClD,8EAA8E;IAC9E,+EAA+E;IAC/E,IAAI,WAAW,KAAK,SAAS,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,MAAM,CAAC;QAAE,OAAO,SAAS,CAAC;IAExF,MAAM,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IACpD,IAAI,MAAM,CAAC,OAAO;QAAE,OAAO,SAAS,CAAC;IAErC,MAAM,OAAO,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,IAAI,EAAE,CAAC;SACzC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QACb,MAAM,IAAI,GACR,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC;YAC/C,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC;YACtB,CAAC,CAAC,WAAW,CAAC,SAAS,CAAC;QAC5B,OAAO,GAAG,WAAW,CAAC,SAAS,IAAI,IAAI,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC;IAC9D,CAAC,CAAC;SACD,IAAI,CAAC,IAAI,CAAC,CAAC;IACd,OAAO,8BAA8B,IAAI,CAAC,QAAQ,CAAC,IAAI,IAAI,IAAI,CAAC,QAAQ,CAAC,EAAE,MACzE,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,wCACjC,EAAE,CAAC;AACL,CAAC"}

package/dist/bootstrap/tool-command-worker-context.d.ts

@@ -0,0 +1,55 @@
+/**
+ * tool-command-worker-context — the WORKER-side {@link ToolCliContext} shim for
+ * the ADR-0054 out-of-process dispatch plane (increments M4-C / M4-D).
+ *
+ * Each seam the worker exposes to the dispatched handler is implemented per its
+ * transport strategy from ADR-0054's M4-C mapping table:
+ *
+ *   - final-result-return (FRR): `render` / `emitJson` / `emitEnvelope` /
+ *     `emitRaw` / `emitError` / `setExitCode` record into a {@link
+ *     ResultAccumulator} drained into a `ToolCommandResult` after the handler
+ *     resolves; the host replays them through the real seams.
+ *   - host-RPC (RPC): `deliverSignals` / `writeSarif` / the four baseline seams
+ *     / `toolState.*` / `hostPlanes.*` / `maybeOpenReport` / `getExitCode` issue
+ *     a typed {@link HostRpcRequest} via the {@link WorkerRpcClient} and await
+ *     the host's reply — the HOST performs the privileged effect (datastore /
+ *     egress / FS / process exit) and returns the result.
+ *   - host-only (fail loud): the live-view seams (`registerLiveView` /
+ *     `renderLive`) throw {@link UnsupportedSeamError} — Ink/TTY rendering
+ *     cannot leave the host (documented as a later increment).
+ *
+ * `scope` / `runSession` / `logger` are backed by the worker's own minimal
+ * {@link RunScope} + run timer (the worker re-bootstraps its own scope; it never
+ * ships a live `RunScope` across IPC).
+ */
+import { type RunScope, type RunTimer, type ToolCliContext } from '@opensip-cli/core';
+import type { ToolCommandFailureClass, ToolCommandResult } from './tool-command-dispatch-types.js';
+import type { WorkerRpcClient } from './tool-command-worker-rpc.js';
+/**
+ * A loud, marked failure for a seam the worker shim cannot marshal (the
+ * live-view seams). Carries the {@link ToolCommandFailureClass} so the
+ * supervisor can triage; the worker catch turns it into an `error` IPC message.
+ */
+export declare class UnsupportedSeamError extends Error {
+    readonly failureClass: ToolCommandFailureClass;
+    constructor(seam: string);
+}
+/**
+ * The mutable accumulator the worker-side context shim records final-result
+ * seam calls into. Drained into a {@link ToolCommandResult} after the handler
+ * resolves.
+ */
+export interface ResultAccumulator {
+    render?: unknown;
+    envelope?: unknown;
+    json?: unknown;
+    raw?: unknown;
+    error?: ToolCommandResult['error'];
+    exitCode?: number;
+}
+/**
+ * Build the worker-side {@link ToolCliContext} shim. FRR seams record into
+ * `acc`; RPC seams upcall via `rpcClient`; the live-view seams fail loud.
+ */
+export declare function buildWorkerContext(scope: RunScope, timing: RunTimer, acc: ResultAccumulator, rpcClient: WorkerRpcClient): ToolCliContext;
+//# sourceMappingURL=tool-command-worker-context.d.ts.map

package/dist/bootstrap/tool-command-worker-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-command-worker-context.d.ts","sourceRoot":"","sources":["../../src/bootstrap/tool-command-worker-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAKL,KAAK,QAAQ,EACb,KAAK,QAAQ,EAEb,KAAK,cAAc,EACpB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAGV,uBAAuB,EACvB,iBAAiB,EAClB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE;;;;GAIG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,YAAY,EAAE,uBAAuB,CAAsB;gBACxD,IAAI,EAAE,MAAM;CAQzB;AAgBD;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,KAAK,CAAC,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AA2DD;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,QAAQ,EACf,MAAM,EAAE,QAAQ,EAChB,GAAG,EAAE,iBAAiB,EACtB,SAAS,EAAE,eAAe,GACzB,cAAc,CA+DhB"}

package/dist/bootstrap/tool-command-worker-context.js

@@ -0,0 +1,163 @@
+/**
+ * tool-command-worker-context — the WORKER-side {@link ToolCliContext} shim for
+ * the ADR-0054 out-of-process dispatch plane (increments M4-C / M4-D).
+ *
+ * Each seam the worker exposes to the dispatched handler is implemented per its
+ * transport strategy from ADR-0054's M4-C mapping table:
+ *
+ *   - final-result-return (FRR): `render` / `emitJson` / `emitEnvelope` /
+ *     `emitRaw` / `emitError` / `setExitCode` record into a {@link
+ *     ResultAccumulator} drained into a `ToolCommandResult` after the handler
+ *     resolves; the host replays them through the real seams.
+ *   - host-RPC (RPC): `deliverSignals` / `writeSarif` / the four baseline seams
+ *     / `toolState.*` / `hostPlanes.*` / `maybeOpenReport` / `getExitCode` issue
+ *     a typed {@link HostRpcRequest} via the {@link WorkerRpcClient} and await
+ *     the host's reply — the HOST performs the privileged effect (datastore /
+ *     egress / FS / process exit) and returns the result.
+ *   - host-only (fail loud): the live-view seams (`registerLiveView` /
+ *     `renderLive`) throw {@link UnsupportedSeamError} — Ink/TTY rendering
+ *     cannot leave the host (documented as a later increment).
+ *
+ * `scope` / `runSession` / `logger` are backed by the worker's own minimal
+ * {@link RunScope} + run timer (the worker re-bootstraps its own scope; it never
+ * ships a live `RunScope` across IPC).
+ */
+/**
+ * A loud, marked failure for a seam the worker shim cannot marshal (the
+ * live-view seams). Carries the {@link ToolCommandFailureClass} so the
+ * supervisor can triage; the worker catch turns it into an `error` IPC message.
+ */
+export class UnsupportedSeamError extends Error {
+    failureClass = 'unsupported-seam';
+    constructor(seam) {
+        super(`tool command worker: seam '${seam}' cannot be marshalled across the ADR-0054 ` +
+            'dispatch boundary (Ink/TTY rendering stays host-side). The external command ' +
+            'attempted a live-view effect the worker cannot perform.');
+        this.name = 'UnsupportedSeamError';
+    }
+}
+/**
+ * Build a host-only seam stub that fails loudly when an external handler calls a
+ * seam the worker cannot marshal (the live-view seams).
+ *
+ * @throws {UnsupportedSeamError} always — that is the point: an unmarshallable
+ *   seam must surface as a structured failure, never a silent no-op.
+ */
+function unsupported(seam) {
+    // @fitness-ignore-next-line throws-documentation -- the throw is documented on the enclosing `unsupported` factory's @throws above; this is the one-line closure it returns.
+    return () => {
+        throw new UnsupportedSeamError(seam);
+    };
+}
+/** Issue one RPC upcall and cast the host's reply to the seam's return type. */
+function rpc(client, request) {
+    return client.call(request);
+}
+/** Build the RPC-backed `toolState` member (ADR-0042 datastore-backed). */
+function buildToolStateRpc(client) {
+    return {
+        get: (tool, key) => rpc(client, { seam: 'toolState.get', tool, key }),
+        put: (tool, key, payload) => rpc(client, { seam: 'toolState.put', tool, key, payload }),
+        delete: (tool, key) => rpc(client, { seam: 'toolState.delete', tool, key }),
+        list: (tool) => rpc(client, { seam: 'toolState.list', tool }),
+    };
+}
+/**
+ * Make one host-plane method into a generic `hostPlane` upcall
+ * (`plane`/`method`/`args`). The host dispatches to the real plane impl by name;
+ * the worker never holds a plane handle.
+ */
+function planeMethod(client, plane, method) {
+    return (...args) => rpc(client, { seam: 'hostPlane', plane, method, args });
+}
+/**
+ * Build the RPC-backed `hostPlanes` bag (governance / audit / entitlements).
+ * Each plane's methods are enumerated explicitly (rather than via a Proxy) so
+ * the shim conforms to the core host-plane interfaces structurally — every
+ * method routes through {@link planeMethod} to a generic `hostPlane` upcall.
+ */
+function buildHostPlanesRpc(client) {
+    const governance = {
+        getGovernanceState: planeMethod(client, 'governance', 'getGovernanceState'),
+        listForProject: planeMethod(client, 'governance', 'listForProject'),
+        queryAudit: planeMethod(client, 'governance', 'queryAudit'),
+        recordInstallation: planeMethod(client, 'governance', 'recordInstallation'),
+        recordApprovalDecision: planeMethod(client, 'governance', 'recordApprovalDecision'),
+        setBlock: planeMethod(client, 'governance', 'setBlock'),
+        checkAllowed: planeMethod(client, 'governance', 'checkAllowed'),
+    };
+    const audit = {
+        append: planeMethod(client, 'audit', 'append'),
+        query: planeMethod(client, 'audit', 'query'),
+        exportForCloud: planeMethod(client, 'audit', 'exportForCloud'),
+    };
+    const entitlements = {
+        check: planeMethod(client, 'entitlements', 'check'),
+        recordUsage: planeMethod(client, 'entitlements', 'recordUsage'),
+        getLicenseState: planeMethod(client, 'entitlements', 'getLicenseState'),
+    };
+    return { governance, audit, entitlements };
+}
+/**
+ * Build the worker-side {@link ToolCliContext} shim. FRR seams record into
+ * `acc`; RPC seams upcall via `rpcClient`; the live-view seams fail loud.
+ */
+export function buildWorkerContext(scope, timing, acc, rpcClient) {
+    return {
+        scope,
+        runSession: { timing },
+        logger: scope.logger,
+        // ── Final-result-return seams (recorded, replayed host-side) ──────────
+        render: (result) => {
+            acc.render = result;
+            return Promise.resolve();
+        },
+        emitJson: (value) => {
+            acc.json = value;
+        },
+        emitEnvelope: (envelope) => {
+            acc.envelope = envelope;
+        },
+        emitRaw: (value) => {
+            acc.raw = value;
+        },
+        emitError: (detail) => {
+            acc.error = {
+                message: detail.message,
+                exitCode: detail.exitCode,
+                ...(detail.suggestion === undefined ? {} : { suggestion: detail.suggestion }),
+                ...(detail.code === undefined ? {} : { code: detail.code }),
+            };
+        },
+        setExitCode: (code) => {
+            acc.exitCode = code;
+        },
+        // ── Host-RPC seams (M4-C upcalls — host performs the effect) ──────────
+        getExitCode: () => acc.exitCode,
+        deliverSignals: (envelope, opts) => rpc(rpcClient, {
+            seam: 'deliverSignals',
+            envelope,
+            opts: {
+                cwd: opts.cwd,
+                ...(opts.reportTo === undefined ? {} : { reportTo: opts.reportTo }),
+                ...(opts.apiKey === undefined ? {} : { apiKey: opts.apiKey }),
+                ...(opts.runFailed === undefined ? {} : { runFailed: opts.runFailed }),
+            },
+        }),
+        writeSarif: (envelope, path) => rpc(rpcClient, { seam: 'writeSarif', envelope, path }),
+        saveBaseline: (tool, envelope) => rpc(rpcClient, { seam: 'saveBaseline', tool, envelope }),
+        compareBaseline: (tool, envelope) => rpc(rpcClient, { seam: 'compareBaseline', tool, envelope }),
+        exportBaselineSarif: (tool, path) => rpc(rpcClient, { seam: 'exportBaselineSarif', tool, path }),
+        exportBaselineFingerprints: (tool, path) => rpc(rpcClient, { seam: 'exportBaselineFingerprints', tool, path }),
+        maybeOpenReport: (opts) => rpc(rpcClient, {
+            seam: 'maybeOpenReport',
+            opts: { openRequested: opts.openRequested, jsonOutput: opts.jsonOutput },
+        }),
+        toolState: buildToolStateRpc(rpcClient),
+        hostPlanes: buildHostPlanesRpc(rpcClient),
+        // ── Live-view seams (host-only — fail loud) ───────────────────────────
+        registerLiveView: unsupported('registerLiveView'),
+        renderLive: unsupported('renderLive'),
+    };
+}
+//# sourceMappingURL=tool-command-worker-context.js.map

package/dist/bootstrap/tool-command-worker-context.js.map

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

package/dist/bootstrap/tool-command-worker-entry.d.ts

@@ -0,0 +1,66 @@
+/**
+ * tool-command-worker-entry — the WORKER side of the out-of-process external
+ * tool command dispatch plane (ADR-0054, increments M4-C / M4-D / M4-E).
+ *
+ * This is a HOST internal `CommandSpec` (`__tool-command-worker`), forked by the
+ * supervisor as `node <cliScript> __tool-command-worker <specPath> --cwd <cwd>`.
+ * Forking the CLI binary as a subcommand (the SAME pattern graph's
+ * `graph-run-worker` uses) means the FULL CLI bootstrap runs first: the preAction
+ * hook discovers + imports the external tool runtime IN THE WORKER, registers it,
+ * runs its `contributeScope`, composes + validates config, and builds the full
+ * per-run scope — so by the time this handler runs, `currentScope()` carries the
+ * tool's subscope (`scope.fitness`/…), the check/recipe registries, project
+ * context, and `toolConfig` exactly as an in-process run (ADR-0054 M4-C `scope`
+ * mapping: "the worker re-bootstraps its OWN scope … exactly like graph's
+ * worker"). This is the isolation move — the untrusted runtime loads HERE, in the
+ * worker, never in the host.
+ *
+ * The handler then resolves the dispatched tool from the re-bootstrapped registry
+ * and runs ITS command handler against the WORKER-side `ToolCliContext` shim
+ * (`tool-command-worker-context.ts`): FRR seams (render/json/envelope/raw/error/
+ * exit) record the value and return it once in the {@link ToolCommandResult}; the
+ * host-RPC seams (datastore / egress / SARIF / baselines / toolState / hostPlanes
+ * / report-open / exit-code re-affirm) UPCALL the host over the rpc-reply channel
+ * (the host performs the privileged effect — datastore/network/FS/exit stay
+ * host-owned). Only the live-view seams fail loud (`unsupported-seam`).
+ *
+ * A handler that calls `process.exit`, throws, crashes the native layer, or spins
+ * the event loop is contained: the supervisor turns a premature child exit /
+ * timeout / `error` message into a structured parent-side failure, and the host
+ * process survives.
+ */
+import { type CommandSpec, type WorkerMessage } from '@opensip-cli/core';
+import { type CliCommandsContext } from '../commands/shared.js';
+import type { HostRpcRequest, ToolCommandResult } from './tool-command-dispatch-types.js';
+/**
+ * The worker's IPC message type binding: host-RPC requests stream on the
+ * `progress` arm; the final {@link ToolCommandResult} settles `result`.
+ */
+type DispatchWorkerMessage = WorkerMessage<HostRpcRequest, ToolCommandResult>;
+/**
+ * The testable core: produce the {@link DispatchWorkerMessage} the worker would
+ * post, without touching `process.send`. Never throws — every failure becomes a
+ * structured `error` message (the supervisor rejects on it). Must run inside an
+ * entered scope (the bootstrap enters it for the real subcommand; unit tests wrap
+ * it in `runWithScope`).
+ */
+export declare function runToolCommandWorker(specPath: string): Promise<DispatchWorkerMessage>;
+/**
+ * Run one external tool command headless in this worker and post the slim
+ * {@link ToolCommandResult} (or a structured `error`) over IPC. Never throws to
+ * the caller — every failure becomes an `error` IPC message so the supervisor
+ * rejects cleanly. This is the host CommandSpec handler's body.
+ */
+export declare function executeToolCommandWorker(specPath: string): Promise<void>;
+/**
+ * `__tool-command-worker <specPath>` — the [internal] host subcommand the
+ * dispatch supervisor forks. Mirrors `graphRunWorkerCommandSpec`: `raw-stream`
+ * (it owns its own IPC output surface), `scope: 'project'` (the full bootstrap
+ * runs first), `visibility: 'internal'`. The supervisor passes `--cwd` so the
+ * bootstrap targets the right project. The handler ignores the host `ctx` it is
+ * given (the worker builds its OWN context shim over the bootstrapped scope) and
+ * posts the result over the IPC channel.
+ */
+export declare const toolCommandWorkerCommandSpec: CommandSpec<unknown, CliCommandsContext>;
+export {};
+//# sourceMappingURL=tool-command-worker-entry.d.ts.map

package/dist/bootstrap/tool-command-worker-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-command-worker-entry.d.ts","sourceRoot":"","sources":["../../src/bootstrap/tool-command-worker-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAIH,OAAO,EAKL,KAAK,WAAW,EAKhB,KAAK,aAAa,EACnB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAUhE,OAAO,KAAK,EACV,cAAc,EAEd,iBAAiB,EAElB,MAAM,kCAAkC,CAAC;AAE1C;;;GAGG;AACH,KAAK,qBAAqB,GAAG,aAAa,CAAC,cAAc,EAAE,iBAAiB,CAAC,CAAC;AAuQ9E;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAY3F;AAED;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAG9E;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B,EAAE,WAAW,CAAC,OAAO,EAAE,kBAAkB,CAkBhF,CAAC"}