@opensip-cli/graph 0.1.0

package/dist/cli/graph-runner.js

@@ -0,0 +1,274 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * graph-runner — owns the live-view state machine for `opensip graph`.
+ *
+ * Layer 5 Phase 3 lifted the graph live view out of `opensip-cli`.
+ * The state machine (loading → running → done | error), `runGraph`
+ * orchestration, `buildUnifiedReportLines` post-call, and the Ink/React
+ * render tree live here, in the package that owns the graph command
+ * surface. Adding a fourth tool with a live view requires zero CLI
+ * edits — each tool ships its own renderer and registers it via
+ * `cli.registerLiveView(key, renderer)`.
+ *
+ * Progress rendering is the shared `<LiveProgress>` from
+ * `@opensip-cli/cli-ui` (ADR-0016), driven in `phases` mode: graph's
+ * 7 fixed pipeline stages map onto the universal `ProgressEvent` stream.
+ * The former graph-local StageChecklist/StageLine/RunningStageLine are
+ * gone. The build runs OFF the main process (ADR-0028): the runner forks
+ * the CLI to `graph-run-worker` via `runOffThreadOrInProcess`, which
+ * re-bootstraps the scope, runs the heavy build, and streams stage progress
+ * + the slim {@link LiveGraphOutput} back over IPC — so this process stays
+ * free to animate the spinner + 80ms clock instead of freezing under the
+ * type-check. It falls back to the in-process closure when forking is
+ * disabled (`OPENSIP_CLI_NO_WORKER`) or the fork fails; both paths reduce
+ * to the same `{ signals, reportLines }` payload.
+ *
+ * Single exit-code write path: error outcomes route through the
+ * supplied `setExitCode` callback (`ToolCliContext.setExitCode`) so the
+ * CLI keeps its only `process.exitCode` mutator.
+ */
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { Banner, ClockProvider, ErrorMessage, LiveProgress, normalizeBannerSize, ProjectHeader, renderToInk, RunFooterHints, RunHeader, RunSummary, RunTimingProvider, ThemeProvider, UpdateHint, VERBOSE_DETAIL_HINT, viewVerboseLines, } from '@opensip-cli/cli-ui';
+import { runOffThreadOrInProcess, currentScope, } from '@opensip-cli/core';
+import { Box, Text, useApp, render } from 'ink';
+import { useEffect, useState } from 'react';
+import { assertFinalizedAcrossBoundary } from './apply-suppressions.js';
+import { buildGraphEnvelope } from './build-envelope.js';
+import { SHARDED_STAGE_LABELS, STAGE_LABELS, toProgressEvent } from './graph-progress.js';
+import { buildLiveGraphOutput, contributionFromSignals, evaluatedRuleSlugs, runShardedLiveBuild, } from './graph.js';
+import { GRAPH_STAGES, runGraph } from './orchestrate.js';
+const GRAPH_TOOL_TITLE = 'Code Graph';
+const GRAPH_TOOL_DESCRIPTION = 'Building call-graph from source';
+const STAGE_RUNNING_DETAIL = {
+    discover: 'Scanning source tree...',
+    parse: 'Building program AST...',
+    walk: 'Walking files for occurrences...',
+    resolve: 'Binding symbols to edges...',
+    index: 'Computing reverse indexes...',
+    features: 'Computing feature columns...',
+    rules: 'Evaluating rule set...',
+};
+// Sharded-engine running sub-labels — mirror SHARDED_STAGE_LABELS: the parallel
+// shard build (parse), the fragment merge (walk), the cross-package link (resolve).
+const SHARDED_STAGE_RUNNING_DETAIL = {
+    ...STAGE_RUNNING_DETAIL,
+    parse: 'Building shards in parallel...',
+    walk: 'Merging shard fragments...',
+    resolve: 'Linking cross-package calls...',
+};
+// The phases surface the shared renderer consumes: graph's fixed, ordered stages,
+// each carrying its checklist label + running sub-label. Engine-aware: the sharded
+// pipeline names its stages for what they actually do (Build shards / Merge catalog
+// / Link cross-package) so the checklist reflects the real parallel build, not the
+// single-program "Parse / Walk / Resolve" shape.
+function graphSurface(sharded) {
+    const labels = sharded ? SHARDED_STAGE_LABELS : STAGE_LABELS;
+    const runningDetail = sharded ? SHARDED_STAGE_RUNNING_DETAIL : STAGE_RUNNING_DETAIL;
+    return {
+        shape: 'phases',
+        stages: GRAPH_STAGES.map((id) => ({
+            id,
+            label: labels[id],
+            runningDetail: runningDetail[id],
+        })),
+    };
+}
+/** Run the pipeline through the in-process transport, mapping graph events to the
+ *  shared progress currency and reducing the result to the slim, serializable
+ *  {@link LiveGraphOutput} the done handler consumes — IDENTICAL to what the
+ *  off-process worker streams back, so both paths converge on one payload shape.
+ *  Hoisted to module scope so the emit translation isn't a deeply-nested function
+ *  inside the runner's effect. */
+async function runGraphWithProgress(args, datastore, emit) {
+    const result = await runGraph({
+        cwd: args.cwd,
+        noCache: args.noCache,
+        resolution: args.resolution,
+        config: args.config,
+        rules: args.rules,
+        datastore,
+        onProgress: (event) => emit(toProgressEvent(event)),
+    });
+    // The interactive live view is whole-project against cwd, so cwd is the build
+    // root the signals' code.file paths resolve against — pass it as the
+    // suppression base so the in-process leg waives `@graph-ignore` identically to
+    // the static path (and to the off-process worker, which uses args.cwd too).
+    return buildLiveGraphOutput(result, args.cwd);
+}
+function GraphRunner({ args, datastore, setExitCode, onSession, liveContext, }) {
+    const { exit } = useApp();
+    const [state, setState] = useState({ phase: 'loading' });
+    // Engine policy (ADR-0032): sharded is the default, `--exact` opts out. The
+    // engine is selected upstream and handed to us as `args.shards` (length > 1 ⇒
+    // sharded). Drives BOTH the run transport (in-process vs off-process worker)
+    // and the engine-aware checklist labels below. `isTTY` never affects it.
+    const sharded = (args.shards?.length ?? 0) > 1;
+    useEffect(() => {
+        let cancelled = false;
+        // Local clock removed for session timing (host RunTimer via liveContext.runSession).
+        // Graph keeps its internal stage/partition clocks for profile if needed.
+        // Engine policy (ADR-0032): the SHARDED engine is the default; `--exact`
+        // opts out. The engine is selected upstream on the dispatch seam (which holds
+        // the `cli` context) and handed to us as `args.shards` — `length > 1` ⇒
+        // sharded. `isTTY` NEVER affects this decision; we are only choosing the
+        // RENDERER's transport here, not the engine.
+        //
+        //   - SHARDED (default): run IN-PROCESS. Its shards are already subprocesses,
+        //     so the heavy parse/walk/resolve is off the render thread and the main
+        //     thread stays free to animate the checklist + 80ms clock while it awaits
+        //     the (I/O-bound) shard pool. No `graph-run-worker` fork needed.
+        //   - EXACT (`--exact` / not-shardable fallback): run the single-program build
+        //     OFF the main process (ADR-0028) — fork the CLI to `graph-run-worker`,
+        //     which streams stage progress + the slim LiveGraphOutput over IPC, so the
+        //     heavy in-process type-check never freezes the spinner. Falls back to the
+        //     in-process closure (OPENSIP_CLI_NO_WORKER / fork failure), which
+        //     reduces to the SAME LiveGraphOutput.
+        //
+        // Both transports converge on one `LiveGraphOutput` — already crossed the
+        // single suppression chokepoint (`buildLiveGraphOutput` → `finalizeGraphSignals`).
+        const specDir = mkdtempSync(join(tmpdir(), 'graph-worker-'));
+        const specPath = join(specDir, 'spec.json');
+        writeFileSync(specPath, JSON.stringify({
+            cwd: args.cwd,
+            noCache: args.noCache,
+            resolution: args.resolution,
+            ...(args.recipe === undefined ? {} : { recipe: args.recipe }),
+        }), 'utf8');
+        const run = runOffThreadOrInProcess({
+            // Sharded runs in-process (shards are already subprocesses); exact forks the
+            // off-process worker. `preferWorker:false` forces the in-process arm for the
+            // sharded path — the descriptor is unused there but still required by the API.
+            preferWorker: !sharded,
+            descriptor: { command: process.argv[1] ?? '', argv: ['graph-run-worker', specPath] },
+            inProcess: (emit) => sharded
+                ? runShardedLiveBuild({
+                    cwd: args.cwd,
+                    noCache: args.noCache,
+                    resolution: args.resolution,
+                    exact: args.exact,
+                    config: args.config,
+                    rules: args.rules,
+                    cliScript: process.argv[1],
+                }, args.shards ?? [], datastore, (event) => emit(toProgressEvent(event, true)))
+                : runGraphWithProgress(args, datastore, emit),
+        });
+        setState({ phase: 'running', subscribe: run.onProgress });
+        void (async () => {
+            try {
+                let result;
+                try {
+                    result = await run.result;
+                }
+                finally {
+                    rmSync(specDir, { recursive: true, force: true });
+                }
+                if (cancelled)
+                    return;
+                // `result` already crossed the single suppression chokepoint inside the
+                // producer (`buildLiveGraphOutput` → `finalizeGraphSignals`), but the
+                // IPC structured-clone dropped the FinalizedSignals brand. Re-stamp it
+                // here — an assertion of the prior finalize, NOT a second suppression —
+                // so the host record (and the verdict) consume the branded, already-waived signals.
+                const finalized = assertFinalizedAcrossBoundary(result.signals, result.suppressedCount);
+                // Host-owned persistence (host-owned-run-timing Phase 2): surface the
+                // contribution built from the finalized (branded, already-waived)
+                // signals; the host persists after the live view exits. Timing is
+                // host-stamped from the lifecycle.
+                //
+                // Use the SHARED contribution builder (the same one the static
+                // `executeGraph` dispatch uses) and feed it the run's evaluated rule set
+                // (`args.rules`, falling back to the scope registry — exactly what
+                // `runGraph` ran). This is what makes a CLEAN interactive run record a
+                // PASS row per rule, so the report's graph session detail shows the full
+                // rule list instead of an empty "no results" panel — parity with fit.
+                onSession?.(contributionFromSignals({ cwd: args.cwd, recipe: args.recipe }, finalized.signals, evaluatedRuleSlugs(args.rules)));
+                // Compute the summary for TTY (duration omitted; provider supplies host value).
+                const envelope = buildGraphEnvelope({
+                    signals: finalized.signals,
+                    runId: currentScope()?.runId ?? '',
+                    createdAt: new Date().toISOString(),
+                });
+                const { verdict } = envelope;
+                const summary = {
+                    passed: verdict.passed,
+                    errors: verdict.summary.errors,
+                    warnings: verdict.summary.warnings,
+                    // durationMs omitted for host provider path
+                };
+                // The worker (or the in-process fallback) already assembled the report
+                // lines with includeSummary: false — RunSummary renders the verdict
+                // footer in place of the text "== Summary ==" block.
+                const reportLines = result.reportLines;
+                setState((prev) => ({
+                    phase: 'done',
+                    subscribe: prev.phase === 'running' ? prev.subscribe : run.onProgress,
+                    reportLines,
+                    summary,
+                }));
+                setTimeout(() => exit(), 50);
+            }
+            catch (error) {
+                if (cancelled)
+                    return;
+                const message = error instanceof Error ? error.message : String(error);
+                setState({ phase: 'error', message });
+                setExitCode?.(1);
+                setTimeout(() => exit(), 50);
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, []);
+    // Presentation settings resolved once in the pre-action hook; the live view
+    // runs inside that scope. `mini` carries the project path in its box, so the
+    // separate ProjectHeader line is dropped for it (matches App.tsx); walkedUp
+    // flows in so mini keeps the "(found N levels up)" hint.
+    const scope = currentScope();
+    const ui = scope?.ui;
+    const walkedUp = scope?.projectContext?.walkedUp;
+    const bannerSize = normalizeBannerSize(ui?.bannerSize);
+    // --quiet suppresses the banner/header chrome (parity with fit/sim).
+    const header = args.quiet === true ? null : (_jsxs(_Fragment, { children: [_jsx(Banner, { size: bannerSize, version: ui?.version, projectPath: args.cwd, walkedUp: walkedUp, update: ui?.update }), bannerSize === 'mini' && ui?.update !== undefined && _jsx(UpdateHint, {}), bannerSize !== 'mini' && _jsx(ProjectHeader, { root: args.cwd, walkedUp: walkedUp }), _jsx(RunHeader, { tool: GRAPH_TOOL_TITLE, description: GRAPH_TOOL_DESCRIPTION })] }));
+    if (state.phase === 'error') {
+        return (_jsxs(Box, { flexDirection: "column", children: [header, _jsx(ErrorMessage, { message: state.message })] }));
+    }
+    if (state.phase === 'loading') {
+        return (_jsxs(Box, { flexDirection: "column", children: [header, _jsx(Box, { paddingLeft: 2, paddingTop: 1, children: _jsx(Text, { dimColor: true, children: "Initializing pipeline..." }) })] }));
+    }
+    // running | done — the same <LiveProgress> stays mounted across both so its
+    // reduced stage state (the ✓ checklist) persists; the done phase adds the
+    // summary + footer below it.
+    return (_jsxs(Box, { flexDirection: "column", children: [header, _jsx(LiveProgress, { surface: graphSurface(sharded), subscribe: state.subscribe }), state.phase === 'done' && (_jsxs(_Fragment, { children: [args.verbose === true && (_jsx(Box, { flexDirection: "column", paddingTop: 1, children: renderToInk(viewVerboseLines(state.reportLines)) })), (() => {
+                        const el = (_jsx(RunSummary, { passed: state.summary.passed, errors: state.summary.errors, warnings: state.summary.warnings }));
+                        return liveContext?.runSession ? (_jsx(RunTimingProvider, { timer: liveContext.runSession.timing, children: el })) : (el);
+                    })(), args.verbose !== true && (_jsx(RunFooterHints, { hints: [
+                            VERBOSE_DETAIL_HINT,
+                            {
+                                text: 'opensip report for HTML report',
+                                bold: ['opensip report'],
+                            },
+                        ] }))] }))] }));
+}
+/**
+ * Render the live `graph` view. Resolves once the underlying Ink app exits with
+ * a {@link ToolRunCompletion} carrying the run's `session` contribution (the
+ * HOST persists it after this resolves — host-owned-run-timing Phase 2; the
+ * component no longer writes the session itself). Graph's cloud egress lives on
+ * the static gate path, so the live wrapper returns no envelope.
+ *
+ * `setExitCode` is the single mutator path on `process.exitCode`; the runner
+ * calls it for error outcomes so the CLI's exit-code seam stays the only writer.
+ */
+export async function renderGraphLive(args, datastore, options, liveContext) {
+    let session;
+    const app = render(_jsx(ThemeProvider, { children: _jsx(ClockProvider, { children: _jsx(GraphRunner, { args: args, datastore: datastore, setExitCode: options?.setExitCode, onSession: (c) => {
+                    session = c;
+                }, liveContext: liveContext }) }) }));
+    await app.waitUntilExit();
+    process.stdout.write('\n');
+    return { session };
+}
+//# sourceMappingURL=graph-runner.js.map

package/dist/cli/graph-runner.js.map

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

package/dist/cli/graph-tracer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Shared graph tracing constants and the span-emitting {@link RunStage} used by
+ * the sharded build's worker processes.
+ *
+ * The sequential orchestrator ({@link file://./orchestrate.ts}) defines its own
+ * `runStage` that also drives the live-view progress callback + pressure
+ * monitor; it reuses {@link GRAPH_TRACER} from here so both paths emit spans
+ * under the same instrumentation scope and `opensip_cli.graph.*` span names.
+ *
+ * Shard workers have no live view (they run headless in a subprocess), so they
+ * use {@link spanRunStage} — span emission without the progress/monitor plumbing.
+ * Before this existed the workers used a pass-through that silently dropped span
+ * coverage, so multi-package (sharded) builds emitted no per-stage spans at all.
+ */
+import { type Attributes } from '@opensip-cli/core';
+import type { RunStage } from './orchestrate/catalog-builder.js';
+/** Instrumentation scope for every graph stage span (sequential and sharded). */
+export declare const GRAPH_TRACER = "opensip-cli-graph";
+/**
+ * A {@link RunStage} that emits one span per stage (named
+ * `opensip_cli.graph.<stage>`) but does no progress/monitor work — for
+ * headless contexts like the shard worker. `baseAttrs` are merged onto every
+ * stage span (e.g. the shard id) so spans from parallel workers are
+ * distinguishable when they nest under the parent build trace.
+ */
+export declare function spanRunStage(baseAttrs?: Attributes): RunStage;
+//# sourceMappingURL=graph-tracer.d.ts.map

package/dist/cli/graph-tracer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-tracer.d.ts","sourceRoot":"","sources":["../../src/cli/graph-tracer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAiB,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAEjE,iFAAiF;AACjF,eAAO,MAAM,YAAY,sBAAsB,CAAC;AAEhD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,SAAS,GAAE,UAAe,GAAG,QAAQ,CAYjE"}

package/dist/cli/graph-tracer.js

@@ -0,0 +1,33 @@
+/**
+ * Shared graph tracing constants and the span-emitting {@link RunStage} used by
+ * the sharded build's worker processes.
+ *
+ * The sequential orchestrator ({@link file://./orchestrate.ts}) defines its own
+ * `runStage` that also drives the live-view progress callback + pressure
+ * monitor; it reuses {@link GRAPH_TRACER} from here so both paths emit spans
+ * under the same instrumentation scope and `opensip_cli.graph.*` span names.
+ *
+ * Shard workers have no live view (they run headless in a subprocess), so they
+ * use {@link spanRunStage} — span emission without the progress/monitor plumbing.
+ * Before this existed the workers used a pass-through that silently dropped span
+ * coverage, so multi-package (sharded) builds emitted no per-stage spans at all.
+ */
+import { withSpanAsync } from '@opensip-cli/core';
+/** Instrumentation scope for every graph stage span (sequential and sharded). */
+export const GRAPH_TRACER = 'opensip-cli-graph';
+/**
+ * A {@link RunStage} that emits one span per stage (named
+ * `opensip_cli.graph.<stage>`) but does no progress/monitor work — for
+ * headless contexts like the shard worker. `baseAttrs` are merged onto every
+ * stage span (e.g. the shard id) so spans from parallel workers are
+ * distinguishable when they nest under the parent build trace.
+ */
+export function spanRunStage(baseAttrs = {}) {
+    return ({ stage, fn, attrsFn }) => withSpanAsync(GRAPH_TRACER, `opensip_cli.graph.${stage}`, async (span) => {
+        const out = await fn();
+        if (attrsFn)
+            span.setAttributes(attrsFn(out));
+        return out;
+    }, { 'opensip_cli.graph.stage': stage, ...baseAttrs });
+}
+//# sourceMappingURL=graph-tracer.js.map

package/dist/cli/graph-tracer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-tracer.js","sourceRoot":"","sources":["../../src/cli/graph-tracer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,aAAa,EAAmB,MAAM,mBAAmB,CAAC;AAInE,iFAAiF;AACjF,MAAM,CAAC,MAAM,YAAY,GAAG,mBAAmB,CAAC;AAEhD;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,YAAwB,EAAE;IACrD,OAAO,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,CAChC,aAAa,CACX,YAAY,EACZ,qBAAqB,KAAK,EAAE,EAC5B,KAAK,EAAE,IAAI,EAAE,EAAE;QACb,MAAM,GAAG,GAAG,MAAM,EAAE,EAAE,CAAC;QACvB,IAAI,OAAO;YAAE,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;QAC9C,OAAO,GAAG,CAAC;IACb,CAAC,EACD,EAAE,yBAAyB,EAAE,KAAK,EAAE,GAAG,SAAS,EAAE,CACnD,CAAC;AACN,CAAC"}

package/dist/cli/graph-worker.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `graph-run-worker <specPath>` — the headless graph build forked by the live
+ * view (ADR-0028). The live runner forks `node <cliScript> graph-run-worker
+ * <spec>`; because it runs through the full CLI bootstrap, the language-adapter
+ * registry, project, and config are populated in scope exactly as a normal
+ * `graph` run — so the build (the heavy TS type-check / parse / walk / resolve)
+ * runs OFF the parent's render thread while the parent stays free to animate the
+ * stage checklist + 80ms clock.
+ *
+ * The spec carries only serializable inputs (cwd, resolution, noCache, recipe
+ * NAME); the worker re-loads the graph config and re-resolves the recipe → rules
+ * itself (rules are functions — they can't cross the boundary), mirroring
+ * `executeGraph`'s setup. It streams stage progress over IPC and posts the final
+ * {@link LiveGraphOutput} — the slim, serializable `{ signals, reportLines }`
+ * payload (a raw `RunGraphResult` can't cross the fork boundary: it carries
+ * class-method accumulators + Maps). The parent persists the signals + renders
+ * the report lines; the worker does all the heavy build + report assembly.
+ * Internal command — the live runner is its only caller.
+ */
+import { type CommandSpec, type ToolCliContext } from '@opensip-cli/core';
+/**
+ * Read the build spec, re-derive config + rules, run `runGraph` headless, and
+ * stream stage progress + the final result over IPC. Never throws to the caller —
+ * a failure is sent as a `{ kind: 'error' }` message so the parent rejects cleanly.
+ */
+export declare function executeGraphWorker(specPath: string, cli: ToolCliContext): Promise<void>;
+/** `graph-run-worker` — [internal] headless graph build, IPC progress/result. */
+export declare const graphRunWorkerCommandSpec: CommandSpec<unknown, ToolCliContext>;
+//# sourceMappingURL=graph-worker.d.ts.map

package/dist/cli/graph-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-worker.d.ts","sourceRoot":"","sources":["../../src/cli/graph-worker.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,cAAc,EAEpB,MAAM,mBAAmB,CAAC;AAuB3B;;;;GAIG;AACH,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAkC7F;AAED,iFAAiF;AACjF,eAAO,MAAM,yBAAyB,EAAE,WAAW,CAAC,OAAO,EAAE,cAAc,CAgBzE,CAAC"}

package/dist/cli/graph-worker.js

@@ -0,0 +1,86 @@
+// @fitness-ignore-file detached-promises -- this worker's `send()` helper is synchronous (it calls process.send, which returns immediately); the name-based heuristic mistakes the floating send(...) IPC posts for promise-returning calls. The one genuine async call (runGraph) is awaited.
+/**
+ * `graph-run-worker <specPath>` — the headless graph build forked by the live
+ * view (ADR-0028). The live runner forks `node <cliScript> graph-run-worker
+ * <spec>`; because it runs through the full CLI bootstrap, the language-adapter
+ * registry, project, and config are populated in scope exactly as a normal
+ * `graph` run — so the build (the heavy TS type-check / parse / walk / resolve)
+ * runs OFF the parent's render thread while the parent stays free to animate the
+ * stage checklist + 80ms clock.
+ *
+ * The spec carries only serializable inputs (cwd, resolution, noCache, recipe
+ * NAME); the worker re-loads the graph config and re-resolves the recipe → rules
+ * itself (rules are functions — they can't cross the boundary), mirroring
+ * `executeGraph`'s setup. It streams stage progress over IPC and posts the final
+ * {@link LiveGraphOutput} — the slim, serializable `{ signals, reportLines }`
+ * payload (a raw `RunGraphResult` can't cross the fork boundary: it carries
+ * class-method accumulators + Maps). The parent persists the signals + renders
+ * the report lines; the worker does all the heavy build + report assembly.
+ * Internal command — the live runner is its only caller.
+ */
+import { readFileSync } from 'node:fs';
+import { defineCommand, } from '@opensip-cli/core';
+import { resolveRecipeToRules } from '../recipes/resolve.js';
+import { toProgressEvent } from './graph-progress.js';
+import { buildLiveGraphOutput } from './graph.js';
+import { loadGraphConfig, resolveGraphRecipeSelection, runGraph } from './orchestrate.js';
+/** Post one IPC message to the parent (no-op when not forked). */
+function send(msg) {
+    process.send?.(msg);
+}
+/**
+ * Read the build spec, re-derive config + rules, run `runGraph` headless, and
+ * stream stage progress + the final result over IPC. Never throws to the caller —
+ * a failure is sent as a `{ kind: 'error' }` message so the parent rejects cleanly.
+ */
+export async function executeGraphWorker(specPath, cli) {
+    try {
+        const args = JSON.parse(readFileSync(specPath, 'utf8'));
+        const config = loadGraphConfig(args.cwd);
+        const recipeSelection = resolveGraphRecipeSelection(args.cwd, args.recipe);
+        const rules = resolveRecipeToRules(recipeSelection.name, {
+            tolerant: recipeSelection.tolerant,
+        });
+        const result = await runGraph({
+            cwd: args.cwd,
+            noCache: args.noCache,
+            resolution: args.resolution,
+            config,
+            rules,
+            datastore: cli.scope.datastore(),
+            onProgress: (event) => send({ kind: 'progress', event: toProgressEvent(event) }),
+        });
+        // Send only the serializable slim payload — a RunGraphResult can't cross the
+        // fork boundary (class-method accumulators + Maps). The parent persists the
+        // signals + renders from reportLines (ADR-0028).
+        //
+        // Suppression runs HERE, inside the worker (ADR-0014): buildLiveGraphOutput
+        // is the single chokepoint, and the worker holds the build root (args.cwd)
+        // plus disk access to read the `@graph-ignore`-directive files. The parent
+        // receives an already-waived LiveGraphOutput — it re-stamps the FinalizedSignals
+        // brand the IPC structured-clone drops, but performs NO second suppression.
+        send({ kind: 'result', value: await buildLiveGraphOutput(result, args.cwd) });
+    }
+    catch (error) {
+        send({
+            kind: 'error',
+            message: error instanceof Error ? error.message : String(error),
+            ...(error instanceof Error && error.stack !== undefined ? { stack: error.stack } : {}),
+        });
+    }
+}
+/** `graph-run-worker` — [internal] headless graph build, IPC progress/result. */
+export const graphRunWorkerCommandSpec = defineCommand({
+    name: 'graph-run-worker',
+    description: '[internal] Run the graph build headless and stream progress + result over IPC (forked by the live view)',
+    commonFlags: [],
+    args: [{ name: 'specPath', description: 'Path to a JSON graph build-spec file' }],
+    scope: 'project',
+    output: 'raw-stream',
+    rawStreamReason: 'worker-ipc',
+    handler: async (rawOpts, cli) => {
+        const specPath = rawOpts._args?.[0] ?? '';
+        await executeGraphWorker(specPath, cli);
+    },
+});
+//# sourceMappingURL=graph-worker.js.map

package/dist/cli/graph-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-worker.js","sourceRoot":"","sources":["../../src/cli/graph-worker.ts"],"names":[],"mappings":"AAAA,+RAA+R;AAC/R;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC,OAAO,EACL,aAAa,GAId,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAE7D,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,oBAAoB,EAAwB,MAAM,YAAY,CAAC;AACxE,OAAO,EAAE,eAAe,EAAE,2BAA2B,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAY1F,kEAAkE;AAClE,SAAS,IAAI,CAAC,GAAkD;IAC9D,OAAO,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC;AACtB,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CAAC,QAAgB,EAAE,GAAmB;IAC5E,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAoB,CAAC;QAC3E,MAAM,MAAM,GAAG,eAAe,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACzC,MAAM,eAAe,GAAG,2BAA2B,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QAC3E,MAAM,KAAK,GAAG,oBAAoB,CAAC,eAAe,CAAC,IAAI,EAAE;YACvD,QAAQ,EAAE,eAAe,CAAC,QAAQ;SACnC,CAAC,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC;YAC5B,GAAG,EAAE,IAAI,CAAC,GAAG;YACb,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,MAAM;YACN,KAAK;YACL,SAAS,EAAE,GAAG,CAAC,KAAK,CAAC,SAAS,EAA2B;YACzD,UAAU,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;SACjF,CAAC,CAAC;QACH,6EAA6E;QAC7E,4EAA4E;QAC5E,iDAAiD;QACjD,EAAE;QACF,4EAA4E;QAC5E,2EAA2E;QAC3E,2EAA2E;QAC3E,iFAAiF;QACjF,4EAA4E;QAC5E,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAChF,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,CAAC;YACH,IAAI,EAAE,OAAO;YACb,OAAO,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;YAC/D,GAAG,CAAC,KAAK,YAAY,KAAK,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACvF,CAAC,CAAC;IACL,CAAC;AACH,CAAC;AAED,iFAAiF;AACjF,MAAM,CAAC,MAAM,yBAAyB,GAAyC,aAAa,CAG1F;IACA,IAAI,EAAE,kBAAkB;IACxB,WAAW,EACT,yGAAyG;IAC3G,WAAW,EAAE,EAAE;IACf,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,sCAAsC,EAAE,CAAC;IACjF,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,YAAY;IACpB,eAAe,EAAE,YAAY;IAC7B,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,EAAiB,EAAE;QAC7C,MAAM,QAAQ,GAAI,OAAyC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QAC7E,MAAM,kBAAkB,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;IAC1C,CAAC;CACF,CAAC,CAAC"}