tinker-agent 1.5.1 → 1.6.0

package/src/tui/components/footer.tsx

@@ -3,9 +3,11 @@ import { Spinner, StatusMessage } from "@inkjs/ui";
 export type FooterProps = {
   status: "idle" | "running" | "cancelling" | "cancelled" | "done" | "failed";
   workedForMs?: number;
+  yolo?: boolean;
 };
 
 export function Footer(props: FooterProps) {
+  const suffix = props.yolo ? " · yolo" : "";
   if (props.status === "done") {
     if (props.workedForMs === undefined) {
       throw new Error("Done footer requires workedForMs");
@@ -14,27 +16,28 @@ export function Footer(props: FooterProps) {
     return (
       <StatusMessage variant="success">
         Worked for {formatDuration(props.workedForMs)}
+        {suffix}
       </StatusMessage>
     );
   }
 
   if (props.status === "failed") {
-    return <StatusMessage variant="error">failed</StatusMessage>;
+    return <StatusMessage variant="error">failed{suffix}</StatusMessage>;
   }
 
   if (props.status === "running") {
-    return <Spinner label="Running" />;
+    return <Spinner label={`Running${suffix}`} />;
   }
 
   if (props.status === "cancelling") {
-    return <StatusMessage variant="info">cancelling</StatusMessage>;
+    return <StatusMessage variant="info">cancelling{suffix}</StatusMessage>;
   }
 
   if (props.status === "cancelled") {
-    return <StatusMessage variant="info">cancelled</StatusMessage>;
+    return <StatusMessage variant="info">cancelled{suffix}</StatusMessage>;
   }
 
-  return <StatusMessage variant="info">idle</StatusMessage>;
+  return <StatusMessage variant="info">idle{suffix}</StatusMessage>;
 }
 
 function formatDuration(durationMs: number): string {

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

@@ -9,7 +9,10 @@ import { ImageNotRecognizedError } from "../../image/image-probe";
 import type { ImportedImageAsset } from "../../image/image-asset-store";
 import type { ImageAssetRef } from "../../image/image-types";
 import { runtimeIdFactory, type RuntimeIdFactory } from "../../ids/runtime-id";
-import { formatContextUsageLine } from "../context-format";
+import {
+  formatContextUsageLine,
+  formatLatestProviderCacheRate,
+} from "../context-format";
 import {
   type FileMentionMatch,
   findFileMention,
@@ -722,6 +725,9 @@ export function PromptInput(props: PromptInputProps) {
   const showFileSuggestions = filePopupActive;
   const showSlashSuggestions = suggestions.length > 0 && !locked;
   const showSuggestions = showFileSuggestions || showSlashSuggestions;
+  const cacheRate = formatLatestProviderCacheRate(
+    props.contextUsage?.lastProviderUsage,
+  );
   return (
     <Box flexDirection="column">
       <Box width="100%" borderStyle="single" borderLeft={false} borderRight={false}>
@@ -745,6 +751,12 @@ export function PromptInput(props: PromptInputProps) {
               </Text>
             </>
           )}
+          {cacheRate === undefined ? null : (
+            <>
+              <Text dimColor> · </Text>
+              <Text dimColor>{cacheRate}</Text>
+            </>
+          )}
         </Box>
       )}
       {showFileSuggestions ? (

package/src/tui/components/timeline.tsx

@@ -1,6 +1,7 @@
 import { Box, Text } from "ink";
 import { Fragment } from "react";
 import type { TimelineItem } from "../event-store";
+import type { AssistantStreamSectionItem } from "../tui-projection-store";
 import { AssistantMarkdown } from "./assistant-markdown";
 import { BashResultView } from "./bash-result-view";
 import { DiffView } from "./diff-view";
@@ -54,6 +55,15 @@ export function TimelineRow(props: { item: TimelineItem }) {
   );
 }
 
+export function AssistantStreamSectionRow(props: { item: AssistantStreamSectionItem }) {
+  return (
+    <Fragment>
+      {props.item.showAssistantLabel ? <Text color="gray">- assistant</Text> : null}
+      <AssistantMarkdown text={props.item.markdown} />
+    </Fragment>
+  );
+}
+
 function renderUserPrompt(prompt: NonNullable<TimelineItem["userPrompt"]>) {
   const chars = [...prompt.text];
   const fragments: React.ReactNode[] = [];

package/src/tui/context-format.ts

@@ -1,4 +1,21 @@
 import type { ContextUsageSnapshot } from "../agent/context-meter";
+import type { ModelUsage } from "../model/model-client";
+
+export function formatLatestProviderCacheRate(
+  usage: ModelUsage | undefined,
+): string | undefined {
+  const hit = usage?.promptCacheHitTokens;
+  const miss = usage?.promptCacheMissTokens;
+  if (hit === undefined || miss === undefined || hit + miss === 0) {
+    return undefined;
+  }
+  // Floor instead of round: an append turn is never a true 100% hit, and
+  // rounding would display 99.5%+ as a misleading "cache 100%". A genuine
+  // full hit (miss === 0, e.g. an identical resent request) still floors to
+  // exactly 100. The min() guards against float rounding when miss > 0.
+  const percent = Math.min(99, Math.floor((hit / (hit + miss)) * 100));
+  return `cache ${miss === 0 ? 100 : percent}%`;
+}
 
 export function formatContextUsageLine(
   usage: Pick<

package/src/tui/event-store.ts

@@ -3,7 +3,7 @@ import {
   bashResultDetail,
   type BashDisplayDetail,
 } from "../events/bash-result-detail";
-import type { AgentEvent } from "../events/types";
+import type { AgentEvent, ModelRequestFailedData } from "../events/types";
 import type { ContextUsageSnapshot } from "../agent/context-meter";
 import type {
   ModelContextBudget,
@@ -162,12 +162,21 @@ export function reduceTuiProjection(
             })
           : updateTurnItem(turn, modelRequestRef(event.iterationId), (item) => ({
               ...item,
-              text: `model iteration ${event.iterationNumber} · retrying`,
+              text: `model iteration ${event.iterationNumber} · retrying (attempt ${event.data.attemptNumber}/${event.data.maxAttempts})`,
               status: "running",
             })),
       );
     case "model.request.failed":
-      return state;
+      if (event.data.retryDisposition !== "scheduled") {
+        return state;
+      }
+      return updateActiveTurn(state, event, policy, (turn) =>
+        updateTurnItem(turn, modelRequestRef(event.iterationId), (item) => ({
+          ...item,
+          text: `model iteration ${requireEventNumber(event.iterationNumber, "model.request.failed iterationNumber")} · ${modelRequestRetryText(event.data)}`,
+          status: "running",
+        })),
+      );
     case "model.request.finished":
       return updateActiveTurn(state, event, policy, (turn) =>
         updateTurnItem(turn, modelRequestRef(event.iterationId), (item) => ({
@@ -214,6 +223,37 @@ export function reduceTuiProjection(
           status: event.data.ok ? "ok" : "failed",
         })),
       );
+    case "tool.confirmation.requested":
+      return updateActiveTurn(state, event, policy, (turn) =>
+        updateTurnItem(
+          turn,
+          toolCallRef(
+            requireEventString(
+              event.toolCallId,
+              "tool.confirmation.requested toolCallId",
+            ),
+          ),
+          (item) => ({
+            ...item,
+            text: `Bash confirmation requested · ${event.data.reason}`,
+            status: "running",
+          }),
+        ),
+      );
+    case "tool.confirmation.resolved":
+      return updateActiveTurn(state, event, policy, (turn) =>
+        appendTurnItem(turn, {
+          id: `confirmation-${event.toolCallId}-${event.eventSequence}`,
+          label: "bash guard",
+          text: `${event.data.decision} · ${event.data.reason}`,
+          status:
+            event.data.decision === "allow"
+              ? "ok"
+              : event.data.decision === "cancelled"
+                ? "cancelled"
+                : "failed",
+        }),
+      );
     case "bash.task.backgrounded":
     case "bash.task.stopping":
     case "bash.task.finished":
@@ -679,6 +719,21 @@ export function completedModelRequestText(
   return `model iteration ${iterationNumber} -> assistant response`;
 }
 
+function modelRequestRetryText(data: ModelRequestFailedData): string {
+  const attempt = `attempt ${data.attemptNumber + 1}/${data.maxAttempts}`;
+  if (data.retryDelayMs !== undefined && data.retryDelayMs > 0) {
+    const seconds = Math.max(1, Math.round(data.retryDelayMs / 1000));
+    const reason =
+      data.code === "provider_rate_limited"
+        ? "rate limited"
+        : data.code === "provider_unavailable"
+          ? "provider unavailable"
+          : data.code;
+    return `${reason} · retrying in ${seconds}s (${attempt})`;
+  }
+  return `retrying (${attempt})`;
+}
+
 export function toolCallStartedProjection(input: {
   name: string;
   args: unknown;
@@ -774,6 +829,8 @@ function toolRawResultSummary(name: string, args: unknown, raw: ToolRawResult):
         ? base
         : `${base} -> ${raw.bytesWritten} bytes`;
     }
+    case "delete":
+      return `${base} -> deleted`;
     case "web_search":
       return raw.resultCount === undefined
         ? base
@@ -857,6 +914,7 @@ function toolRawResultBashDetail(raw: ToolRawResult): Pick<TimelineItem, "bash">
     case "read":
     case "write":
     case "edit":
+    case "delete":
     case "glob":
     case "grep":
     case "task_list":
@@ -890,6 +948,7 @@ function toolRawResultDiff(
             diffTruncated: raw.patchTruncated === true,
           };
     case "read":
+    case "delete":
     case "glob":
     case "grep":
     case "bash":

package/src/tui/slash-commands.ts

@@ -24,6 +24,11 @@ export const SLASH_COMMANDS: readonly BuiltInSlashCommand[] = [
     usage: "/mcp",
     description: "Show MCP servers and runtime tools",
   },
+  {
+    name: "yolo",
+    usage: "/yolo [on|off]",
+    description: "Show or change destructive Bash confirmation",
+  },
   {
     name: "memory",
     usage: "/memory",
@@ -34,6 +39,11 @@ export const SLASH_COMMANDS: readonly BuiltInSlashCommand[] = [
     usage: "/compact [retire]",
     description: "Swap tool output or retire a cold history prefix",
   },
+  {
+    name: "undo",
+    usage: "/undo",
+    description: "Undo the latest Write/Edit/Delete turn",
+  },
   {
     name: "clear",
     usage: "/clear",
@@ -70,11 +80,14 @@ export const SLASH_COMMANDS: readonly BuiltInSlashCommand[] = [
 
 export type ParsedSlashCommand =
   | { type: "status" }
+  | { type: "yolo_status" }
+  | { type: "yolo"; enabled: boolean }
   | { type: "skills" }
   | { type: "mcp" }
   | { type: "memory" }
   | { type: "compact" }
   | { type: "compact_retire" }
+  | { type: "undo" }
   | { type: "clear" }
   | { type: "fork" }
   | { type: "view"; filePath: string }
@@ -111,6 +124,15 @@ export function parseSlashCommand(input: string): ParsedSlashCommand {
   if (command === "/status" && tokens.length === 1) {
     return { type: "status" };
   }
+  if (command === "/yolo") {
+    if (tokens.length === 1) {
+      return { type: "yolo_status" };
+    }
+    if (tokens.length === 2 && (tokens[1] === "on" || tokens[1] === "off")) {
+      return { type: "yolo", enabled: tokens[1] === "on" };
+    }
+    throw slashCommandUsageError("yolo");
+  }
   if (command === "/skills" && tokens.length === 1) {
     return { type: "skills" };
   }
@@ -135,6 +157,12 @@ export function parseSlashCommand(input: string): ParsedSlashCommand {
     }
     throw slashCommandUsageError("compact");
   }
+  if (command === "/undo") {
+    if (tokens.length === 1) {
+      return { type: "undo" };
+    }
+    throw slashCommandUsageError("undo");
+  }
   if (command === "/clear") {
     if (tokens.length === 1) {
       return { type: "clear" };

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

@@ -1,5 +1,9 @@
 import type { EventSink } from "../events/event-sink";
 import type { AgentEvent } from "../events/types";
+import type {
+  AssistantTextDeltaSink,
+  AssistantTextDeltaUpdate,
+} from "../agent/assistant-text-delta";
 import {
   createInitialTuiProjectionState,
   firstRunningIndex,
@@ -14,6 +18,7 @@ import {
   type TuiProjectionPolicy,
   validateTuiProjectionPolicy,
 } from "./tui-projection-policy";
+import { MarkdownSectionFramer } from "./assistant-markdown-section-framer";
 
 export type TuiProjectionStoreInput = {
   sessionId: string;
@@ -23,18 +28,49 @@ export type TuiProjectionStoreInput = {
   initialSnapshot?: TuiProjectionState;
 };
 
+export type AssistantStreamSectionItem = Readonly<{
+  kind: "assistant-stream-section";
+  id: string;
+  iterationId: string;
+  attemptNumber: number;
+  sectionNumber: number;
+  markdown: string;
+  showAssistantLabel: boolean;
+}>;
+
+export type TuiCommittedItem = TimelineItem | AssistantStreamSectionItem;
+
+export function isAssistantStreamSectionItem(
+  item: TuiCommittedItem,
+): item is AssistantStreamSectionItem {
+  return "kind" in item && item.kind === "assistant-stream-section";
+}
+
 export type TuiTimelineLog = Readonly<{
-  committed: readonly TimelineItem[];
+  committed: readonly TuiCommittedItem[];
   live: readonly TimelineItem[];
 }>;
 
-export class TuiProjectionStore implements EventSink {
+type AssistantStreamAttempt = {
+  readonly sessionId: string;
+  readonly turnId: string;
+  readonly turnNumber: number;
+  readonly iterationId: string;
+  readonly iterationNumber: number;
+  readonly attemptNumber: number;
+  readonly framer: MarkdownSectionFramer;
+  sectionCount: number;
+};
+
+export class TuiProjectionStore implements EventSink, AssistantTextDeltaSink {
   readonly name = "tui-projection-store";
   private readonly listeners = new Set<() => void>();
   private readonly policy: TuiProjectionPolicy;
   private readonly printed = new Set<string>();
+  private readonly physicallyAdoptedIterations = new Map<string, string>();
   private snapshot: TuiProjectionState;
   private log: TuiTimelineLog = { committed: [], live: [] };
+  private assistantStreamAttempt?: AssistantStreamAttempt;
 
   constructor(input: TuiProjectionStoreInput) {
     this.policy = validateTuiProjectionPolicy(
@@ -62,15 +98,40 @@ export class TuiProjectionStore implements EventSink {
 
   async append(event: AgentEvent): Promise<void> {
     const next = reduceTuiProjection(this.snapshot, event, this.policy);
-    if (next === this.snapshot) {
+    const snapshotChanged = next !== this.snapshot;
+    this.snapshot = next;
+    const presentationChanged = this.applyAssistantStreamEvent(event);
+    if (!snapshotChanged && !presentationChanged) {
       return;
     }
 
-    this.snapshot = next;
-    this.refreshLog();
-    for (const listener of this.listeners) {
-      listener();
+    if (snapshotChanged) {
+      this.refreshLog();
+    }
+    this.notifyListeners();
+  }
+
+  updateAssistantTextDelta(update: AssistantTextDeltaUpdate): void {
+    const attempt = this.assistantStreamAttempt;
+    if (
+      attempt === undefined ||
+      update.content === "" ||
+      !sameAssistantStreamAttempt(attempt, update)
+    ) {
+      return;
+    }
+
+    const frames = attempt.framer.push(update.content);
+    if (frames.length === 0) {
+      return;
+    }
+    const committed = [...this.log.committed];
+    for (const frame of frames) {
+      attempt.sectionCount += 1;
+      committed.push(this.sectionItem(attempt, frame.markdown));
     }
+    this.log = { committed, live: this.log.live };
+    this.notifyListeners();
   }
 
   hydrate(snapshot: TuiProjectionState): void {
@@ -91,6 +152,130 @@ export class TuiProjectionStore implements EventSink {
       this.policy,
     );
     this.refreshLog(visibleTimelineItems(this.snapshot));
+    this.notifyListeners();
+  }
+
+  private applyAssistantStreamEvent(event: AgentEvent): boolean {
+    switch (event.type) {
+      case "model.request.started":
+        this.assistantStreamAttempt = assistantStreamAttempt(event);
+        return false;
+      case "model.request.failed":
+        return this.failAssistantStreamAttempt(event);
+      case "model.request.finished":
+        return this.finishAssistantStreamAttempt(event);
+      case "assistant.progress":
+        if (
+          event.iterationId !== undefined &&
+          this.physicallyAdoptedIterations.has(event.iterationId)
+        ) {
+          this.printed.add(`assistant-${event.iterationId}-${event.eventSequence}`);
+        }
+        return false;
+      case "turn.finished": {
+        const adopted = this.physicallyAdoptedIterations.has(
+          event.data.lastIteration.iterationId,
+        );
+        if (adopted) {
+          this.printed.add(`turn-${event.turnId}-final-${event.eventSequence}`);
+        }
+        this.clearAdoptedTurn(event.turnId);
+        this.assistantStreamAttempt = undefined;
+        return false;
+      }
+      case "turn.failed":
+      case "turn.cancelled":
+        this.clearAdoptedTurn(event.turnId);
+        this.assistantStreamAttempt = undefined;
+        return false;
+      case "session.finished":
+        this.physicallyAdoptedIterations.clear();
+        this.assistantStreamAttempt = undefined;
+        return false;
+      default:
+        return false;
+    }
+  }
+
+  private failAssistantStreamAttempt(
+    event: Extract<AgentEvent, { type: "model.request.failed" }>,
+  ): boolean {
+    const attempt = this.assistantStreamAttempt;
+    if (attempt === undefined || !sameAssistantStreamEvent(attempt, event)) {
+      return false;
+    }
+    this.assistantStreamAttempt = undefined;
+    if (event.data.retryDisposition !== "scheduled" || attempt.sectionCount === 0) {
+      return false;
+    }
+    this.appendCommitted({
+      id: `assistant-stream-retry-${attempt.iterationId}-${attempt.attemptNumber}`,
+      text: "assistant response interrupted · retrying",
+      status: "info",
+    });
+    return true;
+  }
+
+  private finishAssistantStreamAttempt(
+    event: Extract<AgentEvent, { type: "model.request.finished" }>,
+  ): boolean {
+    const attempt = this.assistantStreamAttempt;
+    if (attempt === undefined || !sameAssistantStreamEvent(attempt, event)) {
+      return false;
+    }
+    this.assistantStreamAttempt = undefined;
+    const result = attempt.framer.finish();
+    if (
+      attempt.sectionCount === 0 ||
+      result.content !== (event.data.output.message.content ?? "")
+    ) {
+      return false;
+    }
+
+    this.printed.add(`model-${attempt.iterationId}`);
+    this.physicallyAdoptedIterations.set(attempt.iterationId, attempt.turnId);
+    if (result.tail === "") {
+      return false;
+    }
+    attempt.sectionCount += 1;
+    this.appendCommitted(this.sectionItem(attempt, result.tail));
+    return true;
+  }
+
+  private sectionItem(
+    attempt: AssistantStreamAttempt,
+    markdown: string,
+  ): AssistantStreamSectionItem {
+    return Object.freeze({
+      kind: "assistant-stream-section",
+      id: `assistant-stream-${attempt.iterationId}-${attempt.attemptNumber}-${attempt.sectionCount}`,
+      iterationId: attempt.iterationId,
+      attemptNumber: attempt.attemptNumber,
+      sectionNumber: attempt.sectionCount,
+      markdown,
+      showAssistantLabel: attempt.sectionCount === 1,
+    });
+  }
+
+  private appendCommitted(item: TuiCommittedItem): void {
+    this.log = {
+      committed: [...this.log.committed, item],
+      live: this.log.live,
+    };
+  }
+
+  private clearAdoptedTurn(turnId: string | undefined): void {
+    if (turnId === undefined) {
+      return;
+    }
+    for (const [iterationId, adoptedTurnId] of this.physicallyAdoptedIterations) {
+      if (adoptedTurnId === turnId) {
+        this.physicallyAdoptedIterations.delete(iterationId);
+      }
+    }
+  }
+
+  private notifyListeners(): void {
     for (const listener of this.listeners) {
       listener();
     }
@@ -112,6 +297,60 @@ export class TuiProjectionStore implements EventSink {
   }
 }
 
+function assistantStreamAttempt(
+  event: Extract<AgentEvent, { type: "model.request.started" }>,
+): AssistantStreamAttempt | undefined {
+  if (
+    event.turnId === undefined ||
+    event.turnNumber === undefined ||
+    event.iterationId === undefined ||
+    event.iterationNumber === undefined
+  ) {
+    return undefined;
+  }
+  return {
+    sessionId: event.sessionId,
+    turnId: event.turnId,
+    turnNumber: event.turnNumber,
+    iterationId: event.iterationId,
+    iterationNumber: event.iterationNumber,
+    attemptNumber: event.data.attemptNumber,
+    framer: new MarkdownSectionFramer(),
+    sectionCount: 0,
+  };
+}
+
+function sameAssistantStreamAttempt(
+  attempt: AssistantStreamAttempt,
+  update: AssistantTextDeltaUpdate,
+): boolean {
+  return (
+    attempt.sessionId === update.sessionId &&
+    attempt.turnId === update.turnId &&
+    attempt.turnNumber === update.turnNumber &&
+    attempt.iterationId === update.iterationId &&
+    attempt.iterationNumber === update.iterationNumber &&
+    attempt.attemptNumber === update.attemptNumber
+  );
+}
+
+function sameAssistantStreamEvent(
+  attempt: AssistantStreamAttempt,
+  event: Extract<
+    AgentEvent,
+    { type: "model.request.failed" | "model.request.finished" }
+  >,
+): boolean {
+  return (
+    attempt.sessionId === event.sessionId &&
+    attempt.turnId === event.turnId &&
+    attempt.turnNumber === event.turnNumber &&
+    attempt.iterationId === event.iterationId &&
+    attempt.iterationNumber === event.iterationNumber &&
+    attempt.attemptNumber === event.data.attemptNumber
+  );
+}
+
 function validateInitialSnapshot(
   input: Pick<TuiProjectionStoreInput, "sessionId" | "modelName" | "workspaceRoot">,
   snapshot: TuiProjectionState,

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

@@ -5,11 +5,13 @@ import type {
 import type {
   ExecuteTurnInput,
   AcceptedTurn,
+  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";
@@ -39,6 +41,10 @@ export type TuiSessionBinding = {
   ) => Promise<void>;
   admitTurn?: (userMessage: UserMessage, signal: AbortSignal) => Promise<AcceptedTurn>;
   executeTurn(userMessage: UserMessage, signal: AbortSignal): Promise<RunAgentResult>;
+  bashGuard(): BashGuardSnapshot;
+  subscribeBashGuard(listener: () => void): () => void;
+  setYoloMode(enabled: boolean): void;
+  resolveBashConfirmation(decision: "allow" | "deny"): Promise<void>;
 };
 
 export type TuiSessionController = {
@@ -47,6 +53,7 @@ export type TuiSessionController = {
   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>;
@@ -100,6 +107,12 @@ export class DefaultTuiSessionController implements TuiSessionController {
     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;
@@ -230,6 +243,11 @@ export function managedTuiBinding(input: {
         userMessage,
         signal,
       } satisfies ExecuteTurnInput),
+    bashGuard: () => input.runtimeSession.bashGuard(),
+    subscribeBashGuard: (listener) => input.runtimeSession.subscribeBashGuard(listener),
+    setYoloMode: (enabled) => input.runtimeSession.setYoloMode(enabled),
+    resolveBashConfirmation: (decision) =>
+      input.runtimeSession.resolveBashConfirmation(decision),
   };
 }