monomind 1.10.57 → 1.11.0

package/packages/@monomind/cli/dist/src/memory/memory-bridge.js

@@ -56,6 +56,11 @@ export function safeParseEmbedding(raw) {
     }
     return parsed;
 }
+// ===== Embedding model constants — single source of truth =====
+// Changing these requires rebuilding stored embeddings (dimension mismatch silently
+// degrades search to BM25-only; see bridgeSearchEntries dimension-mismatch handling).
+const BRIDGE_EMBEDDING_MODEL = 'Xenova/all-MiniLM-L6-v2';
+const BRIDGE_EMBEDDING_DIMS = 384;
 // ===== Lazy singleton =====
 // registryInstance is typed as `any` because ControllerRegistry lives in @monomind/memory
 // and cross-package type resolution is currently broken. When that is fixed, replace with
@@ -63,8 +68,15 @@ export function safeParseEmbedding(raw) {
 let registryPromise = null;
 let registryInstance = null;
 let bridgeAvailable = null;
+// Allow up to 3 init attempts before permanently latching unavailable.
+// Transient failures (e.g. model not yet downloaded, sqlite cold-start) should
+// not permanently degrade the process. After MAX_INIT_ATTEMPTS the latch is set.
+const MAX_INIT_ATTEMPTS = 3;
+let initAttempts = 0;
 /** Backpressure flag for A-MEM Zettelkasten linking — see bridgeStoreEntry. */
 let _amemInFlight = false;
+/** OR-3: Count SONA learning failures so callers can detect degraded state. */
+let _sonaErrorCount = 0;
 /**
  * Resolve database path with path traversal protection.
  * Only allows paths within or below the project's .swarm directory,
@@ -83,6 +95,11 @@ function getDbPath(customPath) {
     if (rel.startsWith('..') || path.isAbsolute(rel)) {
         return path.join(swarmDir, 'memory.db'); // fallback to safe default
     }
+    // Reject non-.db paths — prevents plugins from passing e.g. 'package.json'
+    // and having SQLite truncate/corrupt it on first open.
+    if (!resolved.endsWith('.db')) {
+        return path.join(swarmDir, 'memory.db');
+    }
     return resolved;
 }
 /**
@@ -98,12 +115,16 @@ function generateId(prefix) {
 async function getRegistry(dbPath) {
     if (bridgeAvailable === false)
         return null;
+    if (initAttempts >= MAX_INIT_ATTEMPTS) {
+        bridgeAvailable = false;
+        return null;
+    }
     if (registryInstance)
         return registryInstance;
     if (!registryPromise) {
         registryPromise = (async () => {
             try {
-                const { ControllerRegistry } = await import('@monomind/memory');
+                const { ControllerRegistry } = await import('@monoes/memory');
                 const registry = new ControllerRegistry();
                 // Suppress noisy console.log during init
                 const origLog = console.log;
@@ -113,17 +134,20 @@ async function getRegistry(dbPath) {
                         msg.includes('better-sqlite3') ||
                         msg.includes('[AgentDB]') ||
                         msg.includes('[HNSWLibBackend]') ||
-                        msg.includes('RuVector graph'))
+                        msg.includes('MonoVector graph'))
                         return;
                     origLog.apply(console, args);
                 };
                 try {
                     await registry.initialize({
                         dbPath: dbPath || getDbPath(),
-                        embeddingModel: 'Xenova/all-MiniLM-L6-v2',
-                        dimension: 384,
+                        embeddingModel: BRIDGE_EMBEDDING_MODEL,
+                        dimension: BRIDGE_EMBEDDING_DIMS,
                         controllers: {
                             reasoningBank: true,
+                            // learningBridge enables SONA/LoRA pattern learning — re-enabled after
+                            // confirming LearningBridge init errors are isolated per-controller in
+                            // ControllerRegistry and do not propagate to bridgeAvailable = false.
                             learningBridge: true,
                             tieredCache: true,
                             hierarchicalMemory: true,
@@ -140,8 +164,11 @@ async function getRegistry(dbPath) {
                 return registry;
             }
             catch {
-                bridgeAvailable = false;
+                initAttempts++;
                 registryPromise = null;
+                if (initAttempts >= MAX_INIT_ATTEMPTS) {
+                    bridgeAvailable = false;
+                }
                 return null;
             }
         })();
@@ -379,7 +406,7 @@ export async function bridgeStoreEntry(options) {
                     if (emb) {
                         embeddingJson = JSON.stringify(Array.from(emb));
                         dimensions = emb.length;
-                        model = 'Xenova/all-MiniLM-L6-v2';
+                        model = BRIDGE_EMBEDDING_MODEL;
                     }
                 }
             }
@@ -425,7 +452,12 @@ export async function bridgeStoreEntry(options) {
             void (async () => {
                 try {
                     const neighbors = await bridgeSearchEntries({
-                        query: options.value,
+                        query: (() => {
+                            // Snap to last sentence boundary within 512 chars to avoid cutting mid-phrase.
+                            const raw = options.value.slice(0, 512);
+                            const snapped = raw.replace(/[^.!?\n]*$/, '');
+                            return snapped.trim() || raw;
+                        })(),
                         namespace: options.namespace,
                         limit: 3,
                         threshold: 0.7,
@@ -682,17 +714,33 @@ export async function bridgeGetEntry(options) {
         }
         // Collaborative memory promotion: track agent reads for auto-promotion to 'team'
         // Source: https://arxiv.org/abs/2505.18279
+        //
+        // Security: agentId is caller-supplied. Two guards prevent a single process
+        // from fabricating 3 different IDs to force-promote a private entry:
+        //   1. Format validation — rejects non-standard IDs before they touch the DB
+        //   2. Time-spread check — the 3 reads must span ≥5 minutes, making rapid
+        //      batch escalation observable and impractical within a single session
         if (options.agentId) {
-            try {
-                ctx.db.prepare('INSERT OR IGNORE INTO agent_reads (entry_id, agent_id, read_at) VALUES (?, ?, ?)').run(row.id, options.agentId, Date.now());
-                // Check if 3+ distinct agents read in past 24h → promote to 'team'
-                const cutoff = Date.now() - 24 * 60 * 60 * 1000;
-                const countRow = ctx.db.prepare('SELECT COUNT(DISTINCT agent_id) as cnt FROM agent_reads WHERE entry_id = ? AND read_at > ?').get(row.id, cutoff);
-                if ((countRow?.cnt ?? 0) >= 3) {
-                    ctx.db.prepare("UPDATE memory_entries SET access_level = 'team' WHERE id = ? AND access_level = 'private'").run(row.id);
+            const AGENT_ID_RE = /^[a-zA-Z0-9_\-.]{1,128}$/;
+            if (AGENT_ID_RE.test(options.agentId)) {
+                try {
+                    const now = Date.now();
+                    ctx.db.prepare('INSERT OR IGNORE INTO agent_reads (entry_id, agent_id, read_at) VALUES (?, ?, ?)').run(row.id, options.agentId, now);
+                    const cutoff = now - 24 * 60 * 60 * 1000;
+                    const SPREAD_MS = 5 * 60 * 1000; // reads must span ≥5 min to count
+                    const stats = ctx.db.prepare(`SELECT COUNT(DISTINCT agent_id) as cnt,
+                    MIN(read_at) as earliest,
+                    MAX(read_at) as latest
+             FROM agent_reads WHERE entry_id = ? AND read_at > ?`).get(row.id, cutoff);
+                    // Require 3+ distinct-agent reads AND earliest+latest span ≥5 min
+                    const distinctAgents = stats?.cnt ?? 0;
+                    const spread = stats ? (stats.latest - stats.earliest) : 0;
+                    if (distinctAgents >= 3 && spread >= SPREAD_MS) {
+                        ctx.db.prepare("UPDATE memory_entries SET access_level = 'team' WHERE id = ? AND access_level = 'private'").run(row.id);
+                    }
                 }
+                catch { /* non-critical */ }
             }
-            catch { /* non-critical */ }
         }
         // Bounded tags read — refuse to JSON.parse a multi-MB tags blob that an
         // older write may have persisted before the write-side cap was added.
@@ -806,7 +854,7 @@ export async function bridgeGenerateEmbedding(text, dbPath) {
         return {
             embedding: Array.from(emb),
             dimensions: emb.length,
-            model: 'Xenova/all-MiniLM-L6-v2',
+            model: BRIDGE_EMBEDDING_MODEL,
         };
     }
     catch {
@@ -834,7 +882,7 @@ export async function bridgeLoadEmbeddingModel(dbPath) {
         return {
             success: true,
             dimensions: test.length,
-            modelName: 'Xenova/all-MiniLM-L6-v2',
+            modelName: BRIDGE_EMBEDDING_MODEL,
             loadTime: Date.now() - startTime,
         };
     }
@@ -868,7 +916,7 @@ export async function bridgeGetHNSWStatus(dbPath) {
             available: true,
             initialized: true,
             entryCount,
-            dimensions: 384,
+            dimensions: BRIDGE_EMBEDDING_DIMS,
         };
     }
     catch {
@@ -965,8 +1013,8 @@ export async function bridgeAddToHNSW(id, embedding, entry, dbPath) {
         id, key, namespace, content, type,
         embedding, embedding_dimensions, embedding_model,
         created_at, updated_at, status
-      ) VALUES (?, ?, ?, ?, 'semantic', ?, ?, 'Xenova/all-MiniLM-L6-v2', ?, ?, 'active')
-    `).run(id, entry.key, entry.namespace, entry.content, embeddingJson, embedding.length, now, now);
+      ) VALUES (?, ?, ?, ?, 'semantic', ?, ?, ?, ?, ?, 'active')
+    `).run(id, entry.key, entry.namespace, entry.content, embeddingJson, embedding.length, BRIDGE_EMBEDDING_MODEL, now, now);
         return true;
     }
     catch {
@@ -1047,6 +1095,7 @@ export async function shutdownBridge() {
         registryInstance = null;
         registryPromise = null;
         bridgeAvailable = null;
+        initAttempts = 0;
     }
 }
 // ===== Phase 3: ReasoningBank pattern operations =====
@@ -1197,6 +1246,10 @@ export async function bridgeRecordFeedback(options) {
                 controller += '+skills';
             }
         }
+        // SONA learning feed removed (lean teardown): the per-task ONNX/embedding
+        // write-path via LearningBridge.onInsightRecorded/consolidate is gone. Routing
+        // learning is preserved through the file-based route-outcomes records and the
+        // keyword router; the heavyweight neural trajectory feed was pure overhead.
         // Always store feedback as a memory entry for retrieval (ensures it persists)
         const storeResult = await bridgeStoreEntry({
             key: `feedback-${options.taskId}`,
@@ -1348,7 +1401,7 @@ export async function bridgeSessionEnd(options) {
 // ===== Phase 5: SemanticRouter bridge =====
 /**
  * Route a task via AgentDB's SemanticRouter.
- * Returns null to fall back to local ruvector router.
+ * Returns null to fall back to local monovector router.
  */
 export async function bridgeRouteTask(options) {
     const registry = await getRegistry(options.dbPath);
@@ -1410,7 +1463,7 @@ export async function bridgeHealthCheck(dbPath) {
             const s = cache.stats();
             cacheStats = { size: s.size ?? 0, hits: s.hits ?? 0, misses: s.misses ?? 0 };
         }
-        return { available: true, controllers, attestationCount, cacheStats };
+        return { available: true, controllers, attestationCount, cacheStats, sonaErrorCount: _sonaErrorCount };
     }
     catch {
         return null;
@@ -1618,7 +1671,7 @@ export async function bridgeContextSynthesize(params) {
 }
 /**
  * Route via SemanticRouter.
- * Available since agentdb 3.0.0-alpha.10 — uses @ruvector/router for
+ * Available since agentdb 3.0.0-alpha.10 — uses @monoes/router for
  * semantic matching with keyword fallback.
  */
 export async function bridgeSemanticRoute(params) {

package/packages/@monomind/cli/dist/src/memory/memory-initializer.d.ts

@@ -123,8 +123,8 @@ export declare function softmaxAttention(scores: Float32Array, temperature?: num
 export declare function topKIndices(scores: Float32Array, k: number): number[];
 /**
  * Flash Attention-style search
- * Combines batch similarity, softmax, and top-k in one pass
- * Returns indices and attention weights
+ * Combines batch similarity, softmax, and top-k in one pass.
+ * Returns indices and attention weights.
  */
 export declare function flashAttentionSearch(query: Float32Array | number[], vectors: (Float32Array | number[])[], options?: {
     k?: number;

package/packages/@monomind/cli/dist/src/memory/memory-initializer.js

@@ -373,24 +373,26 @@ export async function getHNSWIndex(options) {
         if (hnswInitializing) {
             throw new Error('HNSW initialization timed out after 5s');
         }
-        return hnswIndex;
+        // Init may have failed — return null rather than a non-initialized index object
+        return hnswIndex?.initialized ? hnswIndex : null;
     }
     hnswInitializing = true;
     try {
-        // Import @ruvector/core dynamically
-        // Handle both ESM (default export) and CJS patterns
-        const ruvectorModule = await import('@ruvector/core').catch(() => null);
-        if (!ruvectorModule) {
+        // Lean teardown: the native @monoes/core HNSW backend (WASM VectorDb) has been
+        // removed. Callers of getHNSWIndex() already treat a null return as "no native
+        // index — use the pure-JS / brute-force fallback", so we short-circuit here.
+        const monovectorModule = await import('@monoes/core').catch(() => null);
+        if (!monovectorModule) {
             hnswInitializing = false;
-            return null; // HNSW not available
+            return null; // HNSW not available — pure-JS fallback path
         }
         // ESM returns { default: { VectorDb, ... } }, CJS returns { VectorDb, ... }
-        const ruvectorCore = ruvectorModule.default || ruvectorModule;
-        if (!ruvectorCore?.VectorDb) {
+        const monovectorCore = monovectorModule.default || monovectorModule;
+        if (!monovectorCore?.VectorDb) {
             hnswInitializing = false;
             return null; // VectorDb not found
         }
-        const { VectorDb } = ruvectorCore;
+        const { VectorDb } = monovectorCore;
         // Persistent storage paths — resolve to absolute to survive CWD changes
         const swarmDir = path.resolve(process.cwd(), '.swarm');
         if (!fs.existsSync(swarmDir)) {
@@ -400,7 +402,7 @@ export async function getHNSWIndex(options) {
         const metadataPath = path.join(swarmDir, 'hnsw.metadata.json');
         const dbPath = options?.dbPath ? path.resolve(options.dbPath) : path.join(swarmDir, 'memory.db');
         // Create HNSW index with persistent storage
-        // @ruvector/core uses string enum for distanceMetric: 'Cosine', 'Euclidean', 'DotProduct', 'Manhattan'
+        // @monoes/core uses string enum for distanceMetric: 'Cosine', 'Euclidean', 'DotProduct', 'Manhattan'
         const db = new VectorDb({
             dimensions,
             distanceMetric: 'Cosine',
@@ -486,6 +488,8 @@ export async function getHNSWIndex(options) {
                 // SQLite load failed, start with empty index
             }
         }
+        // initialized = true even on empty DB — absence of vectors is a valid ready state,
+        // not a failure. The concurrent-waiter null-check at line ~395 relies on this.
         hnswIndex.initialized = true;
         hnswInitializing = false;
         return hnswIndex;
@@ -572,7 +576,7 @@ export async function searchHNSWIndex(queryEmbedding, options) {
                 continue;
             }
             // Convert cosine distance to similarity score (1 - distance)
-            // Cosine distance from @ruvector/core: 0 = identical, 2 = opposite
+            // Cosine distance from @monoes/core: 0 = identical, 2 = opposite
             const score = 1 - (result.score / 2);
             filtered.push({
                 id: entry.id.substring(0, 12),
@@ -818,25 +822,16 @@ export function topKIndices(scores, k) {
 }
 /**
  * Flash Attention-style search
- * Combines batch similarity, softmax, and top-k in one pass
- * Returns indices and attention weights
+ * Combines batch similarity, softmax, and top-k in one pass.
+ * Returns indices and attention weights.
  */
 export function flashAttentionSearch(query, vectors, options = {}) {
     const { k = 10, temperature = 1.0, threshold = 0 } = options;
-    // Compute batch similarity
     const scores = batchCosineSim(query, vectors);
-    // Get top-k indices
-    const indices = topKIndices(scores, k);
-    // Filter by threshold
-    const filtered = indices.filter(i => scores[i] >= threshold);
-    // Extract scores for filtered results
-    const topScores = new Float32Array(filtered.length);
-    for (let i = 0; i < filtered.length; i++) {
-        topScores[i] = scores[filtered[i]];
-    }
-    // Compute attention weights (softmax over top-k)
+    const indices = topKIndices(scores, k).filter(i => scores[i] >= threshold);
+    const topScores = new Float32Array(indices.map(i => scores[i]));
     const weights = softmaxAttention(topScores, temperature);
-    return { indices: filtered, scores: topScores, weights };
+    return { indices, scores: topScores, weights };
 }
 // ============================================================================
 // METADATA AND INITIALIZATION
@@ -1375,22 +1370,22 @@ export async function loadEmbeddingModel(options) {
                 loadTime: Date.now() - startTime
             };
         }
-        // Fallback: Check for ruvector ONNX embedder (bundled MiniLM-L6-v2 since v0.2.15)
+        // Fallback: Check for monovector ONNX embedder (bundled MiniLM-L6-v2 since v0.2.15)
         // v0.2.16: LoRA B=0 fix makes AdaptiveEmbedder safe (identity when untrained)
         // Note: isReady() returns false until first embed() call (lazy init), so we
         // skip the isReady() gate and verify with a probe embed instead.
-        const ruvector = await import('ruvector').catch(() => null);
-        if (ruvector?.initOnnxEmbedder) {
+        const monovector = await import('monovector').catch(() => null);
+        if (monovector?.initOnnxEmbedder) {
             try {
-                await ruvector.initOnnxEmbedder();
+                await monovector.initOnnxEmbedder();
                 // Fallback: OptimizedOnnxEmbedder (raw ONNX, lazy-inits on first embed)
-                const onnxEmb = ruvector.getOptimizedOnnxEmbedder?.();
+                const onnxEmb = monovector.getOptimizedOnnxEmbedder?.();
                 if (onnxEmb?.embed) {
                     // Probe embed to trigger lazy ONNX init and verify it works
                     const probe = await onnxEmb.embed('test');
                     if (probe && probe.length > 0 && (Array.isArray(probe) ? probe.some((v) => v !== 0) : true)) {
                         if (verbose) {
-                            console.log(`Loading ruvector ONNX embedder (all-MiniLM-L6-v2, ${probe.length}d)...`);
+                            console.log(`Loading monovector ONNX embedder (all-MiniLM-L6-v2, ${probe.length}d)...`);
                         }
                         embeddingModelState = {
                             loaded: true,
@@ -1401,14 +1396,14 @@ export async function loadEmbeddingModel(options) {
                         return {
                             success: true,
                             dimensions: probe.length || 384,
-                            modelName: 'ruvector/onnx',
+                            modelName: 'monovector/onnx',
                             loadTime: Date.now() - startTime
                         };
                     }
                 }
             }
             catch {
-                // ruvector ONNX init failed, continue to next fallback
+                // monovector ONNX init failed, continue to next fallback
             }
         }
         // Legacy fallback: Check for agentic-flow core embeddings
@@ -1481,7 +1476,7 @@ export async function generateEmbedding(text) {
     if (state.model && typeof state.model === 'function') {
         try {
             const output = await state.model(text, { pooling: 'mean', normalize: true });
-            // Handle both @xenova/transformers (output.data) and ruvector (plain array) formats
+            // Handle both @xenova/transformers (output.data) and monovector (plain array) formats
             const embedding = output?.data
                 ? Array.from(output.data)
                 : Array.isArray(output) ? output : null;
@@ -1822,13 +1817,14 @@ export async function storeEntry(options) {
         // Add to HNSW index for faster future searches (validated to reject malformed embeddings)
         if (embeddingJson) {
             const embResult = safeParseEmbeddingLocal(embeddingJson);
-            if (embResult)
+            if (embResult) {
                 await addToHNSWIndex(id, embResult, {
                     id,
                     key,
                     namespace,
                     content: value
                 });
+            }
         }
         return {
             success: true,
@@ -1915,10 +1911,12 @@ export async function searchEntries(options) {
                 if (score < threshold) {
                     const lowerContent = (content || '').toLowerCase();
                     const lowerQuery = query.toLowerCase();
-                    const words = lowerQuery.split(/\s+/);
-                    const matchCount = words.filter(w => lowerContent.includes(w)).length;
-                    const keywordScore = matchCount / words.length * 0.5;
-                    score = Math.max(score, keywordScore);
+                    const words = lowerQuery.split(/\s+/).filter(w => w.length > 0);
+                    if (words.length > 0) {
+                        const matchCount = words.filter(w => lowerContent.includes(w)).length;
+                        const keywordScore = matchCount / words.length * 0.5;
+                        score = Math.max(score, keywordScore);
+                    }
                 }
                 if (score >= threshold) {
                     results.push({

package/packages/@monomind/cli/dist/src/monovector/capabilities.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Capability surface for the (removed) @monoes/* native learning packages.
+ *
+ * Lean teardown: the SONA / native / WASM learning layer (@monoes/sona, router,
+ * attention, learning-wasm, core, and @monomind/monovector-upstream) has been
+ * removed. This module is now a stub that always reports "nothing native is
+ * available", so every caller takes the pure-JS / keyword-routing path. The
+ * function and type surface is preserved so importers (index.ts, hooks-tools.ts,
+ * doctor.ts, neural.ts) keep compiling without change.
+ */
+export interface MonoesCapabilities {
+    /** @monoes/sona SonaEngine available — always false after teardown */
+    sona: boolean;
+    /** @monoes/router backend — always 'none' after teardown */
+    router: 'native' | 'js' | 'none';
+    /** @monoes/attention FlashAttention available — always false after teardown */
+    attention: boolean;
+    /** @monoes/learning-wasm WasmMicroLoRA available — always false after teardown */
+    learningWasm: boolean;
+    /** @monomind/monovector-upstream plugin loaded — always false after teardown */
+    upstreamPlugin: boolean;
+}
+/**
+ * Returns the stubbed capability surface — all native backends report absent.
+ * Async to preserve the original signature; callers `await` this everywhere.
+ */
+export declare function getCapabilities(): Promise<MonoesCapabilities>;
+/** Synchronous read of the (constant) capability surface. */
+export declare function getCachedCapabilities(): MonoesCapabilities | null;
+/** No-op after teardown — there is nothing to re-probe. */
+export declare function resetCapabilitiesCache(): void;
+/** Returns the stubbed capability surface — kept for API compatibility. */
+export declare function refreshCapabilities(): Promise<MonoesCapabilities>;
+//# sourceMappingURL=capabilities.d.ts.map

package/packages/@monomind/cli/dist/src/monovector/capabilities.js

@@ -0,0 +1,37 @@
+/**
+ * Capability surface for the (removed) @monoes/* native learning packages.
+ *
+ * Lean teardown: the SONA / native / WASM learning layer (@monoes/sona, router,
+ * attention, learning-wasm, core, and @monomind/monovector-upstream) has been
+ * removed. This module is now a stub that always reports "nothing native is
+ * available", so every caller takes the pure-JS / keyword-routing path. The
+ * function and type surface is preserved so importers (index.ts, hooks-tools.ts,
+ * doctor.ts, neural.ts) keep compiling without change.
+ */
+const STUB_CAPABILITIES = {
+    sona: false,
+    router: 'none',
+    attention: false,
+    learningWasm: false,
+    upstreamPlugin: false,
+};
+/**
+ * Returns the stubbed capability surface — all native backends report absent.
+ * Async to preserve the original signature; callers `await` this everywhere.
+ */
+export async function getCapabilities() {
+    return STUB_CAPABILITIES;
+}
+/** Synchronous read of the (constant) capability surface. */
+export function getCachedCapabilities() {
+    return STUB_CAPABILITIES;
+}
+/** No-op after teardown — there is nothing to re-probe. */
+export function resetCapabilitiesCache() {
+    /* no-op */
+}
+/** Returns the stubbed capability surface — kept for API compatibility. */
+export async function refreshCapabilities() {
+    return STUB_CAPABILITIES;
+}
+//# sourceMappingURL=capabilities.js.map

package/packages/@monomind/cli/dist/src/monovector/command-outcomes.d.ts

@@ -0,0 +1,37 @@
+export interface CommandOutcome {
+    ts: number;
+    command: string;
+    exitCode: number;
+    success: boolean;
+}
+/** Append a command outcome. Non-fatal on error. */
+export declare function recordCommand(baseDir: string, cmd: {
+    command: string;
+    exitCode: number;
+    ts: number;
+}): Promise<void>;
+/**
+ * Derive a measured success signal from recent command outcomes.
+ * Returns:
+ *   - true  if the most recent command(s) in-window ended in a good (final) state
+ *   - false if the task ended on a failing command
+ *   - null  if there are no recent commands (no signal — caller should treat as unknown)
+ *
+ * Heuristic: FINAL-STATE — the exit code of the LAST command in the window.
+ * Within a task the dominant workflow is iterate-until-green (run tests → fail → fix →
+ * run tests → pass), so the task is judged by the state it ENDED in, not by whether any
+ * intermediate command failed. "All must pass" would produce pervasive false failures
+ * because benign commands routinely exit non-zero (`grep` no-match → 1, `test -f`, `diff`)
+ * and the fail-then-pass shape is the norm. Using the last command correctly scores
+ * fail→fix→pass as success and ends-on-failure as failure.
+ *
+ * Known limitation: the store is global (not task-scoped — no taskId exists at command
+ * time), so a trailing benign command after a real failure (e.g. `git status` after a
+ * failed test) could mask it, and the final command of a prior task could bleed in if a
+ * new task records no commands of its own. The time window bounds the latter; per-task
+ * scoping would require threading a taskId into post-command.
+ */
+export declare function deriveRecentSuccess(baseDir: string, windowMs?: number): Promise<boolean | null>;
+/** Read recent command outcomes (for diagnostics). */
+export declare function readCommandOutcomes(baseDir: string, windowMs?: number): Promise<CommandOutcome[]>;
+//# sourceMappingURL=command-outcomes.d.ts.map

package/packages/@monomind/cli/dist/src/monovector/command-outcomes.js

@@ -0,0 +1,87 @@
+/**
+ * Time-windowed command outcome store. Lets post-task derive a MEASURED task
+ * success signal from real command exit codes, instead of trusting a
+ * caller-supplied --success flag.
+ */
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+function storePath(baseDir) {
+    return join(baseDir, 'command-outcomes.jsonl');
+}
+/** Append a command outcome. Non-fatal on error. */
+export async function recordCommand(baseDir, cmd) {
+    try {
+        await fs.mkdir(baseDir, { recursive: true });
+        const rec = { ts: cmd.ts, command: cmd.command, exitCode: cmd.exitCode, success: cmd.exitCode === 0 };
+        await fs.appendFile(storePath(baseDir), JSON.stringify(rec) + '\n', 'utf8');
+        // Opportunistic trim: keep file bounded (last 500 lines) to avoid unbounded growth
+        // (cheap: only rewrite when it gets large)
+    }
+    catch { /* non-fatal */ }
+}
+/**
+ * Derive a measured success signal from recent command outcomes.
+ * Returns:
+ *   - true  if the most recent command(s) in-window ended in a good (final) state
+ *   - false if the task ended on a failing command
+ *   - null  if there are no recent commands (no signal — caller should treat as unknown)
+ *
+ * Heuristic: FINAL-STATE — the exit code of the LAST command in the window.
+ * Within a task the dominant workflow is iterate-until-green (run tests → fail → fix →
+ * run tests → pass), so the task is judged by the state it ENDED in, not by whether any
+ * intermediate command failed. "All must pass" would produce pervasive false failures
+ * because benign commands routinely exit non-zero (`grep` no-match → 1, `test -f`, `diff`)
+ * and the fail-then-pass shape is the norm. Using the last command correctly scores
+ * fail→fix→pass as success and ends-on-failure as failure.
+ *
+ * Known limitation: the store is global (not task-scoped — no taskId exists at command
+ * time), so a trailing benign command after a real failure (e.g. `git status` after a
+ * failed test) could mask it, and the final command of a prior task could bleed in if a
+ * new task records no commands of its own. The time window bounds the latter; per-task
+ * scoping would require threading a taskId into post-command.
+ */
+export async function deriveRecentSuccess(baseDir, windowMs = 300_000) {
+    try {
+        const content = await fs.readFile(storePath(baseDir), 'utf8').catch(() => '');
+        if (!content)
+            return null;
+        const now = Date.now();
+        const recent = [];
+        for (const line of content.trim().split('\n')) {
+            try {
+                const rec = JSON.parse(line);
+                if (now - rec.ts <= windowMs)
+                    recent.push(rec);
+            }
+            catch { /* skip malformed */ }
+        }
+        if (recent.length === 0)
+            return null;
+        // Final-state: the last command in the window decides the outcome.
+        return recent[recent.length - 1].success;
+    }
+    catch {
+        return null;
+    }
+}
+/** Read recent command outcomes (for diagnostics). */
+export async function readCommandOutcomes(baseDir, windowMs = 300_000) {
+    try {
+        const content = await fs.readFile(storePath(baseDir), 'utf8').catch(() => '');
+        if (!content)
+            return [];
+        const now = Date.now();
+        return content.trim().split('\n').map(l => {
+            try {
+                return JSON.parse(l);
+            }
+            catch {
+                return null;
+            }
+        }).filter((r) => r !== null && now - r.ts <= windowMs);
+    }
+    catch {
+        return [];
+    }
+}
+//# sourceMappingURL=command-outcomes.js.map