super-dsh 0.1.0 → 0.1.2

package/agent-claude/dist/session-map.js

@@ -0,0 +1,165 @@
+/**
+ * DSH-session ↔ Claude-session identity + permission-mode record (the "mapping
+ * only" model, 2026-09-16; mirrors `agent-codex/src/session-map.ts`).
+ *
+ * Route A anchors the Claude session id deterministically from the DSH id's
+ * UUID tail, so the *id* itself survives restarts with no map. What the event
+ * log cannot round-trip is the **effective Claude permission mode**: the extra
+ * tiers (`plan` / `auto` / `dontAsk`) are never folded into `permission/preset`
+ * by `permissionEventsFor`, and `presetFromEvents` skips a `preset:"plan"`
+ * event — so a resumed session cannot recover its live mode from the log. The
+ * mode is therefore persisted HERE, in the same record that stores the
+ * `claudeSessionId`, and `resume` reads it back and re-applies it through
+ * `client.setPermissionMode(mode)`.
+ *
+ * The record is an adapter-owned JSON file at the world's DSH-home root (NOT
+ * inside the Claude app home — the app home is the CLI's native `~/.claude`
+ * since the 2026-09-17 home ruling; DSH bookkeeping never lives in the
+ * runtime's native tree):
+ *
+ *   `<worldHome>/dsh-sessions.json`   (`<DSH home>/agents/claude/dsh-sessions.json`)
+ *
+ * Shape: `{ "<dshSessionId>": { claudeSessionId, claudeMode, cwd, createdAt,
+ * preset } }`. Writes are atomic (temp file + rename); reads are fail-soft
+ * (malformed JSON reads as empty) and never throw, so a corrupt map degrades
+ * to "unknown session" rather than breaking every operation.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { assertNotProdHome } from "./claude-home.js";
+/**
+ * The adapter's DSH-side state dir — the world's DSH home root
+ * (`<dshHome>/agents/claude`), never the Claude app home. Precedence:
+ * explicit world home (boot-provided `dshHomePath`), then `$DSH_HOME` (a hub
+ * home, so the world layout nests `agents/claude`), then the line's
+ * historical test-home default. Prod-guarded.
+ */
+export function resolveClaudeStateDir(home) {
+    if (home !== undefined) {
+        const dir = resolve(home);
+        assertNotProdHome(dir, "claude state dir");
+        return dir;
+    }
+    const fallbackHome = resolve(process.env.DSH_HOME ?? join(process.cwd(), ".tests", "aw"));
+    const dir = join(fallbackHome, "agents", "claude");
+    assertNotProdHome(dir, "claude state dir");
+    return dir;
+}
+/** The map file's path at the world DSH-home root. */
+export function sessionMapPath(home) {
+    return join(resolveClaudeStateDir(home), "dsh-sessions.json");
+}
+/** Read the map. Fail-soft: a missing or malformed file reads as `{}`. */
+export function readSessionMap(home) {
+    let raw;
+    try {
+        raw = readFileSync(sessionMapPath(home), "utf8");
+    }
+    catch {
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        return {};
+    const out = {};
+    for (const [id, value] of Object.entries(parsed)) {
+        const record = coerceRecord(value);
+        if (record !== undefined)
+            out[id] = record;
+    }
+    return out;
+}
+/** Validate one entry; malformed entries are dropped (fail-soft). */
+function coerceRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const raw = value;
+    const cwd = raw["cwd"];
+    if (typeof cwd !== "string" || cwd === "")
+        return undefined;
+    const claudeSessionId = raw["claudeSessionId"];
+    const claudeMode = raw["claudeMode"];
+    const preset = raw["preset"];
+    const createdAt = raw["createdAt"];
+    return {
+        claudeSessionId: typeof claudeSessionId === "string" && claudeSessionId !== "" ? claudeSessionId : null,
+        claudeMode: typeof claudeMode === "string" && claudeMode !== "" ? claudeMode : null,
+        cwd,
+        createdAt: typeof createdAt === "number" && Number.isFinite(createdAt) ? createdAt : 0,
+        preset: typeof preset === "string" && preset !== "" ? preset : null,
+        ...(raw["resumable"] === false ? { resumable: false } : {}),
+    };
+}
+/** One session's record, or `undefined` when the id is unknown. */
+export function sessionRecord(home, dshSessionId) {
+    return readSessionMap(home)[dshSessionId];
+}
+/**
+ * Insert or merge one session's record and persist the map atomically (temp
+ * file + rename, same directory). Merge semantics: an omitted `patch` field
+ * keeps the stored value; `claudeSessionId: null` explicitly records "not yet
+ * resolved". Throws only when the write itself fails — the caller owns that
+ * decision (create treats an unwritable map as fatal).
+ */
+export function upsertSession(home, dshSessionId, patch) {
+    const path = sessionMapPath(home);
+    const map = readSessionMap(home);
+    const previous = map[dshSessionId];
+    const next = {
+        claudeSessionId: patch.claudeSessionId !== undefined ? patch.claudeSessionId : previous?.claudeSessionId ?? null,
+        claudeMode: patch.claudeMode !== undefined ? patch.claudeMode : previous?.claudeMode ?? null,
+        cwd: patch.cwd !== undefined ? patch.cwd : previous?.cwd ?? "",
+        createdAt: patch.createdAt !== undefined ? patch.createdAt : previous?.createdAt ?? Date.now(),
+        preset: patch.preset !== undefined ? patch.preset : previous?.preset ?? null,
+        // Sticky refusal: only an explicit `true` clears a recorded false.
+        ...(patch.resumable === true ? {} : patch.resumable === false || previous?.resumable === false ? { resumable: false } : {}),
+    };
+    map[dshSessionId] = next;
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true });
+    const temp = `${path}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(temp, `${JSON.stringify(map, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    try {
+        renameSync(temp, path);
+    }
+    catch (error) {
+        try {
+            rmSync(temp, { force: true });
+        }
+        catch {
+            // The rename failure is primary.
+        }
+        throw error;
+    }
+    return next;
+}
+/** Drop one session's record (idempotent; failure to persist rethrows). */
+export function forgetSession(home, dshSessionId) {
+    const path = sessionMapPath(home);
+    if (!existsSync(path))
+        return;
+    const map = readSessionMap(home);
+    if (map[dshSessionId] === undefined)
+        return;
+    delete map[dshSessionId];
+    const temp = `${path}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(temp, `${JSON.stringify(map, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    try {
+        renameSync(temp, path);
+    }
+    catch (error) {
+        try {
+            rmSync(temp, { force: true });
+        }
+        catch {
+            // The rename failure is primary.
+        }
+        throw error;
+    }
+}

package/agent-claude/dist/world-plugin.js

@@ -0,0 +1,14 @@
+/**
+ * `./world` entry point for a future hub-side packaging step.
+ *
+ * Ruling R2 (2026-09-16): this adapter ships and is verified STANDALONE only.
+ * Joining the agent-worlds hub is the hub side's job — it packages this entry
+ * with its own spawn/roster wiring. Nothing here starts a process or reads the
+ * hub; it only exposes the canonical provider row name.
+ */
+export const name = 'aw.agent-adapter-claude-world';
+export const providerRow = '@pgmi-builds/agent-adapter-claude';
+export function apply() {
+    // Intentionally inert: the standalone bundle patch (cordis.patch.yml) is the
+    // sole mounting path in V1. The hub packages its own insert row via `providerRow`.
+}

package/agent-claude/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@pgmi-builds/agent-adapter-claude",
+  "version": "0.1.0",
+  "description": "Claude Code provider for DeepSeek Harness (dsh) — an AgentFactory that bridges the host Claude Code CLI through the official @anthropic-ai/claude-agent-sdk into the Dash Agent/Session contracts (Agent Worlds, standalone form).",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./world": "./dist/world-plugin.js"
+  },
+  "files": [
+    "dist",
+    "cordis.patch.yml"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "node --test test/*.test.mjs"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "0.3.263"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-agent": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-commands": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-llm": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-session": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-session-persistence": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-user-approval": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-user-questions": "0.1.5-rc.2"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/cordis": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-agent": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-commands": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-llm": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-session": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-session-persistence": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-user-approval": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-user-questions": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "typescript": "^5.6.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "main": "dist/index.js",
+  "engines": {
+    "node": ">=22.18"
+  }
+}

package/agent-codex/README.md

@@ -0,0 +1,74 @@
+# @pgmi-builds/agent-adapter-codex
+
+superd 外壳下的 **Codex adapter**（agent-worlds 线，AW-E）：把 Codex CLI 经由
+`@openai/codex-sdk` 接进 DSH —— 会话、事件、模型目录、持久化全部按 DSH 语义呈现，
+WebUI 消费的是 DSH 服务提供的数据面。
+
+> 通用规则（定位 / 两形态 / 测试准则 / 接线域 / per-agent 定制权 / home 与 profile 布局）
+> 见上级目录的 `agent-adapter-dev-rules.md` —— 改本包前先读它。
+
+## 它是什么
+
+- 一个**普通 dsh plugin bundle**：`package.json` 的 `dsh.bundle.patch` 指向本目录的
+  `cordis.patch.yml`（挂 codex provider、关掉它替代的原生行、重写权限三档表、pin 应用内目录选择器）。
+- 一个 **AgentFactory**：`src/index.ts` 里的 `CodexProvider` 在 `ctx.agents` 注册工厂，
+  每个会话一个 `CodexSdkClient`（真 `@openai/codex-sdk` 线程）；`src/agent.ts` 把 Codex 线程事件
+  投影成 DSH 会话事件。
+- **不包含** 任何 hub 耦合：世界挂载由 hub 侧驱动（AW-B 用 `@pgmi-builds/agent-hub/world` 的
+  mount carrier）。本包自己就足以点亮一个完整的 web app。
+
+## 单独跑起来（首选开发/验收形态）
+
+```bash
+# 在仓根执行；端口默认 4988，LAN 走只绑 LAN IP 的 socat relay
+AW_APP_PORT=4989 bash super-dsh/test/start-codex-app.sh
+# 脚本会打印 loopback / LAN token URL；停止：
+systemctl --user stop aw-codex-app-<port>-test aw-codex-app-<port>-relay
+```
+
+环境变量：`AW_APP_PORT`（端口）、`AW_APP_HOME`（默认 `$WT/.tests`）、
+`SUPERD_LAN_HOST`（默认 `192.168.31.130`）、`CODEX_TRACE=1`（provider/agent 追踪）。
+
+## Home 与 profile 布局（user 裁定）
+
+| 位置 | 内容 |
+|---|---|
+| `$DSH_HOME`（测试 = `<repo>/.tests`） | 测试 DSH home |
+| `$DSH_HOME/agents/codex` | **Codex app home**：`config.toml` / `auth.json` / 模型 catalog（由 `scripts/setup-codex-home.mjs` 从 `~/.codex` **单向**拷入）+ Codex 自己的 rollout/state |
+| `$DSH_HOME/profiles/codex` | 本 app 的 dsh profile（bundles + `cordis.patch.yml`） |
+| `$DSH_HOME/sessions/...` | **DSH 会话日志**（上游 `session-persistence-jsonl`，zstd）——list/replay 都由此提供 |
+
+**禁止**自造 per-app home（如 `.tests/codex-app`）。
+
+## 关键实现点
+
+- **session 身份 = 一对一映射**：DSH session id 是权威；Codex thread id 在其物化后写入
+  `<codexHome>/dsh-sessions.json`（`src/session-map.ts`）。resume 只经该映射重挂线程，查不到即
+  fail-closed。**不自建 rollout 扫描做 list，也不自解析 JSONL 做 replay。**
+- **DSH-native 持久化**：工厂按上游 agent-loop 的方式持有写通道（create `persistence.create` /
+  resume `persistence.open(id,'write')` → `read` → `interruptedTurnClosers` → `prepare`），
+  发布点刷未存后缀，dispose 时 `handle.close()` 排空。
+- **每会话路由钉住**：工厂在 create/resume 时同步钉住本会话路由（追加 `model/selection` +
+  `installModelSelection`），**不依赖全局默认模型的落盘时序**（共享 test home 里 settings 默认可能属别线）。
+- **事件映射**：`system/message`（Codex 系统提示，rollout HEAD `base_instructions`）、
+  `request/context`（provider/model/contextWindow）、`assistant/message`（reasoning 用
+  `{type:'reasoning',text}`）、`tool/call`（原始 JSON 串）/`tool/result`、`step/start|end`、`turn/start|end`。
+
+## 测试
+
+```bash
+npm run build                                   # tsc strict
+DSH_HOME=<repo>/.tests \
+SUPERD_DSH_ANCHOR=<repo>/upstream/deepseek-harness/package.json \
+node --test test/*.test.mjs
+```
+
+live 门控：`AW_CODEX_LIVE=1`（会真跑一次 Codex turn）。
+
+## 已知边界（V1）
+
+- 审批仅 launch-only 预设（SDK 无运行时审批；app-server 线才有 `*/requestApproval`）；
+- 无 steer / 无运行时换模型（下一轮生效）/ usage 滞后一轮 / 无 fork；
+- `compaction/*`、`todo/write`、`subagent/*` 未接（见规则文档 §9.4 backlog）；
+- **AW-B world 挂载移植**：本包已无 world-plugin；若要在 AW-B 的 mount carrier 下作为世界被挂载，
+  由 hub 侧驱动（移植为跟踪项）。

package/agent-codex/cordis.patch.yml

@@ -0,0 +1,77 @@
+# @pgmi-builds/agent-adapter-codex bundle patch (AW-E SDK line, omp-web form).
+# This file is the `dsh.bundle.patch` layer of the adapter package: when the
+# codex world profile mounts the bundle, the boot merges THIS patch — mount
+# the Codex 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 aw-codex-world
+# fixture carries the 127.0.0.1:0 listener posture).
+
+# Mount the Codex provider: a Cordis Service that registers an AgentFactory
+# on ctx.agents. The provider drives @openai/codex-sdk threads (one
+# CodexSdkClient per session) plus resume (--resume-thread); the model
+# selector is served by a Codex-backed LlmAdapter reading the codex home's
+# config.toml + model_catalog_json.
+- insert:
+    - id: codex-provider
+      name: '@pgmi-builds/agent-adapter-codex'
+
+# Codex owns the live agent transcript (the rollout JSONL); disable the
+# built-in loop so it does not double-run alongside the SDK thread.
+- id: agent-loop
+  disabled: true
+
+# The native routes register deepseek-official / pi-ai providers; the Codex
+# provider registers its own adapter (the single `codex` route) on ctx.llm.
+# Leaving them mounted would advertise native models alongside Codex's.
+- id: llm-deepseek
+  disabled: true
+- id: llm-pi-ai
+  disabled: true
+
+# Codex is single-mode: the SDK thread 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-16): the provider
+# writes the DSH session log through it (create/open/append/close), so
+# list/read/replay/workspace grouping are ordinary DSH services over that log.
+# The adapter no longer provides its own persistence.
+
+# Codex has no runtime approval control — the adapter maps the preset onto
+# the launch-only --approval-mode flag (3:3 table in src/permission.ts).
+# 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, breaking the 3:3 Dash<->Codex pairing.
+- 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-codex/dist/adapter.js

@@ -0,0 +1,55 @@
+/**
+ * Codex-backed `LlmAdapter` registered on `ctx.llm` by the Codex provider.
+ *
+ * The browser model selector never touches the Codex 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 Codex home's real catalog (`models.ts`: config.toml +
+ * model_catalog_json) under the single provider route `codex` — never the
+ * native deepseek-official / pi-ai routes, which the profile disables.
+ *
+ * `stream` is never dispatched: Codex owns generation through its SDK thread
+ * (`CodexAgent`), 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 { readCodexModelCatalog } from "./models.js";
+/** The one provider route every Codex model is served under. */
+export const CODEX_PROVIDER_ID = "codex";
+export class CodexLlmAdapter extends LlmAdapter {
+    home;
+    /**
+     * `home` = the codex app home — the CLI's native `~/.codex` (2026-09-17
+     * home ruling), resolved by the provider via resolveCodexHome() so catalog
+     * reads never depend on construction-time context.
+     */
+    constructor(home) {
+        super();
+        this.home = home;
+    }
+    providerInfo(_provider) {
+        return { id: CODEX_PROVIDER_ID, name: readCodexModelCatalog(this.home).provider ?? "Codex" };
+    }
+    async listModels(_provider) {
+        return readCodexModelCatalog(this.home).models.map((model) => ({
+            provider: CODEX_PROVIDER_ID,
+            id: model.id,
+            name: model.label,
+        }));
+    }
+    async resolveModel(_provider, model) {
+        const found = readCodexModelCatalog(this.home).models.find((candidate) => candidate.id === model);
+        if (found === undefined) {
+            throw new LlmError(`Codex provider "${CODEX_PROVIDER_ID}" does not serve model "${model}"`, "MODEL_NOT_FOUND");
+        }
+        return {
+            provider: CODEX_PROVIDER_ID,
+            id: found.id,
+            name: found.label,
+            ...(found.contextWindow !== undefined && found.contextWindow > 0 ? { context: { contextWindow: found.contextWindow } } : {}),
+        };
+    }
+    stream(_options) {
+        throw new LlmError("the Codex adapter does not stream: Codex owns generation through its SDK agent", "UNSUPPORTED_STREAM");
+    }
+}

package/agent-codex/dist/agent-preset-codex.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 CODEX_PRESET = Object.freeze({
+    id: "codex",
+    trust: "system",
+    path: "",
+    name: "Codex",
+    description: "Codex agent via the agent-codex adapter",
+});
+const COMPOSITION_TEXT = [
+    "# Codex (fixed roster)",
+    "",
+    "This deployment runs exactly one agent mode: the Codex provider bridges Dash",
+    "sessions to a native Codex agent over the @openai/codex-sdk. There is no",
+    "per-session plugin composition to configure, so this preset mounts nothing.",
+    "",
+    "rows: []",
+    "",
+].join("\n");
+/** The standing scope key every `codex` session reads presenters through. */
+const STANDING_KEY = {};
+let SingleCodexPresetRoster = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _remoteList_decorators;
+    let _remoteRead_decorators;
+    let _remoteCopy_decorators;
+    let _remoteDelete_decorators;
+    let _remoteSelect_decorators;
+    return class SingleCodexPresetRoster 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 CODEX_PRESET.id;
+        }
+        get roots() {
+            return [];
+        }
+        get authorable() {
+            return false;
+        }
+        async list() {
+            return [CODEX_PRESET];
+        }
+        async resolve(id) {
+            if (id === undefined || id === CODEX_PRESET.id)
+                return CODEX_PRESET;
+            throw new RemoteError("agent-preset/not-found", `agent-presets: preset "${id}" not found (available: codex)`, { agentPreset: id, available: [CODEX_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.CODEX_TRACE === "1")
+                process.stderr.write("[codex-roster] remoteList INVOKED\n");
+            return {
+                presets: [
+                    {
+                        id: CODEX_PRESET.id,
+                        trust: CODEX_PRESET.trust,
+                        isDefault: true,
+                        name: CODEX_PRESET.name,
+                        description: CODEX_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 Codex roster is fixed and ships exactly one preset`, { agentPreset: id, reason: "the Codex 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 Codex roster is fixed and ships exactly one preset`, { agentPreset: id, reason: "the Codex roster is fixed and ships exactly one preset" });
+        }
+        serviceFor(_agent, _name) {
+            return undefined;
+        }
+        composeFrom(_agentCtx, _parentCtx) {
+            return undefined;
+        }
+        composedPreset(_agentCtx) {
+            return CODEX_PRESET.id;
+        }
+        async standingKeyFor(id) {
+            await this.resolve(id);
+            return STANDING_KEY;
+        }
+    };
+})();
+export { SingleCodexPresetRoster };

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

@@ -0,0 +1,37 @@
+/**
+ * The `agentPreset` session projection, owned by the adapter.
+ *
+ * Upstream registers this fold from the `dsh-agent-presets` package, which our
+ * patch disables (the Codex 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 (that
+ * was the "no mode" bug on the omp line: the roster service answered
+ * agentPresets/list 200, yet nothing drove the per-session projection the
+ * chip gates on).
+ *
+ * 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 (`"codex"`) 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 codexAgentPresetProjection = {
+    key: "agentPreset",
+    stateSchema: agentPresetSchema,
+    // adapter-codex is single-preset: default every session to "codex" 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 ?? "codex",
+    apply: (state, event) => event.type === "agent-preset/selected"
+        ? event.data.agentPreset
+        : state,
+    wire: { viewSchema: agentPresetSchema, view: (state) => state },
+    stateVersion: 1,
+};