@primitive.ai/prim 0.1.0-alpha.49 → 0.1.0-alpha.51

package/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: prim
-description: Use the prim CLI for Primitive's decision graph — passive capture of coding decisions, deliberate recording of higher-order forks in the road, the conflict gate, reconcile, rationale confirmations, and team presence. TRIGGER when the user mentions Primitive, prim, decisions / the decision graph / a conflict gate / reconcile; when a durable decision emerges during coding, planning, review, or connected-context work; when an edit is denied or warned by a prior decision; when the repo's package.json depends on @primitive.ai/prim; when onboarding to or configuring Primitive session or git hooks. SKIP when "decision" is unrelated to Primitive, or for unrelated CLIs.
+description: Use the prim CLI for Primitive’s decision graph. MUST INVOKE before finishing any coding, planning, specification, or review task where the user or agent chose between plausible approaches or established or changed a lasting goal, priority, constraint, invariant, default, commitment, tradeoff, exception, or shared instruction—even when Primitive was not mentioned. Also invoke for Primitive setup, reading decisions, conflict gates, reconcile, rationale confirmations, linking, and team presence. SKIP routine implementation that merely follows an existing decision, temporary tactics, and unrelated uses of “decision.”
 ---
 
 # Working with the prim CLI

package/dist/{chunk-S5NUHFAD.js → chunk-4GLVJLEQ.js}

@@ -2,11 +2,11 @@
 function buildHookOutput(options) {
   const output = {};
   if (options.systemMessage) output.systemMessage = options.systemMessage;
-  if (options.additionalContext) {
-    output.hookSpecificOutput = {
-      hookEventName: "SessionStart",
-      additionalContext: options.additionalContext
-    };
+  const fields = {};
+  if (options.additionalContext) fields.additionalContext = options.additionalContext;
+  if (options.reloadSkills) fields.reloadSkills = true;
+  if (Object.keys(fields).length > 0) {
+    output.hookSpecificOutput = { hookEventName: "SessionStart", ...fields };
   }
   return output;
 }

package/dist/{chunk-5K725K35.js → chunk-BOTKPLTI.js}

@@ -1,6 +1,6 @@
 import {
   getSiteUrl
-} from "./chunk-TPROV45L.js";
+} from "./chunk-DWDEQRWN.js";
 
 // src/journal.ts
 import {

package/dist/{chunk-TPROV45L.js → chunk-DWDEQRWN.js}

@@ -154,6 +154,7 @@ var CONFIG_DIR_MODE = 448;
 var CREDENTIAL_FILE_MODE = 384;
 var REFRESH_THRESHOLD_MS = 6e4;
 var DEFAULT_API_URL = "https://api.getprimitive.ai";
+var AUTH_EXPIRED_MESSAGE = "Authentication expired. Run `prim auth login` to re-authenticate.";
 function loadEnvFile() {
   const envVars = {};
   for (const file of [".env.local", ".env"]) {
@@ -349,6 +350,7 @@ async function performTokenRefresh(options = {}) {
   if (selected?.source !== "token_file") return void 0;
   const startingGeneration = readTrimmed(REFRESH_TOKEN_PATH);
   if (!startingGeneration || isSessionEnded()) return void 0;
+  const startingAccessToken = selected.token;
   return withCredentialLock(
     async () => {
       const currentCredential = resolveAuthCredential();
@@ -358,6 +360,9 @@ async function performTokenRefresh(options = {}) {
       if (currentGeneration !== startingGeneration) {
         return currentCredential.token;
       }
+      if (currentCredential.token !== startingAccessToken) {
+        return currentCredential.token;
+      }
       if (isSessionEnded()) return void 0;
       const response = await fetch(`${getSiteUrl()}/mcp/broker/refresh`, {
         method: "POST",
@@ -442,6 +447,12 @@ async function request(method, path, body, options) {
     });
     if (token) credential = { token, source: "token_file" };
   }
+  if (!credential) {
+    throw new HttpError(401, AUTH_EXPIRED_MESSAGE);
+  }
+  if (isTokenExpiringSoon(credential) && isSessionEnded()) {
+    throw new HttpError(401, AUTH_EXPIRED_MESSAGE);
+  }
   const doFetch = (token) => {
     const headers = { "Content-Type": "application/json" };
     if (token) headers.Authorization = `Bearer ${token}`;
@@ -471,7 +482,7 @@ async function request(method, path, body, options) {
   }
   if (!response.ok) {
     if (response.status === 401) {
-      throw new HttpError(401, "Authentication expired. Run `prim auth login` to re-authenticate.");
+      throw new HttpError(401, AUTH_EXPIRED_MESSAGE);
     }
     const errorBody = await response.json().catch(() => null);
     throw new HttpError(response.status, errorBody?.error ?? `HTTP ${response.status}`);

package/dist/chunk-UJEQX52M.js

@@ -0,0 +1,520 @@
+import {
+  gitToplevel
+} from "./chunk-R5ZJRSLV.js";
+import {
+  withFileLock
+} from "./chunk-DWDEQRWN.js";
+
+// src/commands/skill.ts
+import { randomUUID } from "crypto";
+import {
+  closeSync as closeSync2,
+  existsSync as existsSync2,
+  fsyncSync,
+  openSync as openSync2,
+  readFileSync as readFileSync2,
+  renameSync,
+  rmSync as rmSync2,
+  writeFileSync
+} from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { createPatch } from "diff";
+
+// src/output.ts
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+// src/commands/claude-plugin.ts
+import { createHash } from "crypto";
+import {
+  constants,
+  closeSync,
+  existsSync,
+  fstatSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  readSync,
+  readdirSync,
+  realpathSync,
+  rmSync,
+  rmdirSync
+} from "fs";
+import { homedir } from "os";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
+import { fileURLToPath } from "url";
+import { parse as parseYaml } from "yaml";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var PLUGIN_DESCRIPTION = "Primitive decision-graph guidance for the prim CLI \u2014 a model-invoked skill installed by prim skill install.";
+var MAX_MANIFEST_BYTES = 64 * 1024;
+var MAX_SKILL_BYTES = 1024 * 1024;
+var REFRESH_LOCK_TIMEOUT_MS = 150;
+var REFRESH_LOCK_POLL_MS = 10;
+function pluginDirFor(cwd, scope) {
+  const base = scope === "user" ? join(homedir(), ".claude") : join(gitToplevel(cwd) ?? cwd, ".claude");
+  return join(base, "skills", "prim");
+}
+function resolvePluginDir(cwd, scope) {
+  if (scope && scope !== "user" && scope !== "project") {
+    console.error(`Unknown --scope "${scope}" (expected user or project)`);
+    return null;
+  }
+  return pluginDirFor(cwd, scope === "user" ? "user" : "project");
+}
+function packageVersion() {
+  let dir = __dirname;
+  while (dir !== dirname(dir)) {
+    const p = resolve(dir, "package.json");
+    if (existsSync(p)) return JSON.parse(readFileSync(p, "utf-8")).version;
+    dir = dirname(dir);
+  }
+  return "0.0.0";
+}
+function pluginManifest(version) {
+  const manifest = { name: "prim", description: PLUGIN_DESCRIPTION, version };
+  return `${JSON.stringify(manifest, null, 2)}
+`;
+}
+function renderClaudePlugin() {
+  const version = packageVersion();
+  return { manifest: pluginManifest(version), skill: loadSkill(), version };
+}
+function removeDirIfEmpty(dir) {
+  if (existsSync(dir) && readdirSync(dir).length === 0) rmdirSync(dir);
+}
+function pluginPaths(dir) {
+  return {
+    manifestPath: join(dir, ".claude-plugin", "plugin.json"),
+    skillPath: join(dir, "SKILL.md")
+  };
+}
+function parseSemver(value) {
+  if (typeof value !== "string" || value.length > 256) return;
+  const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u.exec(
+    value
+  );
+  if (!match) return;
+  const prerelease = match[4]?.split(".") ?? [];
+  if (prerelease.some((part) => /^\d+$/u.test(part) && part.length > 1 && part.startsWith("0"))) {
+    return;
+  }
+  return { core: [BigInt(match[1]), BigInt(match[2]), BigInt(match[3])], prerelease };
+}
+function compareSemver(left, right) {
+  const a = parseSemver(left);
+  const b = parseSemver(right);
+  if (!a || !b) return;
+  for (let i = 0; i < a.core.length; i += 1) {
+    if (a.core[i] !== b.core[i]) return a.core[i] < b.core[i] ? -1 : 1;
+  }
+  if (a.prerelease.length === 0 || b.prerelease.length === 0) {
+    return a.prerelease.length === b.prerelease.length ? 0 : a.prerelease.length === 0 ? 1 : -1;
+  }
+  const length = Math.max(a.prerelease.length, b.prerelease.length);
+  for (let i = 0; i < length; i += 1) {
+    const x = a.prerelease[i];
+    const y = b.prerelease[i];
+    if (x === void 0 || y === void 0) return x === void 0 ? -1 : 1;
+    if (x === y) continue;
+    const xNumeric = /^\d+$/u.test(x);
+    const yNumeric = /^\d+$/u.test(y);
+    if (xNumeric && yNumeric) return BigInt(x) < BigInt(y) ? -1 : 1;
+    if (xNumeric !== yNumeric) return xNumeric ? -1 : 1;
+    return x < y ? -1 : 1;
+  }
+  return 0;
+}
+function pathIsInside(root, path) {
+  const rel = relative(root, path);
+  return rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+function managedPathsAreSafe(paths, projectRoot) {
+  try {
+    const managed = [paths.manifestPath, paths.skillPath];
+    if (managed.some((path) => !lstatSync(path).isFile())) return false;
+    if (projectRoot === void 0) return true;
+    const realRoot = realpathSync(projectRoot);
+    return managed.every((path) => pathIsInside(realRoot, realpathSync(path)));
+  } catch {
+    return false;
+  }
+}
+function readBoundedRegularFile(path, maxBytes) {
+  const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const stat = fstatSync(fd);
+    if (!stat.isFile() || stat.size > maxBytes) throw new Error("unsafe managed file");
+    const chunks = [];
+    let total = 0;
+    while (total <= maxBytes) {
+      const chunk = Buffer.allocUnsafe(Math.min(64 * 1024, maxBytes + 1 - total));
+      const bytesRead = readSync(fd, chunk, 0, chunk.length, null);
+      if (bytesRead === 0) break;
+      chunks.push(chunk.subarray(0, bytesRead));
+      total += bytesRead;
+    }
+    if (total > maxBytes) throw new Error("unsafe managed file");
+    return Buffer.concat(chunks, total).toString("utf8");
+  } finally {
+    closeSync(fd);
+  }
+}
+function hasUsablePrimFrontmatter(skill) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)([\s\S]*)$/u.exec(skill);
+  if (!match) return false;
+  try {
+    const parsed = parseYaml(match[1]);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return false;
+    const frontmatter = parsed;
+    return frontmatter.name === "prim" && typeof frontmatter.description === "string" && frontmatter.description.trim().length > 0 && match[2].trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function inspectRecognizedInstallation(paths, projectRoot) {
+  if (!existsSync(paths.manifestPath) || !existsSync(paths.skillPath)) return;
+  if (!managedPathsAreSafe(paths, projectRoot)) return;
+  const manifest = readBoundedRegularFile(paths.manifestPath, MAX_MANIFEST_BYTES);
+  const parsed = JSON.parse(manifest);
+  if (parsed.name !== "prim") return;
+  const skill = readBoundedRegularFile(paths.skillPath, MAX_SKILL_BYTES);
+  return {
+    manifest,
+    manifestVersion: parsed.version,
+    skill,
+    usable: hasUsablePrimFrontmatter(skill)
+  };
+}
+function refreshLockDir(physicalPluginDir) {
+  const cacheRoot = process.env.XDG_CACHE_HOME || join(homedir(), ".cache");
+  const identity = createHash("sha256").update(physicalPluginDir).digest("hex");
+  return join(cacheRoot, "prim", "skill-refresh-locks", `${identity}.lock`);
+}
+async function refreshClaudePlugins(cwd, options = {}) {
+  const result = { installed: 0, refreshed: 0 };
+  const candidates = [];
+  if (options.includeProject !== false) {
+    const projectRoot = options.projectRoot ?? gitToplevel(cwd);
+    if (projectRoot !== null && isAbsolute(projectRoot)) {
+      candidates.push({ dir: join(projectRoot, ".claude", "skills", "prim"), projectRoot });
+    }
+  }
+  candidates.push({ dir: pluginDirFor(cwd, "user") });
+  const seen = /* @__PURE__ */ new Set();
+  let desired;
+  for (const { dir, projectRoot } of candidates) {
+    let counted = false;
+    const markInstalled = () => {
+      if (!counted) {
+        result.installed += 1;
+        counted = true;
+      }
+    };
+    const refreshCandidate = () => {
+      const { manifestPath, skillPath } = pluginPaths(dir);
+      const paths = { manifestPath, skillPath };
+      try {
+        let changed = false;
+        const current = inspectRecognizedInstallation(paths, projectRoot);
+        if (!current) return;
+        desired ??= renderClaudePlugin();
+        if (projectRoot !== void 0 && current.usable && compareSemver(current.manifestVersion, desired.version) === 1) {
+          markInstalled();
+          return;
+        }
+        if (current.manifest !== desired.manifest) {
+          if (!managedPathsAreSafe(paths, projectRoot)) throw new Error("unsafe managed path");
+          atomicWrite(manifestPath, desired.manifest);
+          if (!changed) result.refreshed += 1;
+          changed = true;
+        }
+        if (current.skill !== desired.skill) {
+          if (!managedPathsAreSafe(paths, projectRoot)) throw new Error("unsafe managed path");
+          atomicWrite(skillPath, desired.skill);
+          if (!changed) result.refreshed += 1;
+          changed = true;
+        }
+        markInstalled();
+      } catch {
+        try {
+          if (inspectRecognizedInstallation(paths, projectRoot)?.usable) markInstalled();
+        } catch {
+        }
+      }
+    };
+    try {
+      const paths = pluginPaths(dir);
+      if (!existsSync(paths.manifestPath) || !existsSync(paths.skillPath)) continue;
+      const physicalPluginDir = realpathSync(dir);
+      if (seen.has(physicalPluginDir)) continue;
+      seen.add(physicalPluginDir);
+      await withFileLock(refreshLockDir(physicalPluginDir), refreshCandidate, {
+        timeoutMs: REFRESH_LOCK_TIMEOUT_MS,
+        pollMs: REFRESH_LOCK_POLL_MS
+      });
+    } catch {
+    }
+  }
+  return result;
+}
+function installClaudePlugin(cwd, opts) {
+  const dir = resolvePluginDir(cwd, opts.scope);
+  if (dir === null) return 1;
+  const { manifestPath, skillPath } = pluginPaths(dir);
+  const { manifest, skill } = renderClaudePlugin();
+  const manifestCurrent = existsSync(manifestPath) ? readFileSync(manifestPath, "utf-8") : null;
+  const skillCurrent = existsSync(skillPath) ? readFileSync(skillPath, "utf-8") : null;
+  if (manifestCurrent === manifest && skillCurrent === skill) {
+    console.log("No changes \u2014 prim skill plugin already up to date.");
+    return 0;
+  }
+  if (opts.dryRun) {
+    console.log(`Would write plugin to ${dir} (.claude-plugin/plugin.json + SKILL.md)`);
+    return 0;
+  }
+  mkdirSync(join(dir, ".claude-plugin"), { recursive: true });
+  atomicWrite(manifestPath, manifest);
+  atomicWrite(skillPath, skill);
+  console.log(`Installed prim skill plugin at ${dir}`);
+  console.log("Restart Claude Code or run /reload-plugins to load it.");
+  if (opts.scope !== "user") {
+    console.log("Project-scope plugins load only when Claude Code launches from this directory.");
+  }
+  return 0;
+}
+function uninstallClaudePlugin(cwd, opts) {
+  const dir = resolvePluginDir(cwd, opts.scope);
+  if (dir === null) return 1;
+  const { manifestPath, skillPath } = pluginPaths(dir);
+  if (!existsSync(manifestPath) && !existsSync(skillPath)) {
+    console.log(`prim skill plugin not present at ${dir}`);
+    return 0;
+  }
+  rmSync(manifestPath, { force: true });
+  rmSync(skillPath, { force: true });
+  removeDirIfEmpty(join(dir, ".claude-plugin"));
+  removeDirIfEmpty(dir);
+  console.log(`Removed prim skill plugin from ${dir}`);
+  return 0;
+}
+function statusClaudePlugin(cwd, opts) {
+  const dir = resolvePluginDir(cwd, opts.scope);
+  if (dir === null) return 1;
+  const { skillPath } = pluginPaths(dir);
+  const installed = existsSync(skillPath);
+  if (opts.json) {
+    printJson({ installed, target: dir });
+    return installed ? 0 : 1;
+  }
+  if (installed) {
+    console.log(`prim skill plugin installed at ${dir}`);
+    return 0;
+  }
+  console.log(`No prim skill plugin at ${dir}`);
+  return 1;
+}
+
+// src/commands/skill.ts
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+var SKILL_BEGIN = "<!-- BEGIN PRIM SKILL v1 -->";
+var SKILL_END = "<!-- END PRIM SKILL v1 -->";
+var TARGET_CANDIDATES = [
+  "CLAUDE.md",
+  "AGENTS.md",
+  ".hermes.md",
+  ".cursor/rules",
+  ".windsurfrules",
+  ".github/instructions/primitive.md"
+];
+var DEFAULT_TARGET = "CLAUDE.md";
+var AGENT_TARGET = {
+  claude: "CLAUDE.md",
+  codex: "AGENTS.md",
+  hermes: ".hermes.md"
+};
+function userTargetFor(agent) {
+  if (agent === "claude") return join2(homedir2(), ".claude", "CLAUDE.md");
+  if (agent === "codex") return join2(homedir2(), ".codex", "AGENTS.md");
+  if (agent === "hermes") {
+    return join2(process.env.HERMES_HOME ?? join2(homedir2(), ".hermes"), ".hermes.md");
+  }
+  return null;
+}
+function loadSkill() {
+  let dir = __dirname2;
+  while (dir !== dirname2(dir)) {
+    const p = resolve2(dir, "SKILL.md");
+    if (existsSync2(p)) return readFileSync2(p, "utf-8");
+    dir = dirname2(dir);
+  }
+  throw new Error("SKILL.md not found in package");
+}
+function detectTargets(cwd) {
+  return TARGET_CANDIDATES.filter((p) => existsSync2(resolve2(cwd, p)));
+}
+function detectNewline(content) {
+  return content.includes("\r\n") ? "\r\n" : "\n";
+}
+function composeBlock(skill, eol) {
+  const body = skill.replace(/\r?\n/g, eol);
+  return `${SKILL_BEGIN}${eol}${body}${eol}${SKILL_END}`;
+}
+function applyBlock(existing, block, eol) {
+  const b = existing.indexOf(SKILL_BEGIN);
+  const e = existing.indexOf(SKILL_END);
+  if (b !== -1 && e !== -1) {
+    return existing.slice(0, b) + block + existing.slice(e + SKILL_END.length);
+  }
+  if (existing.length === 0) return `${block}${eol}`;
+  const sep2 = existing.endsWith(eol) ? "" : eol;
+  return `${existing}${sep2}${block}${eol}`;
+}
+function removeBlock(existing) {
+  const b = existing.indexOf(SKILL_BEGIN);
+  const e = existing.indexOf(SKILL_END);
+  if (b === -1 || e === -1) return null;
+  const out = existing.slice(0, b) + existing.slice(e + SKILL_END.length);
+  return out.replace(/(\r?\n){2,}$/, "$1");
+}
+function atomicWrite(target, content) {
+  const tmp = `${target}.${randomUUID()}.tmp`;
+  let temporaryCreated = false;
+  try {
+    const fd = openSync2(tmp, "wx");
+    temporaryCreated = true;
+    try {
+      writeFileSync(fd, content);
+      fsyncSync(fd);
+    } finally {
+      closeSync2(fd);
+    }
+    renameSync(tmp, target);
+  } catch (error) {
+    if (temporaryCreated) {
+      try {
+        rmSync2(tmp, { force: true });
+      } catch {
+      }
+    }
+    throw error;
+  }
+}
+function resolveTarget(cwd, opts) {
+  if (opts.scope && opts.scope !== "user" && opts.scope !== "project") {
+    console.error(`Unknown --scope "${opts.scope}" (expected user or project)`);
+    return null;
+  }
+  if (opts.target) return resolve2(cwd, opts.target);
+  if (opts.scope === "user") {
+    if (!opts.agent) {
+      console.error("--scope user requires --agent (claude, codex, or hermes)");
+      return null;
+    }
+    const userTarget = userTargetFor(opts.agent);
+    if (userTarget) return userTarget;
+    console.error(`Unknown --agent "${opts.agent}" (expected claude, codex, or hermes)`);
+    return null;
+  }
+  if (opts.agent) {
+    const mapped = AGENT_TARGET[opts.agent];
+    if (typeof mapped === "string") return resolve2(cwd, mapped);
+    console.error(`Unknown --agent "${opts.agent}" (expected claude, codex, or hermes)`);
+    return null;
+  }
+  const matches = detectTargets(cwd);
+  if (matches.length === 0) return resolve2(cwd, DEFAULT_TARGET);
+  if (matches.length === 1) return resolve2(cwd, matches[0]);
+  console.error("Multiple rules files detected. Use --target to disambiguate:");
+  for (const m of matches) console.error(`  ${m}`);
+  return null;
+}
+function runInstall(cwd, opts) {
+  if (opts.agent === "claude" && !opts.target) return installClaudePlugin(cwd, opts);
+  const target = resolveTarget(cwd, opts);
+  if (target === null) return 1;
+  const existing = existsSync2(target) ? readFileSync2(target, "utf-8") : "";
+  const eol = existing ? detectNewline(existing) : "\n";
+  const block = composeBlock(loadSkill(), eol);
+  const next = applyBlock(existing, block, eol);
+  if (next === existing) {
+    console.log("No changes \u2014 skill block already up to date.");
+    return 0;
+  }
+  if (opts.dryRun) {
+    process.stdout.write(createPatch(target, existing, next, "current", "proposed"));
+    return 0;
+  }
+  atomicWrite(target, next);
+  console.log(`Wrote ${Buffer.byteLength(next)} bytes to ${target}`);
+  return 0;
+}
+function runUninstall(cwd, opts) {
+  if (opts.agent === "claude" && !opts.target) return uninstallClaudePlugin(cwd, opts);
+  const target = resolveTarget(cwd, opts);
+  if (target === null) return 1;
+  if (!existsSync2(target)) {
+    console.log(`Skill block not present at ${target}`);
+    return 0;
+  }
+  const existing = readFileSync2(target, "utf-8");
+  const next = removeBlock(existing);
+  if (next === null) {
+    console.log(`Skill block not present at ${target}`);
+    return 0;
+  }
+  atomicWrite(target, next);
+  console.log(`Removed skill block from ${target}`);
+  return 0;
+}
+function runStatus(cwd, opts) {
+  if (opts.agent === "claude" && !opts.target) return statusClaudePlugin(cwd, opts);
+  const target = resolveTarget(cwd, opts);
+  if (target === null) return 1;
+  const fileExists = existsSync2(target);
+  let installed = false;
+  if (fileExists) {
+    const content = readFileSync2(target, "utf-8");
+    installed = content.includes(SKILL_BEGIN) && content.includes(SKILL_END);
+  }
+  if (opts.json) {
+    printJson({ installed, target });
+    return installed ? 0 : 1;
+  }
+  if (!fileExists) {
+    console.log(`No rules file at ${target}`);
+    return 1;
+  }
+  if (installed) {
+    console.log(`PRIM SKILL v1 installed at ${target}`);
+    return 0;
+  }
+  console.log(`No PRIM SKILL block at ${target}`);
+  return 1;
+}
+function registerSkillCommands(program) {
+  const skill = program.command("skill").description("Manage the prim skill in your project rules file");
+  skill.command("install").description("Install the prim skill block into your project rules file").option("--target <path>", "Path to the rules file (overrides auto-detection)").option("--agent <agent>", "claude, codex, or hermes (selects the default rules file)").option("--scope <scope>", "project (default, this repo) or user (machine-global \u2014 every repo)").option("--dry-run", "Print a unified diff without writing").action((opts) => {
+    try {
+      process.exit(runInstall(process.cwd(), opts));
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(2);
+    }
+  });
+  skill.command("uninstall").description("Remove the prim skill block from your project rules file").option("--target <path>", "Path to the rules file (overrides auto-detection)").option("--agent <agent>", "claude, codex, or hermes (selects the default rules file)").option("--scope <scope>", "project (default, this repo) or user (machine-global \u2014 every repo)").action((opts) => {
+    process.exit(runUninstall(process.cwd(), opts));
+  });
+  skill.command("status").description("Report whether the prim skill block is installed").option("--target <path>", "Path to the rules file (overrides auto-detection)").option("--agent <agent>", "claude, codex, or hermes (selects the default rules file)").option("--scope <scope>", "project (default, this repo) or user (machine-global \u2014 every repo)").option("--json", "Output as JSON").action((opts) => {
+    process.exit(runStatus(process.cwd(), opts));
+  });
+}
+
+export {
+  printJson,
+  refreshClaudePlugins,
+  registerSkillCommands
+};

package/dist/{chunk-WRPKAPVE.js → chunk-VDLAAUWV.js}

@@ -1,7 +1,7 @@
 import {
   getClient,
   getSiteUrl
-} from "./chunk-TPROV45L.js";
+} from "./chunk-DWDEQRWN.js";
 import {
   daemonRequest
 } from "./chunk-UTKQTZHL.js";

package/dist/{chunk-CK75QBCB.js → chunk-WELBNODJ.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-TPROV45L.js";
+} from "./chunk-DWDEQRWN.js";
 
 // src/decisions/feedback.ts
 var FEEDBACK_PROTOCOL_VERSION = 1;