@fml-inc/fml 0.8.13-rc.1 → 0.8.13-rc.2

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "fml",
-  "version": "0.8.13-rc.1",
+  "version": "0.8.13-rc.2",
   "description": "FML agent tools for Claude Code",
   "mcpServers": {
     "fml": {

package/README.md

@@ -398,6 +398,48 @@ directories request owner-only permissions, and the SQLite database and
 sidecars are tightened to owner-only modes on platforms that support POSIX
 modes. An existing caller-supplied state directory retains its directory mode.
 
+## Local Git state
+
+Hooks, MCP defaults, and transcript discovery use the shared
+`@fml/agent-targets/git-state` resolver. A snapshot includes the canonical
+GitHub repository (when available), full HEAD ref, branch, commit SHA,
+worktree root, worktree Git directory, common Git directory, and detached,
+unborn, and linked-worktree flags. Local checkout state is retained even when
+there is no GitHub origin. Origin parsing consistently requires `github.com`;
+SSH aliases need a Git `url.*.insteadOf` rewrite to a canonical GitHub URL.
+Raw remote URLs and Git configuration are not stored.
+
+The resolver has synchronous and asynchronous entry points with a shared
+command sequence. Ordinary cold snapshots use two Git processes; symbolic-ref
+chains, reftable storage, and discovery overrides use an additional lookup.
+Hooks have a 250 ms total Git subprocess budget. It reads
+only the current checkout; it does not enumerate sibling worktrees or scan
+working files for changes.
+
+The cache holds up to 512 checkout snapshots in memory and in
+`git-state.cache.json` under the observer directory. Subdirectories and
+symlink aliases share their checkout's entry; linked worktrees remain
+separate. Cache hits inspect local metadata without launching Git. HEAD,
+current refs, packed refs, and local/worktree configuration changes invalidate
+entries immediately. Small ref files are read once per lookup; config and
+packed-ref files use inode/size/nanosecond mtime and ctime identities. The hook
+resolver validates snapshots without loading a schema library. A five-second
+maximum age bounds changes to global and
+included configuration. Unknown layouts and indeterminate failures bypass
+persistence. Concurrent cache writers may lose cache entries, never captures.
+
+New hook payloads carry the snapshot in `_fmlGitState`; `null` records an
+unsuccessful capture-time lookup. Upload never replaces those snapshots with
+a later checkout. Legacy hooks without a snapshot still use live resolution,
+but a branch is only attached when the captured and live repository match.
+Large hook payloads retain the snapshot when their other content is truncated.
+
+Claude and Codex transcript discovery also include bounded `localGitStates`
+metadata, observed at discovery time. Pi stores its initial snapshot in the
+native repository-origin marker and reuses that evidence during transcript
+sync. These fields use existing metadata/payload storage; they are not new
+indexed database columns or a full history of local changes.
+
 ## Automatic updates
 
 While the observer is running it checks npm for a newer FML release about once

package/dist/chunk-3RKICLMI.js

@@ -0,0 +1,34 @@
+import {
+  GIT_STATE_CACHE_FILENAME,
+  createGitStateResolver
+} from "./chunk-74KOMQZO.js";
+import {
+  FML_OBSERVER_DIR
+} from "./chunk-HDAFEHUY.js";
+
+// src/repo.ts
+import path from "path";
+var CACHE_FILE = path.join(FML_OBSERVER_DIR, GIT_STATE_CACHE_FILENAME);
+var resolver = createGitStateResolver({ cacheFile: CACHE_FILE });
+function repoInfo(state) {
+  return state?.repository ? { repo: state.repository, branch: state.branch, gitState: state } : null;
+}
+function resolveGitStateFromCwd(cwd, timeoutMs = 1e3) {
+  return resolver.resolve(cwd, { timeoutMs });
+}
+function resolveRepoFromCwd(cwd, timeoutMs = 1e3) {
+  return repoInfo(resolveGitStateFromCwd(cwd, timeoutMs));
+}
+function resolveRepositoryRootFromCwd(cwd, timeoutMs = 1e3) {
+  return resolveGitStateFromCwd(cwd, timeoutMs)?.worktreeRoot ?? null;
+}
+async function resolveRepoFromCwdAsync(cwd, signal) {
+  return repoInfo(await resolver.resolveAsync(cwd, { signal }));
+}
+
+export {
+  resolveGitStateFromCwd,
+  resolveRepoFromCwd,
+  resolveRepositoryRootFromCwd,
+  resolveRepoFromCwdAsync
+};

package/dist/{chunk-HVD2GMN3.js → chunk-56ABBKUE.js}

@@ -1,9 +1,9 @@
 import {
   runRawSyncOnce
-} from "./chunk-U7SITLCL.js";
+} from "./chunk-LYKMU7QR.js";
 import {
   resolvePackageRoot
-} from "./chunk-CSOFP7MT.js";
+} from "./chunk-F57IFY3K.js";
 
 // src/observer/sync-cycle.ts
 import { fork } from "child_process";

package/dist/chunk-74KOMQZO.js

@@ -0,0 +1,505 @@
+// ../../packages/shared/src/github-repository.ts
+var MAX_REPOSITORY_BYTES = 201;
+var UTF8_ENCODER = new TextEncoder();
+function utf8Bytes(value) {
+  return UTF8_ENCODER.encode(value).byteLength;
+}
+function githubRepositoryPath(pathname) {
+  const parts = pathname.replace(/^\/+|\/+$/g, "").split("/");
+  if (parts.length !== 2) return null;
+  const owner = parts[0];
+  const repository = parts[1]?.replace(/\.git$/i, "");
+  if (!owner || !repository) return null;
+  const segmentPattern = /^[A-Za-z0-9_.-]+$/;
+  if (!segmentPattern.test(owner) || !segmentPattern.test(repository)) {
+    return null;
+  }
+  const canonical = `${owner.toLowerCase()}/${repository.toLowerCase()}`;
+  if (canonical.startsWith("./") || canonical.startsWith("../") || repository === "." || repository === ".." || repository.toLowerCase().endsWith(".git")) {
+    return null;
+  }
+  return utf8Bytes(canonical) <= MAX_REPOSITORY_BYTES ? canonical : null;
+}
+function canonicalGitHubRepository(remote) {
+  const trimmed = remote.trim();
+  if (!trimmed || trimmed.includes("\0")) return null;
+  const scp = trimmed.match(/^git@github\.com:([^?#]+)$/i);
+  if (scp?.[1]) return githubRepositoryPath(scp[1]);
+  let url;
+  try {
+    url = new URL(trimmed);
+  } catch {
+    return null;
+  }
+  if (url.hostname.toLowerCase() !== "github.com") return null;
+  if (url.search || url.hash || url.password || url.port) return null;
+  if (url.protocol === "https:" || url.protocol === "http:") {
+    if (url.username) return null;
+  } else if (url.protocol === "ssh:") {
+    if (url.username && url.username !== "git") return null;
+  } else {
+    return null;
+  }
+  return githubRepositoryPath(url.pathname);
+}
+
+// ../../packages/agent-targets/src/git-state.ts
+import { execFile, execFileSync } from "child_process";
+import { createHash, randomUUID } from "crypto";
+import fs from "fs";
+import path from "path";
+
+// ../../packages/shared/src/git-state.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function validGitText(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 4096 && !new RegExp("\\p{Cc}", "u").test(value);
+}
+function parseGitState(value) {
+  if (!isRecord(value)) return null;
+  const {
+    version,
+    observedAtMs,
+    repository,
+    worktreeRoot,
+    gitDir,
+    commonDir,
+    headRef,
+    branch,
+    commitHash,
+    detached,
+    unborn,
+    isLinkedWorktree
+  } = value;
+  if (version !== 1 || typeof observedAtMs !== "number" || !Number.isSafeInteger(observedAtMs) || observedAtMs < 0 || !(repository === null || typeof repository === "string" && repository.length <= 201 && canonicalGitHubRepository(`https://github.com/${repository}`) === repository) || !validGitText(worktreeRoot) || !validGitText(gitDir) || !validGitText(commonDir) || !(headRef === null || validGitText(headRef)) || !(branch === null || validGitText(branch)) || !(commitHash === null || typeof commitHash === "string" && /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(commitHash)) || typeof detached !== "boolean" || typeof unborn !== "boolean" || typeof isLinkedWorktree !== "boolean")
+    return null;
+  return {
+    version,
+    observedAtMs,
+    repository,
+    worktreeRoot,
+    gitDir,
+    commonDir,
+    headRef,
+    branch,
+    commitHash,
+    detached,
+    unborn,
+    isLinkedWorktree
+  };
+}
+var MAX_GIT_STATES_BYTES = 16 * 1024;
+
+// ../../packages/agent-targets/src/git-state.ts
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+var GIT_STATE_CACHE_FILENAME = "git-state.cache.json";
+var GIT_STATE_PAYLOAD_KEY = "_fmlGitState";
+function capturedGitState(payload) {
+  if (!payload || typeof payload !== "object" || !(GIT_STATE_PAYLOAD_KEY in payload))
+    return void 0;
+  return parseGitState(payload[GIT_STATE_PAYLOAD_KEY]);
+}
+var DEFAULT_TTL_MS = 5e3;
+var DEFAULT_TIMEOUT_MS = 1e3;
+var DEFAULT_MAX_ENTRIES = 512;
+var MAX_OUTPUT_BYTES = 16 * 1024;
+var GIT_DISCOVERY_OVERRIDES = [
+  "GIT_DIR",
+  "GIT_COMMON_DIR",
+  "GIT_WORK_TREE",
+  "GIT_CEILING_DIRECTORIES",
+  "GIT_DISCOVERY_ACROSS_FILESYSTEM"
+];
+function* readState(cwd, knownHeadRef) {
+  const layout = yield {
+    args: [
+      "rev-parse",
+      "--show-toplevel",
+      "--absolute-git-dir",
+      "--git-common-dir",
+      "--verify",
+      "HEAD"
+    ],
+    // An unborn HEAD still emits the three validated checkout paths.
+    allowedExit: 128,
+    keepOutputOnAllowedExit: true
+  };
+  const [worktreePath, gitPath, commonPath, revision] = layout?.split("\n") ?? [];
+  if (!worktreePath || !gitPath || !commonPath) return null;
+  const worktreeRoot = path.resolve(cwd, worktreePath);
+  const gitDir = path.resolve(cwd, gitPath);
+  const commonDir = path.resolve(cwd, commonPath);
+  const headRef = knownHeadRef === void 0 ? yield { args: ["symbolic-ref", "--quiet", "HEAD"], allowedExit: 1 } : knownHeadRef;
+  const commitHash = revision ?? null;
+  if (!headRef && !commitHash) return null;
+  const remote = yield {
+    args: ["remote", "get-url", "origin"],
+    allowedExit: 2
+  };
+  return {
+    version: 1,
+    repository: remote ? canonicalGitHubRepository(remote) : null,
+    worktreeRoot,
+    gitDir,
+    commonDir,
+    headRef,
+    branch: headRef?.startsWith("refs/heads/") ? headRef.slice(11) : null,
+    commitHash: commitHash?.toLowerCase() ?? null,
+    detached: headRef === null,
+    unborn: headRef !== null && commitHash === null,
+    isLinkedWorktree: gitDir !== commonDir
+  };
+}
+function remaining(deadline) {
+  const milliseconds = deadline - performance.now();
+  if (milliseconds <= 0) throw new Error("Git lookup timed out");
+  return Math.max(1, Math.ceil(milliseconds));
+}
+function runSync(cwd, command, deadline) {
+  try {
+    return execFileSync("git", ["-C", cwd, ...command.args], {
+      encoding: "utf8",
+      timeout: remaining(deadline),
+      maxBuffer: MAX_OUTPUT_BYTES,
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true
+    }).trim() || null;
+  } catch (error) {
+    if (command.allowedExit !== void 0 && error && typeof error === "object" && "status" in error && error.status === command.allowedExit) {
+      return command.keepOutputOnAllowedExit && "stdout" in error && typeof error.stdout === "string" ? error.stdout.trim() || null : null;
+    }
+    throw error;
+  }
+}
+async function runAsync(cwd, command, deadline, signal) {
+  return await new Promise((resolve, reject) => {
+    execFile(
+      "git",
+      ["-C", cwd, ...command.args],
+      {
+        encoding: "utf8",
+        timeout: remaining(deadline),
+        maxBuffer: MAX_OUTPUT_BYTES,
+        windowsHide: true,
+        signal
+      },
+      (error, stdout) => {
+        if (signal?.aborted)
+          reject(signal.reason ?? new Error("Git lookup aborted"));
+        else if (error && error.code !== command.allowedExit) reject(error);
+        else
+          resolve(
+            error && !command.keepOutputOnAllowedExit ? null : stdout.trim() || null
+          );
+      }
+    );
+  });
+}
+function inspectCheckout(cwd) {
+  if (!cwd || cwd.trim() !== cwd || new RegExp("\\p{Cc}", "u").test(cwd) || Buffer.byteLength(cwd) > 4096)
+    return null;
+  try {
+    const directory = fs.realpathSync(cwd);
+    if (!fs.statSync(directory).isDirectory()) return null;
+    if (GIT_DISCOVERY_OVERRIDES.some((key) => process.env[key] !== void 0))
+      return { key: directory, signature: null };
+    const layout = findGitDirectory(directory);
+    if (!layout) return null;
+    if (process.env.GIT_CONFIG !== void 0)
+      return { key: layout.worktreeRoot, signature: null };
+    const local = checkoutSignature(layout);
+    const environment = Object.keys(process.env).filter(
+      (key) => key.startsWith("GIT_") || key === "HOME" || key === "XDG_CONFIG_HOME"
+    ).sort().map((key) => [key, process.env[key]]);
+    return {
+      key: layout.worktreeRoot,
+      headRef: local.headRef,
+      signature: local.signature === null ? null : createHash("sha256").update(JSON.stringify([local.signature, environment])).digest("hex")
+    };
+  } catch {
+    return null;
+  }
+}
+function createGitStateResolver(options = {}) {
+  const entries = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  const now = options.nowMs ?? Date.now;
+  const maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+  const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+  const readDisk = () => {
+    if (!options.cacheFile) return;
+    try {
+      const file = readRegularFile(options.cacheFile, 8 * 1024 * 1024).toString(
+        "utf8"
+      );
+      const parsed = JSON.parse(file);
+      if (!isRecord2(parsed) || parsed.version !== 1 || !Array.isArray(parsed.entries) || parsed.entries.length > maxEntries)
+        return;
+      const timestamp = now();
+      for (const pair of parsed.entries) {
+        if (!Array.isArray(pair) || pair.length !== 2) continue;
+        const cwd = pair[0];
+        const entry = pair[1];
+        if (typeof cwd !== "string" || !isRecord2(entry)) continue;
+        const state = parseGitState(entry.state);
+        if (state && typeof entry.signature === "string" && typeof entry.expiresAtMs === "number" && Number.isFinite(entry.expiresAtMs) && entry.expiresAtMs > timestamp && state.observedAtMs <= timestamp && entry.expiresAtMs <= state.observedAtMs + ttlMs) {
+          entries.set(cwd, {
+            signature: entry.signature,
+            state,
+            expiresAtMs: entry.expiresAtMs
+          });
+        }
+      }
+      trim();
+    } catch {
+    }
+  };
+  const trim = () => {
+    while (entries.size > Math.max(0, maxEntries)) {
+      const key = entries.keys().next().value;
+      if (key === void 0) break;
+      entries.delete(key);
+    }
+  };
+  const cached = (cwd, signature) => {
+    if (!signature || ttlMs <= 0) return void 0;
+    if (!entries.has(cwd)) readDisk();
+    const entry = entries.get(cwd);
+    if (!entry || entry.signature !== signature || entry.expiresAtMs <= now() || entry.state.observedAtMs > now())
+      return void 0;
+    entries.delete(cwd);
+    entries.set(cwd, entry);
+    return entry.state;
+  };
+  const finish = (cwd, signature, value) => {
+    const state = parseGitState(value && { ...value, observedAtMs: now() });
+    if (!state) return null;
+    const after = inspectCheckout(cwd)?.signature ?? null;
+    if (signature !== after) return null;
+    if (signature && maxEntries > 0 && ttlMs > 0) {
+      entries.delete(cwd);
+      entries.set(cwd, {
+        signature,
+        state,
+        expiresAtMs: state.observedAtMs + ttlMs
+      });
+      trim();
+      if (options.cacheFile) {
+        const temporary = `${options.cacheFile}.${process.pid}.${randomUUID()}.tmp`;
+        try {
+          fs.mkdirSync(path.dirname(options.cacheFile), {
+            recursive: true,
+            mode: 448
+          });
+          fs.writeFileSync(
+            temporary,
+            JSON.stringify({ version: 1, entries: [...entries] }),
+            { mode: 384 }
+          );
+          fs.renameSync(temporary, options.cacheFile);
+        } catch {
+          try {
+            fs.rmSync(temporary, { force: true });
+          } catch {
+          }
+        }
+      }
+    }
+    return state;
+  };
+  return {
+    resolve(cwd, lookup = {}) {
+      lookup.signal?.throwIfAborted();
+      const snapshot = inspectCheckout(cwd);
+      if (!snapshot) return null;
+      const { key, signature } = snapshot;
+      const hit = cached(key, signature);
+      if (hit) return hit;
+      try {
+        const deadline = performance.now() + (lookup.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+        const recipe = readState(key, snapshot.headRef);
+        let step = recipe.next();
+        while (!step.done) {
+          lookup.signal?.throwIfAborted();
+          step = recipe.next(runSync(key, step.value, deadline));
+        }
+        return finish(key, signature, step.value);
+      } catch {
+        lookup.signal?.throwIfAborted();
+        return null;
+      }
+    },
+    async resolveAsync(cwd, lookup = {}) {
+      lookup.signal?.throwIfAborted();
+      const snapshot = inspectCheckout(cwd);
+      if (!snapshot) return null;
+      const { key, signature } = snapshot;
+      const hit = cached(key, signature);
+      if (hit) return hit;
+      const existing = !lookup.signal ? pending.get(key) : void 0;
+      if (existing) return await existing;
+      const work = (async () => {
+        try {
+          const deadline = performance.now() + (lookup.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+          const recipe = readState(key, snapshot.headRef);
+          let step = recipe.next();
+          while (!step.done)
+            step = recipe.next(
+              await runAsync(key, step.value, deadline, lookup.signal)
+            );
+          return finish(key, signature, step.value);
+        } catch {
+          lookup.signal?.throwIfAborted();
+          return null;
+        }
+      })();
+      if (!lookup.signal) pending.set(key, work);
+      try {
+        return await work;
+      } finally {
+        if (pending.get(key) === work) pending.delete(key);
+      }
+    }
+  };
+}
+function readRegularFile(filePath, maxBytes) {
+  const fd = fs.openSync(
+    filePath,
+    fs.constants.O_RDONLY | fs.constants.O_NONBLOCK
+  );
+  try {
+    const stat = fs.fstatSync(fd);
+    if (!stat.isFile() || stat.size > maxBytes)
+      throw new Error("Git metadata is not a bounded regular file");
+    const buffer = Buffer.alloc(stat.size + 1);
+    let length = 0;
+    while (length < buffer.length) {
+      const bytes = fs.readSync(
+        fd,
+        buffer,
+        length,
+        buffer.length - length,
+        null
+      );
+      if (bytes === 0) break;
+      length += bytes;
+    }
+    if (length > stat.size) throw new Error("Git metadata grew during read");
+    return buffer.subarray(0, length);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+function fileContentIdentity(filePath) {
+  try {
+    const contents = readRegularFile(filePath, 4 * 1024 * 1024);
+    return `sha256:${createHash("sha256").update(contents).digest("hex")}`;
+  } catch (error) {
+    const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
+    return code === "ENOENT" || code === "ENOTDIR" ? "missing" : null;
+  }
+}
+function fileStatIdentity(filePath) {
+  try {
+    const stat = fs.statSync(filePath, { bigint: true });
+    if (!stat.isFile() || stat.ino === 0n) return null;
+    return [stat.dev, stat.ino, stat.size, stat.mtimeNs, stat.ctimeNs].join(
+      ":"
+    );
+  } catch (error) {
+    const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
+    return code === "ENOENT" || code === "ENOTDIR" ? "missing" : null;
+  }
+}
+function readSmallText(filePath) {
+  try {
+    return readRegularFile(filePath, MAX_OUTPUT_BYTES).toString("utf8").trim();
+  } catch {
+    return null;
+  }
+}
+function findGitDirectory(cwd) {
+  let current = path.resolve(cwd);
+  for (; ; ) {
+    const candidate = path.join(current, ".git");
+    let stat;
+    try {
+      stat = fs.statSync(candidate);
+    } catch {
+      stat = void 0;
+    }
+    if (stat?.isDirectory()) {
+      return { worktreeRoot: current, gitDir: candidate, commonDir: candidate };
+    }
+    if (stat?.isFile()) {
+      const pointer = readSmallText(candidate);
+      const match = pointer ? /^gitdir:\s*(.+)$/u.exec(pointer) : null;
+      if (!match?.[1]) return null;
+      const gitDir = path.resolve(current, match[1]);
+      const common = readSmallText(path.join(gitDir, "commondir"));
+      return {
+        worktreeRoot: current,
+        gitDir,
+        commonDir: common ? path.resolve(gitDir, common) : gitDir
+      };
+    }
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    try {
+      if (fs.statSync(current).dev !== fs.statSync(parent).dev) return null;
+    } catch {
+      return null;
+    }
+    current = parent;
+  }
+}
+function checkoutSignature(layout) {
+  const head = readSmallText(path.join(layout.gitDir, "HEAD"));
+  const configIdentity = [
+    fileStatIdentity(path.join(layout.commonDir, "config")),
+    fileStatIdentity(path.join(layout.gitDir, "config.worktree"))
+  ];
+  if (head === null || configIdentity.some((value) => value === null))
+    return { signature: null };
+  const parts = [layout.gitDir, layout.commonDir, head, ...configIdentity];
+  const ref = /^ref:\s*(.+)$/u.exec(head)?.[1];
+  if (ref) {
+    const looseRefPath = path.join(layout.commonDir, ref);
+    const looseRef = readSmallText(looseRefPath);
+    if (/^ref:/u.test(looseRef ?? "")) return { signature: null };
+    const packedIdentity = fileStatIdentity(
+      path.join(layout.commonDir, "packed-refs")
+    );
+    const reftableIdentity = fileContentIdentity(
+      path.join(layout.commonDir, "reftable", "tables.list")
+    );
+    const looseIdentity = looseRef ?? fileStatIdentity(looseRefPath);
+    if (looseIdentity === null || packedIdentity === null || reftableIdentity === null)
+      return { signature: null };
+    if (looseRef === null && looseIdentity !== "missing")
+      return { signature: null };
+    parts.push(looseIdentity, packedIdentity, reftableIdentity);
+    return {
+      // A fresh unborn checkout has no refs yet. Cache its missing-file
+      // identities after Git validates the snapshot; the first ref invalidates it.
+      signature: parts.join("\0"),
+      ...reftableIdentity === "missing" ? { headRef: ref } : {}
+    };
+  }
+  return {
+    signature: parts.join("\0"),
+    .../^(?:[a-f0-9]{40}|[a-f0-9]{64})$/i.test(head) ? { headRef: null } : {}
+  };
+}
+
+export {
+  canonicalGitHubRepository,
+  parseGitState,
+  GIT_STATE_CACHE_FILENAME,
+  GIT_STATE_PAYLOAD_KEY,
+  capturedGitState,
+  createGitStateResolver
+};

package/dist/{chunk-4YLCUJ6C.js → chunk-AZSAAPRC.js}

@@ -1,6 +1,10 @@
 import {
   resolveRepoFromCwdAsync
-} from "./chunk-EX5J3MPG.js";
+} from "./chunk-3RKICLMI.js";
+import {
+  GIT_STATE_PAYLOAD_KEY,
+  capturedGitState
+} from "./chunk-74KOMQZO.js";
 import {
   getActiveEnv,
   getSiteUrlForConvexUrl,
@@ -263,6 +267,7 @@ function boundedPayloadRow(baseRow, payload) {
   if (initialBytes <= MAX_HOOK_EVENT_ROW_JSON_BYTES) {
     return { row: baseRow, jsonBytes: initialBytes };
   }
+  const snapshot = capturedGitState(payload);
   const payloadJson = serializedJson(payload, "Hook event payload");
   const metadata = {
     truncated: true,
@@ -280,6 +285,7 @@ function boundedPayloadRow(baseRow, payload) {
       ...baseRow,
       payload: {
         _fmlTruncated: metadata,
+        ...snapshot !== void 0 ? { [GIT_STATE_PAYLOAD_KEY]: snapshot } : {},
         preview: codeUnitPrefix(payloadJson, middle)
       }
     };
@@ -374,8 +380,20 @@ async function prepareHookEvent(record, signal) {
 }
 async function repositoryForRecord(record, signal) {
   if (record.target === "pi" && !record.repository) return null;
+  const snapshot = capturedGitState(record.payload);
+  if (snapshot !== void 0) {
+    const repo = record.repository ?? snapshot?.repository;
+    return repo ? {
+      repo,
+      branch: snapshot?.repository === repo ? snapshot.branch : null,
+      ...snapshot ? { gitState: snapshot } : {}
+    } : null;
+  }
   const liveRepository = record.cwd ? await abortable(resolveRepoFromCwdAsync(record.cwd, signal), signal) : null;
-  return record.repository ? { repo: record.repository, branch: liveRepository?.branch ?? null } : liveRepository;
+  return record.repository ? {
+    repo: record.repository,
+    branch: liveRepository?.repo === record.repository ? liveRepository.branch : null
+  } : liveRepository;
 }
 function hookSessionRow(events) {
   const records = events.map((event) => event.record);

package/dist/{chunk-IUFDFBU7.js → chunk-C4Z6RMQ5.js}

@@ -1,6 +1,6 @@
 import {
   resolveRepoFromCwd
-} from "./chunk-EX5J3MPG.js";
+} from "./chunk-3RKICLMI.js";
 import {
   CONVEX_URL,
   getActiveEnv,

package/dist/chunk-F57IFY3K.js

@@ -0,0 +1,21 @@
+// src/package-root.ts
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function resolvePackageRoot(startDir = path.dirname(fileURLToPath(import.meta.url))) {
+  let directory = startDir;
+  while (true) {
+    if (fs.existsSync(path.join(directory, "package.json")) && fs.existsSync(path.join(directory, "bin"))) {
+      return directory;
+    }
+    const parent = path.dirname(directory);
+    if (parent === directory) {
+      throw new Error(`Could not resolve FML package root from ${startDir}`);
+    }
+    directory = parent;
+  }
+}
+
+export {
+  resolvePackageRoot
+};