antechamber 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -7,6 +7,34 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-10-14
+
+### Added
+
+- feat(api): add v2 credential, integration, file-search, VCS, and synthetic-context routes
+- feat(events): replay retained SSE events and expose v2 shell, compaction, and execution terminals
+
+### Fixed
+
+- fix(session): preserve rich prompt parts, metadata, ancestry, and part identities across reloads
+- fix(runtime): retain operation ordering after caller cancellation and finalize interrupted tool cards
+- fix(rpc): close failed transports and reject responses correlated to the wrong command
+- fix(http): allow passwordless loopback origins across ports while retaining explicit origin checks
+- fix(security): validate registry records and write registry state with private permissions
+- fix(cli): advertise OpenCode API compatibility as 2.0.20
+- fix(api): return OpenCode 2.x bootstrap shapes for `/api/config`, `/api/shell`, `/api/websearch/provider` and `GET /api/mcp` so OpenChamber 2.3.2 can initialize workspaces
+- fix(api): answer v2 synthetic context admission with the admitted record and return the bare interrupt flag, so OpenChamber 2.3.2 can send prompts and stop turns
+- fix(extension): bound graph responses and display omitted-node counts
+- fix(api): carry v2 prompt attachments, agent mentions and metadata into OmO's input, admission events and message history, and answer skill references with OpenCode's tagged not-found error
+- fix(session): admit synthetic context and v1 `noReply` messages into OmO's conversation without a turn, keep them after restarts even when no prompt follows, and stop context from titling sessions
+- fix(events): keep an unscoped v2 `/api/event` stream global, as OpenChamber 2.3.2 subscribes
+- fix(rpc): after the agent exits during shutdown, kill only re-identified members of its process group
+
+### Changed
+
+- docs(api): document route statuses, response envelopes, stream framing, and unsupported capabilities
+- docs(maintainers): correct smoke paths, typecheck commands, and release guidance
+
 ## [0.1.1] - 2026-10-14
 
 ### Added

package/README.md

@@ -55,15 +55,15 @@ another executable (see [docs/configuration.md](docs/configuration.md)).
 
 | OpenChamber | API | Status |
 |---|---|---|
-| >= 2.0.4 | v2 (`@opencode-ai/sdk/v2`) | primary target; antechamber advertises `opencode v2.0.18` on `--version` |
+| >= 2.0.4 | v2 (`@opencode-ai/sdk/v2`) | primary target; antechamber advertises `opencode v2.0.20` on `--version` |
 | 1.24.x | v1 | supported |
 | other versions | - | not tested |
 
 OpenChamber changes which OpenCode API calls it makes between releases. If a
 feature breaks on a newer OpenChamber, run `npm run smoke` to see which check
 failed, then open an issue with the output. See
-[docs/api-surface.md](docs/api-surface.md) for the exact endpoints antechamber
-implements.
+[docs/api-surface.md](docs/api-surface.md) for the maintained route, response,
+and event-stream inventory.
 
 ## Quick start
 
@@ -76,10 +76,6 @@ antechamber doctor
 antechamber setup
 ```
 
-The first npm publication (0.1.0) is part of the
-[release process](docs/releasing.md). If it is not on the registry yet, use
-[From source](#from-source) below.
-
 `setup` updates OpenChamber's `opencodeBinary`, preserves all other settings,
 and backs up an existing settings file before changing it. Restart OpenChamber
 after setup. Preview changes with `antechamber setup --dry-run`.
@@ -137,7 +133,7 @@ antechamber serve --hostname 127.0.0.1 --port 4096
 | `antechamber serve` | OpenCode-compatible server; `--hostname`/`--host`, `--port`, `--directory`. Bare `antechamber` also starts the server. |
 | `antechamber setup` | Configure OpenChamber; `--settings <file>`, `--profile <dir>`, `--binary <path>`, `--dry-run`, `--systemd [unit]`, `--pi-binary <path>`, `--restart`. |
 | `antechamber doctor` | Read-only Node, backend, agent/state directories, teardown, OpenChamber and auth checks; `--json`, `--settings <file>`, `--profile <dir>`. Exits 1 on any FAIL; warnings do not fail. |
-| `antechamber version` | Package version plus OpenCode API contract version. `--version`/`-v` deliberately print exactly `opencode v2.0.18` for OpenChamber. |
+| `antechamber version` | Package version plus OpenCode API contract version. `--version`/`-v` deliberately print exactly `opencode v2.0.20` for OpenChamber. |
 | `antechamber help` | Usage and options; also `--help`/`-h`. |
 
 ## Upgrade, uninstall and rollback
@@ -218,9 +214,11 @@ extension, and refuses it as an invalid manifest. Details:
 
 ## Configuration
 
-All settings are environment variables prefixed `ANTECHAMBER_`. The
-deprecated `OCPI_` prefix is still accepted as a fallback for existing
-deployments. Full reference, defaults, and units: [docs/configuration.md](docs/configuration.md).
+Connector settings use the `ANTECHAMBER_` prefix; the deprecated `OCPI_`
+prefix is still accepted as a fallback. RPC capability passthrough also reads
+`OMO_RPC_CLIENT_CAPABILITIES` and `SENPI_RPC_CLIENT_CAPABILITIES` directly.
+Full reference, defaults, and units:
+[docs/configuration.md](docs/configuration.md).
 
 | Variable | Purpose |
 |---|---|
@@ -231,6 +229,7 @@ deployments. Full reference, defaults, and units: [docs/configuration.md](docs/c
 | `ANTECHAMBER_IDLE_TIMEOUT_MS` | idle session reap timeout |
 | `ANTECHAMBER_MAX_LIVE` | cap on concurrent live agent processes |
 | `ANTECHAMBER_DEBUG` / `ANTECHAMBER_DEBUG_LOG` | request/event debug logging |
+| `OMO_RPC_CLIENT_CAPABILITIES` / `SENPI_RPC_CLIENT_CAPABILITIES` | inherited RPC capabilities merged for the agent process |
 
 ## Security
 
@@ -244,8 +243,11 @@ Hardening controls (full reference in [docs/configuration.md](docs/configuration
 - Optional HTTP Basic auth, matching OpenCode's own contract:
   `OPENCODE_SERVER_PASSWORD` (plus `OPENCODE_SERVER_USERNAME`, default
   `opencode`).
-- Without a password, requests carrying a non-loopback browser `Origin` are
-  rejected unless listed in `ANTECHAMBER_ALLOWED_ORIGINS`.
+- Without a password, browser origins are limited to the adapter's own origin,
+  HTTP(S) loopback origins (including a different loopback port), and origins
+  listed in `ANTECHAMBER_ALLOWED_ORIGINS`; other origins get `403`. With a
+  password, other origins may make authenticated requests but receive no CORS
+  headers unless explicitly allowed.
 - Binding to a non-loopback host requires a password, `ANTECHAMBER_ALLOW_INSECURE=1`,
   or the `--insecure-no-auth` flag.
 - Request bodies are capped by `ANTECHAMBER_MAX_BODY_BYTES` (default 10 MiB);
@@ -268,7 +270,8 @@ of crashing; antechamber never falls back to signalling numeric PIDs. macOS is u
   level, not the model level.
 - Some OpenCode routes have no pi/OmO equivalent and are stubbed or return
   `400`/`501` (OAuth-based provider auth, MCP connect/disconnect, session
-  share). See [docs/api-surface.md](docs/api-surface.md) for the exact list.
+  share). See [docs/api-surface.md](docs/api-surface.md) for the maintained
+  route and unsupported-response inventory.
 
 ## Development
 

package/bin/opencode-antechamber

@@ -4,7 +4,16 @@
 # `<binary> --version`; anything else is rejected.
 # Requires a build (`npm run build`) so that dist/cli.js exists.
 set -eu
-SCRIPT_DIR="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"
+SCRIPT_PATH=$0
+while [ -h "$SCRIPT_PATH" ]; do
+  SCRIPT_DIR="$(CDPATH= cd -- "$(dirname -- "$SCRIPT_PATH")" && pwd)"
+  LINK="$(readlink "$SCRIPT_PATH")"
+  case "$LINK" in
+    /*) SCRIPT_PATH=$LINK ;;
+    *) SCRIPT_PATH="$SCRIPT_DIR/$LINK" ;;
+  esac
+done
+SCRIPT_DIR="$(CDPATH= cd -- "$(dirname -- "$SCRIPT_PATH")" && pwd)"
 CLI="$SCRIPT_DIR/../dist/cli.js"
 if [ ! -f "$CLI" ]; then
   echo "opencode-antechamber: $CLI not found; run 'npm run build' first" >&2

package/bin/opencode-pi

@@ -1,3 +1,13 @@
 #!/bin/sh
 # Deprecated name kept for existing OpenChamber settings; use opencode-antechamber.
-exec "$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)/opencode-antechamber" "$@"
+SCRIPT_PATH=$0
+while [ -h "$SCRIPT_PATH" ]; do
+  SCRIPT_DIR="$(CDPATH= cd -- "$(dirname -- "$SCRIPT_PATH")" && pwd)"
+  LINK="$(readlink "$SCRIPT_PATH")"
+  case "$LINK" in
+    /*) SCRIPT_PATH=$LINK ;;
+    *) SCRIPT_PATH="$SCRIPT_DIR/$LINK" ;;
+  esac
+done
+SCRIPT_DIR="$(CDPATH= cd -- "$(dirname -- "$SCRIPT_PATH")" && pwd)"
+exec "$SCRIPT_DIR/opencode-antechamber" "$@"

package/dist/approvals.d.ts

@@ -12,7 +12,7 @@ export type ApprovalEvent = WithoutEventID<EventPermissionAsked | EventPermissio
         formAnswer?: Record<string, string | string[]>;
     };
 };
-export type PermissionReply = "once" | "always" | "reject";
+type PermissionReply = "once" | "always" | "reject";
 export type PendingPermission = PermissionRequest;
 export type PendingQuestion = QuestionRequest & {
     questionIDs?: string[];
@@ -75,10 +75,13 @@ export declare class ApprovalBridge {
     observeQuestion(ev: Record<string, unknown>): void;
     observe(context: Context, ev: Record<string, unknown>): void;
     private ask;
+    private askStructuredQuestion;
+    private askLegacyDialog;
     replyPermission(id: string, reply: PermissionReply, message?: string, sessionID?: string): boolean;
     replyQuestion(id: string, answers: string[][], sessionID?: string, comment?: string): boolean | Promise<boolean>;
     rejectQuestion(id: string, sessionID?: string): boolean | Promise<boolean>;
     private respondStructured;
+    private rememberSettled;
     private follow;
     private remove;
     clear(sessionID: string, cancel: boolean, callID?: string): void;

package/dist/approvals.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 export class ApprovalInputError extends Error {
 }
+const MAX_SETTLED_STRUCTURED_QUESTIONS = 256;
 function record(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value)
         ? value
@@ -169,7 +170,7 @@ export class ApprovalBridge {
         const p = [...this.pending.values()].find((p) => p.request.method === "question" &&
             (p.request.id === ev.id || (typeof ev.requestId === "string" && p.request.requestId === ev.requestId)));
         if (ev.type === "question_resolved" && typeof ev.requestId === "string")
-            this.settled.add(ev.requestId);
+            this.rememberSettled(ev.requestId);
         if (!p || p.kind !== "question")
             return;
         if (ev.type === "question_updated") {
@@ -181,7 +182,7 @@ export class ApprovalBridge {
             p.card.metadata = { ...p.card.metadata, deadlineAtMs: p.request.deadlineAtMs, draft: p.request.draft };
             return;
         }
-        this.settled.add(p.request.requestId ?? "");
+        this.rememberSettled(p.request.requestId);
         if (ev.outcome !== "answered" && ev.outcome !== "comment-submitted") {
             this.remove(p, true);
             return;
@@ -264,41 +265,47 @@ export class ApprovalBridge {
         if (!request)
             return;
         if (request.method === "question") {
-            if (this.settled.has(request.requestId ?? ""))
-                return;
-            const publicID = `que_${createHash("sha256")
-                .update(JSON.stringify([context.sessionID, request.requestId]))
-                .digest("hex")
-                .slice(0, 32)}`;
-            const existing = this.pending.get(publicID);
-            if (existing) {
-                existing.request = request;
-                if (existing.kind === "question")
-                    existing.card.metadata = {
-                        requestId: request.requestId,
-                        waitForAnswer: request.waitForAnswer,
-                        deadlineAtMs: request.deadlineAtMs,
-                        draft: request.draft,
-                    };
-                return;
-            }
-            const card = {
-                id: publicID,
-                sessionID: context.sessionID,
-                questions: (request.questions ?? []).map(({ id: _id, ...q }) => q),
-                questionIDs: (request.questions ?? []).map((q) => q.id),
-                metadata: {
+            this.askStructuredQuestion(context, request);
+            return;
+        }
+        this.askLegacyDialog(context, request);
+    }
+    askStructuredQuestion(context, request) {
+        if (this.settled.has(request.requestId ?? ""))
+            return;
+        const publicID = `que_${createHash("sha256")
+            .update(JSON.stringify([context.sessionID, request.requestId]))
+            .digest("hex")
+            .slice(0, 32)}`;
+        const existing = this.pending.get(publicID);
+        if (existing) {
+            existing.request = request;
+            if (existing.kind === "question")
+                existing.card.metadata = {
                     requestId: request.requestId,
                     waitForAnswer: request.waitForAnswer,
                     deadlineAtMs: request.deadlineAtMs,
                     draft: request.draft,
-                },
-                tool: { messageID: context.messageID, callID: request.requestId ?? "" },
-            };
-            this.pending.set(publicID, { kind: "question", card, context, request });
-            this.emit(context.directory, { type: "question.asked", properties: card });
+                };
             return;
         }
+        const card = {
+            id: publicID,
+            sessionID: context.sessionID,
+            questions: (request.questions ?? []).map(({ id: _id, ...q }) => q),
+            questionIDs: (request.questions ?? []).map((q) => q.id),
+            metadata: {
+                requestId: request.requestId,
+                waitForAnswer: request.waitForAnswer,
+                deadlineAtMs: request.deadlineAtMs,
+                draft: request.draft,
+            },
+            tool: { messageID: context.messageID, callID: request.requestId ?? "" },
+        };
+        this.pending.set(publicID, { kind: "question", card, context, request });
+        this.emit(context.directory, { type: "question.asked", properties: card });
+    }
+    askLegacyDialog(context, request) {
         if (this.pending.has(request.id))
             return;
         const calls = this.questionCalls.get(context.sessionID);
@@ -470,6 +477,17 @@ export class ApprovalBridge {
             p.replying = false;
         }
     }
+    rememberSettled(requestID) {
+        if (!requestID)
+            return;
+        this.settled.delete(requestID);
+        this.settled.add(requestID);
+        if (this.settled.size <= MAX_SETTLED_STRUCTURED_QUESTIONS)
+            return;
+        const oldest = this.settled.values().next().value;
+        if (oldest !== undefined)
+            this.settled.delete(oldest);
+    }
     follow(p, value, kind) {
         const callID = p.request.toolCallId;
         if (callID === undefined)
@@ -502,8 +520,8 @@ export class ApprovalBridge {
                 continue;
             if (p.request.method === "question" && !cancel)
                 continue;
-            if (cancel && p.request.requestId)
-                this.settled.add(p.request.requestId);
+            if (cancel)
+                this.rememberSettled(p.request.requestId);
             if (cancel)
                 p.context.send({ type: "extension_ui_response", id: p.request.id, cancelled: true });
             this.remove(p, true);

package/dist/catalog.d.ts

@@ -48,7 +48,7 @@ interface OCv2Model {
     options: Record<string, unknown>;
     variants?: Record<string, Record<string, unknown>>;
 }
-export interface OCv2Provider {
+interface OCv2Provider {
     id: string;
     name: string;
     source: "config";

package/dist/catalog.js

@@ -45,7 +45,7 @@ function toOCModel(m) {
     };
 }
 export async function loadCatalog(directory) {
-    const pi = new PiRpcClient({ cwd: directory });
+    const pi = new PiRpcClient({ cwd: directory, args: ["--no-session"] });
     try {
         const [modelsRes, firstState] = await Promise.all([
             pi.command({ type: "get_available_models" }),

package/dist/commands/context.d.ts

@@ -13,7 +13,6 @@ export interface CommandContext {
     readonly launcherPath: string;
 }
 export declare function createContext(overrides?: Partial<CommandContext>): CommandContext;
-export declare const packageCliPath: string;
 /** Resolve executables without shell evaluation, respecting the supplied PATH. */
 export declare function resolveBinary(binary: string, ctx: CommandContext): string | undefined;
 export interface SettingsOptions {

package/dist/commands/context.js

@@ -35,7 +35,7 @@ export function createContext(overrides = {}) {
         ...overrides,
     };
 }
-export const packageCliPath = fileURLToPath(new URL("../../dist/cli.js", import.meta.url));
+const packageCliPath = fileURLToPath(new URL("../../dist/cli.js", import.meta.url));
 /** Resolve executables without shell evaluation, respecting the supplied PATH. */
 export function resolveBinary(binary, ctx) {
     const candidates = isAbsolute(binary) || binary.includes("/") || binary.includes("\\")

package/dist/commands/doctor.d.ts

@@ -1,13 +1,14 @@
 import { type CommandContext, type SettingsOptions } from "./context.js";
-export interface DoctorCheck {
+interface DoctorCheck {
     readonly name: string;
     readonly status: "PASS" | "WARN" | "FAIL" | "INFO";
     readonly message: string;
 }
-export interface DoctorReport {
+interface DoctorReport {
     readonly checks: readonly DoctorCheck[];
     readonly exitCode: 0 | 1;
 }
 /** Checks capabilities with access/stat only, never creating state or config files. */
 export declare function doctor(options?: SettingsOptions, ctx?: CommandContext): DoctorReport;
 export declare function formatDoctor(report: DoctorReport, json: boolean): string;
+export {};

package/dist/commands/serve.d.ts

@@ -1,4 +1,4 @@
-export interface ServeOptions {
+interface ServeOptions {
     readonly port: number;
     readonly host: string;
     readonly directory: string;
@@ -6,3 +6,4 @@ export interface ServeOptions {
     readonly compatible: boolean;
 }
 export declare function serve(options: ServeOptions): Promise<void>;
+export {};

package/dist/commands/setup.d.ts

@@ -1,5 +1,5 @@
 import { type CommandContext, type SettingsOptions } from "./context.js";
-export interface SetupOptions extends SettingsOptions {
+interface SetupOptions extends SettingsOptions {
     readonly binary?: string;
     readonly dryRun?: boolean;
     readonly systemd?: string;
@@ -8,7 +8,6 @@ export interface SetupOptions extends SettingsOptions {
     /** User-unit root, overridable without touching the real systemd configuration. */
     readonly systemdDir?: string;
 }
-/** The bundled OmO Graph extension folder, when this installation has its built files. */
-export declare function omoGraphExtensionDir(ctx: CommandContext): string | undefined;
 /** Plan all inputs before applying changes; dependencies are injected for hermetic tests. */
 export declare function setup(options: SetupOptions, ctx?: CommandContext): string[];
+export {};

package/dist/commands/setup.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { dirname, join, resolve } from "node:path";
 import { createContext, isPackageBinary, readSettings, resolveBinary, settingsPath, shellQuote, } from "./context.js";
 function systemdValue(value) {
@@ -5,8 +6,13 @@ function systemdValue(value) {
         throw new Error("systemd environment values cannot contain newlines or NUL");
     return value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("%", "%%");
 }
+function writeAtomically(path, content, ctx) {
+    const temporary = join(dirname(path), `.antechamber-${randomUUID()}.tmp`);
+    ctx.fs.writeFileSync(temporary, content, { mode: 0o600, flag: "wx" });
+    ctx.fs.renameSync(temporary, path);
+}
 /** The bundled OmO Graph extension folder, when this installation has its built files. */
-export function omoGraphExtensionDir(ctx) {
+function omoGraphExtensionDir(ctx) {
     const dir = resolve(dirname(ctx.cliPath), "..", "extensions", "omo-dag");
     const built = ["package.json", "panel/main.js", "service/main.js"].every((file) => ctx.fs.existsSync(join(dir, file)));
     return built ? dir : undefined;
@@ -75,8 +81,14 @@ export function setup(options, ctx = createContext()) {
     const stamp = ctx.now().toISOString().replace(/\D/g, "").slice(0, 14);
     const backup = (path) => {
         const target = `${path}.bak-antechamber-${stamp}`;
-        if (options.dryRun)
+        if (options.dryRun) {
+            if (ctx.fs.existsSync(target)) {
+                throw Object.assign(new Error(`EEXIST: file already exists, copyfile '${path}' -> '${target}'`), {
+                    code: "EEXIST",
+                });
+            }
             report(`Would back up ${path} to ${target}`);
+        }
         else {
             ctx.fs.copyFileSync(path, target, ctx.fs.constants.COPYFILE_EXCL);
             report(`Backed up ${path} to ${target}`);
@@ -98,7 +110,7 @@ export function setup(options, ctx = createContext()) {
             backup(settings);
         if (!options.dryRun) {
             ctx.fs.mkdirSync(dirname(settings), { recursive: true });
-            ctx.fs.writeFileSync(settings, updated, { mode: 0o600 });
+            writeAtomically(settings, updated, ctx);
             report(`Wrote ${settings}`);
         }
     }
@@ -113,7 +125,7 @@ export function setup(options, ctx = createContext()) {
                 backup(dropIn);
             if (!options.dryRun) {
                 ctx.fs.mkdirSync(dirname(dropIn), { recursive: true });
-                ctx.fs.writeFileSync(dropIn, dropInText, { mode: 0o600 });
+                writeAtomically(dropIn, dropInText, ctx);
                 report(`Wrote ${dropIn}`);
             }
         }

package/dist/http.d.ts

@@ -1,5 +1,9 @@
 /** Shared HTTP body, response, authentication, and CORS plumbing. */
 import type { IncomingMessage, ServerResponse } from "node:http";
+export declare class RequestBodyError extends Error {
+    readonly status: 400 | 413;
+    constructor(status: 400 | 413, message: string);
+}
 export declare function serverPassword(): string | undefined;
 export declare function isLoopbackHost(host: string): boolean;
 export declare function errorBody(name: string, message: string): {
@@ -10,9 +14,12 @@ export declare function errorBody(name: string, message: string): {
 };
 export declare function json(res: ServerResponse, status: number, body: unknown): void;
 export declare class Http {
+    private serverOrigin?;
     private readonly credentials;
     private readonly maxBodyBytes;
-    constructor();
+    constructor(serverOrigin?: (() => string) | undefined);
+    allowsUpgrade(req: IncomingMessage): boolean;
     route(req: IncomingMessage, res: ServerResponse, handle: () => Promise<void>): Promise<void>;
     body(req: IncomingMessage): Promise<unknown>;
+    private authorized;
 }

package/dist/http.js

@@ -2,8 +2,9 @@
 import { createHash, timingSafeEqual } from "node:crypto";
 import { ApprovalInputError } from "./approvals.js";
 import { envSetting } from "./config.js";
+import { UpstreamProtocolError } from "./pi-rpc.js";
 const DEFAULT_MAX_BODY_BYTES = 10 * 1024 * 1024;
-class RequestBodyError extends Error {
+export class RequestBodyError extends Error {
     status;
     constructor(status, message) {
         super(message);
@@ -19,7 +20,7 @@ export function isLoopbackHost(host) {
         return true;
     return /^127(?:\.\d{1,3}){3}$/.test(host) && host.split(".").every((part) => Number(part) <= 255);
 }
-function allowedOrigin(origin) {
+function allowedOrigin(origin, serverOrigin) {
     try {
         const url = new URL(origin);
         if (!/^https?:\/\/[^/?#]+$/.test(origin) ||
@@ -29,7 +30,8 @@ function allowedOrigin(origin) {
             url.search !== "" ||
             url.hash !== "")
             return false;
-        return (["localhost", "127.0.0.1", "[::1]"].includes(url.hostname) ||
+        return (origin === serverOrigin ||
+            isLoopbackHost(url.hostname) ||
             (envSetting("ALLOWED_ORIGINS") ?? "").split(",").some((entry) => entry.trim() === origin));
     }
     catch {
@@ -44,9 +46,11 @@ export function json(res, status, body) {
     res.writeHead(status, { "Content-Type": "application/json" }).end(payload);
 }
 export class Http {
+    serverOrigin;
     credentials;
     maxBodyBytes;
-    constructor() {
+    constructor(serverOrigin) {
+        this.serverOrigin = serverOrigin;
         const maxBodyBytes = Number(envSetting("MAX_BODY_BYTES"));
         this.maxBodyBytes = Number.isSafeInteger(maxBodyBytes) && maxBodyBytes > 0 ? maxBodyBytes : DEFAULT_MAX_BODY_BYTES;
         const password = serverPassword();
@@ -57,11 +61,17 @@ export class Http {
                     .update(`${process.env.OPENCODE_SERVER_USERNAME || "opencode"}:${password}`)
                     .digest();
     }
+    allowsUpgrade(req) {
+        const origin = req.headers.origin;
+        if (origin !== undefined && !allowedOrigin(origin, this.serverOrigin?.()) && this.credentials === undefined)
+            return false;
+        return this.authorized(req);
+    }
     async route(req, res, handle) {
         res.setHeader("Vary", "Origin");
         const origin = req.headers.origin;
         if (origin !== undefined) {
-            if (allowedOrigin(origin)) {
+            if (allowedOrigin(origin, this.serverOrigin?.())) {
                 res.setHeader("Access-Control-Allow-Origin", origin);
                 res.setHeader("Access-Control-Allow-Credentials", "true");
             }
@@ -74,16 +84,10 @@ export class Http {
                 return;
             }
         }
-        if (this.credentials !== undefined) {
-            const match = req.headers.authorization?.match(/^Basic\s+([A-Za-z0-9+/]+=*)$/i);
-            const supplied = createHash("sha256")
-                .update(Buffer.from(match?.[1] ?? "", "base64"))
-                .digest();
-            if (!match || !timingSafeEqual(this.credentials, supplied)) {
-                res.setHeader("WWW-Authenticate", 'Basic realm="OpenCode"');
-                json(res, 401, errorBody("UnauthorizedError", "Authentication required"));
-                return;
-            }
+        if (!this.authorized(req)) {
+            res.setHeader("WWW-Authenticate", 'Basic realm="OpenCode"');
+            json(res, 401, errorBody("UnauthorizedError", "Authentication required"));
+            return;
         }
         res.setHeader("Access-Control-Allow-Methods", "GET,POST,PUT,PATCH,DELETE,OPTIONS");
         res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, x-opencode-directory");
@@ -100,11 +104,21 @@ export class Http {
                 res.setHeader("Connection", "close");
                 res.once("finish", () => req.destroy());
             }
-            json(res, err instanceof RequestBodyError ? err.status : err instanceof ApprovalInputError ? 400 : 500, errorBody(err instanceof RequestBodyError
+            json(res, err instanceof UpstreamProtocolError
+                ? 502
+                : err instanceof RequestBodyError
+                    ? err.status
+                    : err instanceof ApprovalInputError || err instanceof URIError
+                        ? 400
+                        : 500, errorBody(err instanceof UpstreamProtocolError
                 ? err.name
-                : err instanceof ApprovalInputError
-                    ? "InvalidRequestError"
-                    : "UnknownError", message));
+                : err instanceof RequestBodyError
+                    ? err.name
+                    : err instanceof ApprovalInputError
+                        ? "InvalidRequestError"
+                        : err instanceof URIError
+                            ? "BadRequestError"
+                            : "UnknownError", err instanceof URIError ? "invalid URL encoding" : message));
         }
     }
     body(req) {
@@ -165,4 +179,13 @@ export class Http {
             req.once("aborted", onAborted);
         });
     }
+    authorized(req) {
+        if (this.credentials === undefined)
+            return true;
+        const match = req.headers.authorization?.match(/^Basic\s+([A-Za-z0-9+/]+=*)$/i);
+        const supplied = createHash("sha256")
+            .update(Buffer.from(match?.[1] ?? "", "base64"))
+            .digest();
+        return match !== null && match !== undefined && timingSafeEqual(this.credentials, supplied);
+    }
 }

package/dist/pi-event-translation.d.ts

@@ -22,8 +22,6 @@ export declare function id(prefix: string): string;
 export declare function piModelId(responseModel: unknown, model: unknown): unknown;
 export declare function piStopReason(stopReason: string | undefined, errorMessage?: string): Pick<OCAssistantMessage, "finish" | "error">;
 export declare function textOf(content: Array<Record<string, unknown>> | undefined): string;
-export declare function newPart(kind: "text" | "reasoning", sessionID: string, messageID: string): OCPart;
-export declare function applyUsage(msg: OCAssistantMessage, usage: PiUsage | undefined): void;
 /**
  * Recompute the session's own spend from its loaded assistant messages. Subagent
  * spend stays on the child sessions: OpenChamber sums the parentID subtree, so
@@ -33,9 +31,8 @@ export declare function syncSessionCost(s: ManagedSession): boolean;
 /**
  * An OmO compaction as OpenCode shows one: a user turn holding a `compaction`
  * part (OpenChamber renders it as `/compact`) answered by a `summary` message.
- * IDs derive from the compaction's first kept entry, which the live
- * `compaction_end` result and the persisted entry share, so a history reload
- * reconciles with the live messages instead of duplicating them.
+ * IDs derive from the native compaction entry, not its retained boundary:
+ * multiple compactions can retain the same entry.
  */
 export declare function compactionMessages(s: ManagedSession, key: string, summary: string, created: number, model: OCModelRef | undefined): [OCMessageWithParts, OCMessageWithParts];
 interface PiEventServices {
@@ -53,11 +50,18 @@ interface PiEventServices {
 export declare class PiEventTranslator {
     private services;
     constructor(services: PiEventServices);
+    /** Close dead-runtime UI state before an error or idle event can reach the client. */
+    finishInterruptedRun(s: ManagedSession, error: NonNullable<OCAssistantMessage["error"]>): void;
     setStatus(s: ManagedSession, status: OCSessionStatus): void;
     emitPart(s: ManagedSession, part: OCPart, delta?: string): void;
     deliverInput(s: ManagedSession, messageID: string): void;
     private reconcileUser;
     onPiEvent(s: ManagedSession, ev: Record<string, unknown>): void;
+    private onTodoEntry;
+    private onLifecycleEvent;
+    private onToolEvent;
+    private onMessageEvent;
+    private onCompactionEvent;
     private finishStreaming;
     private onMessageUpdate;
     private onProviderTools;