@cerebriline/core 4.100.247 → 4.100.248

package/dist/extensions/context/capped-thinking.d.ts

@@ -169,6 +169,20 @@ type PrepareTurnResult = {
     messages?: readonly MessageWithMetadata[];
 } | undefined;
 type PrepareTurn = (context: never) => PrepareTurnResult | Promise<PrepareTurnResult>;
+/** A request answered by the conversation itself, or `undefined` to decline. */
+type ConversationAsk = (systemPrompt: string, request: string, maxTokens: number, what: string) => Promise<string | undefined>;
+/**
+ * The discarded turn's notes, asked of the conversation as its next turn
+ * where that can be done (`DiscardedTurnInput.continueConversation`).
+ *
+ * Declines -- and the note is asked for in a request of its own, as before --
+ * when the runtime offered no way to continue, when a separate summarizer
+ * model is configured (it is not the conversation's model), when the provider
+ * keeps no prefix to share, and when the instruction and its answer do not fit
+ * in what the last request left of the window. A continuation that fails or
+ * says nothing declines too: a note is never lost to the attempt.
+ */
+export declare function createConversationAsk(input: DiscardedTurnInput, config: CappedThinkingCondenserConfig, providerConfig: ProviderConfig): ConversationAsk | undefined;
 /**
  * Condense reasoning that is about to be thrown away rather than sent again.
  *

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

@@ -112,6 +112,39 @@ export type MeasureContextTokens = (message: MessageWithMetadata, index: number)
  * the context as it stands, which is the question the reservation is asking.
  */
 export declare function resolveObservedOutputTokens(messages: readonly MessageWithMetadata[], measure: MeasureContextTokens, sampleTurns?: number): number | undefined;
+/**
+ * What a compaction written as the conversation's next turn needs on top of
+ * the conversation: its instruction and its summary.
+ *
+ * One function because two things ask it. The trigger asks before the fact,
+ * so that compaction starts while this still fits; the continuation asks at
+ * the moment it would start, and steps aside when it does not. Harness run
+ * 0432 (2026-10-11) is what two different answers cost: the trigger waited
+ * for 90% of an 85,106-token window, the writer's request then measured
+ * 92,738, and each such compaction fell back to a summary that did not fit
+ * beside the conversation either, released the conversation's window and made
+ * the next turn read its whole prompt again.
+ */
+export declare const CONTINUATION_WRITER_INSTRUCTION_TOKENS = 3072;
+export declare function resolveContinuationWriterRoomTokens(contextWindow: number | undefined): number;
+/**
+ * What the conversation has gained since its last request was measured: the
+ * newest assistant message and the results that followed it.
+ *
+ * The provider's count is of the request that produced that message, so it
+ * holds neither. In run 0432 the count was 78,895 and the conversation the
+ * writer had to continue was about 90,000.
+ */
+export declare function resolvePendingTurnTokens(messages: readonly MessageWithMetadata[], measure: MeasureContextTokens): number;
+/**
+ * How much one turn adds to the conversation, from this session's own turns:
+ * an assistant message and everything up to the next one.
+ *
+ * Read the way {@link resolveObservedOutputTokens} reads output, for the same
+ * reason: the newest turns count in full, and past them a single large turn is
+ * an outlier and the second largest sets the figure.
+ */
+export declare function resolveObservedTurnGrowthTokens(messages: readonly MessageWithMetadata[], measure: MeasureContextTokens, sampleTurns?: number): number | undefined;
 /**
  * The largest prompt that still leaves the model room to answer.
  *
@@ -150,6 +183,19 @@ export declare function resolveCompactionTriggerTokens(input: {
     modelMaxTokens?: number;
     /** The high-water output of recent turns, from {@link resolveObservedOutputTokens}. */
     observedOutputTokens?: number;
+    /**
+     * Set where compaction would be written as the conversation's next turn.
+     * The trigger then also holds back what that turn needs, so compaction
+     * starts while it still fits: the writer's own room, what the conversation
+     * has gained since the count the trigger compares was taken, and one more
+     * turn like this session's.
+     */
+    continuation?: {
+        /** {@link resolvePendingTurnTokens}; 0 when the compared count is current. */
+        pendingTokens: number;
+        /** {@link resolveObservedTurnGrowthTokens}. */
+        turnGrowthTokens?: number;
+    };
 }): number;
 export interface FileOperationSummary {
     readFiles: string[];

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

@@ -186,6 +186,12 @@ export interface CompactionContinuation {
      * where the engine books.
      */
     fresh(purpose: "retrospective" | "synthesizer", systemPrompt: string, request: string, maxTokens: number, providerConfig: ProviderConfig, reservation?: PPrimeReservation): Promise<ContinuationCallResult>;
+    /**
+     * Whether a retrospective of about `chars` characters would run as the
+     * session's own next turn. It has to be asked for before {@link release}
+     * then: afterwards there is no session to continue.
+     */
+    retrospectiveFitsInSession(chars: number, maxTokens: number): boolean;
     /**
      * Give the session's cells back: the critics, P', P, then the session's
      * own slot. Idempotent; run before the synthesizer, and again by
@@ -216,6 +222,12 @@ export interface PrepareContinuationInput {
     requestTokens: number;
     /** The last request's own prompt count, when one was measured. */
     observedRequestTokens?: number;
+    /**
+     * What the conversation has gained since `requestTokens` was counted: the
+     * newest assistant message and the results after it. 0 when the count is
+     * an estimate of the conversation as it stands.
+     */
+    pendingTokens?: number;
     reasoning: ContinuationReasoning;
     /** A summarizer model of its own is configured: it cannot continue this one. */
     separateSummarizer: boolean;
@@ -238,6 +250,12 @@ export interface PrepareContinuationInput {
 }
 /** Whether a failed call is the server saying "not now". */
 export declare function isInfraFault(error: unknown): boolean;
+/**
+ * Why compaction on this connection is never written as a continuation, or
+ * `undefined` when it can be. The part of the answer that does not depend on
+ * the turn, so the trigger can ask it before there is a compaction to prepare.
+ */
+export declare function continuationCompactionExcluded(config: ProviderConfig, separateSummarizer: boolean): string | undefined;
 /**
  * Whether compaction on this connection can run as a continuation, and in
  * which shape. `undefined` continuation with the reason when it cannot.

package/dist/hub/client/index.d.ts

@@ -61,6 +61,19 @@ export declare class HubCommandError extends Error {
 }
 export declare function isHubCommandTimeoutError(error: unknown, command?: HubCommandEnvelope["command"]): boolean;
 export declare function rememberRecoverableLocalHubUrl(url: string, authToken?: string): string;
+/**
+ * Keep a local hub's token for the connections this process makes to it,
+ * without marking the hub as one this process may restart.
+ *
+ * A hub on an explicit endpoint (`CLINE_HUB_PORT`, or a host/port the caller
+ * passed) is not "recoverable", and that used to mean its token was not kept
+ * either. The caller that had just started it got back a URL, connected with
+ * no token and was refused: "WebSocket connection to
+ * 'ws://127.0.0.1:25499/hub' failed: Connection ended", on every first start
+ * (solidPC and eleven2go, 2026-10-11, three of three). The second start
+ * worked because it found the discovery record, which carries the token.
+ */
+export declare function rememberLocalHubAuthToken(url: string, authToken?: string): void;
 export declare class NodeHubClient {
     private readonly options;
     private socket;