set-prompt 0.5.4 → 0.7.0

package/dist/index.js

@@ -2,17 +2,17 @@
 
 // src/index.ts
 import { Command } from "commander";
-import chalk15 from "chalk";
+import chalk23 from "chalk";
 import figlet from "figlet";
-import fs11 from "fs";
-import path10 from "path";
+import fs14 from "fs";
+import path13 from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/install-command.ts
-import fs3 from "fs";
+import fs4 from "fs";
 import path3 from "path";
-import { spawnSync } from "child_process";
-import chalk4 from "chalk";
+import { spawnSync as spawnSync3 } from "child_process";
+import chalk5 from "chalk";
 import { confirm as confirm2 } from "@inquirer/prompts";
 
 // src/_defs/index.ts
@@ -34,6 +34,10 @@ var ANTIGRAVITY_BACKUP_DIR = path.join(ANTIGRAVITY_DIR, "SET_PROMPT_BACKUP");
 var CODEX_DIR = path.join(HOME_DIR, "codex");
 var CODEX_BACKUP_DIR = path.join(CODEX_DIR, "SET_PROMPT_BACKUP");
 var CURSOR_DIR = path.join(os.homedir(), ".cursor");
+var OPENCODE_DIR = path.join(os.homedir(), ".config", "opencode");
+var OPENCODE_BACKUP_DIR = path.join(OPENCODE_DIR, "SET_PROMPT_BACKUP");
+var GEMINICLI_DIR = path.join(os.homedir(), ".gemini");
+var GEMINICLI_BACKUP_DIR = path.join(GEMINICLI_DIR, "SET_PROMPT_BACKUP");
 var PROMPT_DIR_NAMES = ["skills", "commands", "hooks", "agents", "rules"];
 var AGENT_PROMPT_DIRS = {
   ["claudecode" /* CLAUDECODE */]: ["skills", "commands", "hooks", "agents"],
@@ -41,7 +45,9 @@ var AGENT_PROMPT_DIRS = {
   ["openclaw" /* OPENCLAW */]: ["skills"],
   ["codex" /* CODEX */]: ["skills"],
   ["antigravity" /* ANTIGRAVITY */]: ["skills"],
-  ["cursor" /* CURSOR */]: ["skills", "agents", "commands", "hooks"]
+  ["cursor" /* CURSOR */]: ["skills", "agents", "commands", "hooks"],
+  ["opencode" /* OPENCODE */]: ["skills", "commands", "agents"],
+  ["geminicli" /* GEMINICLI */]: ["skills", "commands", "agents"]
 };
 var ALL_AGENTS = [
   { name: "Claude Code", value: "claudecode" /* CLAUDECODE */ },
@@ -49,7 +55,9 @@ var ALL_AGENTS = [
   { name: "OpenClaw", value: "openclaw" /* OPENCLAW */ },
   { name: "Codex", value: "codex" /* CODEX */ },
   { name: "Antigravity", value: "antigravity" /* ANTIGRAVITY */ },
-  { name: "Cursor", value: "cursor" /* CURSOR */ }
+  { name: "Cursor", value: "cursor" /* CURSOR */ },
+  { name: "OpenCode", value: "opencode" /* OPENCODE */ },
+  { name: "Gemini CLI", value: "geminicli" /* GEMINICLI */ }
 ];
 
 // src/_libs/config.ts
@@ -83,6 +91,14 @@ var CursorConfigSchema = z.object({
   path: z.string().nullable(),
   backup_path: z.string().nullish().optional()
 });
+var OpencodeConfigSchema = z.object({
+  path: z.string().nullable(),
+  backup_path: z.string().nullish().optional()
+});
+var GeminicliConfigSchema = z.object({
+  path: z.string().nullable(),
+  backup_path: z.string().nullish().optional()
+});
 var GlobalConfigSchema = z.object({
   repo_path: z.string(),
   remote_url: z.string().nullable(),
@@ -91,7 +107,9 @@ var GlobalConfigSchema = z.object({
   openclaw: OpenclawConfigSchema.nullable(),
   codex: CodexConfigSchema.nullish().optional(),
   antigravity: AntigravityConfigSchema.nullish().optional(),
-  cursor: CursorConfigSchema.nullish().optional()
+  cursor: CursorConfigSchema.nullish().optional(),
+  opencode: OpencodeConfigSchema.nullish().optional(),
+  geminicli: GeminicliConfigSchema.nullish().optional()
 });
 
 // src/_libs/config.ts
@@ -105,6 +123,8 @@ var ConfigManager = class {
     this._codex = null;
     this._antigravity = null;
     this._cursor = null;
+    this._opencode = null;
+    this._geminicli = null;
   }
   get repo_path() {
     return this._repo_path;
@@ -130,6 +150,12 @@ var ConfigManager = class {
   get cursor() {
     return this._cursor;
   }
+  get opencode() {
+    return this._opencode;
+  }
+  get geminicli() {
+    return this._geminicli;
+  }
   set repo_path(v) {
     this._repo_path = v;
   }
@@ -154,6 +180,12 @@ var ConfigManager = class {
   set cursor(v) {
     this._cursor = v;
   }
+  set opencode(v) {
+    this._opencode = v;
+  }
+  set geminicli(v) {
+    this._geminicli = v;
+  }
   init() {
     this._loadFromDisk();
     if (this._repo_path != null) {
@@ -175,7 +207,9 @@ var ConfigManager = class {
         openclaw: this._openclaw,
         codex: this._codex,
         antigravity: this._antigravity,
-        cursor: this._cursor
+        cursor: this._cursor,
+        opencode: this._opencode,
+        geminicli: this._geminicli
       }, null, 4);
       fs.writeFileSync(CONFIG_PATH, configStr, "utf-8");
       console.log(chalk.green(`Config saved`) + chalk.dim(` \u2192 ${CONFIG_PATH}`));
@@ -212,6 +246,12 @@ var ConfigManager = class {
   isCursorEnabled() {
     return this._cursor != null;
   }
+  isOpencodeEnabled() {
+    return this._opencode != null;
+  }
+  isGeminicliEnabled() {
+    return this._geminicli != null;
+  }
   _assign(config) {
     this._repo_path = config.repo_path;
     this._remote_url = config.remote_url;
@@ -221,6 +261,8 @@ var ConfigManager = class {
     this._codex = config.codex ?? null;
     this._antigravity = config.antigravity ?? null;
     this._cursor = config.cursor ?? null;
+    this._opencode = config.opencode ?? null;
+    this._geminicli = config.geminicli ?? null;
   }
   _loadFromDisk() {
     if (fs.existsSync(CONFIG_PATH) === false) {
@@ -239,6 +281,8 @@ var ConfigManager = class {
 var configManager = new ConfigManager();
 
 // src/_libs/index.ts
+import { spawnSync } from "child_process";
+import fs2 from "fs";
 import chalk2 from "chalk";
 var isGitUrl = (source) => source.startsWith("http://") || source.startsWith("https://") || source.startsWith("git@") || source.startsWith("ssh://") || source.endsWith(".git") && (source.startsWith("http") || source.startsWith("git@") || source.startsWith("ssh://"));
 var resolveRepoPath = () => {
@@ -249,11 +293,71 @@ var resolveRepoPath = () => {
   }
   return configManager.repo_path;
 };
+var isOnPath = (bin) => {
+  const probeCmd = process.platform === "win32" ? "where" : "which";
+  const probe = spawnSync(probeCmd, [bin], { stdio: "ignore" });
+  return probe.status === 0;
+};
+var firstExistingPath = (candidates) => {
+  for (const candidate of candidates) {
+    if (candidate != null && candidate !== "" && fs2.existsSync(candidate)) return candidate;
+  }
+  return null;
+};
+
+// src/_libs/repo.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import chalk3 from "chalk";
+var parsePorcelainLine = (line) => {
+  if (line.length < 4) return null;
+  const status = line.slice(0, 2);
+  let name = line.slice(3);
+  const arrowIdx = name.indexOf(" -> ");
+  if (arrowIdx >= 0) name = name.slice(arrowIdx + 4);
+  if (name.startsWith('"') && name.endsWith('"')) name = name.slice(1, -1);
+  if (status.includes("?")) return { kind: "?", name };
+  if (status.includes("D")) return { kind: "D", name };
+  if (status.includes("R")) return { kind: "R", name };
+  if (status.includes("A")) return { kind: "A", name };
+  if (status.includes("M")) return { kind: "M", name };
+  return null;
+};
+var pickVerb = (files) => {
+  const allAdded = files.every((f) => f.kind === "A" || f.kind === "?");
+  const allDeleted = files.every((f) => f.kind === "D");
+  if (allAdded) return "add";
+  if (allDeleted) return "remove";
+  return "update";
+};
+var generateCommitMessage = (repoPath) => {
+  const result = spawnSync2("git", ["status", "--porcelain", "--untracked-files=all"], {
+    cwd: repoPath,
+    encoding: "utf8"
+  });
+  if (result.status !== 0) return null;
+  const files = result.stdout.split("\n").map(parsePorcelainLine).filter((f) => f !== null);
+  if (files.length === 0) return null;
+  const verb = pickVerb(files);
+  const noun = files.length === 1 ? "file" : "files";
+  const subject = `${verb} ${files.length} ${noun}`;
+  const body = files.map((f) => `- ${f.name}`).join("\n");
+  return `${subject}
+
+${body}`;
+};
+var printSaveHint = (repoPath) => {
+  const generated = generateCommitMessage(repoPath);
+  if (generated == null) return;
+  const subject = generated.split("\n")[0];
+  console.log(chalk3.yellow("\nUncommitted changes detected."));
+  console.log(chalk3.dim(`  Pending: ${subject}`));
+  console.log(chalk3.cyan("  Tip: run `sppt repo save` to commit and push."));
+};
 
 // src/commands/scaffold-command.ts
-import fs2 from "fs";
+import fs3 from "fs";
 import path2 from "path";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import { confirm } from "@inquirer/prompts";
 
 // src/_libs/templates.ts
@@ -275,7 +379,7 @@ This is a shared prompt repository linked to various AI agents via \`set-prompt
 \u2502       \u251C\u2500\u2500 COMMAND.md     # Platform-specific frontmatter + prompt content
 \u2502       \u2514\u2500\u2500 ...            # Supporting files
 \u251C\u2500\u2500 hooks/                 # Lifecycle shell hooks (Claude Code)
-\u251C\u2500\u2500 agents/                # Agent definitions (Claude Code, Cursor)
+\u251C\u2500\u2500 agents/                # Agent definitions (Claude Code, Cursor, OpenCode, Gemini CLI)
 \u2502   \u2514\u2500\u2500 <agent-name>/
 \u2502       \u2514\u2500\u2500 AGENT.md
 \u251C\u2500\u2500 rules/                 # Rule definitions (Cursor)
@@ -299,8 +403,23 @@ set-prompt scaffold .
 set-prompt install https://github.com/you/my-prompts
 set-prompt link
 
-# Pull latest changes
-set-prompt update
+# Inspect current state (branch, ahead/behind, changed files)
+set-prompt repo status
+
+# Pull latest changes from remote
+set-prompt repo pull
+
+# Commit + push local edits in one step (auto-generates message if -m omitted)
+set-prompt repo save -m "update skills"
+set-prompt repo save
+
+# Or commit and push separately
+set-prompt repo commit -m "update skills"
+set-prompt repo push
+
+# Jump into the repo or open it in an editor
+cd "$(set-prompt repo path)"
+set-prompt repo open --code
 \`\`\`
 
 ## Frontmatter Reference
@@ -359,13 +478,27 @@ compatibility: "Requires Node.js 18+"
 metadata:
   category: "development"
 disable-model-invocation: false
+
+# OpenCode
+name: "my-skill"
+description: "What this skill does and when to use it"
+license: "MIT"
+compatibility: "opencode"
+metadata:
+  audience: "maintainers"
+
+# Gemini CLI
+name: my-skill
+description: "What this skill does and when Gemini should use it"
 ---
 \`\`\`
 
+> **Gemini CLI note**: Only \`name\` and \`description\` are recognized. \`name\` must be lowercase with hyphens and match the directory name.
+
 | Field | Required | Platform | Description |
 |-------|----------|----------|-------------|
-| \`name\` | Yes | All | Display name. Claude Code: lowercase, numbers, hyphens only (max 64 chars). RooCode: emoji allowed. Antigravity: optional, defaults to folder name. |
-| \`description\` | Yes | All | What it does and when to use it. Claude uses this to decide auto-loading. |
+| \`name\` | Yes | All | Display name. Claude Code / OpenCode / RooCode: lowercase, numbers, hyphens only (no underscores; Claude Code / OpenCode limit to 64 chars). Gemini CLI: lowercase with hyphens, must match the directory name. Antigravity: optional, defaults to folder name. |
+| \`description\` | Yes | All | What it does and when to use it. Claude / OpenCode / Gemini CLI uses this to decide auto-loading. OpenCode limits to 1\u20131024 chars. |
 | \`allowed-tools\` | No | Claude Code | Tools Claude can use without asking. e.g. \`Read\` \`Write\` \`Edit\` \`Bash\` \`Grep\` \`Glob\` |
 | \`model\` | No | Claude Code | Model to use when active. \`sonnet\` or \`haiku\` |
 | \`context\` | No | Claude Code | \`fork\` = run in a forked subagent context |
@@ -384,9 +517,9 @@ disable-model-invocation: false
 | \`command-dispatch\` | No | OpenClaw | \`"tool"\` = bypass model, dispatch directly to a tool |
 | \`command-tool\` | No | OpenClaw | Tool to invoke when \`command-dispatch: "tool"\` |
 | \`command-arg-mode\` | No | OpenClaw | How arguments are forwarded to the tool. (default: \`"raw"\`) |
-| \`license\` | No | Cursor | License name or reference to a bundled license file. |
-| \`compatibility\` | No | Cursor | Environment requirements (system packages, network access, etc.) |
-| \`metadata\` | No | Cursor | Arbitrary key-value mapping for additional metadata. |
+| \`license\` | No | Cursor, OpenCode | License name or reference to a bundled license file. |
+| \`compatibility\` | No | Cursor, OpenCode | Environment requirements (system packages, network access, etc.) |
+| \`metadata\` | No | Cursor, OpenCode | Arbitrary key-value mapping for additional metadata. OpenCode requires string-to-string values only. |
 
 ---
 
@@ -423,9 +556,41 @@ hooks:
 user-invocable: true
 command-dispatch: "tool"   # bypass model, dispatch directly to a tool
 command-tool: "Bash"
+
+# OpenCode
+description: "What this command does"
+template: "Run the full test suite and summarise failures for $ARGUMENTS"
+agent: build
+model: anthropic/claude-sonnet-4-20250514
+subtask: false
 ---
 \`\`\`
 
+> **OpenCode note**: \`template\` is required in the frontmatter \u2014 it's the prompt sent to the LLM when the command runs. The markdown body is ignored. Placeholders: \`$ARGUMENTS\`, \`$1\`/\`$2\`/\`$3\`, \`\` !\`cmd\` \`\` (bash output), \`@path\` (file contents).
+
+#### Gemini CLI commands (TOML, not Markdown)
+
+Gemini CLI reads \`.toml\` files \u2014 not \`.md\`. The entire command is a TOML file with two top-level keys:
+
+\`\`\`toml
+# ~/.gemini/commands/refactor/pure.toml    \u2192    /refactor:pure
+description = "Refactor current context into a pure function."
+prompt = """
+Please analyze the code provided.
+Refactor it into a pure function.
+Include: 1) Refactored code. 2) Explanation of changes.
+"""
+\`\`\`
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| \`prompt\` | Yes | Single or multi-line prompt sent to Gemini. |
+| \`description\` | No | One-line description shown in \`/help\` menu. Auto-generated from prompt if omitted. |
+
+**Placeholders inside the prompt**: \`{{args}}\` (user input, shell-escaped inside \`!{...}\`), \`!{cmd}\` (shell output injection, asks for confirmation), \`@{path}\` (file/dir content injection, supports images/PDFs). If \`{{args}}\` is absent, the user's text is appended to the prompt end.
+
+**Namespacing**: subdirectories create namespaced commands \u2014 \`commands/git/commit.toml\` becomes \`/git:commit\`. After edits, run \`/commands reload\` in Gemini CLI.
+
 | Field | Required | Platform | Description |
 |-------|----------|----------|-------------|
 | \`name\` | No | All | Display name \u2014 lowercase, numbers, hyphens only (max 64 chars). Defaults to directory name. |
@@ -437,6 +602,10 @@ command-tool: "Bash"
 | \`context\` | No | Claude Code | \`fork\` = run in a forked subagent context |
 | \`agent\` | No | Claude Code | Subagent type when \`context: fork\`. e.g. \`general-purpose\` \`Explore\` \`Plan\` |
 | \`hooks\` | No | Claude Code | Lifecycle hooks for pre/post processing. |
+| \`template\` | Yes | OpenCode | Prompt text sent to the LLM when the command runs. |
+| \`agent\` | No | OpenCode | Agent to route the command to. Defaults to the current agent. |
+| \`model\` | No | OpenCode | Overrides default model. Format: \`provider/model-id\`. |
+| \`subtask\` | No | OpenCode | \`true\` = force subagent invocation to avoid polluting main context. (default: \`false\`) |
 
 ---
 
@@ -461,18 +630,79 @@ description: "What this agent does and when to use it"
 model: inherit
 readonly: false
 is_background: false
+
+# OpenCode
+description: "Reviews code for quality and best practices"
+mode: subagent
+model: anthropic/claude-sonnet-4-20250514
+temperature: 0.1
+top_p: 0.9
+steps: 20
+color: "#FF5733"
+hidden: false
+disable: false
+prompt: "{file:./prompts/review.txt}"
+tools:
+  write: false
+  edit: false
+  bash: false
+permission:
+  edit: deny
+  bash:
+    "*": ask
+    "git diff": allow
+  webfetch: deny
+
+# Gemini CLI
+name: security-auditor
+description: "Specialized in finding security vulnerabilities in code."
+kind: local
+tools:
+  - read_file
+  - grep_search
+model: gemini-3-flash-preview
+temperature: 0.2
+max_turns: 10
+timeout_mins: 15
+mcpServers:
+  my-custom-server:
+    command: 'node'
+    args: ['path/to/server.js']
 ---
 \`\`\`
 
+> **OpenCode note**: The filename (without \`.md\`) becomes the agent ID. \`name\` is **not** a frontmatter field \u2014 don't include it.
+
+> **\u26A0 Gemini CLI note (strict validation)**: Gemini CLI **rejects any unknown frontmatter key** and fails to load the agent with an error like:
+> \`\`\`
+> Agent loading error: ... Validation failed:
+> Unrecognized key(s) in object: 'color', 'skills'
+> \`\`\`
+> Only these keys are allowed: \`name\`, \`description\`, \`kind\`, \`tools\`, \`mcpServers\`, \`model\`, \`temperature\`, \`max_turns\`, \`timeout_mins\`. Fields from other platforms (\`allowed-tools\`, \`mode\`, \`context\`, \`color\`, \`readonly\`, \`is_background\`, etc.) **must not appear** in an agent file if you want Gemini CLI to load it. If you need platform-specific agents, keep them in separate \`.md\` files per agent.
+
 | Field | Required | Platform | Description |
 |-------|----------|----------|-------------|
-| \`name\` | Yes | All | Display name. Claude Code: lowercase, numbers, hyphens only (max 64 chars). Cursor: defaults to folder name. |
+| \`name\` | Yes | Claude Code, Cursor, Gemini CLI | Display name. Claude Code: lowercase, numbers, hyphens only (max 64 chars). Cursor: defaults to folder name. OpenCode uses the filename instead. Gemini CLI uses \`name\` as the tool slug. |
 | \`description\` | Yes | All | When and how to use this agent. Used to decide when to spawn/delegate. |
 | \`allowed-tools\` | No | Claude Code | Tools this agent can use without asking |
-| \`model\` | No | All | Claude Code: \`sonnet\` or \`haiku\`. Cursor: \`fast\`, \`inherit\`, or a specific model ID. |
+| \`tools\` | No | OpenCode, Gemini CLI | OpenCode: per-tool enable/disable map with wildcards. Gemini CLI: array of tool names the agent can use (e.g. \`[read_file, grep_search]\`). |
+| \`model\` | No | All | Claude Code: \`sonnet\` or \`haiku\`. Cursor: \`fast\`, \`inherit\`, or a specific model ID. OpenCode: \`provider/model-id\`. Gemini CLI: specific Gemini model override. |
 | \`context\` | No | Claude Code | \`fork\` = run in isolated subagent context |
 | \`readonly\` | No | Cursor | \`true\` = sub-agent runs with restricted write permissions (no file edits or state-changing shell commands). (default: \`false\`) |
 | \`is_background\` | No | Cursor | \`true\` = sub-agent runs in background without blocking parent. (default: \`false\`) |
+| \`mode\` | No | OpenCode | \`primary\`, \`subagent\`, or \`all\`. (default: \`all\`) |
+| \`temperature\` | No | OpenCode, Gemini CLI | Response randomness. OpenCode: \`0.0\`\u2013\`1.0\`. Gemini CLI: \`0.0\`\u2013\`2.0\`. |
+| \`top_p\` | No | OpenCode | Alternative diversity control, \`0.0\`\u2013\`1.0\`. |
+| \`steps\` | No | OpenCode | Max agentic iterations before forcing a text response. |
+| \`disable\` | No | OpenCode | \`true\` = disable the agent. (default: \`false\`) |
+| \`hidden\` | No | OpenCode | \`true\` = hide from \`@\` autocomplete. Subagents only. (default: \`false\`) |
+| \`color\` | No | OpenCode | Hex color (e.g. \`#FF5733\`) or theme color. |
+| \`prompt\` | No | OpenCode | Custom system prompt source. Supports file references like \`{file:./prompts/review.txt}\`. |
+| \`permission\` | No | OpenCode | Fine-grained action permissions. Values: \`allow\`, \`ask\`, \`deny\`. Applies to \`edit\`, \`bash\` (supports per-command globs like \`"git diff": allow\`), \`webfetch\`, \`task\`. |
+| \`kind\` | No | Gemini CLI | \`local\` or \`remote\`. (default: \`local\`) |
+| \`max_turns\` | No | Gemini CLI | Conversation turn limit. (default: \`30\`) |
+| \`timeout_mins\` | No | Gemini CLI | Execution time limit in minutes. (default: \`10\`) |
+| \`mcpServers\` | No | Gemini CLI | Inline MCP server configuration. Each server is a nested YAML map with \`command\` and \`args\` keys \u2014 define MCP servers unique to this agent (not from the global registry). |
 
 ---
 
@@ -650,43 +880,86 @@ echo '{"permission":"deny","user_message":"Blocked by policy","agent_message":"N
 `;
 
 // src/commands/scaffold-command.ts
+var validateClaudePluginManifest = (data) => {
+  const issues = [];
+  if (typeof data !== "object" || data === null) return ["root must be a JSON object"];
+  const obj = data;
+  if (typeof obj.name !== "string" || obj.name.length === 0) {
+    issues.push('"name" is required and must be a non-empty string');
+  }
+  return issues;
+};
+var validateCodexPluginManifest = (data) => {
+  const issues = [];
+  if (typeof data !== "object" || data === null) return ["root must be a JSON object"];
+  const obj = data;
+  if (typeof obj.name !== "string" || obj.name.length === 0) {
+    issues.push('"name" is required and must be a non-empty string');
+  }
+  if (typeof obj.skills !== "string" || obj.skills.length === 0) {
+    issues.push('"skills" is required and must be a string path (e.g. "./skills/")');
+  }
+  if (typeof obj.mcpServers !== "string" || obj.mcpServers.length === 0) {
+    issues.push('"mcpServers" is required and must be a string path (e.g. "./.mcp.json")');
+  }
+  if (typeof obj.apps !== "string" || obj.apps.length === 0) {
+    issues.push('"apps" is required and must be a string path (e.g. "./.app.json")');
+  }
+  return issues;
+};
+var ensureManifest = (jsonPath, metaDir, validate, defaultData, label) => {
+  if (fs3.existsSync(jsonPath)) {
+    try {
+      const parsed = JSON.parse(fs3.readFileSync(jsonPath, "utf-8"));
+      const issues = validate(parsed);
+      if (issues.length === 0) return "valid";
+      console.warn(chalk4.yellow(`  \u26A0 ${label} has issues \u2014 keeping existing file:`));
+      for (const issue of issues) console.warn(chalk4.dim(`     ${issue}`));
+      return "invalid";
+    } catch (ex) {
+      console.warn(chalk4.yellow(`  \u26A0 ${label} failed to parse: ${ex.message} \u2014 keeping existing file`));
+      return "invalid";
+    }
+  }
+  fs3.mkdirSync(metaDir, { recursive: true });
+  fs3.writeFileSync(jsonPath, JSON.stringify(defaultData, null, 4), { encoding: "utf-8" });
+  return "created";
+};
 var ensureClaudePluginManifest = (repoPath) => {
   const metaDir = path2.join(repoPath, ".claude-plugin");
   const jsonPath = path2.join(metaDir, "plugin.json");
-  fs2.mkdirSync(metaDir, { recursive: true });
-  fs2.writeFileSync(jsonPath, JSON.stringify({
+  return ensureManifest(jsonPath, metaDir, validateClaudePluginManifest, {
     name: PLUGIN_NAME,
     version: "1.0.0",
     description: "Managed by set-prompt"
-  }, null, 4), { encoding: "utf-8" });
+  }, ".claude-plugin/plugin.json");
 };
 var ensureCodexPluginManifest = (repoPath) => {
   const metaDir = path2.join(repoPath, ".codex-plugin");
   const jsonPath = path2.join(metaDir, "plugin.json");
-  fs2.mkdirSync(metaDir, { recursive: true });
-  fs2.writeFileSync(jsonPath, JSON.stringify({
+  return ensureManifest(jsonPath, metaDir, validateCodexPluginManifest, {
     name: PLUGIN_NAME,
     version: "1.0.0",
     description: "Managed by set-prompt",
     skills: "./skills/",
     mcpServers: "./.mcp.json",
     apps: "./.app.json"
-  }, null, 4), { encoding: "utf-8" });
+  }, ".codex-plugin/plugin.json");
 };
 var ensureMcpJson = (repoPath) => {
   const mcpJsonPath = path2.join(repoPath, ".mcp.json");
-  if (fs2.existsSync(mcpJsonPath)) {
+  if (fs3.existsSync(mcpJsonPath)) {
     return false;
   }
-  fs2.writeFileSync(mcpJsonPath, JSON.stringify({ mcpServers: {} }, null, 4), { encoding: "utf-8" });
+  fs3.writeFileSync(mcpJsonPath, JSON.stringify({ mcpServers: {} }, null, 4), { encoding: "utf-8" });
   return true;
 };
 var ensureAppJson = (repoPath) => {
   const appJsonPath = path2.join(repoPath, ".app.json");
-  if (fs2.existsSync(appJsonPath)) {
+  if (fs3.existsSync(appJsonPath)) {
     return false;
   }
-  fs2.writeFileSync(appJsonPath, JSON.stringify({ apps: {} }, null, 4), { encoding: "utf-8" });
+  fs3.writeFileSync(appJsonPath, JSON.stringify({ apps: {} }, null, 4), { encoding: "utf-8" });
   return true;
 };
 var scaffoldCommand = async (localPath) => {
@@ -698,15 +971,15 @@ var scaffoldCommand = async (localPath) => {
       if (configManager.repo_path != null) {
         targetPath = configManager.repo_path;
       } else {
-        console.error(chalk3.red("No path provided and no repo registered. Please provide a path."));
+        console.error(chalk4.red("No path provided and no repo registered. Please provide a path."));
         process.exit(1);
       }
     }
-    if (fs2.existsSync(targetPath) === false || fs2.statSync(targetPath).isDirectory() === false) {
-      console.error(chalk3.red(`Invalid directory path: '${targetPath}'`));
+    if (fs3.existsSync(targetPath) === false || fs3.statSync(targetPath).isDirectory() === false) {
+      console.error(chalk4.red(`Invalid directory path: '${targetPath}'`));
       process.exit(1);
     }
-    console.log(chalk3.dim(`Scaffolding: ${targetPath}
+    console.log(chalk4.dim(`Scaffolding: ${targetPath}
 `));
     const writeGuide = await confirm({
       message: "Generate SET_PROMPT_GUIDE.md? (reference doc for writing prompts)",
@@ -714,32 +987,36 @@ var scaffoldCommand = async (localPath) => {
     });
     if (writeGuide) {
       const guideMdPath = path2.join(targetPath, "SET_PROMPT_GUIDE.md");
-      fs2.writeFileSync(guideMdPath, SET_PROMPT_GUIDE, { encoding: "utf-8", flag: "w" });
-      console.log(`${TAB}${chalk3.green("\u2713")} SET_PROMPT_GUIDE.md`);
+      fs3.writeFileSync(guideMdPath, SET_PROMPT_GUIDE, { encoding: "utf-8", flag: "w" });
+      console.log(`${TAB}${chalk4.green("\u2713")} SET_PROMPT_GUIDE.md`);
     }
     for (const dirName of PROMPT_DIR_NAMES) {
       const dirPath = path2.join(targetPath, dirName);
-      if (fs2.existsSync(dirPath)) {
-        console.log(`${TAB}${chalk3.dim("\u2713")} ${dirName}/`);
+      if (fs3.existsSync(dirPath)) {
+        console.log(`${TAB}${chalk4.dim("\u2713")} ${dirName}/`);
       } else {
-        fs2.mkdirSync(dirPath, { recursive: true });
-        console.log(`${TAB}${chalk3.green("+")} ${dirName}/`);
+        fs3.mkdirSync(dirPath, { recursive: true });
+        console.log(`${TAB}${chalk4.green("+")} ${dirName}/`);
       }
       const gitkeepPath = path2.join(dirPath, ".gitkeep");
-      if (!fs2.existsSync(gitkeepPath)) {
-        fs2.writeFileSync(gitkeepPath, "", { encoding: "utf-8" });
+      if (!fs3.existsSync(gitkeepPath)) {
+        fs3.writeFileSync(gitkeepPath, "", { encoding: "utf-8" });
       }
     }
-    ensureClaudePluginManifest(targetPath);
-    console.log(`${TAB}${chalk3.green("\u2713")} .claude-plugin/plugin.json`);
-    ensureCodexPluginManifest(targetPath);
-    console.log(`${TAB}${chalk3.green("\u2713")} .codex-plugin/plugin.json`);
-    console.log(`${TAB}${ensureMcpJson(targetPath) ? chalk3.green("+") : chalk3.dim("\u2713")} .mcp.json`);
-    console.log(`${TAB}${ensureAppJson(targetPath) ? chalk3.green("+") : chalk3.dim("\u2713")} .app.json`);
-    console.log(chalk3.green("\nScaffold complete."));
+    const symFor = (r) => r === "created" ? chalk4.green("+") : r === "valid" ? chalk4.dim("\u2713") : chalk4.yellow("\u26A0");
+    const claudeResult = ensureClaudePluginManifest(targetPath);
+    console.log(`${TAB}${symFor(claudeResult)} .claude-plugin/plugin.json`);
+    const codexResult = ensureCodexPluginManifest(targetPath);
+    console.log(`${TAB}${symFor(codexResult)} .codex-plugin/plugin.json`);
+    console.log(`${TAB}${ensureMcpJson(targetPath) ? chalk4.green("+") : chalk4.dim("\u2713")} .mcp.json`);
+    console.log(`${TAB}${ensureAppJson(targetPath) ? chalk4.green("+") : chalk4.dim("\u2713")} .app.json`);
+    console.log(chalk4.green("\nScaffold complete."));
+    if (configManager.repo_path != null && path2.resolve(targetPath) === path2.resolve(configManager.repo_path)) {
+      printSaveHint(targetPath);
+    }
     return true;
   } catch (ex) {
-    console.error(chalk3.red(`Failed to scaffold repo structure: ${ex.message}`), ex);
+    console.error(chalk4.red(`Failed to scaffold repo structure: ${ex.message}`), ex);
     throw ex;
   }
 };
@@ -748,86 +1025,87 @@ var scaffoldCommand = async (localPath) => {
 var cloneRepo = async (remoteUrl) => {
   const localPath = path3.join(HOME_DIR, "repo");
   let backupPath = null;
-  if (fs3.existsSync(localPath) == true) {
+  if (fs4.existsSync(localPath) == true) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     backupPath = path3.join(HOME_DIR, `repo.bak.${timestamp}`);
     try {
-      fs3.renameSync(localPath, backupPath);
-      console.log(chalk4.yellow("  backed up") + chalk4.dim(` existing repo \u2192 ${backupPath}`));
+      fs4.renameSync(localPath, backupPath);
+      console.log(chalk5.yellow("  backed up") + chalk5.dim(` existing repo \u2192 ${backupPath}`));
     } catch (ex) {
       if (ex.code === "EPERM") {
-        console.error(chalk4.red("\u274C Cannot rename existing repo \u2014 it may be open in another process."));
-        console.log(chalk4.dim(`   Close any editors or terminals using: ${localPath}`));
+        console.error(chalk5.red("\u274C Cannot rename existing repo \u2014 it may be open in another process."));
+        console.log(chalk5.dim(`   Close any editors or terminals using: ${localPath}`));
       } else {
-        console.error(chalk4.red(`\u274C Failed to backup existing repo: ${ex.message}`));
+        console.error(chalk5.red(`\u274C Failed to backup existing repo: ${ex.message}`));
       }
       return false;
     }
   }
-  fs3.mkdirSync(path3.dirname(localPath), { recursive: true });
+  fs4.mkdirSync(path3.dirname(localPath), { recursive: true });
   console.log(`Cloning ${remoteUrl}...`);
-  const result = spawnSync("git", ["clone", remoteUrl, localPath], { stdio: "inherit" });
+  const result = spawnSync3("git", ["clone", remoteUrl, localPath], { stdio: "inherit" });
   if (result.status !== 0) {
     console.log("\u274C Failed to clone. Check the URL and your git credentials.");
     process.exit(1);
   }
   console.log("\u2705 Cloned successfully.");
   if (backupPath != null) {
-    fs3.rmSync(backupPath, { recursive: true, force: true });
-    console.log(chalk4.red("  removed") + chalk4.dim(` backup \u2192 ${backupPath}`));
+    fs4.rmSync(backupPath, { recursive: true, force: true });
+    console.log(chalk5.red("  removed") + chalk5.dim(` backup \u2192 ${backupPath}`));
   }
-  await scaffoldCommand(localPath, { force: true });
+  await scaffoldCommand(localPath);
   configManager.repo_path = localPath;
   configManager.remote_url = remoteUrl;
   if (configManager.save() === false) {
-    console.error(chalk4.red("Failed to save config."));
+    console.error(chalk5.red("Failed to save config."));
     return false;
   }
+  printSaveHint(localPath);
   return true;
 };
 var installCommand = async (target) => {
   try {
     if (isGitUrl(target) === false) {
-      console.error(chalk4.red("\u274C Only remote git URLs are supported."));
-      console.log(chalk4.dim("   Example: set-prompt install https://github.com/you/my-prompts"));
+      console.error(chalk5.red("\u274C Only remote git URLs are supported."));
+      console.log(chalk5.dim("   Example: set-prompt install https://github.com/you/my-prompts"));
       process.exit(1);
     }
     const normalizeUrl = (url) => url.replace(/\.git$/, "").toLowerCase();
     if (configManager.repo_path != null) {
       if (normalizeUrl(configManager.remote_url ?? "") === normalizeUrl(target)) {
-        console.error(chalk4.red(`\u274C Already installed from the same URL: ${target}`));
-        console.log(chalk4.dim("   Use `set-prompt update` to pull the latest changes."));
+        console.error(chalk5.red(`\u274C Already installed from the same URL: ${target}`));
+        console.log(chalk5.dim("   Use `set-prompt repo pull` to pull the latest changes."));
         return false;
       }
-      console.warn(chalk4.yellow(`\u26A0 Switching repo: ${configManager.remote_url} \u2192 ${target}`));
+      console.warn(chalk5.yellow(`\u26A0 Switching repo: ${configManager.remote_url} \u2192 ${target}`));
       const proceed = await confirm2({ message: "Replace existing installation?", default: false });
       if (!proceed) {
-        console.log(chalk4.yellow("Cancelled."));
+        console.log(chalk5.yellow("Cancelled."));
         return false;
       }
     } else {
       const proceed = await confirm2({ message: `Clone and register "${target}"?`, default: true });
       if (!proceed) {
-        console.log(chalk4.yellow("Cancelled."));
+        console.log(chalk5.yellow("Cancelled."));
         return false;
       }
     }
     return await cloneRepo(target);
   } catch (ex) {
-    console.error(chalk4.red(`Unexpected error: ${ex.message}`), ex);
+    console.error(chalk5.red(`Unexpected error: ${ex.message}`), ex);
     process.exit(1);
   }
 };
 
 // src/commands/link-command.ts
-import chalk11 from "chalk";
+import chalk14 from "chalk";
 import { checkbox } from "@inquirer/prompts";
 
 // src/link/claudecode.ts
 import path4 from "path";
-import fs4 from "fs";
+import fs5 from "fs";
 import os2 from "os";
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 import { confirm as confirm3 } from "@inquirer/prompts";
 var linkClaudeCode = async () => {
   const repoPath = resolveRepoPath();
@@ -837,32 +1115,32 @@ var linkClaudeCode = async () => {
   const buildMarketplace = () => {
     try {
       const marketplaceMetaDir = path4.join(CLAUDE_CODE_DIR, ".claude-plugin");
-      fs4.mkdirSync(marketplaceMetaDir, { recursive: true });
+      fs5.mkdirSync(marketplaceMetaDir, { recursive: true });
       const marketplaceJson = {
         name: MARKET_NAME,
         owner: { name: os2.userInfo().username },
         metadata: { description: "Managed by set-prompt", version: "1.0.0" },
         plugins: [{ name: PLUGIN_NAME, source: `./plugins/${PLUGIN_NAME}`, description: "Managed by set-prompt" }]
       };
-      fs4.writeFileSync(
+      fs5.writeFileSync(
         path4.join(marketplaceMetaDir, "marketplace.json"),
         JSON.stringify(marketplaceJson, null, 4),
         "utf-8"
       );
-      console.log(chalk5.dim("  \u251C\u2500\u2500 .claude-plugin/"));
-      console.log(chalk5.dim("  \u2502   \u2514\u2500\u2500 marketplace.json") + chalk5.green(" \u2713"));
+      console.log(chalk6.dim("  \u251C\u2500\u2500 .claude-plugin/"));
+      console.log(chalk6.dim("  \u2502   \u2514\u2500\u2500 marketplace.json") + chalk6.green(" \u2713"));
       const pluginLink = path4.join(CLAUDE_CODE_DIR, "plugins", PLUGIN_NAME);
-      fs4.mkdirSync(path4.dirname(pluginLink), { recursive: true });
-      if (fs4.existsSync(pluginLink)) {
-        fs4.rmSync(pluginLink, { recursive: true, force: true });
+      fs5.mkdirSync(path4.dirname(pluginLink), { recursive: true });
+      if (fs5.existsSync(pluginLink)) {
+        fs5.rmSync(pluginLink, { recursive: true, force: true });
       }
       const symlinkType = process.platform === "win32" ? "junction" : "dir";
-      fs4.symlinkSync(repoPath, pluginLink, symlinkType);
-      console.log(chalk5.dim("  \u2514\u2500\u2500 plugins/"));
-      console.log(chalk5.dim(`      \u2514\u2500\u2500 ${PLUGIN_NAME}/`) + chalk5.dim(` \u2192 ${repoPath}`) + chalk5.green(" \u2713"));
+      fs5.symlinkSync(repoPath, pluginLink, symlinkType);
+      console.log(chalk6.dim("  \u2514\u2500\u2500 plugins/"));
+      console.log(chalk6.dim(`      \u2514\u2500\u2500 ${PLUGIN_NAME}/`) + chalk6.dim(` \u2192 ${repoPath}`) + chalk6.green(" \u2713"));
       return true;
     } catch (ex) {
-      console.error(chalk5.red(`\u274C Failed to build marketplace structure: ${ex.message}`));
+      console.error(chalk6.red(`\u274C Failed to build marketplace structure: ${ex.message}`));
       return false;
     }
   };
@@ -870,18 +1148,18 @@ var linkClaudeCode = async () => {
     const claudeSettingsPath = path4.join(os2.homedir(), ".claude", "settings.json");
     try {
       let settings = {};
-      if (fs4.existsSync(claudeSettingsPath)) {
-        const raw = fs4.readFileSync(claudeSettingsPath, "utf-8");
+      if (fs5.existsSync(claudeSettingsPath)) {
+        const raw = fs5.readFileSync(claudeSettingsPath, "utf-8");
         try {
           const parsed = JSON.parse(raw);
           if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
             settings = parsed;
           } else {
-            console.warn(chalk5.yellow("  \u26A0 settings.json has unexpected format \u2014 proceeding with caution"));
+            console.warn(chalk6.yellow("  \u26A0 settings.json has unexpected format \u2014 proceeding with caution"));
           }
         } catch {
-          console.warn(chalk5.yellow("  \u26A0 Failed to parse settings.json \u2014 will not overwrite existing file"));
-          console.error(chalk5.red("\u274C Could not register plugin. Please add manually."));
+          console.warn(chalk6.yellow("  \u26A0 Failed to parse settings.json \u2014 will not overwrite existing file"));
+          console.error(chalk6.red("\u274C Could not register plugin. Please add manually."));
           return false;
         }
       }
@@ -894,43 +1172,43 @@ var linkClaudeCode = async () => {
         [`${PLUGIN_NAME}@${MARKET_NAME}`]: true
       };
       let backupPath = null;
-      if (fs4.existsSync(claudeSettingsPath)) {
+      if (fs5.existsSync(claudeSettingsPath)) {
         const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
         backupPath = `${claudeSettingsPath}.bak.${timestamp}`;
         try {
-          fs4.copyFileSync(claudeSettingsPath, backupPath);
+          fs5.copyFileSync(claudeSettingsPath, backupPath);
         } catch (ex) {
-          console.warn(chalk5.yellow(`  \u26A0 Could not create backup: ${ex.message}`));
+          console.warn(chalk6.yellow(`  \u26A0 Could not create backup: ${ex.message}`));
           backupPath = null;
         }
       }
       try {
-        fs4.mkdirSync(path4.dirname(claudeSettingsPath), { recursive: true });
-        fs4.writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 4), "utf-8");
+        fs5.mkdirSync(path4.dirname(claudeSettingsPath), { recursive: true });
+        fs5.writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 4), "utf-8");
       } catch (ex) {
         if (backupPath !== null) {
           try {
-            fs4.copyFileSync(backupPath, claudeSettingsPath);
-            fs4.unlinkSync(backupPath);
-            console.warn(chalk5.yellow("  \u26A0 Write failed \u2014 rolled back to original."));
+            fs5.copyFileSync(backupPath, claudeSettingsPath);
+            fs5.unlinkSync(backupPath);
+            console.warn(chalk6.yellow("  \u26A0 Write failed \u2014 rolled back to original."));
           } catch {
-            console.error(chalk5.red(`  \u274C Rollback failed. Backup preserved at: ${backupPath}`));
+            console.error(chalk6.red(`  \u274C Rollback failed. Backup preserved at: ${backupPath}`));
           }
         }
         throw ex;
       }
       if (backupPath !== null) {
         try {
-          fs4.unlinkSync(backupPath);
+          fs5.unlinkSync(backupPath);
         } catch {
         }
       }
       console.log(`\u2705 Registered to Claude Code settings.`);
-      console.log(chalk5.dim(`   ${claudeSettingsPath}`));
+      console.log(chalk6.dim(`   ${claudeSettingsPath}`));
       return true;
     } catch (ex) {
-      console.error(chalk5.red(`\u274C Failed to update settings.json: ${ex.message}`));
-      console.log(chalk5.dim("   Please add the plugin manually via Claude Code /plugins."));
+      console.error(chalk6.red(`\u274C Failed to update settings.json: ${ex.message}`));
+      console.log(chalk6.dim("   Please add the plugin manually via Claude Code /plugins."));
       return false;
     }
   };
@@ -940,9 +1218,9 @@ var linkClaudeCode = async () => {
     const pluginKey = `${PLUGIN_NAME}@${MARKET_NAME}`;
     try {
       let data = { version: 2, plugins: {} };
-      if (fs4.existsSync(installedPluginsPath)) {
+      if (fs5.existsSync(installedPluginsPath)) {
         try {
-          data = JSON.parse(fs4.readFileSync(installedPluginsPath, "utf-8"));
+          data = JSON.parse(fs5.readFileSync(installedPluginsPath, "utf-8"));
         } catch {
         }
       }
@@ -958,17 +1236,17 @@ var linkClaudeCode = async () => {
           lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
         }
       ];
-      fs4.mkdirSync(path4.dirname(installedPluginsPath), { recursive: true });
-      fs4.writeFileSync(installedPluginsPath, JSON.stringify(data, null, 4), "utf-8");
+      fs5.mkdirSync(path4.dirname(installedPluginsPath), { recursive: true });
+      fs5.writeFileSync(installedPluginsPath, JSON.stringify(data, null, 4), "utf-8");
       console.log(`\u2705 Patched installed_plugins.json \u2192 installPath points to source.`);
-      console.log(chalk5.dim(`   ${installPath}`));
+      console.log(chalk6.dim(`   ${installPath}`));
     } catch (ex) {
-      console.warn(chalk5.yellow(`  \u26A0 Could not patch installed_plugins.json: ${ex.message}`));
+      console.warn(chalk6.yellow(`  \u26A0 Could not patch installed_plugins.json: ${ex.message}`));
     }
   };
-  console.log(chalk5.green(`
+  console.log(chalk6.green(`
 Setting up Claude Code plugin...`));
-  console.log(chalk5.dim(CLAUDE_CODE_DIR));
+  console.log(chalk6.dim(CLAUDE_CODE_DIR));
   const marketplaceOk = buildMarketplace();
   if (marketplaceOk === false) {
     return;
@@ -988,20 +1266,20 @@ var unlinkClaudeCode = async (force = false) => {
       default: false
     });
     if (!ok) {
-      console.log(chalk5.yellow("Cancelled."));
+      console.log(chalk6.yellow("Cancelled."));
       return;
     }
   }
-  console.log(chalk5.red(`
+  console.log(chalk6.red(`
 Removing Claude Code plugin...`));
-  console.log(chalk5.dim(CLAUDE_CODE_DIR));
+  console.log(chalk6.dim(CLAUDE_CODE_DIR));
   const claudeSettingsPath = path4.join(os2.homedir(), ".claude", "settings.json");
-  if (fs4.existsSync(claudeSettingsPath)) {
+  if (fs5.existsSync(claudeSettingsPath)) {
     try {
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
       const backupPath = `${claudeSettingsPath}.bak.${timestamp}`;
-      fs4.copyFileSync(claudeSettingsPath, backupPath);
-      const settings = JSON.parse(fs4.readFileSync(claudeSettingsPath, "utf-8"));
+      fs5.copyFileSync(claudeSettingsPath, backupPath);
+      const settings = JSON.parse(fs5.readFileSync(claudeSettingsPath, "utf-8"));
       if (settings?.extraKnownMarketplaces?.[MARKET_NAME] !== void 0) {
         delete settings.extraKnownMarketplaces[MARKET_NAME];
       }
@@ -1009,26 +1287,26 @@ Removing Claude Code plugin...`));
         delete settings.enabledPlugins[`${PLUGIN_NAME}@${MARKET_NAME}`];
       }
       try {
-        fs4.writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 4), "utf-8");
-        fs4.unlinkSync(backupPath);
-        console.log(chalk5.red("  removed") + chalk5.dim(` set-prompt entries from: ${claudeSettingsPath}`));
+        fs5.writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 4), "utf-8");
+        fs5.unlinkSync(backupPath);
+        console.log(chalk6.red("  removed") + chalk6.dim(` set-prompt entries from: ${claudeSettingsPath}`));
       } catch (ex) {
-        fs4.copyFileSync(backupPath, claudeSettingsPath);
-        fs4.unlinkSync(backupPath);
-        console.warn(chalk5.yellow("  \u26A0 Write failed \u2014 rolled back to original."));
+        fs5.copyFileSync(backupPath, claudeSettingsPath);
+        fs5.unlinkSync(backupPath);
+        console.warn(chalk6.yellow("  \u26A0 Write failed \u2014 rolled back to original."));
       }
     } catch (ex) {
-      console.error(chalk5.red(`  \u274C Failed to clean up settings.json: ${ex.message}`));
+      console.error(chalk6.red(`  \u274C Failed to clean up settings.json: ${ex.message}`));
     }
   }
   const claudePluginsDir = path4.join(os2.homedir(), ".claude", "plugins");
   const installedPluginsPath = path4.join(claudePluginsDir, "installed_plugins.json");
-  if (fs4.existsSync(installedPluginsPath)) {
+  if (fs5.existsSync(installedPluginsPath)) {
     try {
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
       const backupPath = `${installedPluginsPath}.bak.${timestamp}`;
-      fs4.copyFileSync(installedPluginsPath, backupPath);
-      const installed = JSON.parse(fs4.readFileSync(installedPluginsPath, "utf-8"));
+      fs5.copyFileSync(installedPluginsPath, backupPath);
+      const installed = JSON.parse(fs5.readFileSync(installedPluginsPath, "utf-8"));
       if (installed?.plugins && typeof installed.plugins === "object") {
         for (const key of Object.keys(installed.plugins)) {
           if (key.endsWith(`@${MARKET_NAME}`)) {
@@ -1037,44 +1315,44 @@ Removing Claude Code plugin...`));
         }
       }
       try {
-        fs4.writeFileSync(installedPluginsPath, JSON.stringify(installed, null, 4), "utf-8");
-        fs4.unlinkSync(backupPath);
-        console.log(chalk5.red("  removed") + chalk5.dim(` set-prompt entries from: ${installedPluginsPath}`));
+        fs5.writeFileSync(installedPluginsPath, JSON.stringify(installed, null, 4), "utf-8");
+        fs5.unlinkSync(backupPath);
+        console.log(chalk6.red("  removed") + chalk6.dim(` set-prompt entries from: ${installedPluginsPath}`));
       } catch (ex) {
-        fs4.copyFileSync(backupPath, installedPluginsPath);
-        fs4.unlinkSync(backupPath);
-        console.warn(chalk5.yellow("  \u26A0 Write failed \u2014 rolled back installed_plugins.json."));
+        fs5.copyFileSync(backupPath, installedPluginsPath);
+        fs5.unlinkSync(backupPath);
+        console.warn(chalk6.yellow("  \u26A0 Write failed \u2014 rolled back installed_plugins.json."));
       }
     } catch (ex) {
-      console.error(chalk5.red(`  \u274C Failed to clean up installed_plugins.json: ${ex.message}`));
+      console.error(chalk6.red(`  \u274C Failed to clean up installed_plugins.json: ${ex.message}`));
     }
   }
   const knownMarketplacesPath = path4.join(claudePluginsDir, "known_marketplaces.json");
-  if (fs4.existsSync(knownMarketplacesPath)) {
+  if (fs5.existsSync(knownMarketplacesPath)) {
     try {
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
       const backupPath = `${knownMarketplacesPath}.bak.${timestamp}`;
-      fs4.copyFileSync(knownMarketplacesPath, backupPath);
-      const marketplaces = JSON.parse(fs4.readFileSync(knownMarketplacesPath, "utf-8"));
+      fs5.copyFileSync(knownMarketplacesPath, backupPath);
+      const marketplaces = JSON.parse(fs5.readFileSync(knownMarketplacesPath, "utf-8"));
       if (marketplaces?.[MARKET_NAME] !== void 0) {
         delete marketplaces[MARKET_NAME];
       }
       try {
-        fs4.writeFileSync(knownMarketplacesPath, JSON.stringify(marketplaces, null, 4), "utf-8");
-        fs4.unlinkSync(backupPath);
-        console.log(chalk5.red("  removed") + chalk5.dim(` set-prompt entry from: ${knownMarketplacesPath}`));
+        fs5.writeFileSync(knownMarketplacesPath, JSON.stringify(marketplaces, null, 4), "utf-8");
+        fs5.unlinkSync(backupPath);
+        console.log(chalk6.red("  removed") + chalk6.dim(` set-prompt entry from: ${knownMarketplacesPath}`));
       } catch (ex) {
-        fs4.copyFileSync(backupPath, knownMarketplacesPath);
-        fs4.unlinkSync(backupPath);
-        console.warn(chalk5.yellow("  \u26A0 Write failed \u2014 rolled back known_marketplaces.json."));
+        fs5.copyFileSync(backupPath, knownMarketplacesPath);
+        fs5.unlinkSync(backupPath);
+        console.warn(chalk6.yellow("  \u26A0 Write failed \u2014 rolled back known_marketplaces.json."));
       }
     } catch (ex) {
-      console.error(chalk5.red(`  \u274C Failed to clean up known_marketplaces.json: ${ex.message}`));
+      console.error(chalk6.red(`  \u274C Failed to clean up known_marketplaces.json: ${ex.message}`));
     }
   }
-  if (fs4.existsSync(CLAUDE_CODE_DIR)) {
-    fs4.rmSync(CLAUDE_CODE_DIR, { recursive: true, force: true });
-    console.log(chalk5.red("  removed") + chalk5.dim(`: ${CLAUDE_CODE_DIR}`));
+  if (fs5.existsSync(CLAUDE_CODE_DIR)) {
+    fs5.rmSync(CLAUDE_CODE_DIR, { recursive: true, force: true });
+    console.log(chalk6.red("  removed") + chalk6.dim(`: ${CLAUDE_CODE_DIR}`));
   }
   configManager.claude_code = null;
   configManager.save();
@@ -1082,8 +1360,8 @@ Removing Claude Code plugin...`));
 
 // src/link/roocode.ts
 import path5 from "path";
-import fs5 from "fs";
-import chalk6 from "chalk";
+import fs6 from "fs";
+import chalk7 from "chalk";
 import { confirm as confirm4 } from "@inquirer/prompts";
 import { pathExists } from "fs-extra";
 var linkRooCode = async () => {
@@ -1091,44 +1369,44 @@ var linkRooCode = async () => {
   if (repoPath == null) {
     return;
   }
-  console.log(chalk6.green(`
+  console.log(chalk7.green(`
 Setting up RooCode integration...`));
-  console.log(chalk6.dim(ROO_DIR));
+  console.log(chalk7.dim(ROO_DIR));
   const roocodeDirs = AGENT_PROMPT_DIRS["roocode" /* ROOCODE */];
   const backupExistingRooCodeFiles = async () => {
     try {
-      fs5.mkdirSync(ROO_DIR, { recursive: true });
+      fs6.mkdirSync(ROO_DIR, { recursive: true });
       const dirsToBackup = [];
       for (const dir of roocodeDirs) {
         const target = path5.join(ROO_DIR, dir);
-        if (fs5.existsSync(target) && fs5.lstatSync(target).isSymbolicLink() === false && fs5.readdirSync(target).length > 0) {
+        if (fs6.existsSync(target) && fs6.lstatSync(target).isSymbolicLink() === false && fs6.readdirSync(target).length > 0) {
           dirsToBackup.push(dir);
         }
       }
       if (dirsToBackup.length === 0) {
         return true;
       }
-      console.log(chalk6.yellow(`
+      console.log(chalk7.yellow(`
   \u26A0 The following existing directories will be replaced by symlinks:`));
       for (const dir of dirsToBackup) {
-        console.log(chalk6.dim(`    - ${path5.join(ROO_DIR, dir)}`));
+        console.log(chalk7.dim(`    - ${path5.join(ROO_DIR, dir)}`));
       }
-      console.log(chalk6.yellow(`  They will be backed up to: `) + chalk6.dim(ROO_BACKUP_DIR));
+      console.log(chalk7.yellow(`  They will be backed up to: `) + chalk7.dim(ROO_BACKUP_DIR));
       const ok = await confirm4({ message: "Back up existing directories?", default: true });
       if (!ok) {
-        console.log(chalk6.yellow("Skipped RooCode linking."));
+        console.log(chalk7.yellow("Skipped RooCode linking."));
         return false;
       }
-      fs5.mkdirSync(ROO_BACKUP_DIR, { recursive: true });
+      fs6.mkdirSync(ROO_BACKUP_DIR, { recursive: true });
       for (const dir of dirsToBackup) {
         const src = path5.join(ROO_DIR, dir);
         const dest = path5.join(ROO_BACKUP_DIR, dir);
-        fs5.renameSync(src, dest);
-        console.log(chalk6.yellow("  backed up") + chalk6.dim(`: ${dir}/ \u2192 ${dest}`));
+        fs6.renameSync(src, dest);
+        console.log(chalk7.yellow("  backed up") + chalk7.dim(`: ${dir}/ \u2192 ${dest}`));
       }
       return true;
     } catch (ex) {
-      console.error(chalk6.red(`\u274C Failed to backup existing directories: ${ex.message}`));
+      console.error(chalk7.red(`\u274C Failed to backup existing directories: ${ex.message}`));
       return false;
     }
   };
@@ -1141,21 +1419,21 @@ Setting up RooCode integration...`));
         if (await pathExists(src) === false) {
           continue;
         }
-        if (fs5.existsSync(dest)) {
-          fs5.rmSync(dest, { recursive: true, force: true });
+        if (fs6.existsSync(dest)) {
+          fs6.rmSync(dest, { recursive: true, force: true });
         }
         const symlinkType = process.platform === "win32" ? "junction" : "dir";
-        fs5.symlinkSync(src, dest, symlinkType);
+        fs6.symlinkSync(src, dest, symlinkType);
         linked.push({ dir, src });
       }
       for (const { dir, src } of linked) {
         const isLast = linked[linked.length - 1].dir === dir;
         const branch = isLast ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
-        console.log(chalk6.dim(`  ${branch} `) + chalk6.bold(`${dir}/`) + chalk6.dim(` \u2192 ${src}`) + chalk6.green(" \u2713"));
+        console.log(chalk7.dim(`  ${branch} `) + chalk7.bold(`${dir}/`) + chalk7.dim(` \u2192 ${src}`) + chalk7.green(" \u2713"));
       }
       return true;
     } catch (ex) {
-      console.error(chalk6.red(`\u274C Failed to create symlinks: ${ex.message}`));
+      console.error(chalk7.red(`\u274C Failed to create symlinks: ${ex.message}`));
       return false;
     }
   };
@@ -1177,35 +1455,35 @@ var unlinkRooCode = async (force = false) => {
       default: false
     });
     if (!ok) {
-      console.log(chalk6.yellow("Cancelled."));
+      console.log(chalk7.yellow("Cancelled."));
       return;
     }
   }
-  console.log(chalk6.red(`
+  console.log(chalk7.red(`
 Removing RooCode integration...`));
-  console.log(chalk6.dim(ROO_DIR));
+  console.log(chalk7.dim(ROO_DIR));
   const backupPath = configManager.roocode?.backup_path ?? ROO_BACKUP_DIR;
   for (const dir of AGENT_PROMPT_DIRS["roocode" /* ROOCODE */]) {
     const target = path5.join(ROO_DIR, dir);
-    if (fs5.existsSync(target) && fs5.lstatSync(target).isSymbolicLink()) {
-      fs5.unlinkSync(target);
-      console.log(chalk6.red("  removed symlink") + chalk6.dim(`: ${target}`));
+    if (fs6.existsSync(target) && fs6.lstatSync(target).isSymbolicLink()) {
+      fs6.unlinkSync(target);
+      console.log(chalk7.red("  removed symlink") + chalk7.dim(`: ${target}`));
     }
   }
-  if (fs5.existsSync(backupPath)) {
+  if (fs6.existsSync(backupPath)) {
     try {
       for (const dir of AGENT_PROMPT_DIRS["roocode" /* ROOCODE */]) {
         const src = path5.join(backupPath, dir);
         const dest = path5.join(ROO_DIR, dir);
-        if (!fs5.existsSync(src)) {
+        if (!fs6.existsSync(src)) {
           continue;
         }
-        fs5.renameSync(src, dest);
-        console.log(chalk6.green("  restored") + chalk6.dim(`: ${dir}/`));
+        fs6.renameSync(src, dest);
+        console.log(chalk7.green("  restored") + chalk7.dim(`: ${dir}/`));
       }
-      fs5.rmdirSync(backupPath);
+      fs6.rmdirSync(backupPath);
     } catch (ex) {
-      console.error(chalk6.red(`  \u274C Failed to restore RooCode backup: ${ex.message}`));
+      console.error(chalk7.red(`  \u274C Failed to restore RooCode backup: ${ex.message}`));
     }
   }
   configManager.roocode = null;
@@ -1214,8 +1492,8 @@ Removing RooCode integration...`));
 
 // src/link/openclaw.ts
 import path6 from "path";
-import fs6 from "fs";
-import chalk7 from "chalk";
+import fs7 from "fs";
+import chalk8 from "chalk";
 import { confirm as confirm5 } from "@inquirer/prompts";
 import { pathExists as pathExists2 } from "fs-extra";
 var linkOpenclaw = async () => {
@@ -1223,44 +1501,44 @@ var linkOpenclaw = async () => {
   if (repoPath == null) {
     return;
   }
-  console.log(chalk7.green(`
+  console.log(chalk8.green(`
 Setting up OpenClaw integration...`));
-  console.log(chalk7.dim(OPENCLAW_DIR));
+  console.log(chalk8.dim(OPENCLAW_DIR));
   const openclawDirs = AGENT_PROMPT_DIRS["openclaw" /* OPENCLAW */];
   const backupExistingOpenclawFiles = async () => {
     try {
-      fs6.mkdirSync(OPENCLAW_DIR, { recursive: true });
+      fs7.mkdirSync(OPENCLAW_DIR, { recursive: true });
       const dirsToBackup = [];
       for (const dir of openclawDirs) {
         const target = path6.join(OPENCLAW_DIR, dir);
-        if (fs6.existsSync(target) && fs6.lstatSync(target).isSymbolicLink() === false && fs6.readdirSync(target).length > 0) {
+        if (fs7.existsSync(target) && fs7.lstatSync(target).isSymbolicLink() === false && fs7.readdirSync(target).length > 0) {
           dirsToBackup.push(dir);
         }
       }
       if (dirsToBackup.length === 0) {
         return true;
       }
-      console.log(chalk7.yellow(`
+      console.log(chalk8.yellow(`
   \u26A0 The following existing directories will be replaced by symlinks:`));
       for (const dir of dirsToBackup) {
-        console.log(chalk7.dim(`    - ${path6.join(OPENCLAW_DIR, dir)}`));
+        console.log(chalk8.dim(`    - ${path6.join(OPENCLAW_DIR, dir)}`));
       }
-      console.log(chalk7.yellow(`  They will be backed up to: `) + chalk7.dim(OPENCLAW_BACKUP_DIR));
+      console.log(chalk8.yellow(`  They will be backed up to: `) + chalk8.dim(OPENCLAW_BACKUP_DIR));
       const ok = await confirm5({ message: "Back up existing directories?", default: true });
       if (!ok) {
-        console.log(chalk7.yellow("Skipped OpenClaw linking."));
+        console.log(chalk8.yellow("Skipped OpenClaw linking."));
         return false;
       }
-      fs6.mkdirSync(OPENCLAW_BACKUP_DIR, { recursive: true });
+      fs7.mkdirSync(OPENCLAW_BACKUP_DIR, { recursive: true });
       for (const dir of dirsToBackup) {
         const src = path6.join(OPENCLAW_DIR, dir);
         const dest = path6.join(OPENCLAW_BACKUP_DIR, dir);
-        fs6.renameSync(src, dest);
-        console.log(chalk7.yellow("  backed up") + chalk7.dim(`: ${dir}/ \u2192 ${dest}`));
+        fs7.renameSync(src, dest);
+        console.log(chalk8.yellow("  backed up") + chalk8.dim(`: ${dir}/ \u2192 ${dest}`));
       }
       return true;
     } catch (ex) {
-      console.error(chalk7.red(`\u274C Failed to backup existing directories: ${ex.message}`));
+      console.error(chalk8.red(`\u274C Failed to backup existing directories: ${ex.message}`));
       return false;
     }
   };
@@ -1273,21 +1551,21 @@ Setting up OpenClaw integration...`));
         if (await pathExists2(src) === false) {
           continue;
         }
-        if (fs6.existsSync(dest)) {
-          fs6.rmSync(dest, { recursive: true, force: true });
+        if (fs7.existsSync(dest)) {
+          fs7.rmSync(dest, { recursive: true, force: true });
         }
         const symlinkType = process.platform === "win32" ? "junction" : "dir";
-        fs6.symlinkSync(src, dest, symlinkType);
+        fs7.symlinkSync(src, dest, symlinkType);
         linked.push({ dir, src });
       }
       for (const { dir, src } of linked) {
         const isLast = linked[linked.length - 1].dir === dir;
         const branch = isLast ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
-        console.log(chalk7.dim(`  ${branch} `) + chalk7.bold(`${dir}/`) + chalk7.dim(` \u2192 ${src}`) + chalk7.green(" \u2713"));
+        console.log(chalk8.dim(`  ${branch} `) + chalk8.bold(`${dir}/`) + chalk8.dim(` \u2192 ${src}`) + chalk8.green(" \u2713"));
       }
       return true;
     } catch (ex) {
-      console.error(chalk7.red(`\u274C Failed to create symlinks: ${ex.message}`));
+      console.error(chalk8.red(`\u274C Failed to create symlinks: ${ex.message}`));
       return false;
     }
   };
@@ -1309,35 +1587,35 @@ var unlinkOpenclaw = async (force = false) => {
       default: false
     });
     if (!ok) {
-      console.log(chalk7.yellow("Cancelled."));
+      console.log(chalk8.yellow("Cancelled."));
       return;
     }
   }
-  console.log(chalk7.red(`
+  console.log(chalk8.red(`
 Removing OpenClaw integration...`));
-  console.log(chalk7.dim(OPENCLAW_DIR));
+  console.log(chalk8.dim(OPENCLAW_DIR));
   const backupPath = configManager.openclaw?.backup_path ?? OPENCLAW_BACKUP_DIR;
   for (const dir of AGENT_PROMPT_DIRS["openclaw" /* OPENCLAW */]) {
     const target = path6.join(OPENCLAW_DIR, dir);
-    if (fs6.existsSync(target) && fs6.lstatSync(target).isSymbolicLink()) {
-      fs6.unlinkSync(target);
-      console.log(chalk7.red("  removed symlink") + chalk7.dim(`: ${target}`));
+    if (fs7.existsSync(target) && fs7.lstatSync(target).isSymbolicLink()) {
+      fs7.unlinkSync(target);
+      console.log(chalk8.red("  removed symlink") + chalk8.dim(`: ${target}`));
     }
   }
-  if (fs6.existsSync(backupPath)) {
+  if (fs7.existsSync(backupPath)) {
     try {
       for (const dir of AGENT_PROMPT_DIRS["openclaw" /* OPENCLAW */]) {
         const src = path6.join(backupPath, dir);
         const dest = path6.join(OPENCLAW_DIR, dir);
-        if (!fs6.existsSync(src)) {
+        if (!fs7.existsSync(src)) {
           continue;
         }
-        fs6.renameSync(src, dest);
-        console.log(chalk7.green("  restored") + chalk7.dim(`: ${dir}/`));
+        fs7.renameSync(src, dest);
+        console.log(chalk8.green("  restored") + chalk8.dim(`: ${dir}/`));
       }
-      fs6.rmdirSync(backupPath);
+      fs7.rmdirSync(backupPath);
     } catch (ex) {
-      console.error(chalk7.red(`  \u274C Failed to restore OpenClaw backup: ${ex.message}`));
+      console.error(chalk8.red(`  \u274C Failed to restore OpenClaw backup: ${ex.message}`));
     }
   }
   configManager.openclaw = null;
@@ -1346,8 +1624,8 @@ Removing OpenClaw integration...`));
 
 // src/link/antigravity.ts
 import path7 from "path";
-import fs7 from "fs";
-import chalk8 from "chalk";
+import fs8 from "fs";
+import chalk9 from "chalk";
 import { confirm as confirm6 } from "@inquirer/prompts";
 import { pathExists as pathExists3 } from "fs-extra";
 var linkAntigravity = async () => {
@@ -1355,44 +1633,44 @@ var linkAntigravity = async () => {
   if (repoPath == null) {
     return;
   }
-  console.log(chalk8.green(`
+  console.log(chalk9.green(`
 Setting up Antigravity integration...`));
-  console.log(chalk8.dim(ANTIGRAVITY_DIR));
+  console.log(chalk9.dim(ANTIGRAVITY_DIR));
   const antigravityDirs = AGENT_PROMPT_DIRS["antigravity" /* ANTIGRAVITY */];
   const backupExistingAntigravityFiles = async () => {
     try {
-      fs7.mkdirSync(ANTIGRAVITY_DIR, { recursive: true });
+      fs8.mkdirSync(ANTIGRAVITY_DIR, { recursive: true });
       const dirsToBackup = [];
       for (const dir of antigravityDirs) {
         const target = path7.join(ANTIGRAVITY_DIR, dir);
-        if (fs7.existsSync(target) && fs7.lstatSync(target).isSymbolicLink() === false && fs7.readdirSync(target).length > 0) {
+        if (fs8.existsSync(target) && fs8.lstatSync(target).isSymbolicLink() === false && fs8.readdirSync(target).length > 0) {
           dirsToBackup.push(dir);
         }
       }
       if (dirsToBackup.length === 0) {
         return true;
       }
-      console.log(chalk8.yellow(`
+      console.log(chalk9.yellow(`
   \u26A0 The following existing directories will be replaced by symlinks:`));
       for (const dir of dirsToBackup) {
-        console.log(chalk8.dim(`    - ${path7.join(ANTIGRAVITY_DIR, dir)}`));
+        console.log(chalk9.dim(`    - ${path7.join(ANTIGRAVITY_DIR, dir)}`));
       }
-      console.log(chalk8.yellow(`  They will be backed up to: `) + chalk8.dim(ANTIGRAVITY_BACKUP_DIR));
+      console.log(chalk9.yellow(`  They will be backed up to: `) + chalk9.dim(ANTIGRAVITY_BACKUP_DIR));
       const ok = await confirm6({ message: "Back up existing directories?", default: true });
       if (!ok) {
-        console.log(chalk8.yellow("Skipped Antigravity linking."));
+        console.log(chalk9.yellow("Skipped Antigravity linking."));
         return false;
       }
-      fs7.mkdirSync(ANTIGRAVITY_BACKUP_DIR, { recursive: true });
+      fs8.mkdirSync(ANTIGRAVITY_BACKUP_DIR, { recursive: true });
       for (const dir of antigravityDirs) {
         const src = path7.join(ANTIGRAVITY_DIR, dir);
         const dest = path7.join(ANTIGRAVITY_BACKUP_DIR, dir);
-        fs7.renameSync(src, dest);
-        console.log(chalk8.yellow("  backed up") + chalk8.dim(`: ${dir}/ \u2192 ${dest}`));
+        fs8.renameSync(src, dest);
+        console.log(chalk9.yellow("  backed up") + chalk9.dim(`: ${dir}/ \u2192 ${dest}`));
       }
       return true;
     } catch (ex) {
-      console.error(chalk8.red(`\u274C Failed to backup existing directories: ${ex.message}`));
+      console.error(chalk9.red(`\u274C Failed to backup existing directories: ${ex.message}`));
       return false;
     }
   };
@@ -1405,21 +1683,21 @@ Setting up Antigravity integration...`));
         if (await pathExists3(src) === false) {
           continue;
         }
-        if (fs7.existsSync(dest)) {
-          fs7.rmSync(dest, { recursive: true, force: true });
+        if (fs8.existsSync(dest)) {
+          fs8.rmSync(dest, { recursive: true, force: true });
         }
         const symlinkType = process.platform === "win32" ? "junction" : "dir";
-        fs7.symlinkSync(src, dest, symlinkType);
+        fs8.symlinkSync(src, dest, symlinkType);
         linked.push({ dir, src });
       }
       for (const { dir, src } of linked) {
         const isLast = linked[linked.length - 1].dir === dir;
         const branch = isLast ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
-        console.log(chalk8.dim(`  ${branch} `) + chalk8.bold(`${dir}/`) + chalk8.dim(` \u2192 ${src}`) + chalk8.green(" \u2713"));
+        console.log(chalk9.dim(`  ${branch} `) + chalk9.bold(`${dir}/`) + chalk9.dim(` \u2192 ${src}`) + chalk9.green(" \u2713"));
       }
       return true;
     } catch (ex) {
-      console.error(chalk8.red(`\u274C Failed to create symlinks: ${ex.message}`));
+      console.error(chalk9.red(`\u274C Failed to create symlinks: ${ex.message}`));
       return false;
     }
   };
@@ -1441,35 +1719,35 @@ var unlinkAntigravity = async (force = false) => {
       default: false
     });
     if (!ok) {
-      console.log(chalk8.yellow("Cancelled."));
+      console.log(chalk9.yellow("Cancelled."));
       return;
     }
   }
-  console.log(chalk8.red(`
+  console.log(chalk9.red(`
 Removing Antigravity integration...`));
-  console.log(chalk8.dim(ANTIGRAVITY_DIR));
+  console.log(chalk9.dim(ANTIGRAVITY_DIR));
   const backupPath = configManager.antigravity?.backup_path ?? ANTIGRAVITY_BACKUP_DIR;
   for (const dir of AGENT_PROMPT_DIRS["antigravity" /* ANTIGRAVITY */]) {
     const target = path7.join(ANTIGRAVITY_DIR, dir);
-    if (fs7.existsSync(target) && fs7.lstatSync(target).isSymbolicLink()) {
-      fs7.unlinkSync(target);
-      console.log(chalk8.red("  removed symlink") + chalk8.dim(`: ${target}`));
+    if (fs8.existsSync(target) && fs8.lstatSync(target).isSymbolicLink()) {
+      fs8.unlinkSync(target);
+      console.log(chalk9.red("  removed symlink") + chalk9.dim(`: ${target}`));
     }
   }
-  if (fs7.existsSync(backupPath)) {
+  if (fs8.existsSync(backupPath)) {
     try {
       for (const dir of AGENT_PROMPT_DIRS["antigravity" /* ANTIGRAVITY */]) {
         const src = path7.join(backupPath, dir);
         const dest = path7.join(ANTIGRAVITY_DIR, dir);
-        if (!fs7.existsSync(src)) {
+        if (!fs8.existsSync(src)) {
           continue;
         }
-        fs7.renameSync(src, dest);
-        console.log(chalk8.green("  restored") + chalk8.dim(`: ${dir}/`));
+        fs8.renameSync(src, dest);
+        console.log(chalk9.green("  restored") + chalk9.dim(`: ${dir}/`));
       }
-      fs7.rmdirSync(backupPath);
+      fs8.rmdirSync(backupPath);
     } catch (ex) {
-      console.error(chalk8.red(`  \u274C Failed to restore Antigravity backup: ${ex.message}`));
+      console.error(chalk9.red(`  \u274C Failed to restore Antigravity backup: ${ex.message}`));
     }
   }
   configManager.antigravity = null;
@@ -1478,9 +1756,9 @@ Removing Antigravity integration...`));
 
 // src/link/codex.ts
 import path8 from "path";
-import fs8 from "fs";
+import fs9 from "fs";
 import os3 from "os";
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 import { confirm as confirm7 } from "@inquirer/prompts";
 import TOML from "smol-toml";
 var CODEX_AGENTS_DIR = path8.join(os3.homedir(), ".agents", "plugins");
@@ -1502,16 +1780,16 @@ var linkCodex = async () => {
         interface: { displayName: "Local Repository" },
         plugins: []
       };
-      if (fs8.existsSync(marketplacePath)) {
-        const raw = fs8.readFileSync(marketplacePath, "utf-8");
+      if (fs9.existsSync(marketplacePath)) {
+        const raw = fs9.readFileSync(marketplacePath, "utf-8");
         try {
           const parsed = JSON.parse(raw);
           if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
             marketplace = parsed;
           }
         } catch {
-          console.warn(chalk9.yellow("  \u26A0 Failed to parse marketplace.json \u2014 will not overwrite existing file"));
-          console.error(chalk9.red("\u274C Could not register plugin. Please add manually."));
+          console.warn(chalk10.yellow("  \u26A0 Failed to parse marketplace.json \u2014 will not overwrite existing file"));
+          console.error(chalk10.red("\u274C Could not register plugin. Please add manually."));
           return false;
         }
       }
@@ -1534,58 +1812,58 @@ var linkCodex = async () => {
         category: "Productivity"
       });
       let backupPath = null;
-      if (fs8.existsSync(marketplacePath)) {
+      if (fs9.existsSync(marketplacePath)) {
         const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
         backupPath = `${marketplacePath}.bak.${timestamp}`;
         try {
-          fs8.copyFileSync(marketplacePath, backupPath);
+          fs9.copyFileSync(marketplacePath, backupPath);
         } catch (ex) {
-          console.warn(chalk9.yellow(`  \u26A0 Could not create backup: ${ex.message}`));
+          console.warn(chalk10.yellow(`  \u26A0 Could not create backup: ${ex.message}`));
           backupPath = null;
         }
       }
       try {
-        fs8.mkdirSync(path8.dirname(marketplacePath), { recursive: true });
-        fs8.writeFileSync(marketplacePath, JSON.stringify(marketplace, null, 4), "utf-8");
+        fs9.mkdirSync(path8.dirname(marketplacePath), { recursive: true });
+        fs9.writeFileSync(marketplacePath, JSON.stringify(marketplace, null, 4), "utf-8");
       } catch (ex) {
         if (backupPath !== null) {
           try {
-            fs8.copyFileSync(backupPath, marketplacePath);
-            fs8.unlinkSync(backupPath);
-            console.warn(chalk9.yellow("  \u26A0 Write failed \u2014 rolled back to original."));
+            fs9.copyFileSync(backupPath, marketplacePath);
+            fs9.unlinkSync(backupPath);
+            console.warn(chalk10.yellow("  \u26A0 Write failed \u2014 rolled back to original."));
           } catch {
-            console.error(chalk9.red(`  \u274C Rollback failed. Backup preserved at: ${backupPath}`));
+            console.error(chalk10.red(`  \u274C Rollback failed. Backup preserved at: ${backupPath}`));
           }
         }
         throw ex;
       }
       if (backupPath !== null) {
         try {
-          fs8.unlinkSync(backupPath);
+          fs9.unlinkSync(backupPath);
         } catch {
         }
       }
       console.log(`\u2705 Registered to marketplace.json`);
-      console.log(chalk9.dim(`   ${marketplacePath}`));
+      console.log(chalk10.dim(`   ${marketplacePath}`));
       return true;
     } catch (ex) {
-      console.error(chalk9.red(`\u274C Failed to update marketplace.json: ${ex.message}`));
+      console.error(chalk10.red(`\u274C Failed to update marketplace.json: ${ex.message}`));
       return false;
     }
   };
   const patchPluginCache = () => {
     const cachePath = path8.join(CODEX_CACHE_DIR, CODEX_MARKETPLACE_NAME, PLUGIN_NAME, "1.0.0");
     try {
-      fs8.mkdirSync(path8.dirname(cachePath), { recursive: true });
-      if (fs8.existsSync(cachePath)) {
-        fs8.rmSync(cachePath, { recursive: true, force: true });
+      fs9.mkdirSync(path8.dirname(cachePath), { recursive: true });
+      if (fs9.existsSync(cachePath)) {
+        fs9.rmSync(cachePath, { recursive: true, force: true });
       }
       const symlinkType = process.platform === "win32" ? "junction" : "dir";
-      fs8.symlinkSync(repoPath, cachePath, symlinkType);
+      fs9.symlinkSync(repoPath, cachePath, symlinkType);
       console.log(`\u2705 Patched plugin cache.`);
-      console.log(chalk9.dim(`   ${cachePath}`) + chalk9.dim(" \u2192 ") + chalk9.dim(repoPath));
+      console.log(chalk10.dim(`   ${cachePath}`) + chalk10.dim(" \u2192 ") + chalk10.dim(repoPath));
     } catch (ex) {
-      console.warn(chalk9.yellow(`  \u26A0 Could not patch plugin cache: ${ex.message}`));
+      console.warn(chalk10.yellow(`  \u26A0 Could not patch plugin cache: ${ex.message}`));
     }
   };
   const enableInConfig = () => {
@@ -1593,22 +1871,22 @@ var linkCodex = async () => {
     const pluginKey = `${PLUGIN_NAME}@${CODEX_MARKETPLACE_NAME}`;
     try {
       let config = {};
-      if (fs8.existsSync(configPath)) {
-        config = TOML.parse(fs8.readFileSync(configPath, "utf-8"));
+      if (fs9.existsSync(configPath)) {
+        config = TOML.parse(fs9.readFileSync(configPath, "utf-8"));
       }
       if (config.plugins == null) {
         config.plugins = {};
       }
       config.plugins[pluginKey] = { enabled: true };
-      fs8.mkdirSync(path8.dirname(configPath), { recursive: true });
-      fs8.writeFileSync(configPath, TOML.stringify(config), "utf-8");
+      fs9.mkdirSync(path8.dirname(configPath), { recursive: true });
+      fs9.writeFileSync(configPath, TOML.stringify(config), "utf-8");
       console.log(`\u2705 Enabled plugin in config.toml`);
-      console.log(chalk9.dim(`   ${configPath}`));
+      console.log(chalk10.dim(`   ${configPath}`));
     } catch (ex) {
-      console.warn(chalk9.yellow(`  \u26A0 Could not update config.toml: ${ex.message}`));
+      console.warn(chalk10.yellow(`  \u26A0 Could not update config.toml: ${ex.message}`));
     }
   };
-  console.log(chalk9.green(`
+  console.log(chalk10.green(`
 Setting up Codex plugin...`));
   const marketplaceOk = registerToMarketplace();
   if (marketplaceOk === false) {
@@ -1626,55 +1904,55 @@ var unlinkCodex = async (force = false) => {
       default: false
     });
     if (!ok) {
-      console.log(chalk9.yellow("Cancelled."));
+      console.log(chalk10.yellow("Cancelled."));
       return;
     }
   }
-  console.log(chalk9.red(`
+  console.log(chalk10.red(`
 Removing Codex plugin...`));
   const marketplacePath = path8.join(CODEX_AGENTS_DIR, "marketplace.json");
-  if (fs8.existsSync(marketplacePath)) {
+  if (fs9.existsSync(marketplacePath)) {
     try {
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
       const backupPath = `${marketplacePath}.bak.${timestamp}`;
-      fs8.copyFileSync(marketplacePath, backupPath);
-      const marketplace = JSON.parse(fs8.readFileSync(marketplacePath, "utf-8"));
+      fs9.copyFileSync(marketplacePath, backupPath);
+      const marketplace = JSON.parse(fs9.readFileSync(marketplacePath, "utf-8"));
       if (Array.isArray(marketplace?.plugins)) {
         marketplace.plugins = marketplace.plugins.filter(
           (p) => p?.name !== PLUGIN_NAME
         );
       }
       try {
-        fs8.writeFileSync(marketplacePath, JSON.stringify(marketplace, null, 4), "utf-8");
-        fs8.unlinkSync(backupPath);
-        console.log(chalk9.red("  removed") + chalk9.dim(` ${PLUGIN_NAME} from: ${marketplacePath}`));
+        fs9.writeFileSync(marketplacePath, JSON.stringify(marketplace, null, 4), "utf-8");
+        fs9.unlinkSync(backupPath);
+        console.log(chalk10.red("  removed") + chalk10.dim(` ${PLUGIN_NAME} from: ${marketplacePath}`));
       } catch (ex) {
-        fs8.copyFileSync(backupPath, marketplacePath);
-        fs8.unlinkSync(backupPath);
-        console.warn(chalk9.yellow("  \u26A0 Write failed \u2014 rolled back to original."));
+        fs9.copyFileSync(backupPath, marketplacePath);
+        fs9.unlinkSync(backupPath);
+        console.warn(chalk10.yellow("  \u26A0 Write failed \u2014 rolled back to original."));
       }
     } catch (ex) {
-      console.error(chalk9.red(`  \u274C Failed to clean up marketplace.json: ${ex.message}`));
+      console.error(chalk10.red(`  \u274C Failed to clean up marketplace.json: ${ex.message}`));
     }
   }
   const configPath = path8.join(os3.homedir(), ".codex", "config.toml");
-  if (fs8.existsSync(configPath)) {
+  if (fs9.existsSync(configPath)) {
     try {
-      const config = TOML.parse(fs8.readFileSync(configPath, "utf-8"));
+      const config = TOML.parse(fs9.readFileSync(configPath, "utf-8"));
       const pluginKey = `${PLUGIN_NAME}@${CODEX_MARKETPLACE_NAME}`;
       if (config.plugins?.[pluginKey] !== void 0) {
         delete config.plugins[pluginKey];
-        fs8.writeFileSync(configPath, TOML.stringify(config), "utf-8");
-        console.log(chalk9.red("  removed") + chalk9.dim(` ${pluginKey} from: ${configPath}`));
+        fs9.writeFileSync(configPath, TOML.stringify(config), "utf-8");
+        console.log(chalk10.red("  removed") + chalk10.dim(` ${pluginKey} from: ${configPath}`));
       }
     } catch (ex) {
-      console.error(chalk9.red(`  \u274C Failed to clean up config.toml: ${ex.message}`));
+      console.error(chalk10.red(`  \u274C Failed to clean up config.toml: ${ex.message}`));
     }
   }
   const cacheMarketDir = path8.join(CODEX_CACHE_DIR, CODEX_MARKETPLACE_NAME);
-  if (fs8.existsSync(cacheMarketDir)) {
-    fs8.rmSync(cacheMarketDir, { recursive: true, force: true });
-    console.log(chalk9.red("  removed") + chalk9.dim(`: ${cacheMarketDir}`));
+  if (fs9.existsSync(cacheMarketDir)) {
+    fs9.rmSync(cacheMarketDir, { recursive: true, force: true });
+    console.log(chalk10.red("  removed") + chalk10.dim(`: ${cacheMarketDir}`));
   }
   configManager.codex = null;
   configManager.save();
@@ -1682,8 +1960,8 @@ Removing Codex plugin...`));
 
 // src/link/cursor.ts
 import path9 from "path";
-import fs9 from "fs";
-import chalk10 from "chalk";
+import fs10 from "fs";
+import chalk11 from "chalk";
 import { confirm as confirm8 } from "@inquirer/prompts";
 import { pathExists as pathExists4 } from "fs-extra";
 var CURSOR_BACKUP_DIR = path9.join(CURSOR_DIR, "SET_PROMPT_BACKUP");
@@ -1692,35 +1970,35 @@ var linkCursor = async () => {
   if (repoPath == null) {
     return;
   }
-  console.log(chalk10.green(`
+  console.log(chalk11.green(`
 Setting up Cursor integration...`));
-  console.log(chalk10.dim(CURSOR_DIR));
+  console.log(chalk11.dim(CURSOR_DIR));
   const cursorDirs = AGENT_PROMPT_DIRS["cursor" /* CURSOR */];
   const dirsToBackup = [];
   for (const dir of cursorDirs) {
     const target = path9.join(CURSOR_DIR, dir);
-    if (fs9.existsSync(target) && fs9.lstatSync(target).isSymbolicLink() === false && fs9.readdirSync(target).length > 0) {
+    if (fs10.existsSync(target) && fs10.lstatSync(target).isSymbolicLink() === false && fs10.readdirSync(target).length > 0) {
       dirsToBackup.push(dir);
     }
   }
   if (dirsToBackup.length > 0) {
-    console.log(chalk10.yellow(`
+    console.log(chalk11.yellow(`
   \u26A0 The following existing directories will be replaced by symlinks:`));
     for (const dir of dirsToBackup) {
-      console.log(chalk10.dim(`    - ${path9.join(CURSOR_DIR, dir)}`));
+      console.log(chalk11.dim(`    - ${path9.join(CURSOR_DIR, dir)}`));
     }
-    console.log(chalk10.yellow(`  They will be backed up to: `) + chalk10.dim(CURSOR_BACKUP_DIR));
+    console.log(chalk11.yellow(`  They will be backed up to: `) + chalk11.dim(CURSOR_BACKUP_DIR));
     const ok = await confirm8({ message: "Back up existing directories?", default: true });
     if (!ok) {
-      console.log(chalk10.yellow("Skipped Cursor linking."));
+      console.log(chalk11.yellow("Skipped Cursor linking."));
       return;
     }
-    fs9.mkdirSync(CURSOR_BACKUP_DIR, { recursive: true });
+    fs10.mkdirSync(CURSOR_BACKUP_DIR, { recursive: true });
     for (const dir of dirsToBackup) {
       const src = path9.join(CURSOR_DIR, dir);
       const dest = path9.join(CURSOR_BACKUP_DIR, dir);
-      fs9.renameSync(src, dest);
-      console.log(chalk10.yellow("  backed up") + chalk10.dim(`: ${dir}/ \u2192 ${dest}`));
+      fs10.renameSync(src, dest);
+      console.log(chalk11.yellow("  backed up") + chalk11.dim(`: ${dir}/ \u2192 ${dest}`));
     }
   }
   try {
@@ -1731,33 +2009,33 @@ Setting up Cursor integration...`));
       if (await pathExists4(src) === false) {
         continue;
       }
-      if (fs9.existsSync(dest)) {
-        fs9.rmSync(dest, { recursive: true, force: true });
+      if (fs10.existsSync(dest)) {
+        fs10.rmSync(dest, { recursive: true, force: true });
       }
       const symlinkType = process.platform === "win32" ? "junction" : "dir";
-      fs9.symlinkSync(src, dest, symlinkType);
+      fs10.symlinkSync(src, dest, symlinkType);
       linked.push({ dir, src });
     }
     for (const { dir, src } of linked) {
-      console.log(chalk10.dim(`  \u251C\u2500\u2500 `) + chalk10.bold(`${dir}/`) + chalk10.dim(` \u2192 ${src}`) + chalk10.green(" \u2713"));
+      console.log(chalk11.dim(`  \u251C\u2500\u2500 `) + chalk11.bold(`${dir}/`) + chalk11.dim(` \u2192 ${src}`) + chalk11.green(" \u2713"));
     }
     const mcpSrc = path9.join(repoPath, ".mcp.json");
     const mcpDest = path9.join(CURSOR_DIR, "mcp.json");
-    if (fs9.existsSync(mcpSrc)) {
-      if (fs9.existsSync(mcpDest) && fs9.statSync(mcpDest).ino !== fs9.statSync(mcpSrc).ino) {
+    if (fs10.existsSync(mcpSrc)) {
+      if (fs10.existsSync(mcpDest) && fs10.statSync(mcpDest).ino !== fs10.statSync(mcpSrc).ino) {
         const mcpBackup = path9.join(CURSOR_BACKUP_DIR, "mcp.json");
-        fs9.mkdirSync(CURSOR_BACKUP_DIR, { recursive: true });
-        fs9.renameSync(mcpDest, mcpBackup);
-        console.log(chalk10.yellow("  backed up") + chalk10.dim(`: mcp.json \u2192 ${mcpBackup}`));
+        fs10.mkdirSync(CURSOR_BACKUP_DIR, { recursive: true });
+        fs10.renameSync(mcpDest, mcpBackup);
+        console.log(chalk11.yellow("  backed up") + chalk11.dim(`: mcp.json \u2192 ${mcpBackup}`));
       }
-      if (fs9.existsSync(mcpDest)) {
-        fs9.unlinkSync(mcpDest);
+      if (fs10.existsSync(mcpDest)) {
+        fs10.unlinkSync(mcpDest);
       }
-      fs9.linkSync(mcpSrc, mcpDest);
-      console.log(chalk10.dim(`  \u2514\u2500\u2500 `) + chalk10.bold("mcp.json") + chalk10.dim(` \u21D4 ${mcpSrc}`) + chalk10.green(" \u2713"));
+      fs10.linkSync(mcpSrc, mcpDest);
+      console.log(chalk11.dim(`  \u2514\u2500\u2500 `) + chalk11.bold("mcp.json") + chalk11.dim(` \u21D4 ${mcpSrc}`) + chalk11.green(" \u2713"));
     }
   } catch (ex) {
-    console.error(chalk10.red(`\u274C Failed to set up Cursor: ${ex.message}`));
+    console.error(chalk11.red(`\u274C Failed to set up Cursor: ${ex.message}`));
     return;
   }
   configManager.cursor = { path: CURSOR_DIR, backup_path: CURSOR_BACKUP_DIR };
@@ -1770,51 +2048,324 @@ var unlinkCursor = async (force = false) => {
       default: false
     });
     if (!ok) {
-      console.log(chalk10.yellow("Cancelled."));
+      console.log(chalk11.yellow("Cancelled."));
       return;
     }
   }
-  console.log(chalk10.red(`
+  console.log(chalk11.red(`
 Removing Cursor integration...`));
-  console.log(chalk10.dim(CURSOR_DIR));
+  console.log(chalk11.dim(CURSOR_DIR));
   const backupPath = configManager.cursor?.backup_path ?? CURSOR_BACKUP_DIR;
   for (const dir of AGENT_PROMPT_DIRS["cursor" /* CURSOR */]) {
     const target = path9.join(CURSOR_DIR, dir);
-    if (fs9.existsSync(target) && fs9.lstatSync(target).isSymbolicLink()) {
-      fs9.unlinkSync(target);
-      console.log(chalk10.red("  removed symlink") + chalk10.dim(`: ${target}`));
+    if (fs10.existsSync(target) && fs10.lstatSync(target).isSymbolicLink()) {
+      fs10.unlinkSync(target);
+      console.log(chalk11.red("  removed symlink") + chalk11.dim(`: ${target}`));
     }
   }
   const mcpDest = path9.join(CURSOR_DIR, "mcp.json");
-  if (fs9.existsSync(mcpDest)) {
-    fs9.unlinkSync(mcpDest);
-    console.log(chalk10.red("  removed") + chalk10.dim(`: ${mcpDest}`));
+  if (fs10.existsSync(mcpDest)) {
+    fs10.unlinkSync(mcpDest);
+    console.log(chalk11.red("  removed") + chalk11.dim(`: ${mcpDest}`));
   }
-  if (fs9.existsSync(backupPath)) {
+  if (fs10.existsSync(backupPath)) {
     try {
       for (const dir of AGENT_PROMPT_DIRS["cursor" /* CURSOR */]) {
         const src = path9.join(backupPath, dir);
         const dest = path9.join(CURSOR_DIR, dir);
-        if (!fs9.existsSync(src)) {
+        if (!fs10.existsSync(src)) {
           continue;
         }
-        fs9.renameSync(src, dest);
-        console.log(chalk10.green("  restored") + chalk10.dim(`: ${dir}/`));
+        fs10.renameSync(src, dest);
+        console.log(chalk11.green("  restored") + chalk11.dim(`: ${dir}/`));
       }
       const mcpBackup = path9.join(backupPath, "mcp.json");
-      if (fs9.existsSync(mcpBackup)) {
-        fs9.renameSync(mcpBackup, mcpDest);
-        console.log(chalk10.green("  restored") + chalk10.dim(`: mcp.json`));
+      if (fs10.existsSync(mcpBackup)) {
+        fs10.renameSync(mcpBackup, mcpDest);
+        console.log(chalk11.green("  restored") + chalk11.dim(`: mcp.json`));
       }
-      fs9.rmSync(backupPath, { recursive: true, force: true });
+      fs10.rmSync(backupPath, { recursive: true, force: true });
     } catch (ex) {
-      console.error(chalk10.red(`  \u274C Failed to restore Cursor backup: ${ex.message}`));
+      console.error(chalk11.red(`  \u274C Failed to restore Cursor backup: ${ex.message}`));
     }
   }
   configManager.cursor = null;
   configManager.save();
 };
 
+// src/link/opencode.ts
+import path10 from "path";
+import fs11 from "fs";
+import chalk12 from "chalk";
+import { confirm as confirm9 } from "@inquirer/prompts";
+import { pathExists as pathExists5 } from "fs-extra";
+var linkOpencode = async () => {
+  const repoPath = resolveRepoPath();
+  if (repoPath == null) {
+    return;
+  }
+  console.log(chalk12.green(`
+Setting up OpenCode integration...`));
+  console.log(chalk12.dim(OPENCODE_DIR));
+  const opencodeDirs = AGENT_PROMPT_DIRS["opencode" /* OPENCODE */];
+  const backupExistingOpencodeFiles = async () => {
+    try {
+      fs11.mkdirSync(OPENCODE_DIR, { recursive: true });
+      const dirsToBackup = [];
+      for (const dir of opencodeDirs) {
+        const target = path10.join(OPENCODE_DIR, dir);
+        if (fs11.existsSync(target) && fs11.lstatSync(target).isSymbolicLink() === false && fs11.readdirSync(target).length > 0) {
+          dirsToBackup.push(dir);
+        }
+      }
+      if (dirsToBackup.length === 0) {
+        return true;
+      }
+      console.log(chalk12.yellow(`
+  \u26A0 The following existing directories will be replaced by symlinks:`));
+      for (const dir of dirsToBackup) {
+        console.log(chalk12.dim(`    - ${path10.join(OPENCODE_DIR, dir)}`));
+      }
+      console.log(chalk12.yellow(`  They will be backed up to: `) + chalk12.dim(OPENCODE_BACKUP_DIR));
+      const ok = await confirm9({ message: "Back up existing directories?", default: true });
+      if (!ok) {
+        console.log(chalk12.yellow("Skipped OpenCode linking."));
+        return false;
+      }
+      fs11.mkdirSync(OPENCODE_BACKUP_DIR, { recursive: true });
+      for (const dir of opencodeDirs) {
+        const src = path10.join(OPENCODE_DIR, dir);
+        const dest = path10.join(OPENCODE_BACKUP_DIR, dir);
+        if (!fs11.existsSync(src)) {
+          continue;
+        }
+        fs11.renameSync(src, dest);
+        console.log(chalk12.yellow("  backed up") + chalk12.dim(`: ${dir}/ \u2192 ${dest}`));
+      }
+      return true;
+    } catch (ex) {
+      console.error(chalk12.red(`\u274C Failed to backup existing directories: ${ex.message}`));
+      return false;
+    }
+  };
+  const setOpencodeAssets = async () => {
+    try {
+      const linked = [];
+      for (const dir of opencodeDirs) {
+        const src = path10.join(repoPath, dir);
+        const dest = path10.join(OPENCODE_DIR, dir);
+        if (await pathExists5(src) === false) {
+          continue;
+        }
+        if (fs11.existsSync(dest)) {
+          fs11.rmSync(dest, { recursive: true, force: true });
+        }
+        const symlinkType = process.platform === "win32" ? "junction" : "dir";
+        fs11.symlinkSync(src, dest, symlinkType);
+        linked.push({ dir, src });
+      }
+      for (const { dir, src } of linked) {
+        const isLast = linked[linked.length - 1].dir === dir;
+        const branch = isLast ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
+        console.log(chalk12.dim(`  ${branch} `) + chalk12.bold(`${dir}/`) + chalk12.dim(` \u2192 ${src}`) + chalk12.green(" \u2713"));
+      }
+      return true;
+    } catch (ex) {
+      console.error(chalk12.red(`\u274C Failed to create symlinks: ${ex.message}`));
+      return false;
+    }
+  };
+  const backupOk = await backupExistingOpencodeFiles();
+  if (backupOk === false) {
+    return;
+  }
+  const linkOk = await setOpencodeAssets();
+  if (linkOk === false) {
+    return;
+  }
+  configManager.opencode = { path: OPENCODE_DIR, backup_path: OPENCODE_BACKUP_DIR };
+  configManager.save();
+};
+var unlinkOpencode = async (force = false) => {
+  if (!force) {
+    const ok = await confirm9({
+      message: `Remove OpenCode symlinks from ${OPENCODE_DIR}?`,
+      default: false
+    });
+    if (!ok) {
+      console.log(chalk12.yellow("Cancelled."));
+      return;
+    }
+  }
+  console.log(chalk12.red(`
+Removing OpenCode integration...`));
+  console.log(chalk12.dim(OPENCODE_DIR));
+  const backupPath = configManager.opencode?.backup_path ?? OPENCODE_BACKUP_DIR;
+  for (const dir of AGENT_PROMPT_DIRS["opencode" /* OPENCODE */]) {
+    const target = path10.join(OPENCODE_DIR, dir);
+    if (fs11.existsSync(target) && fs11.lstatSync(target).isSymbolicLink()) {
+      fs11.unlinkSync(target);
+      console.log(chalk12.red("  removed symlink") + chalk12.dim(`: ${target}`));
+    }
+  }
+  if (fs11.existsSync(backupPath)) {
+    try {
+      for (const dir of AGENT_PROMPT_DIRS["opencode" /* OPENCODE */]) {
+        const src = path10.join(backupPath, dir);
+        const dest = path10.join(OPENCODE_DIR, dir);
+        if (!fs11.existsSync(src)) {
+          continue;
+        }
+        fs11.renameSync(src, dest);
+        console.log(chalk12.green("  restored") + chalk12.dim(`: ${dir}/`));
+      }
+      fs11.rmdirSync(backupPath);
+    } catch (ex) {
+      console.error(chalk12.red(`  \u274C Failed to restore OpenCode backup: ${ex.message}`));
+    }
+  }
+  configManager.opencode = null;
+  configManager.save();
+};
+
+// src/link/geminicli.ts
+import path11 from "path";
+import fs12 from "fs";
+import chalk13 from "chalk";
+import { confirm as confirm10 } from "@inquirer/prompts";
+import { pathExists as pathExists6 } from "fs-extra";
+var linkGeminicli = async () => {
+  const repoPath = resolveRepoPath();
+  if (repoPath == null) {
+    return;
+  }
+  console.log(chalk13.green(`
+Setting up Gemini CLI integration...`));
+  console.log(chalk13.dim(GEMINICLI_DIR));
+  const geminicliDirs = AGENT_PROMPT_DIRS["geminicli" /* GEMINICLI */];
+  const backupExistingGeminicliFiles = async () => {
+    try {
+      fs12.mkdirSync(GEMINICLI_DIR, { recursive: true });
+      const dirsToBackup = [];
+      for (const dir of geminicliDirs) {
+        const target = path11.join(GEMINICLI_DIR, dir);
+        if (fs12.existsSync(target) && fs12.lstatSync(target).isSymbolicLink() === false && fs12.readdirSync(target).length > 0) {
+          dirsToBackup.push(dir);
+        }
+      }
+      if (dirsToBackup.length === 0) {
+        return true;
+      }
+      console.log(chalk13.yellow(`
+  \u26A0 The following existing directories will be replaced by symlinks:`));
+      for (const dir of dirsToBackup) {
+        console.log(chalk13.dim(`    - ${path11.join(GEMINICLI_DIR, dir)}`));
+      }
+      console.log(chalk13.yellow(`  They will be backed up to: `) + chalk13.dim(GEMINICLI_BACKUP_DIR));
+      const ok = await confirm10({ message: "Back up existing directories?", default: true });
+      if (!ok) {
+        console.log(chalk13.yellow("Skipped Gemini CLI linking."));
+        return false;
+      }
+      fs12.mkdirSync(GEMINICLI_BACKUP_DIR, { recursive: true });
+      for (const dir of geminicliDirs) {
+        const src = path11.join(GEMINICLI_DIR, dir);
+        const dest = path11.join(GEMINICLI_BACKUP_DIR, dir);
+        if (!fs12.existsSync(src)) {
+          continue;
+        }
+        fs12.renameSync(src, dest);
+        console.log(chalk13.yellow("  backed up") + chalk13.dim(`: ${dir}/ \u2192 ${dest}`));
+      }
+      return true;
+    } catch (ex) {
+      console.error(chalk13.red(`\u274C Failed to backup existing directories: ${ex.message}`));
+      return false;
+    }
+  };
+  const setGeminicliAssets = async () => {
+    try {
+      const linked = [];
+      for (const dir of geminicliDirs) {
+        const src = path11.join(repoPath, dir);
+        const dest = path11.join(GEMINICLI_DIR, dir);
+        if (await pathExists6(src) === false) {
+          continue;
+        }
+        if (fs12.existsSync(dest)) {
+          fs12.rmSync(dest, { recursive: true, force: true });
+        }
+        const symlinkType = process.platform === "win32" ? "junction" : "dir";
+        fs12.symlinkSync(src, dest, symlinkType);
+        linked.push({ dir, src });
+      }
+      for (const { dir, src } of linked) {
+        const isLast = linked[linked.length - 1].dir === dir;
+        const branch = isLast ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
+        console.log(chalk13.dim(`  ${branch} `) + chalk13.bold(`${dir}/`) + chalk13.dim(` \u2192 ${src}`) + chalk13.green(" \u2713"));
+      }
+      return true;
+    } catch (ex) {
+      console.error(chalk13.red(`\u274C Failed to create symlinks: ${ex.message}`));
+      return false;
+    }
+  };
+  const backupOk = await backupExistingGeminicliFiles();
+  if (backupOk === false) {
+    return;
+  }
+  const linkOk = await setGeminicliAssets();
+  if (linkOk === false) {
+    return;
+  }
+  configManager.geminicli = { path: GEMINICLI_DIR, backup_path: GEMINICLI_BACKUP_DIR };
+  configManager.save();
+  console.log(chalk13.dim(`
+  \u2139 Gemini CLI file formats: skills/<name>/SKILL.md \xB7 commands/*.toml \xB7 agents/*.md`));
+  console.log(chalk13.yellow(`  \u26A0 Gemini CLI rejects agents with unknown frontmatter keys. Allowed keys only: `) + chalk13.dim(`name, description, kind, tools, mcpServers, model, temperature, max_turns, timeout_mins`));
+};
+var unlinkGeminicli = async (force = false) => {
+  if (!force) {
+    const ok = await confirm10({
+      message: `Remove Gemini CLI symlinks from ${GEMINICLI_DIR}?`,
+      default: false
+    });
+    if (!ok) {
+      console.log(chalk13.yellow("Cancelled."));
+      return;
+    }
+  }
+  console.log(chalk13.red(`
+Removing Gemini CLI integration...`));
+  console.log(chalk13.dim(GEMINICLI_DIR));
+  const backupPath = configManager.geminicli?.backup_path ?? GEMINICLI_BACKUP_DIR;
+  for (const dir of AGENT_PROMPT_DIRS["geminicli" /* GEMINICLI */]) {
+    const target = path11.join(GEMINICLI_DIR, dir);
+    if (fs12.existsSync(target) && fs12.lstatSync(target).isSymbolicLink()) {
+      fs12.unlinkSync(target);
+      console.log(chalk13.red("  removed symlink") + chalk13.dim(`: ${target}`));
+    }
+  }
+  if (fs12.existsSync(backupPath)) {
+    try {
+      for (const dir of AGENT_PROMPT_DIRS["geminicli" /* GEMINICLI */]) {
+        const src = path11.join(backupPath, dir);
+        const dest = path11.join(GEMINICLI_DIR, dir);
+        if (!fs12.existsSync(src)) {
+          continue;
+        }
+        fs12.renameSync(src, dest);
+        console.log(chalk13.green("  restored") + chalk13.dim(`: ${dir}/`));
+      }
+      fs12.rmdirSync(backupPath);
+    } catch (ex) {
+      console.error(chalk13.red(`  \u274C Failed to restore Gemini CLI backup: ${ex.message}`));
+    }
+  }
+  configManager.geminicli = null;
+  configManager.save();
+};
+
 // src/commands/link-command.ts
 var LINK_MAP = {
   ["claudecode" /* CLAUDECODE */]: linkClaudeCode,
@@ -1822,7 +2373,9 @@ var LINK_MAP = {
   ["openclaw" /* OPENCLAW */]: linkOpenclaw,
   ["codex" /* CODEX */]: linkCodex,
   ["antigravity" /* ANTIGRAVITY */]: linkAntigravity,
-  ["cursor" /* CURSOR */]: linkCursor
+  ["cursor" /* CURSOR */]: linkCursor,
+  ["opencode" /* OPENCODE */]: linkOpencode,
+  ["geminicli" /* GEMINICLI */]: linkGeminicli
 };
 var UNLINK_MAP = {
   ["claudecode" /* CLAUDECODE */]: unlinkClaudeCode,
@@ -1830,13 +2383,15 @@ var UNLINK_MAP = {
   ["openclaw" /* OPENCLAW */]: unlinkOpenclaw,
   ["codex" /* CODEX */]: unlinkCodex,
   ["antigravity" /* ANTIGRAVITY */]: unlinkAntigravity,
-  ["cursor" /* CURSOR */]: unlinkCursor
+  ["cursor" /* CURSOR */]: unlinkCursor,
+  ["opencode" /* OPENCODE */]: unlinkOpencode,
+  ["geminicli" /* GEMINICLI */]: unlinkGeminicli
 };
 var linkCommand = async (tool) => {
   if (tool != null) {
     const known = ALL_AGENTS.some((a) => a.value === tool);
     if (!known) {
-      console.log(chalk11.red(`Unknown vendor: ${tool}`));
+      console.log(chalk14.red(`Unknown vendor: ${tool}`));
       process.exit(1);
     }
     await LINK_MAP[tool]();
@@ -1848,24 +2403,28 @@ var linkCommand = async (tool) => {
     ["openclaw" /* OPENCLAW */]: configManager.isOpenclawEnabled(),
     ["codex" /* CODEX */]: configManager.isCodexEnabled(),
     ["antigravity" /* ANTIGRAVITY */]: configManager.isAntigravityEnabled(),
-    ["cursor" /* CURSOR */]: configManager.isCursorEnabled()
+    ["cursor" /* CURSOR */]: configManager.isCursorEnabled(),
+    ["opencode" /* OPENCODE */]: configManager.isOpencodeEnabled(),
+    ["geminicli" /* GEMINICLI */]: configManager.isGeminicliEnabled()
   };
   const selected = await checkbox({
     message: "Which AI agent do you want to integrate?",
     choices: ALL_AGENTS.map((a) => ({
-      name: prevLinked[a.value] ? `${a.name} ${chalk11.dim("(applied)")}` : a.name,
+      name: prevLinked[a.value] ? `${a.name} ${chalk14.dim("(applied)")}` : a.name,
       value: a.value,
       checked: prevLinked[a.value]
-    }))
+    })),
+    pageSize: ALL_AGENTS.length,
+    loop: false
   });
   const toLink = ALL_AGENTS.filter((a) => !prevLinked[a.value] && selected.includes(a.value));
   const toUnlink = ALL_AGENTS.filter((a) => prevLinked[a.value] && !selected.includes(a.value));
   console.log();
   if (toLink.length > 0) {
-    console.log(chalk11.green("  Link   ") + chalk11.dim("\u2192 ") + toLink.map((a) => chalk11.bold(a.name)).join(chalk11.dim(", ")));
+    console.log(chalk14.green("  Link   ") + chalk14.dim("\u2192 ") + toLink.map((a) => chalk14.bold(a.name)).join(chalk14.dim(", ")));
   }
   if (toUnlink.length > 0) {
-    console.log(chalk11.red("  Unlink ") + chalk11.dim("\u2192 ") + toUnlink.map((a) => chalk11.bold(a.name)).join(chalk11.dim(", ")));
+    console.log(chalk14.red("  Unlink ") + chalk14.dim("\u2192 ") + toUnlink.map((a) => chalk14.bold(a.name)).join(chalk14.dim(", ")));
   }
   console.log();
   if (toLink.length === 0 && toUnlink.length === 0) {
@@ -1884,14 +2443,14 @@ var linkCommand = async (tool) => {
 };
 
 // src/commands/uninstall-command.ts
-import fs10 from "fs";
-import chalk12 from "chalk";
-import { confirm as confirm9 } from "@inquirer/prompts";
+import fs13 from "fs";
+import chalk15 from "chalk";
+import { confirm as confirm11 } from "@inquirer/prompts";
 var uninstallCommand = async () => {
   const targets = [
-    { label: `Config file  ${chalk12.dim(CONFIG_PATH)}`, path: CONFIG_PATH },
-    { label: `Home dir     ${chalk12.dim(HOME_DIR)}`, path: HOME_DIR }
-  ].filter((t) => fs10.existsSync(t.path));
+    { label: `Config file  ${chalk15.dim(CONFIG_PATH)}`, path: CONFIG_PATH },
+    { label: `Home dir     ${chalk15.dim(HOME_DIR)}`, path: HOME_DIR }
+  ].filter((t) => fs13.existsSync(t.path));
   const hasClaudeCode = configManager.isClaudeCodeEnabled();
   const hasRooCode = configManager.isRooCodeEnabled();
   const hasOpenclaw = configManager.isOpenclawEnabled();
@@ -1899,32 +2458,32 @@ var uninstallCommand = async () => {
   const hasCodex = configManager.isCodexEnabled();
   const hasCursor = configManager.isCursorEnabled();
   if (targets.length === 0 && !hasClaudeCode && !hasRooCode && !hasOpenclaw && !hasAntigravity && !hasCodex && !hasCursor) {
-    console.log(chalk12.yellow("Nothing to remove."));
+    console.log(chalk15.yellow("Nothing to remove."));
     return;
   }
-  console.log(chalk12.red("\nThe following will be removed:"));
+  console.log(chalk15.red("\nThe following will be removed:"));
   targets.forEach((t) => console.log(`  ${t.label}`));
   if (hasClaudeCode) {
-    console.log(`  Claude Code plugin dir  ${chalk12.dim(CLAUDE_CODE_DIR)}`);
+    console.log(`  Claude Code plugin dir  ${chalk15.dim(CLAUDE_CODE_DIR)}`);
   }
   if (hasRooCode) {
-    console.log(`  RooCode symlinks ${chalk12.dim("(backup will be restored)")}`);
+    console.log(`  RooCode symlinks ${chalk15.dim("(backup will be restored)")}`);
   }
   if (hasOpenclaw) {
-    console.log(`  OpenClaw symlinks ${chalk12.dim("(backup will be restored)")}`);
+    console.log(`  OpenClaw symlinks ${chalk15.dim("(backup will be restored)")}`);
   }
   if (hasAntigravity) {
-    console.log(`  Antigravity symlinks ${chalk12.dim("(backup will be restored)")}`);
+    console.log(`  Antigravity symlinks ${chalk15.dim("(backup will be restored)")}`);
   }
   if (hasCodex) {
-    console.log(`  Codex symlinks ${chalk12.dim("(backup will be restored)")}`);
+    console.log(`  Codex symlinks ${chalk15.dim("(backup will be restored)")}`);
   }
   if (hasCursor) {
-    console.log(`  Cursor plugin dir ${chalk12.dim("(symlink will be removed)")}`);
+    console.log(`  Cursor plugin dir ${chalk15.dim("(symlink will be removed)")}`);
   }
-  const ok = await confirm9({ message: "Proceed?", default: false });
+  const ok = await confirm11({ message: "Proceed?", default: false });
   if (!ok) {
-    console.log(chalk12.yellow("Cancelled."));
+    console.log(chalk15.yellow("Cancelled."));
     return;
   }
   if (hasClaudeCode) {
@@ -1946,26 +2505,26 @@ var uninstallCommand = async () => {
     await unlinkCursor(true);
   }
   for (const t of targets) {
-    fs10.rmSync(t.path, { recursive: true, force: true });
-    console.log(chalk12.dim(`  removed: ${t.path}`));
+    fs13.rmSync(t.path, { recursive: true, force: true });
+    console.log(chalk15.dim(`  removed: ${t.path}`));
   }
-  console.log(chalk12.green("\nUninstalled."));
+  console.log(chalk15.green("\nUninstalled."));
 };
 
 // src/commands/status-command.ts
-import chalk13 from "chalk";
+import chalk16 from "chalk";
 var statusCommand = () => {
   if (configManager.repo_path == null) {
-    console.log(chalk13.yellow("\u274C No repo installed."));
-    console.log(chalk13.dim(`  Run: set-prompt install <repo-url>`));
+    console.log(chalk16.yellow("\u274C No repo installed."));
+    console.log(chalk16.dim(`  Run: set-prompt install <repo-url>`));
     return;
   }
-  console.log(chalk13.bold("\nRepo"));
-  console.log(`${TAB}path   ${chalk13.cyan(configManager.repo_path)}`);
+  console.log(chalk16.bold("\nRepo"));
+  console.log(`${TAB}path   ${chalk16.cyan(configManager.repo_path)}`);
   if (configManager.remote_url != null) {
-    console.log(`${TAB}remote ${chalk13.dim(configManager.remote_url)}`);
+    console.log(`${TAB}remote ${chalk16.dim(configManager.remote_url)}`);
   }
-  console.log(chalk13.bold("\nLinked agents"));
+  console.log(chalk16.bold("\nLinked agents"));
   for (const agent of ALL_AGENTS) {
     let linked = false;
     let agentPath = null;
@@ -1985,78 +2544,363 @@ var statusCommand = () => {
       linked = configManager.isAntigravityEnabled();
       agentPath = configManager.antigravity?.path;
     }
-    const label = linked ? chalk13.green("linked") : chalk13.dim("not linked");
-    const pathStr = linked && agentPath ? chalk13.dim(` \u2192 ${agentPath}`) : "";
+    const label = linked ? chalk16.green("linked") : chalk16.dim("not linked");
+    const pathStr = linked && agentPath ? chalk16.dim(` \u2192 ${agentPath}`) : "";
     console.log(`${TAB}${agent.name.padEnd(12)} ${label}${pathStr}`);
   }
   console.log("");
 };
 
-// src/commands/update-command.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import chalk14 from "chalk";
-var updateCommand = () => {
+// src/commands/repo/pull-command.ts
+import { spawnSync as spawnSync4 } from "child_process";
+import chalk17 from "chalk";
+var repoPullCommand = () => {
   const repoPath = configManager.repo_path;
   if (repoPath == null) {
-    console.error(chalk14.red("\u274C No repo installed."));
-    console.log(chalk14.yellow("Run: set-prompt install <git-url>"));
+    console.error(chalk17.red("\u274C No repo installed."));
+    console.log(chalk17.yellow("Run: set-prompt install <git-url>"));
     return;
   }
   if (configManager.remote_url == null) {
-    console.error(chalk14.red("\u274C No remote URL registered. Cannot update."));
+    console.error(chalk17.red("\u274C No remote URL registered. Cannot pull."));
     return;
   }
-  console.log(chalk14.green("\nUpdating prompt repo..."));
-  console.log(chalk14.dim(repoPath));
-  const fetch = spawnSync2("git", ["fetch"], { cwd: repoPath, stdio: "inherit" });
+  console.log(chalk17.green("\nPulling prompt repo..."));
+  console.log(chalk17.dim(repoPath));
+  const fetch = spawnSync4("git", ["fetch"], { cwd: repoPath, stdio: "inherit" });
   if (fetch.status !== 0) {
-    console.error(chalk14.red("\u274C git fetch failed."));
+    console.error(chalk17.red("\u274C git fetch failed."));
     return;
   }
-  const pull = spawnSync2("git", ["pull"], { cwd: repoPath, stdio: "inherit" });
+  const pull = spawnSync4("git", ["pull"], { cwd: repoPath, stdio: "inherit" });
   if (pull.status !== 0) {
-    console.error(chalk14.red("\u274C git pull failed."));
+    console.error(chalk17.red("\u274C git pull failed."));
     return;
   }
-  console.log(chalk14.green("\u2705 Repo updated."));
+  console.log(chalk17.green("\u2705 Repo pulled."));
+};
+
+// src/commands/repo/commit-command.ts
+import { spawnSync as spawnSync5 } from "child_process";
+import chalk18 from "chalk";
+var repoCommitCommand = (options = {}) => {
+  const repoPath = configManager.repo_path;
+  if (repoPath == null) {
+    console.error(chalk18.red("\u274C No repo installed."));
+    console.log(chalk18.yellow("Run: set-prompt install <git-url>"));
+    return false;
+  }
+  let message = options.message;
+  if (message == null || message.trim() === "") {
+    const generated = generateCommitMessage(repoPath);
+    if (generated == null) {
+      console.error(chalk18.red("\u274C Nothing to commit \u2014 working tree is clean."));
+      return false;
+    }
+    message = generated;
+    const subject = message.split("\n")[0];
+    console.log(chalk18.dim(`  (auto-generated: ${subject})`));
+  }
+  console.log(chalk18.green("\nCommitting prompt repo changes..."));
+  console.log(chalk18.dim(repoPath));
+  const add = spawnSync5("git", ["add", "-A"], { cwd: repoPath, stdio: "inherit" });
+  if (add.status !== 0) {
+    console.error(chalk18.red("\u274C git add failed."));
+    return false;
+  }
+  const commit = spawnSync5("git", ["commit", "-m", message], { cwd: repoPath, stdio: "inherit" });
+  if (commit.status !== 0) {
+    console.error(chalk18.red("\u274C git commit failed \u2014 nothing to commit, or commit rejected."));
+    return false;
+  }
+  console.log(chalk18.green("\u2705 Committed."));
+  return true;
+};
+
+// src/commands/repo/push-command.ts
+import { spawnSync as spawnSync6 } from "child_process";
+import chalk19 from "chalk";
+var repoPushCommand = () => {
+  const repoPath = configManager.repo_path;
+  if (repoPath == null) {
+    console.error(chalk19.red("\u274C No repo installed."));
+    console.log(chalk19.yellow("Run: set-prompt install <git-url>"));
+    return false;
+  }
+  if (configManager.remote_url == null) {
+    console.error(chalk19.red("\u274C No remote URL registered. Cannot push."));
+    return false;
+  }
+  console.log(chalk19.green("\nPushing prompt repo..."));
+  console.log(chalk19.dim(repoPath));
+  const push = spawnSync6("git", ["push"], { cwd: repoPath, stdio: "inherit" });
+  if (push.status !== 0) {
+    console.error(chalk19.red("\u274C git push failed."));
+    return false;
+  }
+  console.log(chalk19.green("\u2705 Pushed."));
+  return true;
+};
+
+// src/commands/repo/save-command.ts
+var repoSaveCommand = (options = {}) => {
+  const committed = repoCommitCommand({ message: options.message });
+  if (committed === false) return;
+  repoPushCommand();
+};
+
+// src/commands/repo/status-command.ts
+import { spawnSync as spawnSync7 } from "child_process";
+import chalk20 from "chalk";
+var parseBranchLine = (line) => {
+  const body = line.replace(/^## /, "");
+  if (body.startsWith("HEAD ") || body.includes("(no branch)")) {
+    return { branch: null, upstream: null, ahead: 0, behind: 0 };
+  }
+  const [refPart, bracketPart] = body.split(/\s+(?=\[)/);
+  const [branch, upstream] = refPart.split("...");
+  let ahead = 0;
+  let behind = 0;
+  if (bracketPart != null) {
+    const inside = bracketPart.replace(/[\[\]]/g, "");
+    for (const piece of inside.split(",").map((s) => s.trim())) {
+      const m = piece.match(/^(ahead|behind) (\d+)$/);
+      if (m == null) continue;
+      if (m[1] === "ahead") ahead = Number(m[2]);
+      if (m[1] === "behind") behind = Number(m[2]);
+    }
+  }
+  return { branch: branch ?? null, upstream: upstream ?? null, ahead, behind };
+};
+var parseFileLine = (line) => {
+  if (line.length < 4) return null;
+  const status = line.slice(0, 2);
+  let name = line.slice(3);
+  const arrowIdx = name.indexOf(" -> ");
+  if (arrowIdx >= 0) name = name.slice(arrowIdx + 4);
+  if (name.startsWith('"') && name.endsWith('"')) name = name.slice(1, -1);
+  if (status.includes("?")) return { label: "untracked", color: chalk20.gray, path: name };
+  if (status.includes("D")) return { label: "deleted", color: chalk20.red, path: name };
+  if (status.includes("R")) return { label: "renamed", color: chalk20.cyan, path: name };
+  if (status.includes("A")) return { label: "added", color: chalk20.green, path: name };
+  if (status.includes("M")) return { label: "modified", color: chalk20.yellow, path: name };
+  return null;
+};
+var formatUpstream = (info) => {
+  if (info.branch == null) return chalk20.red("(detached HEAD)");
+  if (info.upstream == null) return `${info.branch} ${chalk20.yellow("(no upstream)")}`;
+  const segs = [];
+  if (info.ahead > 0) segs.push(chalk20.green(`ahead ${info.ahead}`));
+  if (info.behind > 0) segs.push(chalk20.red(`behind ${info.behind}`));
+  const trailing = segs.length > 0 ? ` (${segs.join(", ")})` : chalk20.dim(" (up to date)");
+  return `${info.branch} ${chalk20.dim("\u2192")} ${info.upstream}${trailing}`;
+};
+var repoStatusCommand = () => {
+  const repoPath = configManager.repo_path;
+  if (repoPath == null) {
+    console.error(chalk20.red("\u274C No repo installed."));
+    console.log(chalk20.yellow("Run: set-prompt install <git-url>"));
+    return;
+  }
+  const result = spawnSync7("git", ["status", "--porcelain=v1", "--branch", "--untracked-files=all"], {
+    cwd: repoPath,
+    encoding: "utf8"
+  });
+  if (result.status !== 0) {
+    console.error(chalk20.red("\u274C git status failed."));
+    if (result.stderr) console.error(chalk20.dim(result.stderr));
+    return;
+  }
+  const lines = result.stdout.split("\n").filter((l) => l.length > 0);
+  const branchLine = lines[0] ?? "## (unknown)";
+  const fileLines = lines.slice(1);
+  const branchInfo = parseBranchLine(branchLine);
+  const changes = fileLines.map(parseFileLine).filter((f) => f !== null);
+  console.log(`${chalk20.cyan("\u{1F4C2}")} ${chalk20.dim(repoPath)}`);
+  console.log(`${chalk20.cyan("\u{1F33F}")} ${formatUpstream(branchInfo)}`);
+  console.log("");
+  if (changes.length === 0) {
+    console.log(chalk20.green("\u2705 Working tree clean"));
+    return;
+  }
+  console.log(chalk20.bold(`\u{1F4DD} Changes (${changes.length}):`));
+  const labelWidth = Math.max(...changes.map((c) => c.label.length));
+  for (const c of changes) {
+    const label = c.color(c.label.padEnd(labelWidth));
+    console.log(`   ${label}  ${c.path}`);
+  }
+};
+
+// src/commands/repo/path-command.ts
+import chalk21 from "chalk";
+var repoPathCommand = () => {
+  const repoPath = configManager.repo_path;
+  if (repoPath == null) {
+    console.error(chalk21.red("\u274C No repo installed."));
+    console.error(chalk21.yellow("Run: set-prompt install <git-url>"));
+    process.exitCode = 1;
+    return;
+  }
+  console.log(repoPath);
+};
+
+// src/commands/repo/open-command.ts
+import { spawn } from "child_process";
+import path12 from "path";
+import chalk22 from "chalk";
+var resolveVscodeTarget = (repoPath) => {
+  if (isOnPath("code") === false) return null;
+  return { bin: "code", args: [repoPath] };
+};
+var resolveSourcetreeTarget = (repoPath) => {
+  if (isOnPath("stree")) {
+    return { bin: "stree", args: [repoPath] };
+  }
+  if (process.platform === "win32") {
+    const exe = firstExistingPath([
+      process.env.LOCALAPPDATA && path12.join(process.env.LOCALAPPDATA, "SourceTree", "SourceTree.exe"),
+      process.env["ProgramFiles(x86)"] && path12.join(process.env["ProgramFiles(x86)"], "Atlassian", "SourceTree", "SourceTree.exe"),
+      process.env.ProgramFiles && path12.join(process.env.ProgramFiles, "Atlassian", "SourceTree", "SourceTree.exe")
+    ]);
+    if (exe != null) return { bin: exe, args: ["-f", repoPath] };
+  }
+  return null;
+};
+var VSCODE_INSTALL_HINT = `Install VSCode CLI: View \u2192 Command Palette \u2192 "Shell Command: Install 'code' command"`;
+var sourcetreeInstallHint = () => {
+  if (process.platform === "darwin") {
+    return 'Install Sourcetree, then: Sourcetree menu bar \u2192 "Install Command Line Tools"';
+  }
+  if (process.platform === "win32") {
+    return "Install Sourcetree from https://sourcetreeapp.com/ \u2014 this CLI auto-detects it at %LOCALAPPDATA%\\SourceTree";
+  }
+  return "Sourcetree is not available on Linux \u2014 try a native Git GUI instead";
+};
+var runLaunch = (label, target) => {
+  console.log(chalk22.green(`Opening in ${label}: ${chalk22.dim(target.args[target.args.length - 1])}`));
+  const child = spawn(target.bin, target.args, { stdio: "ignore", detached: true, shell: true });
+  child.unref();
+};
+var repoOpenCommand = (options = {}) => {
+  const repoPath = configManager.repo_path;
+  if (repoPath == null) {
+    console.error(chalk22.red("\u274C No repo installed."));
+    console.log(chalk22.yellow("Run: set-prompt install <git-url>"));
+    return;
+  }
+  if (options.code === true) {
+    const target = resolveVscodeTarget(repoPath);
+    if (target == null) {
+      console.error(chalk22.red("\u274C VSCode CLI (`code`) not found on PATH."));
+      console.log(chalk22.dim(`   ${VSCODE_INSTALL_HINT}`));
+      return;
+    }
+    runLaunch("VSCode", target);
+    return;
+  }
+  if (options.stree === true) {
+    const target = resolveSourcetreeTarget(repoPath);
+    if (target == null) {
+      console.error(chalk22.red("\u274C Sourcetree not found."));
+      console.log(chalk22.dim(`   ${sourcetreeInstallHint()}`));
+      return;
+    }
+    runLaunch("Sourcetree", target);
+    return;
+  }
+  const platform = process.platform;
+  const opener = platform === "win32" ? "explorer" : platform === "darwin" ? "open" : "xdg-open";
+  console.log(chalk22.green(`Opening: ${chalk22.dim(repoPath)}`));
+  const child = spawn(opener, [repoPath], { stdio: "ignore", detached: true });
+  child.on("error", (ex) => {
+    console.error(chalk22.red(`\u274C Failed to open: ${ex.message}`));
+  });
+  child.unref();
 };
 
 // src/index.ts
 process.on("SIGINT", () => {
-  console.log(chalk15.yellow("\nCancelled."));
+  console.log(chalk23.yellow("\nCancelled."));
   process.exit(0);
 });
 process.on("unhandledRejection", (reason) => {
   if (reason instanceof Error && reason.name === "ExitPromptError") {
-    console.log(chalk15.yellow("\nCancelled."));
+    console.log(chalk23.yellow("\nCancelled."));
     process.exit(0);
   }
   throw reason;
 });
-var __dirname = path10.dirname(fileURLToPath(import.meta.url));
-var pkg = JSON.parse(fs11.readFileSync(path10.join(__dirname, "../package.json"), "utf-8"));
+var __dirname = path13.dirname(fileURLToPath(import.meta.url));
+var pkg = JSON.parse(fs14.readFileSync(path13.join(__dirname, "../package.json"), "utf-8"));
 configManager.init();
 var program = new Command();
-var banner = chalk15.cyan(figlet.textSync("Set-Prompt", { horizontalLayout: "full" }));
-program.name("set-prompt").description(pkg.description).version(pkg.version).addHelpText("beforeAll", banner + "\n").action(() => {
-  program.help();
-});
-program.command("install").description(`\u{1F4E6} Clone a ${chalk15.cyan("git repo")} into ${chalk15.dim("~/.set-prompt/repo/")} and register it as your prompt source`).argument("<url>", "remote git URL").action(async (source) => {
+var banner = chalk23.cyan(figlet.textSync("Set-Prompt", { horizontalLayout: "full" }));
+program.name("set-prompt").description(pkg.description).version(pkg.version).addHelpText("beforeAll", ({ command }) => command === program ? banner + "\n" : "");
+program.command("install").description(`\u{1F4E6} Clone a ${chalk23.cyan("git repo")} into ${chalk23.dim("~/.set-prompt/repo/")} and register it as your prompt source`).argument("<url>", "remote git URL").action(async (source) => {
   await installCommand(source);
 });
-program.command("link").description(`\u{1F517} Symlink your prompt repo into an ${chalk15.cyan("AI agent")} plugin dir ${chalk15.dim("(claudecode | roocode | openclaw | codex | antigravity)")}`).argument("[agent]", `target agent ${chalk15.dim("(omit for interactive selection)")}`).action(async (agent) => {
+program.command("link").description(`\u{1F517} Symlink your prompt repo into an ${chalk23.cyan("AI agent")} plugin dir ${chalk23.dim("(claudecode | roocode | openclaw | codex | antigravity)")}`).argument("[agent]", `target agent ${chalk23.dim("(omit for interactive selection)")}`).action(async (agent) => {
   await linkCommand(agent);
 });
-program.command("scaffold").description(`\u{1F6E0}\uFE0F  Verify and create ${chalk15.cyan("required directories")} in a prompt repo ${chalk15.dim("(-f to force overwrite)")}`).argument("[path]", `path to repo ${chalk15.dim("(defaults to installed source)")}`).action(async (localPath) => {
+program.command("scaffold").description(`\u{1F6E0}\uFE0F  Verify and create ${chalk23.cyan("required directories")} in a prompt repo ${chalk23.dim("(-f to force overwrite)")}`).argument("[path]", `path to repo ${chalk23.dim("(defaults to installed source)")}`).action(async (localPath) => {
   await scaffoldCommand(localPath);
 });
-program.command("status").description(`\u{1F4CB} Show registered ${chalk15.cyan("repo")} and which ${chalk15.cyan("agents")} are linked`).action(() => {
+program.command("status").description(`\u{1F4CB} Show registered ${chalk23.cyan("repo")} and which ${chalk23.cyan("agents")} are linked`).action(() => {
   statusCommand();
 });
-program.command("update").description(`\u{1F504} Fetch and pull the latest changes from the ${chalk15.cyan("remote repo")}`).action(() => {
-  updateCommand();
+var repo = program.command("repo").description(`\u{1F5C2}\uFE0F  Manage the installed prompt repo ${chalk23.dim("(status | pull | commit | push | save | path | open)")}`);
+repo.command("status").description(`\u{1F4CB} Show VCS status of the repo ${chalk23.dim("(branch, ahead/behind, changed files)")}`).addHelpText("after", `
+Example output:
+  \u{1F4C2} ~/.set-prompt/repo
+  \u{1F33F} main \u2192 origin/main (ahead 2)
+
+  \u{1F4DD} Changes (2):
+     modified   skills/foo.md
+     untracked  draft.md
+`).action(() => {
+  repoStatusCommand();
+});
+repo.command("pull").description(`\u{1F504} Fetch and pull the latest changes from the ${chalk23.cyan("remote repo")}`).action(() => {
+  repoPullCommand();
+});
+repo.command("commit").description(`\u{1F4DD} Stage all changes and commit ${chalk23.dim("(auto-generates message if -m omitted; does not push)")}`).option("-m, --message <msg>", "commit message (auto-generated from changed files if omitted)").addHelpText("after", `
+Examples:
+  $ sppt repo commit -m "edit dbml skill"
+  $ sppt repo commit                          ${chalk23.dim('# auto-generates "update N files" + file list')}
+`).action((opts) => {
+  repoCommitCommand({ message: opts.message });
+});
+repo.command("push").description(`\u2B06\uFE0F  Push local commits to the remote`).action(() => {
+  repoPushCommand();
+});
+repo.command("save").description(`\u{1F4BE} Stage + commit + push in one step ${chalk23.dim("(macro for commit \u2192 push; auto-generates message if -m omitted)")}`).option("-m, --message <msg>", "commit message (auto-generated from changed files if omitted)").addHelpText("after", `
+Examples:
+  $ sppt repo save -m "edit dbml skill"
+  $ sppt repo save                            ${chalk23.dim("# auto-generates message and pushes")}
+
+Equivalent to: sppt repo commit && sppt repo push
+`).action((opts) => {
+  repoSaveCommand({ message: opts.message });
+});
+repo.command("path").description(`\u{1F4CD} Print the repo path to stdout ${chalk23.dim("(e.g. cd $(sppt repo path))")}`).addHelpText("after", `
+Examples:
+  $ sppt repo path
+  ${chalk23.dim("/Users/me/.set-prompt/repo")}
+
+  $ cd "$(sppt repo path)"                    ${chalk23.dim("# jump into the repo")}
+  $ code "$(sppt repo path)"                  ${chalk23.dim("# open in VSCode")}
+`).action(() => {
+  repoPathCommand();
+});
+repo.command("open").description(`\u{1F4C2} Open the repo in the OS file manager ${chalk23.dim("(--code: VSCode, --stree: Sourcetree)")}`).option("--code", "open with VSCode (`code` CLI)").option("--stree", "open with Sourcetree (`stree` CLI)").addHelpText("after", `
+Examples:
+  $ sppt repo open                            ${chalk23.dim("# Explorer / Finder / xdg-open")}
+  $ sppt repo open --code                     ${chalk23.dim("# open in VSCode")}
+  $ sppt repo open --stree                    ${chalk23.dim("# open in Sourcetree")}
+`).action((opts) => {
+  repoOpenCommand({ code: opts.code, stree: opts.stree });
 });
-program.command("uninstall").description(`\u{1F5D1}\uFE0F  Remove all set-prompt data ${chalk15.dim("(~/.set-prompt/, plugin dirs, settings entries)")}`).action(async () => {
+program.command("uninstall").description(`\u{1F5D1}\uFE0F  Remove all set-prompt data ${chalk23.dim("(~/.set-prompt/, plugin dirs, settings entries)")}`).action(async () => {
   await uninstallCommand();
 });
 program.parse(process.argv);