mustflow 2.70.0 → 2.74.1

package/README.md

@@ -123,8 +123,16 @@ mustflow installs and validates an agent workflow for user projects.
 - Reports host adapter compatibility with `mf adapters status` without generating host-specific files or treating them as command authority.
 - Classifies changed files, public surfaces, and validation reasons with `mf classify`.
 - Inspects changed files for quality-gaming patterns such as line stuffing, suppressions, test bypass markers, type escapes, and placeholder implementations with `mf quality check`.
-- Prints execution-free verification plans with `mf verify --plan-only --json`, including a machine-readable verification decision graph and read-only local-index lock explanations when available.
+- Prints execution-free verification plans with `mf verify --plan-only --json`, including a risk-priced evidence assessment, machine-readable verification decision graph, and read-only local-index lock explanations when available.
+- Reports a read-only complexity budget in `mf api diff-risk --changed --json`, `mf verify`
+  evidence, and dashboard exports so agents justify new dependencies, helper-style surfaces,
+  config/schema churn, and broad structural changes before treating added complexity as free.
+- Lists and runs bundled utility scripts through `mf script-pack`, including `core/text-budget` for
+  exact file and JSON-field length budgets, so future checks do not sprawl into top-level commands.
+- Prints context trust metadata in `mf context --json` and prompt-cache bundles so agents can distinguish binding instructions, command contracts, contextual hints, generated evidence, and volatile runtime data before using them.
 - Runs only allowed one-shot commands within a timeout via `mf run <intent>` or `mf verify` when the selected intent is runnable.
+- Records blockers, contradictions, verification gaps, and remaining risks as a structured conflict ledger in verify, evidence, and dashboard reports.
+- Stores bounded failure replay capsules for failed `mf verify` runs so future agents can reproduce the intent, receipt, command fingerprint, and changed-file state without copying raw command output.
 - Writes command receipts under `.mustflow/state/runs/run-*` and atomically updates `.mustflow/state/runs/latest.json`.
 - Generates a concise repository navigation map, `REPO_MAP.md`, with `mf map`.
 - Indexes and searches mustflow docs, skills, skill routes, command rules, command-effect locks, file fingerprints, and opt-in source anchor metadata with SQLite via `mf index` and `mf search`. The local SQLite file is a rebuildable lookup cache, not a memory store, audit log, command transcript store, command-authority source, or source-content database.
@@ -251,7 +259,7 @@ mf run mustflow_update_apply
 | `mf contract-lint` | Inspect `.mustflow/config/commands.toml` for command-contract errors and warnings without running commands. Add `--suggest` to print non-runnable candidate snippets from existing command files. |
 | `mf onboard commands` | Suggest review-only command-intent snippets from package.json, Makefile, or justfile without writing files or granting command authority. |
 | `mf next` | Inspect install state, changed files, verification coverage, and command-contract gaps, then print the next safe mustflow action without running commands. |
-| `mf evidence` | Summarize changed-file verification requirements, latest evidence, receipts, remaining risks, and gaps without running commands. |
+| `mf evidence` | Summarize changed-file verification requirements, risk-priced evidence assessment, latest failure replay capsule, conflict ledger, receipts, remaining risks, and gaps without running commands. |
 | `mf workspace status` | Inspect configured workspace roots and nested repository contract readiness without granting parent-to-child command authority. |
 | `mf workspace command-catalog` | Aggregate per-repository command intent availability with safe `mf run` entrypoints and no raw command strings. |
 | `mf workspace verify --changed --plan-only` | Aggregate per-repository changed-file verification plans without running commands or granting parent-to-child command authority. |
@@ -260,7 +268,7 @@ mf run mustflow_update_apply
 | `mf api command-catalog --json` | Print command intent availability and safe `mf run` entrypoints without exposing raw command strings. |
 | `mf api verification-plan --changed --json` | Print a stable, read-only verification plan for changed files without executing commands. |
 | `mf api latest-evidence --json` | Print bounded latest run or verify evidence without raw command output. |
-| `mf api diff-risk --changed --json` | Print a compact changed-file risk, verification summary, and read-only residual correction signals. |
+| `mf api diff-risk --changed --json` | Print a compact changed-file risk, verification summary, read-only complexity budget, and residual correction signals. |
 | `mf api health --json` | Print a compact workspace health report for quick agent gating. |
 | `mf api locks --json` | Print active `mf run` locks for multi-session coordination. |
 | `mf api serve --stdio` | Serve the same read-only API reports as newline-delimited JSON responses over stdin/stdout. |
@@ -269,12 +277,15 @@ mf run mustflow_update_apply
 | `mf docs review comment <path>` | Add multiline review guidance to an existing queue entry. |
 | `mf docs review approve <path>` | Mark review complete and hide the document from the default queue. |
 | `mf handoff validate <path>` | Validate a restricted work-item or handoff JSON record without writing files. |
-| `mf context --json` | Print read order, command rules, available capabilities, and recent run summary as JSON. |
+| `mf context --json` | Print read order, command rules, context trust metadata, available capabilities, prompt-cache bundles, and recent run summary as JSON. |
 | `mf skill route` | Resolve compact skill route candidates from task text, paths, and reasons before reading selected skill documents. |
 | `mf map --stdout` | Print the current mustflow root map to stdout. |
 | `mf map --write` | Create or update `REPO_MAP.md`. |
 | `mf quality check` | Inspect changed files for quality-gaming patterns without writing files. |
 | `mf quality check --all` | Inspect every tracked text file for quality-gaming patterns. |
+| `mf script-pack list` | List bundled script packs and script refs such as `core/text-budget`. |
+| `mf script-pack run core/text-budget check <path...> --max <count>` | Check exact text length budgets for files using grapheme counts by default. |
+| `mf script-pack run core/text-budget check package.json --json-pointer /description --max <count> --json` | Check a JSON string field and print the stable report schema. |
 | `mf run <intent>` | Run an allowed one-shot command. |
 | `mf run <intent> --wait` | Wait for conflicting active run locks before executing the command. |
 | `mf run <intent> --dry-run --json` | Preview whether an intent is runnable and what command metadata would be used, without executing it. |
@@ -300,6 +311,9 @@ mf run mustflow_update_apply
 
 Automation and agents should use `--json` output or `mf api serve --stdio` JSONL responses instead of parsing human-facing text. Published JSON Schemas for stable outputs live in `schemas/`.
 
+`core/text-budget` counts `line` units by splitting text on line breaks; a trailing line break
+therefore contributes an empty final line.
+
 ## Command execution policy
 
 Runnable work is declared in `.mustflow/config/commands.toml` so agents do not guess commands.
@@ -318,9 +332,9 @@ Development servers, watch modes, browser UIs, interactive commands, and backgro
 
 Command environments remove the project-local `node_modules/.bin` path from `PATH` by default. If an intent needs a project dependency binary such as `eslint`, `tsc`, or `vitest`, declare it through the package manager, for example `npm exec eslint -- ...`, `pnpm exec tsc -- --noEmit`, `bun x eslint ...`, or `yarn exec eslint ...`. `mf check --strict` warns when an agent-runnable intent uses a bare executable name that appears under the project-local `.bin` directory, except for names listed in `defaults.allow_project_local_bin_bare_executables`. `mf run` may resolve those allowed names directly from the local `.bin` directory without exposing every local binary through `PATH`. The installed template allows `mf` and `mustflow` by default. Intent-level `allow_env_inheritance_risks = true` is available when a command intentionally uses `env_policy = "inherit"`.
 
-Use `mf verify --reason <event> --plan-only --json` to inspect matching verification intents, command eligibility, remaining gaps, and missing runnable coverage without executing commands. Use `mf run <intent> --dry-run --json` to inspect one resolved command intent without spawning a process or writing a run receipt. Plan-only verification includes a `decision_graph` that connects changed surfaces, classification reasons, command candidates, eligibility checks, effects, and gaps. When `.mustflow/cache/mustflow.sqlite` is fresh, scheduled entries also include read-only `effectGraph` metadata for write locks and lock conflicts. These graph rows are marked `explanation_only` and never grant command authority; `.mustflow/config/commands.toml` remains the only runnable command source.
+Use `mf verify --reason <event> --plan-only --json` to inspect matching verification intents, command eligibility, risk-priced evidence requirements, remaining gaps, and missing runnable coverage without executing commands. Use `mf run <intent> --dry-run --json` to inspect one resolved command intent without spawning a process or writing a run receipt. Plan-only verification includes a `decision_graph` that connects changed surfaces, classification reasons, command candidates, eligibility checks, effects, and gaps. When `.mustflow/cache/mustflow.sqlite` is fresh, scheduled entries also include read-only `effectGraph` metadata for write locks and lock conflicts. These graph rows are marked `explanation_only` and never grant command authority; `.mustflow/config/commands.toml` remains the only runnable command source.
 
-Each executed command run writes a run record under `.mustflow/state/runs/run-*` and atomically updates `.mustflow/state/runs/latest.json`. The record includes the intent name, working directory, timeout, exit code, timeout status, and the tail of stdout and stderr.
+Each executed command run writes a run record under `.mustflow/state/runs/run-*` and atomically updates `.mustflow/state/runs/latest.json`. The record includes the intent name, working directory, timeout, exit code, timeout status, and the tail of stdout and stderr. `latest.json` is a root-scoped convenience pointer, not session-scoped proof; in multi-agent or multi-terminal workflows, use the per-run `receipt_path` or `mf run <intent> --json` output as the evidence for a specific run.
 
 ## Language and profiles
 

package/dist/cli/commands/api.js

@@ -7,6 +7,7 @@ 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 { createComplexityBudgetReport, } from '../../core/complexity-budget.js';
 import { readUtf8FileInsideWithoutSymlinks } from '../../core/safe-filesystem.js';
 import { createVerificationPlanId } from '../../core/verification-plan-id.js';
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
@@ -422,6 +423,7 @@ function createUnavailableVerificationPlanOutput(mustflowRoot, classification, i
         requirements: [],
         candidates: [],
         gaps: [],
+        risk_assessment: null,
         schedule: null,
         test_selection: null,
         execution_policy: createVerificationPlanExecutionPolicy(),
@@ -479,6 +481,7 @@ function createVerificationPlanOutput() {
             surfaces: gap.surfaces,
             detail: gap.detail,
         })),
+        risk_assessment: report.risk_assessment,
         schedule: toVerificationPlanSchedule(report),
         test_selection: toVerificationPlanTestSelection(report),
         execution_policy: createVerificationPlanExecutionPolicy(),
@@ -614,6 +617,14 @@ function getRiskLevel(classification, report) {
     if (classification.summary.fileCount === 0) {
         return 'none';
     }
+    if (report.risk_assessment.level === 'critical') {
+        return 'high';
+    }
+    if (report.risk_assessment.level === 'high' ||
+        report.risk_assessment.level === 'medium' ||
+        report.risk_assessment.level === 'low') {
+        return report.risk_assessment.level;
+    }
     const reasons = new Set(classification.summary.validationReasons);
     if (report.gaps.length > 0 ||
         classification.summary.publicSurfaceCount > 0 ||
@@ -794,6 +805,7 @@ function createDiffRiskOutput() {
             update_policies: [],
             drift_checks: [],
             required_verification: [],
+            complexity_budget: null,
             residual_corrections: createResidualCorrections(mustflowRoot, null),
             gap_count: 0,
             gaps: [],
@@ -820,6 +832,10 @@ function createDiffRiskOutput() {
     }
     const requiredVerification = report ? report.schedule.entries.map((entry) => entry.intent) : [];
     const verificationPlanId = report && contract ? createVerificationPlanId(report, contract) : null;
+    const complexityBudget = createComplexityBudgetReport({
+        files: classification.files,
+        summary: classification.summary,
+    });
     return {
         schema_version: API_DIFF_RISK_SCHEMA_VERSION,
         command: 'api diff-risk',
@@ -834,6 +850,7 @@ function createDiffRiskOutput() {
         update_policies: classification.summary.updatePolicies,
         drift_checks: classification.summary.driftChecks,
         required_verification: requiredVerification,
+        complexity_budget: complexityBudget,
         residual_corrections: createResidualCorrections(mustflowRoot, verificationPlanId),
         gap_count: report?.gaps.length ?? 0,
         gaps: report?.gaps.map((gap) => ({

package/dist/cli/commands/check.js

@@ -1,4 +1,5 @@
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
+import { acquireActiveCommandLock, GENERATED_SURFACE_READ_EFFECTS, reportActiveCommandLockConflict, } from '../lib/active-command-lock.js';
 import { t } from '../lib/i18n.js';
 import { formatCliOptionParseError, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
@@ -43,36 +44,47 @@ export function runCheck(args, reporter, lang = 'en') {
         return 1;
     }
     const strict = hasParsedCliOption(options, '--strict');
-    const report = checkMustflowProjectReport(resolveMustflowRoot(), { strict });
-    const issues = report.issues;
-    const warnings = report.warnings;
-    const ok = issues.length === 0;
-    if (hasParsedCliOption(options, '--json')) {
-        reporter.stdout(JSON.stringify({
-            ok,
-            strict,
-            issueCount: issues.length,
-            issues,
-            warningCount: warnings.length,
-            warnings,
-            issueDetails: report.issueDetails,
-        }, null, 2));
-        return ok ? 0 : 1;
+    const projectRoot = resolveMustflowRoot();
+    const activeLock = acquireActiveCommandLock(projectRoot, 'mf check', GENERATED_SURFACE_READ_EFFECTS);
+    if (!activeLock.ok) {
+        reportActiveCommandLockConflict(reporter, 'mf check', activeLock.conflicts, 'mf check --help', lang);
+        return 1;
     }
-    if (ok) {
-        for (const warning of warnings) {
-            reporter.stderr(warning);
+    try {
+        const report = checkMustflowProjectReport(projectRoot, { strict });
+        const issues = report.issues;
+        const warnings = report.warnings;
+        const ok = issues.length === 0;
+        if (hasParsedCliOption(options, '--json')) {
+            reporter.stdout(JSON.stringify({
+                ok,
+                strict,
+                issueCount: issues.length,
+                issues,
+                warningCount: warnings.length,
+                warnings,
+                issueDetails: report.issueDetails,
+            }, null, 2));
+            return ok ? 0 : 1;
         }
-        if (strict) {
-            reporter.stdout(t(lang, 'check.result.strictPassed'));
+        if (ok) {
+            for (const warning of warnings) {
+                reporter.stderr(warning);
+            }
+            if (strict) {
+                reporter.stdout(t(lang, 'check.result.strictPassed'));
+                return 0;
+            }
+            reporter.stdout(t(lang, 'check.result.passed'));
             return 0;
         }
-        reporter.stdout(t(lang, 'check.result.passed'));
-        return 0;
+        for (const issue of issues) {
+            reporter.stderr(issue);
+        }
+        reporter.stderr(t(lang, 'check.result.failed', { count: issues.length }));
+        return 1;
     }
-    for (const issue of issues) {
-        reporter.stderr(issue);
+    finally {
+        activeLock.handle.release();
     }
-    reporter.stderr(t(lang, 'check.result.failed', { count: issues.length }));
-    return 1;
 }

package/dist/cli/commands/doctor.js

@@ -1,6 +1,7 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
+import { acquireActiveCommandLock, GENERATED_SURFACE_READ_EFFECTS, reportActiveCommandLockConflict, } from '../lib/active-command-lock.js';
 import { getAgentContext, } from '../lib/agent-context.js';
 import { t } from '../lib/i18n.js';
 import { getLocalIndexDatabasePath } from '../lib/local-index.js';
@@ -278,11 +279,22 @@ export function runDoctor(args, reporter, lang = 'en') {
         printUsageError(reporter, formatCliOptionParseError(options.error, lang), 'mf doctor --help', getDoctorHelp(lang), lang);
         return 1;
     }
-    const output = createDoctorOutput(hasParsedCliOption(options, '--strict'));
-    if (hasParsedCliOption(options, '--json')) {
-        reporter.stdout(JSON.stringify(output, null, 2));
+    const projectRoot = resolveMustflowRoot();
+    const activeLock = acquireActiveCommandLock(projectRoot, 'mf doctor', GENERATED_SURFACE_READ_EFFECTS);
+    if (!activeLock.ok) {
+        reportActiveCommandLockConflict(reporter, 'mf doctor', activeLock.conflicts, 'mf doctor --help', lang);
+        return 1;
+    }
+    try {
+        const output = createDoctorOutput(hasParsedCliOption(options, '--strict'));
+        if (hasParsedCliOption(options, '--json')) {
+            reporter.stdout(JSON.stringify(output, null, 2));
+            return output.ok ? 0 : 1;
+        }
+        reporter.stdout(renderDoctorOutput(output, lang));
         return output.ok ? 0 : 1;
     }
-    reporter.stdout(renderDoctorOutput(output, lang));
-    return output.ok ? 0 : 1;
+    finally {
+        activeLock.handle.release();
+    }
 }

package/dist/cli/commands/evidence.js

@@ -234,6 +234,7 @@ function createPlanFromReport(report, contract, classification, latest) {
         changed_files: classification.files,
         validation_reasons: classification.summary.validationReasons,
         selected_intents: report.schedule.entries.map((entry) => entry.intent),
+        risk_assessment: report.risk_assessment,
         requirement_count: requirements.length,
         gap_count: gaps.length,
         requirements,
@@ -278,6 +279,7 @@ function unavailablePlan(source, error, classification = null) {
         changed_files: classification?.files ?? [],
         validation_reasons: classification?.summary.validationReasons ?? [],
         selected_intents: [],
+        risk_assessment: fallbackRiskAssessment('Plan unavailable; risk assessment could not be computed.'),
         requirement_count: 0,
         gap_count: 0,
         requirements: [],
@@ -304,6 +306,7 @@ function createPlanFromFile(mustflowRoot, planPath, latest) {
     const schedule = isRecord(parsed.schedule) ? parsed.schedule : null;
     const testSelection = isRecord(parsed.test_selection) ? parsed.test_selection : null;
     const classification = isRecord(parsed.classification) ? parsed.classification : null;
+    const riskAssessment = readRiskAssessment(parsed.risk_assessment);
     const selectedIntents = schedule
         ? uniqueSorted([
             ...readStringArrayField(schedule, 'selected_intents'),
@@ -324,6 +327,7 @@ function createPlanFromFile(mustflowRoot, planPath, latest) {
         changed_files: classification ? readStringArrayField(classification, 'files') : readStringArrayField(parsed, 'files'),
         validation_reasons: classification ? readStringArrayField(classification, 'validation_reasons') : [],
         selected_intents: selectedIntents,
+        risk_assessment: riskAssessment ?? fallbackRiskAssessment('Plan file does not include risk_assessment.'),
         requirement_count: requirementReports.length,
         gap_count: gaps.length,
         requirements: requirementReports,
@@ -371,6 +375,62 @@ function readLatestRequirement(record) {
         skipped_intents: readStringArrayField(record, 'skipped_intents'),
     };
 }
+function isRiskLevel(value) {
+    return value === 'low' || value === 'medium' || value === 'high' || value === 'critical';
+}
+function readRiskAssessment(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const level = readString(value, 'level');
+    if (value.schema_version !== '1' || value.source !== 'change_classification_and_command_contract' || !isRiskLevel(level)) {
+        return null;
+    }
+    return {
+        schema_version: '1',
+        source: 'change_classification_and_command_contract',
+        level,
+        reasons: readStringArrayField(value, 'reasons'),
+        required_evidence: readStringArrayField(value, 'required_evidence'),
+        blocking_gaps: readStringArrayField(value, 'blocking_gaps'),
+        rollback_required: readBooleanField(value, 'rollback_required') ?? false,
+        human_approval_required: readBooleanField(value, 'human_approval_required') ?? false,
+        manual_review_required: readBooleanField(value, 'manual_review_required') ?? false,
+    };
+}
+function readFailureReplayCapsule(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    if (value.schema_version !== '1' ||
+        value.source !== 'mf_verify_failure' ||
+        value.authority !== 'replay_supporting_evidence') {
+        return null;
+    }
+    return value;
+}
+function readConflictLedger(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    if (value.schema_version !== '1' || value.source !== 'verification_evidence_model' || !Array.isArray(value.items)) {
+        return null;
+    }
+    return value;
+}
+function fallbackRiskAssessment(reason) {
+    return {
+        schema_version: '1',
+        source: 'change_classification_and_command_contract',
+        level: 'low',
+        reasons: [reason],
+        required_evidence: ['changed_file_review'],
+        blocking_gaps: [],
+        rollback_required: false,
+        human_approval_required: false,
+        manual_review_required: false,
+    };
+}
 function createLatestReport(mustflowRoot, expectedPlanId, requested) {
     if (!requested) {
         return latestNotRequested();
@@ -392,6 +452,11 @@ function createLatestReport(mustflowRoot, expectedPlanId, requested) {
     }
     const evidenceModel = isRecord(parsed.evidence_model) ? parsed.evidence_model : null;
     const completionVerdict = isRecord(parsed.completion_verdict) ? parsed.completion_verdict : null;
+    const latestRiskAssessment = readRiskAssessment(parsed.risk_assessment) ?? (evidenceModel ? readRiskAssessment(evidenceModel.risk_assessment) : null);
+    const failureReplayCapsule = readFailureReplayCapsule(parsed.failure_replay_capsule) ??
+        (evidenceModel ? readFailureReplayCapsule(evidenceModel.failure_replay_capsule) : null);
+    const conflictLedger = readConflictLedger(parsed.conflict_ledger) ??
+        (evidenceModel ? readConflictLedger(evidenceModel.conflict_ledger) : null);
     const requirements = evidenceModel ? recordArray(evidenceModel.requirements).map(readLatestRequirement) : [];
     const receipts = evidenceModel ? recordArray(evidenceModel.receipts).map(readLatestReceipt) : [];
     const skippedChecks = evidenceModel ? recordArray(evidenceModel.skipped_checks).map(toGapReport) : [];
@@ -408,6 +473,9 @@ function createLatestReport(mustflowRoot, expectedPlanId, requested) {
         receipt_count: receipts.length,
         skipped_check_count: skippedChecks.length,
         remaining_risk_count: remainingRisks.length,
+        risk_assessment: latestRiskAssessment,
+        failure_replay_capsule: failureReplayCapsule,
+        conflict_ledger: conflictLedger,
         requirements,
         receipts,
         skipped_checks: skippedChecks,
@@ -428,6 +496,9 @@ function latestEmpty(status) {
         receipt_count: null,
         skipped_check_count: 0,
         remaining_risk_count: 0,
+        risk_assessment: null,
+        failure_replay_capsule: null,
+        conflict_ledger: null,
         requirements: [],
         receipts: [],
         skipped_checks: [],

package/dist/cli/commands/index.js

@@ -1,4 +1,5 @@
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
+import { acquireActiveCommandLock, LOCAL_INDEX_WRITE_EFFECTS, reportActiveCommandLockConflict, } from '../lib/active-command-lock.js';
 import { t } from '../lib/i18n.js';
 import { createLocalIndex } from '../lib/local-index.js';
 import { formatCliOptionParseError, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
@@ -83,15 +84,29 @@ export async function runIndex(args, reporter, lang = 'en') {
         printUsageError(reporter, formatCliOptionParseError(parsed.error, lang), 'mf index --help', getIndexHelp(lang), lang);
         return 1;
     }
-    const result = await createLocalIndex(resolveMustflowRoot(), {
-        dryRun: hasParsedCliOption(parsed, '--dry-run'),
-        includeSource: hasParsedCliOption(parsed, '--source'),
-        incremental: hasParsedCliOption(parsed, '--incremental'),
-    });
-    if (hasParsedCliOption(parsed, '--json')) {
-        reporter.stdout(JSON.stringify(result, null, 2));
+    const dryRun = hasParsedCliOption(parsed, '--dry-run');
+    const projectRoot = resolveMustflowRoot();
+    const activeLock = dryRun ? null : acquireActiveCommandLock(projectRoot, 'mf index', LOCAL_INDEX_WRITE_EFFECTS);
+    if (activeLock && !activeLock.ok) {
+        reportActiveCommandLockConflict(reporter, 'mf index', activeLock.conflicts, 'mf index --help', lang);
+        return 1;
+    }
+    try {
+        const result = await createLocalIndex(projectRoot, {
+            dryRun,
+            includeSource: hasParsedCliOption(parsed, '--source'),
+            incremental: hasParsedCliOption(parsed, '--incremental'),
+        });
+        if (hasParsedCliOption(parsed, '--json')) {
+            reporter.stdout(JSON.stringify(result, null, 2));
+            return 0;
+        }
+        reporter.stdout(renderIndexSummary(result, lang));
         return 0;
     }
-    reporter.stdout(renderIndexSummary(result, lang));
-    return 0;
+    finally {
+        if (activeLock?.ok) {
+            activeLock.handle.release();
+        }
+    }
 }

package/dist/cli/commands/map.js

@@ -1,5 +1,6 @@
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
 import { t } from '../lib/i18n.js';
+import { acquireActiveCommandLock, REPO_MAP_WRITE_EFFECTS, reportActiveCommandLockConflict, } from '../lib/active-command-lock.js';
 import { formatCliOptionParseError, getParsedCliStringOption, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
 import { generateRepoMap, writeRepoMap } from '../lib/repo-map.js';
@@ -71,13 +72,25 @@ export function runMap(args, reporter, lang = 'en') {
         shouldPrint = true;
     }
     const projectRoot = resolveMustflowRoot();
-    const content = generateRepoMap(projectRoot, { depth, includeNested });
-    if (shouldWrite) {
-        writeRepoMap(projectRoot, content);
-        reporter.stdout(t(lang, 'map.wrote'));
+    const activeLock = shouldWrite ? acquireActiveCommandLock(projectRoot, 'mf map --write', REPO_MAP_WRITE_EFFECTS) : null;
+    if (activeLock && !activeLock.ok) {
+        reportActiveCommandLockConflict(reporter, 'mf map --write', activeLock.conflicts, 'mf map --help', lang);
+        return 1;
+    }
+    try {
+        const content = generateRepoMap(projectRoot, { depth, includeNested });
+        if (shouldWrite) {
+            writeRepoMap(projectRoot, content);
+            reporter.stdout(t(lang, 'map.wrote'));
+        }
+        if (shouldPrint) {
+            reporter.stdout(content);
+        }
+        return 0;
     }
-    if (shouldPrint) {
-        reporter.stdout(content);
+    finally {
+        if (activeLock?.ok) {
+            activeLock.handle.release();
+        }
     }
-    return 0;
 }

package/dist/cli/commands/run.js

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { performance } from 'node:perf_hooks';
-import { acquireActiveRunLock } from '../../core/active-run-locks.js';
+import { ACTIVE_RUN_LOCK_ID_ENV, acquireActiveRunLock } from '../../core/active-run-locks.js';
 import { createCommandEnv } from '../../core/command-env.js';
 import { createCorrelationId } from '../../core/correlation-id.js';
 import { printUsageError, renderCliError, renderHelp } from '../lib/cli-output.js';
@@ -360,6 +360,7 @@ export async function runRun(args, reporter, lang = 'en', options = {}) {
     try {
         const runReceiptPolicy = profiler.measure('retention_policy', () => resolveRunReceiptRetentionPolicy(readMustflowConfigIfExists(projectRoot)));
         const env = profiler.measure('environment', () => createCommandEnv(projectRoot, { policy: plan.envPolicy, allowlist: plan.envAllowlist }));
+        env[ACTIVE_RUN_LOCK_ID_ENV] = activeRunLock.handle.record.run_id;
         const writeTracker = profiler.measure('write_drift_before', () => startRunWriteTracking(projectRoot, contract, intentName, {
             additionalDeclaredPaths: options.additionalDeclaredWritePaths,
             env,

package/dist/cli/commands/script-pack.js

@@ -0,0 +1,124 @@
+import { printUsageError, renderHelp } from '../lib/cli-output.js';
+import { t } from '../lib/i18n.js';
+import { formatCliOptionParseError, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
+import { resolveMustflowRoot } from '../lib/project-root.js';
+import { findScriptPackScript, SCRIPT_PACKS, } from '../lib/script-pack-registry.js';
+const SCRIPT_PACK_LIST_OPTIONS = [{ name: '--json', kind: 'boolean' }];
+function createCatalogReport(mustflowRoot, packs) {
+    return {
+        schema_version: '1',
+        command: 'script-pack',
+        action: 'list',
+        ok: true,
+        mustflow_root: mustflowRoot,
+        packs: packs.map((pack) => ({
+            id: pack.id,
+            summary_key: pack.summaryKey,
+            scripts: pack.scripts.map((script) => ({
+                id: script.id,
+                ref: script.ref,
+                usage: script.usage,
+                summary_key: script.summaryKey,
+                actions: script.actions,
+                report_schema_file: script.reportSchemaFile,
+            })),
+        })),
+        issues: [],
+    };
+}
+export function getScriptPackHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf script-pack <list|run> [options]',
+        summary: t(lang, 'scriptPack.help.summary'),
+        options: [
+            { label: '--json', description: t(lang, 'cli.option.json') },
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+        ],
+        examples: [
+            'mf script-pack list',
+            'mf script-pack list --json',
+            'mf script-pack run core/text-budget check README.md --max 5000',
+            'mf script-pack run core/text-budget --help',
+        ],
+        exitCodes: [
+            { label: '0', description: t(lang, 'scriptPack.help.exit.ok') },
+            { label: '1', description: t(lang, 'scriptPack.help.exit.fail') },
+        ],
+    }, lang);
+}
+function renderCatalogSummary(report, lang) {
+    const lines = [t(lang, 'scriptPack.title')];
+    for (const pack of report.packs) {
+        lines.push(`- ${pack.id}: ${t(lang, pack.summary_key)}`);
+        for (const script of pack.scripts) {
+            const schema = script.report_schema_file ?? t(lang, 'value.none');
+            lines.push(`  - ${script.ref}: ${t(lang, script.summary_key)} ` +
+                `(${t(lang, 'scriptPack.label.actions')}: ${script.actions.join(', ')}, ` +
+                `${t(lang, 'scriptPack.label.schema')}: ${schema})`);
+        }
+    }
+    return lines.join('\n');
+}
+function parseListOptions(args, lang) {
+    const parsed = parseCliOptions(args, SCRIPT_PACK_LIST_OPTIONS, { allowPositionals: false });
+    const json = hasParsedCliOption(parsed, '--json');
+    if (parsed.error) {
+        return { json, error: formatCliOptionParseError(parsed.error, lang) };
+    }
+    return { json };
+}
+async function runScriptPackList(args, reporter, lang) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
+        reporter.stdout(getScriptPackHelp(lang));
+        return 0;
+    }
+    const options = parseListOptions(args, lang);
+    if (options.error) {
+        printUsageError(reporter, options.error, 'mf script-pack --help', getScriptPackHelp(lang), lang);
+        return 1;
+    }
+    const report = createCatalogReport(resolveMustflowRoot(), SCRIPT_PACKS);
+    if (options.json) {
+        reporter.stdout(JSON.stringify(report, null, 2));
+        return 0;
+    }
+    reporter.stdout(renderCatalogSummary(report, lang));
+    return 0;
+}
+async function runScriptPackScript(args, reporter, lang) {
+    const [scriptRef, ...scriptArgs] = args;
+    if (args.length === 1 && hasCliOptionToken(args, '--help', ['-h'])) {
+        reporter.stdout(getScriptPackHelp(lang));
+        return 0;
+    }
+    if (!scriptRef) {
+        printUsageError(reporter, t(lang, 'scriptPack.error.missingScript'), 'mf script-pack --help', getScriptPackHelp(lang), lang);
+        return 1;
+    }
+    const script = findScriptPackScript(scriptRef);
+    if (!script) {
+        printUsageError(reporter, t(lang, 'scriptPack.error.unknownScript', { script: scriptRef }), 'mf script-pack list', getScriptPackHelp(lang), lang);
+        return 1;
+    }
+    const runner = await script.loadRunner();
+    return runner(scriptArgs, reporter, lang);
+}
+export async function runScriptPack(args, reporter, lang = 'en') {
+    const [action, ...rest] = args;
+    if ((!action || action !== 'run') && hasCliOptionToken(args, '--help', ['-h'])) {
+        reporter.stdout(getScriptPackHelp(lang));
+        return 0;
+    }
+    if (!action) {
+        printUsageError(reporter, t(lang, 'scriptPack.error.missingAction'), 'mf script-pack --help', getScriptPackHelp(lang), lang);
+        return 1;
+    }
+    if (action === 'list') {
+        return runScriptPackList(rest, reporter, lang);
+    }
+    if (action === 'run') {
+        return runScriptPackScript(rest, reporter, lang);
+    }
+    printUsageError(reporter, t(lang, 'scriptPack.error.unknownAction', { action }), 'mf script-pack --help', getScriptPackHelp(lang), lang);
+    return 1;
+}