@ours.network/codex 1.2.0-nightly.6 → 1.2.0-nightly.8

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "ours",
-  "version": "1.2.0-nightly.6",
+  "version": "1.2.0-nightly.8",
   "description": "Secure agent-to-agent messaging and explicitly armed live mail wake for Codex CLI.",
   "author": {
     "name": "Adapt Toolkit",

package/README.md

@@ -51,38 +51,21 @@ The launcher never starts, stops, restarts, or reconfigures the ours daemon. If
 selected daemon is absent or incompatible, it exits with an error and leaves standard
 `codex` available.
 
-## Selecting a daemon
-
-Multiple daemons may run on one host when each uses a distinct port and state directory.
-For network clients, explicit `OURS_CONFIG` takes precedence over the managed
-`~/.ours-client/profile.json`. When the managed file exists, ordinary `ours-codex`
-launches need no environment override. Invalid or unreadable managed profiles
-fail before selecting another daemon. With neither selection, the existing
-local-daemon precedence remains:
-
-1. `ours-codex --ours-port <port>`
-2. `OURS_PORT`
-3. the config selected by `OURS_CONFIG`
-4. `~/.ours/config.json`
-5. port `3050`
-
-All MCP, hooks, unread, and watcher calls inherit the same selected profile. Host-profile
-tools run in the local `@ours.network/mcp` stdio server included as a plugin dependency.
-The MCP server calls the selected daemon's authenticated HTTP API through the SDK.
-Example:
+## Selecting a gateway
+
+Every client uses `~/.ours-client/profile.json`; `OURS_CONFIG` can select a complete
+alternate profile. It contains `serverUrl`, `expectedInstanceId`, and `credentialPath`.
+The daemon endpoint is derived as `serverUrl + /daemon`, including gateway path prefixes.
+Missing, unsafe, or invalid profiles fail closed. Remove legacy port/state/token
+selectors; `--ours-port` is rejected. Example after provisioning with `ours-install client`:
 
 ```sh
-OURS_CONFIG="$HOME/.ours/testing.json" ours-codex --ours-port 4050
+OURS_CONFIG="$HOME/.ours-client/testing.json" ours-codex
 ```
 
-An operator-provisioned host profile uses the complete
-`endpoint`/`expectedInstanceId`/`credentialPath` tuple in the selected file. In this mode,
-do not combine the profile with `--ours-port`, `OURS_PORT`, `OURS_API_TOKEN`, or
-`OURS_STATE_DIR`. Codex forwards the actual selected path as `OURS_CONFIG` and the optional `OURS_MCP_CONFIG` host
-record location; the SDK verifies the expected
-daemon instance and rereads `credentialPath` for every request, so an operator token
-update takes effect in the running hook and live monitor without a restart or token
-snapshot in child process environments.
+MCP, hooks, unread and watcher requests inherit that profile. The SDK verifies the
+instance and rereads the issued credential for each request. Client installation and
+launch never install, start, restart or reconfigure server services.
 
 Native ownership is keyed by Codex's actual thread ID. A normal live TUI exit forwards
 that ID through the same `SessionEnd` input used by the hook. If Codex has not produced

package/bin/codex-config-install.mjs

@@ -33,7 +33,7 @@ export function planTomlInstall(text) {
 }
 
 // Render the managed TOML block: the `ours` MCP server pointing at the globally-installed
-// daemon proxy (`ours-mcp proxy`). Equivalent to `codex mcp add ours -- ours-mcp proxy`.
+// gateway client (`ours-mcp proxy`). Equivalent to `codex mcp add ours -- ours-mcp proxy`.
 export function renderTomlBlock() {
   return `${SENTINEL}
 # Added by @ours.network/codex install.sh. Remove this whole block to uninstall.
@@ -41,9 +41,9 @@ export function renderTomlBlock() {
 [mcp_servers.ours]
 command = "ours-mcp"
 args = ["proxy"]
-# Optional per-server environment overrides go here, e.g.:
+# Optional whole shared gateway profile override:
 # [mcp_servers.ours.env]
-# OURS_PORT = "3050"
+# OURS_CONFIG = "/absolute/private/path/profile.json"
 ${SENTINEL_END}
 `;
 }

package/bin/ours-codex-install.mjs

@@ -5,14 +5,7 @@
 //     npm i -g @ours.network/codex
 //     ours-codex-install
 //
-// SUPERSEDED BY `ours-install`: the unified `ours-install` is now the single front door for the
-// WHOLE stack (ours core + harness plugins + ours-fleet + Telegram). `ours-codex-install` is kept
-// as a THIN ALIAS — by default it hands off to `ours-install` when that's available, so an old
-// muscle-memory command still lands the user in the current, unified flow. Pass `--codex-only`
-// (or set OURS_CODEX_LEGACY=1) to force the legacy Codex-only install below.
-//
-// Usage:
-//   ours-codex-install [--codex-only] [--codex-dir DIR] [--skills-dir DIR] [--skip-daemon]
+// Installs client plugin wiring only after shared gateway profile validation.
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
@@ -33,38 +26,19 @@ for (let i = 0; i < argv.length; i++) {
   else { console.error(`ours-codex-install: unknown argument "${a}"`); help(); process.exit(2); }
 }
 
-// Thin-alias hand-off: unless the caller forced the legacy Codex-only path, run the unified
-// `ours-install` if we can find it — on PATH (published), or the monorepo sibling (dev/test).
-if (!opts.codexOnly && !process.env.OURS_CODEX_LEGACY) {
-  const onPath = spawnSync('bash', ['-c', 'command -v ours-install'], { encoding: 'utf8' });
-  const unified = (onPath.status === 0 && (onPath.stdout || '').trim())
-    ? { cmd: (onPath.stdout || '').trim(), args: argv }
-    : (() => {
-        const sib = join(PKG, '..', 'installer', 'install.mjs');
-        return existsSync(sib) ? { cmd: process.execPath, args: [sib, ...argv] } : null;
-      })();
-  if (unified) {
-    const r = spawnSync(unified.cmd, unified.args, { stdio: 'inherit', env: process.env });
-    if (r.error) { console.error(`ours-codex-install: ${r.error.message}`); process.exit(1); }
-    process.exit(r.status ?? 0);
-  }
-  // No unified installer found → fall through to the legacy Codex-only install (still never a dead end).
-}
-
 function help() {
   console.log(`ours-codex-install — set up the ours.network plugin for the OpenAI Codex CLI.
 
   ours-codex-install [options]
 
-By default this hands off to the unified \`ours-install\` (the single front door for the whole
-stack). Use --codex-only to run the legacy Codex-only install instead. Standard mode uses
+Requires clients and a shared gateway profile provisioned by \`ours-install client\`. Standard mode uses
 \`codex\`; live mode uses \`ours-codex\`. Live monitoring still requires explicit consent.
 
 Options:
-      --codex-only          run the legacy Codex-only install (skip the unified ours-install)
+      --codex-only          compatibility flag; plugin setup is always client-only
       --codex-dir <dir>     Codex config+AGENTS.md root (default ~/.codex)     [--codex-only]
       --skills-dir <dir>    skills root (default ~/.agents/skills — USER scope) [--codex-only]
-      --skip-daemon         do not install/start the ours daemon               [--codex-only]
+      --skip-daemon         compatibility flag; server lifecycle is never changed               [--codex-only]
   -h, --help                show this help
 
 Idempotent: safe to re-run. Start a new Codex thread after installation and review the
@@ -81,7 +55,6 @@ if (!existsSync(INSTALL)) {
 const env = { ...process.env };
 if (opts.codexDir) env.CODEX_DIR = opts.codexDir;
 if (opts.skillsDir) env.SKILLS_DIR = opts.skillsDir;
-if (opts.skipDaemon) env.OURS_INSTALL_SKIP_DAEMON = '1';
 
 const res = spawnSync('bash', [INSTALL], { stdio: 'inherit', env });
 if (res.error) { console.error(`ours-codex-install: ${res.error.message}`); process.exit(1); }

package/dist/hooks-runner.mjs

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 
 // src/hooks/runner.mjs
-import { readFileSync as readFileSync2 } from "node:fs";
+import { readFileSync } from "node:fs";
 import { readFile as readFile3 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname4, join as join4, resolve as resolve4 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname4, join as join3, resolve as resolve3 } from "node:path";
 import { pathToFileURL } from "node:url";
 
 // src/control-server.mjs
@@ -19,7 +19,7 @@ function encodeControlResponse(value) {
 
 // src/control-server.mjs
 function sendControlCommand(socketPath, capability, message, timeoutMs = 2e3) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve4, reject) => {
     const socket = createConnection(socketPath);
     let buffer = "";
     const timer = setTimeout(() => {
@@ -40,7 +40,7 @@ function sendControlCommand(socketPath, capability, message, timeoutMs = 2e3) {
       try {
         const response = JSON.parse(buffer);
         if (!response.ok) reject(new Error(response.error || "monitor control failed"));
-        else resolve5(response);
+        else resolve4(response);
       } catch (error) {
         reject(error);
       }
@@ -49,141 +49,38 @@ function sendControlCommand(socketPath, capability, message, timeoutMs = 2e3) {
 }
 
 // src/profile.mjs
-import { join as join3 } from "node:path";
-import { homedir as homedir3 } from "node:os";
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { assertDaemonStateDir, attachOursClient as attachOursClient2, resolveDaemonConfig } from "@ours.network/sdk";
+import { attachOursClient as attachOursClient2 } from "@ours.network/sdk";
 
 // ../core/src/host-profile.ts
-import { existsSync, lstatSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { resolve } from "node:path";
-var PROFILE_KEYS = ["endpoint", "expectedInstanceId", "credentialPath"];
-var LEGACY_SELECTION_KEYS = ["port", "stateDir", "apiToken", "apiVisibility"];
-var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-var CONFLICTING_ENV = ["OURS_API_TOKEN", "OURS_PORT", "OURS_STATE_DIR", "OURS_DAEMON_ID"];
-function profileError(reason) {
-  return new Error(`Invalid external host profile: ${reason}`);
-}
-function validateHostProfile(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw profileError("expected a complete host profile object.");
-  }
-  const record = value;
-  const present = PROFILE_KEYS.filter((key) => Object.hasOwn(record, key));
-  if (present.length !== PROFILE_KEYS.length) {
-    throw profileError("expected a complete host profile tuple: endpoint, expectedInstanceId, credentialPath.");
-  }
-  const mixed = LEGACY_SELECTION_KEYS.filter((key) => Object.hasOwn(record, key));
-  if (mixed.length) throw profileError(`legacy selection keys cannot be mixed with a host profile (${mixed.join(", ")}).`);
-  const endpoint = record.endpoint;
-  const expectedInstanceId = record.expectedInstanceId;
-  const credentialPath = record.credentialPath;
-  if (typeof endpoint !== "string" || endpoint.trim() !== endpoint || endpoint === "") {
-    throw profileError("endpoint must be a non-empty HTTP or HTTPS origin.");
-  }
-  if (typeof expectedInstanceId !== "string" || !UUID.test(expectedInstanceId)) {
-    throw profileError("expectedInstanceId must be a lowercase UUID.");
-  }
-  if (typeof credentialPath !== "string" || credentialPath === "" || !credentialPath.startsWith("/") || resolve(credentialPath) !== credentialPath) {
-    throw profileError("credentialPath must be a normalized absolute path.");
-  }
-  let url;
-  try {
-    url = new URL(endpoint);
-  } catch {
-    throw profileError("endpoint must be an HTTP or HTTPS origin.");
-  }
-  if (url.protocol !== "http:" && url.protocol !== "https:" || url.username || url.password || url.pathname !== "/" || url.search || url.hash) {
-    throw profileError("endpoint must be an HTTP or HTTPS origin without credentials, path, query, or fragment.");
-  }
-  return { endpoint: url.origin, expectedInstanceId, credentialPath };
-}
-function readProfileObject(configPath) {
-  let text;
-  try {
-    text = readFileSync(configPath, "utf8");
-  } catch {
-    throw new Error(`Cannot read host profile ${JSON.stringify(configPath)}.`);
-  }
-  let value;
-  try {
-    value = JSON.parse(text);
-  } catch {
-    throw profileError(`config ${JSON.stringify(configPath)} is not valid JSON.`);
-  }
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw profileError(`config ${JSON.stringify(configPath)} must be an object.`);
-  return value;
-}
-function assertPrivateRegularFile(configPath) {
-  let stat;
-  try {
-    stat = lstatSync(configPath);
-  } catch {
-    throw new Error(`Cannot read host profile ${JSON.stringify(configPath)}.`);
-  }
-  if (!stat.isFile()) throw profileError(`config ${JSON.stringify(configPath)} must be a regular file.`);
-  const currentUid = process.getuid?.();
-  if (currentUid === void 0 || stat.uid !== currentUid) throw profileError(`config ${JSON.stringify(configPath)} must be owned by the current user.`);
-  if ((stat.mode & 63) !== 0) throw profileError(`config ${JSON.stringify(configPath)} must have private permissions.`);
-}
-function readHostProfile(configPath) {
-  const record = readProfileObject(configPath);
-  const found = PROFILE_KEYS.filter((key) => Object.hasOwn(record, key));
-  if (found.length === 0) return null;
-  assertPrivateRegularFile(configPath);
-  return validateHostProfile(record);
-}
-function nonempty(env, key) {
-  return (env[key] ?? "").trim() !== "";
-}
+import { readGatewayClientProfile, validateGatewayClientProfile } from "@ours.network/sdk/client";
+var validateHostProfile = validateGatewayClientProfile;
 function hostProfileSelectionFromEnv(env = process.env) {
-  const explicit = (env.OURS_CONFIG ?? "").trim();
-  const managedPath = resolve(env.HOME || homedir(), ".ours-client", "profile.json");
-  let configPath = explicit;
-  if (!configPath) {
-    try {
-      lstatSync(managedPath);
-      configPath = managedPath;
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw new Error(`Cannot read host profile ${JSON.stringify(managedPath)}.`);
-      }
-      configPath = resolve(homedir(), ".ours", "config.json");
-      if (!existsSync(configPath)) return null;
-    }
-  }
-  const profile = readHostProfile(configPath);
-  if (profile === null) {
-    if (resolve(configPath) === managedPath) throw profileError("managed client config must contain a complete host profile tuple.");
-    return null;
-  }
-  const conflicting = CONFLICTING_ENV.filter((key) => nonempty(env, key));
-  if (conflicting.length) throw profileError(`${conflicting.join(", ")} conflicts with host-profile mode.`);
+  const { configPath, ...profile } = readGatewayClientProfile(env);
   return { profile, configPath };
 }
 function hostProfileFromEnv(env = process.env) {
-  return hostProfileSelectionFromEnv(env)?.profile ?? null;
+  return hostProfileSelectionFromEnv(env).profile;
 }
 
 // ../core/src/native-session.ts
 import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
 import { chmod as chmod2, mkdir as mkdir2, readFile as readFile2, rename as rename2, unlink as unlink2, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname2, join as join2, resolve as resolve3 } from "node:path";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "node:path";
 import { attachOursClient } from "@ours.network/sdk";
 
 // ../core/src/application-identities.ts
 import { randomUUID } from "node:crypto";
 import { chmod, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { dirname, resolve as resolve2 } from "node:path";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
 var APPLICATION_IDENTITIES_VERSION = 1;
 var APPLICATION_IDENTITIES_ENV = "OURS_MCP_CONFIG";
-var UUID2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 var emptyConfig = () => ({ version: 1, daemons: {}, instances: {} });
 function applicationIdentityConfigPath(env = process.env) {
   const explicit = (env[APPLICATION_IDENTITIES_ENV] ?? "").trim();
-  return resolve2(explicit || resolve2(homedir2(), ".ours-mcp", "config.json"));
+  return resolve(explicit || resolve(homedir(), ".ours-mcp", "config.json"));
 }
 function parseRows(raw, path, namespace, normalizeKey) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
@@ -214,9 +111,9 @@ function parseConfig(text, path) {
   if (record.version !== APPLICATION_IDENTITIES_VERSION) {
     throw new Error(`Unsupported ours-mcp application identity config version at ${path}: expected ${APPLICATION_IDENTITIES_VERSION}, found ${String(record.version)}.`);
   }
-  const daemons = parseRows(record.daemons, path, "daemon", resolve2);
+  const daemons = parseRows(record.daemons, path, "daemon", resolve);
   const instances = record.instances === void 0 ? {} : parseRows(record.instances, path, "instance", (instanceId) => {
-    if (!UUID2.test(instanceId)) throw new Error(`Invalid ours-mcp application identity config at ${path}: instance ${JSON.stringify(instanceId)} must be a lowercase UUID.`);
+    if (!UUID.test(instanceId)) throw new Error(`Invalid ours-mcp application identity config at ${path}: instance ${JSON.stringify(instanceId)} must be a lowercase UUID.`);
     return instanceId;
   });
   return { version: 1, daemons, instances };
@@ -252,14 +149,14 @@ var ApplicationIdentityStore = class {
   path;
   constructor(target, options = {}) {
     if (typeof target === "string") {
-      this.stateDir = resolve2(target);
+      this.stateDir = resolve(target);
       this.instanceId = null;
     } else {
-      if (!target || !UUID2.test(target.instanceId)) throw new Error("Application identity instanceId must be a lowercase UUID.");
+      if (!target || !UUID.test(target.instanceId)) throw new Error("Application identity instanceId must be a lowercase UUID.");
       this.stateDir = null;
       this.instanceId = target.instanceId;
     }
-    this.path = resolve2(options.path ?? applicationIdentityConfigPath(options.env));
+    this.path = resolve(options.path ?? applicationIdentityConfigPath(options.env));
   }
   rows(config) {
     return this.instanceId === null ? config.daemons : config.instances;
@@ -299,7 +196,7 @@ var ApplicationIdentityStore = class {
 
 // ../core/src/session-guard.ts
 import { createHash } from "node:crypto";
-import { openSync, closeSync, lstatSync as lstatSync2, mkdirSync, chmodSync, constants } from "node:fs";
+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;
@@ -330,7 +227,7 @@ function ensureGuardFile(guardPath) {
   } catch (error) {
     if (error.code !== "EEXIST") throw error;
   }
-  const stat = lstatSync2(guardPath);
+  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");
   }
@@ -346,11 +243,11 @@ function acquireSessionGuard(recordPath) {
   const hash = createHash("sha256").update(recordPath).digest("hex");
   const guardPath = join(base, `${hash}.guard`);
   ensureGuardFile(guardPath);
-  const before = lstatSync2(guardPath);
+  const before = lstatSync(guardPath);
   const Database = resolveDatabase();
   const db = new Database(guardPath);
   try {
-    const after = lstatSync2(guardPath);
+    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");
     }
@@ -372,7 +269,7 @@ function acquireSessionGuard(recordPath) {
 
 // ../core/src/native-session.ts
 var RECORD_VERSION = 1;
-var UUID3 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+var UUID2 = /^[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) {
@@ -382,10 +279,10 @@ function selector(value) {
   return value;
 }
 function nativeSessionRecordPath(hostRecordRoot, instanceId, nativeSessionId) {
-  if (!hostRecordRoot || !hostRecordRoot.startsWith("/") || resolve3(hostRecordRoot) !== hostRecordRoot) {
+  if (!hostRecordRoot || !hostRecordRoot.startsWith("/") || resolve2(hostRecordRoot) !== hostRecordRoot) {
     throw new Error("Native session host record root must be a normalized absolute path.");
   }
-  if (!UUID3.test(instanceId)) throw new Error("Native session daemon instance must be a lowercase UUID.");
+  if (!UUID2.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`);
 }
@@ -401,7 +298,7 @@ function parseRecord(text, path) {
   }
   const record = value;
   const keys = Object.keys(record).sort();
-  if (keys.join(",") !== "ownerInstanceId,state,version" || record.version !== RECORD_VERSION || typeof record.ownerInstanceId !== "string" || !UUID3.test(record.ownerInstanceId) || !["active", "pending", "ended"].includes(String(record.state))) {
+  if (keys.join(",") !== "ownerInstanceId,state,version" || record.version !== RECORD_VERSION || typeof record.ownerInstanceId !== "string" || !UUID2.test(record.ownerInstanceId) || !["active", "pending", "ended"].includes(String(record.state))) {
     throw new Error(`Invalid native session record at ${path}.`);
   }
   return record;
@@ -435,8 +332,8 @@ async function writeRecord(path, record) {
 async function serialized(key, operation) {
   const predecessor = operations.get(key) ?? Promise.resolve();
   let release;
-  const gate = new Promise((resolve5) => {
-    release = resolve5;
+  const gate = new Promise((resolve4) => {
+    release = resolve4;
   });
   const tail = predecessor.catch(() => {
   }).then(() => gate);
@@ -545,53 +442,18 @@ function parseOursArgs(argv = []) {
 async function resolveDaemonProfile({ argv = [], env = process.env, fetch: fetchImpl = globalThis.fetch, attach: attach2 = attachOursClient2 } = {}) {
   const parsed = parseOursArgs(argv);
   const hostSelection = hostProfileSelectionFromEnv(env);
-  if (hostSelection !== null) {
-    const { profile: hostProfile, configPath } = hostSelection;
-    if (parsed.port != null) throw new Error("ours: --ours-port conflicts with host-profile mode");
-    const client = await attach2({ ...hostProfile, sessionMode: "external", leaseToken: randomUUID3(), env: {} });
-    let info2;
-    try {
-      info2 = await client.version();
-      await client.identities();
-      await client.unread();
-    } finally {
-      await client.close();
-    }
-    return { profile: hostProfile, info: info2, baseUrl: hostProfile.endpoint, configPath, codexArgs: parsed.codexArgs };
+  const { profile: hostProfile, configPath } = hostSelection;
+  if (parsed.port != null) throw new Error("ours: --ours-port conflicts with host-profile mode");
+  const client = await attach2({ ...hostProfile, sessionMode: "external", leaseToken: randomUUID3(), env: {} });
+  let info;
+  try {
+    info = await client.version();
+    await client.identities();
+    await client.unread();
+  } finally {
+    await client.close();
   }
-  const selection = resolveDaemonConfig({
-    ...parsed.port == null ? {} : { port: parsed.port },
-    env,
-    homeDir: env.HOME || homedir3()
-  });
-  await assertDaemonStateDir(selection, { fetch: fetchImpl, timeoutMs: 2e3 });
-  const baseUrl = selection.baseUrl.value;
-  const token = selection.token?.value ?? null;
-  const headers = token ? { "x-ours-api-token": token } : {};
-  const response = await fetchImpl(`${baseUrl}/info`, { signal: AbortSignal.timeout(2e3) });
-  if (!response.ok) throw new Error(`ours daemon at ${baseUrl} returned HTTP ${response.status}`);
-  const info = await response.json();
-  if (info?.name !== "ours" || !Number.isInteger(info?.protocol) || info.protocol < 1) {
-    throw new Error(`incompatible service at ${baseUrl}; expected an ours daemon with notification protocol 1`);
-  }
-  for (const path of ["/identities", "/unread"]) {
-    const capability = await fetchImpl(`${baseUrl}${path}`, { headers, signal: AbortSignal.timeout(2e3) });
-    if (capability.status === 401 || capability.status === 403) {
-      throw new Error(`ours daemon authentication failed at ${baseUrl}; supply the matching coherent selection`);
-    }
-    if (!capability.ok) throw new Error(`selected daemon lacks ${path} (HTTP ${capability.status})`);
-  }
-  return {
-    port: selection.port.value,
-    stateDir: selection.expectStateDir,
-    token,
-    visibility: "owner",
-    source: selection.baseUrl.source,
-    info,
-    baseUrl,
-    configPath: selection.configPath?.value ?? join3(selection.expectStateDir, "config.json"),
-    codexArgs: parsed.codexArgs
-  };
+  return { profile: hostProfile, info, baseUrl: hostProfile.endpoint, configPath, codexArgs: parsed.codexArgs };
 }
 
 // src/host-hooks.mjs
@@ -621,10 +483,10 @@ async function readHostHookState({ profile, nativeSessionId, applicationPath, cl
 // src/hooks/runner.mjs
 import { attachOursClient as attachOursClient3 } from "@ours.network/sdk";
 async function defaultFindPin(cwd) {
-  let dir = resolve4(cwd || process.cwd());
+  let dir = resolve3(cwd || process.cwd());
   for (; ; ) {
     try {
-      const value = JSON.parse(await readFile3(join4(dir, ".ours-identity"), "utf8"));
+      const value = JSON.parse(await readFile3(join3(dir, ".ours-identity"), "utf8"));
       if (typeof value.identity === "string" && value.identity.trim()) return value;
       return null;
     } catch {
@@ -634,21 +496,6 @@ async function defaultFindPin(cwd) {
     dir = parent;
   }
 }
-var safeUnread = (value) => (Array.isArray(value?.identities) ? value.identities : []).flatMap((entry) => {
-  if (!entry || typeof entry.name !== "string") return [];
-  const count = Number.isSafeInteger(entry.count) ? entry.count : 0;
-  const files = Number.isSafeInteger(entry.files) ? entry.files : 0;
-  if (count <= 0 && files <= 0) return [];
-  const recent = Array.isArray(entry.recent) ? entry.recent.slice(-5).flatMap((m) => m && typeof m.from === "string" ? [{ from: m.from, msg_id: String(m.msg_id ?? "?"), date: typeof m.date === "string" ? m.date : "" }] : []) : [];
-  return [{ name: entry.name, count, files, recent }];
-});
-async function applicationIdentityNames(env, selection) {
-  const path = env.OURS_MCP_CONFIG || join4(homedir4(), ".ours-mcp", "config.json");
-  const value = JSON.parse(await readFile3(path, "utf8"));
-  if (value?.version !== 1 || !value.daemons || typeof value.daemons !== "object") return /* @__PURE__ */ new Set();
-  const identities = selection.instanceId ? value.instances?.[selection.instanceId]?.identities : value.daemons[resolve4(selection.stateDir)]?.identities;
-  return new Set(Array.isArray(identities) ? identities.filter((name) => typeof name === "string") : []);
-}
 function renderContext(unread, pin) {
   const lines = [];
   if (unread.length) {
@@ -681,9 +528,6 @@ async function handleHook(payload, { env = process.env, fetch: fetchImpl = globa
     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 = resolve4(env.OURS_STATE_DIR || join4(homedir4(), ".ours"));
-    let selectedToken = env.OURS_API_TOKEN || "";
     let hostProfile;
     try {
       hostProfile = hostProfileFromEnv(env);
@@ -693,46 +537,13 @@ async function handleHook(payload, { env = process.env, fetch: fetchImpl = globa
     if (hostProfile) {
       const nativeSessionId = payload.session_id;
       if (typeof nativeSessionId !== "string" || !nativeSessionId) return { continue: true };
-      const appPath = env.OURS_MCP_CONFIG || join4(env.HOME || homedir4(), ".ours-mcp", "config.json");
+      const appPath = env.OURS_MCP_CONFIG || join3(env.HOME || homedir2(), ".ours-mcp", "config.json");
       const state = await readHostState({ profile: hostProfile, nativeSessionId, applicationPath: appPath });
-      const pin2 = await findPin(payload.cwd || process.cwd());
-      const context2 = renderContext(state.unread.identities, pin2);
-      return context2 ? { continue: true, hookSpecificOutput: { hookEventName: event, additionalContext: context2 } } : { continue: true };
+      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 };
     }
-    try {
-      const selected = await profileResolver({ env, fetch: fetchImpl });
-      if (selected.profile) {
-        let client;
-        try {
-          client = await clientFactory({ ...selected.profile, sessionMode: "external", leaseToken: `codex-hook-${process.pid}`, env: {} });
-          const visible = await applicationIdentityNames(env, { instanceId: selected.profile.expectedInstanceId });
-          const unread2 = safeUnread(await client.unread()).filter((entry) => visible.has(entry.name));
-          const pin2 = await findPin(payload.cwd || process.cwd());
-          const context2 = renderContext(unread2, pin2);
-          return context2 ? { continue: true, hookSpecificOutput: { hookEventName: event, additionalContext: context2 } } : { continue: true };
-        } finally {
-          await client?.close();
-        }
-      }
-      port = String(selected.port);
-      selectedToken = selected.token || "";
-      selectedStateDir = resolve4(selected.stateDir);
-    } catch {
-    }
-    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, { stateDir: selectedStateDir });
-        unread = safeUnread(await response.json()).filter((entry) => visible.has(entry.name));
-      }
-    } catch {
-    }
-    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 } };
+    return { continue: true };
   } catch {
     return { continue: true };
   }
@@ -740,7 +551,7 @@ async function handleHook(payload, { env = process.env, fetch: fetchImpl = globa
 async function main() {
   let payload = {};
   try {
-    payload = JSON.parse(readFileSync2(0, "utf8"));
+    payload = JSON.parse(readFileSync(0, "utf8"));
   } catch {
   }
   process.stdout.write(JSON.stringify(await handleHook(payload)));