mustflow 2.32.0 → 2.37.1

package/dist/cli/commands/api/actions.js

@@ -0,0 +1,55 @@
+export const API_REPORT_ACTIONS = [
+    {
+        action: 'workspace-summary',
+        requiresChanged: false,
+        helpKey: 'api.help.action.workspaceSummary',
+        example: 'mf api workspace-summary --json',
+    },
+    {
+        action: 'command-catalog',
+        requiresChanged: false,
+        helpKey: 'api.help.action.commandCatalog',
+        example: 'mf api command-catalog --json',
+    },
+    {
+        action: 'verification-plan',
+        requiresChanged: true,
+        helpKey: 'api.help.action.verificationPlan',
+        example: 'mf api verification-plan --changed --json',
+    },
+    {
+        action: 'latest-evidence',
+        requiresChanged: false,
+        helpKey: 'api.help.action.latestEvidence',
+        example: 'mf api latest-evidence --json',
+    },
+    {
+        action: 'diff-risk',
+        requiresChanged: true,
+        helpKey: 'api.help.action.diffRisk',
+        example: 'mf api diff-risk --changed --json',
+    },
+    {
+        action: 'health',
+        requiresChanged: false,
+        helpKey: 'api.help.action.health',
+        example: 'mf api health --json',
+    },
+    {
+        action: 'locks',
+        requiresChanged: false,
+        helpKey: 'api.help.action.locks',
+        example: 'mf api locks --json',
+    },
+];
+const API_REPORT_ACTION_NAMES = new Set(API_REPORT_ACTIONS.map((spec) => spec.action));
+export function isApiReportAction(value) {
+    return API_REPORT_ACTION_NAMES.has(value);
+}
+export function apiReportActionSpec(action) {
+    const spec = API_REPORT_ACTIONS.find((candidate) => candidate.action === action);
+    if (!spec) {
+        throw new Error(`Unknown API report action: ${action}`);
+    }
+    return spec;
+}

package/dist/cli/commands/api/report-runner.js

@@ -0,0 +1,62 @@
+import { printUsageError } from '../../lib/cli-output.js';
+import { formatCliOptionParseError, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../../lib/option-parser.js';
+import { t } from '../../lib/i18n.js';
+const API_JSON_ONLY_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+    { name: '--help', kind: 'boolean', aliases: ['-h'] },
+];
+const API_CHANGED_JSON_OPTIONS = [
+    { name: '--changed', kind: 'boolean' },
+    { name: '--json', kind: 'boolean' },
+    { name: '--help', kind: 'boolean', aliases: ['-h'] },
+];
+function validateJsonOnlyAction(action, args, reporter, lang, runtime) {
+    const parsed = parseCliOptions(args, API_JSON_ONLY_OPTIONS);
+    if (hasParsedCliOption(parsed, '--help')) {
+        reporter.stdout(runtime.getHelp(lang));
+        return false;
+    }
+    if (parsed.error) {
+        printUsageError(reporter, formatCliOptionParseError(parsed.error, lang), 'mf api --help', runtime.getHelp(lang), lang);
+        return false;
+    }
+    if (!hasParsedCliOption(parsed, '--json')) {
+        printUsageError(reporter, t(lang, 'api.error.actionRequiresJson', { action }), 'mf api --help', runtime.getHelp(lang), lang);
+        return false;
+    }
+    return true;
+}
+function validateChangedJsonAction(action, args, reporter, lang, runtime) {
+    const parsed = parseCliOptions(args, API_CHANGED_JSON_OPTIONS);
+    if (hasParsedCliOption(parsed, '--help')) {
+        reporter.stdout(runtime.getHelp(lang));
+        return false;
+    }
+    if (parsed.error) {
+        printUsageError(reporter, formatCliOptionParseError(parsed.error, lang), 'mf api --help', runtime.getHelp(lang), lang);
+        return false;
+    }
+    if (!hasParsedCliOption(parsed, '--json')) {
+        printUsageError(reporter, t(lang, 'api.error.actionRequiresJson', { action }), 'mf api --help', runtime.getHelp(lang), lang);
+        return false;
+    }
+    if (!hasParsedCliOption(parsed, '--changed')) {
+        printUsageError(reporter, t(lang, 'api.error.actionRequiresChanged', { action }), 'mf api --help', runtime.getHelp(lang), lang);
+        return false;
+    }
+    return true;
+}
+export function runJsonOnlyApiReport(action, args, reporter, lang, runtime) {
+    if (!validateJsonOnlyAction(action, args, reporter, lang, runtime)) {
+        return hasCliOptionToken(args, '--help', ['-h']) ? 0 : 1;
+    }
+    runtime.writeReport(action, reporter);
+    return 0;
+}
+export function runChangedApiReport(action, args, reporter, lang, runtime) {
+    if (!validateChangedJsonAction(action, args, reporter, lang, runtime)) {
+        return hasCliOptionToken(args, '--help', ['-h']) ? 0 : 1;
+    }
+    runtime.writeReport(action, reporter);
+    return 0;
+}

package/dist/cli/commands/api/serve.js

@@ -0,0 +1,149 @@
+import { createInterface } from 'node:readline';
+import { apiReportActionSpec, isApiReportAction } from './actions.js';
+import { printUsageError } from '../../lib/cli-output.js';
+import { formatCliOptionParseError, hasParsedCliOption, parseCliOptions, } from '../../lib/option-parser.js';
+import { isRecord } from '../../lib/command-contract.js';
+import { t } from '../../lib/i18n.js';
+const API_SERVE_SCHEMA_VERSION = '1';
+const API_SERVE_OPTIONS = [
+    { name: '--stdio', kind: 'boolean' },
+    { name: '--help', kind: 'boolean', aliases: ['-h'] },
+];
+function createApiServePolicy() {
+    return {
+        mode: 'read_only',
+        executes_commands: false,
+        direct_commands_allowed: false,
+        raw_output_included: false,
+        hidden_reasoning_included: false,
+    };
+}
+function createApiServeError(id, code, message) {
+    return {
+        schema_version: API_SERVE_SCHEMA_VERSION,
+        command: 'api serve',
+        transport: 'stdio',
+        id,
+        ok: false,
+        policy: createApiServePolicy(),
+        error: {
+            code,
+            message,
+        },
+    };
+}
+function createApiServeSuccess(id, result) {
+    return {
+        schema_version: API_SERVE_SCHEMA_VERSION,
+        command: 'api serve',
+        transport: 'stdio',
+        id,
+        ok: true,
+        policy: createApiServePolicy(),
+        result,
+    };
+}
+function readApiServeId(request) {
+    if (!isRecord(request) || !Object.hasOwn(request, 'id')) {
+        return null;
+    }
+    const value = request.id;
+    if (typeof value === 'string' || typeof value === 'number' || value === null) {
+        return value;
+    }
+    return null;
+}
+function parseApiServeRequestLine(line) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            request: null,
+            error: createApiServeError(null, 'invalid_json', `Invalid JSON request: ${message}`),
+        };
+    }
+    const id = readApiServeId(parsed);
+    if (!isRecord(parsed)) {
+        return {
+            request: null,
+            error: createApiServeError(id, 'invalid_request', 'Request must be a JSON object.'),
+        };
+    }
+    return {
+        request: {
+            id,
+            action: parsed.action,
+            changed: parsed.changed,
+        },
+        error: null,
+    };
+}
+function createApiServeResponse(request, runtime) {
+    const id = typeof request.id === 'string' || typeof request.id === 'number' || request.id === null ? request.id : null;
+    if (typeof request.action !== 'string') {
+        return createApiServeError(id, 'invalid_request', 'Request field "action" must be a string.');
+    }
+    if (!isApiReportAction(request.action)) {
+        return createApiServeError(id, 'unknown_action', `Unknown api action: ${request.action}`);
+    }
+    const spec = apiReportActionSpec(request.action);
+    if (spec.requiresChanged && request.changed !== true) {
+        return createApiServeError(id, 'action_requires_changed', `${request.action} requires changed: true.`);
+    }
+    if (!spec.requiresChanged && request.changed === true) {
+        return createApiServeError(id, 'action_does_not_accept_changed', `${request.action} does not accept changed: true.`);
+    }
+    try {
+        return createApiServeSuccess(id, runtime.createReport(request.action));
+    }
+    catch (error) {
+        return createApiServeError(id, 'report_unavailable', error instanceof Error ? error.message : String(error));
+    }
+}
+function writeApiServeResponse(response, reporter) {
+    const line = `${JSON.stringify(response)}\n`;
+    if (reporter.writeStdout) {
+        reporter.writeStdout(line);
+        return;
+    }
+    reporter.stdout(line.trimEnd());
+}
+export async function runApiServe(args, reporter, lang, runtime) {
+    const parsed = parseCliOptions(args, API_SERVE_OPTIONS);
+    if (hasParsedCliOption(parsed, '--help')) {
+        reporter.stdout(runtime.getHelp(lang));
+        return 0;
+    }
+    if (parsed.error) {
+        printUsageError(reporter, formatCliOptionParseError(parsed.error, lang), 'mf api --help', runtime.getHelp(lang), lang);
+        return 1;
+    }
+    if (!hasParsedCliOption(parsed, '--stdio')) {
+        printUsageError(reporter, t(lang, 'api.error.serveRequiresStdio'), 'mf api --help', runtime.getHelp(lang), lang);
+        return 1;
+    }
+    const input = createInterface({
+        input: process.stdin,
+        crlfDelay: Infinity,
+    });
+    for await (const rawLine of input) {
+        const line = rawLine.trim();
+        if (line.length === 0) {
+            continue;
+        }
+        const parsed = parseApiServeRequestLine(line);
+        if (parsed.error) {
+            writeApiServeResponse(parsed.error, reporter);
+            continue;
+        }
+        if (!parsed.request) {
+            writeApiServeResponse(createApiServeError(null, 'invalid_request', 'Request must be a JSON object.'), reporter);
+            continue;
+        }
+        writeApiServeResponse(createApiServeResponse(parsed.request, runtime), reporter);
+    }
+    return 0;
+}

package/dist/cli/commands/api/workspace-recommendations.js

@@ -0,0 +1,13 @@
+export function createRecommendedNextCommands(output) {
+    if (!output.installed) {
+        return ['mf init --dry-run', 'mf init --yes'];
+    }
+    if (!output.check.ok) {
+        return ['mf check', 'mf status --json', 'mf update --dry-run'];
+    }
+    const commands = ['mf context --json', 'mf doctor --json', 'mf check --strict'];
+    if (output.git_state.status === 'available' && output.git_state.changed_file_count !== null && output.git_state.changed_file_count > 0) {
+        commands.push('mf classify --changed --json', 'mf verify --changed --plan-only --json');
+    }
+    return commands;
+}

package/dist/cli/commands/api.js

@@ -1,13 +1,16 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
-import { createInterface } from 'node:readline';
 import { createClassifyOutput } from './classify.js';
+import { API_REPORT_ACTIONS, apiReportActionSpec, isApiReportAction, } from './api/actions.js';
+import { runChangedApiReport, runJsonOnlyApiReport } from './api/report-runner.js';
+import { runApiServe } from './api/serve.js';
+import { createRecommendedNextCommands } from './api/workspace-recommendations.js';
 import { listActiveRunLocks } from '../../core/active-run-locks.js';
 import { createChangeVerificationReport, } from '../../core/change-verification.js';
 import { readUtf8FileInsideWithoutSymlinks } from '../../core/safe-filesystem.js';
 import { createVerificationPlanId } from '../../core/verification-plan-id.js';
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
-import { formatCliOptionParseError, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
+import { hasCliOptionToken } from '../lib/option-parser.js';
 import { getAgentContext } from '../lib/agent-context.js';
 import { isRecord, readCommandContract, readPositiveInteger, readString, readStringArray, } from '../lib/command-contract.js';
 import { readGitChangedFiles } from '../lib/git-changes.js';
@@ -22,79 +25,10 @@ const API_LATEST_EVIDENCE_SCHEMA_VERSION = '1';
 const API_DIFF_RISK_SCHEMA_VERSION = '1';
 const API_HEALTH_SCHEMA_VERSION = '1';
 const API_LOCKS_SCHEMA_VERSION = '1';
-const API_SERVE_SCHEMA_VERSION = '1';
 const COMMANDS_RELATIVE_PATH = '.mustflow/config/commands.toml';
 const LATEST_RUN_RELATIVE_PATH = '.mustflow/state/runs/latest.json';
 const LOCKS_RELATIVE_PATH = '.mustflow/state/locks';
 const MUSTFLOW_JSON_MAX_BYTES = 1024 * 1024;
-const API_JSON_ONLY_OPTIONS = [
-    { name: '--json', kind: 'boolean' },
-    { name: '--help', kind: 'boolean', aliases: ['-h'] },
-];
-const API_CHANGED_JSON_OPTIONS = [
-    { name: '--changed', kind: 'boolean' },
-    { name: '--json', kind: 'boolean' },
-    { name: '--help', kind: 'boolean', aliases: ['-h'] },
-];
-const API_SERVE_OPTIONS = [
-    { name: '--stdio', kind: 'boolean' },
-    { name: '--help', kind: 'boolean', aliases: ['-h'] },
-];
-const API_REPORT_ACTIONS = [
-    {
-        action: 'workspace-summary',
-        requiresChanged: false,
-        helpKey: 'api.help.action.workspaceSummary',
-        example: 'mf api workspace-summary --json',
-    },
-    {
-        action: 'command-catalog',
-        requiresChanged: false,
-        helpKey: 'api.help.action.commandCatalog',
-        example: 'mf api command-catalog --json',
-    },
-    {
-        action: 'verification-plan',
-        requiresChanged: true,
-        helpKey: 'api.help.action.verificationPlan',
-        example: 'mf api verification-plan --changed --json',
-    },
-    {
-        action: 'latest-evidence',
-        requiresChanged: false,
-        helpKey: 'api.help.action.latestEvidence',
-        example: 'mf api latest-evidence --json',
-    },
-    {
-        action: 'diff-risk',
-        requiresChanged: true,
-        helpKey: 'api.help.action.diffRisk',
-        example: 'mf api diff-risk --changed --json',
-    },
-    {
-        action: 'health',
-        requiresChanged: false,
-        helpKey: 'api.help.action.health',
-        example: 'mf api health --json',
-    },
-    {
-        action: 'locks',
-        requiresChanged: false,
-        helpKey: 'api.help.action.locks',
-        example: 'mf api locks --json',
-    },
-];
-const API_REPORT_ACTION_NAMES = new Set(API_REPORT_ACTIONS.map((spec) => spec.action));
-function isApiReportAction(value) {
-    return API_REPORT_ACTION_NAMES.has(value);
-}
-function apiReportActionSpec(action) {
-    const spec = API_REPORT_ACTIONS.find((candidate) => candidate.action === action);
-    if (!spec) {
-        throw new Error(`Unknown API report action: ${action}`);
-    }
-    return spec;
-}
 export function getApiHelp(lang = 'en') {
     return renderHelp({
         usage: 'mf api <action> [options]',
@@ -194,19 +128,6 @@ function createRecommendedReadSurfaces(context) {
     ];
     return [...new Set(surfaces)];
 }
-function createRecommendedNextCommands(output) {
-    if (!output.installed) {
-        return ['mf init --dry-run', 'mf init --yes'];
-    }
-    if (!output.check.ok) {
-        return ['mf check', 'mf status --json', 'mf update --dry-run'];
-    }
-    const commands = ['mf context --json', 'mf doctor --json', 'mf check --strict'];
-    if (output.git_state.status === 'available' && output.git_state.changed_file_count !== null && output.git_state.changed_file_count > 0) {
-        commands.push('mf classify --changed --json', 'mf verify --changed --plan-only --json');
-    }
-    return commands;
-}
 function isSafeIntentName(value) {
     return /^[A-Za-z0-9_-]+$/u.test(value);
 }
@@ -1045,194 +966,6 @@ function createApiReport(action) {
 function writeApiReport(action, reporter) {
     reporter.stdout(JSON.stringify(createApiReport(action), null, 2));
 }
-function createApiServePolicy() {
-    return {
-        mode: 'read_only',
-        executes_commands: false,
-        direct_commands_allowed: false,
-        raw_output_included: false,
-        hidden_reasoning_included: false,
-    };
-}
-function createApiServeError(id, code, message) {
-    return {
-        schema_version: API_SERVE_SCHEMA_VERSION,
-        command: 'api serve',
-        transport: 'stdio',
-        id,
-        ok: false,
-        policy: createApiServePolicy(),
-        error: {
-            code,
-            message,
-        },
-    };
-}
-function createApiServeSuccess(id, result) {
-    return {
-        schema_version: API_SERVE_SCHEMA_VERSION,
-        command: 'api serve',
-        transport: 'stdio',
-        id,
-        ok: true,
-        policy: createApiServePolicy(),
-        result,
-    };
-}
-function readApiServeId(request) {
-    if (!isRecord(request) || !Object.hasOwn(request, 'id')) {
-        return null;
-    }
-    const value = request.id;
-    if (typeof value === 'string' || typeof value === 'number' || value === null) {
-        return value;
-    }
-    return null;
-}
-function parseApiServeRequestLine(line) {
-    let parsed;
-    try {
-        parsed = JSON.parse(line);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            request: null,
-            error: createApiServeError(null, 'invalid_json', `Invalid JSON request: ${message}`),
-        };
-    }
-    const id = readApiServeId(parsed);
-    if (!isRecord(parsed)) {
-        return {
-            request: null,
-            error: createApiServeError(id, 'invalid_request', 'Request must be a JSON object.'),
-        };
-    }
-    return {
-        request: {
-            id,
-            action: parsed.action,
-            changed: parsed.changed,
-        },
-        error: null,
-    };
-}
-function createApiServeResponse(request) {
-    const id = typeof request.id === 'string' || typeof request.id === 'number' || request.id === null ? request.id : null;
-    if (typeof request.action !== 'string') {
-        return createApiServeError(id, 'invalid_request', 'Request field "action" must be a string.');
-    }
-    if (!isApiReportAction(request.action)) {
-        return createApiServeError(id, 'unknown_action', `Unknown api action: ${request.action}`);
-    }
-    const spec = apiReportActionSpec(request.action);
-    if (spec.requiresChanged && request.changed !== true) {
-        return createApiServeError(id, 'action_requires_changed', `${request.action} requires changed: true.`);
-    }
-    if (!spec.requiresChanged && request.changed === true) {
-        return createApiServeError(id, 'action_does_not_accept_changed', `${request.action} does not accept changed: true.`);
-    }
-    try {
-        return createApiServeSuccess(id, createApiReport(request.action));
-    }
-    catch (error) {
-        return createApiServeError(id, 'report_unavailable', error instanceof Error ? error.message : String(error));
-    }
-}
-function writeApiServeResponse(response, reporter) {
-    const line = `${JSON.stringify(response)}\n`;
-    if (reporter.writeStdout) {
-        reporter.writeStdout(line);
-        return;
-    }
-    reporter.stdout(line.trimEnd());
-}
-async function runApiServe(args, reporter, lang) {
-    const parsed = parseCliOptions(args, API_SERVE_OPTIONS);
-    if (hasParsedCliOption(parsed, '--help')) {
-        reporter.stdout(getApiHelp(lang));
-        return 0;
-    }
-    if (parsed.error) {
-        printUsageError(reporter, formatCliOptionParseError(parsed.error, lang), 'mf api --help', getApiHelp(lang), lang);
-        return 1;
-    }
-    if (!hasParsedCliOption(parsed, '--stdio')) {
-        printUsageError(reporter, t(lang, 'api.error.serveRequiresStdio'), 'mf api --help', getApiHelp(lang), lang);
-        return 1;
-    }
-    const input = createInterface({
-        input: process.stdin,
-        crlfDelay: Infinity,
-    });
-    for await (const rawLine of input) {
-        const line = rawLine.trim();
-        if (line.length === 0) {
-            continue;
-        }
-        const parsed = parseApiServeRequestLine(line);
-        if (parsed.error) {
-            writeApiServeResponse(parsed.error, reporter);
-            continue;
-        }
-        if (!parsed.request) {
-            writeApiServeResponse(createApiServeError(null, 'invalid_request', 'Request must be a JSON object.'), reporter);
-            continue;
-        }
-        writeApiServeResponse(createApiServeResponse(parsed.request), reporter);
-    }
-    return 0;
-}
-function validateJsonOnlyAction(action, args, reporter, lang) {
-    const parsed = parseCliOptions(args, API_JSON_ONLY_OPTIONS);
-    if (hasParsedCliOption(parsed, '--help')) {
-        reporter.stdout(getApiHelp(lang));
-        return false;
-    }
-    if (parsed.error) {
-        printUsageError(reporter, formatCliOptionParseError(parsed.error, lang), 'mf api --help', getApiHelp(lang), lang);
-        return false;
-    }
-    if (!hasParsedCliOption(parsed, '--json')) {
-        printUsageError(reporter, t(lang, 'api.error.actionRequiresJson', { action }), 'mf api --help', getApiHelp(lang), lang);
-        return false;
-    }
-    return true;
-}
-function validateChangedJsonAction(action, args, reporter, lang) {
-    const parsed = parseCliOptions(args, API_CHANGED_JSON_OPTIONS);
-    if (hasParsedCliOption(parsed, '--help')) {
-        reporter.stdout(getApiHelp(lang));
-        return false;
-    }
-    if (parsed.error) {
-        printUsageError(reporter, formatCliOptionParseError(parsed.error, lang), 'mf api --help', getApiHelp(lang), lang);
-        return false;
-    }
-    if (!hasParsedCliOption(parsed, '--json')) {
-        printUsageError(reporter, t(lang, 'api.error.actionRequiresJson', { action }), 'mf api --help', getApiHelp(lang), lang);
-        return false;
-    }
-    if (!hasParsedCliOption(parsed, '--changed')) {
-        printUsageError(reporter, t(lang, 'api.error.actionRequiresChanged', { action }), 'mf api --help', getApiHelp(lang), lang);
-        return false;
-    }
-    return true;
-}
-function runJsonOnlyApiReport(action, args, reporter, lang) {
-    if (!validateJsonOnlyAction(action, args, reporter, lang)) {
-        return hasCliOptionToken(args, '--help', ['-h']) ? 0 : 1;
-    }
-    writeApiReport(action, reporter);
-    return 0;
-}
-function runChangedApiReport(action, args, reporter, lang) {
-    if (!validateChangedJsonAction(action, args, reporter, lang)) {
-        return hasCliOptionToken(args, '--help', ['-h']) ? 0 : 1;
-    }
-    writeApiReport(action, reporter);
-    return 0;
-}
 export function runApi(args, reporter, lang = 'en') {
     if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getApiHelp(lang));
@@ -1248,12 +981,19 @@ export function runApi(args, reporter, lang = 'en') {
         return 1;
     }
     if (action === 'serve') {
-        return runApiServe(rest, reporter, lang);
+        return runApiServe(rest, reporter, lang, {
+            createReport: createApiReport,
+            getHelp: getApiHelp,
+        });
     }
     if (isApiReportAction(action)) {
+        const reportRuntime = {
+            getHelp: getApiHelp,
+            writeReport: writeApiReport,
+        };
         return apiReportActionSpec(action).requiresChanged
-            ? runChangedApiReport(action, rest, reporter, lang)
-            : runJsonOnlyApiReport(action, rest, reporter, lang);
+            ? runChangedApiReport(action, rest, reporter, lang, reportRuntime)
+            : runJsonOnlyApiReport(action, rest, reporter, lang, reportRuntime);
     }
     printUsageError(reporter, t(lang, 'api.error.unknownAction', { action }), 'mf api --help', getApiHelp(lang), lang);
     return 1;

package/dist/cli/lib/local-index/search-read-model.js

@@ -107,11 +107,45 @@ function sourceAnchorAuthority() {
         can_instruct_agent: false,
     };
 }
-function getSectionHeadings(database, documentPath) {
-    return queryRows(database, 'SELECT heading FROM sections WHERE document_path = ? ORDER BY ordinal', [documentPath]).map((row) => toSearchString(row.heading));
+function createEmptyDocumentSearchMetadata() {
+    return { sectionHeadings: [], documentTerms: [] };
 }
-function getDocumentTerms(database, documentPath) {
-    return queryRows(database, 'SELECT term FROM document_terms WHERE document_path = ? ORDER BY term', [documentPath]).map((row) => toSearchString(row.term));
+function queryRowsByDocumentPath(database, sqlPrefix, documentPaths) {
+    const rows = [];
+    const chunkSize = 200;
+    for (let start = 0; start < documentPaths.length; start += chunkSize) {
+        const chunk = documentPaths.slice(start, start + chunkSize);
+        rows.push(...queryRows(database, `${sqlPrefix} WHERE document_path IN (${sqlPlaceholders(chunk)})`, chunk));
+    }
+    return rows;
+}
+function readDocumentSearchMetadata(database, documentPaths) {
+    const uniquePaths = [...new Set(documentPaths)].filter((documentPath) => documentPath.length > 0);
+    const metadata = new Map(uniquePaths.map((documentPath) => [documentPath, { sectionHeadings: [], documentTerms: [] }]));
+    if (uniquePaths.length === 0) {
+        return metadata;
+    }
+    for (const row of queryRowsByDocumentPath(database, 'SELECT document_path, ordinal, heading FROM sections', uniquePaths).sort((left, right) => {
+        const leftPath = toSearchString(left.document_path);
+        const rightPath = toSearchString(right.document_path);
+        return leftPath.localeCompare(rightPath) || Number(left.ordinal ?? 0) - Number(right.ordinal ?? 0);
+    })) {
+        const entry = metadata.get(toSearchString(row.document_path));
+        if (entry) {
+            entry.sectionHeadings.push(toSearchString(row.heading));
+        }
+    }
+    for (const row of queryRowsByDocumentPath(database, 'SELECT document_path, term FROM document_terms', uniquePaths).sort((left, right) => {
+        const leftPath = toSearchString(left.document_path);
+        const rightPath = toSearchString(right.document_path);
+        return leftPath.localeCompare(rightPath) || toSearchString(left.term).localeCompare(toSearchString(right.term));
+    })) {
+        const entry = metadata.get(toSearchString(row.document_path));
+        if (entry) {
+            entry.documentTerms.push(toSearchString(row.term));
+        }
+    }
+    return metadata;
 }
 function commandEffectFromRow(row) {
     return {
@@ -363,13 +397,16 @@ export async function searchLocalIndex(projectRoot, query, options = {}) {
             throw new Error(`Local mustflow index is stale: ${stalePaths.join(', ')}. Run \`mf index\` before searching. Refresh command: mf index`);
         }
         if (scope === 'workflow' || scope === 'all') {
-            for (const row of queryCandidateRows(database, 'SELECT path, type, title, content_snippet FROM documents', 'path', indexedMatches.documents, indexedMatches)) {
+            const documentRows = queryCandidateRows(database, 'SELECT path, type, title, content_snippet FROM documents', 'path', indexedMatches.documents, indexedMatches);
+            const metadataByDocument = readDocumentSearchMetadata(database, documentRows.map((row) => toSearchString(row.path)));
+            for (const row of documentRows) {
                 const pathValue = toSearchString(row.path);
                 const typeValue = toSearchString(row.type);
                 const title = toSearchString(row.title);
                 const contentSnippet = toSearchString(row.content_snippet);
-                const sectionHeadings = getSectionHeadings(database, pathValue);
-                const documentTerms = getDocumentTerms(database, pathValue);
+                const metadata = metadataByDocument.get(pathValue) ?? createEmptyDocumentSearchMetadata();
+                const sectionHeadings = metadata.sectionHeadings;
+                const documentTerms = metadata.documentTerms;
                 const primaryFields = [pathValue, title];
                 const secondaryFields = [typeValue, contentSnippet, ...sectionHeadings, ...documentTerms];
                 const fields = [...primaryFields, ...secondaryFields];