@open-tomato/rafa 0.45.0 → 0.46.0

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

@@ -1,11 +1,12 @@
 // @bun
 import {
   activeOutput,
-  isStampableStub,
+  isStampableStub
+} from "./index-2a7nb3an.js";
+import {
   messageOf,
-  parseTaskDeclaration,
-  readRafaBlocks
-} from "./index-mgh2s9bj.js";
+  parseTaskDeclaration
+} from "./index-ykggr043.js";
 // src/preflight/prerequisites-md.ts
 import { basename, dirname, join } from "path";
 var SECTION_AUTO_RE = /\[auto\]/i;
@@ -390,14 +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 TRAILING_COMMENT = /\s<!-- (blocked|repairs): ((?:(?!<!--|-->).)*) -->$/;
-var OPEN_TASK_PREFIX = /^- \[(?: |BLOCKED)\] /;
 var ESCAPE_SEQUENCE = /\\(u[0-9A-Fa-f]{4}|[\s\S])/g;
 var TAB = 9;
 var FIRST_PRINTABLE = 32;
@@ -472,154 +800,7 @@ function splitBlockerComment(taskText) {
   const { text, blocked } = splitTrailingComments(taskText);
   return { text, blocker: commentText(blocked) };
 }
-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 = splitTrailingComments(body.slice(prefix.length));
-  return found.blocked === null ? line : `${prefix}${found.text}${keptRepairs(found.repairs)}${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 found = splitTrailingComments(capture.trim());
-  const blocker = commentText(found.blocked);
-  const repairs = commentText(found.repairs);
-  return {
-    task: found.text,
-    lineNum,
-    status,
-    ...blocker === null ? {} : { blocker },
-    ...repairs === null ? {} : { repairs }
-  };
-}
-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 listOpenTasks(trackerContent) {
-  return listTrackerTasks(trackerContent).filter(isOpenTask);
-}
-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 found = splitTrailingComments(body.slice(prefix.length));
-  const text = found.text.trimEnd();
-  if (text.trim().length === 0)
-    return false;
-  const comment = blocker.trim().length === 0 ? "" : `${BLOCKER_GAP}${blockerComment(blocker)}`;
-  lines[lineNum] = `- [BLOCKED] ${text}${keptRepairs(found.repairs)}${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 repaired = entry.repairs ?? "";
-  const repairs = repaired.trim().length === 0 ? "" : `${BLOCKER_GAP}${repairsComment(repaired)}`;
-  const line = `- [BLOCKED] ${entry.task.trim()}${BLOCKER_GAP}{${entry.declaration.trim()}}` + `${repairs}${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`);
-}
-
-// src/core/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"];
@@ -638,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)
@@ -652,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) {
@@ -784,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`;
@@ -831,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);
@@ -863,7 +1044,7 @@ function parsePlan(markdown) {
     issues
   };
 }
-// src/core/plan/plan-files.ts
+// 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) {
@@ -895,6 +1076,10 @@ function issueLine(file, issue) {
 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: ";
@@ -1036,4 +1221,4 @@ function renderInjection(request) {
   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, plansDirAt, countTasks, planFileName, stubOfPlanFile, isFile, rejectedPath, issueLine, plural, 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 };

package/dist/{index-nv34ptht.js → index-77ajfffn.js}

@@ -1,12 +1,4 @@
 // @bun
-import {
-  CONFIDENCE_MAX,
-  CONFIDENCE_MIN,
-  GAP,
-  SOURCE_STEP,
-  triggerKey
-} from "./index-hf2k497d.js";
-
 // src/learning/bless.ts
 import { createHash } from "crypto";
 var HUNDREDTHS = 100;
@@ -39,6 +31,19 @@ function bless(held, options) {
 function promotable(held, options) {
   return blessedRecords(held, options.minConfidence).filter((each) => each.usage_count >= options.after);
 }
+// src/learning/identity.ts
+import { createHash as createHash2 } from "crypto";
+var GAP = 0.1;
+var SOURCE_STEP = 0.05;
+var CONFIDENCE_MIN = 0.3;
+var CONFIDENCE_MAX = 0.9;
+var WHITESPACE_RUN = /\s+/g;
+function actionHash(action) {
+  return createHash2("sha256").update(action.trim().toLowerCase()).digest("hex");
+}
+function triggerKey(trigger) {
+  return trigger.trim().toLowerCase().replace(WHITESPACE_RUN, " ");
+}
 // src/learning/merge.ts
 var HUNDREDTHS2 = 100;
 var GAP_H = Math.round(GAP * HUNDREDTHS2);
@@ -215,4 +220,4 @@ function merge(held, payload, now) {
     discarded: keys.flatMap((key) => outcomes.get(key).discarded)
   };
 }
-export { bless, promotable, merge };
+export { bless, promotable, GAP, SOURCE_STEP, CONFIDENCE_MIN, CONFIDENCE_MAX, actionHash, triggerKey, merge };