@alook/daemon 0.1.30 → 0.1.32

package/dist/index.js

@@ -91,6 +91,12 @@ function nanoid3(size = 21) {
 }
 var POOL_SIZE_MULTIPLIER = 128, pool, poolOffset;
 var init_nanoid = () => {};
+
+// agent-driver/dist/contract.js
+var SESSION_FILE_DISCOVERY_CAPABILITIES = ["supported", "unavailable"];
+
+// agent-driver/dist/public-contract.js
+var SESSION_FILE_DISCOVERY_CAPABILITIES2 = SESSION_FILE_DISCOVERY_CAPABILITIES;
 // agent-driver/dist/host/default-host.js
 import { randomUUID } from "node:crypto";
 function createDefaultAgentDriverHost(options = {}) {
@@ -1232,6 +1238,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;
@@ -1730,6 +1742,241 @@ class ClaudeTurnProtocol {
   }
 }
 
+// agent-driver/dist/adapters/claude/recent-context.js
+import { createReadStream as createReadStream2 } from "node:fs";
+import { homedir } from "node:os";
+import path6 from "node:path";
+import { createInterface } from "node:readline";
+
+// agent-driver/dist/internal/recent-context.js
+import path5 from "node:path";
+import { createReadStream } from "node:fs";
+import { readdir, stat } from "node:fs/promises";
+function normalizeAbsolutePath(value) {
+  if (typeof value !== "string" || !path5.isAbsolute(value))
+    return null;
+  return path5.normalize(value);
+}
+function normalizeModifiedAt(value) {
+  const date = value instanceof Date ? value : typeof value === "string" || typeof value === "number" ? new Date(value) : null;
+  if (!date || !Number.isFinite(date.getTime()))
+    return null;
+  return date.toISOString();
+}
+function isValidRecentContextTopK(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+function isMissingPathError(error) {
+  return error?.code === "ENOENT";
+}
+async function readFirstLine(filePath, maxBytes = 65536) {
+  const stream = createReadStream(filePath, { highWaterMark: 1 });
+  const bytes = [];
+  let length = 0;
+  try {
+    for await (const chunk of stream) {
+      const byte = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      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 (error) {
+    if (isMissingPathError(error))
+      return null;
+    throw error;
+  } 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 (error) {
+      if (isMissingPathError(error))
+        return;
+      throw error;
+    }
+    await Promise.all(entries.map(async (entry) => {
+      const entryPath = path5.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 (error) {
+          if (!isMissingPathError(error))
+            throw error;
+        }
+      }
+    }));
+  };
+  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, target = "both") {
+    const projectPath = normalizeAbsolutePath(candidate.projectPath);
+    const modifiedAt = normalizeModifiedAt(candidate.modifiedAt);
+    if (!projectPath || !modifiedAt)
+      return;
+    if (target !== "session") {
+      retainNewest(this.projects, projectPath, { projectPath, modifiedAt }, this.request.recentProjectsTopK);
+    }
+    if (target === "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 record = item;
+      collector.add({
+        sessionFilePath: record.sessionFilePath,
+        projectPath: record.projectPath,
+        modifiedAt: record.modifiedAt
+      }, "session");
+    }
+  }
+  for (const item of candidate.recentProjects) {
+    if (!item || typeof item !== "object" || Array.isArray(item))
+      continue;
+    const record = item;
+    collector.add({ projectPath: record.projectPath, modifiedAt: record.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 record;
+      try {
+        record = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!record || typeof record !== "object")
+        continue;
+      const cwd = record.cwd;
+      if (typeof cwd === "string" && path6.isAbsolute(cwd))
+        return cwd;
+    }
+    return null;
+  } catch (error) {
+    if (isMissingPathError(error))
+      return null;
+    throw error;
+  } finally {
+    lines.close();
+    input.destroy();
+  }
+}
+async function discoverClaudeRecentContext(request, dependencies = {}) {
+  const collector = new RecentContextCollector(request, "supported");
+  if (collector.satisfied)
+    return collector.result();
+  const projectsRoot = path6.resolve(dependencies.projectsRoot ?? path6.join(process.env.CLAUDE_CONFIG_DIR || path6.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",
@@ -1751,6 +1998,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();
@@ -2014,16 +2264,16 @@ function normalizeFileChangeInput(item) {
   for (const candidate of changePaths) {
     if (typeof candidate !== "string")
       continue;
-    const path5 = candidate.trim();
-    if (!path5 || seen.has(path5))
+    const path7 = candidate.trim();
+    if (!path7 || seen.has(path7))
       continue;
-    seen.add(path5);
-    paths.push(path5);
+    seen.add(path7);
+    paths.push(path7);
   }
   if (paths.length === 0 && typeof item?.path === "string") {
-    const path5 = item.path.trim();
-    if (path5)
-      paths.push(path5);
+    const path7 = item.path.trim();
+    if (path7)
+      paths.push(path7);
   }
   return paths.length > 0 ? { path: paths.join(", ") } : {};
 }
@@ -2392,7 +2642,7 @@ class CodexEventNormalizer {
 
 // agent-driver/dist/adapters/codex/home.js
 import * as os from "os";
-import * as path5 from "path";
+import * as path7 from "path";
 function readConfiguredCodexHome(env) {
   const raw = env.CODEX_HOME;
   return typeof raw === "string" && raw.trim().length > 0 ? raw : null;
@@ -2400,8 +2650,8 @@ function readConfiguredCodexHome(env) {
 function resolveCodexHomeRootFromEnv(env = process.env, opts = {}) {
   const raw = readConfiguredCodexHome(env);
   if (raw)
-    return path5.resolve(opts.cwd ?? process.cwd(), raw);
-  return path5.join(opts.defaultHomeDir ?? os.homedir(), ".codex");
+    return path7.resolve(opts.cwd ?? process.cwd(), raw);
+  return path7.join(opts.defaultHomeDir ?? os.homedir(), ".codex");
 }
 
 // agent-driver/dist/internal/errors.js
@@ -2494,6 +2744,49 @@ function parsePiModelCatalog(values) {
   return catalogFromIds(ids);
 }
 
+// agent-driver/dist/adapters/codex/recent-context.js
+import path8 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 = path8.resolve(dependencies.sessionsRoot ?? path8.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;
@@ -2522,6 +2815,9 @@ class CodexDriver {
   eventNormalizer = new CodexEventNormalizer;
   pendingAccountReadRequestIds = new Set;
   requestId = 0;
+  discoverRecentContext(request) {
+    return discoverCodexRecentContext(request);
+  }
   codexHomeRoot = null;
   proc = null;
   pendingInitialPrompt = null;
@@ -3698,6 +3994,196 @@ class CursorAcpLane {
   }
 }
 
+// agent-driver/dist/internal/discovery-process.js
+import { StringDecoder } from "node:string_decoder";
+function toBuffer(chunk) {
+  if (Buffer.isBuffer(chunk))
+    return chunk;
+  if (chunk instanceof Uint8Array)
+    return Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+  return Buffer.from(String(chunk));
+}
+async function cleanupProcess(process2, label) {
+  if (process2.pid)
+    await killProcessTree(process2.pid, { graceMs: 250 });
+  else if (process2.exitCode === null && process2.signalCode === null && !process2.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, error) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      if (!decoderEnded)
+        decoder.end();
+      Promise.resolve().then(() => options.cleanup?.(options.process) ?? cleanupProcess(options.process, options.label)).then(() => error ? reject(error) : resolve2(result), () => reject(error ?? new Error(`${options.label} discovery cleanup failed`)));
+    };
+    const control = {
+      get outputBytes() {
+        return outputBytes;
+      },
+      finish: (result) => settle(result),
+      fail: (message) => settle(undefined, new Error(message)),
+      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 = (chunk, decode) => {
+      if (settled)
+        return;
+      const bytes = toBuffer(chunk);
+      outputBytes += bytes.byteLength;
+      if (outputBytes > options.outputMaxBytes) {
+        control.fail(`${options.label} discovery output exceeded its bound`);
+      } else if (decode)
+        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", (chunk) => addBytes(chunk, true));
+    options.process.stderr?.on("data", (chunk) => addBytes(chunk, 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 message = asRecord(tryParseJsonLine(line));
+    if (!message || message.id !== expectedId)
+      return;
+    if (message.error !== undefined)
+      return control.fail("Cursor discovery request failed");
+    const result = asRecord(message.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 session = asRecord(value);
+      if (!session)
+        continue;
+      collector.add({ projectPath: session.cwd, modifiedAt: session.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: (text, final, control) => {
+      buffer += text;
+      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;
@@ -3709,6 +4195,9 @@ class CursorDriver {
     wakeStart: "immediate",
     terminalOwnership: "transport_request"
   };
+  discoverRecentContext(request) {
+    return discoverCursorRecentContext(request);
+  }
   constructor(catalogProbe = probeCursorAcpCatalog) {
     this.catalogProbe = catalogProbe;
   }
@@ -4203,7 +4692,7 @@ class OpenCodeServiceLane {
       "/api/session/{sessionID}/permission/{requestID}/reply",
       "/api/event"
     ];
-    if (!paths || required.some((path6) => !record3(paths[path6]))) {
+    if (!paths || required.some((path9) => !record3(paths[path9]))) {
       throw new OpenCodeIncompatibleError("Installed OpenCode service is missing required v2 session capabilities");
     }
   }
@@ -4261,8 +4750,8 @@ class OpenCodeServiceLane {
       const controller = new AbortController;
       this.durableAbort = controller;
       try {
-        const path6 = `/api/session/${encodeURIComponent(this.sessionId)}/event?after=${this.lastDurableSeq}`;
-        const response = await this.openStream(path6, controller, "durable event stream");
+        const path9 = `/api/session/${encodeURIComponent(this.sessionId)}/event?after=${this.lastDurableSeq}`;
+        const response = await this.openStream(path9, controller, "durable event stream");
         await this.catchUpHistory(true);
         if (!this.isIdentity(identity))
           return;
@@ -4336,12 +4825,12 @@ class OpenCodeServiceLane {
       return;
     this.protocolFailure(`OpenCode ${kind} stream stopped unexpectedly`, error);
   }
-  async openStream(path6, lifecycle, operation) {
+  async openStream(path9, 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}${path6}`, {
+      const response = await this.fetchFn(`${this.baseUrl}${path9}`, {
         method: "GET",
         headers: this.headers({ accept: "text/event-stream" }),
         signal: AbortSignal.any([lifecycle.signal, deadline.signal])
@@ -4768,8 +5257,8 @@ class OpenCodeServiceLane {
       turnOwner: root.receipt
     });
   }
-  async requestNoContent(path6, method, body, operation) {
-    const response = await this.fetchWithTimeout(path6, {
+  async requestNoContent(path9, method, body, operation) {
+    const response = await this.fetchWithTimeout(path9, {
       method,
       ...body ? {
         headers: { "content-type": "application/json" },
@@ -4779,7 +5268,7 @@ class OpenCodeServiceLane {
     if (!response.ok)
       throw new OpenCodeHttpError(response.status, operation);
   }
-  async fetchWithTimeout(path6, init, operation, timeoutMs = this.options.requestTimeoutMs ?? REQUEST_TIMEOUT_MS) {
+  async fetchWithTimeout(path9, init, operation, timeoutMs = this.options.requestTimeoutMs ?? REQUEST_TIMEOUT_MS) {
     if (this.stopping)
       throw new Error("OpenCode service lane is stopping");
     const controller = new AbortController;
@@ -4787,7 +5276,7 @@ class OpenCodeServiceLane {
     const timer = setTimeout(() => controller.abort(), timeoutMs);
     timer.unref?.();
     try {
-      return await this.fetchFn(`${this.baseUrl}${path6}`, {
+      return await this.fetchFn(`${this.baseUrl}${path9}`, {
         ...init,
         headers: this.headers(init.headers),
         signal: controller.signal
@@ -4799,7 +5288,7 @@ class OpenCodeServiceLane {
       this.requestControllers.delete(controller);
     }
   }
-  async fetchJsonWithTimeout(path6, init, operation, timeoutMs = this.options.requestTimeoutMs ?? REQUEST_TIMEOUT_MS) {
+  async fetchJsonWithTimeout(path9, init, operation, timeoutMs = this.options.requestTimeoutMs ?? REQUEST_TIMEOUT_MS) {
     if (this.stopping)
       throw new OpenCodeStoppedError("OpenCode service lane is stopping");
     const controller = new AbortController;
@@ -4811,7 +5300,7 @@ class OpenCodeServiceLane {
     }, timeoutMs);
     timer.unref?.();
     try {
-      const response = await this.fetchFn(`${this.baseUrl}${path6}`, {
+      const response = await this.fetchFn(`${this.baseUrl}${path9}`, {
         ...init,
         headers: this.headers(init.headers),
         signal: controller.signal
@@ -4904,6 +5393,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: (text) => {
+      output += text;
+    },
+    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 session = asRecord(value);
+      if (!session)
+        continue;
+      const modifiedAt = session.updated ?? session.updatedAt;
+      collector.add({ projectPath: session.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")}`;
@@ -4922,6 +5480,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")
@@ -4968,8 +5529,8 @@ class OpenCodeDriver {
 // agent-driver/dist/adapters/pi/index.js
 import { createRequire } from "module";
 import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2, realpathSync } from "fs";
-import { homedir as homedir2 } from "os";
-import * as path7 from "path";
+import { homedir as homedir4 } from "os";
+import * as path11 from "path";
 
 // agent-driver/dist/controller/sdk-host.js
 import { EventEmitter as EventEmitter4 } from "events";
@@ -5084,7 +5645,7 @@ class SdkLane {
 
 // agent-driver/dist/adapters/pi/sessionDeps.js
 import { readFileSync } from "fs";
-import * as path6 from "path";
+import * as path9 from "path";
 import { pathToFileURL } from "url";
 var PI_SDK_PACKAGE_NAME = "@earendil-works/pi-coding-agent";
 var cachedSdkPromise = null;
@@ -5093,9 +5654,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(readFileSync(path6.join(dir, "package.json"), "utf-8"));
+  const pkg = JSON.parse(readFileSync(path9.join(dir, "package.json"), "utf-8"));
   const entry = pkg.exports?.["."]?.import ?? pkg.main ?? "./dist/index.js";
-  const entryPath = path6.join(dir, entry);
+  const entryPath = path9.join(dir, entry);
   const barrel = await import(pathToFileURL(entryPath).href);
   return withSessionDirHelper(barrel, entryPath);
 }
@@ -5103,7 +5664,7 @@ async function withSessionDirHelper(barrel, entryPath) {
   if (typeof barrel.getDefaultSessionDir === "function")
     return barrel;
   try {
-    const deepPath = path6.join(path6.dirname(entryPath), "core", "session-manager.js");
+    const deepPath = path9.join(path9.dirname(entryPath), "core", "session-manager.js");
     const deep = await import(pathToFileURL(deepPath).href);
     if (typeof deep.getDefaultSessionDir !== "function")
       return barrel;
@@ -5183,6 +5744,51 @@ function createPiSessionDependencies(ctx, loadSdk = loadPiSdkModule) {
   };
 }
 
+// agent-driver/dist/adapters/pi/recent-context.js
+import { homedir as homedir3 } from "node:os";
+import path10 from "node:path";
+function expandTildePath(value) {
+  if (value === "~")
+    return homedir3();
+  if (value.startsWith("~/"))
+    return path10.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 = path10.resolve(expandTildePath(dependencies.sessionsRoot ?? customSessionDirectory ?? path10.join(process.env.PI_CODING_AGENT_DIR || path10.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;
@@ -5201,15 +5807,15 @@ function resolvePiSdkPackageDir(deps = {}) {
   if (!binPath)
     return;
   try {
-    let dir = path7.dirname(realpathSync(binPath));
+    let dir = path11.dirname(realpathSync(binPath));
     const MAX_DEPTH = 8;
     for (let i = 0;i < MAX_DEPTH; i++) {
-      if (isPiSdkPackageJson(path7.join(dir, "package.json")))
+      if (isPiSdkPackageJson(path11.join(dir, "package.json")))
         return dir;
-      const siblingDir = path7.join(dir, "node_modules", PI_SDK_PACKAGE_NAME2);
-      if (isPiSdkPackageJson(path7.join(siblingDir, "package.json")))
+      const siblingDir = path11.join(dir, "node_modules", PI_SDK_PACKAGE_NAME2);
+      if (isPiSdkPackageJson(path11.join(siblingDir, "package.json")))
         return siblingDir;
-      const parent = path7.dirname(dir);
+      const parent = path11.dirname(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -5226,21 +5832,21 @@ function findPiSessionFile(sessionDir, sessionId) {
   }
   const suffix = `_${sessionId}.jsonl`;
   const match = entries.find((entry) => entry.endsWith(suffix));
-  return match ? path7.join(sessionDir, match) : null;
+  return match ? path11.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() : path7.join(homedir2(), ".pi", "agent");
-  const encoded = `--${path7.resolve(cwd).replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
-  return path7.join(agentDir, "sessions", encoded);
+  const agentDir = typeof sdk.getAgentDir === "function" ? sdk.getAgentDir() : path11.join(homedir4(), ".pi", "agent");
+  const encoded = `--${path11.resolve(cwd).replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+  return path11.join(agentDir, "sessions", encoded);
 }
 function resolvePiSdkVersionFromPath(deps = {}) {
   const dir = resolvePiSdkPackageDir(deps);
   if (!dir)
     return;
   try {
-    const pkg = JSON.parse(readFileSync2(path7.join(dir, "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync2(path11.join(dir, "package.json"), "utf-8"));
     return pkg.version;
   } catch {
     return;
@@ -5344,6 +5950,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;
@@ -5489,6 +6098,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`);
@@ -5710,8 +6322,8 @@ function ensureSymlinks(workDir, canonical = CANONICAL_FILE, aliases = SYMLINK_A
       continue;
     const aliasPath = join8(workDir, alias);
     try {
-      const stat = lstatSync(aliasPath);
-      if (stat.isSymbolicLink()) {
+      const stat2 = lstatSync(aliasPath);
+      if (stat2.isSymbolicLink()) {
         const target = readlinkSync(aliasPath);
         if (target === canonical)
           continue;
@@ -5874,6 +6486,7 @@ class LogicalAgentSession {
   steeringDeliveries = new Set;
   laneAdmissionTail = Promise.resolve();
   laneAdmissionPending = 0;
+  toolBoundaryOpen = true;
   toolBoundaryFlushDisabled = false;
   safeBoundaryFlush;
   safeBoundaryDelivery;
@@ -6154,6 +6767,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 text = messages.map((message) => message.text).join(`
@@ -6386,6 +7001,7 @@ class LogicalAgentSession {
         }
         if (!this.startToolUse(event.callId))
           return;
+        this.toolBoundaryOpen = false;
         const startedCallId = this.toolCallId(event.callId);
         this.emit({
           type: "tool_started",
@@ -6402,6 +7018,7 @@ class LogicalAgentSession {
         }
         if (!this.finishToolUse(event.callId))
           return;
+        this.toolBoundaryOpen = true;
         const finishedCallId = this.toolCallId(event.callId);
         this.emit({
           type: "tool_finished",
@@ -6409,7 +7026,7 @@ class LogicalAgentSession {
           ...finishedCallId ? { callId: finishedCallId } : {},
           name: event.name
         });
-        if (this.outstandingToolUseCount() === 0 && !this.toolBoundaryFlushDisabled)
+        if (!this.toolBoundaryFlushDisabled)
           this.flushSafeBoundaryQueue();
         return;
       case "compaction_started":
@@ -6555,6 +7172,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") {
@@ -6576,7 +7194,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()) {
@@ -7091,6 +7709,57 @@ function createAgentDriverSdkWithRegistry(options) {
   const registry = options.registry;
   return {
     backendIds: registry.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 = registry.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 (error) {
+        const contractInvalid = error instanceof Error && (error.message.startsWith("Adapter ") || error.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 = registry.get(input.backend);
       const capabilities2 = registration.capabilities;
@@ -7353,7 +8022,7 @@ import { createHash as createHash2 } from "crypto";
 // 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 join9 } from "node:path";
 import { promisify } from "node:util";
 import { randomBytes as randomBytes4 } from "node:crypto";
@@ -7382,7 +8051,7 @@ async function claudeCredentials(options) {
     } catch {}
   }
   const env = options.env ?? process.env;
-  const root = env.CLAUDE_CONFIG_DIR || join9(options.home ?? homedir3(), ".claude");
+  const root = env.CLAUDE_CONFIG_DIR || join9(options.home ?? homedir5(), ".claude");
   try {
     const value = options.readCredentialsFile ? await options.readCredentialsFile(join9(root, ".credentials.json")) : await readFile(join9(root, ".credentials.json"), "utf8");
     return parseCredentials(value);
@@ -9777,7 +10446,19 @@ class AgentProcessManager {
     const session = this.sessions.get(agentId);
     if (!session)
       return;
-    await session.interrupt({ requestId: randomUUID6(), reason: "owner_request" });
+    const result = await session.interrupt({ requestId: randomUUID6(), reason: "owner_request" });
+    if (result.status !== "accepted")
+      return;
+    this.log.info("agent turn interrupt accepted", {
+      agentId,
+      sessionInstanceId: session.sessionInstanceId,
+      turnId: result.turnId
+    });
+    try {
+      this.opts.onBotAuditEvent?.(agentId, { kind: "turn_interrupt", payload: { status: "accepted" } }, this.auditContext(agentId));
+    } catch (err) {
+      this.log.debug("audit emit failed (turn interrupt)", { agentId, err: String(err) });
+    }
   }
   async stopAll() {
     if (this.tickTimer) {
@@ -10119,6 +10800,10 @@ ${this.opts.wakePromptFooter}` : text;
             sent = session.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 (error) {
             if (exactOwner) {
               this.settlePendingDelivery(exactOwner, input.id);
@@ -10164,7 +10849,6 @@ ${this.opts.wakePromptFooter}` : text;
             mode: effect.mode
           });
         }
-        this.log.info("steering message sent to running agent", { agentId: effect.agentId, mode: effect.mode });
         break;
       }
       case "stop":
@@ -11687,10 +12371,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path8) {
-  if (!path8)
+function getElementAtPath(obj, path12) {
+  if (!path12)
     return obj;
-  return path8.reduce((acc, key) => acc?.[key], obj);
+  return path12.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -12098,11 +12782,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path8, issues) {
+function prefixIssues(path12, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path8);
+    iss.path.unshift(path12);
     return iss;
   });
 }
@@ -12249,16 +12933,16 @@ function flattenError(error, mapper = (issue2) => issue2.message) {
 }
 function formatError(error, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error2, path8 = []) => {
+  const processError = (error2, path12 = []) => {
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path8, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path12, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
       } else {
-        const fullpath = [...path8, ...issue2.path];
+        const fullpath = [...path12, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -12285,17 +12969,17 @@ function formatError(error, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error2, path8 = []) => {
+  const processError = (error2, path12 = []) => {
     var _a2, _b;
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path8, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path12, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
       } else {
-        const fullpath = [...path8, ...issue2.path];
+        const fullpath = [...path12, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -12327,8 +13011,8 @@ function treeifyError(error, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path8 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path8) {
+  const path12 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path12) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -24787,13 +25471,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path8 = ref.slice(1).split("/").filter(Boolean);
-  if (path8.length === 0) {
+  const path12 = ref.slice(1).split("/").filter(Boolean);
+  if (path12.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path8[0] === defsKey) {
-    const key = path8[1];
+  if (path12[0] === defsKey) {
+    const key = path12[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -26801,6 +27485,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;
@@ -27675,6 +28360,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)
@@ -28026,6 +28718,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,
@@ -28143,7 +28855,7 @@ import * as fs5 from "fs";
 import * as http from "http";
 import * as https from "https";
 import * as os2 from "os";
-import * as path8 from "path";
+import * as path12 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;
@@ -28175,15 +28887,15 @@ class CredentialBroker {
     this.voucherPrefix = config2.voucherPrefix ?? "vch_";
     this.clientLabel = config2.clientLabel ?? "cli";
     this.headerNames = config2.headerNames ?? DEFAULT_HEADER_NAMES;
-    this.voucherDir = config2.voucherDir ?? path8.join(os2.tmpdir(), "agent-vouchers");
+    this.voucherDir = config2.voucherDir ?? path12.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 = path8.join(this.voucherDir, sanitizeIdSegment(agentId));
+    const dir = path12.join(this.voucherDir, sanitizeIdSegment(agentId));
     fs5.mkdirSync(dir, { recursive: true });
-    const voucherFile = path8.join(dir, `${sanitizeIdSegment(launchId)}.token`);
+    const voucherFile = path12.join(dir, `${sanitizeIdSegment(launchId)}.token`);
     fs5.writeFileSync(voucherFile, voucher, { mode: 384 });
     this.registrations.set(voucher, {
       agentId,
@@ -28578,7 +29290,7 @@ function joinPath(basePath, reqUrl) {
   return base + reqPath || "/";
 }
 // src/daemon/createDaemon.ts
-import { homedir as homedir5 } from "os";
+import { homedir as homedir7 } from "os";
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync7 } from "node:fs";
 
 // src/util/rotatingFileSink.ts
@@ -28595,7 +29307,7 @@ import {
   statSync,
   unlinkSync as unlinkSync3
 } from "node:fs";
-function createRotatingFileSink(path9, maxBytes, opts = {}) {
+function createRotatingFileSink(path13, maxBytes, opts = {}) {
   const report = (operation, error51) => {
     try {
       opts.onError?.({ operation, error: error51 });
@@ -28605,8 +29317,8 @@ function createRotatingFileSink(path9, maxBytes, opts = {}) {
     if (!existsSync5(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"));
@@ -28614,7 +29326,7 @@ function createRotatingFileSink(path9, 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) {
@@ -28631,9 +29343,9 @@ function createRotatingFileSink(path9, maxBytes, opts = {}) {
   };
   const rotate = () => {
     try {
-      renameSync(path9, `${path9}.1`);
+      renameSync(path13, `${path13}.1`);
       if (opts.mode !== undefined)
-        chmodSync(`${path9}.1`, opts.mode);
+        chmodSync(`${path13}.1`, opts.mode);
       return true;
     } catch (error51) {
       report("rotate", error51);
@@ -28642,7 +29354,7 @@ function createRotatingFileSink(path9, maxBytes, opts = {}) {
   };
   const currentSize = () => {
     try {
-      return existsSync5(path9) ? statSync(path9).size : 0;
+      return existsSync5(path13) ? statSync(path13).size : 0;
     } catch (error51) {
       report("stat", error51);
       return null;
@@ -28650,7 +29362,7 @@ function createRotatingFileSink(path9, maxBytes, opts = {}) {
   };
   const sink = {
     secure() {
-      return secureGeneration(`${path9}.1`) && secureGeneration(path9);
+      return secureGeneration(`${path13}.1`) && secureGeneration(path13);
     },
     write(line) {
       try {
@@ -28670,7 +29382,7 @@ function createRotatingFileSink(path9, maxBytes, opts = {}) {
         const shouldRotate = maxBytes > 0 && (opts.hardMaxBytes ? currentBytes > 0 && currentBytes + serializedBytes > maxBytes : currentBytes >= maxBytes);
         if (shouldRotate && !rotate() && opts.hardMaxBytes)
           return;
-        appendFileSync(path9, serialized, opts.mode === undefined ? undefined : { mode: opts.mode });
+        appendFileSync(path13, serialized, opts.mode === undefined ? undefined : { mode: opts.mode });
       } catch (error51) {
         report("append", error51);
       }
@@ -28678,7 +29390,7 @@ function createRotatingFileSink(path9, maxBytes, opts = {}) {
     openSnapshot() {
       const files = [];
       try {
-        for (const candidate of [`${path9}.1`, path9]) {
+        for (const candidate of [`${path13}.1`, path13]) {
           if (!existsSync5(candidate))
             continue;
           if (!secureGeneration(candidate))
@@ -28686,10 +29398,10 @@ function createRotatingFileSink(path9, 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;
@@ -28839,11 +29551,11 @@ function createTraceSampler(emit, throttleMs = DEFAULT_TRACE_SAMPLE_MS) {
 
 // src/util/statusFile.ts
 import { writeFileSync as writeFileSync4, renameSync as renameSync2 } from "node:fs";
-function writeStatusFile(path9, snapshot) {
+function writeStatusFile(path13, snapshot) {
   try {
-    const tmp = `${path9}.tmp`;
+    const tmp = `${path13}.tmp`;
     writeFileSync4(tmp, JSON.stringify(snapshot));
-    renameSync2(tmp, path9);
+    renameSync2(tmp, path13);
   } catch {}
 }
 // ../shared/src/constants/community.ts
@@ -29687,6 +30399,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);
@@ -29781,6 +30497,9 @@ var AuditLogThinkingPayloadSchema = exports_external.object({
   truncated: exports_external.boolean(),
   chars: exports_external.number().int().nonnegative()
 });
+var AuditLogTurnInterruptPayloadSchema = exports_external.object({
+  status: exports_external.literal("accepted")
+});
 var AuditLogWakeTriggerPayloadSchema = exports_external.object({
   messageId: exports_external.string().min(1),
   channel: exports_external.string().min(1),
@@ -29813,6 +30532,7 @@ var BotAuditEventSchema = exports_external.discriminatedUnion("kind", [
   exports_external.object({ kind: exports_external.literal("cli_invocation"), payload: AuditLogCliInvocationPayloadSchema }),
   exports_external.object({ kind: exports_external.literal("tool_call"), payload: AuditLogToolCallPayloadSchema }),
   exports_external.object({ kind: exports_external.literal("thinking"), payload: AuditLogThinkingPayloadSchema }),
+  exports_external.object({ kind: exports_external.literal("turn_interrupt"), payload: AuditLogTurnInterruptPayloadSchema }),
   exports_external.object({ kind: exports_external.literal("wake_trigger"), payload: AuditLogWakeTriggerPayloadSchema }),
   exports_external.object({ kind: exports_external.literal("session_reset"), payload: AuditLogSessionResetPayloadSchema }),
   exports_external.object({ kind: exports_external.literal("nap"), payload: AuditLogNapPayloadSchema }),
@@ -29824,6 +30544,7 @@ var BotAuditEventKindSchema = exports_external.enum([
   "cli_invocation",
   "tool_call",
   "thinking",
+  "turn_interrupt",
   "wake_trigger",
   "session_reset",
   "nap",
@@ -30780,7 +31501,7 @@ var communityBotAuditEventSchema = exports_external.strictObject({
   type: exports_external.literal("community:bot.audit_event"),
   botId: string4,
   id: string4,
-  kind: exports_external.enum(["cli_invocation", "tool_call", "thinking", "wake_trigger", "session_reset", "nap", "model_changed", "provider_changed", "error"]),
+  kind: exports_external.enum(["cli_invocation", "tool_call", "thinking", "turn_interrupt", "wake_trigger", "session_reset", "nap", "model_changed", "provider_changed", "error"]),
   payload: exports_external.unknown(),
   sessionId: nullableString.optional(),
   launchId: nullableString.optional(),
@@ -31806,11 +32527,11 @@ function timelineRowHash(line) {
 }
 function timelineFileGeneration(filePath, lines) {
   try {
-    const stat = fs7.lstatSync(filePath, { bigint: true });
-    if (!stat.isFile())
+    const stat2 = fs7.lstatSync(filePath, { bigint: true });
+    if (!stat2.isFile())
       return null;
     const digest = createHash4("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(`
@@ -31868,9 +32589,9 @@ function compactLines(input) {
   }
   return suffix;
 }
-function isRealDirectory(path9) {
+function isRealDirectory(path13) {
   try {
-    return fs7.lstatSync(path9).isDirectory();
+    return fs7.lstatSync(path13).isDirectory();
   } catch {
     return false;
   }
@@ -31910,8 +32631,8 @@ function scanTimelineFile(filePath) {
   let fd = null;
   try {
     fd = fs7.openSync(filePath, fs7.constants.O_RDONLY | (fs7.constants.O_NOFOLLOW ?? 0));
-    const stat = fs7.fstatSync(fd);
-    if (!stat.isFile())
+    const stat2 = fs7.fstatSync(fd);
+    if (!stat2.isFile())
       return null;
     const chunk2 = Buffer.allocUnsafe(TIMELINE_READ_CHUNK_BYTES);
     const newest = [];
@@ -31924,9 +32645,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);
-      fs7.readSync(fd, last, 0, 1, stat.size - 1);
+      fs7.readSync(fd, last, 0, 1, stat2.size - 1);
       discardIncompleteTail = last[0] !== 10;
     }
     const resetPhysicalLine = () => {
@@ -31985,7 +32706,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;
@@ -32137,11 +32858,11 @@ function readResumeControlState(timelineDir) {
   let fd = null;
   try {
     fd = fs7.openSync(filePath, fs7.constants.O_RDONLY | (fs7.constants.O_NOFOLLOW ?? 0));
-    const stat = fs7.fstatSync(fd);
-    if (!stat.isFile() || stat.size <= 0 || stat.size > RESUME_CONTROL_MAX_BYTES) {
+    const stat2 = fs7.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 = fs7.readSync(fd, bounded, bytesRead, bounded.length - bytesRead, bytesRead);
@@ -32149,7 +32870,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);
@@ -32936,26 +33657,26 @@ function createTimelineRecorder(opts) {
   }
 }
 // src/discovery.ts
-import * as path9 from "path";
+import * as path13 from "path";
 import * as fs8 from "fs";
 import { fileURLToPath } from "url";
 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 fs8.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) {
@@ -33150,7 +33871,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
@@ -33276,7 +33997,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,
@@ -33597,13 +34318,13 @@ function createRuntimeRawLineTap(args) {
   const maxBytes = args.maxBytes ?? RUNTIME_RAW_TRACE_MAX_BYTES;
   const sinks = new Map;
   const warned = new Set;
-  const warnOnce = (agentId, path10, operation, error51) => {
+  const warnOnce = (agentId, path14, operation, error51) => {
     if (warned.has(agentId))
       return;
     warned.add(agentId);
     args.logger.warn("runtime raw trace sink failed", {
       agentId,
-      path: path10,
+      path: path14,
       operation,
       error: error51 instanceof Error ? error51.message : String(error51)
     });
@@ -33612,10 +34333,10 @@ function createRuntimeRawLineTap(args) {
     if (!args.enabledAgentIds.has(agentId))
       return;
     const encodedAgentId = encodeURIComponent(agentId).replace(/\./g, "%2E");
-    const path10 = `${traceDir}/runtime-raw-events-${encodedAgentId}.jsonl`;
+    const path14 = `${traceDir}/runtime-raw-events-${encodedAgentId}.jsonl`;
     const serializedBytes = Buffer.byteLength(line, "utf8") + 1;
     if (serializedBytes > maxBytes) {
-      warnOnce(agentId, path10, "oversize", new Error(`raw line is ${serializedBytes} bytes; max is ${maxBytes}`));
+      warnOnce(agentId, path14, "oversize", new Error(`raw line is ${serializedBytes} bytes; max is ${maxBytes}`));
       return;
     }
     let sink = sinks.get(agentId);
@@ -33623,12 +34344,12 @@ function createRuntimeRawLineTap(args) {
       try {
         mkdirSync7(traceDir, { recursive: true });
       } catch (error51) {
-        warnOnce(agentId, path10, "mkdir", error51);
+        warnOnce(agentId, path14, "mkdir", error51);
       }
-      sink = createRotatingFileSink(path10, maxBytes, {
+      sink = createRotatingFileSink(path14, maxBytes, {
         mode: 384,
         hardMaxBytes: true,
-        onError: ({ operation, error: error51 }) => warnOnce(agentId, path10, operation, error51)
+        onError: ({ operation, error: error51 }) => warnOnce(agentId, path14, operation, error51)
       });
       sinks.set(agentId, sink);
     }
@@ -33720,7 +34441,7 @@ function createBuiltinDaemonSessionFactory(onRuntimeRawLine) {
 }
 async function createDaemon(opts) {
   const log2 = opts.logger ?? createLogger({ 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);
@@ -34311,6 +35032,7 @@ export {
   buildApmFreshnessDecisionProducerFactId,
   UnknownRuntimeError,
   UnknownBotError,
+  SESSION_FILE_DISCOVERY_CAPABILITIES2 as SESSION_FILE_DISCOVERY_CAPABILITIES,
   RuntimeProgressState,
   RuntimeNotificationState,
   RUNTIME_RAW_TRACE_AGENT_IDS_ENV,