backpass 0.1.11 → 0.1.13

package/src/fold.js

@@ -12,7 +12,10 @@ import { GAP_SIMILARITY_THRESHOLD, gapSource } from "./gap-ledger.js";
  *     evidence / sessions analyzed. That ratio is what decides memory-file vs skill
  *     placement in section 7.
  *  2. Near-duplicate gaps from different sessions are clustered, so "three sessions
- *     re-derived the db schema" arrives as one item with three quotes.
+ *     re-derived the db schema" arrives as one item with three quotes. Judged identity
+ *     happens upstream (analysis citations and the consolidation pass reshape the
+ *     ledger); the clustering here stays deterministic. Orchestration-domain sightings
+ *     are excluded before clustering and surfaced only as a count.
  *  3. Gap clusters below `minGapEvidence` are dropped. Batch size > 1: one bad session
  *     never rewrites the weights. Sessions are counted across runs, not per run: when the
  *     caller passes `gapObservations` (the pruned gap ledger, `src/gap-ledger.js`) the
@@ -40,6 +43,7 @@ export function foldEvidence(evidenceRecords, { minGapEvidence = 2, memoryFile =
         positive: 0,
         negative: 0,
         sessions: new Set(),
+        harmSessions: new Set(),
         quotes: [],
       });
     }
@@ -55,8 +59,20 @@ export function foldEvidence(evidenceRecords, { minGapEvidence = 2, memoryFile =
       for (const item of record[polarity] || []) {
         const entry = touch(item.instruction);
         entry[polarity] += 1;
-        entry.sessions.add(record.transcript.id);
-        entry.quotes.push({ polarity, text: item.quote, effect: item.effect, moment: item.moment, source });
+        const sessionIdentity = record.transcript.identity || record.transcript.id;
+        entry.sessions.add(sessionIdentity);
+        // `class` is what a negative means (harm vs non-compliance vs irrelevant);
+        // `harmSessions` is what the removal-evidence floor counts. A record from
+        // before the class existed carries none and never counts as harm.
+        if (polarity === "negative" && item.class === "harm") entry.harmSessions.add(sessionIdentity);
+        entry.quotes.push({
+          polarity,
+          text: item.quote,
+          effect: item.effect,
+          moment: item.moment,
+          class: polarity === "negative" ? (item.class ?? null) : undefined,
+          source,
+        });
         if (polarity === "positive") positiveCount += 1;
         else negativeCount += 1;
       }
@@ -69,12 +85,20 @@ export function foldEvidence(evidenceRecords, { minGapEvidence = 2, memoryFile =
         quote: gap.quote,
         recurrenceRisk: gap.recurrenceRisk,
         source,
-        sessionId: record.transcript.id,
+        sessionId: record.transcript.identity || record.transcript.id,
+        domain: gap.domain === "orchestration" ? "orchestration" : "project",
       });
     }
   }
 
-  const gapClusters = clusterGapObservations(gapObservations ?? recordObservations);
+  // Orchestration-domain sightings are mistakes caused not by this repository but by the
+  // external agent harness or tooling that orchestrated the session; they are counted for
+  // legibility but never cluster, so they can never corroborate into a project proposal.
+  const allObservations = gapObservations ?? recordObservations;
+  const projectObservations = allObservations.filter((obs) => obs?.domain !== "orchestration");
+  const orchestrationGapSightings = allObservations.length - projectObservations.length;
+
+  const gapClusters = clusterGapObservations(projectObservations);
 
   // Instructions that exist in the file but drew no evidence at all are the strongest
   // removal / extraction candidates, so they must appear in the summary too.
@@ -89,6 +113,7 @@ export function foldEvidence(evidenceRecords, { minGapEvidence = 2, memoryFile =
         instruction: entry.instruction,
         positive: entry.positive,
         negative: entry.negative,
+        harmSessions: entry.harmSessions.size,
         sessions: entry.sessions.size,
         relevance: analyzedSessions ? entry.sessions.size / analyzedSessions : 0,
         tokens: unit?.tokens ?? null,
@@ -120,6 +145,7 @@ export function foldEvidence(evidenceRecords, { minGapEvidence = 2, memoryFile =
       negative: negativeCount,
       gapClusters: gaps.length,
       droppedGapSingletons,
+      orchestrationGapSightings,
       usedRawTranscript: usedRawCount,
     },
     instructions: instructionRows,
@@ -179,20 +205,35 @@ export function renderEvidenceForPrompt(summary) {
   );
   lines.push("");
   lines.push("### Per-instruction evidence");
+  lines.push(
+    "A negative's class is what it means: `harm` = following the instruction caused damage " +
+      "(evidence against it); `non-compliance` = the agent ignored it (evidence it failed to " +
+      "steer - argues for reinforcement, never deletion); `irrelevant` = no real bearing.",
+  );
   for (const row of summary.instructions) {
     const relevance = `${(row.relevance * 100).toFixed(1)}%`;
     const cost = row.tokens === null ? "" : ` cost=${row.tokens}tok`;
+    const harm = row.negative > 0 ? ` harm-sessions=${row.harmSessions ?? 0}` : "";
     lines.push(
-      `- [${row.instruction}] +${row.positive} -${row.negative} sessions=${row.sessions} relevance=${relevance}${cost}` +
+      `- [${row.instruction}] +${row.positive} -${row.negative}${harm} sessions=${row.sessions} relevance=${relevance}${cost}` +
         (row.known ? "" : " (id not found in current file - stale reference)"),
     );
     for (const quote of row.quotes.slice(0, 3)) {
-      lines.push(`    ${quote.polarity === "negative" ? "-" : "+"} "${oneLine(quote.text)}" (${quote.source})`);
+      const sign = quote.polarity === "negative" ? "-" : "+";
+      const cls = quote.polarity === "negative" ? ` [${quote.class ?? "unclassified"}]` : "";
+      const effect = quote.effect ? ` :: ${oneLine(quote.effect, 200)}` : "";
+      lines.push(`    ${sign}${cls} "${oneLine(quote.text)}"${effect} (${quote.source})`);
     }
   }
 
   lines.push("");
   lines.push("### Gap clusters (mistakes no current instruction covers)");
+  if (summary.totals.orchestrationGapSightings) {
+    lines.push(
+      `- ${summary.totals.orchestrationGapSightings} orchestration-domain sighting(s) caused by the ` +
+        `orchestrating harness or tooling were excluded; they never enter this repository's memory file`,
+    );
+  }
   if (!summary.gaps.length) {
     lines.push("- none above the evidence threshold");
   }
@@ -206,9 +247,9 @@ export function renderEvidenceForPrompt(summary) {
   return lines.join("\n");
 }
 
-function oneLine(text) {
+function oneLine(text, max = 240) {
   const flat = String(text || "")
     .replace(/\s+/g, " ")
     .trim();
-  return flat.length > 240 ? `${flat.slice(0, 240)}...` : flat;
+  return flat.length > max ? `${flat.slice(0, max)}...` : flat;
 }

package/src/gap-ledger.js

@@ -15,10 +15,23 @@ import { sha256 } from "./state.js";
  *
  * Identity and freshness rules:
  *
- *  - A gap's identity is its proposed instruction, matched by the same bigram similarity
- *    the in-run clustering uses (`GAP_SIMILARITY_THRESHOLD`), against the ledger's
- *    canonical phrasing (the shortest seen). The entry id is a hash of the first phrasing
- *    and never changes, so rephrasing does not split an entry.
+ *  - A gap's identity is judged first and matched lexically second. The analysis turn is
+ *    shown the ledger's open entries (`renderOpenGapIndex`) and cites an entry id
+ *    (`matchesGap`) when its gap is one already on the books; a valid citation wins
+ *    outright, because word overlap cannot recognize a paraphrase and the analysis model
+ *    has both sentences in front of it. Without a citation, bigram similarity
+ *    (`GAP_SIMILARITY_THRESHOLD`) against the canonical phrasing (the shortest seen) is
+ *    the fallback. The entry id is a hash of the first phrasing and never changes, so
+ *    rephrasing does not split an entry. Two entries later judged to be one gap are
+ *    merged by the pre-synthesis consolidation pass (`mergeGapEntries`, driven by
+ *    `src/consolidate.js`), which is what lets two same-run parallel sightings - neither
+ *    of which could cite the other - still corroborate.
+ *  - Every observation carries the `domain` the analysis judged: `orchestration` when the
+ *    mistake was not caused by this repository but by an external agent harness or tooling
+ *    that orchestrated the task, `project` for every other mistake.
+ *    Orchestration sightings are recorded for legibility but never counted toward
+ *    corroboration and never surface in a proposal; a missing domain counts as project,
+ *    so evidence from before the field existed keeps its old behavior.
  *  - Sessions are keyed by transcript id (harness + native session id), so re-analyzing
  *    or re-sampling the same session overwrites its observation and never adds a count.
  *  - A gap is a fact about its session: re-analysis that no longer mentions it is model
@@ -61,13 +74,20 @@ export function gapEntryId(memoryPath, proposedInstruction) {
   return sha256(`${memoryPath}\n${normalize(proposedInstruction)}`).slice(0, 16);
 }
 
+function gapEntryById(ledger, id) {
+  const direct = ledger.entries[id];
+  if (direct) return direct;
+  return Object.values(ledger.entries).find((entry) => (entry.aliases || []).includes(id)) || null;
+}
+
 /** The ledger entry a proposed instruction belongs to, or null. */
 export function findGapEntry(ledger, memoryPath, proposedInstruction) {
   let best = null;
   let bestScore = 0;
   for (const entry of Object.values(ledger.entries)) {
     if (entry.memoryPath !== memoryPath) continue;
-    const score = similarity(entry.proposedInstruction, proposedInstruction);
+    const phrasings = [...new Set([entry.proposedInstruction, ...(entry.phrasings || [])])];
+    const score = Math.max(...phrasings.map((phrasing) => similarity(phrasing, proposedInstruction)));
     if (score >= GAP_SIMILARITY_THRESHOLD && score > bestScore) {
       best = entry;
       bestScore = score;
@@ -86,32 +106,56 @@ export function recordGapObservations(ledger, evidenceRecords, { now = new Date(
   for (const record of evidenceRecords) {
     if (!record || record.status !== "ok" || !record.memoryPath) continue;
     const transcript = record.transcript || {};
-    if (!transcript.id) continue;
+    const sessionIdentity = transcript.identity || transcript.id;
+    if (!sessionIdentity) continue;
     for (const gap of record.gaps || []) {
       if (!gap || !gap.proposedInstruction) continue;
-      let entry = findGapEntry(ledger, record.memoryPath, gap.proposedInstruction);
+      // A citation from the analysis turn wins over word overlap: the model saw both
+      // sentences and judged them the same gap. An id that names nothing (stale index,
+      // typo) falls back to the lexical match rather than failing the record.
+      const cited = gap.matchesGap ? gapEntryById(ledger, gap.matchesGap) : null;
+      const deterministicId = gapEntryId(record.memoryPath, gap.proposedInstruction);
+      const deterministic = gapEntryById(ledger, deterministicId);
+      let entry =
+        (cited && cited.memoryPath === record.memoryPath ? cited : null) ||
+        findGapEntry(ledger, record.memoryPath, gap.proposedInstruction) ||
+        (deterministic && deterministic.memoryPath === record.memoryPath ? deterministic : null);
       if (!entry) {
-        const id = gapEntryId(record.memoryPath, gap.proposedInstruction);
-        entry = ledger.entries[id] = {
-          id,
+        entry = ledger.entries[deterministicId] = {
+          id: deterministicId,
           memoryPath: record.memoryPath,
           proposedInstruction: gap.proposedInstruction,
+          phrasings: [gap.proposedInstruction],
           sessions: {},
         };
-      } else if (gap.proposedInstruction.length < entry.proposedInstruction.length) {
-        // Keep the shortest phrasing: it generalizes best (same rule as the in-run fold).
-        entry.proposedInstruction = gap.proposedInstruction;
+      } else {
+        entry.phrasings = [
+          ...new Set([entry.proposedInstruction, ...(entry.phrasings || []), gap.proposedInstruction]),
+        ];
+        if (gap.proposedInstruction.length < entry.proposedInstruction.length) {
+          // Keep the shortest phrasing: it generalizes best (same rule as the in-run fold).
+          entry.proposedInstruction = gap.proposedInstruction;
+        }
       }
-      const prior = entry.sessions[transcript.id];
-      entry.sessions[transcript.id] = {
-        firstObservedAt: prior?.firstObservedAt || observedAt,
+      const identityPrior = entry.sessions[sessionIdentity];
+      const aliasPrior = transcript.id && transcript.id !== sessionIdentity ? entry.sessions[transcript.id] : null;
+      const priors = [identityPrior, aliasPrior].filter(Boolean);
+      const firstObservedAt = priors
+        .map((observation) => observation.firstObservedAt || observation.observedAt)
+        .filter((value) => Number.isFinite(Date.parse(value)))
+        .sort((a, b) => Date.parse(a) - Date.parse(b))[0];
+      if (aliasPrior) delete entry.sessions[transcript.id];
+      entry.sessions[sessionIdentity] = {
+        firstObservedAt: firstObservedAt || observedAt,
         observedAt,
-        sessionStartedAt: transcript.startedAt ?? prior?.sessionStartedAt ?? null,
+        sessionStartedAt:
+          transcript.startedAt ?? identityPrior?.sessionStartedAt ?? aliasPrior?.sessionStartedAt ?? null,
         memoryHash: record.memoryHash || null,
         source: gapSource(transcript),
         mistake: gap.mistake,
         quote: gap.quote,
         recurrenceRisk: gap.recurrenceRisk,
+        domain: gap.domain === "orchestration" ? "orchestration" : "project",
       };
       recorded += 1;
     }
@@ -133,7 +177,7 @@ export function pruneGapLedger(
 
   for (const [id, entry] of Object.entries(ledger.entries)) {
     const applies = memoryPath === null || entry.memoryPath === memoryPath;
-    if (applies && memoryFile && isCovered(memoryFile, entry.proposedInstruction)) {
+    if (applies && memoryFile && isCovered(memoryFile, entry)) {
       stats.covered += Object.keys(entry.sessions).length;
       delete ledger.entries[id];
       continue;
@@ -150,8 +194,11 @@ export function pruneGapLedger(
   return stats;
 }
 
-function isCovered(memoryFile, proposedInstruction) {
-  return (memoryFile.units || []).some((unit) => similarity(unit.text, proposedInstruction) >= GAP_COVERED_THRESHOLD);
+function isCovered(memoryFile, entry) {
+  const phrasings = [...new Set([entry.proposedInstruction, ...(entry.phrasings || [])])];
+  return (memoryFile.units || []).some((unit) =>
+    phrasings.some((phrasing) => similarity(unit.text, phrasing) >= GAP_COVERED_THRESHOLD),
+  );
 }
 
 /** Flatten the ledger into the observation list `foldEvidence` clusters over. */
@@ -167,8 +214,78 @@ export function ledgerGapObservations(ledger, memoryPath) {
         mistake: obs.mistake,
         quote: obs.quote,
         recurrenceRisk: obs.recurrenceRisk,
+        domain: obs.domain === "orchestration" ? "orchestration" : "project",
       });
     }
   }
   return observations;
 }
+
+/**
+ * The ledger's open entries for one memory path, rendered for the analysis prompt so the
+ * model can cite an existing gap instead of coining a paraphrase of it. An accumulator,
+ * not a detector: a gap nobody has reported yet is simply absent, and the analysis
+ * reports it fresh.
+ */
+export function renderOpenGapIndex(ledger, memoryPath, { max = 200 } = {}) {
+  const entries = Object.values(ledger.entries).filter((e) => e.memoryPath === memoryPath);
+  if (!entries.length) return "(none yet)";
+  const lines = entries.slice(0, max).map((e) => `[gap:${e.id}] ${e.proposedInstruction}`);
+  if (entries.length > max) lines.push(`... ${entries.length - max} more`);
+  return lines.join("\n");
+}
+
+/**
+ * Merge groups of ledger entries the consolidation pass judged to be one gap. Each group
+ * keeps the entry with the most sessions (its id stays citable), unions the session maps
+ * without ever double-counting a session (an observation already present keeps its
+ * earliest firstObservedAt), and keeps the shortest phrasing as canonical - the same rule
+ * recording uses. Unknown ids, cross-path groups, and groups that shrink below two known
+ * entries are dropped rather than guessed at. Returns how many entries were absorbed.
+ */
+export function mergeGapEntries(ledger, groups) {
+  let absorbed = 0;
+  const claimed = new Set();
+  for (const group of Array.isArray(groups) ? groups : []) {
+    const ids = [...new Set((Array.isArray(group) ? group : []).map(String))].filter(
+      (id) => ledger.entries[id] && !claimed.has(id),
+    );
+    if (ids.length < 2) continue;
+    const paths = new Set(ids.map((id) => ledger.entries[id].memoryPath));
+    if (paths.size !== 1) continue;
+    for (const id of ids) claimed.add(id);
+
+    const entries = ids.map((id) => ledger.entries[id]);
+    const target = entries.reduce((best, e) =>
+      Object.keys(e.sessions).length > Object.keys(best.sessions).length ? e : best,
+    );
+    for (const entry of entries) {
+      if (entry === target) continue;
+      for (const [sessionId, obs] of Object.entries(entry.sessions)) {
+        const prior = target.sessions[sessionId];
+        if (!prior) {
+          target.sessions[sessionId] = obs;
+        } else {
+          const earlier =
+            Date.parse(obs.firstObservedAt || obs.observedAt) < Date.parse(prior.firstObservedAt || prior.observedAt);
+          if (earlier) prior.firstObservedAt = obs.firstObservedAt || obs.observedAt;
+        }
+      }
+      target.aliases = [...new Set([...(target.aliases || []), entry.id, ...(entry.aliases || [])])];
+      target.phrasings = [
+        ...new Set([
+          target.proposedInstruction,
+          ...(target.phrasings || []),
+          entry.proposedInstruction,
+          ...(entry.phrasings || []),
+        ]),
+      ];
+      if (entry.proposedInstruction.length < target.proposedInstruction.length) {
+        target.proposedInstruction = entry.proposedInstruction;
+      }
+      delete ledger.entries[entry.id];
+      absorbed += 1;
+    }
+  }
+  return absorbed;
+}

package/src/prompts/analysis.md

@@ -10,6 +10,15 @@ Each instruction has a stable id in [brackets]. Refer to instructions ONLY by th
 
 {{INSTRUCTION_INDEX}}
 
+## Gaps already on the books
+
+Earlier sessions reported these gaps; each has a stable id. If a gap you found is the
+same underlying gap as one below - one instruction would prevent both - cite that id in
+`matchesGap` and still describe what you saw. A gap that matches nothing here is new:
+omit `matchesGap`.
+
+{{OPEN_GAPS}}
+
 ## The distilled session trace
 
 Tool calls are one-line summaries and tool output is truncated. The raw transcript path
@@ -26,8 +35,8 @@ Return ONE JSON object and nothing else. No prose before or after, no markdown f
 ```
 {
   "positive":  [{"instruction": "AG-042", "moment": "turn 12", "effect": "what following it achieved", "quote": "verbatim text from the trace"}],
-  "negative":  [{"instruction": "AG-017", "moment": "turn 3",  "effect": "what going against it cost", "quote": "verbatim text from the trace"}],
-  "gaps":      [{"mistake": "what went wrong", "proposedInstruction": "one sentence that would have prevented it", "recurrenceRisk": "high|medium|low", "quote": "verbatim text from the trace"}],
+  "negative":  [{"instruction": "AG-017", "moment": "turn 3",  "effect": "what happened and what it cost", "class": "harm|non-compliance|irrelevant", "quote": "verbatim text from the trace"}],
+  "gaps":      [{"mistake": "what went wrong", "proposedInstruction": "one sentence that would have prevented it", "recurrenceRisk": "high|medium|low", "domain": "project|orchestration", "matchesGap": "<id from the list above, omit when new>", "quote": "verbatim text from the trace"}],
   "usedRawTranscript": false
 }
 ```
@@ -38,11 +47,23 @@ Rules, in order of importance:
    a real quote are discarded downstream, so an unquotable claim is wasted work.
 2. **Negative evidence is the most valuable.** A visible violation, misreading, or
    ignored instruction outranks a dozen "it went fine" observations.
-3. **Do not confabulate influence.** Only call something positive when the trace shows
+3. **`class` states what a negative means, and the difference decides the instruction's
+   fate.** `harm`: the agent FOLLOWED the instruction and following it caused damage or
+   cost - evidence against the instruction itself. `non-compliance`: the agent ignored
+   or violated the instruction - evidence the instruction failed to steer, which argues
+   for reinforcing it, never for deleting it. `irrelevant`: on inspection the moment
+   does not actually bear on this instruction. Never report a skipped rule as `harm`.
+4. **`domain` states what caused a gap.** A gap is `orchestration` when the mistake was
+   not caused by this repository, but by an external agent harness or tooling that
+   orchestrated the task (a task brief, a supervisor's process, the harness itself - by
+   way of illustration only, not a list to match against); every other gap is `project`.
+   Ask the causal question, not which category the wording resembles. Orchestration gaps
+   are counted but never proposed into this repository's memory file.
+5. **Do not confabulate influence.** Only call something positive when the trace shows
    the agent doing the specific thing the instruction asks for. An outcome that would
    have happened anyway is not evidence.
-4. `gaps` are mistakes NOT covered by any current instruction. If an instruction exists
-   and was ignored, that is `negative`, not a gap.
-5. `proposedInstruction` must be one imperative sentence, specific enough to act on and
+6. `gaps` are mistakes NOT covered by any current instruction. If an instruction exists
+   and was ignored, that is `negative` with `class: "non-compliance"`, not a gap.
+7. `proposedInstruction` must be one imperative sentence, specific enough to act on and
    general enough to apply beyond this one session.
-6. An empty array is a valid and useful answer. Report nothing rather than something weak.
+8. An empty array is a valid and useful answer. Report nothing rather than something weak.

package/src/prompts/annotate.md

@@ -39,14 +39,20 @@ Hard rules - a violation fails the whole proposal:
 4. **New instructions need evidence from at least {{MIN_GAP_EVIDENCE}} distinct
    sessions.** `transcripts` is how many distinct sessions back the edit; an edit that
    only adds text is a new instruction whatever its `kind` says.
-5. `kind: "extract"` is an edit whose changes are one or more created `SKILL.md` files
-   plus the change(s) to {{MEMORY_PATH}} that pay for them. One skill per extract is the
-   normal shape. Several skills belong in ONE extract exactly when their removals landed
-   in a **single** measured change: adjacent removals are merged into one change, and a
-   merged change cannot be accepted in halves. If each skill has its own measured change,
-   give each its own extract. Any other kind must not include a created file, and an edit
-   changes one file only.
-6. **Budget:** {{BUDGET_RULE}}
+5. **Removing an instruction outright needs harm evidence from at least
+   {{MIN_GAP_EVIDENCE}} distinct sessions** (`harm-sessions` in the evidence). Only
+   `harm` negatives argue against an instruction; `non-compliance` never justifies a
+   deletion. A change that only deletes text and is not part of an extract is a removal
+   whatever its `kind` says - if it lacks the evidence, revert it in the file first.
+6. `kind: "extract"` is an edit whose changes are one or more created `SKILL.md` files
+   plus the change(s) to {{MEMORY_PATH}} that pay for them. **The skills must carry every
+   line those changes remove** - a deletion is never part of an extract; give it its own
+   `remove` edit. One skill per extract is the normal shape. Several skills belong in ONE
+   extract exactly when their removals landed in a **single** measured change: adjacent
+   removals are merged into one change, and a merged change cannot be accepted in halves.
+   If each skill has its own measured change, give each its own extract. Any other kind
+   must not include a created file, and an edit changes one file only.
+7. **Budget:** {{BUDGET_RULE}}
 
 If you still need to change the files, do that first and then answer; backpass
 re-measures after this reply and shows you the new ids if anything moved. Re-measuring

package/src/prompts/consolidate.md

@@ -0,0 +1,29 @@
+You are consolidating the gap ledger of a backward pass over a repository's agent
+memory file. Each entry below is a mistake some past agent session hit that no current
+instruction covers, phrased as the instruction that would have prevented it. Different
+sessions phrase the same underlying gap differently, and a gap only graduates into a
+proposal once enough DISTINCT sessions have hit it - so paraphrases of one gap must be
+recognized as one entry, or real recurrence stays invisible.
+
+## Open gap entries
+
+{{GAP_ENTRIES}}
+
+## What to return
+
+Return ONE JSON object and nothing else. No prose, no markdown fence.
+
+```
+{"merges": [["<id>", "<id>", ...], ...]}
+```
+
+Each inner array lists two or more entry ids that are the SAME underlying gap. Rules:
+
+1. Merge only when one instruction would prevent every entry in the group - the same
+   mistake, not merely the same topic. Two gaps about the same subsystem that call for
+   different instructions stay separate.
+2. When unsure, do not merge. A wrong merge fabricates corroboration and can write a
+   weakly-supported instruction into the memory file; a missed merge only waits for
+   another sighting.
+3. An id may appear in at most one group. Ids not listed stay untouched.
+4. `{"merges": []}` is a valid and common answer.

package/src/prompts/synthesis.md

@@ -69,12 +69,21 @@ analyzed sessions in which an instruction drew any evidence at all.
    speculative one.
 2. **New instructions need evidence from at least {{MIN_GAP_EVIDENCE}} distinct
    sessions.** One bad session never rewrites the weights.
-3. **Every edit must be backed by at least one verbatim quote** from the evidence. You
+3. **Removing an instruction outright needs harm evidence from at least
+   {{MIN_GAP_EVIDENCE}} distinct sessions** (`harm-sessions` in the evidence rows).
+   Only `harm` negatives - following the instruction caused damage - argue against an
+   instruction. `non-compliance` means it failed to steer: reinforce it, reposition it,
+   or improve its trigger, never delete it for being ignored. Text you delete that does
+   not land in a created skill is a removal, whatever the edit is called.
+4. **An extraction preserves every line it removes** in the SKILL.md it creates. A
+   deletion is never part of an extract: it is its own `remove` edit, decided on its
+   own evidence.
+5. **Every edit must be backed by at least one verbatim quote** from the evidence. You
    will attach the quotes in the next step, so only make changes you can back.
-4. **Budget:** {{BUDGET_RULE}}
-5. Prefer removing a dead instruction over adding a new one. Instructions with high
-   token cost and zero positive evidence across many sessions are the best removals.
-6. Change only `./{{MEMORY_PATH}}` and files under `./{{SKILLS_DIR}}/`. Never delete a
+6. **Budget:** {{BUDGET_RULE}}
+7. You can extract a long, narrow, crisply-triggered section instead of deleting it:
+   extraction frees the same always-loaded tokens and loses nothing.
+8. Change only `./{{MEMORY_PATH}}` and files under `./{{SKILLS_DIR}}/`. Never delete a
    file. Do not create notes, scripts, or scratch files.
 
 ## Where an instruction belongs
@@ -85,7 +94,7 @@ analyzed sessions in which an instruction drew any evidence at all.
 | Conditional / narrow     | **skill** (the description is the condition) | deletion candidate |
 
 A skill's description is always loaded and its body is free until triggered, so moving a
-long, narrow, crisply-triggered section into a skill is nearly pure budget profit.
+section into a skill trades its always-loaded cost for that one description line.
 
 **Skill descriptions are weights too.** If the evidence shows an agent lacked knowledge
 an existing skill already contains, that is a failed trigger: rewrite that skill's

package/src/proposal.js

@@ -1,6 +1,7 @@
 import { renderHunkLines } from "./diff.js";
 import { editSkills } from "./skills.js";
 import { budgetGateKind, budgetStatus, estimateTokens } from "./tokens.js";
+import { normalizeRecoveryLine, recoveredLineCounts } from "./workspace.js";
 
 /**
  * The proposal model: what a synthesis pass is allowed to produce, and the mechanical
@@ -103,6 +104,28 @@ function countSources(evidence) {
   return new Set(evidence.map((e) => e?.source).filter(Boolean)).size;
 }
 
+/** The del-line texts of a hunk that are not carried by `lineCounts` (blank lines ignored). */
+function unrecoveredRemovedLines(hunk, lineCounts) {
+  const missing = [];
+  for (const line of hunk.lines || []) {
+    if (line.type !== "del") continue;
+    const normalized = normalizeRecoveryLine(line.text);
+    if (!normalized) continue;
+    const remaining = lineCounts.get(normalized) || 0;
+    if (remaining > 0) lineCounts.set(normalized, remaining - 1);
+    else missing.push(line.text);
+  }
+  return missing;
+}
+
+/**
+ * The memory units a pure-removal hunk deletes. For a pure removal every file line in
+ * [oldStart, oldEnd] is removed, so this is a plain range intersection with unit lines.
+ */
+function unitsRemovedBy(hunk, memoryFile) {
+  return memoryFile.units.filter((unit) => unit.startLine <= hunk.oldEnd && unit.endLine >= hunk.oldStart);
+}
+
 /** Overlapping count: a run of identical lines must not pass as unique. */
 function occurrences(haystack, needle) {
   if (!needle) return 0;
@@ -308,6 +331,19 @@ export function buildProposal(rawResult, context) {
         violations.push(`edit ${edit.id}: ${unusable.file} needs YAML frontmatter with \`name:\` and \`description:\``);
         continue;
       }
+      // An extraction moves text; it never doubles as a deletion. Every line its hunks
+      // remove must land in the skills it creates - a real deletion goes in its own
+      // remove edit, where the removal-evidence floor below can judge it on its own.
+      const carried = recoveredLineCounts(created.map((c) => c.text));
+      const missing = hunks.flatMap((h) => unrecoveredRemovedLines(h, carried));
+      if (missing.length) {
+        violations.push(
+          `edit ${edit.id} ("${edit.title}") removes text its created skill(s) do not carry ` +
+            `(first: "${missing[0].trim().slice(0, 80)}"); an extraction preserves every line it removes - ` +
+            `revert that text, or make its deletion a separate "remove" edit`,
+        );
+        continue;
+      }
     } else if (created.length) {
       violations.push(`edit ${edit.id}: only kind "extract" may include a created file (${created[0].id})`);
       continue;
@@ -323,6 +359,34 @@ export function buildProposal(rawResult, context) {
       continue;
     }
 
+    // A removal is measured the same way: a hunk that only deletes text, outside an
+    // extraction, deletes instructions - whatever the edit's kind says. Deleting an
+    // instruction needs the same corroboration adding one does, and only negatives the
+    // analysis classified as `harm` (following the rule caused damage) count toward it.
+    // Non-compliance is the rule failing to steer; it never justifies deletion. This is
+    // the removal-evidence floor; the >= 20%-relevance placement table stays guidance.
+    if (edit.kind !== "extract" && files[0] === memoryFile.path) {
+      const rows = new Map((summary?.instructions ?? []).map((row) => [row.instruction, row]));
+      const unsupported = [];
+      for (const hunk of hunks) {
+        if (!hunk.removed || hunk.added) continue;
+        for (const unit of unitsRemovedBy(hunk, memoryFile)) {
+          const harm = rows.get(unit.id)?.harmSessions ?? 0;
+          if (harm < config.minGapEvidence) unsupported.push({ unit, harm });
+        }
+      }
+      if (unsupported.length) {
+        const worst = unsupported[0];
+        violations.push(
+          `edit ${edit.id} ("${edit.title}") deletes [${worst.unit.id}] "${worst.unit.text.slice(0, 80)}" backed by ` +
+            `${worst.harm} session(s) of harm-class negative evidence; removing an instruction needs ` +
+            `${config.minGapEvidence}, and non-compliance never counts - revert the deletion` +
+            (unsupported.length > 1 ? ` (${unsupported.length} unit(s) affected)` : ""),
+        );
+        continue;
+      }
+    }
+
     const file = files[0];
     const proposed = {
       id: edit.id,