@urielsh/prodify 0.1.0

package/tests/unit/agent-setup.test.js

@@ -0,0 +1,81 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { createTempDir } from './helpers.js';
+import {
+  createInitialGlobalAgentSetupState,
+  listConfiguredAgents,
+  readGlobalAgentSetupState,
+  resolveGlobalAgentSetupStatePath,
+  setupAgentIntegration
+} from '../../dist/core/agent-setup.js';
+import { detectRuntimeAgentFromEnv, resolveRuntimeAgentBinding } from '../../dist/core/agent-runtime.js';
+
+test('global agent setup registers multiple agents without repo-local state', async () => {
+  const root = await createTempDir();
+  const env = {
+    ...process.env,
+    PRODIFY_HOME: path.join(root, '.prodify-home')
+  };
+
+  await setupAgentIntegration('codex', {
+    now: '2026-04-04T00:00:00.000Z',
+    env
+  });
+  await setupAgentIntegration('claude', {
+    now: '2026-04-04T00:05:00.000Z',
+    env
+  });
+
+  const state = await readGlobalAgentSetupState({
+    env
+  });
+
+  assert.deepEqual(listConfiguredAgents(state), ['claude', 'codex']);
+  await fs.access(resolveGlobalAgentSetupStatePath(env));
+  await assert.rejects(fs.access(path.join(root, '.prodify')));
+});
+
+test('runtime agent binding resolves from explicit, env, and single configured agent inputs', async () => {
+  const root = await createTempDir();
+  const env = {
+    ...process.env,
+    PRODIFY_HOME: path.join(root, '.prodify-home')
+  };
+
+  await setupAgentIntegration('copilot', {
+    now: '2026-04-04T00:10:00.000Z',
+    env
+  });
+
+  assert.equal(await resolveRuntimeAgentBinding({
+    requestedAgent: 'claude',
+    env
+  }), 'claude');
+  assert.equal(detectRuntimeAgentFromEnv({
+    ...env,
+    PRODIFY_ACTIVE_AGENT: 'opencode'
+  }), 'opencode');
+  assert.equal(await resolveRuntimeAgentBinding({
+    env
+  }), 'copilot');
+});
+
+test('runtime agent binding rejects ambiguous or missing global setup', async () => {
+  const root = await createTempDir();
+  const env = {
+    ...process.env,
+    PRODIFY_HOME: path.join(root, '.prodify-home')
+  };
+
+  assert.deepEqual(listConfiguredAgents(createInitialGlobalAgentSetupState()), []);
+
+  await assert.rejects(resolveRuntimeAgentBinding({ env }), /setup-agent/);
+
+  await setupAgentIntegration('codex', { env });
+  await setupAgentIntegration('claude', { env });
+
+  await assert.rejects(resolveRuntimeAgentBinding({ env }), /Multiple agents/);
+});

package/tests/unit/cli.test.js

@@ -0,0 +1,28 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { COMMANDS, PUBLIC_COMMANDS, renderHelp, runCli } from '../../dist/cli.js';
+import { memoryStream } from './helpers.js';
+
+test('cli help includes all command names', async () => {
+  const stdout = memoryStream();
+  const stderr = memoryStream();
+  const exitCode = await runCli(['--help'], { cwd: process.cwd(), stdout, stderr });
+
+  assert.equal(exitCode, 0);
+  assert.match(stdout.toString(), /\bsetup-agent\b/);
+  assert.match(stdout.toString(), /\binit\b/);
+  assert.match(stdout.toString(), /\bstatus\b/);
+  assert.match(stdout.toString(), /\bdoctor\b/);
+  assert.match(stdout.toString(), /\bupdate\b/);
+  assert.doesNotMatch(stdout.toString(), /\binstall\b/);
+  assert.doesNotMatch(stdout.toString(), /\bsync\b/);
+});
+
+test('command registry exposes only the lifecycle commands publicly', () => {
+  assert.deepEqual(PUBLIC_COMMANDS, ['init', 'setup-agent', 'status', 'doctor', 'update']);
+  assert.deepEqual(Object.keys(COMMANDS).sort(), ['doctor', 'init', 'setup-agent', 'status', 'update']);
+  assert.match(renderHelp(), /prodify setup-agent/);
+  assert.match(renderHelp(), /prodify status/);
+  assert.match(renderHelp(), /prodify update/);
+});

package/tests/unit/contracts.test.js

@@ -0,0 +1,61 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { compileContractSource, serializeCompiledContract } from '../../dist/contracts/compiler.js';
+
+const validSource = `---
+schema_version: 1
+contract_version: 1.0.0
+stage: understand
+task_id: 01-understand
+required_artifacts:
+  - path: .prodify/artifacts/01-understand.md
+    format: markdown
+    required_sections:
+      - Policy Checks
+      - Repository Summary
+      - Success Criteria
+allowed_write_roots:
+  - .prodify/artifacts/
+forbidden_writes:
+  - src/
+policy_rules:
+  - Operate only on verified data.
+success_criteria:
+  - The repository intent is captured clearly.
+---
+# Understand
+
+Human-readable rationale lives here.
+`;
+
+test('valid Markdown source contracts compile deterministically to strict runtime JSON', () => {
+  const contract = compileContractSource({
+    markdown: validSource,
+    sourcePath: '.prodify/contracts-src/understand.contract.md'
+  });
+
+  assert.equal(contract.stage, 'understand');
+  assert.equal(contract.task_id, '01-understand');
+  assert.equal(contract.required_artifacts.length, 1);
+  assert.equal(contract.required_artifacts[0].format, 'markdown');
+  assert.equal(
+    serializeCompiledContract(contract),
+    serializeCompiledContract(compileContractSource({
+      markdown: validSource,
+      sourcePath: '.prodify/contracts-src/understand.contract.md'
+    }))
+  );
+});
+
+test('invalid frontmatter fails with a precise contract error', () => {
+  const invalidSource = validSource.replace('task_id: 01-understand', 'task_id: 02-diagnose');
+
+  assert.throws(
+    () => compileContractSource({
+      markdown: invalidSource,
+      sourcePath: '.prodify/contracts-src/understand.contract.md'
+    }),
+    /does not match stage/
+  );
+});

package/tests/unit/helpers.js

@@ -0,0 +1,28 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+export async function createTempRepo(prefix = 'prodify-test-') {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), prefix));
+  await fs.mkdir(path.join(root, '.git'));
+  process.env.PRODIFY_HOME = path.join(root, '.prodify-home');
+  return root;
+}
+
+export async function createTempDir(prefix = 'prodify-test-dir-') {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), prefix));
+  process.env.PRODIFY_HOME = path.join(root, '.prodify-home');
+  return root;
+}
+
+export function memoryStream() {
+  let value = '';
+  return {
+    write(chunk) {
+      value += String(chunk);
+    },
+    toString() {
+      return value;
+    }
+  };
+}

package/tests/unit/paths.test.js

@@ -0,0 +1,52 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { resolveRepoRoot } from '../../dist/core/repo-root.js';
+import { resolveCanonicalPath } from '../../dist/core/paths.js';
+import { createTempRepo } from './helpers.js';
+
+test('repo root resolves from .prodify presence', async () => {
+  const repoRoot = await createTempRepo();
+  await fs.mkdir(path.join(repoRoot, '.prodify'));
+  await fs.mkdir(path.join(repoRoot, 'nested', 'more'), { recursive: true });
+
+  const resolved = await resolveRepoRoot({
+    cwd: path.join(repoRoot, 'nested', 'more')
+  });
+
+  assert.equal(resolved, repoRoot);
+});
+
+test('repo root resolves from .git during bootstrap', async () => {
+  const repoRoot = await createTempRepo();
+  await fs.mkdir(path.join(repoRoot, 'nested', 'more'), { recursive: true });
+
+  const resolved = await resolveRepoRoot({
+    cwd: path.join(repoRoot, 'nested', 'more'),
+    allowBootstrap: true
+  });
+
+  assert.equal(resolved, repoRoot);
+});
+
+test('canonical paths still resolve deterministically', () => {
+  const repoRoot = '/tmp/example-repo';
+
+  assert.equal(resolveCanonicalPath(repoRoot, '.prodify/AGENTS.md'), '/tmp/example-repo/.prodify/AGENTS.md');
+  assert.equal(resolveCanonicalPath(repoRoot, '.prodify/contracts-src/understand.contract.md'), '/tmp/example-repo/.prodify/contracts-src/understand.contract.md');
+  assert.equal(resolveCanonicalPath(repoRoot, '.prodify/contracts/understand.contract.json'), '/tmp/example-repo/.prodify/contracts/understand.contract.json');
+});
+
+test('repo root resolution fails cleanly when root is missing', async () => {
+  const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'prodify-no-root-'));
+
+  await assert.rejects(
+    resolveRepoRoot({ cwd: repoRoot }),
+    /Could not resolve repository root/
+  );
+
+  await fs.rm(repoRoot, { recursive: true, force: true });
+});

package/tests/unit/preset-loader.test.js

@@ -0,0 +1,37 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { loadDefaultPreset } from '../../dist/presets/loader.js';
+
+test('default preset loads required canonical files', async () => {
+  const preset = await loadDefaultPreset();
+  const paths = preset.entries.map((entry) => entry.relativePath);
+
+  assert.ok(paths.includes('.prodify/AGENTS.md'));
+  assert.ok(paths.includes('.prodify/artifacts/README.md'));
+  assert.ok(paths.includes('.prodify/contracts-src/README.md'));
+  assert.ok(paths.includes('.prodify/contracts-src/understand.contract.md'));
+  assert.ok(paths.includes('.prodify/contracts-src/validate.contract.md'));
+  assert.ok(paths.includes('.prodify/metrics/README.md'));
+  assert.ok(paths.includes('.prodify/project.md'));
+  assert.ok(paths.includes('.prodify/planning.md'));
+  assert.ok(paths.includes('.prodify/runtime-commands.md'));
+  assert.ok(paths.includes('.prodify/skills/README.md'));
+  assert.ok(paths.includes('.prodify/skills/registry.json'));
+  assert.ok(paths.includes('.prodify/skills/stage-method/codebase-scanning.skill.json'));
+  assert.ok(paths.includes('.prodify/state.json'));
+  assert.ok(paths.includes('.prodify/version.json'));
+  assert.ok(paths.includes('.prodify/tasks/README.md'));
+  assert.ok(paths.includes('.prodify/rules/README.md'));
+  assert.ok(paths.includes('.prodify/templates/README.md'));
+  assert.equal(paths.includes('AGENTS.md'), false);
+  assert.equal(paths.includes('CLAUDE.md'), false);
+  assert.equal(paths.some((entry) => entry.startsWith('.github/')), false);
+  assert.equal(paths.some((entry) => entry.startsWith('.opencode/')), false);
+  assert.equal(paths.some((entry) => entry.startsWith('.prodify/presets/')), false);
+
+  const stateEntry = preset.entries.find((entry) => entry.relativePath === '.prodify/state.json');
+  assert.ok(stateEntry);
+  assert.doesNotMatch(stateEntry.content, /primary_agent/);
+  assert.doesNotMatch(stateEntry.content, /selected_agent/);
+});

package/tests/unit/scoring.test.js

@@ -0,0 +1,65 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { runCli } from '../../dist/cli.js';
+import { bootstrapFlowState, startFlowExecution } from '../../dist/core/flow-state.js';
+import { readRuntimeState } from '../../dist/core/state.js';
+import { writeScoreDelta, writeScoreSnapshot } from '../../dist/scoring/model.js';
+import { createTempRepo, memoryStream } from './helpers.js';
+
+async function execCli(repoRoot, args) {
+  const stdout = memoryStream();
+  const stderr = memoryStream();
+  const exitCode = await runCli(args, { cwd: repoRoot, stdout, stderr });
+  return { exitCode, stdout: stdout.toString(), stderr: stderr.toString() };
+}
+
+test('baseline, final, and delta score artifacts are written under .prodify/metrics', async () => {
+  const repoRoot = await createTempRepo();
+  await execCli(repoRoot, ['init']);
+
+  const state = await readRuntimeState(repoRoot, {
+    presetMetadata: {
+      name: 'default',
+      version: '4.0.0',
+      schemaVersion: '4'
+    }
+  });
+  const baselineState = bootstrapFlowState(state, {
+    agent: 'codex',
+    mode: 'interactive'
+  });
+  const finalState = startFlowExecution(baselineState);
+  finalState.runtime.current_state = 'validate_complete';
+  finalState.runtime.current_stage = 'validate';
+  finalState.runtime.current_task_id = '06-validate';
+  finalState.runtime.last_validation = {
+    stage: 'validate',
+    contract_version: '1.0.0',
+    passed: true,
+    violated_rules: [],
+    missing_artifacts: [],
+    warnings: [],
+    diagnostics: ['ok']
+  };
+  finalState.runtime.last_validation_result = 'pass';
+
+  const baseline = await writeScoreSnapshot(repoRoot, {
+    kind: 'baseline',
+    runtimeState: baselineState
+  });
+  const final = await writeScoreSnapshot(repoRoot, {
+    kind: 'final',
+    runtimeState: finalState
+  });
+  const delta = await writeScoreDelta(repoRoot);
+
+  assert.equal(typeof baseline.total_score, 'number');
+  assert.equal(typeof final.total_score, 'number');
+  assert.equal(delta.delta, Number((final.total_score - baseline.total_score).toFixed(2)));
+  await fs.access(path.join(repoRoot, '.prodify', 'metrics', 'baseline.score.json'));
+  await fs.access(path.join(repoRoot, '.prodify', 'metrics', 'final.score.json'));
+  await fs.access(path.join(repoRoot, '.prodify', 'metrics', 'delta.json'));
+});

package/tests/unit/self-hosted-workspace.test.js

@@ -0,0 +1,22 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { REQUIRED_CANONICAL_PATHS } from '../../dist/core/paths.js';
+
+test('checked-in repo-root .prodify workspace contains the canonical runtime layout', async () => {
+  for (const relativePath of REQUIRED_CANONICAL_PATHS) {
+    await fs.access(path.join(process.cwd(), relativePath));
+  }
+});
+
+test('self-hosted workspace guidance distinguishes canonical runtime files from repo-local additions', async () => {
+  const artifactReadme = await fs.readFile(path.join(process.cwd(), '.prodify', 'artifacts', 'README.md'), 'utf8');
+  const rootGuidance = await fs.readFile(path.join(process.cwd(), '.prodify', 'AGENTS.md'), 'utf8');
+
+  assert.equal(REQUIRED_CANONICAL_PATHS.includes('AGENTS.md'), false);
+  assert.match(artifactReadme, /numbered filenames such as `01-understand\.md` through `06-validate\.md`/);
+  assert.match(artifactReadme, /repository-local design or historical artifacts/i);
+  assert.match(rootGuidance, /root `AGENTS\.md`.*repository-local contributor guidance/i);
+});

package/tests/unit/skills.test.js

@@ -0,0 +1,115 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { runCli } from '../../dist/cli.js';
+import { inspectRepositoryStatus } from '../../dist/core/status.js';
+import { resolveStageSkills } from '../../dist/core/skill-resolution.js';
+import { loadSkillRegistry } from '../../dist/skills/loader.js';
+import { validateSkillDefinitionShape } from '../../dist/skills/schema.js';
+import { createTempRepo, memoryStream } from './helpers.js';
+
+async function execCli(repoRoot, args) {
+  const stdout = memoryStream();
+  const stderr = memoryStream();
+  const exitCode = await runCli(args, { cwd: repoRoot, stdout, stderr });
+
+  return {
+    exitCode,
+    stdout: stdout.toString(),
+    stderr: stderr.toString()
+  };
+}
+
+async function seedTypeScriptCliRepo(repoRoot) {
+  await fs.mkdir(path.join(repoRoot, 'src'), { recursive: true });
+  await fs.writeFile(path.join(repoRoot, 'package.json'), JSON.stringify({
+    name: 'fixture',
+    version: '1.0.0',
+    private: true
+  }, null, 2));
+  await fs.writeFile(path.join(repoRoot, 'tsconfig.json'), JSON.stringify({
+    compilerOptions: {
+      target: 'ES2022'
+    }
+  }, null, 2));
+  await fs.writeFile(path.join(repoRoot, 'src', 'cli.ts'), 'export const cli = true;\n');
+}
+
+test('valid skills load from the canonical registry', async () => {
+  const repoRoot = await createTempRepo();
+  const result = await execCli(repoRoot, ['init']);
+  assert.equal(result.exitCode, 0);
+
+  const registry = await loadSkillRegistry(repoRoot);
+
+  assert.ok(registry.has('codebase-scanning'));
+  assert.ok(registry.has('typescript-backend'));
+  assert.ok(registry.has('test-hardening'));
+});
+
+test('invalid skills fail clearly', () => {
+  assert.throws(
+    () => validateSkillDefinitionShape({
+      schema_version: '1',
+      id: '',
+      name: 'Broken Skill',
+      version: '1.0.0',
+      category: 'stage-method',
+      description: 'broken',
+      intended_use: ['broken'],
+      stage_compatibility: ['understand'],
+      activation_conditions: [],
+      execution_guidance: ['broken'],
+      caution_guidance: []
+    }),
+    /must be a non-empty string/
+  );
+});
+
+test('stage-incompatible skills cannot be attached', async () => {
+  const repoRoot = await createTempRepo();
+  await execCli(repoRoot, ['init']);
+
+  const contractPath = path.join(repoRoot, '.prodify', 'contracts', 'plan.contract.json');
+  const contract = JSON.parse(await fs.readFile(contractPath, 'utf8'));
+  contract.skill_routing = {
+    default_skills: ['validation-method'],
+    allowed_skills: ['validation-method'],
+    conditional_skills: []
+  };
+  await fs.writeFile(contractPath, `${JSON.stringify(contract, null, 2)}\n`, 'utf8');
+
+  await assert.rejects(
+    () => resolveStageSkills(repoRoot, 'plan'),
+    /not compatible with stage "plan"/
+  );
+});
+
+test('stage default and conditional skills resolve deterministically from repo context', async () => {
+  const repoRoot = await createTempRepo();
+  await execCli(repoRoot, ['init']);
+  await seedTypeScriptCliRepo(repoRoot);
+
+  const resolution = await resolveStageSkills(repoRoot, 'refactor');
+
+  assert.equal(resolution.stage, 'refactor');
+  assert.deepEqual(resolution.active_skill_ids, ['refactoring-method', 'test-hardening', 'typescript-backend']);
+  assert.match(
+    resolution.considered_skills.find((skill) => skill.id === 'typescript-backend').reason,
+    /TypeScript/
+  );
+});
+
+test('skill routing stays agent-agnostic across status views', async () => {
+  const repoRoot = await createTempRepo();
+  await execCli(repoRoot, ['init']);
+  await seedTypeScriptCliRepo(repoRoot);
+
+  const codexReport = await inspectRepositoryStatus(repoRoot, { agent: 'codex' });
+  const claudeReport = await inspectRepositoryStatus(repoRoot, { agent: 'claude' });
+
+  assert.deepEqual(codexReport.stageSkillResolution.active_skill_ids, claudeReport.stageSkillResolution.active_skill_ids);
+  assert.equal(codexReport.stageSkillResolution.stage, 'understand');
+});

package/tests/unit/state-and-flow.test.js

@@ -0,0 +1,120 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { bootstrapFlowState, completeFlowStage, failFlowStage, getResumeDecision, stageToTaskId, startFlowExecution } from '../../dist/core/flow-state.js';
+import { buildBootstrapPrompt, buildExecutionPrompt, buildRuntimeCommandReference } from '../../dist/core/prompt-builder.js';
+import { createInitialRuntimeState } from '../../dist/core/state.js';
+
+const presetMetadata = {
+  name: 'default',
+  version: '4.0.0',
+  schemaVersion: '4'
+};
+
+function passingValidation(stage) {
+  return {
+    stage,
+    contract_version: '1.0.0',
+    passed: true,
+    violated_rules: [],
+    missing_artifacts: [],
+    warnings: [],
+    diagnostics: ['ok']
+  };
+}
+
+test('runtime bootstrap initializes the bootstrapped checkpoint deterministically', () => {
+  const state = createInitialRuntimeState({ presetMetadata });
+  const bootstrapped = bootstrapFlowState(state, {
+    agent: 'codex',
+    mode: 'interactive',
+    now: '2026-03-31T00:00:00.000Z'
+  });
+
+  assert.equal(bootstrapped.runtime.status, 'ready');
+  assert.equal(bootstrapped.runtime.current_state, 'bootstrapped');
+  assert.equal(bootstrapped.runtime.pending_stage, 'understand');
+  assert.equal(bootstrapped.runtime.current_stage, null);
+  assert.equal(bootstrapped.runtime.next_action, '$prodify-execute');
+  assert.deepEqual(bootstrapped.runtime.bootstrap, {
+    bootstrapped: true
+  });
+});
+
+test('interactive execution pauses on a stage-complete checkpoint and resumes with $prodify-resume', () => {
+  const state = createInitialRuntimeState({ presetMetadata });
+  const bootstrapped = bootstrapFlowState(state, {
+    agent: 'codex',
+    mode: 'interactive'
+  });
+  const running = startFlowExecution(bootstrapped);
+  const paused = completeFlowStage(running, {
+    validation: passingValidation('understand')
+  });
+
+  assert.equal(paused.runtime.status, 'awaiting_validation');
+  assert.equal(paused.runtime.current_state, 'understand_complete');
+  assert.equal(paused.runtime.current_stage, 'understand');
+  assert.equal(paused.runtime.pending_stage, 'diagnose');
+  assert.equal(paused.runtime.current_task_id, '01-understand');
+  assert.equal(paused.runtime.next_action, '$prodify-resume');
+  assert.deepEqual(paused.runtime.completed_stages, ['understand']);
+  assert.deepEqual(getResumeDecision(paused), {
+    resumable: true,
+    command: '$prodify-resume',
+    reason: 'understand_complete'
+  });
+});
+
+test('auto execution advances to the next pending stage without a validation pause', () => {
+  const state = createInitialRuntimeState({ presetMetadata });
+  const bootstrapped = bootstrapFlowState(state, {
+    agent: 'codex',
+    mode: 'auto'
+  });
+  const running = startFlowExecution(bootstrapped, {
+    mode: 'auto'
+  });
+  const advanced = completeFlowStage(running, {
+    validation: passingValidation('understand')
+  });
+
+  assert.equal(advanced.runtime.status, 'ready');
+  assert.equal(advanced.runtime.current_state, 'diagnose_pending');
+  assert.equal(advanced.runtime.current_stage, 'diagnose');
+  assert.equal(advanced.runtime.next_action, '$prodify-execute --auto');
+});
+
+test('failed validation produces a non-resumable failed checkpoint', () => {
+  const state = createInitialRuntimeState({ presetMetadata });
+  const bootstrapped = bootstrapFlowState(state, {
+    agent: 'codex',
+    mode: 'interactive'
+  });
+  const running = startFlowExecution(bootstrapped);
+  const failed = failFlowStage(running, {
+    reason: 'missing artifact'
+  });
+
+  assert.equal(failed.runtime.current_state, 'failed');
+  assert.equal(failed.runtime.resumable, false);
+  assert.equal(getResumeDecision(failed).resumable, false);
+});
+
+test('prompt builder includes runtime commands and current contract checkpoint context', () => {
+  const state = createInitialRuntimeState({ presetMetadata });
+  const bootstrapped = bootstrapFlowState(state, {
+    agent: 'codex',
+    mode: 'interactive'
+  });
+
+  assert.match(buildRuntimeCommandReference(), /prodify setup-agent <agent>/);
+  assert.match(buildRuntimeCommandReference(), /\.prodify\/contracts\/\*\.contract\.json/);
+  assert.match(buildRuntimeCommandReference({ concise: true }), /\$prodify-resume/);
+  assert.match(buildBootstrapPrompt('codex'), /Read \.prodify\/AGENTS\.md/);
+  assert.match(buildBootstrapPrompt('claude'), /Read \.prodify\/AGENTS\.md/);
+  assert.match(buildBootstrapPrompt('copilot'), /Read \.prodify\/AGENTS\.md/);
+  assert.match(buildBootstrapPrompt('opencode'), /Read \.prodify\/AGENTS\.md/);
+  assert.match(buildExecutionPrompt(bootstrapped), /Current task: 01-understand/);
+  assert.equal(stageToTaskId('validate'), '06-validate');
+});

package/tests/unit/targets.test.js

@@ -0,0 +1,13 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { RUNTIME_PROFILES, listRuntimeProfiles } from '../../dist/core/targets.js';
+
+test('runtime profiles expose all supported agents and bootstrap prompts', () => {
+  assert.deepEqual(Object.keys(RUNTIME_PROFILES).sort(), ['claude', 'codex', 'copilot', 'opencode']);
+
+  for (const profile of listRuntimeProfiles()) {
+    assert.match(profile.bootstrapPrompt, /\.prodify\/AGENTS\.md/);
+    assert.equal(profile.resumeCommand, '$prodify-resume');
+  }
+});