mustflow 2.70.0 → 2.74.1

package/dist/core/risk-priced-evidence.js

@@ -0,0 +1,213 @@
+import { isRecord, readString, readStringArray } from './config-loading.js';
+const LEVEL_RANK = {
+    low: 0,
+    medium: 1,
+    high: 2,
+    critical: 3,
+};
+const HIGH_RISK_REASONS = new Set([
+    'public_api_change',
+    'package_metadata_change',
+    'template_version_change',
+    'packaging_change',
+    'release_risk',
+    'before_publish',
+    'security_change',
+    'privacy_change',
+    'data_change',
+    'mustflow_config_change',
+    'mustflow_docs_change',
+    'auth_permission_change',
+    'deployment_change',
+]);
+const CRITICAL_RISK_REASONS = new Set([
+    'database_migration',
+    'database_migration_change',
+    'migration_change',
+    'secret_exposure',
+    'secret_change',
+    'destructive_change',
+]);
+const MEDIUM_RISK_REASONS = new Set([
+    'code_change',
+    'behavior_change',
+    'test_change',
+    'unknown_change',
+    'performance_change',
+    'ui_change',
+    'build_config_change',
+    'dependency_change',
+]);
+const HIGH_RISK_TEXT = [
+    'auth',
+    'authorization',
+    'permission',
+    'security',
+    'privacy',
+    'pii',
+    'token',
+    'credential',
+    'payment',
+    'refund',
+    'ledger',
+    'billing',
+    'public api',
+    'json schema',
+    'machine-readable output',
+    'package',
+    'release',
+    'deployment',
+    'production',
+    'data contract',
+];
+const CRITICAL_RISK_TEXT = [
+    'destructive',
+    'delete',
+    'drop table',
+    'secret',
+    'credential',
+    'private key',
+    'database migration',
+    'payment settlement',
+    'ledger mutation',
+];
+function uniqueSorted(values) {
+    return [...new Set([...values].filter((value) => typeof value === 'string' && value.length > 0))].sort((left, right) => left.localeCompare(right));
+}
+function maxLevel(left, right) {
+    return LEVEL_RANK[right] > LEVEL_RANK[left] ? right : left;
+}
+function includesAnySignal(values, signals) {
+    const normalizedValues = values.map((value) => value.toLowerCase());
+    return signals.some((signal) => normalizedValues.some((value) => value.includes(signal)));
+}
+function readBoolean(record, key) {
+    return typeof record[key] === 'boolean' ? record[key] : null;
+}
+function selectedIntentRecords(input) {
+    return input.selectedIntents
+        .map((intent) => input.commandContract.intents[intent])
+        .filter((intent) => isRecord(intent));
+}
+function intentHasDeleteEffect(intent) {
+    if (!Array.isArray(intent.effects)) {
+        return false;
+    }
+    return intent.effects.some((effect) => isRecord(effect) && readString(effect, 'mode') === 'delete_recreate');
+}
+function classifyReasonSignals(input) {
+    let level = 'low';
+    const reasons = [];
+    const validationReasons = input.classificationSummary.validationReasons;
+    const signalText = uniqueSorted([
+        ...validationReasons,
+        ...input.classificationSummary.changeKinds,
+        ...input.classificationSummary.affectedContracts,
+        ...input.classificationSummary.driftChecks,
+        ...input.requirements.flatMap((requirement) => [
+            requirement.reason,
+            ...requirement.surfaces,
+            ...requirement.affectedContracts,
+            ...requirement.driftChecks,
+        ]),
+    ]);
+    for (const reason of validationReasons) {
+        if (CRITICAL_RISK_REASONS.has(reason)) {
+            level = maxLevel(level, 'critical');
+            reasons.push(`critical validation reason: ${reason}`);
+        }
+        else if (HIGH_RISK_REASONS.has(reason)) {
+            level = maxLevel(level, 'high');
+            reasons.push(`high validation reason: ${reason}`);
+        }
+        else if (MEDIUM_RISK_REASONS.has(reason)) {
+            level = maxLevel(level, 'medium');
+            reasons.push(`medium validation reason: ${reason}`);
+        }
+    }
+    if (includesAnySignal(signalText, CRITICAL_RISK_TEXT)) {
+        level = maxLevel(level, 'critical');
+        reasons.push('critical contract or surface signal');
+    }
+    else if (includesAnySignal(signalText, HIGH_RISK_TEXT)) {
+        level = maxLevel(level, 'high');
+        reasons.push('high contract or surface signal');
+    }
+    if (input.gaps.length > 0) {
+        level = maxLevel(level, 'high');
+        reasons.push('verification gaps exist');
+    }
+    if (level === 'low' && input.classificationSummary.publicSurfaceCount > 0 && validationReasons.length > 0) {
+        reasons.push('public surface changed but no high-risk trigger matched');
+    }
+    return { level, reasons: uniqueSorted(reasons) };
+}
+function classifyCommandSignals(input) {
+    let level = 'low';
+    const reasons = [];
+    for (const intent of selectedIntentRecords(input)) {
+        const intentName = readString(intent, 'name') ?? null;
+        const label = intentName ?? 'selected intent';
+        if (readBoolean(intent, 'destructive') === true) {
+            level = maxLevel(level, 'critical');
+            reasons.push(`${label} is destructive`);
+        }
+        if (readBoolean(intent, 'network') === true) {
+            level = maxLevel(level, 'high');
+            reasons.push(`${label} uses network`);
+        }
+        if (intentHasDeleteEffect(intent)) {
+            level = maxLevel(level, 'medium');
+            reasons.push(`${label} rewrites declared output paths`);
+        }
+        if ((readStringArray(intent, 'writes') ?? []).length > 0) {
+            level = maxLevel(level, 'medium');
+            reasons.push(`${label} writes files`);
+        }
+    }
+    return { level, reasons: uniqueSorted(reasons) };
+}
+function requiredEvidence(level) {
+    if (level === 'critical') {
+        return [
+            'configured_mf_run_receipt',
+            'receipt_bound_to_current_plan',
+            'synchronized_contract_surfaces',
+            'rollback_or_recovery_plan',
+            'manual_approval_record',
+            'remaining_risk_review',
+        ];
+    }
+    if (level === 'high') {
+        return [
+            'configured_mf_run_receipt',
+            'receipt_bound_to_current_plan',
+            'synchronized_contract_surfaces',
+            'remaining_risk_review',
+        ];
+    }
+    if (level === 'medium') {
+        return ['configured_mf_run_receipt', 'related_or_declared_verification'];
+    }
+    return ['changed_file_review'];
+}
+export function riskPricedEvidenceRiskCount(assessment) {
+    return assessment.level === 'high' || assessment.level === 'critical' ? 1 : 0;
+}
+export function createVerificationRiskAssessment(input) {
+    const reasonSignals = classifyReasonSignals(input);
+    const commandSignals = classifyCommandSignals(input);
+    const level = maxLevel(reasonSignals.level, commandSignals.level);
+    const blockingGaps = input.gaps.map((gap) => `${gap.reason}: ${gap.detail}`);
+    return {
+        schema_version: '1',
+        source: 'change_classification_and_command_contract',
+        level,
+        reasons: uniqueSorted([...reasonSignals.reasons, ...commandSignals.reasons]),
+        required_evidence: requiredEvidence(level),
+        blocking_gaps: blockingGaps,
+        rollback_required: level === 'critical',
+        human_approval_required: level === 'critical',
+        manual_review_required: level === 'high' || level === 'critical',
+    };
+}

package/dist/core/script-check-result.js

@@ -0,0 +1 @@
+export {};

package/dist/core/text-budget.js

@@ -0,0 +1,262 @@
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+import { ensureInside, readFileInsideWithoutSymlinks } from './safe-filesystem.js';
+export const TEXT_BUDGET_PACK_ID = 'core';
+export const TEXT_BUDGET_SCRIPT_ID = 'text-budget';
+export const TEXT_BUDGET_SCRIPT_REF = `${TEXT_BUDGET_PACK_ID}/${TEXT_BUDGET_SCRIPT_ID}`;
+const DEFAULT_TEXT_BUDGET_UNIT = 'grapheme';
+const DEFAULT_MAX_FILE_BYTES = 1024 * 1024;
+const ERROR_FINDING_CODES = new Set([
+    'text_budget_unreadable',
+    'text_budget_json_parse_failed',
+    'text_budget_json_pointer_invalid',
+    'text_budget_json_pointer_missing',
+    'text_budget_json_pointer_not_string',
+]);
+export const TEXT_BUDGET_UNITS = [
+    'grapheme',
+    'code-point',
+    'utf16',
+    'utf8-byte',
+    'word',
+    'line',
+];
+function toPosixPath(value) {
+    return value.split(path.sep).join('/');
+}
+function sha256Hex(buffer) {
+    return createHash('sha256').update(buffer).digest('hex');
+}
+function sha256Tagged(buffer) {
+    return `sha256:${sha256Hex(buffer)}`;
+}
+function createSegmenter(granularity) {
+    const Segmenter = Intl.Segmenter;
+    return Segmenter ? new Segmenter(undefined, { granularity }) : null;
+}
+function countGraphemes(text) {
+    const segmenter = createSegmenter('grapheme');
+    return segmenter ? [...segmenter.segment(text)].length : [...text].length;
+}
+function countWords(text) {
+    const segmenter = createSegmenter('word');
+    if (segmenter) {
+        return [...segmenter.segment(text)].filter((segment) => segment.isWordLike === true).length;
+    }
+    return text.trim().length === 0 ? 0 : (text.trim().match(/\S+/gu) ?? []).length;
+}
+function countLines(text) {
+    return text.length === 0 ? 0 : text.split(/\r\n|\r|\n/u).length;
+}
+export function countTextBudgetUnits(text, unit) {
+    switch (unit) {
+        case 'grapheme':
+            return countGraphemes(text);
+        case 'code-point':
+            return [...text].length;
+        case 'utf16':
+            return text.length;
+        case 'utf8-byte':
+            return Buffer.byteLength(text, 'utf8');
+        case 'word':
+            return countWords(text);
+        case 'line':
+            return countLines(text);
+    }
+}
+function decodeJsonPointerSegment(segment) {
+    return segment.replace(/~1/gu, '/').replace(/~0/gu, '~');
+}
+function resolveJsonPointer(value, pointer) {
+    if (pointer === '') {
+        return { ok: true, value };
+    }
+    if (!pointer.startsWith('/')) {
+        return { ok: false, error: 'invalid' };
+    }
+    let current = value;
+    for (const rawSegment of pointer.slice(1).split('/')) {
+        if (/~(?![01])/u.test(rawSegment)) {
+            return { ok: false, error: 'invalid' };
+        }
+        const segment = decodeJsonPointerSegment(rawSegment);
+        if (Array.isArray(current)) {
+            if (!/^(?:0|[1-9]\d*)$/u.test(segment)) {
+                return { ok: false, error: 'missing' };
+            }
+            const index = Number(segment);
+            if (index >= current.length) {
+                return { ok: false, error: 'missing' };
+            }
+            current = current[index];
+            continue;
+        }
+        if (!current || typeof current !== 'object' || !Object.hasOwn(current, segment)) {
+            return { ok: false, error: 'missing' };
+        }
+        current = current[segment];
+    }
+    return { ok: true, value: current };
+}
+function makeFinding(code, severity, pathValue, jsonPointer, message, actual = null, expected = null, metric = 'text_length') {
+    return {
+        code,
+        severity,
+        message,
+        path: pathValue,
+        json_pointer: jsonPointer,
+        metric,
+        actual,
+        expected,
+    };
+}
+function compareAgainstPolicy(relativePath, pointer, value, policy) {
+    const findings = [];
+    if (policy.exact !== null && value !== policy.exact) {
+        findings.push(makeFinding('text_budget_not_exact', 'medium', relativePath, pointer, `${relativePath} has ${value} ${policy.unit}; expected exactly ${policy.exact}.`, value, policy.exact));
+    }
+    if (policy.min !== null && value < policy.min) {
+        findings.push(makeFinding('text_budget_below_min', 'medium', relativePath, pointer, `${relativePath} has ${value} ${policy.unit}; expected at least ${policy.min}.`, value, policy.min));
+    }
+    if (policy.max !== null && value > policy.max) {
+        findings.push(makeFinding('text_budget_above_max', 'medium', relativePath, pointer, `${relativePath} has ${value} ${policy.unit}; expected at most ${policy.max}.`, value, policy.max));
+    }
+    return findings;
+}
+function createInputHash(policy, artifacts, findings) {
+    const inputState = {
+        policy,
+        artifacts: artifacts.map((artifact) => ({
+            path: artifact.path,
+            sha256: artifact.sha256,
+            size_bytes: artifact.size_bytes,
+        })),
+        input_errors: findings
+            .filter((finding) => ERROR_FINDING_CODES.has(finding.code))
+            .map((finding) => ({
+            code: finding.code,
+            path: finding.path,
+            json_pointer: finding.json_pointer,
+        })),
+    };
+    return sha256Tagged(JSON.stringify(inputState));
+}
+function normalizeTargetPath(projectRoot, targetPath) {
+    const absolutePath = path.resolve(process.cwd(), targetPath);
+    ensureInside(projectRoot, absolutePath);
+    const relativePath = toPosixPath(path.relative(projectRoot, absolutePath));
+    return {
+        absolutePath,
+        relativePath: relativePath.length === 0 ? '.' : relativePath,
+    };
+}
+export function inspectTextBudget(projectRoot, options) {
+    const root = path.resolve(projectRoot);
+    const policy = {
+        min: options.min ?? null,
+        max: options.max ?? null,
+        exact: options.exact ?? null,
+        unit: options.unit ?? DEFAULT_TEXT_BUDGET_UNIT,
+        json_pointer: options.jsonPointer ?? null,
+        max_file_bytes: options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES,
+    };
+    const metrics = [];
+    const findings = [];
+    const artifacts = [];
+    const issues = [];
+    for (const targetPath of options.paths) {
+        let relativePath = targetPath;
+        let absolutePath;
+        try {
+            const normalized = normalizeTargetPath(root, targetPath);
+            absolutePath = normalized.absolutePath;
+            relativePath = normalized.relativePath;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            issues.push(message);
+            findings.push(makeFinding('text_budget_unreadable', 'high', targetPath, policy.json_pointer, message, null, null, null));
+            continue;
+        }
+        let buffer;
+        try {
+            buffer = readFileInsideWithoutSymlinks(root, absolutePath, { maxBytes: policy.max_file_bytes });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            issues.push(message);
+            findings.push(makeFinding('text_budget_unreadable', 'high', relativePath, policy.json_pointer, message, null, null, null));
+            continue;
+        }
+        const contentSha256 = sha256Tagged(buffer);
+        artifacts.push({
+            kind: 'input',
+            path: relativePath,
+            sha256: contentSha256,
+            size_bytes: buffer.byteLength,
+        });
+        const rawText = buffer.toString('utf8');
+        let selectedText = rawText;
+        if (policy.json_pointer !== null) {
+            let parsed;
+            try {
+                parsed = JSON.parse(rawText);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                issues.push(`${relativePath}: ${message}`);
+                findings.push(makeFinding('text_budget_json_parse_failed', 'high', relativePath, policy.json_pointer, `${relativePath} could not be parsed as JSON: ${message}`, null, null, null));
+                continue;
+            }
+            const resolution = resolveJsonPointer(parsed, policy.json_pointer);
+            if (!resolution.ok) {
+                const code = resolution.error === 'invalid' ? 'text_budget_json_pointer_invalid' : 'text_budget_json_pointer_missing';
+                const message = resolution.error === 'invalid'
+                    ? `Invalid JSON pointer: ${policy.json_pointer}`
+                    : `JSON pointer not found: ${policy.json_pointer}`;
+                issues.push(`${relativePath}: ${message}`);
+                findings.push(makeFinding(code, 'high', relativePath, policy.json_pointer, message, null, null, null));
+                continue;
+            }
+            if (typeof resolution.value !== 'string') {
+                const message = `JSON pointer ${policy.json_pointer} does not resolve to a string.`;
+                issues.push(`${relativePath}: ${message}`);
+                findings.push(makeFinding('text_budget_json_pointer_not_string', 'high', relativePath, policy.json_pointer, message, null, null, null));
+                continue;
+            }
+            selectedText = resolution.value;
+        }
+        const value = countTextBudgetUnits(selectedText, policy.unit);
+        metrics.push({
+            name: 'text_length',
+            value,
+            unit: policy.unit,
+            path: relativePath,
+            json_pointer: policy.json_pointer,
+            content_sha256: contentSha256,
+        });
+        findings.push(...compareAgainstPolicy(relativePath, policy.json_pointer, value, policy));
+    }
+    const status = findings.some((finding) => ERROR_FINDING_CODES.has(finding.code))
+        ? 'error'
+        : findings.length > 0
+            ? 'failed'
+            : 'passed';
+    return {
+        schema_version: '1',
+        command: 'script-pack',
+        pack_id: TEXT_BUDGET_PACK_ID,
+        script_id: TEXT_BUDGET_SCRIPT_ID,
+        script_ref: TEXT_BUDGET_SCRIPT_REF,
+        action: 'check',
+        status,
+        ok: status === 'passed',
+        mustflow_root: root,
+        policy,
+        input_hash: createInputHash(policy, artifacts, findings),
+        metrics,
+        findings,
+        artifacts,
+        issues,
+    };
+}

package/dist/core/verification-evidence.js

@@ -1,3 +1,5 @@
+import { createComplexityBudgetReport, createComplexityBudgetReportFromVerification, } from './complexity-budget.js';
+import { createConflictLedger } from './conflict-ledger.js';
 function uniqueSorted(values) {
     return [...new Set([...values].filter((value) => typeof value === 'string' && value.length > 0))].sort((left, right) => left.localeCompare(right));
 }
@@ -138,6 +140,18 @@ function externalEvidenceRemainingRisks(externalEvidenceRisks) {
         detail: risk.detail,
     }));
 }
+function riskPricedEvidenceRemainingRisks(assessment) {
+    if (!assessment?.manual_review_required) {
+        return [];
+    }
+    return [
+        {
+            code: 'risk_priced_evidence_requires_review',
+            severity: assessment.level,
+            detail: `Verification risk is ${assessment.level}; required evidence: ${assessment.required_evidence.join(', ')}.`,
+        },
+    ];
+}
 export function createVerifyEvidenceModel(input) {
     const requirements = input.report.requirements.map((requirement) => {
         const candidates = input.report.candidates.filter((candidate) => candidate.reason === requirement.reason);
@@ -173,6 +187,12 @@ export function createVerifyEvidenceModel(input) {
     const reproEvidenceRisks = input.reproEvidenceRisks ?? [];
     const externalChecks = input.externalChecks ?? [];
     const externalEvidenceRisks = input.externalEvidenceRisks ?? [];
+    const hasSpecificRemainingRisks = sourceAnchorRisks.length > 0 ||
+        scopeDiffRisks.length > 0 ||
+        repeatedFailureRisks.length > 0 ||
+        validationRatchetRisks.length > 0 ||
+        reproEvidenceRisks.length > 0 ||
+        externalEvidenceRisks.length > 0;
     const gaps = input.report.gaps.map((gap) => ({
         reason: gap.reason,
         intent: null,
@@ -181,6 +201,15 @@ export function createVerifyEvidenceModel(input) {
         files: [...gap.files],
         surfaces: [...gap.surfaces],
     }));
+    const remainingRisks = [
+        ...sourceAnchorRemainingRisks(sourceAnchorRisks),
+        ...scopeDiffRemainingRisks(scopeDiffRisks),
+        ...repeatedFailureRemainingRisks(repeatedFailureRisks),
+        ...validationRatchetRemainingRisks(validationRatchetRisks),
+        ...reproEvidenceRemainingRisks(reproEvidenceRisks),
+        ...externalEvidenceRemainingRisks(externalEvidenceRisks),
+        ...(hasSpecificRemainingRisks ? [] : riskPricedEvidenceRemainingRisks(input.report.risk_assessment)),
+    ];
     return {
         schema_version: '1',
         source: 'mf_verify',
@@ -196,14 +225,15 @@ export function createVerifyEvidenceModel(input) {
         receipts,
         skipped_checks: skippedCheckEntries(input.results),
         gaps,
-        remaining_risks: [
-            ...sourceAnchorRemainingRisks(sourceAnchorRisks),
-            ...scopeDiffRemainingRisks(scopeDiffRisks),
-            ...repeatedFailureRemainingRisks(repeatedFailureRisks),
-            ...validationRatchetRemainingRisks(validationRatchetRisks),
-            ...reproEvidenceRemainingRisks(reproEvidenceRisks),
-            ...externalEvidenceRemainingRisks(externalEvidenceRisks),
-        ],
+        complexity_budget: createComplexityBudgetReportFromVerification(input.report),
+        risk_assessment: input.report.risk_assessment,
+        ...(input.failureReplayCapsule ? { failure_replay_capsule: input.failureReplayCapsule } : {}),
+        remaining_risks: remainingRisks,
+        conflict_ledger: createConflictLedger({
+            verdict: input.verdict,
+            gaps,
+            remainingRisks,
+        }),
         ...(reproEvidence ? { repro_evidence: reproEvidence } : {}),
         ...(externalChecks.length > 0 ? { external_checks: externalChecks } : {}),
         explanation: explanationFromVerdict(input.verdict),
@@ -227,6 +257,11 @@ export function createDashboardEvidenceModel(input) {
     const receipts = input.latestReceipt ? [input.latestReceipt] : [];
     const sourceAnchorRisks = input.sourceAnchorRisks ?? [];
     const scopeDiffRisks = input.scopeDiffRisks ?? [];
+    const remainingRisks = [
+        ...input.remainingRisks,
+        ...sourceAnchorRemainingRisks(sourceAnchorRisks),
+        ...scopeDiffRemainingRisks(scopeDiffRisks),
+    ];
     return {
         schema_version: '1',
         source: 'dashboard_export',
@@ -242,11 +277,24 @@ export function createDashboardEvidenceModel(input) {
         receipts,
         skipped_checks: input.skippedChecks,
         gaps: input.gaps,
-        remaining_risks: [
-            ...input.remainingRisks,
-            ...sourceAnchorRemainingRisks(sourceAnchorRisks),
-            ...scopeDiffRemainingRisks(scopeDiffRisks),
-        ],
+        complexity_budget: createComplexityBudgetReport({
+            files: [],
+            summary: {
+                fileCount: 0,
+                publicSurfaceCount: input.changedSurfaces.length,
+                changeKinds: input.changedSurfaces.length > 0 ? ['unknown'] : [],
+                validationReasons: [],
+                updatePolicies: [],
+                driftChecks: [],
+                affectedContracts: [],
+            },
+        }),
+        remaining_risks: remainingRisks,
+        conflict_ledger: createConflictLedger({
+            verdict: input.verdict,
+            gaps: input.gaps,
+            remainingRisks,
+        }),
         explanation: explanationFromVerdict(input.verdict),
     };
 }

package/package.json

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