reyson-spec-gate 0.1.0 → 0.1.1

package/README.md

@@ -1,272 +1,254 @@
-# skill-reyson
+# reyson-spec-gate
 
-An interactive npm installer for a spec-first coding workflow.
+A spec-first installer for coding-agent workflow rules, docs, and skills.
 
-`skill-reyson` helps teams install a lightweight scaffold that makes coding agents slower in the right place: **before implementation starts**.
+`reyson-spec-gate` is designed to install a consistent pre-coding workflow into a workspace so that agents do not jump directly from a loose request into implementation.
 
-It enforces a simple rule:
+Its central rule is simple:
 
 > No coding before the spec is clear, the task list exists, and the checklist exists.
 
 ---
 
-## What this package installs
+## Recommended usage
 
-By default, the installer copies only the core workflow assets into your target directory:
+Do **not** rely on global installation as the primary path.
+
+The recommended way to use this package is:
+
+```bash
+npx reyson-spec-gate
+```
+
+This launches the interactive installer directly and avoids depending on a permanently global npm installation.
+
+---
+
+## What it installs
+
+The installer always installs the shared workflow assets:
 
 - `docs/spec-workflow.md`
 - `skills/generate-task-list/SKILL.md`
 - `skills/generate-checklist/SKILL.md`
 
-By default, it **does not** install agent guidance files.
+It also installs **RULES.md only** for selected agents.
 
-If you choose to install agent guidance files during setup, it can also add one or more of:
+It does **not** install:
+- `AGENTS.md`
+- `CLAUDE.md`
 
-- `AGENTS.md` for Codex-style workflows
-- `CLAUDE.md` for Claude Code-style workflows
-- `RULES.md` as a generic rules entrypoint
+All agent-specific rule entrypoints are normalized to `RULES.md`.
 
 ---
 
-## Installation
+## Supported agents
 
-```bash
-npm i -g reyson-spec-gate
-```
-
-## Quick start
+The interactive installer currently supports these agent targets:
 
-Install globally, then run the interactive installer:
+1. Codex
+2. Trae
+3. Claude Code
+4. Cursor
+5. Antigravity
 
-```bash
-skill-reyson
-```
+You can select one or more targets in the same run.
 
-Fast path examples:
+If you do not select anything, the installer will:
+- default to **Codex**
+- print a message explaining that Codex was chosen by default
 
-```bash
-# install only docs + skills into the current project
-skill-reyson install --yes --dir .
+---
 
-# install docs + skills + Codex AGENTS.md
-skill-reyson install --yes --dir . --with-agent-files --agents codex
-```
+## Interactive behavior
 
-Then run:
+Run:
 
 ```bash
-skill-reyson
+npx reyson-spec-gate
 ```
 
-or:
+The installer will ask:
+1. which directory to install into
+2. which agent targets to install for
 
-```bash
-skill-reyson install
-```
-
----
+Agent selection is multi-select.
 
-## Interactive setup
+Example:
+- `1,3,4` installs for Codex, Claude Code, and Cursor
 
-The CLI is interactive by default.
+If you press ENTER without choosing an agent, it falls back to Codex.
 
-It asks:
-1. where to install the scaffold
-2. whether to install agent guidance files
-3. which agent adapters to install
+---
 
-### Default behavior
+## Output structure
 
-If you accept the defaults:
-- docs and skills are installed
-- `AGENTS.md` / `CLAUDE.md` / `RULES.md` are **not** installed
+The installer writes the shared assets into the target directory and installs rule files per agent under `agents/<agent>/RULES.md`.
 
-This matches your desired safe default: **no agent behavior file unless the user opts in**.
+Example output:
 
----
+```text
+my-project/
+├── docs/
+│   └── spec-workflow.md
+├── skills/
+│   ├── generate-task-list/
+│   │   └── SKILL.md
+│   └── generate-checklist/
+│       └── SKILL.md
+└── agents/
+    ├── codex/
+    │   └── RULES.md
+    ├── claude-code/
+    │   └── RULES.md
+    └── cursor/
+        └── RULES.md
+```
 
-## Non-interactive setup
+This structure avoids filename collisions when multiple agents are installed in one run.
 
-You can also run the installer non-interactively.
+---
 
-### Install core files only
+## Non-interactive usage
 
-```bash
-skill-reyson install --yes --dir ./my-project
-```
+If you want a scriptable path, you can still run the installer non-interactively.
 
-### Install core files plus Codex adapter
+### Default to Codex
 
 ```bash
-skill-reyson install --yes --dir ./my-project --with-agent-files --agents codex
+npx reyson-spec-gate install --yes --dir ./my-project
 ```
 
-### Install multiple agent adapters
+### Install multiple agent targets
 
 ```bash
-skill-reyson install --yes --dir ./my-project --with-agent-files --agents codex,claude,generic
+npx reyson-spec-gate install --yes --dir ./my-project --agents codex,trae,claude,cursor,antigravity
 ```
 
 ---
 
-## Why this exists
-
-In many spec-driven workflows, an agent may produce a decent spec and still move into coding too early.
+## Why `npx` is preferred
 
-Typical failure modes:
-- the task list is implicit instead of explicit
-- the checklist is missing or too generic
-- the agent starts coding before execution and verification artifacts are aligned
+The purpose of this package is to run an installation workflow, not simply to sit globally on a machine.
 
-`skill-reyson` fixes this by separating the workflow into three responsibilities:
+Using `npx reyson-spec-gate` is preferable because:
+- it is explicit
+- it is easy to run in any repository
+- it avoids stale global versions
+- it keeps the install workflow lightweight
 
-- **agent guidance files** tell the agent how to behave
-- **docs** explain the workflow and readiness gate
-- **skills** generate missing artifacts
+Global installation can still work, but it is no longer the recommended entrypoint.
 
 ---
 
-## Repository structure
-
-```text
-skill-reyson/
-├── AGENTS.md
-├── LICENSE
-├── README.md
-├── package.json
-├── bin/
-│   └── skill-reyson.js
-├── docs/
-│   └── spec-workflow.md
-├── examples/
-│   ├── example-derived-artifacts.md
-│   └── example-input-spec.md
-├── skills/
-│   ├── generate-task-list/
-│   │   └── SKILL.md
-│   └── generate-checklist/
-│       └── SKILL.md
-└── templates/
-    └── adapters/
-        ├── AGENTS.md
-        ├── CLAUDE.md
-        └── RULES.md
-```
+## Workflow model
 
----
+This package is based on a spec-first coding workflow.
 
-## Responsibility split
+The intended flow is:
 
-### 1. Agent guidance files
+1. The agent reads `docs/spec-workflow.md`
+2. The agent checks whether the current work has:
+   - a working spec
+   - a task list
+   - a checklist
+3. If the task list is missing, the agent uses `generate-task-list`
+4. If the checklist is missing, the agent uses `generate-checklist`
+5. Only after both artifacts exist does coding begin
+6. After coding, the checklist is revisited before claiming completion
 
-Optional files such as `AGENTS.md`, `CLAUDE.md`, or `RULES.md` act as the enforcement layer.
+---
 
-Their job is to tell the agent:
-- read the workflow doc before coding
-- check whether task list and checklist exist
-- generate missing artifacts before implementation
-- revisit the checklist after coding
+## Responsibilities
 
-### 2. `docs/spec-workflow.md`
+### `docs/spec-workflow.md`
 
-This is the workflow knowledge layer.
+This file is the workflow knowledge source.
 
 It defines:
 - the pre-coding gate
-- artifact ordering rules
-- task-list expectations
-- checklist expectations
+- artifact ordering
+- task-list requirements
+- checklist requirements
 - coding readiness rules
-- post-coding review rules
+- post-coding verification rules
 
-### 3. Skills
+### `skills/generate-task-list`
 
-The two included skills are execution helpers.
+This skill generates or normalizes an explicit task list from a spec or plan.
 
-#### `generate-task-list`
-Use this when the workflow has a spec or plan but no explicit task list.
+### `skills/generate-checklist`
 
-#### `generate-checklist`
-Use this when the workflow has a spec and task list but no explicit checklist.
+This skill generates a checklist from the working spec and task list.
 
----
+### `agents/<agent>/RULES.md`
 
-## Core workflow
+Each selected agent receives a `RULES.md` entrypoint.
 
-1. Read the workflow document
-2. Check whether the current task has a working spec
-3. Check whether a task list exists
-4. Check whether a checklist exists
-5. If task list is missing, generate it
-6. If checklist is missing, generate it
-7. Start coding only after the readiness gate is satisfied
-8. Revisit the checklist after coding
+Its job is to remind the target agent to:
+- read the workflow doc first
+- check for task list and checklist presence
+- generate missing artifacts before implementation
+- avoid coding before the pre-coding gate passes
 
 ---
 
-## Included examples
+## Example installation commands
 
-See:
-- `examples/example-input-spec.md`
-- `examples/example-derived-artifacts.md`
+### Install for Codex only
 
-These show how a spec can lead to an explicit task list and checklist before coding begins.
+```bash
+npx reyson-spec-gate install --yes --dir ./my-project --agents codex
+```
 
----
+### Install for Trae and Cursor
 
-## Development
+```bash
+npx reyson-spec-gate install --yes --dir ./my-project --agents trae,cursor
+```
 
-Run locally without publishing:
+### Install for all supported agents
 
 ```bash
-node bin/skill-reyson.js --help
-node bin/skill-reyson.js install
+npx reyson-spec-gate install --yes --dir ./my-project --agents codex,trae,claude,cursor,antigravity
 ```
 
 ---
 
-## Open-source intent
+## Development
 
-This project is meant to stay small, composable, and easy to adapt.
+Run locally:
 
-Good future extensions:
-- additional agent adapters
-- a readiness report skill
-- templates for Working Spec output
-- project-specific workflow variants
-- validation fixtures and smoke tests
+```bash
+node bin/reyson-spec-gate.js --help
+node bin/reyson-spec-gate.js install
+```
 
 ---
 
-## Publish checklist
+## Package identity
 
-Before publishing to GitHub or npm, verify:
-
-- `node bin/skill-reyson.js --help` works
-- `skill-reyson install --yes --dir /tmp/somewhere` copies the expected files
-- default install does **not** copy agent guidance files
-- `--with-agent-files --agents ...` copies the selected adapter files
-- `README.md` matches current CLI behavior
-- `package.json` name, version, license, and bin entry are correct
-
-### Suggested GitHub steps
+Current npm package:
 
 ```bash
-cd /Users/bytedance/Desktop/coding/skill-reyson
-git remote add origin <your-github-repo-url>
-git push -u origin master
+reyson-spec-gate
 ```
 
-### Suggested npm publish steps
+Recommended invocation:
 
 ```bash
-cd /Users/bytedance/Desktop/coding/skill-reyson
-npm login
-npm publish
+npx reyson-spec-gate
 ```
 
-If you want a safer dry run first:
+---
 
-```bash
-npm pack
-```
+## Notes
+
+This repository intentionally standardizes every agent rule entrypoint to `RULES.md`.
+
+That means:
+- no `AGENTS.md`
+- no `CLAUDE.md`
+- a single normalized rules filename for all supported agent targets
+
+This keeps the workflow easier to reason about and easier to extend.

package/bin/reyson-spec-gate.js

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+const DOC_SOURCE = path.join(PACKAGE_ROOT, 'docs', 'spec-workflow.md');
+const RULES_SOURCE = path.join(PACKAGE_ROOT, 'templates', 'RULES.md');
+const SKILL_SOURCES = [
+  {
+    source: path.join(PACKAGE_ROOT, 'skills', 'generate-task-list', 'SKILL.md'),
+    relativeTarget: path.join('skills', 'generate-task-list', 'SKILL.md'),
+  },
+  {
+    source: path.join(PACKAGE_ROOT, 'skills', 'generate-checklist', 'SKILL.md'),
+    relativeTarget: path.join('skills', 'generate-checklist', 'SKILL.md'),
+  },
+];
+
+const AGENTS = {
+  codex: { label: 'Codex', target: path.join('agents', 'codex', 'RULES.md') },
+  trae: { label: 'Trae', target: path.join('agents', 'trae', 'RULES.md') },
+  claude: { label: 'Claude Code', target: path.join('agents', 'claude-code', 'RULES.md') },
+  cursor: { label: 'Cursor', target: path.join('agents', 'cursor', 'RULES.md') },
+  antigravity: { label: 'Antigravity', target: path.join('agents', 'antigravity', 'RULES.md') },
+};
+const DEFAULT_AGENT = 'codex';
+const AGENT_NUMBER_MAP = { '1': 'codex', '2': 'trae', '3': 'claude', '4': 'cursor', '5': 'antigravity' };
+
+function printHelp() {
+  console.log(`reyson-spec-gate
+
+Recommended usage:
+  npx reyson-spec-gate
+
+Other usage:
+  reyson-spec-gate                Start interactive installer
+  reyson-spec-gate install        Start interactive installer
+  reyson-spec-gate install --dir <path>
+  reyson-spec-gate install --yes [--dir <path>] [--agents codex,trae,claude,cursor,antigravity]
+  reyson-spec-gate --help         Show help
+
+Interactive defaults:
+  - Installs docs/spec-workflow.md
+  - Installs skills/generate-task-list/SKILL.md
+  - Installs skills/generate-checklist/SKILL.md
+  - Prompts for agent selection
+  - If no agent is selected, defaults to Codex
+  - Installs RULES.md only (never AGENTS.md / CLAUDE.md)
+`);
+}
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const options = { command: 'install', dir: process.cwd(), yes: false, agents: [] };
+  if (args[0] && !args[0].startsWith('-')) {
+    options.command = args.shift();
+  }
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--help' || arg === '-h') {
+      options.command = 'help';
+    } else if (arg === '--yes' || arg === '-y') {
+      options.yes = true;
+    } else if (arg === '--dir') {
+      options.dir = path.resolve(args[i + 1] || process.cwd());
+      i += 1;
+    } else if (arg.startsWith('--dir=')) {
+      options.dir = path.resolve(arg.split('=')[1]);
+    } else if (arg === '--agents') {
+      options.agents = (args[i + 1] || '').split(',').map((s) => s.trim()).filter(Boolean);
+      i += 1;
+    } else if (arg.startsWith('--agents=')) {
+      options.agents = arg.split('=')[1].split(',').map((s) => s.trim()).filter(Boolean);
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+  return options;
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function copyFile(source, target) {
+  ensureDir(path.dirname(target));
+  fs.copyFileSync(source, target);
+}
+
+function normalizeAgents(agentKeys) {
+  return Array.from(new Set(agentKeys.map((key) => key.toLowerCase()).filter((key) => AGENTS[key])));
+}
+
+function copyCoreArtifacts(targetDir) {
+  const docTarget = path.join(targetDir, 'docs', 'spec-workflow.md');
+  copyFile(DOC_SOURCE, docTarget);
+  for (const skill of SKILL_SOURCES) {
+    copyFile(skill.source, path.join(targetDir, skill.relativeTarget));
+  }
+  return [
+    path.relative(targetDir, docTarget),
+    ...SKILL_SOURCES.map((skill) => skill.relativeTarget),
+  ];
+}
+
+function copyRulesFiles(targetDir, selectedAgents) {
+  const copied = [];
+  for (const key of selectedAgents) {
+    const agent = AGENTS[key];
+    if (!agent) continue;
+    copyFile(RULES_SOURCE, path.join(targetDir, agent.target));
+    copied.push(agent.target);
+  }
+  return copied;
+}
+
+function createInterface() {
+  return readline.createInterface({ input: process.stdin, output: process.stdout });
+}
+
+function ask(rl, question) {
+  return new Promise((resolve) => rl.question(question, resolve));
+}
+
+function parseInteractiveAgents(answer) {
+  const raw = answer.trim();
+  if (!raw) {
+    return { agents: [DEFAULT_AGENT], usedDefault: true };
+  }
+  const selected = normalizeAgents(raw.split(',').map((token) => {
+    const trimmed = token.trim();
+    return AGENT_NUMBER_MAP[trimmed] || trimmed;
+  }));
+  if (selected.length === 0) {
+    return { agents: [DEFAULT_AGENT], usedDefault: true };
+  }
+  return { agents: selected, usedDefault: false };
+}
+
+function performInstall({ targetDir, agents }) {
+  ensureDir(targetDir);
+  const coreFiles = copyCoreArtifacts(targetDir);
+  const normalizedAgents = normalizeAgents(agents);
+  const finalAgents = normalizedAgents.length > 0 ? normalizedAgents : [DEFAULT_AGENT];
+  const rulesFiles = copyRulesFiles(targetDir, finalAgents);
+  return { targetDir, coreFiles, rulesFiles, agents: finalAgents };
+}
+
+function printSummary(result) {
+  console.log('\nInstalled reyson-spec-gate scaffold:\n');
+  console.log(`Target: ${result.targetDir}`);
+  console.log('\nCore files:');
+  for (const file of result.coreFiles) {
+    console.log(`  - ${file}`);
+  }
+  console.log('\nAgent rule files:');
+  for (const file of result.rulesFiles) {
+    console.log(`  - ${file}`);
+  }
+  console.log(`\nSelected agents: ${result.agents.map((agent) => AGENTS[agent].label).join(', ')}`);
+  console.log('\nNext steps:');
+  console.log('  1) Open docs/spec-workflow.md');
+  console.log('  2) Point your chosen agent(s) at their installed RULES.md file(s)');
+  console.log('  3) Use generate-task-list and generate-checklist when artifacts are missing');
+}
+
+async function runInteractive(defaults) {
+  const rl = createInterface();
+  try {
+    console.log('\nreyson-spec-gate interactive installer\n');
+    console.log('Recommended usage: npx reyson-spec-gate');
+    const dirAnswer = await ask(rl, `\nTarget directory [${defaults.dir}]: `);
+    const targetDir = path.resolve(dirAnswer.trim() || defaults.dir);
+
+    console.log('\nSelect agent targets (comma-separated, multi-select supported):');
+    console.log('  1) Codex');
+    console.log('  2) Trae');
+    console.log('  3) Claude Code');
+    console.log('  4) Cursor');
+    console.log('  5) Antigravity');
+    console.log('  Press ENTER to accept the default: Codex');
+    const agentAnswer = await ask(rl, 'Choice(s) [Codex default]: ');
+    const { agents, usedDefault } = parseInteractiveAgents(agentAnswer);
+    if (usedDefault) {
+      console.log('No valid selection provided. Defaulting to Codex.');
+    }
+
+    const confirmation = await ask(
+      rl,
+      `\nProceed installing into ${targetDir} for ${agents.map((agent) => AGENTS[agent].label).join(', ')}? [Y/n]: `,
+    );
+    const ok = confirmation.trim() === '' || /^y(es)?$/i.test(confirmation.trim());
+    if (!ok) {
+      console.log('Installation cancelled.');
+      return;
+    }
+
+    const result = performInstall({ targetDir, agents });
+    printSummary(result);
+  } finally {
+    rl.close();
+  }
+}
+
+async function main() {
+  let options;
+  try {
+    options = parseArgs(process.argv);
+  } catch (error) {
+    console.error(error.message);
+    printHelp();
+    process.exit(1);
+  }
+
+  if (options.command === 'help' || options.command === '--help' || options.command === '-h') {
+    printHelp();
+    return;
+  }
+
+  if (options.command !== 'install') {
+    console.error(`Unknown command: ${options.command}`);
+    printHelp();
+    process.exit(1);
+  }
+
+  if (options.yes) {
+    const result = performInstall({ targetDir: options.dir, agents: options.agents });
+    printSummary(result);
+    return;
+  }
+
+  await runInteractive(options);
+}
+
+main().catch((error) => {
+  console.error(error.stack || error.message);
+  process.exit(1);
+});

package/bin/skill-reyson.js

@@ -1,234 +1,2 @@
 #!/usr/bin/env node
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const readline = require('readline');
-
-const PACKAGE_ROOT = path.resolve(__dirname, '..');
-const DOC_SOURCE = path.join(PACKAGE_ROOT, 'docs', 'spec-workflow.md');
-const SKILL_SOURCES = [
-  {
-    source: path.join(PACKAGE_ROOT, 'skills', 'generate-task-list', 'SKILL.md'),
-    relativeTarget: path.join('skills', 'generate-task-list', 'SKILL.md'),
-  },
-  {
-    source: path.join(PACKAGE_ROOT, 'skills', 'generate-checklist', 'SKILL.md'),
-    relativeTarget: path.join('skills', 'generate-checklist', 'SKILL.md'),
-  },
-];
-const ADAPTERS = {
-  codex: {
-    label: 'Codex',
-    source: path.join(PACKAGE_ROOT, 'templates', 'adapters', 'AGENTS.md'),
-    target: 'AGENTS.md',
-  },
-  claude: {
-    label: 'Claude Code',
-    source: path.join(PACKAGE_ROOT, 'templates', 'adapters', 'CLAUDE.md'),
-    target: 'CLAUDE.md',
-  },
-  generic: {
-    label: 'Generic rules',
-    source: path.join(PACKAGE_ROOT, 'templates', 'adapters', 'RULES.md'),
-    target: 'RULES.md',
-  },
-};
-
-function printHelp() {
-  console.log(`skill-reyson
-
-Usage:
-  skill-reyson                Start interactive installer
-  skill-reyson install        Start interactive installer
-  skill-reyson install --dir <path> [--agents codex,claude,generic] [--with-agent-files]
-  skill-reyson install --yes [--dir <path>] [--agents codex,claude,generic] [--with-agent-files]
-  skill-reyson --help         Show help
-
-Defaults:
-  - Installs docs/spec-workflow.md
-  - Installs skills/generate-task-list/SKILL.md
-  - Installs skills/generate-checklist/SKILL.md
-  - Does NOT install agent guidance files unless requested
-`);
-}
-
-function parseArgs(argv) {
-  const args = argv.slice(2);
-  const options = { command: 'install', dir: process.cwd(), yes: false, withAgentFiles: false, agents: [] };
-  if (args[0] && !args[0].startsWith('-')) {
-    options.command = args.shift();
-  }
-  for (let i = 0; i < args.length; i += 1) {
-    const arg = args[i];
-    if (arg === '--help' || arg === '-h') {
-      options.command = 'help';
-    } else if (arg === '--yes' || arg === '-y') {
-      options.yes = true;
-    } else if (arg === '--with-agent-files') {
-      options.withAgentFiles = true;
-    } else if (arg === '--dir') {
-      options.dir = path.resolve(args[i + 1] || process.cwd());
-      i += 1;
-    } else if (arg.startsWith('--dir=')) {
-      options.dir = path.resolve(arg.split('=')[1]);
-    } else if (arg === '--agents') {
-      options.agents = (args[i + 1] || '').split(',').map((s) => s.trim()).filter(Boolean);
-      i += 1;
-    } else if (arg.startsWith('--agents=')) {
-      options.agents = arg.split('=')[1].split(',').map((s) => s.trim()).filter(Boolean);
-    } else {
-      throw new Error(`Unknown argument: ${arg}`);
-    }
-  }
-  return options;
-}
-
-function ensureDir(dirPath) {
-  fs.mkdirSync(dirPath, { recursive: true });
-}
-
-function copyFile(source, target) {
-  ensureDir(path.dirname(target));
-  fs.copyFileSync(source, target);
-}
-
-function copyCoreArtifacts(targetDir) {
-  const docTarget = path.join(targetDir, 'docs', 'spec-workflow.md');
-  copyFile(DOC_SOURCE, docTarget);
-  for (const skill of SKILL_SOURCES) {
-    copyFile(skill.source, path.join(targetDir, skill.relativeTarget));
-  }
-  return [
-    path.relative(targetDir, docTarget),
-    ...SKILL_SOURCES.map((skill) => skill.relativeTarget),
-  ];
-}
-
-function copyAgentFiles(targetDir, selectedAgents) {
-  const copied = [];
-  for (const key of selectedAgents) {
-    const adapter = ADAPTERS[key];
-    if (!adapter) continue;
-    copyFile(adapter.source, path.join(targetDir, adapter.target));
-    copied.push(adapter.target);
-  }
-  return copied;
-}
-
-function normalizeAgents(agentKeys) {
-  return Array.from(new Set(agentKeys.filter((key) => ADAPTERS[key])));
-}
-
-function createInterface() {
-  return readline.createInterface({ input: process.stdin, output: process.stdout });
-}
-
-function ask(rl, question) {
-  return new Promise((resolve) => rl.question(question, resolve));
-}
-
-async function runInteractive(defaults) {
-  const rl = createInterface();
-  try {
-    console.log('\nskill-reyson interactive installer\n');
-    const dirAnswer = await ask(rl, `Target directory [${defaults.dir}]: `);
-    const targetDir = path.resolve(dirAnswer.trim() || defaults.dir);
-
-    const includeAgentAnswer = await ask(rl, 'Install agent guidance files (AGENTS.md / CLAUDE.md / RULES.md)? [y/N]: ');
-    const withAgentFiles = /^y(es)?$/i.test(includeAgentAnswer.trim());
-
-    let agents = [];
-    if (withAgentFiles) {
-      console.log('\nSelect agent adapters (comma-separated numbers):');
-      console.log('  1) Codex -> AGENTS.md');
-      console.log('  2) Claude Code -> CLAUDE.md');
-      console.log('  3) Generic rules -> RULES.md');
-      const agentAnswer = await ask(rl, 'Choice(s) [1]: ');
-      const tokens = (agentAnswer.trim() || '1').split(',').map((s) => s.trim());
-      const mapping = { '1': 'codex', '2': 'claude', '3': 'generic' };
-      agents = normalizeAgents(tokens.map((token) => mapping[token] || token.toLowerCase()));
-      if (agents.length === 0) {
-        agents = ['codex'];
-      }
-    }
-
-    const confirmation = await ask(rl, `\nProceed installing into ${targetDir}? [Y/n]: `);
-    const ok = confirmation.trim() === '' || /^y(es)?$/i.test(confirmation.trim());
-    if (!ok) {
-      console.log('Installation cancelled.');
-      return;
-    }
-
-    const result = performInstall({ targetDir, withAgentFiles, agents });
-    printSummary(result);
-  } finally {
-    rl.close();
-  }
-}
-
-function performInstall({ targetDir, withAgentFiles, agents }) {
-  ensureDir(targetDir);
-  const coreFiles = copyCoreArtifacts(targetDir);
-  const agentFiles = withAgentFiles ? copyAgentFiles(targetDir, normalizeAgents(agents)) : [];
-  return { targetDir, coreFiles, agentFiles };
-}
-
-function printSummary(result) {
-  console.log('\nInstalled skill-reyson scaffold:\n');
-  console.log(`Target: ${result.targetDir}`);
-  console.log('\nCore files:');
-  for (const file of result.coreFiles) {
-    console.log(`  - ${file}`);
-  }
-  if (result.agentFiles.length > 0) {
-    console.log('\nAgent guidance files:');
-    for (const file of result.agentFiles) {
-      console.log(`  - ${file}`);
-    }
-  } else {
-    console.log('\nAgent guidance files: none (default)');
-  }
-  console.log('\nNext steps:');
-  console.log('  1) Open docs/spec-workflow.md');
-  console.log('  2) Ensure your agent knows to read the workflow before coding');
-  console.log('  3) Use generate-task-list and generate-checklist when artifacts are missing');
-}
-
-async function main() {
-  let options;
-  try {
-    options = parseArgs(process.argv);
-  } catch (error) {
-    console.error(error.message);
-    printHelp();
-    process.exit(1);
-  }
-
-  if (options.command === 'help' || options.command === '--help' || options.command === '-h') {
-    printHelp();
-    return;
-  }
-
-  if (options.command !== 'install') {
-    console.error(`Unknown command: ${options.command}`);
-    printHelp();
-    process.exit(1);
-  }
-
-  if (options.yes) {
-    const result = performInstall({
-      targetDir: options.dir,
-      withAgentFiles: options.withAgentFiles,
-      agents: options.agents,
-    });
-    printSummary(result);
-    return;
-  }
-
-  await runInteractive(options);
-}
-
-main().catch((error) => {
-  console.error(error.stack || error.message);
-  process.exit(1);
-});
+require('./reyson-spec-gate.js');

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "reyson-spec-gate",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Interactive installer for a spec-first workflow scaffold with docs, skills, and optional agent guidance files.",
   "type": "commonjs",
   "bin": {
-    "skill-reyson": "bin/skill-reyson.js"
+    "reyson-spec-gate": "bin/reyson-spec-gate.js",
+    "skill-reyson": "bin/reyson-spec-gate.js"
   },
   "files": [
     "bin",

package/templates/adapters/AGENTS.md

@@ -1,16 +0,0 @@
-# AGENTS.md
-
-## Spec-first workflow rules
-
-Before any implementation task, read `docs/spec-workflow.md`.
-
-Before coding begins, verify whether the current work includes:
-- an explicit task list
-- an explicit checklist
-
-If the task list is missing, generate it first.
-If the checklist is missing, generate it second.
-If both are missing, generate both before coding.
-
-Do not begin implementation until the pre-coding gate is satisfied.
-After coding, revisit the checklist before claiming completion.

package/templates/adapters/CLAUDE.md

@@ -1,16 +0,0 @@
-# CLAUDE.md
-
-## Spec-first workflow rules
-
-Before any implementation task, read `docs/spec-workflow.md`.
-
-Before coding begins, verify whether the current work includes:
-- an explicit task list
-- an explicit checklist
-
-If the task list is missing, generate it first.
-If the checklist is missing, generate it second.
-If both are missing, generate both before coding.
-
-Do not begin implementation until the pre-coding gate is satisfied.
-After coding, revisit the checklist before claiming completion.