super-dsh 0.1.0 → 0.1.2

package/agent-hermes/README.md

@@ -0,0 +1,144 @@
+# @pgmi-builds/agent-adapter-hermes
+
+Hermes provider for DeepSeek Harness (dsh) — an AgentFactory that embeds the
+Nous Research Hermes Agent via the TUI gateway JSON-RPC (`python -m
+tui_gateway.entry`) and bridges its session surface into Dash Agent/Session
+contracts (Agent Worlds AW-H; parity round 2026-09-17 = Task M1 of
+`docs/superpowers/plans/2026-09-17-aw-five-adapter-parity-fixes.md`).
+
+## Layout
+
+- `src/models.ts` — gateway `model.options` → Dash model catalog (trim rules,
+  r4 id dedupe, provider-name cache, slug list). Pure + fail-soft.
+- `src/adapter.ts` — `HermesLlmAdapter`: one route per real gateway provider
+  slug; `providerInfo` display names; ids stay verbatim selection strings.
+- `src/index.ts` — `HermesProvider` (AgentFactory): creation transaction,
+  boot route registration + atomic swap, default-model push, session map.
+- `src/agent.ts` — `HermesAgent`: wire→DSH event bridge, usage conversion,
+  turn-error classification, resume self-heal, title/todo mirroring.
+- `src/hermes-events.ts` — PURE gateway-event → omp-wire projector.
+- `src/hermes-client.ts` — one client = one gateway child = one session
+  (spawn/env/ready/turn-settle/approval bridge; liveness getters; adoption
+  listener; opt-in idle-probe reaper).
+- `src/hermes-store.ts` — `<dshHome>/agents/hermes/dsh-sessions.json` map.
+- `test/` — imports `dist/`; build first (`npm run build`), then
+  `node --test test/*.test.mjs`. The world-plugin smoke needs the repo farm:
+  run with `DSH_HOME=<repo>/.tests` (it refuses prod homes).
+
+## Per-adapter rulings (2026-09-17 M1; recorded per dev-rules §4/§12)
+
+1. **Model grouping by real provider slug** (RC-3 fix). Boot registers the
+   single placeholder route `hermes` (the selector stays alive while the async
+   probe runs); when the first `model.options` probe resolves, the
+   registration atomically swaps to the DISTINCT surviving provider slugs
+   (`AdapterRegistrationHandle.replace` — validated in full, one synchronous
+   section). `listModels(provider)` filters by the entry's own `provider`;
+   `resolveModel` matches the (provider, id) pair. Model ids are NEVER
+   reformatted: they are the gateway's verbatim selection strings
+   (`session.create {model}` / `/model <id>` consume them as-is — wire
+   contract). The default-model push and the per-session route pin
+   (`model/selection`, `request/context`) carry `{provider: slug, model: id}`,
+   canonicalized through the catalog entry (the r4 dedupe gives every id ONE
+   provider route, so a pinned route always resolves).
+2. **Catalog trims** (the "579-model wall" fix), applied at mapping time in
+   `mapHermesModelOptions`:
+   - `source: "virtual"` rows drop (the `moa` synthesizer is not a selectable
+     endpoint);
+   - mirrored endpoints with IDENTICAL model-id sets collapse onto one row —
+     first in gateway order wins, except a later `is_current` mirror displaces
+     a non-current winner (fixture: `copilot`/`copilot-acp`,
+     `zai-plan`/`zhipu`; 17 providers → 14 groups, 579 → 526 listed ids);
+   - endpoints with MORE than 50 models reorder `featured_models` first
+     (gateway order), remainder alphabetically; smaller rows keep gateway
+     order (the 47-model openrouter row is untouched).
+   The `authenticated !== true` filter predates this ruling and is unchanged.
+3. **Cross-provider id dedupe stays (r4)**: an id listed under several slugs
+   keeps ONE canonical route (first surviving row, current-row preferred).
+   Rationale: the wire sends only the model id, so a duplicate listing would
+   fabricate provider-specific selection the gateway cannot honor; canonical
+   routes keep every pinned route resolvable. Consequence: multi-homed ids
+   (e.g. `kimi-k3` under copilot/qwen-cn/kimi-cn) list under their canonical
+   route only.
+4. **`todo/write`** (typed transcript): the gateway's whole-list
+   `todo.updated {todos, revision}` snapshot → wire `todo_updated` (projector;
+   DSH-shaped items: trimmed content, status ∈ {pending, in_progress,
+   completed}; `cancelled`/unknown statuses and duplicate/blank content drop —
+   the DSH `todo/write` invariant has no cancelled status and forbids
+   repeats) → the agent appends the log-only `todo/write {todos}` snapshot,
+   only inside an open turn (upstream invariant), latest-wins. Log-only
+   semantics kept (upstream `tool-todo` contract); the todo tool pair still
+   renders through `tool_execution_*` as before.
+5. **`session/title` mirror**: gateway `session.title {session_id, title}` →
+   wire `session_title` (pi wire parity) → `session/title
+   {title, messageSeqs: [], source:{kind:"provider", provider:"hermes"}}`,
+   deduped, fail-soft, never affects the turn. The client-side `session.info`
+   title capture stays (feeds `session.create`'s title + tracing).
+6. **Turn usage** (RC-6 fix). Fixture verdict (`gateway-events.sample.json`
+   index 13): the gateway's `total` is CONTEXT-WIDE, not per-message —
+   `total 26805 = prompt 26803 + completion 2` and `prompt === context_used`
+   (the whole re-sent window), so trusting it would inflate every turn.
+   `convertUsage` therefore synthesizes the per-attempt-provable
+   `totalTokens = inputTokens + outputTokens` (fixture: 19251 + 2 = 19253),
+   which the DSH token-meter fold accepts (`normalizeUsage` needs `totalTokens`
+   or BOTH cache buckets; the gateway shape has none — the pre-fix sample
+   folded to `undefined` every turn). `reasoningTokens` rides only when
+   `reasoning ≤ output` (Dash: reasoning ⊆ output; the fold rejects larger
+   values). No cache tokens are invented (the gateway reports none —
+   `cache_hit_pct` is a percentage).
+7. **Resume self-heal over lazy spawn** (RC-4 fix, ruling 4 of the plan; full
+   lazy spawn deferred):
+   - The client exposes `usable` / `closed` / `failure` liveness getters.
+   - On a CLIENT-TERMINAL failure (child exit, ready timeout, close — the
+     client's `usable` is false) the agent's failure path — and the cold-start
+     path — triggers the full idle-exit dispose (`#onIdleExit`), so the host
+     unregisters the dead agent and re-resumes a FRESH client on the next
+     prompt. Ordinary per-turn failures never dispose.
+   - The spawn-grace reaper is now OPT-IN (`spawn({spawnGraceMs})`) and only
+     the self-closing catalog-probe client arms it (env
+     `HERMES_SPAWN_GRACE_MS`, default 10 min, `0` disables). AGENT-HELD
+     clients never arm it: a view-time eager resume may legitimately sit
+     unprompted far beyond any grace, and reaping it stamped the terminal
+     "hermes gateway client closed" failure that wedged every later prompt
+     (the reported wedge). Accepted trade-off until full lazy spawn lands: a
+     resumed-but-never-prompted session pins its gateway child until the host
+     disposes the agent (session close / owner unload).
+   - Turn errors are CLASSIFIED instead of a bare UNKNOWN:
+     `GatewayRpcError` 4001/4006 → `NATIVE_SESSION_GONE` (message names the
+     stored gateway session), gateway child exit/error → `GATEWAY_CRASH`,
+     dead client → `CLIENT_CLOSED`. The code renders in the Web UI error chip
+     (`turn/end {kind:"error", error:{message, code}}`).
+   - `stored_session_id` DRIFT tolerance: adoption
+     (session.create/resume response) fires the client's `onAdopted` listener;
+     the provider's map upsert always tracks the latest adopted pair, so a
+     gateway that remints the durable key on resume cannot strand future
+     resumes on a stale key.
+8. **Model list / switching semantics** (unchanged, recorded): selection
+   applies to the session's pinned route immediately (next request); a fresh
+   session receives the model at `session.create`. The gateway resolves its
+   own provider from the model id; the adapter does not second-guess it.
+9. **Homes** (dev-rules §5/§13): the Hermes runtime keeps its native
+   `~/.hermes` home — never redirected, never seeded. `<dshHome>/agents/hermes/`
+   holds only the adapter's DSH-side state (`dsh-sessions.json`).
+
+## Testing
+
+```bash
+npm run build
+DSH_HOME=<repo>/.tests node --test test/*.test.mjs
+```
+
+All unit/fixture tests fake the gateway child (`setGatewayFactory`) — no real
+python child in tests except the opt-in live suite
+(`hermes-client.live.test.mjs`, skips without a live gateway).
+
+## Trap: `npm install` materializes the hub link
+
+This package depends on `@pgmi-builds/agent-hub` via `file:../agent-hub`. A
+bare `npm install` replaces the symlink with a PHYSICAL copy → a second hub
+instance in the same process → every world webServer stays `pending` forever.
+After any `npm install` here, re-link it:
+
+```bash
+rm -rf node_modules/@pgmi-builds/agent-hub
+ln -s ../../../../agent-worlds/agent-hub node_modules/@pgmi-builds/agent-hub
+```

package/agent-hermes/cordis.patch.yml

@@ -0,0 +1,83 @@
+# @pgmi-builds/agent-adapter-hermes bundle patch (AW-H TUI-gateway line, omp-web form).
+# This file is the `dsh.bundle.patch` layer of the adapter package: when the
+# hermes world profile mounts the bundle, the boot merges THIS patch — mount
+# the Hermes provider plus disable the native components it replaces.
+#
+# Profile-specific values are deliberately NOT here: `webserver.port` (port
+# choice) belongs to the world/profile patch layer (the hermes-standalone
+# profile carries the 127.0.0.1:4985 listener posture).
+
+# Mount the Hermes provider: a Cordis Service that registers an AgentFactory
+# on ctx.agents. The provider drives the Hermes Agent TUI gateway (one
+# spawned `python -m tui_gateway.entry` child per session, JSON-RPC) plus
+# resume (dsh-sessions.json mapping, "mapping only"); the model selector is
+# served by a Hermes-backed LlmAdapter publishing every model under the
+# single `hermes` route (gateway model.options, TTL-cached).
+- insert:
+    - id: hermes-provider
+      name: '@pgmi-builds/agent-adapter-hermes'
+
+# Hermes owns the live agent transcript (the gateway's session state); the
+# built-in loop must not double-run alongside the gateway child — the
+# provider bridges turns into the DSH session log itself.
+- id: agent-loop
+  disabled: true
+
+# The native routes register deepseek-official / pi-ai providers; the Hermes
+# provider registers its own adapter (the single `hermes` route) on ctx.llm.
+# Leaving them mounted would advertise native models alongside Hermes's.
+- id: llm-deepseek
+  disabled: true
+- id: llm-pi-ai
+  disabled: true
+
+# Hermes is single-mode: the gateway drives tools itself, so no Dash preset
+# composition is needed (the provider ships the fixed single-preset roster).
+- id: agent-presets
+  disabled: true
+
+# The upstream jsonl persistence row STAYS MOUNTED (2026-09-17): the provider
+# writes the DSH session log through it (create/open/append/close), and that
+# log is the WebUI read surface (list/read/replay/workspace grouping are
+# ordinary DSH services over it). Hermes owns the LIVE transcript in its own
+# gateway — the DSH jsonl copy duplicates it by design (session storage
+# duplication accepted, user ruling 2026-09-17).
+
+# Hermes approval is RUNTIME: gateway `approval.request` events bridge into
+# Dash `ctx.approval` and answers flow back via `approval.respond` (runtime
+# bridge in src/permission.ts) — there is no launch-only flag to map. The
+# `permission` row below therefore only fixes the DSH approval service's
+# default posture (and its UI presentation); default to danger-full-access.
+# Restate the full 3-preset table: a patch with only defaultPreset silently
+# drops the bundle's 3-preset table to the plugin's built-in 2.
+- id: permission
+  config:
+    presets:
+      read-only:
+        sandbox: read-only
+        approval: ask
+      workspace-write:
+        sandbox: workspace-write
+        approval: ask
+      danger-full-access:
+        sandbox: danger-full-access
+        approval: never
+    defaultPreset: danger-full-access
+
+# Directory picker: the stock `directory-picker-auto` is never a simple alias —
+# it RESOLVES the interaction once per boot and mounts BOTH faces through the
+# loader: the host backend package AND the matching CLIENT SURFACE package
+# (`dsh-client-ui-directory-picker-<kind>`). The client surface is what
+# occupies the workspace picker's directory-flow hole; with the hole empty the
+# client hides the "add workspace" entry entirely (WorkspacePicker: `flowAvailable
+# ? [ADD_WORKSPACE] : []`). NEVER just `disabled: true` this row — that removed
+# the button. Pin the in-app browser by mounting both faces of `browse`
+# ourselves (backend first: the surface's browser half drives the capability the
+# backend registers) and unmounting the auto row.
+- insert:
+    - id: directory-picker-browse
+      name: '@deepseek-ai/dsh-host-directory-picker-browse'
+    - id: directory-picker-browse-surface
+      name: '@deepseek-ai/dsh-client-ui-directory-picker-browse'
+- id: directory-picker
+  disabled: true

package/agent-hermes/dist/adapter.js

@@ -0,0 +1,83 @@
+/**
+ * Hermes-backed `LlmAdapter` registered on `ctx.llm` by the Hermes provider.
+ *
+ * The browser model selector never touches the Hermes agent directly: it is an
+ * RPC round-trip through the apiproxy, which reads `ctx.llm.listProviders /
+ * listModels / resolveModel` to build the catalog. This adapter answers those
+ * queries from the gateway's live model catalog (`models.ts`: `model.options`
+ * RPC, TTL-cached), one route per REAL gateway provider slug (2026-09-17
+ * parity ruling) — never the native deepseek-official / pi-ai routes, which
+ * the profile disables. The provider boots with the single placeholder route
+ * `hermes` and atomically swaps to the distinct slugs once the first catalog
+ * probe resolves (`AdapterRegistrationHandle.replace`), so the selector shows
+ * real groups (DeepSeek / OpenRouter / …) instead of one ~579-model bucket.
+ *
+ * The catalog is ASYNC (a gateway RPC), so the adapter is constructed with a
+ * `() => Promise<HermesCatalog>` supplier (the provider's memoized
+ * probe-client-then-close promise) instead of a home path. `providerInfo` is
+ * a synchronous surface, so it serves the last-known gateway row name via
+ * the models.ts module cache (capitalized-slug fallback before the first
+ * fetch); the async `listModels` / `resolveModel` await the supplier and
+ * filter by the entry's own `provider` slug.
+ *
+ * Model ids stay the VERBATIM gateway selection strings (`session.create
+ * {model}` / `/model <id>` consume them as-is); because the r4 dedupe keeps
+ * one canonical entry per id, `resolveModel` matches on the (provider, id)
+ * pair — a route only ever lists ids that resolve under it.
+ *
+ * `stream` is never dispatched: Hermes owns generation through its gateway
+ * child (`HermesAgent`), so the adapter only serves catalog/metadata queries.
+ * It throws rather than fabricating a wire route the harness would misuse.
+ */
+import { LlmAdapter, LlmError, } from "@deepseek-ai/dsh-llm";
+import { hermesProviderDisplayName } from "./models.js";
+/**
+ * The boot placeholder route every Hermes model is served under until the
+ * first catalog probe resolves and the registration swaps to the real slugs.
+ */
+export const HERMES_PROVIDER_ID = "hermes";
+export class HermesLlmAdapter extends LlmAdapter {
+    catalog;
+    /**
+     * `catalog` = the async catalog supplier — the provider's memoized
+     * probe-client-then-close promise, so catalog reads never depend on
+     * construction-time context.
+     */
+    constructor(catalog) {
+        super();
+        this.catalog = catalog;
+    }
+    providerInfo(provider) {
+        // Synchronous surface: serves the last-known gateway row name (models.ts
+        // module cache, written on every successful fetch); capitalized-slug
+        // fallback before the first fetch — the placeholder `hermes` route then
+        // renders as "Hermes".
+        return { id: provider, name: hermesProviderDisplayName(provider) };
+    }
+    async listModels(provider) {
+        const catalog = await this.catalog();
+        return catalog.models
+            .filter((model) => model.provider === provider)
+            .map((model) => ({
+            provider,
+            id: model.id,
+            name: model.label,
+        }));
+    }
+    async resolveModel(provider, model) {
+        const catalog = await this.catalog();
+        const found = catalog.models.find((candidate) => candidate.id === model && candidate.provider === provider);
+        if (found === undefined) {
+            throw new LlmError(`Hermes provider "${provider}" does not serve model "${model}"`, "MODEL_NOT_FOUND");
+        }
+        return {
+            provider,
+            id: found.id,
+            name: found.label,
+            ...(found.contextWindow !== undefined && found.contextWindow > 0 ? { context: { contextWindow: found.contextWindow } } : {}),
+        };
+    }
+    stream(_options) {
+        throw new LlmError("the Hermes adapter does not stream: Hermes owns generation through its gateway agent", "UNSUPPORTED_STREAM");
+    }
+}

package/agent-hermes/dist/agent-preset-hermes.js

@@ -0,0 +1,171 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { Remote, RemoteError, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+const HERMES_PRESET = Object.freeze({
+    id: "hermes",
+    trust: "system",
+    path: "",
+    name: "Hermes",
+    description: "Hermes agent via the agent-hermes adapter",
+});
+const COMPOSITION_TEXT = [
+    "# Hermes (fixed roster)",
+    "",
+    "This deployment runs exactly one agent mode: the Hermes provider bridges Dash",
+    "sessions to a native Hermes agent over the TUI gateway JSON-RPC. There is no",
+    "per-session plugin composition to configure, so this preset mounts nothing.",
+    "",
+    "rows: []",
+    "",
+].join("\n");
+/** The standing scope key every `hermes` session reads presenters through. */
+const STANDING_KEY = {};
+let SingleHermesPresetRoster = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _remoteList_decorators;
+    let _remoteRead_decorators;
+    let _remoteCopy_decorators;
+    let _remoteDelete_decorators;
+    let _remoteSelect_decorators;
+    return class SingleHermesPresetRoster extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _remoteList_decorators = [Remote("list")];
+            _remoteRead_decorators = [Remote("read")];
+            _remoteCopy_decorators = [Remote("copy")];
+            _remoteDelete_decorators = [Remote("deletePreset")];
+            _remoteSelect_decorators = [Remote("select")];
+            __esDecorate(this, null, _remoteList_decorators, { kind: "method", name: "remoteList", static: false, private: false, access: { has: obj => "remoteList" in obj, get: obj => obj.remoteList }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _remoteRead_decorators, { kind: "method", name: "remoteRead", static: false, private: false, access: { has: obj => "remoteRead" in obj, get: obj => obj.remoteRead }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _remoteCopy_decorators, { kind: "method", name: "remoteCopy", static: false, private: false, access: { has: obj => "remoteCopy" in obj, get: obj => obj.remoteCopy }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _remoteDelete_decorators, { kind: "method", name: "remoteDelete", static: false, private: false, access: { has: obj => "remoteDelete" in obj, get: obj => obj.remoteDelete }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _remoteSelect_decorators, { kind: "method", name: "remoteSelect", static: false, private: false, access: { has: obj => "remoteSelect" in obj, get: obj => obj.remoteSelect }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        constructor(ctx) {
+            super(ctx, "agentPresets");
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+        get defaultId() {
+            return HERMES_PRESET.id;
+        }
+        get roots() {
+            return [];
+        }
+        get authorable() {
+            return false;
+        }
+        async list() {
+            return [HERMES_PRESET];
+        }
+        async resolve(id) {
+            if (id === undefined || id === HERMES_PRESET.id)
+                return HERMES_PRESET;
+            throw new RemoteError("agent-preset/not-found", `agent-presets: preset "${id}" not found (available: hermes)`, { agentPreset: id, available: [HERMES_PRESET.id] });
+        }
+        async mount(_agentCtx, id) {
+            return this.resolve(id);
+        }
+        async recompose(_agentCtx, id) {
+            return this.resolve(id);
+        }
+        async read(id) {
+            await this.resolve(id);
+            return COMPOSITION_TEXT;
+        }
+        // ── Remote RPC surface (alpha: agentPresets routes come from @Remote) ────
+        // The stock dsh-host-apiproxy mapped cordis methods to routes; alpha serves
+        // them from @Remote decorators on a TypertRemoteService. A plain Service
+        // registers no routes, which is why Settings → Agent Preset 404'd.
+        async remoteList() {
+            if (process.env.HERMES_TRACE === "1")
+                process.stderr.write("[hermes-roster] remoteList INVOKED\n");
+            return {
+                presets: [
+                    {
+                        id: HERMES_PRESET.id,
+                        trust: HERMES_PRESET.trust,
+                        isDefault: true,
+                        name: HERMES_PRESET.name,
+                        description: HERMES_PRESET.description,
+                    },
+                ],
+                authorable: this.authorable,
+            };
+        }
+        async remoteRead(agentPreset) {
+            const preset = await this.resolve(agentPreset);
+            return {
+                agentPreset: preset.id,
+                trust: preset.trust,
+                content: await this.read(preset.id),
+                name: preset.name,
+                description: preset.description,
+            };
+        }
+        async remoteCopy(from, id, name) {
+            await this.copy(from, id, name);
+        }
+        async remoteDelete(id) {
+            await this.remove(id);
+        }
+        /** Fixed roster: one preset, so selecting it is a no-op ack; anything else is unknown. */
+        async remoteSelect(agent, agentPreset) {
+            const preset = await this.resolve(agentPreset);
+            return preset.id;
+        }
+        async copy(_from, id, _name) {
+            throw new RemoteError("agent-preset/read-only", `agent-presets: preset "${id}" cannot be written: the Hermes roster is fixed and ships exactly one preset`, { agentPreset: id, reason: "the Hermes roster is fixed and ships exactly one preset" });
+        }
+        async remove(id) {
+            throw new RemoteError("agent-preset/read-only", `agent-presets: preset "${id}" cannot be written: the Hermes roster is fixed and ships exactly one preset`, { agentPreset: id, reason: "the Hermes roster is fixed and ships exactly one preset" });
+        }
+        serviceFor(_agent, _name) {
+            return undefined;
+        }
+        composeFrom(_agentCtx, _parentCtx) {
+            return undefined;
+        }
+        composedPreset(_agentCtx) {
+            return HERMES_PRESET.id;
+        }
+        async standingKeyFor(id) {
+            await this.resolve(id);
+            return STANDING_KEY;
+        }
+    };
+})();
+export { SingleHermesPresetRoster };

package/agent-hermes/dist/agent-preset-projection.js

@@ -0,0 +1,34 @@
+/**
+ * The `agentPreset` session projection, owned by the adapter.
+ *
+ * Upstream registers this fold from the `dsh-agent-presets` package, which our
+ * patch disables (the Hermes provider replaces preset composition wholesale).
+ * But the Web UI depends on the projection regardless: the preset hero chip
+ * renders only when `session.projectionValues.agentPreset` resolves
+ * (`presetOf` in ui-agent-preset/seat-store.ts), and the session-header label
+ * reads it too. Without a registrant the projection is absent for every
+ * adapter session and both surfaces stay blank — roster or no roster.
+ *
+ * Same fold as upstream (packages/preset/agent-presets/src/session.ts):
+ * initialized from the creation header, advanced by `agent-preset/selected`
+ * events, which this adapter synthesizes (`"hermes"`) on every session it
+ * prepares. Registered under the provider's own fiber via
+ * `ctx.inject(['sessionProjections'])`, so the key lives exactly as long as
+ * the provider is mounted.
+ */
+import { z } from "zod";
+const agentPresetSchema = z.union([z.string(), z.null()]);
+/** Current Session preset, initialized from its header and advanced by selection events. */
+export const hermesAgentPresetProjection = {
+    key: "agentPreset",
+    stateSchema: agentPresetSchema,
+    // adapter-hermes is single-preset: default every session to "hermes" so the
+    // header chip resolves for scan-native (never-resumed) sessions too,
+    // instead of only those whose log carries an `agent-preset/selected` event.
+    init: (header) => header.agentPreset ?? "hermes",
+    apply: (state, event) => event.type === "agent-preset/selected"
+        ? event.data.agentPreset
+        : state,
+    wire: { viewSchema: agentPresetSchema, view: (state) => state },
+    stateVersion: 1,
+};