@ricsam/r5d-worker 0.0.137 → 0.0.139

package/dist/mjs/runtime/pty-host.mjs

@@ -0,0 +1,156 @@
+// node-pty's Unix FD integration needs Node, not Bun. This helper belongs to the
+// keeper lifetime, never the adapter. Its IPC is inherited anonymous pipes only.
+import process from "node:process";
+import { Buffer } from "node:buffer";
+import { write, constants, openSync, closeSync, lstatSync, fstatSync, fchmodSync, readSync, realpathSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { setTimeout as delay } from "node:timers/promises";
+import pty from "node-pty";
+import readline from "node:readline";
+
+/** node-pty 1.1.0 ships Darwin's spawn-helper without executable permission. */
+export function ensureDarwinSpawnHelperPermissions({ platform = process.platform, arch = process.arch, currentUid = process.getuid?.(), requirePty = createRequire(import.meta.url) } = {}) {
+  if (platform !== "darwin") return false;
+  if (!["x64", "arm64"].includes(arch) || !Number.isSafeInteger(currentUid)) throw new Error("pty_native_helper_unavailable");
+  const manifest = requirePty("node-pty/package.json");
+  if (manifest.name !== "node-pty" || manifest.version !== "1.1.0") throw new Error("pty_native_helper_version");
+  const packageRoot = path.dirname(requirePty.resolve("node-pty/package.json"));
+  const library = path.dirname(requirePty.resolve("node-pty/lib/unixTerminal.js"));
+  const selected = requirePty("node-pty/lib/utils.js").loadNativeModule("pty");
+  const directory = path.resolve(library, selected.dir);
+  const allowed = ["build/Release", "build/Debug", `prebuilds/darwin-${arch}`].flatMap(relative => [path.join(packageRoot, relative), path.join(packageRoot, "lib", relative)]);
+  if (!allowed.includes(directory)) throw new Error("pty_native_helper_path");
+  const filename = path.join(directory, "spawn-helper");
+  let ancestor = path.parse(filename).root;
+  for (const segment of path.dirname(filename).slice(ancestor.length).split(path.sep).filter(Boolean)) {
+    ancestor = path.join(ancestor, segment);
+    const info = lstatSync(ancestor);
+    if (!info.isDirectory() || info.isSymbolicLink() || ![0, currentUid].includes(info.uid) || ((info.mode & 0o022) && !(info.mode & 0o1000))) throw new Error("pty_native_helper_unsafe");
+  }
+  const fd = openSync(filename, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+  try {
+    const before = fstatSync(fd);
+    if (!before.isFile() || before.nlink !== 1 || ![0, currentUid].includes(before.uid) || (before.mode & 0o7022) || before.size < 1 || before.size > 1024 * 1024) throw new Error("pty_native_helper_unsafe");
+    const target = before.mode | ((before.mode & 0o444) >> 2);
+    if (!(target & 0o111)) throw new Error("pty_native_helper_not_executable");
+    if (target === before.mode) return false;
+    if (before.uid !== currentUid) throw new Error("pty_native_helper_not_owned");
+    const bytes = Buffer.alloc(before.size);
+    if (readSync(fd, bytes, 0, bytes.length, 0) !== bytes.length) throw new Error("pty_native_helper_changed");
+    const named = lstatSync(filename);
+    if (named.dev !== before.dev || named.ino !== before.ino || named.isSymbolicLink()) throw new Error("pty_native_helper_changed");
+    fchmodSync(fd, target & 0o777);
+    const after = fstatSync(fd), sameName = lstatSync(filename), sameBytes = Buffer.alloc(before.size);
+    if (after.dev !== before.dev || after.ino !== before.ino || after.uid !== before.uid || after.nlink !== 1 || after.size !== before.size || after.mtimeMs !== before.mtimeMs || after.mode !== target || sameName.dev !== before.dev || sameName.ino !== before.ino || readSync(fd, sameBytes, 0, sameBytes.length, 0) !== sameBytes.length || !bytes.equals(sameBytes)) throw new Error("pty_native_helper_changed");
+    return true;
+  } finally { closeSync(fd); }
+}
+
+function startPtyHost() {
+try { ensureDarwinSpawnHelperPermissions(); }
+catch {
+  process.stderr.write("pty_native_helper_unavailable: use a supported, user-owned node-pty 1.1.0 installation with executable spawn-helper\n");
+  process.exit(78);
+}
+if (process.argv[2] === "--preflight") { process.stdout.write("pty-preflight-ok\n"); return; }
+
+let terminal;
+let initialized = false;
+let terminalExited = false;
+const send = (message) => process.stdout.write(JSON.stringify(message) + "\n");
+const input = readline.createInterface({ input: process.stdin });
+let serial = Promise.resolve();
+input.on("line", (line) => {
+  serial = serial.then(async () => {
+    try {
+      const message = JSON.parse(line);
+      if (!initialized) {
+        if (message.method !== "start") throw new Error("Expected initialization");
+        initialized = true;
+        terminal = pty.spawn(message.argv[0], message.argv.slice(1), {
+          cwd: message.cwd,
+          env: message.env,
+          name: "xterm-256color",
+          cols: message.cols,
+          rows: message.rows,
+          encoding: null,
+        });
+        // node-pty 1.1.x UnixTerminal exposes fd. Fail closed if this pinned native
+        // contract changes; its public write() only enqueues and cannot ACK delivery.
+        if (!Number.isSafeInteger(terminal.fd) || terminal.fd < 0) throw new Error("PTY descriptor unavailable");
+        send({ event: "ready", pid: terminal.pid });
+        terminal.onData((data) => {
+          if (!Buffer.isBuffer(data)) {
+            shutdown();
+            return;
+          }
+          if (!send({ event: "data", data: data.toString("base64") })) terminal.pause();
+        });
+        process.stdout.on("drain", () => {
+          if (!terminalExited) terminal.resume();
+        });
+        terminal.onExit(({ exitCode, signal }) => {
+          terminalExited = true;
+          input.close();
+          process.stdin.destroy();
+          // Flush all queued output and the final event before process exit.
+          process.stdout.end(JSON.stringify({ event: "exit", exitCode, signal }) + "\n", () => process.exit(0));
+        });
+        return;
+      }
+      if (terminalExited) return;
+      try {
+        if (message.method === "write") await writeTerminal(message.data);
+        else if (message.method === "resize") terminal.resize(message.cols, message.rows);
+        else throw new Error("Unknown method");
+        if (!terminalExited) send({ event: "ack", id: message.id });
+      } catch {
+        if (!terminalExited) send({ event: "action-error", id: message.id });
+      }
+    } catch {
+      shutdown();
+    }
+  });
+});
+async function writeTerminal(data) {
+  const buffer = Buffer.from(data, "utf8");
+  let offset = 0;
+  const deadline = Date.now() + 1500;
+  while (offset < buffer.length) {
+    if (terminalExited || Date.now() > deadline) throw new Error("Unknown input outcome");
+    try {
+      offset += await new Promise((resolve, reject) =>
+        write(terminal.fd, buffer, offset, buffer.length - offset, (error, count) => (error ? reject(error) : resolve(count))),
+      );
+    } catch (error) {
+      if (error.code !== "EAGAIN" && error.code !== "EINTR") throw error;
+      await delay(5);
+    }
+  }
+}
+function shutdown() {
+  if (terminal && !terminalExited) {
+    try {
+      process.kill(-terminal.pid, "SIGKILL");
+    } catch {
+      /* Already gone. */
+    }
+    try {
+      terminal.kill("SIGKILL");
+    } catch {
+      /* Already gone. */
+    }
+  }
+  process.exit(1);
+}
+input.on("close", () => {
+  if (!terminalExited) shutdown();
+});
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);
+process.stdout.on("error", shutdown);
+}
+
+if (process.argv[1] && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url))) startPtyHost();

package/dist/mjs/runtime/pty.mjs

@@ -0,0 +1,127 @@
+import { spawn, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { ExecutorError } from "./protocol.mjs";
+const nodeExecutable = typeof R5D_PACKAGED_NODE !== "undefined" && R5D_PACKAGED_NODE ? fileURLToPath(new URL("./bin/node", import.meta.url)) : Bun.which("node") ?? "node";
+function preflightNativePty() {
+  if (process.platform !== "darwin") return;
+  const result = spawnSync(nodeExecutable, [fileURLToPath(new URL("./pty-host.mjs", import.meta.url)), "--preflight"], { encoding: "utf8", timeout: 5e3, env: { PATH: "/usr/local/bin:/usr/bin:/bin" } });
+  if (result.status !== 0 || typeof result.stdout !== "string" || result.stdout.trim() !== "pty-preflight-ok") throw new ExecutorError("pty_native_helper_unavailable", "Native PTY helper is unavailable; use a supported, user-owned node-pty 1.1.0 installation with executable spawn-helper");
+}
+class PtySession {
+  pid = 0;
+  sequence = 0;
+  pending = /* @__PURE__ */ new Map();
+  child;
+  onDataCallback;
+  onExitCallback;
+  buffered = [];
+  exit;
+  ready;
+  constructor(input) {
+    this.child = spawn(nodeExecutable, [fileURLToPath(new URL("./pty-host.mjs", import.meta.url))], {
+      env: { PATH: "/usr/local/bin:/usr/bin:/bin", HOME: input.cwd },
+      stdio: "pipe"
+    });
+    this.ready = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.child.kill("SIGKILL");
+        reject(new ExecutorError("pty_start_timeout"));
+      }, 5e3);
+      let buffer = "";
+      const fail = () => {
+        clearTimeout(timer);
+        reject(new ExecutorError("pty_helper_failed"));
+        for (const pending of this.pending.values()) pending.reject(new ExecutorError("pty_helper_failed"));
+        this.pending.clear();
+        this.deliverExit({ exitCode: -1, signal: 0 });
+      };
+      this.child.on("error", fail);
+      this.child.stdin.on("error", fail);
+      this.child.stdout.setEncoding("utf8");
+      this.child.stdout.on("data", (data) => {
+        buffer += data;
+        if (buffer.length > 1024 * 1024) {
+          this.child.kill("SIGKILL");
+          fail();
+          return;
+        }
+        while (buffer.includes("\n")) {
+          const n = buffer.indexOf("\n");
+          const event = JSON.parse(buffer.slice(0, n));
+          buffer = buffer.slice(n + 1);
+          if (event.event === "ready") {
+            this.pid = event.pid;
+            clearTimeout(timer);
+            resolve();
+          } else if (event.event === "data") {
+            const bytes = Buffer.from(event.data, "base64");
+            if (this.onDataCallback) this.onDataCallback(bytes);
+            else this.buffered.push(bytes);
+          } else if (event.event === "exit") this.deliverExit({ exitCode: event.exitCode, signal: event.signal ?? 0 });
+          else if (event.event === "ack") {
+            this.pending.get(event.id)?.resolve();
+            this.pending.delete(event.id);
+          } else if (event.event === "action-error") {
+            this.pending.get(event.id)?.reject(new ExecutorError("pty_write_unknown"));
+            this.pending.delete(event.id);
+          } else fail();
+        }
+      });
+      this.child.once("close", () => {
+        if (!this.exit) fail();
+      });
+      this.child.stdin.write(JSON.stringify({ method: "start", ...input }) + "\n");
+    });
+  }
+  deliverExit(event) {
+    if (this.exit) return;
+    this.exit = event;
+    this.onExitCallback?.(event);
+  }
+  onData(callback) {
+    this.onDataCallback = callback;
+    for (const data of this.buffered.splice(0)) callback(data);
+  }
+  onExit(callback) {
+    this.onExitCallback = callback;
+    if (this.exit) callback(this.exit);
+  }
+  request(message) {
+    if (this.exit) return Promise.reject(new ExecutorError("pty_exited"));
+    const id = ++this.sequence;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new ExecutorError("pty_write_unknown"));
+      }, 2e3);
+      this.pending.set(id, {
+        resolve: () => {
+          clearTimeout(timer);
+          resolve();
+        },
+        reject: (error) => {
+          clearTimeout(timer);
+          reject(error);
+        }
+      });
+      this.child.stdin.write(JSON.stringify({ id, ...message }) + "\n");
+    });
+  }
+  write(data) {
+    return this.request({ method: "write", data });
+  }
+  resize(cols, rows) {
+    return this.request({ method: "resize", cols, rows });
+  }
+  kill(signal = "SIGTERM") {
+    if (!Number.isSafeInteger(this.pid) || this.pid <= 1 || this.exit) return;
+    try {
+      process.kill(-this.pid, signal);
+    } catch {
+    }
+  }
+}
+export {
+  PtySession,
+  preflightNativePty
+};

package/dist/mjs/runtime/releases/artifacts.mjs

@@ -0,0 +1,201 @@
+import { createHash, randomUUID } from "node:crypto";
+import {
+  chmodSync,
+  closeSync,
+  constants,
+  existsSync,
+  fstatSync,
+  fsyncSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  readdirSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { z } from "zod";
+import { RuntimeHello, RuntimeId } from "@ricsam/r5d-api/runtime-protocol";
+import { ExecutorError } from "../protocol.mjs";
+import { privateDirectory } from "../storage.mjs";
+import { digest } from "./grants.mjs";
+const sha256 = z.string().regex(/^[a-f0-9]{64}$/);
+const memberPath = z.string().min(1).max(512).refine(
+  (path) => path.split("/").every((part) => /^[a-zA-Z0-9_.-]+$/.test(part) && part !== "." && part !== ".."),
+  "Unsafe artifact member"
+);
+const AdapterManifest = z.object({
+  version: z.literal(1),
+  installationId: RuntimeId,
+  workerId: RuntimeId,
+  hello: RuntimeHello,
+  entrypoint: memberPath,
+  files: z.array(
+    z.object({
+      path: memberPath,
+      sha256,
+      size: z.number().int().min(0).max(64 * 1024 * 1024),
+      executable: z.boolean()
+    }).strict()
+  ).min(1).max(4096)
+}).strict().superRefine((manifest, ctx) => {
+  if (manifest.hello.installationId !== manifest.installationId || manifest.hello.role !== "worker-adapter" || new Set(manifest.files.map((file) => file.path)).size !== manifest.files.length || !manifest.files.some((file) => file.path === manifest.entrypoint) || manifest.files.reduce((total, file) => total + file.size, 0) > 256 * 1024 * 1024)
+    ctx.addIssue({ code: "custom", message: "Invalid adapter inventory or identity" });
+});
+const bytesHash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+function within(root, path) {
+  const rel = relative(root, path);
+  return rel === "" || !isAbsolute(rel) && rel !== ".." && !rel.startsWith("../");
+}
+function canonicalDirectory(path) {
+  if (!isAbsolute(path) || resolve(path) !== path) throw new ExecutorError("unsafe_release_path");
+  let cursor = path;
+  while (true) {
+    const stat = lstatSync(cursor);
+    if (!stat.isDirectory() || stat.isSymbolicLink() || (stat.mode & 18) !== 0 && !(stat.mode & 512))
+      throw new ExecutorError("unsafe_release_path");
+    if (cursor === dirname(cursor)) break;
+    cursor = dirname(cursor);
+  }
+  if (realpathSync(path) !== path) throw new ExecutorError("unsafe_release_path");
+  return path;
+}
+function outsideWorkspaces(path, workspaceRoots) {
+  canonicalDirectory(path);
+  for (const root of workspaceRoots) {
+    const workspace = realpathSync(root);
+    if (within(workspace, path) || within(path, workspace)) throw new ExecutorError("release_inside_workspace");
+  }
+}
+function syncDirectory(path) {
+  const fd = openSync(path, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function readMember(path, immutable) {
+  const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const stat = fstatSync(fd);
+    if (!stat.isFile() || stat.nlink !== 1 || stat.uid !== process.getuid?.() || stat.size > 64 * 1024 * 1024 || stat.mode & (immutable ? 191 : 18))
+      throw new ExecutorError("unsafe_artifact_member");
+    return readFileSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function inventory(root, immutable) {
+  const files = [];
+  let entries = 0;
+  function walk(dir) {
+    const directory = lstatSync(dir);
+    if (immutable && (directory.uid !== process.getuid?.() || (directory.mode & 511) !== 320))
+      throw new ExecutorError("artifact_mode_mismatch");
+    if (++entries > 8192) throw new ExecutorError("artifact_inventory_mismatch");
+    if (files.length > 4096) throw new ExecutorError("artifact_inventory_mismatch");
+    for (const name of readdirSync(dir)) {
+      const path = join(dir, name), stat = lstatSync(path);
+      if (stat.isSymbolicLink() || !stat.isDirectory() && !stat.isFile()) throw new ExecutorError("unsafe_artifact_member");
+      if (stat.isDirectory()) {
+        canonicalDirectory(path);
+        walk(path);
+      } else files.push(relative(root, path));
+    }
+  }
+  walk(root);
+  return files.sort();
+}
+function verifyTree(root, manifest, immutable) {
+  canonicalDirectory(root);
+  if (JSON.stringify(inventory(root, immutable)) !== JSON.stringify(manifest.files.map((file) => file.path).sort()))
+    throw new ExecutorError("artifact_inventory_mismatch");
+  for (const file of manifest.files) {
+    const bytes = readMember(join(root, file.path), immutable);
+    if (bytes.length !== file.size || bytesHash(bytes) !== file.sha256) throw new ExecutorError("artifact_digest_mismatch");
+    if (immutable && (lstatSync(join(root, file.path)).mode & 511) !== (file.executable ? 320 : 256))
+      throw new ExecutorError("artifact_mode_mismatch");
+  }
+}
+class ImmutableAdapterArtifacts {
+  constructor(root, installationId, workerId, workspaceRoots) {
+    this.root = root;
+    this.installationId = installationId;
+    this.workerId = workerId;
+    this.workspaceRoots = workspaceRoots;
+    privateDirectory(root);
+    outsideWorkspaces(root, workspaceRoots);
+  }
+  root;
+  installationId;
+  workerId;
+  workspaceRoots;
+  approved(input, approvalDigest) {
+    const manifest = AdapterManifest.parse(input);
+    if (manifest.installationId !== this.installationId || manifest.workerId !== this.workerId) throw new ExecutorError("wrong_resource");
+    if (digest(manifest) !== sha256.parse(approvalDigest)) throw new ExecutorError("unapproved_artifact");
+    return manifest;
+  }
+  stage(source, input, approvalDigest) {
+    const manifest = this.approved(input, approvalDigest);
+    outsideWorkspaces(source, this.workspaceRoots);
+    verifyTree(source, manifest, false);
+    const destination = join(this.root, approvalDigest);
+    if (existsSync(destination)) return this.verify(manifest, approvalDigest);
+    const temporary = join(this.root, `.staging-${randomUUID()}`);
+    privateDirectory(temporary);
+    try {
+      for (const file of manifest.files) {
+        const target = join(temporary, file.path);
+        mkdirSync(dirname(target), { recursive: true, mode: 448 });
+        const bytes = readMember(join(source, file.path), false);
+        if (bytes.length !== file.size || bytesHash(bytes) !== file.sha256) throw new ExecutorError("artifact_digest_mismatch");
+        const fd = openSync(target, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+        try {
+          writeFileSync(fd, bytes);
+          fsyncSync(fd);
+        } finally {
+          closeSync(fd);
+        }
+        chmodSync(target, file.executable ? 320 : 256);
+      }
+      const seal = (dir) => {
+        for (const name of readdirSync(dir)) if (lstatSync(join(dir, name)).isDirectory()) seal(join(dir, name));
+        chmodSync(dir, 320);
+        syncDirectory(dir);
+      };
+      seal(temporary);
+      verifyTree(temporary, manifest, true);
+      renameSync(temporary, destination);
+      syncDirectory(this.root);
+      return destination;
+    } catch (error) {
+      if (existsSync(temporary)) {
+        const unseal = (dir) => {
+          chmodSync(dir, 448);
+          for (const name of readdirSync(dir)) if (lstatSync(join(dir, name)).isDirectory()) unseal(join(dir, name));
+        };
+        unseal(temporary);
+        rmSync(temporary, { recursive: true });
+      }
+      throw error;
+    }
+  }
+  verify(input, approvalDigest) {
+    const manifest = this.approved(input, approvalDigest), path = join(this.root, approvalDigest);
+    verifyTree(path, manifest, true);
+    return path;
+  }
+}
+export {
+  AdapterManifest,
+  ImmutableAdapterArtifacts,
+  bytesHash,
+  canonicalDirectory,
+  outsideWorkspaces,
+  within
+};

package/dist/mjs/runtime/releases/grants.mjs

@@ -0,0 +1,93 @@
+import { createHash } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { isAbsolute, relative } from "node:path";
+import { canonicalJson, negotiateProtocol } from "@ricsam/r5d-api/runtime-protocol";
+import {
+  AdapterGrant,
+  ExecutorError,
+  EXECUTOR_CAPABILITY
+} from "../protocol.mjs";
+const digest = (value) => createHash("sha256").update(canonicalJson(value)).digest("hex");
+class AdapterGrantRegistry {
+  constructor(db, config) {
+    this.db = db;
+    this.config = config;
+    db.exec(`CREATE TABLE IF NOT EXISTS adapter_grants (
+      id TEXT PRIMARY KEY, owner TEXT NOT NULL UNIQUE, release TEXT NOT NULL UNIQUE,
+      grant_json TEXT NOT NULL, digest TEXT NOT NULL, state TEXT NOT NULL CHECK(state IN ('registered','retired')))`);
+    for (const row of this.rows()) {
+      const grant = AdapterGrant.parse(JSON.parse(row.grant_json));
+      if (digest(grant) !== row.digest || grant.installationId !== config.installationId || grant.workerId !== config.workerId || config.principals.some((p) => p.id === grant.principal.id || p.ownerId === grant.principal.ownerId))
+        throw new ExecutorError("grant_store_conflict");
+    }
+  }
+  db;
+  config;
+  rows() {
+    return this.db.query("SELECT * FROM adapter_grants").all();
+  }
+  find(id) {
+    const row = this.rows().find((row2) => row2.id === id && row2.state === "registered");
+    return row ? AdapterGrant.parse(JSON.parse(row.grant_json)) : void 0;
+  }
+  hasOwner(owner) {
+    return this.rows().some(
+      (row) => row.state === "registered" && AdapterGrant.parse(JSON.parse(row.grant_json)).principal.ownerId === owner
+    );
+  }
+  list() {
+    return this.rows().map((row) => {
+      const grant = AdapterGrant.parse(JSON.parse(row.grant_json));
+      return {
+        principalId: row.id,
+        ownerId: grant.principal.ownerId,
+        releaseId: grant.hello.releaseId,
+        artifactDigest: grant.artifactDigest,
+        grantDigest: row.digest,
+        state: row.state
+      };
+    });
+  }
+  register(controller, input, keeperHello) {
+    if (controller.role !== "controller") throw new ExecutorError("forbidden");
+    const grant = AdapterGrant.parse(input), p = grant.principal;
+    if (grant.installationId !== this.config.installationId || grant.workerId !== this.config.workerId)
+      throw new ExecutorError("wrong_resource");
+    negotiateProtocol(keeperHello, grant.hello, [EXECUTOR_CAPABILITY]);
+    if (grant.hello.role !== "worker-adapter" || grant.hello.instanceId !== p.ownerId) throw new ExecutorError("wrong_principal");
+    if (p.userIds.some((id) => !controller.userIds.includes(id)) || p.lanes.some((lane) => !controller.lanes.includes(lane)) || p.credentialIds.some((id) => !controller.credentialIds.includes(id)) || p.cwdRoots.some(
+      (root) => !controller.cwdRoots.some((allowed) => {
+        const rel = relative(realpathSync(allowed), realpathSync(root));
+        return rel === "" || !isAbsolute(rel) && rel !== ".." && !rel.startsWith("../");
+      })
+    ))
+      throw new ExecutorError("grant_scope_exceeded");
+    const hash = digest(grant), rows = this.rows(), old = rows.find((row) => row.id === p.id);
+    if (old) {
+      if (old.digest !== hash) throw new ExecutorError("grant_identity_conflict");
+      if (old.state === "retired") throw new ExecutorError("adapter_retired");
+      return this.list().find((r) => r.principalId === p.id);
+    }
+    if (this.config.principals.some((s) => s.id === p.id || s.ownerId === p.ownerId) || rows.some((row) => {
+      const prior = AdapterGrant.parse(JSON.parse(row.grant_json));
+      return prior.principal.ownerId === p.ownerId || prior.hello.releaseId === grant.hello.releaseId;
+    }))
+      throw new ExecutorError("grant_identity_conflict");
+    if (rows.filter((row) => row.state === "registered").length + this.config.principals.filter((p2) => p2.role === "adapter").length >= 2)
+      throw new ExecutorError("adapter_retention_blocked");
+    this.db.query("INSERT INTO adapter_grants VALUES (?,?,?,?,?,'registered')").run(p.id, p.ownerId, grant.hello.releaseId, canonicalJson(grant), hash);
+    return this.list().find((r) => r.principalId === p.id);
+  }
+  retire(controller, id, authoritativeOwner) {
+    if (controller.role !== "controller") throw new ExecutorError("forbidden");
+    const row = this.list().find((row2) => row2.principalId === id);
+    if (!row) throw new ExecutorError("adapter_not_found");
+    if (row.ownerId === authoritativeOwner) throw new ExecutorError("adapter_is_authority");
+    this.db.query("UPDATE adapter_grants SET state='retired' WHERE id=?").run(id);
+    return { ...row, state: "retired" };
+  }
+}
+export {
+  AdapterGrantRegistry,
+  digest
+};

package/dist/mjs/runtime/releases/main.mjs

@@ -0,0 +1,101 @@
+import { z } from "zod";
+import { OwnershipFence, RuntimeId } from "@ricsam/r5d-api/runtime-protocol";
+import { AdapterConfig, AdapterGrant, ExecutorCommand, ExecutorError, MAX_FRAME_BYTES } from "../protocol.mjs";
+import { readPrivateJson } from "../storage.mjs";
+import { AdapterManifest } from "./artifacts.mjs";
+import { ReleaseManagerConfig, WorkerAdapterReleases } from "./manager.mjs";
+const Command = z.discriminatedUnion("method", [
+  z.object({ method: z.literal("status") }).strict(),
+  z.object({
+    method: z.literal("stage"),
+    source: z.string(),
+    manifest: AdapterManifest,
+    approvalDigest: z.string(),
+    grant: AdapterGrant,
+    adapter: AdapterConfig
+  }).strict(),
+  z.object({ method: z.literal("launch"), principalId: RuntimeId }).strict(),
+  z.object({ method: z.literal("stop-adapter"), principalId: RuntimeId }).strict(),
+  z.object({ method: z.literal("promote"), principalId: RuntimeId, fence: OwnershipFence, validUntil: z.number().int().positive() }).strict(),
+  z.object({ method: z.literal("retire"), principalId: RuntimeId }).strict(),
+  z.object({ method: z.literal("request"), callId: RuntimeId, principalId: RuntimeId, command: ExecutorCommand }).strict(),
+  z.object({ method: z.literal("reconcile-call"), callId: RuntimeId, principalId: RuntimeId, command: ExecutorCommand }).strict(),
+  z.object({ method: z.literal("acknowledge"), callId: RuntimeId }).strict(),
+  z.object({ method: z.literal("reconcile") }).strict()
+]);
+if (import.meta.main) {
+  const path = process.argv[2];
+  if (!path || process.argv.length !== 3) throw new Error("Usage: bun releases/main.ts /absolute/private/release-manager.json");
+  const manager = new WorkerAdapterReleases(ReleaseManagerConfig.parse(readPrivateJson(path)));
+  let buffer = Buffer.alloc(0), tail = Promise.resolve(), stopping = false;
+  async function handle(line) {
+    let id;
+    try {
+      const message = z.object({ id: RuntimeId, command: Command }).strict().parse(JSON.parse(line.toString("utf8")));
+      id = message.id;
+      const command = message.command;
+      let result;
+      switch (command.method) {
+        case "status":
+          result = { releases: manager.list(), calls: manager.calls(), transitions: manager.transitions() };
+          break;
+        case "stage":
+          result = await manager.stage(command);
+          break;
+        case "launch":
+          result = await manager.launch(command.principalId);
+          break;
+        case "stop-adapter":
+          result = await manager.stopAdapter(command.principalId);
+          break;
+        case "promote":
+          result = await manager.promote(command.principalId, command.fence, command.validUntil);
+          break;
+        case "retire":
+          result = await manager.retire(command.principalId);
+          break;
+        case "request":
+          result = await manager.request(command.callId, command.principalId, command.command);
+          break;
+        case "reconcile-call":
+          result = await manager.reconcileCall(command.callId, command.principalId, command.command);
+          break;
+        case "acknowledge":
+          result = await manager.acknowledge(command.callId);
+          break;
+        case "reconcile":
+          result = await manager.reconcile();
+          break;
+      }
+      process.stdout.write(JSON.stringify({ id, ok: true, result: result ?? null }) + "\n");
+    } catch (error) {
+      process.stdout.write(
+        JSON.stringify({ id, ok: false, error: { code: error instanceof ExecutorError ? error.code : "invalid_request" } }) + "\n"
+      );
+    }
+  }
+  const stop = () => {
+    if (stopping) return;
+    stopping = true;
+    void tail.then(() => manager.close()).then(
+      () => process.exit(0),
+      () => process.exit(1)
+    );
+  };
+  process.stdin.on("data", (chunk) => {
+    if (stopping) return;
+    buffer = Buffer.concat([buffer, chunk]);
+    if (buffer.length > MAX_FRAME_BYTES) {
+      stop();
+      return;
+    }
+    while (buffer.includes(10)) {
+      const end = buffer.indexOf(10), line = buffer.subarray(0, end);
+      buffer = buffer.subarray(end + 1);
+      tail = tail.then(() => handle(line));
+    }
+  });
+  process.stdin.once("end", stop);
+  process.on("SIGTERM", stop);
+  process.on("SIGINT", stop);
+}