@cerebriline/core 4.100.241 → 4.100.243

package/dist/runtime/orchestration/runtime-builder.d.ts

@@ -8,6 +8,19 @@ export declare function createTeamName(): string;
  * nodes agents are actually placed on.
  */
 export declare function resolveSessionAgentNodes(config: CoreSessionConfig): NonNullable<CoreSessionConfig["agentNodes"]>;
+/**
+ * What to tell a model that calls a delegation tool this session withholds.
+ *
+ * The rejection it got before named every tool on offer and no cause, so it
+ * read as a transient failure and the same call came back. This says why, what
+ * to do instead, and that asking again will not change the answer.
+ */
+export declare function describeWithheldDelegationTools(input: {
+    offered: readonly string[];
+    subagentsEnabled: boolean;
+    serialised: boolean;
+    multipleNodes: boolean;
+}): Record<string, string>;
 export declare class DefaultRuntimeBuilder implements RuntimeBuilder {
     private readonly teamRuntimeEntries;
     build(input: RuntimeBuilderInput): Promise<RuntimeEnvironment>;

package/dist/runtime/orchestration/session-runtime.d.ts

@@ -38,6 +38,8 @@ export interface BuiltRuntime {
     configuredAgents?: readonly ConfiguredAgentConfig[];
     extensions?: AgentConfig["extensions"];
     completionPolicy?: AgentConfig["completionPolicy"];
+    /** Why a tool this session withholds is absent, by tool name. */
+    unavailableToolReasons?: Record<string, string>;
     registerLeadAgent?: (agent: LeadAgentHandle) => void;
     shutdown: (reason: string) => Promise<void> | void;
 }

package/dist/runtime/safety/loop-detection.d.ts

@@ -106,6 +106,19 @@ export declare const POLLING_TOOL_NAMES: ReadonlySet<string>;
  * real revision.
  */
 export declare function loopResultSignature(output: unknown): string;
+/**
+ * A call that moves its own subject, so the same arguments ask a new question
+ * every time: `browser` `scroll_down` shows the next viewport, and reading a
+ * long page is that one call sent again and again. The consecutive rule's
+ * premise -- "the arguments have not changed, so neither will the result" --
+ * is false for it. Reported 2026-10-09: seven scrolls down one dashboard, a
+ * different screenshot after each, and the run stopped at the seventh.
+ *
+ * Only the consecutive rule is lifted. The answer is still compared, so a
+ * scroll that has reached the end of the page -- same screenshot, same console
+ * -- is caught by the no-progress cycle like any other call.
+ */
+export declare function callMovesItsOwnSubject(call: LoopDetectionCall): boolean;
 export interface LoopCheckResult {
     softWarning: boolean;
     hardEscalation: boolean;

package/dist/services/retrieval/catalogue.d.ts

@@ -117,7 +117,9 @@ export interface BookImage {
 export interface SourceImageInput {
     /** The name the source's text links it by: `images/<file>`. */
     file: string;
-    data: Uint8Array;
+    /** The picture's bytes, or `path`: a file holding them, read when it is filed. */
+    data?: Uint8Array;
+    path?: string;
     mediaType: string;
     width?: number;
     height?: number;
@@ -151,8 +153,13 @@ export interface BookMatch {
     book: LibraryBook;
     source?: BookSource;
     reason: "same file" | "same link" | "same isbn" | "same title and author" | "same title" | "similar text";
-    /** For "similar text": the share of the text the two have in common, 0 to 1. */
+    /**
+     * The share of the text the two have in common, 0 to 1: for "similar
+     * text", and for a title match when both have text to compare.
+     */
     similarity?: number;
+    /** The running heads of `source`, when it has pages: what document it is. */
+    runningHeads?: string[];
 }
 export interface FindSimilarInput {
     sha256?: string;
@@ -172,7 +179,21 @@ export type ExportScope = {
     shelfId: number;
 } | {
     bookId: number;
+}
+/**
+ * Whatever was ticked, together: whole sections, whole shelves and single
+ * books, from anywhere in the Library. A section or shelf brings
+ * everything on it; a book alone brings its shelf and section with only
+ * that book on them.
+ */
+ | {
+    selection: ExportSelection;
 };
+export interface ExportSelection {
+    sectionIds?: readonly number[];
+    shelfIds?: readonly number[];
+    bookIds?: readonly number[];
+}
 export interface ExportResult {
     file: string;
     books: number;
@@ -349,6 +370,12 @@ export declare class Catalogue {
      * trash are included, and say so.
      */
     findSimilar(input: FindSimilarInput): BookMatch[];
+    /**
+     * A source's running heads. Kept in its metadata from when it was added;
+     * a source added before that has them read from its text once, here, and
+     * kept. Empty for a source with no pages, or no text left to read.
+     */
+    private sourceRunningHeads;
     private bookFile;
     /** Write `book.json`: what the folder is, for a person and for import. */
     writeBookFile(bookId: number): void;

package/dist/services/retrieval/running-heads.d.ts

@@ -0,0 +1,38 @@
+/**
+ * A document's running heads: the lines printed on most of its pages, and
+ * what they say about which document it is.
+ *
+ * Text in common says two documents are related, not that one is a version of
+ * the other. Measured on a folder of AMD's processor manuals: two Processor
+ * Programming References for different processors share 77% of their five-word
+ * runs, more than two revisions of one revision guide (68%), because whole
+ * register chapters are reused from product to product. No threshold on the
+ * text separates them. The running head does: "55803 Rev 0.54 - Sep 12, 2019
+ * PPR for AMD Family 17h Model 31h B0" against "56176 Rev 3.06 - Jul 17, 2019
+ * PPR for AMD Family 17h Model 71h B0". Between revisions of one document only
+ * the revision and the date change; between two documents the number and the
+ * subject do.
+ *
+ * So the head is not stripped as boilerplate: it is read as the document's
+ * name. Only its identifying part is compared -- the tokens that carry a
+ * digit, once revision numbers and dates are taken out -- because the words
+ * around them ("AMD64 Technology", "PPR for AMD Family") are shared by a
+ * whole series.
+ */
+/**
+ * The lines that repeat, word for word, on most pages. A page number printed
+ * on the same line makes it differ from page to page, so it drops out; a
+ * table heading that recurs is kept, and carries no identity (see below).
+ * Empty for a document without pages: an ebook has none to repeat on.
+ */
+export declare function runningHeads(markdown: string): string[];
+/** What the running heads say the document is, as sorted tokens; empty if they say nothing. */
+export declare function documentIdentity(heads: readonly string[]): string[];
+/**
+ * Whether two documents are the same one by their running heads: true when
+ * the identities match, false when both have one and they differ, undefined
+ * when either says nothing -- then the text and the title decide, as before.
+ */
+export declare function sameDocument(a: readonly string[] | undefined, b: readonly string[] | undefined): boolean | undefined;
+/** The head that names the document, for a message: the first with an identity. */
+export declare function namingHead(heads: readonly string[] | undefined): string | undefined;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@cerebriline/core",
 	"description": "Cerebriline Core SDK for Node Runtime",
-	"version": "4.100.241",
+	"version": "4.100.243",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/mann1x/cline.git",
@@ -69,9 +69,9 @@
 		"ws": "^8.20.0",
 		"yaml": "^2.8.2",
 		"zod": "^4.3.6",
-		"@cerebriline/agents": "4.100.241",
-		"@cerebriline/llms": "4.100.241",
-		"@cerebriline/shared": "4.100.241"
+		"@cerebriline/agents": "4.100.243",
+		"@cerebriline/llms": "4.100.243",
+		"@cerebriline/shared": "4.100.243"
 	},
 	"peerDependencies": {
 		"posthog-node": "^5.8.0"