substrate-ai 0.1.33 → 0.2.0

package/dist/index.js

@@ -1,6 +1,6 @@
-import { AdapterRegistry, AdtError, BudgetExceededError, ClaudeCodeAdapter, CodexCLIAdapter, ConfigError, ConfigIncompatibleFormatError, GeminiCLIAdapter, GitError, RecoveryError, TaskConfigError, TaskGraphCycleError, TaskGraphError, TaskGraphIncompatibleFormatError, WorkerError, WorkerNotFoundError, childLogger, computeChangedKeys, createConfigWatcher, createDatabaseService, createEventBus, createGitWorktreeManager, createLogger, createMonitorAgent, createMonitorDatabase, createRoutingEngine, createTaskGraphEngine, createTuiApp, createWorkerPoolManager, isTuiCapable, logger, printNonTtyWarning } from "./app-CY3MaJtP.js";
-import "./config-schema-C9tTMcm1.js";
-import { join } from "node:path";
+import { childLogger, createLogger, logger } from "./logger-C6n1g8uP.js";
+import { AdapterRegistry, ClaudeCodeAdapter, CodexCLIAdapter, GeminiCLIAdapter, createEventBus, createTuiApp, isTuiCapable, printNonTtyWarning } from "./event-bus-J-bw-pkp.js";
+import { AdtError, BudgetExceededError, ConfigError, ConfigIncompatibleFormatError, GitError, RecoveryError, TaskConfigError, TaskGraphCycleError, TaskGraphError, TaskGraphIncompatibleFormatError, WorkerError, WorkerNotFoundError } from "./errors-BPqtzQ4U.js";
 import { randomUUID } from "crypto";
 
 //#region src/utils/helpers.ts
@@ -9,7 +9,7 @@ import { randomUUID } from "crypto";
 * @param ms - Milliseconds to sleep
 */
 function sleep(ms) {
-	return new Promise((resolve$1) => setTimeout(resolve$1, ms));
+	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 /**
 * Assert that a value is defined (not null or undefined)
@@ -161,305 +161,5 @@ var ServiceRegistry = class {
 };
 
 //#endregion
-//#region src/modules/budget/budget-tracker.ts
-const logger$3 = createLogger("budget");
-var BudgetTrackerImpl = class {
-	_eventBus;
-	constructor(eventBus) {
-		this._eventBus = eventBus;
-	}
-	async initialize() {
-		logger$3.info("BudgetTracker.initialize() — stub");
-		this._eventBus.on("budget:warning", ({ taskId, currentSpend, limit }) => {
-			logger$3.warn({
-				taskId,
-				currentSpend,
-				limit
-			}, "budget:warning");
-		});
-		this._eventBus.on("budget:exceeded", ({ taskId, spend, limit }) => {
-			logger$3.error({
-				taskId,
-				spend,
-				limit
-			}, "budget:exceeded");
-		});
-		this._eventBus.on("task:complete", ({ taskId, result }) => {
-			logger$3.debug({
-				taskId,
-				costUsd: result.costUsd
-			}, "task:complete — accumulate cost");
-		});
-		this._eventBus.on("task:progress", ({ taskId, tokensUsed }) => {
-			logger$3.debug({
-				taskId,
-				tokensUsed
-			}, "task:progress — update token usage");
-		});
-	}
-	async shutdown() {
-		logger$3.info("BudgetTracker.shutdown() — stub");
-	}
-};
-function createBudgetTracker(options) {
-	return new BudgetTrackerImpl(options.eventBus);
-}
-
-//#endregion
-//#region src/modules/git/git-manager.ts
-const logger$2 = createLogger("git");
-var GitManagerImpl = class {
-	_eventBus;
-	repoRoot;
-	constructor(eventBus, repoRoot) {
-		this._eventBus = eventBus;
-		this.repoRoot = repoRoot;
-	}
-	async initialize() {
-		logger$2.info({ repoRoot: this.repoRoot }, "GitManager.initialize() — stub");
-		this._eventBus.on("worktree:created", ({ taskId, worktreePath, branchName }) => {
-			logger$2.debug({
-				taskId,
-				worktreePath,
-				branchName
-			}, "worktree:created");
-		});
-		this._eventBus.on("worktree:merged", ({ taskId, branch }) => {
-			logger$2.debug({
-				taskId,
-				branch
-			}, "worktree:merged");
-		});
-		this._eventBus.on("worktree:conflict", ({ taskId, conflictingFiles }) => {
-			logger$2.warn({
-				taskId,
-				conflictingFiles
-			}, "worktree:conflict");
-		});
-		this._eventBus.on("worktree:removed", ({ taskId, branchName }) => {
-			logger$2.debug({
-				taskId,
-				branchName
-			}, "worktree:removed");
-		});
-	}
-	async shutdown() {
-		logger$2.info("GitManager.shutdown() — stub");
-	}
-};
-function createGitManager(options) {
-	return new GitManagerImpl(options.eventBus, options.repoRoot);
-}
-
-//#endregion
-//#region src/core/orchestrator-impl.ts
-const logger$1 = createLogger("orchestrator");
-/** Internal symbol used to expose lifecycle hooks to the factory only */
-const INTERNAL = Symbol("OrchestratorImpl.internal");
-var OrchestratorImpl = class {
-	eventBus;
-	_registry;
-	_ready = false;
-	_shutdown = false;
-	_shutdownHandlersRegistered = false;
-	_configWatcher = null;
-	constructor(eventBus, registry) {
-		this.eventBus = eventBus;
-		this._registry = registry;
-	}
-	get isReady() {
-		return this._ready;
-	}
-	async shutdown() {
-		if (this._shutdown) return;
-		this._shutdown = true;
-		logger$1.info("Orchestrator shutdown initiated");
-		this.eventBus.emit("orchestrator:shutdown", { reason: "shutdown() called" });
-		if (this._configWatcher !== null) {
-			this._configWatcher.stop();
-			this._configWatcher = null;
-		}
-		try {
-			await this._registry.shutdownAll();
-		} catch (err) {
-			logger$1.error({ err }, "Error during orchestrator shutdown");
-		}
-		logger$1.info("Orchestrator shutdown complete");
-	}
-	_markReady() {
-		this._ready = true;
-	}
-	_sigtermHandler = null;
-	_sigintHandler = null;
-	_registerShutdownHandlers() {
-		if (this._shutdownHandlersRegistered) return;
-		this._shutdownHandlersRegistered = true;
-		const makeHandler = (signal) => () => {
-			logger$1.info({ signal }, "Received signal — initiating graceful shutdown");
-			this.shutdown().then(() => {
-				process.exit(0);
-			}).catch((err) => {
-				logger$1.error({ err }, "Error during signal-triggered shutdown");
-				process.exit(1);
-			});
-		};
-		this._sigtermHandler = makeHandler("SIGTERM");
-		this._sigintHandler = makeHandler("SIGINT");
-		process.once("SIGTERM", this._sigtermHandler);
-		process.once("SIGINT", this._sigintHandler);
-	}
-	_removeShutdownHandlers() {
-		if (this._sigtermHandler !== null) {
-			process.removeListener("SIGTERM", this._sigtermHandler);
-			this._sigtermHandler = null;
-		}
-		if (this._sigintHandler !== null) {
-			process.removeListener("SIGINT", this._sigintHandler);
-			this._sigintHandler = null;
-		}
-	}
-	/**
-	* Internal accessor used exclusively by the createOrchestrator factory.
-	* Do not call outside of this module.
-	* @internal
-	*/
-	[INTERNAL]() {
-		return {
-			markReady: () => this._markReady(),
-			registerShutdownHandlers: () => this._registerShutdownHandlers(),
-			removeShutdownHandlers: () => this._removeShutdownHandlers(),
-			setConfigWatcher: (watcher) => {
-				this._configWatcher = watcher;
-			}
-		};
-	}
-};
-/**
-* Initialize the orchestrator with all modules wired via dependency injection.
-*
-* Steps performed:
-*  1. Create the TypedEventBus
-*  2. Create the SQLite database service
-*  3. Instantiate all modules (TaskGraphEngine, RoutingEngine, WorkerManager,
-*     BudgetTracker, GitManager) with constructor injection
-*  4. Register all modules in the ServiceRegistry
-*  5. Call initialize() on all services in registration order
-*  6. Register SIGTERM/SIGINT graceful shutdown handlers
-*  7. Emit orchestrator:ready
-*
-* @param config - Orchestrator configuration
-* @returns Initialized Orchestrator instance
-*/
-async function createOrchestrator(config) {
-	logger$1.info({ databasePath: config.databasePath }, "Initializing orchestrator");
-	const eventBus = createEventBus();
-	const databaseService = createDatabaseService(config.databasePath);
-	const taskGraphEngine = createTaskGraphEngine({
-		eventBus,
-		databaseService
-	});
-	const adapterRegistry = new AdapterRegistry();
-	const routingEngine = createRoutingEngine({
-		eventBus,
-		adapterRegistry
-	});
-	const budgetTracker = createBudgetTracker({ eventBus });
-	const gitManager = createGitManager({
-		eventBus,
-		repoRoot: config.projectRoot
-	});
-	const gitWorktreeManager = createGitWorktreeManager({
-		eventBus,
-		projectRoot: config.projectRoot,
-		db: databaseService
-	});
-	const workerPoolManager = createWorkerPoolManager({
-		eventBus,
-		adapterRegistry,
-		engine: taskGraphEngine,
-		db: databaseService,
-		gitWorktreeManager
-	});
-	const monitorDbPath = config.monitor?.databasePath ?? ":memory:";
-	const monitorDatabase = createMonitorDatabase(monitorDbPath);
-	const monitorAgent = createMonitorAgent({
-		eventBus,
-		monitorDb: monitorDatabase,
-		config: {
-			retentionDays: config.monitor?.retentionDays ?? 90,
-			customTaxonomy: config.monitor?.customTaxonomy,
-			use_recommendations: config.monitor?.use_recommendations ?? false,
-			recommendation_threshold_percentage: config.monitor?.recommendation_threshold_percentage,
-			min_sample_size: config.monitor?.min_sample_size,
-			recommendation_history_days: config.monitor?.recommendation_history_days
-		}
-	});
-	const registry = new ServiceRegistry();
-	registry.register("database", databaseService);
-	registry.register("taskGraph", taskGraphEngine);
-	registry.register("routingEngine", routingEngine);
-	registry.register("gitWorktreeManager", gitWorktreeManager);
-	registry.register("workerPoolManager", workerPoolManager);
-	registry.register("budgetTracker", budgetTracker);
-	registry.register("gitManager", gitManager);
-	registry.register("monitorAgent", monitorAgent);
-	const orchestrator = new OrchestratorImpl(eventBus, registry);
-	const internal = orchestrator[INTERNAL]();
-	try {
-		await registry.initializeAll();
-	} catch (err) {
-		logger$1.error({ err }, "Service initialization failed — cleaning up");
-		internal.removeShutdownHandlers();
-		try {
-			await registry.shutdownAll();
-		} catch (shutdownErr) {
-			logger$1.error({ err: shutdownErr }, "Error during cleanup after failed initialization");
-		}
-		throw err;
-	}
-	internal.registerShutdownHandlers();
-	const enableConfigHotReload = config.enableConfigHotReload ?? true;
-	if (enableConfigHotReload) {
-		const configFilePath = config.configPath ?? join(config.projectRoot, "substrate.config.yaml");
-		let currentConfig = null;
-		const configWatcher = createConfigWatcher({
-			configPath: configFilePath,
-			onReload: (newConfig) => {
-				const previousConfig = currentConfig;
-				if (previousConfig === null) {
-					currentConfig = newConfig;
-					return;
-				}
-				const changedKeys = computeChangedKeys(previousConfig, newConfig);
-				currentConfig = newConfig;
-				const n = changedKeys.length;
-				logger$1.info({
-					changedKeys,
-					configPath: configFilePath
-				}, `Config reloaded: ${n} setting(s) changed`);
-				eventBus.emit("config:reloaded", {
-					path: configFilePath,
-					previousConfig,
-					newConfig,
-					changedKeys
-				});
-			},
-			onError: (err) => {
-				logger$1.error({
-					err,
-					configPath: configFilePath
-				}, `Config reload failed: ${err.message}. Continuing with previous config.`);
-			}
-		});
-		configWatcher.start();
-		internal.setConfigWatcher(configWatcher);
-	}
-	internal.markReady();
-	eventBus.emit("orchestrator:ready", {});
-	logger$1.info("Orchestrator ready");
-	return orchestrator;
-}
-
-//#endregion
-export { AdapterRegistry, AdtError, BudgetExceededError, ClaudeCodeAdapter, CodexCLIAdapter, ConfigError, ConfigIncompatibleFormatError, GeminiCLIAdapter, GitError, RecoveryError, ServiceRegistry, TaskConfigError, TaskGraphCycleError, TaskGraphError, TaskGraphIncompatibleFormatError, WorkerError, WorkerNotFoundError, assertDefined, childLogger, createEventBus, createLogger, createOrchestrator, createTuiApp, deepClone, formatDuration, generateId, isPlainObject, isTuiCapable, logger, printNonTtyWarning, sleep, withRetry };
+export { AdapterRegistry, AdtError, BudgetExceededError, ClaudeCodeAdapter, CodexCLIAdapter, ConfigError, ConfigIncompatibleFormatError, GeminiCLIAdapter, GitError, RecoveryError, ServiceRegistry, TaskConfigError, TaskGraphCycleError, TaskGraphError, TaskGraphIncompatibleFormatError, WorkerError, WorkerNotFoundError, assertDefined, childLogger, createEventBus, createLogger, createTuiApp, deepClone, formatDuration, generateId, isPlainObject, isTuiCapable, logger, printNonTtyWarning, sleep, withRetry };
 //# sourceMappingURL=index.js.map

package/dist/logger-C6n1g8uP.js

@@ -0,0 +1,119 @@
+import pino from "pino";
+
+//#region src/cli/utils/masking.ts
+/**
+* Credential masking utilities for CLI output and Pino logger redaction.
+*
+* Ensures that API keys and other secrets never appear in logs, status
+* output, or error messages (NFR8, NFR9).
+*/
+/** Placeholder shown instead of a real credential */
+const MASKED_VALUE = "***";
+/**
+* Known Pino redaction paths for provider API key fields.
+* Pass this array to the `pino({ redact: ... })` option.
+*
+* @example
+* import pino from 'pino'
+* import { PINO_REDACT_PATHS } from './masking.js'
+* const logger = pino({ redact: PINO_REDACT_PATHS })
+*/
+const PINO_REDACT_PATHS = [
+	"apiKey",
+	"api_key",
+	"*.apiKey",
+	"*.api_key",
+	"providers.*.api_key_env",
+	"env.ANTHROPIC_API_KEY",
+	"env.OPENAI_API_KEY",
+	"env.GOOGLE_API_KEY"
+];
+/**
+* Credential field names that should be replaced with `***` in displayed output.
+*/
+const CREDENTIAL_FIELDS = new Set([
+	"api_key",
+	"apiKey",
+	"api_key_env",
+	"api_key_value",
+	"token",
+	"secret",
+	"password"
+]);
+/**
+* Deep-clone a plain-object tree and replace known credential fields with `***`.
+*
+* Only operates on plain objects and arrays; primitives are returned as-is.
+*
+* @param value - Value to mask
+* @returns Masked clone of `value`
+*/
+function deepMask(value) {
+	if (value === null || value === void 0) return value;
+	if (Array.isArray(value)) return value.map(deepMask);
+	if (typeof value === "object") {
+		const obj = value;
+		const masked = {};
+		for (const [k, v] of Object.entries(obj)) if (CREDENTIAL_FIELDS.has(k)) masked[k] = MASKED_VALUE;
+		else masked[k] = deepMask(v);
+		return masked;
+	}
+	return value;
+}
+
+//#endregion
+//#region src/utils/logger.ts
+/** Default log level based on environment */
+function getDefaultLogLevel() {
+	const envLevel = process.env.LOG_LEVEL;
+	if (envLevel) return envLevel;
+	if (process.env.NODE_ENV === "production") return "info";
+	if (process.env.NODE_ENV === "test" || process.env.NODE_ENV === "development") return "debug";
+	return "warn";
+}
+/** Whether to use pretty printing (development mode) */
+function isPrettyMode() {
+	if (process.env.LOG_PRETTY !== void 0) return process.env.LOG_PRETTY === "true";
+	return process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test";
+}
+/**
+* Create a named logger instance
+* @param name - Logger name (module identifier)
+* @param options - Optional logger configuration overrides
+*/
+function createLogger(name, options = {}) {
+	const level = options.level ?? getDefaultLogLevel();
+	const pretty = options.pretty ?? isPrettyMode();
+	const baseOptions = {
+		name: options.name ?? name,
+		level,
+		redact: PINO_REDACT_PATHS,
+		formatters: { level(label) {
+			return { level: label };
+		} },
+		timestamp: pino.stdTimeFunctions.isoTime,
+		base: { pid: process.pid }
+	};
+	if (pretty) return pino({
+		...baseOptions,
+		transport: {
+			target: "pino-pretty",
+			options: {
+				colorize: true,
+				translateTime: "SYS:standard",
+				ignore: "pid,hostname"
+			}
+		}
+	});
+	return pino(baseOptions);
+}
+/** Root application logger */
+const logger = createLogger("substrate");
+/** Create a child logger with additional context */
+function childLogger(parent, bindings) {
+	return parent.child(bindings);
+}
+
+//#endregion
+export { childLogger, createLogger, deepMask, logger };
+//# sourceMappingURL=logger-C6n1g8uP.js.map

package/dist/metrics-BSg8VIHd.js

@@ -0,0 +1,184 @@
+//#region src/persistence/queries/metrics.ts
+/**
+* Write or update run-level metrics.
+*
+* Uses INSERT ... ON CONFLICT DO UPDATE to avoid a TOCTOU race on the
+* `restarts` counter: when a row already exists, `restarts` is preserved from
+* the DB (so any `incrementRunRestarts()` calls made by the supervisor between
+* the caller's read and this write are not silently overwritten).
+*/
+function writeRunMetrics(db, input) {
+	const stmt = db.prepare(`
+    INSERT INTO run_metrics (
+      run_id, methodology, status, started_at, completed_at,
+      wall_clock_seconds, total_input_tokens, total_output_tokens, total_cost_usd,
+      stories_attempted, stories_succeeded, stories_failed, stories_escalated,
+      total_review_cycles, total_dispatches, concurrency_setting, max_concurrent_actual, restarts,
+      is_baseline
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(run_id) DO UPDATE SET
+      methodology = excluded.methodology,
+      status = excluded.status,
+      started_at = excluded.started_at,
+      completed_at = excluded.completed_at,
+      wall_clock_seconds = excluded.wall_clock_seconds,
+      total_input_tokens = excluded.total_input_tokens,
+      total_output_tokens = excluded.total_output_tokens,
+      total_cost_usd = excluded.total_cost_usd,
+      stories_attempted = excluded.stories_attempted,
+      stories_succeeded = excluded.stories_succeeded,
+      stories_failed = excluded.stories_failed,
+      stories_escalated = excluded.stories_escalated,
+      total_review_cycles = excluded.total_review_cycles,
+      total_dispatches = excluded.total_dispatches,
+      concurrency_setting = excluded.concurrency_setting,
+      max_concurrent_actual = excluded.max_concurrent_actual,
+      restarts = run_metrics.restarts,
+      is_baseline = run_metrics.is_baseline
+  `);
+	stmt.run(input.run_id, input.methodology, input.status, input.started_at, input.completed_at ?? null, input.wall_clock_seconds ?? 0, input.total_input_tokens ?? 0, input.total_output_tokens ?? 0, input.total_cost_usd ?? 0, input.stories_attempted ?? 0, input.stories_succeeded ?? 0, input.stories_failed ?? 0, input.stories_escalated ?? 0, input.total_review_cycles ?? 0, input.total_dispatches ?? 0, input.concurrency_setting ?? 1, input.max_concurrent_actual ?? 1, input.restarts ?? 0, input.is_baseline ?? 0);
+}
+/**
+* Get run metrics for a specific run.
+*/
+function getRunMetrics(db, runId) {
+	return db.prepare("SELECT * FROM run_metrics WHERE run_id = ?").get(runId);
+}
+/**
+* List the most recent N run metrics rows, newest first.
+*/
+function listRunMetrics(db, limit = 10) {
+	return db.prepare("SELECT * FROM run_metrics ORDER BY started_at DESC LIMIT ?").all(limit);
+}
+/**
+* Tag a run as the baseline (clears any existing baseline first).
+*/
+function tagRunAsBaseline(db, runId) {
+	db.transaction(() => {
+		db.prepare("UPDATE run_metrics SET is_baseline = 0").run();
+		db.prepare("UPDATE run_metrics SET is_baseline = 1 WHERE run_id = ?").run(runId);
+	})();
+}
+/**
+* Get the current baseline run metrics (if any).
+*/
+function getBaselineRunMetrics(db) {
+	return db.prepare("SELECT * FROM run_metrics WHERE is_baseline = 1 LIMIT 1").get();
+}
+/**
+* Increment the restart count for a run by 1.
+* Called by the supervisor each time it successfully restarts the pipeline.
+* If the run_id does not yet exist in run_metrics, a placeholder row is
+* inserted so the restart count is not lost — writeRunMetrics will overwrite
+* all other fields when the run reaches a terminal state.
+*/
+function incrementRunRestarts(db, runId) {
+	db.prepare(`
+    INSERT INTO run_metrics (run_id, methodology, status, started_at, restarts)
+    VALUES (?, 'unknown', 'running', datetime('now'), 1)
+    ON CONFLICT(run_id) DO UPDATE SET restarts = run_metrics.restarts + 1
+  `).run(runId);
+}
+/**
+* Write or update story-level metrics.
+*/
+function writeStoryMetrics(db, input) {
+	const stmt = db.prepare(`
+    INSERT INTO story_metrics (
+      run_id, story_key, result, phase_durations_json, started_at, completed_at,
+      wall_clock_seconds, input_tokens, output_tokens, cost_usd,
+      review_cycles, dispatches
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(run_id, story_key) DO UPDATE SET
+      result = excluded.result,
+      phase_durations_json = excluded.phase_durations_json,
+      started_at = COALESCE(excluded.started_at, story_metrics.started_at),
+      completed_at = excluded.completed_at,
+      wall_clock_seconds = excluded.wall_clock_seconds,
+      input_tokens = excluded.input_tokens,
+      output_tokens = excluded.output_tokens,
+      cost_usd = excluded.cost_usd,
+      review_cycles = excluded.review_cycles,
+      dispatches = excluded.dispatches
+  `);
+	stmt.run(input.run_id, input.story_key, input.result, input.phase_durations_json ?? null, input.started_at ?? null, input.completed_at ?? null, input.wall_clock_seconds ?? 0, input.input_tokens ?? 0, input.output_tokens ?? 0, input.cost_usd ?? 0, input.review_cycles ?? 0, input.dispatches ?? 0);
+}
+/**
+* Get all story metrics for a given run.
+*/
+function getStoryMetricsForRun(db, runId) {
+	return db.prepare("SELECT * FROM story_metrics WHERE run_id = ? ORDER BY id ASC").all(runId);
+}
+/**
+* Compare two runs and return percentage deltas for key numeric fields.
+* Positive deltas mean run B is larger/longer than run A.
+* Returns null if either run does not exist.
+*/
+function compareRunMetrics(db, runIdA, runIdB) {
+	const a = getRunMetrics(db, runIdA);
+	const b = getRunMetrics(db, runIdB);
+	if (!a || !b) return null;
+	const pct = (base, diff) => base === 0 ? null : Math.round(diff / base * 100 * 10) / 10;
+	const inputDelta = b.total_input_tokens - a.total_input_tokens;
+	const outputDelta = b.total_output_tokens - a.total_output_tokens;
+	const clockDelta = (b.wall_clock_seconds ?? 0) - (a.wall_clock_seconds ?? 0);
+	const cycleDelta = b.total_review_cycles - a.total_review_cycles;
+	const costDelta = (b.total_cost_usd ?? 0) - (a.total_cost_usd ?? 0);
+	return {
+		run_id_a: runIdA,
+		run_id_b: runIdB,
+		token_input_delta: inputDelta,
+		token_output_delta: outputDelta,
+		token_input_pct: pct(a.total_input_tokens, inputDelta),
+		token_output_pct: pct(a.total_output_tokens, outputDelta),
+		wall_clock_delta_seconds: clockDelta,
+		wall_clock_pct: pct(a.wall_clock_seconds ?? 0, clockDelta),
+		review_cycles_delta: cycleDelta,
+		review_cycles_pct: pct(a.total_review_cycles, cycleDelta),
+		cost_delta: costDelta,
+		cost_pct: pct(a.total_cost_usd ?? 0, costDelta)
+	};
+}
+/**
+* Aggregate token usage from the token_usage table for a pipeline run.
+*/
+function aggregateTokenUsageForRun(db, runId) {
+	const row = db.prepare(`
+    SELECT
+      COALESCE(SUM(input_tokens), 0) as input,
+      COALESCE(SUM(output_tokens), 0) as output,
+      COALESCE(SUM(cost_usd), 0) as cost
+    FROM token_usage
+    WHERE pipeline_run_id = ?
+  `).get(runId);
+	return row ?? {
+		input: 0,
+		output: 0,
+		cost: 0
+	};
+}
+/**
+* Aggregate token usage for a specific story within a pipeline run.
+* Matches rows where the metadata JSON contains the given storyKey.
+*/
+function aggregateTokenUsageForStory(db, runId, storyKey) {
+	const row = db.prepare(`
+    SELECT
+      COALESCE(SUM(input_tokens), 0) as input,
+      COALESCE(SUM(output_tokens), 0) as output,
+      COALESCE(SUM(cost_usd), 0) as cost
+    FROM token_usage
+    WHERE pipeline_run_id = ?
+      AND metadata IS NOT NULL
+      AND json_extract(metadata, '$.storyKey') = ?
+  `).get(runId, storyKey);
+	return row ?? {
+		input: 0,
+		output: 0,
+		cost: 0
+	};
+}
+
+//#endregion
+export { aggregateTokenUsageForRun, aggregateTokenUsageForStory, compareRunMetrics, getBaselineRunMetrics, getRunMetrics, getStoryMetricsForRun, incrementRunRestarts, listRunMetrics, tagRunAsBaseline, writeRunMetrics, writeStoryMetrics };
+//# sourceMappingURL=metrics-BSg8VIHd.js.map

package/dist/run-CRmhkcwN.js

@@ -0,0 +1,7 @@
+import "./logger-C6n1g8uP.js";
+import "./event-bus-J-bw-pkp.js";
+import { registerRunCommand, runRunAction } from "./run-DlOWhkIF.js";
+import "./decisions-BBLMsN_c.js";
+import "./metrics-BSg8VIHd.js";
+
+export { runRunAction };