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

package/dist/{chunk-U7SITLCL.js → chunk-LYKMU7QR.js}

@@ -1,6 +1,9 @@
 import {
-  canonicalGitHubRepository
-} from "./chunk-CSOFP7MT.js";
+  GIT_STATE_CACHE_FILENAME,
+  canonicalGitHubRepository,
+  createGitStateResolver,
+  parseGitState
+} from "./chunk-74KOMQZO.js";
 import {
   FML_INSTALLATION_ID_FILE,
   FML_OBSERVER_DIR,
@@ -186,10 +189,10 @@ function setSyncEnabled(settingsFile, enabled) {
 }
 
 // ../../packages/panopticon/src/artifacts.ts
-import { createHash as createHash5, randomUUID as randomUUID3 } from "crypto";
-import fs9 from "fs";
+import { createHash as createHash4, randomUUID as randomUUID3 } from "crypto";
+import fs8 from "fs";
 import os3 from "os";
-import path20 from "path";
+import path19 from "path";
 
 // ../../packages/agent-targets/src/pi-agent-dir.ts
 import path6 from "path";
@@ -451,14 +454,29 @@ function repositoryObservation(input) {
     ...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 record of readJsonlContextRecords(sourcePath)) {
     if (typeof record.cwd !== "string" || !record.cwd.trim()) continue;
     const origin = context.resolveGitHubOrigin?.(record.cwd);
+    const state = origin?.gitState ?? context.resolveGitState?.(record.cwd);
+    if (state) states.set(state.worktreeRoot, state);
     if (!origin) continue;
     const observation = repositoryObservation({
       repository: origin.repository,
@@ -473,7 +491,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()]
   });
 }
@@ -513,6 +534,7 @@ function codexTranscriptCandidate(sourcePath, readPath, store, context, harnessI
     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(
@@ -547,7 +569,11 @@ function codexTranscriptCandidate(sourcePath, readPath, store, context, harnessI
       identityKey,
       readPath,
       sessionId,
-      metadata: { store, ...identityMetadata },
+      metadata: {
+        store,
+        ...identityMetadata,
+        ...localGitStateMetadata([state])
+      },
       repositoryObservations: observations
     });
   }
@@ -827,6 +853,12 @@ var PI_REPOSITORY_ORIGIN_ENTRY_TYPE = "fml-repository-origin";
 var RepositorySlugSchema = z.string().regex(/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/u).transform((slug) => canonicalGitHubRepository(`https://github.com/${slug}`)).pipe(z.string());
 var PiRepositoryOriginDataSchema = z.object({
   version: z.literal(1),
+  gitState: z.unknown().transform((value, ctx) => {
+    const state = parseGitState(value);
+    if (state) return state;
+    ctx.addIssue({ code: "custom", message: "Invalid Git state snapshot" });
+    return z.NEVER;
+  }).nullable().optional(),
   repository: RepositorySlugSchema.nullable(),
   cwd: z.string().min(1).refine(
     (cwd) => cwd.trim().length > 0 && !new RegExp("\\p{Cc}", "u").test(cwd) && Buffer.byteLength(cwd, "utf8") <= 4096
@@ -868,12 +900,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
       })
     ] : []
   });
@@ -1026,78 +1061,18 @@ function pruneMaterializedCache(input) {
 }
 
 // ../../packages/panopticon/src/repository-context.ts
-import { execFileSync } from "child_process";
-import { createHash as createHash4 } from "crypto";
-import fs8 from "fs";
-import path19 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;
-}
-function runReadOnlyGit(cwd, args, maxBuffer = GIT_OUTPUT_BYTES) {
-  if (!validCwd(cwd)) return null;
-  try {
-    return execFileSync("git", ["-C", cwd, ...args], {
-      encoding: "utf8",
-      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 { origin: null, definitive: false };
-  }
-  const repository = remote ? canonicalGitHubRepository(remote) : null;
-  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;
-  let commitHash;
-  try {
-    commitHash = runGit(cwd, ["rev-parse", "HEAD"]);
-  } catch {
-    return {
-      origin: { repository, ...branch ? { branch } : {} },
-      definitive: false
-    };
-  }
-  return {
-    origin: {
-      repository,
-      ...branch ? { branch } : {},
-      ...commitHash ? { commitHash } : {}
-    },
-    definitive: true
-  };
-}
-function resolveGitHubOrigin(cwd, runGit = runReadOnlyGit) {
-  return resolveGitHubOriginResult(cwd, runGit).origin;
+var DEFAULT_RESOLVER = createGitStateResolver();
+function gitStateOrigin(state) {
+  return state?.repository ? {
+    repository: state.repository,
+    ...state.branch ? { branch: state.branch } : {},
+    ...state.commitHash ? { commitHash: state.commitHash } : {},
+    gitState: state
+  } : null;
+}
+function resolveGitHubOrigin(cwd) {
+  return gitStateOrigin(DEFAULT_RESOLVER.resolve(cwd));
 }
 function createMeasuredGitHubOriginResolver(resolve = (cwd) => resolveGitHubOrigin(cwd), nowMs = () => performance.now(), options = {}) {
   const cache = /* @__PURE__ */ new Map();
@@ -1165,173 +1140,29 @@ function createMeasuredGitHubOriginResolver(resolve = (cwd) => resolveGitHubOrig
     })
   };
 }
-var PERSISTENT_ORIGIN_CACHE_SCHEMA_VERSION = 2;
-var DEFAULT_PERSISTENT_ORIGIN_CACHE_MAX_ENTRIES = 512;
-function fileContentIdentity(filePath) {
-  try {
-    const contents = fs8.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 = fs8.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 fs8.readFileSync(filePath, "utf8").trim();
-  } catch {
-    return null;
-  }
-}
-function findGitDirectory(cwd) {
-  let current = path19.resolve(cwd);
-  for (; ; ) {
-    const candidate = path19.join(current, ".git");
-    let stat;
-    try {
-      stat = fs8.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 = path19.resolve(current, match[1]);
-      const common = readSmallText(path19.join(gitDir, "commondir"));
-      return {
-        gitDir,
-        commonDir: common ? path19.resolve(gitDir, common) : gitDir
-      };
-    }
-    const parent = path19.dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-}
-function checkoutSignature(layout, cwd) {
-  const headPath = path19.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 = path19.join(layout.commonDir, ref);
-    if (/^ref:/u.test(readSmallText(looseRefPath) ?? "")) return null;
-    const looseRefIdentity = fileContentIdentity(looseRefPath);
-    const packedIdentity = packedRefsIdentity(
-      path19.join(layout.commonDir, "packed-refs")
-    );
-    const reftableIdentity = fileContentIdentity(
-      path19.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(fs8.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 {
-    fs8.mkdirSync(path19.dirname(cacheFile), { recursive: true, mode: 448 });
-    fs8.writeFileSync(temporary, `${JSON.stringify(cache)}
-`, { mode: 384 });
-    fs8.renameSync(temporary, cacheFile);
-  } catch {
-    try {
-      fs8.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;
+function createArtifactDiscoveryGitHubOriginResolver(options = {}) {
+  const resolver = createGitStateResolver(options);
+  const states = /* @__PURE__ */ new Map();
+  const measured = createMeasuredGitHubOriginResolver((cwd) => {
+    const state = resolver.resolve(cwd);
+    states.delete(cwd);
+    states.set(cwd, state);
+    while (states.size > DEFAULT_GITHUB_ORIGIN_CACHE_MAX_ENTRIES) {
+      const oldest = states.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;
+      states.delete(oldest);
     }
-    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;
+    return gitStateOrigin(state);
+  });
+  return {
+    ...measured,
+    resolveState: (cwd) => {
+      if (states.has(cwd)) return states.get(cwd) ?? null;
+      const origin = measured.resolve(cwd);
+      return origin?.gitState ?? (states.has(cwd) ? states.get(cwd) ?? null : resolver.resolve(cwd));
     }
   };
 }
-function createArtifactDiscoveryGitHubOriginResolver(options = {}) {
-  const resolve = options.cacheFile ? createPersistentGitHubOriginResolver({ cacheFile: options.cacheFile }) : (cwd) => resolveGitHubOrigin(cwd);
-  return createMeasuredGitHubOriginResolver(resolve, () => performance.now());
-}
 
 // ../../packages/panopticon/src/artifacts.ts
 var RAW_ARTIFACT_ENDPOINT = "/v1/ingest/raw-artifact";
@@ -1374,20 +1205,20 @@ function isAbortError(error) {
 }
 function safeStat(filePath) {
   try {
-    return fs9.statSync(filePath);
+    return fs8.statSync(filePath);
   } catch {
     return null;
   }
 }
 function normalizeFilePath2(filePath) {
-  return path20.resolve(filePath);
+  return path19.resolve(filePath);
 }
 function artifactReadPath(artifact) {
   return normalizeFilePath2(artifact.readPath ?? artifact.sourcePath);
 }
 function statCandidateSource(sourcePath, transientStatErrors) {
   try {
-    return fs9.statSync(sourcePath);
+    return fs8.statSync(sourcePath);
   } catch (error) {
     if (error.code === "ENOENT") return null;
     if (transientStatErrors === "throw") throw error;
@@ -1395,7 +1226,7 @@ function statCandidateSource(sourcePath, transientStatErrors) {
   }
 }
 function contentTypeForPath(filePath) {
-  const ext = path20.extname(filePath).toLowerCase();
+  const ext = path19.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".jsonl") return "application/json";
   if (ext === ".md") return "text/markdown";
   if (ext === ".toml") return "application/toml";
@@ -1444,6 +1275,7 @@ function discoverArtifacts(options = {}) {
     env,
     maxFileBytes: maxBytes,
     resolveGitHubOrigin: repositoryResolution.resolve,
+    resolveGitState: repositoryResolution.resolveState,
     ...options.materializeArtifact ? { materializeArtifact: options.materializeArtifact } : {}
   });
   const byKey = /* @__PURE__ */ new Map();
@@ -1508,7 +1340,7 @@ function readUploadThrottles(value) {
 }
 function readArtifactQueue(queueFile) {
   try {
-    const parsed = JSON.parse(fs9.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) {
@@ -1524,16 +1356,52 @@ function readArtifactQueue(queueFile) {
     return emptyQueue();
   }
 }
+var QUEUE_WRITE_SLICE_ENTRIES = 256;
+function writeQueuePiece(fd, piece) {
+  const buffer = Buffer.from(piece, "utf8");
+  let offset = 0;
+  while (offset < buffer.length) {
+    const written = fs8.writeSync(fd, buffer, offset);
+    if (written === 0) {
+      throw new Error("artifact queue write made no progress");
+    }
+    offset += written;
+  }
+}
 function writeArtifactQueue(queueFile, queue) {
-  fs9.mkdirSync(path20.dirname(queueFile), { recursive: true, mode: 448 });
+  fs8.mkdirSync(path19.dirname(queueFile), { recursive: true, mode: 448 });
   const tempFile = `${queueFile}.${process.pid}.${Date.now()}.tmp`;
-  fs9.writeFileSync(tempFile, `${JSON.stringify(queue, null, 2)}
-`, {
-    mode: 384
-  });
-  fs9.renameSync(tempFile, queueFile);
+  const fd = fs8.openSync(tempFile, "w", 384);
+  try {
+    writeQueuePiece(
+      fd,
+      `{"schemaVersion":${JSON.stringify(queue.schemaVersion)}`
+    );
+    if (queue.uploadThrottles !== void 0) {
+      writeQueuePiece(
+        fd,
+        `,"uploadThrottles":${JSON.stringify(queue.uploadThrottles)}`
+      );
+    }
+    writeQueuePiece(fd, ',"artifacts":[');
+    const artifacts = queue.artifacts;
+    for (let start = 0; start < artifacts.length; start += QUEUE_WRITE_SLICE_ENTRIES) {
+      const slice = artifacts.slice(start, start + QUEUE_WRITE_SLICE_ENTRIES).map((entry) => JSON.stringify(entry)).join(",");
+      writeQueuePiece(fd, start === 0 ? slice : `,${slice}`);
+    }
+    writeQueuePiece(fd, "]}\n");
+  } catch (error) {
+    fs8.closeSync(fd);
+    try {
+      fs8.rmSync(tempFile, { force: true });
+    } catch {
+    }
+    throw error;
+  }
+  fs8.closeSync(fd);
+  fs8.renameSync(tempFile, queueFile);
   try {
-    fs9.chmodSync(queueFile, 384);
+    fs8.chmodSync(queueFile, 384);
   } catch {
   }
 }
@@ -1553,7 +1421,7 @@ function shouldStartNewGeneration(input) {
   if (input.existing.source === "mini-swe-agent") {
     if (input.existing.contentSha256) {
       try {
-        return createHash5("sha256").update(fs9.readFileSync(input.nextReadPath)).digest("hex") !== input.existing.contentSha256;
+        return createHash4("sha256").update(fs8.readFileSync(input.nextReadPath)).digest("hex") !== input.existing.contentSha256;
       } catch {
       }
     }
@@ -1563,7 +1431,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 = createHash5("sha256").update(fs9.readFileSync(input.nextReadPath)).digest("hex");
+      const contentSha256 = createHash4("sha256").update(fs8.readFileSync(input.nextReadPath)).digest("hex");
       if (contentSha256 === input.existing.contentSha256) return false;
     } catch {
     }
@@ -1674,13 +1542,24 @@ function metadataForGeneration(input) {
     observations: input.candidateObservations,
     metadataWithoutContext
   });
-  return {
+  const metadata = {
     ...metadataWithoutContext,
     ...hasInstallIdentity ? {
       installIdentitySchemaVersion: RAW_ARTIFACT_IDENTITY_SCHEMA_VERSION
     } : {},
     ...repositoryContext ? { repositoryContext } : {}
   };
+  const rawGitStates = metadata.localGitStates;
+  const statesValue = Array.isArray(rawGitStates) ? rawGitStates : rawGitStates !== null && typeof rawGitStates === "object" && "version" in rawGitStates && rawGitStates.version === 1 && "states" in rawGitStates ? rawGitStates.states : void 0;
+  if (Array.isArray(statesValue) && rawGitStates && typeof rawGitStates === "object") {
+    const states = [...statesValue];
+    metadata.localGitStates = Array.isArray(rawGitStates) ? states : { ...rawGitStates, states };
+    while (states.length && Buffer.byteLength(JSON.stringify(metadata), "utf8") > MAX_RAW_ARTIFACT_NESTED_METADATA_BYTES)
+      states.pop();
+    if (!states.length && Buffer.byteLength(JSON.stringify(metadata), "utf8") > MAX_RAW_ARTIFACT_NESTED_METADATA_BYTES)
+      delete metadata.localGitStates;
+  }
+  return metadata;
 }
 function snapshotCandidate2(candidate, existing, nowMs, maxFileBytes, transientStatErrors = "ignore", observerIdentity) {
   const sourcePath = normalizeFilePath2(candidate.sourcePath);
@@ -1897,7 +1776,7 @@ function sameSourceRevision(left, right) {
 }
 function safeSourceRevision(filePath) {
   try {
-    const stat = fs9.statSync(filePath, { bigint: true });
+    const stat = fs8.statSync(filePath, { bigint: true });
     return stat.isFile() ? sourceRevisionFromStat(stat) : null;
   } catch {
     return null;
@@ -1909,7 +1788,7 @@ function readExactRange(fd, startByte, endByte) {
   const buffer = Buffer.alloc(sizeBytes);
   let offset = 0;
   while (offset < sizeBytes) {
-    const bytesRead = fs9.readSync(
+    const bytesRead = fs8.readSync(
       fd,
       buffer,
       offset,
@@ -1928,19 +1807,19 @@ function readFileRangeAtRevision(filePath, startByte, endByte, expectedRevision)
   }
   let fd;
   try {
-    fd = fs9.openSync(filePath, "r");
+    fd = fs8.openSync(filePath, "r");
   } catch {
     return null;
   }
   try {
     const openedRevision = sourceRevisionFromStat(
-      fs9.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(
-      fs9.fstatSync(fd, { bigint: true })
+      fs8.fstatSync(fd, { bigint: true })
     );
     const pathRevisionAfter = safeSourceRevision(filePath);
     if (!sameSourceRevision(openedRevision, revisionAfterRead) || !pathRevisionAfter || !sameSourceRevision(openedRevision, pathRevisionAfter)) {
@@ -1950,7 +1829,7 @@ function readFileRangeAtRevision(filePath, startByte, endByte, expectedRevision)
   } catch {
     return null;
   } finally {
-    fs9.closeSync(fd);
+    fs8.closeSync(fd);
   }
 }
 function uploadMetadata(input) {
@@ -2082,18 +1961,18 @@ function validateCheckpointPrefix(input) {
   }
   let fd;
   try {
-    fd = fs9.openSync(input.sourcePath, "r");
+    fd = fs8.openSync(input.sourcePath, "r");
   } catch {
     return { status: "changed" };
   }
   try {
     const openedRevision = sourceRevisionFromStat(
-      fs9.fstatSync(fd, { bigint: true })
+      fs8.fstatSync(fd, { bigint: true })
     );
     if (!sameSourceRevision(pathRevisionBefore, openedRevision)) {
       return { status: "changed" };
     }
-    const contentHash = createHash5("sha256");
+    const contentHash = createHash4("sha256");
     let checkpointMismatch = false;
     for (const checkpoint of checkpoints) {
       const chunk = readExactRange(
@@ -2108,7 +1987,7 @@ function validateCheckpointPrefix(input) {
       contentHash.update(chunk);
     }
     const revisionAfterRead = sourceRevisionFromStat(
-      fs9.fstatSync(fd, { bigint: true })
+      fs8.fstatSync(fd, { bigint: true })
     );
     const pathRevisionAfter = safeSourceRevision(input.sourcePath);
     if (!sameSourceRevision(openedRevision, revisionAfterRead) || !pathRevisionAfter || !sameSourceRevision(openedRevision, pathRevisionAfter)) {
@@ -2123,7 +2002,7 @@ function validateCheckpointPrefix(input) {
   } catch {
     return { status: "changed" };
   } finally {
-    fs9.closeSync(fd);
+    fs8.closeSync(fd);
   }
 }
 function validatedPrefixStillApplies(prefix, entry, uploadDestinationId, revision) {
@@ -2257,14 +2136,14 @@ function defaultIsPidAlive(pid) {
 }
 function readQueueLockHolder(lockFile) {
   try {
-    const parsed = JSON.parse(fs9.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, fs9.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;
@@ -2272,8 +2151,8 @@ function readQueueLockHolder(lockFile) {
 }
 function queueLockFileMatchesOwner(lockFile, fd, ownerToken) {
   try {
-    const openStat = fs9.fstatSync(fd);
-    const pathStat = fs9.statSync(lockFile);
+    const openStat = fs8.fstatSync(fd);
+    const pathStat = fs8.statSync(lockFile);
     if (openStat.dev !== pathStat.dev || openStat.ino !== pathStat.ino) {
       return false;
     }
@@ -2284,14 +2163,14 @@ function queueLockFileMatchesOwner(lockFile, fd, ownerToken) {
 }
 function acquireQueueLock(queueFile, deps) {
   const lockFile = queueLockFile(queueFile);
-  fs9.mkdirSync(path20.dirname(lockFile), { recursive: true, mode: 448 });
+  fs8.mkdirSync(path19.dirname(lockFile), { recursive: true, mode: 448 });
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      const fd = fs9.openSync(lockFile, "wx+", 384);
+      const fd = fs8.openSync(lockFile, "wx+", 384);
       const ownerToken = randomUUID3();
       let released = false;
       try {
-        fs9.writeSync(
+        fs8.writeSync(
           fd,
           `${JSON.stringify({
             pid: process.pid,
@@ -2301,11 +2180,11 @@ function acquireQueueLock(queueFile, deps) {
 `
         );
         const heartbeatAt = new Date(deps.nowMs());
-        fs9.futimesSync(fd, heartbeatAt, heartbeatAt);
+        fs8.futimesSync(fd, heartbeatAt, heartbeatAt);
       } catch (error) {
-        fs9.closeSync(fd);
+        fs8.closeSync(fd);
         try {
-          fs9.unlinkSync(lockFile);
+          fs8.unlinkSync(lockFile);
         } catch {
         }
         throw error;
@@ -2313,7 +2192,7 @@ function acquireQueueLock(queueFile, deps) {
       const close = () => {
         if (released) return;
         released = true;
-        fs9.closeSync(fd);
+        fs8.closeSync(fd);
       };
       return {
         heartbeat() {
@@ -2322,7 +2201,7 @@ function acquireQueueLock(queueFile, deps) {
             return false;
           try {
             const heartbeatAt = new Date(deps.nowMs());
-            fs9.futimesSync(fd, heartbeatAt, heartbeatAt);
+            fs8.futimesSync(fd, heartbeatAt, heartbeatAt);
             return true;
           } catch {
             return false;
@@ -2332,7 +2211,7 @@ function acquireQueueLock(queueFile, deps) {
           if (released) return;
           if (queueLockFileMatchesOwner(lockFile, fd, ownerToken)) {
             try {
-              fs9.unlinkSync(lockFile);
+              fs8.unlinkSync(lockFile);
             } catch {
             }
           }
@@ -2345,7 +2224,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 {
-        fs9.unlinkSync(lockFile);
+        fs8.unlinkSync(lockFile);
       } catch {
       }
     }
@@ -2403,7 +2282,7 @@ async function postRawArtifact(url, metadata, content, headers, fetchImpl = fetc
   form.append(
     "file",
     new Blob([new Uint8Array(content)], { type: metadata.contentType }),
-    path20.basename(metadata.sourcePath) || "raw-artifact"
+    path19.basename(metadata.sourcePath) || "raw-artifact"
   );
   const abort = new AbortController();
   const timeout = setTimeout(() => abort.abort(), timeoutMs);
@@ -2684,14 +2563,15 @@ async function syncArtifacts(options) {
     }
     const upload = await uploadPendingArtifactsLocked(
       options,
-      resolveUploadRun(options, lock)
+      resolveUploadRun(options, lock),
+      snapshot.queue
     );
     return { snapshot, upload };
   } finally {
     lock.release();
   }
 }
-async function uploadPendingArtifactsLocked(options, run) {
+async function uploadPendingArtifactsLocked(options, run, currentQueue) {
   const {
     nowMs,
     limit,
@@ -2703,7 +2583,7 @@ async function uploadPendingArtifactsLocked(options, run) {
     retryExhausted,
     lock
   } = run;
-  const queue = readArtifactQueue(options.queueFile);
+  const queue = currentQueue ?? readArtifactQueue(options.queueFile);
   const entries = queue.artifacts.filter((entry) => artifactSourceEnabled(entry.source)).map(
     (entry) => activateUploadDestination(entry, uploadDestinationId, targetName)
   );
@@ -3255,7 +3135,11 @@ async function uploadPendingArtifactsLocked(options, run) {
       persist();
     }
   }
-  const nextQueue = readArtifactQueue(options.queueFile);
+  const nextQueue = {
+    schemaVersion: RAW_ARTIFACT_SCHEMA_VERSION,
+    artifacts: entries,
+    uploadThrottles: Object.keys(uploadThrottles).length > 0 ? uploadThrottles : void 0
+  };
   const completedAtMs = nowMs();
   const exhausted = nextQueue.artifacts.filter(
     (entry) => isExhaustedForDestination(entry, uploadDestinationId, retryExhausted)
@@ -3292,12 +3176,12 @@ async function uploadPendingArtifactsLocked(options, run) {
 }
 
 // ../../packages/panopticon/src/raw-sync.ts
-import fs11 from "fs";
-import path21 from "path";
+import fs10 from "fs";
+import path20 from "path";
 import os4 from "os";
 
 // ../../packages/panopticon/src/artifact-materializer.ts
-import fs10 from "fs";
+import fs9 from "fs";
 function entryNeedsBytes(entry, amendmentPending) {
   if (entry.uploadedSizeBytes < entry.sizeBytes) return true;
   return amendmentPending(entry);
@@ -3312,7 +3196,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 = fs10.statSync(cachePath);
+      const stat = fs9.statSync(cachePath);
       if (!stat.isFile()) return false;
       if (!retained.has(cachePath)) {
         retained.add(cachePath);
@@ -3360,20 +3244,20 @@ function getRawArtifactSyncPaths(stateDir) {
   if (stateDir.length === 0) {
     throw new Error("raw artifact sync state directory must not be empty");
   }
-  const root = path21.resolve(stateDir);
+  const root = path20.resolve(stateDir);
   const managed = getManagedClientPaths({ PANOPTICON_HOME: root });
   return {
     root,
     settingsFile: managed.syncSettingsFile,
     queueFile: managed.artifactQueue,
     artifactCacheDir: managed.artifactCache,
-    discoveryCacheFile: path21.join(root, "discovery.cache.json"),
-    githubOriginCacheFile: path21.join(root, "github-origins.cache.json")
+    discoveryCacheFile: path20.join(root, "discovery.cache.json"),
+    githubOriginCacheFile: path20.join(root, GIT_STATE_CACHE_FILENAME)
   };
 }
 function invalidateRawArtifactDiscoveryCache(stateDir) {
   try {
-    fs11.rmSync(getRawArtifactSyncPaths(stateDir).discoveryCacheFile, {
+    fs10.rmSync(getRawArtifactSyncPaths(stateDir).discoveryCacheFile, {
       force: true
     });
   } catch {
@@ -3476,9 +3360,9 @@ function createRawArtifactSync(options) {
     options.homeDir ?? null,
     options.projectRoots ?? null,
     options.maxFileBytes ?? null,
-    path21.resolve(
+    path20.resolve(
       resolvePiAgentDir({
-        homeDir: path21.resolve(
+        homeDir: path20.resolve(
           options.homeDir ?? process.env.HOME ?? os4.homedir()
         ),
         env: process.env
@@ -3491,7 +3375,7 @@ function createRawArtifactSync(options) {
     if (reuseMs <= 0) return null;
     try {
       const parsed = JSON.parse(
-        fs11.readFileSync(paths.discoveryCacheFile, "utf8")
+        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;
@@ -3507,11 +3391,11 @@ function createRawArtifactSync(options) {
     if ((options.discoveryReuseMs ?? 0) <= 0) return;
     const temporary = `${paths.discoveryCacheFile}.${process.pid}.tmp`;
     try {
-      fs11.mkdirSync(path21.dirname(paths.discoveryCacheFile), {
+      fs10.mkdirSync(path20.dirname(paths.discoveryCacheFile), {
         recursive: true,
         mode: 448
       });
-      fs11.writeFileSync(
+      fs10.writeFileSync(
         temporary,
         `${JSON.stringify({
           schemaVersion: DISCOVERY_CACHE_SCHEMA_VERSION,
@@ -3522,10 +3406,10 @@ function createRawArtifactSync(options) {
 `,
         { mode: 384 }
       );
-      fs11.renameSync(temporary, paths.discoveryCacheFile);
+      fs10.renameSync(temporary, paths.discoveryCacheFile);
     } catch {
       try {
-        fs11.rmSync(temporary, { force: true });
+        fs10.rmSync(temporary, { force: true });
       } catch {
       }
     }