@opensip-cli/core 0.1.0

package/dist/lib/retry.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Retry with exponential backoff for opensip-cli.
+ * Designed for network calls (e.g., --report-to SARIF POST).
+ */
+export interface RetryOptions {
+    /** Maximum number of attempts (including the first). Default: 3 */
+    maxAttempts?: number;
+    /** Initial delay in ms before first retry. Default: 500 */
+    initialDelayMs?: number;
+    /** Maximum delay in ms. Default: 10000 */
+    maxDelayMs?: number;
+    /** Multiplier for exponential backoff. Default: 2 */
+    backoffMultiplier?: number;
+    /** Called before each retry with attempt number, error, and delay. */
+    onRetry?: (attempt: number, error: Error, delayMs: number) => void;
+}
+/**
+ * Execute an async function with exponential backoff retry.
+ * Throws the last error if all attempts fail.
+ *
+ * @throws {Error} The last error thrown by `fn` after exhausting
+ *   `effectiveMaxAttempts` attempts. Non-Error throws are wrapped in
+ *   an `Error` whose message is `String(value)`.
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+//# sourceMappingURL=retry.d.ts.map

package/dist/lib/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/lib/retry.ts"],"names":[],"mappings":"AACA;;;GAGG;AAEH,MAAM,WAAW,YAAY;IAC3B,mEAAmE;IACnE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,2DAA2D;IAC3D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,0CAA0C;IAC1C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,qDAAqD;IACrD,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,sEAAsE;IACtE,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACpE;AAED;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,CAAC,CAAC,CA2C/F"}

package/dist/lib/retry.js

@@ -0,0 +1,48 @@
+// @fitness-ignore-file performance-anti-patterns -- sequential await is the entire point of a retry/backoff loop; running attempts in parallel would defeat retry semantics
+/**
+ * Retry with exponential backoff for opensip-cli.
+ * Designed for network calls (e.g., --report-to SARIF POST).
+ */
+/**
+ * Execute an async function with exponential backoff retry.
+ * Throws the last error if all attempts fail.
+ *
+ * @throws {Error} The last error thrown by `fn` after exhausting
+ *   `effectiveMaxAttempts` attempts. Non-Error throws are wrapped in
+ *   an `Error` whose message is `String(value)`.
+ */
+export async function withRetry(fn, options = {}) {
+    const { maxAttempts = 3, initialDelayMs = 500, maxDelayMs = 10_000, backoffMultiplier = 2, onRetry, } = options;
+    // Floor defensively against zero/negative/NaN/non-integer values. Math.max(1, NaN)
+    // returns NaN per spec, so an unguarded `Math.max(1, maxAttempts)` would let
+    // NaN reach the loop condition (attempt <= NaN is false) and throw
+    // `undefined` for `lastError!`. Compare against effectiveMaxAttempts everywhere
+    // so the original maxAttempts can never re-enter the comparison.
+    const effectiveMaxAttempts = Number.isFinite(maxAttempts)
+        ? Math.max(1, Math.floor(maxAttempts))
+        : 1;
+    let lastError;
+    for (let attempt = 1; attempt <= effectiveMaxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (attempt >= effectiveMaxAttempts)
+                break;
+            // Exponential backoff with jitter
+            const baseDelay = initialDelayMs * Math.pow(backoffMultiplier, attempt - 1);
+            const jitter = Math.random() * baseDelay * 0.5;
+            const delay = Math.min(baseDelay + jitter, maxDelayMs);
+            onRetry?.(attempt, lastError, delay);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+    }
+    // `lastError` is always assigned before reaching here: the loop runs
+    // `effectiveMaxAttempts >= 1` times and assigns `lastError` on every catch
+    // path before the loop terminates. Guard explicitly for type-safety.
+    if (!lastError)
+        throw new Error('withRetry: unreachable — no attempts ran');
+    throw lastError;
+}
+//# sourceMappingURL=retry.js.map

package/dist/lib/retry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.js","sourceRoot":"","sources":["../../src/lib/retry.ts"],"names":[],"mappings":"AAAA,4KAA4K;AAC5K;;;GAGG;AAeH;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAAI,EAAoB,EAAE,UAAwB,EAAE;IACjF,MAAM,EACJ,WAAW,GAAG,CAAC,EACf,cAAc,GAAG,GAAG,EACpB,UAAU,GAAG,MAAM,EACnB,iBAAiB,GAAG,CAAC,EACrB,OAAO,GACR,GAAG,OAAO,CAAC;IAEZ,mFAAmF;IACnF,6EAA6E;IAC7E,mEAAmE;IACnE,gFAAgF;IAChF,iEAAiE;IACjE,MAAM,oBAAoB,GAAG,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC;QACvD,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC,CAAC;IACN,IAAI,SAA4B,CAAC;IAEjC,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,oBAAoB,EAAE,OAAO,EAAE,EAAE,CAAC;QACjE,IAAI,CAAC;YACH,OAAO,MAAM,EAAE,EAAE,CAAC;QACpB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,SAAS,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;YAEtE,IAAI,OAAO,IAAI,oBAAoB;gBAAE,MAAM;YAE3C,kCAAkC;YAClC,MAAM,SAAS,GAAG,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,iBAAiB,EAAE,OAAO,GAAG,CAAC,CAAC,CAAC;YAC5E,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,SAAS,GAAG,GAAG,CAAC;YAC/C,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,GAAG,MAAM,EAAE,UAAU,CAAC,CAAC;YAEvD,OAAO,EAAE,CAAC,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;YAErC,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC;QAC7D,CAAC;IACH,CAAC;IAED,qEAAqE;IACrE,2EAA2E;IAC3E,qEAAqE;IACrE,IAAI,CAAC,SAAS;QAAE,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;IAC5E,MAAM,SAAS,CAAC;AAClB,CAAC"}

package/dist/lib/run-diagnostics.d.ts

@@ -0,0 +1,64 @@
+/**
+ * RunDiagnostics — the shared, JSON-emittable diagnostics shape carried on a
+ * {@link CommandOutcome} (north-star §5.10, launch).
+ *
+ * Today observability is per-subsystem: graph has OTEL spans, fitness has rich
+ * callbacks, sim has simple progress, and the bootstrap writes loose log lines.
+ * There is no common vocabulary a machine consumer can read. `RunDiagnostics` is
+ * that vocabulary: one structured event stream spanning the uniform tool
+ * lifecycle (discover → load → validate → execute → render → deliver → persist),
+ * a flat metrics-counter map, and a thin bridge to the existing OTEL trace
+ * context.
+ *
+ * The currency is deliberately **minimal-but-extensible** for launch (spec
+ * decision): one `DiagnosticEvent` per lifecycle boundary that already exists,
+ * not a metrics/timer rebuild. The `metrics`/`trace` slots are reserved so later
+ * releases can enrich them without another outer-shape break.
+ *
+ * Serialization-safe by construction: every field is a primitive, a readonly
+ * array of primitives/records, or a plain record — no functions, no class
+ * instances, no clock captured here. The producer (the scope-owned diagnostics
+ * bus, `@opensip-cli/core`) stamps `at` at the emit site; this layer stays
+ * pure (the formatter-purity contract that `SignalEnvelope` also honours).
+ */
+/**
+ * The seven phases of the uniform tool lifecycle (north-star §5.6 / Figure 5),
+ * used to tag every {@link DiagnosticEvent}. A consumer can filter the stream by
+ * phase to answer "what happened during config load?" or "did delivery run?".
+ */
+export type DiagnosticPhase = 'discover' | 'load' | 'validate' | 'execute' | 'render' | 'deliver' | 'persist';
+/** Severity of a single diagnostic event. Independent of signal severity. */
+export type DiagnosticLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * One structured diagnostics event. `at` is an ISO-8601 timestamp supplied by
+ * the emitter (core stays `Date.now()`-free in its pure paths; the bus owns the
+ * clock). `data` is an optional bag of JSON-safe extras (e.g. which plugin
+ * loaded, how many checks matched) — never functions or class instances.
+ */
+export interface DiagnosticEvent {
+    readonly phase: DiagnosticPhase;
+    readonly level: DiagnosticLevel;
+    readonly message: string;
+    readonly at: string;
+    readonly data?: Readonly<Record<string, unknown>>;
+}
+/**
+ * The diagnostics snapshot carried on every {@link CommandOutcome}.
+ *
+ * - `runId` correlates the snapshot with the invocation's logger/runId.
+ * - `events` is the ordered lifecycle stream.
+ * - `metrics` is a flat counter map (e.g. `{ 'plugins.loaded': 3 }`); reserved
+ *   and populated emit-site-by-emit-site as counters are needed.
+ * - `trace` bridges to the existing OTEL span context when telemetry is on
+ *   (`OTEL_EXPORTER_OTLP_ENDPOINT` set); absent otherwise.
+ */
+export interface RunDiagnostics {
+    readonly runId: string;
+    readonly events: readonly DiagnosticEvent[];
+    readonly metrics?: Readonly<Record<string, number>>;
+    readonly trace?: {
+        readonly traceId?: string;
+        readonly spanId?: string;
+    };
+}
+//# sourceMappingURL=run-diagnostics.d.ts.map

package/dist/lib/run-diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-diagnostics.d.ts","sourceRoot":"","sources":["../../src/lib/run-diagnostics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;GAIG;AACH,MAAM,MAAM,eAAe,GACvB,UAAU,GACV,MAAM,GACN,UAAU,GACV,SAAS,GACT,QAAQ,GACR,SAAS,GACT,SAAS,CAAC;AAEd,6EAA6E;AAC7E,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAElE;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACnD;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC;IAC5C,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACpD,QAAQ,CAAC,KAAK,CAAC,EAAE;QACf,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;KAC1B,CAAC;CACH"}

package/dist/lib/run-diagnostics.js

@@ -0,0 +1,25 @@
+/**
+ * RunDiagnostics — the shared, JSON-emittable diagnostics shape carried on a
+ * {@link CommandOutcome} (north-star §5.10, launch).
+ *
+ * Today observability is per-subsystem: graph has OTEL spans, fitness has rich
+ * callbacks, sim has simple progress, and the bootstrap writes loose log lines.
+ * There is no common vocabulary a machine consumer can read. `RunDiagnostics` is
+ * that vocabulary: one structured event stream spanning the uniform tool
+ * lifecycle (discover → load → validate → execute → render → deliver → persist),
+ * a flat metrics-counter map, and a thin bridge to the existing OTEL trace
+ * context.
+ *
+ * The currency is deliberately **minimal-but-extensible** for launch (spec
+ * decision): one `DiagnosticEvent` per lifecycle boundary that already exists,
+ * not a metrics/timer rebuild. The `metrics`/`trace` slots are reserved so later
+ * releases can enrich them without another outer-shape break.
+ *
+ * Serialization-safe by construction: every field is a primitive, a readonly
+ * array of primitives/records, or a plain record — no functions, no class
+ * instances, no clock captured here. The producer (the scope-owned diagnostics
+ * bus, `@opensip-cli/core`) stamps `at` at the emit site; this layer stays
+ * pure (the formatter-purity contract that `SignalEnvelope` also honours).
+ */
+export {};
+//# sourceMappingURL=run-diagnostics.js.map

package/dist/lib/run-diagnostics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-diagnostics.js","sourceRoot":"","sources":["../../src/lib/run-diagnostics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG"}

package/dist/lib/run-scope.d.ts

@@ -0,0 +1,167 @@
+/**
+ * @fileoverview RunScope — per-invocation execution scope.
+ *
+ * Owns the lifecycle of every singleton the codebase previously hung on
+ * module-level state (logger, caches, registries, recipe-config slot,
+ * project context, datastore thunk). Constructed exactly once per CLI
+ * invocation; SaaS hosts construct one per concurrent run.
+ *
+ * Threading happens at the `ToolCliContext` boundary (Phase 5). Tools
+ * read `cli.scope.foo` instead of reaching into module globals.
+ *
+ * AsyncLocalStorage seam: `runWithScope(scope, fn)` binds `scope` as
+ * the current scope for the dynamic extent of `fn`. Library functions
+ * deep inside the call tree (e.g. fitness's `getCheckConfig(slug)`)
+ * read from `currentScope()` instead of `globalThis`. The two-copies-of-
+ * fitness hazard documented at the prior `Symbol.for(globalThis)` site
+ * is solved by ALS — both fitness copies share the same
+ * `AsyncLocalStorage` instance exported from `@opensip-cli/core`.
+ */
+import { LanguageParseCache } from '../languages/parse-cache-class.js';
+import { LanguageRegistry } from '../languages/registry.js';
+import { ToolRegistry } from '../tools/registry.js';
+import { DiagnosticsBus } from './diagnostics-bus.js';
+import type { Logger } from './logger.js';
+import type { ProjectContext } from './project-context.js';
+import type { DataStoreThunk, RecipeUnitConfigSlot, ToolScope } from './scope-types.js';
+import type { UiContext } from './ui-context.js';
+import type { SignalSink } from '../signals/signal-sink.js';
+import type { ToolPluginManifest, ToolProvenance } from '../tools/manifest.js';
+/** Constructor input for {@link RunScope}: registries, services, and per-run identifiers. */
+export interface RunScopeOptions {
+    readonly logger?: Logger;
+    readonly parseCache?: LanguageParseCache;
+    readonly projectContext?: ProjectContext;
+    readonly datastore?: DataStoreThunk;
+    readonly tools?: ToolRegistry;
+    readonly languages?: LanguageRegistry;
+    /**
+     * Per-invocation presentation settings (banner size, CLI version) read
+     * by the render paths. Optional: tests and non-rendering callers omit it,
+     * in which case `RunScope.ui` is `undefined` and render sites apply their
+     * own defaults (banner → `lg`, version → empty).
+     */
+    readonly ui?: UiContext;
+    /**
+     * Correlation id for the current CLI invocation. D7 designates this a
+     * KERNEL concern (every invocation has one) — it stays flat on the
+     * scope rather than under a tool subnamespace. The CLI bootstrap
+     * generates it via `generatePrefixedId('run')` and passes it here;
+     * the logger reads it back via `currentScope()?.runId` for
+     * event-stamping. Optional in `RunScopeOptions` (tests can construct
+     * a bare scope) but if omitted, `RunScope.runId` is the empty string
+     * — matching the prior logger-singleton reset value used in
+     * `configureLogger({ runId: '' })`. Production paths always supply
+     * a non-empty id via the pre-action-hook.
+     */
+    readonly runId?: string;
+    /**
+     * Cloud signal sink for this invocation (ADR-0008). Defaults to
+     * `noopSignalSink` — the CLI bootstrap sets the OpenSIP Cloud sink only
+     * when an API key resolves and entitlement is positive. No module-level
+     * state: selection is always explicit at the composition root.
+     */
+    readonly signalSink?: SignalSink;
+    /**
+     * The manifests of the tools admitted through the compatibility gate this
+     * run, in registration order. Recorded by the CLI bootstrap and stamped on
+     * the scope so host commands (`tools list`) read them via `currentScope()`
+     * instead of a module global. Defaults to `[]` (no tools admitted — e.g. an
+     * isolated test scope). HOST-only: tools never read these, so they live on
+     * `RunScope`, not the tool-facing `ToolScope`.
+     */
+    readonly toolManifests?: readonly ToolPluginManifest[];
+    /**
+     * The provenance records of the tools admitted this run (source, identity,
+     * manifest hash), paired index-wise with {@link toolManifests}. Recorded by
+     * the CLI bootstrap and stamped on the scope so host commands (`plugin list`,
+     * `tools list`, `tools uninstall`) read them via `currentScope()` rather than
+     * a module global. Defaults to `[]`.
+     */
+    readonly toolProvenance?: readonly ToolProvenance[];
+}
+/**
+ * Per-invocation execution scope.
+ *
+ * Construct exactly once per CLI invocation. Pass via
+ * `ToolCliContext.scope` (Phase 5). Tools read `cli.scope.foo`
+ * instead of reaching into module globals (the T1 invariant).
+ *
+ * Defaults: when no overrides are provided, the scope wires up the
+ * default `Logger`, a fresh `LanguageParseCache`, and FRESH empty
+ * `ToolRegistry` / `LanguageRegistry` instances. The CLI bootstrap
+ * constructs and populates one pair per run and passes them in via
+ * `RunScopeOptions` so language adapters and tool plugins land where
+ * `currentScope()?.languages` / `.tools` will find them. Tests that
+ * exercise registry-aware code paths must either construct a populated
+ * registry and pass it in, or register fixtures into `scope.languages`
+ * inside the test body's `runWithScope` block.
+ */
+export declare class RunScope {
+    readonly logger: Logger;
+    readonly parseCache: LanguageParseCache;
+    readonly recipeUnitConfig: RecipeUnitConfigSlot;
+    readonly projectContext: ProjectContext | undefined;
+    readonly datastore: DataStoreThunk;
+    readonly tools: ToolRegistry;
+    readonly languages: LanguageRegistry;
+    /** Per-invocation presentation settings; `undefined` outside the CLI render path. */
+    readonly ui: UiContext | undefined;
+    /**
+     * Correlation id for the current invocation. Read by the logger via
+     * `currentScope()?.runId` for event-stamping. Empty string when no
+     * caller supplied one (matches the prior singleton reset semantics —
+     * the logger's `formatEntry` only emits a `runId` field when truthy).
+     */
+    readonly runId: string;
+    /** Cloud signal sink for this invocation; `noopSignalSink` unless cloud sync is on. */
+    readonly signalSink: SignalSink;
+    /**
+     * Per-invocation diagnostics collector (north-star §5.10, launch).
+     * Library code emits lifecycle events via `currentScope()?.diagnostics`; the
+     * host assembler snapshots it onto every `CommandOutcome`. Scope-owned so
+     * concurrent runs share no diagnostics state (the no-module-singleton rule).
+     */
+    readonly diagnostics: DiagnosticsBus;
+    /**
+     * Manifests of the tools admitted this run (registration order). Empty unless
+     * the CLI bootstrap recorded them. Read by host commands via `currentScope()`.
+     */
+    readonly toolManifests: readonly ToolPluginManifest[];
+    /**
+     * Provenance of the tools admitted this run, paired index-wise with
+     * {@link toolManifests}. Empty unless the CLI bootstrap recorded them.
+     */
+    readonly toolProvenance: readonly ToolProvenance[];
+    constructor(opts?: RunScopeOptions);
+    /** Release per-run resources (caches, recipe-config slot). */
+    dispose(): void;
+}
+/**
+ * Declaration-merge: `RunScope` IS-A `ToolScope` (the Tool-facing view)
+ * plus the `tools` registry it adds. Extending `ToolScope` here also
+ * brings in the augmentable `ScopeContribution` slots, so
+ * `currentScope()?.simulation` / `?.graph` stay readable on a RunScope.
+ * Tools augment `ScopeContribution` (not `RunScope`) from their own
+ * packages; the slots flow in through `ToolScope extends ScopeContribution`.
+ */
+export interface RunScope extends ToolScope {
+}
+/** Run `fn` with `scope` bound as the current scope for everything in its dynamic extent. */
+export declare function runWithScope<T>(scope: RunScope, fn: () => Promise<T>): Promise<T>;
+/** Synchronous variant of `runWithScope`. */
+export declare function runWithScopeSync<T>(scope: RunScope, fn: () => T): T;
+/**
+ * Set `scope` as the current scope for the rest of the calling async
+ * context — without needing a callback wrapper. Backed by
+ * `AsyncLocalStorage.enterWith`. Use this in Commander's `preAction`
+ * hook where the action body runs after the hook returns but in the
+ * same async chain: `enterWith` propagates the scope forward without
+ * needing to wrap the action invocation, which Commander does not let
+ * us do directly. Throws on misuse: an existing scope must NOT be
+ * replaced silently (call `runWithScope` for nested scopes).
+ */
+export declare function enterScope(scope: RunScope): void;
+/** Read the current scope. Returns undefined when called outside a runWithScope. */
+export declare function currentScope(): RunScope | undefined;
+//# sourceMappingURL=run-scope.d.ts.map

package/dist/lib/run-scope.d.ts.map

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

package/dist/lib/run-scope.js

@@ -0,0 +1,176 @@
+/**
+ * @fileoverview RunScope — per-invocation execution scope.
+ *
+ * Owns the lifecycle of every singleton the codebase previously hung on
+ * module-level state (logger, caches, registries, recipe-config slot,
+ * project context, datastore thunk). Constructed exactly once per CLI
+ * invocation; SaaS hosts construct one per concurrent run.
+ *
+ * Threading happens at the `ToolCliContext` boundary (Phase 5). Tools
+ * read `cli.scope.foo` instead of reaching into module globals.
+ *
+ * AsyncLocalStorage seam: `runWithScope(scope, fn)` binds `scope` as
+ * the current scope for the dynamic extent of `fn`. Library functions
+ * deep inside the call tree (e.g. fitness's `getCheckConfig(slug)`)
+ * read from `currentScope()` instead of `globalThis`. The two-copies-of-
+ * fitness hazard documented at the prior `Symbol.for(globalThis)` site
+ * is solved by ALS — both fitness copies share the same
+ * `AsyncLocalStorage` instance exported from `@opensip-cli/core`.
+ */
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { LanguageParseCache } from '../languages/parse-cache-class.js';
+import { LanguageRegistry } from '../languages/registry.js';
+import { noopSignalSink } from '../signals/signal-sink.js';
+import { ToolRegistry } from '../tools/registry.js';
+import { DiagnosticsBus } from './diagnostics-bus.js';
+import { logger as defaultLogger } from './logger.js';
+// RecipeUnitConfigSlot, DataStoreThunk, ToolScope, and ScopeContribution
+// live in the leaf `scope-types.ts` (audit 2026-05-29, M4) so the `Tool`
+// contract can depend on them without naming the concrete `RunScope` —
+// breaking the RunScope⟷Tool type cycle. The core barrel sources them
+// directly from `scope-types.ts`; `run-scope.ts` imports what it needs below.
+class DefaultRecipeUnitConfigSlot {
+    store = {};
+    get(slug) {
+        return this.store[slug];
+    }
+    set(slug, config) {
+        this.store[slug] = config;
+    }
+    setAll(config) {
+        this.store = { ...config };
+    }
+    clear() {
+        this.store = {};
+    }
+}
+/**
+ * Per-invocation execution scope.
+ *
+ * Construct exactly once per CLI invocation. Pass via
+ * `ToolCliContext.scope` (Phase 5). Tools read `cli.scope.foo`
+ * instead of reaching into module globals (the T1 invariant).
+ *
+ * Defaults: when no overrides are provided, the scope wires up the
+ * default `Logger`, a fresh `LanguageParseCache`, and FRESH empty
+ * `ToolRegistry` / `LanguageRegistry` instances. The CLI bootstrap
+ * constructs and populates one pair per run and passes them in via
+ * `RunScopeOptions` so language adapters and tool plugins land where
+ * `currentScope()?.languages` / `.tools` will find them. Tests that
+ * exercise registry-aware code paths must either construct a populated
+ * registry and pass it in, or register fixtures into `scope.languages`
+ * inside the test body's `runWithScope` block.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging -- intentional: the class merges with the `interface RunScope extends ToolScope` below to gain the augmentable ScopeContribution slots for reading. The slots are optional and runtime-installed via Object.assign (the kernel's contributeScope loop), so the "interface declares members the class lacks" warning is the desired, safe behavior here.
+export class RunScope {
+    logger;
+    parseCache;
+    recipeUnitConfig;
+    projectContext;
+    datastore;
+    tools;
+    languages;
+    /** Per-invocation presentation settings; `undefined` outside the CLI render path. */
+    ui;
+    /**
+     * Correlation id for the current invocation. Read by the logger via
+     * `currentScope()?.runId` for event-stamping. Empty string when no
+     * caller supplied one (matches the prior singleton reset semantics —
+     * the logger's `formatEntry` only emits a `runId` field when truthy).
+     */
+    runId;
+    /** Cloud signal sink for this invocation; `noopSignalSink` unless cloud sync is on. */
+    signalSink;
+    /**
+     * Per-invocation diagnostics collector (north-star §5.10, launch).
+     * Library code emits lifecycle events via `currentScope()?.diagnostics`; the
+     * host assembler snapshots it onto every `CommandOutcome`. Scope-owned so
+     * concurrent runs share no diagnostics state (the no-module-singleton rule).
+     */
+    diagnostics;
+    /**
+     * Manifests of the tools admitted this run (registration order). Empty unless
+     * the CLI bootstrap recorded them. Read by host commands via `currentScope()`.
+     */
+    toolManifests;
+    /**
+     * Provenance of the tools admitted this run, paired index-wise with
+     * {@link toolManifests}. Empty unless the CLI bootstrap recorded them.
+     */
+    toolProvenance;
+    constructor(opts = {}) {
+        this.logger = opts.logger ?? defaultLogger;
+        this.parseCache = opts.parseCache ?? new LanguageParseCache();
+        this.recipeUnitConfig = new DefaultRecipeUnitConfigSlot();
+        this.projectContext = opts.projectContext;
+        // eslint-disable-next-line unicorn/no-useless-undefined -- explicit no-store sentinel matches the prior `cli.datastore` contract (tools cast to `DataStore | undefined`).
+        this.datastore = opts.datastore ?? (() => undefined);
+        this.tools = opts.tools ?? new ToolRegistry();
+        this.languages = opts.languages ?? new LanguageRegistry();
+        this.ui = opts.ui;
+        this.runId = opts.runId ?? '';
+        this.signalSink = opts.signalSink ?? noopSignalSink;
+        this.diagnostics = new DiagnosticsBus(this.runId);
+        this.toolManifests = opts.toolManifests ?? [];
+        this.toolProvenance = opts.toolProvenance ?? [];
+    }
+    /** Release per-run resources (caches, recipe-config slot). */
+    dispose() {
+        this.parseCache.dispose();
+        this.recipeUnitConfig.clear();
+        // FileCache lifecycle is owned by fitness; not on RunScope.
+        // datastore close is the consumer's responsibility — RunScope
+        // doesn't open it eagerly.
+    }
+}
+// ─── AsyncLocalStorage seam ──────────────────────────────────────────
+//
+// `runWithScope(scope, fn)` binds `scope` for the dynamic extent of
+// `fn`. Library functions read `currentScope()` instead of any
+// module global.
+//
+// Both copies of a package import the same `AsyncLocalStorage`
+// instance from this module — so the slot identity is bound to core,
+// not to whichever package is reading from it. This solves the
+// two-copies-of-fitness hazard documented at the prior
+// `Symbol.for(globalThis)` site.
+const scopeStorage = new AsyncLocalStorage();
+/** Run `fn` with `scope` bound as the current scope for everything in its dynamic extent. */
+export function runWithScope(scope, fn) {
+    return scopeStorage.run(scope, fn);
+}
+/** Synchronous variant of `runWithScope`. */
+export function runWithScopeSync(scope, fn) {
+    return scopeStorage.run(scope, fn);
+}
+/**
+ * Set `scope` as the current scope for the rest of the calling async
+ * context — without needing a callback wrapper. Backed by
+ * `AsyncLocalStorage.enterWith`. Use this in Commander's `preAction`
+ * hook where the action body runs after the hook returns but in the
+ * same async chain: `enterWith` propagates the scope forward without
+ * needing to wrap the action invocation, which Commander does not let
+ * us do directly. Throws on misuse: an existing scope must NOT be
+ * replaced silently (call `runWithScope` for nested scopes).
+ */
+export function enterScope(scope) {
+    scopeStorage.enterWith(scope);
+}
+/** Read the current scope. Returns undefined when called outside a runWithScope. */
+export function currentScope() {
+    return scopeStorage.getStore();
+}
+// ─── Logger ↔ RunScope wiring ────────────────────────────────────────
+//
+// Inject `currentScope()?.runId` as the logger singleton's runId source
+// at module init. The logger module itself cannot import from this file
+// (run-scope already imports logger, so the reverse direction would
+// produce a cycle that depcruise rejects). The wiring lives here, where
+// both symbols are already in scope.
+//
+// `defaultLogger` is typed as `Logger` (a narrow interface) so we
+// type-assert to `LoggerImpl` to reach the `setRunIdProvider` setter —
+// the singleton is always a `LoggerImpl` (see logger.ts), so this is
+// a structural narrowing, not a behavioural cast.
+defaultLogger.setRunIdProvider(() => currentScope()?.runId);
+//# sourceMappingURL=run-scope.js.map

package/dist/lib/run-scope.js.map

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

package/dist/lib/run-timer.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @fileoverview Host-owned RunTimer / RunLifecycle primitive
+ * (host-owned-run-timing plan).
+ *
+ * Single source of truth for wall-clock start + monotonic elapsed for one
+ * user-visible CLI tool run. The host run-lifecycle plane creates one lifecycle
+ * inside the selected command action (after `RunScope` entry, before any
+ * tool-owned work) and `complete()`s it once the tool handler / live renderer
+ * returns its completion data — that frozen snapshot feeds the generic
+ * `StoredSession.startedAt` / `completedAt` / `durationMs`.
+ *
+ * Tools and engines must never capture their own `Date.now` / `new Date` for
+ * the generic session timing fields; only the host lifecycle feeds those.
+ * Internal tool timers (per-unit, per-stage, etc.) remain tool-owned for
+ * diagnostics.
+ *
+ * `startedAt` is ISO wall time captured at construction. `complete()` is
+ * idempotent: the first call freezes `completedAt` + `durationMs`; later calls
+ * return the same frozen snapshot. `snapshot()` reads live before completion
+ * (for the ticking live display) and the frozen values after. Elapsed uses a
+ * monotonic clock (`performance.now` when available) to avoid skew on long runs
+ * or system clock adjustments.
+ */
+export interface RunTimingSnapshot {
+    /** ISO-8601 timestamp of run start (wall time, captured early by host). */
+    readonly startedAt: string;
+    /** ISO-8601 timestamp captured at the moment of this snapshot. */
+    readonly completedAt: string;
+    /** Wall duration in milliseconds (>= 0). */
+    readonly durationMs: number;
+}
+/**
+ * Host-owned run timer: the single source of run start time and wall duration
+ * for a tool invocation. Tools read timing through `ToolCliContext.runSession`
+ * rather than capturing their own `Date.now()` (see the
+ * `no-tool-owned-session-timing` check).
+ */
+export interface RunTimer {
+    /** ISO-8601 timestamp of run start (fixed for the lifetime of this timer). */
+    readonly startedAt: string;
+    /** Epoch ms at start (for fallback elapsed calculations). */
+    readonly startedAtEpochMs: number;
+    /**
+     * Current elapsed wall time since start, in ms.
+     * Uses monotonic source when available; clamped to >= 0.
+     */
+    elapsedMs(): number;
+    /**
+     * Capture a point-in-time snapshot. `startedAt` is stable; `completedAt`
+     * and `durationMs` reflect now — unless the lifecycle has already been
+     * `complete()`d, in which case the frozen completion snapshot is returned.
+     */
+    snapshot(): RunTimingSnapshot;
+    /**
+     * Freeze the run lifecycle. Idempotent: the first call captures
+     * `completedAt` + `durationMs`; subsequent calls return the same frozen
+     * snapshot. The host run-lifecycle plane calls this once the tool handler /
+     * live renderer has returned, before host persistence / render / egress.
+     */
+    complete(): RunTimingSnapshot;
+}
+/**
+ * The run lifecycle object the host owns for a single tool invocation
+ * (host-owned-run-timing §6.1). Structurally identical to {@link RunTimer};
+ * the alias gives the spec-named type and creator without churning the many
+ * existing `RunTimer` references.
+ */
+export type RunLifecycle = RunTimer;
+/**
+ * Create a fresh host-owned run timer.
+ *
+ * Must be called by the CLI host after `RunScope` is entered (so `runId` etc.
+ * are available for logging in Phase 1 wiring) but before any tool work that
+ * will be timed.
+ */
+export declare function createRunTimer(): RunTimer;
+/**
+ * Create a fresh host-owned run lifecycle. Alias of {@link createRunTimer}
+ * under the spec-named factory (host-owned-run-timing §6.1).
+ */
+export declare const createRunLifecycle: () => RunLifecycle;
+//# sourceMappingURL=run-timer.d.ts.map

package/dist/lib/run-timer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-timer.d.ts","sourceRoot":"","sources":["../../src/lib/run-timer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,WAAW,iBAAiB;IAChC,2EAA2E;IAC3E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,kEAAkE;IAClE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,4CAA4C;IAC5C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;GAKG;AACH,MAAM,WAAW,QAAQ;IACvB,8EAA8E;IAC9E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,6DAA6D;IAC7D,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAElC;;;OAGG;IACH,SAAS,IAAI,MAAM,CAAC;IAEpB;;;;OAIG;IACH,QAAQ,IAAI,iBAAiB,CAAC;IAE9B;;;;;OAKG;IACH,QAAQ,IAAI,iBAAiB,CAAC;CAC/B;AAED;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC;AAEpC;;;;;;GAMG;AACH,wBAAgB,cAAc,IAAI,QAAQ,CAkDzC;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,YAA6B,CAAC"}