@itookit/dsht 0.2.1 → 0.2.4

package/dist/cli.js

@@ -12,6 +12,7 @@ import { App } from "./app.js";
 import { sessionLabel } from "./navigation.js";
 import { CookieStore, login } from "./auth.js";
 import { Client } from "./client.js";
+import { historyLimits } from "./memory.js";
 import { Controller } from "./controller.js";
 import { endpoint } from "./endpoint.js";
 import { errorText, safeText, string } from "./wire.js";
@@ -23,6 +24,8 @@ With no command, choose a workspace and session interactively.
   --workspace <id>      Filter list sessions by workspace
   --session <id>        Open a session directly
   --auth-dir <path>     Private cookie directory (or DSHT_AUTH_DIR)
+  --history-records <n> Soft history record limit (default 2000)
+  --history-mb <n>      Soft history payload budget in MiB (default 16)
   --json               Print machine-readable list output
   --help               Show this help
 
@@ -39,6 +42,7 @@ Examples:
 async function main() {
     const { values, positionals } = parseArgs({ allowPositionals: true, options: {
             url: { type: 'string', default: process.env.DSH_URL ?? 'http://127.0.0.1:3080' },
+            'history-records': { type: 'string' }, 'history-mb': { type: 'string' },
             workspace: { type: 'string' }, session: { type: 'string' }, 'auth-dir': { type: 'string' }, json: { type: 'boolean' }, help: { type: 'boolean' },
         } });
     if (values.help) {
@@ -52,6 +56,7 @@ async function main() {
         throw new Error('--json and --workspace apply to list commands');
     if (list && values.session)
         throw new Error('--session applies to interactive mode');
+    const limits = historyLimits(values['history-records'], values['history-mb']);
     const { url, token } = endpoint(values.url, process.env.DSH_TOKEN);
     const store = new CookieStore(values['auth-dir']);
     if (list) {
@@ -91,7 +96,7 @@ async function main() {
     const costDirectory = join(process.env.DSHT_STATE_DIR ?? join(process.env.XDG_STATE_HOME ?? join(homedir(), '.local', 'state'), 'dsht'), 'cost', createHash('sha256').update(new URL(url).origin).digest('hex'));
     const costs = new CostLedger(prices, costDirectory);
     await costs.load();
-    const controller = new Controller(url, token, values.session, undefined, client => login(client, token, store), costs);
+    const controller = new Controller(url, token, values.session, undefined, client => login(client, token, store), costs, limits);
     const app = render(_jsx(App, { controller: controller }), { exitOnCtrlC: false });
     const terminate = () => app.unmount();
     process.once('SIGTERM', terminate);

package/dist/client.d.ts

@@ -48,6 +48,8 @@ export declare class Client {
     connect(): Promise<void>;
     /** Subscribe on the existing mux; each subscription has a fresh stream identity. */
     subscribe(endpoint: string, args: ObjectValue, listener: Listener): Subscription;
+    /** Archived session IDs from the latest authoritative workspace baseline. */
+    archivedSessionIds: ReadonlySet<string>;
     /** List workspaces by consuming and cancelling the authoritative opening baseline. */
     listWorkspaces(): Promise<ObjectValue[]>;
     /** List visible sessions, optionally filtering by the workspace's accounted IDs. */

package/dist/client.js

@@ -160,6 +160,8 @@ export class Client {
                     socket.send(JSON.stringify({ type: 'cancel', streamId }));
             } };
     }
+    /** Archived session IDs from the latest authoritative workspace baseline. */
+    archivedSessionIds = new Set();
     /** List workspaces by consuming and cancelling the authoritative opening baseline. */
     async listWorkspaces() {
         return new Promise((resolve, reject) => {
@@ -174,6 +176,7 @@ export class Client {
                             const frame = object(value);
                             if (frame.type !== 'baseline')
                                 throw new Error('Workspace stream omitted its baseline');
+                            this.archivedSessionIds = new Set(array(object(frame.value).archivedSessionIds).map(string));
                             resolve(array(object(frame.value).items).map(object));
                         }
                         catch (error) {

package/dist/controller.d.ts

@@ -2,8 +2,17 @@ import { Client } from './client.ts';
 import { CostLedger } from './cost.ts';
 import { Telemetry } from './telemetry.ts';
 import { Transcript } from './transcript.ts';
+import { type HistoryLimits } from './memory.ts';
 import { type FileReference } from './references.ts';
 import { type Json, type ObjectValue } from './wire.ts';
+/** Resolved navigation-removal identity; empty marks a fresh blank, idle session eligible for immediate archival. */
+export interface RemovalTarget {
+    kind: 'workspace' | 'session';
+    id: string;
+    name: string;
+    path?: string;
+    empty?: boolean;
+}
 /** State shared by the picker and conversation view. */
 export interface State {
     version: number;
@@ -20,9 +29,28 @@ export interface State {
     pending: ObjectValue[];
     controlError?: string;
     modelError?: string;
+    presetError?: string;
+    presets?: ObjectValue[];
     defaultModel?: ObjectValue;
     transcript: Transcript;
 }
+/** Bounded search results contain navigation summaries, never complete message bodies. */
+export interface HistorySearch {
+    items: {
+        seq: number;
+        role: string;
+        preview: string;
+    }[];
+    truncated: boolean;
+}
+/** Wire addresses for one `session/list` row, in the order the cost scan should try them.
+ *
+ * A subagent child is reachable only under its durable parent, and the list row omits the delivery
+ * mode, so both modes are offered with the continuable form first.
+ * @param session - One row from the host session list.
+ * @returns One plain-session address, or both subagent forms when the row is a child.
+ */
+export declare function costAddresses(session: ObjectValue): ObjectValue[];
 /** Owns reconnects and subscriptions. User commands remain single-attempt operations. */
 export declare class Controller {
     readonly base: string;
@@ -30,8 +58,10 @@ export declare class Controller {
     private makeClient;
     private authenticate;
     readonly costs?: CostLedger | undefined;
+    readonly historyLimits: HistoryLimits;
     state: State;
     private observers;
+    private interactions;
     private abort;
     private client;
     private clientId;
@@ -39,8 +69,10 @@ export declare class Controller {
     private runTask;
     private generationFailed;
     private selection;
+    private historyPinned;
     telemetry: Telemetry;
     private observedRunningAt;
+    private presetClient?;
     private catalogRevision;
     private catalogTasks;
     private runningUpdates;
@@ -55,6 +87,20 @@ export declare class Controller {
     get running(): boolean;
     /** Current title projection, falling back to the list title and then the session ID. */
     get sessionName(): string | undefined;
+    /** Current agent-preset name, matching the web header's built-in labels and custom metadata. */
+    get sessionMode(): string | undefined;
+    /** Load the optional preset roster once per connection, only when a session names a preset. */
+    loadPresetNames(): void;
+    /** Fetch current model routes and adapter-owned reasoning choices for the selected session.
+     * @returns Host catalog; provider failures remain available to the selector.
+     */
+    modelCatalog(): Promise<ObjectValue>;
+    /** Select the next request's model; the host also attempts to save its deployment default.
+     * @param provider - Host provider route ID.
+     * @param model - Exact model ID.
+     * @param reasoningEffort - Optional adapter-owned effort ID; omission uses its default.
+     */
+    selectModel(provider: string, model: string, reasoningEffort?: string): Promise<void>;
     /** Epoch start from the retained turn log, or when this client first observed the run. */
     get workingSince(): number | undefined;
     /** Stop the selected turn, or allow exit only while idle. Repeated keys share one request.
@@ -62,7 +108,7 @@ export declare class Controller {
      * @returns True when the caller may exit; cancellation failures retain the client.
      */
     interrupt(force?: boolean): Promise<boolean>;
-    constructor(base: string, token: string | undefined, initialSession?: string | undefined, makeClient?: () => Client, authenticate?: (client: Client) => Promise<void>, costs?: CostLedger | undefined);
+    constructor(base: string, token: string | undefined, initialSession?: string | undefined, makeClient?: () => Client, authenticate?: (client: Client) => Promise<void>, costs?: CostLedger | undefined, historyLimits?: HistoryLimits);
     /** React-compatible state subscription. */
     subscribe: (listener: () => void) => (() => void);
     /** Snapshot identity changes only when the controller publishes. */
@@ -71,6 +117,12 @@ export declare class Controller {
     start(): void;
     /** Cancel retries and HTTP, close the socket, and wait for the loop to settle. */
     stop(): Promise<void>;
+    /** Keep history stable while the user reads, searches, or expands it; trim again at the live tail.
+     * @param pinned - Whether the main transcript is actively being read away from its tail.
+     */
+    pinHistory(pinned: boolean): void;
+    private reclaimHistory;
+    private releaseTranscript;
     /** Stop the selected turn and then close, so quitting does not leave host work running.
      * An idle session stays untouched, and an in-flight cancellation is awaited rather than repeated.
      */
@@ -81,8 +133,22 @@ export declare class Controller {
      * @param signal - Optional cancellation for an explicit /cost refresh.
      */
     refreshCosts(signal?: AbortSignal): Promise<void>;
+    /** Read one session's complete cost history, retrying a subagent child with its other delivery mode. */
+    private sessionCostHistory;
+    /** Page one addressed session's history into the billing events the ledger folds. */
+    private readCostHistory;
     /** Refresh both lists from the host, then show the requested picker. */
     showPicker(screen: 'workspaces' | 'sessions'): Promise<void>;
+    /** Resolve a removal command to one reviewable object without changing the selection.
+     * @param kind - Workspace registration removal or session archival.
+     * @param query - Exact name, ID, or unambiguous ID prefix.
+     * @returns The fixed identity and display details for confirmation.
+     */
+    removalTarget(kind: 'workspace' | 'session', query: string): Promise<RemovalTarget>;
+    /** Apply a confirmed removal or freshly verified empty-session archival; directories and logs are preserved.
+     * @param target - Exact workspace or session identity reviewed by the user.
+     */
+    removeTarget(target: RemovalTarget): Promise<void>;
     /** Pick a workspace, or use all sessions when the identity is omitted. */
     pickWorkspace(workspaceId?: string): void;
     /** Open a workspace picker, or resolve a workspace by ID, exact title/path, or unique ID prefix. */
@@ -122,7 +188,19 @@ export declare class Controller {
     /** Cancel the active turn; pending queue items remain host-owned. */
     cancelTurn(): Promise<void>;
     /** Add a page before the retained window using its fixed opening cut. */
-    older(signal?: AbortSignal): Promise<void>;
+    older(signal?: AbortSignal, transcript?: Transcript): Promise<void>;
+    /** Search one page at a time, preserving only the first 200 matches and releasing temporary content.
+     * @param query - Literal, case-insensitive text including folded reasoning.
+     * @param signal - Cancels HTTP and processing without cancelling the agent.
+     * @returns Newest-first bounded summaries and an explicit truncation flag.
+     */
+    searchHistory(query: string, signal: AbortSignal): Promise<HistorySearch>;
+    /** Load a separate small window ending at a search target; the live transcript keeps following.
+     * @param target - Durable message sequence to display.
+     * @param signal - Cancels the target-page request.
+     * @returns A caller-owned historical window that must be disposed when closed.
+     */
+    historyAt(target: number, signal: AbortSignal): Promise<Transcript>;
     /** Load the prefix required for an explicit history jump; never loop on an unadvancing page.
      * @param target - Visible record sequence, or first for the oldest available history.
      * @param signal - Cancels local paging without interrupting the remote agent.
@@ -138,7 +216,6 @@ export declare class Controller {
     private get sessionId();
     private update;
     private reply;
-    private releasePending;
     private refreshCatalog;
     private run;
 }