mustflow 2.22.4 → 2.22.9

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

@@ -1,68 +1,20 @@
-import { existsSync, readFileSync, statSync } from 'node:fs';
-import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
-import { isRecord, readCommandContract, readString, readStringArray } from '../command-contract.js';
-import { listFilesRecursive, toPosixPath } from '../filesystem.js';
-import { readTomlFile } from '../toml.js';
+import { isRecord, readStringArray } from '../command-contract.js';
+import { toPosixPath } from '../filesystem.js';
 import { collectSourceAnchorIndexRecords, hasHighRiskSourceAnchorRiskTags, } from '../../../core/source-anchor-status.js';
-import { listSourceAnchorFiles } from '../../../core/source-anchors.js';
-import { normalizeCommandEffects } from '../../../core/command-effects.js';
 import { listChangeClassificationRuleDescriptors } from '../../../core/change-classification.js';
 import { writeFileInsideWithoutSymlinks } from '../../../core/safe-filesystem.js';
-import { DEFAULT_DATABASE_RELATIVE_PATH, DEFAULT_PROMPT_CACHE_STABLE_READ, DEFAULT_PROMPT_CACHE_TASK_SOURCES, DEFAULT_PROMPT_CACHE_VOLATILE_SOURCES, INDEX_CONFIG_RELATIVE_PATH, LOCAL_INDEX_CONTENT_MODE, LOCAL_INDEX_EXCLUDED_RAW_DATA_KINDS, LOCAL_INDEX_PARSER_VERSION, LOCAL_INDEX_SCHEMA_VERSION, LOCAL_INDEX_STORE_FULL_CONTENT, LATEST_RUN_STATE_RELATIVE_PATH, MAX_SEARCH_MATCH_SNIPPET_CHARS, MAX_SNIPPET_BYTES_PER_DOCUMENT, MUSTFLOW_RELATIVE_PATH, SEARCH_BACKEND_FTS5, SEARCH_BACKEND_TABLE_SCAN, SEARCH_MATCH_CONTEXT_AFTER_CHARS, SEARCH_MATCH_CONTEXT_BEFORE_CHARS, SEARCH_MATCH_TRUNCATION_MARKER, SEARCH_NGRAM_MAX_GRAMS_PER_TARGET, SEARCH_NGRAM_MAX_LENGTH, SEARCH_NGRAM_MAX_TOKEN_CHARS, SEARCH_NGRAM_MIN_LENGTH, SOURCE_INDEX_MAX_FILE_BYTES, TEST_DISABLE_FTS5_ENV, } from './constants.js';
+import { DEFAULT_DATABASE_RELATIVE_PATH, DEFAULT_PROMPT_CACHE_STABLE_READ, DEFAULT_PROMPT_CACHE_TASK_SOURCES, DEFAULT_PROMPT_CACHE_VOLATILE_SOURCES, LOCAL_INDEX_CONTENT_MODE, LOCAL_INDEX_EXCLUDED_RAW_DATA_KINDS, LOCAL_INDEX_PARSER_VERSION, LOCAL_INDEX_SCHEMA_VERSION, LOCAL_INDEX_STORE_FULL_CONTENT, MAX_SEARCH_MATCH_SNIPPET_CHARS, MAX_SNIPPET_BYTES_PER_DOCUMENT, SEARCH_BACKEND_FTS5, SEARCH_BACKEND_TABLE_SCAN, SEARCH_MATCH_CONTEXT_AFTER_CHARS, SEARCH_MATCH_CONTEXT_BEFORE_CHARS, SEARCH_MATCH_TRUNCATION_MARKER, SEARCH_NGRAM_MAX_GRAMS_PER_TARGET, SEARCH_NGRAM_MAX_LENGTH, SEARCH_NGRAM_MAX_TOKEN_CHARS, SEARCH_NGRAM_MIN_LENGTH, SOURCE_INDEX_MAX_FILE_BYTES, TEST_DISABLE_FTS5_ENV, } from './constants.js';
+import { collectCommandIntents } from './command-effect-index.js';
+import { sha256Text } from './hashing.js';
 import { loadSqlJs } from './sql.js';
+import { collectFastPreflightIndexedFileMetadataRecords, collectIndexedFileRecords, collectSourceAnchorCandidatePaths, getSourceScopeHash, hashIndexedFileMetadataRecords, normalizeIndexedFileSourceScope, readIndexedFileRecord, readLocalIndexSourceConfig, readMustflowToml, } from './source-index.js';
+import { createVerificationEvidenceIndex } from './verification-evidence.js';
+import { collectDocuments, collectDocumentsFromPaths, collectSkillRoutes, collectSkills, getExistingIndexablePaths, readText, skillRouteKey, splitVerificationIntents, } from './workflow-documents.js';
 export function getLocalIndexDatabasePath(projectRoot) {
     return path.join(projectRoot, ...DEFAULT_DATABASE_RELATIVE_PATH.split('/'));
 }
-function getExistingIndexablePaths(projectRoot) {
-    const paths = new Set();
-    const addIfExists = (relativePath) => {
-        if (existsSync(path.join(projectRoot, ...relativePath.split('/')))) {
-            paths.add(relativePath);
-        }
-    };
-    addIfExists('AGENTS.md');
-    for (const relativePath of listFilesRecursive(path.join(projectRoot, '.mustflow', 'docs'))) {
-        if (relativePath.endsWith('.md')) {
-            paths.add(toPosixPath(path.join('.mustflow', 'docs', relativePath)));
-        }
-    }
-    for (const relativePath of listFilesRecursive(path.join(projectRoot, '.mustflow', 'context'))) {
-        if (relativePath.endsWith('.md')) {
-            paths.add(toPosixPath(path.join('.mustflow', 'context', relativePath)));
-        }
-    }
-    for (const relativePath of listFilesRecursive(path.join(projectRoot, '.mustflow', 'skills'))) {
-        if (relativePath === 'INDEX.md' || relativePath.endsWith('/SKILL.md')) {
-            paths.add(toPosixPath(path.join('.mustflow', 'skills', relativePath)));
-        }
-    }
-    for (const relativePath of listFilesRecursive(path.join(projectRoot, '.mustflow', 'config'))) {
-        if (relativePath.endsWith('.toml')) {
-            paths.add(toPosixPath(path.join('.mustflow', 'config', relativePath)));
-        }
-    }
-    return Array.from(paths).sort((left, right) => left.localeCompare(right));
-}
-function readText(projectRoot, relativePath) {
-    return readFileSync(path.join(projectRoot, ...relativePath.split('/')), 'utf8');
-}
-function readMustflowToml(projectRoot) {
-    const mustflowPath = path.join(projectRoot, ...MUSTFLOW_RELATIVE_PATH.split('/'));
-    if (!existsSync(mustflowPath)) {
-        return undefined;
-    }
-    const parsed = readTomlFile(mustflowPath);
-    return isRecord(parsed) ? parsed : undefined;
-}
-function readIndexToml(projectRoot) {
-    const indexConfigPath = path.join(projectRoot, ...INDEX_CONFIG_RELATIVE_PATH.split('/'));
-    if (!existsSync(indexConfigPath)) {
-        return undefined;
-    }
-    const parsed = readTomlFile(indexConfigPath);
-    return isRecord(parsed) ? parsed : undefined;
-}
 function readNestedTable(table, key) {
     if (!table || !isRecord(table[key])) {
         return undefined;
@@ -72,297 +24,6 @@ function readNestedTable(table, key) {
 function readOptionalStringArray(table, key) {
     return table ? readStringArray(table, key) ?? null : null;
 }
-function readBoolean(table, key) {
-    const value = table?.[key];
-    return typeof value === 'boolean' ? value : undefined;
-}
-function readPositiveInteger(table, key) {
-    const value = table?.[key];
-    if (typeof value !== 'number' || !Number.isInteger(value) || value <= 0) {
-        return null;
-    }
-    return value;
-}
-function readLocalIndexSourceConfig(projectRoot) {
-    const sourceIndexTable = readNestedTable(readIndexToml(projectRoot), 'source_index');
-    const configuredMaxFileBytes = readPositiveInteger(sourceIndexTable, 'max_file_bytes');
-    return {
-        enabledByDefault: readBoolean(sourceIndexTable, 'enabled_by_default') === true,
-        include: readOptionalStringArray(sourceIndexTable, 'include') ?? [],
-        exclude: readOptionalStringArray(sourceIndexTable, 'exclude') ?? [],
-        maxFileBytes: Math.min(configuredMaxFileBytes ?? SOURCE_INDEX_MAX_FILE_BYTES, SOURCE_INDEX_MAX_FILE_BYTES),
-        allowedExtensions: readOptionalStringArray(sourceIndexTable, 'allowed_extensions') ?? [],
-    };
-}
-function sha256Text(content) {
-    return `sha256:${createHash('sha256').update(content).digest('hex')}`;
-}
-function sha256Bytes(content) {
-    return `sha256:${createHash('sha256').update(content).digest('hex')}`;
-}
-function getSourceScopeHash(includeSource, sourceConfig) {
-    return sha256Text(JSON.stringify({
-        includeSource,
-        sourceConfig,
-    }));
-}
-function getDocumentType(relativePath) {
-    if (relativePath === 'AGENTS.md') {
-        return 'agent_rules';
-    }
-    if (relativePath.startsWith('.mustflow/config/')) {
-        return 'config';
-    }
-    if (relativePath === '.mustflow/skills/INDEX.md') {
-        return 'skill_index';
-    }
-    if (relativePath === '.mustflow/context/INDEX.md') {
-        return 'context_index';
-    }
-    if (relativePath.startsWith('.mustflow/context/')) {
-        return 'context';
-    }
-    if (relativePath.endsWith('/SKILL.md')) {
-        return 'skill';
-    }
-    if (relativePath.startsWith('.mustflow/docs/')) {
-        return 'workflow_doc';
-    }
-    return 'document';
-}
-function parseFrontmatter(content) {
-    if (!content.startsWith('---')) {
-        return {};
-    }
-    const end = content.indexOf('\n---', 3);
-    if (end === -1) {
-        return {};
-    }
-    const result = {};
-    const rawFrontmatter = content.slice(3, end);
-    for (const line of rawFrontmatter.split(/\r?\n/)) {
-        const separatorIndex = line.indexOf(':');
-        if (separatorIndex === -1) {
-            continue;
-        }
-        const key = line.slice(0, separatorIndex).trim();
-        const value = line.slice(separatorIndex + 1).trim();
-        if (key.length > 0 && value.length > 0) {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-function getTitle(relativePath, content) {
-    const heading = content.match(/^#\s+(.+)$/mu)?.[1]?.trim();
-    return heading && heading.length > 0 ? heading : path.posix.basename(relativePath);
-}
-function getSections(content) {
-    return [...content.matchAll(/^##\s+(.+)$/gmu)].map((match) => match[1]?.trim()).filter((value) => Boolean(value));
-}
-function truncateUtf8(value, maxBytes) {
-    const buffer = Buffer.from(value, 'utf8');
-    if (buffer.byteLength <= maxBytes) {
-        return value;
-    }
-    return buffer.subarray(0, maxBytes).toString('utf8').replace(/\uFFFD$/u, '');
-}
-function collectDocuments(projectRoot) {
-    return getExistingIndexablePaths(projectRoot).map((relativePath) => {
-        const content = readText(projectRoot, relativePath);
-        const frontmatter = parseFrontmatter(content);
-        const revision = Number.parseInt(frontmatter.revision ?? '', 10);
-        return {
-            path: relativePath,
-            type: getDocumentType(relativePath),
-            title: getTitle(relativePath, content),
-            locale: frontmatter.locale ?? null,
-            revision: Number.isInteger(revision) ? revision : null,
-            contentHash: sha256Text(content),
-            contentSnippet: truncateUtf8(content, MAX_SNIPPET_BYTES_PER_DOCUMENT),
-            sections: getSections(content),
-        };
-    });
-}
-function collectSkills(documents) {
-    return documents
-        .filter((document) => document.type === 'skill')
-        .map((document) => ({
-        name: document.path.split('/').at(-2) ?? document.title,
-        path: document.path,
-        title: document.title,
-    }))
-        .sort((left, right) => left.name.localeCompare(right.name));
-}
-function normalizeMarkdownCell(value) {
-    return value
-        .replace(/<br\s*\/?>/giu, ' ')
-        .replace(/`([^`]+)`/gu, '$1')
-        .replace(/\s+/gu, ' ')
-        .trim();
-}
-function parseMarkdownTableRow(line) {
-    return line
-        .trim()
-        .replace(/^\|/u, '')
-        .replace(/\|$/u, '')
-        .split('|')
-        .map((cell) => normalizeMarkdownCell(cell));
-}
-function isMarkdownSeparatorRow(cells) {
-    return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/u.test(cell));
-}
-function skillNameFromPath(skillPath) {
-    return skillPath.split('/').at(-2) ?? path.posix.basename(skillPath, '.md');
-}
-function splitVerificationIntents(value) {
-    return value
-        .split(',')
-        .map((item) => item.trim())
-        .filter(Boolean)
-        .sort((left, right) => left.localeCompare(right));
-}
-function collectSkillRoutes(projectRoot) {
-    const indexPath = path.join(projectRoot, '.mustflow', 'skills', 'INDEX.md');
-    if (!existsSync(indexPath)) {
-        return [];
-    }
-    const content = readFileSync(indexPath, 'utf8');
-    const routes = [];
-    let inRouteTable = false;
-    for (const line of content.split(/\r?\n/u)) {
-        if (!line.trim().startsWith('|')) {
-            if (inRouteTable && line.trim() === '') {
-                inRouteTable = false;
-            }
-            continue;
-        }
-        const cells = parseMarkdownTableRow(line);
-        if (cells.includes('Skill Document') && cells.includes('Trigger')) {
-            inRouteTable = true;
-            continue;
-        }
-        if (!inRouteTable || isMarkdownSeparatorRow(cells) || cells.length < 7) {
-            continue;
-        }
-        const [trigger, skillPath, requiredInput, editScope, risk, verificationIntents, expectedOutput] = cells;
-        if (!skillPath?.startsWith('.mustflow/skills/') || !skillPath.endsWith('/SKILL.md')) {
-            continue;
-        }
-        routes.push({
-            skillName: skillNameFromPath(skillPath),
-            skillPath,
-            trigger: trigger ?? '',
-            requiredInput: requiredInput ?? '',
-            editScope: editScope ?? '',
-            risk: risk ?? '',
-            verificationIntents: splitVerificationIntents(verificationIntents ?? ''),
-            expectedOutput: expectedOutput ?? '',
-        });
-    }
-    return routes.sort((left, right) => {
-        const skillOrder = left.skillName.localeCompare(right.skillName);
-        return skillOrder === 0 ? left.trigger.localeCompare(right.trigger) : skillOrder;
-    });
-}
-function collectCommandIntents(projectRoot) {
-    if (!existsSync(path.join(projectRoot, '.mustflow', 'config', 'commands.toml'))) {
-        return [];
-    }
-    const contract = readCommandContract(projectRoot);
-    const intents = [];
-    for (const [name, intent] of Object.entries(contract.intents).sort(([left], [right]) => left.localeCompare(right))) {
-        if (!isRecord(intent)) {
-            continue;
-        }
-        intents.push({
-            name,
-            status: readString(intent, 'status') ?? 'unknown',
-            lifecycle: readString(intent, 'lifecycle') ?? null,
-            runPolicy: readString(intent, 'run_policy') ?? null,
-            description: readString(intent, 'description') ?? null,
-            effects: normalizeCommandEffects(projectRoot, contract, name),
-        });
-    }
-    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 {
-        path: relativePath,
-        sourceScope,
-        sizeBytes: stats.size,
-        mtimeMs: Math.round(stats.mtimeMs),
-    };
-}
-function hashIndexedFileMetadataRecord(projectRoot, metadata) {
-    return {
-        ...metadata,
-        contentHash: sha256Bytes(readFileSync(path.join(projectRoot, ...metadata.path.split('/')))),
-    };
-}
-function hashIndexedFileMetadataRecords(projectRoot, metadataRecords) {
-    return metadataRecords.map((metadata) => hashIndexedFileMetadataRecord(projectRoot, metadata));
-}
-function collectIndexedFileRecords(projectRoot, documents, sourceAnchors, sourceAnchorCandidatePaths = []) {
-    const records = new Map();
-    for (const document of documents) {
-        records.set(document.path, readIndexedFileRecord(projectRoot, document.path, 'workflow', document.contentHash));
-    }
-    const sourcePaths = new Set([...sourceAnchorCandidatePaths, ...sourceAnchors.map((anchor) => anchor.path)]);
-    for (const anchorPath of [...sourcePaths].sort((left, right) => left.localeCompare(right))) {
-        if (!records.has(anchorPath)) {
-            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 collectSourceAnchorCandidatePaths(projectRoot, sourceConfig) {
-    return listSourceAnchorFiles(projectRoot, {
-        ...sourceConfig,
-        excludeGeneratedOrVendor: true,
-    });
-}
-function collectFastPreflightIndexedFileMetadataRecords(projectRoot, includeSource, sourceConfig) {
-    const records = new Map();
-    for (const relativePath of getExistingIndexablePaths(projectRoot)) {
-        records.set(relativePath, readIndexedFileMetadataRecord(projectRoot, relativePath, 'workflow'));
-    }
-    if (includeSource) {
-        try {
-            for (const sourcePath of collectSourceAnchorCandidatePaths(projectRoot, sourceConfig)) {
-                if (!records.has(sourcePath)) {
-                    records.set(sourcePath, readIndexedFileMetadataRecord(projectRoot, sourcePath, 'source_anchor'));
-                }
-            }
-        }
-        catch {
-            return null;
-        }
-    }
-    if (existsSync(path.join(projectRoot, ...LATEST_RUN_STATE_RELATIVE_PATH.split('/')))) {
-        records.set(LATEST_RUN_STATE_RELATIVE_PATH, readIndexedFileMetadataRecord(projectRoot, LATEST_RUN_STATE_RELATIVE_PATH, 'state'));
-    }
-    return [...records.values()].sort((left, right) => left.path.localeCompare(right.path));
-}
 function normalizeSearchText(value) {
     return value.trim().replace(/\s+/g, ' ');
 }
@@ -414,25 +75,7 @@ function queryRows(database, sql, params = []) {
         return row;
     });
 }
-const VALIDATION_RATCHET_RISK_CODES = new Set([
-    'related_test_deleted',
-    'skip_or_only_marker_present',
-    'todo_or_pending_marker_added',
-    'assertion_count_decreased',
-    'assertion_matcher_weakened',
-    'negative_assertion_removed',
-    'exception_assertion_removed',
-    'snapshot_mass_updated',
-    'golden_output_replaced',
-    'verification_intent_disabled',
-    'verification_required_after_removed',
-    'success_exit_codes_widened',
-    'command_allows_no_tests',
-    'command_forces_snapshot_update',
-    'command_hides_failure',
-    'coverage_threshold_lowered',
-    'test_selection_narrowed',
-]);
+const DIRECT_SEARCH_MAX_WORKFLOW_FILES = 200;
 function searchCapabilities(fts5Available) {
     return {
         backend: fts5Available ? SEARCH_BACKEND_FTS5 : SEARCH_BACKEND_TABLE_SCAN,
@@ -452,446 +95,9 @@ function detectLocalSearchCapabilities(database) {
         return searchCapabilities(false);
     }
 }
-function isJsonRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function readJsonRecord(filePath) {
-    try {
-        const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
-        return isJsonRecord(parsed) ? parsed : null;
-    }
-    catch {
-        return null;
-    }
-}
-function stringField(record, key) {
-    const value = record?.[key];
-    return typeof value === 'string' ? value : null;
-}
-function booleanField(record, key) {
-    return record?.[key] === true;
-}
-function numberField(record, key) {
-    const value = record?.[key];
-    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
-}
-function recordField(record, key) {
-    const value = record?.[key];
-    return isJsonRecord(value) ? value : null;
-}
-function recordArrayField(record, key) {
-    const value = record?.[key];
-    return Array.isArray(value) ? value.filter(isJsonRecord) : [];
-}
-function stringArrayField(record, key) {
-    const value = record?.[key];
-    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
-}
 function joinedList(values) {
     return [...values].sort((left, right) => left.localeCompare(right)).join(', ');
 }
-function hashJson(value) {
-    return sha256Text(JSON.stringify(value));
-}
-function stringListHash(values) {
-    const normalized = values.filter((value) => typeof value === 'string' && value.length > 0);
-    return normalized.length > 0 ? hashJson([...normalized].sort((left, right) => left.localeCompare(right))) : null;
-}
-function reproObservation(routeId, phase, evidence) {
-    const status = stringField(evidence, 'status');
-    const outcome = stringField(evidence, 'outcome') ?? status;
-    const receiptHash = stringField(evidence, 'receipt_sha256');
-    const diagnosticFingerprint = stringField(evidence, 'diagnostic_fingerprint') ??
-        stringField(evidence, 'diagnostic_hash') ??
-        hashJson({
-            phase,
-            status,
-            outcome,
-            summary: stringField(evidence, 'summary'),
-            reason: stringField(evidence, 'reason'),
-        });
-    return {
-        routeId,
-        phase,
-        outcome,
-        receiptHash,
-        diagnosticFingerprint,
-    };
-}
-function evidenceStatusForRunReceipt(latest) {
-    return stringField(latest, 'status') ?? (booleanField(latest, 'timed_out') ? 'timed_out' : 'unknown');
-}
-function failedIntentsFromReceipts(receipts) {
-    return receipts
-        .filter((receipt) => ['failed', 'timed_out', 'start_failed'].includes(receipt.status))
-        .map((receipt) => receipt.intent)
-        .filter((intent) => typeof intent === 'string' && intent.length > 0)
-        .sort((left, right) => left.localeCompare(right));
-}
-function createFailureFingerprint(input) {
-    if (input.status === 'passed' ||
-        input.status === 'verified' ||
-        (input.failedIntents.length === 0 && input.riskCodes.length === 0 && input.timedOut !== true && !input.errorKind)) {
-        return null;
-    }
-    return sha256Text(JSON.stringify({
-        command: input.command,
-        status: input.status,
-        verificationPlanId: input.verificationPlanId,
-        primaryReason: input.primaryReason,
-        failedIntents: [...input.failedIntents].sort((left, right) => left.localeCompare(right)),
-        riskCodes: [...input.riskCodes].sort((left, right) => left.localeCompare(right)),
-        runIntent: input.runIntent ?? null,
-        timedOut: input.timedOut === true,
-        exitCodeClass: input.exitCodeClass ?? null,
-        errorKind: input.errorKind ?? null,
-    }));
-}
-function createVerificationEvidenceIndex(projectRoot) {
-    const latestPath = path.join(projectRoot, ...LATEST_RUN_STATE_RELATIVE_PATH.split('/'));
-    if (!existsSync(latestPath)) {
-        return {
-            summaries: [],
-            verificationPlans: [],
-            acceptanceCriteria: [],
-            criterionCoverage: [],
-            receipts: [],
-            commandReceiptSummaries: [],
-            coverageStates: [],
-            riskSignals: [],
-            validationRatchetSignals: [],
-            completionVerdictSummaries: [],
-            failureFingerprints: [],
-            reproRoutes: [],
-            reproObservations: [],
-            failureFingerprintReadModels: [],
-        };
-    }
-    const latest = readJsonRecord(latestPath);
-    if (!latest) {
-        return {
-            summaries: [],
-            verificationPlans: [],
-            acceptanceCriteria: [],
-            criterionCoverage: [],
-            receipts: [],
-            commandReceiptSummaries: [],
-            coverageStates: [],
-            riskSignals: [],
-            validationRatchetSignals: [],
-            completionVerdictSummaries: [],
-            failureFingerprints: [],
-            reproRoutes: [],
-            reproObservations: [],
-            failureFingerprintReadModels: [],
-        };
-    }
-    const sourceHash = sha256Bytes(readFileSync(latestPath));
-    const command = stringField(latest, 'command') ?? 'unknown';
-    const kind = stringField(latest, 'kind') ?? (command === 'verify' ? 'verify_run_summary' : 'run_receipt');
-    const evidenceModel = recordField(latest, 'evidence_model');
-    const completionVerdict = recordField(latest, 'completion_verdict');
-    const completionEvidence = recordField(completionVerdict, 'evidence');
-    const verificationPlanId = stringField(latest, 'verification_plan_id') ?? stringField(evidenceModel, 'verification_plan_id');
-    const primaryReason = stringField(completionVerdict, 'primary_reason');
-    const status = stringField(latest, 'status') ?? stringField(completionVerdict, 'status') ?? 'unknown';
-    const completionStatus = stringField(completionVerdict, 'status');
-    const rawReceipts = recordArrayField(evidenceModel, 'receipts');
-    const rawCoverage = recordArrayField(evidenceModel, 'coverage_matrix');
-    const rawRequirements = recordArrayField(evidenceModel, 'requirements');
-    const rawRisks = recordArrayField(evidenceModel, 'remaining_risks');
-    const recordedFailureFingerprintRecord = recordField(latest, 'failure_fingerprint');
-    const repeatedFailureSummary = recordField(latest, 'repeated_failure_summary');
-    const reproEvidence = recordField(latest, 'repro_evidence') ?? recordField(evidenceModel, 'repro_evidence');
-    const reproductionRoute = recordField(reproEvidence, 'reproduction_route');
-    const recordedFailureFingerprint = stringField(recordedFailureFingerprintRecord, 'fingerprint');
-    const receipts = rawReceipts.length > 0
-        ? rawReceipts.map((receipt, index) => ({
-            sourcePath: LATEST_RUN_STATE_RELATIVE_PATH,
-            ordinal: index + 1,
-            intent: stringField(receipt, 'intent'),
-            status: stringField(receipt, 'status') ?? 'unknown',
-            skipped: booleanField(receipt, 'skipped'),
-            verificationPlanId: stringField(receipt, 'verification_plan_id'),
-            receiptPath: stringField(receipt, 'receipt_path'),
-            receiptSha256: stringField(receipt, 'receipt_sha256'),
-            commandFingerprint: stringField(receipt, 'command_fingerprint'),
-            contractFingerprint: stringField(receipt, 'contract_fingerprint'),
-            currentStateHash: stringField(receipt, 'head_tree_hash') ??
-                stringField(receipt, 'changed_files_hash') ??
-                stringField(receipt, 'changed_file_hash'),
-            writeDriftStatus: stringField(receipt, 'write_drift_status'),
-        }))
-        : [
-            {
-                sourcePath: LATEST_RUN_STATE_RELATIVE_PATH,
-                ordinal: 1,
-                intent: stringField(latest, 'intent'),
-                status: evidenceStatusForRunReceipt(latest),
-                skipped: false,
-                verificationPlanId: null,
-                receiptPath: stringField(latest, 'receipt_path') ?? LATEST_RUN_STATE_RELATIVE_PATH,
-                receiptSha256: sourceHash,
-                commandFingerprint: stringField(recordField(latest, 'performance'), 'command_fingerprint'),
-                contractFingerprint: stringField(recordField(latest, 'performance'), 'contract_fingerprint'),
-                currentStateHash: stringField(latest, 'head_tree_hash') ?? stringField(latest, 'changed_files_hash'),
-                writeDriftStatus: stringField(recordField(latest, 'write_drift'), 'status'),
-            },
-        ];
-    const coverageStates = rawCoverage.map((coverage) => {
-        const evidence = recordField(coverage, 'evidence');
-        return {
-            sourcePath: LATEST_RUN_STATE_RELATIVE_PATH,
-            criterionId: stringField(coverage, 'criterion_id') ?? 'unknown',
-            source: stringField(coverage, 'source') ?? 'unknown',
-            status: stringField(coverage, 'status') ?? 'unknown',
-            requirementReason: stringField(coverage, 'requirement_reason'),
-            intents: stringArrayField(evidence, 'intents'),
-            receiptCount: stringArrayField(evidence, 'receipt_paths').length,
-            gapCount: stringArrayField(evidence, 'gap_reasons').length,
-            sourceAnchorCount: stringArrayField(evidence, 'source_anchor_ids').length,
-        };
-    });
-    const riskSignals = rawRisks.map((risk, index) => ({
-        sourcePath: LATEST_RUN_STATE_RELATIVE_PATH,
-        ordinal: index + 1,
-        code: stringField(risk, 'code') ?? 'unknown',
-        severity: stringField(risk, 'severity') ?? 'unknown',
-        detailHash: sha256Text(stringField(risk, 'detail') ?? ''),
-    }));
-    const validationRatchetSignals = rawRisks
-        .map((risk, index) => {
-        const code = stringField(risk, 'code') ?? 'unknown';
-        if (!VALIDATION_RATCHET_RISK_CODES.has(code)) {
-            return null;
-        }
-        const severity = stringField(risk, 'severity') ?? 'unknown';
-        const pathValue = stringField(risk, 'path');
-        const detailHash = sha256Text(stringField(risk, 'detail') ?? '');
-        const pathHash = pathValue === null ? hashJson({ code, detailHash }) : sha256Text(pathValue);
-        const beforeHash = stringField(risk, 'before_hash') ?? stringField(risk, 'before_digest');
-        const afterHash = stringField(risk, 'after_hash') ?? stringField(risk, 'after_digest');
-        return {
-            signalId: hashJson({
-                sourcePath: LATEST_RUN_STATE_RELATIVE_PATH,
-                ordinal: index + 1,
-                planId: verificationPlanId,
-                code,
-                pathHash,
-                beforeHash,
-                afterHash,
-            }),
-            planId: verificationPlanId,
-            code,
-            severity,
-            pathHash,
-            beforeHash,
-            afterHash,
-        };
-    })
-        .filter((signal) => signal !== null);
-    const verificationPlans = verificationPlanId === null
-        ? []
-        : [
-            {
-                planId: verificationPlanId,
-                sourcePath: LATEST_RUN_STATE_RELATIVE_PATH,
-                classificationHash: rawRequirements.length > 0 || rawCoverage.length > 0
-                    ? hashJson({
-                        requirements: rawRequirements.map((requirement) => ({
-                            id: stringField(requirement, 'requirement_id') ?? stringField(requirement, 'id'),
-                            reason: stringField(requirement, 'reason'),
-                            source: stringField(requirement, 'source'),
-                        })),
-                        coverage: rawCoverage.map((coverage) => ({
-                            id: stringField(coverage, 'criterion_id'),
-                            reason: stringField(coverage, 'requirement_reason'),
-                            source: stringField(coverage, 'source'),
-                            status: stringField(coverage, 'status'),
-                        })),
-                    })
-                    : null,
-                commandContractHash: stringListHash(receipts.map((receipt) => receipt.contractFingerprint)),
-                selectedIntentsHash: stringListHash(receipts.map((receipt) => receipt.intent)),
-                createdAt: stringField(latest, 'started_at') ?? stringField(latest, 'created_at'),
-                sourceHash,
-            },
-        ];
-    const acceptanceCriteria = verificationPlanId === null
-        ? []
-        : rawCoverage.map((coverage) => {
-            const evidence = recordField(coverage, 'evidence');
-            const pathRefs = [
-                ...stringArrayField(evidence, 'paths'),
-                ...stringArrayField(evidence, 'changed_paths'),
-                ...stringArrayField(evidence, 'source_anchor_ids'),
-            ];
-            return {
-                criterionId: stringField(coverage, 'criterion_id') ?? 'unknown',
-                planId: verificationPlanId,
-                source: stringField(coverage, 'source') ?? 'unknown',
-                statementHash: stringField(coverage, 'statement') ? sha256Text(stringField(coverage, 'statement') ?? '') : null,
-                reason: stringField(coverage, 'requirement_reason'),
-                surface: stringField(coverage, 'surface'),
-                pathHash: pathRefs.length > 0 ? stringListHash(pathRefs) : null,
-            };
-        });
-    const criterionCoverage = verificationPlanId === null
-        ? []
-        : coverageStates.map((coverage) => ({
-            criterionId: coverage.criterionId,
-            planId: verificationPlanId,
-            status: coverage.status,
-            receiptCount: coverage.receiptCount,
-            gapCount: coverage.gapCount,
-            riskCount: coverage.sourceAnchorCount,
-        }));
-    const commandReceiptSummaries = verificationPlanId === null
-        ? []
-        : receipts
-            .filter((receipt) => receipt.verificationPlanId === verificationPlanId || receipt.verificationPlanId === null)
-            .map((receipt) => ({
-            receiptHash: receipt.receiptSha256 ??
-                hashJson({
-                    sourcePath: receipt.sourcePath,
-                    ordinal: receipt.ordinal,
-                    intent: receipt.intent,
-                    status: receipt.status,
-                    verificationPlanId,
-                }),
-            planId: verificationPlanId,
-            intent: receipt.intent,
-            status: receipt.status,
-            commandFingerprint: receipt.commandFingerprint,
-            contractFingerprint: receipt.contractFingerprint,
-            currentStateHash: receipt.currentStateHash,
-            writeDriftStatus: receipt.writeDriftStatus,
-        }));
-    const completionVerdictSummaries = verificationPlanId === null || completionStatus === null
-        ? []
-        : [
-            {
-                claimId: hashJson({
-                    sourceHash,
-                    verificationPlanId,
-                    completionStatus,
-                    primaryReason,
-                }),
-                planId: verificationPlanId,
-                status: completionStatus,
-                primaryReason,
-                riskCount: riskSignals.length,
-                contradictionCount: stringArrayField(completionVerdict, 'contradictions').length,
-                blockerCount: stringArrayField(completionVerdict, 'blockers').length,
-            },
-        ];
-    const failedIntents = failedIntentsFromReceipts(receipts);
-    const failureFingerprint = recordedFailureFingerprint ??
-        createFailureFingerprint({
-            command,
-            status: completionStatus ?? status,
-            verificationPlanId,
-            primaryReason,
-            failedIntents,
-            riskCodes: riskSignals.map((risk) => risk.code),
-            runIntent: stringField(latest, 'intent'),
-            timedOut: booleanField(latest, 'timed_out'),
-            exitCodeClass: stringField(recordField(recordField(latest, 'performance'), 'result_summary'), 'exit_code_class'),
-            errorKind: stringField(recordField(recordField(latest, 'performance'), 'result_summary'), 'error_kind'),
-        });
-    const failureFingerprints = failureFingerprint === null
-        ? []
-        : [
-            {
-                sourcePath: LATEST_RUN_STATE_RELATIVE_PATH,
-                fingerprint: failureFingerprint,
-                verificationPlanId,
-                status: completionStatus ?? status,
-                failedIntents,
-                primaryReason,
-                failedIntentsHash: stringField(recordedFailureFingerprintRecord, 'failed_intents_hash') ??
-                    stringField(repeatedFailureSummary, 'failed_intents_hash'),
-                riskCodesHash: stringField(recordedFailureFingerprintRecord, 'risk_codes_hash') ??
-                    stringField(repeatedFailureSummary, 'risk_codes_hash'),
-                affectedSurfacesHash: stringField(recordedFailureFingerprintRecord, 'affected_surfaces_hash') ??
-                    stringField(repeatedFailureSummary, 'affected_surfaces_hash'),
-                firstSeenAt: stringField(repeatedFailureSummary, 'first_seen_at'),
-                lastSeenAt: stringField(repeatedFailureSummary, 'last_seen_at'),
-                seenCount: Math.max(1, numberField(repeatedFailureSummary, 'seen_count')),
-                requiresNewEvidence: booleanField(repeatedFailureSummary, 'requires_new_evidence'),
-            },
-        ];
-    const routeId = stringField(reproductionRoute, 'route_id');
-    const reproRoutes = routeId === null || reproEvidence === null
-        ? []
-        : [
-            {
-                routeId,
-                taskHash: hashJson({
-                    reported_symptom: stringField(reproEvidence, 'reported_symptom'),
-                    expected_behavior: stringField(reproEvidence, 'expected_behavior'),
-                    observed_behavior: stringField(reproEvidence, 'observed_behavior'),
-                }),
-                routeDigest: stringField(reproductionRoute, 'route_digest'),
-                routeKind: stringField(reproductionRoute, 'route_kind'),
-                failureOracleHash: stringField(reproductionRoute, 'failure_oracle_hash'),
-            },
-        ];
-    const reproObservations = routeId === null || reproEvidence === null
-        ? []
-        : [
-            reproObservation(routeId, 'before_fix', recordField(reproEvidence, 'before_fix')),
-            reproObservation(routeId, 'after_fix', recordField(reproEvidence, 'after_fix')),
-            reproObservation(routeId, 'regression_guard', recordField(reproEvidence, 'regression_guard')),
-        ];
-    const failureFingerprintReadModels = failureFingerprints.map((fingerprint) => ({
-        fingerprint: fingerprint.fingerprint,
-        planId: fingerprint.verificationPlanId,
-        failedIntentsHash: fingerprint.failedIntentsHash ?? stringListHash(fingerprint.failedIntents),
-        riskCodesHash: fingerprint.riskCodesHash,
-        seenCount: fingerprint.seenCount,
-        firstSeenAt: fingerprint.firstSeenAt,
-        lastSeenAt: fingerprint.lastSeenAt,
-    }));
-    return {
-        summaries: [
-            {
-                sourcePath: LATEST_RUN_STATE_RELATIVE_PATH,
-                sourceHash,
-                command,
-                kind,
-                status,
-                runDir: stringField(latest, 'run_dir'),
-                manifestPath: stringField(latest, 'manifest_path'),
-                verificationPlanId,
-                completionStatus,
-                primaryReason,
-                matchedIntents: numberField(completionEvidence, 'matched_intents'),
-                ranIntents: numberField(completionEvidence, 'ran_intents'),
-                passedIntents: numberField(completionEvidence, 'passed_intents'),
-                failedIntents: numberField(completionEvidence, 'failed_intents'),
-                skippedIntents: numberField(completionEvidence, 'skipped_intents'),
-                receiptCount: receipts.length,
-                coverageCount: coverageStates.length,
-                remainingRiskCount: riskSignals.length,
-                failureFingerprint,
-            },
-        ],
-        verificationPlans,
-        acceptanceCriteria,
-        criterionCoverage,
-        receipts,
-        commandReceiptSummaries,
-        coverageStates,
-        riskSignals,
-        validationRatchetSignals,
-        completionVerdictSummaries,
-        failureFingerprints,
-        reproRoutes,
-        reproObservations,
-        failureFingerprintReadModels,
-    };
-}
 function readMetadataValue(database, key) {
     return toSearchString(queryRows(database, 'SELECT value FROM metadata WHERE key = ?', [key])[0]?.value) || undefined;
 }
@@ -1591,9 +797,6 @@ function populatePathSurfaceReadModel(database) {
         insertPathSurfaceReasons(database, rule.id, 'drift_check', rule.surface.driftChecks);
     }
 }
-function skillRouteKey(route) {
-    return `${route.skillName}\u0000${route.trigger}`;
-}
 function populateSearchTables(database, capabilities, documents, skills, skillRoutes, commandIntents, sourceAnchors) {
     for (const document of documents) {
         const documentTerms = queryRows(database, 'SELECT term FROM document_terms WHERE document_path = ? ORDER BY term', [
@@ -2075,7 +1278,7 @@ function indexedFilesMatch(database, currentFiles) {
         if (!current) {
             return false;
         }
-        if (normalizeIndexedFileSourceScope(row.source_scope) !== current.sourceScope ||
+        if (normalizeIndexedFileSourceScope(toSearchString(row.source_scope)) !== current.sourceScope ||
             toSearchString(row.content_hash) !== current.contentHash ||
             toSearchString(row.parser_version) !== LOCAL_INDEX_PARSER_VERSION) {
             return false;
@@ -2095,7 +1298,7 @@ function indexedFileMetadataMatch(database, currentFiles) {
         if (!current) {
             return false;
         }
-        if (normalizeIndexedFileSourceScope(row.source_scope) !== current.sourceScope ||
+        if (normalizeIndexedFileSourceScope(toSearchString(row.source_scope)) !== current.sourceScope ||
             toNullableNumber(row.size_bytes) !== current.sizeBytes ||
             toNullableNumber(row.mtime_ms) !== current.mtimeMs ||
             toSearchString(row.parser_version) !== LOCAL_INDEX_PARSER_VERSION) {
@@ -2296,7 +1499,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 = normalizeIndexedFileSourceScope(row.source_scope);
+            const sourceScope = normalizeIndexedFileSourceScope(toSearchString(row.source_scope));
             try {
                 const current = readIndexedFileRecord(projectRoot, indexedPath, sourceScope);
                 if (current.contentHash !== toSearchString(row.content_hash)) {
@@ -2989,6 +2192,99 @@ function scoreIndexedOrTableScan(primaryFields, secondaryFields, query, indexedM
     const tableScore = scoreMatch(primaryFields, secondaryFields, query);
     return indexedMatches.active && matchSet.size > 0 && matchSet.has(key) ? Math.max(tableScore, 20) : tableScore;
 }
+function sortLocalSearchResults(results, scope, limit) {
+    return [...results]
+        .sort((left, right) => {
+        if (scope === 'all' && left.authority_rank !== right.authority_rank) {
+            return left.authority_rank - right.authority_rank;
+        }
+        return right.score - left.score || (left.path ?? left.name ?? '').localeCompare(right.path ?? right.name ?? '');
+    })
+        .slice(0, limit);
+}
+function collectBoundedDirectSearchDocuments(projectRoot) {
+    const documents = [];
+    const relativePaths = getExistingIndexablePaths(projectRoot).slice(0, DIRECT_SEARCH_MAX_WORKFLOW_FILES);
+    for (const relativePath of relativePaths) {
+        try {
+            documents.push(...collectDocumentsFromPaths(projectRoot, [relativePath]));
+        }
+        catch {
+            continue;
+        }
+    }
+    return documents;
+}
+function searchLocalWorkflowFilesDirectly(projectRoot, databasePath, normalizedQuery, limit, scope) {
+    const cacheLayers = readCacheLayerSets(projectRoot);
+    const results = [];
+    if (scope === 'workflow' || scope === 'all') {
+        const documents = collectBoundedDirectSearchDocuments(projectRoot);
+        for (const document of documents) {
+            let searchableContent = document.contentSnippet;
+            try {
+                searchableContent = readText(projectRoot, document.path);
+            }
+            catch {
+                searchableContent = document.contentSnippet;
+            }
+            const primaryFields = [document.path, document.title];
+            const secondaryFields = [document.type, searchableContent, ...document.sections];
+            const fields = [...primaryFields, ...secondaryFields];
+            if (!isMatched(fields, normalizedQuery)) {
+                continue;
+            }
+            results.push(withCacheHint({
+                kind: 'document',
+                path: document.path,
+                title: document.title,
+                document_type: document.type,
+                ...workflowAuthorityForDocument(document.type),
+                match: getMatchSnippet(fields, normalizedQuery),
+                score: scoreMatch(primaryFields, secondaryFields, normalizedQuery),
+            }, cacheLayers));
+        }
+        for (const skill of collectSkills(documents)) {
+            const fields = [skill.name, skill.path, skill.title];
+            if (!isMatched(fields, normalizedQuery)) {
+                continue;
+            }
+            results.push(withCacheHint({
+                kind: 'skill',
+                name: skill.name,
+                path: skill.path,
+                title: skill.title,
+                ...skillAuthority(),
+                match: getMatchSnippet(fields, normalizedQuery),
+                score: scoreMatch(fields, [], normalizedQuery),
+            }, cacheLayers));
+        }
+    }
+    const sortedResults = sortLocalSearchResults(results, scope, limit);
+    return {
+        schema_version: LOCAL_INDEX_SCHEMA_VERSION,
+        command: 'search',
+        ok: true,
+        mustflow_root: path.resolve(projectRoot),
+        database_path: databasePath,
+        query: normalizedQuery,
+        limit,
+        scope,
+        index_fresh: false,
+        stale_paths: [],
+        search_backend: SEARCH_BACKEND_TABLE_SCAN,
+        search_fts5_available: false,
+        result_count: sortedResults.length,
+        results: sortedResults,
+    };
+}
+function isLocalIndexStaleError(error) {
+    return error instanceof Error && error.message.startsWith('Local mustflow index is stale:');
+}
+function isLocalIndexRuntimeUnavailableError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /file is not a database|database disk image is malformed|no such table|no such column|sqlite|sql\.js/iu.test(message);
+}
 /**
  * mf:anchor cli.search.local-index
  * purpose: Search the local index while preserving workflow authority above source navigation hints.
@@ -3001,14 +2297,20 @@ export async function searchLocalIndex(projectRoot, query, options = {}) {
     const limit = Math.max(1, Math.min(options.limit ?? 10, 50));
     const scope = options.scope ?? 'workflow';
     const databasePath = getLocalIndexDatabasePath(projectRoot);
-    if (!existsSync(databasePath)) {
-        throw new Error('Local mustflow index not found. Run `mf index` before searching.');
-    }
     if (normalizedQuery.length === 0) {
         throw new Error('Search query must not be empty.');
     }
-    const SQL = await loadSqlJs();
-    const database = new SQL.Database(readFileSync(databasePath));
+    if (!existsSync(databasePath)) {
+        return searchLocalWorkflowFilesDirectly(projectRoot, databasePath, normalizedQuery, limit, scope);
+    }
+    let database;
+    try {
+        const SQL = await loadSqlJs();
+        database = new SQL.Database(readFileSync(databasePath));
+    }
+    catch {
+        return searchLocalWorkflowFilesDirectly(projectRoot, databasePath, normalizedQuery, limit, scope);
+    }
     const cacheLayers = readCacheLayerSets(projectRoot);
     let capabilities = searchCapabilities(false);
     const results = [];
@@ -3158,17 +2460,19 @@ export async function searchLocalIndex(projectRoot, query, options = {}) {
             }
         }
     }
+    catch (error) {
+        if (isLocalIndexStaleError(error)) {
+            throw error;
+        }
+        if (isLocalIndexRuntimeUnavailableError(error)) {
+            return searchLocalWorkflowFilesDirectly(projectRoot, databasePath, normalizedQuery, limit, scope);
+        }
+        throw error;
+    }
     finally {
         database.close();
     }
-    const sortedResults = results
-        .sort((left, right) => {
-        if (scope === 'all' && left.authority_rank !== right.authority_rank) {
-            return left.authority_rank - right.authority_rank;
-        }
-        return right.score - left.score || (left.path ?? left.name ?? '').localeCompare(right.path ?? right.name ?? '');
-    })
-        .slice(0, limit);
+    const sortedResults = sortLocalSearchResults(results, scope, limit);
     return {
         schema_version: LOCAL_INDEX_SCHEMA_VERSION,
         command: 'search',