create-issflow 1.0.0 → 1.0.2

package/README.md

@@ -1,41 +1,56 @@
-# create-issflow
-
-Scaffold the **iStartSoftFlow** AI-coding workflow into any project — Claude Code
-only, **no Azure, no Cursor**. Non-destructive: it never overwrites your files.
-
-## Use
-
-```bash
-cd my-project
-npx create-issflow            # scaffolds .claude/ into the current project
-# then open Claude Code — the SessionStart hook fires automatically
-/overview                            # bootstrap the project
-```
-
-Flags:
-- `--dry-run` — print what would happen, write nothing.
-- `--force` — overwrite existing kit files (default keeps yours; conflicts are
-  written as `<file>.issflow-new` for you to merge).
-
-## What it installs (into `<project>/.claude/`)
-
-- `agents/` — planner · researcher · implementer · test-author · debugger · e2e-runner · synthesizer
-- `commands/` — `/overview` `/phase` `/quick` `/replan` `/synthesize` `/store-wisdom` `/log-issue` `/log-decision` `/unstuck`
-- `skills/` — caveman · grill-me · karpathy-guidelines
-- `hooks/` — session-start · pre-compact · subagent-stop (merged into `.claude/settings.json`, existing hooks preserved)
-- `istartsoft-flow/METHODOLOGY.md` — the full methodology
-
-It also un-ignores the workflow dirs in `.gitignore` if `.claude/*` was ignored.
-
-## Loop
-
-`design-research → grill → plan → implement → test → deploy`, one vertical slice
-per phase. **Phase 0 (infra) is N/A** — infra is managed (Vercel + Supabase).
-Planning source of truth stays in iSSM/BMAD; iStartSoftFlow is the execution loop.
-
-## Maintainers
-
-The kit lives in the repo's `.claude/`. After editing it, run `bash build.sh` to
-refresh `template/`, then bump `version` and publish.
-
-Adapted from the open "anpunkit" workflow by MetheeS (MIT).
+# create-issflow
+
+Scaffold the **iStartSoftFlow** AI-coding workflow into any project. Stack-agnostic
+and tool-agnostic. Non-destructive: it never overwrites your files.
+
+## Use
+
+```bash
+cd my-project
+npx create-issflow                  # prompts for your AI tool
+npx create-issflow --tool=claude    # or pass it: claude | codex | cursor | gemini | aider | all
+# then open your tool — Claude Code fires the SessionStart hook automatically
+/overview                           # bootstrap the project
+```
+
+Flags:
+- `--tool=<name>` — pick the target tool (skips the prompt). `all` writes every adapter.
+- `--dry-run` — print what would happen, write nothing.
+- `--force` — overwrite existing kit files (default keeps yours; conflicts are
+  written as `<file>.issflow-new` for you to merge).
+- `-h`, `--help` — usage.
+
+## What it installs
+
+The portable kit (every tool) in `<project>/.claude/`:
+
+- `agents/` — planner · researcher · implementer · test-author · debugger · e2e-runner · synthesizer
+- `commands/` — `/overview` `/phase` `/quick` `/replan` `/synthesize` `/store-wisdom` `/log-issue` `/log-decision` `/unstuck`
+- `skills/` — caveman · grill-me · karpathy-guidelines · ux-design
+- `hooks/` — session-start · pre-compact · subagent-stop
+- `istartsoft-flow/METHODOLOGY.md` — the full methodology (single source of truth)
+
+Plus a root `AGENTS.md` (the open standard) and the per-tool adapter:
+
+| Tool | Adds |
+|------|------|
+| `claude` | merges hooks into `.claude/settings.json` |
+| `codex` | nothing extra — `AGENTS.md` is read natively |
+| `cursor` | `.cursor/rules/` + `.cursor/commands/` + `.cursor/hooks.json` |
+| `gemini` | `GEMINI.md` pointer |
+| `aider` | `.aider.conf.yml` that loads the methodology |
+| `all` | every adapter above |
+
+It also un-ignores the workflow dirs in `.gitignore` if `.claude/*` was ignored.
+
+## Loop
+
+`design-research → grill → plan → implement → test → deploy`, one vertical slice
+per phase. Stack-agnostic: declare your stack in `docs/OVERVIEW.md`; Phase 0
+(infra) is N/A when infra is managed. Planning source of truth stays in your
+PRD / architecture / stories (e.g. BMAD / iSSM).
+
+## Maintainers
+
+The kit lives in the repo's `.claude/`. After editing it, run `bash build.sh` to
+refresh `template/`, then bump `version` and publish.

package/bin/cli.js

@@ -1,96 +1,259 @@
-#!/usr/bin/env node
-// create-issflow — scaffold the iStartSoftFlow workflow (Claude Code only)
-// into the current project. Pure Node, cross-platform, NON-DESTRUCTIVE:
-// never overwrites an existing file — on conflict it writes `<file>.issflow-new`.
-'use strict';
-const fs = require('fs');
-const path = require('path');
-
-const TPL = path.join(__dirname, '..', 'template');
-const CWD = process.cwd();
-const argv = process.argv.slice(2);
-const DRY = argv.includes('--dry-run');
-const FORCE = argv.includes('--force');
-
-// Hook wiring merged into .claude/settings.json (repo-relative commands).
-const HOOKS = {
-  SessionStart: [{ matcher: 'startup|clear|compact', hooks: [{ type: 'command', command: 'bash .claude/hooks/session-start.sh' }] }],
-  PreCompact:   [{ matcher: 'auto|manual',           hooks: [{ type: 'command', command: 'bash .claude/hooks/pre-compact.sh' }] }],
-  SubagentStop: [{ hooks: [{ type: 'command', command: 'bash .claude/hooks/subagent-stop.sh' }] }],
-};
-
-if (!fs.existsSync(path.join(TPL, '.claude'))) {
-  console.error('create-issflow: embedded template/ missing. From source run: bash build.sh');
-  process.exit(1);
-}
-
-const log = (...a) => console.log(...a);
-let created = 0, skipped = 0, conflicts = 0;
-
-function walk(dir) {
-  const out = [];
-  for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
-    const p = path.join(dir, e.name);
-    if (e.isDirectory()) out.push(...walk(p));
-    else out.push(p);
-  }
-  return out;
-}
-
-// 1. copy template tree (non-destructive)
-for (const src of walk(path.join(TPL, '.claude'))) {
-  const rel = path.relative(TPL, src);            // e.g. .claude/agents/planner.md
-  const dest = path.join(CWD, rel);
-  const isHook = rel.includes(`${path.sep}hooks${path.sep}`) && rel.endsWith('.sh');
-  const exists = fs.existsSync(dest);
-  if (exists && !FORCE) {
-    const same = fs.readFileSync(src, 'utf8') === fs.readFileSync(dest, 'utf8');
-    if (same) { skipped++; continue; }
-    const alt = dest + '.issflow-new';
-    conflicts++;
-    log(`  ~ conflict, wrote ${path.relative(CWD, alt)} (yours kept)`);
-    if (!DRY) { fs.mkdirSync(path.dirname(alt), { recursive: true }); fs.copyFileSync(src, alt); }
-    continue;
-  }
-  created++;
-  log(`  + ${rel}${exists ? ' (overwrote, --force)' : ''}`);
-  if (!DRY) {
-    fs.mkdirSync(path.dirname(dest), { recursive: true });
-    fs.copyFileSync(src, dest);
-    if (isHook) { try { fs.chmodSync(dest, 0o755); } catch (_) {} }
-  }
-}
-
-// 2. merge settings.json (preserve existing hooks; add ours only if absent)
-const sp = path.join(CWD, '.claude', 'settings.json');
-let settings = {};
-if (fs.existsSync(sp)) { try { settings = JSON.parse(fs.readFileSync(sp, 'utf8')); } catch (_) { console.error('  ! .claude/settings.json is not valid JSON — skipping hook merge'); settings = null; } }
-if (settings) {
-  settings.hooks = settings.hooks || {};
-  const added = [];
-  for (const k of Object.keys(HOOKS)) {
-    if (!settings.hooks[k]) { settings.hooks[k] = HOOKS[k]; added.push(k); }
-  }
-  if (added.length) {
-    log(`  + .claude/settings.json hooks: ${added.join(', ')}`);
-    if (!DRY) { fs.mkdirSync(path.dirname(sp), { recursive: true }); fs.writeFileSync(sp, JSON.stringify(settings, null, 2) + '\n'); }
-  } else {
-    log('  = .claude/settings.json hooks already present');
-  }
-}
-
-// 3. ensure .gitignore tracks the workflow dirs if .claude/* is ignored
-const gi = path.join(CWD, '.gitignore');
-if (fs.existsSync(gi)) {
-  const txt = fs.readFileSync(gi, 'utf8');
-  if (/^\.claude\/\*\s*$/m.test(txt) && !txt.includes('!.claude/agents/')) {
-    const block = '\n# iStartSoftFlow workflow — track as project config\n!.claude/agents/\n!.claude/commands/\n!.claude/skills/\n!.claude/hooks/\n!.claude/istartsoft-flow/\n';
-    log('  + .gitignore: un-ignore .claude workflow dirs');
-    if (!DRY) fs.appendFileSync(gi, block);
-  }
-}
-
-log('');
-log(`iStartSoftFlow ${DRY ? '(dry-run) ' : ''}done — created ${created}, conflicts ${conflicts}, unchanged ${skipped}.`);
-if (conflicts) log('Review *.issflow-new files and merge manually (your originals were untouched).');
-log('Open Claude Code — the SessionStart hook fires automatically. Run /overview to bootstrap.');
+#!/usr/bin/env node
+// create-issflow — scaffold the iStartSoftFlow agentic-dev workflow into the
+// current project. Pure Node, zero deps, cross-platform, NON-DESTRUCTIVE:
+// never overwrites an existing file — on conflict it writes `<file>.issflow-new`.
+//
+// Tool-agnostic: the portable kit lives in `.claude/` and the methodology is the
+// single source of truth. `--tool=<name>` writes the right adapter so the same
+// kit drives Claude Code, Codex, Cursor, Gemini CLI, Aider, or any AGENTS.md tool.
+'use strict';
+const fs = require('fs');
+const path = require('path');
+
+const TPL = path.join(__dirname, '..', 'template');
+const CWD = process.cwd();
+const argv = process.argv.slice(2);
+const DRY = argv.includes('--dry-run');
+const FORCE = argv.includes('--force');
+const HELP = argv.includes('-h') || argv.includes('--help');
+const toolArg = (argv.find(a => a.startsWith('--tool=')) || '').split('=')[1];
+
+const TOOLS = {
+  claude: 'Claude Code (Anthropic) — full: subagents, lifecycle hooks, skills',
+  codex:  'OpenAI Codex CLI — AGENTS.md native; subagents/skills as readable files',
+  cursor: 'Cursor — .cursor/rules + commands + hooks; reads .claude/agents natively',
+  gemini: 'Google Gemini CLI — GEMINI.md pointer; commands/skills as readable files',
+  aider:  'Aider — .aider.conf.yml loads the methodology as conventions',
+  all:    'Write every adapter above (mixed-team repo)',
+};
+
+let created = 0, skipped = 0, conflicts = 0;
+const warnings = [];
+const log = (...a) => console.log(...a);
+
+// ---- helpers ----------------------------------------------------------------
+
+function printHelp() {
+  log(`create-issflow — scaffold the iStartSoftFlow workflow.
+
+Usage: npx create-issflow [--tool=<name>] [--dry-run] [--force]
+
+Tools (--tool=, interactive prompt if omitted):`);
+  for (const [k, v] of Object.entries(TOOLS)) log(`  ${k.padEnd(7)} ${v}`);
+  log(`
+Flags:
+  --dry-run   print what would happen, write nothing
+  --force     overwrite existing kit files (default keeps yours -> <file>.issflow-new)
+  -h, --help  this message
+
+Every tool installs the portable kit in .claude/ + a root AGENTS.md (the open
+standard). The full methodology lives in .claude/istartsoft-flow/METHODOLOGY.md.`);
+}
+
+// Resolve the target tool: flag -> interactive (TTY) -> default 'claude'.
+function pickTool() {
+  if (toolArg) {
+    if (!TOOLS[toolArg]) { console.error(`create-issflow: unknown --tool=${toolArg}. One of: ${Object.keys(TOOLS).join(', ')}`); process.exit(1); }
+    return toolArg;
+  }
+  if (process.stdin.isTTY && process.stdout.isTTY && !DRY) {
+    const keys = Object.keys(TOOLS);
+    process.stdout.write('\nWhich AI coding tool? (the kit is portable — pick your primary)\n');
+    keys.forEach((k, i) => process.stdout.write(`  ${i + 1}) ${k} — ${TOOLS[k]}\n`));
+    process.stdout.write('> ');
+    let line = '';
+    try { line = (fs.readFileSync(0, 'utf8').split('\n')[0] || '').trim().toLowerCase(); } catch (_) {}
+    const chosen = TOOLS[line] ? line : keys[parseInt(line, 10) - 1];
+    if (!chosen) { console.error('create-issflow: no valid choice; defaulting to claude.'); return 'claude'; }
+    return chosen;
+  }
+  return 'claude'; // non-interactive default = back-compatible
+}
+
+// write a single file, non-destructive (honors DRY/FORCE).
+function writeFile(rel, content, { exec = false } = {}) {
+  const dest = path.join(CWD, rel);
+  const exists = fs.existsSync(dest);
+  if (exists && !FORCE) {
+    if (fs.readFileSync(dest, 'utf8') === content) { skipped++; return; }
+    const alt = dest + '.issflow-new';
+    conflicts++; log(`  ~ conflict, wrote ${path.relative(CWD, alt)} (yours kept)`);
+    if (!DRY) { fs.mkdirSync(path.dirname(alt), { recursive: true }); fs.writeFileSync(alt, content); }
+    return;
+  }
+  created++; log(`  + ${rel}${exists ? ' (overwrote, --force)' : ''}`);
+  if (!DRY) {
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.writeFileSync(dest, content);
+    if (exec) { try { fs.chmodSync(dest, 0o755); } catch (_) {} }
+  }
+}
+
+function walk(dir) {
+  const out = [];
+  for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+    const p = path.join(dir, e.name);
+    if (e.isDirectory()) out.push(...walk(p)); else out.push(p);
+  }
+  return out;
+}
+
+function copyTemplateCommands(destDir) {
+  const cmdDir = path.join(TPL, '.claude', 'commands');
+  if (!fs.existsSync(cmdDir)) return;
+  for (const f of fs.readdirSync(cmdDir)) writeFile(path.join(destDir, f), fs.readFileSync(path.join(cmdDir, f), 'utf8'));
+}
+
+// ---- adapters (keep the methodology single-source — these POINT at it) ------
+
+function adapterClaude() {
+  const HOOKS = {
+    SessionStart: [{ matcher: 'startup|clear|compact', hooks: [{ type: 'command', command: 'bash .claude/hooks/session-start.sh' }] }],
+    PreCompact:   [{ matcher: 'auto|manual',           hooks: [{ type: 'command', command: 'bash .claude/hooks/pre-compact.sh' }] }],
+    SubagentStop: [{ hooks: [{ type: 'command', command: 'bash .claude/hooks/subagent-stop.sh' }] }],
+  };
+  const sp = path.join(CWD, '.claude', 'settings.json');
+  let settings = {};
+  if (fs.existsSync(sp)) { try { settings = JSON.parse(fs.readFileSync(sp, 'utf8')); } catch (_) { warnings.push('.claude/settings.json is not valid JSON — skipped hook merge'); settings = null; } }
+  if (!settings) return;
+  settings.hooks = settings.hooks || {};
+  const added = [];
+  for (const k of Object.keys(HOOKS)) if (!settings.hooks[k]) { settings.hooks[k] = HOOKS[k]; added.push(k); }
+  if (added.length) { log(`  + .claude/settings.json hooks: ${added.join(', ')}`); if (!DRY) { fs.mkdirSync(path.dirname(sp), { recursive: true }); fs.writeFileSync(sp, JSON.stringify(settings, null, 2) + '\n'); } }
+  else log('  = .claude/settings.json hooks already present');
+}
+
+function adapterCodex() {
+  warnings.push('codex: AGENTS.md is read natively. Lifecycle hooks unsupported (rituals model-run); subagents in .claude/agents/ are read as reference, not isolated contexts.');
+}
+
+function adapterCursor() {
+  writeFile('.cursor/rules/istartsoftflow.mdc', [
+    '---', 'description: iStartSoftFlow workflow — always apply', 'alwaysApply: true', '---', '',
+    'Run the **iStartSoftFlow** workflow. The full, single-source methodology is',
+    '`.claude/istartsoft-flow/METHODOLOGY.md` — read it before acting. Roles live in',
+    '`.claude/agents/` (Cursor reads them natively); procedures in `.cursor/commands/`',
+    '(mirror of `.claude/commands/`). Caveman ULTRA mode; apply the `karpathy-guidelines`',
+    'and `ux-design` skills. See `AGENTS.md` for the role/command/skill map.', '',
+  ].join('\n'));
+  copyTemplateCommands('.cursor/commands');
+  writeFile('.cursor/hooks.json', JSON.stringify({
+    version: 1,
+    hooks: {
+      sessionStart: [{ command: 'bash .claude/hooks/session-start.sh' }],
+      subagentStop: [{ command: 'bash .claude/hooks/subagent-stop.sh' }],
+    },
+  }, null, 2) + '\n');
+  warnings.push('cursor: PreCompact has no Cursor equivalent (snapshot ritual degrades to model-run); verify hooks.json against cursor.com/docs/hooks — the schema evolves.');
+}
+
+function adapterGemini() {
+  writeFile('GEMINI.md', [
+    '# GEMINI.md — iStartSoftFlow', '',
+    'This repo runs the **iStartSoftFlow** agentic dev workflow. The complete,',
+    'tool-agnostic methodology (the single source of truth) lives in',
+    '`.claude/istartsoft-flow/METHODOLOGY.md` — read it before acting. Roles are in',
+    '`.claude/agents/`, procedures in `.claude/commands/` (run their bodies as prompts),',
+    'skills in `.claude/skills/` (read on demand). See `AGENTS.md` for the full map.', '',
+    'Lifecycle hooks do not auto-fire in Gemini CLI — run the SESSION-OPEN ritual',
+    '(git state, docs/STATE.md, docs/ISSUES.md) yourself at the start of each session.', '',
+  ].join('\n'));
+  warnings.push('gemini: lifecycle hooks unsupported — SESSION-OPEN / PreCompact rituals are model-run (see GEMINI.md).');
+}
+
+function adapterAider() {
+  writeFile('.aider.conf.yml', [
+    '# iStartSoftFlow — load the methodology as conventions.',
+    '# Aider has no lifecycle hooks/subagents; the workflow degrades to model-run rituals.',
+    'read:',
+    '  - AGENTS.md',
+    '  - .claude/istartsoft-flow/METHODOLOGY.md',
+    '',
+  ].join('\n'));
+  warnings.push('aider: hooks + named subagents unsupported — the loop runs as a single-agent, model-driven workflow.');
+}
+
+const ADAPTERS = { claude: adapterClaude, codex: adapterCodex, cursor: adapterCursor, gemini: adapterGemini, aider: adapterAider };
+
+const NEXT_STEPS = {
+  claude: 'Open Claude Code — the SessionStart hook fires automatically. Run /overview to bootstrap.',
+  codex:  'Open Codex CLI — it reads AGENTS.md. Start by running the /overview procedure (.claude/commands/overview.md).',
+  cursor: 'Open Cursor — the rule applies automatically. Run the /overview command to bootstrap.',
+  gemini: 'Open Gemini CLI — it reads GEMINI.md. Run the SESSION-OPEN ritual, then the overview procedure.',
+  aider:  'Run aider — it loads AGENTS.md + METHODOLOGY.md. Drive the loop manually (overview -> phase).',
+  all:    'Open your tool of choice — AGENTS.md is the shared entry. Run /overview to bootstrap.',
+};
+
+function agentsMd() {
+  return [
+    '# AGENTS.md — iStartSoftFlow', '',
+    'This repo runs the **iStartSoftFlow** agentic dev workflow. The complete,',
+    'tool-agnostic methodology — the loop, roles, procedures, rituals, and hard',
+    'rules — lives in ONE file. Read it before acting:', '',
+    '> **`.claude/istartsoft-flow/METHODOLOGY.md`** ← single source of truth.', '',
+    'Do not restate its rules elsewhere; this file only indexes it (anti-drift invariant).', '',
+    '## The loop', '',
+    'design-research → grill ×2 → plan → implement → test → deploy — one VERTICAL',
+    'SLICE per phase. Phase 0 (infra) leads only when infra is self-managed.', '',
+    '## Roles — `.claude/agents/`', '',
+    'planner · researcher · implementer · test-author · debugger · e2e-runner · synthesizer', '',
+    '## Procedures — `.claude/commands/` (run as `/name`)', '',
+    '/overview · /phase · /quick · /replan · /synthesize · /store-wisdom · /log-issue · /log-decision · /unstuck', '',
+    '## Skills — `.claude/skills/` (loaded on demand)', '',
+    'caveman · grill-me · karpathy-guidelines · ux-design', '',
+    '## Hard-rule index (full text in METHODOLOGY.md)', '',
+    '1 grep ISSUES + research before debugging · 2 debug cap = 3 · 3 log every fix ·',
+    '4 synthesize + context-reset per phase · 5 phase gate = real suite green ·',
+    '6 blind tests (RED-first) · 7 programmatic E2E auth · 8 log-decision on arch change ·',
+    '9 UI conforms to the `ux-design` cookbook + wireframe frame · 10 no-rationalization.', '',
+    '## Your stack', '',
+    'Declare your stack (language, framework, infra, auth, test + E2E runner,',
+    'planning source) once in `docs/OVERVIEW.md`. Every rule references *your declared',
+    'stack* and hardcodes none.', '',
+  ].join('\n');
+}
+
+// ---- main -------------------------------------------------------------------
+
+function main() {
+  if (HELP) { printHelp(); return; }
+  if (!fs.existsSync(path.join(TPL, '.claude'))) {
+    console.error('create-issflow: embedded template/ missing. From source run: bash build.sh');
+    process.exit(1);
+  }
+
+  const TOOL = pickTool();
+  const targets = TOOL === 'all' ? Object.keys(TOOLS).filter(t => t !== 'all') : [TOOL];
+
+  // 1. portable kit tree (.claude/) — every tool gets it.
+  for (const src of walk(path.join(TPL, '.claude'))) {
+    const rel = path.relative(TPL, src);
+    const isHook = rel.includes(`${path.sep}hooks${path.sep}`) && rel.endsWith('.sh');
+    writeFile(rel, fs.readFileSync(src, 'utf8'), { exec: isHook });
+  }
+
+  // 2. AGENTS.md — the open-standard entry point.
+  writeFile('AGENTS.md', agentsMd());
+
+  // 3. per-tool adapters
+  for (const t of targets) ADAPTERS[t]();
+
+  // 4. .gitignore: track the workflow dirs if .claude/* is ignored
+  const gi = path.join(CWD, '.gitignore');
+  if (fs.existsSync(gi)) {
+    const txt = fs.readFileSync(gi, 'utf8');
+    if (/^\.claude\/\*\s*$/m.test(txt) && !txt.includes('!.claude/agents/')) {
+      const block = '\n# iStartSoftFlow workflow — track as project config\n!.claude/agents/\n!.claude/commands/\n!.claude/skills/\n!.claude/hooks/\n!.claude/istartsoft-flow/\n';
+      log('  + .gitignore: un-ignore .claude workflow dirs');
+      if (!DRY) fs.appendFileSync(gi, block);
+    }
+  }
+
+  log('');
+  log(`iStartSoftFlow ${DRY ? '(dry-run) ' : ''}[${TOOL}] done — created ${created}, conflicts ${conflicts}, unchanged ${skipped}.`);
+  if (conflicts) log('Review *.issflow-new files and merge manually (your originals were untouched).');
+  for (const w of warnings) log(`  ! ${w}`);
+  log(NEXT_STEPS[TOOL] || NEXT_STEPS.claude);
+}
+
+main();

package/package.json

@@ -1,23 +1,28 @@
-{
-  "name": "create-issflow",
-  "version": "1.0.0",
-  "description": "Scaffold the iStartSoftFlow AI-coding workflow (Claude Code) into a project. Non-destructive, Claude-only (no Azure, no Cursor).",
-  "bin": {
-    "create-issflow": "bin/cli.js"
-  },
-  "files": [
-    "bin/",
-    "template/"
-  ],
-  "engines": {
-    "node": ">=18"
-  },
-  "keywords": [
-    "claude-code",
-    "agents",
-    "tdd",
-    "workflow",
-    "istartsoftflow"
-  ],
-  "license": "MIT"
-}
+{
+  "name": "create-issflow",
+  "version": "1.0.2",
+  "description": "Scaffold the iStartSoftFlow AI-coding workflow into a project. Stack-agnostic, tool-agnostic (Claude Code, Codex, Cursor, Gemini, Aider), non-destructive.",
+  "bin": {
+    "create-issflow": "bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "template/"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "claude-code",
+    "codex",
+    "cursor",
+    "gemini-cli",
+    "aider",
+    "agents-md",
+    "agents",
+    "tdd",
+    "workflow",
+    "istartsoftflow"
+  ],
+  "license": "MIT"
+}

package/template/.claude/agents/debugger.md

@@ -1,47 +1,47 @@
----
-name: debugger
-description: Diagnoses one specific failing test or bug in an ISOLATED context. Keeps debug noise out of the main session.
-tools: Read, Grep, Glob, Edit, Bash, Write
-model: opus
----
-
-You are the DEBUGGER. Caveman ULTRA mode.
-
-Why you exist: debugging generates huge noisy context. Running it isolated +
-writing noise to a file keeps the orchestrator's context clean.
-
-START — check what is already known:
-1. grep docs/ISSUES.md for this error. Found -> apply known solution. Done.
-2. grep docs/research/INDEX.md. If a prior debug-*.md exists, READ IT FIRST —
-   lists hypotheses already ruled out. Do not repeat them.
-
-PROCESS:
-3. Reproduce. Form ONE hypothesis. State it before changing anything.
-4. SERVICE-vs-LOGIC triage: if external service involved, determine
-   SERVICE UNAVAILABLE vs LOGIC FAIL first. SERVICE UNAVAILABLE -> stop,
-   return that status. Do NOT spend attempt budget on outages.
-5. Fix. Verify the fix runs (lint/typecheck/test). Report the REAL root cause.
-6. If fix attempt fails: form a NEW hypothesis (not a variation). Budget = 3 total.
-   WARN at attempt 2: "2 attempts failed, 1 remaining. Hypotheses: <1>, <2>."
-   STUCK at attempt 3: stop, return STUCK.
-
-WRITE-TO-FILE:
-Write full trace to `docs/research/debug-<slug>.md`. Include:
-- the failing test / symptom
-- every hypothesis tried
-- evidence that ruled each one out
-- current best hypothesis if STUCK
-Append one line to docs/research/INDEX.md.
-
-RETURN (terse):
-```
-
-DEBUG DONE: <slug>
-
-- result: FIXED | STUCK | SERVICE UNAVAILABLE | WARN
-- root cause (if fixed): <real cause>
-- fix applied: <what changed>
-- if STUCK: 3 hypotheses tried = <list>, current best guess = <…>
-- full trace: docs/research/debug-<slug>.md
-
-```
+---
+name: debugger
+description: Diagnoses one specific failing test or bug in an ISOLATED context. Keeps debug noise out of the main session.
+tools: Read, Grep, Glob, Edit, Bash, Write
+model: opus
+---
+
+You are the DEBUGGER. Caveman ULTRA mode.
+
+Why you exist: debugging generates huge noisy context. Running it isolated +
+writing noise to a file keeps the orchestrator's context clean.
+
+START — check what is already known:
+1. grep docs/ISSUES.md for this error. Found -> apply known solution. Done.
+2. grep docs/research/INDEX.md. If a prior debug-*.md exists, READ IT FIRST —
+   lists hypotheses already ruled out. Do not repeat them.
+
+PROCESS:
+3. Reproduce. Form ONE hypothesis. State it before changing anything.
+4. SERVICE-vs-LOGIC triage: if external service involved, determine
+   SERVICE UNAVAILABLE vs LOGIC FAIL first. SERVICE UNAVAILABLE -> stop,
+   return that status. Do NOT spend attempt budget on outages.
+5. Fix. Verify the fix runs (lint/typecheck/test). Report the REAL root cause.
+6. If fix attempt fails: form a NEW hypothesis (not a variation). Budget = 3 total.
+   WARN at attempt 2: "2 attempts failed, 1 remaining. Hypotheses: <1>, <2>."
+   STUCK at attempt 3: stop, return STUCK.
+
+WRITE-TO-FILE:
+Write full trace to `docs/research/debug-<slug>.md`. Include:
+- the failing test / symptom
+- every hypothesis tried
+- evidence that ruled each one out
+- current best hypothesis if STUCK
+Append one line to docs/research/INDEX.md.
+
+RETURN (terse):
+```
+
+DEBUG DONE: <slug>
+
+- result: FIXED | STUCK | SERVICE UNAVAILABLE | WARN
+- root cause (if fixed): <real cause>
+- fix applied: <what changed>
+- if STUCK: 3 hypotheses tried = <list>, current best guess = <…>
+- full trace: docs/research/debug-<slug>.md
+
+```