@rebon/cli-linux-arm64 1.18.0 → 1.19.1

package/bin/compose-runtime/src/bridge.mjs

@@ -72,6 +72,25 @@ export function seat(name, method, params = null, options = {}) {
   return require(`seat ${JSON.stringify(name)}`, via).seat(name, method, params, call);
 }
 
+/// Calls a kernel seat as the plugin `via` belongs to, whatever call is in
+/// flight.
+///
+/// `seat()` speaks for the call being answered, which is right for code
+/// serving that call. This is for the composition acting *on behalf of one
+/// entry* while answering someone else — the configuration editor
+/// persisting an entry's own config while a settings form asked for it.
+/// The seat then sees that entry as the caller, so the entry's own ceiling,
+/// not the composition's, decides what the call may do.
+export function seatFor(via, name, method, params = null) {
+  const session = sessionOf(via);
+  if (session === undefined) {
+    throw new Error(
+      `[NO_CALL_CONTEXT] seat ${JSON.stringify(name)} cannot be reached for this entry: it is not attached to a session`,
+    );
+  }
+  return session.seat(name, method, params);
+}
+
 /// Invokes one rebon core tool on the session this call belongs to.
 ///
 /// Three gates stand in front of it and only the first is here: the plugin's

package/bin/compose-runtime/src/entries.mjs

@@ -0,0 +1,53 @@
+// The realm's entry table, as the dsh Loader vocabulary sees it.
+//
+// One view per mounted entry, shaped like a `cordis-plugin-loader` entry
+// (`id`, `options.{id,name,config}`, `fiber`), so the services that answer
+// for the loader (`loader-runtime.mjs`) hand upstream code the shape it
+// reads. `realm.mjs` writes it as entries mount and leave; nothing else
+// does. Its own module so both sides import it without importing each other.
+
+/** Mounted entries by plugin id, in load order. */
+export const entries = new Map();
+
+let inflight = 0;
+let waiters = [];
+
+/// Records one mount for its whole duration, so `settled()` can wait it out.
+export async function mounting(work) {
+  inflight += 1;
+  try {
+    return await work();
+  } finally {
+    inflight -= 1;
+    if (inflight === 0) {
+      const ready = waiters;
+      waiters = [];
+      for (const resolve of ready) resolve();
+    }
+  }
+}
+
+/// Resolves once nothing is mounting.
+export function settled() {
+  if (inflight === 0) return Promise.resolve();
+  return new Promise((resolve) => waiters.push(resolve));
+}
+
+/// The loader-shaped view of one mounted entry.
+export function track(pluginId, request, fiber) {
+  const view = {
+    id: pluginId,
+    options: { id: pluginId, name: request.name ?? pluginId, config: request.config ?? undefined },
+    fiber,
+    // Where the entry's module is, for what reads its package (its client
+    // half): the load request's package root and module.
+    root: request.root,
+    module: request.entry,
+  };
+  entries.set(pluginId, view);
+  return view;
+}
+
+export function untrack(pluginId) {
+  entries.delete(pluginId);
+}

package/bin/compose-runtime/src/loader-runtime.mjs

@@ -0,0 +1,130 @@
+// The composition is DeepSeek Harness's Loader, as far as a plugin can tell.
+//
+// In dsh a profile (`cordis.yml` plus its patches) is loaded by
+// `cordis-plugin-loader`, and the boot packages built on it — the
+// configuration editor, the profile context — are what upstream plugins
+// reach when they need to know what is mounted or to change its config.
+// `@deepseek-ai/dsh-settings` is the one that matters most: its settings
+// forms are entry configs, read through `ctx.configEditor` and written back
+// through it.
+//
+// In rebon the profile is `kernelPlugins` and the loader is the plugin plane:
+// rebon reads the entry list, the realm mounts one entry per `plugin/load`.
+// So the three services here answer the dsh vocabulary from the realm's own
+// table rather than mounting dsh's loader beside it — a second loader would
+// be a second answer to "what is running":
+//
+//   * `loader` — the mounted entries, and `await()` for the loads in flight;
+//   * `configEditor` — an entry's config as two layers (nothing inherited;
+//     the user's layer is its `kernelPlugins` row), and `edit`, which checks
+//     the next config against the plugin's schema, persists it as the entry
+//     itself through the `settings` seat, and commits its volatile fields
+//     into the running plugin the way dsh's loader does;
+//   * `profileContext` — the profile's home, `<config home>/dsh`, rebon's
+//     counterpart of `DSH_HOME`.
+//
+// What is deliberately not here: the loader's create/remove/reorder API.
+// Which entries exist is rebon's composition, changed by installing and
+// configuring, not by a plugin.
+import { Context, Service, resolveConfig } from 'cordis';
+import { deepEqual, updateVolatile, volatileEntries } from 'cosmokit';
+import { seatFor } from './bridge.mjs';
+import { entries, settled } from './entries.mjs';
+
+class LoaderError extends Error {
+  constructor(code, message) {
+    super(`${code} ${message}`);
+    this.code = code;
+    this.name = 'LoaderError';
+  }
+}
+
+const clone = (value) => (value === undefined ? {} : structuredClone(value));
+
+export class RebonLoader extends Service {
+  constructor(ctx) {
+    super(ctx, 'loader');
+  }
+
+  /// Every mounted entry, in load order.
+  entries() {
+    return [...entries.values()];
+  }
+
+  /// Resolves once no entry is being mounted.
+  await() {
+    return settled();
+  }
+}
+
+export class RebonConfigEditor extends Service {
+  constructor(ctx, profile) {
+    super(ctx, 'configEditor');
+    this.profile = profile ?? {};
+  }
+
+  /// The file a person edits by hand, when rebon named one.
+  get documentPath() {
+    return typeof this.profile.documentPath === 'string' ? this.profile.documentPath : undefined;
+  }
+
+  entries() {
+    return [...entries.values()];
+  }
+
+  /// dsh's two layers per entry. Rebon has one: what the entry's row says.
+  configuration() {
+    return this.entries().map((entry) => ({
+      entry,
+      inherited: {},
+      override: clone(entry.options.config),
+    }));
+  }
+
+  /// Validates, persists and applies an entry's next config.
+  ///
+  /// The order is dsh's: a config the plugin's own schema refuses is
+  /// refused before anything is written, and the running plugin changes
+  /// only after rebon has the new config.
+  ///
+  /// What changes in the running plugin is what dsh's loader changes without
+  /// a remount: the `.volatile()` fields, committed into the references the
+  /// plugin reads them through, and announced as `loader/volatile-update` to
+  /// that plugin alone. An ordinary field is a remount in dsh. Here it waits
+  /// for rebon to load the entry again: what an entry registers is reported
+  /// once per load, so a plugin restarted in place could not re-register.
+  /// Settings forms only ever edit volatile fields.
+  async edit(entry, change) {
+    if (entries.get(entry?.id) !== entry || entry.fiber === undefined) {
+      throw new LoaderError('[UNKNOWN_ENTRY]', 'that configuration entry is no longer mounted');
+    }
+    const fiber = entry.fiber;
+    if (fiber.state !== 2) {
+      throw new LoaderError('[ENTRY_INACTIVE]', `${entry.id} is not active`);
+    }
+    const next = change(clone(entry.options.config), {});
+    const candidate = resolveConfig(fiber.runtime, next);
+    await seatFor(fiber.ctx, 'settings', 'entryConfig', { config: next });
+    entry.options.config = next;
+    if (!deepEqual(fiber.config, candidate, true)) return;
+    const paths = volatileEntries(fiber.config).flatMap(({ path, ref }) => {
+      const source = path.reduce((value, key) => Reflect.get(value, key), candidate);
+      if (deepEqual(ref.get(), source.get(), true)) return [];
+      updateVolatile(ref, source);
+      return [path];
+    });
+    if (paths.length === 0) return;
+    const self = Object.create(fiber.ctx);
+    self[Context.filter] = (owner) => owner.fiber?.uid === fiber.uid;
+    fiber.ctx.emit(self, 'loader/volatile-update', paths);
+  }
+}
+
+export class RebonProfileContext extends Service {
+  constructor(ctx, profile) {
+    super(ctx, 'profileContext');
+    this.home = profile?.home;
+    this.name = profile?.name ?? 'rebon';
+    this.dir = this.home;
+  }
+}

package/bin/compose-runtime/src/plugin.mjs

@@ -25,8 +25,13 @@ export async function activate(api, config = {}) {
   });
 
   const { withCall } = await import('./bridge.mjs');
-  const { builtinSeats, createRealm, mounted, reportFor } = await import('./realm.mjs');
-  await createRealm({ web: config.web ?? null, entries: config.entries ?? [] });
+  const { builtinSeats, createRealm, mounted, realm, reportFor } = await import('./realm.mjs');
+  const { remote, REMOTE_EVENTS } = await import('./remote.mjs');
+  await createRealm({
+    web: config.web ?? null,
+    entries: config.entries ?? [],
+    profile: config.profile ?? null,
+  });
 
   // Registered before any entry is loaded, so an entry claiming the same
   // service name hits the registrar's refusal rather than replacing this.
@@ -40,6 +45,9 @@ export async function activate(api, config = {}) {
     if (kind === 'list') {
       return { plugins: mounted(), builtin: builtinSeats() };
     }
+    if (kind === 'remote') {
+      return remote(String(request?.endpoint ?? ''), request?.args ?? {});
+    }
     if (kind === 'report') {
       const pluginId = String(request?.pluginId ?? '');
       const report = reportFor(pluginId);
@@ -54,6 +62,27 @@ export async function activate(api, config = {}) {
     error.code = '[UNKNOWN_CONTROL]';
     throw error;
   }));
+
+  // The Host events a dsh client hears, put on rebon's event plane. They are
+  // the composition's own facts — a settings form changing under a page —
+  // and nothing is asking when they happen, so they go out through the
+  // session the control plugin is attached to rather than an inbound call.
+  const sessions = new Set();
+  api.scope((scope) => {
+    sessions.add(scope);
+    return () => sessions.delete(scope);
+  });
+  for (const event of REMOTE_EVENTS) {
+    realm().ctx.on(event, (...args) => {
+      for (const scope of sessions) {
+        void scope.publish(REMOTE_EVENT_TOPIC, { event, args: JSON.parse(JSON.stringify(args)) }).catch(() => {});
+        break;
+      }
+    });
+  }
 }
 
+/** The topic forwarded Host events are published on. */
+export const REMOTE_EVENT_TOPIC = 'compose:remote-event';
+
 export default activate;

package/bin/compose-runtime/src/probe.mjs

@@ -1,7 +1,8 @@
-// Mounts one Cordis plugin package on a realm of its own and says what it
+// Mounts Cordis plugin packages on a realm of their own and says what each
 // registered, or why it could not mount.
 //
-//   node --permission --allow-fs-read=... probe.mjs <package root> <entry> [config JSON]
+//   rebon-verve --permission --allow-fs-read=... probe.mjs <package root> <entry> [config JSON]
+//   rebon-verve --permission --allow-fs-read=... probe.mjs --bundle <bundle root> [configs JSON]
 //
 // This is how rebon reads a DeepSeek Harness package published to npm, which
 // carries no rebon manifest: the package is mounted against rebon's own
@@ -10,11 +11,23 @@
 // needs a service rebon does not offer fails here with that service's name —
 // which is the compatibility answer, given before anything is installed.
 //
-// The caller runs it under Node's permission model (the package and this
-// runtime readable, nothing writable, no processes): the package is someone
-// else's code, executing for the first time.
+// A *bundle* is several packages installed into one `node_modules` and run in
+// one realm, because that is how dsh packages reach each other: a seam
+// implementation (`dsh-fs-local`) provides the service a consumer
+// (`dsh-tool-fs`) injects. Its members are the rows of the bundle's dsh
+// patch (`package.json` `dsh.bundle.patch`, the format dsh's own profile
+// bundles use), or, without one, its dependencies that are Cordis plugins.
+// They are mounted in the order their injections allow, and each member's
+// report says which realm services it provided, so rebon can keep that order
+// when it loads them.
+//
+// The caller runs it under the permission model (the packages and this
+// runtime readable, nothing writable, no processes): the code is someone
+// else's, executing for the first time.
 //
 // One line of JSON on stdout, whatever happens.
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { installModuleResolution } from './resolve.mjs';
@@ -28,6 +41,19 @@ function injects(plugin) {
   return { required: [], optional: [] };
 }
 
+/// What one mounted sink reports, in the shape the manifest is written from.
+function registered(sink) {
+  const loaded = sink.loaded();
+  return {
+    tools: loaded.tools.map((tool) => ({ name: tool.name, description: tool.description ?? '' })),
+    services: loaded.services,
+    llmProviders: loaded.llmProviders,
+    eventTopics: loaded.eventTopics,
+    commands: loaded.commands.map((command) => ({ name: command.name, description: command.description })),
+    report: sink.report(),
+  };
+}
+
 async function probe(root, entry, config) {
   installModuleResolution();
   const { cordisPluginOf } = await import('./loader.mjs');
@@ -49,27 +75,177 @@ async function probe(root, entry, config) {
   const base = { name: plugin.name ?? null, inject: wanted, seats };
   try {
     const sink = await mountEntry({ pluginId: 'probe', config }, plugin, { probe: true });
-    const loaded = sink.loaded();
-    return {
-      ok: true,
-      ...base,
-      tools: loaded.tools.map((tool) => ({ name: tool.name, description: tool.description ?? '' })),
-      services: loaded.services,
-      llmProviders: loaded.llmProviders,
-      eventTopics: loaded.eventTopics,
-      commands: loaded.commands.map((command) => ({ name: command.name, description: command.description })),
-      report: sink.report(),
-    };
+    return { ok: true, ...base, ...registered(sink) };
   } catch (cause) {
     return { ok: false, ...base, missing, code: cause?.code ?? '[ACTIVATE_FAILED]', error: String(cause?.message ?? cause) };
   }
 }
 
+// ---- bundles ------------------------------------------------------------
+
+const readJson = (file) => JSON.parse(fs.readFileSync(file, 'utf8'));
+
+/// The module a package runs: `main`, else the `.` export, else `index.js` —
+/// the rule rebon's installer uses (`dsh_npm::entry_of`).
+function entryOf(manifest) {
+  if (typeof manifest.main === 'string') return manifest.main.replace(/^\.\//, '');
+  const dot = manifest.exports?.['.'];
+  const fromExports = typeof dot === 'string' ? dot : (dot?.default ?? dot?.import);
+  return typeof fromExports === 'string' ? fromExports.replace(/^\.\//, '') : 'index.js';
+}
+
+/// Whether a parsed config holds a dsh `!!js` expression anywhere.
+function holdsExpression(value) {
+  if (value === null || typeof value !== 'object') return false;
+  if (Object.hasOwn(value, '__jsExpr')) return true;
+  return Object.values(value).some(holdsExpression);
+}
+
+/// The rows a bundle's dsh patch inserts, with later `{id, config}` rows
+/// replacing a row's config the way dsh applies a patch layer.
+function patchRows(root, manifest) {
+  const patch = manifest.dsh?.bundle?.patch;
+  if (typeof patch !== 'string') return undefined;
+  // dsh writes its patches in YAML and parses them with the `yaml` package,
+  // which every bundle that carries one installs; `!!js` values are dsh
+  // Loader expressions and are kept as markers, not evaluated.
+  const yaml = createRequire(path.join(root, 'package.json'))('yaml');
+  const text = fs.readFileSync(path.resolve(root, patch), 'utf8');
+  const doc = yaml.parse(text, {
+    customTags: [{ tag: 'tag:yaml.org,2002:js', resolve: (source) => ({ __jsExpr: source }) }],
+  });
+  const rows = [];
+  for (const op of Array.isArray(doc) ? doc : []) {
+    if (Array.isArray(op?.insert)) {
+      for (const row of op.insert) {
+        if (row && typeof row.name === 'string') rows.push({ id: row.id ?? row.name, name: row.name, config: row.config, disabled: row.disabled });
+      }
+    } else if (op && typeof op.id === 'string' && Object.hasOwn(op, 'config')) {
+      const row = rows.find((candidate) => candidate.id === op.id);
+      if (row) row.config = op.config;
+    } else if (op && typeof op.remove === 'string') {
+      const index = rows.findIndex((candidate) => candidate.id === op.remove);
+      if (index >= 0) rows.splice(index, 1);
+    }
+  }
+  return rows;
+}
+
+/// The members of a bundle: its patch rows, or its dependencies.
+function bundleMembers(root) {
+  const manifest = readJson(path.join(root, 'package.json'));
+  const rows = patchRows(root, manifest);
+  if (rows !== undefined) return rows;
+  return Object.keys(manifest.dependencies ?? {}).map((name) => ({ id: name.split('/').pop(), name }));
+}
+
+async function probeBundle(root, overrides = {}) {
+  installModuleResolution();
+  const { cordisPluginOf } = await import('./loader.mjs');
+  const { createRealm, mountEntry, builtinSeats } = await import('./realm.mjs');
+  const live = await createRealm({});
+  const skipped = [];
+  const candidates = [];
+  for (const row of bundleMembers(root)) {
+    const dir = path.join(root, 'node_modules', ...row.name.split('/'));
+    let manifest;
+    try {
+      manifest = readJson(path.join(dir, 'package.json'));
+    } catch {
+      skipped.push({ id: row.id, name: row.name, code: '[NOT_INSTALLED]', error: `${row.name} is not installed in the bundle` });
+      continue;
+    }
+    if (row.disabled === true) {
+      skipped.push({ id: row.id, name: row.name, code: '[DISABLED]', error: `${row.id} is disabled in the bundle` });
+      continue;
+    }
+    if (holdsExpression(row.disabled)) {
+      skipped.push({ id: row.id, name: row.name, code: '[CONFIG_EXPRESSION]', error: `whether ${row.id} runs is a dsh Loader expression, which rebon does not evaluate` });
+      continue;
+    }
+    const config = Object.hasOwn(overrides, row.id) ? overrides[row.id] : row.config;
+    if (holdsExpression(config)) {
+      skipped.push({ id: row.id, name: row.name, code: '[CONFIG_EXPRESSION]', error: `${row.id}'s config is a dsh Loader expression, which rebon does not evaluate` });
+      continue;
+    }
+    const entry = path.posix.join('node_modules', row.name, entryOf(manifest));
+    let module;
+    try {
+      module = await import(pathToFileURL(path.join(root, entry)).href);
+    } catch (cause) {
+      skipped.push({ id: row.id, name: row.name, code: '[ENTRY_FAILED]', error: String(cause?.message ?? cause) });
+      continue;
+    }
+    const plugin = cordisPluginOf(module);
+    // A dependency that is a library, not a plugin, is simply not a member.
+    if (plugin === undefined) continue;
+    candidates.push({ ...row, entry, config, plugin, inject: injects(plugin) });
+  }
+
+  // Every name any member injects, so what each one provided can be read off
+  // the realm before and after it mounts.
+  const watched = [...new Set(candidates.flatMap((member) => [...member.inject.required, ...member.inject.optional]))];
+  const present = () => new Set(watched.filter((name) => live.ctx.get(name) !== undefined));
+  const entries = [];
+  const failed = new Set();
+  let progress = true;
+  while (progress) {
+    progress = false;
+    for (const member of candidates) {
+      if (failed.has(member) || entries.some((done) => done.id === member.id)) continue;
+      if (member.inject.required.some((name) => live.ctx.get(name) === undefined)) continue;
+      const before = present();
+      try {
+        const sink = await mountEntry({ pluginId: member.id, name: member.name, config: member.config ?? undefined }, member.plugin, { probe: true });
+        const after = present();
+        entries.push({
+          id: member.id,
+          name: member.name,
+          entry: member.entry,
+          config: member.config ?? null,
+          inject: member.inject,
+          provides: [...after].filter((name) => !before.has(name)),
+          ...registered(sink),
+        });
+        progress = true;
+      } catch (cause) {
+        failed.add(member);
+        // A row that *is* one of rebon's seats — dsh's own `llm`, `tools`,
+        // `web`, … services — is answered by rebon, not missing.
+        const taken = /service "([^"]+)" has been registered/.exec(String(cause?.message ?? ''))?.[1];
+        if (taken !== undefined && builtinSeats().includes(taken)) {
+          skipped.push({ id: member.id, name: member.name, code: '[REBON_PROVIDES]', error: `rebon provides ${JSON.stringify(taken)} itself` });
+        } else {
+          skipped.push({ id: member.id, name: member.name, code: cause?.code ?? '[ACTIVATE_FAILED]', error: String(cause?.message ?? cause) });
+        }
+      }
+    }
+  }
+  const seats = builtinSeats();
+  for (const member of candidates) {
+    if (failed.has(member) || entries.some((done) => done.id === member.id)) continue;
+    const missing = member.inject.required.filter((name) => live.ctx.get(name) === undefined);
+    skipped.push({
+      id: member.id,
+      name: member.name,
+      code: '[MISSING_INJECT]',
+      missing,
+      error: `${member.id} requires ${missing.map((name) => JSON.stringify(name)).join(', ')}, which neither rebon nor another member of the bundle provides`,
+    });
+  }
+  return { ok: entries.length > 0, bundle: true, seats, entries, skipped };
+}
+
 if (import.meta.url === pathToFileURL(process.argv[1]).href) {
-  const [root, entry, config] = process.argv.slice(2);
+  const args = process.argv.slice(2);
   let answer;
   try {
-    answer = await probe(root, entry, config ? JSON.parse(config) : null);
+    if (args[0] === '--bundle') {
+      answer = await probeBundle(args[1], args[2] ? JSON.parse(args[2]) : {});
+    } else {
+      const [root, entry, config] = args;
+      answer = await probe(root, entry, config ? JSON.parse(config) : null);
+    }
   } catch (cause) {
     answer = { ok: false, code: '[PROBE_FAILED]', error: String(cause?.message ?? cause) };
   }

package/bin/compose-runtime/src/provided-modules.json

@@ -1,35 +1,37 @@
 {
-  "note": "The bare specifiers the composition answers itself, and from where. `payload` entries are relative to the payload directory, `runtime` entries to this package's src/. Read by src/resolve.mjs and by rebon's installer, which installs from npm only the peers of a package that are not here.",
-  "payload": {
+  "note": "The bare specifiers the composition answers itself, and from where. `owned` entries are rebon's for every importer: the module is the other half of a seat rebon implements (cordis, dsh-tools' scheduler symbol, dsh-llm's adapter base, the environment that shows only what was granted), so a second copy would be a second, wrong answer. `payload` entries are the vendored packages rebon's own payload is built from: they answer importers inside the payload and this runtime, while a package installed from npm resolves its own copy and only falls back to these when it has none. Both are relative to the payload directory; `runtime` entries are relative to this package's src/. Read by src/resolve.mjs and by rebon's installer, which installs from npm every peer of a package that is not `owned` or `runtime`.",
+  "owned": {
     "cordis": "vendor/cordis/index.js",
     "cosmokit": "vendor/cosmokit/index.mjs",
     "schemastery": "vendor/schemastery/index.mjs",
     "@deepseek-ai/cordis": "vendor/cordis/index.js",
     "@deepseek-ai/cosmokit": "vendor/cosmokit/index.mjs",
     "@deepseek-ai/schemastery": "vendor/schemastery/index.mjs",
+    "@deepseek-ai/dsh-llm": "compose/shims/dsh-llm.js",
+    "@deepseek-ai/dsh-credentials": "compose/shims/dsh-credentials.js",
+    "@deepseek-ai/dsh-launch-environment": "compose/shims/dsh-launch-environment.js",
+    "@deepseek-ai/dsh-anonymous-user-id": "compose/shims/dsh-anonymous-user-id.js",
+    "@deepseek-ai/dsh-user-id": "compose/shims/dsh-anonymous-user-id.js",
+    "@deepseek-ai/dsh-environment": "compose/shims/dsh-environment.js",
+    "@deepseek-ai/dsh-tools": "compose/shims/dsh-tools.js",
+    "@deepseek-ai/dsh-web": "compose/shims/dsh-web.js"
+  },
+  "payload": {
     "@deepseek-ai/cordis-plugin-timer": "vendor/dsh/timer.js",
     "@deepseek-ai/cordis-plugin-logger-console": "vendor/dsh/logger-console.js",
     "@deepseek-ai/dsh-llm-deepseek": "vendor/dsh/llm-deepseek.js",
     "@deepseek-ai/dsh-timeout": "vendor/dsh/timeout.js",
-    "@deepseek-ai/dsh-llm": "compose/shims/dsh-llm.js",
-    "@deepseek-ai/dsh-credentials": "compose/shims/dsh-credentials.js",
     "@deepseek-ai/dsh-settings": "compose/shims/dsh-settings.js",
-    "@deepseek-ai/dsh-launch-environment": "compose/shims/dsh-launch-environment.js",
-    "@deepseek-ai/dsh-anonymous-user-id": "compose/shims/dsh-anonymous-user-id.js",
     "eventsource-parser": "vendor/eventsource-parser/index.js",
-    "@deepseek-ai/dsh-tools": "compose/shims/dsh-tools.js",
     "@deepseek-ai/dsh-tool-todo": "vendor/dsh/tool-todo.js",
     "zod": "compose/shims/zod-lite.js",
-    "@deepseek-ai/dsh-web": "compose/shims/dsh-web.js",
     "@deepseek-ai/dsh-web-search-exa": "vendor/dsh/web-search-exa.js",
     "@deepseek-ai/dsh-tool-web": "vendor/dsh/tool-web.js",
     "@deepseek-ai/dsh-scope": "vendor/dsh/scope.js",
     "@deepseek-ai/dsh-session": "vendor/dsh/session.js",
     "@deepseek-ai/dsh-agent": "vendor/dsh/agent.js",
     "@deepseek-ai/dsh-system-prompt": "vendor/dsh/system-prompt.js",
-    "@deepseek-ai/dsh-agent-loop": "vendor/dsh/agent-loop.js",
-    "@deepseek-ai/dsh-environment": "compose/shims/dsh-environment.js",
-    "@deepseek-ai/dsh-user-id": "compose/shims/dsh-anonymous-user-id.js"
+    "@deepseek-ai/dsh-agent-loop": "vendor/dsh/agent-loop.js"
   },
   "runtime": {
     "rebon": "./bridge.mjs",

package/bin/compose-runtime/src/realm.mjs

@@ -28,10 +28,21 @@ import RebonToolsRuntime from './tools-runtime.mjs';
 import RebonWebRuntime from './web-runtime.mjs';
 import RebonSystemPromptRuntime from './systemprompt-runtime.mjs';
 import RebonCommandsRuntime from './commands-runtime.mjs';
+import RebonWorkingDirectory from './working-directory-runtime.mjs';
+import RebonSubprocess from './subprocess-runtime.mjs';
+import { RebonConfigEditor, RebonLoader, RebonProfileContext } from './loader-runtime.mjs';
+import { mounting, track, untrack } from './entries.mjs';
 
 /** The built-in seats, in mount order: a dsh `inject` is satisfied at mount
- *  time, so a seat that arrives after the plugin needing it never arrives. */
-const BUILTIN_SEATS = ['llm', 'credentials', 'tools', 'web', 'systemPrompt', 'commands'];
+ *  time, so a seat that arrives after the plugin needing it never arrives.
+ *  The last five are services an upstream package injects that dsh's boot
+ *  layer and session model provide — the composition answers them itself
+ *  (see `working-directory-runtime.mjs`, `subprocess-runtime.mjs` and
+ *  `loader-runtime.mjs`). */
+const BUILTIN_SEATS = [
+  'llm', 'credentials', 'tools', 'web', 'systemPrompt', 'commands',
+  'workingDirectory', 'subprocess', 'loader', 'profileContext', 'configEditor',
+];
 
 let state;
 
@@ -90,7 +101,7 @@ function place(nodes, parent, placements, groups, realms) {
 }
 
 /// Creates the realm. Called once, by the composition control plugin.
-export async function createRealm({ web = null, entries = [] } = {}) {
+export async function createRealm({ web = null, entries = [], profile = null } = {}) {
   if (state !== undefined) {
     throw new ComposeError('[REALM_EXISTS]', 'the composition realm is already created');
   }
@@ -106,6 +117,11 @@ export async function createRealm({ web = null, entries = [] } = {}) {
   await ctx.plugin(RebonWebRuntime, { web });
   await ctx.plugin(RebonSystemPromptRuntime);
   await ctx.plugin(RebonCommandsRuntime);
+  await ctx.plugin(RebonWorkingDirectory);
+  await ctx.plugin(RebonSubprocess);
+  await ctx.plugin(RebonLoader);
+  await ctx.plugin(RebonProfileContext, profile ?? {});
+  await ctx.plugin(RebonConfigEditor, profile ?? {});
 
   state = { ctx, placements, groups, realms, fibers: new Map(), sinks: new Map() };
   return state;
@@ -150,7 +166,11 @@ function requiredInjects(plugin) {
 /// The sink rides on the entry's own derived context, which is what lets a seat
 /// attribute a registration synchronously — the moment a plugin registers, the
 /// context it registered through says which plugin it was.
-export async function mountEntry(request, plugin, { probe = false } = {}) {
+export async function mountEntry(request, plugin, options = {}) {
+  return mounting(() => mount(request, plugin, options));
+}
+
+async function mount(request, plugin, { probe = false } = {}) {
   const live = realm();
   const { pluginId } = request;
   if (live.groups.has(pluginId)) {
@@ -199,6 +219,7 @@ export async function mountEntry(request, plugin, { probe = false } = {}) {
   sink.seal();
   live.fibers.set(pluginId, fiber);
   live.sinks.set(pluginId, sink);
+  track(pluginId, request, fiber);
   return sink;
 }
 
@@ -209,6 +230,7 @@ export async function disposeEntry(pluginId) {
   const fiber = state.fibers.get(pluginId);
   state.fibers.delete(pluginId);
   state.sinks.delete(pluginId);
+  untrack(pluginId);
   if (fiber === undefined) return;
   await fiber.dispose();
 }

package/bin/compose-runtime/src/registry.mjs

@@ -176,13 +176,22 @@ export class RegistrationSink {
   /// What the `compose` service reports for this plugin.
   report() {
     return {
-      sections: this.sections.map((section) => ({ ...section })),
+      sections: this.sections
+        .map((section) => ({ ...section, text: resolvedText(section.text) }))
+        .filter((section) => section.text.length > 0),
       providers: [...this.catalogs].map(([provider, catalog]) => ({ provider, ...catalog })),
       webProviders: this.webProviders.map((entry) => ({ ...entry })),
     };
   }
 }
 
+/// A section's text as rebon receives it: a provider is asked once, with the
+/// empty AssembleContext a whole-composition prompt is assembled with.
+function resolvedText(text) {
+  const value = typeof text === 'function' ? text({}) : text;
+  return typeof value === 'string' ? value : '';
+}
+
 /// The session this plugin is attached to, if it is attached to one.
 ///
 /// With more than one open, the first is used: a plugin acting on its own