zigmini 0.9.0-beta.1 → 0.9.0-beta.2

package/host/omo-check/patches/omo-5.1.48-runtime-compat.patch

@@ -0,0 +1,31 @@
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative-summary.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative-summary.js
+@@ -124,6 +124,7 @@
+             headers,
+             extraBody: options.auth.extraBody,
+             env: options.auth.env,
++            cwd: options.context.cwd,
+             streamKind: "auxiliary",
+             onPayload: async (payload, model) => {
+                 const sanitized = model.api === "anthropic-messages" ? sanitizeAnthropicPayload(payload) : payload;
+--- a/@code-yeongyu/senpi/dist/modes/rpc/multi-session-host.js
++++ b/@code-yeongyu/senpi/dist/modes/rpc/multi-session-host.js
+@@ -227,7 +227,7 @@
+         onHandoffParked: async (ids) => {
+             await Promise.all(ids.map(async (id) => {
+                 await writer.flushConnection(id);
+-                connections.get(id)?.close();
++                await connections.get(id)?.finish();
+             }));
+         },
+     }, hostContext, {
+@@ -342,7 +342,8 @@
+                     process.stderr.write(`senpi rpc connection ${id} release failed: ${errorMessage(cause)}\n`);
+                 });
+             };
+-            connections.set(id, { id, sink, detach, close: () => socket.destroy() });
++            connections.set(id, { id, sink, detach, close: () => socket.destroy(),
++                finish: () => new Promise((resolve) => socket.end(resolve)) });
+             socket.once("close", detach);
+             socket.once("error", () => detach());
+         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zigmini",
-  "version": "0.9.0-beta.1",
+  "version": "0.9.0-beta.2",
   "type": "module",
   "bin": {
     "zigmini": "bin/zigmini"

package/src/cli/setup.ts

@@ -49,7 +49,7 @@ export interface SetupDeps {
 	readonly env: Env;
 	readonly paths: RuntimePaths;
 	readonly bunPath: string;
-	readonly installEngine: (options: { home: string; acceptLicense: boolean; engineOnly: boolean; confirmLicense?: (summary: string, path: string) => Promise<boolean> }) => Promise<string>;
+	readonly installEngine: (options: { home: string; agentDir: string; acceptLicense: boolean; engineOnly: boolean; confirmLicense?: (summary: string, path: string) => Promise<boolean> }) => Promise<string>;
 	readonly globalOmoVersion: () => Promise<string | null>;
 	readonly installGlobalOmo: (version: string) => Promise<void>;
 	/** The executable checked or installed above; injected installers may keep the plain omo command. */
@@ -221,7 +221,11 @@ async function engineStep(options: SetupOptions, deps: SetupDeps): Promise<numbe
 		return answer?.trim().toLowerCase() === "y";
 	};
 	try {
-		const target = await deps.installEngine({ home: deps.paths.home, acceptLicense: options.acceptLicense, engineOnly: options.engineOnly, confirmLicense });
+		// Findings 214-217: the candidate is checked against the store of the agent folder the bridge will use.
+		const configFile = join(deps.paths.home, "config.env");
+		const dedicated = options.agentDir ?? (existsSync(configFile) ? parseConfigEnv(readFileSync(configFile, "utf8")).ZGW_OMO_AGENT_DIR : undefined);
+		const agentDir = dedicated ? resolve(dedicated) : defaultAgentDir(deps.env);
+		const target = await deps.installEngine({ home: deps.paths.home, agentDir, acceptLicense: options.acceptLicense, engineOnly: options.engineOnly, confirmLicense });
 		deps.out(message(lang, "engineDone", { target }));
 		return 0;
 	} catch (error) {

package/src/engine/compat.json

@@ -1,6 +1,6 @@
 {
-  "omo": "5.1.44",
-  "senpi": "2026.10.21-3",
-  "threadSchema": 7,
-  "verifiedAt": "2026-10-23"
+  "omo": "5.1.48",
+  "senpi": "2026.10.25-2",
+  "threadSchema": 10,
+  "verifiedAt": "2026-10-28"
 }

package/src/engine/install.ts

@@ -1,10 +1,13 @@
 import { cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { createConnection } from "node:net";
+import type { Socket } from "node:net";
+import { connectEngineSocket } from "./rpc-socket.ts";
 import type { ServerWebSocket } from "bun";
 import { OmoClient } from "../omo/client.ts";
 import { applyPatch, patchPath } from "./apply-patch.ts";
 import { engineBuildId, engineRevision } from "./build-id.ts";
+import { readStoreSchema, storeIncompatibility } from "./schema-guard.ts";
+import { supportedSchema } from "./thread-schema.ts";
 
 const PATCHES = new URL("../../host/omo-check/patches/", import.meta.url).pathname;
 const LICENSE = "Sustainable Use License 1.0";
@@ -219,34 +222,54 @@ export async function smokeEngine(home: string, candidate: string, options: { re
 	void proc.exited.then((code) => ready.reject(new Error(`engine_smoke_exit:${code}`)));
 	let server: ReturnType<typeof Bun.serve> | undefined;
 	let client: OmoClient | undefined;
-	const sockets = new Set<ReturnType<typeof createConnection>>();
+	const sockets = new Set<Socket>();
+	const handshake = Promise.withResolvers<void>();
 	try {
 		await bounded(ready.promise, timeout);
 		server = Bun.serve({
 			hostname: "127.0.0.1", port: options.port ?? 0,
-			fetch: (req, srv) => srv.upgrade(req, { data: {} }) ? undefined : new Response("", { status: 400 }),
+			fetch: (req, srv) => srv.upgrade(req, { data: { queue: [], closed: false } }) ? undefined : new Response("", { status: 400 }),
 			websocket: {
-				open(ws: ServerWebSocket<{ upstream?: ReturnType<typeof createConnection> }>) {
-					const upstream = createConnection(socket);
-					sockets.add(upstream);
-					ws.data = { upstream };
-					let pending = "";
-					upstream.on("data", (chunk) => {
-						pending += chunk.toString();
-						let newline: number;
-						while ((newline = pending.indexOf("\n")) !== -1) {
-							ws.send(pending.slice(0, newline));
-							pending = pending.slice(newline + 1);
+				// The engine's own authenticated connection (socket_auth, key root = the smoke agent folder). Frames the client
+				// sends while authentication runs are queued in order; a failed authentication fails the smoke, never falls back.
+				open(ws: ServerWebSocket<{ upstream?: Socket; queue: string[]; closed: boolean }>) {
+					void connectEngineSocket({ socketPath: socket, binary: join(candidate, "node_modules/.bin/omo"), agentDir: join(scratch, "agent") }).then((upstream) => {
+						if (ws.data.closed) {
+							upstream.destroy();
+							return;
 						}
+						sockets.add(upstream);
+						ws.data.upstream = upstream;
+						relay(ws, upstream);
+						for (const frame of ws.data.queue.splice(0)) upstream.write(`${frame}\n`);
+					}, (error: unknown) => {
+						handshake.reject(error instanceof Error ? error : new Error(String(error)));
+						ws.close();
 					});
-					upstream.once("error", () => ws.close());
-					upstream.once("close", () => { sockets.delete(upstream); ws.close(); });
 				},
-				message(ws, message) { ws.data.upstream?.write(`${message}\n`); },
-				close(ws) { ws.data.upstream?.destroy(); },
+				message(ws, message) {
+					if (ws.data.upstream) ws.data.upstream.write(`${message}\n`);
+					else ws.data.queue.push(String(message));
+				},
+				close(ws) {
+					ws.data.closed = true;
+					ws.data.upstream?.destroy();
+				},
 			},
 		});
-		const handshake = Promise.withResolvers<void>();
+		const relay = (ws: ServerWebSocket<{ upstream?: Socket; queue: string[]; closed: boolean }>, upstream: Socket) => {
+			let pending = "";
+			upstream.on("data", (chunk) => {
+				pending += chunk.toString();
+				let newline: number;
+				while ((newline = pending.indexOf("\n")) !== -1) {
+					ws.send(pending.slice(0, newline));
+					pending = pending.slice(newline + 1);
+				}
+			});
+			upstream.once("error", () => ws.close());
+			upstream.once("close", () => { sockets.delete(upstream); ws.close(); });
+		};
 		client = new OmoClient(`ws://127.0.0.1:${server.port}`, "", {
 			onEvent() {},
 			onStatus(status) {
@@ -271,8 +294,27 @@ export async function smokeEngine(home: string, candidate: string, options: { re
 	}
 }
 
+/**
+ * Findings 214-217: the candidate must read the agent folder's shared store before it is selected. The store is read
+ * through the guard's temp copy; an unknown support value or an unreadable store is not a known incompatibility.
+ */
+export function assertStoreCompatible(agentDir: string, candidate: string): void {
+	let supported: number | null = null;
+	try {
+		supported = supportedSchema(candidate);
+	} catch {
+		supported = null;
+	}
+	const found = storeIncompatibility(readStoreSchema(agentDir), supported);
+	if (found !== null) throw new Error(`${ENGINE_SCHEMA_INCOMPATIBLE}:store=${found.store},supported=${found.supported}`);
+}
+
+export const ENGINE_SCHEMA_INCOMPATIBLE = "engine_schema_incompatible";
+
 export async function installEngine(options: {
 	readonly home: string;
+	/** The agent folder the bridge uses; when set, a candidate that cannot read its store is never selected. */
+	readonly agentDir?: string;
 	readonly version?: string;
 	readonly patchDir?: string;
 	readonly registry?: string;
@@ -281,11 +323,17 @@ export async function installEngine(options: {
 	readonly confirmLicense?: (summary: string, path: string) => Promise<boolean>;
 	readonly smoke?: { readonly port?: number; readonly timeoutMs?: number };
 }): Promise<string> {
-	const version = options.version ?? JSON.parse(readFileSync(new URL("./compat.json", import.meta.url), "utf8")).omo;
+	const pin: { readonly omo: string; readonly threadSchema?: number } = JSON.parse(readFileSync(new URL("./compat.json", import.meta.url), "utf8"));
+	const version = options.version ?? pin.omo;
+	if (options.agentDir !== undefined && version === pin.omo) {
+		const found = storeIncompatibility(readStoreSchema(options.agentDir), pin.threadSchema ?? null);
+		if (found !== null) throw new Error(`${ENGINE_SCHEMA_INCOMPATIBLE}:store=${found.store},supported=${found.supported}`);
+	}
 	const omoDir = join(resolve(options.home), "omo");
 	await installStock(version, omoDir, options.registry);
 	const target = buildPatched(version, omoDir, options.patchDir);
 	const candidate = join(omoDir, target);
+	if (options.agentDir !== undefined) assertStoreCompatible(options.agentDir, candidate);
 	await acceptEngineLicense(options.home, candidate, options);
 	await smokeEngine(options.home, candidate, options.smoke);
 	candidateExecutable(candidate);

package/src/engine/rpc-socket.ts

@@ -0,0 +1,36 @@
+import { existsSync, realpathSync } from "node:fs";
+import { createConnection, Socket } from "node:net";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+export interface EngineSocketOptions {
+	readonly socketPath: string;
+	readonly binary: string;
+	readonly agentDir: string;
+}
+
+/** Use the selected engine's key-record validation and challenge-response implementation. */
+export async function connectEngineSocket(options: EngineSocketOptions): Promise<Socket> {
+	const modules = dirname(dirname(dirname(realpathSync(options.binary))));
+	const authPath = join(modules, "@code-yeongyu/senpi/dist/modes/rpc/rpc-auth-client.js");
+	if (existsSync(authPath)) {
+		const auth: { readonly connectAuthenticatedRpcSocket?: unknown } = await import(pathToFileURL(authPath).href);
+		if (typeof auth.connectAuthenticatedRpcSocket !== "function") {
+			throw new Error("engine_rpc_auth_module_invalid");
+		}
+		const result: unknown = await auth.connectAuthenticatedRpcSocket(options.socketPath, undefined, { keyRoot: options.agentDir });
+		if (typeof result !== "object" || result === null || !("socket" in result) || !(result.socket instanceof Socket)) {
+			throw new Error("engine_rpc_auth_socket_invalid");
+		}
+		return result.socket;
+	}
+	// Retained pre-auth engines and the native transport fixture have no authentication module.
+	return await new Promise<Socket>((resolve, reject) => {
+		const socket = createConnection(options.socketPath);
+		socket.once("error", reject);
+		socket.once("connect", () => {
+			socket.off("error", reject);
+			resolve(socket);
+		});
+	});
+}

package/src/engine/schema-guard.ts

@@ -38,6 +38,15 @@ export interface SchemaCheck {
 export interface SavedGuard extends SchemaCheck {
 	readonly mode: GuardMode;
 	readonly at: string;
+	/** The refusing bridge's runtime slot and pinned engine folder; null for a bridge that did not say (findings 214-217). */
+	readonly slot?: string | null;
+	readonly engine?: string | null;
+}
+
+/** Which bridge start ran the guard: a slot bridge passes its slot and pinned engine folder. */
+export interface GuardOrigin {
+	readonly slot: string | null;
+	readonly engine: string | null;
 }
 
 export interface GuardInput {
@@ -48,6 +57,7 @@ export interface GuardInput {
 	readonly supported: () => number;
 	readonly bunInstall: string;
 	readonly now: () => Date;
+	readonly origin?: GuardOrigin;
 }
 
 export interface GuardResult {
@@ -116,11 +126,23 @@ export function compareVersions(a: string, b: string): number {
 	return preA < preB ? -1 : 1;
 }
 
+/** Findings 214-217: the installed global version is an observation, not the proven actor of the schema change. */
 export function tooNewMessage(schema: number, globalVersion: string | null): string {
-	return `다른 OMO(전역 ${globalVersion ?? "버전 알 수 없음"})가 공유 폴더 스키마를 ${schema}으로 올렸습니다. ` +
+	return `공유 폴더 스키마가 ${schema}이라 이 게이트웨이 엔진이 읽지 못합니다(지금 설치된 전역 OMO: ${globalVersion ?? "버전 알 수 없음"}, 스키마를 올린 주체는 확인하지 않음). ` +
 		"`zigmini update`로 맞는 버전을 받거나, 이 게이트웨이 전용 에이전트 폴더를 쓰세요(`zigmini setup --agent-dir`)";
 }
 
+export const SCHEMA_INCOMPATIBLE = "schema_incompatible";
+
+/**
+ * Findings 214-217: a known incompatibility is a readable store newer than what the engine supports. A missing or
+ * unreadable store, or an engine whose support is unknown, is not known to be incompatible.
+ */
+export function storeIncompatibility(store: StoreReading, supported: number | null): { readonly store: number; readonly supported: number } | null {
+	if (store.state !== "ok" || supported === null || store.version <= supported) return null;
+	return { store: store.version, supported };
+}
+
 export function checkSchema(store: StoreReading, supported: number | null, globalVersion: string | null): SchemaCheck {
 	const version = store.state === "ok" ? store.version : null;
 	if (store.state === "missing") return { state: "missing", store: null, supported, globalVersion, message: null };
@@ -147,7 +169,7 @@ export function guardStart(input: GuardInput): GuardResult {
 	const file = join(input.run, GUARD_FILE);
 	if (refuse) {
 		mkdirSync(input.run, { recursive: true, mode: 0o700 });
-		const saved: SavedGuard = { ...check, mode: input.mode, at: input.now().toISOString() };
+		const saved: SavedGuard = { ...check, mode: input.mode, at: input.now().toISOString(), slot: input.origin?.slot ?? null, engine: input.origin?.engine ?? null };
 		writeFileSync(file, `${JSON.stringify(saved)}\n`, { mode: 0o600 });
 	} else rmSync(file, { force: true });
 	if (check.state === "too_new") {
@@ -170,6 +192,16 @@ export function readGuardState(run: string): SavedGuard | null {
 	}
 }
 
+/**
+ * Findings 214-217: the refusal of this start attempt only. The shared run/schema-guard.json may be left by another slot,
+ * engine or an earlier start, which must not fail (or explain) the current one.
+ */
+export function attemptRefusal(saved: SavedGuard | null, attempt: { readonly slot: string; readonly engine: string | null; readonly since: string }): string | null {
+	if (saved === null || saved.mode !== "enforce" || saved.slot !== attempt.slot || saved.engine !== attempt.engine) return null;
+	if (!(Date.parse(saved.at) >= Date.parse(attempt.since))) return null;
+	return `저장소 스키마 ${saved.store} > 엔진 ${attempt.engine ?? "current"} 지원 ${saved.supported}로 브리지가 시작을 거부했습니다. ${saved.message}`;
+}
+
 /** `/api/health` `omo`: a connected bridge wins over a stale file; otherwise an enforced refusal shows as schema_too_new. */
 export function healthOmo(status: string, saved: SavedGuard | null): string {
 	return status !== "ready" && saved?.mode === "enforce" ? SCHEMA_TOO_NEW : status;

package/src/omo/client.ts

@@ -1,9 +1,20 @@
+import { FrameSocket } from "./frame-socket.ts";
 import { NativeLifecycleLog, type NativeLifecycleRecord } from "./lifecycle.ts";
 import { RecoveryReceiptLog } from "./recovery-receipt.ts";
 import type { RecoveryOpenContext, RecoveryReceiptRecord } from "./recovery-receipt-types.ts";
 
 export type OmoStatus = "connecting" | "ready" | "disconnected";
 
+interface OmoSocket {
+	readonly readyState: number;
+	onopen: (() => void) | null;
+	onmessage: ((event: { readonly data: string }) => void) | null;
+	onclose: ((event: { readonly code: number; readonly reason: string; readonly wasClean: boolean }) => void) | null;
+	onerror: ((event: { readonly message?: string }) => void) | null;
+	send(text: string): void;
+	close(): void;
+}
+
 export interface OmoEvent {
 	type: string;
 	sessionId?: string;
@@ -79,7 +90,7 @@ type Pending = {
 const STABLE_READY_MS = 10_000;
 
 export class OmoClient {
-	private ws: WebSocket | null = null;
+	private ws: OmoSocket | null = null;
 	private nextId = 1;
 	private readonly instanceId = crypto.randomUUID();
 	private readonly pending = new Map<string, Pending>();
@@ -157,10 +168,12 @@ export class OmoClient {
 		this.setStatus("connecting");
 		this.recovery?.connecting();
 		if (this.stopped) return;
-		const ws = new WebSocket(this.url, { headers: {
+		const headers: Record<string, string> = {
 			Authorization: `Bearer ${this.token}`,
 			...(this.connectionId ? { "x-zgw-connection-id": this.connectionId } : {}),
-		} } as unknown as string[]);
+		};
+		const ws: OmoSocket = this.url.startsWith("ws://") ? new FrameSocket(this.url, headers)
+			: new WebSocket(this.url, { headers } as unknown as string[]) as unknown as OmoSocket;
 		this.ws = ws;
 		ws.onopen = () => {
 			let continuityLoss: string | undefined;