mustflow 2.18.20 → 2.18.21

package/dist/cli/commands/verify.js

@@ -16,7 +16,7 @@ import { readCommandContract } from '../../core/config-loading.js';
 import { DEFAULT_VERIFY_PARALLELISM, parseVerifyArgs } from './verify/args.js';
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
 import { t } from '../lib/i18n.js';
-import { readLocalCommandEffectGraph, readLocalPathSurfaces, readLocalSourceAnchorVerdictRisks, } from '../lib/local-index.js';
+import { readLocalCommandEffectGraphs, readLocalPathSurfaces, readLocalSourceAnchorVerdictRisks, } from '../lib/local-index.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
 const VERIFY_SCHEMA_VERSION = '1';
 const RUN_STATE_DIR = path.join('.mustflow', 'state', 'runs');
@@ -578,6 +578,20 @@ function skippedResult(candidate) {
         receipt: null,
     };
 }
+function stoppedAfterFailedBatchResult(entry, verificationPlanId) {
+    return {
+        intent: entry.intent,
+        status: 'skipped',
+        skipped: true,
+        reason: 'stopped_after_failed_batch',
+        detail: 'Skipped because an earlier verification batch failed and the schedule failure policy stops before the next batch.',
+        exit_code: null,
+        verification_plan_id: verificationPlanId,
+        receipt_path: null,
+        receipt_sha256: null,
+        receipt: null,
+    };
+}
 function candidateResultKey(candidate) {
     return candidate.intent
         ? `intent:${candidate.intent}`
@@ -670,21 +684,40 @@ async function runVerificationEntriesInParallelChunks(entries, parallelism, lang
     }
     return results;
 }
+function verificationResultFailed(result) {
+    return (!result.skipped &&
+        (result.status === 'failed' ||
+            result.status === 'timed_out' ||
+            result.status === 'start_failed' ||
+            result.status === 'output_limit_exceeded'));
+}
 async function runScheduledVerificationIntents(report, lang, verificationPlanId, scheduledTestTargets, parallelism) {
-    if (parallelism <= DEFAULT_VERIFY_PARALLELISM) {
-        return runVerificationEntriesSequentially(report.schedule.entries, lang, verificationPlanId, scheduledTestTargets);
-    }
     const results = [];
-    for (const batch of report.schedule.batches) {
+    for (let batchIndex = 0; batchIndex < report.schedule.batches.length; batchIndex += 1) {
+        const batch = report.schedule.batches[batchIndex];
         const entries = entriesForScheduleBatch(report.schedule.entries, batch);
         if (entries.length === 0) {
             continue;
         }
+        let batchResults;
         if (entries.length > 1 && entries.every((entry) => entry.parallelEligible)) {
-            results.push(...(await runVerificationEntriesInParallelChunks(entries, parallelism, lang, verificationPlanId, scheduledTestTargets)));
+            batchResults =
+                parallelism > DEFAULT_VERIFY_PARALLELISM
+                    ? await runVerificationEntriesInParallelChunks(entries, parallelism, lang, verificationPlanId, scheduledTestTargets)
+                    : await runVerificationEntriesSequentially(entries, lang, verificationPlanId, scheduledTestTargets);
+        }
+        else {
+            batchResults = await runVerificationEntriesSequentially(entries, lang, verificationPlanId, scheduledTestTargets);
+        }
+        results.push(...batchResults);
+        if (!batchResults.some(verificationResultFailed)) {
             continue;
         }
-        results.push(...(await runVerificationEntriesSequentially(entries, lang, verificationPlanId, scheduledTestTargets)));
+        const remainingEntries = report.schedule.batches
+            .slice(batchIndex + 1)
+            .flatMap((remainingBatch) => entriesForScheduleBatch(report.schedule.entries, remainingBatch));
+        results.push(...remainingEntries.map((entry) => stoppedAfterFailedBatchResult(entry, verificationPlanId)));
+        break;
     }
     return results;
 }
@@ -1276,14 +1309,11 @@ async function createPlanOnlyOutput(input, projectRoot) {
     if (!firstEntry) {
         return { ...report, verification_plan_id: verificationPlanId, requirements };
     }
-    const firstGraph = await readLocalCommandEffectGraph(projectRoot, firstEntry.intent);
-    const graphsByIntent = new Map([[firstEntry.intent, firstGraph]]);
-    if (firstGraph.status === 'fresh') {
-        for (const entry of report.schedule.entries.slice(1)) {
-            if (!graphsByIntent.has(entry.intent)) {
-                graphsByIntent.set(entry.intent, await readLocalCommandEffectGraph(projectRoot, entry.intent));
-            }
-        }
+    const scheduledIntents = Array.from(new Set(report.schedule.entries.map((entry) => entry.intent)));
+    const graphsByIntent = await readLocalCommandEffectGraphs(projectRoot, scheduledIntents);
+    const firstGraph = graphsByIntent.get(firstEntry.intent);
+    if (!firstGraph) {
+        return { ...report, verification_plan_id: verificationPlanId, requirements };
     }
     return {
         ...report,

package/dist/cli/lib/git-changes.js

@@ -1,5 +1,7 @@
 import { spawnSync } from 'node:child_process';
 import { parseGitStatusOutput } from '../../core/change-classification.js';
+const GIT_STATUS_TIMEOUT_MS = 10_000;
+const GIT_STATUS_MAX_BUFFER_BYTES = 16 * 1024 * 1024;
 export class GitChangedFilesError extends Error {
     result;
     constructor(result) {
@@ -9,9 +11,13 @@ export class GitChangedFilesError extends Error {
     }
 }
 export function readGitChangedFiles(projectRoot) {
-    const result = spawnSync('git', ['status', '--short', '--untracked-files=all'], {
+    const result = spawnSync('git', ['status', '--porcelain=v1', '-z', '--untracked-files=all'], {
         cwd: projectRoot,
         encoding: 'utf8',
+        input: '',
+        maxBuffer: GIT_STATUS_MAX_BUFFER_BYTES,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout: GIT_STATUS_TIMEOUT_MS,
         windowsHide: true,
     });
     if (result.status !== 0 || typeof result.stdout !== 'string') {

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

@@ -331,16 +331,16 @@ function collectSourceAnchorCandidatePaths(projectRoot, sourceConfig) {
         excludeGeneratedOrVendor: true,
     });
 }
-function collectFastPreflightIndexedFileMetadataRecords(projectRoot, includeSource, sourceConfig) {
+function collectFastPreflightIndexedFileRecords(projectRoot, includeSource, sourceConfig) {
     const records = new Map();
     for (const relativePath of getExistingIndexablePaths(projectRoot)) {
-        records.set(relativePath, readIndexedFileMetadataRecord(projectRoot, relativePath, 'workflow'));
+        records.set(relativePath, readIndexedFileRecord(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'));
+                    records.set(sourcePath, readIndexedFileRecord(projectRoot, sourcePath, 'source_anchor'));
                 }
             }
         }
@@ -349,7 +349,7 @@ function collectFastPreflightIndexedFileMetadataRecords(projectRoot, includeSour
         }
     }
     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'));
+        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));
 }
@@ -2053,27 +2053,6 @@ function createStoredLocalIndexResult(projectRoot, databasePath, dryRun, indexMo
         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) {
@@ -2116,7 +2095,7 @@ async function readIncrementalPreflightReuse(SQL, databasePath, projectRoot, cur
         if (!hasTable(database, 'indexed_files')) {
             return { result: null, rebuildReason: 'indexed_files_missing' };
         }
-        if (!indexedFileMetadataMatch(database, currentFiles)) {
+        if (!indexedFilesMatch(database, currentFiles)) {
             return { result: null, rebuildReason: 'file_fingerprint_mismatch' };
         }
         const capabilities = readStoredSearchCapabilities(database);
@@ -2190,7 +2169,7 @@ export async function createLocalIndex(projectRoot, options = {}) {
     capabilities = detectLocalSearchCapabilities(capabilityDatabase);
     capabilityDatabase.close();
     if (incremental) {
-        const preflightFiles = collectFastPreflightIndexedFileMetadataRecords(projectRoot, includeSource, sourceConfig);
+        const preflightFiles = collectFastPreflightIndexedFileRecords(projectRoot, includeSource, sourceConfig);
         const preflightReuse = await readIncrementalPreflightReuse(SQL, databasePath, projectRoot, preflightFiles, sourceScopeHash, dryRun, indexMode);
         if (preflightReuse.result) {
             return preflightReuse.result;

package/dist/core/change-classification.js

@@ -46,14 +46,36 @@ function uniqueSorted(values) {
     return [...new Set(values)].sort((left, right) => left.localeCompare(right));
 }
 function toPosixPath(value) {
-    return value.trim().replaceAll('\\', '/');
+    return value.replaceAll('\\', '/');
 }
 export function normalizeStatusPath(value) {
-    const pathText = toPosixPath(value);
+    const pathText = toPosixPath(value.trim());
     const renameTarget = pathText.includes(' -> ') ? (pathText.split(' -> ').pop() ?? pathText) : pathText;
     return renameTarget.replace(/^"|"$/gu, '');
 }
+function normalizePorcelainStatusPath(value) {
+    return toPosixPath(value);
+}
+function parseGitPorcelainStatusOutput(output) {
+    const paths = [];
+    const parts = output.split('\0').filter((part) => part.length > 0);
+    for (let index = 0; index < parts.length; index += 1) {
+        const entry = parts[index] ?? '';
+        const status = entry.slice(0, 2);
+        const filePath = normalizePorcelainStatusPath(entry.slice(3));
+        if (filePath.length > 0) {
+            paths.push(filePath);
+        }
+        if (status.includes('R') || status.includes('C')) {
+            index += 1;
+        }
+    }
+    return uniqueSorted(paths);
+}
 export function parseGitStatusOutput(output) {
+    if (output.includes('\0')) {
+        return parseGitPorcelainStatusOutput(output);
+    }
     const paths = output
         .split(/\r?\n/u)
         .map((line) => line.slice(3))

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

@@ -125,6 +125,12 @@ export function commandIntentBlockedCommandPattern(intent) {
             detail: 'Shell command contains a blocked long-running or background pattern.',
         };
     }
+    if (intent.mode === 'shell' && typeof intent.cmd === 'string' && commandTextHasLongRunningPattern(intent.cmd)) {
+        return {
+            code: 'long_running_command_pattern',
+            detail: `Shell command contains a blocked long-running pattern: ${intent.cmd}.`,
+        };
+    }
     const argv = readStringArray(intent, 'argv');
     if (!argv) {
         return null;

package/dist/core/run-write-drift.js

@@ -130,6 +130,10 @@ function listObservedChangedPaths(before, after) {
 function declaredPathCoversObservedPath(declaredPath, observedPath) {
     const declaredKey = pathKey(declaredPath);
     const observedKey = pathKey(observedPath);
+    if (declaredKey.endsWith('/**')) {
+        const baseKey = declaredKey.slice(0, -3) || '.';
+        return baseKey === '.' || observedKey === baseKey || observedKey.startsWith(`${baseKey}/`);
+    }
     return declaredKey === '.' || observedKey === declaredKey || observedKey.startsWith(`${declaredKey}/`);
 }
 function truncatePaths(paths) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mustflow",
-  "version": "2.18.20",
+  "version": "2.18.21",
   "description": "Agent workflow documents and CLI for mustflow repository roots.",
   "type": "module",
   "license": "MIT-0",

package/templates/default/manifest.toml

@@ -1,6 +1,6 @@
 id = "default"
 name = "default"
-version = "2.18.20"
+version = "2.18.21"
 description = "Minimal workflow for LLM agents to read, edit, and verify their work in a repository."
 common_root = "common"
 locales_root = "locales"