dsh-ntr 0.3.0 → 0.3.2

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/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
@@ -141,6 +168,20 @@ export interface ChatTranscript {
     /** Highest folded transcript seq (gap detection for the live stream). */
     seq: number;
 }
+/**
+ * One line of the settings page's ACP runtime log. Agent-side notices and
+ * session-release reasons land here (bounded, append order oldest→newest);
+ * failures of the settings page's OWN actions stay in {@link UiState.notice}.
+ */
+export interface AcpLogEntry {
+    id: number;
+    at: number;
+    level: 'info' | 'error';
+    text: string;
+    agentId?: string;
+}
+/** Cap on retained runtime-log lines; older entries fall off the front. */
+export declare const LOG_MAX_ENTRIES = 200;
 export interface UiState {
     open: boolean;
     /**
@@ -162,7 +203,15 @@ export interface UiState {
     blocks: Block[];
     permissions: PendingPermission[];
     busy: boolean;
+    /**
+     * The settings page's one-line banner for its OWN action failures. Agent-side
+     * runtime messages do not land here; they append to {@link logs} instead.
+     */
     notice?: string;
+    /** Agent-side runtime log, append order oldest→newest, capped at {@link LOG_MAX_ENTRIES}. */
+    logs: AcpLogEntry[];
+    /** Lines appended since the user last opened the log; reset by {@link AcpStore.markLogsRead}. */
+    logUnread: number;
     /**
      * The plugin's OWN default ACP agent (the panel's ★ gesture) — which agent a
      * new ACP-mode conversation starts on. NOT the deployment default model: that
@@ -218,6 +267,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
@@ -339,11 +394,20 @@ export declare class AcpStore {
     private state;
     private readonly listeners;
     private source?;
+    /** Monotonic id source for {@link AcpLogEntry}s (never reset by `clearLogs`). */
+    private logSeq;
     private readonly lastSeq;
     /** Sessions with a finalized turn (dedups the cancel-fallback + late real turn/end pair). */
     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
@@ -407,6 +471,11 @@ export declare class AcpStore {
     subscribe(listener: Listener): () => void;
     getSnapshot(): UiState;
     private mutate;
+    /**
+     * Build the log patch for one line. Does NOT mutate: the caller merges it
+     * into the single `mutate` call it was already making for the same event.
+     */
+    private logPatch;
     /**
      * Live `session/update` frames waiting to be folded. Agents stream at token
      * granularity — hundreds of frames a second with usage ticks interleaved —
@@ -572,6 +641,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;
     /**
@@ -614,6 +690,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,
@@ -673,6 +779,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
@@ -713,6 +833,10 @@ export declare class AcpStore {
      */
     refreshLocale(): void;
     clearNotice(): void;
+    /** Drop every retained runtime-log line (the unread counter restarts too). */
+    clearLogs(): void;
+    /** The user looked at the log: clear the unread badge. */
+    markLogsRead(): void;
     private flashError;
     private applyEvent;
 }
@@ -732,4 +856,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 {};

package/lib/types/impl.d.ts

@@ -5,7 +5,7 @@
  * fakes.
  */
 import { randomUUID } from './ids.ts';
-import type { AcpAgentCatalog, AcpAgentDef, AcpApprovalDeadlines, AcpConversationChoice, AcpEvent, AcpMcpServerDef, AcpPluginConfig, AcpPresetStatus, AcpTagHalo, AgentCatalogResult, AgentProbeModelsResult, AgentTestResult, AgentView, ApprovalDeadlineKey, ApprovalDeadlinePatch, ChatSessionView, ChatTranscriptView, DetectedAgentInfo, PermissionOptionView, PermissionOutcome, PermissionTimeoutMode, PluginUpdateState, RpcResult } from './protocol.ts';
+import type { AcpAgentCatalog, AcpAgentDef, AcpApprovalDeadlines, AcpConversationChoice, AcpEvent, AcpIdleRelease, AcpMcpServerDef, AcpPluginConfig, AcpPresetStatus, AcpTagHalo, AgentCatalogResult, AgentProbeModelsResult, AgentTestResult, AgentView, ApprovalDeadlineKey, ApprovalDeadlinePatch, ChatSessionView, ChatTranscriptView, DetectedAgentInfo, PermissionOptionView, PermissionOutcome, PermissionTimeoutMode, PluginUpdateState, RpcResult } from './protocol.ts';
 export { randomUUID };
 /** Structured failure the RPC layer converts to `{ok:false, error}` and `apply()` surfaces at boot. */
 export declare class AcpError extends Error {
@@ -82,6 +82,15 @@ export declare function validateApprovalDeadlineMs(raw: unknown, label: string,
  * reset the number. `reset` is not a deadline and is dropped here.
  */
 export declare function validateApprovalDeadlines(value: unknown): Partial<Record<ApprovalDeadlineKey, number>>;
+/**
+ * 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 declare function validateIdleReleaseMs(raw: unknown, code: 'bad_config' | 'bad_payload'): number;
 /**
  * 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
@@ -698,6 +707,19 @@ export interface AcpManager {
      * applies again. Applies to the running bridges without a restart.
      */
     setApprovalDeadlines?(patch: ApprovalDeadlinePatch, reset?: boolean): Promise<void>;
+    /**
+     * The idle-release window in force for chat processes, plus the built-in
+     * default a reset returns to. `undefined` on a host half from before the
+     * card existed, which hides the settings tab instead of showing a number
+     * this browser invented.
+     */
+    idleRelease?(): AcpIdleRelease | undefined;
+    /**
+     * Write the idle-release window (in ms), or drop the persisted
+     * override with `reset` so the built-in default applies again. Applies to
+     * the running bridges without a restart.
+     */
+    setIdleRelease?(idleTimeoutMs: number | undefined, reset?: boolean): Promise<void>;
     detectAgents?(): Promise<DetectedAgentInfo[]>;
     saveAgent?(def: AcpAgentDef): Promise<void>;
     deleteAgent?(agentId: string): Promise<void>;
@@ -770,6 +792,24 @@ export interface AcpManager {
      * without it the live (non-released) session is picked.
      */
     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 (`session/chat-resume`, the released-session
+     * banner's button). Same recovery the next prompt performs lazily, minus
+     * the create path; no-op when the session is already live.
+     */
+    resumeChatSession?(dshSessionId: string): Promise<void>;
+    /**
+     * Adopt the ACP side of a branched conversation (`session/chat-fork-adopt`):
+     * the browser has already asked the HOST to fork the DSH session tree, and
+     * this runs the agent's own `session/fork` of the parent's live ACP session,
+     * then binds the child to it. All-or-nothing — nothing is bound on failure,
+     * so the child stays an ordinary copied-history conversation.
+     */
+    adoptForkedSession?(childDshSessionId: string, parentDshSessionId: string): Promise<{
+        sessionId: string;
+        acpSessionId: string;
+    }>;
     /**
      * Point one DSH chat conversation at an ACP agent — the plugin's own
      * conversation↔agent mapping, never a DSH model route (see

package/lib/types/protocol.d.ts

@@ -178,6 +178,18 @@ export interface AcpPluginConfig {
      * deployment baseline that override falls back to. See {@link AcpApprovalDeadlines}.
      */
     permissionTimeoutMs?: number;
+    /**
+     * How long a chat process may sit idle before it is released (parked, then
+     * resumed by the next message). In MILLISECONDS; default 1800000 (30 min).
+     *
+     * This is the HOST DEFAULT: an agent that names its own
+     * {@link AcpAgentDef.idleTimeoutMs} keeps its own. Editable from the
+     * settings page (「进程管理」 → `ui/idle-release-set`), which persists an
+     * override in the plugin's own state file and applies it to the running
+     * bridges without restarting anything; the value here is the deployment
+     * baseline that override falls back to. See {@link AcpIdleRelease}.
+     */
+    idleTimeoutMs?: number;
     /**
      * LEGACY: the old conversation-route window, kept so an existing
      * `cordis.patch.yml` still says what it meant. Folded into
@@ -321,6 +333,11 @@ export interface AgentView {
      */
     idleTimeoutMs?: number;
 }
+/**
+ * Why the host released a session's agent process. The browser turns this into
+ * one runtime-log line per cause; `idle` stays silent (expected lifecycle).
+ */
+export type AcpReleaseCause = 'idle' | 'workspace' | 'resume-failed' | 'stalled' | 'died';
 export type AcpEvent = {
     type: 'agent/status';
     agentId: string;
@@ -350,6 +367,8 @@ export type AcpEvent = {
     sessionId: string;
     session: SessionView;
     reason: string;
+    /** Host's release-cause classification; absent on an older host half. */
+    cause?: AcpReleaseCause;
 } | {
     /**
      * The session was resumed through `session/load` on a fresh agent
@@ -543,6 +562,14 @@ export interface SessionView {
      * recover") when the agent declares the `loadSession` capability.
      */
     released?: boolean;
+    /**
+     * The agent-side session has history while the local buffer is empty: the
+     * record was restored from disk after a host restart (the `session/load`
+     * replay has not landed), or a resume cleared the buffer ahead of the
+     * replay. The ACP view then says history replays on restore instead of
+     * claiming "nothing yet".
+     */
+    hasHistory?: boolean;
     /** Highest transcript seq included in this snapshot (for gap detection). */
     seq: number;
 }
@@ -606,8 +633,36 @@ export interface ChatSessionView {
      * agent can never see.
      */
     availableCommands?: SessionView['availableCommands'];
+    /**
+     * Context occupancy the agent last reported (`usage_update`): prompt-side
+     * used/size, not request tokens. Absent until the agent reports one; the
+     * browser live-patches this row from the update frames (see AGENTS/ui.md).
+     */
+    usage?: SessionView['usage'];
     /** The agent process died; the session awaits a `session/load` resume. */
     released?: boolean;
+    /** The agent is running a turn on this session right now. */
+    running?: boolean;
+    /**
+     * Whether this session's ACP agent can be forked (`session/fork`) into a
+     * child conversation, as the host computed it. The browser does not derive
+     * this itself — the capability is host knowledge (the agent's
+     * `initialize`), and the row is the one place it is delivered.
+     * `supported: false` carries the reason; no reason on `false` means the
+     * host half predates the field (treat as unsupported).
+     */
+    fork?: ChatSessionForkInfo;
+}
+/**
+ * The host's per-row verdict on forking one chat session's ACP session
+ * (`ChatSessionView.fork`). Computed from the agent's LAST KNOWN
+ * `sessionCapabilities.fork` (persisted with the model catalog) plus the
+ * session's own state — the browser never reads capability bits itself.
+ */
+export interface ChatSessionForkInfo {
+    supported: boolean;
+    /** Why {@link supported} is false: the agent cannot fork, or the session cannot be forked right now. */
+    reason?: 'unsupported' | 'released' | 'busy';
 }
 export type ChatSessionsListResult = {
     sessions: ChatSessionView[];
@@ -763,6 +818,60 @@ export interface TagHaloSetPayload {
 }
 /** The approval deadline the settings page can edit, by field name. ONE window. */
 export type ApprovalDeadlineKey = 'permissionTimeoutMs';
+/**
+ * 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 declare const IDLE_RELEASE_MS: readonly number[];
+/**
+ * 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 declare const DEFAULT_IDLE_TIMEOUT_MS = 1800000;
+/**
+ * The idle-release window for chat processes, as the settings page edits it.
+ *
+ * The window is the HOST default: an agent that names its own
+ * {@link AcpAgentDef.idleTimeoutMs} keeps it, and a probe-only process (one
+ * that never hosted a session) still honors the short probe window — see
+ * `AGENTS/protocol.md` §5.
+ */
+export interface AcpIdleRelease {
+    /** The window in force, in ms. */
+    idleTimeoutMs: number;
+    /**
+     * The window a RESET returns to: the deployment baseline when the config
+     * file names one, else the built-in default (30 minutes).
+     */
+    defaultIdleTimeoutMs: number;
+    /**
+     * The window `cordis.patch.yml` names, when it names one. Reported only
+     * when the file actually names one: the settings card must not say "the
+     * file asks for 30 minutes" about a file that says nothing.
+     */
+    configuredIdleTimeoutMs?: number;
+}
+/** `ui/idle-release`: read the idle-release window in force. */
+export type IdleReleaseResult = {
+    idleRelease?: AcpIdleRelease;
+};
+/**
+ * `ui/idle-release-set`: write the idle-release window, or drop the persisted
+ * override with `reset` so the built-in default applies again.
+ */
+export interface IdleReleaseSetPayload {
+    /** The window to run, in ms; omitted when `reset` is true. */
+    idleTimeoutMs?: number;
+    /** Drop the persisted override so the built-in default applies again. */
+    reset?: boolean;
+}
 /**
  * What an EXPIRED approval deadline does. Three modes, and only three — an
  * unanswered ask either gets answered for you, keeps waiting, or is refused.
@@ -861,6 +970,27 @@ export interface ChatConfigSetPayload {
     value: string | boolean;
     agentId?: string;
 }
+/**
+ * `session/chat-fork-adopt`: bind the DSH chat session a host `sessions.fork`
+ * just created to the SAME agent process, through the agent's own
+ * `session/fork` of the parent conversation's ACP session — the second half of
+ * the two-stage branch (host builds the DSH tree first, the plugin then adopts
+ * the ACP side; see the NTR message-actions plan, §D5/D7).
+ *
+ * On success the child conversation's next message reaches an agent that
+ * actually remembers the parent context. On failure NOTHING is bound: the
+ * child stays an ordinary copied-history conversation and its first message
+ * starts a fresh `session/new` (today's behavior).
+ */
+export interface ChatForkAdoptPayload {
+    dshSessionId: string;
+    parentDshSessionId: string;
+}
+/** `session/chat-fork-adopt` success: the adopted ACP session's ids. */
+export type ChatForkAdoptResult = {
+    sessionId: string;
+    acpSessionId: string;
+};
 /** Host-detected agent presence and tested defaults. */
 export interface DetectedAgentInfo {
     id: string;

package/lib/types/update.d.ts

@@ -77,10 +77,13 @@ export type BundleEligibility = {
 };
 /**
  * Whether a `listBundles().source` value names a registry-resolvable version
- * spec — the only install shape this updater may replace. The test is positive
- * on purpose: link/file/git/workspace/URL/tarball/relative forms all carry a
- * `:` / `/` / `\` or start with `.`, so they fall out without an ever-growing
- * blacklist (a new source scheme must not become silently updatable).
+ * spec — the only install shape this updater may replace. The harness records
+ * a registry dependency as `<package>@<spec>` (`dependencySpec` in the plugin
+ * manager), so the spec half after the last `@` is what gets judged. The test
+ * is positive on purpose: link/file/git/workspace/URL/tarball/relative forms
+ * all carry a `:` / `/` / `\` or start with `.`, so they fall out without an
+ * ever-growing blacklist (a new source scheme must not become silently
+ * updatable).
  */
 export declare function isRegistrySpec(source: string): boolean;
 /**

package/lib/update.js

@@ -46,12 +46,26 @@ function describeFieldError(error) {
         .filter((part) => typeof part === 'string' && part !== '');
     return parts.length > 0 ? parts.join(': ') : 'the host reported a bundle error';
 }
+/** The version-spec half of a registry source: a range, wildcard, or dist-tag. */
+function isRegistryRange(value) {
+    if (value === '')
+        return false;
+    const lowered = value.toLowerCase();
+    if (lowered === '*' || lowered === 'x')
+        return true;
+    if (REGISTRY_TAGS.has(lowered))
+        return true;
+    return REGISTRY_VERSION_SPEC.test(value);
+}
 /**
  * Whether a `listBundles().source` value names a registry-resolvable version
- * spec — the only install shape this updater may replace. The test is positive
- * on purpose: link/file/git/workspace/URL/tarball/relative forms all carry a
- * `:` / `/` / `\` or start with `.`, so they fall out without an ever-growing
- * blacklist (a new source scheme must not become silently updatable).
+ * spec — the only install shape this updater may replace. The harness records
+ * a registry dependency as `<package>@<spec>` (`dependencySpec` in the plugin
+ * manager), so the spec half after the last `@` is what gets judged. The test
+ * is positive on purpose: link/file/git/workspace/URL/tarball/relative forms
+ * all carry a `:` / `/` / `\` or start with `.`, so they fall out without an
+ * ever-growing blacklist (a new source scheme must not become silently
+ * updatable).
  */
 export function isRegistrySpec(source) {
     const value = typeof source === 'string' ? source.trim() : '';
@@ -61,12 +75,13 @@ export function isRegistrySpec(source) {
         return false;
     if (value.includes(':') || value.includes('/') || value.includes('\\'))
         return false;
-    const lowered = value.toLowerCase();
-    if (lowered === '*' || lowered === 'x')
-        return true;
-    if (REGISTRY_TAGS.has(lowered))
-        return true;
-    return REGISTRY_VERSION_SPEC.test(value);
+    const at = value.lastIndexOf('@');
+    if (at === -1)
+        return isRegistryRange(value);
+    const name = value.slice(0, at);
+    if (!/^[a-z0-9][a-z0-9._-]*$/i.test(name))
+        return false;
+    return isRegistryRange(value.slice(at + 1));
 }
 /**
  * Compare two semver strings (build metadata ignored, prerelease precedence per

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-ntr",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Interactive Agent Client Protocol (ACP) client for the DSH web UI: attach any ACP-capable agent and stream its session.",
   "repository": "https://github.com/GDWhisper/dsh-ntr.git",
   "type": "module",
@@ -72,6 +72,7 @@
         "@deepseek-ai/dsh-client-connection",
         "@deepseek-ai/dsh-client-ui-conversation",
         "@deepseek-ai/dsh-client-ui-layout",
+        "@deepseek-ai/dsh-client-ui-primitives",
         "@deepseek-ai/dsh-client-ui-settings",
         "@deepseek-ai/dsh-client-ui-sidebar",
         "@deepseek-ai/dsh-client-ui-slots"