diff --git a/docs/devteam/dashboard/index.html b/docs/devteam/dashboard/index.html
index ce35ac9..52964fc 100644
--- a/docs/devteam/dashboard/index.html
+++ b/docs/devteam/dashboard/index.html
@@ -649,7 +649,7 @@ <h2>Loop <span class="sub">how the supervisor notices, makes sense of, decides a
     <div class="loop-panel" data-panel="orient" hidden>
       <p class="loop-intro">What the signal adds up to. Things noticed more than once become recurring signals; real or likely trouble becomes a problem; lessons, facts and your preferences become knowledge, which goes into every agent's instructions once accepted.</p>
       <h3>Orientation debt</h3>
-      <p class="small muted">Recurring signals nothing has explained for more than a day: each wants a lesson, a problem, or a ruling that it is noise.</p>
+      <p class="small muted">Recurring signals nothing has explained for more than a day: each wants a lesson, a problem, or a ruling that it is noise. Then incidents fixed and verified in the last 30 days that nobody has learned from: each wants a lesson, or a ruling that there is nothing to keep.</p>
       <div id="debt"></div>
       <div class="two">
         <div><h3>Recurring signals</h3><div id="clusters"></div></div>
@@ -2106,8 +2106,10 @@ <h4><a class="title-link" href="#goal/${encodeURIComponent(g.id)}">${esc(g.title
 
   // Orient
   const debt = o.debt?.signals || [];
-  $('debt').innerHTML = debt.length ? debt.map((x) => `
-    <div class="card small" data-open="signal/${esc(encodeURIComponent(x.key))}"><a class="linkish" href="#signal/${encodeURIComponent(x.key)}"><b>${esc(signalTitle(x.key))}</b></a> <span class="muted">· seen ${esc(x.count)} times · unexplained for ${esc(hoursWords(x.hours))}</span><div>${linkify(x.latest)}</div></div>`).join('') : empty('Nothing waiting: every recurring signal is explained or under a day old.');
+  const taught = o.debt?.incidents || [];
+  $('debt').innerHTML = debt.length || taught.length ? debt.map((x) => `
+    <div class="card small" data-open="signal/${esc(encodeURIComponent(x.key))}"><a class="linkish" href="#signal/${encodeURIComponent(x.key)}"><b>${esc(signalTitle(x.key))}</b></a> <span class="muted">· seen ${esc(x.count)} times · unexplained for ${esc(hoursWords(x.hours))}</span><div>${linkify(x.latest)}</div></div>`).join('') + taught.map((x) => `
+    <div class="card small"${subj('problem', x.id, x.title)} data-open="problem/${esc(encodeURIComponent(x.id))}"><span class="badge">incident</span><a class="linkish" href="#problem/${encodeURIComponent(x.id)}"><b>${esc(x.title)}</b></a> <span class="muted">· fixed and verified ${x.days ? `${esc(x.days)} day${x.days > 1 ? 's' : ''} ago` : 'today'}</span><div>What did it teach? A lesson, or a ruling that there is nothing to keep. <span class="muted">${x.decision ? `The fix: ${linkify(x.decision)} · ` : ''}what came of it: ${linkify(x.outcome)}</span></div></div>`).join('') : empty('Nothing waiting: every recurring signal is explained or under a day old, and every fixed incident has been learned from.');
   $('clusters').innerHTML = o.clusters.length ? o.clusters.map((c) => `
     <div class="card small" data-open="signal/${esc(encodeURIComponent(c.key))}"><a class="linkish" href="#signal/${encodeURIComponent(c.key)}"><b>${esc(words(c.key.split(':')[0]))}</b></a> ${subjectLink(c.key.split(':').slice(1).join(':'))} <span class="muted">· seen ${esc(c.count)} times</span><div>${linkify(c.latest)}</div></div>`).join('') : empty('None. Something noticed more than once shows here.');
   $('problems').innerHTML = o.problems.length ? o.problems.map((p) => `
@@ -2290,8 +2292,8 @@ <h4><a class="title-link" href="#goal/${encodeURIComponent(g.id)}">${esc(g.title
     hide: ['review', 'result', 'secrets', 'secrets_posted', 'choices', 'status'],
     fmt: { why_asked: (w) => `${w.rung ? `${esc(RUNG_WORDS[w.rung])}` : ''}${w.ceiling ? `, at most ${esc(RUNG_WORDS[w.ceiling])}` : ''}${(w.reasons || []).length ? ` · ${esc(w.reasons.map(words).join(', '))}` : ''}`, autonomy: (a) => `${esc(words(a.class))}: ${esc(RUNG_WORDS[a.rung])}${a.scope ? ` (${esc(a.scope)})` : ''}`, goal: (v) => glink(v), re: (v) => linkify(v) },
   },
-  decision: { order: ['what', 'class', 'scope', 'authority', 'approved_by', 'rung', 'ceiling', 'options', 'rationale', 'confidence', 'refs', 'reversible'], fmt: { authority: (v) => esc(AUTHORITY_LABEL[v] || v) } },
-  act: { order: ['what', 'class', 'scope', 'decision', 'approved_by', 'rung', 'refs', 'reversible'], fmt: { id_block: (b) => `${esc(b.feature)}: ${esc(b.from)} to ${esc(b.to)}` } },
+  decision: { order: ['what', 'class', 'scope', 'authority', 'approved_by', 'knowledge', 'rung', 'ceiling', 'options', 'rationale', 'confidence', 'refs', 'reversible'], label: { knowledge: 'Rests on' }, fmt: { authority: (v) => esc(AUTHORITY_LABEL[v] || v), knowledge: linkList } },
+  act: { order: ['what', 'class', 'scope', 'decision', 'approved_by', 'rung', 'refs', 'knowledge', 'reversible'], label: { knowledge: 'Given' }, fmt: { id_block: (b) => `${esc(b.feature)}: ${esc(b.from)} to ${esc(b.to)}`, knowledge: linkList } },
   knowledge: { order: ['statement', 'kind', 'status', 'scope', 'confidence', 'valence', 'evidence'], fmt: { valence: (v) => (v < 0 ? `${esc(v)} (something to avoid)` : esc(v)) } },
   problem: { order: ['title', 'status', 'severity', 'realized', 'threatens', 'assigned_to', 'detail', 'refs'], fmt: { realized: (v) => (v ? 'yes: an issue' : 'no: a risk'), assigned_to: (v) => linkify(v), severity: (v) => `<span class="badge ${sevBadge(v)}">${esc(v)}</span>` } },
   message: { fmt: { to: (v) => esc(who(v)), re: (v) => linkify(v) } },
@@ -2922,6 +2924,7 @@ <h3>Changelog</h3>${merged.length ? `<ul>${merged.map((t) => `<li>${tlink(t.id)}
     ] })}
     ${v.detail ? `<p class="ctx measure">${v.detail}</p>` : ''}
     ${lineageBlock(p)}
+    ${knowledgeCited(p, 'What its instructions carried')}
     ${d ? `<h3>The decision it carried out</h3><div class="card small"><div>${dlink(d.id, d.what)}</div>${d.rationale ? `<div class="act-detail">${linkify(d.rationale)}</div>` : ''}<div class="meta">${authorityWords(d.under)} · ${esc(when(d.at))}${d.correction ? ` · <span class="badge high">corrected</span> ${esc(d.correction.reason)}` : ''}</div></div>` : ''}
     ${citedBlock(p, a)}
     ${a.correction ? '' : a.decision ? '<p class="small muted">It carried out a decision: correct the decision if the call was wrong (Loop → Decide). If the call was sound and the act went wrong, that is a problem, not a trust drop.</p>' : '<p class="small muted">To correct it, use Correct on it in Loop → Act.</p>'}
@@ -2934,9 +2937,16 @@ <h3>Changelog</h3>${merged.length ? `<ul>${merged.map((t) => `<li>${tlink(t.id)}
   const k = (DATA.ooda.knowledge || []).find((x) => x.id === approvedBy);
   return k ? `<h3>The standing rule it rests on</h3><div class="card small"><a class="linkish" href="#lesson/${encodeURIComponent(k.id)}">${esc(k.statement)}</a> <span class="muted">· ${esc(scopeWords(k.scope))}</span></div>` : '';
 }
-// Records an object cites, in their own words (from its peek).
+// The knowledge a decision rests on (decide --on), or a start's prompt carried, in its own words
+// (from its peek): what the call or the session had to go on.
+function knowledgeCited(p, title) {
+  const ks = p?.record?.fields?.knowledge || [];
+  return ks.length ? `<h3>${esc(title)}</h3><ul>${ks.map((id) => { const x = p.cited?.[id]; return `<li>${linkify(id)}${x ? ` <span class="muted">${esc(words(x.kind ?? x.type))}${x.type === 'knowledge' && x.status && x.status !== 'accepted' ? `, ${esc(x.status)}` : ''}</span>${x.text ? `: ${linkify(String(x.text).slice(0, 160))}` : ''}` : ''}</li>`; }).join('')}</ul>` : '';
+}
+// Records an object cites, in their own words (from its peek); what it rests on or was given has its own list.
 function citedBlock(p, o) {
-  const c = Object.entries(p?.cited || {}).filter(([id]) => !id.startsWith('q-') || !o?.approved_by || id !== o.approved_by);
+  const given = new Set(p?.record?.fields?.knowledge || []);
+  const c = Object.entries(p?.cited || {}).filter(([id]) => (!id.startsWith('q-') || !o?.approved_by || id !== o.approved_by) && !given.has(id));
   return c.length ? `<h3>What it cites</h3><ul>${c.map(([id, x]) => `<li>${linkify(id)} <span class="muted">${esc(words(x.type))}${x.kind ? ` (${esc(words(x.kind))})` : ''}</span>${x.text ? `: ${linkify(String(x.text).slice(0, 160))}` : ''}</li>`).join('')}</ul>` : '';
 }
 function openDecision(id) {
@@ -2953,6 +2963,7 @@ <h3>Changelog</h3>${merged.length ? `<ul>${merged.map((t) => `<li>${tlink(t.id)}
     ] })}
     ${lineageBlock(p)}
     ${restsOn(r.under?.approved_by)}
+    ${knowledgeCited(p, 'What it drew on (not its authority)')}
     ${r.kind === 'decision' ? `<h3>Carried out by</h3>${acts.length ? `<ol class="tl">${acts.map((a) => `<li class="act"><time>${a.created_at ? esc(when(a.created_at)) : ''}</time><a class="linkish" href="#act/${encodeURIComponent(a.id)}">${a.what ? actView(a).head : esc(a.id)}</a></li>`).join('')}</ol>` : '<p class="muted">Nothing yet.</p>'}` : ''}
     ${r.correction ? '' : '<p class="small muted">To correct it, use Correct on it in Loop → Decide.</p>'}
     ${historySection(p, id)}`);
diff --git a/docs/devteam/process/supervisor.md b/docs/devteam/process/supervisor.md
index d0bf872..46e717d 100644
--- a/docs/devteam/process/supervisor.md
+++ b/docs/devteam/process/supervisor.md
@@ -34,7 +34,7 @@ A reading (a sensor's daily rollup, a goal reading, a `spend` line, a `gate` run
 
 **Orient**
 3. Fix drift (§4).
-4. `devteam.mjs orient`: every recurring signal (three or more observations or corrections on one key) gets explained: a lesson (`knowledge add --kind lesson --scope … --evidence …`, with `--kit` when it is about the kit rather than this project, §9 Share upstream), a problem (`problem add`), or noise: `decide --class orient-noise --refs <signal key> <observation ids> -- "<why>"` (it clears the signal; the owner can correct it, and a corrected ruling brings the signal back). A sensor's qualifies and spikes on one fingerprint are one signal, keyed by the fingerprint's id. A ruling that names the signal's key covers all of its observations up to the ruling, so it needn't list them; one after it gets a fresh look (use `sensor ignore` for a fingerprint that is always noise). A fingerprint an open incident holds is in hand, not a signal. A candidate lesson waits in the owner's inbox to keep or retire; accept one yourself (`knowledge set <id> --status accepted`) only when the evidence is plain, and the owner can still retire it. Accepted knowledge goes into the next prompts in that scope. Triage open problems: assign, mitigate, resolve. Read the owner's recent resolutions (`log --type observation`, kind `thread-resolved`): what they keep raising, about which goals and pages, and what they resolved without a change. Three threads on one goal is a signal about the goal: orient on it. For each new problem or incident, and each observation of severity 3 or more, `search "<its words>" --limit 5`: it may have happened before under other ids. A recurring signal nothing has explained for more than a day is orientation debt: the dashboard's Orient tab lists it first (`dashboard-data`'s `ooda.debt`), and you pay it down before newer signals. Each record in the loop has a lineage, what it came from and what came of it (observation → signal → lesson or incident → decision → act → outcome): `devteam.mjs peek <kind> <id> --json` carries it as `lineage`, and `peek <kind> <id> --mermaid` prints it as a Mermaid flowchart to paste into a retro or a PR body (a recurring signal's kind is `signal`, its id its key).
+4. `devteam.mjs orient`: every recurring signal (three or more observations or corrections on one key) gets explained: a lesson (`knowledge add --kind lesson --scope … --evidence …`, with `--kit` when it is about the kit rather than this project, §9 Share upstream), a problem (`problem add`), or noise: `decide --class orient-noise --refs <signal key> <observation ids> -- "<why>"` (it clears the signal; the owner can correct it, and a corrected ruling brings the signal back). A sensor's qualifies and spikes on one fingerprint are one signal, keyed by the fingerprint's id. A ruling that names the signal's key covers all of its observations up to the ruling, so it needn't list them; one after it gets a fresh look (use `sensor ignore` for a fingerprint that is always noise). A fingerprint an open incident holds is in hand, not a signal. A candidate lesson waits in the owner's inbox to keep or retire; accept one yourself (`knowledge set <id> --status accepted`) only when the evidence is plain, and the owner can still retire it. Accepted knowledge goes into the next prompts in that scope. Triage open problems: assign, mitigate, resolve. Read the owner's recent resolutions (`log --type observation`, kind `thread-resolved`): what they keep raising, about which goals and pages, and what they resolved without a change. Three threads on one goal is a signal about the goal: orient on it. For each new problem or incident, and each observation of severity 3 or more, `search "<its words>" --limit 5`: it may have happened before under other ids. A recurring signal nothing has explained for more than a day is orientation debt: the dashboard's Orient tab lists it first (`dashboard-data`'s `ooda.debt.signals`), and you pay it down before newer signals. So is an incident fixed and verified in the last 30 days (resolved, with an outcome citing it) that nothing learned from: `orient` lists it after the signals ("<p-id> was fixed and verified (<title>): what did it teach?", `ooda.debt.incidents`) with the two answers to paste: a lesson citing the incident, its fix decision and the outcome (`knowledge add --kind lesson --scope … --evidence <p-id> <d-id> <outcome id>`), or `decide --class orient-noise --refs <p-id> -- "nothing to keep"`. A fast fix still turns into knowledge this way; an incident whose status the owner set is theirs, and owes nothing. Each record in the loop has a lineage, what it came from and what came of it (observation → signal → lesson or incident → decision → act → outcome): `devteam.mjs peek <kind> <id> --json` carries it as `lineage`, and `peek <kind> <id> --mermaid` prints it as a Mermaid flowchart to paste into a retro or a PR body (a recurring signal's kind is `signal`, its id its key).
    - **Revisit what matters.** You rate; the kit orders. A goal with no impact (`goal-unjudged`), or one whose impact was corrected at a retro: `goal impact <g-id> <1-4> --rationale "…"`, judged against the strategy's "How it wins" order and never against how much work the goal is (`planning.md` §1). Judge again when the strategy changes. An open question whose stake or urgency has changed (work stopped on it, a ticket merged, another question now covers it): `rate <qid> --urgency 3`. A new question that an open one would settle: `rate <gate-qid> --settles <qid>`, which adds it to the list. An unrated question (`question-unrated`): rate it.
 
 **Decide**
@@ -44,7 +44,7 @@ A reading (a sensor's daily rollup, a goal reading, a `spend` line, a `gate` run
 
 **Act**
 8. Schedule (§5). Merge (`merge <id>`, §5). Log every decision; approvals of specs and plans are acts of those classes, not commands of their own (`act --class approve-spec --refs <id>`, `act --class approve-plan --refs <id>`; the latter refuses while a one-way door on the ticket is unanswered, or while the committed plan has no TL;DR; a door the owner already answered for the ticket's goal is cited with `--approved <qid>`, and counts only when the plan review says `- Goal-level door: <qid> covers this plan`), and so are rulings (`act --class contract-ruling`, `act --class approve-design-change`), goal readiness, recoveries and trials. On a `risk: normal` ticket, approve a plan from its TL;DR and its plan review (the verdict holds, its findings are dispositioned) unless one of them gives you a reason to read on; on `risk: high`, or a ticket with a one-way door or a contract, read the whole plan. `merge`, `ticket add`/`set`, `answer --defaulted` and `withdraw` log their own acts.
-   - **Decide, then act.** A judgment call (you weighed options; a reasonable owner could have chosen otherwise) is a decision first: `decide --class <c> --refs <what it is about> [--options "a" "b"] [--rationale "…"] [--confidence 0-1] [--approved <qid|kid>] -- "<what you decided>"` prints a `d-` id and records the trust it rests on. Each act that carries it out cites it: `act --decision <d-id> -- "<what you did>"`, within the decision's refs; `merge`, `ticket add`/`set`, `withdraw`, `goal hold`, `worker`, `planner` and `fleet` take `--decision` too when what they act on is in its refs. Something routine (merging what the gates passed, starting a worker for a ready ticket) is an act on its own: `act --class <c> [--refs ids] -- "<what>"`. A standing rule authorises a call only when the owner scoped it to the class (`class:<c>`). A decision made on the class's own rung lapses if the class drops after it: decide again.
+   - **Decide, then act.** A judgment call (you weighed options; a reasonable owner could have chosen otherwise) is a decision first: `decide --class <c> --refs <what it is about> [--options "a" "b"] [--rationale "…"] [--confidence 0-1] [--approved <qid|kid>] -- "<what you decided>"` prints a `d-` id and records the trust it rests on. When the call rests on what the project knows, cite it: `--on <k-…|p-…>…` names the accepted knowledge (a lesson, a fact, the owner's rule) or the problems it turned on (at most 60); knowledge that isn't accepted is refused, and it grants nothing: the authority is still `--approved` or the class's rung. They are stored as the decision's `knowledge`, never in its refs (an act stays within refs) and never as its authority (`--approved` is that); a candidate or retired lesson, or an id also in `--refs`, is refused. The lineage draws them into the decision. A worker's or planner's start records the accepted knowledge its prompt carried on its `worker-slots` act (`knowledge`), so a lesson's effect can be traced to the sessions it reached. Each act that carries it out cites it: `act --decision <d-id> -- "<what you did>"`, within the decision's refs; `merge`, `ticket add`/`set`, `withdraw`, `goal hold`, `worker`, `planner` and `fleet` take `--decision` too when what they act on is in its refs. Something routine (merging what the gates passed, starting a worker for a ready ticket) is an act on its own: `act --class <c> [--refs ids] -- "<what>"`. A standing rule authorises a call only when the owner scoped it to the class (`class:<c>`). A decision made on the class's own rung lapses if the class drops after it: decide again.
 9. Health: a ticket silent for `stale_after_minutes` whose pane shows nothing goes to recovery.
 
 **Improve and record**
diff --git a/docs/devteam/schema/log.schema.json b/docs/devteam/schema/log.schema.json
index 9be2b91..5e2a445 100644
--- a/docs/devteam/schema/log.schema.json
+++ b/docs/devteam/schema/log.schema.json
@@ -1784,6 +1784,15 @@
             "type": "string",
             "pattern": "^[qk]-"
           },
+          "knowledge": {
+            "description": "The knowledge or problems this decision rests on (decide --on); never copied into refs, and never its authority (approved_by is).",
+            "type": "array",
+            "items": {
+              "type": "string",
+              "pattern": "^(k|p)-"
+            },
+            "x-tip": "The lessons, facts or problems the call rests on."
+          },
           "corrected": {
             "description": "Your correction, if the call was wrong; it drops the class to rung 1. On a goal-impact decision (constitutional, so no rung drops) it may carry the impact you give the goal instead.",
             "type": "object",
@@ -1871,6 +1880,15 @@
             "pattern": "^d-",
             "x-tip": "The decision it carried out."
           },
+          "knowledge": {
+            "description": "On a worker-slots act that started a worker or planner fresh: the accepted knowledge its prompt carried (the knowledge that applies to its ticket or feature), newest first, at most 60. Never in what, which the kit parses. A resumed session reads no new prompt, so its act carries none.",
+            "type": "array",
+            "items": {
+              "type": "string",
+              "pattern": "^k-"
+            },
+            "x-tip": "The lessons and facts its instructions carried when it started."
+          },
           "corrected": {
             "description": "Your correction, if it was its own call and wrong.",
             "type": "object",
diff --git a/docs/devteam/scripts/devteam.mjs b/docs/devteam/scripts/devteam.mjs
index 8a29a7a..af688f6 100644
--- a/docs/devteam/scripts/devteam.mjs
+++ b/docs/devteam/scripts/devteam.mjs
@@ -998,6 +998,9 @@ const RUNG = { 1: 'ask', 2: 'ask with a default', 3: 'act and report' };
 const SCHEMA = readJson(path.join(kitDir, 'schema', 'log.schema.json'));
 const ENVELOPE = ['v', 'id', 'type', 'op', 'at', 'by', 'channel'];
 const LINE_MAX = 4096;
+// The most knowledge ids a decision (--on) or a start (the lessons its prompt carried) records, so its
+// line stays under LINE_MAX.
+const KNOWLEDGE_IDS_MAX = 60;
 const TYPES = Object.keys(SCHEMA.$defs.types);
 const RANK = SCHEMA['x-authority'].rank;
 
@@ -7833,12 +7836,24 @@ const citing = () => flagStr('decision') ?? undefined;
 function cmdDecide() {
   const what = rest ? rest.join(' ') : flagStr('what');
   const cls = flagStr('class');
-  if (!cls || !what) die('usage: decide --class c [--scope s] [--approved qid|kid] [--options "a" "b"] [--rationale "…"] [--confidence 0-1] [--refs ids] [--irreversible] -- "<what you decided>"');
+  if (!cls || !what) die('usage: decide --class c [--scope s] [--approved qid|kid] [--options "a" "b"] [--rationale "…"] [--confidence 0-1] [--refs ids] [--on k-…|p-…] [--irreversible] -- "<what you decided>"');
   supervisorOnly('decide');
   if (cls === 'improvement-trial') upkeepAllows('a new trial');
   let scope = flagStr('scope') ?? null;
   const approved = flagStr('approved') ?? null;
   const refs = asList(flags.refs);
+  // --on: the knowledge or problems the call rests on, a link for the lineage and the learning
+  // record, apart from refs (an act stays within refs) and from approved_by (authorise reads only
+  // that). Knowledge must be accepted: a candidate isn't the project's yet, and a retired one no
+  // longer is. An id in both would read as what the call is about and what it rests on at once.
+  const on = flags.on === true ? die('--on names the knowledge or problems the decision rests on: --on <k-…|p-…>…') : [...new Set(asList(flags.on))];
+  if (on.length > KNOWLEDGE_IDS_MAX) die(`--on takes at most ${KNOWLEDGE_IDS_MAX} ids (a log line is at most ${LINE_MAX} bytes): cite the ones the call turns on`);
+  for (const k of on) {
+    const o = logGet(k) ?? die(`--on ${k}: no such knowledge or problem`);
+    if (!['knowledge', 'problem'].includes(o.type)) die(`--on ${k} is ${o.type === 'observation' ? 'an' : 'a'} ${o.type}: a decision rests on knowledge or a problem (cite what it is about in --refs)`);
+    if (o.type === 'knowledge' && o.status !== 'accepted') die(`${k} is ${o.status}: a decision rests only on accepted knowledge`);
+    if (refs.includes(k)) die(`${k} is in both --refs and --on: --refs is what the decision is about, --on what it rests on`);
+  }
   // a remediation decision names the remediation it runs
   if (cls === 'production-remediation') {
     upkeepAllows('a remediation', { noForce: true });
@@ -7881,12 +7896,13 @@ function cmdDecide() {
   if (['approve-spec', 'approve-plan'].includes(cls) && !tickets().has(refs[0])) die(`${cls} names the ticket first: --refs <ticket-id> [other ids]`);
   if (cls === 'goal-readiness') readinessGoal(refs);
   // a noise ruling explains observations by citing them (orientClusters); one that cites none explains nothing
-  if (cls === 'orient-noise' && !refs.some((r) => logGet(r)?.type === 'observation')) die('a noise ruling names the observations it explains: --refs <signal key> <o-…>…');
+  // (or the fixed incident it rules there is nothing to learn from: incidentDebt)
+  if (cls === 'orient-noise' && !refs.some((r) => { const x = logGet(r); return x?.type === 'observation' || (x?.type === 'problem' && isIncident(x) && x.status === 'resolved'); })) die('a noise ruling names the observations it explains: --refs <signal key> <o-…>… (or a fixed incident with nothing to keep: --refs <p-…>)');
   const a = authorise(cls, scope, approved, refs, 'decide');
   if (a.doorCited && a.approval.ticket !== refs[0] && !(features().get(tickets().get(refs[0])?.feature)?.goals ?? []).includes(a.approval.goal)) die(`${approved} answered a one-way door for ${a.approval.ticket ?? a.approval.goal ?? 'something else'}, not for ${refs[0]} or a goal its feature serves`);
   const line = appendLog({
     type: 'decision', class: cls, scope: scope ?? undefined, what, rationale: flagStr('rationale'), options: flags.options !== undefined ? listFlag('options') : undefined,
-    confidence, refs, reversible: !flags.irreversible, rung: a.rung, ceiling: a.ceiling, authority: a.authority, approved_by: approved ?? undefined,
+    confidence, refs, reversible: !flags.irreversible, rung: a.rung, ceiling: a.ceiling, authority: a.authority, approved_by: approved ?? undefined, knowledge: on.length ? [...new Set(on)] : undefined,
   }, 'supervisor');
   out(line.id);
 }
@@ -8649,6 +8665,28 @@ function orientationDebt() {
   return orientClusters().map((c) => { const first = signalGroups().get(c.key).items.map((i) => i.at).sort()[0]; return { key: c.key, count: c.count, latest: c.latest, first_at: first, hours: Math.floor((now - Date.parse(first)) / 3600000) }; })
     .filter((x) => x.hours >= 24).sort((a, b) => a.first_at.localeCompare(b.first_at));
 }
+// Resolved incidents nobody learned from, oldest first: fixed and verified (an outcome cites the
+// incident) in the last 30 days, with no knowledge citing it in its evidence and no live noise
+// ruling naming it, so a fast fix still turns into a lesson, or a ruling that there is nothing to
+// keep (a corrected ruling owes it again). Resolved when the last change setting its status said so.
+// One whose status the owner set is the owner's call, and owes nothing.
+function incidentDebt() {
+  const now = Date.now();
+  // a lesson the owner retired taught nothing, so the incident is owed one again
+  const taught = new Set(logObjects('knowledge').filter((k) => k.status !== 'retired').flatMap((k) => k.evidence ?? []));
+  for (const d of logObjects('decision')) if (d.class === 'orient-noise' && liveDecision(d)) for (const r of d.refs ?? []) taught.add(r);
+  const outcomes = logObjects('observation').filter((o) => o.kind === 'outcome').sort(byTime);
+  return incidentList().filter((p) => p.status === 'resolved' && !taught.has(p.id) && !ownerHolds(p, 'status')).flatMap((p) => {
+    const at = (p.updates ?? []).filter((u) => u.status === 'resolved').pop()?.at ?? p.created_at;
+    // verified only: an unverified resolution (valence 0, seen too few times) proved nothing to learn from
+    const outcome = outcomes.filter((o) => (o.refs ?? []).includes(p.id) && (o.valence ?? 0) > 0).pop();
+    if (!outcome || now - Date.parse(at) > 30 * DAY) return [];
+    const d = (outcome.refs ?? []).find((r) => logGet(r)?.type === 'decision') ?? incidentDecisions(p.id).pop()?.id ?? null;
+    const t = (outcome.refs ?? []).map((r) => tickets().get(r)).find(Boolean);
+    const cite = [p.id, ...(d ? [d] : []), outcome.id].map(shq).join(' ');
+    return [{ id: p.id, title: p.title, resolved_at: at, outcome: outcome.id, decision: d, days: Math.floor((now - Date.parse(at)) / DAY), explain: [`knowledge add --kind lesson --scope ${shq(t?.component ? `component:${t.component}` : 'project')} --statement '<what it teaches>' --evidence ${cite}`, `decide --class orient-noise --refs ${shq(p.id)} -- 'nothing to keep'`] }];
+  }).sort((a, b) => a.resolved_at.localeCompare(b.resolved_at));
+}
 // One value as a POSIX shell word: single-quoted, each ' written '\''. Every value orient puts in a
 // command it proposes goes through this, since observation text is anyone's to write and the
 // supervisor runs what it pastes (L-SEC-5).
@@ -8722,10 +8760,14 @@ function orientLinks() {
 }
 function cmdOrient() {
   const cl = orientClusters();
+  const inc = incidentDebt();
   const lk = orientLinks();
+  // --json stays the signals and the link proposals its readers count; incident debt is dashboard-data's ooda.debt.incidents
   if (flags.json) return json([...cl, ...lk]);
-  if (!cl.length && !lk.length) return out('nothing recurring that is unexplained');
+  if (!cl.length && !inc.length && !lk.length) return out('nothing recurring that is unexplained');
   for (const c of cl) out(`${c.key}  x${c.count}  valence ${c.valence}\n  latest: ${c.latest}\n  evidence: ${c.ids.join(' ')}`);
+  for (const x of inc) out(`${x.id} was fixed and verified (${x.title}): what did it teach? ${x.explain[0]} or ${x.explain[1]}`);
+  if (inc.length) out('  (once a lesson is accepted, a decision it informs cites it: decide … --on <k-…>)');
   if (lk.length) { out('link proposals:'); for (const p of lk) out(p.note ? `  ${p.note}` : `  ${p.proposal} (${p.observation})${p.proposed_by ? `, proposed by ${p.proposed_by}; check before adding` : ''}: ${p.command}`); out('  (dismiss one: decide --class registry-edit --refs <observation> -- "<why the registry stays as it is>")'); }
 }
 
@@ -10525,9 +10567,9 @@ function collectOoda() {
     // each with where it sits in the loop, so its card can say so without the whole index
     observations: recent(logObjects('observation').filter((o) => !['reading', 'retro', 'finding-ack'].includes(o.kind)), 40).map((o) => ({ ...withOoda(o), place: placeOf(o) })),
     clusters: orientClusters(),
-    // orientation debt: recurring signals nothing has explained for more than a day, oldest first
-    // (resolved incidents nobody learned from join it in PR 4)
-    debt: { signals: orientationDebt() },
+    // orientation debt: recurring signals nothing has explained for more than a day, and resolved
+    // incidents nobody learned from, each oldest first
+    debt: { signals: orientationDebt(), incidents: incidentDebt() },
     // every lesson waiting on the owner is in the Inbox, however many: only the rest are the recent 60
     knowledge: [...recent(logObjects('knowledge').filter((k) => k.status === 'candidate'), Infinity), ...recent(logObjects('knowledge').filter((k) => !['retired', 'candidate'].includes(k.status)), 60)],
     problems: logObjects('problem').filter((p) => p.status !== 'resolved').map((p) => (isIncident(p) ? { ...p, severity: incidentSeverity(p) } : p)).sort((a, b) => b.severity - a.severity),
@@ -12970,6 +13012,10 @@ function makeSession(role) {
   seedWorktree(wt, { repo: R });
   const promptFile = path.join(runDir, 'prompts', `${name}.txt`);
   const knowledge = knowledgeBlock(id);
+  // What the prompt's knowledge block carries, for the start's act (a lesson's effect is measured
+  // from it): only on a fresh start, since a resumed session never reads the new prompt; the newest
+  // first, as many as fit a line.
+  const given = resume ? [] : knowledgeFor(id).sort((a, b) => b.created_at.localeCompare(a.created_at)).slice(0, KNOWLEDGE_IDS_MAX).map((k) => k.id);
   const links = linksBlock(id);
   const arts = artifactsBlock(id);
   const held = block ?? (role === 'planner' ? idBlockFor(id) : null);
@@ -13031,7 +13077,7 @@ function makeSession(role) {
     if (role === 'worker' && !resume) appendLog({ type: 'phase', from: null, to: 'starting', note: `started in ${shown}` }, id);
     // a planner parked by a park is running again
     if (role === 'planner' && lastPhaseOf(name)?.to === 'parked') appendLog({ type: 'phase', from: 'parked', to: 'starting', note: `started in ${shown}` }, name);
-    appendLog({ type: 'act', decision: citing(), class: 'worker-slots', what: `${resume ? 'resumed' : 'made'} ${role} ${name} in ${shown}${block ? `, ticket numbers ${padNN(block.from)}-${padNN(block.to)}` : ''}${refused ? ` while its goal is ${holdWords(mode)}, with --force` : ''}`, refs: role === 'worker' ? [id] : goalIds, reversible: true, id_block: block ?? undefined }, 'supervisor');
+    appendLog({ type: 'act', decision: citing(), class: 'worker-slots', what: `${resume ? 'resumed' : 'made'} ${role} ${name} in ${shown}${block ? `, ticket numbers ${padNN(block.from)}-${padNN(block.to)}` : ''}${refused ? ` while its goal is ${holdWords(mode)}, with --force` : ''}`, refs: role === 'worker' ? [id] : goalIds, reversible: true, id_block: block ?? undefined, knowledge: given.length ? given : undefined }, 'supervisor');
     out(`${resume ? 'resumed' : 'made'} ${role} ${name} in ${shown} at ${wt}${block ? `; ticket numbers ${padNN(block.from)}-${padNN(block.to)} reserved` : ''}`);
     });
   } catch (e) {
@@ -15489,6 +15535,7 @@ function historyOf(ids, { types = null, limit = 300 } = {}) {
 // authority checks out (decisionAuthorityGap), an act carrying one out, or an act of its own resting
 // on an owner's accepted rule or an answered question. Anything else only cites it: a supervisor's
 // lesson is never the owner approving.
+const restsOnHolds = (x) => x?.type === 'problem' || (x?.type === 'knowledge' && x.status === 'accepted');
 function approvalHolds(o) {
   if (o.type === 'decision') return !decisionAuthorityGap(o);
   if (o.type !== 'act') return false;
@@ -15522,7 +15569,10 @@ function linkIndex() {
     for (const [k, why] of Object.entries(LINK_FIELDS)) for (const t of Array.isArray(o[k]) ? o[k] : []) {
       if (!known(t)) continue;
       if (o.type === 'act' && o.class === 'add-ticket' && k === 'refs' && logGet(t).type === 'ticket') edge(o.id, t, 'made');
-      else edge(t, o.id, why);
+      // a start's knowledge was what its prompt carried, whatever became of it since; what a decision
+      // rests on is only what decide --on would take, a problem or accepted knowledge (a hand-written
+      // line citing anything else only cites it)
+      else edge(t, o.id, k !== 'knowledge' ? why : o.type === 'act' ? 'given' : restsOnHolds(logGet(t)) ? why : 'cites');
     }
     if (known(o.approved_by)) edge(o.approved_by, o.id, approvalHolds(o) ? 'approved' : 'cites');
     if (known(o.decision)) edge(o.decision, o.id, 'carried out');
@@ -15683,7 +15733,7 @@ function peekView(kind, id) {
   const v = { kind, id, record: recordView(flagStr('rec') ?? (kind === 'planner' ? '' : id)) };
   // where a record sits in the loop, and where an observation came from
   if (v.record) { const o = logGet(v.record.id); v.stage = stageOf(o); if (o.type === 'observation') v.provenance = provenanceOf(o); }
-  const cited = (refs) => Object.fromEntries([...new Set(refs ?? [])].map((r) => [r, logGet(r)]).filter(([, o]) => o).map(([r, o]) => [r, { type: o.type, created_at: o.created_at, created_by: o.created_by, kind: o.kind ?? null, text: o.detail ?? o.statement ?? o.what ?? o.title ?? o.question ?? o.text ?? null }]));
+  const cited = (refs) => Object.fromEntries([...new Set(refs ?? [])].map((r) => [r, logGet(r)]).filter(([, o]) => o).map(([r, o]) => [r, { type: o.type, created_at: o.created_at, created_by: o.created_by, kind: o.kind ?? null, status: o.status ?? null, text: o.detail ?? o.statement ?? o.what ?? o.title ?? o.question ?? o.text ?? null }]));
   if (kind === 'ticket') {
     gitReadCache = new Map();
     const t = tickets().get(id) ?? die(`no ticket ${id}`);
@@ -15765,7 +15815,7 @@ function peekView(kind, id) {
   } else {
     const o = logGet(id) ?? die(`no record ${id}`);
     v.history = historyOf([id]);
-    v.cited = cited([...(o.refs ?? []), ...(o.evidence ?? []), ...(o.approved_by ? [o.approved_by] : [])]);
+    v.cited = cited([...(o.refs ?? []), ...(o.evidence ?? []), ...(o.approved_by ? [o.approved_by] : []), ...(Array.isArray(o.knowledge) ? o.knowledge : [])]);
     if (o.type === 'problem' || o.type === 'knowledge') v.related = logObjects('observation').filter((x) => (x.refs ?? []).includes(id) || x.subject === id || (o.evidence ?? []).includes(x.id)).sort(byTime).map((x) => ({ id: x.id, at: x.created_at, by: x.created_by, kind: x.kind, detail: x.detail, severity: x.severity ?? null }));
     // an incident: its view, what its fingerprints raised, and the latest event of each
     // (production data, scrubbed; the drawer frames it as untrusted)
diff --git a/docs/superpowers/specs/2026-11-11-ooda-loop-inspectable-design.md b/docs/superpowers/specs/2026-11-11-ooda-loop-inspectable-design.md
index 7f45f2d..5b1c479 100644
--- a/docs/superpowers/specs/2026-11-11-ooda-loop-inspectable-design.md
+++ b/docs/superpowers/specs/2026-11-11-ooda-loop-inspectable-design.md
@@ -93,6 +93,7 @@ Additive fields and refs, so a lineage walk finds every step:
 - **A worker or planner start records what it was given:** the `worker-slots` act gains `knowledge: [k-…]`, the ids `knowledgeBlock` put in its prompt, as a field (never in `what`, which `LAUNCH_ACT` parses). The act is the same class for both roles; a planner's is counted apart from a worker's. This is what makes a lesson's effect measurable (§6).
 - **A noise ruling is a decision:** `decide --class orient-noise --refs <signal key> <observation ids…> -- "<why>"`, a new constitutional class (the supervisor's own call: the owner can correct it, and a correction is recorded and drawn in Learn, but like every constitutional class it moves no rung). `orientClusters` treats ids cited by a decision as explained, as it does knowledge evidence and problem refs. Today "say so in an observation" silences nothing.
 - **A set-aside cites what it sets aside:** `ack` writes `refs` to the finding's observations. A triage ignore (`sensor ignore`) writes `refs` to the fingerprint's observations. Both stay stored as they are and sit in Decide. Each carries at most the 40 most recent observation ids (a line is at most 4,096 bytes); the fingerprint or finding key stays in `source_ref`, and the lineage joins the rest by key.
+  *Changed while building PR 4:* `orient` proposes no `decide` commands, so the `--on` hint went into its incident-debt lines instead. A start records its knowledge only when it starts fresh (a resumed session never reads the new prompt), newest first, at most 60 ids; `--on` takes at most 60 too, and refuses an id also in `--refs`.
 - **A resolved incident asks what it taught.** An incident resolved with an `outcome` and no knowledge citing it is orientation debt: `orient` lists it beside the recurring signals ("p-… was fixed and verified: what did it teach? a lesson, or nothing to keep"). The supervisor answers with `knowledge add --evidence <p-id> <d-id> <outcome id>` or a noise ruling. This is how a fast fix still turns into knowledge.
 
 ### 4. Lineage
diff --git a/test/fixtures/g1/dashboard-data.txt b/test/fixtures/g1/dashboard-data.txt
index a6029bb..6a8795b 100644
--- a/test/fixtures/g1/dashboard-data.txt
+++ b/test/fixtures/g1/dashboard-data.txt
@@ -448,7 +448,8 @@ exit 0
       }
     ],
     "debt": {
-      "signals": []
+      "signals": [],
+      "incidents": []
     },
     "knowledge": [
       {
diff --git a/test/ooda-knowledge.test.mjs b/test/ooda-knowledge.test.mjs
new file mode 100644
index 0000000..10dfaf1
--- /dev/null
+++ b/test/ooda-knowledge.test.mjs
@@ -0,0 +1,182 @@
+// Knowledge in decisions and prompts (the OODA spec, PR 4): a decision cites the knowledge or
+// problems it rests on, a worker's or planner's start records the lessons its prompt carried, and a
+// fixed incident nobody learned from is orientation debt until a lesson or a noise ruling cites it.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fleetFixture, json, line, hasTmux } from './lib/kit.mjs';
+
+const SUP = { DEVTEAM_ROLE: 'supervisor' };
+const stamp = (d) => `${d.toISOString().slice(0, 10).replace(/-/g, '')}-${d.toISOString().slice(11, 23).replace(/[:.]/g, '')}`;
+// A line as the kit would have written it agoMs ago, in its writer's file. Ids follow the kit's
+// form, so each line picks a distinct agoMs; lines go in time order.
+function handFor(F) {
+  const logDir = path.join(F.old, 'docs/devteam/run/log');
+  return (by, o, agoMs = 1000) => {
+    const d = new Date(Date.now() - agoMs);
+    const id = o.id ?? `${{ observation: 'o', problem: 'p', decision: 'd', act: 'a', knowledge: 'k' }[o.type]}-${stamp(d)}-${by}`;
+    const file = ['owner', 'supervisor'].includes(by) ? `${by}-${d.toISOString().slice(0, 7)}.jsonl` : `${by}.jsonl`;
+    fs.mkdirSync(logDir, { recursive: true });
+    fs.appendFileSync(path.join(logDir, file), line({ op: 'new', ...(by === 'owner' ? { channel: 'cli' } : {}), ...o, id, at: d.toISOString(), by }));
+    return id;
+  };
+}
+const peek = (F, kind, id) => json(F.ok(F.old, ['peek', kind, id, '--json']));
+const decisionOf = (F, id) => json(F.ok(F.old, ['log', '--type', 'decision', '--json'])).find((d) => d.id === id);
+
+test('decide --on: a decision cites the accepted knowledge or problems it rests on, apart from its refs', () => {
+  const F = fleetFixture('ooda-on');
+  const { old, ok, run } = F;
+  try {
+    const o1 = ok(old, ['observe', '--subject', 'app', '--kind', 'note', '--detail', 'the registry has a scratch copy'], SUP).trim();
+    const rule = ok(old, ['knowledge', 'add', '--kind', 'preference', '--statement', 'Keep scratch copies out of the registry', '--scope', 'project', '--owner']).trim();
+    const cand = ok(old, ['knowledge', 'add', '--kind', 'lesson', '--statement', 'Scratch copies confuse workers', '--scope', 'project', '--evidence', o1], SUP).trim();
+    const old1 = ok(old, ['knowledge', 'add', '--kind', 'fact', '--statement', 'The registry was hand-kept', '--scope', 'project', '--owner']).trim();
+    ok(old, ['knowledge', 'set', old1, '--status', 'retired', '--owner']);
+    const p = ok(old, ['problem', 'add', '--title', 'registry drift', '--severity', '1'], SUP).trim();
+
+    // without --on, then with it: the same call, the same authority; knowledge stored, refs as given
+    const plain = ok(old, ['decide', '--class', 'registry-edit', '--refs', o1, '--', 'the registry stays as it is'], SUP).trim();
+    const on = ok(old, ['decide', '--class', 'registry-edit', '--refs', o1, '--on', rule, p, '--', 'the registry stays as it is'], SUP).trim();
+    const d0 = decisionOf(F, plain), d1 = decisionOf(F, on);
+    assert.equal(d0.knowledge, undefined, 'no --on, no field');
+    assert.deepEqual(d1.knowledge, [rule, p]);
+    assert.deepEqual(d1.refs, [o1], 'never copied into refs');
+    assert.equal(d1.authority, d0.authority, 'citing a standing rule with --on is not resting on it for authority');
+    assert.equal(d1.approved_by, undefined);
+    // an act under it stays within its refs, as before
+    ok(old, ['act', '--decision', on, '--', 'left the registry as it is'], SUP);
+    assert.match(run(old, ['act', '--decision', on, '--refs', rule, '--', 'x'], SUP).err, /outside it/);
+
+    // refused: a candidate, a retired lesson, an observation, an unknown id, one in both lists, a bare --on
+    assert.match(run(old, ['decide', '--class', 'registry-edit', '--refs', o1, '--on', cand, '--', 'x'], SUP).err, new RegExp(`${cand} is candidate: a decision rests only on accepted knowledge`));
+    assert.match(run(old, ['decide', '--class', 'registry-edit', '--refs', o1, '--on', old1, '--', 'x'], SUP).err, new RegExp(`${old1} is retired: a decision rests only on accepted knowledge`));
+    assert.match(run(old, ['decide', '--class', 'registry-edit', '--refs', o1, '--on', o1, '--', 'x'], SUP).err, /--on .*knowledge or a problem/);
+    assert.match(run(old, ['decide', '--class', 'registry-edit', '--refs', o1, '--on', 'k-nope', '--', 'x'], SUP).err, /--on k-nope: no such/);
+    assert.match(run(old, ['decide', '--class', 'registry-edit', '--refs', o1, p, '--on', p, '--', 'x'], SUP).err, new RegExp(`${p} is in both --refs and --on`));
+    assert.match(run(old, ['decide', '--class', 'registry-edit', '--refs', o1, '--on', '--', 'x'], SUP).err, /--on names/);
+
+    // lineage draws what it rests on before it
+    const L = peek(F, 'decision', on).lineage;
+    for (const k of [rule, p]) assert.ok(L.edges.some((e) => e.from === k && e.to === on && e.why === 'rests on'), `${k} → ${on}: ${JSON.stringify(L.edges)}`);
+    // the peek names them in their own words
+    assert.equal(peek(F, 'decision', on).cited[rule].text, 'Keep scratch copies out of the registry');
+  } finally { F.done(); }
+});
+
+test('a start records the accepted knowledge its prompt carried: fresh starts only, newest first, at most 60', { skip: !hasTmux && 'no tmux' }, () => {
+  const F = fleetFixture('ooda-given');
+  const { old, ok } = F;
+  const hand = handFor(F);
+  const ticket = (id, component) => ok(old, ['ticket', 'add', id, '--json', JSON.stringify({ title: id, feature: 'chores', component, kind: 'chore', size: 'S', risk: 'normal', serves: [], depends_on: [], touches: [`${component}/**`], done_when: ['the tidy check passes in CI'] })], SUP);
+  const starts = () => json(ok(old, ['log', '--type', 'act', '--json'])).filter((a) => a.class === 'worker-slots');
+  const startOf = (name) => starts().filter((a) => a.what.includes(` ${name} in `)).pop();
+  const rawLine = (id) => fs.readdirSync(path.join(old, 'docs/devteam/run/log')).flatMap((f) => fs.readFileSync(path.join(old, 'docs/devteam/run/log', f), 'utf8').split('\n')).find((l) => l.includes(`"id":"${id}"`));
+  try {
+    // 61 accepted lessons for one component, written hours ago, in time order
+    const many = Array.from({ length: 61 }, (_, i) => hand('owner', { type: 'knowledge', kind: 'lesson', statement: `lesson ${i} for the mn component`, scope: 'component:mn', status: 'accepted', evidence: [] }, (100 - i) * 60000));
+    ticket('ch-01-tidy', 'ch');
+    ticket('ot-01-other', 'ot');
+    ticket('mn-01-many', 'mn');
+    const lesson = ok(old, ['knowledge', 'add', '--kind', 'lesson', '--statement', 'Run the tidy check before pushing', '--scope', 'component:ch', '--owner']).trim();
+    ok(old, ['knowledge', 'add', '--kind', 'lesson', '--statement', 'Tidy checks are slow on Mondays', '--scope', 'component:ch', '--evidence', many[0]], SUP); // a candidate: not given
+
+    // given: the one accepted lesson in its scope, in its prompt and on its act
+    ok(old, ['worker', 'ch-01-tidy'], SUP);
+    const a = startOf('ch-01-tidy');
+    assert.match(a.what, /^made worker ch-01-tidy in /, 'what is as LAUNCH_ACT reads it');
+    assert.deepEqual(a.knowledge, [lesson]);
+    assert.ok(fs.readFileSync(path.join(old, 'docs/devteam/run/prompts/ch-01-tidy.txt'), 'utf8').includes(`(${lesson})`));
+    // none in scope: no field
+    ok(old, ['worker', 'ot-01-other'], SUP);
+    assert.equal('knowledge' in startOf('ot-01-other'), false);
+    assert.ok(!rawLine(startOf('ot-01-other').id).includes('"knowledge"'), 'omitted, not empty');
+    // a resumed session never reads a new prompt: nothing recorded as given
+    ok(old, ['worker', 'ch-01-tidy', '--resume'], SUP);
+    const r = startOf('ch-01-tidy');
+    assert.match(r.what, /^resumed worker ch-01-tidy in /);
+    assert.equal(r.knowledge, undefined);
+    // at most 60, newest first; the line stays under 4,096 bytes
+    ok(old, ['worker', 'mn-01-many'], SUP);
+    const m = startOf('mn-01-many');
+    assert.equal(m.knowledge.length, 60);
+    assert.deepEqual(m.knowledge, many.slice(1).reverse());
+    assert.ok(Buffer.byteLength(rawLine(m.id)) < 4096, `${Buffer.byteLength(rawLine(m.id))} bytes`);
+    // a planner's start too
+    const G = ok(old, ['goal', 'add', '--title', 'Tidy everything', '--outcome', 'nothing untidy', '--measure', 'untidy files', '--target', '0', '--unit', 'files', '--direction', 'down', '--source', 'prod', '--check', 'echo 0', '--non-goals', 'none', '--preconditions', 'a'], SUP).trim();
+    const plan = ok(old, ['knowledge', 'add', '--kind', 'fact', '--statement', 'Plans name their goal', '--scope', 'project', '--owner']).trim();
+    ok(old, ['planner', 'beta', '--goal', G], SUP);
+    assert.deepEqual(startOf('plan-beta').knowledge, [plan]);
+    // the lineage draws a lesson into the start it was given to
+    const L = peek(F, 'act', a.id).lineage;
+    assert.ok(L.edges.some((e) => e.from === lesson && e.to === a.id && e.why === 'given'), JSON.stringify(L.edges));
+  } finally { F.done(); }
+});
+
+const H = 3600000;
+test('orientation debt: an incident fixed and verified owes a lesson or a ruling that there is nothing to keep', () => {
+  const F = fleetFixture('ooda-taught');
+  const { old, ok } = F;
+  const hand = handFor(F);
+  // an incident, its fix decided and resolved ago hours ago, and (verified) the outcome citing it
+  const incident = (n, ago, { outcome = true, owner = false, valence = 1 } = {}) => {
+    const p = hand('supervisor', { type: 'problem', title: `incident ${n}`, severity: 3, realized: true, status: 'open', threatens: [], refs: [], fingerprints: [`web:log:L${n}`], sensor: 'web' }, ago);
+    const d = hand('supervisor', { type: 'decision', class: 'incident-fix', scope: 'sev:high', what: `fix incident ${n}`, authority: 'rung', refs: [p, `fx-0${n}-fix`] }, ago - 1000);
+    hand(owner ? 'owner' : 'supervisor', { type: 'problem', op: 'set', id: p, status: 'resolved' }, ago - 2000);
+    const o = outcome ? hand('supervisor', { type: 'observation', source: 'web', detector: 'sensor', subject: p, kind: 'outcome', detail: `${p} resolved: quiet since the fix`, severity: 0, valence, refs: [d, `fx-0${n}-fix`, p], source_key: `sensor:verified:${p}:abc` }, ago - 3000) : null;
+    return { p, d, o };
+  };
+  const debt = () => json(ok(old, ['dashboard-data'])).ooda.debt.incidents;
+  try {
+    const stale = incident(1, 31 * 24 * H);
+    const taught = incident(2, 50 * H);
+    const ruled = incident(3, 40 * H);
+    const quiet = incident(4, 30 * H, { outcome: false });
+    const owners = incident(5, 20 * H, { owner: true });
+    const unverified = incident(6, 10 * H, { valence: 0 }); // resolved unverified: seen too few times to prove the fix
+    assert.deepEqual(debt().map((x) => x.id), [taught.p, ruled.p], 'verified in the last 30 days, oldest first; not unverified, not one the owner resolved, not one over 30 days ago');
+    const x = debt()[0];
+    assert.equal(x.title, 'incident 2');
+    assert.equal(x.outcome, taught.o);
+    assert.equal(x.decision, taught.d);
+    const said = ok(old, ['orient'], SUP);
+    assert.ok(said.includes(`${taught.p} was fixed and verified (incident 2): what did it teach?`), said);
+    assert.ok(said.includes(`knowledge add --kind lesson --scope 'project' --statement '<what it teaches>' --evidence '${taught.p}' '${taught.d}' '${taught.o}'`), said);
+    assert.ok(said.includes(`decide --class orient-noise --refs '${taught.p}' -- 'nothing to keep'`), said);
+    assert.ok(!said.includes(quiet.p) && !said.includes(owners.p) && !said.includes(stale.p) && !said.includes(unverified.p));
+
+    // a lesson citing it clears it
+    ok(old, ['knowledge', 'add', '--kind', 'lesson', '--scope', 'project', '--statement', 'timeouts need a retry budget', '--evidence', taught.p, taught.d, taught.o], SUP);
+    assert.deepEqual(debt().map((y) => y.id), [ruled.p]);
+    // a noise ruling naming the problem clears it; corrected, it owes again
+    const n = ok(old, ['decide', '--class', 'orient-noise', '--refs', ruled.p, '--', 'nothing to keep'], SUP).trim();
+    assert.deepEqual(debt(), []);
+    assert.equal(ok(old, ['orient'], SUP), 'nothing recurring that is unexplained');
+    ok(old, ['correct', n, '--reason', 'there was a lesson in it']);
+    assert.deepEqual(debt().map((y) => y.id), [ruled.p]);
+    // a lesson the owner retired taught nothing: the incident owes one again
+    const k = json(ok(old, ['knowledge', '--json'])).find((y) => (y.evidence ?? []).includes(taught.p)).id;
+    ok(old, ['knowledge', 'set', k, '--status', 'retired']);
+    assert.deepEqual(debt().map((y) => y.id), [taught.p, ruled.p]);
+    // a noise ruling names an observation or a fixed incident, never an open problem
+    const open = ok(old, ['problem', 'add', '--title', 'slow page', '--severity', '1'], SUP).trim();
+    assert.match(F.run(old, ['decide', '--class', 'orient-noise', '--refs', open, '--', 'x'], SUP).err, /a noise ruling names the observations it explains/);
+  } finally { F.done(); }
+});
+
+test('a hand-written decision citing knowledge that isn\'t accepted only cites it, and its status shows', () => {
+  const F = fleetFixture('ooda-rests-read');
+  const { old, ok } = F;
+  const hand = handFor(F);
+  try {
+    const retired = hand('supervisor', { type: 'knowledge', kind: 'lesson', statement: 'an old idea', scope: 'project', status: 'retired', evidence: [] }, 9 * H);
+    const good = hand('supervisor', { type: 'knowledge', kind: 'lesson', statement: 'a kept idea', scope: 'project', status: 'accepted', evidence: [] }, 8 * H);
+    const d = hand('supervisor', { type: 'decision', class: 'registry-edit', what: 'leave it', authority: 'constitution', refs: [], knowledge: [retired, good] }, 7 * H);
+    const p = json(ok(old, ['peek', 'decision', d, '--json']));
+    const why = (from) => p.lineage.edges.find((e) => e.from === from && e.to === d)?.why;
+    assert.equal(why(retired), 'cites');
+    assert.equal(why(good), 'rests on');
+    assert.equal(p.cited[retired].status, 'retired');
+  } finally { F.done(); }
+});