@urielsh/prodify 0.1.0

package/src/types.ts

@@ -0,0 +1,329 @@
+export type RuntimeProfileName = 'codex' | 'claude' | 'copilot' | 'opencode';
+export type ExecutionMode = 'interactive' | 'auto';
+export type FlowStage = 'understand' | 'diagnose' | 'architecture' | 'plan' | 'refactor' | 'validate';
+export type RuntimeStatus = 'not_bootstrapped' | 'ready' | 'running' | 'awaiting_validation' | 'blocked' | 'failed' | 'complete';
+export type ValidationResult = 'unknown' | 'pass' | 'fail' | 'inconclusive';
+export type ContractArtifactFormat = 'markdown' | 'json';
+export type SkillCategory = 'stage-method' | 'domain' | 'quality-policy';
+export type RepoContextFact = 'language' | 'framework' | 'project_type' | 'architecture_pattern' | 'risk_signal';
+export type ContractRuntimeState =
+  | 'not_bootstrapped'
+  | 'bootstrapped'
+  | 'understand_pending'
+  | 'understand_complete'
+  | 'diagnose_pending'
+  | 'diagnose_complete'
+  | 'architecture_pending'
+  | 'architecture_complete'
+  | 'plan_pending'
+  | 'plan_complete'
+  | 'refactor_pending'
+  | 'refactor_complete'
+  | 'validate_pending'
+  | 'validate_complete'
+  | 'blocked'
+  | 'failed'
+  | 'completed';
+export type ScoreSnapshotKind = 'baseline' | 'final';
+export type ScoreMetricStatus = 'pass' | 'partial' | 'fail' | 'unavailable';
+
+export interface OutputWriter {
+  write(chunk: string): void;
+}
+
+export interface CommandContext {
+  cwd: string;
+  stdout: OutputWriter;
+  stderr: OutputWriter;
+}
+
+export type CommandHandler = (args: string[], context: CommandContext) => Promise<number>;
+
+export interface VersionMetadata {
+  name: string;
+  version: string;
+  schemaVersion: string;
+}
+
+export interface ParsedVersionMetadata {
+  presetName: string;
+  presetVersion: string;
+  schemaVersion: string;
+}
+
+export interface PresetEntry {
+  relativePath: string;
+  content: string;
+}
+
+export interface LoadedPreset {
+  metadata: VersionMetadata;
+  entries: PresetEntry[];
+}
+
+export interface FileEntry {
+  fullPath: string;
+  relativePath: string;
+}
+
+export interface RuntimeTimestamps {
+  bootstrapped_at: string | null;
+  last_transition_at: string | null;
+  completed_at: string | null;
+}
+
+export interface CompiledContractArtifactRule {
+  path: string;
+  format: ContractArtifactFormat;
+  required_sections: string[];
+  required_json_keys: string[];
+}
+
+export interface SkillConditionPredicate {
+  fact: RepoContextFact;
+  includes: string;
+}
+
+export interface SkillCondition {
+  all: SkillConditionPredicate[];
+}
+
+export interface SkillDefinition {
+  schema_version: string;
+  id: string;
+  name: string;
+  version: string;
+  category: SkillCategory;
+  description: string;
+  intended_use: string[];
+  stage_compatibility: FlowStage[];
+  activation_conditions: SkillCondition[];
+  execution_guidance: string[];
+  caution_guidance: string[];
+}
+
+export interface SkillRegistryManifest {
+  schema_version: string;
+  skills: string[];
+}
+
+export interface StageSkillRoutingRule {
+  skill: string;
+  when: SkillCondition;
+  reason: string;
+}
+
+export interface StageSkillRouting {
+  default_skills: string[];
+  allowed_skills: string[];
+  conditional_skills: StageSkillRoutingRule[];
+}
+
+export interface CompiledStageContract {
+  schema_version: string;
+  contract_version: string;
+  stage: FlowStage;
+  task_id: string;
+  source_path: string;
+  source_hash: string;
+  required_artifacts: CompiledContractArtifactRule[];
+  allowed_write_roots: string[];
+  forbidden_writes: string[];
+  policy_rules: string[];
+  success_criteria: string[];
+  skill_routing: StageSkillRouting;
+}
+
+export interface ContractSourceDocument {
+  frontmatter: Record<string, unknown>;
+  body: string;
+}
+
+export interface CompiledContractInventory {
+  ok: boolean;
+  sourceCount: number;
+  compiledCount: number;
+  staleStages: FlowStage[];
+  missingCompiledStages: FlowStage[];
+  missingSourceStages: FlowStage[];
+  invalidStages: string[];
+}
+
+export interface ValidationIssue {
+  rule: string;
+  message: string;
+  path?: string;
+}
+
+export interface StageValidationResult {
+  stage: FlowStage;
+  contract_version: string;
+  passed: boolean;
+  violated_rules: ValidationIssue[];
+  missing_artifacts: string[];
+  warnings: string[];
+  diagnostics: string[];
+}
+
+export interface RuntimeFailureMetadata {
+  stage: FlowStage | null;
+  contract_version: string | null;
+  reason: string;
+}
+
+export interface RuntimeBootstrapMetadata {
+  bootstrapped: boolean;
+}
+
+export interface RuntimeStateBlock {
+  status: RuntimeStatus;
+  current_state: ContractRuntimeState;
+  mode: ExecutionMode | null;
+  current_stage: FlowStage | null;
+  current_task_id: string | null;
+  pending_stage: FlowStage | null;
+  completed_stages: FlowStage[];
+  awaiting_user_validation: boolean;
+  last_validation_result: ValidationResult;
+  last_validation: StageValidationResult | null;
+  last_validated_contract_versions: Partial<Record<FlowStage, string>>;
+  resumable: boolean;
+  blocked_reason: string | null;
+  failure_metadata: RuntimeFailureMetadata | null;
+  bootstrap: RuntimeBootstrapMetadata;
+  next_action: string;
+  timestamps: RuntimeTimestamps;
+}
+
+export interface ProdifyState {
+  schema_version: string;
+  preset_name: string;
+  preset_version: string;
+  runtime: RuntimeStateBlock;
+}
+
+export interface ResumeDecision {
+  resumable: boolean;
+  command: string | null;
+  reason: string;
+}
+
+export interface RuntimeProfile {
+  name: RuntimeProfileName;
+  displayName: string;
+  bootstrapPrompt: string;
+  bootstrapSummary: string;
+  executeCommand: '$prodify-execute' | '$prodify-execute --auto';
+  resumeCommand: '$prodify-resume';
+  nuances: string[];
+}
+
+export interface RepoContextSnapshot {
+  languages: string[];
+  frameworks: string[];
+  project_types: string[];
+  architecture_patterns: string[];
+  risk_signals: string[];
+}
+
+export interface SkillActivationRecord {
+  id: string;
+  name: string;
+  category: SkillCategory;
+  source: 'default' | 'conditional';
+  active: boolean;
+  reason: string;
+}
+
+export interface StageSkillResolution {
+  stage: FlowStage;
+  context: RepoContextSnapshot;
+  considered_skills: SkillActivationRecord[];
+  active_skill_ids: string[];
+}
+
+export interface VersionInspection {
+  status: 'missing' | 'current' | 'outdated' | 'malformed';
+  current: ParsedVersionMetadata | null;
+  expected: VersionMetadata;
+  schemaMigrationRequired: boolean;
+}
+
+export interface StatusReport {
+  ok: boolean;
+  initialized: boolean;
+  canonicalOk: boolean;
+  canonicalMissing: string[];
+  contractsOk: boolean;
+  contractInventory: CompiledContractInventory | null;
+  versionStatus: VersionInspection;
+  configuredAgents: RuntimeProfileName[];
+  runtimeState: ProdifyState | null;
+  runtimeStateError: Error | null;
+  resumable: boolean;
+  manualBootstrapReady: boolean;
+  bootstrapProfile: RuntimeProfileName;
+  bootstrapPrompt: string;
+  stageSkillResolution: StageSkillResolution | null;
+  recommendedNextAction: string;
+  presetMetadata: VersionMetadata;
+}
+
+export interface DoctorCheck {
+  label: string;
+  ok: boolean;
+  skipped?: boolean;
+  details?: string;
+}
+
+export interface DoctorResult {
+  ok: boolean;
+  checks: DoctorCheck[];
+}
+
+export interface UpdateSummary {
+  versionStatus: VersionInspection['status'];
+  schemaMigrationRequired: boolean;
+  writtenCanonicalCount: number;
+  preservedCanonicalCount: number;
+  compiledContractCount: number;
+}
+
+export interface ScoreMetric {
+  id: string;
+  label: string;
+  tool: string;
+  weight: number;
+  max_points: number;
+  points: number;
+  status: ScoreMetricStatus;
+  details: string;
+}
+
+export interface ScoreSnapshot {
+  schema_version: string;
+  kind: ScoreSnapshotKind;
+  ecosystems: string[];
+  total_score: number;
+  max_score: number;
+  metrics: ScoreMetric[];
+}
+
+export interface ScoreDelta {
+  schema_version: string;
+  baseline_score: number;
+  final_score: number;
+  delta: number;
+}
+
+export interface AgentSetupRecord {
+  agent: RuntimeProfileName;
+  display_name: string;
+  configured_at: string;
+  commands: string[];
+}
+
+export interface GlobalAgentSetupState {
+  schema_version: string;
+  configured_agents: Partial<Record<RuntimeProfileName, AgentSetupRecord>>;
+}

package/tests/integration/cli-flows.test.js

@@ -0,0 +1,347 @@
+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, failFlowStage, startFlowExecution } from '../../dist/core/flow-state.js';
+import { readRuntimeState, writeRuntimeState } from '../../dist/core/state.js';
+import { createTempDir, createTempRepo, memoryStream } from '../unit/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 readRepoFile(repoRoot, relativePath) {
+  return fs.readFile(path.join(repoRoot, relativePath), 'utf8');
+}
+
+async function assertMissing(repoRoot, relativePath) {
+  await assert.rejects(fs.access(path.join(repoRoot, relativePath)));
+}
+
+test('status reports an uninitialized repo cleanly', async () => {
+  const repoRoot = await createTempRepo();
+
+  const result = await execCli(repoRoot, ['status']);
+
+  assert.equal(result.exitCode, 1);
+  assert.match(result.stdout, /Repository: not initialized/);
+  assert.match(result.stdout, /Recommended next action: prodify init/);
+});
+
+test('init creates only .prodify-owned runtime scaffolding', async () => {
+  const repoRoot = await createTempRepo();
+
+  const result = await execCli(repoRoot, ['init']);
+
+  assert.equal(result.exitCode, 0);
+  assert.match(result.stdout, /Initialized Prodify/);
+  assert.match(result.stdout, /prodify setup-agent <agent>/);
+  assert.match(result.stdout, /Manual bootstrap starts by telling your agent to read \.prodify\/AGENTS\.md/);
+  assert.match(result.stdout, /Compiled runtime contracts were generated under \.prodify\/contracts\//);
+  await fs.access(path.join(repoRoot, '.prodify', 'state.json'));
+  await fs.access(path.join(repoRoot, '.prodify', 'runtime-commands.md'));
+  await fs.access(path.join(repoRoot, '.prodify', 'contracts-src', 'understand.contract.md'));
+  await fs.access(path.join(repoRoot, '.prodify', 'contracts', 'understand.contract.json'));
+  await fs.access(path.join(repoRoot, '.prodify', 'artifacts', 'README.md'));
+  await fs.access(path.join(repoRoot, '.prodify', 'metrics', 'README.md'));
+  await assertMissing(repoRoot, 'AGENTS.md');
+  await assertMissing(repoRoot, 'CLAUDE.md');
+  await assertMissing(repoRoot, '.github/copilot-instructions.md');
+  await assertMissing(repoRoot, '.opencode/AGENTS.md');
+});
+
+test('status becomes the primary user-facing summary after init', async () => {
+  const repoRoot = await createTempRepo();
+  await execCli(repoRoot, ['init']);
+
+  const result = await execCli(repoRoot, ['status']);
+
+  assert.equal(result.exitCode, 0);
+  assert.match(result.stdout, /Workspace health: healthy/);
+  assert.match(result.stdout, /Canonical files: healthy/);
+  assert.match(result.stdout, /Contract freshness: 6 compiled, synchronized/);
+  assert.match(result.stdout, /Version\/schema: current/);
+  assert.match(result.stdout, /Repo runtime binding: agent-agnostic/);
+  assert.match(result.stdout, /Global agent setup: none configured/);
+  assert.match(result.stdout, /Skill routing stage: understand/);
+  assert.match(result.stdout, /Skills considered: codebase-scanning/);
+  assert.match(result.stdout, /Skills active: codebase-scanning/);
+  assert.match(result.stdout, /Execution state: not bootstrapped/);
+  assert.match(result.stdout, /Stage validation: not run yet/);
+  assert.match(result.stdout, /Manual bootstrap: ready/);
+  assert.match(result.stdout, /Bootstrap prompt: Read \.prodify\/AGENTS\.md/);
+  assert.match(result.stdout, /Recommended next action: prodify setup-agent <agent>/);
+});
+
+test('setup-agent configures a supported agent globally without repo-local writes', async () => {
+  const cwd = await createTempDir();
+
+  const result = await execCli(cwd, ['setup-agent', 'codex']);
+
+  assert.equal(result.exitCode, 0);
+  assert.match(result.stdout, /Prodify Agent Setup/);
+  assert.match(result.stdout, /Agent: codex/);
+  assert.match(result.stdout, /Repo impact: none/);
+  await fs.access(path.join(cwd, '.prodify-home', 'agent-setup.json'));
+  await assertMissing(cwd, '.prodify');
+});
+
+test('multiple agents can be set up independently and status uses configured setup for bootstrap guidance', async () => {
+  const repoRoot = await createTempRepo();
+
+  await execCli(repoRoot, ['setup-agent', 'codex']);
+  await execCli(repoRoot, ['setup-agent', 'claude']);
+  await execCli(repoRoot, ['init']);
+
+  const result = await execCli(repoRoot, ['status', '--agent', 'claude']);
+
+  assert.equal(result.exitCode, 0);
+  assert.match(result.stdout, /Global agent setup: claude, codex/);
+  assert.match(result.stdout, /Skill routing stage: understand/);
+  assert.match(result.stdout, /Bootstrap profile: claude/);
+  assert.match(result.stdout, /tell your agent:/);
+});
+
+test('doctor validates healthy setup after init', async () => {
+  const repoRoot = await createTempRepo();
+  await execCli(repoRoot, ['init']);
+
+  const result = await execCli(repoRoot, ['doctor']);
+
+  assert.equal(result.exitCode, 0);
+  assert.match(result.stdout, /canonical: PASS/);
+  assert.match(result.stdout, /contracts\/source: PASS/);
+  assert.match(result.stdout, /contracts\/compiled: PASS/);
+  assert.match(result.stdout, /canonical\/schema: PASS/);
+  assert.match(result.stdout, /runtime\/state: PASS/);
+  assert.match(result.stdout, /gitignore\/prodify: PASS/);
+  assert.match(result.stdout, /bootstrap\/guidance: PASS/);
+  assert.doesNotMatch(result.stdout, /compatibility\//);
+});
+
+test('update is a no-op refresh on a current repo', async () => {
+  const repoRoot = await createTempRepo();
+  await execCli(repoRoot, ['init']);
+
+  const result = await execCli(repoRoot, ['update']);
+
+  assert.equal(result.exitCode, 0);
+  assert.match(result.stdout, /Prodify Update/);
+  assert.match(result.stdout, /Version\/schema: current/);
+  assert.match(result.stdout, /Canonical assets: /);
+  assert.match(result.stdout, /Compiled contracts: 6/);
+  assert.match(result.stdout, /Legacy compatibility adapters: not part of the default flow/);
+});
+
+test('update repairs outdated version metadata and restores .prodify runtime assets only', async () => {
+  const repoRoot = await createTempRepo();
+  await execCli(repoRoot, ['init']);
+
+  await fs.writeFile(path.join(repoRoot, '.prodify', 'version.json'), '{\n  "schema_version": "1",\n  "preset_name": "default",\n  "preset_version": "1.0.0"\n}\n', 'utf8');
+  await fs.rm(path.join(repoRoot, '.prodify', 'runtime-commands.md'));
+
+  const result = await execCli(repoRoot, ['update']);
+
+  assert.equal(result.exitCode, 0);
+  assert.match(result.stdout, /Version\/schema: outdated/);
+  await fs.access(path.join(repoRoot, '.prodify', 'runtime-commands.md'));
+  await assertMissing(repoRoot, 'AGENTS.md');
+  await assertMissing(repoRoot, 'CLAUDE.md');
+  await assertMissing(repoRoot, '.github/copilot-instructions.md');
+  await assertMissing(repoRoot, '.opencode/AGENTS.md');
+});
+
+test('update preserves user-owned canonical files', async () => {
+  const repoRoot = await createTempRepo();
+  await execCli(repoRoot, ['init']);
+
+  await fs.writeFile(path.join(repoRoot, '.prodify', 'AGENTS.md'), '# Canonical\n\nCustom operator guidance.\n', 'utf8');
+  await fs.writeFile(path.join(repoRoot, '.prodify', 'project.md'), '# Project\n\nCustom project context.\n', 'utf8');
+
+  const result = await execCli(repoRoot, ['update']);
+
+  assert.equal(result.exitCode, 0);
+  assert.match(await readRepoFile(repoRoot, '.prodify/AGENTS.md'), /Custom operator guidance/);
+  assert.match(await readRepoFile(repoRoot, '.prodify/project.md'), /Custom project context/);
+  await assertMissing(repoRoot, 'AGENTS.md');
+});
+
+test('source-only contract edits are detected until compiled contracts are refreshed', async () => {
+  const repoRoot = await createTempRepo();
+  await execCli(repoRoot, ['init']);
+
+  await fs.appendFile(path.join(repoRoot, '.prodify', 'contracts-src', 'understand.contract.md'), '\nAdditional editing note.\n', 'utf8');
+
+  const result = await execCli(repoRoot, ['status']);
+
+  assert.equal(result.exitCode, 1);
+  assert.match(result.stdout, /Contract freshness: stale: understand/);
+  assert.match(result.stdout, /Recommended next action: prodify update/);
+});
+
+test('status reports malformed runtime state and recommends update', async () => {
+  const repoRoot = await createTempRepo();
+  await execCli(repoRoot, ['init']);
+  await fs.writeFile(path.join(repoRoot, '.prodify', 'state.json'), '{bad json\n', 'utf8');
+
+  const result = await execCli(repoRoot, ['status']);
+
+  assert.equal(result.exitCode, 1);
+  assert.match(result.stdout, /Runtime state: Runtime state is malformed/);
+  assert.match(result.stdout, /Recommended next action: prodify update/);
+});
+
+test('doctor fails clearly when .gitignore hides .prodify', async () => {
+  const repoRoot = await createTempRepo();
+  await execCli(repoRoot, ['init']);
+  await fs.writeFile(path.join(repoRoot, '.gitignore'), '.prodify/\n', 'utf8');
+
+  const result = await execCli(repoRoot, ['doctor']);
+
+  assert.equal(result.exitCode, 1);
+  assert.match(result.stdout, /gitignore\/prodify: FAIL/);
+});
+
+test('runtime bootstrap and resume readiness are reflected in status', async () => {
+  const repoRoot = await createTempRepo();
+  await execCli(repoRoot, ['setup-agent', 'codex']);
+  await execCli(repoRoot, ['init']);
+
+  const initial = await readRuntimeState(repoRoot, {
+    presetMetadata: {
+      name: 'default',
+      version: '4.0.0',
+      schemaVersion: '4'
+    }
+  });
+  const bootstrapped = bootstrapFlowState(initial, {
+    agent: 'codex',
+    mode: 'interactive'
+  });
+  const running = startFlowExecution(bootstrapped);
+  await writeRuntimeState(repoRoot, running);
+
+  const result = await execCli(repoRoot, ['status']);
+
+  assert.equal(result.exitCode, 0);
+  assert.match(result.stdout, /Workspace health: healthy/);
+  assert.match(result.stdout, /Repo runtime binding: agent-agnostic/);
+  assert.match(result.stdout, /Global agent setup: codex/);
+  assert.match(result.stdout, /Skill routing stage: understand/);
+  assert.match(result.stdout, /Skills active: codebase-scanning/);
+  assert.match(result.stdout, /Execution state: understand_pending at understand \(01-understand\)/);
+  assert.match(result.stdout, /Stage validation: not run yet/);
+  assert.match(result.stdout, /Resumable: yes/);
+  assert.match(result.stdout, /Recommended next action: \$prodify-resume/);
+});
+
+test('status distinguishes stage-validation failure from workspace health issues', async () => {
+  const repoRoot = await createTempRepo();
+  await execCli(repoRoot, ['setup-agent', 'codex']);
+  await execCli(repoRoot, ['init']);
+
+  const initial = await readRuntimeState(repoRoot, {
+    presetMetadata: {
+      name: 'default',
+      version: '4.0.0',
+      schemaVersion: '4'
+    }
+  });
+  const bootstrapped = bootstrapFlowState(initial, {
+    agent: 'codex',
+    mode: 'interactive'
+  });
+  const running = startFlowExecution(bootstrapped);
+  const failed = failFlowStage(running, {
+    reason: 'Required artifact .prodify/artifacts/01-understand.md is missing.'
+  });
+  await writeRuntimeState(repoRoot, failed);
+
+  const result = await execCli(repoRoot, ['status']);
+
+  assert.equal(result.exitCode, 1);
+  assert.match(result.stdout, /Workspace health: healthy/);
+  assert.match(result.stdout, /Stage validation: failed at understand:/);
+  assert.match(result.stdout, /Recommended next action: rerun or remediate stage outputs/);
+});
+
+test('status can render a deterministic bootstrap prompt for a requested profile', async () => {
+  const repoRoot = await createTempRepo();
+  await execCli(repoRoot, ['setup-agent', 'claude']);
+  await execCli(repoRoot, ['init']);
+
+  const result = await execCli(repoRoot, ['status', '--agent', 'claude']);
+
+  assert.equal(result.exitCode, 0);
+  assert.match(result.stdout, /Bootstrap profile: claude/);
+  assert.match(result.stdout, /Bootstrap prompt: Read \.prodify\/AGENTS\.md/);
+});
+
+test('canonical runtime instructions live inside .prodify guidance', async () => {
+  const repoRoot = await createTempRepo();
+  await execCli(repoRoot, ['init']);
+
+  const guidance = await readRepoFile(repoRoot, '.prodify/AGENTS.md');
+  const runtimeCommands = await readRepoFile(repoRoot, '.prodify/runtime-commands.md');
+
+  assert.match(guidance, /Read \.prodify\/AGENTS\.md and bootstrap Prodify/);
+  assert.match(guidance, /\.prodify\/contracts-src\//);
+  assert.match(guidance, /prodify setup-agent/);
+  assert.match(guidance, /\$prodify-init/);
+  assert.match(runtimeCommands, /\$prodify-execute/);
+  assert.match(runtimeCommands, /prodify setup-agent/);
+  assert.match(runtimeCommands, /compiled-contract validation/i);
+  assert.match(runtimeCommands, /\$prodify-resume/);
+});
+
+test('no command path can create root-level legacy adapter files', async () => {
+  const repoRoot = await createTempRepo();
+  await execCli(repoRoot, ['init']);
+  await execCli(repoRoot, ['update']);
+
+  await assertMissing(repoRoot, 'AGENTS.md');
+  await assertMissing(repoRoot, 'CLAUDE.md');
+  await assertMissing(repoRoot, '.github/copilot-instructions.md');
+  await assertMissing(repoRoot, '.opencode/AGENTS.md');
+});
+
+test('removed legacy commands are not available anymore', async () => {
+  const repoRoot = await createTempRepo();
+  const result = await execCli(repoRoot, ['install', '--agent', 'codex']);
+
+  assert.equal(result.exitCode, 1);
+  assert.match(result.stderr, /Unknown command: install/);
+});
+
+test('README and help output match the lifecycle model', async () => {
+  const repoRoot = await createTempRepo();
+  const readme = await fs.readFile(path.join(process.cwd(), 'README.md'), 'utf8');
+  const compatibilityTargets = await fs.readFile(path.join(process.cwd(), 'docs', 'compatibility-targets.md'), 'utf8');
+  const codexSupport = await fs.readFile(path.join(process.cwd(), 'docs', 'codex-support.md'), 'utf8');
+  const help = await execCli(repoRoot, ['--help']);
+
+  assert.match(readme, /prodify setup-agent codex/);
+  assert.match(readme, /prodify status/);
+  assert.match(readme, /read `\.prodify\/AGENTS\.md`/i);
+  assert.match(readme, /`\.prodify\/skills\/`/);
+  assert.match(readme, /No root-level agent files are required/i);
+  assert.match(readme, /Repo initialization stays agent-agnostic/i);
+  assert.match(readme, /root `AGENTS\.md`.*repository-local contributor guidance/i);
+  assert.doesNotMatch(readme, /prodify install --agent/);
+  assert.match(compatibilityTargets, /do not create root-level compatibility files/i);
+  assert.match(codexSupport, /not part of the default lifecycle/i);
+  assert.match(help.stdout, /prodify setup-agent/);
+  assert.match(help.stdout, /prodify status/);
+  assert.match(help.stdout, /prodify update/);
+  assert.doesNotMatch(help.stdout, /prodify install/);
+});