@gkorepanov/ccodex 0.5.0-rc.8 → 0.5.0

package/dist/claude/threads.d.ts

@@ -6,6 +6,11 @@ import { type JsonObject, type Thread, type Turn } from "../protocol/codex.js";
 import { NativeSessionCatalog, type SessionSummary } from "./native/catalog.js";
 import { type TranscriptProjection } from "./native/projector.js";
 import { ClaudeSession, type SessionSettings } from "./session.js";
+interface RateLimitWindow {
+    usedPercent: number;
+    windowDurationMins: number | null;
+    resetsAt: number | null;
+}
 /** The Claude side of the gateway: catalog of native sessions, live sessions, side chats, models, skills. */
 export declare class ClaudeThreads {
     readonly config: Config;
@@ -16,15 +21,26 @@ export declare class ClaudeThreads {
     private readonly sides;
     /** `agent-<id>` sub-agent thread → the native session whose transcript directory holds it. */
     private readonly subagentRoots;
+    /** Threads rolled back but not continued yet: their kept history ends at this record. A restart meanwhile shows
+     *  the rolled-back messages again. */
+    private readonly leaves;
     /** Sub-agents spawned live, shown until Claude has written their transcript. */
     private readonly spawnedSubagents;
     /** Context window of each Claude model, as its sessions report it. */
-    readonly contextWindows: Map<string, number>;
+    private readonly contextWindows;
     /** Running sub-agents: their thread follows the transcript Claude writes (what was shown: item id → item). */
     private readonly liveSubagents;
     private models_?;
     private defaultModel;
     private readonly rateLimitWindows;
+    private usage?;
+    /** Why Claude's plan limits could not be read, when they could not. */
+    usageError?: string;
+    /** Weekly windows of single models (e.g. Fable), from Claude's `/usage` data. */
+    modelLimits: {
+        name: string;
+        window: RateLimitWindow;
+    }[];
     private stopWatching?;
     onTurnCompleted?: (threadId: string, turnId: string) => void;
     constructor(config: Config, gateway: Gateway, logger: Logger);
@@ -32,7 +48,7 @@ export declare class ClaudeThreads {
     /** CPU seconds each command of a loaded session used, and since when unchanged. */
     private cpuSeen;
     private sweeper?;
-    /** What CCodex last did to each chat's process and commands, and why (shown by /ccstate). */
+    /** What CCodex last did to each chat's process and commands, and why (shown by /cc). */
     private readonly actions;
     private act;
     /**
@@ -53,9 +69,14 @@ export declare class ClaudeThreads {
     private status;
     /** Claude's own title of a session stays unseen while CCodex names it (it would show until CCodex's replaces it). */
     private headerOf;
+    /** A chat's model from its transcript; in plan mode meta.json's (Claude plans a Haiku chat on Sonnet, see Meta.setPlan). */
+    private recordedModel;
+    /** A chat's effort from its transcript (Claude records `ultra` as the max it runs at, told to delegate); in plan mode meta.json's. */
+    private recordedEffort;
     /** Transcripts name the resolved model (`claude-haiku-4-5-…`); the picker (and a live session) its value (`haiku`). */
     private pickerModel;
     /** Every native session as a list row (sub-agents excluded; they are listed through their parent). */
+    search(term: string): Promise<Map<string, string>>;
     threads(): Thread[];
     private decorate;
     private freshThread;
@@ -93,6 +114,8 @@ export declare class ClaudeThreads {
     /** The newest turns (at least `count` unless history is shorter). */
     private newestTurns;
     turnsPage(threadId: string, params: JsonObject): Promise<JsonObject>;
+    /** Stock's `thread/searchOccurrences`: history is read back only to the first message holding the term (ripgrep finds it). */
+    searchOccurrences(threadId: string, params: JsonObject): Promise<JsonObject>;
     itemsPage(threadId: string, params: JsonObject): Promise<JsonObject>;
     settings(threadId: string): SessionSettings;
     /** Common fields of thread/start|resume|fork responses and thread/settings/updated. */
@@ -103,12 +126,17 @@ export declare class ClaudeThreads {
     /** The session continued from the rollback leaf: its new records end the history from now on. */
     resumedAtLeaf(threadId: string): void;
     turnCompleted(session: ClaudeSession, turnId: string): void;
-    /** Claude's native `/goal` as a Codex ThreadGoal (Claude tracks no budget or time). */
+    /**
+     * Claude's native `/goal` as a Codex ThreadGoal (Claude tracks no budget or time); a paused one is kept in meta.json.
+     * The goal last sent to Claude is the chat's: Claude records a `/goal` a moment after taking it.
+     */
     goal(threadId: string): JsonObject | null;
     subagentMessage(_session: ClaudeSession, _message: JsonObject): void;
     onRateLimit(info: JsonObject | undefined): void;
     private rateLimitSnapshot;
+    /** Claude's plan limits: read from Claude's `/usage` data at most once a minute, and as turns report them. */
     rateLimits(): Promise<JsonObject>;
+    private readUsage;
     rateLimitWindowsText(): string[];
     models(): Promise<JsonObject[]>;
     private get modelsPath();
@@ -116,9 +144,14 @@ export declare class ClaudeThreads {
     /** Asks Claude for its models and keeps them for the next start. */
     private probeModels;
     private useModels;
+    /** The effort Claude runs at: the chat's, else its model's default as the picker shows it (Claude's own may differ). */
+    effort(settings: SessionSettings): string | null;
+    /** The context window Claude works with for a model (picker value or resolved id; none: the default model). */
+    contextWindow(model: string | null | undefined): number;
     modelLabel(model: string | null): string;
     private readonly pendingNames;
     private readonly pickerValues;
+    private readonly defaultEfforts;
     private readonly skillCache;
     skills(cwds: readonly string[]): Promise<Map<string, JsonObject[]>>;
     private sideThread;
@@ -137,6 +170,12 @@ export declare class ClaudeThreads {
     create(settings: SessionSettings): ClaudeSession;
     private resume;
     rename(threadId: string, name: string): Promise<JsonObject>;
+    /** The goal of a Claude backend the chat switches away from, out of Claude (a running goal turn stops). */
+    takeGoal(threadId: string): Promise<JsonObject | null>;
+    /** A goal the chat brings to this Claude backend as it switches (or keeps as a switch fails). */
+    giveGoal(threadId: string, goal: JsonObject): Promise<void>;
+    /** A Claude backend the chat switched away from: nothing of it runs on (background tasks, process). */
+    retire(threadId: string): Promise<void>;
     /** Removes a session with its transcript (also what a failed switch to Claude leaves behind). */
     discard(threadId: string): Promise<void>;
     private delete;
@@ -155,3 +194,4 @@ export declare class ClaudeThreads {
     exists(threadId: string): boolean;
     liveSession(threadId: string): ClaudeSession | undefined;
 }
+export {};