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

package/dist/{chunk-ROL7SDXX.js → chunk-GQURYENF.js}

@@ -1,6 +1,6 @@
 import {
   gitToplevel
-} from "./chunk-R5ZJRSLV.js";
+} from "./chunk-LDQZASIF.js";
 import {
   withFileLock
 } from "./chunk-DWDEQRWN.js";

package/dist/{chunk-6LAQVM26.js → chunk-GUXBUBQ7.js}

@@ -78,5 +78,7 @@ function scrubFromCwd(value, cwd) {
 }
 
 export {
+  DEFAULT_RULES,
+  scrub,
   scrubFromCwd
 };

package/dist/chunk-LDQZASIF.js

@@ -0,0 +1,166 @@
+// src/lib/activation.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/lib/git.ts
+import { execFileSync } from "child_process";
+import { lstatSync, realpathSync } from "fs";
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "path";
+function gitToplevel(cwd) {
+  try {
+    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function gitValue(cwd, args) {
+  try {
+    const value = execFileSync("git", args, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return value || null;
+  } catch {
+    return null;
+  }
+}
+function githubRepositoryFullName(cwd) {
+  const remote = gitValue(cwd, ["config", "--get", "remote.origin.url"]);
+  if (!remote || [...remote].some((char) => char < " " || char === "\x7F")) return null;
+  const match = /^(?:git@github\.com:([^?#]+)|(?:https|ssh):\/\/(?:[^/@]+@)?github\.com(?::\d+)?\/([^?#]+))$/i.exec(
+    remote
+  );
+  const path = match?.[1] ?? match?.[2];
+  if (!path) return null;
+  const parts = path.replace(/^\/+|\/+$/g, "").replace(/\.git$/i, "").split("/");
+  if (parts.length !== 2 || parts.some((part) => !part || part !== part.trim())) return null;
+  return `${parts[0]}/${parts[1]}`;
+}
+function canonicalGitRoot(cwd) {
+  try {
+    const top = gitToplevel(cwd);
+    return top ? realpathSync.native(top) : null;
+  } catch {
+    return null;
+  }
+}
+function canonicalRepositoryPath(filePath, cwd, repositoryRoot = canonicalGitRoot(cwd)) {
+  if (!repositoryRoot || !filePath || [...filePath].some((char) => char < " " || char === "\x7F" || "~*?[]{}$`\\".includes(char)))
+    return null;
+  const absolute = resolve(cwd, filePath);
+  let target;
+  try {
+    const stat = lstatSync(absolute);
+    if (!stat.isFile() || stat.isSymbolicLink()) return null;
+    target = realpathSync.native(absolute);
+  } catch (error) {
+    if (!(error instanceof Error) || error.code !== "ENOENT") {
+      return null;
+    }
+    try {
+      const parent = realpathSync.native(dirname(absolute));
+      if (!lstatSync(parent).isDirectory()) return null;
+      target = resolve(parent, basename(absolute));
+    } catch {
+      return null;
+    }
+  }
+  const rel = relative(repositoryRoot, target);
+  if (!rel || isAbsolute(rel) || rel === ".." || rel.startsWith(`..${sep}`)) {
+    return null;
+  }
+  return sep === "/" ? rel : rel.split(sep).join("/");
+}
+
+// src/lib/activation.ts
+var PRIM_ACTIVE_KEY = "prim.active";
+var PRIM_REPO_SYNC_ID_KEY = "prim.repoSyncId";
+var PROJECT_INSTALL_FILES = [".claude/settings.json", ".codex/hooks.json"];
+var PRIM_HOOK_BINS = ["prim-hook", "prim-pre-tool-use", "prim-post-tool-use"];
+function repoActiveFlag(cwd) {
+  try {
+    const value = execFileSync2("git", ["config", "--get", PRIM_ACTIVE_KEY], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (value === "true") return "true";
+    if (value === "false") return "false";
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isRepoActive(cwd) {
+  return repoActiveFlag(cwd) === "true";
+}
+function setRepoActive(cwd, active) {
+  execFileSync2("git", ["config", "--local", PRIM_ACTIVE_KEY, active ? "true" : "false"], {
+    cwd,
+    stdio: ["ignore", "ignore", "pipe"]
+  });
+}
+function repoSyncId(cwd) {
+  try {
+    return execFileSync2("git", ["config", "--local", "--get", PRIM_REPO_SYNC_ID_KEY], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function setRepoSyncId(cwd, value) {
+  if (!value || value.includes("\0") || value.includes("\n")) {
+    throw new Error("invalid repository binding returned by server");
+  }
+  execFileSync2("git", ["config", "--local", PRIM_REPO_SYNC_ID_KEY, value], {
+    cwd,
+    stdio: ["ignore", "ignore", "pipe"]
+  });
+}
+function hasProjectPrimInstall(cwd) {
+  const root = gitToplevel(cwd);
+  if (root === null || root === homedir()) return false;
+  for (const rel of PROJECT_INSTALL_FILES) {
+    const path = join(root, rel);
+    if (existsSync(path)) {
+      try {
+        const content = readFileSync(path, "utf-8");
+        if (PRIM_HOOK_BINS.some((bin) => content.includes(bin))) return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+function isRepoActiveForCapture(cwd) {
+  const flag = repoActiveFlag(cwd);
+  if (flag === "true") return true;
+  if (flag === "false") return false;
+  return hasProjectPrimInstall(cwd);
+}
+function decisionIngestionStatus(cwd) {
+  return isRepoActiveForCapture(cwd) ? "enabled" : "disabled";
+}
+
+export {
+  gitToplevel,
+  githubRepositoryFullName,
+  canonicalGitRoot,
+  canonicalRepositoryPath,
+  isRepoActive,
+  setRepoActive,
+  repoSyncId,
+  setRepoSyncId,
+  isRepoActiveForCapture,
+  decisionIngestionStatus
+};

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 {