dsh-ntr 0.3.1 → 0.3.2

package/lib/impl.js

@@ -5,7 +5,7 @@
  * fakes.
  */
 import { randomUUID } from "./ids.js";
-import { DEFAULT_TAG_HALO } from "./protocol.js";
+import { DEFAULT_IDLE_TIMEOUT_MS, DEFAULT_TAG_HALO, IDLE_RELEASE_MS } from "./protocol.js";
 export { randomUUID };
 /** Structured failure the RPC layer converts to `{ok:false, error}` and `apply()` surfaces at boot. */
 export class AcpError extends Error {
@@ -158,6 +158,20 @@ export function validateApprovalDeadlines(value) {
     }
     return out;
 }
+/**
+ * Validate the idle-release window the settings page writes.
+ *
+ * The window is expressed in MILLISECONDS on the shared ladder
+ * ({@link IDLE_RELEASE_MS}), so a value the slider can produce is always a
+ * value the host runs — the same one-ladder rule the approval deadline card
+ * follows.
+ */
+export function validateIdleReleaseMs(raw, code) {
+    if (typeof raw !== 'number' || !Number.isInteger(raw) || !IDLE_RELEASE_MS.includes(raw)) {
+        throw new AcpError(code, `acp: idleTimeoutMs must be one of ${IDLE_RELEASE_MS.join(', ')}`);
+    }
+    return raw;
+}
 /**
  * Validate the mode a write asks for. Three values, and the list is the whole
  * vocabulary: an unanswered ask is either answered for you, kept waiting, or
@@ -502,6 +516,14 @@ export function validateConfig(raw) {
     // `abort` a zero window would refuse every ask on arrival — the agent stops
     // at every gate — so it becomes the shortest real wait.
     const effectivePermissionTimeoutMs = normalizeApprovalWindow(permissionTimeoutMode, permissionTimeoutMs);
+    // The chat-process idle-release window (the settings page edits it).
+    // Same shape as the per-agent field: 0 = never release, otherwise an
+    // integer number of milliseconds.
+    const idleTimeoutMs = value.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+    if (typeof idleTimeoutMs !== 'number' || !Number.isInteger(idleTimeoutMs)
+        || idleTimeoutMs > 86_400_000 || (idleTimeoutMs !== 0 && idleTimeoutMs < 1_000)) {
+        throw new AcpError('bad_config', 'acp: idleTimeoutMs must be 0 (never release) or an integer in [1000, 86400000]');
+    }
     const cancelFallbackMs = value.cancelFallbackMs ?? 15_000;
     if (typeof cancelFallbackMs !== 'number' || !Number.isInteger(cancelFallbackMs) || cancelFallbackMs < 0 || cancelFallbackMs > 600_000) {
         throw new AcpError('bad_config', 'acp: cancelFallbackMs must be an integer in [0, 600000] (0 = disable the fallback)');
@@ -543,6 +565,7 @@ export function validateConfig(raw) {
         turnStallMs,
         turnStallToolMs,
         turnStallTickMs,
+        idleTimeoutMs,
     };
 }
 // ---- Workspace guard ----
@@ -1733,6 +1756,26 @@ export async function dispatchRpc(manager, endpoint, payload) {
                 await manager.setChatSessionMode?.(dshSessionId, modeId, optionalStr(body, 'agentId', 64));
                 return ok({ done: true });
             }
+            case 'session/chat-resume': {
+                // The released-session banner's explicit resume: the recovery the next
+                // prompt performs lazily, on the user's gesture instead. Addressed by
+                // DSH chat session id, like the rest of the conversation surfaces.
+                const dshSessionId = str(body, 'dshSessionId', 128);
+                await manager.resumeChatSession?.(dshSessionId);
+                return ok({ done: true });
+            }
+            case 'session/chat-fork-adopt': {
+                // The second half of a branched conversation: bind the DSH session the
+                // host's `sessions.fork` just created to the agent's own `session/fork`
+                // of the parent's live ACP session. Both ids are validated before the
+                // optional call — the same shape rule as `session/chat-list` above.
+                // The adopted ids ride the answer (the protocol's ChatForkAdoptResult);
+                // a manager without the method keeps the plain `done` shape.
+                const dshSessionId = str(body, 'dshSessionId', 128);
+                const parentDshSessionId = str(body, 'parentDshSessionId', 128);
+                const adopted = await manager.adoptForkedSession?.(dshSessionId, parentDshSessionId);
+                return ok(adopted ?? { done: true });
+            }
             case 'session/chat-bind': {
                 // Point one chat conversation at an ACP agent. The plugin's own
                 // conversation↔agent mapping — NOT a DSH model route (see
@@ -1820,6 +1863,16 @@ export async function dispatchRpc(manager, endpoint, payload) {
                 await manager.setApprovalDeadlines?.(patch, body.reset === true);
                 return ok({ deadlines: manager.approvalDeadlines?.() });
             }
+            case 'ui/idle-release':
+                // Absent on a host half from before the tab existed: the browser then
+                // renders nothing rather than a number it cannot trust.
+                return ok({ idleRelease: manager.idleRelease?.() });
+            case 'ui/idle-release-set': {
+                const reset = body.reset === true;
+                const idleTimeoutMs = reset ? undefined : validateIdleReleaseMs(body.idleTimeoutMs, 'bad_payload');
+                await manager.setIdleRelease?.(idleTimeoutMs, reset);
+                return ok({ idleRelease: manager.idleRelease?.() });
+            }
             case 'agent/set-exposed-models': {
                 const agentId = str(body, 'agentId', 64);
                 const raw = body.exposedModels;

package/lib/index.js

@@ -32,6 +32,7 @@ export function apply(ctx, config) {
         turnStallMs: resolved.turnStallMs,
         turnStallToolMs: resolved.turnStallToolMs,
         turnStallTickMs: resolved.turnStallTickMs,
+        idleTimeoutMs: resolved.idleTimeoutMs,
     });
     const adapter = new AcpLlmAdapter(manager);
     // Built-in update: the plugin never downloads or swaps files itself. The
@@ -66,6 +67,12 @@ export function apply(ctx, config) {
         ? rawConfig.permissionTimeoutMode
         : undefined;
     manager.setConfiguredApprovalDeadlines(configuredDeadlines, configuredMode);
+    // The idle-release baseline the settings page's pick outranks. Only the
+    // raw value counts: `validateConfig` fills a default in, so the
+    // validated number cannot tell "the file says 10 minutes" from
+    // "the file says nothing, so 30 minutes applies".
+    const configuredIdleTimeoutMs = typeof rawConfig.idleTimeoutMs === 'number' ? rawConfig.idleTimeoutMs : undefined;
+    manager.setConfiguredIdleRelease(configuredIdleTimeoutMs);
     // Boot hook kept only so this entry point's shape does not change:
     // `bootstrapCatalogs` is intentionally empty — boot never spawns an agent,
     // in any environment and for any `probeModelsOnBoot` value. Catalogs fill

package/lib/protocol.js

@@ -17,3 +17,22 @@
  */
 /** Default when nothing was ever saved: the breathing halo at normal speed. */
 export const DEFAULT_TAG_HALO = { mode: 'breath', speed: 'normal' };
+/**
+ * The idle-release windows the settings page offers, in MILLISECONDS.
+ *
+ * ONE ladder, shared by both halves: the browser snaps its slider to these
+ * values and the host accepts only these values, so a window the slider can
+ * produce is always a window the host runs. The first rung is 1 minute (an
+ * aggressive release), the rest are 5-minute steps up to an hour.
+ */
+export const IDLE_RELEASE_MS = [
+    60_000, 300_000, 600_000, 900_000, 1_200_000, 1_500_000, 1_800_000, 2_100_000, 2_400_000, 2_700_000, 3_000_000, 3_300_000, 3_600_000,
+];
+/**
+ * The built-in idle-release window for chat processes: 30 minutes.
+ *
+ * Lives beside the ladder it is a rung of, so the two cannot drift: a
+ * deployment that names no window of its own runs this, and the settings
+ * page's reset returns to it.
+ */
+export const DEFAULT_IDLE_TIMEOUT_MS = 1_800_000;

package/lib/types/bridge.d.ts

@@ -9,7 +9,7 @@
 import { type InitializeResponse } from '@agentclientprotocol/sdk';
 import { EventHub, PermissionLedger, Transcript } from './impl.ts';
 import type { AcpToolCallSnapshot, PendingPermissionView, RosterPresetRow } from './impl.ts';
-import type { AcpAgentCatalog, AcpAgentDef, AcpApprovalDeadlines, AcpConversationChoice, AcpPresetStatus, AcpReleaseCause, AcpTagHalo, AgentCatalogResult, AgentProbeModelsResult, AgentTestResult, AgentView, ChatSessionView, ChatTranscriptView, DetectedAgentInfo, GenerateOptions, LlmAdapterLike, LlmModelInfo, LlmProviderInfo, LlmResolvedModelInfo, ApprovalDeadlineKey, ApprovalDeadlinePatch, PermissionTimeoutMode, PluginUpdateState, PreparedAdapterCall, SessionView, StreamChunk } from './protocol.ts';
+import type { AcpAgentCatalog, AcpAgentDef, AcpApprovalDeadlines, AcpConversationChoice, AcpPresetStatus, AcpReleaseCause, AcpTagHalo, AgentCatalogResult, AgentProbeModelsResult, AgentTestResult, AgentView, ChatSessionView, ChatTranscriptView, DetectedAgentInfo, GenerateOptions, LlmAdapterLike, LlmModelInfo, LlmProviderInfo, LlmResolvedModelInfo, AcpIdleRelease, ApprovalDeadlineKey, ApprovalDeadlinePatch, PermissionTimeoutMode, PluginUpdateState, PreparedAdapterCall, SessionView, StreamChunk } from './protocol.ts';
 import { UpdateService } from './update.ts';
 /**
  * Version of this installed package, read from the shipped `package.json` —
@@ -45,6 +45,15 @@ interface LiveSession {
     closed: boolean;
     /** The agent process died; the session awaits a `session/load` resume. */
     released: boolean;
+    /**
+     * The agent-side session has history while the LOCAL buffer is empty: this
+     * record was restored from disk after a host restart (the replay has not
+     * landed yet), or a resume cleared the buffer ahead of the replay. The ACP
+     * view then says history replays on restore instead of "nothing yet". Set
+     * by `doResumeSession` (captured before the reset) and the restore path; the
+     * serializer ORs it with the live buffer length.
+     */
+    hasHistory?: boolean;
     /**
      * When the agent last showed ANY sign of life on this session: an update, a
      * permission ask (arrival or answer), or a turn start. The stall watchdog
@@ -279,6 +288,20 @@ export declare class AgentBridge {
      * this bridge was built.
      */
     private readonly sessionWorkspace?;
+    /**
+     * Told whenever the SESSION RECORDS change shape (a release parks them, a
+     * resume revives them): the manager persists `chatSessions` through it, so
+     * a parked conversation stays resumable across a host restart (see
+     * `BridgeManager.loadPersistedChatSessions`).
+     */
+    private readonly onSessionsDirty?;
+    /**
+     * Told whenever a fresh `initialize` reports the agent's
+     * `sessionCapabilities.fork` bit — the LAST KNOWN fork capability the
+     * manager persists and serves to the browser (the bridge's own
+     * `initResult` dies with the process; the manager's copy survives it).
+     */
+    private readonly onForkCapability?;
     state: BridgeState;
     initResult?: InitializeResponse;
     lastError?: string;
@@ -309,7 +332,7 @@ export declare class AgentBridge {
     private readonly staleCancelRetryDelayMs;
     private readonly staleCancelMaxRetries;
     private readonly turnSettleMs;
-    private readonly defaultIdleTimeoutMs;
+    private defaultIdleTimeoutMs;
     private readonly probeIdleTimeoutMs;
     /** Armed while READY; fires the idle-release check. */
     private idleTimer?;
@@ -330,6 +353,13 @@ export declare class AgentBridge {
      * that a caller is waiting on the child it is about to kill.
      */
     private pendingCreates;
+    /**
+     * `session/fork` requests in flight (the adopt path of a branched
+     * conversation). Same teardown hazard as {@link pendingCreates}: until the
+     * forked session is registered, nothing else would stop an idle release
+     * from killing the child out from under the caller.
+     */
+    private pendingForks;
     /**
      * Whether a REAL session has ever been registered on this bridge. Probes
      * bypass session bookkeeping, so a bridge that has never hosted anything was
@@ -366,7 +396,21 @@ export declare class AgentBridge {
      * Resolved per turn: the host entry may wire the workspace reader after
      * this bridge was built.
      */
-    sessionWorkspace?: (() => SessionWorkspaceResolver | undefined) | undefined);
+    sessionWorkspace?: (() => SessionWorkspaceResolver | undefined) | undefined, 
+    /**
+     * Told whenever the SESSION RECORDS change shape (a release parks them, a
+     * resume revives them): the manager persists `chatSessions` through it, so
+     * a parked conversation stays resumable across a host restart (see
+     * `BridgeManager.loadPersistedChatSessions`).
+     */
+    onSessionsDirty?: (() => void) | undefined, 
+    /**
+     * Told whenever a fresh `initialize` reports the agent's
+     * `sessionCapabilities.fork` bit — the LAST KNOWN fork capability the
+     * manager persists and serves to the browser (the bridge's own
+     * `initResult` dies with the process; the manager's copy survives it).
+     */
+    onForkCapability?: ((agentId: string, supported: boolean) => void) | undefined);
     /**
      * Adopt a rewritten approval deadline or mode (the settings page's write).
      * Only the window and the mode live here; every other tuning value is
@@ -381,6 +425,18 @@ export declare class AgentBridge {
         permissionTimeoutMs?: number;
         mode?: PermissionTimeoutMode;
     }): void;
+    /**
+     * Adopt a rewritten host-default idle window (the settings page's write).
+     *
+     * Only the DEFAULT moves: an agent that names its own `idleTimeoutMs` keeps
+     * it (that promise is about the agent, not about the deployment), and a
+     * probe-only child keeps the short probe window.
+     *
+     * The timer is re-armed so the new window governs from NOW: an already
+     * armed timer still holds the old window, so a shortened window would not
+     * take effect until the old one elapsed.
+     */
+    applyIdleRelease(defaultIdleTimeoutMs: number): void;
     /**
      * The idle-release window this agent honors for its CHAT process: its own
      * field, else the host default. This is the number the panel prefills and
@@ -559,6 +615,25 @@ export declare class AgentBridge {
      * only shape that keeps every session of that process consistent.
      */
     probeConfigOptions(): Promise<unknown[]>;
+    /**
+     * Fork one live session through the agent's own `session/fork` (the
+     * UNSTABLE fourth session-creation point): the agent copies its internal
+     * state into a NEW ACP session that remembers the parent's context — the
+     * second half of a branched conversation, after the host's `sessions.fork`
+     * has already built the DSH session tree. The child is addressed by the
+     * CHILD DSH conversation id, so its first message reaches an agent that
+     * actually remembers the parent.
+     *
+     * The parent must be live on this connection — a released parent has no
+     * process to fork from (the browser blocks that click; this is the hard
+     * stop behind it). The ACP request carries the SAME `mcpServers` list as
+     * `session/new` / `session/load` (one list per process; an empty list would
+     * evict the live sessions' MCP scope) and is bounded by the startup timeout
+     * like every session-creation step. Counted in {@link pendingForks} while
+     * in flight so an idle release cannot kill the child out from under the
+     * caller.
+     */
+    forkSession(parent: LiveSession, dshSessionId: string): Promise<LiveSession>;
     /**
      * Fire one prompt turn. Returns after the agent settles the turn; the caller
      * (manager) keeps the UI informed through broadcast events, so the RPC that
@@ -617,6 +692,12 @@ export declare class AgentBridge {
     takeReleased(sessionId: string): LiveSession | undefined;
     /** Drop a released session record for good (user closed it or the agent was stopped). */
     dropReleased(sessionId: string): boolean;
+    /**
+     * Register a session record restored from disk as already parked: a host
+     * restart killed every process, so it comes back exactly as `releaseAll`
+     * would have left it — resumable via `session/load`, never live.
+     */
+    parkReleased(session: LiveSession): void;
     get releasedList(): LiveSession[];
     hasReleased(sessionId: string): LiveSession | undefined;
     inflightResume(sessionId: string): Promise<LiveSession> | undefined;
@@ -1131,6 +1212,29 @@ export declare class BridgeManager {
      * write would fight with no way to tell which one is live.
      */
     private deadlineOverride;
+    /**
+     * The idle-release window the settings page picked, in ms, persisted
+     * with the agent registry. `undefined` means the deployment baseline runs.
+     *
+     * Merged OVER {@link baselineIdleTimeoutMs} exactly like
+     * {@link deadlineOverride} over {@link baselineDeadline}: a UI pick is what
+     * runs, and `cordis.patch.yml` becomes the value the reset button returns
+     * to. Without this split the two sources would fight with no way to tell
+     * which one is live.
+     */
+    private idleReleaseOverride?;
+    /**
+     * The window `cordis.patch.yml` names, when it names one. Kept apart
+     * from the override for the same reason the deadline keeps its baseline
+     * apart: the settings card has to be able to say "the file asks for
+     * 10 minutes, the value set here wins".
+     */
+    private configuredIdleTimeoutMs?;
+    /**
+     * The idle-release window before any override — the tuning this manager was
+     * constructed with (the deployment baseline, or the built-in 30 minutes).
+     */
+    private baselineIdleTimeoutMs;
     /**
      * Tuning in force, defaults applied. The approval deadline is rewritten
      * IN PLACE by {@link applyDeadlineTuning}, which is why this is a live object
@@ -1238,6 +1342,29 @@ export declare class BridgeManager {
      * keeps the two controls from reading as duplicates.
      */
     chatSessions(dshSessionId: string): ChatSessionView[];
+    /**
+     * Adopt the ACP side of a branched conversation: the browser has already
+     * asked the HOST to fork the DSH session tree (`sessions.fork`), and this
+     * runs the agent's own `session/fork` of the parent conversation's live ACP
+     * session so the child actually remembers the parent context — then binds
+     * the child to it (the fourth session-creation point, with every discipline
+     * the other three carry).
+     *
+     * Failure is deliberately all-or-nothing: nothing is written for the child
+     * until the agent has answered, so a failed adopt leaves the child an
+     * ordinary copied-history conversation whose first message starts a fresh
+     * `session/new` (today's behavior) — never a half-bound record.
+     *
+     * @param childDshSessionId - the DSH session the host fork created.
+     * @param parentDshSessionId - the conversation being branched; its ACP
+     *   session must be LIVE on this connection (a released parent has no
+     *   process to fork from — the browser blocks the click, this is the hard
+     *   stop behind it).
+     */
+    adoptForkedSession(childDshSessionId: string, parentDshSessionId: string): Promise<{
+        sessionId: string;
+        acpSessionId: string;
+    }>;
     /**
      * Bind one DSH chat session to an ACP agent.
      *
@@ -1391,11 +1518,26 @@ export declare class BridgeManager {
      */
     chatTranscripts(dshSessionId: string, afterSeq?: number): ChatTranscriptView[];
     /**
-     * Switch one chat-bound session's ACP mode. A released session is resumed
-     * first (`session/load`), matching the "send to recover" promise — the mode
-     * switch is itself a reason to bring the agent back.
+     * Switch one chat-bound session's ACP mode.
+     *
+     * A released session is deliberately NOT resumed for it (user decision,
+     * 2026-10-30 — the composer's axes are "what the next turn should use", and
+     * the process comes back only when the user sends a message or hits the
+     * released banner's resume button). The pick is recorded and
+     * `applyChatChoice` applies it on resume, exactly like `setChatSessionModel`
+     * / `setChatSessionEffort` / `setChatSessionConfig`; only a LIVE session is
+     * told immediately (`session/set_mode`).
      */
     setChatSessionMode(dshSessionId: string, modeId: string, agentId?: string): Promise<void>;
+    /**
+     * Bring one chat conversation's released session back on a fresh process on
+     * the USER's explicit gesture (the "恢复进程" banner) — the same work the
+     * next prompt performs lazily (`getOrCreateDshSession`'s released branch),
+     * minus the create path: a banner button must never materialize a session
+     * the conversation has not had yet. A live target passes through untouched,
+     * so a double click (or a click racing the next message) spawns nothing.
+     */
+    resumeChatSession(dshSessionId: string): Promise<void>;
     /**
      * Wire the harness's preset roster (`ctx.agentPresets`) into `presetStatus`.
      *
@@ -1451,7 +1593,30 @@ export declare class BridgeManager {
      */
     private loadPersistedChoices;
     private persistAgents;
+    /**
+     * Restore chat session records from disk as PARKED sessions.
+     *
+     * Every process died with the host, so nothing comes back live — but the
+     * agent-side sessions did not. Restoring each record as `released` is what
+     * makes the released banner, its resume button and the "next message
+     * resumes it" promise survive a restart (the alternative is the next
+     * message quietly starting a NEW, context-less session — constraint 10's
+     * "released ≠ destroyed" lost at the process boundary). Tolerant, one row
+     * at a time: a single corrupt entry must not cost every other conversation
+     * its context. Records whose agent is no longer configured are dropped —
+     * there is nothing to resume ON, and the next write omits them.
+     */
+    private loadPersistedChatSessions;
     private readonly catalogs;
+    /**
+     * Each agent's LAST KNOWN `sessionCapabilities.fork` bit, persisted with the
+     * model catalog. A live `initialize` result outranks it whenever one exists
+     * (see {@link canForkNow}) — this copy answers when the process is gone
+     * (a released session's branch button must not flash into "supported" just
+     * because `initResult` died with it, nor read `view().agentCapabilities`,
+     * which a release clears).
+     */
+    private readonly forkCaps;
     /**
      * The slash commands each agent declared in its most recent session, cached
      * per agent and persisted alongside the model catalog.
@@ -1520,6 +1685,21 @@ export declare class BridgeManager {
      * restatement would make every open composer re-read `agent/catalog`.
      */
     private absorbCommands;
+    /**
+     * Record a fresh `initialize`'s `sessionCapabilities.fork` verdict (the
+     * bridge reports it right after the handshake). Persisted with the model
+     * catalog; no broadcast — the browser learns it through `session/chat-list`
+     * rows, and its branch button deliberately runs on a last-known basis (the
+     * agent's own next `initialize` is the refresh).
+     */
+    private noteForkCapability;
+    /**
+     * Whether an agent's fork can be attempted RIGHT NOW: a live `initialize`
+     * answer wins (the process is up, its handshake is current); only when the
+     * process is gone does the LAST KNOWN persisted bit answer. `false` covers
+     * "never seen" — an unknown agent simply never gets a fork attempt.
+     */
+    private canForkNow;
     /**
      * Append models this observation newly introduced to the agent's selection.
      *
@@ -1736,6 +1916,18 @@ export declare class BridgeManager {
     /** The agent tag's halo preference (composer display, plugin-private). */
     tagHalo(): AcpTagHalo;
     setTagHalo(halo: AcpTagHalo): Promise<void>;
+    /**
+     * Declare the deployment baseline for the idle-release window — the value
+     * `cordis.patch.yml` names, passed RAW (only when it names one).
+     *
+     * Kept separate from the validated tuning for the same reason the
+     * deadline keeps its baseline apart: "the file says 10 minutes" and
+     * "the file says nothing, so 30 minutes applies" are different facts.
+     * The first is the reset target and shows as the fact being overridden;
+     * the second is a built-in default. Called once by the host entry,
+     * before any bridge exists.
+     */
+    setConfiguredIdleRelease(idleTimeoutMs: number | undefined): void;
     /**
      * Declare the deployment baseline for the approval deadline — the values
      * `cordis.patch.yml` names, passed RAW (only the keys it actually contains).
@@ -1758,6 +1950,37 @@ export declare class BridgeManager {
      * stay silent about a plain default.
      */
     approvalDeadlines(): AcpApprovalDeadlines;
+    /**
+     * The idle-release window in force, plus the facts that explain a value the
+     * user did not pick: the deployment baseline an override is outranking.
+     *
+     * `defaultIdleTimeoutMs` is the window a RESET returns to — the deployment
+     * baseline when the config file names one, else the built-in default. It is
+     * NOT a hardcoded constant: a deployment that names 10 minutes must reset
+     * to 10 minutes, not to the built-in 30.
+     *
+     * The config file's own number is reported only when the file names one, so
+     * the settings card can stay silent about a plain default.
+     */
+    idleRelease(): AcpIdleRelease;
+    /**
+     * Write the idle-release window, or drop the persisted override with
+     * `reset` so the deployment baseline applies again.
+     *
+     * HOT: the rewrite reaches every live bridge, so a user changing the window
+     * never has to kill a running session to see it take effect.
+     */
+    setIdleRelease(idleTimeoutMs: number | undefined, reset?: boolean): Promise<void>;
+    /**
+     * Recompute the idle-release window from override → deployment baseline, and
+     * push the result to every live bridge.
+     */
+    private applyIdleReleaseTuning;
+    /**
+     * The idle-release window that runs, in ms: the settings page's pick, else
+     * the deployment baseline.
+     */
+    private idleTimeoutMs;
     /**
      * Write the approval deadline, or the mode (omitted keys keep their value),
      * or drop the persisted override with `reset` so the config-file baseline —

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/branch-action.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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 } from './acp-ui.tsx';
+/**
+ * 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;