@open-tomato/rafa 0.18.0 → 0.20.0

package/dist/index-d6d0942q.js

@@ -0,0 +1,218 @@
+// @bun
+import {
+  CONFIDENCE_MAX,
+  CONFIDENCE_MIN,
+  GAP,
+  SOURCE_STEP,
+  triggerKey
+} from "./index-wp8c28fd.js";
+
+// src/learning/bless.ts
+import { createHash } from "crypto";
+var HUNDREDTHS = 100;
+function hundredths(confidence) {
+  return Math.round(confidence * HUNDREDTHS);
+}
+function compareText(left, right) {
+  if (left < right) {
+    return -1;
+  }
+  if (left > right) {
+    return 1;
+  }
+  return 0;
+}
+function byTrust(left, right) {
+  return hundredths(right.confidence) - hundredths(left.confidence) || right.usage_count - left.usage_count || compareText(left.id, right.id);
+}
+function blessedRecords(held, minConfidence) {
+  const floor = hundredths(minConfidence);
+  return held.filter((each) => each.status === "active" && each.promoted_to === undefined && hundredths(each.confidence) >= floor).sort(byTrust);
+}
+function versionOf(instincts) {
+  return createHash("sha256").update(JSON.stringify(instincts)).digest("hex");
+}
+function bless(held, options) {
+  const instincts = blessedRecords(held, options.minConfidence);
+  return { version: versionOf(instincts), instincts };
+}
+function promotable(held, options) {
+  return blessedRecords(held, options.minConfidence).filter((each) => each.usage_count >= options.after);
+}
+// src/learning/merge.ts
+var HUNDREDTHS2 = 100;
+var GAP_H = Math.round(GAP * HUNDREDTHS2);
+var STEP_H = Math.round(SOURCE_STEP * HUNDREDTHS2);
+var MIN_H = Math.round(CONFIDENCE_MIN * HUNDREDTHS2);
+var MAX_H = Math.round(CONFIDENCE_MAX * HUNDREDTHS2);
+function hundredths2(confidence) {
+  return Math.round(confidence * HUNDREDTHS2);
+}
+function compareText2(left, right) {
+  if (left < right) {
+    return -1;
+  }
+  if (left > right) {
+    return 1;
+  }
+  return 0;
+}
+function byAge(left, right) {
+  return compareText2(left.created_at, right.created_at) || compareText2(left.id, right.id);
+}
+function byConfidence(left, right) {
+  return hundredths2(right.confidence) - hundredths2(left.confidence) || compareText2(left.id, right.id);
+}
+function sourcesOf(record) {
+  return record.sources !== undefined && record.sources.length > 0 ? [...new Set(record.sources)] : [record.id];
+}
+function withSource(record, sourceId) {
+  const sources = [...new Set([...record.sources ?? [], sourceId])].sort();
+  return { ...record, sources, usage_count: sources.length };
+}
+function firstOptional(ordered, key) {
+  const found = ordered.find((record) => record[key] !== undefined);
+  return found === undefined ? {} : { [key]: found[key] };
+}
+function collapse(group) {
+  const ordered = [...[...group.held].sort(byAge), ...[...group.incoming].sort(byAge)];
+  if (ordered.length === 1) {
+    return ordered[0];
+  }
+  const seen = new Set;
+  let weighted = 0;
+  for (const member of ordered) {
+    const own = sourcesOf(member);
+    const fresh = own.filter((source) => !seen.has(source));
+    const base = hundredths2(member.confidence) - STEP_H * (own.length - 1);
+    weighted += base * fresh.length;
+    for (const source of fresh) {
+      seen.add(source);
+    }
+  }
+  const sources = [...seen].sort();
+  const stepped = Math.round(weighted / sources.length + STEP_H * (sources.length - 1));
+  const confidence = Math.min(MAX_H, Math.max(MIN_H, stepped)) / HUNDREDTHS2;
+  const byAgeAll = [...ordered].sort(byAge);
+  const lead = byAgeAll[0];
+  const rest = {};
+  for (const [key, value] of Object.entries(lead)) {
+    if (key !== "artifact" && key !== "promoted_to") {
+      Object.assign(rest, { [key]: value });
+    }
+  }
+  return {
+    ...rest,
+    ...firstOptional(byAgeAll, "artifact"),
+    ...firstOptional(byAgeAll, "promoted_to"),
+    confidence,
+    usage_count: sources.length,
+    sources
+  };
+}
+function sameButStamp(left, right) {
+  const keys = new Set([...Object.keys(left), ...Object.keys(right)]);
+  keys.delete("updated_at");
+  return [...keys].every((key) => {
+    const field = key;
+    return JSON.stringify(left[field]) === JSON.stringify(right[field]);
+  });
+}
+function stamp(record, held, now) {
+  const before = held.find((candidate) => candidate.id === record.id);
+  if (before !== undefined && sameButStamp(before, record)) {
+    return before;
+  }
+  return { ...record, updated_at: now };
+}
+function withStatus(record, status) {
+  return record.status === status ? record : { ...record, status };
+}
+function groupByAction(held, incoming) {
+  const groups = new Map;
+  const groupOf = (hash) => {
+    const found = groups.get(hash);
+    if (found !== undefined) {
+      return found;
+    }
+    const made = { held: [], incoming: [] };
+    groups.set(hash, made);
+    return made;
+  };
+  for (const record of held) {
+    groupOf(record.action_hash).held.push(record);
+  }
+  for (const record of incoming) {
+    groupOf(record.action_hash).incoming.push(record);
+  }
+  return groups;
+}
+function settleOne(hash, group, held, now) {
+  if (group.held.length === 0 && group.incoming.length === 1) {
+    return {
+      produced: [group.incoming[0]],
+      discarded: [],
+      rules: new Map([[hash, "new-trigger"]])
+    };
+  }
+  const record = stamp(withStatus(collapse(group), "active"), held, now);
+  return { produced: [record], discarded: [], rules: new Map([[hash, "same-action"]]) };
+}
+function settleMany(collapsed, held, now) {
+  const leaderH = Math.max(...[...collapsed.values()].map((record) => hundredths2(record.confidence)));
+  const kept = new Map;
+  const discarded = [];
+  for (const [hash, record] of collapsed) {
+    if (leaderH - hundredths2(record.confidence) > GAP_H) {
+      discarded.push(record);
+    } else {
+      kept.set(hash, record);
+    }
+  }
+  const status = kept.size > 1 ? "flagged" : "active";
+  const rule = kept.size > 1 ? "flagged" : "higher-confidence";
+  const rules = new Map;
+  for (const hash of collapsed.keys()) {
+    rules.set(hash, kept.has(hash) ? rule : "higher-confidence");
+  }
+  const produced = [...kept.values()].map((record) => stamp(withStatus(record, status), held, now));
+  return {
+    produced: produced.sort(byConfidence),
+    discarded: discarded.sort(byConfidence),
+    rules
+  };
+}
+function settleTrigger(held, incoming, now) {
+  const groups = groupByAction(held, incoming);
+  if (groups.size === 1) {
+    const [hash, group] = [...groups.entries()][0];
+    return settleOne(hash, group, held, now);
+  }
+  const collapsed = new Map;
+  for (const [hash, group] of groups) {
+    collapsed.set(hash, collapse(group));
+  }
+  return settleMany(collapsed, held, now);
+}
+function merge(held, payload, now) {
+  const incoming = payload.instincts.map((record) => withSource(record, payload.source_id));
+  const keys = [...new Set(incoming.map((record) => triggerKey(record.trigger)))];
+  const outcomes = new Map;
+  for (const key of keys) {
+    const onKey = (record) => triggerKey(record.trigger) === key;
+    outcomes.set(key, settleTrigger(held.filter(onKey), incoming.filter(onKey), now));
+  }
+  const decisions = payload.instincts.map((record) => {
+    const outcome = outcomes.get(triggerKey(record.trigger));
+    return {
+      incoming: record,
+      rule: outcome.rules.get(record.action_hash),
+      produced: [...outcome.produced]
+    };
+  });
+  return {
+    decisions,
+    discarded: keys.flatMap((key) => outcomes.get(key).discarded)
+  };
+}
+export { bless, promotable, merge };

package/dist/{index-944pncd8.js → index-pmkgvtfe.js}

@@ -1,5 +1,8 @@
 // @bun
-var __require = import.meta.require;
+import {
+  CONFIDENCE_MAX,
+  CONFIDENCE_MIN
+} from "./index-wp8c28fd.js";
 
 // src/pr/types.ts
 var MERGE_METHODS = Object.freeze([
@@ -315,6 +318,8 @@ var CLAUDE_SETTING_SOURCES = ["user", "project", "local"];
 var PR_PROVIDERS = ["gh", "none"];
 var RELEASE_AUTO = "auto";
 var TIER_SWITCHES = ["on", "off"];
+var SKILL_RESOLVERS = ["planner", "tag", "none"];
+var LESSON_SWITCHES = ["on", "off"];
 function accepted(value) {
   return { value, problems: [], extras: [] };
 }
@@ -349,6 +354,11 @@ var usdAmount = (raw, at) => {
 };
 var issueNumber = (raw, at) => typeof raw === "number" && Number.isSafeInteger(raw) && raw > 0 ? accepted(raw) : refused(at, raw, "an issue number, a whole number above zero");
 var dayCount = (raw, at) => typeof raw === "number" && Number.isSafeInteger(raw) && raw > 0 ? accepted(raw) : refused(at, raw, "a number of days, a whole number above zero");
+var confidence = (raw, at) => typeof raw === "number" && Number.isFinite(raw) && toHundredths(raw) >= toHundredths(CONFIDENCE_MIN) && toHundredths(raw) <= toHundredths(CONFIDENCE_MAX) ? accepted(raw) : refused(at, raw, `a confidence from ${String(CONFIDENCE_MIN)} to ${String(CONFIDENCE_MAX)}`);
+function toHundredths(value) {
+  return Math.round(value * 100);
+}
+var recurrenceCount = (raw, at) => typeof raw === "number" && Number.isSafeInteger(raw) && raw >= 1 ? accepted(raw) : refused(at, raw, "a count, a whole number of 1 or more");
 var releaseEnabled = (raw, at) => typeof raw === "boolean" || raw === RELEASE_AUTO ? accepted(raw) : refused(at, raw, `true, false or ${RELEASE_AUTO}`);
 var tierSwitch = oneOf(TIER_SWITCHES);
 var tierPin = (raw, at) => {
@@ -358,6 +368,8 @@ var tierPin = (raw, at) => {
   return tier === undefined ? refused(at, raw, `false or one of: ${SKILL_TIERS.join(", ")}`) : accepted(tier);
 };
 var routeTarget = (raw, at) => raw === false || typeof raw === "string" && raw.trim() !== "" ? accepted(raw) : refused(at, raw, "false or an agent name");
+var skillResolverName = oneOf(SKILL_RESOLVERS);
+var lessonSwitch = oneOf(LESSON_SWITCHES);
 var GITHUB_LOGIN = /^[A-Za-z0-9][A-Za-z0-9-]*(?:\[bot\])?$/;
 function isGitHubLogin(value) {
   return typeof value === "string" && GITHUB_LOGIN.test(value);
@@ -462,4 +474,4 @@ var moduleSource = (raw, at) => {
   }));
 };
 
-export { __require, MERGE_METHODS, isMergeMethod, SKILL_TIERS, BUNDLED_SKILLS_DIR, isSkillTier, realEntry, bundledBinDirectory, skillTierDirectory, resolveSkillTiers, resolveInstinctScopes, tierExists, isAgentName, BUDGET_FLAG, parseBudgetUsd, parseTaskDeclaration, stripTaskDeclaration, resolveDeclarationFlags, isMapping, describeValue, messageOf, CONFIG_VERSIONS, STORE_BACKENDS, INJECT_MODES, OUTPUT_MODES, CLAUDE_SETTING_SOURCES, PR_PROVIDERS, RELEASE_AUTO, oneOf, text, flag, mergeMethod, usdAmount, issueNumber, dayCount, releaseEnabled, tierSwitch, tierPin, routeTarget, isGitHubLogin, githubLogin, listOf, subsetOf, PREREQUISITE_KINDS, REQUIRED_ITEM_KEYS, OPTIONAL_ITEM_KEYS, requiredPrerequisite, optionalPrerequisite, MODULE_SOURCE_KINDS, MODULE_SOURCE_KEYS, moduleSource };
+export { MERGE_METHODS, isMergeMethod, SKILL_TIERS, RAFA_INSTINCTS_PATH, BUNDLED_SKILLS_DIR, isSkillTier, realEntry, bundledBinDirectory, skillTierDirectory, resolveSkillTiers, resolveInstinctScopes, tierExists, isAgentName, BUDGET_FLAG, parseBudgetUsd, parseTaskDeclaration, stripTaskDeclaration, resolveDeclarationFlags, isMapping, describeValue, messageOf, CONFIG_VERSIONS, STORE_BACKENDS, INJECT_MODES, OUTPUT_MODES, CLAUDE_SETTING_SOURCES, PR_PROVIDERS, RELEASE_AUTO, SKILL_RESOLVERS, oneOf, text, flag, mergeMethod, usdAmount, issueNumber, dayCount, confidence, recurrenceCount, releaseEnabled, tierSwitch, tierPin, routeTarget, skillResolverName, lessonSwitch, isGitHubLogin, githubLogin, listOf, subsetOf, PREREQUISITE_KINDS, REQUIRED_ITEM_KEYS, OPTIONAL_ITEM_KEYS, requiredPrerequisite, optionalPrerequisite, MODULE_SOURCE_KINDS, MODULE_SOURCE_KEYS, moduleSource };

package/dist/{index-jva32qe6.js → index-twbp38kz.js}

@@ -11,6 +11,7 @@ import {
   REQUIRED_ITEM_KEYS,
   SKILL_TIERS,
   STORE_BACKENDS,
+  confidence,
   dayCount,
   describeValue,
   flag,
@@ -18,25 +19,61 @@ import {
   isMapping,
   isSkillTier,
   issueNumber,
+  lessonSwitch,
   listOf,
   mergeMethod,
   messageOf,
   moduleSource,
   oneOf,
   optionalPrerequisite,
+  recurrenceCount,
   releaseEnabled,
   requiredPrerequisite,
   routeTarget,
+  skillResolverName,
   subsetOf,
   text,
   tierPin,
   tierSwitch,
   usdAmount
-} from "./index-944pncd8.js";
+} from "./index-pmkgvtfe.js";
 
 // src/config-schema.ts
 import { join } from "path";
 
+// src/config-readers.ts
+function mapOf(value, expected) {
+  return (raw, at) => {
+    if (!isMapping(raw)) {
+      const problem = `${at.label} is ${describeValue(raw)}, expected a mapping of names to ${expected}`;
+      return { value: undefined, problems: [problem], extras: [] };
+    }
+    const readings = Object.entries(raw).map(([name, entry]) => [
+      name,
+      name.trim() === "" ? {
+        value: undefined,
+        problems: [`${at.label} names ${JSON.stringify(name)}, expected a non-empty name`],
+        extras: []
+      } : value(entry, { label: `${at.label}.${name}`, key: `${at.key}.${name}` })
+    ]);
+    const problems = readings.flatMap(([, reading]) => reading.problems);
+    const extras = readings.flatMap(([, reading]) => reading.extras);
+    if (problems.length > 0)
+      return { value: undefined, problems, extras };
+    const read = new Map;
+    for (const [name, reading] of readings) {
+      if (reading.value !== undefined)
+        read.set(name, reading.value);
+    }
+    return { value: read, problems, extras };
+  };
+}
+var directory = text("a directory path");
+var trackerKind = text("a tracker kind name");
+var releaseFile = text("a file path");
+var tierPins = mapOf(tierPin, "false or a tier");
+var routeTable = mapOf(routeTarget, "false or an agent name");
+
 // src/tiers/resolve.ts
 import { readFileSync } from "fs";
 var VENDORED_HEADER = /^<!-- vendored by rafa from .* on \d{4}-\d{2}-\d{2} -->$/;
@@ -203,32 +240,6 @@ var DEFAULT_ROUTING = new Map(DEFAULT_ROUTES);
 
 // src/config-schema.ts
 var CONFIG_FILE = join(".rafa", "config.yaml");
-function mapOf(value, expected) {
-  return (raw, at) => {
-    if (!isMapping(raw)) {
-      const problem = `${at.label} is ${describeValue(raw)}, expected a mapping of names to ${expected}`;
-      return { value: undefined, problems: [problem], extras: [] };
-    }
-    const readings = Object.entries(raw).map(([name, entry]) => [
-      name,
-      name.trim() === "" ? {
-        value: undefined,
-        problems: [`${at.label} names ${JSON.stringify(name)}, expected a non-empty name`],
-        extras: []
-      } : value(entry, { label: `${at.label}.${name}`, key: `${at.key}.${name}` })
-    ]);
-    const problems = readings.flatMap(([, reading]) => reading.problems);
-    const extras = readings.flatMap(([, reading]) => reading.extras);
-    if (problems.length > 0)
-      return { value: undefined, problems, extras };
-    const read = new Map;
-    for (const [name, reading] of readings) {
-      if (reading.value !== undefined)
-        read.set(name, reading.value);
-    }
-    return { value: read, problems, extras };
-  };
-}
 var CONFIG_DEFAULTS = Object.freeze({
   version: 1,
   store: "sqlite",
@@ -238,6 +249,9 @@ var CONFIG_DEFAULTS = Object.freeze({
   trackerDefault: "github",
   trackerFallback: Object.freeze(["local"]),
   learningAdapter: "local",
+  learningBlessMinConfidence: 0.5,
+  learningPromoteAfter: 3,
+  learningPromoteMinConfidence: 0.7,
   outputMode: "text",
   prerequisitesRequired: Object.freeze([]),
   prerequisitesOptional: Object.freeze([]),
@@ -265,12 +279,10 @@ var CONFIG_DEFAULTS = Object.freeze({
   tiersRafa: "on",
   tiersSkills: new Map,
   tiersAgents: new Map,
-  routing: DEFAULT_ROUTING
+  routing: DEFAULT_ROUTING,
+  taskSkills: "planner",
+  taskLessons: "on"
 });
-var directory = text("a directory path");
-var trackerKind = text("a tracker kind name");
-var releaseFile = text("a file path");
-var tierPins = mapOf(tierPin, "false or a tier");
 var SETTINGS = {
   version: { key: "version", read: oneOf(CONFIG_VERSIONS), cli: false },
   store: { key: "store", read: oneOf(STORE_BACKENDS), cli: true },
@@ -288,6 +300,9 @@ var SETTINGS = {
     read: text("a learning adapter name"),
     cli: true
   },
+  learningBlessMinConfidence: { key: "learning.bless.minConfidence", read: confidence, cli: false },
+  learningPromoteAfter: { key: "learning.promote.after", read: recurrenceCount, cli: false },
+  learningPromoteMinConfidence: { key: "learning.promote.minConfidence", read: confidence, cli: false },
   outputMode: { key: "output.mode", read: oneOf(OUTPUT_MODES), cli: true },
   prerequisitesRequired: {
     key: "prerequisites.required",
@@ -362,11 +377,9 @@ var SETTINGS = {
   tiersRafa: { key: "tiers.rafa", read: tierSwitch, cli: false },
   tiersSkills: { key: "tiers.skills", read: tierPins, cli: false },
   tiersAgents: { key: "tiers.agents", read: tierPins, cli: false },
-  routing: {
-    key: "routing",
-    read: mapOf(routeTarget, "false or an agent name"),
-    cli: false
-  }
+  routing: { key: "routing", read: routeTable, cli: false },
+  taskSkills: { key: "task.skills", read: skillResolverName, cli: true },
+  taskLessons: { key: "task.lessons", read: lessonSwitch, cli: false }
 };
 var SETTING_NAMES = Object.keys(SETTINGS);
 var SETTING_BY_KEY = new Map(SETTING_NAMES.map((setting) => [
@@ -442,6 +455,9 @@ function readLayer(rawOf, atOf) {
     trackerDefault: read("trackerDefault"),
     trackerFallback: read("trackerFallback"),
     learningAdapter: read("learningAdapter"),
+    learningBlessMinConfidence: read("learningBlessMinConfidence"),
+    learningPromoteAfter: read("learningPromoteAfter"),
+    learningPromoteMinConfidence: read("learningPromoteMinConfidence"),
     outputMode: read("outputMode"),
     prerequisitesRequired: read("prerequisitesRequired"),
     prerequisitesOptional: read("prerequisitesOptional"),
@@ -469,7 +485,9 @@ function readLayer(rawOf, atOf) {
     tiersRafa: read("tiersRafa"),
     tiersSkills: read("tiersSkills"),
     tiersAgents: read("tiersAgents"),
-    routing: read("routing")
+    routing: read("routing"),
+    taskSkills: read("taskSkills"),
+    taskLessons: read("taskLessons")
   };
   return { layer, problems, extras };
 }
@@ -685,6 +703,239 @@ function readRafaBlocks(markdown) {
   return blocks;
 }
 
+// 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 REPORT_KIND = "report";
+var REQUIRED = true;
+var OPTIONAL = false;
+var REPORT_KEYS = [
+  "status",
+  "feedback",
+  "findings",
+  "skills_used",
+  "blockers",
+  "out_of_scope_bugs",
+  "changes"
+];
+var FINDING_KEYS = [
+  "trigger",
+  "kind",
+  "what",
+  "cause",
+  "resolution",
+  "artifact",
+  "signal",
+  "domain"
+];
+var BLOCKER_KEYS = ["what", "artifact"];
+var BUG_KEYS = ["what", "artifact", "security"];
+var CHANGE_KEYS = ["level", "area", "summary"];
+function isMapping2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isOneOf(choices, value) {
+  return choices.includes(value);
+}
+function describeValue2(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, text2) {
+  return { reason, field, text: text2 };
+}
+function absent(reason, block, text2) {
+  return { present: false, reason, block, text: text2 };
+}
+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 ${describeValue2(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 ${describeValue2(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 ${describeValue2(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 ${describeValue2(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 (isMapping2(item))
+    return scopeOf(item, keys, `${field}.`, issues);
+  const text2 = `${field} is ${describeValue2(item)}, not a mapping of ${keys.join(", ")}; dropped`;
+  issues.push(reportIssue("unusable-field", field, text2));
+  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),
+    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 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),
+    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 text2 = `rafa:report block at line ${line} is not valid YAML (${messageOf2(error)})`;
+    return absent("malformed-block", block, text2);
+  }
+  if (!isMapping2(document)) {
+    const text2 = `rafa:report block at line ${line} holds ${describeValue2(document)}, ` + "not a mapping of report fields";
+    return absent("malformed-block", block, text2);
+  }
+  const issues = [];
+  const report = readReport(document, issues);
+  return { present: true, report, block, issues };
+}
+
 // src/adapters/output/text.ts
 var DEBUG_VERBOSITY = 2;
 function formatPayload(payload) {
@@ -773,4 +1024,4 @@ function activeOutputMode() {
   return activeMode;
 }
 
-export { pinKey, pinLine, collisionMessage, readItemBytes, resolveTiers, findTierItem, DEFAULT_ROUTES, DEFAULT_ROUTING, CONFIG_FILE, CONFIG_DEFAULTS, SETTINGS, ConfigError, configFilePath, parseConfigText, resolveConfig, createTextOutput, activeOutput, activeOutputMode, RAFA_BLOCK_KINDS, isRafaBlockKind, readRafaBlocks };
+export { pinKey, pinLine, collisionMessage, readItemBytes, resolveTiers, findTierItem, DEFAULT_ROUTES, DEFAULT_ROUTING, CONFIG_FILE, CONFIG_DEFAULTS, SETTINGS, ConfigError, configFilePath, parseConfigText, resolveConfig, RAFA_BLOCK_KINDS, isRafaBlockKind, readRafaBlocks, REPORT_STATUSES, FINDING_KINDS, FINDING_SIGNALS, FINDING_DOMAINS, CHANGE_LEVELS, parseReport, createTextOutput, activeOutput, activeOutputMode };