tinker-agent 2.12.0 → 3.0.0

package/src/remote/session-reads.ts

@@ -0,0 +1,126 @@
+import { readPromptHistory, appendPromptHistory } from "./prompt-history";
+import { loadProjectSlashCommands } from "../tui/project-slash-commands";
+import { readCurrentGitBranch } from "../tui/git-branch";
+import { listMemoryFiles } from "../memory/memory-files";
+import path from "node:path";
+import { realpath } from "node:fs/promises";
+import type { HostedSession } from "../agent/runtime-hosted-session";
+import { requireObject, requireText, RemoteError } from "./protocol";
+import { IMAGE_INPUT_POLICY } from "../image/image-input-policy";
+import { validateImageAssetRef, type ImageAssetRef } from "../image/image-types";
+import { encodeFailure } from "./failures";
+import { createWorkspaceFileLister } from "../tui/workspace-file-search";
+import { loadViewFile } from "../tui/view-file";
+import { readLastAssistantResponse } from "../session/session-last-response-reader";
+
+export async function sessionPost(
+  session: HostedSession,
+  route: string,
+  request: Request,
+  homeRoot?: string,
+): Promise<Response | undefined> {
+  if (!["images", "verify-images", "prompt-history"].includes(route)) return undefined;
+  try {
+    if (route === "prompt-history") {
+      await appendPromptHistory(
+        request,
+        session.tuiSnapshot().history.workspaceRoot,
+        homeRoot,
+      );
+      return Response.json({ saved: true });
+    }
+    const input = requireObject(await request.json());
+    const value = await session.exclusive(async (runtime) => {
+      if (route === "verify-images") {
+        if (
+          !Array.isArray(input.assets) ||
+          input.assets.length > IMAGE_INPUT_POLICY.maxImagesPerMessage
+        )
+          throw new Error("Invalid image asset list.");
+        for (const asset of input.assets) validateImageAssetRef(asset as ImageAssetRef);
+        await runtime.verifyImageAssets(
+          input.assets as ImageAssetRef[],
+          request.signal,
+        );
+        return { verified: true };
+      }
+      const count = input.count;
+      if (
+        typeof count !== "number" ||
+        !Number.isInteger(count) ||
+        count < 1 ||
+        count > IMAGE_INPUT_POLICY.maxImagesPerMessage
+      )
+        throw new Error("Invalid image count.");
+      if (input.sourcePath !== undefined) {
+        const source = requireText(input.sourcePath, "sourcePath", 4096);
+        if (path.isAbsolute(source))
+          throw new Error("Workspace image paths must be relative.");
+        return runtime.importImage(source, request.signal, count);
+      }
+      const encoded = requireText(
+        input.bytes,
+        "bytes",
+        Math.ceil(IMAGE_INPUT_POLICY.maxBytesPerImage / 3) * 4,
+      );
+      if (!/^[A-Za-z0-9+/]*={0,2}$/.test(encoded) || encoded.length % 4 !== 0)
+        throw new Error("Invalid base64 image.");
+      return runtime.importImageBytes(
+        Buffer.from(encoded, "base64"),
+        requireText(input.originalName, "originalName", 255),
+        request.signal,
+        count,
+      );
+    });
+    return Response.json(value, { headers: { "Cache-Control": "no-store" } });
+  } catch (error) {
+    return Response.json(
+      {
+        error: { message: error instanceof Error ? error.message : String(error) },
+        failure: encodeFailure(error),
+      },
+      { status: error instanceof RemoteError ? error.status : 422 },
+    );
+  }
+}
+export async function sessionRead(
+  session: HostedSession,
+  route: string,
+  url: URL,
+  signal: AbortSignal,
+  homeRoot?: string,
+): Promise<unknown> {
+  const snapshot = session.tuiSnapshot();
+  const workspaceRoot = snapshot.history.workspaceRoot;
+  if (route === "prompt-history") return readPromptHistory(workspaceRoot, homeRoot);
+  if (route === "project-commands") return loadProjectSlashCommands(workspaceRoot);
+  if (route === "git-branch")
+    return { branch: await readCurrentGitBranch(workspaceRoot) };
+  if (route === "memories") return listMemoryFiles(homeRoot);
+  if (route === "files") return createWorkspaceFileLister()(workspaceRoot, signal);
+  if (route === "last-response")
+    return {
+      text: await readLastAssistantResponse({
+        workspaceRoot,
+        sessionId: session.id,
+        homeRoot,
+      }),
+    };
+  if (route === "view-file") {
+    const requested = requireText(url.searchParams.get("path"), "path", 4096);
+    const actual = await realpath(path.resolve(workspaceRoot, requested));
+    const relative = path.relative(workspaceRoot, actual);
+    if (
+      relative === ".." ||
+      relative.startsWith(`..${path.sep}`) ||
+      path.isAbsolute(relative)
+    )
+      throw new RemoteError(
+        403,
+        "OUTSIDE_WORKSPACE",
+        "File is outside this workspace.",
+      );
+    return loadViewFile(workspaceRoot, relative);
+  }
+  throw new RemoteError(404, "NOT_FOUND", "Unknown session read route.");
+}

package/src/remote/sync-hub.ts

@@ -89,6 +89,8 @@ export class RemoteSyncHub {
     }
   }
   close(): void {
+    this.ring.length = 0;
+    this.ringBytes = 0;
     this.listeners.clear();
     this.pending = [];
   }

package/src/remote/tui-protocol.ts

@@ -0,0 +1,32 @@
+import type { ClientModelCatalog } from "../client/model-catalog";
+import type { ReasoningEffortSnapshot } from "../model/reasoning-effort";
+import type { ProviderRetrySnapshot } from "../agent/runtime-provider-retry";
+import type { AskUserSnapshot } from "../agent/runtime-session";
+import type { PromptSchedulerSnapshot } from "../agent/runtime-session-contracts";
+import type { TuiTimelineLog } from "../tui/tui-projection-store";
+import type {
+  BashGuardSnapshot,
+  RuntimeSkillsSnapshot,
+} from "../agent/runtime-session";
+import type { McpInventorySnapshot } from "../mcp/mcp-manager";
+import type { TuiProjectionState } from "../tui/event-store";
+import type { RemoteActivity, RemoteCursor } from "./protocol";
+
+/** Additive v1 read model for the full terminal renderer; no raw runtime events. */
+export type RemoteTuiSnapshot = {
+  version: 1;
+  profileName?: string;
+  modelCatalog?: ClientModelCatalog;
+  reasoningEffort?: ReasoningEffortSnapshot;
+  supportsImageInput: boolean;
+  cursor: RemoteCursor;
+  activity: RemoteActivity;
+  history: TuiProjectionState;
+  timeline: TuiTimelineLog;
+  promptScheduler: PromptSchedulerSnapshot;
+  bashGuard: BashGuardSnapshot & { interactionId?: string };
+  askUser: AskUserSnapshot & { interactionId?: string };
+  providerRetry: ProviderRetrySnapshot;
+  skills: RuntimeSkillsSnapshot;
+  mcp: McpInventorySnapshot;
+};

package/src/remote/workspace-resolution.ts

@@ -0,0 +1,82 @@
+import { realpath, stat } from "node:fs/promises";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import type { RemoteWorkspaceConfig } from "./config";
+import { RemoteError } from "./protocol";
+
+/** Only resolves configured roots; selecting a child directory does not change execution scope. */
+export async function resolveServiceWorkspace(
+  workspaces: readonly RemoteWorkspaceConfig[],
+  directory: string,
+): Promise<RemoteWorkspaceConfig> {
+  if (!path.isAbsolute(directory))
+    throw new RemoteError(
+      400,
+      "INVALID_DIRECTORY",
+      "Workspace directory must be an absolute path on the service host.",
+    );
+  let canonical: string;
+  try {
+    canonical = await realpath(directory);
+    if (!(await stat(canonical)).isDirectory()) throw new Error("Not a directory.");
+  } catch {
+    throw new RemoteError(
+      404,
+      "DIRECTORY_NOT_FOUND",
+      "Workspace directory does not exist on the service host.",
+    );
+  }
+  const match = findContainingWorkspace(workspaces, canonical);
+  if (!match)
+    throw new RemoteError(
+      404,
+      "WORKSPACE_NOT_CONFIGURED",
+      "Current directory is outside configured workspaces. Use --service-config <path> from a local terminal to register it, or select --workspace <id> explicitly.",
+    );
+  return match;
+}
+
+export function findContainingWorkspace(
+  workspaces: readonly RemoteWorkspaceConfig[],
+  canonical: string,
+): RemoteWorkspaceConfig | undefined {
+  const matches = workspaces
+    .filter((workspace) => {
+      const relative = path.relative(workspace.path, canonical);
+      return (
+        relative === "" ||
+        (!path.isAbsolute(relative) &&
+          relative !== ".." &&
+          !relative.startsWith(`..${path.sep}`))
+      );
+    })
+    .sort((a, b) => b.path.length - a.path.length);
+  return matches[0];
+}
+
+export function localWorkspaceRecord(canonical: string): RemoteWorkspaceConfig {
+  return {
+    id: `local-${createHash("sha256").update(canonical).digest("hex").slice(0, 32)}`,
+    name: path.basename(canonical) || canonical,
+    path: canonical,
+  };
+}
+
+export function mergeWorkspaces(
+  configured: readonly RemoteWorkspaceConfig[],
+  registered: readonly RemoteWorkspaceConfig[],
+): RemoteWorkspaceConfig[] {
+  const result = [...configured];
+  for (const workspace of registered) {
+    const match = result.find(
+      (entry) => entry.id === workspace.id || entry.path === workspace.path,
+    );
+    if (match) {
+      if (match.id !== workspace.id || match.path !== workspace.path)
+        throw new Error(
+          "Configured workspace conflicts with a locally registered workspace identity. Preserve its ID and canonical path.",
+        );
+    } else result.push(workspace);
+  }
+  return result;
+}

package/src/session/resume-projection.ts

@@ -60,6 +60,22 @@ export class ResumeProjectionReader {
       input.sessionId,
       input.homeRoot,
     );
+    return this.readDatabase({ ...input, workspaceRoot, databasePath, policy });
+  }
+
+  /** Read completed history while a service-owned session may have an open tail. */
+  static readDatabase(input: {
+    workspaceRoot: string;
+    sessionId: SessionId;
+    modelName: string;
+    databasePath: string;
+    policy?: TuiProjectionPolicy;
+    closedTurnsOnly?: boolean;
+  }): TuiProjectionState {
+    const { workspaceRoot, databasePath } = input;
+    const policy = validateTuiProjectionPolicy(
+      input.policy ?? defaultTuiProjectionPolicy,
+    );
     const database = new Database(databasePath, {
       readonly: true,
       strict: true,
@@ -84,11 +100,12 @@ export class ResumeProjectionReader {
           { sessionId: input.sessionId },
         );
       }
+      const filter = input.closedTurnsOnly ? " WHERE status <> 'open'" : "";
       const totalTurns = count(
-        database.query("SELECT COUNT(*) AS count FROM turns").get(),
+        database.query(`SELECT COUNT(*) AS count FROM turns${filter}`).get(),
       );
       const turns = database
-        .query(`SELECT * FROM turns ORDER BY turn_number DESC LIMIT ?`)
+        .query(`SELECT * FROM turns${filter} ORDER BY turn_number DESC LIMIT ?`)
         .all(policy.recentTurnLimit)
         .reverse() as Array<Record<string, unknown>>;
       const recentTurns = turns.map((turn) => projectTurn(database, turn, policy));

package/src/session/session-lock.ts

@@ -46,6 +46,8 @@ const defaultDependencies: SessionLeaseDependencies = {
 
 export class SessionLease {
   private released = false;
+  private retained = false;
+  private writerActive = true;
   private lockPath: string;
 
   private constructor(
@@ -167,7 +169,37 @@ export class SessionLease {
     this.lockPath = path.join(sessionDirectory, "active.lock");
   }
 
+  /** Keep the canonical process lease while its current SQLite writer is unloaded. */
+  retainOwnership(): this {
+    this.requireActive();
+    this.retained = true;
+    return this;
+  }
+  claim(sessionDirectory: string, sessionId: SessionId): this {
+    this.requireActive();
+    if (
+      !this.retained ||
+      this.writerActive ||
+      sessionId !== this.record.sessionId ||
+      path.join(sessionDirectory, "active.lock") !== this.lockPath
+    )
+      throw new Error("Retained session lease is not available for this writer.");
+    this.writerActive = true;
+    return this;
+  }
+  async releaseOwnership(): Promise<void> {
+    if (this.released) return;
+    if (this.retained && this.writerActive)
+      throw new Error("Close the session writer before releasing service ownership.");
+    this.retained = false;
+    await this.release();
+  }
+
   async release(): Promise<void> {
+    if (this.retained && !this.released) {
+      this.writerActive = false;
+      return;
+    }
     if (this.released) {
       return;
     }

package/src/session/session-store-contracts.ts

@@ -1,3 +1,4 @@
+import type { SessionLease } from "./session-lock";
 import type {
   ContextRevisionId,
   IterationId,
@@ -269,6 +270,7 @@ export type CreateNewSessionStoreInput = {
 };
 
 export type OpenSessionStoreInput = {
+  lease?: SessionLease;
   workspaceRoot: string;
   sessionId: SessionId;
   clock?: () => string;

package/src/session/session-store.ts

@@ -374,10 +374,9 @@ export class SessionStore implements SessionLedgerCommitter {
       await validateSecureOptionalFile(optionalFile, input.sessionId);
     }
 
-    const lease = await SessionLease.acquire({
-      sessionDirectory,
-      sessionId: input.sessionId,
-    });
+    const lease = input.lease
+      ? input.lease.claim(sessionDirectory, input.sessionId)
+      : await SessionLease.acquire({ sessionDirectory, sessionId: input.sessionId });
     let database: Database | undefined;
     try {
       database = openWritableDatabase(databasePath);
@@ -1317,6 +1316,10 @@ export class SessionStore implements SessionLedgerCommitter {
     }
   }
 
+  retainLease(): SessionLease {
+    return this.lease.retainOwnership();
+  }
+
   async close(reason: SessionCloseReason): Promise<void> {
     if (this.closed) {
       return;

package/src/tools/bash.ts

@@ -48,7 +48,15 @@ export function createBashToolExecutor(options: BashToolOptions): ToolExecutor {
     definition: {
       name: "Bash",
       description:
-        "Run a shell command locally. If the foreground timeout expires while the command is still running, it continues as a background task and returns a task ID; it is not killed. Use TaskOutput to inspect progress, then decide whether to keep waiting or stop it with TaskStop.",
+        "Run a shell command locally. " +
+        "If the foreground timeout expires while the command is still running, " +
+        "it continues as a background task and returns a task ID; it is not killed. " +
+        "Use TaskOutput to inspect progress, then decide whether to keep waiting or stop it with TaskStop. " +
+        "Use run_in_background=true for persistent processes such as dev servers and watch commands, " +
+        "or when you have independent work to do while a command runs. " +
+        "For finite commands whose result is needed next, such as builds, tests, and checks, " +
+        "prefer foreground execution when no independent work remains. " +
+        "Set a sufficient foreground timeout; the call returns as soon as the command finishes.",
       parameters: {
         type: "object",
         additionalProperties: false,

package/src/tools/bounded-output-preview.ts

@@ -1,7 +1,7 @@
 import { Buffer } from "node:buffer";
 
-export const MAX_PREVIEW_LINES = 200;
-export const PREVIEW_EDGE_LINES = 100;
+export const MAX_PREVIEW_LINES = 50;
+export const PREVIEW_EDGE_LINES = 25;
 export const MAX_PREVIEW_BYTES = 32 * 1024;
 export const MAX_PREVIEW_LINE_BYTES = 8 * 1024;
 

package/src/tui/app.tsx

@@ -20,7 +20,6 @@ import { ContextBudgetExceededError } from "../model/model-request-preflight";
 import { ModelRequestMediaAggregateError } from "../model/model-client";
 import type { ReasoningEffortSnapshot } from "../model/reasoning-effort";
 import type { SessionId } from "../ids/runtime-id";
-import { readLastAssistantResponse } from "../session/session-last-response-reader";
 import type { PromptHistory } from "./prompt-history";
 import { Footer } from "./components/footer";
 import { AssistantMarkdownProvider } from "./components/assistant-markdown";
@@ -56,8 +55,8 @@ import {
   type ProjectSlashCommand,
 } from "./project-slash-commands";
 import type { TuiSessionController } from "./tui-session-controller";
-import type { SessionSummary } from "../session/session-catalog";
-import type { ModelProfile, ModelProfiles } from "../cli/model-profiles";
+import type { ClientSessionSummary as SessionSummary } from "../client/session-client";
+import type { ClientModelProfile, ClientModelProfiles } from "../client/model-catalog";
 import { loadViewFile, type ViewFile } from "./view-file";
 import { writeClipboardText } from "./clipboard";
 import type { WorkspaceFileLister } from "./workspace-file-search";
@@ -74,7 +73,7 @@ export type AppProps = {
   history?: PromptHistory;
   projectSlashCommands?: readonly ProjectSlashCommand[];
   fileLister?: WorkspaceFileLister;
-  profiles?: ModelProfiles;
+  profiles?: ClientModelProfiles;
   persistDefaultProfile?: (profileName: string) => Promise<void>;
   readViewFile?: (workspaceRoot: string, filePath: string) => Promise<ViewFile>;
   readLastResponse?: (
@@ -203,16 +202,34 @@ export function App(props: AppProps) {
     write(clearTerminal);
     setStaticRenderEpoch((current) => current + 1);
   }, [write]);
+  const presentationRevision = binding.projectionStore.getPresentationRevision?.();
+  const renderedPresentation = useRef({
+    sessionId: binding.sessionId,
+    revision: presentationRevision,
+  });
+  useEffect(() => {
+    const previous = renderedPresentation.current;
+    renderedPresentation.current = {
+      sessionId: binding.sessionId,
+      revision: presentationRevision,
+    };
+    if (
+      previous.sessionId === binding.sessionId &&
+      previous.revision !== presentationRevision
+    )
+      restoreStaticViewport();
+  }, [binding.sessionId, presentationRevision, restoreStaticViewport]);
   const staticItems = useMemo<Array<typeof STATIC_HEADER | TuiCommittedItem>>(
     () => [STATIC_HEADER, ...log.committed],
     [log.committed],
   );
 
+  const profiles = props.profiles ?? binding.modelProfiles?.();
   const canSwitchModel =
     state.recentTurns.length === 0 &&
     state.activeTurn === undefined &&
-    props.profiles !== undefined &&
-    props.profiles.profiles.size > 1;
+    profiles !== undefined &&
+    profiles.profiles.size > 1;
   const reasoningEffort = binding.reasoningEffort?.();
   const hasReasoningEffort = reasoningEffort !== undefined;
   const activeResumePicker =
@@ -225,8 +242,8 @@ export function App(props: AppProps) {
   );
   const availableCommands = [...builtInCommands, ...(props.projectSlashCommands ?? [])];
 
-  const profileList = props.profiles ? [...props.profiles.profiles.values()] : [];
-  const cycleReasoningEffort = () => {
+  const profileList = profiles ? [...profiles.profiles.values()] : [];
+  const cycleReasoningEffort = async () => {
     const current = binding.reasoningEffort?.();
     if (current === undefined) {
       return;
@@ -239,7 +256,7 @@ export function App(props: AppProps) {
       return;
     }
     try {
-      const updated = binding.setReasoningEffort?.(nextEffort);
+      const updated = await binding.setReasoningEffort?.(nextEffort);
       if (updated === undefined) {
         throw new Error("Reasoning effort control is unavailable.");
       }
@@ -282,6 +299,24 @@ export function App(props: AppProps) {
         return;
       }
 
+      if (binding.stopTurn !== undefined) {
+        if (isCancelling) return;
+        setIsCancelling(true);
+        setNotice("Cancelling current turn...");
+        void binding.stopTurn().then(
+          () => {
+            setIsCancelling(false);
+            setNotice((current) =>
+              current === "Cancelling current turn..." ? undefined : current,
+            );
+          },
+          (error: unknown) => {
+            setIsCancelling(false);
+            setNotice(`Stop failed: ${errorMessage(error)}`);
+          },
+        );
+        return;
+      }
       const controller = activeController.current;
       if (controller === undefined || controller.signal.aborted) {
         return;
@@ -384,7 +419,7 @@ export function App(props: AppProps) {
     restoreStaticViewport();
   };
 
-  const doSwitchModel = (profile: ModelProfile) => {
+  const doSwitchModel = (profile: ClientModelProfile) => {
     setShowModelPicker(false);
     setModelPickerState(undefined);
     setNotice(undefined);
@@ -394,7 +429,9 @@ export function App(props: AppProps) {
       .then(async () => {
         setGitBranchRefresh((current) => current + 1);
         try {
-          await props.persistDefaultProfile?.(profile.name);
+          await (
+            props.persistDefaultProfile ?? props.sessionController.persistDefaultProfile
+          )?.(profile.name);
           setNotice(`Switched to model profile "${profile.name}" (${profile.model}).`);
         } catch (error) {
           setNotice(
@@ -462,10 +499,7 @@ export function App(props: AppProps) {
     void Promise.resolve()
       .then(() =>
         props.readLastResponse === undefined
-          ? readLastAssistantResponse({
-              workspaceRoot,
-              sessionId: binding.sessionId,
-            })
+          ? binding.readLastResponse()
           : props.readLastResponse(workspaceRoot, binding.sessionId),
       )
       .then(async (markdown) => {
@@ -496,7 +530,7 @@ export function App(props: AppProps) {
         return false;
       }
       try {
-        const queued = binding.queueFollowUp?.(submission.userMessage);
+        const queued = await binding.queueFollowUp?.(submission.userMessage);
         if (queued === undefined) {
           throw new Error("TUI session binding does not support follow-up queuing.");
         }
@@ -605,10 +639,10 @@ export function App(props: AppProps) {
     }
   };
 
-  const onSubmit = (
+  const onSubmit = async (
     submission: PromptSubmission,
     signal: AbortSignal,
-  ): PromptSubmissionOutcome | Promise<PromptSubmissionOutcome> => {
+  ): Promise<PromptSubmissionOutcome> => {
     const { userMessage } = submission;
     const trimmed = userMessage.content.trim();
     const shouldRestoreViewport = showStatus || showSkills || showMcp;
@@ -664,7 +698,7 @@ export function App(props: AppProps) {
           return true;
         }
         if (command.type === "yolo") {
-          binding.setYoloMode(command.enabled);
+          await binding.setYoloMode(command.enabled);
           setNotice(
             command.enabled
               ? "YOLO enabled for this session; dangerous Bash commands will run without confirmation."
@@ -770,7 +804,7 @@ export function App(props: AppProps) {
             if (command.type === "reasoning_status") {
               setNotice(formatReasoningEffortStatus(current));
             } else if (command.type === "reasoning_reset") {
-              const reset = binding.resetReasoningEffort?.();
+              const reset = await binding.resetReasoningEffort?.();
               if (reset === undefined) {
                 throw new Error("Reasoning effort control is unavailable.");
               }
@@ -778,7 +812,7 @@ export function App(props: AppProps) {
                 `Reasoning effort reset to profile default ${JSON.stringify(reset.defaultEffort)}.`,
               );
             } else {
-              const updated = binding.setReasoningEffort?.(command.effort);
+              const updated = await binding.setReasoningEffort?.(command.effort);
               if (updated === undefined) {
                 throw new Error("Reasoning effort control is unavailable.");
               }
@@ -800,7 +834,7 @@ export function App(props: AppProps) {
             return false;
           }
           if (command.type === "model_switch") {
-            const targetProfile = props.profiles?.profiles.get(command.profileName);
+            const targetProfile = profiles?.profiles.get(command.profileName);
             if (targetProfile === undefined) {
               setNotice(`Unknown model profile: ${command.profileName}`);
               return false;
@@ -969,18 +1003,22 @@ export function App(props: AppProps) {
                 />
               ) : askUser.pending !== undefined ? (
                 <AskUser
+                  key={askUser.interactionId}
                   question={askUser.pending.question}
                   options={askUser.pending.options}
                   onSelect={(selectedIndex) => {
                     void binding
-                      .resolveAskUser({ outcome: "selected", selectedIndex })
+                      .resolveAskUser(
+                        { outcome: "selected", selectedIndex },
+                        askUser.interactionId,
+                      )
                       .catch((error: unknown) =>
                         setNotice(`Answer failed: ${errorMessage(error)}`),
                       );
                   }}
                   onDismiss={() => {
                     void binding
-                      .resolveAskUser({ outcome: "dismissed" })
+                      .resolveAskUser({ outcome: "dismissed" }, askUser.interactionId)
                       .catch((error: unknown) =>
                         setNotice(`Dismiss failed: ${errorMessage(error)}`),
                       );
@@ -992,7 +1030,7 @@ export function App(props: AppProps) {
                   reason={bashGuard.pending.reason}
                   onDecision={(decision) => {
                     void binding
-                      .resolveBashConfirmation(decision)
+                      .resolveBashConfirmation(decision, bashGuard.interactionId)
                       .catch((error: unknown) =>
                         setNotice(`Bash confirmation failed: ${errorMessage(error)}`),
                       );
@@ -1014,6 +1052,7 @@ export function App(props: AppProps) {
                   version={props.version}
                   workspaceRoot={binding.workspaceRoot}
                   gitBranch={gitBranch}
+                  serviceStatus={binding.projectionStore.getServiceStatus?.()}
                   contextUsage={state.contextUsage}
                   isDisabled={
                     isSessionOperation ||
@@ -1034,7 +1073,9 @@ export function App(props: AppProps) {
                   verifyImageAssets={binding.verifyImageAssets}
                   onCycleReasoningEffort={
                     hasReasoningEffort && promptScheduler.state !== "running"
-                      ? cycleReasoningEffort
+                      ? () => {
+                          void cycleReasoningEffort();
+                        }
                       : undefined
                   }
                   onSubmit={onSubmit}