@cerebriline/core 4.100.264 → 4.100.266

package/dist/extensions/context/compaction-shared.d.ts

@@ -261,6 +261,13 @@ export interface CompactionSummaryMetadata {
      * exists nowhere else once the messages are gone.
      */
     userRequests?: string[];
+    /**
+     * The files a call has put in front of the model, over every generation
+     * so far. A summary line about a file outside it states what nobody read
+     * (`unread-files.ts`); carried because the next fold's calls are not the
+     * only ones that opened files.
+     */
+    seenFiles?: string[];
 }
 export type EstimateMessageTokens = (message: MessageWithMetadata) => number;
 /**
@@ -317,7 +324,9 @@ export declare function formatToolInput(input: Record<string, unknown>): string;
  * says how much of it was left out.
  */
 export declare function formatToolInputForTranscript(input: Record<string, unknown>): string;
-export declare function serializeMessage(message: MessageWithMetadata, format?: ToolResultFormat): string;
+export declare function serializeMessage(message: MessageWithMetadata, format?: ToolResultFormat, 
+/** Each call's number in the tool ledger's key, by call id. */
+callNumbers?: ReadonlyMap<string, number>): string;
 /**
  * Render the discarded reasoning against what it produced.
  *
@@ -332,7 +341,7 @@ export declare function serializeMessage(message: MessageWithMetadata, format?:
  * was built against the results are most of the bytes.
  */
 export declare function serializeReasoningWithOutcomes(messages: MessageWithMetadata[], format?: ToolResultFormat): string;
-export declare function serializeConversation(messages: MessageWithMetadata[], format?: ToolResultFormat): string;
+export declare function serializeConversation(messages: MessageWithMetadata[], format?: ToolResultFormat, callNumbers?: ReadonlyMap<string, number>): string;
 export declare function createTokenEstimator(): EstimateMessageTokens;
 export declare function isCompactionSummaryMessage(message: MessageWithMetadata): boolean;
 /**
@@ -730,6 +739,8 @@ export declare function buildSummaryMessage(options: {
     userRequests?: string[];
     /** How much room the quoted requests may take, all together. */
     userRequestBudgetChars?: number;
+    /** The files calls have opened, for the next generation. */
+    seenFiles?: string[];
 }): MessageWithMetadata;
 /**
  * Recover the token calibration from a transcript that was written by an

package/dist/extensions/context/council-compaction.d.ts

@@ -202,6 +202,8 @@ export declare function runCouncilReview(input: {
     messages: readonly MessageWithMetadata[];
     /** How the conversation's tool results read; the critics see the same. */
     toolResultFormat?: ToolResultFormat;
+    /** Each call's number in the ledger key, so the critics read it as the writer did. */
+    callNumbers?: ReadonlyMap<string, number>;
     /**
      * One model call. Throwing is allowed and is handled as a decline.
      *

package/dist/extensions/context/tool-ledger.d.ts

@@ -105,6 +105,31 @@ export interface ToolLedgerOptions {
  * track, which is most of them — an untracked file simply does not appear.
  */
 export type RevisionSpanLookup = (path: string) => string | undefined;
+export interface NormalisedCall {
+    id: string;
+    name: string;
+    input: unknown;
+}
+export interface NormalisedResult {
+    id: string;
+    output: unknown;
+    isError?: boolean;
+    serialized?: string;
+}
+/**
+ * One call, whichever of the two block shapes it arrived in.
+ *
+ * This repository carries both, and which one a caller holds is not something
+ * the caller can be expected to know: the agent runtime works in the AI SDK's
+ * `tool-call` / `toolCallId` / `input`, and the compaction pipeline works in
+ * the Anthropic-style `tool_use` / `id` / `input` with results keyed by
+ * `tool_use_id`. A ledger that reads only one of them is not half-working; it
+ * silently reports that no tools were called, which is the most damaging thing
+ * it could say. So it reads both and says so here.
+ */
+export declare function normaliseCall(part: unknown): NormalisedCall | undefined;
+/** One result, in either shape. See {@link normaliseCall}. */
+export declare function normaliseResult(part: unknown): NormalisedResult | undefined;
 /**
  * Pair the calls in a stretch of messages with their results.
  *
@@ -114,6 +139,17 @@ export type RevisionSpanLookup = (path: string) => string | undefined;
  * something it never returned.
  */
 export declare function buildToolLedger(messages: readonly ToolLedgerMessage[], options?: ToolLedgerOptions): ToolLedgerEntry[];
+/**
+ * The number each call of `messages` has in the key that
+ * `mergeToolLedger(previous, buildToolLedger(messages))` makes, by call id.
+ *
+ * For the writer's transcript: with the calls numbered where they happen,
+ * the writer cites `#7` by reading it, not by counting tool calls down the
+ * conversation, and counting was where its citations went wrong
+ * (claude-hooks 0e7310e, compaction-v7). A run of repeats is one entry, so
+ * all its calls carry the one number.
+ */
+export declare function numberToolCalls(previous: readonly ToolLedgerEntry[], messages: readonly ToolLedgerMessage[], options?: ToolLedgerOptions): Map<string, number>;
 /**
  * Concatenate a carried ledger with this compaction's own, as one run.
  *
@@ -167,6 +203,31 @@ export declare function renderToolLedgerEntry(entry: ToolLedgerEntry): string;
  * deliberately cut.
  */
 export declare function renderToolLedgerKey(entries: readonly ToolLedgerEntry[], maxChars?: number): string;
+/**
+ * The call numbers `text` cites past a key of `calls` entries: calls that
+ * did not happen in the span, so the sentence that cites them is invented.
+ *
+ * Measured by claude-hooks on compaction-v7-cite with qwen3.6 27B: a writer
+ * whose span ended mid-task carried on in the present tense and cited up to
+ * #174 against a 55-call record -- a forecast written as a record.
+ */
+export declare function citedPastKey(text: string, calls: number): number[];
+/**
+ * `text` without its narration of calls past the key.
+ *
+ * A citation follows the clause that narrates its call, so a citation naming
+ * only calls past the key goes with the clause before it: back to the end of
+ * the previous citation, never across a paragraph. One that also names real
+ * calls keeps its clause; the splice drops just its bad numbers.
+ *
+ * The splice alone dropped the number and kept the sentence, which is the
+ * half of the failure a reader can see -- the invented step is still there,
+ * now uncited.
+ */
+export declare function dropPastKey(text: string, calls: number): {
+    text: string;
+    dropped: number;
+};
 export interface LedgerSpliceResult {
     text: string;
     /** Entries the replay placed itself, in the order it placed them. */

package/dist/extensions/context/unread-files.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Cut the summary lines that state facts about files no call opened.
+ *
+ * Measured by claude-hooks on compaction-v7-g2 / -cite (qwen3.6 27B,
+ * 2026-10-24): on every first fold, in both flows, the writer or a reviewer
+ * completed the module table the task asked for -- fields for 66 to 118
+ * modules not yet read, one line each, uncited, and 1 of 98 right. The
+ * summary is the session's only record of the fold, so a session that
+ * trusts it works from invented facts.
+ *
+ * Deterministic: the record knows which files each call put in front of the
+ * model, so a line whose every file is one no call opened says nothing that
+ * was read, whatever it claims.
+ *
+ * A file counts as seen when a call that shows content named it, in its
+ * arguments (a `read_files` path, a command that prints it) or in its result
+ * (a search match). A listing proves a file exists, not what it holds, so it
+ * never makes one seen. A file the user's own requests name is never cut:
+ * an instruction that names it is not an invention. The names the cut lines
+ * mentioned are kept, as one note, so a legitimate list of what is still to
+ * read survives as names.
+ *
+ * Ported from claude-hooks consultants/engine/unread_files.py (209185b).
+ */
+import { type ToolLedgerMessage } from "./tool-ledger";
+/** Tools whose results name files without showing what they contain. */
+export declare const LISTING_TOOLS: Set<string>;
+/** The most seen files carried to the next generation. */
+export declare const MAX_SEEN_FILES = 5000;
+export declare const UNREAD_NOTE_HEAD = "Not yet read";
+/** The file paths `text` names, in order, once each. */
+export declare function filesIn(text: string): string[];
+/** Files a call put in front of the model, in its arguments or its result. */
+export declare function seenFiles(messages: readonly ToolLedgerMessage[]): Set<string>;
+/**
+ * `text` without the lines whose every named file is unseen, the names those
+ * lines mentioned, and how many lines went. The files `exempt` names (the
+ * user's requests) are never cut, and fenced code is left alone.
+ */
+export declare function dropUnreadLines(text: string, seen: ReadonlySet<string>, exempt?: string): {
+    text: string;
+    names: string[];
+    cut: number;
+};
+/** What the cut leaves in the summary: the names, never the claims. */
+export declare function unreadNote(names: readonly string[], cut: number): string;
+/** The seen set for the summary's metadata, newest kept when over the bound. */
+export declare function carrySeenFiles(previous: readonly string[], next: Iterable<string>): string[];

package/dist/extensions/tools/check-file.d.ts

@@ -36,7 +36,7 @@ export declare const CHECK_FILE_TOOL_NAME = "check_file";
  * otherwise type are named here, in the description of the tool that replaces
  * them, which is where the model is standing when it is about to type one.
  */
-export declare const CHECK_FILE_TOOL_DESCRIPTION = "Check files for syntax errors and unbalanced brackets. **This is the syntax check.** Whichever word the question uses \u2014 parse error, syntax error, \"is it valid\", \"is it clean now\", \"what is still broken\" \u2014 this is the tool that answers it, for the files you name, in milliseconds, without running anything.\n\nAsk this instead of running `node --check`, `python -m py_compile`, `tsc --noEmit` or a bracket-counting script of your own. It parses the file without executing it, so it is safe on a page that would otherwise start a game or a server.\n\nWhen to call it:\n- After editing a file, to confirm the edit is valid before moving on.\n- Before reporting a task finished, on every file you changed. An edit you have not looked at is not a change you can report as done.\n- On a file you are about to change, to see what was already wrong with it.\n\nPass every file you want checked in one call.\n\nFor `.html` files each `<script>` block is parsed as JavaScript and the line numbers reported are the line numbers in the HTML file, not in the block.\n\nRead the bound carefully. This reports **syntax**, not meaning: a file that parses may still call a function that does not exist, and this will not say so. It is not a type checker, it does not run tests, and it does not know your project's lint rules \u2014 for those, use `run_commands`.\n\nOutput: JSON, in the shape a language server answers in. `files` holds one entry per path you named, each with `uri`, `checked` and `diagnostics`. There is no `success` field \u2014 diagnostics being listed is this tool working, not failing.\n\n`checked` says which check actually ran, and you have to read it before calling a file clean: `parsed` a real parser was satisfied, `delimiters` only the bracket scan reads this language so anything past brackets is unchecked, `none` nothing here reads this file type at all \u2014 empty `diagnostics` there means nothing was checked, not that the file is sound.\n\nEach diagnostic carries `range` (zero-based line and character), `severity` (1 = error) and `message`. `located: false` means the parser could not name a position, so the range is a placeholder rather than a claim about the top of the file. `complexity` appears on a file big enough to be worth a word about \u2014 a note to you, not a diagnostic.\n\nWhen a file's brackets do not match, a diagnostic names the line to edit and how many brackets that line is out by, one line per place the trouble starts \u2014 a file can be broken in several spots at once, so work through every line it lists before re-checking rather than re-checking after each one. Edit the lines it names; do not re-derive the balance by hand or with a script you write, which costs more thinking than you have and counts brackets inside strings, comments and regex literals that this scan skips. A parse error is always reported where the parser gave up, which is the closing bracket; the line named here is the one the error cannot name.";
+export declare const CHECK_FILE_TOOL_DESCRIPTION = "Check files for syntax errors and unbalanced brackets. **This is the syntax check.** Whichever word the question uses \u2014 parse error, syntax error, \"is it valid\", \"is it clean now\", \"what is still broken\" \u2014 this is the tool that answers it, for the files you name, in milliseconds, without running anything.\n\nAsk this instead of running `node --check`, `python -m py_compile`, `tsc --noEmit` or a bracket-counting script of your own. It parses the file without executing it, so it is safe on a page that would otherwise start a game or a server.\n\nWhen to call it:\n- After editing a file, to confirm the edit is valid before moving on.\n- Before reporting a task finished, on every file you changed. An edit you have not looked at is not a change you can report as done.\n- On a file you are about to change, to see what was already wrong with it.\n\nPass every file you want checked in one call.\n\nFor `.html` files each `<script>` block is parsed as JavaScript and the line numbers reported are the line numbers in the HTML file, not in the block.\n\nRead the bound carefully. This reports **syntax**, not meaning: a file that parses may still call a function that does not exist, and this will not say so. It is not a type checker, it does not run tests, and it does not know your project's lint rules \u2014 for those, use `run_commands`.\n\nOutput: JSON, in the shape a language server answers in. `files` holds one entry per path you named, each with `uri`, `checked` and `diagnostics`. There is no `success` field \u2014 diagnostics being listed is this tool working, not failing.\n\n`checked` says which check actually ran, and you have to read it before calling a file clean: `parsed` a real parser was satisfied, `delimiters` only the bracket scan reads this language so anything past brackets is unchecked, `none` nothing here reads this file type at all \u2014 empty `diagnostics` there means nothing was checked, not that the file is sound.\n\nEach diagnostic carries `range` (zero-based line and character), `severity` (1 = error) and `message`. `located: false` means the parser could not name a position, so the range is a placeholder rather than a claim about the top of the file. `complexity` appears on a file big enough to be worth a word about \u2014 a note to you, not a diagnostic.\n\nWhen a file's brackets do not match, a diagnostic names the line to edit and how many brackets that line is out by, one line per place the trouble starts \u2014 a file can be broken in several spots at once, so work through every line it lists before re-checking rather than re-checking after each one. Edit the lines it names; do not re-derive the balance by hand or with a script you write, which costs more thinking than you have and counts brackets inside strings, comments and regex literals that this scan skips. A parse error is always reported where the parser gave up, which is the closing bracket; the line named here is the one the error cannot name. The scan reads the whole file from line 1, and names each bracket by its line, its column and the text just before it: find it by that text rather than by counting columns.";
 /**
  * The description when the host has a real checker to point at.
  *

package/dist/extensions/tools/executors/read-receipts.d.ts

@@ -89,6 +89,18 @@ export interface ReadReceipts {
      * get different advice.
      */
     retire(filePath: string): void;
+    /**
+     * Record that the session's own machinery rewrote the file: a
+     * `restore_file`, a transaction rollback, an expert's edits.
+     *
+     * Every line may have moved, so the spans retire, and the stamp goes so
+     * the rewrite is not later reported as something outside the session.
+     * That the model read the file stays known. {@link forget} erased it, and
+     * a text-matched edit sent straight after a restore was refused with "has
+     * not been read in this session", of a file read four times and edited
+     * twice (pandorum g5tmt, calls 24 and 88).
+     */
+    noteRewrite(filePath: string): void;
     /** Drop everything known about a file. */
     forget(filePath: string): void;
     /**

package/dist/extensions/tools/memory-tools.d.ts

@@ -11,7 +11,7 @@
  * read from, a memory the user did not allow this workspace.
  */
 import { type AgentTool, type MemorySettings } from "@cerebriline/shared";
-import { type Memory, type MemoryEndpoints } from "../../services/retrieval/memory";
+import { type Memory, type MemoryEndpoints, type MemoryItem } from "../../services/retrieval/memory";
 export declare const MEMORY_TOOL_NAMES: readonly ["remember", "recall", "forget"];
 export type MemoryToolName = (typeof MEMORY_TOOL_NAMES)[number];
 export interface MemoryToolsConfig extends MemoryEndpoints {
@@ -37,5 +37,9 @@ export declare function resolveMemoryAccess(memory: Memory, settings: MemorySett
     recall: string[];
     storeFellBack?: string;
 };
+/** A note as the model reads it, with what became of its places in this workspace. */
+export declare function describeNoteHere(memory: Memory, item: MemoryItem & {
+    relevance?: number;
+}, cwd: string): string;
 /** Memory's tools, when Memory is on at session start. */
 export declare function createMemoryTools(options: CreateMemoryToolsOptions): AgentTool[];