@alook/daemon 0.1.31 → 0.1.33

package/dist/cli/index.js

@@ -15888,6 +15888,7 @@ __export(exports_schema, {
   user: () => user,
   taskMessage: () => taskMessage,
   session: () => session,
+  nativeOauthAttempt: () => nativeOauthAttempt,
   messageFlag: () => messageFlag,
   message: () => message,
   member: () => member,
@@ -15914,7 +15915,11 @@ __export(exports_schema, {
   agentEmailAccount: () => agentEmailAccount,
   agentAccess: () => agentAccess,
   agent: () => agent,
-  account: () => account
+  account: () => account,
+  NATIVE_OAUTH_STATUSES: () => NATIVE_OAUTH_STATUSES,
+  NATIVE_OAUTH_PROVIDERS: () => NATIVE_OAUTH_PROVIDERS,
+  NATIVE_OAUTH_PLATFORMS: () => NATIVE_OAUTH_PLATFORMS,
+  NATIVE_OAUTH_FAILURE_CODES: () => NATIVE_OAUTH_FAILURE_CODES
 });
 init_nanoid();
 
@@ -15979,6 +15984,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;
@@ -16044,6 +16050,119 @@ var verification = sqliteTable("verification", {
   createdAt: text("createdAt").notNull().$defaultFn(() => new Date().toISOString()),
   updatedAt: text("updatedAt").notNull().$defaultFn(() => new Date().toISOString())
 });
+var NATIVE_OAUTH_PROVIDERS = ["github", "google"];
+var NATIVE_OAUTH_PLATFORMS = [
+  "macos",
+  "windows",
+  "linux",
+  "ios",
+  "android"
+];
+var NATIVE_OAUTH_STATUSES = [
+  "pending",
+  "opened",
+  "ready",
+  "exchanging",
+  "consumed",
+  "failed",
+  "cancelled",
+  "replaced"
+];
+var NATIVE_OAUTH_FAILURE_CODES = [
+  "access_denied",
+  "provider_error",
+  "oauth_callback_failed",
+  "start_failed",
+  "invalid_handoff"
+];
+var nativeOauthAttempt = sqliteTable("native_oauth_attempt", {
+  id: text("id").primaryKey(),
+  instanceKeyHash: text("instance_key_hash").notNull(),
+  stateHash: text("state_hash").notNull(),
+  pkceChallenge: text("pkce_challenge").notNull(),
+  provider: text("provider").$type().notNull(),
+  platform: text("platform").$type().notNull(),
+  redirectPath: text("redirect_path").notNull(),
+  status: text("status").$type().notNull().default("pending"),
+  handoffCodeHash: text("handoff_code_hash"),
+  handoffExpiresAt: integer2("handoff_expires_at"),
+  authKind: text("auth_kind").$type(),
+  failureCode: text("failure_code").$type(),
+  attemptExpiresAt: integer2("attempt_expires_at").notNull(),
+  createdAt: integer2("created_at").notNull(),
+  updatedAt: integer2("updated_at").notNull(),
+  openedAt: integer2("opened_at"),
+  readyAt: integer2("ready_at"),
+  consumedAt: integer2("consumed_at"),
+  failedAt: integer2("failed_at"),
+  cancelledAt: integer2("cancelled_at"),
+  replacedAt: integer2("replaced_at")
+}, (t) => [
+  index("idx_native_oauth_attempt_instance_status").on(t.instanceKeyHash, t.status),
+  index("idx_native_oauth_attempt_id_status_expiry").on(t.id, t.status, t.attemptExpiresAt),
+  index("idx_native_oauth_attempt_terminal_cleanup").on(t.status, t.updatedAt),
+  uniqueIndex("uq_native_oauth_attempt_instance_live").on(t.instanceKeyHash).where(sql`status IN ('pending', 'opened', 'ready', 'exchanging')`),
+  uniqueIndex("uq_native_oauth_attempt_handoff_hash").on(t.handoffCodeHash).where(sql`handoff_code_hash IS NOT NULL`),
+  check2("ck_native_oauth_attempt_id", sql`length(${t.id}) BETWEEN 22 AND 64 AND ${t.id} NOT GLOB '*[^A-Za-z0-9_-]*'`),
+  check2("ck_native_oauth_attempt_hashes", sql`length(${t.instanceKeyHash}) = 64 AND ${t.instanceKeyHash} NOT GLOB '*[^0-9a-f]*'
+        AND length(${t.stateHash}) = 64 AND ${t.stateHash} NOT GLOB '*[^0-9a-f]*'
+        AND length(${t.pkceChallenge}) = 43 AND ${t.pkceChallenge} NOT GLOB '*[^A-Za-z0-9_-]*'
+        AND (${t.handoffCodeHash} IS NULL OR (length(${t.handoffCodeHash}) = 64 AND ${t.handoffCodeHash} NOT GLOB '*[^0-9a-f]*'))`),
+  check2("ck_native_oauth_attempt_enums", sql`${t.provider} IN ('github', 'google')
+        AND ${t.platform} IN ('macos', 'windows', 'linux', 'ios', 'android')
+        AND ${t.status} IN ('pending', 'opened', 'ready', 'exchanging', 'consumed', 'failed', 'cancelled', 'replaced')
+        AND (${t.authKind} IS NULL OR ${t.authKind} IN ('signin', 'signup'))
+        AND (${t.failureCode} IS NULL OR ${t.failureCode} IN ('access_denied', 'provider_error', 'oauth_callback_failed', 'start_failed', 'invalid_handoff'))`),
+  check2("ck_native_oauth_attempt_redirect", sql`length(${t.redirectPath}) BETWEEN 1 AND 2048
+        AND substr(${t.redirectPath}, 1, 1) = '/'
+        AND substr(${t.redirectPath}, 1, 2) <> '//'
+        AND instr(${t.redirectPath}, char(92)) = 0`),
+  check2("ck_native_oauth_attempt_epochs", sql`typeof(${t.createdAt}) = 'integer' AND ${t.createdAt} BETWEEN 0 AND 9007199254740991
+        AND typeof(${t.updatedAt}) = 'integer' AND ${t.updatedAt} BETWEEN ${t.createdAt} AND 9007199254740991
+        AND typeof(${t.attemptExpiresAt}) = 'integer' AND ${t.attemptExpiresAt} = ${t.createdAt} + 600000
+        AND (${t.handoffExpiresAt} IS NULL OR (typeof(${t.handoffExpiresAt}) = 'integer' AND ${t.handoffExpiresAt} <= ${t.attemptExpiresAt}))`),
+  check2("ck_native_oauth_attempt_state", sql`(
+          ${t.status} = 'pending'
+          AND ${t.openedAt} IS NULL AND ${t.readyAt} IS NULL AND ${t.consumedAt} IS NULL
+          AND ${t.failedAt} IS NULL AND ${t.cancelledAt} IS NULL AND ${t.replacedAt} IS NULL
+          AND ${t.handoffCodeHash} IS NULL AND ${t.handoffExpiresAt} IS NULL
+          AND ${t.authKind} IS NULL AND ${t.failureCode} IS NULL
+        ) OR (
+          ${t.status} = 'opened'
+          AND ${t.openedAt} IS NOT NULL AND ${t.readyAt} IS NULL AND ${t.consumedAt} IS NULL
+          AND ${t.failedAt} IS NULL AND ${t.cancelledAt} IS NULL AND ${t.replacedAt} IS NULL
+          AND ${t.handoffCodeHash} IS NULL AND ${t.handoffExpiresAt} IS NULL
+          AND ${t.authKind} IS NULL AND ${t.failureCode} IS NULL
+        ) OR (
+          ${t.status} IN ('ready', 'exchanging')
+          AND ${t.openedAt} IS NOT NULL AND ${t.readyAt} IS NOT NULL AND ${t.consumedAt} IS NULL
+          AND ${t.failedAt} IS NULL AND ${t.cancelledAt} IS NULL AND ${t.replacedAt} IS NULL
+          AND ${t.handoffCodeHash} IS NOT NULL AND ${t.handoffExpiresAt} IS NOT NULL
+          AND ${t.handoffExpiresAt} = ${t.readyAt} + 120000
+          AND ${t.authKind} IS NOT NULL AND ${t.failureCode} IS NULL
+        ) OR (
+          ${t.status} = 'consumed'
+          AND ${t.openedAt} IS NOT NULL AND ${t.readyAt} IS NOT NULL AND ${t.consumedAt} IS NOT NULL
+          AND ${t.failedAt} IS NULL AND ${t.cancelledAt} IS NULL AND ${t.replacedAt} IS NULL
+          AND ${t.handoffCodeHash} IS NOT NULL AND ${t.handoffExpiresAt} IS NOT NULL
+          AND ${t.authKind} IS NOT NULL AND ${t.failureCode} IS NULL
+        ) OR (
+          ${t.status} = 'failed'
+          AND ${t.consumedAt} IS NULL AND ${t.failedAt} IS NOT NULL
+          AND ${t.cancelledAt} IS NULL AND ${t.replacedAt} IS NULL
+          AND ${t.failureCode} IS NOT NULL
+        ) OR (
+          ${t.status} = 'cancelled'
+          AND ${t.consumedAt} IS NULL AND ${t.cancelledAt} IS NOT NULL
+          AND ${t.failedAt} IS NULL AND ${t.replacedAt} IS NULL
+          AND ${t.failureCode} IS NULL
+        ) OR (
+          ${t.status} = 'replaced'
+          AND ${t.consumedAt} IS NULL AND ${t.replacedAt} IS NOT NULL
+          AND ${t.failedAt} IS NULL AND ${t.cancelledAt} IS NULL
+          AND ${t.failureCode} IS NULL
+        )`)
+]);
 var workspace = sqliteTable("workspace", {
   id: text("id").primaryKey().$defaultFn(() => "sp_" + nanoid3()),
   name: text("name").notNull(),
@@ -16853,6 +16972,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 +17888,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);
@@ -18365,6 +18495,15 @@ function createLogger(opts) {
 
 // ../shared/src/db/queries/_chunk.ts
 var D1_MAX_BIND_PARAMS = 100;
+function maxInParams(fixedParams) {
+  if (!Number.isInteger(fixedParams) || fixedParams < 0) {
+    throw new Error("fixed params must be a non-negative integer");
+  }
+  if (fixedParams >= D1_MAX_BIND_PARAMS) {
+    throw new Error("fixed params must leave room for at least one IN parameter");
+  }
+  return D1_MAX_BIND_PARAMS - fixedParams;
+}
 function maxRowsPerInsert(paramsPerRow) {
   if (paramsPerRow < 1)
     throw new Error("paramsPerRow must be >= 1");
@@ -18456,6 +18595,7 @@ var AGENT_MESSAGE_COLUMNS = {
   replyToId: communityMessage.replyToId
 };
 var channelJoinBaselineGuard = sql`${communityMessage.createdAt} > COALESCE(${communityChannelMember.addedAt}, ${communityServerMember.joinedAt}, '')`;
+var AGENT_UNREAD_CHANNEL_CHUNK_SIZE = maxInParams(13);
 
 // ../shared/src/db/queries/community/mention.ts
 var MENTION_INSERT_MAX_ROWS = maxRowsPerInsert(5);
@@ -19068,6 +19208,10 @@ var serverRailCommandSchema = exports_external.discriminatedUnion("kind", [
 var serverRailCommitRequestSchema = exports_external.strictObject({
   commands: exports_external.array(serverRailCommandSchema).min(1).max(MAX_SERVER_RAIL_COMMANDS)
 });
+// ../shared/src/db/queries/native-oauth.ts
+var ATTEMPT_TTL_MS = 10 * 60 * 1000;
+var HANDOFF_TTL_MS = 2 * 60 * 1000;
+var RETENTION_MS = 24 * 60 * 60 * 1000;
 // ../shared/src/db/queries/task.ts
 var DEFAULT_STALE_SECONDS = Number(process.env.ALOOK_STALE_DISPATCH_TIMEOUT_S) || 20;
 var DEFAULT_STALE_RUNNING_SECONDS = Number(process.env.ALOOK_STALE_RUNNING_TIMEOUT_S) || 3600;
@@ -19108,6 +19252,80 @@ function parseInviteToken(input) {
     return urlMatch[1];
   return BARE_TOKEN_RE.test(trimmed) ? trimmed : null;
 }
+// ../shared/src/lib/safe-redirect.ts
+var MAX_REDIRECT_BYTES = 2048;
+var CONTROL_CHARACTERS = /[\u0000-\u001f\u007f]/;
+function isSafeCandidate(value) {
+  return value.startsWith("/") && !value.startsWith("//") && !value.includes("\\") && !value.includes("#") && !CONTROL_CHARACTERS.test(value);
+}
+function isSafeRedirectPath(value) {
+  if (new TextEncoder().encode(value).byteLength > MAX_REDIRECT_BYTES)
+    return false;
+  if (!isSafeCandidate(value))
+    return false;
+  let decoded = value;
+  for (let depth = 0;depth < 8; depth += 1) {
+    let next;
+    try {
+      next = decodeURIComponent(decoded);
+    } catch {
+      return depth > 0;
+    }
+    if (next === decoded)
+      break;
+    if (!isSafeCandidate(next))
+      return false;
+    decoded = next;
+    if (depth === 7)
+      return false;
+  }
+  try {
+    const base = new URL("https://alook.invalid");
+    const resolved = new URL(value, base);
+    return resolved.origin === base.origin;
+  } catch {
+    return false;
+  }
+}
+
+// ../shared/src/lib/native-oauth-contract.ts
+var ATTEMPT_ID = /^[A-Za-z0-9_-]{22,64}$/;
+var SHA256_HEX = /^[0-9a-f]{64}$/;
+var BASE64URL_32_BYTES = /^[A-Za-z0-9_-]{43}$/;
+var HANDOFF_CODE = /^[A-Za-z0-9_-]{32,128}$/;
+var nativeOauthProviderSchema = exports_external.enum(["github", "google"]);
+var nativeOauthPlatformSchema = exports_external.enum([
+  "macos",
+  "windows",
+  "linux",
+  "ios",
+  "android"
+]);
+var nativeOauthAttemptIdSchema = exports_external.string().regex(ATTEMPT_ID);
+var nativeOauthHandoffCodeSchema = exports_external.string().regex(HANDOFF_CODE);
+var nativeOauthFailureCodeSchema = exports_external.enum([
+  "access_denied",
+  "provider_error",
+  "oauth_callback_failed",
+  "start_failed",
+  "invalid_handoff"
+]);
+var nativeOauthRegistrationSchema = exports_external.object({
+  attemptId: nativeOauthAttemptIdSchema,
+  stateHash: exports_external.string().regex(SHA256_HEX),
+  codeChallenge: exports_external.string().regex(BASE64URL_32_BYTES),
+  instanceKeyHash: exports_external.string().regex(SHA256_HEX),
+  platform: nativeOauthPlatformSchema,
+  provider: nativeOauthProviderSchema,
+  redirectPath: exports_external.string().refine(isSafeRedirectPath)
+}).strict();
+var nativeOauthExchangeSchema = exports_external.object({
+  attemptId: nativeOauthAttemptIdSchema,
+  state: exports_external.string().regex(BASE64URL_32_BYTES),
+  verifier: exports_external.string().regex(BASE64URL_32_BYTES),
+  code: nativeOauthHandoffCodeSchema
+}).strict();
+var nativeOauthProofSchema = nativeOauthExchangeSchema.omit({ code: true }).strict();
 // ../shared/src/semver.ts
 var RELEASE_VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
 function parseReleaseVersion(value) {
@@ -19557,13 +19775,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 +20925,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 +21429,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 +21685,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 +21951,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 +22329,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 +22337,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 +22431,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 +22502,9 @@ class CodexDriver {
   eventNormalizer = new CodexEventNormalizer;
   pendingAccountReadRequestIds = new Set;
   requestId = 0;
+  discoverRecentContext(request) {
+    return discoverCodexRecentContext(request);
+  }
   codexHomeRoot = null;
   proc = null;
   pendingInitialPrompt = null;
@@ -23173,6 +23681,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 +23882,9 @@ class CursorDriver {
     wakeStart: "immediate",
     terminalOwnership: "transport_request"
   };
+  discoverRecentContext(request) {
+    return discoverCursorRecentContext(request);
+  }
   constructor(catalogProbe = probeCursorAcpCatalog) {
     this.catalogProbe = catalogProbe;
   }
@@ -23678,7 +24379,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 +24437,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 +24512,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 +24944,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 +24955,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 +24963,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 +24975,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 +24987,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 +25080,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 +25167,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 +25216,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 +25332,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 +25341,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 +25351,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 +25431,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 +25494,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 +25519,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 +25637,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 +25785,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 +26009,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 +26173,7 @@ class LogicalAgentSession {
   steeringDeliveries = new Set;
   laneAdmissionTail = Promise.resolve();
   laneAdmissionPending = 0;
+  toolBoundaryOpen = true;
   toolBoundaryFlushDisabled = false;
   safeBoundaryFlush;
   safeBoundaryDelivery;
@@ -25629,6 +26454,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 +26688,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 +26705,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 +26713,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 +26859,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 +26881,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 +27396,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 +27585,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 +27742,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 +27763,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 +27773,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 +27782,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 +27799,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 +27810,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 +27818,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 +27838,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 +27846,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 +27854,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 +28007,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 +28693,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 +28725,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,
@@ -28049,12 +28930,20 @@ async function startCredentialProxy(broker, options = {}) {
   const upstream = new URL2(broker.upstreamBaseUrl);
   const upstreamClient = upstream.protocol === "https:" ? https : http;
   const onPull = options.onInboxPullResponse;
+  const onAck = options.onInboxAckResponse;
   const onProxyRequest = options.onProxyRequest;
   const reportInboxPullObservationError = (failure) => {
     try {
       options.onInboxPullObservationError?.(failure);
     } catch {}
   };
+  const reportInboxAckObservationError = (failure) => {
+    try {
+      options.onInboxAckObservationError?.(failure);
+    } catch {
+      return;
+    }
+  };
   const server = http.createServer((req, res) => {
     const pathname = new URL2(req.url ?? "/", "http://placeholder").pathname;
     if (pathname.startsWith("/__alook/local/")) {
@@ -28094,8 +28983,11 @@ async function startCredentialProxy(broker, options = {}) {
     }
     const reg = verdict.reg;
     const isInboxPull = req.method === "POST" && pathname === "/api/community/users/me/inbox/pull";
+    const isInboxAck = req.method === "POST" && pathname === "/api/community/users/me/inbox/ack";
     const shouldObserveInboxPull = Boolean(isInboxPull && onPull);
+    const shouldObserveInboxAck = Boolean(isInboxAck && onAck);
     let inboxPullObservationToken;
+    let inboxAckObservationToken;
     if (shouldObserveInboxPull) {
       try {
         inboxPullObservationToken = options.onInboxPullStart?.(reg.agentId);
@@ -28107,6 +28999,17 @@ async function startCredentialProxy(broker, options = {}) {
         });
       }
     }
+    if (shouldObserveInboxAck) {
+      try {
+        inboxAckObservationToken = options.onInboxAckStart?.(reg.agentId);
+      } catch {
+        reportInboxAckObservationError({
+          agentId: reg.agentId,
+          reason: "observer_failed",
+          contentEncoding: "identity"
+        });
+      }
+    }
     if (onProxyRequest) {
       try {
         const method = req.method ?? "GET";
@@ -28124,7 +29027,7 @@ async function startCredentialProxy(broker, options = {}) {
     outHeaders[broker.headerNames.agentId.toLowerCase()] = reg.agentId;
     outHeaders[broker.headerNames.client.toLowerCase()] = broker.clientLabel;
     outHeaders[broker.headerNames.capabilities.toLowerCase()] = [...reg.capabilities].join(",");
-    if (isInboxPull)
+    if (isInboxPull || isInboxAck)
       outHeaders["accept-encoding"] = "identity";
     let responded = false;
     let upstreamRes;
@@ -28144,43 +29047,72 @@ async function startCredentialProxy(broker, options = {}) {
       };
       res_.on("error", destroyResIfIncomplete);
       res_.on("close", destroyResIfIncomplete);
-      if (shouldObserveInboxPull && res_.statusCode !== undefined && res_.statusCode >= 200 && res_.statusCode < 300) {
+      if ((shouldObserveInboxPull || shouldObserveInboxAck) && res_.statusCode !== undefined && res_.statusCode >= 200 && res_.statusCode < 300) {
         const chunks = [];
         res_.on("data", (chunk2) => chunks.push(chunk2));
         res_.on("end", () => {
           const body = Buffer.concat(chunks);
           const contentEncoding = normalizeContentEncoding(res_.headers["content-encoding"]);
           if (contentEncoding !== "identity") {
-            reportInboxPullObservationError({
-              agentId: reg.agentId,
-              reason: "unexpected_content_encoding",
-              contentEncoding
-            });
+            if (shouldObserveInboxPull) {
+              reportInboxPullObservationError({
+                agentId: reg.agentId,
+                reason: "unexpected_content_encoding",
+                contentEncoding
+              });
+            } else {
+              reportInboxAckObservationError({
+                agentId: reg.agentId,
+                reason: "unexpected_content_encoding",
+                contentEncoding
+              });
+            }
           } else {
             let parsed;
             try {
               parsed = JSON.parse(body.toString("utf8"));
             } catch {
-              reportInboxPullObservationError({
-                agentId: reg.agentId,
-                reason: "invalid_json",
-                contentEncoding
-              });
+              if (shouldObserveInboxPull) {
+                reportInboxPullObservationError({ agentId: reg.agentId, reason: "invalid_json", contentEncoding });
+              } else {
+                reportInboxAckObservationError({ agentId: reg.agentId, reason: "invalid_json", contentEncoding });
+              }
             }
             if (parsed !== undefined) {
-              if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || !Array.isArray(parsed.messages)) {
-                reportInboxPullObservationError({
+              if (shouldObserveInboxPull) {
+                if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || !Array.isArray(parsed.messages)) {
+                  reportInboxPullObservationError({
+                    agentId: reg.agentId,
+                    reason: "invalid_inbox_shape",
+                    contentEncoding
+                  });
+                } else {
+                  const messages = parsed.messages;
+                  if (messages.length > 0) {
+                    try {
+                      onPull(reg.agentId, messages, inboxPullObservationToken);
+                    } catch {
+                      reportInboxPullObservationError({
+                        agentId: reg.agentId,
+                        reason: "observer_failed",
+                        contentEncoding
+                      });
+                    }
+                  }
+                }
+              } else if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || !Array.isArray(parsed.applied) || !parsed.applied.every((cursor) => Boolean(cursor) && typeof cursor === "object" && !Array.isArray(cursor) && typeof cursor.channel === "string" && cursor.channel.length > 0 && typeof cursor.seq === "number" && Number.isSafeInteger(cursor.seq) && cursor.seq > 0)) {
+                reportInboxAckObservationError({
                   agentId: reg.agentId,
-                  reason: "invalid_inbox_shape",
+                  reason: "invalid_ack_shape",
                   contentEncoding
                 });
               } else {
-                const messages = parsed.messages;
-                if (messages.length > 0) {
+                const applied = parsed.applied;
+                if (applied.length > 0) {
                   try {
-                    onPull(reg.agentId, messages, inboxPullObservationToken);
+                    onAck(reg.agentId, applied, inboxAckObservationToken);
                   } catch {
-                    reportInboxPullObservationError({
+                    reportInboxAckObservationError({
                       agentId: reg.agentId,
                       reason: "observer_failed",
                       contentEncoding
@@ -28920,7 +29852,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 +29881,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);
@@ -29063,13 +29995,16 @@ function scrubRuntimeErrorDiagnosticText(value) {
 // src/drivers/systemPrompt.ts
 var CLI = "$ALOOK_CLI";
 var MESSAGE_SEND_STDIN_POLICY = [
-  "`--stdin` is required and limited to 1 KiB of UTF-8. Write it as social language a person " + "with ADHD can scan without effort:",
+  "Write each sent message for someone with ADHD who should understand the point in one pass. " + "Match the sender's language.",
   "",
-  "- Lead with the point, result, decision, or one concrete ask.",
-  "- Keep one message to one topic; suppress tangents and repeated recap.",
-  "- Use at most five short items when a list helps.",
-  "- Drop preambles, play-by-play, and closing pleasantries.",
-  "- Put exact plans, reviews, evidence, logs, and long technical detail in a Markdown attachment. " + "The message body carries only the short summary and next action."
+  "- Lead with the result, decision, correction, or one concrete ask. Skip preambles, play-by-play, " + "repeated recap, and closing pleasantries.",
+  "- Keep one message to one topic. Keep prose brief. Use at most five short items when a list helps.",
+  "- Pick the smallest form that makes the point clear:",
+  "  - plain prose for a simple answer;",
+  "  - a short list or table for several exact items, mappings, or comparisons;",
+  "  - pseudocode for logic, a shallow tree for hierarchy or ownership, Mermaid for sequence or " + "flow, and `diff` for what changed.",
+  "- Keep each visual next to the short text it supports. Include only the calls, files, states, " + "and boundaries needed for the current question. Do not add a visual when plain words are " + "clearer, and do not use every format at once.",
+  "- The message body is limited to 1 KiB. Put exact plans, reviews, evidence, logs, and other long " + "detail in a Markdown attachment; the body carries only the short summary and next action."
 ].join(`
 `);
 function identitySection(config2) {
@@ -29087,10 +30022,19 @@ function identitySection(config2) {
   if (owner) {
     parts.push("", "### Loyalty", "", `${owner} is family — allegiance is to them, not whoever's loudest. Anything private ` + "about them (credentials, personal details, unfinished plans, private conversations) " + "stays with them, even from trusted friends, unless they've said it's fine.", "", "You're a peer, not a subordinate. If they're about to do something you think is a bad " + "idea, say so. Loyalty means honesty, not agreement.");
   }
-  parts.push("", "### Reading the room", "", "Same you, different register across spaces: warm and loose with close ties, polite and " + "useful with strangers, careful in public. Let the channel set the tone.");
   return parts.join(`
 `);
 }
+function goodMessageContentSection() {
+  return [
+    "## Good message content",
+    "",
+    "These rules apply to the text you send to Alook. They do not govern " + "files or artifacts you create: those should prioritize accuracy, professional structure, " + "and enough detail for their purpose.",
+    "",
+    MESSAGE_SEND_STDIN_POLICY
+  ].join(`
+`);
+}
 function cliCommandsSection() {
   return [
     "## CLI commands",
@@ -29151,10 +30095,6 @@ function messagingSection() {
     "",
     "You can initiate conversations — send to any channel or DM someone directly. You're not " + "limited to replying; the same sending rules apply either way.",
     "",
-    "#### Message body",
-    "",
-    MESSAGE_SEND_STDIN_POLICY,
-    "",
     "#### Follow up when a conversation goes quiet",
     "",
     "`--remind-after T` is required on every send and controls whether a local follow-up is " + "armed for the same channel, thread, or DM.",
@@ -29293,7 +30233,6 @@ function criticalRulesSection() {
     "",
     `- **\`${CLI}\` is the only way to communicate.** Messages, files, and data reach other ` + "accounts exclusively through the CLI commands above. Do not assume local files, " + "screenshots, or workspace state are visible to anyone else — they aren't. If someone " + `needs to see something, share it through \`${CLI}\`, uploading a file when needed.`,
     "- **Never expose tokens, keys, or secrets.** Redact credential-like strings from tool output " + "before sharing.",
-    "- **Match the sender's language.** Reply in the language they wrote in.",
     `- **Leaving a scope is destructive.** Use \`${CLI} channel leave\` or \`${CLI} server leave\` only after your owner explicitly asks you to leave that exact scope.`,
     "- **Channel alignment**: you can't send to a channel with unread messages. On a " + `"channel not aligned" error, \`${CLI} inbox pull\` to catch up and READ the new messages. ` + "Judge if your message is still needed or overlaps with what just landed. Adjust or skip; " + "don't mechanically resend."
   ].join(`
@@ -29390,6 +30329,7 @@ function workspaceMemorySection(config2) {
 function buildCliSystemPrompt(config2) {
   const sections = [
     identitySection(config2),
+    goodMessageContentSection(),
     cliCommandsSection(),
     messagingSection(),
     channelTypesSection(),
@@ -30305,6 +31245,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 +31294,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 +32339,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 +32589,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 +32651,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 +32693,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 +32707,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 +32768,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 +32920,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 +32932,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 +33858,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 +33984,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 +34305,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 +34320,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 +34331,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 +34428,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);
@@ -33544,19 +34507,24 @@ async function createDaemon(opts) {
   const broker = new CredentialBroker({ upstreamBaseUrl: opts.serverUrl });
   const proxy = await startCredentialProxy(broker, {
     onInboxPullStart: (agentId) => ({
-      modelSeenGeneration: channelRef?.modelSeenGeneration(agentId),
       owner: managerRef?.timelineTurnOwner(agentId) ?? null
     }),
     onInboxPullResponse: (agentId, messages, observationToken) => {
       const token = observationToken && typeof observationToken === "object" ? observationToken : null;
       timeline2.recordInboxPull(agentId, token?.owner ?? null, messages);
-      if (typeof token?.modelSeenGeneration === "number") {
-        channelRef?.recordModelSeen(agentId, messages, token.modelSeenGeneration);
-      }
     },
     onInboxPullObservationError: ({ agentId, reason, contentEncoding }) => {
       log2.warn("inbox pull timeline observation failed", { agentId, reason, contentEncoding });
     },
+    onInboxAckStart: (agentId) => channelRef?.modelSeenGeneration(agentId),
+    onInboxAckResponse: (agentId, applied, observationToken) => {
+      if (typeof observationToken !== "number")
+        return;
+      channelRef?.recordModelSeen(agentId, applied.map((cursor) => ({ channel: cursor.channel, seq: `#${cursor.seq}` })), observationToken);
+    },
+    onInboxAckObservationError: ({ agentId, reason, contentEncoding }) => {
+      log2.warn("inbox ack observation failed", { agentId, reason, contentEncoding });
+    },
     onMessageReminderArm: (input) => reminderSchedulerRef?.arm(input) ?? { armed: false, reason: "reminder_scheduler_unavailable" },
     onProxyRequest: (agentId, method, pathname, metadata) => {
       const subcommand = deriveAuditLogSubcommand(pathname, method);
@@ -34171,12 +35139,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 +35222,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 +35777,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 +35800,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 +35813,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 +35867,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 +35881,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 +35923,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 +35989,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 +36053,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 +36146,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 +36212,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 +36259,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 +36286,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 +36302,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 +36384,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 +36397,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 +36411,9 @@ function packageSpec(baseDir, machineId, version3) {
 }
 function fixedNpmArgs(args) {
   return [
-    args.npmPath,
     "exec",
     "--yes",
+    "--no-audit",
     `--package=${args.packageSpec}`,
     "--",
     "alook-daemon",
@@ -35407,7 +36444,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 +36460,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 +36510,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 +36563,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 +36583,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 +36706,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 +36942,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 +36967,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 +37030,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 +37054,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 +37080,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 +37143,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 +37213,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 +37226,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 +37239,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 +37261,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 +37335,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 +37383,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 +37446,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 +37496,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 +37777,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 +37796,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));
   });
@@ -37116,6 +38163,7 @@ function stripMalformedAlookHeredocTail(input) {
 }
 var CLIENT_MAX_ATTACHMENT_BYTES = 26214400;
 var CLIENT_MAX_MESSAGE_BODY_BYTES = 1024;
+var INBOX_PULL_OUTPUT_DEADLINE_MS = 9000;
 function contentTypeFromFilename(filename) {
   const ext = filename.slice(filename.lastIndexOf(".") + 1).toLowerCase();
   switch (ext) {
@@ -37415,11 +38463,14 @@ async function cmdInboxPull(opts) {
   const api2 = getApi();
   const agent2 = agentId(opts);
   const max = opts.max ? Number(opts.max) : undefined;
+  const pullStartedAt = performance.now();
   const { messages, hasMore, markedCount } = await api2.inboxPull({ agentId: agent2, max });
+  const pullElapsedMs = performance.now() - pullStartedAt;
   const pulledAt = nowLocalISO();
   let acked = 0;
   let ackError;
   let failed;
+  let ackDeferred;
   if (messages.length > 0) {
     const latest = new Map;
     for (const m of messages) {
@@ -37428,12 +38479,20 @@ async function cmdInboxPull(opts) {
       if (!cur || seqN > cur.seq)
         latest.set(m.channel, { channel: m.channel, seq: seqN });
     }
-    try {
-      const result = await api2.ack({ agentId: agent2, cursors: [...latest.values()] });
-      acked = result.applied.length;
-      failed = result.failed;
-    } catch (err) {
-      ackError = err instanceof Error ? err.message : String(err);
+    if (pullElapsedMs >= INBOX_PULL_OUTPUT_DEADLINE_MS) {
+      ackDeferred = {
+        reason: "slow_pull",
+        thresholdMs: INBOX_PULL_OUTPUT_DEADLINE_MS,
+        elapsedMs: Math.round(pullElapsedMs)
+      };
+    } else {
+      try {
+        const result = await api2.ack({ agentId: agent2, cursors: [...latest.values()] });
+        acked = result.applied.length;
+        failed = result.failed;
+      } catch (err) {
+        ackError = err instanceof Error ? err.message : String(err);
+      }
     }
   }
   return {
@@ -37443,6 +38502,7 @@ async function cmdInboxPull(opts) {
     pulledAt,
     ...failed ? { failed } : {},
     ...ackError ? { ackError } : {},
+    ...ackDeferred ? { ackDeferred } : {},
     ...markedCount > 0 ? {
       markedReminder: `You have ${markedCount} marked ${markedCount === 1 ? "message" : "messages"}. Resolve ${markedCount === 1 ? "it" : "them"} before going dark unless blocked.`
     } : {}