@iroaxel/arcena 4.3.157

package/dist/pixel-fix-UIPF4UIQ.js

@@ -0,0 +1,941 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  DEFAULT_INGEST_URL,
+  source_default
+} from "./chunk-YKKUCYNE.js";
+import {
+  init_esm_shims
+} from "./chunk-YNWFCUMR.js";
+
+// ../ggcoder/dist/core/pixel-fix.js
+init_esm_shims();
+import { spawn } from "child_process";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+
+// ../ggcoder/dist/core/pixel-fix-agent.js
+init_esm_shims();
+var PIXEL_FIX_SYSTEM_PROMPT = `You are the gg-pixel fix agent \u2014 a non-interactive coding agent invoked by the gg-pixel fix-queue runner.
+
+Your single job for this session is to fix the one specific error described in the user message. You do not chat. You do not ask questions. You investigate, fix, commit, stop.
+
+# Identity
+- You are NOT the regular arcicoder interactive assistant.
+- You are a one-shot fix worker. Your work will be reviewed by a human after you stop.
+- Be terse. Don't narrate your reasoning unless it materially affects the fix.
+
+# Required workflow
+1. Read the error in the user message (type, message, file:line, code window, stack).
+2. Use your tools (read, grep, find, edit, bash) to investigate. Prefer reading the exact file:line referenced in the error first.
+3. Make the smallest fix that resolves the actual error. Do not refactor surrounding code, do not improve unrelated things, do not add tests unless the error is in a test.
+4. Create the git branch named in the user message. Do NOT switch back to main afterward.
+5. Commit your changes on that branch with a clear message.
+6. If the project has quality checks (\`pnpm check\`, \`pnpm test\`, \`pytest\`, \`cargo check\`, etc.), run them. Only commit if they pass \u2014 if checks fail, fix and retry, do not commit broken code.
+7. Stop. The runner will inspect git state and mark the result.
+
+# Hard rules
+- Do NOT merge. Do NOT push. Do NOT open a PR.
+- Do NOT switch back to main/master after committing on the fix branch.
+- Do NOT mark the error status yourself \u2014 the runner observes git state and updates status.
+- If you cannot fix the error (genuinely stuck, missing context, ambiguous), commit nothing and stop. The runner will mark it as failed; a human will look.
+
+# Recurrence signal
+If the user message says "Recurrence: Nth time", the previous fix did not hold. Investigate why before patching again \u2014 a quick re-patch is likely to regress.`;
+
+// ../ggcoder/dist/core/source-maps.js
+init_esm_shims();
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { dirname, join, posix } from "path";
+
+// ../../node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
+init_esm_shims();
+
+// ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+init_esm_shims();
+var comma = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+  const c = chars.charCodeAt(i);
+  intToChar[i] = c;
+  charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+  let value = 0;
+  let shift = 0;
+  let integer = 0;
+  do {
+    const c = reader.next();
+    integer = charToInt[c];
+    value |= (integer & 31) << shift;
+    shift += 5;
+  } while (integer & 32);
+  const shouldNegate = value & 1;
+  value >>>= 1;
+  if (shouldNegate) {
+    value = -2147483648 | -value;
+  }
+  return relative + value;
+}
+function hasMoreVlq(reader, max) {
+  if (reader.pos >= max) return false;
+  return reader.peek() !== comma;
+}
+var bufLength = 1024 * 16;
+var StringReader = class {
+  constructor(buffer) {
+    this.pos = 0;
+    this.buffer = buffer;
+  }
+  next() {
+    return this.buffer.charCodeAt(this.pos++);
+  }
+  peek() {
+    return this.buffer.charCodeAt(this.pos);
+  }
+  indexOf(char) {
+    const { buffer, pos } = this;
+    const idx = buffer.indexOf(char, pos);
+    return idx === -1 ? buffer.length : idx;
+  }
+};
+function decode(mappings) {
+  const { length } = mappings;
+  const reader = new StringReader(mappings);
+  const decoded = [];
+  let genColumn = 0;
+  let sourcesIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let namesIndex = 0;
+  do {
+    const semi = reader.indexOf(";");
+    const line = [];
+    let sorted = true;
+    let lastCol = 0;
+    genColumn = 0;
+    while (reader.pos < semi) {
+      let seg;
+      genColumn = decodeInteger(reader, genColumn);
+      if (genColumn < lastCol) sorted = false;
+      lastCol = genColumn;
+      if (hasMoreVlq(reader, semi)) {
+        sourcesIndex = decodeInteger(reader, sourcesIndex);
+        sourceLine = decodeInteger(reader, sourceLine);
+        sourceColumn = decodeInteger(reader, sourceColumn);
+        if (hasMoreVlq(reader, semi)) {
+          namesIndex = decodeInteger(reader, namesIndex);
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+        } else {
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+        }
+      } else {
+        seg = [genColumn];
+      }
+      line.push(seg);
+      reader.pos++;
+    }
+    if (!sorted) sort(line);
+    decoded.push(line);
+    reader.pos = semi + 1;
+  } while (reader.pos <= length);
+  return decoded;
+}
+function sort(line) {
+  line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+  return a[0] - b[0];
+}
+
+// ../../node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
+init_esm_shims();
+var schemeRegex = /^[\w+.-]+:\/\//;
+var urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+var fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+function isAbsoluteUrl(input) {
+  return schemeRegex.test(input);
+}
+function isSchemeRelativeUrl(input) {
+  return input.startsWith("//");
+}
+function isAbsolutePath(input) {
+  return input.startsWith("/");
+}
+function isFileUrl(input) {
+  return input.startsWith("file:");
+}
+function isRelative(input) {
+  return /^[.?#]/.test(input);
+}
+function parseAbsoluteUrl(input) {
+  const match = urlRegex.exec(input);
+  return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
+}
+function parseFileUrl(input) {
+  const match = fileRegex.exec(input);
+  const path = match[2];
+  return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path) ? path : "/" + path, match[3] || "", match[4] || "");
+}
+function makeUrl(scheme, user, host, port, path, query, hash) {
+  return {
+    scheme,
+    user,
+    host,
+    port,
+    path,
+    query,
+    hash,
+    type: 7
+  };
+}
+function parseUrl(input) {
+  if (isSchemeRelativeUrl(input)) {
+    const url2 = parseAbsoluteUrl("http:" + input);
+    url2.scheme = "";
+    url2.type = 6;
+    return url2;
+  }
+  if (isAbsolutePath(input)) {
+    const url2 = parseAbsoluteUrl("http://foo.com" + input);
+    url2.scheme = "";
+    url2.host = "";
+    url2.type = 5;
+    return url2;
+  }
+  if (isFileUrl(input))
+    return parseFileUrl(input);
+  if (isAbsoluteUrl(input))
+    return parseAbsoluteUrl(input);
+  const url = parseAbsoluteUrl("http://foo.com/" + input);
+  url.scheme = "";
+  url.host = "";
+  url.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1;
+  return url;
+}
+function stripPathFilename(path) {
+  if (path.endsWith("/.."))
+    return path;
+  const index = path.lastIndexOf("/");
+  return path.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+  normalizePath(base, base.type);
+  if (url.path === "/") {
+    url.path = base.path;
+  } else {
+    url.path = stripPathFilename(base.path) + url.path;
+  }
+}
+function normalizePath(url, type) {
+  const rel = type <= 4;
+  const pieces = url.path.split("/");
+  let pointer = 1;
+  let positive = 0;
+  let addTrailingSlash = false;
+  for (let i = 1; i < pieces.length; i++) {
+    const piece = pieces[i];
+    if (!piece) {
+      addTrailingSlash = true;
+      continue;
+    }
+    addTrailingSlash = false;
+    if (piece === ".")
+      continue;
+    if (piece === "..") {
+      if (positive) {
+        addTrailingSlash = true;
+        positive--;
+        pointer--;
+      } else if (rel) {
+        pieces[pointer++] = piece;
+      }
+      continue;
+    }
+    pieces[pointer++] = piece;
+    positive++;
+  }
+  let path = "";
+  for (let i = 1; i < pointer; i++) {
+    path += "/" + pieces[i];
+  }
+  if (!path || addTrailingSlash && !path.endsWith("/..")) {
+    path += "/";
+  }
+  url.path = path;
+}
+function resolve(input, base) {
+  if (!input && !base)
+    return "";
+  const url = parseUrl(input);
+  let inputType = url.type;
+  if (base && inputType !== 7) {
+    const baseUrl = parseUrl(base);
+    const baseType = baseUrl.type;
+    switch (inputType) {
+      case 1:
+        url.hash = baseUrl.hash;
+      // fall through
+      case 2:
+        url.query = baseUrl.query;
+      // fall through
+      case 3:
+      case 4:
+        mergePaths(url, baseUrl);
+      // fall through
+      case 5:
+        url.user = baseUrl.user;
+        url.host = baseUrl.host;
+        url.port = baseUrl.port;
+      // fall through
+      case 6:
+        url.scheme = baseUrl.scheme;
+    }
+    if (baseType > inputType)
+      inputType = baseType;
+  }
+  normalizePath(url, inputType);
+  const queryHash = url.query + url.hash;
+  switch (inputType) {
+    // This is impossible, because of the empty checks at the start of the function.
+    // case UrlType.Empty:
+    case 2:
+    case 3:
+      return queryHash;
+    case 4: {
+      const path = url.path.slice(1);
+      if (!path)
+        return queryHash || ".";
+      if (isRelative(base || input) && !isRelative(path)) {
+        return "./" + path + queryHash;
+      }
+      return path + queryHash;
+    }
+    case 5:
+      return url.path + queryHash;
+    default:
+      return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
+  }
+}
+
+// ../../node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
+function stripFilename(path) {
+  if (!path) return "";
+  const index = path.lastIndexOf("/");
+  return path.slice(0, index + 1);
+}
+function resolver(mapUrl, sourceRoot) {
+  const from = stripFilename(mapUrl);
+  const prefix = sourceRoot ? sourceRoot + "/" : "";
+  return (source) => resolve(prefix + (source || ""), from);
+}
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+function maybeSort(mappings, owned) {
+  const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+  if (unsortedIndex === mappings.length) return mappings;
+  if (!owned) mappings = mappings.slice();
+  for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
+    mappings[i] = sortSegments(mappings[i], owned);
+  }
+  return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+  for (let i = start; i < mappings.length; i++) {
+    if (!isSorted(mappings[i])) return i;
+  }
+  return mappings.length;
+}
+function isSorted(line) {
+  for (let j = 1; j < line.length; j++) {
+    if (line[j][COLUMN] < line[j - 1][COLUMN]) {
+      return false;
+    }
+  }
+  return true;
+}
+function sortSegments(line, owned) {
+  if (!owned) line = line.slice();
+  return line.sort(sortComparator2);
+}
+function sortComparator2(a, b) {
+  return a[COLUMN] - b[COLUMN];
+}
+var found = false;
+function binarySearch(haystack, needle, low, high) {
+  while (low <= high) {
+    const mid = low + (high - low >> 1);
+    const cmp = haystack[mid][COLUMN] - needle;
+    if (cmp === 0) {
+      found = true;
+      return mid;
+    }
+    if (cmp < 0) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  found = false;
+  return low - 1;
+}
+function upperBound(haystack, needle, index) {
+  for (let i = index + 1; i < haystack.length; index = i++) {
+    if (haystack[i][COLUMN] !== needle) break;
+  }
+  return index;
+}
+function lowerBound(haystack, needle, index) {
+  for (let i = index - 1; i >= 0; index = i--) {
+    if (haystack[i][COLUMN] !== needle) break;
+  }
+  return index;
+}
+function memoizedState() {
+  return {
+    lastKey: -1,
+    lastNeedle: -1,
+    lastIndex: -1
+  };
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+  const { lastKey, lastNeedle, lastIndex } = state;
+  let low = 0;
+  let high = haystack.length - 1;
+  if (key === lastKey) {
+    if (needle === lastNeedle) {
+      found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+      return lastIndex;
+    }
+    if (needle >= lastNeedle) {
+      low = lastIndex === -1 ? 0 : lastIndex;
+    } else {
+      high = lastIndex;
+    }
+  }
+  state.lastKey = key;
+  state.lastNeedle = needle;
+  return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+function parse(map) {
+  return typeof map === "string" ? JSON.parse(map) : map;
+}
+var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+var LEAST_UPPER_BOUND = -1;
+var GREATEST_LOWER_BOUND = 1;
+var TraceMap = class {
+  constructor(map, mapUrl) {
+    const isString = typeof map === "string";
+    if (!isString && map._decodedMemo) return map;
+    const parsed = parse(map);
+    const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+    this.version = version;
+    this.file = file;
+    this.names = names || [];
+    this.sourceRoot = sourceRoot;
+    this.sources = sources;
+    this.sourcesContent = sourcesContent;
+    this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
+    const resolve2 = resolver(mapUrl, sourceRoot);
+    this.resolvedSources = sources.map(resolve2);
+    const { mappings } = parsed;
+    if (typeof mappings === "string") {
+      this._encoded = mappings;
+      this._decoded = void 0;
+    } else if (Array.isArray(mappings)) {
+      this._encoded = void 0;
+      this._decoded = maybeSort(mappings, isString);
+    } else if (parsed.sections) {
+      throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
+    } else {
+      throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
+    }
+    this._decodedMemo = memoizedState();
+    this._bySources = void 0;
+    this._bySourceMemos = void 0;
+  }
+};
+function cast(map) {
+  return map;
+}
+function decodedMappings(map) {
+  var _a;
+  return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+}
+function originalPositionFor(map, needle) {
+  let { line, column, bias } = needle;
+  line--;
+  if (line < 0) throw new Error(LINE_GTR_ZERO);
+  if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+  const decoded = decodedMappings(map);
+  if (line >= decoded.length) return OMapping(null, null, null, null);
+  const segments = decoded[line];
+  const index = traceSegmentInternal(
+    segments,
+    cast(map)._decodedMemo,
+    line,
+    column,
+    bias || GREATEST_LOWER_BOUND
+  );
+  if (index === -1) return OMapping(null, null, null, null);
+  const segment = segments[index];
+  if (segment.length === 1) return OMapping(null, null, null, null);
+  const { names, resolvedSources } = map;
+  return OMapping(
+    resolvedSources[segment[SOURCES_INDEX]],
+    segment[SOURCE_LINE] + 1,
+    segment[SOURCE_COLUMN],
+    segment.length === 5 ? names[segment[NAMES_INDEX]] : null
+  );
+}
+function OMapping(source, line, column, name) {
+  return { source, line, column, name };
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+  let index = memoizedBinarySearch(segments, column, memo, line);
+  if (found) {
+    index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+  } else if (bias === LEAST_UPPER_BOUND) index++;
+  if (index === -1 || index === segments.length) return -1;
+  return index;
+}
+
+// ../ggcoder/dist/core/source-maps.js
+var COMMON_BUILD_DIRS = ["dist", "build", ".next", "out", "public", ".vite"];
+var MAX_DEPTH = 4;
+var SourceMapResolver = class {
+  projectDir;
+  cache = /* @__PURE__ */ new Map();
+  constructor(projectDir) {
+    this.projectDir = projectDir;
+  }
+  /**
+   * Resolve a minified stack into the original source. Frames that can't
+   * be resolved are returned unchanged so the caller still sees something.
+   */
+  resolveStack(stack) {
+    return stack.map((f) => this.resolveFrame(f));
+  }
+  resolveFrame(frame) {
+    const minifiedName = filenameFromUrl(frame.file);
+    if (!minifiedName)
+      return frame;
+    const entry = this.findMap(minifiedName);
+    if (!entry)
+      return frame;
+    let resolved;
+    try {
+      resolved = originalPositionFor(entry.trace, { line: frame.line, column: frame.col });
+    } catch {
+      return frame;
+    }
+    if (!resolved.source)
+      return frame;
+    const sourceAbs = posix.normalize(posix.join(entry.mapDir, resolved.source));
+    return {
+      file: sourceAbs,
+      line: resolved.line ?? frame.line,
+      col: resolved.column ?? frame.col,
+      fn: resolved.name || frame.fn,
+      in_app: !sourceAbs.includes("/node_modules/") && !sourceAbs.startsWith("webpack:///")
+    };
+  }
+  findMap(minifiedName) {
+    const cached = this.cache.get(minifiedName);
+    if (cached !== void 0)
+      return cached;
+    const result = this.searchForMap(minifiedName);
+    this.cache.set(minifiedName, result);
+    return result;
+  }
+  searchForMap(minifiedName) {
+    for (const dir of COMMON_BUILD_DIRS) {
+      const root = join(this.projectDir, dir);
+      if (!existsSync(root))
+        continue;
+      const found2 = walkForMap(root, minifiedName, MAX_DEPTH);
+      if (found2)
+        return loadMap(found2);
+    }
+    const rootCandidate = join(this.projectDir, minifiedName + ".map");
+    if (existsSync(rootCandidate))
+      return loadMap(rootCandidate);
+    return null;
+  }
+};
+function filenameFromUrl(file) {
+  if (!file)
+    return null;
+  const cleaned = file.split("?")[0].split("#")[0];
+  const last = cleaned.split("/").pop();
+  return last || null;
+}
+function walkForMap(root, minifiedName, depth) {
+  const target = minifiedName + ".map";
+  const direct = join(root, target);
+  if (existsSync(direct))
+    return direct;
+  if (depth <= 0)
+    return null;
+  let entries;
+  try {
+    entries = readdirSync(root);
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    if (entry.startsWith("."))
+      continue;
+    const child = join(root, entry);
+    if (!isDirectorySafe(child))
+      continue;
+    const found2 = walkForMap(child, minifiedName, depth - 1);
+    if (found2)
+      return found2;
+  }
+  return null;
+}
+function isDirectorySafe(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function loadMap(mapPath) {
+  try {
+    const raw = readFileSync(mapPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return { trace: new TraceMap(parsed), mapDir: dirname(mapPath) };
+  } catch {
+    return null;
+  }
+}
+function tryResolveStack(stack, projectDir) {
+  try {
+    const resolver2 = new SourceMapResolver(projectDir);
+    return resolver2.resolveStack(stack);
+  } catch {
+    return stack;
+  }
+}
+
+// ../ggcoder/dist/core/pixel-fix.js
+async function fixError(errorId, opts = {}) {
+  const ingestUrl = (opts.ingestUrl ?? DEFAULT_INGEST_URL).replace(/\/+$/, "");
+  const fetchFn = opts.fetchFn ?? fetch;
+  const home = opts.homeDir ?? homedir();
+  const owner = await resolveErrorOwner(fetchFn, ingestUrl, errorId, home);
+  const { error, project, secret } = owner;
+  const branch = `fix/pixel-${error.id}`;
+  await patchError(fetchFn, ingestUrl, error.id, { status: "in_progress", branch }, secret);
+  const exitCode = await runAgent({
+    cwd: project.path,
+    prompt: buildAgentPrompt(error, branch, project.path),
+    systemPrompt: PIXEL_FIX_SYSTEM_PROMPT,
+    spawnFn: opts.spawnFn ?? spawn,
+    ggcoderBin: opts.ggcoderBin ?? "arcicoder",
+    inheritStdio: opts.inheritStdio ?? true,
+    maxTurns: opts.maxTurns ?? 60
+  });
+  const observed = await observeOutcome(project.path, branch, opts.spawnFn ?? spawn);
+  let outcome;
+  let reason;
+  if (exitCode !== 0) {
+    outcome = "failed";
+    reason = `Agent exited with code ${exitCode}`;
+  } else if (!observed.branchExists) {
+    outcome = "failed";
+    reason = `Branch ${branch} was not created`;
+  } else if (!observed.hasCommits) {
+    outcome = "failed";
+    reason = `Branch ${branch} has no new commits`;
+  } else {
+    outcome = "awaiting_review";
+    reason = `Branch ${branch} created with ${observed.commitCount} commit(s) \u2014 ready for review`;
+  }
+  await patchError(fetchFn, ingestUrl, error.id, { status: outcome, branch }, secret);
+  return { errorId: error.id, projectName: project.name, branch, outcome, reason };
+}
+async function runQueue(opts = {}) {
+  const ingestUrl = (opts.ingestUrl ?? DEFAULT_INGEST_URL).replace(/\/+$/, "");
+  const fetchFn = opts.fetchFn ?? fetch;
+  const home = opts.homeDir ?? homedir();
+  const log = opts.onProgress ?? ((msg) => console.log(msg));
+  const projectsPath = join2(home, ".gg", "projects.json");
+  if (!existsSync2(projectsPath)) {
+    log(source_default.dim("No projects registered. Run `arcicoder pixel install` first."));
+    return { fixed: 0, failed: 0, total: 0 };
+  }
+  const projects = JSON.parse(readFileSync2(projectsPath, "utf8"));
+  const queue = [];
+  for (const [projectId, project] of Object.entries(projects)) {
+    if (!project.secret)
+      continue;
+    try {
+      const res = await fetchFn(`${ingestUrl}/api/projects/${projectId}/errors?status=open`, {
+        headers: { authorization: `Bearer ${project.secret}` }
+      });
+      if (!res.ok)
+        continue;
+      const body = await res.json();
+      for (const e of body.errors) {
+        queue.push({ projectName: project.name, errorId: e.id });
+      }
+    } catch {
+    }
+  }
+  if (queue.length === 0) {
+    log(source_default.hex("#4ade80")("No open errors. Queue is clean."));
+    return { fixed: 0, failed: 0, total: 0 };
+  }
+  log(source_default.bold(`Fixing ${queue.length} ${queue.length === 1 ? "error" : "errors"}...`));
+  log("");
+  let fixed = 0;
+  let failed = 0;
+  for (const item of queue) {
+    log(source_default.hex("#a78bfa").bold(`\u25B8 ${item.projectName}`) + source_default.dim(`  ${item.errorId}`));
+    try {
+      const result = await fixError(item.errorId, opts);
+      if (result.outcome === "awaiting_review") {
+        log(source_default.hex("#4ade80")(`  \u2713 ${result.reason}`));
+        fixed++;
+      } else {
+        log(source_default.hex("#ef4444")(`  \u2717 ${result.reason}`));
+        failed++;
+      }
+    } catch (err) {
+      log(source_default.hex("#ef4444")(`  \u2717 ${err instanceof Error ? err.message : String(err)}`));
+      failed++;
+    }
+    log("");
+  }
+  return { fixed, failed, total: queue.length };
+}
+async function preparePixelFix(errorId, opts = {}) {
+  const ingestUrl = (opts.ingestUrl ?? DEFAULT_INGEST_URL).replace(/\/+$/, "");
+  const fetchFn = opts.fetchFn ?? fetch;
+  const home = opts.homeDir ?? homedir();
+  const owner = await resolveErrorOwner(fetchFn, ingestUrl, errorId, home);
+  const { error, project, secret } = owner;
+  const branch = `fix/pixel-${error.id}`;
+  await patchError(fetchFn, ingestUrl, error.id, { status: "in_progress", branch }, secret);
+  return {
+    errorId: error.id,
+    projectId: error.project_id,
+    projectName: project.name,
+    projectPath: project.path,
+    branch,
+    prompt: buildAgentPrompt(error, branch, project.path)
+  };
+}
+async function finalizePixelFix(prep, opts = {}) {
+  const ingestUrl = (opts.ingestUrl ?? DEFAULT_INGEST_URL).replace(/\/+$/, "");
+  const fetchFn = opts.fetchFn ?? fetch;
+  const home = opts.homeDir ?? homedir();
+  const observed = await observeOutcome(prep.projectPath, prep.branch, opts.spawnFn ?? spawn);
+  let outcome;
+  let reason;
+  if (opts.agentExitedCleanly === false) {
+    outcome = "failed";
+    reason = "Agent did not finish cleanly";
+  } else if (!observed.branchExists) {
+    outcome = "failed";
+    reason = `Branch ${prep.branch} was not created`;
+  } else if (!observed.hasCommits) {
+    outcome = "failed";
+    reason = `Branch ${prep.branch} has no new commits`;
+  } else {
+    outcome = "awaiting_review";
+    reason = `Branch ${prep.branch} created with ${observed.commitCount} commit(s) \u2014 ready for review`;
+  }
+  const secret = lookupProjectSecret(home, prep.projectId);
+  await patchError(fetchFn, ingestUrl, prep.errorId, { status: outcome, branch: prep.branch }, secret);
+  return { outcome, reason };
+}
+function buildAgentPrompt(error, branch, projectDir) {
+  let stack = parseStackJson(error.stack);
+  if (projectDir && stack.length > 0 && looksLikeMinifiedBrowserStack(stack)) {
+    stack = tryResolveStack(stack, projectDir);
+  }
+  const ctx = parseCodeContext(error.code_context);
+  const lines = [];
+  lines.push("An error has been identified in this project. Investigate and fix it.");
+  lines.push("");
+  lines.push(`Error: ${error.type ?? "Error"} \u2014 ${error.message ?? "(no message)"}`);
+  const topInApp = stack.find((f) => f.in_app) ?? stack[0];
+  if (topInApp)
+    lines.push(`Location: ${topInApp.file}:${topInApp.line}`);
+  if (ctx && ctx.lines.length > 0) {
+    lines.push("");
+    lines.push("Code at site:");
+    const startLine = ctx.error_line - Math.floor((ctx.lines.length - 1) / 2);
+    ctx.lines.forEach((line, i) => {
+      const lineNum = startLine + i;
+      const marker = lineNum === ctx.error_line ? ">" : " ";
+      lines.push(`  ${marker}${String(lineNum).padStart(4)} | ${line}`);
+    });
+  }
+  if (stack.length > 0) {
+    lines.push("");
+    lines.push("Stack:");
+    for (const f of stack.slice(0, 10)) {
+      const lib = f.in_app ? "" : "  (lib)";
+      lines.push(`  ${f.fn || "<anon>"}  ${f.file}:${f.line}${lib}`);
+    }
+  }
+  if (error.runtime)
+    lines.push(`
+Runtime: ${error.runtime}`);
+  lines.push(`Occurrences: ${error.occurrences}`);
+  if (error.recurrence_count > 0) {
+    lines.push("");
+    lines.push(`Recurrence: this is the ${ordinal(error.recurrence_count)} time this fingerprint has appeared after a previous fix was merged. The earlier fix did not hold \u2014 investigate why.`);
+  }
+  lines.push("");
+  lines.push("When done:");
+  lines.push(`  1. Create branch: ${branch}`);
+  lines.push("  2. Commit the fix on that branch");
+  lines.push("  3. Run the project's quality checks (only commit if they pass)");
+  lines.push("");
+  lines.push("Do not merge. Do not push. Do not switch back to main.");
+  return lines.join("\n");
+}
+async function resolveErrorOwner(fetchFn, ingestUrl, errorId, home) {
+  const projectsPath = join2(home, ".gg", "projects.json");
+  if (!existsSync2(projectsPath)) {
+    throw new Error(`No projects mapping at ${projectsPath} \u2014 run \`arcicoder pixel install\` in the project first.`);
+  }
+  const projects = JSON.parse(readFileSync2(projectsPath, "utf8"));
+  const ownersWithSecret = Object.entries(projects).filter(([, p]) => Boolean(p.secret));
+  if (ownersWithSecret.length === 0) {
+    throw new Error("No managed projects on this machine \u2014 run `arcicoder pixel install` in the project to refresh management access.");
+  }
+  for (const [, project] of ownersWithSecret) {
+    const res = await fetchFn(`${ingestUrl}/api/errors/${errorId}`, {
+      headers: { authorization: `Bearer ${project.secret}` }
+    });
+    if (res.ok) {
+      const error = await res.json();
+      return { error, project, secret: project.secret };
+    }
+  }
+  throw new Error(`Error ${errorId} was not found in any registered project. Ensure the project is installed (\`arcicoder pixel install\`).`);
+}
+function lookupProjectSecret(home, projectId) {
+  const projectsPath = join2(home, ".gg", "projects.json");
+  if (!existsSync2(projectsPath)) {
+    throw new Error(`No projects mapping at ${projectsPath} \u2014 run \`arcicoder pixel install\` in the project first.`);
+  }
+  const projects = JSON.parse(readFileSync2(projectsPath, "utf8"));
+  const project = projects[projectId];
+  if (!project) {
+    throw new Error(`No local mapping for project ${projectId} in ${projectsPath}. Run \`arcicoder pixel install\` in the project's directory.`);
+  }
+  if (!project.secret) {
+    throw new Error(`Project ${projectId} is missing its bearer secret in ${projectsPath} \u2014 re-run \`arcicoder pixel install\` to refresh.`);
+  }
+  return project.secret;
+}
+async function patchError(fetchFn, ingestUrl, errorId, body, secret) {
+  const res = await fetchFn(`${ingestUrl}/api/errors/${errorId}`, {
+    method: "PATCH",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${secret}`
+    },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok)
+    throw new Error(`PATCH /api/errors/${errorId} failed: ${res.status}`);
+}
+async function runAgent(opts) {
+  return new Promise((resolve2, reject) => {
+    const args = [
+      "--json",
+      "--max-turns",
+      String(opts.maxTurns),
+      "--system-prompt",
+      opts.systemPrompt,
+      opts.prompt
+    ];
+    const child = opts.spawnFn(opts.ggcoderBin, args, {
+      cwd: opts.cwd,
+      stdio: opts.inheritStdio ? "inherit" : ["ignore", "pipe", "pipe"]
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => resolve2(code ?? 1));
+  });
+}
+async function observeOutcome(cwd, branch, spawnFn) {
+  const exists = await runGit(cwd, ["show-ref", "--verify", `refs/heads/${branch}`], spawnFn);
+  if (exists.code !== 0)
+    return { branchExists: false, hasCommits: false, commitCount: 0 };
+  let baseBranch = null;
+  for (const candidate of ["main", "master"]) {
+    const r = await runGit(cwd, ["show-ref", "--verify", `refs/heads/${candidate}`], spawnFn);
+    if (r.code === 0) {
+      baseBranch = candidate;
+      break;
+    }
+  }
+  if (!baseBranch)
+    return { branchExists: true, hasCommits: false, commitCount: 0 };
+  const ahead = await runGit(cwd, ["rev-list", "--count", `${baseBranch}..${branch}`], spawnFn);
+  const count = ahead.code === 0 ? parseInt(ahead.stdout.trim(), 10) || 0 : 0;
+  return { branchExists: true, hasCommits: count > 0, commitCount: count };
+}
+function runGit(cwd, args, spawnFn) {
+  return new Promise((resolve2) => {
+    const child = spawnFn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (b) => stdout += b.toString());
+    child.stderr?.on("data", (b) => stderr += b.toString());
+    child.on("error", () => resolve2({ code: 1, stdout, stderr }));
+    child.on("exit", (code) => resolve2({ code: code ?? 1, stdout, stderr }));
+  });
+}
+function looksLikeMinifiedBrowserStack(stack) {
+  return stack.some((f) => /^https?:\/\//.test(f.file));
+}
+function parseStackJson(raw) {
+  if (!raw)
+    return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed))
+      return parsed;
+  } catch {
+  }
+  return [];
+}
+function parseCodeContext(raw) {
+  if (!raw)
+    return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function ordinal(n) {
+  const s = ["th", "st", "nd", "rd"];
+  const v = n % 100;
+  return `${n}${s[(v - 20) % 10] ?? s[v] ?? s[0]}`;
+}
+export {
+  buildAgentPrompt,
+  finalizePixelFix,
+  fixError,
+  preparePixelFix,
+  runQueue
+};
+//# sourceMappingURL=pixel-fix-UIPF4UIQ.js.map