@soleri/core 2.4.0 → 2.5.0

package/dist/loop/types.d.ts

@@ -2,7 +2,10 @@
  * Loop system types — iterative validation loop state tracking.
  *
  * Loops let agents run validate-fix-validate cycles (e.g. token migration,
- * contrast fixes, component builds). In-memory only — session-scoped.
+ * contrast fixes, component builds).
+ *
+ * Ported from Salvador's loop.facade.ts with full gate decision system,
+ * output scanning, and completion promise detection.
  */
 /** Supported loop modes — each maps to a different validation strategy. */
 export type LoopMode = 'token-migration' | 'contrast-fix' | 'component-build' | 'plan-iteration' | 'custom';
@@ -11,7 +14,16 @@ export interface LoopConfig {
     mode: LoopMode;
     prompt: string;
     maxIterations: number;
+    /** Target validation score for score-based modes (token-migration, component-build). */
     targetScore?: number;
+    /** Target grade for plan-iteration mode (e.g., 'A', 'A+'). */
+    targetGrade?: string;
+    /** Completion promise text — loop completes when this appears in output. */
+    completionPromise?: string;
+    /** Validation instructions appended to the prompt each iteration. */
+    validationInstructions?: string;
+    /** Detected intent for this loop (e.g., 'BUILD', 'FIX'). Used for brain session recording. */
+    intent?: string;
 }
 /** A single iteration result within a loop. */
 export interface LoopIteration {
@@ -20,9 +32,23 @@ export interface LoopIteration {
     validationScore?: number;
     validationResult?: string;
     passed: boolean;
+    /** Duration of this iteration in milliseconds. */
+    durationMs?: number;
 }
 /** Loop lifecycle status. */
 export type LoopStatus = 'active' | 'completed' | 'cancelled' | 'max-iterations';
+/**
+ * Knowledge items tracked during loop execution.
+ * Ported from Salvador's loop knowledge tracking for brain session recording.
+ */
+export interface LoopKnowledge {
+    /** Knowledge items discovered during the loop. */
+    items?: string[];
+    /** Patterns successfully applied during the loop. */
+    patternsApplied?: string[];
+    /** Anti-patterns intentionally avoided during the loop. */
+    antiPatternsAvoided?: string[];
+}
 /** Full state of a loop (active or historical). */
 export interface LoopState {
     id: string;
@@ -31,5 +57,47 @@ export interface LoopState {
     status: LoopStatus;
     startedAt: string;
     completedAt?: string;
+    /** Knowledge accumulated during the loop. */
+    knowledge?: LoopKnowledge;
+}
+/**
+ * Loop history entry — stored after loop completion.
+ * Ported from Salvador's LoopHistoryEntry.
+ */
+export interface LoopHistoryEntry {
+    id: string;
+    mode: LoopMode;
+    intent?: string;
+    prompt: string;
+    iterations: number;
+    outcome: 'completed' | 'cancelled' | 'max_iterations';
+    startedAt: string;
+    completedAt: string;
+}
+/**
+ * Gate decision returned by iterateWithGate().
+ * Ported from Salvador's LoopIterateDecision.
+ *
+ * - 'allow': Loop has ended (completed, max_iterations, or error). Exit the loop.
+ * - 'block': Loop continues. The returned prompt and systemMessage are injected
+ *   into the next iteration of the Stop hook.
+ */
+export interface LoopIterateDecision {
+    /** Gate decision: 'allow' to exit loop, 'block' to continue iterating. */
+    decision: 'allow' | 'block';
+    /** Human-readable reason for this decision. */
+    reason: string;
+    /** Full prompt for the next iteration (only when decision = 'block'). */
+    prompt?: string;
+    /** System message for the next iteration (only when decision = 'block'). */
+    systemMessage?: string;
+    /** Current iteration number. */
+    iteration?: number;
+    /** Outcome when loop ends (only when decision = 'allow'). */
+    outcome?: 'completed' | 'max_iterations';
+    /** Whether completion was auto-detected (heuristic, not explicit promise). */
+    autoCompleted?: boolean;
+    /** Warning if anomalous patterns detected in this iteration. */
+    anomalyWarning?: string;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/loop/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/loop/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,2EAA2E;AAC3E,MAAM,MAAM,QAAQ,GAChB,iBAAiB,GACjB,cAAc,GACd,iBAAiB,GACjB,gBAAgB,GAChB,QAAQ,CAAC;AAEb,6CAA6C;AAC7C,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,+CAA+C;AAC/C,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,6BAA6B;AAC7B,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,WAAW,GAAG,WAAW,GAAG,gBAAgB,CAAC;AAEjF,mDAAmD;AACnD,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,UAAU,CAAC;IACnB,UAAU,EAAE,aAAa,EAAE,CAAC;IAC5B,MAAM,EAAE,UAAU,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/loop/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,2EAA2E;AAC3E,MAAM,MAAM,QAAQ,GAChB,iBAAiB,GACjB,cAAc,GACd,iBAAiB,GACjB,gBAAgB,GAChB,QAAQ,CAAC;AAEb,6CAA6C;AAC7C,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,wFAAwF;IACxF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8DAA8D;IAC9D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4EAA4E;IAC5E,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,qEAAqE;IACrE,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,8FAA8F;IAC9F,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,+CAA+C;AAC/C,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,MAAM,EAAE,OAAO,CAAC;IAChB,kDAAkD;IAClD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,6BAA6B;AAC7B,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,WAAW,GAAG,WAAW,GAAG,gBAAgB,CAAC;AAEjF;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,qDAAqD;IACrD,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,2DAA2D;IAC3D,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;CAChC;AAED,mDAAmD;AACnD,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,UAAU,CAAC;IACnB,UAAU,EAAE,aAAa,EAAE,CAAC;IAC5B,MAAM,EAAE,UAAU,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6CAA6C;IAC7C,SAAS,CAAC,EAAE,aAAa,CAAC;CAC3B;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,WAAW,GAAG,WAAW,GAAG,gBAAgB,CAAC;IACtD,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,mBAAmB;IAClC,0EAA0E;IAC1E,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC;IAC5B,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4EAA4E;IAC5E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gCAAgC;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6DAA6D;IAC7D,OAAO,CAAC,EAAE,WAAW,GAAG,gBAAgB,CAAC;IACzC,8EAA8E;IAC9E,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,gEAAgE;IAChE,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB"}

package/dist/loop/types.js

@@ -2,7 +2,10 @@
  * Loop system types — iterative validation loop state tracking.
  *
  * Loops let agents run validate-fix-validate cycles (e.g. token migration,
- * contrast fixes, component builds). In-memory only — session-scoped.
+ * contrast fixes, component builds).
+ *
+ * Ported from Salvador's loop.facade.ts with full gate decision system,
+ * output scanning, and completion promise detection.
  */
 export {};
 //# sourceMappingURL=types.js.map

package/dist/loop/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/loop/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/loop/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/dist/persistence/index.d.ts

@@ -0,0 +1,3 @@
+export type { PersistenceProvider, PersistenceParams, RunResult, PersistenceConfig, } from './types.js';
+export { SQLitePersistenceProvider } from './sqlite-provider.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/persistence/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/persistence/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,mBAAmB,EACnB,iBAAiB,EACjB,SAAS,EACT,iBAAiB,GAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/persistence/index.js

@@ -0,0 +1,2 @@
+export { SQLitePersistenceProvider } from './sqlite-provider.js';
+//# sourceMappingURL=index.js.map

package/dist/persistence/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/persistence/index.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/persistence/sqlite-provider.d.ts

@@ -0,0 +1,25 @@
+/**
+ * SQLite persistence provider backed by better-sqlite3.
+ *
+ * Supports both positional (array) and named (object) parameters.
+ * Exposes getDatabase() for backward-compat consumers that need the raw db.
+ */
+import Database from 'better-sqlite3';
+import type { PersistenceProvider, PersistenceParams, RunResult } from './types.js';
+export declare class SQLitePersistenceProvider implements PersistenceProvider {
+    private db;
+    constructor(path?: string);
+    execSql(sql: string): void;
+    run(sql: string, params?: PersistenceParams): RunResult;
+    get<T = Record<string, unknown>>(sql: string, params?: PersistenceParams): T | undefined;
+    all<T = Record<string, unknown>>(sql: string, params?: PersistenceParams): T[];
+    transaction<T>(fn: () => T): T;
+    close(): void;
+    /**
+     * Escape hatch: get the raw better-sqlite3 Database.
+     * Used by modules that need direct db access (ProjectRegistry, BrainIntelligence, etc.).
+     * Will be deprecated once those modules migrate to PersistenceProvider.
+     */
+    getDatabase(): Database.Database;
+}
+//# sourceMappingURL=sqlite-provider.d.ts.map

package/dist/persistence/sqlite-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-provider.d.ts","sourceRoot":"","sources":["../../src/persistence/sqlite-provider.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,QAAQ,MAAM,gBAAgB,CAAC;AAGtC,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEpF,qBAAa,yBAA0B,YAAW,mBAAmB;IACnE,OAAO,CAAC,EAAE,CAAoB;gBAElB,IAAI,GAAE,MAAmB;IAKrC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAI1B,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,iBAAiB,GAAG,SAAS;IAOvD,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,iBAAiB,GAAG,CAAC,GAAG,SAAS;IAOxF,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,iBAAiB,GAAG,CAAC,EAAE;IAO9E,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC;IAI9B,KAAK,IAAI,IAAI;IAIb;;;;OAIG;IACH,WAAW,IAAI,QAAQ,CAAC,QAAQ;CAGjC"}

package/dist/persistence/sqlite-provider.js

@@ -0,0 +1,59 @@
+/**
+ * SQLite persistence provider backed by better-sqlite3.
+ *
+ * Supports both positional (array) and named (object) parameters.
+ * Exposes getDatabase() for backward-compat consumers that need the raw db.
+ */
+import Database from 'better-sqlite3';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+export class SQLitePersistenceProvider {
+    db;
+    constructor(path = ':memory:') {
+        if (path !== ':memory:')
+            mkdirSync(dirname(path), { recursive: true });
+        this.db = new Database(path);
+    }
+    execSql(sql) {
+        this.db.exec(sql);
+    }
+    run(sql, params) {
+        const stmt = this.db.prepare(sql);
+        if (!params)
+            return stmt.run();
+        if (Array.isArray(params))
+            return stmt.run(...params);
+        return stmt.run(params);
+    }
+    get(sql, params) {
+        const stmt = this.db.prepare(sql);
+        if (!params)
+            return stmt.get();
+        if (Array.isArray(params))
+            return stmt.get(...params);
+        return stmt.get(params);
+    }
+    all(sql, params) {
+        const stmt = this.db.prepare(sql);
+        if (!params)
+            return stmt.all();
+        if (Array.isArray(params))
+            return stmt.all(...params);
+        return stmt.all(params);
+    }
+    transaction(fn) {
+        return this.db.transaction(fn)();
+    }
+    close() {
+        this.db.close();
+    }
+    /**
+     * Escape hatch: get the raw better-sqlite3 Database.
+     * Used by modules that need direct db access (ProjectRegistry, BrainIntelligence, etc.).
+     * Will be deprecated once those modules migrate to PersistenceProvider.
+     */
+    getDatabase() {
+        return this.db;
+    }
+}
+//# sourceMappingURL=sqlite-provider.js.map

package/dist/persistence/sqlite-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-provider.js","sourceRoot":"","sources":["../../src/persistence/sqlite-provider.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,QAAQ,MAAM,gBAAgB,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,MAAM,OAAO,yBAAyB;IAC5B,EAAE,CAAoB;IAE9B,YAAY,OAAe,UAAU;QACnC,IAAI,IAAI,KAAK,UAAU;YAAE,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACvE,IAAI,CAAC,EAAE,GAAG,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAED,OAAO,CAAC,GAAW;QACjB,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACpB,CAAC;IAED,GAAG,CAAC,GAAW,EAAE,MAA0B;QACzC,MAAM,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC,GAAG,EAAE,CAAC;QAC/B,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC;YAAE,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC;QACtD,OAAO,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAC1B,CAAC;IAED,GAAG,CAA8B,GAAW,EAAE,MAA0B;QACtE,MAAM,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC,GAAG,EAAmB,CAAC;QAChD,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC;YAAE,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAkB,CAAC;QACvE,OAAO,IAAI,CAAC,GAAG,CAAC,MAAM,CAAkB,CAAC;IAC3C,CAAC;IAED,GAAG,CAA8B,GAAW,EAAE,MAA0B;QACtE,MAAM,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC,GAAG,EAAS,CAAC;QACtC,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC;YAAE,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAQ,CAAC;QAC7D,OAAO,IAAI,CAAC,GAAG,CAAC,MAAM,CAAQ,CAAC;IACjC,CAAC;IAED,WAAW,CAAI,EAAW;QACxB,OAAO,IAAI,CAAC,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,EAAE,CAAC;IACnC,CAAC;IAED,KAAK;QACH,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC;IAClB,CAAC;IAED;;;;OAIG;IACH,WAAW;QACT,OAAO,IAAI,CAAC,EAAE,CAAC;IACjB,CAAC;CACF"}

package/dist/persistence/types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Abstract persistence layer.
+ *
+ * Decouples Vault (and future modules) from any specific database engine.
+ * The default implementation is SQLitePersistenceProvider (better-sqlite3).
+ */
+export type PersistenceParams = unknown[] | Record<string, unknown>;
+export interface RunResult {
+    changes: number;
+    lastInsertRowid: number | bigint;
+}
+/**
+ * Minimal database provider interface.
+ *
+ * Supports both positional (`?`) and named (`@param`) parameter styles.
+ * Implementations must handle both array and object params.
+ */
+export interface PersistenceProvider {
+    /** Run raw SQL (DDL, multi-statement). No return value. */
+    execSql(sql: string): void;
+    /** Run a parameterized statement (INSERT, UPDATE, DELETE). */
+    run(sql: string, params?: PersistenceParams): RunResult;
+    /** Get a single row. Returns undefined if no match. */
+    get<T = Record<string, unknown>>(sql: string, params?: PersistenceParams): T | undefined;
+    /** Get all matching rows. */
+    all<T = Record<string, unknown>>(sql: string, params?: PersistenceParams): T[];
+    /** Run a function inside a transaction. Commits on success, rolls back on error. */
+    transaction<T>(fn: () => T): T;
+    /** Close the connection. */
+    close(): void;
+}
+export interface PersistenceConfig {
+    type: 'sqlite';
+    path: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/persistence/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/persistence/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,MAAM,iBAAiB,GAAG,OAAO,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpE,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,GAAG,MAAM,CAAC;CAClC;AAED;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,2DAA2D;IAC3D,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAE3B,8DAA8D;IAC9D,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,iBAAiB,GAAG,SAAS,CAAC;IAExD,uDAAuD;IACvD,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,iBAAiB,GAAG,CAAC,GAAG,SAAS,CAAC;IAEzF,6BAA6B;IAC7B,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,iBAAiB,GAAG,CAAC,EAAE,CAAC;IAE/E,oFAAoF;IACpF,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;IAE/B,4BAA4B;IAC5B,KAAK,IAAI,IAAI,CAAC;CACf;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd"}

package/dist/persistence/types.js

@@ -0,0 +1,8 @@
+/**
+ * Abstract persistence layer.
+ *
+ * Decouples Vault (and future modules) from any specific database engine.
+ * The default implementation is SQLitePersistenceProvider (better-sqlite3).
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/persistence/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/persistence/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/planning/gap-analysis.d.ts

@@ -1,23 +1,66 @@
 /**
- * 6-pass gap analysis engine for plan grading.
- * Ported from Salvador MCP's plan-gap-content.ts / plan-gap-technical.ts.
+ * Gap analysis engine for plan grading.
+ * Ported from Salvador MCP's plan-gap-content.ts / plan-gap-technical.ts /
+ * plan-gap-domain.ts / plan-gap-antipattern.ts.
  *
- * Passes:
+ * 6 built-in passes (always run):
  *   1. Structure     — required fields present and sufficiently long
  *   2. Completeness  — measurable objectives, decision rationale, scope exclusions
  *   3. Feasibility   — overly broad scope, missing dependency awareness
  *   4. Risk          — breaking changes without mitigation, missing verification
  *   5. Clarity       — ambiguous language, vague criteria
  *   6. Semantic Quality — generic objectives, shallow rationale, non-concrete approach
+ *
+ * Opt-in pass factories (registered via customPasses):
+ *   - createToolFeasibilityPass  — validates tool_chain entries and ordering
+ *   - createFlowAlignmentPass    — validates flow and target_mode against registries
+ *   - createAntiPatternPass      — detects content anti-patterns and vague criteria
  */
 import type { Plan } from './planner.js';
-import type { PlanGap } from './gap-types.js';
+import type { PlanGap, GapSeverity } from './gap-types.js';
 /** A custom gap analysis pass that agents can register. */
 export type GapAnalysisPass = (plan: Plan) => PlanGap[];
 export interface GapAnalysisOptions {
     /** Custom gap analysis passes appended after the 6 built-in passes. */
     customPasses?: GapAnalysisPass[];
 }
+/**
+ * Factory: tool chain feasibility pass.
+ * Validates that tool_chain entries are known and ordering rules are respected.
+ * Ported from Salvador's analyzeToolFeasibility.
+ *
+ * @param validTools - Set of valid tool names for this agent
+ * @param orderingRules - Ordering constraints (e.g., search before create)
+ */
+export declare function createToolFeasibilityPass(validTools: Set<string>, orderingRules?: Array<{
+    before: string;
+    after: string;
+    reason: string;
+}>): GapAnalysisPass;
+/**
+ * Factory: flow and mode alignment pass.
+ * Validates flow and target_mode against known values and intent alignment.
+ * Ported from Salvador's analyzeFlowAlignment.
+ *
+ * @param validFlows - Set of valid flow names for this agent
+ * @param validModes - Set of valid operational modes for this agent
+ * @param intentFlowMap - Maps detected intents to expected flows
+ */
+export declare function createFlowAlignmentPass(validFlows: Set<string>, validModes: Set<string>, intentFlowMap?: Record<string, string[]>): GapAnalysisPass;
+/**
+ * Factory: content anti-pattern pass.
+ * Detects common anti-patterns in plan content.
+ * Ported from Salvador's analyzeContentAntiPatterns.
+ *
+ * @param antiPatterns - Regex patterns to check against approach text
+ * @param mitigationPatterns - Patterns that indicate the plan is already mitigating
+ */
+export declare function createAntiPatternPass(antiPatterns?: Array<{
+    pattern: RegExp;
+    severity: GapSeverity;
+    description: string;
+    recommendation: string;
+}>, mitigationPatterns?: RegExp[]): GapAnalysisPass;
 /**
  * Run all 6 built-in gap analysis passes on a plan, plus any custom passes.
  * Returns a combined list of all gaps found, ordered by pass.

package/dist/planning/gap-analysis.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gap-analysis.d.ts","sourceRoot":"","sources":["../../src/planning/gap-analysis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,KAAK,EAAE,OAAO,EAA4B,MAAM,gBAAgB,CAAC;AAwcxE,2DAA2D;AAC3D,MAAM,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,EAAE,CAAC;AAExD,MAAM,WAAW,kBAAkB;IACjC,uEAAuE;IACvE,YAAY,CAAC,EAAE,eAAe,EAAE,CAAC;CAClC;AAID;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,EAAE,CAkBlF"}
+{"version":3,"file":"gap-analysis.d.ts","sourceRoot":"","sources":["../../src/planning/gap-analysis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAgB,MAAM,cAAc,CAAC;AACvD,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAe,MAAM,gBAAgB,CAAC;AAqfxE,2DAA2D;AAC3D,MAAM,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,EAAE,CAAC;AAExD,MAAM,WAAW,kBAAkB;IACjC,uEAAuE;IACvE,YAAY,CAAC,EAAE,eAAe,EAAE,CAAC;CAClC;AAOD;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,EACvB,aAAa,CAAC,EAAE,KAAK,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,GACvE,eAAe,CA2CjB;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,EACvB,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,EACvB,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GACvC,eAAe,CAoEjB;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,YAAY,CAAC,EAAE,KAAK,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,WAAW,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC,EACF,kBAAkB,CAAC,EAAE,MAAM,EAAE,GAC5B,eAAe,CAwDjB;AAID;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,EAAE,CAkBlF"}

package/dist/planning/gap-analysis.js

@@ -1,14 +1,20 @@
 /**
- * 6-pass gap analysis engine for plan grading.
- * Ported from Salvador MCP's plan-gap-content.ts / plan-gap-technical.ts.
+ * Gap analysis engine for plan grading.
+ * Ported from Salvador MCP's plan-gap-content.ts / plan-gap-technical.ts /
+ * plan-gap-domain.ts / plan-gap-antipattern.ts.
  *
- * Passes:
+ * 6 built-in passes (always run):
  *   1. Structure     — required fields present and sufficiently long
  *   2. Completeness  — measurable objectives, decision rationale, scope exclusions
  *   3. Feasibility   — overly broad scope, missing dependency awareness
  *   4. Risk          — breaking changes without mitigation, missing verification
  *   5. Clarity       — ambiguous language, vague criteria
  *   6. Semantic Quality — generic objectives, shallow rationale, non-concrete approach
+ *
+ * Opt-in pass factories (registered via customPasses):
+ *   - createToolFeasibilityPass  — validates tool_chain entries and ordering
+ *   - createFlowAlignmentPass    — validates flow and target_mode against registries
+ *   - createAntiPatternPass      — detects content anti-patterns and vague criteria
  */
 import { generateGapId, MIN_OBJECTIVE_LENGTH, MIN_SCOPE_LENGTH, MIN_DECISION_LENGTH, } from './gap-types.js';
 // ─── Helpers ─────────────────────────────────────────────────────
@@ -27,6 +33,14 @@ function gap(severity, category, description, recommendation, location, trigger)
 function taskText(plan) {
     return plan.tasks.map((t) => `${t.title} ${t.description}`).join(' ');
 }
+/** Extract text from a decision (supports both string and structured format). */
+function decisionText(d) {
+    return typeof d === 'string' ? d : `${d.decision} ${d.rationale}`;
+}
+/** Combine all decisions into a single text blob. */
+function decisionsText(plan) {
+    return plan.decisions.map(decisionText).join(' ');
+}
 /** Check if text contains any of the given patterns (case-insensitive). */
 function containsAny(text, patterns) {
     const lower = text.toLowerCase();
@@ -63,7 +77,16 @@ const METRIC_PATTERNS = [
     /metric/i,
     /benchmark/i,
 ];
-const EXCLUSION_KEYWORDS = ['not', 'exclude', 'outside', 'beyond', 'limit', 'except', 'won\'t', 'will not'];
+const EXCLUSION_KEYWORDS = [
+    'not',
+    'exclude',
+    'outside',
+    'beyond',
+    'limit',
+    'except',
+    "won't",
+    'will not',
+];
 function analyzeCompleteness(plan) {
     const gaps = [];
     // Objective lacks measurable indicators
@@ -74,8 +97,9 @@ function analyzeCompleteness(plan) {
     if (plan.decisions.length > 0) {
         for (let i = 0; i < plan.decisions.length; i++) {
             const d = plan.decisions[i];
-            if (d.trim().length < MIN_DECISION_LENGTH) {
-                gaps.push(gap('major', 'completeness', `Decision ${i + 1} is too short (${d.trim().length} chars) — lacks rationale.`, 'Expand each decision to include the reasoning (why this choice over alternatives).', `decisions[${i}]`, 'short_decision'));
+            const text = decisionText(d);
+            if (text.trim().length < MIN_DECISION_LENGTH) {
+                gaps.push(gap('major', 'completeness', `Decision ${i + 1} is too short (${text.trim().length} chars) — lacks rationale.`, 'Expand each decision to include the reasoning (why this choice over alternatives).', `decisions[${i}]`, 'short_decision'));
             }
         }
     }
@@ -95,7 +119,14 @@ const OVERLY_BROAD_PATTERNS = [
     'total overhaul',
     'rewrite everything',
 ];
-const DEPENDENCY_KEYWORDS = ['depends', 'dependency', 'prerequisite', 'requires', 'blocked', 'before'];
+const DEPENDENCY_KEYWORDS = [
+    'depends',
+    'dependency',
+    'prerequisite',
+    'requires',
+    'blocked',
+    'before',
+];
 function analyzeFeasibility(plan) {
     const gaps = [];
     const scopeAndTasks = `${plan.scope} ${taskText(plan)}`;
@@ -135,12 +166,22 @@ const MITIGATION_KEYWORDS = [
     'canary',
     'blue-green',
 ];
-const VERIFICATION_KEYWORDS = ['test', 'verify', 'validate', 'check', 'assert', 'confirm', 'spec', 'coverage'];
+const VERIFICATION_KEYWORDS = [
+    'test',
+    'verify',
+    'validate',
+    'check',
+    'assert',
+    'confirm',
+    'spec',
+    'coverage',
+];
 function analyzeRisk(plan) {
     const gaps = [];
-    const allText = `${plan.objective} ${plan.scope} ${taskText(plan)} ${plan.decisions.join(' ')}`;
+    const allText = `${plan.objective} ${plan.scope} ${taskText(plan)} ${decisionsText(plan)}`;
     // Breaking changes without mitigation
-    if (containsAny(allText, BREAKING_CHANGE_KEYWORDS) && !containsAny(allText, MITIGATION_KEYWORDS)) {
+    if (containsAny(allText, BREAKING_CHANGE_KEYWORDS) &&
+        !containsAny(allText, MITIGATION_KEYWORDS)) {
         gaps.push(gap('major', 'risk', 'Plan involves breaking changes but mentions no mitigation strategy.', 'Add a rollback plan, feature flags, or phased migration approach.', undefined, 'breaking_without_mitigation'));
     }
     // No verification/testing mentioned
@@ -169,7 +210,7 @@ const AMBIGUOUS_WORDS = [
 ];
 function analyzeClarity(plan) {
     const gaps = [];
-    const allText = `${plan.objective} ${plan.scope} ${plan.decisions.join(' ')}`;
+    const allText = `${plan.objective} ${plan.scope} ${decisionsText(plan)}`;
     const lower = allText.toLowerCase();
     // Ambiguous language
     const found = AMBIGUOUS_WORDS.filter((w) => {
@@ -192,7 +233,15 @@ const GENERIC_OBJECTIVE_PATTERNS = [
     /^fix\s+\w+$/i,
     /^update\s+\w+$/i,
 ];
-const RATIONALE_INDICATORS = ['because', 'since', 'due to', 'in order to', 'so that', 'given that', 'as a result'];
+const RATIONALE_INDICATORS = [
+    'because',
+    'since',
+    'due to',
+    'in order to',
+    'so that',
+    'given that',
+    'as a result',
+];
 const SHALLOW_INDICATORS = ['better', 'good', 'best', 'nice', 'great', 'improved'];
 function analyzeSemanticQuality(plan) {
     const gaps = [];
@@ -213,7 +262,7 @@ function analyzeSemanticQuality(plan) {
     }
     // Decisions with shallow rationale (uses "better/good" without "because/since")
     for (let i = 0; i < plan.decisions.length; i++) {
-        const d = plan.decisions[i];
+        const d = decisionText(plan.decisions[i]);
         const hasShallow = containsAny(d, SHALLOW_INDICATORS);
         const hasRationale = containsAny(d, RATIONALE_INDICATORS);
         if (hasShallow && !hasRationale) {
@@ -237,6 +286,134 @@ function analyzeSemanticQuality(plan) {
     }
     return gaps;
 }
+// ─── Opt-In Pass Factories ──────────────────────────────────────
+// Ported from Salvador's plan-gap-technical.ts, plan-gap-domain.ts,
+// and plan-gap-antipattern.ts. These are parameterized factories that
+// agents register via customPasses.
+/**
+ * Factory: tool chain feasibility pass.
+ * Validates that tool_chain entries are known and ordering rules are respected.
+ * Ported from Salvador's analyzeToolFeasibility.
+ *
+ * @param validTools - Set of valid tool names for this agent
+ * @param orderingRules - Ordering constraints (e.g., search before create)
+ */
+export function createToolFeasibilityPass(validTools, orderingRules) {
+    return (plan) => {
+        const gaps = [];
+        const toolChain = plan.tool_chain;
+        if (!toolChain || toolChain.length === 0)
+            return gaps;
+        // Validate tool names
+        const invalidTools = toolChain.filter((t) => !validTools.has(t));
+        if (invalidTools.length > 0) {
+            gaps.push(gap('critical', 'tool-feasibility', `Invalid tool names in tool_chain: ${invalidTools.join(', ')}`, 'Use valid tool names. Check available tools for this agent.', 'tool_chain', `invalid_tools:${invalidTools.join(',')}`));
+        }
+        // Validate ordering rules
+        if (orderingRules) {
+            for (const rule of orderingRules) {
+                const beforeIndex = toolChain.indexOf(rule.before);
+                const afterIndex = toolChain.indexOf(rule.after);
+                if (beforeIndex !== -1 && afterIndex !== -1 && beforeIndex > afterIndex) {
+                    gaps.push(gap('major', 'tool-feasibility', `Tool ordering violation: ${rule.before} must come before ${rule.after}`, rule.reason, 'tool_chain', `ordering:${rule.before}>${rule.after}`));
+                }
+            }
+        }
+        return gaps;
+    };
+}
+/**
+ * Factory: flow and mode alignment pass.
+ * Validates flow and target_mode against known values and intent alignment.
+ * Ported from Salvador's analyzeFlowAlignment.
+ *
+ * @param validFlows - Set of valid flow names for this agent
+ * @param validModes - Set of valid operational modes for this agent
+ * @param intentFlowMap - Maps detected intents to expected flows
+ */
+export function createFlowAlignmentPass(validFlows, validModes, intentFlowMap) {
+    return (plan) => {
+        const gaps = [];
+        if (plan.flow && !validFlows.has(plan.flow)) {
+            gaps.push(gap('major', 'flow-alignment', `Invalid flow: ${plan.flow}`, `Valid flows are: ${Array.from(validFlows).join(', ')}`, 'flow', `invalid_flow:${plan.flow}`));
+        }
+        if (plan.target_mode && !validModes.has(plan.target_mode)) {
+            gaps.push(gap('major', 'flow-alignment', `Invalid target_mode: ${plan.target_mode}`, `Valid modes are: ${Array.from(validModes).join(', ')}`, 'target_mode', `invalid_mode:${plan.target_mode}`));
+        }
+        // Intent-flow alignment (optional)
+        if (intentFlowMap && plan.flow) {
+            const objectiveLower = (plan.objective || '').toLowerCase();
+            let detectedIntent = null;
+            if (/\b(create|build|implement|add|new)\b/.test(objectiveLower)) {
+                detectedIntent = 'CREATE';
+            }
+            else if (/\b(fix|debug|repair|resolve|bug)\b/.test(objectiveLower)) {
+                detectedIntent = 'FIX';
+            }
+            else if (/\b(review|audit|check|validate|inspect)\b/.test(objectiveLower)) {
+                detectedIntent = 'REVIEW';
+            }
+            else if (/\b(plan|design|architect|structure)\b/.test(objectiveLower)) {
+                detectedIntent = 'PLAN';
+            }
+            else if (/\b(enhance|improve|refactor|optimize)\b/.test(objectiveLower)) {
+                detectedIntent = 'ENHANCE';
+            }
+            else if (/\b(deliver|package|publish|deploy|release)\b/.test(objectiveLower)) {
+                detectedIntent = 'DELIVER';
+            }
+            if (detectedIntent) {
+                const expectedFlows = intentFlowMap[detectedIntent] || [];
+                if (expectedFlows.length > 0 && !expectedFlows.includes(plan.flow)) {
+                    gaps.push(gap('minor', 'flow-alignment', `Flow '${plan.flow}' may not align with detected intent '${detectedIntent}'`, `Consider using flow: ${expectedFlows.join(' or ')}`, 'flow', `intent_flow_mismatch:${detectedIntent}->${plan.flow}`));
+                }
+            }
+        }
+        return gaps;
+    };
+}
+/**
+ * Factory: content anti-pattern pass.
+ * Detects common anti-patterns in plan content.
+ * Ported from Salvador's analyzeContentAntiPatterns.
+ *
+ * @param antiPatterns - Regex patterns to check against approach text
+ * @param mitigationPatterns - Patterns that indicate the plan is already mitigating
+ */
+export function createAntiPatternPass(antiPatterns, mitigationPatterns) {
+    const VAGUE_CRITERIA_PATTERNS = [
+        /^it (looks?|works?|is) (good|nice|fine|great|ok|correct)/i,
+        /^(looks?|works?) (good|nice|fine|great|ok)/i,
+        /^it('s| is) (done|complete|finished)/i,
+        /\bmy machine\b/i,
+    ];
+    return (plan) => {
+        const gaps = [];
+        const approach = (plan.approach || '').toLowerCase();
+        const criteria = plan.success_criteria || [];
+        const fullText = [approach, ...criteria].join(' ').toLowerCase();
+        // Check if plan is actively mitigating known anti-patterns
+        const isMitigating = mitigationPatterns
+            ? mitigationPatterns.some((p) => p.test(fullText))
+            : false;
+        // Custom anti-pattern checks
+        if (!isMitigating && antiPatterns) {
+            for (const ap of antiPatterns) {
+                if (ap.pattern.test(approach)) {
+                    gaps.push(gap(ap.severity, 'anti-pattern', ap.description, ap.recommendation, 'approach', `anti_pattern:${ap.description}`));
+                }
+            }
+        }
+        // Vague success criteria (generic — always checked)
+        for (const criterion of criteria) {
+            const isVague = VAGUE_CRITERIA_PATTERNS.some((p) => p.test(criterion));
+            if (isVague) {
+                gaps.push(gap('minor', 'anti-pattern', `Success criterion is not measurable: "${criterion}"`, 'Rewrite as a verifiable assertion: "Component renders X", "All Y pass Z", "No A in B".', 'success_criteria', `vague_criterion:${criterion}`));
+            }
+        }
+        return gaps;
+    };
+}
 // ─── Orchestrator ────────────────────────────────────────────────
 /**
  * Run all 6 built-in gap analysis passes on a plan, plus any custom passes.