mustflow 2.70.0 → 2.74.1

package/dist/cli/index.js

@@ -54,6 +54,7 @@ function getTopLevelHelp(lang) {
             'mf verify --reason code_change',
             'mf line-endings check',
             'mf quality check',
+            'mf script-pack run core/text-budget check README.md --max 5000',
             'mf version --check',
             'mf version-sources --json',
         ],

package/dist/cli/lib/active-command-lock.js

@@ -0,0 +1,96 @@
+import { ACTIVE_RUN_LOCK_ID_ENV, acquireActiveRunLock, } from '../../core/active-run-locks.js';
+import { renderCliError } from './cli-output.js';
+import { t } from './i18n.js';
+export const REPO_MAP_WRITE_EFFECTS = [
+    { type: 'write', mode: 'replace', path: 'REPO_MAP.md', concurrency: 'exclusive' },
+];
+export const LOCAL_INDEX_WRITE_EFFECTS = [
+    {
+        type: 'write',
+        mode: 'replace',
+        path: '.mustflow/cache/**',
+        lock: 'local_index_cache',
+        concurrency: 'exclusive',
+    },
+];
+export const MUSTFLOW_UPDATE_APPLY_EFFECTS = [
+    { type: 'write', mode: 'replace', path: 'AGENTS.md', concurrency: 'exclusive' },
+    { type: 'write', mode: 'replace', path: '.mustflow/config/manifest.lock.toml', concurrency: 'exclusive' },
+    { type: 'write', mode: 'replace', path: '.mustflow/config/commands.toml', concurrency: 'exclusive' },
+    { type: 'write', mode: 'replace', path: '.mustflow/config/mustflow.toml', concurrency: 'exclusive' },
+    { type: 'write', mode: 'replace', path: '.mustflow/config/preferences.toml', concurrency: 'exclusive' },
+    { type: 'write', mode: 'replace', path: '.mustflow/context/**', concurrency: 'exclusive' },
+    { type: 'write', mode: 'replace', path: '.mustflow/docs/**', concurrency: 'exclusive' },
+    { type: 'write', mode: 'replace', path: '.mustflow/skills/**', concurrency: 'exclusive' },
+    { type: 'write', mode: 'replace', path: '.mustflow/backups/**', concurrency: 'exclusive' },
+];
+export const GENERATED_SURFACE_READ_EFFECTS = [
+    { type: 'read', mode: 'read', path: 'REPO_MAP.md', concurrency: 'shared' },
+    { type: 'read', mode: 'read', path: '.mustflow/config/manifest.lock.toml', concurrency: 'shared' },
+    {
+        type: 'read',
+        mode: 'read',
+        path: '.mustflow/cache/**',
+        lock: 'local_index_cache',
+        concurrency: 'shared',
+    },
+];
+function effectToToml(effect) {
+    const output = {
+        type: effect.type,
+    };
+    if (effect.mode) {
+        output.mode = effect.mode;
+    }
+    if (effect.path) {
+        output.path = effect.path;
+    }
+    if (effect.paths) {
+        output.paths = [...effect.paths];
+    }
+    if (effect.lock) {
+        output.lock = effect.lock;
+    }
+    if (effect.concurrency) {
+        output.concurrency = effect.concurrency;
+    }
+    return output;
+}
+function createSyntheticCommandContract(intentName, effects) {
+    return {
+        defaults: { default_cwd: '.' },
+        resources: {},
+        intents: {
+            [intentName]: {
+                cwd: '.',
+                writes: [],
+                effects: effects.map(effectToToml),
+            },
+        },
+    };
+}
+function parentRunId() {
+    const value = process.env[ACTIVE_RUN_LOCK_ID_ENV]?.trim();
+    return value && value.length > 0 ? value : null;
+}
+export function acquireActiveCommandLock(projectRoot, displayName, effects) {
+    return acquireActiveRunLock(projectRoot, createSyntheticCommandContract(displayName, effects), displayName, {
+        commandHash: null,
+        ignoreRunId: parentRunId(),
+        ignorePid: process.ppid,
+    });
+}
+export function renderActiveCommandLockConflictMessage(displayName, conflicts, lang) {
+    const [first] = conflicts;
+    const detail = first
+        ? t(lang, 'run.error.activeLockConflictDetail', {
+            lock: first.lock,
+            intent: first.conflictsWithIntent,
+            pid: first.conflictsWithPid,
+        })
+        : t(lang, 'run.error.activeLockConflictUnknown');
+    return t(lang, 'run.error.activeLockConflict', { intent: displayName, detail });
+}
+export function reportActiveCommandLockConflict(reporter, displayName, conflicts, helpCommand, lang) {
+    reporter.stderr(renderCliError(renderActiveCommandLockConflictMessage(displayName, conflicts, lang), helpCommand, lang));
+}

package/dist/cli/lib/agent-context.js

@@ -87,10 +87,20 @@ function readNumber(table, key) {
     return typeof value === 'number' && Number.isFinite(value) ? value : null;
 }
 function readPathContext(projectRoot, paths) {
-    return paths.map((relativePath) => ({
-        path: toPosixPath(relativePath),
-        exists: safeExists(projectRoot, relativePath),
-    }));
+    return paths.map((relativePath) => {
+        const normalizedPath = toPosixPath(relativePath);
+        const content = safeRead(projectRoot, normalizedPath);
+        return {
+            path: normalizedPath,
+            exists: content !== null,
+            trust: createContextTrust({
+                relativePath: normalizedPath,
+                cacheLayer: null,
+                contentHash: content === null ? null : sha256(content),
+                exists: content !== null,
+            }),
+        };
+    });
 }
 function readScalarObject(table) {
     if (!table) {
@@ -111,6 +121,100 @@ function readScalarObject(table) {
 function sha256(content) {
     return `sha256:${createHash('sha256').update(content).digest('hex')}`;
 }
+function trustSourceKind(relativePath, sourceKind) {
+    if (sourceKind === 'runtime_volatile') {
+        return 'runtime_volatile';
+    }
+    if (relativePath === null) {
+        return sourceKind === 'dynamic_selection' ? 'source_placeholder' : 'unknown_file';
+    }
+    if (relativePath === COMMANDS_RELATIVE_PATH) {
+        return 'command_contract';
+    }
+    if (relativePath === LATEST_RUN_RELATIVE_PATH || relativePath.startsWith('.mustflow/state/')) {
+        return 'generated_state';
+    }
+    if (relativePath.startsWith('.mustflow/cache/')) {
+        return 'generated_cache';
+    }
+    if (relativePath.startsWith('.mustflow/skills/') && relativePath.endsWith('/SKILL.md')) {
+        return 'skill_file';
+    }
+    if (relativePath.startsWith('.mustflow/context/')) {
+        return 'context_file';
+    }
+    if (relativePath === 'AGENTS.md' ||
+        relativePath.startsWith('.mustflow/docs/') ||
+        relativePath.startsWith('.mustflow/config/') ||
+        relativePath.startsWith('.mustflow/skills/')) {
+        return 'workflow_file';
+    }
+    return 'unknown_file';
+}
+function trustAuthority(relativePath, sourceKind) {
+    if (relativePath === 'AGENTS.md') {
+        return 'binding';
+    }
+    if (relativePath === COMMANDS_RELATIVE_PATH) {
+        return 'command_contract';
+    }
+    if (relativePath === MUSTFLOW_RELATIVE_PATH ||
+        relativePath === PREFERENCES_RELATIVE_PATH ||
+        relativePath === TECHNOLOGY_RELATIVE_PATH) {
+        return 'configuration';
+    }
+    if (relativePath?.startsWith('.mustflow/docs/')) {
+        return 'workflow_policy';
+    }
+    if (relativePath?.startsWith('.mustflow/skills/') && relativePath.endsWith('/SKILL.md')) {
+        return 'procedure';
+    }
+    if (relativePath?.startsWith('.mustflow/context/')) {
+        return 'contextual';
+    }
+    if (sourceKind === 'generated_cache') {
+        return 'generated';
+    }
+    if (sourceKind === 'generated_state') {
+        return 'evidence_only';
+    }
+    if (sourceKind === 'runtime_volatile') {
+        return 'volatile';
+    }
+    if (sourceKind === 'source_placeholder') {
+        return 'hint';
+    }
+    return 'unknown';
+}
+function createContextTrust(input) {
+    const normalizedPath = input.relativePath === null ? null : toPosixPath(input.relativePath);
+    const sourceKind = trustSourceKind(normalizedPath, input.sourceKind ?? null);
+    const authority = trustAuthority(normalizedPath, sourceKind);
+    const freshness = sourceKind === 'runtime_volatile'
+        ? 'runtime_volatile'
+        : input.contentHash !== null
+            ? 'hash_verified'
+            : input.exists === false
+                ? 'missing'
+                : sourceKind === 'source_placeholder'
+                    ? 'dynamic'
+                    : 'unchecked';
+    return {
+        source_kind: sourceKind,
+        authority,
+        cache_layer: input.cacheLayer,
+        freshness,
+        content_hash: input.contentHash,
+        can_instruct_agent: authority === 'binding' ||
+            authority === 'workflow_policy' ||
+            authority === 'configuration' ||
+            authority === 'command_contract' ||
+            authority === 'procedure' ||
+            authority === 'contextual',
+        grants_command_authority: authority === 'command_contract',
+        notes: input.notes ?? [],
+    };
+}
 function estimateTokens(renderedBytes) {
     return Math.ceil(renderedBytes / 4);
 }
@@ -396,10 +500,19 @@ function readStablePromptCacheLayer(projectRoot, mustflow) {
     const read = readOptionalStringArray(layer, 'read') ?? [...DEFAULT_PROMPT_CACHE_STABLE_READ];
     const documents = read.map((relativePath) => {
         const content = safeRead(projectRoot, relativePath);
+        const contentHash = content === null ? null : sha256(content);
+        const normalizedPath = toPosixPath(relativePath);
         return {
-            path: toPosixPath(relativePath),
+            path: normalizedPath,
             exists: content !== null,
-            content_hash: content === null ? null : sha256(content),
+            content_hash: contentHash,
+            trust: createContextTrust({
+                relativePath: normalizedPath,
+                cacheLayer: 'stable',
+                contentHash,
+                exists: content !== null,
+                sourceKind: 'file_reference',
+            }),
         };
     });
     const cacheMaterial = documents
@@ -515,6 +628,7 @@ function readStablePromptBundleLayer(projectRoot, mustflow) {
         blocks: read.map((relativePath, index) => {
             const path = toPosixPath(relativePath);
             const content = safeRead(projectRoot, relativePath);
+            const contentHash = content === null ? null : sha256(content);
             const renderedBytes = content === null ? null : measurePromptCacheReferenceBlockBytes(relativePath, content);
             const issue = content === null ? `stable prefix document is missing: ${path}` : null;
             return {
@@ -527,12 +641,19 @@ function readStablePromptBundleLayer(projectRoot, mustflow) {
                 source_kind: 'file_reference',
                 selection_policy: 'always_rendered',
                 content_included: false,
-                content_hash: content === null ? null : sha256(content),
+                content_hash: contentHash,
                 rendered_digest: content === null ? null : renderedDigest(relativePath, content),
                 rendered_bytes: renderedBytes,
                 estimated_tokens: renderedBytes === null ? null : estimateTokens(renderedBytes),
                 cacheability: 'provider_prefix_candidate',
                 reload_on: ['stable_file_hash_changed'],
+                trust: createContextTrust({
+                    relativePath: path,
+                    cacheLayer: 'stable',
+                    contentHash,
+                    exists: content !== null,
+                    sourceKind: 'file_reference',
+                }),
                 issue,
             };
         }),
@@ -589,6 +710,14 @@ function readTaskPromptBundleLayer(projectRoot, mustflow, routeReport) {
                 estimated_tokens: renderedBytes === null ? null : estimateTokens(renderedBytes),
                 cacheability: taskSourceCacheability(source, selectionPolicy),
                 reload_on: taskSourceReloadOn(source, selectionPolicy),
+                trust: createContextTrust({
+                    relativePath: routeCandidateContent !== null ? SKILL_ROUTE_CANDIDATES_VIRTUAL_PATH : referencePath,
+                    cacheLayer: 'task',
+                    contentHash,
+                    exists: routeCandidateContent !== null || content !== null ? true : sourceKind === 'file_reference' ? false : null,
+                    sourceKind,
+                    notes: source === 'skill_route_candidates' ? ['derived from route resolver input'] : [],
+                }),
                 issue,
             };
             if (source !== 'matching_skill') {
@@ -597,6 +726,7 @@ function readTaskPromptBundleLayer(projectRoot, mustflow, routeReport) {
             const selectedBlocks = selectedSkillPaths.map((skillPath, selectedIndex) => {
                 const normalizedPath = toPosixPath(skillPath);
                 const skillContent = safeRead(projectRoot, normalizedPath);
+                const skillContentHash = skillContent === null ? null : sha256(skillContent);
                 const skillRenderedBytes = skillContent === null ? null : measurePromptCacheReferenceBlockBytes(normalizedPath, skillContent);
                 const skillIssue = skillContent === null
                     ? taskSourceIssue(normalizedPath, 'hash_only_deferred')
@@ -611,12 +741,20 @@ function readTaskPromptBundleLayer(projectRoot, mustflow, routeReport) {
                     source_kind: skillContent === null ? 'dynamic_selection' : 'file_reference',
                     selection_policy: 'selected_at_runtime',
                     content_included: false,
-                    content_hash: skillContent === null ? null : sha256(skillContent),
+                    content_hash: skillContentHash,
                     rendered_digest: skillContent === null ? null : renderedDigest(normalizedPath, skillContent),
                     rendered_bytes: skillRenderedBytes,
                     estimated_tokens: skillRenderedBytes === null ? null : estimateTokens(skillRenderedBytes),
                     cacheability: 'runtime_selection',
                     reload_on: ['route_resolution_changed', 'source_file_hash_changed'],
+                    trust: createContextTrust({
+                        relativePath: normalizedPath,
+                        cacheLayer: 'task',
+                        contentHash: skillContentHash,
+                        exists: skillContent !== null,
+                        sourceKind: skillContent === null ? 'dynamic_selection' : 'file_reference',
+                        notes: ['selected by task route resolver'],
+                    }),
                     issue: skillIssue,
                 };
             });
@@ -646,6 +784,14 @@ function readVolatilePromptBundleLayer(mustflow) {
             estimated_tokens: null,
             cacheability: 'volatile_suffix',
             reload_on: ['volatile_state_changed'],
+            trust: createContextTrust({
+                relativePath: null,
+                cacheLayer: 'volatile',
+                contentHash: null,
+                exists: null,
+                sourceKind: 'runtime_volatile',
+                notes: ['not rendered in stable or task prompt cache layers'],
+            }),
             issue,
         })),
     };
@@ -663,10 +809,27 @@ function readPromptBundle(projectRoot, mustflow, profile, routeReport = null) {
     }
     const blocks = layers.flatMap((layer) => layer.blocks);
     const shapeMaterial = blocks
-        .map((block) => [block.cache_layer, block.order, block.kind, block.path ?? '', block.source ?? '', block.selection_policy, block.cacheability].join('\0'))
+        .map((block) => [
+        block.cache_layer,
+        block.order,
+        block.kind,
+        block.path ?? '',
+        block.source ?? '',
+        block.selection_policy,
+        block.cacheability,
+        block.trust.authority,
+        block.trust.source_kind,
+    ].join('\0'))
         .join('\n');
     const bundleMaterial = blocks
-        .map((block) => [block.id, block.content_hash ?? '', block.rendered_digest ?? '', block.issue ?? ''].join('\0'))
+        .map((block) => [
+        block.id,
+        block.content_hash ?? '',
+        block.rendered_digest ?? '',
+        block.trust.freshness,
+        block.trust.content_hash ?? '',
+        block.issue ?? '',
+    ].join('\0'))
         .join('\n');
     return {
         schema_version: '1',
@@ -744,6 +907,9 @@ function blockLocation(block) {
 function compareStringArray(left, right) {
     return left.length === right.length && left.every((entry, index) => entry === right[index]);
 }
+function contextTrustMatches(left, right) {
+    return JSON.stringify(left ?? null) === JSON.stringify(right ?? null);
+}
 function changedBlockFields(current, baseline) {
     const fields = [];
     if (current.id !== baseline.id) {
@@ -779,6 +945,9 @@ function changedBlockFields(current, baseline) {
     if (current.cacheability !== baseline.cacheability) {
         fields.push('cacheability');
     }
+    if (!contextTrustMatches(current.trust, baseline.trust)) {
+        fields.push('trust');
+    }
     if (!compareStringArray(current.reload_on, baseline.reload_on)) {
         fields.push('reload_on');
     }

package/dist/cli/lib/command-registry.js

@@ -95,6 +95,12 @@ export const COMMAND_DEFINITIONS = [
         summaryKey: 'command.quality.summary',
         loadRunner: async () => (await import('../commands/quality.js')).runQuality,
     },
+    {
+        id: 'script-pack',
+        usage: 'mf script-pack',
+        summaryKey: 'command.scriptPack.summary',
+        loadRunner: async () => (await import('../commands/script-pack.js')).runScriptPack,
+    },
     {
         id: 'run',
         usage: 'mf run',

package/dist/cli/lib/dashboard-export.js

@@ -448,6 +448,7 @@ function createDashboardHarnessReport(statusValue, docsReviewValue) {
         verification: {
             completion_verdict: completionVerdict,
             evidence_model: evidenceModel,
+            conflict_ledger: evidenceModel.conflict_ledger,
             changed_file_count: changedFileCount,
             changed_surfaces: changedSurfaces,
             decision_graph_summary: decisionGraphSummary,

package/dist/cli/lib/script-pack-registry.js

@@ -0,0 +1,27 @@
+function scriptRef(packId, scriptId) {
+    return `${packId}/${scriptId}`;
+}
+export const SCRIPT_PACKS = [
+    {
+        id: 'core',
+        summaryKey: 'scriptPack.pack.core.summary',
+        scripts: [
+            {
+                packId: 'core',
+                id: 'text-budget',
+                ref: scriptRef('core', 'text-budget'),
+                usage: 'mf script-pack run core/text-budget check <path...> [options]',
+                summaryKey: 'scriptPack.script.textBudget.summary',
+                actions: ['check'],
+                reportSchemaFile: 'text-budget-report.schema.json',
+                loadRunner: async () => (await import('../script-packs/core-text-budget.js')).runCoreTextBudgetScript,
+            },
+        ],
+    },
+];
+export function listScriptPackScripts() {
+    return SCRIPT_PACKS.flatMap((pack) => pack.scripts);
+}
+export function findScriptPackScript(ref) {
+    return listScriptPackScripts().find((script) => script.ref === ref);
+}

package/dist/cli/script-packs/core-text-budget.js

@@ -0,0 +1,241 @@
+import { printUsageError, renderHelp } from '../lib/cli-output.js';
+import { t } from '../lib/i18n.js';
+import { formatCliOptionParseError, getParsedCliStringOption, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
+import { resolveMustflowRoot } from '../lib/project-root.js';
+import { inspectTextBudget, TEXT_BUDGET_SCRIPT_REF, TEXT_BUDGET_UNITS, } from '../../core/text-budget.js';
+const TEXT_BUDGET_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+    { name: '--min', kind: 'string' },
+    { name: '--max', kind: 'string' },
+    { name: '--exact', kind: 'string' },
+    { name: '--unit', kind: 'string' },
+    { name: '--json-pointer', kind: 'string' },
+];
+export function getCoreTextBudgetHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf script-pack run core/text-budget check <path...> [options]',
+        summary: t(lang, 'textBudget.help.summary'),
+        options: [
+            { label: '--min <count>', description: t(lang, 'textBudget.help.option.min') },
+            { label: '--max <count>', description: t(lang, 'textBudget.help.option.max') },
+            { label: '--exact <count>', description: t(lang, 'textBudget.help.option.exact') },
+            { label: '--unit <unit>', description: t(lang, 'textBudget.help.option.unit') },
+            { label: '--json-pointer <pointer>', description: t(lang, 'textBudget.help.option.jsonPointer') },
+            { label: '--json', description: t(lang, 'cli.option.json') },
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+        ],
+        examples: [
+            'mf script-pack run core/text-budget check README.md --max 5000',
+            'mf script-pack run core/text-budget check package.json --json-pointer /description --max 80 --json',
+            'mf script-pack run core/text-budget check docs/intro.md --min 20 --max 120 --unit word',
+        ],
+        exitCodes: [
+            { label: '0', description: t(lang, 'textBudget.help.exit.ok') },
+            { label: '1', description: t(lang, 'textBudget.help.exit.fail') },
+        ],
+    }, lang);
+}
+function parseNonNegativeInteger(value, option, lang) {
+    if (value === null) {
+        return { value: null };
+    }
+    if (!/^(?:0|[1-9]\d*)$/u.test(value)) {
+        return { value: null, error: t(lang, 'textBudget.error.invalidNumber', { option, value }) };
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed)) {
+        return { value: null, error: t(lang, 'textBudget.error.invalidNumber', { option, value }) };
+    }
+    return { value: parsed };
+}
+function parseTextBudgetUnit(value, lang) {
+    if (value === null) {
+        return { value: 'grapheme' };
+    }
+    if (TEXT_BUDGET_UNITS.includes(value)) {
+        return { value: value };
+    }
+    return {
+        value: 'grapheme',
+        error: t(lang, 'textBudget.error.invalidUnit', { unit: value, allowed: TEXT_BUDGET_UNITS.join(', ') }),
+    };
+}
+function parseTextBudgetOptions(args, lang) {
+    const [action, ...rest] = args;
+    const parsed = parseCliOptions(rest, TEXT_BUDGET_OPTIONS, {
+        allowPositionals: true,
+        allowEmptyStringValues: true,
+    });
+    const json = hasParsedCliOption(parsed, '--json');
+    const min = parseNonNegativeInteger(getParsedCliStringOption(parsed, '--min'), '--min', lang);
+    const max = parseNonNegativeInteger(getParsedCliStringOption(parsed, '--max'), '--max', lang);
+    const exact = parseNonNegativeInteger(getParsedCliStringOption(parsed, '--exact'), '--exact', lang);
+    const unit = parseTextBudgetUnit(getParsedCliStringOption(parsed, '--unit'), lang);
+    const jsonPointer = getParsedCliStringOption(parsed, '--json-pointer');
+    if (action !== 'check') {
+        return {
+            action: 'check',
+            json,
+            paths: parsed.positionals,
+            min: min.value,
+            max: max.value,
+            exact: exact.value,
+            unit: unit.value,
+            jsonPointer,
+            error: action ? t(lang, 'textBudget.error.unknownAction', { action }) : t(lang, 'textBudget.error.missingAction'),
+        };
+    }
+    if (parsed.error) {
+        return {
+            action,
+            json,
+            paths: parsed.positionals,
+            min: min.value,
+            max: max.value,
+            exact: exact.value,
+            unit: unit.value,
+            jsonPointer,
+            error: formatCliOptionParseError(parsed.error, lang),
+        };
+    }
+    for (const candidate of [min, max, exact, unit]) {
+        if (candidate.error) {
+            return {
+                action,
+                json,
+                paths: parsed.positionals,
+                min: min.value,
+                max: max.value,
+                exact: exact.value,
+                unit: unit.value,
+                jsonPointer,
+                error: candidate.error,
+            };
+        }
+    }
+    if (parsed.positionals.length === 0) {
+        return {
+            action,
+            json,
+            paths: parsed.positionals,
+            min: min.value,
+            max: max.value,
+            exact: exact.value,
+            unit: unit.value,
+            jsonPointer,
+            error: t(lang, 'textBudget.error.missingPath'),
+        };
+    }
+    if (exact.value !== null && (min.value !== null || max.value !== null)) {
+        return {
+            action,
+            json,
+            paths: parsed.positionals,
+            min: min.value,
+            max: max.value,
+            exact: exact.value,
+            unit: unit.value,
+            jsonPointer,
+            error: t(lang, 'textBudget.error.exactConflict'),
+        };
+    }
+    if (exact.value === null && min.value === null && max.value === null) {
+        return {
+            action,
+            json,
+            paths: parsed.positionals,
+            min: min.value,
+            max: max.value,
+            exact: exact.value,
+            unit: unit.value,
+            jsonPointer,
+            error: t(lang, 'textBudget.error.missingBudget'),
+        };
+    }
+    if (min.value !== null && max.value !== null && min.value > max.value) {
+        return {
+            action,
+            json,
+            paths: parsed.positionals,
+            min: min.value,
+            max: max.value,
+            exact: exact.value,
+            unit: unit.value,
+            jsonPointer,
+            error: t(lang, 'textBudget.error.minGreaterThanMax'),
+        };
+    }
+    return {
+        action,
+        json,
+        paths: parsed.positionals,
+        min: min.value,
+        max: max.value,
+        exact: exact.value,
+        unit: unit.value,
+        jsonPointer,
+    };
+}
+function renderBudget(report) {
+    if (report.policy.exact !== null) {
+        return `exact ${report.policy.exact} ${report.policy.unit}`;
+    }
+    const lower = report.policy.min === null ? null : `min ${report.policy.min}`;
+    const upper = report.policy.max === null ? null : `max ${report.policy.max}`;
+    return [lower, upper].filter((part) => part !== null).join(', ') + ` ${report.policy.unit}`;
+}
+function renderTextBudgetSummary(report, lang) {
+    const lines = [
+        t(lang, 'textBudget.title'),
+        `${t(lang, 'scriptPack.label.script')}: ${TEXT_BUDGET_SCRIPT_REF}`,
+        `${t(lang, 'label.status')}: ${report.status}`,
+        `${t(lang, 'textBudget.label.budget')}: ${renderBudget(report)}`,
+        `${t(lang, 'textBudget.label.checkedTargets')}: ${report.metrics.length}`,
+        `${t(lang, 'textBudget.label.findings')}: ${report.findings.length}`,
+    ];
+    if (report.metrics.length > 0) {
+        lines.push(t(lang, 'textBudget.label.metrics'));
+        for (const metric of report.metrics) {
+            const pointer = metric.json_pointer === null ? '' : ` ${metric.json_pointer}`;
+            lines.push(`- ${metric.path}${pointer}: ${metric.value} ${metric.unit}`);
+        }
+    }
+    if (report.findings.length > 0) {
+        lines.push(t(lang, 'textBudget.label.findings'));
+        for (const finding of report.findings) {
+            lines.push(`- ${finding.path}: ${finding.code} (${finding.message})`);
+        }
+    }
+    if (report.issues.length > 0) {
+        lines.push(t(lang, 'textBudget.label.issues'), ...report.issues.map((issue) => `- ${issue}`));
+    }
+    if (report.findings.length === 0 && report.issues.length === 0) {
+        lines.push(t(lang, 'textBudget.clean'));
+    }
+    return lines.join('\n');
+}
+export function runCoreTextBudgetScript(args, reporter, lang = 'en') {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
+        reporter.stdout(getCoreTextBudgetHelp(lang));
+        return 0;
+    }
+    const options = parseTextBudgetOptions(args, lang);
+    if (options.error) {
+        printUsageError(reporter, options.error, 'mf script-pack run core/text-budget --help', getCoreTextBudgetHelp(lang), lang);
+        return 1;
+    }
+    const report = inspectTextBudget(resolveMustflowRoot(), {
+        paths: options.paths,
+        min: options.min,
+        max: options.max,
+        exact: options.exact,
+        unit: options.unit,
+        jsonPointer: options.jsonPointer,
+    });
+    if (options.json) {
+        reporter.stdout(JSON.stringify(report, null, 2));
+        return report.ok ? 0 : 1;
+    }
+    reporter.stdout(renderTextBudgetSummary(report, lang));
+    return report.ok ? 0 : 1;
+}