@heart-of-gold/toolkit 0.1.8 → 0.1.10

package/README.md

@@ -2,7 +2,7 @@
 
 > **Don't Panic.**
 
-25 skills for AI coding agents. Five plugins. Works with **Claude Code, Codex, OpenCode, Pi**, and any tool supporting the [agentskills.io](https://agentskills.io) standard. Named after *The Hitchhiker's Guide to the Galaxy* because the universe is absurd and your tools should at least have personality.
+29 skills for AI coding agents. Five plugins. Works with **Claude Code, Codex, OpenCode, Pi**, and any tool supporting the [agentskills.io](https://agentskills.io) standard. Named after *The Hitchhiker's Guide to the Galaxy* because the universe is absurd and your tools should at least have personality.
 
 ## Installation
 
@@ -36,12 +36,13 @@ pi install npm:@heart-of-gold/toolkit
 Pi also discovers skills from the shared `~/.agents/skills/` location, so installs done with the OpenCode target are usable from Pi too.
 
 When installed as a Pi package, Heart of Gold exposes Pi-native extension commands for the flagship workflows:
-- `/deep-thought-brainstorm` — guided brainstorm intake for the shared `brainstorm` skill
-- `/deep-thought-plan` — planning mode entrypoint with pi-friendly tool defaults
-- `/marvin-work` — execution mode entrypoint with stronger work guardrails
-- `/marvin-execute` — leave planning mode and begin execution
+- `/deep-thought-brainstorm` — start a brainstorm (collaborative discovery)
+- `/deep-thought-plan` — start planning (research and produce a plan document)
+- `/marvin-work` — start executing a plan (with always-on safety guardrails)
 
-For Pi, these extension commands replace the direct shared-skill entries for `brainstorm`, `plan`, and `work` so the command palette stays clean and there is only one obvious command per flagship workflow.
+The skills themselves enforce their own boundaries (read-only for brainstorm/plan, safe commands for work) via `allowed-tools` and prompt constraints — no manual mode switching needed.
+
+The work extension also provides always-on guardrails that protect `.env`, `.git/`, and `node_modules/` from edits, block `git add .` and destructive `rm`, and require confirmation for `git push` / `npm publish`.
 
 ### List available skills
 ```bash
@@ -106,13 +107,14 @@ Your personal content engine.
 
 Configurable sources (RSS, Gmail, HN, web search), narrative briefs, LinkedIn drafts, blog outlines, voice fidelity checking, iMessage delivery, and two-way captures.
 
-6 skills · 2 agents · 4 scripts
+7 skills · 2 agents · 5 scripts
 
 ```
 /guide:setup       # configure your sources, themes, and voice
 /guide:pipeline    # run the full content engine
 /guide:capture     # morning/evening thought capture
 /guide:write-post  # guided blog writing (7 phases)
+/guide:claude-code # Claude Code CLI guidance
 /guide:codex       # Codex CLI guidance
 /guide:gemini      # Gemini CLI guidance
 ```

package/extensions/pi/brainstorm.ts

@@ -1,67 +1,23 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 
-function sendPrompt(pi: ExtensionAPI, prompt: string, ctx: Parameters<NonNullable<Parameters<ExtensionAPI["registerCommand"]>[1]["handler"]>>[1]) {
-	if (ctx.isIdle()) {
-		pi.sendUserMessage(prompt);
-	} else {
-		pi.sendUserMessage(prompt, { deliverAs: "followUp" });
-		ctx.ui.notify("Brainstorm prompt queued as follow-up", "info");
-	}
-}
-
 export default function brainstormExtension(pi: ExtensionAPI) {
 	pi.registerCommand("deep-thought-brainstorm", {
-		description: "Interactive pi-first intake for the shared brainstorm skill",
+		description: "Start a brainstorm — collaborative discovery before planning",
 		handler: async (args, ctx) => {
-			if (!ctx.hasUI) {
-				ctx.ui.notify("/deep-thought-brainstorm requires interactive mode", "warning");
-				return;
-			}
-
-			const topic = args.trim() || (await ctx.ui.editor("Brainstorm topic", ""))?.trim();
+			const topic = args.trim() || (ctx.hasUI ? (await ctx.ui.editor("Brainstorm topic", ""))?.trim() : undefined);
 			if (!topic) {
-				ctx.ui.notify("Cancelled", "info");
+				ctx.ui.notify("Usage: /deep-thought-brainstorm <topic>", "info");
 				return;
 			}
 
-			const clarity = await ctx.ui.select("How clear are the requirements right now?", [
-				"Unclear — need discovery",
-				"Partly clear — explore tradeoffs",
-				"Quite clear — validate before planning",
-			]);
-			if (!clarity) {
-				ctx.ui.notify("Cancelled", "info");
-				return;
-			}
+			const prompt = `/skill:brainstorm ${topic}`;
 
-			const goal = await ctx.ui.select("What should the brainstorm optimize for first?", [
-				"Find the right problem framing",
-				"Compare 2-3 viable approaches",
-				"Pressure-test the chosen direction",
-			]);
-			if (!goal) {
-				ctx.ui.notify("Cancelled", "info");
-				return;
+			if (ctx.isIdle()) {
+				pi.sendUserMessage(prompt);
+			} else {
+				pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+				ctx.ui.notify("Brainstorm queued as follow-up", "info");
 			}
-
-			const prompt = [
-				`/skill:brainstorm ${topic}`,
-				"",
-				"Use a pi-friendly interactive flow:",
-				"- Ask one question at a time.",
-				"- Use explicit option lists whenever there are natural choices.",
-				"- Keep momentum high and avoid dumping questionnaires.",
-				"",
-				`Current clarity: ${clarity}`,
-				`Primary goal: ${goal}`,
-			].join("\n");
-
-			const theme = ctx.ui.theme;
-			ctx.ui.setStatus(
-				"deep-thought-brainstorm",
-				theme.fg("accent", "◉") + theme.fg("dim", " Brainstorm flow active"),
-			);
-			sendPrompt(pi, prompt, ctx);
 		},
 	});
 }

package/extensions/pi/plan.ts

@@ -1,93 +1,22 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 
-const PLAN_SAFE_TOOLS = ["read", "bash", "grep", "find", "ls"];
-
 export default function planExtension(pi: ExtensionAPI) {
-	let previousTools: string[] | null = null;
-
-	const applyPlanTools = () => {
-		const available = new Set(pi.getAllTools().map((tool) => tool.name));
-		const nextTools = PLAN_SAFE_TOOLS.filter((tool) => available.has(tool));
-		if (nextTools.length > 0) {
-			pi.setActiveTools(nextTools);
-		}
-	};
-
 	pi.registerCommand("deep-thought-plan", {
-		description: "Interactive pi-first entrypoint for planning mode and the shared plan skill",
+		description: "Start planning — research and produce a plan document",
 		handler: async (args, ctx) => {
-			if (!ctx.hasUI) {
-				ctx.ui.notify("/deep-thought-plan requires interactive mode", "warning");
-				return;
-			}
-
-			const source = args.trim() || (await ctx.ui.editor("Plan topic or brainstorm path", ""))?.trim();
+			const source = args.trim() || (ctx.hasUI ? (await ctx.ui.editor("Plan topic or brainstorm path", ""))?.trim() : undefined);
 			if (!source) {
-				ctx.ui.notify("Cancelled", "info");
-				return;
-			}
-
-			const mode = await ctx.ui.select("How should planning mode behave?", [
-				"Read-only planning (recommended)",
-				"Allow normal tools, but stay in planning mode",
-			]);
-			if (!mode) {
-				ctx.ui.notify("Cancelled", "info");
+				ctx.ui.notify("Usage: /deep-thought-plan <topic or brainstorm path>", "info");
 				return;
 			}
 
-			if (previousTools === null) {
-				previousTools = pi.getActiveTools();
-			}
-			if (mode.startsWith("Read-only")) {
-				applyPlanTools();
-			}
-
-			const prompt = [
-				`/skill:plan ${source}`,
-				"",
-				"Use a pi-friendly planning flow:",
-				"- Keep planning read-only unless the user explicitly exits planning mode.",
-				"- Ask one question at a time when clarification is needed.",
-				"- Use concise option lists when choosing between paths or handoffs.",
-			].join("\n");
-
-			const theme = ctx.ui.theme;
-			ctx.ui.setStatus(
-				"deep-thought-plan",
-				theme.fg("accent", "◉") + theme.fg("dim", " Plan mode active"),
-			);
-
-			if (ctx.isIdle()) {
-				pi.sendUserMessage(prompt);
-			} else {
-				pi.sendUserMessage(prompt, { deliverAs: "followUp" });
-				ctx.ui.notify("Plan prompt queued as follow-up", "info");
-			}
-		},
-	});
-
-	pi.registerCommand("marvin-execute", {
-		description: "Exit planning mode, restore tools, and optionally start work",
-		handler: async (args, ctx) => {
-			if (previousTools) {
-				pi.setActiveTools(previousTools);
-				previousTools = null;
-			}
-			ctx.ui.setStatus("deep-thought-plan", "");
-
-			const target = args.trim();
-			if (!target) {
-				ctx.ui.notify("Planning mode cleared. Run /marvin-work <plan-path> when ready.", "info");
-				return;
-			}
+			const prompt = `/skill:plan ${source}`;
 
-			const prompt = `/skill:work ${target}`;
 			if (ctx.isIdle()) {
 				pi.sendUserMessage(prompt);
 			} else {
 				pi.sendUserMessage(prompt, { deliverAs: "followUp" });
-				ctx.ui.notify("Work prompt queued as follow-up", "info");
+				ctx.ui.notify("Plan queued as follow-up", "info");
 			}
 		},
 	});

package/extensions/pi/work.ts

@@ -5,76 +5,15 @@ const CONFIRM_COMMANDS = [/\bgit\s+push\b/i, /\bnpm\s+publish\b/i, /\bbun\s+publ
 const BLOCKED_COMMANDS = [/\bgit\s+add\s+\.\b/i, /\brm\s+(-rf?|--recursive)/i];
 
 export default function workExtension(pi: ExtensionAPI) {
-	let workMode = false;
-
-	pi.registerCommand("marvin-work", {
-		description: "Interactive pi-first entrypoint for the shared work skill",
-		handler: async (args, ctx) => {
-			if (!ctx.hasUI) {
-				ctx.ui.notify("/marvin-work requires interactive mode", "warning");
-				return;
-			}
-
-			const planPath = args.trim() || (await ctx.ui.editor("Plan path", ""))?.trim();
-			if (!planPath) {
-				ctx.ui.notify("Cancelled", "info");
-				return;
-			}
-
-			const runMode = await ctx.ui.select("How strict should work mode be?", [
-				"Normal guardrails (recommended)",
-				"Strict guardrails for shipping work",
-			]);
-			if (!runMode) {
-				ctx.ui.notify("Cancelled", "info");
-				return;
-			}
-
-			workMode = true;
-			const theme = ctx.ui.theme;
-			ctx.ui.setStatus(
-				"marvin-work",
-				theme.fg("accent", "◉") + theme.fg("dim", ` Work mode active — ${runMode}`),
-			);
-
-			const prompt = [
-				`/skill:work ${planPath}`,
-				"",
-				"Use pi guardrails while executing:",
-				"- keep progress visible as tasks move from in-progress to complete",
-				"- do not use `git add .`",
-				"- confirm push/publish actions deliberately",
-				"- protect .env, .git/, and node_modules/ from accidental edits",
-			].join("\n");
-
-			if (ctx.isIdle()) {
-				pi.sendUserMessage(prompt);
-			} else {
-				pi.sendUserMessage(prompt, { deliverAs: "followUp" });
-				ctx.ui.notify("Work prompt queued as follow-up", "info");
-			}
-		},
-	});
-
-	pi.registerCommand("marvin-work-off", {
-		description: "Disable Heart of Gold work-mode guardrails",
-		handler: async (_args, ctx) => {
-			workMode = false;
-			ctx.ui.setStatus("marvin-work", "");
-			ctx.ui.notify("Work mode disabled", "info");
-		},
-	});
-
+	// Always-on guardrails — no mode toggle needed
 	pi.on("tool_call", async (event, ctx) => {
-		if (!workMode) return undefined;
-
 		if (event.toolName === "write" || event.toolName === "edit") {
 			const path = String(event.input.path ?? "");
 			if (PROTECTED_PATHS.some((segment) => path.includes(segment))) {
 				if (ctx.hasUI) {
-					ctx.ui.notify(`Blocked protected path in work mode: ${path}`, "warning");
+					ctx.ui.notify(`⛔ Protected path: ${path}`, "warning");
 				}
-				return { block: true, reason: `Protected path in work mode: ${path}` };
+				return { block: true, reason: `Protected path: ${path}` };
 			}
 		}
 
@@ -82,7 +21,7 @@ export default function workExtension(pi: ExtensionAPI) {
 		const command = String(event.input.command ?? "");
 
 		if (BLOCKED_COMMANDS.some((pattern) => pattern.test(command))) {
-			return { block: true, reason: `Blocked unsafe command in work mode: ${command}` };
+			return { block: true, reason: `Blocked unsafe command: ${command}` };
 		}
 
 		if (!CONFIRM_COMMANDS.some((pattern) => pattern.test(command))) {
@@ -93,11 +32,31 @@ export default function workExtension(pi: ExtensionAPI) {
 			return { block: true, reason: `Interactive confirmation required for: ${command}` };
 		}
 
-		const choice = await ctx.ui.select(`Confirm work-mode command:\n\n${command}`, ["Allow", "Block"]);
+		const choice = await ctx.ui.select(`Confirm: ${command}`, ["Allow", "Block"]);
 		if (choice !== "Allow") {
 			return { block: true, reason: `Blocked by user: ${command}` };
 		}
 
 		return undefined;
 	});
+
+	pi.registerCommand("marvin-work", {
+		description: "Start executing a plan — implement with guardrails",
+		handler: async (args, ctx) => {
+			const planPath = args.trim() || (ctx.hasUI ? (await ctx.ui.editor("Plan path", ""))?.trim() : undefined);
+			if (!planPath) {
+				ctx.ui.notify("Usage: /marvin-work <plan path>", "info");
+				return;
+			}
+
+			const prompt = `/skill:work ${planPath}`;
+
+			if (ctx.isIdle()) {
+				pi.sendUserMessage(prompt);
+			} else {
+				pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+				ctx.ui.notify("Work queued as follow-up", "info");
+			}
+		},
+	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heart-of-gold/toolkit",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "type": "module",
   "description": "Cross-platform installer for Heart of Gold skills — works with Codex, OpenCode, Pi, Claude Code, and more",
   "bin": {
@@ -59,6 +59,7 @@
       "./plugins/deep-thought/skills/review",
       "./plugins/deep-thought/skills/think",
       "./plugins/guide/skills/capture",
+      "./plugins/guide/skills/claude-code",
       "./plugins/guide/skills/codex",
       "./plugins/guide/skills/gemini",
       "./plugins/guide/skills/pipeline",

package/plugins/guide/README.md

@@ -73,6 +73,12 @@ Guided blog writing in seven phases:
 
 Can pick up blog outlines generated by the pipeline (`needs_write_post: true` in frontmatter).
 
+### /guide:claude-code
+
+Headless Claude Code handoff for second opinions, code review, targeted analysis, or follow-up on a bounded task.
+
+Use it when you want another agent harness to invoke Claude Code non-interactively, capture the result, and summarize it back. The skill ships with a small wrapper script that standardizes `claude -p` / resume usage across installs.
+
 ## How the Pipeline Works
 
 ```

package/plugins/guide/skills/claude-code/SKILL.md

@@ -0,0 +1,118 @@
+---
+name: claude-code
+description: Use when the user asks to run Claude Code CLI (`claude`, `claude resume`) or asks for a second opinion, review, analysis, refactor, or follow-up specifically from Claude Code.
+---
+
+# Claude Code CLI Skill Guide
+
+Use this skill to hand a bounded task to Claude Code from the current harness, capture the output, and summarize it back to the user.
+
+## Defaults
+
+- Default model: `sonnet`
+- Default permission mode for review or analysis: `plan`
+- Default permission mode for requested edits: `acceptEdits`
+- Default effort: `medium`
+
+Prefer the harness's structured question UI when available; otherwise ask plainly in text and wait for the answer before continuing.
+
+## Running a Task
+
+1. Ask the user which model to use if they care. Default to `sonnet`.
+2. Ask for permission mode only when it materially affects safety:
+   - `plan` for review, analysis, and read-only second opinions
+   - `acceptEdits` when the user explicitly wants Claude Code to make local changes
+   - `bypassPermissions` only with explicit user approval
+3. Resolve the bundled runner relative to this skill:
+   - `scripts/run-claude-code.sh`
+4. Build a concrete prompt for Claude Code. For review requests, include scope and output shape:
+   - Ask for findings ordered by severity
+   - Ask for file paths in each finding
+   - Ask for a short final verdict
+5. Run the bundled script:
+
+```bash
+bash <skill-dir>/scripts/run-claude-code.sh \
+  --prompt "<PROMPT>" \
+  --model <MODEL> \
+  --permission-mode <MODE> \
+  --effort <EFFORT>
+```
+
+6. Capture stdout and summarize the result for the user.
+7. If the user wants a follow-up, resume the latest Claude Code session instead of starting from scratch:
+
+```bash
+bash <skill-dir>/scripts/run-claude-code.sh \
+  --resume latest \
+  --prompt "<FOLLOW_UP_PROMPT>" \
+  --model <MODEL> \
+  --permission-mode <MODE> \
+  --effort <EFFORT>
+```
+
+## Quick Reference
+
+| Use case | Permission mode | Suggested prompt shape |
+| --- | --- | --- |
+| Read-only code review | `plan` | "Review the current diff and return findings ordered by severity with file paths." |
+| Architecture second opinion | `plan` | "Assess this design and name the top risks, tradeoffs, and missing tests." |
+| Targeted implementation | `acceptEdits` | "Implement X, keep changes minimal, and explain what changed." |
+| Continue prior thread | prior mode | Resume with a narrow follow-up prompt instead of restating everything |
+
+## Prompting Guidance
+
+- Keep prompts bounded. Claude Code performs better when the scope is explicit.
+- Name the artifact under review: current diff, specific files, or a directory.
+- For reviews, ask for bugs, regressions, missing tests, and risky assumptions first.
+- For implementation requests, specify what must not change.
+- If you disagree with the result, treat Claude Code as a colleague and challenge it with evidence.
+
+## Examples
+
+### Review the current diff
+
+```bash
+bash <skill-dir>/scripts/run-claude-code.sh \
+  --prompt "Review the current git diff. Return only findings, ordered by severity, with file paths and concise explanations." \
+  --model sonnet \
+  --permission-mode plan \
+  --effort medium
+```
+
+### Ask Claude Code to inspect a single file
+
+```bash
+bash <skill-dir>/scripts/run-claude-code.sh \
+  --prompt "Review src/server.ts for correctness, edge cases, and missing tests. Keep the response concise." \
+  --model sonnet \
+  --permission-mode plan \
+  --effort high
+```
+
+### Continue the latest Claude Code session
+
+```bash
+bash <skill-dir>/scripts/run-claude-code.sh \
+  --resume latest \
+  --prompt "Focus only on the migration risk you mentioned. What is the safest rollout plan?" \
+  --model sonnet \
+  --permission-mode plan \
+  --effort medium
+```
+
+## Script
+
+Use the bundled runner instead of assembling `claude` commands ad hoc:
+
+- `scripts/run-claude-code.sh --check` verifies that Claude Code is installed
+- `scripts/run-claude-code.sh --help` prints usage
+
+The wrapper keeps flag handling deterministic and portable when this skill is installed into Codex, Pi, or other agent harnesses.
+
+## Error Handling
+
+- Stop and report failures when `claude --version` or the runner exits non-zero.
+- If Claude Code is missing, tell the user to install or authenticate Claude Code before retrying.
+- If output is partial or Claude reports permission issues, summarize that clearly and ask whether to retry with a different permission mode.
+- Do not use `bypassPermissions` unless the user explicitly approves it.

package/plugins/guide/skills/claude-code/scripts/run-claude-code.sh

@@ -0,0 +1,140 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  cat <<'EOF'
+Usage:
+  run-claude-code.sh --check
+  run-claude-code.sh --prompt "..." [options]
+
+Options:
+  --check                       Verify that Claude Code is installed
+  --prompt TEXT                 Prompt to send to Claude Code
+  --model MODEL                 Claude model or alias (default: sonnet)
+  --permission-mode MODE        plan, acceptEdits, default, auto, dontAsk, bypassPermissions
+  --effort LEVEL                low, medium, high, max
+  --output-format FORMAT        text, json, stream-json (default: text)
+  --resume VALUE                Resume a session, for example: latest
+  --continue                    Continue the most recent session in the current directory
+  --add-dir PATH                Additional directory to allow tool access to; repeatable
+  --cwd PATH                    Working directory to run Claude Code from
+  --help                        Show this help text
+EOF
+}
+
+check_only=0
+prompt=""
+model="sonnet"
+permission_mode=""
+effort=""
+output_format="text"
+resume_value=""
+continue_mode=0
+cwd=""
+add_dirs=()
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --check)
+      check_only=1
+      shift
+      ;;
+    --prompt)
+      [[ $# -ge 2 ]] || { echo "Missing value for --prompt" >&2; exit 2; }
+      prompt="$2"
+      shift 2
+      ;;
+    --model)
+      [[ $# -ge 2 ]] || { echo "Missing value for --model" >&2; exit 2; }
+      model="$2"
+      shift 2
+      ;;
+    --permission-mode)
+      [[ $# -ge 2 ]] || { echo "Missing value for --permission-mode" >&2; exit 2; }
+      permission_mode="$2"
+      shift 2
+      ;;
+    --effort)
+      [[ $# -ge 2 ]] || { echo "Missing value for --effort" >&2; exit 2; }
+      effort="$2"
+      shift 2
+      ;;
+    --output-format)
+      [[ $# -ge 2 ]] || { echo "Missing value for --output-format" >&2; exit 2; }
+      output_format="$2"
+      shift 2
+      ;;
+    --resume)
+      [[ $# -ge 2 ]] || { echo "Missing value for --resume" >&2; exit 2; }
+      resume_value="$2"
+      shift 2
+      ;;
+    --continue)
+      continue_mode=1
+      shift
+      ;;
+    --add-dir)
+      [[ $# -ge 2 ]] || { echo "Missing value for --add-dir" >&2; exit 2; }
+      add_dirs+=("$2")
+      shift 2
+      ;;
+    --cwd)
+      [[ $# -ge 2 ]] || { echo "Missing value for --cwd" >&2; exit 2; }
+      cwd="$2"
+      shift 2
+      ;;
+    --help|-h)
+      usage
+      exit 0
+      ;;
+    *)
+      echo "Unknown argument: $1" >&2
+      usage >&2
+      exit 2
+      ;;
+  esac
+done
+
+if [[ "$check_only" -eq 1 ]]; then
+  exec claude --version
+fi
+
+if [[ -z "$prompt" ]]; then
+  echo "--prompt is required unless --check is used" >&2
+  exit 2
+fi
+
+if [[ -n "$resume_value" && "$continue_mode" -eq 1 ]]; then
+  echo "--resume and --continue cannot be used together" >&2
+  exit 2
+fi
+
+cmd=(claude)
+
+if [[ -n "$resume_value" ]]; then
+  cmd+=(-r "$resume_value")
+elif [[ "$continue_mode" -eq 1 ]]; then
+  cmd+=(-c)
+fi
+
+cmd+=(--print --output-format "$output_format" --model "$model")
+
+if [[ -n "$permission_mode" ]]; then
+  cmd+=(--permission-mode "$permission_mode")
+fi
+
+if [[ -n "$effort" ]]; then
+  cmd+=(--effort "$effort")
+fi
+
+for dir in "${add_dirs[@]}"; do
+  cmd+=(--add-dir "$dir")
+done
+
+cmd+=("$prompt")
+
+if [[ -n "$cwd" ]]; then
+  cd "$cwd"
+fi
+
+exec "${cmd[@]}"

package/src/index.ts

@@ -7,7 +7,7 @@ import { targetsCommand } from "./commands/targets";
 const main = defineCommand({
   meta: {
     name: "heart-of-gold",
-    version: "0.1.3",
+    version: "0.1.10",
     description:
       "Cross-platform installer for Heart of Gold skills — Codex, OpenCode, Pi, Claude Code, and more",
   },

package/src/utils/transform.ts

@@ -9,6 +9,7 @@ const CODEX_COMMAND_ALIASES: Record<string, string> = {
   "/brainstorm": "$brainstorm",
   "/capture": "$capture",
   "/coach": "$coach",
+  "/claude-code": "$claude-code",
   "/codex": "$codex",
   "/compound": "$compound",
   "/craft-skill": "$craft-skill",
@@ -26,6 +27,7 @@ const CODEX_COMMAND_ALIASES: Record<string, string> = {
   "/goal-checkin": "$goal-checkin",
   "/goal-setting": "$goal-setting",
   "/guide:capture": "$capture",
+  "/guide:claude-code": "$claude-code",
   "/guide:codex": "$codex",
   "/guide:gemini": "$gemini",
   "/guide:pipeline": "$pipeline",