@alook/daemon 0.1.31 → 0.1.32

package/dist/cli/index.js

@@ -15979,6 +15979,7 @@ var TERMINAL_MEETING_STATUSES = [
   MeetingStatus.COMPLETED,
   MeetingStatus.FAILED
 ];
+var COMMUNITY_BOT_LIMIT_PER_OWNER = 20;
 var COMMUNITY_BOT_NAME_MIN = 1;
 var COMMUNITY_BOT_NAME_MAX = 32;
 var COMMUNITY_BOT_DESCRIPTION_MAX = 1024;
@@ -16853,6 +16854,13 @@ var HostCommandSchema = exports_external.discriminatedUnion("type", [
     launchId: exports_external.string().min(1),
     unreadNotice: exports_external.unknown()
   }),
+  exports_external.object({
+    type: exports_external.literal("agent:event"),
+    agentId: exports_external.string().min(1),
+    config: exports_external.unknown(),
+    launchId: exports_external.string().min(1),
+    prompt: exports_external.string().min(1).max(32768)
+  }),
   exports_external.object({
     type: exports_external.literal("agent:stop"),
     agentId: exports_external.string().min(1)
@@ -17762,6 +17770,10 @@ var CommunityBotPatchRequestSchema = exports_external.object({
 var CommunityBotAddToServerRequestSchema = exports_external.object({
   botId: exports_external.string().min(1)
 });
+var CommunityServerOnboardRequestSchema = exports_external.strictObject({
+  botIds: exports_external.array(exports_external.string().min(1).max(128)).min(1).max(COMMUNITY_BOT_LIMIT_PER_OWNER).refine((ids) => new Set(ids).size === ids.length, "botIds must be unique"),
+  wakePrompt: exports_external.string().max(32768).refine((value) => value.trim().length > 0, "wakePrompt is required")
+});
 var CommunityAgentMessageContentSchema = exports_external.object({ text: exports_external.string().max(MAX_MESSAGE_CONTENT_LENGTH).default("") }).catchall(exports_external.unknown());
 var CommunityAgentSeqSchema = exports_external.number().int().min(0);
 var CommunityAgentPositiveSeqSchema = exports_external.number().int().min(1);
@@ -19557,13 +19569,13 @@ function createProxyServerApi(config2) {
 
 // src/cli/daemonStart.ts
 import * as fs12 from "fs";
-import * as path13 from "path";
+import * as path17 from "path";
 import * as crypto5 from "crypto";
 import * as os3 from "os";
-import { homedir as homedir6 } from "os";
+import { homedir as homedir8 } from "os";
 
 // src/discovery.ts
-import * as path9 from "path";
+import * as path13 from "path";
 import * as fs6 from "fs";
 import { fileURLToPath } from "url";
 // agent-driver/dist/host/default-host.js
@@ -20707,6 +20719,12 @@ function tryParseJsonLine(line) {
     return null;
   }
 }
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function tryParseJsonRecord(line) {
+  return asRecord(tryParseJsonLine(line));
+}
 
 // agent-driver/dist/adapters/claude/normalizer.js
 var API_ERROR_RE = /API Error:.*(?:Connection error|\b[45]\d{2}\b)/i;
@@ -21205,6 +21223,241 @@ class ClaudeTurnProtocol {
   }
 }
 
+// agent-driver/dist/adapters/claude/recent-context.js
+import { createReadStream as createReadStream2 } from "node:fs";
+import { homedir } from "node:os";
+import path7 from "node:path";
+import { createInterface } from "node:readline";
+
+// agent-driver/dist/internal/recent-context.js
+import path6 from "node:path";
+import { createReadStream } from "node:fs";
+import { readdir, stat } from "node:fs/promises";
+function normalizeAbsolutePath(value) {
+  if (typeof value !== "string" || !path6.isAbsolute(value))
+    return null;
+  return path6.normalize(value);
+}
+function normalizeModifiedAt(value) {
+  const date5 = value instanceof Date ? value : typeof value === "string" || typeof value === "number" ? new Date(value) : null;
+  if (!date5 || !Number.isFinite(date5.getTime()))
+    return null;
+  return date5.toISOString();
+}
+function isValidRecentContextTopK(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+function isMissingPathError(error51) {
+  return error51?.code === "ENOENT";
+}
+async function readFirstLine(filePath, maxBytes = 65536) {
+  const stream = createReadStream(filePath, { highWaterMark: 1 });
+  const bytes = [];
+  let length = 0;
+  try {
+    for await (const chunk2 of stream) {
+      const byte = Buffer.isBuffer(chunk2) ? chunk2 : Buffer.from(chunk2);
+      if (byte[0] === 10)
+        break;
+      if (length >= maxBytes)
+        return null;
+      bytes.push(byte);
+      length += byte.length;
+    }
+    return length === 0 ? null : Buffer.concat(bytes, length).toString("utf8").replace(/\r$/, "");
+  } catch (error51) {
+    if (isMissingPathError(error51))
+      return null;
+    throw error51;
+  } finally {
+    stream.destroy();
+  }
+}
+async function collectJsonlFileCandidates(root, options = {}) {
+  const candidates = [];
+  const readDirectory = options.readDirectory ?? ((directory) => readdir(directory, { withFileTypes: true }));
+  const statPath = options.statPath ?? stat;
+  const visit = async (directory, remainingDepth, includeFiles) => {
+    let entries;
+    try {
+      entries = await readDirectory(directory);
+    } catch (error51) {
+      if (isMissingPathError(error51))
+        return;
+      throw error51;
+    }
+    await Promise.all(entries.map(async (entry) => {
+      const entryPath = path6.join(directory, entry.name);
+      if (entry.isDirectory() && remainingDepth > 0) {
+        await visit(entryPath, remainingDepth - 1, true);
+      } else if (includeFiles && entry.isFile() && entry.name.endsWith(".jsonl")) {
+        try {
+          const metadata = await statPath(entryPath);
+          if (metadata.isFile())
+            candidates.push({ filePath: entryPath, modifiedAt: metadata.mtime });
+        } catch (error51) {
+          if (!isMissingPathError(error51))
+            throw error51;
+        }
+      }
+    }));
+  };
+  await visit(root, options.maxDepth ?? Number.POSITIVE_INFINITY, options.includeRootFiles ?? true);
+  return candidates;
+}
+function retainNewest(values, key, value, topK) {
+  const existing = values.get(key);
+  if (existing) {
+    if (value.modifiedAt > existing.modifiedAt)
+      values.set(key, value);
+    return;
+  }
+  if (values.size < topK) {
+    values.set(key, value);
+    return;
+  }
+  let oldest;
+  for (const entry of values) {
+    if (!oldest || entry[1].modifiedAt < oldest[1].modifiedAt)
+      oldest = entry;
+  }
+  if (oldest && value.modifiedAt > oldest[1].modifiedAt) {
+    values.delete(oldest[0]);
+    values.set(key, value);
+  }
+}
+
+class RecentContextCollector {
+  request;
+  sessionFileCapability;
+  sessions = new Map;
+  projects = new Map;
+  constructor(request, sessionFileCapability) {
+    this.request = request;
+    this.sessionFileCapability = sessionFileCapability;
+  }
+  add(candidate, target2 = "both") {
+    const projectPath = normalizeAbsolutePath(candidate.projectPath);
+    const modifiedAt = normalizeModifiedAt(candidate.modifiedAt);
+    if (!projectPath || !modifiedAt)
+      return;
+    if (target2 !== "session") {
+      retainNewest(this.projects, projectPath, { projectPath, modifiedAt }, this.request.recentProjectsTopK);
+    }
+    if (target2 === "project" || this.sessionFileCapability !== "supported")
+      return;
+    const sessionFilePath = normalizeAbsolutePath(candidate.sessionFilePath);
+    if (!sessionFilePath)
+      return;
+    retainNewest(this.sessions, sessionFilePath, { sessionFilePath, projectPath, modifiedAt }, this.request.recentSessionFilesTopK);
+  }
+  get satisfied() {
+    const sessionsSatisfied = this.sessionFileCapability === "unavailable" || this.sessions.size >= this.request.recentSessionFilesTopK;
+    return sessionsSatisfied && this.projects.size >= this.request.recentProjectsTopK;
+  }
+  result() {
+    const newestFirst = (left, right) => right.modifiedAt.localeCompare(left.modifiedAt);
+    return {
+      sessionFiles: {
+        capability: this.sessionFileCapability,
+        items: [...this.sessions.values()].sort(newestFirst).slice(0, this.request.recentSessionFilesTopK)
+      },
+      recentProjects: [...this.projects.values()].sort(newestFirst).slice(0, this.request.recentProjectsTopK)
+    };
+  }
+}
+function sanitizeRecentContextData(value, request) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const candidate = value;
+  if (!candidate.sessionFiles || typeof candidate.sessionFiles !== "object" || Array.isArray(candidate.sessionFiles)) {
+    return null;
+  }
+  const sessionFiles = candidate.sessionFiles;
+  const capability = sessionFiles.capability;
+  if (capability !== "supported" && capability !== "unavailable" || !Array.isArray(sessionFiles.items)) {
+    return null;
+  }
+  if (!Array.isArray(candidate.recentProjects))
+    return null;
+  const collector = new RecentContextCollector(request, capability);
+  if (capability === "supported") {
+    for (const item of sessionFiles.items) {
+      if (!item || typeof item !== "object" || Array.isArray(item))
+        continue;
+      const record2 = item;
+      collector.add({
+        sessionFilePath: record2.sessionFilePath,
+        projectPath: record2.projectPath,
+        modifiedAt: record2.modifiedAt
+      }, "session");
+    }
+  }
+  for (const item of candidate.recentProjects) {
+    if (!item || typeof item !== "object" || Array.isArray(item))
+      continue;
+    const record2 = item;
+    collector.add({ projectPath: record2.projectPath, modifiedAt: record2.modifiedAt }, "project");
+  }
+  return collector.result();
+}
+
+// agent-driver/dist/adapters/claude/recent-context.js
+async function readClaudeProjectPath(filePath) {
+  const input = createReadStream2(filePath);
+  const lines = createInterface({ input, crlfDelay: Infinity });
+  try {
+    for await (const line of lines) {
+      let record2;
+      try {
+        record2 = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!record2 || typeof record2 !== "object")
+        continue;
+      const cwd = record2.cwd;
+      if (typeof cwd === "string" && path7.isAbsolute(cwd))
+        return cwd;
+    }
+    return null;
+  } catch (error51) {
+    if (isMissingPathError(error51))
+      return null;
+    throw error51;
+  } finally {
+    lines.close();
+    input.destroy();
+  }
+}
+async function discoverClaudeRecentContext(request, dependencies = {}) {
+  const collector = new RecentContextCollector(request, "supported");
+  if (collector.satisfied)
+    return collector.result();
+  const projectsRoot = path7.resolve(dependencies.projectsRoot ?? path7.join(process.env.CLAUDE_CONFIG_DIR || path7.join(homedir(), ".claude"), "projects"));
+  const readProjectPath = dependencies.readProjectPath ?? readClaudeProjectPath;
+  const candidates = await collectJsonlFileCandidates(projectsRoot, {
+    includeRootFiles: false,
+    maxDepth: 1,
+    readDirectory: dependencies.readDirectory,
+    statPath: dependencies.statPath
+  });
+  candidates.sort((left, right) => right.modifiedAt.getTime() - left.modifiedAt.getTime());
+  for (const candidate of candidates) {
+    const projectPath = await readProjectPath(candidate.filePath);
+    if (!projectPath)
+      continue;
+    collector.add({
+      sessionFilePath: candidate.filePath,
+      projectPath,
+      modifiedAt: candidate.modifiedAt
+    });
+    if (collector.satisfied)
+      break;
+  }
+  return collector.result();
+}
+
 // agent-driver/dist/adapters/claude/index.js
 var CLAUDE_MODEL_CATALOG = {
   updateMode: "unsupported",
@@ -21226,6 +21479,9 @@ class ClaudeDriver {
   turnProtocol = new ClaudeTurnProtocol;
   eventNormalizer = new ClaudeEventNormalizer(this.turnProtocol);
   pendingInterrupt;
+  discoverRecentContext(request) {
+    return discoverClaudeRecentContext(request);
+  }
   beginTurn() {
     this.pendingInterrupt = undefined;
     const receipt = this.turnProtocol.beginTurn();
@@ -21489,16 +21745,16 @@ function normalizeFileChangeInput(item) {
   for (const candidate of changePaths) {
     if (typeof candidate !== "string")
       continue;
-    const path6 = candidate.trim();
-    if (!path6 || seen.has(path6))
+    const path8 = candidate.trim();
+    if (!path8 || seen.has(path8))
       continue;
-    seen.add(path6);
-    paths.push(path6);
+    seen.add(path8);
+    paths.push(path8);
   }
   if (paths.length === 0 && typeof item?.path === "string") {
-    const path6 = item.path.trim();
-    if (path6)
-      paths.push(path6);
+    const path8 = item.path.trim();
+    if (path8)
+      paths.push(path8);
   }
   return paths.length > 0 ? { path: paths.join(", ") } : {};
 }
@@ -21867,7 +22123,7 @@ class CodexEventNormalizer {
 
 // agent-driver/dist/adapters/codex/home.js
 import * as os from "os";
-import * as path6 from "path";
+import * as path8 from "path";
 function readConfiguredCodexHome(env) {
   const raw = env.CODEX_HOME;
   return typeof raw === "string" && raw.trim().length > 0 ? raw : null;
@@ -21875,8 +22131,8 @@ function readConfiguredCodexHome(env) {
 function resolveCodexHomeRootFromEnv(env = process.env, opts = {}) {
   const raw = readConfiguredCodexHome(env);
   if (raw)
-    return path6.resolve(opts.cwd ?? process.cwd(), raw);
-  return path6.join(opts.defaultHomeDir ?? os.homedir(), ".codex");
+    return path8.resolve(opts.cwd ?? process.cwd(), raw);
+  return path8.join(opts.defaultHomeDir ?? os.homedir(), ".codex");
 }
 
 // agent-driver/dist/internal/errors.js
@@ -21969,6 +22225,49 @@ function parsePiModelCatalog(values) {
   return catalogFromIds(ids);
 }
 
+// agent-driver/dist/adapters/codex/recent-context.js
+import path9 from "node:path";
+function isChildSession(payload) {
+  if (payload.parentThreadId != null || payload.parent_thread_id != null)
+    return true;
+  const source = payload.source;
+  if (typeof source === "string")
+    return source.toLowerCase().startsWith("subagent");
+  const sourceRecord = asRecord(source);
+  return sourceRecord != null && (("subagent" in sourceRecord) || ("subAgent" in sourceRecord));
+}
+async function discoverCodexRecentContext(request, dependencies = {}) {
+  const collector = new RecentContextCollector(request, "supported");
+  if (collector.satisfied)
+    return collector.result();
+  const sessionsRoot = path9.resolve(dependencies.sessionsRoot ?? path9.join(resolveCodexHomeRootFromEnv(), "sessions"));
+  const readHeader = dependencies.readHeader ?? readFirstLine;
+  const candidates = await collectJsonlFileCandidates(sessionsRoot, {
+    readDirectory: dependencies.readDirectory,
+    statPath: dependencies.statPath
+  });
+  candidates.sort((left, right) => right.modifiedAt.getTime() - left.modifiedAt.getTime());
+  for (const candidate of candidates) {
+    const line = await readHeader(candidate.filePath);
+    if (!line)
+      continue;
+    const header = tryParseJsonRecord(line);
+    if (!header)
+      continue;
+    const payload = asRecord(header.payload);
+    if (header.type !== "session_meta" || !payload || isChildSession(payload))
+      continue;
+    collector.add({
+      sessionFilePath: candidate.filePath,
+      projectPath: payload.cwd,
+      modifiedAt: candidate.modifiedAt
+    });
+    if (collector.satisfied)
+      break;
+  }
+  return collector.result();
+}
+
 // agent-driver/dist/adapters/codex/index.js
 var SETTINGS_UPDATE_TIMEOUT_MS = 5000;
 var MODEL_LIST_TIMEOUT_MS = 5000;
@@ -21997,6 +22296,9 @@ class CodexDriver {
   eventNormalizer = new CodexEventNormalizer;
   pendingAccountReadRequestIds = new Set;
   requestId = 0;
+  discoverRecentContext(request) {
+    return discoverCodexRecentContext(request);
+  }
   codexHomeRoot = null;
   proc = null;
   pendingInitialPrompt = null;
@@ -23173,6 +23475,196 @@ class CursorAcpLane {
   }
 }
 
+// agent-driver/dist/internal/discovery-process.js
+import { StringDecoder } from "node:string_decoder";
+function toBuffer(chunk2) {
+  if (Buffer.isBuffer(chunk2))
+    return chunk2;
+  if (chunk2 instanceof Uint8Array)
+    return Buffer.from(chunk2.buffer, chunk2.byteOffset, chunk2.byteLength);
+  return Buffer.from(String(chunk2));
+}
+async function cleanupProcess(process3, label) {
+  if (process3.pid)
+    await killProcessTree(process3.pid, { graceMs: 250 });
+  else if (process3.exitCode === null && process3.signalCode === null && !process3.kill("SIGTERM")) {
+    throw new Error(`${label} discovery cleanup failed`);
+  }
+}
+function onStream(stream, event, listener) {
+  stream?.on?.(event, listener);
+}
+function runBoundedDiscoveryProcess(options) {
+  return new Promise((resolve2, reject) => {
+    const decoder = new StringDecoder("utf8");
+    let settled = false;
+    let decoderEnded = false;
+    let outputBytes = 0;
+    const settle = (result, error51) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      if (!decoderEnded)
+        decoder.end();
+      Promise.resolve().then(() => options.cleanup?.(options.process) ?? cleanupProcess(options.process, options.label)).then(() => error51 ? reject(error51) : resolve2(result), () => reject(error51 ?? new Error(`${options.label} discovery cleanup failed`)));
+    };
+    const control = {
+      get outputBytes() {
+        return outputBytes;
+      },
+      finish: (result) => settle(result),
+      fail: (message2) => settle(undefined, new Error(message2)),
+      flushStdout: () => {
+        if (settled || decoderEnded)
+          return;
+        decoderEnded = true;
+        options.onStdout(decoder.end(), true, control);
+      },
+      write: (line) => {
+        const stdin = options.process.stdin;
+        if (!stdin || stdin.destroyed || stdin.writableEnded || stdin.writable === false) {
+          return control.fail(`${options.label} discovery transport is unavailable`);
+        }
+        try {
+          stdin.write(line);
+        } catch {
+          control.fail(`${options.label} discovery transport write failed`);
+        }
+      }
+    };
+    const addBytes = (chunk2, decode3) => {
+      if (settled)
+        return;
+      const bytes = toBuffer(chunk2);
+      outputBytes += bytes.byteLength;
+      if (outputBytes > options.outputMaxBytes) {
+        control.fail(`${options.label} discovery output exceeded its bound`);
+      } else if (decode3)
+        options.onStdout(decoder.write(bytes), false, control);
+    };
+    const timer = setTimeout(() => control.fail(`${options.label} discovery timed out`), Math.max(1, options.timeoutMs));
+    timer.unref?.();
+    options.process.stdout?.on("data", (chunk2) => addBytes(chunk2, true));
+    options.process.stderr?.on("data", (chunk2) => addBytes(chunk2, false));
+    onStream(options.process.stdout, "end", control.flushStdout);
+    for (const stream of [options.process.stdin, options.process.stdout, options.process.stderr]) {
+      onStream(stream, "error", () => control.fail(`${options.label} discovery transport failed`));
+    }
+    options.process.on("error", () => control.fail(`${options.label} discovery process failed`));
+    options.process.on(options.exitEvent, (code, signal) => options.onExit(code, signal, control));
+    options.onStart?.(control);
+  });
+}
+
+// agent-driver/dist/adapters/cursor/recent-context.js
+var ACP_PROTOCOL_VERSION3 = 1;
+var AUTH_METHOD_ID3 = "cursor_login";
+var CURSOR_DISCOVERY_TIMEOUT_MS = 30000;
+var CURSOR_DISCOVERY_OUTPUT_MAX_BYTES = 4 * 1024 * 1024;
+async function discoverCursorRecentContext(request, dependencies = {}) {
+  const collector = new RecentContextCollector(request, "unavailable");
+  if (collector.satisfied)
+    return collector.result();
+  const spec = resolveSpawnSpec("cursor-agent", ["acp"], request.command);
+  const processHandle = (dependencies.spawn ?? spawnAgentProcess)(spec.command, spec.args, {
+    cwd: dependencies.cwd ?? process.cwd(),
+    env: { ...process.env, CI: "1" },
+    shell: spec.shell
+  });
+  let buffer = "";
+  let requestId = 0;
+  let expectedId = 0;
+  let expectedMethod = "";
+  const seenCursors = new Set;
+  const requestRpc = (method, params, control) => {
+    expectedId = ++requestId;
+    expectedMethod = method;
+    control.write(`${jsonRpcRequest(method, params, expectedId)}
+`);
+  };
+  const requestPage = (control, cursor) => requestRpc("session/list", cursor ? { cursor } : {}, control);
+  const onLine = (line, control) => {
+    const message2 = asRecord(tryParseJsonLine(line));
+    if (!message2 || message2.id !== expectedId)
+      return;
+    if (message2.error !== undefined)
+      return control.fail("Cursor discovery request failed");
+    const result = asRecord(message2.result);
+    if (!result)
+      return control.fail("Cursor discovery returned an invalid response");
+    if (expectedMethod === "initialize") {
+      if (result.protocolVersion !== ACP_PROTOCOL_VERSION3) {
+        return control.fail("Cursor discovery protocol is incompatible");
+      }
+      const capabilities = asRecord(result.agentCapabilities);
+      const sessionCapabilities = asRecord(capabilities?.sessionCapabilities);
+      if (sessionCapabilities?.list !== true && !asRecord(sessionCapabilities?.list)) {
+        return control.fail("Cursor session listing is unavailable");
+      }
+      const authMethods = Array.isArray(result.authMethods) ? result.authMethods : [];
+      if (!authMethods.some((method) => asRecord(method)?.id === AUTH_METHOD_ID3)) {
+        return control.fail("Cursor discovery authentication is unavailable");
+      }
+      requestRpc("authenticate", { methodId: AUTH_METHOD_ID3 }, control);
+      return;
+    }
+    if (expectedMethod === "authenticate") {
+      requestPage(control);
+      return;
+    }
+    if (expectedMethod !== "session/list")
+      return control.fail("Cursor discovery state is invalid");
+    const sessions = Array.isArray(result.sessions) ? result.sessions : Array.isArray(result.data) ? result.data : [];
+    for (const value of sessions) {
+      const session2 = asRecord(value);
+      if (!session2)
+        continue;
+      collector.add({ projectPath: session2.cwd, modifiedAt: session2.updatedAt });
+      if (collector.satisfied)
+        return control.finish(collector.result());
+    }
+    const nextCursor = typeof result.nextCursor === "string" && result.nextCursor ? result.nextCursor : undefined;
+    if (!nextCursor)
+      return control.finish(collector.result());
+    if (seenCursors.has(nextCursor))
+      return control.fail("Cursor discovery cursor repeated");
+    seenCursors.add(nextCursor);
+    requestPage(control, nextCursor);
+  };
+  return runBoundedDiscoveryProcess({
+    process: processHandle,
+    label: "Cursor",
+    timeoutMs: dependencies.timeoutMs ?? CURSOR_DISCOVERY_TIMEOUT_MS,
+    outputMaxBytes: dependencies.outputMaxBytes ?? CURSOR_DISCOVERY_OUTPUT_MAX_BYTES,
+    cleanup: dependencies.cleanup,
+    exitEvent: "exit",
+    onStdout: (text2, final, control) => {
+      buffer += text2;
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() ?? "";
+      for (const line of lines)
+        if (line.trim())
+          onLine(line, control);
+      if (final && buffer.trim()) {
+        const line = buffer;
+        buffer = "";
+        onLine(line, control);
+      }
+    },
+    onExit: (_code, _signal, control) => control.fail("Cursor discovery process exited early"),
+    onStart: (control) => requestRpc("initialize", {
+      protocolVersion: ACP_PROTOCOL_VERSION3,
+      clientCapabilities: {
+        fs: { readTextFile: false, writeTextFile: false },
+        terminal: false
+      },
+      clientInfo: { name: "alook-agent-driver-discovery", version: "0.1.31" }
+    }, control)
+  });
+}
+
 // agent-driver/dist/adapters/cursor/index.js
 class CursorDriver {
   catalogProbe;
@@ -23184,6 +23676,9 @@ class CursorDriver {
     wakeStart: "immediate",
     terminalOwnership: "transport_request"
   };
+  discoverRecentContext(request) {
+    return discoverCursorRecentContext(request);
+  }
   constructor(catalogProbe = probeCursorAcpCatalog) {
     this.catalogProbe = catalogProbe;
   }
@@ -23678,7 +24173,7 @@ class OpenCodeServiceLane {
       "/api/session/{sessionID}/permission/{requestID}/reply",
       "/api/event"
     ];
-    if (!paths || required2.some((path7) => !record4(paths[path7]))) {
+    if (!paths || required2.some((path10) => !record4(paths[path10]))) {
       throw new OpenCodeIncompatibleError("Installed OpenCode service is missing required v2 session capabilities");
     }
   }
@@ -23736,8 +24231,8 @@ class OpenCodeServiceLane {
       const controller = new AbortController;
       this.durableAbort = controller;
       try {
-        const path7 = `/api/session/${encodeURIComponent(this.sessionId)}/event?after=${this.lastDurableSeq}`;
-        const response = await this.openStream(path7, controller, "durable event stream");
+        const path10 = `/api/session/${encodeURIComponent(this.sessionId)}/event?after=${this.lastDurableSeq}`;
+        const response = await this.openStream(path10, controller, "durable event stream");
         await this.catchUpHistory(true);
         if (!this.isIdentity(identity))
           return;
@@ -23811,12 +24306,12 @@ class OpenCodeServiceLane {
       return;
     this.protocolFailure(`OpenCode ${kind} stream stopped unexpectedly`, error51);
   }
-  async openStream(path7, lifecycle, operation) {
+  async openStream(path10, lifecycle, operation) {
     const deadline = new AbortController;
     const timeout = setTimeout(() => deadline.abort(), this.options.requestTimeoutMs ?? REQUEST_TIMEOUT_MS);
     timeout.unref?.();
     try {
-      const response = await this.fetchFn(`${this.baseUrl}${path7}`, {
+      const response = await this.fetchFn(`${this.baseUrl}${path10}`, {
         method: "GET",
         headers: this.headers({ accept: "text/event-stream" }),
         signal: AbortSignal.any([lifecycle.signal, deadline.signal])
@@ -24243,8 +24738,8 @@ class OpenCodeServiceLane {
       turnOwner: root.receipt
     });
   }
-  async requestNoContent(path7, method, body, operation) {
-    const response = await this.fetchWithTimeout(path7, {
+  async requestNoContent(path10, method, body, operation) {
+    const response = await this.fetchWithTimeout(path10, {
       method,
       ...body ? {
         headers: { "content-type": "application/json" },
@@ -24254,7 +24749,7 @@ class OpenCodeServiceLane {
     if (!response.ok)
       throw new OpenCodeHttpError(response.status, operation);
   }
-  async fetchWithTimeout(path7, init, operation, timeoutMs = this.options.requestTimeoutMs ?? REQUEST_TIMEOUT_MS) {
+  async fetchWithTimeout(path10, init, operation, timeoutMs = this.options.requestTimeoutMs ?? REQUEST_TIMEOUT_MS) {
     if (this.stopping)
       throw new Error("OpenCode service lane is stopping");
     const controller = new AbortController;
@@ -24262,7 +24757,7 @@ class OpenCodeServiceLane {
     const timer = setTimeout(() => controller.abort(), timeoutMs);
     timer.unref?.();
     try {
-      return await this.fetchFn(`${this.baseUrl}${path7}`, {
+      return await this.fetchFn(`${this.baseUrl}${path10}`, {
         ...init,
         headers: this.headers(init.headers),
         signal: controller.signal
@@ -24274,7 +24769,7 @@ class OpenCodeServiceLane {
       this.requestControllers.delete(controller);
     }
   }
-  async fetchJsonWithTimeout(path7, init, operation, timeoutMs = this.options.requestTimeoutMs ?? REQUEST_TIMEOUT_MS) {
+  async fetchJsonWithTimeout(path10, init, operation, timeoutMs = this.options.requestTimeoutMs ?? REQUEST_TIMEOUT_MS) {
     if (this.stopping)
       throw new OpenCodeStoppedError("OpenCode service lane is stopping");
     const controller = new AbortController;
@@ -24286,7 +24781,7 @@ class OpenCodeServiceLane {
     }, timeoutMs);
     timer.unref?.();
     try {
-      const response = await this.fetchFn(`${this.baseUrl}${path7}`, {
+      const response = await this.fetchFn(`${this.baseUrl}${path10}`, {
         ...init,
         headers: this.headers(init.headers),
         signal: controller.signal
@@ -24379,6 +24874,75 @@ class OpenCodeServiceLane {
   }
 }
 
+// agent-driver/dist/adapters/opencode/recent-context.js
+var OPENCODE_DISCOVERY_TIMEOUT_MS = 15000;
+var OPENCODE_DISCOVERY_OUTPUT_MAX_BYTES = 4 * 1024 * 1024;
+function collectCommandOutput(command, args, shell, dependencies, timeoutMs, outputMaxBytes) {
+  const processHandle = (dependencies.spawn ?? spawnAgentProcess)(command, args, {
+    cwd: dependencies.cwd ?? process.cwd(),
+    env: { ...process.env, CI: "1" },
+    shell,
+    stdin: "ignore"
+  });
+  let output = "";
+  return runBoundedDiscoveryProcess({
+    process: processHandle,
+    label: "OpenCode",
+    timeoutMs,
+    outputMaxBytes,
+    cleanup: dependencies.cleanup,
+    exitEvent: "close",
+    onStdout: (text2) => {
+      output += text2;
+    },
+    onExit: (code, _signal, control) => {
+      if (code !== 0)
+        return control.fail("OpenCode session listing failed");
+      control.flushStdout();
+      control.finish({ output, outputBytes: control.outputBytes });
+    }
+  });
+}
+async function discoverOpenCodeRecentContext(request, dependencies = {}) {
+  const collector = new RecentContextCollector(request, "unavailable");
+  if (collector.satisfied)
+    return collector.result();
+  const startedAt = Date.now();
+  const timeoutMs = dependencies.timeoutMs ?? OPENCODE_DISCOVERY_TIMEOUT_MS;
+  let remainingOutputBytes = dependencies.outputMaxBytes ?? OPENCODE_DISCOVERY_OUTPUT_MAX_BYTES;
+  let maxCount = Math.max(1, Math.min(Number.MAX_SAFE_INTEGER, request.recentProjectsTopK * 10));
+  while (!collector.satisfied) {
+    const remainingTimeoutMs = timeoutMs - (Date.now() - startedAt);
+    if (remainingTimeoutMs <= 0)
+      throw new Error("OpenCode discovery timed out");
+    const spec = resolveSpawnSpec("opencode", ["session", "list", "--format", "json", "--max-count", String(maxCount), "--pure"], request.command);
+    const commandOutput = await collectCommandOutput(spec.command, spec.args, spec.shell, dependencies, remainingTimeoutMs, remainingOutputBytes);
+    remainingOutputBytes -= commandOutput.outputBytes;
+    let parsed;
+    try {
+      parsed = JSON.parse(commandOutput.output);
+    } catch {
+      throw new Error("OpenCode session listing returned invalid JSON");
+    }
+    if (!Array.isArray(parsed))
+      throw new Error("OpenCode session listing returned an invalid response");
+    for (const value of parsed) {
+      const session2 = asRecord(value);
+      if (!session2)
+        continue;
+      const modifiedAt = session2.updated ?? session2.updatedAt;
+      collector.add({ projectPath: session2.directory, modifiedAt });
+    }
+    if (collector.satisfied || parsed.length < maxCount)
+      break;
+    const nextMaxCount = Math.min(Number.MAX_SAFE_INTEGER, maxCount * 2);
+    if (nextMaxCount === maxCount)
+      throw new Error("OpenCode session listing could not prove the requested Top-K");
+    maxCount = nextMaxCount;
+  }
+  return collector.result();
+}
+
 // agent-driver/dist/adapters/opencode/index.js
 function createOpenCodeMessageId() {
   return `msg_${randomBytes3(16).toString("hex")}`;
@@ -24397,6 +24961,9 @@ class OpenCodeDriver {
   constructor(outputProbe = probeCommandOutput) {
     this.outputProbe = outputProbe;
   }
+  discoverRecentContext(request) {
+    return discoverOpenCodeRecentContext(request);
+  }
   probe(command) {
     const result = probeCliRuntime("opencode", {}, command);
     if (result.status !== "healthy")
@@ -24443,8 +25010,8 @@ class OpenCodeDriver {
 // agent-driver/dist/adapters/pi/index.js
 import { createRequire as createRequire2 } from "module";
 import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3, realpathSync } from "fs";
-import { homedir as homedir2 } from "os";
-import * as path8 from "path";
+import { homedir as homedir4 } from "os";
+import * as path12 from "path";
 
 // agent-driver/dist/controller/sdk-host.js
 import { EventEmitter as EventEmitter4 } from "events";
@@ -24559,7 +25126,7 @@ class SdkLane {
 
 // agent-driver/dist/adapters/pi/sessionDeps.js
 import { readFileSync as readFileSync2 } from "fs";
-import * as path7 from "path";
+import * as path10 from "path";
 import { pathToFileURL } from "url";
 var PI_SDK_PACKAGE_NAME = "@earendil-works/pi-coding-agent";
 var cachedSdkPromise = null;
@@ -24568,9 +25135,9 @@ async function importPiSdkFromGlobalInstall() {
   if (!dir) {
     throw new Error(`${PI_SDK_PACKAGE_NAME} not found — install it (e.g. \`npm install -g ${PI_SDK_PACKAGE_NAME}\`) before launching a pi agent`);
   }
-  const pkg = JSON.parse(readFileSync2(path7.join(dir, "package.json"), "utf-8"));
+  const pkg = JSON.parse(readFileSync2(path10.join(dir, "package.json"), "utf-8"));
   const entry = pkg.exports?.["."]?.import ?? pkg.main ?? "./dist/index.js";
-  const entryPath = path7.join(dir, entry);
+  const entryPath = path10.join(dir, entry);
   const barrel = await import(pathToFileURL(entryPath).href);
   return withSessionDirHelper(barrel, entryPath);
 }
@@ -24578,7 +25145,7 @@ async function withSessionDirHelper(barrel, entryPath) {
   if (typeof barrel.getDefaultSessionDir === "function")
     return barrel;
   try {
-    const deepPath = path7.join(path7.dirname(entryPath), "core", "session-manager.js");
+    const deepPath = path10.join(path10.dirname(entryPath), "core", "session-manager.js");
     const deep = await import(pathToFileURL(deepPath).href);
     if (typeof deep.getDefaultSessionDir !== "function")
       return barrel;
@@ -24658,6 +25225,51 @@ function createPiSessionDependencies(ctx, loadSdk = loadPiSdkModule) {
   };
 }
 
+// agent-driver/dist/adapters/pi/recent-context.js
+import { homedir as homedir3 } from "node:os";
+import path11 from "node:path";
+function expandTildePath(value) {
+  if (value === "~")
+    return homedir3();
+  if (value.startsWith("~/"))
+    return path11.join(homedir3(), value.slice(2));
+  return value;
+}
+async function discoverPiRecentContext(request, dependencies = {}) {
+  const collector = new RecentContextCollector(request, "supported");
+  if (collector.satisfied)
+    return collector.result();
+  const customSessionDirectory = process.env.PI_CODING_AGENT_SESSION_DIR;
+  const sessionsRoot = path11.resolve(expandTildePath(dependencies.sessionsRoot ?? customSessionDirectory ?? path11.join(process.env.PI_CODING_AGENT_DIR || path11.join(homedir3(), ".pi", "agent"), "sessions")));
+  const scanDirectSessions = dependencies.sessionsRoot == null && customSessionDirectory != null;
+  const readHeader = dependencies.readHeader ?? readFirstLine;
+  const candidates = await collectJsonlFileCandidates(sessionsRoot, {
+    includeRootFiles: scanDirectSessions,
+    maxDepth: 1,
+    readDirectory: dependencies.readDirectory,
+    statPath: dependencies.statPath
+  });
+  candidates.sort((left, right) => right.modifiedAt.getTime() - left.modifiedAt.getTime());
+  for (const candidate of candidates) {
+    const line = await readHeader(candidate.filePath);
+    if (!line)
+      continue;
+    const header = tryParseJsonRecord(line);
+    if (!header)
+      continue;
+    if (header.type !== "session" || header.parentSession != null)
+      continue;
+    collector.add({
+      sessionFilePath: candidate.filePath,
+      projectPath: header.cwd,
+      modifiedAt: candidate.modifiedAt
+    });
+    if (collector.satisfied)
+      break;
+  }
+  return collector.result();
+}
+
 // agent-driver/dist/adapters/pi/index.js
 var PI_SDK_PACKAGE_NAME2 = "@earendil-works/pi-coding-agent";
 var PI_MODEL_PROBE_TIMEOUT_MS = 5000;
@@ -24676,15 +25288,15 @@ function resolvePiSdkPackageDir(deps = {}) {
   if (!binPath)
     return;
   try {
-    let dir = path8.dirname(realpathSync(binPath));
+    let dir = path12.dirname(realpathSync(binPath));
     const MAX_DEPTH = 8;
     for (let i = 0;i < MAX_DEPTH; i++) {
-      if (isPiSdkPackageJson(path8.join(dir, "package.json")))
+      if (isPiSdkPackageJson(path12.join(dir, "package.json")))
         return dir;
-      const siblingDir = path8.join(dir, "node_modules", PI_SDK_PACKAGE_NAME2);
-      if (isPiSdkPackageJson(path8.join(siblingDir, "package.json")))
+      const siblingDir = path12.join(dir, "node_modules", PI_SDK_PACKAGE_NAME2);
+      if (isPiSdkPackageJson(path12.join(siblingDir, "package.json")))
         return siblingDir;
-      const parent = path8.dirname(dir);
+      const parent = path12.dirname(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -24701,21 +25313,21 @@ function findPiSessionFile(sessionDir, sessionId) {
   }
   const suffix = `_${sessionId}.jsonl`;
   const match = entries.find((entry) => entry.endsWith(suffix));
-  return match ? path8.join(sessionDir, match) : null;
+  return match ? path12.join(sessionDir, match) : null;
 }
 function resolvePiSessionDir(sdk, cwd) {
   if (typeof sdk.getDefaultSessionDir === "function")
     return sdk.getDefaultSessionDir(cwd);
-  const agentDir = typeof sdk.getAgentDir === "function" ? sdk.getAgentDir() : path8.join(homedir2(), ".pi", "agent");
-  const encoded = `--${path8.resolve(cwd).replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
-  return path8.join(agentDir, "sessions", encoded);
+  const agentDir = typeof sdk.getAgentDir === "function" ? sdk.getAgentDir() : path12.join(homedir4(), ".pi", "agent");
+  const encoded = `--${path12.resolve(cwd).replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+  return path12.join(agentDir, "sessions", encoded);
 }
 function resolvePiSdkVersionFromPath(deps = {}) {
   const dir = resolvePiSdkPackageDir(deps);
   if (!dir)
     return;
   try {
-    const pkg = JSON.parse(readFileSync3(path8.join(dir, "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync3(path12.join(dir, "package.json"), "utf-8"));
     return pkg.version;
   } catch {
     return;
@@ -24819,6 +25431,9 @@ class PiDriver {
   };
   sessionId = null;
   terminalSequence = 0;
+  discoverRecentContext(request) {
+    return discoverPiRecentContext(request);
+  }
   constructor(dependenciesFor = createPiSessionDependencies, loadSdk = loadPiSdkModule, readVersion = readPiSdkVersion) {
     this.dependenciesFor = dependenciesFor;
     this.loadSdk = loadSdk;
@@ -24964,6 +25579,9 @@ function assertAdapterCompatibility(registrationId, registeredCapabilities, adap
     if (typeof candidate[method] !== "function")
       throw new Error(`Adapter ${registrationId} is missing ${method}()`);
   }
+  if (candidate.discoverRecentContext !== undefined && typeof candidate.discoverRecentContext !== "function") {
+    throw new Error(`Adapter ${registrationId} has an invalid discoverRecentContext()`);
+  }
   const instruction = candidate.instructionDelivery;
   if (!instruction || instruction.kind !== "native" && instruction.kind !== "workspace_file") {
     throw new Error(`Adapter ${registrationId} has an invalid instructionDelivery declaration`);
@@ -25185,8 +25803,8 @@ function ensureSymlinks(workDir, canonical = CANONICAL_FILE, aliases = SYMLINK_A
       continue;
     const aliasPath = join8(workDir, alias2);
     try {
-      const stat = lstatSync(aliasPath);
-      if (stat.isSymbolicLink()) {
+      const stat2 = lstatSync(aliasPath);
+      if (stat2.isSymbolicLink()) {
         const target2 = readlinkSync(aliasPath);
         if (target2 === canonical)
           continue;
@@ -25349,6 +25967,7 @@ class LogicalAgentSession {
   steeringDeliveries = new Set;
   laneAdmissionTail = Promise.resolve();
   laneAdmissionPending = 0;
+  toolBoundaryOpen = true;
   toolBoundaryFlushDisabled = false;
   safeBoundaryFlush;
   safeBoundaryDelivery;
@@ -25629,6 +26248,8 @@ class LogicalAgentSession {
     this.turnError = undefined;
     this.interruptedTurnId = undefined;
     this.processTurnEnded = false;
+    this.toolBoundaryOpen = true;
+    this.toolBoundaryFlushDisabled = false;
     this.state = "starting";
     const generation = this.lifecycleGeneration;
     const text2 = messages.map((message2) => message2.text).join(`
@@ -25861,6 +26482,7 @@ class LogicalAgentSession {
         }
         if (!this.startToolUse(event.callId))
           return;
+        this.toolBoundaryOpen = false;
         const startedCallId = this.toolCallId(event.callId);
         this.emit({
           type: "tool_started",
@@ -25877,6 +26499,7 @@ class LogicalAgentSession {
         }
         if (!this.finishToolUse(event.callId))
           return;
+        this.toolBoundaryOpen = true;
         const finishedCallId = this.toolCallId(event.callId);
         this.emit({
           type: "tool_finished",
@@ -25884,7 +26507,7 @@ class LogicalAgentSession {
           ...finishedCallId ? { callId: finishedCallId } : {},
           name: event.name
         });
-        if (this.outstandingToolUseCount() === 0 && !this.toolBoundaryFlushDisabled)
+        if (!this.toolBoundaryFlushDisabled)
           this.flushSafeBoundaryQueue();
         return;
       case "compaction_started":
@@ -26030,6 +26653,7 @@ class LogicalAgentSession {
     this.clearOutstandingToolUses();
     this.compacting = false;
     this.reviewing = false;
+    this.toolBoundaryOpen = true;
     this.toolBoundaryFlushDisabled = false;
     this.state = "idle";
     if (this.adapter.execution.lifetime === "turn") {
@@ -26051,7 +26675,7 @@ class LogicalAgentSession {
     return this.safeBoundaryFlush;
   }
   canFlushSafeBoundaryQueue() {
-    return this.state === "working" && this.behavior.midTurnDelivery === "safe_boundary_queue" && this.outstandingToolUseCount() === 0 && !this.compacting && !this.reviewing && this.activeTurn !== undefined && this.lane !== null && this.queued.length > 0;
+    return this.state === "working" && this.behavior.midTurnDelivery === "safe_boundary_queue" && this.toolBoundaryOpen && !this.toolBoundaryFlushDisabled && !this.compacting && !this.reviewing && this.activeTurn !== undefined && this.lane !== null && this.queued.length > 0;
   }
   async drainSafeBoundaryQueue() {
     while (this.canFlushSafeBoundaryQueue()) {
@@ -26566,6 +27190,57 @@ function createAgentDriverSdkWithRegistry(options) {
   const registry2 = options.registry;
   return {
     backendIds: registry2.backendIds,
+    async discoverRecentContext(input) {
+      if (!isValidRecentContextTopK(input.recentSessionFilesTopK) || !isValidRecentContextTopK(input.recentProjectsTopK)) {
+        return {
+          ok: false,
+          error: {
+            category: "configuration",
+            code: "invalid_recent_context_top_k",
+            message: "Recent-context Top-K values must be non-negative safe integers",
+            retryable: false
+          }
+        };
+      }
+      const registration = registry2.get(input.backend);
+      try {
+        assertRegistrationShape(registration);
+        const adapter = registration.createAdapter();
+        assertAdapterCompatibility(String(registration.id), registration.capabilities, adapter);
+        if (!adapter.discoverRecentContext) {
+          return {
+            ok: false,
+            error: {
+              category: "configuration",
+              code: "recent_context_discovery_unsupported",
+              message: `Backend ${input.backend} does not support recent-context discovery`,
+              retryable: false
+            }
+          };
+        }
+        const command = registration.capabilities.commandOverride ? input.command : undefined;
+        const discovered = await adapter.discoverRecentContext({
+          recentSessionFilesTopK: input.recentSessionFilesTopK,
+          recentProjectsTopK: input.recentProjectsTopK,
+          ...command ? { command } : {}
+        });
+        const sanitized = sanitizeRecentContextData(discovered, input);
+        if (!sanitized)
+          throw new Error(`Adapter ${input.backend} returned invalid recent-context data`);
+        return { ok: true, ...sanitized };
+      } catch (error51) {
+        const contractInvalid = error51 instanceof Error && (error51.message.startsWith("Adapter ") || error51.message.startsWith("Agent backend registration "));
+        return {
+          ok: false,
+          error: {
+            category: contractInvalid ? "internal" : "runtime_unavailable",
+            code: contractInvalid ? "adapter_contract_invalid" : "recent_context_discovery_failed",
+            message: contractInvalid ? `Backend ${input.backend} adapter contract is invalid` : `Backend ${input.backend} recent-context discovery failed`,
+            retryable: !contractInvalid
+          }
+        };
+      }
+    },
     async probe(input) {
       const registration = registry2.get(input.backend);
       const capabilities2 = registration.capabilities;
@@ -26704,22 +27379,22 @@ function listRuntimeIds() {
 
 // src/discovery.ts
 function resolveAlookCliPath(moduleDir) {
-  const thisDir = moduleDir ?? path9.dirname(fileURLToPath(import.meta.url));
-  const target2 = path9.basename(thisDir) === "dist" ? path9.resolve(thisDir, "cli", "index.js") : path9.resolve(thisDir, "..", "scripts", "alook-shim.mjs");
+  const thisDir = moduleDir ?? path13.dirname(fileURLToPath(import.meta.url));
+  const target2 = path13.basename(thisDir) === "dist" ? path13.resolve(thisDir, "cli", "index.js") : path13.resolve(thisDir, "..", "scripts", "alook-shim.mjs");
   return fs6.existsSync(target2) ? target2 : null;
 }
 function deriveCliFallbackCandidates(cliPath) {
   if (!cliPath)
     return [];
-  const normalized = cliPath.split(path9.sep).join("/");
+  const normalized = cliPath.split(path13.sep).join("/");
   const marker = "/node_modules/";
   const idx = normalized.indexOf(marker);
   if (idx === -1)
     return [];
   const globalRoot = cliPath.slice(0, idx + marker.length - 1);
-  const tail = path9.join("dist", "cli", "index.js");
+  const tail = path13.join("dist", "cli", "index.js");
   return [
-    path9.join(globalRoot, "@alook", "daemon", tail)
+    path13.join(globalRoot, "@alook", "daemon", tail)
   ].filter((candidate) => candidate !== cliPath);
 }
 function resolveAlookCliPathWithFallback(primary) {
@@ -26861,11 +27536,11 @@ function readDaemonVersion() {
 
 // src/cli/daemonRunner.ts
 import * as fs11 from "node:fs";
-import * as path12 from "node:path";
+import * as path16 from "node:path";
 import { WebSocket } from "ws";
 
 // src/daemon/createDaemon.ts
-import { homedir as homedir5 } from "os";
+import { homedir as homedir7 } from "os";
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync8 } from "node:fs";
 
 // src/util/rotatingFileSink.ts
@@ -26882,7 +27557,7 @@ import {
   statSync,
   unlinkSync as unlinkSync3
 } from "node:fs";
-function createRotatingFileSink(path10, maxBytes, opts = {}) {
+function createRotatingFileSink(path14, maxBytes, opts = {}) {
   const report = (operation, error51) => {
     try {
       opts.onError?.({ operation, error: error51 });
@@ -26892,8 +27567,8 @@ function createRotatingFileSink(path10, maxBytes, opts = {}) {
     if (!existsSync6(filePath))
       return true;
     try {
-      const stat = lstatSync2(filePath);
-      if (!stat.isFile()) {
+      const stat2 = lstatSync2(filePath);
+      if (!stat2.isFile()) {
         if (opts.mode === undefined && !opts.hardMaxBytes)
           return true;
         report("unsafe_generation", new Error("log generation is not a regular file"));
@@ -26901,7 +27576,7 @@ function createRotatingFileSink(path10, maxBytes, opts = {}) {
       }
       if (opts.mode !== undefined)
         chmodSync(filePath, opts.mode);
-      if (opts.hardMaxBytes && maxBytes > 0 && stat.size > maxBytes) {
+      if (opts.hardMaxBytes && maxBytes > 0 && stat2.size > maxBytes) {
         try {
           unlinkSync3(filePath);
         } catch (error51) {
@@ -26918,9 +27593,9 @@ function createRotatingFileSink(path10, maxBytes, opts = {}) {
   };
   const rotate = () => {
     try {
-      renameSync2(path10, `${path10}.1`);
+      renameSync2(path14, `${path14}.1`);
       if (opts.mode !== undefined)
-        chmodSync(`${path10}.1`, opts.mode);
+        chmodSync(`${path14}.1`, opts.mode);
       return true;
     } catch (error51) {
       report("rotate", error51);
@@ -26929,7 +27604,7 @@ function createRotatingFileSink(path10, maxBytes, opts = {}) {
   };
   const currentSize = () => {
     try {
-      return existsSync6(path10) ? statSync(path10).size : 0;
+      return existsSync6(path14) ? statSync(path14).size : 0;
     } catch (error51) {
       report("stat", error51);
       return null;
@@ -26937,7 +27612,7 @@ function createRotatingFileSink(path10, maxBytes, opts = {}) {
   };
   const sink = {
     secure() {
-      return secureGeneration(`${path10}.1`) && secureGeneration(path10);
+      return secureGeneration(`${path14}.1`) && secureGeneration(path14);
     },
     write(line) {
       try {
@@ -26957,7 +27632,7 @@ function createRotatingFileSink(path10, maxBytes, opts = {}) {
         const shouldRotate = maxBytes > 0 && (opts.hardMaxBytes ? currentBytes > 0 && currentBytes + serializedBytes > maxBytes : currentBytes >= maxBytes);
         if (shouldRotate && !rotate() && opts.hardMaxBytes)
           return;
-        appendFileSync(path10, serialized, opts.mode === undefined ? undefined : { mode: opts.mode });
+        appendFileSync(path14, serialized, opts.mode === undefined ? undefined : { mode: opts.mode });
       } catch (error51) {
         report("append", error51);
       }
@@ -26965,7 +27640,7 @@ function createRotatingFileSink(path10, maxBytes, opts = {}) {
     openSnapshot() {
       const files = [];
       try {
-        for (const candidate of [`${path10}.1`, path10]) {
+        for (const candidate of [`${path14}.1`, path14]) {
           if (!existsSync6(candidate))
             continue;
           if (!secureGeneration(candidate))
@@ -26973,10 +27648,10 @@ function createRotatingFileSink(path10, maxBytes, opts = {}) {
           const noFollow = "O_NOFOLLOW" in constants ? constants.O_NOFOLLOW : 0;
           const fd = openSync(candidate, constants.O_RDONLY | noFollow);
           try {
-            const stat = fstatSync(fd);
-            if (!stat.isFile())
+            const stat2 = fstatSync(fd);
+            if (!stat2.isFile())
               throw new Error("snapshot source is not a regular file");
-            files.push({ path: candidate, fd, size: stat.size });
+            files.push({ path: candidate, fd, size: stat2.size });
           } catch (error51) {
             closeSync(fd);
             throw error51;
@@ -27126,11 +27801,11 @@ function createTraceSampler(emit, throttleMs = DEFAULT_TRACE_SAMPLE_MS) {
 
 // src/util/statusFile.ts
 import { writeFileSync as writeFileSync4, renameSync as renameSync3 } from "node:fs";
-function writeStatusFile(path10, snapshot) {
+function writeStatusFile(path14, snapshot) {
   try {
-    const tmp = `${path10}.tmp`;
+    const tmp = `${path14}.tmp`;
     writeFileSync4(tmp, JSON.stringify(snapshot));
-    renameSync3(tmp, path10);
+    renameSync3(tmp, path14);
   } catch {}
 }
 
@@ -27812,7 +28487,7 @@ import * as fs7 from "fs";
 import * as http from "http";
 import * as https from "https";
 import * as os2 from "os";
-import * as path10 from "path";
+import * as path14 from "path";
 import { URL as URL2 } from "url";
 var LOCAL_MESSAGE_REMINDER_PATH = "/__alook/local/message-reminder";
 var LOCAL_MESSAGE_REMINDER_BODY_MAX_BYTES = 4 * 1024;
@@ -27844,15 +28519,15 @@ class CredentialBroker {
     this.voucherPrefix = config2.voucherPrefix ?? "vch_";
     this.clientLabel = config2.clientLabel ?? "cli";
     this.headerNames = config2.headerNames ?? DEFAULT_HEADER_NAMES;
-    this.voucherDir = config2.voucherDir ?? path10.join(os2.tmpdir(), "agent-vouchers");
+    this.voucherDir = config2.voucherDir ?? path14.join(os2.tmpdir(), "agent-vouchers");
   }
   mint(agentId, launchId, capabilities2, runnerKey) {
     if (!runnerKey)
       throw new Error("CredentialBroker.mint: runnerKey is required (per-agent tier-2 credential)");
     const voucher = randomVoucher(this.voucherPrefix);
-    const dir = path10.join(this.voucherDir, sanitizeIdSegment(agentId));
+    const dir = path14.join(this.voucherDir, sanitizeIdSegment(agentId));
     fs7.mkdirSync(dir, { recursive: true });
-    const voucherFile = path10.join(dir, `${sanitizeIdSegment(launchId)}.token`);
+    const voucherFile = path14.join(dir, `${sanitizeIdSegment(launchId)}.token`);
     fs7.writeFileSync(voucherFile, voucher, { mode: 384 });
     this.registrations.set(voucher, {
       agentId,
@@ -28920,7 +29595,7 @@ function runtimeModelName(config2) {
 // agent-driver/dist/provider-quota.js
 import { execFile } from "node:child_process";
 import { readFile } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
+import { homedir as homedir5 } from "node:os";
 import { join as join11 } from "node:path";
 import { promisify } from "node:util";
 import { randomBytes as randomBytes5 } from "node:crypto";
@@ -28949,7 +29624,7 @@ async function claudeCredentials(options) {
     } catch {}
   }
   const env = options.env ?? process.env;
-  const root = env.CLAUDE_CONFIG_DIR || join11(options.home ?? homedir3(), ".claude");
+  const root = env.CLAUDE_CONFIG_DIR || join11(options.home ?? homedir5(), ".claude");
   try {
     const value = options.readCredentialsFile ? await options.readCredentialsFile(join11(root, ".credentials.json")) : await readFile(join11(root, ".credentials.json"), "utf8");
     return parseCredentials(value);
@@ -30305,6 +30980,10 @@ ${this.opts.wakePromptFooter}` : text2;
             sent = session2.send(input);
             if (exactOwner)
               this.markPendingDeliveryObserved(exactOwner, input.id);
+            this.log.info("steering message submitted to logical session", {
+              agentId: effect.agentId,
+              mode: effect.mode
+            });
           } catch (error51) {
             if (exactOwner) {
               this.settlePendingDelivery(exactOwner, input.id);
@@ -30350,7 +31029,6 @@ ${this.opts.wakePromptFooter}` : text2;
             mode: effect.mode
           });
         }
-        this.log.info("steering message sent to running agent", { agentId: effect.agentId, mode: effect.mode });
         break;
       }
       case "stop":
@@ -31396,6 +32074,26 @@ class AgentRouter {
           return;
         }
         break;
+      case "agent:event":
+        this.log.info("agent:event received", { agentId: cmd.agentId });
+        try {
+          await this.opts.onBeforeAgent?.(cmd.agentId);
+          this.opts.manager.register(cmd.agentId, {
+            runtimeConfig: cmd.config,
+            launchId: cmd.launchId
+          });
+          this.running.add(cmd.agentId);
+          this.opts.manager.deliver(cmd.agentId, {
+            id: `${cmd.agentId}:event:${cmd.launchId}`,
+            text: cmd.prompt
+          });
+        } catch (err) {
+          this.log.warn("agent:event failed", {
+            agentId: cmd.agentId,
+            err: err instanceof Error ? err.message : String(err)
+          });
+        }
+        break;
       case "agent:reset":
         await this.runRestartCommand(cmd.agentId, cmd.launchId, "agent:reset", () => this.opts.manager.resetSession(cmd.agentId, {
           runtimeConfig: cmd.config,
@@ -31626,11 +32324,11 @@ function timelineRowHash(line) {
 }
 function timelineFileGeneration(filePath, lines) {
   try {
-    const stat = fs9.lstatSync(filePath, { bigint: true });
-    if (!stat.isFile())
+    const stat2 = fs9.lstatSync(filePath, { bigint: true });
+    if (!stat2.isFile())
       return null;
     const digest = createHash2("sha256");
-    digest.update(`${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}
+    digest.update(`${stat2.dev}:${stat2.ino}:${stat2.size}:${stat2.mtimeNs}:${stat2.ctimeNs}
 `);
     for (const line of lines)
       digest.update(line.text, "utf8").update(`
@@ -31688,9 +32386,9 @@ function compactLines(input) {
   }
   return suffix;
 }
-function isRealDirectory(path11) {
+function isRealDirectory(path15) {
   try {
-    return fs9.lstatSync(path11).isDirectory();
+    return fs9.lstatSync(path15).isDirectory();
   } catch {
     return false;
   }
@@ -31730,8 +32428,8 @@ function scanTimelineFile(filePath) {
   let fd = null;
   try {
     fd = fs9.openSync(filePath, fs9.constants.O_RDONLY | (fs9.constants.O_NOFOLLOW ?? 0));
-    const stat = fs9.fstatSync(fd);
-    if (!stat.isFile())
+    const stat2 = fs9.fstatSync(fd);
+    if (!stat2.isFile())
       return null;
     const chunk2 = Buffer.allocUnsafe(TIMELINE_READ_CHUNK_BYTES);
     const newest = [];
@@ -31744,9 +32442,9 @@ function scanTimelineFile(filePath) {
     let oversized = false;
     let stop = false;
     let discardIncompleteTail = false;
-    if (stat.size > 0) {
+    if (stat2.size > 0) {
       const last = Buffer.allocUnsafe(1);
-      fs9.readSync(fd, last, 0, 1, stat.size - 1);
+      fs9.readSync(fd, last, 0, 1, stat2.size - 1);
       discardIncompleteTail = last[0] !== 10;
     }
     const resetPhysicalLine = () => {
@@ -31805,7 +32503,7 @@ function scanTimelineFile(filePath) {
       }
       resetPhysicalLine();
     };
-    let position = stat.size;
+    let position = stat2.size;
     while (position > 0 && !stop) {
       const start = Math.max(0, position - chunk2.length);
       const requested = position - start;
@@ -31957,11 +32655,11 @@ function readResumeControlState(timelineDir) {
   let fd = null;
   try {
     fd = fs9.openSync(filePath, fs9.constants.O_RDONLY | (fs9.constants.O_NOFOLLOW ?? 0));
-    const stat = fs9.fstatSync(fd);
-    if (!stat.isFile() || stat.size <= 0 || stat.size > RESUME_CONTROL_MAX_BYTES) {
+    const stat2 = fs9.fstatSync(fd);
+    if (!stat2.isFile() || stat2.size <= 0 || stat2.size > RESUME_CONTROL_MAX_BYTES) {
       return { kind: "invalid" };
     }
-    const bounded = Buffer.allocUnsafe(stat.size + 1);
+    const bounded = Buffer.allocUnsafe(stat2.size + 1);
     let bytesRead = 0;
     while (bytesRead < bounded.length) {
       const count = fs9.readSync(fd, bounded, bytesRead, bounded.length - bytesRead, bytesRead);
@@ -31969,7 +32667,7 @@ function readResumeControlState(timelineDir) {
         break;
       bytesRead += count;
     }
-    if (bytesRead !== stat.size)
+    if (bytesRead !== stat2.size)
       return { kind: "invalid" };
     const raw = bounded.subarray(0, bytesRead).toString("utf8");
     const value = JSON.parse(raw);
@@ -32895,7 +33593,7 @@ class MessageReminderScheduler {
 
 // src/manager/agentDriverHost.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
-import { homedir as homedir4 } from "node:os";
+import { homedir as homedir6 } from "node:os";
 import { join as join13 } from "node:path";
 
 // src/drivers/gitIdentityEnv.ts
@@ -33021,7 +33719,7 @@ function createDaemonAgentDriverHost(ctx, onRawLine) {
             hostUser: readHostGitIdentity() ?? undefined
           }),
           platformProtected: {
-            ALOOK_HOME: process.env.ALOOK_HOME ?? join13(homedir4(), ".alook"),
+            ALOOK_HOME: process.env.ALOOK_HOME ?? join13(homedir6(), ".alook"),
             ALOOK_ID: ctx.agentId,
             ALOOK_CLI: ctx.agentCliPath,
             ALOOK_SERVER_URL: ctx.config.serverUrl,
@@ -33342,13 +34040,13 @@ function createRuntimeRawLineTap(args) {
   const maxBytes = args.maxBytes ?? RUNTIME_RAW_TRACE_MAX_BYTES;
   const sinks = new Map;
   const warned = new Set;
-  const warnOnce = (agentId, path11, operation, error51) => {
+  const warnOnce = (agentId, path15, operation, error51) => {
     if (warned.has(agentId))
       return;
     warned.add(agentId);
     args.logger.warn("runtime raw trace sink failed", {
       agentId,
-      path: path11,
+      path: path15,
       operation,
       error: error51 instanceof Error ? error51.message : String(error51)
     });
@@ -33357,10 +34055,10 @@ function createRuntimeRawLineTap(args) {
     if (!args.enabledAgentIds.has(agentId))
       return;
     const encodedAgentId = encodeURIComponent(agentId).replace(/\./g, "%2E");
-    const path11 = `${traceDir}/runtime-raw-events-${encodedAgentId}.jsonl`;
+    const path15 = `${traceDir}/runtime-raw-events-${encodedAgentId}.jsonl`;
     const serializedBytes = Buffer.byteLength(line, "utf8") + 1;
     if (serializedBytes > maxBytes) {
-      warnOnce(agentId, path11, "oversize", new Error(`raw line is ${serializedBytes} bytes; max is ${maxBytes}`));
+      warnOnce(agentId, path15, "oversize", new Error(`raw line is ${serializedBytes} bytes; max is ${maxBytes}`));
       return;
     }
     let sink = sinks.get(agentId);
@@ -33368,12 +34066,12 @@ function createRuntimeRawLineTap(args) {
       try {
         mkdirSync8(traceDir, { recursive: true });
       } catch (error51) {
-        warnOnce(agentId, path11, "mkdir", error51);
+        warnOnce(agentId, path15, "mkdir", error51);
       }
-      sink = createRotatingFileSink(path11, maxBytes, {
+      sink = createRotatingFileSink(path15, maxBytes, {
         mode: 384,
         hardMaxBytes: true,
-        onError: ({ operation, error: error51 }) => warnOnce(agentId, path11, operation, error51)
+        onError: ({ operation, error: error51 }) => warnOnce(agentId, path15, operation, error51)
       });
       sinks.set(agentId, sink);
     }
@@ -33465,7 +34163,7 @@ function createBuiltinDaemonSessionFactory(onRuntimeRawLine) {
 }
 async function createDaemon(opts) {
   const log2 = opts.logger ?? createLogger2({ header: "@alook/daemon" });
-  const fallbackBase = (process.env.ALOOK_PROJECT_ROOT || `${homedir5()}/.alook`) + "/daemon";
+  const fallbackBase = (process.env.ALOOK_PROJECT_ROOT || `${homedir7()}/.alook`) + "/daemon";
   const workingDirectoryBase = opts.workingDirectoryBase ?? fallbackBase;
   const workdirFor = (agentId) => `${workingDirectoryBase}/${agentId}`;
   const dailyTokenUsage2 = new DailyTokenUsageStore(workingDirectoryBase);
@@ -34171,12 +34869,12 @@ async function readPinnedJsonFile(args) {
       }
     }
     fd = openSync3(args.path, constants3.O_RDONLY | noFollow);
-    const stat = fstatSync3(fd);
-    if (!stat.isFile())
+    const stat2 = fstatSync3(fd);
+    if (!stat2.isFile())
       return { value: null, warnings: ["source_unavailable"] };
-    if (stat.size > args.maxBytes)
+    if (stat2.size > args.maxBytes)
       return { value: null, warnings: ["line_too_long"] };
-    const bytes = readPinnedBytes(fd, stat.size);
+    const bytes = readPinnedBytes(fd, stat2.size);
     try {
       return { value: JSON.parse(bytes.toString("utf8")), warnings: [] };
     } catch {
@@ -34254,7 +34952,7 @@ var DAEMON_LOG_DIAGNOSTIC_POLICY = [
     reason: string5(32, { values: ["turn_end", "stopped", "terminate_stalled", "exit"] }),
     sessionId: string5(256, { scrub: true })
   } },
-  { header: "@alook/daemon:manager", message: "steering message sent to running agent", scope: "target", fields: {
+  { header: "@alook/daemon:manager", message: "steering message submitted to logical session", scope: "target", fields: {
     agentId: AGENT,
     mode: string5(8, { values: ["busy", "idle"] })
   } },
@@ -34809,7 +35507,7 @@ import { createHash as createHash4, randomBytes as randomBytes7 } from "node:cry
 import {
   chmodSync as chmodSync2,
   closeSync as closeSync4,
-  createReadStream,
+  createReadStream as createReadStream3,
   existsSync as existsSync7,
   fsyncSync as fsyncSync2,
   lstatSync as lstatSync5,
@@ -34832,7 +35530,7 @@ class CoordinatorError extends Error {
 function defaultFsOps() {
   return {
     randomSuffix: () => randomBytes7(12).toString("hex"),
-    open: (path11, flags, mode) => openSync4(path11, flags, mode),
+    open: (path15, flags, mode) => openSync4(path15, flags, mode),
     write: (fd, bytes) => {
       writeSync(fd, bytes);
     },
@@ -34845,10 +35543,10 @@ function defaultFsOps() {
     rename: (from, to) => {
       renameSync5(from, to);
     },
-    fsyncDirectory: (path11) => {
+    fsyncDirectory: (path15) => {
       if (process.platform === "win32")
         return;
-      const fd = openSync4(path11, "r");
+      const fd = openSync4(path15, "r");
       try {
         fsyncSync2(fd);
       } finally {
@@ -34899,8 +35597,8 @@ function createDiagnosticReportCoordinator(args) {
   const sidecarPath = (reportId) => join15(dir, `report-${reportId}.json`);
   const ensureDir = () => {
     if (existsSync7(dir)) {
-      const stat = lstatSync5(dir);
-      if (!stat.isDirectory() || stat.isSymbolicLink())
+      const stat2 = lstatSync5(dir);
+      if (!stat2.isDirectory() || stat2.isSymbolicLink())
         throw new CoordinatorError("local_artifact_invalid");
       if (process.platform !== "win32")
         chmodSync2(dir, 448);
@@ -34913,11 +35611,11 @@ function createDiagnosticReportCoordinator(args) {
       args.logger?.warn("diagnostic local artifact invalid", { reportId, code: "local_artifact_invalid" });
     } catch {}
   };
-  const removeExact = (path11) => {
+  const removeExact = (path15) => {
     try {
-      const stat = lstatSync5(path11);
-      if (stat.isFile() && !stat.isSymbolicLink())
-        unlinkSync6(path11);
+      const stat2 = lstatSync5(path15);
+      if (stat2.isFile() && !stat2.isSymbolicLink())
+        unlinkSync6(path15);
     } catch {}
   };
   const cleanup = (reportId) => {
@@ -34955,12 +35653,12 @@ function createDiagnosticReportCoordinator(args) {
     checkpoint(sidecar.phase === "collecting" ? "collecting_dir_fsynced" : "ready_dir_fsynced");
   };
   const committedArchive = (reportId) => {
-    const path11 = archivePath(reportId);
+    const path15 = archivePath(reportId);
     try {
-      const stat = lstatSync5(path11);
-      if (!stat.isFile() || stat.isSymbolicLink())
+      const stat2 = lstatSync5(path15);
+      if (!stat2.isFile() || stat2.isSymbolicLink())
         return null;
-      const bytes = readFileSync6(path11);
+      const bytes = readFileSync6(path15);
       return { sizeBytes: bytes.byteLength, sha256: createHash4("sha256").update(bytes).digest("hex") };
     } catch {
       return null;
@@ -35021,7 +35719,7 @@ function createDiagnosticReportCoordinator(args) {
       if (stopped)
         throw new CoordinatorError("coordinator_shutdown");
       checkpoint("before_upload");
-      const result = await args.transport.upload({ reportId: sidecar.reportId, sizeBytes: sidecar.sizeBytes, sha256: sidecar.sha256 }, createReadStream(archivePath(sidecar.reportId)));
+      const result = await args.transport.upload({ reportId: sidecar.reportId, sizeBytes: sidecar.sizeBytes, sha256: sidecar.sha256 }, createReadStream3(archivePath(sidecar.reportId)));
       checkpoint("after_upload");
       if (result.kind === "terminal") {
         cleanup(sidecar.reportId);
@@ -35085,12 +35783,12 @@ function createDiagnosticReportCoordinator(args) {
     return uploadReady(ready);
   };
   const readSidecar = (reportId) => {
-    const path11 = sidecarPath(reportId);
+    const path15 = sidecarPath(reportId);
     try {
-      const stat = lstatSync5(path11);
-      if (!stat.isFile() || stat.isSymbolicLink())
+      const stat2 = lstatSync5(path15);
+      if (!stat2.isFile() || stat2.isSymbolicLink())
         return null;
-      return parseSidecar(JSON.parse(readFileSync6(path11, "utf8")));
+      return parseSidecar(JSON.parse(readFileSync6(path15, "utf8")));
     } catch {
       return null;
     }
@@ -35178,9 +35876,9 @@ function createDiagnosticReportCoordinator(args) {
 }
 // src/diagnostics/httpTransport.ts
 import { Readable as Readable2 } from "node:stream";
-function endpoint(serverUrl, path11) {
+function endpoint(serverUrl, path15) {
   const base = serverUrl.endsWith("/") ? serverUrl : `${serverUrl}/`;
-  return new URL(path11.replace(/^\//, ""), base).toString();
+  return new URL(path15.replace(/^\//, ""), base).toString();
 }
 async function strictOutcome(response, allowed) {
   try {
@@ -35244,29 +35942,29 @@ function createDiagnosticHttpTransport(args) {
 // src/cli/daemonUpdate.ts
 import * as crypto4 from "node:crypto";
 import * as fs10 from "node:fs";
-import * as path11 from "node:path";
+import * as path15 from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 var UPDATE_INTENT_SCHEMA_VERSION = 1;
 var UPDATE_LOG_MAX_BYTES = 512 * 1024;
 var UPDATE_LOG_KEEP_BYTES = 256 * 1024;
 var REQUEST_ID_PATTERN = /^[A-Za-z0-9_-]{16,128}$/;
 function intentPath(baseDir, machineId) {
-  return path11.join(daemonDirById(baseDir, machineId), "update-intent.json");
+  return path15.join(daemonDirById(baseDir, machineId), "update-intent.json");
 }
 function updateLogPath(baseDir, machineId) {
-  return path11.join(daemonDirById(baseDir, machineId), "update.log");
+  return path15.join(daemonDirById(baseDir, machineId), "update.log");
 }
 function updatePackageMapPath(baseDir, machineId) {
-  return path11.join(daemonDirById(baseDir, machineId), "update-package-map.json");
+  return path15.join(daemonDirById(baseDir, machineId), "update-package-map.json");
 }
 function ensurePrivateDir(dir) {
   fs10.mkdirSync(dir, { recursive: true, mode: 448 });
   fs10.chmodSync(dir, 448);
 }
 function writePrivateJsonAtomic(filePath, value) {
-  const dir = path11.dirname(filePath);
+  const dir = path15.dirname(filePath);
   ensurePrivateDir(dir);
-  const tempPath = path11.join(dir, `.${path11.basename(filePath)}.${process.pid}.${crypto4.randomBytes(8).toString("hex")}.tmp`);
+  const tempPath = path15.join(dir, `.${path15.basename(filePath)}.${process.pid}.${crypto4.randomBytes(8).toString("hex")}.tmp`);
   let fd = fs10.openSync(tempPath, "wx", 384);
   try {
     fs10.writeFileSync(fd, JSON.stringify(value));
@@ -35291,7 +35989,7 @@ function scrub(value) {
 }
 function appendUpdateLog(baseDir, machineId, event, fields = {}) {
   const filePath = updateLogPath(baseDir, machineId);
-  ensurePrivateDir(path11.dirname(filePath));
+  ensurePrivateDir(path15.dirname(filePath));
   try {
     if (fs10.existsSync(filePath) && fs10.statSync(filePath).size > UPDATE_LOG_MAX_BYTES) {
       const data = fs10.readFileSync(filePath);
@@ -35318,8 +36016,8 @@ function tuplesEqual(value, expected) {
 }
 function readIntent(baseDir, machineId) {
   const filePath = intentPath(baseDir, machineId);
-  const stat = fs10.lstatSync(filePath);
-  if (!stat.isFile())
+  const stat2 = fs10.lstatSync(filePath);
+  if (!stat2.isFile())
     throw new Error("unsafe daemon update intent type");
   fs10.chmodSync(filePath, 384);
   const value = JSON.parse(fs10.readFileSync(filePath, "utf8"));
@@ -35334,12 +36032,81 @@ function removeIntentIfMatches(baseDir, machineId, requestId) {
       fs10.unlinkSync(intentPath(baseDir, machineId));
   } catch {}
 }
-function npmExecPath(explicit) {
-  const value = explicit ?? process.env.npm_execpath;
-  if (!value || !path11.isAbsolute(value) || !fs10.existsSync(value)) {
-    throw new Error("npm launch context unavailable; daemon remains online");
+var defaultNpmLaunchFileProbe = {
+  isFile(filePath) {
+    try {
+      return fs10.statSync(filePath).isFile();
+    } catch {
+      return false;
+    }
+  },
+  isExecutable(filePath) {
+    try {
+      fs10.accessSync(filePath, fs10.constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
   }
-  return value;
+};
+function pathEnvironment(env, platform) {
+  if (platform !== "win32")
+    return env.PATH;
+  const entry = Object.entries(env).find(([key]) => key.toLowerCase() === "path");
+  return entry?.[1];
+}
+function launchFromNpmPath(args) {
+  const pathApi = args.platform === "win32" ? path15.win32 : path15.posix;
+  if (!pathApi.isAbsolute(args.npmPath) || !args.probe.isFile(args.npmPath))
+    return null;
+  const extension = pathApi.extname(args.npmPath).toLowerCase();
+  if ([".js", ".cjs", ".mjs"].includes(extension)) {
+    return { file: args.nodePath, prefixArgs: [args.npmPath] };
+  }
+  if (args.platform === "win32" && [".cmd", ".bat"].includes(extension)) {
+    const cliPath = pathApi.join(pathApi.dirname(args.npmPath), "node_modules", "npm", "bin", "npm-cli.js");
+    return args.probe.isFile(cliPath) ? { file: args.nodePath, prefixArgs: [cliPath] } : null;
+  }
+  if (args.requireExecutable && !args.probe.isExecutable(args.npmPath))
+    return null;
+  return { file: args.npmPath, prefixArgs: [] };
+}
+function resolveNpmLaunchCommand(options = {}) {
+  const env = options.env ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const nodePath = options.nodePath ?? process.execPath;
+  const probe = options.probe ?? defaultNpmLaunchFileProbe;
+  const inherited = options.npmExecPath ?? env.npm_execpath;
+  if (inherited) {
+    const launch = launchFromNpmPath({
+      npmPath: inherited,
+      platform,
+      nodePath,
+      probe,
+      requireExecutable: platform !== "win32"
+    });
+    if (launch)
+      return launch;
+  }
+  const pathApi = platform === "win32" ? path15.win32 : path15.posix;
+  const names = platform === "win32" ? ["npm.exe", "npm.cmd", "npm.bat", "npm"] : ["npm"];
+  const pathValue = pathEnvironment(env, platform);
+  for (const directory of pathValue?.split(pathApi.delimiter) ?? []) {
+    if (!directory || !pathApi.isAbsolute(directory))
+      continue;
+    for (const name of names) {
+      const launch = launchFromNpmPath({
+        npmPath: pathApi.join(directory, name),
+        platform,
+        nodePath,
+        probe,
+        requireExecutable: platform !== "win32"
+      });
+      if (launch)
+        return launch;
+    }
+  }
+  throw new Error("npm launch context unavailable and no safe npm executable was found on PATH; daemon remains online");
 }
 function readTestPackageMap(baseDir, machineId) {
   if (true)
@@ -35347,10 +36114,10 @@ function readTestPackageMap(baseDir, machineId) {
   const filePath = updatePackageMapPath(baseDir, machineId);
   if (!fs10.existsSync(filePath))
     return null;
-  const stat = fs10.lstatSync(filePath);
-  if (!stat.isFile())
+  const stat2 = fs10.lstatSync(filePath);
+  if (!stat2.isFile())
     throw new Error("unsafe daemon update package map type");
-  if (process.platform !== "win32" && (stat.mode & 63) !== 0) {
+  if (process.platform !== "win32" && (stat2.mode & 63) !== 0) {
     throw new Error("daemon update package map must be mode 0600");
   }
   const parsed = JSON.parse(fs10.readFileSync(filePath, "utf8"));
@@ -35360,7 +36127,7 @@ function readTestPackageMap(baseDir, machineId) {
   for (const [key, value] of Object.entries(parsed)) {
     if (key !== "latest" && !parseReleaseVersion(key))
       throw new Error("invalid daemon update package map key");
-    if (typeof value !== "string" || !path11.isAbsolute(value))
+    if (typeof value !== "string" || !path15.isAbsolute(value))
       throw new Error("invalid daemon update package map value");
     result[key] = value;
   }
@@ -35374,9 +36141,9 @@ function packageSpec(baseDir, machineId, version3) {
 }
 function fixedNpmArgs(args) {
   return [
-    args.npmPath,
     "exec",
     "--yes",
+    "--no-audit",
     `--package=${args.packageSpec}`,
     "--",
     "alook-daemon",
@@ -35407,7 +36174,13 @@ function createDaemonSelfUpdateHandler(context, deps = {}) {
       const current = pidTuple(readPidFile(pidfilePathById(context.baseDir, context.machineId)));
       if (!current || current.pid !== context.pid || current.machineId !== context.machineId || current.startedAt !== context.startedAt || current.ownerToken !== context.ownerToken)
         throw new Error("daemon ownership changed before update launch");
-      const npmPath = npmExecPath(deps.npmExecPath);
+      const npmLaunch = resolveNpmLaunchCommand({
+        npmExecPath: deps.npmExecPath,
+        env: deps.npmLaunchEnv,
+        platform: deps.npmLaunchPlatform,
+        nodePath: deps.npmLaunchNodePath,
+        probe: deps.npmLaunchFileProbe
+      });
       requestId = crypto4.randomUUID();
       const intent = {
         schemaVersion: UPDATE_INTENT_SCHEMA_VERSION,
@@ -35417,14 +36190,16 @@ function createDaemonSelfUpdateHandler(context, deps = {}) {
       writePrivateJsonAtomic(intentPath(context.baseDir, context.machineId), intent);
       const logFd = openUpdateLog(context.baseDir, context.machineId);
       try {
-        const child = (deps.spawnProcess ?? spawn2)(process.execPath, fixedNpmArgs({
-          npmPath,
-          packageSpec: packageSpec(context.baseDir, context.machineId, "latest"),
-          command: "replace",
-          machineId: context.machineId,
-          baseDir: context.baseDir,
-          requestId
-        }), {
+        const child = (deps.spawnProcess ?? spawn2)(npmLaunch.file, [
+          ...npmLaunch.prefixArgs,
+          ...fixedNpmArgs({
+            packageSpec: packageSpec(context.baseDir, context.machineId, "latest"),
+            command: "replace",
+            machineId: context.machineId,
+            baseDir: context.baseDir,
+            requestId
+          })
+        ], {
           detached: true,
           shell: false,
           stdio: ["ignore", logFd, logFd]
@@ -35465,14 +36240,16 @@ function removeOldPidfileIfMatches(baseDir, intent) {
 async function runPinnedResume(args) {
   const fd = openUpdateLog(args.baseDir, args.machineId);
   try {
-    const child = spawn2(process.execPath, fixedNpmArgs({
-      npmPath: args.npmPath,
-      packageSpec: packageSpec(args.baseDir, args.machineId, args.version),
-      command: "resume",
-      machineId: args.machineId,
-      baseDir: args.baseDir,
-      requestId: args.requestId
-    }), {
+    const child = spawn2(args.npmLaunch.file, [
+      ...args.npmLaunch.prefixArgs,
+      ...fixedNpmArgs({
+        packageSpec: packageSpec(args.baseDir, args.machineId, args.version),
+        command: "resume",
+        machineId: args.machineId,
+        baseDir: args.baseDir,
+        requestId: args.requestId
+      })
+    ], {
       shell: false,
       stdio: ["ignore", fd, fd]
     });
@@ -35516,7 +36293,7 @@ async function daemonReplace(opts) {
     removeIntentIfMatches(baseDir, opts.id, opts.requestId);
     throw new Error("daemon ownership changed before replacement");
   }
-  const npmPath = npmExecPath();
+  const npmLaunch = resolveNpmLaunchCommand();
   const acquired = acquireDaemonReplacementLock({ baseDir, machineId: opts.id, requestId: opts.requestId });
   let oldStopped = false;
   try {
@@ -35536,7 +36313,7 @@ async function daemonReplace(opts) {
     } catch (error51) {
       appendUpdateLog(baseDir, opts.id, "replacement_start_failed", { error: error51 });
       await runPinnedResume({
-        npmPath,
+        npmLaunch,
         version: launch.daemonVersion,
         machineId: opts.id,
         baseDir,
@@ -35659,7 +36436,7 @@ async function buildRunnerDiagnosticBundle(args) {
 function createDaemonProcessLogger(daemonDir, foreground) {
   fs11.mkdirSync(daemonDir, { recursive: true, mode: 448 });
   fs11.chmodSync(daemonDir, 448);
-  const logPath = path12.join(daemonDir, "daemon.log");
+  const logPath = path16.join(daemonDir, "daemon.log");
   let warnedOversize = false;
   const sink = createRotatingFileSink(logPath, DAEMON_LOG_MAX_BYTES, {
     mode: 384,
@@ -35895,16 +36672,16 @@ var LEGACY_DAEMON_ID_PATTERN = /^[a-f0-9]{12}$/;
 var DEFAULT_SERVER_URL = "https://alook.ai";
 var DEFAULT_WS_URL = "wss://alook.ai/api/ws/community-daemon";
 function resolveDefaultBaseDir() {
-  const root = process.env.ALOOK_PROJECT_ROOT || path13.join(homedir6(), ".alook");
-  return path13.join(root, "daemon");
+  const root = process.env.ALOOK_PROJECT_ROOT || path17.join(homedir8(), ".alook");
+  return path17.join(root, "daemon");
 }
 var DEFAULT_BASE_DIR = resolveDefaultBaseDir();
 var log2 = createLogger2({ header: "@alook/daemon" });
 function daemonsDir(baseDir) {
-  return path13.join(baseDir, "daemons");
+  return path17.join(baseDir, "daemons");
 }
 function daemonDirById(baseDir, id) {
-  return path13.join(daemonsDir(baseDir), validateDaemonId(id));
+  return path17.join(daemonsDir(baseDir), validateDaemonId(id));
 }
 function validateMachineId(machineId) {
   if (!MACHINE_ID_PATTERN.test(machineId))
@@ -35920,10 +36697,10 @@ function validateDaemonId(id) {
   return id;
 }
 function pidfilePathById(baseDir, id) {
-  return path13.join(daemonDirById(baseDir, id), "daemon.pid");
+  return path17.join(daemonDirById(baseDir, id), "daemon.pid");
 }
 function statusFilePathById(baseDir, id) {
-  return path13.join(daemonDirById(baseDir, id), "status.json");
+  return path17.join(daemonDirById(baseDir, id), "status.json");
 }
 function isProcessAlive(pid) {
   try {
@@ -35983,9 +36760,9 @@ function syncDirectory(dir) {
   }
 }
 function writeExclusive(filePath, value) {
-  const dir = path13.dirname(filePath);
+  const dir = path17.dirname(filePath);
   ensurePrivateDir2(dir);
-  const tempPath = path13.join(dir, `.${path13.basename(filePath)}.${process.pid}.${crypto5.randomBytes(12).toString("hex")}.tmp`);
+  const tempPath = path17.join(dir, `.${path17.basename(filePath)}.${process.pid}.${crypto5.randomBytes(12).toString("hex")}.tmp`);
   let fd = fs12.openSync(tempPath, "wx", 384);
   try {
     fs12.writeFileSync(fd, JSON.stringify(value));
@@ -36007,9 +36784,9 @@ function writeExclusive(filePath, value) {
   }
 }
 function writePrivateJsonAtomic2(filePath, value) {
-  const dir = path13.dirname(filePath);
+  const dir = path17.dirname(filePath);
   ensurePrivateDir2(dir);
-  const tempPath = path13.join(dir, `.${path13.basename(filePath)}.${process.pid}.${crypto5.randomBytes(12).toString("hex")}.tmp`);
+  const tempPath = path17.join(dir, `.${path17.basename(filePath)}.${process.pid}.${crypto5.randomBytes(12).toString("hex")}.tmp`);
   let fd = fs12.openSync(tempPath, "wx", 384);
   try {
     fs12.writeFileSync(fd, JSON.stringify(value));
@@ -36033,8 +36810,8 @@ function writePrivateJsonAtomic2(filePath, value) {
 function secureExistingFile(filePath) {
   if (!fs12.existsSync(filePath))
     return;
-  const stat = fs12.lstatSync(filePath);
-  if (!stat.isFile())
+  const stat2 = fs12.lstatSync(filePath);
+  if (!stat2.isFile())
     throw new Error("unsafe daemon ownership file type");
   fs12.chmodSync(filePath, 384);
 }
@@ -36096,14 +36873,14 @@ function clearStaleOwnership(filePath, liveError) {
   } catch {}
 }
 function replacementLockPathById(baseDir, machineId) {
-  return path13.join(daemonDirById(baseDir, machineId), "daemon.replace.lock");
+  return path17.join(daemonDirById(baseDir, machineId), "daemon.replace.lock");
 }
 function readReplacementLock(filePath) {
   if (!fs12.existsSync(filePath))
     return null;
   try {
-    const stat = fs12.lstatSync(filePath);
-    if (!stat.isFile())
+    const stat2 = fs12.lstatSync(filePath);
+    if (!stat2.isFile())
       throw new Error("unsafe daemon replacement lock type");
     fs12.chmodSync(filePath, 384);
     const content = JSON.parse(fs12.readFileSync(filePath, "utf8"));
@@ -36166,7 +36943,7 @@ function checkReplacementLock(baseDir, machineId, resumeRequestId) {
 }
 function acquireDaemonReplacementLock(args) {
   const lockPath = replacementLockPathById(args.baseDir, args.machineId);
-  ensurePrivateDir2(path13.dirname(lockPath));
+  ensurePrivateDir2(path17.dirname(lockPath));
   checkReplacementLock(args.baseDir, args.machineId);
   const lock = {
     pid: process.pid,
@@ -36179,11 +36956,11 @@ function acquireDaemonReplacementLock(args) {
   return { path: lockPath, lock };
 }
 function coarseStartLockPath(baseDir) {
-  return path13.join(daemonsDir(baseDir), ".start.lock");
+  return path17.join(daemonsDir(baseDir), ".start.lock");
 }
 function acquireCoarseLock(baseDir, ownerToken) {
   const lf = coarseStartLockPath(baseDir);
-  ensurePrivateDir2(path13.dirname(lf));
+  ensurePrivateDir2(path17.dirname(lf));
   secureExistingFile(lf);
   clearStaleOwnership(lf, (pid) => new Error(`another daemon start is in progress on this machine (pid ${pid})`));
   writeExclusive(lf, { pid: process.pid, machineId: "coarse", startedAt: new Date().toISOString(), ownerToken });
@@ -36192,7 +36969,7 @@ function acquireCoarseLock(baseDir, ownerToken) {
 function acquireLaunchLock(baseDir, machineId, ownerToken, resumeRequestId) {
   const daemonDir = daemonDirById(baseDir, machineId);
   ensurePrivateDir2(daemonDir);
-  const lockPath = path13.join(daemonDir, "daemon.launch.lock");
+  const lockPath = path17.join(daemonDir, "daemon.launch.lock");
   const finalPath = pidfilePathById(baseDir, machineId);
   checkReplacementLock(baseDir, machineId, resumeRequestId);
   secureExistingFile(lockPath);
@@ -36214,9 +36991,9 @@ function legacyPidfileCandidates(baseDir) {
   const candidates = [];
   for (const entry of fs12.readdirSync(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
-      candidates.push(path13.join(dir, entry.name, "daemon.pid"));
+      candidates.push(path17.join(dir, entry.name, "daemon.pid"));
     } else if (entry.isFile() && entry.name.endsWith(".pid")) {
-      candidates.push(path13.join(dir, entry.name));
+      candidates.push(path17.join(dir, entry.name));
     }
   }
   return candidates;
@@ -36288,7 +37065,7 @@ function daemonList(opts) {
   for (const entry of fs12.readdirSync(dir, { withFileTypes: true })) {
     if (entry.isDirectory() && isDaemonId(entry.name)) {
       const id = entry.name;
-      pushRow(id, path13.join(dir, id, "daemon.pid"), path13.join(dir, id, "status.json"));
+      pushRow(id, path17.join(dir, id, "daemon.pid"), path17.join(dir, id, "status.json"));
     }
   }
   return results;
@@ -36336,7 +37113,7 @@ function daemonIdsWithStatus(baseDir) {
     return [];
   const ids = [];
   for (const entry of fs12.readdirSync(dir, { withFileTypes: true })) {
-    if (entry.isDirectory() && isDaemonId(entry.name) && fs12.existsSync(path13.join(dir, entry.name, "status.json"))) {
+    if (entry.isDirectory() && isDaemonId(entry.name) && fs12.existsSync(path17.join(dir, entry.name, "status.json"))) {
       ids.push(entry.name);
     }
   }
@@ -36399,16 +37176,16 @@ async function stopByPidfile(pf, notFoundHint) {
 }
 async function daemonStop(opts) {
   const baseDir = opts.baseDir || process.env.ALOOK_DATA_DIR || DEFAULT_BASE_DIR;
-  await stopByPidfile(path13.join(daemonDirById(baseDir, opts.id), "daemon.pid"), `no daemon with id '${opts.id}' (pidfile not found — check \`alook daemon list\`)`);
+  await stopByPidfile(path17.join(daemonDirById(baseDir, opts.id), "daemon.pid"), `no daemon with id '${opts.id}' (pidfile not found — check \`alook daemon list\`)`);
 }
 function credentialFilePathByMachineId(baseDir, machineId) {
-  return path13.join(daemonsDir(baseDir), `${validateMachineId(machineId)}.credential.json`);
+  return path17.join(daemonsDir(baseDir), `${validateMachineId(machineId)}.credential.json`);
 }
 function readCredentialFile(filePath) {
   if (!fs12.existsSync(filePath))
     return null;
-  const stat = fs12.lstatSync(filePath);
-  if (!stat.isFile())
+  const stat2 = fs12.lstatSync(filePath);
+  if (!stat2.isFile())
     throw new Error("unsafe daemon credential file type");
   fs12.chmodSync(filePath, 384);
   try {
@@ -36449,7 +37226,7 @@ function findExistingCredentialForBearer(baseDir, bearer) {
   for (const file2 of fs12.readdirSync(dir)) {
     if (!file2.endsWith(".credential.json"))
       continue;
-    const parsed = readCredentialFile(path13.join(dir, file2));
+    const parsed = readCredentialFile(path17.join(dir, file2));
     if (parsed && parsed.credential === bearer)
       return parsed;
   }
@@ -36730,7 +37507,7 @@ function waitForReceipt(child, prepared) {
     };
     const configuredTestTimeout = NaN;
     const receiptTimeoutMs = Number.isFinite(configuredTestTimeout) && configuredTestTimeout > 0 ? configuredTestTimeout : START_RECEIPT_TIMEOUT_MS;
-    const timeout = setTimeout(() => settle(new Error(`daemon start timed out; inspect ${path13.join(prepared.daemonDir, "daemon.log")}`)), receiptTimeoutMs);
+    const timeout = setTimeout(() => settle(new Error(`daemon start timed out; inspect ${path17.join(prepared.daemonDir, "daemon.log")}`)), receiptTimeoutMs);
     child.on("message", (message2) => {
       const accepted = message2;
       if (accepted.type === "daemon:accepted") {
@@ -36749,7 +37526,7 @@ function waitForReceipt(child, prepared) {
       settle(undefined, receipt);
     });
     child.once("exit", (code, signal) => {
-      settle(new Error(`daemon child exited before ready (${signal ?? code}); inspect ${path13.join(prepared.daemonDir, "daemon.log")}`));
+      settle(new Error(`daemon child exited before ready (${signal ?? code}); inspect ${path17.join(prepared.daemonDir, "daemon.log")}`));
     });
     child.once("error", (error51) => settle(error51));
   });