@agentproto/runtime 2.8.0 → 2.10.0

package/dist/index.d.ts

@@ -13,8 +13,8 @@ export { CostBudget, CostBudgetScope } from '@agentproto/auth';
 import { R as ResolvedContextContinuityPolicy } from './context-continuity-ib9_bVYM.js';
 import { SandboxMode } from '@agentproto/command-sandbox';
 import { AdapterHandle, SetupField, AdapterResolver, AdapterLister, HarnessCapabilities, AdapterEntry } from '@agentproto/provider-kit';
-import { R as ResolvedAuthSpec, D as DeclaredAdapterOption, A as AdapterAuthDescriptor } from './spawn-defaults-DVgmfxWo.js';
-export { a as AuthEcho, b as AuthResolutionError, C as CLAUDE_CODE_OAUTH_SOURCE, c as CredentialSource, d as DefaultsAdapterAuthConfig, e as DefaultsAdapterConfig, f as ResolveSubscriptionCredentialInput, g as ResolvedSpawnAuthMaterial, h as ResolvedSpawnDefaults, S as SpawnDefaultsConfig, i as SubscriptionCredentialResolution, j as SubscriptionSourceError, k as credentialFingerprint, n as normalizeSkillsOption, r as resolveAuthSpec, l as resolveSpawnDefaults, m as resolveSubscriptionCredential } from './spawn-defaults-DVgmfxWo.js';
+import { R as ResolvedAuthSpec, D as DeclaredAdapterOption, A as AdapterAuthDescriptor } from './spawn-defaults-DUnTfwVK.js';
+export { a as AuthEcho, b as AuthResolutionError, C as CLAUDE_CODE_OAUTH_SOURCE, c as CredentialSource, d as DefaultsAdapterAuthConfig, e as DefaultsAdapterConfig, f as ResolveSubscriptionCredentialInput, g as ResolvedSpawnAuthMaterial, h as ResolvedSpawnDefaults, S as SpawnDefaultsConfig, i as SubscriptionCredentialResolution, j as SubscriptionSourceError, k as credentialFingerprint, n as normalizeSkillsOption, r as resolveAuthSpec, l as resolveSpawnDefaults, m as resolveSubscriptionCredential } from './spawn-defaults-DUnTfwVK.js';
 import { CatalogModelsQuery, CatalogModelsResponse } from './catalog-models.js';
 export { CatalogAdapterInput, CatalogAdapterModelInput, CatalogPricing, CatalogProduct, CatalogRoute, CatalogRouteSummary, CatalogVendor, buildCatalogModels } from './catalog-models.js';
 import { FooterSession } from './pr-provenance.js';
@@ -1251,9 +1251,21 @@ interface PolicyRunState {
     retries: number;
     startedAt: string;
     endedAt?: string;
+    /**
+     * Result of the most recent gate run. `kind` distinguishes what produced
+     * it — `stdout`/`stderr` (truncated) are only populated for a shell gate;
+     * a judge gate only ever sets `exitCode`/`at` here (its actual verdict
+     * lives in `verdict` below). Consulted by a SIBLING judge gate watching
+     * an overlapping session set (see `findRecentMachineGateResult`) so it
+     * cannot render a verdict blind to an already-known machine result —
+     * see that function's doc for the incident this closes.
+     */
     lastGate?: {
         exitCode: number;
         at: string;
+        kind?: "shell" | "judge" | "cost";
+        stdout?: string;
+        stderr?: string;
     };
     /**
      * Structured judge-gate verdict (WP-D). Set when the gate is a judge gate
@@ -2046,6 +2058,17 @@ interface SessionModelChangedEvent {
     type: "session:model-changed";
     sessionId: string;
     model: string;
+    /**
+     * The model now believed to be ACTIVE — mirrors
+     * `SessionDescriptor.activeModel`. Absent only for adapters/paths that
+     * predate this field; once populated it's kept in lockstep with `model`
+     * (equal when a switch went through this daemon, divergent when learned
+     * from an adapter's own reply to a `/model` sent as an ordinary prompt).
+     * REPORTED BY THE ADAPTER, NOT INDEPENDENTLY VERIFIED when it diverges
+     * from `model` — see `SessionDescriptor.activeModel`'s doc. A display
+     * hint, never a source of billing/cost truth.
+     */
+    activeModel?: string;
     label?: string;
     ts: string;
 }
@@ -3348,6 +3371,35 @@ declare function createActivityProjector(opts: {
     resolvePrState?: PrStateResolver;
 }): ActivityProjector;
 
+/**
+ * Daemon-side AGENTS.md resolution + injection (WP-R2).
+ *
+ * The daemon historically had ZERO first-class handling of `AGENTS.md` — it
+ * was read only when an adapter happened to do so natively (opencode by its
+ * own convention, claude-code via `CLAUDE.md`, hermes not at all), and the
+ * supervisor brief told a child to "go read AGENTS.md" by hand, which is a
+ * loterie, not a guarantee. This module makes the daemon resolve and inject
+ * it itself, adapter-agnostic, at spawn time — the same way it already
+ * composes the role disposition (see `role.ts`'s `composeRoleContext`).
+ *
+ * Resolution runs once per spawn, from the session's resolved `cwd`:
+ *   - walk UP directory by directory, checking for an `AGENTS.md` at each
+ *     level; the FIRST one found (nearest to `cwd`) wins.
+ *   - the walk is bounded by the git toplevel of `cwd`'s own repo
+ *     (`git rev-parse --show-toplevel` from `cwd`) — it never walks past it
+ *     into an outer/parent repo. A nested repo has its own `.git`, so git's
+ *     toplevel resolves to the nested root and the walk stops exactly there.
+ *   - if `cwd` is not inside a git repo at all, only `cwd` itself is checked
+ *     (no walk), falling through to "absent" when nothing is there.
+ *
+ * Injection is a block in the child's single composed initial prompt (there
+ * is no separate system-prompt channel — see `session-spawn.ts`'s
+ * `effectivePrompt` construction): a full inline copy when the file is small
+ * enough, a pointer to read it first when it's large, or nothing extra when
+ * absent — plus a standing cd-contract sentence regardless of mode.
+ */
+type AgentsMdMode = "inline" | "pointer" | "absent";
+
 /**
  * Policy layer for `agent_start.worktree` — the config-driven decision of
  * WHETHER to isolate a spawn into its own git worktree, kept deliberately
@@ -3435,17 +3487,44 @@ type WorktreeProvisionOutcome = {
  * by the CLI (over `@agentproto/worktree`); absent on a bare runtime.
  */
 type WorktreeProvisioner = (req: WorktreeProvisionRequest) => Promise<WorktreeProvisionOutcome>;
+/**
+ * Injected port: best-effort attempt to reclaim ONE worktree by path, called
+ * when its session reaches a terminal state (see
+ * `SessionDescriptor.worktreeAutoProvisioned` and `createSessionsRegistry`'s
+ * `runWorktreeAutoReclaim` option in `sessions.ts`). Deliberately scoped to
+ * exactly the one path a session's own exit is allowed to touch — never a
+ * repo-wide sweep. The implementation (wired by the CLI over
+ * `@agentproto/worktree`'s `reclaimOneWorktree`) re-classifies fresh and only
+ * ever removes the worktree when that comes back `reclaim` (merged-or-fresh,
+ * clean, idle) — a dirty or held worktree is simply left alone. Must never
+ * reject in a way the caller can't safely ignore; `sessions.ts` treats any
+ * rejection as "couldn't reclaim this time, leave it for a manual or
+ * scheduled `gc` sweep" and logs rather than lets it interrupt session
+ * teardown. Absent on a bare runtime — auto-reclaim is simply skipped, and a
+ * caller-explicit worktree request is never routed through this port at all
+ * (see `WorktreeDecision.provision.implicit`).
+ */
+type WorktreeAutoReclaimer = (worktreePath: string) => Promise<void>;
 /** The pure decision's three outcomes. `spawn-in-place` may carry a `warn`:
  *  a non-fatal notice the caller should surface (the child is about to run in
  *  a shared, dirty checkout it doesn't own). A `warn` never blocks the spawn —
  *  it's the loud-but-legitimate middle ground between silently spawning into a
- *  shared tree and hard-rejecting an in-place spawn that's normal at depth. */
+ *  shared tree and hard-rejecting an in-place spawn that's normal at depth.
+ *  `provision.implicit` is `true` exactly when the caller made no explicit
+ *  `worktree` request and the `"always"` policy provisioned one anyway (the
+ *  worktree the caller never asked to keep) — `false` whenever the request
+ *  came from the caller itself (`on-request`'s only path here, or `"always"`
+ *  with an explicit field). This is the signal `session-spawn.ts` threads
+ *  onto the session descriptor so exit-time auto-reclaim (`sessions.ts`)
+ *  only ever touches a worktree the daemon minted on its own — a worktree a
+ *  caller explicitly asked to keep is never auto-removed. */
 type WorktreeDecision = {
     action: "spawn-in-place";
     warn?: string;
 } | {
     action: "provision";
     request: WorktreeRequest;
+    implicit: boolean;
 } | {
     action: "reject";
     message: string;
@@ -3571,17 +3650,21 @@ declare function toWorktreeStatusView(entry: unknown): WorktreeStatusView;
  * Repo-root resolution is shared with the status surface via
  * `resolveWorktreeQueryRoot` in `worktree-status.ts`.
  */
+
 /** `gc`'s three classes, mirrored runtime-local (matches `GcClass`). */
 type WorktreeGcClass = "reclaim" | "salvage" | "hold";
 /**
- * `gc`'s one reclaim reason, mirrored runtime-local (matches `GcReclaimReason`).
- * Set only on a `reclaim`-class entry/outcome that was promoted out of `hold`
- * by the dep-bump exemption (`resolveGcClass` in `@agentproto/worktree`) —
- * absent for an ordinary merged/fresh reclaim, so its presence alone is the
- * "why does this line have unpushed commits and still leave" signal a human
- * reading the plan/outcome table needs.
+ * `gc`'s reclaim reasons, mirrored runtime-local (matches `GcReclaimReason`).
+ * `dep-bump` is set on a `reclaim`-class entry/outcome that was promoted out
+ * of `hold` by the dep-bump exemption (`resolveGcClass` in
+ * `@agentproto/worktree`) — absent for an ordinary merged/fresh reclaim, so
+ * its presence alone is the "why does this line have unpushed commits and
+ * still leave" signal a human reading the plan/outcome table needs.
+ * `orphan` is set on an entry/outcome the orphan scan found — a directory
+ * physically present under the repo's worktree pool with no `git worktree
+ * list` entry at all (see `WorktreeGcPlanEntryView.orphan`).
  */
-type WorktreeGcReclaimReason = "dep-bump";
+type WorktreeGcReclaimReason = "dep-bump" | "orphan";
 /**
  * One entry of the dry-run plan — a runtime-local projection of a
  * `GcPlanEntry`. `tree` / `integration` / `liveness` are flattened to their
@@ -3593,8 +3676,17 @@ interface WorktreeGcPlanEntryView {
     branch: string | null;
     head: string;
     class: WorktreeGcClass;
-    /** Set only when `class === "reclaim"` via the dep-bump exemption. */
+    /** Set only when `class === "reclaim"` via the dep-bump exemption or the orphan scan. */
     reclaimReason?: WorktreeGcReclaimReason;
+    /**
+     * `true` only for an orphan-scan entry: a directory physically present
+     * under the repo's worktree pool with no `git worktree list` entry at all
+     * (even after a prune). `tree`/`integration`/`liveness` carry no real axis
+     * read for these — git itself can't answer those questions for a
+     * directory it no longer recognizes as a worktree — so they're set to the
+     * literal `"orphan"` placeholder below rather than a fabricated value.
+     */
+    orphan?: boolean;
     tree: string;
     integration: {
         state: string;
@@ -3646,6 +3738,17 @@ interface WorktreeGcRunInput {
     apply: boolean;
     salvageDirty: boolean;
     includeDetached: boolean;
+    /**
+     * Absolute cwds of every live session the daemon knows about right now —
+     * see `livingSessionCwds` below. Threaded straight to the gc engine's own
+     * `protectedPaths` (`@agentproto/worktree`'s `PlanGcInput`/`ApplyGcOptions`):
+     * a worktree that IS or CONTAINS one of these paths is held, never
+     * reclaimed/salvaged, regardless of what `classify`'s own (snapshot-based)
+     * liveness axis concludes. Optional — a host that can't cheaply enumerate
+     * its own live sessions (or has none, e.g. the bare CLI `worktree gc`
+     * command) omits it and gets exactly today's behavior.
+     */
+    protectedPaths?: string[];
 }
 /**
  * Injected port: the runtime asks the host to plan (and, when `apply`, execute)
@@ -4219,6 +4322,22 @@ interface AgentStreamEvent {
     /** "permission-resolved" chosen option id, when the driver's offered
      *  options included one (e.g. ACP's `allow_always`). */
     optionId?: string;
+    /** "available-commands" full command list — see @agentproto/acp's
+     *  `StreamEvent`'s `available-commands` kind. REPLACES any previously
+     *  reported list wholesale; it is not a delta. */
+    commands?: Array<{
+        name: string;
+        description?: string;
+        input?: {
+            hint?: string;
+        } | null;
+        _meta?: {
+            scope?: string;
+            path?: string;
+            bareName?: string;
+            qualifiedName?: string;
+        };
+    }>;
 }
 /**
  * Env vars the registry injects into every process it spawns on a session's
@@ -4329,8 +4448,29 @@ interface QueuedPrompt {
     /** ISO 8601 timestamp this item was queued. */
     queuedAt: string;
     /** Same as `enqueuePrompt`'s `opts.source` — carried through to the
-     *  turn this item eventually becomes. */
+     *  turn this item eventually becomes (transcript provenance). */
     source?: string;
+    /** Who/what queued this, for the AFTER-THE-FACT queue UI — DISTINCT
+     *  from `source` (transcript provenance). Set from `enqueuePrompt`'s
+     *  `opts.origin` at the enqueue site so a human session-operator, an
+     *  agent session (`agent_prompt`), and a child's report (`message_parent`)
+     *  are cleanly separable when someone inspects the queue later across a
+     *  daemon restart. Absent for legacy queued items — `promptOriginLabel`
+     *  falls back to `source`, then `"user"`. */
+    origin?: string;
+}
+/** One entry in the after-the-fact queue listing (`listQueuedPrompts` /
+ *  `session_queue_list` / `GET /sessions/:id/queue`). `position` is the
+ *  array index (0 = next to dispatch). */
+interface QueuedPromptView {
+    id: string;
+    /** Human-readable origin — who queued this ("user", "agent <id>", "child <id>"). */
+    origin: string;
+    /** Short single-line text preview of the message. */
+    preview: string;
+    /** ISO 8601 timestamp the item was queued. */
+    queuedAt: string;
+    position: number;
 }
 interface SessionDescriptor {
     id: string;
@@ -4438,6 +4578,14 @@ interface SessionDescriptor {
      *  busy descendants. NOTE: in-process subagents a harness runs itself are
      *  invisible to the daemon between turns, so they don't count here. */
     childrenBusy?: number;
+    /** Count of prompts currently sitting in this session's
+     *  {@link promptQueue} — a cheap, always-present badge signal for
+     *  list/table/panel rendering ("N queued"), derived at read time from
+     *  the live queue. Ephemeral, never persisted (the queue itself is).
+     *  0/absent ⇒ nothing waiting. The full per-item detail (origin,
+     *  preview, queuedAt, position) lives behind the `session_queue_list`
+     *  verb / `GET /sessions/:id/queue` — this is just the scalar badge. */
+    queuedPrompts?: number;
     /** 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
@@ -4497,6 +4645,24 @@ interface SessionDescriptor {
      *  the moment a LATER turn completes without one (same reset shape as
      *  `resumeAttempts`/`restartAttempts`). Detection + signal only. */
     lastTurnErroredAt?: string;
+    /** True when the LAST completed turn produced zero assistant output and
+     *  zero tool calls (mirrors `SessionTurnEndEvent.empty` — see that
+     *  field's doc). Persisted so `monitorSessionWait`'s synchronous
+     *  already-in-target-state fast-path (which has only the descriptor to
+     *  read, not the triggering bus event) can surface the same "green
+     *  turn-end but nothing actually happened" signal the bus/ring branches
+     *  get from the event itself. Stamped every `turnCompleted` turn end
+     *  (absent, not `false`, on a productive turn) — never set by the
+     *  abnormal (error/abort) turn-end path, matching the bus event. */
+    lastTurnEmpty?: boolean;
+    /** The LAST completed turn's `SessionTurnEndEvent.reason` (e.g.
+     *  `"completed"`, `"error"`, `"aborted"`), when the adapter/daemon
+     *  reported one. Twin of `lastTurnEmpty` — same reason for existing:
+     *  the sync fast-path branch of `monitorSessionWait` has no event
+     *  object to read `.reason` off, only this descriptor. Stamped at every
+     *  turn end (normal or abnormal); absent when the turn ended with no
+     *  reason to report. */
+    lastTurnReason?: string;
     /** DERIVED, read-time only (never persisted — stripped by `snapshotRows`,
      *  stamped by `stampInterrupted` in list()/get()/findByIdOrName). True when
      *  this session died with a turn in flight under a daemon restart —
@@ -4668,6 +4834,42 @@ interface SessionDescriptor {
      *  `worktreePath` without an id identifies a PATH, which a later worktree
      *  may reuse; the pair identifies one specific worktree. */
     worktreeId?: string;
+    /** `true` only when `worktreePath` was provisioned by the `worktrees.isolation`
+     *  policy WITHOUT an explicit `worktree` request from the caller (see
+     *  `decideWorktreeIsolation`'s `WorktreeDecision.provision.implicit` in
+     *  `worktree-isolation.ts`) — a worktree the caller never asked to keep.
+     *  Gates exit-time auto-reclaim (`emitExited` below, via the injected
+     *  `WorktreeAutoReclaimer` port): only an implicit worktree is ever a
+     *  candidate for automatic removal on session exit. Absent (never `true`)
+     *  for a worktree the caller explicitly requested (`worktree: {...}` on
+     *  the spawn), which keeps today's manual-cleanup-only behavior unchanged,
+     *  and absent for every session persisted before this field existed. */
+    worktreeAutoProvisioned?: boolean;
+    /** Absolute path of the AGENTS.md the daemon resolved for this session's
+     *  spawn `cwd` (walking up, bounded by the repo's git toplevel — see
+     *  `agents-md.ts`), whose content or pointer was injected into the initial
+     *  prompt. Absent when `agentsMdMode` is `"absent"` and for a session
+     *  persisted before this field existed. */
+    agentsMd?: string;
+    /** How the resolved AGENTS.md was injected at spawn: `"inline"` (full
+     *  content), `"pointer"` (read-it-first instruction), or `"absent"` (the
+     *  walk found none — a real, reported state, a consumer distinguishes it
+     *  from the field being missing in an old descriptor shape by checking
+     *  `=== "absent"`). The daemon's spawn path (`session-spawn.ts`) ALWAYS
+     *  stamps this once resolution ran — it is optional on the type only so
+     *  legacy persisted descriptors (pre-WP-R2) and non-AGENTS.md-aware
+     *  constructor paths don't have to fabricate a value; a freshly-spawned
+     *  session always carries it. */
+    agentsMdMode?: AgentsMdMode;
+    /** Absolute path of the per-workspace `RULES.md` the daemon resolved for
+     *  this session's spawn workspace (see `workspace-rules.ts`) — read from
+     *  the workspace's state bucket (`~/.agentproto/workspaces/<slug>/
+     *  RULES.md`) and injected into the initial prompt of EVERY spawn in the
+     *  workspace (root and nested, no depth gate). Present only when a rules
+     *  file was actually found and injected; `undefined` means absent (there
+     *  is no separate inline/pointer/absent tri-state — the field itself being
+     *  undefined already means absent). */
+    rulesMd?: string;
     /** Pull requests opened while this session was acting on a code host.
      *
      * This is deliberately session provenance rather than workspace state: a
@@ -4736,6 +4938,24 @@ interface SessionDescriptor {
     mode?: string;
     /** The model the session was requested to run (echoed back at spawn). */
     model?: string;
+    /**
+     * The model believed to be ACTIVE right now, when it may differ from
+     * `model` above (the requested/spawn-time value). Populated by a
+     * successful live `setModel` (mirrors `model` — the switch went through
+     * this daemon, so both facts agree) or, more importantly, by picking a
+     * model-switch acknowledgement out of an ORDINARY prompt turn whose text
+     * opened with `/model <id>` (`@agentproto/driver-agent-cli`'s
+     * `isModelSwitchAcknowledgement`/`parseModelSwitchCommand` —
+     * `applyModelCommand`'s dedicated control turn never runs for that case,
+     * since the switch never went through `agent_set_model`).
+     *
+     * That second source is REPORTED BY THE ADAPTER'S OWN REPLY TEXT, NOT
+     * INDEPENDENTLY VERIFIED — a deliberately lax match good enough as a
+     * display hint for a UI chip, NEVER a source of billing/cost truth. Never
+     * overwrites `model`: losing the spawn-time request would lose the very
+     * thing that lets a client show the two facts diverging.
+     */
+    activeModel?: string;
     /** Reasoning / compute budget the session resolved to (SPEC §3.1 axis 2).
      *  A LIVE-switchable axis; echoed here so the effort chip re-opens on it. */
     effort?: EffortLevel;
@@ -4790,6 +5010,24 @@ interface SessionDescriptor {
      *  `"no-pricing"` (tokens present but the model isn't in the catalog — cost
      *  deliberately left undefined), or `"none"`. Stamped at each turn-end. */
     usageSource?: UsageSource;
+    /** Latest known `available_commands_update` payload (see @agentproto/acp's
+     *  `StreamEvent`'s `available-commands` kind) — the slash-commands/skills
+     *  the agent currently supports. Each notification REPLACES the previous
+     *  list wholesale, so this always mirrors the most recent one, not a
+     *  merge across notifications. */
+    availableCommands?: Array<{
+        name: string;
+        description?: string;
+        input?: {
+            hint?: string;
+        } | null;
+        _meta?: {
+            scope?: string;
+            path?: string;
+            bareName?: string;
+            qualifiedName?: string;
+        };
+    }>;
     /** ACP-level session id (the adapter's own handle — claude-code's
      *  conversation id, hermes' chat id, …). Set at spawnAgent time
      *  from `agentSession.sessionId`. Survives across daemon restarts
@@ -4826,6 +5064,19 @@ interface SessionDescriptor {
      *  Keys are adapter-specific so future adapters can add their own
      *  ("hermesResumeId", etc.) without changing this type. */
     resumeMetadata?: Record<string, string>;
+    /** Extra env this PTY (`kind: "terminal"`) session was spawned with, on
+     *  top of `process.env` — e.g. `{ CLAUDE_CONFIG_DIR: "..." }` for a
+     *  `pty-native` restart of a claude-code session (see
+     *  `ResumeStrategy.configDirEnvVar`, resume-strategies.ts). Once a
+     *  restart lands on a bare PTY row, `adapterSlug`/`adapterConfigDir` are
+     *  gone (undefined for pty/command kinds, by design — see those fields'
+     *  docs), so this is the ONLY way a LATER `pty-plain` restart-of-a-
+     *  restart can still know what env the provider's native resume needs —
+     *  `session_restart`'s pty-plain branch replays it verbatim, the same way
+     *  it already replays `argv`. Absent when the PTY was spawned with no
+     *  extra env (a plain `agentproto sessions terminal`, or a `pty-plain`
+     *  restart of one). */
+    ptyResumeEnv?: Record<string, string>;
     /** Set by the orchestration layer when the agent emits an
      *  "awaiting-input" turn-end. Cleared on the next turn start.
      *  Used by `session_monitor` to fast-return without subscribing. */
@@ -5071,6 +5322,8 @@ interface SessionSummary {
     /** Busy-descendant count (#session-visibility, subtree rollup) — see
      *  `SessionDescriptor.childrenBusy`. Drives the "delegating" row state. */
     childrenBusy?: number;
+    /** Prompt-queue badge count — see `SessionDescriptor.queuedPrompts`. */
+    queuedPrompts?: number;
     label?: string;
     title?: string;
     renamedByUser?: boolean;
@@ -5084,6 +5337,12 @@ interface SessionSummary {
     cwd?: string;
     worktreePath?: string;
     worktreeId?: string;
+    /** Resolved AGENTS.md path — see `SessionDescriptor.agentsMd`. */
+    agentsMd?: string;
+    /** Injection mode — see `SessionDescriptor.agentsMdMode`. */
+    agentsMdMode?: AgentsMdMode;
+    /** Resolved workspace RULES.md path — see `SessionDescriptor.rulesMd`. */
+    rulesMd?: string;
     adapterSlug?: string;
     mode?: string;
     model?: string;
@@ -5382,6 +5641,7 @@ interface SessionsRegistry {
     sendPrompt(id: string, message: unknown, opts?: {
         interrupt?: boolean;
         source?: string;
+        system?: string;
     }): Promise<void>;
     /** Fire-and-forget variant of `sendPrompt` for the TURN ITSELF only.
      *  Admission (resume attempt + the missing/wrong-kind/dead/busy
@@ -5425,6 +5685,11 @@ interface SessionsRegistry {
     enqueuePrompt(id: string, message: unknown, opts?: {
         interrupt?: boolean;
         source?: string;
+        /** Display origin for the after-the-fact queue UI ("user" for a
+         *  human operator, agent/child when another session injected this).
+         *  Sets `QueuedPrompt.origin` — see that field; does NOT influence
+         *  transcript provenance (`source` does that). */
+        origin?: string;
         queue?: boolean;
         force?: boolean;
         queueId?: string;
@@ -5438,6 +5703,43 @@ interface SessionsRegistry {
     removeQueuedPrompt(id: string, queueId: string): {
         removed: boolean;
     };
+    /** Snapshot a session's prompt queue for inspection — the after-the-fact
+     *  view of what's sitting in `SessionDescriptor.promptQueue` right now.
+     *  Runs the shared preview + origin-label derivation so every consumer
+     *  (the `session_queue_list` MCP tool, `GET /sessions/:id/queue`, the CLI,
+     *  the VS Code panel) sees identical text. `position` is the array index
+     *  (0 = next to dispatch), not stored — derived per call. Returns `null`
+     *  when the session is unknown (the caller surfaces 404). */
+    listQueuedPrompts(id: string): QueuedPromptView[] | null;
+    /** Reorder-only force: move an already-queued item to the FRONT of the
+     *  queue (position 0) WITHOUT touching any turn currently in flight — it
+     *  becomes next-to-dispatch once the current turn (if any) ends. The
+     *  queue-reordering counterpart to `deliverQueuedPrompt`'s interrupt-and-
+     *  dispatch; the two are deliberately distinct operations. Returns
+     *  position after promotion (0 when promoted, -1 when the item/session
+     *  isn't found). Never mutates the array in place (the webview diff rules
+     *  on `!==` per field). */
+    promoteQueuedPrompt(id: string, queueId: string): {
+        promoted: boolean;
+        position: number;
+    };
+    /** Deliver-now: interrupt whatever's mid-flight (same effect + shared
+     *  helper as `enqueuePrompt`'s `interrupt` arm) and immediately dispatch
+     *  THIS specific queued item as the new turn, removing it from the queue.
+     *  The "I need this NOW" op — distinct from `promoteQueuedPrompt` (which
+     *  only reorders; deliver-now cannot wait for the current turn to end).
+     *
+     *  Implemented as promote-to-front + interrupt: the cancelled turn's
+     *  own `dispatchQueuedPrompt` (in its finally) then drains the promoted
+     *  item into a fresh turn. On an idle session (nothing to interrupt) the
+     *  promoted item is dispatched directly. Returns:
+     *    `{ delivered: false, reason }` — `"no-session"` / `"not-in-queue"`;
+     *    `{ delivered: true, interrupted: boolean }` otherwise. */
+    deliverQueuedPrompt(id: string, queueId: string): Promise<{
+        delivered: boolean;
+        reason?: string;
+        interrupted?: boolean;
+    }>;
     /** Eagerly resume ONE dead-but-resumable agent-cli session IN PLACE,
      *  WITHOUT a prompt — the boot-time counterpart to the lazy resume that
      *  `sendPrompt`/`enqueuePrompt` trigger on the first prompt after a restart
@@ -5943,6 +6245,15 @@ interface SpawnAgentInput {
      *  runs in the background, projecting events into the ring
      *  buffer. Skip to spawn idle. */
     initialPrompt?: string;
+    /** The daemon-composed SYSTEM slice of {@link initialPrompt} — the part
+     *  it synthesized ahead of the CALLER's ask (role disposition, lineage
+     *  line, AGENTS.md, posture preamble). The adapter still receives the
+     *  single concatenated `initialPrompt` unchanged; this metadata lets the
+     *  daemon's OWN event stream record that slice as a `system-prompt` turn
+     *  (ahead of the `user-prompt`) so UIs can fold it instead of rendering
+     *  it as a user bubble. Absent ⇒ the whole `initialPrompt` is treated as
+     *  user text (no synthesized preamble, e.g. a human reprompt). */
+    initialPromptSystem?: string;
     label?: string;
     /** Title to stamp on the descriptor up-front, BEFORE the `initialPrompt`
      *  turn runs. Set by the spawn path from the CALLER's ask (`input.prompt`),
@@ -6054,6 +6365,10 @@ interface SpawnAgentInput {
      *  idle-reaper.ts) regardless of how long it sits idle — stamped straight
      *  onto `SessionDescriptor.keepAlive`. Default false. */
     keepAlive?: boolean;
+    /** Recorded verbatim onto {@link SessionDescriptor.worktreeAutoProvisioned}
+     *  — see that field's doc. Set by `session-spawn.ts` from
+     *  `WorktreeDecision.provision.implicit`. Default false. */
+    worktreeAutoProvisioned?: boolean;
 }
 /** `SpawnAgentInput` minus the fields that only exist once the driver's
  *  `startSession` has actually run — see `spawnAgentPending`'s doc for why
@@ -6078,6 +6393,10 @@ type PendingAgentOutcome = {
     /** Dispatched now that the tree + driver session both exist — never
      *  passed to `spawnAgentPending`, which would race the tree. */
     initialPrompt?: string;
+    /** The daemon-composed SYSTEM slice of `initialPrompt` (see
+     *  `SpawnAgentInput.initialPromptSystem`) — threaded through the
+     *  placeholder so the deferred dispatch records it as a system turn. */
+    initialPromptSystem?: string;
 } | {
     ok: false;
     /** Short, readable — stamped verbatim onto `SessionDescriptor.lastError`. */
@@ -6120,6 +6439,17 @@ interface SpawnPtyInput {
      *  the factory layer (node-pty.spawn options); don't try to clear
      *  them here. */
     env?: Record<string, string>;
+    /** Env vars to strip from the inherited `process.env` before spawning —
+     *  same scrub semantics as `ResolvedAuthSpec.unsetEnv` (define-agent-cli.ts's
+     *  driver applies this by deleting from its own composed env; `spawnPty` has
+     *  no such composition step of its own, so `session_restart`'s pty-native
+     *  branch passes it here). Without this, a PTY resume that re-resolves the
+     *  session's own billing auth still leaks whatever conflicting credential
+     *  (e.g. an ambient `ANTHROPIC_API_KEY`) happens to be in the daemon's own
+     *  `process.env` — `env` alone can only ADD/override keys, never remove
+     *  one inherited from process.env. Applied AFTER `env` overrides so an
+     *  explicit override always wins over a scrub of the same key. */
+    unsetEnv?: string[];
     /** User-friendly slug. Used by `findByIdOrName(query)`. Must not
      *  collide with an existing session's name. */
     name?: string;
@@ -6856,6 +7186,11 @@ interface CatalogProviderModel {
     /** Per-1M-token pricing for LLM models; `null` for the media kinds, whose
      *  pricing is per-image/second/character rather than per token. */
     pricing: CatalogProviderPricing | null;
+    /** ISO date (`YYYY-MM-DD`) this model first appeared in the catalog, when
+     *  known — see `LLMPricing.addedAt` (`model-catalog/src/llm/catalog.ts`)
+     *  for the convention. `null` for media kinds and for LLM entries the sync
+     *  never stamped (hand-maintained rows). Lets a picker show a "new" badge. */
+    addedAt: string | null;
 }
 interface CatalogProviderModelsResponse {
     /** The provider key that was enumerated (echoed back, trimmed). */
@@ -8234,6 +8569,19 @@ interface SessionWaitResult {
      *  dropped work that was NOT re-run — the in-place resume never auto-retries.
      *  Absent (not `false`) when the session was not interrupted. */
     interrupted?: boolean;
+    /** True when the matched turn-end produced ZERO assistant output and
+     *  zero tool calls — a silent no-op (see `SessionTurnEndEvent.empty`'s
+     *  doc). Surfaced on `event: "turn-end"` matches across all three
+     *  branches (ring-replay, sync fast-path via
+     *  `SessionDescriptor.lastTurnEmpty`, bus long-poll) so a caller doesn't
+     *  mistake a green turn-end for real progress. Absent (not `false`) on a
+     *  normal, productive turn. */
+    empty?: boolean;
+    /** The matched turn-end's `SessionTurnEndEvent.reason` (e.g.
+     *  `"completed"`, `"error"`, `"aborted"`), when the adapter/daemon
+     *  reported one. `"error"` means the adapter reported a failed turn.
+     *  Same three-branch coverage as `empty`. */
+    reason?: string;
 }
 /**
  * Block until one of the listed sessions fires a matching lifecycle event
@@ -8248,6 +8596,15 @@ interface SessionWaitResult {
  * `since` is an EventRing cursor: when provided, already-emitted matching
  * events for the watched sessions that occurred after that cursor are
  * returned immediately (race-free replay) before subscribing to the bus.
+ *
+ * The synchronous already-in-target-state check for `turn-end` ALSO
+ * requires `since` to be present (even `since: 0`) — `turnsCompleted > 0`
+ * never resets, so without a cursor to anchor "since when", it can't tell
+ * a turn this call should wait for apart from any turn the session ever
+ * completed, including ones from long before this call started. A
+ * `since`-less `turn-end` wait (e.g. a fresh `agentproto sessions wait`
+ * process, which has no persisted cursor) always falls through to the real
+ * bus-subscribe long-poll instead.
  */
 declare function monitorSessionWait(opts: {
     registry: SessionsRegistry;
@@ -8574,6 +8931,17 @@ interface CreateGatewayOptions {
      * `worktree_gc` returns a clear "not enabled" error.
      */
     runWorktreeGc?: WorktreeGcRunner;
+    /**
+     * Optional best-effort exit-time reclaim of ONE policy-provisioned
+     * (implicit) session's own worktree — powers `SessionDescriptor.
+     * worktreeAutoProvisioned` (see that field's doc in `sessions.ts`).
+     * Injected for the same reason as `runWorktreeGc`: the classify/remove
+     * logic runs over `@agentproto/worktree`, a dependency the runtime
+     * deliberately does NOT take. The CLI wires it (over `reclaimOneWorktree`).
+     * Omitted → exit-time auto-reclaim is simply skipped; an implicit
+     * worktree is still reclaimable manually or via a scheduled `gc` sweep.
+     */
+    runWorktreeAutoReclaim?: WorktreeAutoReclaimer;
     /**
      * Optional resolver: given a session's cwd, return the OPEN PR for that
      * cwd's git branch (or null). Powers the daemon PR-provenance reconciler,
@@ -8669,4 +9037,4 @@ interface GatewayHandle {
  */
 declare function createGateway(opts: CreateGatewayOptions): Promise<GatewayHandle>;
 
-export { type ActivityKind, type ActivityListFilter, type ActivityPolicyLister, type ActivityProjector, type ActivityProjectorRegistry, type ActivityProjectorSession, type ActivityRecord, type ActivitySource, type ActivityState, type ActivityWaitingOn, type ActivityWorkflowLister, AdapterAuthDescriptor, type AdapterCapabilitiesLister, type AdapterInstallResult, type AdapterListEntry, type AgentAdapterInstaller, type AgentAdapterLister, type AgentAdapterResolver, type AgentSessionLike, type AgentStreamEvent, type AnthropicReaderConfig, AnthropicRemainingQuotaReader, type AttachPolicyInput, type AttachSandboxOpts, type AttachSandboxResult, AuthMethod, BUCKETS_ROOT, type BrowserAdapterHandle, type BrowserAdapterInfo, type BrowserAdapterLister, type BrowserAdapterResolver, BuildHeartbeatAgent, CanonicalPosture, type CatalogModelsLister, CatalogModelsQuery, CatalogModelsResponse, type CatalogProviderModel, type CatalogProviderModelsQuery, type CatalogProviderModelsResponse, type CatalogProviderPricing, type ClaudeNativeRef, type CommitSpec, type CompletionPolicySupervisor, ContextProfile, type ConversationIndexRecord, type ConversationNativeRef, type CostBudgetDecision, type CrashDetectSummary, type CrashReaperRegistry, type CreateGatewayOptions, type CreateOfferInput, type CreatedOffer, DEFAULT_BUCKET, DEFAULT_ORCHESTRATOR_TOOLS, DEFAULT_WORKTREE_ISOLATION, DeclaredAdapterOption, type DeclaredAdapterPreset, type EagerResumeFailReason, type EagerResumeOutcome, type EagerResumeSkipReason, type EagerResumeSummary, EffortLevel, type GateSpec, type GatewayHandle, type HarnessPreset, type HarnessPresetValidationDeps, HarnessPresetValidationError, type HarnessPresetsFile, type HermesNativeRef, INBOUND_PROVIDERS, type IdleReapSummary, type IdleReaperRegistry, type InboundEndpoint, type InboundEndpointStore, type InboundEndpointStoreOptions, type InboundEnqueuePrompt, type InboundIsSessionAlive, type InboundMessage, type InboundProvider, type InboundRestartSession, type InboundRouteMode, type InboundRouterDeps, type InboundRouterLog, type InboundSpawnForContact, type InboundWatcher, type JudgeGateSpec, LEGACY_SESSIONS_FILE, type LocatedConversation, type LocatedConversationByPath, type McpCredentialDeps, type MigrationMarker, type NormalizeInboundResult, type OnFailSpec, type OpenPrResolver, type OrchestratorGatewayDeps, type OrchestratorInjection, type OrchestratorInjector, type OrchestratorInjectorDeps, type OrchestratorMcpServerFactory, type OrchestratorScope, type OrphanReaperRegistry, PAIRINGS_VERSION, POSTURE_NATIVE_ALIASES, POSTURE_PREAMBLES, type PairingChannelContext, type PairingChannelHandle, type PairingChannelMode, type PairingRecord, type PairingRegistry, type PairingRegistryDeps, type PendingPermission, type PermissionRespondInput, type PermissionRespondResult, type PolicyRunState, type PolicyRunStatus, Posture, type PostureResolution, type PrResolvedState, type PrStateResolver, type PresetInfo, type PricingResolver, type QuotaReadableProfile, type QuotaStoreFile, type QuotaStoreOptions, type ReconnectLogGate, type RegisterBrainToolsOptions, type RegisterBrowserInput, type RegisterPairingToolsOptions, type RegisterSessionInput, type RemainingQuota, type RemainingQuotaReader, type ResolveNativeLinkInput, ResolvedAuthSpec, ResumeDisabledError, type RouteAwareLaunchConfig, type RouteAwareLaunchConfigInput, RouteSpec, type RuntimeMeta, SESSION_ID_ENV, type SandboxAdapterInfo, type SandboxConnectionDescriptor, type SandboxProviderCapabilities, type SandboxProviderHandle, type SandboxProviderLister, type SandboxProviderResolver, type ScopeTokenRegistry, SessionConfig, type SessionCurrentPhase, type SessionDescriptor, type SessionKind, type SessionObserver, type SessionSnapshots, type SessionStatus, type SessionUsage, type SessionWaitEvent, type SessionWaitResult, type SessionsRegistry, type ShellGateSpec, type SpawnAgentInput, type SpawnSessionInput, type StallWatchdogRegistry, type StallWatchdogSummary, type StoredProfileQuota, TASK_STATUSES, type TaskCaller, type TaskChangedEvent, type TaskClaimInput, type TaskCreateInput, type TaskGateOutcome, type TaskGateRunner, type TaskLedger, type TaskLedgerRegistry, type TaskLedgerSessionSlice, type TaskListFilter, type TaskRecord, type TaskStatus, type TaskUpdateInput, type TaskVerification, type TaskVerifySupervisor, type TaskWriteResult, type TokenPricing, type TransmitterBinding, type TransmitterBindingStore, type TunnelDescriptor, type TunnelProvider, type TunnelStatus, type UsageBucket, type UsageComputeInput, type UsageRollup, type UsageSnapshotRecord, type UsageSource, WORKSPACE_SLUG_ENV, WORKTREE_ISOLATION_ENV, type WatcherDescriptor, type WatcherStartInput, type WorkspaceBrainSubscriber, type WorkspaceBrainSubscriberOptions, type WorkspaceBrains, WorkspaceFs, type WorktreeDecision, type WorktreeField, type WorktreeGcClass, type WorktreeGcOutcomeView, type WorktreeGcPlanEntryView, type WorktreeGcReclaimReason, type WorktreeGcResult, type WorktreeGcRunInput, type WorktreeGcRunner, WorktreeIsolationMode, type WorktreeProvisionOutcome, type WorktreeProvisionRequest, type WorktreeProvisioner, type WorktreeRequest, type WorktreeStatusLister, type WorktreeStatusView, activityCounts, addHarnessPreset, appendConversationRecord, attachSandbox, bucketDir, bucketSessionsFile, bucketTranscriptDir, buildCatalogProviderModels, buildMcpConfigSnippet, buildRouteAwareLaunchConfig, canonicalForModeId, claudeProjectSlug, composeSessionObservers, conversationIndexPath, createActivityProjector, createFileStepCache, createGateway, createInboundEndpointStore, createOrchestratorInjector, createOrchestratorMcpServerFactory, createPairingRegistry, createPrProvenanceReconciler, createReconnectLogGate, createScopeTokenRegistry, createSupervisorTaskGateRunner, createTaskLedger, createWorkspaceBrainSubscriber, createWorkspaceBrains, daemonRegistryDir, decideWorktreeIsolation, declaredPresetToProviderPreset, deriveSessionUsage, enrichRollupWithProviderQuota, enrichWithRemainingQuota, evaluateCostBudget, filterActivities, findConversationRecord, findNativeMode, formatToolCall, formatToolResult, getDefaultHarnessPreset, getHarnessPreset, getMcpCredentialDeps, harnessPresetsPath, isAgentCliAuthConfigured, isClosedTaskStatus, isSafeBucketSlug, isTerminalActivityState, listBuckets, listHarnessPresets, listPresets, loadHarnessPresets, loadQuotaStore, loadWorktreeIsolation, locateConversationByNativePath, locateConversationBySessionId, makeBrowserAdapterLister, migrateLegacySessionsFile, migrationMarkerPath, monitorPolicyWait, monitorSessionWait, narrowOrchestratorTools, normalizeInbound, normalizeModeId, normalizeWorktreeField, parseAnthropicRateLimitHeaders, parseTaskStatus, parseWindow, parseWorktreeIsolationMode, policyToActivities, policyWatchesSession, prToActivities, projectSessionUsage, readConversationIndex, readDaemonRegistry, readProfileQuota, readRegisteredSlugs, readRuntimeMeta, readSessionForBrain, readUsageSnapshots, reapOrphanedDescendants, recordProfileQuota, registerBrainTools, registerBuiltinRoutes, registerPairingTools, registerSandboxAttachTool, removeHarnessPreset, resolveBucketSlug, resolveNativeLink, resolvePosture, rollupUsage, runCrashDetectPass, runEagerResumePass, runIdleReapPass, runStallWatchdogPass, setDefaultPreset, setMcpCredentialDeps, sweepStaleDaemonRegistry, sweepStaleRuntimeMetas, toWorktreeStatusView, turnToActivities, unlinkDaemonRegistryEntry, unlinkRuntimeMeta, updateHarnessPreset, verifyInboundSignature, workflowToActivities, writeDaemonRegistryEntry };
+export { type ActivityKind, type ActivityListFilter, type ActivityPolicyLister, type ActivityProjector, type ActivityProjectorRegistry, type ActivityProjectorSession, type ActivityRecord, type ActivitySource, type ActivityState, type ActivityWaitingOn, type ActivityWorkflowLister, AdapterAuthDescriptor, type AdapterCapabilitiesLister, type AdapterInstallResult, type AdapterListEntry, type AgentAdapterInstaller, type AgentAdapterLister, type AgentAdapterResolver, type AgentSessionLike, type AgentStreamEvent, type AnthropicReaderConfig, AnthropicRemainingQuotaReader, type AttachPolicyInput, type AttachSandboxOpts, type AttachSandboxResult, AuthMethod, BUCKETS_ROOT, type BrowserAdapterHandle, type BrowserAdapterInfo, type BrowserAdapterLister, type BrowserAdapterResolver, BuildHeartbeatAgent, CanonicalPosture, type CatalogModelsLister, CatalogModelsQuery, CatalogModelsResponse, type CatalogProviderModel, type CatalogProviderModelsQuery, type CatalogProviderModelsResponse, type CatalogProviderPricing, type ClaudeNativeRef, type CommitSpec, type CompletionPolicySupervisor, ContextProfile, type ConversationIndexRecord, type ConversationNativeRef, type CostBudgetDecision, type CrashDetectSummary, type CrashReaperRegistry, type CreateGatewayOptions, type CreateOfferInput, type CreatedOffer, DEFAULT_BUCKET, DEFAULT_ORCHESTRATOR_TOOLS, DEFAULT_WORKTREE_ISOLATION, DeclaredAdapterOption, type DeclaredAdapterPreset, type EagerResumeFailReason, type EagerResumeOutcome, type EagerResumeSkipReason, type EagerResumeSummary, EffortLevel, type GateSpec, type GatewayHandle, type HarnessPreset, type HarnessPresetValidationDeps, HarnessPresetValidationError, type HarnessPresetsFile, type HermesNativeRef, INBOUND_PROVIDERS, type IdleReapSummary, type IdleReaperRegistry, type InboundEndpoint, type InboundEndpointStore, type InboundEndpointStoreOptions, type InboundEnqueuePrompt, type InboundIsSessionAlive, type InboundMessage, type InboundProvider, type InboundRestartSession, type InboundRouteMode, type InboundRouterDeps, type InboundRouterLog, type InboundSpawnForContact, type InboundWatcher, type JudgeGateSpec, LEGACY_SESSIONS_FILE, type LocatedConversation, type LocatedConversationByPath, type McpCredentialDeps, type MigrationMarker, type NormalizeInboundResult, type OnFailSpec, type OpenPrResolver, type OrchestratorGatewayDeps, type OrchestratorInjection, type OrchestratorInjector, type OrchestratorInjectorDeps, type OrchestratorMcpServerFactory, type OrchestratorScope, type OrphanReaperRegistry, PAIRINGS_VERSION, POSTURE_NATIVE_ALIASES, POSTURE_PREAMBLES, type PairingChannelContext, type PairingChannelHandle, type PairingChannelMode, type PairingRecord, type PairingRegistry, type PairingRegistryDeps, type PendingPermission, type PermissionRespondInput, type PermissionRespondResult, type PolicyRunState, type PolicyRunStatus, Posture, type PostureResolution, type PrResolvedState, type PrStateResolver, type PresetInfo, type PricingResolver, type QuotaReadableProfile, type QuotaStoreFile, type QuotaStoreOptions, type ReconnectLogGate, type RegisterBrainToolsOptions, type RegisterBrowserInput, type RegisterPairingToolsOptions, type RegisterSessionInput, type RemainingQuota, type RemainingQuotaReader, type ResolveNativeLinkInput, ResolvedAuthSpec, ResumeDisabledError, type RouteAwareLaunchConfig, type RouteAwareLaunchConfigInput, RouteSpec, type RuntimeMeta, SESSION_ID_ENV, type SandboxAdapterInfo, type SandboxConnectionDescriptor, type SandboxProviderCapabilities, type SandboxProviderHandle, type SandboxProviderLister, type SandboxProviderResolver, type ScopeTokenRegistry, SessionConfig, type SessionCurrentPhase, type SessionDescriptor, type SessionKind, type SessionObserver, type SessionSnapshots, type SessionStatus, type SessionUsage, type SessionWaitEvent, type SessionWaitResult, type SessionsRegistry, type ShellGateSpec, type SpawnAgentInput, type SpawnSessionInput, type StallWatchdogRegistry, type StallWatchdogSummary, type StoredProfileQuota, TASK_STATUSES, type TaskCaller, type TaskChangedEvent, type TaskClaimInput, type TaskCreateInput, type TaskGateOutcome, type TaskGateRunner, type TaskLedger, type TaskLedgerRegistry, type TaskLedgerSessionSlice, type TaskListFilter, type TaskRecord, type TaskStatus, type TaskUpdateInput, type TaskVerification, type TaskVerifySupervisor, type TaskWriteResult, type TokenPricing, type TransmitterBinding, type TransmitterBindingStore, type TunnelDescriptor, type TunnelProvider, type TunnelStatus, type UsageBucket, type UsageComputeInput, type UsageRollup, type UsageSnapshotRecord, type UsageSource, WORKSPACE_SLUG_ENV, WORKTREE_ISOLATION_ENV, type WatcherDescriptor, type WatcherStartInput, type WorkspaceBrainSubscriber, type WorkspaceBrainSubscriberOptions, type WorkspaceBrains, WorkspaceFs, type WorktreeAutoReclaimer, type WorktreeDecision, type WorktreeField, type WorktreeGcClass, type WorktreeGcOutcomeView, type WorktreeGcPlanEntryView, type WorktreeGcReclaimReason, type WorktreeGcResult, type WorktreeGcRunInput, type WorktreeGcRunner, WorktreeIsolationMode, type WorktreeProvisionOutcome, type WorktreeProvisionRequest, type WorktreeProvisioner, type WorktreeRequest, type WorktreeStatusLister, type WorktreeStatusView, activityCounts, addHarnessPreset, appendConversationRecord, attachSandbox, bucketDir, bucketSessionsFile, bucketTranscriptDir, buildCatalogProviderModels, buildMcpConfigSnippet, buildRouteAwareLaunchConfig, canonicalForModeId, claudeProjectSlug, composeSessionObservers, conversationIndexPath, createActivityProjector, createFileStepCache, createGateway, createInboundEndpointStore, createOrchestratorInjector, createOrchestratorMcpServerFactory, createPairingRegistry, createPrProvenanceReconciler, createReconnectLogGate, createScopeTokenRegistry, createSupervisorTaskGateRunner, createTaskLedger, createWorkspaceBrainSubscriber, createWorkspaceBrains, daemonRegistryDir, decideWorktreeIsolation, declaredPresetToProviderPreset, deriveSessionUsage, enrichRollupWithProviderQuota, enrichWithRemainingQuota, evaluateCostBudget, filterActivities, findConversationRecord, findNativeMode, formatToolCall, formatToolResult, getDefaultHarnessPreset, getHarnessPreset, getMcpCredentialDeps, harnessPresetsPath, isAgentCliAuthConfigured, isClosedTaskStatus, isSafeBucketSlug, isTerminalActivityState, listBuckets, listHarnessPresets, listPresets, loadHarnessPresets, loadQuotaStore, loadWorktreeIsolation, locateConversationByNativePath, locateConversationBySessionId, makeBrowserAdapterLister, migrateLegacySessionsFile, migrationMarkerPath, monitorPolicyWait, monitorSessionWait, narrowOrchestratorTools, normalizeInbound, normalizeModeId, normalizeWorktreeField, parseAnthropicRateLimitHeaders, parseTaskStatus, parseWindow, parseWorktreeIsolationMode, policyToActivities, policyWatchesSession, prToActivities, projectSessionUsage, readConversationIndex, readDaemonRegistry, readProfileQuota, readRegisteredSlugs, readRuntimeMeta, readSessionForBrain, readUsageSnapshots, reapOrphanedDescendants, recordProfileQuota, registerBrainTools, registerBuiltinRoutes, registerPairingTools, registerSandboxAttachTool, removeHarnessPreset, resolveBucketSlug, resolveNativeLink, resolvePosture, rollupUsage, runCrashDetectPass, runEagerResumePass, runIdleReapPass, runStallWatchdogPass, setDefaultPreset, setMcpCredentialDeps, sweepStaleDaemonRegistry, sweepStaleRuntimeMetas, toWorktreeStatusView, turnToActivities, unlinkDaemonRegistryEntry, unlinkRuntimeMeta, updateHarnessPreset, verifyInboundSignature, workflowToActivities, writeDaemonRegistryEntry };