@urielsh/prodify 0.1.0 → 0.1.2

package/README.md

@@ -1,92 +1,124 @@
 # Prodify
 
-Prodify turns AI- or vibe-coded repositories into production-grade code through a deterministic, agent-native workflow.
+Prodify turns AI- and vibe-coded repositories into production-grade repositories through a deterministic, agent-native workflow.
 
-## Product Purpose
+It gives a repo a repeatable upgrade path instead of relying on ad hoc prompting, one-off cleanup passes, or agent memory. The CLI bootstraps the runtime. The coding agent executes the staged transformation flow inside the repo.
 
-Fast AI-generated code drifts into inconsistent structure, weak validation, and unclear ownership. Prodify gives that repo a repeatable upgrade path instead of relying on ad hoc prompting.
+## Why Prodify
 
-## Architecture
+- Turn messy AI-generated repos into structured, reviewable systems.
+- Keep runtime state, tasks, artifacts, contracts, and metrics inside `.prodify/`.
+- Separate repository setup from in-agent execution.
+- Validate stage outputs against compiled contracts instead of trusting freeform agent claims.
 
-Prodify has two layers:
+## Quick Start
 
-- external CLI for repository setup and health
-- inside-agent runtime commands for actually running the contract-driven transformation flow
+Install Prodify from npm:
 
-External CLI:
-
-- `prodify init`
-- `prodify status`
-- `prodify doctor`
-- `prodify update`
+```sh
+npm install -g @urielsh/prodify
+```
 
-Inside the agent:
+Prepare your coding agent once per machine:
 
-- read `.prodify/AGENTS.md`
-- `$prodify-init`
-- `$prodify-execute`
-- `$prodify-execute --auto`
-- `$prodify-resume`
+```sh
+prodify setup-agent codex
+```
 
-## Repo Model
+Initialize a target repository:
 
-- `.prodify/` is the only required product-owned footprint.
-- No root-level agent files are required in the default flow.
-- If this repository contains a root `AGENTS.md`, treat it as repository-local contributor guidance for developing Prodify itself, not as a generated or required product runtime file.
-- All durable workflow state lives in `.prodify/`.
-- Humans edit stage contracts under `.prodify/contracts-src/`.
-- Runtime execution reads only compiled contracts under `.prodify/contracts/`.
-- Product-owned skill definitions live under `.prodify/skills/`.
-- Stage outputs live under `.prodify/artifacts/`.
-- Local baseline/final/delta scoring lives under `.prodify/metrics/`.
-- This repository’s checked-in repo-root `.prodify/` directory is the self-hosting workspace for Prodify itself. It includes the generated runtime layout plus repo-specific design and development artifacts, so it is not a byte-for-byte snapshot of fresh `prodify init` output.
+```sh
+cd path/to/your-repo
+prodify init
+```
 
-## User Flow
+Then open your coding agent and start the runtime:
 
-1. Set up an agent once per machine:
+```text
+Read .prodify/AGENTS.md and bootstrap Prodify for this repository.
+```
 
-```sh
-prodify setup-agent codex
+```text
+$prodify-init
+$prodify-execute
 ```
 
-2. Initialize the repository:
+Use `$prodify-execute --auto` to continue without pausing between stages, or `$prodify-resume` to continue an interrupted run.
 
-```sh
-npm run build
-node ./dist/index.js init
-```
+## Using Prodify In Your Repo
 
-3. Open the supported agent you want to use.
+1. Install the npm package.
+2. Run `prodify setup-agent <agent>` once per machine for the agent you use.
+3. Run `prodify init` inside the repository you want to upgrade.
+4. Open that repository in a supported coding agent.
+5. Tell the agent to read `.prodify/AGENTS.md`.
+6. Run `$prodify-init`, then continue with `$prodify-execute` or `$prodify-execute --auto`.
 
-- Codex
-- Claude
-- Copilot
-- OpenCode
+Repo initialization stays agent-agnostic. The active runtime is resolved when `$prodify-init` runs inside the opened agent, not when `prodify init` creates `.prodify/`.
+
+## How It Works
 
-4. Tell it: `Read .prodify/AGENTS.md and bootstrap Prodify for this repository.`
+- `prodify init` creates the `.prodify/` runtime workspace in the repo.
+- The agent reads `.prodify/AGENTS.md` as the runtime entrypoint.
+- `$prodify-init` prepares the in-agent run state.
+- `$prodify-execute` runs one stage at a time.
+- `$prodify-execute --auto` keeps advancing until a hard stop.
+- `$prodify-resume` continues from the saved runtime state.
 
-5. Inside that agent, run `$prodify-init`.
+Stage order:
 
-6. Run `$prodify-execute` for stage-by-stage execution, or `$prodify-execute --auto` to continue until a hard stop.
+- `understand`
+- `diagnose`
+- `architecture`
+- `plan`
+- `refactor`
+- `validate`
+
+## CLI Commands
+
+- `prodify setup-agent <codex|claude|copilot|opencode>`
+  One-time machine setup for the coding agent runtime.
+- `prodify init`
+  Create the `.prodify/` workspace in a repository.
+- `prodify status`
+  Inspect runtime state and recommended next actions.
+- `prodify doctor`
+  Check runtime health, generated files, and execution readiness.
+- `prodify update`
+  Refresh the local Prodify workspace, compiled contracts, and related runtime assets.
+
+## Agent Runtime Commands
+
+- `$prodify-init`
+  Bootstrap Prodify inside the opened coding agent.
+- `$prodify-execute`
+  Run the next workflow stage interactively.
+- `$prodify-execute --auto`
+  Continue across stages until a hard stop or policy gate.
+- `$prodify-resume`
+  Continue from the saved `.prodify/state.json` runtime state.
 
-7. If the flow pauses for validation or is interrupted, continue with `$prodify-resume`.
-8. Use `prodify status`, `prodify doctor`, and `prodify update` from the CLI to inspect or refresh the `.prodify/` scaffolding, compiled contracts, and local metrics workspace.
+## Repo Model
 
-Repo initialization stays agent-agnostic. The active agent is resolved when `$prodify-init` runs inside the opened agent, not when `prodify init` creates `.prodify/`.
+- `.prodify/` is the only required product-owned footprint.
+- Durable workflow state lives in `.prodify/state.json`.
+- Tasks live under `.prodify/tasks/`.
+- Stage outputs live under `.prodify/artifacts/`.
+- Skill definitions live under `.prodify/skills/`.
+- Local baseline, final, and delta scoring artifacts live under `.prodify/metrics/`.
+- No root-level agent files are required in the default product flow.
 
 ## Contracts And Validation
 
-- Contract source files are Markdown with YAML frontmatter under `.prodify/contracts-src/`.
-- `prodify init` and `prodify update` compile those sources into deterministic runtime JSON under `.prodify/contracts/`.
-- Each stage can also declare bounded `skill_routing` metadata, while concrete skill definitions stay versioned under `.prodify/skills/`.
-- Status can report which stage skills were considered and activated from repository context, but contracts and validators remain authoritative.
-- Stage completion is gated by compiled-contract validation, not by agent assertion alone.
+- Humans edit contract sources under `.prodify/contracts-src/`.
+- Runtime execution reads only compiled contracts under `.prodify/contracts/`.
+- Stage completion is gated by compiled-contract validation.
 - Validation checks required artifacts, write boundaries, forbidden writes, Markdown sections, JSON keys, and contract criteria.
 
 ## Local Scoring
 
-- Prodify can persist local baseline, final, and delta score artifacts under `.prodify/metrics/`.
-- Raw tool outputs and normalized scores are stored separately so the score is traceable and deterministic.
+- Prodify can persist baseline, final, and delta score artifacts under `.prodify/metrics/`.
+- Raw outputs and normalized scores are stored separately so scoring stays traceable and deterministic.
 
 ## Supported Agents
 
@@ -95,24 +127,32 @@ Repo initialization stays agent-agnostic. The active agent is resolved when `$pr
 - Copilot
 - OpenCode
 
-All supported agents use the same `.prodify/AGENTS.md` bootstrap path in the current product model.
+All supported agents share the same bootstrap path: read `.prodify/AGENTS.md`, then run `$prodify-init`.
 
-## Development
+## Development / Contributing
 
-Run the test suite:
+Prodify users and Prodify contributors follow different entrypoints:
+
+- Product users start from `.prodify/AGENTS.md` inside the repository they want to improve.
+- Contributors working on the Prodify source repository follow the root [AGENTS.md](/Users/urielsh/projects/prodify/AGENTS.md).
+
+In this repository, root `AGENTS.md` is repository-local contributor guidance. `.prodify/AGENTS.md` remains the runtime entrypoint for product users.
+
+For this self-hosting repository, the checked-in repo-root `.prodify/` directory is a development workspace for Prodify itself, not a byte-for-byte snapshot of fresh `prodify init` output.
+
+Run the source-repo test suite with:
 
 ```sh
 npm test
 ```
 
-The implementation lives primarily in:
+The main implementation lives in:
+
 - `src/`
 - `assets/presets/default/`
 - `tests/`
 - `docs/`
 
-Repository-local contributor guidance for this self-hosted repo lives in root [AGENTS.md](/Users/urielsh/projects/prodify/AGENTS.md). Product runtime guidance lives in [.prodify/AGENTS.md](/Users/urielsh/projects/prodify/.prodify/AGENTS.md).
-
 ## License
 
 This project is licensed under the Apache License 2.0. See [LICENSE](./LICENSE).

package/dist/commands/setup-agent.js

@@ -17,6 +17,9 @@ export async function runSetupAgentCommand(args, context) {
     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/dist/core/agent-setup.js

@@ -6,6 +6,117 @@ import { pathExists, writeFileEnsuringDir } from './fs.js';
 import { getRuntimeProfile } from './targets.js';
 export const GLOBAL_AGENT_SETUP_SCHEMA_VERSION = '1';
 export const PRODIFY_RUNTIME_COMMANDS = ['$prodify-init', '$prodify-execute', '$prodify-resume'];
+function resolveCodexHome(env = process.env) {
+    const explicit = env.CODEX_HOME?.trim();
+    if (explicit) {
+        return path.resolve(explicit);
+    }
+    return path.join(os.homedir(), '.codex');
+}
+function resolveCodexSkillsRoot(env = process.env) {
+    return path.join(resolveCodexHome(env), 'skills');
+}
+function renderCodexSkill(name) {
+    if (name === 'prodify-init') {
+        return `---
+name: "prodify-init"
+description: "Bootstrap Prodify inside the current repository."
+metadata:
+  short-description: "Bootstrap Prodify inside the current repository."
+---
+
+<codex_skill_adapter>
+## A. Skill Invocation
+- This skill is invoked by mentioning \`$prodify-init\`.
+- Ignore trailing arguments unless the repository-specific runtime instructions require them.
+</codex_skill_adapter>
+
+# prodify-init
+
+Use this runtime bridge to bootstrap Prodify inside the current repository.
+
+Load and follow, in this order:
+- \`.prodify/AGENTS.md\`
+- \`.prodify/runtime-commands.md\`
+- \`.prodify/state.json\`
+
+Keep the runtime anchored to \`.prodify/\`.
+Do not substitute compatibility files for the canonical \`.prodify/AGENTS.md\` entrypoint.
+
+Available runtime commands:
+- \`$prodify-init\`
+- \`$prodify-execute\`
+- \`$prodify-execute --auto\`
+- \`$prodify-resume\`
+`;
+    }
+    if (name === 'prodify-execute') {
+        return `---
+name: "prodify-execute"
+description: "Execute the next Prodify workflow stage inside the current repository."
+metadata:
+  short-description: "Execute the next Prodify workflow stage."
+---
+
+<codex_skill_adapter>
+## A. Skill Invocation
+- This skill is invoked by mentioning \`$prodify-execute\`.
+- Treat all user text after \`$prodify-execute\` as \`{{PRODIFY_EXECUTE_ARGS}}\`.
+- If no arguments are present, treat \`{{PRODIFY_EXECUTE_ARGS}}\` as empty.
+</codex_skill_adapter>
+
+# prodify-execute
+
+Use this runtime bridge to execute the next Prodify workflow stage.
+
+Load and follow, in this order:
+- \`.prodify/runtime-commands.md\`
+- \`.prodify/state.json\`
+- \`.prodify/AGENTS.md\`
+
+Interpret \`{{PRODIFY_EXECUTE_ARGS}}\` as the runtime command arguments.
+- empty: run \`$prodify-execute\`
+- \`--auto\`: run \`$prodify-execute --auto\`
+
+Keep all execution state, artifacts, contracts, and validation anchored to \`.prodify/\`.
+`;
+    }
+    return `---
+name: "prodify-resume"
+description: "Resume a paused Prodify run from saved runtime state."
+metadata:
+  short-description: "Resume a paused Prodify run."
+---
+
+<codex_skill_adapter>
+## A. Skill Invocation
+- This skill is invoked by mentioning \`$prodify-resume\`.
+- Treat trailing arguments as optional runtime-specific hints only when the repository guidance explicitly supports them.
+</codex_skill_adapter>
+
+# prodify-resume
+
+Use this runtime bridge to resume Prodify from saved runtime state.
+
+Load and follow, in this order:
+- \`.prodify/runtime-commands.md\`
+- \`.prodify/state.json\`
+- \`.prodify/AGENTS.md\`
+
+Resume from the current state recorded under \`.prodify/state.json\`.
+Preserve validation checkpoints and stop clearly if the state is corrupt or non-resumable.
+`;
+}
+async function installCodexRuntimeCommands(env = process.env) {
+    const skillsRoot = resolveCodexSkillsRoot(env);
+    const installedFiles = [];
+    for (const command of ['prodify-init', 'prodify-execute', 'prodify-resume']) {
+        const skillPath = path.join(skillsRoot, command, 'SKILL.md');
+        await writeFileEnsuringDir(skillPath, renderCodexSkill(command));
+        installedFiles.push(skillPath);
+    }
+    return installedFiles;
+}
 function asRecord(value) {
     return typeof value === 'object' && value !== null ? value : {};
 }
@@ -102,10 +213,14 @@ export async function setupAgentIntegration(agent, { now = new Date().toISOStrin
         configured_at: now,
         commands: [...PRODIFY_RUNTIME_COMMANDS]
     };
+    const installedPaths = profile.name === 'codex'
+        ? await installCodexRuntimeCommands(env)
+        : [];
     const statePath = await writeGlobalAgentSetupState(nextState, { env });
     return {
         statePath,
         configuredAgents: listConfiguredAgents(nextState),
-        alreadyConfigured
+        alreadyConfigured,
+        installedPaths
     };
 }

package/dist/core/repo-root.js

@@ -39,15 +39,24 @@ export async function resolveRepoRoot(options = {}) {
         }
         return explicitRepo;
     }
-    const prodifyRoot = await searchUpwards(cwd, async (candidate) => directoryHas(candidate, '.prodify'));
-    if (prodifyRoot) {
-        return prodifyRoot;
-    }
-    if (allowBootstrap) {
-        const gitRoot = await searchUpwards(cwd, async (candidate) => directoryHas(candidate, '.git'));
-        if (gitRoot) {
-            return gitRoot;
+    let current = cwd;
+    while (true) {
+        const hasProdify = await directoryHas(current, '.prodify');
+        if (hasProdify) {
+            return current;
+        }
+        const hasGit = await directoryHas(current, '.git');
+        if (hasGit) {
+            if (allowBootstrap) {
+                return current;
+            }
+            break;
         }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
     }
     throw new ProdifyError('Could not resolve repository root from the current working directory.', {
         code: 'REPO_ROOT_NOT_FOUND'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@urielsh/prodify",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "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/core/agent-setup.ts

@@ -10,6 +10,126 @@ import type { GlobalAgentSetupState, RuntimeProfileName } from '../types.js';
 export const GLOBAL_AGENT_SETUP_SCHEMA_VERSION = '1';
 export const PRODIFY_RUNTIME_COMMANDS = ['$prodify-init', '$prodify-execute', '$prodify-resume'] as const;
 
+function resolveCodexHome(env: NodeJS.ProcessEnv = process.env): string {
+  const explicit = env.CODEX_HOME?.trim();
+  if (explicit) {
+    return path.resolve(explicit);
+  }
+
+  return path.join(os.homedir(), '.codex');
+}
+
+function resolveCodexSkillsRoot(env: NodeJS.ProcessEnv = process.env): string {
+  return path.join(resolveCodexHome(env), 'skills');
+}
+
+function renderCodexSkill(name: 'prodify-init' | 'prodify-execute' | 'prodify-resume'): string {
+  if (name === 'prodify-init') {
+    return `---
+name: "prodify-init"
+description: "Bootstrap Prodify inside the current repository."
+metadata:
+  short-description: "Bootstrap Prodify inside the current repository."
+---
+
+<codex_skill_adapter>
+## A. Skill Invocation
+- This skill is invoked by mentioning \`$prodify-init\`.
+- Ignore trailing arguments unless the repository-specific runtime instructions require them.
+</codex_skill_adapter>
+
+# prodify-init
+
+Use this runtime bridge to bootstrap Prodify inside the current repository.
+
+Load and follow, in this order:
+- \`.prodify/AGENTS.md\`
+- \`.prodify/runtime-commands.md\`
+- \`.prodify/state.json\`
+
+Keep the runtime anchored to \`.prodify/\`.
+Do not substitute compatibility files for the canonical \`.prodify/AGENTS.md\` entrypoint.
+
+Available runtime commands:
+- \`$prodify-init\`
+- \`$prodify-execute\`
+- \`$prodify-execute --auto\`
+- \`$prodify-resume\`
+`;
+  }
+
+  if (name === 'prodify-execute') {
+    return `---
+name: "prodify-execute"
+description: "Execute the next Prodify workflow stage inside the current repository."
+metadata:
+  short-description: "Execute the next Prodify workflow stage."
+---
+
+<codex_skill_adapter>
+## A. Skill Invocation
+- This skill is invoked by mentioning \`$prodify-execute\`.
+- Treat all user text after \`$prodify-execute\` as \`{{PRODIFY_EXECUTE_ARGS}}\`.
+- If no arguments are present, treat \`{{PRODIFY_EXECUTE_ARGS}}\` as empty.
+</codex_skill_adapter>
+
+# prodify-execute
+
+Use this runtime bridge to execute the next Prodify workflow stage.
+
+Load and follow, in this order:
+- \`.prodify/runtime-commands.md\`
+- \`.prodify/state.json\`
+- \`.prodify/AGENTS.md\`
+
+Interpret \`{{PRODIFY_EXECUTE_ARGS}}\` as the runtime command arguments.
+- empty: run \`$prodify-execute\`
+- \`--auto\`: run \`$prodify-execute --auto\`
+
+Keep all execution state, artifacts, contracts, and validation anchored to \`.prodify/\`.
+`;
+  }
+
+  return `---
+name: "prodify-resume"
+description: "Resume a paused Prodify run from saved runtime state."
+metadata:
+  short-description: "Resume a paused Prodify run."
+---
+
+<codex_skill_adapter>
+## A. Skill Invocation
+- This skill is invoked by mentioning \`$prodify-resume\`.
+- Treat trailing arguments as optional runtime-specific hints only when the repository guidance explicitly supports them.
+</codex_skill_adapter>
+
+# prodify-resume
+
+Use this runtime bridge to resume Prodify from saved runtime state.
+
+Load and follow, in this order:
+- \`.prodify/runtime-commands.md\`
+- \`.prodify/state.json\`
+- \`.prodify/AGENTS.md\`
+
+Resume from the current state recorded under \`.prodify/state.json\`.
+Preserve validation checkpoints and stop clearly if the state is corrupt or non-resumable.
+`;
+}
+
+async function installCodexRuntimeCommands(env: NodeJS.ProcessEnv = process.env): Promise<string[]> {
+  const skillsRoot = resolveCodexSkillsRoot(env);
+  const installedFiles: string[] = [];
+
+  for (const command of ['prodify-init', 'prodify-execute', 'prodify-resume'] as const) {
+    const skillPath = path.join(skillsRoot, command, 'SKILL.md');
+    await writeFileEnsuringDir(skillPath, renderCodexSkill(command));
+    installedFiles.push(skillPath);
+  }
+
+  return installedFiles;
+}
+
 function asRecord(value: unknown): Record<string, unknown> {
   return typeof value === 'object' && value !== null ? value as Record<string, unknown> : {};
 }
@@ -116,7 +236,7 @@ export async function setupAgentIntegration(
     now?: string;
     env?: NodeJS.ProcessEnv;
   } = {}
-): Promise<{ statePath: string; configuredAgents: RuntimeProfileName[]; alreadyConfigured: boolean }> {
+): Promise<{ statePath: string; configuredAgents: RuntimeProfileName[]; alreadyConfigured: boolean; installedPaths: string[] }> {
   const profile = getRuntimeProfile(agent);
   if (!profile) {
     throw new ProdifyError('setup-agent requires <codex|claude|copilot|opencode>.', {
@@ -138,10 +258,14 @@ export async function setupAgentIntegration(
     commands: [...PRODIFY_RUNTIME_COMMANDS]
   };
 
+  const installedPaths = profile.name === 'codex'
+    ? await installCodexRuntimeCommands(env)
+    : [];
   const statePath = await writeGlobalAgentSetupState(nextState, { env });
   return {
     statePath,
     configuredAgents: listConfiguredAgents(nextState),
-    alreadyConfigured
+    alreadyConfigured,
+    installedPaths
   };
 }

package/src/core/repo-root.ts

@@ -56,16 +56,29 @@ export async function resolveRepoRoot(options: ResolveRepoRootOptions = {}): Pro
     return explicitRepo;
   }
 
-  const prodifyRoot = await searchUpwards(cwd, async (candidate) => directoryHas(candidate, '.prodify'));
-  if (prodifyRoot) {
-    return prodifyRoot;
-  }
+  let current = cwd;
+
+  while (true) {
+    const hasProdify = await directoryHas(current, '.prodify');
+    if (hasProdify) {
+      return current;
+    }
+
+    const hasGit = await directoryHas(current, '.git');
+    if (hasGit) {
+      if (allowBootstrap) {
+        return current;
+      }
 
-  if (allowBootstrap) {
-    const gitRoot = await searchUpwards(cwd, async (candidate) => directoryHas(candidate, '.git'));
-    if (gitRoot) {
-      return gitRoot;
+      break;
     }
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+
+    current = parent;
   }
 
   throw new ProdifyError('Could not resolve repository root from the current working directory.', {

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

@@ -60,6 +60,19 @@ test('init creates only .prodify-owned runtime scaffolding', async () => {
   await assertMissing(repoRoot, '.opencode/AGENTS.md');
 });
 
+test('init prefers the current git repo over an unrelated ancestor .prodify workspace', async () => {
+  const outerRepo = await createTempRepo('prodify-outer-');
+  await execCli(outerRepo, ['init']);
+
+  const nestedRepo = path.join(outerRepo, 'nested-app');
+  await fs.mkdir(path.join(nestedRepo, '.git'), { recursive: true });
+
+  const result = await execCli(nestedRepo, ['init']);
+
+  assert.equal(result.exitCode, 0);
+  await fs.access(path.join(nestedRepo, '.prodify', 'state.json'));
+});
+
 test('status becomes the primary user-facing summary after init', async () => {
   const repoRoot = await createTempRepo();
   await execCli(repoRoot, ['init']);
@@ -85,14 +98,19 @@ test('status becomes the primary user-facing summary after init', async () => {
 
 test('setup-agent configures a supported agent globally without repo-local writes', async () => {
   const cwd = await createTempDir();
+  process.env.CODEX_HOME = path.join(cwd, '.codex-home');
 
   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, /Installed runtime commands:/);
   assert.match(result.stdout, /Repo impact: none/);
   await fs.access(path.join(cwd, '.prodify-home', 'agent-setup.json'));
+  await fs.access(path.join(cwd, '.codex-home', 'skills', 'prodify-init', 'SKILL.md'));
+  await fs.access(path.join(cwd, '.codex-home', 'skills', 'prodify-execute', 'SKILL.md'));
+  await fs.access(path.join(cwd, '.codex-home', 'skills', 'prodify-resume', 'SKILL.md'));
   await assertMissing(cwd, '.prodify');
 });
 

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

@@ -17,10 +17,11 @@ test('global agent setup registers multiple agents without repo-local state', as
   const root = await createTempDir();
   const env = {
     ...process.env,
-    PRODIFY_HOME: path.join(root, '.prodify-home')
+    PRODIFY_HOME: path.join(root, '.prodify-home'),
+    CODEX_HOME: path.join(root, '.codex-home')
   };
 
-  await setupAgentIntegration('codex', {
+  const codexResult = await setupAgentIntegration('codex', {
     now: '2026-04-04T00:00:00.000Z',
     env
   });
@@ -34,7 +35,11 @@ test('global agent setup registers multiple agents without repo-local state', as
   });
 
   assert.deepEqual(listConfiguredAgents(state), ['claude', 'codex']);
+  assert.equal(codexResult.installedPaths.length, 3);
   await fs.access(resolveGlobalAgentSetupStatePath(env));
+  assert.match(await fs.readFile(path.join(root, '.codex-home', 'skills', 'prodify-init', 'SKILL.md'), 'utf8'), /\$prodify-init/);
+  assert.match(await fs.readFile(path.join(root, '.codex-home', 'skills', 'prodify-execute', 'SKILL.md'), 'utf8'), /\$prodify-execute/);
+  assert.match(await fs.readFile(path.join(root, '.codex-home', 'skills', 'prodify-resume', 'SKILL.md'), 'utf8'), /\$prodify-resume/);
   await assert.rejects(fs.access(path.join(root, '.prodify')));
 });
 
@@ -67,7 +72,8 @@ 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')
+    PRODIFY_HOME: path.join(root, '.prodify-home'),
+    CODEX_HOME: path.join(root, '.codex-home')
   };
 
   assert.deepEqual(listConfiguredAgents(createInitialGlobalAgentSetupState()), []);