@4fu/dsh-arbor-ui-workspace 0.0.0-stage → 2026.1110.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 4fuu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,235 @@
-# Temporary Holding Version
+# dsh-arbor
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Run [arbor](https://github.com/4fuu/arbor) as the agent driver inside
+[DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) (DSH).
+
+DSH gives a user a session, a transcript, approvals, plugins, skills and a model
+picker. arbor gives an agent disposable context windows over one shared journal,
+note store and workspace, instead of one long conversation. dsh-arbor connects
+them: one arbor host runs inside the DSH process, each DSH session that selects
+**Arbor** is served by that host, and the window's reply is written back to the
+DSH session as an ordinary assistant message. A DSH session that does not select
+Arbor keeps running on DSH's own embedded AgentLoop, in the same process.
+
+> **Status.** This is a research-grade integration, not a DSH release. It is
+> pinned to one DSH version and relies on DSH internals. Read
+> [Versions and compatibility](docs/versions.md) before installing it on
+> anything you care about. The packages are published under `@4fu` at
+> `2026.1110.0`; the bundle and the font plugin install independently from npm.
+
+## What an arbor session changes
+
+Choosing **Arbor** in a DSH composer creates the session under the `arbor` agent
+preset. That session then runs on arbor, and the following are true for it:
+
+- **One window per turn, one chain per session.** A DSH session is one arbor
+  conversation: its first turn opens a window, a window that ends hands off to a
+  continuation, and the next turn drives the chain. The journal and note store
+  live under `$DSH_HOME/arbor/` and survive a restart.
+- **arbor's workspace, not DSH's sandbox.** A window works in arbor's shared
+  folder (`$DSH_HOME/arbor/shared`). When the `ovnfs` binary is available a
+  window opens a copy-on-write checkout and merges back with `apply`; otherwise
+  arbor uses a plain directory. **There is no DSH sandbox for an arbor session:**
+  arbor's file tools and commands run on the host, and arbor's own secret scrub
+  is the only protection on what reaches the model.
+- **arbor's projects.** The shared folder's project folders are the DSH project
+  list for arbor composers. A directory the user adds outside the shared folder
+  is recorded as an external pointer for that session and used in place.
+- **arbor's prompt and tools.** DSH's official prompt sections are decided one by
+  one; the ones arbor replaces are absent, third-party sections go into a
+  `<dsh>` data block, and a trusted `<harness>` section says what remains true of
+  DSH. DSH tools are offered to the model as arbor external tools, and arbor's
+  own tools replace DSH tools with the same capability.
+- **The Arbor page.** A permanent **Arbor** entry in DSH's left navigation opens
+  the whole-host overview and one tab per arbor session: windows, chains,
+  handoffs, projects, the board, notes, `/env`, schedules and arbor's search.
+  An arbor composer hides DSH's sandbox access-mode switch, because that switch
+  does not apply to it.
+
+## What stays untouched in ordinary DSH sessions
+
+A session that does not select Arbor is an ordinary DSH session. It keeps:
+
+- DSH's embedded AgentLoop, session format, turn boundaries and streaming path;
+- DSH's sandbox policy and its `ctx.fs` / `ctx.shell` file and command tools;
+- DSH's project management, working directory and prompt assembly;
+- its composer, sandbox access-mode switch, header and sidebar behavior.
+
+It gets **no Arbor tab** and no arbor windows. The only shared surface is the
+permanent Arbor entry in the left navigation, which simply does not list that
+session. The routing registry replaces DSH's base `agent` row so it can send
+`agentPreset: 'arbor'` sessions to arbor; every other session goes to the
+official loop. Approvals still use DSH's approval path for both kinds of
+session, and arbor's windows are registered so DSH's sidebar leaves them out.
+
+## Screenshots
+
+| Overview, light | Overview, dark |
+| --- | --- |
+| ![Arbor overview in light mode](docs/screenshots/overview-light.png) | ![Arbor overview in dark mode](docs/screenshots/overview-dark.png) |
+| **Session tab, light** | **Session tab, dark** |
+| ![An arbor session tab in light mode](docs/screenshots/session-light.png) | ![An arbor session tab in dark mode](docs/screenshots/session-dark.png) |
+
+These are the web profile at 1440 px wide with the optional
+[font plugin](https://github.com/4fuu/dsh-arbor-fonts) installed: ChillDIN
+Gothic for labels and ChillDIN for numerals, while body text and code keep
+DSH's fonts. The same overview without the plugin is
+[here](docs/screenshots/overview-without-fonts.png).
+
+## Install
+
+Requirements: Node.js 24.9 or newer and DeepSeek Harness `dsh-v0.2.2-rc.1`.
+The bundle is published with all packages it depends on; nothing has to be
+built or linked.
+
+```bash
+npm install -g @deepseek-ai/dsh@0.2.2-rc.1
+dsh plugin --profile web add @4fu/dsh-arbor-bundle@2026.1110.0
+dsh web
+```
+
+`dsh plugin` adds the bundle to the profile's `dsh.profile.bundles` and installs
+its packages into the profile. Pick **Arbor** in a composer and send a message.
+The optional [font plugin](https://github.com/4fuu/dsh-arbor-fonts) installs the
+same way:
+
+```bash
+dsh plugin --profile web add @4fu/dsh-arbor-fonts@2026.1110.0
+```
+
+### From a checkout
+
+The proofs and development use the TypeScript sources directly; that checkout is
+what the scripts and the pin check run against.
+
+```bash
+git clone https://github.com/4fuu/dsh-arbor
+cd dsh-arbor
+pnpm install --frozen-lockfile
+pnpm check                 # tsc --noEmit over every package and proof
+pnpm proofs                # 29 proofs against the scripted model
+```
+
+The first install may ask pnpm to approve dependency build scripts. Do not
+approve them by hand: the repository's `pnpm-workspace.yaml` already denies the
+six scripts it pulls in, each with the reason, and `pnpm install` finishes
+cleanly with that policy.
+
+### Hand the install to a model
+
+[docs/install-for-agents.md](docs/install-for-agents.md) is a step-by-step guide
+written for an AI agent: install from npm or a checkout, run the proofs, drive a
+live turn with a restart, boot the web profile, and inspect what ran. Give a
+model this prompt, editing the bracketed parts or dropping them:
+
+```text copy Copy Install Prompt
+Install dsh-arbor (https://github.com/4fuu/dsh-arbor) in this environment [in a
+scratch DSH home under /tmp] and show me that it works: follow
+docs/install-for-agents.md, install @4fu/dsh-arbor-bundle@2026.1110.0 into a DSH
+web profile, pick Arbor for one session, and [also run the proof suite from a
+checkout with pnpm install --frozen-lockfile, pnpm check and pnpm proofs]. Report
+which checks passed, what the live session answered, and anything that did not
+work. Fix only what is yours to fix and tell me what you changed.
+```
+
+## Use it in DSH
+
+The npm install above adds the bundle to a DSH web profile. Pick **Arbor** in a
+composer and send a message: the session is created under the preset, its window
+and chain appear under the **Arbor** entry, and an ordinary session started
+beside it keeps DSH's own composer and sandbox behavior. A checkout can also be
+wired by hand; [section 7 of the install guide](docs/install-for-agents.md#7-wiring-the-bundle-into-a-real-dsh-installation)
+shows the profile layout.
+
+The one-shot `dsh <task>` runner cannot drive an arbor-preset session: DSH's
+runner refuses to adopt a session that runs under a preset. Use the web client,
+the SDK path the proofs use, or a remote `agent-preset/select` on a blank.
+
+## Pinned DSH version
+
+DSH is pinned to **`dsh-v0.2.2-rc.1`** (npm
+`@deepseek-ai/dsh@0.2.2-rc.1`, commit `66491b05e3` of
+`deepseek-ai/deepseek-harness`). Every `@deepseek-ai/dsh*` dependency is an
+exact version, every package under `packages/` declares
+`engines.dsh: 0.2.2-rc.1`, and `pnpm check:pin` checks both plus the prompt
+bridge's `DSH_PINNED_VERSION`.
+
+A different DSH version is unsupported. The bundle depends on DSH's row names,
+its one-`AgentFactory` rule, its prompt-section registry, its client slot
+registration and its exact Fetch registry; a move in any of them can fail the
+boot, leave an official prompt section undecided, or stop the Arbor page from
+registering. `proofs/12-official-sections.ts` and `proofs/18-picker-pin.ts`
+are the behavioral checks. The canonical pin and the upgrade procedure are in
+[Versions and compatibility](docs/versions.md).
+
+## Optional: the font plugin
+
+[dsh-arbor-fonts](https://github.com/4fuu/dsh-arbor-fonts) is a separate DSH
+client plugin that changes only the typography of the Arbor page. It sets
+ChillDIN Gothic for display labels and ChillDIN for numerals, leaves body text
+and code on DSH's fonts, and does nothing on ordinary pages. It is optional and
+installs into the same DSH profile:
+
+```bash
+dsh plugin --profile web add @4fu/dsh-arbor-fonts@2026.1110.0
+```
+
+The fonts are licensed under the SIL Open Font License 1.1; the plugin ships the
+license text, per-file hashes and attribution.
+
+## Limits worth knowing
+
+- The judge is off: a model-based judge cannot run through the DSH backend yet.
+- The 12 bundle packages are published together at one version; install and
+  upgrade the bundle as a unit, because its packages name each other exactly.
+- `ovnfs` is optional. Without it arbor uses the plain-directory workspace, and a
+  window no longer gets a copy-on-write checkout.
+- The web page's numbers and layout are read from arbor's journal and API; it is
+  not a generic DSH dashboard, and it deliberately shows only arbor sessions.
+- The prompt bridge, the UI and the picker filter are pinned to DSH's internals,
+  not to a stable public API. See [Versions and compatibility](docs/versions.md).
+
+## Documentation
+
+- [Installing and inspecting dsh-arbor](docs/install-for-agents.md) — the
+  agent-facing install, proof, live-turn, web-profile and wiring guide.
+- [Versions and compatibility](docs/versions.md) — the DSH and arbor pins, and
+  what breaks on another DSH version.
+- [B0 findings](docs/b0-findings.md), [B3 findings](docs/b3-findings.md) and
+  [B3b projects and sandbox](docs/b3b-projects-and-sandbox.md) — historical
+  records of the integration's decisions, with the DSH source locations each
+  one rests on. They describe earlier stages; the install guide is the current
+  status.
+- [Layout and proofs](#layout) below for a quick map of the packages.
+
+## Layout
+
+```text
+packages/
+  arbor-host/       one Arbor host per process: SQLite journal and notes,
+                    settings, window lifecycle, workspace and environment
+  arbor-driver/     the routing AgentRegistry, AgentFactory, session agent,
+                    inbox and stream mirrors, and the journal relay
+  arbor-llm/        the arbor AgentBackend over DSH's ctx.llm and ctx.tools
+  arbor-prompt/     <harness>, the <dsh> data block, and the section table
+  arbor-tools/      DSH tools as arbor external tools, same-name replacement
+  arbor-workspace/  arbor's workspace over the shared folder (ovnfs or dir)
+  arbor-env/        /env, with DSH's skills and MCP servers mounted read-only
+  arbor-bundle/     the installable patch that mounts the rows and UI
+  arbor-facts/      the read face behind the Arbor page and its Fetch routes
+  arbor-ui/         the Arbor page, session tabs, copy and composer gate
+  arbor-ui-workspace/
+                    the per-preset hero project picker
+  arbor-preset/     the agent-preset row that puts Arbor in the roster
+  arbor-testkit/    the boot harness, memory journal and scripted model
+patches/            overlay layers a proof applies above the shipped profile
+proofs/             one runnable proof per integration point
+docs/               install, versions, screenshots and historical findings
+scripts/            the DSH pin check, the release build and the publish dry run
+```
+
+## License
+
+MIT. See [LICENSE](LICENSE). The optional font plugin vendors fonts under the
+SIL Open Font License 1.1; its repository carries the license text and
+attribution.

package/client.js

@@ -0,0 +1,294 @@
+window.__ModuleLoader__.load({
+	id: "@4fu/dsh-arbor-ui-workspace",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client.ts
+var client_exports = {};
+__export(client_exports, {
+  apply: () => apply,
+  inject: () => inject
+});
+module.exports = __toCommonJS(client_exports);
+var import_react = require("react");
+var PICKER_SLOT = "conversation.hero.workspace";
+var HERO_SEAT_SLOT = "conversation.hero.agentPreset";
+var SIDEBAR_SLOT = "sidebar.workspaces";
+var ARBOR_PRESET = "arbor";
+var PRESET_PROJECTION = "agentPreset";
+var ARBOR_MARK = "\uFF08Arbor\uFF09";
+var POLL_MS = 40;
+var MAX_POLLS = 500;
+var NAVIGATION_SERVICE = "uiWorkspace";
+var CARRY_MS = 2e3;
+var PRESET_WAIT_MS = 2e3;
+var PRESET_POLL_MS = 25;
+function useMainSessionId(props) {
+  const useSessions = props["useSessions"];
+  return useSessions?.((state) => {
+    for (const [id, row] of Object.entries(state.byId)) {
+      if ((row.retainedBy?.mainView ?? 0) > 0) return id;
+    }
+    return void 0;
+  });
+}
+function useProjectionOf(props) {
+  const useProjection = props["useProjection"];
+  return useProjection?.(PRESET_PROJECTION);
+}
+var inject = [
+  "contextMenus",
+  "slots",
+  "sessions",
+  "workspaces",
+  "locale",
+  "remote",
+  "remote.directoryPicker",
+  "layout",
+  "shortcuts",
+  "remoteAccess"
+];
+function isArborProject(path) {
+  const segments = path.split(/[\\/]/).filter((segment) => segment !== "");
+  for (let index = 0; index + 1 < segments.length; index++) {
+    if (segments[index] === "arbor" && segments[index + 1] === "shared") return true;
+  }
+  return false;
+}
+var EXTERNAL_MARK = "\uFF08\u5916\u90E8\uFF09";
+function filterRows(rows, preset) {
+  if (preset === ARBOR_PRESET) {
+    return rows.map((row) => isArborProject(row.path) ? row : { ...row, title: `${row.title}${EXTERNAL_MARK}` });
+  }
+  return rows.filter((row) => !isArborProject(row.path));
+}
+var cached;
+function filterState(state, preset) {
+  if (cached !== void 0 && cached.state === state && cached.preset === preset) return cached.result;
+  const result = { ...state, items: filterRows(state.items, preset) };
+  cached = { state, preset, result };
+  return result;
+}
+var markedCache;
+function markState(state) {
+  if (markedCache !== void 0 && markedCache.state === state) return markedCache.result;
+  const result = {
+    ...state,
+    items: state.items.map((row) => isArborProject(row.path) ? { ...row, title: `${row.title}${ARBOR_MARK}` } : row)
+  };
+  markedCache = { state, result };
+  return result;
+}
+function apply(ctx) {
+  const slots = ctx.slots;
+  let heroInject;
+  let unboundSeat;
+  const heroSeatFor = (sessionId) => {
+    if (heroInject === void 0) return void 0;
+    if (sessionId === void 0) {
+      unboundSeat ??= heroInject()?.hooks?.agentPresetSeat;
+      return unboundSeat;
+    }
+    return heroInject(sessionId)?.hooks?.agentPresetSeat;
+  };
+  let poll;
+  let attempts = 0;
+  let adoptWrapped = false;
+  let restoreWrapped = false;
+  const stop = () => {
+    if (poll !== void 0) {
+      clearInterval(poll);
+      poll = void 0;
+    }
+  };
+  const look = () => {
+    if (++attempts > MAX_POLLS) {
+      stop();
+      return;
+    }
+    if (heroInject === void 0) {
+      const face = slots.entriesOfSlot?.(HERO_SEAT_SLOT)[0]?.inject;
+      if (typeof face === "function") heroInject = face;
+    }
+    if (!adoptWrapped || !restoreWrapped) {
+      const navigation = ctx.get(NAVIGATION_SERVICE);
+      if (navigation !== void 0) {
+        if (!adoptWrapped) {
+          wrapAdopt();
+          adoptWrapped = true;
+        }
+        if (!restoreWrapped) {
+          wrapRestoreBlank();
+          restoreWrapped = true;
+        }
+      }
+    }
+    if (heroInject !== void 0 && adoptWrapped && restoreWrapped) stop();
+  };
+  ctx.effect(() => () => {
+    stop();
+  }, "dsh-arbor-ui-workspace: stop the hero-seat poll");
+  poll = setInterval(look, POLL_MS);
+  function usePresetPick(sessionId, projected) {
+    const bound = heroSeatFor(sessionId);
+    const unbound = heroSeatFor(void 0);
+    return (0, import_react.useSyncExternalStore)(
+      (onChange) => {
+        const stops = [bound, unbound].map((store) => store?.subscribe(onChange));
+        return () => {
+          for (const halt of stops) halt?.();
+        };
+      },
+      () => {
+        const picks = [bound, unbound].map((store) => store?.getSnapshot().current);
+        return picks.find((pick) => pick === ARBOR_PRESET) ?? picks.find((pick) => pick !== void 0 && pick !== "") ?? (typeof projected === "string" ? projected : void 0);
+      }
+    );
+  }
+  const sessions = ctx.sessions;
+  const mainSession = () => {
+    const byId = sessions?.list.getSnapshot().byId ?? {};
+    for (const id of Object.keys(byId)) {
+      if ((byId[id]?.retainedBy?.mainView ?? 0) > 0) return byId[id];
+    }
+    return void 0;
+  };
+  const currentPick = () => {
+    const bound = heroSeatFor(mainSession()?.id);
+    const unbound = heroSeatFor(void 0);
+    const picks = [bound, unbound].map((store) => store?.getSnapshot().current);
+    return picks[0] !== void 0 && picks[0] !== "" ? picks[0] : picks.find((pick) => pick !== void 0 && pick !== "");
+  };
+  const heroFaceNow = (sessionId) => {
+    const face = slots.entriesOfSlot?.(HERO_SEAT_SLOT)[0]?.inject;
+    return typeof face === "function" ? face(sessionId) : void 0;
+  };
+  const workspaceRow = (workspaceId) => {
+    const items = ctx.get("workspaces");
+    return items?.list.getSnapshot().items.find((item) => item.workspaceId === workspaceId);
+  };
+  const reaskPick = (before) => {
+    const deadline = Date.now() + CARRY_MS;
+    const settle = () => {
+      const main = mainSession();
+      if (main === void 0 || main.blank !== true) return;
+      if (main.id === before && Date.now() < deadline) {
+        setTimeout(settle, POLL_MS);
+        return;
+      }
+      if (main.projectionValues?.agentPreset !== ARBOR_PRESET) {
+        heroFaceNow(main.id)?.select?.(ARBOR_PRESET);
+      }
+    };
+    setTimeout(settle, POLL_MS);
+  };
+  const wrapAdopt = () => {
+    const navigation = ctx.get(NAVIGATION_SERVICE);
+    if (navigation === void 0 || typeof navigation.openWorkspace !== "function") return;
+    if (navigation.__arborAdopt === true) return;
+    const original2 = navigation.openWorkspace.bind(navigation);
+    navigation.openWorkspace = (workspaceId, beforeOpen, options) => {
+      const pick = currentPick();
+      const row = workspaceRow(workspaceId);
+      const createTakesIt = pick === ARBOR_PRESET && row !== void 0;
+      const before = mainSession()?.id;
+      const outcome = original2(workspaceId, beforeOpen, createTakesIt ? { agentPreset: pick } : options);
+      if (pick === ARBOR_PRESET && !createTakesIt) reaskPick(before);
+      return outcome;
+    };
+    Object.defineProperty(navigation, "__arborAdopt", { value: true, configurable: true });
+    ctx.effect(() => () => {
+      navigation.openWorkspace = original2;
+      delete navigation.__arborAdopt;
+    }, "dsh-arbor-ui-workspace: restore uiWorkspace.openWorkspace");
+  };
+  const presetInList = (sessionId) => {
+    const sessions2 = ctx.get("sessions");
+    const recorded = sessions2?.list.getSnapshot().byId[sessionId]?.projectionValues?.agentPreset;
+    return typeof recorded === "string" ? recorded : void 0;
+  };
+  const recordedPreset = async (sessionId) => {
+    const sessions2 = ctx.get("sessions");
+    if (sessions2 === void 0) return void 0;
+    const deadline = Date.now() + PRESET_WAIT_MS;
+    for (; ; ) {
+      const recorded = presetInList(sessionId);
+      if (recorded !== void 0) return recorded;
+      if (Date.now() >= deadline) return void 0;
+      await sessions2.refreshProjections(sessionId).catch(() => void 0);
+      const after = presetInList(sessionId);
+      if (after !== void 0) return after;
+      await new Promise((resolve) => setTimeout(resolve, PRESET_POLL_MS));
+    }
+  };
+  const wrapRestoreBlank = () => {
+    const navigation = ctx.get(NAVIGATION_SERVICE);
+    if (navigation === void 0 || typeof navigation.restoreBlank !== "function") return;
+    const original2 = navigation.restoreBlank.bind(navigation);
+    navigation.restoreBlank = async (workspaceId, sessionId) => {
+      await recordedPreset(sessionId);
+      return original2(workspaceId, sessionId);
+    };
+    ctx.effect(() => () => {
+      navigation.restoreBlank = original2;
+    }, "dsh-arbor-ui-workspace: restore uiWorkspace.restoreBlank");
+  };
+  const gate = (shipped) => (props) => {
+    const sessionId = useMainSessionId(props);
+    const preset = usePresetPick(sessionId, useProjectionOf(props));
+    const useWorkspaces = props["useWorkspaces"];
+    const filtered = (selector) => useWorkspaces === void 0 ? void 0 : selector(filterState(useWorkspaces((state) => state), preset));
+    return (0, import_react.createElement)(shipped, {
+      ...props,
+      useWorkspaces: filtered
+    });
+  };
+  const marked = (shipped) => (props) => {
+    const useWorkspaces = props["useWorkspaces"];
+    const marking = (selector) => useWorkspaces === void 0 ? void 0 : selector(markState(useWorkspaces((state) => state)));
+    return (0, import_react.createElement)(shipped, {
+      ...props,
+      useWorkspaces: marking
+    });
+  };
+  const original = slots.register.bind(slots);
+  const register = (options, component) => {
+    if (options.name === PICKER_SLOT) {
+      return original(options, gate(component));
+    }
+    if (options.name === SIDEBAR_SLOT) {
+      return original(options, marked(component));
+    }
+    return original(options, component);
+  };
+  Object.defineProperty(slots, "register", { value: register, configurable: true, writable: true });
+  ctx.effect(() => () => {
+    delete slots.register;
+  }, "dsh-arbor-ui-workspace: restore slots.register");
+}
+
+		return module.exports;
+	}
+});
+

package/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The dsh-arbor-ui-workspace node half.
+ *
+ * The empty host `apply` exists only so the plugin appears in the host
+ * cordis.yml / Loader: every behavior lives in the browser half
+ * (`exports["./client"]`), which the client module graph discovers from this
+ * package's `dsh.client` declaration. There is nothing to do on the host — the
+ * picker filter is a slot registration, which is browser state.
+ */
+/** Host plugin body — no host-side behavior for this surface plugin. */
+export declare function apply(): void;

package/index.js

@@ -0,0 +1,11 @@
+/**
+ * The dsh-arbor-ui-workspace node half.
+ *
+ * The empty host `apply` exists only so the plugin appears in the host
+ * cordis.yml / Loader: every behavior lives in the browser half
+ * (`exports["./client"]`), which the client module graph discovers from this
+ * package's `dsh.client` declaration. There is nothing to do on the host — the
+ * picker filter is a slot registration, which is browser state.
+ */
+/** Host plugin body — no host-side behavior for this surface plugin. */
+export function apply() { }

package/package.json

@@ -1,6 +1,45 @@
 {
   "name": "@4fu/dsh-arbor-ui-workspace",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "2026.1110.0",
+  "type": "module",
+  "description": "The dsh-arbor browser package for the project picker: arbor's shared-folder projects are listed for an arbor session only, and a directory outside them is marked external",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./client": "./client.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "client.js",
+    "index.d.ts",
+    "index.js"
+  ],
+  "dsh": {
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-workspace"
+      ],
+      "platform": "web"
+    }
+  },
+  "dependencies": {
+    "@deepseek-ai/cordis": "4.1.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/4fuu/dsh-arbor.git",
+    "directory": "packages/arbor-ui-workspace"
+  },
+  "engines": {
+    "node": ">=24.9.0",
+    "dsh": "0.2.2-rc.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "types": "./index.d.ts",
+  "main": "./index.js"
+}