@quikit/quikpilot-runner 8.2.8 → 9.1.0

package/dist/index.js

@@ -73,13 +73,14 @@ async function describeQuikTrackFailure(res) {
 
 // src/callback.ts
 async function reportBack(params) {
-  const { callbackUrl, runToken, status, branch, warnings, targeting, baselineFindings, unresolved } = params;
+  const { callbackUrl, runToken, status, branch, warnings, targeting, baselineFindings, vanishedTests, unresolved } = params;
   const body = { status };
   if (branch) body.branch = branch;
   if (warnings && warnings.length > 0) body.warnings = warnings;
   if (unresolved && unresolved.length > 0) body.unresolved = unresolved;
   if (targeting) body.targeting = targeting;
   if (baselineFindings) body.baselineFindings = baselineFindings;
+  if (vanishedTests) body.vanishedTests = vanishedTests;
   const res = await fetch(callbackUrl, {
     method: "POST",
     headers: { Authorization: `Bearer ${runToken}`, "Content-Type": "application/json" },
@@ -111,20 +112,20 @@ function runTestCommand(command) {
 }
 function runTestCommandAsync(command) {
   if (!command) return Promise.resolve("success");
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const child = (0, import_node_child_process.spawn)(command, { shell: "/bin/bash", stdio: "inherit" });
-    child.on("exit", (code) => resolve4(code === 0 ? "success" : "failure"));
-    child.on("error", () => resolve4("failure"));
+    child.on("exit", (code) => resolve5(code === 0 ? "success" : "failure"));
+    child.on("error", () => resolve5("failure"));
   });
 }
 function runCommandWithTimeout(command, timeoutMs) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let settled = false;
     const finish = (outcome) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve4(outcome);
+      resolve5(outcome);
     };
     const child = (0, import_node_child_process.spawn)(command, { shell: "/bin/bash", stdio: "inherit", detached: true });
     const timer = setTimeout(() => {
@@ -229,7 +230,7 @@ function commitAndPush(branch, runId, installationToken, targeted, issueKey, iss
 
 // src/codegen.ts
 var import_node_fs = require("node:fs");
-var import_node_path = require("node:path");
+var import_node_path2 = require("node:path");
 
 // src/deniedPaths.ts
 function globToRegExp(pattern) {
@@ -251,6 +252,96 @@ function findDeniedContextPath(contextPaths, patterns) {
   return null;
 }
 
+// src/editsApply.ts
+function detectLineEnding(text) {
+  const crlf = text.split("\r\n").length - 1;
+  const bareLf = text.split("\n").length - 1 - crlf;
+  if (crlf > 0 && bareLf > 0) return "mixed";
+  return crlf > 0 ? "CRLF" : "LF";
+}
+function toLf(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+function fromLf(text, ending) {
+  return ending === "CRLF" ? text.replace(/\n/g, "\r\n") : text;
+}
+function occurrences(haystack, needle) {
+  const found = [];
+  let index = haystack.indexOf(needle);
+  while (index !== -1) {
+    found.push(index);
+    index = haystack.indexOf(needle, index + 1);
+  }
+  return found;
+}
+function applyEdits(originalLf, edits) {
+  if (!Array.isArray(edits) || edits.length === 0) {
+    return {
+      ok: false,
+      editCount: 0,
+      refusals: [{ kind: "no_edits", edits: [], matchCount: null, message: "the response carried no edits" }]
+    };
+  }
+  const refusals = [];
+  const ranges = [];
+  edits.forEach((edit, index) => {
+    const number = index + 1;
+    const record = edit !== null && typeof edit === "object" ? edit : null;
+    const find = record?.find;
+    const replace = record?.replace;
+    if (typeof find !== "string" || typeof replace !== "string") {
+      refusals.push({
+        kind: "empty",
+        edits: [number],
+        matchCount: null,
+        message: `edit ${number} is missing a string find or replace`
+      });
+      return;
+    }
+    if (find === "") {
+      refusals.push({ kind: "empty", edits: [number], matchCount: null, message: `edit ${number} has an empty anchor` });
+      return;
+    }
+    const starts = occurrences(originalLf, find);
+    if (starts.length === 0) {
+      refusals.push({ kind: "no_match", edits: [number], matchCount: 0, message: `edit ${number}: the anchor matched nothing` });
+    } else if (starts.length > 1) {
+      refusals.push({
+        kind: "ambiguous",
+        edits: [number],
+        matchCount: starts.length,
+        message: `edit ${number}: the anchor matched ${starts.length} times`
+      });
+    } else {
+      ranges.push({ start: starts[0], end: starts[0] + find.length, number, replace });
+    }
+  });
+  for (let i = 0; i < ranges.length; i++) {
+    for (let j = i + 1; j < ranges.length; j++) {
+      const a = ranges[i];
+      const b = ranges[j];
+      if (a.start < b.end && b.start < a.end) {
+        const [first, second] = a.number < b.number ? [a.number, b.number] : [b.number, a.number];
+        refusals.push({
+          kind: "overlap",
+          edits: [first, second],
+          matchCount: null,
+          message: `edits ${first} and ${second} overlap`
+        });
+      }
+    }
+  }
+  if (refusals.length > 0) return { ok: false, refusals, editCount: edits.length };
+  const pieces = [];
+  let cursor = 0;
+  for (const range of [...ranges].sort((x, y) => x.start - y.start)) {
+    pieces.push(originalLf.slice(cursor, range.start), range.replace);
+    cursor = range.end;
+  }
+  pieces.push(originalLf.slice(cursor));
+  return { ok: true, content: pieces.join(""), editCount: edits.length };
+}
+
 // src/runtimeReplyError.ts
 var RuntimeReplyError = class extends Error {
   summary;
@@ -291,6 +382,315 @@ function unwrapExecute(envelope, useCase) {
   return envelope.structuredJson;
 }
 
+// src/importContext.ts
+var import_node_path = require("node:path");
+var REGEX_PRECEDING_KEYWORDS = /* @__PURE__ */ new Set([
+  "return",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "new",
+  "delete",
+  "void",
+  "throw",
+  "case",
+  "do",
+  "else",
+  "yield",
+  "await"
+]);
+var SPACE_CODES = /* @__PURE__ */ new Set([32, 9, 10, 11, 12, 13, 160, 5760, 8232, 8233, 8239, 8287, 12288, 65279]);
+var isSpace = (c) => {
+  const code = c.charCodeAt(0);
+  return SPACE_CODES.has(code) || code >= 8192 && code <= 8202;
+};
+var isIdStart = (c) => !isSpace(c) && (/[A-Za-z_$]/.test(c) || c.charCodeAt(0) > 127);
+var isIdPart = (c) => !isSpace(c) && (/[A-Za-z0-9_$]/.test(c) || c.charCodeAt(0) > 127);
+function tokenize(src) {
+  const out = [];
+  const n = src.length;
+  function regexAllowed() {
+    const prev = out[out.length - 1];
+    if (!prev) return true;
+    if (prev.k === "p") return prev.v !== ")" && prev.v !== "]" && prev.v !== "}";
+    if (prev.k === "id") return REGEX_PRECEDING_KEYWORDS.has(prev.v);
+    return false;
+  }
+  function scan(start, inSubstitution) {
+    let i = start;
+    let depth = 0;
+    while (i < n) {
+      const c = src[i];
+      if (isSpace(c)) {
+        i++;
+        continue;
+      }
+      if (c === "/" && src[i + 1] === "/") {
+        while (i < n && src[i] !== "\n") i++;
+        continue;
+      }
+      if (c === "/" && src[i + 1] === "*") {
+        const end = src.indexOf("*/", i + 2);
+        i = end === -1 ? n : end + 2;
+        continue;
+      }
+      if (c === "'" || c === '"') {
+        let j = i + 1;
+        let closed = false;
+        while (j < n) {
+          const d = src[j];
+          if (d === "\\") {
+            j += 2;
+            continue;
+          }
+          if (d === c) {
+            closed = true;
+            break;
+          }
+          if (d === "\n" || d === "\r") break;
+          j++;
+        }
+        if (closed) out.push({ k: "str", v: src.slice(i + 1, j) });
+        i = closed ? j + 1 : j;
+        continue;
+      }
+      if (c === "`") {
+        let j = i + 1;
+        let hasSubstitution = false;
+        let closed = false;
+        const textStart = j;
+        let textEnd = j;
+        while (j < n) {
+          const d = src[j];
+          if (d === "\\") {
+            j += 2;
+            continue;
+          }
+          if (d === "`") {
+            closed = true;
+            textEnd = hasSubstitution ? textEnd : j;
+            break;
+          }
+          if (d === "$" && src[j + 1] === "{") {
+            hasSubstitution = true;
+            j = scan(j + 2, true);
+            continue;
+          }
+          j++;
+        }
+        if (closed) out.push(hasSubstitution ? { k: "tpl", v: "" } : { k: "str", v: src.slice(textStart, textEnd) });
+        i = closed ? j + 1 : n;
+        continue;
+      }
+      if (c === "/" && regexAllowed()) {
+        let j = i + 1;
+        let inClass = false;
+        let closed = false;
+        while (j < n) {
+          const d = src[j];
+          if (d === "\\") {
+            j += 2;
+            continue;
+          }
+          if (d === "\n" || d === "\r") break;
+          if (d === "[") inClass = true;
+          else if (d === "]") inClass = false;
+          else if (d === "/" && !inClass) {
+            closed = true;
+            break;
+          }
+          j++;
+        }
+        if (closed) {
+          j++;
+          while (j < n && /[a-z]/i.test(src[j])) j++;
+          out.push({ k: "num", v: "/re/" });
+          i = j;
+          continue;
+        }
+        out.push({ k: "p", v: "/" });
+        i++;
+        continue;
+      }
+      if (/[0-9]/.test(c)) {
+        let j = i + 1;
+        while (j < n && /[0-9A-Za-z_.]/.test(src[j])) j++;
+        out.push({ k: "num", v: src.slice(i, j) });
+        i = j;
+        continue;
+      }
+      if (isIdStart(c)) {
+        let j = i + 1;
+        while (j < n && isIdPart(src[j])) j++;
+        out.push({ k: "id", v: src.slice(i, j) });
+        i = j;
+        continue;
+      }
+      if (inSubstitution) {
+        if (c === "{") depth++;
+        else if (c === "}") {
+          if (depth === 0) return i + 1;
+          depth--;
+        }
+      }
+      out.push({ k: "p", v: c });
+      i++;
+    }
+    return n;
+  }
+  scan(0, false);
+  return out;
+}
+function extractImportSpecifiers(source) {
+  const t = tokenize(source);
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (s) => {
+    if (!seen.has(s)) {
+      seen.add(s);
+      found.push(s);
+    }
+  };
+  const isP = (tok, v) => tok?.k === "p" && tok.v === v;
+  for (let i = 0; i < t.length; i++) {
+    const tok = t[i];
+    if (tok.k !== "id") continue;
+    if (isP(t[i - 1], ".")) continue;
+    if (tok.v === "require") {
+      if (isP(t[i + 1], "(") && t[i + 2]?.k === "str" && isP(t[i + 3], ")")) add(t[i + 2].v);
+      continue;
+    }
+    if (tok.v !== "import" && tok.v !== "export") continue;
+    const next = t[i + 1];
+    if (tok.v === "import") {
+      if (next?.k === "str") {
+        add(next.v);
+        continue;
+      }
+      if (isP(next, "(")) {
+        if (t[i + 2]?.k === "str" && (isP(t[i + 3], ")") || isP(t[i + 3], ","))) add(t[i + 2].v);
+        continue;
+      }
+    }
+    for (let j = i + 1; j < t.length; j++) {
+      const c = t[j];
+      if (c.k === "id") {
+        if (c.v === "import" || c.v === "export") break;
+        if (c.v === "from" && t[j + 1]?.k === "str") {
+          add(t[j + 1].v);
+          break;
+        }
+        continue;
+      }
+      if (c.k === "p" && (c.v === "{" || c.v === "}" || c.v === "," || c.v === "*")) continue;
+      break;
+    }
+  }
+  return found;
+}
+function supportsImportScan(path) {
+  return /\.(?:[cm]?[jt]sx?)$/i.test(path);
+}
+var CODE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts", ".json"];
+var ASSET_EXTS = /* @__PURE__ */ new Set([
+  ".css",
+  ".scss",
+  ".sass",
+  ".less",
+  ".svg",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".avif",
+  ".ico",
+  ".bmp",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".mp3",
+  ".mp4",
+  ".webm",
+  ".wav",
+  ".pdf",
+  ".zip",
+  ".wasm"
+]);
+var TS_SIBLINGS = { ".js": [".ts", ".tsx"], ".jsx": [".tsx"], ".mjs": [".mts"], ".cjs": [".cts"] };
+function resolveImport(fromPath, specifier, listing) {
+  if (/^(?:@\/|~\/|#|\$|\/)/.test(specifier)) return { kind: "unresolved", reason: "alias" };
+  const clean = specifier.replace(/[?#].*$/, "");
+  const relative4 = clean === "." || clean === ".." || clean.startsWith("./") || clean.startsWith("../");
+  if (!relative4) return { kind: "external" };
+  const base = import_node_path.posix.normalize(import_node_path.posix.join(import_node_path.posix.dirname(fromPath), clean));
+  if (base === ".." || base.startsWith("../") || import_node_path.posix.isAbsolute(base)) return { kind: "unresolved", reason: "not found" };
+  const ext = import_node_path.posix.extname(base);
+  if (ASSET_EXTS.has(ext.toLowerCase())) return { kind: "unresolved", reason: "asset" };
+  const candidates = [];
+  if (CODE_EXTS.includes(ext)) {
+    candidates.push(base);
+    for (const sibling of TS_SIBLINGS[ext] ?? []) candidates.push(base.slice(0, -ext.length) + sibling);
+  }
+  for (const e of CODE_EXTS) candidates.push(base + e);
+  candidates.push(base + ".d.ts");
+  for (const e of CODE_EXTS) candidates.push(`${base}/index${e}`);
+  for (const candidate of candidates) {
+    if (listing.has(candidate)) return { kind: "repo", path: candidate };
+  }
+  return { kind: "unresolved", reason: "not found", attempted: base };
+}
+var ACTIONABLE_IMPORT_SKIPS = /* @__PURE__ */ new Set(["import: too large", "import: over budget", "import: unreadable"]);
+function collectImportContext(p) {
+  const out = { entries: [], skipped: [], importedPaths: [], aliasImports: 0 };
+  if (!supportsImportScan(p.targetPath)) return out;
+  const seen = new Set(p.alreadyNamed);
+  seen.add(p.targetPath);
+  let total = p.spentChars;
+  for (const specifier of extractImportSpecifiers(p.source)) {
+    const resolved = resolveImport(p.targetPath, specifier, p.listing);
+    if (resolved.kind === "external") continue;
+    if (resolved.kind === "unresolved") {
+      if (resolved.reason === "alias") out.aliasImports++;
+      else if (resolved.reason === "not found") {
+        const path2 = resolved.attempted ?? specifier;
+        if (!seen.has(path2)) {
+          seen.add(path2);
+          out.skipped.push({ path: path2, reason: "import: not in workspace" });
+        }
+      }
+      continue;
+    }
+    const path = resolved.path;
+    if (seen.has(path)) continue;
+    seen.add(path);
+    if (matchesDeniedPath(path, p.deniedPaths)) {
+      out.skipped.push({ path, reason: "import: denied" });
+      continue;
+    }
+    let content;
+    try {
+      content = p.readFile(path);
+    } catch {
+      out.skipped.push({ path, reason: "import: unreadable" });
+      continue;
+    }
+    if (content.length > p.maxFileChars) {
+      out.skipped.push({ path, reason: "import: too large" });
+    } else if (total + content.length > p.maxTotalChars) {
+      out.skipped.push({ path, reason: "import: over budget" });
+    } else {
+      total += content.length;
+      out.entries.push({ path, content });
+      out.importedPaths.push(path);
+    }
+  }
+  return out;
+}
+
 // src/retryFetch.ts
 var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([502, 503, 504]);
 var RETRYABLE_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set(["ECONNRESET", "ETIMEDOUT"]);
@@ -413,6 +813,58 @@ function looksLikeTruncatedRewrite(target, currentContent, newContent) {
   return null;
 }
 var CONTRACT_VERSION = "test-targets-1";
+var CONTRACT_VERSION_EDITS = "edits-1";
+var ANCHOR_REFUSED_CODE = "CODEGEN_ANCHOR_REFUSED";
+function summariseLocalRefusals(refusals) {
+  const parts = [];
+  const matchCounts = [];
+  for (const r of refusals) {
+    if (r.kind === "ambiguous") {
+      parts.push(`an anchor matched ${r.matchCount} times`);
+      if (r.matchCount !== null) matchCounts.push(r.matchCount);
+    } else if (r.kind === "no_match") {
+      parts.push("an anchor matched nothing");
+    } else if (r.kind === "overlap") {
+      parts.push(`edits ${r.edits.join(" and ")} overlap`);
+    } else if (r.kind === "no_edits") {
+      parts.push("the reply had no edits");
+    } else {
+      parts.push("an edit was missing its anchor or replacement");
+    }
+  }
+  return { text: [...new Set(parts)].join("; "), matchCounts };
+}
+function summariseRuntimeRefusal(error) {
+  const text = typeof error === "string" ? error : "";
+  const matchCounts = [...text.matchAll(/anchor matched (\d+) times/g)].map((m) => Number(m[1]));
+  const parts = matchCounts.map((n) => `an anchor matched ${n} times`);
+  if (/no match/i.test(text)) parts.push("an anchor matched nothing");
+  if (/overlap/i.test(text)) parts.push("edits overlapped");
+  if (/empty anchor|missing a string/i.test(text)) parts.push("an edit was missing its anchor or replacement");
+  return { text: parts.length > 0 ? [...new Set(parts)].join("; ") : "the runtime could not place the edits", matchCounts };
+}
+function throwOnTerminalRefusal(envelope, targetPath) {
+  if (typeof envelope?.errorCode === "string" && NOT_RETRIED_CODES.has(envelope.errorCode)) {
+    const detail = envelope.error ? `: ${envelope.error}` : "";
+    throw new RuntimeReplyError(
+      `Codegen refused ${targetPath}: ${envelope.errorCode} (not retried)${detail}`,
+      `Codegen refused ${targetPath}: ${envelope.errorCode} (not retried)`
+    );
+  }
+  if (envelope?.errorCode === JUDGED_BY_TOO_LARGE_CODE) {
+    const detail = envelope.error ? `: ${envelope.error}` : "";
+    throw new RuntimeReplyError(
+      `Codegen refused ${targetPath}: ${envelope.errorCode} (after narrowing)${detail}`,
+      `Codegen refused ${targetPath}: ${envelope.errorCode} (after narrowing)`
+    );
+  }
+}
+function codegenRefusedError(targetPath, body) {
+  return new RuntimeReplyError(
+    `Codegen refused ${targetPath}${body.refusalReason ? `: ${body.refusalReason}` : ""}`,
+    `Codegen refused ${targetPath}`
+  );
+}
 function buildJudgedByPool(requiredTests, targets, skippedCases) {
   const claimedIds = /* @__PURE__ */ new Set();
   for (const t of targets) {
@@ -444,6 +896,8 @@ async function runCodegen(gateway, targets, workspaceListing, requiredTests, den
   for (const target of targets) {
     const isNewFile = target.kind === "NEW_FILE";
     const currentContent = isNewFile ? "" : (0, import_node_fs.readFileSync)(target.path, "utf8");
+    const lineEnding = isNewFile ? "LF" : detectLineEnding(currentContent);
+    const wantsEdits = !isNewFile && lineEnding !== "mixed";
     const contextPaths = target.contextPaths ?? [];
     const deniedContext = findDeniedContextPath(contextPaths, deniedPaths);
     if (deniedContext) {
@@ -458,28 +912,51 @@ async function runCodegen(gateway, targets, workspaceListing, requiredTests, den
         );
       }
     }
-    const namedContents = contextPaths.map((path) => ({ path, content: (0, import_node_fs.readFileSync)(path, "utf8") }));
-    const added = collectRunContext(target, targets, new Set(contextPaths), deniedPaths);
-    const contextContents = [...namedContents, ...added.entries];
-    for (const s of added.skipped) {
+    const namedContents = contextPaths.map((path2) => ({ path: path2, content: (0, import_node_fs.readFileSync)(path2, "utf8") }));
+    const runFiles = collectRunContext(target, targets, new Set(contextPaths), deniedPaths);
+    for (const s of runFiles.skipped) {
       warnings.push(`not shown to the test for ${target.path}: ${s.path} (${s.reason})`);
     }
+    const imports = isNewFile ? { entries: [], skipped: [], importedPaths: [], aliasImports: 0 } : collectImportContext({
+      targetPath: target.path,
+      source: currentContent,
+      alreadyNamed: /* @__PURE__ */ new Set([...contextPaths, ...runFiles.entries.map((e) => e.path)]),
+      deniedPaths,
+      listing,
+      readFile: (p) => (0, import_node_fs.readFileSync)(p, "utf8"),
+      maxFileChars: MAX_ADDED_FILE_CHARS,
+      maxTotalChars: MAX_ADDED_CONTEXT_CHARS,
+      spentChars: runFiles.entries.reduce((n, e) => n + e.content.length, 0)
+    });
+    for (const s of imports.skipped) {
+      if (ACTIONABLE_IMPORT_SKIPS.has(s.reason)) {
+        warnings.push(`not shown with ${target.path}: ${s.path} (imported by it; ${s.reason.replace(/^import: /, "")})`);
+      }
+    }
+    const added = {
+      entries: [...runFiles.entries, ...imports.entries],
+      skipped: [...runFiles.skipped, ...imports.skipped]
+    };
+    const contextContents = [...namedContents, ...added.entries];
     const contextRecord = {
       targetPath: target.path,
       contextPaths,
       addedPaths: added.entries.map((e) => e.path),
-      skipped: added.skipped
+      skipped: added.skipped,
+      ...imports.importedPaths.length > 0 ? { importedPaths: imports.importedPaths } : {},
+      ...imports.aliasImports > 0 ? { aliasImports: imports.aliasImports } : {}
     };
     console.log(JSON.stringify({ event: "codegen.context", ...contextRecord }));
     contextLog?.push(contextRecord);
     const contextData = {
       targetPath: target.path,
-      currentContent,
+      // Every anchor and replacement is LF, always (Doc 62 §2), so the file is sent as LF.
+      currentContent: wantsEdits ? toLf(currentContent) : currentContent,
       planSteps: target.planStepsImplemented,
       kind: target.kind,
       contextContents,
       // QUIKTR-1083 (§15.6) — required on every call on the versioned path.
-      contractVersion: CONTRACT_VERSION
+      contractVersion: wantsEdits ? CONTRACT_VERSION_EDITS : CONTRACT_VERSION
     };
     if (isNewFile) {
       contextData.workspaceListing = workspaceListing;
@@ -533,6 +1010,7 @@ async function runCodegen(gateway, targets, workspaceListing, requiredTests, den
       contextData.contextContents = namedContents;
       warnings.push(`context for ${target.path} was too large with the run's other files; retried without them`);
       contextRecord.addedPaths = [];
+      delete contextRecord.importedPaths;
       contextRecord.retriedWithoutAdded = true;
       res = await callCodegen();
       if (!res.ok) {
@@ -541,29 +1019,91 @@ async function runCodegen(gateway, targets, workspaceListing, requiredTests, den
       envelope = await res.json();
       checkHardFailure(envelope, "pilot.codegen", target.path);
     }
-    if (typeof envelope?.errorCode === "string" && NOT_RETRIED_CODES.has(envelope.errorCode)) {
-      const detail = envelope.error ? `: ${envelope.error}` : "";
-      throw new RuntimeReplyError(
-        `Codegen refused ${target.path}: ${envelope.errorCode} (not retried)${detail}`,
-        `Codegen refused ${target.path}: ${envelope.errorCode} (not retried)`
-      );
+    throwOnTerminalRefusal(envelope, target.path);
+    let newContent = null;
+    let failedEdits = null;
+    let editCount;
+    let path = "whole_file";
+    let reason = isNewFile ? "new_file" : wantsEdits ? void 0 : "mixed_line_endings";
+    if (wantsEdits && envelope?.errorCode === ANCHOR_REFUSED_CODE) {
+      failedEdits = { reason: "anchor_refused", summary: summariseRuntimeRefusal(envelope.error) };
+    } else {
+      const body = unwrapExecute(envelope, "pilot.codegen");
+      if (wantsEdits) {
+        if (body.outcome === "REFUSED") throw codegenRefusedError(target.path, body);
+        if (body.outcome !== "GENERATED" || typeof body.newContent === "string") {
+          throw new RuntimeReplyError(
+            `Codegen reply for ${target.path} was not in the edits-1 shape and was not applied`,
+            `Codegen reply for ${target.path} was not in the edits-1 shape`
+          );
+        }
+        const applied = applyEdits(toLf(currentContent), body.edits);
+        if (applied.ok) {
+          newContent = fromLf(applied.content, lineEnding);
+          path = "edits";
+          editCount = applied.editCount;
+        } else if (applied.refusals.some((r) => r.kind === "no_edits")) {
+          throw new RuntimeReplyError(
+            `Codegen reply for ${target.path} carried no edits (not retried)`,
+            `Codegen reply for ${target.path} carried no edits`
+          );
+        } else {
+          failedEdits = { reason: "local_refusal", summary: summariseLocalRefusals(applied.refusals) };
+        }
+      } else {
+        if (body.outcome !== "GENERATED" || typeof body.newContent !== "string") {
+          throw codegenRefusedError(target.path, body);
+        }
+        newContent = body.newContent;
+      }
     }
-    if (envelope?.errorCode === JUDGED_BY_TOO_LARGE_CODE) {
-      const detail = envelope.error ? `: ${envelope.error}` : "";
-      throw new RuntimeReplyError(
-        `Codegen refused ${target.path}: ${envelope.errorCode} (after narrowing)${detail}`,
-        `Codegen refused ${target.path}: ${envelope.errorCode} (after narrowing)`
+    if (failedEdits) {
+      warnings.push(
+        `edits for ${target.path} could not be placed (${failedEdits.summary.text}); asked again for the whole file`
       );
+      contextData.currentContent = currentContent;
+      contextData.contractVersion = CONTRACT_VERSION;
+      try {
+        res = await callCodegen();
+        if (!res.ok) {
+          throw new Error(`Codegen call failed for ${target.path}: ${res.status} ${res.statusText}`);
+        }
+        envelope = await res.json();
+        checkHardFailure(envelope, "pilot.codegen", target.path);
+        throwOnTerminalRefusal(envelope, target.path);
+        const whole = unwrapExecute(envelope, "pilot.codegen");
+        if (whole.outcome !== "GENERATED" || typeof whole.newContent !== "string") {
+          throw codegenRefusedError(target.path, whole);
+        }
+        newContent = whole.newContent;
+      } catch (error) {
+        if (error instanceof RuntimeReplyError) {
+          throw new RuntimeReplyError(
+            `${error.message} (this was the whole-file request made after the edits for ${target.path} were refused: ${failedEdits.summary.text})`,
+            `${error.summary} (the whole-file request, made after the edits were refused)`
+          );
+        }
+        throw error;
+      }
+      path = "fallback";
+      reason = failedEdits.reason;
     }
-    const body = unwrapExecute(envelope, "pilot.codegen");
-    if (body.outcome !== "GENERATED" || typeof body.newContent !== "string") {
-      throw new RuntimeReplyError(
-        `Codegen refused ${target.path}${body.refusalReason ? `: ${body.refusalReason}` : ""}`,
-        `Codegen refused ${target.path}`
+    if (newContent === null) throw new Error(`Codegen produced no content for ${target.path}`);
+    if (!isNewFile) {
+      console.log(
+        JSON.stringify({
+          event: "codegen.edits_path",
+          targetPath: target.path,
+          path,
+          ...reason ? { reason } : {},
+          ...editCount !== void 0 ? { editCount } : {},
+          ...failedEdits && failedEdits.summary.matchCounts.length > 0 ? { matchCounts: failedEdits.summary.matchCounts } : {},
+          lineEnding
+        })
       );
     }
     if (!isNewFile) {
-      const suspectReason = looksLikeTruncatedRewrite(target, currentContent, body.newContent);
+      const suspectReason = looksLikeTruncatedRewrite(target, currentContent, newContent);
       if (suspectReason) {
         throw new Error(
           `Codegen output for ${target.path} looks like a truncated/abbreviated rewrite (${suspectReason}) \u2014 refusing to apply it. Interim guard per \xA716.7; the AI Runtime's own output-cap check is not live yet.`
@@ -576,24 +1116,24 @@ async function runCodegen(gateway, targets, workspaceListing, requiredTests, den
         targetPath: target.path,
         kind: target.kind,
         inputLength: currentContent.length,
-        outputLength: body.newContent.length,
-        removedLines: isNewFile ? null : countRemovedLines(currentContent, body.newContent)
+        outputLength: newContent.length,
+        removedLines: isNewFile ? null : countRemovedLines(currentContent, newContent)
       })
     );
-    results.push({ targetPath: target.path, newContent: body.newContent });
+    results.push({ targetPath: target.path, newContent });
   }
   return results;
 }
 function flushCodegenResults(results) {
   for (const { targetPath, newContent } of results) {
-    (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(targetPath), { recursive: true });
+    (0, import_node_fs.mkdirSync)((0, import_node_path2.dirname)(targetPath), { recursive: true });
     (0, import_node_fs.writeFileSync)(targetPath, newContent);
   }
 }
 
 // src/dependencyCheck.ts
 var import_node_fs2 = require("node:fs");
-var import_node_path2 = require("node:path");
+var import_node_path3 = require("node:path");
 var SCANNABLE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"];
 var IMPORT_RE = /(?:\bimport\b[^'"]*?\bfrom\s*|\bimport\s*\(\s*|\bexport\b[^'"]*?\bfrom\s*|\brequire\s*\(\s*|\bimport\s+)(['"])([^'"]+)\1/g;
 var NODE_BUILTINS = /* @__PURE__ */ new Set([
@@ -672,8 +1212,8 @@ function dependencyNames(pkg) {
   ]);
 }
 function readDeclaredDependencies(results, workspaceRoot) {
-  const packageJsonPath = (0, import_node_path2.join)((0, import_node_path2.resolve)(workspaceRoot ?? "."), "package.json");
-  const generated = results.find((r) => (0, import_node_path2.resolve)(r.targetPath) === packageJsonPath);
+  const packageJsonPath = (0, import_node_path3.join)((0, import_node_path3.resolve)(workspaceRoot ?? "."), "package.json");
+  const generated = results.find((r) => (0, import_node_path3.resolve)(r.targetPath) === packageJsonPath);
   let raw;
   if (generated) {
     raw = generated.newContent;
@@ -743,10 +1283,10 @@ function stripJsonComments(text) {
   return out.replace(/,(\s*[}\]])/g, "$1");
 }
 function resolveAliasPrefixes(results, workspaceRoot) {
-  const root = (0, import_node_path2.resolve)(workspaceRoot ?? ".");
+  const root = (0, import_node_path3.resolve)(workspaceRoot ?? ".");
   for (const filename of ["tsconfig.json", "jsconfig.json"]) {
-    const configPath = (0, import_node_path2.join)(root, filename);
-    const generated = results.find((r) => (0, import_node_path2.resolve)(r.targetPath) === configPath);
+    const configPath = (0, import_node_path3.join)(root, filename);
+    const generated = results.find((r) => (0, import_node_path3.resolve)(r.targetPath) === configPath);
     let raw;
     if (generated) {
       raw = generated.newContent;
@@ -953,7 +1493,7 @@ function writePhase0Marker(runId) {
 
 // src/quiktest.ts
 var import_node_fs4 = require("node:fs");
-var import_node_path3 = require("node:path");
+var import_node_path4 = require("node:path");
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git"]);
 function walkForJUnitByName(dir) {
   let entries;
@@ -964,7 +1504,7 @@ function walkForJUnitByName(dir) {
   }
   for (const entry of entries) {
     if (SKIP_DIRS.has(entry)) continue;
-    const full = (0, import_node_path3.join)(dir, entry);
+    const full = (0, import_node_path4.join)(dir, entry);
     let stat;
     try {
       stat = (0, import_node_fs4.statSync)(full);
@@ -988,10 +1528,18 @@ function firstXmlIn(dir, namePattern) {
     return null;
   }
   const match = entries.find((e) => namePattern.test(e));
-  return match ? (0, import_node_path3.join)(dir, match) : null;
+  return match ? (0, import_node_path4.join)(dir, match) : null;
+}
+function readTestReportBytes(cwd = process.cwd()) {
+  try {
+    const report = findJUnitReport(cwd);
+    return report ? (0, import_node_fs4.readFileSync)(report) : null;
+  } catch {
+    return null;
+  }
 }
 function findJUnitReport(cwd = process.cwd()) {
-  return walkForJUnitByName(cwd) ?? firstXmlIn((0, import_node_path3.join)(cwd, "test-results"), /\.xml$/) ?? firstXmlIn((0, import_node_path3.join)(cwd, "reports"), /^junit.*\.xml$/) ?? firstXmlIn((0, import_node_path3.join)(cwd, "target", "surefire-reports"), /\.xml$/);
+  return walkForJUnitByName(cwd) ?? firstXmlIn((0, import_node_path4.join)(cwd, "test-results"), /\.xml$/) ?? firstXmlIn((0, import_node_path4.join)(cwd, "reports"), /^junit.*\.xml$/) ?? firstXmlIn((0, import_node_path4.join)(cwd, "target", "surefire-reports"), /\.xml$/);
 }
 function buildCiUrl(serverUrl, repository, githubRunId) {
   return `${serverUrl}/${repository}/actions/runs/${githubRunId}`;
@@ -1015,8 +1563,8 @@ async function reportToQuikTest(params) {
   try {
     console.log(`reporting ${report}`);
     const ciUrl = buildCiUrl(githubServerUrl, githubRepository, githubRunId);
-    const { readFileSync: readFileSync6 } = await import("node:fs");
-    const body = readFileSync6(report);
+    const { readFileSync: readFileSync7 } = await import("node:fs");
+    const body = readFileSync7(report);
     let url = `${resultsUrl}?ciUrl=${encodeURIComponent(ciUrl)}&automationIdFormat=bracket`;
     if (generatedFiles) {
       url += `&generatedFiles=${encodeURIComponent(generatedFiles.join(","))}`;
@@ -1046,7 +1594,7 @@ async function reportToQuikTest(params) {
 // src/baselineCheck.ts
 var import_node_child_process3 = require("node:child_process");
 var import_node_fs6 = require("node:fs");
-var import_node_path4 = require("node:path");
+var import_node_path5 = require("node:path");
 
 // src/regressionCheck.ts
 var import_node_fs5 = require("node:fs");
@@ -1106,9 +1654,11 @@ function parseJUnitOutcomes(xml) {
   TESTCASE_RE.lastIndex = 0;
   while (match = TESTCASE_RE.exec(xml)) {
     const [, attrs, body = ""] = match;
-    const name = NAME_ATTR_RE.exec(attrs)?.[1];
-    if (!name) continue;
-    const classname = CLASSNAME_ATTR_RE.exec(attrs)?.[1];
+    const rawName = NAME_ATTR_RE.exec(attrs)?.[1];
+    if (!rawName) continue;
+    const name = unescapeXmlEntities(rawName);
+    const rawClassname = CLASSNAME_ATTR_RE.exec(attrs)?.[1];
+    const classname = rawClassname === void 0 ? void 0 : unescapeXmlEntities(rawClassname);
     const id = classname ? `${classname}::${name}` : name;
     const failed = FAILURE_CHILD_RE.test(body);
     outcomes.set(id, !failed);
@@ -1230,16 +1780,16 @@ function checkableIds(ids, types) {
   });
 }
 function insideCheckout(cwd, path) {
-  const abs = (0, import_node_path4.resolve)(cwd, path);
-  const rel = (0, import_node_path4.relative)(cwd, abs);
-  return rel === "" || rel.startsWith("..") || (0, import_node_path4.isAbsolute)(rel) ? null : abs;
+  const abs = (0, import_node_path5.resolve)(cwd, path);
+  const rel = (0, import_node_path5.relative)(cwd, abs);
+  return rel === "" || rel.startsWith("..") || (0, import_node_path5.isAbsolute)(rel) ? null : abs;
 }
 function writeForCheck(abs, content) {
   const original = (0, import_node_fs6.existsSync)(abs) ? (0, import_node_fs6.readFileSync)(abs) : null;
   const createdDirs = [];
   if (original === null) {
     const missing = [];
-    for (let d = (0, import_node_path4.dirname)(abs); !(0, import_node_fs6.existsSync)(d); d = (0, import_node_path4.dirname)(d)) missing.push(d);
+    for (let d = (0, import_node_path5.dirname)(abs); !(0, import_node_fs6.existsSync)(d); d = (0, import_node_path5.dirname)(d)) missing.push(d);
     for (const d of missing.reverse()) {
       (0, import_node_fs6.mkdirSync)(d);
       createdDirs.push(d);
@@ -1389,6 +1939,10 @@ async function runBaselineCheck(params) {
   }
 }
 
+// src/failureArtifact.ts
+var import_node_fs7 = require("node:fs");
+var import_node_path6 = require("node:path");
+
 // src/failureReason.ts
 var MAX_FAILURE_REASON = 1e3;
 var MIN_SECRET_LENGTH = 8;
@@ -1409,18 +1963,86 @@ function failureSummary(err) {
   if (err instanceof RuntimeReplyError) return err.summary;
   return err instanceof Error ? err.message : String(err);
 }
-function describeFailureReason(message, secrets = []) {
+function scrubSecrets(message, secrets = []) {
   let text = message;
   for (const secret of secrets) {
     if (secret.length >= MIN_SECRET_LENGTH) text = text.split(secret).join("***");
   }
   for (const pattern of CREDENTIAL_PATTERNS) text = text.replace(pattern, "***");
+  return text;
+}
+function describeFailureReason(message, secrets = []) {
+  let text = scrubSecrets(message, secrets);
   text = text.replace(/\s*\n\s*/g, " | ").trim();
   return text.length > MAX_FAILURE_REASON ? `${text.slice(0, MAX_FAILURE_REASON)}\u2026` : text;
 }
 
+// src/failureArtifact.ts
+var FAILURE_ARTIFACT_DIR = "quikpilot-failure";
+var REPORT_COPY = "final-test-report.xml";
+var MAX_REPORT_BYTES = 5 * 1024 * 1024;
+var MAX_FILES = 200;
+var RUNNER_VERSION = true ? "9.1.0" : "dev";
+function safeDestination(base, repoPath) {
+  if (!repoPath || (0, import_node_path6.isAbsolute)(repoPath)) return null;
+  const destination = (0, import_node_path6.resolve)(base, repoPath);
+  const rel = (0, import_node_path6.relative)(base, destination);
+  if (!rel || rel.startsWith("..") || (0, import_node_path6.isAbsolute)(rel)) return null;
+  return destination;
+}
+function writeFailureArtifact(input) {
+  if (input.results.length === 0) return { written: false };
+  try {
+    const base = (0, import_node_path6.resolve)(input.cwd, FAILURE_ARTIFACT_DIR);
+    (0, import_node_fs7.rmSync)(base, { recursive: true, force: true });
+    (0, import_node_fs7.mkdirSync)(base, { recursive: true });
+    const files = [];
+    const skipped = [];
+    for (const result of input.results) {
+      const destination = files.length < MAX_FILES ? safeDestination(base, result.targetPath) : null;
+      if (!destination) {
+        skipped.push(result.targetPath);
+        continue;
+      }
+      (0, import_node_fs7.mkdirSync)((0, import_node_path6.dirname)(destination), { recursive: true });
+      (0, import_node_fs7.writeFileSync)(destination, result.newContent);
+      files.push({ path: result.targetPath, bytes: Buffer.byteLength(result.newContent) });
+    }
+    let testReport = "none";
+    if (input.testReport) {
+      if (input.testReport.byteLength > MAX_REPORT_BYTES) {
+        testReport = "too-large";
+      } else {
+        (0, import_node_fs7.writeFileSync)((0, import_node_path6.join)(base, REPORT_COPY), input.testReport);
+        testReport = "included";
+      }
+    }
+    const manifest = {
+      runId: input.runId,
+      issueKey: input.issueKey,
+      runnerVersion: RUNNER_VERSION,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      targets: input.targets.map((t) => ({
+        path: t.path,
+        kind: t.kind,
+        ...t.automationIds && t.automationIds.length > 0 ? { automationIds: t.automationIds } : {}
+      })),
+      files,
+      skipped,
+      testReport,
+      failureReasons: input.failureReasons
+    };
+    const text = JSON.stringify(manifest, (_key, value) => typeof value === "string" ? scrubSecrets(value, input.secrets) : value, 2);
+    (0, import_node_fs7.writeFileSync)((0, import_node_path6.join)(base, "manifest.json"), text);
+    return { written: (0, import_node_fs7.existsSync)((0, import_node_path6.join)(base, "manifest.json")) };
+  } catch (err) {
+    console.warn(`::warning::Could not keep the failed run's files: ${err instanceof Error ? err.message : String(err)}`);
+    return { written: false };
+  }
+}
+
 // src/scopeCheck.ts
-var import_node_fs7 = require("node:fs");
+var import_node_fs8 = require("node:fs");
 var ROUTE_METHOD_RE = /\b(GET|POST|PUT|PATCH|DELETE)\b/i;
 var ROUTE_PATH_RE = /\/[A-Za-z0-9_\-{}[\]]+(?:\/[A-Za-z0-9_\-:{}[\]]+)+/;
 var ROUTE_EXPORT_RE = /\bexport\s+(?:async\s+)?function\s+(GET|POST|PUT|PATCH|DELETE)\s*\(/;
@@ -1477,7 +2099,7 @@ function checkApiScope(results, targets, apiChanges) {
     } else {
       let currentContent;
       try {
-        currentContent = (0, import_node_fs7.readFileSync)(targetPath, "utf8");
+        currentContent = (0, import_node_fs8.readFileSync)(targetPath, "utf8");
       } catch {
         currentContent = "";
       }
@@ -1496,7 +2118,7 @@ function describeScopeViolations(check) {
 }
 
 // src/targeting.ts
-var import_node_path5 = require("node:path");
+var import_node_path7 = require("node:path");
 var CONTRACT_VERSION2 = "test-targets-1";
 function listWorkspaceFiles(workspaceRoot) {
   return listFiles(workspaceRoot ?? ".");
@@ -1525,9 +2147,9 @@ function validateTarget(target, workspaceRoot, workspaceListing, deniedPaths) {
     }
     return;
   }
-  const root = (0, import_node_path5.resolve)(workspaceRoot ?? ".");
-  const rel = (0, import_node_path5.relative)(root, (0, import_node_path5.resolve)(target.path));
-  if (rel.startsWith("..") || (0, import_node_path5.isAbsolute)(rel)) {
+  const root = (0, import_node_path7.resolve)(workspaceRoot ?? ".");
+  const rel = (0, import_node_path7.relative)(root, (0, import_node_path7.resolve)(target.path));
+  if (rel.startsWith("..") || (0, import_node_path7.isAbsolute)(rel)) {
     throw new Error(
       `pilot.targeting named a NEW_FILE path that escapes the workspace root: ${target.path}`
     );
@@ -1582,10 +2204,19 @@ async function runTargeting(gateway, design, workspaceRoot, workspaceListing, re
   for (const target of body.targets) {
     validateTarget(target, workspaceRoot, listing, deniedPaths);
   }
+  const correctedKinds = [];
+  const targets = body.targets.map((target) => {
+    if (target.kind === "NEW_FILE" && listing.has(target.path)) {
+      correctedKinds.push(target.path);
+      return { ...target, kind: "EXISTING" };
+    }
+    return target;
+  });
   return {
     outcome: "TARGETED",
-    targets: body.targets,
-    skippedCases: body.skippedCases ?? []
+    targets,
+    skippedCases: body.skippedCases ?? [],
+    ...correctedKinds.length > 0 ? { correctedKinds } : {}
   };
 }
 
@@ -1748,6 +2379,19 @@ async function exchangeForRunToken(tokenUrl, oidcToken) {
   return body.data.runToken;
 }
 
+// src/vanishedTests.ts
+var MAX_VANISHED_NAMES = 50;
+function findVanishedTests(baseline, after) {
+  if (!baseline.results || !after.results) return null;
+  const missing = [...baseline.results.keys()].filter((id) => !after.results.has(id));
+  if (missing.length === 0) return null;
+  return { names: missing.slice(0, MAX_VANISHED_NAMES), total: missing.length };
+}
+function describeVanishedTests(vanished) {
+  const noun = vanished.total === 1 ? "1 test" : `${vanished.total} tests`;
+  return `${noun} that ran before this change ${vanished.total === 1 ? "is" : "are"} missing from the final test report; the pull request lists ${vanished.total === 1 ? "it" : "them"}.`;
+}
+
 // src/run.ts
 async function run(env2) {
   let hardFailure = false;
@@ -1764,8 +2408,11 @@ async function run(env2) {
   };
   let targeted = false;
   let generatedFilePaths = [];
+  let generatedResults = [];
+  let finalTestReport = null;
   let targetingResult;
   let baselineFindings;
+  let vanishedTests;
   const contextLog = [];
   try {
     runToken = await exchangeForRunToken(env2.tokenUrl, await fetchGithubOidcToken());
@@ -1784,6 +2431,14 @@ async function run(env2) {
       outOfScope
     );
     targetingResult = targeting;
+    if (targeting.outcome === "TARGETED") {
+      for (const path of targeting.correctedKinds ?? []) {
+        const w = `QuikPilot named ${path} as a new file, but it already exists in the repository. It was treated as an existing file so its current content was kept in view.`;
+        warnings.push(w);
+        console.warn(`QuikPilot targeting warning (not blocking): ${w}`);
+        console.log(JSON.stringify({ event: "targeting.kind_corrected", path }));
+      }
+    }
     if (targeting.outcome === "NO_TARGET") {
       writePhase0Marker(env2.runId);
       runCommand(packet.commands.setup, "Setup");
@@ -1833,6 +2488,7 @@ async function run(env2) {
           outOfScope
         )
       ]);
+      generatedResults = results;
       const depCheck = checkImportDependencies(
         results,
         readDeclaredDependencies(results, packet.workspaceRoot),
@@ -1878,6 +2534,13 @@ async function run(env2) {
       }
       runCommand(packet.commands.lint, "Lint");
       const after = captureTestSnapshot(packet.commands.test);
+      finalTestReport = readTestReportBytes();
+      vanishedTests = findVanishedTests(baseline, after) ?? void 0;
+      if (vanishedTests) {
+        const w = describeVanishedTests(vanishedTests);
+        warnings.push(w);
+        console.warn(`QuikPilot test warning (not blocking): ${w}`);
+      }
       const check = checkForRegressions(baseline, after);
       if (check.blocked) {
         throw new Error(
@@ -1933,6 +2596,22 @@ async function run(env2) {
       recordFailure(err);
     }
   }
+  if (hardFailure && generatedResults.length > 0) {
+    try {
+      writeFailureArtifact({
+        cwd: process.cwd(),
+        runId: env2.runId,
+        issueKey: packet?.issueKey ?? null,
+        targets: targetingResult?.outcome === "TARGETED" ? targetingResult.targets : [],
+        results: generatedResults,
+        testReport: finalTestReport,
+        failureReasons,
+        secrets: runToken ? [runToken] : []
+      });
+    } catch (err) {
+      console.warn(`::warning::Could not keep the failed run's files: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
   await reportBack({
     callbackUrl: env2.callbackUrl,
     runToken,
@@ -1942,6 +2621,7 @@ async function run(env2) {
     // Omitted when targeting itself never produced a result (nothing exists to record).
     targeting: targetingResult ? buildTargetingRecord(targetingResult, contextLog) : void 0,
     baselineFindings,
+    vanishedTests,
     unresolved: failureReasons.length > 0 ? failureReasons : void 0
   });
   return { hardFailure };