@urielsh/prodify 0.1.2 → 0.1.3

package/.prodify/contracts/architecture.contract.json

@@ -38,5 +38,13 @@
     "default_skills": [],
     "allowed_skills": [],
     "conditional_skills": []
-  }
+  },
+  "diff_validation_rules": {
+    "minimum_files_modified": 0,
+    "minimum_lines_changed": 0,
+    "must_create_files": false,
+    "required_structural_changes": []
+  },
+  "min_impact_score": 0,
+  "enforce_plan_units": false
 }

package/.prodify/contracts/diagnose.contract.json

@@ -38,5 +38,13 @@
     "default_skills": [],
     "allowed_skills": [],
     "conditional_skills": []
-  }
+  },
+  "diff_validation_rules": {
+    "minimum_files_modified": 0,
+    "minimum_lines_changed": 0,
+    "must_create_files": false,
+    "required_structural_changes": []
+  },
+  "min_impact_score": 0,
+  "enforce_plan_units": false
 }

package/.prodify/contracts/plan.contract.json

@@ -38,5 +38,13 @@
     "default_skills": [],
     "allowed_skills": [],
     "conditional_skills": []
-  }
+  },
+  "diff_validation_rules": {
+    "minimum_files_modified": 0,
+    "minimum_lines_changed": 0,
+    "must_create_files": false,
+    "required_structural_changes": []
+  },
+  "min_impact_score": 0,
+  "enforce_plan_units": false
 }

package/.prodify/contracts/refactor.contract.json

@@ -4,7 +4,7 @@
   "stage": "refactor",
   "task_id": "05-refactor",
   "source_path": ".prodify/contracts-src/refactor.contract.md",
-  "source_hash": "0445b0239d888c292430f8fe5ddba557813f0e19a6bafdb9c7a7ad7d10c627b1",
+  "source_hash": "3e752b6d837af065cd8eb623a2cfdd3aa3eaf48e71ed4e4513058af2e8f86f81",
   "required_artifacts": [
     {
       "path": ".prodify/artifacts/05-refactor.md",
@@ -34,6 +34,7 @@
     "Keep the diff minimal and behavior-preserving unless the plan says otherwise."
   ],
   "success_criteria": [
+    "The refactor introduces measurable structural improvement.",
     "The selected plan step is implemented fully.",
     "Unrelated files remain untouched."
   ],
@@ -41,5 +42,15 @@
     "default_skills": [],
     "allowed_skills": [],
     "conditional_skills": []
-  }
+  },
+  "diff_validation_rules": {
+    "minimum_files_modified": 1,
+    "minimum_lines_changed": 10,
+    "must_create_files": false,
+    "required_structural_changes": [
+      "module-boundary-created"
+    ]
+  },
+  "min_impact_score": 0,
+  "enforce_plan_units": true
 }

package/.prodify/contracts/understand.contract.json

@@ -38,5 +38,13 @@
     "default_skills": [],
     "allowed_skills": [],
     "conditional_skills": []
-  }
+  },
+  "diff_validation_rules": {
+    "minimum_files_modified": 0,
+    "minimum_lines_changed": 0,
+    "must_create_files": false,
+    "required_structural_changes": []
+  },
+  "min_impact_score": 0,
+  "enforce_plan_units": false
 }

package/.prodify/contracts/validate.contract.json

@@ -4,7 +4,7 @@
   "stage": "validate",
   "task_id": "06-validate",
   "source_path": ".prodify/contracts-src/validate.contract.md",
-  "source_hash": "10c9f32b2bbed054884a3c9c5ad5f195954ca0c702f14a783835d79a07aca2ed",
+  "source_hash": "4e1d5d6b56b147cbd6e0c98d35604e04e96eae0c6ae38353b7181da5359b3469",
   "required_artifacts": [
     {
       "path": ".prodify/artifacts/06-validate.md",
@@ -41,6 +41,7 @@
     "Validation must follow every refactor step."
   ],
   "success_criteria": [
+    "The measured impact score exceeds the minimum threshold.",
     "The result is strong enough to gate the next runtime transition.",
     "Validation records whether regressions were found."
   ],
@@ -48,5 +49,13 @@
     "default_skills": [],
     "allowed_skills": [],
     "conditional_skills": []
-  }
+  },
+  "diff_validation_rules": {
+    "minimum_files_modified": 0,
+    "minimum_lines_changed": 0,
+    "must_create_files": false,
+    "required_structural_changes": []
+  },
+  "min_impact_score": 1,
+  "enforce_plan_units": false
 }

package/.prodify/contracts-src/refactor.contract.md

@@ -20,12 +20,19 @@ allowed_write_roots:
   - tests/
 forbidden_writes:
   - .prodify/contracts/
+minimum_files_modified: 1
+minimum_lines_changed: 10
+must_create_files: false
+required_structural_changes:
+  - module-boundary-created
+enforce_plan_units: true
 policy_rules:
   - Execute exactly one selected step.
   - Keep the diff minimal and behavior-preserving unless the plan says otherwise.
 success_criteria:
   - The selected plan step is implemented fully.
   - Unrelated files remain untouched.
+  - The refactor introduces measurable structural improvement.
 ---
 # Refactor Contract
 

package/.prodify/contracts-src/validate.contract.md

@@ -23,12 +23,14 @@ allowed_write_roots:
   - .prodify/metrics/
 forbidden_writes:
   - src/
+min_impact_score: 1
 policy_rules:
   - Validation must follow every refactor step.
   - Critical regressions block forward progress.
 success_criteria:
   - Validation records whether regressions were found.
   - The result is strong enough to gate the next runtime transition.
+  - The measured impact score exceeds the minimum threshold.
 ---
 # Validate Contract
 

package/assets/presets/default/canonical/contracts-src/refactor.contract.md

@@ -20,12 +20,19 @@ allowed_write_roots:
   - tests/
 forbidden_writes:
   - .prodify/contracts/
+minimum_files_modified: 1
+minimum_lines_changed: 10
+must_create_files: false
+required_structural_changes:
+  - module-boundary-created
+enforce_plan_units: true
 policy_rules:
   - Execute exactly one selected step.
   - Keep the diff minimal and behavior-preserving unless the plan says otherwise.
 success_criteria:
   - The selected plan step is implemented fully.
   - Unrelated files remain untouched.
+  - The refactor introduces measurable structural improvement.
 skill_routing:
   default_skills:
     - refactoring-method

package/assets/presets/default/canonical/contracts-src/validate.contract.md

@@ -23,12 +23,14 @@ allowed_write_roots:
   - .prodify/metrics/
 forbidden_writes:
   - src/
+min_impact_score: 1
 policy_rules:
   - Validation must follow every refactor step.
   - Critical regressions block forward progress.
 success_criteria:
   - Validation records whether regressions were found.
   - The result is strong enough to gate the next runtime transition.
+  - The measured impact score exceeds the minimum threshold.
 skill_routing:
   default_skills:
     - test-hardening

package/dist/contracts/compiled-schema.js

@@ -15,6 +15,9 @@ export function validateCompiledContractShape(contract) {
         });
     }
     const record = contract;
+    const diffValidation = typeof record.diff_validation_rules === 'object' && record.diff_validation_rules !== null
+        ? record.diff_validation_rules
+        : {};
     return normalizeSourceContractDocument({
         document: {
             frontmatter: {
@@ -27,7 +30,13 @@ export function validateCompiledContractShape(contract) {
                 forbidden_writes: record.forbidden_writes,
                 policy_rules: record.policy_rules,
                 success_criteria: record.success_criteria,
-                skill_routing: record.skill_routing
+                skill_routing: record.skill_routing,
+                minimum_files_modified: diffValidation.minimum_files_modified ?? record.minimum_files_modified,
+                minimum_lines_changed: diffValidation.minimum_lines_changed ?? record.minimum_lines_changed,
+                must_create_files: diffValidation.must_create_files ?? record.must_create_files,
+                required_structural_changes: diffValidation.required_structural_changes ?? record.required_structural_changes,
+                min_impact_score: record.min_impact_score,
+                enforce_plan_units: record.enforce_plan_units
             },
             body: 'compiled-contract'
         },

package/dist/contracts/source-schema.js

@@ -26,6 +26,39 @@ function asOptionalStringArray(value, fieldName) {
     }
     return asStringArray(value, fieldName);
 }
+function asOptionalNonNegativeInteger(value, fieldName, fallback = 0) {
+    if (value === undefined || value === null || value === '') {
+        return fallback;
+    }
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < 0) {
+        throw new ProdifyError(`Contract frontmatter field "${fieldName}" must be a non-negative integer.`, {
+            code: 'CONTRACT_SCHEMA_INVALID'
+        });
+    }
+    return value;
+}
+function asOptionalNonNegativeNumber(value, fieldName, fallback = 0) {
+    if (value === undefined || value === null || value === '') {
+        return fallback;
+    }
+    if (typeof value !== 'number' || Number.isNaN(value) || value < 0) {
+        throw new ProdifyError(`Contract frontmatter field "${fieldName}" must be a non-negative number.`, {
+            code: 'CONTRACT_SCHEMA_INVALID'
+        });
+    }
+    return value;
+}
+function asOptionalBoolean(value, fieldName, fallback = false) {
+    if (value === undefined || value === null || value === '') {
+        return fallback;
+    }
+    if (typeof value !== 'boolean') {
+        throw new ProdifyError(`Contract frontmatter field "${fieldName}" must be a boolean.`, {
+            code: 'CONTRACT_SCHEMA_INVALID'
+        });
+    }
+    return value;
+}
 function asStage(value) {
     const stage = asString(value, 'stage');
     if (!CONTRACT_STAGE_NAMES.includes(stage)) {
@@ -106,6 +139,14 @@ export function normalizeSourceContractDocument(options) {
             : [],
         policy_rules: asStringArray(document.frontmatter.policy_rules, 'policy_rules'),
         success_criteria: asStringArray(document.frontmatter.success_criteria, 'success_criteria'),
-        skill_routing: normalizeStageSkillRouting(document.frontmatter.skill_routing)
+        skill_routing: normalizeStageSkillRouting(document.frontmatter.skill_routing),
+        diff_validation_rules: {
+            minimum_files_modified: asOptionalNonNegativeInteger(document.frontmatter.minimum_files_modified, 'minimum_files_modified'),
+            minimum_lines_changed: asOptionalNonNegativeInteger(document.frontmatter.minimum_lines_changed, 'minimum_lines_changed'),
+            must_create_files: asOptionalBoolean(document.frontmatter.must_create_files, 'must_create_files'),
+            required_structural_changes: asOptionalStringArray(document.frontmatter.required_structural_changes, 'required_structural_changes')
+        },
+        min_impact_score: asOptionalNonNegativeNumber(document.frontmatter.min_impact_score, 'min_impact_score'),
+        enforce_plan_units: asOptionalBoolean(document.frontmatter.enforce_plan_units, 'enforce_plan_units')
     };
 }

package/dist/core/diff-validator.js

@@ -0,0 +1,183 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { listFilesRecursive, pathExists, writeFileEnsuringDir } from './fs.js';
+import { normalizeRepoRelativePath, resolveRepoPath } from './paths.js';
+const DIFF_SNAPSHOT_SCHEMA_VERSION = '1';
+const BASELINE_SNAPSHOT_PATH = '.prodify/metrics/refactor-baseline.snapshot.json';
+const TRACKED_PREFIXES = ['src/', 'tests/', 'assets/'];
+const TRACKED_FILE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json', '.md', '.py', '.cs', '.css', '.scss', '.html']);
+const LAYER_DIRECTORY_NAMES = new Set(['application', 'domain', 'services', 'service', 'modules', 'module', 'adapters', 'infrastructure', 'core']);
+function isTrackedPath(relativePath) {
+    const normalized = normalizeRepoRelativePath(relativePath);
+    if (!TRACKED_PREFIXES.some((prefix) => normalized.startsWith(prefix))) {
+        return false;
+    }
+    return TRACKED_FILE_EXTENSIONS.has(path.extname(normalized));
+}
+function normalizeWhitespace(content) {
+    return content
+        .replace(/\s+/g, '')
+        .trim();
+}
+function toMap(snapshot) {
+    return new Map(snapshot.files.map((file) => [file.path, file]));
+}
+function diffLines(before, after) {
+    const beforeLines = before.replace(/\r\n/g, '\n').split('\n');
+    const afterLines = after.replace(/\r\n/g, '\n').split('\n');
+    const rows = beforeLines.length;
+    const cols = afterLines.length;
+    const dp = Array.from({ length: rows + 1 }, () => Array(cols + 1).fill(0));
+    for (let row = rows - 1; row >= 0; row -= 1) {
+        for (let col = cols - 1; col >= 0; col -= 1) {
+            if (beforeLines[row] === afterLines[col]) {
+                dp[row][col] = dp[row + 1][col + 1] + 1;
+            }
+            else {
+                dp[row][col] = Math.max(dp[row + 1][col], dp[row][col + 1]);
+            }
+        }
+    }
+    const common = dp[0][0];
+    return {
+        added: Math.max(0, afterLines.length - common),
+        removed: Math.max(0, beforeLines.length - common)
+    };
+}
+function collectDirectories(paths) {
+    return [...new Set(paths
+            .map((relativePath) => path.posix.dirname(relativePath))
+            .filter((directory) => directory !== '.' && directory !== ''))]
+        .sort((left, right) => left.localeCompare(right));
+}
+function detectStructuralChanges(options) {
+    const newDirectories = collectDirectories(options.addedPaths);
+    const newLayers = newDirectories.filter((directory) => LAYER_DIRECTORY_NAMES.has(path.posix.basename(directory)));
+    const filesWithReducedResponsibility = options.modifiedPaths
+        .filter((relativePath) => (options.removedLineCounts.get(relativePath) ?? 0) > 0)
+        .sort((left, right) => left.localeCompare(right));
+    const newModules = options.addedPaths
+        .filter((relativePath) => relativePath.startsWith('src/'))
+        .sort((left, right) => left.localeCompare(right));
+    const flags = new Set();
+    if (newDirectories.length > 0) {
+        flags.add('new-directories');
+    }
+    if (newLayers.length > 0) {
+        flags.add('new-layer-directories');
+        flags.add('module-boundary-created');
+    }
+    if (newModules.length > 0) {
+        flags.add('new-modules');
+        flags.add('module-boundary-created');
+    }
+    if (filesWithReducedResponsibility.length > 0) {
+        flags.add('responsibility-reduced');
+    }
+    return {
+        new_directories: newDirectories,
+        new_layer_directories: newLayers,
+        files_with_reduced_responsibility: filesWithReducedResponsibility,
+        new_modules: newModules,
+        structural_change_flags: [...flags].sort((left, right) => left.localeCompare(right))
+    };
+}
+function serializeSnapshot(snapshot) {
+    return `${JSON.stringify(snapshot, null, 2)}\n`;
+}
+export async function captureRepoSnapshot(repoRoot) {
+    const repoFiles = await listFilesRecursive(repoRoot);
+    const files = [];
+    for (const file of repoFiles) {
+        if (!isTrackedPath(file.relativePath)) {
+            continue;
+        }
+        files.push({
+            path: normalizeRepoRelativePath(file.relativePath),
+            content: await fs.readFile(file.fullPath, 'utf8')
+        });
+    }
+    files.sort((left, right) => left.path.localeCompare(right.path));
+    return {
+        schema_version: DIFF_SNAPSHOT_SCHEMA_VERSION,
+        files
+    };
+}
+export async function writeRefactorBaselineSnapshot(repoRoot) {
+    const snapshot = await captureRepoSnapshot(repoRoot);
+    await writeFileEnsuringDir(resolveRepoPath(repoRoot, BASELINE_SNAPSHOT_PATH), serializeSnapshot(snapshot));
+    return snapshot;
+}
+export async function readRefactorBaselineSnapshot(repoRoot) {
+    const baselinePath = resolveRepoPath(repoRoot, BASELINE_SNAPSHOT_PATH);
+    if (!(await pathExists(baselinePath))) {
+        return null;
+    }
+    return JSON.parse(await fs.readFile(baselinePath, 'utf8'));
+}
+export function diffSnapshots(before, after) {
+    const beforeMap = toMap(before);
+    const afterMap = toMap(after);
+    const allPaths = [...new Set([...beforeMap.keys(), ...afterMap.keys()])].sort((left, right) => left.localeCompare(right));
+    const modifiedPaths = [];
+    const addedPaths = [];
+    const deletedPaths = [];
+    const formattingOnlyPaths = [];
+    let linesAdded = 0;
+    let linesRemoved = 0;
+    const removedLineCounts = new Map();
+    for (const relativePath of allPaths) {
+        const beforeFile = beforeMap.get(relativePath);
+        const afterFile = afterMap.get(relativePath);
+        if (!beforeFile && afterFile) {
+            addedPaths.push(relativePath);
+            linesAdded += afterFile.content.replace(/\r\n/g, '\n').split('\n').length;
+            continue;
+        }
+        if (beforeFile && !afterFile) {
+            deletedPaths.push(relativePath);
+            const removed = beforeFile.content.replace(/\r\n/g, '\n').split('\n').length;
+            linesRemoved += removed;
+            removedLineCounts.set(relativePath, removed);
+            continue;
+        }
+        if (!beforeFile || !afterFile || beforeFile.content === afterFile.content) {
+            continue;
+        }
+        modifiedPaths.push(relativePath);
+        if (normalizeWhitespace(beforeFile.content) === normalizeWhitespace(afterFile.content)) {
+            formattingOnlyPaths.push(relativePath);
+            continue;
+        }
+        const lineDiff = diffLines(beforeFile.content, afterFile.content);
+        linesAdded += lineDiff.added;
+        linesRemoved += lineDiff.removed;
+        removedLineCounts.set(relativePath, lineDiff.removed);
+    }
+    return {
+        filesModified: modifiedPaths.length,
+        filesAdded: addedPaths.length,
+        filesDeleted: deletedPaths.length,
+        linesAdded,
+        linesRemoved,
+        modifiedPaths,
+        addedPaths,
+        deletedPaths,
+        formattingOnlyPaths,
+        structuralChanges: detectStructuralChanges({
+            addedPaths,
+            modifiedPaths,
+            beforeMap,
+            afterMap,
+            removedLineCounts
+        })
+    };
+}
+export async function diffAgainstRefactorBaseline(repoRoot) {
+    const baseline = await readRefactorBaselineSnapshot(repoRoot);
+    if (!baseline) {
+        return null;
+    }
+    const current = await captureRepoSnapshot(repoRoot);
+    return diffSnapshots(baseline, current);
+}

package/dist/core/plan-units.js

@@ -0,0 +1,64 @@
+import fs from 'node:fs/promises';
+import { resolveCanonicalPath } from './paths.js';
+function extractSection(markdown, heading) {
+    const normalized = markdown.replace(/\r\n/g, '\n');
+    const match = new RegExp(`^##\\s+${heading}\\s*$([\\s\\S]*?)(?=^##\\s+|\\Z)`, 'm').exec(normalized);
+    return match?.[1]?.trim() ?? '';
+}
+function normalizePlanUnits(section) {
+    const lines = section.split('\n');
+    const units = [];
+    let currentId = null;
+    let currentDescription = '';
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        const idMatch = /^-\s+Step ID:\s+(.+)$/.exec(line);
+        if (idMatch) {
+            if (currentId) {
+                units.push({
+                    id: currentId,
+                    description: currentDescription
+                });
+            }
+            currentId = idMatch[1].trim();
+            currentDescription = '';
+            continue;
+        }
+        if (!currentId) {
+            continue;
+        }
+        const descriptionMatch = /^-\s+Description:\s+(.+)$/.exec(line);
+        if (descriptionMatch) {
+            currentDescription = descriptionMatch[1].trim();
+        }
+    }
+    if (currentId) {
+        units.push({
+            id: currentId,
+            description: currentDescription
+        });
+    }
+    return units;
+}
+export async function readPlanUnits(repoRoot) {
+    const planPath = resolveCanonicalPath(repoRoot, '.prodify/artifacts/04-plan.md');
+    const markdown = await fs.readFile(planPath, 'utf8');
+    return normalizePlanUnits(extractSection(markdown, 'Step Breakdown'));
+}
+export async function readSelectedRefactorStep(repoRoot) {
+    const refactorPath = resolveCanonicalPath(repoRoot, '.prodify/artifacts/05-refactor.md');
+    const markdown = await fs.readFile(refactorPath, 'utf8');
+    const section = extractSection(markdown, 'Selected Step');
+    if (!section) {
+        return null;
+    }
+    const id = /-\s+Step ID:\s+(.+)/.exec(section)?.[1]?.trim() ?? null;
+    const description = /-\s+Description:\s+(.+)/.exec(section)?.[1]?.trim() ?? '';
+    if (!id) {
+        return null;
+    }
+    return {
+        id,
+        description
+    };
+}

package/dist/core/state.js

@@ -2,6 +2,8 @@ import fs from 'node:fs/promises';
 import { ProdifyError } from './errors.js';
 import { pathExists, writeFileEnsuringDir } from './fs.js';
 import { resolveCanonicalPath } from './paths.js';
+import { writeRefactorBaselineSnapshot } from './diff-validator.js';
+import { syncScoreArtifactsForRuntimeState } from '../scoring/model.js';
 export const RUNTIME_STATE_SCHEMA_VERSION = '2';
 export const RUNTIME_STATUS = {
     NOT_BOOTSTRAPPED: 'not_bootstrapped',
@@ -217,4 +219,8 @@ export async function readRuntimeState(repoRoot, { allowMissing = false, presetM
 export async function writeRuntimeState(repoRoot, state) {
     const statePath = resolveCanonicalPath(repoRoot, '.prodify/state.json');
     await writeFileEnsuringDir(statePath, serializeRuntimeState(state));
+    if (state.runtime.current_state === 'refactor_pending') {
+        await writeRefactorBaselineSnapshot(repoRoot);
+    }
+    await syncScoreArtifactsForRuntimeState(repoRoot, state);
 }

package/dist/core/status.js

@@ -11,6 +11,7 @@ import { readRuntimeState, RUNTIME_STATUS } from './state.js';
 import { inspectVersionStatus } from './version-checks.js';
 import { buildBootstrapPrompt, hasManualBootstrapGuidance } from './prompt-builder.js';
 import { getRuntimeProfile } from './targets.js';
+import { readScoreDelta } from '../scoring/model.js';
 function describeCanonicalHealth(missingPaths) {
     if (missingPaths.length === 0) {
         return 'healthy';
@@ -126,6 +127,14 @@ function describeStageValidation(report) {
         ? `last pass at ${runtime.last_validation.stage} (contract ${runtime.last_validation.contract_version})`
         : `failed at ${runtime.last_validation.stage}`;
 }
+function describeImpactScore(scoreDelta) {
+    if (!scoreDelta) {
+        return 'not available';
+    }
+    const threshold = scoreDelta.min_impact_score !== undefined ? `, threshold=${scoreDelta.min_impact_score}` : '';
+    const verdict = scoreDelta.passed === undefined ? '' : `, passed=${scoreDelta.passed}`;
+    return `${scoreDelta.baseline_score} -> ${scoreDelta.final_score} (delta ${scoreDelta.delta}${threshold}${verdict})`;
+}
 async function checkManualBootstrapGuidance(repoRoot) {
     const agentsPath = resolveCanonicalPath(repoRoot, '.prodify/AGENTS.md');
     if (!(await pathExists(agentsPath))) {
@@ -192,6 +201,7 @@ export async function inspectRepositoryStatus(repoRoot, options = {}) {
             bootstrapProfile,
             bootstrapPrompt,
             stageSkillResolution: null,
+            scoreDelta: null,
             recommendedNextAction: 'prodify init',
             presetMetadata: preset.metadata
         };
@@ -207,6 +217,7 @@ export async function inspectRepositoryStatus(repoRoot, options = {}) {
     let runtimeState = null;
     let runtimeStateError = null;
     let stageSkillResolution = null;
+    let scoreDelta = null;
     try {
         runtimeState = await readRuntimeState(repoRoot, {
             presetMetadata: preset.metadata
@@ -216,6 +227,7 @@ export async function inspectRepositoryStatus(repoRoot, options = {}) {
         runtimeStateError = error instanceof Error ? error : new Error(String(error));
     }
     const manualBootstrapReady = await checkManualBootstrapGuidance(repoRoot);
+    scoreDelta = await readScoreDelta(repoRoot);
     const canonicalOk = missingPaths.length === 0;
     if (canonicalOk && contractInventory.ok) {
         const skillStage = runtimeState?.runtime.current_stage
@@ -252,6 +264,7 @@ export async function inspectRepositoryStatus(repoRoot, options = {}) {
         bootstrapProfile,
         bootstrapPrompt,
         stageSkillResolution,
+        scoreDelta,
         recommendedNextAction: deriveNextAction({
             initialized,
             canonicalOk,
@@ -280,6 +293,7 @@ export function renderStatusReport(report) {
         `Skills active: ${describeActiveSkills(report)}`,
         `Execution state: ${describeRuntime(report.runtimeState?.runtime ?? null)}`,
         `Stage validation: ${describeStageValidation(report)}`,
+        `Impact score: ${describeImpactScore(report.scoreDelta)}`,
         `Manual bootstrap: ${report.manualBootstrapReady ? 'ready' : 'repair .prodify/AGENTS.md guidance'}`,
         `Bootstrap profile: ${report.bootstrapProfile}`,
         `Bootstrap prompt: ${report.bootstrapPrompt}`,