@urielsh/prodify 0.1.1 → 0.1.3

package/dist/scoring/model.js

@@ -1,237 +1,87 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { inspectCompiledContracts } from '../contracts/freshness.js';
 import { ProdifyError } from '../core/errors.js';
-import { listFilesRecursive, pathExists, writeFileEnsuringDir } from '../core/fs.js';
+import { pathExists, writeFileEnsuringDir } from '../core/fs.js';
 import { resolveRepoPath } from '../core/paths.js';
-const SCORE_SCHEMA_VERSION = '1';
+import { calculateRepositoryQuality } from './scoring-engine.js';
+const SCORE_SCHEMA_VERSION = '2';
 function roundScore(value) {
     return Math.round(value * 100) / 100;
 }
-function createMetric(options) {
-    const ratio = Math.max(0, Math.min(1, options.ratio));
-    const points = roundScore(options.weight * ratio);
-    return {
-        id: options.id,
-        label: options.label,
-        tool: options.tool,
-        weight: options.weight,
-        max_points: options.weight,
-        points,
-        status: ratio === 1 ? 'pass' : ratio === 0 ? 'fail' : 'partial',
-        details: options.details
-    };
-}
-async function detectEcosystems(repoRoot) {
-    const ecosystems = [];
-    if (await pathExists(resolveRepoPath(repoRoot, 'package.json'))) {
-        ecosystems.push('typescript-javascript');
-    }
-    const repoFiles = await listFilesRecursive(repoRoot);
-    if (repoFiles.some((file) => file.relativePath.endsWith('.py'))) {
-        ecosystems.push('python');
-    }
-    if (repoFiles.some((file) => file.relativePath.endsWith('.cs') || file.relativePath.endsWith('.csproj') || file.relativePath.endsWith('.sln'))) {
-        ecosystems.push('csharp');
-    }
-    return ecosystems.sort((left, right) => left.localeCompare(right));
+function serializeJson(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
 }
-async function buildEcosystemMetrics(repoRoot, ecosystems) {
-    const metrics = [];
-    const toolOutputs = [];
-    if (ecosystems.includes('typescript-javascript')) {
-        const packageJsonPath = resolveRepoPath(repoRoot, 'package.json');
-        const tsconfigPath = resolveRepoPath(repoRoot, 'tsconfig.json');
-        const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
-        const scripts = packageJson.scripts ?? {};
-        const hasBuild = typeof scripts.build === 'string' && scripts.build.length > 0;
-        const hasTest = typeof scripts.test === 'string' && scripts.test.length > 0;
-        const hasTsconfig = await pathExists(tsconfigPath);
-        const score = [hasBuild, hasTest, hasTsconfig].filter(Boolean).length / 3;
-        metrics.push(createMetric({
-            id: 'typescript-javascript',
-            label: 'TypeScript/JavaScript local tooling',
-            tool: 'package-json',
-            weight: 15,
-            ratio: score,
-            details: `build=${hasBuild}, test=${hasTest}, tsconfig=${hasTsconfig}`
-        }));
-        toolOutputs.push({
-            adapter: 'typescript-javascript',
-            details: {
-                build_script: hasBuild,
-                test_script: hasTest,
-                tsconfig: hasTsconfig
-            }
-        });
-    }
-    if (ecosystems.includes('python')) {
-        const hasPyproject = await pathExists(resolveRepoPath(repoRoot, 'pyproject.toml'));
-        const hasRequirements = await pathExists(resolveRepoPath(repoRoot, 'requirements.txt'));
-        const ratio = [hasPyproject, hasRequirements].filter(Boolean).length / 2;
-        metrics.push(createMetric({
-            id: 'python',
-            label: 'Python local tooling',
-            tool: 'filesystem',
-            weight: 7.5,
-            ratio,
-            details: `pyproject=${hasPyproject}, requirements=${hasRequirements}`
-        }));
-        toolOutputs.push({
-            adapter: 'python',
-            details: {
-                pyproject: hasPyproject,
-                requirements: hasRequirements
-            }
-        });
-    }
-    if (ecosystems.includes('csharp')) {
-        const repoFiles = await listFilesRecursive(repoRoot);
-        const hasSolution = repoFiles.some((file) => file.relativePath.endsWith('.sln'));
-        const hasProject = repoFiles.some((file) => file.relativePath.endsWith('.csproj'));
-        const ratio = [hasSolution, hasProject].filter(Boolean).length / 2;
-        metrics.push(createMetric({
-            id: 'csharp',
-            label: 'C# local tooling',
-            tool: 'filesystem',
-            weight: 7.5,
-            ratio,
-            details: `solution=${hasSolution}, project=${hasProject}`
-        }));
-        toolOutputs.push({
-            adapter: 'csharp',
-            details: {
-                solution: hasSolution,
-                project: hasProject
-            }
-        });
+async function removeIfExists(targetPath) {
+    if (await pathExists(targetPath)) {
+        await fs.rm(targetPath);
     }
-    return {
-        metrics,
-        toolOutputs
-    };
 }
-async function buildRepoHygieneMetric(repoRoot) {
-    const requiredSignals = ['README.md', 'LICENSE', 'tests', '.prodify/contracts-src'];
-    const available = await Promise.all(requiredSignals.map((relativePath) => pathExists(resolveRepoPath(repoRoot, relativePath))));
-    const ratio = available.filter(Boolean).length / requiredSignals.length;
+function createMetric(label, points, maxPoints, details) {
+    const normalizedPoints = roundScore(points);
     return {
-        metric: createMetric({
-            id: 'repo-hygiene',
-            label: 'Repository hygiene signals',
-            tool: 'filesystem',
-            weight: 20,
-            ratio,
-            details: requiredSignals.map((entry, index) => `${entry}=${available[index]}`).join(', ')
-        }),
-        toolOutput: {
-            adapter: 'filesystem',
-            details: Object.fromEntries(requiredSignals.map((entry, index) => [entry, available[index]]))
-        }
+        id: label.toLowerCase().replace(/\s+/g, '-'),
+        label,
+        tool: 'scoring-engine',
+        weight: maxPoints,
+        max_points: maxPoints,
+        points: normalizedPoints,
+        status: normalizedPoints >= maxPoints ? 'pass' : normalizedPoints <= 0 ? 'fail' : 'partial',
+        details
     };
 }
-function buildRuntimeMetric(runtimeState) {
-    const healthyState = runtimeState.runtime.current_state !== 'failed' && runtimeState.runtime.current_state !== 'blocked';
-    const ratio = healthyState ? 1 : 0;
-    return {
-        metric: createMetric({
-            id: 'runtime-state',
-            label: 'Contract-driven runtime state',
-            tool: 'state-json',
-            weight: 25,
-            ratio,
-            details: `current_state=${runtimeState.runtime.current_state}, status=${runtimeState.runtime.status}`
-        }),
-        toolOutput: {
-            adapter: 'state-json',
-            details: {
-                current_state: runtimeState.runtime.current_state,
-                status: runtimeState.runtime.status,
-                last_validation_result: runtimeState.runtime.last_validation_result
-            }
-        }
-    };
-}
-function buildValidationMetric(runtimeState) {
-    const passed = runtimeState.runtime.last_validation?.passed === true;
-    const finalReady = runtimeState.runtime.current_state === 'validate_complete' || runtimeState.runtime.current_state === 'completed';
-    const ratio = passed ? (finalReady ? 1 : 0.5) : 0;
-    return {
-        metric: createMetric({
-            id: 'validation-gate',
-            label: 'Validated contract completion',
-            tool: 'state-json',
-            weight: 10,
-            ratio,
-            details: `passed=${passed}, final_ready=${finalReady}`
-        }),
-        toolOutput: {
-            adapter: 'validation-gate',
-            details: {
-                passed,
-                final_ready: finalReady
-            }
-        }
-    };
+function toSnapshotMetrics(score) {
+    return [
+        createMetric('Structure', score.breakdown.structure * (score.weights.structure / 100), score.weights.structure, `modules=${score.signals.module_count}, avg_directory_depth=${score.signals.average_directory_depth}`),
+        createMetric('Maintainability', score.breakdown.maintainability * (score.weights.maintainability / 100), score.weights.maintainability, `avg_function_length=${score.signals.average_function_length}`),
+        createMetric('Complexity', score.breakdown.complexity * (score.weights.complexity / 100), score.weights.complexity, `dependency_depth=${score.signals.dependency_depth}, avg_imports=${score.signals.average_imports_per_module}`),
+        createMetric('Testability', score.breakdown.testability * (score.weights.testability / 100), score.weights.testability, `test_file_ratio=${score.signals.test_file_ratio}`)
+    ];
 }
 export async function calculateLocalScore(repoRoot, { kind, runtimeState }) {
-    const contractInventory = await inspectCompiledContracts(repoRoot);
-    const ecosystems = await detectEcosystems(repoRoot);
-    const metrics = [];
-    const toolOutputs = [];
-    metrics.push(createMetric({
-        id: 'contracts',
-        label: 'Compiled contract health',
-        tool: 'contract-compiler',
-        weight: 30,
-        ratio: contractInventory.ok ? 1 : Math.max(0, 1 - ((contractInventory.missingCompiledStages.length + contractInventory.staleStages.length) / 6)),
-        details: `source=${contractInventory.sourceCount}, compiled=${contractInventory.compiledCount}, stale=${contractInventory.staleStages.length}, missing=${contractInventory.missingCompiledStages.length}`
-    }));
-    toolOutputs.push({
-        adapter: 'contract-compiler',
-        details: {
-            ok: contractInventory.ok,
-            sourceCount: contractInventory.sourceCount,
-            compiledCount: contractInventory.compiledCount,
-            staleStages: contractInventory.staleStages,
-            missingCompiledStages: contractInventory.missingCompiledStages,
-            missingSourceStages: contractInventory.missingSourceStages,
-            invalidStages: contractInventory.invalidStages
-        }
-    });
-    const runtimeMetric = buildRuntimeMetric(runtimeState);
-    metrics.push(runtimeMetric.metric);
-    toolOutputs.push(runtimeMetric.toolOutput);
-    const validationMetric = buildValidationMetric(runtimeState);
-    metrics.push(validationMetric.metric);
-    toolOutputs.push(validationMetric.toolOutput);
-    const hygieneMetric = await buildRepoHygieneMetric(repoRoot);
-    metrics.push(hygieneMetric.metric);
-    toolOutputs.push(hygieneMetric.toolOutput);
-    const ecosystemMetrics = await buildEcosystemMetrics(repoRoot, ecosystems);
-    metrics.push(...ecosystemMetrics.metrics);
-    toolOutputs.push(...ecosystemMetrics.toolOutputs);
-    const totalScore = roundScore(metrics.reduce((sum, metric) => sum + metric.points, 0));
-    const maxScore = roundScore(metrics.reduce((sum, metric) => sum + metric.max_points, 0));
     if (kind === 'final' && !(runtimeState.runtime.last_validation?.passed && (runtimeState.runtime.current_state === 'validate_complete' || runtimeState.runtime.current_state === 'completed'))) {
         throw new ProdifyError('Final scoring requires a validated runtime state at validate_complete or completed.', {
             code: 'SCORING_STATE_INVALID'
         });
     }
+    const quality = await calculateRepositoryQuality(repoRoot);
+    const snapshot = {
+        schema_version: SCORE_SCHEMA_VERSION,
+        kind,
+        ecosystems: ['repository'],
+        total_score: quality.total_score,
+        max_score: quality.max_score,
+        breakdown: quality.breakdown,
+        weights: quality.weights,
+        signals: quality.signals,
+        metrics: toSnapshotMetrics(quality)
+    };
     return {
-        snapshot: {
-            schema_version: SCORE_SCHEMA_VERSION,
-            kind,
-            ecosystems,
-            total_score: totalScore,
-            max_score: maxScore,
-            metrics
-        },
-        toolOutputs
+        snapshot,
+        toolOutputs: [{
+                adapter: 'scoring-engine',
+                details: {
+                    kind,
+                    breakdown: quality.breakdown,
+                    weights: quality.weights,
+                    signals: quality.signals
+                }
+            }]
     };
 }
-function serializeJson(value) {
-    return `${JSON.stringify(value, null, 2)}\n`;
+export async function calculateCurrentImpactDelta(repoRoot) {
+    const metricsDir = resolveRepoPath(repoRoot, '.prodify/metrics');
+    const baselinePath = path.join(metricsDir, 'baseline.score.json');
+    if (!(await pathExists(baselinePath))) {
+        return null;
+    }
+    const baseline = JSON.parse(await fs.readFile(baselinePath, 'utf8'));
+    const current = await calculateRepositoryQuality(repoRoot);
+    return {
+        schema_version: SCORE_SCHEMA_VERSION,
+        baseline_score: baseline.total_score,
+        final_score: current.total_score,
+        delta: roundScore(current.total_score - baseline.total_score)
+    };
 }
 export async function writeScoreSnapshot(repoRoot, { kind, runtimeState }) {
     const { snapshot, toolOutputs } = await calculateLocalScore(repoRoot, {
@@ -247,16 +97,47 @@ export async function writeScoreSnapshot(repoRoot, { kind, runtimeState }) {
     }));
     return snapshot;
 }
-export async function writeScoreDelta(repoRoot) {
+export async function writeScoreDelta(repoRoot, options = {}) {
     const metricsDir = resolveRepoPath(repoRoot, '.prodify/metrics');
     const baseline = JSON.parse(await fs.readFile(path.join(metricsDir, 'baseline.score.json'), 'utf8'));
     const final = JSON.parse(await fs.readFile(path.join(metricsDir, 'final.score.json'), 'utf8'));
+    const deltaValue = roundScore(final.total_score - baseline.total_score);
+    const threshold = options.minImpactScore;
     const delta = {
         schema_version: SCORE_SCHEMA_VERSION,
         baseline_score: baseline.total_score,
         final_score: final.total_score,
-        delta: roundScore(final.total_score - baseline.total_score)
+        delta: deltaValue,
+        ...(threshold !== undefined ? {
+            min_impact_score: threshold,
+            passed: deltaValue >= threshold
+        } : {})
     };
     await writeFileEnsuringDir(path.join(metricsDir, 'delta.json'), serializeJson(delta));
     return delta;
 }
+export async function readScoreDelta(repoRoot) {
+    const deltaPath = resolveRepoPath(repoRoot, '.prodify/metrics/delta.json');
+    if (!(await pathExists(deltaPath))) {
+        return null;
+    }
+    return JSON.parse(await fs.readFile(deltaPath, 'utf8'));
+}
+export async function syncScoreArtifactsForRuntimeState(repoRoot, runtimeState) {
+    if (runtimeState.runtime.current_state === 'bootstrapped' || runtimeState.runtime.current_state === 'understand_pending') {
+        await writeScoreSnapshot(repoRoot, {
+            kind: 'baseline',
+            runtimeState
+        });
+        await removeIfExists(resolveRepoPath(repoRoot, '.prodify/metrics/final.score.json'));
+        await removeIfExists(resolveRepoPath(repoRoot, '.prodify/metrics/final.tools.json'));
+        await removeIfExists(resolveRepoPath(repoRoot, '.prodify/metrics/delta.json'));
+    }
+    if (runtimeState.runtime.last_validation?.passed && (runtimeState.runtime.current_state === 'validate_complete' || runtimeState.runtime.current_state === 'completed')) {
+        await writeScoreSnapshot(repoRoot, {
+            kind: 'final',
+            runtimeState
+        });
+        await writeScoreDelta(repoRoot);
+    }
+}

package/dist/scoring/scoring-engine.js

@@ -0,0 +1,158 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { listFilesRecursive } from '../core/fs.js';
+import { normalizeRepoRelativePath } from '../core/paths.js';
+const SCORE_WEIGHTS = {
+    structure: 30,
+    maintainability: 30,
+    complexity: 20,
+    testability: 20
+};
+const CODE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.py', '.cs']);
+function round(value) {
+    return Math.round(value * 100) / 100;
+}
+function clamp(value, min = 0, max = 100) {
+    return Math.max(min, Math.min(max, value));
+}
+function scoreInverse(value, ideal, tolerance) {
+    if (value <= ideal) {
+        return 100;
+    }
+    return clamp(100 - (((value - ideal) / tolerance) * 100));
+}
+function extractImports(content) {
+    return content
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith('import ') || line.startsWith('export ') || line.includes('require('));
+}
+function extractDependencyDepth(imports) {
+    const relativeImports = imports
+        .map((line) => /from\s+['"](.+?)['"]/.exec(line)?.[1] ?? /require\(['"](.+?)['"]\)/.exec(line)?.[1] ?? '')
+        .filter((specifier) => specifier.startsWith('./') || specifier.startsWith('../'));
+    if (relativeImports.length === 0) {
+        return 0;
+    }
+    return Math.max(...relativeImports.map((specifier) => specifier.split('/').filter((segment) => segment === '..').length));
+}
+function extractFunctionLengths(content) {
+    const lines = content.replace(/\r\n/g, '\n').split('\n');
+    const lengths = [];
+    let captureDepth = 0;
+    let currentLength = 0;
+    let tracking = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        const startsFunction = /^(export\s+)?(async\s+)?function\s+\w+/.test(trimmed)
+            || /^(export\s+)?const\s+\w+\s*=\s*(async\s*)?\(/.test(trimmed)
+            || /^(public\s+|private\s+|protected\s+)?(async\s+)?\w+\s*\(.*\)\s*\{?$/.test(trimmed);
+        if (startsFunction && trimmed.includes('{')) {
+            tracking = true;
+            currentLength = 1;
+            captureDepth = (trimmed.match(/\{/g) ?? []).length - (trimmed.match(/\}/g) ?? []).length;
+            if (captureDepth <= 0) {
+                lengths.push(currentLength);
+                tracking = false;
+                currentLength = 0;
+                captureDepth = 0;
+            }
+            continue;
+        }
+        if (!tracking) {
+            continue;
+        }
+        currentLength += 1;
+        captureDepth += (trimmed.match(/\{/g) ?? []).length;
+        captureDepth -= (trimmed.match(/\}/g) ?? []).length;
+        if (captureDepth <= 0) {
+            lengths.push(currentLength);
+            tracking = false;
+            currentLength = 0;
+            captureDepth = 0;
+        }
+    }
+    return lengths;
+}
+async function collectSourceFiles(repoRoot) {
+    const allFiles = await listFilesRecursive(repoRoot);
+    const sourceFiles = [];
+    for (const file of allFiles) {
+        const relativePath = normalizeRepoRelativePath(file.relativePath);
+        if (relativePath.startsWith('.git/')
+            || relativePath.startsWith('.prodify/')
+            || relativePath.startsWith('.agent/')
+            || relativePath.startsWith('.codex/')
+            || relativePath.startsWith('dist/')
+            || relativePath.startsWith('node_modules/')) {
+            continue;
+        }
+        if (!CODE_EXTENSIONS.has(path.extname(relativePath))) {
+            continue;
+        }
+        sourceFiles.push({
+            path: relativePath,
+            content: await fs.readFile(file.fullPath, 'utf8')
+        });
+    }
+    return sourceFiles.sort((left, right) => left.path.localeCompare(right.path));
+}
+function deriveSignals(sourceFiles) {
+    const functionLengths = sourceFiles.flatMap((file) => extractFunctionLengths(file.content));
+    const allImports = sourceFiles.map((file) => extractImports(file.content));
+    const moduleCount = sourceFiles.length;
+    const averageFunctionLength = functionLengths.length === 0
+        ? 0
+        : functionLengths.reduce((sum, value) => sum + value, 0) / functionLengths.length;
+    const averageDirectoryDepth = moduleCount === 0
+        ? 0
+        : sourceFiles
+            .map((file) => path.posix.dirname(file.path))
+            .map((directory) => directory === '.' ? 0 : directory.split('/').length)
+            .reduce((sum, depth) => sum + depth, 0) / moduleCount;
+    const dependencyDepth = allImports.length === 0
+        ? 0
+        : Math.max(...allImports.map((imports) => extractDependencyDepth(imports)));
+    const averageImportsPerModule = moduleCount === 0
+        ? 0
+        : allImports.reduce((sum, imports) => sum + imports.length, 0) / moduleCount;
+    const testFiles = sourceFiles.filter((file) => file.path.startsWith('tests/') || /\.test\./.test(file.path)).length;
+    const sourceModules = Math.max(1, sourceFiles.filter((file) => file.path.startsWith('src/')).length);
+    const testFileRatio = testFiles / sourceModules;
+    return {
+        average_function_length: round(averageFunctionLength),
+        module_count: moduleCount,
+        average_directory_depth: round(averageDirectoryDepth),
+        dependency_depth: dependencyDepth,
+        average_imports_per_module: round(averageImportsPerModule),
+        test_file_ratio: round(testFileRatio)
+    };
+}
+function buildBreakdown(signals) {
+    const structure = round(((clamp(signals.module_count * 5, 0, 60)) + clamp(signals.average_directory_depth * 15, 0, 40)));
+    const maintainability = round((scoreInverse(signals.average_function_length, 18, 40) * 0.7) + (scoreInverse(signals.average_imports_per_module, 4, 8) * 0.3));
+    const complexity = round((scoreInverse(signals.dependency_depth, 1, 5) * 0.6) + (scoreInverse(signals.average_imports_per_module, 4, 8) * 0.4));
+    const testability = round(clamp(signals.test_file_ratio * 100, 0, 100));
+    return {
+        structure: clamp(structure),
+        maintainability: clamp(maintainability),
+        complexity: clamp(complexity),
+        testability: clamp(testability)
+    };
+}
+export async function calculateRepositoryQuality(repoRoot) {
+    const sourceFiles = await collectSourceFiles(repoRoot);
+    const signals = deriveSignals(sourceFiles);
+    const breakdown = buildBreakdown(signals);
+    const total = round((breakdown.structure * (SCORE_WEIGHTS.structure / 100))
+        + (breakdown.maintainability * (SCORE_WEIGHTS.maintainability / 100))
+        + (breakdown.complexity * (SCORE_WEIGHTS.complexity / 100))
+        + (breakdown.testability * (SCORE_WEIGHTS.testability / 100)));
+    return {
+        breakdown,
+        signals,
+        total_score: total,
+        max_score: 100,
+        weights: SCORE_WEIGHTS
+    };
+}

package/docs/diff-validator-design.md

@@ -0,0 +1,44 @@
+# Diff Validator Design
+
+## Purpose
+
+Prodify must reject refactor stages that only move whitespace, touch too few files, or fail to create meaningful structural change.
+
+## Snapshot Model
+
+- Capture a tracked repository snapshot before refactor.
+- Compare the current tracked tree against that snapshot.
+- Tracked roots:
+  - `src/`
+  - `tests/`
+  - `assets/`
+
+## Deterministic Outputs
+
+- `filesModified`
+- `filesAdded`
+- `filesDeleted`
+- `linesAdded`
+- `linesRemoved`
+- `formattingOnlyPaths`
+- `structuralChanges`
+
+## Structural Change Flags
+
+- `new-directories`
+- `new-layer-directories`
+- `new-modules`
+- `module-boundary-created`
+- `responsibility-reduced`
+
+## Validation Rules
+
+- minimum files modified
+- minimum lines changed
+- optional file-creation requirement
+- required structural flags
+- formatting-only changes fail
+
+## Plan Coupling
+
+Refactor validation also confirms that the selected step in `05-refactor.md` maps to a real plan unit from `04-plan.md`.

package/docs/impact-scoring-design.md

@@ -0,0 +1,38 @@
+# Impact Scoring Design
+
+## Purpose
+
+Prodify should measure whether a run actually improved repository quality instead of only checking that files changed.
+
+## Breakdown
+
+- `structure`
+- `maintainability`
+- `complexity`
+- `testability`
+
+## Formula
+
+```text
+total =
+  structure * 0.30 +
+  maintainability * 0.30 +
+  complexity * 0.20 +
+  testability * 0.20
+```
+
+## Signals
+
+- average function length
+- module count
+- average directory depth
+- dependency depth
+- average imports per module
+- test file ratio
+
+## Runtime Integration
+
+- Write baseline score when a run is bootstrapped.
+- Write final score and delta after validated completion.
+- Enforce `min_impact_score` during validation.
+- Show stored score delta in `prodify status`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@urielsh/prodify",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "license": "Apache-2.0",
   "private": false,
   "type": "module",

package/src/commands/setup-agent.ts

@@ -22,6 +22,9 @@ export async function runSetupAgentCommand(args: string[], context: CommandConte
   context.stdout.write(`Status: ${result.alreadyConfigured ? 'already configured globally; refreshed' : 'configured globally'}\n`);
   context.stdout.write(`Configured agents: ${result.configuredAgents.join(', ')}\n`);
   context.stdout.write(`Registry: ${result.statePath}\n`);
+  if (result.installedPaths.length > 0) {
+    context.stdout.write(`Installed runtime commands: ${result.installedPaths.join(', ')}\n`);
+  }
   context.stdout.write('Repo impact: none\n');
   context.stdout.write('Next step: run `prodify init` in a repository, then open that agent and use `$prodify-init`.\n');
   return 0;

package/src/contracts/compiled-schema.ts

@@ -20,6 +20,9 @@ export function validateCompiledContractShape(contract: unknown): CompiledStageC
   }
 
   const record = contract as Record<string, unknown>;
+  const diffValidation = typeof record.diff_validation_rules === 'object' && record.diff_validation_rules !== null
+    ? record.diff_validation_rules as Record<string, unknown>
+    : {};
   return normalizeSourceContractDocument({
     document: {
       frontmatter: {
@@ -32,7 +35,13 @@ export function validateCompiledContractShape(contract: unknown): CompiledStageC
         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'
     },