dsh-ntr 0.3.1 → 0.3.3

package/src/index.ts

@@ -91,6 +91,7 @@ export function apply(ctx: Context, config?: unknown): void {
       turnStallMs: resolved.turnStallMs,
       turnStallToolMs: resolved.turnStallToolMs,
       turnStallTickMs: resolved.turnStallTickMs,
+      idleTimeoutMs: resolved.idleTimeoutMs,
     },
   )
   const adapter = new AcpLlmAdapter(manager)
@@ -126,6 +127,13 @@ export function apply(ctx: Context, config?: unknown): void {
     ? 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
@@ -269,6 +277,31 @@ export function apply(ctx: Context, config?: unknown): void {
     })
   }
 
+  const wireAttachments = (injectedCtx?: Context): void => {
+    const c = injectedCtx ?? ctx
+    let attachments: unknown
+    try {
+      if (typeof c.get === 'function') {
+        attachments = c.get('attachments') ?? c.get('attachmentService')
+      }
+    } catch {}
+    try {
+      if (attachments === undefined) {
+        attachments = (c as unknown as Record<string, unknown>).attachments ?? (c as unknown as Record<string, unknown>).attachmentService
+      }
+    } catch {}
+    if (attachments !== undefined) {
+      manager.setAttachmentResolver(attachments)
+    } else {
+      manager.setAttachmentResolver(c)
+    }
+  }
+  wireAttachments()
+  if (typeof ctx.inject === 'function') {
+    ctx.inject(['attachments'], injectedCtx => { wireAttachments(injectedCtx) })
+    ctx.inject(['attachmentService'], injectedCtx => { wireAttachments(injectedCtx) })
+  }
+
   /** Registration handle: callable disposer, plus `replace` to re-announce routes. */
   interface LlmAdapterHandle {
     (): void

package/src/protocol.ts

@@ -187,6 +187,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
@@ -446,6 +458,18 @@ export type AcpEvent =
    */
   | { type: 'permission/synced'; requestIds: string[] }
   | { type: 'turn/start'; sessionId: string; turnId: string; text: string }
+  | {
+      type: 'turn/metrics'
+      /** ACP session id (the store keys live burst state by it). */
+      sessionId: string
+      /** DSH chat session id (routing/context only). */
+      dshSessionId: string
+      turnId: string
+      /** Session aggregate INCLUDING the current turn when measurable. */
+      outputTokens: number
+      burstMs: number
+      final: boolean
+    }
   | { type: 'turn/end'; sessionId: string; turnId: string; stopReason?: string; error?: string }
   /**
    * A DSH chat conversation was locked to its agent at the start of its first
@@ -469,6 +493,14 @@ export interface PermissionOptionView {
 
 export type PermissionOutcome = { outcome: 'selected'; optionId: string } | { outcome: 'cancelled' }
 
+/** Plugin-side measurable burst aggregate for one ACP session (not host turn timings). */
+export interface SessionBurst {
+  /** Sum of estimated output tokens over measurable turns. */
+  outputTokens: number
+  /** Sum of within-burst chunk gaps over those turns; tool/approval/long pauses excluded. */
+  burstMs: number
+}
+
 /** Derived session snapshot for replay/reconnect (source of truth stays in the transcript). */
 export interface SessionView {
   sessionId: string
@@ -482,6 +514,8 @@ export interface SessionView {
   availableCommands?: Array<{ name: string; description?: string; [key: string]: unknown }>
   plan?: unknown[]
   usage?: { used: number; size: number; cost?: { amount: number; currency: string } }
+  /** Measurable burst aggregate over this session's turns; absent until measured. */
+  burst?: SessionBurst
   running: boolean
   closed: boolean
   /**
@@ -490,6 +524,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
 }
@@ -543,8 +585,38 @@ 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']
+  /** Measurable burst aggregate over this session's turns; absent until measured. */
+  burst?: SessionView['burst']
   /** 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[] }
 
@@ -668,6 +740,63 @@ export interface TagHaloSetPayload { halo: AcpTagHalo }
 /** 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 const IDLE_RELEASE_MS: readonly number[] = [
+  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
+
+/**
+ * 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.
@@ -752,6 +881,22 @@ export interface ChatEffortSetPayload { dshSessionId: string; effort?: string; a
 /** `session/chat-config-set`: set one of the agent's extra config options. */
 export interface ChatConfigSetPayload { dshSessionId: string; configId: string; 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/src/tps.ts

@@ -0,0 +1,40 @@
+/** ACP `usage_update` is context occupancy, not request tokens; this is the plugin's 4-chars/token OUTPUT estimate (tool args excluded). */
+export const OUTPUT_CHARS_PER_TOKEN = 4
+export const BURST_GAP_MS = 1000
+
+export interface TurnTpsSnapshot {
+  outputTokens: number
+  burstMs: number
+}
+
+export class TurnTpsTracker {
+  private readonly gapMs: number
+  private lastProseAt: number | undefined
+  private outputChars = 0
+  private burstMs = 0
+
+  constructor(gapMs = BURST_GAP_MS) {
+    this.gapMs = gapMs
+  }
+
+  onProse(text: string, at: number): void {
+    if (text === '') return
+    if (this.lastProseAt !== undefined) {
+      const gap = at - this.lastProseAt
+      if (gap <= this.gapMs) this.burstMs += gap
+    }
+    this.lastProseAt = at
+    this.outputChars += text.length
+  }
+
+  onBreak(): void {
+    this.lastProseAt = undefined
+  }
+
+  snapshot(): TurnTpsSnapshot {
+    return {
+      outputTokens: Math.round(this.outputChars / OUTPUT_CHARS_PER_TOKEN),
+      burstMs: this.burstMs,
+    }
+  }
+}