tinker-agent 2.12.0 → 3.0.0

package/src/tui/components/model-picker.tsx

@@ -1,14 +1,14 @@
 import { Box, Text, useInput } from "ink";
 import { useState } from "react";
-import type { ModelProfile } from "../../cli/model-profiles";
+import type { ClientModelProfile } from "../../client/model-catalog";
 
 export type ModelPickerProps = {
-  profiles: readonly ModelProfile[];
+  profiles: readonly ClientModelProfile[];
   currentProfileName?: string;
   isSwitching?: boolean;
   error?: string;
   onCancel: () => void;
-  onSelect: (profile: ModelProfile) => void;
+  onSelect: (profile: ClientModelProfile) => void;
 };
 
 export function ModelPicker(props: ModelPickerProps) {
@@ -89,7 +89,7 @@ function ModelPickerContent(props: ModelPickerProps) {
 }
 
 function ProfileOption(props: {
-  profile: ModelProfile;
+  profile: ClientModelProfile;
   isSelected: boolean;
   isCurrent: boolean;
 }) {
@@ -117,7 +117,7 @@ function ProfileOption(props: {
 }
 
 function initialSelectedIndex(
-  profiles: readonly ModelProfile[],
+  profiles: readonly ClientModelProfile[],
   currentProfileName?: string,
 ): number {
   if (currentProfileName === undefined) {

package/src/tui/components/prompt-input.tsx

@@ -1,3 +1,5 @@
+import type { TuiServiceStatus } from "../tui-session-controller";
+import { TurnCancelledError } from "../../agent/turn-cancellation";
 import os from "node:os";
 import path from "node:path";
 import { Box, Text, useInput, usePaste } from "ink";
@@ -68,6 +70,7 @@ export type PromptInputProps = {
   version?: string;
   workspaceRoot: string;
   gitBranch?: string;
+  serviceStatus?: TuiServiceStatus;
   contextUsage?: ContextUsageSnapshot;
   isDisabled?: boolean;
   placeholder?: string;
@@ -150,7 +153,7 @@ export function PromptInput(props: PromptInputProps) {
 
   useEffect(
     () => () => {
-      operation.current?.abort();
+      operation.current?.abort(new TurnCancelledError("session_dispose"));
     },
     [],
   );
@@ -785,6 +788,18 @@ export function PromptInput(props: PromptInputProps) {
                 <Text color={FOOTER_COLORS.cacheRate}>{cacheRate}</Text>
               </>
             )}
+            {props.serviceStatus === undefined ? null : (
+              <Text
+                dimColor={!props.serviceStatus.error}
+                color={props.serviceStatus.error ? "red" : undefined}
+              >
+                {" · "}
+                {props.serviceStatus.connection}
+                {" · "}
+                {props.serviceStatus.activity}
+                {props.serviceStatus.error ? ` · ${props.serviceStatus.error}` : ""}
+              </Text>
+            )}
             {props.version === undefined ? null : (
               <Text dimColor> · tinker {props.version}</Text>
             )}

package/src/tui/components/resume-session-picker.tsx

@@ -1,6 +1,6 @@
 import { Box, Text, useInput, usePaste, useWindowSize } from "ink";
 import { useReducer, useRef } from "react";
-import type { SessionSummary } from "../../session/session-catalog";
+import type { ClientSessionSummary as SessionSummary } from "../../client/session-client";
 import {
   backspace,
   createLineEditorState,
@@ -470,7 +470,11 @@ function SessionCell(props: {
 }
 
 export function isSessionSelectable(session: SessionSummary): boolean {
-  return session.status === "resumable" || session.status === "interrupted";
+  return (
+    session.canConnect === true ||
+    session.status === "resumable" ||
+    session.status === "interrupted"
+  );
 }
 
 export function formatRelativeTime(updatedAt: string, now: Date): string {

package/src/tui/tui-projection-store.ts

@@ -26,6 +26,8 @@ export type TuiProjectionStoreInput = {
   workspaceRoot: string;
   policy?: TuiProjectionPolicy;
   initialSnapshot?: TuiProjectionState;
+  /** Optional retained transport tail; local terminal scrollback stays unlimited. */
+  committedItemLimit?: number;
 };
 
 export type AssistantStreamSectionItem = Readonly<{
@@ -66,6 +68,7 @@ export class TuiProjectionStore implements EventSink, AssistantTextDeltaSink {
   readonly name = "tui-projection-store";
   private readonly listeners = new Set<() => void>();
   private readonly policy: TuiProjectionPolicy;
+  private readonly committedItemLimit?: number;
   private readonly printed = new Set<string>();
   private readonly physicallyAdoptedIterations = new Map<string, string>();
   private snapshot: TuiProjectionState;
@@ -73,6 +76,12 @@ export class TuiProjectionStore implements EventSink, AssistantTextDeltaSink {
   private assistantStreamAttempt?: AssistantStreamAttempt;
 
   constructor(input: TuiProjectionStoreInput) {
+    if (
+      input.committedItemLimit !== undefined &&
+      (!Number.isSafeInteger(input.committedItemLimit) || input.committedItemLimit < 1)
+    )
+      throw new Error("Committed item limit must be a positive integer.");
+    this.committedItemLimit = input.committedItemLimit;
     this.policy = validateTuiProjectionPolicy(
       input.policy ?? defaultTuiProjectionPolicy,
     );
@@ -82,6 +91,7 @@ export class TuiProjectionStore implements EventSink, AssistantTextDeltaSink {
         : validateInitialSnapshot(input, input.initialSnapshot, this.policy);
     if (input.initialSnapshot !== undefined) {
       this.refreshLog(visibleTimelineItems(this.snapshot));
+      this.retainLog();
     }
   }
 
@@ -279,11 +289,26 @@ export class TuiProjectionStore implements EventSink, AssistantTextDeltaSink {
   }
 
   private notifyListeners(): void {
+    this.retainLog();
     for (const listener of this.listeners) {
       listener();
     }
   }
 
+  private retainLog(): void {
+    if (this.committedItemLimit === undefined) return;
+    this.log = {
+      ...this.log,
+      committed: this.log.committed.slice(-this.committedItemLimit),
+    };
+    // Only IDs still reachable from the bounded projection or transport tail can reappear.
+    const retained = new Set([
+      ...timelineStreamItems(this.snapshot).map((item) => item.id),
+      ...this.log.committed.map((item) => item.id),
+    ]);
+    for (const id of this.printed) if (!retained.has(id)) this.printed.delete(id);
+  }
+
   private refreshLog(stream = timelineStreamItems(this.snapshot)): void {
     const settledEnd = firstRunningIndex(stream);
     const pending = stream

package/src/tui/tui-session-controller.ts

@@ -1,286 +1,16 @@
-import type {
-  ContextCompactionResult,
-  ContextRetirementResult,
-} from "../context/context-manager";
-import type {
-  ExecuteTurnInput,
-  AcceptedTurn,
-  AskUserSnapshot,
-  AskUserResolution,
-  BashGuardSnapshot,
-  RuntimeSession,
-  RuntimeSkillsSnapshot,
-  SessionDisposeReason,
-} from "../agent/runtime-session";
-import type { RunAgentResult, UserMessage } from "../agent/types";
-import type { TurnUndoResult } from "../tools/turn-undo-manager";
-import type { ImageAssetRef } from "../image/image-types";
-import type { ImportedImageAsset } from "../image/image-asset-store";
-import type { SessionId } from "../ids/runtime-id";
-import { createUuidV7 } from "../ids/uuid-v7";
-import type { ModelProfile } from "../cli/model-profiles";
-import type { McpInventorySnapshot } from "../mcp/mcp-manager";
-import type { ReasoningEffortSnapshot } from "../model/reasoning-effort";
-import { SessionCatalog, type SessionSummary } from "../session/session-catalog";
+import type { SessionClient, WorkspaceClient } from "../client/session-client";
 import type { TuiProjectionStore } from "./tui-projection-store";
 
-export type TuiSessionBinding = {
-  sessionId: SessionId;
-  modelName: string;
-  workspaceRoot: string;
-  profileName?: string;
-  projectionStore: TuiProjectionStore;
-  skills(): RuntimeSkillsSnapshot;
-  mcp(): McpInventorySnapshot;
-  reasoningEffort?: () => ReasoningEffortSnapshot | undefined;
-  setReasoningEffort?: (effort: string) => ReasoningEffortSnapshot;
-  resetReasoningEffort?: () => ReasoningEffortSnapshot;
-  supportsImageInput?: () => boolean;
-  importImage?: (
-    sourcePath: string,
-    signal: AbortSignal,
-    prospectiveMessageImageCount: number,
-  ) => Promise<ImportedImageAsset>;
-  verifyImageAssets?: (
-    assets: readonly ImageAssetRef[],
-    signal: AbortSignal,
-  ) => Promise<void>;
-  admitTurn?: (userMessage: UserMessage, signal: AbortSignal) => Promise<AcceptedTurn>;
-  executeTurn(userMessage: UserMessage, signal: AbortSignal): Promise<RunAgentResult>;
-  promptScheduler?: RuntimeSession["promptScheduler"];
-  subscribePromptScheduler?: RuntimeSession["subscribePromptScheduler"];
-  queueFollowUp?: RuntimeSession["queueFollowUp"];
-  bashGuard(): BashGuardSnapshot;
-  subscribeBashGuard(listener: () => void): () => void;
-  setYoloMode(enabled: boolean): void;
-  resolveBashConfirmation(decision: "allow" | "deny"): Promise<void>;
-  providerRetry?: RuntimeSession["providerRetry"];
-  subscribeProviderRetry?: RuntimeSession["subscribeProviderRetry"];
-  resolveProviderRetry?: RuntimeSession["resolveProviderRetry"];
-  askUser(): AskUserSnapshot;
-  subscribeAskUser(listener: () => void): () => void;
-  resolveAskUser(response: AskUserResolution): Promise<void>;
-};
-
-export type TuiSessionController = {
-  getBinding: () => TuiSessionBinding;
-  subscribe: (listener: () => void) => () => void;
-  listSessions: () => Promise<readonly SessionSummary[]>;
-  compact: () => Promise<ContextCompactionResult>;
-  retire: () => Promise<ContextRetirementResult>;
-  undo: () => Promise<TurnUndoResult>;
-  fork: (beforeCommit?: () => void) => Promise<SessionId>;
-  clear: (beforeCommit?: () => void) => Promise<void>;
-  resume: (sessionId: SessionId, beforeCommit?: () => void) => Promise<void>;
-  delete: (sessionId: SessionId) => Promise<void>;
-  switchModel: (profile: ModelProfile, beforeCommit?: () => void) => Promise<void>;
-};
+export type TuiServiceStatus = { connection: string; activity: string; error?: string };
 
-export type ManagedTuiSessionBinding = TuiSessionBinding & {
-  runtimeSession: RuntimeSession;
+/** Read-only presentation surface; the client adapter owns event ingestion. */
+export type TuiSessionView = Pick<
+  TuiProjectionStore,
+  "getSnapshot" | "getLogSnapshot" | "subscribe"
+> & {
+  getServiceStatus?: () => TuiServiceStatus;
+  /** Changes when canonical recovery replaces previously printed rows. */
+  getPresentationRevision?: () => string | undefined;
 };
-
-export class DefaultTuiSessionController implements TuiSessionController {
-  private readonly listeners = new Set<() => void>();
-  private binding: ManagedTuiSessionBinding;
-  private operation?: Promise<unknown>;
-
-  constructor(
-    initial: ManagedTuiSessionBinding,
-    private readonly catalog: SessionCatalog,
-    private readonly openSession: (
-      sessionId: SessionId,
-    ) => Promise<ManagedTuiSessionBinding>,
-    private readonly createSessionWithProfile: (
-      profile: ModelProfile,
-    ) => Promise<ManagedTuiSessionBinding>,
-    private readonly createFreshSession: (
-      current: TuiSessionBinding,
-    ) => Promise<ManagedTuiSessionBinding>,
-  ) {
-    this.binding = initial;
-  }
-
-  readonly getBinding = (): TuiSessionBinding => this.binding;
-
-  readonly subscribe = (listener: () => void): (() => void) => {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  };
-
-  listSessions(): Promise<readonly SessionSummary[]> {
-    return this.catalog.listAll(this.binding.sessionId);
-  }
-
-  compact(): Promise<ContextCompactionResult> {
-    return this.serialize(() => this.binding.runtimeSession.compactContext());
-  }
-
-  retire(): Promise<ContextRetirementResult> {
-    return this.serialize(() => this.binding.runtimeSession.retireContext());
-  }
-
-  undo(): Promise<TurnUndoResult> {
-    return this.serialize(() =>
-      this.binding.runtimeSession.undoLatestFileMutationTurn(),
-    );
-  }
-
-  fork(beforeCommit?: () => void): Promise<SessionId> {
-    return this.serialize(async () => {
-      const targetSessionId = createUuidV7() as SessionId;
-      await this.replaceSession(
-        "Cannot clone the session while a turn, context operation, or background task is active.",
-        async (current) => {
-          await current.runtimeSession.cloneSession(targetSessionId);
-          return this.openSession(targetSessionId);
-        },
-        beforeCommit,
-      );
-      return targetSessionId;
-    });
-  }
-
-  clear(beforeCommit?: () => void): Promise<void> {
-    return this.serialize(() =>
-      this.replaceSession(
-        "Cannot clear the session while a turn, context operation, or background task is active.",
-        (current) => this.createFreshSession(current),
-        beforeCommit,
-      ),
-    );
-  }
-
-  resume(sessionId: SessionId, beforeCommit?: () => void): Promise<void> {
-    return this.serialize(async () => {
-      if (sessionId === this.binding.sessionId) {
-        throw new Error(`Session ${sessionId} is already current.`);
-      }
-      await this.replaceSession(
-        "Cannot switch sessions while a turn or background task is active.",
-        () => this.openSession(sessionId),
-        beforeCommit,
-      );
-    });
-  }
-
-  delete(sessionId: SessionId): Promise<void> {
-    return this.serialize(() => this.catalog.delete(sessionId, this.binding.sessionId));
-  }
-
-  switchModel(profile: ModelProfile, beforeCommit?: () => void): Promise<void> {
-    return this.serialize(() =>
-      this.replaceSession(
-        "Cannot switch models while a turn or background task is active.",
-        () => this.createSessionWithProfile(profile),
-        beforeCommit,
-      ),
-    );
-  }
-
-  dispose(reason: SessionDisposeReason): Promise<void> {
-    return this.binding.runtimeSession.dispose(reason);
-  }
-
-  private async replaceSession(
-    unavailableMessage: string,
-    createTarget: (
-      current: ManagedTuiSessionBinding,
-    ) => Promise<ManagedTuiSessionBinding>,
-    beforeCommit?: () => void,
-  ): Promise<void> {
-    const current = this.binding;
-    if (!current.runtimeSession.canSwitchSession()) {
-      throw new Error(unavailableMessage);
-    }
-
-    const target = await createTarget(current);
-    try {
-      await current.runtimeSession.dispose({ type: "session_switch" });
-    } catch (error) {
-      await target.runtimeSession
-        .dispose({ type: "runner_failed", error: errorMessage(error) })
-        .catch(() => undefined);
-      throw error;
-    }
-    beforeCommit?.();
-    this.binding = target;
-    for (const listener of this.listeners) {
-      listener();
-    }
-  }
-
-  private serialize<T>(operation: () => Promise<T>): Promise<T> {
-    if (this.operation !== undefined) {
-      return Promise.reject(new Error("Another session operation is already running."));
-    }
-    const pending = operation().finally(() => {
-      if (this.operation === pending) {
-        this.operation = undefined;
-      }
-    });
-    this.operation = pending;
-    return pending;
-  }
-}
-
-export function managedTuiBinding(input: {
-  runtimeSession: RuntimeSession;
-  modelName: string;
-  workspaceRoot: string;
-  profileName?: string;
-  projectionStore: TuiProjectionStore;
-}): ManagedTuiSessionBinding {
-  return {
-    sessionId: input.runtimeSession.sessionId,
-    modelName: input.modelName,
-    workspaceRoot: input.workspaceRoot,
-    profileName: input.profileName,
-    projectionStore: input.projectionStore,
-    runtimeSession: input.runtimeSession,
-    skills: () => input.runtimeSession.skills(),
-    mcp: () => input.runtimeSession.mcp(),
-    reasoningEffort: () => input.runtimeSession.reasoningEffort(),
-    setReasoningEffort: (effort) => input.runtimeSession.setReasoningEffort(effort),
-    resetReasoningEffort: () => input.runtimeSession.resetReasoningEffort(),
-    supportsImageInput: () => input.runtimeSession.supportsImageInput(),
-    importImage: (sourcePath, signal, prospectiveMessageImageCount) =>
-      input.runtimeSession.importImage(
-        sourcePath,
-        signal,
-        prospectiveMessageImageCount,
-      ),
-    verifyImageAssets: (assets, signal) =>
-      input.runtimeSession.verifyImageAssets(assets, signal),
-    admitTurn: (userMessage, signal) =>
-      input.runtimeSession.admitTurn({ userMessage, signal }),
-    executeTurn: (userMessage, signal) =>
-      input.runtimeSession.executeTurn({
-        userMessage,
-        signal,
-      } satisfies ExecuteTurnInput),
-    promptScheduler: () => input.runtimeSession.promptScheduler(),
-    subscribePromptScheduler: (listener) =>
-      input.runtimeSession.subscribePromptScheduler(listener),
-    queueFollowUp: (userMessage) => input.runtimeSession.queueFollowUp(userMessage),
-    bashGuard: () => input.runtimeSession.bashGuard(),
-    subscribeBashGuard: (listener) => input.runtimeSession.subscribeBashGuard(listener),
-    setYoloMode: (enabled) => input.runtimeSession.setYoloMode(enabled),
-    resolveBashConfirmation: (decision) =>
-      input.runtimeSession.resolveBashConfirmation(decision),
-    providerRetry: () => input.runtimeSession.providerRetry(),
-    subscribeProviderRetry: (listener) =>
-      input.runtimeSession.subscribeProviderRetry(listener),
-    resolveProviderRetry: (requestId, decision) =>
-      input.runtimeSession.resolveProviderRetry(requestId, decision),
-    askUser: () => input.runtimeSession.askUser(),
-    subscribeAskUser: (listener) => input.runtimeSession.subscribeAskUser(listener),
-    resolveAskUser: (response) => input.runtimeSession.resolveAskUser(response),
-  };
-}
-
-function errorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
+export type TuiSessionBinding = SessionClient<TuiSessionView>;
+export type TuiSessionController = WorkspaceClient<TuiSessionView>;