pi-longhaul 1.0.4 → 1.1.1

package/CHANGELOG.md

@@ -8,6 +8,44 @@ entries and log event types. Rendered state text, prompt wording and section lay
 
 ## [Unreleased]
 
+## [v1.1.1] - 2026-10-23
+
+### Fixed
+
+- v1.1.0 was tagged but never published: its release stopped before npm because the package's gallery image still
+  named the previous release. v1.1.1 is the first published release with the v1.1.0 changes below (standing rules
+  kept until withdrawn, the `/skill:` text no longer quotable as yours, the summarizer's tighter rule wording).
+
+## [v1.1.0] - 2026-10-23 [not published]
+
+### Changed
+
+- Standing rules no longer retire by count. Only the newest 8 corrections used to stay, so a long session lost its
+  oldest rules, often its most basic ones, while requests mislabeled as rules kept their places. Now only your
+  withdrawal retires a rule. When the state is over its hard cap, after the work log, decisions and dead ends, the
+  oldest rules are shown as an 80-character excerpt that names the message holding them, instead of being dropped.
+  `caps.corrections` in `longhaul.json` now defaults to 0, no limit up to a safety ceiling of 64 that no real
+  session has come near; a number set there still retires the oldest past it. The log's `capFit` reports
+  `condensedCorrections`.
+- The summarizer's answer is bounded at 32 rules, lifts, decisions and dead ends each, and each rule's text in its
+  prompt is cut to `caps.objectiveQuoteChars` with a pointer to the message, so many long rules cannot grow every
+  compaction's prompt.
+- The summarizer is told more precisely what is not a rule: a request for the work at hand however firmly worded
+  ("make sure the banner is blue"), a question, a report of what you did ("I ran the script"), or an idea still
+  under discussion. A rule is what still binds once the work asked for now is done. `longhaul_remember` says the
+  same. When Longhaul takes over a session, an earlier request is not a rule either, even when it says how the
+  result must behave ("add an export button that saves the report as CSV"). Prompt revisions `state-19` and
+  `turns-11`.
+
+### Fixed
+
+- A `/skill:<name>` invocation's text became standing rules: pi expands the skill into the user message, and its
+  rule-like lines ("Never push the tag before the commit") were recorded as the user's, six from one paste. Only the
+  words typed after the skill can be quoted now, whoever proposes the rule, and the summarizer sees such a message
+  as `[/skill:<name>] <your words>` (in turns mode too, with the skill's text behind `show`). A skill whose text
+  carries its own closing tag or a /goal block cannot pass that text off as yours either. A prompt template
+  (`/<name>`) leaves no such mark, so its text still reads as yours: docs/security.md names this limit.
+
 ## [v1.0.4] - 2026-10-22
 
 ### Fixed

package/CONTEXT.md

@@ -66,8 +66,10 @@ The workspace at the moment of compaction: branch, commit, whether the tree is c
 test, build or lint command, open errors, background tasks still running. Newer than anything the model wrote.
 
 **Correction**:
-A standing rule the user gave, kept verbatim with the message it came from. A **Lift** is the user withdrawing
-one; the correction stays visible as history.
+A standing rule the user gave, kept verbatim with the message it came from: one that still binds once the work
+asked for now is done, never a request for that work. Only a **Lift**, the user withdrawing one, retires it, never
+their number (short of a safety ceiling no real session reaches); the correction stays visible as history. A **Condensed** correction is one the hard cap shows as an
+excerpt naming its message. A skill's text is never a correction: it is the skill author's, not the user's.
 _Avoid_: preference, constraint (pi's own summary heading, not this concept)
 
 **Learned values**:

package/README.md

@@ -57,8 +57,9 @@ Longhaul answers each of these:
 
 - **Carried, not rewritten.** The Session state is updated with a diff, so nothing earlier is paraphrased
   again. A standing rule you gave ("never use mocks; fakes only") is kept in your own words, copied from your
-  message by code, until you withdraw it ("the no-mocks rule no longer applies"). A one-time permission ("go
-  ahead and use a mock here") leaves the rule standing.
+  message by code, until you withdraw it ("the no-mocks rule no longer applies"), however many rules you give:
+  by default none is dropped to make room (up to a safety ceiling of 64), and when the state is full the oldest show
+  their opening words and the message that holds them. A one-time permission ("go ahead and use a mock here") leaves the rule standing.
 - **Old reasoning left behind.** The kept window is handed over without the reasoning the state already
   superseded, so the next span starts from the state and recent tool input and output, as a fresh prompt would
   (*Old reasoning in the kept window*).

package/config.example.json

@@ -3,7 +3,7 @@
   "routeProviders": [],
   "localOnlyRoots": [],
   "summarizerHeaders": {},
-  "caps": { "hardChars": 13500, "objectiveQuoteChars": 600, "corrections": 8, "correctionChars": 300, "decisions": 10, "deadEnds": 10, "itemChars": 300, "workLogLines": 12, "openErrors": 5, "worldChars": 1200, "filesChars": 2500, "learnedChars": 1500 },
+  "caps": { "hardChars": 13500, "objectiveQuoteChars": 600, "corrections": 0, "correctionChars": 300, "decisions": 10, "deadEnds": 10, "itemChars": 300, "workLogLines": 12, "openErrors": 5, "worldChars": 1200, "filesChars": 2500, "learnedChars": 1500 },
   "claimPatterns": [
     { "pattern": "npm test", "kind": "test" }, { "pattern": "node --test", "kind": "test" }, { "pattern": "go test", "kind": "test" },
     { "pattern": "pytest", "kind": "test" }, { "pattern": "cargo test", "kind": "test" }, { "pattern": "make test", "kind": "test" },

package/docs/how-it-works.md

@@ -41,6 +41,9 @@ When pi is about to compact and Longhaul is selected (`PI_COMPACTOR` unset, empt
    - every quoted correction must be a verbatim substring of a user message (a quote cited under the wrong
      message binds to the newest message that does hold it; text no user wrote is rejected);
    - in a pi-goal `/goal` message only the objective inside the goal tags is quotable, never pi-goal's template;
+   - in a `/skill:<name>` message only the words typed after the skill are quotable, never the skill's text pi
+     expanded into the message (a pasted skill once became six rules); the message list shows it as
+     `[/skill:<name>] <your words>`;
    - an evidence id the ledger does not know is dropped, and the decision or dead end it backed is kept;
    - shape slips that say nothing about content (`null` for an absent optional, an omitted empty list) are
      normalized before the schema check, and every list and item is bounded by the schema.
@@ -154,7 +157,7 @@ messages in the log; `PI_COMPACT_STATE_DEBUG_STACK=1` adds stack traces.
 | `event` | when | says |
 |---|---|---|
 | `extension-loaded` | pi loads Longhaul (at startup and on a reload) | `piVersion`, `piVersionVerified` (`true` for an exact verified version, `"line"` for a verified release line, `false`) |
-| `compaction` | a pass finished | `span`, `tokensBefore`, `summaryChars`, `narrative` (kind, calls, accepted, dropped, usage, timings, and `reasoning`: the level asked for when the model cannot turn reasoning off), `route`, `capFit`, `world`, `carried`, `durationMs` |
+| `compaction` | a pass finished | `span`, `tokensBefore`, `summaryChars`, `narrative` (kind, calls, accepted, dropped, usage, timings, and `reasoning`: the level asked for when the model cannot turn reasoning off), `route`, `capFit` (the work-log lines, decisions and dead ends retired to fit the hard cap, and `condensedCorrections`), `world`, `carried`, `durationMs` |
 | `compacted` | pi wrote the compaction entry | `fromExtension` (was the summary Longhaul's?), `reason`, `span`, `summaryChars`, `tokensBefore` |
 | `compact-failed` | pi reported the compaction failed | `reason`, `span` |
 | `kept-window-strip` | old reasoning was first left out of a new kept window | `cutoff`, `strippedBlocks`, `strippedChars`, `contextMessages` |

package/docs/security.md

@@ -59,6 +59,17 @@ the session (a web page, a README, another agent's message) could try to plant a
 - A `/goal` objective counts only when the message has pi-goal's exact template **and** pi-goal recorded that
   goal in its own custom entry: text that reaches pi as a user message can copy the template, but only
   extension code writes a custom entry. A stopped goal is cleared.
+- In a message that opens with pi's `/skill:` expansion (`<skill name=… location=…>…</skill>`), only the words
+  after the block are quotable: the block is the skill author's text, not the user's. pi does not escape a skill's
+  text, so the block ends at the LAST closing tag followed by a blank line or the end of the message (pi's own parse
+  takes the first): a skill that carries its own closing tag cannot pass part of its text off as the user's words.
+  The skill is found before a /goal block, and the goal test reads only the user's words, so a skill that shows a
+  goal block never names the objective. Text that copies the block's shape only hides its own words from being
+  quoted, which fails safe (a rule is missed, never planted). The block is found by a loop over its closing tags,
+  linear in the message, never by a backtracking pattern.
+- Known limit: a pi prompt template (`/<name> args`) replaces the user message with the template's text and
+  leaves no mark in the transcript, so its rule-like lines can be quoted as the user's. Installing and invoking a
+  template is the user's choice, and a package that ships one can already run code as an extension.
 - The line under the state's title scopes "newer wins" to progress (Now, World, Work log). Standing rules stay
   until a user message withdraws one, and text in tool results or relayed from other agents is named as data.
 - Every rendered field is one line: no id, reference, evidence tag or narrative can carry a line break into
@@ -314,7 +325,14 @@ A transcript or a model answer can be arbitrarily long, and a compaction runs in
 - Reading the state back never spreads a transcript's entries into a function call (`Math.max(...)`,
   `push(...)`), whose arguments live on the stack: a branch with hundreds of thousands of events folds.
 - The rendered state has a hard cap (`caps.hardChars`) and every section its own; the background-task line is
-  bounded on its own because it renders after World's fitted lines.
+  bounded on its own because it renders after World's fitted lines. Corrections are the exception by design: none
+  is retired to fit (an old rule binds as much as a new one), so once the work log, decisions and dead ends are
+  gone they are condensed, oldest first, to an 80-character excerpt naming the message. Only a state with more rules
+  than condensed lines fit stays over the cap (`capExhausted` in the log). Rules are bounded elsewhere: one message
+  can yield several (distinct passages of one long paste each count), so with no count cap set a state keeps at most
+  64 (`CORRECTIONS_CEILING`), the oldest past it retiring and still recallable from the transcript, which no real
+  session has come near (the most seen was 22). One answer carries at most 32 rules, lifts, decisions or dead ends,
+  and each rule's text in the summarizer prompt is cut to `caps.objectiveQuoteChars`, naming its recall.
 - `longhaul_recall` answers are capped at 4,000 characters and output pages at 8,000.
 - The narrative call is bounded in count (`maxChunks` × (3 + `fixableRetries`): one more call per chunk, only when the
   last answer is first refused because a lift aimed at a rule that was replaced, and one replacement question per

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-longhaul",
-  "version": "1.0.4",
+  "version": "1.1.1",
   "description": "Keep pi sessions working all night. A compactor that carries your session forward instead of rewriting it: your rules kept in your own words, the state written by code, old reasoning left behind, and about 5x faster than pi's own compaction on a local model.",
   "type": "module",
   "license": "MIT",
@@ -32,7 +32,7 @@
     "extensions": [
       "./src/index.ts"
     ],
-    "image": "https://raw.githubusercontent.com/lobo235/pi-longhaul/v1.0.4/.github/assets/infographic.png"
+    "image": "https://raw.githubusercontent.com/lobo235/pi-longhaul/v1.1.1/.github/assets/infographic.png"
   },
   "files": [
     "src/**/*.ts",

package/src/config.ts

@@ -69,7 +69,7 @@ export function readConfigFile(agentDir: string = getAgentDir()): string | undef
   }
 }
 
-const CAP_FLOORS: Record<keyof Caps, number> = { hardChars: 2000, objectiveQuoteChars: 40, corrections: 1, correctionChars: 40, decisions: 1, deadEnds: 1, itemChars: 40, workLogLines: 1, openErrors: 0, worldChars: 200, filesChars: 0, learnedChars: 0 };
+const CAP_FLOORS: Record<keyof Caps, number> = { hardChars: 2000, objectiveQuoteChars: 40, corrections: 0, correctionChars: 40, decisions: 1, deadEnds: 1, itemChars: 40, workLogLines: 1, openErrors: 0, worldChars: 200, filesChars: 0, learnedChars: 0 };
 const CLAIM_KINDS: ReadonlySet<string> = new Set<ClaimKind>(["test", "build", "lint", "custom"]);
 
 function parseObject(raw: string | undefined): Record<string, unknown> {

package/src/intent.ts

@@ -117,9 +117,39 @@ export function activeGoalId(branchEntries: SessionEntry[]): string | undefined
   return goal.status === undefined || goal.status === "active" ? goal.id : undefined;
 }
 
-/** The part of a user message a quote may bind to: the objective of a /goal-mode message, else all of it. */
+/** The head of pi's `/skill:` expansion (agent-session.ts `parseSkillBlock`): the block opens the message. */
+const SKILL_HEAD_RE = /^<skill name="([^"]+)" location="[^"]+">\n/;
+const SKILL_CLOSE = "\n</skill>";
+
+/**
+ * A skill invocation's name and the words the user typed after it ("" when none), or undefined when the message is
+ * not one. pi expands `/skill:<name> words` into the skill's text in a `<skill>` block, then the words after a blank
+ * line; the block is the skill author's text, so a rule in it is never the user's (a pasted skill once became six
+ * rules). The block ends at the LAST closing tag after which nothing, or a blank line and the words, follows: pi does
+ * not escape a skill's text, so text that carries its own closing tag must not pass for the user's words (pi's own
+ * parse takes the first; here the user's words that copy the tag lose words, the skill's text never gains any). A loop
+ * over closing tags rather than pi's lazy pattern, so a long message is read once, never backtracked.
+ */
+export function skillInvocationOf(text: string): { name: string; words: string } | undefined {
+  const head = SKILL_HEAD_RE.exec(text);
+  if (!head) return undefined;
+  let words: string | undefined;
+  for (let at = text.indexOf(SKILL_CLOSE); at >= 0; at = text.indexOf(SKILL_CLOSE, at + 1)) {
+    const end = at + SKILL_CLOSE.length;
+    if (end === text.length) words = "";
+    else if (text.startsWith("\n\n", end) && text.length > end + 2) words = text.slice(end + 2).trim();
+  }
+  return words === undefined ? undefined : { name: head[1], words };
+}
+
+/**
+ * The part of a user message a quote may bind to: the user's own words after a skill's text, then the objective of a
+ * /goal-mode message, else all of it. The skill comes first, so a skill's text that shows a /goal block never names
+ * the objective.
+ */
 export function quotableText(text: string): string {
-  return goalObjectiveOf(text) ?? text;
+  const own = skillInvocationOf(text)?.words ?? text;
+  return goalObjectiveOf(own) ?? own;
 }
 
 /** Words that make a user message read as a standing rule. A pointer for the model, never a verdict: quotes are still verified. */

package/src/narrative/message-labels.ts

@@ -43,7 +43,16 @@ function objectTargets(value: unknown): string[] | undefined {
 }
 
 /** What a rule is, as both modes' prompts say it. */
-export const RULE_DEFINITION = `A rule is a standing instruction that should keep holding for the rest of the session, however it is worded: a convention, a constraint, a fact about where the code must run. A message that asks for work and also sets a constraint that must keep holding after that work is done is a rule too ("add an error handler; the API must never return a stack trace"). A description of what is being built (its options, defaults, limits, file names, messages, exit codes) is not a rule, though later changes must keep it working: the code and its tests keep it. Label such a requirement a rule only when the user states it as standing over later work ("every dry-run line must start with DRY:", "never ...", "always ...", "from now on ..."). Code keeps a message of at most ${RULE_SHOWN_WHOLE_CHARS} characters whole; for a longer one, give the constraint's exact words as {"u<n>": {"rule": "<exact words>"}}, words that make sense on their own.`;
+export const RULE_DEFINITION = `A rule is a standing instruction that should keep holding for the rest of the session, however it is worded: a convention, a constraint, a fact about where the code must run. The test is whether it still binds once the work asked for now is done. A message that asks for work and also sets a constraint that must keep holding after that work is done is a rule too ("add an error handler; the API must never return a stack trace"). A description of what is being built (its options, defaults, limits, file names, messages, exit codes) is not a rule, though later changes must keep it working: the code and its tests keep it. Label such a requirement a rule only when the user states it as standing over later work ("every dry-run line must start with DRY:", "never ...", "always ...", "from now on ..."). Code keeps a message of at most ${RULE_SHOWN_WHOLE_CHARS} characters whole; for a longer one, give the constraint's exact words as {"u<n>": {"rule": "<exact words>"}}, words that make sense on their own.`;
+
+/**
+ * What is not a rule, as both modes' prompts say it: the classes that filled rule slots on real sessions (a request for
+ * the work at hand worded firmly, a question, a report of what the user did, an idea under discussion).
+ */
+/** For a switchover's earlier messages: a feature asked for back then says how it must behave, which is no standing rule. */
+export const EARLIER_REQUEST = 'An earlier request is the work asked for then, even when it says how the result must behave ("add an export button that saves the report as CSV", "make the import skip blank rows"): label it "not a rule"; a rule among them says what must hold for all later work too.';
+
+export const NOT_A_RULE = '"not a rule" is everything else: a request for the work at hand, however firmly it is worded ("make sure the banner is blue", "be sure to mention the fix in the PR"); a question; an answer, an approval, or a report of what the user did or saw ("I ran the script", "it works now"); an idea or plan still under discussion ("I was thinking we could cache it"); a one-off.';
 
 /** What a lift is, as both modes' prompts say it: a narrowed rule replaces the old one, so the part that still holds stays. */
 export const LIFT_GUIDANCE = '"lifts" withdraws a standing rule. A message that only withdraws a rule is "lifts R<n>", even when it says what is fine instead ("the no-semicolons rule is lifted; either style is fine now"): what is fine is not a new rule, and how to carry out the withdrawal ("keep the existing tests passing") is not a new rule either. Use "rule and lifts R<n>" only when the message puts a new standing rule in the old one\'s place: it replaces the rule, or narrows it ("the type hint rule is lifted for test files; keep it for the package itself"), and the whole message then stands as the new rule; words that need the rest of the message to make sense ("keep it for ...") are not the rule. Use "lifts R<n>" alone only when the rule no longer holds anywhere. A new rule that cannot hold together with a rule in the state replaces it, even when it does not say so ("switch to two-space indentation" beside "use tabs"): label it "rule and lifts R<n>", and name every rule it replaces, a narrowing of it included ("rule and lifts R1, R6"). A permission for one occasion ("go ahead and push it this time") is not a lift: the rule still stands.';

package/src/narrative/prepare.ts

@@ -6,7 +6,7 @@
  */
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
 
-import { EXCERPT_CHARS, goalObjectiveOf, normalizeWs, type IndexedUserMessage, type MessageIndex } from "../intent.ts";
+import { EXCERPT_CHARS, goalObjectiveOf, normalizeWs, skillInvocationOf, type IndexedUserMessage, type MessageIndex } from "../intent.ts";
 import { closedWhole } from "../store/events.ts";
 
 /**
@@ -61,9 +61,20 @@ function prefixed(message: AgentMessage, ordinal: string): AgentMessage {
   return { ...message, content } as AgentMessage;
 }
 
+/** How a skill invocation is named wherever the summarizer is shown it: the skill's text is not the user's. */
+export const skillTag = (name: string): string => `[/skill:${normalizeWs(name).slice(0, 40)}]`;
+
+/** What the message list shows: a /goal by its objective, a skill invocation by its name and the user's own words. */
+export function listedExcerpt(text: string): string {
+  const skill = skillInvocationOf(text);
+  const goal = goalObjectiveOf(skill?.words ?? text);
+  if (goal) return `[/goal] ${normalizeWs(goal)}`.slice(0, EXCERPT_CHARS + 8);
+  if (skill) return `${skillTag(skill.name)} ${skill.words ? spanExcerpt(skill.words) : "(no words of the user's own)"}`;
+  return spanExcerpt(text);
+}
+
 function ordinalEntry(indexed: IndexedUserMessage): SpanInput["ordinals"][number] {
-  const goal = goalObjectiveOf(indexed.text);
-  return { ordinal: indexed.ordinal, excerpt: goal ? `[/goal] ${normalizeWs(goal)}`.slice(0, EXCERPT_CHARS + 8) : spanExcerpt(indexed.text), text: indexed.text };
+  return { ordinal: indexed.ordinal, excerpt: listedExcerpt(indexed.text), text: indexed.text };
 }
 
 export function prepareSpan(input: { messagesToSummarize: AgentMessage[]; turnPrefixMessages: AgentMessage[]; index: MessageIndex }): SpanInput {

package/src/narrative/prompt.ts

@@ -12,7 +12,7 @@ import { quoteText } from "../render.ts";
 import { DEFAULT_CAPS, type Now, type Quote, type StateEvent } from "../store/events.ts";
 import { activeCorrections, activeDeadEnds, activeDecisions, GOAL_SOURCE_LABEL, goalLine, type GoalSource, type SessionState } from "../store/project.ts";
 import { fitFirstChunk } from "./fit.ts";
-import { LABEL_FORMS, LIFT_GUIDANCE, RULE_DEFINITION, RULE_WHOLE_CHARS } from "./message-labels.ts";
+import { EARLIER_REQUEST, LABEL_FORMS, LIFT_GUIDANCE, NOT_A_RULE, RULE_DEFINITION, RULE_WHOLE_CHARS } from "./message-labels.ts";
 
 /**
  * state-2: the switchover seed (previous summary + the user's earlier rule-shaped messages) and /goal excerpts in the user-message index.
@@ -35,8 +35,11 @@ import { LABEL_FORMS, LIFT_GUIDANCE, RULE_DEFINITION, RULE_WHOLE_CHARS } from ".
  *   (the seed floor now records "from now on" replacements, which "they need no label" left lifting nothing).
  * state-16: outside a /goal, the session's opening request is the goal line once the Request has moved from it
  *   (store/project.ts goalLine), so the project's purpose survives every compaction; never quoted as the objective.
+ * state-18: a rule is what still binds once the work asked for now is done; "not a rule" names the kinds that filled
+ *   rule slots on real sessions (a firm request for the task at hand, a question, a report, an idea under discussion).
+ * state-19: at a switchover, an earlier request is not a rule even when it says how the result must behave.
  */
-export const NARRATIVE_PROMPT_REVISION = "state-17";
+export const NARRATIVE_PROMPT_REVISION = "state-19";
 
 export const NARRATIVE_SYSTEM_PROMPT = `You maintain the SESSION STATE of a coding session that is being compacted. You are given the state so far, the user's messages with their ordinals (u1, u2, ...), and the conversation being compacted. Answer with ONE fenced json block and nothing else:
 
@@ -53,7 +56,7 @@ export const NARRATIVE_SYSTEM_PROMPT = `You maintain the SESSION STATE of a codi
 }
 \`\`\`
 
-Rules. "objective" is the request the work is answering now. It is optional: include it only when none is set or the user moved to a different request in this span, and quote the user's own message verbatim. The goal line, when present, is the active /goal or the session's opening request: code keeps it, so never quote it as the objective; under a goal the objective is the specific ask. "labels": Label EVERY message in <user-messages> with one of ${LABEL_FORMS}. ${RULE_DEFINITION} ${LIFT_GUIDANCE} The target is R<n> from the state, or u<n> for a rule given earlier in this span. "not a rule" is a request, question, answer, approval or one-off. Code copies the user's words into the state, so a short message labeled a rule needs no quote; a message longer than ${RULE_WHOLE_CHARS} characters labeled a rule must come with the rule's exact words: {"u7": {"rule": "<exact words>"}}. "corrections" is only for a standing rule that an earlier summary records and no listed message gives; quote the user's exact words. "values": values a later turn may need again that no file will give back: a measurement, a total, a port or a count a turn reported, a hash it named, a file-name format the user chose ("<name>-YYYYMMDD.tar.gz"). Copy each exactly as it appears in the turn "ref" names (the user's message, your replies and the tool output up to the next user message); a value is a number with or without its unit ("166 ms"), a version, a short commit hash, a path or file name (with <placeholders> if the format has them), a host:port or a date; nothing else is kept. "name" is a short label (at most 40 characters, no colon) saying what it is. At most 12, never a password, key or token. "decisions" and "deadEnds" are your own one-sentence records with evidence: a command id C<n>, an error id E<n>, a message u<n>, or the words "last command" / "last error". "now" replaces the previous Now entirely. Never write "done" unless the state's Done gate line says met. ${CREDENTIAL_RULE} Empty arrays are fine. No prose outside the fence.`;
+Rules. "objective" is the request the work is answering now. It is optional: include it only when none is set or the user moved to a different request in this span, and quote the user's own message verbatim. The goal line, when present, is the active /goal or the session's opening request: code keeps it, so never quote it as the objective; under a goal the objective is the specific ask. "labels": Label EVERY message in <user-messages> with one of ${LABEL_FORMS}. ${RULE_DEFINITION} ${LIFT_GUIDANCE} The target is R<n> from the state, or u<n> for a rule given earlier in this span. ${NOT_A_RULE} Code copies the user's words into the state, so a short message labeled a rule needs no quote; a message longer than ${RULE_WHOLE_CHARS} characters labeled a rule must come with the rule's exact words: {"u7": {"rule": "<exact words>"}}. "corrections" is only for a standing rule that an earlier summary records and no listed message gives; quote the user's exact words. "values": values a later turn may need again that no file will give back: a measurement, a total, a port or a count a turn reported, a hash it named, a file-name format the user chose ("<name>-YYYYMMDD.tar.gz"). Copy each exactly as it appears in the turn "ref" names (the user's message, your replies and the tool output up to the next user message); a value is a number with or without its unit ("166 ms"), a version, a short commit hash, a path or file name (with <placeholders> if the format has them), a host:port or a date; nothing else is kept. "name" is a short label (at most 40 characters, no colon) saying what it is. At most 12, never a password, key or token. "decisions" and "deadEnds" are your own one-sentence records with evidence: a command id C<n>, an error id E<n>, a message u<n>, or the words "last command" / "last error". "now" replaces the previous Now entirely. Never write "done" unless the state's Done gate line says met. ${CREDENTIAL_RULE} Empty arrays are fine. No prose outside the fence.`;
 
 export interface PromptState {
   /** The Goal line (store/project.ts goalLine), shown so the summarizer never re-picks it as the Request. */
@@ -89,7 +92,7 @@ export function seedOf(previousSummary: string | undefined): string | undefined
 
 const SEED_RULES_GUIDANCE = 'The user\'s own earlier messages that read like standing rules, verbatim, with their ordinals. Each one is recorded as corrections automatically, word for word: do not copy them into "corrections", and they need no label unless one replaces or withdraws an earlier rule: label that one "rule and lifts u<n>" or "lifts u<n>". List the ordinal of any that was a one-off request, an answer or a question rather than a rule still in force in a top-level "oneOffs" array, e.g. "oneOffs": ["u3"]; list none when all of them still hold. A rule a later message withdrew or replaced is not in force either: label that later message "lifts u<n>" (or "rule and lifts u<n>"), whether it is listed here or among the other messages.';
 
-const SEED_CONTEXT_GUIDANCE = 'The user\'s other earlier messages, each cut to its start. A later message may withdraw or replace an earlier rule: label it "lifts u<n>" (or "rule and lifts u<n>") with the earlier rule\'s ordinal, and that rule is not carried. Label every one of these too: "rule" when it is a standing rule still in force, however it is worded ("tests go under tests/", "our servers run Node 22"), "not a rule" otherwise.';
+const SEED_CONTEXT_GUIDANCE = `The user's other earlier messages, each cut to its start. A later message may withdraw or replace an earlier rule: label it "lifts u<n>" (or "rule and lifts u<n>") with the earlier rule\'s ordinal, and that rule is not carried. Label every one of these too: "rule" when it is a standing rule still in force, however it is worded ("tests go under tests/", "our servers run Node 22"), "not a rule" otherwise. ${EARLIER_REQUEST}`;
 
 export const SEED_CONTEXT_EXCERPT_CHARS = 240;
 
@@ -136,7 +139,7 @@ export function promptStateOf(state: SessionState, remembered: StateEvent[], quo
   return {
     ...goalOf(state, quoteChars),
     objective: state.objective ? { ...cut(state.objective.quote), doneWhen: state.objective.doneWhen ? cut(state.objective.doneWhen) : undefined } : undefined,
-    corrections: activeCorrections(state).map((item) => ({ id: item.id, ordinal: item.quote.ordinal, text: item.quote.text, lifted: item.liftedBy?.ordinal })),
+    corrections: activeCorrections(state).map((item) => ({ id: item.id, ordinal: item.quote.ordinal, text: quoteText(item.quote, quoteChars), lifted: item.liftedBy?.ordinal })),
     decisions: activeDecisions(state).map((item) => ({ id: item.id, text: item.text })),
     deadEnds: activeDeadEnds(state).map((item) => ({ id: item.id, text: item.text })),
     now: state.now ? { inProgress: state.now.inProgress, next: state.now.next, blocked: state.now.blocked, resume: state.now.resume } : undefined,

package/src/narrative/turns/conversation.ts

@@ -17,7 +17,7 @@ import type { CallTrace } from "../types.ts";
 import { callUsageOf } from "../usage.ts";
 
 /** Recorded as the span's promptRevision in turns mode, as NARRATIVE_PROMPT_REVISION is for the single call. */
-export const TURNS_PROMPT_REVISION = "turns-9";
+export const TURNS_PROMPT_REVISION = "turns-11";
 
 export const TURNS_SYSTEM_PROMPT = `You maintain the SESSION STATE of a coding session that is being compacted. The first message holds the digest of the span: the state so far, the user's messages, the commands and errors (with ids), the files, the workspace and a condensed transcript. Code asks for one section at a time. Answer each with ONE JSON object and nothing else. Use only ids that appear in the digest. Call show(ref) to read a user message (u<n>), command (C<n>), error (E<n>) or tool output (T<n>) in full when the digest cut it. ${CREDENTIAL_RULE}`;
 

package/src/narrative/turns/digest.ts

@@ -1,14 +1,17 @@
 /**
  * The Digest (CONTEXT.md *Digest*): what code knows about the span, built once and sent whole at the
  * start of the turn conversation -- the state so far, on a switchover the previous summary and the
- * user's earlier rule-shaped messages, the span's user messages verbatim with ordinals, the ledger's
- * commands and errors with outcomes, the file lists, World, and the condensed transcript. `show(ref)`
- * answers the one read-only tool: a user message, command or error record, or a whole tool output.
+ * user's earlier rule-shaped messages, the span's user messages verbatim with ordinals (a skill
+ * invocation by its name and the user's own words), the ledger's commands and errors with outcomes,
+ * the file lists, World, and the condensed transcript. `show(ref)` answers the one read-only tool: a
+ * user message, command or error record, or a whole tool output.
  */
 import { renderCommandLine, renderErrorLine } from "../../ledger/handoff-render.ts";
 import type { CommandRecord, ErrorRecord } from "../../ledger/handoff.ts";
 import type { FileLists } from "../../carry.ts";
 import { renderFilesSection } from "../../files-render.ts";
+import { skillInvocationOf } from "../../intent.ts";
+import { skillTag } from "../prepare.ts";
 import { stateBlock, type PromptState } from "../prompt.ts";
 import type { CondensedTranscript } from "./transcript.ts";
 
@@ -36,10 +39,14 @@ export const USER_MESSAGE_CAP = { head: 3000, tail: 1000 };
 /** One show() answer, at most. */
 export const SHOW_CHARS = 8000;
 
+/** A skill invocation is shown by its name and the user's own words; the skill's text is behind show(uN). */
 function userMessageLine(message: { ordinal: string; text: string }): string {
+  const skill = skillInvocationOf(message.text);
+  const text = skill ? `${skillTag(skill.name)} ${skill.words || "(no words of the user's own)"}` : message.text;
+  const pointer = skill ? `\n[the skill's text: show ${message.ordinal}]` : "";
   const { head, tail } = USER_MESSAGE_CAP;
-  if (message.text.length <= head + tail) return `[${message.ordinal}] ${message.text}`;
-  return `[${message.ordinal}] ${message.text.slice(0, head)}\n[… ${message.text.length - head - tail} chars, show ${message.ordinal} …]\n${message.text.slice(-tail)}`;
+  if (text.length <= head + tail) return `[${message.ordinal}] ${text}${pointer}`;
+  return `[${message.ordinal}] ${text.slice(0, head)}\n[… ${text.length - head - tail} chars, show ${message.ordinal} …]\n${text.slice(-tail)}${pointer}`;
 }
 
 const block = (tag: string, lines: string[], empty = "(none)") => `<${tag}>\n${lines.length ? lines.join("\n") : empty}\n</${tag}>`;

package/src/narrative/turns/labels.ts

@@ -8,8 +8,8 @@
  * forced label per earlier message made "not a rule" the cheap answer and dropped half the earlier
  * rules in a replay; opt-out keeps the default safe.
  */
-import { SPAN_EXCERPT_CHARS, spanExcerpt as excerpt } from "../prepare.ts";
-import { LABEL_FORMS, LIFT_GUIDANCE, labelProposals, RULE_DEFINITION, ruleLabelProblem, readLabels, RULE_WHOLE_CHARS, type Label } from "../message-labels.ts";
+import { listedExcerpt, SPAN_EXCERPT_CHARS, spanExcerpt as excerpt } from "../prepare.ts";
+import { EARLIER_REQUEST, LABEL_FORMS, LIFT_GUIDANCE, labelProposals, NOT_A_RULE, RULE_DEFINITION, ruleLabelProblem, readLabels, RULE_WHOLE_CHARS, type Label } from "../message-labels.ts";
 import type { Proposal } from "../../store/verify.ts";
 import type { Complaint, Facts, Parsed, Section } from "./section.ts";
 
@@ -22,19 +22,19 @@ export { RULE_WHOLE_CHARS };
 const shownOf = (facts: Facts) => (ordinal: string): number | undefined => (facts.contextOrdinals?.includes(ordinal) ? SPAN_EXCERPT_CHARS : undefined);
 
 function instruction(facts: Facts): string {
-  const span = facts.spanOrdinals.map((ordinal) => `${ordinal}: ${excerpt(facts.textOf(ordinal) ?? "")}`);
-  const seed = facts.seedOrdinals.map((ordinal) => `${ordinal}: ${excerpt(facts.textOf(ordinal) ?? "")}`);
-  const context = (facts.contextOrdinals ?? []).map((ordinal) => `${ordinal}: ${excerpt(facts.textOf(ordinal) ?? "")}`);
+  const span = facts.spanOrdinals.map((ordinal) => `${ordinal}: ${listedExcerpt(facts.textOf(ordinal) ?? "")}`);
+  const seed = facts.seedOrdinals.map((ordinal) => `${ordinal}: ${listedExcerpt(facts.textOf(ordinal) ?? "")}`);
+  const context = (facts.contextOrdinals ?? []).map((ordinal) => `${ordinal}: ${listedExcerpt(facts.textOf(ordinal) ?? "")}`);
   const rules = facts.activeCorrections.map((rule) => `${rule.id} [${rule.ordinal}] ${excerpt(rule.text)}`);
   return [
     "Section 3 of 5: the user's messages. Label EVERY message listed under Messages in this span with one of:",
-    `${LABEL_FORMS}. ${RULE_DEFINITION} ${LIFT_GUIDANCE} "not a rule" is a request, question, answer, approval or one-off.`,
+    `${LABEL_FORMS}. ${RULE_DEFINITION} ${LIFT_GUIDANCE} ${NOT_A_RULE}`,
     `Code copies the user's words. A message longer than ${RULE_WHOLE_CHARS} characters that you label a rule must come with the rule's exact words instead of "rule": {"u7": {"rule": "<the user's exact words>"}}.`,
     'Answer: {"labels": {"u3": "not a rule", "u4": "rule", "u5": "lifts R1"}}',
     `Standing rules already recorded:\n${rules.length ? rules.join("\n") : "(none)"}`,
     `Messages in this span:\n${span.length ? span.join("\n") : "(none)"}`,
     ...(seed.length ? [`Earlier messages that read like standing rules. Each one is kept as a rule automatically; do not label them. Only if one was a one-off request, an answer or a question rather than a rule still in force, list its id in a top-level "oneOffs" array, e.g. "oneOffs": ["u3"]; list none when all of them still hold:\n${seed.join("\n")}`] : []),
-    ...(context.length ? [`The user's other earlier messages, each cut to its start. Label every one of these too: "rule" when it is a standing rule still in force, however it is worded ("tests go under tests/", "our servers run Node 22"), "not a rule" otherwise:\n${context.join("\n")}`] : []),
+    ...(context.length ? [`The user's other earlier messages, each cut to its start. Label every one of these too: "rule" when it is a standing rule still in force, however it is worded ("tests go under tests/", "our servers run Node 22"), "not a rule" otherwise. ${EARLIER_REQUEST}\n${context.join("\n")}`] : []),
   ].join("\n\n");
 }
 

package/src/narrative/types.ts

@@ -29,14 +29,17 @@ const QuoteRef = Type.Object({ messageRef: Ref, text: Text });
 const NowItem = Type.String({ maxLength: NOW_ITEM_CHARS });
 const NowList = Type.Array(NowItem, { maxItems: NOW_ITEMS });
 
+/** The most rules, lifts, decisions or dead ends one answer may carry: far above a real span's, so only a runaway answer is refused. */
+export const LIST_ITEMS = 32;
+
 export const NarrativeDiffSchema = Type.Object({
   narrative: Text,
   objective: Type.Optional(Type.Object({ messageRef: Ref, text: Text, doneWhen: Type.Optional(QuoteRef) })),
-  corrections: Type.Array(QuoteRef),
+  corrections: Type.Array(QuoteRef, { maxItems: LIST_ITEMS }),
   /** `text` is the withdrawing words: unlike a summary's handoff, the diff hand quotes too. */
-  lifts: Type.Array(Type.Object({ target: Ref, messageRef: Ref, text: Text })),
-  decisions: Type.Array(Type.Object({ text: Text, evidence: Type.Optional(Ref) })),
-  deadEnds: Type.Array(Type.Object({ text: Text, evidence: Type.Optional(Ref) })),
+  lifts: Type.Array(Type.Object({ target: Ref, messageRef: Ref, text: Text }), { maxItems: LIST_ITEMS }),
+  decisions: Type.Array(Type.Object({ text: Text, evidence: Type.Optional(Ref) }), { maxItems: LIST_ITEMS }),
+  deadEnds: Type.Array(Type.Object({ text: Text, evidence: Type.Optional(Ref) }), { maxItems: LIST_ITEMS }),
   now: Type.Object({ inProgress: NowList, next: NowList, blocked: NowList, resume: NowItem }),
   /** Every user message of the span, labeled (message-labels.ts): code turns a "rule" into a correction in the user's own words. */
   labels: Type.Optional(Type.Record(Type.String(), Type.Unknown())),

package/src/pass.ts

@@ -367,7 +367,7 @@ function assembleResult(input: PassInput, config: StateConfig, fold: Fold, outco
   const pending: PendingSpan = { span: fold.span, events: closed.log.events.filter((event) => event.span === fold.span), ledger, snapshot, usage, caps: config.coldSliceCaps };
   const route = { spec: fold.route.spec, rule: fold.route.rule, model: fold.resolved ? `${fold.resolved.model.provider}/${fold.resolved.model.id}` : undefined, fallbackReason: fold.resolved?.fallbackReason, routeIgnored: fold.resolved?.routeIgnored, routeAvailable: fold.routeAvailable };
   const logOptions = logOptionsOf(input.env);
-  const log = { event: "compaction", at, reason: input.reason, span: fold.span, tokensBefore: preparation.tokensBefore, summaryChars: summary.length, narrative: logSafeNarrative(details.narrative, logOptions), rejected: logSafeRejected(outcome.rejected, logOptions), route, routeHealth: outcome.routeHealth, capFit: closed.capFit.retired, capExhausted: closed.capFit.exhausted, anomalies: fold.log.anomalies, world: { claims: closed.state.world?.claims.length ?? 0, openErrors: closed.state.world?.openErrorIds.length ?? 0, dirty: closed.state.world?.dirty }, carried: { readFiles: files.readFiles.length, modifiedFiles: files.modifiedFiles.length, removed: logSafeRemoved(files.removed, logOptions), learnedValues: learned.length }, redacted, workspace: "skipped" in capture ? { skipped: logSafeSkipped(capture.skipped, logOptions) } : { captured: true }, durationMs: deps.now().getTime() - startedAt.getTime() };
+  const log = { event: "compaction", at, reason: input.reason, span: fold.span, tokensBefore: preparation.tokensBefore, summaryChars: summary.length, narrative: logSafeNarrative(details.narrative, logOptions), rejected: logSafeRejected(outcome.rejected, logOptions), route, routeHealth: outcome.routeHealth, capFit: { ...closed.capFit.retired, condensedCorrections: closed.capFit.condensed }, capExhausted: closed.capFit.exhausted, anomalies: fold.log.anomalies, world: { claims: closed.state.world?.claims.length ?? 0, openErrors: closed.state.world?.openErrorIds.length ?? 0, dirty: closed.state.world?.dirty }, carried: { readFiles: files.readFiles.length, modifiedFiles: files.modifiedFiles.length, removed: logSafeRemoved(files.removed, logOptions), learnedValues: learned.length }, redacted, workspace: "skipped" in capture ? { skipped: logSafeSkipped(capture.skipped, logOptions) } : { captured: true }, durationMs: deps.now().getTime() - startedAt.getTime() };
   return {
     compaction: { summary, firstKeptEntryId: preparation.firstKeptEntryId, tokensBefore: preparation.tokensBefore, usage: compactionUsageOf(outcome.usage), details },
     pending, outcome, routeHealth: outcome.routeHealth, route, capFit: closed.capFit, anomalies: fold.log.anomalies, notice: noticeOf(fold.span, outcome, summary.length), log,

package/src/remember-tool.ts

@@ -54,7 +54,7 @@ function credentialRefusal(proposal: Proposal, branch: Parameters<typeof message
 }
 
 const PARAMETERS = Type.Object({
-  kind: Type.Union(REMEMBER_KINDS.map((kind) => Type.Literal(kind)), { description: "correction: a standing rule the user gave (quote). lift: the user withdrew a correction (target + quote). decision / dead-end: your own one sentence (text, evidence). done-when: the user's acceptance words (quote)." }),
+  kind: Type.Union(REMEMBER_KINDS.map((kind) => Type.Literal(kind)), { description: "correction: a standing rule the user gave, still binding after the current task (quote). lift: the user withdrew a correction (target + quote). decision / dead-end: your own one sentence (text, evidence). done-when: the user's acceptance words (quote)." }),
   quote: Type.Optional(Type.String({ description: "The user's exact words, a substring of one user message (12+ chars). Example: \"never use mocks in these tests\"." })),
   text: Type.Optional(Type.String({ description: "Your own sentence for a decision or dead end. Example: \"Copied the ledger modules instead of importing them across extensions\"." })),
   evidence: Type.Optional(Type.String({ description: "C<n>, E<n>, u<n>, \"last command\" or \"last error\"." })),
@@ -67,7 +67,7 @@ export function registerRememberTool(pi: ExtensionAPI, deps: { readConfig: ReadF
     label: "Remember",
     description: "Write one verified item into the session state that survives compaction: a user correction (their exact words), a lift, a decision, a dead end, or the acceptance criterion. Rejections say why and whether to retry.",
     promptGuidelines: [
-      `Call \`${REMEMBER_TOOL}\` the moment the user states a standing rule (kind correction, quote their exact words) or when you settle a decision or abandon an approach (kind decision / dead-end, one sentence with evidence C<n>/E<n>/u<n>).`,
+      `Call \`${REMEMBER_TOOL}\` the moment the user states a standing rule, one that still binds once the current task is done (kind correction, quote their exact words; a request for the task at hand is not one), or when you settle a decision or abandon an approach (kind decision / dead-end, one sentence with evidence C<n>/E<n>/u<n>).`,
       "Never paraphrase a correction: the quote must be a substring of a user message, at least 12 characters, or it is rejected with the closest match.",
     ],
     parameters: PARAMETERS,

package/src/render.ts

@@ -105,8 +105,12 @@ function retiredNote(count: number, what?: string): string {
   return what ? `; ${count} retired, ${RECALL_TOOL} ${what}` : `; ${count} retired`;
 }
 
+/** How much of a rule the cap fit condensed is shown (capfit.ts); the cut names the message that holds it whole. */
+export const CONDENSED_CORRECTION_CHARS = 80;
+
 function correctionsSection({ state, caps }: RenderInput): string[] {
-  const lines = activeCorrections(state).map((item) => `- ${item.id} [${item.quote.ordinal}] ${renderQuote(item.quote, caps.correctionChars)}${item.liftedBy ? ` (lifted by ${item.liftedBy.ordinal})` : ""}`);
+  const shown = (condensed: boolean | undefined) => (condensed ? Math.min(CONDENSED_CORRECTION_CHARS, caps.correctionChars) : caps.correctionChars);
+  const lines = activeCorrections(state).map((item) => `- ${item.id} [${item.quote.ordinal}] ${renderQuote(item.quote, shown(item.condensed))}${item.liftedBy ? ` (lifted by ${item.liftedBy.ordinal})` : ""}`);
   return [`## Constraints & corrections (verbatim, newest last${retiredNote(state.retired.corrections, "corrections")})`, ...(lines.length ? lines : ["(none)"])];
 }
 

package/src/store/capfit.ts

@@ -1,21 +1,25 @@
 /**
  * The hard cap on the rendered state: over it, sections retire oldest-first in the
- * order work log, decisions, dead ends, corrections, until under it. Objective, Now and World are
- * never touched. The size function is injected so this stays a pure step over the projection and
- * the loop provably terminates: every step retires one item or stops.
+ * order work log, decisions, dead ends, until under it; then corrections are condensed, oldest first, to an
+ * excerpt that names the rule's recall (render.ts). A correction is never retired here: only a lift retires one,
+ * since an old rule binds as much as a new one. Objective, Now and World are never touched. The size function is
+ * injected so this stays a pure step over the projection and the loop provably terminates: every step retires or
+ * condenses one item or stops.
  */
 import type { Caps } from "./events.ts";
 import type { SessionState } from "./project.ts";
 
 export interface CapFitResult {
   state: SessionState;
-  retired: { workLog: number; decisions: number; deadEnds: number; corrections: number };
-  /** Nothing retirable was left and the state is still over the cap. */
+  retired: { workLog: number; decisions: number; deadEnds: number };
+  /** Corrections rendered as an excerpt to fit; each is still in the state, whole in recall. */
+  condensed: number;
+  /** Nothing retirable or condensable was left and the state is still over the cap. */
   exhausted: boolean;
 }
 
 type Section = keyof CapFitResult["retired"];
-const ORDER: Section[] = ["workLog", "decisions", "deadEnds", "corrections"];
+const ORDER: Section[] = ["workLog", "decisions", "deadEnds"];
 
 /** Retire the oldest active item of `section`; false when there is none. */
 function retireOne(state: SessionState, section: Section): boolean {
@@ -33,13 +37,23 @@ function retireOne(state: SessionState, section: Section): boolean {
   return true;
 }
 
+/** Condense the oldest active correction not condensed yet; false when there is none. */
+function condenseOne(state: SessionState): boolean {
+  const oldest = state.corrections.find((item) => !item.retired && !item.condensed);
+  if (!oldest) return false;
+  oldest.condensed = true;
+  return true;
+}
+
 export function fitToHardCap(input: SessionState, caps: Caps, measure: (state: SessionState) => number): CapFitResult {
   const state = structuredClone(input);
-  const retired = { workLog: 0, decisions: 0, deadEnds: 0, corrections: 0 };
+  const retired = { workLog: 0, decisions: 0, deadEnds: 0 };
+  let condensed = 0;
   while (measure(state) > caps.hardChars) {
     const section = ORDER.find((candidate) => retireOne(state, candidate));
-    if (!section) return { state, retired, exhausted: true };
-    retired[section]++;
+    if (section) retired[section]++;
+    else if (condenseOne(state)) condensed++;
+    else return { state, retired, condensed, exhausted: true };
   }
-  return { state, retired, exhausted: false };
+  return { state, retired, condensed, exhausted: false };
 }

package/src/store/events.ts

@@ -80,6 +80,7 @@ export const closedWhole = (close: { foreign?: unknown; narrativeLess: boolean;
 export interface Caps {
   hardChars: number;
   objectiveQuoteChars: number;
+  /** The most active corrections kept, the oldest retiring past it; 0 (the default) keeps every one until it is lifted, up to CORRECTIONS_CEILING. */
   corrections: number;
   correctionChars: number;
   decisions: number;
@@ -95,7 +96,14 @@ export interface Caps {
   learnedChars: number;
 }
 
-export const DEFAULT_CAPS: Caps = { hardChars: 13500, objectiveQuoteChars: 600, corrections: 8, correctionChars: 300, decisions: 10, deadEnds: 10, itemChars: 300, workLogLines: 12, openErrors: 5, worldChars: 1200, filesChars: 2500, learnedChars: 1500 };
+/**
+ * With no count cap set, the most active corrections a state keeps: a safety bound, never a working limit (the most a
+ * real session carried was 22). Past it the oldest retires, still recallable from the transcript, so text steered into
+ * many rules cannot grow the state, and every summarizer prompt, without end (security.md T4).
+ */
+export const CORRECTIONS_CEILING = 64;
+
+export const DEFAULT_CAPS: Caps = { hardChars: 13500, objectiveQuoteChars: 600, corrections: 0, correctionChars: 300, decisions: 10, deadEnds: 10, itemChars: 300, workLogLines: 12, openErrors: 5, worldChars: 1200, filesChars: 2500, learnedChars: 1500 };
 
 export const MIN_QUOTE_CHARS = 12;
 

package/src/store/project.ts

@@ -1,11 +1,13 @@
 /**
  * Hot memory is `project(log, caps)`: a pure reducer over accepted events. Per-kind caps retire
- * the oldest of a kind on add; a lift marks a correction, and a correction lifted in an earlier
+ * the oldest decision or dead end on add. A correction does not retire by count unless `caps.corrections` asks
+ * for it (0, the default, never), since an old rule binds as much as a new one: a lift marks it, and a correction lifted in an earlier
  * span is retired, so it renders as lifted exactly once; a span close appends the work-log line,
  * carries World, and consolidates work-log lines past the cap into one code-written line.
  * Retirement is a projection rule: the log never deletes, and recall reads the log.
  */
 import type { Caps, ForeignCompactor, Now, Quote, Source, StateEvent, StateLog, World } from "./events.ts";
+import { CORRECTIONS_CEILING } from "./events.ts";
 import { DEFAULT_NEAR_DUPLICATE_THRESHOLD, overlap, tokenize } from "./near-duplicate.ts";
 import { oneLine } from "../one-line.ts";
 import { scrubCredentials } from "../credential-scrub.ts";
@@ -19,6 +21,8 @@ export interface CorrectionItem {
   seq: number;
   liftedBy?: { messageId: string; ordinal: string; span: number };
   retired: boolean;
+  /** Set by the cap fit alone (capfit.ts): rendered as an excerpt naming its recall, never projected. */
+  condensed?: boolean;
   /** Ids this rule held before being recorded again from its message (addCorrection); see liftTarget. */
   formerIds?: Set<string>;
   /** `span:seq` of the earlier correction.add events folded into this rule, for recall (addCorrection). */
@@ -183,7 +187,7 @@ function addCorrection(state: SessionState, event: Extract<StateEvent, { kind: "
   const copyKeys = earlier?.copyKeys ?? [];
   if (earlier) copyKeys.push(eventKey(earlier));
   state.corrections.push({ id: event.id, quote: event.quote, span: event.span, source: event.source, evidence: event.evidence, seq: event.seq, retired: false, ...(formerIds.size ? { formerIds } : {}), ...(copyKeys.length ? { copyKeys } : {}) });
-  state.retired.corrections += retireOverCap(state.corrections, caps.corrections);
+  state.retired.corrections += retireOverCap(state.corrections, caps.corrections > 0 ? caps.corrections : CORRECTIONS_CEILING);
 }
 
 export function applyEvent(previous: SessionState, event: StateEvent, caps: Caps): SessionState {