@lazehq/cli 0.1.14 → 0.1.16

package/dist/laze.mjs

@@ -18733,8 +18733,8 @@ var require_snapshot_utils = __commonJS({
 var require_snapshot_recorder = __commonJS({
   "../../node_modules/.pnpm/undici@8.10.0/node_modules/undici/lib/mock/snapshot-recorder.js"(exports, module) {
     "use strict";
-    var { writeFile: writeFile20, readFile: readFile32, mkdir: mkdir18 } = __require("node:fs/promises");
-    var { dirname: dirname18, resolve: resolve17 } = __require("node:path");
+    var { writeFile: writeFile21, readFile: readFile34, mkdir: mkdir19 } = __require("node:fs/promises");
+    var { dirname: dirname19, resolve: resolve17 } = __require("node:path");
     var { setTimeout: setTimeout2, clearTimeout: clearTimeout2 } = __require("node:timers");
     var { InvalidArgumentError, UndiciError } = require_errors();
     var { hashId, isUrlExcludedFactory, normalizeHeaders, createHeaderFilters } = require_snapshot_utils();
@@ -18950,7 +18950,7 @@ var require_snapshot_recorder = __commonJS({
           throw new InvalidArgumentError("Snapshot path is required");
         }
         try {
-          const data = await readFile32(resolve17(path), "utf8");
+          const data = await readFile34(resolve17(path), "utf8");
           const parsed = JSON.parse(data);
           if (Array.isArray(parsed)) {
             this.#snapshots.clear();
@@ -18980,12 +18980,12 @@ var require_snapshot_recorder = __commonJS({
           throw new InvalidArgumentError("Snapshot path is required");
         }
         const resolvedPath = resolve17(path);
-        await mkdir18(dirname18(resolvedPath), { recursive: true });
+        await mkdir19(dirname19(resolvedPath), { recursive: true });
         const data = Array.from(this.#snapshots.entries()).map(([hash2, snapshot]) => ({
           hash: hash2,
           snapshot
         }));
-        await writeFile20(resolvedPath, JSON.stringify(data, null, 2), { flush: true });
+        await writeFile21(resolvedPath, JSON.stringify(data, null, 2), { flush: true });
       }
       /**
        * Clears all recorded snapshots
@@ -35606,7 +35606,7 @@ function flagText({
 }
 
 // src/rules/cli-version.rules.ts
-var STAMPED = "0.1.14";
+var STAMPED = "0.1.16";
 function cliVersionOf({ stamped = STAMPED } = {}) {
   return stamped.startsWith("__") ? "dev" : stamped;
 }
@@ -65390,7 +65390,7 @@ async function copyAgent({
 }
 
 // src/services/agent-commands.service.ts
-import { mkdir as mkdir11, readFile as readFile9, writeFile as writeFile11 } from "node:fs/promises";
+import { mkdir as mkdir13, readFile as readFile11, writeFile as writeFile13 } from "node:fs/promises";
 import { join as join12, resolve as resolve4 } from "node:path";
 
 // src/rules/agent-profile.rules.ts
@@ -67264,10 +67264,327 @@ async function claudeProjectOf({
   return candidates.find((folder) => holds({ folder, inner: context.cwd })) ?? resolve2(context.cwd);
 }
 
+// src/services/claude-wait.service.ts
+import { readFile as readFile5, rm as rm2, writeFile as writeFile5, mkdir as mkdir5 } from "node:fs/promises";
+import { dirname as dirname5 } from "node:path";
+
+// src/services/harness-session.service.ts
+import { mkdir as mkdir4, readdir, readFile as readFile4, writeFile as writeFile4 } from "node:fs/promises";
+import { hostname as hostname3 } from "node:os";
+import { dirname as dirname4, join as join4 } from "node:path";
+
+// src/rules/session-headers.rules.ts
+import { relative as relative2, sep } from "node:path";
+function sessionKeyOf({ session }) {
+  return `${session.harness}:${session.sessionId}`;
+}
+function sessionHeadersOf({
+  session
+}) {
+  if (!session) return {};
+  return {
+    [AGENT_SESSION_HEADER]: sessionKeyOf({ session }),
+    [AGENT_SESSION_FOLDER_HEADER]: encodeURIComponent(session.folder),
+    [AGENT_SESSION_HOST_HEADER]: encodeURIComponent(session.host)
+  };
+}
+function displayFolderOf({ folder, home }) {
+  if (!home) return folder;
+  const below = relative2(home, folder);
+  if (below === "") return "~";
+  if (below.startsWith("..") || below.startsWith(sep)) return folder;
+  return `~/${below.split(sep).join("/")}`;
+}
+
+// src/services/harness-session.service.ts
+function sessionOf({
+  context,
+  harness,
+  sessionId
+}) {
+  if (!sessionId) return void 0;
+  const inherited = context.environment.inherited;
+  const folder = inherited.CLAUDE_PROJECT_DIR || context.cwd;
+  return {
+    harness,
+    sessionId,
+    folder: displayFolderOf({ folder, home: inherited.HOME }),
+    host: hostname3()
+  };
+}
+function forSession({
+  client,
+  session
+}) {
+  return client.withHeaders(sessionHeadersOf({ session }));
+}
+async function rememberSession({
+  context,
+  claudePid,
+  session
+}) {
+  if (!session || !claudePid) return;
+  const path = statePathOf({ context, kind: "sessions", profile: String(claudePid) });
+  await mkdir4(dirname4(path), { recursive: true, mode: 448 });
+  await writeFile4(path, JSON.stringify(session), { mode: 384 });
+}
+async function currentSessionOf({
+  context,
+  args
+}) {
+  const inherited = context.environment.inherited;
+  const named = flagText({ args, name: "session" });
+  const harness = context.environment.harness;
+  if (named) return sessionOf({ context, harness, sessionId: named });
+  if (harness === "claude-code" && inherited.CLAUDE_CODE_SESSION_ID) {
+    return sessionOf({ context, harness, sessionId: inherited.CLAUDE_CODE_SESSION_ID });
+  }
+  if (harness === "codex" && inherited.CODEX_THREAD_ID) {
+    return sessionOf({ context, harness, sessionId: inherited.CODEX_THREAD_ID });
+  }
+  const nearest = await nearestHarnessOf({ context });
+  if (!nearest) return void 0;
+  const path = statePathOf({ context, kind: "sessions", profile: String(nearest.pid) });
+  return readFile4(path, "utf8").then(
+    (text2) => JSON.parse(text2),
+    () => void 0
+  );
+}
+async function sessionProfileArgs({
+  context,
+  args,
+  session
+}) {
+  if (!session) return args;
+  const key = sessionKeyOf({ session });
+  const config2 = await context.store.read();
+  const bound = config2.sessions?.[key];
+  if (bound && config2.profiles[bound]) {
+    return { ...args, flags: { ...args.flags, profile: bound } };
+  }
+  const own2 = flagText({ args, name: "profile" });
+  if (own2 && config2.profiles[own2]?.kind === "agent") {
+    await context.store.bindSession({ session: key, profile: own2 });
+  }
+  return args;
+}
+async function liveElsewhere({
+  context,
+  key,
+  claudePid
+}) {
+  const folder = dirname4(statePathOf({ context, kind: "sessions", profile: "x" }));
+  for (const file3 of await readdir(folder).catch(() => [])) {
+    const pid = Number(file3.replace(/\.json$/, ""));
+    if (!pid || pid === claudePid || !context.processes.alive(pid)) continue;
+    const noted = await readFile4(join4(folder, file3), "utf8").then(
+      (text2) => JSON.parse(text2),
+      () => void 0
+    );
+    if (noted && sessionKeyOf({ session: noted }) === key) return true;
+  }
+  return false;
+}
+function notBoundText({ meta: meta3 }) {
+  return `Laze: this agent listens in another session${meta3.bound ? `: ${meta3.bound}` : ""}. Create a new Laze agent with this session: laze agent request. Or move this agent here: laze agent bind.`;
+}
+async function notBoundNotice({
+  context,
+  client,
+  session,
+  error: error62
+}) {
+  if (!(error62 instanceof LazeApiError) || error62.code !== "session_not_bound") return void 0;
+  const meta3 = error62.meta ?? {};
+  if (client && session && meta3.session && meta3.host === session.host) {
+    const claudePid = (await nearestHarnessOf({ context }))?.pid;
+    if (!await liveElsewhere({ context, key: meta3.session, claudePid })) {
+      await client.post("/api/agents/me/bind", {});
+      return { notice: void 0, rebound: true };
+    }
+  }
+  const key = session ? sessionKeyOf({ session }) : "unknown";
+  const path = statePathOf({ context, kind: "told", profile: key });
+  const told = await readFile4(path, "utf8").then(
+    () => true,
+    () => false
+  );
+  if (told) return { notice: void 0 };
+  await mkdir4(dirname4(path), { recursive: true, mode: 448 });
+  await writeFile4(path, String(context.nowMs()), { mode: 384 });
+  return { notice: notBoundText({ meta: meta3 }) };
+}
+
+// src/services/claude-wait.service.ts
+var ROUND_SECONDS = 50;
+var WATCH_MS = 2e3;
+var CHANNEL_CHECK_MS = 5e3;
+async function holderOf({ path }) {
+  return readFile5(path, "utf8").then(
+    (text2) => JSON.parse(text2),
+    () => void 0
+  );
+}
+async function holderClaudeOf({ context, holder }) {
+  if (holder.claudePid) return holder.claudePid;
+  return (await nearestHarnessOf({ context, from: holder.pid }))?.pid;
+}
+async function takeLock({
+  context,
+  path,
+  sessionId,
+  claudePid,
+  preempt = false
+}) {
+  const holder = await holderOf({ path });
+  const self2 = context.processes.pid;
+  if (holder && holder.pid !== self2 && context.processes.alive(holder.pid)) {
+    const served = await holderClaudeOf({ context, holder });
+    const mine3 = preempt && served === claudePid && !holder.monitor;
+    if (served && context.processes.alive(served) && !mine3) return false;
+    context.processes.stop(holder.pid);
+  }
+  await mkdir5(dirname5(path), { recursive: true, mode: 448 });
+  await writeFile5(
+    path,
+    JSON.stringify({
+      pid: self2,
+      claudePid,
+      ...sessionId ? { sessionId } : {},
+      ...preempt ? { monitor: true } : {}
+    })
+  );
+  return true;
+}
+async function channelLive({ context, profile }) {
+  const holder = await holderOf({ path: statePathOf({ context, kind: "channels", profile }) });
+  return holder !== void 0 && context.processes.alive(holder.pid);
+}
+async function takeRound({
+  context,
+  client,
+  claudePid,
+  session
+}) {
+  const controller = new AbortController();
+  const { signal } = controller;
+  const watch = (async () => {
+    while (!signal.aborted) {
+      await context.sleep(WATCH_MS, signal);
+      if (claudePid && !context.processes.alive(claudePid)) controller.abort();
+    }
+  })();
+  try {
+    return await forSession({ client, session }).post(
+      "/api/agents/me/inbox",
+      { waitSeconds: ROUND_SECONDS },
+      { signal }
+    );
+  } catch (error62) {
+    if (signal.aborted) return [];
+    throw error62;
+  } finally {
+    controller.abort();
+    await watch;
+  }
+}
+async function roundOf({ context, client, name: name2, lock, claudePid, session, seen }) {
+  if ((await holderOf({ path: lock }))?.pid !== context.processes.pid) return void 0;
+  if (claudePid && !context.processes.alive(claudePid)) return void 0;
+  const due = await dueFromSpool({ context, profile: name2, seen, pushedToo: true });
+  if (due.length > 0) return due;
+  if (await channelLive({ context, profile: name2 })) {
+    await context.sleep(CHANNEL_CHECK_MS);
+    return [];
+  }
+  const taken = await takeRound({ context, client, claudePid, session });
+  if (taken.length === 0) {
+    await context.sleep(1e3);
+    return [];
+  }
+  await keepTaken({ context, profile: name2, messages: taken });
+  return taken;
+}
+async function claudePidOf({ context }) {
+  const harness = await nearestHarnessOf({ context });
+  if (harness?.harness === "claude-code") return harness.pid;
+  return await context.processes.parentOf(context.processes.pid) ?? 0;
+}
+async function settleRound(round) {
+  const { context, client, name: name2, session } = round;
+  const messages = await roundOf(round).catch(async (error62) => {
+    const refused = await notBoundNotice({
+      context,
+      client: forSession({ client, session }),
+      session,
+      error: error62
+    });
+    if (!refused) throw error62;
+    return refused;
+  });
+  if (messages === void 0) return 0;
+  if (!Array.isArray(messages)) {
+    if (messages.rebound) return "again";
+    if (!messages.notice) return 0;
+    context.err(`${messages.notice}
+`);
+    return 2;
+  }
+  if (messages.length === 0) return "again";
+  await turnStarted({ context, client, agent: name2, messages }).catch(() => void 0);
+  const self2 = await currentNameOf({ context, client, profile: name2 });
+  context.err(`${hookContextOf({ messages, self: self2 })}
+`);
+  const messageIds = messages.map((message2) => message2.messageId);
+  await dropFromSpool({ context, profile: name2, messageIds });
+  return 2;
+}
+async function waitForMessages({ context, args }) {
+  const raw = await context.readStdin();
+  const input2 = raw.trim() ? JSON.parse(raw) : {};
+  const session = sessionOf({ context, harness: "claude-code", sessionId: input2.session_id });
+  const named = await sessionProfileArgs({ context, args, session });
+  const { client, name: name2 } = await signedIn({ context, args: named });
+  const claudePid = await claudePidOf({ context });
+  await rememberSession({ context, claudePid, session });
+  const lock = statePathOf({ context, kind: "waiters", profile: name2 });
+  if (!await takeLock({ context, path: lock, sessionId: input2.session_id, claudePid })) return 0;
+  const seen = () => input2.transcript_path ? readFile5(input2.transcript_path, "utf8") : Promise.resolve("");
+  const deadline = context.nowMs() + (WAIT_HOOK_TIMEOUT_SECONDS - 60) * 1e3;
+  try {
+    while (context.nowMs() < deadline) {
+      const code = await settleRound({ context, client, name: name2, lock, claudePid, session, seen });
+      if (code !== "again") return code;
+    }
+    return 0;
+  } finally {
+    if ((await holderOf({ path: lock }))?.pid === context.processes.pid)
+      await rm2(lock, { force: true });
+  }
+}
+async function waitHook({ context, args }) {
+  try {
+    return await waitForMessages({ context, args });
+  } catch (error62) {
+    context.err(`laze: the background waiter stopped: ${String(error62)}
+`);
+    return 0;
+  }
+}
+async function monitorServes({
+  context,
+  profile,
+  claudePid
+}) {
+  const holder = await holderOf({ path: statePathOf({ context, kind: "waiters", profile }) });
+  if (!holder?.monitor || !context.processes.alive(holder.pid)) return false;
+  return await holderClaudeOf({ context, holder }) === claudePid;
+}
+
 // src/services/codex-link.service.ts
 import { createReadStream } from "node:fs";
-import { readdir as readdir3, rm as rm5, stat as stat2 } from "node:fs/promises";
-import { join as join9, resolve as resolve3 } from "node:path";
+import { readdir as readdir4, rm as rm6, stat as stat2 } from "node:fs/promises";
+import { join as join10, resolve as resolve3 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 
 // src/rules/connect-service.rules.ts
@@ -67387,8 +67704,8 @@ function rolloutEventOf({
 
 // src/services/codex-adopt.service.ts
 import { spawn as spawn2 } from "node:child_process";
-import { mkdir as mkdir4, readdir, readFile as readFile4, rm as rm2, stat, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname4, join as join4 } from "node:path";
+import { mkdir as mkdir6, readdir as readdir2, readFile as readFile6, rm as rm3, stat, writeFile as writeFile6 } from "node:fs/promises";
+import { dirname as dirname6, join as join5 } from "node:path";
 import { createInterface } from "node:readline";
 
 // src/rules/codex-requests.rules.ts
@@ -67508,11 +67825,11 @@ var CodexAppServer = class _CodexAppServer {
   }
 };
 async function newestThreadId({ codexHome }) {
-  const root = join4(codexHome, "sessions");
-  const files2 = await readdir(root, { recursive: true }).catch(() => []);
+  const root = join5(codexHome, "sessions");
+  const files2 = await readdir2(root, { recursive: true }).catch(() => []);
   const rollouts = files2.filter((file3) => /rollout-.*\.jsonl$/.test(file3));
   const dated = await Promise.all(
-    rollouts.map(async (file3) => ({ file: file3, at: (await stat(join4(root, file3))).mtimeMs }))
+    rollouts.map(async (file3) => ({ file: file3, at: (await stat(join5(root, file3))).mtimeMs }))
   );
   const newest = dated.toSorted((a, b) => b.at - a.at)[0]?.file ?? "";
   const id = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/.exec(newest);
@@ -67587,7 +67904,7 @@ async function answer({
 var MAX_RESTART_WAIT_SECONDS = 60;
 var HEALTHY_RUN_MS = 6e4;
 async function recordOf({ path }) {
-  return readFile4(path, "utf8").then(
+  return readFile6(path, "utf8").then(
     (text2) => JSON.parse(text2),
     () => void 0
   );
@@ -67609,8 +67926,8 @@ async function startAdoptInBackground({
   const adopt = ["adopt", "codex", "--profile", profile, ...threadFlag({ thread: thread2 })];
   const argv = [...context.program, ...adopt, "--supervise"];
   const pid = context.processes.spawnDetached({ argv, logPath: log });
-  await mkdir4(dirname4(path), { recursive: true, mode: 448 });
-  await writeFile4(path, JSON.stringify({ pid, thread: thread2, log, startedAt: context.nowMs() }));
+  await mkdir6(dirname6(path), { recursive: true, mode: 448 });
+  await writeFile6(path, JSON.stringify({ pid, thread: thread2, log, startedAt: context.nowMs() }));
   return [
     `Started \`${laze} adopt codex\` in the background (pid ${pid}). It answers each Laze message`,
     `as a turn in ${thread2 ? `this Codex thread (${thread2})` : "the newest Codex thread"}, and starts again if it stops.`,
@@ -67665,7 +67982,7 @@ Log: ${record4.log}
 async function adoptStop({ context, profile }) {
   const path = statePathOf({ context, kind: "adopt", profile });
   const record4 = await recordOf({ path });
-  await rm2(path, { force: true });
+  await rm3(path, { force: true });
   if (!record4 || !context.processes.stop(record4.pid)) {
     context.out(`laze adopt codex was not running in the background for profile "${profile}".
 `);
@@ -67690,7 +68007,7 @@ async function adoptedThreadOf({
   );
   if (!held) return threadId;
   const path = statePathOf({ context, kind: "adopt", profile, extension: "forks.json" });
-  const forks = await readFile4(path, "utf8").then(
+  const forks = await readFile6(path, "utf8").then(
     (text2) => JSON.parse(text2),
     () => ({})
   );
@@ -67705,8 +68022,8 @@ async function adoptedThreadOf({
   }
   const forked = record3((await codex.call("thread/fork", { threadId })).thread).id;
   if (typeof forked !== "string") throw new Error("thread/fork answered no thread id");
-  await mkdir4(dirname4(path), { recursive: true, mode: 448 });
-  await writeFile4(path, JSON.stringify({ ...forks, [threadId]: forked }));
+  await mkdir6(dirname6(path), { recursive: true, mode: 448 });
+  await writeFile6(path, JSON.stringify({ ...forks, [threadId]: forked }));
   context.out(
     `Codex holds thread ${threadId} open elsewhere; answering in its new fork ${forked}.
 `
@@ -67761,43 +68078,20 @@ async function adoptCodex({ context, args }) {
 }
 
 // src/services/connect-delivery.service.ts
-import { mkdir as mkdir6, readFile as readFile6, rename as rename3, rm as rm3, writeFile as writeFile6 } from "node:fs/promises";
-import { homedir as homedir2, hostname as hostname3 } from "node:os";
-import { dirname as dirname6, join as join7 } from "node:path";
-
-// src/rules/session-headers.rules.ts
-import { relative as relative2, sep } from "node:path";
-function sessionKeyOf({ session }) {
-  return `${session.harness}:${session.sessionId}`;
-}
-function sessionHeadersOf({
-  session
-}) {
-  if (!session) return {};
-  return {
-    [AGENT_SESSION_HEADER]: sessionKeyOf({ session }),
-    [AGENT_SESSION_FOLDER_HEADER]: encodeURIComponent(session.folder),
-    [AGENT_SESSION_HOST_HEADER]: encodeURIComponent(session.host)
-  };
-}
-function displayFolderOf({ folder, home }) {
-  if (!home) return folder;
-  const below = relative2(home, folder);
-  if (below === "") return "~";
-  if (below.startsWith("..") || below.startsWith(sep)) return folder;
-  return `~/${below.split(sep).join("/")}`;
-}
+import { mkdir as mkdir8, readFile as readFile8, rename as rename3, rm as rm4, writeFile as writeFile8 } from "node:fs/promises";
+import { homedir as homedir2, hostname as hostname4 } from "node:os";
+import { dirname as dirname8, join as join8 } from "node:path";
 
 // src/services/codex-turn-watch.service.ts
-import { open as open2, readdir as readdir2 } from "node:fs/promises";
-import { join as join5 } from "node:path";
+import { open as open2, readdir as readdir3 } from "node:fs/promises";
+import { join as join6 } from "node:path";
 var READ_MS = 1500;
 var KEEP_WORKING_MS = 3e4;
 async function rolloutPathOf({ delivery }) {
-  const root = join5(delivery.codexHome, "sessions");
-  const files2 = await readdir2(root, { recursive: true }).catch(() => []);
+  const root = join6(delivery.codexHome, "sessions");
+  const files2 = await readdir3(root, { recursive: true }).catch(() => []);
   const file3 = files2.find((name2) => name2.endsWith(`-${delivery.threadId}.jsonl`));
-  return file3 ? join5(root, file3) : void 0;
+  return file3 ? join6(root, file3) : void 0;
 }
 async function readFrom({ path, offset }) {
   const handle = await open2(path, "r");
@@ -67883,8 +68177,8 @@ var CodexTurnWatch = class _CodexTurnWatch {
 };
 
 // src/services/openclaw-relay.service.ts
-import { chmod as chmod2, mkdir as mkdir5, readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
-import { dirname as dirname5, join as join6 } from "node:path";
+import { chmod as chmod2, mkdir as mkdir7, readFile as readFile7, writeFile as writeFile7 } from "node:fs/promises";
+import { dirname as dirname7, join as join7 } from "node:path";
 
 // ../../modules/openclaw/contract/src/openclaw.ts
 var workspaceIdSchema14 = external_exports.string().min(1);
@@ -68112,11 +68406,11 @@ var STOPS = /* @__PURE__ */ new Map([
   [OPENCLAW_RELAY_CLOSE.replaced.code, "another relay for this gateway took over"]
 ]);
 function relaysPathOf({ context }) {
-  return join6(dirname5(context.environment.configPath), "connect", "openclaw-relays.json");
+  return join7(dirname7(context.environment.configPath), "connect", "openclaw-relays.json");
 }
 async function readRelays({ context }) {
   try {
-    return JSON.parse(await readFile5(relaysPathOf({ context }), "utf8"));
+    return JSON.parse(await readFile7(relaysPathOf({ context }), "utf8"));
   } catch {
     return {};
   }
@@ -68126,8 +68420,8 @@ async function saveRelays({
   relays
 }) {
   const path = relaysPathOf({ context });
-  await mkdir5(dirname5(path), { recursive: true, mode: 448 });
-  await writeFile5(path, `${JSON.stringify(relays, null, 2)}
+  await mkdir7(dirname7(path), { recursive: true, mode: 448 });
+  await writeFile7(path, `${JSON.stringify(relays, null, 2)}
 `, { mode: 384 });
   await chmod2(path, 384);
 }
@@ -68313,14 +68607,14 @@ var RelayLoops = class _RelayLoops {
 
 // src/services/connect-delivery.service.ts
 function connectFolderOf({ context }) {
-  return join7(dirname6(context.environment.configPath), "connect");
+  return join8(dirname8(context.environment.configPath), "connect");
 }
 function runStatePathOf({ context }) {
-  return join7(connectFolderOf({ context }), "run.json");
+  return join8(connectFolderOf({ context }), "run.json");
 }
 async function readJson({ path }) {
   try {
-    return JSON.parse(await readFile6(path, "utf8"));
+    return JSON.parse(await readFile8(path, "utf8"));
   } catch {
     return void 0;
   }
@@ -68328,7 +68622,7 @@ async function readJson({ path }) {
 async function runStateOf({ context }) {
   return readJson({ path: runStatePathOf({ context }) });
 }
-var ROUND_SECONDS = 50;
+var ROUND_SECONDS2 = 50;
 var REFRESH_MS = 3e4;
 var MAX_RETRY_SECONDS2 = 60;
 var CodexQueueError = class extends Error {
@@ -68360,7 +68654,7 @@ async function queueInCodex({
     throw new CodexQueueError(codexQueueFailureOf({ stderr: stderr2 }), stderr2.trim() || `exit ${code}`);
   }
 }
-async function takeRound({
+async function takeRound2({
   client,
   signal,
   delivery
@@ -68369,10 +68663,10 @@ async function takeRound({
     harness: "codex",
     sessionId: delivery.threadId,
     folder: displayFolderOf({ folder: delivery.cwd, home: homedir2() }),
-    host: hostname3()
+    host: hostname4()
   };
   try {
-    return await client.withHeaders(sessionHeadersOf({ session })).post("/api/agents/me/inbox", { waitSeconds: ROUND_SECONDS }, { signal });
+    return await client.withHeaders(sessionHeadersOf({ session })).post("/api/agents/me/inbox", { waitSeconds: ROUND_SECONDS2 }, { signal });
   } catch (error62) {
     if (signal.aborted) return [];
     throw error62;
@@ -68387,7 +68681,7 @@ async function deliverRound({
   watch
 }) {
   const kept = await dueFromSpool({ context, profile, seen: async () => "", pushedToo: true });
-  const messages = kept.length > 0 ? kept : await takeRound({ client, signal, delivery });
+  const messages = kept.length > 0 ? kept : await takeRound2({ client, signal, delivery });
   if (messages.length === 0) return 0;
   if (kept.length === 0) await keepTaken({ context, profile, messages });
   const self2 = await currentNameOf({ context, client, profile });
@@ -68470,9 +68764,9 @@ async function serveRounds({
 }
 var saves = 0;
 async function save(run4) {
-  await mkdir6(dirname6(run4.path), { recursive: true, mode: 448 });
+  await mkdir8(dirname8(run4.path), { recursive: true, mode: 448 });
   const temporary = `${run4.path}.${run4.self}.${saves += 1}.tmp`;
-  await writeFile6(temporary, JSON.stringify(run4.state));
+  await writeFile8(temporary, JSON.stringify(run4.state));
   await rename3(temporary, run4.path);
 }
 async function holdsLock(run4) {
@@ -68546,15 +68840,15 @@ async function runConnectLoop({ context }) {
     await relays.stopAll();
     for (const current2 of run4.served.values()) current2.stop.abort();
     await Promise.all([...run4.served.values()].map((current2) => current2.done));
-    if (await holdsLock(run4)) await rm3(run4.path, { force: true });
+    if (await holdsLock(run4)) await rm4(run4.path, { force: true });
   }
   return 0;
 }
 
 // src/services/connect-service.service.ts
 import { createHash } from "node:crypto";
-import { mkdir as mkdir7, rm as rm4, writeFile as writeFile7 } from "node:fs/promises";
-import { dirname as dirname7, join as join8 } from "node:path";
+import { mkdir as mkdir9, rm as rm5, writeFile as writeFile9 } from "node:fs/promises";
+import { dirname as dirname9, join as join9 } from "node:path";
 var CONNECT_SERVICE_USAGE = `laze connect install|status|stop|uninstall|run: the service that delivers to linked Codex sessions.
 
   laze connect install     install and start it (systemd --user, a LaunchAgent, or detached)
@@ -68567,17 +68861,17 @@ var CONNECT_SERVICE_USAGE = `laze connect install|status|stop|uninstall|run: the
 \`laze openclaw connect --local\`, whose OpenClaw relay it also runs.
 `;
 function installedPathOf({ context }) {
-  return join8(connectFolderOf({ context }), "service.json");
+  return join9(connectFolderOf({ context }), "service.json");
 }
 function logPathOf({ context }) {
-  return join8(connectFolderOf({ context }), "connect.log");
+  return join9(connectFolderOf({ context }), "connect.log");
 }
 function homeOf({ context }) {
-  return context.environment.inherited.HOME ?? dirname7(dirname7(context.environment.configPath));
+  return context.environment.inherited.HOME ?? dirname9(dirname9(context.environment.configPath));
 }
 function serviceNameOf({ context }) {
   const { configPath } = context.environment;
-  if (configPath === join8(homeOf({ context }), ".laze", "config.json")) return "laze-connect";
+  if (configPath === join9(homeOf({ context }), ".laze", "config.json")) return "laze-connect";
   return `laze-connect-${createHash("sha256").update(configPath).digest("hex").slice(0, 8)}`;
 }
 function serviceEnvOf({ context }) {
@@ -68600,10 +68894,10 @@ async function run({ context, command }) {
 async function installSystemd({ context }) {
   const name2 = serviceNameOf({ context });
   const env = context.environment.inherited;
-  const base = env.XDG_CONFIG_HOME || join8(homeOf({ context }), ".config");
-  const file3 = join8(base, "systemd", "user", `${name2}.service`);
-  await mkdir7(dirname7(file3), { recursive: true });
-  await writeFile7(
+  const base = env.XDG_CONFIG_HOME || join9(homeOf({ context }), ".config");
+  const file3 = join9(base, "systemd", "user", `${name2}.service`);
+  await mkdir9(dirname9(file3), { recursive: true });
+  await writeFile9(
     file3,
     systemdUnitOf({ argv: runArgvOf({ context }), env: serviceEnvOf({ context }) })
   );
@@ -68616,10 +68910,10 @@ async function installSystemd({ context }) {
 async function installLaunchd({ context }) {
   const name2 = serviceNameOf({ context });
   const label2 = `ai.laze.${name2}`;
-  const file3 = join8(homeOf({ context }), "Library", "LaunchAgents", `${label2}.plist`);
+  const file3 = join9(homeOf({ context }), "Library", "LaunchAgents", `${label2}.plist`);
   const log = logPathOf({ context });
-  await mkdir7(dirname7(file3), { recursive: true });
-  await writeFile7(
+  await mkdir9(dirname9(file3), { recursive: true });
+  await writeFile9(
     file3,
     launchAgentOf({
       label: label2,
@@ -68671,8 +68965,8 @@ async function installConnectService({ context }) {
   const manager = await managerOf({ context });
   const install = { systemd: installSystemd, launchd: installLaunchd, detached: installDetached };
   const installed = await install[manager]({ context });
-  await mkdir7(dirname7(path), { recursive: true, mode: 448 });
-  await writeFile7(path, JSON.stringify(installed));
+  await mkdir9(dirname9(path), { recursive: true, mode: 448 });
+  await writeFile9(path, JSON.stringify(installed));
   return describeInstalled({ installed });
 }
 function describeInstalled({ installed }) {
@@ -68738,11 +69032,11 @@ async function uninstall({ context }) {
       command: ["systemctl", "--user", "disable", `${installed.name}.service`]
     });
   }
-  if (installed.file) await rm4(installed.file, { force: true });
+  if (installed.file) await rm5(installed.file, { force: true });
   if (installed.manager === "systemd") {
     await run({ context, command: ["systemctl", "--user", "daemon-reload"] });
   }
-  await rm4(path, { force: true });
+  await rm5(path, { force: true });
   context.out(
     `Removed the connect service (${installed.manager}, ${installed.name}). Linked Codex agents get no messages until \`laze connect install\`.
 `
@@ -68784,13 +69078,13 @@ async function newestThreadIn({
   codexHome,
   directory
 }) {
-  const root = join9(codexHome, "sessions");
-  const files2 = await readdir3(root, { recursive: true }).catch(() => []);
+  const root = join10(codexHome, "sessions");
+  const files2 = await readdir4(root, { recursive: true }).catch(() => []);
   const rollouts = files2.filter((file3) => /rollout-.*\.jsonl$/.test(file3));
   const dated = await Promise.all(
     rollouts.map(async (file3) => ({
-      path: join9(root, file3),
-      at: await stat2(join9(root, file3)).then(
+      path: join10(root, file3),
+      at: await stat2(join10(root, file3)).then(
         (info) => info.mtimeMs,
         () => 0
       )
@@ -68821,7 +69115,7 @@ async function stopAdopt({ context, profile }) {
   const running = await readJson({ path });
   if (!running) return;
   context.processes.stop(running.pid);
-  await rm5(path, { force: true });
+  await rm6(path, { force: true });
 }
 async function linkCodexSession({
   context,
@@ -68857,131 +69151,9 @@ async function linkCodexSession({
   ].join("\n");
 }
 
-// src/services/harness-session.service.ts
-import { mkdir as mkdir8, readdir as readdir4, readFile as readFile7, writeFile as writeFile8 } from "node:fs/promises";
-import { hostname as hostname4 } from "node:os";
-import { dirname as dirname8, join as join10 } from "node:path";
-function sessionOf({
-  context,
-  harness,
-  sessionId
-}) {
-  if (!sessionId) return void 0;
-  const inherited = context.environment.inherited;
-  const folder = inherited.CLAUDE_PROJECT_DIR || context.cwd;
-  return {
-    harness,
-    sessionId,
-    folder: displayFolderOf({ folder, home: inherited.HOME }),
-    host: hostname4()
-  };
-}
-function forSession({
-  client,
-  session
-}) {
-  return client.withHeaders(sessionHeadersOf({ session }));
-}
-async function rememberSession({
-  context,
-  claudePid,
-  session
-}) {
-  if (!session || !claudePid) return;
-  const path = statePathOf({ context, kind: "sessions", profile: String(claudePid) });
-  await mkdir8(dirname8(path), { recursive: true, mode: 448 });
-  await writeFile8(path, JSON.stringify(session), { mode: 384 });
-}
-async function currentSessionOf({
-  context,
-  args
-}) {
-  const inherited = context.environment.inherited;
-  const named = flagText({ args, name: "session" });
-  const harness = context.environment.harness;
-  if (named) return sessionOf({ context, harness, sessionId: named });
-  if (harness === "claude-code" && inherited.CLAUDE_CODE_SESSION_ID) {
-    return sessionOf({ context, harness, sessionId: inherited.CLAUDE_CODE_SESSION_ID });
-  }
-  if (harness === "codex" && inherited.CODEX_THREAD_ID) {
-    return sessionOf({ context, harness, sessionId: inherited.CODEX_THREAD_ID });
-  }
-  const nearest = await nearestHarnessOf({ context });
-  if (!nearest) return void 0;
-  const path = statePathOf({ context, kind: "sessions", profile: String(nearest.pid) });
-  return readFile7(path, "utf8").then(
-    (text2) => JSON.parse(text2),
-    () => void 0
-  );
-}
-async function sessionProfileArgs({
-  context,
-  args,
-  session
-}) {
-  if (!session) return args;
-  const key = sessionKeyOf({ session });
-  const config2 = await context.store.read();
-  const bound = config2.sessions?.[key];
-  if (bound && config2.profiles[bound]) {
-    return { ...args, flags: { ...args.flags, profile: bound } };
-  }
-  const own2 = flagText({ args, name: "profile" });
-  if (own2 && config2.profiles[own2]?.kind === "agent") {
-    await context.store.bindSession({ session: key, profile: own2 });
-  }
-  return args;
-}
-async function liveElsewhere({
-  context,
-  key,
-  claudePid
-}) {
-  const folder = dirname8(statePathOf({ context, kind: "sessions", profile: "x" }));
-  for (const file3 of await readdir4(folder).catch(() => [])) {
-    const pid = Number(file3.replace(/\.json$/, ""));
-    if (!pid || pid === claudePid || !context.processes.alive(pid)) continue;
-    const noted = await readFile7(join10(folder, file3), "utf8").then(
-      (text2) => JSON.parse(text2),
-      () => void 0
-    );
-    if (noted && sessionKeyOf({ session: noted }) === key) return true;
-  }
-  return false;
-}
-function notBoundText({ meta: meta3 }) {
-  return `Laze: this agent listens in another session${meta3.bound ? `: ${meta3.bound}` : ""}. Create a new Laze agent with this session: laze agent request. Or move this agent here: laze agent bind.`;
-}
-async function notBoundNotice({
-  context,
-  client,
-  session,
-  error: error62
-}) {
-  if (!(error62 instanceof LazeApiError) || error62.code !== "session_not_bound") return void 0;
-  const meta3 = error62.meta ?? {};
-  if (client && session && meta3.session && meta3.host === session.host) {
-    const claudePid = (await nearestHarnessOf({ context }))?.pid;
-    if (!await liveElsewhere({ context, key: meta3.session, claudePid })) {
-      await client.post("/api/agents/me/bind", {});
-      return { notice: void 0, rebound: true };
-    }
-  }
-  const key = session ? sessionKeyOf({ session }) : "unknown";
-  const path = statePathOf({ context, kind: "told", profile: key });
-  const told = await readFile7(path, "utf8").then(
-    () => true,
-    () => false
-  );
-  if (told) return { notice: void 0 };
-  await mkdir8(dirname8(path), { recursive: true, mode: 448 });
-  await writeFile8(path, String(context.nowMs()), { mode: 384 });
-  return { notice: notBoundText({ meta: meta3 }) };
-}
-
 // src/services/laze-plugin.service.ts
-import { mkdir as mkdir9, readFile as readFile8, writeFile as writeFile9 } from "node:fs/promises";
-import { dirname as dirname9, join as join11 } from "node:path";
+import { mkdir as mkdir10, readFile as readFile9, writeFile as writeFile10 } from "node:fs/promises";
+import { dirname as dirname10, join as join11 } from "node:path";
 
 // src/rules/laze-plugin.rules.ts
 var LAZE_PLUGIN = "laze";
@@ -69073,11 +69245,11 @@ function lazePluginFiles({
 var REGISTER_LIMIT_MS = 6e4;
 var quote2 = (value) => `'${value.replaceAll("'", "'\\''")}'`;
 function pluginFolderOf({ context }) {
-  return join11(dirname9(context.environment.configPath), "plugins");
+  return join11(dirname10(context.environment.configPath), "plugins");
 }
 async function pluginIsCurrent({ context }) {
   const manifest = join11(pluginFolderOf({ context }), LAZE_PLUGIN, ".claude-plugin", "plugin.json");
-  const written = await readFile8(manifest, "utf8").then(
+  const written = await readFile9(manifest, "utf8").then(
     (text2) => JSON.parse(text2).version,
     () => void 0
   );
@@ -69088,8 +69260,8 @@ async function writeLazePlugin({ context }) {
   const files2 = lazePluginFiles({ program: context.program, version: cliVersionOf() });
   for (const [path, text2] of Object.entries(files2)) {
     const target = join11(folder, path);
-    await mkdir9(dirname9(target), { recursive: true });
-    await writeFile9(target, text2);
+    await mkdir10(dirname10(target), { recursive: true });
+    await writeFile10(target, text2);
   }
   return folder;
 }
@@ -69107,9 +69279,19 @@ async function registerWithClaude({ context, folder }) {
   done.abort();
   return code === 0;
 }
+function registeredMarkOf({ context }) {
+  return join11(pluginFolderOf({ context }), "registered");
+}
+async function pluginRegistered({ context }) {
+  return readFile9(registeredMarkOf({ context }), "utf8").then(
+    () => true,
+    () => false
+  );
+}
 async function installLazePlugin({ context }) {
   const folder = await writeLazePlugin({ context });
   const registered = await registerWithClaude({ context, folder });
+  if (registered) await writeFile10(registeredMarkOf({ context }), cliVersionOf());
   return { folder, registered };
 }
 async function plugin({ context, args }) {
@@ -69133,11 +69315,11 @@ async function plugin({ context, args }) {
 }
 
 // src/services/mcp-channel.service.ts
-import { mkdir as mkdir10, rm as rm6, writeFile as writeFile10 } from "node:fs/promises";
-import { dirname as dirname10 } from "node:path";
+import { mkdir as mkdir11, rm as rm7, writeFile as writeFile11 } from "node:fs/promises";
+import { dirname as dirname11 } from "node:path";
 var LAZE_MCP_SERVER = "laze";
 var DEV_CHANNELS_FLAG = "--dangerously-load-development-channels";
-var ROUND_SECONDS2 = 50;
+var ROUND_SECONDS3 = 50;
 var RETRY_MS = 5e3;
 function channelInstructionsOf({ server }) {
   return [
@@ -69224,11 +69406,11 @@ async function pushInbox({
   signal
 }) {
   const marker = statePathOf({ context, kind: "channels", profile });
-  await mkdir10(dirname10(marker), { recursive: true, mode: 448 });
-  await writeFile10(marker, JSON.stringify({ pid: context.processes.pid }));
+  await mkdir11(dirname11(marker), { recursive: true, mode: 448 });
+  await writeFile11(marker, JSON.stringify({ pid: context.processes.pid }));
   try {
     while (!signal.aborted) {
-      const messages = await client.post("/api/agents/me/inbox", { waitSeconds: ROUND_SECONDS2 }, { signal }).catch(async (error62) => {
+      const messages = await client.post("/api/agents/me/inbox", { waitSeconds: ROUND_SECONDS3 }, { signal }).catch(async (error62) => {
         if (signal.aborted) return [];
         context.err(`laze mcp: could not read the inbox: ${String(error62)}
 `);
@@ -69247,10 +69429,41 @@ async function pushInbox({
 `);
     }
   } finally {
-    await rm6(marker, { force: true });
+    await rm7(marker, { force: true });
   }
 }
 
+// src/services/plugin-tip.service.ts
+import { mkdir as mkdir12, readFile as readFile10, writeFile as writeFile12 } from "node:fs/promises";
+import { dirname as dirname12 } from "node:path";
+var RELOAD_TIP = "Laze: the Laze plugin is installed in Claude Code, and this session has not loaded it yet. Tell the user once, in one plain line, that it is optional: typing /reload-plugins makes Laze messages arrive right away; until then they still arrive through the hooks.";
+var LINK_RELOAD_TIP = "Tell the user once, in one plain line, that it is optional: typing /reload-plugins makes Laze messages arrive right away; until then they still arrive through the hooks.";
+function toldPathOf({ context, session }) {
+  return statePathOf({ context, kind: "told", profile: `plugin-${sessionKeyOf({ session })}` });
+}
+async function markReloadTipTold({
+  context,
+  session
+}) {
+  if (!session) return;
+  const path = toldPathOf({ context, session });
+  await mkdir12(dirname12(path), { recursive: true, mode: 448 });
+  await writeFile12(path, String(context.nowMs()), { mode: 384 });
+}
+async function reloadTipOnce({
+  context,
+  session
+}) {
+  if (!session || !await pluginRegistered({ context })) return void 0;
+  const told = await readFile10(toldPathOf({ context, session }), "utf8").then(
+    () => true,
+    () => false
+  );
+  if (told) return void 0;
+  await markReloadTipTold({ context, session });
+  return RELOAD_TIP;
+}
+
 // src/services/agent-commands.service.ts
 function percentOf(agent2) {
   const { contextTokens, contextWindow } = agent2.context;
@@ -69310,7 +69523,7 @@ async function installHooks({
 }) {
   const folder = join12(directory, ".claude");
   const path = join12(folder, "settings.local.json");
-  const current2 = await readFile9(path, "utf8").then(
+  const current2 = await readFile11(path, "utf8").then(
     (text2) => JSON.parse(text2),
     () => ({})
   );
@@ -69321,8 +69534,8 @@ async function installHooks({
     waitCommand: command("wait"),
     preToolCommand: command("pre-tool")
   });
-  await mkdir11(folder, { recursive: true });
-  await writeFile11(path, `${JSON.stringify(settings2, null, 2)}
+  await mkdir13(folder, { recursive: true });
+  await writeFile13(path, `${JSON.stringify(settings2, null, 2)}
 `);
   return path;
 }
@@ -69350,7 +69563,8 @@ function pluginLinesOf({ plugin: plugin2 }) {
   if (plugin2 === void 0) return [];
   if (!plugin2) return ["Claude Code did not take the Laze plugin; the hooks deliver on their own."];
   return [
-    "The Laze plugin is installed in Claude Code: from the next start or resume it delivers too."
+    "The Laze plugin is installed in Claude Code: from the next start or resume it delivers too.",
+    LINK_RELOAD_TIP
   ];
 }
 function mcpLinesOf({
@@ -69505,6 +69719,9 @@ async function nextStepsFor({
   if (harness === "codex") return linkCodexSession({ context, args, profile, laze, directory });
   if (!hooked) return waiterStepsOf({ profile, laze });
   const plugin2 = args.flags["no-plugin"] ? void 0 : await installLazePlugin({ context });
+  if (plugin2?.registered) {
+    await markReloadTipTold({ context, session: await currentSessionOf({ context, args }) });
+  }
   const mcp2 = args.flags.mcp ? await registerMcp({ context, directory, profile }) : void 0;
   const mcpAdd2 = mcpAddCommandOf({ context, profile });
   return claudeStepsOf({ profile, laze, directory, mcp: mcp2, mcpAdd: mcpAdd2, plugin: plugin2?.registered });
@@ -69514,7 +69731,7 @@ async function reportTranscript({
   input: input2
 }) {
   if (!input2.transcript_path || !input2.session_id) return;
-  const lines = (await readFile9(input2.transcript_path, "utf8")).split("\n");
+  const lines = (await readFile11(input2.transcript_path, "utf8")).split("\n");
   const context = readTranscript({ lines });
   await client.post("/api/agents/me/activity", {
     sessionId: input2.session_id,
@@ -69523,6 +69740,10 @@ async function reportTranscript({
     compactions: context.compactions.slice(-20)
   });
 }
+function stopContext({ context, text: text2 }) {
+  const hookSpecificOutput = { hookEventName: "Stop", additionalContext: text2 };
+  context.out(JSON.stringify({ hookSpecificOutput }));
+}
 async function handOver({ context, args }) {
   const raw = await context.readStdin();
   const input2 = raw.trim() ? JSON.parse(raw) : {};
@@ -69534,10 +69755,14 @@ async function handOver({ context, args }) {
 `)
   );
   if (input2.stop_hook_active) return;
+  const claudePid = await claudePidOf({ context });
+  if (await monitorServes({ context, profile: agent2, claudePid })) {
+    return turnEnded({ context, client, agent: agent2 });
+  }
   const kept = await dueFromSpool({
     context,
     profile: agent2,
-    seen: () => input2.transcript_path ? readFile9(input2.transcript_path, "utf8") : Promise.resolve(""),
+    seen: () => input2.transcript_path ? readFile11(input2.transcript_path, "utf8") : Promise.resolve(""),
     pushedToo: false
   });
   const claim3 = forSession({ client, session });
@@ -69547,20 +69772,23 @@ async function handOver({ context, args }) {
   } catch (error62) {
     const refused = await notBoundNotice({ context, client: claim3, session, error: error62 });
     if (!refused) throw error62;
-    if (!refused.notice) return;
-    const additionalContext2 = refused.notice;
-    context.out(
-      JSON.stringify({ hookSpecificOutput: { hookEventName: "Stop", additionalContext: additionalContext2 } })
-    );
+    if (refused.notice) stopContext({ context, text: refused.notice });
     return;
   }
   await keepTaken({ context, profile: agent2, messages: fresh });
   const messages = [...kept, ...fresh];
-  if (messages.length === 0) return turnEnded({ context, client, agent: agent2 });
+  const tip = await reloadTipOnce({ context, session });
+  if (messages.length === 0) {
+    await turnEnded({ context, client, agent: agent2 });
+    if (tip) stopContext({ context, text: tip });
+    return;
+  }
   await turnStarted({ context, client, agent: agent2, messages });
   const self2 = await currentNameOf({ context, client, profile: agent2 });
-  const additionalContext = hookContextOf({ messages, self: self2 });
-  context.out(JSON.stringify({ hookSpecificOutput: { hookEventName: "Stop", additionalContext } }));
+  stopContext({
+    context,
+    text: [hookContextOf({ messages, self: self2 }), tip].filter(Boolean).join("\n\n")
+  });
   const messageIds = messages.map((message2) => message2.messageId);
   await dropFromSpool({ context, profile: agent2, messageIds });
 }
@@ -69569,7 +69797,7 @@ async function addSessionStartWaiter({ context, args }) {
   const profile = flagText({ args, name: "profile" });
   if (!directory || !profile) return;
   const path = join12(directory, ".claude", "settings.local.json");
-  const settings2 = await readFile9(path, "utf8").then(
+  const settings2 = await readFile11(path, "utf8").then(
     (text2) => JSON.parse(text2),
     () => void 0
   );
@@ -69596,7 +69824,7 @@ async function stopHook({ context, args }) {
 }
 
 // src/services/agent-manage-commands.service.ts
-import { readFile as readFile10 } from "node:fs/promises";
+import { readFile as readFile12 } from "node:fs/promises";
 import { extname, resolve as resolve5 } from "node:path";
 
 // src/rules/login-format.rules.ts
@@ -69725,7 +69953,7 @@ async function avatarOf({
 }) {
   const path = flagText({ args, name: "avatar" });
   if (!path) return void 0;
-  const bytes = await readFile10(resolve5(context.cwd, path)).catch(() => {
+  const bytes = await readFile12(resolve5(context.cwd, path)).catch(() => {
     throw new CliUsageError(`laze: cannot read the avatar file ${path}.`);
   });
   const uploaded = await client.post("/api/agents/avatars", {
@@ -70415,8 +70643,8 @@ async function requestAgent({ context, args }) {
 }
 
 // src/services/app-commands.service.ts
-import { mkdir as mkdir12, readdir as readdir5, readFile as readFile11, writeFile as writeFile13 } from "node:fs/promises";
-import { dirname as dirname11, join as join14, relative as relative3, resolve as resolve6, sep as sep2 } from "node:path";
+import { mkdir as mkdir14, readdir as readdir5, readFile as readFile13, writeFile as writeFile15 } from "node:fs/promises";
+import { dirname as dirname13, join as join14, relative as relative3, resolve as resolve6, sep as sep2 } from "node:path";
 
 // ../../modules/app/contract/src/app.connections.ts
 var appFunctionNameSchema = external_exports.string().regex(/^[a-z0-9][a-z0-9_-]{0,63}$/);
@@ -72807,7 +73035,7 @@ async function appPinsCommand({
 
 // src/services/app-script-check.service.ts
 import { execFile } from "node:child_process";
-import { mkdtemp, rm as rm7, writeFile as writeFile12 } from "node:fs/promises";
+import { mkdtemp, rm as rm8, writeFile as writeFile14 } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join as join13 } from "node:path";
 import { promisify } from "node:util";
@@ -72843,7 +73071,7 @@ async function scriptErrorsOf({
     const errors = await Promise.all(
       scripts.map(async (script, index) => {
         const file3 = join13(dir, `${index}.${script.module ? "mjs" : "cjs"}`);
-        await writeFile12(file3, script.code);
+        await writeFile14(file3, script.code);
         try {
           await run2(process.execPath, ["--check", file3]);
           return null;
@@ -72855,7 +73083,7 @@ async function scriptErrorsOf({
     );
     return [...errors.filter((error62) => error62 !== null), ...unknown2];
   } finally {
-    await rm7(dir, { recursive: true, force: true });
+    await rm8(dir, { recursive: true, force: true });
   }
 }
 
@@ -72992,7 +73220,7 @@ async function turnTokenOf({
   const pinned = env.LAZE_TURN_TOKEN?.trim();
   if (pinned) return pinned;
   if (env.LAZE_TURN_FILE) {
-    return readFile11(env.LAZE_TURN_FILE, "utf8").then(
+    return readFile13(env.LAZE_TURN_FILE, "utf8").then(
       (text2) => text2.trim(),
       () => ""
     );
@@ -73018,7 +73246,7 @@ function folderOf({ context, word: word3 }) {
   return resolve6(context.cwd, word3 ?? ".");
 }
 async function readManifest(folder) {
-  const text2 = await readFile11(join14(folder, APP_MANIFEST_FILE), "utf8").catch(() => void 0);
+  const text2 = await readFile13(join14(folder, APP_MANIFEST_FILE), "utf8").catch(() => void 0);
   if (text2 === void 0) return void 0;
   const parsed = appManifestSchema.safeParse(JSON.parse(text2));
   if (!parsed.success) {
@@ -73053,7 +73281,7 @@ async function jsonFlag({
 }) {
   const raw = flagText({ args, name: name2 });
   if (!raw) return void 0;
-  const text2 = raw.startsWith("@") ? await readFile11(resolve6(context.cwd, raw.slice(1)), "utf8") : raw;
+  const text2 = raw.startsWith("@") ? await readFile13(resolve6(context.cwd, raw.slice(1)), "utf8") : raw;
   try {
     return JSON.parse(text2);
   } catch {
@@ -73107,11 +73335,11 @@ var appCreate = async ({ context, args }) => {
     ...visibility ? { visibility } : {}
   });
   const folder = resolve6(context.cwd, flagText({ args, name: "dir", fallback: app2.slug }));
-  await mkdir12(folder, { recursive: true });
+  await mkdir14(folder, { recursive: true });
   const files2 = template ? templateFiles({ template, name: name2 }) : {};
   for (const [path, content] of Object.entries(files2)) {
-    await mkdir12(dirname11(join14(folder, path)), { recursive: true });
-    await writeFile13(join14(folder, path), content);
+    await mkdir14(dirname13(join14(folder, path)), { recursive: true });
+    await writeFile15(join14(folder, path), content);
   }
   const manifest = {
     app: { id: app2.id, name: app2.name, slug: app2.slug },
@@ -73119,7 +73347,7 @@ var appCreate = async ({ context, args }) => {
     views: template?.views ? [...template.views] : [],
     seed: template ? { ...template.seed } : {}
   };
-  await writeFile13(join14(folder, APP_MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
+  await writeFile15(join14(folder, APP_MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
 `);
   print5({
     context,
@@ -73156,7 +73384,7 @@ var appPush = async ({ context, args }) => {
     paths.map(
       async (path) => buildFileOf({
         path: relative3(folder, path).split(sep2).join("/"),
-        bytes: await readFile11(path)
+        bytes: await readFile13(path)
       })
     )
   );
@@ -73531,7 +73759,7 @@ var appExport = async ({ context, args }) => {
   const out = flagText({ args, name: "out" });
   if (!out) return context.out(exported.body);
   const target = resolve6(context.cwd, out);
-  await writeFile13(target, exported.body);
+  await writeFile15(target, exported.body);
   context.out(`Wrote ${exported.rows} records to ${relative3(context.cwd, target)}
 `);
 };
@@ -73539,7 +73767,7 @@ var appImport = async ({ context, args }) => {
   const words = args.words.slice(2);
   const [named, collection, file3] = words.length >= 3 ? words : [void 0, ...words];
   if (!collection || !file3) throw new CliUsageError(USAGE5);
-  const csv = await readFile11(resolve6(context.cwd, file3), "utf8").catch(() => {
+  const csv = await readFile13(resolve6(context.cwd, file3), "utf8").catch(() => {
     throw new CliUsageError(`Cannot read ${file3}`);
   });
   const scoped = named ? { ...args, flags: { ...args.flags, app: named } } : args;
@@ -73558,7 +73786,7 @@ var appImport = async ({ context, args }) => {
   });
   const refusedOut = flagText({ args, name: "refused" });
   if (refusedOut && result.refusedCsv) {
-    await writeFile13(resolve6(context.cwd, refusedOut), result.refusedCsv);
+    await writeFile15(resolve6(context.cwd, refusedOut), result.refusedCsv);
   }
   const fitting = result.rows - result.refused.length;
   const skipped = result.refused.slice(0, 20).map((row) => `  line ${row.line}: ${row.reason}
@@ -74105,8 +74333,8 @@ async function billing({ context, args }) {
 
 // src/services/browser-commands.service.ts
 import { randomBytes } from "node:crypto";
-import { mkdir as mkdir13, readFile as readFile12, writeFile as writeFile14 } from "node:fs/promises";
-import { dirname as dirname12, join as join15 } from "node:path";
+import { mkdir as mkdir15, readFile as readFile14, writeFile as writeFile16 } from "node:fs/promises";
+import { dirname as dirname14, join as join15 } from "node:path";
 
 // src/services/browser-tab-commands.service.ts
 var BROWSER_TAB_PATHS = {
@@ -74652,7 +74880,7 @@ async function turnTokenOf2({ context }) {
   const pinned = env.LAZE_TURN_TOKEN?.trim();
   if (pinned) return pinned;
   if (!env.LAZE_TURN_FILE) return "";
-  return readFile12(env.LAZE_TURN_FILE, "utf8").then(
+  return readFile14(env.LAZE_TURN_FILE, "utf8").then(
     (text2) => text2.trim(),
     () => ""
   );
@@ -74726,7 +74954,7 @@ async function cdp({ context, args }) {
 }
 function bridgeStatePath({ context, machine: machine2 }) {
   const safe = machine2.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join15(dirname12(context.environment.configPath), "bridges", `${safe}.json`);
+  return join15(dirname14(context.environment.configPath), "bridges", `${safe}.json`);
 }
 async function bridgePort({
   context,
@@ -74734,7 +74962,7 @@ async function bridgePort({
   access
 }) {
   const path = bridgeStatePath({ context, machine: machine2 });
-  const live = await readFile12(path, "utf8").then(
+  const live = await readFile14(path, "utf8").then(
     (text2) => JSON.parse(text2),
     () => void 0
   );
@@ -74747,8 +74975,8 @@ async function bridgePort({
     key,
     ...target
   });
-  await mkdir13(dirname12(path), { recursive: true, mode: 448 });
-  await writeFile14(path, JSON.stringify({ port, key }), { mode: 384 });
+  await mkdir15(dirname14(path), { recursive: true, mode: 448 });
+  await writeFile16(path, JSON.stringify({ port, key }), { mode: 384 });
   return port;
 }
 async function bridge({ context }) {
@@ -75392,7 +75620,7 @@ async function channelSettings({ context, args }) {
 }
 
 // src/services/chat-actions-commands.service.ts
-import { readFile as readFile13 } from "node:fs/promises";
+import { readFile as readFile15 } from "node:fs/promises";
 import { basename as basename2, isAbsolute as isAbsolute2, relative as relative4, resolve as resolve7 } from "node:path";
 
 // src/services/file-upload.service.ts
@@ -75697,7 +75925,7 @@ function uploadNameOf({ cwd, path }) {
 }
 var fileUpload = async ({ context, args, client }) => {
   const path = resolve7(context.cwd, wordAt(args, 3));
-  const bytes = new Uint8Array(await readFile13(path));
+  const bytes = new Uint8Array(await readFile15(path));
   const answer4 = await uploadFile({
     context,
     client,
@@ -75862,176 +76090,18 @@ async function chatActions({
 }
 
 // src/services/claude-monitor.service.ts
-import { rm as rm9 } from "node:fs/promises";
-
-// src/services/claude-wait.service.ts
-import { readFile as readFile14, rm as rm8, writeFile as writeFile15, mkdir as mkdir14 } from "node:fs/promises";
-import { dirname as dirname13 } from "node:path";
-var ROUND_SECONDS3 = 50;
-var WATCH_MS = 2e3;
-var CHANNEL_CHECK_MS = 5e3;
-async function holderOf({ path }) {
-  return readFile14(path, "utf8").then(
-    (text2) => JSON.parse(text2),
-    () => void 0
-  );
-}
-async function holderClaudeOf({ context, holder }) {
-  if (holder.claudePid) return holder.claudePid;
-  return (await nearestHarnessOf({ context, from: holder.pid }))?.pid;
-}
-async function takeLock({
-  context,
-  path,
-  sessionId,
-  claudePid,
-  preempt = false
-}) {
-  const holder = await holderOf({ path });
-  const self2 = context.processes.pid;
-  if (holder && holder.pid !== self2 && context.processes.alive(holder.pid)) {
-    const served = await holderClaudeOf({ context, holder });
-    const mine3 = preempt && served === claudePid && !holder.monitor;
-    if (served && context.processes.alive(served) && !mine3) return false;
-    context.processes.stop(holder.pid);
-  }
-  await mkdir14(dirname13(path), { recursive: true, mode: 448 });
-  await writeFile15(
-    path,
-    JSON.stringify({
-      pid: self2,
-      claudePid,
-      ...sessionId ? { sessionId } : {},
-      ...preempt ? { monitor: true } : {}
-    })
-  );
-  return true;
-}
-async function channelLive({ context, profile }) {
-  const holder = await holderOf({ path: statePathOf({ context, kind: "channels", profile }) });
-  return holder !== void 0 && context.processes.alive(holder.pid);
-}
-async function takeRound2({
-  context,
-  client,
-  claudePid,
-  session
-}) {
-  const controller = new AbortController();
-  const { signal } = controller;
-  const watch = (async () => {
-    while (!signal.aborted) {
-      await context.sleep(WATCH_MS, signal);
-      if (claudePid && !context.processes.alive(claudePid)) controller.abort();
-    }
-  })();
-  try {
-    return await forSession({ client, session }).post(
-      "/api/agents/me/inbox",
-      { waitSeconds: ROUND_SECONDS3 },
-      { signal }
-    );
-  } catch (error62) {
-    if (signal.aborted) return [];
-    throw error62;
-  } finally {
-    controller.abort();
-    await watch;
-  }
-}
-async function roundOf({ context, client, name: name2, lock, claudePid, session, seen }) {
-  if ((await holderOf({ path: lock }))?.pid !== context.processes.pid) return void 0;
-  if (claudePid && !context.processes.alive(claudePid)) return void 0;
-  const due = await dueFromSpool({ context, profile: name2, seen, pushedToo: true });
-  if (due.length > 0) return due;
-  if (await channelLive({ context, profile: name2 })) {
-    await context.sleep(CHANNEL_CHECK_MS);
-    return [];
-  }
-  const taken = await takeRound2({ context, client, claudePid, session });
-  if (taken.length === 0) {
-    await context.sleep(1e3);
-    return [];
-  }
-  await keepTaken({ context, profile: name2, messages: taken });
-  return taken;
-}
-async function claudePidOf({ context }) {
-  const harness = await nearestHarnessOf({ context });
-  if (harness?.harness === "claude-code") return harness.pid;
-  return await context.processes.parentOf(context.processes.pid) ?? 0;
-}
-async function settleRound(round) {
-  const { context, client, name: name2, session } = round;
-  const messages = await roundOf(round).catch(async (error62) => {
-    const refused = await notBoundNotice({
-      context,
-      client: forSession({ client, session }),
-      session,
-      error: error62
-    });
-    if (!refused) throw error62;
-    return refused;
-  });
-  if (messages === void 0) return 0;
-  if (!Array.isArray(messages)) {
-    if (messages.rebound) return "again";
-    if (!messages.notice) return 0;
-    context.err(`${messages.notice}
-`);
-    return 2;
-  }
-  if (messages.length === 0) return "again";
-  await turnStarted({ context, client, agent: name2, messages }).catch(() => void 0);
-  const self2 = await currentNameOf({ context, client, profile: name2 });
-  context.err(`${hookContextOf({ messages, self: self2 })}
-`);
-  const messageIds = messages.map((message2) => message2.messageId);
-  await dropFromSpool({ context, profile: name2, messageIds });
-  return 2;
-}
-async function waitForMessages({ context, args }) {
-  const raw = await context.readStdin();
-  const input2 = raw.trim() ? JSON.parse(raw) : {};
-  const session = sessionOf({ context, harness: "claude-code", sessionId: input2.session_id });
-  const named = await sessionProfileArgs({ context, args, session });
-  const { client, name: name2 } = await signedIn({ context, args: named });
-  const claudePid = await claudePidOf({ context });
-  await rememberSession({ context, claudePid, session });
-  const lock = statePathOf({ context, kind: "waiters", profile: name2 });
-  if (!await takeLock({ context, path: lock, sessionId: input2.session_id, claudePid })) return 0;
-  const seen = () => input2.transcript_path ? readFile14(input2.transcript_path, "utf8") : Promise.resolve("");
-  const deadline = context.nowMs() + (WAIT_HOOK_TIMEOUT_SECONDS - 60) * 1e3;
-  try {
-    while (context.nowMs() < deadline) {
-      const code = await settleRound({ context, client, name: name2, lock, claudePid, session, seen });
-      if (code !== "again") return code;
-    }
-    return 0;
-  } finally {
-    if ((await holderOf({ path: lock }))?.pid === context.processes.pid)
-      await rm8(lock, { force: true });
-  }
-}
-async function waitHook({ context, args }) {
-  try {
-    return await waitForMessages({ context, args });
-  } catch (error62) {
-    context.err(`laze: the background waiter stopped: ${String(error62)}
-`);
-    return 0;
-  }
-}
-
-// src/services/claude-monitor.service.ts
+import { readFile as readFile16, rm as rm9 } from "node:fs/promises";
 var MONITOR_IDLE_MS = 3e4;
+var MONITOR_OUTRANKED_MS = 3e3;
 async function agentProfileHere({
   context,
   args,
-  session
+  session,
+  claudePid
 }) {
   const config2 = await context.store.read();
-  const folder = boundProfileOf({ bindings: config2.bindings, cwd: context.cwd });
+  const cwd = (claudePid ? await context.processes.cwdOf(claudePid) : void 0) ?? context.cwd;
+  const folder = boundProfileOf({ bindings: config2.bindings, cwd });
   if (!folder && !session) return void 0;
   const asked = { ...args, flags: { ...args.flags, ...folder ? { profile: folder } : {} } };
   const name2 = flagText({
@@ -76049,11 +76119,13 @@ async function deliverOnce({
 }) {
   const lock = statePathOf({ context, kind: "waiters", profile });
   const mine3 = (await holderOf({ path: lock }))?.pid === context.processes.pid;
-  if (!mine3 && !await takeLock({ context, path: lock, claudePid, preempt: true })) return false;
+  if (!mine3 && !await takeLock({ context, path: lock, claudePid, preempt: true })) {
+    return "outranked";
+  }
   const named = { ...args, flags: { ...args.flags, profile } };
   const { client } = await signedIn({ context, args: named });
   const due = await dueFromSpool({ context, profile, seen: async () => "", pushedToo: true });
-  const taken = due.length > 0 ? [] : await takeRound2({ context, client, claudePid, session });
+  const taken = due.length > 0 ? [] : await takeRound({ context, client, claudePid, session });
   const messages = [...due, ...taken];
   if (messages.length === 0) {
     await context.sleep(1e3);
@@ -76089,23 +76161,46 @@ async function release({ context, profile }) {
 }
 async function monitorHook({ context, args }) {
   const claudePid = await claudePidOf({ context });
-  const sessionId = context.environment.inherited.CLAUDE_CODE_SESSION_ID;
-  const session = sessionOf({ context, harness: "claude-code", sessionId });
-  await rememberSession({ context, claudePid, session });
+  const session = await monitorSessionOf({ context, claudePid });
+  await rememberSession({ context, claudePid, session }).catch(() => void 0);
   const held = /* @__PURE__ */ new Set();
   const turn = { context, args, claudePid, session };
   try {
     while (claudePid && context.processes.alive(claudePid)) {
-      const profile = await agentProfileHere({ context, args, session });
-      const busy = profile ? await monitorRound({ ...turn, profile }) : false;
-      if (profile && busy) held.add(profile);
-      if (!busy) await context.sleep(MONITOR_IDLE_MS);
+      const round = await oneRound({ turn, held });
+      if (round === "outranked") await context.sleep(MONITOR_OUTRANKED_MS);
+      else if (!round) await context.sleep(MONITOR_IDLE_MS);
     }
     return 0;
   } finally {
-    for (const profile of held) await release({ context, profile });
+    for (const profile of held) await release({ context, profile }).catch(() => void 0);
+  }
+}
+async function oneRound({ turn, held }) {
+  try {
+    const profile = await agentProfileHere(turn);
+    const round = profile ? await monitorRound({ ...turn, profile }) : false;
+    if (profile && round === true) held.add(profile);
+    return round;
+  } catch (error62) {
+    turn.context.err(`laze: the monitor will try again: ${String(error62)}
+`);
+    return false;
   }
 }
+async function monitorSessionOf({
+  context,
+  claudePid
+}) {
+  const sessionId = context.environment.inherited.CLAUDE_CODE_SESSION_ID;
+  const fromEnv = sessionOf({ context, harness: "claude-code", sessionId });
+  if (fromEnv || !claudePid) return fromEnv;
+  const path = statePathOf({ context, kind: "sessions", profile: String(claudePid) });
+  return readFile16(path, "utf8").then(
+    (text2) => JSON.parse(text2),
+    () => void 0
+  );
+}
 
 // ../../modules/compute/contract/src/browser-tab.ts
 var browserTabSharingSchema = external_exports.enum(["private", "watch", "use"]);
@@ -77588,10 +77683,10 @@ async function computer({ context, args }) {
 }
 
 // src/services/connect-commands.service.ts
-import { readFile as readFile16 } from "node:fs/promises";
+import { readFile as readFile18 } from "node:fs/promises";
 
 // src/services/mcp-gateway.service.ts
-import { readFile as readFile15 } from "node:fs/promises";
+import { readFile as readFile17 } from "node:fs/promises";
 import { createInterface as createInterface3 } from "node:readline";
 var TURN_HEADER = "x-laze-turn";
 function serveMcpGateway({
@@ -77634,7 +77729,7 @@ async function relayMcpLines({
   const github3 = env.LAZE_GITHUB_CONNECTION;
   const url2 = `${profile.url.replace(/\/+$/, "")}/api/connectors/mcp/${encodeURIComponent(profile.agentId)}${github3 ? `?github=${encodeURIComponent(github3)}` : ""}`;
   const turnFile = env.LAZE_TURN_FILE;
-  const readTurn = () => readFile15(turnFile, "utf8").then(
+  const readTurn = () => readFile17(turnFile, "utf8").then(
     (text2) => text2.trim(),
     () => ""
   );
@@ -77724,7 +77819,7 @@ async function turnOf({ context }) {
   const pinned = env.LAZE_TURN_TOKEN?.trim();
   if (pinned) return pinned;
   const file3 = env.LAZE_TURN_FILE;
-  const turn = file3 ? await readFile16(file3, "utf8").then(
+  const turn = file3 ? await readFile18(file3, "utf8").then(
     (text2) => text2.trim(),
     () => ""
   ) : "";
@@ -77782,11 +77877,11 @@ async function connect({
 }
 
 // src/services/connector-commands.service.ts
-import { readFile as readFile18 } from "node:fs/promises";
+import { readFile as readFile20 } from "node:fs/promises";
 import { resolve as resolve8 } from "node:path";
 
 // src/services/vault-keychain-commands.service.ts
-import { readFile as readFile17 } from "node:fs/promises";
+import { readFile as readFile19 } from "node:fs/promises";
 
 // src/rules/vault-input.rules.ts
 function secondsOf(text2) {
@@ -78097,7 +78192,7 @@ async function secretText({ context, args }) {
     );
   }
   const file3 = flagText({ args, name: "from-file" });
-  const text2 = file3 ? await readFile17(file3, "utf8") : await context.readStdin();
+  const text2 = file3 ? await readFile19(file3, "utf8") : await context.readStdin();
   const trimmed = text2.replace(/\r?\n$/, "");
   if (!trimmed.trim()) throw new CliUsageError("No value: pipe it on stdin or use --from-file.");
   return trimmed;
@@ -78295,7 +78390,7 @@ async function keyText({ context, args }) {
     throw new CliUsageError("A key never goes in a flag: pipe it on stdin or use --from-file.");
   }
   const file3 = flagText({ args, name: "from-file" });
-  const text2 = file3 ? await readFile18(resolve8(context.cwd, file3), "utf8") : await context.readStdin();
+  const text2 = file3 ? await readFile20(resolve8(context.cwd, file3), "utf8") : await context.readStdin();
   const trimmed = text2.trim();
   if (!trimmed) throw new CliUsageError("No key: pipe it on stdin or use --from-file.");
   return trimmed;
@@ -78714,7 +78809,7 @@ async function domains({ context, args }) {
 }
 
 // src/services/feed-commands.service.ts
-import { readFile as readFile20 } from "node:fs/promises";
+import { readFile as readFile22 } from "node:fs/promises";
 import { resolve as resolve10 } from "node:path";
 
 // src/rules/feed-input.rules.ts
@@ -78839,7 +78934,7 @@ function feedFlagsOf({ args }) {
 }
 
 // src/services/feed-files.service.ts
-import { readFile as readFile19 } from "node:fs/promises";
+import { readFile as readFile21 } from "node:fs/promises";
 import { basename as basename3, resolve as resolve9 } from "node:path";
 
 // ../../modules/feed/contract/src/feed.ts
@@ -79432,7 +79527,7 @@ async function local({ context, path }) {
   return {
     fileName,
     contentType: contentTypeOf(fileName),
-    bytes: new Uint8Array(await readFile19(full))
+    bytes: new Uint8Array(await readFile21(full))
   };
 }
 async function directWith({ client, to }) {
@@ -79510,7 +79605,7 @@ async function bodyOf2({
   flags: flags2
 }) {
   const body = { ...flags2.fields };
-  const read3 = (source) => "file" in source ? readFile20(resolve10(context.cwd, source.file), "utf8") : source.text;
+  const read3 = (source) => "file" in source ? readFile22(resolve10(context.cwd, source.file), "utf8") : source.text;
   for (const [field, source] of Object.entries(flags2.texts)) body[field] = await read3(source);
   if (flags2.rich) {
     const text2 = await read3(flags2.rich.source);
@@ -79672,7 +79767,7 @@ async function textFlag({
 }) {
   const value = flagText({ args, name: name2 });
   if (!value.startsWith("@")) return value;
-  return readFile20(resolve10(context.cwd, value.slice(1)), "utf8");
+  return readFile22(resolve10(context.cwd, value.slice(1)), "utf8");
 }
 async function feedList({ context, args }) {
   const { client } = await signedIn({ context, args });
@@ -79782,7 +79877,7 @@ async function feed({ context, args }) {
 }
 
 // src/services/github-commands.service.ts
-import { readFile as readFile21 } from "node:fs/promises";
+import { readFile as readFile23 } from "node:fs/promises";
 
 // src/rules/github-signature.rules.ts
 var TURN_SEPARATOR = "~";
@@ -79852,7 +79947,7 @@ var REAL_GH = "/usr/bin/gh";
 var NOT_SET = "laze: agent_github_not_set: this agent has no GitHub connection. Its owner sets one on the agent's settings page or with `laze agent set-github <agent> <connection>`.";
 async function turnFileToken({ env }) {
   if (!env.LAZE_TURN_FILE) return "";
-  return readFile21(env.LAZE_TURN_FILE, "utf8").then(
+  return readFile23(env.LAZE_TURN_FILE, "utf8").then(
     (text2) => text2.trim(),
     () => ""
   );
@@ -79886,7 +79981,7 @@ async function githubGh({
     args: args.rest,
     agentName: profile.name ?? "An agent",
     threadUrl: threadUrlOf({ env, workspaceId: profile.workspaceId }),
-    readBodyFile: (path) => path === "-" ? context.readStdin() : readFile21(path, "utf8")
+    readBodyFile: (path) => path === "-" ? context.readStdin() : readFile23(path, "utf8")
   });
   return context.runCommand({
     command: [REAL_GH, ...ghArgs],
@@ -79985,7 +80080,7 @@ async function setAgentGithub({
 }
 
 // src/services/history-commands.service.ts
-import { readFile as readFile22 } from "node:fs/promises";
+import { readFile as readFile24 } from "node:fs/promises";
 
 // src/rules/history-format.rules.ts
 function timeOf2(iso) {
@@ -80081,7 +80176,7 @@ async function turnTokenOf3({ context }) {
   const pinned = env.LAZE_TURN_TOKEN?.trim();
   if (pinned) return pinned;
   if (!env.LAZE_TURN_FILE) return "";
-  return readFile22(env.LAZE_TURN_FILE, "utf8").then(
+  return readFile24(env.LAZE_TURN_FILE, "utf8").then(
     (text2) => text2.trim(),
     () => ""
   );
@@ -80273,19 +80368,19 @@ async function ip({ context, args }) {
 }
 
 // src/services/join-commands.service.ts
-import { mkdir as mkdir15, readFile as readFile23, rename as rename5, rm as rm10, writeFile as writeFile16 } from "node:fs/promises";
-import { dirname as dirname14, join as join16 } from "node:path";
+import { mkdir as mkdir16, readFile as readFile25, rename as rename5, rm as rm10, writeFile as writeFile17 } from "node:fs/promises";
+import { dirname as dirname15, join as join16 } from "node:path";
 var DEFAULT_WAIT_SECONDS2 = 100;
 var JOIN_USAGE = "Usage: laze join [--workspace <name|id|invite link>] [--for <email>] [--name <name>] [--note <text>] [--timeout <seconds>] [--project <folder>]";
 function pendingPathOf({ context }) {
-  return join16(dirname14(context.environment.configPath), "join", "pending.json");
+  return join16(dirname15(context.environment.configPath), "join", "pending.json");
 }
 async function readPending({
   context,
   url: url2,
   args
 }) {
-  const pending = await readFile23(pendingPathOf({ context }), "utf8").then(
+  const pending = await readFile25(pendingPathOf({ context }), "utf8").then(
     (text2) => JSON.parse(text2),
     () => void 0
   );
@@ -80295,9 +80390,9 @@ async function readPending({
 }
 async function keepPending({ context, pending }) {
   const path = pendingPathOf({ context });
-  await mkdir15(dirname14(path), { recursive: true, mode: 448 });
+  await mkdir16(dirname15(path), { recursive: true, mode: 448 });
   const temporary = `${path}.${process.pid}.tmp`;
-  await writeFile16(temporary, JSON.stringify(pending), { mode: 384 });
+  await writeFile17(temporary, JSON.stringify(pending), { mode: 384 });
   await rename5(temporary, path);
 }
 async function dropPending({ context }) {
@@ -80615,9 +80710,9 @@ function machineAccessCommand(name2) {
 
 // src/services/vault-commands.service.ts
 import { createHash as createHash2 } from "node:crypto";
-import { mkdir as mkdir16, readFile as readFile24, rm as rm11, writeFile as writeFile17 } from "node:fs/promises";
+import { mkdir as mkdir17, readFile as readFile26, rm as rm11, writeFile as writeFile18 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { dirname as dirname15, join as join17 } from "node:path";
+import { dirname as dirname16, join as join17 } from "node:path";
 var USAGE10 = `Usage: laze vault run <connection> --reason "<one plain sentence>" [--wait <s>] -- <command> [args...]
 Runs the command with the connection's values in its environment, on a Laze agent's computer
 or on a machine it runs on.`;
@@ -80656,7 +80751,7 @@ async function turnTokenOf4({
   if (pinned) return pinned;
   if (!turnFile) throw new CliUsageError(`${command} works only during an agent's turn`);
   try {
-    return (await readFile24(turnFile, "utf8")).trim();
+    return (await readFile26(turnFile, "utf8")).trim();
   } catch {
     throw new CliUsageError(`${command} works only during an agent's turn`);
   }
@@ -80666,11 +80761,11 @@ function runKeyPathOf({
   connection
 }) {
   const name2 = createHash2("sha256").update(connection).digest("hex");
-  const base = turnFile ? dirname15(turnFile) : join17(tmpdir2(), "laze-vault");
+  const base = turnFile ? dirname16(turnFile) : join17(tmpdir2(), "laze-vault");
   return join17(base, "vault-run-keys", `${name2}.json`);
 }
 async function runKeyAt({ path }) {
-  const saved3 = await readFile24(path, "utf8").then(
+  const saved3 = await readFile26(path, "utf8").then(
     (text2) => JSON.parse(text2),
     () => void 0
   );
@@ -80680,8 +80775,8 @@ async function runKeyAt({ path }) {
   }
   const fresh = await generateEcdhKeys();
   const jwk = await globalThis.crypto.subtle.exportKey("jwk", fresh.privateKey);
-  await mkdir16(dirname15(path), { recursive: true, mode: 448 });
-  await writeFile17(path, JSON.stringify({ publicKey: fresh.publicKey, privateKey: jwk }), {
+  await mkdir17(dirname16(path), { recursive: true, mode: 448 });
+  await writeFile18(path, JSON.stringify({ publicKey: fresh.publicKey, privateKey: jwk }), {
     mode: 384
   });
   return fresh;
@@ -81352,14 +81447,14 @@ async function serveMcp({
 }
 
 // src/services/mount-files.service.ts
-import { mkdir as mkdir17, readFile as readFile25, rm as rm12, writeFile as writeFile18 } from "node:fs/promises";
-import { dirname as dirname16, relative as relative5, resolve as resolve11 } from "node:path";
+import { mkdir as mkdir18, readFile as readFile27, rm as rm12, writeFile as writeFile19 } from "node:fs/promises";
+import { dirname as dirname17, relative as relative5, resolve as resolve11 } from "node:path";
 async function textArgument({
   context,
   value
 }) {
   if (value === "-") return context.readStdin();
-  if (value.startsWith("@")) return readFile25(resolve11(context.cwd, value.slice(1)), "utf8");
+  if (value.startsWith("@")) return readFile27(resolve11(context.cwd, value.slice(1)), "utf8");
   return value;
 }
 function turnChannel({ context, args }) {
@@ -81373,14 +81468,14 @@ async function writeMount({
 }) {
   const root = resolve11(context.cwd, flagText({ args, name: "dir", fallback: ".laze" }), folder);
   await rm12(root, { recursive: true, force: true });
-  await mkdir17(root, { recursive: true });
+  await mkdir18(root, { recursive: true });
   for (const file3 of files2) {
     const target = resolve11(root, file3.path);
     const inside = relative5(root, target);
     if (!inside || inside.startsWith(".."))
       throw new Error(`Refusing to write outside ${root}: ${file3.path}`);
-    await mkdir17(dirname16(target), { recursive: true });
-    await writeFile18(target, file3.content);
+    await mkdir18(dirname17(target), { recursive: true });
+    await writeFile19(target, file3.content);
   }
   return root;
 }
@@ -82257,7 +82352,7 @@ async function schedule({ context, args }) {
 }
 
 // src/services/skill-commands.service.ts
-import { readdir as readdir6, readFile as readFile26 } from "node:fs/promises";
+import { readdir as readdir6, readFile as readFile28 } from "node:fs/promises";
 import { join as join18, relative as relative6, resolve as resolve12 } from "node:path";
 var USAGE16 = `Usage:
   laze skill list [--agent <agentId>]
@@ -82280,7 +82375,7 @@ async function folderFiles({ root }) {
   for (const entry of entries) {
     if (!entry.isFile()) continue;
     const full = join18(entry.parentPath, entry.name);
-    files2.push({ path: relative6(root, full), content: await readFile26(full, "utf8") });
+    files2.push({ path: relative6(root, full), content: await readFile28(full, "utf8") });
   }
   return files2.toSorted((a, b) => a.path.localeCompare(b.path));
 }
@@ -82378,7 +82473,7 @@ async function skillUpdate({ context, args }) {
   if (!name2 || !newName && description === void 0 && !skillMdFile) {
     throw new CliUsageError(USAGE16);
   }
-  const skillMd = skillMdFile ? await readFile26(resolve12(context.cwd, skillMdFile), "utf8") : void 0;
+  const skillMd = skillMdFile ? await readFile28(resolve12(context.cwd, skillMdFile), "utf8") : void 0;
   const { client } = await signedIn({ context, args });
   const updated = await client.post("/api/skills/update", {
     name: name2,
@@ -82424,7 +82519,7 @@ async function skill({ context, args }) {
 }
 
 // src/services/slack-commands.service.ts
-import { readFile as readFile27 } from "node:fs/promises";
+import { readFile as readFile29 } from "node:fs/promises";
 import { resolve as resolve13 } from "node:path";
 var SLACK_USAGE = `Usage (a person's key; Slack stays the source, the bot joins no channel by itself):
   laze slack overview                            connected Slack workspaces, mirrors, your link
@@ -82472,7 +82567,7 @@ async function secretLines({ context, args }) {
     throw new CliUsageError("A secret never goes in a flag: pipe it on stdin or use --from-file.");
   }
   const file3 = flagText({ args, name: "from-file" });
-  const text2 = file3 ? await readFile27(resolve13(context.cwd, file3), "utf8") : await context.readStdin();
+  const text2 = file3 ? await readFile29(resolve13(context.cwd, file3), "utf8") : await context.readStdin();
   return text2.split("\n").map((line) => line.trim()).filter(Boolean);
 }
 async function secretsOf({
@@ -82776,7 +82871,7 @@ async function slack({
 }
 
 // src/services/sso-commands.service.ts
-import { readFile as readFile28 } from "node:fs/promises";
+import { readFile as readFile30 } from "node:fs/promises";
 var SSO_USAGE = `Usage:
   laze sso domains                                claimed domains and how each signs in (admins)
   laze sso claim <domain>                         the TXT record that proves the domain
@@ -82863,7 +82958,7 @@ function refuseSecretFlags({ args }) {
 }
 async function clientSecretOf({ context, args }) {
   const file3 = flagText({ args, name: "from-file" });
-  const text2 = file3 ? await readFile28(file3, "utf8") : await context.readStdin();
+  const text2 = file3 ? await readFile30(file3, "utf8") : await context.readStdin();
   const secret = text2.trim();
   if (!secret) throw new CliUsageError("No client secret: pipe it on stdin or use --from-file.");
   return secret;
@@ -83196,7 +83291,7 @@ async function vaultScrub({ context, args }) {
 }
 
 // src/services/whatsapp-business-commands.service.ts
-import { readFile as readFile29 } from "node:fs/promises";
+import { readFile as readFile31 } from "node:fs/promises";
 import { resolve as resolve14 } from "node:path";
 
 // ../../modules/whatsapp-business/contract/src/whatsapp-business.prices.ts
@@ -83616,7 +83711,7 @@ async function secretsOf2({ context, args }) {
   const fromConnection = flagText({ args, name: "from-vault" });
   if (fromConnection) return { fromConnection };
   const file3 = flagText({ args, name: "from-file" });
-  const text2 = file3 ? await readFile29(resolve14(context.cwd, file3), "utf8") : await context.readStdin();
+  const text2 = file3 ? await readFile31(resolve14(context.cwd, file3), "utf8") : await context.readStdin();
   const lines = text2.split("\n").map((line) => line.trim()).filter(Boolean);
   if (lines.length !== 2) {
     throw new CliUsageError(
@@ -83817,7 +83912,7 @@ async function whatsappBusiness({
 }
 
 // src/services/whatsapp-pairing-commands.service.ts
-import { writeFile as writeFile19 } from "node:fs/promises";
+import { writeFile as writeFile20 } from "node:fs/promises";
 import { resolve as resolve15 } from "node:path";
 var WHATSAPP_PAIRING_USAGE = [
   "       laze whatsapp pair <machine> [--qr <file.svg>]     link WhatsApp on your machine; scan the code (owner)",
@@ -83838,7 +83933,7 @@ function svgOf(dataUrl) {
 }
 async function report({ context, args, pairing: pairing2 }) {
   const qrFile = pairing2.qrSvg ? resolve15(context.cwd, flagText({ args, name: "qr", fallback: "whatsapp-qr.svg" })) : null;
-  if (qrFile && pairing2.qrSvg) await writeFile19(qrFile, svgOf(pairing2.qrSvg), "utf8");
+  if (qrFile && pairing2.qrSvg) await writeFile20(qrFile, svgOf(pairing2.qrSvg), "utf8");
   if (args.flags.json) return context.out(`${JSON.stringify({ ...pairing2, qrFile }, null, 2)}
 `);
   context.out(`${pairing2.pairingId}	${pairing2.state}
@@ -84197,7 +84292,7 @@ async function flags({ context, args }) {
 }
 
 // src/services/workspace-commands.service.ts
-import { readFile as readFile30 } from "node:fs/promises";
+import { readFile as readFile32 } from "node:fs/promises";
 import { resolve as resolve16 } from "node:path";
 var ROLE_NAMES2 = {
   OWNER: "Owner",
@@ -84380,7 +84475,7 @@ var LOGO_USAGE = "Usage: laze workspace logo set <file.png|jpg|webp> | laze work
 async function readLogo({ context, file: file3 }) {
   let bytes;
   try {
-    bytes = new Uint8Array(await readFile30(resolve16(context.cwd, file3)));
+    bytes = new Uint8Array(await readFile32(resolve16(context.cwd, file3)));
   } catch {
     throw new CliUsageError(`No file to read at ${file3}.`);
   }
@@ -85041,8 +85136,8 @@ async function runCli({
 // src/services/processes.service.ts
 import { execFile as execFile2, spawn as spawn4 } from "node:child_process";
 import { mkdirSync, openSync } from "node:fs";
-import { readFile as readFile31, readlink } from "node:fs/promises";
-import { dirname as dirname17 } from "node:path";
+import { readFile as readFile33, readlink } from "node:fs/promises";
+import { dirname as dirname18 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 var run3 = promisify2(execFile2);
 function alive(pid) {
@@ -85055,14 +85150,14 @@ function alive(pid) {
   }
 }
 async function argsOf(pid) {
-  const raw = await readFile31(`/proc/${pid}/cmdline`, "utf8").catch(() => void 0);
+  const raw = await readFile33(`/proc/${pid}/cmdline`, "utf8").catch(() => void 0);
   if (raw) return raw.split("\0").filter(Boolean);
   const listed = await run3("ps", ["-o", "args=", "-p", String(pid)]).catch(() => void 0);
   const line = listed?.stdout.trim();
   return line ? line.split(/\s+/) : void 0;
 }
 async function parentOf(pid) {
-  const stat3 = await readFile31(`/proc/${pid}/stat`, "utf8").catch(() => void 0);
+  const stat3 = await readFile33(`/proc/${pid}/stat`, "utf8").catch(() => void 0);
   const fromStat = stat3 ? Number(stat3.slice(stat3.lastIndexOf(")") + 2).split(" ")[1]) : NaN;
   if (fromStat > 0) return fromStat;
   const listed = await run3("ps", ["-o", "ppid=", "-p", String(pid)]).catch(() => void 0);
@@ -85079,7 +85174,7 @@ async function cwdOf(pid) {
   return line ? line.slice(1) : void 0;
 }
 function spawnDetached({ argv, logPath }) {
-  mkdirSync(dirname17(logPath), { recursive: true, mode: 448 });
+  mkdirSync(dirname18(logPath), { recursive: true, mode: 448 });
   const log = openSync(logPath, "a", 384);
   const [program = "", ...rest] = argv;
   const child = spawn4(program, rest, { detached: true, stdio: ["ignore", log, log] });