substrate-ai 0.20.63 → 0.20.65

package/dist/src/modules/recovery-engine/index.js

@@ -0,0 +1,5 @@
+import "../../../logger-KeHncl-f.js";
+import "../../../work-graph-repository-DZyJv5pV.js";
+import { classifyRecoveryAction, runRecoveryEngine } from "../../../recovery-engine-BKGBeBnW.js";
+
+export { classifyRecoveryAction, runRecoveryEngine };

package/dist/{upgrade-C8LAnB6W.js → upgrade-DxzQ1nss.js}

@@ -1,5 +1,5 @@
-import "./dist-W2emvN3F.js";
-import "./version-manager-impl-BmOWu8ml.js";
-import { isGlobalInstall, registerUpgradeCommand, runUpgradeCommand } from "./upgrade-CAqLkNUP.js";
+import "./dist-K_RRWnBX.js";
+import "./version-manager-impl-qFBiO4Eh.js";
+import { isGlobalInstall, registerUpgradeCommand, runUpgradeCommand } from "./upgrade-MP9XzrI6.js";
 
 export { isGlobalInstall, registerUpgradeCommand, runUpgradeCommand };

package/dist/{upgrade-CAqLkNUP.js → upgrade-MP9XzrI6.js}

@@ -1,4 +1,4 @@
-import { createVersionManager } from "./dist-W2emvN3F.js";
+import { createVersionManager } from "./dist-K_RRWnBX.js";
 import { execSync, spawn } from "child_process";
 import * as readline from "readline";
 
@@ -123,4 +123,4 @@ function registerUpgradeCommand(program) {
 
 //#endregion
 export { isGlobalInstall, registerUpgradeCommand, runUpgradeCommand };
-//# sourceMappingURL=upgrade-CAqLkNUP.js.map
+//# sourceMappingURL=upgrade-MP9XzrI6.js.map

package/dist/version-manager-impl-GZDUBt0Q.js

@@ -0,0 +1,4 @@
+import { VersionManagerImpl, createVersionManager } from "./dist-K_RRWnBX.js";
+import "./version-manager-impl-qFBiO4Eh.js";
+
+export { createVersionManager };

package/dist/work-graph-repository-DZyJv5pV.js

@@ -0,0 +1,265 @@
+//#region src/modules/work-graph/cycle-detector.ts
+/**
+* detectCycles — DFS-based cycle detection for story dependency graphs.
+*
+* Story 31-7: Cycle Detection in Work Graph
+*
+* Pure function; no database or I/O dependencies.
+*/
+/**
+* Detect cycles in a directed dependency graph represented as an edge list.
+*
+* Each edge `{ story_key, depends_on }` means story_key depends on depends_on
+* (i.e. story_key → depends_on is the directed edge we traverse).
+*
+* Uses iterative DFS with an explicit stack to avoid call-stack overflows on
+* large graphs, but also supports a nested recursive helper for cycle path
+* reconstruction.
+*
+* @param edges - List of dependency edges to check.
+* @returns `null` if the graph is acyclic (safe to persist), or a `string[]`
+*   containing the cycle path with the first and last element being the same
+*   story key (e.g. `['A', 'B', 'A']`).
+*/
+function detectCycles(edges) {
+	const adj = new Map();
+	for (const { story_key, depends_on } of edges) {
+		if (!adj.has(story_key)) adj.set(story_key, []);
+		adj.get(story_key).push(depends_on);
+	}
+	const visited = new Set();
+	const visiting = new Set();
+	const path = [];
+	function dfs(node) {
+		if (visiting.has(node)) {
+			const cycleStart = path.indexOf(node);
+			return [...path.slice(cycleStart), node];
+		}
+		if (visited.has(node)) return null;
+		visiting.add(node);
+		path.push(node);
+		for (const neighbor of adj.get(node) ?? []) {
+			const cycle = dfs(neighbor);
+			if (cycle !== null) return cycle;
+		}
+		path.pop();
+		visiting.delete(node);
+		visited.add(node);
+		return null;
+	}
+	const allNodes = new Set([...edges.map((e) => e.story_key), ...edges.map((e) => e.depends_on)]);
+	for (const node of allNodes) if (!visited.has(node)) {
+		const cycle = dfs(node);
+		if (cycle !== null) return cycle;
+	}
+	return null;
+}
+
+//#endregion
+//#region src/modules/state/work-graph-repository.ts
+var WorkGraphRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	/**
+	* Insert or replace a work-graph story node.
+	* Uses DELETE + INSERT so it works on InMemoryDatabaseAdapter (which does
+	* not support ON DUPLICATE KEY UPDATE).
+	*/
+	async upsertStory(story) {
+		await this.db.query(`DELETE FROM wg_stories WHERE story_key = ?`, [story.story_key]);
+		await this.db.query(`INSERT INTO wg_stories (story_key, epic, title, status, spec_path, created_at, updated_at, completed_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+			story.story_key,
+			story.epic,
+			story.title ?? null,
+			story.status,
+			story.spec_path ?? null,
+			story.created_at ?? null,
+			story.updated_at ?? null,
+			story.completed_at ?? null
+		]);
+	}
+	/**
+	* Insert a dependency edge.  Idempotent — if a row with the same
+	* (story_key, depends_on) already exists it is silently skipped.
+	*/
+	async addDependency(dep) {
+		const existing = await this.db.query(`SELECT story_key FROM story_dependencies WHERE story_key = ? AND depends_on = ?`, [dep.story_key, dep.depends_on]);
+		if (existing.length > 0) return;
+		await this.db.query(`INSERT INTO story_dependencies (story_key, depends_on, dependency_type, source, created_at) VALUES (?, ?, ?, ?, ?)`, [
+			dep.story_key,
+			dep.depends_on,
+			dep.dependency_type,
+			dep.source,
+			dep.created_at ?? null
+		]);
+	}
+	/**
+	* Persist contract-based dependency edges to `story_dependencies` as
+	* best-effort, idempotent writes.
+	*
+	* - edges where `reason` does NOT start with `'dual export:'` are persisted
+	*   as `dependency_type = 'blocks'` (hard prerequisites).
+	* - edges where `reason` starts with `'dual export:'` are persisted as
+	*   `dependency_type = 'informs'` (serialization hints, not hard gates).
+	*
+	* Idempotency is delegated to `addDependency()`, which skips the INSERT if
+	* a row with the same `(story_key, depends_on)` already exists.
+	*
+	* @param edges - Readonly list of contract dependency edges to persist.
+	*/
+	async addContractDependencies(edges) {
+		if (edges.length === 0) return;
+		for (const edge of edges) {
+			const dependency_type = edge.reason?.startsWith("dual export:") ? "informs" : "blocks";
+			await this.addDependency({
+				story_key: edge.to,
+				depends_on: edge.from,
+				dependency_type,
+				source: "contract",
+				created_at: new Date().toISOString()
+			});
+		}
+	}
+	/**
+	* Return all work-graph stories, optionally filtered by epic and/or status.
+	*/
+	async listStories(filter) {
+		if (!filter || !filter.epic && !filter.status) return this.db.query(`SELECT * FROM wg_stories`);
+		const conditions = [];
+		const params = [];
+		if (filter.epic) {
+			conditions.push(`epic = ?`);
+			params.push(filter.epic);
+		}
+		if (filter.status) {
+			conditions.push(`status = ?`);
+			params.push(filter.status);
+		}
+		const where = conditions.join(" AND ");
+		return this.db.query(`SELECT * FROM wg_stories WHERE ${where}`, params);
+	}
+	/**
+	* Update the `status` (and optionally `completed_at`) of an existing
+	* work-graph story.
+	*
+	* This is a read-modify-write operation: SELECT existing row → build
+	* updated WgStory → upsertStory(). If no row exists for `storyKey` the
+	* call is a no-op (AC4).
+	*
+	* @param storyKey - Story identifier, e.g. "31-4"
+	* @param status   - Target WgStoryStatus value
+	* @param opts     - Optional `completedAt` ISO string for terminal phases
+	*/
+	async updateStoryStatus(storyKey, status, opts) {
+		const rows = await this.db.query(`SELECT * FROM wg_stories WHERE story_key = ?`, [storyKey]);
+		if (rows.length === 0) return;
+		const existing = rows[0];
+		const now = new Date().toISOString();
+		const isTerminal = status === "complete" || status === "escalated";
+		const updated = {
+			...existing,
+			status,
+			updated_at: now,
+			completed_at: isTerminal ? opts?.completedAt ?? now : existing.completed_at
+		};
+		await this.upsertStory(updated);
+	}
+	/**
+	* Return stories that are eligible for dispatch.
+	*
+	* A story is ready when:
+	*   1. Its status is 'planned' or 'ready', AND
+	*   2. It has no 'blocks' dependency whose blocking story is not 'complete'.
+	*
+	* Soft ('informs') dependencies never block dispatch.
+	*
+	* This is implemented programmatically rather than via the `ready_stories`
+	* VIEW so that the InMemoryDatabaseAdapter can handle it without VIEW support.
+	*/
+	async getReadyStories() {
+		const allStories = await this.db.query(`SELECT * FROM wg_stories`);
+		const candidates = allStories.filter((s) => s.status === "planned" || s.status === "ready");
+		if (candidates.length === 0) return [];
+		const deps = await this.db.query(`SELECT story_key, depends_on FROM story_dependencies WHERE dependency_type = 'blocks'`);
+		if (deps.length === 0) return candidates;
+		const blockerStatus = new Map(allStories.map((s) => [s.story_key, s.status]));
+		const depsMap = new Map();
+		for (const d of deps) {
+			if (!depsMap.has(d.story_key)) depsMap.set(d.story_key, []);
+			depsMap.get(d.story_key).push(d.depends_on);
+		}
+		return candidates.filter((s) => {
+			const blocking = depsMap.get(s.story_key) ?? [];
+			return blocking.every((dep) => blockerStatus.get(dep) === "complete");
+		});
+	}
+	/**
+	* Return stories that are planned/ready but cannot be dispatched because
+	* at least one hard-blocking ('blocks') dependency is not yet complete.
+	*
+	* For each blocked story, the returned object includes the full WgStory
+	* record plus the list of unsatisfied blockers (key, title, status).
+	*
+	* Soft ('informs') dependencies are ignored here, matching getReadyStories().
+	*/
+	/**
+	* Query the database for all 'blocks' dependency rows and run DFS cycle
+	* detection over them.
+	*
+	* Returns an empty array if no cycle is found (consistent with other
+	* repository methods that return empty arrays rather than null).
+	*
+	* Only 'blocks' deps are checked — soft 'informs' deps cannot cause
+	* dispatch deadlocks (AC5).
+	*/
+	async detectCycles() {
+		const rows = await this.db.query(`SELECT story_key, depends_on FROM story_dependencies WHERE dependency_type = 'blocks'`);
+		const cycle = detectCycles(rows);
+		return cycle ?? [];
+	}
+	async getBlockedStories() {
+		const allStories = await this.db.query(`SELECT * FROM wg_stories`);
+		const candidates = allStories.filter((s) => s.status === "planned" || s.status === "ready");
+		if (candidates.length === 0) return [];
+		const deps = await this.db.query(`SELECT story_key, depends_on FROM story_dependencies WHERE dependency_type = 'blocks'`);
+		if (deps.length === 0) return [];
+		const statusMap = new Map(allStories.map((s) => [s.story_key, s]));
+		const depsMap = new Map();
+		for (const d of deps) {
+			if (!depsMap.has(d.story_key)) depsMap.set(d.story_key, []);
+			depsMap.get(d.story_key).push(d.depends_on);
+		}
+		const result = [];
+		for (const story of candidates) {
+			const blockerKeys = depsMap.get(story.story_key) ?? [];
+			const unsatisfied = blockerKeys.filter((key) => statusMap.get(key)?.status !== "complete").map((key) => {
+				const s = statusMap.get(key);
+				return {
+					key,
+					title: s?.title ?? key,
+					status: s?.status ?? "unknown"
+				};
+			});
+			if (unsatisfied.length > 0) result.push({
+				story,
+				blockers: unsatisfied
+			});
+		}
+		return result;
+	}
+	/**
+	* Return all 'blocks' dependency edges from story_dependencies.
+	*
+	* Used by back-pressure logic (e.g., Recovery Engine computeDependencyAwarePause)
+	* to find which pending stories depend on proposed/blocked stories without
+	* requiring a status-filtered candidate query like getBlockedStories().
+	*/
+	async getDependencyEdges() {
+		return this.db.query(`SELECT story_key, depends_on FROM story_dependencies WHERE dependency_type = 'blocks'`);
+	}
+};
+
+//#endregion
+export { WorkGraphRepository, detectCycles };
+//# sourceMappingURL=work-graph-repository-DZyJv5pV.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "substrate-ai",
-  "version": "0.20.63",
+  "version": "0.20.65",
   "description": "Substrate — multi-agent orchestration daemon for AI coding agents",
   "type": "module",
   "license": "MIT",

package/dist/adapter-registry-k7ZX3Bz6.js

@@ -1,4 +0,0 @@
-import { AdapterRegistry } from "./dist-W2emvN3F.js";
-import "./adapter-registry-DXLMTmfD.js";
-
-export { AdapterRegistry };

package/dist/health-CJqd1FzY.js

@@ -1,6 +0,0 @@
-import { DEFAULT_STALL_THRESHOLD_SECONDS, getAllDescendantPids, getAutoHealthData, inspectProcessTree, isOrchestratorProcessLine, registerHealthCommand, runHealthAction } from "./health-C-KOZrFJ.js";
-import "./logger-KeHncl-f.js";
-import "./dist-W2emvN3F.js";
-import "./decisions-C0pz9Clx.js";
-
-export { inspectProcessTree };

package/dist/run-Z_-caE_i.js

@@ -1,9 +0,0 @@
-import "./health-C-KOZrFJ.js";
-import "./logger-KeHncl-f.js";
-import "./helpers-CElYrONe.js";
-import "./dist-W2emvN3F.js";
-import { normalizeGraphSummaryToStatus, registerRunCommand, resolveMaxReviewCycles, resolveProbeAuthorStateIntegrating, runRunAction, wireNdjsonEmitter } from "./run-CHUFlRbH.js";
-import "./routing-CcBOCuC9.js";
-import "./decisions-C0pz9Clx.js";
-
-export { runRunAction };

package/dist/version-manager-impl-DaA_ALYK.js

@@ -1,4 +0,0 @@
-import { VersionManagerImpl, createVersionManager } from "./dist-W2emvN3F.js";
-import "./version-manager-impl-BmOWu8ml.js";
-
-export { createVersionManager };