triples-agentic 2.4.0 → 2.4.4

package/README.md

@@ -112,7 +112,7 @@ npx triples-agentic all         # all platforms
 # Global install
 npx triples-agentic claude --global     # → ~/.claude/skills/
 npx triples-agentic cursor --global     # → ~/.cursor/rules/
-npx triples-agentic codex --global      # → ~/.codex/AGENTS.md
+npx triples-agentic codex --global      # → ~/.codex/skills/
 npx triples-agentic windsurf --global   # → ~/.codeium/windsurf/rules/
 
 # Install into a specific directory
@@ -141,7 +141,7 @@ triples-agentic claude       # direct install for Claude Code
 | **Claude Code** | `.claude/skills/*.md` | `.claude/settings.json` (PreToolUse hook) |
 | **Cursor AI** | `.cursor/rules/*.mdc` | `.cursor/rules/triples-safety.mdc` (always-applied rule) |
 | **GitHub Copilot** | `.github/instructions/*.instructions.md` | `.github/instructions/triples-safety.instructions.md` |
-| **OpenAI Codex** | `AGENTS.md` (project) / `~/.codex/AGENTS.md` (global) | `.codex/config.toml` / `~/.codex/config.toml` (PreToolUse hook) |
+| **OpenAI Codex** | `.codex/skills/<skill>/SKILL.md` (project) / `~/.codex/skills/<skill>/SKILL.md` (global) | `.codex/config.toml` / `~/.codex/config.toml` (PreToolUse hook) |
 | **Windsurf** | `.windsurfrules` | `.windsurf/hooks.json` (pre_run_command hook) |
 
 Global install paths:
@@ -150,7 +150,7 @@ Global install paths:
 |---|---|---|
 | Claude Code | `~/.claude/skills/` | `~/.claude/settings.json` |
 | Cursor AI | `~/.cursor/rules/` | `~/.cursor/rules/triples-safety.mdc` |
-| OpenAI Codex | `~/.codex/AGENTS.md` | `~/.codex/config.toml` |
+| OpenAI Codex | `~/.codex/skills/` | `~/.codex/config.toml` |
 | Windsurf | `~/.codeium/windsurf/rules/` | `~/.codeium/windsurf/hooks.json` |
 
 ---
@@ -214,6 +214,15 @@ SeoYeon walks you through the complete workflow and delegates to each agent.
 /seoyeon status  Check current run state
 ```
 
+### In Codex
+Use `/skills` to browse installed TripleS skills, or mention them directly in your prompt:
+
+```text
+Use $seoyeon to orchestrate this feature from PRD through QA.
+Use $jiwoo-prd to draft the PRD for this feature.
+Use $kaede-backend to implement the backend task from the breakdown.
+```
+
 ### With other coding assistants
 Ask for the agent by name — e.g., "Act as JiWoo and create a PRD for [description]"
 
@@ -280,7 +289,9 @@ triples-agentic/
 │   │   ├── task-breakdown.md  # → workspace/TASK_BREAKDOWN.md
 │   │   └── test-case.md       # → workspace/TEST_CASES.md
 │   └── bin/
-│       └── setup.js           # Platform installer CLI
+│       ├── setup.js           # Platform installer CLI entrypoint
+│       └── setup/
+│           └── codex.js       # Codex-specific installer
 ├── docs/
 │   └── workflow.md            # Full workflow diagram + agent roster
 └── CHANGELOG.md
@@ -292,9 +303,9 @@ your-project/
 │   └── settings.json          # Claude Code PreToolUse safety hook
 ├── .cursor/rules/             # Cursor AI agent rules + safety rule
 ├── .github/instructions/      # Copilot agent instructions + safety instruction
+├── .codex/skills/             # Codex skill bundles (project install)
 ├── .codex/config.toml         # Codex PreToolUse safety hook
 ├── .windsurf/hooks.json       # Windsurf pre_run_command safety hook
-├── AGENTS.md                  # Codex agent context
 └── .windsurfrules             # Windsurf agent rules
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triples-agentic",
-  "version": "2.4.0",
+  "version": "2.4.4",
   "description": "TripleS software engineering agent orchestrator — skill plugin for Claude Code, Cursor, Copilot, Codex, and Windsurf",
   "type": "module",
   "bin": {

package/src/bin/setup/codex.js

@@ -0,0 +1,230 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+const CODEX_AGENT_SKILL_METADATA = {
+  seoyeon: {
+    description: 'Coordinate the full TripleS delivery pipeline across PRD, RFC, task breakdown, development, test cases, and QA. Use when the user wants end-to-end orchestration, status, routing, or delivery summaries.',
+    shortDescription: 'Orchestrate the full TripleS delivery flow',
+    defaultPrompt: 'Use $seoyeon to orchestrate this feature from PRD through QA.',
+  },
+  'jiwoo-prd': {
+    description: 'Create, review, and refine implementation-ready product requirements documents for TripleS workflows. Use when the user needs a PRD with explicit quality gates and product clarifications.',
+    shortDescription: 'Create and review implementation-ready PRDs',
+    defaultPrompt: 'Use $jiwoo-prd to draft or revise the PRD for this feature.',
+  },
+  'yooyeon-rfc': {
+    description: 'Create, review, and refine implementation-ready technical RFCs that trace back to an approved PRD. Use when the user needs architecture decisions, API contracts, risks, or rollout plans documented.',
+    shortDescription: 'Create and review implementation-ready RFCs',
+    defaultPrompt: 'Use $yooyeon-rfc to turn this PRD into a technical RFC.',
+  },
+  'nakyoung-tasks': {
+    description: 'Break approved PRDs and RFCs into estimated, dependency-aware engineering tasks. Use when the user needs a delivery plan, story points, task sequencing, or platform assignments.',
+    shortDescription: 'Break work into ready-to-build tasks',
+    defaultPrompt: 'Use $nakyoung-tasks to create the task breakdown for this project.',
+  },
+  'yubin-frontend': {
+    description: 'Implement frontend web tasks from the approved TripleS task breakdown with strong accessibility, performance, and testing practices. Use when the user needs web UI implementation work.',
+    shortDescription: 'Implement web frontend tasks from breakdown',
+    defaultPrompt: 'Use $yubin-frontend to implement the assigned web frontend task.',
+  },
+  'kaede-backend': {
+    description: 'Implement backend APIs, services, and data access layers from the approved TripleS task breakdown. Use when the user needs backend implementation with strong reliability, security, and testing practices.',
+    shortDescription: 'Implement backend APIs and services',
+    defaultPrompt: 'Use $kaede-backend to implement the assigned backend task.',
+  },
+  'yeonji-android': {
+    description: 'Implement Android tasks in Kotlin and Jetpack Compose from the approved TripleS task breakdown. Use when the user needs Android-native feature work.',
+    shortDescription: 'Implement Android features in Kotlin',
+    defaultPrompt: 'Use $yeonji-android to implement the assigned Android task.',
+  },
+  'sohyun-ios': {
+    description: 'Implement iOS tasks in Swift and SwiftUI from the approved TripleS task breakdown. Use when the user needs iOS-native feature work with Apple platform conventions.',
+    shortDescription: 'Implement iOS features in SwiftUI',
+    defaultPrompt: 'Use $sohyun-ios to implement the assigned iOS task.',
+  },
+  'kotone-flutter': {
+    description: 'Implement Flutter tasks in Dart with Riverpod from the approved TripleS task breakdown. Use when the user needs cross-platform mobile feature work.',
+    shortDescription: 'Implement Flutter features with Riverpod',
+    defaultPrompt: 'Use $kotone-flutter to implement the assigned Flutter task.',
+  },
+  'lynn-testcase': {
+    description: 'Create, review, and refine implementation-ready QA test suites from approved PRDs and RFCs. Use when the user needs structured test cases, coverage gaps, or automation candidates documented.',
+    shortDescription: 'Create and review QA test suites',
+    defaultPrompt: 'Use $lynn-testcase to create the test case suite for this project.',
+  },
+  'shion-qa': {
+    description: 'Execute approved test suites, file defects, and produce a go/no-go QA recommendation. Use when the user needs test execution, bug reports, or release-readiness assessment.',
+    shortDescription: 'Execute tests and issue go/no-go QA reports',
+    defaultPrompt: 'Use $shion-qa to execute QA and produce a release recommendation.',
+  },
+};
+
+function codexSkillMetadata(agent) {
+  return CODEX_AGENT_SKILL_METADATA[agent.slug] || {
+    description: `Use when the user wants help from the TripleS ${agent.displayName} workflow.`,
+    shortDescription: `Use the ${agent.displayName} TripleS workflow`,
+    defaultPrompt: `Use $${agent.slug} for this TripleS workflow.`,
+  };
+}
+
+function codexSkillFileContent(agent, helpers) {
+  const { stripAgentMetadataComments, yamlEscape } = helpers;
+  const meta = codexSkillMetadata(agent);
+  const references = [];
+
+  if (agent.knowledgePaths.length) {
+    references.push('- Bundled knowledge references live under `references/knowledge/`.');
+  }
+
+  if (agent.templatePaths.length) {
+    references.push('- Bundled templates live under `references/templates/`.');
+  }
+
+  if (references.length) {
+    references.push('- When the original TripleS instructions mention `knowledge/...` or `templates/...`, resolve them to those bundled copies inside this skill directory.');
+  }
+
+  const preface = references.length
+    ? ['## Bundled References', '', ...references, ''].join('\n')
+    : '';
+
+  return [
+    '---',
+    `name: "${yamlEscape(agent.slug)}"`,
+    `description: "${yamlEscape(meta.description)}"`,
+    '---',
+    '',
+    `# ${agent.displayName}`,
+    '',
+    preface,
+    stripAgentMetadataComments(agent.content),
+    '',
+  ].join('\n');
+}
+
+function codexSkillUiYaml(agent, helpers) {
+  const { yamlEscape } = helpers;
+  const meta = codexSkillMetadata(agent);
+  return [
+    'interface:',
+    `  display_name: "${yamlEscape(agent.displayName)}"`,
+    `  short_description: "${yamlEscape(meta.shortDescription)}"`,
+    `  default_prompt: "${yamlEscape(meta.defaultPrompt)}"`,
+    '',
+    'policy:',
+    '  allow_implicit_invocation: true',
+    '',
+  ].join('\n');
+}
+
+function writeCodexSkillBundle(skillsRoot, agent, ctx) {
+  const { ROOT, KNOWLEDGE_DIR, writeFile } = ctx;
+  const skillDir = join(skillsRoot, agent.slug);
+  writeFile(join(skillDir, 'SKILL.md'), codexSkillFileContent(agent, ctx));
+  writeFile(join(skillDir, 'agents', 'openai.yaml'), codexSkillUiYaml(agent, ctx));
+
+  for (const relPath of agent.knowledgePaths) {
+    const sourcePath = join(KNOWLEDGE_DIR, relPath);
+    if (existsSync(sourcePath)) {
+      writeFile(join(skillDir, 'references', 'knowledge', relPath), readFileSync(sourcePath, 'utf-8'));
+    }
+  }
+
+  for (const relPath of agent.templatePaths) {
+    const sourcePath = join(ROOT, 'templates', relPath);
+    if (existsSync(sourcePath)) {
+      writeFile(join(skillDir, 'references', 'templates', relPath), readFileSync(sourcePath, 'utf-8'));
+    }
+  }
+}
+
+function maybeRewriteLegacyCodexAgentsDoc(targetPath, skillsRoot, ctx) {
+  const { display, writeFile } = ctx;
+  if (!existsSync(targetPath)) return;
+
+  let existing = '';
+  try { existing = readFileSync(targetPath, 'utf-8'); } catch { return; }
+  if (!existing.includes('TripleS Agent Orchestrator')) return;
+
+  const compatDoc = [
+    '# TripleS Agentic for Codex',
+    '',
+    'TripleS workflows are installed as Codex skills, not as a generated agent catalog in this file.',
+    '',
+    `- Skills root: \`${display(skillsRoot)}\``,
+    '- In Codex, use `/skills` to browse them or mention a skill directly such as `$seoyeon` or `$jiwoo-prd`.',
+    '- The actual workflow instructions now live in each skill bundle under `SKILL.md`.',
+    '',
+  ].join('\n');
+
+  writeFile(targetPath, compatDoc);
+}
+
+function installCodexSettings(base, ctx) {
+  const { GLOBAL_PATHS, isGlobal, projectDir, loadCodexHooks, tomlEscape, writeFile } = ctx;
+  const hookEntries = loadCodexHooks().filter(entry => entry.event === 'PreToolUse');
+  if (hookEntries.length === 0) return;
+
+  const configPath = isGlobal && !base
+    ? join(GLOBAL_PATHS.codex, 'config.toml')
+    : join(base || projectDir, '.codex', 'config.toml');
+  let existing = existsSync(configPath) ? readFileSync(configPath, 'utf-8') : '';
+
+  existing = existing.replace(/\n?# triples-agentic hooks[\s\S]*?# end triples-agentic hooks\n?/g, '');
+
+  let block = '\n# triples-agentic hooks\n';
+  for (const entry of hookEntries) {
+    block += '\n[[hooks.PreToolUse]]\n';
+    if (entry.matcher) block += `matcher = "${tomlEscape(entry.matcher)}"\n`;
+    for (const hook of (entry.hooks || [])) {
+      block += '\n[[hooks.PreToolUse.hooks]]\n';
+      block += 'type = "command"\n';
+      block += `command = "${tomlEscape(hook.command)}"\n`;
+      if (hook.statusMessage) block += `statusMessage = "${tomlEscape(hook.statusMessage)}"\n`;
+    }
+  }
+  block += '\n# end triples-agentic hooks\n';
+
+  writeFile(configPath, existing.trimEnd() + block);
+}
+
+export function installCodex(base, ctx) {
+  const { GLOBAL_PATHS, isGlobal, projectDir, allAgents, display } = ctx;
+  const codexRoot = isGlobal && !base
+    ? GLOBAL_PATHS.codex
+    : join(base || projectDir, '.codex');
+  const skillsRoot = join(codexRoot, 'skills');
+  console.log(`\nInstalling OpenAI Codex skills → ${display(skillsRoot)}`);
+
+  for (const agent of allAgents()) {
+    writeCodexSkillBundle(skillsRoot, agent, ctx);
+  }
+
+  const legacyAgentsPath = isGlobal && !base
+    ? join(GLOBAL_PATHS.codex, 'AGENTS.md')
+    : join(base || projectDir, 'AGENTS.md');
+  maybeRewriteLegacyCodexAgentsDoc(legacyAgentsPath, skillsRoot, ctx);
+  installCodexSettings(base, ctx);
+}
+
+export function detectCodexInstallations(ctx) {
+  const { GLOBAL_PATHS, projectDir } = ctx;
+  const hasMarker = (file) => {
+    try { return readFileSync(file, 'utf-8').includes('TripleS Agent Orchestrator'); } catch { return false; }
+  };
+
+  const found = [];
+  const codexGlobal = join(GLOBAL_PATHS.codex, 'AGENTS.md');
+  const codexGlobalSkills = join(GLOBAL_PATHS.codex, 'skills', 'seoyeon', 'SKILL.md');
+  if (existsSync(codexGlobalSkills) || (existsSync(codexGlobal) && hasMarker(codexGlobal))) {
+    found.push({ platform: 'codex', isGlobal: true });
+  }
+
+  const codexProject = join(projectDir, 'AGENTS.md');
+  const codexProjectSkills = join(projectDir, '.codex', 'skills', 'seoyeon', 'SKILL.md');
+  if (existsSync(codexProjectSkills) || (existsSync(codexProject) && hasMarker(codexProject))) {
+    found.push({ platform: 'codex', isGlobal: false });
+  }
+
+  return found;
+}

package/src/bin/setup.js

@@ -2,7 +2,7 @@
 /**
  * TripleS Agentic — Skill Plugin Setup
  *
- * Installs all TripleS skill files (11 agents + 40 knowledge skills)
+ * Installs all TripleS skill files (11 agents + 41 knowledge references)
  * into your coding assistant's config directory.
  *
  * Usage:
@@ -89,16 +89,51 @@ function parseComment(content, key) {
   return m ? m[1].trim() : '';
 }
 
+function parseCommentList(content, key) {
+  const raw = parseComment(content, key);
+  if (!raw) return [];
+  return raw.split(',').map(item => item.trim()).filter(Boolean);
+}
+
+function parseHeading(content) {
+  const m = content.match(/^#\s+(.+)$/m);
+  return m ? m[1].trim() : '';
+}
+
+function stripAgentMetadataComments(content) {
+  return content.replace(/^<!-- .*? -->\r?\n/gm, '').trimStart();
+}
+
+function yamlEscape(value) {
+  return String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+function shortHeading(heading, fallback) {
+  if (!heading) return fallback;
+  return heading.split('—')[0].trim();
+}
+
 // ─── Source collectors ────────────────────────────────────────────────────────
 
 function allAgents() {
   return readdirSync(AGENTS_DIR)
-    .filter(f => f.endsWith('.md'))
+    .filter(f => f.endsWith('.md') && f !== 'README.md')
     .map(f => {
       const name    = f.replace('.md', '');
       const content = readFileSync(join(AGENTS_DIR, f), 'utf-8');
+      const slug = parseComment(content, 'triples-agent') || name;
       const persona = parseComment(content, 'persona') || 'software engineering agent';
-      return { name, content, persona };
+      const heading = parseHeading(content);
+      return {
+        name,
+        slug,
+        content,
+        persona,
+        heading,
+        displayName: shortHeading(heading, name),
+        knowledgePaths: parseCommentList(content, 'knowledge'),
+        templatePaths: parseCommentList(content, 'templates'),
+      };
     })
     .sort((a, b) => a.name.localeCompare(b.name));
 }
@@ -187,6 +222,30 @@ function tomlEscape(str) {
   return str.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
 }
 
+function createInstallerContext() {
+  return {
+    ROOT,
+    HOME,
+    AGENTS_DIR,
+    KNOWLEDGE_DIR,
+    KNOWLEDGE_GROUPS,
+    GLOBAL_PATHS,
+    projectDir,
+    isGlobal,
+    allAgents,
+    loadCodexHooks,
+    stripAgentMetadataComments,
+    yamlEscape,
+    tomlEscape,
+    display,
+    writeFile,
+  };
+}
+
+async function loadCodexInstaller() {
+  return import('./setup/codex.js');
+}
+
 // ─── Platform installers ──────────────────────────────────────────────────────
 
 /** Write (or merge) PreToolUse hooks from platforms.claude into .claude/settings.json */
@@ -215,35 +274,6 @@ function installClaudeSettings(claudeDir) {
   writeFile(settingsPath, JSON.stringify(settings, null, 2));
 }
 
-/** Write (or append) PreToolUse hooks from platforms.codex into .codex/config.toml */
-function installCodexSettings(base) {
-  const hookEntries = loadCodexHooks().filter(e => e.event === 'PreToolUse');
-  if (hookEntries.length === 0) return;
-
-  const configPath = isGlobal && !base
-    ? join(GLOBAL_PATHS.codex, 'config.toml')
-    : join(base || projectDir, '.codex', 'config.toml');
-  let existing = existsSync(configPath) ? readFileSync(configPath, 'utf-8') : '';
-
-  // Remove previous triples-agentic block (idempotent reinstall)
-  existing = existing.replace(/\n?# triples-agentic hooks[\s\S]*?# end triples-agentic hooks\n?/g, '');
-
-  let block = '\n# triples-agentic hooks\n';
-  for (const entry of hookEntries) {
-    block += `\n[[hooks.PreToolUse]]\n`;
-    if (entry.matcher) block += `matcher = "${tomlEscape(entry.matcher)}"\n`;
-    for (const hook of (entry.hooks || [])) {
-      block += `\n[[hooks.PreToolUse.hooks]]\n`;
-      block += `type = "command"\n`;
-      block += `command = "${tomlEscape(hook.command)}"\n`;
-      if (hook.statusMessage) block += `statusMessage = "${tomlEscape(hook.statusMessage)}"\n`;
-    }
-  }
-  block += '\n# end triples-agentic hooks\n';
-
-  writeFile(configPath, existing.trimEnd() + block);
-}
-
 /** Write (or merge) Windsurf hooks from platforms.windsurf into .windsurf/hooks.json */
 function installWindsurfSettings(base) {
   const byEvent = loadWindsurfHooks();
@@ -335,32 +365,9 @@ function installCopilot(base) {
   }
 }
 
-function installCodex(base) {
-  const dest = isGlobal && !base
-    ? join(GLOBAL_PATHS.codex, 'AGENTS.md')
-    : join(base || projectDir, 'AGENTS.md');
-  console.log(`\nInstalling OpenAI Codex → ${display(dest)}`);
-
-  const safetyBody = loadSafetyRulesBody();
-  const lines = ['# TripleS Agent Orchestrator\n\n', ...(safetyBody ? [safetyBody + '\n\n'] : []), '## Agents\n\n'];
-  for (const { name, content } of allAgents()) {
-    lines.push(`---\n\n${content}\n\n`);
-  }
-
-  lines.push('## Knowledge Skills\n\n');
-  for (const group of KNOWLEDGE_GROUPS) {
-    lines.push(`### ${group.charAt(0).toUpperCase() + group.slice(1)}\n\n`);
-    for (const { name, content } of allKnowledgeSkills().filter(s => s.group === group)) {
-      const body = stripFrontmatter(content);
-      lines.push(`#### ${name}\n\n${body}\n\n`);
-    }
-  }
-
-  writeFileSync(dest, lines.join(''), 'utf-8');
-  console.log(`  ✓ ${display(dest)}`);
-
-  // Hooks — enforced at harness level via .codex/config.toml
-  installCodexSettings(base);
+async function installCodex(base) {
+  const { installCodex: runCodexInstall } = await loadCodexInstaller();
+  runCodexInstall(base, createInstallerContext());
 }
 
 function installWindsurf(base) {
@@ -443,7 +450,7 @@ const KNOWLEDGE_SUMMARY = {
  * Detect existing TripleS installations by checking sentinel files.
  * Returns an array of { platform, isGlobal } objects.
  */
-function detectInstallations() {
+async function detectInstallations() {
   const found = [];
 
   const hasFile = (...parts) => existsSync(join(...parts));
@@ -468,12 +475,8 @@ function detectInstallations() {
     found.push({ platform: 'copilot', isGlobal: false });
 
   // Codex
-  const codexGlobal = join(GLOBAL_PATHS.codex, 'AGENTS.md');
-  if (hasFile(codexGlobal) && hasMarker(codexGlobal))
-    found.push({ platform: 'codex', isGlobal: true });
-  const codexProject = join(projectDir, 'AGENTS.md');
-  if (hasFile(codexProject) && hasMarker(codexProject))
-    found.push({ platform: 'codex', isGlobal: false });
+  const { detectCodexInstallations } = await loadCodexInstaller();
+  found.push(...detectCodexInstallations(createInstallerContext()));
 
   // Windsurf
   const windsurfGlobal = join(GLOBAL_PATHS.windsurf, '.windsurfrules');
@@ -487,7 +490,7 @@ function detectInstallations() {
 }
 
 async function runUpdate() {
-  const installations = detectInstallations();
+  const installations = await detectInstallations();
 
   if (installations.length === 0) {
     console.log('\n⚠  No existing TripleS Agentic installations detected.\n');
@@ -509,32 +512,33 @@ async function runUpdate() {
   const savedIsGlobal = isGlobal;
   for (const { platform, isGlobal: g } of installations) {
     isGlobal = g;
-    INSTALLERS[platform](g ? null : projectDir);
+    await INSTALLERS[platform](g ? null : projectDir);
   }
   isGlobal = savedIsGlobal;
 
   const totalKnowledge = Object.values(KNOWLEDGE_SUMMARY).reduce((n, g) => n + g.length, 0);
-  console.log(`\n✅  Updated ${installations.length} installation(s) — ${AGENT_COMMANDS.length} agents, ${totalKnowledge} knowledge skills\n`);
+  console.log(`\n✅  Updated ${installations.length} installation(s) — ${AGENT_COMMANDS.length} agents, ${totalKnowledge} knowledge references\n`);
 }
 
 // ─── Success banner ───────────────────────────────────────────────────────────
 
 function printSuccessBanner() {
   const totalKnowledge = Object.values(KNOWLEDGE_SUMMARY).reduce((n, g) => n + g.length, 0);
+  const knowledgeGroups = Object.keys(KNOWLEDGE_SUMMARY).length;
   console.log('\n✅  TripleS Agentic installed successfully!\n');
 
-  console.log('── Agents (invoke as slash commands) ──────────────────────────');
+  console.log('── Agents / Skills ───────────────────────────────────────────');
   for (const [cmd, desc] of AGENT_COMMANDS) {
-    console.log(`  /${cmd.padEnd(18)} ${desc}`);
+    console.log(`  ${cmd.padEnd(18)} ${desc}`);
   }
 
-  console.log(`\n── Knowledge Skills (${totalKnowledge} skills across 4 groups) ──────────────────`);
+  console.log(`\n── Knowledge Library (${totalKnowledge} bundled references across ${knowledgeGroups} groups) ───────`);
   for (const [group, skills] of Object.entries(KNOWLEDGE_SUMMARY)) {
     const label = group.includes('/') ? group : group; // full path for sub-groups
     console.log(`  ${label.padEnd(16)} ${skills.map(s => `/${s}`).join('  ')}`);
   }
 
-  console.log('\nStart the full pipeline with /seoyeon');
+  console.log('\nUse `/seoyeon` in Claude Code, or `/skills` / `$seoyeon` in Codex.');
   console.log('To update later run: npx triples-agentic update\n');
 }
 
@@ -592,7 +596,7 @@ async function runWizard() {
 
     console.log('');
     for (const p of selectedPlatforms) {
-      INSTALLERS[p](useGlobal && GLOBAL_PATHS[p] ? null : projectDir);
+      await INSTALLERS[p](useGlobal && GLOBAL_PATHS[p] ? null : projectDir);
     }
 
     printSuccessBanner();
@@ -618,7 +622,7 @@ async function main() {
 
   if (platformArg === 'all') {
     for (const installer of Object.values(INSTALLERS)) {
-      installer(isGlobal ? null : projectDir);
+      await installer(isGlobal ? null : projectDir);
     }
     printSuccessBanner();
     return;
@@ -630,7 +634,7 @@ async function main() {
     process.exit(1);
   }
 
-  INSTALLERS[platformArg](isGlobal ? null : projectDir);
+  await INSTALLERS[platformArg](isGlobal ? null : projectDir);
   printSuccessBanner();
 }