@open-tomato/rafa 0.33.0 → 0.34.0

package/dist/{index-w3vyb08t.js → index-4b3m7s0z.js}

@@ -13,7 +13,7 @@ import {
   trackerPathFor,
   updateTrackerLine,
   writeTrackerBlocker
-} from "./index-zn08ywsv.js";
+} from "./index-v8d7c6sw.js";
 import {
   ACROSS_STORES_ORDER,
   CORE_ADAPTER_REGISTRY,
@@ -127,7 +127,7 @@ import {
   writeNames,
   writePositionFile,
   writeSqliteStore
-} from "./index-kz7e4gtt.js";
+} from "./index-bvfbfa63.js";
 import {
   CHANGE_LEVELS,
   CONFIG_DEFAULTS,
@@ -155,7 +155,7 @@ import {
   requiredPrerequisite,
   resolveTiers,
   stampPrompt
-} from "./index-dv0ycmp8.js";
+} from "./index-vp0xghk2.js";
 import {
   promotable
 } from "./index-d6d0942q.js";
@@ -8183,6 +8183,11 @@ function createGhPullRequests(options) {
       const text = textArgument(title, "editTitle", "title", false);
       await succeed(["pr", "edit", target, "--title", text], `gh pr edit ${target} --title <title>`);
     },
+    editBase: async (number, base) => {
+      const target = pullNumber(number, "editBase");
+      const branch = textArgument(base, "editBase", "base", false);
+      await succeed(["pr", "edit", target, "--base", branch], `gh pr edit ${target} --base ${branch}`);
+    },
     editBody: async (number, body) => {
       const target = pullNumber(number, "editBody");
       const text = bodyText(body, "editBody");
@@ -14329,7 +14334,7 @@ function withOutlineCache(outline, root) {
 import path2 from "path";
 async function coreRoster() {
   const [{ CORE_REGISTRY }, { describeRegistry }] = await Promise.all([
-    import("./index-13caphhp.js"),
+    import("./index-b8t7q5hc.js"),
     import("./describe-5hqfwbjc.js")
   ]);
   return describeRegistry(CORE_REGISTRY, version);
@@ -20569,6 +20574,47 @@ function hasBranch(refs, stub) {
   const branch = `${BRANCH_PREFIX2}${stub}`;
   return refs.some((ref7) => ref7 === branch || ref7.endsWith(`/${branch}`));
 }
+function readBranchTips(sources, remote, stub, note) {
+  const branch = `${BRANCH_PREFIX2}${stub}`;
+  const tips = [];
+  for (const ref7 of [`refs/heads/${branch}`, `refs/remotes/${remote}/${branch}`]) {
+    const resolved = sources.git(["rev-parse", "--verify", "--quiet", `${ref7}^{commit}`]);
+    const said = gitSaid(resolved);
+    if (resolved.ok && resolved.stdout.trim() !== "") {
+      tips.push(ref7);
+    } else if (said !== "") {
+      note(`\`${ref7}\` could not be read, so its plan reads as started: ${said}`);
+      return null;
+    }
+  }
+  return tips;
+}
+function readBranchMessages(sources, ref7, note) {
+  const result = sources.git(["log", "-z", "--format=%B", `${sources.base}..${ref7}`]);
+  if (!result.ok) {
+    note(`the commits of \`${ref7}\` past \`${sources.base}\` could not be read, so its plan reads as started: ${gitSaid(result)}`);
+    return null;
+  }
+  return result.stdout.split("\x00").map((message) => message.trim()).filter((message) => message !== "");
+}
+function claimsOnly(messages) {
+  return messages.length > 0 && messages.every((message) => parseClaimMessage(message).kind === "ownership");
+}
+function hasStartedBranch(sources, remote, refs, stub, note) {
+  if (!hasBranch(refs, stub))
+    return false;
+  const tips = readBranchTips(sources, remote, stub, note);
+  if (tips === null)
+    return true;
+  if (tips.length === 0) {
+    note(`\`${BRANCH_PREFIX2}${stub}\` is on ${remote} but not fetched here, so its commits were not read and its plan reads as started`);
+    return true;
+  }
+  return tips.some((ref7) => {
+    const messages = readBranchMessages(sources, ref7, note);
+    return messages === null || !claimsOnly(messages);
+  });
+}
 function openWorld(sources) {
   let problems = [];
   const note = (problem) => {
@@ -20593,7 +20639,7 @@ function openWorld(sources) {
     tracked: once2(() => readTracked(sources, note)),
     checkout: once2(() => readCheckout(sources, note)),
     branchPlan: once2(() => readBranchPlan(branch(), plans())),
-    unstartedPlan: once2(() => plans().find((plan) => !hasRun(runs(), plan.stub) && !hasBranch(refs(), plan.stub)) ?? null),
+    unstartedPlan: once2(() => plans().find((plan) => !hasRun(runs(), plan.stub) && !hasStartedBranch(sources, remote, refs(), plan.stub, note)) ?? null),
     openPull: once2(() => readOpenPull(sources, branch(), note)),
     roadmap,
     picked: once2(async () => {
@@ -21674,7 +21720,7 @@ var ready_default = createIssueReadyCommand();
 
 // src/start.ts
 import fs from "fs";
-import { homedir as homedir8 } from "os";
+import { homedir as homedir9 } from "os";
 import path4 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
@@ -23761,6 +23807,26 @@ async function handOut(handout, task, resolution, repoRoot) {
   return { resolver: handout.resolver, skills, lessons };
 }
 
+// src/start/inherited-notice.ts
+var INHERITED_HEADING = "## Failures this run inherited";
+var INHERITED_SENTENCE = "These tests were already failing when this run started. " + "They need no proof that they predate your task: do not run `git stash` or check out a clean worktree of `main` to show it. " + "A bug you report for one of them, by its file and case, is recognised as inherited and files nothing.";
+var INHERITED_LIST_CAP = 20;
+function oneLine7(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function failureLine(failure3) {
+  return `- \`${oneLine7(failure3.file)}\`: ${oneLine7(failure3.name)}`;
+}
+function renderInheritedSection(failures) {
+  if (failures.length === 0)
+    return "";
+  const listed = failures.slice(0, INHERITED_LIST_CAP).map(failureLine);
+  const rest = failures.length - listed.length;
+  const more = rest > 0 ? [`- ...and ${rest} more.`] : [];
+  return [INHERITED_HEADING, INHERITED_SENTENCE, ...listed, ...more].join(`
+`);
+}
+
 // src/start/preflight.ts
 import { randomUUID as randomUUID7 } from "crypto";
 import { existsSync as existsSync27, readFileSync as readFileSync33 } from "fs";
@@ -24584,16 +24650,16 @@ function baseLines(base) {
 }
 var NO_TASK_SECTIONS = { skills: "", lessons: "" };
 function sectionLines(sections2) {
-  return [sections2.skills, sections2.lessons].filter((section) => section.trim().length > 0).flatMap((section) => [section, ""]);
+  return [sections2.skills, sections2.lessons, sections2.inherited].filter((section) => section.trim().length > 0).flatMap((section) => [section, ""]);
 }
-function buildTaskPrompt(taskText, promptContent, planText, knownMissing = [], blocker = null, sections2 = NO_TASK_SECTIONS, base = null) {
+function buildTaskPrompt(taskText, promptContent, planText, knownMissing = [], blocker = null, sections2 = NO_TASK_SECTIONS, base = null, inherited = []) {
   return [
     `Your scoped task is: ${taskText}`,
     "Consider tasks listed above this one in the plan checklist as completed. Do not re-evaluate or re-do them. Focus only on the scoped task.",
     ...blockerLines(blocker),
     ...baseLines(base),
     "",
-    ...sectionLines(sections2),
+    ...sectionLines({ ...sections2, inherited: renderInheritedSection(inherited) }),
     promptContent,
     planText,
     ...knownMissingNotice(knownMissing)
@@ -24635,7 +24701,7 @@ async function dispatchTask(options) {
   const resolution = options.serving === null ? EMPTY_RESOLUTION : resolveSessionTiers(options.serving);
   const task = taskInputFor(taskInfo, taskText, declaration, options.planContent);
   const handed = await handOut(options.handout, task, resolution, options.repoRoot);
-  const prompt = withStamp(buildTaskPrompt(taskText, options.promptContent, injection.text, options.knownMissing, taskInfo.blocker ?? null, { skills: renderSkillsSection(handed.skills), lessons: renderLessonsSection(handed.lessons) }, options.base));
+  const prompt = withStamp(buildTaskPrompt(taskText, options.promptContent, injection.text, options.knownMissing, taskInfo.blocker ?? null, { skills: renderSkillsSection(handed.skills), lessons: renderLessonsSection(handed.lessons) }, options.base, options.inherited));
   const served = serveForSession(options.serving, resolution);
   const sessionId = (options.newSessionId ?? randomUUID8)();
   const session = await run(prompt, flags, sessionId, options.settingSources, served, options.checkout);
@@ -24770,6 +24836,8 @@ function summaryOf3(event) {
       return `${padKind("no pr")}${oneLine(event.reason)}`;
     case "halt":
       return `${padKind("halt")}${oneLine(event.reason)}`;
+    case "inherited":
+      return `${padKind("inherited")}${oneLine(`${event.file} > ${event.name}`)}`;
   }
 }
 function emitLoopEvent(event, now = () => new Date) {
@@ -26276,6 +26344,9 @@ function baselinePathFor(trackerPath) {
   }
   return join32(dirname11(trackerPath), `${BASELINE_FILE_PREFIX}${match[1] ?? ""}.json`);
 }
+function copyFailure(failure3) {
+  return failure3.message === undefined ? { file: failure3.file, name: failure3.name } : { file: failure3.file, name: failure3.name, message: failure3.message };
+}
 function baselineOf(result, recordedAt, commit) {
   return {
     version: BASELINE_VERSION,
@@ -26284,7 +26355,7 @@ function baselineOf(result, recordedAt, commit) {
     command: [...result.command],
     exitCode: result.exitCode,
     summary: result.summary,
-    failures: result.failures.map((failure3) => ({ file: failure3.file, name: failure3.name })),
+    failures: result.failures.map(copyFailure),
     errors: result.errors,
     junit: result.junit
   };
@@ -26303,7 +26374,8 @@ function isFailure(value) {
   if (typeof value !== "object" || value === null)
     return false;
   const record = value;
-  return typeof record["file"] === "string" && typeof record["name"] === "string";
+  const message = record["message"];
+  return typeof record["file"] === "string" && typeof record["name"] === "string" && (message === undefined || typeof message === "string");
 }
 function badField(record) {
   const checks = [
@@ -26503,8 +26575,18 @@ function closeCase(walk) {
   if (open === null || !open.failed)
     return;
   const held = walk.failures.some((failure3) => failure3.file === open.file && failure3.name === open.name);
-  if (!held)
-    walk.failures.push({ file: open.file, name: open.name });
+  if (held)
+    return;
+  walk.failures.push(open.message === undefined ? { file: open.file, name: open.name } : { file: open.file, name: open.name, message: open.message });
+}
+function firstMessageLine(message) {
+  const line = message?.split(/\r?\n/, 1)[0]?.trim() ?? "";
+  return line === "" ? undefined : line;
+}
+function failCase(open, attributes) {
+  open.failed = true;
+  if (open.message === undefined)
+    open.message = firstMessageLine(attributes["message"]);
 }
 function openCase(walk, attributes) {
   const [fileSuite, ...describes] = walk.suites;
@@ -26531,7 +26613,7 @@ function takeTag(walk, match) {
     return;
   }
   if ((element === "failure" || element === "error") && closing !== "/" && walk.open !== null)
-    walk.open.failed = true;
+    failCase(walk.open, attributes);
 }
 function parseJunitFailures(xml) {
   if (!/<testsuites\b/.test(xml) || !xml.includes("</testsuites>"))
@@ -27108,9 +27190,266 @@ function createRunSuiteSteps(options) {
   return { beforeSession, afterTask };
 }
 
+// src/start/triage.ts
+import { homedir as homedir8 } from "os";
+
+// src/triage/bug-key.ts
+import { basename as basename11 } from "path";
+
+// src/triage/test-failure.ts
+var TEST_FILE = "(?:/?(?:[\\w.@+-]+/)*)[\\w.@+-]+\\.(?:test|spec)\\.[cm]?[jt]sx?";
+var TEST_FILE_ANYWHERE = new RegExp(`(?<![\\w.@+/-])${TEST_FILE}(?![\\w])`, "g");
+var FAIL_LINE = /^\s*\(fail\)\s+(.+?)(?:\s+\[\d+(?:\.\d+)?m?s\])?\s*$/;
+var FILE_CASE_LINE = new RegExp(`^\\s*(${TEST_FILE})\\s+>\\s+(.+?)\\s*$`);
+var FILE_HEADER = new RegExp(`^\\s*(${TEST_FILE}):\\s*$`);
+var NOISE_LINES = [
+  /^\s*$/,
+  FILE_HEADER,
+  /^\s*\d+\s+\|/,
+  /^\s*\^+\s*$/,
+  /^\s*at\s/,
+  /^\s*bun test v/
+];
+var ERROR_PREFIX = /^error:\s+/;
+function caseLineOf(line, index) {
+  const fail = FAIL_LINE.exec(line);
+  if (fail !== null)
+    return { index, name: fail[1], file: null };
+  const fileCase = FILE_CASE_LINE.exec(line);
+  return fileCase === null ? null : { index, name: fileCase[2], file: fileCase[1] };
+}
+function linesOf2(text) {
+  return text.split(/\r?\n/);
+}
+function caseLinesOf(lines) {
+  return lines.map((line, index) => caseLineOf(line, index)).filter((found) => found !== null);
+}
+function testFilesIn(text) {
+  return text.match(TEST_FILE_ANYWHERE) ?? [];
+}
+function firstEvidence(lines) {
+  const found = lines.find((line) => caseLineOf(line, 0) === null && !NOISE_LINES.some((noise) => noise.test(line)));
+  return found === undefined ? null : found.trim().replace(ERROR_PREFIX, "");
+}
+function testFileOf(found, artifactLines, what) {
+  if (found.file !== null)
+    return found.file;
+  const above = artifactLines.slice(0, found.index);
+  const header = above.map((line) => FILE_HEADER.exec(line)?.[1]).filter((file) => file !== undefined).at(-1);
+  const before = testFilesIn(above.join(`
+`));
+  const after = testFilesIn(artifactLines.slice(found.index).join(`
+`));
+  return header ?? before.at(-1) ?? after[0] ?? testFilesIn(what)[0] ?? null;
+}
+function evidenceOf(found, artifactLines) {
+  if (found === null)
+    return firstEvidence(artifactLines);
+  const cases = caseLinesOf(artifactLines);
+  const previous = cases.filter((other) => other.index < found.index).at(-1);
+  const next = cases.find((other) => other.index > found.index);
+  const before = artifactLines.slice(previous === undefined ? 0 : previous.index + 1, found.index);
+  const after = artifactLines.slice(found.index + 1, next === undefined ? artifactLines.length : next.index);
+  return firstEvidence(before) ?? firstEvidence(after);
+}
+function testFailureOf(bug) {
+  const artifactLines = linesOf2(bug.artifact ?? "");
+  const what = bug.what ?? "";
+  const inArtifact = caseLinesOf(artifactLines)[0];
+  if (inArtifact !== undefined) {
+    return {
+      file: testFileOf(inArtifact, artifactLines, what),
+      name: inArtifact.name,
+      evidence: evidenceOf(inArtifact, artifactLines)
+    };
+  }
+  const inWhat = caseLinesOf(linesOf2(what))[0];
+  if (inWhat === undefined)
+    return null;
+  return {
+    file: inWhat.file ?? testFilesIn(bug.artifact ?? "")[0] ?? testFilesIn(what)[0] ?? null,
+    name: inWhat.name,
+    evidence: evidenceOf(null, artifactLines)
+  };
+}
+
+// src/triage/bug-key.ts
+var KEY_SEPARATOR = ": ";
+var CASE_SEPARATOR = " > ";
+function hasText2(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function artifactOf(bug) {
+  return hasText2(bug.artifact) && textProblem(bug.artifact) === null ? bug.artifact : null;
+}
+function oneLine8(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+var COMMIT_HASH = /\b[0-9a-f]{7,40}\b/gi;
+var FOLDER_PREFIX = /[^\s'"`()[\]{}<>,;|]*\//g;
+var NUMBER = /\d+/g;
+function strippedText(text) {
+  const taken = text.replace(COMMIT_HASH, "").replace(FOLDER_PREFIX, "").replace(NUMBER, "");
+  return oneLine8(taken);
+}
+function keyText(text) {
+  const stripped = strippedText(text);
+  return stripped.length > 0 ? stripped : oneLine8(text);
+}
+function testFailureKeyOf(failure3) {
+  const test = failure3.file === null ? oneLine8(failure3.name) : `${basename11(failure3.file)}${CASE_SEPARATOR}${oneLine8(failure3.name)}`;
+  return failure3.evidence === null ? test : `${test}${KEY_SEPARATOR}${keyText(failure3.evidence)}`;
+}
+function bugKeyOf(trackerPath, artifact, what = null) {
+  const failure3 = testFailureOf({ what, artifact });
+  return failure3 === null ? `${basename11(trackerPath)}${KEY_SEPARATOR}${keyText(artifact)}` : testFailureKeyOf(failure3);
+}
+function legacyBugKeyOf(trackerPath, artifact) {
+  return `${basename11(trackerPath)}${KEY_SEPARATOR}${oneLine8(artifact)}`;
+}
+
+// src/triage/inherited.ts
+import { basename as basename12 } from "path";
+var CLOSED_ISSUE_STATES = ["done", "released", "cancelled"];
+function isOpenIssueState(state) {
+  return !CLOSED_ISSUE_STATES.includes(state);
+}
+function sameFailure(failure3, baseline) {
+  const { file, evidence } = failure3;
+  if (file === null)
+    return false;
+  const sameTest = basename12(file) === basename12(baseline.file) && oneLine8(failure3.name) === oneLine8(baseline.name);
+  const message = baseline.message ?? null;
+  if (!sameTest || !hasText2(message))
+    return sameTest;
+  return evidence !== null && keyText(evidence).includes(keyText(message));
+}
+function inheritedFailureOf(bug, failures) {
+  const failure3 = testFailureOf(bug);
+  if (failure3 === null)
+    return null;
+  return failures.find((baseline) => sameFailure(failure3, baseline)) ?? null;
+}
+
+// src/triage/issue-text.ts
+var TITLE_MAX_LENGTH = 120;
+var TITLE_CUT = "...";
+var MIN_FENCE_LENGTH = 3;
+var ISSUE_OPENING = "An out-of-scope bug a rafa task session reported. The loop filed it and" + " dispatches no task for it: a plan that wants it fixed declares a task.";
+var COMMENT_OPENING = "Reported again by a rafa task session.";
+function fenced(value) {
+  const runs = Array.from(value.matchAll(/`+/g), (run) => run[0].length);
+  const fence = "`".repeat(Math.max(MIN_FENCE_LENGTH, ...runs.map((length) => length + 1)));
+  const body = value.endsWith(`
+`) ? value : `${value}
+`;
+  return `${fence}
+${body}${fence}`;
+}
+function issueTitle2(redactedWhat) {
+  const line = oneLine8(redactedWhat);
+  const points = Array.from(line);
+  if (points.length <= TITLE_MAX_LENGTH)
+    return line;
+  const kept = points.slice(0, TITLE_MAX_LENGTH - TITLE_CUT.length).join("");
+  return `${kept.trimEnd()}${TITLE_CUT}`;
+}
+function scoreText(score) {
+  return score.toFixed(2);
+}
+function similarCommentOpening(score, threshold) {
+  return `${COMMENT_OPENING} No key found this issue: the report's words match its first report` + ` at a Jaccard similarity of ${scoreText(score)}, at or above the threshold of` + ` ${String(threshold)}, so it is taken for the same bug.`;
+}
+function possibleDuplicatesSection(duplicates2, redact) {
+  const intro = `No open bug scored at or above the similarity threshold of ${String(duplicates2.threshold)}.`;
+  const listed = duplicates2.nearest.length === 0 ? "No open bug shares a word with this one." : duplicates2.nearest.map(({ issue: issue3, score }) => `- ${issueNameOf(issue3.ref)} (score ${scoreText(score)})`).join(`
+`);
+  return `## Possible duplicates
+
+${redact(`${intro}
+
+${listed}`)}`;
+}
+function issueNameOf(ref8) {
+  return ref8.url ?? `${ref8.kind} issue ${ref8.externalId}`;
+}
+function supersedesSection(closed, redact) {
+  const sentence = `This bug came back after ${issueNameOf(closed)} was closed as completed;` + " this issue is filed in its place.";
+  return `## Supersedes
+
+${redact(sentence)}`;
+}
+function section(heading, value, absent2, redact) {
+  const shown = value === null ? absent2 : fenced(redact(value));
+  return `## ${heading}
+
+${shown}`;
+}
+function issueText(opening, values, redact) {
+  return [
+    opening,
+    ...values.supersedes === undefined ? [] : [supersedesSection(values.supersedes, redact)],
+    section("What", values.what, "", redact),
+    section("Artifact", values.artifact, "The report gave no artifact, so a recurrence files again.", redact),
+    ...values.refs === null ? [] : [values.refs],
+    section("Recurrence key", values.key, "The report gave no artifact, so this bug has no key.", redact),
+    section("Plan", values.planStub, "The dispatch resolved no plan stub.", redact),
+    section("Task", values.taskText, "", redact),
+    section("Feedback", values.feedback, "The report gave no feedback.", redact),
+    ...values.duplicates === undefined ? [] : [possibleDuplicatesSection(values.duplicates, redact)]
+  ].join(`
+
+`) + `
+`;
+}
+
+// src/triage/local-paths.ts
+import { realpathSync as realpathSync5 } from "fs";
+import { resolve as resolve20 } from "path";
+var HOME_MARKER = "[redacted: HOME]";
+var SEGMENT = "[^/\\s'\"`()<>:,;]+";
+var HOME_PATTERN = `(?:/${SEGMENT})*?/(?:Users|home)/${SEGMENT}`;
+var PATH_START = "(?:(?<![\\w.\\-])|(?<=(?:^|\\s)-[A-Za-z]))";
+var UNDER = "(/)(?=[^\\s'\"`()<>])";
+var PATH_END = "(?![\\w\\-]|\\.[\\w.\\-/])";
+function literalPattern(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function forms(path3) {
+  const given = resolve20(path3);
+  try {
+    const real = realpathSync5(given);
+    return real === given ? [given] : [given, real];
+  } catch {
+    return [given];
+  }
+}
+function isRoot(path3) {
+  return path3.length > 1;
+}
+function localPathRedactor(repoRoot, home) {
+  const asHome = (pattern) => ({ pattern, under: `${HOME_MARKER}/`, bare: HOME_MARKER });
+  const asRepo = (pattern) => ({ pattern, under: "", bare: "." });
+  const literals = [
+    ...forms(repoRoot).filter(isRoot).map((root) => asRepo(literalPattern(root))),
+    ...forms(home).filter(isRoot).map((root) => asHome(literalPattern(root)))
+  ];
+  const roots = [
+    ...[...literals].sort((a, b) => b.pattern.length - a.pattern.length),
+    asHome(HOME_PATTERN)
+  ];
+  const alternatives = roots.map(({ pattern }) => `(${pattern})(?:${UNDER}|${PATH_END})`);
+  const matcher = new RegExp(`${PATH_START}(?:${alternatives.join("|")})`, "g");
+  return (text) => text.replace(matcher, (...groups) => {
+    const index = roots.findIndex((_, at) => groups[1 + at * 2] !== undefined);
+    const root = roots[index];
+    return groups[2 + index * 2] === undefined ? root.bare : root.under;
+  });
+}
+
 // src/triage/triage.ts
 import { homedir as homedir7 } from "os";
-import { basename as basename11, join as join35 } from "path";
+import { join as join35 } from "path";
 
 // src/effort/store/tracker-refs.ts
 import { randomUUID as randomUUID9 } from "crypto";
@@ -27129,10 +27468,11 @@ var INSERT_REF = `
   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ${stampedValues("findings")})
 `;
 var ATTACH_REF = "UPDATE findings SET tracker_ref = ? WHERE seq = ? AND tracker_ref IS NULL";
-var SELECT_OLDEST = `
+var NEWEST_FIRST = ACROSS_STORES_ORDER.split(",").map((term) => `${term.trim()} DESC`).join(", ");
+var SELECT_NEWEST = `
   SELECT seq, tracker_ref FROM findings
   WHERE artifact = ? AND tracker_ref IS NOT NULL
-  ORDER BY seq
+  ORDER BY ${NEWEST_FIRST}
   LIMIT 1
 `;
 var REFUSAL_TAILS = { write: "nothing written", read: "nothing opened" };
@@ -27205,7 +27545,18 @@ function heldRefOf(path3, seq, text) {
     return stored;
   throw new Error(`effort store: ${path3}: findings row ${seq} holds a tracker_ref ${stored};` + " no writer stores one");
 }
-function placeRef(db, path3, write, wanted, insertValues) {
+
+class SupersedeInSessionRefusal extends Error {
+  path;
+  seq;
+  constructor(path3, seq) {
+    super(`effort store: ${path3}: tracker ref write supersedes the reference findings row ${seq} holds` + " for this session and artifact, and findings_by_artifact holds one row per session and" + " artifact; nothing written");
+    this.name = "SupersedeInSessionRefusal";
+    this.path = path3;
+    this.seq = seq;
+  }
+}
+function placeRef(db, path3, write, wanted, superseded, insertValues) {
   const held = db.query(SELECT_HELD2).get(write.dispatch.sessionId, write.artifact);
   if (held === null) {
     db.query(INSERT_REF).run(...insertValues());
@@ -27216,14 +27567,27 @@ function placeRef(db, path3, write, wanted, insertValues) {
     return ["attached", wanted.ref];
   }
   const kept = heldRefOf(path3, held.seq, held.tracker_ref);
+  if (kept.json === superseded?.json)
+    throw new SupersedeInSessionRefusal(path3, held.seq);
   return kept.json === wanted.json ? ["held", kept.ref] : ["conflict", kept.ref];
 }
+function supersededOf(write, wanted) {
+  if (write.supersedes === undefined)
+    return null;
+  const superseded = storedRefOf(write.supersedes);
+  if (typeof superseded === "string")
+    throw refused("write", `supersedes a reference ${superseded}`);
+  if (superseded.json === wanted.json)
+    throw refused("write", "supersedes the reference it writes");
+  return superseded;
+}
 function writeTrackerRef(repoRoot, write, seams = {}) {
   checkDispatch("tracker ref", write.dispatch, write.outcome);
   checkArtifact("write", write.artifact);
   const wanted = storedRefOf(write.ref);
   if (typeof wanted === "string")
     throw refused("write", `has a reference ${wanted}`);
+  const superseded = supersededOf(write, wanted);
   const path3 = sqliteStorePath(repoRoot);
   const { sessionId, planStub: planStub2, taskLine } = write.dispatch;
   const collectedAt = (seams.now ?? (() => new Date))().toISOString();
@@ -27239,7 +27603,7 @@ function writeTrackerRef(repoRoot, write, seams = {}) {
     collectedAt
   ];
   const [action, stored] = withSqliteStore(path3, "write", !existsSync33(path3), (db) => {
-    const place = db.transaction(() => placeRef(db, path3, write, wanted, insertValues));
+    const place = db.transaction(() => placeRef(db, path3, write, wanted, superseded, insertValues));
     return place.immediate();
   });
   return { path: path3, action, stored };
@@ -27249,52 +27613,8 @@ function readTrackerRef(repoRoot, artifact) {
   const path3 = sqliteStorePath(repoRoot);
   if (!existsSync33(path3))
     return null;
-  const oldest = withSqliteStore(path3, "read", false, (db) => db.query(SELECT_OLDEST).get(artifact));
-  return oldest === null ? null : heldRefOf(path3, oldest.seq, oldest.tracker_ref).ref;
-}
-
-// src/triage/local-paths.ts
-import { realpathSync as realpathSync5 } from "fs";
-import { resolve as resolve20 } from "path";
-var HOME_MARKER = "[redacted: HOME]";
-var SEGMENT = "[^/\\s'\"`()<>:,;]+";
-var HOME_PATTERN = `(?:/${SEGMENT})*?/(?:Users|home)/${SEGMENT}`;
-var PATH_START = "(?:(?<![\\w.\\-])|(?<=(?:^|\\s)-[A-Za-z]))";
-var UNDER = "(/)(?=[^\\s'\"`()<>])";
-var PATH_END = "(?![\\w\\-]|\\.[\\w.\\-/])";
-function literalPattern(text) {
-  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function forms(path3) {
-  const given = resolve20(path3);
-  try {
-    const real = realpathSync5(given);
-    return real === given ? [given] : [given, real];
-  } catch {
-    return [given];
-  }
-}
-function isRoot(path3) {
-  return path3.length > 1;
-}
-function localPathRedactor(repoRoot, home) {
-  const asHome = (pattern) => ({ pattern, under: `${HOME_MARKER}/`, bare: HOME_MARKER });
-  const asRepo = (pattern) => ({ pattern, under: "", bare: "." });
-  const literals = [
-    ...forms(repoRoot).filter(isRoot).map((root) => asRepo(literalPattern(root))),
-    ...forms(home).filter(isRoot).map((root) => asHome(literalPattern(root)))
-  ];
-  const roots = [
-    ...[...literals].sort((a, b) => b.pattern.length - a.pattern.length),
-    asHome(HOME_PATTERN)
-  ];
-  const alternatives = roots.map(({ pattern }) => `(${pattern})(?:${UNDER}|${PATH_END})`);
-  const matcher = new RegExp(`${PATH_START}(?:${alternatives.join("|")})`, "g");
-  return (text) => text.replace(matcher, (...groups) => {
-    const index = roots.findIndex((_, at) => groups[1 + at * 2] !== undefined);
-    const root = roots[index];
-    return groups[2 + index * 2] === undefined ? root.bare : root.under;
-  });
+  const newest = withSqliteStore(path3, "read", false, (db) => db.query(SELECT_NEWEST).get(artifact));
+  return newest === null ? null : heldRefOf(path3, newest.seq, newest.tracker_ref).ref;
 }
 
 // src/triage/refs-section.ts
@@ -27358,17 +27678,72 @@ function createArtifactRefsVerifier(repoRoot, env) {
   };
 }
 
+// src/triage/similarity.ts
+import { basename as basename13 } from "path";
+var NON_WORD2 = /\W+/;
+var FENCE_LINE6 = /^`{3,}$/;
+var HEADING_LINE3 = /^## (.+)$/;
+function wordSetOf(text) {
+  const words = strippedText(text).toLowerCase().split(NON_WORD2).filter((word) => word.length > 0);
+  return new Set(words);
+}
+function reportWordsOf(report2) {
+  return wordSetOf(`${report2.what ?? ""}
+${report2.artifact ?? ""}`);
+}
+function jaccard(a, b) {
+  const shared = [...a].filter((word) => b.has(word)).length;
+  const all = a.size + b.size - shared;
+  return all === 0 ? 0 : shared / all;
+}
+function fencedValueAt(lines, start) {
+  const open = lines.slice(start).findIndex((line) => line.trim().length > 0);
+  if (open === -1)
+    return null;
+  const fence = lines[start + open];
+  if (!FENCE_LINE6.test(fence))
+    return null;
+  const body = lines.slice(start + open + 1);
+  const close = body.indexOf(fence);
+  return close === -1 ? null : body.slice(0, close).join(`
+`);
+}
+function sectionValueOf(body, heading) {
+  const lines = body.split(/\r?\n/);
+  const at = lines.findIndex((line) => HEADING_LINE3.exec(line)?.[1]?.trim() === heading);
+  return at === -1 ? null : fencedValueAt(lines, at + 1);
+}
+function issueTextOf(body) {
+  return {
+    what: sectionValueOf(body, "What"),
+    artifact: sectionValueOf(body, "Artifact")
+  };
+}
+function testFileOf2(text) {
+  const file = testFailureOf(text)?.file ?? testFilesIn(text.artifact ?? "")[0] ?? testFilesIn(text.what ?? "")[0] ?? null;
+  return file === null ? null : basename13(file);
+}
+function namesOtherTestFile(reportFile, issueFile) {
+  return reportFile !== null && issueFile !== null && reportFile !== issueFile;
+}
+function nearestOpenBugs(report2, openBugs) {
+  const words = reportWordsOf(report2);
+  const reportFile = testFileOf2(report2);
+  const scored = openBugs.flatMap((issue3) => {
+    const text = issueTextOf(issue3.body);
+    if (namesOtherTestFile(reportFile, testFileOf2(text)))
+      return [];
+    const score = jaccard(words, reportWordsOf(text));
+    return score > 0 ? [{ issue: issue3, score }] : [];
+  });
+  return [...scored].sort((a, b) => b.score - a.score);
+}
+
 // src/triage/triage.ts
 var PRIVATE_TRIAGE_DIR = join35(".rafa", "triage", "private");
 var SECRET_ENV_NAMES = ["GITHUB_TOKEN", "ANTHROPIC_API_KEY", "LINEAR_API_KEY"];
 var TRIAGE_MODULE = "unassigned";
 var BLOCKER_SEPARATOR = "; ";
-var KEY_SEPARATOR = ": ";
-var TITLE_MAX_LENGTH = 120;
-var TITLE_CUT = "...";
-var MIN_FENCE_LENGTH = 3;
-var ISSUE_OPENING = "An out-of-scope bug a rafa task session reported. The loop filed it and" + " dispatches no task for it: a plan that wants it fixed declares a task.";
-var COMMENT_OPENING = "Reported again by a rafa task session.";
 function privateTriageDir(repoRoot) {
   return join35(repoRoot, PRIVATE_TRIAGE_DIR);
 }
@@ -27405,9 +27780,6 @@ function redactSecrets(text, secrets) {
   const pattern = new RegExp(values.map(literalPattern2).join("|"), "g");
   return text.replace(pattern, (value) => `[redacted: ${nameByValue.get(value)}]`);
 }
-function hasText2(value) {
-  return typeof value === "string" && value.trim().length > 0;
-}
 function blockerTextOf(blockers) {
   const texts = blockers.map((blocker) => blocker.what).filter(hasText2);
   return texts.length === 0 ? null : texts.join(BLOCKER_SEPARATOR);
@@ -27426,57 +27798,11 @@ function triageBlockers(options) {
     return { text, written: false, problem: `the blocker was not written: ${messageOf(error)}` };
   }
 }
-function artifactOf(bug) {
-  return hasText2(bug.artifact) && textProblem(bug.artifact) === null ? bug.artifact : null;
-}
-function oneLine7(text) {
-  return text.replace(/\s+/g, " ").trim();
-}
-function bugKeyOf(trackerPath, artifact) {
-  return `${basename11(trackerPath)}${KEY_SEPARATOR}${oneLine7(artifact)}`;
-}
-function fenced(value) {
-  const runs = Array.from(value.matchAll(/`+/g), (run) => run[0].length);
-  const fence = "`".repeat(Math.max(MIN_FENCE_LENGTH, ...runs.map((length) => length + 1)));
-  const body = value.endsWith(`
-`) ? value : `${value}
-`;
-  return `${fence}
-${body}${fence}`;
-}
-function issueTitle2(redactedWhat) {
-  const line = oneLine7(redactedWhat);
-  const points = Array.from(line);
-  if (points.length <= TITLE_MAX_LENGTH)
-    return line;
-  const kept = points.slice(0, TITLE_MAX_LENGTH - TITLE_CUT.length).join("");
-  return `${kept.trimEnd()}${TITLE_CUT}`;
-}
-function section(heading, value, absent2, redact) {
-  const shown = value === null ? absent2 : fenced(redact(value));
-  return `## ${heading}
-
-${shown}`;
-}
-function issueText(opening, values, redact) {
-  return [
-    opening,
-    section("What", values.what, "", redact),
-    section("Artifact", values.artifact, "The report gave no artifact, so a recurrence files again.", redact),
-    ...values.refs === null ? [] : [values.refs],
-    section("Recurrence key", values.key, "The report gave no artifact, so this bug has no key.", redact),
-    section("Plan", values.planStub, "The dispatch resolved no plan stub.", redact),
-    section("Task", values.taskText, "", redact),
-    section("Feedback", values.feedback, "The report gave no feedback.", redact)
-  ].join(`
-
-`) + `
-`;
-}
 async function filingFor(what, bug, options, local, redact, verifyRefs) {
   const reported = artifactOf(bug);
   const artifact = reported === null ? null : local(reported);
-  const searchText = artifact === null ? null : bugKeyOf(options.trackerPath, redact(artifact));
+  const searchText = artifact === null ? null : bugKeyOf(options.trackerPath, redact(artifact), redact(what));
+  const key = artifact === null ? null : bugKeyOf(options.trackerPath, artifact, local(what));
   const refs = await buildRefsSection(artifact === null ? null : redact(artifact), verifyRefs);
   const values = {
     what,
@@ -27500,10 +27826,23 @@ async function filingFor(what, bug, options, local, redact, verifyRefs) {
     },
     comment: issueText(COMMENT_OPENING, values, redact),
     searchText,
-    key: artifact === null ? null : bugKeyOf(options.trackerPath, artifact),
-    legacyKey: reported === null || reported === artifact ? null : bugKeyOf(options.trackerPath, reported)
+    key,
+    legacyKeys: legacyKeysOf(options.trackerPath, key, reported, artifact),
+    values,
+    compared: { what: local(what), artifact }
   };
 }
+function legacyKeysOf(trackerPath, key, reported, artifact) {
+  if (key === null || reported === null || artifact === null)
+    return [];
+  const keys = [legacyBugKeyOf(trackerPath, artifact), legacyBugKeyOf(trackerPath, reported)];
+  return [...new Set(keys)].filter((legacy) => legacy !== key);
+}
+function similarityStepOf(options) {
+  const threshold = options.similarity?.triageSimilarityThreshold;
+  const candidates = options.similarity?.triageSimilarityCandidates;
+  return typeof threshold === "number" && typeof candidates === "number" ? { threshold, candidates } : null;
+}
 async function step(run, name2, action) {
   try {
     return { ok: true, value: await action() };
@@ -27523,47 +27862,110 @@ function resultOf(run, action, fields = {}) {
     ...fields
   };
 }
-async function settle(run, action, ref8, foundBy) {
+async function settle(run, action, ref8, foundBy, supersedes) {
   const { store } = run.route;
   const { key } = run.filing;
   if (store === null || key === null)
     return resultOf(run, action, { ref: ref8, foundBy });
-  const stored = await step(run, "storing the reference", () => store(key, ref8));
+  const stored = await step(run, "storing the reference", () => store(key, ref8, supersedes));
   return stored.ok ? resultOf(run, action, { ref: ref8, foundBy, stored: stored.value }) : resultOf(run, action, { ref: ref8, foundBy, problem: stored.problem });
 }
-async function fileNew(run) {
-  const created = await step(run, `the ${run.route.channel} tracker create`, () => run.route.tracker.create(run.filing.draft));
-  return created.ok ? settle(run, "filed", created.value, null) : resultOf(run, "failed", { problem: created.problem });
+async function fileNew(run, extras = {}) {
+  const { filing } = run;
+  const draft = extras.supersedes === undefined && extras.duplicates === undefined ? filing.draft : { ...filing.draft, body: issueText(ISSUE_OPENING, { ...filing.values, ...extras }, run.redact) };
+  const created = await step(run, `the ${run.route.channel} tracker create`, () => run.route.tracker.create(draft));
+  return created.ok ? settle(run, "filed", created.value, null, extras.supersedes) : resultOf(run, "failed", { problem: created.problem });
 }
-async function commentOn(run, ref8, foundBy) {
-  const commented = await step(run, `the ${run.route.channel} tracker comment`, () => run.route.tracker.comment(ref8, run.filing.comment));
+async function commentOn(run, ref8, foundBy, action = "commented", comment = run.filing.comment) {
+  const commented = await step(run, `the ${run.route.channel} tracker comment`, () => run.route.tracker.comment(ref8, comment));
   if (!commented.ok)
     return resultOf(run, "failed", { ref: ref8, foundBy, problem: commented.problem });
-  return foundBy === "store" ? resultOf(run, "commented", { ref: ref8, foundBy }) : settle(run, "commented", ref8, foundBy);
+  return foundBy === "store" ? resultOf(run, action, { ref: ref8, foundBy }) : settle(run, action, ref8, foundBy);
 }
-async function triageBug(run) {
+async function lookUp2(run, key, searchText) {
   const { route, filing } = run;
-  const { key, searchText } = filing;
-  if (key === null || searchText === null)
-    return fileNew(run);
   const { readStored } = route;
   if (readStored !== null) {
-    for (const storedKey of [key, filing.legacyKey]) {
-      if (storedKey === null)
-        continue;
+    for (const storedKey of [key, ...filing.legacyKeys]) {
       const stored = await step(run, "reading the stored reference", () => readStored(storedKey));
       if (!stored.ok)
-        return resultOf(run, "failed", { problem: stored.problem });
+        return stored;
       if (stored.value !== null && stored.value.kind === route.tracker.kind) {
-        return commentOn(run, stored.value, "store");
+        return { ok: true, value: { ref: stored.value, foundBy: "store" } };
       }
     }
   }
   const found = await step(run, `the ${route.channel} tracker find`, () => route.tracker.find({ text: searchText, type: "bug" }));
   if (!found.ok)
-    return resultOf(run, "failed", { problem: found.problem });
+    return found;
   const [match] = found.value;
-  return match === undefined ? fileNew(run) : commentOn(run, match, "find");
+  return {
+    ok: true,
+    value: match === undefined ? null : { ref: match, foundBy: "find" }
+  };
+}
+var COMPLETED_ISSUE_STATES = ["done", "released"];
+async function answerRecurrence(run, { ref: ref8, foundBy }) {
+  if (!run.route.readsState)
+    return commentOn(run, ref8, foundBy);
+  const issue3 = await step(run, `the ${run.route.channel} tracker get`, () => run.route.tracker.get(ref8));
+  if (!issue3.ok)
+    return resultOf(run, "failed", { ref: ref8, foundBy, problem: issue3.problem });
+  return COMPLETED_ISSUE_STATES.includes(issue3.value.state) ? fileNew(run, { supersedes: ref8 }) : commentOn(run, ref8, foundBy);
+}
+async function commentOnNearest(run, nearest, threshold) {
+  const opening = similarCommentOpening(nearest.score, threshold);
+  const comment = issueText(opening, run.filing.values, run.redact);
+  const result = await commentOn(run, nearest.issue.ref, "similarity", "commented", comment);
+  return { ...result, score: nearest.score };
+}
+async function answerMiss(run) {
+  const { tracker, similarity } = run.route;
+  const list = tracker.openIssues;
+  if (similarity === null || list === undefined)
+    return fileNew(run);
+  const listed = await step(run, `the ${run.route.channel} tracker openIssues`, () => list.call(tracker, "bug"));
+  if (!listed.ok)
+    return resultOf(run, "failed", { problem: listed.problem });
+  const nearest = nearestOpenBugs(run.filing.compared, listed.value);
+  const [first] = nearest;
+  return first !== undefined && first.score >= similarity.threshold ? commentOnNearest(run, first, similarity.threshold) : fileNew(run, { duplicates: { threshold: similarity.threshold, nearest: nearest.slice(0, similarity.candidates) } });
+}
+async function triageBug(run) {
+  const { key, searchText } = run.filing;
+  if (key === null || searchText === null)
+    return fileNew(run);
+  const found = await lookUp2(run, key, searchText);
+  if (!found.ok)
+    return resultOf(run, "failed", { problem: found.problem });
+  return found.value === null ? answerMiss(run) : answerRecurrence(run, found.value);
+}
+async function triageInherited(run, commented) {
+  const { key, searchText } = run.filing;
+  if (key === null || searchText === null || commented.has(key))
+    return resultOf(run, "inherited");
+  const found = await lookUp2(run, key, searchText);
+  if (!found.ok)
+    return resultOf(run, "failed", { problem: found.problem });
+  if (found.value === null)
+    return resultOf(run, "inherited");
+  const { ref: ref8, foundBy } = found.value;
+  const issue3 = await step(run, `the ${run.route.channel} tracker get`, () => run.route.tracker.get(ref8));
+  if (!issue3.ok)
+    return resultOf(run, "failed", { ref: ref8, foundBy, problem: issue3.problem });
+  if (!isOpenIssueState(issue3.value.state))
+    return resultOf(run, "inherited");
+  const result = await commentOn(run, ref8, foundBy, "inherited");
+  if (result.action === "inherited")
+    commented.add(key);
+  return result;
+}
+function localBug(bug, what, local) {
+  const artifact = artifactOf(bug);
+  return {
+    what: local(what),
+    artifact: artifact === null ? null : local(artifact)
+  };
 }
 function skippedRow(index, channel, problem) {
   return { index, channel, action: "skipped", ref: null, foundBy: null, stored: null, problem };
@@ -27592,14 +27994,24 @@ async function triageReport(options) {
       channel: "public",
       tracker: options.tracker,
       readStored: (key) => readTrackerRef(repoRoot, key),
-      store: (key, ref8) => writeTrackerRef(repoRoot, {
+      store: (key, ref8, supersedes) => writeTrackerRef(repoRoot, {
         dispatch: options.dispatch,
         outcome: options.outcome,
         artifact: key,
-        ref: ref8
-      }, options.seams).action
+        ref: ref8,
+        ...supersedes === undefined ? {} : { supersedes }
+      }, options.seams).action,
+      readsState: true,
+      similarity: similarityStepOf(options)
     },
-    private: { channel: "private", tracker: privateTracker, readStored: null, store: null }
+    private: {
+      channel: "private",
+      tracker: privateTracker,
+      readStored: null,
+      store: null,
+      readsState: false,
+      similarity: null
+    }
   };
   const bugs = [];
   for (const [index, bug] of options.report.outOfScopeBugs.entries()) {
@@ -27615,7 +28027,10 @@ async function triageReport(options) {
       continue;
     }
     const filing = await filingFor(what, bug, options, local, redact, verifyRefs);
-    bugs.push(await triageBug({ route, index, filing, redact }));
+    const run = { route, index, filing, redact };
+    const { inherited } = options;
+    const isInherited = route.channel === "public" && inherited !== undefined && inheritedFailureOf(localBug(bug, what, local), inherited.failures) !== null;
+    bugs.push(isInherited ? await triageInherited(run, inherited.commented) : await triageBug(run));
   }
   return { blocker, bugs };
 }
@@ -27626,8 +28041,13 @@ var LINE_PREFIX = "Triage: ";
 var INDENT8 = "   ";
 var FOUND_BY = {
   store: "its stored reference",
-  find: "a tracker find"
+  find: "a tracker find",
+  similarity: "word similarity"
 };
+function foundByText(bug) {
+  const found = FOUND_BY[bug.foundBy ?? "find"];
+  return bug.score === undefined ? found : `${found} (score ${scoreText(bug.score)})`;
+}
 function unresolvedTracker(kind, reason) {
   const refuse7 = () => Promise.reject(new Error(reason));
   return Object.freeze({
@@ -27650,7 +28070,15 @@ function hasTriage(report2) {
 function issueName2(ref8) {
   return ref8.url ?? `${ref8.kind} issue ${ref8.externalId}`;
 }
-function bugLines(bug) {
+function failureName(failure3) {
+  return `${failure3.file} > ${failure3.name}`;
+}
+function inheritedNote(bug, name2, where, failure3) {
+  const test = failure3 === undefined ? "a red test the run started with" : `the run-start failure ${failureName(failure3)}`;
+  const comment = bug.ref === null ? "" : `, and ${issueName2(bug.ref)} on ${where}, found by ${foundByText(bug)}, was commented on`;
+  return `${name2}: inherited: ${test}; nothing was filed${comment}.`;
+}
+function bugLines(bug, inherited) {
   const name2 = `out_of_scope_bugs[${bug.index}]`;
   const where = `the ${bug.channel} tracker`;
   if (bug.action === "skipped") {
@@ -27661,16 +28089,17 @@ function bugLines(bug) {
     return { notes: [], warnings: [warning] };
   }
   const issue3 = bug.ref === null ? "an issue" : issueName2(bug.ref);
-  const note = bug.action === "filed" ? `${name2}: filed on ${where} as ${issue3}.` : `${name2}: recurs in ${issue3} on ${where}, found by ${FOUND_BY[bug.foundBy ?? "find"]}; commented on it.`;
+  const reached = bug.action === "filed" ? `${name2}: filed on ${where} as ${issue3}.` : `${name2}: recurs in ${issue3} on ${where}, found by ${foundByText(bug)}; commented on it.`;
+  const note = bug.action === "inherited" ? inheritedNote(bug, name2, where, inherited) : reached;
   const problem = bug.problem === null ? [] : [`${name2}: ${bug.problem}`];
   const conflict = bug.stored === "conflict" ? [`${name2}: the store keeps another reference for its artifact, in place of ${issue3}.`] : [];
   return { notes: [note], warnings: [...problem, ...conflict] };
 }
-function describeStartTriage(result) {
+function describeStartTriage(result, inherited = new Map) {
   const { blocker } = result;
   const blockerNotes = blocker.written ? ["blockers: written onto the task line, for the next dispatch of this task."] : [];
   const blockerWarnings = blocker.problem === null ? [] : [`blockers: ${blocker.problem}`];
-  const bugs = result.bugs.map(bugLines);
+  const bugs = result.bugs.map((bug) => bugLines(bug, inherited.get(bug.index)));
   const prefixed = (lines) => lines.map((line) => `${LINE_PREFIX}${line}`);
   return {
     notes: prefixed([...blockerNotes, ...bugs.flatMap((lines) => lines.notes)]),
@@ -27694,10 +28123,42 @@ async function resolvePublicTracker(options, redact) {
     return unresolvedTracker(options.config.trackerDefault, reason);
   }
 }
+function baselinePathOrNull(trackerPath) {
+  try {
+    return baselinePathFor(trackerPath);
+  } catch {
+    return null;
+  }
+}
+function runStartFailures(trackerPath) {
+  const path3 = baselinePathOrNull(trackerPath);
+  const reading2 = path3 === null ? null : readBaseline(path3);
+  return reading2?.state === "read" && reading2.baseline.junit === "read" ? reading2.baseline.failures : [];
+}
+function inheritedByIndex(result, report2, failures, local, redact) {
+  const named3 = result.bugs.flatMap((bug) => {
+    const reported = report2.outOfScopeBugs[bug.index];
+    if (bug.action !== "inherited" || reported === undefined || !hasText2(reported.what))
+      return [];
+    const artifact = artifactOf(reported);
+    const failure3 = inheritedFailureOf({
+      what: local(reported.what),
+      artifact: artifact === null ? null : local(artifact)
+    }, failures);
+    return failure3 === null ? [] : [[bug.index, { file: redact(failure3.file), name: redact(failure3.name) }]];
+  });
+  return new Map(named3);
+}
 function createStartTriage(options) {
   const secrets = namedSecrets(options.config, options.env ?? process.env);
   const redact = (text) => redactSecrets(text, secrets);
+  const local = localPathRedactor(options.repoRoot, homedir8());
   let publicTracker = null;
+  let inherited = null;
+  const inheritedFor = (trackerPath) => {
+    inherited ??= { failures: runStartFailures(trackerPath), commented: new Set };
+    return inherited;
+  };
   const trackerFor = (report2) => {
     if (!report2.outOfScopeBugs.some(filesPublicly)) {
       return Promise.resolve(unresolvedTracker(options.config.trackerDefault, NOT_RESOLVED_REASON));
@@ -27710,6 +28171,7 @@ function createStartTriage(options) {
     if (!reading2.present || !hasTriage(reading2.report))
       return null;
     const { report: report2 } = reading2;
+    const run = inheritedFor(input.trackerPath);
     const result = await triageReport({
       repoRoot: options.repoRoot,
       trackerPath: input.trackerPath,
@@ -27724,13 +28186,18 @@ function createStartTriage(options) {
       tracker: await trackerFor(report2),
       privateTracker: options.privateTracker,
       secrets,
-      seams: options.seams
+      seams: options.seams,
+      inherited: run,
+      similarity: options.config
     });
-    const { notes, warnings } = describeStartTriage(result);
+    const named3 = inheritedByIndex(result, report2, run.failures, local, redact);
+    const { notes, warnings } = describeStartTriage(result, named3);
     for (const note of notes)
       activeOutput().info(`${INDENT8}${note}`);
     for (const warning of warnings)
       activeOutput().warn(`${INDENT8}${warning}`);
+    for (const failure3 of named3.values())
+      emitLoopEvent({ kind: "inherited", file: failure3.file, name: failure3.name });
     return result;
   };
   return async (input) => {
@@ -28447,6 +28914,28 @@ function firstLine6(text) {
 `).map((line) => line.trim()).find((line) => line !== "") ?? "";
 }
 
+// src/start/pr-retarget.ts
+function retargetedLine(number, from, to) {
+  return `\u21AA Retargeted pull request #${String(number)} from ${from} to ${to} (pr.base).`;
+}
+function refusedRetargetLine(number, from, to, detail) {
+  return `\u26A0\uFE0F  Could not retarget pull request #${String(number)} from ${from} to ${to} (pr.base): ${detail}. Retarget it by hand; the run carries on to the CI wait.`;
+}
+async function retargetPullRequest(pull, base, seams) {
+  const from = pull.baseRefName;
+  if (from === base)
+    return { kind: "unchanged" };
+  try {
+    await seams.pulls.editBase(pull.number, base);
+  } catch (error) {
+    const detail = messageOf(error);
+    seams.output.warn(refusedRetargetLine(pull.number, from, base, detail));
+    return { kind: "refused", from, to: base, detail };
+  }
+  seams.output.info(retargetedLine(pull.number, from, base));
+  return { kind: "retargeted", from, to: base };
+}
+
 // src/release/prepare.ts
 import { mkdirSync as mkdirSync13, readFileSync as readFileSync40, writeFileSync as writeFileSync15 } from "fs";
 import { dirname as dirname14, join as join38, posix as posix4 } from "path";
@@ -28688,7 +29177,6 @@ var RELEASE_STAGE_SEAMS = {
   push: pushBranch,
   pulls: ghPullRequestsIn,
   readProvider: (repoRoot) => resolvePrProvider({ configured: null, dir: repoRoot }),
-  currentBranch: getCurrentBranch,
   now: () => new Date
 };
 var PLAN_HEADING = /^# +(.+)$/;
@@ -28831,18 +29319,18 @@ function announceBody(write, count) {
   }
   out.info(`   ${noun} ${verb} now in the body of pull request #${write.number}.`);
 }
-async function writeBody(io, repoRoot, write) {
-  const reading2 = io.readProvider(repoRoot);
+async function writeBody(io, input, write) {
+  const reading2 = io.readProvider(input.repoRoot);
   if (reading2.provider !== "gh") {
     const problem = noProviderProblem(reading2);
     activeOutput().info(`   No pull request body carries ${JSON.stringify(write.lines.join(" "))}: ${problem}.`);
     return unwritten(null, problem);
   }
-  const body = await carryIntoBody(io.pulls(repoRoot), io.currentBranch(), write);
+  const body = await carryIntoBody(io.pulls(input.repoRoot), input.branch, write);
   announceBody(body, write.lines.length);
   return body;
 }
-async function reportFailure(io, repoRoot, outcome2, sentence, facts) {
+async function reportFailure(io, input, outcome2, sentence, facts) {
   const out = activeOutput();
   if (outcome2 === "skipped") {
     out.info(`
@@ -28853,7 +29341,7 @@ async function reportFailure(io, repoRoot, outcome2, sentence, facts) {
   }
   const parts = { forecast: null, levelReport: facts.levelReport };
   const block = releaseBodyBlock(parts);
-  const body = await writeBody(io, repoRoot, { sentence, block, lines: [sentence, ...releaseBodyLines(parts)] });
+  const body = await writeBody(io, input, { sentence, block, lines: [sentence, ...releaseBodyLines(parts)] });
   return { outcome: outcome2, sentence, forecast: null, body, ...facts };
 }
 var NO_RELEASE = {
@@ -28873,12 +29361,12 @@ async function reportForecast(io, input, forecast, facts) {
     out.warn(`   \u26A0\uFE0F  ${problem}`);
   const parts = { forecast, levelReport: facts.levelReport };
   const block = releaseBodyBlock(parts);
-  const body = await writeBody(io, input.repoRoot, { sentence: null, block, lines: releaseBodyLines(parts) });
+  const body = await writeBody(io, input, { sentence: null, block, lines: releaseBodyLines(parts) });
   return { outcome: "released", sentence: null, forecast, body, ...facts };
 }
 async function finishRelease(input, seams = {}) {
   const io = { ...RELEASE_STAGE_SEAMS, ...seams };
-  const { preparation, repoRoot, settings } = input;
+  const { preparation, repoRoot, branch, settings } = input;
   if (preparation === null)
     return NO_RELEASE;
   const levelReport = releaseLevelReport({
@@ -28888,31 +29376,30 @@ async function finishRelease(input, seams = {}) {
   });
   const none2 = { fragment: null, subject: null, sha: null, levelReport };
   if (preparation.kind === "skipped") {
-    return reportFailure(io, repoRoot, "skipped", preparation.sentence, none2);
+    return reportFailure(io, input, "skipped", preparation.sentence, none2);
   }
   const git = io.git(repoRoot);
   const verification = io.verify(preparation, { git, settings });
   if (verification.kind === "refused") {
-    return reportFailure(io, repoRoot, "refused", verification.sentence, none2);
+    return reportFailure(io, input, "refused", verification.sentence, none2);
   }
   const fragment = verification.path;
   const subject = releaseSubject(preparation);
   const commit = commitFragment(git, fragment, subject);
   if (!commit.committed) {
-    return reportFailure(io, repoRoot, "uncommitted", commit.sentence, { ...none2, fragment, subject });
+    return reportFailure(io, input, "uncommitted", commit.sentence, { ...none2, fragment, subject });
   }
   const out = activeOutput();
   const sha = commit.sha;
   const facts = { fragment, subject, sha, levelReport };
   out.info(`
 \uD83D\uDCE6 Committed ${commitName(sha, subject)} over ${fragment}.`);
-  const branch = io.currentBranch();
   const pushed = io.push(repoRoot, branch);
   if (!pushed.ok) {
     const said = pushed.output.trim() === "" ? "" : `: ${pushed.output.trim().split(`
 `)[0] ?? ""}`;
     const sentence = `${commitName(sha, subject)} was made but could not be pushed to ${branch}${said}`;
-    return reportFailure(io, repoRoot, "unpushed", sentence, facts);
+    return reportFailure(io, input, "unpushed", sentence, facts);
   }
   out.info(`   Pushed it to ${branch}.`);
   const forecast = io.forecast({ git, settings, prepared: preparation, verified: verification, now: io.now() });
@@ -29225,7 +29712,7 @@ async function checkWrapUpAnswer(input) {
 }
 
 // src/start/wrap-up.ts
-function buildWrapUpPrompt(branch, planContent, openPullRequest = null, release = null, lessons = []) {
+function buildWrapUpPrompt(branch, base, planContent, openPullRequest = null, release = null, lessons = []) {
   return [
     "* Read `@progress.txt` in full.",
     "* `@progress.txt` above names the file `progress.txt` at the repo root; the `@` is a reference marker, never part of a path. Do not create or write a file whose name starts with `@`.",
@@ -29238,7 +29725,7 @@ function buildWrapUpPrompt(branch, planContent, openPullRequest = null, release
     "* If the merge touched `bun.lock` or any `package.json`, run `bun install --frozen-lockfile` and require it to pass BEFORE pushing. It is the one-second local reproduction of the CI install step, and it catches a lockfile that no longer matches the merged manifests \u2014 the failure mode where every CI job dies at its first step and nothing downstream runs. When it fails, do NOT hand-edit the lockfile: restore the base's copy (`git checkout origin/main -- bun.lock`), run a plain `bun install` so this branch's own dependencies are re-added, and confirm the frozen run then passes.",
     ...releaseBullets(release),
     `* Commit these changes and push them to the CURRENT branch (${branch}). Never create a branch here: the work under review is this branch's, and a second branch splits one plan across two reviews.`,
-    pullRequestStep(branch, openPullRequest),
+    pullRequestStep(branch, base, openPullRequest),
     "* Do not include Claude attribution in the commit or PR message.",
     ...lessonsSection(lessons),
     "",
@@ -29248,15 +29735,15 @@ function buildWrapUpPrompt(branch, planContent, openPullRequest = null, release
   ].join(`
 `);
 }
-function oneLine8(text) {
+function oneLine9(text) {
   return text.trim().replace(/\s+/g, " ");
 }
 function lessonLines(lesson) {
-  const artifact = lesson.artifact === undefined || oneLine8(lesson.artifact) === "" ? "none" : oneLine8(lesson.artifact);
+  const artifact = lesson.artifact === undefined || oneLine9(lesson.artifact) === "" ? "none" : oneLine9(lesson.artifact);
   return [
     `- \`${lesson.id}\``,
-    `  - trigger: ${oneLine8(lesson.trigger)}`,
-    `  - action: ${oneLine8(lesson.action)}`,
+    `  - trigger: ${oneLine9(lesson.trigger)}`,
+    `  - action: ${oneLine9(lesson.action)}`,
     `  - artifact: ${artifact}`
   ];
 }
@@ -29281,8 +29768,8 @@ function lessonsSection(lessons) {
     "```"
   ];
 }
-function pullRequestStep(branch, openPullRequest) {
-  return openPullRequest === null ? `* No open PR was found for ${branch}: open one with \`gh pr create\`. If it answers that a PR already exists, push to that PR and update its body with \`gh pr edit\`; never open a second PR from a new branch.` : `* PR #${openPullRequest} is already open for ${branch}, likely opened by the plan's close-out: push to it and update its body with \`gh pr edit ${openPullRequest}\` so the description covers the promotions this session committed.`;
+function pullRequestStep(branch, base, openPullRequest) {
+  return openPullRequest === null ? `* No open PR was found for ${branch}: open one with \`gh pr create --base ${base}\`. If it answers that a PR already exists, push to that PR and update its body with \`gh pr edit\`; never open a second PR from a new branch.` : `* PR #${openPullRequest} is already open for ${branch}, likely opened by the plan's close-out: push to it and update its body with \`gh pr edit ${openPullRequest}\` so the description covers the promotions this session committed.`;
 }
 function releaseBullets(release) {
   if (release === null)
@@ -29344,11 +29831,11 @@ async function lessonsToPromote(learning) {
     return [];
   }
 }
-async function preserveProgress(planContent, settingSources, release, serving, learning, checkout) {
+async function preserveProgress(planContent, settingSources, release, serving, learning, base, checkout) {
   const branch = getCurrentBranch(checkout);
   const openPullRequest = await openPullRequestNumber(checkout, branch);
   return runWrapUpSession({
-    buildPrompt: (lessons) => buildWrapUpPrompt(branch, planContent, openPullRequest, release, lessons),
+    buildPrompt: (lessons) => buildWrapUpPrompt(branch, base, planContent, openPullRequest, release, lessons),
     settingSources,
     serving,
     learning,
@@ -29402,8 +29889,8 @@ function missingPullRequestBullet(branch, previousMessage) {
   return [opening, "  Its final message follows, quoted:", "", ...quoted3(previousMessage), ""];
 }
 function buildWrapUpRetryPrompt(retry) {
-  const base = buildWrapUpPrompt(retry.branch, retry.planContent, null, retry.release, retry.lessons);
-  const [classifierKey, ...rest] = base.split(`
+  const first = buildWrapUpPrompt(retry.branch, retry.base, retry.planContent, null, retry.release, retry.lessons);
+  const [classifierKey, ...rest] = first.split(`
 `);
   return [
     classifierKey,
@@ -29413,9 +29900,9 @@ function buildWrapUpRetryPrompt(retry) {
 `);
 }
 function retryWrapUp(run) {
-  const { branch, planContent, previousMessage } = run;
+  const { branch, base, planContent, previousMessage } = run;
   return runWrapUpSession({
-    buildPrompt: (lessons) => buildWrapUpRetryPrompt({ branch, planContent, release: null, lessons, previousMessage }),
+    buildPrompt: (lessons) => buildWrapUpRetryPrompt({ branch, base, planContent, release: null, lessons, previousMessage }),
     settingSources: run.settingSources,
     serving: run.serving,
     learning: run.learning,
@@ -29457,8 +29944,9 @@ async function runWrapUp(input) {
     planStub: planStub2,
     planContent
   });
+  const base = resolveBaseBranch(createGitRunner(checkout), settings.prBase);
   emitLoopEvent({ kind: "wrap-up", phase: "session" });
-  const finalMessage = await preserveProgress(planContent, settingSources, release, serving, wrapUpLearning, checkout);
+  const finalMessage = await preserveProgress(planContent, settingSources, release, serving, wrapUpLearning, base, checkout);
   if (activeOutputMode() !== "text") {
     const pullRequest = await openPullRequestNumber(checkout, expected2.branch);
     emitLoopEvent(pullRequest === null ? { kind: "no-pr", reason: `no open pull request for ${expected2.branch}` } : { kind: "pr", number: pullRequest });
@@ -29472,13 +29960,14 @@ async function runWrapUp(input) {
     dir: checkout
   });
   emitLoopEvent({ kind: "wrap-up", phase: "release" });
-  const finish = await finishRelease({ repoRoot: checkout, settings, preparation: release }, { readProvider });
+  const finish = await finishRelease({ repoRoot: checkout, branch: expected2.branch, settings, preparation: release }, { readProvider });
   if (readProvider().provider !== "none") {
-    const delivery = await deliverPullRequest({ branch: expected2.branch, retries: settings.loopWrapUpRetries, previousMessage: finalMessage }, deliverySeamsIn({ ...input, fragment: finish.fragment }));
+    const delivery = await deliverPullRequest({ branch: expected2.branch, retries: settings.loopWrapUpRetries, previousMessage: finalMessage }, deliverySeamsIn({ ...input, base, fragment: finish.fragment }));
     if (delivery.kind === "interrupted")
       return;
     if (delivery.kind === "blocked")
       throw new CommandExit(1, delivery.message);
+    await retargetPullRequest(delivery.pull, base, { pulls: ghPullRequestsIn(checkout), output: activeOutput() });
   }
   if (ciWait) {
     emitLoopEvent({ kind: "wrap-up", phase: "ci" });
@@ -29576,6 +30065,7 @@ function deliverySeamsIn(context) {
     retry: (previousMessage) => retryWrapUp({
       previousMessage,
       branch: expected2.branch,
+      base: context.base,
       planContent: context.planContent,
       settingSources: context.settingSources,
       serving: context.serving,
@@ -29585,7 +30075,7 @@ function deliverySeamsIn(context) {
     openRunnerPullRequest: async () => {
       const runnerInput = runnerPrInputFor({
         branch: expected2.branch,
-        base: resolveBaseBranch(createGitRunner(checkout), context.settings.prBase),
+        base: context.base,
         planContent: context.planContent,
         planStub: context.planStub,
         notes: fragmentNotesIn(checkout, context.fragment)
@@ -29638,7 +30128,7 @@ async function start(args, repoRoot) {
     return;
   let runConfig;
   try {
-    runConfig = loadRunConfig({ root: repoRoot, home: homedir8() }, args);
+    runConfig = loadRunConfig({ root: repoRoot, home: homedir9() }, args);
   } catch (error) {
     if (!(error instanceof ConfigError))
       throw error;
@@ -29669,7 +30159,7 @@ async function start(args, repoRoot) {
   let expected2 = openCheckoutExpectation({ projectRoot: repoRoot, checkout, branch });
   await announceRiskTotal({
     repoRoot,
-    home: homedir8(),
+    home: homedir9(),
     planPath,
     config: runConfig.config,
     environment: process.env
@@ -29694,16 +30184,16 @@ async function start(args, repoRoot) {
         tiersRafa: runConfig.config.tiersRafa,
         tiersSkills: runConfig.config.tiersSkills,
         tiersAgents: runConfig.config.tiersAgents,
-        home: homedir8()
+        home: homedir9()
       },
-      sync: { resolved: runConfig, home: homedir8() },
+      sync: { resolved: runConfig, home: homedir9() },
       claim: createStartPreflightClaim(repoRoot, runConfig.config),
       drift: createStartPreflightDrift(repoRoot, runConfig.config)
     });
-    const serving = { root: repoRoot, run: session.id, home: homedir8(), settings: runConfig.config };
+    const serving = { root: repoRoot, run: session.id, home: homedir9(), settings: runConfig.config };
     const learning = {
       kind: runConfig.config.learningAdapter,
-      home: homedir8(),
+      home: homedir9(),
       blessMinConfidence: runConfig.config.learningBlessMinConfidence
     };
     const handout = {
@@ -29719,7 +30209,7 @@ async function start(args, repoRoot) {
     };
     const hubContact = createHubContact({
       root: repoRoot,
-      home: homedir8(),
+      home: homedir9(),
       resolved: runConfig,
       warn: (message) => activeOutput().warn(message),
       sessionId: session.id
@@ -29798,9 +30288,10 @@ async function start(args, repoRoot) {
         inject: injectMode,
         repoRoot,
         checkout,
-        home: homedir8(),
+        home: homedir9(),
         settingSources,
         knownMissing,
+        inherited: runStartFailures(trackerPath),
         serving,
         handout,
         base
@@ -29895,7 +30386,7 @@ function buildBar(pct, width = 20) {
 
 // src/plan.ts
 import fs4 from "fs";
-import { homedir as homedir9 } from "os";
+import { homedir as homedir10 } from "os";
 import path8 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
@@ -30705,7 +31196,7 @@ function resolvePlanConfig(repoRoot, home) {
   }
 }
 async function plan(args, repoRoot, registry = CORE_ADAPTER_REGISTRY) {
-  const home = homedir9();
+  const home = homedir10();
   const config = resolvePlanConfig(repoRoot, home);
   const {
     settingSources,