@fml-inc/fml 0.8.10-dev.1 → 0.8.11-rc.1

package/dist/{chunk-JPHN4VKM.js → chunk-VFZWTVPD.js}

@@ -1,3 +1,6 @@
+import {
+  canonicalGitHubRepository
+} from "./chunk-CSOFP7MT.js";
 import {
   FML_INSTALLATION_ID_FILE,
   FML_OBSERVER_DIR,
@@ -184,9 +187,9 @@ function setSyncEnabled(settingsFile, enabled) {
 
 // ../../packages/panopticon/src/artifacts.ts
 import { createHash as createHash5, randomUUID as randomUUID3 } from "crypto";
-import fs8 from "fs";
+import fs9 from "fs";
 import os3 from "os";
-import path18 from "path";
+import path19 from "path";
 
 // ../../packages/agent-targets/src/artifacts/targets/claude.ts
 import path8 from "path";
@@ -326,65 +329,18 @@ function readClaudeMachineId(configFile) {
 // ../../packages/agent-targets/src/artifacts/repository-context.ts
 import { createHash as createHash2 } from "crypto";
 import fs5 from "fs";
-
-// ../../packages/shared/src/github-repository.ts
-var MAX_REPOSITORY_BYTES = 201;
-var UTF8_ENCODER = new TextEncoder();
-function utf8Bytes(value) {
-  return UTF8_ENCODER.encode(value).byteLength;
-}
-function githubRepositoryPath(pathname) {
-  const parts = pathname.replace(/^\/+|\/+$/g, "").split("/");
-  if (parts.length !== 2) return null;
-  const owner = parts[0];
-  const repository = parts[1]?.replace(/\.git$/i, "");
-  if (!owner || !repository) return null;
-  const segmentPattern = /^[A-Za-z0-9_.-]+$/;
-  if (!segmentPattern.test(owner) || !segmentPattern.test(repository)) {
-    return null;
-  }
-  const canonical = `${owner.toLowerCase()}/${repository.toLowerCase()}`;
-  if (canonical.startsWith("./") || canonical.startsWith("../") || repository === "." || repository === ".." || repository.toLowerCase().endsWith(".git")) {
-    return null;
-  }
-  return utf8Bytes(canonical) <= MAX_REPOSITORY_BYTES ? canonical : null;
-}
-function canonicalGitHubRepository(remote) {
-  const trimmed = remote.trim();
-  if (!trimmed || trimmed.includes("\0")) return null;
-  const scp = trimmed.match(/^git@github\.com:([^?#]+)$/i);
-  if (scp?.[1]) return githubRepositoryPath(scp[1]);
-  let url;
-  try {
-    url = new URL(trimmed);
-  } catch {
-    return null;
-  }
-  if (url.hostname.toLowerCase() !== "github.com") return null;
-  if (url.search || url.hash || url.password || url.port) return null;
-  if (url.protocol === "https:" || url.protocol === "http:") {
-    if (url.username) return null;
-  } else if (url.protocol === "ssh:") {
-    if (url.username && url.username !== "git") return null;
-  } else {
-    return null;
-  }
-  return githubRepositoryPath(url.pathname);
-}
-
-// ../../packages/agent-targets/src/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) {
+function utf8Bytes(value) {
   return Buffer.byteLength(value, "utf8");
 }
 function boundedOptionalString(value, maxBytes) {
   if (typeof value !== "string") return void 0;
   const trimmed = value.trim();
-  if (!trimmed || new RegExp("\\p{Cc}", "u").test(trimmed) || utf8Bytes2(trimmed) > maxBytes) {
+  if (!trimmed || new RegExp("\\p{Cc}", "u").test(trimmed) || utf8Bytes(trimmed) > maxBytes) {
     return void 0;
   }
   return trimmed;
@@ -755,50 +711,168 @@ var grokArtifactDiscovery = Object.freeze({
   )
 });
 
-// ../../packages/agent-targets/src/artifacts/targets/pi.ts
+// ../../packages/agent-targets/src/artifacts/targets/mini-swe-agent.ts
+import fs6 from "fs";
 import path15 from "path";
-var PI_SKIP_DIRS = /* @__PURE__ */ new Set(["subagent-artifacts"]);
-function piTranscriptCandidate(sourcePath, context) {
-  const fallbackObservedAtMs = (context.nowMs ?? Date.now)();
-  for (const record of readJsonlContextRecords(sourcePath)) {
-    if (record.type !== "session") continue;
-    const sessionId = typeof record.id === "string" && record.id.trim() ? record.id.trim() : null;
-    if (typeof record.cwd !== "string" || !record.cwd.trim()) {
-      return transcriptCandidate({
-        targetId: "pi",
-        sourcePath,
-        sessionId
-      });
+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)) {
+      throw new Error("FML_DATA_DIR must be an absolute path");
     }
-    const origin = context.resolveGitHubOrigin?.(record.cwd);
+    return path15.normalize(env.FML_DATA_DIR);
+  }
+  if (process.platform === "darwin") {
+    return path15.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 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");
+}
+function snapshotCandidate(sourcePath, context) {
+  let file;
+  try {
+    file = fs6.openSync(sourcePath, "r");
+  } catch {
+    return null;
+  }
+  try {
+    const stat = fs6.fstatSync(file);
+    if (!stat.isFile()) return null;
+    if (context.maxFileBytes !== void 0 && stat.size > context.maxFileBytes) {
+      return transcriptCandidate({ targetId: "mini-swe-agent", sourcePath });
+    }
+    const bytes = Buffer.allocUnsafe(stat.size);
+    let offset = 0;
+    while (offset < bytes.length) {
+      const read = fs6.readSync(
+        file,
+        bytes,
+        offset,
+        bytes.length - offset,
+        offset
+      );
+      if (read <= 0) return null;
+      offset += read;
+    }
+    if (fs6.fstatSync(file).size !== stat.size) return null;
+    const value = JSON.parse(bytes.toString("utf8"));
+    if (typeof value !== "object" || value === null || !("fml" in value)) {
+      return null;
+    }
+    const metadata = value.fml;
+    if (typeof metadata !== "object" || metadata === null || !("version" in metadata) || metadata.version !== 1 || !("session_id" in metadata) || typeof metadata.session_id !== "string" || !SESSION_ID_PATTERN.test(metadata.session_id)) {
+      return null;
+    }
+    const cwd = "cwd" in metadata && typeof metadata.cwd === "string" ? metadata.cwd : void 0;
+    const origin = cwd ? context.resolveGitHubOrigin?.(cwd) : null;
     return transcriptCandidate({
-      targetId: "pi",
+      targetId: "mini-swe-agent",
       sourcePath,
-      sessionId,
+      sessionId: metadata.session_id,
+      metadata: { store: "managed_snapshots" },
       repositoryObservations: origin ? [
         repositoryObservation({
           repository: origin.repository,
           source: "git_origin",
-          observedAtMs: fallbackObservedAtMs,
-          cwd: record.cwd,
+          observedAtMs: (context.nowMs ?? Date.now)(),
+          cwd,
           branch: origin.branch,
           commitHash: origin.commitHash
         })
       ] : []
     });
+  } catch {
+    return null;
+  } finally {
+    fs6.closeSync(file);
+  }
+}
+var miniSweAgentArtifactDiscovery = Object.freeze({
+  targetId: "mini-swe-agent",
+  discover: (context) => walkFiles({
+    root: path15.join(dataDirectory(context), "mini-swe-agent", "trajectories"),
+    maxDepth: 0,
+    includeFile: (filePath) => filePath.endsWith(".traj.json")
+  }).flatMap((sourcePath) => {
+    const candidate = snapshotCandidate(sourcePath, context);
+    return candidate ? [candidate] : [];
+  })
+});
+
+// ../../packages/agent-targets/src/artifacts/targets/pi.ts
+import path16 from "path";
+
+// ../../packages/agent-targets/src/artifacts/pi-repository-origin.ts
+import { z } from "zod";
+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),
+  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
+  )
+});
+var NativeOriginMarkerSchema = z.object({
+  customType: z.literal(PI_REPOSITORY_ORIGIN_ENTRY_TYPE)
+});
+var NativeOriginEntrySchema = z.object({
+  type: z.literal("custom"),
+  customType: z.literal(PI_REPOSITORY_ORIGIN_ENTRY_TYPE),
+  timestamp: z.iso.datetime({ offset: true }).transform((value) => Date.parse(value)).pipe(z.number().int().nonnegative()),
+  data: PiRepositoryOriginDataSchema
+});
+function readPiRepositoryOrigin(entries) {
+  let snapshot;
+  for (const entry of entries) {
+    if (!NativeOriginMarkerSchema.safeParse(entry).success) continue;
+    const parsed = NativeOriginEntrySchema.safeParse(entry);
+    if (!parsed.success) return { status: "invalid" };
+    const next = { ...parsed.data.data, observedAtMs: parsed.data.timestamp };
+    if (snapshot && (snapshot.repository !== next.repository || snapshot.cwd !== next.cwd || snapshot.observedAtMs !== next.observedAtMs)) {
+      return { status: "invalid" };
+    }
+    snapshot = next;
   }
-  return transcriptCandidate({ targetId: "pi", sourcePath });
+  return snapshot ? { status: "captured", snapshot } : { status: "absent" };
+}
+
+// ../../packages/agent-targets/src/artifacts/targets/pi.ts
+var PI_SKIP_DIRS = /* @__PURE__ */ new Set(["subagent-artifacts"]);
+function piTranscriptCandidate(sourcePath) {
+  const records = readJsonlContextRecords(sourcePath);
+  const header = records.find((record) => record.type === "session");
+  const sessionId = typeof header?.id === "string" && header.id.trim() ? header.id.trim() : null;
+  const evidence = readPiRepositoryOrigin(records);
+  const snapshot = evidence.status === "captured" ? evidence.snapshot : null;
+  return transcriptCandidate({
+    targetId: "pi",
+    sourcePath,
+    sessionId,
+    repositoryObservations: snapshot?.repository ? [
+      repositoryObservation({
+        repository: snapshot.repository,
+        source: "git_origin",
+        observedAtMs: snapshot.observedAtMs,
+        cwd: snapshot.cwd
+      })
+    ] : []
+  });
 }
 var piArtifactDiscovery = Object.freeze({
   targetId: "pi",
   discover: (context) => {
     const { homeDir } = context;
     return walkFiles({
-      root: path15.join(homeDir, ".pi", "agent", "sessions"),
+      root: path16.join(homeDir, ".pi", "agent", "sessions"),
       maxDepth: 8,
       includeFile: (filePath) => filePath.endsWith(".jsonl"),
       skipDirs: PI_SKIP_DIRS
-    }).map((sourcePath) => piTranscriptCandidate(sourcePath, context));
+    }).map((sourcePath) => piTranscriptCandidate(sourcePath));
   }
 });
 
@@ -809,6 +883,7 @@ var ARTIFACT_DISCOVERY_CAPABILITIES = Object.freeze([
   geminiArtifactDiscovery,
   grokArtifactDiscovery,
   piArtifactDiscovery,
+  miniSweAgentArtifactDiscovery,
   cursorArtifactDiscovery,
   copilotCliArtifactDiscovery,
   factoryDroidArtifactDiscovery
@@ -826,13 +901,13 @@ function discoverTargetArtifactCandidates(context) {
 
 // ../../packages/agent-targets/src/artifacts/materialize.ts
 import { createHash as createHash3 } from "crypto";
-import fs6 from "fs";
-import path16 from "path";
+import fs7 from "fs";
+import path17 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 = `${path16.resolve(sourcePath)}\0${stat.size}\0${Math.floor(
+  const identity = `${path17.resolve(sourcePath)}\0${stat.size}\0${Math.floor(
     stat.mtimeMs
   )}`;
   const digest = createHash3("sha256").update(identity).digest("hex");
@@ -845,7 +920,7 @@ function decodeZstd(sourcePath, maxOutputBytes) {
   const decompress = zlib.zstdDecompressSync;
   if (typeof decompress !== "function") return null;
   try {
-    return decompress(fs6.readFileSync(sourcePath), {
+    return decompress(fs7.readFileSync(sourcePath), {
       maxOutputLength: maxOutputBytes
     });
   } catch {
@@ -854,9 +929,9 @@ function decodeZstd(sourcePath, maxOutputBytes) {
 }
 function materializedArtifactPath(input) {
   try {
-    const stat = fs6.statSync(input.sourcePath);
+    const stat = fs7.statSync(input.sourcePath);
     if (!stat.isFile() || stat.size === 0) return null;
-    return path16.join(input.cacheDir, cacheEntryName(input.sourcePath, stat));
+    return path17.join(input.cacheDir, cacheEntryName(input.sourcePath, stat));
   } catch {
     return null;
   }
@@ -864,20 +939,20 @@ function materializedArtifactPath(input) {
 function materializeCompressedArtifact(input) {
   let stat;
   try {
-    stat = fs6.statSync(input.sourcePath);
+    stat = fs7.statSync(input.sourcePath);
   } catch {
     return null;
   }
   if (!stat.isFile() || stat.size === 0) return null;
-  const cachePath = path16.join(
+  const cachePath = path17.join(
     input.cacheDir,
     cacheEntryName(input.sourcePath, stat)
   );
   try {
-    if (fs6.statSync(cachePath).isFile()) {
+    if (fs7.statSync(cachePath).isFile()) {
       const now = /* @__PURE__ */ new Date();
       try {
-        fs6.utimesSync(cachePath, now, now);
+        fs7.utimesSync(cachePath, now, now);
       } catch {
       }
       return cachePath;
@@ -890,10 +965,10 @@ function materializeCompressedArtifact(input) {
   );
   if (!decoded) return null;
   try {
-    fs6.mkdirSync(input.cacheDir, { recursive: true, mode: 448 });
+    fs7.mkdirSync(input.cacheDir, { recursive: true, mode: 448 });
     const tempPath = `${cachePath}.${process.pid}.tmp`;
-    fs6.writeFileSync(tempPath, decoded, { mode: 384 });
-    fs6.renameSync(tempPath, cachePath);
+    fs7.writeFileSync(tempPath, decoded, { mode: 384 });
+    fs7.renameSync(tempPath, cachePath);
     return cachePath;
   } catch {
     return null;
@@ -903,16 +978,16 @@ function pruneMaterializedCache(input) {
   const maxTotalBytes = input.maxTotalBytes ?? DEFAULT_MATERIALIZED_CACHE_BYTES;
   let entries;
   try {
-    entries = fs6.readdirSync(input.cacheDir, { withFileTypes: true });
+    entries = fs7.readdirSync(input.cacheDir, { withFileTypes: true });
   } catch {
     return { removed: 0, retainedBytes: 0 };
   }
   const files = [];
   for (const entry of entries) {
     if (!entry.isFile()) continue;
-    const filePath = path16.join(input.cacheDir, entry.name);
+    const filePath = path17.join(input.cacheDir, entry.name);
     try {
-      const stat = fs6.statSync(filePath);
+      const stat = fs7.statSync(filePath);
       files.push({ path: filePath, size: stat.size, atimeMs: stat.atimeMs });
     } catch {
     }
@@ -927,7 +1002,7 @@ function pruneMaterializedCache(input) {
       continue;
     }
     try {
-      fs6.rmSync(file.path);
+      fs7.rmSync(file.path);
       removed += 1;
     } catch {
       retainedBytes += file.size;
@@ -939,8 +1014,8 @@ 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";
+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;
@@ -1080,7 +1155,7 @@ var PERSISTENT_ORIGIN_CACHE_SCHEMA_VERSION = 2;
 var DEFAULT_PERSISTENT_ORIGIN_CACHE_MAX_ENTRIES = 512;
 function fileContentIdentity(filePath) {
   try {
-    const contents = fs7.readFileSync(filePath);
+    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;
@@ -1089,7 +1164,7 @@ function fileContentIdentity(filePath) {
 }
 function packedRefsIdentity(filePath) {
   try {
-    const stat = fs7.statSync(filePath, { bigint: true });
+    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(
       ":"
@@ -1118,18 +1193,18 @@ function effectiveConfigIdentity(cwd) {
 }
 function readSmallText(filePath) {
   try {
-    return fs7.readFileSync(filePath, "utf8").trim();
+    return fs8.readFileSync(filePath, "utf8").trim();
   } catch {
     return null;
   }
 }
 function findGitDirectory(cwd) {
-  let current = path17.resolve(cwd);
+  let current = path18.resolve(cwd);
   for (; ; ) {
-    const candidate = path17.join(current, ".git");
+    const candidate = path18.join(current, ".git");
     let stat;
     try {
-      stat = fs7.statSync(candidate);
+      stat = fs8.statSync(candidate);
     } catch {
       stat = void 0;
     }
@@ -1140,20 +1215,20 @@ function findGitDirectory(cwd) {
       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"));
+      const gitDir = path18.resolve(current, match[1]);
+      const common = readSmallText(path18.join(gitDir, "commondir"));
       return {
         gitDir,
-        commonDir: common ? path17.resolve(gitDir, common) : gitDir
+        commonDir: common ? path18.resolve(gitDir, common) : gitDir
       };
     }
-    const parent = path17.dirname(current);
+    const parent = path18.dirname(current);
     if (parent === current) return null;
     current = parent;
   }
 }
 function checkoutSignature(layout, cwd) {
-  const headPath = path17.join(layout.gitDir, "HEAD");
+  const headPath = path18.join(layout.gitDir, "HEAD");
   const head = readSmallText(headPath);
   const configIdentity = effectiveConfigIdentity(cwd);
   if (head === null || configIdentity === null) {
@@ -1162,14 +1237,14 @@ function checkoutSignature(layout, cwd) {
   const parts = [layout.gitDir, head, configIdentity];
   const ref = /^ref:\s*(.+)$/u.exec(head)?.[1];
   if (ref) {
-    const looseRefPath = path17.join(layout.commonDir, ref);
+    const looseRefPath = path18.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")
+      path18.join(layout.commonDir, "packed-refs")
     );
     const reftableIdentity = fileContentIdentity(
-      path17.join(layout.commonDir, "reftable", "tables.list")
+      path18.join(layout.commonDir, "reftable", "tables.list")
     );
     if (!looseRefIdentity || !packedIdentity || !reftableIdentity || looseRefIdentity === "missing" && packedIdentity === "missing" && reftableIdentity === "missing") {
       return null;
@@ -1180,7 +1255,7 @@ function checkoutSignature(layout, cwd) {
 }
 function readPersistentOriginCache(cacheFile) {
   try {
-    const parsed = JSON.parse(fs7.readFileSync(cacheFile, "utf8"));
+    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;
     }
@@ -1191,13 +1266,13 @@ function readPersistentOriginCache(cacheFile) {
 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)}
+    fs8.mkdirSync(path18.dirname(cacheFile), { recursive: true, mode: 448 });
+    fs8.writeFileSync(temporary, `${JSON.stringify(cache)}
 `, { mode: 384 });
-    fs7.renameSync(temporary, cacheFile);
+    fs8.renameSync(temporary, cacheFile);
   } catch {
     try {
-      fs7.rmSync(temporary, { force: true });
+      fs8.rmSync(temporary, { force: true });
     } catch {
     }
   }
@@ -1285,20 +1360,20 @@ function isAbortError(error) {
 }
 function safeStat(filePath) {
   try {
-    return fs8.statSync(filePath);
+    return fs9.statSync(filePath);
   } catch {
     return null;
   }
 }
 function normalizeFilePath2(filePath) {
-  return path18.resolve(filePath);
+  return path19.resolve(filePath);
 }
 function artifactReadPath(artifact) {
   return normalizeFilePath2(artifact.readPath ?? artifact.sourcePath);
 }
 function statCandidateSource(sourcePath, transientStatErrors) {
   try {
-    return fs8.statSync(sourcePath);
+    return fs9.statSync(sourcePath);
   } catch (error) {
     if (error.code === "ENOENT") return null;
     if (transientStatErrors === "throw") throw error;
@@ -1306,7 +1381,7 @@ function statCandidateSource(sourcePath, transientStatErrors) {
   }
 }
 function contentTypeForPath(filePath) {
-  const ext = path18.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";
@@ -1349,13 +1424,14 @@ function discoverArtifacts(options = {}) {
     };
   }
   const homeDir = normalizeFilePath2(homeDirInput);
+  const maxBytes = options.maxFileBytes ?? DEFAULT_MAX_ARTIFACT_BYTES;
   const candidates = discoverTargetArtifactCandidates({
     homeDir,
     env,
+    maxFileBytes: maxBytes,
     resolveGitHubOrigin: repositoryResolution.resolve,
     ...options.materializeArtifact ? { materializeArtifact: options.materializeArtifact } : {}
   });
-  const maxBytes = options.maxFileBytes ?? DEFAULT_MAX_ARTIFACT_BYTES;
   const byKey = /* @__PURE__ */ new Map();
   const oversizedByKey = /* @__PURE__ */ new Map();
   for (const candidate of candidates) {
@@ -1418,7 +1494,7 @@ function readUploadThrottles(value) {
 }
 function readArtifactQueue(queueFile) {
   try {
-    const parsed = JSON.parse(fs8.readFileSync(queueFile, "utf8"));
+    const parsed = JSON.parse(fs9.readFileSync(queueFile, "utf8"));
     if (!parsed || typeof parsed !== "object") return emptyQueue();
     const record = parsed;
     if (record.schemaVersion !== RAW_ARTIFACT_SCHEMA_VERSION) {
@@ -1435,15 +1511,15 @@ function readArtifactQueue(queueFile) {
   }
 }
 function writeArtifactQueue(queueFile, queue) {
-  fs8.mkdirSync(path18.dirname(queueFile), { recursive: true, mode: 448 });
+  fs9.mkdirSync(path19.dirname(queueFile), { recursive: true, mode: 448 });
   const tempFile = `${queueFile}.${process.pid}.${Date.now()}.tmp`;
-  fs8.writeFileSync(tempFile, `${JSON.stringify(queue, null, 2)}
+  fs9.writeFileSync(tempFile, `${JSON.stringify(queue, null, 2)}
 `, {
     mode: 384
   });
-  fs8.renameSync(tempFile, queueFile);
+  fs9.renameSync(tempFile, queueFile);
   try {
-    fs8.chmodSync(queueFile, 384);
+    fs9.chmodSync(queueFile, 384);
   } catch {
   }
 }
@@ -1460,11 +1536,20 @@ function nextGenerationStartedAtMs(nowMs, existing) {
   return existing ? Math.max(nowMs, existing.generationStartedAtMs + 1) : nowMs;
 }
 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;
+      } catch {
+      }
+    }
+    return input.nextSizeBytes !== input.existing.sizeBytes || input.nextMtimeMs !== input.existing.mtimeMs;
+  }
   if (input.nextSizeBytes < input.existing.uploadedSizeBytes) return true;
   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(fs8.readFileSync(input.nextReadPath)).digest("hex");
+      const contentSha256 = createHash5("sha256").update(fs9.readFileSync(input.nextReadPath)).digest("hex");
       if (contentSha256 === input.existing.contentSha256) return false;
     } catch {
     }
@@ -1583,7 +1668,7 @@ function metadataForGeneration(input) {
     ...repositoryContext ? { repositoryContext } : {}
   };
 }
-function snapshotCandidate(candidate, existing, nowMs, maxFileBytes, transientStatErrors = "ignore", observerIdentity) {
+function snapshotCandidate2(candidate, existing, nowMs, maxFileBytes, transientStatErrors = "ignore", observerIdentity) {
   const sourcePath = normalizeFilePath2(candidate.sourcePath);
   const readPath = artifactReadPath(candidate);
   const stat = statCandidateSource(readPath, transientStatErrors);
@@ -1727,7 +1812,7 @@ function snapshotArtifactsLocked(options, lock) {
       throw new Error("artifact queue lock ownership was lost");
     }
     const existing = (candidate.identityKey ? entriesByIdentityKey.get(candidate.identityKey) : void 0) ?? entriesByKey.get(buildArtifactKey(candidate));
-    const snapshot = snapshotCandidate(
+    const snapshot = snapshotCandidate2(
       candidate,
       existing,
       nowMs,
@@ -1798,7 +1883,7 @@ function sameSourceRevision(left, right) {
 }
 function safeSourceRevision(filePath) {
   try {
-    const stat = fs8.statSync(filePath, { bigint: true });
+    const stat = fs9.statSync(filePath, { bigint: true });
     return stat.isFile() ? sourceRevisionFromStat(stat) : null;
   } catch {
     return null;
@@ -1810,7 +1895,7 @@ function readExactRange(fd, startByte, endByte) {
   const buffer = Buffer.alloc(sizeBytes);
   let offset = 0;
   while (offset < sizeBytes) {
-    const bytesRead = fs8.readSync(
+    const bytesRead = fs9.readSync(
       fd,
       buffer,
       offset,
@@ -1829,19 +1914,19 @@ function readFileRangeAtRevision(filePath, startByte, endByte, expectedRevision)
   }
   let fd;
   try {
-    fd = fs8.openSync(filePath, "r");
+    fd = fs9.openSync(filePath, "r");
   } catch {
     return null;
   }
   try {
     const openedRevision = sourceRevisionFromStat(
-      fs8.fstatSync(fd, { bigint: true })
+      fs9.fstatSync(fd, { bigint: true })
     );
     if (!sameSourceRevision(pathRevisionBefore, openedRevision)) return null;
     const bytes = readExactRange(fd, startByte, endByte);
     if (!bytes) return null;
     const revisionAfterRead = sourceRevisionFromStat(
-      fs8.fstatSync(fd, { bigint: true })
+      fs9.fstatSync(fd, { bigint: true })
     );
     const pathRevisionAfter = safeSourceRevision(filePath);
     if (!sameSourceRevision(openedRevision, revisionAfterRead) || !pathRevisionAfter || !sameSourceRevision(openedRevision, pathRevisionAfter)) {
@@ -1851,7 +1936,7 @@ function readFileRangeAtRevision(filePath, startByte, endByte, expectedRevision)
   } catch {
     return null;
   } finally {
-    fs8.closeSync(fd);
+    fs9.closeSync(fd);
   }
 }
 function uploadMetadata(input) {
@@ -1983,13 +2068,13 @@ function validateCheckpointPrefix(input) {
   }
   let fd;
   try {
-    fd = fs8.openSync(input.sourcePath, "r");
+    fd = fs9.openSync(input.sourcePath, "r");
   } catch {
     return { status: "changed" };
   }
   try {
     const openedRevision = sourceRevisionFromStat(
-      fs8.fstatSync(fd, { bigint: true })
+      fs9.fstatSync(fd, { bigint: true })
     );
     if (!sameSourceRevision(pathRevisionBefore, openedRevision)) {
       return { status: "changed" };
@@ -2009,7 +2094,7 @@ function validateCheckpointPrefix(input) {
       contentHash.update(chunk);
     }
     const revisionAfterRead = sourceRevisionFromStat(
-      fs8.fstatSync(fd, { bigint: true })
+      fs9.fstatSync(fd, { bigint: true })
     );
     const pathRevisionAfter = safeSourceRevision(input.sourcePath);
     if (!sameSourceRevision(openedRevision, revisionAfterRead) || !pathRevisionAfter || !sameSourceRevision(openedRevision, pathRevisionAfter)) {
@@ -2024,7 +2109,7 @@ function validateCheckpointPrefix(input) {
   } catch {
     return { status: "changed" };
   } finally {
-    fs8.closeSync(fd);
+    fs9.closeSync(fd);
   }
 }
 function validatedPrefixStillApplies(prefix, entry, uploadDestinationId, revision) {
@@ -2158,14 +2243,14 @@ function defaultIsPidAlive(pid) {
 }
 function readQueueLockHolder(lockFile) {
   try {
-    const parsed = JSON.parse(fs8.readFileSync(lockFile, "utf8"));
+    const parsed = JSON.parse(fs9.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, fs8.statSync(lockFile).mtimeMs) : record.timestampMs;
+    const timestampMs = ownerToken ? Math.max(record.timestampMs, fs9.statSync(lockFile).mtimeMs) : record.timestampMs;
     return { pid: record.pid, timestampMs, ownerToken };
   } catch {
     return null;
@@ -2173,8 +2258,8 @@ function readQueueLockHolder(lockFile) {
 }
 function queueLockFileMatchesOwner(lockFile, fd, ownerToken) {
   try {
-    const openStat = fs8.fstatSync(fd);
-    const pathStat = fs8.statSync(lockFile);
+    const openStat = fs9.fstatSync(fd);
+    const pathStat = fs9.statSync(lockFile);
     if (openStat.dev !== pathStat.dev || openStat.ino !== pathStat.ino) {
       return false;
     }
@@ -2185,14 +2270,14 @@ function queueLockFileMatchesOwner(lockFile, fd, ownerToken) {
 }
 function acquireQueueLock(queueFile, deps) {
   const lockFile = queueLockFile(queueFile);
-  fs8.mkdirSync(path18.dirname(lockFile), { recursive: true, mode: 448 });
+  fs9.mkdirSync(path19.dirname(lockFile), { recursive: true, mode: 448 });
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      const fd = fs8.openSync(lockFile, "wx+", 384);
+      const fd = fs9.openSync(lockFile, "wx+", 384);
       const ownerToken = randomUUID3();
       let released = false;
       try {
-        fs8.writeSync(
+        fs9.writeSync(
           fd,
           `${JSON.stringify({
             pid: process.pid,
@@ -2202,11 +2287,11 @@ function acquireQueueLock(queueFile, deps) {
 `
         );
         const heartbeatAt = new Date(deps.nowMs());
-        fs8.futimesSync(fd, heartbeatAt, heartbeatAt);
+        fs9.futimesSync(fd, heartbeatAt, heartbeatAt);
       } catch (error) {
-        fs8.closeSync(fd);
+        fs9.closeSync(fd);
         try {
-          fs8.unlinkSync(lockFile);
+          fs9.unlinkSync(lockFile);
         } catch {
         }
         throw error;
@@ -2214,7 +2299,7 @@ function acquireQueueLock(queueFile, deps) {
       const close = () => {
         if (released) return;
         released = true;
-        fs8.closeSync(fd);
+        fs9.closeSync(fd);
       };
       return {
         heartbeat() {
@@ -2223,7 +2308,7 @@ function acquireQueueLock(queueFile, deps) {
             return false;
           try {
             const heartbeatAt = new Date(deps.nowMs());
-            fs8.futimesSync(fd, heartbeatAt, heartbeatAt);
+            fs9.futimesSync(fd, heartbeatAt, heartbeatAt);
             return true;
           } catch {
             return false;
@@ -2233,7 +2318,7 @@ function acquireQueueLock(queueFile, deps) {
           if (released) return;
           if (queueLockFileMatchesOwner(lockFile, fd, ownerToken)) {
             try {
-              fs8.unlinkSync(lockFile);
+              fs9.unlinkSync(lockFile);
             } catch {
             }
           }
@@ -2246,7 +2331,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 {
-        fs8.unlinkSync(lockFile);
+        fs9.unlinkSync(lockFile);
       } catch {
       }
     }
@@ -2304,7 +2389,7 @@ async function postRawArtifact(url, metadata, content, headers, fetchImpl = fetc
   form.append(
     "file",
     new Blob([new Uint8Array(content)], { type: metadata.contentType }),
-    path18.basename(metadata.sourcePath) || "raw-artifact"
+    path19.basename(metadata.sourcePath) || "raw-artifact"
   );
   const abort = new AbortController();
   const timeout = setTimeout(() => abort.abort(), timeoutMs);
@@ -2663,7 +2748,7 @@ async function uploadPendingArtifactsLocked(options, run) {
       let sourceRefreshesThisAttempt = 0;
       let validatedPrefix;
       const refreshSourceSnapshot = () => {
-        const snapshot = snapshotCandidate(
+        const snapshot = snapshotCandidate2(
           {
             artifactType: current.artifactType,
             source: current.source,
@@ -3193,11 +3278,11 @@ async function uploadPendingArtifactsLocked(options, run) {
 }
 
 // ../../packages/panopticon/src/raw-sync.ts
-import fs10 from "fs";
-import path19 from "path";
+import fs11 from "fs";
+import path20 from "path";
 
 // ../../packages/panopticon/src/artifact-materializer.ts
-import fs9 from "fs";
+import fs10 from "fs";
 function entryNeedsBytes(entry, amendmentPending) {
   if (entry.uploadedSizeBytes < entry.sizeBytes) return true;
   return amendmentPending(entry);
@@ -3212,7 +3297,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 = fs9.statSync(cachePath);
+      const stat = fs10.statSync(cachePath);
       if (!stat.isFile()) return false;
       if (!retained.has(cachePath)) {
         retained.add(cachePath);
@@ -3260,20 +3345,20 @@ function getRawArtifactSyncPaths(stateDir) {
   if (stateDir.length === 0) {
     throw new Error("raw artifact sync state directory must not be empty");
   }
-  const root = path19.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: path19.join(root, "discovery.cache.json"),
-    githubOriginCacheFile: path19.join(root, "github-origins.cache.json")
+    discoveryCacheFile: path20.join(root, "discovery.cache.json"),
+    githubOriginCacheFile: path20.join(root, "github-origins.cache.json")
   };
 }
 function invalidateRawArtifactDiscoveryCache(stateDir) {
   try {
-    fs10.rmSync(getRawArtifactSyncPaths(stateDir).discoveryCacheFile, {
+    fs11.rmSync(getRawArtifactSyncPaths(stateDir).discoveryCacheFile, {
       force: true
     });
   } catch {
@@ -3382,7 +3467,7 @@ function createRawArtifactSync(options) {
     if (reuseMs <= 0) return null;
     try {
       const parsed = JSON.parse(
-        fs10.readFileSync(paths.discoveryCacheFile, "utf8")
+        fs11.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;
@@ -3398,11 +3483,11 @@ function createRawArtifactSync(options) {
     if ((options.discoveryReuseMs ?? 0) <= 0) return;
     const temporary = `${paths.discoveryCacheFile}.${process.pid}.tmp`;
     try {
-      fs10.mkdirSync(path19.dirname(paths.discoveryCacheFile), {
+      fs11.mkdirSync(path20.dirname(paths.discoveryCacheFile), {
         recursive: true,
         mode: 448
       });
-      fs10.writeFileSync(
+      fs11.writeFileSync(
         temporary,
         `${JSON.stringify({
           schemaVersion: DISCOVERY_CACHE_SCHEMA_VERSION,
@@ -3413,10 +3498,10 @@ function createRawArtifactSync(options) {
 `,
         { mode: 384 }
       );
-      fs10.renameSync(temporary, paths.discoveryCacheFile);
+      fs11.renameSync(temporary, paths.discoveryCacheFile);
     } catch {
       try {
-        fs10.rmSync(temporary, { force: true });
+        fs11.rmSync(temporary, { force: true });
       } catch {
       }
     }