commonswarm 0.1.56 → 0.1.58

package/cswarm.cjs

@@ -13512,6 +13512,7 @@ __export(cli_exports, {
   listenerFailureMessage: () => listenerFailureMessage,
   listenerHostLimits: () => listenerHostLimits,
   listenerPermissionMode: () => listenerPermissionMode,
+  listenerPollIntervalMs: () => listenerPollIntervalMs,
   listenerProviderInstallEvidence: () => listenerProviderInstallEvidence,
   listenerRouteConfiguration: () => listenerRouteConfiguration,
   listenerStatusJson: () => listenerStatusJson,
@@ -13528,10 +13529,10 @@ module.exports = __toCommonJS(cli_exports);
 var import_node_crypto22 = require("node:crypto");
 var import_node_child_process9 = require("node:child_process");
 var import_node_fs7 = require("node:fs");
-var import_promises12 = require("node:fs/promises");
+var import_promises13 = require("node:fs/promises");
 var import_node_os10 = require("node:os");
 var import_node_path21 = require("node:path");
-var import_promises13 = require("node:readline/promises");
+var import_promises14 = require("node:readline/promises");
 
 // src/protocol/events.ts
 var SCHEMA_VERSION = 1;
@@ -26174,7 +26175,7 @@ var src_default = Postgres;
 function Postgres(a, b2) {
   const options = parseOptions(a, b2), subscribe = options.no_subscribe || Subscribe(Postgres, { ...options });
   let ending = false;
-  const queries = queue_default(), connecting = queue_default(), reserved = queue_default(), closed = queue_default(), ended = queue_default(), open6 = queue_default(), busy = queue_default(), full = queue_default(), queues = { connecting, reserved, closed, ended, open: open6, busy, full };
+  const queries = queue_default(), connecting = queue_default(), reserved = queue_default(), closed = queue_default(), ended = queue_default(), open7 = queue_default(), busy = queue_default(), full = queue_default(), queues = { connecting, reserved, closed, ended, open: open7, busy, full };
   const connections = [...Array(options.max)].map(() => connection_default(options, queues, { onopen, onend, onclose }));
   const sql = Sql(handler);
   Object.assign(sql, {
@@ -26287,7 +26288,7 @@ function Postgres(a, b2) {
   }
   async function reserve() {
     const queue = queue_default();
-    const c = open6.length ? open6.shift() : await new Promise((resolve3, reject) => {
+    const c = open7.length ? open7.shift() : await new Promise((resolve3, reject) => {
       const query = { reserve: resolve3, reject };
       queries.push(query);
       closed.length && connect(closed.shift(), query);
@@ -26360,7 +26361,7 @@ function Postgres(a, b2) {
     c.queue.remove(c);
     queue.push(c);
     c.queue = queue;
-    queue === open6 ? c.idleTimer.start() : c.idleTimer.cancel();
+    queue === open7 ? c.idleTimer.start() : c.idleTimer.cancel();
     return c;
   }
   function json(x) {
@@ -26374,8 +26375,8 @@ function Postgres(a, b2) {
   function handler(query) {
     if (ending)
       return query.reject(Errors.connection("CONNECTION_ENDED", options, options));
-    if (open6.length)
-      return go(open6.shift(), query);
+    if (open7.length)
+      return go(open7.shift(), query);
     if (closed.length)
       return connect(closed.shift(), query);
     busy.length ? go(busy.shift(), query) : queries.push(query);
@@ -26420,7 +26421,7 @@ function Postgres(a, b2) {
   }
   function onopen(c) {
     if (queries.length === 0)
-      return move(c, open6);
+      return move(c, open7);
     let max = Math.ceil(queries.length / (connecting.length + 1)), ready = true;
     while (ready && queries.length && max-- > 0) {
       const query = queries.shift();
@@ -27125,6 +27126,34 @@ function describeRenewalGrant(grant) {
   return lines;
 }
 
+// src/cloud/wake.ts
+var WAKE_EVENT = "wake";
+var WAKE_TOPIC_RE = /^cswarm-wake:[A-Za-z0-9_-]{43}$/;
+function isWakeTopic(value) {
+  return WAKE_TOPIC_RE.test(value);
+}
+var WakeHintError = class extends Error {
+  code = "malformed_wake";
+  constructor(message) {
+    super(message);
+    this.name = "WakeHintError";
+  }
+};
+function parseOptionalWakeHint(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new WakeHintError("wake hint must be an object");
+  }
+  const row = value;
+  if (typeof row.topic !== "string" || !isWakeTopic(row.topic)) {
+    throw new WakeHintError("wake hint topic is malformed");
+  }
+  if (row.event !== WAKE_EVENT) {
+    throw new WakeHintError("wake hint event is malformed");
+  }
+  return { topic: row.topic, event: WAKE_EVENT };
+}
+
 // src/cloud/renewal.ts
 var AGENT_TOKEN_DEFAULT_TTL_MS2 = 60 * 60 * 1e3;
 var AGENT_TOKEN_MAX_TTL_MS2 = 8 * 60 * 60 * 1e3;
@@ -27426,6 +27455,16 @@ async function requestSuccessor(options) {
       "The deployment issued a successor credential that lasts longer than eight hours. cswarm refused to store it. Agent credentials stay short on purpose; renewal is what makes that survivable."
     );
   }
+  let wake;
+  try {
+    wake = parseOptionalWakeHint(body.wake);
+  } catch {
+    throw new RenewalRefused(
+      response.status,
+      "malformed_wake",
+      "The deployment returned a successor credential with a malformed wake hint. It was not stored."
+    );
+  }
   return {
     token,
     tokenId: tokenId.toLowerCase(),
@@ -27434,7 +27473,8 @@ async function requestSuccessor(options) {
     issuedAt,
     expiresAt,
     horizonExpiresAt: timestamp(body.horizon_expires_at),
-    successorsRemaining: count(body.successors_remaining)
+    successorsRemaining: count(body.successors_remaining),
+    ...wake === void 0 ? {} : { wake }
   };
 }
 var AgentCredentialSession = class _AgentCredentialSession {
@@ -30009,6 +30049,12 @@ async function agentSignalPage(target2, credential, query, options, allowLegacyC
   const rawRows = body.signals;
   const parsedRows = parseSignalRows(rawRows, parseOptions2);
   const ascending = query.ascending === true || query.after !== void 0;
+  let wake;
+  try {
+    wake = parseOptionalWakeHint(body.wake);
+  } catch {
+    throw plainMalformedError("signal read returned a malformed wake hint");
+  }
   return {
     signals: sortSignals(
       rowsAfterCursor(parsedRows.signals, query.after),
@@ -30019,7 +30065,8 @@ async function agentSignalPage(target2, credential, query, options, allowLegacyC
     rawCount: rawRows.length,
     nextCursor: rawRows.length === 0 ? null : cursorFromUnknown(rawRows[rawRows.length - 1]),
     malformedRows: parsedRows.malformedRows,
-    pendingDeliveryCount
+    pendingDeliveryCount,
+    ...wake === void 0 ? {} : { wake }
   };
 }
 function parseAgentMemberRow(value) {
@@ -30720,10 +30767,86 @@ async function runInboxFollow(options) {
 // src/cloud/arrival-watch.ts
 var import_node_os4 = require("node:os");
 var import_node_path4 = require("node:path");
+var import_promises4 = require("node:fs/promises");
+
+// src/cloud/idle-poll.ts
+var IDLE_POLL_DEFAULT_MS = 15e3;
+var IDLE_POLL_MAX_MS = 6e4;
+var IDLE_POLL_MIN_MS = 1e3;
+var ARRIVAL_WATCH_POLL_MS = IDLE_POLL_MAX_MS;
+var DURATION_RE = /^([1-9]\d*)(s|m)$/;
+function formatIdlePollDuration(ms) {
+  if (!Number.isSafeInteger(ms) || ms <= 0) {
+    throw new Error("idle poll duration must be a positive number of milliseconds");
+  }
+  if (ms % 6e4 === 0) return `${ms / 6e4}m`;
+  if (ms % 1e3 === 0) return `${ms / 1e3}s`;
+  throw new Error("idle poll duration must be a whole number of seconds");
+}
+var IDLE_POLL_MIN_LABEL = formatIdlePollDuration(IDLE_POLL_MIN_MS);
+var IDLE_POLL_DEFAULT_LABEL = formatIdlePollDuration(IDLE_POLL_DEFAULT_MS);
+var IDLE_POLL_MAX_LABEL = formatIdlePollDuration(IDLE_POLL_MAX_MS);
+function idlePollDurationExamples() {
+  const midMs = Math.min(IDLE_POLL_MAX_MS, IDLE_POLL_DEFAULT_MS * 2);
+  const labels = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const ms of [IDLE_POLL_DEFAULT_MS, midMs, IDLE_POLL_MAX_MS]) {
+    const label = formatIdlePollDuration(ms);
+    if (seen.has(label)) continue;
+    seen.add(label);
+    labels.push(label);
+  }
+  return labels;
+}
+var IDLE_POLL_DURATION_EXAMPLES = idlePollDurationExamples();
+function idlePollDurationHint() {
+  return idlePollDurationExamples().join(", ");
+}
+function idlePollBoundSentence() {
+  return `between ${IDLE_POLL_MIN_LABEL} and ${IDLE_POLL_MAX_LABEL}`;
+}
+function parseIdlePollIntervalMs(value, defaultMs = IDLE_POLL_DEFAULT_MS) {
+  if (value === void 0) return defaultMs;
+  const match = DURATION_RE.exec(value);
+  if (!match) {
+    throw new Error(
+      `--poll-interval must be a duration such as ${idlePollDurationHint()}`
+    );
+  }
+  const unit = match[2] === "s" ? 1e3 : 6e4;
+  const milliseconds = Number(match[1]) * unit;
+  if (!Number.isSafeInteger(milliseconds) || milliseconds < IDLE_POLL_MIN_MS || milliseconds > IDLE_POLL_MAX_MS) {
+    throw new Error(`--poll-interval must be ${idlePollBoundSentence()}`);
+  }
+  return milliseconds;
+}
+function nextIdlePollMs(baseMs, emptyStreak, maxMs = IDLE_POLL_MAX_MS) {
+  if (!Number.isSafeInteger(baseMs) || baseMs < 0) {
+    throw new Error("idle poll base must be a non-negative number of milliseconds");
+  }
+  if (!Number.isSafeInteger(emptyStreak) || emptyStreak < 0) {
+    throw new Error("idle poll empty streak must be a non-negative integer");
+  }
+  if (!Number.isSafeInteger(maxMs) || maxMs < 0) {
+    throw new Error("idle poll max must be a non-negative number of milliseconds");
+  }
+  const shift = Math.min(emptyStreak, 16);
+  const grown = baseMs * 2 ** shift;
+  return Math.min(maxMs, grown);
+}
+function idlePollStatusSentence(currentMs) {
+  return `Current idle poll interval: ${formatIdlePollDuration(currentMs)}.`;
+}
+function idlePollHelpSentence(defaultMs = IDLE_POLL_DEFAULT_MS) {
+  return `listen start --poll-interval sets how long the listener waits after an empty claim (default ${formatIdlePollDuration(defaultMs)}). A whole number plus s or m (for example ${idlePollDurationHint()}), ${idlePollBoundSentence()}. Empty polls double that wait up to ${IDLE_POLL_MAX_LABEL}; any delivery resets it to the configured interval.`;
+}
+
+// src/cloud/arrival-watch.ts
 var UUID_RE11 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 var CURSOR_MAX_BYTES = 4 * 1024;
 var ARRIVAL_SNIPPET_MAX = 180;
-var ARRIVAL_WATCH_POLL_MS = 25e3;
+var WATCH_LOCK_MAX_BYTES = 512;
+var ARRIVAL_WATCH_POLL_MS2 = ARRIVAL_WATCH_POLL_MS;
 var ARRIVAL_RETRY_NOTICE_THRESHOLD_MS = 6e4;
 var EXIT_NOTIFY_ORPHANED = 74;
 var NotifyStdoutClosedError = class extends Error {
@@ -30776,6 +30899,94 @@ function arrivalCursorPath(target2, workspaceId2, principalId, root = stateRoot(
     `${target2.profileId}-${workspaceId2.toLowerCase()}-${principalId.toLowerCase()}.json`
   );
 }
+function arrivalWatchLockPath(target2, workspaceId2, principalId, root = stateRoot()) {
+  return arrivalCursorPath(target2, workspaceId2, principalId, root).replace(
+    /\.json$/u,
+    ".lock"
+  );
+}
+function arrivalWatchAlreadyRunningSentence(pid) {
+  return `inbox --notify is already running for this agent as pid ${pid}.`;
+}
+var ArrivalWatchAlreadyRunningError = class extends Error {
+  code = "notify_already_running";
+  pid;
+  constructor(pid) {
+    super(arrivalWatchAlreadyRunningSentence(pid));
+    this.name = "ArrivalWatchAlreadyRunningError";
+    this.pid = pid;
+  }
+};
+function pidIsAlive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+function parseWatchLock(raw) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const row = value;
+  if (row.version !== 1 || !Number.isSafeInteger(row.pid) || row.pid <= 0) {
+    return null;
+  }
+  return { pid: row.pid };
+}
+async function acquireArrivalWatchLock(path, pid = process.pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) {
+    throw new Error("arrival watch lock pid must be a positive integer");
+  }
+  await ensureSecureStateDirectory((0, import_node_path4.dirname)(path));
+  const payload = `${JSON.stringify({ version: 1, pid })}
+`;
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      const handle = await (0, import_promises4.open)(path, "wx", 384);
+      try {
+        await handle.writeFile(payload, "utf8");
+      } finally {
+        await handle.close();
+      }
+      return;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+    let existing = null;
+    try {
+      const raw = await (0, import_promises4.readFile)(path, "utf8");
+      if (Buffer.byteLength(raw, "utf8") <= WATCH_LOCK_MAX_BYTES) {
+        existing = parseWatchLock(raw);
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      continue;
+    }
+    if (existing !== null && pidIsAlive(existing.pid)) {
+      throw new ArrivalWatchAlreadyRunningError(existing.pid);
+    }
+    await (0, import_promises4.unlink)(path).catch(() => void 0);
+  }
+  throw new Error("arrival watch lock could not be acquired");
+}
+async function releaseArrivalWatchLock(path, pid = process.pid) {
+  try {
+    const raw = await (0, import_promises4.readFile)(path, "utf8");
+    const existing = parseWatchLock(raw);
+    if (existing === null || existing.pid !== pid) return;
+    await (0, import_promises4.unlink)(path);
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+}
 function parseCursor(raw, workspaceId2, principalId) {
   let value;
   try {
@@ -30889,8 +31100,9 @@ function assertCursorPage(page) {
   }
 }
 async function runArrivalWatch(options) {
-  const pollMs = options.pollMs ?? ARRIVAL_WATCH_POLL_MS;
+  const pollMs = options.pollMs ?? ARRIVAL_WATCH_POLL_MS2;
   const random = options.random ?? Math.random;
+  let emptyIdleStreak = 0;
   let cursor = await options.store.read();
   let baseline = cursor === void 0;
   let attempt = 0;
@@ -30915,6 +31127,12 @@ async function runArrivalWatch(options) {
       timer2 = setTimeout(finish, ms);
     });
   };
+  const idleWait = async (hadDelivery) => {
+    if (hadDelivery) emptyIdleStreak = 0;
+    const intervalMs = nextIdlePollMs(pollMs, emptyIdleStreak, IDLE_POLL_MAX_MS);
+    if (!hadDelivery) emptyIdleStreak += 1;
+    await wait(intervalMs);
+  };
   while (!cancelled()) {
     try {
       const page = await options.readPage({
@@ -30940,7 +31158,7 @@ async function runArrivalWatch(options) {
         await options.store.write(cursor);
         baseline = false;
         if (cancelled()) break;
-        await wait(pollMs);
+        await idleWait(false);
         continue;
       }
       const emittedSignals = [];
@@ -30956,7 +31174,8 @@ async function runArrivalWatch(options) {
       }
       if (cancelled()) break;
       const fullPage = page.rawCount >= SIGNAL_FOLLOW_PAGE_LIMIT;
-      await wait(fullPage ? 0 : pollMs);
+      if (fullPage) await wait(0);
+      else await idleWait(emittedSignals.length > 0);
     } catch (error) {
       if (cancelled()) break;
       const http = followHttpDetails(error);
@@ -31903,11 +32122,18 @@ function parseClaimSuccess(body, expected, now) {
       "delivery claim response returned more deliveries than its pending count"
     );
   }
+  let wake;
+  try {
+    wake = parseOptionalWakeHint(row.wake);
+  } catch {
+    throw new DeliveryProtocolError("delivery claim response wake field is malformed");
+  }
   return {
     capabilities,
     deliveries,
     pendingDeliveryCount,
-    terminalDeliveryFailureCount
+    terminalDeliveryFailureCount,
+    ...wake === void 0 ? {} : { wake }
   };
 }
 function parseAckSuccess(body, expected) {
@@ -32121,7 +32347,8 @@ var DeliveryCommandClient = class {
       capabilities: parsed.capabilities,
       deliveries: parsed.deliveries,
       pendingDeliveryCount: parsed.pendingDeliveryCount,
-      terminalDeliveryFailureCount: parsed.terminalDeliveryFailureCount
+      terminalDeliveryFailureCount: parsed.terminalDeliveryFailureCount,
+      ...parsed.wake === void 0 ? {} : { wake: parsed.wake }
     };
   }
   /** Acknowledge one leased delivery with an exact terminal outcome. */
@@ -32288,12 +32515,13 @@ var CONTROL_AND_SEPARATOR_STRIP_RE = new RegExp(
   "[\\u0000-\\u0008\\u000b-\\u001f\\u007f-\\u009f" + EXOTIC_SEPARATORS + "]",
   "g"
 );
-var CREDENTIAL_PREFIX_RE = new RegExp(
-  `swm_(?:agt|inv|cap)_[^${SEPARATOR_CLASS_SOURCE}]*`,
-  "gi"
+var SECRET_SHAPE_RE = new RegExp(
+  `swm_(?:agt|inv|cap)_[^${SEPARATOR_CLASS_SOURCE}]*|cswarm-wake:[A-Za-z0-9_-]{43}`,
+  "i"
 );
+var SECRET_SHAPE_GLOBAL_RE = new RegExp(SECRET_SHAPE_RE.source, "gi");
 function redactCredentialText(value) {
-  return value.replace(ANSI_ESCAPE_GLOBAL_RE2, "").replace(CONTROL_AND_SEPARATOR_STRIP_RE, "").replace(CREDENTIAL_PREFIX_RE, "[redacted-credential]");
+  return value.replace(ANSI_ESCAPE_GLOBAL_RE2, "").replace(CONTROL_AND_SEPARATOR_STRIP_RE, "").replace(SECRET_SHAPE_GLOBAL_RE, "[redacted-credential]");
 }
 
 // src/host/stderr-tail.ts
@@ -32368,7 +32596,7 @@ function attachStderrTailExitObserver(child, onStderrTail) {
 
 // src/host/opencode.ts
 var import_node_fs3 = require("node:fs");
-var import_promises4 = require("node:fs/promises");
+var import_promises5 = require("node:fs/promises");
 var import_node_os5 = require("node:os");
 var import_node_path6 = require("node:path");
 
@@ -33712,18 +33940,18 @@ function buildOpenCodeHomeOwner(options) {
 }
 async function writeOpenCodeHomeOwner(home, owner) {
   const path = (0, import_node_path6.join)(home, OPENCODE_HOME_OWNER_FILE);
-  await (0, import_promises4.writeFile)(path, `${JSON.stringify(owner)}
+  await (0, import_promises5.writeFile)(path, `${JSON.stringify(owner)}
 `, {
     flag: "wx",
     mode: 384
   });
-  await (0, import_promises4.chmod)(path, 384);
+  await (0, import_promises5.chmod)(path, 384);
 }
 async function readOpenCodeHomeOwner(home) {
   const path = (0, import_node_path6.join)(home, OPENCODE_HOME_OWNER_FILE);
   let raw;
   try {
-    raw = await (0, import_promises4.readFile)(path, "utf8");
+    raw = await (0, import_promises5.readFile)(path, "utf8");
   } catch {
     return null;
   }
@@ -33744,10 +33972,10 @@ async function releaseOpenCodeHome(home, instanceId) {
     return;
   }
   try {
-    await (0, import_promises4.rm)(home, { recursive: true, force: true });
+    await (0, import_promises5.rm)(home, { recursive: true, force: true });
   } catch {
-    await (0, import_promises4.chmod)(home, 448);
-    await (0, import_promises4.rm)(home, { recursive: true, force: true });
+    await (0, import_promises5.chmod)(home, 448);
+    await (0, import_promises5.rm)(home, { recursive: true, force: true });
   }
 }
 function parseOpenCodeVersionOutput(stdout) {
@@ -33815,7 +34043,7 @@ function buildOpenCodeSafeConfigJson(options) {
 async function readValidatedOpenCodeAuth(sourceAuthPath, options) {
   let info;
   try {
-    info = await (0, import_promises4.lstat)(sourceAuthPath);
+    info = await (0, import_promises5.lstat)(sourceAuthPath);
   } catch (error) {
     if (error.code === "ENOENT") {
       if (options?.allowMissing) return null;
@@ -33844,7 +34072,7 @@ async function readValidatedOpenCodeAuth(sourceAuthPath, options) {
       "OpenCode auth file exceeds the listener safety bound"
     );
   }
-  const raw = await (0, import_promises4.readFile)(sourceAuthPath);
+  const raw = await (0, import_promises5.readFile)(sourceAuthPath);
   if (raw.byteLength > MAX_OPENCODE_AUTH_BYTES) {
     throw new AcpHostError(
       "opencode_auth_too_large",
@@ -33870,53 +34098,53 @@ function resolveOpenCodeAuthSourcePath(parent = process.env) {
   return (0, import_node_path6.join)(home, ".local", "share", "opencode", "auth.json");
 }
 async function prepareOpenCodeIsolatedHome(options) {
-  const home = options.home ?? await (0, import_promises4.mkdtemp)((0, import_node_path6.join)((0, import_node_os5.tmpdir)(), OPENCODE_HOME_PREFIX));
+  const home = options.home ?? await (0, import_promises5.mkdtemp)((0, import_node_path6.join)((0, import_node_os5.tmpdir)(), OPENCODE_HOME_PREFIX));
   if (!(0, import_node_path6.isAbsolute)(home)) {
     throw new AcpHostError(
       "isolated_home_invalid",
       "isolated OpenCode home must be absolute"
     );
   }
-  await (0, import_promises4.chmod)(home, 448);
+  await (0, import_promises5.chmod)(home, 448);
   try {
     const xdgConfig = (0, import_node_path6.join)(home, "xdg-config");
     const xdgData = (0, import_node_path6.join)(home, "xdg-data");
     const xdgCache = (0, import_node_path6.join)(home, "xdg-cache");
     const xdgState = (0, import_node_path6.join)(home, "xdg-state");
     for (const dir of [xdgConfig, xdgData, xdgCache, xdgState]) {
-      await (0, import_promises4.mkdir)(dir, { recursive: true, mode: 448 });
-      await (0, import_promises4.chmod)(dir, 448);
+      await (0, import_promises5.mkdir)(dir, { recursive: true, mode: 448 });
+      await (0, import_promises5.chmod)(dir, 448);
     }
     const configDir = (0, import_node_path6.join)(xdgConfig, "opencode");
     const dataDir = (0, import_node_path6.join)(xdgData, "opencode");
-    await (0, import_promises4.mkdir)(configDir, { recursive: true, mode: 448 });
-    await (0, import_promises4.mkdir)(dataDir, { recursive: true, mode: 448 });
-    await (0, import_promises4.chmod)(configDir, 448);
-    await (0, import_promises4.chmod)(dataDir, 448);
+    await (0, import_promises5.mkdir)(configDir, { recursive: true, mode: 448 });
+    await (0, import_promises5.mkdir)(dataDir, { recursive: true, mode: 448 });
+    await (0, import_promises5.chmod)(configDir, 448);
+    await (0, import_promises5.chmod)(dataDir, 448);
     const configPath = (0, import_node_path6.join)(configDir, "opencode.json");
-    await (0, import_promises4.writeFile)(
+    await (0, import_promises5.writeFile)(
       configPath,
       buildOpenCodeSafeConfigJson(
         options.model ? { model: options.model } : void 0
       ),
       { flag: "wx", mode: 384 }
     );
-    await (0, import_promises4.chmod)(configPath, 384);
+    await (0, import_promises5.chmod)(configPath, 384);
     const sourceAuth = resolveOpenCodeAuthSourcePath(options.env ?? process.env);
     const authBytes = await readValidatedOpenCodeAuth(sourceAuth, {
       allowMissing: options.allowMissingAuth === true
     });
     if (authBytes) {
       const destAuth = (0, import_node_path6.join)(dataDir, "auth.json");
-      await (0, import_promises4.writeFile)(destAuth, authBytes, { flag: "wx", mode: 384 });
-      await (0, import_promises4.chmod)(destAuth, 384);
+      await (0, import_promises5.writeFile)(destAuth, authBytes, { flag: "wx", mode: 384 });
+      await (0, import_promises5.chmod)(destAuth, 384);
     }
     const owner = options.owner ?? buildOpenCodeHomeOwner({ role: "ephemeral" });
     await writeOpenCodeHomeOwner(home, owner);
     return home;
   } catch (error) {
     if (!options.home) {
-      await (0, import_promises4.rm)(home, { recursive: true, force: true }).catch(() => void 0);
+      await (0, import_promises5.rm)(home, { recursive: true, force: true }).catch(() => void 0);
     }
     throw error;
   }
@@ -33941,10 +34169,10 @@ function buildOpenCodeChildEnv(parent, home) {
   };
 }
 async function assertOpenCodeEffectiveConfig(options) {
-  const hostile = await (0, import_promises4.mkdtemp)((0, import_node_path6.join)((0, import_node_os5.tmpdir)(), "cswarm-opencode-hostile-"));
+  const hostile = await (0, import_promises5.mkdtemp)((0, import_node_path6.join)((0, import_node_os5.tmpdir)(), "cswarm-opencode-hostile-"));
   try {
-    await (0, import_promises4.chmod)(hostile, 448);
-    await (0, import_promises4.writeFile)(
+    await (0, import_promises5.chmod)(hostile, 448);
+    await (0, import_promises5.writeFile)(
       (0, import_node_path6.join)(hostile, "opencode.json"),
       `${JSON.stringify({
         permission: {
@@ -34007,7 +34235,7 @@ async function assertOpenCodeEffectiveConfig(options) {
     assertForcedAskPermissionMap(map);
     return { permission: map };
   } finally {
-    await (0, import_promises4.rm)(hostile, { recursive: true, force: true }).catch(() => void 0);
+    await (0, import_promises5.rm)(hostile, { recursive: true, force: true }).catch(() => void 0);
   }
 }
 function assertForcedAskPermissionMap(map) {
@@ -34058,7 +34286,7 @@ async function sweepStaleOpenCodeHomes(options) {
   let removed = 0;
   let entries;
   try {
-    entries = await (0, import_promises4.readdir)(root);
+    entries = await (0, import_promises5.readdir)(root);
   } catch {
     return 0;
   }
@@ -34066,7 +34294,7 @@ async function sweepStaleOpenCodeHomes(options) {
     if (!name.startsWith(OPENCODE_HOME_PREFIX)) continue;
     const full = (0, import_node_path6.join)(root, name);
     try {
-      const st = await (0, import_promises4.lstat)(full);
+      const st = await (0, import_promises5.lstat)(full);
       if (!st.isDirectory() || st.isSymbolicLink()) continue;
       if (selfUid !== null && typeof st.uid === "number" && st.uid !== selfUid) {
         continue;
@@ -34080,12 +34308,12 @@ async function sweepStaleOpenCodeHomes(options) {
         if (alive(owner.pid)) {
           continue;
         }
-        await (0, import_promises4.rm)(full, { recursive: true, force: true });
+        await (0, import_promises5.rm)(full, { recursive: true, force: true });
         removed += 1;
         continue;
       }
       if (now - st.mtimeMs < maxAgeMs) continue;
-      await (0, import_promises4.rm)(full, { recursive: true, force: true });
+      await (0, import_promises5.rm)(full, { recursive: true, force: true });
       removed += 1;
     } catch {
     }
@@ -34146,10 +34374,10 @@ async function openOpenCodeAcpSession(options) {
   const disposeHome = async () => {
     if (createdHome) {
       try {
-        await (0, import_promises4.rm)(home, { recursive: true, force: true });
+        await (0, import_promises5.rm)(home, { recursive: true, force: true });
       } catch {
-        await (0, import_promises4.chmod)(home, 448);
-        await (0, import_promises4.rm)(home, { recursive: true, force: true });
+        await (0, import_promises5.chmod)(home, 448);
+        await (0, import_promises5.rm)(home, { recursive: true, force: true });
       }
     }
   };
@@ -35827,7 +36055,7 @@ var FileListenerEffectStore = class {
 
 // src/listener/grok-model.ts
 var import_node_crypto14 = require("node:crypto");
-var import_promises5 = require("node:fs/promises");
+var import_promises6 = require("node:fs/promises");
 var import_node_os7 = require("node:os");
 var import_node_path11 = require("node:path");
 
@@ -36099,9 +36327,9 @@ var GrokListenerModel = class {
     }
     let sentinelCreated = false;
     try {
-      await (0, import_promises5.lstat)(sentinelPath);
+      await (0, import_promises6.lstat)(sentinelPath);
       sentinelCreated = true;
-      await (0, import_promises5.unlink)(sentinelPath);
+      await (0, import_promises6.unlink)(sentinelPath);
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
     }
@@ -36123,7 +36351,7 @@ var GrokListenerModel = class {
     const sourceAuth = (0, import_node_path11.join)(sourceHome, "auth.json");
     let info;
     try {
-      info = await (0, import_promises5.lstat)(sourceAuth);
+      info = await (0, import_promises6.lstat)(sourceAuth);
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
       throw new AcpHostError(
@@ -36149,7 +36377,7 @@ var GrokListenerModel = class {
         "Grok auth file exceeds the listener safety bound"
       );
     }
-    const raw = await (0, import_promises5.readFile)(sourceAuth);
+    const raw = await (0, import_promises6.readFile)(sourceAuth);
     if (raw.byteLength > MAX_GROK_AUTH_BYTES) {
       throw new AcpHostError(
         "grok_auth_too_large",
@@ -36169,7 +36397,7 @@ var GrokListenerModel = class {
 
 // src/listener/opencode-model.ts
 var import_node_crypto15 = require("node:crypto");
-var import_promises6 = require("node:fs/promises");
+var import_promises7 = require("node:fs/promises");
 var import_node_path12 = require("node:path");
 function asError(error) {
   return error instanceof Error ? error : new Error(String(error));
@@ -36181,8 +36409,8 @@ var OpenCodeListenerModel = class {
     this.openSession = options.open ?? openOpenCodeAcpSession;
     this.prepareHome = options.prepareHome ?? prepareOpenCodeIsolatedHome;
     this.prepareWorkerCwd = options.prepareWorkerCwd ?? (async (home) => {
-      const cwd = await (0, import_promises6.mkdtemp)((0, import_node_path12.join)(home, "canary-cwd-"));
-      await (0, import_promises6.chmod)(cwd, 448);
+      const cwd = await (0, import_promises7.mkdtemp)((0, import_node_path12.join)(home, "canary-cwd-"));
+      await (0, import_promises7.chmod)(cwd, 448);
       return cwd;
     });
     this.permissionMode = options.permissionMode ?? "deny";
@@ -36526,11 +36754,11 @@ var OpenCodeListenerModel = class {
               await closeWorker();
             } catch (error) {
               if (error?.code !== "child_exit_timeout") {
-                await (0, import_promises6.rm)(ownedCanaryCwd, { recursive: true, force: true }).catch(() => void 0);
+                await (0, import_promises7.rm)(ownedCanaryCwd, { recursive: true, force: true }).catch(() => void 0);
               }
               throw error;
             }
-            await (0, import_promises6.rm)(ownedCanaryCwd, { recursive: true, force: true }).catch(() => void 0);
+            await (0, import_promises7.rm)(ownedCanaryCwd, { recursive: true, force: true }).catch(() => void 0);
           })();
           return await closePromise;
         };
@@ -36601,7 +36829,7 @@ var OpenCodeListenerModel = class {
       throw finalErr;
     } finally {
       if (canaryCwd !== null && !canaryCwdOwnedByHandle && !retainCanaryCwd) {
-        await (0, import_promises6.rm)(canaryCwd, { recursive: true, force: true }).catch(() => void 0);
+        await (0, import_promises7.rm)(canaryCwd, { recursive: true, force: true }).catch(() => void 0);
       }
     }
   }
@@ -36609,7 +36837,7 @@ var OpenCodeListenerModel = class {
 
 // src/listener/claude-model.ts
 var import_node_crypto16 = require("node:crypto");
-var import_promises7 = require("node:fs/promises");
+var import_promises8 = require("node:fs/promises");
 var import_node_os8 = require("node:os");
 var import_node_path13 = require("node:path");
 var CLAUDE_CODE_VERSION_REQUIRED_RE = /\bClaude Code (\d+\.\d+\.\d+) does not support this model; version (\d+\.\d+\.\d+) or newer is required\b/;
@@ -36798,9 +37026,9 @@ var ClaudeListenerModel = class {
       canaryError = error;
     } finally {
       try {
-        await (0, import_promises7.lstat)(sentinelPath);
+        await (0, import_promises8.lstat)(sentinelPath);
         sentinelCreated = true;
-        await (0, import_promises7.unlink)(sentinelPath);
+        await (0, import_promises8.unlink)(sentinelPath);
       } catch (error) {
         if (error.code !== "ENOENT") throw error;
       }
@@ -36829,7 +37057,7 @@ var ClaudeListenerModel = class {
 
 // src/listener/codex-model.ts
 var import_node_crypto17 = require("node:crypto");
-var import_promises8 = require("node:fs/promises");
+var import_promises9 = require("node:fs/promises");
 var import_node_os9 = require("node:os");
 var import_node_path14 = require("node:path");
 var CodexListenerClosedDuringOpen = class extends Error {
@@ -36977,11 +37205,11 @@ var CodexListenerModel = class {
     const configuredHome = this.options.env?.HOME;
     const home = configuredHome && (0, import_node_path14.isAbsolute)(configuredHome) ? configuredHome : (0, import_node_os9.homedir)();
     const sentinelDirectory = (0, import_node_path14.join)(home, ".cswarm", "canary");
-    await (0, import_promises8.mkdir)(sentinelDirectory, { recursive: true, mode: 448 });
-    await (0, import_promises8.chmod)(sentinelDirectory, 448);
+    await (0, import_promises9.mkdir)(sentinelDirectory, { recursive: true, mode: 448 });
+    await (0, import_promises9.chmod)(sentinelDirectory, 448);
     const [workerCwd, canaryDirectory] = await Promise.all([
-      (0, import_promises8.realpath)(this.options.cwd),
-      (0, import_promises8.realpath)(sentinelDirectory)
+      (0, import_promises9.realpath)(this.options.cwd),
+      (0, import_promises9.realpath)(sentinelDirectory)
     ]);
     if (pathIsInsideOrEqual(workerCwd, canaryDirectory)) {
       throw new AcpPermissionCanaryError(
@@ -37004,9 +37232,9 @@ var CodexListenerModel = class {
       canaryError = error;
     } finally {
       try {
-        await (0, import_promises8.lstat)(sentinelPath);
+        await (0, import_promises9.lstat)(sentinelPath);
         sentinelCreated = true;
-        await (0, import_promises8.unlink)(sentinelPath);
+        await (0, import_promises9.unlink)(sentinelPath);
       } catch (error) {
         if (error.code !== "ENOENT") throw error;
       }
@@ -37238,9 +37466,350 @@ function pendingMainEntry(signal, principalId, provenance, now, options = {}) {
   }, true);
 }
 
+// src/listener/wake.ts
+var LISTENER_RECONCILE_POLL_MS = 3e5;
+var WAKE_COALESCE_MS = 1e3;
+var WAKE_CLAIMS_PER_MINUTE_BUDGET = 50;
+var WAKE_RATE_LIMIT_POLL_MS = 6e4;
+var REALTIME_SUBSCRIBE_STATUS = {
+  SUBSCRIBED: "SUBSCRIBED",
+  CHANNEL_ERROR: "CHANNEL_ERROR",
+  CLOSED: "CLOSED",
+  TIMED_OUT: "TIMED_OUT"
+};
+var LISTENER_WAKE_MODES = ["push", "poll"];
+var LISTENER_WAKE_MODE_PUSH = LISTENER_WAKE_MODES[0];
+var LISTENER_WAKE_MODE_POLL = LISTENER_WAKE_MODES[1];
+var LISTENER_WAKE_MODE_SET = new Set(
+  LISTENER_WAKE_MODES
+);
+var WAKE_ERROR_CODES = [
+  "channel_error",
+  "closed",
+  "timed_out",
+  "rate_limited",
+  "wake_budget"
+];
+var WAKE_ERROR_CODE_SET = new Set(WAKE_ERROR_CODES);
+var WAKE_ERROR_CODE_WAKE_BUDGET = WAKE_ERROR_CODES.find(
+  (code) => code === "wake_budget"
+);
+var LISTENER_WAKE_STATUS_KEYS = [
+  "mode",
+  "subscribedAt",
+  "reconnects",
+  "lastWakeAt",
+  "lastReconcileAt",
+  "errorCode",
+  "topicRotatedAt",
+  "rateLimited"
+];
+var LISTENER_WAKE_SENSITIVE_KEYS = [
+  "topic",
+  "wakeTopic",
+  "wake_topic"
+];
+function defaultRealtime(target2) {
+  const client = createClient(target2.url, target2.anonKey, {
+    auth: { persistSession: false, autoRefreshToken: false }
+  });
+  return client.realtime;
+}
+function isSubscribeStatus(value) {
+  return value === REALTIME_SUBSCRIBE_STATUS.SUBSCRIBED || value === REALTIME_SUBSCRIBE_STATUS.CHANNEL_ERROR || value === REALTIME_SUBSCRIBE_STATUS.CLOSED || value === REALTIME_SUBSCRIBE_STATUS.TIMED_OUT;
+}
+function wakeErrorCodeFromSubscribeStatus(status) {
+  switch (status) {
+    case REALTIME_SUBSCRIBE_STATUS.CHANNEL_ERROR:
+      return "channel_error";
+    case REALTIME_SUBSCRIBE_STATUS.CLOSED:
+      return "closed";
+    case REALTIME_SUBSCRIBE_STATUS.TIMED_OUT:
+      return "timed_out";
+    default:
+      return null;
+  }
+}
+function emptyListenerWakeStatus() {
+  return {
+    mode: LISTENER_WAKE_MODE_POLL,
+    subscribedAt: null,
+    reconnects: 0,
+    lastWakeAt: null,
+    lastReconcileAt: null,
+    errorCode: null,
+    topicRotatedAt: null,
+    rateLimited: false
+  };
+}
+function listenerWakePersistWorthy(previous, next, lastPersistMs, nowMs) {
+  if (previous === void 0) return true;
+  if (previous.mode !== next.mode || previous.rateLimited !== next.rateLimited || previous.errorCode !== next.errorCode || previous.reconnects !== next.reconnects || previous.subscribedAt !== next.subscribedAt || previous.topicRotatedAt !== next.topicRotatedAt || previous.lastReconcileAt !== next.lastReconcileAt) {
+    return true;
+  }
+  if (previous.lastWakeAt !== next.lastWakeAt) {
+    return nowMs - lastPersistMs >= WAKE_COALESCE_MS;
+  }
+  return false;
+}
+function listenerWakeStatusSentence(wake, pollIntervalMs, lastWakeLabel) {
+  if (wake.mode === LISTENER_WAKE_MODE_PUSH) {
+    const last = lastWakeLabel === null ? "no wake yet" : `last wake ${lastWakeLabel}`;
+    return `${LISTENER_WAKE_MODE_PUSH} (Realtime), ${last}, reconcile every ${formatIdlePollDuration(LISTENER_RECONCILE_POLL_MS)}.`;
+  }
+  if (wake.errorCode === WAKE_ERROR_CODE_WAKE_BUDGET) {
+    return `Subscribed; claims paused until the minute clears (${WAKE_ERROR_CODE_WAKE_BUDGET}); polling every ${formatIdlePollDuration(pollIntervalMs)} meanwhile.`;
+  }
+  const code = wake.errorCode ?? "disconnected";
+  return `${LISTENER_WAKE_MODE_POLL} every ${formatIdlePollDuration(pollIntervalMs)}. Realtime not connected (${code}).`;
+}
+var WakeSubscriber = class {
+  now;
+  target;
+  createRealtime;
+  realtime = null;
+  channel = null;
+  topic = null;
+  waiter = null;
+  pending = null;
+  connectionState = "disconnected";
+  subscribedAt = null;
+  reconnects = 0;
+  lastWakeAt = null;
+  lastReconcileAt = null;
+  lastErrorCode = null;
+  topicRotatedAt = null;
+  rateLimitedUntil = 0;
+  lastClaimAt = 0;
+  wakeClaimTimes = [];
+  closed = false;
+  everSubscribed = false;
+  constructor(options) {
+    this.target = options.target;
+    this.now = options.now ?? Date.now;
+    this.createRealtime = options.createRealtime ?? defaultRealtime;
+  }
+  get state() {
+    return this.connectionState;
+  }
+  get hasTopic() {
+    return this.topic !== null;
+  }
+  snapshot(nowMs = this.now()) {
+    const serverLimited = nowMs < this.rateLimitedUntil;
+    const overBudget = this.overWakeBudget(nowMs);
+    const rateLimited = serverLimited || overBudget;
+    const mode3 = this.connectionState === "subscribed" && !rateLimited ? LISTENER_WAKE_MODE_PUSH : LISTENER_WAKE_MODE_POLL;
+    const errorCode = serverLimited ? "rate_limited" : overBudget ? WAKE_ERROR_CODE_WAKE_BUDGET : this.lastErrorCode;
+    return {
+      mode: mode3,
+      subscribedAt: this.subscribedAt,
+      reconnects: this.reconnects,
+      lastWakeAt: this.lastWakeAt,
+      lastReconcileAt: this.lastReconcileAt,
+      errorCode,
+      topicRotatedAt: this.topicRotatedAt,
+      rateLimited
+    };
+  }
+  noteReconcile(nowMs = this.now()) {
+    this.lastReconcileAt = new Date(nowMs).toISOString();
+  }
+  noteClaim(nowMs = this.now()) {
+    this.lastClaimAt = nowMs;
+  }
+  noteWakeClaim(nowMs = this.now()) {
+    this.noteClaim(nowMs);
+    this.wakeClaimTimes.push(nowMs);
+    this.trimWakeClaims(nowMs);
+  }
+  coalescingRemainingMs(nowMs = this.now()) {
+    if (this.lastClaimAt <= 0) return 0;
+    return Math.max(0, this.lastClaimAt + WAKE_COALESCE_MS - nowMs);
+  }
+  overWakeBudget(nowMs = this.now()) {
+    this.trimWakeClaims(nowMs);
+    return this.wakeClaimTimes.length >= WAKE_CLAIMS_PER_MINUTE_BUDGET;
+  }
+  canClaimOnWake(nowMs = this.now()) {
+    if (nowMs < this.rateLimitedUntil) return false;
+    if (this.coalescingRemainingMs(nowMs) > 0) return false;
+    return !this.overWakeBudget(nowMs);
+  }
+  markRateLimited(nowMs = this.now()) {
+    this.rateLimitedUntil = nowMs + WAKE_RATE_LIMIT_POLL_MS;
+    this.lastErrorCode = "rate_limited";
+    this.emitPending("state");
+  }
+  setTopic(topic) {
+    if (this.closed) return;
+    if (!isWakeTopic(topic)) {
+      throw new Error("wake topic is malformed");
+    }
+    if (this.topic === topic) return;
+    const rotated = this.topic !== null;
+    void this.detachChannel();
+    this.topic = topic;
+    if (rotated) {
+      this.topicRotatedAt = new Date(this.now()).toISOString();
+    }
+    this.connect();
+  }
+  next(options) {
+    if (this.waiter !== null) {
+      throw new Error("wake next() already has a waiter");
+    }
+    if (options.signal?.aborted) {
+      return Promise.resolve("deadline");
+    }
+    const nowMs = this.now();
+    if (this.pending !== null) {
+      if (!(this.pending === "wake" && this.wakeClaimPaused(nowMs))) {
+        const reason = this.pending;
+        this.pending = null;
+        return Promise.resolve(reason);
+      }
+    }
+    if (nowMs >= options.until) {
+      return Promise.resolve("deadline");
+    }
+    return new Promise((resolve3) => {
+      const finish = (reason) => {
+        if (this.waiter === null) return;
+        const current = this.waiter;
+        this.waiter = null;
+        if (current.timer !== null) clearTimeout(current.timer);
+        if (current.signal && current.onAbort) {
+          current.signal.removeEventListener("abort", current.onAbort);
+        }
+        resolve3(reason);
+      };
+      const delay2 = Math.max(0, options.until - this.now());
+      const timer2 = setTimeout(() => finish("deadline"), delay2);
+      const onAbort = () => finish("deadline");
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+      this.waiter = {
+        resolve: finish,
+        timer: timer2,
+        onAbort,
+        signal: options.signal
+      };
+    });
+  }
+  async close() {
+    this.closed = true;
+    this.topic = null;
+    this.finishWait("deadline");
+    await this.detachChannel();
+    try {
+      this.realtime?.disconnect?.();
+    } catch {
+    }
+    this.realtime = null;
+    this.connectionState = "disconnected";
+  }
+  trimWakeClaims(nowMs) {
+    const minuteStart = Math.floor(nowMs / 6e4) * 6e4;
+    this.wakeClaimTimes = this.wakeClaimTimes.filter((ts) => ts >= minuteStart);
+  }
+  /** Client budget or a server 429: do not claim on wake; poll covers the window. */
+  wakeClaimPaused(nowMs) {
+    return nowMs < this.rateLimitedUntil || this.overWakeBudget(nowMs);
+  }
+  emitPending(reason) {
+    if (this.waiter !== null) {
+      if (reason === "wake" && this.wakeClaimPaused(this.now())) {
+        this.pending = "wake";
+        return;
+      }
+      this.finishWait(reason);
+      return;
+    }
+    if (reason === "wake" || this.pending !== "wake") {
+      this.pending = reason;
+    }
+  }
+  finishWait(reason) {
+    const waiter = this.waiter;
+    if (waiter === null) return;
+    this.waiter = null;
+    if (waiter.timer !== null) clearTimeout(waiter.timer);
+    if (waiter.signal && waiter.onAbort) {
+      waiter.signal.removeEventListener("abort", waiter.onAbort);
+    }
+    waiter.resolve(reason);
+  }
+  connect() {
+    if (this.closed || this.topic === null) return;
+    if (this.realtime === null) {
+      this.realtime = this.createRealtime(this.target);
+      void this.realtime.setAuth(this.target.anonKey);
+    }
+    const topic = this.topic;
+    this.connectionState = "connecting";
+    this.lastErrorCode = null;
+    const channel = this.realtime.channel(topic, {
+      config: { private: true }
+    });
+    this.channel = channel;
+    channel.on("broadcast", { event: WAKE_EVENT }, () => {
+      this.lastWakeAt = new Date(this.now()).toISOString();
+      this.emitPending("wake");
+    });
+    channel.subscribe((status) => {
+      this.onSubscribeStatus(status);
+    });
+  }
+  onSubscribeStatus(status) {
+    if (this.closed) return;
+    if (!isSubscribeStatus(status)) return;
+    const wasSubscribed = this.connectionState === "subscribed";
+    if (status === REALTIME_SUBSCRIBE_STATUS.SUBSCRIBED) {
+      this.connectionState = "subscribed";
+      this.subscribedAt = new Date(this.now()).toISOString();
+      this.lastErrorCode = null;
+      if (this.everSubscribed && !wasSubscribed) this.reconnects += 1;
+      this.everSubscribed = true;
+      if (!wasSubscribed) this.emitPending("state");
+      return;
+    }
+    const code = wakeErrorCodeFromSubscribeStatus(status);
+    if (status === REALTIME_SUBSCRIBE_STATUS.CLOSED) {
+      this.connectionState = "disconnected";
+    } else {
+      this.connectionState = "errored";
+    }
+    this.lastErrorCode = code;
+    this.subscribedAt = null;
+    if (wasSubscribed) this.emitPending("state");
+  }
+  async detachChannel() {
+    const channel = this.channel;
+    this.channel = null;
+    if (channel === null) return;
+    try {
+      await channel.unsubscribe();
+    } catch {
+    }
+    try {
+      await this.realtime?.removeChannel?.(channel);
+    } catch {
+    }
+    if (this.channel !== null) return;
+    if (this.connectionState === "subscribed") {
+      this.connectionState = "disconnected";
+      this.subscribedAt = null;
+    }
+  }
+};
+function createWakeSubscriber(options) {
+  return new WakeSubscriber(options);
+}
+
 // src/listener/runtime.ts
 var LISTENER_PAGE_LIMIT = 100;
-var LISTENER_IDLE_POLL_MS = 2e3;
+var LISTENER_IDLE_POLL_MS = IDLE_POLL_DEFAULT_MS;
+var LISTENER_IDLE_POLL_MAX_MS = IDLE_POLL_MAX_MS;
 var LISTENER_DELIVERY_SAFETY_MARGIN_MS = 3e4;
 var LISTENER_ACK_ONLY_MINIMUM_MS = DELIVERY_REQUEST_TIMEOUT_MS + LISTENER_DELIVERY_SAFETY_MARGIN_MS;
 var LISTENER_REPLY_ONLY_MINIMUM_MS = SIGNAL_REQUEST_TIMEOUT_MS + LISTENER_ACK_ONLY_MINIMUM_MS;
@@ -37525,10 +38094,22 @@ async function runListenerRuntime(options) {
   const random = options.random ?? Math.random;
   const pageLimit = options.pageLimit ?? LISTENER_PAGE_LIMIT;
   const pollMs = options.pollMs ?? LISTENER_IDLE_POLL_MS;
+  let emptyIdleStreak = 0;
   const routeMode = options.routeMode ?? "worker";
   const deferOverChars = options.deferOverChars ?? null;
   const deliveryHoldBudgetMs = options.deliveryHoldBudgetMs ?? LISTENER_DELIVERY_HOLD_BUDGET_MS;
   const abort = options.signal;
+  const idleSleep = async (hadDelivery) => {
+    if (hadDelivery) emptyIdleStreak = 0;
+    const intervalMs = nextIdlePollMs(pollMs, emptyIdleStreak, LISTENER_IDLE_POLL_MAX_MS);
+    if (!hadDelivery) emptyIdleStreak += 1;
+    options.onEvent?.({
+      type: "idle_poll",
+      intervalMs,
+      ts: eventTime(now)
+    });
+    await sleep2(intervalMs, abort);
+  };
   const hasInstanceId = options.listenerInstanceId !== void 0;
   const hasJournal = options.deliveryJournal !== void 0;
   if (hasInstanceId !== hasJournal) {
@@ -37714,6 +38295,35 @@ async function runListenerRuntime(options) {
     abort.addEventListener("abort", onAbort);
   }
   let stop;
+  let wakeSubscriber = options.wake ?? null;
+  let reconcileDueAt = now();
+  const ensureWake = () => {
+    if (wakeSubscriber === null) {
+      wakeSubscriber = options.createWake ? options.createWake(options.target) : createWakeSubscriber({ target: options.target, now });
+    }
+    return wakeSubscriber;
+  };
+  const applyWakeHint = (hint) => {
+    if (hint === void 0) return;
+    try {
+      ensureWake().setTopic(hint.topic);
+    } catch {
+    }
+  };
+  const emitWake = () => {
+    if (wakeSubscriber === null) return;
+    options.onEvent?.({
+      type: "wake",
+      wake: wakeSubscriber.snapshot(now()),
+      ts: eventTime(now)
+    });
+  };
+  const waitCapMs = () => {
+    if (wakeSubscriber !== null && wakeSubscriber.snapshot(now()).mode === LISTENER_WAKE_MODE_PUSH) {
+      return LISTENER_RECONCILE_POLL_MS;
+    }
+    return nextIdlePollMs(pollMs, emptyIdleStreak, LISTENER_IDLE_POLL_MAX_MS);
+  };
   const sendPreparedAck = async (active) => {
     if (active.phase !== "ack_pending" || active.signalId === null || active.leaseId === null || active.leasedUntil === null || active.ack === null) {
       return {
@@ -37780,8 +38390,33 @@ async function runListenerRuntime(options) {
         stop = { reason: "cancelled" };
         break;
       }
-      let page;
-      try {
+      let skipRead = false;
+      if (ready && deliveryMode === "durable_claim" && wakeSubscriber !== null && wakeSubscriber.hasTopic) {
+        const until = Math.min(reconcileDueAt, now() + waitCapMs());
+        const reason = await wakeSubscriber.next({
+          until,
+          ...abort ? { signal: abort } : {}
+        });
+        emitWake();
+        if (abort?.aborted) {
+          stop = { reason: "cancelled" };
+          break;
+        }
+        if (reason === "wake" && wakeSubscriber.snapshot(now()).mode === LISTENER_WAKE_MODE_PUSH) {
+          const coalesceMs = wakeSubscriber.coalescingRemainingMs(now());
+          if (coalesceMs > 0) await sleep2(coalesceMs, abort);
+          if (abort?.aborted) {
+            stop = { reason: "cancelled" };
+            break;
+          }
+          if (wakeSubscriber.snapshot(now()).mode === LISTENER_WAKE_MODE_PUSH) {
+            skipRead = true;
+          }
+        }
+      }
+      let page = null;
+      if (skipRead) {
+      } else try {
         const token = await options.credentialSession.bearer();
         page = await readPage({
           token,
@@ -37799,6 +38434,8 @@ async function runListenerRuntime(options) {
           }
         });
         requireCapabilities(page);
+        applyWakeHint(page.wake);
+        emitWake();
         if (ready && readEpisodeStartedAtMs !== null) {
           const recoveredAtMs = now();
           options.onEvent?.({
@@ -37926,7 +38563,7 @@ async function runListenerRuntime(options) {
             break;
           }
         }
-        if (page.capabilities.deliveryAck && now() < horizon && !preparedNeedsMainRoute) {
+        if ((page?.capabilities.deliveryAck === true || skipRead) && now() < horizon && !preparedNeedsMainRoute) {
           const ackStop = await sendPreparedAck(recovery);
           if (ackStop !== null) {
             stop = ackStop;
@@ -37936,7 +38573,7 @@ async function runListenerRuntime(options) {
             stop = { reason: "cancelled" };
             break;
           }
-          await sleep2(pollMs, abort);
+          await idleSleep(true);
           continue;
         }
         await sleep2(Math.max(0, horizon - now()), abort);
@@ -37956,7 +38593,7 @@ async function runListenerRuntime(options) {
         continue;
       }
       if (recovery?.phase === "leased") {
-        if (page.capabilities.deliveryAck) {
+        if (page?.capabilities.deliveryAck === true || skipRead) {
           let terminal = null;
           if (recovery.signalId !== null) {
             try {
@@ -38066,6 +38703,10 @@ async function runListenerRuntime(options) {
               stop = { reason: "credential", error: asError2(error) };
               break;
             }
+            if (error instanceof DeliveryHttpError && error.code === "rate_limited") {
+              wakeSubscriber?.markRateLimited(now());
+              emitWake();
+            }
             if (!isRetryableDeliveryError(error)) {
               stop = { reason: "fatal", error: asError2(error) };
               break;
@@ -38084,6 +38725,14 @@ async function runListenerRuntime(options) {
           stop = { reason: "fatal", error: new Error("delivery claim did not settle") };
           break;
         }
+        applyWakeHint(result.wake);
+        if (!skipRead && wakeSubscriber !== null && wakeSubscriber.hasTopic) {
+          wakeSubscriber.noteReconcile(now());
+          reconcileDueAt = now() + LISTENER_RECONCILE_POLL_MS;
+        }
+        if (skipRead) wakeSubscriber?.noteWakeClaim(now());
+        else wakeSubscriber?.noteClaim(now());
+        emitWake();
         const claimed = result.deliveries[0] ?? null;
         options.onEvent?.({
           type: "delivery_claim",
@@ -38114,9 +38763,28 @@ async function runListenerRuntime(options) {
             stop = { reason: "fatal", error: asError2(error) };
             break;
           }
-          await sleep2(pollMs, abort);
+          if (wakeSubscriber !== null && wakeSubscriber.hasTopic) {
+            const snap = wakeSubscriber.snapshot(now());
+            const intervalMs = snap.mode === LISTENER_WAKE_MODE_PUSH ? LISTENER_RECONCILE_POLL_MS : nextIdlePollMs(pollMs, emptyIdleStreak, LISTENER_IDLE_POLL_MAX_MS);
+            if (snap.mode === LISTENER_WAKE_MODE_PUSH) emptyIdleStreak = 0;
+            else emptyIdleStreak += 1;
+            options.onEvent?.({
+              type: "idle_poll",
+              intervalMs,
+              ts: eventTime(now)
+            });
+            emitWake();
+            continue;
+          }
+          await idleSleep(false);
           continue;
         }
+        emptyIdleStreak = 0;
+        options.onEvent?.({
+          type: "idle_poll",
+          intervalMs: pollMs,
+          ts: eventTime(now)
+        });
         const leasedUntilMs = Date.parse(claimed.leasedUntil);
         if (!Number.isFinite(leasedUntilMs) || leasedUntilMs > now() + LISTENER_DELIVERY_MAX_LEASE_MS) {
           stop = { reason: "fatal", error: new Error("delivery lease deadline is invalid") };
@@ -38302,6 +38970,7 @@ async function runListenerRuntime(options) {
         }
         continue;
       }
+      if (page === null) continue;
       for (const signal of page.signals) {
         if (abort?.aborted) {
           stop = { reason: "cancelled" };
@@ -38389,11 +39058,15 @@ async function runListenerRuntime(options) {
         continue;
       }
       after = null;
-      await sleep2(pollMs, abort);
+      await idleSleep(page.signals.length > 0);
     }
   } finally {
     abort?.removeEventListener("abort", onAbort);
     options.model.cancel();
+    try {
+      await wakeSubscriber?.close();
+    } catch {
+    }
     try {
       await options.model.close();
     } catch (error) {
@@ -38411,6 +39084,7 @@ var LISTENER_READ_RETRY_HOUR_CAP = 25;
 var LISTENER_READ_RETRY_MINUTE_CAP = 61;
 var LISTENER_CLAIM_HOUR_CAP = 25;
 var LISTENER_THROUGHPUT_LAPSE_RATIO = 0.5;
+var LISTENER_MODE_CHANGE_SKIP_MAX = 1;
 var FAILURE_CODES = /* @__PURE__ */ new Set([
   "http_status",
   "no_response",
@@ -38507,12 +39181,52 @@ function recordListenerReadRecovery(health, input) {
     retryHours: trimNewest(retryHours, LISTENER_READ_RETRY_HOUR_CAP)
   };
 }
-function recordListenerClaimCadence(health, cadenceMs) {
-  return { ...health, claimCadenceMs: cadenceMs };
+function freezeClosedHourExpectedClaims(rows3, currentHourStart) {
+  return rows3.map((row) => {
+    if (row.hourStart === currentHourStart) return row;
+    if (row.expectedClaims !== void 0) return row;
+    if (row.cadenceMs === void 0 || row.cadenceMs < 1) return row;
+    return { ...row, expectedClaims: HOUR_MS / row.cadenceMs };
+  });
+}
+function recordListenerClaimCadence(health, cadenceMs, ts) {
+  const hourStart = bucketStart(ts, HOUR_MS);
+  const claimHours = freezeClosedHourExpectedClaims(
+    health.claimHours.map((row) => ({ ...row })),
+    hourStart
+  );
+  const hour = claimHours.find((row) => row.hourStart === hourStart);
+  if (hour) {
+    hour.cadenceMs = hour.cadenceMs === void 0 ? cadenceMs : Math.max(hour.cadenceMs, cadenceMs);
+  } else {
+    claimHours.push({ hourStart, claims: 0, cadenceMs });
+  }
+  return {
+    ...health,
+    claimCadenceMs: cadenceMs,
+    claimHours: trimNewest(claimHours, LISTENER_CLAIM_HOUR_CAP)
+  };
+}
+function recordListenerWakeModeChange(health, ts) {
+  const hourStart = bucketStart(ts, HOUR_MS);
+  const claimHours = freezeClosedHourExpectedClaims(
+    health.claimHours.map((row) => ({ ...row })),
+    hourStart
+  );
+  const hour = claimHours.find((row) => row.hourStart === hourStart);
+  if (hour) hour.modeChanged = true;
+  else claimHours.push({ hourStart, claims: 0, modeChanged: true });
+  return {
+    ...health,
+    claimHours: trimNewest(claimHours, LISTENER_CLAIM_HOUR_CAP)
+  };
 }
 function recordListenerClaim(health, ts) {
   const hourStart = bucketStart(ts, HOUR_MS);
-  const claimHours = health.claimHours.map((row) => ({ ...row }));
+  const claimHours = freezeClosedHourExpectedClaims(
+    health.claimHours.map((row) => ({ ...row })),
+    hourStart
+  );
   const hour = claimHours.find((row) => row.hourStart === hourStart);
   if (hour) hour.claims += 1;
   else claimHours.push({ hourStart, claims: 1 });
@@ -38567,7 +39281,15 @@ function parseListenerReadHealth(value, rejectUnknownKeys = false) {
   for (const value2 of row.claimHours) {
     if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) return null;
     const hour = value2;
-    if (!hasExpectedKeys(hour, ["hourStart", "claims"], rejectUnknownKeys) || !validTimestamp(hour.hourStart) || !validCount(hour.claims)) return null;
+    if (!hasExpectedKeys(hour, ["hourStart", "claims"], false) || !validTimestamp(hour.hourStart) || !validCount(hour.claims)) return null;
+    if (rejectUnknownKeys && Object.keys(hour).some(
+      (key2) => key2 !== "hourStart" && key2 !== "claims" && key2 !== "cadenceMs" && key2 !== "expectedClaims" && key2 !== "modeChanged"
+    )) return null;
+    if (hour.cadenceMs !== void 0 && !(typeof hour.cadenceMs === "number" && Number.isSafeInteger(hour.cadenceMs) && hour.cadenceMs >= 1)) return null;
+    if (hour.expectedClaims !== void 0 && !(typeof hour.expectedClaims === "number" && Number.isFinite(hour.expectedClaims) && hour.expectedClaims > 0)) return null;
+    if (hour.modeChanged !== void 0 && typeof hour.modeChanged !== "boolean") {
+      return null;
+    }
   }
   return {
     currentEpisodeStartedAt: row.currentEpisodeStartedAt,
@@ -38587,10 +39309,18 @@ function parseListenerReadHealth(value, rejectUnknownKeys = false) {
       retries: minute.retries
     })),
     claimCadenceMs: row.claimCadenceMs,
-    claimHours: row.claimHours.map((hour) => ({
-      hourStart: hour.hourStart,
-      claims: hour.claims
-    }))
+    claimHours: row.claimHours.map((hour) => {
+      const cadenceMs = hour.cadenceMs;
+      const expectedClaims = hour.expectedClaims;
+      const modeChanged = hour.modeChanged;
+      return {
+        hourStart: hour.hourStart,
+        claims: hour.claims,
+        ...typeof cadenceMs === "number" ? { cadenceMs } : {},
+        ...typeof expectedClaims === "number" ? { expectedClaims } : {},
+        ...modeChanged === true ? { modeChanged: true } : {}
+      };
+    })
   };
 }
 function summarizeListenerReadHealth(health, readyAt, nowMs) {
@@ -38624,10 +39354,19 @@ function summarizeListenerReadHealth(health, readyAt, nowMs) {
     const claimsByHour = new Map(
       health.claimHours.map((row) => [row.hourStart, row.claims])
     );
-    const expectedClaims = HOUR_MS / health.claimCadenceMs;
+    const cadenceByHour = /* @__PURE__ */ new Map();
+    const expectedByHour = /* @__PURE__ */ new Map();
+    for (const row of health.claimHours) {
+      if (row.cadenceMs !== void 0) cadenceByHour.set(row.hourStart, row.cadenceMs);
+      if (row.expectedClaims !== void 0) {
+        expectedByHour.set(row.hourStart, row.expectedClaims);
+      }
+    }
     for (let hour = first; hour < currentHour; hour += HOUR_MS) {
       const hourStart = new Date(hour).toISOString();
       const claims = claimsByHour.get(hourStart) ?? 0;
+      const cadenceMs = cadenceByHour.get(hourStart) ?? health.claimCadenceMs;
+      const expectedClaims = expectedByHour.get(hourStart) ?? HOUR_MS / cadenceMs;
       claimThroughputHours.push({
         hourStart,
         claims,
@@ -38636,9 +39375,25 @@ function summarizeListenerReadHealth(health, readyAt, nowMs) {
       });
     }
   }
-  const throughputLapseHours = claimThroughputHours.filter(
-    (hour) => hour.ratio < LISTENER_THROUGHPUT_LAPSE_RATIO
-  );
+  const consecutiveModeChangedHours = (hourStart) => {
+    let count2 = 0;
+    let t = Date.parse(hourStart);
+    if (!Number.isFinite(t)) return 0;
+    while (true) {
+      const start = new Date(t).toISOString();
+      const row = health.claimHours.find((hour) => hour.hourStart === start);
+      if (row?.modeChanged !== true) break;
+      count2 += 1;
+      t -= HOUR_MS;
+    }
+    return count2;
+  };
+  const throughputLapseHours = claimThroughputHours.filter((hour) => {
+    if (hour.ratio >= LISTENER_THROUGHPUT_LAPSE_RATIO) return false;
+    const consecutive = consecutiveModeChangedHours(hour.hourStart);
+    if (consecutive === 0) return true;
+    return consecutive > LISTENER_MODE_CHANGE_SKIP_MAX;
+  });
   return {
     currentEpisodeDurationMs,
     episodesLast24h,
@@ -38654,7 +39409,7 @@ function summarizeListenerReadHealth(health, readyAt, nowMs) {
 // src/listener/control.ts
 var import_node_crypto19 = require("node:crypto");
 var import_node_net = require("node:net");
-var import_promises9 = require("node:fs/promises");
+var import_promises10 = require("node:fs/promises");
 var import_node_path16 = require("node:path");
 var UUID_RE18 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 var SEMVER_RE2 = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:0|[1-9]\d*|[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|[A-Za-z-][0-9A-Za-z-]*))*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
@@ -38741,7 +39496,9 @@ var STATUS_ALLOWED_KEYS = /* @__PURE__ */ new Set([
   "connectionsOpened",
   "connectionReuseRatio",
   "activityPublishFailures",
-  "activityLastErrorCode"
+  "activityLastErrorCode",
+  "idlePollMs",
+  "wake"
 ]);
 var STATUS_ACTIVITY_ERROR_CODES = /* @__PURE__ */ new Set([
   "activity_credential_failed",
@@ -38764,7 +39521,10 @@ var STATUS_SENSITIVE_KEYS = /* @__PURE__ */ new Set([
   "reply",
   "owner",
   "ownerId",
-  "owner_id"
+  "owner_id",
+  "topic",
+  "wakeTopic",
+  "wake_topic"
 ]);
 var STATUS_DELIVERY_KEYS = [
   "deliveryMode",
@@ -38801,6 +39561,37 @@ function parseHeldBackDeliveries(value) {
   }
   return parsed;
 }
+var WAKE_STATUS_KEY_SET = new Set(LISTENER_WAKE_STATUS_KEYS);
+var WAKE_SENSITIVE_KEY_SET = new Set(LISTENER_WAKE_SENSITIVE_KEYS);
+function nullableIso(value) {
+  return value === null || typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function parseListenerWake(value, rejectUnknownKeys = false) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const row = value;
+  for (const key2 of Object.keys(row)) {
+    if (WAKE_SENSITIVE_KEY_SET.has(key2)) return null;
+    if (rejectUnknownKeys && !WAKE_STATUS_KEY_SET.has(key2)) return null;
+  }
+  for (const key2 of LISTENER_WAKE_STATUS_KEYS) {
+    if (!(key2 in row)) return null;
+  }
+  const mode3 = LISTENER_WAKE_MODES.find((item) => item === row.mode);
+  if (mode3 === void 0 || !nullableIso(row.subscribedAt) || !(typeof row.reconnects === "number" && Number.isSafeInteger(row.reconnects) && row.reconnects >= 0) || !nullableIso(row.lastWakeAt) || !nullableIso(row.lastReconcileAt) || !(row.errorCode === null || typeof row.errorCode === "string" && WAKE_ERROR_CODE_SET.has(row.errorCode)) || !nullableIso(row.topicRotatedAt) || typeof row.rateLimited !== "boolean") {
+    return null;
+  }
+  if (mode3 === LISTENER_WAKE_MODE_PUSH && row.subscribedAt === null) return null;
+  return {
+    mode: mode3,
+    subscribedAt: row.subscribedAt,
+    reconnects: row.reconnects,
+    lastWakeAt: row.lastWakeAt,
+    lastReconcileAt: row.lastReconcileAt,
+    errorCode: row.errorCode,
+    topicRotatedAt: row.topicRotatedAt,
+    rateLimited: row.rateLimited
+  };
+}
 function parseStatus(raw, rejectUnknownKeys = false) {
   let value;
   try {
@@ -38825,9 +39616,10 @@ function parseStatus(raw, rejectUnknownKeys = false) {
   const nullableTimestamp3 = (candidate) => candidate === null || typeof candidate === "string" && Number.isFinite(Date.parse(candidate));
   const readHealth = row.readHealth === void 0 ? void 0 : parseListenerReadHealth(row.readHealth, rejectUnknownKeys);
   const heldBackDeliveries = row.heldBackDeliveries === void 0 ? void 0 : parseHeldBackDeliveries(row.heldBackDeliveries);
-  if (row.version !== 1 || typeof row.instanceId !== "string" || !UUID_RE18.test(row.instanceId) || row.provider !== "grok" && row.provider !== "opencode" && row.provider !== "claude" && row.provider !== "codex" || typeof row.profileId !== "string" || typeof row.workspaceId !== "string" || !UUID_RE18.test(row.workspaceId) || typeof row.principalId !== "string" || !UUID_RE18.test(row.principalId) || !Number.isSafeInteger(row.pid) || row.pid < 1 || typeof row.state !== "string" || !["starting", "ready", "stopping", "stopped", "failed"].includes(row.state) || typeof row.startedAt !== "string" || !Number.isFinite(Date.parse(row.startedAt)) || !(row.readyAt === null || typeof row.readyAt === "string" && Number.isFinite(Date.parse(row.readyAt))) || typeof row.updatedAt !== "string" || !Number.isFinite(Date.parse(row.updatedAt)) || !(row.stoppedAt === null || typeof row.stoppedAt === "string" && Number.isFinite(Date.parse(row.stoppedAt))) || !nullableUuid3(row.lastSignalId) || !(row.lastErrorCode === null || typeof row.lastErrorCode === "string" && /^[a-z0-9_-]{1,96}$/.test(row.lastErrorCode)) || !(row.lastErrorDetail === void 0 || row.lastErrorDetail === null || typeof row.lastErrorDetail === "string" && row.lastErrorDetail.length > 0 && row.lastErrorDetail.length <= 2048 && !/swm_(?:agt|inv|cap)_/i.test(row.lastErrorDetail)) || !(row.lastErrorReasonCode === void 0 || row.lastErrorReasonCode === null || typeof row.lastErrorReasonCode === "string" && /^[a-z0-9_-]{1,96}$/.test(row.lastErrorReasonCode)) || !(row.providerExecutable === void 0 || row.providerExecutable === null || typeof row.providerExecutable === "string" && (0, import_node_path16.isAbsolute)(row.providerExecutable)) || !(row.providerVersion === void 0 || row.providerVersion === null || typeof row.providerVersion === "string" && SEMVER_RE2.test(row.providerVersion)) || !(row.providerLastMeasuredVersion === void 0 || row.providerLastMeasuredVersion === null || typeof row.providerLastMeasuredVersion === "string" && SEMVER_RE2.test(row.providerLastMeasuredVersion)) || !(row.providerBundledAgentSdkVersion === void 0 || row.providerBundledAgentSdkVersion === null || typeof row.providerBundledAgentSdkVersion === "string" && SEMVER_RE2.test(row.providerBundledAgentSdkVersion)) || !(row.providerBundledClaudeCodeVersion === void 0 || row.providerBundledClaudeCodeVersion === null || typeof row.providerBundledClaudeCodeVersion === "string" && SEMVER_RE2.test(row.providerBundledClaudeCodeVersion)) || !(row.providerMinimumRequiredVersion === void 0 || row.providerMinimumRequiredVersion === null || typeof row.providerMinimumRequiredVersion === "string" && SEMVER_RE2.test(row.providerMinimumRequiredVersion)) || !(row.cswarmVersion === void 0 || row.cswarmVersion === null || typeof row.cswarmVersion === "string" && SEMVER_RE2.test(row.cswarmVersion)) || (row.providerVersion === null || row.providerVersion === void 0) !== (row.providerLastMeasuredVersion === null || row.providerLastMeasuredVersion === void 0) || !(row.lastWorkerStderrTail === void 0 || row.lastWorkerStderrTail === null || typeof row.lastWorkerStderrTail === "string" && row.lastWorkerStderrTail.length > 0 && row.lastWorkerStderrTail.length <= 2048 && !/swm_(?:agt|inv|cap)_/i.test(row.lastWorkerStderrTail)) || typeof row.logPath !== "string" || !(0, import_node_path16.isAbsolute)(row.logPath) || !(row.deliveryMode === void 0 || row.deliveryMode === null || typeof row.deliveryMode === "string" && STATUS_DELIVERY_MODES.has(row.deliveryMode)) || !(row.pendingDeliveryCount === void 0 || nullableCount(row.pendingDeliveryCount)) || !(row.lastTerminalDeliveryFailureCount === void 0 || nullableCount(row.lastTerminalDeliveryFailureCount)) || !(row.lastTerminalDeliveryFailureAt === void 0 || nullableTimestamp3(row.lastTerminalDeliveryFailureAt)) || !(row.lastClaimAt === void 0 || nullableTimestamp3(row.lastClaimAt)) || !(row.lastAckAt === void 0 || nullableTimestamp3(row.lastAckAt)) || !(row.lastAckOutcome === void 0 || row.lastAckOutcome === null || typeof row.lastAckOutcome === "string" && deliveryOutcomes.has(row.lastAckOutcome)) || !(row.consecutiveAckFailureCount === void 0 || nullableCount(row.consecutiveAckFailureCount)) || !(row.lastAckSignalId === void 0 || row.lastAckSignalId === null || typeof row.lastAckSignalId === "string" && UUID_RE18.test(row.lastAckSignalId)) || !(row.currentDeliverySignalId === void 0 || row.currentDeliverySignalId === null || typeof row.currentDeliverySignalId === "string" && UUID_RE18.test(row.currentDeliverySignalId)) || !(row.currentDeliverySince === void 0 || nullableTimestamp3(row.currentDeliverySince)) || heldBackDeliveries === null || !(row.pendingDeliveryCountAt === void 0 || nullableTimestamp3(row.pendingDeliveryCountAt)) || !(row.routeMode === void 0 || row.routeMode === "worker" || row.routeMode === "main" || row.routeMode === "split") || !(row.deferOverChars === void 0 || row.deferOverChars === null || typeof row.deferOverChars === "number" && Number.isSafeInteger(row.deferOverChars) && row.deferOverChars >= 1 && row.deferOverChars <= 1e4) || !(row.pendingForMainCount === void 0 || typeof row.pendingForMainCount === "number" && Number.isSafeInteger(row.pendingForMainCount) && row.pendingForMainCount >= 0) || !(row.droppedForMainCount === void 0 || typeof row.droppedForMainCount === "number" && Number.isSafeInteger(row.droppedForMainCount) && row.droppedForMainCount >= 0) || readHealth === null || !(row.connectionsOpened === void 0 || typeof row.connectionsOpened === "number" && Number.isSafeInteger(row.connectionsOpened) && row.connectionsOpened >= 0) || !(row.connectionReuseRatio === void 0 || typeof row.connectionReuseRatio === "number" && Number.isFinite(row.connectionReuseRatio) && row.connectionReuseRatio >= 0) || !(row.activityPublishFailures === void 0 || typeof row.activityPublishFailures === "number" && Number.isSafeInteger(row.activityPublishFailures) && row.activityPublishFailures >= 0) || !(row.activityLastErrorCode === void 0 || row.activityLastErrorCode === null || typeof row.activityLastErrorCode === "string" && STATUS_ACTIVITY_ERROR_CODES.has(
+  const wake = row.wake === void 0 ? void 0 : parseListenerWake(row.wake, rejectUnknownKeys);
+  if (row.version !== 1 || typeof row.instanceId !== "string" || !UUID_RE18.test(row.instanceId) || row.provider !== "grok" && row.provider !== "opencode" && row.provider !== "claude" && row.provider !== "codex" || typeof row.profileId !== "string" || typeof row.workspaceId !== "string" || !UUID_RE18.test(row.workspaceId) || typeof row.principalId !== "string" || !UUID_RE18.test(row.principalId) || !Number.isSafeInteger(row.pid) || row.pid < 1 || typeof row.state !== "string" || !["starting", "ready", "stopping", "stopped", "failed"].includes(row.state) || typeof row.startedAt !== "string" || !Number.isFinite(Date.parse(row.startedAt)) || !(row.readyAt === null || typeof row.readyAt === "string" && Number.isFinite(Date.parse(row.readyAt))) || typeof row.updatedAt !== "string" || !Number.isFinite(Date.parse(row.updatedAt)) || !(row.stoppedAt === null || typeof row.stoppedAt === "string" && Number.isFinite(Date.parse(row.stoppedAt))) || !nullableUuid3(row.lastSignalId) || !(row.lastErrorCode === null || typeof row.lastErrorCode === "string" && /^[a-z0-9_-]{1,96}$/.test(row.lastErrorCode)) || !(row.lastErrorDetail === void 0 || row.lastErrorDetail === null || typeof row.lastErrorDetail === "string" && row.lastErrorDetail.length > 0 && row.lastErrorDetail.length <= 2048 && !SECRET_SHAPE_RE.test(row.lastErrorDetail)) || !(row.lastErrorReasonCode === void 0 || row.lastErrorReasonCode === null || typeof row.lastErrorReasonCode === "string" && /^[a-z0-9_-]{1,96}$/.test(row.lastErrorReasonCode)) || !(row.providerExecutable === void 0 || row.providerExecutable === null || typeof row.providerExecutable === "string" && (0, import_node_path16.isAbsolute)(row.providerExecutable)) || !(row.providerVersion === void 0 || row.providerVersion === null || typeof row.providerVersion === "string" && SEMVER_RE2.test(row.providerVersion)) || !(row.providerLastMeasuredVersion === void 0 || row.providerLastMeasuredVersion === null || typeof row.providerLastMeasuredVersion === "string" && SEMVER_RE2.test(row.providerLastMeasuredVersion)) || !(row.providerBundledAgentSdkVersion === void 0 || row.providerBundledAgentSdkVersion === null || typeof row.providerBundledAgentSdkVersion === "string" && SEMVER_RE2.test(row.providerBundledAgentSdkVersion)) || !(row.providerBundledClaudeCodeVersion === void 0 || row.providerBundledClaudeCodeVersion === null || typeof row.providerBundledClaudeCodeVersion === "string" && SEMVER_RE2.test(row.providerBundledClaudeCodeVersion)) || !(row.providerMinimumRequiredVersion === void 0 || row.providerMinimumRequiredVersion === null || typeof row.providerMinimumRequiredVersion === "string" && SEMVER_RE2.test(row.providerMinimumRequiredVersion)) || !(row.cswarmVersion === void 0 || row.cswarmVersion === null || typeof row.cswarmVersion === "string" && SEMVER_RE2.test(row.cswarmVersion)) || (row.providerVersion === null || row.providerVersion === void 0) !== (row.providerLastMeasuredVersion === null || row.providerLastMeasuredVersion === void 0) || !(row.lastWorkerStderrTail === void 0 || row.lastWorkerStderrTail === null || typeof row.lastWorkerStderrTail === "string" && row.lastWorkerStderrTail.length > 0 && row.lastWorkerStderrTail.length <= 2048 && !SECRET_SHAPE_RE.test(row.lastWorkerStderrTail)) || typeof row.logPath !== "string" || !(0, import_node_path16.isAbsolute)(row.logPath) || !(row.deliveryMode === void 0 || row.deliveryMode === null || typeof row.deliveryMode === "string" && STATUS_DELIVERY_MODES.has(row.deliveryMode)) || !(row.pendingDeliveryCount === void 0 || nullableCount(row.pendingDeliveryCount)) || !(row.lastTerminalDeliveryFailureCount === void 0 || nullableCount(row.lastTerminalDeliveryFailureCount)) || !(row.lastTerminalDeliveryFailureAt === void 0 || nullableTimestamp3(row.lastTerminalDeliveryFailureAt)) || !(row.lastClaimAt === void 0 || nullableTimestamp3(row.lastClaimAt)) || !(row.lastAckAt === void 0 || nullableTimestamp3(row.lastAckAt)) || !(row.lastAckOutcome === void 0 || row.lastAckOutcome === null || typeof row.lastAckOutcome === "string" && deliveryOutcomes.has(row.lastAckOutcome)) || !(row.consecutiveAckFailureCount === void 0 || nullableCount(row.consecutiveAckFailureCount)) || !(row.lastAckSignalId === void 0 || row.lastAckSignalId === null || typeof row.lastAckSignalId === "string" && UUID_RE18.test(row.lastAckSignalId)) || !(row.currentDeliverySignalId === void 0 || row.currentDeliverySignalId === null || typeof row.currentDeliverySignalId === "string" && UUID_RE18.test(row.currentDeliverySignalId)) || !(row.currentDeliverySince === void 0 || nullableTimestamp3(row.currentDeliverySince)) || heldBackDeliveries === null || !(row.pendingDeliveryCountAt === void 0 || nullableTimestamp3(row.pendingDeliveryCountAt)) || !(row.routeMode === void 0 || row.routeMode === "worker" || row.routeMode === "main" || row.routeMode === "split") || !(row.deferOverChars === void 0 || row.deferOverChars === null || typeof row.deferOverChars === "number" && Number.isSafeInteger(row.deferOverChars) && row.deferOverChars >= 1 && row.deferOverChars <= 1e4) || !(row.pendingForMainCount === void 0 || typeof row.pendingForMainCount === "number" && Number.isSafeInteger(row.pendingForMainCount) && row.pendingForMainCount >= 0) || !(row.droppedForMainCount === void 0 || typeof row.droppedForMainCount === "number" && Number.isSafeInteger(row.droppedForMainCount) && row.droppedForMainCount >= 0) || readHealth === null || wake === null || !(row.connectionsOpened === void 0 || typeof row.connectionsOpened === "number" && Number.isSafeInteger(row.connectionsOpened) && row.connectionsOpened >= 0) || !(row.connectionReuseRatio === void 0 || typeof row.connectionReuseRatio === "number" && Number.isFinite(row.connectionReuseRatio) && row.connectionReuseRatio >= 0) || !(row.activityPublishFailures === void 0 || typeof row.activityPublishFailures === "number" && Number.isSafeInteger(row.activityPublishFailures) && row.activityPublishFailures >= 0) || !(row.activityLastErrorCode === void 0 || row.activityLastErrorCode === null || typeof row.activityLastErrorCode === "string" && STATUS_ACTIVITY_ERROR_CODES.has(
     row.activityLastErrorCode
-  ))) {
+  )) || !(row.idlePollMs === void 0 || row.idlePollMs === null || typeof row.idlePollMs === "number" && Number.isSafeInteger(row.idlePollMs) && row.idlePollMs >= 0)) {
     throw new Error("stored listener status is malformed");
   }
   const routeMode = row.routeMode ?? "worker";
@@ -38870,7 +39662,9 @@ function parseStatus(raw, rejectUnknownKeys = false) {
     deferOverChars,
     pendingForMainCount: row.pendingForMainCount ?? 0,
     droppedForMainCount: row.droppedForMainCount ?? 0,
-    ...readHealth === void 0 ? {} : { readHealth }
+    ...readHealth === void 0 ? {} : { readHealth },
+    ...row.idlePollMs === void 0 ? {} : { idlePollMs: row.idlePollMs ?? null },
+    ...wake === void 0 ? {} : { wake }
   };
 }
 async function writeListenerStatus(paths, status) {
@@ -38940,7 +39734,12 @@ async function appendListenerEvent(paths, event) {
     "dropped_count",
     // How long one delivery held the worker seat, and why it gave it back.
     "held_ms",
-    "release_reason"
+    "release_reason",
+    "idle_poll_ms",
+    "wake_mode",
+    "wake_error_code",
+    "wake_reconnects",
+    "rate_limited"
   ]);
   const deliveryModes = /* @__PURE__ */ new Set(["durable_claim", "cursor_fallback"]);
   const routeModes = /* @__PURE__ */ new Set(["worker", "main", "split"]);
@@ -39005,6 +39804,21 @@ async function appendListenerEvent(paths, event) {
     if (key2 === "held_ms" && !(typeof value === "number" && Number.isSafeInteger(value) && value >= 0)) {
       throw new Error("listener event hold duration is not allowed");
     }
+    if (key2 === "idle_poll_ms" && !(typeof value === "number" && Number.isSafeInteger(value) && value >= 0)) {
+      throw new Error("listener event idle poll interval is not allowed");
+    }
+    if (key2 === "wake_mode" && !(typeof value === "string" && LISTENER_WAKE_MODE_SET.has(value))) {
+      throw new Error("listener event wake mode is not allowed");
+    }
+    if (key2 === "wake_error_code" && !(value === null || typeof value === "string" && WAKE_ERROR_CODE_SET.has(value))) {
+      throw new Error("listener event wake error code is not allowed");
+    }
+    if (key2 === "wake_reconnects" && !(typeof value === "number" && Number.isSafeInteger(value) && value >= 0)) {
+      throw new Error("listener event wake reconnect count is not allowed");
+    }
+    if (key2 === "rate_limited" && typeof value !== "boolean") {
+      throw new Error("listener event rate-limited flag is not allowed");
+    }
     if (key2 === "release_reason" && !(typeof value === "string" && LISTENER_DELIVERY_HOLD_RELEASE_REASONS.includes(
       value
     ))) {
@@ -39019,7 +39833,7 @@ async function appendListenerEvent(paths, event) {
     if (typeof value === "string" && // worker_stderr_tail is deliberately exempt from the generic 128-char
     // cap (its own bound is 2048, above); the secret scan still applies to
     // every string, the tail included.
-    (key2 !== "worker_stderr_tail" && value.length > 128 || /swm_(?:agt|inv|cap)_/i.test(value))) {
+    (key2 !== "worker_stderr_tail" && value.length > 128 || SECRET_SHAPE_RE.test(value))) {
       throw new Error("listener event contains unsafe text");
     }
   }
@@ -39039,7 +39853,7 @@ async function appendListenerEvent(paths, event) {
     throw new Error("listener event is too large");
   }
   try {
-    const info = await (0, import_promises9.lstat)(paths.logPath);
+    const info = await (0, import_promises10.lstat)(paths.logPath);
     if (!info.isFile() || info.isSymbolicLink() || (info.mode & 511) !== 384) {
       throw new Error("listener event log is not a secure regular file");
     }
@@ -39049,14 +39863,14 @@ async function appendListenerEvent(paths, event) {
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
   }
-  const handle = await (0, import_promises9.open)(paths.logPath, "a", 384);
+  const handle = await (0, import_promises10.open)(paths.logPath, "a", 384);
   try {
     await handle.writeFile(serialized, "utf8");
     await handle.sync();
   } finally {
     await handle.close();
   }
-  await (0, import_promises9.chmod)(paths.logPath, 384);
+  await (0, import_promises10.chmod)(paths.logPath, 384);
 }
 function parseControlRequest(raw) {
   let value;
@@ -39091,7 +39905,7 @@ async function startupLock(paths) {
   while (Date.now() < deadline) {
     let handle;
     try {
-      handle = await (0, import_promises9.open)(lockPath, "wx", 384);
+      handle = await (0, import_promises10.open)(lockPath, "wx", 384);
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
       try {
@@ -39100,9 +39914,9 @@ async function startupLock(paths) {
       } catch (queryError) {
         if (queryError instanceof ListenerAlreadyRunningError) throw queryError;
       }
-      const info = await (0, import_promises9.lstat)(lockPath).catch(() => null);
+      const info = await (0, import_promises10.lstat)(lockPath).catch(() => null);
       if (info && Date.now() - info.mtimeMs >= START_LOCK_STALE_MS) {
-        await (0, import_promises9.unlink)(lockPath).catch(() => void 0);
+        await (0, import_promises10.unlink)(lockPath).catch(() => void 0);
         continue;
       }
       await new Promise((resolve3) => setTimeout(resolve3, 25));
@@ -39114,12 +39928,12 @@ async function startupLock(paths) {
       await handle.sync();
     } catch (error) {
       await handle.close().catch(() => void 0);
-      await (0, import_promises9.unlink)(lockPath).catch(() => void 0);
+      await (0, import_promises10.unlink)(lockPath).catch(() => void 0);
       throw error;
     }
     return async () => {
       await handle.close().catch(() => void 0);
-      await (0, import_promises9.unlink)(lockPath).catch(() => void 0);
+      await (0, import_promises10.unlink)(lockPath).catch(() => void 0);
     };
   }
   throw new ListenerAlreadyRunningError();
@@ -39136,7 +39950,7 @@ async function prepareSocket(paths) {
   } catch (error) {
     if (error instanceof ListenerAlreadyRunningError) throw error;
     if (process.platform !== "win32") {
-      await (0, import_promises9.unlink)(paths.socketPath).catch((unlinkError) => {
+      await (0, import_promises10.unlink)(paths.socketPath).catch((unlinkError) => {
         if (unlinkError.code !== "ENOENT") {
           throw unlinkError;
         }
@@ -39193,13 +40007,13 @@ async function startListenerControlServer(options) {
       server.listen(options.paths.socketPath);
     });
     if (process.platform !== "win32") {
-      await (0, import_promises9.chmod)(options.paths.socketPath, 384);
+      await (0, import_promises10.chmod)(options.paths.socketPath, 384);
     }
   } catch (error) {
     if (server.listening) {
       await new Promise((resolve3) => server.close(() => resolve3()));
       if (process.platform !== "win32") {
-        await (0, import_promises9.unlink)(options.paths.socketPath).catch(() => void 0);
+        await (0, import_promises10.unlink)(options.paths.socketPath).catch(() => void 0);
       }
     }
     throw error;
@@ -39210,7 +40024,7 @@ async function startListenerControlServer(options) {
     close: async () => {
       await new Promise((resolve3) => server.close(() => resolve3()));
       if (process.platform !== "win32") {
-        await (0, import_promises9.unlink)(options.paths.socketPath).catch(() => void 0);
+        await (0, import_promises10.unlink)(options.paths.socketPath).catch(() => void 0);
       }
     }
   };
@@ -39307,7 +40121,7 @@ function safeErrorCode(error) {
 }
 function localDiagnostic(message, maxChars) {
   const redacted = message.replace(
-    /swm_(?:agt|inv|cap)_[^\s"'\\]*/gi,
+    new RegExp(SECRET_SHAPE_RE.source, "gi"),
     "[redacted]"
   ).trim();
   if (redacted.length === 0) return null;
@@ -39415,6 +40229,8 @@ async function runListenerSupervisor(options) {
     connectionReuseRatio: 0,
     activityPublishFailures: 0,
     activityLastErrorCode: null,
+    idlePollMs: null,
+    wake: emptyListenerWakeStatus(),
     logPath: options.paths.logPath
   };
   let writes = Promise.resolve();
@@ -39487,7 +40303,69 @@ async function runListenerSupervisor(options) {
     const fitted = fitWorkerStderrTailForLog(tail);
     return fitted.length > 0 ? fitted : null;
   };
+  let lastWakePersistMs = 0;
   const onEvent = (event) => {
+    if (event.type === "wake") {
+      const previousWake = status.wake;
+      const previous = previousWake?.mode;
+      let readHealth = status.readHealth ?? emptyListenerReadHealth();
+      if (previous !== void 0 && previous !== event.wake.mode) {
+        readHealth = recordListenerWakeModeChange(readHealth, event.ts);
+      }
+      const cadenceMs = event.wake.mode === LISTENER_WAKE_MODE_PUSH ? LISTENER_RECONCILE_POLL_MS : status.idlePollMs && status.idlePollMs > 0 ? status.idlePollMs : null;
+      if (cadenceMs !== null) {
+        readHealth = recordListenerClaimCadence(
+          readHealth,
+          cadenceMs,
+          event.ts
+        );
+      }
+      status = {
+        ...status,
+        wake: event.wake,
+        readHealth,
+        updatedAt: event.ts
+      };
+      const eventMs = Date.parse(event.ts);
+      const nowMs = Number.isFinite(eventMs) ? eventMs : Date.now();
+      if (listenerWakePersistWorthy(
+        previousWake,
+        event.wake,
+        lastWakePersistMs,
+        nowMs
+      )) {
+        lastWakePersistMs = nowMs;
+        persist();
+        log({
+          ts: event.ts,
+          event: "listener_wake",
+          wake_mode: event.wake.mode,
+          wake_error_code: event.wake.errorCode,
+          wake_reconnects: event.wake.reconnects,
+          rate_limited: event.wake.rateLimited
+        });
+      }
+      return;
+    }
+    if (event.type === "idle_poll") {
+      status = {
+        ...status,
+        idlePollMs: event.intervalMs,
+        readHealth: recordListenerClaimCadence(
+          status.readHealth ?? emptyListenerReadHealth(),
+          event.intervalMs > 0 ? event.intervalMs : 1,
+          event.ts
+        ),
+        updatedAt: event.ts
+      };
+      persist();
+      log({
+        ts: event.ts,
+        event: "listener_idle_poll",
+        idle_poll_ms: event.intervalMs
+      });
+      return;
+    }
     if (event.type === "ready") {
       const versionNotice = options.getProviderVersionNotice?.() ?? null;
       transition("ready", {
@@ -39512,7 +40390,8 @@ async function runListenerSupervisor(options) {
         ...event.cadenceMs === void 0 ? {} : {
           readHealth: recordListenerClaimCadence(
             status.readHealth ?? emptyListenerReadHealth(),
-            event.cadenceMs
+            event.cadenceMs,
+            event.ts
           )
         }
       });
@@ -40785,6 +41664,7 @@ function buildListenerChildArgs(spec) {
     ...spec.model ? ["--model", spec.model] : [],
     ...provider === "grok" && spec.effort ? ["--effort", spec.effort] : [],
     ...spec.turnBudget ? ["--turn-budget", spec.turnBudget] : [],
+    ...spec.pollInterval ? ["--poll-interval", spec.pollInterval] : [],
     ...spec.route && spec.route !== "worker" ? ["--route", spec.route] : [],
     ...spec.deferOver !== void 0 ? ["--defer-over", String(spec.deferOver)] : []
   ];
@@ -40820,7 +41700,7 @@ async function spawnDetachedListener(options) {
 }
 
 // src/listener/hook.ts
-var import_promises10 = require("node:fs/promises");
+var import_promises11 = require("node:fs/promises");
 var import_node_path20 = require("node:path");
 
 // src/listener/brain-digest.ts
@@ -41218,7 +42098,7 @@ async function listenerIsLive(context) {
 async function discoverStoredStatusContexts(stateDirectory2) {
   let entries;
   try {
-    entries = await (0, import_promises10.readdir)(stateDirectory2, { withFileTypes: true });
+    entries = await (0, import_promises11.readdir)(stateDirectory2, { withFileTypes: true });
   } catch (error) {
     if (error.code === "ENOENT") return [];
     throw error;
@@ -41618,7 +42498,7 @@ async function runListenerHookCheck(options = {}) {
 }
 
 // src/listener/attendance-canary.ts
-var import_promises11 = require("node:fs/promises");
+var import_promises12 = require("node:fs/promises");
 var LOG_TAIL_BYTES = 256 * 1024;
 function agentReceipt(receipts, principalId) {
   for (const receipt of receipts) {
@@ -41631,7 +42511,7 @@ function agentReceipt(receipts, principalId) {
 async function readLogTail(path) {
   let handle;
   try {
-    handle = await (0, import_promises11.open)(path, "r");
+    handle = await (0, import_promises12.open)(path, "r");
   } catch (error) {
     if (error.code === "ENOENT") return "";
     throw error;
@@ -42735,6 +43615,7 @@ var KNOWN_FLAGS = /* @__PURE__ */ new Set([
   "slug",
   "state-dir",
   "thread",
+  "poll-interval",
   "renewal-horizon-days",
   "standing",
   "task-id",
@@ -42781,8 +43662,8 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
 ]);
 var UUID_RE23 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 function packageVersion() {
-  if ("0.1.56".length > 0) {
-    return "0.1.56";
+  if ("0.1.58".length > 0) {
+    return "0.1.58";
   }
   try {
     const value = JSON.parse(
@@ -42923,7 +43804,7 @@ Usage:
   cswarm brain get <topic>[@<version>] [--version <n>] [--url <url> --anon-key <key>] [--workspace-id <uuid>] ${agentCredential2} [--json]
   cswarm brain put <topic> [<markdown-path>] [--url <url> --anon-key <key>] [--workspace-id <uuid>] ${agentCredential2} [--if-version <n>] [--json]  # without a path, reads Markdown from stdin; --if-version refuses the write unless the live version is still <n>
   cswarm feedback "<text>" --kind bug|idea|friction [--about <ref>] [--url <url> --anon-key <key>] [--workspace-id <uuid>] ${agentCredential2} [--json]
-  cswarm listen start ${requiredAgentCredential} [--url <url> --anon-key <key>] --workspace-id <uuid> --provider grok|opencode|claude|codex [--cwd <absolute-path>] [--model <model>] [--effort <level>] [--permissions deny|allow] [--grok-executable <path>] [--opencode-executable <path>] [--claude-executable <path>] [--codex-executable <path>] [--turn-budget <duration>] [--route worker|main|split] [--defer-over <chars>] [--allow-unattended] [--foreground] [--json]
+  cswarm listen start ${requiredAgentCredential} [--url <url> --anon-key <key>] --workspace-id <uuid> --provider grok|opencode|claude|codex [--cwd <absolute-path>] [--model <model>] [--effort <level>] [--permissions deny|allow] [--grok-executable <path>] [--opencode-executable <path>] [--claude-executable <path>] [--codex-executable <path>] [--turn-budget <duration>] [--poll-interval <duration>] [--route worker|main|split] [--defer-over <chars>] [--allow-unattended] [--foreground] [--json]
   cswarm listen canary ${requiredAgentCredential} [--url <url> --anon-key <key>] --workspace-id <uuid> [--state-dir <path>] [--wait <seconds>] [--json]
   cswarm listen status ${agentCredential2} [--url <url> --anon-key <key>] --workspace-id <uuid> [--principal-id <uuid>] [--json]
   cswarm listen stop ${agentCredential2} [--url <url> --anon-key <key>] --workspace-id <uuid> [--principal-id <uuid>] [--json]
@@ -43013,6 +43894,8 @@ Place -- before signal text that itself begins with -- to stop option parsing.
 Signal text is at most 8000 characters and --about at most 500; a longer body is
 refused locally before any network call, so compose within the limit.
 
+${idlePollHelpSentence()}
+
 listen start --turn-budget bounds ONE worker prompt turn (default 10m): how long
 the worker may think and use tools on a single message before the turn times out
 and durable delivery retries it. A whole number plus s, m, or h (for example
@@ -43251,7 +44134,7 @@ async function stdinInviteLink() {
   return link;
 }
 async function confirmationLine(prompt) {
-  const reader = (0, import_promises13.createInterface)({
+  const reader = (0, import_promises14.createInterface)({
     input: process.stdin,
     output: process.stderr,
     terminal: Boolean(process.stdin.isTTY)
@@ -44555,6 +45438,9 @@ function listenerTurnBudgetMs(value) {
   }
   return milliseconds;
 }
+function listenerPollIntervalMs(value) {
+  return parseIdlePollIntervalMs(value);
+}
 function listenerRouteConfiguration(routeValue, deferOverValue) {
   const routeMode = routeValue ?? "worker";
   if (routeMode !== "worker" && routeMode !== "main" && routeMode !== "split") {
@@ -45535,6 +46421,12 @@ async function runInboxNotifyCommand(args) {
   const stop = () => controller.abort();
   process.on("SIGINT", stop);
   process.on("SIGTERM", stop);
+  const lockPath = arrivalWatchLockPath(
+    cloud,
+    selected.selectedWorkspace,
+    principalId
+  );
+  await acquireArrivalWatchLock(lockPath);
   try {
     const retryNotices = createArrivalRetryNoticePolicy();
     let renderedBearer = selected.bearer;
@@ -45608,6 +46500,7 @@ async function runInboxNotifyCommand(args) {
     process.off("SIGINT", stop);
     process.off("SIGTERM", stop);
     httpClient.close();
+    await releaseArrivalWatchLock(lockPath);
   }
 }
 async function runReceipt(args) {
@@ -46107,6 +47000,10 @@ function listenerStatusJson(status, permissionMode, evidence = {
     readRetriesLastHour: readSummary.retriesLastHour,
     readRetryHours: readSummary.retryHours,
     claimCadenceMs: readHealth.claimCadenceMs,
+    idlePollMs: status.idlePollMs ?? null,
+    idlePollSentence: status.idlePollMs === void 0 || status.idlePollMs === null ? null : idlePollStatusSentence(status.idlePollMs),
+    wake: status.wake ?? emptyListenerWakeStatus(),
+    mode: (status.wake ?? emptyListenerWakeStatus()).mode,
     claimThroughputHours: readSummary.claimThroughputHours,
     listenerLapse: lapseNotices.length > 0,
     listenerLapseCodes: lapseNotices.map((notice) => notice.code),
@@ -46177,7 +47074,13 @@ function renderListenerStatus(status, evidence = {
     `Read retry episodes in the last 24h: ${readSummary.episodesLast24h}; retries in the rolling hour: ${readSummary.retriesLastHour}.`,
     readSummary.longestEpisodeAttemptsLast24h === 0 ? "Longest read retry episode in the last 24h: none recorded." : `Longest read retry episode in the last 24h: ${readSummary.longestEpisodeAttemptsLast24h} attempts over ${Math.floor(readSummary.longestEpisodeDurationMsLast24h / 1e3)}s.`,
     readSummary.retryHours.length === 0 ? "Read retries by hour in the last 24h: none." : `Read retries by hour in the last 24h: ${readSummary.retryHours.map((hour) => `${hour.hourStart}=${hour.retries}`).join("; ")}.`,
-    readSummary.claimThroughputHours.length === 0 ? "Claim throughput by full hour: no complete listener hour is available yet." : `Claim throughput by full hour: ${readSummary.claimThroughputHours.map((hour) => `${hour.hourStart} ${hour.claims}/${Math.round(hour.expectedClaims)} (${hour.ratio.toFixed(3)})`).join("; ")}.`
+    readSummary.claimThroughputHours.length === 0 ? "Claim throughput by full hour: no complete listener hour is available yet." : `Claim throughput by full hour: ${readSummary.claimThroughputHours.map((hour) => `${hour.hourStart} ${hour.claims}/${Math.round(hour.expectedClaims)} (${hour.ratio.toFixed(3)})`).join("; ")}.`,
+    status.idlePollMs === void 0 || status.idlePollMs === null ? "Current idle poll interval has not been reported yet." : idlePollStatusSentence(status.idlePollMs),
+    listenerWakeStatusSentence(
+      status.wake ?? emptyListenerWakeStatus(),
+      status.idlePollMs && status.idlePollMs > 0 ? status.idlePollMs : IDLE_POLL_DEFAULT_MS,
+      status.wake?.lastWakeAt ? relativeAge(status.wake.lastWakeAt, nowMs) : null
+    )
   ];
   for (const notice of lapseNotices) {
     lines.push(`WARNING [${notice.code}]: ${notice.message}`);
@@ -46811,6 +47714,7 @@ async function runConfiguredListener(options) {
             /* One delivery may hold the seat for one turn budget, not for the
                whole 15-minute lease. Same lever, so the two cannot drift. */
             deliveryHoldBudgetMs: turnBudgetMs,
+            ...options.pollMs === void 0 ? {} : { pollMs: options.pollMs },
             pendingMainQueue,
             fetcher: httpClient.fetch
           });
@@ -46841,6 +47745,7 @@ async function runListenStart(args) {
     "codex-executable",
     "state-dir",
     "turn-budget",
+    "poll-interval",
     "route",
     "defer-over",
     "allow-unattended",
@@ -46855,6 +47760,7 @@ async function runListenStart(args) {
   const provider = listenerProvider(args);
   validateListenerProviderFlags(args, provider);
   const turnBudgetMs = listenerTurnBudgetMs(args.optional("turn-budget"));
+  const pollMs = listenerPollIntervalMs(args.optional("poll-interval"));
   const routing = listenerRouteConfiguration(
     args.optional("route"),
     args.optional("defer-over")
@@ -46897,6 +47803,7 @@ async function runListenStart(args) {
       permissionMode,
       provider,
       turnBudgetMs,
+      pollMs,
       ...routing,
       ...args.optional("model") ? { model: args.required("model") } : {},
       ...args.optional("effort") ? { effort: args.required("effort") } : {},
@@ -46951,6 +47858,7 @@ async function runListenStart(args) {
         ...args.optional("model") ? { model: args.required("model") } : {},
         ...args.optional("effort") ? { effort: args.required("effort") } : {},
         ...args.optional("turn-budget") ? { turnBudget: args.required("turn-budget") } : {},
+        ...args.optional("poll-interval") ? { pollInterval: args.required("poll-interval") } : {},
         ...args.optional("grok-executable") ? { executable: args.required("grok-executable") } : {},
         ...opencodeExecutable ? { opencodeExecutable } : {},
         ...claudeExecutable ? { claudeExecutable } : {},
@@ -47059,12 +47967,14 @@ async function runListenSupervisor(args) {
     "codex-executable",
     "state-dir",
     "turn-budget",
+    "poll-interval",
     "route",
     "defer-over"
   ], 1);
   const provider = listenerProvider(args);
   validateListenerProviderFlags(args, provider);
   const turnBudgetMs = listenerTurnBudgetMs(args.optional("turn-budget"));
+  const pollMs = listenerPollIntervalMs(args.optional("poll-interval"));
   const routing = listenerRouteConfiguration(
     args.optional("route"),
     args.optional("defer-over")
@@ -47085,6 +47995,7 @@ async function runListenSupervisor(args) {
     permissionMode: listenerPermissionMode(args.optional("permissions")),
     provider,
     turnBudgetMs,
+    pollMs,
     ...routing,
     ...args.optional("model") ? { model: args.required("model") } : {},
     ...args.optional("effort") ? { effort: args.required("effort") } : {},
@@ -48337,7 +49248,7 @@ async function runSeed(args) {
   if (!tokenOut || !(0, import_node_path21.isAbsolute)(tokenOut)) {
     throw new Error("SEED_TOKEN_OUT must be an absolute path");
   }
-  const tokenFile = await (0, import_promises12.open)(tokenOut, "wx", 384).catch((error) => {
+  const tokenFile = await (0, import_promises13.open)(tokenOut, "wx", 384).catch((error) => {
     if (error.code === "EEXIST") {
       throw new Error("SEED_TOKEN_OUT already exists; refusing to overwrite it");
     }
@@ -48376,7 +49287,7 @@ async function runSeed(args) {
       tokenWritten = true;
     }
     await tokenFile.close();
-    if (!tokenWritten) await (0, import_promises12.unlink)(tokenOut);
+    if (!tokenWritten) await (0, import_promises13.unlink)(tokenOut);
     process.stdout.write(`${JSON.stringify({
       userId: result.userId,
       membershipRole: result.membershipRole,
@@ -48389,7 +49300,7 @@ async function runSeed(args) {
 `);
   } catch (error) {
     await tokenFile.close().catch(() => void 0);
-    if (!tokenWritten) await (0, import_promises12.unlink)(tokenOut).catch(() => void 0);
+    if (!tokenWritten) await (0, import_promises13.unlink)(tokenOut).catch(() => void 0);
     throw error;
   }
 }
@@ -48653,6 +49564,7 @@ ${usage()}
   listenerFailureMessage,
   listenerHostLimits,
   listenerPermissionMode,
+  listenerPollIntervalMs,
   listenerProviderInstallEvidence,
   listenerRouteConfiguration,
   listenerStatusJson,