@open-tomato/rafa 0.44.0 → 0.46.0

package/dist/{index-57mmzkcn.js → index-39kbcw68.js}

@@ -1,20 +1,22 @@
 // @bun
 import {
   activeOutput,
-  isStampableStub,
+  isStampableStub
+} from "./index-2a7nb3an.js";
+import {
   messageOf,
-  parseTaskDeclaration,
-  readRafaBlocks
-} from "./index-cknayrpc.js";
+  parseTaskDeclaration
+} from "./index-ykggr043.js";
 // src/preflight/prerequisites-md.ts
 import { basename, dirname, join } from "path";
 var SECTION_AUTO_RE = /\[auto\]/i;
 var SECTION_START_RE = /\[start\]/i;
 var SECTION_HUMAN_RE = /\[human\]|manual|human|sign.?off|team/i;
+var TASKS_MARKER_RE = /\[tasks\]/i;
+var WRAP_UP_MARKER_RE = /\[wrap-up\]/i;
 var ITEM_RE = /^-\s+\[\s*\]\s+/;
-var INLINE_AUTO_RE = /^-\s+\[\s*\]\s+\[auto\]\s+/i;
-var INLINE_HUMAN_RE = /^-\s+\[\s*\]\s+\[human\]\s+/i;
-var INLINE_START_RE = /^-\s+\[\s*\]\s+\[start\]\s+/i;
+var SCOPE_MARKERS = String.raw`((?:\[(?:tasks|wrap-up)\]\s+)*)`;
+var ITEM_OPENING_RE = new RegExp(String.raw`^-\s+\[\s*\]\s+${SCOPE_MARKERS}(?:\[(auto|human|start)\]\s+)?${SCOPE_MARKERS}`, "i");
 var PROBE_RE = /:\s+`([^`]+)`\s*$/;
 var HEADING_MARKS_RE = /^#+/;
 var FENCE_RE = /^ {0,3}(`{3,}|~{3,})/;
@@ -29,18 +31,29 @@ function inferSectionTag(header) {
     return "human";
   return null;
 }
+function markedScope(text) {
+  const isForTasks = TASKS_MARKER_RE.test(text);
+  const isForWrapUp = WRAP_UP_MARKER_RE.test(text);
+  if (isForTasks && isForWrapUp)
+    return "both";
+  if (isForTasks)
+    return "tasks";
+  if (isForWrapUp)
+    return "wrap-up";
+  return null;
+}
 function enterHeading(scope, header) {
   const level = HEADING_MARKS_RE.exec(header)?.[0].length ?? 1;
   const above = Array.from({ length: level - 1 }, (_, index) => scope[index] ?? null);
-  return [...above, inferSectionTag(header)];
+  return [...above, { tag: inferSectionTag(header), scope: markedScope(header) }];
 }
-function sectionDefault(scope) {
+function sectionMark(scope, mark) {
   for (let index = scope.length - 1;index >= 0; index -= 1) {
-    const tag = scope[index];
-    if (tag)
-      return tag;
+    const named = scope[index]?.[mark];
+    if (named)
+      return named;
   }
-  return "human";
+  return null;
 }
 function fenceOf(line) {
   return FENCE_RE.exec(line)?.[1] ?? null;
@@ -61,17 +74,18 @@ function continuationOf(lines, start) {
   }
   return following;
 }
-function inlineTag(line) {
-  if (INLINE_AUTO_RE.test(line))
-    return "auto";
-  if (INLINE_START_RE.test(line))
-    return "start";
-  if (INLINE_HUMAN_RE.test(line))
-    return "human";
-  return null;
+function tagNamed(word) {
+  const tag = word?.toLowerCase();
+  return tag === "auto" || tag === "human" || tag === "start" ? tag : null;
 }
-function stripItemPrefix(line) {
-  return line.replace(INLINE_AUTO_RE, "").replace(INLINE_HUMAN_RE, "").replace(INLINE_START_RE, "").replace(ITEM_RE, "").trim();
+function readOpening(line) {
+  const opening = ITEM_OPENING_RE.exec(line);
+  const [matched = "", before = "", tag, after = ""] = opening ?? [];
+  return {
+    tag: tagNamed(tag),
+    scope: markedScope(`${before}${after}`),
+    rest: line.slice(matched.length).trim()
+  };
 }
 function isProbedTag(tag) {
   return tag === "auto" || tag === "start";
@@ -80,12 +94,14 @@ function extractProbe(description) {
   const probe = PROBE_RE.exec(description)?.[1]?.trim();
   return probe || null;
 }
-function readItem(lines, lineIndex, inherited) {
+function readItem(lines, lineIndex, headings) {
   const raw = lines[lineIndex] ?? "";
-  const tag = inlineTag(raw) ?? inherited;
-  const description = [stripItemPrefix(raw), ...continuationOf(lines, lineIndex + 1)].join(" ");
+  const opening = readOpening(raw);
+  const tag = opening.tag ?? sectionMark(headings, "tag") ?? "human";
+  const scope = opening.scope ?? sectionMark(headings, "scope") ?? "both";
+  const description = [opening.rest, ...continuationOf(lines, lineIndex + 1)].join(" ");
   const probe = isProbedTag(tag) ? extractProbe(description) : null;
-  return Object.freeze({ raw, description, tag, lineIndex, probe });
+  return Object.freeze({ raw, description, tag, scope, lineIndex, probe });
 }
 function parsePrerequisites(content) {
   const lines = content.split(`
@@ -110,7 +126,7 @@ function parsePrerequisites(content) {
       continue;
     }
     if (ITEM_RE.test(line))
-      items.push(readItem(lines, index, sectionDefault(scope)));
+      items.push(readItem(lines, index, scope));
   }
   return Object.freeze(items);
 }
@@ -118,7 +134,7 @@ function isProbed(item) {
   return isProbedTag(item.tag) && item.probe !== null;
 }
 function requiredItem(item) {
-  return Object.freeze({ kind: "tool", name: item.description, probe: item.probe });
+  return Object.freeze({ kind: "tool", name: item.description, probe: item.probe, scope: item.scope });
 }
 function requiredItemsTagged(items, tag) {
   const probed = items.filter(isProbed).filter((item) => item.tag === tag);
@@ -375,13 +391,341 @@ async function runPreflight(items, options) {
     knownMissing: Object.freeze(knownMissing)
   });
 }
-// src/utils/tracker.ts
-import fs from "fs";
+// packages/rafa/src/core/plan/blocks.ts
+var RAFA_BLOCK_KINDS = [
+  "plan",
+  "context",
+  "stage-context",
+  "report"
+];
+var RAFA_PREFIX = "rafa:";
+var FENCE_RUN = /^( {0,3})(`{3,}|~{3,})/;
+var CLOSING_FENCE = /^ {0,3}(`{3,}|~{3,})[ \t]*$/;
+function isRafaBlockKind(kind) {
+  return RAFA_BLOCK_KINDS.includes(kind);
+}
+function linesOf(markdown) {
+  const lines = markdown.split(`
+`);
+  if (lines[lines.length - 1] === "")
+    lines.pop();
+  return lines.map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
+}
+function kindOf(info) {
+  const word = info.trim().split(/\s+/)[0] ?? "";
+  return word.startsWith(RAFA_PREFIX) ? word.slice(RAFA_PREFIX.length) : null;
+}
+function openingFence(line) {
+  const match = FENCE_RUN.exec(line);
+  const opener = match?.[0];
+  const indent = match?.[1];
+  const run = match?.[2];
+  if (opener === undefined || indent === undefined || run === undefined) {
+    return null;
+  }
+  const marker = run.charAt(0);
+  const info = line.slice(opener.length);
+  if (marker === "`" && info.includes("`"))
+    return null;
+  return { marker, length: run.length, indent: indent.length, kind: kindOf(info) };
+}
+function closes(line, fence) {
+  const run = CLOSING_FENCE.exec(line)?.[1];
+  return run !== undefined && run.charAt(0) === fence.marker && run.length >= fence.length;
+}
+function closingIndex(lines, from, fence) {
+  for (let index = from;index < lines.length; index += 1) {
+    if (closes(lines[index] ?? "", fence))
+      return index;
+  }
+  return lines.length;
+}
+function dedent(line, indent) {
+  let cut = 0;
+  while (cut < indent && line.charAt(cut) === " ")
+    cut += 1;
+  return line.slice(cut);
+}
+function readRafaBlocks(markdown) {
+  const lines = linesOf(markdown);
+  const blocks = [];
+  let index = 0;
+  while (index < lines.length) {
+    const fence = openingFence(lines[index] ?? "");
+    if (fence === null) {
+      index += 1;
+      continue;
+    }
+    const closing = closingIndex(lines, index + 1, fence);
+    const closed = closing < lines.length;
+    if (fence.kind !== null) {
+      const body = lines.slice(index + 1, closing).map((line) => dedent(line, fence.indent)).join(`
+`);
+      const last = closed ? closing + 1 : lines.length;
+      blocks.push({ kind: fence.kind, body, span: { first: index + 1, last }, closed });
+    }
+    index = closing + 1;
+  }
+  return blocks;
+}
+// packages/rafa/src/report/parse.ts
+var REPORT_STATUSES = ["done", "blocked"];
+var FINDING_KINDS = ["gotcha", "pattern", "location", "skill-suggestion"];
+var FINDING_SIGNALS = ["loud", "silent"];
+var FINDING_DOMAINS = [
+  "code-style",
+  "testing",
+  "git",
+  "debugging",
+  "workflow",
+  "security",
+  "general-best-practices"
+];
+var CHANGE_LEVELS = ["patch", "minor", "major", "none"];
+var BUG_KINDS = ["bug", "own-fallout", "own-gap", "convention", "docs", "machine"];
+var DEFAULT_BUG_KIND = "bug";
+var REPORT_KIND = "report";
+var REQUIRED = true;
+var OPTIONAL = false;
+var REPORT_KEYS = [
+  "status",
+  "feedback",
+  "findings",
+  "skills_used",
+  "blockers",
+  "out_of_scope_bugs",
+  "changes",
+  "stale_docs"
+];
+var FINDING_KEYS = [
+  "trigger",
+  "kind",
+  "what",
+  "cause",
+  "resolution",
+  "artifact",
+  "signal",
+  "domain"
+];
+var BLOCKER_KEYS = ["what", "artifact"];
+var BUG_KEYS = ["what", "artifact", "security", "kind", "module", "action", "reproduce", "cause"];
+var CHANGE_KEYS = ["level", "area", "summary"];
+var STALE_DOC_KEYS = ["where", "what"];
+function isMapping(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isOneOf(choices, value) {
+  return choices.includes(value);
+}
+function describeValue(value) {
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  if (value === null)
+    return "nothing";
+  if (Array.isArray(value))
+    return "a list";
+  if (typeof value === "object")
+    return "a mapping";
+  return `the ${typeof value} ${String(value)}`;
+}
+function messageOf2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function reportIssue(reason, field, text) {
+  return { reason, field, text };
+}
+function absent(reason, block, text) {
+  return { present: false, reason, block, text };
+}
+function scopeOf(mapping, keys, prefix, issues) {
+  const fields = new Map;
+  const extras = [];
+  for (const [key, value] of Object.entries(mapping)) {
+    if (keys.includes(key))
+      fields.set(key, value);
+    else
+      extras.push({ key, value });
+  }
+  return { fields, extras, prefix, issues };
+}
+function valueOf(scope, key, required) {
+  const value = scope.fields.get(key) ?? null;
+  if (value === null && required) {
+    const field = `${scope.prefix}${key}`;
+    scope.issues.push(reportIssue("missing-field", field, `${field} is missing`));
+  }
+  return value;
+}
+function unusable(scope, key, why) {
+  const field = `${scope.prefix}${key}`;
+  scope.issues.push(reportIssue("unusable-field", field, `${field} ${why}`));
+  return null;
+}
+function stringProblem(value) {
+  if (typeof value !== "string")
+    return `is ${describeValue(value)}, not a string; quote it`;
+  if (value.trim().length === 0)
+    return "is blank";
+  return null;
+}
+function stringField(scope, key, required) {
+  const value = valueOf(scope, key, required);
+  if (value === null)
+    return null;
+  const problem = stringProblem(value);
+  return problem === null ? value : unusable(scope, key, problem);
+}
+function choiceField(scope, key, choices, required) {
+  const value = valueOf(scope, key, required);
+  if (value === null || isOneOf(choices, value))
+    return value;
+  return unusable(scope, key, `is ${describeValue(value)}, not one of ${choices.join(", ")}`);
+}
+function booleanField(scope, key, required) {
+  const value = valueOf(scope, key, required);
+  if (value === null || typeof value === "boolean")
+    return value;
+  return unusable(scope, key, `is ${describeValue(value)}, not true or false; write it unquoted`);
+}
+function listField(scope, key, readEntry) {
+  const value = valueOf(scope, key, OPTIONAL);
+  if (value === null)
+    return [];
+  if (!Array.isArray(value)) {
+    unusable(scope, key, `is ${describeValue(value)}, not a list`);
+    return [];
+  }
+  const entries = [];
+  const items = value;
+  for (const [index, item] of items.entries()) {
+    const entry = readEntry(item, `${scope.prefix}${key}[${index}]`, scope.issues);
+    if (entry !== null)
+      entries.push(entry);
+  }
+  return entries;
+}
+function entryScope(item, field, keys, issues) {
+  if (isMapping(item))
+    return scopeOf(item, keys, `${field}.`, issues);
+  const text = `${field} is ${describeValue(item)}, not a mapping of ${keys.join(", ")}; dropped`;
+  issues.push(reportIssue("unusable-field", field, text));
+  return null;
+}
+function readSkill(item, field, issues) {
+  const problem = stringProblem(item);
+  if (problem === null)
+    return item;
+  issues.push(reportIssue("unusable-field", field, `${field} ${problem}; dropped`));
+  return null;
+}
+function readFinding(item, field, issues) {
+  const scope = entryScope(item, field, FINDING_KEYS, issues);
+  if (scope === null)
+    return null;
+  return {
+    trigger: stringField(scope, "trigger", REQUIRED),
+    kind: choiceField(scope, "kind", FINDING_KINDS, REQUIRED),
+    what: stringField(scope, "what", REQUIRED),
+    cause: stringField(scope, "cause", OPTIONAL),
+    resolution: stringField(scope, "resolution", OPTIONAL),
+    artifact: stringField(scope, "artifact", OPTIONAL),
+    signal: choiceField(scope, "signal", FINDING_SIGNALS, REQUIRED),
+    domain: choiceField(scope, "domain", FINDING_DOMAINS, OPTIONAL),
+    extras: scope.extras
+  };
+}
+function readBlocker(item, field, issues) {
+  const scope = entryScope(item, field, BLOCKER_KEYS, issues);
+  if (scope === null)
+    return null;
+  return {
+    what: stringField(scope, "what", REQUIRED),
+    artifact: stringField(scope, "artifact", OPTIONAL),
+    extras: scope.extras
+  };
+}
+function readBug(item, field, issues) {
+  const scope = entryScope(item, field, BUG_KEYS, issues);
+  if (scope === null)
+    return null;
+  return {
+    what: stringField(scope, "what", REQUIRED),
+    artifact: stringField(scope, "artifact", OPTIONAL),
+    security: booleanField(scope, "security", REQUIRED),
+    kind: choiceField(scope, "kind", BUG_KINDS, OPTIONAL) ?? DEFAULT_BUG_KIND,
+    module: stringField(scope, "module", OPTIONAL),
+    action: stringField(scope, "action", OPTIONAL),
+    reproduce: stringField(scope, "reproduce", OPTIONAL),
+    cause: stringField(scope, "cause", OPTIONAL),
+    extras: scope.extras
+  };
+}
+function readChange(item, field, issues) {
+  const scope = entryScope(item, field, CHANGE_KEYS, issues);
+  if (scope === null)
+    return null;
+  return {
+    level: choiceField(scope, "level", CHANGE_LEVELS, REQUIRED),
+    area: stringField(scope, "area", OPTIONAL),
+    summary: stringField(scope, "summary", REQUIRED),
+    extras: scope.extras
+  };
+}
+function readStaleDoc(item, field, issues) {
+  const scope = entryScope(item, field, STALE_DOC_KEYS, issues);
+  if (scope === null)
+    return null;
+  const where = stringField(scope, "where", OPTIONAL);
+  const what = stringField(scope, "what", REQUIRED);
+  if (what === null)
+    return null;
+  return { where, what, extras: scope.extras };
+}
+function readReport(document, issues) {
+  const scope = scopeOf(document, REPORT_KEYS, "", issues);
+  return {
+    status: choiceField(scope, "status", REPORT_STATUSES, REQUIRED),
+    feedback: stringField(scope, "feedback", OPTIONAL),
+    findings: listField(scope, "findings", readFinding),
+    skillsUsed: listField(scope, "skills_used", readSkill),
+    blockers: listField(scope, "blockers", readBlocker),
+    outOfScopeBugs: listField(scope, "out_of_scope_bugs", readBug),
+    changes: listField(scope, "changes", readChange),
+    staleDocs: listField(scope, "stale_docs", readStaleDoc),
+    extras: scope.extras
+  };
+}
+function parseReport(output) {
+  const reports = readRafaBlocks(output).filter((block2) => block2.kind === REPORT_KIND);
+  const block = reports.at(-1);
+  if (block === undefined) {
+    return absent("no-block", null, "the session output holds no rafa:report block");
+  }
+  const line = block.span.first;
+  if (!block.closed) {
+    return absent("unclosed-block", block, `rafa:report block at line ${line} is never closed, so its body may have been cut short ` + "and is not read");
+  }
+  let document;
+  try {
+    document = Bun.YAML.parse(block.body);
+  } catch (error) {
+    const text = `rafa:report block at line ${line} is not valid YAML (${messageOf2(error)})`;
+    return absent("malformed-block", block, text);
+  }
+  if (!isMapping(document)) {
+    const text = `rafa:report block at line ${line} holds ${describeValue(document)}, ` + "not a mapping of report fields";
+    return absent("malformed-block", block, text);
+  }
+  const issues = [];
+  const report = readReport(document, issues);
+  return { present: true, report, block, issues };
+}
+// packages/rafa/src/core/plan/blocker-comment.ts
 var BLOCKER_OPEN = "<!-- blocked: ";
+var REPAIRS_OPEN = "<!-- repairs: ";
 var BLOCKER_CLOSE = " -->";
 var BLOCKER_GAP = "  ";
-var BLOCKER_COMMENT = /\s<!-- blocked: ((?:(?!<!--|-->).)*) -->$/;
-var OPEN_TASK_PREFIX = /^- \[(?: |BLOCKED)\] /;
+var TRAILING_COMMENT = /\s<!-- (blocked|repairs): ((?:(?!<!--|-->).)*) -->$/;
 var ESCAPE_SEQUENCE = /\\(u[0-9A-Fa-f]{4}|[\s\S])/g;
 var TAB = 9;
 var FIRST_PRINTABLE = 32;
@@ -418,163 +762,45 @@ function unescapeBlockerText(escaped) {
 function blockerComment(blocker) {
   return `${BLOCKER_OPEN}${escapeBlockerText(blocker)}${BLOCKER_CLOSE}`;
 }
-function findBlockerComment(text) {
+function repairsComment(repaired) {
+  return `${REPAIRS_OPEN}${escapeBlockerText(repaired)}${BLOCKER_CLOSE}`;
+}
+function findTrailingComment(text) {
   const trimmed = text.trimEnd();
-  const match = BLOCKER_COMMENT.exec(trimmed);
-  const escaped = match?.[1];
-  if (match === null || escaped === undefined)
+  const match = TRAILING_COMMENT.exec(trimmed);
+  const kind = match?.[1];
+  const escaped = match?.[2];
+  if (match === null || escaped === undefined || kind !== "blocked" && kind !== "repairs")
     return null;
   const before = trimmed.slice(0, match.index).trimEnd();
-  return before.length === 0 ? null : { before, escaped };
-}
-function splitBlockerComment(taskText) {
-  const found = findBlockerComment(taskText);
-  if (found === null)
-    return { text: taskText, blocker: null };
-  const blocker = unescapeBlockerText(found.escaped);
+  return before.length === 0 ? null : { kind, before, escaped };
+}
+function splitTrailingComments(taskText) {
+  const last = findTrailingComment(taskText);
+  if (last === null)
+    return { text: taskText, blocked: null, repairs: null };
+  const earlier = findTrailingComment(last.before);
+  const found = earlier === null || earlier.kind === last.kind ? [last] : [last, earlier];
   return {
-    text: found.before,
-    blocker: blocker.trim().length === 0 ? null : blocker
+    text: found.at(-1)?.before ?? last.before,
+    blocked: found.find((comment) => comment.kind === "blocked")?.escaped ?? null,
+    repairs: found.find((comment) => comment.kind === "repairs")?.escaped ?? null
   };
 }
-function splitCarriageReturn(line) {
-  return line.endsWith("\r") ? { body: line.slice(0, -1), cr: "\r" } : { body: line, cr: "" };
-}
-function withoutBlockerComment(line) {
-  const { body, cr } = splitCarriageReturn(line);
-  const prefix = OPEN_TASK_PREFIX.exec(body)?.[0];
-  if (prefix === undefined)
-    return line;
-  const found = findBlockerComment(body.slice(prefix.length));
-  return found === null ? line : `${prefix}${found.before}${cr}`;
-}
-function closedBlockLines(trackerContent) {
-  const inside = new Set;
-  for (const block of readRafaBlocks(trackerContent)) {
-    if (!block.closed)
-      continue;
-    for (let line = block.span.first;line <= block.span.last; line += 1) {
-      inside.add(line - 1);
-    }
-  }
-  return inside;
-}
-function taskInfoOf(capture, lineNum, status) {
-  const { text, blocker } = splitBlockerComment(capture.trim());
-  return blocker === null ? { task: text, lineNum, status } : { task: text, lineNum, status, blocker };
-}
-var TASK_LINE_STATUSES = [
-  [/^- \[BLOCKED\] (.+)/, "blocked"],
-  [/^- \[ \] (.+)/, "unchecked"],
-  [/^- \[x\] (.+)/, "done"]
-];
-var NO_LINES = new Set;
-function findNextTask(trackerContent, options = {}) {
-  const skip = options.skipLines ?? NO_LINES;
-  const open = listOpenTasks(trackerContent).filter((task) => !skip.has(task.lineNum));
-  return open.find((task) => task.status === "blocked") ?? open.find((task) => task.status === "unchecked") ?? null;
-}
-function listTrackerTasks(trackerContent) {
-  const lines = trackerContent.split(`
-`);
-  const inBlock = closedBlockLines(trackerContent);
-  const tasks = [];
-  for (let i = 0;i < lines.length; i++) {
-    if (inBlock.has(i))
-      continue;
-    for (const [pattern, status] of TASK_LINE_STATUSES) {
-      const capture = lines[i].match(pattern)?.[1];
-      if (!capture)
-        continue;
-      tasks.push(taskInfoOf(capture, i, status));
-      break;
-    }
-  }
-  return tasks;
-}
-function isOpenTask(task) {
-  return task.status !== "done";
+function commentText(escaped) {
+  if (escaped === null)
+    return null;
+  const text = unescapeBlockerText(escaped);
+  return text.trim().length === 0 ? null : text;
 }
-function listOpenTasks(trackerContent) {
-  return listTrackerTasks(trackerContent).filter(isOpenTask);
+function keptRepairs(escaped) {
+  return escaped === null ? "" : `${BLOCKER_GAP}${REPAIRS_OPEN}${escaped}${BLOCKER_CLOSE}`;
 }
-function updateTrackerLine(trackerPath, lineNum, newStatus) {
-  const lines = fs.readFileSync(trackerPath, "utf8").split(`
-`);
-  const line = lines[lineNum];
-  if (!line)
-    return;
-  if (newStatus === "done") {
-    lines[lineNum] = withoutBlockerComment(line).replace(/^- \[ \]/, "- [x]").replace(/^- \[BLOCKED\]/, "- [x]");
-  } else {
-    lines[lineNum] = line.replace(/^- \[ \]/, "- [BLOCKED]");
-  }
-  fs.writeFileSync(trackerPath, lines.join(`
-`), "utf8");
-}
-function writeTrackerBlocker(trackerPath, lineNum, blocker) {
-  const lines = fs.readFileSync(trackerPath, "utf8").split(`
-`);
-  const line = lines[lineNum];
-  if (line === undefined)
-    return false;
-  const { body, cr } = splitCarriageReturn(line);
-  const prefix = OPEN_TASK_PREFIX.exec(body)?.[0];
-  if (prefix === undefined)
-    return false;
-  const rest = body.slice(prefix.length);
-  const text = (findBlockerComment(rest)?.before ?? rest).trimEnd();
-  if (text.trim().length === 0)
-    return false;
-  const comment = blocker.trim().length === 0 ? "" : `${BLOCKER_GAP}${blockerComment(blocker)}`;
-  lines[lineNum] = `- [BLOCKED] ${text}${comment}${cr}`;
-  fs.writeFileSync(trackerPath, lines.join(`
-`), "utf8");
-  return true;
-}
-var ANY_TASK_PREFIX = /^- \[(?: |x|BLOCKED)\] /;
-var LINE_TERMINATOR = /[\n\r\u2028\u2029]/;
-function assertInsertable(entry) {
-  if (entry.task.trim().length === 0 || LINE_TERMINATOR.test(entry.task)) {
-    throw new Error("insertTrackerTask: the task text must be one line and not blank");
-  }
-  if (entry.declaration.trim().length === 0 || /[{}]/.test(entry.declaration) || LINE_TERMINATOR.test(entry.declaration)) {
-    throw new Error("insertTrackerTask: the declaration must be one line of entries holding no brace");
-  }
-}
-function endOfChecklist(lines, inBlock) {
-  for (let i = lines.length - 1;i >= 0; i -= 1) {
-    if (!inBlock.has(i) && ANY_TASK_PREFIX.test(lines[i]))
-      return i + 1;
-  }
-  const last = lines.length - 1;
-  return lines[last] === "" ? last : lines.length;
-}
-function insertTrackerTask(trackerPath, entry, beforeLine) {
-  assertInsertable(entry);
-  const content = fs.readFileSync(trackerPath, "utf8");
-  const lines = content.split(`
-`);
-  const inBlock = closedBlockLines(content);
-  if (beforeLine !== null) {
-    const target = lines[beforeLine];
-    if (target === undefined || inBlock.has(beforeLine) || !ANY_TASK_PREFIX.test(target)) {
-      throw new Error(`insertTrackerTask: line ${beforeLine} is no task line`);
-    }
-  }
-  const at = beforeLine ?? endOfChecklist(lines, inBlock);
-  const { cr } = splitCarriageReturn(lines[0] ?? "");
-  const line = `- [BLOCKED] ${entry.task.trim()}${BLOCKER_GAP}{${entry.declaration.trim()}}` + `${BLOCKER_GAP}${blockerComment(entry.blocker)}${cr}`;
-  const written = [...lines.slice(0, at), line, ...lines.slice(at)];
-  fs.writeFileSync(trackerPath, written.join(`
-`), "utf8");
-  return at;
-}
-function trackerPathFor(planPath) {
-  return planPath.replace(/PLAN(-[^/]*)?\.md$/, (_m, stub) => `PLAN_TRACKER${stub ?? ""}.md`);
+function splitBlockerComment(taskText) {
+  const { text, blocked } = splitTrailingComments(taskText);
+  return { text, blocker: commentText(blocked) };
 }
-
-// src/plan/parse.ts
+// packages/rafa/src/core/plan/parse.ts
 var PLAN_BLOCK_KINDS = ["plan", "context", "stage-context"];
 var PLAN_HEADER_FIELDS = ["stub", "issue", "spec", "release"];
 var PLAN_RELEASE_LEVELS = ["patch", "minor", "major", "none"];
@@ -593,10 +819,10 @@ function isHeaderField(key) {
 function isReleaseLevel(value) {
   return PLAN_RELEASE_LEVELS.includes(value);
 }
-function isMapping(value) {
+function isMapping2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function describeValue(value) {
+function describeValue2(value) {
   if (typeof value === "string")
     return JSON.stringify(value);
   if (value === null)
@@ -607,7 +833,7 @@ function describeValue(value) {
     return "a mapping";
   return String(value);
 }
-function messageOf2(error) {
+function messageOf3(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function planIssue(reason, line, text) {
@@ -739,10 +965,10 @@ function unusableText(field, value) {
     return `${subject} is empty; a value opening with # after a space is a YAML comment unless quoted`;
   }
   if (field === "release") {
-    return `${subject} is ${describeValue(value)}, not one of ${PLAN_RELEASE_LEVELS.join(", ")}`;
+    return `${subject} is ${describeValue2(value)}, not one of ${PLAN_RELEASE_LEVELS.join(", ")}`;
   }
   if (typeof value !== "string") {
-    return field === "issue" ? `${subject} is ${describeValue(value)}, not a string or a whole number; quote it` : `${subject} is ${describeValue(value)}, not a string; quote it`;
+    return field === "issue" ? `${subject} is ${describeValue2(value)}, not a string or a whole number; quote it` : `${subject} is ${describeValue2(value)}, not a string; quote it`;
   }
   if (value.trim().length === 0)
     return `${subject} is blank`;
@@ -786,13 +1012,13 @@ function readHeader(block) {
   try {
     document = Bun.YAML.parse(block.body);
   } catch (error) {
-    const text = `rafa:plan block is not valid YAML (${messageOf2(error)})`;
+    const text = `rafa:plan block is not valid YAML (${messageOf3(error)})`;
     return { header: emptyHeader(), issues: [planIssue("malformed-header", line, text)] };
   }
   if (document === null)
     return { header: emptyHeader(), issues: [] };
-  if (!isMapping(document)) {
-    const text = `rafa:plan block holds ${describeValue(document)}, not a mapping of fields`;
+  if (!isMapping2(document)) {
+    const text = `rafa:plan block holds ${describeValue2(document)}, not a mapping of fields`;
     return { header: emptyHeader(), issues: [planIssue("malformed-header", line, text)] };
   }
   return readFields(document, line);
@@ -818,7 +1044,42 @@ function parsePlan(markdown) {
     issues
   };
 }
-
+// packages/rafa/src/core/plan/plan-files.ts
+import { statSync } from "fs";
+import { basename as basename2, dirname as dirname2, join as join2, resolve } from "path";
+function plansDirAt(root, planDir) {
+  return { label: planDir, path: resolve(root, planDir) };
+}
+function countTasks(tasks) {
+  const done = tasks.filter((task) => task.status === "done").length;
+  const blocked = tasks.filter((task) => task.status === "blocked").length;
+  return { total: tasks.length, done, blocked, open: tasks.length - done - blocked };
+}
+function planFileName(stub, tracker) {
+  return tracker ? `PLAN_TRACKER-${stub}.md` : `PLAN-${stub}.md`;
+}
+function stubOfPlanFile(name) {
+  const stub = /^PLAN-(.+)\.md$/.exec(name)?.[1];
+  return stub !== undefined && isStampableStub(stub) ? stub : null;
+}
+function isFile(path) {
+  return statSync(path, { throwIfNoEntry: false })?.isFile() ?? false;
+}
+var REJECTED_DIR = "rejected";
+function rejectedPath(path) {
+  const parent = dirname2(path);
+  return parent === "." ? join2(REJECTED_DIR, basename2(path)) : join2(parent, REJECTED_DIR, basename2(path));
+}
+function issueLine(file, issue) {
+  return `${file}:${issue.line}: ${issue.reason}: ${issue.text}`;
+}
+function plural(count, noun) {
+  return count === 1 ? `${count} ${noun}` : `${count} ${noun}s`;
+}
+// packages/rafa/src/core/plan/tracker-path.ts
+function trackerPathFor(planPath) {
+  return planPath.replace(/PLAN(-[^/]*)?\.md$/, (_m, stub) => `PLAN_TRACKER${stub ?? ""}.md`);
+}
 // src/plan/inject.ts
 var PLAN_CONTEXT_HEADING = "## Plan context";
 var STAGE_HEADING_PREFIX = "## Stage: ";
@@ -830,19 +1091,49 @@ var CHECKBOXES = {
   blocked: "- [BLOCKED]",
   done: "- [x]"
 };
-function fallbackFor(reason, lineNum) {
-  const line = lineNum + 1;
-  const found = reason === "no-task-at-line" ? "no task the plan model reads" : "a different task than the one dispatched";
-  const text = `line ${line} of the plan holds ${found}, so the whole plan is handed over; ` + "the plan may have changed since its tracker was copied, or the line sits inside a rafa:* block";
-  return { found: false, fallback: { reason, line, text } };
-}
-function locate(model, wanted) {
-  const task = model.tasks.find((candidate) => candidate.lineNum === wanted.lineNum);
-  if (task === undefined)
-    return fallbackFor("no-task-at-line", wanted.lineNum);
-  if (task.task !== wanted.task)
-    return fallbackFor("task-text-differs", wanted.lineNum);
-  return { found: true, task };
+var HANDED_OVER = ", so the whole plan is handed over";
+function placeOf(position) {
+  return position !== undefined && Number.isInteger(position) && position >= 0 ? position : null;
+}
+var DISPATCHED_TEXT = "the dispatched text";
+var REPAIRED_TEXT = "the text the dispatched repair names";
+function noTaskWithText(place) {
+  const beyond = place === null ? "" : ` and no task number ${place + 1}`;
+  const text = `the plan holds no task with ${DISPATCHED_TEXT}${beyond}${HANDED_OVER}; ` + "the plan may have changed since its tracker was copied, or the task line sits inside a rafa:* block";
+  return { found: false, fallback: { reason: "no-task-with-text", text } };
+}
+function severalTasksWithText(count, place, sought) {
+  const which = place === null ? "the dispatch gives no position among its tasks" : `task number ${place + 1} is none of them`;
+  const text = `the plan holds ${count} tasks with ${sought} and ${which}${HANDED_OVER}`;
+  return { found: false, fallback: { reason: "several-tasks-with-text", text } };
+}
+function noRepairedTask() {
+  const text = `the plan holds no task with ${REPAIRED_TEXT}${HANDED_OVER}; ` + "the plan may have changed since the repair was written";
+  return { found: false, fallback: { reason: "no-task-with-text", text } };
+}
+function locate(model, wanted, position) {
+  const place = placeOf(position);
+  const atPlace = place === null ? undefined : model.tasks[place];
+  const holders = model.tasks.filter((candidate) => candidate.task === wanted.task);
+  const [first] = holders;
+  if (first === undefined) {
+    return atPlace === undefined ? noTaskWithText(place) : { found: true, task: atPlace };
+  }
+  if (holders.length === 1)
+    return { found: true, task: first };
+  return atPlace !== undefined && holders.includes(atPlace) ? { found: true, task: atPlace } : severalTasksWithText(holders.length, place, DISPATCHED_TEXT);
+}
+function locateRepaired(model, named, position) {
+  const sentence = named.trim();
+  const holders = model.tasks.filter((candidate) => candidate.text.trim() === sentence);
+  const [first] = holders;
+  if (first === undefined)
+    return noRepairedTask();
+  if (holders.length === 1)
+    return { found: true, task: first };
+  const place = placeOf(position);
+  const atPlace = place === null ? undefined : model.tasks[place];
+  return atPlace !== undefined && holders.includes(atPlace) ? { found: true, task: atPlace } : severalTasksWithText(holders.length, place, REPAIRED_TEXT);
 }
 function contextBody(body) {
   if (body === null || body.trim().length === 0)
@@ -862,15 +1153,22 @@ function renderDocument(sections) {
 `;
 }
 function shownStatus(task, dispatched) {
-  if (task.lineNum < dispatched.lineNum)
+  if (task.lineNum < dispatched.task.lineNum)
     return "done";
-  if (task.lineNum === dispatched.lineNum)
-    return "unchecked";
-  return task.status;
+  if (task.lineNum > dispatched.task.lineNum)
+    return task.status;
+  return dispatched.repair === null ? "unchecked" : "done";
 }
 function taskLine(status, task) {
   return `${CHECKBOXES[status]} ${task.text}`;
 }
+function openLine(dispatched) {
+  return taskLine("unchecked", { text: dispatched.repair ?? dispatched.task.text });
+}
+function checklistLines(task, dispatched) {
+  const line = taskLine(shownStatus(task, dispatched), task);
+  return task === dispatched.task && dispatched.repair !== null ? [line, openLine(dispatched)] : [line];
+}
 function planContextSection(model) {
   const body = contextBody(model.context);
   return body === null ? null : section(PLAN_CONTEXT_HEADING, body);
@@ -894,17 +1192,17 @@ function stageListSection(model, dispatched) {
 `));
 }
 function renderStage(model, dispatched) {
-  const checklist = model.tasks.filter((task) => task.stage === dispatched.stage).map((task) => taskLine(shownStatus(task, dispatched), task));
+  const checklist = model.tasks.filter((task) => task.stage === dispatched.task.stage).flatMap((task) => checklistLines(task, dispatched));
   return renderDocument([
     planContextSection(model),
-    stageSection(model, dispatched, checklist),
-    stageListSection(model, dispatched)
+    stageSection(model, dispatched.task, checklist),
+    stageListSection(model, dispatched.task)
   ]);
 }
 function renderTask(model, dispatched) {
   return renderDocument([
     planContextSection(model),
-    stageSection(model, dispatched, [taskLine("unchecked", dispatched)])
+    stageSection(model, dispatched.task, [openLine(dispatched)])
   ]);
 }
 var RENDERERS = {
@@ -912,14 +1210,15 @@ var RENDERERS = {
   task: renderTask
 };
 function renderInjection(request) {
-  const { mode, plan, task } = request;
-  if (mode === "full")
-    return { requested: mode, mode, text: plan, fallback: null };
+  const { mode, plan, task, position, repairs } = request;
+  if (mode === "full" || repairs === null)
+    return { requested: mode, mode: "full", text: plan, fallback: null };
   const model = parsePlan(plan);
-  const location = locate(model, task);
+  const location = repairs === undefined ? locate(model, task, position) : locateRepaired(model, repairs, position);
   if (!location.found) {
     return { requested: mode, mode: "full", text: plan, fallback: location.fallback };
   }
-  return { requested: mode, mode, text: RENDERERS[mode](model, location.task), fallback: null };
+  const repair = repairs === undefined ? null : parseTaskDeclaration(task.task).text.trim();
+  return { requested: mode, mode, text: RENDERERS[mode](model, { task: location.task, repair }), fallback: null };
 }
-export { escapeBlockerText, splitBlockerComment, findNextTask, listTrackerTasks, listOpenTasks, updateTrackerLine, writeTrackerBlocker, insertTrackerTask, trackerPathFor, PLAN_BLOCK_KINDS, PLAN_HEADER_FIELDS, PLAN_RELEASE_LEVELS, parsePlan, parsePrerequisites, planPrerequisites, malformedPrerequisiteLines, mergePlanPrerequisites, prerequisitesPathForPlan, loadPlanPrerequisites, PROBE_TIMEOUT_MS, runShellProbe, runPreflight, renderInjection };
+export { RAFA_BLOCK_KINDS, isRafaBlockKind, readRafaBlocks, REPORT_STATUSES, FINDING_KINDS, FINDING_SIGNALS, FINDING_DOMAINS, CHANGE_LEVELS, BUG_KINDS, parseReport, BLOCKER_GAP, escapeBlockerText, unescapeBlockerText, blockerComment, repairsComment, splitTrailingComments, commentText, keptRepairs, splitBlockerComment, PLAN_BLOCK_KINDS, PLAN_HEADER_FIELDS, PLAN_RELEASE_LEVELS, parsePlan, plansDirAt, countTasks, planFileName, stubOfPlanFile, isFile, rejectedPath, issueLine, plural, trackerPathFor, parsePrerequisites, planPrerequisites, malformedPrerequisiteLines, mergePlanPrerequisites, prerequisitesPathForPlan, loadPlanPrerequisites, PROBE_TIMEOUT_MS, runShellProbe, runPreflight, renderInjection };