moflo 4.9.36 → 4.10.0

package/dist/src/cli/commands/doctor-checks-writers-audit.js

@@ -0,0 +1,170 @@
+/**
+ * Writers Audit runtime doctor check (epic #1054.S5 / #1059).
+ *
+ * Runtime sibling of S1's static lint (`tests/system/moflo-db-writer-audit.test.ts`).
+ * Enumerates running node processes whose command line invokes one of the
+ * known cross-process writers (build-embeddings, migrations) and fails if any
+ * are alive while the daemon owns the lock.
+ *
+ * Why not lsof / handle.exe?
+ *   - `lsof` not installed on every Linux distro and not on Windows.
+ *   - `handle.exe` (Sysinternals) requires manual install.
+ *   - `openfiles.exe` is disabled by default on Windows and requires a reboot to
+ *     enable.
+ *
+ * Command-line signature scan is cross-platform, dependency-free, and matches
+ * the writers we actually care about — S3 ported them all to the daemon-offline
+ * pattern, so any of them being alive concurrently with the daemon is a
+ * regression of S3's wrapper logic.
+ *
+ * @module cli/commands/doctor-checks-writers-audit
+ */
+import { execSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { getDaemonLockHolder } from '../services/daemon-lock.js';
+import { errorDetail } from '../shared/utils/error-detail.js';
+const SCAN_TIMEOUT_MS_WIN = 10_000;
+const SCAN_TIMEOUT_MS_POSIX = 5_000;
+const CMDLINE_CAPTURE_LEN = 300;
+/**
+ * Command-line fragments that identify a CROSS-PROCESS moflo.db writer.
+ * These should never run while the daemon owns the lock (S3 wraps every
+ * invocation in an explicit daemon-stop). Indexer scripts (index-guidance,
+ * index-tests, etc.) are daemon-spawned children — they appear in
+ * `background-pids.json` and are filtered out below.
+ */
+const FOREIGN_WRITER_PATTERNS = [
+    /build-embeddings\.mjs/i,
+    /bin[\\\/]migrations[\\\/][^\s"']+\.mjs/i,
+    /lib[\\\/]db-repair\.mjs/i,
+];
+function readTrackedBackgroundPids(cwd) {
+    const result = new Set();
+    const registryFile = join(cwd, '.moflo', 'background-pids.json');
+    try {
+        if (!existsSync(registryFile))
+            return result;
+        const entries = JSON.parse(readFileSync(registryFile, 'utf-8'));
+        if (!Array.isArray(entries))
+            return result;
+        for (const entry of entries) {
+            if (entry && typeof entry.pid === 'number' && entry.pid > 0) {
+                result.add(entry.pid);
+            }
+        }
+    }
+    catch { /* unreadable — treat as empty */ }
+    return result;
+}
+function enumerateNodeProcesses() {
+    try {
+        if (process.platform === 'win32') {
+            const csv = execSync('powershell -NoProfile -Command "Get-CimInstance Win32_Process -Filter \\"Name=\'node.exe\'\\" | Select-Object ProcessId,CommandLine | ConvertTo-Csv -NoTypeInformation"', { encoding: 'utf-8', timeout: SCAN_TIMEOUT_MS_WIN, windowsHide: true });
+            const out = [];
+            for (const line of csv.split(/\r?\n/)) {
+                const m = line.match(/^"(\d+)","?(.*?)"?$/);
+                if (!m)
+                    continue;
+                const pid = parseInt(m[1], 10);
+                if (!Number.isFinite(pid) || pid <= 0)
+                    continue;
+                out.push({ pid, cmdline: m[2].replace(/""/g, '"').slice(0, CMDLINE_CAPTURE_LEN) });
+            }
+            return out;
+        }
+        // POSIX
+        const ps = execSync('ps -ww -eo pid,command', { encoding: 'utf-8', timeout: SCAN_TIMEOUT_MS_POSIX });
+        const out = [];
+        for (const line of ps.split(/\r?\n/)) {
+            const m = line.trim().match(/^(\d+)\s+(.*)$/);
+            if (!m)
+                continue;
+            const cmd = m[2];
+            if (!/\bnode\b/.test(cmd))
+                continue;
+            const pid = parseInt(m[1], 10);
+            if (!Number.isFinite(pid) || pid <= 0)
+                continue;
+            out.push({ pid, cmdline: cmd.slice(0, CMDLINE_CAPTURE_LEN) });
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+function formatCmdline(raw, max = 80) {
+    const cleaned = raw.replace(/^"?[^"\s]*node(?:\.exe)?"?\s+/i, '').trim();
+    return cleaned.length > max ? cleaned.slice(0, max - 1) + '…' : cleaned;
+}
+export function findForeignWriters(procs, daemonPid, trackedPids, selfPid) {
+    const out = [];
+    for (const p of procs) {
+        if (p.pid === selfPid)
+            continue;
+        if (p.pid === daemonPid)
+            continue;
+        if (trackedPids.has(p.pid))
+            continue;
+        for (const re of FOREIGN_WRITER_PATTERNS) {
+            const m = p.cmdline.match(re);
+            if (m) {
+                out.push({ ...p, matchedPattern: m[0] });
+                break;
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Pass: daemon down (single-writer invariant has nothing to enforce) OR no
+ * foreign writers detected.
+ *
+ * Fail: daemon owns the lock AND a non-daemon, non-tracked node process is
+ * running a known cross-process writer. Lists every offender so the user can
+ * SIGKILL them by PID.
+ */
+export async function checkWritersAudit(cwd = process.cwd()) {
+    const name = 'Writers Audit';
+    try {
+        const daemonPid = getDaemonLockHolder(cwd);
+        if (daemonPid === null) {
+            return {
+                name,
+                status: 'pass',
+                message: 'Daemon not running — single-writer invariant trivially satisfied',
+            };
+        }
+        const procs = enumerateNodeProcesses();
+        const trackedPids = readTrackedBackgroundPids(cwd);
+        const foreign = findForeignWriters(procs, daemonPid, trackedPids, process.pid);
+        if (foreign.length === 0) {
+            return {
+                name,
+                status: 'pass',
+                message: `Daemon PID ${daemonPid} is sole writer; no foreign writers detected`,
+            };
+        }
+        const detail = foreign
+            .map((p) => `pid=${p.pid} (${p.matchedPattern}): ${formatCmdline(p.cmdline)}`)
+            .join(' | ');
+        return {
+            name,
+            status: 'fail',
+            message: `${foreign.length} non-daemon writer(s) running concurrently with daemon (PID ${daemonPid}): ${detail}. ` +
+                `Each will clobber the daemon's sql.js snapshot on flush — #1054 bug class.`,
+            fix: process.platform === 'win32'
+                ? `taskkill /F /PID ${foreign.map((p) => p.pid).join(' /PID ')}`
+                : `kill ${foreign.map((p) => p.pid).join(' ')}`,
+        };
+    }
+    catch (e) {
+        return {
+            name,
+            status: 'warn',
+            message: `Unable to audit writers: ${errorDetail(e, { firstLineOnly: true })}`,
+        };
+    }
+}
+//# sourceMappingURL=doctor-checks-writers-audit.js.map

package/dist/src/cli/commands/doctor-embedding-hygiene.js

@@ -24,8 +24,8 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { existsSync } from 'fs';
 import { CANONICAL_EMBEDDING_MODEL } from '../embeddings/migration/types.js';
-import { mofloImport } from '../services/moflo-require.js';
 import { memoryDbCandidatePaths } from '../services/moflo-paths.js';
+import { openDaemonDatabase } from '../memory/daemon-backend.js';
 /**
  * Known neural-model labels that all share the all-MiniLM-L6-v2 384-dim
  * vector space. The Story-2 migration retags any of these to the
@@ -59,7 +59,7 @@ export async function checkEmbeddingHygiene() {
         return {
             name: 'Embedding hygiene',
             status: 'pass',
-            message: 'Cannot inspect memory DB (sql.js not available)',
+            message: 'Cannot inspect memory DB (open failed)',
         };
     }
     if (groups.length === 0) {
@@ -127,21 +127,9 @@ function resolveMemoryDb() {
     return memoryDbCandidatePaths(process.cwd()).find((p) => existsSync(p)) ?? null;
 }
 async function loadModelGroups(dbPath) {
-    const fs = await import('fs');
-    let initSqlJs;
-    try {
-        initSqlJs = (await mofloImport('sql.js'))?.default;
-    }
-    catch {
-        return null;
-    }
-    if (!initSqlJs)
-        return null;
     let db;
     try {
-        const SQL = await initSqlJs();
-        const buffer = fs.readFileSync(dbPath);
-        db = new SQL.Database(buffer);
+        db = openDaemonDatabase(dbPath);
     }
     catch {
         return null;

package/dist/src/cli/commands/doctor-fixes.js

@@ -169,6 +169,36 @@ export async function autoFixCheck(check) {
             catch { /* best effort */ }
             return runFixCommand('npx moflo daemon start');
         },
+        // Epic #1054.S5 / #1059 — SIGTERM the stale daemon and let the launcher's
+        // existing respawn path (mirrored as `npx moflo daemon start`) pick up the
+        // installed-version code. Mirrors `recycleDaemon` in
+        // bin/session-start-launcher.mjs so the auto-fix matches the launcher's
+        // behavior exactly.
+        'Daemon Version Skew': async () => {
+            const cwd = process.cwd();
+            const { getDaemonLockPayload } = await import('../services/daemon-lock.js');
+            const payload = getDaemonLockPayload(cwd);
+            if (payload?.pid && payload.pid > 0) {
+                try {
+                    process.kill(payload.pid, 'SIGTERM');
+                }
+                catch { /* already dead */ }
+            }
+            const lockFile = join(cwd, '.moflo', 'daemon.lock');
+            try {
+                if (existsSync(lockFile))
+                    unlinkSync(lockFile);
+            }
+            catch { /* ok */ }
+            return runFixCommand('npx moflo daemon start');
+        },
+        'Embedding Coverage Truth': async () => {
+            // Same as the existing Embeddings fix — rebuild the cache by re-running
+            // the embeddings pipeline. Routes through `npx moflo` so the consumer
+            // CLI resolution stays consistent across platforms (see
+            // feedback_cross_platform_mandatory).
+            return runFixCommand('npx moflo embeddings init --force');
+        },
         'MCP Servers': async () => {
             return runFixCommand('claude mcp add moflo -- npx -y moflo mcp start');
         },

package/dist/src/cli/commands/doctor-registry.js

@@ -6,6 +6,9 @@
  */
 import { checkSubagentHealth, checkSpellExecution, checkMcpToolInvocation, checkHookExecution, checkMcpSpellIntegration, checkGateHealth, checkHookBlockDrift, checkMofloDbBridge, } from './doctor-checks-deep.js';
 import { checkEmbeddingHygiene } from './doctor-embedding-hygiene.js';
+import { checkDaemonVersionSkew } from './doctor-checks-version-skew.js';
+import { checkEmbeddingCoverageTruth } from './doctor-checks-coverage-truth.js';
+import { checkWritersAudit } from './doctor-checks-writers-audit.js';
 import { checkSwarmFunctional, checkHiveMindFunctional, } from './doctor-checks-swarm.js';
 import { checkMemoryAccessFunctional } from './doctor-checks-memory-access.js';
 import { checkBuildTools, checkClaudeCode, checkDiskSpace, checkGit, checkGitRepo, checkNodeVersion, checkNpmVersion, } from './doctor-checks-runtime.js';
@@ -33,10 +36,13 @@ export const allChecks = [
     checkMofloYamlCompliance,
     checkStatusLine,
     checkDaemonStatus,
+    checkDaemonVersionSkew,
     checkDaemonWriteRouting,
+    checkWritersAudit,
     checkMemoryDatabase,
     checkEmbeddings,
     checkEmbeddingHygiene,
+    checkEmbeddingCoverageTruth,
     checkTestDirs,
     checkMcpServers,
     checkDiskSpace,
@@ -77,11 +83,19 @@ export const componentMap = {
     'statusline': checkStatusLine,
     'status-line': checkStatusLine,
     'daemon': checkDaemonStatus,
+    'daemon-version-skew': checkDaemonVersionSkew,
+    'version-skew': checkDaemonVersionSkew,
+    'skew': checkDaemonVersionSkew,
     'daemon-write-routing': checkDaemonWriteRouting,
     'write-routing': checkDaemonWriteRouting,
+    'writers-audit': checkWritersAudit,
+    'writers': checkWritersAudit,
     'memory': checkMemoryDatabase,
     'embeddings': checkEmbeddings,
     'embedding-hygiene': checkEmbeddingHygiene,
+    'embedding-coverage': checkEmbeddingCoverageTruth,
+    'coverage': checkEmbeddingCoverageTruth,
+    'coverage-truth': checkEmbeddingCoverageTruth,
     'hygiene': checkEmbeddingHygiene,
     'git': checkGit,
     'mcp': checkMcpServers,

package/dist/src/cli/commands/doctor.js

@@ -40,7 +40,7 @@ export const doctorCommand = {
         {
             name: 'component',
             short: 'c',
-            description: 'Check specific component (version, node, npm, config, daemon, memory, embeddings, git, mcp, claude, disk, typescript, semantic, intelligence, swarm, hive-mind)',
+            description: 'Check specific component (version, version-skew, node, npm, config, daemon, writers-audit, memory, embeddings, coverage-truth, git, mcp, claude, disk, typescript, semantic, intelligence, swarm, hive-mind)',
             type: 'string',
         },
         {

package/dist/src/cli/commands/embeddings.js

@@ -13,10 +13,10 @@
  * Created with ❤️ by motailz.com
  */
 import { output } from '../output.js';
-import { mofloImport } from '../services/moflo-require.js';
 import { runEmbeddingsMigrationIfNeeded } from '../services/embeddings-migration.js';
 import { memoryDbPath, MEMORY_DB_FILE, MOFLO_DIR } from '../services/moflo-paths.js';
 import * as embeddings from '../embeddings/index.js';
+import { openDaemonDatabase } from '../memory/daemon-backend.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
 const DEFAULT_DB_PATH_FLAG = `${MOFLO_DIR}/${MEMORY_DB_FILE}`;
 // Generate subcommand - REAL implementation
@@ -90,7 +90,7 @@ const generateCommand = {
         }
     },
 };
-// Search subcommand - REAL implementation using sql.js
+// Search subcommand - REAL implementation using node:sqlite via openDaemonDatabase
 const searchCommand = {
     name: 'search',
     description: 'Semantic similarity search',
@@ -131,11 +131,8 @@ const searchCommand = {
                 output.printInfo('Run: claude-flow memory init');
                 return { success: false, exitCode: 1 };
             }
-            // Load sql.js
-            const initSqlJs = (await mofloImport('sql.js')).default;
-            const SQL = await initSqlJs();
-            const fileBuffer = fs.readFileSync(fullDbPath);
-            const db = new SQL.Database(fileBuffer);
+            // node:sqlite via the unified factory (Phase 5 / #1084).
+            const db = openDaemonDatabase(fullDbPath);
             const startTime = Date.now();
             // Generate embedding for query
             const { generateEmbedding } = await import('../memory/memory-initializer.js');
@@ -343,7 +340,7 @@ const compareCommand = {
         }
     },
 };
-// Collections subcommand - REAL implementation using sql.js
+// Collections subcommand - REAL implementation using node:sqlite via openDaemonDatabase
 const collectionsCommand = {
     name: 'collections',
     description: 'Manage embedding collections (namespaces)',
@@ -374,11 +371,8 @@ const collectionsCommand = {
                 output.writeln(output.dim('No collections yet - initialize memory first'));
                 return { success: true, data: [] };
             }
-            // Load sql.js and query real data
-            const initSqlJs = (await mofloImport('sql.js')).default;
-            const SQL = await initSqlJs();
-            const fileBuffer = fs.readFileSync(fullDbPath);
-            const db = new SQL.Database(fileBuffer);
+            // node:sqlite via the unified factory (Phase 5 / #1084).
+            const db = openDaemonDatabase(fullDbPath);
             // Get collection stats from database
             const statsQuery = db.exec(`
         SELECT
@@ -1159,17 +1153,18 @@ const cacheCommand = {
                 else {
                     sqliteSize = `${sizeBytes} B`;
                 }
-                // Try to count real entries via sql.js
+                // Try to count real entries via node:sqlite
                 try {
-                    const initSqlJs = (await mofloImport('sql.js')).default;
-                    const SQL = await initSqlJs();
-                    const fileBuffer = fs.readFileSync(resolvedDbPath);
-                    const db = new SQL.Database(fileBuffer);
-                    const result = db.exec('SELECT COUNT(*) as count FROM embeddings');
-                    if (result.length > 0 && result[0].values.length > 0) {
-                        sqliteEntries = result[0].values[0][0];
+                    const db = openDaemonDatabase(resolvedDbPath);
+                    try {
+                        const result = db.exec('SELECT COUNT(*) as count FROM embeddings');
+                        if (result.length > 0 && result[0].values.length > 0) {
+                            sqliteEntries = result[0].values[0][0];
+                        }
+                    }
+                    finally {
+                        db.close();
                     }
-                    db.close();
                 }
                 catch {
                     // Estimate entries from file size (~1600 bytes per entry for 384-dim embeddings)

package/dist/src/cli/commands/memory.js

@@ -7,8 +7,7 @@ import * as pathModule from 'path';
 import { output } from '../output.js';
 import { select, confirm, input } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
-import { mofloImport } from '../services/moflo-require.js';
-import { atomicWriteFileSync } from '../services/atomic-file-write.js';
+import { openDaemonDatabase } from '../memory/daemon-backend.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
 // Memory backends
 const BACKENDS = [
@@ -242,7 +241,7 @@ const searchCommand = {
             name: 'threshold',
             description: 'Similarity threshold (0-1)',
             type: 'number',
-            default: 0.7
+            default: 0.5
         },
         {
             name: 'type',
@@ -268,7 +267,8 @@ const searchCommand = {
         const query = ctx.flags.query || ctx.args[0];
         const namespace = ctx.flags.namespace || 'all';
         const limit = ctx.flags.limit || 10;
-        const threshold = ctx.flags.threshold || 0.3;
+        // #1053 S6: align with MCP default — was 0.3 here vs 0.7 in option block.
+        const threshold = ctx.flags.threshold || 0.5;
         const searchType = ctx.flags.type || 'semantic';
         const buildHnsw = ctx.flags.buildHnsw;
         if (!query) {
@@ -1264,23 +1264,10 @@ const initMemoryCommand = {
 const DB_FILENAME = 'memory.db';
 const SWARM_DIR = '.swarm';
 async function openDb(cwd) {
-    const fs = await import('fs');
     const path = await import('path');
-    const initSqlJs = (await mofloImport('sql.js')).default;
-    const SQL = await initSqlJs();
     const dbPath = path.join(cwd, SWARM_DIR, DB_FILENAME);
-    const dir = path.dirname(dbPath);
-    if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-    }
-    let db;
-    if (fs.existsSync(dbPath)) {
-        const buffer = fs.readFileSync(dbPath);
-        db = new SQL.Database(buffer);
-    }
-    else {
-        db = new SQL.Database();
-    }
+    // openDaemonDatabase ensures the parent directory exists and applies WAL.
+    const db = openDaemonDatabase(dbPath);
     // Ensure table exists
     db.run(`
     CREATE TABLE IF NOT EXISTS memory_entries (
@@ -1306,10 +1293,14 @@ async function openDb(cwd) {
   `);
     db.run(`CREATE INDEX IF NOT EXISTS idx_memory_key_ns ON memory_entries(key, namespace)`);
     db.run(`CREATE INDEX IF NOT EXISTS idx_memory_namespace ON memory_entries(namespace)`);
-    return { db, dbPath, SQL };
+    return { db, dbPath };
 }
-function saveAndCloseDb(db, dbPath) {
-    atomicWriteFileSync(dbPath, db.export());
+/**
+ * Close the DB handle. node:sqlite + WAL has already persisted every prior
+ * `db.run` incrementally — the explicit atomicWriteFileSync sql.js used to
+ * need is gone (Phase 5 / #1084).
+ */
+function saveAndCloseDb(db, _dbPath) {
     db.close();
 }
 function batchGenerateId() {
@@ -1612,16 +1603,16 @@ const indexGuidanceCommand = {
             try {
                 const content = fs.readFileSync(filePath, 'utf-8');
                 const contentHash_ = hashContent(content);
-                // Check if content changed
+                // #1053 S4: doc-* retired — read docContentHash off chunk-0 instead.
                 if (!forceReindex) {
                     const stmt = db.prepare('SELECT metadata FROM memory_entries WHERE key = ? AND namespace = ?');
-                    stmt.bind([docKey, NAMESPACE]);
+                    stmt.bind([`${chunkPrefix}-0`, NAMESPACE]);
                     const entry = stmt.step() ? stmt.getAsObject() : null;
                     stmt.free();
                     if (entry?.metadata) {
                         try {
                             const meta = JSON.parse(entry.metadata);
-                            if (meta.contentHash === contentHash_) {
+                            if (meta.docContentHash === contentHash_) {
                                 return { docKey, status: 'unchanged', chunks: 0 };
                             }
                         }
@@ -1630,19 +1621,12 @@ const indexGuidanceCommand = {
                 }
                 const stats = fs.statSync(filePath);
                 const relativePath = filePath.replace(cwd, '').replace(/\\/g, '/');
-                // Delete old chunks
+                // Delete old chunks. Also delete any legacy doc-* row (#1053 S4).
                 db.run(`DELETE FROM memory_entries WHERE namespace = ? AND key LIKE ?`, [NAMESPACE, `${chunkPrefix}%`]);
-                // Store full document
-                const docMetadata = {
-                    type: 'document',
-                    filePath: relativePath,
-                    fileSize: stats.size,
-                    lastModified: stats.mtime.toISOString(),
-                    contentHash: contentHash_,
-                    indexedAt: new Date().toISOString(),
-                    ragVersion: '2.0',
-                };
-                batchStoreEntry(db, docKey, NAMESPACE, content, docMetadata, [keyPrefix, 'document']);
+                db.run(`DELETE FROM memory_entries WHERE namespace = ? AND key = ?`, [NAMESPACE, docKey]);
+                // #1053 S4: doc-* entries no longer written. parentDoc on chunks
+                // remains as an identifier label; callers Read parentPath when
+                // they need the source file (see shipped/moflo-memory-protocol.md).
                 // Chunk content
                 const chunks = chunkMarkdown(content, fileName);
                 if (chunks.length === 0) {
@@ -1650,26 +1634,24 @@ const indexGuidanceCommand = {
                 }
                 const hierarchy = buildHierarchy(chunks, chunkPrefix);
                 const siblings = chunks.map((_, i) => `${chunkPrefix}-${i}`);
-                // Update doc with children refs
-                const docChildrenMeta = { ...docMetadata, children: siblings, chunkCount: chunks.length };
-                batchStoreEntry(db, docKey, NAMESPACE, content, docChildrenMeta, [keyPrefix, 'document']);
                 for (let i = 0; i < chunks.length; i++) {
                     const chunk = chunks[i];
                     const chunkKey = `${chunkPrefix}-${i}`;
                     const prevChunk = i > 0 ? `${chunkPrefix}-${i - 1}` : null;
                     const nextChunk = i < chunks.length - 1 ? `${chunkPrefix}-${i + 1}` : null;
-                    const contextBefore = i > 0
-                        ? extractOverlapContext(chunks[i - 1].content, overlapPercent, 'end')
-                        : null;
-                    const contextAfter = i < chunks.length - 1
-                        ? extractOverlapContext(chunks[i + 1].content, overlapPercent, 'start')
-                        : null;
+                    // #1053 S5: dropped prev/next preamble wrapping. Traversal happens
+                    // via memory_get_neighbors now (S2).
                     const hierInfo = hierarchy[chunkKey];
                     const chunkMetadata = {
                         type: 'chunk',
                         ragVersion: '2.0',
+                        // #1053 S4: parentDoc is an identifier label (target row no
+                        // longer exists); use parentPath for the actual source file.
+                        // docContentHash on every chunk lets the skip-if-unchanged
+                        // check read it off chunk-0.
                         parentDoc: docKey,
                         parentPath: relativePath,
+                        docContentHash: contentHash_,
                         chunkIndex: i,
                         totalChunks: chunks.length,
                         prevChunk,
@@ -1682,21 +1664,12 @@ const indexGuidanceCommand = {
                         headerLine: chunk.headerLine,
                         isPart: chunk.isPart || false,
                         partNum: chunk.partNum || null,
-                        contextOverlapPercent: overlapPercent,
-                        hasContextBefore: !!contextBefore,
-                        hasContextAfter: !!contextAfter,
                         contentLength: chunk.content.length,
                         contentHash: hashContent(chunk.content),
                         indexedAt: new Date().toISOString(),
                     };
-                    let searchableContent = `# ${chunk.title}\n\n`;
-                    if (contextBefore) {
-                        searchableContent += `[Context from previous section:]\n${contextBefore}\n\n---\n\n`;
-                    }
-                    searchableContent += chunk.content;
-                    if (contextAfter) {
-                        searchableContent += `\n\n---\n\n[Context from next section:]\n${contextAfter}`;
-                    }
+                    // #1053 S5: title heading + chunk body. No prev/next preamble.
+                    const searchableContent = `# ${chunk.title}\n\n${chunk.content}`;
                     batchStoreEntry(db, chunkKey, NAMESPACE, searchableContent, chunkMetadata, [keyPrefix, 'chunk', `level-${chunk.level}`, chunk.title.toLowerCase().replace(/[^a-z0-9]+/g, '-')]);
                 }
                 return { docKey, status: 'indexed', chunks: chunks.length };
@@ -1753,22 +1726,28 @@ const indexGuidanceCommand = {
                     errors++;
                 }
             }
-            // Clean stale entries for deleted files
-            const docsStmt = db.prepare(`SELECT DISTINCT key FROM memory_entries WHERE namespace = ? AND key LIKE 'doc-%'`);
-            docsStmt.bind([NAMESPACE]);
-            const docs = [];
-            while (docsStmt.step())
-                docs.push(docsStmt.getAsObject());
-            docsStmt.free();
-            for (const { key } of docs) {
-                if (!key.startsWith('doc-guidance-'))
-                    continue;
-                const checkPath = pathModule.resolve(cwd, '.claude/guidance', key.replace('doc-guidance-', '') + '.md');
+            // #1053 S4: Clean stale chunks for deleted files.
+            // doc-* markers are gone — derive prefixes from chunk keys directly.
+            // Chunk key shape: chunk-guidance-<filename>-<index>; group by stripping
+            // the trailing -<index>.
+            const chunksStmt = db.prepare(`SELECT DISTINCT key FROM memory_entries WHERE namespace = ? AND key LIKE 'chunk-guidance-%'`);
+            chunksStmt.bind([NAMESPACE]);
+            const seenPrefixes = new Set();
+            while (chunksStmt.step()) {
+                const { key } = chunksStmt.getAsObject();
+                const prefix = key.replace(/-\d+$/, '');
+                seenPrefixes.add(prefix);
+            }
+            chunksStmt.free();
+            for (const prefix of seenPrefixes) {
+                const filename = prefix.replace('chunk-guidance-', '') + '.md';
+                const checkPath = pathModule.resolve(cwd, '.claude/guidance', filename);
                 if (!fs.existsSync(checkPath)) {
-                    const cp = key.replace('doc-', 'chunk-');
-                    db.run(`DELETE FROM memory_entries WHERE namespace = ? AND key LIKE ?`, [NAMESPACE, `${cp}%`]);
-                    db.run(`DELETE FROM memory_entries WHERE namespace = ? AND key = ?`, [NAMESPACE, key]);
-                    output.writeln(output.dim(`  Removed stale: ${key}`));
+                    db.run(`DELETE FROM memory_entries WHERE namespace = ? AND key LIKE ?`, [NAMESPACE, `${prefix}-%`]);
+                    // Also sweep any legacy doc-* row for this prefix (one-time tidy).
+                    const legacyDocKey = prefix.replace('chunk-', 'doc-');
+                    db.run(`DELETE FROM memory_entries WHERE namespace = ? AND key = ?`, [NAMESPACE, legacyDocKey]);
+                    output.writeln(output.dim(`  Removed stale: ${prefix}-* (file ${filename} not found)`));
                 }
             }
         }
@@ -1948,9 +1927,9 @@ const rebuildIndexCommand = {
                 }
                 failed++;
             }
-            if ((i + 1) % BATCH_SIZE === 0) {
-                atomicWriteFileSync(dbPath, db.export());
-            }
+            // node:sqlite + WAL persists each db.run incrementally — the
+            // periodic batch flush sql.js needed here was the export-+-rewrite
+            // pattern Phase 5 (#1084) killed. No flush needed.
         }
         const totalTime = ((Date.now() - startTime) / 1000).toFixed(1);
         // Final stats