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

package/dist/pi/extension.js

@@ -10,7 +10,7 @@ var __export = (target, all) => {
 
 // src/dirs.ts
 import os from "node:os";
-import path15 from "node:path";
+import path16 from "node:path";
 function isPresent(value) {
   return value !== void 0 && value.trim().length > 0;
 }
@@ -31,7 +31,7 @@ function platformBaseDirectory(value, pathApi) {
 function resolveFmlDirectories(options = {}) {
   const platform = options.platform ?? process.platform;
   const env = options.env ?? process.env;
-  const pathApi = platform === "win32" ? path15.win32 : path15.posix;
+  const pathApi = platform === "win32" ? path16.win32 : path16.posix;
   const homeDir = normalizeAbsolutePath(
     options.homeDir ?? os.homedir(),
     "home directory",
@@ -123,41 +123,41 @@ var init_dirs = __esm({
     FML_LOG_DIR = DIRECTORIES.logDir;
     FML_OBSERVER_DIR = DIRECTORIES.observerDir;
     FML_OBSERVER_PORT = observerPort();
-    FML_OBSERVER_STATE_FILE = path15.join(
+    FML_OBSERVER_STATE_FILE = path16.join(
       FML_OBSERVER_DIR,
       "observer.pid.json"
     );
-    FML_OBSERVER_LOCK_FILE = path15.join(
+    FML_OBSERVER_LOCK_FILE = path16.join(
       FML_OBSERVER_DIR,
       "observer.lock"
     );
-    FML_OBSERVER_AUTH_TOKEN_FILE = path15.join(
+    FML_OBSERVER_AUTH_TOKEN_FILE = path16.join(
       FML_OBSERVER_DIR,
       "auth-token"
     );
-    FML_OBSERVER_ENDPOINT_FILE = path15.join(
+    FML_OBSERVER_ENDPOINT_FILE = path16.join(
       FML_OBSERVER_DIR,
       "endpoint.json"
     );
-    FML_OBSERVER_LOG_FILE = path15.join(FML_LOG_DIR, "observer.log");
-    FML_UPDATE_LOG_FILE = path15.join(FML_LOG_DIR, "update.log");
-    FML_INSTALLATION_ID_FILE = path15.join(
+    FML_OBSERVER_LOG_FILE = path16.join(FML_LOG_DIR, "observer.log");
+    FML_UPDATE_LOG_FILE = path16.join(FML_LOG_DIR, "update.log");
+    FML_INSTALLATION_ID_FILE = path16.join(
       FML_STATE_DIR,
       "installation_id"
     );
-    FML_PANOPTICON_DB_FILE = path15.join(FML_STATE_DIR, "panopticon.db");
+    FML_PANOPTICON_DB_FILE = path16.join(FML_STATE_DIR, "panopticon.db");
     FML_PANOPTICON_DB_OBSERVER_STATE_FILE = `${FML_PANOPTICON_DB_FILE}.observer.pid.json`;
     FML_PANOPTICON_DB_OBSERVER_LOCK_FILE = `${FML_PANOPTICON_DB_FILE}.observer.lock`;
-    FML_LEGACY_OBSERVER_DB_FILE = path15.join(
+    FML_LEGACY_OBSERVER_DB_FILE = path16.join(
       FML_OBSERVER_DIR,
       "observer.db"
     );
-    FML_HOOK_INBOX_DIR = path15.join(FML_OBSERVER_DIR, "hook-inbox");
-    FML_HOOK_CONTEXT_STATE_DIR = path15.join(
+    FML_HOOK_INBOX_DIR = path16.join(FML_OBSERVER_DIR, "hook-inbox");
+    FML_HOOK_CONTEXT_STATE_DIR = path16.join(
       FML_OBSERVER_DIR,
       "hook-context-state"
     );
-    FML_HOOK_CAPTURE_DISABLED_FILE = path15.join(
+    FML_HOOK_CAPTURE_DISABLED_FILE = path16.join(
       FML_OBSERVER_DIR,
       "hook-capture.disabled"
     );
@@ -165,8 +165,8 @@ var init_dirs = __esm({
 });
 
 // src/config.ts
-import fs6 from "node:fs";
-import path16 from "node:path";
+import fs7 from "node:fs";
+import path17 from "node:path";
 function isHostedBackendUrl(url2) {
   let normalized;
   try {
@@ -195,7 +195,7 @@ function normalizeAppUrl(value) {
 function readEnvConfig() {
   try {
     const parsed = JSON.parse(
-      fs6.readFileSync(ENV_CONFIG_PATH, "utf8")
+      fs7.readFileSync(ENV_CONFIG_PATH, "utf8")
     );
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       throw new Error("invalid environment config");
@@ -256,7 +256,7 @@ function getActiveEnv() {
   return { name, convexUrl, appUrl };
 }
 function authStorePathFor(envName) {
-  return path16.join(FML_DATA_DIR, `auth.${envName}.json`);
+  return path17.join(FML_DATA_DIR, `auth.${envName}.json`);
 }
 function getSiteUrlForConvexUrl(convexUrl) {
   const explicit = process.env.CONVEX_SITE_URL;
@@ -274,7 +274,7 @@ var init_config = __esm({
     LEGACY_HOSTED_BACKEND_URLS = [
       "https://trustworthy-chihuahua-382.convex.site"
     ];
-    ENV_CONFIG_PATH = path16.join(FML_DATA_DIR, "env.json");
+    ENV_CONFIG_PATH = path17.join(FML_DATA_DIR, "env.json");
     ENV_NAME_RE = /^[A-Za-z0-9_-]+$/;
     CONVEX_URL = (process.env.FML_CONVEX_URL ?? getActiveEnv().convexUrl ?? DEFAULT_PROD_URL).replace(/\/$/, "");
     WORKOS_API_URL = "https://api.workos.com";
@@ -307,9 +307,9 @@ __export(telemetry_config_exports, {
   refreshCliTelemetryConfig: () => refreshCliTelemetryConfig,
   resolveCliSentryConfig: () => resolveCliSentryConfig
 });
-import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
-import fs7 from "node:fs";
-import path17 from "node:path";
+import { createHash as createHash4, randomUUID as randomUUID3 } from "node:crypto";
+import fs8 from "node:fs";
+import path18 from "node:path";
 function parseSentryConfig(value) {
   if (value === null) return null;
   if (!value || typeof value !== "object")
@@ -330,16 +330,16 @@ function parseSentryConfig(value) {
 }
 function cachePathFor(siteUrl) {
   const key = isHostedBackendUrl(siteUrl) ? DEFAULT_SYNC_URL : siteUrl;
-  return path17.join(
+  return path18.join(
     FML_DATA_DIR,
     "telemetry-config",
-    `${createHash3("sha256").update(key).digest("hex")}.json`
+    `${createHash4("sha256").update(key).digest("hex")}.json`
   );
 }
 function readCache(siteUrl) {
   try {
     const value = JSON.parse(
-      fs7.readFileSync(cachePathFor(siteUrl), "utf8")
+      fs8.readFileSync(cachePathFor(siteUrl), "utf8")
     );
     if (!value || typeof value !== "object") return void 0;
     const entry = value;
@@ -356,15 +356,15 @@ function readCache(siteUrl) {
 }
 function writeCache(entry) {
   const cachePath = cachePathFor(entry.siteUrl);
-  const temporaryPath = `${cachePath}.${randomUUID2()}.tmp`;
+  const temporaryPath = `${cachePath}.${randomUUID3()}.tmp`;
   try {
-    fs7.mkdirSync(path17.dirname(cachePath), { recursive: true, mode: 448 });
-    fs7.writeFileSync(temporaryPath, JSON.stringify(entry), { mode: 384 });
-    fs7.renameSync(temporaryPath, cachePath);
+    fs8.mkdirSync(path18.dirname(cachePath), { recursive: true, mode: 448 });
+    fs8.writeFileSync(temporaryPath, JSON.stringify(entry), { mode: 384 });
+    fs8.renameSync(temporaryPath, cachePath);
   } catch {
   } finally {
     try {
-      fs7.rmSync(temporaryPath, { force: true });
+      fs8.rmSync(temporaryPath, { force: true });
     } catch {
     }
   }
@@ -450,10 +450,10 @@ var init_telemetry_config = __esm({
 });
 
 // src/auth/token-store.ts
-import { createHash as createHash4, randomUUID as randomUUID3 } from "node:crypto";
-import { execFileSync } from "node:child_process";
-import fs8 from "node:fs";
-import path18 from "node:path";
+import { createHash as createHash5, randomUUID as randomUUID4 } from "node:crypto";
+import { execFileSync as execFileSync2 } from "node:child_process";
+import fs9 from "node:fs";
+import path19 from "node:path";
 function getCurrentProcessIdentity() {
   let cache = processGlobals[PROCESS_IDENTITY_KEY];
   if (!cache) {
@@ -473,36 +473,36 @@ function resolveEnvName(envName) {
   return envName ?? getActiveEnv().name;
 }
 function ensureDir(envName) {
-  const dir = path18.dirname(storePathFor(envName));
-  fs8.mkdirSync(dir, { recursive: true, mode: 448 });
+  const dir = path19.dirname(storePathFor(envName));
+  fs9.mkdirSync(dir, { recursive: true, mode: 448 });
   try {
-    fs8.chmodSync(dir, 448);
+    fs9.chmodSync(dir, 448);
   } catch {
   }
 }
 function writeSecretFile(filePath, data) {
-  const temporaryFile = `${filePath}.${process.pid}.${randomUUID3()}.tmp`;
+  const temporaryFile = `${filePath}.${process.pid}.${randomUUID4()}.tmp`;
   let descriptor = null;
   try {
-    descriptor = fs8.openSync(temporaryFile, "wx", 384);
-    fs8.writeFileSync(descriptor, data, { encoding: "utf8" });
-    fs8.fsyncSync(descriptor);
-    fs8.closeSync(descriptor);
+    descriptor = fs9.openSync(temporaryFile, "wx", 384);
+    fs9.writeFileSync(descriptor, data, { encoding: "utf8" });
+    fs9.fsyncSync(descriptor);
+    fs9.closeSync(descriptor);
     descriptor = null;
-    fs8.renameSync(temporaryFile, filePath);
+    fs9.renameSync(temporaryFile, filePath);
     try {
-      fs8.chmodSync(filePath, 384);
+      fs9.chmodSync(filePath, 384);
     } catch {
     }
   } finally {
     if (descriptor !== null) {
       try {
-        fs8.closeSync(descriptor);
+        fs9.closeSync(descriptor);
       } catch {
       }
     }
     try {
-      fs8.unlinkSync(temporaryFile);
+      fs9.unlinkSync(temporaryFile);
     } catch {
     }
   }
@@ -510,7 +510,7 @@ function writeSecretFile(filePath, data) {
 function readTokens(envName) {
   let raw;
   try {
-    raw = fs8.readFileSync(storePathFor(envName), "utf-8");
+    raw = fs9.readFileSync(storePathFor(envName), "utf-8");
   } catch {
     return null;
   }
@@ -534,7 +534,7 @@ function parseStoredAuthShape(parsed) {
 function readTokensForReconciliation(envName) {
   let raw;
   try {
-    raw = fs8.readFileSync(storePathFor(envName), "utf8");
+    raw = fs9.readFileSync(storePathFor(envName), "utf8");
   } catch (error62) {
     if (error62.code === "ENOENT") return null;
     throw error62;
@@ -561,7 +561,7 @@ function writeTokensUnlocked(auth, envName) {
   writeSecretFile(storePathFor(envName), JSON.stringify(auth, null, 2));
 }
 function credentialHash(value) {
-  return createHash4("sha256").update(value).digest("hex");
+  return createHash5("sha256").update(value).digest("hex");
 }
 function describeError(error62) {
   return error62 instanceof Error ? error62.message : String(error62);
@@ -639,7 +639,7 @@ function refreshLockPath(envName) {
   return `${storePathFor(envName)}.refresh.lock`;
 }
 function pendingOAuthRefreshPrefix(envName) {
-  return `${path18.basename(storePathFor(envName))}.refresh-result.`;
+  return `${path19.basename(storePathFor(envName))}.refresh-result.`;
 }
 function parsePendingOAuthRefresh(raw) {
   try {
@@ -655,7 +655,7 @@ function parsePendingOAuthRefresh(raw) {
 }
 function stagePendingOAuthRefresh(previousRefreshToken, refreshed, envName) {
   ensureDir(envName);
-  const resultPath = `${storePathFor(envName)}.refresh-result.${Date.now()}.${randomUUID3()}.json`;
+  const resultPath = `${storePathFor(envName)}.refresh-result.${Date.now()}.${randomUUID4()}.json`;
   const pending = {
     version: 1,
     previousRefreshTokenHash: credentialHash(previousRefreshToken),
@@ -668,7 +668,7 @@ function stagePendingOAuthRefresh(previousRefreshToken, refreshed, envName) {
 }
 function removePendingOAuthRefresh(resultPath) {
   try {
-    fs8.unlinkSync(resultPath);
+    fs9.unlinkSync(resultPath);
   } catch (error62) {
     if (error62.code !== "ENOENT") {
       console.error(
@@ -679,11 +679,11 @@ function removePendingOAuthRefresh(resultPath) {
 }
 function reconcilePendingOAuthRefreshes(envName, unreadableStorePolicy = "preserve-staged") {
   const storePath = storePathFor(envName);
-  const directory = path18.dirname(storePath);
+  const directory = path19.dirname(storePath);
   const prefix = pendingOAuthRefreshPrefix(envName);
   let resultPaths;
   try {
-    resultPaths = fs8.readdirSync(directory).filter((entry) => entry.startsWith(prefix) && entry.endsWith(".json")).map((entry) => path18.join(directory, entry));
+    resultPaths = fs9.readdirSync(directory).filter((entry) => entry.startsWith(prefix) && entry.endsWith(".json")).map((entry) => path19.join(directory, entry));
   } catch (error62) {
     if (error62.code === "ENOENT") return;
     throw error62;
@@ -691,7 +691,7 @@ function reconcilePendingOAuthRefreshes(envName, unreadableStorePolicy = "preser
   const pendingResults = resultPaths.map((resultPath) => {
     let pending = null;
     try {
-      pending = parsePendingOAuthRefresh(fs8.readFileSync(resultPath, "utf8"));
+      pending = parsePendingOAuthRefresh(fs9.readFileSync(resultPath, "utf8"));
     } catch (error62) {
       if (error62.code !== "ENOENT") throw error62;
     }
@@ -746,13 +746,13 @@ function parseRefreshLockOwner(raw) {
 function getProcessIdentity(pid) {
   try {
     if (process.platform === "linux") {
-      const stat = fs8.readFileSync(`/proc/${pid}/stat`, "utf8");
+      const stat = fs9.readFileSync(`/proc/${pid}/stat`, "utf8");
       const fieldsAfterCommand = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
       const startTimeTicks = fieldsAfterCommand[19];
       return startTimeTicks ? `linux:${startTimeTicks}` : null;
     }
     if (process.platform === "darwin") {
-      const startedAt = execFileSync(
+      const startedAt = execFileSync2(
         "ps",
         ["-p", String(pid), "-o", "lstart="],
         {
@@ -764,7 +764,7 @@ function getProcessIdentity(pid) {
       return startedAt ? `darwin:${startedAt}` : null;
     }
     if (process.platform === "win32") {
-      const startedAt = execFileSync(
+      const startedAt = execFileSync2(
         "powershell.exe",
         [
           "-NoProfile",
@@ -798,7 +798,7 @@ function parseRecoveryMarkerOwner(raw) {
 function snapshotLeaseFile(filePath) {
   let stat;
   try {
-    stat = fs8.lstatSync(filePath);
+    stat = fs9.lstatSync(filePath);
   } catch (error62) {
     if (error62.code === "ENOENT") return null;
     throw error62;
@@ -807,7 +807,7 @@ function snapshotLeaseFile(filePath) {
     try {
       return {
         stat,
-        raw: fs8.readFileSync(path18.join(filePath, "owner.json"), "utf8")
+        raw: fs9.readFileSync(path19.join(filePath, "owner.json"), "utf8")
       };
     } catch (error62) {
       if (error62.code === "ENOENT") {
@@ -817,7 +817,7 @@ function snapshotLeaseFile(filePath) {
     }
   }
   try {
-    return { stat, raw: fs8.readFileSync(filePath, "utf8") };
+    return { stat, raw: fs9.readFileSync(filePath, "utf8") };
   } catch (error62) {
     if (error62.code === "ENOENT") return null;
     throw error62;
@@ -829,21 +829,21 @@ function snapshotsMatch(observed, current) {
 function restoreMovedLease(movedPath, originalPath) {
   let movedStat;
   try {
-    movedStat = fs8.lstatSync(movedPath);
+    movedStat = fs9.lstatSync(movedPath);
   } catch (error62) {
     if (error62.code === "ENOENT") return;
     throw error62;
   }
   if (!movedStat.isFile()) return;
   try {
-    fs8.linkSync(movedPath, originalPath);
+    fs9.linkSync(movedPath, originalPath);
   } catch (error62) {
     const code = error62.code;
     if (code === "EEXIST" || code === "ENOENT") return;
     throw error62;
   }
   try {
-    fs8.unlinkSync(movedPath);
+    fs9.unlinkSync(movedPath);
   } catch (error62) {
     if (error62.code !== "ENOENT") throw error62;
   }
@@ -857,27 +857,27 @@ function pathMatchesClaim(filePath, claimedStat, ownerId, parseOwner) {
 function markClaimReleased(filePath, claimedStat, owner, parseOwner) {
   let descriptor;
   try {
-    descriptor = fs8.openSync(filePath, "r+");
+    descriptor = fs9.openSync(filePath, "r+");
   } catch (error62) {
     if (error62.code === "ENOENT") return false;
     throw error62;
   }
   try {
-    const currentStat = fs8.fstatSync(descriptor);
+    const currentStat = fs9.fstatSync(descriptor);
     if (currentStat.dev !== claimedStat.dev || currentStat.ino !== claimedStat.ino) {
       return false;
     }
-    const currentOwner = parseOwner(fs8.readFileSync(descriptor, "utf8"));
+    const currentOwner = parseOwner(fs9.readFileSync(descriptor, "utf8"));
     if (currentOwner?.ownerId !== owner.ownerId) return false;
     const serialized = Buffer.from(
       `${JSON.stringify({ ...owner, releasedAtMs: Date.now() })}
 `,
       "utf8"
     );
-    fs8.ftruncateSync(descriptor, 0);
+    fs9.ftruncateSync(descriptor, 0);
     let offset = 0;
     while (offset < serialized.length) {
-      offset += fs8.writeSync(
+      offset += fs9.writeSync(
         descriptor,
         serialized,
         offset,
@@ -885,19 +885,19 @@ function markClaimReleased(filePath, claimedStat, owner, parseOwner) {
         offset
       );
     }
-    fs8.fsyncSync(descriptor);
+    fs9.fsyncSync(descriptor);
     return true;
   } finally {
-    fs8.closeSync(descriptor);
+    fs9.closeSync(descriptor);
   }
 }
 function releaseOwnedLease(filePath, claimedStat, owner, parseOwner, description) {
-  const releasedPath = `${filePath}.released.${randomUUID3()}`;
+  const releasedPath = `${filePath}.released.${randomUUID4()}`;
   let moved = false;
   try {
     if (!markClaimReleased(filePath, claimedStat, owner, parseOwner)) return;
     try {
-      fs8.renameSync(filePath, releasedPath);
+      fs9.renameSync(filePath, releasedPath);
       moved = true;
     } catch (error62) {
       if (error62.code === "ENOENT") return;
@@ -910,7 +910,7 @@ function releaseOwnedLease(filePath, claimedStat, owner, parseOwner, description
       moved = false;
       return;
     }
-    fs8.rmSync(releasedPath, {
+    fs9.rmSync(releasedPath, {
       recursive: released.stat.isDirectory(),
       force: true
     });
@@ -984,9 +984,9 @@ function ownerPidWasReused(owner, lockMtimeMs) {
   return currentIdentity !== null && currentIdentity !== owner.processIdentity;
 }
 function writeClaimToDescriptor(descriptor, serializedOwner) {
-  const claimedStat = fs8.fstatSync(descriptor);
-  fs8.writeFileSync(descriptor, serializedOwner, { encoding: "utf8" });
-  fs8.fsyncSync(descriptor);
+  const claimedStat = fs9.fstatSync(descriptor);
+  fs9.writeFileSync(descriptor, serializedOwner, { encoding: "utf8" });
+  fs9.fsyncSync(descriptor);
   return claimedStat;
 }
 function recoverAbandonedRecoveryMarker(recoveryPath) {
@@ -996,15 +996,15 @@ function recoverAbandonedRecoveryMarker(recoveryPath) {
   const ownerAlive = owner ? isProcessAlive(owner.pid) : false;
   const reclaimable = owner ? owner.releasedAtMs !== void 0 || !ownerAlive || ownerAlive && ownerPidWasReused(owner, observed.stat.mtimeMs) : Date.now() - observed.stat.mtimeMs > OAUTH_REFRESH_RECOVERY_STALE_MS;
   if (!reclaimable) return;
-  const abandonedPath = `${recoveryPath}.stale.${randomUUID3()}`;
+  const abandonedPath = `${recoveryPath}.stale.${randomUUID4()}`;
   try {
-    fs8.renameSync(recoveryPath, abandonedPath);
+    fs9.renameSync(recoveryPath, abandonedPath);
     const moved = snapshotLeaseFile(abandonedPath);
     if (!moved || !snapshotsMatch(observed, moved)) {
       restoreMovedLease(abandonedPath, recoveryPath);
       return;
     }
-    fs8.rmSync(abandonedPath, {
+    fs9.rmSync(abandonedPath, {
       recursive: moved.stat.isDirectory(),
       force: true
     });
@@ -1013,7 +1013,7 @@ function recoverAbandonedRecoveryMarker(recoveryPath) {
   }
 }
 function acquireRecoveryMarker(recoveryPath) {
-  const ownerId = randomUUID3();
+  const ownerId = randomUUID4();
   const owner = {
     version: 1,
     ownerId,
@@ -1024,7 +1024,7 @@ function acquireRecoveryMarker(recoveryPath) {
   };
   let descriptor;
   try {
-    descriptor = fs8.openSync(recoveryPath, "wx", 384);
+    descriptor = fs9.openSync(recoveryPath, "wx", 384);
   } catch (error62) {
     if (error62.code === "EEXIST") return null;
     throw error62;
@@ -1037,7 +1037,7 @@ function acquireRecoveryMarker(recoveryPath) {
 `
     );
   } finally {
-    fs8.closeSync(descriptor);
+    fs9.closeSync(descriptor);
   }
   const isOwned = () => pathMatchesClaim(
     recoveryPath,
@@ -1081,15 +1081,15 @@ function recoverStaleRefreshLock(lockPath) {
     }
     if (!reclaimable) return;
     if (!recovery.isOwned()) return;
-    const abandonedPath = `${lockPath}.stale.${randomUUID3()}`;
+    const abandonedPath = `${lockPath}.stale.${randomUUID4()}`;
     try {
-      fs8.renameSync(lockPath, abandonedPath);
+      fs9.renameSync(lockPath, abandonedPath);
       const moved = snapshotLeaseFile(abandonedPath);
       if (!moved || !snapshotsMatch(observed, moved)) {
         restoreMovedLease(abandonedPath, lockPath);
         return;
       }
-      fs8.rmSync(abandonedPath, {
+      fs9.rmSync(abandonedPath, {
         recursive: moved.stat.isDirectory(),
         force: true
       });
@@ -1116,7 +1116,7 @@ async function acquireRefreshLock(envName, signal) {
     if (signal?.aborted) {
       throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
     }
-    if (fs8.existsSync(recoveryPath)) {
+    if (fs9.existsSync(recoveryPath)) {
       try {
         recoverAbandonedRecoveryMarker(recoveryPath);
       } catch (recoveryError) {
@@ -1130,7 +1130,7 @@ async function acquireRefreshLock(envName, signal) {
     }
     let descriptor;
     try {
-      descriptor = fs8.openSync(lockPath, "wx", 384);
+      descriptor = fs9.openSync(lockPath, "wx", 384);
     } catch (error62) {
       if (error62.code !== "EEXIST") {
         console.error(
@@ -1149,7 +1149,7 @@ async function acquireRefreshLock(envName, signal) {
       await sleep(OAUTH_REFRESH_LOCK_POLL_MS, signal);
       continue;
     }
-    const ownerId = randomUUID3();
+    const ownerId = randomUUID4();
     const owner = {
       version: 1,
       ownerId,
@@ -1166,13 +1166,13 @@ async function acquireRefreshLock(envName, signal) {
 `
       );
     } catch (error62) {
-      fs8.closeSync(descriptor);
+      fs9.closeSync(descriptor);
       console.error(
         `[fml] Auth: unable to initialize refresh lock: ${error62 instanceof Error ? error62.message : String(error62)}`
       );
       return null;
     }
-    fs8.closeSync(descriptor);
+    fs9.closeSync(descriptor);
     const isOwned = () => pathMatchesClaim(lockPath, claimedStat, ownerId, parseRefreshLockOwner);
     const releaseClaim = () => releaseOwnedLease(
       lockPath,
@@ -1187,7 +1187,7 @@ async function acquireRefreshLock(envName, signal) {
     }
     let entryBlocked;
     try {
-      entryBlocked = fs8.existsSync(recoveryPath) || !isOwned();
+      entryBlocked = fs9.existsSync(recoveryPath) || !isOwned();
     } catch (error62) {
       console.error(
         `[fml] Auth: unable to verify refresh lock ownership: ${describeError(error62)}`
@@ -1600,7 +1600,7 @@ var init_token_store = __esm({
     PROCESS_IDENTITY_KEY = /* @__PURE__ */ Symbol.for("@fml-inc/fml:auth-process-identity");
     processGlobals = globalThis;
     existingProcessInstanceId = processGlobals[PROCESS_INSTANCE_KEY];
-    CURRENT_PROCESS_INSTANCE_ID = typeof existingProcessInstanceId === "string" ? existingProcessInstanceId : randomUUID3();
+    CURRENT_PROCESS_INSTANCE_ID = typeof existingProcessInstanceId === "string" ? existingProcessInstanceId : randomUUID4();
     processGlobals[PROCESS_INSTANCE_KEY] = CURRENT_PROCESS_INSTANCE_ID;
     CorruptStoredCredentialsError = class extends Error {
     };
@@ -1612,16 +1612,508 @@ var init_token_store = __esm({
   }
 });
 
+// ../../packages/agent-targets/src/git-state.ts
+import { execFile, execFileSync } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+// ../../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 url2;
+  try {
+    url2 = new URL(trimmed);
+  } catch {
+    return null;
+  }
+  if (url2.hostname.toLowerCase() !== "github.com") return null;
+  if (url2.search || url2.hash || url2.password || url2.port) return null;
+  if (url2.protocol === "https:" || url2.protocol === "http:") {
+    if (url2.username) return null;
+  } else if (url2.protocol === "ssh:") {
+    if (url2.username && url2.username !== "git") return null;
+  } else {
+    return null;
+  }
+  return githubRepositoryPath(url2.pathname);
+}
+
+// ../../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: version2,
+    observedAtMs,
+    repository,
+    worktreeRoot,
+    gitDir,
+    commonDir,
+    headRef,
+    branch,
+    commitHash,
+    detached,
+    unborn,
+    isLinkedWorktree
+  } = value;
+  if (version2 !== 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: version2,
+    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";
+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 (error62) {
+    if (command.allowedExit !== void 0 && error62 && typeof error62 === "object" && "status" in error62 && error62.status === command.allowedExit) {
+      return command.keepOutputOnAllowedExit && "stdout" in error62 && typeof error62.stdout === "string" ? error62.stdout.trim() || null : null;
+    }
+    throw error62;
+  }
+}
+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
+      },
+      (error62, stdout) => {
+        if (signal?.aborted)
+          reject(signal.reason ?? new Error("Git lookup aborted"));
+        else if (error62 && error62.code !== command.allowedExit) reject(error62);
+        else
+          resolve(
+            error62 && !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 file2 = readRegularFile(options.cacheFile, 8 * 1024 * 1024).toString(
+        "utf8"
+      );
+      const parsed = JSON.parse(file2);
+      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 cached2 = (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 = cached2(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 = cached2(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 (error62) {
+    const code = error62 && typeof error62 === "object" && "code" in error62 ? error62.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 (error62) {
+    const code = error62 && typeof error62 === "object" && "code" in error62 ? error62.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 } : {}
+  };
+}
+
 // src/pi/extension.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
-import fs9 from "node:fs";
+import { randomUUID as randomUUID5 } from "node:crypto";
+import fs10 from "node:fs";
 import os2 from "node:os";
-import path20 from "node:path";
+import path22 from "node:path";
 
 // ../../packages/agent-targets/src/pi-agent-dir.ts
-import path from "node:path";
+import path2 from "node:path";
 function resolvePiAgentDir(context) {
-  const pathApi = (context.platform ?? process.platform) === "win32" ? path.win32 : path.posix;
+  const pathApi = (context.platform ?? process.platform) === "win32" ? path2.win32 : path2.posix;
   const configured = context.env.PI_CODING_AGENT_DIR?.trim();
   if (!configured) {
     return pathApi.join(context.homeDir, ".pi", "agent");
@@ -1634,23 +2126,23 @@ function resolvePiAgentDir(context) {
 }
 
 // ../../packages/agent-targets/src/artifacts/targets/claude.ts
-import path4 from "node:path";
+import path5 from "node:path";
 
 // ../../packages/agent-targets/src/config-paths.ts
-import path2 from "node:path";
+import path3 from "node:path";
 function claudeConfigDirectory(context) {
   const configuredDir = context.claudeConfigDir ?? context.env?.CLAUDE_CONFIG_DIR;
-  return typeof configuredDir === "string" && configuredDir.trim().length > 0 ? path2.resolve(configuredDir) : path2.join(context.homeDir, ".claude");
+  return typeof configuredDir === "string" && configuredDir.trim().length > 0 ? path3.resolve(configuredDir) : path3.join(context.homeDir, ".claude");
 }
 function geminiConfigDirectory(context) {
   const configuredHome = context.env.GEMINI_CLI_HOME;
-  const homeRoot = typeof configuredHome === "string" && configuredHome.trim().length > 0 ? path2.resolve(configuredHome) : context.homeDir;
-  return path2.join(homeRoot, ".gemini");
+  const homeRoot = typeof configuredHome === "string" && configuredHome.trim().length > 0 ? path3.resolve(configuredHome) : context.homeDir;
+  return path3.join(homeRoot, ".gemini");
 }
 
 // ../../packages/agent-targets/src/artifacts/filesystem.ts
-import fs from "node:fs";
-import path3 from "node:path";
+import fs2 from "node:fs";
+import path4 from "node:path";
 var DEFAULT_SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -1667,11 +2159,11 @@ var DEFAULT_SKIP_DIRS = /* @__PURE__ */ new Set([
   "designqc-captures"
 ]);
 function normalizeFilePath(filePath) {
-  return path3.resolve(filePath);
+  return path4.resolve(filePath);
 }
 function safeReaddir(dir) {
   try {
-    return fs.readdirSync(dir, { withFileTypes: true });
+    return fs2.readdirSync(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -1684,7 +2176,7 @@ function walkFiles(input2) {
   function walk(dir, depth) {
     if (depth > input2.maxDepth) return;
     for (const entry of safeReaddir(dir)) {
-      const entryPath = path3.join(dir, entry.name);
+      const entryPath = path4.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (!skipDirs.has(entry.name)) walk(entryPath, depth + 1);
         continue;
@@ -1720,7 +2212,7 @@ function transcriptCandidate(input2) {
 }
 
 // ../../packages/agent-targets/src/artifacts/harness-install-id.ts
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 var MAX_HARNESS_INSTALL_ID_LENGTH = 128;
 function normalizeHarnessInstallId(value) {
   if (typeof value !== "string") return null;
@@ -1731,7 +2223,7 @@ function normalizeHarnessInstallId(value) {
 }
 function readHarnessInstallIdFile(filePath) {
   try {
-    return normalizeHarnessInstallId(fs2.readFileSync(filePath, "utf8"));
+    return normalizeHarnessInstallId(fs3.readFileSync(filePath, "utf8"));
   } catch {
     return null;
   }
@@ -1740,7 +2232,7 @@ var claudeMachineIdCache = /* @__PURE__ */ new Map();
 function readClaudeMachineId(configFile) {
   let stat;
   try {
-    stat = fs2.statSync(configFile);
+    stat = fs3.statSync(configFile);
   } catch {
     claudeMachineIdCache.delete(configFile);
     return null;
@@ -1751,7 +2243,7 @@ function readClaudeMachineId(configFile) {
   }
   let machineId = null;
   try {
-    const parsed = JSON.parse(fs2.readFileSync(configFile, "utf8"));
+    const parsed = JSON.parse(fs3.readFileSync(configFile, "utf8"));
     if (parsed && typeof parsed === "object") {
       machineId = normalizeHarnessInstallId(
         parsed.machineID
@@ -1769,55 +2261,8 @@ function readClaudeMachineId(configFile) {
 }
 
 // ../../packages/agent-targets/src/artifacts/repository-context.ts
-import { createHash } from "node:crypto";
-import fs3 from "node:fs";
-
-// ../../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 url2;
-  try {
-    url2 = new URL(trimmed);
-  } catch {
-    return null;
-  }
-  if (url2.hostname.toLowerCase() !== "github.com") return null;
-  if (url2.search || url2.hash || url2.password || url2.port) return null;
-  if (url2.protocol === "https:" || url2.protocol === "http:") {
-    if (url2.username) return null;
-  } else if (url2.protocol === "ssh:") {
-    if (url2.username && url2.username !== "git") return null;
-  } else {
-    return null;
-  }
-  return githubRepositoryPath(url2.pathname);
-}
-
-// ../../packages/agent-targets/src/artifacts/repository-context.ts
+import { createHash as createHash2 } from "node:crypto";
+import fs4 from "node:fs";
 var MAX_ARTIFACT_CONTEXT_PREFIX_BYTES = 256 * 1024;
 var MAX_ARTIFACT_CONTEXT_RECORDS = 64;
 var ARTIFACT_CONTEXT_READ_CHUNK_BYTES = 32 * 1024;
@@ -1840,12 +2285,12 @@ function recordValue(value) {
 function readJsonlContextRecords(sourcePath) {
   let file2;
   try {
-    file2 = fs3.openSync(sourcePath, "r");
+    file2 = fs4.openSync(sourcePath, "r");
   } catch {
     return [];
   }
   try {
-    const stat = fs3.fstatSync(file2);
+    const stat = fs4.fstatSync(file2);
     const byteLimit = Math.min(stat.size, MAX_ARTIFACT_CONTEXT_PREFIX_BYTES);
     if (byteLimit <= 0) return [];
     const records = [];
@@ -1863,7 +2308,7 @@ function readJsonlContextRecords(sourcePath) {
     const chunk = Buffer.allocUnsafe(ARTIFACT_CONTEXT_READ_CHUNK_BYTES);
     while (position < byteLimit && records.length < MAX_ARTIFACT_CONTEXT_RECORDS) {
       const want = Math.min(chunk.length, byteLimit - position);
-      const bytesRead = fs3.readSync(file2, chunk, 0, want, position);
+      const bytesRead = fs4.readSync(file2, chunk, 0, want, position);
       if (bytesRead <= 0) break;
       position += bytesRead;
       const buffered = Buffer.concat([carry, chunk.subarray(0, bytesRead)]);
@@ -1886,7 +2331,7 @@ function readJsonlContextRecords(sourcePath) {
   } catch {
     return [];
   } finally {
-    fs3.closeSync(file2);
+    fs4.closeSync(file2);
   }
 }
 function contextTimestampMs(value, fallback) {
@@ -1914,7 +2359,7 @@ function repositoryObservation(input2) {
     branch ?? null,
     commitHash ?? null
   ]);
-  const id = `repo_observation:${createHash("sha256").update(identity).digest("hex")}`;
+  const id = `repo_observation:${createHash2("sha256").update(identity).digest("hex")}`;
   return {
     id,
     repository: input2.repository,
@@ -1925,14 +2370,29 @@ function repositoryObservation(input2) {
     ...commitHash ? { commitHash } : {}
   };
 }
+function localGitStateMetadata(states, source = "transcript_discovery") {
+  const bounded = [];
+  for (const state of states) {
+    if (!state || Buffer.byteLength(
+      JSON.stringify({ version: 1, source, states: [...bounded, state] }),
+      "utf8"
+    ) > 4 * 1024)
+      continue;
+    bounded.push(state);
+  }
+  return bounded.length ? { localGitStates: { version: 1, source, states: bounded } } : {};
+}
 
 // ../../packages/agent-targets/src/artifacts/targets/claude.ts
 function claudeTranscriptCandidate(sourcePath, context, harnessInstallId) {
   const fallbackObservedAtMs = (context.nowMs ?? Date.now)();
+  const states = /* @__PURE__ */ new Map();
   const observations = /* @__PURE__ */ new Map();
   for (const record2 of readJsonlContextRecords(sourcePath)) {
     if (typeof record2.cwd !== "string" || !record2.cwd.trim()) continue;
     const origin = context.resolveGitHubOrigin?.(record2.cwd);
+    const state = origin?.gitState ?? context.resolveGitState?.(record2.cwd);
+    if (state) states.set(state.worktreeRoot, state);
     if (!origin) continue;
     const observation = repositoryObservation({
       repository: origin.repository,
@@ -1947,7 +2407,10 @@ function claudeTranscriptCandidate(sourcePath, context, harnessInstallId) {
   return transcriptCandidate({
     targetId: "claude",
     sourcePath,
-    metadata: harnessInstallId ? { harnessInstallId } : void 0,
+    metadata: {
+      ...harnessInstallId ? { harnessInstallId } : {},
+      ...localGitStateMetadata([...states.values()])
+    },
     repositoryObservations: [...observations.values()]
   });
 }
@@ -1956,9 +2419,9 @@ var claudeArtifactDiscovery = Object.freeze({
   discover: (context) => {
     const { homeDir, env } = context;
     const configDir = claudeConfigDirectory({ homeDir, env });
-    const harnessInstallId = readClaudeMachineId(path4.join(configDir, ".claude.json")) ?? readClaudeMachineId(path4.join(homeDir, ".claude.json"));
+    const harnessInstallId = readClaudeMachineId(path5.join(configDir, ".claude.json")) ?? readClaudeMachineId(path5.join(homeDir, ".claude.json"));
     return walkFiles({
-      root: path4.join(configDir, "projects"),
+      root: path5.join(configDir, "projects"),
       maxDepth: 6,
       includeFile: (filePath) => filePath.endsWith(".jsonl")
     }).map(
@@ -1968,10 +2431,10 @@ var claudeArtifactDiscovery = Object.freeze({
 });
 
 // ../../packages/agent-targets/src/artifacts/targets/codex.ts
-import path5 from "node:path";
+import path6 from "node:path";
 var CODEX_ROLLOUT_ID = /-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl(?:\.zst)?$/i;
 function codexRolloutId(sourcePath) {
-  return CODEX_ROLLOUT_ID.exec(path5.basename(sourcePath))?.[1]?.toLowerCase() ?? null;
+  return CODEX_ROLLOUT_ID.exec(path6.basename(sourcePath))?.[1]?.toLowerCase() ?? null;
 }
 function codexTranscriptCandidate(sourcePath, readPath, store, context, harnessInstallId) {
   const rolloutId = codexRolloutId(sourcePath);
@@ -1984,9 +2447,10 @@ function codexTranscriptCandidate(sourcePath, readPath, store, context, harnessI
     if (!payload) continue;
     const sessionId = typeof payload.id === "string" && payload.id.trim() ? payload.id.trim() : null;
     const cwd = typeof payload.cwd === "string" ? payload.cwd : void 0;
-    const git2 = recordValue(payload.git);
-    const nativeRepository = typeof git2?.repository_url === "string" ? canonicalGitHubRepository(git2.repository_url) : null;
+    const git = recordValue(payload.git);
+    const nativeRepository = typeof git?.repository_url === "string" ? canonicalGitHubRepository(git.repository_url) : null;
     const origin = cwd ? context.resolveGitHubOrigin?.(cwd) : null;
+    const state = origin?.gitState ?? (cwd ? context.resolveGitState?.(cwd) : null);
     const observations = [];
     if (nativeRepository) {
       observations.push(
@@ -1998,8 +2462,8 @@ function codexTranscriptCandidate(sourcePath, readPath, store, context, harnessI
             fallbackObservedAtMs
           ),
           cwd,
-          branch: git2?.branch,
-          commitHash: git2?.commit_hash
+          branch: git?.branch,
+          commitHash: git?.commit_hash
         })
       );
     }
@@ -2021,7 +2485,11 @@ function codexTranscriptCandidate(sourcePath, readPath, store, context, harnessI
       identityKey,
       readPath,
       sessionId,
-      metadata: { store, ...identityMetadata },
+      metadata: {
+        store,
+        ...identityMetadata,
+        ...localGitStateMetadata([state])
+      },
       repositoryObservations: observations
     });
   }
@@ -2041,15 +2509,15 @@ var codexArtifactDiscovery = Object.freeze({
   discover: (context) => {
     const { homeDir, env } = context;
     const configuredHome = env.CODEX_HOME?.trim();
-    const codexHome = configuredHome ? path5.resolve(configuredHome) : path5.join(homeDir, ".codex");
+    const codexHome = configuredHome ? path6.resolve(configuredHome) : path6.join(homeDir, ".codex");
     const harnessInstallId = readHarnessInstallIdFile(
-      path5.join(codexHome, "installation_id")
+      path6.join(codexHome, "installation_id")
     );
     const roots = [
-      { store: "sessions", root: path5.join(codexHome, "sessions") },
+      { store: "sessions", root: path6.join(codexHome, "sessions") },
       {
         store: "archived_sessions",
-        root: path5.join(codexHome, "archived_sessions")
+        root: path6.join(codexHome, "archived_sessions")
       }
     ];
     const files = roots.flatMap(
@@ -2087,27 +2555,27 @@ var codexArtifactDiscovery = Object.freeze({
 });
 
 // ../../packages/agent-targets/src/artifacts/targets/copilot-cli.ts
-import path6 from "node:path";
+import path7 from "node:path";
 var copilotCliArtifactDiscovery = Object.freeze({
   targetId: "copilot-cli",
   discover: ({ homeDir }) => walkFiles({
-    root: path6.join(homeDir, ".copilot", "session-state"),
+    root: path7.join(homeDir, ".copilot", "session-state"),
     maxDepth: 3,
-    includeFile: (filePath) => path6.basename(filePath) === "events.jsonl"
+    includeFile: (filePath) => path7.basename(filePath) === "events.jsonl"
   }).map(
     (sourcePath) => transcriptCandidate({ targetId: "copilot-cli", sourcePath })
   )
 });
 
 // ../../packages/agent-targets/src/artifacts/targets/cursor.ts
-import path7 from "node:path";
+import path8 from "node:path";
 function hasPathSegment(filePath, segment) {
-  return normalizeFilePath(filePath).split(path7.sep).includes(segment);
+  return normalizeFilePath(filePath).split(path8.sep).includes(segment);
 }
 var cursorArtifactDiscovery = Object.freeze({
   targetId: "cursor",
   discover: ({ homeDir }) => walkFiles({
-    root: path7.join(homeDir, ".cursor", "projects"),
+    root: path8.join(homeDir, ".cursor", "projects"),
     maxDepth: 5,
     includeFile: (filePath) => filePath.endsWith(".jsonl") && hasPathSegment(filePath, "agent-transcripts")
   }).map(
@@ -2116,11 +2584,11 @@ var cursorArtifactDiscovery = Object.freeze({
 });
 
 // ../../packages/agent-targets/src/artifacts/targets/factory-droid.ts
-import path8 from "node:path";
+import path9 from "node:path";
 var factoryDroidArtifactDiscovery = Object.freeze({
   targetId: "factory-droid",
   discover: ({ homeDir }) => walkFiles({
-    root: path8.join(homeDir, ".factory", "sessions"),
+    root: path9.join(homeDir, ".factory", "sessions"),
     maxDepth: 4,
     includeFile: (filePath) => filePath.endsWith(".jsonl")
   }).map(
@@ -2129,7 +2597,7 @@ var factoryDroidArtifactDiscovery = Object.freeze({
 });
 
 // ../../packages/agent-targets/src/artifacts/targets/gemini.ts
-import path9 from "node:path";
+import path10 from "node:path";
 var GEMINI_DISCOVER_SKIP_DIRS = /* @__PURE__ */ new Set([
   "bin",
   "checkpoints",
@@ -2144,15 +2612,15 @@ var geminiArtifactDiscovery = Object.freeze({
   discover: ({ homeDir, env }) => {
     const geminiDir = geminiConfigDirectory({ homeDir, env });
     const harnessInstallId = readHarnessInstallIdFile(
-      path9.join(geminiDir, "installation_id")
+      path10.join(geminiDir, "installation_id")
     );
-    const root = path9.join(geminiDir, "tmp");
+    const root = path10.join(geminiDir, "tmp");
     const files = [];
     const seen = /* @__PURE__ */ new Set();
     function walk(dir, depth) {
       if (depth > 4) return;
       for (const entry of safeReaddir(dir)) {
-        const entryPath = path9.join(dir, entry.name);
+        const entryPath = path10.join(dir, entry.name);
         if (!entry.isDirectory()) continue;
         if (GEMINI_DISCOVER_SKIP_DIRS.has(entry.name)) continue;
         if (entry.name === "chats") {
@@ -2161,7 +2629,7 @@ var geminiArtifactDiscovery = Object.freeze({
               continue;
             }
             const sourcePath = normalizeFilePath(
-              path9.join(entryPath, chatEntry.name)
+              path10.join(entryPath, chatEntry.name)
             );
             if (seen.has(sourcePath)) continue;
             seen.add(sourcePath);
@@ -2184,52 +2652,52 @@ var geminiArtifactDiscovery = Object.freeze({
 });
 
 // ../../packages/agent-targets/src/artifacts/targets/grok.ts
-import path10 from "node:path";
+import path11 from "node:path";
 function grokHome(homeDir, env) {
   const configuredHome = env.GROK_HOME?.trim();
-  return configuredHome ? path10.resolve(configuredHome) : path10.join(homeDir, ".grok");
+  return configuredHome ? path11.resolve(configuredHome) : path11.join(homeDir, ".grok");
 }
 var grokArtifactDiscovery = Object.freeze({
   targetId: "grok",
   discover: ({ homeDir, env }) => walkFiles({
-    root: path10.join(grokHome(homeDir, env), "sessions"),
+    root: path11.join(grokHome(homeDir, env), "sessions"),
     maxDepth: 5,
-    includeFile: (filePath) => path10.basename(filePath) === "updates.jsonl"
+    includeFile: (filePath) => path11.basename(filePath) === "updates.jsonl"
   }).map(
     (sourcePath) => transcriptCandidate({ targetId: "grok", sourcePath })
   )
 });
 
 // ../../packages/agent-targets/src/artifacts/targets/mini-swe-agent.ts
-import fs4 from "node:fs";
-import path11 from "node:path";
+import fs5 from "node:fs";
+import path12 from "node:path";
 var SESSION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function dataDirectory({ homeDir, env }) {
   if (env.FML_DATA_DIR?.trim()) {
-    if (!path11.isAbsolute(env.FML_DATA_DIR)) {
+    if (!path12.isAbsolute(env.FML_DATA_DIR)) {
       throw new Error("FML_DATA_DIR must be an absolute path");
     }
-    return path11.normalize(env.FML_DATA_DIR);
+    return path12.normalize(env.FML_DATA_DIR);
   }
   if (process.platform === "darwin") {
-    return path11.join(homeDir, "Library", "Application Support", "fml");
+    return path12.join(homeDir, "Library", "Application Support", "fml");
   }
   if (process.platform === "win32") {
-    const roaming = env.APPDATA && path11.isAbsolute(env.APPDATA) ? env.APPDATA : path11.join(homeDir, "AppData", "Roaming");
-    return path11.join(roaming, "fml");
+    const roaming = env.APPDATA && path12.isAbsolute(env.APPDATA) ? env.APPDATA : path12.join(homeDir, "AppData", "Roaming");
+    return path12.join(roaming, "fml");
   }
-  const xdgDataHome = env.XDG_DATA_HOME && path11.isAbsolute(env.XDG_DATA_HOME) ? env.XDG_DATA_HOME : path11.join(homeDir, ".local", "share");
-  return path11.join(xdgDataHome, "fml");
+  const xdgDataHome = env.XDG_DATA_HOME && path12.isAbsolute(env.XDG_DATA_HOME) ? env.XDG_DATA_HOME : path12.join(homeDir, ".local", "share");
+  return path12.join(xdgDataHome, "fml");
 }
 function snapshotCandidate(sourcePath, context) {
   let file2;
   try {
-    file2 = fs4.openSync(sourcePath, "r");
+    file2 = fs5.openSync(sourcePath, "r");
   } catch {
     return null;
   }
   try {
-    const stat = fs4.fstatSync(file2);
+    const stat = fs5.fstatSync(file2);
     if (!stat.isFile()) return null;
     if (context.maxFileBytes !== void 0 && stat.size > context.maxFileBytes) {
       return transcriptCandidate({ targetId: "mini-swe-agent", sourcePath });
@@ -2237,7 +2705,7 @@ function snapshotCandidate(sourcePath, context) {
     const bytes = Buffer.allocUnsafe(stat.size);
     let offset = 0;
     while (offset < bytes.length) {
-      const read = fs4.readSync(
+      const read = fs5.readSync(
         file2,
         bytes,
         offset,
@@ -2247,7 +2715,7 @@ function snapshotCandidate(sourcePath, context) {
       if (read <= 0) return null;
       offset += read;
     }
-    if (fs4.fstatSync(file2).size !== stat.size) return null;
+    if (fs5.fstatSync(file2).size !== stat.size) return null;
     const value = JSON.parse(bytes.toString("utf8"));
     if (typeof value !== "object" || value === null || !("fml" in value)) {
       return null;
@@ -2277,13 +2745,13 @@ function snapshotCandidate(sourcePath, context) {
   } catch {
     return null;
   } finally {
-    fs4.closeSync(file2);
+    fs5.closeSync(file2);
   }
 }
 var miniSweAgentArtifactDiscovery = Object.freeze({
   targetId: "mini-swe-agent",
   discover: (context) => walkFiles({
-    root: path11.join(dataDirectory(context), "mini-swe-agent", "trajectories"),
+    root: path12.join(dataDirectory(context), "mini-swe-agent", "trajectories"),
     maxDepth: 0,
     includeFile: (filePath) => filePath.endsWith(".traj.json")
   }).flatMap((sourcePath) => {
@@ -2293,7 +2761,7 @@ var miniSweAgentArtifactDiscovery = Object.freeze({
 });
 
 // ../../packages/agent-targets/src/artifacts/targets/pi.ts
-import path12 from "node:path";
+import path13 from "node:path";
 
 // ../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -3112,10 +3580,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path21) {
-  if (!path21)
+function getElementAtPath(obj, path23) {
+  if (!path23)
     return obj;
-  return path21.reduce((acc, key) => acc?.[key], obj);
+  return path23.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -3455,11 +3923,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path21, issues) {
+function prefixIssues(path23, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path21);
+    iss.path.unshift(path23);
     return iss;
   });
 }
@@ -3921,16 +4389,16 @@ function flattenError(error62, mapper = (issue2) => issue2.message) {
 }
 function formatError(error62, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error63, path21 = []) => {
+  const processError = (error63, path23 = []) => {
     for (const issue2 of error63.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path21, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path23, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path21, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path23, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path21, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path23, ...issue2.path]);
       } else {
-        const fullpath = [...path21, ...issue2.path];
+        const fullpath = [...path23, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -3969,17 +4437,17 @@ function formatError(error62, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error62, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error63, path21 = []) => {
+  const processError = (error63, path23 = []) => {
     var _a3;
     for (const issue2 of error63.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path21, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path23, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path21, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path23, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path21, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path23, ...issue2.path]);
       } else {
-        const fullpath = [...path21, ...issue2.path];
+        const fullpath = [...path23, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -4018,8 +4486,8 @@ function treeifyError(error62, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path21 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path21) {
+  const path23 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path23) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -21157,13 +21625,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path21 = ref.slice(1).split("/").filter(Boolean);
-  if (path21.length === 0) {
+  const path23 = ref.slice(1).split("/").filter(Boolean);
+  if (path23.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path21[0] === defsKey) {
-    const key = path21[1] === void 0 ? void 0 : decodeJSONPointerSegment(path21[1]);
+  if (path23[0] === defsKey) {
+    const key = path23[1] === void 0 ? void 0 : decodeJSONPointerSegment(path23[1]);
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -22017,6 +22485,12 @@ var PI_REPOSITORY_ORIGIN_ENTRY_TYPE = "fml-repository-origin";
 var RepositorySlugSchema = external_exports.string().regex(/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/u).transform((slug) => canonicalGitHubRepository(`https://github.com/${slug}`)).pipe(external_exports.string());
 var PiRepositoryOriginDataSchema = external_exports.object({
   version: external_exports.literal(1),
+  gitState: external_exports.unknown().transform((value, ctx) => {
+    const state = parseGitState(value);
+    if (state) return state;
+    ctx.addIssue({ code: "custom", message: "Invalid Git state snapshot" });
+    return external_exports.NEVER;
+  }).nullable().optional(),
   repository: RepositorySlugSchema.nullable(),
   cwd: external_exports.string().min(1).refine(
     (cwd) => cwd.trim().length > 0 && !new RegExp("\\p{Cc}", "u").test(cwd) && Buffer.byteLength(cwd, "utf8") <= 4096
@@ -22058,12 +22532,15 @@ function piTranscriptCandidate(sourcePath) {
     targetId: "pi",
     sourcePath,
     sessionId,
+    metadata: localGitStateMetadata([snapshot?.gitState], "pi_origin"),
     repositoryObservations: snapshot?.repository ? [
       repositoryObservation({
         repository: snapshot.repository,
         source: "git_origin",
         observedAtMs: snapshot.observedAtMs,
-        cwd: snapshot.cwd
+        cwd: snapshot.cwd,
+        branch: snapshot.gitState?.branch,
+        commitHash: snapshot.gitState?.commitHash
       })
     ] : []
   });
@@ -22072,7 +22549,7 @@ var piArtifactDiscovery = Object.freeze({
   targetId: "pi",
   discover: (context) => {
     return walkFiles({
-      root: path12.join(resolvePiAgentDir(context), "sessions"),
+      root: path13.join(resolvePiAgentDir(context), "sessions"),
       maxDepth: 8,
       includeFile: (filePath) => filePath.endsWith(".jsonl"),
       skipDirs: PI_SKIP_DIRS
@@ -22098,9 +22575,9 @@ var MAX_MATERIALIZED_ARTIFACT_BYTES = 100 * 1024 * 1024;
 var DEFAULT_MATERIALIZED_CACHE_BYTES = 2 * 1024 * 1024 * 1024;
 
 // ../../packages/agent-targets/src/install/pi/index.ts
-import fs5 from "node:fs";
-import path13 from "node:path";
-import { randomUUID } from "node:crypto";
+import fs6 from "node:fs";
+import path14 from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
 var FML_PI_EXTENSION_MARKER = "__FML_PI_EXTENSION_V1__";
 var LEGACY_PI_EXTENSION_MARKER = "__panopticonPiExtensionTest";
 var LEGACY_PI_EXTENSION_SIGNATURES = Object.freeze([
@@ -22112,11 +22589,11 @@ var LEGACY_PI_EXTENSION_SIGNATURES = Object.freeze([
   "SessionEnd"
 ]);
 function pathApiFor(platform) {
-  return platform === "win32" ? path13.win32 : path13.posix;
+  return platform === "win32" ? path14.win32 : path14.posix;
 }
 function readFileIfPresent(filePath) {
   try {
-    return fs5.readFileSync(filePath, "utf8");
+    return fs6.readFileSync(filePath, "utf8");
   } catch (error62) {
     if (error62.code === "ENOENT") return null;
     throw error62;
@@ -22133,23 +22610,23 @@ function removeLegacyExtension(filePath) {
   if (!isOwnedExtension(source, true)) {
     return { removed: false, preserved: true };
   }
-  fs5.rmSync(filePath);
+  fs6.rmSync(filePath);
   return { removed: true, preserved: false };
 }
 function writeExtensionAtomically(filePath, source) {
-  fs5.mkdirSync(path13.dirname(filePath), { recursive: true, mode: 448 });
-  const temporaryPath = path13.join(
-    path13.dirname(filePath),
-    `.${path13.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`
+  fs6.mkdirSync(path14.dirname(filePath), { recursive: true, mode: 448 });
+  const temporaryPath = path14.join(
+    path14.dirname(filePath),
+    `.${path14.basename(filePath)}.${process.pid}.${randomUUID2()}.tmp`
   );
   try {
-    fs5.writeFileSync(temporaryPath, source, { encoding: "utf8", mode: 384 });
-    if (process.platform === "win32" && fs5.existsSync(filePath)) {
-      fs5.rmSync(filePath);
+    fs6.writeFileSync(temporaryPath, source, { encoding: "utf8", mode: 384 });
+    if (process.platform === "win32" && fs6.existsSync(filePath)) {
+      fs6.rmSync(filePath);
     }
-    fs5.renameSync(temporaryPath, filePath);
+    fs6.renameSync(temporaryPath, filePath);
   } finally {
-    fs5.rmSync(temporaryPath, { force: true });
+    fs6.rmSync(temporaryPath, { force: true });
   }
 }
 var PI_EXTENSION_INSTALLER = Object.freeze({
@@ -22172,7 +22649,7 @@ var PI_EXTENSION_INSTALLER = Object.freeze({
     };
   },
   install(paths) {
-    const source = fs5.readFileSync(paths.sourcePath, "utf8");
+    const source = fs6.readFileSync(paths.sourcePath, "utf8");
     if (!source.includes(FML_PI_EXTENSION_MARKER)) {
       throw new Error(
         `Packaged Pi extension is invalid: ${paths.sourcePath} does not contain the FML ownership marker`
@@ -22221,7 +22698,7 @@ var PI_EXTENSION_INSTALLER = Object.freeze({
         legacyPreserved: legacy.preserved
       };
     }
-    fs5.rmSync(paths.destinationPath);
+    fs6.rmSync(paths.destinationPath);
     return {
       status: "removed",
       destinationPath: paths.destinationPath,
@@ -22232,11 +22709,11 @@ var PI_EXTENSION_INSTALLER = Object.freeze({
 });
 
 // src/hooks/context.ts
-import { createHash as createHash5 } from "node:crypto";
-import path19 from "node:path";
+import { createHash as createHash6 } from "node:crypto";
+import path21 from "node:path";
 
 // ../../packages/agent-targets/src/hooks/normalize.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 
 // ../../packages/agent-targets/src/hooks/types.ts
 var HOOK_TARGETS = Object.freeze([
@@ -22352,7 +22829,7 @@ var MINI_SWE_AGENT_HOOK_EVENTS = Object.freeze([
 ]);
 
 // ../../packages/agent-targets/src/hooks/read-command.ts
-import path14 from "node:path";
+import path15 from "node:path";
 var SHELL_TOOL_NAMES = /* @__PURE__ */ new Set([
   "bash",
   "exec_command",
@@ -22468,12 +22945,12 @@ function splitCommandSegments(tokens) {
   return segments;
 }
 function stripSimpleOptions(args, flagsWithValues = /* @__PURE__ */ new Set(), patternFlags = /* @__PURE__ */ new Set()) {
-  const remaining = [];
+  const remaining2 = [];
   let consumedPatternFlag = false;
   for (let index = 0; index < args.length; index += 1) {
     const argument = args[index];
     if (argument === "--") {
-      remaining.push(...args.slice(index + 1));
+      remaining2.push(...args.slice(index + 1));
       break;
     }
     if (argument.startsWith("-") && argument.length > 1) {
@@ -22483,9 +22960,9 @@ function stripSimpleOptions(args, flagsWithValues = /* @__PURE__ */ new Set(), p
       }
       continue;
     }
-    remaining.push(argument);
+    remaining2.push(argument);
   }
-  return { args: remaining, consumedPatternFlag };
+  return { args: remaining2, consumedPatternFlag };
 }
 function readCommandFileArgs(args, flagsWithValues, patternFlags = flagsWithValues) {
   const stripped = stripSimpleOptions(args, flagsWithValues, patternFlags);
@@ -22496,7 +22973,7 @@ function isPlausibleReadPath(argument) {
   if (COMMAND_SEPARATORS.has(argument)) return false;
   if (/[\0*?[{}`$]/.test(argument)) return false;
   if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(argument)) return false;
-  return path14.posix.isAbsolute(argument) || path14.win32.isAbsolute(argument) || argument.startsWith("~/") || argument.startsWith("./") || argument.startsWith("../") || argument.includes("/") || /\.[A-Za-z0-9][A-Za-z0-9_-]*$/.test(argument) || /^[A-Z][A-Za-z0-9_.-]*$/.test(argument);
+  return path15.posix.isAbsolute(argument) || path15.win32.isAbsolute(argument) || argument.startsWith("~/") || argument.startsWith("./") || argument.startsWith("../") || argument.includes("/") || /\.[A-Za-z0-9][A-Za-z0-9_-]*$/.test(argument) || /^[A-Z][A-Za-z0-9_.-]*$/.test(argument);
 }
 function filePathFromSegment(tokens) {
   const commandTokens = [...tokens];
@@ -22567,7 +23044,7 @@ function extractReadFilePathFromCommand(command) {
 
 // ../../packages/agent-targets/src/hooks/normalize.ts
 var MAX_EXTRACTED_TEXT_BYTES = 64 * 1024;
-function isRecord(value) {
+function isRecord3(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function firstString(record2, keys) {
@@ -22614,7 +23091,7 @@ function boundedExtractedText(value, field) {
   if (value === void 0) return void 0;
   const originalBytes = Buffer.byteLength(value, "utf8");
   if (originalBytes <= MAX_EXTRACTED_TEXT_BYTES) return value;
-  const digest = createHash2("sha256").update(value).digest("hex");
+  const digest = createHash3("sha256").update(value).digest("hex");
   const marker = `
 [fml:${field}:truncated originalBytes=${originalBytes} sha256=${digest}]`;
   return `${utf8Prefix(
@@ -22625,7 +23102,7 @@ function boundedExtractedText(value, field) {
 function nestedRecord(record2, keys) {
   for (const key of keys) {
     const value = record2[key];
-    if (isRecord(value)) return value;
+    if (isRecord3(value)) return value;
   }
   return void 0;
 }
@@ -22683,9 +23160,9 @@ function grokEventType(eventType) {
 }
 function geminiUserPrompt(payload) {
   const request = payload.llm_request;
-  if (!isRecord(request) || !Array.isArray(request.messages)) return void 0;
+  if (!isRecord3(request) || !Array.isArray(request.messages)) return void 0;
   const userMessage = [...request.messages].reverse().find(
-    (message) => isRecord(message) && message.role === "user"
+    (message) => isRecord3(message) && message.role === "user"
   );
   if (!userMessage) return void 0;
   if (typeof userMessage.content === "string") {
@@ -22693,7 +23170,7 @@ function geminiUserPrompt(payload) {
   }
   if (!Array.isArray(userMessage.content)) return void 0;
   const text = userMessage.content.filter(
-    (part) => isRecord(part) && part.type === "text" && typeof part.text === "string"
+    (part) => isRecord3(part) && part.type === "text" && typeof part.text === "string"
   ).map((part) => part.text).join("\n");
   return text || void 0;
 }
@@ -22792,51 +23269,15 @@ init_token_store();
 init_dirs();
 
 // src/repo.ts
-import { execFile, execFileSync as execFileSync2 } from "node:child_process";
-var REPO_CACHE = /* @__PURE__ */ new Map();
-var GIT_TIMEOUT_MS = 5e3;
-function cachedRepo(cwd) {
-  const entry = REPO_CACHE.get(cwd);
-  if (!entry) return { hit: false };
-  if (entry.expiresAtMs <= Date.now()) {
-    REPO_CACHE.delete(cwd);
-    return { hit: false };
-  }
-  REPO_CACHE.delete(cwd);
-  REPO_CACHE.set(cwd, entry);
-  return { hit: true, value: entry.value };
-}
-function git(cwd, args, timeoutMs) {
-  try {
-    return execFileSync2("git", ["-C", cwd, ...args], {
-      encoding: "utf8",
-      timeout: timeoutMs,
-      stdio: ["ignore", "pipe", "ignore"],
-      windowsHide: true
-    }).trim() || null;
-  } catch {
-    return null;
-  }
-}
-function repositorySlug(remote) {
-  const ssh = remote.match(/^[^@]+@[^:]+:([^/]+\/[^/]+?)(?:\.git)?$/);
-  if (ssh?.[1]) return ssh[1].toLowerCase();
-  try {
-    const url2 = new URL(remote);
-    const slug = url2.pathname.replace(/^\/+|\/+$/g, "").replace(/\.git$/, "");
-    return /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(slug) ? slug.toLowerCase() : null;
-  } catch {
-    return null;
-  }
-}
-function resolveRepositorySlugFromCwd(cwd, timeoutMs = GIT_TIMEOUT_MS) {
-  const cached2 = cachedRepo(cwd);
-  if (cached2.hit) return cached2.value?.repo ?? null;
-  const remote = git(cwd, ["remote", "get-url", "origin"], timeoutMs);
-  return remote ? repositorySlug(remote) : null;
+import path20 from "node:path";
+init_dirs();
+var CACHE_FILE = path20.join(FML_OBSERVER_DIR, GIT_STATE_CACHE_FILENAME);
+var resolver = createGitStateResolver({ cacheFile: CACHE_FILE });
+function resolveGitStateFromCwd(cwd, timeoutMs = 1e3) {
+  return resolver.resolve(cwd, { timeoutMs });
 }
-function resolveRepositoryRootFromCwd(cwd, timeoutMs = GIT_TIMEOUT_MS) {
-  return git(cwd, ["rev-parse", "--show-toplevel"], timeoutMs);
+function resolveRepositoryRootFromCwd(cwd, timeoutMs = 1e3) {
+  return resolveGitStateFromCwd(cwd, timeoutMs)?.worktreeRoot ?? null;
 }
 
 // src/hooks/sync-loop.ts
@@ -22921,14 +23362,14 @@ function sameDestination(left, right) {
   return left.environment === right.environment && left.targetUrl === right.targetUrl && left.destinationIdentity === right.destinationIdentity;
 }
 function hookContextInjectionId(target, syncId) {
-  const digest = createHash5("sha256").update(`${INJECTION_ID_VERSION}\0${target}\0${syncId}`).digest("base64url");
+  const digest = createHash6("sha256").update(`${INJECTION_ID_VERSION}\0${target}\0${syncId}`).digest("base64url");
   return `${INJECTION_ID_VERSION}_${digest}`;
 }
 function canonicalHookContextFilePath(filePath, cwd, repositoryRoot) {
   const windows = [filePath, cwd, repositoryRoot].some(
     (value) => value !== void 0 && value !== null && /^[A-Za-z]:[\\/]/.test(value)
   );
-  const pathApi = windows ? path19.win32 : path19.posix;
+  const pathApi = windows ? path21.win32 : path21.posix;
   const normalized = pathApi.normalize(filePath);
   const resolved = pathApi.isAbsolute(normalized) ? normalized : cwd && pathApi.isAbsolute(cwd) ? pathApi.resolve(cwd, normalized) : normalized;
   if (repositoryRoot && pathApi.isAbsolute(resolved)) {
@@ -23088,16 +23529,16 @@ function wrapReceiptDetail(label, detail) {
   const firstPrefix = `\u2502 ${label}: `;
   const continuationPrefix = "\u2502   ";
   const lines = [];
-  let remaining = detail;
+  let remaining2 = detail;
   let prefix = firstPrefix;
-  while (remaining) {
+  while (remaining2) {
     const available = RECEIPT_LINE_WIDTH - receiptDisplayWidth(prefix);
-    if (receiptDisplayWidth(remaining) <= available) {
-      lines.push(`${prefix}${remaining}`);
+    if (receiptDisplayWidth(remaining2) <= available) {
+      lines.push(`${prefix}${remaining2}`);
       break;
     }
-    const tokenEnd = remaining.search(/\s/u);
-    const token = tokenEnd === -1 ? remaining : remaining.slice(0, tokenEnd);
+    const tokenEnd = remaining2.search(/\s/u);
+    const token = tokenEnd === -1 ? remaining2 : remaining2.slice(0, tokenEnd);
     const inlineCodeToken = splitInlineCodeToken(token);
     const inlineCodeWidth = inlineCodeToken ? receiptDisplayWidth(inlineCodeToken.inlineCode) + receiptDisplayWidth(inlineCodeToken.trailingPunctuation) : 0;
     if (inlineCodeToken && inlineCodeWidth > available) {
@@ -23109,7 +23550,7 @@ function wrapReceiptDetail(label, detail) {
             codeWidth
           )}${inlineCodeToken.trailingPunctuation}`
         );
-        remaining = tokenEnd === -1 ? "" : remaining.slice(tokenEnd).trimStart();
+        remaining2 = tokenEnd === -1 ? "" : remaining2.slice(tokenEnd).trimStart();
       } else {
         lines.push(
           `${prefix}${truncateInlineCodeToken(
@@ -23117,13 +23558,13 @@ function wrapReceiptDetail(label, detail) {
             available
           )}`
         );
-        remaining = `${inlineCodeToken.trailingPunctuation}${tokenEnd === -1 ? "" : ` ${remaining.slice(tokenEnd).trimStart()}`}`;
+        remaining2 = `${inlineCodeToken.trailingPunctuation}${tokenEnd === -1 ? "" : ` ${remaining2.slice(tokenEnd).trimStart()}`}`;
       }
     } else {
-      const { head, tail } = splitAtDisplayWidth(remaining, available);
+      const { head, tail } = splitAtDisplayWidth(remaining2, available);
       if (!head) return [];
       lines.push(`${prefix}${head}`);
-      remaining = tail;
+      remaining2 = tail;
     }
     prefix = continuationPrefix;
   }
@@ -23257,17 +23698,17 @@ function absoluteEnvPath(value) {
   const trimmed = value.trim();
   if (trimmed === "~") return os2.homedir();
   if (trimmed.startsWith("~/") || trimmed.startsWith("~\\")) {
-    return path20.join(os2.homedir(), trimmed.slice(2));
+    return path22.join(os2.homedir(), trimmed.slice(2));
   }
-  return path20.isAbsolute(trimmed) ? path20.normalize(trimmed) : void 0;
+  return path22.isAbsolute(trimmed) ? path22.normalize(trimmed) : void 0;
 }
 function observerDirectory() {
   const fmlHome = absoluteEnvPath(process.env.FML_HOME);
-  return absoluteEnvPath(process.env.FML_OBSERVER_DIR) ?? absoluteEnvPath(process.env.PANOPTICON_HOME) ?? (fmlHome ? path20.join(fmlHome, "panopticon") : path20.join(os2.homedir(), ".fml", "panopticon"));
+  return absoluteEnvPath(process.env.FML_OBSERVER_DIR) ?? absoluteEnvPath(process.env.PANOPTICON_HOME) ?? (fmlHome ? path22.join(fmlHome, "panopticon") : path22.join(os2.homedir(), ".fml", "panopticon"));
 }
 function readObserverEndpoint(filePath) {
   try {
-    const parsed = JSON.parse(fs9.readFileSync(filePath, "utf8"));
+    const parsed = JSON.parse(fs10.readFileSync(filePath, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       return null;
     }
@@ -23282,15 +23723,15 @@ function readObserverEndpoint(filePath) {
 }
 function readObserverAuthToken(filePath) {
   try {
-    return fs9.readFileSync(filePath, "utf8").trim() || null;
+    return fs10.readFileSync(filePath, "utf8").trim() || null;
   } catch {
     return null;
   }
 }
 async function deliver(event, repository) {
   const directory = observerDirectory();
-  const endpoint = readObserverEndpoint(path20.join(directory, "endpoint.json"));
-  const authToken = readObserverAuthToken(path20.join(directory, "auth-token"));
+  const endpoint = readObserverEndpoint(path22.join(directory, "endpoint.json"));
+  const authToken = readObserverAuthToken(path22.join(directory, "auth-token"));
   if (!endpoint || !authToken) return;
   const host = endpoint.host === "::1" ? "[::1]" : endpoint.host;
   try {
@@ -23302,7 +23743,10 @@ async function deliver(event, repository) {
       },
       body: JSON.stringify({
         target: "pi",
-        payload: event,
+        payload: {
+          ...event,
+          [GIT_STATE_PAYLOAD_KEY]: event.cwd ? resolveGitStateFromCwd(event.cwd, 250) : null
+        },
         ...event.cwd ? { cwd: event.cwd } : {},
         ...repository ? { repository } : {}
       }),
@@ -23360,16 +23804,16 @@ var RECEIPT_GRAPHEME_SEGMENTER = new Intl.Segmenter(void 0, {
 });
 function wrapReceiptLine(text, width) {
   if (width < 1) return [""];
-  let remaining = text.trim();
-  if (!remaining) return [""];
+  let remaining2 = text.trim();
+  if (!remaining2) return [""];
   const lines = [];
-  while (remaining) {
+  while (remaining2) {
     let line = "";
     let lineWidth = 0;
     let end = 0;
     let whitespaceEnd = 0;
     for (const { segment, index } of RECEIPT_GRAPHEME_SEGMENTER.segment(
-      remaining
+      remaining2
     )) {
       const segmentWidth = receiptDisplayWidth(segment);
       if (segmentWidth > width) {
@@ -23384,16 +23828,16 @@ function wrapReceiptLine(text, width) {
       end = index + segment.length;
       if (/^\s$/u.test(segment)) whitespaceEnd = end;
     }
-    if (end === remaining.length) {
+    if (end === remaining2.length) {
       lines.push(line.trimEnd());
       break;
     }
     if (whitespaceEnd > 0) {
-      lines.push(remaining.slice(0, whitespaceEnd).trimEnd());
-      remaining = remaining.slice(whitespaceEnd).trimStart();
+      lines.push(remaining2.slice(0, whitespaceEnd).trimEnd());
+      remaining2 = remaining2.slice(whitespaceEnd).trimStart();
     } else {
       lines.push(line);
-      remaining = remaining.slice(end);
+      remaining2 = remaining2.slice(end);
     }
   }
   return lines;
@@ -23433,7 +23877,7 @@ var PiReceiptComponent = class {
   }
 };
 function fmlPiExtension(pi) {
-  let sessionId = randomUUID4();
+  let sessionId = randomUUID5();
   let initializedSessionId = null;
   let cwd;
   let repository = null;
@@ -23558,7 +24002,7 @@ function fmlPiExtension(pi) {
     }
     repository = null;
     try {
-      repository = cwd ? resolveRepositorySlugFromCwd(cwd, 250) : null;
+      repository = cwd ? resolveGitStateFromCwd(cwd, 250)?.repository ?? null : null;
     } catch {
     }
     if (newIdentity && evidence?.status === "absent" && (event.reason === "startup" || event.reason === "new" || event.reason === "resume") && entries.every(
@@ -23567,7 +24011,8 @@ function fmlPiExtension(pi) {
       const origin = PiRepositoryOriginDataSchema.safeParse({
         version: 1,
         repository,
-        cwd
+        cwd,
+        gitState: cwd ? resolveGitStateFromCwd(cwd, 250) : null
       });
       if (origin.success) {
         capturedRepository = origin.data.repository;