@ours.network/codex 1.1.1 → 1.2.0-nightly.10

package/dist/network-watch.mjs

@@ -0,0 +1,287 @@
+// src/network-watch.mjs
+import { homedir } from "node:os";
+import { dirname as dirname2, join as join3 } from "node:path";
+
+// ../core/src/host-profile.ts
+import { readGatewayClientProfile, validateGatewayClientProfile } from "@ours.network/sdk/client";
+var validateHostProfile = validateGatewayClientProfile;
+function hostProfileSelectionFromEnv(env = process.env) {
+  const { configPath, ...profile } = readGatewayClientProfile(env);
+  return { profile, configPath };
+}
+function hostProfileFromEnv(env = process.env) {
+  return hostProfileSelectionFromEnv(env).profile;
+}
+
+// ../core/src/native-session.ts
+import { createHash as createHash2, randomUUID } from "node:crypto";
+import { chmod, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { dirname, join as join2, resolve } from "node:path";
+import { attachOursClient } from "@ours.network/sdk";
+
+// ../core/src/session-guard.ts
+import { createHash } from "node:crypto";
+import { openSync, closeSync, lstatSync, mkdirSync, chmodSync, constants } from "node:fs";
+import { join } from "node:path";
+import { createRequire } from "node:module";
+var BUSY_TIMEOUT_MS = 5e3;
+var DatabaseSync = null;
+var resolveAttempted = false;
+function resolveDatabase() {
+  if (DatabaseSync) return DatabaseSync;
+  if (resolveAttempted) throw new Error("No SQLite implementation available for native session guard");
+  resolveAttempted = true;
+  try {
+    const mod = createRequire(import.meta.url)("node:sqlite");
+    DatabaseSync = mod.DatabaseSync;
+    return DatabaseSync;
+  } catch {
+    try {
+      const mod = createRequire(import.meta.url)("better-sqlite3");
+      DatabaseSync = mod.default ?? mod;
+      return DatabaseSync;
+    } catch {
+      throw new Error("Native session guard requires node:sqlite (Node >=22.13) or better-sqlite3");
+    }
+  }
+}
+function ensureGuardFile(guardPath) {
+  try {
+    const fd = openSync(guardPath, constants.O_RDWR | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+    closeSync(fd);
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  }
+  const stat = lstatSync(guardPath);
+  if (!stat.isFile() || stat.uid !== process.getuid() || (stat.mode & 63) !== 0 || stat.nlink !== 1) {
+    throw new Error("Native session guard file must be an owner-only regular file");
+  }
+}
+function acquireSessionGuard(recordPath) {
+  const uid = process.getuid();
+  const base = join(`/tmp/ours-${uid}`, "session-guards");
+  mkdirSync(base, { recursive: true, mode: 448 });
+  try {
+    chmodSync(base, 448);
+  } catch {
+  }
+  const hash = createHash("sha256").update(recordPath).digest("hex");
+  const guardPath = join(base, `${hash}.guard`);
+  ensureGuardFile(guardPath);
+  const before = lstatSync(guardPath);
+  const Database = resolveDatabase();
+  const db = new Database(guardPath);
+  try {
+    const after = lstatSync(guardPath);
+    if (before.dev !== after.dev || before.ino !== after.ino || before.mode !== after.mode || before.uid !== after.uid) {
+      throw new Error("Native session guard file changed during acquisition");
+    }
+    db.exec(`PRAGMA busy_timeout=${BUSY_TIMEOUT_MS}; BEGIN EXCLUSIVE`);
+    return () => {
+      try {
+        db.close();
+      } catch {
+      }
+    };
+  } catch (error) {
+    try {
+      db.close();
+    } catch {
+    }
+    throw error;
+  }
+}
+
+// ../core/src/native-session.ts
+var RECORD_VERSION = 1;
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+var clients = /* @__PURE__ */ new Map();
+var operations = /* @__PURE__ */ new Map();
+function selector(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > 4096 || value.trim() !== value || value.includes("\0")) {
+    throw new Error("Native session metadata is missing or invalid for this host-profile tool call.");
+  }
+  return value;
+}
+function nativeSessionRecordPath(hostRecordRoot, instanceId, nativeSessionId) {
+  if (!hostRecordRoot || !hostRecordRoot.startsWith("/") || resolve(hostRecordRoot) !== hostRecordRoot) {
+    throw new Error("Native session host record root must be a normalized absolute path.");
+  }
+  if (!UUID.test(instanceId)) throw new Error("Native session daemon instance must be a lowercase UUID.");
+  const hash = createHash2("sha256").update(selector(nativeSessionId), "utf8").digest("hex");
+  return join2(hostRecordRoot, "sessions", instanceId, `${hash}.json`);
+}
+function parseRecord(text, path) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`Invalid native session record at ${path}: ${String(error)}`);
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Invalid native session record at ${path}: expected an object.`);
+  }
+  const record = value;
+  const keys = Object.keys(record).sort();
+  if (keys.join(",") !== "ownerInstanceId,state,version" || record.version !== RECORD_VERSION || typeof record.ownerInstanceId !== "string" || !UUID.test(record.ownerInstanceId) || !["active", "pending", "ended"].includes(String(record.state))) {
+    throw new Error(`Invalid native session record at ${path}.`);
+  }
+  return record;
+}
+async function readRecord(path) {
+  try {
+    return parseRecord(await readFile(path, "utf8"), path);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+async function writeRecord(path, record) {
+  const parent = dirname(path);
+  await mkdir(parent, { recursive: true, mode: 448 });
+  await chmod(parent, 448);
+  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, `${JSON.stringify(record, null, 2)}
+`, { mode: 384, flag: "wx" });
+    await rename(temporary, path);
+    await chmod(path, 384);
+  } catch (error) {
+    try {
+      await unlink(temporary);
+    } catch {
+    }
+    throw error;
+  }
+}
+async function serialized(key, operation) {
+  const predecessor = operations.get(key) ?? Promise.resolve();
+  let release;
+  const gate = new Promise((resolve2) => {
+    release = resolve2;
+  });
+  const tail = predecessor.catch(() => {
+  }).then(() => gate);
+  operations.set(key, tail);
+  await predecessor.catch(() => {
+  });
+  let releaseGuard;
+  try {
+    releaseGuard = acquireSessionGuard(key);
+    return await operation();
+  } finally {
+    try {
+      releaseGuard?.();
+    } finally {
+      release();
+      if (operations.get(key) === tail) operations.delete(key);
+    }
+  }
+}
+function attach(profile, ownerInstanceId) {
+  return attachOursClient({
+    endpoint: profile.endpoint,
+    expectedInstanceId: profile.expectedInstanceId,
+    credentialPath: profile.credentialPath,
+    sessionMode: "external",
+    leaseToken: ownerInstanceId,
+    env: {}
+  });
+}
+function cachedClient(path, profile, ownerInstanceId) {
+  const cached = clients.get(path);
+  if (cached?.ownerInstanceId === ownerInstanceId) return cached.promise;
+  if (cached) {
+    clients.delete(path);
+    void cached.promise.then((client) => client.close()).catch(() => {
+    });
+  }
+  const promise = attach(profile, ownerInstanceId);
+  const next = { ownerInstanceId, promise };
+  clients.set(path, next);
+  void promise.catch(() => {
+    if (clients.get(path) === next) clients.delete(path);
+  });
+  return promise;
+}
+async function releaseOwner(path, profile, ownerInstanceId) {
+  const cached = clients.get(path);
+  const client = cached?.ownerInstanceId === ownerInstanceId ? await cached.promise : await attach(profile, ownerInstanceId);
+  try {
+    await client.releaseLease();
+  } finally {
+    if (cached?.ownerInstanceId !== ownerInstanceId) await client.close();
+  }
+}
+async function finishPending(path, profile, ownerInstanceId) {
+  await releaseOwner(path, profile, ownerInstanceId);
+  const current = await readRecord(path);
+  if (current?.state === "pending" && current.ownerInstanceId === ownerInstanceId) {
+    await writeRecord(path, { version: RECORD_VERSION, ownerInstanceId, state: "ended" });
+  }
+  const cached = clients.get(path);
+  if (cached?.ownerInstanceId === ownerInstanceId) {
+    clients.delete(path);
+    void cached.promise.then((client) => client.close()).catch(() => {
+    });
+  }
+}
+async function nativeClientForAtRoot(profileValue, nativeSessionId, hostRecordRoot) {
+  const profile = validateHostProfile(profileValue);
+  const path = nativeSessionRecordPath(hostRecordRoot, profile.expectedInstanceId, nativeSessionId);
+  return serialized(path, async () => {
+    let record = await readRecord(path);
+    if (record?.state === "pending") {
+      await finishPending(path, profile, record.ownerInstanceId);
+      record = await readRecord(path);
+    }
+    if (record?.state === "active") return cachedClient(path, profile, record.ownerInstanceId);
+    const ownerInstanceId = randomUUID();
+    await writeRecord(path, { version: RECORD_VERSION, ownerInstanceId, state: "active" });
+    return cachedClient(path, profile, ownerInstanceId);
+  });
+}
+
+// src/network-watch.mjs
+async function runNetworkWatch({
+  identity,
+  nativeSessionId,
+  env = process.env,
+  profile: profileValue,
+  hostRecordRoot: hostRecordRootValue,
+  clientFor = nativeClientForAtRoot,
+  write = (value) => process.stdout.write(value),
+  installSignalHandlers = true
+} = {}) {
+  if (typeof identity !== "string" || !identity.trim()) throw new Error("identity is required");
+  if (typeof nativeSessionId !== "string" || !nativeSessionId.trim()) throw new Error("native session id is required");
+  const profile = profileValue ?? hostProfileFromEnv(env);
+  if (!profile) throw new Error("A selected host network profile is required.");
+  const appPath = env.OURS_MCP_CONFIG || join3(env.HOME || homedir(), ".ours-mcp", "config.json");
+  const hostRecordRoot = hostRecordRootValue ?? dirname2(appPath);
+  const controller = new AbortController();
+  const stop = () => controller.abort();
+  if (installSignalHandlers) {
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  }
+  let client;
+  try {
+    client = await clientFor(profile, nativeSessionId, hostRecordRoot);
+    for await (const event of client.watchNotifications(identity, { kinds: ["inbound"], signal: controller.signal })) {
+      const summary = event?.event === "file_received" ? `[${identity}] new file ${event.filename ?? "?"} from ${event.from ?? "?"}` : `[${identity}] new message from ${event?.from ?? "?"}`;
+      write(`${summary}
+`);
+      return;
+    }
+  } finally {
+    if (installSignalHandlers) {
+      process.off("SIGINT", stop);
+      process.off("SIGTERM", stop);
+    }
+    await client?.close();
+  }
+}
+export {
+  runNetworkWatch
+};

package/dist/profile.mjs

@@ -0,0 +1,56 @@
+// src/profile.mjs
+import { randomUUID } from "node:crypto";
+import { attachOursClient as attachOursClient2 } from "@ours.network/sdk";
+
+// ../core/src/host-profile.ts
+import { readGatewayClientProfile, validateGatewayClientProfile } from "@ours.network/sdk/client";
+function hostProfileSelectionFromEnv(env = process.env) {
+  const { configPath, ...profile } = readGatewayClientProfile(env);
+  return { profile, configPath };
+}
+
+// ../core/src/native-session.ts
+import { attachOursClient } from "@ours.network/sdk";
+
+// src/profile.mjs
+function validPort(value) {
+  const port = Number(value);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error(`ours: ${value} is not a valid TCP port`);
+  return port;
+}
+function parseOursArgs(argv = []) {
+  const codexArgs = [];
+  let port;
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--ours-port") {
+      if (argv[index + 1] == null) throw new Error("ours: --ours-port requires a value");
+      port = validPort(argv[++index]);
+    } else if (arg.startsWith("--ours-port=")) {
+      port = validPort(arg.slice("--ours-port=".length));
+    } else {
+      codexArgs.push(arg);
+    }
+  }
+  return { port, codexArgs };
+}
+async function resolveDaemonProfile({ argv = [], env = process.env, fetch: fetchImpl = globalThis.fetch, attach = attachOursClient2 } = {}) {
+  const parsed = parseOursArgs(argv);
+  const hostSelection = hostProfileSelectionFromEnv(env);
+  const { profile: hostProfile, configPath } = hostSelection;
+  if (parsed.port != null) throw new Error("ours: --ours-port conflicts with host-profile mode");
+  const client = await attach({ ...hostProfile, sessionMode: "external", leaseToken: randomUUID(), env: {} });
+  let info;
+  try {
+    info = await client.version();
+    await client.identities();
+    await client.unread();
+  } finally {
+    await client.close();
+  }
+  return { profile: hostProfile, info, baseUrl: hostProfile.endpoint, configPath, codexArgs: parsed.codexArgs };
+}
+export {
+  parseOursArgs,
+  resolveDaemonProfile
+};

package/hooks/hooks.json

@@ -6,7 +6,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"${PLUGIN_ROOT}/src/hooks/runner.mjs\"",
+            "command": "node \"${PLUGIN_ROOT}/dist/hooks-runner.mjs\"",
             "timeout": 5,
             "statusMessage": "Checking ours mail metadata"
           }
@@ -18,7 +18,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"${PLUGIN_ROOT}/src/hooks/runner.mjs\"",
+            "command": "node \"${PLUGIN_ROOT}/dist/hooks-runner.mjs\"",
             "timeout": 3
           }
         ]
@@ -30,7 +30,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"${PLUGIN_ROOT}/src/hooks/runner.mjs\"",
+            "command": "node \"${PLUGIN_ROOT}/dist/hooks-runner.mjs\"",
             "timeout": 3
           }
         ]

package/install.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # Install the native ours.network plugin into the OpenAI Codex CLI:
-#   1. ensure the ours operator CLI and MCP adapter are installed; start the shared daemon
+#   1. verify the installed gateway client profile before modifying plugin configuration
 #   2. add/upgrade adapt-toolkit/ours-codex-marketplace
 #   3. install the native `ours` plugin (skills, MCP servers, and hooks)
 #   4. back up and remove installer-owned legacy config only after verification
@@ -10,7 +10,6 @@
 #   SKILLS_DIR                 skills root                (default ~/.agents/skills)
 #   CODEX_CONFIG               config.toml path           (default $CODEX_DIR/config.toml)
 #   CODEX_AGENTS               AGENTS.md path             (default $CODEX_DIR/AGENTS.md)
-#   OURS_INSTALL_SKIP_DAEMON=1 skip daemon install/start
 set -euo pipefail
 
 SELFDIR="$(cd "$(dirname "$0")" && pwd)"
@@ -21,33 +20,21 @@ SKILLS_DIR="${SKILLS_DIR:-$HOME/.agents/skills}"
 
 say(){ printf 'ours-install: %s\n' "$1"; }
 
-# Ensure the ours daemon is on @latest (UPGRADE, not install-if-missing): an already-present
-# daemon must still be pulled up to the newest published version. Record the CLI version
-# before/after; start if not running, restart only if the version actually changed.
-ensure_daemon_latest(){
-  if [ "${OURS_INSTALL_SKIP_DAEMON:-}" = "1" ]; then say "skipping daemon step (OURS_INSTALL_SKIP_DAEMON=1)"; return 0; fi
-  local before after
-  before="$(ours version 2>/dev/null | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' | head -1 || true)"
-  say "ensuring @ours.network/cli@latest and @ours.network/mcp@latest…"
-  npm i -g @ours.network/cli@latest @ours.network/mcp@latest
-  after="$(ours version 2>/dev/null | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' | head -1 || true)"
-  if ! ours daemon status >/dev/null 2>&1; then
-    say "starting the ours daemon…"
-    if ! ours daemon start; then say "could not start the ours daemon; installation stopped."; return 1; fi
-  elif [ -n "$before" ] && [ "$before" != "$after" ]; then
-    say "operator CLI upgraded (v${before} → v${after}) — restarting its daemon…"
-    if ! ours daemon restart; then
-      say "restart failed; trying a clean start…"
-      if ! ours daemon start; then say "could not restart or start the upgraded daemon; installation stopped."; return 1; fi
-    fi
-  else
-    say "daemon already current (v${after:-unknown})."
+# Client installation never installs, starts or restarts server services.
+require_gateway_client(){
+  if ! command -v ours >/dev/null 2>&1 || ! command -v ours-mcp >/dev/null 2>&1; then
+    say "Install gateway clients with ours-install client first; ours and ours-mcp are required."
+    return 1
+  fi
+  local contract
+  if ! contract="$(ours-mcp verify-client-profile)" || [ "$contract" != "ours.gateway-client-profile-v1" ]; then
+    say "Configure the shared gateway profile with ours-install client first; plugin setup was left unchanged."
+    return 1
   fi
-  say "operator CLI: $(command -v ours) (v${after:-unknown}); MCP adapter: $(command -v ours-mcp)"
 }
 
-# --- 1) daemon (ensure @latest + restart on change) ---
-ensure_daemon_latest
+# --- 1) shared gateway client preflight ---
+require_gateway_client
 
 # --- native Codex plugin ------------------------------------------------------
 # Codex owns the plugin cache and hook-trust workflow. Only remove the legacy
@@ -73,7 +60,7 @@ if [ "${OURS_CODEX_SKIP_NATIVE:-}" != "1" ]; then
   CODEX_DIR="$CODEX_DIR" SKILLS_DIR="$SKILLS_DIR" node "$SELFDIR/bin/codex-legacy-cleanup.mjs"
   say "native plugin installed. Review and trust its hooks in Codex, then start a new thread."
   say "standard mode: codex"
-  say "live mode:     ours-codex${OURS_PORT:+ --ours-port $OURS_PORT}"
+  say "live mode:     ours-codex"
   exit 0
 fi
 
@@ -93,11 +80,5 @@ CODEX_CONFIG="$CODEX_CONFIG" node "$SELFDIR/bin/codex-config-install.mjs"
 CODEX_AGENTS="$CODEX_AGENTS" node "$SELFDIR/bin/codex-agents-install.mjs"
 
 say "done. The ours MCP server + skill are live for the next Codex session."
-# --- version echo: show the user they are on latest ---
-if [ "${OURS_INSTALL_SKIP_DAEMON:-}" != "1" ]; then
-  say "versions:"
-  say "  MCP adapter: $(ours-mcp --version 2>/dev/null | head -1 || echo 'unknown')"
-  say "  plugin: $(npm ls -g @ours.network/codex 2>/dev/null | grep -oE '@ours\.network/codex@[0-9][0-9.]*' | head -1 || echo '@ours.network/codex (not a global install)')"
-fi
 say "next: bind (or create) an identity, then the ours skill tails ours-mcp watch (or polls"
 say "      get_messages) in-session so you react to new mail while you work."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/codex",
-  "version": "1.1.1",
+  "version": "1.2.0-nightly.10",
   "description": "Native Codex plugin for secure ours.network messaging and explicitly armed, session-scoped live mail wake.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",
@@ -46,10 +46,10 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@ours.network/mcp": "1.1.1",
-    "@ours.network/sdk": "3.7.0",
+    "@ours.network/sdk": "3.8.1-nightly.15",
     "ws": "^8.21.0",
-    "zod": "^3.25.76"
+    "zod": "^3.25.76",
+    "@ours.network/mcp": "1.2.0-nightly.10"
   },
   "devDependencies": {
     "esbuild": "^0.24.2"
@@ -58,7 +58,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "esbuild src/monitor-mcp.mjs --bundle --platform=node --format=esm --external:@ours.network/mcp --outfile=dist/monitor-mcp.mjs",
+    "build": "node build.mjs",
     "prepack": "npm run build",
     "install-plugin": "bash install.sh",
     "test": "node --test"

package/skills/ours/SKILL.md

@@ -108,12 +108,12 @@ existing file.
    **control-plane monitoring proxy is not available in this release** — there is no tool
    to call. See "Control plane" below.
 
-- **Configuration.** Port, state dir, broker, and GC interval are configurable.
-  More than one daemon may run when each uses a distinct port and state directory.
-  Select live mode with `ours-codex --ours-port <port>` or `OURS_CONFIG`. Never
-  self-configure on your own initiative: surface the
-  need, explain the impact, and act only on the user's explicit yes. Details:
-  `references/configuration.md`.
+- **Configuration.** Every client selects the HTTP gateway through
+  `~/.ours-client/profile.json` (or the whole-profile `OURS_CONFIG` override).
+  `serverUrl` is the base URL; daemon and Cowork use `/daemon` and `/cowork`
+  beneath it. Import the issued credential with `ours-install client`.
+  Local daemon ports, state directories, and Unix sockets are not client routes.
+  Missing or invalid configuration fails closed. See `references/configuration.md`.
 
 ## ours-fleet — persistent harness roles
 
@@ -448,6 +448,7 @@ feature and still works; it is described above.
   watcher for exactly one TUI session. The launcher observes that session's thread
   directly; monitor MCP tools carry explicit arm/disarm consent, while trusted hooks add
   defensive identity-state synchronization. Standard `codex` falls back, after separate
-  consent, to a foreground `ours-mcp watch` call that returns on the next body-free event.
+  consent, to a package-local authenticated network watch that returns on the next
+  body-free event.
   Authenticated daemon notification endpoints remain body-free. Message text is returned
   only by the explicit unread-drain and history tools.

package/skills/ours/references/configuration.md

@@ -1,26 +1,24 @@
-# ours daemon configuration
+# Shared gateway client configuration
 
-ours-mcp is a client of one already-running shared daemon. The operator CLI owns
-configuration and lifecycle:
+Fleet, ours CLI, MCP and harness hooks select one server through
+`~/.ours-client/profile.json`. `serverUrl` names the HTTP(S) gateway, with
+optional base path. Daemon operations use `/daemon`; Cowork uses `/cowork`.
+The profile also pins `expectedInstanceId` and an absolute `credentialPath`.
+An optional `endpoint` must equal `serverUrl + "/daemon"`.
 
-```sh
-ours config show --json
-ours config setup --port 3050 --state-dir "$HOME/.ours"
-ours daemon start
-ours daemon status --json
-```
+Import a prepared private profile with `ours-install client --config /absolute/profile.json`.
+Use `ours config show --json` to inspect connection metadata without reading the token.
+Keep the profile directory mode 0700 and files mode 0600. `OURS_CONFIG` may
+select the same whole profile for all clients. Remove legacy `OURS_PORT`,
+`OURS_STATE_DIR`, `OURS_API_TOKEN` and `OURS_DAEMON_ID` overrides.
 
-The MCP adapter and `ours-codex` use the published SDK's coherent selection. The
-wholly default selection is port 3050 with state directory `~/.ours`. For another
-daemon, set `OURS_CONFIG`, or set matching `OURS_PORT` and `OURS_STATE_DIR`. A
-token or endpoint selection must be paired with its state directory. `/state-dir`
-is verified before credentials are sent.
+Missing profiles, rejected credentials and unavailable gateways fail closed.
+Clients never read daemon state, start a daemon, or try a local port/socket.
+Hooks use the same gateway and return a harmless no-op on failure. Their
+application-local identity/session files do not select another server.
 
-The adapter never starts a daemon and never falls back to an embedded one.
-`OURS_INSTANCE`, `--application`, and old ours-mcp daemon variables are errors.
-Standard and live Codex mode use the same selection; live mode only adds an
-explicitly armed, session-scoped wake monitor.
-
-Changing daemon configuration or restarting the shared daemon affects every
-connected application. Explain that blast radius and obtain the user's consent
-before making operator-level changes.
+For full-stack setup, a custom public port (such as 4050), systemd propagation
+and migration, see the [gateway setup guide](https://github.com/adapt-toolkit/ours-network/blob/prerelease/packages/installer/GATEWAY_SETUP.md).
+The coordinated gateway changes require approved matching package releases;
+current npm nightly is not automatically evidence that these changes are installed.
+Server administration uses `ours-install server` on the server host.

package/src/hooks/runner.mjs

@@ -1,10 +1,14 @@
 #!/usr/bin/env node
+import { readFileSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { sendControlCommand } from '../control-server.mjs';
 import { resolveDaemonProfile } from '../profile.mjs';
+import { readHostHookState } from '../host-hooks.mjs';
+import { attachOursClient } from '@ours.network/sdk';
+import { hostProfileFromEnv } from '../../../core/src/host-client/index.ts';
 
 async function defaultFindPin(cwd) {
   let dir = resolve(cwd || process.cwd());
@@ -31,14 +35,6 @@ const safeUnread = (value) => (Array.isArray(value?.identities) ? value.identiti
   return [{ name: entry.name, count, files, recent }];
 });
 
-async function applicationIdentityNames(env, stateDir) {
-  const path = env.OURS_MCP_CONFIG || join(homedir(), '.ours-mcp', 'config.json');
-  const value = JSON.parse(await readFile(path, 'utf8'));
-  if (value?.version !== 1 || !value.daemons || typeof value.daemons !== 'object') return new Set();
-  const identities = value.daemons[resolve(stateDir)]?.identities;
-  return new Set(Array.isArray(identities) ? identities.filter((name) => typeof name === 'string') : []);
-}
-
 function renderContext(unread, pin) {
   const lines = [];
   if (unread.length) {
@@ -54,7 +50,7 @@ function renderContext(unread, pin) {
   return lines.join('\n');
 }
 
-export async function handleHook(payload, { env = process.env, fetch: fetchImpl = globalThis.fetch, send = sendControlCommand, findPin = defaultFindPin } = {}) {
+export async function handleHook(payload, { env = process.env, fetch: fetchImpl = globalThis.fetch, send = sendControlCommand, findPin = defaultFindPin, profileResolver = resolveDaemonProfile, clientFactory = attachOursClient, readHostState = readHostHookState } = {}) {
   try {
     const event = payload?.hook_event_name;
     const socket = env.OURS_CODEX_CONTROL_SOCKET;
@@ -72,37 +68,26 @@ export async function handleHook(payload, { env = process.env, fetch: fetchImpl
     if (event === 'SessionStart' && socket && capability && payload.session_id && payload.cwd) {
       await send(socket, capability, { command: 'register_session', sessionId: payload.session_id, threadId: payload.session_id, cwd: payload.cwd });
     }
-    let port = env.OURS_PORT || '3050';
-    let selectedStateDir = resolve(env.OURS_STATE_DIR || join(homedir(), '.ours'));
-    let selectedToken = env.OURS_API_TOKEN || '';
-    // Standard Codex does not pass through ours-codex's resolved environment.
-    // Resolve the same coherent SDK selection here so SessionStart and
-    // UserPromptSubmit inspect the same daemon as the stdio proxy.
-    try {
-      const selected = await resolveDaemonProfile({ env, fetch: fetchImpl });
-      port = String(selected.port);
-      selectedToken = selected.token || '';
-      selectedStateDir = resolve(selected.stateDir);
-    } catch { /* proxy/launcher owns diagnostics; hooks emit a benign no-op */ }
-    const headers = selectedToken ? { 'x-ours-api-token': selectedToken } : {};
-    let unread = [];
-    try {
-      const response = await fetchImpl(`http://127.0.0.1:${port}/unread`, { headers, signal: AbortSignal.timeout(1500) });
-      if (response.ok) {
-        const visible = await applicationIdentityNames(env, selectedStateDir);
-        unread = safeUnread(await response.json()).filter((entry) => visible.has(entry.name));
-      }
-    } catch { /* daemon diagnostics belong to launcher/proxy */ }
-    const pin = await findPin(payload.cwd || process.cwd());
-    const context = renderContext(unread, pin);
-    if (!context) return { continue: true };
-    return { continue: true, hookSpecificOutput: { hookEventName: event, additionalContext: context } };
+    let hostProfile;
+    try { hostProfile = hostProfileFromEnv(env); }
+    catch { return { continue: true }; }
+    if (hostProfile) {
+      const nativeSessionId = payload.session_id;
+      if (typeof nativeSessionId !== 'string' || !nativeSessionId) return { continue: true };
+      const appPath = env.OURS_MCP_CONFIG || join(env.HOME || homedir(), '.ours-mcp', 'config.json');
+      const state = await readHostState({ profile: hostProfile, nativeSessionId, applicationPath: appPath });
+      const pin = await findPin(payload.cwd || process.cwd());
+      const context = renderContext(state.unread.identities, pin);
+      return context ? { continue: true, hookSpecificOutput: { hookEventName: event, additionalContext: context } } : { continue: true };
+    }
+
+    return { continue: true };
   } catch { return { continue: true }; }
 }
 
 async function main() {
   let payload = {};
-  try { payload = JSON.parse(await readFile(0, 'utf8')); } catch { /* noop */ }
+  try { payload = JSON.parse(readFileSync(0, 'utf8')); } catch { /* noop */ }
   process.stdout.write(JSON.stringify(await handleHook(payload)));
 }