@fml-inc/fml 0.8.6 → 0.8.7-rc.1

package/dist/{chunk-V2XC7JTB.js → chunk-5JJQWV4G.js}

@@ -183,10 +183,10 @@ function setSyncEnabled(settingsFile, enabled) {
 }
 
 // ../../packages/panopticon/src/artifacts.ts
-import { createHash as createHash4, randomUUID as randomUUID3 } from "crypto";
-import fs7 from "fs";
+import { createHash as createHash5, randomUUID as randomUUID3 } from "crypto";
+import fs8 from "fs";
 import os3 from "os";
-import path17 from "path";
+import path18 from "path";
 
 // ../../packages/agent-targets/src/artifacts/targets/claude.ts
 import path8 from "path";
@@ -375,6 +375,7 @@ function canonicalGitHubRepository(remote) {
 // ../../packages/agent-targets/src/artifacts/repository-context.ts
 var MAX_ARTIFACT_CONTEXT_PREFIX_BYTES = 256 * 1024;
 var MAX_ARTIFACT_CONTEXT_RECORDS = 64;
+var ARTIFACT_CONTEXT_READ_CHUNK_BYTES = 32 * 1024;
 var MAX_CWD_BYTES = 4096;
 var MAX_BRANCH_BYTES = 1024;
 function utf8Bytes2(value) {
@@ -402,24 +403,39 @@ function readJsonlContextRecords(sourcePath) {
     const stat = fs5.fstatSync(file);
     const byteLimit = Math.min(stat.size, MAX_ARTIFACT_CONTEXT_PREFIX_BYTES);
     if (byteLimit <= 0) return [];
-    const buffer = Buffer.allocUnsafe(byteLimit);
-    const bytesRead = fs5.readSync(file, buffer, 0, byteLimit, 0);
-    let content = buffer.subarray(0, bytesRead).toString("utf8");
-    if (bytesRead < stat.size) {
-      const lastNewline = content.lastIndexOf("\n");
-      if (lastNewline < 0) return [];
-      content = content.slice(0, lastNewline + 1);
-    }
     const records = [];
-    for (const line of content.split(/\r?\n/)) {
-      if (records.length >= MAX_ARTIFACT_CONTEXT_RECORDS) break;
+    const parseLine = (line) => {
       const jsonLine = line.startsWith("\uFEFF") ? line.slice(1) : line;
-      if (!jsonLine.trim()) continue;
+      if (!jsonLine.trim()) return;
       try {
         const record = recordValue(JSON.parse(jsonLine));
         if (record) records.push(record);
       } catch {
       }
+    };
+    let carry = Buffer.alloc(0);
+    let position = 0;
+    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 = fs5.readSync(file, chunk, 0, want, position);
+      if (bytesRead <= 0) break;
+      position += bytesRead;
+      const buffered = Buffer.concat([carry, chunk.subarray(0, bytesRead)]);
+      const lastNewline = buffered.lastIndexOf(10);
+      if (lastNewline < 0) {
+        carry = buffered;
+        continue;
+      }
+      const complete = buffered.subarray(0, lastNewline + 1).toString("utf8");
+      carry = Buffer.from(buffered.subarray(lastNewline + 1));
+      for (const line of complete.split(/\r?\n/)) {
+        if (records.length >= MAX_ARTIFACT_CONTEXT_RECORDS) break;
+        parseLine(line);
+      }
+    }
+    if (carry.length > 0 && position >= stat.size && records.length < MAX_ARTIFACT_CONTEXT_RECORDS) {
+      parseLine(carry.toString("utf8"));
     }
     return records;
   } catch {
@@ -922,41 +938,78 @@ function pruneMaterializedCache(input) {
 
 // ../../packages/panopticon/src/repository-context.ts
 import { execFileSync } from "child_process";
+import { createHash as createHash4 } from "crypto";
+import fs7 from "fs";
+import path17 from "path";
 var MAX_CWD_BYTES2 = 4096;
 var GIT_OUTPUT_BYTES = 16 * 1024;
+var GIT_CONFIG_OUTPUT_BYTES = 4 * 1024 * 1024;
 var GIT_TIMEOUT_MS = 1e3;
 var DEFAULT_GITHUB_ORIGIN_CACHE_MAX_ENTRIES = 512;
+var ReadOnlyGitCommandError = class extends Error {
+  constructor() {
+    super("read-only git command failed");
+  }
+};
 function validCwd(cwd) {
   const trimmed = cwd.trim();
   return trimmed === cwd && trimmed.length > 0 && !new RegExp("\\p{Cc}", "u").test(trimmed) && Buffer.byteLength(trimmed, "utf8") <= MAX_CWD_BYTES2;
 }
-var runReadOnlyGit = (cwd, args) => {
+function runReadOnlyGit(cwd, args, maxBuffer = GIT_OUTPUT_BYTES) {
   if (!validCwd(cwd)) return null;
   try {
     return execFileSync("git", ["-C", cwd, ...args], {
       encoding: "utf8",
-      maxBuffer: GIT_OUTPUT_BYTES,
+      maxBuffer,
       timeout: GIT_TIMEOUT_MS,
       stdio: ["ignore", "pipe", "ignore"],
       windowsHide: true
     }).trim() || null;
+  } catch (error) {
+    const status = error && typeof error === "object" && "status" in error ? error.status : void 0;
+    if (status === 2 && args.length === 3 && args[0] === "remote" && args[1] === "get-url" && args[2] === "origin") {
+      return null;
+    }
+    throw new ReadOnlyGitCommandError();
+  }
+}
+function resolveGitHubOriginResult(cwd, runGit = runReadOnlyGit) {
+  let remote;
+  try {
+    remote = runGit(cwd, ["remote", "get-url", "origin"]);
   } catch {
-    return null;
+    return { origin: null, definitive: false };
   }
-};
-function resolveGitHubOrigin(cwd, runGit = runReadOnlyGit) {
-  const remote = runGit(cwd, ["remote", "get-url", "origin"]);
   const repository = remote ? canonicalGitHubRepository(remote) : null;
-  if (!repository) return null;
-  const branchResult = runGit(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  if (!repository) return { origin: null, definitive: true };
+  let branchResult;
+  try {
+    branchResult = runGit(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  } catch {
+    return { origin: { repository }, definitive: false };
+  }
   const branch = branchResult === "HEAD" ? null : branchResult;
-  const commitHash = runGit(cwd, ["rev-parse", "HEAD"]);
+  let commitHash;
+  try {
+    commitHash = runGit(cwd, ["rev-parse", "HEAD"]);
+  } catch {
+    return {
+      origin: { repository, ...branch ? { branch } : {} },
+      definitive: false
+    };
+  }
   return {
-    repository,
-    ...branch ? { branch } : {},
-    ...commitHash ? { commitHash } : {}
+    origin: {
+      repository,
+      ...branch ? { branch } : {},
+      ...commitHash ? { commitHash } : {}
+    },
+    definitive: true
   };
 }
+function resolveGitHubOrigin(cwd, runGit = runReadOnlyGit) {
+  return resolveGitHubOriginResult(cwd, runGit).origin;
+}
 function createMeasuredGitHubOriginResolver(resolve = (cwd) => resolveGitHubOrigin(cwd), nowMs = () => performance.now(), options = {}) {
   const cache = /* @__PURE__ */ new Map();
   const maxCacheEntries = options.maxCacheEntries ?? DEFAULT_GITHUB_ORIGIN_CACHE_MAX_ENTRIES;
@@ -1023,11 +1076,172 @@ function createMeasuredGitHubOriginResolver(resolve = (cwd) => resolveGitHubOrig
     })
   };
 }
-function createArtifactDiscoveryGitHubOriginResolver() {
-  return createMeasuredGitHubOriginResolver(
-    (cwd) => resolveGitHubOrigin(cwd),
-    () => performance.now()
-  );
+var PERSISTENT_ORIGIN_CACHE_SCHEMA_VERSION = 2;
+var DEFAULT_PERSISTENT_ORIGIN_CACHE_MAX_ENTRIES = 512;
+function fileContentIdentity(filePath) {
+  try {
+    const contents = fs7.readFileSync(filePath);
+    return `sha256:${createHash4("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 packedRefsIdentity(filePath) {
+  try {
+    const stat = fs7.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 effectiveConfigIdentity(cwd) {
+  if (["GIT_CONFIG", "GIT_DIR", "GIT_COMMON_DIR", "GIT_WORK_TREE"].some(
+    (name) => process.env[name] !== void 0
+  )) {
+    return null;
+  }
+  try {
+    const config = runReadOnlyGit(
+      cwd,
+      ["config", "--includes", "--null", "--list"],
+      GIT_CONFIG_OUTPUT_BYTES
+    );
+    return createHash4("sha256").update(config ?? "").digest("hex");
+  } catch {
+    return null;
+  }
+}
+function readSmallText(filePath) {
+  try {
+    return fs7.readFileSync(filePath, "utf8").trim();
+  } catch {
+    return null;
+  }
+}
+function findGitDirectory(cwd) {
+  let current = path17.resolve(cwd);
+  for (; ; ) {
+    const candidate = path17.join(current, ".git");
+    let stat;
+    try {
+      stat = fs7.statSync(candidate);
+    } catch {
+      stat = void 0;
+    }
+    if (stat?.isDirectory()) {
+      return { 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 = path17.resolve(current, match[1]);
+      const common = readSmallText(path17.join(gitDir, "commondir"));
+      return {
+        gitDir,
+        commonDir: common ? path17.resolve(gitDir, common) : gitDir
+      };
+    }
+    const parent = path17.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function checkoutSignature(layout, cwd) {
+  const headPath = path17.join(layout.gitDir, "HEAD");
+  const head = readSmallText(headPath);
+  const configIdentity = effectiveConfigIdentity(cwd);
+  if (head === null || configIdentity === null) {
+    return null;
+  }
+  const parts = [layout.gitDir, head, configIdentity];
+  const ref = /^ref:\s*(.+)$/u.exec(head)?.[1];
+  if (ref) {
+    const looseRefPath = path17.join(layout.commonDir, ref);
+    if (/^ref:/u.test(readSmallText(looseRefPath) ?? "")) return null;
+    const looseRefIdentity = fileContentIdentity(looseRefPath);
+    const packedIdentity = packedRefsIdentity(
+      path17.join(layout.commonDir, "packed-refs")
+    );
+    const reftableIdentity = fileContentIdentity(
+      path17.join(layout.commonDir, "reftable", "tables.list")
+    );
+    if (!looseRefIdentity || !packedIdentity || !reftableIdentity || looseRefIdentity === "missing" && packedIdentity === "missing" && reftableIdentity === "missing") {
+      return null;
+    }
+    parts.push(looseRefIdentity, packedIdentity, reftableIdentity);
+  }
+  return parts.join("\0");
+}
+function readPersistentOriginCache(cacheFile) {
+  try {
+    const parsed = JSON.parse(fs7.readFileSync(cacheFile, "utf8"));
+    if (parsed && typeof parsed === "object" && parsed.schemaVersion === PERSISTENT_ORIGIN_CACHE_SCHEMA_VERSION && parsed.entries && typeof parsed.entries === "object") {
+      return parsed;
+    }
+  } catch {
+  }
+  return { schemaVersion: PERSISTENT_ORIGIN_CACHE_SCHEMA_VERSION, entries: {} };
+}
+function writePersistentOriginCache(cacheFile, cache) {
+  const temporary = `${cacheFile}.${process.pid}.tmp`;
+  try {
+    fs7.mkdirSync(path17.dirname(cacheFile), { recursive: true, mode: 448 });
+    fs7.writeFileSync(temporary, `${JSON.stringify(cache)}
+`, { mode: 384 });
+    fs7.renameSync(temporary, cacheFile);
+  } catch {
+    try {
+      fs7.rmSync(temporary, { force: true });
+    } catch {
+    }
+  }
+}
+function createPersistentGitHubOriginResolver(options) {
+  const maxEntries = options.maxEntries ?? DEFAULT_PERSISTENT_ORIGIN_CACHE_MAX_ENTRIES;
+  const cache = readPersistentOriginCache(options.cacheFile);
+  const entries = new Map(Object.entries(cache.entries));
+  const remember = (cwd, entry) => {
+    entries.delete(cwd);
+    entries.set(cwd, entry);
+    while (entries.size > maxEntries) {
+      const oldest = entries.keys().next().value;
+      if (oldest === void 0) break;
+      entries.delete(oldest);
+    }
+    writePersistentOriginCache(options.cacheFile, {
+      schemaVersion: PERSISTENT_ORIGIN_CACHE_SCHEMA_VERSION,
+      entries: Object.fromEntries(entries)
+    });
+  };
+  return (cwd) => {
+    if (!validCwd(cwd)) return null;
+    const layout = findGitDirectory(cwd);
+    if (!layout) return null;
+    const signature = checkoutSignature(layout, cwd);
+    const cached = entries.get(cwd);
+    if (signature !== null && cached && cached.signature === signature) {
+      return cached.origin;
+    }
+    try {
+      const result = options.resolve ? { origin: options.resolve(cwd), definitive: true } : resolveGitHubOriginResult(cwd);
+      if (signature !== null && result.definitive) {
+        remember(cwd, { signature, origin: result.origin });
+      }
+      return result.origin;
+    } catch {
+      return null;
+    }
+  };
+}
+function createArtifactDiscoveryGitHubOriginResolver(options = {}) {
+  const resolve = options.cacheFile ? createPersistentGitHubOriginResolver({ cacheFile: options.cacheFile }) : (cwd) => resolveGitHubOrigin(cwd);
+  return createMeasuredGitHubOriginResolver(resolve, () => performance.now());
 }
 
 // ../../packages/panopticon/src/artifacts.ts
@@ -1071,20 +1285,20 @@ function isAbortError(error) {
 }
 function safeStat(filePath) {
   try {
-    return fs7.statSync(filePath);
+    return fs8.statSync(filePath);
   } catch {
     return null;
   }
 }
 function normalizeFilePath2(filePath) {
-  return path17.resolve(filePath);
+  return path18.resolve(filePath);
 }
 function artifactReadPath(artifact) {
   return normalizeFilePath2(artifact.readPath ?? artifact.sourcePath);
 }
 function statCandidateSource(sourcePath, transientStatErrors) {
   try {
-    return fs7.statSync(sourcePath);
+    return fs8.statSync(sourcePath);
   } catch (error) {
     if (error.code === "ENOENT") return null;
     if (transientStatErrors === "throw") throw error;
@@ -1092,7 +1306,7 @@ function statCandidateSource(sourcePath, transientStatErrors) {
   }
 }
 function contentTypeForPath(filePath) {
-  const ext = path17.extname(filePath).toLowerCase();
+  const ext = path18.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".jsonl") return "application/json";
   if (ext === ".md") return "text/markdown";
   if (ext === ".toml") return "application/toml";
@@ -1122,7 +1336,9 @@ function buildArtifactChunkId(args) {
   )}`;
 }
 function discoverArtifacts(options = {}) {
-  const repositoryResolution = createArtifactDiscoveryGitHubOriginResolver();
+  const repositoryResolution = createArtifactDiscoveryGitHubOriginResolver(
+    options.githubOriginCacheFile ? { cacheFile: options.githubOriginCacheFile } : {}
+  );
   const env = options.env ?? process.env;
   const homeDirInput = options.homeDir ?? env.HOME ?? os3.homedir();
   if (!homeDirInput) {
@@ -1202,7 +1418,7 @@ function readUploadThrottles(value) {
 }
 function readArtifactQueue(queueFile) {
   try {
-    const parsed = JSON.parse(fs7.readFileSync(queueFile, "utf8"));
+    const parsed = JSON.parse(fs8.readFileSync(queueFile, "utf8"));
     if (!parsed || typeof parsed !== "object") return emptyQueue();
     const record = parsed;
     if (record.schemaVersion !== RAW_ARTIFACT_SCHEMA_VERSION) {
@@ -1219,15 +1435,15 @@ function readArtifactQueue(queueFile) {
   }
 }
 function writeArtifactQueue(queueFile, queue) {
-  fs7.mkdirSync(path17.dirname(queueFile), { recursive: true, mode: 448 });
+  fs8.mkdirSync(path18.dirname(queueFile), { recursive: true, mode: 448 });
   const tempFile = `${queueFile}.${process.pid}.${Date.now()}.tmp`;
-  fs7.writeFileSync(tempFile, `${JSON.stringify(queue, null, 2)}
+  fs8.writeFileSync(tempFile, `${JSON.stringify(queue, null, 2)}
 `, {
     mode: 384
   });
-  fs7.renameSync(tempFile, queueFile);
+  fs8.renameSync(tempFile, queueFile);
   try {
-    fs7.chmodSync(queueFile, 384);
+    fs8.chmodSync(queueFile, 384);
   } catch {
   }
 }
@@ -1248,7 +1464,7 @@ function shouldStartNewGeneration(input) {
   if (input.nextSizeBytes < input.existing.sizeBytes) return true;
   if ((input.nextReadPath !== artifactReadPath(input.existing) || input.existing.readPath !== void 0) && input.nextSizeBytes === input.existing.sizeBytes && input.existing.uploadedSizeBytes >= input.nextSizeBytes && input.existing.contentSha256) {
     try {
-      const contentSha256 = createHash4("sha256").update(fs7.readFileSync(input.nextReadPath)).digest("hex");
+      const contentSha256 = createHash5("sha256").update(fs8.readFileSync(input.nextReadPath)).digest("hex");
       if (contentSha256 === input.existing.contentSha256) return false;
     } catch {
     }
@@ -1582,7 +1798,7 @@ function sameSourceRevision(left, right) {
 }
 function safeSourceRevision(filePath) {
   try {
-    const stat = fs7.statSync(filePath, { bigint: true });
+    const stat = fs8.statSync(filePath, { bigint: true });
     return stat.isFile() ? sourceRevisionFromStat(stat) : null;
   } catch {
     return null;
@@ -1594,7 +1810,7 @@ function readExactRange(fd, startByte, endByte) {
   const buffer = Buffer.alloc(sizeBytes);
   let offset = 0;
   while (offset < sizeBytes) {
-    const bytesRead = fs7.readSync(
+    const bytesRead = fs8.readSync(
       fd,
       buffer,
       offset,
@@ -1613,19 +1829,19 @@ function readFileRangeAtRevision(filePath, startByte, endByte, expectedRevision)
   }
   let fd;
   try {
-    fd = fs7.openSync(filePath, "r");
+    fd = fs8.openSync(filePath, "r");
   } catch {
     return null;
   }
   try {
     const openedRevision = sourceRevisionFromStat(
-      fs7.fstatSync(fd, { bigint: true })
+      fs8.fstatSync(fd, { bigint: true })
     );
     if (!sameSourceRevision(pathRevisionBefore, openedRevision)) return null;
     const bytes = readExactRange(fd, startByte, endByte);
     if (!bytes) return null;
     const revisionAfterRead = sourceRevisionFromStat(
-      fs7.fstatSync(fd, { bigint: true })
+      fs8.fstatSync(fd, { bigint: true })
     );
     const pathRevisionAfter = safeSourceRevision(filePath);
     if (!sameSourceRevision(openedRevision, revisionAfterRead) || !pathRevisionAfter || !sameSourceRevision(openedRevision, pathRevisionAfter)) {
@@ -1635,7 +1851,7 @@ function readFileRangeAtRevision(filePath, startByte, endByte, expectedRevision)
   } catch {
     return null;
   } finally {
-    fs7.closeSync(fd);
+    fs8.closeSync(fd);
   }
 }
 function uploadMetadata(input) {
@@ -1767,18 +1983,18 @@ function validateCheckpointPrefix(input) {
   }
   let fd;
   try {
-    fd = fs7.openSync(input.sourcePath, "r");
+    fd = fs8.openSync(input.sourcePath, "r");
   } catch {
     return { status: "changed" };
   }
   try {
     const openedRevision = sourceRevisionFromStat(
-      fs7.fstatSync(fd, { bigint: true })
+      fs8.fstatSync(fd, { bigint: true })
     );
     if (!sameSourceRevision(pathRevisionBefore, openedRevision)) {
       return { status: "changed" };
     }
-    const contentHash = createHash4("sha256");
+    const contentHash = createHash5("sha256");
     let checkpointMismatch = false;
     for (const checkpoint of checkpoints) {
       const chunk = readExactRange(
@@ -1793,7 +2009,7 @@ function validateCheckpointPrefix(input) {
       contentHash.update(chunk);
     }
     const revisionAfterRead = sourceRevisionFromStat(
-      fs7.fstatSync(fd, { bigint: true })
+      fs8.fstatSync(fd, { bigint: true })
     );
     const pathRevisionAfter = safeSourceRevision(input.sourcePath);
     if (!sameSourceRevision(openedRevision, revisionAfterRead) || !pathRevisionAfter || !sameSourceRevision(openedRevision, pathRevisionAfter)) {
@@ -1808,7 +2024,7 @@ function validateCheckpointPrefix(input) {
   } catch {
     return { status: "changed" };
   } finally {
-    fs7.closeSync(fd);
+    fs8.closeSync(fd);
   }
 }
 function validatedPrefixStillApplies(prefix, entry, uploadDestinationId, revision) {
@@ -1942,14 +2158,14 @@ function defaultIsPidAlive(pid) {
 }
 function readQueueLockHolder(lockFile) {
   try {
-    const parsed = JSON.parse(fs7.readFileSync(lockFile, "utf8"));
+    const parsed = JSON.parse(fs8.readFileSync(lockFile, "utf8"));
     if (!parsed || typeof parsed !== "object") return null;
     const record = parsed;
     if (typeof record.pid !== "number" || typeof record.timestampMs !== "number") {
       return null;
     }
     const ownerToken = typeof record.ownerToken === "string" ? record.ownerToken : void 0;
-    const timestampMs = ownerToken ? Math.max(record.timestampMs, fs7.statSync(lockFile).mtimeMs) : record.timestampMs;
+    const timestampMs = ownerToken ? Math.max(record.timestampMs, fs8.statSync(lockFile).mtimeMs) : record.timestampMs;
     return { pid: record.pid, timestampMs, ownerToken };
   } catch {
     return null;
@@ -1957,8 +2173,8 @@ function readQueueLockHolder(lockFile) {
 }
 function queueLockFileMatchesOwner(lockFile, fd, ownerToken) {
   try {
-    const openStat = fs7.fstatSync(fd);
-    const pathStat = fs7.statSync(lockFile);
+    const openStat = fs8.fstatSync(fd);
+    const pathStat = fs8.statSync(lockFile);
     if (openStat.dev !== pathStat.dev || openStat.ino !== pathStat.ino) {
       return false;
     }
@@ -1969,14 +2185,14 @@ function queueLockFileMatchesOwner(lockFile, fd, ownerToken) {
 }
 function acquireQueueLock(queueFile, deps) {
   const lockFile = queueLockFile(queueFile);
-  fs7.mkdirSync(path17.dirname(lockFile), { recursive: true, mode: 448 });
+  fs8.mkdirSync(path18.dirname(lockFile), { recursive: true, mode: 448 });
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      const fd = fs7.openSync(lockFile, "wx+", 384);
+      const fd = fs8.openSync(lockFile, "wx+", 384);
       const ownerToken = randomUUID3();
       let released = false;
       try {
-        fs7.writeSync(
+        fs8.writeSync(
           fd,
           `${JSON.stringify({
             pid: process.pid,
@@ -1986,11 +2202,11 @@ function acquireQueueLock(queueFile, deps) {
 `
         );
         const heartbeatAt = new Date(deps.nowMs());
-        fs7.futimesSync(fd, heartbeatAt, heartbeatAt);
+        fs8.futimesSync(fd, heartbeatAt, heartbeatAt);
       } catch (error) {
-        fs7.closeSync(fd);
+        fs8.closeSync(fd);
         try {
-          fs7.unlinkSync(lockFile);
+          fs8.unlinkSync(lockFile);
         } catch {
         }
         throw error;
@@ -1998,7 +2214,7 @@ function acquireQueueLock(queueFile, deps) {
       const close = () => {
         if (released) return;
         released = true;
-        fs7.closeSync(fd);
+        fs8.closeSync(fd);
       };
       return {
         heartbeat() {
@@ -2007,7 +2223,7 @@ function acquireQueueLock(queueFile, deps) {
             return false;
           try {
             const heartbeatAt = new Date(deps.nowMs());
-            fs7.futimesSync(fd, heartbeatAt, heartbeatAt);
+            fs8.futimesSync(fd, heartbeatAt, heartbeatAt);
             return true;
           } catch {
             return false;
@@ -2017,7 +2233,7 @@ function acquireQueueLock(queueFile, deps) {
           if (released) return;
           if (queueLockFileMatchesOwner(lockFile, fd, ownerToken)) {
             try {
-              fs7.unlinkSync(lockFile);
+              fs8.unlinkSync(lockFile);
             } catch {
             }
           }
@@ -2030,7 +2246,7 @@ function acquireQueueLock(queueFile, deps) {
       const stale = !holder || !deps.isPidAlive(holder.pid) || deps.nowMs() - holder.timestampMs > QUEUE_LOCK_STALE_MS;
       if (!stale) return null;
       try {
-        fs7.unlinkSync(lockFile);
+        fs8.unlinkSync(lockFile);
       } catch {
       }
     }
@@ -2088,7 +2304,7 @@ async function postRawArtifact(url, metadata, content, headers, fetchImpl = fetc
   form.append(
     "file",
     new Blob([new Uint8Array(content)], { type: metadata.contentType }),
-    path17.basename(metadata.sourcePath) || "raw-artifact"
+    path18.basename(metadata.sourcePath) || "raw-artifact"
   );
   const abort = new AbortController();
   const timeout = setTimeout(() => abort.abort(), timeoutMs);
@@ -2977,10 +3193,11 @@ async function uploadPendingArtifactsLocked(options, run) {
 }
 
 // ../../packages/panopticon/src/raw-sync.ts
-import path18 from "path";
+import fs10 from "fs";
+import path19 from "path";
 
 // ../../packages/panopticon/src/artifact-materializer.ts
-import fs8 from "fs";
+import fs9 from "fs";
 function entryNeedsBytes(entry, amendmentPending) {
   if (entry.uploadedSizeBytes < entry.sizeBytes) return true;
   return amendmentPending(entry);
@@ -2995,7 +3212,7 @@ function createArtifactMaterializer(input) {
   const unsupportedReason = (input.supportsCompression ?? supportsCompressedArtifacts)() ? void 0 : `compressed artifacts need Node 22.15 or newer (running ${process.version})`;
   const chargeExisting = (cachePath) => {
     try {
-      const stat = fs8.statSync(cachePath);
+      const stat = fs9.statSync(cachePath);
       if (!stat.isFile()) return false;
       if (!retained.has(cachePath)) {
         retained.add(cachePath);
@@ -3006,6 +3223,11 @@ function createArtifactMaterializer(input) {
       return false;
     }
   };
+  for (const entry of input.entries) {
+    if (entry.readPath && entryNeedsBytes(entry, input.amendmentPending)) {
+      chargeExisting(entry.readPath);
+    }
+  }
   return {
     unsupportedReason,
     materialize: (sourcePath) => {
@@ -3033,19 +3255,30 @@ function createArtifactMaterializer(input) {
 var DEFAULT_RAW_SYNC_MAX_DRAIN_PASSES = 10;
 var DEFAULT_RAW_SYNC_MAX_DRAIN_BYTES = 100 * 1024 * 1024;
 var DEFAULT_RAW_SYNC_MAX_DRAIN_MS = 6e4;
+var DISCOVERY_CACHE_SCHEMA_VERSION = 1;
 function getRawArtifactSyncPaths(stateDir) {
   if (stateDir.length === 0) {
     throw new Error("raw artifact sync state directory must not be empty");
   }
-  const root = path18.resolve(stateDir);
+  const root = path19.resolve(stateDir);
   const managed = getManagedClientPaths({ PANOPTICON_HOME: root });
   return {
     root,
     settingsFile: managed.syncSettingsFile,
     queueFile: managed.artifactQueue,
-    artifactCacheDir: managed.artifactCache
+    artifactCacheDir: managed.artifactCache,
+    discoveryCacheFile: path19.join(root, "discovery.cache.json"),
+    githubOriginCacheFile: path19.join(root, "github-origins.cache.json")
   };
 }
+function invalidateRawArtifactDiscoveryCache(stateDir) {
+  try {
+    fs10.rmSync(getRawArtifactSyncPaths(stateDir).discoveryCacheFile, {
+      force: true
+    });
+  } catch {
+  }
+}
 function summarizeArtifactQueue(queue) {
   let pending = 0;
   let uploaded = 0;
@@ -3115,7 +3348,7 @@ function createRawArtifactSync(options) {
     settings: getSettings(),
     queue: summarizeArtifactQueue(readArtifactQueue(paths.queueFile))
   });
-  const discover = () => {
+  const createMaterializer = () => {
     const materializer = createArtifactMaterializer({
       cacheDir: paths.artifactCacheDir,
       entries: readArtifactQueue(paths.queueFile).artifacts,
@@ -3123,17 +3356,81 @@ function createRawArtifactSync(options) {
       maxTotalBytes: options.maxArtifactCacheBytes
     });
     lastMaterializer = materializer;
+    return materializer;
+  };
+  const discover = () => {
+    const materializer = createMaterializer();
     const discovery = discoverArtifacts({
       homeDir: options.homeDir,
       projectRoots: options.projectRoots,
       maxFileBytes: options.maxFileBytes,
-      materializeArtifact: materializer.materialize
+      materializeArtifact: materializer.materialize,
+      githubOriginCacheFile: paths.githubOriginCacheFile
     });
     return materializer.unsupportedReason ? {
       ...discovery,
       compressedArtifactsUnsupportedReason: materializer.unsupportedReason
     } : discovery;
   };
+  const discoveryInputs = () => JSON.stringify([
+    options.homeDir ?? null,
+    options.projectRoots ?? null,
+    options.maxFileBytes ?? null
+  ]);
+  const readReusableDiscovery = (nowMs) => {
+    const reuseMs = options.discoveryReuseMs ?? 0;
+    if (reuseMs <= 0) return null;
+    try {
+      const parsed = JSON.parse(
+        fs10.readFileSync(paths.discoveryCacheFile, "utf8")
+      );
+      if (parsed.schemaVersion !== DISCOVERY_CACHE_SCHEMA_VERSION || typeof parsed.createdAtMs !== "number" || parsed.inputs !== discoveryInputs() || !parsed.discovery || typeof parsed.discovery !== "object") {
+        return null;
+      }
+      const ageMs = nowMs - parsed.createdAtMs;
+      if (ageMs < 0 || ageMs >= reuseMs) return null;
+      return parsed.discovery;
+    } catch {
+      return null;
+    }
+  };
+  const rememberDiscovery = (discovery, nowMs) => {
+    if ((options.discoveryReuseMs ?? 0) <= 0) return;
+    const temporary = `${paths.discoveryCacheFile}.${process.pid}.tmp`;
+    try {
+      fs10.mkdirSync(path19.dirname(paths.discoveryCacheFile), {
+        recursive: true,
+        mode: 448
+      });
+      fs10.writeFileSync(
+        temporary,
+        `${JSON.stringify({
+          schemaVersion: DISCOVERY_CACHE_SCHEMA_VERSION,
+          createdAtMs: nowMs,
+          inputs: discoveryInputs(),
+          discovery
+        })}
+`,
+        { mode: 384 }
+      );
+      fs10.renameSync(temporary, paths.discoveryCacheFile);
+    } catch {
+      try {
+        fs10.rmSync(temporary, { force: true });
+      } catch {
+      }
+    }
+  };
+  const discoverForRun = (nowMs) => {
+    const reusable = readReusableDiscovery(nowMs);
+    if (reusable) {
+      createMaterializer();
+      return reusable;
+    }
+    const discovery = discover();
+    rememberDiscovery(discovery, nowMs);
+    return discovery;
+  };
   return {
     paths,
     getSettings,
@@ -3166,7 +3463,7 @@ function createRawArtifactSync(options) {
           status: status()
         };
       }
-      const discovery = discover();
+      const discovery = discoverForRun((options.nowMs ?? Date.now)());
       const syncOptions = {
         queueFile: paths.queueFile,
         candidates: discovery.candidates,
@@ -3261,10 +3558,17 @@ function createRawArtifactSync(options) {
 }
 
 // src/sync/runner.ts
+var OBSERVER_DISCOVERY_REUSE_MS = 6e4;
+function invalidateCliRawSyncDiscoveryCache() {
+  invalidateRawArtifactDiscoveryCache(FML_OBSERVER_DIR);
+}
 function createCliRawSync(opts = {}) {
   return createRawArtifactSync({
     stateDir: FML_OBSERVER_DIR,
     retryExhausted: opts.continuous ?? false,
+    // Interactive `fml sync` always discovers fresh; only the observer's
+    // back-to-back cycles reuse a recent discovery.
+    ...opts.continuous ? { discoveryReuseMs: OBSERVER_DISCOVERY_REUSE_MS } : {},
     observerIdentity: collectObserverIdentity(FML_INSTALLATION_ID_FILE) ?? void 0
   });
 }
@@ -3304,30 +3608,12 @@ async function runRawSyncOnce(opts = {}) {
   };
 }
 
-// src/package-root.ts
-import fs9 from "fs";
-import path19 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-function resolvePackageRoot(startDir = path19.dirname(fileURLToPath2(import.meta.url))) {
-  let directory = startDir;
-  while (true) {
-    if (fs9.existsSync(path19.join(directory, "package.json")) && fs9.existsSync(path19.join(directory, "bin"))) {
-      return directory;
-    }
-    const parent = path19.dirname(directory);
-    if (parent === directory) {
-      throw new Error(`Could not resolve FML package root from ${startDir}`);
-    }
-    directory = parent;
-  }
-}
-
 export {
   claudeConfigDirectory,
   geminiConfigDirectory,
   initializeSyncSettings,
   createRawArtifactSync,
-  resolvePackageRoot,
+  invalidateCliRawSyncDiscoveryCache,
   createCliRawSync,
   runRawSyncOnce
 };