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

package/dist/{chunk-VFZWTVPD.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,29 +189,44 @@ 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 path19 from "path";
 
+// ../../packages/agent-targets/src/pi-agent-dir.ts
+import path6 from "path";
+function resolvePiAgentDir(context) {
+  const pathApi = (context.platform ?? process.platform) === "win32" ? path6.win32 : path6.posix;
+  const configured = context.env.PI_CODING_AGENT_DIR?.trim();
+  if (!configured) {
+    return pathApi.join(context.homeDir, ".pi", "agent");
+  }
+  if (configured === "~") return context.homeDir;
+  if (configured.startsWith("~/") || configured.startsWith("~\\")) {
+    return pathApi.join(context.homeDir, configured.slice(2));
+  }
+  return pathApi.normalize(configured);
+}
+
 // ../../packages/agent-targets/src/artifacts/targets/claude.ts
-import path8 from "path";
+import path9 from "path";
 
 // ../../packages/agent-targets/src/config-paths.ts
-import path6 from "path";
+import path7 from "path";
 function claudeConfigDirectory(context) {
   const configuredDir = context.claudeConfigDir ?? context.env?.CLAUDE_CONFIG_DIR;
-  return typeof configuredDir === "string" && configuredDir.trim().length > 0 ? path6.resolve(configuredDir) : path6.join(context.homeDir, ".claude");
+  return typeof configuredDir === "string" && configuredDir.trim().length > 0 ? path7.resolve(configuredDir) : path7.join(context.homeDir, ".claude");
 }
 function geminiConfigDirectory(context) {
   const configuredHome = context.env.GEMINI_CLI_HOME;
-  const homeRoot = typeof configuredHome === "string" && configuredHome.trim().length > 0 ? path6.resolve(configuredHome) : context.homeDir;
-  return path6.join(homeRoot, ".gemini");
+  const homeRoot = typeof configuredHome === "string" && configuredHome.trim().length > 0 ? path7.resolve(configuredHome) : context.homeDir;
+  return path7.join(homeRoot, ".gemini");
 }
 
 // ../../packages/agent-targets/src/artifacts/filesystem.ts
 import fs3 from "fs";
-import path7 from "path";
+import path8 from "path";
 var DEFAULT_SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -225,7 +243,7 @@ var DEFAULT_SKIP_DIRS = /* @__PURE__ */ new Set([
   "designqc-captures"
 ]);
 function normalizeFilePath(filePath) {
-  return path7.resolve(filePath);
+  return path8.resolve(filePath);
 }
 function safeReaddir(dir) {
   try {
@@ -242,7 +260,7 @@ function walkFiles(input) {
   function walk(dir, depth) {
     if (depth > input.maxDepth) return;
     for (const entry of safeReaddir(dir)) {
-      const entryPath = path7.join(dir, entry.name);
+      const entryPath = path8.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (!skipDirs.has(entry.name)) walk(entryPath, depth + 1);
         continue;
@@ -436,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,
@@ -458,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()]
   });
 }
@@ -467,9 +503,9 @@ var claudeArtifactDiscovery = Object.freeze({
   discover: (context) => {
     const { homeDir, env } = context;
     const configDir = claudeConfigDirectory({ homeDir, env });
-    const harnessInstallId = readClaudeMachineId(path8.join(configDir, ".claude.json")) ?? readClaudeMachineId(path8.join(homeDir, ".claude.json"));
+    const harnessInstallId = readClaudeMachineId(path9.join(configDir, ".claude.json")) ?? readClaudeMachineId(path9.join(homeDir, ".claude.json"));
     return walkFiles({
-      root: path8.join(configDir, "projects"),
+      root: path9.join(configDir, "projects"),
       maxDepth: 6,
       includeFile: (filePath) => filePath.endsWith(".jsonl")
     }).map(
@@ -479,10 +515,10 @@ var claudeArtifactDiscovery = Object.freeze({
 });
 
 // ../../packages/agent-targets/src/artifacts/targets/codex.ts
-import path9 from "path";
+import path10 from "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(path9.basename(sourcePath))?.[1]?.toLowerCase() ?? null;
+  return CODEX_ROLLOUT_ID.exec(path10.basename(sourcePath))?.[1]?.toLowerCase() ?? null;
 }
 function codexTranscriptCandidate(sourcePath, readPath, store, context, harnessInstallId) {
   const rolloutId = codexRolloutId(sourcePath);
@@ -498,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(
@@ -532,7 +569,11 @@ function codexTranscriptCandidate(sourcePath, readPath, store, context, harnessI
       identityKey,
       readPath,
       sessionId,
-      metadata: { store, ...identityMetadata },
+      metadata: {
+        store,
+        ...identityMetadata,
+        ...localGitStateMetadata([state])
+      },
       repositoryObservations: observations
     });
   }
@@ -552,15 +593,15 @@ var codexArtifactDiscovery = Object.freeze({
   discover: (context) => {
     const { homeDir, env } = context;
     const configuredHome = env.CODEX_HOME?.trim();
-    const codexHome = configuredHome ? path9.resolve(configuredHome) : path9.join(homeDir, ".codex");
+    const codexHome = configuredHome ? path10.resolve(configuredHome) : path10.join(homeDir, ".codex");
     const harnessInstallId = readHarnessInstallIdFile(
-      path9.join(codexHome, "installation_id")
+      path10.join(codexHome, "installation_id")
     );
     const roots = [
-      { store: "sessions", root: path9.join(codexHome, "sessions") },
+      { store: "sessions", root: path10.join(codexHome, "sessions") },
       {
         store: "archived_sessions",
-        root: path9.join(codexHome, "archived_sessions")
+        root: path10.join(codexHome, "archived_sessions")
       }
     ];
     const files = roots.flatMap(
@@ -598,27 +639,27 @@ var codexArtifactDiscovery = Object.freeze({
 });
 
 // ../../packages/agent-targets/src/artifacts/targets/copilot-cli.ts
-import path10 from "path";
+import path11 from "path";
 var copilotCliArtifactDiscovery = Object.freeze({
   targetId: "copilot-cli",
   discover: ({ homeDir }) => walkFiles({
-    root: path10.join(homeDir, ".copilot", "session-state"),
+    root: path11.join(homeDir, ".copilot", "session-state"),
     maxDepth: 3,
-    includeFile: (filePath) => path10.basename(filePath) === "events.jsonl"
+    includeFile: (filePath) => path11.basename(filePath) === "events.jsonl"
   }).map(
     (sourcePath) => transcriptCandidate({ targetId: "copilot-cli", sourcePath })
   )
 });
 
 // ../../packages/agent-targets/src/artifacts/targets/cursor.ts
-import path11 from "path";
+import path12 from "path";
 function hasPathSegment(filePath, segment) {
-  return normalizeFilePath(filePath).split(path11.sep).includes(segment);
+  return normalizeFilePath(filePath).split(path12.sep).includes(segment);
 }
 var cursorArtifactDiscovery = Object.freeze({
   targetId: "cursor",
   discover: ({ homeDir }) => walkFiles({
-    root: path11.join(homeDir, ".cursor", "projects"),
+    root: path12.join(homeDir, ".cursor", "projects"),
     maxDepth: 5,
     includeFile: (filePath) => filePath.endsWith(".jsonl") && hasPathSegment(filePath, "agent-transcripts")
   }).map(
@@ -627,11 +668,11 @@ var cursorArtifactDiscovery = Object.freeze({
 });
 
 // ../../packages/agent-targets/src/artifacts/targets/factory-droid.ts
-import path12 from "path";
+import path13 from "path";
 var factoryDroidArtifactDiscovery = Object.freeze({
   targetId: "factory-droid",
   discover: ({ homeDir }) => walkFiles({
-    root: path12.join(homeDir, ".factory", "sessions"),
+    root: path13.join(homeDir, ".factory", "sessions"),
     maxDepth: 4,
     includeFile: (filePath) => filePath.endsWith(".jsonl")
   }).map(
@@ -640,7 +681,7 @@ var factoryDroidArtifactDiscovery = Object.freeze({
 });
 
 // ../../packages/agent-targets/src/artifacts/targets/gemini.ts
-import path13 from "path";
+import path14 from "path";
 var GEMINI_DISCOVER_SKIP_DIRS = /* @__PURE__ */ new Set([
   "bin",
   "checkpoints",
@@ -655,15 +696,15 @@ var geminiArtifactDiscovery = Object.freeze({
   discover: ({ homeDir, env }) => {
     const geminiDir = geminiConfigDirectory({ homeDir, env });
     const harnessInstallId = readHarnessInstallIdFile(
-      path13.join(geminiDir, "installation_id")
+      path14.join(geminiDir, "installation_id")
     );
-    const root = path13.join(geminiDir, "tmp");
+    const root = path14.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 = path13.join(dir, entry.name);
+        const entryPath = path14.join(dir, entry.name);
         if (!entry.isDirectory()) continue;
         if (GEMINI_DISCOVER_SKIP_DIRS.has(entry.name)) continue;
         if (entry.name === "chats") {
@@ -672,7 +713,7 @@ var geminiArtifactDiscovery = Object.freeze({
               continue;
             }
             const sourcePath = normalizeFilePath(
-              path13.join(entryPath, chatEntry.name)
+              path14.join(entryPath, chatEntry.name)
             );
             if (seen.has(sourcePath)) continue;
             seen.add(sourcePath);
@@ -695,17 +736,17 @@ var geminiArtifactDiscovery = Object.freeze({
 });
 
 // ../../packages/agent-targets/src/artifacts/targets/grok.ts
-import path14 from "path";
+import path15 from "path";
 function grokHome(homeDir, env) {
   const configuredHome = env.GROK_HOME?.trim();
-  return configuredHome ? path14.resolve(configuredHome) : path14.join(homeDir, ".grok");
+  return configuredHome ? path15.resolve(configuredHome) : path15.join(homeDir, ".grok");
 }
 var grokArtifactDiscovery = Object.freeze({
   targetId: "grok",
   discover: ({ homeDir, env }) => walkFiles({
-    root: path14.join(grokHome(homeDir, env), "sessions"),
+    root: path15.join(grokHome(homeDir, env), "sessions"),
     maxDepth: 5,
-    includeFile: (filePath) => path14.basename(filePath) === "updates.jsonl"
+    includeFile: (filePath) => path15.basename(filePath) === "updates.jsonl"
   }).map(
     (sourcePath) => transcriptCandidate({ targetId: "grok", sourcePath })
   )
@@ -713,24 +754,24 @@ var grokArtifactDiscovery = Object.freeze({
 
 // ../../packages/agent-targets/src/artifacts/targets/mini-swe-agent.ts
 import fs6 from "fs";
-import path15 from "path";
+import path16 from "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 (!path15.isAbsolute(env.FML_DATA_DIR)) {
+    if (!path16.isAbsolute(env.FML_DATA_DIR)) {
       throw new Error("FML_DATA_DIR must be an absolute path");
     }
-    return path15.normalize(env.FML_DATA_DIR);
+    return path16.normalize(env.FML_DATA_DIR);
   }
   if (process.platform === "darwin") {
-    return path15.join(homeDir, "Library", "Application Support", "fml");
+    return path16.join(homeDir, "Library", "Application Support", "fml");
   }
   if (process.platform === "win32") {
-    const roaming = env.APPDATA && path15.isAbsolute(env.APPDATA) ? env.APPDATA : path15.join(homeDir, "AppData", "Roaming");
-    return path15.join(roaming, "fml");
+    const roaming = env.APPDATA && path16.isAbsolute(env.APPDATA) ? env.APPDATA : path16.join(homeDir, "AppData", "Roaming");
+    return path16.join(roaming, "fml");
   }
-  const xdgDataHome = env.XDG_DATA_HOME && path15.isAbsolute(env.XDG_DATA_HOME) ? env.XDG_DATA_HOME : path15.join(homeDir, ".local", "share");
-  return path15.join(xdgDataHome, "fml");
+  const xdgDataHome = env.XDG_DATA_HOME && path16.isAbsolute(env.XDG_DATA_HOME) ? env.XDG_DATA_HOME : path16.join(homeDir, ".local", "share");
+  return path16.join(xdgDataHome, "fml");
 }
 function snapshotCandidate(sourcePath, context) {
   let file;
@@ -794,7 +835,7 @@ function snapshotCandidate(sourcePath, context) {
 var miniSweAgentArtifactDiscovery = Object.freeze({
   targetId: "mini-swe-agent",
   discover: (context) => walkFiles({
-    root: path15.join(dataDirectory(context), "mini-swe-agent", "trajectories"),
+    root: path16.join(dataDirectory(context), "mini-swe-agent", "trajectories"),
     maxDepth: 0,
     includeFile: (filePath) => filePath.endsWith(".traj.json")
   }).flatMap((sourcePath) => {
@@ -804,7 +845,7 @@ var miniSweAgentArtifactDiscovery = Object.freeze({
 });
 
 // ../../packages/agent-targets/src/artifacts/targets/pi.ts
-import path16 from "path";
+import path17 from "path";
 
 // ../../packages/agent-targets/src/artifacts/pi-repository-origin.ts
 import { z } from "zod";
@@ -812,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
@@ -853,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
       })
     ] : []
   });
@@ -866,9 +916,8 @@ function piTranscriptCandidate(sourcePath) {
 var piArtifactDiscovery = Object.freeze({
   targetId: "pi",
   discover: (context) => {
-    const { homeDir } = context;
     return walkFiles({
-      root: path16.join(homeDir, ".pi", "agent", "sessions"),
+      root: path17.join(resolvePiAgentDir(context), "sessions"),
       maxDepth: 8,
       includeFile: (filePath) => filePath.endsWith(".jsonl"),
       skipDirs: PI_SKIP_DIRS
@@ -902,12 +951,12 @@ function discoverTargetArtifactCandidates(context) {
 // ../../packages/agent-targets/src/artifacts/materialize.ts
 import { createHash as createHash3 } from "crypto";
 import fs7 from "fs";
-import path17 from "path";
+import path18 from "path";
 import zlib from "zlib";
 var MAX_MATERIALIZED_ARTIFACT_BYTES = 100 * 1024 * 1024;
 var DEFAULT_MATERIALIZED_CACHE_BYTES = 2 * 1024 * 1024 * 1024;
 function cacheEntryName(sourcePath, stat) {
-  const identity = `${path17.resolve(sourcePath)}\0${stat.size}\0${Math.floor(
+  const identity = `${path18.resolve(sourcePath)}\0${stat.size}\0${Math.floor(
     stat.mtimeMs
   )}`;
   const digest = createHash3("sha256").update(identity).digest("hex");
@@ -931,7 +980,7 @@ function materializedArtifactPath(input) {
   try {
     const stat = fs7.statSync(input.sourcePath);
     if (!stat.isFile() || stat.size === 0) return null;
-    return path17.join(input.cacheDir, cacheEntryName(input.sourcePath, stat));
+    return path18.join(input.cacheDir, cacheEntryName(input.sourcePath, stat));
   } catch {
     return null;
   }
@@ -944,7 +993,7 @@ function materializeCompressedArtifact(input) {
     return null;
   }
   if (!stat.isFile() || stat.size === 0) return null;
-  const cachePath = path17.join(
+  const cachePath = path18.join(
     input.cacheDir,
     cacheEntryName(input.sourcePath, stat)
   );
@@ -985,7 +1034,7 @@ function pruneMaterializedCache(input) {
   const files = [];
   for (const entry of entries) {
     if (!entry.isFile()) continue;
-    const filePath = path17.join(input.cacheDir, entry.name);
+    const filePath = path18.join(input.cacheDir, entry.name);
     try {
       const stat = fs7.statSync(filePath);
       files.push({ path: filePath, size: stat.size, atimeMs: stat.atimeMs });
@@ -1012,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 path18 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();
@@ -1151,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 = path18.resolve(cwd);
-  for (; ; ) {
-    const candidate = path18.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 = path18.resolve(current, match[1]);
-      const common = readSmallText(path18.join(gitDir, "commondir"));
-      return {
-        gitDir,
-        commonDir: common ? path18.resolve(gitDir, common) : gitDir
-      };
-    }
-    const parent = path18.dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-}
-function checkoutSignature(layout, cwd) {
-  const headPath = path18.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 = path18.join(layout.commonDir, ref);
-    if (/^ref:/u.test(readSmallText(looseRefPath) ?? "")) return null;
-    const looseRefIdentity = fileContentIdentity(looseRefPath);
-    const packedIdentity = packedRefsIdentity(
-      path18.join(layout.commonDir, "packed-refs")
-    );
-    const reftableIdentity = fileContentIdentity(
-      path18.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(path18.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);
+      states.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;
+    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";
@@ -1360,7 +1205,7 @@ function isAbortError(error) {
 }
 function safeStat(filePath) {
   try {
-    return fs9.statSync(filePath);
+    return fs8.statSync(filePath);
   } catch {
     return null;
   }
@@ -1373,7 +1218,7 @@ function artifactReadPath(artifact) {
 }
 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;
@@ -1430,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();
@@ -1494,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) {
@@ -1510,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(path19.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 {
-    fs9.chmodSync(queueFile, 384);
+    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 {
+    fs8.chmodSync(queueFile, 384);
   } catch {
   }
 }
@@ -1539,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 {
       }
     }
@@ -1549,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 {
     }
@@ -1660,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);
@@ -1883,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;
@@ -1895,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,
@@ -1914,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)) {
@@ -1936,7 +1829,7 @@ function readFileRangeAtRevision(filePath, startByte, endByte, expectedRevision)
   } catch {
     return null;
   } finally {
-    fs9.closeSync(fd);
+    fs8.closeSync(fd);
   }
 }
 function uploadMetadata(input) {
@@ -2068,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(
@@ -2094,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)) {
@@ -2109,7 +2002,7 @@ function validateCheckpointPrefix(input) {
   } catch {
     return { status: "changed" };
   } finally {
-    fs9.closeSync(fd);
+    fs8.closeSync(fd);
   }
 }
 function validatedPrefixStillApplies(prefix, entry, uploadDestinationId, revision) {
@@ -2243,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;
@@ -2258,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;
     }
@@ -2270,14 +2163,14 @@ function queueLockFileMatchesOwner(lockFile, fd, ownerToken) {
 }
 function acquireQueueLock(queueFile, deps) {
   const lockFile = queueLockFile(queueFile);
-  fs9.mkdirSync(path19.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,
@@ -2287,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;
@@ -2299,7 +2192,7 @@ function acquireQueueLock(queueFile, deps) {
       const close = () => {
         if (released) return;
         released = true;
-        fs9.closeSync(fd);
+        fs8.closeSync(fd);
       };
       return {
         heartbeat() {
@@ -2308,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;
@@ -2318,7 +2211,7 @@ function acquireQueueLock(queueFile, deps) {
           if (released) return;
           if (queueLockFileMatchesOwner(lockFile, fd, ownerToken)) {
             try {
-              fs9.unlinkSync(lockFile);
+              fs8.unlinkSync(lockFile);
             } catch {
             }
           }
@@ -2331,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 {
       }
     }
@@ -2670,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,
@@ -2689,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)
   );
@@ -3241,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)
@@ -3278,11 +3176,12 @@ async function uploadPendingArtifactsLocked(options, run) {
 }
 
 // ../../packages/panopticon/src/raw-sync.ts
-import fs11 from "fs";
+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);
@@ -3297,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);
@@ -3353,12 +3252,12 @@ function getRawArtifactSyncPaths(stateDir) {
     queueFile: managed.artifactQueue,
     artifactCacheDir: managed.artifactCache,
     discoveryCacheFile: path20.join(root, "discovery.cache.json"),
-    githubOriginCacheFile: path20.join(root, "github-origins.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 {
@@ -3460,14 +3359,23 @@ function createRawArtifactSync(options) {
   const discoveryInputs = () => JSON.stringify([
     options.homeDir ?? null,
     options.projectRoots ?? null,
-    options.maxFileBytes ?? null
+    options.maxFileBytes ?? null,
+    path20.resolve(
+      resolvePiAgentDir({
+        homeDir: path20.resolve(
+          options.homeDir ?? process.env.HOME ?? os4.homedir()
+        ),
+        env: process.env
+      }),
+      "sessions"
+    )
   ]);
   const readReusableDiscovery = (nowMs) => {
     const reuseMs = options.discoveryReuseMs ?? 0;
     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;
@@ -3483,11 +3391,11 @@ function createRawArtifactSync(options) {
     if ((options.discoveryReuseMs ?? 0) <= 0) return;
     const temporary = `${paths.discoveryCacheFile}.${process.pid}.tmp`;
     try {
-      fs11.mkdirSync(path20.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,
@@ -3498,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 {
       }
     }
@@ -3694,6 +3602,7 @@ async function runRawSyncOnce(opts = {}) {
 }
 
 export {
+  resolvePiAgentDir,
   claudeConfigDirectory,
   geminiConfigDirectory,
   initializeSyncSettings,