@ours.network/cowork 0.4.0 → 0.4.1-nightly.20260816.4aaf940

package/dist/daemon.js

@@ -10,446 +10,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/adapt.ts
-import * as fs from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { brotliCompressSync, brotliDecompressSync, constants as zlibConstants } from "node:zlib";
-function withScope(fn) {
-  const lifetime = new AdaptObjectLifetime();
-  try {
-    return fn(lifetime);
-  } finally {
-    lifetime.Finalize();
-  }
-}
-async function withScopeAsync(fn) {
-  const lifetime = new AdaptObjectLifetime();
-  try {
-    return await fn(lifetime);
-  } finally {
-    lifetime.Finalize();
-  }
-}
-function locateUnit() {
-  const here = dirname(fileURLToPath(import.meta.url));
-  const override = process.env.OURS_COWORK_UNIT_DIR;
-  const candidates = override ? [resolve(override)] : [join(here, "mufl_code"), join(here, "..", "mufl_code")];
-  for (const dir of candidates) {
-    if (!fs.existsSync(dir)) continue;
-    const compiled = fs.readdirSync(dir).find((name) => name.endsWith(".muflo"));
-    if (compiled) {
-      return {
-        dir,
-        hash: compiled.slice(0, -".muflo".length),
-        contents: new Uint8Array(fs.readFileSync(join(dir, compiled)))
-      };
-    }
-  }
-  throw new Error(`no compiled .muflo packet found (looked in: ${candidates.join(", ")})`);
-}
-function wireHandlers(packet, hooks, log) {
-  const settleAfterActionLoop = (pending) => {
-    queueMicrotask(() => {
-      if (packet.pending[0] !== pending || !pending.payload || pending.callbackError) return;
-      packet.pending.shift();
-      clearTimeout(pending.timer);
-      pending.settled = true;
-      pending.resolve(pending.payload);
-    });
-  };
-  packet.pw.on_return_data = (data) => {
-    const lifetime = new AdaptObjectLifetime();
-    data.Attach(lifetime);
-    try {
-      if (packet.isClosed) return;
-      const kind = data.Reduce("kind").Visualize();
-      if (kind === "save_state") {
-        try {
-          hooks.onSaveState();
-        } catch (error) {
-          const pending2 = packet.pending[0];
-          if (pending2) pending2.callbackError = asError(error);
-          throw error;
-        }
-        return;
-      }
-      if (kind === "notify_agent") {
-        const payload = data.Reduce("payload");
-        hooks.onNotify(payload.Reduce("event").Visualize(), payload);
-        return;
-      }
-      const pending = packet.pending[0];
-      if (!pending) return;
-      if (pending.expired) {
-        packet.releaseExpired(pending);
-        return;
-      }
-      if (pending.payload) pending.payload.Destroy();
-      pending.payload = data.Reduce("payload").Detach();
-      settleAfterActionLoop(pending);
-    } finally {
-      lifetime.Finalize();
-    }
-  };
-  packet.pw.on_transaction_failure = (message) => {
-    log(`[${packet.name}] transaction rejected (origin uncorrelated):`, message);
-  };
-}
-function asError(error) {
-  return error instanceof Error ? error : new Error(String(error));
-}
-function packInvite(raw) {
-  return brotliCompressSync(raw, {
-    params: {
-      [zlibConstants.BROTLI_PARAM_QUALITY]: 11,
-      [zlibConstants.BROTLI_PARAM_SIZE_HINT]: raw.length
-    }
-  }).toString("base64url");
-}
-function unpackInvite(encoded, maximumBytes) {
-  const normalized = encoded.replace(/\s+/g, "");
-  if (maximumBytes !== void 0 && Buffer.byteLength(encoded, "utf8") > maximumBytes || normalized.length === 0 || !/^[A-Za-z0-9_-]+$/.test(normalized)) {
-    throw new Error("the invite blob is empty, oversized, or invalid base64url");
-  }
-  const compressed = Buffer.from(normalized, "base64url");
-  if (compressed.length === 0) throw new Error("the invite blob is empty or invalid base64url");
-  return Buffer.from(maximumBytes === void 0 ? brotliDecompressSync(compressed) : brotliDecompressSync(compressed, { maxOutputLength: maximumBytes }));
-}
-var commonSdk, executableSdk, wrapperSdk, wrappersSdk, AdaptObjectLifetime, adapt_wrapper, object_to_adapt_value, PacketWrapperConfigurator, LATE_RESULT_DRAIN_MS, Packet, AdaptHostShutdownError, AdaptHost;
-var init_adapt = __esm({
-  async "src/adapt.ts"() {
-    "use strict";
-    [commonSdk, executableSdk, wrapperSdk, wrappersSdk] = await Promise.all([
-      import("@adapt-toolkit/sdk/common"),
-      import("@adapt-toolkit/sdk/executables"),
-      import("@adapt-toolkit/sdk/wrapper"),
-      import("@adapt-toolkit/sdk/wrappers")
-    ]);
-    ({ AdaptObjectLifetime } = commonSdk);
-    ({ adapt_wrapper } = executableSdk);
-    ({ object_to_adapt_value } = wrapperSdk);
-    ({ PacketWrapperConfigurator } = wrappersSdk);
-    LATE_RESULT_DRAIN_MS = 50;
-    Packet = class {
-      pending = [];
-      lock = Promise.resolve();
-      expiredDrain;
-      releaseExpiredDrain;
-      closedError;
-      terminalNotified = false;
-      onTerminal;
-      terminalListeners = /* @__PURE__ */ new Set();
-      makeEnvelope;
-      name;
-      cid;
-      pw;
-      constructor(name, cid, pw, onTerminal = () => {
-      }, makeEnvelope = (transactionName, targ) => object_to_adapt_value({ name: transactionName, targ })) {
-        this.name = name;
-        this.cid = cid;
-        this.pw = pw;
-        this.onTerminal = onTerminal;
-        this.makeEnvelope = makeEnvelope;
-      }
-      get isClosed() {
-        return this.closedError !== void 0;
-      }
-      onTerminalClose(listener) {
-        if (this.closedError) {
-          listener(this.closedError);
-          return () => {
-          };
-        }
-        this.terminalListeners.add(listener);
-        return () => this.terminalListeners.delete(listener);
-      }
-      assertOpen() {
-        if (this.closedError) throw this.closedError;
-      }
-      readonlyTx(name, lifetime) {
-        this.assertOpen();
-        const envelope = this.makeEnvelope(name, void 0);
-        try {
-          const result = this.pw.packet.ExecuteTransaction(envelope);
-          return lifetime ? result.Attach(lifetime) : result;
-        } finally {
-          envelope.Destroy();
-        }
-      }
-      async withLock(fn) {
-        this.assertOpen();
-        const previous = this.lock;
-        let release;
-        this.lock = new Promise((resolveLock) => {
-          release = resolveLock;
-        });
-        await previous;
-        try {
-          this.assertOpen();
-          if (this.expiredDrain) await this.expiredDrain;
-          this.assertOpen();
-          return await fn();
-        } finally {
-          release();
-        }
-      }
-      enqueue(envelope, timeoutMs) {
-        return new Promise((resolveResult, rejectResult) => {
-          const timer = setTimeout(() => {
-            const pending2 = this.pending.find((candidate) => candidate.timer === timer);
-            if (!pending2 || pending2.settled) return;
-            pending2.settled = true;
-            pending2.expired = true;
-            pending2.reject(new Error(`timed out waiting for transaction result on packet "${this.name}"`));
-            this.expiredDrain = new Promise((resolveDrain) => {
-              this.releaseExpiredDrain = resolveDrain;
-            });
-            pending2.lateTimer = setTimeout(() => {
-              if (this.closedError || !pending2.expired || !this.pending.includes(pending2)) return;
-              this.close(new Error(
-                `packet "${this.name}" closed after a timed-out transaction produced no correlated callback`
-              ));
-            }, LATE_RESULT_DRAIN_MS);
-          }, timeoutMs);
-          const pending = { resolve: resolveResult, reject: rejectResult, timer };
-          this.pending.push(pending);
-          try {
-            this.pw.add_client_message(envelope);
-          } catch (error) {
-            clearTimeout(timer);
-            const index = this.pending.indexOf(pending);
-            if (index >= 0) this.pending.splice(index, 1);
-            rejectResult(asError(error));
-          }
-        });
-      }
-      mutatingTx(name, targ, lifetime, timeoutMs = 25e3) {
-        let envelope;
-        try {
-          this.assertOpen();
-          envelope = this.makeEnvelope(name, targ);
-        } catch (error) {
-          return Promise.reject(asError(error));
-        }
-        return this.withLock(() => this.enqueue(envelope, timeoutMs)).then(
-          (payload) => {
-            envelope.Destroy();
-            return lifetime ? payload.Attach(lifetime) : payload;
-          },
-          (error) => {
-            envelope.Destroy();
-            throw error;
-          }
-        );
-      }
-      newBinary(bytes, lifetime) {
-        this.assertOpen();
-        const value = this.pw.packet.NewBinaryFromBuffer(bytes);
-        return lifetime ? value.Attach(lifetime) : value;
-      }
-      close(error = new Error(`packet "${this.name}" is closed`)) {
-        if (this.closedError) return;
-        this.closedError = error;
-        const pending = this.pending.splice(0);
-        for (const call of pending) {
-          clearTimeout(call.timer);
-          if (call.lateTimer) clearTimeout(call.lateTimer);
-          call.payload?.Destroy();
-          if (!call.settled) {
-            call.settled = true;
-            call.reject(error);
-          }
-        }
-        this.releaseExpiredDrain?.();
-        this.releaseExpiredDrain = void 0;
-        this.expiredDrain = void 0;
-        if (!this.terminalNotified) {
-          this.terminalNotified = true;
-          for (const listener of this.terminalListeners) listener(error);
-          this.terminalListeners.clear();
-          this.onTerminal(error);
-        }
-      }
-      releaseExpired(pending) {
-        const index = this.pending.indexOf(pending);
-        if (index >= 0) this.pending.splice(index, 1);
-        if (pending.lateTimer) clearTimeout(pending.lateTimer);
-        pending.payload?.Destroy();
-        this.releaseExpiredDrain?.();
-        this.releaseExpiredDrain = void 0;
-        this.expiredDrain = void 0;
-      }
-    };
-    AdaptHostShutdownError = class extends AggregateError {
-      requiresProcessExit;
-      constructor(errors, requiresProcessExit) {
-        super(errors, "AdaptHost shutdown encountered errors");
-        this.name = "AdaptHostShutdownError";
-        this.requiresProcessExit = requiresProcessExit;
-      }
-    };
-    AdaptHost = class {
-      wrapper;
-      packets = /* @__PURE__ */ new Map();
-      exposedPackets = /* @__PURE__ */ new Set();
-      brokerUrl;
-      log;
-      unit;
-      shutdownWrapper;
-      constructor(brokerUrl, log = () => {
-      }, options = {}) {
-        this.brokerUrl = brokerUrl;
-        this.log = log;
-        this.unit = options.unit ?? locateUnit();
-        this.shutdownWrapper = options.shutdownWrapper;
-      }
-      get packetCount() {
-        return this.packets.size;
-      }
-      async boot() {
-        if (this.wrapper) return;
-        this.wrapper = await adapt_wrapper.start([
-          "--broker_address",
-          this.brokerUrl,
-          "--test_mode",
-          "--logger_config",
-          "--level",
-          "WARNING",
-          "--stdout",
-          "stderr",
-          "--logger_config_end"
-        ]);
-        this.wrapper.on_packet_created_cb = (cid) => {
-          this.log(`wrapper: packet ready ${cid.slice(0, 12)}\u2026`);
-        };
-        this.wrapper.start();
-      }
-      createPacket(name, seed, signingSecret, options = {}) {
-        const wrapper = this.wrapper;
-        if (!wrapper) return Promise.reject(new Error("AdaptHost.boot() must complete before creating packets"));
-        const config = new PacketWrapperConfigurator();
-        config.deferred_exposure = options.deferredExposure ?? false;
-        const args = [
-          "--unit_hash",
-          this.unit.hash,
-          "--seed_phrase",
-          seed,
-          "--unit_dir_path",
-          this.unit.dir
-        ];
-        if (signingSecret) args.push("--init_trn_argument", JSON.stringify(signingSecret));
-        config.process_arguments(args);
-        return new Promise((resolveCreate, rejectCreate) => {
-          let settled = false;
-          const timer = setTimeout(() => {
-            settled = true;
-            rejectCreate(new Error(`packet creation for "${name}" timed out`));
-          }, 3e4);
-          try {
-            wrapper.packet_manager.create_packet(config, (pw) => {
-              if (settled) {
-                pw.dispose();
-                return;
-              }
-              settled = true;
-              clearTimeout(timer);
-              const cid = withScope((lifetime) => pw.packet.GetContainerID().Attach(lifetime).Visualize());
-              let packet;
-              packet = new Packet(name, cid, pw, (error) => {
-                queueMicrotask(() => {
-                  if (this.packets.get(cid) !== packet) return;
-                  try {
-                    this.removePacket(cid, error);
-                  } catch (removeError) {
-                    this.log(`[${name}] terminal packet removal failed:`, removeError);
-                  }
-                });
-              });
-              this.packets.set(cid, packet);
-              if (!config.deferred_exposure) this.exposedPackets.add(cid);
-              resolveCreate(packet);
-            }, this.unit.contents);
-          } catch (error) {
-            if (settled) return;
-            settled = true;
-            clearTimeout(timer);
-            rejectCreate(asError(error));
-          }
-        });
-      }
-      exposePacket(cid) {
-        const wrapper = this.wrapper;
-        const packet = this.packets.get(cid);
-        if (!wrapper || !packet) throw new Error(`cannot expose unknown packet ${cid}`);
-        if (packet.isClosed) throw new Error(`cannot expose closed packet ${cid}`);
-        wrapper.expose_packet(cid);
-        this.exposedPackets.add(cid);
-      }
-      isPacketExposed(cid) {
-        return this.exposedPackets.has(cid);
-      }
-      removePacket(cid, error = new Error(`packet ${cid} removed from host`)) {
-        const wrapper = this.wrapper;
-        if (!wrapper) throw new Error("AdaptHost is not booted");
-        const packet = this.packets.get(cid);
-        if (!packet) return;
-        packet.close(error);
-        wrapper.remove_packet(cid);
-        this.packets.delete(cid);
-        this.exposedPackets.delete(cid);
-      }
-      close() {
-        if (!this.wrapper) return;
-        const errors = [];
-        for (const cid of [...this.packets.keys()]) {
-          try {
-            this.removePacket(cid, new Error("AdaptHost closed"));
-          } catch (error) {
-            errors.push(asError(error));
-          }
-        }
-        this.wrapper = void 0;
-        if (errors.length) throw new AggregateError(errors, "failed to remove all hosted packets");
-      }
-      /**
-       * Release every public SDK resource. SDK 0.10.12 exposes packet disposal but
-       * not its private broker client's stop(), so a real native wrapper reports
-       * that the owning process must exit after graceful daemon cleanup.
-       */
-      async shutdown() {
-        const wrapper = this.wrapper;
-        if (!wrapper) return { requiresProcessExit: false };
-        const errors = [];
-        let requiresProcessExit = true;
-        try {
-          this.close();
-        } catch (error) {
-          errors.push(error);
-        }
-        try {
-          if (this.shutdownWrapper) {
-            await this.shutdownWrapper(wrapper);
-            requiresProcessExit = false;
-          } else {
-            const futureWrapper = wrapper;
-            const publicStop = futureWrapper.shutdown ?? futureWrapper.stop ?? futureWrapper.dispose;
-            if (typeof publicStop === "function") {
-              await publicStop.call(wrapper);
-              requiresProcessExit = false;
-            }
-          }
-        } catch (error) {
-          errors.push(error);
-        }
-        this.wrapper = void 0;
-        if (errors.length > 0) throw new AdaptHostShutdownError(errors, requiresProcessExit);
-        return { requiresProcessExit };
-      }
-    };
-  }
-});
-
 // node_modules/zod/v3/helpers/util.js
 var util, objectUtil, ZodParsedType, getParsedType;
 var init_util = __esm({
@@ -861,8 +421,8 @@ var init_parseUtil = __esm({
   "node_modules/zod/v3/helpers/parseUtil.js"() {
     init_errors();
     init_en();
-    makeIssue = (params2) => {
-      const { data, path, errorMaps, issueData } = params2;
+    makeIssue = (params) => {
+      const { data, path, errorMaps, issueData } = params;
       const fullPath = [...path, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
@@ -971,17 +531,17 @@ var init_errorUtil = __esm({
 });
 
 // node_modules/zod/v3/types.js
-function processCreateParams(params2) {
-  if (!params2)
+function processCreateParams(params) {
+  if (!params)
     return {};
-  const { errorMap: errorMap2, invalid_type_error, required_error, description } = params2;
+  const { errorMap: errorMap2, invalid_type_error, required_error, description } = params;
   if (errorMap2 && (invalid_type_error || required_error)) {
     throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
   }
   if (errorMap2)
     return { errorMap: errorMap2, description };
   const customMap = (iss, ctx) => {
-    const { message } = params2;
+    const { message } = params;
     if (iss.code === "invalid_enum_value") {
       return { message: message ?? ctx.defaultError };
     }
@@ -1128,15 +688,15 @@ function mergeValues(a, b) {
     return { valid: false };
   }
 }
-function createZodEnum(values, params2) {
+function createZodEnum(values, params) {
   return new ZodEnum({
     values,
     typeName: ZodFirstPartyTypeKind.ZodEnum,
-    ...processCreateParams(params2)
+    ...processCreateParams(params)
   });
 }
-function cleanParams(params2, data) {
-  const p = typeof params2 === "function" ? params2(data) : typeof params2 === "string" ? { message: params2 } : params2;
+function cleanParams(params, data) {
+  const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
   const p2 = typeof p === "string" ? { message: p } : p;
   return p2;
 }
@@ -1147,16 +707,16 @@ function custom(check, _params = {}, fatal) {
       if (r instanceof Promise) {
         return r.then((r2) => {
           if (!r2) {
-            const params2 = cleanParams(_params, data);
-            const _fatal = params2.fatal ?? fatal ?? true;
-            ctx.addIssue({ code: "custom", ...params2, fatal: _fatal });
+            const params = cleanParams(_params, data);
+            const _fatal = params.fatal ?? fatal ?? true;
+            ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
           }
         });
       }
       if (!r) {
-        const params2 = cleanParams(_params, data);
-        const _fatal = params2.fatal ?? fatal ?? true;
-        ctx.addIssue({ code: "custom", ...params2, fatal: _fatal });
+        const params = cleanParams(_params, data);
+        const _fatal = params.fatal ?? fatal ?? true;
+        ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
       }
       return;
     });
@@ -1249,20 +809,20 @@ var init_types = __esm({
         const result = this._parse(input);
         return Promise.resolve(result);
       }
-      parse(data, params2) {
-        const result = this.safeParse(data, params2);
+      parse(data, params) {
+        const result = this.safeParse(data, params);
         if (result.success)
           return result.data;
         throw result.error;
       }
-      safeParse(data, params2) {
+      safeParse(data, params) {
         const ctx = {
           common: {
             issues: [],
-            async: params2?.async ?? false,
-            contextualErrorMap: params2?.errorMap
+            async: params?.async ?? false,
+            contextualErrorMap: params?.errorMap
           },
-          path: params2?.path || [],
+          path: params?.path || [],
           schemaErrorMap: this._def.errorMap,
           parent: null,
           data,
@@ -1307,20 +867,20 @@ var init_types = __esm({
           issues: ctx.common.issues
         });
       }
-      async parseAsync(data, params2) {
-        const result = await this.safeParseAsync(data, params2);
+      async parseAsync(data, params) {
+        const result = await this.safeParseAsync(data, params);
         if (result.success)
           return result.data;
         throw result.error;
       }
-      async safeParseAsync(data, params2) {
+      async safeParseAsync(data, params) {
         const ctx = {
           common: {
             issues: [],
-            contextualErrorMap: params2?.errorMap,
+            contextualErrorMap: params?.errorMap,
             async: true
           },
-          path: params2?.path || [],
+          path: params?.path || [],
           schemaErrorMap: this._def.errorMap,
           parent: null,
           data,
@@ -2046,12 +1606,12 @@ var init_types = __esm({
         return max;
       }
     };
-    ZodString.create = (params2) => {
+    ZodString.create = (params) => {
       return new ZodString({
         checks: [],
         typeName: ZodFirstPartyTypeKind.ZodString,
-        coerce: params2?.coerce ?? false,
-        ...processCreateParams(params2)
+        coerce: params?.coerce ?? false,
+        ...processCreateParams(params)
       });
     };
     ZodNumber = class _ZodNumber extends ZodType {
@@ -2278,12 +1838,12 @@ var init_types = __esm({
         return Number.isFinite(min) && Number.isFinite(max);
       }
     };
-    ZodNumber.create = (params2) => {
+    ZodNumber.create = (params) => {
       return new ZodNumber({
         checks: [],
         typeName: ZodFirstPartyTypeKind.ZodNumber,
-        coerce: params2?.coerce || false,
-        ...processCreateParams(params2)
+        coerce: params?.coerce || false,
+        ...processCreateParams(params)
       });
     };
     ZodBigInt = class _ZodBigInt extends ZodType {
@@ -2450,12 +2010,12 @@ var init_types = __esm({
         return max;
       }
     };
-    ZodBigInt.create = (params2) => {
+    ZodBigInt.create = (params) => {
       return new ZodBigInt({
         checks: [],
         typeName: ZodFirstPartyTypeKind.ZodBigInt,
-        coerce: params2?.coerce ?? false,
-        ...processCreateParams(params2)
+        coerce: params?.coerce ?? false,
+        ...processCreateParams(params)
       });
     };
     ZodBoolean = class extends ZodType {
@@ -2476,11 +2036,11 @@ var init_types = __esm({
         return OK(input.data);
       }
     };
-    ZodBoolean.create = (params2) => {
+    ZodBoolean.create = (params) => {
       return new ZodBoolean({
         typeName: ZodFirstPartyTypeKind.ZodBoolean,
-        coerce: params2?.coerce || false,
-        ...processCreateParams(params2)
+        coerce: params?.coerce || false,
+        ...processCreateParams(params)
       });
     };
     ZodDate = class _ZodDate extends ZodType {
@@ -2584,12 +2144,12 @@ var init_types = __esm({
         return max != null ? new Date(max) : null;
       }
     };
-    ZodDate.create = (params2) => {
+    ZodDate.create = (params) => {
       return new ZodDate({
         checks: [],
-        coerce: params2?.coerce || false,
+        coerce: params?.coerce || false,
         typeName: ZodFirstPartyTypeKind.ZodDate,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     ZodSymbol = class extends ZodType {
@@ -2607,10 +2167,10 @@ var init_types = __esm({
         return OK(input.data);
       }
     };
-    ZodSymbol.create = (params2) => {
+    ZodSymbol.create = (params) => {
       return new ZodSymbol({
         typeName: ZodFirstPartyTypeKind.ZodSymbol,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     ZodUndefined = class extends ZodType {
@@ -2628,10 +2188,10 @@ var init_types = __esm({
         return OK(input.data);
       }
     };
-    ZodUndefined.create = (params2) => {
+    ZodUndefined.create = (params) => {
       return new ZodUndefined({
         typeName: ZodFirstPartyTypeKind.ZodUndefined,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     ZodNull = class extends ZodType {
@@ -2649,10 +2209,10 @@ var init_types = __esm({
         return OK(input.data);
       }
     };
-    ZodNull.create = (params2) => {
+    ZodNull.create = (params) => {
       return new ZodNull({
         typeName: ZodFirstPartyTypeKind.ZodNull,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     ZodAny = class extends ZodType {
@@ -2664,10 +2224,10 @@ var init_types = __esm({
         return OK(input.data);
       }
     };
-    ZodAny.create = (params2) => {
+    ZodAny.create = (params) => {
       return new ZodAny({
         typeName: ZodFirstPartyTypeKind.ZodAny,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     ZodUnknown = class extends ZodType {
@@ -2679,10 +2239,10 @@ var init_types = __esm({
         return OK(input.data);
       }
     };
-    ZodUnknown.create = (params2) => {
+    ZodUnknown.create = (params) => {
       return new ZodUnknown({
         typeName: ZodFirstPartyTypeKind.ZodUnknown,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     ZodNever = class extends ZodType {
@@ -2696,10 +2256,10 @@ var init_types = __esm({
         return INVALID;
       }
     };
-    ZodNever.create = (params2) => {
+    ZodNever.create = (params) => {
       return new ZodNever({
         typeName: ZodFirstPartyTypeKind.ZodNever,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     ZodVoid = class extends ZodType {
@@ -2717,10 +2277,10 @@ var init_types = __esm({
         return OK(input.data);
       }
     };
-    ZodVoid.create = (params2) => {
+    ZodVoid.create = (params) => {
       return new ZodVoid({
         typeName: ZodFirstPartyTypeKind.ZodVoid,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     ZodArray = class _ZodArray extends ZodType {
@@ -2814,14 +2374,14 @@ var init_types = __esm({
         return this.min(1, message);
       }
     };
-    ZodArray.create = (schema, params2) => {
+    ZodArray.create = (schema, params) => {
       return new ZodArray({
         type: schema,
         minLength: null,
         maxLength: null,
         exactLength: null,
         typeName: ZodFirstPartyTypeKind.ZodArray,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     ZodObject = class _ZodObject extends ZodType {
@@ -3135,31 +2695,31 @@ var init_types = __esm({
         return createZodEnum(util.objectKeys(this.shape));
       }
     };
-    ZodObject.create = (shape, params2) => {
+    ZodObject.create = (shape, params) => {
       return new ZodObject({
         shape: () => shape,
         unknownKeys: "strip",
         catchall: ZodNever.create(),
         typeName: ZodFirstPartyTypeKind.ZodObject,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
-    ZodObject.strictCreate = (shape, params2) => {
+    ZodObject.strictCreate = (shape, params) => {
       return new ZodObject({
         shape: () => shape,
         unknownKeys: "strict",
         catchall: ZodNever.create(),
         typeName: ZodFirstPartyTypeKind.ZodObject,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
-    ZodObject.lazycreate = (shape, params2) => {
+    ZodObject.lazycreate = (shape, params) => {
       return new ZodObject({
         shape,
         unknownKeys: "strip",
         catchall: ZodNever.create(),
         typeName: ZodFirstPartyTypeKind.ZodObject,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     ZodUnion = class extends ZodType {
@@ -3246,11 +2806,11 @@ var init_types = __esm({
         return this._def.options;
       }
     };
-    ZodUnion.create = (types, params2) => {
+    ZodUnion.create = (types, params) => {
       return new ZodUnion({
         options: types,
         typeName: ZodFirstPartyTypeKind.ZodUnion,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     getDiscriminator = (type) => {
@@ -3337,7 +2897,7 @@ var init_types = __esm({
        * @param types an array of object schemas
        * @param params
        */
-      static create(discriminator, options, params2) {
+      static create(discriminator, options, params) {
         const optionsMap = /* @__PURE__ */ new Map();
         for (const type of options) {
           const discriminatorValues = getDiscriminator(type.shape[discriminator]);
@@ -3356,7 +2916,7 @@ var init_types = __esm({
           discriminator,
           options,
           optionsMap,
-          ...processCreateParams(params2)
+          ...processCreateParams(params)
         });
       }
     };
@@ -3405,12 +2965,12 @@ var init_types = __esm({
         }
       }
     };
-    ZodIntersection.create = (left, right, params2) => {
+    ZodIntersection.create = (left, right, params) => {
       return new ZodIntersection({
         left,
         right,
         typeName: ZodFirstPartyTypeKind.ZodIntersection,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     ZodTuple = class _ZodTuple extends ZodType {
@@ -3469,7 +3029,7 @@ var init_types = __esm({
         });
       }
     };
-    ZodTuple.create = (schemas, params2) => {
+    ZodTuple.create = (schemas, params) => {
       if (!Array.isArray(schemas)) {
         throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
       }
@@ -3477,7 +3037,7 @@ var init_types = __esm({
         items: schemas,
         typeName: ZodFirstPartyTypeKind.ZodTuple,
         rest: null,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     ZodRecord = class _ZodRecord extends ZodType {
@@ -3591,12 +3151,12 @@ var init_types = __esm({
         }
       }
     };
-    ZodMap.create = (keyType, valueType, params2) => {
+    ZodMap.create = (keyType, valueType, params) => {
       return new ZodMap({
         valueType,
         keyType,
         typeName: ZodFirstPartyTypeKind.ZodMap,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     ZodSet = class _ZodSet extends ZodType {
@@ -3675,13 +3235,13 @@ var init_types = __esm({
         return this.min(1, message);
       }
     };
-    ZodSet.create = (valueType, params2) => {
+    ZodSet.create = (valueType, params) => {
       return new ZodSet({
         valueType,
         minSize: null,
         maxSize: null,
         typeName: ZodFirstPartyTypeKind.ZodSet,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     ZodFunction = class _ZodFunction extends ZodType {
@@ -3721,18 +3281,18 @@ var init_types = __esm({
             }
           });
         }
-        const params2 = { errorMap: ctx.common.contextualErrorMap };
+        const params = { errorMap: ctx.common.contextualErrorMap };
         const fn = ctx.data;
         if (this._def.returns instanceof ZodPromise) {
           const me = this;
           return OK(async function(...args) {
             const error = new ZodError([]);
-            const parsedArgs = await me._def.args.parseAsync(args, params2).catch((e) => {
+            const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
               error.addIssue(makeArgsIssue(args, e));
               throw error;
             });
             const result = await Reflect.apply(fn, this, parsedArgs);
-            const parsedReturns = await me._def.returns._def.type.parseAsync(result, params2).catch((e) => {
+            const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
               error.addIssue(makeReturnsIssue(result, e));
               throw error;
             });
@@ -3741,12 +3301,12 @@ var init_types = __esm({
         } else {
           const me = this;
           return OK(function(...args) {
-            const parsedArgs = me._def.args.safeParse(args, params2);
+            const parsedArgs = me._def.args.safeParse(args, params);
             if (!parsedArgs.success) {
               throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
             }
             const result = Reflect.apply(fn, this, parsedArgs.data);
-            const parsedReturns = me._def.returns.safeParse(result, params2);
+            const parsedReturns = me._def.returns.safeParse(result, params);
             if (!parsedReturns.success) {
               throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
             }
@@ -3780,12 +3340,12 @@ var init_types = __esm({
         const validatedFunc = this.parse(func);
         return validatedFunc;
       }
-      static create(args, returns, params2) {
+      static create(args, returns, params) {
         return new _ZodFunction({
           args: args ? args : ZodTuple.create([]).rest(ZodUnknown.create()),
           returns: returns || ZodUnknown.create(),
           typeName: ZodFirstPartyTypeKind.ZodFunction,
-          ...processCreateParams(params2)
+          ...processCreateParams(params)
         });
       }
     };
@@ -3799,11 +3359,11 @@ var init_types = __esm({
         return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
       }
     };
-    ZodLazy.create = (getter, params2) => {
+    ZodLazy.create = (getter, params) => {
       return new ZodLazy({
         getter,
         typeName: ZodFirstPartyTypeKind.ZodLazy,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     ZodLiteral = class extends ZodType {
@@ -3823,11 +3383,11 @@ var init_types = __esm({
         return this._def.value;
       }
     };
-    ZodLiteral.create = (value, params2) => {
+    ZodLiteral.create = (value, params) => {
       return new ZodLiteral({
         value,
         typeName: ZodFirstPartyTypeKind.ZodLiteral,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     ZodEnum = class _ZodEnum extends ZodType {
@@ -3926,11 +3486,11 @@ var init_types = __esm({
         return this._def.values;
       }
     };
-    ZodNativeEnum.create = (values, params2) => {
+    ZodNativeEnum.create = (values, params) => {
       return new ZodNativeEnum({
         values,
         typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     ZodPromise = class extends ZodType {
@@ -3956,11 +3516,11 @@ var init_types = __esm({
         }));
       }
     };
-    ZodPromise.create = (schema, params2) => {
+    ZodPromise.create = (schema, params) => {
       return new ZodPromise({
         type: schema,
         typeName: ZodFirstPartyTypeKind.ZodPromise,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     ZodEffects = class extends ZodType {
@@ -4086,20 +3646,20 @@ var init_types = __esm({
         util.assertNever(effect);
       }
     };
-    ZodEffects.create = (schema, effect, params2) => {
+    ZodEffects.create = (schema, effect, params) => {
       return new ZodEffects({
         schema,
         typeName: ZodFirstPartyTypeKind.ZodEffects,
         effect,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
-    ZodEffects.createWithPreprocess = (preprocess, schema, params2) => {
+    ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
       return new ZodEffects({
         schema,
         effect: { type: "preprocess", transform: preprocess },
         typeName: ZodFirstPartyTypeKind.ZodEffects,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     ZodOptional = class extends ZodType {
@@ -4114,11 +3674,11 @@ var init_types = __esm({
         return this._def.innerType;
       }
     };
-    ZodOptional.create = (type, params2) => {
+    ZodOptional.create = (type, params) => {
       return new ZodOptional({
         innerType: type,
         typeName: ZodFirstPartyTypeKind.ZodOptional,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     ZodNullable = class extends ZodType {
@@ -4133,11 +3693,11 @@ var init_types = __esm({
         return this._def.innerType;
       }
     };
-    ZodNullable.create = (type, params2) => {
+    ZodNullable.create = (type, params) => {
       return new ZodNullable({
         innerType: type,
         typeName: ZodFirstPartyTypeKind.ZodNullable,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     ZodDefault = class extends ZodType {
@@ -4157,12 +3717,12 @@ var init_types = __esm({
         return this._def.innerType;
       }
     };
-    ZodDefault.create = (type, params2) => {
+    ZodDefault.create = (type, params) => {
       return new ZodDefault({
         innerType: type,
         typeName: ZodFirstPartyTypeKind.ZodDefault,
-        defaultValue: typeof params2.default === "function" ? params2.default : () => params2.default,
-        ...processCreateParams(params2)
+        defaultValue: typeof params.default === "function" ? params.default : () => params.default,
+        ...processCreateParams(params)
       });
     };
     ZodCatch = class extends ZodType {
@@ -4210,12 +3770,12 @@ var init_types = __esm({
         return this._def.innerType;
       }
     };
-    ZodCatch.create = (type, params2) => {
+    ZodCatch.create = (type, params) => {
       return new ZodCatch({
         innerType: type,
         typeName: ZodFirstPartyTypeKind.ZodCatch,
-        catchValue: typeof params2.catch === "function" ? params2.catch : () => params2.catch,
-        ...processCreateParams(params2)
+        catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
+        ...processCreateParams(params)
       });
     };
     ZodNaN = class extends ZodType {
@@ -4233,10 +3793,10 @@ var init_types = __esm({
         return { status: "valid", value: input.data };
       }
     };
-    ZodNaN.create = (params2) => {
+    ZodNaN.create = (params) => {
       return new ZodNaN({
         typeName: ZodFirstPartyTypeKind.ZodNaN,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     BRAND = Symbol("zod_brand");
@@ -4324,11 +3884,11 @@ var init_types = __esm({
         return this._def.innerType;
       }
     };
-    ZodReadonly.create = (type, params2) => {
+    ZodReadonly.create = (type, params) => {
       return new ZodReadonly({
         innerType: type,
         typeName: ZodFirstPartyTypeKind.ZodReadonly,
-        ...processCreateParams(params2)
+        ...processCreateParams(params)
       });
     };
     late = {
@@ -4372,9 +3932,9 @@ var init_types = __esm({
       ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
       ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly";
     })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
-    instanceOfType = (cls, params2 = {
+    instanceOfType = (cls, params = {
       message: `Input not instance of ${cls.name}`
-    }) => custom((data) => data instanceof cls, params2);
+    }) => custom((data) => data instanceof cls, params);
     stringType = ZodString.create;
     numberType = ZodNumber.create;
     nanType = ZodNaN.create;
@@ -4559,26 +4119,29 @@ var init_zod = __esm({
 // src/config.ts
 import * as nodeFs from "node:fs";
 import { homedir } from "node:os";
-import { dirname as dirname2, isAbsolute, join as join2, parse, resolve as resolve2 } from "node:path";
+import { dirname, isAbsolute, join, parse, resolve } from "node:path";
+function daemonMode(config) {
+  return config.daemon?.mode ?? "embedded";
+}
 function defaultConfig(home = homedir()) {
   return {
     version: 1,
     brokerUrl: "wss://broker1.ours.network",
-    stateDir: resolve2(home, ".ours-cowork"),
+    stateDir: resolve(home, ".ours-cowork"),
     rest: { enabled: true, port: 3052 }
   };
 }
 function loadConfig(env = process.env, io = {}) {
-  const fs2 = io.fs ?? nodeFs;
+  const fs3 = io.fs ?? nodeFs;
   const defaults = defaultConfig(io.home);
-  const configPath = resolve2(env.OURS_COWORK_CONFIG ?? join2(io.home ?? homedir(), ".ours-cowork", "config.json"));
+  const configPath = resolve(env.OURS_COWORK_CONFIG ?? join(io.home ?? homedir(), ".ours-cowork", "config.json"));
   let file = defaults;
-  const stat = lstatIfPresent(fs2, configPath);
+  const stat = lstatIfPresent(fs3, configPath);
   if (stat) {
-    assertSecureFile(fs2, configPath, "config file");
+    assertSecureFile(fs3, configPath, "config file");
     let parsed;
     try {
-      parsed = JSON.parse(readSecureFile(fs2, configPath, "config file").toString("utf8"));
+      parsed = JSON.parse(readSecureFile(fs3, configPath, "config file").toString("utf8"));
     } catch (error) {
       throw new CoworkConfigError(`malformed cowork config at ${configPath}`, { cause: error });
     }
@@ -4591,42 +4154,100 @@ function loadConfig(env = process.env, io = {}) {
     throw new CoworkConfigError(`configured cowork config does not exist: ${configPath}`);
   }
   const restPort = env.OURS_COWORK_REST_PORT === void 0 ? void 0 : parsePort(env.OURS_COWORK_REST_PORT);
+  const daemon = mergeDaemonSelection(env, file.daemon);
   try {
     return CoworkConfigSchema.parse({
       version: 1,
       brokerUrl: env.OURS_COWORK_BROKER_URL ?? file.brokerUrl,
-      stateDir: resolve2(env.OURS_COWORK_STATE_DIR ?? file.stateDir),
+      stateDir: resolve(env.OURS_COWORK_STATE_DIR ?? file.stateDir),
       rest: {
         enabled: restPort === void 0 ? file.rest.enabled : true,
         port: restPort ?? file.rest.port
-      }
+      },
+      ...daemon === void 0 ? {} : { daemon }
     });
   } catch (error) {
     throw new CoworkConfigError("invalid effective cowork config", { cause: error });
   }
 }
+function mergeDaemonSelection(env, file) {
+  const mode = env.OURS_COWORK_DAEMON_MODE;
+  const endpoint = env.OURS_COWORK_DAEMON_ENDPOINT;
+  const stateDir = env.OURS_COWORK_DAEMON_STATE_DIR;
+  if (mode === void 0 && endpoint === void 0 && stateDir === void 0) return file;
+  if (mode !== void 0 && mode !== "embedded" && mode !== "external") {
+    throw new CoworkConfigError('OURS_COWORK_DAEMON_MODE must be "embedded" or "external"');
+  }
+  const effectiveMode = mode ?? file?.mode ?? "external";
+  if (effectiveMode === "embedded") {
+    if (endpoint !== void 0 || stateDir !== void 0) {
+      throw new CoworkConfigError(
+        'OURS_COWORK_DAEMON_ENDPOINT and OURS_COWORK_DAEMON_STATE_DIR require daemon mode "external"'
+      );
+    }
+    return { mode: "embedded" };
+  }
+  const effectiveEndpoint = endpoint ?? file?.endpoint;
+  const effectiveStateDir = stateDir ?? file?.stateDir;
+  return {
+    mode: "external",
+    ...effectiveEndpoint === void 0 ? {} : { endpoint: effectiveEndpoint },
+    ...effectiveStateDir === void 0 ? {} : { stateDir: effectiveStateDir }
+  };
+}
+function isDaemonOrigin(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return false;
+  }
+  return (url.protocol === "http:" || url.protocol === "https:") && url.username === "" && url.password === "" && url.search === "" && url.hash === "" && (url.pathname === "" || url.pathname === "/");
+}
+function isConfidentialDaemonEndpoint(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return false;
+  }
+  return url.protocol === "https:" || isLoopbackHost(url.hostname);
+}
+function isLoopbackHost(hostname) {
+  const host = hostname.toLowerCase().replace(/^\[(.*)\]$/, "$1");
+  if (host === "localhost") return true;
+  if (host === "::1" || host === "0:0:0:0:0:0:0:1") return true;
+  const octets = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(host);
+  if (!octets) return false;
+  const parts = octets.slice(1).map(Number);
+  return parts.every((part) => part <= 255) && parts[0] === 127;
+}
+function normalizeDaemonEndpoint(value) {
+  const url = new URL(value);
+  return `${url.protocol}//${url.host}`;
+}
 function ensureRuntimeState(config, io = {}) {
   const parsed = CoworkConfigSchema.parse(config);
-  const fs2 = io.fs ?? nodeFs;
-  const stateDir = resolve2(parsed.stateDir);
-  assertSecureAncestors(fs2, stateDir, "state directory");
-  const existing = lstatIfPresent(fs2, stateDir);
+  const fs3 = io.fs ?? nodeFs;
+  const stateDir = resolve(parsed.stateDir);
+  assertSecureAncestors(fs3, stateDir, "state directory");
+  const existing = lstatIfPresent(fs3, stateDir);
   if (!existing) {
-    createSecureDirectoryTree(fs2, stateDir, "state directory");
+    createSecureDirectoryTree(fs3, stateDir, "state directory");
   }
-  assertSecureDirectory(fs2, stateDir, "state directory");
-  const roomsPath = join2(stateDir, "rooms");
-  const rooms = lstatIfPresent(fs2, roomsPath);
+  assertSecureDirectory(fs3, stateDir, "state directory");
+  const roomsPath = join(stateDir, "rooms");
+  const rooms = lstatIfPresent(fs3, roomsPath);
   if (!rooms) {
-    fs2.mkdirSync(roomsPath, { mode: DIRECTORY_MODE });
-    secureOpenedDirectory(fs2, roomsPath, "rooms directory");
-    fsyncDirectory(fs2, stateDir);
+    fs3.mkdirSync(roomsPath, { mode: DIRECTORY_MODE });
+    secureOpenedDirectory(fs3, roomsPath, "rooms directory");
+    fsyncDirectory(fs3, stateDir);
   }
-  assertSecureDirectory(fs2, roomsPath, "rooms directory");
+  assertSecureDirectory(fs3, roomsPath, "rooms directory");
   return {
-    socketPath: join2(stateDir, "management.sock"),
-    pidPath: join2(stateDir, "daemon.pid"),
-    lockPath: join2(stateDir, "daemon.lock")
+    socketPath: join(stateDir, "management.sock"),
+    pidPath: join(stateDir, "daemon.pid"),
+    lockPath: join(stateDir, "daemon.lock")
   };
 }
 function parsePort(value) {
@@ -4637,15 +4258,15 @@ function parsePort(value) {
   if (port > 65535) throw new CoworkConfigError("OURS_COWORK_REST_PORT must be from 1 to 65535");
   return port;
 }
-function assertSecureAncestors(fs2, path, label) {
-  const absolute = isAbsolute(path) ? path : resolve2(path);
+function assertSecureAncestors(fs3, path, label) {
+  const absolute = isAbsolute(path) ? path : resolve(path);
   const root = parse(absolute).root;
-  const rootOwner = fs2.lstatSync(root).uid;
+  const rootOwner = fs3.lstatSync(root).uid;
   let cursor = root;
   const components = absolute.slice(root.length).split("/").filter(Boolean);
   for (const [index, component] of components.entries()) {
-    cursor = join2(cursor, component);
-    const stat = lstatIfPresent(fs2, cursor);
+    cursor = join(cursor, component);
+    const stat = lstatIfPresent(fs3, cursor);
     if (stat?.isSymbolicLink()) throw new CoworkConfigError(`${label} must not traverse a symbolic link (symlink): ${cursor}`);
     if (!stat) break;
     if (!stat.isDirectory()) {
@@ -4664,39 +4285,39 @@ function assertTrustedAncestor(stat, rootOwner, path, label) {
     throw new CoworkConfigError(`${label} has an unsafe writable ancestor: ${path}`);
   }
 }
-function createSecureDirectoryTree(fs2, path, label) {
+function createSecureDirectoryTree(fs3, path, label) {
   const missing = [];
   let cursor = path;
-  while (!lstatIfPresent(fs2, cursor)) {
+  while (!lstatIfPresent(fs3, cursor)) {
     missing.push(cursor);
-    const parent = dirname2(cursor);
+    const parent = dirname(cursor);
     if (parent === cursor) throw new CoworkConfigError(`cannot locate an existing ancestor for ${label}`);
     cursor = parent;
   }
-  assertSecureAncestors(fs2, path, label);
+  assertSecureAncestors(fs3, path, label);
   for (const directory of missing.reverse()) {
-    fs2.mkdirSync(directory, { mode: DIRECTORY_MODE });
-    secureOpenedDirectory(fs2, directory, label);
-    fsyncDirectory(fs2, dirname2(directory));
+    fs3.mkdirSync(directory, { mode: DIRECTORY_MODE });
+    secureOpenedDirectory(fs3, directory, label);
+    fsyncDirectory(fs3, dirname(directory));
   }
 }
-function secureOpenedDirectory(fs2, path, label) {
+function secureOpenedDirectory(fs3, path, label) {
   let fd;
   try {
-    fd = fs2.openSync(path, nodeFs.constants.O_RDONLY | NO_FOLLOW);
-    const opened = fs2.fstatSync(fd);
-    const current = fs2.lstatSync(path);
+    fd = fs3.openSync(path, nodeFs.constants.O_RDONLY | NO_FOLLOW);
+    const opened = fs3.fstatSync(fd);
+    const current = fs3.lstatSync(path);
     if (!opened.isDirectory() || current.isSymbolicLink() || opened.dev !== current.dev || opened.ino !== current.ino) {
       throw new CoworkConfigError(`${label} changed while opening`);
     }
-    fs2.fchmodSync(fd, DIRECTORY_MODE);
-    fs2.fsyncSync(fd);
+    fs3.fchmodSync(fd, DIRECTORY_MODE);
+    fs3.fsyncSync(fd);
   } finally {
-    if (fd !== void 0) fs2.closeSync(fd);
+    if (fd !== void 0) fs3.closeSync(fd);
   }
 }
-function assertSecureDirectory(fs2, path, label) {
-  const stat = fs2.lstatSync(path);
+function assertSecureDirectory(fs3, path, label) {
+  const stat = fs3.lstatSync(path);
   if (stat.isSymbolicLink()) throw new CoworkConfigError(`${label} must not be a symbolic link (symlink)`);
   if (!stat.isDirectory()) throw new CoworkConfigError(`${label} must be a directory`);
   if ((stat.mode & 511) !== DIRECTORY_MODE) {
@@ -4704,8 +4325,8 @@ function assertSecureDirectory(fs2, path, label) {
   }
   assertOwner(stat, label);
 }
-function assertSecureFile(fs2, path, label) {
-  const stat = fs2.lstatSync(path);
+function assertSecureFile(fs3, path, label) {
+  const stat = fs3.lstatSync(path);
   if (stat.isSymbolicLink()) throw new CoworkConfigError(`${label} must not be a symbolic link (symlink)`);
   if (!stat.isFile() || stat.nlink !== 1) throw new CoworkConfigError(`${label} must be a single-link regular file`);
   if ((stat.mode & 511) !== FILE_MODE) throw new CoworkConfigError(`${label} mode must be 0600`);
@@ -4716,38 +4337,38 @@ function assertOwner(stat, label) {
     throw new CoworkConfigError(`${label} must be owned by the current user`);
   }
 }
-function readSecureFile(fs2, path, label) {
+function readSecureFile(fs3, path, label) {
   let fd;
   try {
-    fd = fs2.openSync(path, nodeFs.constants.O_RDONLY | NO_FOLLOW);
-    const opened = fs2.fstatSync(fd);
-    const current = fs2.lstatSync(path);
+    fd = fs3.openSync(path, nodeFs.constants.O_RDONLY | NO_FOLLOW);
+    const opened = fs3.fstatSync(fd);
+    const current = fs3.lstatSync(path);
     if (!opened.isFile() || opened.nlink !== 1 || (opened.mode & 511) !== FILE_MODE || typeof process.getuid === "function" && opened.uid !== process.getuid() || current.isSymbolicLink() || current.dev !== opened.dev || current.ino !== opened.ino) {
       throw new CoworkConfigError(`${label} changed while opening`);
     }
-    return fs2.readFileSync(fd);
+    return fs3.readFileSync(fd);
   } finally {
-    if (fd !== void 0) fs2.closeSync(fd);
+    if (fd !== void 0) fs3.closeSync(fd);
   }
 }
-function fsyncDirectory(fs2, path) {
+function fsyncDirectory(fs3, path) {
   let fd;
   try {
-    fd = fs2.openSync(path, nodeFs.constants.O_RDONLY | NO_FOLLOW);
-    fs2.fsyncSync(fd);
+    fd = fs3.openSync(path, nodeFs.constants.O_RDONLY | NO_FOLLOW);
+    fs3.fsyncSync(fd);
   } finally {
-    if (fd !== void 0) fs2.closeSync(fd);
+    if (fd !== void 0) fs3.closeSync(fd);
   }
 }
-function lstatIfPresent(fs2, path) {
+function lstatIfPresent(fs3, path) {
   try {
-    return fs2.lstatSync(path);
+    return fs3.lstatSync(path);
   } catch (error) {
     if (error.code === "ENOENT") return void 0;
     throw error;
   }
 }
-var DIRECTORY_MODE, FILE_MODE, NO_FOLLOW, CoworkConfigSchema, CoworkConfigError;
+var DIRECTORY_MODE, FILE_MODE, NO_FOLLOW, CoworkDaemonSchema, CoworkConfigSchema, CoworkConfigError;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
@@ -4755,6 +4376,33 @@ var init_config = __esm({
     DIRECTORY_MODE = 448;
     FILE_MODE = 384;
     NO_FOLLOW = nodeFs.constants.O_NOFOLLOW ?? 0;
+    CoworkDaemonSchema = external_exports.object({
+      mode: external_exports.enum(["embedded", "external"]),
+      endpoint: external_exports.string().url().refine(isDaemonOrigin, "daemon.endpoint must be an http(s) origin with no credentials, path, query, or fragment").refine(isConfidentialDaemonEndpoint, "daemon.endpoint must use https:// unless the daemon is on this host (http:// is allowed only for localhost, 127.0.0.0/8, or [::1])").transform(normalizeDaemonEndpoint).optional(),
+      stateDir: external_exports.string().min(1).transform((value) => resolve(value)).optional()
+    }).strict().superRefine((value, ctx) => {
+      if (value.mode === "external") {
+        for (const field of ["endpoint", "stateDir"]) {
+          if (value[field] === void 0) {
+            ctx.addIssue({
+              code: external_exports.ZodIssueCode.custom,
+              path: [field],
+              message: `daemon.${field} is required when daemon.mode is "external"`
+            });
+          }
+        }
+        return;
+      }
+      for (const field of ["endpoint", "stateDir"]) {
+        if (value[field] !== void 0) {
+          ctx.addIssue({
+            code: external_exports.ZodIssueCode.custom,
+            path: [field],
+            message: `daemon.${field} is only valid when daemon.mode is "external"`
+          });
+        }
+      }
+    });
     CoworkConfigSchema = external_exports.object({
       version: external_exports.literal(1),
       brokerUrl: external_exports.string().url().refine((value) => {
@@ -4765,7 +4413,10 @@ var init_config = __esm({
       rest: external_exports.object({
         enabled: external_exports.boolean(),
         port: external_exports.number().int().min(1).max(65535)
-      }).strict()
+      }).strict(),
+      // Absent unless an operator selected a daemon explicitly, so an untouched
+      // deployment keeps producing byte-identical effective configuration.
+      daemon: CoworkDaemonSchema.optional()
     }).strict();
     CoworkConfigError = class extends Error {
       constructor(message, options) {
@@ -4776,6 +4427,271 @@ var init_config = __esm({
   }
 });
 
+// src/ours-runtime.ts
+import { randomBytes } from "node:crypto";
+import * as fs from "node:fs";
+import { join as join2, resolve as resolve2 } from "node:path";
+function createOursHost(config, log = () => {
+}) {
+  return daemonMode(config) === "external" ? new ExternalOursHost(config, log) : new EmbeddedOursHost(config, log);
+}
+function sleep(ms, signal) {
+  return new Promise((resolveSleep) => {
+    const timer = setTimeout(finish, ms);
+    signal.addEventListener("abort", finish, { once: true });
+    function finish() {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", finish);
+      resolveSleep();
+    }
+  });
+}
+function sdkRuntimeStateDir(config) {
+  return resolve2(config.stateDir, "ours-sdk");
+}
+function configureOwnedSdkEnvironment(config) {
+  const stateDir = sdkRuntimeStateDir(config);
+  fs.mkdirSync(stateDir, { recursive: true, mode: 448 });
+  fs.chmodSync(stateDir, 448);
+  process.env.OURS_CONFIG = join2(stateDir, "config.json");
+  process.env.OURS_STATE_DIR = stateDir;
+  process.env.OURS_BROKER_URL = config.brokerUrl;
+  process.env.OURS_PORT = "0";
+  process.env.OURS_API_VISIBILITY = "owner";
+  process.env.OURS_TRANSPORT = "http";
+  process.env.OURS_AUTOSTART = "false";
+  process.env.OURS_GC_INTERVAL_MS = "3600000";
+  delete process.env.OURS_API_TOKEN;
+  return stateDir;
+}
+var WATCH_RETRY_MIN_MS, WATCH_RETRY_MAX_MS, EmbeddedOursHost, ExternalOursHost;
+var init_ours_runtime = __esm({
+  "src/ours-runtime.ts"() {
+    "use strict";
+    init_config();
+    WATCH_RETRY_MIN_MS = 500;
+    WATCH_RETRY_MAX_MS = 3e4;
+    EmbeddedOursHost = class {
+      config;
+      log;
+      listeners = /* @__PURE__ */ new Set();
+      handle;
+      Client;
+      apiToken;
+      closed = false;
+      constructor(config, log = () => {
+      }) {
+        this.config = config;
+        this.log = log;
+      }
+      async boot() {
+        if (this.handle) return;
+        if (this.closed) throw new Error("embedded ours SDK runtime cannot restart in the same process");
+        const runtimeDir = configureOwnedSdkEnvironment(this.config);
+        let handle;
+        try {
+          const [{ OursClient }, { startDaemon }] = await Promise.all([
+            import("@ours.network/sdk"),
+            import("@ours.network/sdk/daemon")
+          ]);
+          handle = await startDaemon({
+            version: "@ours.network/cowork@vNext",
+            handleSignals: false,
+            onIdentityNotify: (identityName) => {
+              for (const listener of this.listeners) {
+                try {
+                  listener(identityName);
+                } catch (error) {
+                  this.log(`cowork SDK notification listener failed for ${identityName}:`, error);
+                }
+              }
+            }
+          });
+          const tokenPath = join2(runtimeDir, "daemon-token");
+          const apiToken = fs.readFileSync(tokenPath, "utf8").trim();
+          if (!apiToken) throw new Error("embedded ours SDK runtime created an empty owner token");
+          this.Client = OursClient;
+          this.apiToken = apiToken;
+          this.handle = handle;
+        } catch (error) {
+          await handle?.close();
+          throw new Error("failed to start the embedded ours SDK runtime", { cause: error });
+        }
+      }
+      createClient(leaseToken = `cowork-${randomBytes(16).toString("hex")}`) {
+        if (!this.handle || !this.Client || !this.apiToken) {
+          throw new Error("embedded ours SDK runtime is not booted");
+        }
+        return new this.Client({
+          url: `http://127.0.0.1:${this.handle.port}`,
+          leaseToken,
+          apiToken: this.apiToken
+        });
+      }
+      onIdentityNotify(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+      }
+      close() {
+      }
+      async shutdown() {
+        if (this.closed) return { requiresProcessExit: true };
+        this.closed = true;
+        const handle = this.handle;
+        this.handle = void 0;
+        this.Client = void 0;
+        this.apiToken = void 0;
+        this.listeners.clear();
+        await handle?.close();
+        return { requiresProcessExit: true };
+      }
+    };
+    ExternalOursHost = class {
+      endpoint;
+      daemonStateDir;
+      log;
+      listeners = /* @__PURE__ */ new Set();
+      watchers = /* @__PURE__ */ new Map();
+      watchLeaseToken = `cowork-watch-${randomBytes(16).toString("hex")}`;
+      Client;
+      resolved;
+      watchClient;
+      closed = false;
+      constructor(config, log = () => {
+      }) {
+        const daemon = config.daemon;
+        if (daemon?.mode !== "external" || daemon.endpoint === void 0 || daemon.stateDir === void 0) {
+          throw new Error("external ours daemon mode requires both daemon.endpoint and daemon.stateDir");
+        }
+        this.endpoint = daemon.endpoint;
+        this.daemonStateDir = daemon.stateDir;
+        this.log = log;
+      }
+      async boot() {
+        if (this.resolved) return;
+        if (this.closed) throw new Error("external ours daemon host cannot restart in the same process");
+        const { OursClient, resolveDaemonConfig, assertDaemonStateDir } = await import("@ours.network/sdk");
+        let resolved;
+        try {
+          resolved = resolveDaemonConfig({ endpoint: this.endpoint, expectStateDir: this.daemonStateDir });
+        } catch (error) {
+          throw new Error(`cowork cannot select the external ours daemon at ${this.endpoint}`, { cause: error });
+        }
+        try {
+          await assertDaemonStateDir(resolved);
+        } catch (error) {
+          throw new Error(
+            `the external ours daemon at ${this.endpoint} is unavailable or does not own ${this.daemonStateDir}`,
+            { cause: error }
+          );
+        }
+        this.Client = OursClient;
+        this.resolved = resolved;
+        this.watchClient = this.createClient(this.watchLeaseToken);
+      }
+      createClient(leaseToken = `cowork-${randomBytes(16).toString("hex")}`) {
+        if (!this.Client || !this.resolved) throw new Error("external ours daemon host is not booted");
+        return new this.Client({
+          url: this.resolved.baseUrl.value,
+          leaseToken,
+          ...this.resolved.token === void 0 ? {} : { apiToken: this.resolved.token.value }
+        });
+      }
+      onIdentityNotify(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+      }
+      trackIdentity(identityName) {
+        if (!this.watchClient) throw new Error("external ours daemon host is not booted");
+        const existing = this.watchers.get(identityName);
+        if (existing) return () => this.untrack(identityName, existing);
+        const controller = new AbortController();
+        const watcher = { controller, work: Promise.resolve() };
+        watcher.work = this.follow(identityName, controller.signal);
+        this.watchers.set(identityName, watcher);
+        return () => this.untrack(identityName, watcher);
+      }
+      close() {
+      }
+      async shutdown() {
+        if (this.closed) return { requiresProcessExit: false };
+        this.closed = true;
+        this.listeners.clear();
+        const watchers = [...this.watchers.values()];
+        this.watchers.clear();
+        for (const watcher of watchers) watcher.controller.abort();
+        await Promise.allSettled(watchers.map((watcher) => watcher.work));
+        const client = this.watchClient;
+        this.watchClient = void 0;
+        this.Client = void 0;
+        this.resolved = void 0;
+        if (client) await client.releaseLease().catch(() => {
+        });
+        return { requiresProcessExit: false };
+      }
+      untrack(identityName, watcher) {
+        if (this.watchers.get(identityName) !== watcher) return;
+        this.watchers.delete(identityName);
+        watcher.controller.abort();
+      }
+      /**
+       * Long-poll one identity forever, reconnecting with bounded backoff.
+       *
+       * A watch primes at the daemon's tip, so a reconnected watch never replays
+       * what arrived while it was down. Losing those arrivals would be silent, so
+       * every reconnect announces the identity once. The consumer's reaction to an
+       * announcement is a full state refresh, which is exactly the recovery this
+       * needs; it is idempotent and self-coalescing, so the extra announcement can
+       * only cost one refresh.
+       *
+       * ORDER IS LOAD-BEARING. The resync is issued only AFTER the replacement
+       * watch's request is already in flight, because that request is what fixes
+       * the new tip. Announcing first would read the inbox at T0 and fix the tip at
+       * T1 > T0, and anything arriving in between would be in neither — the very
+       * gap this exists to close. This way every arrival lands in the refresh, on
+       * the stream, or (harmlessly) in both.
+       */
+      async follow(identityName, signal) {
+        let backoffMs = WATCH_RETRY_MIN_MS;
+        let resyncPending = false;
+        while (!signal.aborted) {
+          const client = this.watchClient;
+          if (!client) return;
+          try {
+            const stream = client.watchNotifications(identityName, { signal });
+            let step = stream.next();
+            if (resyncPending) {
+              resyncPending = false;
+              this.announce(identityName);
+            }
+            for (let settled = await step; !settled.done; settled = await step) {
+              backoffMs = WATCH_RETRY_MIN_MS;
+              this.announce(identityName);
+              step = stream.next();
+            }
+          } catch (error) {
+            if (signal.aborted) return;
+            resyncPending = true;
+            this.log(`[${identityName}] external ours daemon notification watch failed:`, error);
+          }
+          if (signal.aborted) return;
+          await sleep(backoffMs, signal);
+          backoffMs = Math.min(backoffMs * 2, WATCH_RETRY_MAX_MS);
+        }
+      }
+      announce(identityName) {
+        for (const listener of this.listeners) {
+          try {
+            listener(identityName);
+          } catch (error) {
+            this.log(`cowork SDK notification listener failed for ${identityName}:`, error);
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/contracts.ts
 import { createHash } from "node:crypto";
 function utf8Bounded(label, maximumBytes) {
@@ -4805,15 +4721,15 @@ function isStrictRfc3339(value) {
 function normalizeRoomName(value) {
   return value.trim().normalize("NFC");
 }
-function roomIdentityName(roomName) {
-  return `${ROOM_IDENTITY_PREFIX}${RoomNameSchema.parse(roomName)}`;
+function roomIdentityName(roomId) {
+  return `${ROOM_IDENTITY_PREFIX}${LowerCrockfordUlidSchema.parse(roomId)}`;
 }
 function legacyRoomIdentityName(roomId) {
   return `cowork-room-${LowerCrockfordUlidSchema.parse(roomId)}`;
 }
 function refineRoomLineage(room, context) {
   const pendingIdentityName = legacyRoomIdentityName(room.room_id);
-  const currentPendingIdentityName = room.room_name === void 0 ? void 0 : roomIdentityName(room.room_name);
+  const currentPendingIdentityName = roomIdentityName(room.room_id);
   const exactPacketPending = room.state === "provisioning" && room.status === "packet_pending" && (room.identity_name === pendingIdentityName || room.identity_name === currentPendingIdentityName) && room.invites.length === 0 && room.seats.length === 0 && room.activated_at === void 0 && room.closed_at === void 0;
   if (room.identity_cid === "" && !exactPacketPending) {
     context.addIssue({
@@ -4940,7 +4856,7 @@ function refineMessageCategory(message, context) {
     }
   }
 }
-var MAX_TEXT_BYTES, MAX_FILE_BYTES, MAX_HISTORY_PAGE_BYTES, MAX_MANAGEMENT_RESPONSE_BYTES, MAX_EXTERNAL_INVITE_BYTES, MAX_FILE_NAME_BYTES, MAX_MIME_BYTES, MAX_ROLE_BYTES, MAX_ROOM_NAME_CHARACTERS, NonEmptyStringSchema, PositiveSafeIntegerSchema, LowerCrockfordUlidSchema, Rfc3339Schema, RoomNameSchema, ROOM_IDENTITY_PREFIX, RoleSchema, MissionTextSchema, MessageTextSchema, FileNameSchema, FileMimeSchema, RoomStateSchema, SeatStateSchema, InviteModeSchema, DEFAULT_ROLE, InviteStateSchema, RelayStatusSchema, SeatV1Schema, SeatSchema, RoomInviteSchema, MissionV1Schema, MissionSchema, RoleBriefingSchema, RoomCommonShape, RoomV1Schema, CurrentRoomSchema, RoomSchema, CreateRoomInputSchema, UpdateRoomInputSchema, RoleBriefingSetInputSchema, RoleBriefingDeleteInputSchema, PostMessageInputSchema, ContainerIdSchema, AcceptExternalInviteInputSchema, AuthorSnapshotSchema, RecordCommonShape, AppendCommonShape, MembershipNoticeSchema, AuthorAliasSchema, MessageShape, RelayIntentShape, RelayResultStatusSchema, RelayResultShape, FileShape, MembershipIntentShape, MembershipResultShape, CloseNoticeIntentShape, CloseNoticeResultShape, MessageRecordSchema, FileRecordSchema, RelayIntentRecordSchema, RelayResultRecordSchema, MembershipIntentRecordSchema, MembershipResultRecordSchema, CloseNoticeIntentRecordSchema, CloseNoticeResultRecordSchema, RawCommunicationRecordSchema, CommunicationRecordSchema, AppendRecordSchema;
+var MAX_TEXT_BYTES, MAX_FILE_BYTES, MAX_HISTORY_PAGE_BYTES, MAX_MANAGEMENT_RESPONSE_BYTES, MAX_EXTERNAL_INVITE_BYTES, MAX_FILE_NAME_BYTES, MAX_MIME_BYTES, MAX_ROLE_BYTES, MAX_ROOM_NAME_CHARACTERS, NonEmptyStringSchema, PositiveSafeIntegerSchema, LowerCrockfordUlidSchema, Rfc3339Schema, RoomNameSchema, ROOM_IDENTITY_PREFIX, RoleSchema, MissionTextSchema, MessageTextSchema, FileNameSchema, FileMimeSchema, RoomStateSchema, SeatStateSchema, InviteModeSchema, DEFAULT_ROLE, InviteStateSchema, RelayStatusSchema, SeatV1Schema, SeatSchema, RoomInviteSchema, MissionV1Schema, MissionSchema, RoleBriefingSchema, RoomCommonShape, RoomV1Schema, CurrentRoomSchema, RoomSchema, CreateRoomInputSchema, UpdateRoomInputSchema, RoleBriefingSetInputSchema, RoleBriefingDeleteInputSchema, PostMessageInputSchema, ContainerIdSchema, AcceptExternalInviteInputSchema, AuthorSnapshotSchema, RecordCommonShape, AppendCommonShape, MembershipNoticeSchema, AuthorAliasSchema, ReplyReferenceSchema, MessageShape, RelayIntentShape, RelayResultStatusSchema, RelayResultShape, FileShape, MembershipIntentShape, MembershipResultShape, CloseNoticeIntentShape, CloseNoticeResultShape, MessageRecordSchema, FileRecordSchema, RelayIntentRecordSchema, RelayResultRecordSchema, MembershipIntentRecordSchema, MembershipResultRecordSchema, CloseNoticeIntentRecordSchema, CloseNoticeResultRecordSchema, RawCommunicationRecordSchema, CommunicationRecordSchema, AppendRecordSchema;
 var init_contracts = __esm({
   "src/contracts.ts"() {
     "use strict";
@@ -4973,7 +4889,7 @@ var init_contracts = __esm({
         });
       }
     });
-    ROOM_IDENTITY_PREFIX = "ours-cowork-room:";
+    ROOM_IDENTITY_PREFIX = "ours-cowork-";
     RoleSchema = utf8Bounded("role", MAX_ROLE_BYTES);
     MissionTextSchema = utf8Bounded("mission text", MAX_TEXT_BYTES);
     MessageTextSchema = utf8Bounded("message text", MAX_TEXT_BYTES);
@@ -5325,6 +5241,10 @@ var init_contracts = __esm({
       participant_id: LowerCrockfordUlidSchema,
       alias: NonEmptyStringSchema
     }).strict();
+    ReplyReferenceSchema = external_exports.object({
+      wire_id: NonEmptyStringSchema,
+      sentence: PositiveSafeIntegerSchema.optional()
+    }).strict();
     MessageShape = {
       kind: external_exports.literal("message"),
       message_id: LowerCrockfordUlidSchema,
@@ -5349,7 +5269,8 @@ var init_contracts = __esm({
         }
       }),
       source_msg_id: external_exports.number().int().nonnegative().safe().optional(),
-      source_wire_id: NonEmptyStringSchema.optional()
+      source_wire_id: NonEmptyStringSchema.optional(),
+      source_reply_to: ReplyReferenceSchema.optional()
     };
     RelayIntentShape = {
       kind: external_exports.literal("relay_intent"),
@@ -5392,7 +5313,8 @@ var init_contracts = __esm({
         }
       }),
       source_file_id: external_exports.number().int().nonnegative().safe(),
-      source_wire_id: NonEmptyStringSchema.optional()
+      source_wire_id: NonEmptyStringSchema.optional(),
+      source_reply_to: ReplyReferenceSchema.optional()
     };
     MembershipIntentShape = {
       kind: external_exports.literal("membership_intent"),
@@ -5474,217 +5396,93 @@ var init_contracts = __esm({
 });
 
 // src/packets.ts
-import { randomBytes } from "node:crypto";
-import * as nodeFs2 from "node:fs";
-import { dirname as dirname3, join as join3 } from "node:path";
-function atomicWriteFileSync(target, bytes, ops = nodeFs2) {
-  const temp = `${target}.tmp-${process.pid}-${temporarySequence++}`;
-  let fileFd;
-  let directoryFd;
-  try {
-    fileFd = ops.openSync(temp, nodeFs2.constants.O_CREAT | nodeFs2.constants.O_TRUNC | nodeFs2.constants.O_WRONLY, 384);
-    ops.fchmodSync(fileFd, 384);
-    let offset = 0;
-    while (offset < bytes.byteLength) {
-      const written = ops.writeSync(fileFd, bytes, offset, bytes.byteLength - offset, null);
-      if (written <= 0) throw new Error(`short write while persisting ${target}`);
-      offset += written;
-    }
-    ops.fsyncSync(fileFd);
-    ops.closeSync(fileFd);
-    fileFd = void 0;
-    ops.renameSync(temp, target);
-    ops.chmodSync(target, 384);
-    directoryFd = ops.openSync(dirname3(target), nodeFs2.constants.O_RDONLY);
-    ops.fsyncSync(directoryFd);
-    ops.closeSync(directoryFd);
-    directoryFd = void 0;
-  } catch (error) {
-    if (fileFd !== void 0) {
-      try {
-        ops.closeSync(fileFd);
-      } catch {
-      }
-    }
-    if (directoryFd !== void 0) {
-      try {
-        ops.closeSync(directoryFd);
-      } catch {
-      }
-    }
-    try {
-      ops.rmSync(temp, { force: true });
-    } catch {
-    }
-    throw new PacketPersistenceError(`failed to durably persist ${target}`, { cause: error });
-  }
-}
-function renderInbox(value) {
-  const output = [];
-  if (value.IsNil()) return output;
-  for (let index = 0; ; index += 1) {
-    const message = value.Reduce(index);
-    if (message.IsNil()) break;
-    output.push({
-      msg_id: Number(message.Reduce("msg_id").Visualize()),
-      sender_id: message.Reduce("sender_id").Visualize(),
-      sender_name: message.Reduce("sender_name").Visualize(),
-      text: message.Reduce("text").Visualize(),
-      date: adaptTimeToRfc3339(message.Reduce("date").Visualize()),
-      status: message.Reduce("status").Visualize(),
-      wire_id: message.Reduce("wire_id").Visualize()
-    });
-  }
-  return output;
-}
-function renderFileInbox(value) {
-  const output = [];
-  if (value.IsNil()) return output;
-  for (let index = 0; ; index += 1) {
-    const file = value.Reduce(index);
-    if (file.IsNil()) break;
-    output.push({
-      file_id: Number(file.Reduce("file_id").Visualize()),
-      sender_id: file.Reduce("sender_id").Visualize(),
-      sender_name: file.Reduce("sender_name").Visualize(),
-      filename: file.Reduce("filename").Visualize(),
-      mime: file.Reduce("mime").Visualize(),
-      data: Buffer.from(file.Reduce("data").GetBinary()),
-      date: adaptTimeToRfc3339(file.Reduce("date").Visualize()),
-      status: file.Reduce("status").Visualize(),
-      wire_id: file.Reduce("wire_id").Visualize()
-    });
-  }
-  return output;
-}
-function renderIntegerArray(value) {
-  const output = [];
-  if (value.IsNil()) return output;
-  for (let index = 0; ; index += 1) {
-    const item = value.Reduce(index);
-    if (item.IsNil()) break;
-    output.push(Number(item.Visualize()));
-  }
-  return output;
+import { createHash as createHash2 } from "node:crypto";
+import * as fs2 from "node:fs";
+import { join as join3 } from "node:path";
+import { brotliCompressSync, brotliDecompressSync, constants as zlibConstants } from "node:zlib";
+function sendResult(result) {
+  if (result.kind === "refused" || result.kind === "migrating") return { status: "send_failed" };
+  if (result.kind === "introduced") return { status: "queued" };
+  return { status: "queued", wire_id: result.wireId };
 }
-function dictionaryEntries(value) {
-  if (value.IsNil()) return [];
-  return value.GetKeys().map((key) => [key.Visualize(), value.Reduce(key)]);
+async function fileItem(file, bytes) {
+  return {
+    file_id: file.file_id,
+    sender_id: file.from.id,
+    sender_name: file.from.name,
+    filename: file.filename,
+    mime: file.mime,
+    data: Buffer.from(bytes),
+    date: normalizeDate(file.date),
+    wire_id: file.wire_id,
+    reply_to: cloneReply(file.reply_to)
+  };
 }
-function booleanValue(value) {
-  if (value.IsNil()) return false;
-  try {
-    return value.GetBoolean();
-  } catch {
-    return /true/i.test(value.Visualize());
-  }
+function cloneReply(reply) {
+  return reply === null ? null : {
+    wire_id: reply.wire_id,
+    ...reply.sentence === void 0 ? {} : { sentence: reply.sentence }
+  };
 }
-function strictBooleanValue(value, label) {
-  if (value.IsNil()) throw new Error(`${label} must be a boolean`);
-  let decoded;
-  try {
-    decoded = value.GetBoolean();
-  } catch (error) {
-    throw new Error(`${label} must be a boolean`, { cause: error });
-  }
-  if (typeof decoded !== "boolean") throw new Error(`${label} must be a boolean`);
-  return decoded;
+function normalizeDate(value) {
+  const date = new Date(value);
+  if (Number.isNaN(date.valueOf())) throw new Error(`SDK returned an invalid message timestamp: ${value}`);
+  return date.toISOString();
 }
-function nilString(value) {
-  return value.IsNil() ? "" : value.Visualize();
+function hasOursCode(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
 }
-function adaptTimeToRfc3339(value) {
-  const rfc3339 = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,3}))?(?:Z|([+-])(\d{2}):(\d{2}))$/.exec(value);
-  if (rfc3339) {
-    const [, year2, month2, day2, hour2, minute2, second2, fraction2 = "", sign2, offsetHour2 = "0", offsetMinute = "0"] = rfc3339;
-    if (sign2 === "-" && offsetHour2 === "00" && offsetMinute === "00") return invalidAdaptTime(value);
-    return canonicalUtcTime(value, year2, month2, day2, hour2, minute2, second2, fraction2, sign2, offsetHour2, offsetMinute);
-  }
-  const native = /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,9}))? \(UTC(?:([+-])(0|[1-9]|1\d|2[0-3]))?\)$/.exec(value);
-  if (!native) return invalidAdaptTime(value);
-  const [, year, month, day, hour, minute, second, fraction = "", sign, offsetHour = "0"] = native;
-  if (sign === "-" && offsetHour === "0") return invalidAdaptTime(value);
-  return canonicalUtcTime(value, year, month, day, hour, minute, second, fraction, sign, offsetHour, "0");
+function validateRoomId(roomId) {
+  if (!/^[0-7][0-9a-hjkmnp-tv-z]{25}$/.test(roomId)) throw new Error(`invalid room id "${roomId}"`);
 }
-function canonicalUtcTime(source, yearText, monthText, dayText, hourText, minuteText, secondText, fraction, offsetSign, offsetHourText, offsetMinuteText) {
-  const year = Number(yearText);
-  const month = Number(monthText);
-  const day = Number(dayText);
-  const hour = Number(hourText);
-  const minute = Number(minuteText);
-  const second = Number(secondText);
-  const offsetHour = Number(offsetHourText);
-  const offsetMinute = Number(offsetMinuteText);
-  const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
-  const monthDays = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-  if (month < 1 || month > 12 || day < 1 || day > monthDays[month - 1] || hour > 23 || minute > 59 || second > 59 || offsetHour > 23 || offsetMinute > 59) return invalidAdaptTime(source);
-  const milliseconds = Number(fraction.slice(0, 3).padEnd(3, "0"));
-  const local = /* @__PURE__ */ new Date(0);
-  local.setUTCFullYear(year, month - 1, day);
-  local.setUTCHours(hour, minute, second, milliseconds);
-  if (local.getUTCFullYear() !== year || local.getUTCMonth() !== month - 1 || local.getUTCDate() !== day || local.getUTCHours() !== hour || local.getUTCMinutes() !== minute || local.getUTCSeconds() !== second) {
-    return invalidAdaptTime(source);
+function unpackInvite(encoded, maximumBytes) {
+  const normalized = encoded.replace(/\s+/g, "");
+  if (maximumBytes !== void 0 && Buffer.byteLength(encoded, "utf8") > maximumBytes || normalized.length === 0 || !/^[A-Za-z0-9_-]+$/.test(normalized)) {
+    throw new Error("the invite blob is empty, oversized, or invalid base64url");
   }
-  const direction = offsetSign === "-" ? -1 : 1;
-  const offsetMilliseconds = direction * (offsetHour * 60 + offsetMinute) * 6e4;
-  const canonical = new Date(local.getTime() - offsetMilliseconds).toISOString();
-  if (!/^\d{4}-/.test(canonical)) return invalidAdaptTime(source);
-  return canonical;
-}
-function invalidAdaptTime(value) {
-  throw new Error(`unexpected ADAPT time visualization: ${value}`);
-}
-function inviteMode(value) {
-  const normalized = value.replace(/^\$/, "");
-  if (normalized === "one_time" || normalized === "public") return normalized;
-  throw new Error(`unexpected invite mode: ${value}`);
-}
-function exportSigningSecret(packet) {
-  return withScope((lifetime) => Buffer.from(packet.readonlyTx("::actor::export_signing_secret", lifetime).Serialize()).toString("hex"));
-}
-function validateRoomId(roomId) {
-  if (!/^[A-Za-z0-9_-]{1,128}$/.test(roomId)) throw new Error(`invalid room id: ${roomId}`);
+  const compressed = Buffer.from(normalized, "base64url");
+  if (compressed.length === 0) throw new Error("the invite blob is empty or invalid base64url");
+  return Buffer.from(maximumBytes === void 0 ? brotliDecompressSync(compressed) : brotliDecompressSync(compressed, { maxOutputLength: maximumBytes }));
 }
-var PacketPersistenceError, temporarySequence, PacketRegistry, HostedRoomPacket;
+var LegacyCoworkStateError, PacketRegistry, SdkRoomPacket;
 var init_packets = __esm({
-  async "src/packets.ts"() {
+  "src/packets.ts"() {
     "use strict";
-    await init_adapt();
     init_contracts();
-    PacketPersistenceError = class extends Error {
-      constructor(message, options) {
-        super(message, options);
-        this.name = "PacketPersistenceError";
+    LegacyCoworkStateError = class extends Error {
+      constructor(roomId) {
+        super(
+          `room "${roomId}" uses the pre-1.0 custom packet format and cannot be opened by the standard ours SDK runtime; back it up with the old release, recreate the room for cowork 1.0, and re-invite its participants`
+        );
+        this.name = "LegacyCoworkStateError";
       }
     };
-    temporarySequence = 0;
     PacketRegistry = class {
       packets = /* @__PURE__ */ new Map();
+      trackers = /* @__PURE__ */ new Map();
       host;
       stateDir;
       fs;
-      persistence;
       log;
-      seed;
-      beforeExpose;
       onNotify;
-      provisioningCheckpoint;
-      stagingName;
+      unsubscribe;
       constructor(host, stateDir, options = {}) {
         this.host = host;
         this.stateDir = stateDir;
-        this.fs = options.fs ?? nodeFs2;
-        this.persistence = options.persistence ?? this.fs;
+        this.fs = options.fs ?? fs2;
         this.log = options.log ?? (() => {
         });
-        this.seed = options.seed ?? (() => randomBytes(24).toString("hex"));
-        this.beforeExpose = options.beforeExpose ?? (() => {
-        });
         this.onNotify = options.onNotify ?? (() => {
         });
-        this.provisioningCheckpoint = options.provisioningCheckpoint ?? (() => {
+        this.unsubscribe = host.onIdentityNotify((name) => {
+          const found = [...this.packets.entries()].find(([, packet2]) => packet2.name === name);
+          if (!found) return;
+          const [roomId, packet] = found;
+          void packet.refresh().then(
+            () => this.onNotify(roomId, "message_received"),
+            (error) => this.log(`[${name}] failed to refresh SDK state after notification:`, error)
+          );
         });
-        this.stagingName = options.stagingName ?? (() => `live.staging-${randomBytes(16).toString("hex")}`);
       }
       get size() {
         return this.packets.size;
@@ -5692,563 +5490,253 @@ var init_packets = __esm({
       get(roomId) {
         return this.packets.get(roomId);
       }
-      async create(roomId, identityName = `cowork-room-${roomId}`, bio = `ours-cowork mission room ${roomId}`) {
+      async create(roomId, identityName = `ours-cowork-${roomId}`, bio = `ours-cowork mission room ${roomId}`) {
         validateRoomId(roomId);
-        if (this.packets.has(roomId)) throw new Error(`room packet "${roomId}" is already hosted`);
-        const liveDir = this.liveDir(roomId);
-        if (this.hasRestorableState(roomId)) {
+        this.assertStandardIdentity(roomId, identityName);
+        this.assertNoLegacyState(roomId);
+        if (this.packets.has(roomId)) throw new Error(`room identity "${roomId}" is already hosted`);
+        const client = this.host.createClient();
+        try {
+          let cid;
           try {
-            return await this.restore(roomId, void 0, identityName, bio);
+            cid = (await client.chooseIdentity({ name: identityName, force: false })).cid;
           } catch (error) {
-            this.log(`[${this.packetName(roomId)}] pending packet restore failed; reprovisioning:`, error);
+            if (!hasOursCode(error, "NO_SUCH_IDENTITY")) throw error;
+            const created = await client.createIdentity({
+              name: identityName,
+              bio,
+              exposeLocal: false,
+              localAutoAccept: true
+            });
+            cid = created.info.cid;
           }
-        }
-        this.prepareProvisioningDirectory(roomId);
-        let native;
-        try {
-          native = await this.host.createPacket(this.packetName(roomId), this.seed());
-          let room;
-          room = new HostedRoomPacket(
-            native,
-            () => this.saveState(native, liveDir),
-            this.log,
-            (event) => this.onNotify(roomId, event),
-            () => {
-              if (this.packets.get(roomId) === room) this.packets.delete(roomId);
-            }
-          );
-          atomicWriteFileSync(this.identityPath(roomId), Buffer.from(exportSigningSecret(native), "utf8"), this.persistence);
-          this.provisioningCheckpoint("identity");
-          this.saveState(native, liveDir);
-          this.provisioningCheckpoint("state");
-          this.packets.set(roomId, room);
-          await room.setIdentity(identityName, bio);
-          this.provisioningCheckpoint("identity_applied");
-          return room;
+          const packet = new SdkRoomPacket(identityName, cid, client);
+          await packet.refresh();
+          this.packets.set(roomId, packet);
+          this.track(roomId, identityName);
+          return packet;
         } catch (error) {
-          if (native) {
-            try {
-              this.host.removePacket(native.cid);
-            } catch {
-            }
-          }
-          this.packets.delete(roomId);
-          throw error;
+          await client.releaseLease().catch(() => {
+          });
+          throw new Error(`failed to provision standard SDK identity for room "${roomId}"`, { cause: error });
         }
       }
-      async restore(roomId, expectedCid, identityName, bio) {
+      async restore(roomId, expectedCid, identityName = `ours-cowork-${roomId}`) {
         validateRoomId(roomId);
-        if (this.packets.has(roomId)) throw new Error(`room packet "${roomId}" is already hosted`);
-        const liveDir = this.liveDir(roomId);
-        const secret = this.fs.readFileSync(this.identityPath(roomId), "utf8").trim();
-        if (!/^[0-9a-f]+$/i.test(secret) || secret.length % 2 !== 0) {
-          throw new Error(`invalid signing secret for room "${roomId}"`);
-        }
-        const stateBytes = this.fs.readFileSync(this.statePath(roomId));
-        if (stateBytes.length === 0) throw new Error(`empty packet state for room "${roomId}"`);
-        const native = await this.host.createPacket(
-          this.packetName(roomId),
-          this.seed(),
-          secret,
-          { deferredExposure: true }
-        );
-        if (expectedCid !== void 0 && native.cid !== expectedCid) {
-          try {
-            this.host.removePacket(native.cid);
-          } catch {
-          }
-          throw new Error(
-            `restored room packet CID mismatch for "${roomId}": expected "${expectedCid}", found "${native.cid}"`
-          );
-        }
-        let room;
-        room = new HostedRoomPacket(
-          native,
-          () => this.saveState(native, liveDir),
-          this.log,
-          (event) => this.onNotify(roomId, event),
-          () => {
-            if (this.packets.get(roomId) === room) this.packets.delete(roomId);
-          }
-        );
+        this.assertStandardIdentity(roomId, identityName);
+        this.assertNoLegacyState(roomId);
+        if (this.packets.has(roomId)) throw new Error(`room identity "${roomId}" is already hosted`);
+        const client = this.host.createClient();
         try {
-          await withScopeAsync(async (lifetime) => {
-            const state = native.pw.packet.ParseValue(new Uint8Array(stateBytes)).Attach(lifetime);
-            await native.mutatingTx("::actor::import_state", state, lifetime);
-          });
-          native.pw.refresh_identity_proof_document();
-          if (identityName !== void 0 && bio !== void 0) {
-            await room.setIdentity(identityName, bio);
-            this.provisioningCheckpoint("identity_applied");
-          }
-          atomicWriteFileSync(
-            this.ownershipPath(roomId),
-            Buffer.from(`${roomId}
-`, "utf8"),
-            this.persistence
-          );
-          await this.beforeExpose(room);
-          this.host.exposePacket(native.cid);
-          this.packets.set(roomId, room);
-          return room;
+          const bound = await client.chooseIdentity({ name: identityName, force: false });
+          if (expectedCid !== void 0 && bound.cid !== expectedCid) {
+            throw new Error(`restored room identity CID mismatch: expected "${expectedCid}", found "${bound.cid}"`);
+          }
+          const packet = new SdkRoomPacket(identityName, bound.cid, client);
+          await packet.refresh();
+          this.packets.set(roomId, packet);
+          this.track(roomId, identityName);
+          return packet;
         } catch (error) {
-          try {
-            this.host.removePacket(native.cid);
-          } catch {
-          }
+          await client.releaseLease().catch(() => {
+          });
           throw error;
         }
       }
       async destroy(roomId) {
         validateRoomId(roomId);
-        const room = this.packets.get(roomId);
-        if (room) {
-          this.host.removePacket(room.cid);
-          this.packets.delete(roomId);
-        }
-        const liveDir = this.liveDir(roomId);
-        let removalFailure;
+        const packet = this.packets.get(roomId);
+        if (!packet) return [];
         try {
-          this.assertSafeRoomDirectory(roomId);
-          this.fs.rmSync(liveDir, { recursive: true, force: true });
-          this.fsyncDirectory(this.roomDir(roomId));
+          await packet.destroy();
+          this.packets.delete(roomId);
+          return [];
         } catch (error) {
-          this.log(`[${room?.name ?? this.packetName(roomId)}] live-state removal failed:`, error);
-          removalFailure = error;
-        }
-        const residue = this.residue(roomId);
-        if (removalFailure !== void 0 && residue.length === 0) {
-          throw new PacketPersistenceError(
-            `live-state removal durability is uncertain for room "${roomId}"`,
-            { cause: removalFailure }
-          );
+          throw new Error(`failed to remove standard SDK identity for room "${roomId}"`, { cause: error });
+        } finally {
+          this.untrack(roomId);
         }
-        return residue;
       }
-      /** Unhost runtime packets while retaining every byte required for restart. */
       async unhostAll() {
+        this.unsubscribe();
+        for (const roomId of [...this.trackers.keys()]) this.untrack(roomId);
         const errors = [];
-        for (const [roomId, room] of [...this.packets]) {
+        for (const [roomId, packet] of [...this.packets]) {
           try {
-            this.host.removePacket(room.cid, new Error("cowork daemon is shutting down"));
-            this.packets.delete(roomId);
+            await packet.close();
           } catch (error) {
             errors.push(error);
           }
+          this.packets.delete(roomId);
         }
-        if (errors.length > 0) throw new AggregateError(errors, "failed to unhost room packets");
-      }
-      saveState(packet, liveDir) {
-        try {
-          const bytes = withScope((lifetime) => Buffer.from(packet.readonlyTx("::actor::export_state", lifetime).Serialize()));
-          atomicWriteFileSync(join3(liveDir, "state_data.bin"), bytes, this.persistence);
-        } catch (error) {
-          if (error instanceof PacketPersistenceError) throw error;
-          throw new PacketPersistenceError(`failed to export state for packet "${packet.name}"`, { cause: error });
-        }
+        if (errors.length) throw new AggregateError(errors, "failed to release room SDK leases");
       }
-      residue(roomId) {
-        const liveDir = this.liveDir(roomId);
+      /**
+       * Hosts that watch the runtime from outside need to be told which identities
+       * exist; an embedded host omits `trackIdentity` and keeps its own callback.
+       */
+      track(roomId, identityName) {
+        const dispose = this.host.trackIdentity?.(identityName);
+        if (dispose) this.trackers.set(roomId, dispose);
+      }
+      untrack(roomId) {
+        const dispose = this.trackers.get(roomId);
+        if (!dispose) return;
+        this.trackers.delete(roomId);
         try {
-          this.fs.lstatSync(liveDir);
-          return [liveDir];
+          dispose();
         } catch (error) {
-          if (error.code === "ENOENT") return [];
-          throw error;
+          this.log(`failed to stop the notification watch for room "${roomId}":`, error);
         }
       }
-      packetName(roomId) {
-        return `cowork-room-${roomId}`;
-      }
-      roomDir(roomId) {
-        return join3(this.stateDir, "rooms", roomId);
-      }
-      liveDir(roomId) {
-        return join3(this.roomDir(roomId), "live");
-      }
-      identityPath(roomId) {
-        return join3(this.liveDir(roomId), "identity.key");
-      }
-      statePath(roomId) {
-        return join3(this.liveDir(roomId), "state_data.bin");
-      }
-      ownershipPath(roomId) {
-        return join3(this.liveDir(roomId), ".cowork-provisioning-v1");
-      }
-      stagingJournalPath(roomId) {
-        return join3(this.roomDir(roomId), ".cowork-provisioning-stage");
-      }
-      residuePath(roomId) {
-        return join3(this.roomDir(roomId), "provisioning-residue");
-      }
-      hasRestorableState(roomId) {
-        try {
-          const secret = this.fs.readFileSync(this.identityPath(roomId), "utf8").trim();
-          return /^[0-9a-f]+$/i.test(secret) && secret.length % 2 === 0 && this.fs.readFileSync(this.statePath(roomId)).length > 0;
-        } catch {
-          return false;
+      assertNoLegacyState(roomId) {
+        const live = join3(this.stateDir, "rooms", roomId, "live");
+        if (this.fs.existsSync(join3(live, "identity.key")) || this.fs.existsSync(join3(live, "state_data.bin"))) {
+          throw new LegacyCoworkStateError(roomId);
         }
       }
-      prepareProvisioningDirectory(roomId) {
-        const roomDir = this.roomDir(roomId);
-        const liveDir = this.liveDir(roomId);
-        if (!this.fs.existsSync(roomDir)) {
-          this.fs.mkdirSync(roomDir, { recursive: true, mode: 448 });
-          this.fs.chmodSync(roomDir, 448);
-        }
-        if (this.fs.existsSync(liveDir)) {
-          let owned = false;
-          try {
-            owned = this.fs.readFileSync(this.ownershipPath(roomId), "utf8") === `${roomId}
-`;
-          } catch {
-          }
-          if (owned) {
-            this.assertSafeRoomDirectory(roomId);
-            this.fs.rmSync(liveDir, { recursive: true, force: true });
-            this.fsyncDirectory(roomDir);
-          } else {
-            this.assertSafeRoomDirectory(roomId);
-            const residue = this.residuePath(roomId);
-            if (this.fs.existsSync(residue)) {
-              throw new PacketPersistenceError(
-                `room "${roomId}" has unknown live state and an existing provisioning residue; inspect both before retrying`
-              );
-            }
-            this.fs.renameSync(liveDir, residue);
-            this.fs.chmodSync(residue, 448);
-            this.fsyncDirectory(roomDir);
-          }
-        }
-        this.cleanupOwnedStaging(roomId);
-        const stagingName = this.stagingName();
-        if (!/^live\.staging-[0-9a-f]{32}$/.test(stagingName)) {
-          throw new PacketPersistenceError(`invalid provisioning staging name for room "${roomId}"`);
-        }
-        this.createStagingJournal(roomId, stagingName);
-        const stagingDir = join3(roomDir, stagingName);
-        try {
-          this.fs.mkdirSync(stagingDir, { recursive: false, mode: 448 });
-        } catch (error) {
-          try {
-            this.fs.unlinkSync(this.stagingJournalPath(roomId));
-            this.fsyncDirectory(roomDir);
-          } catch (cleanupError) {
-            throw new AggregateError([error, cleanupError], `provisioning staging collision cleanup failed for room "${roomId}"`);
-          }
-          throw new PacketPersistenceError(`provisioning staging collision for room "${roomId}"`, { cause: error });
-        }
-        this.fs.chmodSync(stagingDir, 448);
-        atomicWriteFileSync(
-          join3(stagingDir, ".cowork-provisioning-v1"),
-          Buffer.from(`${roomId}
-`, "utf8"),
-          this.persistence
-        );
-        this.provisioningCheckpoint("mkdir");
-        this.fs.renameSync(stagingDir, liveDir);
-        this.fsyncDirectory(roomDir);
-        this.fs.unlinkSync(this.stagingJournalPath(roomId));
-        this.fsyncDirectory(roomDir);
-      }
-      cleanupOwnedStaging(roomId) {
-        const journal = this.stagingJournalPath(roomId);
-        let journalFd;
-        try {
-          try {
-            journalFd = this.fs.openSync(
-              journal,
-              nodeFs2.constants.O_RDONLY | (nodeFs2.constants.O_NOFOLLOW ?? 0)
-            );
-          } catch (error) {
-            if (error.code === "ENOENT") return;
-            throw error;
-          }
-          const journalStat = this.fs.fstatSync(journalFd);
-          if (!journalStat.isFile() || journalStat.size > 128) {
-            throw new PacketPersistenceError(`unsafe provisioning staging journal for room "${roomId}"`);
-          }
-          const stagingName = this.fs.readFileSync(journalFd, "utf8").trim();
-          if (!/^live\.staging-[0-9a-f]{32}$/.test(stagingName)) {
-            throw new PacketPersistenceError(`invalid provisioning staging journal for room "${roomId}"`);
-          }
-          const roomDir = this.roomDir(roomId);
-          const stagingDir = join3(roomDir, stagingName);
-          if (this.fs.existsSync(stagingDir)) {
-            const stat = this.fs.lstatSync(stagingDir);
-            if (stat.isSymbolicLink() || !stat.isDirectory()) {
-              throw new PacketPersistenceError(`unsafe provisioning staging path for room "${roomId}"`);
-            }
-            let owned = false;
-            try {
-              owned = this.fs.readFileSync(join3(stagingDir, ".cowork-provisioning-v1"), "utf8") === `${roomId}
-`;
-            } catch {
-            }
-            if (owned) {
-              this.fs.rmSync(stagingDir, { recursive: true, force: true });
-              this.fsyncDirectory(roomDir);
-            } else {
-              const residue = this.residuePath(roomId);
-              if (this.fs.existsSync(residue)) {
-                throw new PacketPersistenceError(
-                  `provisioning staging recovery for room "${roomId}" found an existing provisioning residue; preserving both`
-                );
-              }
-              this.fs.renameSync(stagingDir, residue);
-              this.fs.chmodSync(residue, 448);
-              this.fsyncDirectory(roomDir);
-            }
-          }
-          const currentJournal = this.fs.lstatSync(journal);
-          if (!currentJournal.isFile() || currentJournal.dev !== journalStat.dev || currentJournal.ino !== journalStat.ino) {
-            throw new PacketPersistenceError(
-              `provisioning staging journal changed during recovery for room "${roomId}"; replacement preserved`
-            );
-          }
-          this.fs.unlinkSync(journal);
-          this.fsyncDirectory(roomDir);
-        } finally {
-          if (journalFd !== void 0) this.fs.closeSync(journalFd);
-        }
+      assertStandardIdentity(roomId, identityName) {
+        if (identityName !== `ours-cowork-${roomId}`) throw new LegacyCoworkStateError(roomId);
       }
-      createStagingJournal(roomId, stagingName) {
-        const journal = this.stagingJournalPath(roomId);
-        const bytes = Buffer.from(`${stagingName}
-`, "utf8");
-        let fd;
-        let created = false;
-        try {
-          fd = this.persistence.openSync(
-            journal,
-            nodeFs2.constants.O_CREAT | nodeFs2.constants.O_EXCL | nodeFs2.constants.O_WRONLY | (nodeFs2.constants.O_NOFOLLOW ?? 0),
-            384
-          );
-          created = true;
-          this.persistence.fchmodSync(fd, 384);
-          let offset = 0;
-          while (offset < bytes.byteLength) {
-            const written = this.persistence.writeSync(fd, bytes, offset, bytes.byteLength - offset, null);
-            if (written <= 0) throw new Error(`short write while persisting ${journal}`);
-            offset += written;
-          }
-          this.persistence.fsyncSync(fd);
-          this.persistence.closeSync(fd);
-          fd = void 0;
-          this.fsyncDirectory(this.roomDir(roomId));
-        } catch (error) {
-          if (fd !== void 0) {
-            try {
-              this.persistence.closeSync(fd);
-            } catch {
-            }
-          }
-          if (created) {
-            try {
-              this.fs.unlinkSync(journal);
-              this.fsyncDirectory(this.roomDir(roomId));
-            } catch {
-            }
-          }
-          throw new PacketPersistenceError(`failed to establish staging ownership for room "${roomId}"`, { cause: error });
-        }
+    };
+    SdkRoomPacket = class {
+      name;
+      cid;
+      client;
+      contacts = [];
+      invites = [];
+      inbox = [];
+      fileInbox = [];
+      refreshWork;
+      constructor(name, cid, client) {
+        this.name = name;
+        this.cid = cid;
+        this.client = client;
+      }
+      refresh() {
+        this.refreshWork ??= this.refreshUnlocked().finally(() => {
+          this.refreshWork = void 0;
+        });
+        return this.refreshWork;
+      }
+      async refreshUnlocked() {
+        const contacts = await this.client.listContacts();
+        this.contacts = contacts.contacts.map((contact) => ({ ...contact }));
+        this.invites = (await this.client.listInvites()).flatMap((invite) => invite.mode === "one_time" || invite.mode === "public" ? [{ invite_id: invite.invite_id, mode: invite.mode }] : []);
+        this.inbox = (await this.client.listIncomingMessages()).filter((message) => message.status === "unread").map((message) => ({
+          msg_id: message.msg_id,
+          sender_id: message.sender_id,
+          sender_name: message.sender_name,
+          text: message.text,
+          date: normalizeDate(message.date),
+          wire_id: message.wire_id,
+          reply_to: cloneReply(message.reply_to)
+        }));
+        await this.refreshFiles();
       }
-      assertSafeRoomDirectory(roomId) {
-        const roomDir = this.roomDir(roomId);
-        const stat = this.fs.lstatSync(roomDir);
-        if (stat.isSymbolicLink() || !stat.isDirectory()) {
-          throw new Error(`room directory for "${roomId}" is not a safe directory`);
+      async refreshFiles() {
+        const unread = (await this.client.listIncomingFiles()).filter((file) => file.status === "unread");
+        if (unread.length === 0) {
+          this.fileInbox = [];
+          return;
         }
-      }
-      fsyncDirectory(path) {
-        let fd;
+        const ids = unread.map((file) => file.file_id);
+        const wires = unread.map((file) => file.wire_id);
         try {
-          fd = this.fs.openSync(path, nodeFs2.constants.O_RDONLY | (nodeFs2.constants.O_NOFOLLOW ?? 0));
-          this.fs.fsyncSync(fd);
+          await this.client.getFiles({ wire_ids: wires });
+          this.fileInbox = await Promise.all(unread.map(async (file) => fileItem(file, await this.client.fetchFile(file.wire_id))));
         } finally {
-          if (fd !== void 0) this.fs.closeSync(fd);
+          await this.client.deferFiles({ file_ids: ids }).catch(() => {
+          });
         }
       }
-    };
-    HostedRoomPacket = class {
-      name;
-      cid;
-      packet;
-      constructor(packet, saveState, log, onNotify = () => {
-      }, onTerminal = () => {
-      }) {
-        this.packet = packet;
-        this.name = packet.name;
-        this.cid = packet.cid;
-        wireHandlers(packet, { onSaveState: saveState, onNotify: (event) => onNotify(event) }, log);
-        packet.onTerminalClose?.(onTerminal);
-      }
-      async setIdentity(identityName, bio) {
-        await withScopeAsync((lifetime) => this.packet.mutatingTx("::a2a_messaging::set_my_name", { name: identityName }, lifetime));
-        await withScopeAsync((lifetime) => this.packet.mutatingTx("::a2a_messaging::set_my_bio", { bio }, lifetime));
-      }
       async mintInvite(mode) {
-        return withScopeAsync(async (lifetime) => {
-          const result = await this.packet.mutatingTx("::a2a_messaging::generate_invite", { mode }, lifetime);
-          return {
-            blob: packInvite(Buffer.from(result.Reduce("invite").GetBinary())),
-            invite_id: result.Reduce("invite_id").Visualize(),
-            reusable: booleanValue(result.Reduce("reusable"))
-          };
-        });
+        const result = await this.client.generateInvite({ mode });
+        await this.refresh();
+        return { blob: result.blob, invite_id: result.inviteId, reusable: mode === "public" };
       }
       async addContact(invite) {
-        let decoded;
-        try {
-          decoded = unpackInvite(invite, MAX_EXTERNAL_INVITE_BYTES);
-        } catch (error) {
-          throw new Error("external invite could not be decoded within the 48 KiB limit", { cause: error });
-        }
-        return withScopeAsync(async (lifetime) => {
-          const result = await this.packet.mutatingTx("::a2a_messaging::add_contact", {
-            invite: this.packet.newBinary(decoded, lifetime)
-          }, lifetime);
-          return {
-            invite_id: result.Reduce("invite_id").Visualize(),
-            container_id: result.Reduce("container_id").Visualize(),
-            inviter_name: result.Reduce("inviter_name").Visualize(),
-            pending_name: result.Reduce("pending").Visualize()
-          };
-        });
+        const decoded = unpackInvite(invite, MAX_EXTERNAL_INVITE_BYTES);
+        const result = await this.client.addContact({ invite });
+        await this.refresh();
+        return {
+          invite_id: createHash2("sha256").update(decoded).digest("hex"),
+          container_id: result.cid,
+          inviter_name: result.display,
+          pending_name: result.display
+        };
       }
       async revokeInvite(inviteId) {
-        return withScopeAsync(async (lifetime) => {
-          const result = await this.packet.mutatingTx("::a2a_messaging::revoke_invite", { invite_id: inviteId }, lifetime);
-          return { revoked: booleanValue(result.Reduce("revoked")) };
-        });
+        const result = await this.client.revokeInvite({ invite_id: inviteId });
+        await this.refresh();
+        return { revoked: result.revoked };
       }
       listInvites() {
-        return withScope((lifetime) => {
-          const value = this.packet.readonlyTx("::a2a_messaging::list_invites", lifetime);
-          return dictionaryEntries(value).map(([inviteId, invite]) => ({
-            invite_id: inviteId,
-            mode: inviteMode(invite.Reduce("mode").Visualize())
-          }));
-        });
+        return this.invites.map((invite) => ({ ...invite }));
       }
       listContacts() {
-        return withScope((lifetime) => {
-          const value = this.packet.readonlyTx("::a2a_messaging::list_contacts", lifetime);
-          return dictionaryEntries(value).map(([, contact]) => ({
-            name: contact.Reduce("name").Visualize(),
-            container_id: contact.Reduce("container_id").Visualize()
-          }));
-        });
-      }
-      listContactOrigins() {
-        return withScope((lifetime) => {
-          const value = this.packet.readonlyTx("::a2a_messaging::list_contact_origins", lifetime);
-          return Object.fromEntries(dictionaryEntries(value).map(([cid, origin]) => [cid, {
-            via: origin.Reduce("via").Visualize(),
-            invite_id: nilString(origin.Reduce("invite_id")),
-            at: adaptTimeToRfc3339(origin.Reduce("at").Visualize())
-          }]));
-        });
+        return this.contacts.map((contact) => ({ ...contact }));
       }
       peekInbox() {
-        return withScope((lifetime) => renderInbox(this.packet.readonlyTx("::actor::list_incoming_messages", lifetime)).filter((message) => message.status === "unread").map(({ status: _status, ...message }) => message));
-      }
-      async consumeInbox(expectedIds) {
-        return withScopeAsync(async (lifetime) => {
-          const result = await this.packet.mutatingTx(
-            "::actor::consume_messages",
-            { expected_ids: expectedIds },
-            lifetime
-          );
-          return {
-            consumed: renderIntegerArray(result.Reduce("consumed")),
-            deferred: renderIntegerArray(result.Reduce("deferred"))
-          };
-        });
+        return this.inbox.map((item) => ({ ...item }));
       }
       peekFileInbox() {
-        return withScope((lifetime) => renderFileInbox(
-          this.packet.readonlyTx("::actor::list_incoming_files", lifetime)
-        ).filter((file) => file.status === "unread").map(({ status: _status, ...file }) => file));
+        return this.fileInbox.map((item) => ({ ...item, data: Buffer.from(item.data) }));
       }
-      async consumeFileInbox(expectedIds) {
-        return withScopeAsync(async (lifetime) => {
-          const result = await this.packet.mutatingTx(
-            "::actor::consume_files",
-            { expected_ids: expectedIds },
-            lifetime
-          );
-          return {
-            consumed: renderIntegerArray(result.Reduce("consumed")),
-            deferred: renderIntegerArray(result.Reduce("deferred"))
-          };
-        });
+      async consumeInbox(expectedIds) {
+        if (expectedIds.length === 0) return { consumed: [], deferred: [] };
+        const pulled = await this.client.getMessages();
+        const expected = new Set(expectedIds);
+        const consumed = pulled.messages.filter((message) => expected.has(message.msg_id)).map((message) => message.msg_id);
+        const deferred = pulled.messages.filter((message) => !expected.has(message.msg_id)).map((message) => message.msg_id);
+        if (deferred.length) await this.client.deferMessages({ msg_ids: deferred });
+        await this.refresh();
+        return { consumed, deferred };
       }
-      async send(contactCid, body) {
-        return withScopeAsync(async (lifetime) => {
-          const result = await this.packet.mutatingTx(
-            "::a2a_messaging::send_message",
-            { contact: contactCid, text: body },
-            lifetime
-          );
-          const refused = !result.Reduce("downgrade_refused").IsNil();
-          return refused ? { status: "send_failed" } : { status: "queued", wire_id: nilString(result.Reduce("wire_id")) || void 0 };
-        });
+      async consumeFileInbox(expectedIds) {
+        const expected = new Set(expectedIds);
+        const selected = this.fileInbox.filter((file) => expected.has(file.file_id));
+        if (selected.length) await this.client.getFiles({ wire_ids: selected.map((file) => file.wire_id) });
+        this.fileInbox = this.fileInbox.filter((file) => !expected.has(file.file_id));
+        return { consumed: selected.map((file) => file.file_id), deferred: [] };
+      }
+      async send(contactCid, body, replyTo) {
+        return sendResult(await this.client.sendMessage({
+          contact: contactCid,
+          text: body,
+          ...replyTo === void 0 ? {} : {
+            reply_to_wire_id: replyTo.wire_id,
+            ...replyTo.sentence === void 0 ? {} : { reply_to_sentence: replyTo.sentence }
+          }
+        }));
       }
-      async sendFile(contactCid, filename, mime, data) {
+      async sendFile(contactCid, filename, mime, data, replyTo) {
         const validName = FileNameSchema.parse(filename);
         const validMime = FileMimeSchema.parse(mime);
-        if (data.length > MAX_FILE_BYTES) {
-          throw new RangeError(`room files must be at most ${MAX_FILE_BYTES} bytes (2 MiB)`);
-        }
-        return withScopeAsync(async (lifetime) => {
-          const result = await this.packet.mutatingTx(
-            "::a2a_messaging::send_file",
-            {
-              contact: contactCid,
-              filename: validName,
-              mime: validMime,
-              // The core contract takes bytes. A filesystem path here would make
-              // recovery depend on staging ownership and is deliberately forbidden.
-              data: this.packet.newBinary(data, lifetime)
-            },
-            lifetime
-          );
-          const refused = !result.Reduce("downgrade_refused").IsNil() || !result.Reduce("migrating").IsNil();
-          return refused ? { status: "send_failed" } : { status: "queued", wire_id: nilString(result.Reduce("wire_id")) || void 0 };
-        });
+        if (data.length > MAX_FILE_BYTES) throw new RangeError(`room files must be at most ${MAX_FILE_BYTES} bytes (2 MiB)`);
+        return sendResult(await this.client.sendFile({
+          contact: contactCid,
+          data_base64: data.toString("base64"),
+          filename: validName,
+          mime: validMime,
+          ...replyTo === void 0 ? {} : {
+            reply_to_wire_id: replyTo.wire_id,
+            ...replyTo.sentence === void 0 ? {} : { reply_to_sentence: replyTo.sentence }
+          }
+        }));
       }
       async removeContact(contactCid) {
-        return withScopeAsync(async (lifetime) => {
-          const result = await this.packet.mutatingTx(
-            "::a2a_messaging::remove_contact",
-            { contact: contactCid },
-            lifetime
-          );
-          const notified = strictBooleanValue(result.Reduce("notified"), "remove_contact notified");
-          const keyMaterialRetained = strictBooleanValue(
-            result.Reduce("key_material_retained"),
-            "remove_contact key_material_retained"
-          );
-          if (!keyMaterialRetained) {
-            throw new Error("remove_contact key_material_retained must be true");
-          }
-          return {
-            status: notified ? "queued" : "send_failed",
-            notified,
-            key_material_retained: true
-          };
-        });
+        const result = await this.client.removeContact({ contact: contactCid });
+        const notified = result.notified === true;
+        await this.refresh();
+        return { status: notified ? "queued" : "send_failed", notified, key_material_retained: true };
       }
-      async sign(canonicalJson2) {
-        return withScopeAsync(async (lifetime) => {
-          const result = await this.packet.mutatingTx(
-            "::actor::sign_app_envelope",
-            { canonical_json: canonicalJson2 },
-            lifetime
-          );
-          return Buffer.from(result.Reduce("signature").GetBinary()).toString("base64url");
-        });
+      async close() {
+        await this.client.releaseLease();
+      }
+      async destroy() {
+        await this.client.removeIdentity({ name: this.name });
+        await this.client.releaseLease();
       }
     };
   }
@@ -6286,15 +5774,18 @@ var init_ulid = __esm({
 });
 
 // src/intake.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 function canonicalJson(value) {
   const encoded = JSON.stringify(canonicalValue(value));
   if (encoded === void 0) throw new TypeError("canonical JSON value is not serializable");
   return encoded;
 }
-async function sendSignedBody(packet, recipientIdentity, unsigned) {
-  const signature = await packet.sign(canonicalJson(unsigned));
-  return packet.send(recipientIdentity, canonicalJson({ ...unsigned, signature }));
+async function sendRoomBody(packet, recipientIdentity, unsigned) {
+  return packet.send(recipientIdentity, canonicalJson(unsigned));
+}
+function sameReply(stored, observed) {
+  if (stored === void 0 || observed == null) return stored === void 0 && observed == null;
+  return stored.wire_id === observed.wire_id && stored.sentence === observed.sentence;
 }
 function canonicalValue(value) {
   if (Array.isArray(value)) return value.map(canonicalValue);
@@ -6449,11 +5940,12 @@ var init_intake = __esm({
             filename: parsedName.data,
             mime: parsedMime.data,
             size: bytes.length,
-            sha256: createHash2("sha256").update(bytes).digest("hex"),
+            sha256: createHash3("sha256").update(bytes).digest("hex"),
             data_base64: bytes.toString("base64"),
             recipient_identities: recipientIdentities,
             source_file_id: item.file_id,
-            ...item.wire_id === "" ? {} : { source_wire_id: item.wire_id }
+            ...item.wire_id === "" ? {} : { source_wire_id: item.wire_id },
+            ...item.reply_to == null ? {} : { source_reply_to: item.reply_to }
           });
           if (appended.kind !== "file") throw new Error("storage returned the wrong participant file kind");
           file = appended;
@@ -6493,7 +5985,8 @@ var init_intake = __esm({
             text: item.text,
             recipient_identities: recipientIdentities,
             source_msg_id: item.msg_id,
-            ...item.wire_id === "" ? {} : { source_wire_id: item.wire_id }
+            ...item.wire_id === "" ? {} : { source_wire_id: item.wire_id },
+            ...item.reply_to == null ? {} : { source_reply_to: item.reply_to }
           });
           if (appended.kind !== "message") throw new Error("storage returned the wrong participant message kind");
           message = appended;
@@ -6518,7 +6011,7 @@ var init_intake = __esm({
         await this.store.save(RoomSchema.parse({ ...room, seats }));
         try {
           const unsigned = { version: 1, kind: "room_not_member", room_id: roomId };
-          await sendSignedBody(packet, item.sender_id, unsigned);
+          await sendRoomBody(packet, item.sender_id, unsigned);
         } catch {
         }
       }
@@ -6602,7 +6095,7 @@ var init_intake = __esm({
               display_name: file.author_alias.alias,
               role: file.author.role
             };
-            const metadata = await sendSignedBody(packet, intent.recipient_identity, {
+            const metadata = await sendRoomBody(packet, intent.recipient_identity, {
               version: 1,
               kind: "room_file",
               room_id: roomId,
@@ -6668,7 +6161,7 @@ var init_intake = __esm({
             ...message.briefing_version === void 0 ? {} : { briefing_version: message.briefing_version },
             ...message.membership === void 0 ? {} : { membership: message.membership }
           };
-          const outcome = await sendSignedBody(packet, intent.recipient_identity, unsigned);
+          const outcome = await sendRoomBody(packet, intent.recipient_identity, unsigned);
           const appended = await this.store.append(roomId, {
             version: 1,
             kind: "relay_result",
@@ -6688,7 +6181,7 @@ var init_intake = __esm({
         const message = records.find((record) => record.kind === "message" && record.source_msg_id === item.msg_id);
         if (!message) return void 0;
         const observedWireId = item.wire_id === "" ? void 0 : item.wire_id;
-        if (message.source_wire_id !== observedWireId || message.author.identity !== item.sender_id || message.text !== item.text || message.at !== item.date) {
+        if (message.source_wire_id !== observedWireId || !sameReply(message.source_reply_to, item.reply_to) || message.author.identity !== item.sender_id || message.text !== item.text || message.at !== item.date) {
           throw new Error(`inbox source ${item.msg_id} does not match its durable room message`);
         }
         return message;
@@ -6698,7 +6191,7 @@ var init_intake = __esm({
         if (!file) return void 0;
         const observedWireId = item.wire_id === "" ? void 0 : item.wire_id;
         const bytes = Buffer.from(item.data);
-        if (file.source_wire_id !== observedWireId || file.author.identity !== item.sender_id || file.filename !== item.filename || file.mime !== item.mime || file.at !== item.date || file.size !== bytes.length || file.data_base64 !== bytes.toString("base64")) {
+        if (file.source_wire_id !== observedWireId || !sameReply(file.source_reply_to, item.reply_to) || file.author.identity !== item.sender_id || file.filename !== item.filename || file.mime !== item.mime || file.at !== item.date || file.size !== bytes.length || file.data_base64 !== bytes.toString("base64")) {
           throw new Error(`file inbox source ${item.file_id} does not match its durable room file`);
         }
         return file;
@@ -6719,7 +6212,7 @@ var init_intake = __esm({
 });
 
 // src/service.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 function byteBoundedHistoryPage(records) {
   const page = [];
   let bytes = 2;
@@ -6754,11 +6247,11 @@ function currentContactIdentities(packet) {
 }
 var ROOM_ROLE, CreateInviteInputSchema, HistoryOptionsSchema, DeleteRoomInputSchema, RemoveParticipantInputSchema, ReplaceParticipantInputSchema, RoomServiceError, RoomService;
 var init_service = __esm({
-  async "src/service.ts"() {
+  "src/service.ts"() {
     "use strict";
     init_zod();
     init_contracts();
-    await init_adapt();
+    init_packets();
     init_intake();
     init_ulid();
     ROOM_ROLE = "room";
@@ -6824,7 +6317,7 @@ var init_service = __esm({
         const settings = CreateRoomInputSchema.parse(input);
         const roomId = LowerCrockfordUlidSchema.parse(this.nextRoomId());
         const roomName = settings.name ?? defaultRoomName(roomId);
-        const identityName = roomIdentityName(roomName);
+        const identityName = roomIdentityName(roomId);
         return this.lock(roomId, async () => {
           const provisional = RoomSchema.parse({
             version: 2,
@@ -6907,7 +6400,7 @@ var init_service = __esm({
             throw new RoomServiceError(`room packet "${id}" with established CID must be restored, not created`);
           }
           try {
-            packet = await this.packets.restore(id, room.identity_cid);
+            packet = await this.packets.restore(id, room.identity_cid, room.identity_name);
           } catch (error) {
             throw new RoomServiceError(
               `failed to restore established room packet "${id}": ${error instanceof Error ? error.message : String(error)}`,
@@ -7006,6 +6499,11 @@ var init_service = __esm({
         return this.lock(id, async () => {
           const room = await this.store.load(id);
           this.assertMutable(room, "create an invite for");
+          if (room.invites.some((invite) => invite.state === "live" || invite.state === "receipt_pending")) {
+            throw new RoomServiceError(
+              "standard SDK rooms permit one live invitation at a time so every accepted contact has unambiguous room admission metadata"
+            );
+          }
           return this.mintInviteUnlocked(room, {
             mode: request.mode,
             role: request.role ?? DEFAULT_ROLE,
@@ -7023,7 +6521,7 @@ var init_service = __esm({
         } catch {
           throw new RoomServiceError("external invite is invalid or exceeds the 48 KiB decoded limit");
         }
-        const digest = createHash3("sha256").update(decoded).digest("hex");
+        const digest = createHash4("sha256").update(decoded).digest("hex");
         const receipt = await this.lock(id, async () => {
           const room = await this.store.load(id);
           this.assertMutable(room, "accept an external invite for");
@@ -7089,6 +6587,11 @@ var init_service = __esm({
         return receipt;
       }
       async mintInviteUnlocked(room, request) {
+        if (room.invites.some((invite2) => invite2.state === "live" || invite2.state === "receipt_pending")) {
+          throw new RoomServiceError(
+            "standard SDK rooms permit one live invitation at a time; revoke or consume the current invitation first"
+          );
+        }
         const packet = this.packet(room.room_id);
         const minted = await packet.mintInvite(request.mode);
         const invite = RoomInviteSchema.parse({
@@ -7458,7 +6961,7 @@ var init_service = __esm({
           }
           const coreInvite = this.packet(id).listInvites().find((invite) => invite.invite_id === replacementId);
           if (!coreInvite || coreInvite.mode !== replacement.mode) {
-            throw new RoomServiceError("recovered invite is no longer present in packet state");
+            throw new RoomServiceError("recovered invite is no longer present in SDK identity state");
           }
           const confirmed2 = {
             invite_id: replacement.invite_id,
@@ -7621,7 +7124,6 @@ var init_service = __esm({
         for (const contact of packet.listContacts()) {
           if (!contactsByCid.has(contact.container_id)) contactsByCid.set(contact.container_id, contact.name);
         }
-        const origins = packet.listContactOrigins();
         const inviteById = new Map(room.invites.map((invite) => [invite.invite_id, invite]));
         const existingCids = new Set(room.seats.filter((seat) => seat.state === "active" || seat.state === "pending").map((seat) => seat.identity));
         const lastRemovedAt = /* @__PURE__ */ new Map();
@@ -7637,37 +7139,26 @@ var init_service = __esm({
         for (const [seatIndex, seat] of room.seats.entries()) {
           if (seat.state !== "pending") continue;
           const displayName = contactsByCid.get(seat.identity);
-          const origin = origins[seat.identity];
-          if (displayName === void 0 || origin === void 0) continue;
-          const completedExternalRedemption = origin.via === "invite_redeemed" && origin.invite_id === seat.invite_id;
-          const fallbackInvite = origin.via === "invite_one_time" || origin.via === "invite_public" ? inviteById.get(origin.invite_id) : void 0;
-          const confirmedFallback = fallbackInvite !== void 0 && fallbackInvite.state !== "receipt_pending" && (fallbackInvite.recovery_of === void 0 || fallbackInvite.recovery_confirmed === true);
-          if (!completedExternalRedemption && !confirmedFallback) continue;
-          const removedAt = lastRemovedAt.get(seat.identity);
-          if (fallbackInvite !== void 0 && removedAt !== void 0 && fallbackInvite.created_at <= removedAt) continue;
-          const predecessor = fallbackInvite?.replaces_seat === void 0 ? void 0 : room.seats.find((candidate) => candidate.participant_id === fallbackInvite.replaces_seat && candidate.state === "removed");
-          if (fallbackInvite?.replaces_seat !== void 0 && predecessor === void 0) continue;
+          if (displayName === void 0) continue;
           const { alias: _alias, replaces_seat: _replacesSeat, ...base } = seat;
           const activated = {
             ...base,
             state: "active",
             display_name: displayName,
-            accepted_at: origin.at,
-            role: fallbackInvite?.role ?? seat.role,
-            invite_id: fallbackInvite?.invite_id ?? seat.invite_id,
-            ...fallbackInvite === void 0 ? _replacesSeat === void 0 ? {} : { replaces_seat: _replacesSeat } : predecessor === void 0 ? {} : { replaces_seat: predecessor.participant_id },
-            ...room.anonymous ? { alias: fallbackInvite === void 0 ? _alias : predecessor?.alias ?? (fallbackInvite.role === seat.role ? _alias : mintAlias(seatsWithActivations, fallbackInvite.role)) } : {}
+            accepted_at: this.now(),
+            ..._replacesSeat === void 0 ? {} : { replaces_seat: _replacesSeat },
+            ...room.anonymous ? { alias: _alias } : {}
           };
           activatedPending.push(activated);
           seatsWithActivations[seatIndex] = activated;
         }
         const newSeats = [];
+        const eligibleInvites = room.invites.filter((invite) => invite.state === "live" && (invite.recovery_of === void 0 || invite.recovery_confirmed === true));
+        const admissionInvite = eligibleInvites.length === 1 ? eligibleInvites[0] : void 0;
         for (const [cid, displayName] of contactsByCid) {
           if (existingCids.has(cid)) continue;
-          const origin = origins[cid];
-          if (!origin || origin.via !== "invite_one_time" && origin.via !== "invite_public") continue;
-          const invite = inviteById.get(origin.invite_id);
-          if (!invite || invite.state === "receipt_pending" || invite.recovery_of !== void 0 && invite.recovery_confirmed !== true) continue;
+          const invite = admissionInvite;
+          if (!invite) continue;
           const removedAt = lastRemovedAt.get(cid);
           if (removedAt !== void 0 && invite.created_at <= removedAt) continue;
           const seated = [...seatsWithActivations, ...newSeats];
@@ -7678,7 +7169,7 @@ var init_service = __esm({
             display_name: displayName,
             role: invite.role,
             invite_id: invite.invite_id,
-            accepted_at: origin.at,
+            accepted_at: this.now(),
             participant_id: LowerCrockfordUlidSchema.parse(generateUlid()),
             state: "active",
             ...predecessor === void 0 ? {} : { replaces_seat: predecessor.participant_id },
@@ -7935,7 +7426,7 @@ var init_service = __esm({
         }
       }
       isPacketPending(room) {
-        return room.identity_cid === "" && room.state === "provisioning" && room.status === "packet_pending" && (room.identity_name === legacyRoomIdentityName(room.room_id) || room.identity_name === roomIdentityName(room.room_name));
+        return room.identity_cid === "" && room.state === "provisioning" && room.status === "packet_pending" && room.identity_name === roomIdentityName(room.room_id);
       }
       now() {
         return external_exports.string().datetime({ offset: true }).parse(this.nowValue());
@@ -7946,9 +7437,9 @@ var init_service = __esm({
 
 // src/storage.ts
 import { randomBytes as randomBytes3 } from "node:crypto";
-import * as nodeFs3 from "node:fs";
+import * as nodeFs2 from "node:fs";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { dirname as dirname4, join as join4 } from "node:path";
+import { dirname as dirname2, join as join4 } from "node:path";
 var DIRECTORY_MODE2, FILE_MODE2, NO_FOLLOW2, utf8Decoder, CoworkStorageError, RoomQueue, CoworkStore;
 var init_storage = __esm({
   "src/storage.ts"() {
@@ -7957,7 +7448,7 @@ var init_storage = __esm({
     init_ulid();
     DIRECTORY_MODE2 = 448;
     FILE_MODE2 = 384;
-    NO_FOLLOW2 = nodeFs3.constants.O_NOFOLLOW ?? 0;
+    NO_FOLLOW2 = nodeFs2.constants.O_NOFOLLOW ?? 0;
     utf8Decoder = new TextDecoder("utf-8", { fatal: true });
     CoworkStorageError = class extends Error {
       constructor(message, options) {
@@ -7993,7 +7484,7 @@ var init_storage = __esm({
       constructor(stateDir, options = {}) {
         if (!stateDir) throw new CoworkStorageError("state directory is required");
         this.stateDir = stateDir;
-        this.fs = options.fs ?? nodeFs3;
+        this.fs = options.fs ?? nodeFs2;
       }
       mutex(roomId, work) {
         const validRoomId = this.roomId(roomId);
@@ -8126,7 +7617,7 @@ var init_storage = __esm({
           try {
             fd = this.fs.openSync(
               archivePath,
-              nodeFs3.constants.O_WRONLY | nodeFs3.constants.O_APPEND | NO_FOLLOW2
+              nodeFs2.constants.O_WRONLY | nodeFs2.constants.O_APPEND | NO_FOLLOW2
             );
             const opened = this.validateOpenPath(fd, archivePath, "room archive", "file", true);
             originalSize = opened.size;
@@ -8341,7 +7832,7 @@ var init_storage = __esm({
         try {
           fd = this.fs.openSync(
             temp,
-            nodeFs3.constants.O_CREAT | nodeFs3.constants.O_EXCL | nodeFs3.constants.O_WRONLY | NO_FOLLOW2,
+            nodeFs2.constants.O_CREAT | nodeFs2.constants.O_EXCL | nodeFs2.constants.O_WRONLY | NO_FOLLOW2,
             FILE_MODE2
           );
           this.validateOpenPath(fd, temp, `temporary ${label}`, "file", true);
@@ -8351,7 +7842,7 @@ var init_storage = __esm({
           this.fs.closeSync(fd);
           fd = void 0;
           this.fs.renameSync(temp, path);
-          this.fsyncDirectory(dirname4(path));
+          this.fsyncDirectory(dirname2(path));
         } catch (error) {
           if (fd !== void 0) {
             try {
@@ -8447,7 +7938,7 @@ var init_storage = __esm({
             break;
           }
           missing.push(cursor);
-          const parent = dirname4(cursor);
+          const parent = dirname2(cursor);
           if (parent === cursor) throw new CoworkStorageError(`cannot find existing parent for ${label}`);
           cursor = parent;
         }
@@ -8458,13 +7949,13 @@ var init_storage = __esm({
             created.push(directory);
             this.fs.chmodSync(directory, DIRECTORY_MODE2);
             this.fsyncDirectory(directory);
-            this.fsyncDirectory(dirname4(directory));
+            this.fsyncDirectory(dirname2(directory));
           }
         } catch (error) {
           for (const directory of created.reverse()) {
             try {
               this.fs.rmdirSync(directory);
-              this.fsyncDirectory(dirname4(directory));
+              this.fsyncDirectory(dirname2(directory));
             } catch {
             }
           }
@@ -8514,7 +8005,7 @@ var init_storage = __esm({
         try {
           fd = this.fs.openSync(
             path,
-            nodeFs3.constants.O_CREAT | nodeFs3.constants.O_EXCL | nodeFs3.constants.O_WRONLY | NO_FOLLOW2,
+            nodeFs2.constants.O_CREAT | nodeFs2.constants.O_EXCL | nodeFs2.constants.O_WRONLY | NO_FOLLOW2,
             FILE_MODE2
           );
           this.validateOpenPath(fd, path, "room archive", "file", true);
@@ -8523,7 +8014,7 @@ var init_storage = __esm({
         } finally {
           if (fd !== void 0) this.fs.closeSync(fd);
         }
-        this.fsyncDirectory(dirname4(path));
+        this.fsyncDirectory(dirname2(path));
       }
       atomicMetadataWrite(path, room) {
         if (this.lstatIfPresent(path)) this.assertRegularFile(path, "room metadata");
@@ -8534,7 +8025,7 @@ var init_storage = __esm({
         try {
           fd = this.fs.openSync(
             temp,
-            nodeFs3.constants.O_CREAT | nodeFs3.constants.O_EXCL | nodeFs3.constants.O_WRONLY | NO_FOLLOW2,
+            nodeFs2.constants.O_CREAT | nodeFs2.constants.O_EXCL | nodeFs2.constants.O_WRONLY | NO_FOLLOW2,
             FILE_MODE2
           );
           this.validateOpenPath(fd, temp, "temporary room metadata", "file", true);
@@ -8544,7 +8035,7 @@ var init_storage = __esm({
           this.fs.closeSync(fd);
           fd = void 0;
           this.fs.renameSync(temp, path);
-          this.fsyncDirectory(dirname4(path));
+          this.fsyncDirectory(dirname2(path));
         } catch (error) {
           if (fd !== void 0) {
             try {
@@ -8570,7 +8061,7 @@ var init_storage = __esm({
       readFileNoFollow(path, label) {
         let fd;
         try {
-          fd = this.fs.openSync(path, nodeFs3.constants.O_RDONLY | NO_FOLLOW2);
+          fd = this.fs.openSync(path, nodeFs2.constants.O_RDONLY | NO_FOLLOW2);
           this.validateOpenPath(fd, path, label, "file", true);
           return this.fs.readFileSync(fd);
         } finally {
@@ -8580,7 +8071,7 @@ var init_storage = __esm({
       fsyncDirectory(path) {
         let fd;
         try {
-          fd = this.fs.openSync(path, nodeFs3.constants.O_RDONLY | NO_FOLLOW2);
+          fd = this.fs.openSync(path, nodeFs2.constants.O_RDONLY | NO_FOLLOW2);
           this.validateOpenPath(fd, path, "directory fsync target", "directory", false);
           this.fs.fsyncSync(fd);
         } finally {
@@ -8611,743 +8102,33 @@ var init_storage = __esm({
   }
 });
 
-// src/openapi.ts
-function params(properties, required) {
-  return { type: "object", additionalProperties: false, properties, required: [...required] };
-}
-function schemaBaseName(method) {
-  return method.split(".").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-function errorResponseSpec(description, codes) {
-  return {
-    description,
-    content: {
-      "application/json": {
-        schema: { $ref: "#/components/schemas/RpcErrorResponse" },
-        example: {
-          version: 1,
-          id: "req-1",
-          error: { code: codes[0], message: "see the daemon response for detail" }
-        }
-      }
-    }
-  };
-}
-function documentResponseSpec(description, mediaType) {
-  return { description, content: { [mediaType]: { schema: { type: "string" } } } };
-}
-function buildOpenApiDocument() {
-  const schemas = {
-    RpcId: {
-      description: "Caller-chosen correlation id echoed in the response.",
-      oneOf: [
-        { type: "string", minLength: 1, maxLength: 256 },
-        { type: "integer", minimum: 0 }
-      ]
-    },
-    RpcError: {
-      type: "object",
-      additionalProperties: false,
-      required: ["code", "message"],
-      properties: {
-        code: {
-          type: "string",
-          enum: RPC_ERROR_CODES.map(([code]) => code),
-          description: RPC_ERROR_CODES.map(([code, text]) => `\`${code}\`: ${text}`).join(" ")
-        },
-        message: { type: "string", description: "Human-readable detail. Not machine-parsed." }
-      }
-    },
-    RpcSuccessResponse: {
-      type: "object",
-      additionalProperties: false,
-      required: ["version", "id", "result"],
-      properties: {
-        version: { type: "integer", const: 1 },
-        id: { $ref: "#/components/schemas/RpcId" },
-        result: {
-          description: "Method-specific result. See the individual method descriptions."
-        }
-      }
-    },
-    RpcErrorResponse: {
-      type: "object",
-      additionalProperties: false,
-      required: ["version", "id", "error"],
-      properties: {
-        version: { type: "integer", const: 1 },
-        id: {
-          description: "The request id, or null when it could not be recovered from the body.",
-          oneOf: [{ $ref: "#/components/schemas/RpcId" }, { type: "null" }]
-        },
-        error: { $ref: "#/components/schemas/RpcError" }
-      }
-    }
-  };
-  const requestSchemaNames = [];
-  const discriminatorMapping = {};
-  for (const entry of ROOM_RPC_METHODS) {
-    const base = schemaBaseName(entry.method);
-    const paramsName = `${base}Params`;
-    const requestName = `${base}Request`;
-    schemas[paramsName] = { ...entry.params, description: `Parameters for \`${entry.method}\`.` };
-    schemas[requestName] = {
-      type: "object",
-      additionalProperties: false,
-      required: ["version", "id", "method", "params"],
-      title: entry.summary,
-      description: `${entry.description}
-
-Result: ${entry.result}`,
-      properties: {
-        version: { type: "integer", const: 1 },
-        id: { $ref: "#/components/schemas/RpcId" },
-        method: { type: "string", const: entry.method },
-        params: { $ref: `#/components/schemas/${paramsName}` }
-      },
-      examples: [{ version: 1, id: "req-1", method: entry.method, params: entry.example }]
-    };
-    requestSchemaNames.push(requestName);
-    discriminatorMapping[entry.method] = `#/components/schemas/${requestName}`;
-  }
-  return {
-    openapi: "3.1.0",
-    info: {
-      title: "ours-cowork room management API",
-      version: API_VERSION,
-      summary: "Loopback REST control surface for cowork mission rooms.",
-      description: [
-        'Every room-management operation is carried by a single REST route, `POST /rpc`, using the versioned RPC envelope `{ "version": 1, "id": ..., "method": ..., "params": ... }`. The `method` field selects the operation; the request schemas below are discriminated on it.',
-        "",
-        "The listener binds `127.0.0.1` only and has no authentication, so it accepts requests whose `Host` header is `127.0.0.1:<port>` or `localhost:<port>`, rejects cross-site fetches, and must not be exposed to other hosts through forwarding or a proxy.",
-        "",
-        "Requests must declare `Content-Type: application/json` and stay within 1 MiB. Operations that need an invite secret are not served here: they are reachable only over the daemon's private Unix socket."
-      ].join("\n"),
-      license: { name: "FSL-1.1-Apache-2.0" }
-    },
-    servers: [{ url: "/", description: "This cowork daemon, on its loopback REST port." }],
-    tags: [
-      { name: "rooms", description: "Room management over the RPC envelope." },
-      { name: "documentation", description: "The API description and its browser UI." }
-    ],
-    paths: {
-      [RPC_PATH]: {
-        post: {
-          tags: ["rooms"],
-          operationId: "roomManagementRpc",
-          summary: "Invoke a room-management method",
-          description: "Dispatches one room-management method. The HTTP status reflects the envelope outcome: 200 on success, 404 when the method is not served over REST, 500 on an internal failure, and 400 for every other error code \u2014 including `not_found`.",
-          requestBody: {
-            required: true,
-            content: {
-              "application/json": {
-                schema: {
-                  oneOf: requestSchemaNames.map((name) => ({ $ref: `#/components/schemas/${name}` })),
-                  discriminator: { propertyName: "method", mapping: discriminatorMapping }
-                }
-              }
-            }
-          },
-          responses: {
-            200: {
-              description: "The method completed. `result` is method-specific.",
-              content: {
-                "application/json": {
-                  schema: { $ref: "#/components/schemas/RpcSuccessResponse" }
-                }
-              }
-            },
-            400: errorResponseSpec(
-              "The envelope, parameters, or room state rejected the call.",
-              [
-                "invalid_params",
-                "invalid_json",
-                "invalid_request",
-                "not_found",
-                "invalid_state",
-                "shutting_down"
-              ]
-            ),
-            403: errorResponseSpec(
-              "The Host header was not a loopback console authority, the Origin did not match it, or the fetch was cross-site.",
-              ["forbidden"]
-            ),
-            404: errorResponseSpec(
-              "The method is not part of the REST route table.",
-              ["method_not_found"]
-            ),
-            413: errorResponseSpec("The request body exceeded 1 MiB.", ["request_too_large"]),
-            415: errorResponseSpec(
-              "The request did not declare `application/json`.",
-              ["unsupported_media_type"]
-            ),
-            500: errorResponseSpec("The daemon failed to complete the operation.", ["internal"])
-          }
-        }
-      },
-      [OPENAPI_DOCUMENT_PATH]: {
-        get: {
-          tags: ["documentation"],
-          operationId: "getOpenApiDocument",
-          summary: "Fetch this OpenAPI document",
-          description: "Returns the OpenAPI 3.1 description of the room-management REST API.",
-          responses: {
-            200: {
-              description: "The OpenAPI document.",
-              content: { "application/json": { schema: { type: "object" } } }
-            }
-          }
-        }
-      },
-      [API_DOCS_PATH]: {
-        get: {
-          tags: ["documentation"],
-          operationId: "getApiDocsPage",
-          summary: "Open the API documentation UI",
-          description: `Serves the browser UI that renders \`${OPENAPI_DOCUMENT_PATH}\`.`,
-          responses: { 200: documentResponseSpec("The documentation page.", "text/html") }
-        }
-      },
-      [API_DOCS_SCRIPT_PATH]: {
-        get: {
-          tags: ["documentation"],
-          operationId: "getApiDocsScript",
-          summary: "Fetch the documentation UI script",
-          responses: { 200: documentResponseSpec("The UI script.", "text/javascript") }
-        }
-      },
-      [API_DOCS_STYLESHEET_PATH]: {
-        get: {
-          tags: ["documentation"],
-          operationId: "getApiDocsStylesheet",
-          summary: "Fetch the documentation UI stylesheet",
-          responses: { 200: documentResponseSpec("The UI stylesheet.", "text/css") }
-        }
-      }
-    },
-    components: { schemas }
-  };
-}
-function apiDocsAsset(pathname) {
-  switch (pathname) {
-    case OPENAPI_DOCUMENT_PATH:
-      return {
-        body: `${JSON.stringify(buildOpenApiDocument(), null, 2)}
-`,
-        contentType: "application/json; charset=utf-8"
-      };
-    case API_DOCS_PATH:
-      return { body: DOCS_PAGE, contentType: "text/html; charset=utf-8" };
-    case API_DOCS_SCRIPT_PATH:
-      return { body: DOCS_SCRIPT, contentType: "text/javascript; charset=utf-8" };
-    case API_DOCS_STYLESHEET_PATH:
-      return { body: DOCS_STYLESHEET, contentType: "text/css; charset=utf-8" };
-    default:
-      return void 0;
-  }
-}
-var RPC_PATH, OPENAPI_DOCUMENT_PATH, API_DOCS_PATH, API_DOCS_SCRIPT_PATH, API_DOCS_STYLESHEET_PATH, API_VERSION, EXAMPLE_ROOM_ID, roomIdProperty, roleProperty, missionTextProperty, roomNameProperty, inviteModeProperty, notifyProperty, ROOM_RPC_METHODS, RPC_ERROR_CODES, DOCS_PAGE, DOCS_STYLESHEET, DOCS_SCRIPT;
-var init_openapi = __esm({
-  "src/openapi.ts"() {
-    "use strict";
-    RPC_PATH = "/rpc";
-    OPENAPI_DOCUMENT_PATH = "/openapi.json";
-    API_DOCS_PATH = "/docs";
-    API_DOCS_SCRIPT_PATH = "/docs/ui.js";
-    API_DOCS_STYLESHEET_PATH = "/docs/ui.css";
-    API_VERSION = "1";
-    EXAMPLE_ROOM_ID = "01jd7q4h9m2v8xk3znbc5regty";
-    roomIdProperty = {
-      type: "string",
-      pattern: "^[0-7][0-9a-hjkmnp-tv-z]{25}$",
-      description: "26-character lowercase Crockford ULID identifying the room."
-    };
-    roleProperty = {
-      type: "string",
-      description: "Invite role. At most 256 UTF-8 bytes."
-    };
-    missionTextProperty = (what) => ({
-      type: "string",
-      description: `${what}. At most 262144 UTF-8 bytes.`
-    });
-    roomNameProperty = {
-      type: "string",
-      description: "Friendly room name: 1-64 Unicode characters after trimming and NFC normalization, with no Unicode control or format characters. Duplicates are allowed."
-    };
-    inviteModeProperty = {
-      type: "string",
-      enum: ["one_time", "public"],
-      description: "Invitation mode. `one_time` requires `min_accepts` to be 1."
-    };
-    notifyProperty = {
-      type: "boolean",
-      description: "Announce the membership change to the room. Defaults to the room's quiet setting."
-    };
-    ROOM_RPC_METHODS = [
-      {
-        method: "room.create",
-        summary: "Create a room",
-        description: "Provisions a room, its durable metadata, and its room packet. The room stays in the provisioning state until its invitation requirements are satisfied.",
-        params: params({
-          name: roomNameProperty,
-          goal: missionTextProperty("Mission goal"),
-          briefing: missionTextProperty("Mission briefing"),
-          anonymous: {
-            type: "boolean",
-            description: "Project participants under aliases instead of contact identities."
-          },
-          quiet_membership: {
-            type: "boolean",
-            description: "Suppress membership announcements for this room by default."
-          }
-        }, ["goal", "briefing"]),
-        result: "The created room record, including `room_id`, `room_name`, `state`, mission, invites, and seats.",
-        example: { goal: "Ship the release", briefing: "Coordinate the 1.0 cut.", name: "Release" }
-      },
-      {
-        method: "room.settings",
-        summary: "Update room settings",
-        description: "Updates mutable room settings. At least one setting besides `room_id` is required; omitted settings are left unchanged.",
-        params: params({
-          room_id: roomIdProperty,
-          name: roomNameProperty,
-          goal: missionTextProperty("Replacement mission goal"),
-          briefing: missionTextProperty("Replacement mission briefing"),
-          status: { type: "string", minLength: 1, description: "Operator status line." },
-          quiet_membership: {
-            type: "boolean",
-            description: "Suppress membership announcements for this room."
-          }
-        }, ["room_id"]),
-        result: "The updated room record.",
-        example: { room_id: EXAMPLE_ROOM_ID, name: "Release cut" }
-      },
-      {
-        method: "room.briefing.role.set",
-        summary: "Set a role briefing",
-        description: "Creates or replaces the briefing for one role and bumps its briefing version.",
-        params: params({
-          room_id: roomIdProperty,
-          role: roleProperty,
-          text: missionTextProperty("Role briefing text")
-        }, ["room_id", "role", "text"]),
-        result: "The updated room record with the stored role briefing.",
-        example: { room_id: EXAMPLE_ROOM_ID, role: "Reviewer", text: "Review every merge request." }
-      },
-      {
-        method: "room.briefing.role.delete",
-        summary: "Delete a role briefing",
-        description: "Removes the briefing for one role.",
-        params: params({ room_id: roomIdProperty, role: roleProperty }, ["room_id", "role"]),
-        result: "The updated room record without the removed role briefing.",
-        example: { room_id: EXAMPLE_ROOM_ID, role: "Reviewer" }
-      },
-      {
-        method: "room.invite",
-        summary: "Mint an invitation requirement",
-        description: "Mints one invitation requirement and returns its receipt. The invite secret is returned once in `blob` and is never stored in room metadata or replayed by any later call.",
-        params: params({
-          room_id: roomIdProperty,
-          mode: inviteModeProperty,
-          role: roleProperty,
-          min_accepts: {
-            type: "integer",
-            minimum: 1,
-            description: "Acceptances required before the requirement is satisfied. Must be 1 for `one_time` invites."
-          }
-        }, ["room_id", "mode", "min_accepts"]),
-        result: "An invite receipt: `room_id`, the recorded `invite`, the one-shot `blob` secret, and `reusable`.",
-        example: { room_id: EXAMPLE_ROOM_ID, mode: "one_time", role: "Reviewer", min_accepts: 1 }
-      },
-      {
-        method: "room.participant.remove",
-        summary: "Remove a participant",
-        description: "Removes one participant seat, bumps the membership epoch, and severs the contact. The receipt reports what actually happened, including retained key material.",
-        params: params({
-          room_id: roomIdProperty,
-          participant: {
-            type: "string",
-            minLength: 1,
-            description: "Participant id, identity, display name, or alias."
-          },
-          notify: notifyProperty
-        }, ["room_id", "participant"]),
-        result: "A removal receipt with `participant_id`, `epoch`, `status`, `notified`, and `key_material_retained`.",
-        example: { room_id: EXAMPLE_ROOM_ID, participant: "Reviewer-1", notify: true }
-      },
-      {
-        method: "room.participant.replace",
-        summary: "Replace a participant",
-        description: "Removes one participant seat and mints a replacement invitation requirement in the same operation.",
-        params: params({
-          room_id: roomIdProperty,
-          participant: {
-            type: "string",
-            minLength: 1,
-            description: "Participant id, identity, display name, or alias."
-          },
-          notify: notifyProperty,
-          mode: inviteModeProperty,
-          min_accepts: {
-            type: "integer",
-            minimum: 1,
-            description: "Acceptances required for the replacement invitation requirement."
-          }
-        }, ["room_id", "participant"]),
-        result: "An invite receipt for the replacement, extended with the `removal` receipt.",
-        example: { room_id: EXAMPLE_ROOM_ID, participant: "Reviewer-1", mode: "one_time" }
-      },
-      {
-        method: "room.revoke",
-        summary: "Revoke an invitation requirement",
-        description: "Revokes one live invitation requirement so it can no longer admit a seat.",
-        params: params({
-          room_id: roomIdProperty,
-          invite_id: { type: "string", minLength: 1, description: "Recorded invite identifier." }
-        }, ["room_id", "invite_id"]),
-        result: "The updated room record with the invite marked revoked.",
-        example: { room_id: EXAMPLE_ROOM_ID, invite_id: "inv-01" }
-      },
-      {
-        method: "room.recover",
-        summary: "Recover unusable invitations",
-        description: "Mints recovery invitations for requirements whose secret can no longer admit a seat. Each recovery must be confirmed before it replaces the original.",
-        params: params({ room_id: roomIdProperty }, ["room_id"]),
-        result: "The list of recovery invite receipts, each carrying `recovery_of`.",
-        example: { room_id: EXAMPLE_ROOM_ID }
-      },
-      {
-        method: "room.recover.confirm",
-        summary: "Confirm a recovery invitation",
-        description: "Confirms that a recovery invitation was handed over, retiring the invitation requirement it recovers.",
-        params: params({
-          room_id: roomIdProperty,
-          recovery_of: { type: "string", minLength: 1, description: "Invite id being recovered." },
-          invite_id: { type: "string", minLength: 1, description: "Recovery invite id to confirm." }
-        }, ["room_id", "recovery_of", "invite_id"]),
-        result: "The updated room record with the confirmed recovery.",
-        example: { room_id: EXAMPLE_ROOM_ID, recovery_of: "inv-01", invite_id: "inv-02" }
-      },
-      {
-        method: "room.list",
-        summary: "List rooms",
-        description: "Lists every room held on this host. Takes no parameters.",
-        params: params({}, []),
-        result: "An array of room records.",
-        example: {}
-      },
-      {
-        method: "room.show",
-        summary: "Show one room",
-        description: "Returns the complete durable record for one room.",
-        params: params({ room_id: roomIdProperty }, ["room_id"]),
-        result: "The room record.",
-        example: { room_id: EXAMPLE_ROOM_ID }
-      },
-      {
-        method: "room.participants",
-        summary: "List participants",
-        description: "Returns the room's seats, including pending, active, and removed states.",
-        params: params({ room_id: roomIdProperty }, ["room_id"]),
-        result: "An array of seat records.",
-        example: { room_id: EXAMPLE_ROOM_ID }
-      },
-      {
-        method: "room.history",
-        summary: "Read room history",
-        description: "Reads one page of the room's ordered communication archive. The operator view returns every record kind; the participant view returns message records only, with routing identities removed and authors reduced to alias form in anonymous rooms.",
-        params: params({
-          room_id: roomIdProperty,
-          after: {
-            type: "integer",
-            minimum: 0,
-            description: "Return records with a sequence number greater than this value."
-          },
-          limit: { type: "integer", minimum: 1, description: "Maximum number of records to return." },
-          view: {
-            type: "string",
-            enum: ["operator", "participant"],
-            description: "History projection. Defaults to the operator view."
-          }
-        }, ["room_id"]),
-        result: "An array of communication records, byte-bounded to one page.",
-        example: { room_id: EXAMPLE_ROOM_ID, after: 0, limit: 50, view: "operator" }
-      },
-      {
-        method: "room.message",
-        summary: "Post an operator message",
-        description: "Appends an operator message to the room archive and relays it to active seats. Authorship is assigned by the daemon.",
-        params: params({
-          room_id: roomIdProperty,
-          text: missionTextProperty("Message text")
-        }, ["room_id", "text"]),
-        result: "The appended message record with its `seq` and `record_id`.",
-        example: { room_id: EXAMPLE_ROOM_ID, text: "Standup at 10:00." }
-      },
-      {
-        method: "room.close",
-        summary: "Close a room",
-        description: "Closes the room forward-only. The plaintext local archive is left in place.",
-        params: params({ room_id: roomIdProperty }, ["room_id"]),
-        result: "The closed room record.",
-        example: { room_id: EXAMPLE_ROOM_ID }
-      },
-      {
-        method: "room.delete",
-        summary: "Delete a room",
-        description: "Removes this host's local room state after the room is closed. The scope is this host only.",
-        params: params({
-          room_id: roomIdProperty,
-          confirm: { type: "boolean", const: true, description: "Must be `true`." }
-        }, ["room_id", "confirm"]),
-        result: 'A delete receipt: `{ "version": 1, "room_id": "...", "deleted": true, "scope": "this_host" }`.',
-        example: { room_id: EXAMPLE_ROOM_ID, confirm: true }
-      }
-    ];
-    RPC_ERROR_CODES = [
-      ["invalid_json", "The request body was not valid JSON."],
-      ["invalid_request", "The RPC envelope did not match the strict envelope schema."],
-      ["invalid_params", "The `params` object failed method validation."],
-      ["not_found", "The referenced room or record does not exist."],
-      ["invalid_state", "The room is not in a state that permits the operation."],
-      ["shutting_down", "The daemon stopped accepting work."],
-      ["method_not_found", "The method is not served over REST."],
-      ["unsupported_media_type", "The request did not declare `application/json`."],
-      ["forbidden", "The request origin or Host header was not the loopback console origin."],
-      ["request_too_large", "The request body exceeded 1 MiB."],
-      ["internal", "The daemon failed to complete the operation."]
-    ];
-    DOCS_PAGE = `<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>ours-cowork room management API</title>
-<link rel="stylesheet" href="${API_DOCS_STYLESHEET_PATH}">
-</head>
-<body>
-<main id="api-docs" data-document="${OPENAPI_DOCUMENT_PATH}" data-rpc="${RPC_PATH}">
-<p class="loading">Loading <code>${OPENAPI_DOCUMENT_PATH}</code>&hellip;</p>
-</main>
-<script src="${API_DOCS_SCRIPT_PATH}"></script>
-</body>
-</html>
-`;
-    DOCS_STYLESHEET = `:root { color-scheme: light dark; --line: #8883; --accent: #2563eb; }
-* { box-sizing: border-box; }
-body { margin: 0; font: 15px/1.5 ui-sans-serif, system-ui, sans-serif; }
-main { margin: 0 auto; max-width: 60rem; padding: 2rem 1.25rem 4rem; }
-h1 { font-size: 1.6rem; margin: 0 0 .25rem; }
-h2 { font-size: 1.15rem; margin: 2rem 0 .5rem; }
-code, pre, textarea { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: .86em; }
-pre { background: #8881; border-radius: 6px; margin: 0; overflow-x: auto; padding: .6rem .75rem; }
-.subtitle { color: #8889; margin: 0 0 1rem; }
-.intro { border-left: 3px solid var(--accent); padding-left: .9rem; white-space: pre-wrap; }
-.route { border: 1px solid var(--line); border-radius: 8px; margin-bottom: .5rem; padding: .6rem .8rem; }
-.verb { background: var(--accent); border-radius: 4px; color: #fff; font-size: .72rem;
-  font-weight: 700; letter-spacing: .04em; margin-right: .5rem; padding: .12rem .4rem; }
-details.method { border: 1px solid var(--line); border-radius: 8px; margin-bottom: .5rem; }
-details.method > summary { cursor: pointer; padding: .6rem .8rem; }
-details.method[open] > summary { border-bottom: 1px solid var(--line); }
-summary .name { font-family: ui-monospace, monospace; font-weight: 600; }
-summary .summary-text { color: #8889; margin-left: .6rem; }
-.body { padding: .8rem; }
-.description { margin: 0 0 .8rem; white-space: pre-wrap; }
-table { border-collapse: collapse; margin-bottom: .8rem; width: 100%; }
-th, td { border-bottom: 1px solid var(--line); padding: .35rem .5rem; text-align: left;
-  vertical-align: top; }
-th { font-size: .78rem; letter-spacing: .04em; text-transform: uppercase; }
-td.param { font-family: ui-monospace, monospace; white-space: nowrap; }
-.required { color: #b91c1c; font-size: .75rem; margin-left: .3rem; }
-textarea { border: 1px solid var(--line); border-radius: 6px; padding: .5rem; width: 100%; }
-button { background: var(--accent); border: 0; border-radius: 6px; color: #fff; cursor: pointer;
-  font: inherit; margin: .5rem 0; padding: .4rem 1rem; }
-.status { font-weight: 600; margin: .5rem 0 .35rem; }
-.status.failed { color: #b91c1c; }
-.error { color: #b91c1c; }
-`;
-    DOCS_SCRIPT = `'use strict';
-(function () {
-  var root = document.getElementById('api-docs');
-  var documentUrl = root.dataset.document;
-  var rpcUrl = root.dataset.rpc;
-
-  function element(tag, className, text) {
-    var node = document.createElement(tag);
-    if (className) node.className = className;
-    if (text !== undefined) node.textContent = text;
-    return node;
-  }
-
-  function resolveRef(spec, ref) {
-    return ref.replace(/^#\\//, '').split('/').reduce(function (node, part) {
-      return node === undefined ? undefined : node[part];
-    }, spec);
-  }
-
-  function typeLabel(schema) {
-    if (!schema) return 'any';
-    if (schema.const !== undefined) return JSON.stringify(schema.const);
-    if (schema.enum) return schema.enum.map(function (value) { return JSON.stringify(value); }).join(' | ');
-    return schema.type || 'any';
-  }
-
-  function parameterTable(schema) {
-    var properties = (schema && schema.properties) || {};
-    var names = Object.keys(properties);
-    if (names.length === 0) return element('p', 'description', 'No parameters.');
-    var required = (schema && schema.required) || [];
-    var table = document.createElement('table');
-    var head = table.insertRow();
-    ['Parameter', 'Type', 'Description'].forEach(function (label) {
-      head.appendChild(element('th', null, label));
-    });
-    names.forEach(function (name) {
-      var property = properties[name];
-      var row = table.insertRow();
-      var cell = element('td', 'param', name);
-      if (required.indexOf(name) >= 0) cell.appendChild(element('span', 'required', 'required'));
-      row.appendChild(cell);
-      row.appendChild(element('td', null, typeLabel(property)));
-      row.appendChild(element('td', null, property.description || ''));
-    });
-    return table;
-  }
-
-  function tryItPanel(example) {
-    var panel = document.createElement('div');
-    var input = document.createElement('textarea');
-    input.rows = Math.min(14, JSON.stringify(example, null, 2).split('\\n').length + 1);
-    input.value = JSON.stringify(example, null, 2);
-    input.setAttribute('aria-label', 'Request body');
-    var send = element('button', null, 'Send request');
-    var output = document.createElement('div');
-    send.addEventListener('click', function () {
-      var body = input.value;
-      try { JSON.parse(body); } catch (error) {
-        output.textContent = '';
-        output.appendChild(element('p', 'status failed', 'Request body is not valid JSON.'));
-        return;
-      }
-      send.disabled = true;
-      output.textContent = '';
-      output.appendChild(element('p', 'status', 'Sending\\u2026'));
-      fetch(rpcUrl, {
-        method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: body,
-      }).then(function (response) {
-        return response.text().then(function (text) { return { status: response.status, text: text }; });
-      }).then(function (result) {
-        var pretty = result.text;
-        try { pretty = JSON.stringify(JSON.parse(result.text), null, 2); } catch (error) { /* raw */ }
-        output.textContent = '';
-        output.appendChild(element(
-          'p',
-          result.status === 200 ? 'status' : 'status failed',
-          'HTTP ' + result.status
-        ));
-        output.appendChild(element('pre', null, pretty));
-      }).catch(function (error) {
-        output.textContent = '';
-        output.appendChild(element('p', 'status failed', 'Request failed: ' + error));
-      }).then(function () { send.disabled = false; });
-    });
-    panel.appendChild(element('h3', null, 'Try it'));
-    panel.appendChild(input);
-    panel.appendChild(send);
-    panel.appendChild(output);
-    return panel;
-  }
-
-  function methodPanel(spec, ref) {
-    var schema = resolveRef(spec, ref);
-    var method = schema.properties.method.const;
-    var panel = element('details', 'method');
-    var summary = document.createElement('summary');
-    summary.appendChild(element('span', 'name', method));
-    summary.appendChild(element('span', 'summary-text', schema.title || ''));
-    panel.appendChild(summary);
-    var body = element('div', 'body');
-    body.appendChild(element('p', 'description', schema.description || ''));
-    body.appendChild(parameterTable(resolveRef(spec, schema.properties.params.$ref)));
-    body.appendChild(tryItPanel((schema.examples && schema.examples[0]) || {
-      version: 1, id: 'req-1', method: method, params: {},
-    }));
-    panel.appendChild(body);
-    return panel;
-  }
-
-  function renderRoutes(spec) {
-    var section = document.createDocumentFragment();
-    Object.keys(spec.paths).forEach(function (path) {
-      Object.keys(spec.paths[path]).forEach(function (verb) {
-        var operation = spec.paths[path][verb];
-        var route = element('div', 'route');
-        var heading = document.createElement('div');
-        heading.appendChild(element('span', 'verb', verb.toUpperCase()));
-        heading.appendChild(element('code', null, path));
-        route.appendChild(heading);
-        route.appendChild(element('p', 'description', operation.summary || ''));
-        section.appendChild(route);
-      });
-    });
-    return section;
-  }
-
-  function render(spec) {
-    root.textContent = '';
-    root.appendChild(element('h1', null, spec.info.title));
-    root.appendChild(element('p', 'subtitle', 'API version ' + spec.info.version + ' \\u00b7 OpenAPI ' + spec.openapi));
-    root.appendChild(element('p', 'intro', spec.info.description || ''));
-    root.appendChild(element('h2', null, 'Routes'));
-    root.appendChild(renderRoutes(spec));
-    root.appendChild(element('h2', null, 'Room management methods'));
-    var alternatives = spec.paths[rpcUrl].post.requestBody.content['application/json'].schema.oneOf;
-    alternatives.forEach(function (alternative) {
-      root.appendChild(methodPanel(spec, alternative.$ref));
-    });
-  }
-
-  fetch(documentUrl).then(function (response) {
-    if (!response.ok) throw new Error('HTTP ' + response.status);
-    return response.json();
-  }).then(render).catch(function (error) {
-    root.textContent = '';
-    root.appendChild(element('p', 'error', 'Could not load ' + documentUrl + ': ' + error));
-  });
-}());
-`;
-  }
-});
-
 // src/web.ts
-import * as nodeFs4 from "node:fs";
+import * as nodeFs3 from "node:fs";
 import { extname, join as join5 } from "node:path";
-function loadWebAssets(root, fs2 = nodeFs4) {
+function loadWebAssets(root, fs3 = nodeFs3) {
   let rootIdentity;
   try {
-    rootIdentity = observeDirectory(fs2, root, "web asset root");
+    rootIdentity = observeDirectory(fs3, root, "web asset root");
   } catch (error) {
     if (error.code === "ENOENT") return /* @__PURE__ */ new Map();
     throw error;
   }
   const manifest = /* @__PURE__ */ new Map();
-  manifest.set("/", loadAsset(fs2, join5(root, "index.html"), false, [rootIdentity]));
+  manifest.set("/", loadAsset(fs3, join5(root, "index.html"), false, [rootIdentity]));
   const assetsDirectory = join5(root, "assets");
-  assertDirectoryIdentity(fs2, rootIdentity);
-  const assetsIdentity = observeDirectory(fs2, assetsDirectory, "web assets directory");
-  assertDirectoryIdentity(fs2, rootIdentity);
+  assertDirectoryIdentity(fs3, rootIdentity);
+  const assetsIdentity = observeDirectory(fs3, assetsDirectory, "web assets directory");
+  assertDirectoryIdentity(fs3, rootIdentity);
   const directories = [rootIdentity, assetsIdentity];
-  assertDirectoryIdentities(fs2, directories);
-  const assetEntries = fs2.readdirSync(assetsDirectory, { withFileTypes: true });
-  assertDirectoryIdentities(fs2, directories);
+  assertDirectoryIdentities(fs3, directories);
+  const assetEntries = fs3.readdirSync(assetsDirectory, { withFileTypes: true });
+  assertDirectoryIdentities(fs3, directories);
   for (const entry of assetEntries) {
     if (!entry.isFile() || entry.isSymbolicLink()) continue;
     const path = join5(assetsDirectory, entry.name);
-    manifest.set(`/assets/${entry.name}`, loadAsset(fs2, path, true, directories));
+    manifest.set(`/assets/${entry.name}`, loadAsset(fs3, path, true, directories));
   }
-  assertDirectoryIdentities(fs2, directories);
+  assertDirectoryIdentities(fs3, directories);
   return manifest;
 }
 function createStaticWebHandler(assets) {
@@ -9370,44 +8151,44 @@ function createStaticWebHandler(assets) {
     return true;
   };
 }
-function loadAsset(fs2, path, immutable, directories) {
-  assertDirectoryIdentities(fs2, directories);
-  const observed = fs2.lstatSync(path);
-  assertDirectoryIdentities(fs2, directories);
+function loadAsset(fs3, path, immutable, directories) {
+  assertDirectoryIdentities(fs3, directories);
+  const observed = fs3.lstatSync(path);
+  assertDirectoryIdentities(fs3, directories);
   if (observed.isSymbolicLink() || !observed.isFile() || observed.nlink !== 1) {
     throw new Error(`web asset must be a non-symbolic-link regular file: ${path}`);
   }
   let fd;
   try {
-    fd = fs2.openSync(path, nodeFs4.constants.O_RDONLY | NO_FOLLOW3);
-    const opened = fs2.fstatSync(fd);
-    assertDirectoryIdentities(fs2, directories);
+    fd = fs3.openSync(path, nodeFs3.constants.O_RDONLY | NO_FOLLOW3);
+    const opened = fs3.fstatSync(fd);
+    assertDirectoryIdentities(fs3, directories);
     if (!opened.isFile() || opened.nlink !== 1 || opened.dev !== observed.dev || opened.ino !== observed.ino) {
       throw new Error(`web asset changed while opening: ${path}`);
     }
-    const bytes = fs2.readFileSync(fd);
-    assertDirectoryIdentities(fs2, directories);
+    const bytes = fs3.readFileSync(fd);
+    assertDirectoryIdentities(fs3, directories);
     return {
       bytes,
       contentType: CONTENT_TYPES.get(extname(path).toLowerCase()) ?? "application/octet-stream",
       immutable
     };
   } finally {
-    if (fd !== void 0) fs2.closeSync(fd);
+    if (fd !== void 0) fs3.closeSync(fd);
   }
 }
-function observeDirectory(fs2, path, label) {
-  const stat = fs2.lstatSync(path);
+function observeDirectory(fs3, path, label) {
+  const stat = fs3.lstatSync(path);
   if (stat.isSymbolicLink() || !stat.isDirectory()) {
     throw new Error(`${label} must be a non-symbolic-link directory`);
   }
   return { path, label, dev: stat.dev, ino: stat.ino };
 }
-function assertDirectoryIdentities(fs2, directories) {
-  for (const directory of directories) assertDirectoryIdentity(fs2, directory);
+function assertDirectoryIdentities(fs3, directories) {
+  for (const directory of directories) assertDirectoryIdentity(fs3, directory);
 }
-function assertDirectoryIdentity(fs2, expected) {
-  const current = fs2.lstatSync(expected.path);
+function assertDirectoryIdentity(fs3, expected) {
+  const current = fs3.lstatSync(expected.path);
   if (current.isSymbolicLink() || !current.isDirectory() || current.dev !== expected.dev || current.ino !== expected.ino) {
     throw new Error(`${expected.label} changed during web asset loading`);
   }
@@ -9446,7 +8227,7 @@ var NO_FOLLOW3, CONTENT_SECURITY_POLICY, CONTENT_TYPES;
 var init_web = __esm({
   "src/web.ts"() {
     "use strict";
-    NO_FOLLOW3 = nodeFs4.constants.O_NOFOLLOW ?? 0;
+    NO_FOLLOW3 = nodeFs3.constants.O_NOFOLLOW ?? 0;
     CONTENT_SECURITY_POLICY = [
       "default-src 'self'",
       "script-src 'self'",
@@ -9483,12 +8264,12 @@ var init_web = __esm({
 import { randomBytes as randomBytes4 } from "node:crypto";
 import * as http from "node:http";
 import * as net from "node:net";
-import * as nodeFs5 from "node:fs";
-import { basename, dirname as dirname5, join as join6 } from "node:path";
+import * as nodeFs4 from "node:fs";
+import { basename, dirname as dirname3, join as join6 } from "node:path";
 function createServiceRoutes(service) {
   return {
-    "room.create": { auth: true, run: (params2) => service.createRoom(params2) },
-    "room.settings": { auth: true, run: (params2) => {
+    "room.create": { auth: true, run: (params) => service.createRoom(params) },
+    "room.settings": { auth: true, run: (params) => {
       const { room_id, ...input } = external_exports.object({
         room_id: external_exports.string(),
         name: external_exports.unknown().optional(),
@@ -9496,68 +8277,68 @@ function createServiceRoutes(service) {
         briefing: external_exports.unknown().optional(),
         status: external_exports.unknown().optional(),
         quiet_membership: external_exports.unknown().optional()
-      }).strict().parse(params2);
+      }).strict().parse(params);
       return service.updateRoom(room_id, input);
     } },
-    "room.briefing.role.set": { auth: true, run: (params2) => {
-      const { room_id, ...input } = RoleBriefingSetParams.parse(params2);
+    "room.briefing.role.set": { auth: true, run: (params) => {
+      const { room_id, ...input } = RoleBriefingSetParams.parse(params);
       return service.setRoleBriefing(room_id, input);
     } },
-    "room.briefing.role.delete": { auth: true, run: (params2) => {
-      const { room_id, ...input } = RoleBriefingDeleteParams.parse(params2);
+    "room.briefing.role.delete": { auth: true, run: (params) => {
+      const { room_id, ...input } = RoleBriefingDeleteParams.parse(params);
       return service.deleteRoleBriefing(room_id, input);
     } },
-    "room.invite": { auth: true, run: (params2) => {
+    "room.invite": { auth: true, run: (params) => {
       const { room_id, ...input } = external_exports.object({
         room_id: external_exports.string(),
         mode: external_exports.unknown(),
         role: external_exports.unknown().optional(),
         min_accepts: external_exports.unknown()
-      }).strict().parse(params2);
+      }).strict().parse(params);
       return service.createInvite(room_id, input);
     } },
-    "room.participant.remove": { auth: true, run: (params2) => {
-      const { room_id, ...input } = ParticipantRemoveParams.parse(params2);
+    "room.participant.remove": { auth: true, run: (params) => {
+      const { room_id, ...input } = ParticipantRemoveParams.parse(params);
       return service.removeParticipant(room_id, input);
     } },
-    "room.participant.replace": { auth: true, run: (params2) => {
-      const { room_id, ...input } = ParticipantReplaceParams.parse(params2);
+    "room.participant.replace": { auth: true, run: (params) => {
+      const { room_id, ...input } = ParticipantReplaceParams.parse(params);
       return service.replaceParticipant(room_id, input);
     } },
-    "room.revoke": { auth: true, run: (params2) => {
-      const value = InviteRevokeParams.parse(params2);
+    "room.revoke": { auth: true, run: (params) => {
+      const value = InviteRevokeParams.parse(params);
       return service.revokeInvite(value.room_id, value.invite_id);
     } },
-    "room.recover": { auth: true, run: (params2) => service.recoverInvites(RoomIdParams.parse(params2).room_id) },
-    "room.recover.confirm": { auth: true, run: (params2) => {
-      const value = RecoverConfirmParams.parse(params2);
+    "room.recover": { auth: true, run: (params) => service.recoverInvites(RoomIdParams.parse(params).room_id) },
+    "room.recover.confirm": { auth: true, run: (params) => {
+      const value = RecoverConfirmParams.parse(params);
       return service.confirmRecoveredInvite(value.room_id, value.recovery_of, value.invite_id);
     } },
-    "room.list": { auth: true, run: (params2) => {
-      external_exports.object({}).strict().parse(params2);
+    "room.list": { auth: true, run: (params) => {
+      external_exports.object({}).strict().parse(params);
       return service.listRooms();
     } },
-    "room.show": { auth: true, run: (params2) => service.showRoom(RoomIdParams.parse(params2).room_id) },
-    "room.participants": { auth: true, run: (params2) => service.participants(RoomIdParams.parse(params2).room_id) },
-    "room.history": { auth: true, run: (params2) => {
-      const { room_id, ...options } = HistoryParams.parse(params2);
+    "room.show": { auth: true, run: (params) => service.showRoom(RoomIdParams.parse(params).room_id) },
+    "room.participants": { auth: true, run: (params) => service.participants(RoomIdParams.parse(params).room_id) },
+    "room.history": { auth: true, run: (params) => {
+      const { room_id, ...options } = HistoryParams.parse(params);
       return service.history(room_id, options);
     } },
-    "room.message": { auth: true, run: (params2) => {
-      const { room_id, ...input } = external_exports.object({ room_id: external_exports.string(), text: external_exports.unknown() }).strict().parse(params2);
+    "room.message": { auth: true, run: (params) => {
+      const { room_id, ...input } = external_exports.object({ room_id: external_exports.string(), text: external_exports.unknown() }).strict().parse(params);
       return service.postMessage(room_id, input);
     } },
-    "room.close": { auth: true, run: (params2) => service.closeRoom(RoomIdParams.parse(params2).room_id) },
-    "room.delete": { auth: true, run: (params2) => {
-      const { room_id, ...input } = external_exports.object({ room_id: external_exports.string(), confirm: external_exports.unknown() }).strict().parse(params2);
+    "room.close": { auth: true, run: (params) => service.closeRoom(RoomIdParams.parse(params).room_id) },
+    "room.delete": { auth: true, run: (params) => {
+      const { room_id, ...input } = external_exports.object({ room_id: external_exports.string(), confirm: external_exports.unknown() }).strict().parse(params);
       return service.deleteRoom(room_id, input);
     } }
   };
 }
 function createPrivateServiceRoutes(service) {
   return {
-    "room.accept": { auth: true, run: (params2) => {
-      const { room_id, ...input } = ExternalInviteAcceptParams.parse(params2);
+    "room.accept": { auth: true, run: (params) => {
+      const { room_id, ...input } = ExternalInviteAcceptParams.parse(params);
       return service.acceptExternalInvite(room_id, input);
     } }
   };
@@ -9577,23 +8358,6 @@ function isJsonMediaType(value) {
   const mediaType = value.split(";", 1)[0]?.trim().toLowerCase();
   return mediaType === "application/json" || mediaType?.startsWith("application/") === true && mediaType.endsWith("+json");
 }
-async function serveApiDocs(request, response) {
-  const pathname = safePathname(request.url);
-  if (pathname === void 0) return false;
-  const asset = apiDocsAsset(pathname);
-  if (!asset) return false;
-  const body = Buffer.from(asset.body, "utf8");
-  response.writeHead(200, {
-    "content-type": asset.contentType,
-    "content-length": body.length,
-    "cache-control": "no-cache",
-    "content-security-policy": CONTENT_SECURITY_POLICY,
-    "x-content-type-options": "nosniff"
-  });
-  response.end(body);
-  await responseFinished2(response);
-  return true;
-}
 function sendJson(response, status, value) {
   const body = Buffer.from(JSON.stringify(value), "utf8");
   response.writeHead(status, {
@@ -9711,7 +8475,6 @@ var init_transports = __esm({
   "src/transports.ts"() {
     "use strict";
     init_zod();
-    init_openapi();
     init_web();
     MAX_REQUEST_BYTES = 1024 * 1024;
     HTTP_HEADERS_TIMEOUT_MS = 5e3;
@@ -9831,7 +8594,7 @@ var init_transports = __esm({
       protectedPrivateReplacement;
       constructor(options) {
         this.options = options;
-        this.fs = options.fs ?? nodeFs5;
+        this.fs = options.fs ?? nodeFs4;
         this.staticHandler = options.staticHandler ?? createStaticWebHandler(/* @__PURE__ */ new Map());
       }
       get restAddress() {
@@ -9978,7 +8741,6 @@ var init_transports = __esm({
           if (request.url !== "/rpc") {
             if (request.method === "GET") {
               activateResponse();
-              if (await serveApiDocs(request, response)) return;
               if (await this.staticHandler(request, response)) return;
             }
             activateResponse();
@@ -10127,7 +8889,7 @@ var init_transports = __esm({
         throw new Error(`private management socket changed during removal; replacement protected at ${quarantined.path}`);
       }
       async cleanupStalePrivateSockets() {
-        const directory = dirname5(this.options.socketPath);
+        const directory = dirname3(this.options.socketPath);
         const prefix = `${basename(this.options.socketPath)}.private-`;
         const uid = typeof process.getuid === "function" ? process.getuid() : void 0;
         const candidates = this.fs.readdirSync(directory).filter((name) => name.startsWith(prefix)).sort().slice(0, MAX_STALE_PRIVATE_SOCKET_CLEANUP);
@@ -10235,24 +8997,24 @@ __export(daemon_runtime_exports, {
   removeDaemonPid: () => removeDaemonPid,
   writeDaemonPid: () => writeDaemonPid
 });
-import * as nodeFs6 from "node:fs";
+import * as nodeFs5 from "node:fs";
 import { join as join7 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath } from "node:url";
 function isIntakeNotification(event) {
   return event === "message_received" || event === "file_received" || event === "contact_accepted" || event === "contact_added";
 }
 function createDaemonControlRoutes(control) {
   if (!/^[0-9a-f]{32}$/.test(control.session)) throw new TypeError("invalid daemon control session");
-  const requireExact = (params2, keys) => {
-    if (Object.keys(params2).length !== keys.length || keys.some((key) => !Object.hasOwn(params2, key))) {
+  const requireExact = (params, keys) => {
+    if (Object.keys(params).length !== keys.length || keys.some((key) => !Object.hasOwn(params, key))) {
       throw new TypeError("invalid daemon control parameters");
     }
   };
   return {
     "daemon.status": {
       auth: true,
-      run(params2) {
-        requireExact(params2, []);
+      run(params) {
+        requireExact(params, []);
         return {
           version: 1,
           protocol: "cowork-supervisor-control",
@@ -10263,9 +9025,9 @@ function createDaemonControlRoutes(control) {
     },
     "daemon.shutdown": {
       auth: true,
-      async run(params2) {
-        requireExact(params2, ["session"]);
-        if (params2.session !== control.session) throw new TypeError("daemon control session changed");
+      async run(params) {
+        requireExact(params, ["session"]);
+        if (params.session !== control.session) throw new TypeError("daemon control session changed");
         if (!await control.requestSupervisorShutdown()) throw new Error("supervisor IPC rejected shutdown request");
         return { accepted: true, session: control.session };
       }
@@ -10273,7 +9035,7 @@ function createDaemonControlRoutes(control) {
   };
 }
 function acquireDaemonLock(stateDir, options = {}) {
-  const fs2 = options.fs ?? nodeFs6;
+  const fs3 = options.fs ?? nodeFs5;
   const pid = options.pid ?? process.pid;
   const alive = options.isProcessAlive ?? isProcessAlive;
   const path = join7(stateDir, "daemon.lock");
@@ -10281,22 +9043,22 @@ function acquireDaemonLock(stateDir, options = {}) {
     let fd;
     let created = false;
     try {
-      fd = fs2.openSync(path, nodeFs6.constants.O_CREAT | nodeFs6.constants.O_EXCL | nodeFs6.constants.O_WRONLY | NO_FOLLOW4, FILE_MODE3);
+      fd = fs3.openSync(path, nodeFs5.constants.O_CREAT | nodeFs5.constants.O_EXCL | nodeFs5.constants.O_WRONLY | NO_FOLLOW4, FILE_MODE3);
       created = true;
-      fs2.fchmodSync(fd, FILE_MODE3);
-      writeAll(fs2, fd, Buffer.from(`${pid}
+      fs3.fchmodSync(fd, FILE_MODE3);
+      writeAll(fs3, fd, Buffer.from(`${pid}
 `, "ascii"));
-      fs2.fsyncSync(fd);
-      const owned = fs2.fstatSync(fd);
-      fs2.closeSync(fd);
+      fs3.fsyncSync(fd);
+      const owned = fs3.fstatSync(fd);
+      fs3.closeSync(fd);
       fd = void 0;
-      fsyncDirectory2(fs2, stateDir);
+      fsyncDirectory2(fs3, stateDir);
       const pidPath = join7(stateDir, "daemon.pid");
-      if (lstatIfPresent2(fs2, pidPath)) {
-        const pidOwner = readSecurePid(fs2, pidPath, "daemon PID");
+      if (lstatIfPresent2(fs3, pidPath)) {
+        const pidOwner = readSecurePid(fs3, pidPath, "daemon PID");
         if (alive(pidOwner)) {
-          fs2.unlinkSync(path);
-          fsyncDirectory2(fs2, stateDir);
+          fs3.unlinkSync(path);
+          fsyncDirectory2(fs3, stateDir);
           throw new Error(`cowork daemon is already running with PID ${pidOwner}`);
         }
       }
@@ -10305,90 +9067,90 @@ function acquireDaemonLock(stateDir, options = {}) {
         release() {
           if (released) return;
           released = true;
-          const current = lstatIfPresent2(fs2, path);
+          const current = lstatIfPresent2(fs3, path);
           if (!current || current.dev !== owned.dev || current.ino !== owned.ino) return;
-          const content = readSecurePid(fs2, path, "daemon lock");
+          const content = readSecurePid(fs3, path, "daemon lock");
           if (content !== pid) return;
-          fs2.unlinkSync(path);
-          fsyncDirectory2(fs2, stateDir);
+          fs3.unlinkSync(path);
+          fsyncDirectory2(fs3, stateDir);
         }
       };
     } catch (error) {
       if (fd !== void 0) try {
-        fs2.closeSync(fd);
+        fs3.closeSync(fd);
       } catch {
       }
       if (error.code !== "EEXIST") {
         if (created) {
           try {
-            fs2.unlinkSync(path);
-            fsyncDirectory2(fs2, stateDir);
+            fs3.unlinkSync(path);
+            fsyncDirectory2(fs3, stateDir);
           } catch {
           }
         }
         throw error;
       }
-      const observed = fs2.lstatSync(path);
-      const owner = readSecurePid(fs2, path, "daemon lock");
+      const observed = fs3.lstatSync(path);
+      const owner = readSecurePid(fs3, path, "daemon lock");
       if (alive(owner)) throw new Error(`cowork daemon is already running with PID ${owner}`);
-      const current = fs2.lstatSync(path);
+      const current = fs3.lstatSync(path);
       if (current.dev !== observed.dev || current.ino !== observed.ino) continue;
-      fs2.unlinkSync(path);
-      fsyncDirectory2(fs2, stateDir);
+      fs3.unlinkSync(path);
+      fsyncDirectory2(fs3, stateDir);
     }
   }
   throw new Error("daemon lock changed repeatedly while acquiring it");
 }
-function writeDaemonPid(stateDir, fs2 = nodeFs6, pid = process.pid) {
+function writeDaemonPid(stateDir, fs3 = nodeFs5, pid = process.pid) {
   const path = join7(stateDir, "daemon.pid");
-  const existing = lstatIfPresent2(fs2, path);
+  const existing = lstatIfPresent2(fs3, path);
   if (existing) {
-    const owner = readSecurePid(fs2, path, "daemon PID");
+    const owner = readSecurePid(fs3, path, "daemon PID");
     if (isProcessAlive(owner) && owner !== pid) throw new Error(`cowork daemon PID file belongs to live PID ${owner}`);
-    const current = fs2.lstatSync(path);
+    const current = fs3.lstatSync(path);
     if (current.dev !== existing.dev || current.ino !== existing.ino) throw new Error("daemon PID file changed during stale-owner check");
-    fs2.unlinkSync(path);
+    fs3.unlinkSync(path);
   }
   let fd;
   let created = false;
   try {
-    fd = fs2.openSync(path, nodeFs6.constants.O_CREAT | nodeFs6.constants.O_EXCL | nodeFs6.constants.O_WRONLY | NO_FOLLOW4, FILE_MODE3);
+    fd = fs3.openSync(path, nodeFs5.constants.O_CREAT | nodeFs5.constants.O_EXCL | nodeFs5.constants.O_WRONLY | NO_FOLLOW4, FILE_MODE3);
     created = true;
-    fs2.fchmodSync(fd, FILE_MODE3);
-    writeAll(fs2, fd, Buffer.from(`${pid}
+    fs3.fchmodSync(fd, FILE_MODE3);
+    writeAll(fs3, fd, Buffer.from(`${pid}
 `, "ascii"));
-    fs2.fsyncSync(fd);
+    fs3.fsyncSync(fd);
   } catch (error) {
     if (fd !== void 0) {
       try {
-        fs2.closeSync(fd);
+        fs3.closeSync(fd);
       } catch {
       }
       fd = void 0;
     }
     if (created) try {
-      fs2.unlinkSync(path);
+      fs3.unlinkSync(path);
     } catch {
     }
     throw error;
   } finally {
-    if (fd !== void 0) fs2.closeSync(fd);
+    if (fd !== void 0) fs3.closeSync(fd);
   }
-  fsyncDirectory2(fs2, stateDir);
+  fsyncDirectory2(fs3, stateDir);
 }
-function removeDaemonPid(stateDir, fs2 = nodeFs6, pid = process.pid) {
+function removeDaemonPid(stateDir, fs3 = nodeFs5, pid = process.pid) {
   const path = join7(stateDir, "daemon.pid");
-  const observed = lstatIfPresent2(fs2, path);
+  const observed = lstatIfPresent2(fs3, path);
   if (!observed) return;
-  const owner = readSecurePid(fs2, path, "daemon PID");
+  const owner = readSecurePid(fs3, path, "daemon PID");
   if (owner !== pid) return;
-  const current = fs2.lstatSync(path);
+  const current = fs3.lstatSync(path);
   if (current.dev !== observed.dev || current.ino !== observed.ino) return;
-  fs2.unlinkSync(path);
-  fsyncDirectory2(fs2, stateDir);
+  fs3.unlinkSync(path);
+  fsyncDirectory2(fs3, stateDir);
 }
-function readSecurePid(fs2, path, label) {
-  const stat = fs2.lstatSync(path);
+function readSecurePid(fs3, path, label) {
+  const stat = fs3.lstatSync(path);
   if (stat.isSymbolicLink() || !stat.isFile() || stat.nlink !== 1 || (stat.mode & 511) !== FILE_MODE3) {
     throw new Error(`${label} must be a 0600 single-link regular file`);
   }
@@ -10398,15 +9160,15 @@ function readSecurePid(fs2, path, label) {
   let fd;
   let text;
   try {
-    fd = fs2.openSync(path, nodeFs6.constants.O_RDONLY | NO_FOLLOW4);
-    const opened = fs2.fstatSync(fd);
-    const current = fs2.lstatSync(path);
+    fd = fs3.openSync(path, nodeFs5.constants.O_RDONLY | NO_FOLLOW4);
+    const opened = fs3.fstatSync(fd);
+    const current = fs3.lstatSync(path);
     if (opened.dev !== stat.dev || opened.ino !== stat.ino || current.dev !== opened.dev || current.ino !== opened.ino) {
       throw new Error(`${label} changed while opening`);
     }
-    text = fs2.readFileSync(fd, "utf8");
+    text = fs3.readFileSync(fd, "utf8");
   } finally {
-    if (fd !== void 0) fs2.closeSync(fd);
+    if (fd !== void 0) fs3.closeSync(fd);
   }
   if (!/^[1-9][0-9]*\n$/.test(text)) throw new Error(`${label} contains an invalid PID`);
   const pid = Number(text.trim());
@@ -10421,26 +9183,26 @@ function isProcessAlive(pid) {
     return error.code === "EPERM";
   }
 }
-function writeAll(fs2, fd, bytes) {
+function writeAll(fs3, fd, bytes) {
   let offset = 0;
   while (offset < bytes.length) {
-    const written = fs2.writeSync(fd, bytes, offset, bytes.length - offset, null);
+    const written = fs3.writeSync(fd, bytes, offset, bytes.length - offset, null);
     if (written <= 0) throw new Error("write made no progress");
     offset += written;
   }
 }
-function fsyncDirectory2(fs2, path) {
+function fsyncDirectory2(fs3, path) {
   let fd;
   try {
-    fd = fs2.openSync(path, nodeFs6.constants.O_RDONLY | NO_FOLLOW4);
-    fs2.fsyncSync(fd);
+    fd = fs3.openSync(path, nodeFs5.constants.O_RDONLY | NO_FOLLOW4);
+    fs3.fsyncSync(fd);
   } finally {
-    if (fd !== void 0) fs2.closeSync(fd);
+    if (fd !== void 0) fs3.closeSync(fd);
   }
 }
-function lstatIfPresent2(fs2, path) {
+function lstatIfPresent2(fs3, path) {
   try {
-    return fs2.lstatSync(path);
+    return fs3.lstatSync(path);
   } catch (error) {
     if (error.code === "ENOENT") return void 0;
     throw error;
@@ -10451,18 +9213,18 @@ function requiresExitFrom(error) {
 }
 var FILE_MODE3, NO_FOLLOW4, DaemonBootCancelledError, DaemonShutdownError, CoworkDaemon;
 var init_daemon_runtime = __esm({
-  async "src/daemon-runtime.ts"() {
+  "src/daemon-runtime.ts"() {
     "use strict";
-    await init_adapt();
     init_config();
     init_config();
-    await init_packets();
-    await init_service();
+    init_ours_runtime();
+    init_packets();
+    init_service();
     init_storage();
     init_transports();
     init_web();
     FILE_MODE3 = 384;
-    NO_FOLLOW4 = nodeFs6.constants.O_NOFOLLOW ?? 0;
+    NO_FOLLOW4 = nodeFs5.constants.O_NOFOLLOW ?? 0;
     DaemonBootCancelledError = class extends Error {
       constructor() {
         super("cowork daemon boot cancelled by shutdown");
@@ -10514,7 +9276,7 @@ var init_daemon_runtime = __esm({
         this.options.onStage?.("post-lock");
         this.checkpoint();
         try {
-          this.host = this.options.host ?? new AdaptHost(config.brokerUrl, this.options.log);
+          this.host = this.options.host ?? createOursHost(config, this.options.log);
           this.store = this.options.store ?? new CoworkStore(config.stateDir);
           let serviceRef = this.options.service;
           this.registry = this.options.registry ?? new PacketRegistry(
@@ -10565,7 +9327,7 @@ var init_daemon_runtime = __esm({
           const unixDispatcher = new RpcDispatcher(unixRoutes);
           const restDispatcher = new RpcDispatcher(serviceRoutes);
           const staticHandler = createStaticWebHandler(loadWebAssets(
-            fileURLToPath2(new URL("./web/", import.meta.url))
+            fileURLToPath(new URL("./web/", import.meta.url))
           ));
           this.transports = this.options.transports ?? new TransportServer({
             socketPath: runtime.socketPath,
@@ -10808,7 +9570,7 @@ async function runWorker() {
     await acknowledge();
     return shutdownComplete;
   }
-  const runtime = await init_daemon_runtime().then(() => daemon_runtime_exports);
+  const runtime = await Promise.resolve().then(() => (init_daemon_runtime(), daemon_runtime_exports));
   if (shutdownRequested) {
     await acknowledge();
     return shutdownComplete;
@@ -10903,13 +9665,13 @@ var init_daemon_process = __esm({
 import { fork } from "node:child_process";
 import { randomBytes as randomBytes6 } from "node:crypto";
 import { resolve as resolve3 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 async function runSupervisor(options = {}) {
   const workerEnv = { ...process.env };
   delete workerEnv.NODE_OPTIONS;
   workerEnv.OURS_COWORK_DAEMON_WORKER = "1";
   workerEnv.OURS_COWORK_SUPERVISOR_PID = String(process.pid);
-  const child = fork(fileURLToPath3(import.meta.url), [], {
+  const child = fork(fileURLToPath2(import.meta.url), [], {
     env: workerEnv,
     stdio: options.quiet ? ["ignore", "ignore", "ignore", "ipc"] : ["inherit", "inherit", "inherit", "ipc"],
     execArgv: [],
@@ -11085,7 +9847,7 @@ var init_daemon = __esm({
       }
     };
     invokedPath = process.argv[1] ? resolve3(process.argv[1]) : void 0;
-    if (invokedPath === fileURLToPath3(import.meta.url)) {
+    if (invokedPath === fileURLToPath2(import.meta.url)) {
       void Promise.resolve().then(() => (init_daemon_process(), daemon_process_exports)).then(({ runDaemonProcess: runDaemonProcess2 }) => runDaemonProcess2()).catch((error) => {
         console.error(error instanceof Error ? error.stack ?? error.message : String(error));
         process.exitCode = 1;