mustflow 2.70.0 → 2.74.0

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.0",
   "description": "Agent workflow documents and CLI for mustflow repository roots.",
   "type": "module",
   "license": "MIT-0",

package/schemas/README.md

@@ -7,12 +7,14 @@ Current schemas:
 
 - `doctor-report.schema.json`: output of `mf doctor --json`
 - `adapter-compatibility-report.schema.json`: output of `mf adapters status --json`
-- `context-report.schema.json`: output of `mf context --json`, including prompt-cache profiles and optional cache audit data
+- `context-report.schema.json`: output of `mf context --json`, including context trust metadata, prompt-cache profiles, and optional cache audit data
 - `workspace-summary.schema.json`: output of `mf api workspace-summary --json`
 - `command-catalog.schema.json`: output of `mf api command-catalog --json`
-- `verification-plan.schema.json`: output of `mf api verification-plan --changed --json`
+- `verification-plan.schema.json`: output of `mf api verification-plan --changed --json`, including
+  risk-priced evidence assessment for the changed surfaces and selected command contract
 - `latest-evidence.schema.json`: output of `mf api latest-evidence --json`
-- `diff-risk.schema.json`: output of `mf api diff-risk --changed --json`
+- `diff-risk.schema.json`: output of `mf api diff-risk --changed --json`, including a read-only
+  complexity budget for structural additions
 - `health.schema.json`: output of `mf api health --json`
 - `locks.schema.json`: output of `mf api locks --json`
 - `api-serve-response.schema.json`: each newline-delimited response from `mf api serve --stdio`
@@ -29,7 +31,8 @@ Current schemas:
 - `next-report.schema.json`: output of `mf next --json`, containing the next safe action,
   changed-file verification gaps, and read-only command recommendations
 - `evidence-report.schema.json`: output of `mf evidence --changed --json`, containing verification
-  requirements, latest bounded evidence, receipts, remaining risks, and gaps without running commands
+  requirements, risk-priced evidence assessment, latest bounded evidence, failure replay capsules,
+  conflict ledgers, receipts, remaining risks, and gaps without running commands
 - `workspace-status.schema.json`: output of `mf workspace status --json`, containing configured
   workspace roots, discovered nested repositories, and per-root command-contract readiness without
   granting command authority
@@ -38,11 +41,12 @@ Current schemas:
   strings
 - `workspace-verification-plan.schema.json`: output of
   `mf workspace verify --changed --plan-only --json`, containing per-root changed-file
-  verification plans without running commands or granting parent-to-child command authority
+  verification plans and risk-priced evidence assessment without running commands or granting
+  parent-to-child command authority
 - `dashboard-export.schema.json`: bounded static export written by `mf dashboard --export-json <path>`,
   including output policy, redaction and truncation metadata, the dashboard harness report, and
-  the evidence-based completion verdict, evidence model, and conservative coverage matrix for the
-  exported snapshot
+  the evidence-based completion verdict, conflict ledger, complexity budget, evidence model, and
+  conservative coverage matrix for the exported snapshot
 - `classify-report.schema.json`: output of `mf classify --changed --json` and  
   `mf classify <path...> --json`
 - `impact-report.schema.json`: output of `mf impact --changed --json` and  
@@ -52,6 +56,12 @@ Current schemas:
 - `quality-gaming-report.schema.json`: output of `mf quality check --json`, containing changed-file
   quality-gaming risks such as line stuffing, validation suppressions, test bypass markers, type
   escapes, generated/vendor logic, empty catch swallowing, and placeholder implementations
+- `script-pack-catalog.schema.json`: output of `mf script-pack list --json`, containing bundled
+  script-pack ids, script refs, action names, usage strings, and associated report schemas
+- `text-budget-report.schema.json`: output of
+  `mf script-pack run core/text-budget check <path...> --json`, containing
+  exact text-budget metrics, input content hashes, policy metadata, findings, and JSON Pointer field
+  checks for bounded user-facing strings and generated text
 - `skill-route-report.schema.json`: output of `mf skill route --json`, containing compact route
   candidates, selected main and adjunct skills, score breakdowns, route read plans, and source
   route shards without granting command authority or replacing selected `SKILL.md` reads
@@ -59,7 +69,7 @@ Current schemas:
   skill-route golden cases with required and forbidden route expectations
 - `latest-run-pointer.schema.json`: `.mustflow/state/runs/latest.json` when `mf verify` writes a
   pointer to the latest verify run bundle, including the verify completion verdict, evidence model,
-  and coverage matrix
+  complexity budget, failure replay capsule, conflict ledger, and coverage matrix
 - `handoff-validation-report.schema.json`: output of  
   `mf handoff validate <path> --json`
 - `version-sources-report.schema.json`: output of `mf version-sources --json`
@@ -69,14 +79,16 @@ Current schemas:
   `mf explain surface --json`, and `mf explain why <target> --json`. Verify explanations include the shared
   `decisionGraph` evidence model; latest-failure explanations include bounded latest-run metadata only.
 - `verify-report.schema.json`: output of `mf verify --reason <event> --json`, including an
-  explicit execution aggregate, evidence-based completion verdict, and evidence model with a
+  explicit execution aggregate, risk-priced evidence assessment, evidence-based completion verdict,
+  failure replay capsule, conflict ledger, and evidence model with a read-only complexity budget and
   conservative coverage matrix for the selected receipts and skipped checks
 - `verify-run-manifest.schema.json`: `.mustflow/state/runs/verify-*/manifest.json`, including
-  the same execution aggregate, completion verdict, evidence model, and coverage matrix as the verify report
+  the same execution aggregate, risk assessment, completion verdict, failure replay capsule,
+  conflict ledger, evidence model, complexity budget, and coverage matrix as the verify report
 - `change-verification-report.schema.json`: output of `mf verify --reason <event> --plan-only --json` and  
   `mf verify --from-classification <classify-report.json> --plan-only --json`, including the `decision_graph` that links
   changed surfaces, classification reasons, command candidates, eligibility, selected or not-selected state,
-  effects, and gaps.
+  effects, gaps, and risk-priced evidence requirements.
   Local-index command-effect graphs and command preconditions are explanation-only and cannot grant command authority.
 
 These schemas define stable, automation-facing fields. Human-readable command  

package/schemas/change-verification-report.schema.json

@@ -55,6 +55,9 @@
         "$ref": "#/$defs/verificationGap"
       }
     },
+    "risk_assessment": {
+      "$ref": "#/$defs/riskAssessment"
+    },
     "schedule": {
       "$ref": "#/$defs/verificationSchedule"
     },
@@ -328,6 +331,32 @@
         }
       }
     },
+    "riskAssessment": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "schema_version",
+        "source",
+        "level",
+        "reasons",
+        "required_evidence",
+        "blocking_gaps",
+        "rollback_required",
+        "human_approval_required",
+        "manual_review_required"
+      ],
+      "properties": {
+        "schema_version": { "const": "1" },
+        "source": { "const": "change_classification_and_command_contract" },
+        "level": { "enum": ["low", "medium", "high", "critical"] },
+        "reasons": { "$ref": "#/$defs/stringArray" },
+        "required_evidence": { "$ref": "#/$defs/stringArray" },
+        "blocking_gaps": { "$ref": "#/$defs/stringArray" },
+        "rollback_required": { "type": "boolean" },
+        "human_approval_required": { "type": "boolean" },
+        "manual_review_required": { "type": "boolean" }
+      }
+    },
     "testSelectionReport": {
       "type": "object",
       "additionalProperties": false,

package/schemas/context-report.schema.json

@@ -121,7 +121,61 @@
       "required": ["path", "exists"],
       "properties": {
         "path": { "type": "string" },
-        "exists": { "type": "boolean" }
+        "exists": { "type": "boolean" },
+        "trust": { "$ref": "#/$defs/contextTrust" }
+      }
+    },
+    "contextTrust": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "source_kind",
+        "authority",
+        "cache_layer",
+        "freshness",
+        "content_hash",
+        "can_instruct_agent",
+        "grants_command_authority",
+        "notes"
+      ],
+      "properties": {
+        "source_kind": {
+          "enum": [
+            "workflow_file",
+            "command_contract",
+            "skill_file",
+            "context_file",
+            "generated_cache",
+            "generated_state",
+            "source_placeholder",
+            "runtime_volatile",
+            "unknown_file"
+          ]
+        },
+        "authority": {
+          "enum": [
+            "binding",
+            "workflow_policy",
+            "configuration",
+            "command_contract",
+            "procedure",
+            "contextual",
+            "hint",
+            "generated",
+            "evidence_only",
+            "volatile",
+            "unknown"
+          ]
+        },
+        "cache_layer": { "enum": ["stable", "task", "volatile", null] },
+        "freshness": { "enum": ["hash_verified", "missing", "dynamic", "runtime_volatile", "unchecked"] },
+        "content_hash": { "type": ["string", "null"] },
+        "can_instruct_agent": { "type": "boolean" },
+        "grants_command_authority": { "type": "boolean" },
+        "notes": {
+          "type": "array",
+          "items": { "type": "string" }
+        }
       }
     },
     "intentContext": {
@@ -364,7 +418,8 @@
       "properties": {
         "path": { "type": "string" },
         "exists": { "type": "boolean" },
-        "content_hash": { "type": ["string", "null"] }
+        "content_hash": { "type": ["string", "null"] },
+        "trust": { "$ref": "#/$defs/contextTrust" }
       }
     },
     "taskContextLayer": {
@@ -617,6 +672,7 @@
           "type": "array",
           "items": { "type": "string" }
         },
+        "trust": { "$ref": "#/$defs/contextTrust" },
         "issue": { "type": ["string", "null"] }
       }
     },

package/schemas/dashboard-export.schema.json

@@ -197,6 +197,9 @@
           "type": "array",
           "items": { "$ref": "#/$defs/evidenceGap" }
         },
+        "complexity_budget": { "$ref": "verify-report.schema.json#/$defs/complexityBudget" },
+        "risk_assessment": { "$ref": "#/$defs/riskAssessment" },
+        "conflict_ledger": { "$ref": "verify-report.schema.json#/$defs/conflictLedger" },
         "remaining_risks": {
           "type": "array",
           "items": { "$ref": "#/$defs/evidenceRemainingRisk" }
@@ -304,6 +307,41 @@
         "detail": { "type": "string" }
       }
     },
+    "riskAssessment": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "schema_version",
+        "source",
+        "level",
+        "reasons",
+        "required_evidence",
+        "blocking_gaps",
+        "rollback_required",
+        "human_approval_required",
+        "manual_review_required"
+      ],
+      "properties": {
+        "schema_version": { "const": "1" },
+        "source": { "const": "change_classification_and_command_contract" },
+        "level": { "enum": ["low", "medium", "high", "critical"] },
+        "reasons": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "required_evidence": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "blocking_gaps": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "rollback_required": { "type": "boolean" },
+        "human_approval_required": { "type": "boolean" },
+        "manual_review_required": { "type": "boolean" }
+      }
+    },
     "evidenceExplanation": {
       "type": "object",
       "additionalProperties": false,
@@ -377,6 +415,7 @@
             "receipt_binding_risk_count": { "type": "integer" },
             "stale_receipt_count": { "type": "integer" },
             "plan_mismatch_count": { "type": "integer" },
+            "risk_priced_evidence_risk_count": { "type": "integer" },
             "risks": { "$ref": "#/$defs/completionVerdictRisks" },
             "receipt_binding": { "$ref": "#/$defs/completionVerdictReceiptBinding" },
             "latest_run_status": { "type": ["string", "null"] }
@@ -434,7 +473,8 @@
         "write_drift": { "type": "integer" },
         "receipt_binding": { "type": "integer" },
         "stale_receipt": { "type": "integer" },
-        "plan_mismatch": { "type": "integer" }
+        "plan_mismatch": { "type": "integer" },
+        "risk_priced_evidence": { "type": "integer" }
       }
     },
     "completionVerdictReceiptBinding": {
@@ -505,6 +545,7 @@
           "properties": {
             "completion_verdict": { "$ref": "#/$defs/completionVerdict" },
             "evidence_model": { "$ref": "#/$defs/evidenceModel" },
+            "conflict_ledger": { "$ref": "verify-report.schema.json#/$defs/conflictLedger" },
             "changed_file_count": { "type": "integer" },
             "changed_surfaces": { "$ref": "#/$defs/stringArray" },
             "decision_graph_summary": {