@urielsh/prodify 0.1.0

package/dist/core/status.js

@@ -0,0 +1,293 @@
+import fs from 'node:fs/promises';
+import { loadDefaultPreset } from '../presets/loader.js';
+import { inspectCompiledContracts } from '../contracts/freshness.js';
+import { listConfiguredAgents, readGlobalAgentSetupState } from './agent-setup.js';
+import { detectRuntimeAgentFromEnv } from './agent-runtime.js';
+import { pathExists } from './fs.js';
+import { getResumeDecision } from './flow-state.js';
+import { resolveStageSkills } from './skill-resolution.js';
+import { resolveCanonicalPath, resolveRepoPath, REQUIRED_CANONICAL_PATHS } from './paths.js';
+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';
+function describeCanonicalHealth(missingPaths) {
+    if (missingPaths.length === 0) {
+        return 'healthy';
+    }
+    return `missing ${missingPaths.join(', ')}`;
+}
+function hasStageValidationFailure(report) {
+    return report.runtimeState?.runtime.current_state === 'failed'
+        || report.runtimeState?.runtime.last_validation_result === 'fail';
+}
+function describeWorkspaceHealth(report) {
+    if (!report.initialized) {
+        return 'not initialized';
+    }
+    const issues = [];
+    if (!report.canonicalOk) {
+        issues.push(`canonical files: ${describeCanonicalHealth(report.canonicalMissing)}`);
+    }
+    if (report.versionStatus.status !== 'current') {
+        issues.push(`version/schema: ${report.versionStatus.status}`);
+    }
+    if (report.runtimeStateError) {
+        issues.push('runtime state unreadable');
+    }
+    if (!report.manualBootstrapReady) {
+        issues.push('bootstrap guidance incomplete');
+    }
+    return issues.length === 0 ? 'healthy' : `repair required (${issues.join('; ')})`;
+}
+function describeContractFreshness(report) {
+    if (!report.contractInventory) {
+        return 'unavailable';
+    }
+    if (report.contractInventory.ok) {
+        return `${report.contractInventory.compiledCount} compiled, synchronized`;
+    }
+    const parts = [];
+    if (report.contractInventory.missingCompiledStages.length > 0) {
+        parts.push(`missing compiled: ${report.contractInventory.missingCompiledStages.join(', ')}`);
+    }
+    if (report.contractInventory.staleStages.length > 0) {
+        parts.push(`stale: ${report.contractInventory.staleStages.join(', ')}`);
+    }
+    if (report.contractInventory.invalidStages.length > 0) {
+        parts.push(`invalid: ${report.contractInventory.invalidStages.join(', ')}`);
+    }
+    return parts.join('; ') || 'invalid';
+}
+function describeGlobalAgentSetup(report) {
+    return report.configuredAgents.length === 0 ? 'none configured' : report.configuredAgents.join(', ');
+}
+function describeSkillStage(report) {
+    return report.stageSkillResolution?.stage ?? 'unavailable';
+}
+function describeConsideredSkills(report) {
+    if (!report.stageSkillResolution) {
+        return 'unavailable';
+    }
+    if (report.stageSkillResolution.considered_skills.length === 0) {
+        return 'none';
+    }
+    return report.stageSkillResolution.considered_skills
+        .map((skill) => `${skill.id} [${skill.reason}]`)
+        .join(', ');
+}
+function describeActiveSkills(report) {
+    if (!report.stageSkillResolution) {
+        return 'unavailable';
+    }
+    const activeSkills = report.stageSkillResolution.considered_skills.filter((skill) => skill.active);
+    if (activeSkills.length === 0) {
+        return 'none';
+    }
+    return activeSkills.map((skill) => `${skill.id} [${skill.reason}]`).join(', ');
+}
+function describeVersion(versionStatus, presetMetadata) {
+    if (versionStatus.status === 'current') {
+        return `current (${presetMetadata.name}@${presetMetadata.version}, schema ${presetMetadata.schemaVersion})`;
+    }
+    if (versionStatus.status === 'outdated' && versionStatus.current) {
+        return `outdated (${versionStatus.current.presetName}@${versionStatus.current.presetVersion}, schema ${versionStatus.current.schemaVersion})`;
+    }
+    if (versionStatus.status === 'malformed') {
+        return 'malformed';
+    }
+    return 'missing';
+}
+function describeRuntime(runtime) {
+    if (!runtime) {
+        return 'unavailable';
+    }
+    if (runtime.status === RUNTIME_STATUS.NOT_BOOTSTRAPPED) {
+        return 'not bootstrapped';
+    }
+    const stage = runtime.current_stage ?? runtime.pending_stage ?? 'none';
+    const task = runtime.current_task_id ?? (runtime.pending_stage ? `${runtime.pending_stage} pending` : 'none');
+    return `${runtime.current_state} at ${stage} (${task})`;
+}
+function describeStageValidation(report) {
+    const runtime = report.runtimeState?.runtime ?? null;
+    if (!runtime) {
+        return 'unavailable';
+    }
+    if (runtime.current_state === 'failed' || runtime.last_validation_result === 'fail') {
+        const stage = runtime.failure_metadata?.stage ?? runtime.current_stage ?? null;
+        const reason = runtime.failure_metadata?.reason ?? runtime.blocked_reason ?? 'stage outputs failed contract validation';
+        return `failed${stage ? ` at ${stage}` : ''}: ${reason}`;
+    }
+    if (!runtime.last_validation) {
+        return 'not run yet';
+    }
+    return runtime.last_validation.passed
+        ? `last pass at ${runtime.last_validation.stage} (contract ${runtime.last_validation.contract_version})`
+        : `failed at ${runtime.last_validation.stage}`;
+}
+async function checkManualBootstrapGuidance(repoRoot) {
+    const agentsPath = resolveCanonicalPath(repoRoot, '.prodify/AGENTS.md');
+    if (!(await pathExists(agentsPath))) {
+        return false;
+    }
+    const content = await fs.readFile(agentsPath, 'utf8');
+    return hasManualBootstrapGuidance(content);
+}
+function deriveNextAction({ initialized, canonicalOk, contractsOk, configuredAgents, versionStatus, runtimeState, runtimeStateError, bootstrapPrompt }) {
+    if (!initialized) {
+        return 'prodify init';
+    }
+    if (!canonicalOk || !contractsOk || ['missing', 'malformed', 'outdated'].includes(versionStatus.status)) {
+        return 'prodify update';
+    }
+    if (runtimeStateError) {
+        return 'prodify update';
+    }
+    if (!runtimeState || runtimeState.runtime.status === RUNTIME_STATUS.NOT_BOOTSTRAPPED) {
+        if (configuredAgents.length === 0) {
+            return 'prodify setup-agent <agent>';
+        }
+        return `tell your agent: "${bootstrapPrompt}"`;
+    }
+    if (runtimeState.runtime.current_state === 'failed' || runtimeState.runtime.last_validation_result === 'fail') {
+        return 'rerun or remediate stage outputs';
+    }
+    const resume = getResumeDecision(runtimeState);
+    if (!resume.resumable) {
+        return runtimeState.runtime.status === RUNTIME_STATUS.COMPLETE ? 'none' : 'repair runtime state';
+    }
+    return resume.command ?? 'repair runtime state';
+}
+export async function inspectRepositoryStatus(repoRoot, options = {}) {
+    const preset = await loadDefaultPreset();
+    const prodifyPath = resolveRepoPath(repoRoot, '.prodify');
+    const initialized = await pathExists(prodifyPath);
+    const configuredAgents = listConfiguredAgents(await readGlobalAgentSetupState({
+        allowMissing: true
+    }));
+    const bootstrapProfile = (getRuntimeProfile(options.agent ?? null)?.name
+        ?? detectRuntimeAgentFromEnv()
+        ?? (configuredAgents.length === 1 ? configuredAgents[0] : 'codex'));
+    const bootstrapPrompt = buildBootstrapPrompt(bootstrapProfile);
+    if (!initialized) {
+        return {
+            ok: false,
+            initialized: false,
+            canonicalOk: false,
+            canonicalMissing: [...REQUIRED_CANONICAL_PATHS],
+            contractsOk: false,
+            contractInventory: null,
+            versionStatus: {
+                status: 'missing',
+                current: null,
+                expected: preset.metadata,
+                schemaMigrationRequired: false
+            },
+            configuredAgents,
+            runtimeState: null,
+            runtimeStateError: null,
+            resumable: false,
+            manualBootstrapReady: false,
+            bootstrapProfile,
+            bootstrapPrompt,
+            stageSkillResolution: null,
+            recommendedNextAction: 'prodify init',
+            presetMetadata: preset.metadata
+        };
+    }
+    const missingPaths = [];
+    for (const relativePath of REQUIRED_CANONICAL_PATHS) {
+        if (!(await pathExists(resolveCanonicalPath(repoRoot, relativePath)))) {
+            missingPaths.push(relativePath);
+        }
+    }
+    const contractInventory = await inspectCompiledContracts(repoRoot);
+    const versionStatus = await inspectVersionStatus(repoRoot, preset.metadata);
+    let runtimeState = null;
+    let runtimeStateError = null;
+    let stageSkillResolution = null;
+    try {
+        runtimeState = await readRuntimeState(repoRoot, {
+            presetMetadata: preset.metadata
+        });
+    }
+    catch (error) {
+        runtimeStateError = error instanceof Error ? error : new Error(String(error));
+    }
+    const manualBootstrapReady = await checkManualBootstrapGuidance(repoRoot);
+    const canonicalOk = missingPaths.length === 0;
+    if (canonicalOk && contractInventory.ok) {
+        const skillStage = runtimeState?.runtime.current_stage
+            ?? runtimeState?.runtime.pending_stage
+            ?? 'understand';
+        stageSkillResolution = await resolveStageSkills(repoRoot, skillStage);
+    }
+    const resume = runtimeState ? getResumeDecision(runtimeState) : {
+        resumable: false,
+        command: null,
+        reason: runtimeStateError?.message ?? 'runtime unavailable'
+    };
+    const stageValidationFailed = runtimeState?.runtime.current_state === 'failed'
+        || runtimeState?.runtime.last_validation_result === 'fail';
+    return {
+        ok: initialized
+            && canonicalOk
+            && contractInventory.ok
+            && versionStatus.status === 'current'
+            && !runtimeStateError
+            && manualBootstrapReady
+            && !stageValidationFailed,
+        initialized,
+        canonicalOk,
+        canonicalMissing: missingPaths,
+        contractsOk: contractInventory.ok,
+        contractInventory,
+        versionStatus,
+        configuredAgents,
+        runtimeState,
+        runtimeStateError,
+        resumable: resume.resumable,
+        manualBootstrapReady,
+        bootstrapProfile,
+        bootstrapPrompt,
+        stageSkillResolution,
+        recommendedNextAction: deriveNextAction({
+            initialized,
+            canonicalOk,
+            contractsOk: contractInventory.ok,
+            configuredAgents,
+            versionStatus,
+            runtimeState,
+            runtimeStateError,
+            bootstrapPrompt
+        }),
+        presetMetadata: preset.metadata
+    };
+}
+export function renderStatusReport(report) {
+    const lines = [
+        'Prodify Status',
+        `Repository: ${report.initialized ? 'initialized' : 'not initialized'}`,
+        `Workspace health: ${describeWorkspaceHealth(report)}`,
+        `Canonical files: ${describeCanonicalHealth(report.canonicalMissing)}`,
+        `Contract freshness: ${describeContractFreshness(report)}`,
+        `Version/schema: ${describeVersion(report.versionStatus, report.presetMetadata)}`,
+        'Repo runtime binding: agent-agnostic',
+        `Global agent setup: ${describeGlobalAgentSetup(report)}`,
+        `Skill routing stage: ${describeSkillStage(report)}`,
+        `Skills considered: ${describeConsideredSkills(report)}`,
+        `Skills active: ${describeActiveSkills(report)}`,
+        `Execution state: ${describeRuntime(report.runtimeState?.runtime ?? null)}`,
+        `Stage validation: ${describeStageValidation(report)}`,
+        `Manual bootstrap: ${report.manualBootstrapReady ? 'ready' : 'repair .prodify/AGENTS.md guidance'}`,
+        `Bootstrap profile: ${report.bootstrapProfile}`,
+        `Bootstrap prompt: ${report.bootstrapPrompt}`,
+        `Resumable: ${report.resumable ? 'yes' : 'no'}`,
+        `Recommended next action: ${report.recommendedNextAction}`
+    ];
+    if (report.runtimeStateError) {
+        lines.splice(7, 0, `Runtime state: ${report.runtimeStateError.message}`);
+    }
+    return lines.join('\n');
+}

package/dist/core/sync.js

@@ -0,0 +1,63 @@
+import fs from 'node:fs/promises';
+import { ProdifyError } from './errors.js';
+import { detectManagedFileState, parseManagedFileHeader } from './managed-files.js';
+import { pathExists, writeFileEnsuringDir } from './fs.js';
+import { resolveTargetPath } from './paths.js';
+import { getLegacyTarget, listLegacyTargets } from '../legacy/targets.js';
+export async function syncManagedTargets(repoRoot, options = {}) {
+    const requestedAgent = options.agent ?? null;
+    const force = options.force ?? false;
+    const createMissing = options.createMissing ?? Boolean(requestedAgent);
+    const requestedTarget = requestedAgent ? getLegacyTarget(requestedAgent) : null;
+    if (requestedAgent && !requestedTarget) {
+        throw new ProdifyError(`Unknown target agent: ${requestedAgent}`, {
+            code: 'UNKNOWN_TARGET'
+        });
+    }
+    const agents = requestedAgent
+        ? (requestedTarget ? [requestedTarget] : [])
+        : listLegacyTargets();
+    const results = [];
+    for (const target of agents) {
+        const agent = target.agent;
+        const targetPath = resolveTargetPath(repoRoot, agent);
+        if (!targetPath) {
+            continue;
+        }
+        if (!target.enabled || !target.generator) {
+            results.push({
+                agent,
+                targetPath,
+                status: 'not-enabled'
+            });
+            continue;
+        }
+        const expectedContent = await target.generator(repoRoot);
+        if (!(await pathExists(targetPath))) {
+            if (createMissing) {
+                await writeFileEnsuringDir(targetPath, expectedContent);
+                results.push({ agent, targetPath, status: 'updated' });
+            }
+            continue;
+        }
+        const existingContent = await fs.readFile(targetPath, 'utf8');
+        const managedHeader = parseManagedFileHeader(existingContent);
+        if (!managedHeader || managedHeader.targetAgent !== agent) {
+            results.push({ agent, targetPath, status: 'skipped-unmanaged' });
+            continue;
+        }
+        const state = detectManagedFileState(existingContent, expectedContent);
+        if (state.state === 'unchanged') {
+            results.push({ agent, targetPath, status: 'unchanged' });
+            continue;
+        }
+        if (state.state === 'conflict' && !force) {
+            results.push({ agent, targetPath, status: 'blocked' });
+            continue;
+        }
+        await writeFileEnsuringDir(targetPath, expectedContent);
+        results.push({ agent, targetPath, status: 'updated' });
+    }
+    results.sort((left, right) => left.agent.localeCompare(right.agent));
+    return results;
+}

package/dist/core/targets.js

@@ -0,0 +1,48 @@
+import { isRuntimeProfileName } from './paths.js';
+export const RUNTIME_PROFILES = {
+    codex: {
+        name: 'codex',
+        displayName: 'Codex',
+        bootstrapPrompt: 'Read .prodify/AGENTS.md and bootstrap Prodify for this repository.',
+        bootstrapSummary: 'Manual bootstrap through .prodify/AGENTS.md.',
+        executeCommand: '$prodify-execute',
+        resumeCommand: '$prodify-resume',
+        nuances: ['Prefer the explicit instruction to read .prodify/AGENTS.md before any repo scan.']
+    },
+    claude: {
+        name: 'claude',
+        displayName: 'Claude',
+        bootstrapPrompt: 'Read .prodify/AGENTS.md and bootstrap Prodify for this repository. Then use the runtime commands from that file.',
+        bootstrapSummary: 'Manual bootstrap from canonical guidance inside .prodify/.',
+        executeCommand: '$prodify-execute',
+        resumeCommand: '$prodify-resume',
+        nuances: ['Keep the flow anchored to .prodify/AGENTS.md instead of relying on root discovery.']
+    },
+    copilot: {
+        name: 'copilot',
+        displayName: 'Copilot',
+        bootstrapPrompt: 'Read .prodify/AGENTS.md, bootstrap Prodify for this repository, and keep the workflow state under .prodify/.',
+        bootstrapSummary: 'Manual bootstrap with explicit .prodify-only state.',
+        executeCommand: '$prodify-execute',
+        resumeCommand: '$prodify-resume',
+        nuances: ['The main flow does not require .github/copilot-instructions.md.']
+    },
+    opencode: {
+        name: 'opencode',
+        displayName: 'OpenCode',
+        bootstrapPrompt: 'Read .prodify/AGENTS.md and bootstrap Prodify for this repository using the .prodify runtime state.',
+        bootstrapSummary: 'Manual bootstrap with runtime state anchored in .prodify/state.json.',
+        executeCommand: '$prodify-execute',
+        resumeCommand: '$prodify-resume',
+        nuances: ['No root-level OpenCode adapter is required for the default flow.']
+    }
+};
+export function listRuntimeProfiles() {
+    return Object.values(RUNTIME_PROFILES);
+}
+export function getRuntimeProfile(agent) {
+    if (!agent || !isRuntimeProfileName(agent)) {
+        return null;
+    }
+    return RUNTIME_PROFILES[agent];
+}

package/dist/core/upgrade.js

@@ -0,0 +1,57 @@
+import fs from 'node:fs/promises';
+import { writeFileEnsuringDir } from './fs.js';
+import { USER_OWNED_CANONICAL_PATHS, USER_OWNED_CANONICAL_PREFIXES, resolveRepoPath } from './paths.js';
+import { loadDefaultPreset } from '../presets/loader.js';
+import { readRuntimeState, createInitialRuntimeState, normalizeRuntimeState, serializeRuntimeState } from './state.js';
+import { inspectVersionStatus } from './version-checks.js';
+import { synchronizeRuntimeContracts } from '../contracts/compiler.js';
+export async function updateProdifySetup(repoRoot) {
+    const preset = await loadDefaultPreset();
+    const versionStatus = await inspectVersionStatus(repoRoot, preset.metadata);
+    const writtenCanonical = [];
+    const preservedCanonical = [];
+    for (const entry of preset.entries) {
+        const targetPath = resolveRepoPath(repoRoot, entry.relativePath);
+        const isUserOwned = USER_OWNED_CANONICAL_PATHS.includes(entry.relativePath);
+        const isUserOwnedByPrefix = USER_OWNED_CANONICAL_PREFIXES.some((prefix) => entry.relativePath.startsWith(prefix));
+        if (isUserOwned || isUserOwnedByPrefix) {
+            try {
+                await fs.access(targetPath);
+                preservedCanonical.push(entry.relativePath);
+                continue;
+            }
+            catch {
+                // fall through and create the missing file
+            }
+        }
+        if (entry.relativePath === '.prodify/state.json') {
+            let nextState;
+            try {
+                const existingState = await readRuntimeState(repoRoot, {
+                    presetMetadata: preset.metadata
+                });
+                nextState = normalizeRuntimeState(existingState, {
+                    presetMetadata: preset.metadata
+                });
+            }
+            catch {
+                nextState = createInitialRuntimeState({
+                    presetMetadata: preset.metadata
+                });
+            }
+            await writeFileEnsuringDir(targetPath, serializeRuntimeState(nextState));
+            writtenCanonical.push(entry.relativePath);
+            continue;
+        }
+        await writeFileEnsuringDir(targetPath, entry.content);
+        writtenCanonical.push(entry.relativePath);
+    }
+    const compiledContracts = await synchronizeRuntimeContracts(repoRoot);
+    return {
+        versionStatus: versionStatus.status,
+        schemaMigrationRequired: versionStatus.schemaMigrationRequired,
+        writtenCanonicalCount: writtenCanonical.length,
+        preservedCanonicalCount: preservedCanonical.length,
+        compiledContractCount: compiledContracts.length
+    };
+}

package/dist/core/validation.js

@@ -0,0 +1,138 @@
+import fs from 'node:fs/promises';
+import { loadCompiledContract } from '../contracts/compiler.js';
+import { normalizeRepoRelativePath, resolveRepoPath } from './paths.js';
+function pathIsWithin(pathToCheck, root) {
+    const normalizedPath = normalizeRepoRelativePath(pathToCheck);
+    const normalizedRoot = normalizeRepoRelativePath(root);
+    return normalizedPath === normalizedRoot || normalizedPath.startsWith(`${normalizedRoot.replace(/\/$/, '')}/`);
+}
+function collectMarkdownSections(markdown) {
+    const sections = new Map();
+    const lines = markdown.replace(/\r\n/g, '\n').split('\n');
+    let currentHeading = null;
+    let buffer = [];
+    const flush = () => {
+        if (currentHeading) {
+            sections.set(currentHeading, buffer.join('\n').trim());
+        }
+    };
+    for (const line of lines) {
+        const headingMatch = /^(#{1,6})\s+(.+?)\s*$/.exec(line);
+        if (headingMatch) {
+            flush();
+            currentHeading = headingMatch[2].trim();
+            buffer = [];
+            continue;
+        }
+        buffer.push(line);
+    }
+    flush();
+    return sections;
+}
+function containsAllStatements(sectionContent, statements) {
+    return statements.every((statement) => sectionContent.includes(statement));
+}
+function buildRule(rule, message, path) {
+    return { rule, message, path };
+}
+async function validateArtifact(repoRoot, contract, artifact) {
+    const artifactPath = resolveRepoPath(repoRoot, artifact.path);
+    const issues = [];
+    const missing = [];
+    const diagnostics = [];
+    try {
+        const content = await fs.readFile(artifactPath, 'utf8');
+        diagnostics.push(`validated artifact ${artifact.path}`);
+        if (!contract.allowed_write_roots.some((root) => pathIsWithin(artifact.path, root))) {
+            issues.push(buildRule('artifact/outside-allowed-roots', `Required artifact ${artifact.path} is outside allowed write roots.`, artifact.path));
+        }
+        if (artifact.format === 'markdown') {
+            const sections = collectMarkdownSections(content);
+            for (const section of artifact.required_sections) {
+                if (!sections.has(section)) {
+                    issues.push(buildRule('artifact/markdown-section-missing', `Markdown artifact ${artifact.path} is missing section "${section}".`, artifact.path));
+                }
+            }
+            const successCriteriaSection = sections.get('Success Criteria') ?? '';
+            if (contract.success_criteria.length > 0 && !containsAllStatements(successCriteriaSection, contract.success_criteria)) {
+                issues.push(buildRule('artifact/success-criteria-missing', `Markdown artifact ${artifact.path} does not document all success criteria.`, artifact.path));
+            }
+            const policyChecksSection = sections.get('Policy Checks') ?? '';
+            if (contract.policy_rules.length > 0 && !containsAllStatements(policyChecksSection, contract.policy_rules)) {
+                issues.push(buildRule('artifact/policy-rules-missing', `Markdown artifact ${artifact.path} does not document all policy checks.`, artifact.path));
+            }
+        }
+        else {
+            const parsed = JSON.parse(content);
+            for (const key of artifact.required_json_keys) {
+                if (!(key in parsed)) {
+                    issues.push(buildRule('artifact/json-key-missing', `JSON artifact ${artifact.path} is missing key "${key}".`, artifact.path));
+                }
+            }
+        }
+    }
+    catch {
+        missing.push(artifact.path);
+        issues.push(buildRule('artifact/missing', `Required artifact ${artifact.path} is missing.`, artifact.path));
+    }
+    return {
+        issues,
+        missing,
+        diagnostics
+    };
+}
+export async function validateStageOutputs(repoRoot, { contract, runtimeState, touchedPaths = [] }) {
+    const violatedRules = [];
+    const missingArtifacts = [];
+    const diagnostics = [];
+    const warnings = [];
+    if (runtimeState.runtime.current_stage !== contract.stage) {
+        violatedRules.push(buildRule('runtime/stage-mismatch', `Runtime stage ${runtimeState.runtime.current_stage ?? 'none'} does not match contract stage ${contract.stage}.`));
+    }
+    for (const artifact of contract.required_artifacts) {
+        const artifactValidation = await validateArtifact(repoRoot, contract, artifact);
+        violatedRules.push(...artifactValidation.issues);
+        missingArtifacts.push(...artifactValidation.missing);
+        diagnostics.push(...artifactValidation.diagnostics);
+    }
+    for (const rawTouchedPath of touchedPaths.map((entry) => normalizeRepoRelativePath(entry))) {
+        if (!contract.allowed_write_roots.some((root) => pathIsWithin(rawTouchedPath, root))) {
+            violatedRules.push(buildRule('writes/outside-allowed-roots', `Touched path ${rawTouchedPath} is outside the contract write boundary.`, rawTouchedPath));
+        }
+        if (contract.forbidden_writes.some((entry) => pathIsWithin(rawTouchedPath, entry))) {
+            violatedRules.push(buildRule('writes/forbidden', `Touched path ${rawTouchedPath} is forbidden by the contract.`, rawTouchedPath));
+        }
+    }
+    if (touchedPaths.length === 0) {
+        warnings.push('No touched paths were provided; forbidden-write checks are limited to required artifacts.');
+    }
+    return {
+        stage: contract.stage,
+        contract_version: contract.contract_version,
+        passed: violatedRules.length === 0,
+        violated_rules: violatedRules,
+        missing_artifacts: [...new Set(missingArtifacts)].sort((left, right) => left.localeCompare(right)),
+        warnings,
+        diagnostics
+    };
+}
+export async function validateStageOutputsForCurrentState(repoRoot, { runtimeState, touchedPaths = [] }) {
+    const stage = runtimeState.runtime.current_stage;
+    if (!stage) {
+        throw new Error('Cannot validate stage outputs when no stage is active.');
+    }
+    const contract = await loadCompiledContract(repoRoot, stage);
+    return validateStageOutputs(repoRoot, {
+        contract,
+        runtimeState,
+        touchedPaths
+    });
+}
+export async function validateStageOutputsForStage(repoRoot, { stage, runtimeState, touchedPaths = [] }) {
+    const contract = await loadCompiledContract(repoRoot, stage);
+    return validateStageOutputs(repoRoot, {
+        contract,
+        runtimeState,
+        touchedPaths
+    });
+}

package/dist/core/version-checks.js

@@ -0,0 +1,35 @@
+import fs from 'node:fs/promises';
+import { pathExists } from './fs.js';
+import { resolveCanonicalPath } from './paths.js';
+import { parseVersionMetadata } from '../presets/version.js';
+export async function inspectVersionStatus(repoRoot, presetMetadata) {
+    const versionPath = resolveCanonicalPath(repoRoot, '.prodify/version.json');
+    if (!(await pathExists(versionPath))) {
+        return {
+            status: 'missing',
+            current: null,
+            expected: presetMetadata,
+            schemaMigrationRequired: false
+        };
+    }
+    try {
+        const current = parseVersionMetadata(await fs.readFile(versionPath, 'utf8'));
+        const versionMatches = current.presetName === presetMetadata.name
+            && current.presetVersion === presetMetadata.version;
+        const schemaMatches = current.schemaVersion === presetMetadata.schemaVersion;
+        return {
+            status: versionMatches && schemaMatches ? 'current' : 'outdated',
+            current,
+            expected: presetMetadata,
+            schemaMigrationRequired: !schemaMatches
+        };
+    }
+    catch {
+        return {
+            status: 'malformed',
+            current: null,
+            expected: presetMetadata,
+            schemaMigrationRequired: true
+        };
+    }
+}

package/dist/generators/claude.js

@@ -0,0 +1,14 @@
+import { buildManagedMarkdownOutput, readCanonicalMarkdown } from './shared.js';
+import { LEGACY_TARGET_PATH_DEFINITIONS } from '../core/paths.js';
+export async function generateClaudeContent(repoRoot) {
+    const target = LEGACY_TARGET_PATH_DEFINITIONS.claude;
+    const guidance = await readCanonicalMarkdown(repoRoot, target.canonicalSources[0]);
+    const runtime = await readCanonicalMarkdown(repoRoot, '.prodify/runtime-commands.md');
+    const body = `${guidance.trimEnd()}\n\n${runtime.trim()}\n`;
+    return buildManagedMarkdownOutput({
+        agent: target.agent,
+        canonicalSources: target.canonicalSources,
+        regenerateCommand: 'prodify update',
+        body
+    });
+}

package/dist/generators/codex.js

@@ -0,0 +1,14 @@
+import { buildManagedMarkdownOutput, readCanonicalMarkdown } from './shared.js';
+import { LEGACY_TARGET_PATH_DEFINITIONS } from '../core/paths.js';
+export async function generateCodexContent(repoRoot) {
+    const target = LEGACY_TARGET_PATH_DEFINITIONS.codex;
+    const guidance = await readCanonicalMarkdown(repoRoot, target.canonicalSources[0]);
+    const runtime = await readCanonicalMarkdown(repoRoot, '.prodify/runtime-commands.md');
+    const body = `${guidance.trimEnd()}\n\n${runtime.trim()}\n`;
+    return buildManagedMarkdownOutput({
+        agent: target.agent,
+        canonicalSources: target.canonicalSources,
+        regenerateCommand: 'prodify update',
+        body
+    });
+}