@lazehq/cli 0.1.16 → 0.1.18

package/dist/laze.mjs

@@ -18733,7 +18733,7 @@ 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: writeFile21, readFile: readFile34, mkdir: mkdir19 } = __require("node:fs/promises");
+    var { writeFile: writeFile21, readFile: readFile35, 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();
@@ -18950,7 +18950,7 @@ var require_snapshot_recorder = __commonJS({
           throw new InvalidArgumentError("Snapshot path is required");
         }
         try {
-          const data = await readFile34(resolve17(path), "utf8");
+          const data = await readFile35(resolve17(path), "utf8");
           const parsed = JSON.parse(data);
           if (Array.isArray(parsed)) {
             this.#snapshots.clear();
@@ -35606,7 +35606,7 @@ function flagText({
 }
 
 // src/rules/cli-version.rules.ts
-var STAMPED = "0.1.16";
+var STAMPED = "0.1.18";
 function cliVersionOf({ stamped = STAMPED } = {}) {
   return stamped.startsWith("__") ? "dev" : stamped;
 }
@@ -65390,8 +65390,8 @@ async function copyAgent({
 }
 
 // src/services/agent-commands.service.ts
-import { mkdir as mkdir13, readFile as readFile11, writeFile as writeFile13 } from "node:fs/promises";
-import { join as join12, resolve as resolve4 } from "node:path";
+import { mkdir as mkdir13, readFile as readFile12, writeFile as writeFile13 } from "node:fs/promises";
+import { join as join13, resolve as resolve4 } from "node:path";
 
 // src/rules/agent-profile.rules.ts
 var LEVELS = { fast: "Laze Fast", frontier: "Laze Frontier" };
@@ -65486,7 +65486,8 @@ function lazeCommandOf({ program }) {
 
 // src/rules/hook-settings.rules.ts
 var LAZE_HOOK_MARKER = "laze-cli-hook";
-var TIMEOUTS = { Stop: 30, PreToolUse: 5, SessionStart: 30 };
+var HOOK_TIMEOUTS = { Stop: 30, PreToolUse: 5, SessionStart: 30 };
+var TIMEOUTS = HOOK_TIMEOUTS;
 var WAIT_HOOK_TIMEOUT_SECONDS = 7 * 24 * 60 * 60;
 function withHooks({
   hooks,
@@ -65549,12 +65550,17 @@ function hookCommand({
   const words = [...program, "hook", hook, "--profile", profile].map(quote4).join(" ");
   return `${words} # ${LAZE_HOOK_MARKER}`;
 }
-function lacksSessionStartWaiter({ settings: settings2 }) {
+function holdsOurs({ settings: settings2, event }) {
   const hooks = settings2.hooks ?? {};
-  const ours = (event) => Array.isArray(hooks[event]) && hooks[event].some(
+  return Array.isArray(hooks[event]) && hooks[event].some(
     (entry) => entry.hooks?.some((hook) => hook.command?.includes(LAZE_HOOK_MARKER))
   );
-  return ours("Stop") && !ours("SessionStart");
+}
+function lacksSessionStartWaiter({ settings: settings2 }) {
+  return holdsOurs({ settings: settings2, event: "Stop" }) && !holdsOurs({ settings: settings2, event: "SessionStart" });
+}
+function hasLazeHooks({ settings: settings2 }) {
+  return holdsOurs({ settings: settings2, event: "Stop" });
 }
 
 // src/rules/inbox-format.rules.ts
@@ -66516,15 +66522,323 @@ function formatSearch({
 }
 
 // src/services/claude-turn.service.ts
-import { mkdir as mkdir2, readFile as readFile2, rm, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir4, readFile as readFile5, rm, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname4, join as join5 } from "node:path";
+
+// src/services/harness-session.service.ts
+import { mkdir as mkdir3, readdir, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
+import { hostname as hostname3 } from "node:os";
+import { dirname as dirname3, join as join3 } from "node:path";
+
+// src/rules/session-headers.rules.ts
+import { relative, 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 = relative(home, folder);
+  if (below === "") return "~";
+  if (below.startsWith("..") || below.startsWith(sep)) return folder;
+  return `~/${below.split(sep).join("/")}`;
+}
+
+// src/services/claude-project.service.ts
+import { basename, isAbsolute, relative as relative2, resolve as resolve2 } from "node:path";
+function harnessIn({ words }) {
+  const names = words.slice(0, 2).map((word3) => basename(word3).replace(/\.(js|mjs|cjs)$/, ""));
+  if (names.includes("codex")) return "codex";
+  if (words.some((word3) => word3.includes("@openai/codex"))) return "codex";
+  const claude = words.some((word3) => word3.includes("@anthropic-ai/claude-code"));
+  return claude || names.includes("claude") ? "claude-code" : void 0;
+}
+async function nearestHarnessOf({
+  context,
+  from = context.processes.pid
+}) {
+  let pid = await context.processes.parentOf(from);
+  for (let depth = 0; pid !== void 0 && pid > 1 && depth < 12; depth += 1) {
+    const harness = harnessIn({ words: await context.processes.argsOf(pid) ?? [] });
+    if (harness) return { harness, pid };
+    pid = await context.processes.parentOf(pid);
+  }
+  return void 0;
+}
+function holds({ folder, inner }) {
+  const rel = relative2(resolve2(folder), resolve2(inner));
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+async function claudeProjectOf({
+  context,
+  claudePid
+}) {
+  const env = context.environment.inherited;
+  const pid = Number(env.CLAUDE_PID);
+  const candidates = [
+    claudePid ? await context.processes.cwdOf(claudePid) : void 0,
+    env.CLAUDE_PROJECT_DIR ? resolve2(env.CLAUDE_PROJECT_DIR) : void 0,
+    pid > 0 ? await context.processes.cwdOf(pid) : void 0
+  ].filter((folder) => Boolean(folder));
+  return candidates.find((folder) => holds({ folder, inner: context.cwd })) ?? resolve2(context.cwd);
+}
+
+// src/services/inbox-spool.service.ts
+import { mkdir as mkdir2, readFile as readFile2, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname2, join as join2 } from "node:path";
+var PUSH_GRACE_MS = 3 * 6e4;
+function fileNameOf({ profile }) {
+  return profile.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function statePathOf({
+  context,
+  kind,
+  profile,
+  extension: extension2 = "json"
+}) {
+  const directory = join2(dirname2(context.environment.configPath), kind);
+  return join2(directory, `${fileNameOf({ profile })}.${extension2}`);
+}
+async function readSpool({ path }) {
+  return readFile2(path, "utf8").then(
+    (text2) => JSON.parse(text2),
+    () => []
+  );
+}
+async function writeSpool({ path, entries }) {
+  await mkdir2(dirname2(path), { recursive: true, mode: 448 });
+  const temporary = `${path}.${process.pid}.tmp`;
+  await writeFile2(temporary, JSON.stringify(entries), { mode: 384 });
+  await rename2(temporary, path);
+}
+async function keepTaken({
+  context,
+  profile,
+  messages,
+  pushed = false
+}) {
+  if (messages.length === 0) return;
+  const path = statePathOf({ context, kind: "spool", profile });
+  const ids = new Set(messages.map((message2) => message2.messageId));
+  const kept = (await readSpool({ path })).filter((entry) => !ids.has(entry.message.messageId));
+  const now = context.nowMs();
+  const taken = messages.map((message2) => ({
+    message: message2,
+    takenAt: now,
+    ...pushed ? { pushedAt: now } : {}
+  }));
+  await writeSpool({ path, entries: [...kept, ...taken] });
+}
+async function dropFromSpool({
+  context,
+  profile,
+  messageIds
+}) {
+  if (messageIds.length === 0) return;
+  const path = statePathOf({ context, kind: "spool", profile });
+  const entries = await readSpool({ path });
+  const ids = new Set(messageIds);
+  const kept = entries.filter((entry) => !ids.has(entry.message.messageId));
+  if (kept.length !== entries.length) await writeSpool({ path, entries: kept });
+}
+async function dueFromSpool({
+  context,
+  profile,
+  seen,
+  pushedToo
+}) {
+  const path = statePathOf({ context, kind: "spool", profile });
+  const entries = await readSpool({ path });
+  const pushed = entries.some((entry) => entry.pushedAt !== void 0);
+  const text2 = pushed ? await seen().catch(() => "") : "";
+  const shown = entries.filter(
+    (entry) => entry.pushedAt !== void 0 && text2.includes(entry.message.messageId)
+  );
+  await dropFromSpool({
+    context,
+    profile,
+    messageIds: shown.map((entry) => entry.message.messageId)
+  });
+  const late = context.nowMs() - PUSH_GRACE_MS;
+  return entries.filter((entry) => !shown.includes(entry)).filter((entry) => entry.pushedAt === void 0 || pushedToo && entry.pushedAt <= late).map((entry) => entry.message);
+}
+
+// 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 mkdir3(dirname3(path), { recursive: true, mode: 448 });
+  await writeFile3(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 readFile3(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 = dirname3(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 readFile3(join3(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 readFile3(path, "utf8").then(
+    () => true,
+    () => false
+  );
+  if (told) return { notice: void 0 };
+  await mkdir3(dirname3(path), { recursive: true, mode: 448 });
+  await writeFile3(path, String(context.nowMs()), { mode: 384 });
+  return { notice: notBoundText({ meta: meta3 }) };
+}
+
+// src/services/plugin-hook.service.ts
+import { readFile as readFile4 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+async function agentProfileHere({
+  context,
+  args,
+  session,
+  claudePid
+}) {
+  const config2 = await context.store.read();
+  const cwd = (claudePid ? await context.processes.cwdOf(claudePid) : void 0) ?? (context.environment.inherited.CLAUDE_PROJECT_DIR || 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({
+    args: await sessionProfileArgs({ context, args: asked, session }),
+    name: "profile"
+  });
+  return name2 && config2.profiles[name2]?.kind === "agent" ? name2 : void 0;
+}
+async function projectHooksHere({ context }) {
+  const directory = context.environment.inherited.CLAUDE_PROJECT_DIR || context.cwd;
+  const path = join4(directory, ".claude", "settings.local.json");
+  return readFile4(path, "utf8").then(
+    (text2) => hasLazeHooks({ settings: JSON.parse(text2) }),
+    () => false
+  );
+}
+async function pluginHookArgs({
+  context,
+  args,
+  session,
+  claudePid
+}) {
+  if (!args.flags.plugin) return args;
+  if (await projectHooksHere({ context })) return void 0;
+  const profile = await agentProfileHere({ context, args, session, claudePid });
+  return profile ? { ...args, flags: { ...args.flags, profile } } : void 0;
+}
+
+// src/services/claude-turn.service.ts
 var PRE_TOOL_TIMEOUT_MS = 3e3;
 function statePath({ context, agent: agent2 }) {
   const safe = agent2.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join2(dirname2(context.environment.configPath), "turns", `${safe}.json`);
+  return join5(dirname4(context.environment.configPath), "turns", `${safe}.json`);
 }
 async function readState({ context, agent: agent2 }) {
-  return readFile2(statePath({ context, agent: agent2 }), "utf8").then(
+  return readFile5(statePath({ context, agent: agent2 }), "utf8").then(
     (text2) => JSON.parse(text2),
     () => void 0
   );
@@ -66560,8 +66874,8 @@ async function turnStarted({
     await beat({ client, state: before, working: false }).catch(() => void 0);
   }
   const path = statePath({ context, agent: agent2 });
-  await mkdir2(dirname2(path), { recursive: true, mode: 448 });
-  await writeFile2(path, JSON.stringify(state));
+  await mkdir4(dirname4(path), { recursive: true, mode: 448 });
+  await writeFile4(path, JSON.stringify(state));
   await beat({ client, state, working: true }).catch(() => void 0);
 }
 async function turnEnded({
@@ -66576,12 +66890,16 @@ async function turnEnded({
 }
 async function preToolHook({ context, args }) {
   try {
-    await context.readStdin();
-    const { name: name2, profile } = await signedIn({ 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 asked = await pluginHookArgs({ context, args, session, claudePid: 0 });
+    if (!asked) return;
+    const { name: name2, profile } = await signedIn({ context, args: asked });
     const client = LazeClient.create({
       baseUrl: profile.url,
       token: profile.token,
-      fetcher: (input2, init) => context.fetcher(input2, { ...init, signal: AbortSignal.timeout(PRE_TOOL_TIMEOUT_MS) })
+      fetcher: (input3, init) => context.fetcher(input3, { ...init, signal: AbortSignal.timeout(PRE_TOOL_TIMEOUT_MS) })
     });
     const state = await readState({ context, agent: name2 });
     const answer4 = await beat({ client, state, working: true });
@@ -66605,86 +66923,6 @@ async function preToolHook({ context, args }) {
   }
 }
 
-// src/services/inbox-spool.service.ts
-import { mkdir as mkdir3, readFile as readFile3, rename as rename2, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname3, join as join3 } from "node:path";
-var PUSH_GRACE_MS = 3 * 6e4;
-function fileNameOf({ profile }) {
-  return profile.replace(/[^a-zA-Z0-9_-]/g, "_");
-}
-function statePathOf({
-  context,
-  kind,
-  profile,
-  extension: extension2 = "json"
-}) {
-  const directory = join3(dirname3(context.environment.configPath), kind);
-  return join3(directory, `${fileNameOf({ profile })}.${extension2}`);
-}
-async function readSpool({ path }) {
-  return readFile3(path, "utf8").then(
-    (text2) => JSON.parse(text2),
-    () => []
-  );
-}
-async function writeSpool({ path, entries }) {
-  await mkdir3(dirname3(path), { recursive: true, mode: 448 });
-  const temporary = `${path}.${process.pid}.tmp`;
-  await writeFile3(temporary, JSON.stringify(entries), { mode: 384 });
-  await rename2(temporary, path);
-}
-async function keepTaken({
-  context,
-  profile,
-  messages,
-  pushed = false
-}) {
-  if (messages.length === 0) return;
-  const path = statePathOf({ context, kind: "spool", profile });
-  const ids = new Set(messages.map((message2) => message2.messageId));
-  const kept = (await readSpool({ path })).filter((entry) => !ids.has(entry.message.messageId));
-  const now = context.nowMs();
-  const taken = messages.map((message2) => ({
-    message: message2,
-    takenAt: now,
-    ...pushed ? { pushedAt: now } : {}
-  }));
-  await writeSpool({ path, entries: [...kept, ...taken] });
-}
-async function dropFromSpool({
-  context,
-  profile,
-  messageIds
-}) {
-  if (messageIds.length === 0) return;
-  const path = statePathOf({ context, kind: "spool", profile });
-  const entries = await readSpool({ path });
-  const ids = new Set(messageIds);
-  const kept = entries.filter((entry) => !ids.has(entry.message.messageId));
-  if (kept.length !== entries.length) await writeSpool({ path, entries: kept });
-}
-async function dueFromSpool({
-  context,
-  profile,
-  seen,
-  pushedToo
-}) {
-  const path = statePathOf({ context, kind: "spool", profile });
-  const entries = await readSpool({ path });
-  const pushed = entries.some((entry) => entry.pushedAt !== void 0);
-  const text2 = pushed ? await seen().catch(() => "") : "";
-  const shown = entries.filter(
-    (entry) => entry.pushedAt !== void 0 && text2.includes(entry.message.messageId)
-  );
-  await dropFromSpool({
-    context,
-    profile,
-    messageIds: shown.map((entry) => entry.message.messageId)
-  });
-  const late = context.nowMs() - PUSH_GRACE_MS;
-  return entries.filter((entry) => !shown.includes(entry)).filter((entry) => entry.pushedAt === void 0 || pushedToo && entry.pushedAt <= late).map((entry) => entry.message);
-}
-
 // src/rules/activity-format.rules.ts
 function utcTimeOf(iso) {
   return `${iso.slice(0, 10)} ${iso.slice(11, 16)} UTC`;
@@ -67225,202 +67463,14 @@ function channelLabelIn(channel) {
   return `#${channel.name}`;
 }
 
-// src/services/claude-project.service.ts
-import { basename, isAbsolute, relative, resolve as resolve2 } from "node:path";
-function harnessIn({ words }) {
-  const names = words.slice(0, 2).map((word3) => basename(word3).replace(/\.(js|mjs|cjs)$/, ""));
-  if (names.includes("codex")) return "codex";
-  if (words.some((word3) => word3.includes("@openai/codex"))) return "codex";
-  const claude = words.some((word3) => word3.includes("@anthropic-ai/claude-code"));
-  return claude || names.includes("claude") ? "claude-code" : void 0;
-}
-async function nearestHarnessOf({
-  context,
-  from = context.processes.pid
-}) {
-  let pid = await context.processes.parentOf(from);
-  for (let depth = 0; pid !== void 0 && pid > 1 && depth < 12; depth += 1) {
-    const harness = harnessIn({ words: await context.processes.argsOf(pid) ?? [] });
-    if (harness) return { harness, pid };
-    pid = await context.processes.parentOf(pid);
-  }
-  return void 0;
-}
-function holds({ folder, inner }) {
-  const rel = relative(resolve2(folder), resolve2(inner));
-  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
-}
-async function claudeProjectOf({
-  context,
-  claudePid
-}) {
-  const env = context.environment.inherited;
-  const pid = Number(env.CLAUDE_PID);
-  const candidates = [
-    claudePid ? await context.processes.cwdOf(claudePid) : void 0,
-    env.CLAUDE_PROJECT_DIR ? resolve2(env.CLAUDE_PROJECT_DIR) : void 0,
-    pid > 0 ? await context.processes.cwdOf(pid) : void 0
-  ].filter((folder) => Boolean(folder));
-  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 { readFile as readFile6, 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(
+  return readFile6(path, "utf8").then(
     (text2) => JSON.parse(text2),
     () => void 0
   );
@@ -67543,13 +67593,15 @@ 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 });
+  const asked = await pluginHookArgs({ context, args, session, claudePid });
+  if (!asked) return 0;
+  const named = await sessionProfileArgs({ context, args: asked, session });
+  const { client, name: name2 } = await signedIn({ context, args: named });
   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 seen = () => input2.transcript_path ? readFile6(input2.transcript_path, "utf8") : Promise.resolve("");
   const deadline = context.nowMs() + (WAIT_HOOK_TIMEOUT_SECONDS - 60) * 1e3;
   try {
     while (context.nowMs() < deadline) {
@@ -67584,7 +67636,7 @@ async function monitorServes({
 // src/services/codex-link.service.ts
 import { createReadStream } from "node:fs";
 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 { join as join11, resolve as resolve3 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 
 // src/rules/connect-service.rules.ts
@@ -67704,8 +67756,8 @@ function rolloutEventOf({
 
 // src/services/codex-adopt.service.ts
 import { spawn as spawn2 } from "node:child_process";
-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 { mkdir as mkdir6, readdir as readdir2, readFile as readFile7, rm as rm3, stat, writeFile as writeFile6 } from "node:fs/promises";
+import { dirname as dirname6, join as join6 } from "node:path";
 import { createInterface } from "node:readline";
 
 // src/rules/codex-requests.rules.ts
@@ -67825,11 +67877,11 @@ var CodexAppServer = class _CodexAppServer {
   }
 };
 async function newestThreadId({ codexHome }) {
-  const root = join5(codexHome, "sessions");
+  const root = join6(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(join5(root, file3))).mtimeMs }))
+    rollouts.map(async (file3) => ({ file: file3, at: (await stat(join6(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);
@@ -67904,7 +67956,7 @@ async function answer({
 var MAX_RESTART_WAIT_SECONDS = 60;
 var HEALTHY_RUN_MS = 6e4;
 async function recordOf({ path }) {
-  return readFile6(path, "utf8").then(
+  return readFile7(path, "utf8").then(
     (text2) => JSON.parse(text2),
     () => void 0
   );
@@ -68007,7 +68059,7 @@ async function adoptedThreadOf({
   );
   if (!held) return threadId;
   const path = statePathOf({ context, kind: "adopt", profile, extension: "forks.json" });
-  const forks = await readFile6(path, "utf8").then(
+  const forks = await readFile7(path, "utf8").then(
     (text2) => JSON.parse(text2),
     () => ({})
   );
@@ -68078,20 +68130,20 @@ async function adoptCodex({ context, args }) {
 }
 
 // src/services/connect-delivery.service.ts
-import { mkdir as mkdir8, readFile as readFile8, rename as rename3, rm as rm4, writeFile as writeFile8 } from "node:fs/promises";
+import { mkdir as mkdir8, readFile as readFile9, 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";
+import { dirname as dirname8, join as join9 } from "node:path";
 
 // src/services/codex-turn-watch.service.ts
 import { open as open2, readdir as readdir3 } from "node:fs/promises";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 var READ_MS = 1500;
 var KEEP_WORKING_MS = 3e4;
 async function rolloutPathOf({ delivery }) {
-  const root = join6(delivery.codexHome, "sessions");
+  const root = join7(delivery.codexHome, "sessions");
   const files2 = await readdir3(root, { recursive: true }).catch(() => []);
   const file3 = files2.find((name2) => name2.endsWith(`-${delivery.threadId}.jsonl`));
-  return file3 ? join6(root, file3) : void 0;
+  return file3 ? join7(root, file3) : void 0;
 }
 async function readFrom({ path, offset }) {
   const handle = await open2(path, "r");
@@ -68177,8 +68229,8 @@ var CodexTurnWatch = class _CodexTurnWatch {
 };
 
 // src/services/openclaw-relay.service.ts
-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";
+import { chmod as chmod2, mkdir as mkdir7, readFile as readFile8, writeFile as writeFile7 } from "node:fs/promises";
+import { dirname as dirname7, join as join8 } from "node:path";
 
 // ../../modules/openclaw/contract/src/openclaw.ts
 var workspaceIdSchema14 = external_exports.string().min(1);
@@ -68406,11 +68458,11 @@ var STOPS = /* @__PURE__ */ new Map([
   [OPENCLAW_RELAY_CLOSE.replaced.code, "another relay for this gateway took over"]
 ]);
 function relaysPathOf({ context }) {
-  return join7(dirname7(context.environment.configPath), "connect", "openclaw-relays.json");
+  return join8(dirname7(context.environment.configPath), "connect", "openclaw-relays.json");
 }
 async function readRelays({ context }) {
   try {
-    return JSON.parse(await readFile7(relaysPathOf({ context }), "utf8"));
+    return JSON.parse(await readFile8(relaysPathOf({ context }), "utf8"));
   } catch {
     return {};
   }
@@ -68607,14 +68659,14 @@ var RelayLoops = class _RelayLoops {
 
 // src/services/connect-delivery.service.ts
 function connectFolderOf({ context }) {
-  return join8(dirname8(context.environment.configPath), "connect");
+  return join9(dirname8(context.environment.configPath), "connect");
 }
 function runStatePathOf({ context }) {
-  return join8(connectFolderOf({ context }), "run.json");
+  return join9(connectFolderOf({ context }), "run.json");
 }
 async function readJson({ path }) {
   try {
-    return JSON.parse(await readFile8(path, "utf8"));
+    return JSON.parse(await readFile9(path, "utf8"));
   } catch {
     return void 0;
   }
@@ -68848,7 +68900,7 @@ async function runConnectLoop({ context }) {
 // src/services/connect-service.service.ts
 import { createHash } from "node:crypto";
 import { mkdir as mkdir9, rm as rm5, writeFile as writeFile9 } from "node:fs/promises";
-import { dirname as dirname9, join as join9 } from "node:path";
+import { dirname as dirname9, join as join10 } 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)
@@ -68861,17 +68913,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 join9(connectFolderOf({ context }), "service.json");
+  return join10(connectFolderOf({ context }), "service.json");
 }
 function logPathOf({ context }) {
-  return join9(connectFolderOf({ context }), "connect.log");
+  return join10(connectFolderOf({ context }), "connect.log");
 }
 function homeOf({ context }) {
   return context.environment.inherited.HOME ?? dirname9(dirname9(context.environment.configPath));
 }
 function serviceNameOf({ context }) {
   const { configPath } = context.environment;
-  if (configPath === join9(homeOf({ context }), ".laze", "config.json")) return "laze-connect";
+  if (configPath === join10(homeOf({ context }), ".laze", "config.json")) return "laze-connect";
   return `laze-connect-${createHash("sha256").update(configPath).digest("hex").slice(0, 8)}`;
 }
 function serviceEnvOf({ context }) {
@@ -68894,8 +68946,8 @@ async function run({ context, command }) {
 async function installSystemd({ context }) {
   const name2 = serviceNameOf({ context });
   const env = context.environment.inherited;
-  const base = env.XDG_CONFIG_HOME || join9(homeOf({ context }), ".config");
-  const file3 = join9(base, "systemd", "user", `${name2}.service`);
+  const base = env.XDG_CONFIG_HOME || join10(homeOf({ context }), ".config");
+  const file3 = join10(base, "systemd", "user", `${name2}.service`);
   await mkdir9(dirname9(file3), { recursive: true });
   await writeFile9(
     file3,
@@ -68910,7 +68962,7 @@ async function installSystemd({ context }) {
 async function installLaunchd({ context }) {
   const name2 = serviceNameOf({ context });
   const label2 = `ai.laze.${name2}`;
-  const file3 = join9(homeOf({ context }), "Library", "LaunchAgents", `${label2}.plist`);
+  const file3 = join10(homeOf({ context }), "Library", "LaunchAgents", `${label2}.plist`);
   const log = logPathOf({ context });
   await mkdir9(dirname9(file3), { recursive: true });
   await writeFile9(
@@ -69078,13 +69130,13 @@ async function newestThreadIn({
   codexHome,
   directory
 }) {
-  const root = join10(codexHome, "sessions");
+  const root = join11(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: join10(root, file3),
-      at: await stat2(join10(root, file3)).then(
+      path: join11(root, file3),
+      at: await stat2(join11(root, file3)).then(
         (info) => info.mtimeMs,
         () => 0
       )
@@ -69152,17 +69204,22 @@ async function linkCodexSession({
 }
 
 // src/services/laze-plugin.service.ts
-import { mkdir as mkdir10, readFile as readFile9, writeFile as writeFile10 } from "node:fs/promises";
-import { dirname as dirname10, join as join11 } from "node:path";
+import { mkdir as mkdir10, readFile as readFile10, writeFile as writeFile10 } from "node:fs/promises";
+import { dirname as dirname10, join as join12 } from "node:path";
 
 // src/rules/laze-plugin.rules.ts
 var LAZE_PLUGIN = "laze";
 var NPX_CLI = ["npx", "-y", "@lazehq/cli@latest"];
 var quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
-function cliLineOf({ program, args }) {
+function cliLineOf({
+  program,
+  args,
+  configPath
+}) {
   const here = [...program, ...args].map(quote).join(" ");
   const fallback = [...NPX_CLI, ...args].join(" ");
-  return `if [ -e ${quote(program.at(-1) ?? "")} ]; then exec ${here}; else exec ${fallback}; fi`;
+  const run4 = `if [ -e ${quote(program.at(-1) ?? "")} ]; then exec ${here}; else exec ${fallback}; fi`;
+  return `export LAZE_CLI_CONFIG=${quote(configPath)}; ${run4}`;
 }
 var SKILL = `---
 name: laze
@@ -69196,10 +69253,28 @@ are waiting, if you think one was missed.
 If \`laze\` is not on the PATH, run the same commands through \`npx -y @lazehq/cli@latest\`.
 Never print or repeat your Laze key.
 `;
+function pluginHooksOf({ line }) {
+  const hook = (name2, timeout) => ({
+    type: "command",
+    command: line(["hook", name2, "--plugin"]),
+    timeout
+  });
+  const waiter = { ...hook("wait", WAIT_HOOK_TIMEOUT_SECONDS), async: true, asyncRewake: true };
+  return {
+    description: "Hands Laze messages to the session and wakes it when one arrives",
+    hooks: {
+      Stop: [{ hooks: [hook("stop", HOOK_TIMEOUTS.Stop), waiter] }],
+      SessionStart: [{ hooks: [waiter] }],
+      PreToolUse: [{ hooks: [hook("pre-tool", HOOK_TIMEOUTS.PreToolUse)] }]
+    }
+  };
+}
 function lazePluginFiles({
   program,
-  version: version2
+  version: version2,
+  configPath
 }) {
+  const line = (args) => cliLineOf({ program, args, configPath });
   const json5 = (value) => `${JSON.stringify(value, null, 2)}
 `;
   const description = "Laze messages reach this session, and the laze tools to answer them";
@@ -69234,10 +69309,11 @@ function lazePluginFiles({
     "laze/monitors/monitors.json": json5([
       {
         name: "laze-messages",
-        command: cliLineOf({ program, args: ["hook", "monitor"] }),
+        command: line(["hook", "monitor"]),
         description: "Laze messages for this session"
       }
-    ])
+    ]),
+    "laze/hooks/hooks.json": json5(pluginHooksOf({ line }))
   };
 }
 
@@ -69245,11 +69321,11 @@ function lazePluginFiles({
 var REGISTER_LIMIT_MS = 6e4;
 var quote2 = (value) => `'${value.replaceAll("'", "'\\''")}'`;
 function pluginFolderOf({ context }) {
-  return join11(dirname10(context.environment.configPath), "plugins");
+  return join12(dirname10(context.environment.configPath), "plugins");
 }
 async function pluginIsCurrent({ context }) {
-  const manifest = join11(pluginFolderOf({ context }), LAZE_PLUGIN, ".claude-plugin", "plugin.json");
-  const written = await readFile9(manifest, "utf8").then(
+  const manifest = join12(pluginFolderOf({ context }), LAZE_PLUGIN, ".claude-plugin", "plugin.json");
+  const written = await readFile10(manifest, "utf8").then(
     (text2) => JSON.parse(text2).version,
     () => void 0
   );
@@ -69257,9 +69333,13 @@ async function pluginIsCurrent({ context }) {
 }
 async function writeLazePlugin({ context }) {
   const folder = pluginFolderOf({ context });
-  const files2 = lazePluginFiles({ program: context.program, version: cliVersionOf() });
+  const files2 = lazePluginFiles({
+    program: context.program,
+    version: cliVersionOf(),
+    configPath: context.environment.configPath
+  });
   for (const [path, text2] of Object.entries(files2)) {
-    const target = join11(folder, path);
+    const target = join12(folder, path);
     await mkdir10(dirname10(target), { recursive: true });
     await writeFile10(target, text2);
   }
@@ -69280,10 +69360,10 @@ async function registerWithClaude({ context, folder }) {
   return code === 0;
 }
 function registeredMarkOf({ context }) {
-  return join11(pluginFolderOf({ context }), "registered");
+  return join12(pluginFolderOf({ context }), "registered");
 }
 async function pluginRegistered({ context }) {
-  return readFile9(registeredMarkOf({ context }), "utf8").then(
+  return readFile10(registeredMarkOf({ context }), "utf8").then(
     () => true,
     () => false
   );
@@ -69297,7 +69377,7 @@ async function installLazePlugin({ context }) {
 async function plugin({ context, args }) {
   const action = args.words[1] ?? "install";
   if (action === "path") {
-    context.out(`${join11(pluginFolderOf({ context }), LAZE_PLUGIN)}
+    context.out(`${join12(pluginFolderOf({ context }), LAZE_PLUGIN)}
 `);
     return 0;
   }
@@ -69434,10 +69514,32 @@ async function pushInbox({
 }
 
 // src/services/plugin-tip.service.ts
-import { mkdir as mkdir12, readFile as readFile10, writeFile as writeFile12 } from "node:fs/promises";
+import { mkdir as mkdir12, readFile as readFile11, 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 monitorsRunHere({ context }) {
+  const entrypoint = context.environment.inherited.CLAUDE_CODE_ENTRYPOINT;
+  return entrypoint === void 0 || entrypoint === "cli";
+}
+function pluginLinesOf({
+  context,
+  registered
+}) {
+  if (registered === void 0) return [];
+  if (!registered)
+    return ["Claude Code did not take the Laze plugin; the hooks deliver on their own."];
+  if (!monitorsRunHere({ context })) {
+    return [
+      "The Laze plugin is installed in Claude Code. This session runs headless (claude -p), where",
+      "Claude Code starts no plugin monitors, so the hooks deliver here; nothing to type or restart."
+    ];
+  }
+  return [
+    "The Laze plugin is installed in Claude Code: from the next start or resume it delivers too.",
+    LINK_RELOAD_TIP
+  ];
+}
 function toldPathOf({ context, session }) {
   return statePathOf({ context, kind: "told", profile: `plugin-${sessionKeyOf({ session })}` });
 }
@@ -69454,8 +69556,9 @@ async function reloadTipOnce({
   context,
   session
 }) {
-  if (!session || !await pluginRegistered({ context })) return void 0;
-  const told = await readFile10(toldPathOf({ context, session }), "utf8").then(
+  if (!session || !monitorsRunHere({ context })) return void 0;
+  if (!await pluginRegistered({ context })) return void 0;
+  const told = await readFile11(toldPathOf({ context, session }), "utf8").then(
     () => true,
     () => false
   );
@@ -69521,9 +69624,9 @@ async function installHooks({
   directory,
   profile
 }) {
-  const folder = join12(directory, ".claude");
-  const path = join12(folder, "settings.local.json");
-  const current2 = await readFile11(path, "utf8").then(
+  const folder = join13(directory, ".claude");
+  const path = join13(folder, "settings.local.json");
+  const current2 = await readFile12(path, "utf8").then(
     (text2) => JSON.parse(text2),
     () => ({})
   );
@@ -69559,14 +69662,6 @@ async function registerMcp({
   done.abort();
   return code === 0;
 }
-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.",
-    LINK_RELOAD_TIP
-  ];
-}
 function mcpLinesOf({
   mcp: mcp2,
   mcpAdd: mcpAdd2,
@@ -69595,7 +69690,7 @@ function claudeStepsOf({
     "Answer each with",
     `  ${laze} reply <message-id> "<answer>" --profile ${profile}`,
     "Nothing else needs to keep running.",
-    ...pluginLinesOf({ plugin: plugin2 }),
+    ...plugin2,
     ...mcpLinesOf({ mcp: mcp2, mcpAdd: mcpAdd2, directory })
   ].join("\n");
 }
@@ -69724,14 +69819,15 @@ async function nextStepsFor({
   }
   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 });
+  const lines = pluginLinesOf({ context, registered: plugin2?.registered });
+  return claudeStepsOf({ profile, laze, directory, mcp: mcp2, mcpAdd: mcpAdd2, plugin: lines });
 }
 async function reportTranscript({
   client,
   input: input2
 }) {
   if (!input2.transcript_path || !input2.session_id) return;
-  const lines = (await readFile11(input2.transcript_path, "utf8")).split("\n");
+  const lines = (await readFile12(input2.transcript_path, "utf8")).split("\n");
   const context = readTranscript({ lines });
   await client.post("/api/agents/me/activity", {
     sessionId: input2.session_id,
@@ -69748,21 +69844,23 @@ async function handOver({ 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 claudePid = await claudePidOf({ context });
+  const asked = await pluginHookArgs({ context, args, session, claudePid });
+  if (!asked) return;
+  const named = await sessionProfileArgs({ context, args: asked, session });
   const { client, name: agent2 } = await signedIn({ context, args: named });
   await reportTranscript({ client, input: input2 }).catch(
     (error62) => context.err(`laze: could not report context: ${String(error62)}
 `)
   );
   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 ? readFile11(input2.transcript_path, "utf8") : Promise.resolve(""),
+    seen: () => input2.transcript_path ? readFile12(input2.transcript_path, "utf8") : Promise.resolve(""),
     pushedToo: false
   });
   const claim3 = forSession({ client, session });
@@ -69796,8 +69894,8 @@ async function addSessionStartWaiter({ context, args }) {
   const directory = context.environment.inherited.CLAUDE_PROJECT_DIR;
   const profile = flagText({ args, name: "profile" });
   if (!directory || !profile) return;
-  const path = join12(directory, ".claude", "settings.local.json");
-  const settings2 = await readFile11(path, "utf8").then(
+  const path = join13(directory, ".claude", "settings.local.json");
+  const settings2 = await readFile12(path, "utf8").then(
     (text2) => JSON.parse(text2),
     () => void 0
   );
@@ -69806,7 +69904,7 @@ async function addSessionStartWaiter({ context, args }) {
 }
 async function refreshPlugin({ context }) {
   if (await pluginIsCurrent({ context })) return;
-  const logPath = join12(pluginFolderOf({ context }), "install.log");
+  const logPath = join13(pluginFolderOf({ context }), "install.log");
   context.processes.spawnDetached({ argv: [...context.program, "plugin", "install"], logPath });
 }
 async function stopHook({ context, args }) {
@@ -69824,7 +69922,7 @@ async function stopHook({ context, args }) {
 }
 
 // src/services/agent-manage-commands.service.ts
-import { readFile as readFile12 } from "node:fs/promises";
+import { readFile as readFile13 } from "node:fs/promises";
 import { extname, resolve as resolve5 } from "node:path";
 
 // src/rules/login-format.rules.ts
@@ -69953,7 +70051,7 @@ async function avatarOf({
 }) {
   const path = flagText({ args, name: "avatar" });
   if (!path) return void 0;
-  const bytes = await readFile12(resolve5(context.cwd, path)).catch(() => {
+  const bytes = await readFile13(resolve5(context.cwd, path)).catch(() => {
     throw new CliUsageError(`laze: cannot read the avatar file ${path}.`);
   });
   const uploaded = await client.post("/api/agents/avatars", {
@@ -70643,8 +70741,8 @@ async function requestAgent({ context, args }) {
 }
 
 // src/services/app-commands.service.ts
-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";
+import { mkdir as mkdir14, readdir as readdir5, readFile as readFile14, writeFile as writeFile15 } from "node:fs/promises";
+import { dirname as dirname13, join as join15, 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}$/);
@@ -73037,7 +73135,7 @@ async function appPinsCommand({
 import { execFile } from "node:child_process";
 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 { join as join14 } from "node:path";
 import { promisify } from "node:util";
 var run2 = promisify(execFile);
 var MODULE_SYNTAX = /^\s*(import|export)\s/m;
@@ -73066,11 +73164,11 @@ async function scriptErrorsOf({
   const unknown2 = unknownCollectionsOf({ files: files2, collections });
   const scripts = files2.flatMap(scriptsOf);
   if (scripts.length === 0) return unknown2;
-  const dir = await mkdtemp(join13(tmpdir(), "laze-app-check-"));
+  const dir = await mkdtemp(join14(tmpdir(), "laze-app-check-"));
   try {
     const errors = await Promise.all(
       scripts.map(async (script, index) => {
-        const file3 = join13(dir, `${index}.${script.module ? "mjs" : "cjs"}`);
+        const file3 = join14(dir, `${index}.${script.module ? "mjs" : "cjs"}`);
         await writeFile14(file3, script.code);
         try {
           await run2(process.execPath, ["--check", file3]);
@@ -73220,7 +73318,7 @@ async function turnTokenOf({
   const pinned = env.LAZE_TURN_TOKEN?.trim();
   if (pinned) return pinned;
   if (env.LAZE_TURN_FILE) {
-    return readFile13(env.LAZE_TURN_FILE, "utf8").then(
+    return readFile14(env.LAZE_TURN_FILE, "utf8").then(
       (text2) => text2.trim(),
       () => ""
     );
@@ -73246,7 +73344,7 @@ function folderOf({ context, word: word3 }) {
   return resolve6(context.cwd, word3 ?? ".");
 }
 async function readManifest(folder) {
-  const text2 = await readFile13(join14(folder, APP_MANIFEST_FILE), "utf8").catch(() => void 0);
+  const text2 = await readFile14(join15(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) {
@@ -73281,7 +73379,7 @@ async function jsonFlag({
 }) {
   const raw = flagText({ args, name: name2 });
   if (!raw) return void 0;
-  const text2 = raw.startsWith("@") ? await readFile13(resolve6(context.cwd, raw.slice(1)), "utf8") : raw;
+  const text2 = raw.startsWith("@") ? await readFile14(resolve6(context.cwd, raw.slice(1)), "utf8") : raw;
   try {
     return JSON.parse(text2);
   } catch {
@@ -73294,7 +73392,7 @@ async function listFiles(folder) {
   while (pending.length > 0 && found.length <= MAX_FILES) {
     const current2 = pending.pop() ?? folder;
     for (const entry of await readdir5(current2, { withFileTypes: true })) {
-      const path = join14(current2, entry.name);
+      const path = join15(current2, entry.name);
       const rel = relative3(folder, path).split(sep2).join("/");
       if (isSkippedPath({ path: rel })) continue;
       if (entry.isDirectory()) pending.push(path);
@@ -73338,8 +73436,8 @@ var appCreate = async ({ context, args }) => {
   await mkdir14(folder, { recursive: true });
   const files2 = template ? templateFiles({ template, name: name2 }) : {};
   for (const [path, content] of Object.entries(files2)) {
-    await mkdir14(dirname13(join14(folder, path)), { recursive: true });
-    await writeFile15(join14(folder, path), content);
+    await mkdir14(dirname13(join15(folder, path)), { recursive: true });
+    await writeFile15(join15(folder, path), content);
   }
   const manifest = {
     app: { id: app2.id, name: app2.name, slug: app2.slug },
@@ -73347,7 +73445,7 @@ var appCreate = async ({ context, args }) => {
     views: template?.views ? [...template.views] : [],
     seed: template ? { ...template.seed } : {}
   };
-  await writeFile15(join14(folder, APP_MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
+  await writeFile15(join15(folder, APP_MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
 `);
   print5({
     context,
@@ -73384,7 +73482,7 @@ var appPush = async ({ context, args }) => {
     paths.map(
       async (path) => buildFileOf({
         path: relative3(folder, path).split(sep2).join("/"),
-        bytes: await readFile13(path)
+        bytes: await readFile14(path)
       })
     )
   );
@@ -73767,7 +73865,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 readFile13(resolve6(context.cwd, file3), "utf8").catch(() => {
+  const csv = await readFile14(resolve6(context.cwd, file3), "utf8").catch(() => {
     throw new CliUsageError(`Cannot read ${file3}`);
   });
   const scoped = named ? { ...args, flags: { ...args.flags, app: named } } : args;
@@ -74333,8 +74431,8 @@ async function billing({ context, args }) {
 
 // src/services/browser-commands.service.ts
 import { randomBytes } from "node:crypto";
-import { mkdir as mkdir15, readFile as readFile14, writeFile as writeFile16 } from "node:fs/promises";
-import { dirname as dirname14, join as join15 } from "node:path";
+import { mkdir as mkdir15, readFile as readFile15, writeFile as writeFile16 } from "node:fs/promises";
+import { dirname as dirname14, join as join16 } from "node:path";
 
 // src/services/browser-tab-commands.service.ts
 var BROWSER_TAB_PATHS = {
@@ -74880,7 +74978,7 @@ async function turnTokenOf2({ context }) {
   const pinned = env.LAZE_TURN_TOKEN?.trim();
   if (pinned) return pinned;
   if (!env.LAZE_TURN_FILE) return "";
-  return readFile14(env.LAZE_TURN_FILE, "utf8").then(
+  return readFile15(env.LAZE_TURN_FILE, "utf8").then(
     (text2) => text2.trim(),
     () => ""
   );
@@ -74954,7 +75052,7 @@ async function cdp({ context, args }) {
 }
 function bridgeStatePath({ context, machine: machine2 }) {
   const safe = machine2.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join15(dirname14(context.environment.configPath), "bridges", `${safe}.json`);
+  return join16(dirname14(context.environment.configPath), "bridges", `${safe}.json`);
 }
 async function bridgePort({
   context,
@@ -74962,7 +75060,7 @@ async function bridgePort({
   access
 }) {
   const path = bridgeStatePath({ context, machine: machine2 });
-  const live = await readFile14(path, "utf8").then(
+  const live = await readFile15(path, "utf8").then(
     (text2) => JSON.parse(text2),
     () => void 0
   );
@@ -75620,7 +75718,7 @@ async function channelSettings({ context, args }) {
 }
 
 // src/services/chat-actions-commands.service.ts
-import { readFile as readFile15 } from "node:fs/promises";
+import { readFile as readFile16 } 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
@@ -75925,7 +76023,7 @@ function uploadNameOf({ cwd, path }) {
 }
 var fileUpload = async ({ context, args, client }) => {
   const path = resolve7(context.cwd, wordAt(args, 3));
-  const bytes = new Uint8Array(await readFile15(path));
+  const bytes = new Uint8Array(await readFile16(path));
   const answer4 = await uploadFile({
     context,
     client,
@@ -76090,26 +76188,9 @@ async function chatActions({
 }
 
 // src/services/claude-monitor.service.ts
-import { readFile as readFile16, rm as rm9 } from "node:fs/promises";
+import { readFile as readFile17, rm as rm9 } from "node:fs/promises";
 var MONITOR_IDLE_MS = 3e4;
 var MONITOR_OUTRANKED_MS = 3e3;
-async function agentProfileHere({
-  context,
-  args,
-  session,
-  claudePid
-}) {
-  const config2 = await context.store.read();
-  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({
-    args: await sessionProfileArgs({ context, args: asked, session }),
-    name: "profile"
-  });
-  return name2 && config2.profiles[name2]?.kind === "agent" ? name2 : void 0;
-}
 async function deliverOnce({
   context,
   args,
@@ -76196,7 +76277,7 @@ async function monitorSessionOf({
   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(
+  return readFile17(path, "utf8").then(
     (text2) => JSON.parse(text2),
     () => void 0
   );
@@ -77683,10 +77764,10 @@ async function computer({ context, args }) {
 }
 
 // src/services/connect-commands.service.ts
-import { readFile as readFile18 } from "node:fs/promises";
+import { readFile as readFile19 } from "node:fs/promises";
 
 // src/services/mcp-gateway.service.ts
-import { readFile as readFile17 } from "node:fs/promises";
+import { readFile as readFile18 } from "node:fs/promises";
 import { createInterface as createInterface3 } from "node:readline";
 var TURN_HEADER = "x-laze-turn";
 function serveMcpGateway({
@@ -77729,7 +77810,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 = () => readFile17(turnFile, "utf8").then(
+  const readTurn = () => readFile18(turnFile, "utf8").then(
     (text2) => text2.trim(),
     () => ""
   );
@@ -77819,7 +77900,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 readFile18(file3, "utf8").then(
+  const turn = file3 ? await readFile19(file3, "utf8").then(
     (text2) => text2.trim(),
     () => ""
   ) : "";
@@ -77877,11 +77958,11 @@ async function connect({
 }
 
 // src/services/connector-commands.service.ts
-import { readFile as readFile20 } from "node:fs/promises";
+import { readFile as readFile21 } from "node:fs/promises";
 import { resolve as resolve8 } from "node:path";
 
 // src/services/vault-keychain-commands.service.ts
-import { readFile as readFile19 } from "node:fs/promises";
+import { readFile as readFile20 } from "node:fs/promises";
 
 // src/rules/vault-input.rules.ts
 function secondsOf(text2) {
@@ -78192,7 +78273,7 @@ async function secretText({ context, args }) {
     );
   }
   const file3 = flagText({ args, name: "from-file" });
-  const text2 = file3 ? await readFile19(file3, "utf8") : await context.readStdin();
+  const text2 = file3 ? await readFile20(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;
@@ -78390,7 +78471,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 readFile20(resolve8(context.cwd, file3), "utf8") : await context.readStdin();
+  const text2 = file3 ? await readFile21(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;
@@ -78776,8 +78857,8 @@ var DOMAINS_USAGE = `Usage:
 var printJson4 = (context, data) => context.out(`${JSON.stringify(data, null, 2)}
 `);
 function printDomain(context, row) {
-  const join19 = row.autoJoin ? "auto-join on" : "auto-join off";
-  context.out(`${row.domain}	${join19}${row.enforced ? "	single sign-on enforced" : ""}
+  const join20 = row.autoJoin ? "auto-join on" : "auto-join off";
+  context.out(`${row.domain}	${join20}${row.enforced ? "	single sign-on enforced" : ""}
 `);
 }
 async function list4({ context, args }) {
@@ -78809,7 +78890,7 @@ async function domains({ context, args }) {
 }
 
 // src/services/feed-commands.service.ts
-import { readFile as readFile22 } from "node:fs/promises";
+import { readFile as readFile23 } from "node:fs/promises";
 import { resolve as resolve10 } from "node:path";
 
 // src/rules/feed-input.rules.ts
@@ -78934,7 +79015,7 @@ function feedFlagsOf({ args }) {
 }
 
 // src/services/feed-files.service.ts
-import { readFile as readFile21 } from "node:fs/promises";
+import { readFile as readFile22 } from "node:fs/promises";
 import { basename as basename3, resolve as resolve9 } from "node:path";
 
 // ../../modules/feed/contract/src/feed.ts
@@ -79527,7 +79608,7 @@ async function local({ context, path }) {
   return {
     fileName,
     contentType: contentTypeOf(fileName),
-    bytes: new Uint8Array(await readFile21(full))
+    bytes: new Uint8Array(await readFile22(full))
   };
 }
 async function directWith({ client, to }) {
@@ -79605,7 +79686,7 @@ async function bodyOf2({
   flags: flags2
 }) {
   const body = { ...flags2.fields };
-  const read3 = (source) => "file" in source ? readFile22(resolve10(context.cwd, source.file), "utf8") : source.text;
+  const read3 = (source) => "file" in source ? readFile23(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);
@@ -79767,7 +79848,7 @@ async function textFlag({
 }) {
   const value = flagText({ args, name: name2 });
   if (!value.startsWith("@")) return value;
-  return readFile22(resolve10(context.cwd, value.slice(1)), "utf8");
+  return readFile23(resolve10(context.cwd, value.slice(1)), "utf8");
 }
 async function feedList({ context, args }) {
   const { client } = await signedIn({ context, args });
@@ -79877,7 +79958,7 @@ async function feed({ context, args }) {
 }
 
 // src/services/github-commands.service.ts
-import { readFile as readFile23 } from "node:fs/promises";
+import { readFile as readFile24 } from "node:fs/promises";
 
 // src/rules/github-signature.rules.ts
 var TURN_SEPARATOR = "~";
@@ -79947,7 +80028,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 readFile23(env.LAZE_TURN_FILE, "utf8").then(
+  return readFile24(env.LAZE_TURN_FILE, "utf8").then(
     (text2) => text2.trim(),
     () => ""
   );
@@ -79981,7 +80062,7 @@ async function githubGh({
     args: args.rest,
     agentName: profile.name ?? "An agent",
     threadUrl: threadUrlOf({ env, workspaceId: profile.workspaceId }),
-    readBodyFile: (path) => path === "-" ? context.readStdin() : readFile23(path, "utf8")
+    readBodyFile: (path) => path === "-" ? context.readStdin() : readFile24(path, "utf8")
   });
   return context.runCommand({
     command: [REAL_GH, ...ghArgs],
@@ -80080,7 +80161,7 @@ async function setAgentGithub({
 }
 
 // src/services/history-commands.service.ts
-import { readFile as readFile24 } from "node:fs/promises";
+import { readFile as readFile25 } from "node:fs/promises";
 
 // src/rules/history-format.rules.ts
 function timeOf2(iso) {
@@ -80176,7 +80257,7 @@ async function turnTokenOf3({ context }) {
   const pinned = env.LAZE_TURN_TOKEN?.trim();
   if (pinned) return pinned;
   if (!env.LAZE_TURN_FILE) return "";
-  return readFile24(env.LAZE_TURN_FILE, "utf8").then(
+  return readFile25(env.LAZE_TURN_FILE, "utf8").then(
     (text2) => text2.trim(),
     () => ""
   );
@@ -80368,19 +80449,19 @@ async function ip({ context, args }) {
 }
 
 // src/services/join-commands.service.ts
-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";
+import { mkdir as mkdir16, readFile as readFile26, rename as rename5, rm as rm10, writeFile as writeFile17 } from "node:fs/promises";
+import { dirname as dirname15, join as join17 } 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(dirname15(context.environment.configPath), "join", "pending.json");
+  return join17(dirname15(context.environment.configPath), "join", "pending.json");
 }
 async function readPending({
   context,
   url: url2,
   args
 }) {
-  const pending = await readFile25(pendingPathOf({ context }), "utf8").then(
+  const pending = await readFile26(pendingPathOf({ context }), "utf8").then(
     (text2) => JSON.parse(text2),
     () => void 0
   );
@@ -80710,9 +80791,9 @@ function machineAccessCommand(name2) {
 
 // src/services/vault-commands.service.ts
 import { createHash as createHash2 } from "node:crypto";
-import { mkdir as mkdir17, readFile as readFile26, rm as rm11, writeFile as writeFile18 } from "node:fs/promises";
+import { mkdir as mkdir17, readFile as readFile27, rm as rm11, writeFile as writeFile18 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { dirname as dirname16, join as join17 } from "node:path";
+import { dirname as dirname16, join as join18 } 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.`;
@@ -80751,7 +80832,7 @@ async function turnTokenOf4({
   if (pinned) return pinned;
   if (!turnFile) throw new CliUsageError(`${command} works only during an agent's turn`);
   try {
-    return (await readFile26(turnFile, "utf8")).trim();
+    return (await readFile27(turnFile, "utf8")).trim();
   } catch {
     throw new CliUsageError(`${command} works only during an agent's turn`);
   }
@@ -80761,11 +80842,11 @@ function runKeyPathOf({
   connection
 }) {
   const name2 = createHash2("sha256").update(connection).digest("hex");
-  const base = turnFile ? dirname16(turnFile) : join17(tmpdir2(), "laze-vault");
-  return join17(base, "vault-run-keys", `${name2}.json`);
+  const base = turnFile ? dirname16(turnFile) : join18(tmpdir2(), "laze-vault");
+  return join18(base, "vault-run-keys", `${name2}.json`);
 }
 async function runKeyAt({ path }) {
-  const saved3 = await readFile26(path, "utf8").then(
+  const saved3 = await readFile27(path, "utf8").then(
     (text2) => JSON.parse(text2),
     () => void 0
   );
@@ -81447,14 +81528,14 @@ async function serveMcp({
 }
 
 // src/services/mount-files.service.ts
-import { mkdir as mkdir18, readFile as readFile27, rm as rm12, writeFile as writeFile19 } from "node:fs/promises";
+import { mkdir as mkdir18, readFile as readFile28, 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 readFile27(resolve11(context.cwd, value.slice(1)), "utf8");
+  if (value.startsWith("@")) return readFile28(resolve11(context.cwd, value.slice(1)), "utf8");
   return value;
 }
 function turnChannel({ context, args }) {
@@ -82352,8 +82433,8 @@ async function schedule({ context, args }) {
 }
 
 // src/services/skill-commands.service.ts
-import { readdir as readdir6, readFile as readFile28 } from "node:fs/promises";
-import { join as join18, relative as relative6, resolve as resolve12 } from "node:path";
+import { readdir as readdir6, readFile as readFile29 } from "node:fs/promises";
+import { join as join19, relative as relative6, resolve as resolve12 } from "node:path";
 var USAGE16 = `Usage:
   laze skill list [--agent <agentId>]
   laze skill install <catalogue-id> [--as <name>] [--agent <agentId>]
@@ -82374,8 +82455,8 @@ async function folderFiles({ root }) {
   const files2 = [];
   for (const entry of entries) {
     if (!entry.isFile()) continue;
-    const full = join18(entry.parentPath, entry.name);
-    files2.push({ path: relative6(root, full), content: await readFile28(full, "utf8") });
+    const full = join19(entry.parentPath, entry.name);
+    files2.push({ path: relative6(root, full), content: await readFile29(full, "utf8") });
   }
   return files2.toSorted((a, b) => a.path.localeCompare(b.path));
 }
@@ -82473,7 +82554,7 @@ async function skillUpdate({ context, args }) {
   if (!name2 || !newName && description === void 0 && !skillMdFile) {
     throw new CliUsageError(USAGE16);
   }
-  const skillMd = skillMdFile ? await readFile28(resolve12(context.cwd, skillMdFile), "utf8") : void 0;
+  const skillMd = skillMdFile ? await readFile29(resolve12(context.cwd, skillMdFile), "utf8") : void 0;
   const { client } = await signedIn({ context, args });
   const updated = await client.post("/api/skills/update", {
     name: name2,
@@ -82519,7 +82600,7 @@ async function skill({ context, args }) {
 }
 
 // src/services/slack-commands.service.ts
-import { readFile as readFile29 } from "node:fs/promises";
+import { readFile as readFile30 } 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
@@ -82567,7 +82648,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 readFile29(resolve13(context.cwd, file3), "utf8") : await context.readStdin();
+  const text2 = file3 ? await readFile30(resolve13(context.cwd, file3), "utf8") : await context.readStdin();
   return text2.split("\n").map((line) => line.trim()).filter(Boolean);
 }
 async function secretsOf({
@@ -82871,7 +82952,7 @@ async function slack({
 }
 
 // src/services/sso-commands.service.ts
-import { readFile as readFile30 } from "node:fs/promises";
+import { readFile as readFile31 } 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
@@ -82958,7 +83039,7 @@ function refuseSecretFlags({ args }) {
 }
 async function clientSecretOf({ context, args }) {
   const file3 = flagText({ args, name: "from-file" });
-  const text2 = file3 ? await readFile30(file3, "utf8") : await context.readStdin();
+  const text2 = file3 ? await readFile31(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;
@@ -83291,7 +83372,7 @@ async function vaultScrub({ context, args }) {
 }
 
 // src/services/whatsapp-business-commands.service.ts
-import { readFile as readFile31 } from "node:fs/promises";
+import { readFile as readFile32 } from "node:fs/promises";
 import { resolve as resolve14 } from "node:path";
 
 // ../../modules/whatsapp-business/contract/src/whatsapp-business.prices.ts
@@ -83711,7 +83792,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 readFile31(resolve14(context.cwd, file3), "utf8") : await context.readStdin();
+  const text2 = file3 ? await readFile32(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(
@@ -84292,7 +84373,7 @@ async function flags({ context, args }) {
 }
 
 // src/services/workspace-commands.service.ts
-import { readFile as readFile32 } from "node:fs/promises";
+import { readFile as readFile33 } from "node:fs/promises";
 import { resolve as resolve16 } from "node:path";
 var ROLE_NAMES2 = {
   OWNER: "Owner",
@@ -84475,7 +84556,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 readFile32(resolve16(context.cwd, file3)));
+    bytes = new Uint8Array(await readFile33(resolve16(context.cwd, file3)));
   } catch {
     throw new CliUsageError(`No file to read at ${file3}.`);
   }
@@ -85136,7 +85217,7 @@ 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 readFile33, readlink } from "node:fs/promises";
+import { readFile as readFile34, readlink } from "node:fs/promises";
 import { dirname as dirname18 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 var run3 = promisify2(execFile2);
@@ -85150,14 +85231,14 @@ function alive(pid) {
   }
 }
 async function argsOf(pid) {
-  const raw = await readFile33(`/proc/${pid}/cmdline`, "utf8").catch(() => void 0);
+  const raw = await readFile34(`/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 readFile33(`/proc/${pid}/stat`, "utf8").catch(() => void 0);
+  const stat3 = await readFile34(`/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);