@dsh-cove/dsh-web-all 0.0.0-stage → 0.4.3

package/src/host/services/worktree/session-lane/manager.ts

@@ -0,0 +1,228 @@
+/**
+ * Session-bound lane orchestration: the two host-side halves of "start a
+ * conversation on its own worktree".
+ *
+ * Why the host does NOT create the session
+ *   The obvious host path is a direct store insert, but it is wrong on two
+ *   counts:
+ *     1. `ctx.sessions.create()` makes the session owned by the CALLING
+ *        FIBER — disposing that fiber removes the session from the store. A
+ *        session created by this plugin would then disappear on the next
+ *        plugin reload, which is exactly when a developer expects their
+ *        conversation to still be there.
+ *     2. The retired session-isolation wrapper reached for a host gateway
+ *        face (`apiProxy.sessions.create`); on a real deployment that face is
+ *        absent — reproduced live: `POST /worktree/lane/create` answered
+ *        `session-create-failed: the apiProxy sessions face is unavailable`.
+ *   So creation stays with the platform: the browser asks the platform's own
+ *   workspace navigation for the lane (`uiWorkspace.openWorkspace`, whose
+ *   `beforeOpen` callback names the `ctx.sessions.create({ workspaceId })`
+ *   session it connected) and binds that id to the lane. The lane's directory is
+ *   a registered workspace because the platform accounts a session to a workspace
+ *   only while its cwd equals that path; a lane session created with a bare cwd
+ *   would render an inert composer.
+ *
+ * What the host owns
+ *   `createLane`       — make the branch's worktree (attaching an existing
+ *                        branch, cutting a missing one) and register its
+ *                        directory as a workspace. The registration is what makes
+ *                        the conversation in it usable; ownership still sits with
+ *                        the session, and teardown removes the registration with
+ *                        the directory.
+ *   `bindLaneSession`  — after the platform created the session, record the
+ *                        binding and apply the preset the lane requires.
+ *
+ * Why the lane needs `danger-full-access`
+ *   A linked worktree keeps its git directory under
+ *   `<repo>/.git/worktrees/<name>/`, i.e. OUTSIDE the session cwd (which is
+ *   the lane directory). The sandbox grants writes only to the session cwd and
+ *   its descendants, so under `workspace-write` git could not write its index,
+ *   objects or refs and no commit would be possible. Reported as a boolean,
+ *   never thrown: a lane whose preset could not be applied is still usable
+ *   once the user switches the access mode manually, and the header chip says
+ *   so.
+ * @module dsh-client-ui-worktree/host/session-lane
+ */
+
+import type { Context } from '@deepseek-ai/cordis'
+import type { SessionId } from '@deepseek-ai/dsh-session/types'
+import { isValidBranchName, WorktreeError } from '../../../../core/worktree/invariant.ts'
+import { samePath } from '../../../../core/worktree/paths.ts'
+import type {
+  BindLaneInput, BindLaneResult, CreateLaneInput, CreateLaneResult, LaneLookupInput, LaneView,
+} from '../../../../core/worktree/types.ts'
+import type { WorktreeManager } from '../manager.ts'
+
+/**
+ * The preset every lane session must run under. `danger-full-access` maps to
+ * `{sandbox: 'danger-full-access', approval: 'never'}` in
+ * `@deepseek-ai/dsh-permission-presets`.
+ */
+export const LANE_PERMISSION_PRESET = 'danger-full-access'
+
+/** Structural face over the permission-preset service (needs a live session). */
+interface PermissionPresetsFace {
+  set(session: unknown, name: string): void
+}
+
+/** Structural face over the host session store (id -> live session). */
+interface SessionsStoreFace {
+  get(id: string): unknown
+}
+
+/** Test seams; production uses the ctx services. */
+export interface SessionLaneManagerOptions {
+  /** Preset applier override (tests). */
+  setPermissionPreset?: (sessionId: string, preset: string) => void | Promise<void>
+  /** Live-session lookup override (tests). */
+  hasSession?: (sessionId: string) => boolean
+}
+
+export class SessionLaneManager {
+  private readonly ctx: Context
+  private readonly worktrees: WorktreeManager
+  private readonly options: SessionLaneManagerOptions
+  /**
+   * Captured through an optional inject, so the preset service is picked up
+   * whenever the deployment provides it and never blocks this plugin's mount
+   * when it does not.
+   */
+  private presets: PermissionPresetsFace | undefined
+
+  constructor(ctx: Context, worktrees: WorktreeManager, options: SessionLaneManagerOptions = {}) {
+    this.ctx = ctx
+    this.worktrees = worktrees
+    this.options = options
+    this.presets = ctx.get('permissionPresets') as PermissionPresetsFace | undefined
+    ctx.inject(['permissionPresets'], (child) => {
+      this.presets = child.get('permissionPresets') as PermissionPresetsFace | undefined
+      child.effect(() => () => { this.presets = undefined })
+    })
+  }
+
+  /** Phase 1: ensure the worktree behind the branch exists (no workspace). */
+  async createLane(input: CreateLaneInput): Promise<CreateLaneResult> {
+    return await this.worktrees.ensureLane(input)
+  }
+
+  /**
+   * Phase 2: bind the platform-created session to its lane and apply the preset.
+   *
+   * Fail closed, in this order: every check that can reject the request runs
+   * BEFORE the session is elevated, and the request has to name the directory
+   * the conversation actually runs in. Without that, this route could record —
+   * and hand `danger-full-access` to — a conversation living somewhere else,
+   * and a later teardown would archive a session that never used the lane.
+   * Both halves were reproduced before this check existed: a bind resolved for a
+   * session whose cwd was a different directory, and the elevation happened on
+   * the way to a manifest write that then failed.
+   *
+   * The preset outcome is recorded with the binding, so a lane whose preset
+   * failed still resolves for the header chip.
+   */
+  async bindLaneSession(input: BindLaneInput): Promise<BindLaneResult> {
+    if (!this.hasSession(input.sessionId)) {
+      throw new WorktreeError(
+        'session-unknown',
+        `session ${input.sessionId} is not live on the host, so it cannot be bound to a lane`,
+        { sessionId: input.sessionId },
+      )
+    }
+    if (!isValidBranchName(input.branch)) {
+      throw new WorktreeError(
+        'invalid-branch',
+        `branch ${JSON.stringify(input.branch)} is not a valid git ref`,
+        { branch: input.branch },
+      )
+    }
+    // Only a lane the host actually records may be bound; `laneForPath`
+    // synthesizes a view for a directory the manifest does not know about.
+    const recorded = await this.worktrees.laneEntry(input.repoPath, input.branch)
+    if (recorded === null) {
+      throw new WorktreeError(
+        'worktree-not-found',
+        `no manifest entry records the lane ${JSON.stringify(input.branch)}`,
+        { branch: input.branch },
+      )
+    }
+    // The conversation has to be in that directory already: the bind is a
+    // record of where it runs, never a way to move it.
+    const lane = await this.worktrees.laneForPath({ sessionId: input.sessionId })
+    if (lane === null || !samePath(lane.path, recorded.path)) {
+      throw new WorktreeError(
+        'lane-mismatch',
+        `session ${input.sessionId} runs in ${lane === null ? 'no lane' : lane.path}, not ${recorded.path}`,
+        { sessionId: input.sessionId, branch: input.branch, expected: recorded.path, actual: lane?.path ?? null },
+      )
+    }
+    const permissionPresetApplied = await this.applyPreset(input.sessionId)
+    await this.worktrees.bindSession(
+      input.repoPath,
+      input.branch,
+      input.sessionId as SessionId,
+      permissionPresetApplied,
+    )
+    return { lane, permissionPresetApplied }
+  }
+
+  /** Resolve the lane a path or session belongs to (delegates to the git layer). */
+  async laneForPath(input: LaneLookupInput): Promise<LaneView | null> {
+    return this.worktrees.laneForPath(input)
+  }
+
+  /**
+   * Undo a lane whose session never came up (the platform's create failed, or
+   * the user cancelled before it landed). Removes the worktree directory, the
+   * local branch, the git admin records, the manifest entry and the registered
+   * workspace, so a failed start leaves no stray lane behind.
+   */
+  async rollbackLane(input: { repoPath: string; branch: string }): Promise<void> {
+    await this.worktrees.rollbackCreate({ repoPath: input.repoPath, name: input.branch })
+  }
+
+  /** Whether the host can see that session. */
+  private hasSession(sessionId: string): boolean {
+    if (this.options.hasSession !== undefined) return this.options.hasSession(sessionId)
+    const store = this.ctx.get('sessions') as SessionsStoreFace | undefined
+    return store?.get?.(sessionId) !== undefined
+  }
+
+  /** Apply the lane preset; a failure is reported, not thrown. */
+  private async applyPreset(sessionId: string): Promise<boolean> {
+    if (this.options.setPermissionPreset !== undefined) {
+      try {
+        await this.options.setPermissionPreset(sessionId, LANE_PERMISSION_PRESET)
+        return true
+      } catch (error) {
+        this.warnPreset(error)
+        return false
+      }
+    }
+    const presets = this.presets
+    if (presets === undefined) {
+      this.warnPreset(new Error('the permissionPresets service is unavailable in this deployment'))
+      return false
+    }
+    const store = this.ctx.get('sessions') as SessionsStoreFace | undefined
+    const session = store?.get?.(sessionId)
+    if (session === undefined) {
+      this.warnPreset(new Error(`session ${sessionId} is not in the session store`))
+      return false
+    }
+    try {
+      presets.set(session, LANE_PERMISSION_PRESET)
+      return true
+    } catch (error) {
+      this.warnPreset(error)
+      return false
+    }
+  }
+
+  private warnPreset(error: unknown): void {
+    console.warn(
+      `[dsh-worktree] could not apply the "${LANE_PERMISSION_PRESET}" preset; `
+      + 'the lane session will need its access mode switched manually before it can commit:',
+      error,
+    )
+  }
+}

package/src/host/services/worktree/workspace-model-routes.ts

@@ -0,0 +1,156 @@
+/**
+ * HTTP route layer for the workspace-model manager. Mirrors the worktree
+ * route discipline:
+ *   1. JSON envelope + status code translation
+ *   2. Shared host access fence (`accessTrustOf`) for every endpoint
+ *   3. Surfacing errors under the stable `WorkspaceModelResponse` contract
+ *
+ * Route list:
+ *   - GET  /workspace-model/list   — read; always allowed from the browser
+ *   - POST /workspace-model/get     — read one path (body `{ path }`)
+ *   - POST /workspace-model/set     — mutation; shared fence
+ *   - POST /workspace-model/clear   — mutation; shared fence
+ * @module dsh-client-ui-worktree/host/workspace-model-routes
+ */
+
+import type { ServerResponse } from 'node:http'
+import type { Context } from '@deepseek-ai/cordis'
+import type {} from '@deepseek-ai/dsh-host-webserver'
+import type {
+  SetWorkspaceModelInput, WorkspaceModelResponse, WorkspaceModelPreset, WorkspaceModelView,
+} from '../../../core/worktree/workspace-model.ts'
+import type { WorkspaceModelManager } from './workspace-model.ts'
+import { readJsonObject, writeJson } from './http.ts'
+import { accessTrustOf } from '../access-trust/index.ts'
+import { registerResources, type OwnResource } from '../resources.ts'
+
+/** Per-route URL prefix. */
+export const WORKSPACE_MODEL_PREFIX = '/workspace-model'
+
+const BAD_REQUEST: WorkspaceModelResponse<never> = { ok: false, code: 'bad-request', message: 'malformed request' }
+const FORBIDDEN: WorkspaceModelResponse<never> = { ok: false, code: 'forbidden', message: 'mutation endpoints require the host access fence' }
+const READ_FORBIDDEN: WorkspaceModelResponse<never> = { ok: false, code: 'forbidden', message: 'reads require the host access fence' }
+
+/** Pull a required string field, or null when absent/empty. */
+function stringField(body: Record<string, unknown> | null, name: string): string | null {
+  if (body === null) return null
+  const value = body[name]
+  return typeof value === 'string' && value !== '' ? value : null
+}
+
+/** CORS preflight short-circuit for the mutation routes. */
+function handleOptions(res: ServerResponse): void {
+  res.writeHead(204, {
+    'access-control-allow-methods': 'POST, OPTIONS',
+    'access-control-allow-headers': 'content-type',
+    'access-control-max-age': '600',
+  })
+  res.end()
+}
+
+/**
+ * True when the request may mutate: the shared host access fence (loopback, or
+ * a deployment trusted authority with an authenticated browser session).
+ * `isTrusted` already carries the whole rule, so there is no second allow path.
+ */
+
+/** Wrap a handler that already bounds its own errors. */
+function respond<T>(res: ServerResponse, value: WorkspaceModelResponse<T>): void {
+  writeJson(res, value.ok ? 200 : value.code === 'forbidden' ? 403 : 400, value)
+}
+
+/** Register all /workspace-model/* routes. Returns the dispose function. */
+export function registerWorkspaceModelRoutes(ctx: Context, manager: WorkspaceModelManager): () => void {
+  return registerResources(own => registerOwnedWorkspaceModelRoutes(ctx, manager, own))
+}
+
+function registerOwnedWorkspaceModelRoutes(ctx: Context, manager: WorkspaceModelManager, own: OwnResource<() => void>): void {
+  const isTrusted = accessTrustOf(ctx).isTrusted
+  const canMutate = isTrusted
+
+  // GET /workspace-model/list
+  own(ctx.webServer.register({
+    kind: 'exact',
+    path: `${WORKSPACE_MODEL_PREFIX}/list`,
+    handler: async (req, res) => {
+      if (req.method !== 'GET') { writeJson(res, 405, BAD_REQUEST); return }
+      if (!isTrusted(req)) { respond<never>(res, READ_FORBIDDEN); return }
+      const list = manager.list()
+      const views: WorkspaceModelView[] = Object.entries(list).map(([path, preset]) => ({ path, preset }))
+      writeJson(res, 200, { ok: true, value: views })
+    },
+  }))
+
+  // POST /workspace-model/get
+  own(ctx.webServer.register({
+    kind: 'exact',
+    path: `${WORKSPACE_MODEL_PREFIX}/get`,
+    handler: async (req, res) => {
+      if (req.method === 'OPTIONS') { handleOptions(res); return }
+      if (req.method !== 'POST') { writeJson(res, 405, BAD_REQUEST); return }
+      if (!isTrusted(req)) { respond<never>(res, READ_FORBIDDEN); return }
+      let body: Record<string, unknown> | null
+      try { body = await readJsonObject(req) } catch { writeJson(res, 400, BAD_REQUEST); return }
+      const path = stringField(body, 'path')
+      if (path === null) { writeJson(res, 400, BAD_REQUEST); return }
+      respond<WorkspaceModelView>(res, { ok: true, value: { path, preset: manager.get(path) } })
+    },
+  }))
+
+  // POST /workspace-model/set
+  own(ctx.webServer.register({
+    kind: 'exact',
+    path: `${WORKSPACE_MODEL_PREFIX}/set`,
+    handler: async (req, res) => {
+      if (req.method === 'OPTIONS') { handleOptions(res); return }
+      if (req.method !== 'POST') { writeJson(res, 405, BAD_REQUEST); return }
+      if (!canMutate(req)) { writeJson(res, 403, FORBIDDEN); return }
+      let body: Record<string, unknown> | null
+      try { body = await readJsonObject(req) } catch { writeJson(res, 400, BAD_REQUEST); return }
+      const path = stringField(body, 'path')
+      const preset = body?.preset
+      if (path === null || typeof preset !== 'object' || preset === null || Array.isArray(preset)) {
+        writeJson(res, 400, BAD_REQUEST); return
+      }
+      const p = preset as Partial<WorkspaceModelPreset>
+      if (typeof p.provider !== 'string' || p.provider === '' || typeof p.model !== 'string' || p.model === '') {
+        writeJson(res, 400, BAD_REQUEST); return
+      }
+      if (p.reasoningEffort !== undefined && typeof p.reasoningEffort !== 'string') {
+        writeJson(res, 400, BAD_REQUEST); return
+      }
+      const input: SetWorkspaceModelInput = {
+        path,
+        preset: { provider: p.provider, model: p.model, ...(p.reasoningEffort !== undefined ? { reasoningEffort: p.reasoningEffort } : {}) },
+      }
+      try {
+        const stored = await manager.set(input.path, input.preset)
+        respond<WorkspaceModelPreset>(res, { ok: true, value: stored })
+      } catch (error) {
+        writeJson(res, 500, { ok: false, code: 'bad-request', message: error instanceof Error ? error.message : String(error) })
+      }
+    },
+  }))
+
+  // POST /workspace-model/clear
+  own(ctx.webServer.register({
+    kind: 'exact',
+    path: `${WORKSPACE_MODEL_PREFIX}/clear`,
+    handler: async (req, res) => {
+      if (req.method === 'OPTIONS') { handleOptions(res); return }
+      if (req.method !== 'POST') { writeJson(res, 405, BAD_REQUEST); return }
+      if (!canMutate(req)) { writeJson(res, 403, FORBIDDEN); return }
+      let body: Record<string, unknown> | null
+      try { body = await readJsonObject(req) } catch { writeJson(res, 400, BAD_REQUEST); return }
+      const path = stringField(body, 'path')
+      if (path === null) { writeJson(res, 400, BAD_REQUEST); return }
+      try {
+        const removed = await manager.clear(path)
+        respond<boolean>(res, { ok: true, value: removed })
+      } catch (error) {
+        writeJson(res, 500, { ok: false, code: 'bad-request', message: error instanceof Error ? error.message : String(error) })
+      }
+    },
+  }))
+
+}

package/src/host/services/worktree/workspace-model.ts

@@ -0,0 +1,132 @@
+/**
+ * Host workspace-model manager: owns the workspace-granularity model preset
+ * document. Presets are stored in a plugin-own settings namespace
+ * (`workspace-model`) as a `{ [canonicalPath]: { provider, model, effort? } }`
+ * map, so a single user-editable document is the source of truth across
+ * machines and reloads.
+ *
+ * The settings service is optional: when no settings provider is mounted the
+ * manager degrades to an in-memory-only store (model presets still apply for
+ * the process lifetime, just not durable) rather than failing to mount.
+ * @module dsh-client-ui-worktree/host/workspace-model
+ */
+
+import { realpathSync } from 'node:fs'
+import type { Context } from '@deepseek-ai/cordis'
+import { familyNamespace, registerFamilyNamespace, updateFamilyNamespace } from '../family-config.ts'
+import type { SettingsNamespace } from '@deepseek-ai/dsh-settings'
+import z from 'schemastery'
+import type {
+  WorkspaceModelPreset, WorkspacePresetMap,
+} from '../../../core/worktree/workspace-model.ts'
+
+/** Settings namespace unique to this plugin. */
+export const WORKSPACE_MODEL_NS = 'workspace-model'
+
+/** Schemastery schema for the preset document (a path -> preset map). */
+export const WorkspacePresetSchema = z.dict(z.object({
+  provider: z.string().required(),
+  model: z.string().required(),
+  reasoningEffort: z.string(),
+})).default({}) as unknown as z<WorkspacePresetMap>
+
+/** Face over the settings service the manager talks to (settings optional). */
+interface SettingsFace {
+  get(): WorkspacePresetMap
+  replace(section: WorkspacePresetMap): Promise<void>
+}
+
+/** Canonicalize a workspace path for use as a document key. Follows symlinks
+ *  via realpath and strips a trailing separator, matching how the workspace
+ *  registry records paths and how sessions record `cwd`. The root path `/`
+ *  is preserved (and is the only case where stripping the trailing separator
+ *  is a no-op, because paths must be non-empty when used as a key). */
+export function canonicalWorkspacePath(path: string): string {
+  if (typeof path !== 'string' || path.length === 0) return path
+  let canonical: string
+  try {
+    canonical = realpathSync(path)
+  } catch {
+    canonical = path.replace(/\\/g, '/')
+  }
+  // Strip trailing separator(s) but preserve the root.
+  const stripped = canonical.replace(/[\\/]+$/, '')
+  return stripped === '' ? canonical : stripped
+}
+
+registerFamilyNamespace(WORKSPACE_MODEL_NS, WorkspacePresetSchema)
+
+/** Public surface used by `routes.ts` and the agent wiring. */
+export class WorkspaceModelManager {
+  private settings: SettingsFace | null = null
+  private memory = new Map<string, WorkspaceModelPreset>()
+  private settingsFiber: { dispose(): void | Promise<void> } | undefined
+
+  dispose(): void {
+    this.settings = null
+    void this.settingsFiber?.dispose()
+    this.settingsFiber = undefined
+  }
+
+  /** Optional settings service; safe to call with an unmounted provider. */
+  constructor(private readonly ctx: Context) {
+    this.installSettings()
+  }
+
+  /** Wire the workspace-model namespace to the 0.2 settings document. */
+  private installSettings(): void {
+    this.settingsFiber = this.ctx.inject(['settings'], (sctx) => {
+      const ns = WORKSPACE_MODEL_NS
+      this.settings = {
+        get: () => (familyNamespace<WorkspacePresetMap>(ns) ?? {}),
+        replace: async (section) => {
+          await updateFamilyNamespace(sctx, ns, section as unknown as Record<string, unknown>)
+        },
+      }
+      this.seedMemory(this.settings.get())
+    })
+  }
+
+  /** Replace the in-memory mirror from a resolved document. */
+  private seedMemory(map: WorkspacePresetMap): void {
+    this.memory = new Map(Object.entries(map ?? {}))
+  }
+
+  /** All stored presets keyed by canonical path (read snapshot). */
+  list(): Record<string, WorkspaceModelPreset> {
+    return Object.fromEntries(this.memory)
+  }
+
+  /** The preset for one workspace path, or undefined when none. */
+  get(path: string): WorkspaceModelPreset | undefined {
+    return this.memory.get(canonicalWorkspacePath(path))
+  }
+
+  /** Store a preset for one workspace path. Returns the stored preset. */
+  async set(path: string, preset: WorkspaceModelPreset): Promise<WorkspaceModelPreset> {
+    const key = canonicalWorkspacePath(path)
+    if (this.settings !== null) {
+      const next = { ...this.settings.get(), [key]: { ...preset } }
+      await this.settings.replace(next)
+      this.seedMemory(next)
+    } else {
+      this.memory.set(key, { ...preset })
+    }
+    return { ...preset }
+  }
+
+  /** Remove a workspace's preset if present. Returns true when removed. */
+  async clear(path: string): Promise<boolean> {
+    const key = canonicalWorkspacePath(path)
+    const existed = this.memory.has(key)
+    if (this.settings !== null) {
+      const next = { ...this.settings.get() }
+      delete next[key]
+      await this.settings.replace(next)
+      this.seedMemory(next)
+    } else {
+      this.memory.delete(key)
+    }
+    return existed
+  }
+}

package/src/index.ts

@@ -0,0 +1,84 @@
+/**
+ * dsh-web-all — host half.
+ *
+ * dsh-cove 的唯一运行时实体。host 半区按服务域组织（src/host/services/*），
+ * 每个服务域导出一个 register(ctx) 注册函数，由本文件统一装配；
+ * cordis.patch.yml 只有一行 `web-all`。
+ *
+ * 服务域不按能力对外暴露插件边界：路由前缀（/api/dsh-ssh 等）、agent 工具名
+ * （ssh_exec 等）、settings namespace（dsh-ssh 等）保持不变，仅注册入口收敛。
+ */
+import type { Context } from '@deepseek-ai/cordis'
+import { assembleServices } from './host/services/index.ts'
+import { bindFamilyConfig, createFamilyConfig, notifyFamilyConfigChange } from './host/services/family-config.ts'
+
+/** Stable cordis plugin name (matches cordis.patch.yml insert id). */
+export const name = 'web-all'
+
+/**
+ * Services the host half needs before any service domain can mount.
+ * 每个服务域会声明自己的额外依赖；装配器把 ctx 完整交给它们。
+ */
+export const inject = [
+  'webServer',
+  'tools',
+  'systemPrompt',
+  'settings',
+  'sessions',
+  'sessionController',
+  'workspaceController',
+  'workspaceRegistry',
+  'connection',
+  'subprocess',
+  'fs',
+  'agentPresets',
+  'commands',
+  'agents',
+] as const
+
+/**
+ * 插件 config 类型面（运行时的权威 schema 是下面导出的 `Config`）。
+ * 命名空间键（doctor / remote-web-ui / dsh-ssh / …）即各能力域的设置命名空间。
+ */
+export interface Config extends Record<string, unknown> {
+  /** 用户 dsh 配置根（默认 $DSH_HOME 或 ~/.dsh）。 */
+  dshHome?: string
+  /** 用户 agents 配置根（默认 $DSH_AGENTS_HOME 或 ~/.agents）。 */
+  agentsHome?: string
+  /** Worktree PR credential reference. */
+  worktree?: import('./host/services/worktree/index.ts').WorktreeServiceConfig
+  /** Playwright sessions service options (profile overridable; `liveView` enables the agent-browser live view). */
+  playwright?: import('./core/playwright-sessions/contracts.ts').PlaywrightSessionsConfig
+  /** 跳过 BrowserAuth token/cookie 检查；仅可信反向代理或局域网显式启用。 */
+  noBrowserAuth?: boolean
+}
+
+/**
+ * 运行时 Config（0.2 原生设置模型的入口）：聚合条目 = 装配参数 + 每个能力域的
+ * 设置命名空间（volatile）。导出后该条目才会出现在原生设置文档里，家族设置
+ * 才能被读写而不必重挂插件。构建时机必须在装配器 import 求值之后——见
+ * `createFamilyConfig` 的注释。
+ */
+export const Config = createFamilyConfig()
+
+/**
+ * Application entry：装配全部 host 服务域。
+ * @param ctx - host plugin context。
+ */
+export function apply(ctx: Context, config?: Config): void {
+  // 绑定 loader 解析后的聚合 config：volatile 节点是引用，设置变更会原地热更新。
+  bindFamilyConfig(config)
+  // 设置变更扇出：注册时读一次的服务域据此重新 sync（无需重挂插件）。
+  ctx.effect(() => {
+    const off = (ctx as unknown as { on?: (event: string, listener: () => void) => (() => void) | undefined }).on?.('loader/volatile-update', () => { notifyFamilyConfigChange() })
+    const offSettings = (ctx as unknown as { on?: (event: string, listener: () => void) => (() => void) | undefined }).on?.('settings/document-updated', () => { notifyFamilyConfigChange() })
+    return () => { off?.(); offSettings?.() }
+  }, 'web-all: settings change fan-out')
+  ctx.effect(async () => assembleServices(ctx, {
+    dshHome: config?.dshHome,
+    agentsHome: config?.agentsHome,
+    noBrowserAuth: config?.noBrowserAuth,
+    worktree: config?.worktree,
+    playwright: config?.playwright,
+  }), 'web-all: host services')
+}

package/src/invariant.ts

@@ -0,0 +1,4 @@
+/** Invariant companion plugin (no assertions — nothing to check at runtime). */
+
+/** Provides no assertions: web-all owns no cross-package runtime invariants. */
+export function apply(): void {}