@givolt/i3-composer-agent 1.0.0 → 2.0.0

package/bin/i3-composer-agent.cjs

@@ -12,23 +12,35 @@ const identity = `i3 Composer Agent v${pkg.version}\nBased on agent-skills v${pk
 const help = `${identity}
 ${pkg.name}
 
-Prepare the complete i3 Composer Agent plugin, including shared references.
+Install engineering skills with a multi-tool installation wizard.
 
 Usage:
-  npx ${pkg.name} --codebuddy [--dir <directory>]
-  npx ${pkg.name} --codex [--dir <directory>]
-  npx ${pkg.name} --claude [--dir <directory>]
+  npx ${pkg.name}
+  npx ${pkg.name} --codebuddy
+  npx ${pkg.name} --agents codebuddy,codex --scope project --yes
+  npx ${pkg.name} --prepare --claude --dir <directory>
   npx ${pkg.name} --extract --dir <directory>
 
 Options:
-  --dir <directory>  Output directory (default: ./i3-composer-agent)
-  --dry-run         Show the planned bundle without writing files
-  --force           Replace an existing i3 bundle, preserving a backup
-  --version         Print the package version
-  --help            Show this help
+  --agents <ids>      Comma-separated tool IDs; multiple tools are supported
+  --codebuddy        Preselect CodeBuddy desktop IDE / CodeBuddy Code
+  --codex            Preselect Codex
+  --claude           Preselect Claude Code
+  --scope <scope>    project or global (or use --global / --local)
+  --project-dir <dir> Project installation root (default: current directory)
+  --yes              Confirm explicit noninteractive installation
+  --list-agents      List all supported tool directories
+  --prepare          Prepare a complete plugin for native plugin registration
+  --dir <directory>  Plugin output directory; implies --prepare
+  --dry-run          Show the installation or bundle plan without writing files
+  --force            Replace existing assets, preserving backups
+  --version          Print the package version
+  --help             Show this help
 
-Host flags prepare the bundle and print native registration commands.
-Execute those commands in the intended host to enable the plugin.
+The terminal wizard selects tools and scope, then installs native skill files.
+CodeBuddy and Claude Code also receive short lifecycle commands and personas.
+Other tools receive skills and references; command availability is host-specific.
+Use --prepare for complete plugins, including hooks and host registration.
 `;
 
 function quote(value) { return "'" + value.replaceAll("'", "'\\''") + "'"; }
@@ -43,15 +55,14 @@ function realDestination(target) {
   }
   return path.join(fs.realpathSync(existing), ...suffix);
 }
-function main() {
-  if (!args.length || args.includes('--help')) { console.log(help); return; }
-  if (args.length === 1 && args[0] === '--version') { console.log(pkg.version); return; }
+function prepare() {
   let host;
   let directory = path.join(process.cwd(), name);
   let dryRun = false;
   let force = false;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
+    if (arg === '--prepare') continue;
     if (['--codebuddy', '--codex', '--claude', '--extract'].includes(arg)) {
       if (host) throw new Error('Choose exactly one host flag or --extract.');
       host = arg.slice(2);
@@ -116,7 +127,64 @@ function main() {
   } else {
     console.log(`/plugin marketplace add ${quote(directory)}`);
     console.log(`/plugin install ${selector}`);
-    console.log(`Use /${name}:spec, /${name}:plan, /${name}:build, and /${name}:ship in ${host === 'claude' ? 'Claude Code' : 'CodeBuddy'}.`);
+    console.log(`Use /${name}:i3-spec, /${name}:i3-plan, /${name}:i3-build, and /${name}:i3-ship in ${host === 'claude' ? 'Claude Code' : 'CodeBuddy'}.`);
+  }
+}
+async function main() {
+  if (args.includes('--help') || (!args.length && !process.stdin.isTTY)) { console.log(help); return; }
+  if (args.length === 1 && args[0] === '--version') { console.log(pkg.version); return; }
+  if (args.some(arg => ['--extract', '--prepare', '--dir'].includes(arg))) { prepare(); return; }
+  const installer = require('./install.cjs');
+  if (args.length === 1 && args[0] === '--list-agents') {
+    for (const agent of installer.registry.agents) console.log(`${agent.id.padEnd(20)} ${agent.label}${agent.globalSkillsDir ? '' : ' (project only)'}`);
+    return;
+  }
+  const options = { agents: [], projectDir: process.cwd() };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (['--codebuddy', '--codex', '--claude'].includes(arg)) options.agents.push(arg.slice(2));
+    else if (['--agents', '--scope', '--project-dir'].includes(arg)) {
+      if (!args[i + 1] || args[i + 1].startsWith('--')) throw new Error(`${arg} requires a value.`);
+      const value = args[++i];
+      if (arg === '--agents') options.agents.push(value);
+      else if (arg === '--scope') { if (options.scope && options.scope !== value) throw new Error('Choose one installation scope.'); options.scope = value; }
+      else options.projectDir = path.resolve(value);
+    } else if (arg === '--global' || arg === '--local') {
+      const scope = arg === '--global' ? 'global' : 'project';
+      if (options.scope && options.scope !== scope) throw new Error('Choose one installation scope.');
+      options.scope = scope;
+    } else if (arg === '--yes') options.yes = true;
+    else if (arg === '--force') options.force = true;
+    else if (arg === '--dry-run') options.dryRun = true;
+    else throw new Error(`Unknown option: ${arg}`);
+  }
+  options.agents = installer.selectAgents(options.agents);
+  if (process.stdin.isTTY && process.stdout.isTTY && !options.yes && !options.dryRun) {
+    const selection = await require('./wizard.cjs').choose(options, identity);
+    if (!selection) { console.log('Installation cancelled. No files changed.'); return; }
+    Object.assign(options, selection);
+  } else if (!options.agents.length || !options.scope || (!options.yes && !options.dryRun)) {
+    throw new Error('Use an interactive terminal, or specify --agents <ids> --scope project|global --yes.');
+  }
+  const plan = installer.planInstallation(options);
+  if (options.dryRun) {
+    console.log(JSON.stringify({ name, version: pkg.version, upstreamVersion: pkg.i3ComposerAgent.upstreamVersion, upstreamCommit: pkg.i3ComposerAgent.upstreamCommit, mode: plan.mode, scope: plan.scope, agents: plan.agents, targets: plan.targets, conflicts: plan.conflicts }, null, 2));
+    return;
+  }
+  if (!options.yes) {
+    const confirmed = await require('./wizard.cjs').confirm(plan);
+    if (!confirmed) { console.log('Installation cancelled. No files changed.'); return; }
+    options.force = plan.conflicts.length > 0;
+  }
+  const backups = installer.executeInstallation(plan, { force: options.force });
+  console.log(identity);
+  for (const target of plan.targets) {
+    console.log(`Installed ${target.agents.join(', ')} skills at ${target.skillsDirectory}`);
+    if (target.commandsDirectory) console.log(`Commands: /i3-spec, /i3-plan, /i3-build, /i3-ship (all ${fs.readdirSync(target.commandsDirectory).filter(file => file.endsWith('.md')).length} workflows) at ${target.commandsDirectory}`);
   }
+  for (const backup of backups) console.log(`Previous assets preserved at ${backup}`);
+  console.log('Reload the IDE window or start a new host session to discover installed files.');
+  if (plan.agents.some(id => !['codebuddy', 'claude-code'].includes(id))) console.log('These tools use the existing skill IDs; lifecycle slash-command support depends on the host.');
+  console.log('Native skill installation does not enable plugin hooks. Use --prepare for complete plugin registration.');
 }
-try { main(); } catch (error) { console.error(`${name}: ${error.message}`); process.exitCode = 1; }
+main().catch(error => { console.error(`${name}: ${error.message}`); process.exitCode = 1; });

package/bin/install.cjs

@@ -0,0 +1,180 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const crypto = require('node:crypto');
+const registry = require('./agent-targets.json');
+const upstream = require('../rebrand/upstream.json');
+const root = path.resolve(__dirname, '..');
+const name = 'i3-composer-agent';
+const aliases = { claude: 'claude-code', gemini: 'gemini-cli', copilot: 'github-copilot' };
+function exists(file) {
+  try { fs.lstatSync(file); return true; }
+  catch (error) { if (error.code === 'ENOENT') return false; throw error; }
+}
+function selectAgents(values) {
+  const ids = [...new Set(values.flatMap(value => value.split(',')).map(id => aliases[id.trim()] || id.trim()).filter(Boolean))];
+  for (const id of ids) if (!registry.agents.some(agent => agent.id === id)) throw new Error(`Unknown tool: ${id}. Use --list-agents.`);
+  return ids;
+}
+function globalSkillsDir(agent, home, env) {
+  const config = agent.globalSkillsDir;
+  if (!config) throw new Error(`${agent.label} supports project installation only. Choose project scope or remove this tool.`);
+  let base = home;
+  if (config.base === 'config') base = env.XDG_CONFIG_HOME && path.isAbsolute(env.XDG_CONFIG_HOME) ? env.XDG_CONFIG_HOME : path.join(home, '.config');
+  if (config.base === 'env') base = env[config.env]?.trim() || path.join(home, config.fallback);
+  if (config.alternatives && !fs.existsSync(path.join(home, path.dirname(config.path)))) {
+    const alternative = config.alternatives.find(relative => fs.existsSync(path.join(home, path.dirname(relative))));
+    if (alternative) return path.join(home, alternative);
+  }
+  return path.resolve(base, config.path);
+}
+// Resolve parent aliases while keeping a leaf symlink replaceable as a link.
+function destination(file) {
+  let parent = path.dirname(file);
+  const suffix = [path.basename(file)];
+  while (!exists(parent)) { suffix.unshift(path.basename(parent)); parent = path.dirname(parent); }
+  return path.join(fs.realpathSync(parent), ...suffix);
+}
+function checkDestination(file) {
+  const source = fs.realpathSync(root);
+  if (file === source || file.startsWith(source + path.sep) || source.startsWith(file + path.sep)) {
+    throw new Error('Installation destinations must be outside this package directory.');
+  }
+}
+function planInstallation({ agents, scope, projectDir = process.cwd(), home = os.homedir(), env = process.env }) {
+  agents = selectAgents(agents);
+  if (!agents.length) throw new Error('Choose at least one tool.');
+  if (!['project', 'global'].includes(scope)) throw new Error('Choose --scope project or --scope global.');
+  const targets = new Map();
+  for (const id of agents) {
+    const agent = registry.agents.find(item => item.id === id);
+    const skillsDirectory = destination(scope === 'project' ? path.resolve(projectDir, agent.projectSkillsDir) : globalSkillsDir(agent, home, env));
+    const base = path.dirname(skillsDirectory);
+    if (!targets.has(skillsDirectory)) targets.set(skillsDirectory, { agents: [], skillsDirectory, referencesDirectory: path.join(base, 'references'), base });
+    const target = targets.get(skillsDirectory);
+    target.agents.push(id);
+    if (['codebuddy', 'claude-code'].includes(id)) {
+      target.commandsDirectory = path.join(base, 'commands');
+      target.personasDirectory = path.join(base, 'agents');
+    }
+  }
+  const assets = [];
+  function addDirectory(sourceDirectory, destinationDirectory, kind) {
+    if (exists(destinationDirectory) && fs.lstatSync(destinationDirectory).isSymbolicLink()) {
+      throw new Error(`Installation directory is a symlink: ${destinationDirectory}. Choose its canonical location instead.`);
+    }
+    for (const entry of fs.readdirSync(path.join(root, sourceDirectory)).sort()) {
+      if (entry === '.DS_Store') continue;
+      assets.push({ source: path.join(root, sourceDirectory, entry), destination: destination(path.join(destinationDirectory, entry)), kind });
+    }
+  }
+  for (const target of targets.values()) {
+    const start = assets.length;
+    addDirectory('skills', target.skillsDirectory, 'skill');
+    addDirectory('references', target.referencesDirectory, 'reference');
+    if (target.commandsDirectory) {
+      addDirectory('.claude/commands', target.commandsDirectory, 'command');
+      addDirectory('agents', target.personasDirectory, 'persona');
+      const docs = path.join(target.base, 'docs');
+      if (exists(docs) && fs.lstatSync(docs).isSymbolicLink()) throw new Error(`Installation directory is a symlink: ${docs}.`);
+      assets.push({ source: path.join(root, 'docs/agents.md'), destination: destination(path.join(target.base, 'docs/agents.md')), kind: 'documentation' });
+    }
+    assets.push({ source: path.join(root, 'LICENSE'), destination: destination(path.join(target.base, `${name}-LICENSE`)), kind: 'attribution' });
+    assets.push({ source: path.join(root, 'NOTICE.md'), destination: destination(path.join(target.base, `${name}-NOTICE.md`)), kind: 'attribution' });
+    const manifestFile = path.join(target.base, `.${name}.json`);
+    if (exists(manifestFile)) {
+      const previous = JSON.parse(fs.readFileSync(manifestFile, 'utf8'));
+      if (previous.name === name && Array.isArray(previous.assets)) {
+        const legacy = upstream.skills.map(id => `skills/${id}`);
+        if (target.commandsDirectory) legacy.push(...upstream.commands.map(id => `commands/${id}.md`));
+        for (const relative of legacy) {
+          const file = destination(path.join(target.base, relative));
+          if (previous.assets.includes(relative) && exists(file)) assets.push({ destination: file, kind: 'legacy' });
+        }
+      }
+    }
+    assets.push({ target, destination: destination(manifestFile), kind: 'manifest' });
+    for (const asset of assets.slice(start)) {
+      asset.base = target.base;
+      asset.codebuddyCommand = asset.kind === 'command' && target.agents.includes('codebuddy');
+    }
+  }
+  for (const asset of assets) { checkDestination(asset.destination); asset.existing = exists(asset.destination); }
+  return { mode: 'install', scope, agents, targets: [...targets.values()], assets, conflicts: assets.filter(asset => asset.existing).map(asset => asset.destination) };
+}
+function executeInstallation(plan, { force = false } = {}) {
+  if (plan.conflicts.length && !force) throw new Error('Existing installation assets require confirmation or --force; previous files will be backed up.');
+  const pkg = require('../package.json');
+  const contexts = new Map();
+  const createdDirectories = [];
+  const committed = [];
+  function mkdir(directory) {
+    if (exists(directory)) return;
+    mkdir(path.dirname(directory));
+    fs.mkdirSync(directory);
+    createdDirectories.push(directory);
+  }
+  function portable(file, markdown = false, codebuddyCommand = false) {
+    if (fs.statSync(file).isDirectory()) {
+      for (const entry of fs.readdirSync(file)) portable(path.join(file, entry), false, codebuddyCommand);
+    } else if (markdown || file.endsWith('.md')) {
+      let content = fs.readFileSync(file, 'utf8').replaceAll('i3-composer-agent:', '').replaceAll('agent-skills:', '');
+      if (codebuddyCommand) content = content.replaceAll('.claude/agents/', '.codebuddy/agents/');
+      fs.writeFileSync(file, content);
+    }
+  }
+  try {
+    // Stage every target before replacing the first installed asset.
+    for (const [index, asset] of plan.assets.entries()) {
+      if (!contexts.has(asset.base)) {
+        mkdir(asset.base);
+        contexts.set(asset.base, { staging: fs.mkdtempSync(path.join(asset.base, `.${name}-stage-`)), backup: path.join(asset.base, `.${name}-backup-${crypto.randomUUID()}`) });
+      }
+      const context = contexts.get(asset.base);
+      if (asset.kind === 'legacy') continue;
+      asset.staged = path.join(context.staging, String(index));
+      if (asset.kind === 'manifest') {
+        fs.writeFileSync(asset.staged, JSON.stringify({ name, version: pkg.version, entryPrefix: 'i3-', upstreamVersion: pkg.i3ComposerAgent.upstreamVersion, upstreamCommit: pkg.i3ComposerAgent.upstreamCommit, scope: plan.scope, agents: asset.target.agents, assets: plan.assets.filter(item => item.base === asset.base && item.kind !== 'legacy').map(item => path.relative(asset.base, item.destination)) }, null, 2) + '\n');
+      } else {
+        fs.cpSync(asset.source, asset.staged, { recursive: true, filter: file => {
+          if (fs.lstatSync(file).isSymbolicLink()) throw new Error(`Package contains a symlink: ${file}`);
+          return path.basename(file) !== '.DS_Store';
+        } });
+        portable(asset.staged, asset.source.endsWith('.md'), asset.codebuddyCommand);
+      }
+    }
+    for (const asset of plan.assets) {
+      const context = contexts.get(asset.base);
+      mkdir(path.dirname(asset.destination));
+      // A destination may have appeared since planning; never replace it implicitly.
+      if (exists(asset.destination) && !force) throw new Error(`Destination appeared during installation: ${asset.destination}. Retry with confirmed replacement.`);
+      const change = { destination: asset.destination, written: false };
+      if (exists(asset.destination)) {
+        change.backup = path.join(context.backup, path.relative(asset.base, asset.destination));
+        mkdir(path.dirname(change.backup));
+        fs.renameSync(asset.destination, change.backup);
+      }
+      committed.push(change);
+      if (asset.kind !== 'legacy') {
+        fs.renameSync(asset.staged, asset.destination);
+        change.written = true;
+      }
+    }
+    return [...contexts.values()].map(context => context.backup).filter(exists);
+  } catch (error) {
+    for (const change of committed.reverse()) {
+      if (change.written) fs.rmSync(change.destination, { recursive: true, force: true });
+      if (change.backup) fs.renameSync(change.backup, change.destination);
+    }
+    throw error;
+  } finally {
+    for (const context of contexts.values()) fs.rmSync(context.staging, { recursive: true, force: true });
+    for (const directory of createdDirectories.reverse()) {
+      try { fs.rmdirSync(directory); }
+      catch (error) { if (!['ENOENT', 'ENOTEMPTY', 'EEXIST'].includes(error.code)) throw error; }
+    }
+  }
+}
+module.exports = { registry, selectAgents, planInstallation, executeInstallation, exists };

package/bin/skills-registry.LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vercel, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/wizard.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+const readline = require('node:readline');
+const { registry, selectAgents } = require('./install.cjs');
+
+async function session(action) {
+  const terminal = readline.createInterface({ input: process.stdin, output: process.stdout });
+  let closed = false;
+  terminal.on('close', () => { closed = true; });
+  terminal.on('SIGINT', () => terminal.close());
+  const ask = prompt => new Promise(resolve => {
+    if (closed) { resolve(null); return; }
+    const cancelled = () => resolve(null);
+    terminal.once('close', cancelled);
+    terminal.question(prompt, answer => {
+      terminal.off('close', cancelled);
+      resolve(answer.trim());
+    });
+  });
+  try { return await action(ask); }
+  finally { terminal.close(); }
+}
+async function choose(options, identity) {
+  console.log(identity);
+  console.log('\nChoose tools (multiple selections are supported):');
+  const entries = registry.agents.map((agent, index) => `${index + 1}. ${agent.label} [${agent.id}]${agent.globalSkillsDir ? '' : ' (project only)'}`);
+  for (let index = 0; index < entries.length; index += 2) console.log(entries[index].padEnd(49) + (entries[index + 1] || ''));
+  return session(async ask => {
+    let agents;
+    while (!agents) {
+      const input = await ask(`Select tools by number or ID, comma-separated${options.agents.length ? ` [${options.agents.join(',')}]` : ''} (q cancels): `);
+      if (input === null || ['q', 'cancel'].includes(input.toLowerCase())) return null;
+      try {
+        const values = input === 'all' ? registry.agents.map(agent => agent.id) : input ? input.split(',').map(value => {
+          const trimmed = value.trim();
+          return /^\d+$/.test(trimmed) ? registry.agents[Number(trimmed) - 1]?.id || trimmed : trimmed;
+        }) : options.agents;
+        agents = selectAgents(values);
+        if (!agents.length) { agents = undefined; console.log('Choose at least one tool.'); }
+      } catch (error) { console.log(error.message); }
+    }
+    let scope = options.scope;
+    while (!scope) {
+      const input = await ask('Installation scope: 1. Project (current project), 2. Global (all projects) [1] (q cancels): ');
+      if (input === null || ['q', 'cancel'].includes(input.toLowerCase())) return null;
+      if (['', '1', 'project'].includes(input)) scope = 'project';
+      else if (['2', 'global'].includes(input)) scope = 'global';
+      else console.log('Choose 1 (project) or 2 (global).');
+    }
+    return { agents, scope };
+  });
+}
+async function confirm(plan) {
+  console.log(`\nInstallation scope: ${plan.scope}`);
+  for (const target of plan.targets) {
+    console.log(`  ${target.agents.join(', ')}: ${target.skillsDirectory}`);
+    if (target.commandsDirectory) console.log(`  Commands: ${target.commandsDirectory}`);
+  }
+  if (plan.conflicts.length) console.log(`${plan.conflicts.length} existing assets will be preserved in backups before replacement.`);
+  console.log('Includes all skills and shared references. Plugin hooks require native plugin registration.');
+  return session(async ask => {
+    const answer = await ask('Install these files? [y/N]: ');
+    return answer !== null && ['y', 'yes'].includes(answer.toLowerCase());
+  });
+}
+module.exports = { choose, confirm };

package/commands/{build.toml → i3-build.toml}

@@ -1,12 +1,12 @@
 description = "Implement tasks incrementally — build, test, verify, commit. Add \"auto\" to run the whole plan in one approved pass."
 
 prompt = """
-Invoke the incremental-implementation skill alongside test-driven-development.
+Invoke the i3-incremental-implementation skill alongside i3-test-driven-development.
 
 ## Modes
 
-- `/build` — implement the next pending task, then stop (careful, one slice at a time).
-- `/build auto` — generate the plan if needed, get a single approval, then implement every task without stopping between them.
+- `/i3-build` — implement the next pending task, then stop (careful, one slice at a time).
+- `/i3-build auto` — generate the plan if needed, get a single approval, then implement every task without stopping between them.
 
 The arguments select the mode. Treat `auto` (canonical) or `all` as autonomous mode; anything else (or empty) is the default single-task mode. Note: autonomous mode is not faster per task — it runs the same test-driven loop — it only removes the human stepping between tasks.
 
@@ -23,21 +23,21 @@ Pick the next pending task from the plan. Then:
 7. Commit with a descriptive message
 8. Mark the task complete and stop
 
-## Autonomous: the whole plan (`/build auto`)
+## Autonomous: the whole plan (`/i3-build auto`)
 
 Use this once a spec exists and you want to collapse plan + build into one run. It removes the manual stepping between tasks — not the verification. Every task still earns a passing test and its own commit.
 
-1. Require a spec. Look only for a spec at a known path: SPEC.md at the repo root, docs/SPEC.md, or a file under spec/. A README or arbitrary doc does NOT count. If none exists, stop and tell the user to run /spec first — do not invent requirements.
+1. Require a spec. Look only for a spec at a known path: SPEC.md at the repo root, docs/SPEC.md, or a file under spec/. A README or arbitrary doc does NOT count. If none exists, stop and tell the user to run /i3-spec first — do not invent requirements.
 2. Establish a clean baseline. Run `git status --porcelain`. If there are uncommitted changes outside the expected planning artifacts (SPEC.md, docs/SPEC.md, spec/*, tasks/plan.md, tasks/todo.md), stop and ask the user to commit, stash, or confirm how to handle them. Autonomous per-task commits must not absorb unrelated local work, or the clean-rollback guarantee breaks.
-3. Plan if needed. If there is no tasks/plan.md, invoke the planning-and-task-breakdown skill to generate one.
+3. Plan if needed. If there is no tasks/plan.md, invoke the i3-planning-and-task-breakdown skill to generate one.
 4. Single checkpoint. Present the full plan and wait for an unambiguous affirmative (e.g. "approve", "go", "yes"). Treat hedged responses ("looks reasonable", "I guess") as NOT approved. This is the only human gate — after approval, run autonomously. If you generated tasks/plan.md, commit it as a single preparatory commit now so it doesn't bleed into the first task's commit.
 5. Execute every task in dependency order. Use each task's declared dependencies; if they aren't explicit, execute in the order the plan lists them. For each task, run the full default loop above (RED → GREEN → regression → build → commit → mark complete). Stage only the files that task touched plus its task-status update — never `git add -A` blindly — and make one commit per task so any point is a clean rollback.
 6. Stop and ask the user (do not push through) when:
-   - a test can't be made to pass or the build breaks without an obvious fix → follow the debugging-and-error-recovery skill
+   - a test can't be made to pass or the build breaks without an obvious fix → follow the i3-debugging-and-error-recovery skill
    - the spec is ambiguous, or a task needs a decision the spec doesn't cover
-   - a task is high-risk or irreversible — auth/permission changes, destructive data migrations, payments, deletions, deploys, anything touching secrets, or anything you can't undo with `git revert` → follow the doubt-driven-development skill and get explicit sign-off before continuing
-   After the user resolves a blocker, they re-invoke /build auto — it resumes from the next pending task.
+   - a task is high-risk or irreversible — auth/permission changes, destructive data migrations, payments, deletions, deploys, anything touching secrets, or anything you can't undo with `git revert` → follow the i3-doubt-driven-development skill and get explicit sign-off before continuing
+   After the user resolves a blocker, they re-invoke /i3-build auto — it resumes from the next pending task.
 7. Summarize at the end: tasks completed, tests added, commits made, and anything skipped, flagged, or left for the user.
 
-If any step fails, follow the debugging-and-error-recovery skill.
+If any step fails, follow the i3-debugging-and-error-recovery skill.
 """

package/commands/{code-simplify.toml → i3-code-simplify.toml}

@@ -1,7 +1,7 @@
 description = "Simplify code for clarity and maintainability — reduce complexity without changing behavior"
 
 prompt = """
-Invoke the code-simplification skill.
+Invoke the i3-code-simplification skill.
 
 Simplify recently changed code (or the specified scope) while preserving exact behavior:
 
@@ -18,5 +18,5 @@ Simplify recently changed code (or the specified scope) while preserving exact b
 5. Apply each simplification incrementally — run tests after each change
 6. Verify all tests pass, the build succeeds, and the diff is clean
 
-If tests fail after a simplification, revert that change and reconsider. Use `code-review-and-quality` to review the result.
+If tests fail after a simplification, revert that change and reconsider. Use `i3-code-review-and-quality` to review the result.
 """

package/commands/{constraints.toml → i3-constraints.toml}

@@ -1,7 +1,7 @@
 description = "Define and enforce this project's quality bar — interview, sane defaults, CONSTRAINTS.md"
 
 prompt = """
-Invoke the constraint-driven-development skill.
+Invoke the i3-constraint-driven-development skill.
 
 $ARGUMENTS
 
@@ -26,7 +26,7 @@ Default behaviour with no arguments: set up constraints for this repository.
 7. **Verify.** Run the constraints against the current branch. If anything fails that the user disagrees with, fix the constraint now rather than leaving a gate people will learn to ignore.
 
 Sub-commands:
-- `/constraints check` — run the current constraints against this branch and report
-- `/constraints guard` — inspect the diff for a weakened bar: lowered thresholds, skipped or deleted tests, new suppression comments, unfinished stubs, new exceptions
-- `/constraints ratchet` — record today's measured values as the floor that must not fall
+- `/i3-constraints check` — run the current constraints against this branch and report
+- `/i3-constraints guard` — inspect the diff for a weakened bar: lowered thresholds, skipped or deleted tests, new suppression comments, unfinished stubs, new exceptions
+- `/i3-constraints ratchet` — record today's measured values as the floor that must not fall
 """

package/commands/{planning.toml → i3-planning.toml}

@@ -1,7 +1,7 @@
 description = "Break work into small verifiable tasks with acceptance criteria and dependency ordering"
 
 prompt = """
-Invoke the planning-and-task-breakdown skill.
+Invoke the i3-planning-and-task-breakdown skill.
 
 Read the existing spec (SPEC.md or equivalent) and the relevant codebase sections. Then:
 

package/{.gemini/commands/review.toml → commands/i3-review.toml}

@@ -1,15 +1,15 @@
 description = "Conduct a five-axis code review — correctness, readability, architecture, security, performance"
 
 prompt = """
-Invoke the code-review-and-quality skill.
+Invoke the i3-code-review-and-quality skill.
 
 Review the current changes (staged or recent commits) across all five axes:
 
 1. **Correctness** — Does it match the spec? Edge cases handled? Tests adequate?
 2. **Readability** — Clear names? Straightforward logic? Well-organized?
 3. **Architecture** — Follows existing patterns? Clean boundaries? Right abstraction level?
-4. **Security** — Input validated? Secrets safe? Auth checked? (Use security-and-hardening skill)
-5. **Performance** — No N+1 queries? No unbounded ops? (Use performance-optimization skill)
+4. **Security** — Input validated? Secrets safe? Auth checked? (Use i3-security-and-hardening skill)
+5. **Performance** — No N+1 queries? No unbounded ops? (Use i3-performance-optimization skill)
 
 Categorize findings as Critical, Important, or Suggestion.
 Output a structured review with specific file:line references and fix recommendations.

package/commands/{ship.toml → i3-ship.toml}

@@ -1,9 +1,9 @@
 description = "Run the pre-launch checklist via parallel fan-out to specialist personas, then synthesize a go/no-go decision"
 
 prompt = """
-Invoke the shipping-and-launch skill.
+Invoke the i3-shipping-and-launch skill.
 
-`/ship` is a **fan-out orchestrator**. It runs three specialist personas in parallel against the current change, then merges their reports into a single go/no-go decision with a rollback plan. The personas operate independently — no shared state, no ordering — which is what makes parallel execution safe and useful here.
+`/i3-ship` is a **fan-out orchestrator**. It runs three specialist personas in parallel against the current change, then merges their reports into a single go/no-go decision with a rollback plan. The personas operate independently — no shared state, no ordering — which is what makes parallel execution safe and useful here.
 
 ## Phase A — Parallel fan-out
 
@@ -22,7 +22,7 @@ Constraints (from CLI's subagent model):
 - Do not let one persona delegate to another — keep the fan-out flat.
 - For richer multi-agent collaboration where teammates talk to each other instead of just reporting back, see `references/orchestration-patterns.md`.
 
-**Persona resolution.** If you've defined your own `code-reviewer`, `security-auditor`, or `test-engineer` in `agents/` or your global configuration, those take precedence over this plugin's versions — `/ship` picks up your customizations automatically. This is intentional: plugin subagents sit at the bottom of the CLI's scope priority table, so user-level definitions win by design.
+**Persona resolution.** If you've defined your own `code-reviewer`, `security-auditor`, or `test-engineer` in `agents/` or your global configuration, those take precedence over this plugin's versions — `/i3-ship` picks up your customizations automatically. This is intentional: plugin subagents sit at the bottom of the CLI's scope priority table, so user-level definitions win by design.
 
 ## Phase B — Merge in main context
 
@@ -68,5 +68,5 @@ Produce a single output:
 2. Personas do not call each other. The main agent merges in Phase B.
 3. The rollback plan is mandatory before any GO decision.
 4. If any persona returns a Critical finding, the default verdict is NO-GO unless the user explicitly accepts the risk.
-5. **Skip the fan-out only if all of the following are true:** the change touches 2 files or fewer, the diff is under 50 lines, and it does not touch auth, payments, data access, or config/env. Otherwise, default to fan-out. `/ship` is designed for production-bound changes — when the blast radius is non-trivial, run the parallel review even if the diff looks small.
+5. **Skip the fan-out only if all of the following are true:** the change touches 2 files or fewer, the diff is under 50 lines, and it does not touch auth, payments, data access, or config/env. Otherwise, default to fan-out. `/i3-ship` is designed for production-bound changes — when the blast radius is non-trivial, run the parallel review even if the diff looks small.
 """

package/commands/{spec.toml → i3-spec.toml}

@@ -1,7 +1,7 @@
 description = "Start spec-driven development — write a structured specification before writing code"
 
 prompt = """
-Invoke the spec-driven-development skill.
+Invoke the i3-spec-driven-development skill.
 
 Begin by understanding what the user wants to build. Ask clarifying questions about:
 1. The objective and target users

package/{.gemini/commands/test.toml → commands/i3-test.toml}

@@ -1,7 +1,7 @@
 description = "Run TDD workflow — write failing tests, implement, verify. For bugs, use the Prove-It pattern."
 
 prompt = """
-Invoke the test-driven-development skill.
+Invoke the i3-test-driven-development skill.
 
 For new features:
 1. Write tests that describe the expected behavior (they should FAIL)
@@ -15,5 +15,5 @@ For bug fixes (Prove-It pattern):
 4. Confirm the test passes
 5. Run the full test suite for regressions
 
-For browser-related issues, also invoke browser-testing-with-devtools to verify with Chrome DevTools MCP.
+For browser-related issues, also invoke i3-browser-testing-with-devtools to verify with Chrome DevTools MCP.
 """

package/commands/{webperf.toml → i3-webperf.toml}

@@ -1,7 +1,7 @@
 description = "Run a web performance audit via the web-performance-auditor persona"
 
 prompt = """
-/webperf targets web applications specifically. Do not use it for utility libraries, CLIs, or server-only code with no browser-facing output.
+/i3-webperf targets web applications specifically. Do not use it for utility libraries, CLIs, or server-only code with no browser-facing output.
 
 ## Determine the mode