tinker-agent 1.5.0 → 1.6.0

package/src/agent/runtime-session.ts

@@ -73,8 +73,13 @@ import {
 } from "../context/compiled-context-hash";
 import { createDefaultTooling, type DefaultTooling } from "../tools/registry";
 import type { ToolExecutor } from "../tools/types";
+import type { TurnUndoResult } from "../tools/turn-undo-manager";
 import type { Refiner } from "../tools/web-fetch/refiner";
 import type { ProjectInstructionManifest } from "../instructions/project-instructions";
+import type {
+  AssistantTextDeltaSink,
+  AssistantTextDeltaUpdate,
+} from "./assistant-text-delta";
 import {
   SessionStore,
   createSessionCompatibilityContract,
@@ -91,7 +96,7 @@ import {
   type AdmissionBaseToken,
   type SessionLedger,
 } from "./session-ledger";
-import { TurnCancelledError } from "./turn-cancellation";
+import { cancellationError, TurnCancelledError } from "./turn-cancellation";
 import type { ToolCompletionInput } from "../context/protocol-frame";
 import type { BuiltContextRequest } from "../context/context-revision";
 import type { CommittedToolCompletion } from "./session-ledger";
@@ -159,11 +164,27 @@ export type RuntimeSession = {
   executeTurn(input: ExecuteTurnInput): Promise<RunAgentResult>;
   compactContext(): Promise<ContextCompactionResult>;
   retireContext(): Promise<ContextRetirementResult>;
+  undoLatestFileMutationTurn(): Promise<TurnUndoResult>;
   cloneSession(targetSessionId: SessionId): Promise<void>;
   canSwitchSession(): boolean;
+  bashGuard(): BashGuardSnapshot;
+  subscribeBashGuard(listener: () => void): () => void;
+  setYoloMode(enabled: boolean): void;
+  resolveBashConfirmation(decision: "allow" | "deny"): Promise<void>;
   dispose(reason: SessionDisposeReason): Promise<void>;
 };
 
+export type BashGuardSource = "default" | "environment" | "cli" | "session";
+
+export type BashGuardSnapshot = {
+  readonly mode: "guard" | "yolo";
+  readonly source: BashGuardSource;
+  readonly pending?: {
+    readonly command: string;
+    readonly reason: string;
+  };
+};
+
 const EMPTY_MCP_INVENTORY: McpInventorySnapshot = Object.freeze({
   servers: Object.freeze([]),
 });
@@ -187,6 +208,7 @@ export type RuntimeSessionContext = {
   ): ToolCallIdentity;
   finishIterationForContinuation(iteration: IterationIdentity): void;
   append(input: AgentEventInput): Promise<void>;
+  updateAssistantTextDelta?(update: AssistantTextDeltaUpdate): void;
   onToolCompletionsCommitted?(input: {
     completions: readonly ToolCompletionInput[];
     committed: readonly CommittedToolCompletion[];
@@ -247,6 +269,7 @@ type CommonRuntimeSessionInput = {
   projectInstruction?: ProjectInstructionManifest;
   skillCatalog?: SkillCatalogSnapshot;
   presentationSinks?: EventSink[];
+  assistantTextDeltaSink?: AssistantTextDeltaSink;
   persistence?:
     | false
     | {
@@ -257,6 +280,12 @@ type CommonRuntimeSessionInput = {
   toolingConfig?: PublicToolingConfig;
   memorySearch?: ToolExecutor;
   completedTurnHook?: CompletedTurnHook;
+  enableTurnUndo?: boolean;
+  bashGuard?: {
+    readonly mode: "guard" | "yolo";
+    readonly source: Exclude<BashGuardSource, "session">;
+    readonly surface: "tui" | "one-shot";
+  };
 };
 
 type CreateNewRuntimeSessionInput = CommonRuntimeSessionInput & {
@@ -309,6 +338,7 @@ type RuntimeSessionState =
   | "executing"
   | "compacting"
   | "maintaining_context"
+  | "undoing"
   | "faulted"
   | "disposing"
   | "disposed";
@@ -388,6 +418,20 @@ class DefaultRuntimeSession implements RuntimeSession {
   private pendingAutomaticContextMaintenance = false;
   private readonly skillCatalog: SkillCatalogSnapshot;
   private skillCoordinator = new SkillActivationCoordinator();
+  private bashGuardMode: "guard" | "yolo";
+  private bashGuardSource: BashGuardSource;
+  private bashGuardSnapshot: BashGuardSnapshot;
+  private readonly bashGuardListeners = new Set<() => void>();
+  private assistantTextDeltaSinkDisabled = false;
+  private pendingBashConfirmation?: {
+    readonly command: string;
+    readonly reason: string;
+    readonly startedAt: number;
+    readonly call: ToolCallIdentity;
+    readonly resolve: (decision: "allow" | "deny") => void;
+    readonly reject: (error: unknown) => void;
+    readonly removeAbortListener: () => void;
+  };
 
   private readonly context: RuntimeSessionContext;
 
@@ -401,6 +445,12 @@ class DefaultRuntimeSession implements RuntimeSession {
   ) {
     this.sessionId = input.selection.sessionId;
     this.resumed = input.selection.mode === "resume";
+    this.bashGuardMode = input.bashGuard?.mode ?? "guard";
+    this.bashGuardSource = input.bashGuard?.source ?? "default";
+    this.bashGuardSnapshot = Object.freeze({
+      mode: this.bashGuardMode,
+      source: this.bashGuardSource,
+    });
     this.skillCatalog =
       input.skillCatalog ??
       createSkillCatalogSnapshot({
@@ -423,6 +473,12 @@ class DefaultRuntimeSession implements RuntimeSession {
       finishIterationForContinuation: (iteration) =>
         this.finishIterationForContinuation(iteration),
       append: (event) => this.append(event),
+      ...(input.assistantTextDeltaSink === undefined
+        ? {}
+        : {
+            updateAssistantTextDelta: (update: AssistantTextDeltaUpdate) =>
+              this.updateAssistantTextDelta(update),
+          }),
       onToolCompletionsCommitted: (completion) =>
         this.onToolCompletionsCommitted(completion),
       prepareModelDispatch: (dispatch) => this.prepareModelDispatch(dispatch),
@@ -556,8 +612,14 @@ class DefaultRuntimeSession implements RuntimeSession {
         workspaceRoot: input.workspaceRoot,
         runtimeSession: session.context,
         historyReader: store.historyReader(),
+        ...(input.enableTurnUndo === true ? { enableTurnUndo: true } : {}),
         webFetchRefiner: input.webFetchRefiner,
         toolingConfig: input.toolingConfig,
+        bashGuard: {
+          surface: input.bashGuard?.surface ?? "one-shot",
+          confirm: (call, request, signal) =>
+            session.confirmBashCommand(call, request, signal),
+        },
         ...(input.memorySearch === undefined
           ? {}
           : { memorySearch: input.memorySearch }),
@@ -902,6 +964,134 @@ class DefaultRuntimeSession implements RuntimeSession {
     return this.input.modelClient.inputModalities?.includes("image") === true;
   }
 
+  bashGuard(): BashGuardSnapshot {
+    return this.bashGuardSnapshot;
+  }
+
+  private refreshBashGuardSnapshot(): void {
+    this.bashGuardSnapshot = Object.freeze({
+      mode: this.bashGuardMode,
+      source: this.bashGuardSource,
+      ...(this.pendingBashConfirmation === undefined
+        ? {}
+        : {
+            pending: Object.freeze({
+              command: this.pendingBashConfirmation.command,
+              reason: this.pendingBashConfirmation.reason,
+            }),
+          }),
+    });
+  }
+
+  subscribeBashGuard(listener: () => void): () => void {
+    this.bashGuardListeners.add(listener);
+    return () => this.bashGuardListeners.delete(listener);
+  }
+
+  setYoloMode(enabled: boolean): void {
+    this.bashGuardMode = enabled ? "yolo" : "guard";
+    this.bashGuardSource = "session";
+    this.refreshBashGuardSnapshot();
+    this.notifyBashGuardListeners();
+  }
+
+  async resolveBashConfirmation(decision: "allow" | "deny"): Promise<void> {
+    const pending = this.pendingBashConfirmation;
+    if (pending === undefined) {
+      throw new Error("No Bash confirmation is pending.");
+    }
+    this.pendingBashConfirmation = undefined;
+    this.refreshBashGuardSnapshot();
+    pending.removeAbortListener();
+    await this.append({
+      type: "tool.confirmation.resolved",
+      ...pending.call,
+      data: {
+        command: pending.command,
+        reason: pending.reason,
+        decision,
+        durationMs: Date.now() - pending.startedAt,
+      },
+    });
+    pending.resolve(decision);
+    this.notifyBashGuardListeners();
+  }
+
+  private async confirmBashCommand(
+    call: ToolCallIdentity,
+    request: { command: string; reason: string },
+    signal: AbortSignal,
+  ): Promise<"allow" | "deny"> {
+    const startedAt = Date.now();
+    await this.append({
+      type: "tool.confirmation.requested",
+      ...call,
+      data: request,
+    });
+
+    const surface = this.input.bashGuard?.surface ?? "one-shot";
+    if (this.bashGuardMode === "yolo" || surface === "one-shot") {
+      const decision = this.bashGuardMode === "yolo" ? "allow" : "deny";
+      await this.append({
+        type: "tool.confirmation.resolved",
+        ...call,
+        data: {
+          ...request,
+          decision,
+          durationMs: Date.now() - startedAt,
+        },
+      });
+      return decision;
+    }
+
+    if (this.pendingBashConfirmation !== undefined) {
+      throw new Error("Another Bash confirmation is already pending.");
+    }
+
+    return new Promise<"allow" | "deny">((resolve, reject) => {
+      const onAbort = () => {
+        const pending = this.pendingBashConfirmation;
+        if (pending?.call.toolCallId !== call.toolCallId) {
+          return;
+        }
+        this.pendingBashConfirmation = undefined;
+        this.refreshBashGuardSnapshot();
+        void this.append({
+          type: "tool.confirmation.resolved",
+          ...call,
+          data: {
+            ...request,
+            decision: "cancelled",
+            durationMs: Date.now() - startedAt,
+          },
+        }).finally(() => {
+          reject(cancellationError(signal));
+          this.notifyBashGuardListeners();
+        });
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      this.pendingBashConfirmation = {
+        ...request,
+        startedAt,
+        call,
+        resolve,
+        reject,
+        removeAbortListener: () => signal.removeEventListener("abort", onAbort),
+      };
+      this.refreshBashGuardSnapshot();
+      this.notifyBashGuardListeners();
+      if (signal.aborted) {
+        onAbort();
+      }
+    });
+  }
+
+  private notifyBashGuardListeners(): void {
+    for (const listener of this.bashGuardListeners) {
+      listener();
+    }
+  }
+
   async importImage(
     sourcePath: string,
     signal: AbortSignal,
@@ -1613,6 +1803,36 @@ class DefaultRuntimeSession implements RuntimeSession {
     );
   }
 
+  async undoLatestFileMutationTurn(): Promise<TurnUndoResult> {
+    if (
+      this.state !== "ready" ||
+      this.activeTurn !== undefined ||
+      this.activeContextRevision !== undefined
+    ) {
+      throw new Error("Cannot undo while a turn or context operation is active.");
+    }
+    const tooling = this.requireTooling();
+    if (
+      tooling.taskManager
+        .listBackgroundTasks()
+        .some((task) => task.status === "running" || task.status === "stopping")
+    ) {
+      throw new Error("Cannot undo while a background task is active.");
+    }
+    if (tooling.turnUndoManager === undefined) {
+      return { status: "nothing" };
+    }
+
+    this.state = "undoing";
+    try {
+      return await tooling.turnUndoManager.undoLatest();
+    } finally {
+      if (this.state === "undoing") {
+        this.state = "ready";
+      }
+    }
+  }
+
   async cloneSession(targetSessionId: SessionId): Promise<void> {
     if (!this.canSwitchSession()) {
       throw new Error(
@@ -1744,6 +1964,7 @@ class DefaultRuntimeSession implements RuntimeSession {
       await this.appendTerminalEvent(turn, result, projectedMessageCount);
       pendingLedgerTurn.finish(result);
       settled = true;
+      this.requireTooling().turnUndoManager?.completeTurn(turn);
       if (result.status === "completed") {
         this.notifyCompletedTurn(turn);
       }
@@ -2156,6 +2377,32 @@ class DefaultRuntimeSession implements RuntimeSession {
     return identity;
   }
 
+  private updateAssistantTextDelta(update: AssistantTextDeltaUpdate): void {
+    const sink = this.input.assistantTextDeltaSink;
+    const iteration = this.iterations.get(update.iterationId);
+    if (
+      sink === undefined ||
+      this.assistantTextDeltaSinkDisabled ||
+      this.state !== "executing" ||
+      update.content === "" ||
+      !Number.isSafeInteger(update.attemptNumber) ||
+      update.attemptNumber < 1 ||
+      iteration === undefined ||
+      iteration.sessionId !== update.sessionId ||
+      iteration.turnId !== update.turnId ||
+      iteration.turnNumber !== update.turnNumber ||
+      iteration.iterationNumber !== update.iterationNumber
+    ) {
+      return;
+    }
+
+    try {
+      sink.updateAssistantTextDelta(update);
+    } catch {
+      this.assistantTextDeltaSinkDisabled = true;
+    }
+  }
+
   private createToolCall(
     iteration: IterationIdentity,
     toolCallNumber: number,

package/src/cli/command-line.ts

@@ -8,6 +8,7 @@ export type CliCommand =
   | {
       readonly type: "run";
       readonly profileName?: string;
+      readonly yolo?: boolean;
       readonly promptSource: PromptSource;
     };
 
@@ -72,6 +73,7 @@ export async function parseCommandLine(
     .option(contract.run.profileOption.flags, contract.run.profileOption.description)
     .option(contract.run.stdinOption.flags, contract.run.stdinOption.description)
     .option(contract.run.fileOption.flags, contract.run.fileOption.description)
+    .option(contract.run.yoloOption.flags, contract.run.yoloOption.description)
     .addHelpText("after", `\n${contract.run.helpAfter}\n`)
     .showHelpAfterError('Run "tinker run --help" for usage.')
     .showSuggestionAfterError(false)
@@ -80,7 +82,12 @@ export async function parseCommandLine(
     .action(
       (
         prompt: string | undefined,
-        options: { profile?: string; stdin?: boolean; file?: string },
+        options: {
+          profile?: string;
+          stdin?: boolean;
+          file?: string;
+          yolo?: boolean;
+        },
       ) => {
         const sources: PromptSource[] = [];
         if (prompt !== undefined) {
@@ -116,6 +123,7 @@ export async function parseCommandLine(
           ...(options.profile === undefined
             ? {}
             : { profileName: validateProfile(options.profile, "run") }),
+          ...(options.yolo === true ? { yolo: true } : {}),
           promptSource,
         });
       },

package/src/cli/config.ts

@@ -37,11 +37,14 @@ export type RunnerConfig = {
   readonly profileName?: string;
   readonly inputModalities: readonly ModelInputModality[];
   readonly tokenEstimator?: ModelTokenEstimatorProfile;
+  readonly bashGuardMode: "guard" | "yolo";
+  readonly bashGuardSource: "default" | "environment" | "cli";
 };
 
 export type RunnerConfigSelection = {
   readonly sessionId: SessionId;
   readonly profileName?: string;
+  readonly yolo?: boolean;
 };
 
 type RunnerConfigTemplate = Omit<RunnerConfig, "sessionId">;
@@ -144,7 +147,7 @@ export function deriveRunnerConfig(
     if (template === undefined) {
       throw unknownProfileError(profileName, snapshot.profiles);
     }
-    return runnerConfigFromTemplate(template, selection.sessionId);
+    return runnerConfigFromTemplate(template, selection);
   }
 
   if (selection.profileName !== undefined) {
@@ -152,7 +155,7 @@ export function deriveRunnerConfig(
       `Cannot select model profile ${JSON.stringify(selection.profileName)} because TINKER_MODELS is not configured.`,
     );
   }
-  return runnerConfigFromTemplate(snapshot.template, selection.sessionId);
+  return runnerConfigFromTemplate(snapshot.template, selection);
 }
 
 function runnerConfigTemplateFromProfile(
@@ -172,6 +175,8 @@ function runnerConfigTemplateFromProfile(
     contextBudget: deriveModelContextBudget(contextProfile),
     profileName: profile.name,
     inputModalities: profile.inputModalities,
+    bashGuardMode: environment.bashGuardMode,
+    bashGuardSource: environment.bashGuardSource,
     ...(profile.tokenEstimator === undefined
       ? {}
       : { tokenEstimator: profile.tokenEstimator }),
@@ -196,14 +201,22 @@ function runnerConfigTemplateFromEnvironment(
     contextProfile,
     contextBudget: deriveModelContextBudget(contextProfile),
     inputModalities: Object.freeze(["text"] as const),
+    bashGuardMode: environment.bashGuardMode,
+    bashGuardSource: environment.bashGuardSource,
   });
 }
 
 function runnerConfigFromTemplate(
   template: RunnerConfigTemplate,
-  sessionId: SessionId,
+  selection: RunnerConfigSelection,
 ): RunnerConfig {
-  return Object.freeze({ ...template, sessionId });
+  return Object.freeze({
+    ...template,
+    sessionId: selection.sessionId,
+    ...(selection.yolo === true
+      ? { bashGuardMode: "yolo" as const, bashGuardSource: "cli" as const }
+      : {}),
+  });
 }
 
 export function eventLogPath(workspaceRoot: string, sessionId: SessionId): string {

package/src/cli/main.ts

@@ -144,6 +144,7 @@ export async function main(
         ...(parsed.command.profileName === undefined
           ? {}
           : { profileName: parsed.command.profileName }),
+        ...(parsed.command.type === "run" && parsed.command.yolo ? { yolo: true } : {}),
       });
     } catch (error) {
       await writeCliOutput(

package/src/cli/public-cli-contract.ts

@@ -60,6 +60,10 @@ export const PUBLIC_CLI_CONTRACT = Object.freeze({
       description: "Read the prompt from a UTF-8 text file.",
       valueName: "path",
     } satisfies PublicCliOption),
+    yoloOption: Object.freeze({
+      flags: "--yolo",
+      description: "Skip destructive Bash command confirmation; use at your own risk.",
+    } satisfies PublicCliOption),
     promptSources: RUN_PROMPT_SOURCES,
     helpAfter:
       "Use exactly one prompt source. For complex or sensitive prompts, prefer --stdin or --file.",

package/src/cli/public-config-contract.ts

@@ -174,6 +174,17 @@ export const PUBLIC_CONFIG_FIELDS = Object.freeze([
     section: "tooling",
     description: "Maximum Bash foreground timeout in milliseconds.",
   }),
+  publicField({
+    name: "TINKER_YOLO",
+    valueKind: "boolean",
+    requiredIn: "never",
+    appliesIn: "always",
+    defaultValue: false,
+    secret: false,
+    section: "tooling",
+    description:
+      "Allow high-confidence destructive Bash commands without confirmation.",
+  }),
   publicField({
     name: "TINKER_GREP_TIMEOUT_MS",
     valueKind: "positive-integer",
@@ -479,6 +490,8 @@ type ParsedCommonEnvironment = {
   readonly workspaceRoot: string;
   readonly maxIterations: number;
   readonly tooling: PublicToolingConfig;
+  readonly bashGuardMode: "guard" | "yolo";
+  readonly bashGuardSource: "default" | "environment";
 };
 
 export type ParsedPublicEnvironment =
@@ -562,7 +575,18 @@ export function parsePublicEnvironment(
     );
   }
 
-  const common = { workspaceRoot, maxIterations, tooling };
+  const common = {
+    workspaceRoot,
+    maxIterations,
+    tooling,
+    bashGuardMode: requiredBooleanValue(values, "TINKER_YOLO")
+      ? ("yolo" as const)
+      : ("guard" as const),
+    bashGuardSource:
+      optionalRawString(env.TINKER_YOLO) === undefined
+        ? ("default" as const)
+        : ("environment" as const),
+  };
   if (mode === "profile") {
     if (configuredModelsPath === undefined) {
       throw new Error("Profile mode requires TINKER_MODELS.");

package/src/cli/run-runner.ts

@@ -74,6 +74,11 @@ export async function runOneShot(
         options.eventLogPath === false ? false : { eventLogPath: options.eventLogPath },
       webFetchRefiner: createWebFetchRefiner(config, options.env),
       toolingConfig: options.tooling,
+      bashGuard: {
+        mode: config.bashGuardMode,
+        source: config.bashGuardSource,
+        surface: "one-shot",
+      },
     });
 
     const result = await session.executeTurn({

package/src/cli/tui-runner.tsx

@@ -7,6 +7,10 @@ import {
 } from "../agent/runtime-session";
 import type { EventSink } from "../events/event-sink";
 import type { AgentEvent } from "../events/types";
+import type {
+  AssistantTextDeltaSink,
+  AssistantTextDeltaUpdate,
+} from "../agent/assistant-text-delta";
 import { createUuidV7 } from "../ids/uuid-v7";
 import type { SessionId } from "../ids/runtime-id";
 import {
@@ -43,6 +47,7 @@ import { loadProjectSlashCommands } from "../tui/project-slash-commands";
 import { createWorkspaceFileLister } from "../tui/workspace-file-search";
 import { clipboardWriterForEnvironment } from "../tui/clipboard";
 import { initializeTuiMemory } from "./tui-memory";
+import { prepareShikiHighlighter } from "../tui/shiki-highlighter";
 
 export type RunTuiOptions = {
   readonly publicConfig: ResolvedPublicConfig;
@@ -51,6 +56,7 @@ export type RunTuiOptions = {
 };
 
 export async function runTui(options: RunTuiOptions): Promise<void> {
+  const shikiPreparation = prepareShikiHighlighter();
   const profiles =
     options.publicConfig.mode === "profile" ? options.publicConfig.profiles : undefined;
   const config = options.initialRunnerConfig;
@@ -74,7 +80,7 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
       sessionConfig: RunnerConfig,
       mode: "new" | "resume",
       sessionId: SessionId,
-      sink: EventSink,
+      sink: EventSink & AssistantTextDeltaSink,
     ): Promise<RuntimeSession> => {
       const modelClient = createRunnerModelClient(
         sessionConfig,
@@ -100,8 +106,15 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
         projectInstruction: projectInstructionManifest(projectInstructions),
         skillCatalog,
         presentationSinks: [sink],
+        assistantTextDeltaSink: sink,
         webFetchRefiner: createWebFetchRefiner(sessionConfig, options.env),
         toolingConfig: options.publicConfig.tooling,
+        enableTurnUndo: true,
+        bashGuard: {
+          mode: sessionConfig.bashGuardMode,
+          source: sessionConfig.bashGuardSource,
+          surface: "tui" as const,
+        },
         ...(memoryCoordinator === undefined
           ? {}
           : {
@@ -256,6 +269,7 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
       createFreshSession,
     );
 
+    await shikiPreparation;
     instance = render(
       <App
         sessionController={controller}
@@ -285,6 +299,7 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
             : () => memoryCoordinator.listStoredMemories()
         }
       />,
+      { incrementalRendering: true },
     );
     await instance.waitUntilExit();
   } catch (error) {
@@ -317,7 +332,7 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
   }
 }
 
-class DeferredProjectionSink implements EventSink {
+class DeferredProjectionSink implements EventSink, AssistantTextDeltaSink {
   readonly name = "deferred-tui-projection";
   private target?: TuiProjectionStore;
   private readonly buffered: AgentEvent[] = [];
@@ -330,6 +345,10 @@ class DeferredProjectionSink implements EventSink {
     await this.target.append(event);
   }
 
+  updateAssistantTextDelta(update: AssistantTextDeltaUpdate): void {
+    this.target?.updateAssistantTextDelta(update);
+  }
+
   async attach(target: TuiProjectionStore): Promise<void> {
     if (this.target !== undefined) {
       throw new Error("Deferred projection sink is already attached.");

package/src/events/observation-text-log.ts

@@ -39,6 +39,27 @@ export function renderObservationLogEvent(event: AgentEvent): string | undefined
       return renderAssistantProgress(event);
     case "tool.observation":
       return renderToolObservation(event);
+    case "tool.confirmation.requested":
+      return [
+        "## Bash confirmation requested",
+        "",
+        `Reason: ${event.data.reason}`,
+        "",
+        event.data.command,
+        "",
+        "---",
+        "",
+      ].join("\n");
+    case "tool.confirmation.resolved":
+      return [
+        "## Bash confirmation resolved",
+        "",
+        `Decision: ${event.data.decision}`,
+        `Duration: ${event.data.durationMs} ms`,
+        "",
+        "---",
+        "",
+      ].join("\n");
     case "turn.finished":
       return renderTurnFinished(event.data);
     case "turn.cancelled":

package/src/events/stdout-event-printer.ts

@@ -117,6 +117,16 @@ export class StdoutEventPrinter implements EventSink {
           `${formatToolLine("tool.finished", event.data.call).trimEnd()} ok=${event.data.ok}\n`,
         );
         break;
+      case "tool.confirmation.requested":
+        this.stdout.write(
+          `tool.confirmation.requested toolCallId=${event.toolCallId} reason=${JSON.stringify(event.data.reason)} command=${JSON.stringify(event.data.command)}\n`,
+        );
+        break;
+      case "tool.confirmation.resolved":
+        this.stdout.write(
+          `tool.confirmation.resolved toolCallId=${event.toolCallId} decision=${event.data.decision} durationMs=${event.data.durationMs}\n`,
+        );
+        break;
       case "mcp.server.connected":
         this.stdout.write(
           `mcp.server.connected name=${event.data.serverName} tools=${event.data.toolCount}\n`,
@@ -199,6 +209,7 @@ function formatToolRawResult(call: ToolCall, raw: ToolRawResult): string[] {
     case "skill":
       return [formatSkillResult(raw)];
     case "read":
+    case "delete":
     case "glob":
     case "grep":
     case "web_search":