mustflow 2.18.0 → 2.18.2

package/dist/cli/commands/verify.js

@@ -1,10 +1,11 @@
 import { createHash } from 'node:crypto';
-import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { createClassifyOutput } from './classify.js';
 import { runRun } from './run.js';
 import { createChangeVerificationReport, } from '../../core/change-verification.js';
 import { createVerifyCompletionVerdict, } from '../../core/completion-verdict.js';
+import { atomicWriteJsonFile, createStateRunId } from '../../core/atomic-state-write.js';
 import { createExternalEvidenceRisks, } from '../../core/external-evidence.js';
 import { createRepeatedFailureRisks, createVerificationFailureFingerprint, updateRepeatedFailureState, } from '../../core/repeated-failure.js';
 import { countReproEvidenceVerdictEffects, createReproEvidenceRisks, } from '../../core/repro-evidence.js';
@@ -17,9 +18,9 @@ import { t } from '../lib/i18n.js';
 import { readLocalCommandEffectGraph, readLocalPathSurfaces, readLocalSourceAnchorVerdictRisks, } from '../lib/local-index.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
 const VERIFY_SCHEMA_VERSION = '1';
-const VERIFY_RUN_DIR = path.join('.mustflow', 'state', 'runs', 'verify-latest');
-const VERIFY_MANIFEST_PATH = path.join(VERIFY_RUN_DIR, 'manifest.json');
-const LATEST_RUN_RECEIPT_PATH = path.join('.mustflow', 'state', 'runs', 'latest.json');
+const RUN_STATE_DIR = path.join('.mustflow', 'state', 'runs');
+const LATEST_RUN_RECEIPT_PATH = path.join(RUN_STATE_DIR, 'latest.json');
+const DEFAULT_VERIFY_PARALLELISM = 1;
 function createBufferedOutput() {
     const stdout = [];
     const stderr = [];
@@ -52,6 +53,7 @@ export function getVerifyHelp(lang = 'en') {
             { label: '--write-plan <path>', description: t(lang, 'verify.help.option.writePlan') },
             { label: '--repro-evidence <path>', description: t(lang, 'verify.help.option.reproEvidence') },
             { label: '--external-evidence <path>', description: t(lang, 'verify.help.option.externalEvidence') },
+            { label: '--parallel <count>', description: t(lang, 'verify.help.option.parallel') },
             { label: '--plan-only', description: t(lang, 'verify.help.option.planOnly') },
             { label: '--json', description: t(lang, 'cli.option.json') },
             { label: '-h, --help', description: t(lang, 'cli.option.help') },
@@ -81,6 +83,7 @@ function parseVerifyArgs(args) {
     let json = false;
     let planOnly = false;
     let changed = false;
+    let parallelism = DEFAULT_VERIFY_PARALLELISM;
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === '--json') {
@@ -95,6 +98,19 @@ function parseVerifyArgs(args) {
             changed = true;
             continue;
         }
+        if (arg === '--parallel') {
+            const value = args[index + 1];
+            if (!value || value.startsWith('-')) {
+                return { json, planOnly, changed, reason, parallelism, error: 'missing_parallel_value' };
+            }
+            const parsedParallelism = parseVerifyParallelism(value);
+            if (parsedParallelism === null) {
+                return { json, planOnly, changed, reason, parallelism, error: 'invalid_parallel_value' };
+            }
+            parallelism = parsedParallelism;
+            index += 1;
+            continue;
+        }
         if (arg === '--reason') {
             const value = args[index + 1];
             if (!value || value.startsWith('-')) {
@@ -195,6 +211,15 @@ function parseVerifyArgs(args) {
             reason = value;
             continue;
         }
+        if (arg.startsWith('--parallel=')) {
+            const value = arg.slice('--parallel='.length);
+            const parsedParallelism = parseVerifyParallelism(value);
+            if (parsedParallelism === null) {
+                return { json, planOnly, changed, reason, parallelism, error: 'invalid_parallel_value' };
+            }
+            parallelism = parsedParallelism;
+            continue;
+        }
         if (arg.startsWith('--from-plan=')) {
             const value = arg.slice('--from-plan='.length);
             if (value.length === 0) {
@@ -289,7 +314,25 @@ function parseVerifyArgs(args) {
             error: `unexpected:${arg}`,
         };
     }
-    return { json, planOnly, changed, reason, fromClassification, fromPlan, writePlan, reproEvidence, externalEvidence };
+    return {
+        json,
+        planOnly,
+        changed,
+        reason,
+        fromClassification,
+        fromPlan,
+        writePlan,
+        reproEvidence,
+        externalEvidence,
+        parallelism,
+    };
+}
+function parseVerifyParallelism(value) {
+    if (!/^[1-9][0-9]*$/u.test(value)) {
+        return null;
+    }
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) ? parsed : null;
 }
 function uniqueStrings(values) {
     return [...new Set(values.map((value) => value.trim()).filter((value) => value.length > 0))];
@@ -297,6 +340,18 @@ function uniqueStrings(values) {
 function toPosixPath(value) {
     return value.split(path.sep).join('/');
 }
+function createVerifyRunStatePaths(projectRoot) {
+    const runDir = toPosixPath(path.join(RUN_STATE_DIR, createStateRunId('verify')));
+    const manifestPath = toPosixPath(path.join(runDir, 'manifest.json'));
+    const absoluteRunDir = path.join(projectRoot, runDir);
+    return {
+        runDir,
+        manifestPath,
+        absoluteRunDir,
+        absoluteIntentDir: path.join(absoluteRunDir, 'intents'),
+        absoluteManifestPath: path.join(projectRoot, manifestPath),
+    };
+}
 function sanitizeIntentFilePart(value) {
     const sanitized = value.replace(/[^A-Za-z0-9._-]+/g, '_').replace(/^_+|_+$/g, '');
     return sanitized.length > 0 ? sanitized.slice(0, 80) : 'intent';
@@ -445,7 +500,7 @@ function resolvePlanPath(projectRoot, inputPath) {
     }
     return resolved;
 }
-export function readInputFromPlan(projectRoot, inputPath) {
+export function readInputFromClassificationReport(projectRoot, inputPath) {
     let parsed;
     const planPath = resolvePlanPath(projectRoot, inputPath);
     try {
@@ -836,7 +891,8 @@ async function runVerificationIntent(intent, lang, verificationPlanId, testTarge
         if (receiptStatus === 'passed' ||
             receiptStatus === 'failed' ||
             receiptStatus === 'timed_out' ||
-            receiptStatus === 'start_failed') {
+            receiptStatus === 'start_failed' ||
+            receiptStatus === 'output_limit_exceeded') {
             status = receiptStatus;
         }
     }
@@ -856,12 +912,52 @@ async function runVerificationIntent(intent, lang, verificationPlanId, testTarge
         receipt,
     };
 }
+function entriesForScheduleBatch(entries, batch) {
+    const batchIntents = new Set(batch.intents);
+    return entries.filter((entry) => batchIntents.has(entry.intent));
+}
+async function runVerificationEntriesSequentially(entries, lang, verificationPlanId, scheduledTestTargets) {
+    const results = [];
+    for (const entry of entries) {
+        results.push(await runVerificationIntent(entry.intent, lang, verificationPlanId, scheduledTestTargets.get(entry.intent) ?? []));
+    }
+    return results;
+}
+async function runVerificationEntriesInParallelChunks(entries, parallelism, lang, verificationPlanId, scheduledTestTargets) {
+    const results = [];
+    for (let index = 0; index < entries.length; index += parallelism) {
+        const chunk = entries.slice(index, index + parallelism);
+        results.push(...(await Promise.all(chunk.map((entry) => runVerificationIntent(entry.intent, lang, verificationPlanId, scheduledTestTargets.get(entry.intent) ?? [])))));
+    }
+    return results;
+}
+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) {
+        const entries = entriesForScheduleBatch(report.schedule.entries, batch);
+        if (entries.length === 0) {
+            continue;
+        }
+        if (entries.length > 1 && entries.every((entry) => entry.parallelEligible)) {
+            results.push(...(await runVerificationEntriesInParallelChunks(entries, parallelism, lang, verificationPlanId, scheduledTestTargets)));
+            continue;
+        }
+        results.push(...(await runVerificationEntriesSequentially(entries, lang, verificationPlanId, scheduledTestTargets)));
+    }
+    return results;
+}
 function summarizeResults(results) {
     const ran = results.filter((result) => !result.skipped).length;
     const passed = results.filter((result) => result.status === 'passed').length;
     const skipped = results.filter((result) => result.skipped).length;
     const failed = results.filter((result) => !result.skipped &&
-        (result.status === 'failed' || result.status === 'timed_out' || result.status === 'start_failed')).length;
+        (result.status === 'failed' ||
+            result.status === 'timed_out' ||
+            result.status === 'start_failed' ||
+            result.status === 'output_limit_exceeded')).length;
     return {
         matched: results.filter((result) => result.intent !== null).length,
         ran,
@@ -910,11 +1006,15 @@ function timedOutForResult(result) {
     return result.status === 'timed_out' || resultSummary?.timed_out === true;
 }
 function errorKindForResult(result) {
-    return stringField(resultSummaryForResult(result)?.error_kind) ?? (result.status === 'start_failed' ? 'start_failed' : null);
+    return (stringField(resultSummaryForResult(result)?.error_kind) ??
+        (result.status === 'start_failed' || result.status === 'output_limit_exceeded' ? result.status : null));
 }
 function failedResults(results) {
     return results.filter((result) => !result.skipped &&
-        (result.status === 'failed' || result.status === 'timed_out' || result.status === 'start_failed'));
+        (result.status === 'failed' ||
+            result.status === 'timed_out' ||
+            result.status === 'start_failed' ||
+            result.status === 'output_limit_exceeded'));
 }
 function createFailureFingerprintForVerify(input) {
     const failures = failedResults(input.results);
@@ -1026,7 +1126,10 @@ function createCriteriaEvidence(report, results) {
             .filter((intent) => intent !== null);
         const gapCount = report.gaps.filter((gap) => gap.reason === requirement.reason).length;
         const selectedResults = selectedIntents.map((intent) => resultForSelectedIntent(results, intent));
-        if (selectedResults.some((result) => result?.status === 'failed' || result?.status === 'timed_out' || result?.status === 'start_failed')) {
+        if (selectedResults.some((result) => result?.status === 'failed' ||
+            result?.status === 'timed_out' ||
+            result?.status === 'start_failed' ||
+            result?.status === 'output_limit_exceeded')) {
             return { ...current, contradicted: current.contradicted + 1 };
         }
         if (gapCount > 0 || (selectedIntents.length === 0 && skippedIntents.length > 0)) {
@@ -1181,20 +1284,18 @@ function createVerificationPlanId(report, contract) {
     return hashTextSha256(stableJson(fingerprintSource));
 }
 function writeVerifyRunReceipts(projectRoot, output, report, sourceAnchorRisks, scopeDiffRisks, validationRatchetRisks, reproEvidence, externalChecks) {
-    const runDir = path.join(projectRoot, VERIFY_RUN_DIR);
-    const intentDir = path.join(runDir, 'intents');
+    const statePaths = createVerifyRunStatePaths(projectRoot);
     const receipts = [];
     const results = [];
-    rmSync(runDir, { recursive: true, force: true });
-    mkdirSync(intentDir, { recursive: true });
+    mkdirSync(statePaths.absoluteIntentDir, { recursive: true });
     for (const [index, result] of output.results.entries()) {
         let receiptPath = null;
         let receiptSha256 = null;
         let receipt = result.receipt;
         if (result.intent && result.receipt) {
             const fileName = `${String(index + 1).padStart(3, '0')}-${sanitizeIntentFilePart(result.intent)}.json`;
-            const absoluteReceiptPath = path.join(intentDir, fileName);
-            receiptPath = toPosixPath(path.join(VERIFY_RUN_DIR, 'intents', fileName));
+            const absoluteReceiptPath = path.join(statePaths.absoluteIntentDir, fileName);
+            receiptPath = toPosixPath(path.join(statePaths.runDir, 'intents', fileName));
             receipt = {
                 ...result.receipt,
                 verification_plan_id: output.verification_plan_id,
@@ -1202,7 +1303,7 @@ function writeVerifyRunReceipts(projectRoot, output, report, sourceAnchorRisks,
             };
             const receiptContent = `${JSON.stringify(receipt, null, 2)}\n`;
             receiptSha256 = hashTextSha256(receiptContent);
-            writeFileSync(absoluteReceiptPath, receiptContent, 'utf8');
+            atomicWriteJsonFile(absoluteReceiptPath, receipt);
         }
         receipts.push({
             intent: result.intent,
@@ -1272,6 +1373,8 @@ function writeVerifyRunReceipts(projectRoot, output, report, sourceAnchorRisks,
         completion_verdict: completionVerdict,
         failure_fingerprint: failureFingerprint,
         repeated_failure_summary: repeatedFailureSummary,
+        run_dir: statePaths.runDir,
+        manifest_path: statePaths.manifestPath,
         results,
         evidence_model: createVerifyEvidenceModel({
             report,
@@ -1306,7 +1409,7 @@ function writeVerifyRunReceipts(projectRoot, output, report, sourceAnchorRisks,
         ...(outputWithReceiptPaths.external_checks ? { external_checks: outputWithReceiptPaths.external_checks } : {}),
         receipts,
     };
-    writeFileSync(path.join(runDir, 'manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    atomicWriteJsonFile(statePaths.absoluteManifestPath, manifest);
     const latest = {
         schema_version: '1',
         command: 'verify',
@@ -1324,13 +1427,13 @@ function writeVerifyRunReceipts(projectRoot, output, report, sourceAnchorRisks,
         summary: outputWithReceiptPaths.summary,
         ...(outputWithReceiptPaths.repro_evidence ? { repro_evidence: outputWithReceiptPaths.repro_evidence } : {}),
         ...(outputWithReceiptPaths.external_checks ? { external_checks: outputWithReceiptPaths.external_checks } : {}),
-        run_dir: toPosixPath(VERIFY_RUN_DIR),
-        manifest_path: toPosixPath(VERIFY_MANIFEST_PATH),
+        run_dir: statePaths.runDir,
+        manifest_path: statePaths.manifestPath,
     };
-    writeFileSync(path.join(projectRoot, LATEST_RUN_RECEIPT_PATH), `${JSON.stringify(latest, null, 2)}\n`, 'utf8');
+    atomicWriteJsonFile(path.join(projectRoot, LATEST_RUN_RECEIPT_PATH), latest);
     return outputWithReceiptPaths;
 }
-async function createVerifyOutput(input, planSource, projectRoot, lang, reproEvidence = null, externalChecks = []) {
+async function createVerifyOutput(input, planSource, projectRoot, lang, reproEvidence = null, externalChecks = [], parallelism = DEFAULT_VERIFY_PARALLELISM) {
     const contract = readCommandContract(projectRoot);
     const report = createChangeVerificationReport(input.classificationReport, contract, projectRoot);
     const verificationPlanId = createVerificationPlanId(report, contract);
@@ -1343,10 +1446,7 @@ async function createVerifyOutput(input, planSource, projectRoot, lang, reproEvi
     const reproEvidenceRisks = createReproEvidenceRisks(reproEvidence, { verificationPlanId });
     const reproEvidenceVerdictEffects = countReproEvidenceVerdictEffects(reproEvidenceRisks);
     const externalEvidenceRisks = createExternalEvidenceRisks(externalChecks);
-    const results = [];
-    for (const entry of report.schedule.entries) {
-        results.push(await runVerificationIntent(entry.intent, lang, verificationPlanId, scheduledTestTargets.get(entry.intent) ?? []));
-    }
+    const results = await runScheduledVerificationIntents(report, lang, verificationPlanId, scheduledTestTargets, parallelism);
     results.push(...createSkippedResults(report.candidates, scheduledIntents, report.gaps));
     const summary = summarizeResults(results);
     const status = getVerificationStatus(summary);
@@ -1416,8 +1516,8 @@ async function createVerifyOutput(input, planSource, projectRoot, lang, reproEvi
         summary,
         ...(reproEvidence ? { repro_evidence: reproEvidence } : {}),
         ...(externalChecks.length > 0 ? { external_checks: externalChecks } : {}),
-        run_dir: toPosixPath(VERIFY_RUN_DIR),
-        manifest_path: toPosixPath(VERIFY_MANIFEST_PATH),
+        run_dir: '',
+        manifest_path: '',
         results,
     };
     return writeVerifyRunReceipts(projectRoot, output, report, sourceAnchorRisks, scopeDiffRisks, validationRatchetRisks, reproEvidence, externalChecks);
@@ -1491,19 +1591,23 @@ export async function runVerify(args, reporter, lang = 'en') {
     if (parsed.error) {
         const message = parsed.error === 'missing_reason_value'
             ? t(lang, 'cli.error.missingValue', { option: '--reason' })
-            : parsed.error === 'missing_from_classification_value'
-                ? t(lang, 'cli.error.missingValue', { option: '--from-classification' })
-                : parsed.error === 'missing_from_plan_value'
-                    ? t(lang, 'cli.error.missingValue', { option: '--from-plan' })
-                    : parsed.error === 'missing_write_plan_value'
-                        ? t(lang, 'cli.error.missingValue', { option: '--write-plan' })
-                        : parsed.error === 'missing_repro_evidence_value'
-                            ? t(lang, 'cli.error.missingValue', { option: '--repro-evidence' })
-                            : parsed.error === 'missing_external_evidence_value'
-                                ? t(lang, 'cli.error.missingValue', { option: '--external-evidence' })
-                                : parsed.error.startsWith('unexpected:')
-                                    ? t(lang, 'cli.error.unexpectedArgument', { argument: parsed.error.slice('unexpected:'.length) })
-                                    : t(lang, 'cli.error.unknownOption', { option: parsed.error });
+            : parsed.error === 'missing_parallel_value'
+                ? t(lang, 'cli.error.missingValue', { option: '--parallel' })
+                : parsed.error === 'invalid_parallel_value'
+                    ? t(lang, 'verify.error.invalidParallel')
+                    : parsed.error === 'missing_from_classification_value'
+                        ? t(lang, 'cli.error.missingValue', { option: '--from-classification' })
+                        : parsed.error === 'missing_from_plan_value'
+                            ? t(lang, 'cli.error.missingValue', { option: '--from-plan' })
+                            : parsed.error === 'missing_write_plan_value'
+                                ? t(lang, 'cli.error.missingValue', { option: '--write-plan' })
+                                : parsed.error === 'missing_repro_evidence_value'
+                                    ? t(lang, 'cli.error.missingValue', { option: '--repro-evidence' })
+                                    : parsed.error === 'missing_external_evidence_value'
+                                        ? t(lang, 'cli.error.missingValue', { option: '--external-evidence' })
+                                        : parsed.error.startsWith('unexpected:')
+                                            ? t(lang, 'cli.error.unexpectedArgument', { argument: parsed.error.slice('unexpected:'.length) })
+                                            : t(lang, 'cli.error.unknownOption', { option: parsed.error });
         printUsageError(reporter, message, 'mf verify --help', getVerifyHelp(lang), lang);
         return 1;
     }
@@ -1552,7 +1656,7 @@ export async function runVerify(args, reporter, lang = 'en') {
             changedPlan = changedInput.plan;
         }
         else if (parsed.fromClassification || parsed.fromPlan) {
-            input = readInputFromPlan(projectRoot, (parsed.fromClassification ?? parsed.fromPlan));
+            input = readInputFromClassificationReport(projectRoot, (parsed.fromClassification ?? parsed.fromPlan));
         }
         else {
             input = {
@@ -1588,7 +1692,7 @@ export async function runVerify(args, reporter, lang = 'en') {
         reporter.stdout(JSON.stringify(await createPlanOnlyOutput(input, projectRoot), null, 2));
         return 0;
     }
-    const output = await createVerifyOutput(input, parsed.fromClassification ?? parsed.fromPlan ?? (parsed.changed ? 'changed' : null), projectRoot, lang, reproEvidence, externalChecks);
+    const output = await createVerifyOutput(input, parsed.fromClassification ?? parsed.fromPlan ?? (parsed.changed ? 'changed' : null), projectRoot, lang, reproEvidence, externalChecks, parsed.parallelism ?? DEFAULT_VERIFY_PARALLELISM);
     if (parsed.json) {
         reporter.stdout(JSON.stringify(output, null, 2));
     }

package/dist/cli/i18n/en.js

@@ -750,11 +750,12 @@ Read these files before working:
     "verify.help.summary": "Run configured verification intents selected by required_after metadata.",
     "verify.help.option.reason": "Select the required_after reason to verify",
     "verify.help.option.fromClassification": "Read verification reasons from an mf classify report inside this repository",
-    "verify.help.option.fromPlan": "Compatibility alias for --from-classification",
+    "verify.help.option.fromPlan": "Deprecated compatibility alias for --from-classification; it still expects an mf classify report",
     "verify.help.option.changed": "Classify current Git changes and verify the matching reasons",
     "verify.help.option.writePlan": "Compatibility option that writes the changed-file classification report",
     "verify.help.option.reproEvidence": "Read structured bug-fix reproduction evidence from a repository-local JSON summary",
     "verify.help.option.externalEvidence": "Read lower-authority external CI evidence from a repository-local JSON summary",
+    "verify.help.option.parallel": "Run safe non-conflicting schedule batches with up to this many commands; default is 1",
     "verify.help.option.planOnly": "Print the verification plan without running commands; requires --json",
     "verify.help.exit.ok": "All selected verification intents passed",
     "verify.help.exit.fail": "Verification failed, was partial, was blocked, or input was invalid",
@@ -769,6 +770,7 @@ Read these files before working:
     "verify.error.planOnlyJson": "--plan-only requires --json",
     "verify.error.reproEvidenceRequiresRun": "--repro-evidence cannot be used with --plan-only",
     "verify.error.externalEvidenceRequiresRun": "--external-evidence cannot be used with --plan-only",
+    "verify.error.invalidParallel": "--parallel must be a positive integer",
     "verify.error.invalid_plan_file": "Classification report must be a readable JSON file",
     "verify.error.unsupported_plan_source": "Verification input must be an mf classify report",
     "verify.error.plan_root_mismatch": "Classification report must come from this mustflow root",

package/dist/cli/i18n/es.js

@@ -750,11 +750,12 @@ Lee estos archivos antes de trabajar:
     "verify.help.summary": "Ejecuta intenciones de verificación configuradas seleccionadas por metadatos required_after.",
     "verify.help.option.reason": "Selecciona la razón required_after que se debe verificar",
     "verify.help.option.fromClassification": "Lee razones de verificación desde un informe de mf classify dentro de este repositorio",
-    "verify.help.option.fromPlan": "Alias de compatibilidad para --from-classification",
+    "verify.help.option.fromPlan": "Alias de compatibilidad obsoleto para --from-classification; todavía espera un informe de mf classify",
     "verify.help.option.changed": "Clasifica los cambios actuales de Git y verifica las razones correspondientes",
     "verify.help.option.writePlan": "Opción de compatibilidad que escribe el informe de clasificación de cambios",
     "verify.help.option.reproEvidence": "Lee evidencia estructurada de reproducción de errores desde un resumen JSON local del repositorio",
     "verify.help.option.externalEvidence": "Lee evidencia de CI externa de menor autoridad desde un resumen JSON local del repositorio",
+    "verify.help.option.parallel": "Ejecuta lotes programados seguros y sin conflictos con hasta esta cantidad de comandos; el valor predeterminado es 1",
     "verify.help.option.planOnly": "Imprime el plan de verificación sin ejecutar comandos; requiere --json",
     "verify.help.exit.ok": "Todas las intenciones de verificación seleccionadas pasaron",
     "verify.help.exit.fail": "La verificación falló, fue parcial, quedó bloqueada o la entrada no fue válida",
@@ -769,6 +770,7 @@ Lee estos archivos antes de trabajar:
     "verify.error.planOnlyJson": "--plan-only requiere --json",
     "verify.error.reproEvidenceRequiresRun": "--repro-evidence no se puede usar con --plan-only",
     "verify.error.externalEvidenceRequiresRun": "--external-evidence no se puede usar con --plan-only",
+    "verify.error.invalidParallel": "--parallel debe ser un entero positivo",
     "verify.error.invalid_plan_file": "El informe de clasificación debe ser un archivo JSON legible",
     "verify.error.unsupported_plan_source": "La entrada de verificación debe ser un informe de mf classify",
     "verify.error.plan_root_mismatch": "El informe de clasificación debe provenir de esta raíz mustflow",

package/dist/cli/i18n/fr.js

@@ -750,11 +750,12 @@ Lisez ces fichiers avant de travailler :
     "verify.help.summary": "Exécute les intentions de vérification configurées sélectionnées par les métadonnées required_after.",
     "verify.help.option.reason": "Sélectionne la raison required_after à vérifier",
     "verify.help.option.fromClassification": "Lit les raisons de vérification depuis un rapport mf classify dans ce dépôt",
-    "verify.help.option.fromPlan": "Alias de compatibilité pour --from-classification",
+    "verify.help.option.fromPlan": "Alias de compatibilité obsolète pour --from-classification; il attend toujours un rapport mf classify",
     "verify.help.option.changed": "Classe les changements Git actuels et vérifie les raisons correspondantes",
     "verify.help.option.writePlan": "Option de compatibilité qui écrit le rapport de classification des changements",
     "verify.help.option.reproEvidence": "Lit une preuve structurée de reproduction de bogue depuis un résumé JSON local au dépôt",
     "verify.help.option.externalEvidence": "Lit une preuve CI externe de moindre autorité depuis un résumé JSON local au dépôt",
+    "verify.help.option.parallel": "Exécute les lots planifiés sûrs et sans conflit avec au plus ce nombre de commandes ; valeur par défaut : 1",
     "verify.help.option.planOnly": "Affiche le plan de vérification sans exécuter de commandes; nécessite --json",
     "verify.help.exit.ok": "Toutes les intentions de vérification sélectionnées ont réussi",
     "verify.help.exit.fail": "La vérification a échoué, est partielle, est bloquée ou l'entrée est invalide",
@@ -769,6 +770,7 @@ Lisez ces fichiers avant de travailler :
     "verify.error.planOnlyJson": "--plan-only nécessite --json",
     "verify.error.reproEvidenceRequiresRun": "--repro-evidence ne peut pas être utilisé avec --plan-only",
     "verify.error.externalEvidenceRequiresRun": "--external-evidence ne peut pas être utilisé avec --plan-only",
+    "verify.error.invalidParallel": "--parallel doit être un entier positif",
     "verify.error.invalid_plan_file": "Le rapport de classification doit être un fichier JSON lisible",
     "verify.error.unsupported_plan_source": "L'entrée de vérification doit être un rapport mf classify",
     "verify.error.plan_root_mismatch": "Le rapport de classification doit venir de cette racine mustflow",

package/dist/cli/i18n/hi.js

@@ -750,11 +750,12 @@ export const hiMessages = {
     "verify.help.summary": "required_after metadata से चुने गए configured verification intents चलाएँ।",
     "verify.help.option.reason": "Verify करने के लिए required_after reason चुनें",
     "verify.help.option.fromClassification": "इस repository के अंदर mf classify report से verification reasons पढ़ें",
-    "verify.help.option.fromPlan": "--from-classification का compatibility alias",
+    "verify.help.option.fromPlan": "--from-classification का deprecated compatibility alias; input अब भी mf classify report होना चाहिए",
     "verify.help.option.changed": "Current Git changes classify करके matching reasons verify करें",
     "verify.help.option.writePlan": "Changed-file classification report लिखने वाला compatibility option",
     "verify.help.option.reproEvidence": "Repository-local JSON summary से structured bug reproduction evidence पढ़ें",
     "verify.help.option.externalEvidence": "Repository-local JSON summary से lower-authority external CI evidence पढ़ें",
+    "verify.help.option.parallel": "Safe और non-conflicting schedule batches को इतने commands तक साथ चलाएं; default 1 है",
     "verify.help.option.planOnly": "Commands चलाए बिना verification plan print करें; --json चाहिए",
     "verify.help.exit.ok": "सभी selected verification intents pass हुए",
     "verify.help.exit.fail": "Verification fail हुआ, partial रहा, blocked रहा, या input invalid था",
@@ -769,6 +770,7 @@ export const hiMessages = {
     "verify.error.planOnlyJson": "--plan-only के लिए --json चाहिए",
     "verify.error.reproEvidenceRequiresRun": "--repro-evidence को --plan-only के साथ इस्तेमाल नहीं किया जा सकता",
     "verify.error.externalEvidenceRequiresRun": "--external-evidence को --plan-only के साथ इस्तेमाल नहीं किया जा सकता",
+    "verify.error.invalidParallel": "--parallel positive integer होना चाहिए",
     "verify.error.invalid_plan_file": "Classification report readable JSON file होना चाहिए",
     "verify.error.unsupported_plan_source": "Verification input mf classify report होना चाहिए",
     "verify.error.plan_root_mismatch": "Classification report इसी mustflow root से आना चाहिए",

package/dist/cli/i18n/ko.js

@@ -750,11 +750,12 @@ export const koMessages = {
     "verify.help.summary": "required_after 메타데이터로 선택된 설정된 검증 의도를 실행합니다.",
     "verify.help.option.reason": "검증할 required_after 이유를 지정합니다",
     "verify.help.option.fromClassification": "이 저장소 안의 mf classify 보고서에서 검증 이유를 읽습니다",
-    "verify.help.option.fromPlan": "--from-classification과 같은 호환 옵션입니다",
+    "verify.help.option.fromPlan": "--from-classification과 같은 폐기 예정 호환 옵션입니다. 입력은 여전히 mf classify 보고서여야 합니다",
     "verify.help.option.changed": "현재 Git 변경을 분류하고 맞는 검증 이유를 실행합니다",
     "verify.help.option.writePlan": "변경 파일 분류 보고서를 쓰는 호환 옵션입니다",
     "verify.help.option.reproEvidence": "저장소 안의 JSON 요약에서 구조화된 버그 재현 증거를 읽습니다",
     "verify.help.option.externalEvidence": "저장소 안의 JSON 요약에서 낮은 권한의 외부 CI 증거를 읽습니다",
+    "verify.help.option.parallel": "안전하고 서로 충돌하지 않는 예정 실행 묶음을 이 개수까지 함께 실행합니다. 기본값은 1입니다",
     "verify.help.option.planOnly": "명령을 실행하지 않고 검증 계획만 출력합니다. --json이 필요합니다",
     "verify.help.exit.ok": "선택된 모든 검증 의도가 통과했습니다",
     "verify.help.exit.fail": "검증이 실패했거나, 일부만 실행됐거나, 막혔거나, 입력이 올바르지 않습니다",
@@ -769,6 +770,7 @@ export const koMessages = {
     "verify.error.planOnlyJson": "--plan-only에는 --json이 필요합니다",
     "verify.error.reproEvidenceRequiresRun": "--repro-evidence는 --plan-only와 함께 사용할 수 없습니다",
     "verify.error.externalEvidenceRequiresRun": "--external-evidence는 --plan-only와 함께 사용할 수 없습니다",
+    "verify.error.invalidParallel": "--parallel 값은 양의 정수여야 합니다",
     "verify.error.invalid_plan_file": "분류 보고서는 읽을 수 있는 JSON 파일이어야 합니다",
     "verify.error.unsupported_plan_source": "검증 입력은 mf classify 보고서여야 합니다",
     "verify.error.plan_root_mismatch": "분류 보고서는 현재 mustflow 루트에서 나온 것이어야 합니다",

package/dist/cli/i18n/zh.js

@@ -750,11 +750,12 @@ export const zhMessages = {
     "verify.help.summary": "运行由 required_after 元数据选出的已配置验证意图。",
     "verify.help.option.reason": "选择要验证的 required_after 原因",
     "verify.help.option.fromClassification": "从此仓库内的 mf classify 报告读取验证原因",
-    "verify.help.option.fromPlan": "--from-classification 的兼容别名",
+    "verify.help.option.fromPlan": "--from-classification 的已弃用兼容别名；输入仍必须是 mf classify 报告",
     "verify.help.option.changed": "分类当前 Git 变更并验证匹配的原因",
     "verify.help.option.writePlan": "写入变更文件分类报告的兼容选项",
     "verify.help.option.reproEvidence": "从仓库本地 JSON 摘要读取结构化的 bug 复现证据",
     "verify.help.option.externalEvidence": "从仓库本地 JSON 摘要读取低权限外部 CI 证据",
+    "verify.help.option.parallel": "最多并行执行这个数量的安全、无冲突计划批次命令；默认值为 1",
     "verify.help.option.planOnly": "仅输出验证计划，不执行命令；需要 --json",
     "verify.help.exit.ok": "选中的所有验证意图均已通过",
     "verify.help.exit.fail": "验证失败、部分完成、被阻止，或输入无效",
@@ -769,6 +770,7 @@ export const zhMessages = {
     "verify.error.planOnlyJson": "--plan-only 需要 --json",
     "verify.error.reproEvidenceRequiresRun": "--repro-evidence 不能与 --plan-only 一起使用",
     "verify.error.externalEvidenceRequiresRun": "--external-evidence 不能与 --plan-only 一起使用",
+    "verify.error.invalidParallel": "--parallel 必须是正整数",
     "verify.error.invalid_plan_file": "分类报告必须是可读取的 JSON 文件",
     "verify.error.unsupported_plan_source": "验证输入必须是 mf classify 报告",
     "verify.error.plan_root_mismatch": "分类报告必须来自当前 mustflow 根目录",

package/dist/cli/lib/repo-map.js

@@ -11,6 +11,8 @@ const REPO_MAP_GENERATOR = 'mustflow';
 const REPO_MAP_RELATIVE_ROOT = '.';
 const REPO_MAP_SOURCE_POLICY = 'anchors_only';
 const REPO_MAP_PRIVACY_MODE = 'minimal';
+const GIT_LS_FILES_TIMEOUT_MS = 5_000;
+const GIT_LS_FILES_MAX_BUFFER_BYTES = 1_048_576;
 const EXCLUDED_SEGMENTS = new Set([
     '.astro',
     '.cache',
@@ -240,10 +242,15 @@ function getRepoMapConfig(projectRoot) {
         },
     };
 }
-function getGitFiles(projectRoot) {
-    const result = spawnSync('git', ['ls-files', '-z'], {
+export function listGitFilesForRepoMap(projectRoot, options = {}) {
+    const spawnGit = options.spawnGit ??
+        ((command, args, spawnOptions) => spawnSync(command, [...args], spawnOptions));
+    const result = spawnGit('git', ['ls-files', '-z'], {
         cwd: projectRoot,
         encoding: 'utf8',
+        maxBuffer: options.maxBuffer ?? GIT_LS_FILES_MAX_BUFFER_BYTES,
+        timeout: options.timeout ?? GIT_LS_FILES_TIMEOUT_MS,
+        windowsHide: true,
     });
     if (result.status !== 0 || result.error) {
         return [];
@@ -282,7 +289,7 @@ function listAnchorCandidateFilesRecursive(rootPath, depth, priorityPaths) {
 }
 function getRepositoryFiles(projectRoot, depth, priorityPaths) {
     const files = new Set();
-    for (const relativePath of getGitFiles(projectRoot)) {
+    for (const relativePath of listGitFilesForRepoMap(projectRoot)) {
         files.add(relativePath);
     }
     for (const relativePath of listAnchorCandidateFilesRecursive(projectRoot, depth, priorityPaths)) {

package/dist/core/atomic-state-write.js

@@ -0,0 +1,31 @@
+import { randomBytes } from 'node:crypto';
+import { mkdirSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+function tempFilePath(targetPath) {
+    const suffix = `${process.pid}-${Date.now()}-${randomBytes(6).toString('hex')}`;
+    return path.join(path.dirname(targetPath), `.${path.basename(targetPath)}.${suffix}.tmp`);
+}
+export function createStateRunId(prefix) {
+    const timestamp = new Date().toISOString().replaceAll(/[:.]/g, '-');
+    return `${prefix}-${timestamp}-${process.pid}-${randomBytes(6).toString('hex')}`;
+}
+export function atomicWriteTextFile(targetPath, content) {
+    mkdirSync(path.dirname(targetPath), { recursive: true });
+    const temporaryPath = tempFilePath(targetPath);
+    try {
+        writeFileSync(temporaryPath, content, { encoding: 'utf8', flag: 'wx' });
+        renameSync(temporaryPath, targetPath);
+    }
+    catch (error) {
+        try {
+            unlinkSync(temporaryPath);
+        }
+        catch {
+            // Best-effort cleanup for a temporary file that may not have been created.
+        }
+        throw error;
+    }
+}
+export function atomicWriteJsonFile(targetPath, value) {
+    atomicWriteTextFile(targetPath, `${JSON.stringify(value, null, 2)}\n`);
+}

package/dist/core/bounded-output.js

@@ -1,3 +1,24 @@
+function isUtf8ContinuationByte(value) {
+    return value !== undefined && (value & 0xc0) === 0x80;
+}
+function findUtf8TailStart(buffer, startOffset) {
+    let start = Math.min(buffer.byteLength, Math.max(0, Math.trunc(startOffset)));
+    while (start < buffer.byteLength && isUtf8ContinuationByte(buffer[start])) {
+        start += 1;
+    }
+    return start;
+}
+export function decodeUtf8Tail(buffer, maxTailBytes) {
+    if (maxTailBytes <= 0) {
+        return { text: '', truncated: buffer.byteLength > 0 };
+    }
+    const rawStart = buffer.byteLength > maxTailBytes ? buffer.byteLength - maxTailBytes : 0;
+    const start = findUtf8TailStart(buffer, rawStart);
+    return {
+        text: buffer.subarray(start).toString('utf8'),
+        truncated: buffer.byteLength > maxTailBytes || start > 0,
+    };
+}
 export class BoundedOutputBuffer {
     #maxTailBytes;
     #chunks = [];
@@ -30,9 +51,10 @@ export class BoundedOutputBuffer {
         }
     }
     toSnapshot() {
+        const tail = decodeUtf8Tail(Buffer.concat(this.#chunks, this.#tailBytes), this.#maxTailBytes);
         return {
             bytes: this.#bytes,
-            tail: Buffer.concat(this.#chunks, this.#tailBytes).toString('utf8'),
+            tail: tail.text,
         };
     }
 }

package/dist/core/check-issues.js

@@ -14,6 +14,7 @@ const CHECK_ISSUE_ID_RULES = [
     ['mustflow.command_contract.effects_invalid', /^(?:Strict: )?(?:\[commands\.(?:resources|intents\.[^\]]+\.effects)[^\]]*\]|Command effect for intent [^\s]+ must define path, paths, or lock)/u],
     ['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.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],