goalbuddy 0.2.21 → 0.3.0

package/internal/cli/goal-maker.mjs

@@ -25,23 +25,33 @@ const canonicalSkillDirectory = "goalbuddy";
 const legacyCliName = "goal-maker";
 const legacySkillName = "goal-maker";
 const skillSource = join(packageRoot, canonicalSkillDirectory);
+const claudePluginSource = join(packageRoot, "plugins", "goalbuddy");
 const packageInfo = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8"));
 const defaultCodexHome = process.env.CODEX_HOME || join(homedir(), ".codex");
+const defaultClaudeHome = process.env.CLAUDE_HOME || join(homedir(), ".claude");
 const defaultCatalogUrl = "https://raw.githubusercontent.com/tolibear/goalbuddy/main/extend/catalog.json";
 const requiredAgentFiles = [
   "goal_judge.toml",
   "goal_scout.toml",
   "goal_worker.toml",
 ];
+const requiredClaudeAgentFiles = [
+  "goal-scout.md",
+  "goal-judge.md",
+  "goal-worker.md",
+];
+const bundledCoreExtensionIds = new Set(["github-projects", "local-goal-board"]);
 const optionsWithValues = new Set([
   "--catalog",
   "--catalog-url",
+  "--claude-home",
   "--codex-home",
   "--goal",
   "--host",
   "--kind",
   "--port",
   "--source",
+  "--target",
 ]);
 
 const args = process.argv.slice(2);
@@ -61,17 +71,37 @@ async function main() {
   maybePrintLegacyNotice();
   switch (command) {
     case "default":
-      installPlugin();
+      if (installTargetMode() === "all") {
+        await installEverywhere();
+      } else if (installTargetMode() === "codex") {
+        installPlugin();
+      } else {
+        await installClaudeAll();
+      }
       break;
     case "install":
     case "update":
-      await installAll();
+      if (installTargetMode() === "all") {
+        await installEverywhere();
+      } else if (installTargetMode() === "codex") {
+        await installAll();
+      } else {
+        await installClaudeAll();
+      }
       break;
     case "agents":
-      installAgents();
+      if (targetMode() === "codex") {
+        installAgents();
+      } else {
+        installClaudeAgents();
+      }
       break;
     case "doctor":
-      doctor();
+      if (targetMode() === "codex") {
+        doctor();
+      } else {
+        doctorClaude();
+      }
       break;
     case "check-update":
     case "update-check":
@@ -145,15 +175,15 @@ function positionalArgs() {
 }
 
 function usage() {
-  console.log(`Codex ${canonicalProductName}
+  console.log(`${canonicalProductName} for Claude Code and Codex
 
 Usage:
-  ${canonicalCliName} [--codex-home <path>] [--json]
+  ${canonicalCliName} [--target claude|codex] [--claude-home <path>] [--codex-home <path>] [--json]
   ${canonicalCliName} plugin install [--source <marketplace-source>] [--codex-home <path>] [--json]
-  ${canonicalCliName} install [--codex-home <path>] [--force] [--json]
-  ${canonicalCliName} update [--codex-home <path>] [--json]
-  ${canonicalCliName} agents [--codex-home <path>] [--force]
-  ${canonicalCliName} doctor [--codex-home <path>] [--goal-ready]
+  ${canonicalCliName} install [--target claude|codex] [--claude-home <path>] [--codex-home <path>] [--force] [--json]
+  ${canonicalCliName} update [--target claude|codex] [--claude-home <path>] [--codex-home <path>] [--json]
+  ${canonicalCliName} agents [--target claude|codex] [--claude-home <path>] [--codex-home <path>] [--force]
+  ${canonicalCliName} doctor [--target claude|codex] [--claude-home <path>] [--codex-home <path>] [--goal-ready]
   ${canonicalCliName} check-update [--json]
   ${canonicalCliName} extend [--catalog-url <url-or-path>] [--kind <kind>] [--json]
   ${canonicalCliName} extend <id> [--catalog-url <url-or-path>] [--json]
@@ -162,17 +192,19 @@ Usage:
   ${canonicalCliName} extend doctor [<id>] [--codex-home <path>] [--json]
   ${canonicalCliName} board <docs/goals/slug> [--catalog-url <url-or-path>] [--host <host>] [--port <port>] [--once] [--json]
 
-Default:
-  ${canonicalCliName}  Installs and enables the native Codex plugin.
+Targets: by default, install/update prepares both Codex (~/.codex) and Claude Code (~/.claude). Use --target codex or --target claude to limit the command.
 
-Skill-only fallback:
-  ${canonicalCliName} install  Installs the legacy skill payload and bundled agent definitions.
+Default:
+  ${canonicalCliName}                  Installs and enables Codex, then installs Claude Code skill + agents + /goal-prep command.
+  ${canonicalCliName} --target claude  Installs ${canonicalProductName} for Claude Code (skill + agents + /goal-prep command).
+  ${canonicalCliName} --target codex   Installs and enables the native Codex plugin.
 
 Compatibility:
   ${legacyCliName} remains a temporary alias and prints the new npx command for human-facing use.
 
 Environment:
   CODEX_HOME                         Overrides the default ~/.codex target.
+  CLAUDE_HOME                        Overrides the default ~/.claude target (and selects Claude Code unless --target codex is set).
   GOALBUDDY_EXTEND_CATALOG_URL       Overrides the default GitHub-hosted extension catalog.
   GOAL_MAKER_EXTEND_CATALOG_URL      Legacy fallback for the extension catalog.
 `);
@@ -182,6 +214,272 @@ function codexHome() {
   return resolve(optionValue("--codex-home") || defaultCodexHome);
 }
 
+function claudeHome() {
+  return resolve(optionValue("--claude-home") || defaultClaudeHome);
+}
+
+function targetMode() {
+  const value = (optionValue("--target") || "").toLowerCase();
+  if (value === "codex" || value === "claude") return value;
+  // Explicit --claude-home or CLAUDE_HOME implies Claude target unless --target codex is set.
+  if (optionValue("--claude-home") || process.env.CLAUDE_HOME) return "claude";
+  return "codex";
+}
+
+function installTargetMode() {
+  const value = (optionValue("--target") || "").toLowerCase();
+  if (value === "codex" || value === "claude") return value;
+
+  const hasCodexHomeOption = Boolean(optionValue("--codex-home"));
+  const hasClaudeHomeOption = Boolean(optionValue("--claude-home"));
+  if (hasCodexHomeOption && !hasClaudeHomeOption) return "codex";
+  if (hasClaudeHomeOption && !hasCodexHomeOption) return "claude";
+  if (process.env.CLAUDE_HOME && !hasCodexHomeOption) return "claude";
+  return "all";
+}
+
+function claudeSkillRoot() {
+  return join(claudeHome(), "skills", canonicalSkillDirectory);
+}
+
+function claudeAgentsRoot() {
+  return join(claudeHome(), "agents");
+}
+
+function claudeCommandsRoot() {
+  return join(claudeHome(), "commands");
+}
+
+function installClaudeSkill({ quiet = false } = {}) {
+  const target = claudeSkillRoot();
+  if (!existsSync(skillSource)) {
+    console.error(`Skill payload not found: ${skillSource}`);
+    process.exit(1);
+  }
+
+  const previousMetadata = readInstallMetadata(target);
+  const previousFingerprint = existsSync(target) ? directoryFingerprint(target, { exclude: installFingerprintExcludes() }) : "";
+  const preservedExtensions = preserveInstalledExtensions([target], { tempRoot: claudeHome() });
+  const extensionTempPath = preservedExtensions.tempPath;
+  const preservedExtensionIds = preservedExtensions.ids;
+
+  mkdirSync(dirname(target), { recursive: true });
+  rmSync(target, { recursive: true, force: true });
+  cpSync(skillSource, target, { recursive: true });
+  restoreInstalledExtensions(target, extensionTempPath);
+  writeInstallMetadata(target, previousMetadata);
+  cleanupPreservedExtensions([extensionTempPath]);
+
+  const currentFingerprint = directoryFingerprint(target, { exclude: installFingerprintExcludes() });
+  const status = previousFingerprint
+    ? previousFingerprint === currentFingerprint ? "unchanged" : "updated"
+    : "installed";
+  if (!quiet) console.log(`Installed Claude Code ${canonicalProductName} skill to ${target}`);
+
+  return {
+    status,
+    path: target,
+    previous_version: previousMetadata?.package_version || "",
+    current_version: packageInfo.version,
+    preserved_extensions: preservedExtensionIds,
+  };
+}
+
+function installClaudeAgents({ quiet = false } = {}) {
+  const source = join(claudePluginSource, "agents");
+  const target = claudeAgentsRoot();
+  const force = hasFlag("--force") || command === "update" || command === "install" || command === "default";
+  mkdirSync(target, { recursive: true });
+
+  const results = [];
+  if (!existsSync(source)) return results;
+  for (const file of readdirSync(source)) {
+    if (!file.endsWith(".md")) continue;
+    const dest = join(target, file);
+    const sourceHash = sha256(readFileSync(join(source, file)));
+    const previousHash = existsSync(dest) ? sha256(readFileSync(dest)) : "";
+    if (existsSync(dest) && !force) {
+      if (!quiet) console.log(`skip existing ${dest} (use --force to overwrite)`);
+      results.push({ file, status: "skipped", path: dest });
+      continue;
+    }
+    cpSync(join(source, file), dest);
+    const status = previousHash ? previousHash === sourceHash ? "unchanged" : "updated" : "installed";
+    if (!quiet) console.log(`installed ${dest}`);
+    results.push({ file, status, path: dest });
+  }
+  return results;
+}
+
+function installClaudeCommands({ quiet = false } = {}) {
+  const source = join(claudePluginSource, "commands");
+  const target = claudeCommandsRoot();
+  const force = hasFlag("--force") || command === "update" || command === "install" || command === "default";
+  mkdirSync(target, { recursive: true });
+
+  const results = [];
+  if (!existsSync(source)) return results;
+  for (const file of readdirSync(source)) {
+    if (!file.endsWith(".md")) continue;
+    const dest = join(target, file);
+    if (existsSync(dest) && !force) {
+      if (!quiet) console.log(`skip existing ${dest} (use --force to overwrite)`);
+      results.push({ file, status: "skipped", path: dest });
+      continue;
+    }
+    const sourceHash = sha256(readFileSync(join(source, file)));
+    const previousHash = existsSync(dest) ? sha256(readFileSync(dest)) : "";
+    cpSync(join(source, file), dest);
+    const status = previousHash ? previousHash === sourceHash ? "unchanged" : "updated" : "installed";
+    if (!quiet) console.log(`installed ${dest}`);
+    results.push({ file, status, path: dest });
+  }
+  return results;
+}
+
+async function buildClaudeInstallReport() {
+  const quiet = true;
+  const report = {
+    command,
+    target: "claude",
+    package: {
+      name: packageInfo.name,
+      current_version: packageInfo.version,
+    },
+    claude_home: claudeHome(),
+    skill: installClaudeSkill({ quiet }),
+    agents: installClaudeAgents({ quiet }),
+    commands: installClaudeCommands({ quiet }),
+    extensions: await extensionDiscoverySummary(),
+    warnings: [],
+  };
+
+  report.package.previous_version = report.skill.previous_version;
+  return report;
+}
+
+async function installClaudeAll() {
+  const report = await buildClaudeInstallReport();
+
+  if (hasFlag("--json")) {
+    printJson(report);
+  } else {
+    printClaudeInstallReport(report);
+  }
+}
+
+async function installEverywhere() {
+  const report = {
+    command,
+    package: {
+      name: packageInfo.name,
+      current_version: packageInfo.version,
+    },
+    codex: null,
+    claude: null,
+    errors: [],
+  };
+
+  try {
+    report.codex = installPlugin({ quiet: true });
+  } catch (error) {
+    report.errors.push({ target: "codex", error: error.message });
+    report.codex = { target: "codex", ok: false, error: error.message };
+  }
+
+  try {
+    report.claude = await buildClaudeInstallReport();
+  } catch (error) {
+    report.errors.push({ target: "claude", error: error.message });
+    report.claude = { target: "claude", ok: false, error: error.message };
+  }
+
+  report.ok = report.errors.length === 0;
+
+  if (hasFlag("--json")) {
+    printJson(report);
+  } else {
+    printEverywhereInstallReport(report);
+  }
+
+  if (!report.ok) process.exit(1);
+}
+
+function doctorClaude() {
+  const skillPath = join(claudeSkillRoot(), "SKILL.md");
+  const agentsPath = claudeAgentsRoot();
+  const commandsPath = claudeCommandsRoot();
+  const installed = existsSync(skillPath);
+  const agents = existsSync(agentsPath)
+    ? readdirSync(agentsPath).filter((file) => file.startsWith("goal-") && file.endsWith(".md"))
+    : [];
+  const missingAgents = requiredClaudeAgentFiles.filter((file) => !agents.includes(file));
+  const staleAgents = requiredClaudeAgentFiles.filter((file) => {
+    const installedAgent = join(agentsPath, file);
+    const bundledAgent = join(claudePluginSource, "agents", file);
+    if (!existsSync(installedAgent) || !existsSync(bundledAgent)) return false;
+    return sha256(readFileSync(installedAgent)) !== sha256(readFileSync(bundledAgent));
+  });
+  const commands = existsSync(commandsPath)
+    ? readdirSync(commandsPath).filter((file) => file === "goal-prep.md")
+    : [];
+
+  console.log(JSON.stringify({
+    target: "claude",
+    claude_home: claudeHome(),
+    skill_installed: installed,
+    skill_path: skillPath,
+    installed_agents: agents,
+    missing_agents: missingAgents,
+    stale_agents: staleAgents,
+    installed_commands: commands,
+  }, null, 2));
+
+  const installOk = installed && missingAgents.length === 0 && staleAgents.length === 0;
+  process.exit(installOk ? 0 : 1);
+}
+
+function printClaudeInstallReport(report) {
+  const verb = report.command === "update" ? "Updated" : "Installed";
+  const previous = report.package.previous_version && report.package.previous_version !== report.package.current_version
+    ? ` ${report.package.previous_version} -> ${report.package.current_version}`
+    : ` ${report.package.current_version}`;
+  console.log("");
+  console.log(`${verb} ${canonicalProductName} for Claude Code${previous}`);
+  console.log("");
+  console.log(`Skill: ${report.skill.status} at ${report.skill.path}`);
+  console.log(`Agents: ${summarizeStatuses(report.agents)}`);
+  console.log(`Commands: ${summarizeStatuses(report.commands)}`);
+  if (report.skill.preserved_extensions.length) {
+    console.log(`Preserved extensions: ${report.skill.preserved_extensions.join(", ")}`);
+  }
+
+  if (report.extensions?.error) {
+    console.log("");
+    console.log(`Extensions: unavailable (${report.extensions.error})`);
+  } else if (report.extensions) {
+    console.log("");
+    console.log(`Extensions: ${report.extensions.available_count} available from ${report.extensions.catalog_url}`);
+    if (report.extensions.recommended?.length) {
+      console.log("");
+      console.log("Recommended:");
+      for (const extension of report.extensions.recommended.slice(0, 3)) {
+        console.log(`  ${extension.name || extension.id}`);
+        if (extension.summary) console.log(`    ${extension.summary}`);
+        console.log(`    Details: npx ${extension.next_command}`);
+      }
+    }
+  }
+
+  console.log("");
+  console.log("Next:");
+  console.log(`  Restart Claude Code, then run: /goal-prep`);
+  console.log(`  Or invoke the skill: ${canonicalSkillName}`);
+  console.log("");
+  console.log("Also available for Codex:");
+  console.log(`  npx ${canonicalCliName} --target codex`);
+}
+
 function installSkill({ force = true, quiet = false } = {}) {
   const target = installedSkillRoot();
   const legacyTarget = legacyInstalledSkillRoot();
@@ -192,7 +490,7 @@ function installSkill({ force = true, quiet = false } = {}) {
 
   const previousMetadata = readInstallMetadata(target) || readInstallMetadata(legacyTarget);
   const previousFingerprint = existsSync(target) ? directoryFingerprint(target, { exclude: installFingerprintExcludes() }) : "";
-  const preservedExtensions = preserveInstalledExtensions([target, legacyTarget]);
+  const preservedExtensions = preserveInstalledExtensions([target, legacyTarget], { tempRoot: codexHome() });
   const extensionTempPath = preservedExtensions.tempPath;
   const preservedExtensionIds = preservedExtensions.ids;
 
@@ -416,7 +714,7 @@ Default source:
 `);
 }
 
-function installPlugin() {
+function installPlugin({ quiet = false } = {}) {
   const source = optionValue("--source") || "tolibear/goalbuddy";
   const pluginSource = join(packageRoot, "plugins", pluginName);
   const pluginManifestPath = join(pluginSource, ".codex-plugin", "plugin.json");
@@ -426,42 +724,55 @@ function installPlugin() {
 
   const pluginManifest = JSON.parse(readFileSync(pluginManifestPath, "utf8"));
   const pluginCachePath = pluginCacheRoot(pluginManifest.version);
+  const pluginSkillPath = join(pluginCachePath, "skills", canonicalSkillDirectory);
   const marketplace = runCodex(["plugin", "marketplace", "add", source]);
   if (!marketplace.ok) {
     throw new Error(`Failed to add Codex plugin marketplace: ${firstLine(marketplace.stderr || marketplace.stdout)}`);
   }
 
+  const existingPluginSkillPath = installedPluginSkillRoot();
+  const preservedExtensions = preserveInstalledExtensions([existingPluginSkillPath], { tempRoot: dirname(pluginCachePath) });
   mkdirSync(dirname(pluginCachePath), { recursive: true });
   rmSync(pluginCachePath, { recursive: true, force: true });
   cpSync(pluginSource, pluginCachePath, { recursive: true });
+  restoreInstalledExtensions(pluginSkillPath, preservedExtensions.tempPath);
+  cleanupPreservedExtensions([preservedExtensions.tempPath]);
   const configPath = enablePluginConfig();
 
   const report = {
     installed: true,
+    target: "codex",
     plugin: `${pluginName}@${pluginName}`,
     version: pluginManifest.version,
     codex_home: codexHome(),
     marketplace_source: source,
     cache_path: pluginCachePath,
     config_path: configPath,
+    preserved_extensions: preservedExtensions.ids,
   };
 
-  if (hasFlag("--json")) {
+  if (hasFlag("--json") && !quiet) {
     printJson(report);
-    return;
+    return report;
   }
 
+  if (quiet) return report;
+
   console.log(`Installed ${canonicalProductName} Codex plugin ${pluginManifest.version}`);
   console.log(`Marketplace: ${source}`);
   console.log(`Cache: ${pluginCachePath}`);
   console.log(`Config: ${configPath}`);
+  if (report.preserved_extensions.length) {
+    console.log(`Preserved extensions: ${report.preserved_extensions.join(", ")}`);
+  }
   console.log("");
   console.log("Restart Codex, then use:");
   console.log(`  $${canonicalSkillName}`);
   console.log("");
-  console.log("Optional extensions:");
-  console.log(`  npx ${canonicalCliName} extend`);
-  console.log(`  npx ${canonicalCliName} extend install --all`);
+  console.log("Bundled visual boards:");
+  console.log(`  npx ${canonicalCliName} board docs/goals/<slug>`);
+  console.log(`  npx ${canonicalCliName} extend github-projects`);
+  return report;
 }
 
 function pluginCacheRoot(version) {
@@ -527,9 +838,12 @@ function codexGoalRuntimeStatus() {
 }
 
 function runCodex(args) {
-  const result = spawnSync("codex", args, {
+  const env = { ...process.env, CODEX_HOME: codexHome() };
+  const command = codexSpawnCommand(args, env);
+  const result = spawnSync(command.file, command.args, {
     encoding: "utf8",
-    env: { ...process.env, CODEX_HOME: codexHome() },
+    env,
+    shell: command.shell || false,
   });
   return {
     ok: result.status === 0,
@@ -539,6 +853,38 @@ function runCodex(args) {
   };
 }
 
+function codexSpawnCommand(args, env) {
+  if (process.platform !== "win32") return { file: "codex", args };
+
+  const command = resolveWindowsCommand("codex", env);
+  if (!command) return { file: "codex", args };
+  if (/\.(?:cmd|bat)$/i.test(command)) {
+    const commandLine = [quoteWindowsCommandArg(command), ...args.map(quoteWindowsCommandArg)].join(" ");
+    return {
+      file: commandLine,
+      args: [],
+      shell: true,
+    };
+  }
+  return { file: command, args };
+}
+
+function resolveWindowsCommand(name, env) {
+  const systemWhere = env.SystemRoot ? join(env.SystemRoot, "System32", "where.exe") : "";
+  const whereCommand = systemWhere && existsSync(systemWhere) ? systemWhere : "where.exe";
+  const where = spawnSync(whereCommand, [name], { encoding: "utf8", env });
+  if (where.status !== 0) return "";
+  const candidates = where.stdout
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+  return candidates.find((candidate) => /\.(?:exe|cmd|bat)$/i.test(candidate)) || "";
+}
+
+function quoteWindowsCommandArg(value) {
+  return `"${String(value).replace(/(["^&|<>()%])/g, "^$1")}"`;
+}
+
 function parseGoalFeature(output) {
   const line = output.split(/\r?\n/).find((candidate) => candidate.trim().startsWith("goals"));
   if (!line) return { enabled: false, stage: "" };
@@ -788,6 +1134,11 @@ async function extendInstall() {
 async function extendInstallAll(catalog) {
   const results = [];
   for (const extension of catalog.extensions) {
+    if (existsSync(extensionTarget(extension.id)) && !hasFlag("--force")) {
+      validateCatalogExtension(extension);
+      results.push({ extension, target: extensionTarget(extension.id), plan: installPlan(catalog, extension, extensionTarget(extension.id)), skipped: true });
+      continue;
+    }
     results.push(await installCatalogExtension(catalog, extension));
   }
 
@@ -815,11 +1166,13 @@ async function extendInstallAll(catalog) {
     printJson({
       installed: true,
       count: results.length,
-      extensions: results.map(({ extension, target }) => ({ id: extension.id, target })),
+      extensions: results.map(({ extension, target, skipped }) => ({ id: extension.id, target, skipped: Boolean(skipped) })),
     });
   } else {
-    console.log(`Installed ${results.length} extensions`);
-    for (const { extension, target } of results) console.log(`  ${extension.id} -> ${target}`);
+    const installedCount = results.filter((result) => !result.skipped).length;
+    const skippedCount = results.length - installedCount;
+    console.log(`Installed ${installedCount} extensions${skippedCount ? `, skipped ${skippedCount} already installed` : ""}`);
+    for (const { extension, target, skipped } of results) console.log(`  ${extension.id} -> ${target}${skipped ? " (already installed)" : ""}`);
   }
 }
 
@@ -1058,15 +1411,18 @@ function listFiles(root, { exclude = new Set(), prefix = "" } = {}) {
   return files;
 }
 
-function preserveInstalledExtensions(targets) {
+function preserveInstalledExtensions(targets, { tempRoot = "" } = {}) {
   const ids = [];
-  const tempPath = join(codexHome(), `.goalbuddy-preserved-extend-${process.pid}-${Date.now()}`);
+  const firstTarget = targets.find(Boolean) || codexHome();
+  const tempPath = join(tempRoot || dirname(dirname(firstTarget)), `.goalbuddy-preserved-extend-${process.pid}-${Date.now()}`);
   let hasExtensions = false;
   for (const target of targets) {
+    if (!target) continue;
     const source = join(target, "extend");
     if (!existsSync(source)) continue;
     mkdirSync(tempPath, { recursive: true });
     for (const entry of readdirSync(source, { withFileTypes: true })) {
+      if (bundledCoreExtensionIds.has(entry.name)) continue;
       const from = join(source, entry.name);
       const to = join(tempPath, entry.name);
       cpSync(from, to, { recursive: true, force: true });
@@ -1080,9 +1436,11 @@ function preserveInstalledExtensions(targets) {
 
 function restoreInstalledExtensions(target, tempPath) {
   if (!tempPath) return;
-  rmSync(join(target, "extend"), { recursive: true, force: true });
-  mkdirSync(target, { recursive: true });
-  cpSync(tempPath, join(target, "extend"), { recursive: true });
+  const destinationRoot = join(target, "extend");
+  mkdirSync(destinationRoot, { recursive: true });
+  for (const entry of readdirSync(tempPath, { withFileTypes: true })) {
+    cpSync(join(tempPath, entry.name), join(destinationRoot, entry.name), { recursive: true, force: true });
+  }
 }
 
 function cleanupPreservedExtensions(paths) {
@@ -1215,6 +1573,41 @@ function printInstallReport(report) {
   console.log(`  ${legacyCliName} remains a temporary compatibility alias.`);
 }
 
+function printEverywhereInstallReport(report) {
+  const verb = report.command === "update" ? "Updated" : "Installed";
+  console.log("");
+  console.log(`${verb} ${canonicalProductName} for Codex and Claude Code ${report.package.current_version}`);
+  console.log("");
+
+  if (report.codex?.ok === false) {
+    console.log(`Codex: not completed (${report.codex.error})`);
+  } else if (report.codex) {
+    console.log(`Codex: plugin ${report.codex.version} enabled at ${report.codex.cache_path}`);
+    if (report.codex.preserved_extensions?.length) {
+      console.log(`Codex preserved extensions: ${report.codex.preserved_extensions.join(", ")}`);
+    }
+  }
+
+  if (report.claude?.ok === false) {
+    console.log(`Claude Code: not completed (${report.claude.error})`);
+  } else if (report.claude) {
+    console.log(`Claude Code: skill ${report.claude.skill.status} at ${report.claude.skill.path}`);
+    console.log(`Claude Code agents: ${summarizeStatuses(report.claude.agents)}`);
+    console.log(`Claude Code commands: ${summarizeStatuses(report.claude.commands)}`);
+  }
+
+  if (report.errors.length) {
+    console.log("");
+    console.log("One or more targets need attention:");
+    for (const error of report.errors) console.log(`  ${error.target}: ${error.error}`);
+  }
+
+  console.log("");
+  console.log("Next:");
+  console.log(`  Restart Codex, then use: $${canonicalSkillName}`);
+  console.log("  Restart Claude Code, then run: /goal-prep");
+}
+
 function summarizeStatuses(items) {
   const counts = items.reduce((memo, item) => {
     memo[item.status] = (memo[item.status] || 0) + 1;

package/internal/cli/postinstall.mjs

@@ -12,7 +12,7 @@ if (!globalInstall || process.env.GOALBUDDY_SKIP_POSTINSTALL) {
   process.exit(0);
 }
 
-const result = spawnSync(process.execPath, [cliPath, "plugin", "install"], {
+const result = spawnSync(process.execPath, [cliPath], {
   encoding: "utf8",
   env: process.env,
   stdio: "inherit",
@@ -23,7 +23,7 @@ if (result.status === 0) {
 }
 
 console.error("");
-console.error("GoalBuddy installed globally, but Codex plugin setup did not complete.");
-console.error("Run this after Codex is available:");
+console.error("GoalBuddy installed globally, but setup did not complete for every target.");
+console.error("Run this after Codex and Claude Code are available:");
 console.error("  goalbuddy");
 process.exit(0);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "goalbuddy",
-  "version": "0.2.21",
-  "description": "Turn open-ended Codex goals into a GoalBuddy Scout/Judge/Worker board with receipts, verification, and optional extensions.",
+  "version": "0.3.0",
+  "description": "A /goal operating system for Codex and Claude Code: Scout/Judge/Worker boards with visual board surfaces, receipts, and verification.",
   "type": "module",
   "bin": {
     "goalbuddy": "internal/cli/goal-maker.mjs",
@@ -18,6 +18,7 @@
     "goalbuddy/SKILL.md",
     "goalbuddy/agents",
     "goalbuddy/scripts",
+    "goalbuddy/extend",
     "goalbuddy/templates"
   ],
   "scripts": {
@@ -36,6 +37,10 @@
     "codex",
     "codex-skill",
     "openai-codex",
+    "claude-code",
+    "claude-code-plugin",
+    "claude-code-skill",
+    "anthropic",
     "goalbuddy",
     "goal",
     "task-board",