@quikit/quikpilot-runner 9.0.0 → 9.1.0

package/README.md

@@ -26,6 +26,16 @@ Releases follow [SemVer](https://semver.org/): a major version bump means the wo
 shape changed (inputs, permissions) and requires a new pull request regardless of this package's
 version; minor/patch releases are runner-logic fixes safe to pick up on the next re-bootstrap.
 
+**9.1.0 — the code-writing step sees the files the changed file imports.** For every existing file a run changes (code or
+test), the runner now reads that file's own imports (JavaScript and TypeScript, one hop, never what those files import)
+and sends the repository files they point to as extra context. They come after the files targeting named and never in
+place of them. Packages, path aliases (`@/…`), stylesheets and images are not followed; a denied path is never read; the
+extra files share the existing size limits, and if the runtime still finds the context too large the call is retried
+without them. The `codegen.context` log line now also carries `importedPaths`, what was skipped and why (`import: too
+large`, `import: over budget`, `import: unreadable`, `import: denied`, `import: not in workspace`) and how many path
+aliases were not followed. The workflow file is unchanged, so a repository on 9.0.0 picks this up with its next
+"runner version" pull request.
+
 **9.0.0 — a failed run keeps its files.** When a run fails after code generation, the runner writes the files it
 generated, a copy of the last test report and a short `manifest.json` (run, targets, files, the reason it stopped;
 no credentials) to `quikpilot-failure/`, and the workflow's new `Keep the files of a failed run` step uploads that folder

package/dist/index.js

@@ -230,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) {
@@ -382,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"]);
@@ -604,16 +913,38 @@ async function runCodegen(gateway, targets, workspaceListing, requiredTests, den
       }
     }
     const namedContents = contextPaths.map((path2) => ({ path: path2, content: (0, import_node_fs.readFileSync)(path2, "utf8") }));
-    const added = collectRunContext(target, targets, new Set(contextPaths), deniedPaths);
-    const contextContents = [...namedContents, ...added.entries];
-    for (const s of added.skipped) {
+    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);
@@ -679,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) {
@@ -794,14 +1126,14 @@ async function runCodegen(gateway, targets, workspaceListing, requiredTests, den
 }
 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([
@@ -880,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;
@@ -951,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;
@@ -1161,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;
@@ -1172,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);
@@ -1196,7 +1528,7 @@ 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 {
@@ -1207,7 +1539,7 @@ function readTestReportBytes(cwd = process.cwd()) {
   }
 }
 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}`;
@@ -1262,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");
@@ -1448,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);
@@ -1609,7 +1941,7 @@ async function runBaselineCheck(params) {
 
 // src/failureArtifact.ts
 var import_node_fs7 = require("node:fs");
-var import_node_path5 = require("node:path");
+var import_node_path6 = require("node:path");
 
 // src/failureReason.ts
 var MAX_FAILURE_REASON = 1e3;
@@ -1650,18 +1982,18 @@ 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.0.0" : "dev";
+var RUNNER_VERSION = true ? "9.1.0" : "dev";
 function safeDestination(base, repoPath) {
-  if (!repoPath || (0, import_node_path5.isAbsolute)(repoPath)) return null;
-  const destination = (0, import_node_path5.resolve)(base, repoPath);
-  const rel = (0, import_node_path5.relative)(base, destination);
-  if (!rel || rel.startsWith("..") || (0, import_node_path5.isAbsolute)(rel)) return null;
+  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_path5.resolve)(input.cwd, FAILURE_ARTIFACT_DIR);
+    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 = [];
@@ -1672,7 +2004,7 @@ function writeFailureArtifact(input) {
         skipped.push(result.targetPath);
         continue;
       }
-      (0, import_node_fs7.mkdirSync)((0, import_node_path5.dirname)(destination), { recursive: true });
+      (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) });
     }
@@ -1681,7 +2013,7 @@ function writeFailureArtifact(input) {
       if (input.testReport.byteLength > MAX_REPORT_BYTES) {
         testReport = "too-large";
       } else {
-        (0, import_node_fs7.writeFileSync)((0, import_node_path5.join)(base, REPORT_COPY), input.testReport);
+        (0, import_node_fs7.writeFileSync)((0, import_node_path6.join)(base, REPORT_COPY), input.testReport);
         testReport = "included";
       }
     }
@@ -1701,8 +2033,8 @@ function writeFailureArtifact(input) {
       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_path5.join)(base, "manifest.json"), text);
-    return { written: (0, import_node_fs7.existsSync)((0, import_node_path5.join)(base, "manifest.json")) };
+    (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 };
@@ -1786,7 +2118,7 @@ function describeScopeViolations(check) {
 }
 
 // src/targeting.ts
-var import_node_path6 = require("node:path");
+var import_node_path7 = require("node:path");
 var CONTRACT_VERSION2 = "test-targets-1";
 function listWorkspaceFiles(workspaceRoot) {
   return listFiles(workspaceRoot ?? ".");
@@ -1815,9 +2147,9 @@ function validateTarget(target, workspaceRoot, workspaceListing, deniedPaths) {
     }
     return;
   }
-  const root = (0, import_node_path6.resolve)(workspaceRoot ?? ".");
-  const rel = (0, import_node_path6.relative)(root, (0, import_node_path6.resolve)(target.path));
-  if (rel.startsWith("..") || (0, import_node_path6.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}`
     );