dsh-coding-sidebar 1.0.7 → 1.0.9

package/lib/types/agent-pty.d.ts

@@ -15,6 +15,20 @@ export declare function clampDims(cols: number, rows: number): {
     cols: number;
     rows: number;
 };
+/**
+ * Arm the Windows pre-ready resize gate for one freshly spawned pty.
+ * No-op on POSIX and for injected ptys without `onData`.
+ */
+export declare function armPtyResizeGate(pty: IPty): void;
+/**
+ * Best-effort resize for WebSocket-driven terminal views. Layout animation
+ * can briefly produce unusable dimensions, and node-pty can reject a resize
+ * after the socket setup's outer try/catch has returned. Ignore that one
+ * frame so the host stays alive and a later valid measurement can retry.
+ * Returns whether node-pty accepted the resize (or parked it for replay on
+ * the first output — the Windows pre-ready window).
+ */
+export declare function tryResizePty(pty: Pick<IPty, 'resize'>, cols: number, rows: number): boolean;
 /**
  * Serializable snapshot of one agent terminal — the shape the model sees
  * through `terminal_list` and the sidebar sees through the push endpoint.
@@ -36,6 +50,15 @@ export interface AgentTerminalSnapshot {
     exitCode?: number | null;
     /** Exit signal name if the process was killed by a signal; null otherwise. */
     exitSignal?: string | null;
+    /**
+     * The model's active `terminal_wait_for` on this terminal (the sidebar
+     * renders the wait banner from it). Present only while a wait is
+     * registered; carries the LATEST wait when several overlap.
+     */
+    waiting?: {
+        needle: string;
+        since: number;
+    };
 }
 /** One live agent terminal. */
 export interface AgentTerminalHandle {
@@ -59,6 +82,17 @@ export interface AgentTerminalHandle {
     exitCode?: number | null;
     /** Exit signal number once known (POSIX only; undefined on Windows). */
     exitSignal?: number | null;
+    /** Active wait_for registrations (skip bookkeeping; empty while idle). */
+    waits: AgentTerminalActiveWait[];
+}
+/** One active wait_for registration on a handle (banner + skip bookkeeping). */
+export interface AgentTerminalActiveWait {
+    /** The needle being awaited (shown on the sidebar wait banner). */
+    needle: string;
+    /** Epoch ms when the wait registered (age display / debugging). */
+    since: number;
+    /** Flipped by `skipWait()`; the waiting poll returns `skipped` within one tick. */
+    skipped: boolean;
 }
 /** Read result shape (mirrors the official tool-pty terminal_read contract). */
 export interface AgentTerminalReadResult {
@@ -73,14 +107,18 @@ export interface AgentTerminalReadResult {
 }
 /** Outcome of {@link AgentPtyRegistry.waitFor}. */
 export type AgentTerminalWaitResult = {
-    /** The needle was found in the transcript. */
+    /** The pattern that was awaited. */
     kind: 'found';
-    /** The matched substring. */
     needle: string;
     /** 0-based line index (in the retained transcript) where the needle first appeared. */
     line: number;
     /** 0-based column index within that line where the match starts. */
     column: number;
+    /**
+     * The text that actually matched — for multi-outcome patterns
+     * (e.g. `(BUILD_OK|BUILD_FAIL)`) this tells which alternative matched.
+     */
+    match: string;
     /** Elapsed wall-clock milliseconds from the wait start to the match. */
     elapsedMs: number;
 } | {
@@ -101,6 +139,11 @@ export type AgentTerminalWaitResult = {
     exitCode?: number | null;
     /** The exit signal name, if the process was killed by a signal. */
     exitSignal?: string | null;
+} | {
+    /** The user skipped the wait from the sidebar banner. */
+    kind: 'skipped';
+    /** The needle that was awaited. */
+    needle: string;
 };
 /** Snapshot projection of a handle (drops the pty reference and transcript). */
 export declare function snapshotOf(handle: AgentTerminalHandle): AgentTerminalSnapshot;
@@ -181,12 +224,27 @@ export declare class AgentPtyRegistry {
      * make event-driven wakeups unreliable. A 50ms poll is fast enough for
      * interactive use and simple enough to be obviously correct.
      * @param uuid - terminal to watch.
-     * @param needle - substring to search for (case-sensitive, verbatim).
+     * @param needle - JavaScript regular expression to search for
+     *   (case-sensitive); a pattern that fails to compile falls back to
+     *   verbatim substring matching. May cover several outcomes at once
+     *   (e.g. `(BUILD_OK|BUILD_FAIL)` for build success vs failure) — the
+     *   returned `match` reports the text that actually matched, so callers
+     *   can tell which outcome hit.
      * @param timeoutMs - max wait; default 10000 (10s). Clamped to ≥100ms.
      * @param signal - caller-owned cancellation; aborts the wait re-throwing.
-     * @returns one of `found` / `timeout` / `exited`.
+     *   A wait can also be skipped by the user from the sidebar banner
+     *   (`skipWait`), which resolves it with `{kind:'skipped'}`.
+     * @returns one of `found` / `timeout` / `exited` / `skipped`.
      */
     waitFor(uuid: string, needle: string, timeoutMs?: number, signal?: AbortSignal): Promise<AgentTerminalWaitResult>;
+    /**
+     * Mark every active wait on one terminal as skipped (the sidebar banner's
+     * skip button). Each waiting poll loop observes its record's flag within
+     * one 50ms tick and returns `{kind:'skipped'}`. Idempotent: 0 when nothing
+     * is waiting (a stale banner racing a wait that already resolved).
+     * @returns the number of waits that transitioned to skipped.
+     */
+    skipWait(uuid: string): number;
     /**
      * Send a POSIX signal to a terminal's foreground process.
      *

package/lib/types/bundle-route.d.ts

@@ -1,6 +1,6 @@
 import type { Context, SidebarHttpRequest, SidebarHttpResponse } from './context-types.ts';
 /** The chunk names the client may request (mirror of src/client/chunk-loader.ts). */
-export declare const CHUNK_NAMES: readonly ["terminal", "editor"];
+export declare const CHUNK_NAMES: readonly ["terminal", "editor", "locale"];
 export type ChunkName = (typeof CHUNK_NAMES)[number];
 /**
  * Build the /sidebar/bundle route handler. `fence` is the shared browser-

package/lib/types/client/DiffView.d.ts

@@ -1,3 +1,5 @@
+import { type SessionScope } from './api.ts';
+import type { SidebarDiffRef } from './state.ts';
 /** One rendered diff line. */
 export interface DiffLine {
     kind: 'ctx' | 'del' | 'add' | 'meta';
@@ -41,11 +43,41 @@ export interface ParsedDiff {
  * can still draw its path.
  */
 export declare function parseUnifiedDiff(text: string): ParsedDiff;
+/** The old/new line range one hidden gap spans (both sides derive from the
+ *  surrounding hunk headers and their counted rows). */
+interface DiffFoldRange {
+    oldStart: number;
+    oldEnd: number;
+    newStart: number;
+    newEnd: number;
+}
+/**
+ * Materialize a git gap fold's hidden rows from the two sides' full file
+ * contents, by the fold's known line ranges: the old side drives context
+ * rows (each mapped onto the new side through the fold's offset — a gap is
+ * an unchanged run, so the sides align), and new-side lines the old range
+ * never reaches become pure additions. Line numbers clip to the actual
+ * content (a no-newline file's ranges can overrun by one); `\r` endings
+ * survive verbatim, like git's own context lines.
+ */
+export declare function foldRowsFromContents(fold: DiffFoldRange, oldContent: string, newContent: string): DiffLine[];
 export interface DiffViewProps {
     /** Unified diff text (`git.diff` or `git.commit-diff` payloads). */
     diff: string;
     /** Untracked-file content: when present, renders as a full-file addition instead of parsing. */
     untrackedPath?: string;
     untrackedContent?: string;
+    /**
+     * When present (a worktree/commit diff ref plus its scope), hunk gaps
+     * render an expandable fold: clicking resolves both sides' full contents
+     * (`git.fold-contents`) and materializes the hidden context rows. Absent
+     * (or an untracked full-addition render) — no fold rows at all.
+     */
+    foldSource?: {
+        scope: SessionScope;
+        ref: SidebarDiffRef;
+        cwd: string | undefined;
+    };
 }
-export declare function DiffView({ diff, untrackedPath, untrackedContent }: DiffViewProps): import("react").JSX.Element | null;
+export declare function DiffView({ diff, untrackedPath, untrackedContent, foldSource }: DiffViewProps): import("react").JSX.Element | null;
+export {};

package/lib/types/client/EditorHost.d.ts

@@ -9,5 +9,8 @@ export declare function EditorHost(props: {
     expanded: string[];
     revealed: string[];
     onToggleDir: (path: string) => void;
-    onReferenceFile: (path: string) => void;
+    onReferenceFile: (path: string, isDir: boolean) => void;
+    /** Tree-row mutations (passed through to the file tree; absent → hidden). */
+    onPathRenamed?: (oldPath: string, newPath: string) => void;
+    onPathRemoved?: (path: string) => void;
 }): import("react").JSX.Element;

package/lib/types/client/FileTree.d.ts

@@ -27,12 +27,16 @@ export declare function FileTree(props: {
     onOpenWith?: (targetId: string, path: string) => void;
     /** Toggle one target's pinned state (the submenu row's pushpin). */
     onToggleOpenWithPin?: (targetId: string) => void;
-    /** Insert `@<relative path>` into the composer draft. */
-    onReferenceFile: (path: string) => void;
+    /** Insert `@<relative path>` into the composer draft (file vs directory). */
+    onReferenceFile: (path: string, isDir: boolean) => void;
     /** Bump to wipe the level cache and reload the visible set. */
     refreshTick: number;
     /** Upload into `dir` (absolute, inside the workspace); runs in the caller. */
     onUploadRequest: (dir: string, items: UploadItem[]) => void;
     /** True while an upload is in flight (drops are ignored). */
     busy: boolean;
+    /** A tree row was renamed (retarget open tabs; absent → no rename entry). */
+    onPathRenamed?: (oldPath: string, newPath: string) => void;
+    /** A tree row was removed (close affected tabs; absent → no delete entry). */
+    onPathRemoved?: (path: string) => void;
 }): import("react").JSX.Element;

package/lib/types/client/TerminalWaitBanner.d.ts

@@ -0,0 +1,6 @@
+/** Truncate one needle for inline display (title attr carries the full text). */
+export declare function truncateNeedle(needle: string): string;
+export declare function TerminalWaitBanner(props: {
+    needle: string;
+    onSkip: () => void;
+}): import("react").JSX.Element;

package/lib/types/client/TreePanel.d.ts

@@ -17,7 +17,10 @@ export declare function TreePanel(props: {
     openWithSsh?: boolean;
     onOpenWith?: (targetId: string, path: string) => void;
     onToggleOpenWithPin?: (targetId: string) => void;
-    onReferenceFile: (path: string) => void;
+    onReferenceFile: (path: string, isDir: boolean) => void;
+    /** Tree-row mutations (passed through to the file tree; absent → hidden). */
+    onPathRenamed?: (oldPath: string, newPath: string) => void;
+    onPathRemoved?: (path: string) => void;
     /** Full-window presentation: the panel fills its host instead of docking
      *  at a fixed width. */
     full?: boolean;

package/lib/types/client/api.d.ts

@@ -138,6 +138,16 @@ export declare const api: {
     fsWrite: (scope: SessionScope, path: string, content: string) => Promise<{
         ok: true;
     }>;
+    /** Rename one tree row within its directory (single-segment name; a
+     *  destination-existence clash is a 409; symlink rows rename the link). */
+    fsRename: (scope: SessionScope, path: string, name: string) => Promise<{
+        path: string;
+    }>;
+    /** Delete one tree row permanently (recursive for directories; a symlink
+     *  row unlinks the link only). */
+    fsRemove: (scope: SessionScope, path: string) => Promise<{
+        path: string;
+    }>;
     /** Upload one file's raw bytes into `dir` (keeps the folder tree via
      *  `relativePath`); the host streams it under the session workspace. */
     uploadFile: (scope: SessionScope, dir: string, relativePath: string, body: Blob, signal?: AbortSignal) => Promise<{
@@ -171,6 +181,16 @@ export declare const api: {
     gitCommitDiff: (scope: SessionScope, hash: string, worktree?: string, signal?: AbortSignal) => Promise<{
         diff: string;
     }>;
+    /** Both sides' full file contents for a diff-fold expansion; a missing
+     *  side is null (untracked / deleted) and the view degrades the fold. */
+    gitFoldContents: (scope: SessionScope, opts: {
+        path: string;
+        staged?: boolean;
+        hash?: string;
+    }, worktree?: string, signal?: AbortSignal) => Promise<{
+        old: string | null;
+        new: string | null;
+    }>;
     /** Discard the worktree changes of one file (the index is untouched). */
     gitDiscard: (scope: SessionScope, path: string, worktree?: string) => Promise<{
         ok: true;
@@ -193,6 +213,12 @@ export declare const api: {
     agentPtyClose: (uuid: string) => Promise<{
         ok: true;
     }>;
+    /** Skip every active terminal_wait_for on one agent terminal (the wait
+     *  banner's skip button). Idempotent: {skipped:0} when none is active. */
+    agentSkipWait: (uuid: string) => Promise<{
+        ok: true;
+        skipped: number;
+    }>;
     /** Terminal dependency status (issue #140): after a WS close 1011 with
      *  reason `pty-deps-missing` the view fetches the full repair details here
      *  (the close reason itself is capped at 123 bytes). */

package/lib/types/client/chunk-loader.d.ts

@@ -48,7 +48,7 @@
  * client.js); an edit that does land while a core HMR happens is caught by
  * the ETag comparison on the next activation.
  */
-export type ChunkName = 'terminal' | 'editor';
+export type ChunkName = 'terminal' | 'editor' | 'locale';
 /** The module exports a chunk factory provides (namespace-ish record). */
 export type ChunkExports = Record<string, unknown>;
 /**

package/lib/types/client/chunks/locale.d.ts

@@ -0,0 +1,3 @@
+/** Every non-zh/en dictionary keyed by its override id, ready for the
+ *  better-locale store's `register(ns, dicts)`. */
+export declare const localeDicts: Record<string, Record<string, string>>;

package/lib/types/client/conversation-draft.d.ts

@@ -1,14 +1,95 @@
 /**
- * Append text to the current session's composer draft through the
+ * Insert text into the current session's composer draft through the
  * conversation service — the shared path behind the explorer's @-reference
  * button and the viewer selection popup. The service is resolved lazily
  * through `ctx.get` (the inject-free read the app's own plugins use); a
  * missing service or scope degrades to a logged no-op, never a crash.
+ *
+ * File references additionally use DSH's own structured insert event
+ * (`slash/input-insert-reference`, see `insertFileReference`) instead of
+ * plain draft text: the native `@file` picker emits this event, and the
+ * conversation input machine mints one occurrence whose chip covers the
+ * whole reference. Plain text `@folder/file.ts` only ever gets DSH's
+ * folder-ref decoration (`@folder/`) — the file name stays undecorated — so
+ * plain append is the fallback, not the primary path, for files.
+ *
+ * Insert position (upstream issue #425): the draft store only exposes the
+ * whole string (`getSnapshot().draft` + `setDraft(text)`) — there is no
+ * caret API on the conversation service. The composer's `<textarea>` keeps
+ * its last selection even while unfocused, so the live caret is probed from
+ * the DOM (guarded by a value-sync check), and the text is spliced at that
+ * position, replacing any live selection — with whitespace-aware joins, an
+ * insert into the middle of a sentence keeps single-space separation like
+ * the append path. An unknown/stale caret falls back to appending at the
+ * end (the pre-fix behavior).
+ *
+ * The caret is also *restored* after the insert: committing a programmatic
+ * draft change resets the controlled textarea's caret (observed landing at
+ * the start of the value), which would make every later insert probe the
+ * reset position and drift the stack (A|B + C + D ended up as |DACB). The
+ * placement (`placeComposerCaretAfterInsert`) puts the caret right after the
+ * inserted text once the value commit lands — the index accounts for the
+ * separating space on the left, so stacked inserts stay at their running
+ * position (A|B + C + D → ACD|B).
  */
 import type { Context } from '../context-types.ts';
+/** A resolved composer caret/selection in draft coordinates. */
+export interface DraftCaret {
+    start: number;
+    end: number;
+}
 /**
- * Append `text` to the session's composer draft (space-separated, like the
- * @-mentions). Returns false — and logs — when the conversation service or
- * the session scope is unavailable.
+ * The spliced draft string (see {@link spliceInsert}); pure string math.
+ */
+export declare function insertAtCaret(draft: string, text: string, caret: DraftCaret | null): string;
+/**
+ * Resolve the composer's live caret from its DOM `<textarea>`. The draft
+ * store has no caret API, so the sidebar reads the composed input's selection
+ * directly; the value-sync check (`el.value === draft`) discards stale or
+ * wrong-composer reads — a caret must never be applied against a draft it
+ * was not measured on.
+ *
+ * Returns null when the composer is missing, disabled/read-only, out of
+ * sync with the store draft, or has no measurable selection (odd hosts
+ * report null selectionStart/End).
+ */
+export declare function probeComposerCaret(draft: string): DraftCaret | null;
+/**
+ * Restore the composer caret to `caretIndex` after a programmatic
+ * `setDraft` commit. A controlled textarea update resets the caret (React
+ * commits the value asynchronously and the browser moves the caret to the
+ * start/end), so the placement is scheduled and retried across at most two
+ * animation frames (setTimeout fallback), and only applied when the textarea
+ * still matches `expectedDraft` — a newer edit or a different composer wins
+ * the race untouched. The caret is clamped into the value bounds, mirroring
+ * how browsers clamp type-in positions.
+ */
+export declare function placeComposerCaretAfterInsert(expectedDraft: string, caretIndex: number): void;
+/**
+ * Insert `text` into the session's composer draft at the composer's live
+ * caret (see {@link probeComposerCaret}), falling back to appending at the
+ * end when the caret cannot be resolved. Returns false — and logs — when the
+ * conversation service or the session scope is unavailable.
  */
 export declare function appendToDraft(ctx: Context, sessionId: string, text: string): boolean;
+/**
+ * The DSH `@file` spelling for one relative path, mirroring the host grammar
+ * (`formatFileMention` in `@deepseek-ai/dsh-file-reference`): plain when
+ * there is no whitespace, quoted when there is, and `undefined` when the
+ * path contains a control character or an embedded quote the editor grammar
+ * cannot represent.
+ */
+export declare function fileMention(relativePath: string): {
+    mention: string;
+    label: string;
+} | undefined;
+/**
+ * Insert one FILE reference as a structured chip (like DSH's own `@` picker).
+ * The chip displays `@<basename>` but serializes to `@<relative path>` on
+ * send, so the reference stays a single link from trigger to basename.
+ *
+ * Directories are NOT handled here: DSH's folder grammar wants the trailing
+ * slash as plain text (`@dir/`) so completion can descend, which
+ * `appendToDraft` already covers.
+ */
+export declare function insertFileReference(ctx: Context, sessionId: string, relativePath: string): boolean;

package/lib/types/client/locales.d.ts

@@ -94,6 +94,7 @@ export declare const zh: {
     terminalDepsFailed: string;
     terminalDepsHint: string;
     terminalDepsProfile: string;
+    terminalShellNotFound: string;
     refresh: string;
     refreshUnsavedConfirm: string;
     save: string;
@@ -158,6 +159,18 @@ export declare const zh: {
     producedOpen: string;
     showInFolder: string;
     disconnected: string;
+    terminalWaitBanner: string;
+    terminalSkipWait: string;
+    gitFoldExpand: string;
+    gitFoldLoading: string;
+    gitFoldFailed: string;
+    rename: string;
+    renameInvalid: string;
+    delete: string;
+    deleteTitle: string;
+    deleteDescFile: string;
+    deleteDescDir: string;
+    dismiss: string;
     exited: string;
     noSession: string;
     pluginNotLoaded: string;
@@ -362,26 +375,6 @@ export declare const en: Record<keyof typeof zh, string>;
  * (`'sidebar'` is taken by DSH's own ui-sidebar, hence this distinct name).
  */
 export declare const LOCALE_NS = "betterSidebar";
-/** The ja dictionary (key-set-equal to zh, enforced by the type annotation). */
-export declare const ja: Record<keyof typeof zh, string>;
-export declare const de: Record<keyof typeof zh, string>;
-export declare const fr: Record<keyof typeof zh, string>;
-export declare const pt: Record<keyof typeof zh, string>;
-export declare const ko: Record<keyof typeof zh, string>;
-export declare const ar: Record<keyof typeof zh, string>;
-export declare const hi: Record<keyof typeof zh, string>;
-export declare const id: Record<keyof typeof zh, string>;
-export declare const tr: Record<keyof typeof zh, string>;
-export declare const vi: Record<keyof typeof zh, string>;
-export declare const th: Record<keyof typeof zh, string>;
-export declare const ru: Record<keyof typeof zh, string>;
-export declare const it: Record<keyof typeof zh, string>;
-export declare const nl: Record<keyof typeof zh, string>;
-export declare const sv: Record<keyof typeof zh, string>;
-export declare const pl: Record<keyof typeof zh, string>;
-export declare const zhHK: Record<keyof typeof zh, string>;
-export declare const zhTW: Record<keyof typeof zh, string>;
-export declare const zhMO: Record<keyof typeof zh, string>;
 /**
  * The better-locale override store attached by the client apply
  * (absent → no override; the zh/en chain runs). The store's `active`

package/lib/types/client/selection-popup.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The floating "add selection to conversation" popup shared by the text
+ * viewer: a viewport-anchored button portaled to `document.body`, kept alive
+ * across the selection gesture and committed on click.
+ *
+ * Dismissal contract (upstream issue #425): the popup must never outlive its
+ * editor surface. The sidebar keeps every tab MOUNTED — switching tabs only
+ * flips the pane cell to `display:none` and collapsing the panel translates
+ * it off-screen — while the portaled `position:fixed` button stays pinned to
+ * its viewport anchor, ignoring both. The caller already hides on surface
+ * scrolls, selection collapse and content swaps; this hook adds the global
+ * dismissal that covers everything else:
+ *
+ * - any `mousedown` outside the button (tab bar, composer, another pane,
+ *   the collapse toggle, …) closes it;
+ * - `Escape` closes it;
+ * - the document going hidden (`visibilitychange`) or the window losing
+ *   focus closes it;
+ * - an `IntersectionObserver` on the editor surface closes it as soon as the
+ *   surface leaves the viewport — the tab-switch (`display:none`) and
+ *   panel-collapse (translated off-screen) paths have no DOM events of their
+ *   own, so the geometry signal is the only reliable one.
+ *
+ * The button's own `mousedown` is never treated as an outside click: the
+ * caller preventDefaults it to keep the selection/caret alive until the
+ * click commits (the hook's capture-phase listener runs first and must not
+ * hide for it).
+ */
+import { type RefObject } from 'react';
+/** The floating "add to conversation" action: payload + viewport anchor. */
+export interface SelectionPopup {
+    insert: string;
+    left: number;
+    top: number;
+}
+export interface SelectionPopupOptions {
+    /** Commit the payload into the composer draft (button click). */
+    onCommit(insert: string): void;
+    /**
+     * The DOM surface that must stay on screen for the popup to live: the
+     * CodeMirror host element. Called lazily (refs are null until the content
+     * loads).
+     */
+    getSurface(): HTMLElement | null;
+}
+export interface SelectionPopupControls {
+    /** The current popup (null = hidden). */
+    popup: SelectionPopup | null;
+    /** Attach to the portaled button element. */
+    buttonRef: RefObject<HTMLButtonElement>;
+    /** Anchor the popup above a selection (viewport-clamped). */
+    show(insert: string, left: number, top: number): void;
+    /** Hide the popup (idempotent). */
+    hide(): void;
+    /** The button's click: commit the stored payload, then hide. */
+    commit(): void;
+}
+export declare function useSelectionPopup(options: SelectionPopupOptions): SelectionPopupControls;

package/lib/types/client/service.d.ts

@@ -132,7 +132,7 @@ export interface TabComponentProps {
     /** The explorer's reveal-highlight set (ExplorerView; "Show in folder" targets). */
     revealed?: string[];
     onToggleDir?: (path: string) => void;
-    onReferenceFile?: (path: string) => void;
+    onReferenceFile?: (path: string, isDir: boolean) => void;
     onOpenFile?: (path: string) => void;
     onOpenDiff?: (tab: SidebarTab) => void;
     onSubagentJump?: (childSessionId: string) => void;

package/lib/types/client/state.d.ts

@@ -110,6 +110,17 @@ export interface SidebarState {
     splits: SplitNode;
     /** Free windows (tabs dragged out onto the conversation area). */
     floats: FloatWindow[];
+    /**
+     * Live agent-terminal wait state (uuid → the wait the model currently
+     * blocks on in `terminal_wait_for`), mirrored from the host's
+     * agent-terminals push. Transient by design: sanitizeState never restores
+     * it, so a reload starts clean and the next push (sent immediately on WS
+     * attach) repopulates it.
+     */
+    agentWaits: Record<string, {
+        needle: string;
+        since: number;
+    }>;
 }
 export declare const PANEL_MIN = 280;
 export declare const PANEL_MAX = 640;
@@ -325,6 +336,10 @@ export declare function agentTabId(uuid: string): string;
 export declare function reconcileAgentTerminals(state: SidebarState, agentTerminals: ReadonlyArray<{
     uuid: string;
     title: string;
+    waiting?: {
+        needle: string;
+        since: number;
+    } | null;
 }>): SidebarState;
 /** Immutable snapshot handed to React (replaced only on real changes). */
 export interface SidebarSnapshot {

package/lib/types/client/terminal-font.d.ts

@@ -60,12 +60,35 @@ export declare const ICON_FONT_FALLBACKS: readonly string[];
  * @returns the stack with icon fallbacks merged in.
  */
 export declare function withIconFontFallbacks(stack: string): string;
+/**
+ * Guarantee the stack ends in a generic family, so a font the browser cannot
+ * resolve degrades to a monospace one.
+ *
+ * Without this a stack of unresolvable names (a misspelled family, or one only
+ * installed on the machine running the shell rather than the one running the
+ * browser) falls through to the browser's *standard* font, which is
+ * proportional — xterm then measures its cell from a proportional advance and
+ * the whole grid breaks, rather than merely losing the requested typeface.
+ *
+ * This does not sniff whether the named families exist (an explicit non-goal
+ * of the terminal font design): it only terminates the stack. A stack that
+ * already names a generic family is returned untouched, so a user who
+ * deliberately wrote one keeps it. Generics are matched unquoted only — a
+ * quoted `"monospace"` is a family *name*, not the keyword.
+ *
+ * @param stack - the resolved font-family value.
+ * @returns the stack, ending in a generic family.
+ */
+export declare function withMonospaceFallback(stack: string): string;
 /**
  * Resolve the xterm font options for the given prefs.
  *
  * The base family keeps its existing precedence — user pref > theme code
- * font > built-in stack — and then {@link withIconFontFallbacks} tops it up
- * so prompt icons resolve regardless of which base won.
+ * font > built-in stack. {@link withMonospaceFallback} then terminates the
+ * stack with a generic family so an unresolvable name degrades to a
+ * monospace instead of the proportional standard font, and finally
+ * {@link withIconFontFallbacks} tops it up so prompt icons resolve
+ * regardless of which base won.
  *
  * @param prefs - the current side card preferences.
  * @param themeFontFamily - the app's theme code font (`--ds-font-family-code`

package/lib/types/context-types.d.ts

@@ -430,10 +430,12 @@ export interface SidebarLocaleService {
 }
 /** The composer draft face the sidebar reaches through `ctx.conversation.input`. */
 export interface SidebarSessionInput {
-    /** The live input store (draft read for append). */
+    /** The live input store (draft read for append). `draftRev` is the machine's
+     *  span-CAS revision — required to mint a structured file-reference chip. */
     state: {
         getSnapshot(): {
             draft: string;
+            draftRev?: number;
         };
     };
     /** Replace the draft text (the input machine's single public write path). */

package/lib/types/fs-operations.d.ts

@@ -26,3 +26,45 @@ export declare function writeWorkspaceUpload(input: WorkspaceUploadInput): Promi
     path: string;
     size: number;
 }>;
+/** Inputs of one tree-row rename. */
+export interface WorkspaceRenameInput {
+    /** The session workspace root; the renamed entry must stay inside it. */
+    cwd: string;
+    /** Absolute path of the row as the tree displays it (may be a symlink). */
+    path: string;
+    /** The new base name (single segment — rename never moves across directories). */
+    name: string;
+}
+/**
+ * Rename one tree row within its directory: `path` → `<parent>/<name>`.
+ * The new name must be a single path segment (this is rename, not move);
+ * an existing destination is refused (POSIX rename would clobber it
+ * silently); the workspace root itself is never renamable; a symlink row
+ * renames the link, not its target. A no-op rename (same name) succeeds
+ * without touching the filesystem.
+ *
+ * @throws SidebarError with a wire code for shape, containment, existence
+ * and root failures.
+ */
+export declare function renameWorkspaceEntry(input: WorkspaceRenameInput): Promise<{
+    path: string;
+}>;
+/** Inputs of one tree-row delete. */
+export interface WorkspaceRemoveInput {
+    /** The session workspace root; the removed entry must stay inside it. */
+    cwd: string;
+    /** Absolute path of the row as the tree displays it (may be a symlink). */
+    path: string;
+}
+/**
+ * Delete one tree row permanently (there is no trash on the host): files are
+ * unlinked, directories removed recursively, a symlink row unlinks the LINK
+ * only (lstat decides, so a link to a directory does not recurse into its
+ * target). The workspace root itself is never removable.
+ *
+ * @throws SidebarError with a wire code for containment, existence and
+ * root failures.
+ */
+export declare function removeWorkspaceEntry(input: WorkspaceRemoveInput): Promise<{
+    path: string;
+}>;