@sessionbus/dsh 0.1.0-pre.2

package/README.md

@@ -0,0 +1,58 @@
+# sessionbus for DSH
+
+`@sessionbus/dsh` connects DSH roots to sessionbus and runs daemon-managed DSH lanes.
+It depends on the exact `@sessionbus/kit` prerelease `0.1.0-pre.3`.
+It supports DeepSeek Harness `0.1.5-rc.2` and later; tested versions are
+`0.1.5-rc.2`, `0.1.6-alpha.1`, and `0.1.6-alpha.2`.
+A DSH profile must install every DSH package at one uniform DSH version; adding
+one prerelease package can otherwise pull newer prereleases through DSH's caret peers.
+`@sessionbus/dsh` is a pkg.pr.new preview until a separately reviewed trusted-
+publishing workflow exists; its first registry version must be published manually
+before trusted publishing can be configured.
+The plugin reads the token once, deletes it from process.env, and retains it
+nowhere in the plugin; DSH's immutable launch snapshot keeps it for the process
+lifetime (trusted host).
+
+Create the base-only lane profile with:
+
+```sh
+dsh plugin --profile sessionbus add @sessionbus/dsh && dsh plugin --profile sessionbus exec sessionbus-dsh-install
+```
+
+Add the peer plugin to another profile, such as `web`, with:
+
+```sh
+dsh plugin --profile web add @sessionbus/dsh && dsh plugin --profile web exec sessionbus-dsh-install --product dsh web
+```
+
+The installer writes only profile-local rows and leaves an existing
+`sessionbus` row's other fields unchanged while adding or updating its required
+`product`. With no profile arguments it configures only the `sessionbus` lane
+profile and derives product `sessionbus-dsh`. Use product `dashi` for the dashi
+profile, `dsh` for a standalone web or custom peer profile, or another stable
+operator-chosen identifier matching `^[a-z0-9][a-z0-9-]{0,31}$`.
+Non-web profiles also receive the no-upload provider required by DSH's Session
+Controller; ordinary text prompts work while file-upload receipts are rejected.
+
+Register the daemon's `sessionbus-dsh` product command as the package's
+`sessionbus-dsh` bin. With a launch token it selects the installed `sessionbus`
+profile; without one it forwards arguments to `dsh` unchanged.
+The daemon finds that command on `PATH`, so install this package alongside
+`dsh` at the host level too—for example, run `pnpm add @sessionbus/dsh` in the
+directory where `dsh` is installed—so both bins share one `node_modules/.bin`.
+
+Uninstall without invoking DSH by running the installed bin from the profile:
+
+```sh
+pnpm --dir "$DSH_HOME/profiles/web" exec sessionbus-dsh-install --remove web
+```
+
+When the DSH CLI works, `dsh plugin --profile web exec
+sessionbus-dsh-install --remove web` is the equivalent convenience form. The
+installer removes the package first, then strips its managed `sessionbus` and
+`file-uploads-none` rows.
+
+`SESSIONBUS_GROUPS` configures peer identities only. Lane membership is owned
+by the daemon; the plugin accepts and does not consume groups in `session.open`.
+
+See [Lane without a TUI](docs/LANE-WITHOUT-TUI.md) for the daemon launch contract.

package/bin.mjs

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import { install, remove } from "./install.mjs";
+
+const profiles = [];
+let product;
+let removing = false;
+try {
+  for (let index = 2; index < process.argv.length; index++) {
+    if (process.argv[index] === "--remove") removing = true;
+    else if (process.argv[index] !== "--product") profiles.push(process.argv[index]);
+    else if ((product = process.argv[++index]) === undefined) throw new Error("--product requires a value");
+  }
+  if (removing) remove(profiles);
+  else install(profiles, { product });
+} catch (error) {
+  process.stderr.write(`sessionbus-dsh-install: ${error.message}\n`);
+  process.exitCode = 1;
+}

package/docs/LANE-WITHOUT-TUI.md

@@ -0,0 +1,7 @@
+# Lane without a TUI
+
+The Sessionbus daemon starts a DSH lane directly; dashi is not involved. Its
+`sessionbus-dsh` product command executes the package-owned `sessionbus-dsh` bin
+with `SESSIONBUS_LAUNCH_TOKEN` set and supplies no CLI task. The bin selects
+`dsh --profile sessionbus`; the profile's `product: sessionbus-dsh` row identifies
+the launched product and its resident base-only DSH app.

package/install.mjs

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const profilePatch = `- id: system-prompt
+  config:
+    persona: >-
+      You are a coding agent powered by the {{model}} model. Your working directory is {{cwd}}.
+- id: session-title-llm
+  disabled: true
+- id: permission
+  config:
+    presets:
+      read-only: { sandbox: read-only, approval: ask }
+      workspace-write: { sandbox: workspace-write, approval: ask }
+      workspace-write-noninteractive: { sandbox: workspace-write, approval: never }
+      danger-full-access: { sandbox: danger-full-access, approval: never }
+
+- insert:
+    - { id: workspace, name: '@deepseek-ai/dsh-workspace' }
+    - { id: file-uploads-none, name: '@antst/dsh-file-uploads-none' }
+    - { id: session-controller, name: '@deepseek-ai/dsh-api-session-controller' }
+    - id: sessionbus
+      name: '@sessionbus/dsh'
+      config: { mode: lane, product: sessionbus-dsh }
+`;
+const peerPatch = (product) => `- insert:
+    - { id: sessionbus, name: '@sessionbus/dsh', config: { product: ${product} } }
+`;
+const noUploadsPatch = `- insert:
+    - { id: file-uploads-none, name: '@antst/dsh-file-uploads-none' }
+`;
+const sessionbusID = /(?:^\s*-\s*|[{,]\s*)['"]?id['"]?\s*:\s*['"]?sessionbus['"]?(?=\s|[,}]|$)/mu;
+const noUploadsID = /(?:^\s*-\s*|[{,]\s*)['"]?id['"]?\s*:\s*['"]?file-uploads-none['"]?(?=\s|[,}]|$)/mu;
+const productPattern = /^[a-z0-9][a-z0-9-]{0,31}$/u;
+const ownedIDs = [sessionbusID, noUploadsID];
+function writeChanged(file, body) {
+  if (!existsSync(file) || readFileSync(file, "utf8") !== body) writeFileSync(file, body);
+}
+
+function convergePatch(file, id, patch) {
+  const old = existsSync(file) ? readFileSync(file, "utf8") : "";
+  if (id.test(old)) return;
+  const empty = /^(?:\s*#.*\n)*\s*\[\]\s*$/u.test(old);
+  writeChanged(file, `${empty ? "" : old.trimEnd() + (old.trim() ? "\n\n" : "")}${patch}`);
+}
+
+function withProduct(body, product) {
+  const lines = body.split("\n");
+  const row = lines.findIndex((line) => sessionbusID.test(line));
+  if (row < 0) return body;
+  const value = /(['"]?product['"]?\s*:\s*)(?:'[^']*'|"[^"]*"|[^,\s}]+)/u;
+  const column = lines[row].search(/['"]?id['"]?\s*:/u);
+  const open = lines[row].lastIndexOf("{", column);
+  if (open >= 0) {
+    if (value.test(lines[row])) lines[row] = lines[row].replace(value, `$1${product}`);
+    else if (/['"]?config['"]?\s*:\s*\{/u.test(lines[row])) lines[row] = lines[row].replace(/(['"]?config['"]?\s*:\s*\{\s*)/u, `$1product: ${product}, `);
+    else {
+      let depth = 0, close = -1;
+      for (let index = open; index < lines[row].length; index++) {
+        if (lines[row][index] === "{") depth++;
+        if (lines[row][index] === "}" && --depth === 0) { close = index; break; }
+      }
+      lines[row] = `${lines[row].slice(0, close)}, config: { product: ${product} }${lines[row].slice(close)}`;
+    }
+    return lines.join("\n");
+  }
+  const indent = lines[row].match(/^\s*/u)[0].length;
+  let end = row + 1;
+  while (end < lines.length && !new RegExp(`^\\s{0,${indent}}-\\s+`, "u").test(lines[end])) end++;
+  for (let index = row; index < end; index++) {
+    if (value.test(lines[index])) { lines[index] = lines[index].replace(value, `$1${product}`); return lines.join("\n"); }
+  }
+  const config = lines.slice(row, end).findIndex((line) => /^\s*['"]?config['"]?\s*:/u.test(line));
+  if (config >= 0) {
+    const index = row + config;
+    if (lines[index].includes("{")) lines[index] = lines[index].replace(/\{\s*/u, `{ product: ${product}, `);
+    else lines.splice(index + 1, 0, `${lines[index].match(/^\s*/u)[0]}  product: ${product}`);
+  } else {
+    if (end === lines.length && lines.at(-1) === "") end--;
+    lines.splice(end, 0, `${" ".repeat(indent + 2)}config: { product: ${product} }`);
+  }
+  return lines.join("\n");
+}
+
+function convergeSessionbus(file, product) {
+  const old = existsSync(file) ? readFileSync(file, "utf8") : "";
+  if (sessionbusID.test(old)) return writeChanged(file, withProduct(old, product));
+  convergePatch(file, sessionbusID, peerPatch(product));
+}
+
+function withoutOwnedRows(body) {
+  const lines = body.split(/(?<=\n)/u);
+  for (let row = lines.length - 1; row >= 0; row--) {
+    const text = lines[row].replace(/\r?\n$/u, "");
+    if (!ownedIDs.some((id) => id.test(text))) continue;
+    const indent = text.match(/^\s*/u)[0].length;
+    let end = row + 1;
+    if (!text.includes("{")) {
+      while (end < lines.length) {
+        const next = lines[end].replace(/\r?\n$/u, "");
+        const nextIndent = next.match(/^\s*/u)[0].length;
+        if ((/^\s*-\s+/u.test(next) || /^\s*#/u.test(next)) && nextIndent <= indent) break;
+        end++;
+      }
+    }
+    lines.splice(row, end - row);
+  }
+  for (let row = lines.length - 1; row >= 0; row--) {
+    const match = /^(\s*)-\s+insert:\s*(?:#.*)?(?:\r?\n)?$/u.exec(lines[row]);
+    if (!match) continue;
+    let child = row + 1;
+    while (child < lines.length && /^\s*(?:#.*)?(?:\r?\n)?$/u.test(lines[child])) child++;
+    if (child === lines.length || lines[child].match(/^\s*/u)[0].length <= match[1].length) {
+      if (row > 0 && /^\s*(?:\r?\n)?$/u.test(lines[row - 1])) lines.splice(row - 1, 2);
+      else lines.splice(row, 1);
+    }
+  }
+  const result = lines.join("");
+  return result.trim() ? result : "[]\n";
+}
+
+function validProfile(name) {
+  return name && !name.includes("/") && !name.includes("\\") && name !== "." && name !== ".." && name !== "node_modules";
+}
+
+export function install(profileNames = [], options = {}) {
+  const home = options.home || process.env.DSH_HOME || path.join(os.homedir(), ".dsh");
+  const root = options.root || path.dirname(fileURLToPath(import.meta.url));
+  const run = options.run || ((args) => spawnSync("dsh", args, { cwd: root, encoding: "utf8" }));
+  const names = [...new Set(profileNames.length ? profileNames : ["sessionbus"])];
+  if (options.product !== undefined && (typeof options.product !== "string" || !productPattern.test(options.product))) throw new Error(`invalid product ${JSON.stringify(options.product)}; expected ^[a-z0-9][a-z0-9-]{0,31}$`);
+  if (names.includes("sessionbus") && options.product !== undefined && options.product !== "sessionbus-dsh") throw new Error("the sessionbus profile product must be sessionbus-dsh");
+  if (names.some((name) => name !== "sessionbus") && options.product === undefined) throw new Error("--product is required for peer profiles");
+  for (const name of names) {
+    if (!validProfile(name)) throw new Error(`invalid profile name ${JSON.stringify(name)}`);
+    const profile = path.join(home, "profiles", name);
+    const manifestFile = path.join(profile, "package.json");
+    let manifest = existsSync(manifestFile) ? JSON.parse(readFileSync(manifestFile, "utf8")) : null;
+    if (!manifest?.dependencies?.["@sessionbus/dsh"]) {
+      const result = run(["plugin", "--profile", name, "add", "@sessionbus/dsh"]);
+      if (result.status !== 0) throw new Error(String(result.stderr || "dsh plugin add failed").trim());
+      manifest = JSON.parse(readFileSync(manifestFile, "utf8"));
+    }
+    if (name !== "sessionbus") {
+      const patch = path.join(profile, "cordis.patch.yml");
+      convergeSessionbus(patch, options.product);
+      if (name !== "web") convergePatch(patch, noUploadsID, noUploadsPatch);
+      continue;
+    }
+    manifest = {
+      name: "dsh-profile-sessionbus",
+      private: true,
+      dependencies: { "@sessionbus/dsh": manifest.dependencies["@sessionbus/dsh"] },
+      dsh: { profile: { bundles: ["@deepseek-ai/dsh-base"], patchReload: "startup" } },
+    };
+    writeChanged(manifestFile, `${JSON.stringify(manifest, null, 2)}\n`);
+    writeChanged(path.join(profile, "cordis.patch.yml"), profilePatch);
+  }
+}
+
+export function remove(profileNames = [], options = {}) {
+  if (profileNames.length === 0) throw new Error("--remove requires at least one profile");
+  const home = options.home || process.env.DSH_HOME || path.join(os.homedir(), ".dsh");
+  const run = options.run || ((args, cwd) => spawnSync("pnpm", args, { cwd, encoding: "utf8" }));
+  for (const name of [...new Set(profileNames)]) {
+    if (!validProfile(name)) throw new Error(`invalid profile name ${JSON.stringify(name)}`);
+    const profile = path.join(home, "profiles", name);
+    const result = run(["remove", "@sessionbus/dsh"], profile);
+    if (result.status !== 0) throw new Error(String(result.stderr || result.error?.message || "pnpm remove failed").trim());
+    const patch = path.join(profile, "cordis.patch.yml");
+    if (existsSync(patch)) writeChanged(patch, withoutOwnedRows(readFileSync(patch, "utf8")));
+  }
+}

package/launcher.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+// Signal and exit forwarding mirrors @antst/dashi-launcher's bin/dashi.js.
+import { spawn } from "node:child_process";
+
+const args = process.env.SESSIONBUS_LAUNCH_TOKEN === undefined
+  ? process.argv.slice(2)
+  : ["--profile", "sessionbus", ...process.argv.slice(2)];
+const child = spawn("dsh", args, { stdio: "inherit" });
+const signals = ["SIGINT", "SIGTERM"];
+const forwards = signals.map((signal) => [signal, () => child.kill(signal)]);
+for (const [signal, forward] of forwards) process.on(signal, forward);
+
+let failed = false;
+child.on("error", (error) => {
+  failed = true;
+  const missing = error.code === "ENOENT";
+  process.stderr.write(missing
+    ? "sessionbus-dsh: dsh not found; install it with 'npm install --global @deepseek-ai/dsh'\n"
+    : `sessionbus-dsh: could not start dsh: ${error.message}\n`);
+  process.exitCode = missing ? 127 : 1;
+});
+child.on("close", (code, signal) => {
+  for (const [name, forward] of forwards) process.off(name, forward);
+  if (failed) return;
+  if (code !== null) process.exitCode = code;
+  else if (signal !== null) process.kill(process.pid, signal);
+});

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@sessionbus/dsh",
+  "version": "0.1.0-pre.2",
+  "type": "commonjs",
+  "main": "plugin.cjs",
+  "exports": "./plugin.cjs",
+  "bin": {
+    "sessionbus-dsh": "launcher.mjs",
+    "sessionbus-dsh-install": "bin.mjs"
+  },
+  "files": ["README.md", "docs/LANE-WITHOUT-TUI.md", "plugin.cjs", "launcher.mjs", "bin.mjs", "install.mjs"],
+  "scripts": {
+    "test": "node --test plugin.test.cjs install.test.mjs launcher.test.mjs package.test.cjs rename.test.mjs"
+  },
+  "dependencies": {
+    "@antst/dsh-file-uploads-none": "0.1.0-alpha.18",
+    "@sessionbus/kit": "0.1.0-pre.3"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/cordis-plugin-loader": "^1.0.3",
+    "@deepseek-ai/dsh-agent": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-api-session-controller": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-cmdline": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-commands": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-launch-environment": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-llm": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-permission-presets": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-session": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-session-title": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-tools": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-workspace": ">=0.1.5-rc.2"
+  },
+  "publishConfig": { "access": "public" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/antst/sessionbus-dsh.git"
+  }
+}

package/plugin.cjs

@@ -0,0 +1,388 @@
+"use strict";
+
+const os = require("node:os");
+const path = require("node:path");
+const kit = require("@sessionbus/kit");
+const version = require("./package.json").version;
+const { ACTIONS } = kit;
+
+// Match the MCP tool's closed union; the public kit validates each action.
+function argumentSchema() {
+  const properties = {};
+  for (const field of ["session_id", "host", "message", "target", "group", "product", "name", "resume_session_id", "notify_target", "input", "run_id"]) properties[field] = { type: "string" };
+  for (const field of ["targets", "extra_groups"]) properties[field] = { type: "array", items: { type: "string" } };
+  for (const field of ["persistent", "notify", "forget"]) properties[field] = { type: "boolean" };
+  for (const field of ["auto_close_ms", "timeout_ms"]) properties[field] = { type: "integer" };
+  properties.idle_message = { type: "string", enum: ["stage", "run"] };
+  properties.trace = { type: "string", enum: ["off", "events", "content"] };
+  properties.mode = { type: "string", enum: ["off", "events", "content"] };
+  const open = {};
+  for (const field of ["cwd", "permission_mode", "model", "reasoning_effort"]) open[field] = { type: "string" };
+  open.arguments = { type: "array", items: { type: "string" } };
+  properties.open = { type: "object", additionalProperties: false, properties: open };
+  return { type: "object", additionalProperties: false, properties, description: "Use only the fields listed for the selected action in the tool description. send has no summary field; put the complete content in message." };
+}
+
+function assertKnownArguments(value, schema, location = "arguments") {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`sessionbus ${location} must be an object`);
+  for (const field of Object.keys(value)) {
+    if (!Object.hasOwn(schema.properties, field)) throw new Error(`sessionbus ${location}.${field} is not supported`);
+    const property = schema.properties[field];
+    if (property.type === "object") assertKnownArguments(value[field], property, `${location}.${field}`);
+  }
+}
+
+const name = "sessionbus-dsh";
+const productPattern = /^[a-z0-9][a-z0-9-]{0,31}$/u;
+const inject = [
+  "agents", "appReady", "appExit", "commands", "permissionPresets",
+  "sessionController", "sessions", "sessionTitle", "tools",
+];
+function deferred() {
+  let resolve, reject;
+  const promise = new Promise((yes, no) => { resolve = yes; reject = no; });
+  return { promise, resolve, reject };
+}
+
+function text(value) {
+  return typeof value === "string" && value.length > 0 && value.trim() === value && !/[\0\r\n]/u.test(value);
+}
+
+function clean(error) {
+  return String(error?.message || error || "DSH plugin failed").replace(/[\0\r\n]/gu, " ").slice(0, 4096);
+}
+
+function readConfiguration(ctx, config = {}, ambient = process.env) {
+  if (config.product === undefined) throw new Error("product is required; re-run sessionbus-dsh-install --product <name> <profile>");
+  if (typeof config.product !== "string" || !productPattern.test(config.product)) throw new Error("product must match ^[a-z0-9][a-z0-9-]{0,31}$");
+  const launch = ctx.launchEnvironment || ctx.get?.("launchEnvironment");
+  const value = (key) => {
+    if (launch) return launch.get(key)?.value;
+    return Object.hasOwn(ambient, key) ? ambient[key] : undefined;
+  };
+  const token = value("SESSIONBUS_LAUNCH_TOKEN");
+  delete process.env.SESSIONBUS_LAUNCH_TOKEN;
+  const mode = token === undefined ? "peer" : "lane";
+  if (config.mode !== undefined && config.mode !== mode) throw new Error(`mode ${config.mode} conflicts with launch environment`);
+  let groups = mode === "lane" ? [] : Object.hasOwn(config, "groups") ? config.groups : JSON.parse(value("SESSIONBUS_GROUPS") || "[]");
+  if (!Array.isArray(groups) || groups.some((group) => !text(group)) || new Set(groups).size !== groups.length) throw new Error("groups are invalid");
+  const socket = Object.hasOwn(config, "socket") ? config.socket : value("SESSIONBUS_SOCKET") || path.join(value("XDG_STATE_HOME") || path.join(value("HOME") || os.homedir(), ".local/state"), "sessionbus/run/presence.sock");
+  const localKey = Object.hasOwn(config, "local_key") ? config.local_key : value("SESSIONBUS_LOCAL_KEY");
+  if (!text(socket) || localKey !== undefined && !text(localKey)) throw new Error("connection settings are invalid");
+  return { settings: { mode, product: config.product, groups: [...groups], socket, localKey }, token };
+}
+
+function captureContext(ctx) {
+  const services = Object.fromEntries(inject.map((service) => [service, ctx[service]]));
+  let launchEnvironment;
+  try { launchEnvironment = ctx.launchEnvironment || ctx.get?.("launchEnvironment"); } catch {}
+  const fiber = ctx.fiber;
+  return {
+    active: () => fiber?.uid !== null,
+    context: {
+      ...services,
+      launchEnvironment,
+      on: ctx.on.bind(ctx),
+      effect: ctx.effect.bind(ctx),
+    },
+  };
+}
+
+function settings(ctx, config = {}, ambient = process.env) {
+  return readConfiguration(ctx, config, ambient).settings;
+}
+
+function connectionEnvironment(config, token) {
+  return {
+    SESSIONBUS_SOCKET: config.socket,
+    ...(config.localKey === undefined ? {} : { SESSIONBUS_LOCAL_KEY: config.localKey }),
+    ...(token === undefined ? {} : { SESSIONBUS_LAUNCH_TOKEN: token }),
+  };
+}
+
+function nativeName(value) {
+  const at = value.lastIndexOf("@");
+  return at < 0 ? value : value.slice(0, at);
+}
+
+function textOf(message) {
+  return Array.isArray(message?.content) ? message.content.filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text).join("") : "";
+}
+
+function terminal(reason) {
+  const native_stop_reason = reason?.kind;
+  if (native_stop_reason === "completed") return { outcome: "completed", native_stop_reason };
+  if (native_stop_reason === "aborted" || native_stop_reason === "interrupted") return { outcome: "interrupted", native_stop_reason };
+  if (["blocked", "error", "max-tokens"].includes(native_stop_reason)) return { outcome: "failed", native_stop_reason };
+  throw new Error(`unknown DSH turn end reason ${JSON.stringify(reason)}`);
+}
+
+class NativeSession {
+  constructor(ctx, createUserMessage) {
+    this.ctx = ctx;
+    this.createUserMessage = createUserMessage;
+    this.receipts = new Map();
+    this.removeEvents = ctx.on("session/event", (session, event) => this.event(session, event), { global: true });
+  }
+
+  async open(request) {
+    const options = request.open || {};
+    let resolved;
+    if (request.resume_session_id) {
+      resolved = await this.ctx.sessionController.resolveAgent(request.resume_session_id);
+    } else {
+      const created = await this.ctx.sessionController.create(options.cwd ? { cwd: options.cwd } : {});
+      resolved = await this.ctx.sessionController.resolveAgent(created.sessionId);
+    }
+    if (resolved.error) throw resolved.error;
+    const agent = resolved.agent;
+    const expected = request.resume_session_id || agent.id;
+    if (agent.id !== expected || agent.session.id !== expected) throw new Error("DSH resolved a different native session");
+    if (options.cwd !== undefined && agent.session.header.cwd !== options.cwd) throw new Error("DSH resolved a different native cwd");
+    await this.ctx.sessionController.rename({ sessionId: agent.id, title: nativeName(request.name) });
+    if (options.model !== undefined || options.reasoning_effort !== undefined) {
+      const model = options.model || `${agent.options?.provider || ""}/${agent.options?.model || ""}`;
+      const slash = model.indexOf("/");
+      if (slash < 1 || slash === model.length - 1) throw new Error(`unsupported value model=${model}`);
+      await this.ctx.sessionController.selectModel({ sessionId: agent.id, provider: model.slice(0, slash), model: model.slice(slash + 1), ...(options.reasoning_effort === undefined ? {} : { reasoningEffort: options.reasoning_effort }) });
+    }
+    if (options.permission_mode !== undefined) {
+      if (!this.ctx.permissionPresets.names.includes(options.permission_mode)) throw new Error(`unsupported value permission_mode=${options.permission_mode}`);
+      this.ctx.permissionPresets.set(agent.session, options.permission_mode);
+    }
+    await this.ctx.sessions.flush(agent.session);
+    this.agent = agent;
+    return { session_id: agent.id };
+  }
+
+  message(body) {
+    return this.createUserMessage({ content: [{ type: "text", text: body }], source: { kind: "plugin", plugin: name, form: "relay" } });
+  }
+
+  receipt(message, session, cancel) {
+    if (cancel?.aborted) throw cancel.reason || new Error("cancelled");
+    const accepted = { ...deferred(), session };
+    const abort = () => accepted.reject(cancel.reason || new Error("cancelled"));
+    cancel?.addEventListener("abort", abort, { once: true });
+    accepted.promise.catch(() => {});
+    accepted.close = () => {
+      cancel?.removeEventListener("abort", abort);
+      if (this.receipts.get(message.id) === accepted) this.receipts.delete(message.id);
+    };
+    this.receipts.set(message.id, accepted);
+    return accepted;
+  }
+
+  event(session, event) {
+    if (event.type === "agent/inbox/spliced") {
+      for (const message of event.data.inserted || []) {
+        const receipt = this.receipts.get(message.id);
+        if (receipt?.session === session) receipt.resolve();
+      }
+    }
+    const run = this.active;
+    if (!run || session !== this.agent?.session) return;
+    if (event.type === "turn/start") run.openTurn = event.data.turn;
+    if (event.type === "user/message" && event.data.id === run.message.id) {
+      if (!Number.isSafeInteger(run.openTurn)) {
+        run.endError = new Error("DSH consumed input outside a turn");
+        return;
+      }
+      run.turn = run.openTurn;
+    }
+    if (event.type === "assistant/message" && run.turn === event.data.turn) run.output += textOf(event.data.message);
+    if (event.type === "turn/end" && run.turn === event.data.turn) {
+      try { run.end = terminal(event.data.reason); }
+      catch (error) { run.endError = error; }
+    }
+  }
+
+  async run(cancel, token, input) {
+    if (token.Interrupted()) return { outcome: "interrupted", result: "" };
+    const message = this.message(input);
+    const record = { message, openTurn: null, turn: null, output: "", cancelled: deferred() };
+    const receipt = this.receipt(message, this.agent.session, cancel);
+    this.active = record;
+    token.Native = record;
+    record.cancelled.promise.catch(() => {});
+    const abort = () => { record.cancelled.reject(cancel.reason || new Error("cancelled")); this.receipts.get(message.id)?.reject(cancel.reason || new Error("cancelled")); };
+    cancel.addEventListener("abort", abort, { once: true });
+    try {
+      try { this.agent.followup(message); }
+      catch (error) { receipt.reject(error); throw error; }
+      await receipt.promise;
+      const idle = this.agent.whenIdle();
+      idle.catch(() => {});
+      await Promise.race([idle, record.cancelled.promise]);
+      if (record.endError) throw record.endError;
+      if (record.end) return { ...record.end, result: record.output };
+      if (record.cancelReason) return { outcome: "interrupted", native_stop_reason: record.cancelReason, result: record.output };
+      throw new Error("DSH reached idle without turn/end");
+    } finally {
+      receipt.close();
+      cancel.removeEventListener("abort", abort);
+      if (this.active === record) this.active = null;
+      if (token.Native === record) token.Native = null;
+    }
+  }
+
+  interrupt(_cancel, token) {
+    if (token.Native) {
+      token.Native.cancelReason = "aborted:user";
+      this.agent.cancel({ kind: "user" }, { keepInbox: true });
+    }
+  }
+
+  async deliver(cancel, request, agent = this.agent) {
+    const message = this.message(request.body);
+    if (agent.status === "running") {
+      const receipt = this.receipt(message, agent.session, cancel);
+      try {
+        try { agent.steer(message); }
+        catch (error) { receipt.reject(error); throw error; }
+        await receipt.promise;
+      } finally { receipt.close(); }
+    } else {
+      const event = await agent.session.append("user/message", message, { surfaceOp: "append" });
+      if (event?.type !== "user/message" || event.data?.id !== message.id) throw new Error("DSH did not commit the delivered message");
+    }
+    return { disposition: "injected" };
+  }
+
+  async close() {
+    if (!this.agent) return;
+    if (this.agent.status === "running") this.agent.cancel({ kind: "disposed" });
+    await this.agent.whenIdle();
+    await this.ctx.sessions.flush(this.agent.session);
+    this.removeEvents();
+  }
+}
+
+function identity(ctx, agent, product, groups, title) {
+  const sessionID = String(agent?.session?.id || agent?.id || "");
+  const cwd = agent?.session?.header?.cwd;
+  if (!text(sessionID) || !text(cwd)) throw new Error("DSH root identity is incomplete");
+  const current = title === undefined ? ctx.sessionTitle.get(agent.session)?.title : title;
+  const provider = agent.options?.provider;
+  const model = agent.options?.model;
+  return { product, session_id: sessionID, name: text(current) ? current : sessionID, groups: [...groups], info: { cwd, ...(text(provider) && text(model) ? { model: `${provider}/${model}` } : {}) } };
+}
+
+function createRuntime(ctx, config, dependencies, prepared) {
+  const configured = prepared || readConfiguration(ctx, config, dependencies.ambient);
+  const values = configured.settings;
+  const active = dependencies.active || (() => true);
+  let launchToken = configured.token;
+  const native = new NativeSession(ctx, dependencies.createUserMessage);
+  const peers = new Map();
+  let worker;
+  let workerExit = Promise.resolve();
+  let ready = false;
+  let warned = false;
+  const warn = (error) => { if (active() && !warned) { warned = true; dependencies.stderr(`sessionbus: ${clean(error)}\n`); } };
+  const root = (agent) => ctx.agents.roots().includes(agent);
+  const present = (agent) => {
+    if (values.mode !== "peer" || !ready || !root(agent) || peers.has(agent)) return;
+    try {
+      const current = identity(ctx, agent, values.product, values.groups);
+      const peer = dependencies.connectPeer(current, (cancel, request) => native.deliver(cancel, request, agent), connectionEnvironment(values));
+      peers.set(agent, { peer, identity: current, rehello: Promise.resolve() });
+    } catch (error) { warn(error); }
+  };
+  const forget = (agent) => { peers.get(agent)?.peer.shutdown(); peers.delete(agent); };
+  let removeCreated = () => {}, removeDisposed = () => {}, removeTitle = () => {};
+  if (values.mode === "peer") {
+    removeCreated = ctx.on("agent/created", ({ agent }) => present(agent));
+    removeDisposed = ctx.on("agent/disposed", ({ agent }) => forget(agent));
+    removeTitle = ctx.on("session/event", (session, event) => {
+      if (event.type !== "session/title") return;
+      const agent = ctx.agents.get(session.id);
+      const record = peers.get(agent);
+      if (!record || agent.session !== session) return;
+      const next = identity(ctx, agent, values.product, values.groups, event.data.title);
+      record.identity = next;
+      record.rehello = record.rehello.then(() => record.peer.rehello({ name: next.name, info: next.info })).catch(warn);
+    }, { global: true });
+  }
+  const caller = (agent) => worker && native.agent === agent ? worker.caller : peers.get(agent)?.peer.caller;
+  const argumentsSchema = argumentSchema();
+  const execute = (argumentsValue, execution) => {
+    const client = caller(execution?.agent);
+    if (!client) throw new Error("sessionbus requires an exact live DSH root");
+    const args = argumentsValue.arguments || {};
+    assertKnownArguments(args, argumentsSchema);
+    return client.action(argumentsValue.action, args);
+  };
+  const removeTool = ctx.tools.register(dependencies.defineTool({
+    name: "sessionbus",
+    description: "List, message, spawn and control Sessionbus sessions. Use trace mode off, events or content to configure live parent tracing for a direct child; spawn trace sets its initial mode.",
+    parameters: { action: { type: "string", enum: ACTIONS, required: true }, arguments: argumentsSchema },
+    output: { schema: { type: "object", additionalProperties: true, properties: {} }, render: (_args, result) => [{ type: "text", text: JSON.stringify(result) }] },
+    execute,
+  }));
+  const removeCommand = ctx.commands.register({
+    name: "sessionbus",
+    description: "list sessionbus sessions",
+    handler: async (invocation) => ({ kind: "success", text: JSON.stringify(await execute({ action: "list", arguments: {} }, { agent: invocation.agent })) }),
+  });
+  const start = () => {
+    ready = true;
+    if (values.mode === "lane") {
+      const environment = connectionEnvironment(values, launchToken);
+      launchToken = undefined;
+      worker = dependencies.serveWorker({
+        hello: () => ({ product: values.product, version, supported_open_fields: ["cwd", "permission_mode", "model", "reasoning_effort"], extra_arguments: [] }),
+        open: (_cancel, request) => native.open(request),
+        run: (cancel, token, input) => native.run(cancel, token, input),
+        interrupt: (cancel, token) => native.interrupt(cancel, token),
+        deliver: (cancel, request) => native.deliver(cancel, request),
+        close: () => native.close(),
+      }, environment);
+      workerExit = worker.closed.then(async () => {
+        const failure = await worker.serving?.catch((error) => error);
+        if (!active()) return;
+        if (failure && !worker.opened) { warn(failure); ctx.appExit(1); } else ctx.appExit(0);
+      });
+    } else {
+      for (const agent of ctx.agents.roots()) present(agent);
+    }
+  };
+  const removeReady = ctx.appReady.onReady(start);
+  const close = () => {
+    removeReady(); removeCreated(); removeDisposed(); removeTitle(); removeCommand(); removeTool();
+    for (const agent of peers.keys()) forget(agent);
+    worker?.shutdown(); native.removeEvents();
+  };
+  ctx.effect(() => close, "sessionbus-dsh.lifecycle");
+  return { close, execute, native, peers, settings: values, start, get worker() { return worker; }, get workerExit() { return workerExit; } };
+}
+
+async function activate(ctx, config = {}, dependencies = {}, prepared) {
+  const configured = prepared || readConfiguration(ctx, config, dependencies.ambient);
+  const [{ createUserMessage }, { defineTool }] = await Promise.all([
+    dependencies.createUserMessage ? { createUserMessage: dependencies.createUserMessage } : (dependencies.importLLM || (() => import("@deepseek-ai/dsh-llm")))(),
+    dependencies.defineTool ? { defineTool: dependencies.defineTool } : (dependencies.importTools || (() => import("@deepseek-ai/dsh-tools")))(),
+  ]);
+  if (dependencies.active && !dependencies.active()) return;
+  return createRuntime(ctx, config, { ...kit, active: () => true, stderr: (line) => process.stderr.write(line), ...dependencies, createUserMessage, defineTool }, configured);
+}
+
+function apply(ctx, config = {}, dependencies = {}) {
+  let captured, prepared;
+  try {
+    captured = captureContext(ctx);
+    prepared = readConfiguration(captured.context, config, dependencies.ambient);
+  } catch (error) {
+    (dependencies.stderr || ((line) => process.stderr.write(line)))(`sessionbus: ${clean(error)}\n`);
+    try { ctx.appExit(1); } catch {}
+    return;
+  }
+  const runtimeDependencies = { stderr: (line) => process.stderr.write(line), ...dependencies, active: captured.active };
+  void activate(captured.context, config, runtimeDependencies, prepared).catch((error) => {
+    if (!captured.active()) return;
+    runtimeDependencies.stderr(`sessionbus: ${clean(error)}\n`);
+    captured.context.appExit(1);
+  });
+}
+
+module.exports = { ACTIONS, NativeSession, activate, apply, connectionEnvironment, createRuntime, identity, inject, name, settings, terminal };