@primitive.ai/prim 0.1.0-alpha.55 → 0.1.0-alpha.57

package/dist/chunk-SWWBK4MP.js

@@ -0,0 +1,424 @@
+import {
+  DEFAULT_RULES,
+  scrub
+} from "./chunk-GUXBUBQ7.js";
+import {
+  canonicalGitRoot,
+  canonicalRepositoryPath
+} from "./chunk-LDQZASIF.js";
+
+// src/hooks/pre-tool-use-scoring.ts
+import { isAbsolute, relative, sep } from "path";
+function anyUnverified(results) {
+  return results.some((r) => r.verdict === "unavailable" || r.truncated);
+}
+function unverifiedNote(results) {
+  const causes = [];
+  const unavailable = results.find((r) => r.verdict === "unavailable");
+  if (unavailable) {
+    causes.push(
+      unavailable.unavailable ? `decision check skipped \u2014 ${unavailable.unavailable}` : "decision check skipped \u2014 not verified"
+    );
+  }
+  if (results.some((r) => r.truncated)) {
+    causes.push("decision check partial \u2014 conflict set truncated (per-file cap hit)");
+  }
+  return causes.map((c) => `[primitive] ${c}`).join("\n");
+}
+function buildHookOutput(aggregate, results, agent = "claude_code") {
+  if (aggregate === "deny") {
+    const reason = results.filter((r) => r.verdict === "deny").map((r) => r.reason).filter((s) => s.length > 0).join("\n\n") || "[primitive] conflict detected (no detail available)";
+    return {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "deny",
+        permissionDecisionReason: reason
+      }
+    };
+  }
+  if (agent === "codex" && aggregate === "ask") {
+    const reason = results.filter((r) => r.verdict === "ask" || r.verdict === "deny").map((r) => r.reason).filter((s) => s.length > 0).join("\n\n");
+    const context = results.map((r) => r.additionalContext).filter((s) => s.length > 0 && s !== reason).join("\n");
+    const merged = [reason, context].filter((s) => s.length > 0).join("\n\n");
+    const out = {
+      hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "allow" }
+    };
+    if (merged.length > 0) {
+      out.hookSpecificOutput.additionalContext = merged;
+    }
+    return out;
+  }
+  if (aggregate === "ask") {
+    const reason = results.filter((r) => r.verdict === "ask" || r.verdict === "deny").map((r) => r.reason).filter((s) => s.length > 0).join("\n\n") || "[primitive] please confirm this edit";
+    const additionalContext = results.map((r) => r.additionalContext).filter((s) => s.length > 0 && s !== reason).join("\n");
+    const out = {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "ask",
+        permissionDecisionReason: reason
+      }
+    };
+    if (additionalContext.length > 0) {
+      out.hookSpecificOutput.additionalContext = additionalContext;
+    }
+    return out;
+  }
+  const notes = [
+    ...results.map((r) => r.additionalContext).filter((s) => s.length > 0),
+    anyUnverified(results) ? unverifiedNote(results) : ""
+  ].filter((s) => s.length > 0).join("\n");
+  if (notes.length > 0) {
+    return {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "allow",
+        additionalContext: notes
+      }
+    };
+  }
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "allow"
+    }
+  };
+}
+function failOpenOutput() {
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "allow"
+    }
+  };
+}
+function buildHermesOutput(aggregate, results) {
+  if (aggregate !== "deny" && aggregate !== "ask") {
+    return {};
+  }
+  const reason = results.filter((r) => r.verdict === "deny" || r.verdict === "ask").map((r) => r.reason).filter((s) => s.length > 0).join("\n\n");
+  const directive = results.map((r) => r.additionalContext).filter((s) => s.length > 0 && s !== reason).join("\n");
+  const message = [reason, directive].filter((s) => s.length > 0).join("\n\n") || "[primitive] conflict detected (no detail available)";
+  return { action: "block", message };
+}
+function failOpenHermes() {
+  return {};
+}
+var SUPPORTED_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+var APPLY_PATCH_FILE_RE = /^\*\*\* (?:Update|Add|Delete) File: (?<path>.+)$/;
+var MOVE_FILE_RE = /^\*\*\* Move File:\s*(?<src>.+?)\s*->\s*(?<dst>.+?)\s*$/;
+var MOVE_TO_RE = /^\*\*\* Move to: (?<dst>.+)$/;
+var LINE_SPLIT_RE = /\r?\n/;
+function parseApplyPatchTargets(command) {
+  const paths = /* @__PURE__ */ new Set();
+  let activeUpdate = false;
+  let complete = true;
+  for (const line of command.split(LINE_SPLIT_RE)) {
+    const path = APPLY_PATCH_FILE_RE.exec(line)?.groups?.path;
+    if (path) {
+      paths.add(path);
+      activeUpdate = line.startsWith("*** Update File:");
+      continue;
+    }
+    const moveTo = MOVE_TO_RE.exec(line)?.groups?.dst;
+    if (moveTo) {
+      if (activeUpdate) paths.add(moveTo);
+      else complete = false;
+      activeUpdate = false;
+      continue;
+    }
+    const move = MOVE_FILE_RE.exec(line)?.groups;
+    if (move?.src) {
+      paths.add(move.src);
+      if (move.dst) {
+        paths.add(move.dst);
+      }
+      activeUpdate = false;
+      continue;
+    }
+    if (line === "*** Begin Patch" || line === "*** End Patch") activeUpdate = false;
+    else if (line.startsWith("*** ")) complete = false;
+  }
+  return { paths: [...paths], complete: complete && paths.size > 0 };
+}
+function extractCodexFileTargets(toolName, toolInput) {
+  if (toolName !== "apply_patch") {
+    return null;
+  }
+  if (!toolInput || typeof toolInput !== "object") {
+    return { paths: [], complete: false };
+  }
+  const command = toolInput.command;
+  return typeof command === "string" ? parseApplyPatchTargets(command) : { paths: [], complete: false };
+}
+var HERMES_EDITING_TOOLS = /* @__PURE__ */ new Set(["write_file", "patch"]);
+function extractHermesFileTargets(toolName, toolInput) {
+  if (!HERMES_EDITING_TOOLS.has(toolName)) {
+    return null;
+  }
+  if (!toolInput || typeof toolInput !== "object") {
+    return { paths: [], complete: false };
+  }
+  const input = toolInput;
+  if (toolName === "patch" && input.mode === "patch") {
+    return typeof input.patch === "string" ? parseApplyPatchTargets(input.patch) : { paths: [], complete: false };
+  }
+  const paths = typeof input.path === "string" && input.path.length > 0 ? [input.path] : [];
+  const mode = input.mode;
+  return { paths, complete: paths.length > 0 && (mode === void 0 || mode === "replace") };
+}
+function extractFileTargets(toolName, toolInput, agent = "claude_code") {
+  if (agent === "codex") {
+    return extractCodexFileTargets(toolName, toolInput);
+  }
+  if (agent === "hermes") {
+    return extractHermesFileTargets(toolName, toolInput);
+  }
+  if (!SUPPORTED_TOOLS.has(toolName)) {
+    return null;
+  }
+  if (!toolInput || typeof toolInput !== "object") {
+    return { paths: [], complete: false };
+  }
+  const input = toolInput;
+  if (toolName === "NotebookEdit") {
+    const paths2 = typeof input.notebook_path === "string" && input.notebook_path.length > 0 ? [input.notebook_path] : [];
+    return { paths: paths2, complete: paths2.length > 0 };
+  }
+  const paths = typeof input.file_path === "string" && input.file_path.length > 0 ? [input.file_path] : [];
+  return { paths, complete: paths.length > 0 };
+}
+function readHookMode(env) {
+  if (env.PRIM_BYPASS === "1" || env.PRIM_BYPASS === "true") {
+    return "off";
+  }
+  const mode = env.PRIM_HOOK_MODE;
+  if (mode === "off" || mode === "warn") {
+    return mode;
+  }
+  return "block";
+}
+function demoteForMode(verdict, mode) {
+  if (mode === "off") {
+    return "allow";
+  }
+  if (mode === "warn" && (verdict === "ask" || verdict === "deny")) {
+    return "warn";
+  }
+  return verdict;
+}
+
+// src/hooks/preflight-v3.ts
+import { Buffer } from "buffer";
+
+// src/hooks/shell-targets.ts
+import { parse } from "unbash";
+var OUTPUT_REDIRECTS = /* @__PURE__ */ new Set([">", ">>", ">|", "&>", "&>>"]);
+var READ_ONLY_COMMANDS = new Set(": cat echo false printf pwd test true [".split(" "));
+var SINKS = /* @__PURE__ */ new Set(["/dev/null", "/dev/stdout", "/dev/stderr"]);
+var STATIC_PARTS = /* @__PURE__ */ new Set(["Literal", "SingleQuoted", "AnsiCQuoted"]);
+function staticPart(part) {
+  return STATIC_PARTS.has(part.type) || part.type === "DoubleQuoted" && part.parts.every(staticPart);
+}
+function staticWord(word) {
+  if (!word || !word.value || word.value.includes("\0") || word.value.includes("\n")) return;
+  if (word.parts ? !word.parts.every(staticPart) : word.value.startsWith("~") || /[*?\[$`]/.test(word.text))
+    return;
+  return word.value;
+}
+function unknown(state) {
+  state.complete = false;
+  state.mutation = true;
+}
+function recordTarget(word, state) {
+  const path = staticWord(word);
+  if (path === "-" || path && (SINKS.has(path) || path.startsWith("/dev/fd/"))) return;
+  state.mutation = true;
+  if (path) state.paths.add(path);
+  else state.complete = false;
+}
+function visitRedirect(redirect, state) {
+  const target = staticWord(redirect.target);
+  if (redirect.operator === ">&" && (target === "-" || /^\d+$/.test(target ?? ""))) return;
+  if (OUTPUT_REDIRECTS.has(redirect.operator) || redirect.operator === ">&")
+    recordTarget(redirect.target, state);
+  else unknown(state);
+}
+function operands(words, short = "", long = /* @__PURE__ */ new Set()) {
+  const result = [];
+  let optionsEnded = false;
+  for (const word of words) {
+    const value = staticWord(word);
+    if (value === void 0) return;
+    if (optionsEnded || value === "-" || !value.startsWith("-")) result.push(value);
+    else if (value === "--") optionsEnded = true;
+    else if (value.startsWith("--") ? !long.has(value) : [...value.slice(1)].some((c) => !short.includes(c)))
+      return;
+  }
+  return result;
+}
+function visitCommand(command, state) {
+  for (const redirect of command.redirects) visitRedirect(redirect, state);
+  const name = staticWord(command.name);
+  if (!name || name.includes("/") || command.suffix.some((word) => !staticWord(word))) {
+    unknown(state);
+  } else if (!READ_ONLY_COMMANDS.has(name)) {
+    state.mutation = true;
+    let targets;
+    if (name === "tee") {
+      targets = operands(command.suffix, "ai", /* @__PURE__ */ new Set(["--append", "--ignore-interrupts"]));
+    } else if (name === "touch") {
+      targets = operands(command.suffix);
+    } else if (name === "rm") {
+      targets = operands(
+        command.suffix,
+        "fivI",
+        /* @__PURE__ */ new Set(["--force", "--interactive", "--interactive=once", "--verbose"])
+      );
+    } else if (name === "cp" || name === "mv") {
+      const pair = operands(command.suffix);
+      if (pair?.length === 2) targets = name === "cp" ? [pair[1]] : pair;
+    }
+    if (!targets?.length) state.complete = false;
+    else for (const target of targets) state.paths.add(target);
+  }
+  visitNested([command.name, command.prefix, command.suffix, command.redirects], state);
+}
+var CONTAINERS = /* @__PURE__ */ new Set(["Script", "Pipeline", "AndOr", "CompoundList"]);
+function visitNested(value, state) {
+  if (Array.isArray(value)) {
+    for (const child of value) visitNested(child, state);
+  } else if (value && typeof value === "object") {
+    const child = value;
+    if (child.type === "Command") {
+      visitCommand(child, state);
+    } else if (child.type === "Statement") {
+      visitStatement(child, state);
+    } else if ("parts" in child) {
+      for (const part of value.parts ?? []) visitNested(part, state);
+    } else {
+      const node = typeof child.type === "string" && "pos" in child && "end" in child;
+      if (node && !CONTAINERS.has(child.type)) unknown(state);
+      if (child.type === "Function") return;
+      for (const nested of Object.values(child)) visitNested(nested, state);
+    }
+  }
+}
+function visitStatement(statement, state) {
+  if (statement.background) unknown(state);
+  for (const redirect of statement.redirects) visitRedirect(redirect, state);
+  visitNested([statement.redirects, statement.command], state);
+}
+function analyzeShellTargets(source) {
+  if (!source.trim())
+    return { paths: [], coverage: "complete", mutation: "none" };
+  try {
+    const script = parse(source);
+    const state = { paths: /* @__PURE__ */ new Set(), complete: !script.errors?.length, mutation: false };
+    for (const statement of script.commands) visitStatement(statement, state);
+    if (script.errors?.length) state.mutation = true;
+    return {
+      paths: [...state.paths],
+      coverage: state.complete ? "complete" : "unverified",
+      mutation: state.mutation ? "present" : "none"
+    };
+  } catch {
+    return { paths: [], coverage: "unverified", mutation: "present" };
+  }
+}
+
+// src/hooks/preflight-v3.ts
+var PREFLIGHT_PROTOCOL_VERSION = 3;
+var MAX_PREFLIGHT_PATHS = 32;
+var MAX_PROPOSAL_BYTES = 6144;
+function resolvePreflightTargets(args) {
+  let rawPaths;
+  let coverage = "complete";
+  let mutation = "present";
+  if (args.agent === "claude_code" && args.toolName === "Bash") {
+    const command = args.toolInput && typeof args.toolInput === "object" ? args.toolInput.command : void 0;
+    if (typeof command !== "string") {
+      return { paths: [], coverage: "unverified", mutation: "present" };
+    }
+    const shell = analyzeShellTargets(command);
+    rawPaths = shell.paths;
+    coverage = shell.coverage;
+    mutation = shell.mutation;
+  } else {
+    const extracted = extractFileTargets(args.toolName, args.toolInput, args.agent);
+    if (!extracted) return { paths: [], coverage: "complete", mutation: "none" };
+    rawPaths = extracted.paths;
+    if (!extracted.complete) coverage = "unverified";
+  }
+  const root = canonicalGitRoot(args.cwd);
+  const paths = /* @__PURE__ */ new Set();
+  for (const rawPath of rawPaths) {
+    const canonical = canonicalRepositoryPath(rawPath, args.cwd, root);
+    if (canonical) paths.add(canonical);
+    else coverage = "unverified";
+  }
+  const bounded = [...paths];
+  if (bounded.length > MAX_PREFLIGHT_PATHS) coverage = "unverified";
+  return { paths: bounded.slice(0, MAX_PREFLIGHT_PATHS), coverage, mutation };
+}
+function truncateUtf8(value, maxBytes) {
+  const encoded = Buffer.from(value);
+  if (encoded.byteLength <= maxBytes) return value;
+  return encoded.subarray(0, maxBytes).toString("utf8").replace(/\uFFFD$/u, "");
+}
+function proposalFor(toolInput) {
+  const redacted = scrub(toolInput, DEFAULT_RULES);
+  return truncateUtf8(JSON.stringify(redacted) ?? "", MAX_PROPOSAL_BYTES);
+}
+function parsePreflightResponse(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const response = value;
+  const verdicts = /* @__PURE__ */ new Set(["allow", "warn", "ask", "block", "unavailable"]);
+  if (response.protocolVersion !== PREFLIGHT_PROTOCOL_VERSION || typeof response.verdict !== "string" || !verdicts.has(response.verdict) || typeof response.reasonCode !== "string" || typeof response.message !== "string" || !Array.isArray(response.conflicts) || !Array.isArray(response.bypassed)) {
+    return null;
+  }
+  return response;
+}
+function resultForPreflight(response) {
+  const verdict = response.verdict === "block" ? "deny" : response.verdict;
+  const safe = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+  const directives = response.conflicts.flatMap((value) => {
+    if (!value || typeof value !== "object") return [];
+    const { decisionId, shortId } = value;
+    const id = typeof shortId === "string" && safe.test(shortId) ? `dec_${shortId}` : typeof decisionId === "string" && safe.test(decisionId) ? decisionId : void 0;
+    return id ? [`To reconcile, run: prim reconcile ${id}`] : [];
+  });
+  const reason = [response.message, ...new Set(directives)].filter(Boolean).join("\n");
+  return {
+    verdict,
+    conflicts: response.conflicts,
+    reason,
+    additionalContext: ["warn", "ask", "block"].includes(response.verdict) ? reason : "",
+    truncated: false,
+    unavailable: response.verdict === "unavailable" ? response.message || response.reasonCode : void 0
+  };
+}
+function unverifiedResult(message) {
+  return {
+    verdict: "unavailable",
+    conflicts: [],
+    reason: "",
+    additionalContext: "",
+    truncated: false,
+    unavailable: message
+  };
+}
+
+export {
+  buildHookOutput,
+  failOpenOutput,
+  buildHermesOutput,
+  failOpenHermes,
+  readHookMode,
+  demoteForMode,
+  PREFLIGHT_PROTOCOL_VERSION,
+  resolvePreflightTargets,
+  proposalFor,
+  parsePreflightResponse,
+  resultForPreflight,
+  unverifiedResult
+};

package/dist/{chunk-F5QCFBJ6.js → chunk-TNNHR3EZ.js}

@@ -4,20 +4,12 @@ import { platform } from "os";
 
 // src/protocol/move.ts
 var LEGACY_ENVELOPE_VERSION = 1;
-var AGENT_ENVELOPE_VERSION = 2;
+var AGENT_ENVELOPE_VERSION = 3;
 var ENVELOPE_VERSION = LEGACY_ENVELOPE_VERSION;
-function withAgentProvenance(move, producer, workspaceId) {
-  return {
-    ...move,
-    env: { ...move.env, workspaceId },
-    envelopeVersion: AGENT_ENVELOPE_VERSION,
-    producer
-  };
-}
 
 // src/hooks/prim-hook-core.ts
-function toMove(parsed, cliVersion, agent = "claude_code", workspaceId) {
-  const move = {
+function toMove(parsed, cliVersion, agent = "claude_code", workspaceId, invocationId) {
+  return {
     moveId: randomUUID(),
     capturedAt: Date.now(),
     sessionId: parsed.session_id ?? "",
@@ -26,15 +18,13 @@ function toMove(parsed, cliVersion, agent = "claude_code", workspaceId) {
     env: {
       cwd: parsed.cwd ?? process.cwd(),
       cliVersion,
-      osPlatform: platform()
+      osPlatform: platform(),
+      ...workspaceId ? { workspaceId } : {}
     },
-    envelopeVersion: ENVELOPE_VERSION,
-    // Stamp the producer for non-Claude agents (codex, hermes); Claude Code
-    // moves omit it (the backend defaults an absent value to "claude_code"),
-    // keeping the Claude wire shape byte-identical.
-    ...agent === "claude_code" ? {} : { producer: agent }
+    envelopeVersion: AGENT_ENVELOPE_VERSION,
+    producer: agent,
+    ...invocationId ? { invocationId } : {}
   };
-  return workspaceId ? withAgentProvenance(move, agent, workspaceId) : move;
 }
 function toCommitMove(commit, cliVersion, cwd) {
   return {

package/dist/{chunk-HSZPTVKU.js → chunk-YIMUIPMD.js}

@@ -10,8 +10,6 @@ import { fileURLToPath } from "url";
 var PKG_NAME = "@primitive.ai/prim";
 var ROOT_WALK_LIMIT = 6;
 var NPX_FALLBACK = `npx --yes -p ${PKG_NAME}@latest`;
-var BIN_CACHE_DIR_SH = "${XDG_CACHE_HOME:-$HOME/.cache}/prim/bin";
-var BIN_CACHE_TTL_MIN_DEFAULT = 1440;
 var resolvedRoot;
 function locateRoot() {
   if (resolvedRoot !== void 0) {
@@ -24,7 +22,7 @@ function locateRoot() {
       try {
         const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
         if (manifest.name === PKG_NAME && manifest.bin) {
-          resolvedRoot = { dir, bin: manifest.bin };
+          resolvedRoot = { dir, version: manifest.version, bin: manifest.bin };
           return resolvedRoot;
         }
       } catch {
@@ -47,18 +45,23 @@ function binFile(bin) {
   }
   return isAbsolute(rel) ? rel : join(root.dir, rel);
 }
-function hookShimCommand(bin, args = "", opts = {}) {
-  const invoke = (cmd) => args ? `${cmd} ${args}` : cmd;
-  const ladder = `if command -v ${bin} >/dev/null 2>&1; then ${invoke(bin)}; elif [ -f "./node_modules/.bin/${bin}" ]; then ${invoke(`./node_modules/.bin/${bin}`)}; else ${invoke(`${NPX_FALLBACK} ${bin}`)}; fi`;
-  if (opts.cacheRead === false) {
-    return ladder;
-  }
-  const execArgs = args ? ` ${args}` : "";
-  const cacheBranch = `d="${BIN_CACHE_DIR_SH}"; if [ "\${PRIM_BIN_CACHE:-1}" != "0" ] && [ -f "$d/${bin}" ] && [ -f "$d/node" ] && [ -n "$(find "$d/${bin}" -mmin "-\${PRIM_BIN_CACHE_TTL_MIN:-${BIN_CACHE_TTL_MIN_DEFAULT}}" 2>/dev/null)" ]; then n=$(cat "$d/node"); p=$(cat "$d/${bin}"); if [ -x "$n" ] && [ -f "$p" ]; then export PRIM_BIN_CACHE_HIT=1; exec "$n" "$p"${execArgs}; fi; fi; `;
-  return cacheBranch + ladder;
+function packageVersion() {
+  return locateRoot()?.version ?? null;
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function pinnedHookCommand(bin, args = "") {
+  const version = packageVersion();
+  if (!version) throw new Error("cannot determine Primitive package version");
+  const suffix = args ? ` ${args}` : "";
+  const fallback = `npx --yes -p ${PKG_NAME}@${version} ${bin}${suffix}`;
+  const file = binFile(bin);
+  if (!file) return fallback;
+  return `if [ -x ${shellQuote(process.execPath)} ] && [ -f ${shellQuote(file)} ]; then ${shellQuote(process.execPath)} ${shellQuote(file)}${suffix}; else ${fallback}; fi`;
 }
 function detachedHookShimCommand(bin, args = "") {
-  return `payload=$(cat); { trap '' HUP; export npm_config_fetch_retries=2 npm_config_fetch_retry_mintimeout=10000 npm_config_fetch_retry_maxtimeout=10000 npm_config_fetch_timeout=60000; printf '%s' "$payload" | { ${hookShimCommand(bin, args, { cacheRead: false })}; }; } </dev/null >/dev/null 2>&1 &`;
+  return `payload=$(cat); { trap '' HUP; export npm_config_fetch_retries=2 npm_config_fetch_retry_mintimeout=10000 npm_config_fetch_retry_maxtimeout=10000 npm_config_fetch_timeout=60000; printf '%s' "$payload" | { ${pinnedHookCommand(bin, args)}; }; } </dev/null >/dev/null 2>&1 &`;
 }
 function commandMatchesBin(command, bin) {
   if (!command) {
@@ -68,7 +71,8 @@ function commandMatchesBin(command, bin) {
   if (c === bin || c.startsWith(`${bin} `)) {
     return true;
   }
-  return c.includes(`command -v ${bin} `);
+  const exactBin = new RegExp(`(?:^|\\s)${bin.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?:\\s|;|$)`);
+  return c.includes(`command -v ${bin} `) || c.includes(`-p ${PKG_NAME}@`) && exactBin.test(c);
 }
 
 // src/lib/bin-cache.ts
@@ -106,7 +110,8 @@ function warmBinCache() {
 
 export {
   binFile,
-  hookShimCommand,
+  packageVersion,
+  pinnedHookCommand,
   detachedHookShimCommand,
   commandMatchesBin,
   warmBinCache

package/dist/daemon/server.js

@@ -1488,6 +1488,13 @@ async function runIngestionLoop() {
 }
 async function handleConflictCheck(params) {
   assertCallerEnvMatches(params.callerEnv, getSiteUrl());
+  if (params.protocolVersion === 3) {
+    const { callerEnv: _callerEnv, ...body } = params;
+    return await client.post("/api/cli/decisions/conflict-check", body, {
+      signal: AbortSignal.timeout(HTTP_PROXY_TIMEOUT_MS),
+      quietRefresh: true
+    });
+  }
   if (typeof params.file !== "string") {
     throw new Error("conflict_check requires `file: string`");
   }

package/dist/hooks/post-commit.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import {
   toCommitMove
-} from "../chunk-F5QCFBJ6.js";
+} from "../chunk-TNNHR3EZ.js";
 import {
   appendMove,
   resolveOrg
 } from "../chunk-BOTKPLTI.js";
 import {
   isRepoActiveForCapture
-} from "../chunk-R5ZJRSLV.js";
+} from "../chunk-LDQZASIF.js";
 import "../chunk-DWDEQRWN.js";
 
 // src/hooks/post-commit.ts

package/dist/hooks/post-tool-use.js

@@ -5,24 +5,28 @@ import {
   requireDurableIngestAcknowledgement
 } from "../chunk-QY75BQMF.js";
 import {
-  scrubFromCwd
-} from "../chunk-6LAQVM26.js";
+  resolvePreflightTargets
+} from "../chunk-SWWBK4MP.js";
 import {
   toMove
-} from "../chunk-F5QCFBJ6.js";
+} from "../chunk-TNNHR3EZ.js";
 import {
   appendMove,
   resolveOrg
 } from "../chunk-BOTKPLTI.js";
+import {
+  scrubFromCwd
+} from "../chunk-GUXBUBQ7.js";
 import {
   getOrCreateWorkspaceId
 } from "../chunk-IMAIBPUC.js";
 import {
   warmBinCache
-} from "../chunk-HSZPTVKU.js";
+} from "../chunk-YIMUIPMD.js";
 import {
-  isRepoActiveForCapture
-} from "../chunk-R5ZJRSLV.js";
+  isRepoActive,
+  repoSyncId
+} from "../chunk-LDQZASIF.js";
 import {
   getClient
 } from "../chunk-DWDEQRWN.js";
@@ -66,7 +70,7 @@ function isVerdictFooterContext(value) {
 
 // src/hooks/post-tool-use.ts
 var STDIN_TIMEOUT_MS = 1e3;
-var EDITING_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit"]);
+var EDITING_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit", "Bash"]);
 var CODEX_EDITING_TOOLS = /* @__PURE__ */ new Set(["apply_patch"]);
 var HERMES_EDITING_TOOLS = /* @__PURE__ */ new Set(["write_file", "patch"]);
 function editingToolsFor(agent) {
@@ -146,13 +150,26 @@ async function main() {
     return;
   }
   const cwd = parsed.cwd ?? process.cwd();
-  if (!isRepoActiveForCapture(cwd)) {
+  if (!isRepoActive(cwd) || !repoSyncId(cwd)) {
     emit();
     return;
   }
+  if (agent === "claude_code") {
+    const targets = resolvePreflightTargets({
+      toolName,
+      toolInput: envelope.tool_input,
+      agent,
+      cwd
+    });
+    if (targets.mutation === "none") {
+      emit();
+      return;
+    }
+  }
   const identity = getOrCreateWorkspaceId(cwd);
   const workspaceId = identity.status === "ready" ? identity.workspaceId : void 0;
-  const base = toMove(parsed, resolveCliVersion(), agent, workspaceId);
+  const invocationId = agent === "claude_code" && typeof envelope.tool_use_id === "string" ? envelope.tool_use_id : void 0;
+  const base = toMove(parsed, resolveCliVersion(), agent, workspaceId, invocationId);
   const move = { ...base, payload: scrubFromCwd(parsed, cwd) };
   const { orgId } = resolveOrg({ sessionId: move.sessionId, cwd: move.env.cwd });
   try {