@arvorco/relentless 0.1.27 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arvorco/relentless",
-  "version": "0.1.27",
+  "version": "0.2.0",
   "description": "Universal AI agent orchestrator - works with Claude Code, Amp, OpenCode, Codex, Droid, and Gemini",
   "type": "module",
   "publishConfig": {

package/src/agents/amp.ts

@@ -94,22 +94,35 @@ export const ampAdapter: AgentAdapter = {
 
   async installSkills(projectPath: string): Promise<void> {
     // Amp can install skills globally via amp skill add
-    // For project-local, we copy to the project
+    // For project-local, we copy to the project's .amp/skills/
     const skillsDir = `${projectPath}/.amp/skills`;
     await Bun.spawn(["mkdir", "-p", skillsDir]).exited;
 
     const relentlessRoot = import.meta.dir.replace("/src/agents", "");
-    await Bun.spawn([
-      "cp",
-      "-r",
-      `${relentlessRoot}/skills/prd`,
-      `${skillsDir}/`,
-    ]).exited;
-    await Bun.spawn([
-      "cp",
-      "-r",
-      `${relentlessRoot}/skills/relentless`,
-      `${skillsDir}/`,
-    ]).exited;
+    const sourceSkillsDir = `${relentlessRoot}/.claude/skills`;
+
+    // Copy all skills
+    const skills = [
+      "prd",
+      "relentless",
+      "constitution",
+      "specify",
+      "plan",
+      "tasks",
+      "checklist",
+      "clarify",
+      "analyze",
+      "implement",
+      "taskstoissues",
+    ];
+
+    for (const skill of skills) {
+      await Bun.spawn([
+        "cp",
+        "-r",
+        `${sourceSkillsDir}/${skill}`,
+        `${skillsDir}/`,
+      ]).exited;
+    }
   },
 };

package/src/agents/codex.ts

@@ -10,7 +10,8 @@ import type { AgentAdapter, AgentResult, InvokeOptions, RateLimitInfo } from "./
 export const codexAdapter: AgentAdapter = {
   name: "codex",
   displayName: "OpenAI Codex",
-  hasSkillSupport: false, // Uses SKILL.md but requires manual setup
+  hasSkillSupport: true,
+  skillInstallCommand: "codex skill add <skill-name>",
 
   async isInstalled(): Promise<boolean> {
     try {
@@ -86,4 +87,37 @@ export const codexAdapter: AgentAdapter = {
 
     return { limited: false };
   },
+
+  async installSkills(projectPath: string): Promise<void> {
+    // Codex uses .codex/skills/ for project-level skills
+    const skillsDir = `${projectPath}/.codex/skills`;
+    await Bun.spawn(["mkdir", "-p", skillsDir]).exited;
+
+    const relentlessRoot = import.meta.dir.replace("/src/agents", "");
+    const sourceSkillsDir = `${relentlessRoot}/.claude/skills`;
+
+    // Copy all skills
+    const skills = [
+      "prd",
+      "relentless",
+      "constitution",
+      "specify",
+      "plan",
+      "tasks",
+      "checklist",
+      "clarify",
+      "analyze",
+      "implement",
+      "taskstoissues",
+    ];
+
+    for (const skill of skills) {
+      await Bun.spawn([
+        "cp",
+        "-r",
+        `${sourceSkillsDir}/${skill}`,
+        `${skillsDir}/`,
+      ]).exited;
+    }
+  },
 };

package/src/agents/droid.ts

@@ -10,7 +10,8 @@ import type { AgentAdapter, AgentResult, InvokeOptions, RateLimitInfo } from "./
 export const droidAdapter: AgentAdapter = {
   name: "droid",
   displayName: "Factory Droid",
-  hasSkillSupport: false, // No skill system, uses prompting
+  hasSkillSupport: true,
+  skillInstallCommand: "droid skill install <skill-name>",
 
   async isInstalled(): Promise<boolean> {
     try {
@@ -87,4 +88,37 @@ export const droidAdapter: AgentAdapter = {
 
     return { limited: false };
   },
+
+  async installSkills(projectPath: string): Promise<void> {
+    // Factory uses .factory/skills/ for skills (PLURAL)
+    const skillsDir = `${projectPath}/.factory/skills`;
+    await Bun.spawn(["mkdir", "-p", skillsDir]).exited;
+
+    const relentlessRoot = import.meta.dir.replace("/src/agents", "");
+    const sourceSkillsDir = `${relentlessRoot}/.claude/skills`;
+
+    // Copy all skills
+    const skills = [
+      "prd",
+      "relentless",
+      "constitution",
+      "specify",
+      "plan",
+      "tasks",
+      "checklist",
+      "clarify",
+      "analyze",
+      "implement",
+      "taskstoissues",
+    ];
+
+    for (const skill of skills) {
+      await Bun.spawn([
+        "cp",
+        "-r",
+        `${sourceSkillsDir}/${skill}`,
+        `${skillsDir}/`,
+      ]).exited;
+    }
+  },
 };

package/src/agents/opencode.ts

@@ -10,7 +10,8 @@ import type { AgentAdapter, AgentResult, InvokeOptions, RateLimitInfo } from "./
 export const opencodeAdapter: AgentAdapter = {
   name: "opencode",
   displayName: "OpenCode",
-  hasSkillSupport: false, // Uses agent system, different from skills
+  hasSkillSupport: true,
+  skillInstallCommand: "opencode skill add <skill-name>",
 
   async isInstalled(): Promise<boolean> {
     try {
@@ -85,4 +86,37 @@ export const opencodeAdapter: AgentAdapter = {
 
     return { limited: false };
   },
+
+  async installSkills(projectPath: string): Promise<void> {
+    // OpenCode uses .opencode/skill/ (SINGULAR!) for skills
+    const skillsDir = `${projectPath}/.opencode/skill`;
+    await Bun.spawn(["mkdir", "-p", skillsDir]).exited;
+
+    const relentlessRoot = import.meta.dir.replace("/src/agents", "");
+    const sourceSkillsDir = `${relentlessRoot}/.claude/skills`;
+
+    // Copy all skills
+    const skills = [
+      "prd",
+      "relentless",
+      "constitution",
+      "specify",
+      "plan",
+      "tasks",
+      "checklist",
+      "clarify",
+      "analyze",
+      "implement",
+      "taskstoissues",
+    ];
+
+    for (const skill of skills) {
+      await Bun.spawn([
+        "cp",
+        "-r",
+        `${sourceSkillsDir}/${skill}`,
+        `${skillsDir}/`,
+      ]).exited;
+    }
+  },
 };

package/src/init/scaffolder.ts

@@ -55,76 +55,6 @@ const RELENTLESS_FILES: Record<string, () => string> = {
   "config.json": () => JSON.stringify(DEFAULT_CONFIG, null, 2),
 };
 
-/**
- * Files that should NEVER be overwritten, even with -f flag
- * These are personalized files that users customize for their project
- */
-const PROTECTED_FILES: Record<string, () => string> = {
-  "prompt.md": () => PROMPT_TEMPLATE,
-};
-
-const PROMPT_TEMPLATE = `# Relentless Agent Instructions
-
-You are an autonomous coding agent. Follow these instructions exactly.
-
-**⚠️ This is a generic template. Personalize it for your project using:**
-\`\`\`bash
-/relentless.prompt
-\`\`\`
-
----
-
-## Your Task (Per Iteration)
-
-1. Read \`relentless/features/<feature>/prd.json\`
-2. Read \`relentless/features/<feature>/progress.txt\`
-3. Check you're on the correct branch from PRD \`branchName\`
-4. Pick the **highest priority** story where \`passes: false\`
-5. Review existing code to understand patterns
-6. Implement the story
-7. Run quality checks (typecheck, lint, test)
-8. If ALL checks pass, commit: \`feat: [Story ID] - [Story Title]\`
-9. Update PRD: set \`passes: true\`
-10. Append progress to \`progress.txt\`
-
----
-
-## Quality Requirements
-
-Before marking a story complete:
-- [ ] All quality checks pass (typecheck, lint, test)
-- [ ] Zero errors and zero warnings
-- [ ] No debug code (console.log, debugger)
-- [ ] No unused imports or variables
-- [ ] Follows existing patterns
-
----
-
-## Progress Report Format
-
-APPEND to progress.txt:
-\`\`\`
-## [Date/Time] - [Story ID]
-- What was implemented
-- Files changed
-- Learnings for future iterations
----
-\`\`\`
-
----
-
-## Stop Condition
-
-After completing a story, check if ALL stories have \`passes: true\`.
-
-If ALL complete:
-\`\`\`
-<promise>COMPLETE</promise>
-\`\`\`
-
-Otherwise, end normally (next iteration continues).
-`;
-
 /**
  * Default progress.txt content for a new feature with YAML frontmatter
  */
@@ -195,21 +125,9 @@ export async function initProject(projectDir: string = process.cwd(), force: boo
     console.log(`  ${chalk.green("✓")} relentless/${filename} ${force ? `(${action})` : ""}`);
   }
 
-  // Create protected files (NEVER overwritten, even with -f)
-  for (const [filename, contentFn] of Object.entries(PROTECTED_FILES)) {
-    const path = join(relentlessDir, filename);
-
-    if (existsSync(path)) {
-      console.log(`  ${chalk.yellow("⚠")} relentless/${filename} already exists (protected, not overwriting)`);
-      continue;
-    }
-
-    await Bun.write(path, contentFn());
-    console.log(`  ${chalk.green("✓")} relentless/${filename} (created)`);
-  }
-
-  // Note: constitution.md is NOT copied - it should be created by /relentless.constitution command
-  // This ensures each project gets a personalized constitution
+  // Note: constitution.md and prompt.md are NOT created here
+  // They should be generated by /relentless.constitution command
+  // This ensures each project gets personalized governance and agent instructions
 
   // Create features directory with .gitkeep
   const gitkeepPath = join(featuresDir, ".gitkeep");
@@ -227,6 +145,13 @@ export async function initProject(projectDir: string = process.cwd(), force: boo
 
   const sourceSkillsDir = join(relentlessRoot, ".claude", "skills");
 
+  // Check if we're running in the relentless project itself (source == destination)
+  // This prevents accidentally deleting our own source files with -f flag
+  const isRelentlessProject = skillsDir === sourceSkillsDir;
+  if (isRelentlessProject) {
+    console.log(chalk.yellow("  ⚠ Running in Relentless project itself - skipping skill copy to avoid self-destruction"));
+  }
+
   if (!existsSync(sourceSkillsDir)) {
     console.error(chalk.red(`\n❌ Error: Skills directory not found at ${sourceSkillsDir}`));
     console.error(chalk.red(`   Relentless root: ${relentlessRoot}`));
@@ -238,21 +163,22 @@ export async function initProject(projectDir: string = process.cwd(), force: boo
     process.exit(1);
   }
 
-  if (existsSync(sourceSkillsDir)) {
-    const skills = [
-      "prd",
-      "relentless",
-      "constitution",
-      "specify",
-      "plan",
-      "tasks",
-      "checklist",
-      "clarify",
-      "analyze",
-      "implement",
-      "taskstoissues",
-    ];
-
+  // List of skills to install (used for both Claude Code and Amp)
+  const skills = [
+    "prd",
+    "relentless",
+    "constitution",
+    "specify",
+    "plan",
+    "tasks",
+    "checklist",
+    "clarify",
+    "analyze",
+    "implement",
+    "taskstoissues",
+  ];
+
+  if (existsSync(sourceSkillsDir) && !isRelentlessProject) {
     for (const skill of skills) {
       const sourcePath = join(sourceSkillsDir, skill);
       const destPath = join(skillsDir, skill);
@@ -283,6 +209,158 @@ export async function initProject(projectDir: string = process.cwd(), force: boo
     }
   }
 
+  // Copy skills to .amp/skills/ if Amp is installed
+  const ampInstalled = installed.some((a) => a.name === "amp");
+  if (ampInstalled) {
+    console.log(chalk.dim("\nInstalling skills for Amp..."));
+    const ampSkillsDir = join(projectDir, ".amp", "skills");
+    if (!existsSync(ampSkillsDir)) {
+      mkdirSync(ampSkillsDir, { recursive: true });
+    }
+
+    for (const skill of skills) {
+      const sourcePath = join(sourceSkillsDir, skill);
+      const destPath = join(ampSkillsDir, skill);
+
+      if (!existsSync(sourcePath)) {
+        continue;
+      }
+
+      if (existsSync(destPath) && !force) {
+        console.log(`  ${chalk.yellow("⚠")} .amp/skills/${skill} already exists, skipping`);
+      } else {
+        try {
+          if (existsSync(destPath) && force) {
+            await Bun.spawn(["rm", "-rf", destPath]).exited;
+          }
+          const result = await Bun.spawn(["cp", "-r", sourcePath, destPath]).exited;
+          if (result !== 0) {
+            console.log(`  ${chalk.red("✗")} .amp/skills/${skill} - copy failed`);
+            continue;
+          }
+          const action = force ? "updated" : "created";
+          console.log(`  ${chalk.green("✓")} .amp/skills/${skill} (${action})`);
+        } catch (error) {
+          console.log(`  ${chalk.red("✗")} .amp/skills/${skill} - error: ${error}`);
+        }
+      }
+    }
+  }
+
+  // Copy skills to .opencode/skill/ if OpenCode is installed (SINGULAR!)
+  const opencodeInstalled = installed.some((a) => a.name === "opencode");
+  if (opencodeInstalled) {
+    console.log(chalk.dim("\nInstalling skills for OpenCode..."));
+    const opencodeSkillsDir = join(projectDir, ".opencode", "skill");
+    if (!existsSync(opencodeSkillsDir)) {
+      mkdirSync(opencodeSkillsDir, { recursive: true });
+    }
+
+    for (const skill of skills) {
+      const sourcePath = join(sourceSkillsDir, skill);
+      const destPath = join(opencodeSkillsDir, skill);
+
+      if (!existsSync(sourcePath)) {
+        continue;
+      }
+
+      if (existsSync(destPath) && !force) {
+        console.log(`  ${chalk.yellow("⚠")} .opencode/skill/${skill} already exists, skipping`);
+      } else {
+        try {
+          if (existsSync(destPath) && force) {
+            await Bun.spawn(["rm", "-rf", destPath]).exited;
+          }
+          const result = await Bun.spawn(["cp", "-r", sourcePath, destPath]).exited;
+          if (result !== 0) {
+            console.log(`  ${chalk.red("✗")} .opencode/skill/${skill} - copy failed`);
+            continue;
+          }
+          const action = force ? "updated" : "created";
+          console.log(`  ${chalk.green("✓")} .opencode/skill/${skill} (${action})`);
+        } catch (error) {
+          console.log(`  ${chalk.red("✗")} .opencode/skill/${skill} - error: ${error}`);
+        }
+      }
+    }
+  }
+
+  // Copy skills to .codex/skills/ if Codex is installed
+  const codexInstalled = installed.some((a) => a.name === "codex");
+  if (codexInstalled) {
+    console.log(chalk.dim("\nInstalling skills for Codex..."));
+    const codexSkillsDir = join(projectDir, ".codex", "skills");
+    if (!existsSync(codexSkillsDir)) {
+      mkdirSync(codexSkillsDir, { recursive: true });
+    }
+
+    for (const skill of skills) {
+      const sourcePath = join(sourceSkillsDir, skill);
+      const destPath = join(codexSkillsDir, skill);
+
+      if (!existsSync(sourcePath)) {
+        continue;
+      }
+
+      if (existsSync(destPath) && !force) {
+        console.log(`  ${chalk.yellow("⚠")} .codex/skills/${skill} already exists, skipping`);
+      } else {
+        try {
+          if (existsSync(destPath) && force) {
+            await Bun.spawn(["rm", "-rf", destPath]).exited;
+          }
+          const result = await Bun.spawn(["cp", "-r", sourcePath, destPath]).exited;
+          if (result !== 0) {
+            console.log(`  ${chalk.red("✗")} .codex/skills/${skill} - copy failed`);
+            continue;
+          }
+          const action = force ? "updated" : "created";
+          console.log(`  ${chalk.green("✓")} .codex/skills/${skill} (${action})`);
+        } catch (error) {
+          console.log(`  ${chalk.red("✗")} .codex/skills/${skill} - error: ${error}`);
+        }
+      }
+    }
+  }
+
+  // Copy skills to .factory/skills/ if Droid (Factory) is installed
+  const droidInstalled = installed.some((a) => a.name === "droid");
+  if (droidInstalled) {
+    console.log(chalk.dim("\nInstalling skills for Droid (Factory)..."));
+    const factorySkillsDir = join(projectDir, ".factory", "skills");
+    if (!existsSync(factorySkillsDir)) {
+      mkdirSync(factorySkillsDir, { recursive: true });
+    }
+
+    for (const skill of skills) {
+      const sourcePath = join(sourceSkillsDir, skill);
+      const destPath = join(factorySkillsDir, skill);
+
+      if (!existsSync(sourcePath)) {
+        continue;
+      }
+
+      if (existsSync(destPath) && !force) {
+        console.log(`  ${chalk.yellow("⚠")} .factory/skills/${skill} already exists, skipping`);
+      } else {
+        try {
+          if (existsSync(destPath) && force) {
+            await Bun.spawn(["rm", "-rf", destPath]).exited;
+          }
+          const result = await Bun.spawn(["cp", "-r", sourcePath, destPath]).exited;
+          if (result !== 0) {
+            console.log(`  ${chalk.red("✗")} .factory/skills/${skill} - copy failed`);
+            continue;
+          }
+          const action = force ? "updated" : "created";
+          console.log(`  ${chalk.green("✓")} .factory/skills/${skill} (${action})`);
+        } catch (error) {
+          console.log(`  ${chalk.red("✗")} .factory/skills/${skill} - error: ${error}`);
+        }
+      }
+    }
+  }
+
   // Copy commands to .claude/commands/ (for Claude Code)
   console.log(chalk.dim("\nInstalling commands..."));
   const commandsDir = join(projectDir, ".claude", "commands");
@@ -292,19 +370,26 @@ export async function initProject(projectDir: string = process.cwd(), force: boo
 
   const sourceCommandsDir = join(relentlessRoot, ".claude", "commands");
 
-  if (existsSync(sourceCommandsDir)) {
-    const commands = [
-      "relentless.analyze.md",
-      "relentless.checklist.md",
-      "relentless.clarify.md",
-      "relentless.constitution.md",
-      "relentless.implement.md",
-      "relentless.plan.md",
-      "relentless.specify.md",
-      "relentless.tasks.md",
-      "relentless.taskstoissues.md",
-    ];
+  // Check if we're running in the relentless project itself (source == destination)
+  const isRelentlessProjectCommands = commandsDir === sourceCommandsDir;
+  if (isRelentlessProjectCommands) {
+    console.log(chalk.yellow("  ⚠ Running in Relentless project itself - skipping command copy to avoid self-destruction"));
+  }
 
+  // List of commands to install (used for Claude, OpenCode, Factory, and Codex)
+  const commands = [
+    "relentless.analyze.md",
+    "relentless.checklist.md",
+    "relentless.clarify.md",
+    "relentless.constitution.md",
+    "relentless.implement.md",
+    "relentless.plan.md",
+    "relentless.specify.md",
+    "relentless.tasks.md",
+    "relentless.taskstoissues.md",
+  ];
+
+  if (existsSync(sourceCommandsDir) && !isRelentlessProjectCommands) {
     for (const command of commands) {
       const sourcePath = join(sourceCommandsDir, command);
       const destPath = join(commandsDir, command);
@@ -322,21 +407,162 @@ export async function initProject(projectDir: string = process.cwd(), force: boo
     }
   }
 
+  // Copy commands to .opencode/command/ if OpenCode is installed (SINGULAR!)
+  if (opencodeInstalled && existsSync(sourceCommandsDir)) {
+    console.log(chalk.dim("\nInstalling commands for OpenCode..."));
+    const opencodeCommandsDir = join(projectDir, ".opencode", "command");
+    if (!existsSync(opencodeCommandsDir)) {
+      mkdirSync(opencodeCommandsDir, { recursive: true });
+    }
+
+    for (const command of commands) {
+      const sourcePath = join(sourceCommandsDir, command);
+      const destPath = join(opencodeCommandsDir, command);
+
+      if (existsSync(sourcePath)) {
+        if (existsSync(destPath) && !force) {
+          console.log(`  ${chalk.yellow("⚠")} .opencode/command/${command} already exists, skipping`);
+        } else {
+          const content = await Bun.file(sourcePath).text();
+          await Bun.write(destPath, content);
+          const action = existsSync(destPath) && force ? "updated" : "created";
+          console.log(`  ${chalk.green("✓")} .opencode/command/${command} (${action})`);
+        }
+      }
+    }
+  }
+
+  // Copy commands to .factory/commands/ if Droid (Factory) is installed
+  if (droidInstalled && existsSync(sourceCommandsDir)) {
+    console.log(chalk.dim("\nInstalling commands for Droid (Factory)..."));
+    const factoryCommandsDir = join(projectDir, ".factory", "commands");
+    if (!existsSync(factoryCommandsDir)) {
+      mkdirSync(factoryCommandsDir, { recursive: true });
+    }
+
+    for (const command of commands) {
+      const sourcePath = join(sourceCommandsDir, command);
+      const destPath = join(factoryCommandsDir, command);
+
+      if (existsSync(sourcePath)) {
+        if (existsSync(destPath) && !force) {
+          console.log(`  ${chalk.yellow("⚠")} .factory/commands/${command} already exists, skipping`);
+        } else {
+          const content = await Bun.file(sourcePath).text();
+          await Bun.write(destPath, content);
+          const action = existsSync(destPath) && force ? "updated" : "created";
+          console.log(`  ${chalk.green("✓")} .factory/commands/${command} (${action})`);
+        }
+      }
+    }
+  }
+
+  // Copy prompts to ~/.codex/prompts/ if Codex is installed (user-level only)
+  if (codexInstalled && existsSync(sourceCommandsDir)) {
+    console.log(chalk.dim("\nInstalling prompts for Codex (user-level)..."));
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    const codexPromptsDir = join(homeDir, ".codex", "prompts");
+    if (!existsSync(codexPromptsDir)) {
+      mkdirSync(codexPromptsDir, { recursive: true });
+    }
+
+    for (const command of commands) {
+      const sourcePath = join(sourceCommandsDir, command);
+      // Codex prompts are invoked as /prompts:name, so we keep the same filename
+      const destPath = join(codexPromptsDir, command);
+
+      if (existsSync(sourcePath)) {
+        if (existsSync(destPath) && !force) {
+          console.log(`  ${chalk.yellow("⚠")} ~/.codex/prompts/${command} already exists, skipping`);
+        } else {
+          const content = await Bun.file(sourcePath).text();
+          await Bun.write(destPath, content);
+          const action = existsSync(destPath) && force ? "updated" : "created";
+          console.log(`  ${chalk.green("✓")} ~/.codex/prompts/${command} (${action})`);
+        }
+      }
+    }
+  }
+
+  // Create .gemini/GEMINI.md context file if Gemini is installed
+  const geminiInstalled = installed.some((a) => a.name === "gemini");
+  if (geminiInstalled) {
+    console.log(chalk.dim("\nInstalling context for Gemini..."));
+    const geminiDir = join(projectDir, ".gemini");
+    if (!existsSync(geminiDir)) {
+      mkdirSync(geminiDir, { recursive: true });
+    }
+
+    const geminiContextPath = join(geminiDir, "GEMINI.md");
+    const geminiContextContent = `# Relentless - Universal AI Agent Orchestrator
+
+This project uses Relentless for feature-driven development with AI agents.
+
+## Available Skills
+
+The following skills are available in \`.claude/skills/\`:
+
+- **prd** - Generate Product Requirements Documents
+- **constitution** - Create project governance and coding principles
+- **specify** - Create feature specifications
+- **plan** - Generate technical implementation plans
+- **tasks** - Generate user stories and tasks
+- **checklist** - Generate quality validation checklists
+- **clarify** - Resolve ambiguities in specifications
+- **analyze** - Analyze consistency across artifacts
+- **implement** - Execute implementation workflows
+- **taskstoissues** - Convert user stories to GitHub issues
+
+## Workflow
+
+1. Run \`/relentless.constitution\` to create project governance
+2. Run \`/relentless.specify "feature description"\` to create a feature spec
+3. Run \`/relentless.plan\` to generate technical plan
+4. Run \`/relentless.tasks\` to generate user stories
+5. Run \`/relentless.checklist\` to generate quality checklist
+
+## Feature Directory Structure
+
+\`\`\`
+relentless/features/<feature-name>/
+├── spec.md       # Feature specification
+├── plan.md       # Technical plan
+├── tasks.md      # User stories
+├── checklist.md  # Quality checklist
+├── prd.json      # PRD JSON (for orchestrator)
+└── progress.txt  # Progress log
+\`\`\`
+
+For full documentation, see: https://github.com/ArvorCo/Relentless
+`;
+
+    if (existsSync(geminiContextPath) && !force) {
+      console.log(`  ${chalk.yellow("⚠")} .gemini/GEMINI.md already exists, skipping`);
+    } else {
+      await Bun.write(geminiContextPath, geminiContextContent);
+      const action = existsSync(geminiContextPath) && force ? "updated" : "created";
+      console.log(`  ${chalk.green("✓")} .gemini/GEMINI.md (${action})`);
+    }
+  }
+
   // Print next steps
   console.log(chalk.bold.green("\n✅ Relentless initialized!\n"));
   console.log(chalk.dim("Structure:"));
   console.log(chalk.dim("  relentless/"));
   console.log(chalk.dim("  ├── config.json          # Configuration"));
-  console.log(chalk.dim("  ├── constitution.md      # Project governance"));
-  console.log(chalk.dim("  ├── prompt.md            # Base prompt template"));
+  console.log(chalk.dim("  ├── constitution.md      # Project governance (run /relentless.constitution)"));
+  console.log(chalk.dim("  ├── prompt.md            # Agent instructions (run /relentless.constitution)"));
   console.log(chalk.dim("  └── features/            # Feature folders"));
   console.log(chalk.dim("      └── <feature>/       # Each feature has:"));
-  console.log(chalk.dim("          ├── prd.md       # PRD markdown"));
-  console.log(chalk.dim("          ├── prd.json     # PRD JSON"));
+  console.log(chalk.dim("          ├── spec.md      # Feature specification"));
+  console.log(chalk.dim("          ├── plan.md      # Technical plan"));
+  console.log(chalk.dim("          ├── tasks.md     # User stories"));
+  console.log(chalk.dim("          ├── checklist.md # Quality checklist"));
+  console.log(chalk.dim("          ├── prd.json     # PRD JSON (for orchestrator)"));
   console.log(chalk.dim("          └── progress.txt # Progress log\n"));
 
   console.log("Next steps:");
-  console.log(chalk.dim("1. Create project constitution (recommended):"));
+  console.log(chalk.dim("1. Create project constitution and prompt (required):"));
   console.log(`   ${chalk.cyan("/relentless.constitution")}`);
   console.log(chalk.dim("\n2. Create a feature specification:"));
   console.log(`   ${chalk.cyan("/relentless.specify Add user authentication")}`);