@agentproto/runtime 5.8.0 → 5.10.0

package/dist/session-story.d.ts

@@ -43,6 +43,11 @@ interface ExportedMessage {
         args: string;
     }[];
     ts?: number;
+    /** Daemon plumbing rather than the work itself: `handoff` marks the handoff
+     *  question and the source session's reply to it; `preamble` marks the
+     *  daemon-composed system slice (role, AGENTS.md contract, lineage) of a
+     *  spawned session's initial prompt. Checkpoints leave these out. */
+    internal?: "handoff" | "preamble";
 }
 interface ExportedSessionMeta {
     title?: string;

package/dist/{sessions-SrISpFsH.d.ts → sessions-BdgU9X6P.d.ts}

@@ -1,11 +1,11 @@
 import { z } from 'zod';
-import { R as RouteSpec, S as SessionConfig, P as Posture, E as EffortLevel, C as ContextProfile, A as AuthMethod } from './session-config-DxIIuJFY.js';
-import { a as SpawnBrowserMode, R as ResolvedContextContinuityPolicy } from './spawn-defaults-Cp9SGZex.js';
+import { R as RouteSpec, S as SessionConfig, P as Posture, E as EffortLevel, C as ContextProfile, A as AuthMethod } from './session-config-BUDM7T1B.js';
+import { a as SpawnBrowserMode, R as ResolvedContextContinuityPolicy } from './spawn-defaults-Dm7nbxcP.js';
 import { AcpPermissionResolution, AcpMcpServer } from '@agentproto/acp';
 import { SessionMode } from '@agentproto/acp/client';
 import { ChildProcess } from 'node:child_process';
 import { CostBudget } from '@agentproto/auth';
-import { h as WorktreeIsolationMode } from './config-Gz7q9yfJ.js';
+import { h as WorktreeIsolationMode } from './config-Dsmv-jri.js';
 
 /**
  * Typed, best-effort persistence for the last-seen provider "remaining quota"
@@ -1534,6 +1534,8 @@ interface PolicyRunState {
         exitCode: number;
         at: string;
         kind?: "shell" | "judge" | "cost";
+        /** Shell gates only: the command line that ran (command + args). */
+        command?: string;
         stdout?: string;
         stderr?: string;
     };
@@ -2011,7 +2013,7 @@ declare function createTaskLedger(opts: {
  * list — {@link isKnownSessionEndReason} says so, and callers should fall
  * back to a generic label rather than throw.
  */
-declare const SESSION_END_REASONS: readonly ["daemon-restart", "idle-reaped", "crashed", "operator-completed", "operator-stopped", "cost-cap-exceeded", "policy-cleanup", "parent-exited", "provider-limit", "forgotten", "steward-completed", "steward-abandoned"];
+declare const SESSION_END_REASONS: readonly ["daemon-restart", "idle-reaped", "crashed", "operator-completed", "operator-stopped", "cost-cap-exceeded", "context-hard-stop", "policy-cleanup", "parent-exited", "provider-limit", "forgotten", "steward-completed", "steward-abandoned"];
 type SessionEndReason = (typeof SESSION_END_REASONS)[number];
 /** True when `reason` is one of {@link SESSION_END_REASONS}. A label
  *  lookup, not a wire-format gate — an unrecognized string is still a
@@ -2038,7 +2040,7 @@ declare function isProviderLimitError(message: string | undefined): boolean;
  * and session_monitor MCP tool (long-poll multiplexed).
  */
 
-type SessionEventType = "session:turn-end" | "session:awaiting-input" | "session:awaiting-input-flagged" | "session:awaiting-question-answered" | "session:permission-request" | "session:permission-resolved" | "session:exited" | "session:reaped" | "session:stalled" | "session:stall-cleared" | "session:watcher-attached" | "session:watcher-detached" | "session:bg-tasks-parked" | "session:bg-tasks-cleared" | "session:bg-task" | "session:resumed" | "session:spawned" | "session:provisioning" | "session:command-done" | "session:model-changed" | "session:config-changed" | "session:renamed" | "session:pinned-changed" | "session:artifact-added" | "session:artifact-pinned-changed" | "session:message" | "policy:passed" | "policy:failed" | "policy:commit-ready" | "policy:committed" | "cron:fired" | "cron:succeeded" | "cron:failed" | "activity:changed" | "task:changed" | "workflow:gate-report" | "workflow:suspended" | "workflow:suspend-resumed" | "session:harness-warning" | "approval:requested" | "approval:decided" | "approval:consumed" | "approval:expired";
+type SessionEventType = "session:turn-end" | "session:awaiting-input" | "session:awaiting-input-flagged" | "session:awaiting-question-answered" | "session:permission-request" | "session:permission-resolved" | "session:exited" | "session:reaped" | "session:stalled" | "session:stall-cleared" | "session:watcher-attached" | "session:watcher-detached" | "session:bg-tasks-parked" | "session:bg-tasks-cleared" | "session:bg-task" | "session:resumed" | "session:spawned" | "session:provisioning" | "session:command-done" | "session:model-changed" | "session:config-changed" | "session:renamed" | "session:pinned-changed" | "session:pinned-reordered" | "session:artifact-added" | "session:artifact-pinned-changed" | "session:message" | "policy:passed" | "policy:failed" | "policy:commit-ready" | "policy:committed" | "cron:fired" | "cron:succeeded" | "cron:failed" | "cron:unhealthy" | "activity:changed" | "task:changed" | "workflow:gate-report" | "workflow:suspended" | "workflow:suspend-resumed" | "session:harness-warning" | "session:handoff-suggested" | "approval:requested" | "approval:decided" | "approval:consumed" | "approval:expired";
 /**
  * Fixed severity vocabulary for a judge-gate finding (WP-D). Deliberately
  * small and fixed so `policy_status` output is comparable across different
@@ -2586,6 +2588,18 @@ interface SessionPinnedEvent {
     pinned: boolean;
     ts: string;
 }
+/** Emitted when the pinned group is manually reordered
+ *  (`session_reorder_pinned`, `POST /sessions/pinned/order` →
+ *  `registry.reorderPinned`). `ids` is the requested new order — the full
+ *  pinned order is a `session_list` / `GET /sessions` call away. Rides the
+ *  same bus distribution as every other lifecycle event, which is how a
+ *  live UI learns to resort its pinned group without waiting for its next
+ *  snapshot poll. */
+interface SessionPinnedReorderedEvent {
+    type: "session:pinned-reordered";
+    ids: string[];
+    ts: string;
+}
 /**
  * Emitted when a new artifact (or a new version of an existing one) is
  * materialized into the session's artifact store (`session_artifact_add`,
@@ -2720,6 +2734,28 @@ interface CronFailedEvent {
     error: string;
     ts: string;
 }
+/**
+ * Emitted by CronScheduler when a job trips its health threshold: `N`
+ * consecutive non-productive runs (default 2, per-job
+ * `maxConsecutiveFailures`) pause the job (`active:false` + `pausedReason`)
+ * instead of letting it keep firing into a wall. `lastOutcome` is the run
+ * that tripped it; `consecutiveFailures` is the count at trip time (mirrors
+ * the job's own counter and `cron_list`'s `health`). Rides the same bus
+ * fan-out as every other cron event (`session_events_poll`, the webhook
+ * notifier), so an existing global notify URL relays it with no new channel.
+ */
+interface CronUnhealthyEvent {
+    type: "cron:unhealthy";
+    jobId: string;
+    label?: string;
+    /** Consecutive non-productive runs at the moment the job was paused. */
+    consecutiveFailures: number;
+    /** The real outcome of the run that tripped the threshold. */
+    lastOutcome: "produced" | "empty" | "errored" | "timeout";
+    /** Human-readable pause reason now stored on the job. */
+    reason: string;
+    ts: string;
+}
 /**
  * Emitted by the activity projector (`activities.ts`) whenever an
  * {@link ActivityRecord}'s state or waitingOn actually changed — the ONE
@@ -2849,6 +2885,31 @@ interface SessionHarnessWarningEvent {
     label?: string;
     ts: string;
 }
+/** Why a handoff is being suggested. */
+type HandoffSuggestionReason = "provider-limit" | "quota-threshold";
+/**
+ * Emitted when agentproto SUGGESTS moving a session to another harness:
+ * the provider reported a usage cap (`provider-limit`) or the remaining
+ * quota fell under `contextContinuity.handoffAtQuotaRemaining`
+ * (`quota-threshold`). A suggestion only — nothing is spawned, the user
+ * runs the `command` (`agentproto sessions handoff <id> --to <harness>`)
+ * to switch. `suggestions` lists installed harnesses with usable
+ * credentials (never the source harness); the event is not emitted when
+ * there are none. Same bus distribution as every other lifecycle event
+ * (`session_events_poll`, SSE, webhooks).
+ */
+interface SessionHandoffSuggestedEvent {
+    type: "session:handoff-suggested";
+    sessionId: string;
+    fromHarness: string;
+    reason: HandoffSuggestionReason;
+    suggestions: Array<{
+        harness: string;
+        command: string;
+    }>;
+    label?: string;
+    ts: string;
+}
 /**
  * Emitted by the approvals engine (`approvals/engine.ts`) when an
  * `approval_request` (MCP or `POST /approvals`) raises a new pending
@@ -2897,7 +2958,7 @@ interface ApprovalExpiredEvent {
     taskId?: string;
     ts: string;
 }
-type SessionEvent = SessionTurnEndEvent | SessionAwaitingInputEvent | SessionAwaitingInputFlaggedEvent | SessionAwaitingQuestionAnsweredEvent | SessionPermissionRequestEvent | SessionPermissionResolvedEvent | SessionExitedEvent | SessionReapedEvent | SessionStalledEvent | SessionStallClearedEvent | SessionWatcherAttachedEvent | SessionWatcherDetachedEvent | SessionBgTasksParkedEvent | SessionBgTasksClearedEvent | SessionBgTaskEvent | SessionResumedEvent | SessionSpawnedEvent | SessionProvisioningEvent | SessionCommandDoneEvent | SessionModelChangedEvent | SessionConfigChangedEvent | SessionRenamedEvent | SessionPinnedEvent | SessionArtifactAddedEvent | SessionArtifactPinnedEvent | SessionMessageEvent | PolicyPassedEvent | PolicyFailedEvent | PolicyCommitReadyEvent | PolicyCommittedEvent | CronFiredEvent | CronSucceededEvent | CronFailedEvent | ActivityChangedEvent | TaskChangedEvent | WorkflowGateReportEvent | WorkflowApprovalRequestedEvent | WorkflowApprovalResolvedEvent | WorkflowSuspendedEvent | WorkflowSuspendResumedEvent | SessionHarnessWarningEvent | ApprovalRequestedEvent | ApprovalDecidedEvent | ApprovalConsumedEvent | ApprovalExpiredEvent;
+type SessionEvent = SessionTurnEndEvent | SessionAwaitingInputEvent | SessionAwaitingInputFlaggedEvent | SessionAwaitingQuestionAnsweredEvent | SessionPermissionRequestEvent | SessionPermissionResolvedEvent | SessionExitedEvent | SessionReapedEvent | SessionStalledEvent | SessionStallClearedEvent | SessionHandoffSuggestedEvent | SessionWatcherAttachedEvent | SessionWatcherDetachedEvent | SessionBgTasksParkedEvent | SessionBgTasksClearedEvent | SessionBgTaskEvent | SessionResumedEvent | SessionSpawnedEvent | SessionProvisioningEvent | SessionCommandDoneEvent | SessionModelChangedEvent | SessionConfigChangedEvent | SessionRenamedEvent | SessionPinnedEvent | SessionPinnedReorderedEvent | SessionArtifactAddedEvent | SessionArtifactPinnedEvent | SessionMessageEvent | PolicyPassedEvent | PolicyFailedEvent | PolicyCommitReadyEvent | PolicyCommittedEvent | CronFiredEvent | CronSucceededEvent | CronFailedEvent | CronUnhealthyEvent | ActivityChangedEvent | TaskChangedEvent | WorkflowGateReportEvent | WorkflowApprovalRequestedEvent | WorkflowApprovalResolvedEvent | WorkflowSuspendedEvent | WorkflowSuspendResumedEvent | SessionHarnessWarningEvent | ApprovalRequestedEvent | ApprovalDecidedEvent | ApprovalConsumedEvent | ApprovalExpiredEvent;
 interface SessionEventBus {
     emit(ev: SessionEvent): void;
     /** Subscribe to a specific event type. Returns an unsubscribe fn. */
@@ -3685,8 +3746,11 @@ interface SessionOutcome {
      *  `empty` — no assistant text and no artifacts. */
     status: "produced" | "empty";
     /** Level 2 only: what a judge/declaration decided the session's work
-     *  amounted to. Absent on a plain Level 1 `"derived"` outcome. */
-    verdict?: "done" | "abandoned" | "blocked" | "needs-input";
+     *  amounted to. `blocked`/`needs-input` never close (flagged instead);
+     *  `abandoned`/`partial`/`failed` all close as not-completed
+     *  (`endedReason:"steward-abandoned"`), the verdict nuance kept here.
+     *  Absent on a plain Level 1 `"derived"` outcome. */
+    verdict?: "done" | "abandoned" | "partial" | "failed" | "blocked" | "needs-input";
     /** Level 2 only: who reached `verdict` — a session id (a judge agent) or
      *  the literal `"steward-rules"` for a deterministic close with no judge
      *  in the loop. Absent on a plain Level 1 `"derived"` outcome. */
@@ -3771,6 +3835,36 @@ interface AgentSessionLike {
      *  adapter-specific forensics. Undefined for drivers that don't
      *  expose a process (e.g. a future non-subprocess transport). */
     pid?: number;
+    /** Whether the driver's transport to the adapter is still usable, read
+     *  fresh at call time — mirrors `@agentproto/driver-agent-cli`'s
+     *  `AgentCliRuntimeSession.isConnected` without importing it (same
+     *  driver-decoupled structural-mirror reasoning as `setModel` below).
+     *
+     *  The liveness axis `pid` can't cover: an ACP wrapper process commonly
+     *  survives its own JSON-RPC stream, so `processAlive` says "alive" while
+     *  every RPC rejects with "ACP connection closed". Projected onto
+     *  `SessionDescriptor.adapterConnected` at read time and read by the
+     *  crash-detect sweep.
+     *
+     *  Optional, and `true`-by-absence on purpose: a sandbox proxy or a
+     *  print-arm session has no long-lived connection to lose, so only an
+     *  explicit `false` is evidence of death. */
+    isConnected?(): boolean;
+    /** Subscribe to transport death — the push half of the axis `isConnected`
+     *  polls. Fires at most once, and SYNCHRONOUSLY if the transport is
+     *  already gone when the listener is attached, which is what lets the
+     *  registry wire this up at bind time without racing a connection that
+     *  died during spawn.
+     *
+     *  It fires on an ORDERLY teardown too (the host's own `close()` aborts
+     *  the same signal). The registry's listener is safe against that by
+     *  construction: it routes into `markCrashed`, which refuses any row that
+     *  isn't still `running` — and `kill()`/`reapIdle` both flip `status`
+     *  before they close the connection.
+     *
+     *  Absent for session shapes with no long-lived connection (sandbox
+     *  proxy, print arm, future transports). */
+    onDisconnect?(listener: (err: Error) => void): void;
     send(message: unknown): AsyncIterable<AgentStreamEvent>;
     cancel(): Promise<void>;
     /** Resolve a permission request the driver parked in permission-hold mode
@@ -4052,6 +4146,14 @@ interface AgentStreamEvent {
      *  autonomous wake) — see @agentproto/acp's `StreamEvent`. */
     origin?: string;
 }
+/**
+ * Turn error attached when a turn has produced NO output and NO usage since
+ * its prompt and then goes silent past the stall threshold — the provider is
+ * almost certainly retrying internally (opencode's silent 429 loop) and the
+ * daemon would otherwise only report `stalledSinceMs` with no reason. Set by
+ * `markStalled`; cleared at the next turn-end like every other turn error.
+ */
+declare const NO_OUTPUT_STALL_TURN_ERROR = "no output since prompt \u2014 provider retrying?";
 /**
  * Env vars the registry injects into every process it spawns on a session's
  * behalf (agent-cli adapters, PTY/terminal, and generic `spawn()` — see
@@ -4178,6 +4280,20 @@ interface QueuedPrompt {
      *  as a `session-message` transcript record, and coalesced with any
      *  envelope items queued right behind it (never with a plain prompt). */
     envelope?: SessionMessage;
+    /** Opt-in (`enqueuePrompt` `opts.steer`): this item may be injected into
+     *  the target's RUNNING turn at the next safe point instead of waiting for
+     *  the turn to end — only when the agent advertises steering. Plain
+     *  (non-envelope), non-child prompts only. */
+    steer?: boolean;
+    /** ISO 8601 deadline (`deliverWithin`): past it, the pending-prompt sweep
+     *  force-delivers this item per {@link deliverVia}. */
+    deliverBy?: string;
+    /** How the sweep forces delivery at {@link deliverBy}: `steer` (inject,
+     *  else stay queued), `interrupt` (cancel the turn and run it now), or
+     *  `auto` (steer when the agent can, else interrupt). Default `auto`. */
+    deliverVia?: "auto" | "steer" | "interrupt";
+    /** ISO 8601 — when the staleness notice for this item was sent (once). */
+    staleNotifiedAt?: string;
 }
 /** What `enqueuePrompt` resolved to — lets a caller (e.g. MCP `agent_prompt`)
  *  tell the user whether the prompt was delivered/started now or PARKED behind
@@ -4187,8 +4303,23 @@ interface QueuedPrompt {
  *  idle dispatch, an interrupt that redirected the live turn, a structured-
  *  question answer — resolves `queued: false`. */
 interface EnqueuePromptResult {
+    /** Legacy: true ONLY when the prompt is parked in `promptQueue` (not yet
+     *  delivered). Prefer `delivery` / `pending`. */
     queued: boolean;
-}
+    /** `delivered` — started as a turn (idle target, or an interrupt);
+     *  `steered` — injected into the running turn; `queued-mid-turn` — parked
+     *  until the current turn ends (or a steer / `deliverWithin` fires).
+     *  `delivery` / `pending` are always set by the registry; optional here so
+     *  structural stand-ins that only know `queued` still type-check. */
+    delivery?: PromptDelivery;
+    /** ISO 8601 delivery time, when already delivered. */
+    deliveredAt?: string;
+    /** True while the prompt has NOT reached the target yet. */
+    pending?: boolean;
+    /** Id of the parked item (`delivery: "queued-mid-turn"`). */
+    queueId?: string;
+}
+type PromptDelivery = "delivered" | "steered" | "queued-mid-turn";
 /** What `sendMessage` did with a message — truthful, per AIP-46. */
 interface SendMessageResult {
     messageId: string;
@@ -4218,6 +4349,30 @@ interface QueuedPromptView {
     queuedAt: string;
     position: number;
 }
+/** One prompt still waiting to reach a session, with its age — the
+ *  `pendingPrompts` field on `session_list` / `session_recap` so a sender (or
+ *  a supervisor reading a truncated list) sees a stuck delivery. `stale` is
+ *  set once it has waited past the staleness threshold. */
+interface PendingPromptView {
+    id: string;
+    /** Same label as `QueuedPromptView.origin`. */
+    origin: string;
+    preview: string;
+    queuedAt: string;
+    /** Milliseconds since `queuedAt` at read time. */
+    ageMs: number;
+    stale?: true;
+    /** ISO 8601 `deliverWithin` deadline, when one was set. */
+    deliverBy?: string;
+}
+/** Tally of one `sweepPendingPrompts` pass. */
+interface PendingPromptSweepSummary {
+    /** Prompts newly reported stale (sender notified). */
+    stale: number;
+    /** Prompts force-delivered because their `deliverWithin` deadline passed. */
+    forced: number;
+    ids: string[];
+}
 /** Provenance stamped onto a `session_continue_fresh` target by
  *  {@link SessionDescriptor.handoff} — which harness the checkpoint moved
  *  from/to and when. `fromHarness === toHarness` for a same-harness
@@ -4291,7 +4446,9 @@ interface SessionDescriptor {
      *     MCP tool (never by an internal automatic teardown), so it reads as
      *     deliberate rather than random;
      *   - other internal/automatic reasons: `"cost-cap-exceeded"` (the
-     *     turn-granular `maxCostUsd` cap tripped), `"policy-cleanup"` (a
+     *     turn-granular `maxCostUsd` cap tripped), `"context-hard-stop"` (the
+     *     context-continuity hard-stop closed a session past `hardStopAtPct`),
+     *     `"policy-cleanup"` (a
      *     supervisor gate tore down its own ephemeral judge session),
      *     `"parent-exited"` (an orchestrator's dying subtree reap),
      *     `"provider-limit"` (a driver-reported subscription/usage-cap error,
@@ -4394,6 +4551,26 @@ interface SessionDescriptor {
      *  every process. Ephemeral and opt-in (`session_list`/`agent_sessions_list`
      *  `stats`), never persisted; absent for a row with no live process. */
     stats?: Omit<SessionResourceStats, "sessionId">;
+    /** Whether the LIVE agent session's transport to its adapter is still
+     *  usable — `AgentCliRuntimeSession.isConnected()`, read at the same
+     *  points and with the same ephemeral, never-persisted contract as
+     *  {@link processAlive}.
+     *
+     *  This is the second, independent liveness axis, and the one `pid` alone
+     *  cannot answer. An ACP adapter's wrapper process routinely OUTLIVES its
+     *  own JSON-RPC stream: the stream ends (the wrapper closed stdout, the
+     *  child it fronts died, the transport errored), `process.kill(pid, 0)`
+     *  still succeeds, and the row keeps reporting `running`/`alive` forever
+     *  while every prompt rejects with "ACP connection closed". Observed live
+     *  on 2026-09-25 (`sess_950d1251`), 40+ minutes after the connection
+     *  died, with UIs still showing "Idle · live".
+     *
+     *  `false` ⇒ provably dead transport, and the crash-detect sweep's second
+     *  ground for marking a row crashed. Absent ⇒ no live binding to ask (a
+     *  terminal row, or one whose adapter models no long-lived connection) —
+     *  absent is NOT "disconnected", exactly as absent `processAlive` is not
+     *  "dead". */
+    adapterConnected?: boolean;
     /** Count of live supervisors currently blocked waiting on this session —
      *  HTTP `GET /sessions/:id/wait` long-polls and `session_monitor`
      *  subscriptions, both via `monitorSessionWait` (#session-visibility).
@@ -4427,6 +4604,10 @@ interface SessionDescriptor {
      *  preview, queuedAt, position) lives behind the `session_queue_list`
      *  verb / `GET /sessions/:id/queue` — this is just the scalar badge. */
     queuedPrompts?: number;
+    /** The queued prompts themselves, with age (`PendingPromptView`) — derived
+     *  at read time from {@link promptQueue}, never persisted. Absent when
+     *  nothing is waiting. */
+    pendingPrompts?: PendingPromptView[];
     /** Short human-readable string describing the most recent automatic
      *  failure — currently only stamped by `markCrashed` (e.g. "adapter
      *  process gone (pid 1234) — session crashed"). Not a stack trace or raw
@@ -4718,6 +4899,15 @@ interface SessionDescriptor {
      *  effects on reaping, notifications, or anything else. Absent (not
      *  `false`) for every session that hasn't been pinned. */
     pinned?: boolean;
+    /** Ascending position among pinned sessions — the stored order behind
+     *  the pinned group of the CLI table / VS Code webview list. Set by
+     *  `registry.setPinned` (append-at-end) and `registry.reorderPinned`
+     *  (manual reorder); deleted when the session is unpinned. Absent on
+     *  legacy pinned rows persisted before this field existed — those sort
+     *  after every ordered pinned session (by `startedAt` asc, then id).
+     *  Pure sort/display state, same as `pinned` — never touches the live
+     *  agent, keepAlive, or the idle-reaper. */
+    pinnedOrder?: number;
     /** True when the session was spawned under a real PTY (node-pty)
      *  instead of `child_process.spawn`. PTY sessions carry raw ANSI
      *  bytes (alt-screen, key bindings, colors); attach goes through
@@ -4924,8 +5114,8 @@ interface SessionDescriptor {
     /**
      * Deterministic billing-auth mode + a non-secret credential fingerprint,
      * recorded at spawn time for adapters that resolved an explicit
-     * credential (today: claude-code — see `AgentCliAuth.modes` in
-     * `@agentproto/driver-agent-cli`). The "verifiability" answer to "what
+     * credential (adapters declaring `authSubscription` and/or an API-key
+     * `provider`). The "verifiability" answer to "what
      * was used": `mode` is the resolved `"subscription" | "api-key"`;
      * `fingerprint` is `credentialFingerprint(mode, credential)` — e.g.
      * `"subscription · sk-ant-oat…3f9c"` — NEVER the raw credential. Absent
@@ -5431,7 +5621,18 @@ interface SessionSummary {
      *  `unarchiveSession`. Absent on rows archived before this field existed. */
     archivedAt?: string;
     keepAlive?: boolean;
+    /** Steward wrap-up flag — a blocked/needs-input verdict that deliberately
+     *  left the session running; see `SessionDescriptor.wrapupFlag`. */
+    wrapupFlag?: {
+        verdict: "blocked" | "needs-input";
+        note?: string;
+        judgedBy?: string;
+        at: string;
+    };
     pinned?: boolean;
+    /** Ascending position among pinned sessions — see
+     *  `SessionDescriptor.pinnedOrder`. */
+    pinnedOrder?: number;
     pty?: boolean;
     name?: string;
     argv?: readonly string[];
@@ -5519,6 +5720,20 @@ interface SessionSummary {
  *  (i.e. never wrap) to avoid a regression for sessions/shells that don't
  *  use bracketed paste at all. */
 type BracketedPasteMode = "on" | "off" | "unknown";
+/**
+ * Which death `markCrashed` is recording. Both leave the row equally dead
+ * and equally lazy-resumable — this only picks the `lastError`/banner
+ * wording, so whoever reads the row afterwards knows which liveness axis
+ * actually failed.
+ *
+ *   - `"process-gone"`     — the pid probe came back dead (`processAlive:
+ *     false`). The original, and still the common, crash shape.
+ *   - `"transport-closed"` — the adapter's JSON-RPC stream is closed while
+ *     its process is (or may be) alive: `AgentSessionLike.isConnected()`
+ *     returned false. Invisible to the pid probe, which is exactly why this
+ *     ground exists.
+ */
+type SessionCrashReason = "process-gone" | "transport-closed";
 /**
  * Thrown by the lazy resume path when a resumable session has already failed to
  * resume `MAX_RESUME_ATTEMPTS` times in a row (`canResume` false on a row that
@@ -5681,7 +5896,7 @@ type PermissionRespondResult = {
  *  SessionOutcome} / {@link SessionDescriptor.wrapupFlag} for the field
  *  meanings. */
 interface CloseWithOutcomeInput {
-    verdict: "done" | "abandoned" | "blocked" | "needs-input";
+    verdict: "done" | "abandoned" | "partial" | "failed" | "blocked" | "needs-input";
     /** Overrides the outcome's derived summary when given (e.g. a judge's own
      *  written summary) — trimmed the same way `deriveSessionOutcome` trims
      *  `lastAssistantText`. Omitted keeps whatever `deriveSessionOutcome`
@@ -5878,7 +6093,27 @@ interface SessionsRegistry {
          *  structured-question answer, and noted in the SENDER's transcript
          *  as `session-message-sent`. */
         envelope?: SessionMessage;
+        /** On the queue arm, inject this prompt into the target's RUNNING turn
+         *  at the next safe point (ACP steering) instead of waiting for the
+         *  turn to end — when the agent advertises steering. FIFO among steered
+         *  prompts. Ignored for envelopes and child-sourced prompts; absent ⇒
+         *  today's park-until-turn-end. A refused steer leaves it queued. */
+        steer?: boolean;
+        /** Deadline in ms: a prompt still queued past it is force-delivered by
+         *  the pending-prompt sweep per `deliverVia`. */
+        deliverWithinMs?: number;
+        /** `steer` — inject only (stay queued if it can't); `interrupt` —
+         *  cancel the turn and run it; `auto` (default) — steer, else interrupt. */
+        deliverVia?: "auto" | "steer" | "interrupt";
     }): Promise<EnqueuePromptResult>;
+    /** One pass over every prompt queue: force-deliver items past their
+     *  `deliverWithin` deadline, and notify the sender (typed `notice` into the
+     *  caller's — else the target's parent's — inbox) once per item that has
+     *  waited past `staleMs`. Driven on a timer by the daemon; callable directly. */
+    sweepPendingPrompts(opts?: {
+        now?: number;
+        staleMs?: number;
+    }): Promise<PendingPromptSweepSummary>;
     /** Cancel one not-yet-dispatched item in `SessionDescriptor.promptQueue`
      *  by id — the composer's per-item "remove" action. Idempotent: an
      *  unknown session or an id that's already gone (dispatched, already
@@ -6012,6 +6247,16 @@ interface SessionsRegistry {
      *  so `interruptedAtBoot === bootId` means "interrupted by the restart that
      *  preceded THIS boot" (continue-interrupted). */
     readonly bootId: string;
+    /** Absolute base dir this registry's per-session transcripts AND index
+     *  sidecars live under — the SAME dir the writers use (`sessions.eventsDir`
+     *  config > default). Exposed so `session_search`/`session_recap` (and a
+     *  daemon-startup backfill) read the sidecars this registry writes without
+     *  re-deriving the path. */
+    readonly transcriptBaseDir: string;
+    /** Flush any throttled index-sidecar writes immediately. Called at
+     *  shutdown; exposed so a test can assert a trailing write landed without
+     *  waiting out the throttle window. Best-effort and synchronous. */
+    flushSessionIndexes(): void;
     /** Book one automatic continue prompt against `id` (increment
      *  `autoContinueAttempts`, stamp `lastAutoContinueBoot = bootId`) and
      *  persist. Called by the continue-on-boot pass BEFORE it sends, so the
@@ -6211,12 +6456,26 @@ interface SessionsRegistry {
      *  MCP verb / `POST /sessions/:id/pin`). `true` flips
      *  `SessionDescriptor.pinned` on — pure sort/display state for the CLI
      *  table and the VS Code webview's list, which sort a pinned session to
-     *  the top. `false` clears it. Persists via the same `schedulePersist`
-     *  every descriptor mutation uses and emits `session:pinned-changed` so a
+     *  the top. Pinning a session that isn't pinned yet APPENDS it to the
+     *  end of the pinned group (`pinnedOrder` = max pinned order over the
+     *  currently pinned + 1, missing treated as -1); re-pinning an already
+     *  pinned session keeps its order. `false` clears the pin and deletes
+     *  `pinnedOrder`. Persists via the same `schedulePersist` every
+     *  descriptor mutation uses and emits `session:pinned-changed` so a
      *  live UI resorts without waiting for its next snapshot poll. NEVER
      *  touches `keepAlive`, reaper eligibility, or any notification path —
      *  pin is quiet, structural state only. Throws when the id is unknown. */
     setPinned(id: string, pinned: boolean): SessionDescriptor;
+    /** Manually reorder the pinned group (the `session_reorder_pinned` MCP
+     *  verb / `POST /sessions/pinned/order`). Every id must exist and be
+     *  pinned — throws `reorderPinned: ...` otherwise (duplicates rejected
+     *  too). Listed ids get `pinnedOrder` 0..n-1 in the given order; every
+     *  other pinned session keeps its relative order and is placed after
+     *  (legacy pinned rows with no `pinnedOrder` sort by `startedAt` asc,
+     *  then id). Persists via `schedulePersist`, emits
+     *  `session:pinned-reordered` on the session event bus, and returns the
+     *  pinned descriptors in their new order. */
+    reorderPinned(ids: string[]): SessionDescriptor[];
     /** Materialize a new artifact (or version of one) into the session's
      *  durable artifact store (`session_artifact_add` MCP verb / `POST
      *  /sessions/:id/artifacts`) — see `session-artifacts.ts`. Emits
@@ -6411,8 +6670,19 @@ interface SessionsRegistry {
      *  violate — it refuses (returns false, no-op) a session that is not a
      *  live (`running`) agent-cli row, so it is idempotent and safe to call on
      *  an already-terminal or non-agent-cli row. Returns true iff a row was
-     *  actually marked crashed. */
-    markCrashed(id: string): boolean;
+     *  actually marked crashed.
+     *
+     *  `reason` names WHICH death was discovered, and is the only thing that
+     *  differs between the sweep's two grounds. Omitted ⇒ `"process-gone"`,
+     *  the original pid-probe wording ("adapter process gone (pid N) — session
+     *  crashed"). `"transport-closed"` is the case a pid probe cannot see: the
+     *  wrapper process is still alive but its ACP stream ended, so the row
+     *  would otherwise sit `running`/`alive` forever while every prompt
+     *  rejects with "ACP connection closed". Only the `lastError`/banner text
+     *  changes — every other effect (status, endedReason, cleared binding,
+     *  `session:exited`) is identical, because in both cases the session is
+     *  equally dead and equally resumable. */
+    markCrashed(id: string, reason?: SessionCrashReason): boolean;
     /** Flip a LIVE, mid-turn agent-cli row to `stalledSinceMs:<ts>` — the
      *  primitive the turn-liveness watchdog (`runStallWatchdogPass`) drives on
      *  a periodic sweep when a turn's adapter stream has gone silent past the
@@ -6943,4 +7213,4 @@ interface RecordOpenedPrInput {
     url: string;
 }
 
-export { DEFAULT_WORKTREE_PROVISION_CONCURRENCY as $, type ActivityPolicySlice as A, type UsageRollup as B, type CompletionPolicySupervisor as C, type RemainingQuotaReader as D, type UsageSnapshotRecord as E, type SessionAwaitingQuestion as F, type PolicyRunState as G, type PtyFactory as H, type WorktreeAutoReclaimer as I, type ActivityKind as J, type ActivitySource as K, type ActivityState as L, type MessageUrgency as M, type ActivityWaitingOn as N, type AnthropicReaderConfig as O, type PrResolvedState as P, type QuotaReadableProfile as Q, type RestartPolicy as R, type SessionEvent as S, type TaskLedger as T, type UserPreset as U, AnthropicRemainingQuotaReader as V, type WorktreeProvisioner as W, type AttachPolicyInput as X, type CommandGroupStats as Y, type CommitSpec as Z, DEFAULT_WORKTREE_ISOLATION as _, type SessionEventType as a, type TaskUpdateInput as a$, type EagerResumeFailReason as a0, type EagerResumeOutcome as a1, type EagerResumeSkipReason as a2, type GateSpec as a3, type HostInfo as a4, type JudgeGateSpec as a5, type LabeledProcessStatsReport as a6, type LabeledSessionStats as a7, MAX_MESSAGE_DATA_BYTES as a8, MESSAGE_KINDS as a9, type SessionCurrentPhase as aA, type SessionKind as aB, type SessionMessageFrom as aC, type SessionOutcome as aD, type SessionOutcomeArtifact as aE, type SessionOutcomeCompact as aF, type SessionOutcomeLink as aG, type SessionResourceStats as aH, type SessionSnapshots as aI, type SessionStatus as aJ, type ShellGateSpec as aK, type SpawnAgentInput as aL, type SpawnSessionInput as aM, type StatsDetail as aN, type StoredProfileQuota as aO, TASK_STATUSES as aP, type TaskCaller as aQ, type TaskChangedEvent as aR, type TaskClaimInput as aS, type TaskCreateInput as aT, type TaskGateOutcome as aU, type TaskGateRunner as aV, type TaskLedgerRegistry as aW, type TaskLedgerSessionSlice as aX, type TaskListFilter as aY, type TaskRecord as aZ, type TaskStatus as a_, MESSAGE_PREAMBLE as aa, MESSAGE_TAG as ab, MESSAGE_URGENCIES as ac, type MessageDeliveryVia as ad, type MessageFilter as ae, type MessageRelation as af, type MessageTreeNode as ag, type OnFailSpec as ah, type OrphanGroup as ai, type PendingPermission as aj, type PermissionRespondInput as ak, type PermissionRespondResult as al, type PolicyRunStatus as am, type PricingResolver as an, type ProcessDetail as ao, type ProcessStatsReport as ap, type ProcessStatsService as aq, type QuotaStoreFile as ar, type QuotaStoreOptions as as, type RegisterBrowserInput as at, type RegisterSessionInput as au, type RemainingQuota as av, type ResourceStats as aw, ResumeDisabledError as ax, SESSION_END_REASONS as ay, SESSION_ID_ENV as az, type SessionEventBus as b, sanitizeLabel as b$, type TaskVerification as b0, type TaskVerifySupervisor as b1, type TaskWriteResult as b2, type TokenPricing as b3, type UsageBucket as b4, type UsageComputeInput as b5, type UsageDetail as b6, type UsageSource as b7, type UserPresetsFile as b8, WORKSPACE_SLUG_ENV as b9, isProviderLimitError as bA, isTerminalActivityState as bB, listUserPresets as bC, loadQuotaStore as bD, loadUserPresets as bE, loadWorktreeIsolation as bF, matchesMessageFilter as bG, messageFrom as bH, mintMessageId as bI, normalizeCommand as bJ, normalizeWorktreeField as bK, parseAnthropicRateLimitHeaders as bL, parseTaskStatus as bM, parseWindow as bN, parseWorktreeIsolationMode as bO, pickUsageDetail as bP, policyToActivities as bQ, policyWatchesSession as bR, prToActivities as bS, projectSessionUsage as bT, readProfileQuota as bU, recordProfileQuota as bV, renderInboxDigest as bW, renderSessionMessage as bX, renderSessionMessages as bY, resolveRelation as bZ, rollupUsage as b_, WORKTREE_ISOLATION_ENV as ba, WORKTREE_PROVISION_CONCURRENCY_ENV as bb, type WorktreeDecision as bc, type WorktreeProvisionOutcome as bd, type WorktreeProvisionPhase as be, type WorktreeProvisionProgress as bf, type WorktreeProvisionRequest as bg, type WorktreeRequest as bh, activityCounts as bi, compactOutcome as bj, createProcessStatsService as bk, createSessionMessage as bl, createSupervisorTaskGateRunner as bm, createTaskLedger as bn, decideWorktreeIsolation as bo, deleteUserPreset as bp, deriveSessionOutcome as bq, deriveSessionUsage as br, escapeHumanPrompt as bs, escapeMessageBody as bt, filterActivities as bu, getProcessStatsService as bv, getUserPreset as bw, isClosedTaskStatus as bx, isKnownSessionEndReason as by, isMessageAllowed as bz, type SessionsRegistry as c, saveUserPreset as c0, trackWorktreeProvision as c1, turnToActivities as c2, userPresetsPath as c3, workflowToActivities as c4, type RecentSpawnConfig as c5, deriveRecentSpawnConfigs as c6, touchUserPreset as c7, userPresetSchema as c8, type SessionDescriptor as d, type SessionEndReason as e, type ActivityListFilter as f, type ActivityRecord as g, type ActivityTurnSession as h, type ActivityPrSession as i, type ActivityWorkflowRunSlice as j, type ActivityTaskSlice as k, type AgentsMdResolution as l, type SandboxAppServeSpec as m, type WorktreeField as n, type AgentSessionLike as o, type UsageReadContext as p, type UsageReadResult as q, type MessageKind as r, type SessionMessage as s, type AgentStreamEvent as t, type SessionUsage as u, type ToolCallRecord as v, type StatsSessionDescriptor as w, type ProcRow as x, type ProvisionInFlight as y, type ProvisionTracker as z };
+export { type CommitSpec as $, type ActivityPolicySlice as A, type ProvisionTracker as B, type CompletionPolicySupervisor as C, type SessionCrashReason as D, type UsageRollup as E, type RemainingQuotaReader as F, type UsageSnapshotRecord as G, type SessionAwaitingQuestion as H, type PolicyRunState as I, type PtyFactory as J, type WorktreeAutoReclaimer as K, type ActivityKind as L, type MessageUrgency as M, type ActivitySource as N, type ActivityState as O, type PrResolvedState as P, type QuotaReadableProfile as Q, type RestartPolicy as R, type SessionEvent as S, type TaskLedger as T, type UserPreset as U, type ActivityWaitingOn as V, type WorktreeProvisioner as W, type AnthropicReaderConfig as X, AnthropicRemainingQuotaReader as Y, type AttachPolicyInput as Z, type CommandGroupStats as _, type SessionEventType as a, type TaskListFilter as a$, DEFAULT_WORKTREE_ISOLATION as a0, DEFAULT_WORKTREE_PROVISION_CONCURRENCY as a1, type EagerResumeFailReason as a2, type EagerResumeOutcome as a3, type EagerResumeSkipReason as a4, type GateSpec as a5, type HostInfo as a6, type JudgeGateSpec as a7, type LabeledProcessStatsReport as a8, type LabeledSessionStats as a9, ResumeDisabledError as aA, SESSION_END_REASONS as aB, SESSION_ID_ENV as aC, type SessionCurrentPhase as aD, type SessionKind as aE, type SessionMessageFrom as aF, type SessionOutcome as aG, type SessionOutcomeArtifact as aH, type SessionOutcomeCompact as aI, type SessionOutcomeLink as aJ, type SessionResourceStats as aK, type SessionSnapshots as aL, type SessionStatus as aM, type ShellGateSpec as aN, type SpawnAgentInput as aO, type SpawnSessionInput as aP, type StatsDetail as aQ, type StoredProfileQuota as aR, TASK_STATUSES as aS, type TaskCaller as aT, type TaskChangedEvent as aU, type TaskClaimInput as aV, type TaskCreateInput as aW, type TaskGateOutcome as aX, type TaskGateRunner as aY, type TaskLedgerRegistry as aZ, type TaskLedgerSessionSlice as a_, MAX_MESSAGE_DATA_BYTES as aa, MESSAGE_KINDS as ab, MESSAGE_PREAMBLE as ac, MESSAGE_TAG as ad, MESSAGE_URGENCIES as ae, type MessageDeliveryVia as af, type MessageFilter as ag, type MessageRelation as ah, type MessageTreeNode as ai, NO_OUTPUT_STALL_TURN_ERROR as aj, type OnFailSpec as ak, type OrphanGroup as al, type PendingPermission as am, type PermissionRespondInput as an, type PermissionRespondResult as ao, type PolicyRunStatus as ap, type PricingResolver as aq, type ProcessDetail as ar, type ProcessStatsReport as as, type ProcessStatsService as at, type QuotaStoreFile as au, type QuotaStoreOptions as av, type RegisterBrowserInput as aw, type RegisterSessionInput as ax, type RemainingQuota as ay, type ResourceStats as az, type SessionEventBus as b, renderSessionMessages as b$, type TaskRecord as b0, type TaskStatus as b1, type TaskUpdateInput as b2, type TaskVerification as b3, type TaskVerifySupervisor as b4, type TaskWriteResult as b5, type TokenPricing as b6, type UsageBucket as b7, type UsageComputeInput as b8, type UsageDetail as b9, isClosedTaskStatus as bA, isKnownSessionEndReason as bB, isMessageAllowed as bC, isProviderLimitError as bD, isTerminalActivityState as bE, listUserPresets as bF, loadQuotaStore as bG, loadUserPresets as bH, loadWorktreeIsolation as bI, matchesMessageFilter as bJ, messageFrom as bK, mintMessageId as bL, normalizeCommand as bM, normalizeWorktreeField as bN, parseAnthropicRateLimitHeaders as bO, parseTaskStatus as bP, parseWindow as bQ, parseWorktreeIsolationMode as bR, pickUsageDetail as bS, policyToActivities as bT, policyWatchesSession as bU, prToActivities as bV, projectSessionUsage as bW, readProfileQuota as bX, recordProfileQuota as bY, renderInboxDigest as bZ, renderSessionMessage as b_, type UsageSource as ba, type UserPresetsFile as bb, WORKSPACE_SLUG_ENV as bc, WORKTREE_ISOLATION_ENV as bd, WORKTREE_PROVISION_CONCURRENCY_ENV as be, type WorktreeDecision as bf, type WorktreeProvisionOutcome as bg, type WorktreeProvisionPhase as bh, type WorktreeProvisionProgress as bi, type WorktreeProvisionRequest as bj, type WorktreeRequest as bk, activityCounts as bl, compactOutcome as bm, createProcessStatsService as bn, createSessionMessage as bo, createSupervisorTaskGateRunner as bp, createTaskLedger as bq, decideWorktreeIsolation as br, deleteUserPreset as bs, deriveSessionOutcome as bt, deriveSessionUsage as bu, escapeHumanPrompt as bv, escapeMessageBody as bw, filterActivities as bx, getProcessStatsService as by, getUserPreset as bz, type SessionsRegistry as c, resolveRelation as c0, rollupUsage as c1, sanitizeLabel as c2, saveUserPreset as c3, trackWorktreeProvision as c4, turnToActivities as c5, userPresetsPath as c6, workflowToActivities as c7, type RecentSpawnConfig as c8, deriveRecentSpawnConfigs as c9, touchUserPreset as ca, userPresetSchema as cb, type SessionDescriptor as d, type SessionEndReason as e, type ActivityListFilter as f, type ActivityRecord as g, type ActivityTurnSession as h, type ActivityPrSession as i, type ActivityWorkflowRunSlice as j, type ActivityTaskSlice as k, type AgentsMdResolution as l, type SandboxAppServeSpec as m, type WorktreeField as n, type AgentSessionLike as o, type UsageReadContext as p, type UsageReadResult as q, type MessageKind as r, type SessionMessage as s, type AgentStreamEvent as t, type SessionUsage as u, type ToolCallRecord as v, type PendingPromptView as w, type StatsSessionDescriptor as x, type ProcRow as y, type ProvisionInFlight as z };

package/dist/{spawn-defaults-Cp9SGZex.d.ts → spawn-defaults-Dm7nbxcP.d.ts}

@@ -91,6 +91,13 @@ interface ContextContinuityPolicy extends Partial<ContextContinuityThresholds>,
     mode?: ContextContinuityMode;
     /** Optional display label for UIs. */
     label?: string;
+    /** Suggest a cross-harness handoff (`session:handoff-suggested`) once the
+     *  provider-reported remaining quota of the session's auth profile falls to
+     *  or below this number. Same unit as the `remaining` figure
+     *  `usage_rollup` shows per profile (Anthropic's unified rate-limit
+     *  header — a count, not a percentage: the header carries no limit to
+     *  divide by). Unset = disabled. Suggestion only, never a switch. */
+    handoffAtQuotaRemaining?: number;
 }
 /**
  * Fully-resolved, validated policy. This is the shape stored on a session
@@ -100,6 +107,8 @@ interface ResolvedContextContinuityPolicy extends ContextContinuityThresholds, R
     mode: ContextContinuityMode;
     /** Effective label (falls back to mode when absent). */
     label: string;
+    /** See {@link ContextContinuityPolicy.handoffAtQuotaRemaining}. */
+    handoffAtQuotaRemaining?: number;
 }
 
 /**
@@ -238,7 +247,8 @@ interface McpDefaultsConfig {
      *  3 — see `deferred-tools.ts`). Default false/absent: every daemon boot
      *  stays eager, byte-identical to pre-existing behaviour — turning this
      *  on is a deliberate operator opt-in. Independent of the per-role
-     *  default (`RoleProfile.deferredTools`, on for `executor`) and the
+     *  default (`RoleProfile.deferredTools`, on for `executor`), the
+     *  harness default (`nativeToolSearch` ⇒ eager) and the
      *  per-spawn `agent_start.deferredTools` override, and independent of
      *  the per-mount `?deferred=1|0` query override on `/mcp` — this is only
      *  the BOOT-TIME default for connections that specify neither. */
@@ -355,6 +365,10 @@ interface SpawnDefaultsConfig {
          *  recipient's in-flight turn). Default "deny": downgraded to `steer`
          *  and reported as such. Human (HTTP/CLI) senders always may. */
         agentInterrupt?: "allow" | "deny";
+        /** Minutes a prompt may sit queued behind a running turn before the
+         *  sender is told it is stuck (typed notice) and it is flagged `stale`
+         *  in `pendingPrompts`. Default 5. */
+        pendingPromptStaleMinutes?: number;
     };
     /** Daemon-wide MCP gateway policy. See {@link McpDefaultsConfig}. */
     mcp?: McpDefaultsConfig;

package/dist/user-presets.d.ts

@@ -1,11 +1,11 @@
 import 'zod';
-import './session-config-DxIIuJFY.js';
-import './spawn-defaults-Cp9SGZex.js';
-export { c5 as RecentSpawnConfig, U as UserPreset, b8 as UserPresetsFile, bp as deleteUserPreset, c6 as deriveRecentSpawnConfigs, bw as getUserPreset, bC as listUserPresets, bE as loadUserPresets, c0 as saveUserPreset, c7 as touchUserPreset, c8 as userPresetSchema, c3 as userPresetsPath } from './sessions-SrISpFsH.js';
+import './session-config-BUDM7T1B.js';
+import './spawn-defaults-Dm7nbxcP.js';
+export { c8 as RecentSpawnConfig, U as UserPreset, bb as UserPresetsFile, bs as deleteUserPreset, c9 as deriveRecentSpawnConfigs, bz as getUserPreset, bF as listUserPresets, bH as loadUserPresets, c3 as saveUserPreset, ca as touchUserPreset, cb as userPresetSchema, c6 as userPresetsPath } from './sessions-BdgU9X6P.js';
 import '@agentproto/auth';
 import '@agentproto/acp';
 import '@agentproto/command-sandbox';
 import '@agentproto/model-catalog';
 import '@agentproto/acp/client';
 import 'node:child_process';
-import './config-Gz7q9yfJ.js';
+import './config-Dsmv-jri.js';