dsh-multi-folder 0.1.0 → 0.1.2

package/README.md

@@ -13,33 +13,28 @@ A [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) plugin bun
 - Under **Workspace Write** mode the agent gains the **same read / write / edit / execute permissions** on the configured secondary directories as on the primary workspace — enforced by re-rooting the session's own sandbox policy, so every mode keeps its semantics (`read-only` still denies, `workspace-write` allows, `danger-full-access` allows).
 - The directory list is **injected into the system prompt** and re-rendered per session assembly.
 - Configuration changes notify the agent through a **non-interrupting message queue** — delivered at the next message boundary (user send or tool-call end), and **only when the directory set actually changed**.
+- Configurable **before the session starts**: the session-creation page (new-session screen) offers a Multi-folder entry (「多工作目录」 in the Chinese UI) that reads and edits the same per-workspace configuration through a **sessionless remote API** (`multiFolder/*` endpoints) — no session id required.
+- **Localized UI.** The button, panel, and creation-page entries follow the DSH locale (the browser language or the Language setting in Settings): "Multi-folder" in English, 「多工作目录」 in Chinese.
 - **No new tools.** Everything is a framework-level change (tool-pipeline interception) plus a UI-level change (a session-scoped header entry).
 
 ## Requirements
 
 - Node.js >= 20
-- A DSH profile composed from `@deepseek-ai/dsh-base` + `@deepseek-ai/dsh-web-app` (or an equivalent composition that provides `fs`, `sandboxPolicy`, `systemPrompt`, `commands`, `shell`, `shellEnv`, and the standard web client modules).
+- A DSH profile composed from `@deepseek-ai/dsh-base` + `@deepseek-ai/dsh-web-app`
 
 ## Install
 
 Link this repository into a DSH profile:
 
 ```bash
-dsh plugin --profile web add link:<path-to-this-repo>
-```
-
-or install from npm and add `dsh-multi-folder` to the profile's `dsh.profile.bundles`:
-
-```bash
-cd <dsh-home>/profiles/web
-pnpm add dsh-multi-folder
+dsh plugin --profile web add dsh-multi-folder
 ```
 
 Then **restart the DSH backend** (host composition loads at process start) and **refresh the browser page** (the client bundle is served `no-cache`).
 
 ## Usage
 
-A **「多工作目录 / Multi-folder」** button appears in the session header. The panel lets you:
+A Multi-folder button (「多工作目录」 in the Chinese UI) appears in the session header, and a second entry appears on the **session-creation page** (fixed launcher in the bottom-right corner while the new-session screen is shown; an inline chip beside the workspace picker once the upstream `conversation.hero.workspaceExtras` slot is available). The panel lets you:
 
 | Action | Behavior |
 | ------ | -------- |
@@ -65,15 +60,16 @@ The agent needs nothing extra: `read` / `glob` / `grep` work everywhere, and `wr
 - **Prompt injection** — one ordered `systemPrompt` section with a text provider evaluated per assembly, rendering only for sessions whose workspace has configured directories.
 - **Notifications** — a pending notice armed by the command handler (only on actual change) is consumed at the next boundary by either the `agent/pre-step` waterfall (prepend into the entering message batch) or the `tools/post-execute` waterfall (attach as `additionalContexts`), whichever fires first — the framework's native plugin-sourced `notice` context.
 - **Configuration & security boundary** — per-workspace config lives in a host-owned store outside every agent sandbox root (`<DSH_HOME>/storages/multi-folder/<workspace-key>.json`). Direct `write`/`edit` attempts against the config file are rejected with an explicit message — **the agent can never self-grant directories; configuration is user-managed by design**. See [SECURITY.md](SECURITY.md).
-- **Client** — a hand-maintained factory bundle (`window.__ModuleLoader__.load`), no build toolchain required. The panel drives the host through the Remote BFF (`ctx.remote.commands.execute`).
+- **Sessionless remote API** — a `multiFolder` namespace registered through `ctx.typert.register` (hand-written `src-json` descriptors) plus a plain-object service provided as `multiFolder`. Its `list`/`add`/`remove`/`set` methods are keyed by workspace **path** and share one validated core with the `/multi-folder` command, so the creation page can configure directories before any session exists.
+- **Client** — a hand-maintained factory bundle (`window.__ModuleLoader__.load`), no build toolchain required. The panel drives the host through two channels: the Remote BFF (`ctx.remote.commands.execute`) for sessions, and the shared `/api` RPC channel (`ctx.connection.rpc.call`) for the sessionless endpoints.
 
 ## Project layout
 
 | Path | Purpose |
 | ---- | ------- |
 | `cordis.patch.yml` | Profile patch layer inserting the `dsh-multi-folder` row |
-| `lib/index.js` | Host plugin: config store, tool-pipeline interception, prompt injection, dual-channel notifications, `/multi-folder` command |
-| `lib/client.js` | Client plugin (factory bundle): session-header button + overlay panel |
+| `lib/index.js` | Host plugin: config store, tool-pipeline interception, prompt injection, dual-channel notifications, `/multi-folder` command, sessionless `multiFolder/*` remote API |
+| `lib/client.js` | Client plugin (factory bundle): session-header button + overlay panel + session-creation page entry (hero launcher / upstream hero chip) |
 | `test/` | Runtime-free behavior tests (see Development) |
 | `docs/` | Design and analysis documents |
 
@@ -82,7 +78,7 @@ The agent needs nothing extra: `read` / `glob` / `grep` work everywhere, and `wr
 No build step: the host half is plain ESM and `lib/client.js` is a hand-maintained factory bundle in the DSH client-modules format. Tests run with Node directly:
 
 ```bash
-node test/smoke-host.mjs    # host apply smoke test
+node test/smoke-host.mjs    # host apply smoke test + remote API behavior
 node test/intercept.mjs     # interception / command / notification behavior
 node test/smoke-client.mjs  # client bundle + panel flows (React shim)
 ```
@@ -92,7 +88,7 @@ Before modifying `lib/client.js`, see [docs/design.md](docs/design.md) for the b
 ## Documentation
 
 - [docs/design.md](docs/design.md) — architecture and security model
-- 中文说明：[README.zh.md](README.zh.md)
+- [docs/upstream-hero-slot.md](docs/upstream-hero-slot.md) — the upstream `conversation.hero.workspaceExtras` slot change (B1) and its plugin-side consumption
 
 ## Contributing
 

package/README.zh.md

@@ -13,33 +13,28 @@
 - 在 **Workspace Write** 模式下，Agent 对配置的副工作目录拥有与主工作目录**同等的读取、写入、编辑与命令执行权限**——实现方式是重定向会话自身的沙箱策略根，因此每种模式语义都自然保持（`read-only` 依旧拒绝、`workspace-write` 放行、`danger-full-access` 放行）；
 - 目录列表**注入系统提示词**，每次组装按会话求值；
 - 配置变更通过**不打断的消息队列**通知 Agent——在下一次消息边界（用户发送或工具调用结束）送达，且**仅在目录集合实际变化时**发送；
+- **会话开始前即可配置**：会话创建页（新会话界面）提供「多工作目录」入口（英文界面显示 "Multi-folder"），通过**无会话远程 API**（`multiFolder/*` 端点）读写同一份 per-workspace 配置——无需 session id；
+- **界面本地化**：按钮、面板与创建页入口跟随 DSH 的语言设置（浏览器语言或设置中的 Language 选项）：英文界面显示 "Multi-folder"，中文界面显示「多工作目录」。
 - **不新增任何工具**：改动全部位于框架级（工具流水线拦截）与 UI 级（会话级头部入口）。
 
 ## 环境要求
 
 - Node.js >= 20
-- 由 `@deepseek-ai/dsh-base` + `@deepseek-ai/dsh-web-app` 组成的 DSH profile（或提供 `fs`、`sandboxPolicy`、`systemPrompt`、`commands`、`shell`、`shellEnv` 及标准 Web 客户端模块的等价组合）。
+- 由 `@deepseek-ai/dsh-base` + `@deepseek-ai/dsh-web-app` 组成的 DSH profile
 
 ## 安装
 
 将本仓库链接进 DSH profile：
 
 ```bash
-dsh plugin --profile web add link:<本仓库路径>
-```
-
-或从 npm 安装并把 `dsh-multi-folder` 加入 profile 的 `dsh.profile.bundles`：
-
-```bash
-cd <dsh-home>/profiles/web
-pnpm add dsh-multi-folder
+dsh plugin --profile web add dsh-multi-folder
 ```
 
 然后**重启 DSH 后端**（宿主组合在进程启动时装载）并**刷新浏览器页面**（客户端 bundle 以 `no-cache` 提供）。
 
 ## 使用
 
-会话头部出现「多工作目录」按钮，打开面板即可：
+会话头部出现「多工作目录」按钮（英文界面显示 "Multi-folder"）；**会话创建页**也有入口（新会话界面右下角的浮动按钮；当上游 DSH 声明 `conversation.hero.workspaceExtras` 插槽后，还会在工作区选择器旁显示内联 chip）。打开面板即可：
 
 | 操作 | 行为 |
 | ---- | ---- |
@@ -65,15 +60,16 @@ Agent 无需任何额外操作：`read` / `glob` / `grep` 随处可用；`write`
 - **提示词注入**——一个有序 `systemPrompt` 段落，text provider 每次组装按会话求值，仅为配置了副目录的会话渲染。
 - **通知**——命令处理器仅在目录集合实际变化时置位 pending notice；`agent/pre-step`（前置注入进入批次）与 `tools/post-execute`（附加为 `additionalContexts`）两个通道中先触发者消费——均使用框架原生的插件来源 `notice` 上下文。
 - **配置与安全边界**——per-workspace 配置存储于 Agent 沙箱之外的宿主自有目录（`<DSH_HOME>/storages/multi-folder/<workspace-key>.json`）。对配置文件的任何直接 `write`/`edit` 都会收到显式拒绝——**Agent 永远无法自我授予目录，配置权仅属于用户**。详见 [SECURITY.md](SECURITY.md)。
-- **客户端**——手写维护的 factory bundle（`window.__ModuleLoader__.load`），无需构建工具链；面板经 Remote BFF（`ctx.remote.commands.execute`）驱动宿主。
+- **无会话远程 API**——经 `ctx.typert.register` 注册 `multiFolder` 命名空间（手写 `src-json` 描述符），并以普通对象服务 `multiFolder` 提供；`list`/`add`/`remove`/`set` 以工作区**路径**为键，与 `/multi-folder` 命令共享同一套校验核心，因此会话尚未建立时创建页也能直接配置。
+- **客户端**——手写维护的 factory bundle（`window.__ModuleLoader__.load`），无需构建工具链；面板经两条通道驱动宿主：会话内走 Remote BFF（`ctx.remote.commands.execute`），无会话端点走共享 `/api` RPC 通道（`ctx.connection.rpc.call`）。
 
 ## 目录结构
 
 | 路径 | 作用 |
 | ---- | ---- |
 | `cordis.patch.yml` | profile patch 层，插入 `dsh-multi-folder` 行 |
-| `lib/index.js` | 宿主插件：配置存储、工具流水线拦截、提示词注入、双通道通知、`/multi-folder` 命令 |
-| `lib/client.js` | 客户端插件（factory bundle）：会话头部按钮 + 覆盖层面板 |
+| `lib/index.js` | 宿主插件：配置存储、工具流水线拦截、提示词注入、双通道通知、`/multi-folder` 命令、无会话 `multiFolder/*` 远程 API |
+| `lib/client.js` | 客户端插件（factory bundle）：会话头部按钮 + 覆盖层面板 + 会话创建页入口（hero 浮动按钮 / 上游 hero chip） |
 | `test/` | 免 DSH 运行时的行为测试（见开发） |
 | `docs/` | 设计与分析文档 |
 
@@ -82,7 +78,7 @@ Agent 无需任何额外操作：`read` / `glob` / `grep` 随处可用；`write`
 零构建步骤：宿主半边为纯 ESM，`lib/client.js` 为 DSH client-modules 格式的手写 factory bundle。测试直接用 Node 运行：
 
 ```bash
-node test/smoke-host.mjs    # 宿主 apply 冒烟
+node test/smoke-host.mjs    # 宿主 apply 冒烟 + 远程 API 行为
 node test/intercept.mjs     # 拦截 / 命令 / 通知行为
 node test/smoke-client.mjs  # 客户端 bundle 与面板流程（React shim）
 ```
@@ -92,7 +88,7 @@ node test/smoke-client.mjs  # 客户端 bundle 与面板流程（React shim）
 ## 文档
 
 - [docs/design.md](docs/design.md) — 架构与安全模型（英文）
-- English README: [README.md](README.md)
+- [docs/upstream-hero-slot.md](docs/upstream-hero-slot.md) — 上游 `conversation.hero.workspaceExtras` 插槽改动（B1）与插件的对接方式（英文）
 
 ## 参与贡献
 

package/SECURITY.md

@@ -7,8 +7,11 @@
 granted the session. The design enforces four boundaries:
 
 1. **User-only configuration.** Secondary directories can only be added or removed by
-   the user through the UI panel or the `/multi-folder` slash command. The agent has no
-   tool, command, or file path through which it can change the configuration.
+   the user, through the session-header panel, the session-creation page panel, or
+   the `/multi-folder` slash command. The two panels are backed by a sessionless
+   `multiFolder/*` remote API on the trusted browser→host RPC channel — endpoints
+   that exist only for the web UI and are never exposed as agent tools. The agent
+   has no tool, command, or file path through which it can change the configuration.
 
 2. **Host-owned configuration store.** Per-workspace configuration lives in
    `<DSH_HOME>/storages/multi-folder/<workspace-key>.json` — outside every agent

package/docs/design.md

@@ -14,8 +14,8 @@ agent informed. No new tools are added.
 
 | Half | File | Role |
 | ---- | ---- | ---- |
-| Host | `lib/index.js` | Config store, tool-pipeline interception, prompt section, notifications, `/multi-folder` command |
-| Client | `lib/client.js` | Session-header button + overlay panel; drives the host through the Remote BFF |
+| Host | `lib/index.js` | Config store, tool-pipeline interception, prompt section, notifications, `/multi-folder` command, sessionless `multiFolder/*` remote API |
+| Client | `lib/client.js` | Session-header button + overlay panel; session-creation page entry (hero launcher + upstream hero chip), both driving the host through the Remote BFF / shared RPC channel |
 
 The package declares both faces: `dsh.bundle.patch` (the host row inserted by
 `cordis.patch.yml`) and `dsh.client` (the web bundle at `exports["./client"]`).
@@ -67,10 +67,60 @@ at apply time can yield `undefined` when the provider row activates later. There
 
 - Canonical location: `<DSH_HOME>/storages/multi-folder/<workspace-key>.json`
   (`DSH_HOME` falls back to `~/.dsh`), i.e. **outside every agent sandbox root**.
-- Writes happen only from the command handler (user-initiated) with an explicit
+- Writes happen only from user-initiated flows (the `/multi-folder` command
+  handler and the `multiFolder/*` remote endpoints) with an explicit
   `workspace-write` policy rooted at the config directory.
 - A per-process cache keyed by normalized workspace path hydrates lazily (on
   `agent/created`, `agent/pre-step`, and `tools/execute`).
+- One shared **core** (`coreList` / `coreAdd` / `coreRemove` / `coreSet`)
+  implements validation, canonicalization, sanitization, cache write-through,
+  and persistence. The command channel and the remote channel both call it, so
+  the security surface stays identical on both. Core errors carry bare
+  messages; each channel adds its own `multi-folder: ` prefix.
+
+## Host: sessionless remote API
+
+The session-creation page has no session (and no `sessionId`), so the
+agent-scoped `commands/execute` remote cannot serve it. Instead the plugin
+opens its own **sessionless** endpoints on the shared `/api` RPC channel:
+
+- A **plain-object service** is registered with `ctx.provide('multiFolder', api)`.
+  The object carries the gateway-visible binding
+  `typertRemote = { service, serviceKey: 'multiFolder', namespace: 'multiFolder' }`
+  (frozen), which is exactly what the gateway's `validateBinding` expects.
+- A **hand-written Typert contribution** is registered through
+  `ctx.inject(['typert'], (t) => t.typert.register(REMOTE_CONTRIBUTION))` —
+  the sanctioned manual path documented by `dsh-typert-loader` ("Manual
+  `ctx.typert.register()` remains available for contributions that do not use
+  a `./typert` artifact"). All four descriptors use `src-json` codecs (no zod
+  schemas needed) with `invocation: { kind: 'direct' }`:
+
+  | Endpoint | Parameters (wire) | Result |
+  | -------- | ----------------- | ------ |
+  | `multiFolder/list` | `workspace` | `{ workspace, dirs, changed: false }` |
+  | `multiFolder/add` | `workspace`, `path` | `{ workspace, dirs, changed }` |
+  | `multiFolder/remove` | `workspace`, `path` | `{ workspace, dirs, changed }` |
+  | `multiFolder/set` | `workspace`, `dirs` | `{ workspace, dirs, changed }` |
+
+  The workspace argument is a **path**, not a session id; the client derives
+  it from the workspaces store (`WorkspaceView.path`). Business errors throw
+  and arrive at the browser as `{ ok: false, error: { message } }`.
+- Gateway mechanics verified against `dsh-api-gateway` + `dsh-typert-registry`:
+  `resolveDescriptor` finds the endpoint in `typert.local` (claimable on
+  `/api`), direct invocation resolves the receiver through
+  `ctx.get('multiFolder')` (global shared store), `validateBinding` reads the
+  frozen `typertRemote` property, and src-json parameters tolerate omitted
+  wire fields. Both registrations are owned by the plugin fiber, so unloading
+  the plugin withdraws them together.
+- No notice is armed on the remote channel: pre-session changes have no agent
+  to notify. The session created afterwards hydrates the cache on
+  `agent/created` and the prompt section renders the directories in the very
+  first assembly.
+- Note: `src-json` descriptors are boundary-validated only for JSON safety
+  (the gateway's `assertJsonValue`), not schema-validated. The service itself
+  must therefore treat every argument as hostile — the shared core already
+  does (type checks, absolute-path requirement, canonicalization, sanitization,
+  primary-workspace exclusion).
 
 ## Host: prompt injection and notifications
 
@@ -95,21 +145,58 @@ window.__ModuleLoader__.load({
 })
 ```
 
-- `inject: ['remote', 'remote.commands', 'slots', 'workspaces']`; the package's
+- `inject: ['remote', 'remote.commands', 'slots', 'workspaces', 'connection', 'sessions', 'locale']`; the package's
   `dsh.client.inject` lists the packages providing them
   (`@deepseek-ai/dsh-api-gateway`, `@deepseek-ai/dsh-api-remotes`,
+  `@deepseek-ai/dsh-client-connection`, `@deepseek-ai/dsh-client-locale`,
   `@deepseek-ai/dsh-client-runtime`).
-- UI registrations: `conversation.session.header.actions` (session-scoped button) and
-  `shell.overlay` (root-scoped panel). One module-level store is shared by both.
-- Host communication: `ctx.remote.commands.execute(sessionId, line)`. The return value
-  is the RPC envelope `{ ok, value }` where `value` is the `CommandExecution`; command
-  result text carries a `[MF:JSON] {…}` line the panel parses for structured state.
-- Session switch: a `React.useEffect` on `sessionId` re-points the open panel to the
-  current session, reusing the per-session cache (no command row) or refreshing.
-- Per-session caching keeps pure reads (`list`) off the conversation: the command runs
-  only on first open per session or on explicit refresh; mutations return their data
-  directly and remain visible change records (command lifecycle events are log-only
-  and never reach the model).
+- UI registrations: `conversation.session.header.actions` (session-scoped button),
+  `shell.overlay` panel, `shell.overlay` hero launcher (root-scoped, fixed
+  position), and `conversation.hero.workspaceExtras` (upstream slot; see
+  below). One module-level store is shared by all of them.
+- **Localization (zh / en).** All client copy goes through
+  `@deepseek-ai/dsh-client-locale` (always composed by the standard web
+  profile). The bundle registers a `multi-folder` dictionary namespace with
+  `ctx.effect(() => locale.register(NS, { zh, en }))` — the locale service
+  enforces bilingual balance, and the effect ties the dictionaries to the
+  plugin fiber. Every slot registration declares `locale: 'multi-folder'`,
+  so the renderer synthesizes the `t` seat on component props and
+  re-renders mounted outlets on locale switch; list-entry `label`s are
+  thunks (`() => t('label')`) that `resolveSlotLabel` re-evaluates per read,
+  so registration-time text follows the active locale without
+  re-registering. The active locale is the browser language or the user's
+  Language preference in Settings; the English UI reads "Multi-folder", the
+  Chinese UI keeps 「多工作目录」.
+- Host communication, two channels:
+  - session mode: `ctx.remote.commands.execute(sessionId, line)`. The return
+    value is the RPC envelope `{ ok, value }` where `value` is the
+    `CommandExecution`; command result text carries a `[MF:JSON] {…}` line the
+    panel parses for structured state.
+  - workspace mode (session-creation page): `ctx.connection.rpc.call('/api',
+    'multiFolder/<op>', { args })` against the sessionless remote endpoints.
+    The panel runs in either mode according to how it was opened; mutations
+    and refreshes route per mode, and both modes share the same row/error UI.
+- Session switch: a `React.useEffect` on `sessionId` re-points the open panel
+  to the current session (reusing the per-session cache) — this also folds a
+  workspace-mode panel back into session mode once the first message creates
+  the session.
+- Caching: per-session cache (`sessionCache`) keeps pure reads off the
+  conversation; per-workspace cache (`workspaceCache`) plays the same role for
+  the sessionless channel.
+- Hero (session-creation page) support:
+  - The **hero launcher** (`shell.overlay` entry, `multi-folder-hero`)
+    subscribes to `sessions.list` + `workspaces.list` and observes the
+    conversation root's `data-phase="hero"` attribute (MutationObserver on
+    `document.body`). While the hero is visible it renders a fixed-position
+    「多工作目录」 button; the workspace path is derived from the current
+    (blank) session's `WorkspaceView.path`, falling back to `SessionSummary.cwd`.
+  - Clicking it opens the panel in workspace mode; without a selected
+    workspace the panel shows the "pick a workspace first" hint.
+  - The **hero chip** registers into `conversation.hero.workspaceExtras` via
+    `slots.inject`, which waits for the declaration: with an upstream DSH
+    build that declares the slot, the chip renders inline beside the workspace
+    picker; without one, the registration is a harmless no-op and the fixed
+    launcher covers the page.
 
 ## Known limitations
 
@@ -123,11 +210,28 @@ window.__ModuleLoader__.load({
   secondary directories are passed through to the default pipeline.
 - The `/multi-folder` command lifecycle rows (`command/run`, `command/done`) are
   visible in the conversation UI by framework design; they are log-only and never
-  reach the model.
+  reach the model. Workspace-mode (session-creation page) operations avoid them
+  entirely by using the sessionless remote channel.
+- The hero launcher relies on the conversation root's `data-phase="hero"`
+  attribute and the `sessions.list`/`workspaces.list` snapshot shapes — DOM and
+  client-runtime internals rather than documented APIs. They are guarded
+  defensively (missing services or DOM degrade to "launcher hidden"), and the
+  upstream `conversation.hero.workspaceExtras` slot (see
+  [upstream-hero-slot.md](upstream-hero-slot.md)) is the long-term surface.
+- The `multiFolder/*` endpoints use hand-written `src-json` Typert descriptors
+  registered through `ctx.typert.register`. `src-json` gives JSON-safety
+  boundary checks, not schema validation; the shared core performs all
+  business validation server-side. DSH versions that change the Typert
+  registry contract would need this contribution revisited (the tests assert
+  the descriptor shape).
 
 ## Tests
 
 `test/smoke-host.mjs`, `test/intercept.mjs`, and `test/smoke-client.mjs` run without
 the DSH runtime using mock services and a React shim. They cover interception,
 canonicalization, the config guard, both notification channels, notice
-gating, command flows, and the panel's session-switch/caching behavior.
+gating, command flows, the panel's session-switch/caching behavior, the
+sessionless remote contribution shape and behavior (list/add/set/remove,
+idempotence, sanitization, error prefixing, cross-channel cache coherence),
+and the hero/workspace-mode client flows (launcher visibility, RPC routing,
+workspace-mode mutations and error surfacing).

package/docs/upstream-hero-slot.md

@@ -0,0 +1,127 @@
+# Upstream slot: `conversation.hero.workspaceExtras` (B1)
+
+The session-creation page (the hero phase of `ConversationRoot`) currently
+declares only two root-scope slots — `conversation.hero.workspace` and
+`conversation.hero.agentPreset` — and both are `single`-kind (occupying them
+replaces the built-in control). There is no additive seat for a plugin to
+place configuration UI next to the workspace picker.
+
+This document specifies the small upstream change to
+`@deepseek-ai/dsh-client-ui-conversation` that adds one, and explains how the
+plugin consumes it. Until this lands in a DSH release, the plugin's fixed
+`shell.overlay` hero launcher covers the same page (B2); the slot registration
+below is a waiting no-op (`slots.inject` fires only once the declaration
+exists), so the plugin works with and without the upstream change.
+
+## 1. Declare the slot
+
+File: `packages/client/ui-conversation/src/client/contract/slots.ts`
+
+Add to the `SlotMap` declaration merging:
+
+```ts
+        /**
+         * Additive row beside the hero workspace picker and the agent-preset
+         * chip on the new-session screen. Root scope: no session exists yet,
+         * so entries address the pending/selected workspace by its canonical
+         * path rather than by a session id.
+         */
+        'conversation.hero.workspaceExtras': {
+            kind: 'list';
+            scope: 'root';
+            owner: HeroWorkspaceExtrasOwnerProps;
+        };
+```
+
+And the owner share:
+
+```ts
+/** Owner share of the hero workspace-extras row: the canonical target path. */
+export interface HeroWorkspaceExtrasOwnerProps {
+    /**
+     * Absolute canonical path of the workspace the hero targets (the pending
+     * pick or the blank session's workspace); undefined until one is chosen.
+     */
+    workspacePath?: string | undefined;
+}
+```
+
+## 2. Render the slot in the hero row
+
+File: `packages/client/ui-conversation/src/client/skeleton/ConversationRoot.tsx`
+
+The `heroWorkspaceRow` element currently renders
+`WorkspaceChip` → `renderSlot('conversation.hero.workspace', …)` →
+`renderSlot('conversation.hero.agentPreset', {})`. Append the new seat:
+
+```tsx
+                    renderSlot('conversation.hero.workspaceExtras', {
+                        workspacePath: pendingWorkspace?.path ?? sessionWorkspace?.path,
+                    }),
+```
+
+(`pendingWorkspace` and `sessionWorkspace` are the `WorkspaceView` values the
+root already resolves; `path` is their canonical host path.)
+
+## 3. Declare the slot on the `conversation` registration
+
+In the same file, the `slots.register({ name: 'conversation', children: { … } })`
+table must gain the child declaration (declaring is claiming — the render site
+above is only authorized once it is listed):
+
+```ts
+                    'conversation.hero.workspaceExtras': {
+                        kind: 'list',
+                        scope: 'root',
+                    },
+```
+
+## 4. Plugin side (already implemented)
+
+`lib/client.js` registers into the slot the moment it is declared. The entry
+declares the plugin's `multi-folder` locale namespace, so the chip renders
+through the framework `t` seat and its `label` is a thunk that follows the
+active locale (English: "Multi-folder", Chinese: 「多工作目录」):
+
+```js
+slots.inject('conversation.hero.workspaceExtras', function () {
+  return slots.register(
+    { name: 'conversation.hero.workspaceExtras', id: 'multi-folder', order: 30, label: () => t('label'), locale: NS },
+    function (props) { return React.createElement(HeroChip, props); },
+  );
+});
+```
+
+(`NS` is the plugin's `multi-folder` namespace and `t` its bound translator —
+see the localization section of [design.md](design.md).)
+
+`HeroChip` prefers the owner-supplied `props.workspacePath` and falls back to
+the store-derived hero workspace. It opens the same overlay panel in workspace
+mode, which reads and writes the configuration through the sessionless
+`multiFolder/*` endpoints (see [design.md](design.md)).
+
+## Compiled-bundle equivalent (for local patching)
+
+The shipped `lib/client.js` of `dsh-client-ui-conversation` is a compiled
+bundle; the same change there is three touchpoints:
+
+1. `SlotMap` declaration — the `declare module` block compiles into the
+   registration data; add the `'conversation.hero.workspaceExtras': { kind:
+   'list', scope: 'root' }` child entry to the `children` table of the
+   `conversation` registration (around the existing
+   `"conversation.hero.agentPreset"` entry).
+2. The render site — inside `heroWorkspaceRow`, after
+   `renderSlot("conversation.hero.agentPreset", {})`, add
+   `renderSlot("conversation.hero.workspaceExtras", { workspacePath: (pendingWorkspace ?? sessionWorkspace)?.path })`.
+3. Rebuild the web bundle and refresh the page (bundled shell changes require
+   a rebuild; the plugin's own bundle is served no-cache).
+
+## Verification
+
+- Unit: the plugin's `test/smoke-client.mjs` registers and drives `HeroChip`
+  with a mock owner share (`workspacePath`), asserting the panel opens in
+  workspace mode and reuses the per-workspace cache.
+- Manual: with the patched build, the Multi-folder chip (「多工作目录」 in the
+  Chinese UI) renders in the hero workspace row between the preset chip and
+  the composer; clicking it lists the workspace's secondary directories
+  before any message is sent.

package/lib/client.js

@@ -1,14 +1,27 @@
 /**
  * dsh-multi-folder — client half (hand-written factory bundle, no build step).
  *
- * Session-scoped UI: a "多工作目录" button in the conversation session header
- * (`conversation.session.header.actions`, scope: session) that opens a panel in
- * `shell.overlay` listing the project's secondary working directories.
+ * Session-scoped UI: a localized "Multi-folder" (「多工作目录」) button in the
+ * conversation session header (`conversation.session.header.actions`, scope:
+ * session) that opens a panel in `shell.overlay` listing the project's
+ * secondary working directories. All copy goes through the framework locale
+ * service (`@deepseek-ai/dsh-client-locale`) — see the "i18n" section below.
  * Mutations go through the Host `/multi-folder` command via the Remote BFF
  * (`ctx.remote.commands.execute(sessionId, line)`); the Host answers with a
  * human-readable result carrying a `[MF:JSON]` line the panel parses for
  * structured state.
  *
+ * Session-creation page UI (no session exists yet):
+ * - a hero-phase launcher in `shell.overlay` (fixed-position entry) whose
+ *   visibility follows the conversation root's `data-phase="hero"` attribute;
+ * - an inline chip registered into the upstream `conversation.hero.workspaceExtras`
+ *   slot when that slot exists (the `slots.inject` wait is a no-op until the
+ *   DSH core declares it).
+ * Both open the same panel in WORKSPACE mode and drive the sessionless
+ * `multiFolder/*` endpoints over the shared RPC channel
+ * (`ctx.connection.rpc.call('/api', endpoint, { args })`), keyed by workspace
+ * path instead of sessionId.
+ *
  * Layout shape: an entry in the session header action row plus a frame-wide
  * overlay panel. Both read one tiny module-scoped store; opening the panel
  * refreshes the list from the Host.
@@ -22,7 +35,7 @@ window.__ModuleLoader__.load({
 
     // ------------------------------------------------------------- store
     var listeners = new Set();
-    var state = { open: false, sessionId: null, dirs: [], workspace: null, busy: false, error: null };
+    var state = { open: false, mode: null, sessionId: null, dirs: [], workspace: null, busy: false, error: null, hero: false, heroWorkspace: null };
     function patch(next) {
       state = Object.assign({}, state, next);
       listeners.forEach(function (fn) { fn(); });
@@ -36,6 +49,13 @@ window.__ModuleLoader__.load({
     /** sessionId -> { dirs, workspace }: avoids re-running the list command
      *  (and its conversation row) on every panel open. */
     var sessionCache = {};
+    /** workspacePathKey -> { dirs, workspace }: the workspace-mode twin of
+     *  sessionCache, keyed by the sessionless remote's workspace argument. */
+    var workspaceCache = {};
+
+    function workspacePathKey(path) {
+      return String(path).replace(/\\/g, '/').toLowerCase().replace(/\/+$/, '');
+    }
 
     function parseJsonLine(text) {
       if (typeof text !== 'string') return null;
@@ -44,14 +64,154 @@ window.__ModuleLoader__.load({
       try { return JSON.parse(m[1]); } catch (_) { return null; }
     }
 
+    // ------------------------------------------------------------- i18n
+    /** Locale namespace owned by this plugin. Dictionaries are registered
+     *  with the `locale` service (`@deepseek-ai/dsh-client-locale`, always
+     *  composed by the standard web profile), which enforces bilingual
+     *  balance: both shipped locales (zh, en) must be registered together. */
+    var NS = 'multi-folder';
+    /** Simplified Chinese dictionary — the key-set source of truth. */
+    var zhDict = {
+      'label': '多工作目录',
+      'label.open': '多工作目录 ▾',
+      'label.heroLauncher': '多工作目录（新会话）',
+      'title.header': '多工作目录（副工作目录）',
+      'title.remove': '移除此副工作目录',
+      'title.close': '关闭',
+      'title.heroLauncher.hasWorkspace': '配置此项目的副工作目录（多工作目录）',
+      'title.heroLauncher.noWorkspace': '请先选择工作区，再配置多工作目录',
+      'title.heroChip': '配置此项目的副工作目录（多工作目录）',
+      'panel.title': '多工作目录（副工作目录）',
+      'panel.project': '项目：{path}',
+      'panel.noWorkspaceHint': '尚未选择工作区。请先在上方选择项目，再配置多工作目录。',
+      'panel.empty': '尚未配置副工作目录。',
+      'panel.pickWorkspaceHint': '选择工作区后可在此添加副工作目录。',
+      'panel.add': '+ 添加目录',
+      'panel.adding': '处理中…',
+      'panel.remove': '移除',
+      'panel.refresh': '刷新',
+      'panel.footnote': 'Agent 的主工作目录不变；在 Workspace Write 模式下，Agent 对上述目录拥有与主工作目录同等的读写与命令执行权限。配置变更会在下一条消息或工具调用结束时通知 Agent。',
+    };
+    /** English dictionary — checked complete against the zh key set. */
+    var enDict = {
+      'label': 'Multi-folder',
+      'label.open': 'Multi-folder ▾',
+      'label.heroLauncher': 'Multi-folder (new session)',
+      'title.header': 'Multi-folder (secondary working directories)',
+      'title.remove': 'Remove this secondary working directory',
+      'title.close': 'Close',
+      'title.heroLauncher.hasWorkspace': 'Configure secondary working directories for this project (Multi-folder)',
+      'title.heroLauncher.noWorkspace': 'Pick a workspace first, then configure Multi-folder',
+      'title.heroChip': 'Configure secondary working directories for this project (Multi-folder)',
+      'panel.title': 'Multi-folder (secondary working directories)',
+      'panel.project': 'Workspace: {path}',
+      'panel.noWorkspaceHint': 'No workspace selected yet. Pick a project above first, then configure secondary directories.',
+      'panel.empty': 'No secondary working directories configured yet.',
+      'panel.pickWorkspaceHint': 'Pick a workspace first — secondary directories can be added here afterwards.',
+      'panel.add': '+ Add directory',
+      'panel.adding': 'Working…',
+      'panel.remove': 'Remove',
+      'panel.refresh': 'Refresh',
+      'panel.footnote': "The agent's primary working directory stays unchanged; under Workspace Write mode the agent has the same read/write and command-execution rights on the listed directories as on the primary workspace. Configuration changes are announced at the next message or tool-call boundary.",
+    };
+
     // ------------------------------------------------------------- plugin
     var name = 'dsh-multi-folder';
-    var inject = ['remote', 'remote.commands', 'slots', 'workspaces'];
+    var inject = ['remote', 'remote.commands', 'slots', 'workspaces', 'connection', 'sessions', 'locale'];
 
     function apply(ctx) {
       var slots = ctx.slots;
       var remote = ctx.remote;
       var workspaces = ctx.workspaces;
+      var connection = ctx.connection;
+      var sessions = ctx.sessions;
+      var locale = ctx.locale;
+
+      /** Register this plugin's dictionaries for every shipped locale
+       *  (bilingual balance is enforced by the locale service). The
+       *  registration is an effect on this plugin's fiber, so unloading the
+       *  plugin withdraws the dictionaries. */
+      ctx.effect(function () {
+        return locale.register(NS, { zh: zhDict, en: enDict });
+      }, 'dsh-multi-folder: client dictionaries');
+
+      /** Bound translator for slot labels: label thunks re-evaluate per read
+       *  (`resolveSlotLabel`), so registration-time text follows the active
+       *  locale without re-registering. Components themselves render through
+       *  the `t` seat the renderer synthesizes from the declared
+       *  `locale:` namespace (which also re-renders them on locale switch). */
+      var t = locale.bind(NS);
+
+      // -------------------------------------------------- sessionless RPC
+      /** Call one `multiFolder/*` endpoint over the shared /api channel.
+       *  The Host gateway answers with the same `{ ok, value }` envelope as
+       *  the command remote; business errors surface as thrown Errors. */
+      function remoteCall(endpoint, args) {
+        if (!connection || !connection.rpc || typeof connection.rpc.call !== 'function') {
+          return Promise.reject(new Error('multi-folder: the shared RPC channel (connection service) is unavailable'));
+        }
+        return connection.rpc.call('/api', endpoint, { args: args }).then(function (envelope) {
+          if (!envelope || envelope.ok !== true) {
+            var message = envelope && envelope.error !== undefined
+              ? String(envelope.error.message !== undefined ? envelope.error.message : envelope.error)
+              : 'remote call failed';
+            throw new Error('multi-folder: ' + String(message).replace(/^multi-folder:\s*/, ''));
+          }
+          return envelope.value;
+        });
+      }
+
+      function refreshWorkspace(workspacePath) {
+        if (!workspacePath) return;
+        patch({ busy: true, error: null });
+        remoteCall('multiFolder/list', { workspace: workspacePath }).then(function (value) {
+          workspaceCache[workspacePathKey(workspacePath)] = value || { workspace: workspacePath, dirs: [] };
+          var current = getSnapshot();
+          if (!current.sessionId && current.mode === 'workspace' && current.workspace && workspacePathKey(current.workspace) === workspacePathKey(workspacePath)) {
+            patch({ busy: false, workspace: value.workspace, dirs: value.dirs || [] });
+          } else {
+            patch({ busy: false });
+          }
+        }).catch(function (e) {
+          patch({ busy: false, error: String(e && e.message ? e.message : e) });
+        });
+      }
+
+      function mutateWorkspace(workspacePath, endpoint, args) {
+        if (!workspacePath) return Promise.resolve();
+        patch({ busy: true, error: null });
+        var payload = Object.assign({ workspace: workspacePath }, args);
+        return remoteCall(endpoint, payload).then(function (value) {
+          workspaceCache[workspacePathKey(workspacePath)] = value || { workspace: workspacePath, dirs: [] };
+          var current = getSnapshot();
+          if (!current.sessionId && current.mode === 'workspace' && current.workspace && workspacePathKey(current.workspace) === workspacePathKey(workspacePath)) {
+            patch({ busy: false, workspace: value.workspace, dirs: value.dirs || [] });
+          } else {
+            patch({ busy: false });
+          }
+        }).catch(function (e) {
+          patch({ busy: false, error: String(e && e.message ? e.message : e) });
+        });
+      }
+
+      /** Open the panel in WORKSPACE mode (session-creation page): a null
+       *  workspace shows the "pick a workspace first" hint instead. */
+      function openForWorkspace(workspacePath) {
+        if (!workspacePath) {
+          patch({ open: true, mode: 'workspace', sessionId: null, workspace: null, dirs: [], error: null });
+          return;
+        }
+        var cached = workspaceCache[workspacePathKey(workspacePath)];
+        patch({
+          open: true,
+          mode: 'workspace',
+          sessionId: null,
+          workspace: workspacePath,
+          dirs: cached ? cached.dirs : [],
+          error: null,
+        });
+        if (!cached) refreshWorkspace(workspacePath);
+      }
 
       function runCommand(sessionId, line) {
         return remote.commands.execute(sessionId, line).then(function (envelope) {
@@ -107,10 +267,15 @@ window.__ModuleLoader__.load({
         });
       }
 
-      function addDirectory(sessionId) {
+      function addDirectory() {
         workspaces.pickDirectory().then(function (path) {
           if (path === null || path === undefined) return;
-          mutate(sessionId, '/multi-folder add "' + path.replace(/"/g, '\\"') + '"');
+          var snapshot = getSnapshot();
+          if (snapshot.sessionId) {
+            mutate(snapshot.sessionId, '/multi-folder add "' + path.replace(/"/g, '\\"') + '"');
+          } else if (snapshot.workspace) {
+            mutateWorkspace(snapshot.workspace, 'multiFolder/add', { path: path });
+          }
         }).catch(function (e) {
           patch({ error: String(e && e.message ? e.message : e) });
         });
@@ -123,6 +288,7 @@ window.__ModuleLoader__.load({
         var cached = sessionCache[sessionId];
         patch({
           open: true,
+          mode: 'session',
           sessionId: sessionId,
           dirs: cached ? cached.dirs : [],
           workspace: cached ? cached.workspace : null,
@@ -135,6 +301,7 @@ window.__ModuleLoader__.load({
       function HeaderButton(props) {
         var store = useStore();
         var sessionId = props.sessionId;
+        var t = props.t;
         var open = store.open && store.sessionId === sessionId;
         // Session switch: keep the panel in sync with the session this
         // header belongs to. On a changed sessionId (or first mount) with
@@ -153,7 +320,7 @@ window.__ModuleLoader__.load({
           'button',
           {
             type: 'button',
-            title: '多工作目录（副工作目录）',
+            title: t('title.header'),
             onClick: function () {
               var current = getSnapshot();
               var isOpen = current.open && current.sessionId === sessionId;
@@ -176,15 +343,18 @@ window.__ModuleLoader__.load({
               cursor: 'pointer',
             },
           },
-          open ? '多工作目录 ▾' : '多工作目录',
+          open ? t('label.open') : t('label'),
         );
         return btn;
       }
 
       // Overlay panel ------------------------------------------------------
-      function Panel() {
+      function Panel(props) {
         var store = useStore();
-        if (!store.open || !store.sessionId) return null;
+        var t = props.t;
+        if (!store.open || !store.mode) return null;
+        var sessionMode = store.mode === 'session';
+        var usable = sessionMode || !!store.workspace;
         var rows = (store.dirs || []).map(function (dir, index) {
           return React.createElement(
             'div',
@@ -212,11 +382,18 @@ window.__ModuleLoader__.load({
               'button',
               {
                 type: 'button',
-                title: '移除此副工作目录',
-                onClick: function () { mutate(store.sessionId, '/multi-folder remove "' + dir.replace(/"/g, '\\"') + '"'); },
+                title: t('title.remove'),
+                disabled: !usable,
+                onClick: function () {
+                  if (sessionMode) {
+                    mutate(store.sessionId, '/multi-folder remove "' + dir.replace(/"/g, '\\"') + '"');
+                  } else if (store.workspace) {
+                    mutateWorkspace(store.workspace, 'multiFolder/remove', { path: dir });
+                  }
+                },
                 style: { padding: '2px 8px', borderRadius: 6, border: '1px solid transparent', background: 'transparent', color: 'var(--color-danger, #c62828)', cursor: 'pointer' },
               },
-              '移除',
+              t('panel.remove'),
             ),
           );
         });
@@ -242,12 +419,12 @@ window.__ModuleLoader__.load({
           React.createElement(
             'div',
             { style: { display: 'flex', alignItems: 'center', justifyContent: 'space-between', marginBottom: 10 } },
-            React.createElement('div', { style: { fontWeight: 600, fontSize: 14 } }, '多工作目录（副工作目录）'),
+            React.createElement('div', { style: { fontWeight: 600, fontSize: 14 } }, t('panel.title')),
             React.createElement(
               'button',
               {
                 type: 'button',
-                title: '关闭',
+                title: t('title.close'),
                 onClick: function () { patch({ open: false }); },
                 style: { padding: '2px 8px', borderRadius: 6, border: '1px solid transparent', background: 'transparent', cursor: 'pointer' },
               },
@@ -258,10 +435,18 @@ window.__ModuleLoader__.load({
             ? React.createElement(
                 'div',
                 { style: { marginBottom: 8, color: 'var(--color-text-muted, #6b6b6b)', fontSize: 12, wordBreak: 'break-all' } },
-                '项目：' + store.workspace,
+                t('panel.project', { path: store.workspace }),
               )
-            : null,
-          rows.length > 0 ? rows : React.createElement('div', { style: { marginBottom: 8, color: 'var(--color-text-muted, #6b6b6b)' } }, '尚未配置副工作目录。'),
+            : (!sessionMode
+                ? React.createElement(
+                    'div',
+                    { style: { marginBottom: 8, color: 'var(--color-text-muted, #6b6b6b)' } },
+                    t('panel.noWorkspaceHint'),
+                  )
+                : null),
+          usable
+            ? (rows.length > 0 ? rows : React.createElement('div', { style: { marginBottom: 8, color: 'var(--color-text-muted, #6b6b6b)' } }, t('panel.empty')))
+            : React.createElement('div', { style: { marginBottom: 8, color: 'var(--color-text-muted, #6b6b6b)' } }, t('panel.pickWorkspaceHint')),
           store.error
             ? React.createElement('div', { style: { marginBottom: 8, color: 'var(--color-danger, #c62828)', whiteSpace: 'pre-wrap' } }, String(store.error))
             : null,
@@ -272,8 +457,8 @@ window.__ModuleLoader__.load({
               'button',
               {
                 type: 'button',
-                disabled: !!store.busy,
-                onClick: function () { addDirectory(store.sessionId); },
+                disabled: !!store.busy || !usable,
+                onClick: function () { addDirectory(); },
                 style: {
                   flex: 1,
                   padding: '6px 10px',
@@ -281,29 +466,35 @@ window.__ModuleLoader__.load({
                   border: '1px solid var(--color-border, rgba(127,127,127,0.35))',
                   background: 'var(--color-bg-accent, rgba(80,120,255,0.14))',
                   color: 'var(--color-text, inherit)',
-                  cursor: store.busy ? 'default' : 'pointer',
-                  opacity: store.busy ? 0.6 : 1,
+                  cursor: store.busy || !usable ? 'default' : 'pointer',
+                  opacity: store.busy || !usable ? 0.6 : 1,
                 },
               },
-              store.busy ? '处理中…' : '+ 添加目录',
+              store.busy ? t('panel.adding') : t('panel.add'),
             ),
             React.createElement(
               'button',
               {
                 type: 'button',
-                disabled: !!store.busy,
-                onClick: function () { refresh(store.sessionId); },
+                disabled: !!store.busy || !usable,
+                onClick: function () {
+                  if (sessionMode) {
+                    refresh(store.sessionId);
+                  } else if (store.workspace) {
+                    refreshWorkspace(store.workspace);
+                  }
+                },
                 style: {
                   padding: '6px 10px',
                   borderRadius: 8,
                   border: '1px solid var(--color-border, rgba(127,127,127,0.35))',
                   background: 'transparent',
                   color: 'var(--color-text, inherit)',
-                  cursor: store.busy ? 'default' : 'pointer',
-                  opacity: store.busy ? 0.6 : 1,
+                  cursor: store.busy || !usable ? 'default' : 'pointer',
+                  opacity: store.busy || !usable ? 0.6 : 1,
                 },
               },
-              '刷新',
+              t('panel.refresh'),
             ),
           ),
           React.createElement(
@@ -316,22 +507,162 @@ window.__ModuleLoader__.load({
                 color: 'var(--color-text-muted, #6b6b6b)',
               },
             },
-            'Agent 的主工作目录不变；在 Workspace Write 模式下，Agent 对上述目录拥有与主工作目录同等的读写与命令执行权限。配置变更会在下一条消息或工具调用结束时通知 Agent。',
+            t('panel.footnote'),
           ),
         );
       }
 
+      // Hero (session-creation page) support --------------------------------
+      /** Workspace path of the current session (blank-session hero), or null
+       *  while no session/workspace is selected at all. */
+      function heroWorkspacePath() {
+        var sessionList = sessions && sessions.list ? sessions.list.getSnapshot() : null;
+        var id = sessionList && sessionList.current;
+        if (!id) return null;
+        var workspaceList = workspaces && workspaces.list ? workspaces.list.getSnapshot() : null;
+        var items = workspaceList && workspaceList.items ? workspaceList.items : [];
+        for (var i = 0; i < items.length; i++) {
+          var workspace = items[i];
+          if (workspace && workspace.path && Array.isArray(workspace.sessionIds) && workspace.sessionIds.indexOf(id) >= 0) {
+            return workspace.path;
+          }
+        }
+        var row = sessionList && sessionList.byId ? sessionList.byId[id] : undefined;
+        return row && row.cwd ? row.cwd : null;
+      }
+
+      /** Re-read the conversation root's `data-phase` attribute (authoritative
+       *  hero signal) and the derivable workspace, then patch the store. */
+      function syncHero() {
+        var phaseEl = null;
+        try {
+          if (typeof document !== 'undefined') phaseEl = document.querySelector('[data-phase]');
+        } catch (_) { /* no DOM (tests) */ }
+        var hero = !!phaseEl && phaseEl.getAttribute && phaseEl.getAttribute('data-phase') === 'hero';
+        var workspacePath = hero ? heroWorkspacePath() : null;
+        var current = getSnapshot();
+        if (current.hero !== hero || current.heroWorkspace !== workspacePath) {
+          patch({ hero: hero, heroWorkspace: workspacePath });
+        }
+      }
+
+      /** Fixed-position hero launcher (B2): visible only while the
+       *  conversation root reports the hero phase. */
+      function HeroLauncher(props) {
+        var store = useStore();
+        var t = props.t;
+        React.useEffect(
+          function () {
+            var disposers = [];
+            if (sessions && sessions.list && typeof sessions.list.subscribe === 'function') {
+              disposers.push(sessions.list.subscribe(syncHero));
+            }
+            if (workspaces && workspaces.list && typeof workspaces.list.subscribe === 'function') {
+              disposers.push(workspaces.list.subscribe(syncHero));
+            }
+            syncHero();
+            var observer = null;
+            if (typeof document !== 'undefined' && document.body && typeof MutationObserver !== 'undefined') {
+              observer = new MutationObserver(syncHero);
+              observer.observe(document.body, {
+                subtree: true,
+                childList: true,
+                attributes: true,
+                attributeFilter: ['data-phase'],
+              });
+            }
+            return function () {
+              disposers.forEach(function (dispose) { dispose(); });
+              if (observer) observer.disconnect();
+            };
+          },
+          [],
+        );
+        if (!store.hero) return null;
+        return React.createElement(
+          'button',
+          {
+            type: 'button',
+            title: store.heroWorkspace ? t('title.heroLauncher.hasWorkspace') : t('title.heroLauncher.noWorkspace'),
+            onClick: function () { openForWorkspace(store.heroWorkspace); },
+            style: {
+              position: 'fixed',
+              bottom: 24,
+              right: 24,
+              zIndex: 300,
+              display: 'inline-flex',
+              alignItems: 'center',
+              gap: 6,
+              padding: '6px 12px',
+              borderRadius: 999,
+              border: '1px solid var(--color-border, rgba(127,127,127,0.35))',
+              background: 'var(--color-bg-elevated, #ffffff)',
+              color: 'var(--color-text, inherit)',
+              fontSize: 13,
+              cursor: 'pointer',
+              boxShadow: '0 4px 16px rgba(0,0,0,0.14)',
+              opacity: store.heroWorkspace ? 1 : 0.7,
+            },
+          },
+          t('label'),
+        );
+      }
+
+      /** Inline chip for the upstream `conversation.hero.workspaceExtras`
+       *  slot (B1): rendered beside the workspace picker once the DSH core
+       *  declares the slot; a no-op registration until then. */
+      function HeroChip(props) {
+        var store = useStore();
+        var t = props.t;
+        var workspacePath = props && props.workspacePath ? props.workspacePath : store.heroWorkspace;
+        return React.createElement(
+          'button',
+          {
+            type: 'button',
+            title: t('title.heroChip'),
+            onClick: function () { openForWorkspace(workspacePath); },
+            style: {
+              display: 'inline-flex',
+              alignItems: 'center',
+              gap: 6,
+              padding: '4px 10px',
+              borderRadius: 999,
+              border: '1px solid var(--color-border, rgba(127,127,127,0.35))',
+              background: 'transparent',
+              color: 'var(--color-text, inherit)',
+              fontSize: 13,
+              cursor: 'pointer',
+            },
+          },
+          t('label'),
+        );
+      }
+
       // Registrations ------------------------------------------------------
       slots.inject('conversation.session.header.actions', function () {
         return slots.register(
-          { name: 'conversation.session.header.actions', id: 'multi-folder', order: 30, label: '多工作目录' },
+          { name: 'conversation.session.header.actions', id: 'multi-folder', order: 30, label: function () { return t('label'); }, locale: NS },
           function (props) { return React.createElement(HeaderButton, props); },
         );
       });
       slots.inject('shell.overlay', function () {
         return slots.register(
-          { name: 'shell.overlay', id: 'multi-folder', order: 100, label: '多工作目录' },
-          function () { return React.createElement(Panel); },
+          { name: 'shell.overlay', id: 'multi-folder', order: 100, label: function () { return t('label'); }, locale: NS },
+          function (props) { return React.createElement(Panel, props); },
+        );
+      });
+      slots.inject('shell.overlay', function () {
+        return slots.register(
+          { name: 'shell.overlay', id: 'multi-folder-hero', order: 200, label: function () { return t('label.heroLauncher'); }, locale: NS },
+          function (props) { return React.createElement(HeroLauncher, props); },
+        );
+      });
+      // Upstream slot (B1): the callback fires only once a DSH build declares
+      // `conversation.hero.workspaceExtras`; until then this contributes nothing.
+      slots.inject('conversation.hero.workspaceExtras', function () {
+        return slots.register(
+          { name: 'conversation.hero.workspaceExtras', id: 'multi-folder', order: 30, label: function () { return t('label'); }, locale: NS },
+          function (props) { return React.createElement(HeroChip, props); },
         );
       });
     }

package/lib/index.js

@@ -27,6 +27,14 @@
  *    plugin-sourced `notice` context channel.
  * 5. `/multi-folder` command (list/add/remove/set): the human-command
  *    registry entry the browser UI drives through the Remote BFF.
+ * 6. Sessionless remote API: a `multiFolder` namespace registered through
+ *    the Typert registry with hand-written `src-json` descriptors and a
+ *    plain-object service (`ctx.provide('multiFolder', …)`). Methods are
+ *    keyed by workspace PATH (not sessionId), so the session-creation page
+ *    — where no session exists yet — can read and edit the configuration
+ *    directly. The `/multi-folder` command and the remote methods share
+ *    one core so validation, canonicalization, and the config guard are
+ *    identical on both channels.
  */
 
 import { join } from 'node:path'
@@ -48,7 +56,7 @@ const INTERCEPT_TOOLS = new Set(['write', 'edit', 'pwsh', 'bash'])
 const JSON_MARK = '[MF:JSON]'
 const CONFIG_GUARD_TEXT =
   'This file is managed by the dsh-multi-folder plugin. Secondary working directories may only be ' +
-  'configured by the user through the UI panel or the /multi-folder command; direct edits are rejected.'
+  'configured by the user through the UI (session header or session-creation page) or the /multi-folder command; direct edits are rejected.'
 
 export function apply(ctx) {
   const { fs, sandboxPolicy, systemPrompt } = ctx
@@ -150,6 +158,139 @@ export function apply(ctx) {
     return 'Secondary working directories for ' + ws + ':\n' + dirs.map((d) => '- ' + d).join('\n')
   }
 
+  // ----------------------------------------------------- shared config core
+  // One validated, canonicalizing write-through core shared by the
+  // `/multi-folder` command and the sessionless `multiFolder/*` remote
+  // endpoints. Errors thrown here carry bare messages; each channel adds
+  // its own `multi-folder: ` prefix.
+
+  const requireWorkspace = (ws) => {
+    if (typeof ws !== 'string' || ws.length === 0) throw new Error('workspace is required')
+    return ws
+  }
+
+  const coreList = async (ws) => {
+    ws = requireWorkspace(ws)
+    const entry = await loadDirs(ws)
+    return { workspace: ws, dirs: [...entry.dirs], changed: false }
+  }
+
+  const coreAdd = async (ws, path) => {
+    ws = requireWorkspace(ws)
+    if (typeof path !== 'string' || path.length === 0) throw new Error('add requires a path')
+    if (!isAbsolute(path)) throw new Error('add requires an absolute path')
+    const canonical = await canonicalizeAbs(path)
+    if (canonical === null) throw new Error('cannot resolve path "' + path + '"')
+    const entry = await loadDirs(ws)
+    const next = sanitizeDirs([...entry.dirs, canonical], ws)
+    const changed = next.length !== entry.dirs.length
+    entry.dirs = next
+    if (changed) await saveDirs(ws, next)
+    return { workspace: ws, dirs: [...next], changed }
+  }
+
+  const coreRemove = async (ws, path) => {
+    ws = requireWorkspace(ws)
+    if (typeof path !== 'string' || path.length === 0) throw new Error('remove requires a path')
+    const canonical = await canonicalizeAbs(path)
+    const key = wsKey(canonical === null ? path : canonical)
+    const entry = await loadDirs(ws)
+    const next = entry.dirs.filter((d) => wsKey(d) !== key)
+    const changed = next.length !== entry.dirs.length
+    entry.dirs = next
+    if (changed) await saveDirs(ws, next)
+    return { workspace: ws, dirs: [...next], changed }
+  }
+
+  const coreSet = async (ws, paths) => {
+    ws = requireWorkspace(ws)
+    if (!Array.isArray(paths)) throw new Error('set requires an array of absolute paths')
+    const canon = []
+    for (const p of paths) {
+      if (!isAbsolute(p)) throw new Error('set requires absolute paths')
+      const c = await canonicalizeAbs(p)
+      if (c === null) throw new Error('cannot resolve path "' + p + '"')
+      canon.push(c)
+    }
+    const entry = await loadDirs(ws)
+    const next = sanitizeDirs(canon, ws)
+    const changed = JSON.stringify(next) !== JSON.stringify(entry.dirs)
+    entry.dirs = next
+    if (changed) await saveDirs(ws, next)
+    return { workspace: ws, dirs: [...next], changed }
+  }
+
+  // ----------------------------------------------- sessionless remote API
+  // `multiFolder/*` endpoints over the Typert gateway. Hand-written
+  // `src-json` descriptors registered through ctx.typert.register (the
+  // sanctioned manual path documented by dsh-typert-loader) plus a
+  // plain-object service carrying the gateway's typertRemote binding.
+  // No session is involved: parameters are the workspace path and paths.
+
+  const remoteErrorMessage = (e) =>
+    'multi-folder: ' + String(e && e.message ? e.message : e).replace(/^multi-folder:\s*/, '')
+
+  const multiFolderApi = {
+    async list(workspace) {
+      try {
+        return await coreList(workspace)
+      } catch (e) {
+        throw new Error(remoteErrorMessage(e))
+      }
+    },
+    async add(workspace, path) {
+      try {
+        return await coreAdd(workspace, path)
+      } catch (e) {
+        throw new Error(remoteErrorMessage(e))
+      }
+    },
+    async remove(workspace, path) {
+      try {
+        return await coreRemove(workspace, path)
+      } catch (e) {
+        throw new Error(remoteErrorMessage(e))
+      }
+    },
+    async set(workspace, dirs) {
+      try {
+        return await coreSet(workspace, dirs)
+      } catch (e) {
+        throw new Error(remoteErrorMessage(e))
+      }
+    },
+  }
+  Object.defineProperty(multiFolderApi, 'typertRemote', {
+    value: Object.freeze({
+      service: multiFolderApi,
+      serviceKey: 'multiFolder',
+      namespace: 'multiFolder',
+    }),
+  })
+
+  const remoteParam = (name) => ({ name, wire: name, source: 'json', codec: { mode: 'src-json' } })
+  const remoteInvocation = (method, params) => ({
+    id: 'dsh-multi-folder#multiFolder/' + method,
+    service: 'multiFolder',
+    namespace: 'multiFolder',
+    method,
+    invocation: { kind: 'direct' },
+    parameters: params.map(remoteParam),
+    result: { mode: 'src-json' },
+  })
+  const REMOTE_CONTRIBUTION = {
+    package: 'dsh-multi-folder',
+    face: 'host',
+    schemas: [],
+    model: { services: [], events: [], objects: [] },
+    invocations: [
+      remoteInvocation('list', ['workspace']),
+      remoteInvocation('add', ['workspace', 'path']),
+      remoteInvocation('remove', ['workspace', 'path']),
+      remoteInvocation('set', ['workspace', 'dirs']),
+    ],
+  }
+
   // -------------------------------------------------------- notice channel
   const noticeMessage = (text) => ({
     id: 'mf-note-' + (++noteSeq),
@@ -435,62 +576,45 @@ export function apply(ctx) {
           if (typeof ws !== 'string' || ws.length === 0) {
             return { kind: 'error', text: 'multi-folder: session workspace is unknown' }
           }
-          const entry = await loadDirs(ws)
           const argv = parseArgs(invocation.rawInput)
           const sub = argv.length === 0 ? 'list' : argv[0].toLowerCase()
-          let next
-          let changed = false
+          let outcome
           if (sub === 'list') {
-            return { kind: 'success', text: resultText(ws, entry.dirs, false) }
-          }
-          if (sub === 'add') {
-            const path = argv.slice(1).join(' ')
-            if (path.length === 0) return { kind: 'error', text: 'multi-folder: add requires a path' }
-            if (!isAbsolute(path)) return { kind: 'error', text: 'multi-folder: add requires an absolute path' }
-            const canonical = await canonicalizeAbs(path)
-            if (canonical === null) {
-              return { kind: 'error', text: 'multi-folder: cannot resolve path "' + path + '"' }
-            }
-            next = sanitizeDirs([...entry.dirs, canonical], ws)
-            changed = next.length !== entry.dirs.length
+            outcome = await coreList(ws)
+          } else if (sub === 'add') {
+            outcome = await coreAdd(ws, argv.slice(1).join(' '))
           } else if (sub === 'remove') {
-            const path = argv.slice(1).join(' ')
-            if (path.length === 0) return { kind: 'error', text: 'multi-folder: remove requires a path' }
-            const canonical = await canonicalizeAbs(path)
-            const key = wsKey(canonical === null ? path : canonical)
-            next = entry.dirs.filter((d) => wsKey(d) !== key)
-            changed = next.length !== entry.dirs.length
+            outcome = await coreRemove(ws, argv.slice(1).join(' '))
           } else if (sub === 'set') {
-            const canon = []
-            for (const p of argv.slice(1)) {
-              if (!isAbsolute(p)) return { kind: 'error', text: 'multi-folder: set requires absolute paths' }
-              const c = await canonicalizeAbs(p)
-              if (c === null) {
-                return { kind: 'error', text: 'multi-folder: cannot resolve path "' + p + '"' }
-              }
-              canon.push(c)
-            }
-            next = sanitizeDirs(canon, ws)
-            changed = JSON.stringify(next) !== JSON.stringify(entry.dirs)
+            outcome = await coreSet(ws, argv.slice(1))
           } else {
             return {
               kind: 'error',
               text: 'multi-folder: unknown subcommand "' + sub + '" (use list / add / remove / set)',
             }
           }
-          entry.dirs = next
-          if (changed) {
-            await saveDirs(ws, next)
+          if (outcome.changed) {
             armNotice(
               invocation.agent,
-              'Secondary working directories changed (dsh-multi-folder):\n' + dirsText(ws, next),
+              'Secondary working directories changed (dsh-multi-folder):\n' + dirsText(ws, outcome.dirs),
             )
           }
-          return { kind: 'success', text: resultText(ws, next, changed) }
+          return { kind: 'success', text: resultText(outcome.workspace, outcome.dirs, outcome.changed) }
         } catch (e) {
-          return { kind: 'error', text: 'multi-folder: ' + String(e) }
+          return {
+            kind: 'error',
+            text: 'multi-folder: ' + String(e && e.message ? e.message : e).replace(/^multi-folder:\s*/, ''),
+          }
         }
       },
     })
   })
+
+  // ------------------------------------------ sessionless remote API mounts
+  // The plain-object service must be reachable through ctx.get('multiFolder')
+  // with a visible typertRemote binding, and the typert registry entry makes
+  // the endpoints claimable on the shared /api channel. Both are owned by
+  // this plugin fiber, so unloading the plugin withdraws them together.
+  ctx.provide('multiFolder', multiFolderApi)
+  ctx.inject(['typert'], (t) => t.typert.register(REMOTE_CONTRIBUTION))
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-multi-folder",
-  "version": "0.1.0",
-  "description": "DeepSeek Harness plugin: secondary working directories for a project. The agent keeps the primary workspace as cwd, gains equal write/exec permissions on configured secondary directories under workspace-write mode, and is notified of configuration changes at the next message boundary.",
+  "version": "0.1.2",
+  "description": "DeepSeek Harness plugin: secondary working directories for a project. The agent keeps the primary workspace as cwd, gains equal write/exec permissions on configured secondary directories under workspace-write mode, and is notified of configuration changes at the next message boundary. Configurable from the session header AND from the session-creation page (before the first message) through a sessionless multiFolder remote API.",
   "keywords": [
     "dsh-plugin",
     "dsh",
@@ -47,6 +47,8 @@
       "inject": [
         "@deepseek-ai/dsh-api-gateway",
         "@deepseek-ai/dsh-api-remotes",
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-client-locale",
         "@deepseek-ai/dsh-client-runtime"
       ]
     }