Merge remote-tracking branch 'origin/master' into worktree/preset-plane-fallout-p1

Generated docs (`module-graph`, `event-producer-consumer`) taken from master
and regenerated. The `cordis-inspect-jsdoc` golden likewise: master's copy is
the base, and this branch's `presentAs` per-scope rewording is re-applied on
top, since `cordis_inspect` renders that JSDoc into model-visible output.

Hook bypassed as before: the staged-pairing check hands an archived note path
to `verify-translation-pairing`. The full-corpus gate passes.

packages/host/apiproxy/src/api-proxy.ts

@@ -39,7 +39,7 @@ import type {
   ApiProxy, ConfigurableProviderView, CredentialView, GoalRef, HistoryEntry, HostFrame,
   ModelCatalogFailure, ModelProviderGroup,
   ModelReasoning, MuxFrame, PromptContentPart, QuestionResponsePayload, SessionProjectionsBlock, SessionSearchItem,
-  QueuedInboxItem, SessionSummary, SettingsNamespaceView, SubagentAddress, ToolEventView,
+  QueuedInboxItem, SessionSummary, SettingsNamespaceView, SubagentAddress, TaskView, ToolEventView,
   WorkspaceId, WorkspaceView,
 } from './api/index.ts'
 import {
@@ -49,6 +49,9 @@ import {
 } from './api/session-search.ts'
 // Type-only: resolves `ctx.get('sessionProjections')` to the projection registry.
 import type {} from '@deepseek-ai/dsh-session-projection'
+// Type-only: resolves `ctx.get('tasks')` to the background task registry.
+import type {} from '@deepseek-ai/dsh-tasks'
+import type { TaskSnapshot } from '@deepseek-ai/dsh-tasks'
 // Type-only: resolves `ctx.get('sessionProjectionCache')` (the cold listing column).
 import type {} from '@deepseek-ai/dsh-session-projection-cache'
 // GoalError narrows domain rejections to their stable codes at the wire boundary.
@@ -406,6 +409,22 @@ function subscribeSession(queue: FrameQueue<RpcRequest<MuxFrame>>, session: Sess
   queue.push(frame({ type: 'session/subscribed', sessionId: session.id, lastSeq: session.seq - 1 }))
 }
 
+/**
+ * Project registry snapshots onto the wire view, dropping the three internal
+ * fields {@link TaskView} documents as absent.
+ */
+function taskViews(snapshots: readonly TaskSnapshot[]): TaskView[] {
+  return snapshots.map(task => ({
+    id: task.id,
+    kind: task.kind,
+    label: task.label,
+    status: task.status,
+    ...task.detail === undefined ? {} : { detail: task.detail },
+    startedAt: task.startedAt,
+    ...task.finishedAt === undefined ? {} : { finishedAt: task.finishedAt },
+  }))
+}
+
 /**
  * Whether the session's conversation has started: no turn has run yet (a
  * turn is one model-loop execution). Standalone plugin events — command
@@ -3260,6 +3279,19 @@ export function createApiProxy(ctx: Context, defaults: ApiProxyDefaults): ApiPro
             queue.push(frame({ type: 'session/queue', sessionId: session.id, items: queueItems(agent) }))
           }
         }
+        // Background-task baseline. `ctx.agents.get` is the non-resuming read:
+        // a session with no live Agent owns no tasks, so it correctly sees only
+        // the unowned ones, and listing never revives a cold session. An empty
+        // set sends nothing — absence is how the client reads "no tasks".
+        const tasks = ctx.get('tasks')
+        if (tasks !== undefined) {
+          for (const session of ctx.sessions.list()) {
+            const views = taskViews(tasks.list(ctx.agents.get(session.id)))
+            if (views.length > 0) {
+              queue.push(frame({ type: 'session/tasks', sessionId: session.id, tasks: views }))
+            }
+          }
+        }
         // Per-session open-call table for result-view pairing. Bounded by the
         // per-turn call count: entries clear on turn/end; a table miss (stream
         // opened mid-turn) backscans the session's in-memory events instead.
@@ -3287,10 +3319,36 @@ export function createApiProxy(ctx: Context, defaults: ApiProxyDefaults): ApiPro
           }),
           ctx.on('session/created', (session: Session) => {
             subscribeSession(queue, session)
+            // The subscribe frame clears the client's task mirror, and a
+            // session born after the stream opened missed the baseline loop.
+            // Unowned tasks are visible to it from birth, so without this it
+            // would show none until the next registry change.
+            const views = tasks === undefined ? [] : taskViews(tasks.list(ctx.agents.get(session.id)))
+            if (views.length > 0) {
+              queue.push(frame({ type: 'session/tasks', sessionId: session.id, tasks: views }))
+            }
           }),
           ctx.on('session/disposed', (session: Session) => {
             openCalls.delete(session.id)
           }),
+          ...tasks === undefined ? [] : [tasks.onTasksChanged((owner) => {
+            if (owner !== undefined) {
+              // The exact owner instance the fence compares against, so the
+              // push stays correct even while that Agent's scope is tearing
+              // down and a lookup by id would already miss.
+              queue.push(frame({ type: 'session/tasks', sessionId: owner.id, tasks: taskViews(tasks.list(owner)) }))
+              return
+            }
+            // An unowned task is visible to every caller, so every subscribed
+            // session's set changed with it.
+            for (const session of ctx.sessions.list()) {
+              queue.push(frame({
+                type: 'session/tasks',
+                sessionId: session.id,
+                tasks: taskViews(tasks.list(ctx.agents.get(session.id))),
+              }))
+            }
+          })],
         ]
         return queue.iterate(signal, () => {
           muxQueues.delete(queue)

packages/host/apiproxy/src/api/events.schema.ts

@@ -13,6 +13,7 @@ import { approvalRequestIdSchema } from './approvals.schema.ts'
 import {
   contentBlockSchema, messageIdSchema, sessionEventSchema, sessionIdSchema, toolEventViewSchema,
 } from './sessions.schema.ts'
+import { taskViewSchema } from './tasks.schema.ts'
 import { workspaceIdSchema, workspaceViewSchema } from './workspace.schema.ts'
 
 /** Question fields validated strictly against core dsh-user-interaction. */
@@ -58,6 +59,7 @@ export const muxFrameSchema = z.discriminatedUnion('type', [
       message: messageSchema,
     })),
   }),
+  z.object({ type: z.literal('session/tasks'), sessionId: sessionIdSchema, tasks: z.array(taskViewSchema) }),
   // value stays wide: it already passed its unit's own schema on the host,
   // and deep-validating here would import every domain's schema into the carrier.
   z.object({ type: z.literal('session/projection'), sessionId: sessionIdSchema, key: z.string().min(1), value: z.unknown(), seq: z.number().int().nonnegative() }),

packages/host/apiproxy/src/api/events.ts

@@ -14,6 +14,7 @@ import type { CallId } from '@deepseek-ai/dsh-llm/brand'
 import type { SessionEvent, SessionId } from '@deepseek-ai/dsh-session/types'
 import type { ToolCallView, ToolResultView } from '@deepseek-ai/dsh-tools/presentation'
 import type { RpcError, RpcId, RpcRequest } from './rpc.ts'
+import type { TaskView } from './tasks.ts'
 import type { WorkspaceView } from './workspace.ts'
 
 // Client-side consumers take the render-intent vocabulary from the contract;
@@ -81,6 +82,20 @@ export type MuxFrame =
    * in QueueDock, while pending steering renders at the conversation tail.
    */
   | { type: 'session/queue'; sessionId: SessionId; items: QueuedInboxItem[] }
+  /**
+   * Complete set of background tasks this session can see, after every registry
+   * commit that changes it: registration, the stopping transition, settlement,
+   * and owner-disposal removal. The registry is process-local and holds no
+   * durable event, so — exactly like `session/queue` — the whole snapshot is
+   * what makes a start, a kill, a reconnect, and a second tab converge on one
+   * authoritative value.
+   *
+   * Sent as a subscription baseline only for a session that currently has
+   * tasks; an absent key means an empty set. A change that empties the set
+   * still sends `[]`, since that transition is the only one absence cannot
+   * express.
+   */
+  | { type: 'session/tasks'; sessionId: SessionId; tasks: TaskView[] }
   /**
    * One projection unit's finished value changed (session-projection RFC).
    * Live push state, never logged — replay recomputes on the host (the

packages/host/apiproxy/src/api/index.ts

@@ -48,6 +48,7 @@ export type {
   SubagentAddress, SubagentCatalog, SubagentInterruptReceipt, SubagentListEntry,
   SubagentPromptReceipt, SubagentsApi,
 } from './subagents.ts'
+export type { TaskView } from './tasks.ts'
 export type { WorkspaceApi, WorkspaceId, WorkspaceView } from './workspace.ts'
 export type { CommandsApi, CommandDescriptor } from './commands.ts'
 export type { SkillsApi, SkillEntry } from './skills.ts'

packages/host/apiproxy/src/api/sessions.schema.ts

@@ -45,6 +45,7 @@ export const sessionEventSchema = z.object({
   data: z.unknown(),
   sourceEventSeqs: z.array(z.number()).optional(),
   surfaceOp: z.unknown().optional(),
+  ignorable: z.literal(true).optional(),
 }) as unknown as z.ZodType<SessionEvent>
 
 /** SessionSummary row of session.list (`projections` reuses the history block's shape and schema). */

packages/host/apiproxy/src/api/tasks.schema.ts

@@ -0,0 +1,33 @@
+/**
+ * tasks domain zod schemas: the branded task id and the wire view carried by
+ * `session/tasks` frames.
+ */
+
+import { z } from 'zod'
+import type { TaskId } from '@deepseek-ai/dsh-tasks/brand'
+import type { TaskView } from './tasks.ts'
+import type { Wire } from './rpc.schema.ts'
+
+/** TaskId: one brand cast after non-empty string validation. */
+export const taskIdSchema = z.string().min(1) as unknown as z.ZodType<TaskId>
+
+/**
+ * One wire task view. `kind` stays an open string because producer plugins
+ * extend the registry's kind map by declaration merging, so the closed set is
+ * not knowable at this boundary.
+ */
+export const taskViewSchema = z.object({
+  id: taskIdSchema,
+  kind: z.string().min(1),
+  label: z.string().min(1),
+  status: z.union([
+    z.literal('running'),
+    z.literal('stopping'),
+    z.literal('completed'),
+    z.literal('killed'),
+    z.literal('failed'),
+  ]),
+  detail: z.string().optional(),
+  startedAt: z.number().int().nonnegative(),
+  finishedAt: z.number().int().nonnegative().optional(),
+}) satisfies z.ZodType<Wire<TaskView>>

packages/host/apiproxy/src/api/tasks.ts

@@ -0,0 +1,36 @@
+/**
+ * Browser-safe background-task domain contract. The registry's live records
+ * never cross the wire; a view is the subset a human list needs, minted fresh
+ * per push.
+ */
+
+import type { TaskId } from '@deepseek-ai/dsh-tasks/brand'
+
+/**
+ * One background task as the client sees it.
+ *
+ * Three registry fields are deliberately absent. `ownerSession` is redundant
+ * beside the frame's own `sessionId`; `reported` is an internal notice-delivery
+ * bit with no user meaning; `outputLimitBytes` is producer-owned model
+ * presentation policy that never reaches a human surface.
+ */
+export interface TaskView {
+  /** Registry-issued `<kind>-N` identity, stable for the task's whole life. */
+  id: TaskId
+  /**
+   * Producer kind (`bash`, `pwsh`, `pty-send`, `subagent`, …). Kept as a bare
+   * string because producer plugins extend the kind map by declaration merging,
+   * so no client build can enumerate the closed set.
+   */
+  kind: string
+  /** Producer-supplied one-line label: the command, or the delegation description. */
+  label: string
+  /** Current lifecycle state. */
+  status: 'running' | 'stopping' | 'completed' | 'killed' | 'failed'
+  /** Kind-specific status detail ('exit code: 3'), present once the producer supplied one. */
+  detail?: string
+  /** Epoch ms when the task was registered. */
+  startedAt: number
+  /** Epoch ms when the task settled; absent while live. */
+  finishedAt?: number
+}