mustflow 2.18.2 → 2.18.7

package/dist/cli/index.js

@@ -2,7 +2,7 @@
 import { realpathSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { COMMAND_DEFINITIONS } from './lib/command-registry.js';
+import { COMMAND_DEFINITIONS, findCommandDefinition } from './lib/command-registry.js';
 import { renderCliError, renderHelp } from './lib/cli-output.js';
 import { DEFAULT_CLI_LANG, SUPPORTED_CLI_LANGS, isCliLang, t } from './lib/i18n.js';
 import { consoleReporter } from './lib/reporter.js';
@@ -102,77 +102,11 @@ export async function runCli(argv, reporter = consoleReporter) {
         reporter.stdout(getTopLevelHelp(parsed.lang));
         return 0;
     }
-    if (command === '--version' || command === '-v' || command === 'version') {
-        return (await import('./commands/version.js')).runVersion(args, reporter, parsed.lang);
-    }
-    if (command === 'init') {
-        return (await import('./commands/init.js')).runInit(args, reporter, parsed.lang);
-    }
-    if (command === 'adapters') {
-        return (await import('./commands/adapters.js')).runAdapters(args, reporter, parsed.lang);
-    }
-    if (command === 'check') {
-        return (await import('./commands/check.js')).runCheck(args, reporter, parsed.lang);
-    }
-    if (command === 'classify') {
-        return (await import('./commands/classify.js')).runClassify(args, reporter, parsed.lang);
-    }
-    if (command === 'contract-lint') {
-        return (await import('./commands/contract-lint.js')).runContractLint(args, reporter, parsed.lang);
-    }
-    if (command === 'status') {
-        return (await import('./commands/status.js')).runStatus(args, reporter, parsed.lang);
-    }
-    if (command === 'update') {
-        return (await import('./commands/update.js')).runUpdate(args, reporter, parsed.lang);
-    }
-    if (command === 'upgrade') {
-        return (await import('./commands/upgrade.js')).runUpgrade(args, reporter, parsed.lang);
-    }
-    if (command === 'map') {
-        return (await import('./commands/map.js')).runMap(args, reporter, parsed.lang);
-    }
-    if (command === 'line-endings') {
-        return (await import('./commands/line-endings.js')).runLineEndings(args, reporter, parsed.lang);
-    }
-    if (command === 'run') {
-        return (await import('./commands/run.js')).runRun(args, reporter, parsed.lang);
-    }
-    if (command === 'context') {
-        return (await import('./commands/context.js')).runContext(args, reporter, parsed.lang);
-    }
-    if (command === 'doctor') {
-        return (await import('./commands/doctor.js')).runDoctor(args, reporter, parsed.lang);
-    }
-    if (command === 'docs') {
-        return (await import('./commands/docs.js')).runDocs(args, reporter, parsed.lang);
-    }
-    if (command === 'handoff') {
-        return (await import('./commands/handoff.js')).runHandoff(args, reporter, parsed.lang);
-    }
-    if (command === 'index') {
-        return (await import('./commands/index.js')).runIndex(args, reporter, parsed.lang);
-    }
-    if (command === 'search') {
-        return (await import('./commands/search.js')).runSearch(args, reporter, parsed.lang);
-    }
-    if (command === 'dashboard') {
-        return (await import('./commands/dashboard.js')).runDashboard(args, reporter, parsed.lang);
-    }
-    if (command === 'version-sources') {
-        return (await import('./commands/version-sources.js')).runVersionSources(args, reporter, parsed.lang);
-    }
-    if (command === 'verify') {
-        return (await import('./commands/verify.js')).runVerify(args, reporter, parsed.lang);
-    }
-    if (command === 'explain') {
-        return (await import('./commands/explain.js')).runExplain(args, reporter, parsed.lang);
-    }
-    if (command === 'impact') {
-        return (await import('./commands/impact.js')).runImpact(args, reporter, parsed.lang);
-    }
-    if (command === 'help') {
-        return (await import('./commands/help.js')).runHelp(args, reporter, parsed.lang);
+    const commandId = command === '--version' || command === '-v' ? 'version' : command;
+    const commandDefinition = findCommandDefinition(commandId);
+    if (commandDefinition) {
+        const runner = await commandDefinition.loadRunner();
+        return runner(args, reporter, parsed.lang);
     }
     reporter.stderr(renderCliError(t(parsed.lang, 'cli.error.unknownCommand', { command }), 'mf --help', parsed.lang));
     reporter.stdout(getTopLevelHelp(parsed.lang));

package/dist/cli/lib/command-registry.js

@@ -3,120 +3,147 @@ export const COMMAND_DEFINITIONS = [
         id: 'adapters',
         usage: 'mf adapters',
         summaryKey: 'command.adapters.summary',
+        loadRunner: async () => (await import('../commands/adapters.js')).runAdapters,
     },
     {
         id: 'init',
         usage: 'mf init',
         summaryKey: 'command.init.summary',
+        loadRunner: async () => (await import('../commands/init.js')).runInit,
     },
     {
         id: 'check',
         usage: 'mf check',
         summaryKey: 'command.check.summary',
+        loadRunner: async () => (await import('../commands/check.js')).runCheck,
     },
     {
         id: 'classify',
         usage: 'mf classify',
         summaryKey: 'command.classify.summary',
+        loadRunner: async () => (await import('../commands/classify.js')).runClassify,
     },
     {
         id: 'contract-lint',
         usage: 'mf contract-lint',
         summaryKey: 'command.contractLint.summary',
+        loadRunner: async () => (await import('../commands/contract-lint.js')).runContractLint,
     },
     {
         id: 'status',
         usage: 'mf status',
         summaryKey: 'command.status.summary',
+        loadRunner: async () => (await import('../commands/status.js')).runStatus,
     },
     {
         id: 'update',
         usage: 'mf update',
         summaryKey: 'command.update.summary',
+        loadRunner: async () => (await import('../commands/update.js')).runUpdate,
     },
     {
         id: 'upgrade',
         usage: 'mf upgrade',
         summaryKey: 'command.upgrade.summary',
+        loadRunner: async () => (await import('../commands/upgrade.js')).runUpgrade,
     },
     {
         id: 'map',
         usage: 'mf map',
         summaryKey: 'command.map.summary',
+        loadRunner: async () => (await import('../commands/map.js')).runMap,
     },
     {
         id: 'line-endings',
         usage: 'mf line-endings',
         summaryKey: 'command.lineEndings.summary',
+        loadRunner: async () => (await import('../commands/line-endings.js')).runLineEndings,
     },
     {
         id: 'run',
         usage: 'mf run',
         summaryKey: 'command.run.summary',
+        loadRunner: async () => (await import('../commands/run.js')).runRun,
     },
     {
         id: 'context',
         usage: 'mf context',
         summaryKey: 'command.context.summary',
+        loadRunner: async () => (await import('../commands/context.js')).runContext,
     },
     {
         id: 'doctor',
         usage: 'mf doctor',
         summaryKey: 'command.doctor.summary',
+        loadRunner: async () => (await import('../commands/doctor.js')).runDoctor,
     },
     {
         id: 'docs',
         usage: 'mf docs',
         summaryKey: 'command.docs.summary',
+        loadRunner: async () => (await import('../commands/docs.js')).runDocs,
     },
     {
         id: 'handoff',
         usage: 'mf handoff',
         summaryKey: 'command.handoff.summary',
+        loadRunner: async () => (await import('../commands/handoff.js')).runHandoff,
     },
     {
         id: 'index',
         usage: 'mf index',
         summaryKey: 'command.index.summary',
+        loadRunner: async () => (await import('../commands/index.js')).runIndex,
     },
     {
         id: 'search',
         usage: 'mf search',
         summaryKey: 'command.search.summary',
+        loadRunner: async () => (await import('../commands/search.js')).runSearch,
     },
     {
         id: 'dashboard',
         usage: 'mf dashboard',
         summaryKey: 'command.dashboard.summary',
+        loadRunner: async () => (await import('../commands/dashboard.js')).runDashboard,
     },
     {
         id: 'version',
         usage: 'mf version',
         summaryKey: 'command.version.summary',
+        loadRunner: async () => (await import('../commands/version.js')).runVersion,
     },
     {
         id: 'version-sources',
         usage: 'mf version-sources',
         summaryKey: 'command.versionSources.summary',
+        loadRunner: async () => (await import('../commands/version-sources.js')).runVersionSources,
     },
     {
         id: 'verify',
         usage: 'mf verify',
         summaryKey: 'command.verify.summary',
+        loadRunner: async () => (await import('../commands/verify.js')).runVerify,
     },
     {
         id: 'explain',
         usage: 'mf explain',
         summaryKey: 'command.explain.summary',
+        loadRunner: async () => (await import('../commands/explain.js')).runExplain,
     },
     {
         id: 'impact',
         usage: 'mf impact',
         summaryKey: 'command.impact.summary',
+        loadRunner: async () => (await import('../commands/impact.js')).runImpact,
     },
     {
         id: 'help',
         usage: 'mf help',
         summaryKey: 'command.help.summary',
+        loadRunner: async () => (await import('../commands/help.js')).runHelp,
     },
 ];
+export function findCommandDefinition(command) {
+    return COMMAND_DEFINITIONS.find((definition) => definition.id === command);
+}

package/dist/cli/lib/dashboard-export.js

@@ -4,6 +4,7 @@ import { createDashboardCompletionVerdict } from '../../core/completion-verdict.
 import { createDashboardEvidenceModel } from '../../core/verification-evidence.js';
 import { redactSecretLikeText } from '../../core/secret-redaction.js';
 import { ensureFileTargetInsideWithoutSymlinks, ensureInside, toPosixPath, writeUtf8FileInsideWithoutSymlinks, } from './filesystem.js';
+import { safeJsonForInlineScript } from './html-json.js';
 export class DashboardExportPathError extends Error {
     targetPath;
     constructor(targetPath) {
@@ -634,7 +635,7 @@ export function renderDashboardExportHtml(snapshot) {
     const graphSummary = asRecord(harnessVerification.decision_graph_summary);
     const harnessRunHistory = asRecord(harnessReport.run_history);
     const harnessDocsReview = asRecord(harnessReport.docs_review);
-    const embeddedJson = JSON.stringify(snapshot).replace(/</gu, '\\u003c');
+    const embeddedJson = safeJsonForInlineScript(snapshot);
     return `<!doctype html>
 <html lang="en">
 <head>

package/dist/cli/lib/dashboard-html/locale-bootstrap.js

@@ -1,8 +1,9 @@
 import { getDashboardLocaleBundle } from '../dashboard-locale.js';
+import { safeJsonForInlineScript } from '../html-json.js';
 export function createDashboardLocaleBootstrap() {
     const localeBundle = getDashboardLocaleBundle();
     return {
-        serializedLocaleBundle: JSON.stringify(localeBundle),
-        serializedAvailableLocales: JSON.stringify(localeBundle.locales),
+        serializedLocaleBundle: safeJsonForInlineScript(localeBundle),
+        serializedAvailableLocales: safeJsonForInlineScript(localeBundle.locales),
     };
 }

package/dist/cli/lib/dashboard-html/template.js

@@ -1,3 +1,4 @@
+import { safeJsonForInlineScript } from '../html-json.js';
 import { renderDashboardClientScript } from './client-script.js';
 import { createDashboardLocaleBootstrap } from './locale-bootstrap.js';
 import { renderDashboardStyles } from './styles.js';
@@ -12,10 +13,10 @@ function escapeHtml(value) {
 export function renderDashboardHtml(snapshot, token, statusSnapshot, docReviewSnapshot) {
     const root = escapeHtml(snapshot.projectRoot);
     const preferencesPath = escapeHtml(snapshot.preferencesPath);
-    const serializedSnapshot = JSON.stringify(snapshot);
-    const serializedStatusSnapshot = JSON.stringify(statusSnapshot);
-    const serializedDocReviewSnapshot = JSON.stringify(docReviewSnapshot);
-    const serializedToken = JSON.stringify(token);
+    const serializedSnapshot = safeJsonForInlineScript(snapshot);
+    const serializedStatusSnapshot = safeJsonForInlineScript(statusSnapshot);
+    const serializedDocReviewSnapshot = safeJsonForInlineScript(docReviewSnapshot);
+    const serializedToken = safeJsonForInlineScript(token);
     const { serializedLocaleBundle, serializedAvailableLocales } = createDashboardLocaleBootstrap();
     return `<!doctype html>
 <html lang="en">

package/dist/cli/lib/html-json.js

@@ -0,0 +1,11 @@
+const INLINE_SCRIPT_JSON_ESCAPES = {
+    '<': '\\u003C',
+    '>': '\\u003E',
+    '&': '\\u0026',
+    '\u2028': '\\u2028',
+    '\u2029': '\\u2029',
+};
+export function safeJsonForInlineScript(value) {
+    const json = JSON.stringify(value);
+    return (json ?? 'null').replace(/[<>&\u2028\u2029]/gu, (character) => INLINE_SCRIPT_JSON_ESCAPES[character]);
+}

package/dist/cli/lib/local-index/index.js

@@ -284,7 +284,21 @@ function collectCommandIntents(projectRoot) {
     }
     return intents;
 }
+function normalizeIndexedFileSourceScope(value) {
+    const sourceScope = toSearchString(value);
+    if (sourceScope === 'source_anchor' || sourceScope === 'state') {
+        return sourceScope;
+    }
+    return 'workflow';
+}
 function readIndexedFileRecord(projectRoot, relativePath, sourceScope, contentHash = null) {
+    const metadata = readIndexedFileMetadataRecord(projectRoot, relativePath, sourceScope);
+    return {
+        ...metadata,
+        contentHash: contentHash ?? sha256Bytes(readFileSync(path.join(projectRoot, ...relativePath.split('/')))),
+    };
+}
+function readIndexedFileMetadataRecord(projectRoot, relativePath, sourceScope) {
     const fullPath = path.join(projectRoot, ...relativePath.split('/'));
     const stats = statSync(fullPath);
     return {
@@ -292,7 +306,6 @@ function readIndexedFileRecord(projectRoot, relativePath, sourceScope, contentHa
         sourceScope,
         sizeBytes: stats.size,
         mtimeMs: Math.round(stats.mtimeMs),
-        contentHash: contentHash ?? sha256Bytes(readFileSync(fullPath)),
     };
 }
 function collectIndexedFileRecords(projectRoot, documents, sourceAnchors) {
@@ -305,8 +318,21 @@ function collectIndexedFileRecords(projectRoot, documents, sourceAnchors) {
             records.set(anchorPath, readIndexedFileRecord(projectRoot, anchorPath, 'source_anchor'));
         }
     }
+    if (existsSync(path.join(projectRoot, ...LATEST_RUN_STATE_RELATIVE_PATH.split('/')))) {
+        records.set(LATEST_RUN_STATE_RELATIVE_PATH, readIndexedFileRecord(projectRoot, LATEST_RUN_STATE_RELATIVE_PATH, 'state'));
+    }
     return [...records.values()].sort((left, right) => left.path.localeCompare(right.path));
 }
+function collectFastPreflightIndexedFileMetadataRecords(projectRoot, includeSource) {
+    if (includeSource) {
+        return null;
+    }
+    const records = getExistingIndexablePaths(projectRoot).map((relativePath) => readIndexedFileMetadataRecord(projectRoot, relativePath, 'workflow'));
+    if (existsSync(path.join(projectRoot, ...LATEST_RUN_STATE_RELATIVE_PATH.split('/')))) {
+        records.push(readIndexedFileMetadataRecord(projectRoot, LATEST_RUN_STATE_RELATIVE_PATH, 'state'));
+    }
+    return records.sort((left, right) => left.path.localeCompare(right.path));
+}
 function normalizeSearchText(value) {
     return value.trim().replace(/\s+/g, ' ');
 }
@@ -1948,6 +1974,86 @@ function populateDatabase(database, capabilities, documents, skills, skillRoutes
     populatePathSurfaceReadModel(database);
     populateSearchTables(database, capabilities, documents, skills, skillRoutes, commandIntents, sourceAnchors);
 }
+function readCount(database, tableName) {
+    if (!hasTable(database, tableName)) {
+        return 0;
+    }
+    const [row] = queryRows(database, `SELECT COUNT(*) AS count FROM ${tableName}`);
+    const count = row?.count;
+    return typeof count === 'number' && Number.isFinite(count) ? count : 0;
+}
+function readStoredIndexedPaths(database) {
+    if (!hasTable(database, 'documents')) {
+        return [];
+    }
+    return queryRows(database, 'SELECT path FROM documents ORDER BY path')
+        .map((row) => toSearchString(row.path))
+        .filter(Boolean);
+}
+function createStoredLocalIndexResult(projectRoot, databasePath, dryRun, indexMode, database, capabilities) {
+    return {
+        schema_version: LOCAL_INDEX_SCHEMA_VERSION,
+        command: 'index',
+        ok: true,
+        mustflow_root: path.resolve(projectRoot),
+        database_path: databasePath,
+        dry_run: dryRun,
+        wrote_files: false,
+        index_mode: indexMode,
+        reused_existing: true,
+        rebuild_reason: null,
+        document_count: readCount(database, 'documents'),
+        skill_count: readCount(database, 'skills'),
+        skill_route_count: readCount(database, 'skill_routes'),
+        command_intent_count: readCount(database, 'command_intents'),
+        command_effect_count: readCount(database, 'command_effects'),
+        verification_evidence_summary_count: readCount(database, 'verification_evidence_summaries'),
+        verification_plan_count: readCount(database, 'verification_plans'),
+        acceptance_criteria_count: readCount(database, 'acceptance_criteria'),
+        criterion_coverage_count: readCount(database, 'criterion_coverage'),
+        verification_receipt_summary_count: readCount(database, 'verification_receipt_summaries'),
+        command_receipt_summary_count: readCount(database, 'command_receipt_summaries'),
+        verification_coverage_state_count: readCount(database, 'verification_coverage_states'),
+        verification_risk_signal_count: readCount(database, 'verification_risk_signals'),
+        validation_ratchet_signal_count: readCount(database, 'validation_ratchet_signals'),
+        completion_verdict_summary_count: readCount(database, 'completion_verdict_summaries'),
+        repro_route_count: readCount(database, 'repro_routes'),
+        repro_observation_count: readCount(database, 'repro_observations'),
+        failure_fingerprint_count: readCount(database, 'verification_failure_fingerprints'),
+        source_index_enabled: readMetadataValue(database, 'source_index_enabled') === 'true',
+        source_anchor_count: readCount(database, 'source_anchors'),
+        source_anchor_risk_signal_count: readCount(database, 'source_anchor_risk_signals'),
+        search_backend: capabilities.backend,
+        search_fts5_available: capabilities.fts5Available,
+        content_mode: LOCAL_INDEX_CONTENT_MODE,
+        store_full_content: LOCAL_INDEX_STORE_FULL_CONTENT,
+        max_snippet_bytes_per_document: MAX_SNIPPET_BYTES_PER_DOCUMENT,
+        excluded_raw_data_kinds: [...LOCAL_INDEX_EXCLUDED_RAW_DATA_KINDS],
+        indexed_file_count: readCount(database, 'indexed_files'),
+        indexed_paths: readStoredIndexedPaths(database),
+    };
+}
+function indexedFileMetadataMatch(database, currentFiles) {
+    const rows = queryRows(database, 'SELECT path, source_scope, size_bytes, mtime_ms, parser_version FROM indexed_files ORDER BY path');
+    if (rows.length !== currentFiles.length) {
+        return false;
+    }
+    const currentByPath = new Map(currentFiles.map((file) => [file.path, file]));
+    for (const row of rows) {
+        const storedPath = toSearchString(row.path);
+        const current = currentByPath.get(storedPath);
+        if (!current) {
+            return false;
+        }
+        if (normalizeIndexedFileSourceScope(row.source_scope) !== current.sourceScope ||
+            row.size_bytes !== current.sizeBytes ||
+            row.mtime_ms !== current.mtimeMs ||
+            toSearchString(row.parser_version) !== LOCAL_INDEX_PARSER_VERSION) {
+            return false;
+        }
+    }
+    return true;
+}
 function indexedFilesMatch(database, currentFiles) {
     const rows = queryRows(database, 'SELECT path, source_scope, content_hash, parser_version FROM indexed_files ORDER BY path');
     if (rows.length !== currentFiles.length) {
@@ -1960,7 +2066,7 @@ function indexedFilesMatch(database, currentFiles) {
         if (!current) {
             return false;
         }
-        if (toSearchString(row.source_scope) !== current.sourceScope ||
+        if (normalizeIndexedFileSourceScope(row.source_scope) !== current.sourceScope ||
             toSearchString(row.content_hash) !== current.contentHash ||
             toSearchString(row.parser_version) !== LOCAL_INDEX_PARSER_VERSION) {
             return false;
@@ -1968,6 +2074,44 @@ function indexedFilesMatch(database, currentFiles) {
     }
     return true;
 }
+async function readIncrementalPreflightReuse(SQL, databasePath, projectRoot, currentFiles, sourceScopeHash, dryRun, indexMode) {
+    if (!currentFiles) {
+        return { result: null, rebuildReason: null };
+    }
+    if (!existsSync(databasePath)) {
+        return { result: null, rebuildReason: 'missing_index' };
+    }
+    let database;
+    try {
+        database = new SQL.Database(readFileSync(databasePath));
+        if (readStoredSchemaVersion(database) !== LOCAL_INDEX_SCHEMA_VERSION) {
+            return { result: null, rebuildReason: 'schema_version_mismatch' };
+        }
+        if (readMetadataValue(database, 'parser_version') !== LOCAL_INDEX_PARSER_VERSION) {
+            return { result: null, rebuildReason: 'parser_version_mismatch' };
+        }
+        if (readMetadataValue(database, 'source_scope_hash') !== sourceScopeHash) {
+            return { result: null, rebuildReason: 'source_scope_mismatch' };
+        }
+        if (!hasTable(database, 'indexed_files')) {
+            return { result: null, rebuildReason: 'indexed_files_missing' };
+        }
+        if (!indexedFileMetadataMatch(database, currentFiles)) {
+            return { result: null, rebuildReason: 'file_fingerprint_mismatch' };
+        }
+        const capabilities = readStoredSearchCapabilities(database);
+        return {
+            result: createStoredLocalIndexResult(projectRoot, databasePath, dryRun, indexMode, database, capabilities),
+            rebuildReason: null,
+        };
+    }
+    catch {
+        return { result: null, rebuildReason: 'unreadable_index' };
+    }
+    finally {
+        database?.close();
+    }
+}
 async function readIncrementalReuseDecision(SQL, databasePath, currentFiles, sourceScopeHash) {
     if (!existsSync(databasePath)) {
         return { reusable: false, rebuildReason: 'missing_index', capabilities: null };
@@ -2015,13 +2159,28 @@ export async function createLocalIndex(projectRoot, options = {}) {
     const dryRun = options.dryRun === true;
     const incremental = options.incremental === true;
     const indexMode = incremental ? 'incremental' : 'full';
+    const sourceConfig = readLocalIndexSourceConfig(projectRoot);
+    const includeSource = options.includeSource === true || sourceConfig.enabledByDefault;
+    const sourceScopeHash = getSourceScopeHash(includeSource, sourceConfig);
+    let capabilities = searchCapabilities(false);
+    let reusedExisting = false;
+    let rebuildReason = null;
+    const SQL = await loadSqlJs();
+    const capabilityDatabase = new SQL.Database();
+    capabilities = detectLocalSearchCapabilities(capabilityDatabase);
+    capabilityDatabase.close();
+    if (incremental) {
+        const preflightFiles = collectFastPreflightIndexedFileMetadataRecords(projectRoot, includeSource);
+        const preflightReuse = await readIncrementalPreflightReuse(SQL, databasePath, projectRoot, preflightFiles, sourceScopeHash, dryRun, indexMode);
+        if (preflightReuse.result) {
+            return preflightReuse.result;
+        }
+        rebuildReason = preflightReuse.rebuildReason;
+    }
     const documents = collectDocuments(projectRoot);
     const skills = collectSkills(documents);
     const skillRoutes = collectSkillRoutes(projectRoot);
     const commandIntents = collectCommandIntents(projectRoot);
-    const sourceConfig = readLocalIndexSourceConfig(projectRoot);
-    const includeSource = options.includeSource === true || sourceConfig.enabledByDefault;
-    const sourceScopeHash = getSourceScopeHash(includeSource, sourceConfig);
     const previousSourceAnchors = includeSource
         ? await readPreviousSourceAnchorSnapshots(databasePath).catch(() => [])
         : [];
@@ -2033,17 +2192,10 @@ export async function createLocalIndex(projectRoot, options = {}) {
         : [];
     const verificationEvidence = createVerificationEvidenceIndex(projectRoot);
     const indexedFiles = collectIndexedFileRecords(projectRoot, documents, sourceAnchors);
-    let capabilities = searchCapabilities(false);
-    let reusedExisting = false;
-    let rebuildReason = null;
-    const SQL = await loadSqlJs();
-    const capabilityDatabase = new SQL.Database();
-    capabilities = detectLocalSearchCapabilities(capabilityDatabase);
-    capabilityDatabase.close();
     if (incremental) {
         const reuseDecision = await readIncrementalReuseDecision(SQL, databasePath, indexedFiles, sourceScopeHash);
         reusedExisting = reuseDecision.reusable;
-        rebuildReason = reuseDecision.rebuildReason;
+        rebuildReason = reuseDecision.rebuildReason ?? rebuildReason;
         capabilities = reuseDecision.capabilities ?? capabilities;
     }
     if (!dryRun && !reusedExisting) {
@@ -2110,7 +2262,7 @@ function getStalePaths(projectRoot, database) {
         const indexedPaths = new Set(indexedRows.map((row) => toSearchString(row.path)));
         for (const row of indexedRows) {
             const indexedPath = toSearchString(row.path);
-            const sourceScope = toSearchString(row.source_scope) === 'source_anchor' ? 'source_anchor' : 'workflow';
+            const sourceScope = normalizeIndexedFileSourceScope(row.source_scope);
             try {
                 const current = readIndexedFileRecord(projectRoot, indexedPath, sourceScope);
                 if (current.contentHash !== toSearchString(row.content_hash)) {

package/dist/cli/lib/run-plan.js

@@ -78,6 +78,9 @@ function readEffectiveMaxOutputBytes(contract, intent) {
         readPositiveInteger(contract.defaults, 'max_output_bytes') ??
         DEFAULT_COMMAND_MAX_OUTPUT_BYTES;
 }
+function readEffectiveKillAfterSeconds(contract) {
+    return readPositiveInteger(contract.defaults, 'kill_after_seconds') ?? 5;
+}
 function getMaxOutputBytesLimitDetail(contract, intent) {
     const intentValue = readPositiveInteger(intent, 'max_output_bytes');
     if (intentValue !== undefined) {
@@ -103,6 +106,7 @@ function readRunIntentMetadata(contract, intent) {
         kind: readString(intent, 'kind') ?? null,
         configuredCwd,
         timeoutSeconds: readPositiveInteger(intent, 'timeout_seconds') ?? null,
+        killAfterSeconds: readEffectiveKillAfterSeconds(contract),
         maxOutputBytes: readEffectiveMaxOutputBytes(contract, intent),
         successExitCodes: getSuccessExitCodes(intent),
         commandArgv,
@@ -138,6 +142,7 @@ function createBlockedRunPlan(contract, intentName, intent, eligibility, reasonC
         cwd: null,
         relativeCwd: null,
         timeoutSeconds: metadata?.timeoutSeconds ?? null,
+        killAfterSeconds: metadata?.killAfterSeconds ?? null,
         maxOutputBytes: metadata?.maxOutputBytes ?? null,
         successExitCodes: metadata?.successExitCodes ?? null,
         commandArgv: metadata?.commandArgv,
@@ -199,6 +204,7 @@ export function createRunPlan(projectRoot, contract, intentName, options = {}) {
         cwd,
         relativeCwd: getRelativeProjectPath(projectRoot, cwd),
         timeoutSeconds: metadata.timeoutSeconds,
+        killAfterSeconds: metadata.killAfterSeconds,
         maxOutputBytes: metadata.maxOutputBytes,
         successExitCodes: metadata.successExitCodes,
         commandArgv,

package/dist/core/check-issues.js

@@ -15,6 +15,7 @@ const CHECK_ISSUE_ID_RULES = [
     ['mustflow.command_contract.effect_path_escape', /^Strict: Command effect path must stay inside the current root:/u],
     ['mustflow.command_contract.shared_writes_without_effects', /^Strict warning: configured agent-runnable intents .+ share path:.+ through writes without explicit effects or resource locks$/u],
     ['mustflow.command_contract.broad_env_inheritance', /^Strict warning: configured agent-runnable intent [^\s]+ (?:implicitly inherits the host environment|uses env_policy = "inherit")/u],
+    ['mustflow.command_contract.project_local_bin_bare_executable', /^Strict warning: configured agent-runnable intent [^\s]+ uses bare executable "[^"]+" that matches project-local node_modules\/\.bin/u],
     ['mustflow.prompt_cache.required', /^Strict: \[prompt_cache\] table is required$/u],
     ['mustflow.prompt_cache.volatile_in_stable', /^Strict: \[prompt_cache\.layers\.stable\]\.read must not include volatile path /u],
     ['mustflow.refresh.hash_method_required', /^Strict: \[refresh\]\.default_method should be "hash_check" for cache-friendly refresh$/u],

package/dist/core/command-contract-rules.js

@@ -45,9 +45,6 @@ export function commandIntentHasCommandSource(intent) {
 export function shellCommandHasBlockedBackgroundPattern(command) {
     return BACKGROUND_SHELL_PATTERNS.some((pattern) => pattern.test(command));
 }
-export function commandIntentHasBlockedShellBackgroundPattern(intent) {
-    return intent.mode === 'shell' && typeof intent.cmd === 'string' && shellCommandHasBlockedBackgroundPattern(intent.cmd);
-}
 function normalizeExecutableName(value) {
     return path.basename(value).replace(/\.(?:cmd|exe|ps1)$/iu, '').toLowerCase();
 }