@primitive.ai/prim 0.1.0-alpha.50 → 0.1.0-alpha.52

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-ROL7SDXX.js

@@ -0,0 +1,594 @@
+import {
+  gitToplevel
+} from "./chunk-R5ZJRSLV.js";
+import {
+  withFileLock
+} from "./chunk-DWDEQRWN.js";
+
+// src/commands/skill.ts
+import { randomUUID } from "crypto";
+import {
+  constants as constants2,
+  closeSync as closeSync2,
+  existsSync as existsSync2,
+  fstatSync as fstatSync2,
+  fsyncSync,
+  lstatSync as lstatSync2,
+  openSync as openSync2,
+  readFileSync as readFileSync2,
+  readSync as readSync2,
+  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";
+import { parse as parseYaml2 } from "yaml";
+
+// 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 CODEX_GUIDANCE_LIMIT_BYTES = 1024 * 1024;
+var CODEX_DEFAULT_PROJECT_GUIDANCE_BYTES = 32 * 1024;
+var SKILL_BEGIN_BUFFER = Buffer.from(SKILL_BEGIN);
+var SKILL_END_BUFFER = Buffer.from(SKILL_END);
+function readCodexGuidance(path) {
+  try {
+    const entry = lstatSync2(path);
+    if (entry.isSymbolicLink() || !entry.isFile()) return null;
+    const fd = openSync2(path, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+    try {
+      const opened = fstatSync2(fd);
+      if (!opened.isFile() || opened.size > CODEX_GUIDANCE_LIMIT_BYTES) return null;
+      const bytes = Buffer.allocUnsafe(CODEX_GUIDANCE_LIMIT_BYTES + 1);
+      let length = 0;
+      while (length < bytes.length) {
+        const read = readSync2(fd, bytes, length, bytes.length - length, length);
+        if (read === 0) break;
+        length += read;
+      }
+      return length > CODEX_GUIDANCE_LIMIT_BYTES ? null : bytes.subarray(0, length);
+    } finally {
+      closeSync2(fd);
+    }
+  } catch (error) {
+    const code = error.code;
+    return code === "ENOENT" || code === "ENOTDIR" ? void 0 : null;
+  }
+}
+function effectiveCodexGuidance(scope) {
+  const override = readCodexGuidance(join2(scope, "AGENTS.override.md"));
+  if (override === null) return null;
+  if (override !== void 0 && override.toString("utf8").trim().length > 0) return override;
+  const base = readCodexGuidance(join2(scope, "AGENTS.md"));
+  return base ?? null;
+}
+function hasUsablePrimBlock(content, visibleBytes) {
+  const begin = content.indexOf(SKILL_BEGIN_BUFFER);
+  const end = content.indexOf(SKILL_END_BUFFER);
+  if (begin === -1 || end <= begin + SKILL_BEGIN_BUFFER.length || end + SKILL_END_BUFFER.length > visibleBytes || content.indexOf(SKILL_BEGIN_BUFFER, begin + SKILL_BEGIN_BUFFER.length) !== -1 || content.indexOf(SKILL_END_BUFFER, end + SKILL_END_BUFFER.length) !== -1) {
+    return false;
+  }
+  const block = content.subarray(begin + SKILL_BEGIN_BUFFER.length, end).toString("utf8").trim();
+  const match = /^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)([\s\S]*)$/u.exec(block);
+  if (!match || match[2].trim().length === 0) return false;
+  try {
+    const metadata = parseYaml2(match[1]);
+    if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) return false;
+    const fields = metadata;
+    return fields.name === "prim" && typeof fields.description === "string" && fields.description.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function hasUsableCodexGuidance(projectRoot) {
+  try {
+    const codexHome = process.env.CODEX_HOME?.trim() ? resolve2(process.env.CODEX_HOME) : join2(homedir2(), ".codex");
+    const scopes = [
+      { path: codexHome, visibleBytes: CODEX_GUIDANCE_LIMIT_BYTES },
+      { path: projectRoot, visibleBytes: CODEX_DEFAULT_PROJECT_GUIDANCE_BYTES }
+    ];
+    return scopes.some(({ path, visibleBytes }) => {
+      const guidance = effectiveCodexGuidance(path);
+      return guidance !== null && hasUsablePrimBlock(guidance, visibleBytes);
+    });
+  } catch {
+    return false;
+  }
+}
+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,
+  hasUsableCodexGuidance,
+  registerSkillCommands
+};

package/dist/hooks/prim-hook.js

@@ -13,7 +13,7 @@ import {
 import {
   buildHookOutput,
   handoffHookOutput
-} from "../chunk-S5NUHFAD.js";
+} from "../chunk-4GLVJLEQ.js";
 import {
   FEEDBACK_DEADLINE_MS,
   acknowledgeDecisionFeedback,

package/dist/hooks/session-start.js

@@ -1,8 +1,12 @@
 #!/usr/bin/env node
+import {
+  hasUsableCodexGuidance,
+  refreshClaudePlugins
+} from "../chunk-ROL7SDXX.js";
 import {
   buildHookOutput,
   handoffHookOutput
-} from "../chunk-S5NUHFAD.js";
+} from "../chunk-4GLVJLEQ.js";
 import {
   FEEDBACK_DEADLINE_MS,
   acknowledgeDecisionFeedback,
@@ -17,6 +21,7 @@ import {
   warmBinCache
 } from "../chunk-HSZPTVKU.js";
 import {
+  gitToplevel,
   isRepoActiveForCapture
 } from "../chunk-R5ZJRSLV.js";
 import {
@@ -53,69 +58,38 @@ function kickDaemonEnsure(options = {}) {
 
 // src/hooks/reauth-notice.ts
 var REAUTH_NOTICE = "[prim] authentication ended \u2014 run `prim auth login` to resume decision capture";
-function reauthNoticeOutput(agent) {
-  if (agent === "codex") {
-    return buildHookOutput({ additionalContext: REAUTH_NOTICE });
-  }
-  if (agent === "claude_code") {
-    return buildHookOutput({ systemMessage: REAUTH_NOTICE });
-  }
+function reauthNoticeFields(agent) {
+  if (agent === "codex") return { additionalContext: REAUTH_NOTICE };
+  if (agent === "claude_code") return { systemMessage: REAUTH_NOTICE };
   return;
 }
 
-// src/hooks/session-start.ts
-var STDIN_TIMEOUT_MS = 1e3;
+// src/hooks/session-start-core.ts
 var DAEMON_TIMEOUT_MS = 250;
-var outputAttempted = false;
-function emitOutput(output, acknowledge) {
-  outputAttempted = true;
-  return handoffHookOutput(output, acknowledge);
+var PRIM_TRIGGER = "When this task chooses between plausible approaches or establishes or changes a lasting goal, priority, constraint, invariant, default, commitment, tradeoff, exception, or shared instruction";
+var PRIM_EXCLUSIONS = "Never invoke `prim` for routine implementation that merely follows an existing decision made before this task or for temporary tactics; they never qualify, including for evaluation.";
+function primReminder(action, rationaleAction) {
+  return `Primitive is active in this repository. ${PRIM_TRIGGER}, ${action} before finishing. ${PRIM_EXCLUSIONS} When a direct request replaces one lasting default with another but supplies no rationale, complete the work, ${rationaleAction}, and ask one concise rationale question at the task boundary, even if the user requested only implementation or recording fails.`;
 }
-function readStdin() {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    const timer = setTimeout(() => {
-      reject(new Error("stdin read timeout"));
-    }, STDIN_TIMEOUT_MS);
-    process.stdin.on("data", (chunk) => chunks.push(chunk));
-    process.stdin.on("end", () => {
-      clearTimeout(timer);
-      resolve(Buffer.concat(chunks).toString("utf-8"));
-    });
-    process.stdin.on("error", (err) => {
-      clearTimeout(timer);
-      reject(err);
-    });
-  });
-}
-async function main() {
-  const feedbackSignal = AbortSignal.timeout(FEEDBACK_DEADLINE_MS);
-  warmBinCache();
-  const agent = parseAgent(process.argv);
-  let raw;
-  try {
-    raw = await readStdin();
-  } catch {
-    await emitOutput(buildHookOutput({}));
-    return;
-  }
+var PRIM_SKILL_REMINDER = primReminder("invoke the `prim` skill", "invoke the skill");
+var CODEX_PRIM_ACTION = "follow the installed Prim workflow and use the `prim` CLI";
+var CODEX_PRIM_REMINDER = primReminder(CODEX_PRIM_ACTION, CODEX_PRIM_ACTION);
+async function processSessionStart(raw, agent, feedbackSignal = AbortSignal.timeout(FEEDBACK_DEADLINE_MS)) {
   let envelope;
   try {
-    envelope = normalizeEnvelope(
-      JSON.parse(raw),
-      agent
-    );
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return { output: buildHookOutput({}) };
+    }
+    envelope = normalizeEnvelope(parsed, agent);
   } catch {
-    await emitOutput(buildHookOutput({}));
-    return;
+    return { output: buildHookOutput({}) };
   }
   if (envelope.hook_event_name !== "SessionStart") {
-    await emitOutput(buildHookOutput({}));
-    return;
+    return { output: buildHookOutput({}) };
   }
   if (typeof envelope.session_id !== "string" || envelope.session_id.length === 0) {
-    await emitOutput(buildHookOutput({}));
-    return;
+    return { output: buildHookOutput({}) };
   }
   kickDaemonEnsure();
   await daemonRequest(
@@ -123,11 +97,26 @@ async function main() {
     { sessionId: envelope.session_id },
     { timeoutMs: DAEMON_TIMEOUT_MS }
   );
+  const cwd = envelope.cwd ?? process.cwd();
+  let active = false;
+  let skillState = { installed: 0, refreshed: 0 };
+  if (agent === "claude_code") {
+    try {
+      const projectRoot = gitToplevel(cwd);
+      active = projectRoot !== null && isRepoActiveForCapture(cwd);
+      skillState = await refreshClaudePlugins(
+        cwd,
+        active && projectRoot !== null ? { includeProject: true, projectRoot } : { includeProject: false }
+      );
+    } catch {
+    }
+  }
   if (isSessionEnded()) {
-    const notice = reauthNoticeOutput(agent);
+    const notice = reauthNoticeFields(agent);
     if (notice) {
-      await emitOutput(notice);
-      return;
+      return {
+        output: buildHookOutput({ ...notice, reloadSkills: skillState.refreshed > 0 })
+      };
     }
   }
   if (agent === "codex") {
@@ -138,16 +127,20 @@ async function main() {
       { callerEnv: getSiteUrl() },
       { timeoutMs: DAEMON_TIMEOUT_MS }
     );
-    if (snapshot && !snapshot.presenceStale && typeof snapshot.onlineCount === "number") {
-      await emitOutput(
-        buildHookOutput({ additionalContext: `[prim] team: ${snapshot.onlineCount} online` })
-      );
-      return;
+    const presence = snapshot && !snapshot.presenceStale && typeof snapshot.onlineCount === "number" ? `[prim] team: ${snapshot.onlineCount} online` : void 0;
+    let proactive = false;
+    try {
+      const projectRoot = gitToplevel(cwd);
+      proactive = projectRoot !== null && isRepoActiveForCapture(cwd) && hasUsableCodexGuidance(projectRoot);
+    } catch {
     }
+    const additionalContext = [proactive ? CODEX_PRIM_REMINDER : void 0, presence].filter((value) => value !== void 0).join("\n\n");
+    return { output: buildHookOutput({ additionalContext }) };
   }
   if (agent === "claude_code") {
-    const cwd = envelope.cwd ?? process.cwd();
-    if (isRepoActiveForCapture(cwd)) {
+    const additionalContext = active && skillState.installed > 0 ? PRIM_SKILL_REMINDER : void 0;
+    const reloadSkills = skillState.refreshed > 0;
+    if (active) {
       const identity = getOrCreateWorkspaceId(cwd);
       if (identity.status === "ready") {
         const lease = await leaseDecisionFeedback({
@@ -156,21 +149,64 @@ async function main() {
           signal: feedbackSignal
         });
         const rendered = lease ? renderFeedback(lease) : void 0;
-        await emitOutput(
-          buildHookOutput({ systemMessage: rendered?.systemMessage }),
-          rendered ? async () => {
+        return {
+          output: buildHookOutput({
+            systemMessage: rendered?.systemMessage,
+            additionalContext,
+            reloadSkills
+          }),
+          acknowledge: rendered ? async () => {
             await acknowledgeDecisionFeedback({
               workspaceId: identity.workspaceId,
               deliveries: rendered.deliveries,
               signal: feedbackSignal
             });
           } : void 0
-        );
-        return;
+        };
       }
     }
+    return { output: buildHookOutput({ additionalContext, reloadSkills }) };
+  }
+  return { output: buildHookOutput({}) };
+}
+
+// src/hooks/session-start.ts
+var STDIN_TIMEOUT_MS = 1e3;
+var outputAttempted = false;
+function emitOutput(output, acknowledge) {
+  outputAttempted = true;
+  return handoffHookOutput(output, acknowledge);
+}
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    const timer = setTimeout(() => {
+      reject(new Error("stdin read timeout"));
+    }, STDIN_TIMEOUT_MS);
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => {
+      clearTimeout(timer);
+      resolve(Buffer.concat(chunks).toString("utf-8"));
+    });
+    process.stdin.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+async function main() {
+  const feedbackSignal = AbortSignal.timeout(FEEDBACK_DEADLINE_MS);
+  warmBinCache();
+  const agent = parseAgent(process.argv);
+  let raw;
+  try {
+    raw = await readStdin();
+  } catch {
+    await emitOutput(buildHookOutput({}));
+    return;
   }
-  await emitOutput(buildHookOutput({}));
+  const result = await processSessionStart(raw, agent, feedbackSignal);
+  await emitOutput(result.output, result.acknowledge);
 }
 void main().catch(async () => {
   if (!outputAttempted) await emitOutput(buildHookOutput({}));

package/dist/index.js

@@ -22,6 +22,10 @@ import {
   pendingJournalStats,
   readMovesFromPath
 } from "./chunk-BOTKPLTI.js";
+import {
+  printJson,
+  registerSkillCommands
+} from "./chunk-ROL7SDXX.js";
 import {
   fetchFeedbackCapability
 } from "./chunk-WELBNODJ.js";
@@ -63,17 +67,12 @@ import {
 } from "./chunk-UTKQTZHL.js";
 
 // src/index.ts
-import { readFileSync as readFileSync12 } from "fs";
-import { dirname as dirname9, resolve as resolve6 } from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import { readFileSync as readFileSync10 } from "fs";
+import { dirname as dirname7, resolve as resolve4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { Command } from "commander";
 import updateNotifier from "update-notifier";
 
-// src/output.ts
-function printJson(data) {
-  console.log(JSON.stringify(data, null, 2));
-}
-
 // src/commands/activation.ts
 function applyActivation(active) {
   const root = gitToplevel();
@@ -468,8 +467,8 @@ function registerAuthCommands(program2) {
     const state = base64url(randomBytes(16));
     const redirectUri = `http://${LOCALHOST}:${CALLBACK_PORT}/callback`;
     let settle;
-    const outcome = new Promise((resolve7) => {
-      settle = resolve7;
+    const outcome = new Promise((resolve5) => {
+      settle = resolve5;
     });
     const server = createServer((req, res) => {
       const url = new URL(req.url ?? "/", `http://${LOCALHOST}`);
@@ -483,12 +482,12 @@ function registerAuthCommands(program2) {
       res.end(page.html, () => settle(page.result));
     });
     try {
-      await new Promise((resolve7, reject) => {
+      await new Promise((resolve5, reject) => {
         const onError = (err) => reject(err);
         server.once("error", onError);
         server.listen(CALLBACK_PORT, LOCALHOST, () => {
           server.removeListener("error", onError);
-          resolve7();
+          resolve5();
         });
       });
     } catch (err) {
@@ -1767,7 +1766,7 @@ function clearStaleArtifacts() {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 function spawnDaemon(options) {
   const file = binFile(DAEMON_BIN);
@@ -4871,319 +4870,25 @@ function registerSetupCommand(program2, dependencies = {}) {
   });
 }
 
-// src/commands/skill.ts
-import {
-  closeSync as closeSync4,
-  existsSync as existsSync12,
-  fsyncSync as fsyncSync3,
-  openSync as openSync4,
-  readFileSync as readFileSync10,
-  renameSync as renameSync5,
-  writeFileSync as writeFileSync7
-} from "fs";
-import { homedir as homedir8 } from "os";
-import { dirname as dirname7, join as join12, resolve as resolve4 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { createPatch } from "diff";
-
-// src/commands/claude-plugin.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync9, readdirSync as readdirSync2, rmSync as rmSync3, rmdirSync } from "fs";
-import { homedir as homedir7 } from "os";
-import { dirname as dirname6, join as join11, resolve as resolve3 } from "path";
-import { fileURLToPath } from "url";
-var __dirname = dirname6(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.";
-function resolvePluginDir(cwd, scope) {
-  if (scope && scope !== "user" && scope !== "project") {
-    console.error(`Unknown --scope "${scope}" (expected user or project)`);
-    return null;
-  }
-  const base = scope === "user" ? join11(homedir7(), ".claude") : join11(gitToplevel(cwd) ?? cwd, ".claude");
-  return join11(base, "skills", "prim");
-}
-function packageVersion() {
-  let dir = __dirname;
-  while (dir !== dirname6(dir)) {
-    const p = resolve3(dir, "package.json");
-    if (existsSync11(p)) return JSON.parse(readFileSync9(p, "utf-8")).version;
-    dir = dirname6(dir);
-  }
-  return "0.0.0";
-}
-function pluginManifest() {
-  const manifest = { name: "prim", description: PLUGIN_DESCRIPTION, version: packageVersion() };
-  return `${JSON.stringify(manifest, null, 2)}
-`;
-}
-function removeDirIfEmpty(dir) {
-  if (existsSync11(dir) && readdirSync2(dir).length === 0) rmdirSync(dir);
-}
-function pluginPaths(dir) {
-  return {
-    manifestPath: join11(dir, ".claude-plugin", "plugin.json"),
-    skillPath: join11(dir, "SKILL.md")
-  };
-}
-function installClaudePlugin(cwd, opts) {
-  const dir = resolvePluginDir(cwd, opts.scope);
-  if (dir === null) return 1;
-  const { manifestPath, skillPath } = pluginPaths(dir);
-  const manifest = pluginManifest();
-  const skill = loadSkill();
-  const manifestCurrent = existsSync11(manifestPath) ? readFileSync9(manifestPath, "utf-8") : null;
-  const skillCurrent = existsSync11(skillPath) ? readFileSync9(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;
-  }
-  mkdirSync8(join11(dir, ".claude-plugin"), { recursive: true });
-  atomicWrite3(manifestPath, manifest);
-  atomicWrite3(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 (!existsSync11(manifestPath) && !existsSync11(skillPath)) {
-    console.log(`prim skill plugin not present at ${dir}`);
-    return 0;
-  }
-  rmSync3(manifestPath, { force: true });
-  rmSync3(skillPath, { force: true });
-  removeDirIfEmpty(join11(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 = existsSync11(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 = dirname7(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 join12(homedir8(), ".claude", "CLAUDE.md");
-  if (agent === "codex") return join12(homedir8(), ".codex", "AGENTS.md");
-  if (agent === "hermes") {
-    return join12(process.env.HERMES_HOME ?? join12(homedir8(), ".hermes"), ".hermes.md");
-  }
-  return null;
-}
-function loadSkill() {
-  let dir = __dirname2;
-  while (dir !== dirname7(dir)) {
-    const p = resolve4(dir, "SKILL.md");
-    if (existsSync12(p)) return readFileSync10(p, "utf-8");
-    dir = dirname7(dir);
-  }
-  throw new Error("SKILL.md not found in package");
-}
-function detectTargets(cwd) {
-  return TARGET_CANDIDATES.filter((p) => existsSync12(resolve4(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 sep = existing.endsWith(eol) ? "" : eol;
-  return `${existing}${sep}${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 atomicWrite3(target, content) {
-  const tmp = `${target}.tmp`;
-  writeFileSync7(tmp, content);
-  const fd = openSync4(tmp, "r+");
-  try {
-    fsyncSync3(fd);
-  } finally {
-    closeSync4(fd);
-  }
-  renameSync5(tmp, target);
-}
-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 resolve4(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 resolve4(cwd, mapped);
-    console.error(`Unknown --agent "${opts.agent}" (expected claude, codex, or hermes)`);
-    return null;
-  }
-  const matches = detectTargets(cwd);
-  if (matches.length === 0) return resolve4(cwd, DEFAULT_TARGET);
-  if (matches.length === 1) return resolve4(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 = existsSync12(target) ? readFileSync10(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;
-  }
-  atomicWrite3(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 (!existsSync12(target)) {
-    console.log(`Skill block not present at ${target}`);
-    return 0;
-  }
-  const existing = readFileSync10(target, "utf-8");
-  const next = removeBlock(existing);
-  if (next === null) {
-    console.log(`Skill block not present at ${target}`);
-    return 0;
-  }
-  atomicWrite3(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 = existsSync12(target);
-  let installed = false;
-  if (fileExists) {
-    const content = readFileSync10(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(program2) {
-  const skill = program2.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));
-  });
-}
-
 // src/commands/statusline.ts
-import { readFileSync as readFileSync11 } from "fs";
-import { dirname as dirname8, resolve as resolve5 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { readFileSync as readFileSync9 } from "fs";
+import { dirname as dirname6, resolve as resolve3 } from "path";
+import { fileURLToPath } from "url";
 var STATUSLINE_TIMEOUT_MS = 200;
 var STATUSLINE_NAME_CAP = 3;
 function readPackageVersion() {
   try {
-    const here = dirname8(fileURLToPath3(import.meta.url));
+    const here = dirname6(fileURLToPath(import.meta.url));
     const candidates = [
       // The supervised runtime stages a tiny manifest beside the standalone
       // statusline bundle, so it remains versioned without loading the package.
-      resolve5(here, "manifest.json"),
-      resolve5(here, "../../package.json"),
-      resolve5(here, "../package.json")
+      resolve3(here, "manifest.json"),
+      resolve3(here, "../../package.json"),
+      resolve3(here, "../package.json")
     ];
     for (const path of candidates) {
       try {
-        const pkg2 = JSON.parse(readFileSync11(path, "utf-8"));
+        const pkg2 = JSON.parse(readFileSync9(path, "utf-8"));
         if (pkg2.version) {
           return pkg2.version;
         }
@@ -5370,8 +5075,8 @@ function registerWelcomeCommand(program2, deps = { getClient }) {
 }
 
 // src/index.ts
-var __dirname3 = dirname9(fileURLToPath4(import.meta.url));
-var pkg = JSON.parse(readFileSync12(resolve6(__dirname3, "../package.json"), "utf-8"));
+var __dirname = dirname7(fileURLToPath2(import.meta.url));
+var pkg = JSON.parse(readFileSync10(resolve4(__dirname, "../package.json"), "utf-8"));
 updateNotifier({ pkg }).notify();
 var program = new Command();
 program.name("prim").description("CLI for Primitive's decision graph").version(pkg.version).option("-y, --yes", "auto-confirm prompts").option(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primitive.ai/prim",
-  "version": "0.1.0-alpha.50",
+  "version": "0.1.0-alpha.52",
   "description": "CLI for Primitive's decision graph — passive decision capture, conflict gate, and team presence",
   "type": "module",
   "license": "MIT",