@slock-ai/daemon 0.57.3 → 0.57.4

package/dist/cli/index.js

@@ -293,7 +293,6 @@ var ApiClient = class {
     const suffix = pathname.slice(agentPrefix.length);
     if (suffix === "/server") return "/internal/agent-api/server";
     if (suffix === "/send") return "/internal/agent-api/send";
-    if (suffix === "/inbox" || suffix.startsWith("/inbox?")) return `/internal/agent-api/inbox${suffix.slice("/inbox".length)}`;
     if (suffix.startsWith("/history")) return `/internal/agent-api/history${suffix.slice("/history".length)}`;
     if (suffix.startsWith("/search")) return `/internal/agent-api/search${suffix.slice("/search".length)}`;
     const messageResolve = /^\/messages\/([^/]+)\/resolve$/.exec(suffix);
@@ -827,6 +826,28 @@ function describeDeviceCodeLoginError(code) {
   return ACTIONABLE_ERROR_MESSAGES[code] ?? `Device login failed (code: ${code}).`;
 }
 async function runDeviceCodeLogin(options) {
+  const authorization = await authorizeDeviceCode({
+    serverUrl: options.serverUrl,
+    ...options.clientName ? { clientName: options.clientName } : {},
+    ...options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}
+  });
+  await options.onUserAction({
+    verificationUri: authorization.verificationUri,
+    ...authorization.verificationUriComplete ? { verificationUriComplete: authorization.verificationUriComplete } : {},
+    userCode: authorization.userCode,
+    expiresInSeconds: authorization.expiresInSeconds
+  });
+  const pollIntervalMs = options.pollIntervalOverrideMs ?? authorization.intervalMs;
+  const deadlineMs = Date.now() + Math.max(1, authorization.expiresInSeconds) * 1e3;
+  return pollDeviceToken({
+    serverUrl: options.serverUrl,
+    deviceCode: authorization.deviceCode,
+    pollIntervalMs,
+    deadlineMs,
+    ...options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}
+  });
+}
+async function authorizeDeviceCode(options) {
   const httpFetch = options.fetchImpl ?? fetch2;
   const base = options.serverUrl.replace(/\/+$/, "");
   const authorizeRes = await httpFetch(`${base}/api/auth/device/authorize`, {
@@ -850,25 +871,29 @@ async function runDeviceCodeLogin(options) {
       "Server's authorize response was missing deviceCode / userCode / verificationUri."
     );
   }
-  const verificationUri = authorizeBody.verificationUri.startsWith("http") ? authorizeBody.verificationUri : `${base}${authorizeBody.verificationUri}`;
-  await options.onUserAction({
-    verificationUri,
+  const absolutize = (uri) => uri.startsWith("http") ? uri : `${base}${uri}`;
+  return {
+    deviceCode: authorizeBody.deviceCode,
     userCode: authorizeBody.userCode,
-    expiresInSeconds: authorizeBody.expiresIn ?? 0
-  });
-  const serverIntervalMs = (authorizeBody.interval ?? 5) * 1e3;
-  const pollIntervalMs = options.pollIntervalOverrideMs ?? serverIntervalMs;
-  const deadlineMs = Date.now() + Math.max(1, authorizeBody.expiresIn ?? 600) * 1e3;
-  while (Date.now() < deadlineMs) {
+    verificationUri: absolutize(authorizeBody.verificationUri),
+    ...authorizeBody.verificationUriComplete ? { verificationUriComplete: absolutize(authorizeBody.verificationUriComplete) } : {},
+    expiresInSeconds: authorizeBody.expiresIn ?? 600,
+    intervalMs: (authorizeBody.interval ?? 5) * 1e3
+  };
+}
+async function pollDeviceToken(options) {
+  const httpFetch = options.fetchImpl ?? fetch2;
+  const base = options.serverUrl.replace(/\/+$/, "");
+  while (Date.now() < options.deadlineMs) {
     let tokenRes;
     try {
       tokenRes = await httpFetch(`${base}/api/auth/device/token`, {
         method: "POST",
         headers: { "content-type": "application/json" },
-        body: JSON.stringify({ deviceCode: authorizeBody.deviceCode })
+        body: JSON.stringify({ deviceCode: options.deviceCode })
       });
     } catch {
-      await delay(pollIntervalMs);
+      await delay(options.pollIntervalMs);
       continue;
     }
     if (tokenRes.ok) {
@@ -888,7 +913,7 @@ async function runDeviceCodeLogin(options) {
     const tokenError = await safeJson(tokenRes);
     const code = typeof tokenError?.code === "string" ? tokenError.code : "token_failed";
     if (code === "authorization_pending") {
-      await delay(pollIntervalMs);
+      await delay(options.pollIntervalMs);
       continue;
     }
     throw new DeviceCodeLoginError(code, describeDeviceCodeLoginError(code));
@@ -993,128 +1018,332 @@ function registerAgentListCommand(parent, runtimeOptions = {}) {
 }
 
 // src/commands/agent/login.ts
-import { mkdir, stat, writeFile } from "fs/promises";
+import { mkdir, readFile, stat, writeFile } from "fs/promises";
 import path3 from "path";
 import { fetch as undiciFetch2 } from "undici";
+var WAIT_MAX_POLL_MS = 15 * 60 * 1e3;
+var SERVER_OPTION = {
+  flags: "--server <url>",
+  description: "Slock server base URL, e.g. https://slock.example.com"
+};
+var AGENT_OPTION = {
+  flags: "--agent <agentId>",
+  description: "Agent id to log in as"
+};
+var CLIENT_NAME_OPTION = {
+  flags: "--client-name <label>",
+  description: "Human-readable label shown on the web approval page"
+};
+var PROFILE_SLUG_OPTION = {
+  flags: "--profile-slug <slug>",
+  description: "Slug to save the new profile under (defaults to the agent id). Distinct from root `slock --profile`, which selects an existing profile to use."
+};
+var PROFILE_DIR_OPTION = {
+  flags: "--profile-dir <path>",
+  description: "Override the profile directory root (default resolution: SLOCK_HOME/profiles/<slug> when SLOCK_HOME is set, else ~/.slock/profiles/<slug>)"
+};
+var DEVICE_CODE_OPTION = {
+  flags: "--device-code <code>",
+  description: "The device_code returned by `slock agent login start`"
+};
 var agentLoginCommand = defineCommand(
   {
     name: "login",
     description: "Sign this CLI in as a specific Slock agent via the device-code login grant.",
     options: [
-      { flags: "--server <url>", description: "Slock server base URL, e.g. https://slock.example.com" },
-      { flags: "--agent <agentId>", description: "Agent id to log in as" },
-      { flags: "--client-name <label>", description: "Human-readable label shown on the web approval page" },
-      { flags: "--profile-slug <slug>", description: "Slug to save the new profile under (defaults to the agent id). Distinct from root `slock --profile`, which selects an existing profile to use." },
-      { flags: "--profile-dir <path>", description: "Override the profile directory root (default resolution: SLOCK_HOME/profiles/<slug> when SLOCK_HOME is set, else ~/.slock/profiles/<slug>)" }
+      SERVER_OPTION,
+      AGENT_OPTION,
+      CLIENT_NAME_OPTION,
+      PROFILE_SLUG_OPTION,
+      PROFILE_DIR_OPTION
     ]
   },
   async (ctx, options) => {
-    if (!options.server?.trim()) {
-      throw cliError("INVALID_ARG", "--server is required");
-    }
-    if (!options.agent?.trim()) {
-      throw cliError("INVALID_AGENT_ID", "--agent must not be empty.");
+    validateServerAgent(options);
+    const paths = resolveProfilePaths(options);
+    const idempotent = await handleExistingCredential(ctx, options, paths);
+    if (idempotent === "handled") return;
+    let userSession;
+    try {
+      userSession = await runDeviceCodeLogin({
+        serverUrl: options.server,
+        ...options.clientName ? { clientName: options.clientName } : {},
+        onUserAction: (action) => {
+          ctx.io.stderr.write(formatVerificationHandoff(action));
+        }
+      });
+    } catch (err) {
+      throw asCliError(err);
     }
-    const invalidShape = describeInvalidAgentIdShape(options.agent);
-    if (invalidShape) {
-      throw cliError("INVALID_AGENT_ID", invalidShape, {
-        suggestedNextAction: `Run \`slock agent list --server ${options.server}\` to see valid agent ids, then rerun login with --agent <id>.`
+    await mintAndPersist(ctx, options, userSession.accessToken, paths);
+  }
+);
+var agentLoginStartCommand = defineCommand(
+  {
+    name: "start",
+    description: "Begin device-code login and print the browser handoff, then exit (does not wait for approval).",
+    options: [SERVER_OPTION, AGENT_OPTION, CLIENT_NAME_OPTION, PROFILE_SLUG_OPTION, PROFILE_DIR_OPTION]
+  },
+  async (ctx, options) => {
+    validateServerAgent(options);
+    const paths = resolveProfilePaths(options);
+    let authorization;
+    try {
+      authorization = await authorizeDeviceCode({
+        serverUrl: options.server,
+        ...options.clientName ? { clientName: options.clientName } : {}
       });
+    } catch (err) {
+      throw asCliError(err);
     }
-    const profileSlug = options.profileSlug ?? options.agent;
-    const profileDir = options.profileDir ?? resolveProfileDir(profileSlug);
-    const credentialPath = path3.join(profileDir, "credential.json");
-    if (await profileFileExists(credentialPath)) {
-      throw cliError(
-        "PROFILE_ALREADY_EXISTS",
-        `Profile '${profileSlug}' already has a credential at ${credentialPath}.`,
-        {
-          suggestedNextAction: `Use a different \`--profile-slug <slug>\` to mint a coexistent credential, OR manually delete ${credentialPath} and rerun login. Note: the existing sk_agent_* on the server is NOT revoked by deleting the local file \u2014 it remains valid until it expires or is explicitly revoked from the agent settings UI.`
-        }
-      );
+    ctx.io.stdout.write(formatStartHandoff(authorization, options, paths));
+  }
+);
+var agentLoginWaitCommand = defineCommand(
+  {
+    name: "wait",
+    description: "Wait for the user to approve a `login start` request, then mint and save the credential.",
+    options: [SERVER_OPTION, AGENT_OPTION, DEVICE_CODE_OPTION, PROFILE_SLUG_OPTION, PROFILE_DIR_OPTION]
+  },
+  async (ctx, options) => {
+    validateServerAgent(options);
+    if (!options.deviceCode?.trim()) {
+      throw cliError("INVALID_ARG", "--device-code is required (the value printed by `slock agent login start`).");
     }
+    const paths = resolveProfilePaths(options);
     let userSession;
     try {
-      userSession = await runDeviceCodeLogin({
+      userSession = await pollDeviceToken({
         serverUrl: options.server,
-        ...options.clientName ? { clientName: options.clientName } : {},
-        onUserAction: ({ verificationUri, userCode, expiresInSeconds }) => {
-          ctx.io.stderr.write(
-            `Open ${verificationUri} in your browser, enter code ${userCode} (expires in ~${Math.max(0, Math.floor(expiresInSeconds / 60))}m).
-`
-          );
-        }
+        deviceCode: options.deviceCode,
+        pollIntervalMs: 5e3,
+        deadlineMs: Date.now() + WAIT_MAX_POLL_MS
       });
     } catch (err) {
-      if (err instanceof DeviceCodeLoginError) {
-        throw cliError(err.code, err.message, { cause: err });
-      }
-      throw err;
+      throw asCliError(err);
     }
-    const mintRes = await undiciFetch2(
-      `${options.server.replace(/\/+$/, "")}/api/agents/${encodeURIComponent(options.agent)}/credentials`,
+    await mintAndPersist(ctx, options, userSession.accessToken, paths);
+  }
+);
+var agentLoginStatusCommand = defineCommand(
+  {
+    name: "status",
+    description: "Report whether the local profile credential is usable, expired, or needs re-login.",
+    options: [SERVER_OPTION, AGENT_OPTION, PROFILE_SLUG_OPTION, PROFILE_DIR_OPTION]
+  },
+  async (ctx, options) => {
+    validateServerAgent(options);
+    const paths = resolveProfilePaths(options);
+    if (!await profileFileExists(paths.credentialPath)) {
+      ctx.io.stdout.write(
+        `state: missing
+No credential for profile '${paths.profileSlug}' at ${paths.credentialPath}.
+Next: run \`${startCommandLine(options, paths)}\` to log in.
+`
+      );
+      return;
+    }
+    const outcome = await tryIdempotentLogin(paths.credentialPath, options);
+    ctx.io.stdout.write(formatStatus(outcome, options, paths));
+  }
+);
+function registerAgentLoginCommand(parent, runtimeOptions = {}) {
+  registerCliCommand(parent, agentLoginCommand, runtimeOptions);
+  const loginCmd = parent.commands.find((c) => c.name() === "login");
+  if (!loginCmd) {
+    throw new Error("internal: `login` command was not registered before attaching subcommands");
+  }
+  registerCliCommand(loginCmd, agentLoginStartCommand, runtimeOptions);
+  registerCliCommand(loginCmd, agentLoginWaitCommand, runtimeOptions);
+  registerCliCommand(loginCmd, agentLoginStatusCommand, runtimeOptions);
+}
+function validateServerAgent(options) {
+  if (!options.server?.trim()) {
+    throw cliError("INVALID_ARG", "--server is required");
+  }
+  if (!options.agent?.trim()) {
+    throw cliError("INVALID_AGENT_ID", "--agent must not be empty.");
+  }
+  const invalidShape = describeInvalidAgentIdShape(options.agent);
+  if (invalidShape) {
+    throw cliError("INVALID_AGENT_ID", invalidShape, {
+      suggestedNextAction: `Run \`slock agent list --server ${options.server}\` to see valid agent ids, then rerun login with --agent <id>.`
+    });
+  }
+}
+function resolveProfilePaths(options) {
+  const profileSlug = options.profileSlug ?? options.agent;
+  const profileDir = options.profileDir ?? resolveProfileDir(profileSlug);
+  const credentialPath = path3.join(profileDir, "credential.json");
+  return { profileSlug, profileDir, credentialPath };
+}
+async function handleExistingCredential(ctx, options, paths) {
+  if (!await profileFileExists(paths.credentialPath)) {
+    return "continue";
+  }
+  const outcome = await tryIdempotentLogin(paths.credentialPath, options);
+  if (outcome === "already_logged_in") {
+    ctx.io.stdout.write(
+      `state: already_logged_in
+Profile '${paths.profileSlug}' is already logged in and its credential is valid. No action needed.
+Next: use \`slock --profile ${paths.profileSlug} \u2026\` to act as this agent.
+`
+    );
+    return "handled";
+  }
+  if (outcome === "mismatch") {
+    throw cliError(
+      "PROFILE_ALREADY_EXISTS",
+      `Profile '${paths.profileSlug}' is already bound to a different agent or server at ${paths.credentialPath}.`,
       {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          authorization: `Bearer ${userSession.accessToken}`
-        },
-        body: JSON.stringify({})
+        suggestedNextAction: `Use a different \`--profile-slug <slug>\` to mint a coexistent credential.`
       }
     );
-    if (!mintRes.ok) {
-      const body = await safeJson2(mintRes);
-      const code = body?.code ?? `mint_failed_${mintRes.status}`;
-      const detail = describeMintError(code, options.server);
-      throw cliError(
-        code,
-        detail?.message ?? body?.error ?? `Failed to mint agent credential (status ${mintRes.status}).`,
-        detail?.suggestedNextAction ? { suggestedNextAction: detail.suggestedNextAction } : void 0
-      );
-    }
-    const minted = await mintRes.json();
-    if (!minted.apiKey || !minted.agentId || !minted.serverId) {
-      throw cliError(
-        "mint_response_invalid",
-        "Server mint response was missing apiKey / agentId / serverId."
-      );
+  }
+  if (outcome === "unverified") {
+    throw cliError(
+      "CREDENTIAL_CHECK_FAILED",
+      `Could not verify the existing credential for profile '${paths.profileSlug}' because the server is unreachable.`,
+      {
+        suggestedNextAction: `The credential at ${paths.credentialPath} may still be valid. Retry when the server is reachable, or use \`--profile-slug <new-slug>\` to mint a fresh credential.`
+      }
+    );
+  }
+  ctx.io.stderr.write(
+    `Existing credential for profile '${paths.profileSlug}' is no longer valid. Starting device-code login to re-mint.
+`
+  );
+  return "continue";
+}
+async function mintAndPersist(ctx, options, accessToken, paths) {
+  const mintRes = await undiciFetch2(
+    `${options.server.replace(/\/+$/, "")}/api/agents/${encodeURIComponent(options.agent)}/credentials`,
+    {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${accessToken}`
+      },
+      body: JSON.stringify({})
     }
-    await mkdir(profileDir, { recursive: true, mode: 448 });
-    await writeFile(
-      credentialPath,
-      JSON.stringify(
-        {
-          schemaVersion: 1,
-          serverUrl: options.server,
-          agentId: minted.agentId,
-          agentName: minted.agentName,
-          serverId: minted.serverId,
-          credentialId: minted.credentialId,
-          scopes: minted.scopes,
-          apiKey: minted.apiKey,
-          createdAt: (/* @__PURE__ */ new Date()).toISOString()
-        },
-        null,
-        2
-      ) + "\n",
-      { mode: 384 }
+  );
+  if (!mintRes.ok) {
+    const body = await safeJson2(mintRes);
+    const code = body?.code ?? `mint_failed_${mintRes.status}`;
+    const detail = describeMintError(code, options.server);
+    throw cliError(
+      code,
+      detail?.message ?? body?.error ?? `Failed to mint agent credential (status ${mintRes.status}).`,
+      detail?.suggestedNextAction ? { suggestedNextAction: detail.suggestedNextAction } : void 0
     );
-    writeJson(ctx.io, {
-      ok: true,
-      data: {
+  }
+  const minted = await mintRes.json();
+  if (!minted.apiKey || !minted.agentId || !minted.serverId) {
+    throw cliError("mint_response_invalid", "Server mint response was missing apiKey / agentId / serverId.");
+  }
+  await mkdir(paths.profileDir, { recursive: true, mode: 448 });
+  await writeFile(
+    paths.credentialPath,
+    JSON.stringify(
+      {
+        schemaVersion: 1,
+        serverUrl: options.server,
         agentId: minted.agentId,
         agentName: minted.agentName,
         serverId: minted.serverId,
         credentialId: minted.credentialId,
         scopes: minted.scopes,
-        profileSlug,
-        credentialPath
-      }
-    });
+        apiKey: minted.apiKey,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      null,
+      2
+    ) + "\n",
+    { mode: 384 }
+  );
+  ctx.io.stdout.write(
+    `state: authorized
+Logged in as '${minted.agentName}' on ${options.server}. Credential saved to ${paths.credentialPath}.
+Next: run \`slock manual get slock-cli-overview\` to learn the Slock CLI, then use \`slock --profile ${paths.profileSlug} \u2026\` for all commands.
+`
+  );
+}
+function formatVerificationHandoff(action) {
+  const mins = Math.max(0, Math.floor(action.expiresInSeconds / 60));
+  if (action.verificationUriComplete) {
+    return `Open this link to approve (code pre-filled): ${action.verificationUriComplete}
+  (fallback) Open ${action.verificationUri} and enter code ${action.userCode}.
+  Expires in ~${mins}m.
+`;
   }
-);
-function registerAgentLoginCommand(parent, runtimeOptions = {}) {
-  registerCliCommand(parent, agentLoginCommand, runtimeOptions);
+  return `Open ${action.verificationUri} in your browser, enter code ${action.userCode} (expires in ~${mins}m).
+`;
+}
+function formatStartHandoff(authorization, options, paths) {
+  const mins = Math.max(0, Math.floor(authorization.expiresInSeconds / 60));
+  let out = `state: pending_human_action
+`;
+  out += `Login started for profile '${paths.profileSlug}'. Ask the user to approve in a browser:
+`;
+  if (authorization.verificationUriComplete) {
+    out += `  Open this link (code pre-filled): ${authorization.verificationUriComplete}
+`;
+    out += `  (fallback) Open ${authorization.verificationUri} and enter code ${authorization.userCode}.
+`;
+  } else {
+    out += `  Open ${authorization.verificationUri} and enter code ${authorization.userCode}.
+`;
+  }
+  out += `  Code expires in ~${mins}m.
+`;
+  out += `Next: after the user approves, run \`${waitCommandLine(options, paths, authorization.deviceCode)}\` to finish.
+`;
+  return out;
+}
+function formatStatus(outcome, options, paths) {
+  const slug = paths.profileSlug;
+  switch (outcome) {
+    case "already_logged_in":
+      return `state: usable
+Profile '${slug}' is logged in and the credential is valid. No action needed.
+Next: use \`slock --profile ${slug} \u2026\` to act as this agent.
+`;
+    case "expired":
+      return `state: expired
+The credential for profile '${slug}' is no longer valid (revoked or expired on the server).
+Next: run \`${startCommandLine(options, paths)}\` to re-login.
+`;
+    case "mismatch":
+      return `state: mismatch
+Profile '${slug}' is bound to a different agent or server than requested.
+Next: re-check --agent / --server, or use a different \`--profile-slug <slug>\`.
+`;
+    case "invalid":
+      return `state: invalid
+The credential file for profile '${slug}' is malformed or missing required fields (${paths.credentialPath}).
+Next: run \`${startCommandLine(options, paths)}\` to re-login.
+`;
+    case "unverified":
+    default:
+      return `state: unverified
+Could not reach the server to verify profile '${slug}' (network or server error). The credential may still be valid \u2014 do not assume it is invalid.
+Next: retry \`slock agent login status\` when connectivity is restored.
+`;
+  }
+}
+function startCommandLine(options, paths) {
+  const slugFlag = paths.profileSlug !== options.agent ? ` --profile-slug ${paths.profileSlug}` : "";
+  return `slock agent login start --server ${options.server} --agent ${options.agent}${slugFlag}`;
+}
+function waitCommandLine(options, paths, deviceCode) {
+  const slugFlag = paths.profileSlug !== options.agent ? ` --profile-slug ${paths.profileSlug}` : "";
+  return `slock agent login wait --server ${options.server} --agent ${options.agent} --device-code ${deviceCode}${slugFlag}`;
+}
+function asCliError(err) {
+  if (err instanceof DeviceCodeLoginError) {
+    return cliError(err.code, err.message, { cause: err });
+  }
+  return err instanceof Error ? err : new Error(String(err));
 }
 async function safeJson2(res) {
   try {
@@ -1123,6 +1352,50 @@ async function safeJson2(res) {
     return null;
   }
 }
+async function tryIdempotentLogin(credentialPath, options) {
+  let credential;
+  try {
+    const raw = await readFile(credentialPath, "utf-8");
+    credential = JSON.parse(raw);
+  } catch {
+    return "invalid";
+  }
+  const localAgentId = typeof credential.agentId === "string" ? credential.agentId : "";
+  const localApiKey = typeof credential.apiKey === "string" ? credential.apiKey : "";
+  const localServerUrl = typeof credential.serverUrl === "string" ? credential.serverUrl : "";
+  const localServerId = typeof credential.serverId === "string" ? credential.serverId : "";
+  const targetServer = options.server.replace(/\/+$/, "");
+  if (localAgentId && localAgentId !== options.agent) {
+    return "mismatch";
+  }
+  if (localServerUrl && localServerUrl.replace(/\/+$/, "") !== targetServer) {
+    return "mismatch";
+  }
+  if (!localAgentId || !localApiKey || !localServerUrl) {
+    return "invalid";
+  }
+  try {
+    const whoamiRes = await undiciFetch2(`${targetServer}/internal/agent-api/`, {
+      headers: { authorization: `Bearer ${localApiKey}` }
+    });
+    if (whoamiRes.ok) {
+      const body = await safeJson2(whoamiRes);
+      if (!body) {
+        return "unverified";
+      }
+      if (body.agentId === localAgentId && (body.serverId === localServerId || !localServerId)) {
+        return "already_logged_in";
+      }
+      return "mismatch";
+    }
+    if (whoamiRes.status === 401 || whoamiRes.status === 403) {
+      return "expired";
+    }
+    return "unverified";
+  } catch {
+    return "unverified";
+  }
+}
 async function profileFileExists(filePath) {
   try {
     await stat(filePath);
@@ -1171,6 +1444,11 @@ function describeMintError(code, serverUrl) {
   return void 0;
 }
 
+// src/agentCommsCore/bridge.ts
+import fs2 from "fs";
+import path4 from "path";
+import { randomUUID } from "crypto";
+
 // ../shared/src/slockRefs.ts
 var SLOCK_REF_CHANNEL_NAME_PATTERN = String.raw`[\p{L}\p{N}_-]+`;
 var SLOCK_REF_USER_NAME_PATTERN = SLOCK_REF_CHANNEL_NAME_PATTERN;
@@ -2059,10 +2337,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path6) {
-  if (!path6)
+function getElementAtPath(obj, path7) {
+  if (!path7)
     return obj;
-  return path6.reduce((acc, key) => acc?.[key], obj);
+  return path7.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -2445,11 +2723,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path6, issues) {
+function prefixIssues(path7, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path6);
+    iss.path.unshift(path7);
     return iss;
   });
 }
@@ -2632,7 +2910,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path6 = []) => {
+  const processError = (error49, path7 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -2642,7 +2920,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path6, ...issue2.path];
+        const fullpath = [...path7, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -2674,8 +2952,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path6 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path6) {
+  const path7 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path7) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -14652,13 +14930,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path6 = ref.slice(1).split("/").filter(Boolean);
-  if (path6.length === 0) {
+  const path7 = ref.slice(1).split("/").filter(Boolean);
+  if (path7.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path6[0] === defsKey) {
-    const key = path6[1];
+  if (path7[0] === defsKey) {
+    const key = path7[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -15173,6 +15451,167 @@ function shortMessageId(value) {
   return value.slice(0, 8);
 }
 
+// ../shared/src/externalAgentIntegration.ts
+var EXTERNAL_AGENT_COMMS_PROTOCOL_VERSION = "agent-comms-core.v1";
+var EXTERNAL_AGENT_PROOF_SCHEMA_VERSION = "agent-proof.v1";
+var EXTERNAL_RUNTIME_INTEGRATION_MANIFEST_SCHEMA = "slock-external-runtime-integration.v1";
+var EXTERNAL_AGENT_WAKE_EVENT_SCHEMA = "slock-external-agent-wake-event.v1";
+var externalAgentCommsModeValues = ["spawn-core", "attach-core", "import-core"];
+var externalAgentIntegrationPatternValues = ["external-harness-plugin", "integrated-runtime"];
+var externalAgentIsolationValues = ["profile-scoped", "session-scoped"];
+var externalAgentWakeAdapterKindValues = ["claude-code-channels", "hermes-in-process"];
+var externalAgentWakeProofLevelValues = [
+  "server_delivered",
+  "harness_accepted",
+  "wake_injected"
+];
+var externalAgentProofLevelValues = [
+  ...externalAgentWakeProofLevelValues,
+  "model_seen"
+];
+var externalAgentCommsLifecycleStateValues = [
+  "unbound",
+  "bound_stopped",
+  "starting",
+  "connected_replaying",
+  "listening_idle",
+  "handoff_pending",
+  "degraded_backoff",
+  "stopping",
+  "stopped",
+  "auth_revoked"
+];
+var externalAgentLifecycleSourceValues = ["server_core", "comms_core", "wake_adapter", "server"];
+var externalAgentLifecycleProvenanceValues = [
+  "slock_core",
+  "adapter_observed",
+  "agent_reported"
+];
+var externalAgentAdapterFailureValues = [
+  "no_session",
+  "busy",
+  "injection_failed",
+  "protocol_mismatch",
+  "auth_revoked"
+];
+var externalAgentServerApiModeValues = ["interim-agent-api-events", "agent-inbox-protocol"];
+var nonEmptyStringSchema = external_exports.string().min(1);
+var isoTimestampSchema = external_exports.string().refine((value) => !Number.isNaN(Date.parse(value)), {
+  message: "must be a parseable timestamp"
+});
+var externalRuntimeIntegrationManifestSchema = external_exports.object({
+  schema: external_exports.literal(EXTERNAL_RUNTIME_INTEGRATION_MANIFEST_SCHEMA),
+  runtimeId: nonEmptyStringSchema,
+  integrationPattern: external_exports.enum(externalAgentIntegrationPatternValues),
+  commsMode: external_exports.enum(externalAgentCommsModeValues),
+  commsProtocolVersion: external_exports.literal(EXTERNAL_AGENT_COMMS_PROTOCOL_VERSION),
+  proofSchemaVersion: external_exports.literal(EXTERNAL_AGENT_PROOF_SCHEMA_VERSION),
+  minSlockCliVersion: nonEmptyStringSchema,
+  multiplex: external_exports.boolean(),
+  agentIsolation: external_exports.enum(externalAgentIsolationValues),
+  bridgeLifecycle: external_exports.object({
+    explicitStartOnly: external_exports.literal(true),
+    oneShotCommandsBridgeIndependent: external_exports.literal(true),
+    requiresBridgeFailureCodes: external_exports.array(external_exports.enum(["BRIDGE_NOT_RUNNING", "NO_CORE_SESSION"])).min(1),
+    autoStartDefault: external_exports.literal(false)
+  }).strict(),
+  serverApi: external_exports.object({
+    mode: external_exports.enum(externalAgentServerApiModeValues),
+    deliveryOnly: external_exports.boolean(),
+    cursorAuthority: external_exports.literal("model_seen_only")
+  }).strict(),
+  wakeAdapter: external_exports.object({
+    kind: external_exports.enum(externalAgentWakeAdapterKindValues),
+    protocol: nonEmptyStringSchema,
+    requiresInteractiveSession: external_exports.boolean().optional()
+  }).strict()
+}).strict().superRefine((value, ctx) => {
+  if (!value.bridgeLifecycle.requiresBridgeFailureCodes.includes("BRIDGE_NOT_RUNNING")) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["bridgeLifecycle", "requiresBridgeFailureCodes"],
+      message: "bridge-dependent surfaces must include BRIDGE_NOT_RUNNING"
+    });
+  }
+  if (!value.bridgeLifecycle.requiresBridgeFailureCodes.includes("NO_CORE_SESSION")) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["bridgeLifecycle", "requiresBridgeFailureCodes"],
+      message: "bridge-dependent surfaces must include NO_CORE_SESSION"
+    });
+  }
+  if (value.serverApi.mode === "interim-agent-api-events" && value.serverApi.deliveryOnly !== true) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["serverApi", "deliveryOnly"],
+      message: "interim agent-api events mode must be delivery-only"
+    });
+  }
+});
+var externalAgentWakeEventBaseSchema = external_exports.object({
+  schema: external_exports.literal(EXTERNAL_AGENT_WAKE_EVENT_SCHEMA),
+  eventId: nonEmptyStringSchema,
+  attemptId: nonEmptyStringSchema,
+  messageId: nonEmptyStringSchema,
+  agentId: nonEmptyStringSchema,
+  profile: nonEmptyStringSchema,
+  coreSessionId: nonEmptyStringSchema,
+  adapterInstance: nonEmptyStringSchema,
+  runtimeSession: nonEmptyStringSchema.nullable(),
+  occurredAt: isoTimestampSchema,
+  lifecycleState: external_exports.enum(externalAgentCommsLifecycleStateValues),
+  authority: external_exports.object({
+    source: external_exports.enum(externalAgentLifecycleSourceValues),
+    provenance: external_exports.enum(externalAgentLifecycleProvenanceValues)
+  }).strict()
+}).strict();
+var externalAgentProofEventEnvelopeSchema = externalAgentWakeEventBaseSchema.extend({
+  kind: external_exports.literal("proof"),
+  proofLevel: external_exports.enum(externalAgentWakeProofLevelValues),
+  outcome: external_exports.literal("ok"),
+  failureMeta: external_exports.undefined().optional(),
+  reason: external_exports.string().optional()
+});
+var externalAgentFailedWakeEventEnvelopeSchema = externalAgentWakeEventBaseSchema.extend({
+  kind: external_exports.literal("wake_attempt"),
+  proofLevel: external_exports.undefined().optional(),
+  outcome: external_exports.literal("failed"),
+  failureMeta: external_exports.object({
+    failureClass: external_exports.enum(externalAgentAdapterFailureValues),
+    retryAfterMs: external_exports.number().int().positive().optional()
+  }).strict(),
+  reason: nonEmptyStringSchema
+});
+var externalAgentWakeEventEnvelopeSchema = external_exports.discriminatedUnion("kind", [
+  externalAgentProofEventEnvelopeSchema,
+  externalAgentFailedWakeEventEnvelopeSchema
+]);
+function validateExternalRuntimeIntegrationManifest(value) {
+  return externalRuntimeIntegrationManifestSchema.parse(value);
+}
+function validateExternalAgentWakeEventEnvelope(value) {
+  const event = externalAgentWakeEventEnvelopeSchema.parse(value);
+  assertExternalAgentWakeEventAuthority(event);
+  return event;
+}
+function assertExternalAgentWakeEventAuthority(event) {
+  if (event.outcome === "failed") {
+    if (event.authority.source !== "wake_adapter") {
+      throw new Error("failed wake_attempt events must be sourced by wake_adapter");
+    }
+    return;
+  }
+  if (event.proofLevel === "server_delivered" && event.authority.source !== "server_core") {
+    throw new Error("server_delivered proof must be sourced by server_core");
+  }
+  if (event.proofLevel === "harness_accepted" && event.authority.source !== "comms_core") {
+    throw new Error("harness_accepted proof must be sourced by comms_core");
+  }
+  if (event.proofLevel === "wake_injected" && event.authority.source !== "wake_adapter") {
+    throw new Error("wake_injected proof must be sourced by wake_adapter");
+  }
+}
+
 // ../shared/src/translationLanguages.ts
 var SUPPORTED_TRANSLATION_LANGUAGE_CODES = [
   "en",
@@ -15372,6 +15811,592 @@ var DISPLAY_PLAN_CONFIG = {
   }
 };
 
+// src/agentCommsCore/bridge.ts
+var AGENT_COMMS_PROTOCOL_VERSION = "agent-comms-core.v1";
+var AGENT_PROOF_SCHEMA_VERSION = "agent-proof.v1";
+function resolveAgentCommsBridgeStateDir(input) {
+  if (input.stateDir) return input.stateDir;
+  const env = input.env ?? process.env;
+  if (env.SLOCK_AGENT_BRIDGE_STATE_DIR) return env.SLOCK_AGENT_BRIDGE_STATE_DIR;
+  const profileSlug = requireProfileSlug(input.agentContext);
+  const adapterInstance = input.adapterInstance ?? "default";
+  return path4.join(
+    resolveProfileDir(profileSlug, env),
+    "agent-comms-core",
+    safePathSegment(input.agentContext.agentId),
+    safePathSegment(adapterInstance)
+  );
+}
+function createFileAgentCommsBridgeStore(input) {
+  const rootDir = resolveAgentCommsBridgeStateDir(input);
+  const paths = {
+    rootDir,
+    sessionFile: path4.join(rootDir, "session.json"),
+    wakeHintsFile: path4.join(rootDir, "wake-hints.jsonl"),
+    proofFile: path4.join(rootDir, "proofs.jsonl")
+  };
+  fs2.mkdirSync(rootDir, { recursive: true, mode: 448 });
+  return {
+    paths,
+    readSession() {
+      if (!fs2.existsSync(paths.sessionFile)) return null;
+      try {
+        const parsed = JSON.parse(fs2.readFileSync(paths.sessionFile, "utf-8"));
+        return {
+          ...typeof parsed.coreSessionId === "string" ? { coreSessionId: parsed.coreSessionId } : {},
+          ...typeof parsed.lastSeenHintSeq === "number" ? { lastSeenHintSeq: parsed.lastSeenHintSeq } : {}
+        };
+      } catch {
+        return null;
+      }
+    },
+    writeSession(session) {
+      fs2.writeFileSync(paths.sessionFile, `${JSON.stringify(session, null, 2)}
+`, { mode: 384 });
+    },
+    readWakeHints() {
+      return readJsonl(paths.wakeHintsFile);
+    },
+    appendWakeHintIfAbsent(hint) {
+      const key = wakeHintKey(hint);
+      const pending = readJsonl(paths.wakeHintsFile);
+      if (pending.some((candidate) => wakeHintKey(candidate) === key)) return false;
+      appendJsonl(paths.wakeHintsFile, stripContentFields(hint));
+      return true;
+    },
+    appendProof(proof2) {
+      appendJsonl(paths.proofFile, proof2);
+    }
+  };
+}
+async function runAgentCommsBridgeOnce(input) {
+  if (input.agentContext.clientMode !== "self-hosted-runner") {
+    throw new Error("slock agent bridge requires a self-hosted profile credential; run with `slock --profile <slug> agent bridge`.");
+  }
+  const profileSlug = requireProfileSlug(input.agentContext);
+  const adapterInstance = input.adapterInstance ?? "default";
+  const store = createFileAgentCommsBridgeStore({
+    agentContext: input.agentContext,
+    env: input.env,
+    stateDir: input.stateDir,
+    adapterInstance
+  });
+  const existingSession = store.readSession();
+  const coreSessionId = input.coreSessionId ?? existingSession?.coreSessionId ?? `core_${randomUUID()}`;
+  const identity = {
+    agentId: input.agentContext.agentId,
+    profileSlug,
+    adapterInstance,
+    coreSessionId
+  };
+  const now = input.now ?? (() => /* @__PURE__ */ new Date());
+  const output = [
+    lifecycle(identity, "starting", now)
+  ];
+  if (input.replayPending !== false) {
+    const hints = store.readWakeHints();
+    if (hints.length > 0) {
+      output.push(lifecycle(identity, "connected_replaying", now));
+      for (const hint of hints) {
+        const attemptId = `attempt_${randomUUID()}`;
+        output.push(handoff(identity, hint, attemptId, true, now));
+        await maybeRunWakeAdapter({
+          identity,
+          hint,
+          attemptId,
+          wakeAdapter: input.wakeAdapter,
+          runtimeSession: input.runtimeSession ?? null,
+          now,
+          output,
+          store
+        });
+      }
+    }
+  }
+  const since = existingSession?.lastSeenHintSeq ?? "latest";
+  const fetched = await input.source.fetchWakeHints({ since, limit: input.limit ?? 50 });
+  let lastSeenHintSeq = existingSession?.lastSeenHintSeq;
+  for (const hint of fetched.hints) {
+    const attemptId = `attempt_${randomUUID()}`;
+    const serverDelivered = proof(identity, hint, attemptId, "server_delivered", now);
+    store.appendProof(serverDelivered);
+    output.push(serverDelivered);
+    store.appendWakeHintIfAbsent(hint);
+    const accepted = proof(identity, hint, attemptId, "harness_accepted", now);
+    store.appendProof(accepted);
+    output.push(accepted);
+    output.push(handoff(identity, hint, attemptId, false, now));
+    await maybeRunWakeAdapter({
+      identity,
+      hint,
+      attemptId,
+      wakeAdapter: input.wakeAdapter,
+      runtimeSession: input.runtimeSession ?? null,
+      now,
+      output,
+      store
+    });
+    const seq = wakeHintSeq(hint);
+    if (typeof seq === "number") lastSeenHintSeq = Math.max(lastSeenHintSeq ?? 0, seq);
+  }
+  const fetchedLastSeq = typeof fetched.last_seen_hint_seq === "number" ? fetched.last_seen_hint_seq : typeof fetched.last_hint_seq === "number" ? fetched.last_hint_seq : void 0;
+  if (typeof fetchedLastSeq === "number") lastSeenHintSeq = Math.max(lastSeenHintSeq ?? 0, fetchedLastSeq);
+  store.writeSession({
+    coreSessionId,
+    ...typeof lastSeenHintSeq === "number" ? { lastSeenHintSeq } : {}
+  });
+  output.push(lifecycle(identity, fetched.hints.length > 0 ? "handoff_pending" : "listening_idle", now));
+  return output;
+}
+async function maybeRunWakeAdapter(input) {
+  if (!input.wakeAdapter) return;
+  const wakeInput = wakeAttemptInput({
+    identity: input.identity,
+    hint: input.hint,
+    attemptId: input.attemptId,
+    runtimeSession: input.runtimeSession,
+    now: input.now
+  });
+  const event = await wakeAdapterEvent(input.wakeAdapter, wakeInput);
+  input.store.appendProof(event);
+  input.output.push(event);
+}
+function wakeAttemptInput(input) {
+  return {
+    eventId: `event_${randomUUID()}`,
+    attemptId: input.attemptId,
+    messageId: wakeHintMessageId(input.hint),
+    agentId: input.identity.agentId,
+    profile: input.identity.profileSlug,
+    coreSessionId: input.identity.coreSessionId,
+    adapterInstance: input.identity.adapterInstance,
+    runtimeSession: input.runtimeSession,
+    occurredAt: input.now().toISOString()
+  };
+}
+async function wakeAdapterEvent(wakeAdapter, input) {
+  try {
+    return await wakeAdapter.wake(input);
+  } catch (err) {
+    const reason = err instanceof Error && err.message ? err.message : "Wake adapter failed before producing a proof event";
+    return validateExternalAgentWakeEventEnvelope({
+      ...input,
+      schema: EXTERNAL_AGENT_WAKE_EVENT_SCHEMA,
+      kind: "wake_attempt",
+      outcome: "failed",
+      lifecycleState: "degraded_backoff",
+      failureMeta: { failureClass: "injection_failed" },
+      reason,
+      authority: {
+        source: "wake_adapter",
+        provenance: "adapter_observed"
+      }
+    });
+  }
+}
+function lifecycle(identity, state, now) {
+  return {
+    type: "agent_comms.lifecycle",
+    eventId: `event_${randomUUID()}`,
+    protocolVersion: AGENT_COMMS_PROTOCOL_VERSION,
+    proofSchemaVersion: AGENT_PROOF_SCHEMA_VERSION,
+    timestamp: now().toISOString(),
+    coreSessionId: identity.coreSessionId,
+    agentId: identity.agentId,
+    profile: identity.profileSlug,
+    profileSlug: identity.profileSlug,
+    adapterInstance: identity.adapterInstance,
+    runtimeSession: null,
+    state,
+    lifecycleState: state,
+    source: "slock-agent-bridge",
+    provenance: commsCoreProvenance("comms_core"),
+    commsMode: "spawn-core"
+  };
+}
+function proof(identity, wakeHint, attemptId, level, now) {
+  const id = wakeHintId(wakeHint);
+  const seq = wakeHintSeq(wakeHint) ?? null;
+  return {
+    type: "agent_comms.proof",
+    eventId: `event_${randomUUID()}`,
+    attemptId,
+    protocolVersion: AGENT_COMMS_PROTOCOL_VERSION,
+    proofSchemaVersion: AGENT_PROOF_SCHEMA_VERSION,
+    timestamp: now().toISOString(),
+    coreSessionId: identity.coreSessionId,
+    agentId: identity.agentId,
+    profile: identity.profileSlug,
+    profileSlug: identity.profileSlug,
+    adapterInstance: identity.adapterInstance,
+    runtimeSession: null,
+    lifecycleState: "handoff_pending",
+    source: "slock-agent-bridge",
+    provenance: commsCoreProvenance(level === "server_delivered" ? "server_core" : "comms_core"),
+    wakeHintId: id,
+    seq,
+    proofLevel: level,
+    proof: {
+      level,
+      wakeHintId: id,
+      seq,
+      target: wakeHintTarget(wakeHint),
+      cursorImpact: {
+        wakeDedup: true,
+        deliveryAck: false,
+        modelSeen: false,
+        read: false
+      }
+    }
+  };
+}
+function handoff(identity, wakeHint, attemptId, replay, now) {
+  const id = wakeHintId(wakeHint);
+  const seq = wakeHintSeq(wakeHint) ?? null;
+  return {
+    type: "agent_comms.handoff",
+    eventId: `event_${randomUUID()}`,
+    attemptId,
+    protocolVersion: AGENT_COMMS_PROTOCOL_VERSION,
+    proofSchemaVersion: AGENT_PROOF_SCHEMA_VERSION,
+    timestamp: now().toISOString(),
+    coreSessionId: identity.coreSessionId,
+    agentId: identity.agentId,
+    profile: identity.profileSlug,
+    profileSlug: identity.profileSlug,
+    adapterInstance: identity.adapterInstance,
+    runtimeSession: null,
+    state: "handoff_pending",
+    lifecycleState: "handoff_pending",
+    source: "slock-agent-bridge",
+    provenance: commsCoreProvenance("comms_core"),
+    replay,
+    wakeHintId: id,
+    seq,
+    proofLevel: "harness_accepted",
+    wakeHint: stripContentFields(wakeHint),
+    acceptedProof: {
+      level: "harness_accepted",
+      wakeHintId: id,
+      seq
+    }
+  };
+}
+function commsCoreProvenance(authority) {
+  return {
+    producer: "agent-comms-core",
+    authority,
+    source: "slock-agent-bridge"
+  };
+}
+function readJsonl(filePath) {
+  if (!fs2.existsSync(filePath)) return [];
+  return fs2.readFileSync(filePath, "utf-8").split("\n").map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+}
+function appendJsonl(filePath, value) {
+  fs2.mkdirSync(path4.dirname(filePath), { recursive: true, mode: 448 });
+  fs2.appendFileSync(filePath, `${JSON.stringify(value)}
+`, { mode: 384 });
+}
+function requireProfileSlug(agentContext) {
+  if (!agentContext.profileSlug) {
+    throw new Error("slock agent bridge requires SLOCK_PROFILE / --profile so state is profile-scoped.");
+  }
+  return agentContext.profileSlug;
+}
+function wakeHintKey(wakeHint) {
+  const id = wakeHintId(wakeHint);
+  if (id) return `id:${id}`;
+  const seq = wakeHintSeq(wakeHint);
+  if (typeof seq === "number") return `seq:${seq}`;
+  return `hint:${JSON.stringify(stripContentFields(wakeHint))}`;
+}
+function wakeHintId(wakeHint) {
+  if (typeof wakeHint.hintId === "string" && wakeHint.hintId.length > 0) return wakeHint.hintId;
+  if (typeof wakeHint.hint_id === "string" && wakeHint.hint_id.length > 0) return wakeHint.hint_id;
+  if (typeof wakeHint.eventId === "string" && wakeHint.eventId.length > 0) return wakeHint.eventId;
+  if (typeof wakeHint.event_id === "string" && wakeHint.event_id.length > 0) return wakeHint.event_id;
+  if (typeof wakeHint.id === "string" && wakeHint.id.length > 0) return wakeHint.id;
+  return null;
+}
+function wakeHintMessageId(wakeHint) {
+  if (typeof wakeHint.messageId === "string" && wakeHint.messageId.length > 0) return wakeHint.messageId;
+  if (typeof wakeHint.message_id === "string" && wakeHint.message_id.length > 0) return wakeHint.message_id;
+  const id = wakeHintId(wakeHint);
+  if (id) return id;
+  const seq = wakeHintSeq(wakeHint);
+  if (typeof seq === "number") return `seq:${seq}`;
+  const target = wakeHintTarget(wakeHint);
+  if (target) return `target:${target}`;
+  return `wake-hint:${JSON.stringify(stripContentFields(wakeHint))}`;
+}
+function wakeHintSeq(wakeHint) {
+  if (typeof wakeHint.seq !== "number" || !Number.isInteger(wakeHint.seq) || wakeHint.seq <= 0) return void 0;
+  return wakeHint.seq;
+}
+function wakeHintTarget(wakeHint) {
+  if (typeof wakeHint.target === "string" && wakeHint.target.length > 0) return wakeHint.target;
+  return null;
+}
+function stripContentFields(wakeHint) {
+  const clone2 = { ...wakeHint };
+  delete clone2.content;
+  delete clone2.body;
+  delete clone2.text;
+  delete clone2.message;
+  return clone2;
+}
+function safePathSegment(value) {
+  return value.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 120) || "unknown";
+}
+
+// src/external/claudeCodeWakeAdapter.ts
+var CLAUDE_CODE_CHANNELS_WAKE_PROTOCOL = "claude-code-channels.v0";
+var claudeCodeChannelsWakeManifest = validateExternalRuntimeIntegrationManifest({
+  schema: EXTERNAL_RUNTIME_INTEGRATION_MANIFEST_SCHEMA,
+  runtimeId: "claude",
+  integrationPattern: "external-harness-plugin",
+  commsMode: "spawn-core",
+  commsProtocolVersion: EXTERNAL_AGENT_COMMS_PROTOCOL_VERSION,
+  proofSchemaVersion: EXTERNAL_AGENT_PROOF_SCHEMA_VERSION,
+  minSlockCliVersion: "0.0.3",
+  multiplex: false,
+  agentIsolation: "session-scoped",
+  bridgeLifecycle: {
+    explicitStartOnly: true,
+    oneShotCommandsBridgeIndependent: true,
+    requiresBridgeFailureCodes: ["BRIDGE_NOT_RUNNING", "NO_CORE_SESSION"],
+    autoStartDefault: false
+  },
+  serverApi: {
+    mode: "interim-agent-api-events",
+    deliveryOnly: true,
+    cursorAuthority: "model_seen_only"
+  },
+  wakeAdapter: {
+    kind: "claude-code-channels",
+    protocol: CLAUDE_CODE_CHANNELS_WAKE_PROTOCOL,
+    requiresInteractiveSession: true
+  }
+});
+function createClaudeCodeChannelsWakeAdapter(options = {}) {
+  return {
+    manifest: claudeCodeChannelsWakeManifest,
+    async wake(input) {
+      if (!options.endpointUrl) {
+        return buildClaudeCodeWakeFailedEvent(input, {
+          failureClass: "no_session",
+          reason: "Claude Code Slock channel plugin endpoint is not configured; start Claude Code with the Slock channel plugin and pass its localhost wake endpoint to the bridge."
+        });
+      }
+      const request = options.fetchImpl ?? fetch;
+      let response;
+      try {
+        response = await request(options.endpointUrl, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            ...options.token ? { "x-slock-bridge-token": options.token } : {}
+          },
+          body: JSON.stringify({
+            schema: "slock-claude-code-channel-wake.v1",
+            attemptId: input.attemptId,
+            eventId: input.eventId,
+            messageId: input.messageId,
+            agentId: input.agentId,
+            profile: input.profile,
+            coreSessionId: input.coreSessionId,
+            adapterInstance: input.adapterInstance,
+            occurredAt: input.occurredAt
+          })
+        });
+      } catch (err) {
+        return buildClaudeCodeWakeFailedEvent(input, {
+          failureClass: "no_session",
+          reason: err instanceof Error && err.message ? `Claude Code Slock channel plugin endpoint is unreachable: ${err.message}` : "Claude Code Slock channel plugin endpoint is unreachable"
+        });
+      }
+      const body = await parseWakeResponse(response);
+      if (!response.ok || body.ok === false) {
+        return buildClaudeCodeWakeFailedEvent(input, {
+          failureClass: body.failureClass ?? statusFailureClass(response.status),
+          reason: body.reason ?? `Claude Code Slock channel plugin rejected wake attempt with HTTP ${response.status}`,
+          ...typeof body.retryAfterMs === "number" ? { retryAfterMs: body.retryAfterMs } : {}
+        });
+      }
+      const runtimeSession = body.runtimeSession ?? input.runtimeSession;
+      if (!runtimeSession) {
+        return buildClaudeCodeWakeFailedEvent(input, {
+          failureClass: "protocol_mismatch",
+          reason: "Claude Code Slock channel plugin accepted wake but did not return runtimeSession"
+        });
+      }
+      return buildClaudeCodeWakeInjectedEvent({
+        ...input,
+        runtimeSession
+      });
+    }
+  };
+}
+function buildClaudeCodeWakeInjectedEvent(input) {
+  return validateExternalAgentWakeEventEnvelope({
+    ...input,
+    schema: "slock-external-agent-wake-event.v1",
+    kind: "proof",
+    proofLevel: "wake_injected",
+    outcome: "ok",
+    lifecycleState: "handoff_pending",
+    authority: {
+      source: "wake_adapter",
+      provenance: "adapter_observed"
+    }
+  });
+}
+async function parseWakeResponse(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  if (!contentType.includes("application/json")) return {};
+  try {
+    return await response.json();
+  } catch {
+    return {};
+  }
+}
+function statusFailureClass(status) {
+  if (status === 401 || status === 403) return "auth_revoked";
+  if (status === 409 || status === 429) return "busy";
+  if (status === 426 || status === 501) return "protocol_mismatch";
+  if (status === 404 || status === 410) return "no_session";
+  return "injection_failed";
+}
+function buildClaudeCodeWakeFailedEvent(input, failure) {
+  return validateExternalAgentWakeEventEnvelope({
+    ...input,
+    schema: "slock-external-agent-wake-event.v1",
+    kind: "wake_attempt",
+    outcome: "failed",
+    failureMeta: {
+      failureClass: failure.failureClass,
+      ...failure.retryAfterMs ? { retryAfterMs: failure.retryAfterMs } : {}
+    },
+    reason: failure.reason,
+    lifecycleState: "degraded_backoff",
+    authority: {
+      source: "wake_adapter",
+      provenance: "adapter_observed"
+    }
+  });
+}
+
+// src/commands/agent/bridge.ts
+var agentBridgeCommand = defineCommand(
+  {
+    name: "bridge",
+    description: "Run the explicit long-lived Agent CommsCore bridge for self-hosted runtime wake integrations.",
+    options: [
+      { flags: "--json", description: "Emit newline-delimited JSON protocol events." },
+      { flags: "--once", description: "Run one receive/replay iteration, then exit." },
+      { flags: "--poll-interval-ms <ms>", description: "Polling interval for the long-running bridge loop." },
+      { flags: "--state-dir <path>", description: "Override bridge state directory for tests/debugging." },
+      { flags: "--adapter-instance <id>", description: "Wake adapter instance id for per-agent state partitioning." },
+      { flags: "--limit <n>", description: "Maximum events to pull per iteration." },
+      { flags: "--wake-adapter <kind>", description: "Enable a wake adapter. Supported: claude-code-channels." },
+      { flags: "--claude-channel-endpoint <url>", description: "Localhost wake endpoint exposed by the Slock Claude Code channel plugin." },
+      { flags: "--claude-channel-token <token>", description: "Optional shared token for the Claude Code channel plugin wake endpoint." },
+      { flags: "--runtime-session <id>", description: "Optional runtime session id when the adapter endpoint does not return one." }
+    ]
+  },
+  async (ctx, options) => {
+    const agentContext = ctx.loadAgentContext();
+    if (agentContext.clientMode !== "self-hosted-runner") {
+      throw new CliError({
+        code: "BRIDGE_REQUIRES_PROFILE",
+        message: "slock agent bridge requires a self-hosted profile credential, not daemon-injected runner auth.",
+        suggestedNextAction: "Run it as `slock --profile <slug> agent bridge --json`; create the profile with `slock agent login` if needed."
+      });
+    }
+    const pollIntervalMs = parsePositiveInt(options.pollIntervalMs, 5e3, "poll-interval-ms");
+    const limit = parsePositiveInt(options.limit, 50, "limit");
+    const source = createAgentApiWakeHintSource(ctx.createApiClient(agentContext));
+    const wakeAdapter = createWakeAdapter(options);
+    const emit = (value) => {
+      if (options.json) {
+        writeText(ctx.io, `${JSON.stringify(value)}
+`);
+      }
+    };
+    let replayPending = true;
+    do {
+      const events = await runAgentCommsBridgeOnce({
+        agentContext,
+        source,
+        env: ctx.env,
+        stateDir: options.stateDir,
+        adapterInstance: options.adapterInstance,
+        limit,
+        replayPending,
+        wakeAdapter,
+        runtimeSession: options.runtimeSession ?? null
+      });
+      for (const event of events) emit(event);
+      replayPending = false;
+      if (options.once) break;
+      await sleep(pollIntervalMs);
+    } while (true);
+  }
+);
+function registerAgentBridgeCommand(parent, runtimeOptions) {
+  registerCliCommand(parent, agentBridgeCommand, runtimeOptions);
+}
+function createAgentApiWakeHintSource(client) {
+  return {
+    async fetchWakeHints(input) {
+      const query = new URLSearchParams({
+        since: String(input.since),
+        limit: String(input.limit)
+      });
+      const response = await client.request("GET", `/internal/agent-api/wake-hints?${query.toString()}`);
+      if (!response.ok) {
+        throw new CliError({
+          code: response.status >= 500 ? "SERVER_5XX" : "BRIDGE_WAKE_HINTS_FAILED",
+          message: response.error ?? `HTTP ${response.status}`
+        });
+      }
+      return {
+        hints: response.data?.hints ?? response.data?.wake_hints ?? [],
+        last_seen_hint_seq: response.data?.last_seen_hint_seq ?? response.data?.last_hint_seq ?? null,
+        has_more: response.data?.has_more ?? false
+      };
+    }
+  };
+}
+function parsePositiveInt(raw, fallback, label) {
+  if (raw === void 0) return fallback;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new CliError({
+      code: "INVALID_ARG",
+      message: `--${label} must be a positive integer`
+    });
+  }
+  return parsed;
+}
+function createWakeAdapter(options) {
+  if (!options.wakeAdapter) return void 0;
+  if (options.wakeAdapter !== "claude-code-channels") {
+    throw new CliError({
+      code: "INVALID_ARG",
+      message: "--wake-adapter must be `claude-code-channels`"
+    });
+  }
+  return createClaudeCodeChannelsWakeAdapter({
+    endpointUrl: options.claudeChannelEndpoint,
+    token: options.claudeChannelToken
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 // src/commands/action/prepare.ts
 var ACTION_HEREDOC_DELIMITER = "SLOCKACTION";
 var PrepareActionInputError = class extends Error {
@@ -15867,9 +16892,15 @@ var inboxCheckCommand = defineCommand(
   },
   async (ctx) => {
     const agentContext = ctx.loadAgentContext();
+    if (agentContext.clientMode !== "managed-runner") {
+      throw new CliError({
+        code: "INBOX_CHECK_FAILED",
+        message: "`slock inbox check` is only available inside managed daemon runners.",
+        suggestedNextAction: "Use `slock message check` to drain messages."
+      });
+    }
     const client = ctx.createApiClient(agentContext);
-    const path6 = `/internal/agent/${encodeURIComponent(agentContext.agentId)}/inbox`;
-    const response = await client.request("GET", path6);
+    const response = await client.request("GET", "/internal/agent-api/inbox");
     if (!response.ok) {
       throw new CliError({
         code: response.status >= 500 ? "SERVER_5XX" : "INBOX_CHECK_FAILED",
@@ -16228,17 +17259,17 @@ ${opts.heldAction} Review the bounded context shown here, then choose one path.$
 }
 
 // src/commands/message/_continueDraftState.ts
-import fs2 from "fs";
+import fs3 from "fs";
 import os2 from "os";
-import path4 from "path";
+import path5 from "path";
 var DEFAULT_LOCAL_DRAFT_TTL_MS = 10 * 60 * 1e3;
 function stateFilePath(agentId) {
-  return path4.join(process.env.SLOCK_CLI_DRAFT_STATE_DIR ?? os2.tmpdir(), "slock-cli-attested-send", agentId, "continue-state.json");
+  return path5.join(process.env.SLOCK_CLI_DRAFT_STATE_DIR ?? os2.tmpdir(), "slock-cli-attested-send", agentId, "continue-state.json");
 }
 function readState(agentId) {
   const filePath = stateFilePath(agentId);
   try {
-    const raw = fs2.readFileSync(filePath, "utf8");
+    const raw = fs3.readFileSync(filePath, "utf8");
     const parsed = JSON.parse(raw);
     return typeof parsed === "object" && parsed ? parsed : {};
   } catch {
@@ -16247,8 +17278,8 @@ function readState(agentId) {
 }
 function writeState(agentId, state) {
   const filePath = stateFilePath(agentId);
-  fs2.mkdirSync(path4.dirname(filePath), { recursive: true });
-  fs2.writeFileSync(filePath, JSON.stringify(state), "utf8");
+  fs3.mkdirSync(path5.dirname(filePath), { recursive: true });
+  fs3.writeFileSync(filePath, JSON.stringify(state), "utf8");
 }
 function getSavedDraft(agentId, target) {
   const state = readState(agentId);
@@ -16544,8 +17575,8 @@ async function drainInbox(ctx, opts, client = new ApiClient(ctx)) {
   const query = [];
   if (opts.block) query.push("block=true");
   if (opts.block && opts.timeoutMs !== void 0) query.push(`timeout=${opts.timeoutMs}`);
-  const path6 = query.length > 0 ? `${agentPath}/receive?${query.join("&")}` : `${agentPath}/receive`;
-  const res = await client.request("GET", path6);
+  const path7 = query.length > 0 ? `${agentPath}/receive?${query.join("&")}` : `${agentPath}/receive`;
+  const res = await client.request("GET", path7);
   if (!res.ok) {
     throw new CliError({
       code: res.status >= 500 ? "SERVER_5XX" : failCode,
@@ -16587,7 +17618,7 @@ function registerCheckCommand(parent, runtimeOptions) {
 }
 
 // src/commands/message/read.ts
-function parsePositiveInt(name, raw) {
+function parsePositiveInt2(name, raw) {
   if (raw === void 0) return void 0;
   const n = Number(raw);
   if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0) {
@@ -16641,7 +17672,7 @@ function validateReadOpts(opts) {
       message: "--channel is required"
     });
   }
-  const limit = parsePositiveInt("limit", opts.limit);
+  const limit = parsePositiveInt2("limit", opts.limit);
   const before = opts.before?.trim();
   const after = opts.after?.trim();
   return {
@@ -16715,7 +17746,7 @@ function normalizeMemberHandleRef(raw) {
   }
   return handle;
 }
-function parsePositiveInt2(name, raw) {
+function parsePositiveInt3(name, raw) {
   if (raw === void 0) return void 0;
   const n = Number(raw);
   if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0) {
@@ -16740,7 +17771,7 @@ function normalizeSearchOpts(opts) {
       message: `--sort must be "relevance" or "recent"; got ${opts.sort}`
     });
   }
-  const limit = parsePositiveInt2("limit", opts.limit);
+  const limit = parsePositiveInt3("limit", opts.limit);
   return {
     query,
     ...opts.channel ? { channel: opts.channel } : {},
@@ -17989,9 +19020,9 @@ function registerIntegrationLoginCommand(parent, runtimeOptions = {}) {
 }
 
 // src/commands/integration/manifest.ts
-import fs3 from "fs";
+import fs4 from "fs";
 import os3 from "os";
-import path5 from "path";
+import path6 from "path";
 var AGENT_MANIFEST_MAX_BYTES = 64 * 1024;
 var AgentManifestFetchError = class extends Error {
   constructor(message, status) {
@@ -18114,8 +19145,8 @@ function sanitizePathSegment(value) {
   return segment || "service";
 }
 function resolveSlockHome(env) {
-  if (env.SLOCK_HOME?.trim()) return path5.resolve(env.SLOCK_HOME);
-  return path5.join(env.HOME ?? os3.homedir(), ".slock");
+  if (env.SLOCK_HOME?.trim()) return path6.resolve(env.SLOCK_HOME);
+  return path6.join(env.HOME ?? os3.homedir(), ".slock");
 }
 function buildLocalCliProfileEnv(input) {
   if (input.manifest.execution.mode !== "local_cli" || !input.manifest.execution.command) {
@@ -18128,15 +19159,15 @@ function buildLocalCliProfileEnv(input) {
     throw new Error("manifest must set credential_boundary.forbid_user_home=true for local_cli isolation");
   }
   const root = resolveSlockHome(input.env ?? process.env);
-  const profileHome = path5.join(
+  const profileHome = path6.join(
     root,
     "integration-profiles",
     sanitizePathSegment(input.ctx.serverId ?? "server"),
     sanitizePathSegment(input.ctx.agentId),
     sanitizePathSegment(input.serviceId)
   );
-  fs3.mkdirSync(profileHome, { recursive: true, mode: 448 });
-  fs3.chmodSync(profileHome, 448);
+  fs4.mkdirSync(profileHome, { recursive: true, mode: 448 });
+  fs4.chmodSync(profileHome, 448);
   return {
     serviceId: input.serviceId,
     command: input.manifest.execution.command,
@@ -18145,10 +19176,10 @@ function buildLocalCliProfileEnv(input) {
       SLOCK_INTEGRATION_SERVICE: input.serviceId,
       SLOCK_INTEGRATION_PROFILE_HOME: profileHome,
       HOME: profileHome,
-      XDG_CONFIG_HOME: path5.join(profileHome, ".config"),
-      XDG_CACHE_HOME: path5.join(profileHome, ".cache"),
-      XDG_DATA_HOME: path5.join(profileHome, ".local", "share"),
-      XDG_STATE_HOME: path5.join(profileHome, ".local", "state")
+      XDG_CONFIG_HOME: path6.join(profileHome, ".config"),
+      XDG_CACHE_HOME: path6.join(profileHome, ".cache"),
+      XDG_DATA_HOME: path6.join(profileHome, ".local", "share"),
+      XDG_STATE_HOME: path6.join(profileHome, ".local", "state")
     }
   };
 }
@@ -18752,6 +19783,7 @@ registerWhoamiCommand(authCmd);
 var agentCmd = program.command("agent").description("Self-managed agent onboarding (device-code login \u2192 sk_agent_* mint \u2192 ~/.slock/profiles/<slug>/credential.json)");
 registerAgentLoginCommand(agentCmd);
 registerAgentListCommand(agentCmd);
+registerAgentBridgeCommand(agentCmd);
 var channelCmd = program.command("channel").description("Channel membership operations");
 registerChannelMembersCommand(channelCmd);
 registerChannelJoinCommand(channelCmd);