dsh-ntr 0.3.1 → 0.3.3

package/lib/types/client/acp-ui.d.ts

@@ -81,6 +81,26 @@ export interface AcpChatInjected {
     acp: AcpStore;
     /** Resolve the session's command/projection face; `undefined` before the session materializes. */
     faceFor(sessionId: string): AcpSessionFace | undefined;
+    /**
+     * The runtime's `sessions.fork` face (the host's own branching primitive,
+     * resolved structurally per call); `undefined` when the host half lacks it —
+     * the branch button then renders disabled (`hostUnavailable`), never hidden.
+     */
+    hostFork?: () => AcpHostForkFace | undefined;
+    /** The workspace's `openSession` face (the branch click's final step). */
+    openSession?: (sessionId: string) => void;
+}
+/** The slice of the client runtime's session service the branch button needs. */
+export interface AcpHostForkFace {
+    /**
+     * Fork the DSH session tree at the latest completed turn. Resolves the CHILD
+     * session id; the host owns the cut-point snapping, history copy, `(1)`
+     * title and workspace attribution — the plugin rewrites none of it.
+     */
+    fork(options: {
+        sessionId: string;
+        increaseTitle?: boolean;
+    }): Promise<unknown>;
 }
 /**
  * The slice of the client runtime's `ConversationSnapshot` our composer entries
@@ -233,6 +253,13 @@ export interface AcpStagedSession {
 /**
  * Which session the composer is currently staged on.
  *
+ * The renderer's own current scope binding is the first answer when the caller
+ * passes it (`currentSessionId`, read from `uiSession.adapter.current` in the
+ * browser entry): that is the exact session the host has selected, while the
+ * list can retain more than one row in a multi-view layout. Falling back to
+ * the list is still required — a host without that scope adapter, and the old
+ * snapshot shape below, have no better source.
+ *
  * Old runtimes answer from `snapshot.current` (with `currentAddress` as the
  * subagent marker). rc.2 has no `current`: the staged session is the row the
  * main view retains (`retainedBy.mainView > 0`) — the exact rule
@@ -240,10 +267,15 @@ export interface AcpStagedSession {
  * row with `origin === "subagent"` is an addressed subagent route. `undefined`
  * when nothing is staged yet (the list has not loaded, or no row holds the main
  * view): callers must stand down rather than guess.
+ *
+ * A current id the list has no row for is ALSO `undefined`: the selection may
+ * be a subagent address, and guessing "not a subagent" there would let the
+ * gate install ACP chrome on a route the plugin must not drive. The next list
+ * notification retries.
  */
-export declare function stagedSessionOf(snapshot: AcpSessionsSnapshot | undefined): AcpStagedSession | undefined;
+export declare function stagedSessionOf(snapshot: AcpSessionsSnapshot | undefined, currentSessionId?: string): AcpStagedSession | undefined;
 /** Whether the staged session runs the ACP agent preset. */
-export declare function stagedIsAcpMode(snapshot: AcpSessionsSnapshot | undefined, acpMode?: (sessionId: string) => boolean | undefined): boolean;
+export declare function stagedIsAcpMode(snapshot: AcpSessionsSnapshot | undefined, acpMode?: (sessionId: string) => boolean | undefined, currentSessionId?: string): boolean;
 /**
  * The ACP-mode verdict a committed `agent-preset/selected` frame carries. The
  * frame is `[sessionId, agentPreset]` and the runtime broadcasts it the moment

package/lib/types/client/acp-view.d.ts

@@ -12,7 +12,7 @@
  * spawns. Everything it shows is host state.
  */
 import type { AcpChatInjected } from './acp-ui.tsx';
-import type { AgentView, ChatSessionView } from '../protocol.ts';
+import type { AgentView, ChatSessionView, SessionView } from '../protocol.ts';
 /** Props of the ACP view entry (injected face + the frame's session id). */
 export interface AcpViewProps extends AcpChatInjected {
     sessionId: string;
@@ -43,6 +43,17 @@ export declare function diffRows(oldText: string | null, newText: string): DiffR
  * the new content — the degenerate case where there is no edit at all.
  */
 export declare function isNewFileDiff(oldText: string | null, newText: string): boolean;
+/**
+ * Whether an empty stream means "history exists but is not shown yet": the
+ * record was restored from disk after a host restart (the agent's replay has
+ * not landed), or a resume cleared the buffer ahead of the replay. The view
+ * then promises the replay instead of claiming the conversation never
+ * happened — "还没有消息" to someone whose chat plane still shows yesterday's
+ * turns is exactly the kind of contradiction this file's copy rules exist to
+ * prevent. In-memory released sessions keep their buffer, so this only fires
+ * when the buffer really is absent.
+ */
+export declare function historyAwaitsReplay(session: Pick<SessionView, 'released' | 'hasHistory'>): boolean;
 /**
  * Everything the view can read that says "this conversation is set up on an
  * agent": a live or parked ACP session, the host's binding (`session/chat-list`'s
@@ -101,5 +112,5 @@ export declare function acpEmptyCopy(facts: AcpEmptyFacts, t: Translate): AcpEmp
  * The ACP view tab body: who serves this conversation and how it is doing,
  * then the agent's own stream.
  */
-export declare function AcpConversationView(props: AcpViewProps): import("react").JSX.Element;
+export declare function AcpConversationView(props: AcpViewProps): import("react").JSX.Element | null;
 export {};

package/lib/types/client/activity-pill.d.ts

@@ -0,0 +1,81 @@
+/**
+ * The composer dock's `x轮x步 · xx tok/s` pill on an ACP conversation.
+ *
+ * WHY SHADOW INSTEAD OF A SECOND PILL: the host's `ActivityPill` already states
+ * the two things this conversation has — turn/step counts and a whole-session
+ * decode speed — in the one place a speed belongs. Only its speed is wrong for
+ * ACP: the host divides the tokens a step emitted by `firstTokenTime →
+ * completedTime`, and that window contains every tool wait. Rendering a second
+ * speed beside it would leave two numbers on screen and no way to tell which
+ * is the honest one. So this module takes the host pill's own cell (`list` slot
+ * `conversation.composer.dock`, id `activity`) at a lower priority, renders the
+ * HOST's component, and hands it a patched `sessionStats` whose decode fields
+ * are the plugin's burst aggregate. Style, counts, dialog, aria and locale stay
+ * the host's; only the number changes.
+ *
+ * NON-ACP CONVERSATIONS PASS THROUGH. The shadow is installed only while the
+ * gate confirms the staged conversation runs the ACP preset, but a list entry
+ * is projected into EVERY session's composer. The wrapper therefore renders the
+ * host component with the ORIGINAL projection whenever `acpMode` is not
+ * affirmatively true, making the shadow visually indistinguishable from the
+ * shipped entry there.
+ *
+ * FAIL-OPEN IS STRUCTURAL: if the host entry, its inject face, its locale or
+ * its `performanceUsage` source is missing, no claim is created and the native
+ * pill stays exactly as shipped. If the host component rejects the patched
+ * projection, the slot's error boundary retires this entry and the native
+ * `activity` entry wins again. No CSS hiding and no DOM patching are involved.
+ */
+import type { SessionBurst } from '../protocol.ts';
+import type { AcpStore, UiState } from './store.ts';
+import type { ModelSeatClaim, SeatSlots } from './model-seat.tsx';
+export declare const DOCK_SLOT = "conversation.composer.dock";
+export declare const ACTIVITY_ENTRY_ID = "activity";
+type ActivityProjection = (key: string, selector?: (value: unknown) => unknown) => unknown;
+type ActivityPerformanceHook = (selector?: (value: unknown) => unknown) => unknown;
+type ActivityTranslate = (key: string, params?: Record<string, unknown>) => string;
+/** The standard kit + injected face the shadow renders the host component with. */
+export interface ActivityPillHostProps {
+    sessionId: string;
+    useChat: unknown;
+    useProjection: ActivityProjection;
+    usePerformanceUsage: ActivityPerformanceHook;
+    t?: ActivityTranslate;
+    acp: AcpStore;
+}
+/**
+ * The aggregate the dock should show: the sum of every ACP session backing this
+ * chat (the host pill's counts are whole-chat too), with a live `turn/metrics`
+ * entry preferred per session over its persisted row. `undefined` means "no
+ * measurable burst yet" — the wrapper then hides the speed instead of showing
+ * the host's tool-inclusive number.
+ */
+export declare function activityBurst(ui: Pick<UiState, 'chatSessions' | 'chatSessionsFor' | 'burstStats'>, dshSessionId: string): SessionBurst | undefined;
+/**
+ * Replace ONLY the decode half of the host's session stats.
+ *
+ * `decodeTokens` and `decodeMs` are the two fields the host's `decodeSpeed`
+ * reads (`decodeTokens / (decodeMs / 1000)`), so writing the plugin's aggregate
+ * there makes the host's own formatter, dialog row and aria label display the
+ * plugin's burst rate. Every other field — turns, steps, LLM/tool/TTFT — stays
+ * host-native. With no measurable burst the two decode fields are zeroed: the
+ * host then hides the speed (`decodeMs > 0` guard) while keeping the counts.
+ */
+export declare function patchedActivityStats(native: Record<string, unknown> | undefined, burst: SessionBurst | undefined, acp: boolean): Record<string, unknown> | undefined;
+export interface ActivityPillClaimOptions {
+    slots: SeatSlots;
+    /** Session-scoped face factory (the gate's `chatFace`). */
+    inject(sessionId: unknown, actions?: unknown): unknown;
+    onDiag?(line: string): void;
+    maxClaims?: number;
+}
+/**
+ * Take the dock's `activity` cell for one ACP-mode spell.
+ *
+ * Returns `undefined` on any host shape this bundle cannot serve — an older
+ * host without the `activity` entry (0.1.5 ships `stats`), a slot kind change,
+ * a missing inject/locale, or no `performanceUsage` source. The native pill is
+ * then left untouched; that is the honest failure mode, not a hidden control.
+ */
+export declare function createActivityPillClaim(options: ActivityPillClaimOptions): ModelSeatClaim | undefined;
+export {};

package/lib/types/client/branch-action.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The NTR branch button (slot `conversation.chat.assistant-actions`): in an
+ * ACP conversation this is the ONLY branch entry — the host's like / dislike /
+
+ * branch icons are hidden under `html[data-ntr-acp]` (see acp-ui.tsx), and
+ * this button takes the host branch's place with the same icon, size and
+ * row position (order 20, after the hidden feedback entry's order 10).
+ *
+ * Clicking runs the fixed two-stage branch: the HOST forks the DSH session
+ * tree first (`sessions.fork`, structurally resolved), then the plugin adopts
+ * the ACP side (`session/chat-fork-adopt` → the agent's own `session/fork`),
+ * so the child conversation's agent actually remembers the parent context —
+ * see the NTR message-actions plan, §D5/§D7.
+ *
+ * Availability is the store's `forkStateOf` six-state mapping over facts the
+ * button never derives itself: the host's per-row `fork` verdict
+ * (`session/chat-list`), the SSE running flag, the host-fork structural probe,
+ * and the DOM tail verdict. The tail check reads the host's OWN
+ * `[data-turn-tail]` marker (`data-actions-reveal === "always"` = the latest
+ * completed turn) and fails CLOSED: a missing marker disables the button
+ * rather than risking a fork cut at a point the user is not looking at.
+ */
+import type { ComponentType } from 'react';
+import type { AcpChatInjected, AcpHostForkFace } from './acp-ui.tsx';
+/**
+ * Resolves the runtime's `sessions.fork` primitive, binding it to the service
+ * instance so that internal `this` accesses (such as `this.list.getSnapshot()`)
+ * resolve correctly when called through `face.fork(...)`.
+ * Returns `undefined` if the service or `fork` method is absent or not a function.
+ */
+export declare function resolveHostFork(sessionsService: unknown): AcpHostForkFace | undefined;
+/**
+ * The host's own branch-button icon, picked per host generation. The icon
+ * exports MOVED between shipped hosts — desktop 0.2.1-rc.2 has
+ * `IconBranchOutlineRegular` / `…Medium` but NOT `…16`, newer packages export
+ * `…16` — and a hard import of one name compiles to a plain property read
+ * (`primitives.IconBranchOutline16`), so the missing export is `undefined`
+ * and `<undefined />` throws "Element type is invalid". The slot's error
+ * boundary then abdicates the whole entry: no button, no tooltip, nothing in
+ * any log — the exact silent disappearance this picker exists to prevent.
+ * Rendering the button never depends on the icon: with all three absent the
+ * click still works, only the 28px glyph is missing.
+ */
+export declare function branchIconOf(source: Record<string, unknown>): ComponentType<Record<string, never>> | undefined;
+export declare function AcpBranchAction(props: AcpChatInjected & {
+    sessionId: string;
+}): import("react").JSX.Element | null;

package/lib/types/client/composer-mode.d.ts

@@ -50,4 +50,32 @@ export interface ComposerModeProps {
  * gone and this select is the mode switch the user actually has.
  */
 export declare function agentModeTitle(agentId: string | undefined, acp: AcpStore): string;
+/**
+ * Whether this conversation is one the agent-mode control may serve.
+ *
+ * An EXPLICIT non-ACP verdict outranks a lingering session row: switching a
+ * conversation off the NTR preset does not close its ACP session, so "a row
+ * exists" alone would keep this control on an ordinary conversation — the same
+ * precedence the agent tag, the context ring and the released banner already
+ * apply. Only while the host has not answered (`undefined`) does a bound
+ * session count as proof, which is what keeps the control available before the
+ * host's first `session/chat-list` answer lands.
+ */
+export declare function agentModeVisible(acpMode: boolean | undefined, hasBoundSession: boolean): boolean;
+/**
+ * The mode the select shows as in force.
+ *
+ * A LIVE session is the authority (it is what the agent runs right now). A
+ * RELEASED row only describes the mode the agent was parked ON, so a newer
+ * pick — which `applyChatChoice` will apply on the next resume — outranks it
+ * (and the parked row still beats the catalog default). Same precedence as
+ * the model and thought level in `describeRoute`: a pre-switch on a parked
+ * session must be visible or the control reads as dead.
+ */
+export declare function modeInForce(target: {
+    released?: boolean;
+    modes?: {
+        currentModeId?: string;
+    };
+} | undefined, persisted: string | undefined, fallback?: string): string;
 export declare function AcpComposerMode({ acp, sessionId, useSession }: ComposerModeProps): import("react").JSX.Element | null;

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

@@ -0,0 +1,51 @@
+/**
+ * Composer context-occupancy ring at `conversation.composer.dock` — the bottom
+ * info row below the input card, where the host also renders its ContextMeter.
+ *
+ * WHY A PLUGIN-OWNED RING: the host's meter reads its `contextPressure`
+ * projection, folded from DSH provider-usage samples plus a route capacity. An
+ * ACP conversation produces neither — the agent owns the request and the host
+ * never sees its prompt — so the native meter renders nothing there. This ring
+ * reports the agent's OWN `usage_update` used/size instead: occupancy only. ACP
+ * declares no system/tools/messages split, so no breakdown is invented.
+ *
+ * Registered for every conversation and gating itself: it renders only for an
+ * ACP conversation whose session row carries usage. The row comes from
+ * `session/chat-list`; the store live-patches it from the coalesced
+ * `usage_update` frames (see `AcpStore.flushUpdates`).
+ */
+import type { AcpSessionHook } from './acp-ui.tsx';
+import type { AcpStore, UiState } from './store.ts';
+import type { SessionView } from '../protocol.ts';
+/** Props of the composer entry (injected face + the frame's standard kit). */
+export interface AcpContextMeterProps {
+    /** Injected face: the chat session id this entry belongs to. */
+    sessionId: string;
+    /** Framework-bound conversation snapshot hook (`SessionStandardProps.useSession`). */
+    useSession: AcpSessionHook;
+    acp: AcpStore;
+}
+export interface ContextOccupancy {
+    /** Rounded occupancy percentage, clamped to 0..100. */
+    percent: number;
+    used: number;
+    size: number;
+}
+/**
+ * The sample this conversation's ring should show, or `undefined` when the
+ * entry must render nothing. An explicit `acpMode === false` outranks a stale
+ * `chatSessions` row: the conversation's preset left NTR while its ACP session
+ * was still alive, and the ring must leave with it (same precedence as the
+ * agent tag's `agentTagVisible`). While the verdict is unknown, a LIVE row is
+ * proof; a PARKED one is not — it can outlive the preset switch, and the ring
+ * must not appear on an ordinary conversation during the answer window.
+ */
+export declare function acpMeterUsage(ui: Pick<UiState, 'acpMode' | 'chatSessions' | 'chatSessionsFor'>, dshSessionId: string): SessionView['usage'] | undefined;
+/**
+ * Bounded display occupancy from one agent sample. `undefined` (no meter) for
+ * an absent / malformed / zero-capacity sample rather than a made-up 0%.
+ */
+export declare function contextOccupancy(usage: SessionView['usage'] | undefined): ContextOccupancy | undefined;
+/** Compact token count for the tooltip, in the host meter's K/M shape. */
+export declare function compactTokenCount(value: number): string;
+export declare function AcpContextMeter({ acp, sessionId, useSession }: AcpContextMeterProps): import("react").JSX.Element | null;

package/lib/types/client/model-seat.d.ts

@@ -122,7 +122,13 @@ export interface SeatEntry {
     options?: {
         priority?: number;
         registrant?: string;
+        id?: string;
+        order?: number;
     };
+    /** Entry-owned inject face; needed when the claim reuses a shipped occupant. */
+    inject?: (...args: unknown[]) => unknown;
+    /** Locale namespace the occupant's `t` is bound to; needed for the same reuse. */
+    locale?: string;
 }
 /** The slot-registry face this module uses (structural: the registry is not a dependency of this bundle). */
 export interface SeatSlots {
@@ -142,6 +148,12 @@ export interface SeatSlots {
  */
 export interface SeatRegisterOptions {
     name: string;
+    /** List-slot cell to shadow; omitted for single/keyed registers. */
+    id?: string;
+    /** Display position within the list; only meaningful with `id`. */
+    order?: number;
+    /** Locale namespace the occupant's `t` is bound to. */
+    locale?: string;
     priority?: number;
     /**
      * The session-scoped face factory the renderer calls with the scope binding's
@@ -218,6 +230,15 @@ export interface PermissionSeatClaimOptions {
 export interface SeatClaimOptions {
     slots: SeatSlots;
     slotKey: string;
+    /**
+     * List-slot cell id to hold. Omitted for single/keyed seats; a list slot
+     * needs it because its winner view is one entry PER id, not one per slot.
+     */
+    entryId?: string;
+    /** Display order for the installed list entry (same cell, so usually the shipped order). */
+    order?: number;
+    /** Locale namespace the installed occupant resolves `t` against. */
+    locale?: string;
     basePriority: number;
     occupant(): unknown;
     inject?(sessionId: unknown, actions?: unknown): unknown;

package/lib/types/client/released-banner.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The conversation's released-session banner: one row above the composer
+ * (`conversation.input.dock`) saying the agent process behind this
+ * conversation has been released, with the explicit resume button.
+ *
+ * WHY A BANNER: releasing a process is deliberately silent (constraint 19 —
+ * an idle teardown is the expected lifecycle, no `agent/notice`), and the
+ * only other trace was the NTR view tab's status badge — a surface most
+ * users never open. The "your next message resumes it" promise is real but
+ * unverifiable from the chat itself, so the banner states it here and the
+ * button turns it into a gesture (`session/chat-resume`), the explicit form
+ * of the same recovery the next prompt performs lazily.
+ *
+ * The gate is a pure function ({@link releasedBannerVisible}) — the seam the
+ * composer's other visibility decisions use, so the rules are testable with
+ * no DOM. Like the agent tag and the context ring, an explicit
+ * `acpMode === false` outranks a lingering `chatSessions` row: a conversation
+ * that left NTR mode must not keep claiming a parked NTR process.
+ */
+import type { AcpStore, UiState } from './store.ts';
+export interface ReleasedBannerProps {
+    /** Injected face: the store plus the chat session id this banner belongs to. */
+    acp: AcpStore;
+    sessionId: string;
+}
+/**
+ * Whether the banner should render: this conversation's ACP session records
+ * are all released — the process is parked (idle release or crash) and
+ * nothing is live to serve the next message yet. An empty list (no agent has
+ * run here) and a live row anywhere both mean "nothing to recover", so the
+ * banner stays out of the way.
+ */
+export declare function releasedBannerVisible(ui: Pick<UiState, 'acpMode' | 'chatSessions' | 'chatSessionsFor'>, dshSessionId: string): boolean;
+export declare function ReleasedBanner({ acp, sessionId }: ReleasedBannerProps): import("react").JSX.Element | null;

package/lib/types/client/slash-isolation.d.ts

@@ -107,7 +107,7 @@ export interface SlashIsolation {
  * caller reads as "not ACP" (fail-open: an ordinary conversation must never
  * lose its native commands to a guess).
  */
-export declare function slashAcpVerdict(snapshot: AcpSessionsSnapshot | undefined, sessionId: string, verdict: (sessionId: string) => boolean | undefined): boolean | undefined;
+export declare function slashAcpVerdict(snapshot: AcpSessionsSnapshot | undefined, sessionId: string, verdict: (sessionId: string) => boolean | undefined, currentSessionId?: string): boolean | undefined;
 /**
  * The agent's commands as menu rows, ranked the way the host ranks its own
  * menu: the query matches as a case-insensitive ordered subsequence of the

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

@@ -5,7 +5,7 @@
  *
  * Deliberately framework-free: React binds through `useSyncExternalStore`.
  */
-import type { AcpApprovalDeadlines, AcpConversationChoice, AcpPresetStatus, AcpTagHalo, AgentCatalogResult, AgentProbeModelsResult, AgentSavePayload, AgentTestResult, AgentView, ChatSessionView, DetectedAgentInfo, PermissionTimeoutMode, PluginUpdateState, SessionView } from '../protocol.ts';
+import type { AcpApprovalDeadlines, AcpConversationChoice, AcpIdleRelease, AcpPresetStatus, AcpTagHalo, AgentCatalogResult, AgentProbeModelsResult, AgentSavePayload, AgentTestResult, AgentView, ChatSessionView, DetectedAgentInfo, PermissionTimeoutMode, PluginUpdateState, SessionView } from '../protocol.ts';
 /** One slash command the ACP agent declared, whole row (the menu draws name, description and `input.hint`). */
 export type AgentCommand = NonNullable<ChatSessionView['availableCommands']>[number];
 /** The unary RPC face (narrowed `ctx.connection.rpc.call`). */
@@ -117,6 +117,33 @@ export declare const PERMISSION_DEADLINE_EXPIRED = "expired";
  * settings-panel ledger.
  */
 export declare function permissionsForSession(permissions: readonly PendingPermission[], dshSessionId: string): PendingPermission[];
+/** The branch button's six states (the NTR message-actions plan, §D4). */
+export type ChatForkState = 'ready' | 'unsupported' | 'released' | 'busy' | 'notTail' | 'hostUnavailable';
+/**
+ * The branch click's outcome: the child DSH session id on success, or one
+ * actionable failure line (also flashed into the notice banner — the line is
+ * the conversation's local copy of the same failure).
+ */
+export type ChatForkOutcome = {
+    childId: string;
+} | {
+    failure: string;
+};
+/**
+ * The branch button's state for one conversation, in the precedence it renders:
+ * the host service missing beats everything (nothing can work), then the
+ * agent's fork capability, then the session's own state (a parked session
+ * before a running one), then the DOM's tail verdict, and only then ready.
+ *
+ * Every input is a fact someone else owns — the row's `fork` verdict is the
+ * host's, `hostFork` is the structural probe of the runtime's `sessions.fork`,
+ * `isTail` is read from the host's own `[data-turn-tail]` marker, and
+ * `liveRunning` is the SSE-driven running flag (the row's own `running` only
+ * refreshes on a chat-list read, so it would answer last turn). `undefined`
+ * facts degrade CLOSED: no row and no `fork` verdict both read as not-ready,
+ * never as a click-through.
+ */
+export declare function forkStateOf(row: ChatSessionView | undefined, hostFork: boolean, isTail: boolean, liveRunning?: boolean): ChatForkState;
 /**
  * Compact countdown for one ask, or `undefined` when there is nothing to count
  * down (`wait` mode, or a frame without a deadline). Pure so the formatting is
@@ -227,6 +254,16 @@ export interface UiState {
     chatSessions: ChatSessionView[];
     /** The DSH chat session id {@link chatSessions} was loaded for. */
     chatSessionsFor?: string;
+    /**
+     * Live burst aggregate per ACP session id, from `turn/metrics`. Absent means
+     * no measured burst yet; a row's persisted `burst` is the reload seed.
+     */
+    burstStats: Record<string, {
+        outputTokens: number;
+        burstMs: number;
+        turnId: string;
+        final: boolean;
+    }>;
     /**
      * The agent tag's halo preference (settings-editable display choice). The
      * tag reads it per render; the host answer in `resync` is the authority and
@@ -240,6 +277,12 @@ export interface UiState {
      * host answer (returned by the same route) is the authority.
      */
     approvalDeadlines?: AcpApprovalDeadlines;
+    /**
+     * The idle-release window in force, as the settings page edits it.
+     * Absent on a host half from before the tab existed, which hides the
+     * tab rather than showing a number this browser invented.
+     */
+    idleRelease?: AcpIdleRelease;
     /**
      * Per-chat-session "does this conversation run the ACP preset" verdicts, as
      * reported by `session/chat-list` (host-read from the session log). The
@@ -368,6 +411,13 @@ export declare class AcpStore {
     private readonly openTurns;
     /** In-flight `session/chat-list` reads, keyed by chat session id. */
     private readonly chatSessionReads;
+    /**
+     * ACP session ids whose chat-list row was requested mid-turn (one read each).
+     * A conversation's first ACP session does not exist when the composer's
+     * mount/running read fires, so its first `usage_update` would find no row to
+     * patch; `turn/start` asks again once the host has materialized the session.
+     */
+    private readonly chatSessionRowReads;
     /**
      * Chat sessions whose list has answered at least once in this page. The
      * FIRST answer only seeds the lock; a lock appearing on a later answer is a
@@ -601,6 +651,13 @@ export declare class AcpStore {
      * being the one authorized exception. Same no-op-when-unchanged discipline as
      * the other accessors, so a frame restating the held verdict costs no
      * listener churn.
+     *
+     * The seat gate (`syncAcpMode`) is the SECOND caller: it folds the runtime
+     * row's own `agentPreset` — the same session-log source the frames announce —
+     * through here, in both directions. That hands the row the frame's authority
+     * on purpose (one provenance, one rank): a stale projection is corrected by
+     * the gate's next evaluation with fresher row data, and only HOST READS are
+     * barred from regressing what the runtime itself already said.
      */
     noteAcpMode(dshSessionId: string, acpMode: boolean): void;
     /**
@@ -643,6 +700,36 @@ export declare class AcpStore {
      * reports (a rejected switch must not leave an optimistic lie on screen).
      */
     setChatSessionMode(dshSessionId: string, modeId: string, agentId?: string): Promise<void>;
+    /**
+     * Bring the conversation's released ACP session back on a fresh process —
+     * the released banner's explicit form of the "next message resumes it"
+     * promise (`session/chat-resume`). A failure is reported through the notice
+     * AND rethrown (the `respondPermission` contract), so the banner can pin
+     * the message beside the button the user just pressed; the binding is
+     * re-read either way so the row follows the host's real answer.
+     */
+    resumeChatSession(dshSessionId: string): Promise<void>;
+    /**
+     * Branch one conversation (the NTR branch button's click): the fixed
+     * two-stage order — the HOST forks the DSH session tree first (copied
+     * history, `(1)` title, workspace), then the plugin adopts the ACP side via
+     * `session/chat-fork-adopt`, which runs the agent's own `session/fork` so
+     * the child actually remembers the parent context. Host first is structural:
+     * ACP fork has no cut-point parameter and nothing to return to if the host
+     * half failed second (see the plan's §D7).
+     *
+     * Resolves `{ childId }` on success, or `{ failure }` with one actionable
+     * line — the reason is ALSO flashed into the notice banner (a user-action
+     * failure, so the banner is its surface), and the local line is what the
+     * conversation renders beside the button (the user is not on the settings
+     * page). A failed adopt leaves the child an ordinary copied-history
+     * conversation (its first message starts a fresh `session/new` — today's
+     * behavior), never a half-bound one, and NOTHING is opened.
+     *
+     * `forkHost` is the runtime's `sessions.fork` face, resolved structurally by
+     * the entry and injected here: the store stays transport-free.
+     */
+    forkChatSession(dshSessionId: string, forkHost: (sessionId: string) => Promise<unknown>): Promise<ChatForkOutcome>;
     /**
      * Start (or refresh) observation of every ACP transcript behind one DSH chat
      * session. Blocks are rebuilt from scratch — the host buffer is the record,
@@ -702,6 +789,20 @@ export declare class AcpStore {
     setApprovalTimeoutMode(mode: PermissionTimeoutMode): Promise<void>;
     /** Drop the persisted override: the config file (or the built-in default) decides again. */
     resetApprovalDeadlines(): Promise<void>;
+    /**
+     * Write the idle-release window (in ms).
+     *
+     * The host answer — the same route returns the window now in force — is
+     * the authority, so an optimistic write that the host trims self-corrects
+     * instead of drifting from what runs.
+     */
+    setIdleRelease(idleTimeoutMs: number): Promise<void>;
+    /**
+     * Drop the persisted override: the config file (or the built-in default)
+     * decides again.
+     */
+    resetIdleRelease(): Promise<void>;
+    private writeIdleRelease;
     private writeApprovalDeadlines;
     /**
      * Bind one DSH chat session to an ACP agent. This is the plugin's own
@@ -765,4 +866,10 @@ export declare class AcpStore {
 export declare function foldUpdate(blocks: Block[], update: Record<string, unknown>): boolean;
 /** Notifications that update the SessionView snapshot instead of the block stream. */
 export declare const STATE_ONLY_UPDATES: ReadonlySet<string>;
+/**
+ * Context occupancy carried by one raw `usage_update` frame, in the shape the
+ * session snapshots already use. A malformed frame is ignored (the last good
+ * sample stays on screen) instead of zeroing the meter.
+ */
+export declare function usageFromUpdate(update: Record<string, unknown>): SessionView['usage'] | undefined;
 export {};