@rhize/skill-forge 0.1.0 → 0.3.0

package/dist/cli.js

@@ -5,8 +5,7 @@ import { Command } from "commander";
 import { createRequire } from "module";
 
 // src/commands/add.ts
-import { createInterface } from "readline/promises";
-import { spawnSync } from "child_process";
+import { createInterface as createInterface2 } from "readline/promises";
 
 // src/config.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
@@ -38,19 +37,30 @@ function loadConfig() {
     skillsRoots: parsed.skillsRoots ?? defaults.skillsRoots,
     quarantineDir: parsed.quarantineDir ?? defaults.quarantineDir,
     strictness: parsed.strictness ?? defaults.strictness,
-    licenseKey: parsed.licenseKey ?? defaults.licenseKey
+    licenseKey: parsed.licenseKey ?? defaults.licenseKey,
+    defaultTarget: parsed.defaultTarget ?? defaults.defaultTarget,
+    agents: parsed.agents ?? defaults.agents,
+    handoffCommand: parsed.handoffCommand ?? defaults.handoffCommand
   };
 }
+function saveConfig(config) {
+  const home = getHomeDir();
+  if (!existsSync(home)) {
+    mkdirSync(home, { recursive: true });
+  }
+  writeFileSync(getConfigPath(), JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
 
 // src/install/resolve.ts
 import { existsSync as existsSync2 } from "fs";
 var GIT_URL_PATTERN = /^(git@|https?:\/\/|ssh:\/\/)/;
+var LOCAL_PATH_PATTERN = /^(\.{1,2}\/|\/|~\/|~$)/;
 function resolve(source) {
   const value = source.trim();
   if (GIT_URL_PATTERN.test(value) || value.endsWith(".git")) {
     return { type: "git", value };
   }
-  if (existsSync2(value)) {
+  if (existsSync2(value) || LOCAL_PATH_PATTERN.test(value)) {
     return { type: "local", value };
   }
   return { type: "skills.sh", value };
@@ -61,6 +71,16 @@ import { randomUUID } from "crypto";
 import { spawn } from "child_process";
 import { cpSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync } from "fs";
 import { basename, join as join2, resolve as resolvePath } from "path";
+
+// src/errors.ts
+var UserError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UserError";
+  }
+};
+
+// src/install/quarantine.ts
 var SKILL_MANIFEST = "SKILL.md";
 var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules"]);
 async function quarantine(source, quarantineDir, deps = {}) {
@@ -86,17 +106,23 @@ async function quarantine(source, quarantineDir, deps = {}) {
         cwd: quarantinePath
       });
       if (result.code !== 0) {
-        throw new Error(
+        throw new UserError(
           `git clone failed for "${source.value}" (exit ${result.code}): ${result.stderr || result.stdout}`
         );
       }
       break;
     }
     case "local": {
+      if (!existsSync3(source.value)) {
+        throw new UserError(`local path not found: ${source.value}`);
+      }
       const dirName = basename(resolvePath(source.value));
       cpSync(source.value, join2(quarantinePath, dirName), { recursive: true });
       break;
     }
+    default: {
+      throw new UserError(`unknown source type: ${source.type}`);
+    }
   }
   return { id, quarantinePath, skillDirs: findSkillDirs(quarantinePath), source };
 }
@@ -184,115 +210,11 @@ function moveDir(src, dest) {
   }
 }
 
-// src/license.ts
-import { verify as cryptoVerify } from "crypto";
-var LICENSE_PREFIX = "skf1";
-var PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
-MCowBQYDK2VwAyEAWSVbcX9u70IsN1O5zS5z+AYtAUVz7ExT7h+1gT9x+wQ=
------END PUBLIC KEY-----
-`;
-function readLicenseKey() {
-  const fromEnv = process.env.SKILL_FORGE_LICENSE?.trim();
-  if (fromEnv) return fromEnv;
-  return loadConfig().licenseKey?.trim() || void 0;
-}
-function isLicensePayload(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const p = value;
-  return typeof p.name === "string" && typeof p.email === "string" && typeof p.seats === "number" && typeof p.exp === "string";
-}
-function checkLicense(rawKey = readLicenseKey()) {
-  if (!rawKey) {
-    return { valid: false, reason: "missing" };
-  }
-  const parts = rawKey.trim().split(".");
-  if (parts.length !== 3 || parts[0] !== LICENSE_PREFIX) {
-    return { valid: false, reason: "malformed" };
-  }
-  const [, payloadPart, signaturePart] = parts;
-  const payloadBuffer = Buffer.from(payloadPart, "base64url");
-  const signature = Buffer.from(signaturePart, "base64url");
-  let payload;
-  try {
-    payload = JSON.parse(payloadBuffer.toString("utf-8"));
-  } catch {
-    return { valid: false, reason: "malformed" };
-  }
-  if (!isLicensePayload(payload)) {
-    return { valid: false, reason: "malformed" };
-  }
-  let signatureValid;
-  try {
-    signatureValid = cryptoVerify(null, payloadBuffer, PUBLIC_KEY_PEM, signature);
-  } catch {
-    return { valid: false, reason: "malformed" };
-  }
-  if (!signatureValid) {
-    return { valid: false, reason: "signature" };
-  }
-  const expMs = new Date(payload.exp).getTime();
-  if (Number.isNaN(expMs) || expMs < Date.now()) {
-    return { valid: false, reason: "expired" };
-  }
-  return { valid: true, payload };
-}
-function hasProLicense() {
-  return checkLicense().valid;
-}
-function upgradeNotice(feature) {
-  return `[skill-forge] Pro feature (${feature}) \u2014 set SKILL_FORGE_LICENSE or config.licenseKey to a valid license to unlock.`;
-}
-
-// src/report/render.ts
-var BORDER = "\u2501".repeat(55);
-var LABEL_WIDTH = 20;
-function padLabel(text) {
-  return text.padEnd(LABEL_WIDTH);
-}
-function renderListField(labelText, items, placeholder) {
-  const head = `${padLabel(labelText)}: `;
-  if (!items || items.length === 0) {
-    return `${head}${placeholder}`;
-  }
-  const bullets = items.map((item) => `  - ${item}`).join("\n");
-  return `${head.trimEnd()}
-${bullets}`;
-}
-function renderSafetyLine(safety) {
-  const detail = [safety.severity, safety.score !== void 0 ? `score ${safety.score}` : void 0].filter((v) => Boolean(v)).join(", ");
-  const withDetail = detail ? `${safety.verdict} (${detail})` : safety.verdict;
-  return safety.recommendation ? `${withDetail} \u2014 ${safety.recommendation}` : withDetail;
-}
-function renderReport(result) {
-  const { profile, overlap, overlapLocked, safety, worthTaking, leaveBehind } = result;
-  const name = profile.name ?? "unknown";
-  const version = profile.version ?? "unknown";
-  const license = profile.license ?? "UNKNOWN";
-  const overlapLines = overlapLocked ? [`${padLabel("Overlap analysis")}: ${upgradeNotice("overlap analysis")}`] : overlap ? [
-    `${padLabel("Nearest Rhize skill")}: ${overlap.nearest}  (overlap ${overlap.nearestScore})`,
-    `${padLabel("Recommended verb")}: ${overlap.suggestedVerb}`
-  ] : [`${padLabel("Nearest Rhize skill")}: n/a \u2014 no skills root configured`, `${padLabel("Recommended verb")}: n/a`];
-  const lines = [
-    BORDER,
-    `\u{1F528} Forge: ${name}  (v${version}, ${license})`,
-    BORDER,
-    ...overlapLines,
-    renderListField("What's worth taking", worthTaking, "(pending \u2014 not yet determined)"),
-    renderListField("What to leave behind", leaveBehind, "(pending \u2014 not yet determined)"),
-    `${padLabel("Safety verdict")}: ${renderSafetyLine(safety)}`,
-    BORDER
-  ];
-  return lines.join("\n");
-}
-function renderJson(result) {
-  return JSON.stringify(result, null, 2);
-}
-
 // src/provenance.ts
 import { appendFileSync, existsSync as existsSync5, statSync, writeFileSync as writeFileSync2 } from "fs";
 import { join as join4 } from "path";
 var FORGE_VERBS = ["DEFER", "ABSORB", "FORK", "REJECT", "WATCH"];
-var LEDGER_HEADER = "# Rhize Skill Forge \u2014 Provenance Ledger\n\nOne entry per external-skill ingestion decision.\n";
+var LEDGER_HEADER = "# Skill Forge \u2014 Provenance Ledger\n\nOne entry per external-skill ingestion decision.\n";
 function todayLocalIsoDate() {
   const d = /* @__PURE__ */ new Date();
   const year = d.getFullYear();
@@ -1064,12 +986,159 @@ function scanOverlap(candidatePath, skillsRoot) {
   };
 }
 
+// src/license.ts
+import { verify as cryptoVerify } from "crypto";
+var LICENSE_PREFIX = "skf1";
+var BETA_FREE = true;
+var PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEAWSVbcX9u70IsN1O5zS5z+AYtAUVz7ExT7h+1gT9x+wQ=
+-----END PUBLIC KEY-----
+`;
+function readLicenseKey() {
+  const fromEnv = process.env.SKILL_FORGE_LICENSE?.trim();
+  if (fromEnv) return fromEnv;
+  return loadConfig().licenseKey?.trim() || void 0;
+}
+function isLicensePayload(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const p = value;
+  return typeof p.name === "string" && typeof p.email === "string" && typeof p.seats === "number" && typeof p.exp === "string";
+}
+function checkLicense(rawKey = readLicenseKey()) {
+  if (!rawKey) {
+    return { valid: false, reason: "missing" };
+  }
+  const parts = rawKey.trim().split(".");
+  if (parts.length !== 3 || parts[0] !== LICENSE_PREFIX) {
+    return { valid: false, reason: "malformed" };
+  }
+  const [, payloadPart, signaturePart] = parts;
+  const payloadBuffer = Buffer.from(payloadPart, "base64url");
+  const signature = Buffer.from(signaturePart, "base64url");
+  let payload;
+  try {
+    payload = JSON.parse(payloadBuffer.toString("utf-8"));
+  } catch {
+    return { valid: false, reason: "malformed" };
+  }
+  if (!isLicensePayload(payload)) {
+    return { valid: false, reason: "malformed" };
+  }
+  let signatureValid;
+  try {
+    signatureValid = cryptoVerify(null, payloadBuffer, PUBLIC_KEY_PEM, signature);
+  } catch {
+    return { valid: false, reason: "malformed" };
+  }
+  if (!signatureValid) {
+    return { valid: false, reason: "signature" };
+  }
+  const expMs = new Date(payload.exp).getTime();
+  if (Number.isNaN(expMs) || expMs < Date.now()) {
+    return { valid: false, reason: "expired" };
+  }
+  return { valid: true, payload };
+}
+function upgradeNotice(feature) {
+  return `[skill-forge] Pro feature (${feature}) \u2014 set SKILL_FORGE_LICENSE or config.licenseKey to a valid license to unlock.`;
+}
+function invalidLicenseReasonText(reason) {
+  switch (reason) {
+    case "malformed":
+      return "is malformed";
+    case "signature":
+      return "has an invalid signature";
+    case "expired":
+      return "has expired";
+    default:
+      return "is invalid";
+  }
+}
+function proFeatureStatus(feature, betaFree = BETA_FREE) {
+  const status2 = checkLicense();
+  if (status2.valid) {
+    return { enabled: true };
+  }
+  if (!betaFree) {
+    return { enabled: false, notice: upgradeNotice(feature) };
+  }
+  const betaNotice = `Pro feature (${feature}) \u2014 free during the 0.x beta; will require a license at 1.0.`;
+  if (status2.reason === "missing") {
+    return { enabled: true, notice: betaNotice };
+  }
+  return {
+    enabled: true,
+    notice: `${betaNotice} (Note: your license key ${invalidLicenseReasonText(status2.reason)} \u2014 ignored while Pro is free.)`
+  };
+}
+
+// src/report/render.ts
+var BORDER = "\u2501".repeat(55);
+var LABEL_WIDTH = 20;
+function padLabel(text) {
+  return text.padEnd(LABEL_WIDTH);
+}
+function renderListField(labelText, items, placeholder) {
+  const head = `${padLabel(labelText)}: `;
+  if (!items || items.length === 0) {
+    return `${head}${placeholder}`;
+  }
+  const bullets = items.map((item) => `  - ${item}`).join("\n");
+  return `${head.trimEnd()}
+${bullets}`;
+}
+function renderSafetyLine(safety) {
+  const detail = [safety.severity, safety.score !== void 0 ? `score ${safety.score}` : void 0].filter((v) => Boolean(v)).join(", ");
+  const withDetail = detail ? `${safety.verdict} (${detail})` : safety.verdict;
+  return safety.recommendation ? `${withDetail} \u2014 ${safety.recommendation}` : withDetail;
+}
+function renderFindingLine(finding) {
+  const severity = finding.severity ?? "UNKNOWN";
+  const rule = finding.rule ?? "unknown-rule";
+  return `  - [${severity}] ${rule}${finding.message ? `: ${finding.message}` : ""}`;
+}
+function renderFindingsLines(findings) {
+  if (!findings?.length) return [];
+  return [`${padLabel("Findings")}:`, ...findings.map(renderFindingLine)];
+}
+function renderReport(result) {
+  const { profile, overlap, overlapLocked, safety, worthTaking, leaveBehind } = result;
+  const name = profile.name ?? "unknown";
+  const version = profile.version ?? "unknown";
+  const license = profile.license ?? "UNKNOWN";
+  const overlapLines = overlapLocked ? [`${padLabel("Overlap analysis")}: ${upgradeNotice("overlap analysis")}`] : overlap ? [
+    `${padLabel("Nearest existing skill")}: ${overlap.nearest}  (overlap ${overlap.nearestScore})`,
+    `${padLabel("Recommended verb")}: ${overlap.suggestedVerb}`
+  ] : [`${padLabel("Nearest existing skill")}: n/a \u2014 no skills root configured`, `${padLabel("Recommended verb")}: n/a`];
+  const lines = [
+    BORDER,
+    `\u{1F528} Forge: ${name}  (v${version}, ${license})`,
+    BORDER,
+    ...overlapLines,
+    renderListField("What's worth taking", worthTaking, "(pending \u2014 not yet determined)"),
+    renderListField("What to leave behind", leaveBehind, "(pending \u2014 not yet determined)"),
+    `${padLabel("Safety verdict")}: ${renderSafetyLine(safety)}`,
+    ...renderFindingsLines(safety.findings),
+    BORDER
+  ];
+  return lines.join("\n");
+}
+function renderJson(result) {
+  return JSON.stringify(result, null, 2);
+}
+
 // src/commands/gatePipeline.ts
 var SAFETY_VERDICT_MAP = {
   pass: "ALLOW",
   warn: "CAUTION",
   block: "BLOCK"
 };
+function printGateOutput(gateResult, json) {
+  if (!json) {
+    for (const notice of gateResult.notices ?? []) console.log(`[skill-forge] ${notice}`);
+  }
+  console.log(json ? renderJson(gateResult) : renderReport(gateResult));
+}
 function asSkillProfile(candidatePath) {
   const profile = profileSkill(candidatePath);
   if (profile.kind !== "skill") {
@@ -1085,15 +1154,16 @@ function tryOverlap(candidatePath, skillsRoot) {
     return void 0;
   }
 }
-async function runGate(candidatePath, skillsRoot) {
+async function runGate(candidatePath, skillsRoot, proFeatureLabel = "overlap analysis") {
   const profile = asSkillProfile(candidatePath);
   const safety = await scanSafety(candidatePath);
-  const pro = hasProLicense();
-  const overlap = pro ? tryOverlap(candidatePath, skillsRoot) : void 0;
+  const proStatus = proFeatureStatus(proFeatureLabel);
+  const overlap = proStatus.enabled ? tryOverlap(candidatePath, skillsRoot) : void 0;
   const gateResult = {
     profile,
     overlap,
-    overlapLocked: !pro,
+    overlapLocked: !proStatus.enabled,
+    notices: proStatus.notice ? [proStatus.notice] : void 0,
     safety: {
       verdict: SAFETY_VERDICT_MAP[safety.verdict],
       findings: safety.findings.map((f) => ({
@@ -1103,7 +1173,7 @@ async function runGate(candidatePath, skillsRoot) {
       }))
     }
   };
-  return { safety, gateResult, pro };
+  return { safety, gateResult, proEnabled: proStatus.enabled };
 }
 
 // src/queue.ts
@@ -1146,10 +1216,392 @@ function generateId(existingIds) {
   return id;
 }
 
+// src/handoff.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync9 } from "fs";
+import { dirname as dirname3, join as join10 } from "path";
+import { fileURLToPath } from "url";
+var KNOWN_AGENT_BINARIES = ["claude", "codex", "cursor-agent", "windsurf", "opencode", "gemini"];
+var HANDOFF_INSTRUCTION = "Read {prompt} and follow its instructions for the skill installed at {path}";
+function resolvePromptPath() {
+  const here = dirname3(fileURLToPath(import.meta.url));
+  const builtCandidate = join10(here, "ingest-prompt.md");
+  if (existsSync9(builtCandidate)) return builtCandidate;
+  return join10(here, "..", "assets", "ingest-prompt.md");
+}
+function defaultIsOnPath(bin) {
+  const finder = process.platform === "win32" ? "where" : "which";
+  const result = spawnSync(finder, [bin], { stdio: "ignore" });
+  return result.status === 0;
+}
+function substitute(template, vars) {
+  return template.map((token) => token.replace(/\{(\w+)\}/g, (match, key) => vars[key] ?? match));
+}
+function buildHandoffCommand(config, installedPath, deps = {}) {
+  const isOnPath = deps.isOnPath ?? defaultIsOnPath;
+  const promptPath = resolvePromptPath();
+  const vars = { path: installedPath, prompt: promptPath };
+  if (config.handoffCommand && config.handoffCommand.length > 0) {
+    return { argv: substitute(config.handoffCommand, vars), source: "template" };
+  }
+  for (const bin of KNOWN_AGENT_BINARIES) {
+    if (isOnPath(bin)) {
+      return { argv: substitute([bin, "-p", HANDOFF_INSTRUCTION], vars), source: "detected" };
+    }
+  }
+  return { argv: [], source: "none" };
+}
+function printOnlyMessage(installedPath) {
+  const promptPath = resolvePromptPath();
+  return `[skill-forge] no agent handoff available \u2014 run one yourself:
+  Prompt:      ${promptPath}
+  Skill path:  ${installedPath}`;
+}
+function runHandoff(config, installedPath, options = {}) {
+  const command = buildHandoffCommand(config, installedPath, options);
+  const spawn2 = options.spawn ?? spawnSync;
+  if (command.source === "none" || command.argv.length === 0) {
+    const printed = printOnlyMessage(installedPath);
+    console.log(printed);
+    return { ran: false, command, printed };
+  }
+  const [bin, ...args] = command.argv;
+  const result = spawn2(bin, args, { stdio: options.stdio ?? "inherit" });
+  const error = result.error;
+  if (error?.code === "ENOENT") {
+    const printed = printOnlyMessage(installedPath);
+    console.log(`[skill-forge] ${bin} not found on PATH \u2014 run this yourself:`);
+    console.log(printed);
+    return { ran: false, command, printed, error: error.message };
+  }
+  if (error) {
+    console.error(`[skill-forge] failed to launch handoff: ${error.message}`);
+    return { ran: false, command, error: error.message };
+  }
+  return { ran: true, command };
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync10 } from "fs";
+import { homedir as homedir4 } from "os";
+import { createInterface } from "readline/promises";
+
+// src/agents.ts
+import { homedir as homedir3 } from "os";
+import { join as join11, resolve as resolve4 } from "path";
+function projectPath(root, cwd) {
+  return root ? resolve4(cwd, root) : void 0;
+}
+function globalPath(root, home) {
+  if (!root) return void 0;
+  if (root === "~") return home;
+  if (root.startsWith("~/")) return join11(home, root.slice(2));
+  return root;
+}
+function makeAgent(spec) {
+  const agent = {
+    id: spec.id,
+    displayName: spec.displayName,
+    projectRoot: spec.projectRoot,
+    globalRoot: spec.globalRoot,
+    verified: spec.verified ?? true,
+    defaultHandoffTemplate: spec.defaultHandoffTemplate,
+    detect: (cwd, home) => detectAgentRoot(agent, cwd, home) !== void 0
+  };
+  return agent;
+}
+function resolveAgentRoot(agent, scope, cwd = process.cwd(), home = homedir3()) {
+  return scope === "project" ? projectPath(agent.projectRoot, cwd) : globalPath(agent.globalRoot, home);
+}
+function detectAgentRoot(agent, cwd = process.cwd(), home = homedir3()) {
+  for (const scope of ["project", "global"]) {
+    const root = resolveAgentRoot(agent, scope, cwd, home);
+    if (root && isDir(root)) return { scope, root };
+  }
+  return void 0;
+}
+var AGENTS = [
+  { id: "aider-desk", displayName: "AiderDesk", projectRoot: ".aider-desk/skills", globalRoot: "~/.aider-desk/skills" },
+  { id: "amp", displayName: "Amp", projectRoot: ".agents/skills", globalRoot: "~/.config/agents/skills" },
+  { id: "replit", displayName: "Replit", projectRoot: ".agents/skills", globalRoot: "~/.config/agents/skills" },
+  { id: "universal", displayName: "Universal", projectRoot: ".agents/skills", globalRoot: "~/.config/agents/skills" },
+  { id: "antigravity", displayName: "Antigravity", projectRoot: ".agents/skills", globalRoot: "~/.gemini/antigravity/skills" },
+  {
+    id: "antigravity-cli",
+    displayName: "Antigravity CLI",
+    projectRoot: ".agents/skills",
+    globalRoot: "~/.gemini/antigravity-cli/skills"
+  },
+  { id: "astrbot", displayName: "AstrBot", projectRoot: "data/skills", globalRoot: "~/.astrbot/data/skills" },
+  { id: "autohand-code", displayName: "Autohand Code CLI", projectRoot: ".autohand/skills", globalRoot: "~/.autohand/skills" },
+  { id: "augment", displayName: "Augment", projectRoot: ".augment/skills", globalRoot: "~/.augment/skills" },
+  { id: "bob", displayName: "IBM Bob", projectRoot: ".bob/skills", globalRoot: "~/.bob/skills" },
+  {
+    id: "claude-code",
+    displayName: "Claude Code",
+    projectRoot: ".claude/skills",
+    globalRoot: "~/.claude/skills",
+    defaultHandoffTemplate: ["claude", "-p", HANDOFF_INSTRUCTION]
+  },
+  { id: "openclaw", displayName: "OpenClaw", projectRoot: "skills", globalRoot: "~/.openclaw/skills" },
+  { id: "cline", displayName: "Cline", projectRoot: ".agents/skills", globalRoot: "~/.agents/skills" },
+  { id: "dexto", displayName: "Dexto", projectRoot: ".agents/skills", globalRoot: "~/.agents/skills" },
+  { id: "kimi-code-cli", displayName: "Kimi Code CLI", projectRoot: ".agents/skills", globalRoot: "~/.agents/skills" },
+  { id: "loaf", displayName: "Loaf", projectRoot: ".agents/skills", globalRoot: "~/.agents/skills" },
+  { id: "warp", displayName: "Warp", projectRoot: ".agents/skills", globalRoot: "~/.agents/skills" },
+  { id: "zed", displayName: "Zed", projectRoot: ".agents/skills", globalRoot: "~/.agents/skills" },
+  {
+    id: "codearts-agent",
+    displayName: "CodeArts Agent",
+    projectRoot: ".codeartsdoer/skills",
+    globalRoot: "~/.codeartsdoer/skills"
+  },
+  { id: "codebuddy", displayName: "CodeBuddy", projectRoot: ".codebuddy/skills", globalRoot: "~/.codebuddy/skills" },
+  { id: "codemaker", displayName: "Codemaker", projectRoot: ".codemaker/skills", globalRoot: "~/.codemaker/skills" },
+  { id: "codestudio", displayName: "Code Studio", projectRoot: ".codestudio/skills", globalRoot: "~/.codestudio/skills" },
+  {
+    id: "codex",
+    displayName: "Codex",
+    projectRoot: ".agents/skills",
+    globalRoot: "~/.codex/skills",
+    defaultHandoffTemplate: ["codex", "exec", HANDOFF_INSTRUCTION]
+  },
+  {
+    id: "command-code",
+    displayName: "Command Code",
+    projectRoot: ".commandcode/skills",
+    globalRoot: "~/.commandcode/skills"
+  },
+  { id: "continue", displayName: "Continue", projectRoot: ".continue/skills", globalRoot: "~/.continue/skills" },
+  { id: "cortex", displayName: "Cortex Code", projectRoot: ".cortex/skills", globalRoot: "~/.snowflake/cortex/skills" },
+  { id: "crush", displayName: "Crush", projectRoot: ".crush/skills", globalRoot: "~/.config/crush/skills" },
+  { id: "cursor", displayName: "Cursor", projectRoot: ".agents/skills", globalRoot: "~/.cursor/skills" },
+  {
+    id: "deepagents",
+    displayName: "Deep Agents",
+    projectRoot: ".agents/skills",
+    globalRoot: "~/.deepagents/agent/skills"
+  },
+  { id: "devin", displayName: "Devin for Terminal", projectRoot: ".devin/skills", globalRoot: "~/.config/devin/skills" },
+  { id: "droid", displayName: "Droid", projectRoot: ".factory/skills", globalRoot: "~/.factory/skills" },
+  { id: "eve", displayName: "Eve", projectRoot: "agent/skills" },
+  { id: "firebender", displayName: "Firebender", projectRoot: ".agents/skills", globalRoot: "~/.firebender/skills" },
+  { id: "forgecode", displayName: "ForgeCode", projectRoot: ".forge/skills", globalRoot: "~/.forge/skills" },
+  {
+    id: "gemini-cli",
+    displayName: "Gemini CLI",
+    projectRoot: ".agents/skills",
+    globalRoot: "~/.gemini/skills",
+    defaultHandoffTemplate: ["gemini", "-p", HANDOFF_INSTRUCTION]
+  },
+  {
+    id: "github-copilot",
+    displayName: "GitHub Copilot",
+    projectRoot: ".agents/skills",
+    globalRoot: "~/.copilot/skills"
+  },
+  { id: "goose", displayName: "Goose", projectRoot: ".goose/skills", globalRoot: "~/.config/goose/skills" },
+  { id: "hermes-agent", displayName: "Hermes Agent", projectRoot: ".hermes/skills", globalRoot: "~/.hermes/skills" },
+  {
+    id: "inference-sh",
+    displayName: "inference.sh",
+    projectRoot: ".inferencesh/skills",
+    globalRoot: "~/.inferencesh/skills"
+  },
+  { id: "jazz", displayName: "Jazz", projectRoot: ".jazz/skills", globalRoot: "~/.jazz/skills" },
+  { id: "junie", displayName: "Junie", projectRoot: ".junie/skills", globalRoot: "~/.junie/skills" },
+  { id: "iflow-cli", displayName: "iFlow CLI", projectRoot: ".iflow/skills", globalRoot: "~/.iflow/skills" },
+  { id: "kilo", displayName: "Kilo Code", projectRoot: ".kilocode/skills", globalRoot: "~/.kilocode/skills" },
+  { id: "kiro-cli", displayName: "Kiro CLI", projectRoot: ".kiro/skills", globalRoot: "~/.kiro/skills" },
+  { id: "kode", displayName: "Kode", projectRoot: ".kode/skills", globalRoot: "~/.kode/skills" },
+  { id: "lingma", displayName: "Lingma", projectRoot: ".lingma/skills", globalRoot: "~/.lingma/skills" },
+  { id: "mcpjam", displayName: "MCPJam", projectRoot: ".mcpjam/skills", globalRoot: "~/.mcpjam/skills" },
+  { id: "mistral-vibe", displayName: "Mistral Vibe", projectRoot: ".vibe/skills", globalRoot: "~/.vibe/skills" },
+  { id: "moxby", displayName: "Moxby", projectRoot: ".moxby/skills", globalRoot: "~/.moxby/skills" },
+  { id: "mux", displayName: "Mux", projectRoot: ".mux/skills", globalRoot: "~/.mux/skills" },
+  {
+    id: "opencode",
+    displayName: "OpenCode",
+    projectRoot: ".agents/skills",
+    globalRoot: "~/.config/opencode/skills",
+    defaultHandoffTemplate: ["opencode", "run", HANDOFF_INSTRUCTION]
+  },
+  { id: "openhands", displayName: "OpenHands", projectRoot: ".openhands/skills", globalRoot: "~/.openhands/skills" },
+  { id: "ona", displayName: "Ona", projectRoot: ".ona/skills", globalRoot: "~/.ona/skills" },
+  { id: "pi", displayName: "Pi", projectRoot: ".pi/skills", globalRoot: "~/.pi/agent/skills" },
+  { id: "qoder", displayName: "Qoder", projectRoot: ".qoder/skills", globalRoot: "~/.qoder/skills" },
+  { id: "qoder-cn", displayName: "Qoder CN", projectRoot: ".qoder/skills", globalRoot: "~/.qoder-cn/skills" },
+  { id: "qwen-code", displayName: "Qwen Code", projectRoot: ".qwen/skills", globalRoot: "~/.qwen/skills" },
+  { id: "reasonix", displayName: "Reasonix", projectRoot: ".reasonix/skills", globalRoot: "~/.reasonix/skills" },
+  { id: "rovodev", displayName: "Rovo Dev", projectRoot: ".rovodev/skills", globalRoot: "~/.rovodev/skills" },
+  { id: "roo", displayName: "Roo Code", projectRoot: ".roo/skills", globalRoot: "~/.roo/skills" },
+  {
+    id: "tabnine-cli",
+    displayName: "Tabnine CLI",
+    projectRoot: ".tabnine/agent/skills",
+    globalRoot: "~/.tabnine/agent/skills"
+  },
+  { id: "terramind", displayName: "Terramind", projectRoot: ".terramind/skills", globalRoot: "~/.terramind/skills" },
+  { id: "tinycloud", displayName: "Tinycloud", projectRoot: ".tinycloud/skills", globalRoot: "~/.tinycloud/skills" },
+  { id: "trae", displayName: "Trae", projectRoot: ".trae/skills", globalRoot: "~/.trae/skills" },
+  { id: "trae-cn", displayName: "Trae CN", projectRoot: ".trae/skills", globalRoot: "~/.trae-cn/skills" },
+  { id: "windsurf", displayName: "Windsurf", projectRoot: ".windsurf/skills", globalRoot: "~/.codeium/windsurf/skills" },
+  { id: "zcode", displayName: "ZCode", projectRoot: ".zcode/skills", globalRoot: "~/.zcode/skills" },
+  { id: "zencoder", displayName: "Zencoder", projectRoot: ".zencoder/skills", globalRoot: "~/.zencoder/skills" },
+  { id: "zenflow", displayName: "Zenflow", projectRoot: ".zencoder/skills", globalRoot: "~/.zencoder/skills" },
+  { id: "neovate", displayName: "Neovate", projectRoot: ".neovate/skills", globalRoot: "~/.neovate/skills" },
+  { id: "pochi", displayName: "Pochi", projectRoot: ".pochi/skills", globalRoot: "~/.pochi/skills" },
+  { id: "promptscript", displayName: "PromptScript", projectRoot: ".agents/skills" },
+  { id: "adal", displayName: "AdaL", projectRoot: ".adal/skills", globalRoot: "~/.adal/skills" }
+].map(makeAgent);
+
+// src/commands/init.ts
+function detectAgents(cwd, home) {
+  const found = [];
+  for (const agent of AGENTS) {
+    const hit = detectAgentRoot(agent, cwd, home);
+    if (hit) found.push({ agent, ...hit });
+  }
+  return found;
+}
+function printDetectionResults(detected) {
+  console.log(`[skill-forge] init \u2014 agent detection (${AGENTS.length} known agents)`);
+  if (detected.length === 0) {
+    console.log("  none detected");
+    return;
+  }
+  for (const d of detected) {
+    console.log(`  ${d.agent.displayName} (${d.agent.id}) \u2014 ${d.scope}: ${d.root}`);
+  }
+}
+function handoffTemplateFor(agent) {
+  return agent.defaultHandoffTemplate ?? [agent.id, "-p", HANDOFF_INSTRUCTION];
+}
+function buildConfig(selected, defaultTargetEntry, handoffAgent) {
+  const existing = loadConfig();
+  return {
+    ...existing,
+    skillsRoots: selected.map((s) => s.root),
+    agents: selected.map((s) => ({ id: s.agent.id, skillsRoot: s.root })),
+    defaultTarget: defaultTargetEntry?.root ?? existing.defaultTarget,
+    handoffCommand: handoffAgent ? handoffTemplateFor(handoffAgent) : existing.handoffCommand
+  };
+}
+function printSummary(config) {
+  console.log(`
+[skill-forge] wrote config to ${getConfigPath()}`);
+  console.log(`  gate targets: ${config.skillsRoots.join(", ")}`);
+  if (config.defaultTarget) console.log(`  default target: ${config.defaultTarget}`);
+  if (config.handoffCommand?.length) console.log(`  handoff command: ${config.handoffCommand.join(" ")}`);
+}
+function parseChoice(answer, max) {
+  const n = Number(answer);
+  return Number.isInteger(n) && n >= 1 && n <= max ? n - 1 : void 0;
+}
+async function promptMultiSelect(rl, detected) {
+  const chosen = new Set(detected.map((_, i) => i));
+  for (; ; ) {
+    console.log("\nGate targets (all detected roots pre-selected \u2014 type a number to toggle, Enter to confirm):");
+    detected.forEach((d, i) => {
+      const mark = chosen.has(i) ? "[x]" : "[ ]";
+      console.log(`  ${mark} ${i + 1}. ${d.agent.displayName} (${d.scope}) \u2014 ${d.root}`);
+    });
+    const answer = (await rl.question("> ")).trim();
+    if (answer === "") break;
+    const idx = parseChoice(answer, detected.length);
+    if (idx !== void 0) {
+      if (chosen.has(idx)) chosen.delete(idx);
+      else chosen.add(idx);
+    } else {
+      console.log("  (invalid selection \u2014 enter a listed number, or press Enter to confirm)");
+    }
+  }
+  return detected.filter((_, i) => chosen.has(i));
+}
+async function promptDefaultTarget(rl, selected) {
+  console.log("\nDefault promotion target:");
+  selected.forEach((d, i) => console.log(`  ${i + 1}. ${d.agent.displayName} \u2014 ${d.root}`));
+  const answer = (await rl.question(`Choose [1-${selected.length}] (default 1): `)).trim();
+  const idx = answer === "" ? 0 : parseChoice(answer, selected.length) ?? 0;
+  return selected[idx];
+}
+async function promptHandoffAgent(rl, detected) {
+  console.log("\nHandoff agent (used to hand off follow-up prompts after promotion; optional):");
+  detected.forEach((d, i) => {
+    const note = d.agent.defaultHandoffTemplate ? "" : " (no confirmed CLI \u2014 best-effort)";
+    console.log(`  ${i + 1}. ${d.agent.displayName}${note}`);
+  });
+  const answer = (await rl.question(`Choose [1-${detected.length}] or Enter to skip: `)).trim();
+  if (answer === "") return void 0;
+  const idx = parseChoice(answer, detected.length);
+  return idx === void 0 ? void 0 : detected[idx].agent;
+}
+async function init(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const home = options.home ?? homedir4();
+  const detected = detectAgents(cwd, home);
+  if (options.list) {
+    printDetectionResults(detected);
+    return;
+  }
+  if (detected.length === 0) {
+    console.log("[skill-forge] No known agent skill directories were found.");
+    console.log("  Install a coding agent (Claude Code, Codex, Cursor, ...) or create a skills root, then re-run `skill-forge init`.");
+    return;
+  }
+  if (options.defaults) {
+    const config = buildConfig(detected, detected[0], void 0);
+    saveConfig(config);
+    printSummary(config);
+    return;
+  }
+  if (!process.stdin.isTTY) {
+    console.log("[skill-forge] Not an interactive terminal \u2014 run with --defaults for non-interactive setup.");
+    return;
+  }
+  printDetectionResults(detected);
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const selected = await promptMultiSelect(rl, detected);
+    if (selected.length === 0) {
+      console.log("[skill-forge] No targets selected \u2014 aborting, nothing written.");
+      return;
+    }
+    const target = await promptDefaultTarget(rl, selected);
+    const handoffAgent = await promptHandoffAgent(rl, detected);
+    const config = buildConfig(selected, target, handoffAgent);
+    saveConfig(config);
+    printSummary(config);
+  } finally {
+    rl.close();
+  }
+}
+async function maybeOfferInit(options = {}) {
+  if (options.json || options.yes || !process.stdin.isTTY) return;
+  if (existsSync10(getConfigPath())) return;
+  console.log("[skill-forge] No config found \u2014 run `skill-forge init` to detect your agents and set gate targets.");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  let answer = "";
+  try {
+    answer = (await rl.question("Run `skill-forge init` now? [y/N] ")).trim().toLowerCase();
+  } finally {
+    rl.close();
+  }
+  if (answer === "y" || answer === "yes") {
+    await init();
+  }
+}
+
 // src/commands/add.ts
+var PRO_FEATURE_LABEL = "overlap analysis, the provenance ledger, and the pending-ingestion queue";
+function logOutcome(message, json) {
+  if (json) console.error(message);
+  else console.log(message);
+}
 async function add(source, options = {}) {
+  await maybeOfferInit({ json: options.json, yes: options.yes });
   const config = loadConfig();
-  const targetRoot = options.target ?? config.skillsRoots[0];
+  const targetRoot = options.target ?? config.defaultTarget ?? config.skillsRoots[0];
   if (!targetRoot) {
     throw new Error("no target skills root configured; pass --target <dir> or set skillsRoots in the config");
   }
@@ -1167,15 +1619,15 @@ async function add(source, options = {}) {
 ` + entry.skillDirs.map((d) => `  - ${d}`).join("\n")
     );
   }
-  const { safety, gateResult, pro } = await runGate(entry.skillDirs[0], targetRoot);
+  const { safety, gateResult, proEnabled } = await runGate(entry.skillDirs[0], targetRoot, PRO_FEATURE_LABEL);
   const { profile, overlap } = gateResult;
-  console.log(options.json ? renderJson(gateResult) : renderReport(gateResult));
-  const decision = options.yes ? yesDecision(safety.verdict) : await promptDecision(safety.verdict);
+  printGateOutput(gateResult, options.json);
+  const decision = options.yes || options.json ? yesDecision(safety.verdict) : await promptDecision(safety.verdict);
   let installedPath = null;
   if (decision === "promote") {
     const result = promote(entry, targetRoot);
-    console.log(`[skill-forge] promoted -> ${result.promoted.join(", ")}`);
-    if (pro) {
+    logOutcome(`[skill-forge] promoted -> ${result.promoted.join(", ")}`, options.json);
+    if (proEnabled) {
       const ledgerPath = appendProvenance(
         {
           name: profile.name ?? entry.id,
@@ -1189,19 +1641,19 @@ async function add(source, options = {}) {
         },
         targetRoot
       );
-      console.log(`[skill-forge] provenance recorded -> ${ledgerPath}`);
+      logOutcome(`[skill-forge] provenance recorded -> ${ledgerPath}`, options.json);
     }
     installedPath = result.promoted[0] ?? null;
   } else if (decision === "reject") {
     reject(entry);
-    console.log("[skill-forge] rejected \u2014 quarantine sandbox removed");
+    logOutcome("[skill-forge] rejected \u2014 quarantine sandbox removed", options.json);
     if (safety.verdict === "block") process.exitCode = 1;
     return;
   } else {
     hold(entry);
-    console.log(`[skill-forge] held in quarantine -> ${entry.quarantinePath}`);
+    logOutcome(`[skill-forge] held in quarantine -> ${entry.quarantinePath}`, options.json);
   }
-  if (pro) {
+  if (proEnabled) {
     appendQueueEntry({
       source,
       sourceType: resolved.type,
@@ -1217,28 +1669,15 @@ async function add(source, options = {}) {
       status: "pending"
     });
     if (options.ingest && installedPath) {
-      handoffToClaude(installedPath);
+      runHandoff(config, installedPath);
     }
-  } else {
-    console.log(upgradeNotice("provenance ledger, pending-ingestion queue, and --ingest handoff"));
-  }
-}
-function handoffToClaude(installedPath) {
-  const command = `/rhize-meta:forge-ingest ${installedPath}`;
-  const result = spawnSync("claude", ["-p", command], { stdio: "inherit" });
-  const error = result.error;
-  if (error?.code === "ENOENT") {
-    console.log("[skill-forge] claude not found on PATH \u2014 run this yourself:");
-    console.log(`  claude -p "${command}"`);
-  } else if (error) {
-    console.error(`[skill-forge] failed to launch claude: ${error.message}`);
   }
 }
 function yesDecision(verdict) {
   return verdict === "block" ? "reject" : "promote";
 }
 async function promptDecision(verdict) {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
   const defaultChoice = verdict === "block" ? "reject" : verdict === "warn" ? "hold" : "promote";
   const prompt = `Promote, hold, or reject this skill? [promote/hold/reject] (default: ${defaultChoice}) `;
   try {
@@ -1258,7 +1697,8 @@ ${prompt}`);
 }
 
 // src/commands/scan.ts
-async function scan(source) {
+async function scan(source, options = {}) {
+  await maybeOfferInit({ json: options.json });
   const config = loadConfig();
   const skillsRoot = config.skillsRoots[0];
   if (!skillsRoot) {
@@ -1279,7 +1719,7 @@ async function scan(source) {
       );
     }
     const { safety, gateResult } = await runGate(entry.skillDirs[0], skillsRoot);
-    console.log(renderReport(gateResult));
+    printGateOutput(gateResult, options.json);
     if (safety.verdict === "block") {
       process.exitCode = 1;
     }
@@ -1289,8 +1729,9 @@ async function scan(source) {
 }
 
 // src/commands/list.ts
-import { join as join10 } from "path";
+import { join as join12 } from "path";
 async function list() {
+  await maybeOfferInit();
   const config = loadConfig();
   const { quarantineDir } = config;
   const ids = listQuarantineIds(quarantineDir);
@@ -1301,14 +1742,14 @@ async function list() {
   }
   console.log(`[skill-forge] ${ids.length} held in quarantine (${quarantineDir}):`);
   for (const id of ids) {
-    const skillDirs = findSkillDirs(join10(quarantineDir, id));
+    const skillDirs = findSkillDirs(join12(quarantineDir, id));
     if (skillDirs.length === 0) {
       console.log(`  ${id}  (no SKILL.md found)`);
       continue;
     }
     const names = skillDirs.map((dir) => {
       try {
-        return readFrontmatter(join10(dir, "SKILL.md")).name;
+        return readFrontmatter(join12(dir, "SKILL.md")).name;
       } catch {
         return dir;
       }
@@ -1319,6 +1760,7 @@ async function list() {
 
 // src/commands/status.ts
 async function status() {
+  await maybeOfferInit();
   const config = loadConfig();
   const heldCount = listQuarantineIds(config.quarantineDir).length;
   console.log("[skill-forge] status");
@@ -1333,9 +1775,25 @@ var require2 = createRequire(import.meta.url);
 var pkg = require2("../package.json");
 var program = new Command();
 program.name("skill-forge").description("The supply-chain gate for agent skills").version(pkg.version);
-program.command("add <source>").description("Quarantine-install a skill and run it through the safety gate").option("-y, --yes", "skip the interactive prompt; honor the gate verdict automatically").option("-t, --target <dir>", "skills root to promote into (defaults to config skillsRoots[0])").option("--json", "print the gate result as JSON instead of the terminal report").option("--ingest", "after a successful promote, hand off to Claude via /rhize-meta:forge-ingest").action(add);
-program.command("scan <source>").description("Run the safety gate against a skill without installing it").action(scan);
+program.command("add <source>").description("Quarantine-install a skill and run it through the safety gate").option("-y, --yes", "skip the interactive prompt; honor the gate verdict automatically").option("-t, --target <dir>", "skills root to promote into (defaults to config skillsRoots[0])").option("--json", "print the gate result as JSON instead of the terminal report").option("--ingest", "after a successful promote, hand off the bundled ingest prompt to a coding agent").action(add);
+program.command("scan <source>").description("Run the safety gate against a skill without installing it").option("--json", "print the gate result as JSON instead of the terminal report").action(scan);
 program.command("list").description("List skills currently in quarantine").action(list);
 program.command("status").description("Show skill-forge configuration and quarantine status").action(status);
-await program.parseAsync();
+program.command("init").description("Detect installed agents and set gate targets, default promotion target, and handoff agent").option("--defaults", "non-interactive: use all detected agents as gate targets, the first as the default target").option("--list", "print detected agent skill roots and exit \u2014 no writes").action(init);
+try {
+  await program.parseAsync();
+} catch (err) {
+  if (err instanceof UserError) {
+    console.error(`skill-forge: ${err.message}`);
+    process.exit(1);
+  }
+  if (process.env.DEBUG === "skill-forge") {
+    console.error(err);
+  } else {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`skill-forge: unexpected error: ${message}`);
+    console.error("Re-run with DEBUG=skill-forge to see the full stack trace.");
+  }
+  process.exit(1);
+}
 //# sourceMappingURL=cli.js.map