@arvorco/relentless 0.1.26 → 0.2.0

package/.claude/skills/constitution/SKILL.md

@@ -54,7 +54,7 @@ Ask essential questions about the project:
 
 ## Step 2: Generate Constitution
 
-Load the template from `templates/constitution-template.md` and:
+Load the template from `templates/constitution.md` and:
 
 1. Replace all `[PLACEHOLDER]` tokens with concrete values from user answers
 2. Add/remove principles based on project needs (template is a starting point)

package/.claude/skills/plan/SKILL.md

@@ -38,7 +38,7 @@ Read these files:
 
 ## Step 3: Generate Technical Plan
 
-Using the template at `templates/plan-template.md`, create a plan with:
+Using the template at `templates/plan.md`, create a plan with:
 
 ### Required Sections:
 

package/.claude/skills/specify/SKILL.md

@@ -48,7 +48,7 @@ This will output JSON with:
 
 ## Step 3: Generate Specification
 
-Using the template at `templates/spec-template.md`, create a specification with:
+Using the template at `templates/spec.md`, create a specification with:
 
 ### Required Sections:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arvorco/relentless",
-  "version": "0.1.26",
+  "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")}`);
@@ -414,7 +640,7 @@ export async function createFeature(
 
   // Copy plan.md template if requested
   if (options.withPlan) {
-    const planSourcePath = join(relentlessRoot, "templates", "plan.md");
+    const planSourcePath = join(relentlessRoot, ".claude", "skills", "plan", "templates", "plan.md");
     const planDestPath = join(featureDir, "plan.md");
 
     if (existsSync(planSourcePath)) {

package/.claude/skills/constitution/templates/constitution-template.md

@@ -1,228 +0,0 @@
-# Project Constitution
-
-## Overview
-
-This document defines the governing principles, patterns, and constraints for this project. All agents and developers MUST follow these guidelines when working on the codebase.
-
-## Core Principles
-
-### Architecture
-
-**MUST** follow these architectural patterns:
-- Follow existing code structure and organization patterns
-- Keep modules focused and single-purpose
-- Use dependency injection where appropriate
-
-**SHOULD** consider these best practices:
-- Prefer composition over inheritance
-- Keep functions small and focused
-- Write self-documenting code
-
-### Code Quality
-
-**MUST** maintain these quality standards:
-- All commits MUST pass typecheck with 0 errors
-- All commits MUST pass lint with 0 warnings
-- All new features MUST include appropriate tests
-- All code MUST be formatted consistently
-
-**SHOULD** strive for:
-- High test coverage (aim for >80%)
-- Clear, descriptive variable and function names
-- Comprehensive error handling
-
-### Version Control
-
-**MUST** follow these Git practices:
-- Write clear, descriptive commit messages
-- Reference user story IDs in commits: `feat: [US-XXX] - Description`
-- Keep commits focused and atomic
-- Do not commit broken code
-
-**SHOULD** maintain:
-- Clean commit history
-- Meaningful branch names
-- Updated documentation with code changes
-
-## Technology Stack
-
-### Language & Runtime
-
-- **TypeScript** - Primary language
-- **Bun** - Runtime environment (not Node.js)
-- **Zod** - Schema validation
-
-### Key Libraries
-
-- Commander - CLI parsing
-- Chalk - Terminal formatting
-- Execa - Process execution
-
-## File Organization
-
-```
-project/
-├── bin/              # CLI entry points
-├── src/              # Source code
-│   ├── agents/       # Agent adapters
-│   ├── config/       # Configuration
-│   ├── execution/    # Orchestration
-│   ├── init/         # Project scaffolding
-│   └── prd/          # PRD handling
-├── templates/        # Template files
-├── skills/           # Agent skills
-└── relentless/       # Relentless workspace
-    ├── config.json
-    ├── prompt.md
-    └── features/
-```
-
-## Coding Standards
-
-### TypeScript
-
-**MUST** follow:
-- Use strict TypeScript mode
-- Avoid `any` type - use `unknown` or proper types
-- Export types alongside implementations
-- Use Zod schemas for runtime validation
-
-**SHOULD** prefer:
-- Interface for public APIs
-- Type for unions and intersections
-- Explicit return types on public functions
-
-### Error Handling
-
-**MUST** implement:
-- Descriptive error messages
-- Proper error types
-- Validation at system boundaries
-- Graceful degradation where appropriate
-
-**SHOULD** include:
-- Context in error messages
-- Recovery suggestions
-- Logging for debugging
-
-### Testing
-
-**MUST** test:
-- Core business logic
-- Edge cases and error conditions
-- Integration points
-- CLI commands
-
-**SHOULD** test:
-- Helper functions
-- Utilities
-- Type guards
-
-## Documentation
-
-**MUST** document:
-- Public APIs and interfaces
-- Complex algorithms or logic
-- Breaking changes in commits
-- Setup and installation steps
-
-**SHOULD** document:
-- Configuration options
-- Architecture decisions
-- Common workflows
-- Troubleshooting steps
-
-## Security
-
-**MUST** ensure:
-- No secrets committed to git
-- Proper input validation
-- Safe file system operations
-- Minimal permissions required
-
-**SHOULD** consider:
-- Rate limiting where appropriate
-- Audit logs for sensitive operations
-- Security updates for dependencies
-
-## Performance
-
-**MUST** maintain:
-- Fast startup time (<1s)
-- Responsive CLI commands
-- Efficient file operations
-- Minimal memory footprint
-
-**SHOULD** optimize:
-- Parallel operations where safe
-- Caching for repeated operations
-- Lazy loading of heavy modules
-
-## Constraints
-
-### Dependencies
-
-**MUST NOT**:
-- Add dependencies without justification
-- Include deprecated packages
-- Use packages with known security issues
-
-**SHOULD**:
-- Prefer built-in solutions over dependencies
-- Keep dependencies minimal and focused
-- Regularly update dependencies
-
-### Backwards Compatibility
-
-**MUST**:
-- Maintain compatibility with existing PRDs
-- Provide migration paths for breaking changes
-- Version configuration formats
-
-**SHOULD**:
-- Deprecate features before removal
-- Provide clear upgrade documentation
-- Support at least 2 major versions
-
-## Agent-Specific Guidelines
-
-### For All Agents
-
-**MUST**:
-- Read progress.txt before starting work
-- Work on ONE story per iteration
-- Update PRD after completing a story
-- Append learnings to progress.txt
-- Run all quality checks before committing
-
-**SHOULD**:
-- Review existing code before modifying
-- Follow established patterns
-- Ask questions when unclear
-- Document non-obvious decisions
-
-### Iteration Workflow
-
-1. Read PRD to find next incomplete story
-2. Read progress.txt for context and patterns
-3. Review relevant existing code
-4. Implement the single story
-5. Run typecheck and lint
-6. Run tests if applicable
-7. Commit with proper message format
-8. Update PRD passes: true
-9. Append to progress.txt
-10. Check if all stories complete
-
-## Review and Updates
-
-This constitution should be:
-- **Reviewed** at project milestones
-- **Updated** when patterns emerge
-- **Referenced** in code reviews
-- **Enforced** in CI/CD pipelines
-
----
-
-Last Updated: YYYY-MM-DD
-Version: 1.0.0

package/templates/plan.md

@@ -1,273 +0,0 @@
-# Technical Planning Document
-
-## Feature Overview
-
-**Feature Name**: [Feature Name]
-**PRD Reference**: [Link or path to PRD]
-**Planning Date**: [YYYY-MM-DD]
-**Author**: [Name or Agent ID]
-
-### Problem Statement
-
-[Describe the problem this feature solves. What pain point are we addressing?]
-
-### Goals and Non-Goals
-
-**Goals:**
-- [Goal 1]
-- [Goal 2]
-- [Goal 3]
-
-**Non-Goals:**
-- [What this feature will NOT do]
-- [Scope limitations]
-
----
-
-## Technical Approach
-
-### High-Level Architecture
-
-[Describe the overall architectural approach. Include diagrams if helpful.]
-
-### Technology Stack
-
-**Languages/Frameworks:**
-- [Technology 1]: [Justification]
-- [Technology 2]: [Justification]
-
-**Libraries/Dependencies:**
-- [Dependency 1]: [Version] - [Purpose]
-- [Dependency 2]: [Version] - [Purpose]
-
-### Design Patterns
-
-[Which design patterns will be used and why?]
-- [Pattern 1]: [Rationale]
-- [Pattern 2]: [Rationale]
-
----
-
-## Implementation Details
-
-### Data Models
-
-```typescript
-// Example schema definitions
-interface Example {
-  field: string;
-  // ...
-}
-```
-
-### API Design
-
-**Endpoints/Functions:**
-- `functionName(params)`: [Description]
-- `anotherFunction(params)`: [Description]
-
-**Request/Response Formats:**
-```json
-{
-  "example": "payload"
-}
-```
-
-### File Structure
-
-```
-src/
-├── feature/
-│   ├── module1.ts
-│   ├── module2.ts
-│   └── types.ts
-└── tests/
-    └── feature.test.ts
-```
-
----
-
-## Integration Points
-
-### Existing Systems
-
-- **System 1**: [How does this feature integrate?]
-- **System 2**: [Dependencies or interactions]
-
-### Database Changes
-
-**Schema Updates:**
-- [Table/Collection 1]: [Changes]
-- [Table/Collection 2]: [Changes]
-
-**Migration Strategy:**
-- [Backward compatibility considerations]
-- [Data migration approach]
-
----
-
-## Testing Strategy
-
-### Unit Tests
-
-- [What units will be tested?]
-- [Coverage goals]
-
-### Integration Tests
-
-- [Integration scenarios]
-- [External dependencies to mock]
-
-### E2E Tests
-
-- [User flows to test]
-- [Critical paths]
-
-### Performance Tests
-
-- [Load testing requirements]
-- [Performance benchmarks]
-
----
-
-## Security Considerations
-
-### Authentication/Authorization
-
-- [How is access controlled?]
-- [Role-based permissions]
-
-### Data Privacy
-
-- [PII handling]
-- [Encryption requirements]
-
-### Vulnerability Analysis
-
-- [Potential security risks]
-- [Mitigation strategies]
-
----
-
-## Rollout Strategy
-
-### Feature Flags
-
-- [Which flags to use?]
-- [Gradual rollout plan]
-
-### Deployment Steps
-
-1. [Step 1]
-2. [Step 2]
-3. [Step 3]
-
-### Rollback Plan
-
-- [How to revert if needed]
-- [Data cleanup strategy]
-
----
-
-## Monitoring and Observability
-
-### Metrics
-
-- [Metric 1]: [What it measures]
-- [Metric 2]: [What it measures]
-
-### Logging
-
-- [Key events to log]
-- [Log levels and structured logging approach]
-
-### Alerting
-
-- [What triggers alerts?]
-- [Escalation procedures]
-
----
-
-## Open Questions
-
-- [ ] [Question 1]
-- [ ] [Question 2]
-- [ ] [Question 3]
-
----
-
-## Alternatives Considered
-
-### Alternative 1: [Name]
-
-**Pros:**
-- [Pro 1]
-- [Pro 2]
-
-**Cons:**
-- [Con 1]
-- [Con 2]
-
-**Why not chosen:** [Reasoning]
-
-### Alternative 2: [Name]
-
-**Pros:**
-- [Pro 1]
-
-**Cons:**
-- [Con 1]
-
-**Why not chosen:** [Reasoning]
-
----
-
-## Dependencies and Risks
-
-### External Dependencies
-
-- [Dependency 1]: [Risk if unavailable]
-- [Dependency 2]: [Mitigation strategy]
-
-### Technical Risks
-
-1. **Risk**: [Description]
-   - **Impact**: [High/Medium/Low]
-   - **Mitigation**: [Strategy]
-
-2. **Risk**: [Description]
-   - **Impact**: [High/Medium/Low]
-   - **Mitigation**: [Strategy]
-
-### Timeline Risks
-
-- [Risk 1]: [Mitigation]
-- [Risk 2]: [Mitigation]
-
----
-
-## Success Criteria
-
-### Definition of Done
-
-- [ ] All acceptance criteria met
-- [ ] All tests passing
-- [ ] Code reviewed and approved
-- [ ] Documentation complete
-- [ ] Performance benchmarks met
-- [ ] Security review passed
-
-### Success Metrics
-
-- [Metric 1]: [Target value]
-- [Metric 2]: [Target value]
-- [Metric 3]: [Target value]
-
----
-
-## References
-
-- [Link to PRD]
-- [Related design docs]
-- [External documentation]
-- [Research papers or articles]