@alook/daemon 0.1.2 → 0.1.4

package/dist/index.js

@@ -3783,6 +3783,24 @@ function formatData(data) {
   }
   return " " + parts.join(" ");
 }
+function recordFields(data) {
+  const fields = {};
+  let positional = 0;
+  for (const value of data) {
+    if (value instanceof Error) {
+      fields.error = value.message;
+      continue;
+    }
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      for (const [key, entry] of Object.entries(value)) {
+        fields[key] = entry;
+      }
+      continue;
+    }
+    fields[`arg${positional++}`] = value;
+  }
+  return fields;
+}
 function createLogger(options = {}) {
   const header = options.header ?? DEFAULT_HEADER;
   const minRank = LEVEL_RANK[options.level ?? envLevel() ?? "info"];
@@ -3791,10 +3809,15 @@ function createLogger(options = {}) {
 `));
   const err = options.err ?? ((line) => process.stderr.write(line + `
 `));
+  const record = options.record;
   const emit = (level, message, data) => {
     if (LEVEL_RANK[level] < minRank)
       return;
-    const line = `${now()} ${header} ${level.toUpperCase().padEnd(5)} ${message}${formatData(data)}`;
+    const time = now();
+    const line = `${time} ${header} ${level.toUpperCase().padEnd(5)} ${message}${formatData(data)}`;
+    try {
+      record?.({ time, header, level, message, fields: recordFields(data) });
+    } catch {}
     (level === "warn" || level === "error" ? err : out)(line);
   };
   return {
@@ -3827,6 +3850,51 @@ function nowLocalISO() {
 }
 
 // src/manager/managerRuntime.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+function normalizeTerminationCause(value) {
+  return value === "runtime_error" || value === "killed_stalled" ? value : "other";
+}
+function normalizeAbortCause(value) {
+  switch (value) {
+    case "start_threw":
+    case "start_rejected":
+    case "send_threw":
+    case "spawn_failure":
+    case "handshake_timeout":
+    case "reset":
+    case "nap":
+    case "model_switch":
+    case "requested_stop":
+    case "shutdown":
+    case "physical_exit":
+    case "terminate_stalled":
+    case "force_exit":
+      return value;
+    default:
+      return "other";
+  }
+}
+function normalizeSpawnFailureReason(value) {
+  switch (value) {
+    case "ENOENT":
+    case "handshake_timeout":
+    case "pre_handshake_exit":
+    case "spawn_threw":
+      return value;
+    default:
+      return "other";
+  }
+}
+function normalizeTerminationSemantics(value) {
+  switch (value) {
+    case "killed_stalled":
+    case "idle_stop":
+    case "force_exit":
+      return value;
+    default:
+      return "other";
+  }
+}
 var THINKING_MAX_BYTES = 4096;
 var STDERR_LOG_MAX_LEN = 2000;
 var AUDIT_ERROR_MESSAGE_MAX_LEN = 2000;
@@ -4015,6 +4083,9 @@ class AgentProcessManager {
   liveSessions = new Map;
   thinkingBuffers = new Map;
   activeSpawnState = new Map;
+  traceProcessNonce = randomUUID4();
+  nextSpawnOrdinal = 1;
+  nextDaemonTurnOrdinal = 1;
   nonCleanEndMarker = new Map;
   opts;
   tickTimer = null;
@@ -4076,6 +4147,7 @@ class AgentProcessManager {
       rewakePrompt: opts.rewakePrompt,
       forgetSession: true,
       barrierType: opts.barrierType ?? "reset_session",
+      abortCause: opts.barrierType === "nap" ? "nap" : "reset",
       opName: "reset"
     });
   }
@@ -4083,6 +4155,7 @@ class AgentProcessManager {
     this.register(agentId, { runtimeConfig: opts.runtimeConfig, launchId: opts.launchId });
     if (opts.forgetSession)
       this.forgetSession(agentId, opts.barrierType ?? "reset_session");
+    this.abortCurrentTurn(agentId, opts.abortCause);
     this.markResetting(agentId);
     const status = this.state.agents[agentId]?.status;
     if (status === "idle") {
@@ -4107,6 +4180,7 @@ class AgentProcessManager {
       launchId: opts.launchId,
       rewakePrompt: opts.rewakePrompt,
       forgetSession: false,
+      abortCause: "model_switch",
       opName: "model switch"
     });
   }
@@ -4120,6 +4194,7 @@ class AgentProcessManager {
     const session = this.sessions.get(agentId);
     if (!session)
       return;
+    this.abortCurrentTurn(agentId, "requested_stop");
     await Promise.resolve(session.stop({ reason: "requested", forceAfterMs: SESSION_STOP_GRACE_MS }));
     this.sessions.delete(agentId);
   }
@@ -4128,7 +4203,10 @@ class AgentProcessManager {
       clearInterval(this.tickTimer);
       this.tickTimer = null;
     }
-    await Promise.all([...this.sessions.values()].map((s) => Promise.resolve(s.stop({ reason: "shutdown", forceAfterMs: SESSION_STOP_GRACE_MS }))));
+    const entries = [...this.sessions.entries()];
+    for (const [agentId] of entries)
+      this.abortCurrentTurn(agentId, "shutdown");
+    await Promise.all(entries.map(([, session]) => Promise.resolve(session.stop({ reason: "shutdown", forceAfterMs: SESSION_STOP_GRACE_MS }))));
     this.sessions.clear();
   }
   snapshot() {
@@ -4168,19 +4246,95 @@ class AgentProcessManager {
       stoppingSince: a.stoppingSince
     }));
   }
-  dispatch(event) {
+  emitTrace(rec) {
+    if (!this.opts.onFsmTransition)
+      return;
+    try {
+      this.opts.onFsmTransition(rec);
+    } catch {}
+  }
+  traceOwnerFor(agentId, captured) {
+    if (captured)
+      return captured.agentId === agentId ? captured : undefined;
+    const owner = this.activeSpawnState.get(agentId);
+    return owner && this.sessions.get(agentId) === owner.session ? owner : undefined;
+  }
+  openTurn(owner) {
+    if (owner.activeSpan)
+      return owner.activeSpan;
+    const daemonTurnOrdinal = this.nextDaemonTurnOrdinal++;
+    const span = {
+      traceTurnId: `${owner.launchIdSnapshot ?? this.traceProcessNonce}:${daemonTurnOrdinal}`,
+      daemonTurnOrdinal,
+      spawnOrdinal: owner.spawnOrdinal,
+      turnOrdinal: owner.nextTurnOrdinal++,
+      launchIdSnapshot: owner.launchIdSnapshot
+    };
+    owner.activeSpan = span;
+    const nowMs = this.now();
+    this.emitTrace({
+      recordKind: "turn_span",
+      agentId: owner.agentId,
+      event: "turn_begin",
+      ...span,
+      effects: [],
+      nowMs,
+      timeIso: new Date(nowMs).toISOString()
+    });
+    return span;
+  }
+  closeTurn(owner, expectedSpan, close) {
+    if (!expectedSpan || owner.activeSpan !== expectedSpan)
+      return false;
+    owner.activeSpan = null;
+    const nowMs = this.now();
+    const base = {
+      recordKind: "turn_span",
+      agentId: owner.agentId,
+      ...expectedSpan,
+      effects: [],
+      nowMs,
+      timeIso: new Date(nowMs).toISOString()
+    };
+    if (close.event === "turn_end") {
+      this.emitTrace({
+        ...base,
+        event: "turn_end",
+        outcome: close.outcome,
+        ...close.terminationCause ? { terminationCause: close.terminationCause } : {}
+      });
+    } else {
+      this.emitTrace({
+        ...base,
+        event: "turn_abort",
+        abortCause: normalizeAbortCause(close.abortCause)
+      });
+    }
+    return true;
+  }
+  abortCurrentTurn(agentId, cause) {
+    const owner = this.traceOwnerFor(agentId);
+    if (owner)
+      this.closeTurn(owner, owner.activeSpan, { event: "turn_abort", abortCause: cause });
+  }
+  dispatch(event, capturedOwner) {
     const before = this.deriveActivitySnapshot(this.state);
     const { state, effects } = reduceManager(this.state, event);
     this.state = state;
+    const eventAgentId = event.agentId;
+    const closingOwner = event.type === "turn_end" && eventAgentId ? this.traceOwnerFor(eventAgentId, capturedOwner) : undefined;
+    const closingSpan = closingOwner?.activeSpan ?? null;
     if (this.opts.onFsmTransition) {
-      const nowMs = this.now();
-      const emit = (agentId2) => {
-        const a = this.state.agents[agentId2];
+      const emit = (agentId) => {
+        const a = this.state.agents[agentId];
         if (!a)
           return;
-        const myEffects = effects.filter((e) => e.agentId === agentId2).map((e) => e.type);
-        this.opts.onFsmTransition({
-          agentId: agentId2,
+        const nowMs = this.now();
+        const activeSpan = this.traceOwnerFor(agentId, capturedOwner)?.activeSpan ?? null;
+        const myEffects = effects.filter((e) => e.agentId === agentId).map((e) => e.type);
+        this.emitTrace({
+          recordKind: "fsm",
+          agentId,
           event: event.type,
           status: a.status,
           turnActive: a.turnActive,
@@ -4194,31 +4348,43 @@ class AgentProcessManager {
           apmPhase: a.apm.phase,
           effects: myEffects,
           nowMs,
+          timeIso: new Date(nowMs).toISOString(),
+          ...activeSpan ? activeSpan : {},
           sinceProgressMs: nowMs - a.lastProgressAt,
           sinceDeliverMs: a.lastDeliverAt === null ? null : nowMs - a.lastDeliverAt,
           sinceStoppingMs: a.stoppingSince === null ? null : nowMs - a.stoppingSince,
           ...event.type === "turn_end" && event.endReason === "errored" ? {
             endReason: "errored",
-            terminationCause: event.terminationCause,
-            errorDetail: event.errorDetail
+            terminationCause: normalizeTerminationCause(event.terminationCause)
           } : {},
           ...event.type === "exit" ? {
             exitCode: event.exitCode ?? null,
             exitSignal: event.exitSignal ?? null,
             abnormal: event.abnormal ?? false,
-            ...event.spawnFailureReason != null ? { spawnFailureReason: event.spawnFailureReason } : {},
-            ...event.terminationSemantics != null ? { terminationSemantics: event.terminationSemantics } : {}
+            ...event.spawnFailureReason != null ? {
+              spawnFailureReason: normalizeSpawnFailureReason(event.spawnFailureReason)
+            } : {},
+            ...event.terminationSemantics != null ? {
+              terminationSemantics: normalizeTerminationSemantics(event.terminationSemantics)
+            } : {}
           } : {}
         });
       };
-      const agentId = event.agentId;
-      if (agentId) {
-        emit(agentId);
+      if (eventAgentId) {
+        emit(eventAgentId);
       } else if (event.type === "tick") {
         for (const id of Object.keys(this.state.agents))
           emit(id);
       }
     }
+    if (closingOwner && closingSpan) {
+      const errored = event.endReason === "errored";
+      this.closeTurn(closingOwner, closingSpan, errored ? {
+        event: "turn_end",
+        outcome: "errored",
+        terminationCause: normalizeTerminationCause(event.terminationCause)
+      } : { event: "turn_end", outcome: "clean" });
+    }
     for (const effect of effects)
       this.applyEffect(effect);
     if (this.opts.onAgentActivity) {
@@ -4257,15 +4423,37 @@ ${this.opts.wakePromptFooter}` : text;
         break;
       case "send": {
         const session = this.sessions.get(effect.agentId);
-        session?.send({ text: this.stampNow(this.withFooter(effect.text)), mode: effect.mode });
+        const input = { text: this.stampNow(this.withFooter(effect.text)), mode: effect.mode };
+        if (session) {
+          const owner = this.activeSpawnState.get(effect.agentId);
+          const exactOwner = owner?.session === session ? owner : undefined;
+          const associatedSpan = exactOwner ? effect.mode === "idle" ? this.openTurn(exactOwner) : exactOwner.activeSpan : null;
+          try {
+            session.send(input);
+          } catch (error) {
+            if (exactOwner) {
+              this.closeTurn(exactOwner, associatedSpan, {
+                event: "turn_abort",
+                abortCause: "send_threw"
+              });
+            }
+            throw error;
+          }
+        }
         this.log.info("steering message sent to running agent", { agentId: effect.agentId, mode: effect.mode });
         break;
       }
       case "stop":
       case "terminate_stalled": {
         const session = this.sessions.get(effect.agentId);
-        Promise.resolve(session?.stop({ reason: effect.type, forceAfterMs: SESSION_STOP_GRACE_MS }));
         const spawnState = this.activeSpawnState.get(effect.agentId);
+        if (effect.type === "terminate_stalled" && spawnState) {
+          this.closeTurn(spawnState, spawnState.activeSpan, {
+            event: "turn_abort",
+            abortCause: "terminate_stalled"
+          });
+        }
+        Promise.resolve(session?.stop({ reason: effect.type, forceAfterMs: SESSION_STOP_GRACE_MS }));
         if (spawnState)
           spawnState.suppressExitLog = true;
         if (effect.type === "terminate_stalled") {
@@ -4281,6 +4469,12 @@ ${this.opts.wakePromptFooter}` : text;
       case "force_exit": {
         const session = this.sessions.get(effect.agentId);
         const state = this.activeSpawnState.get(effect.agentId);
+        if (state) {
+          this.closeTurn(state, state.activeSpan, {
+            event: "turn_abort",
+            abortCause: "force_exit"
+          });
+        }
         if (session) {
           Promise.resolve(session.stop({ reason: effect.reason, forceAfterMs: SESSION_STOP_GRACE_MS })).catch(() => {});
         } else if (state?.pid != null) {
@@ -4355,7 +4549,23 @@ ${this.opts.wakePromptFooter}` : text;
     const rawLineSink = this.opts.onRuntimeRawLine;
     const session = this.opts.sessionFactory ? this.opts.sessionFactory({ agentId, driver, ctx }) : driver.createSession ? new SdkManagedSession(driver, ctx, this.opts.sdkDriverDepsFor(ctx)) : createChildProcessRuntimeSession(driver, ctx, rawLineSink ? { onRawStdoutLine: (line) => rawLineSink(agentId, line) } : undefined);
     this.sessions.set(agentId, session);
-    const state = { hasEstablished: false, hasReportedSpawnFailure: false, suppressExitLog: false, handshakeTimer: null, torndown: false, superseded: false, pid: null, spawnFailureReason: null, terminationSemantics: null };
+    const state = {
+      agentId,
+      session,
+      hasEstablished: false,
+      hasReportedSpawnFailure: false,
+      suppressExitLog: false,
+      handshakeTimer: null,
+      torndown: false,
+      superseded: false,
+      pid: null,
+      spawnFailureReason: null,
+      terminationSemantics: null,
+      spawnOrdinal: this.nextSpawnOrdinal++,
+      launchIdSnapshot: typeof ctx.launchId === "string" && ctx.launchId.length > 0 ? ctx.launchId : null,
+      nextTurnOrdinal: 1,
+      activeSpan: null
+    };
     this.activeSpawnState.set(agentId, state);
     const clearHandshakeTimer = () => {
       if (state.handshakeTimer) {
@@ -4367,6 +4577,10 @@ ${this.opts.wakePromptFooter}` : text;
       if (state.hasEstablished || state.hasReportedSpawnFailure)
         return;
       state.hasReportedSpawnFailure = true;
+      this.closeTurn(state, state.activeSpan, {
+        event: "turn_abort",
+        abortCause: opts?.scope === "handshake_timeout" ? "handshake_timeout" : "spawn_failure"
+      });
       state.spawnFailureReason = reason;
       this.log.warn("spawn failed", { agentId, runtime: driver.id, reason });
       this.opts.onRuntimeSpawnFailed?.(driver.id, reason);
@@ -4381,7 +4595,7 @@ ${this.opts.wakePromptFooter}` : text;
       if (e?.kind === "turn_end" && driver.lifecycle.kind === "per_turn") {
         state.suppressExitLog = true;
       }
-      this.onRuntimeEvent(agentId, e, driver.id, state.superseded);
+      this.onRuntimeEvent(agentId, e, driver.id, state);
     });
     session.on("stderr", (...args) => {
       const raw = typeof args[0] === "string" ? args[0] : String(args[0] ?? "");
@@ -4398,6 +4612,10 @@ ${this.opts.wakePromptFooter}` : text;
       if (state.torndown)
         return;
       state.torndown = true;
+      this.closeTurn(state, state.activeSpan, {
+        event: "turn_abort",
+        abortCause: "physical_exit"
+      });
       const info = args[0];
       reportSpawnFailure("pre_handshake_exit");
       const exitCode = typeof info?.code === "number" ? info.code : null;
@@ -4417,14 +4635,22 @@ ${this.opts.wakePromptFooter}` : text;
         this.activeSpawnState.delete(agentId);
         this.nonCleanEndMarker.delete(agentId);
       }
-      this.dispatch({ type: "exit", agentId, exitCode, exitSignal, abnormal, spawnFailureReason: state.spawnFailureReason, terminationSemantics: state.terminationSemantics });
+      this.dispatch({ type: "exit", agentId, exitCode, exitSignal, abnormal, spawnFailureReason: state.spawnFailureReason, terminationSemantics: state.terminationSemantics }, state);
     });
     const stampedPrompt = this.stampNow(prompt);
-    Promise.resolve(session.start({ text: stampedPrompt, sessionId: ctx.config.sessionId })).then(() => {
+    const startedSpan = this.openTurn(state);
+    let startResult;
+    try {
+      startResult = Promise.resolve(session.start({ text: stampedPrompt, sessionId: ctx.config.sessionId }));
+    } catch (error) {
+      this.closeTurn(state, startedSpan, { event: "turn_abort", abortCause: "start_threw" });
+      throw error;
+    }
+    startResult.then(() => {
       if (this.sessions.get(agentId) !== session)
         return;
       state.pid = session.pid ?? null;
-      this.dispatch({ type: "spawned", agentId, nowMs: this.now() });
+      this.dispatch({ type: "spawned", agentId, nowMs: this.now() }, state);
       if (state.hasEstablished || state.hasReportedSpawnFailure)
         return;
       state.handshakeTimer = setTimeout(() => {
@@ -4433,6 +4659,10 @@ ${this.opts.wakePromptFooter}` : text;
           return;
         if (this.sessions.get(agentId) !== session)
           return;
+        this.closeTurn(state, state.activeSpan, {
+          event: "turn_abort",
+          abortCause: "handshake_timeout"
+        });
         reportSpawnFailure("handshake_timeout", {
           scope: "handshake_timeout",
           message: `No response ${Math.round(this.opts.handshakeTimeoutMs / 1000)}s after launch — the runtime may be misconfigured (e.g. an invalid model).`
@@ -4444,14 +4674,18 @@ ${this.opts.wakePromptFooter}` : text;
         this.liveSessions.delete(agentId);
         if (this.activeSpawnState.get(agentId) === state)
           this.activeSpawnState.delete(agentId);
-        this.dispatch({ type: "exit", agentId, spawnFailureReason: state.spawnFailureReason });
+        this.dispatch({ type: "exit", agentId, spawnFailureReason: state.spawnFailureReason }, state);
       }, this.opts.handshakeTimeoutMs);
     }).catch((err) => {
+      this.closeTurn(state, startedSpan, {
+        event: "turn_abort",
+        abortCause: "start_rejected"
+      });
       const code = err?.code ?? "spawn_threw";
       reportSpawnFailure(String(code));
       if (this.sessions.get(agentId) === session)
         this.sessions.delete(agentId);
-      this.dispatch({ type: "exit", agentId, spawnFailureReason: state.spawnFailureReason });
+      this.dispatch({ type: "exit", agentId, spawnFailureReason: state.spawnFailureReason }, state);
     });
   }
   currentModelFor(agentId) {
@@ -4493,10 +4727,12 @@ ${this.opts.wakePromptFooter}` : text;
       this.log.debug("audit emit failed (thinking)", { agentId, err: String(err) });
     }
   }
-  onRuntimeEvent(agentId, e, runtimeId, sessionSuperseded) {
+  onRuntimeEvent(agentId, e, runtimeId, ownerOrSuperseded) {
     const ev = e;
     if (!ev?.kind)
       return;
+    const owner = typeof ownerOrSuperseded === "boolean" ? undefined : ownerOrSuperseded;
+    const sessionSuperseded = typeof ownerOrSuperseded === "boolean" ? ownerOrSuperseded : ownerOrSuperseded.superseded;
     if (ev.kind === "error" && !sessionSuperseded) {
       this.emitErrorAudit(agentId, "runtime", "runtime_error", ev.message ?? "Runtime error");
       if (this.nonCleanEndMarker.get(agentId)?.cause !== "killed_stalled") {
@@ -4538,7 +4774,7 @@ ${this.opts.wakePromptFooter}` : text;
       }
     }
     if (ev.kind === "session_init" && ev.sessionId) {
-      this.dispatch({ type: "session", agentId, sessionId: ev.sessionId });
+      this.dispatch({ type: "session", agentId, sessionId: ev.sessionId }, owner);
       this.liveSessions.set(agentId, ev.sessionId);
       this.opts.timeline?.setSession(agentId, ev.sessionId);
       this.opts.onAgentSession?.({
@@ -4552,9 +4788,9 @@ ${this.opts.wakePromptFooter}` : text;
       this.opts.timeline?.appendResponseToLatest(agentId, ev.text);
     }
     if (ev.kind !== "internal_progress" && ev.kind !== "error") {
-      this.dispatch({ type: "progress", agentId, nowMs: this.now() });
+      this.dispatch({ type: "progress", agentId, nowMs: this.now() }, owner);
     }
-    this.dispatch({ type: "runtime_signal", agentId, kind: ev.kind, nowMs: this.now() });
+    this.dispatch({ type: "runtime_signal", agentId, kind: ev.kind, nowMs: this.now() }, owner);
     if (ev.kind === "turn_end") {
       this.logSessionEnded(agentId, "turn_end");
       const marker = this.nonCleanEndMarker.get(agentId);
@@ -4566,7 +4802,7 @@ ${this.opts.wakePromptFooter}` : text;
         endReason: "errored",
         terminationCause: marker.cause,
         errorDetail: marker.detail
-      } : { type: "turn_end", agentId, nowMs: this.now() });
+      } : { type: "turn_end", agentId, nowMs: this.now() }, owner);
     }
   }
 }
@@ -5174,21 +5410,50 @@ function joinPath(basePath, reqUrl) {
 }
 // src/daemon/createDaemon.ts
 import { homedir as homedir3 } from "os";
-import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync6 } from "node:fs";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync6 } from "node:fs";
 
 // src/util/rotatingFileSink.ts
-import { appendFileSync, chmodSync, statSync, renameSync, existsSync as existsSync5 } from "node:fs";
+import {
+  appendFileSync,
+  chmodSync,
+  closeSync,
+  constants,
+  existsSync as existsSync5,
+  fstatSync,
+  lstatSync as lstatSync2,
+  openSync,
+  renameSync,
+  statSync,
+  unlinkSync as unlinkSync3
+} from "node:fs";
 function createRotatingFileSink(path8, maxBytes, opts = {}) {
   const report = (operation, error) => {
     try {
       opts.onError?.({ operation, error });
     } catch {}
   };
-  const secureActive = () => {
-    if (opts.mode === undefined || !existsSync5(path8))
+  const secureGeneration = (filePath) => {
+    if (!existsSync5(filePath))
       return true;
     try {
-      chmodSync(path8, opts.mode);
+      const stat = lstatSync2(filePath);
+      if (!stat.isFile()) {
+        if (opts.mode === undefined && !opts.hardMaxBytes)
+          return true;
+        report("unsafe_generation", new Error("log generation is not a regular file"));
+        return false;
+      }
+      if (opts.mode !== undefined)
+        chmodSync(filePath, opts.mode);
+      if (opts.hardMaxBytes && maxBytes > 0 && stat.size > maxBytes) {
+        try {
+          unlinkSync3(filePath);
+        } catch (error) {
+          report("oversize_generation", error);
+          return false;
+        }
+        report("oversize_generation", new Error(`removed generation larger than ${maxBytes} bytes`));
+      }
       return true;
     } catch (error) {
       report("chmod", error);
@@ -5198,6 +5463,8 @@ function createRotatingFileSink(path8, maxBytes, opts = {}) {
   const rotate = () => {
     try {
       renameSync(path8, `${path8}.1`);
+      if (opts.mode !== undefined)
+        chmodSync(`${path8}.1`, opts.mode);
       return true;
     } catch (error) {
       report("rotate", error);
@@ -5212,31 +5479,86 @@ function createRotatingFileSink(path8, maxBytes, opts = {}) {
       return null;
     }
   };
-  return {
+  const sink = {
+    secure() {
+      return secureGeneration(`${path8}.1`) && secureGeneration(path8);
+    },
     write(line) {
       try {
-        if (!secureActive())
+        if (!sink.secure())
           return;
         const serialized = line + `
 `;
+        const serializedBytes = Buffer.byteLength(serialized, "utf8");
+        if (opts.hardMaxBytes && maxBytes > 0 && serializedBytes > maxBytes) {
+          report("oversize", new Error(`record exceeds ${maxBytes} bytes`));
+          return;
+        }
         const measuredBytes = currentSize();
         if (measuredBytes === null && opts.hardMaxBytes)
           return;
         const currentBytes = measuredBytes ?? 0;
-        const shouldRotate = maxBytes > 0 && (opts.hardMaxBytes ? currentBytes > 0 && currentBytes + Buffer.byteLength(serialized, "utf8") > maxBytes : currentBytes >= maxBytes);
+        const shouldRotate = maxBytes > 0 && (opts.hardMaxBytes ? currentBytes > 0 && currentBytes + serializedBytes > maxBytes : currentBytes >= maxBytes);
         if (shouldRotate && !rotate() && opts.hardMaxBytes)
           return;
         appendFileSync(path8, serialized, opts.mode === undefined ? undefined : { mode: opts.mode });
       } catch (error) {
         report("append", error);
       }
+    },
+    openSnapshot() {
+      const files = [];
+      try {
+        for (const candidate of [`${path8}.1`, path8]) {
+          if (!existsSync5(candidate))
+            continue;
+          if (!secureGeneration(candidate))
+            continue;
+          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())
+              throw new Error("snapshot source is not a regular file");
+            files.push({ path: candidate, fd, size: stat.size });
+          } catch (error) {
+            closeSync(fd);
+            throw error;
+          }
+        }
+      } catch (error) {
+        for (const file of files) {
+          try {
+            closeSync(file.fd);
+          } catch {}
+        }
+        report("snapshot", error);
+        return { files: [], close: () => {} };
+      }
+      let closed = false;
+      return {
+        files,
+        close() {
+          if (closed)
+            return;
+          closed = true;
+          for (const file of files) {
+            try {
+              closeSync(file.fd);
+            } catch {}
+          }
+        }
+      };
     }
   };
+  return sink;
 }
 
 // src/util/traceSampler.ts
 var SAMPLEABLE_EVENTS = new Set(["tick", "progress", "runtime_signal"]);
+var SACRED_TURN_SPAN_EVENTS = new Set(["turn_begin", "turn_end", "turn_abort"]);
 var DEFAULT_TRACE_SAMPLE_MS = 30000;
+var DEFAULT_TRACE_FILE_MAX_BYTES = 32 * 1024 * 1024;
 function newAgentState() {
   return {
     lastTickKey: null,
@@ -5290,6 +5612,11 @@ function createTraceSampler(emit, throttleMs = DEFAULT_TRACE_SAMPLE_MS) {
       }
       const s = stateFor(agentId);
       const event = rec.event;
+      if (rec.recordKind === "turn_span" && SACRED_TURN_SPAN_EVENTS.has(String(event))) {
+        flushPending(s);
+        emit(rec);
+        return;
+      }
       if (!SAMPLEABLE_EVENTS.has(event) || hasEffects(rec)) {
         flushPending(s);
         if (event === "tick") {
@@ -19632,152 +19959,2382 @@ function formatHandle(name, discriminator) {
   return `${name}#${discriminator}`;
 }
 
-// ../shared/src/community-cli-contract.ts
-var HostCommandSchema = exports_external.discriminatedUnion("type", [
-  exports_external.object({
-    type: exports_external.literal("agent:wake"),
-    agentId: exports_external.string().min(1),
-    config: exports_external.unknown(),
-    sessionId: exports_external.string().optional(),
-    launchId: exports_external.string().min(1),
-    unreadNotice: exports_external.unknown()
-  }),
-  exports_external.object({
-    type: exports_external.literal("agent:stop"),
-    agentId: exports_external.string().min(1)
-  }),
-  exports_external.object({
-    type: exports_external.literal("agent:reset"),
-    agentId: exports_external.string().min(1),
-    config: exports_external.unknown(),
-    launchId: exports_external.string().min(1)
-  }),
-  exports_external.object({
-    type: exports_external.literal("agent:nap"),
-    agentId: exports_external.string().min(1),
-    config: exports_external.unknown(),
-    launchId: exports_external.string().min(1),
-    handoff: exports_external.string().min(1)
-  }),
-  exports_external.object({
-    type: exports_external.literal("agent:model_switch"),
-    agentId: exports_external.string().min(1),
-    config: exports_external.unknown(),
-    launchId: exports_external.string().min(1)
-  }),
-  exports_external.object({
-    type: exports_external.literal("machine:reset_all"),
-    resets: exports_external.array(exports_external.object({
-      agentId: exports_external.string().min(1),
-      config: exports_external.unknown(),
-      launchId: exports_external.string().min(1)
-    }))
-  }),
-  exports_external.object({
-    type: exports_external.literal("bot:added"),
-    botId: exports_external.string().min(1),
-    name: exports_external.string().optional(),
-    discriminator: exports_external.string().optional(),
-    description: exports_external.string().optional(),
-    ownerName: exports_external.string().optional(),
-    ownerDiscriminator: exports_external.string().optional()
-  }),
-  exports_external.object({
-    type: exports_external.literal("bot:updated"),
-    botId: exports_external.string().min(1),
-    name: exports_external.string().optional(),
-    discriminator: exports_external.string().optional(),
-    description: exports_external.string().optional(),
-    ownerName: exports_external.string().optional(),
-    ownerDiscriminator: exports_external.string().optional()
-  }),
-  exports_external.object({
-    type: exports_external.literal("bot:removed"),
-    botId: exports_external.string().min(1)
-  })
-]);
-// src/server/wsControlChannel.ts
-var DEFAULT_PING_INTERVAL_MS = 15000;
-var DEFAULT_PONG_TIMEOUT_MS = 30000;
-var DEFAULT_RECONNECT_BASE_MS = 500;
-var DEFAULT_RECONNECT_MAX_MS = 30000;
-function describeErr(err) {
-  return err instanceof Error ? err.message : String(err);
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/entity.js
+var entityKind = Symbol.for("drizzle:entityKind");
+var hasOwnEntityKind = Symbol.for("drizzle:hasOwnEntityKind");
+function is(value, type) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (value instanceof type) {
+    return true;
+  }
+  if (!Object.prototype.hasOwnProperty.call(type, entityKind)) {
+    throw new Error(`Class "${type.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`);
+  }
+  let cls = Object.getPrototypeOf(value).constructor;
+  if (cls) {
+    while (cls) {
+      if (entityKind in cls && cls[entityKind] === type[entityKind]) {
+        return true;
+      }
+      cls = Object.getPrototypeOf(cls);
+    }
+  }
+  return false;
 }
 
-class WsControlChannel {
-  opts;
-  statusValue = "idle";
-  commandCbs = [];
-  resyncHooks = [];
-  ws = null;
-  attempt = 0;
-  closedByUser = false;
-  authRejected = false;
-  pingTimer = null;
-  pongDeadline = 0;
-  resyncProvider = null;
-  log;
-  constructor(opts) {
-    this.opts = opts;
-    this.log = opts.logger ?? createLogger({ header: "@alook/daemon:ws" });
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/column.js
+class Column {
+  constructor(table, config2) {
+    this.table = table;
+    this.config = config2;
+    this.name = config2.name;
+    this.keyAsName = config2.keyAsName;
+    this.notNull = config2.notNull;
+    this.default = config2.default;
+    this.defaultFn = config2.defaultFn;
+    this.onUpdateFn = config2.onUpdateFn;
+    this.hasDefault = config2.hasDefault;
+    this.primary = config2.primaryKey;
+    this.isUnique = config2.isUnique;
+    this.uniqueName = config2.uniqueName;
+    this.uniqueType = config2.uniqueType;
+    this.dataType = config2.dataType;
+    this.columnType = config2.columnType;
+    this.generated = config2.generated;
+    this.generatedIdentity = config2.generatedIdentity;
+  }
+  static [entityKind] = "Column";
+  name;
+  keyAsName;
+  primary;
+  notNull;
+  default;
+  defaultFn;
+  onUpdateFn;
+  hasDefault;
+  isUnique;
+  uniqueName;
+  uniqueType;
+  dataType;
+  columnType;
+  enumValues = undefined;
+  generated = undefined;
+  generatedIdentity = undefined;
+  config;
+  mapFromDriverValue(value) {
+    return value;
   }
-  get status() {
-    return this.statusValue;
+  mapToDriverValue(value) {
+    return value;
   }
-  connect() {
-    this.closedByUser = false;
-    this.authRejected = false;
-    this.openSocket();
+  shouldDisableInsert() {
+    return this.config.generated !== undefined && this.config.generated.type !== "byDefault";
   }
-  close() {
-    this.closedByUser = true;
-    this.clearHeartbeat();
-    this.ws?.close();
-    this.ws = null;
-    this.statusValue = "closed";
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/column-builder.js
+class ColumnBuilder {
+  static [entityKind] = "ColumnBuilder";
+  config;
+  constructor(name, dataType, columnType) {
+    this.config = {
+      name,
+      keyAsName: name === "",
+      notNull: false,
+      default: undefined,
+      hasDefault: false,
+      primaryKey: false,
+      isUnique: false,
+      uniqueName: undefined,
+      uniqueType: undefined,
+      dataType,
+      columnType,
+      generated: undefined
+    };
   }
-  onCommand(cb) {
-    this.commandCbs.push(cb);
+  $type() {
+    return this;
   }
-  onResync(provider) {
-    this.resyncProvider = provider;
+  notNull() {
+    this.config.notNull = true;
+    return this;
   }
-  onOpen(hook) {
-    this.resyncHooks.push(hook);
+  default(value) {
+    this.config.default = value;
+    this.config.hasDefault = true;
+    return this;
   }
-  async reportReady(ready) {
-    this.sendFrame({ type: "ready", ...ready });
+  $defaultFn(fn) {
+    this.config.defaultFn = fn;
+    this.config.hasDefault = true;
+    return this;
   }
-  sendReady(ready) {
-    this.sendFrame({ type: "ready", ...ready });
+  $default = this.$defaultFn;
+  $onUpdateFn(fn) {
+    this.config.onUpdateFn = fn;
+    this.config.hasDefault = true;
+    return this;
   }
-  async reportAgentSession(info) {
-    this.sendFrame({ type: "agent_session", ...info });
+  $onUpdate = this.$onUpdateFn;
+  primaryKey() {
+    this.config.primaryKey = true;
+    this.config.notNull = true;
+    return this;
   }
-  async reportAgentActivity(info) {
-    this.sendFrame({ type: "agent_activity", ...info });
+  setName(name) {
+    if (this.config.name !== "")
+      return;
+    this.config.name = name;
   }
-  reportAgentTyping(info) {
-    this.sendFrame({ type: "agent_typing", ...info });
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/table.utils.js
+var TableName = Symbol.for("drizzle:Name");
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/tracing-utils.js
+function iife(fn, ...args) {
+  return fn(...args);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/pg-core/unique-constraint.js
+function uniqueKeyName(table, columns) {
+  return `${table[TableName]}_${columns.join("_")}_unique`;
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/pg-core/columns/common.js
+class PgColumn extends Column {
+  constructor(table, config2) {
+    if (!config2.uniqueName) {
+      config2.uniqueName = uniqueKeyName(table, [config2.name]);
+    }
+    super(table, config2);
+    this.table = table;
   }
-  reportAgentTypingStop(info) {
-    this.sendFrame({ type: "agent_typing_stop", ...info });
+  static [entityKind] = "PgColumn";
+}
+
+class ExtraConfigColumn extends PgColumn {
+  static [entityKind] = "ExtraConfigColumn";
+  getSQLType() {
+    return this.getSQLType();
+  }
+  indexConfig = {
+    order: this.config.order ?? "asc",
+    nulls: this.config.nulls ?? "last",
+    opClass: this.config.opClass
+  };
+  defaultConfig = {
+    order: "asc",
+    nulls: "last",
+    opClass: undefined
+  };
+  asc() {
+    this.indexConfig.order = "asc";
+    return this;
   }
-  async reportBotAuditEvent(frame) {
-    this.sendFrame(frame);
+  desc() {
+    this.indexConfig.order = "desc";
+    return this;
   }
-  async reportWakeAck(info) {
-    this.sendFrame({ type: "agent_wake_ack", ...info });
+  nullsFirst() {
+    this.indexConfig.nulls = "first";
+    return this;
   }
-  async reportStoppedAck(info) {
-    this.sendFrame({ type: "agent_stopped_ack", ...info });
+  nullsLast() {
+    this.indexConfig.nulls = "last";
+    return this;
   }
-  async reportSessionError(frame) {
-    this.sendFrame(frame);
+  op(opClass) {
+    this.indexConfig.opClass = opClass;
+    return this;
   }
-  sendFrame(frame) {
-    if (this.statusValue !== "open" || !this.ws) {
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/pg-core/columns/enum.js
+class PgEnumObjectColumn extends PgColumn {
+  static [entityKind] = "PgEnumObjectColumn";
+  enum;
+  enumValues = this.config.enum.enumValues;
+  constructor(table, config2) {
+    super(table, config2);
+    this.enum = config2.enum;
+  }
+  getSQLType() {
+    return this.enum.enumName;
+  }
+}
+var isPgEnumSym = Symbol.for("drizzle:isPgEnum");
+function isPgEnum(obj) {
+  return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
+}
+class PgEnumColumn extends PgColumn {
+  static [entityKind] = "PgEnumColumn";
+  enum = this.config.enum;
+  enumValues = this.config.enum.enumValues;
+  constructor(table, config2) {
+    super(table, config2);
+    this.enum = config2.enum;
+  }
+  getSQLType() {
+    return this.enum.enumName;
+  }
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/subquery.js
+class Subquery {
+  static [entityKind] = "Subquery";
+  constructor(sql, fields, alias, isWith = false, usedTables = []) {
+    this._ = {
+      brand: "Subquery",
+      sql,
+      selectedFields: fields,
+      alias,
+      isWith,
+      usedTables
+    };
+  }
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/version.js
+var version2 = "0.45.2";
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/tracing.js
+var otel;
+var rawTracer;
+var tracer = {
+  startActiveSpan(name, fn) {
+    if (!otel) {
+      return fn();
+    }
+    if (!rawTracer) {
+      rawTracer = otel.trace.getTracer("drizzle-orm", version2);
+    }
+    return iife((otel2, rawTracer2) => rawTracer2.startActiveSpan(name, (span) => {
+      try {
+        return fn(span);
+      } catch (e) {
+        span.setStatus({
+          code: otel2.SpanStatusCode.ERROR,
+          message: e instanceof Error ? e.message : "Unknown error"
+        });
+        throw e;
+      } finally {
+        span.end();
+      }
+    }), otel, rawTracer);
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/view-common.js
+var ViewBaseConfig = Symbol.for("drizzle:ViewBaseConfig");
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/table.js
+var Schema = Symbol.for("drizzle:Schema");
+var Columns = Symbol.for("drizzle:Columns");
+var ExtraConfigColumns = Symbol.for("drizzle:ExtraConfigColumns");
+var OriginalName = Symbol.for("drizzle:OriginalName");
+var BaseName = Symbol.for("drizzle:BaseName");
+var IsAlias = Symbol.for("drizzle:IsAlias");
+var ExtraConfigBuilder = Symbol.for("drizzle:ExtraConfigBuilder");
+var IsDrizzleTable = Symbol.for("drizzle:IsDrizzleTable");
+
+class Table {
+  static [entityKind] = "Table";
+  static Symbol = {
+    Name: TableName,
+    Schema,
+    OriginalName,
+    Columns,
+    ExtraConfigColumns,
+    BaseName,
+    IsAlias,
+    ExtraConfigBuilder
+  };
+  [TableName];
+  [OriginalName];
+  [Schema];
+  [Columns];
+  [ExtraConfigColumns];
+  [BaseName];
+  [IsAlias] = false;
+  [IsDrizzleTable] = true;
+  [ExtraConfigBuilder] = undefined;
+  constructor(name, schema, baseName) {
+    this[TableName] = this[OriginalName] = name;
+    this[Schema] = schema;
+    this[BaseName] = baseName;
+  }
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/sql/sql.js
+function isSQLWrapper(value) {
+  return value !== null && value !== undefined && typeof value.getSQL === "function";
+}
+function mergeQueries(queries) {
+  const result = { sql: "", params: [] };
+  for (const query of queries) {
+    result.sql += query.sql;
+    result.params.push(...query.params);
+    if (query.typings?.length) {
+      if (!result.typings) {
+        result.typings = [];
+      }
+      result.typings.push(...query.typings);
+    }
+  }
+  return result;
+}
+
+class StringChunk {
+  static [entityKind] = "StringChunk";
+  value;
+  constructor(value) {
+    this.value = Array.isArray(value) ? value : [value];
+  }
+  getSQL() {
+    return new SQL([this]);
+  }
+}
+
+class SQL {
+  constructor(queryChunks) {
+    this.queryChunks = queryChunks;
+    for (const chunk of queryChunks) {
+      if (is(chunk, Table)) {
+        const schemaName = chunk[Table.Symbol.Schema];
+        this.usedTables.push(schemaName === undefined ? chunk[Table.Symbol.Name] : schemaName + "." + chunk[Table.Symbol.Name]);
+      }
+    }
+  }
+  static [entityKind] = "SQL";
+  decoder = noopDecoder;
+  shouldInlineParams = false;
+  usedTables = [];
+  append(query) {
+    this.queryChunks.push(...query.queryChunks);
+    return this;
+  }
+  toQuery(config2) {
+    return tracer.startActiveSpan("drizzle.buildSQL", (span) => {
+      const query = this.buildQueryFromSourceParams(this.queryChunks, config2);
+      span?.setAttributes({
+        "drizzle.query.text": query.sql,
+        "drizzle.query.params": JSON.stringify(query.params)
+      });
+      return query;
+    });
+  }
+  buildQueryFromSourceParams(chunks, _config) {
+    const config2 = Object.assign({}, _config, {
+      inlineParams: _config.inlineParams || this.shouldInlineParams,
+      paramStartIndex: _config.paramStartIndex || { value: 0 }
+    });
+    const {
+      casing,
+      escapeName,
+      escapeParam,
+      prepareTyping,
+      inlineParams,
+      paramStartIndex
+    } = config2;
+    return mergeQueries(chunks.map((chunk) => {
+      if (is(chunk, StringChunk)) {
+        return { sql: chunk.value.join(""), params: [] };
+      }
+      if (is(chunk, Name)) {
+        return { sql: escapeName(chunk.value), params: [] };
+      }
+      if (chunk === undefined) {
+        return { sql: "", params: [] };
+      }
+      if (Array.isArray(chunk)) {
+        const result = [new StringChunk("(")];
+        for (const [i, p] of chunk.entries()) {
+          result.push(p);
+          if (i < chunk.length - 1) {
+            result.push(new StringChunk(", "));
+          }
+        }
+        result.push(new StringChunk(")"));
+        return this.buildQueryFromSourceParams(result, config2);
+      }
+      if (is(chunk, SQL)) {
+        return this.buildQueryFromSourceParams(chunk.queryChunks, {
+          ...config2,
+          inlineParams: inlineParams || chunk.shouldInlineParams
+        });
+      }
+      if (is(chunk, Table)) {
+        const schemaName = chunk[Table.Symbol.Schema];
+        const tableName = chunk[Table.Symbol.Name];
+        return {
+          sql: schemaName === undefined || chunk[IsAlias] ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
+          params: []
+        };
+      }
+      if (is(chunk, Column)) {
+        const columnName = casing.getColumnCasing(chunk);
+        if (_config.invokeSource === "indexes") {
+          return { sql: escapeName(columnName), params: [] };
+        }
+        const schemaName = chunk.table[Table.Symbol.Schema];
+        return {
+          sql: chunk.table[IsAlias] || schemaName === undefined ? escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName) : escapeName(schemaName) + "." + escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName),
+          params: []
+        };
+      }
+      if (is(chunk, View)) {
+        const schemaName = chunk[ViewBaseConfig].schema;
+        const viewName = chunk[ViewBaseConfig].name;
+        return {
+          sql: schemaName === undefined || chunk[ViewBaseConfig].isAlias ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
+          params: []
+        };
+      }
+      if (is(chunk, Param)) {
+        if (is(chunk.value, Placeholder)) {
+          return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+        }
+        const mappedValue = chunk.value === null ? null : chunk.encoder.mapToDriverValue(chunk.value);
+        if (is(mappedValue, SQL)) {
+          return this.buildQueryFromSourceParams([mappedValue], config2);
+        }
+        if (inlineParams) {
+          return { sql: this.mapInlineParam(mappedValue, config2), params: [] };
+        }
+        let typings = ["none"];
+        if (prepareTyping) {
+          typings = [prepareTyping(chunk.encoder)];
+        }
+        return { sql: escapeParam(paramStartIndex.value++, mappedValue), params: [mappedValue], typings };
+      }
+      if (is(chunk, Placeholder)) {
+        return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+      }
+      if (is(chunk, SQL.Aliased) && chunk.fieldAlias !== undefined) {
+        return { sql: escapeName(chunk.fieldAlias), params: [] };
+      }
+      if (is(chunk, Subquery)) {
+        if (chunk._.isWith) {
+          return { sql: escapeName(chunk._.alias), params: [] };
+        }
+        return this.buildQueryFromSourceParams([
+          new StringChunk("("),
+          chunk._.sql,
+          new StringChunk(") "),
+          new Name(chunk._.alias)
+        ], config2);
+      }
+      if (isPgEnum(chunk)) {
+        if (chunk.schema) {
+          return { sql: escapeName(chunk.schema) + "." + escapeName(chunk.enumName), params: [] };
+        }
+        return { sql: escapeName(chunk.enumName), params: [] };
+      }
+      if (isSQLWrapper(chunk)) {
+        if (chunk.shouldOmitSQLParens?.()) {
+          return this.buildQueryFromSourceParams([chunk.getSQL()], config2);
+        }
+        return this.buildQueryFromSourceParams([
+          new StringChunk("("),
+          chunk.getSQL(),
+          new StringChunk(")")
+        ], config2);
+      }
+      if (inlineParams) {
+        return { sql: this.mapInlineParam(chunk, config2), params: [] };
+      }
+      return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+    }));
+  }
+  mapInlineParam(chunk, { escapeString }) {
+    if (chunk === null) {
+      return "null";
+    }
+    if (typeof chunk === "number" || typeof chunk === "boolean") {
+      return chunk.toString();
+    }
+    if (typeof chunk === "string") {
+      return escapeString(chunk);
+    }
+    if (typeof chunk === "object") {
+      const mappedValueAsString = chunk.toString();
+      if (mappedValueAsString === "[object Object]") {
+        return escapeString(JSON.stringify(chunk));
+      }
+      return escapeString(mappedValueAsString);
+    }
+    throw new Error("Unexpected param value: " + chunk);
+  }
+  getSQL() {
+    return this;
+  }
+  as(alias) {
+    if (alias === undefined) {
+      return this;
+    }
+    return new SQL.Aliased(this, alias);
+  }
+  mapWith(decoder) {
+    this.decoder = typeof decoder === "function" ? { mapFromDriverValue: decoder } : decoder;
+    return this;
+  }
+  inlineParams() {
+    this.shouldInlineParams = true;
+    return this;
+  }
+  if(condition) {
+    return condition ? this : undefined;
+  }
+}
+
+class Name {
+  constructor(value) {
+    this.value = value;
+  }
+  static [entityKind] = "Name";
+  brand;
+  getSQL() {
+    return new SQL([this]);
+  }
+}
+var noopDecoder = {
+  mapFromDriverValue: (value) => value
+};
+var noopEncoder = {
+  mapToDriverValue: (value) => value
+};
+var noopMapper = {
+  ...noopDecoder,
+  ...noopEncoder
+};
+
+class Param {
+  constructor(value, encoder = noopEncoder) {
+    this.value = value;
+    this.encoder = encoder;
+  }
+  static [entityKind] = "Param";
+  brand;
+  getSQL() {
+    return new SQL([this]);
+  }
+}
+function sql(strings, ...params) {
+  const queryChunks = [];
+  if (params.length > 0 || strings.length > 0 && strings[0] !== "") {
+    queryChunks.push(new StringChunk(strings[0]));
+  }
+  for (const [paramIndex, param2] of params.entries()) {
+    queryChunks.push(param2, new StringChunk(strings[paramIndex + 1]));
+  }
+  return new SQL(queryChunks);
+}
+((sql2) => {
+  function empty() {
+    return new SQL([]);
+  }
+  sql2.empty = empty;
+  function fromList(list) {
+    return new SQL(list);
+  }
+  sql2.fromList = fromList;
+  function raw(str) {
+    return new SQL([new StringChunk(str)]);
+  }
+  sql2.raw = raw;
+  function join9(chunks, separator) {
+    const result = [];
+    for (const [i, chunk] of chunks.entries()) {
+      if (i > 0 && separator !== undefined) {
+        result.push(separator);
+      }
+      result.push(chunk);
+    }
+    return new SQL(result);
+  }
+  sql2.join = join9;
+  function identifier(value) {
+    return new Name(value);
+  }
+  sql2.identifier = identifier;
+  function placeholder2(name2) {
+    return new Placeholder(name2);
+  }
+  sql2.placeholder = placeholder2;
+  function param2(value, encoder) {
+    return new Param(value, encoder);
+  }
+  sql2.param = param2;
+})(sql || (sql = {}));
+((SQL2) => {
+
+  class Aliased {
+    constructor(sql2, fieldAlias) {
+      this.sql = sql2;
+      this.fieldAlias = fieldAlias;
+    }
+    static [entityKind] = "SQL.Aliased";
+    isSelectionField = false;
+    getSQL() {
+      return this.sql;
+    }
+    clone() {
+      return new Aliased(this.sql, this.fieldAlias);
+    }
+  }
+  SQL2.Aliased = Aliased;
+})(SQL || (SQL = {}));
+
+class Placeholder {
+  constructor(name2) {
+    this.name = name2;
+  }
+  static [entityKind] = "Placeholder";
+  getSQL() {
+    return new SQL([this]);
+  }
+}
+var IsDrizzleView = Symbol.for("drizzle:IsDrizzleView");
+
+class View {
+  static [entityKind] = "View";
+  [ViewBaseConfig];
+  [IsDrizzleView] = true;
+  constructor({ name: name2, schema, selectedFields, query }) {
+    this[ViewBaseConfig] = {
+      name: name2,
+      originalName: name2,
+      schema,
+      selectedFields,
+      query,
+      isExisting: !query,
+      isAlias: false
+    };
+  }
+  getSQL() {
+    return new SQL([this]);
+  }
+}
+Column.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+Table.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+Subquery.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/sqlite-core/checks.js
+class CheckBuilder {
+  constructor(name, value) {
+    this.name = name;
+    this.value = value;
+  }
+  static [entityKind] = "SQLiteCheckBuilder";
+  brand;
+  build(table) {
+    return new Check(table, this);
+  }
+}
+
+class Check {
+  constructor(table, builder) {
+    this.table = table;
+    this.name = builder.name;
+    this.value = builder.value;
+  }
+  static [entityKind] = "SQLiteCheck";
+  name;
+  value;
+}
+function check2(name, value) {
+  return new CheckBuilder(name, value);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/utils.js
+function getColumnNameAndConfig(a, b) {
+  return {
+    name: typeof a === "string" && a.length > 0 ? a : "",
+    config: typeof a === "object" ? a : b
+  };
+}
+var textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder;
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/sqlite-core/foreign-keys.js
+class ForeignKeyBuilder {
+  static [entityKind] = "SQLiteForeignKeyBuilder";
+  reference;
+  _onUpdate;
+  _onDelete;
+  constructor(config2, actions) {
+    this.reference = () => {
+      const { name, columns, foreignColumns } = config2();
+      return { name, columns, foreignTable: foreignColumns[0].table, foreignColumns };
+    };
+    if (actions) {
+      this._onUpdate = actions.onUpdate;
+      this._onDelete = actions.onDelete;
+    }
+  }
+  onUpdate(action) {
+    this._onUpdate = action;
+    return this;
+  }
+  onDelete(action) {
+    this._onDelete = action;
+    return this;
+  }
+  build(table) {
+    return new ForeignKey(table, this);
+  }
+}
+
+class ForeignKey {
+  constructor(table, builder) {
+    this.table = table;
+    this.reference = builder.reference;
+    this.onUpdate = builder._onUpdate;
+    this.onDelete = builder._onDelete;
+  }
+  static [entityKind] = "SQLiteForeignKey";
+  reference;
+  onUpdate;
+  onDelete;
+  getName() {
+    const { name, columns, foreignColumns } = this.reference();
+    const columnNames = columns.map((column) => column.name);
+    const foreignColumnNames = foreignColumns.map((column) => column.name);
+    const chunks = [
+      this.table[TableName],
+      ...columnNames,
+      foreignColumns[0].table[TableName],
+      ...foreignColumnNames
+    ];
+    return name ?? `${chunks.join("_")}_fk`;
+  }
+}
+function foreignKey(config2) {
+  function mappedConfig() {
+    if (typeof config2 === "function") {
+      const { name, columns, foreignColumns } = config2();
+      return {
+        name,
+        columns,
+        foreignColumns
+      };
+    }
+    return config2;
+  }
+  return new ForeignKeyBuilder(mappedConfig);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/sqlite-core/unique-constraint.js
+function uniqueKeyName2(table, columns) {
+  return `${table[TableName]}_${columns.join("_")}_unique`;
+}
+function unique(name) {
+  return new UniqueOnConstraintBuilder(name);
+}
+
+class UniqueConstraintBuilder {
+  constructor(columns, name) {
+    this.name = name;
+    this.columns = columns;
+  }
+  static [entityKind] = "SQLiteUniqueConstraintBuilder";
+  columns;
+  build(table) {
+    return new UniqueConstraint(table, this.columns, this.name);
+  }
+}
+
+class UniqueOnConstraintBuilder {
+  static [entityKind] = "SQLiteUniqueOnConstraintBuilder";
+  name;
+  constructor(name) {
+    this.name = name;
+  }
+  on(...columns) {
+    return new UniqueConstraintBuilder(columns, this.name);
+  }
+}
+
+class UniqueConstraint {
+  constructor(table, columns, name) {
+    this.table = table;
+    this.columns = columns;
+    this.name = name ?? uniqueKeyName2(this.table, this.columns.map((column) => column.name));
+  }
+  static [entityKind] = "SQLiteUniqueConstraint";
+  columns;
+  name;
+  getName() {
+    return this.name;
+  }
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/sqlite-core/columns/common.js
+class SQLiteColumnBuilder extends ColumnBuilder {
+  static [entityKind] = "SQLiteColumnBuilder";
+  foreignKeyConfigs = [];
+  references(ref, actions = {}) {
+    this.foreignKeyConfigs.push({ ref, actions });
+    return this;
+  }
+  unique(name) {
+    this.config.isUnique = true;
+    this.config.uniqueName = name;
+    return this;
+  }
+  generatedAlwaysAs(as, config2) {
+    this.config.generated = {
+      as,
+      type: "always",
+      mode: config2?.mode ?? "virtual"
+    };
+    return this;
+  }
+  buildForeignKeys(column, table) {
+    return this.foreignKeyConfigs.map(({ ref, actions }) => {
+      return ((ref2, actions2) => {
+        const builder = new ForeignKeyBuilder(() => {
+          const foreignColumn = ref2();
+          return { columns: [column], foreignColumns: [foreignColumn] };
+        });
+        if (actions2.onUpdate) {
+          builder.onUpdate(actions2.onUpdate);
+        }
+        if (actions2.onDelete) {
+          builder.onDelete(actions2.onDelete);
+        }
+        return builder.build(table);
+      })(ref, actions);
+    });
+  }
+}
+
+class SQLiteColumn extends Column {
+  constructor(table, config2) {
+    if (!config2.uniqueName) {
+      config2.uniqueName = uniqueKeyName2(table, [config2.name]);
+    }
+    super(table, config2);
+    this.table = table;
+  }
+  static [entityKind] = "SQLiteColumn";
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/sqlite-core/columns/blob.js
+class SQLiteBigIntBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBigIntBuilder";
+  constructor(name) {
+    super(name, "bigint", "SQLiteBigInt");
+  }
+  build(table) {
+    return new SQLiteBigInt(table, this.config);
+  }
+}
+
+class SQLiteBigInt extends SQLiteColumn {
+  static [entityKind] = "SQLiteBigInt";
+  getSQLType() {
+    return "blob";
+  }
+  mapFromDriverValue(value) {
+    if (typeof Buffer !== "undefined" && Buffer.from) {
+      const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
+      return BigInt(buf.toString("utf8"));
+    }
+    return BigInt(textDecoder.decode(value));
+  }
+  mapToDriverValue(value) {
+    return Buffer.from(value.toString());
+  }
+}
+
+class SQLiteBlobJsonBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBlobJsonBuilder";
+  constructor(name) {
+    super(name, "json", "SQLiteBlobJson");
+  }
+  build(table) {
+    return new SQLiteBlobJson(table, this.config);
+  }
+}
+
+class SQLiteBlobJson extends SQLiteColumn {
+  static [entityKind] = "SQLiteBlobJson";
+  getSQLType() {
+    return "blob";
+  }
+  mapFromDriverValue(value) {
+    if (typeof Buffer !== "undefined" && Buffer.from) {
+      const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
+      return JSON.parse(buf.toString("utf8"));
+    }
+    return JSON.parse(textDecoder.decode(value));
+  }
+  mapToDriverValue(value) {
+    return Buffer.from(JSON.stringify(value));
+  }
+}
+
+class SQLiteBlobBufferBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBlobBufferBuilder";
+  constructor(name) {
+    super(name, "buffer", "SQLiteBlobBuffer");
+  }
+  build(table) {
+    return new SQLiteBlobBuffer(table, this.config);
+  }
+}
+
+class SQLiteBlobBuffer extends SQLiteColumn {
+  static [entityKind] = "SQLiteBlobBuffer";
+  mapFromDriverValue(value) {
+    if (Buffer.isBuffer(value)) {
+      return value;
+    }
+    return Buffer.from(value);
+  }
+  getSQLType() {
+    return "blob";
+  }
+}
+function blob(a, b) {
+  const { name, config: config2 } = getColumnNameAndConfig(a, b);
+  if (config2?.mode === "json") {
+    return new SQLiteBlobJsonBuilder(name);
+  }
+  if (config2?.mode === "bigint") {
+    return new SQLiteBigIntBuilder(name);
+  }
+  return new SQLiteBlobBufferBuilder(name);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/sqlite-core/columns/custom.js
+class SQLiteCustomColumnBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteCustomColumnBuilder";
+  constructor(name, fieldConfig, customTypeParams) {
+    super(name, "custom", "SQLiteCustomColumn");
+    this.config.fieldConfig = fieldConfig;
+    this.config.customTypeParams = customTypeParams;
+  }
+  build(table) {
+    return new SQLiteCustomColumn(table, this.config);
+  }
+}
+
+class SQLiteCustomColumn extends SQLiteColumn {
+  static [entityKind] = "SQLiteCustomColumn";
+  sqlName;
+  mapTo;
+  mapFrom;
+  constructor(table, config2) {
+    super(table, config2);
+    this.sqlName = config2.customTypeParams.dataType(config2.fieldConfig);
+    this.mapTo = config2.customTypeParams.toDriver;
+    this.mapFrom = config2.customTypeParams.fromDriver;
+  }
+  getSQLType() {
+    return this.sqlName;
+  }
+  mapFromDriverValue(value) {
+    return typeof this.mapFrom === "function" ? this.mapFrom(value) : value;
+  }
+  mapToDriverValue(value) {
+    return typeof this.mapTo === "function" ? this.mapTo(value) : value;
+  }
+}
+function customType(customTypeParams) {
+  return (a, b) => {
+    const { name, config: config2 } = getColumnNameAndConfig(a, b);
+    return new SQLiteCustomColumnBuilder(name, config2, customTypeParams);
+  };
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/sqlite-core/columns/integer.js
+class SQLiteBaseIntegerBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBaseIntegerBuilder";
+  constructor(name, dataType, columnType) {
+    super(name, dataType, columnType);
+    this.config.autoIncrement = false;
+  }
+  primaryKey(config2) {
+    if (config2?.autoIncrement) {
+      this.config.autoIncrement = true;
+    }
+    this.config.hasDefault = true;
+    return super.primaryKey();
+  }
+}
+
+class SQLiteBaseInteger extends SQLiteColumn {
+  static [entityKind] = "SQLiteBaseInteger";
+  autoIncrement = this.config.autoIncrement;
+  getSQLType() {
+    return "integer";
+  }
+}
+
+class SQLiteIntegerBuilder extends SQLiteBaseIntegerBuilder {
+  static [entityKind] = "SQLiteIntegerBuilder";
+  constructor(name) {
+    super(name, "number", "SQLiteInteger");
+  }
+  build(table) {
+    return new SQLiteInteger(table, this.config);
+  }
+}
+
+class SQLiteInteger extends SQLiteBaseInteger {
+  static [entityKind] = "SQLiteInteger";
+}
+
+class SQLiteTimestampBuilder extends SQLiteBaseIntegerBuilder {
+  static [entityKind] = "SQLiteTimestampBuilder";
+  constructor(name, mode) {
+    super(name, "date", "SQLiteTimestamp");
+    this.config.mode = mode;
+  }
+  defaultNow() {
+    return this.default(sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`);
+  }
+  build(table) {
+    return new SQLiteTimestamp(table, this.config);
+  }
+}
+
+class SQLiteTimestamp extends SQLiteBaseInteger {
+  static [entityKind] = "SQLiteTimestamp";
+  mode = this.config.mode;
+  mapFromDriverValue(value) {
+    if (this.config.mode === "timestamp") {
+      return new Date(value * 1000);
+    }
+    return new Date(value);
+  }
+  mapToDriverValue(value) {
+    const unix = value.getTime();
+    if (this.config.mode === "timestamp") {
+      return Math.floor(unix / 1000);
+    }
+    return unix;
+  }
+}
+
+class SQLiteBooleanBuilder extends SQLiteBaseIntegerBuilder {
+  static [entityKind] = "SQLiteBooleanBuilder";
+  constructor(name, mode) {
+    super(name, "boolean", "SQLiteBoolean");
+    this.config.mode = mode;
+  }
+  build(table) {
+    return new SQLiteBoolean(table, this.config);
+  }
+}
+
+class SQLiteBoolean extends SQLiteBaseInteger {
+  static [entityKind] = "SQLiteBoolean";
+  mode = this.config.mode;
+  mapFromDriverValue(value) {
+    return Number(value) === 1;
+  }
+  mapToDriverValue(value) {
+    return value ? 1 : 0;
+  }
+}
+function integer2(a, b) {
+  const { name, config: config2 } = getColumnNameAndConfig(a, b);
+  if (config2?.mode === "timestamp" || config2?.mode === "timestamp_ms") {
+    return new SQLiteTimestampBuilder(name, config2.mode);
+  }
+  if (config2?.mode === "boolean") {
+    return new SQLiteBooleanBuilder(name, config2.mode);
+  }
+  return new SQLiteIntegerBuilder(name);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/sqlite-core/columns/numeric.js
+class SQLiteNumericBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteNumericBuilder";
+  constructor(name) {
+    super(name, "string", "SQLiteNumeric");
+  }
+  build(table) {
+    return new SQLiteNumeric(table, this.config);
+  }
+}
+
+class SQLiteNumeric extends SQLiteColumn {
+  static [entityKind] = "SQLiteNumeric";
+  mapFromDriverValue(value) {
+    if (typeof value === "string")
+      return value;
+    return String(value);
+  }
+  getSQLType() {
+    return "numeric";
+  }
+}
+
+class SQLiteNumericNumberBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteNumericNumberBuilder";
+  constructor(name) {
+    super(name, "number", "SQLiteNumericNumber");
+  }
+  build(table) {
+    return new SQLiteNumericNumber(table, this.config);
+  }
+}
+
+class SQLiteNumericNumber extends SQLiteColumn {
+  static [entityKind] = "SQLiteNumericNumber";
+  mapFromDriverValue(value) {
+    if (typeof value === "number")
+      return value;
+    return Number(value);
+  }
+  mapToDriverValue = String;
+  getSQLType() {
+    return "numeric";
+  }
+}
+
+class SQLiteNumericBigIntBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteNumericBigIntBuilder";
+  constructor(name) {
+    super(name, "bigint", "SQLiteNumericBigInt");
+  }
+  build(table) {
+    return new SQLiteNumericBigInt(table, this.config);
+  }
+}
+
+class SQLiteNumericBigInt extends SQLiteColumn {
+  static [entityKind] = "SQLiteNumericBigInt";
+  mapFromDriverValue = BigInt;
+  mapToDriverValue = String;
+  getSQLType() {
+    return "numeric";
+  }
+}
+function numeric(a, b) {
+  const { name, config: config2 } = getColumnNameAndConfig(a, b);
+  const mode = config2?.mode;
+  return mode === "number" ? new SQLiteNumericNumberBuilder(name) : mode === "bigint" ? new SQLiteNumericBigIntBuilder(name) : new SQLiteNumericBuilder(name);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/sqlite-core/columns/real.js
+class SQLiteRealBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteRealBuilder";
+  constructor(name) {
+    super(name, "number", "SQLiteReal");
+  }
+  build(table) {
+    return new SQLiteReal(table, this.config);
+  }
+}
+
+class SQLiteReal extends SQLiteColumn {
+  static [entityKind] = "SQLiteReal";
+  getSQLType() {
+    return "real";
+  }
+}
+function real(name) {
+  return new SQLiteRealBuilder(name ?? "");
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/sqlite-core/columns/text.js
+class SQLiteTextBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteTextBuilder";
+  constructor(name, config2) {
+    super(name, "string", "SQLiteText");
+    this.config.enumValues = config2.enum;
+    this.config.length = config2.length;
+  }
+  build(table) {
+    return new SQLiteText(table, this.config);
+  }
+}
+
+class SQLiteText extends SQLiteColumn {
+  static [entityKind] = "SQLiteText";
+  enumValues = this.config.enumValues;
+  length = this.config.length;
+  constructor(table, config2) {
+    super(table, config2);
+  }
+  getSQLType() {
+    return `text${this.config.length ? `(${this.config.length})` : ""}`;
+  }
+}
+
+class SQLiteTextJsonBuilder extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteTextJsonBuilder";
+  constructor(name) {
+    super(name, "json", "SQLiteTextJson");
+  }
+  build(table) {
+    return new SQLiteTextJson(table, this.config);
+  }
+}
+
+class SQLiteTextJson extends SQLiteColumn {
+  static [entityKind] = "SQLiteTextJson";
+  getSQLType() {
+    return "text";
+  }
+  mapFromDriverValue(value) {
+    return JSON.parse(value);
+  }
+  mapToDriverValue(value) {
+    return JSON.stringify(value);
+  }
+}
+function text(a, b = {}) {
+  const { name, config: config2 } = getColumnNameAndConfig(a, b);
+  if (config2.mode === "json") {
+    return new SQLiteTextJsonBuilder(name);
+  }
+  return new SQLiteTextBuilder(name, config2);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/sqlite-core/columns/all.js
+function getSQLiteColumnBuilders() {
+  return {
+    blob,
+    customType,
+    integer: integer2,
+    numeric,
+    real,
+    text
+  };
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/sqlite-core/table.js
+var InlineForeignKeys = Symbol.for("drizzle:SQLiteInlineForeignKeys");
+
+class SQLiteTable extends Table {
+  static [entityKind] = "SQLiteTable";
+  static Symbol = Object.assign({}, Table.Symbol, {
+    InlineForeignKeys
+  });
+  [Table.Symbol.Columns];
+  [InlineForeignKeys] = [];
+  [Table.Symbol.ExtraConfigBuilder] = undefined;
+}
+function sqliteTableBase(name, columns, extraConfig, schema, baseName = name) {
+  const rawTable = new SQLiteTable(name, schema, baseName);
+  const parsedColumns = typeof columns === "function" ? columns(getSQLiteColumnBuilders()) : columns;
+  const builtColumns = Object.fromEntries(Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {
+    const colBuilder = colBuilderBase;
+    colBuilder.setName(name2);
+    const column = colBuilder.build(rawTable);
+    rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
+    return [name2, column];
+  }));
+  const table = Object.assign(rawTable, builtColumns);
+  table[Table.Symbol.Columns] = builtColumns;
+  table[Table.Symbol.ExtraConfigColumns] = builtColumns;
+  if (extraConfig) {
+    table[SQLiteTable.Symbol.ExtraConfigBuilder] = extraConfig;
+  }
+  return table;
+}
+var sqliteTable = (name, columns, extraConfig) => {
+  return sqliteTableBase(name, columns, extraConfig);
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/sqlite-core/indexes.js
+class IndexBuilderOn {
+  constructor(name, unique2) {
+    this.name = name;
+    this.unique = unique2;
+  }
+  static [entityKind] = "SQLiteIndexBuilderOn";
+  on(...columns) {
+    return new IndexBuilder(this.name, columns, this.unique);
+  }
+}
+
+class IndexBuilder {
+  static [entityKind] = "SQLiteIndexBuilder";
+  config;
+  constructor(name, columns, unique2) {
+    this.config = {
+      name,
+      columns,
+      unique: unique2,
+      where: undefined
+    };
+  }
+  where(condition) {
+    this.config.where = condition;
+    return this;
+  }
+  build(table) {
+    return new Index(this.config, table);
+  }
+}
+
+class Index {
+  static [entityKind] = "SQLiteIndex";
+  config;
+  constructor(config2, table) {
+    this.config = { ...config2, table };
+  }
+}
+function index(name) {
+  return new IndexBuilderOn(name, false);
+}
+function uniqueIndex(name) {
+  return new IndexBuilderOn(name, true);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@4.20260702.1_@opentelemetry+api@1.9.1_@typ_5aa9492b131e5fac58fa98e88e5c0ad3/node_modules/drizzle-orm/sqlite-core/primary-keys.js
+function primaryKey(...config2) {
+  if (config2[0].columns) {
+    return new PrimaryKeyBuilder(config2[0].columns, config2[0].name);
+  }
+  return new PrimaryKeyBuilder(config2);
+}
+
+class PrimaryKeyBuilder {
+  static [entityKind] = "SQLitePrimaryKeyBuilder";
+  columns;
+  name;
+  constructor(columns, name) {
+    this.columns = columns;
+    this.name = name;
+  }
+  build(table) {
+    return new PrimaryKey(table, this.columns, this.name);
+  }
+}
+
+class PrimaryKey {
+  constructor(table, columns, name) {
+    this.table = table;
+    this.columns = columns;
+    this.name = name;
+  }
+  static [entityKind] = "SQLitePrimaryKey";
+  columns;
+  name;
+  getName() {
+    return this.name ?? `${this.table[SQLiteTable.Symbol.Name]}_${this.columns.map((column) => column.name).join("_")}_pk`;
+  }
+}
+
+// ../../node_modules/.pnpm/nanoid@5.1.16/node_modules/nanoid/index.js
+import { webcrypto as crypto2 } from "node:crypto";
+
+// ../../node_modules/.pnpm/nanoid@5.1.16/node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// ../../node_modules/.pnpm/nanoid@5.1.16/node_modules/nanoid/index.js
+var POOL_SIZE_MULTIPLIER = 128;
+var pool;
+var poolOffset;
+function fillPool(bytes) {
+  if (bytes < 0)
+    throw new RangeError("Wrong ID size");
+  try {
+    if (!pool || pool.length < bytes) {
+      pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+      crypto2.getRandomValues(pool);
+      poolOffset = 0;
+    } else if (poolOffset + bytes > pool.length) {
+      crypto2.getRandomValues(pool);
+      poolOffset = 0;
+    }
+  } catch (e) {
+    pool = undefined;
+    throw e;
+  }
+  poolOffset += bytes;
+}
+function nanoid3(size = 21) {
+  fillPool(size |= 0);
+  let id = "";
+  for (let i = poolOffset - size;i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63];
+  }
+  return id;
+}
+
+// ../shared/src/constants.ts
+var TaskStatus = {
+  QUEUED: "queued",
+  DISPATCHED: "dispatched",
+  RUNNING: "running",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  CANCELLED: "cancelled",
+  SUPERSEDED: "superseded"
+};
+var TERMINAL_TASK_STATUSES = [
+  TaskStatus.COMPLETED,
+  TaskStatus.FAILED,
+  TaskStatus.CANCELLED,
+  TaskStatus.SUPERSEDED
+];
+var TASK_TYPES = {
+  USER_DM_MESSAGE: "user_dm_message",
+  EMAIL_NOTIFICATION: "email_notification",
+  CALENDAR_EVENT: "calendar_event",
+  ISSUE_EVENT: "issue_event",
+  KILL_TASK: "kill_task"
+};
+var IssueStatus = {
+  TODO: "todo",
+  IN_PROGRESS: "in_progress",
+  REVIEW: "review",
+  DONE: "done",
+  CLOSED: "closed",
+  CANCELED: "canceled",
+  FAILED: "failed"
+};
+var ACTIVE_ISSUE_STATUSES = [
+  IssueStatus.TODO,
+  IssueStatus.IN_PROGRESS,
+  IssueStatus.REVIEW
+];
+var TERMINAL_ISSUE_STATUSES = [
+  IssueStatus.DONE,
+  IssueStatus.CLOSED,
+  IssueStatus.CANCELED,
+  IssueStatus.FAILED
+];
+var POLL_INTERVAL_MS = Number(process.env.POLL_INTERVAL_MS) || 3000;
+var OFFLINE_THRESHOLD_MS = Number(process.env.OFFLINE_THRESHOLD_MS) || 30000;
+var COMMUNITY_MACHINE_HEARTBEAT_MS = 30000;
+var COMMUNITY_MACHINE_OFFLINE_THRESHOLD_MS = 3 * COMMUNITY_MACHINE_HEARTBEAT_MS;
+var COMMUNITY_MACHINE_PAIR_TOKEN_TTL_MS = 15 * 60000;
+var EVENT_POLL_INTERVAL_MS = Number(process.env.EVENT_POLL_INTERVAL_MS) || 2000;
+var MeetingStatus = {
+  PENDING: "pending",
+  SCHEDULED: "scheduled",
+  JOINING: "joining",
+  RECORDING: "recording",
+  COMPLETED: "completed",
+  FAILED: "failed"
+};
+var TERMINAL_MEETING_STATUSES = [
+  MeetingStatus.COMPLETED,
+  MeetingStatus.FAILED
+];
+var DEV_PORTS = {
+  web: 3000,
+  emailWorker: 8787,
+  wsDo: 8789,
+  wakeWorker: 8790
+};
+var DEV_WEB_URL = process.env.ALOOK_SERVER_URL || `http://localhost:${DEV_PORTS.web}`;
+var DEV_WS_DO_URL = process.env.DEV_WS_DO_URL || `http://localhost:${DEV_PORTS.wsDo}`;
+var DEV_EMAIL_WORKER_URL = process.env.DEV_EMAIL_WORKER_URL || `http://localhost:${DEV_PORTS.emailWorker}`;
+var DEV_WAKE_WORKER_URL = process.env.DEV_WAKE_WORKER_URL || `http://localhost:${DEV_PORTS.wakeWorker}`;
+
+// ../shared/src/db/schema.ts
+var user = sqliteTable("user", {
+  id: text("id").primaryKey().$defaultFn(() => nanoid3()),
+  name: text("name").notNull().default(""),
+  email: text("email").unique().notNull(),
+  emailVerified: integer2("emailVerified", { mode: "boolean" }),
+  image: text("image"),
+  createdAt: text("createdAt").notNull().$defaultFn(() => new Date().toISOString()),
+  updatedAt: text("updatedAt").notNull().$defaultFn(() => new Date().toISOString()),
+  isBot: integer2("isBot", { mode: "boolean" }).notNull().default(false),
+  ownerUserId: text("ownerUserId").references(() => user.id, { onDelete: "no action" }),
+  deletedAt: text("deletedAt"),
+  discriminator: text("discriminator").notNull().default("0000"),
+  lastRefreshContextAt: text("lastRefreshContextAt")
+}, (t) => [index("idx_user_ownerUserId_isBot").on(t.ownerUserId, t.isBot)]);
+var session = sqliteTable("session", {
+  id: text("id").primaryKey().$defaultFn(() => nanoid3()),
+  userId: text("userId").notNull().references(() => user.id, { onDelete: "cascade" }),
+  token: text("token").unique().notNull(),
+  expiresAt: text("expiresAt").notNull(),
+  ipAddress: text("ipAddress"),
+  userAgent: text("userAgent"),
+  createdAt: text("createdAt").notNull().$defaultFn(() => new Date().toISOString()),
+  updatedAt: text("updatedAt").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [index("idx_session_token_expires").on(t.token, t.expiresAt)]);
+var account = sqliteTable("account", {
+  id: text("id").primaryKey().$defaultFn(() => nanoid3()),
+  userId: text("userId").notNull().references(() => user.id, { onDelete: "cascade" }),
+  accountId: text("accountId").notNull(),
+  providerId: text("providerId").notNull(),
+  accessToken: text("accessToken"),
+  refreshToken: text("refreshToken"),
+  accessTokenExpiresAt: text("accessTokenExpiresAt"),
+  refreshTokenExpiresAt: text("refreshTokenExpiresAt"),
+  scope: text("scope"),
+  idToken: text("idToken"),
+  password: text("password"),
+  createdAt: text("createdAt").notNull().$defaultFn(() => new Date().toISOString()),
+  updatedAt: text("updatedAt").notNull().$defaultFn(() => new Date().toISOString())
+});
+var verification = sqliteTable("verification", {
+  id: text("id").primaryKey().$defaultFn(() => nanoid3()),
+  identifier: text("identifier").notNull(),
+  value: text("value").notNull(),
+  expiresAt: text("expiresAt").notNull(),
+  createdAt: text("createdAt").notNull().$defaultFn(() => new Date().toISOString()),
+  updatedAt: text("updatedAt").notNull().$defaultFn(() => new Date().toISOString())
+});
+var workspace = sqliteTable("workspace", {
+  id: text("id").primaryKey().$defaultFn(() => "sp_" + nanoid3()),
+  name: text("name").notNull(),
+  slug: text("slug").unique().notNull(),
+  onboarded: integer2("onboarded").notNull().default(0),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString()),
+  updatedAt: text("updated_at").notNull().$defaultFn(() => new Date().toISOString())
+});
+var member = sqliteTable("member", {
+  id: text("id").primaryKey().$defaultFn(() => nanoid3()),
+  workspaceId: text("workspace_id").notNull().references(() => workspace.id, { onDelete: "cascade" }),
+  userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+  role: text("role").notNull().default("member"),
+  globalInstruction: text("global_instruction").notNull().default(""),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [unique("member_workspace_user").on(t.workspaceId, t.userId)]);
+var workspaceInvite = sqliteTable("workspace_invite", {
+  id: text("id").primaryKey().$defaultFn(() => "inv_" + nanoid3()),
+  workspaceId: text("workspace_id").notNull().references(() => workspace.id, { onDelete: "cascade" }),
+  token: text("token").unique().notNull().$defaultFn(() => nanoid3(32)),
+  createdBy: text("created_by").notNull().references(() => user.id, { onDelete: "cascade" }),
+  usedBy: text("used_by").references(() => user.id, { onDelete: "set null" }),
+  usedAt: text("used_at"),
+  expiresAt: text("expires_at").notNull(),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [
+  index("idx_workspace_invite_token").on(t.token),
+  index("idx_workspace_invite_workspace").on(t.workspaceId)
+]);
+var agentAccess = sqliteTable("agent_access", {
+  id: text("id").primaryKey().$defaultFn(() => nanoid3()),
+  agentId: text("agent_id").notNull(),
+  workspaceId: text("workspace_id").notNull(),
+  userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [
+  unique("agent_access_agent_ws_user").on(t.agentId, t.workspaceId, t.userId),
+  index("idx_agent_access_agent_ws").on(t.agentId, t.workspaceId),
+  index("idx_agent_access_user").on(t.userId),
+  foreignKey({
+    columns: [t.agentId, t.workspaceId],
+    foreignColumns: [agent.id, agent.workspaceId]
+  }).onDelete("cascade")
+]);
+var agentPin = sqliteTable("agent_pin", {
+  id: text("id").primaryKey().$defaultFn(() => nanoid3()),
+  agentId: text("agent_id").notNull(),
+  workspaceId: text("workspace_id").notNull(),
+  userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString()),
+  position: integer2("position").notNull().default(0)
+}, (t) => [
+  unique("agent_pin_agent_ws_user").on(t.agentId, t.workspaceId, t.userId),
+  index("idx_agent_pin_ws_user").on(t.workspaceId, t.userId),
+  foreignKey({
+    columns: [t.agentId, t.workspaceId],
+    foreignColumns: [agent.id, agent.workspaceId]
+  }).onDelete("cascade")
+]);
+var agentSidebarOrder = sqliteTable("agent_sidebar_order", {
+  id: text("id").primaryKey().$defaultFn(() => nanoid3()),
+  agentId: text("agent_id").notNull(),
+  workspaceId: text("workspace_id").notNull(),
+  userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+  position: integer2("position").notNull().default(0)
+}, (t) => [
+  unique("agent_sidebar_order_agent_ws_user").on(t.agentId, t.workspaceId, t.userId),
+  index("idx_agent_sidebar_order_ws_user").on(t.workspaceId, t.userId),
+  foreignKey({
+    columns: [t.agentId, t.workspaceId],
+    foreignColumns: [agent.id, agent.workspaceId]
+  }).onDelete("cascade")
+]);
+var machine = sqliteTable("machine", {
+  daemonId: text("daemon_id").notNull(),
+  workspaceId: text("workspace_id").notNull().references(() => workspace.id, { onDelete: "cascade" }),
+  deviceInfo: text("device_info").notNull().default(""),
+  lastSeenAt: text("last_seen_at"),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString()),
+  pendingUpdateVersion: text("pending_update_version"),
+  pendingRescan: integer2("pending_rescan", { mode: "boolean" }).default(false),
+  updatedAt: text("updated_at").notNull().$defaultFn(() => new Date().toISOString()),
+  ownerId: text("owner_id").references(() => user.id, { onDelete: "set null" })
+}, (t) => [primaryKey({ columns: [t.workspaceId, t.daemonId] })]);
+var agentRuntime = sqliteTable("agent_runtime", {
+  id: text("id").primaryKey().$defaultFn(() => nanoid3()),
+  workspaceId: text("workspace_id").notNull().references(() => workspace.id, { onDelete: "cascade" }),
+  daemonId: text("daemon_id").notNull(),
+  runtimeMode: text("runtime_mode").notNull().default("local"),
+  provider: text("provider").notNull(),
+  deviceInfo: text("device_info").notNull().default(""),
+  metadata: text("metadata", { mode: "json" }),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString()),
+  updatedAt: text("updated_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [
+  unique("agent_runtime_workspace_daemon_provider").on(t.workspaceId, t.daemonId, t.provider),
+  index("idx_agent_runtime_workspace_daemon").on(t.workspaceId, t.daemonId),
+  index("idx_agent_runtime_daemon_workspace").on(t.daemonId, t.workspaceId)
+]);
+var agent = sqliteTable("agent", {
+  id: text("id").notNull().$defaultFn(() => "ag_" + nanoid3(8)),
+  workspaceId: text("workspace_id").notNull().references(() => workspace.id, { onDelete: "cascade" }),
+  name: text("name").notNull(),
+  description: text("description").notNull().default(""),
+  instructions: text("instructions").notNull().default(""),
+  avatarUrl: text("avatar_url"),
+  runtimeId: text("runtime_id").references(() => agentRuntime.id),
+  runtimeMode: text("runtime_mode").notNull().default("local"),
+  runtimeConfig: text("runtime_config", { mode: "json" }),
+  visibility: text("visibility").notNull().default("private"),
+  status: text("status").notNull().default("idle"),
+  maxConcurrentTasks: integer2("max_concurrent_tasks").notNull().default(6),
+  ownerId: text("owner_id").references(() => user.id),
+  tools: text("tools", { mode: "json" }),
+  triggers: text("triggers", { mode: "json" }),
+  emailHandle: text("email_handle").unique(),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString()),
+  updatedAt: text("updated_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [primaryKey({ columns: [t.id, t.workspaceId] })]);
+var agentWhitelist = sqliteTable("agent_whitelist", {
+  id: text("id").primaryKey().$defaultFn(() => nanoid3()),
+  agentId: text("agent_id").notNull(),
+  workspaceId: text("workspace_id").notNull(),
+  email: text("email").notNull(),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [
+  unique("agent_whitelist_agent_ws_email").on(t.agentId, t.workspaceId, t.email),
+  foreignKey({
+    columns: [t.agentId, t.workspaceId],
+    foreignColumns: [agent.id, agent.workspaceId]
+  }).onDelete("cascade")
+]);
+var channel = sqliteTable("channel", {
+  id: text("id").primaryKey().$defaultFn(() => "ch_" + nanoid3()),
+  workspaceId: text("workspace_id").notNull().references(() => workspace.id, { onDelete: "cascade" }),
+  name: text("name").notNull(),
+  position: integer2("position").notNull().default(0),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [
+  unique("channel_workspace_name").on(t.workspaceId, t.name),
+  index("idx_channel_workspace").on(t.workspaceId)
+]);
+var conversation = sqliteTable("conversation", {
+  id: text("id").primaryKey().$defaultFn(() => nanoid3()),
+  workspaceId: text("workspace_id").notNull().references(() => workspace.id, { onDelete: "cascade" }),
+  agentId: text("agent_id").notNull(),
+  userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+  title: text("title").notNull().default(""),
+  type: text("type").notNull().default(TASK_TYPES.USER_DM_MESSAGE),
+  channel: text("channel").notNull().default("default"),
+  parentMessageId: text("parent_message_id"),
+  threadTitle: text("thread_title").notNull().default(""),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [
+  index("idx_conversation_agent_lookup").on(t.workspaceId, t.agentId, t.userId, t.type, t.channel, t.createdAt),
+  index("idx_conversation_ws_user").on(t.workspaceId, t.userId, t.createdAt),
+  index("idx_conversation_thread").on(t.parentMessageId),
+  unique("uq_conversation_parent_message").on(t.parentMessageId, t.workspaceId),
+  foreignKey({
+    columns: [t.agentId, t.workspaceId],
+    foreignColumns: [agent.id, agent.workspaceId]
+  }).onDelete("cascade")
+]);
+var message = sqliteTable("message", {
+  id: text("id").primaryKey().$defaultFn(() => nanoid3()),
+  conversationId: text("conversation_id").notNull().references(() => conversation.id, { onDelete: "cascade" }),
+  role: text("role").notNull(),
+  content: text("content").notNull().default(""),
+  taskId: text("task_id"),
+  attachmentIds: text("attachment_ids"),
+  metadata: text("metadata"),
+  status: text("status").notNull().default("active"),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [
+  index("idx_message_conversation_status").on(t.conversationId, t.status)
+]);
+var agentTaskQueue = sqliteTable("agent_task_queue", {
+  id: text("id").primaryKey().$defaultFn(() => nanoid3()),
+  agentId: text("agent_id").notNull(),
+  runtimeId: text("runtime_id").notNull().references(() => agentRuntime.id, { onDelete: "cascade" }),
+  workspaceId: text("workspace_id").notNull().references(() => workspace.id, { onDelete: "cascade" }),
+  conversationId: text("conversation_id").notNull().references(() => conversation.id, { onDelete: "cascade" }),
+  prompt: text("prompt").notNull(),
+  type: text("type").notNull().default(TASK_TYPES.USER_DM_MESSAGE),
+  contextKey: text("context_key"),
+  status: text("status").notNull().default("queued"),
+  priority: integer2("priority").notNull().default(0),
+  result: text("result", { mode: "json" }),
+  context: text("context", { mode: "json" }),
+  sessionId: text("session_id"),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString()),
+  dispatchedAt: text("dispatched_at"),
+  startedAt: text("started_at"),
+  completedAt: text("completed_at"),
+  error: text("error"),
+  traceId: text("trace_id"),
+  parentTaskId: text("parent_task_id")
+}, (t) => [
+  index("idx_task_queue_pending").on(t.agentId, t.status).where(sql`status IN ('queued', 'dispatched')`),
+  index("idx_task_queue_workspace_active").on(t.workspaceId, t.status, t.agentId).where(sql`status IN ('queued', 'dispatched', 'running')`),
+  index("idx_task_queue_agent_history").on(t.agentId, t.workspaceId, t.createdAt),
+  index("idx_task_queue_conversation_status").on(t.conversationId, t.status),
+  index("idx_task_queue_trace").on(t.traceId),
+  index("idx_task_queue_parent").on(t.parentTaskId),
+  index("idx_task_queue_workspace_type_status").on(t.workspaceId, t.type, t.status),
+  index("idx_task_queue_workspace_status_dispatched").on(t.workspaceId, t.status, t.dispatchedAt),
+  index("idx_task_queue_inbox").on(t.workspaceId, t.status, t.completedAt),
+  index("idx_task_queue_runtime_pending").on(t.workspaceId, t.runtimeId, t.status).where(sql`status IN ('queued', 'dispatched')`),
+  index("idx_task_queue_agent_running").on(t.agentId, t.workspaceId, t.status).where(sql`status IN ('dispatched', 'running')`),
+  index("idx_task_queue_inbox_convo").on(t.workspaceId, t.status, t.conversationId, t.completedAt).where(sql`status IN ('completed', 'failed') AND parent_task_id IS NULL`),
+  foreignKey({
+    columns: [t.agentId, t.workspaceId],
+    foreignColumns: [agent.id, agent.workspaceId]
+  }).onDelete("cascade")
+]);
+var issue2 = sqliteTable("issue", {
+  id: text("id").primaryKey().$defaultFn(() => "iss_" + nanoid3()),
+  workspaceId: text("workspace_id").notNull().references(() => workspace.id, { onDelete: "cascade" }),
+  agentId: text("agent_id"),
+  creatorUserId: text("creator_user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+  conversationId: text("conversation_id").references(() => conversation.id, { onDelete: "cascade" }),
+  latestTaskId: text("latest_task_id").references(() => agentTaskQueue.id, {
+    onDelete: "set null"
+  }),
+  title: text("title").notNull(),
+  description: text("description").notNull().default(""),
+  status: text("status").notNull().default("todo"),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString()),
+  updatedAt: text("updated_at").notNull().$defaultFn(() => new Date().toISOString()),
+  completedAt: text("completed_at")
+}, (t) => [
+  index("idx_issue_workspace_status_agent").on(t.workspaceId, t.status, t.agentId),
+  index("idx_issue_workspace_updated").on(t.workspaceId, t.updatedAt),
+  unique("issue_conversation_unique").on(t.conversationId),
+  foreignKey({
+    columns: [t.agentId, t.workspaceId],
+    foreignColumns: [agent.id, agent.workspaceId]
+  }).onDelete("cascade")
+]);
+var issueComment = sqliteTable("issue_comment", {
+  id: text("id").primaryKey().$defaultFn(() => "ic_" + nanoid3()),
+  issueId: text("issue_id").notNull().references(() => issue2.id, { onDelete: "cascade" }),
+  workspaceId: text("workspace_id").notNull().references(() => workspace.id, { onDelete: "cascade" }),
+  authorType: text("author_type").notNull().default("user"),
+  authorId: text("author_id").notNull(),
+  content: text("content").notNull(),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [
+  index("idx_issue_comment_issue").on(t.issueId, t.createdAt),
+  index("idx_issue_comment_workspace").on(t.workspaceId, t.issueId)
+]);
+var taskMessage = sqliteTable("task_message", {
+  id: text("id").primaryKey().$defaultFn(() => nanoid3()),
+  taskId: text("task_id").notNull().references(() => agentTaskQueue.id, { onDelete: "cascade" }),
+  seq: integer2("seq").notNull(),
+  type: text("type").notNull().default(""),
+  tool: text("tool").notNull().default(""),
+  content: text("content").notNull().default(""),
+  callId: text("call_id").notNull().default(""),
+  input: text("input", { mode: "json" }),
+  output: text("output").notNull().default(""),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [
+  index("idx_task_message_task_seq").on(t.taskId, t.seq),
+  index("idx_task_message_task_created").on(t.taskId, t.createdAt)
+]);
+var emails = sqliteTable("emails", {
+  id: text("id").primaryKey().$defaultFn(() => nanoid3()),
+  agentId: text("agent_id").notNull(),
+  workspaceId: text("workspace_id").notNull(),
+  fromEmail: text("from_email").notNull(),
+  toEmail: text("to_email").notNull(),
+  subject: text("subject").notNull().default(""),
+  r2Key: text("r2_key").notNull(),
+  isWhitelisted: integer2("is_whitelisted", { mode: "boolean" }).notNull().default(false),
+  forwarded: integer2("forwarded", { mode: "boolean" }).notNull().default(false),
+  messageId: text("message_id").notNull().default(""),
+  inReplyTo: text("in_reply_to").notNull().default(""),
+  references: text("references").notNull().default(""),
+  htmlBody: text("html_body").notNull().default(""),
+  attachments: text("attachments").notNull().default("[]"),
+  status: text("status").notNull().default("unread"),
+  direction: text("direction").notNull().default("inbound"),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [
+  foreignKey({
+    columns: [t.agentId, t.workspaceId],
+    foreignColumns: [agent.id, agent.workspaceId]
+  }).onDelete("cascade"),
+  index("idx_emails_agent_ws_status").on(t.agentId, t.workspaceId, t.status),
+  index("idx_emails_to_direction").on(t.toEmail, t.direction),
+  index("idx_emails_from_direction").on(t.fromEmail, t.direction),
+  index("idx_emails_message_id").on(t.messageId),
+  index("idx_emails_created_at").on(t.createdAt)
+]);
+var calendarEvent = sqliteTable("calendar_event", {
+  id: text("id").primaryKey().$defaultFn(() => "ce_" + nanoid3()),
+  agentId: text("agent_id").notNull(),
+  workspaceId: text("workspace_id").notNull(),
+  title: text("title").notNull(),
+  description: text("description"),
+  scheduledAt: text("scheduled_at").notNull(),
+  repeatInterval: text("repeat_interval"),
+  repeatStopAt: text("repeat_stop_at"),
+  lastTriggeredAt: text("last_triggered_at"),
+  exceptions: text("exceptions", { mode: "json" }).$type().notNull().default(sql`'[]'`),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString()),
+  updatedAt: text("updated_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [
+  index("idx_calendar_event_agent_ws").on(t.agentId, t.workspaceId),
+  index("idx_calendar_event_ws_scheduled").on(t.workspaceId, t.scheduledAt),
+  foreignKey({
+    columns: [t.agentId, t.workspaceId],
+    foreignColumns: [agent.id, agent.workspaceId]
+  }).onDelete("cascade")
+]);
+var artifact = sqliteTable("artifact", {
+  id: text("id").primaryKey().$defaultFn(() => "art_" + nanoid3()),
+  conversationId: text("conversation_id").notNull().references(() => conversation.id, { onDelete: "cascade" }),
+  agentId: text("agent_id").notNull(),
+  workspaceId: text("workspace_id").notNull().references(() => workspace.id, { onDelete: "cascade" }),
+  filename: text("filename").notNull(),
+  contentType: text("content_type").notNull().default("application/octet-stream"),
+  size: integer2("size").notNull(),
+  r2Key: text("r2_key").notNull(),
+  thumbnailR2Key: text("thumbnail_r2_key"),
+  source: text("source").notNull().default("agent"),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [
+  index("idx_artifact_conversation").on(t.conversationId),
+  foreignKey({
+    columns: [t.agentId, t.workspaceId],
+    foreignColumns: [agent.id, agent.workspaceId]
+  }).onDelete("cascade")
+]);
+var agentEmailAccount = sqliteTable("agent_email_account", {
+  id: text("id").primaryKey().$defaultFn(() => "aea_" + nanoid3()),
+  agentId: text("agent_id").notNull(),
+  workspaceId: text("workspace_id").notNull(),
+  emailAddress: text("email_address").notNull(),
+  displayName: text("display_name").notNull().default(""),
+  imapHost: text("imap_host").notNull(),
+  imapPort: integer2("imap_port").notNull().default(993),
+  imapUsername: text("imap_username").notNull(),
+  imapPassword: text("imap_password").notNull(),
+  imapTls: integer2("imap_tls", { mode: "boolean" }).notNull().default(true),
+  smtpHost: text("smtp_host").notNull(),
+  smtpPort: integer2("smtp_port").notNull().default(587),
+  smtpUsername: text("smtp_username").notNull(),
+  smtpPassword: text("smtp_password").notNull(),
+  smtpTls: integer2("smtp_tls").notNull().default(1),
+  pollIntervalSeconds: integer2("poll_interval_seconds").notNull().default(60),
+  lastSyncedUid: text("last_synced_uid").notNull().default("0"),
+  lastSyncedAt: text("last_synced_at"),
+  status: text("status").notNull().default("active"),
+  errorMessage: text("error_message").notNull().default(""),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString()),
+  updatedAt: text("updated_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [
+  index("idx_email_account_agent_ws").on(t.agentId, t.workspaceId),
+  unique("email_account_agent_email").on(t.agentId, t.emailAddress),
+  foreignKey({
+    columns: [t.agentId, t.workspaceId],
+    foreignColumns: [agent.id, agent.workspaceId]
+  }).onDelete("cascade")
+]);
+var meetingSession = sqliteTable("meeting_session", {
+  id: text("id").primaryKey().$defaultFn(() => "ms_" + nanoid3()),
+  agentId: text("agent_id").notNull(),
+  workspaceId: text("workspace_id").notNull(),
+  title: text("title").notNull().default(""),
+  meetingUrl: text("meeting_url").notNull(),
+  status: text("status").notNull().default("scheduled"),
+  fromEmail: text("from_email"),
+  isWhitelisted: integer2("is_whitelisted", { mode: "boolean" }).notNull().default(true),
+  participants: text("participants", { mode: "json" }).$type().notNull().default([]),
+  scheduledAt: text("scheduled_at"),
+  startedAt: text("started_at"),
+  completedAt: text("completed_at"),
+  transcriptR2Key: text("transcript_r2_key"),
+  summary: text("summary"),
+  error: text("error"),
+  workerSessionId: text("worker_session_id"),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString()),
+  updatedAt: text("updated_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [
+  index("idx_meeting_session_agent_ws").on(t.agentId, t.workspaceId),
+  index("idx_meeting_session_status").on(t.status),
+  foreignKey({
+    columns: [t.agentId, t.workspaceId],
+    foreignColumns: [agent.id, agent.workspaceId]
+  }).onDelete("cascade")
+]);
+var machineToken = sqliteTable("machine_token", {
+  id: text("id").primaryKey().$defaultFn(() => nanoid3()),
+  userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+  workspaceId: text("workspace_id").references(() => workspace.id, { onDelete: "cascade" }),
+  token: text("token").unique().notNull(),
+  name: text("name").notNull().default(""),
+  status: text("status").notNull().default("active"),
+  hostname: text("hostname"),
+  runtimesJson: text("runtimes_json"),
+  lastUsedAt: text("last_used_at"),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [index("idx_machine_token").on(t.token)]);
+var messageFlag = sqliteTable("message_flag", {
+  id: text("id").primaryKey().$defaultFn(() => nanoid3()),
+  messageId: text("message_id").notNull().references(() => message.id, { onDelete: "cascade" }),
+  userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+  workspaceId: text("workspace_id").notNull().references(() => workspace.id, { onDelete: "cascade" }),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [
+  unique("message_flag_message_user").on(t.messageId, t.userId),
+  index("idx_message_flag_ws_user_created").on(t.workspaceId, t.userId, t.createdAt),
+  index("idx_message_flag_message_user").on(t.messageId, t.userId)
+]);
+var conversationMap = sqliteTable("conversation_map", {
+  id: text("id").primaryKey().$defaultFn(() => nanoid3()),
+  key: text("key").notNull(),
+  workspaceId: text("workspace_id").notNull().references(() => workspace.id, { onDelete: "cascade" }),
+  conversationId: text("conversation_id").notNull().references(() => conversation.id, { onDelete: "cascade" }),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [
+  unique("conversation_map_key_workspace").on(t.key, t.workspaceId)
+]);
+var agentLink = sqliteTable("agent_link", {
+  id: text("id").primaryKey().$defaultFn(() => "al_" + nanoid3()),
+  workspaceId: text("workspace_id").notNull(),
+  sourceAgentId: text("source_agent_id").notNull(),
+  targetAgentId: text("target_agent_id").notNull(),
+  instruction: text("instruction").notNull().default(""),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString()),
+  updatedAt: text("updated_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [
+  unique("agent_link_ws_source_target").on(t.workspaceId, t.sourceAgentId, t.targetAgentId),
+  index("idx_agent_link_workspace").on(t.workspaceId),
+  foreignKey({
+    columns: [t.sourceAgentId, t.workspaceId],
+    foreignColumns: [agent.id, agent.workspaceId]
+  }).onDelete("cascade"),
+  foreignKey({
+    columns: [t.targetAgentId, t.workspaceId],
+    foreignColumns: [agent.id, agent.workspaceId]
+  }).onDelete("cascade")
+]);
+var conversationReadState = sqliteTable("conversation_read_state", {
+  id: text("id").primaryKey().$defaultFn(() => nanoid3()),
+  conversationId: text("conversation_id").notNull().references(() => conversation.id, { onDelete: "cascade" }),
+  userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+  lastReadAt: text("last_read_at").notNull().default("1970-01-01T00:00:00.000Z"),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [
+  unique("conversation_read_state_conv_user").on(t.conversationId, t.userId),
+  index("idx_conversation_read_state_user").on(t.userId)
+]);
+var workspaceFileRequest = sqliteTable("workspace_file_request", {
+  id: text("id").primaryKey().$defaultFn(() => "wfr_" + nanoid3()),
+  workspaceId: text("workspace_id").notNull().references(() => workspace.id, { onDelete: "cascade" }),
+  agentId: text("agent_id").notNull(),
+  requestType: text("request_type").notNull(),
+  path: text("path").notNull().default("."),
+  status: text("status").notNull().default("pending"),
+  result: text("result"),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString()),
+  updatedAt: text("updated_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [
+  index("idx_wfr_workspace_status").on(t.workspaceId, t.status)
+]);
+var agentSkill = sqliteTable("agent_skill", {
+  id: text("id").primaryKey().$defaultFn(() => "as_" + nanoid3()),
+  workspaceId: text("workspace_id").notNull().references(() => workspace.id, { onDelete: "cascade" }),
+  agentId: text("agent_id"),
+  daemonId: text("daemon_id"),
+  runtime: text("runtime").notNull(),
+  name: text("name").notNull(),
+  description: text("description").notNull().default(""),
+  syncedAt: text("synced_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [
+  unique("agent_skill_ws_runtime_name_agent_daemon").on(t.workspaceId, t.runtime, t.name, t.agentId, t.daemonId),
+  index("idx_as_workspace_runtime").on(t.workspaceId, t.runtime),
+  index("idx_as_agent_runtime").on(t.agentId, t.runtime),
+  foreignKey({
+    columns: [t.agentId, t.workspaceId],
+    foreignColumns: [agent.id, agent.workspaceId]
+  }).onDelete("cascade")
+]);
+var inboxUnread = sqliteTable("inbox_unread", {
+  id: text("id").primaryKey().$defaultFn(() => nanoid3()),
+  conversationId: text("conversation_id").notNull().references(() => conversation.id, { onDelete: "cascade" }),
+  userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+  workspaceId: text("workspace_id").notNull(),
+  agentId: text("agent_id").notNull(),
+  taskId: text("task_id").notNull(),
+  taskType: text("task_type").notNull(),
+  taskStatus: text("task_status").notNull(),
+  taskPrompt: text("task_prompt"),
+  completedAt: text("completed_at").notNull(),
+  latestMessageId: text("latest_message_id")
+}, (t) => [
+  unique("inbox_unread_conv_user").on(t.conversationId, t.userId),
+  index("idx_inbox_unread_user_ws").on(t.userId, t.workspaceId, t.taskType, t.completedAt)
+]);
+
+// ../shared/src/db/community-machine-schema.ts
+var DIAGNOSTIC_REPORT_FAILURE_CODES = [
+  "offline",
+  "timeout",
+  "upload_conflict",
+  "invalid_upload",
+  "diagnostics_unavailable",
+  "collector_busy",
+  "bot_not_bound",
+  "collection_failed",
+  "local_artifact_invalid",
+  "bundle_too_large",
+  "upload_failed",
+  "internal_error"
+];
+var communityDiagnosticReport = sqliteTable("community_diagnostic_report", {
+  id: text("id").primaryKey().$defaultFn(() => "dbr_" + nanoid3()),
+  ownerUserId: text("owner_user_id").notNull(),
+  agentId: text("agent_id").notNull(),
+  machineId: text("machine_id").notNull(),
+  clientNonce: text("client_nonce").notNull(),
+  rateBucket: integer2("rate_bucket").notNull(),
+  status: text("status").$type().notNull().default("pending"),
+  failureCode: text("failure_code").$type(),
+  fromMs: integer2("from_ms").notNull(),
+  createdAt: integer2("created_at").notNull(),
+  deadlineAt: integer2("deadline_at").notNull(),
+  completedAt: integer2("completed_at"),
+  r2Key: text("r2_key"),
+  sha256: text("sha256"),
+  sizeBytes: integer2("size_bytes"),
+  uploadedAt: integer2("uploaded_at"),
+  objectExpiresAt: integer2("object_expires_at")
+}, (t) => [
+  index("idx_community_diagnostic_report_owner_created").on(t.ownerUserId, t.createdAt),
+  index("idx_community_diagnostic_report_machine_status_deadline").on(t.machineId, t.status, t.deadlineAt),
+  uniqueIndex("uq_community_diagnostic_report_owner_nonce").on(t.ownerUserId, t.clientNonce),
+  uniqueIndex("uq_community_diagnostic_report_owner_agent_pending").on(t.ownerUserId, t.agentId).where(sql`status = 'pending'`),
+  uniqueIndex("uq_community_diagnostic_report_owner_rate_bucket").on(t.ownerUserId, t.rateBucket),
+  check2("ck_community_diagnostic_report_id", sql`length(${t.id}) > 4 AND substr(${t.id}, 1, 4) = 'dbr_' AND ${t.id} NOT GLOB '*[^A-Za-z0-9_-]*'`),
+  check2("ck_community_diagnostic_report_nonce", sql`length(${t.clientNonce}) BETWEEN 16 AND 64 AND ${t.clientNonce} NOT GLOB '*[^A-Za-z0-9_-]*'`),
+  check2("ck_community_diagnostic_report_required_epochs", sql`typeof(${t.fromMs}) = 'integer' AND ${t.fromMs} BETWEEN 0 AND 9007199254740991
+        AND typeof(${t.createdAt}) = 'integer' AND ${t.createdAt} BETWEEN 0 AND 9007199254740991
+        AND typeof(${t.deadlineAt}) = 'integer' AND ${t.deadlineAt} BETWEEN 0 AND 9007199254740991
+        AND ${t.fromMs} = ${t.createdAt} - 86400000
+        AND ${t.deadlineAt} = ${t.createdAt} + 600000`),
+  check2("ck_community_diagnostic_report_rate_bucket", sql`typeof(${t.rateBucket}) = 'integer'
+        AND ${t.rateBucket} BETWEEN 0 AND 9007199254740991
+        AND ${t.rateBucket} = CAST(${t.createdAt} / 60000 AS INTEGER)`),
+  check2("ck_community_diagnostic_report_nullable_epochs", sql`(${t.completedAt} IS NULL OR (typeof(${t.completedAt}) = 'integer' AND ${t.completedAt} BETWEEN 0 AND 9007199254740991))
+        AND (${t.uploadedAt} IS NULL OR (typeof(${t.uploadedAt}) = 'integer' AND ${t.uploadedAt} BETWEEN 0 AND 9007199254740991))
+        AND (${t.objectExpiresAt} IS NULL OR (typeof(${t.objectExpiresAt}) = 'integer' AND ${t.objectExpiresAt} BETWEEN 0 AND 9007199254740991))`),
+  check2("ck_community_diagnostic_report_size", sql`${t.sizeBytes} IS NULL OR (typeof(${t.sizeBytes}) = 'integer' AND ${t.sizeBytes} BETWEEN 1 AND 10485760)`),
+  check2("ck_community_diagnostic_report_sha256", sql`${t.sha256} IS NULL OR (length(${t.sha256}) = 64 AND ${t.sha256} NOT GLOB '*[^0-9a-f]*')`),
+  check2("ck_community_diagnostic_report_state", sql`(
+          ${t.status} = 'pending'
+          AND ${t.failureCode} IS NULL AND ${t.completedAt} IS NULL
+          AND ${t.r2Key} IS NULL AND ${t.sha256} IS NULL AND ${t.sizeBytes} IS NULL
+          AND ${t.uploadedAt} IS NULL AND ${t.objectExpiresAt} IS NULL
+        ) OR (
+          ${t.status} = 'failed'
+          AND ${t.failureCode} IN ('offline', 'timeout', 'upload_conflict', 'invalid_upload', 'diagnostics_unavailable', 'collector_busy', 'bot_not_bound', 'collection_failed', 'local_artifact_invalid', 'bundle_too_large', 'upload_failed', 'internal_error')
+          AND ${t.completedAt} IS NOT NULL
+          AND ${t.completedAt} >= ${t.createdAt}
+          AND ${t.r2Key} IS NULL AND ${t.sha256} IS NULL AND ${t.sizeBytes} IS NULL
+          AND ${t.uploadedAt} IS NULL AND ${t.objectExpiresAt} IS NULL
+        ) OR (
+          ${t.status} = 'uploaded'
+          AND ${t.failureCode} IS NULL AND ${t.completedAt} IS NOT NULL
+          AND ${t.completedAt} >= ${t.createdAt}
+          AND ${t.r2Key} IS NOT NULL
+          AND ${t.r2Key} = 'bug-reports/' || ${t.ownerUserId} || '/' || ${t.id} || '.ndjson.gz'
+          AND ${t.sha256} IS NOT NULL AND ${t.sizeBytes} IS NOT NULL
+          AND ${t.uploadedAt} IS NOT NULL AND ${t.objectExpiresAt} IS NOT NULL
+          AND ${t.completedAt} = ${t.uploadedAt}
+          AND ${t.objectExpiresAt} = ${t.uploadedAt} + 604800000
+        )`)
+]);
+var communityMachineToken = sqliteTable("community_machine_token", {
+  id: text("id").primaryKey().$defaultFn(() => "cmt_" + nanoid3(32)),
+  userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+  machineId: text("machine_id"),
+  status: text("status").notNull().default("pending"),
+  expiresAt: text("expires_at").notNull(),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString()),
+  lastUsedAt: text("last_used_at")
+}, (t) => [
+  index("idx_community_machine_token_user_status").on(t.userId, t.status),
+  uniqueIndex("uq_community_machine_token_user_pending").on(t.userId).where(sql`status = 'pending'`)
+]);
+var communityMachine = sqliteTable("community_machine", {
+  id: text("id").primaryKey().$defaultFn(() => "cm_" + nanoid3()),
+  userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+  displayName: text("display_name").notNull().default(""),
+  hostname: text("hostname").notNull().default(""),
+  platform: text("platform").notNull().default(""),
+  arch: text("arch").notNull().default(""),
+  osRelease: text("os_release").notNull().default(""),
+  daemonVersion: text("daemon_version").notNull().default(""),
+  metadata: text("metadata"),
+  availableRuntimes: text("available_runtimes", { mode: "json" }).$type().notNull().default([]),
+  status: text("status").notNull().default("offline"),
+  lastSeenAt: text("last_seen_at"),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString()),
+  updatedAt: text("updated_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [
+  index("idx_community_machine_user_last_seen").on(t.userId, t.lastSeenAt),
+  index("idx_community_machine_user_updated").on(t.userId, t.updatedAt),
+  index("idx_community_machine_user_status").on(t.userId, t.status)
+]);
+var communityMachineCredential = sqliteTable("community_machine_credential", {
+  id: text("id").primaryKey().$defaultFn(() => "cmkid_" + nanoid3()),
+  userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+  machineId: text("machine_id").notNull().references(() => communityMachine.id, { onDelete: "cascade" }),
+  credentialHash: text("credential_hash").notNull().unique(),
+  doName: text("do_name").notNull().unique(),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString()),
+  lastUsedAt: text("last_used_at"),
+  revokedAt: text("revoked_at")
+}, (t) => [
+  index("idx_community_machine_credential_user").on(t.userId),
+  index("idx_community_machine_credential_machine").on(t.machineId)
+]);
+var communityBotBinding = sqliteTable("community_bot_binding", {
+  userId: text("user_id").primaryKey().references(() => user.id, { onDelete: "cascade" }),
+  machineId: text("machine_id").notNull().references(() => communityMachine.id, { onDelete: "restrict" }),
+  runtime: text("runtime").notNull(),
+  modelName: text("model_name"),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString())
+}, (t) => [index("idx_community_bot_binding_machine").on(t.machineId)]);
+var communityAgentRunnerKey = sqliteTable("community_agent_runner_key", {
+  id: text("id").primaryKey().$defaultFn(() => "crkid_" + nanoid3()),
+  userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+  machineId: text("machine_id").notNull().references(() => communityMachine.id, { onDelete: "cascade" }),
+  agentId: text("agent_id").notNull(),
+  runnerKeyHash: text("runner_key_hash").notNull().unique(),
+  doName: text("do_name").notNull().unique(),
+  createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString()),
+  revokedAt: text("revoked_at")
+}, (t) => [
+  index("idx_community_agent_runner_key_machine_agent").on(t.machineId, t.agentId)
+]);
+
+// ../shared/src/diagnostics-contract.ts
+var DIAGNOSTIC_REPORT_COLLECTION_WINDOW_MS = 86400000;
+var DIAGNOSTIC_REPORT_DEADLINE_WINDOW_MS = 600000;
+var DIAGNOSTIC_COLLECT_SPAN_MS = DIAGNOSTIC_REPORT_COLLECTION_WINDOW_MS + DIAGNOSTIC_REPORT_DEADLINE_WINDOW_MS;
+var SafeEpochSchema = exports_external.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var AgentIdSchema = exports_external.string().min(1).regex(/^[A-Za-z0-9_-]+$/);
+var DiagnosticReportIdSchema = exports_external.string().regex(/^dbr_[A-Za-z0-9_-]+$/);
+var DiagnosticReportFailureCodeSchema = exports_external.enum(DIAGNOSTIC_REPORT_FAILURE_CODES);
+var DiagnosticReportCreateRequestSchema = exports_external.object({
+  clientNonce: exports_external.string().min(16).max(64).regex(/^[A-Za-z0-9_-]+$/)
+}).strict();
+var DiagnosticCollectPayloadSchema = exports_external.object({
+  reportId: DiagnosticReportIdSchema,
+  agentId: AgentIdSchema,
+  fromMs: SafeEpochSchema,
+  deadlineAt: SafeEpochSchema
+}).strict();
+var DiagnosticCollectCommandSchema = exports_external.object({
+  type: exports_external.literal("diagnostics:collect"),
+  reportId: DiagnosticReportIdSchema,
+  agentId: AgentIdSchema,
+  fromMs: SafeEpochSchema,
+  deadlineAt: SafeEpochSchema
+}).strict().refine((command) => command.deadlineAt - command.fromMs === DIAGNOSTIC_COLLECT_SPAN_MS, { message: "diagnostic collection span must match v1" });
+var OwnerDiagnosticReportBase = {
+  reportId: DiagnosticReportIdSchema,
+  deadlineAt: SafeEpochSchema
+};
+var OwnerDiagnosticReportSchema = exports_external.discriminatedUnion("status", [
+  exports_external.object({
+    ...OwnerDiagnosticReportBase,
+    status: exports_external.literal("pending"),
+    completedAt: exports_external.null(),
+    failureCode: exports_external.null(),
+    objectExpired: exports_external.literal(false)
+  }).strict(),
+  exports_external.object({
+    ...OwnerDiagnosticReportBase,
+    status: exports_external.literal("uploaded"),
+    completedAt: SafeEpochSchema,
+    failureCode: exports_external.null(),
+    objectExpired: exports_external.boolean()
+  }).strict(),
+  exports_external.object({
+    ...OwnerDiagnosticReportBase,
+    status: exports_external.literal("failed"),
+    completedAt: SafeEpochSchema,
+    failureCode: DiagnosticReportFailureCodeSchema,
+    objectExpired: exports_external.literal(false)
+  }).strict()
+]);
+
+// ../shared/src/community-cli-contract.ts
+var HostCommandSchema = exports_external.discriminatedUnion("type", [
+  exports_external.object({
+    type: exports_external.literal("agent:wake"),
+    agentId: exports_external.string().min(1),
+    config: exports_external.unknown(),
+    sessionId: exports_external.string().optional(),
+    launchId: exports_external.string().min(1),
+    unreadNotice: exports_external.unknown()
+  }),
+  exports_external.object({
+    type: exports_external.literal("agent:stop"),
+    agentId: exports_external.string().min(1)
+  }),
+  exports_external.object({
+    type: exports_external.literal("agent:reset"),
+    agentId: exports_external.string().min(1),
+    config: exports_external.unknown(),
+    launchId: exports_external.string().min(1)
+  }),
+  exports_external.object({
+    type: exports_external.literal("agent:nap"),
+    agentId: exports_external.string().min(1),
+    config: exports_external.unknown(),
+    launchId: exports_external.string().min(1),
+    handoff: exports_external.string().min(1)
+  }),
+  exports_external.object({
+    type: exports_external.literal("agent:model_switch"),
+    agentId: exports_external.string().min(1),
+    config: exports_external.unknown(),
+    launchId: exports_external.string().min(1)
+  }),
+  exports_external.object({
+    type: exports_external.literal("machine:reset_all"),
+    resets: exports_external.array(exports_external.object({
+      agentId: exports_external.string().min(1),
+      config: exports_external.unknown(),
+      launchId: exports_external.string().min(1)
+    }))
+  }),
+  exports_external.object({
+    type: exports_external.literal("bot:added"),
+    botId: exports_external.string().min(1),
+    name: exports_external.string().optional(),
+    discriminator: exports_external.string().optional(),
+    description: exports_external.string().optional(),
+    ownerName: exports_external.string().optional(),
+    ownerDiscriminator: exports_external.string().optional()
+  }),
+  exports_external.object({
+    type: exports_external.literal("bot:updated"),
+    botId: exports_external.string().min(1),
+    name: exports_external.string().optional(),
+    discriminator: exports_external.string().optional(),
+    description: exports_external.string().optional(),
+    ownerName: exports_external.string().optional(),
+    ownerDiscriminator: exports_external.string().optional()
+  }),
+  exports_external.object({
+    type: exports_external.literal("bot:removed"),
+    botId: exports_external.string().min(1)
+  }),
+  DiagnosticCollectCommandSchema
+]);
+// src/server/wsControlChannel.ts
+var WS_CONTROL_COMMAND_CONSUMED = Symbol("ws-control-command-consumed");
+var DEFAULT_PING_INTERVAL_MS = 15000;
+var DEFAULT_PONG_TIMEOUT_MS = 30000;
+var DEFAULT_RECONNECT_BASE_MS = 500;
+var DEFAULT_RECONNECT_MAX_MS = 30000;
+function describeErr(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+class WsControlChannel {
+  opts;
+  statusValue = "idle";
+  commandCbs = [];
+  resyncHooks = [];
+  ws = null;
+  attempt = 0;
+  closedByUser = false;
+  authRejected = false;
+  pingTimer = null;
+  pongDeadline = 0;
+  resyncProvider = null;
+  log;
+  constructor(opts) {
+    this.opts = opts;
+    this.log = opts.logger ?? createLogger({ header: "@alook/daemon:ws" });
+  }
+  get status() {
+    return this.statusValue;
+  }
+  connect() {
+    this.closedByUser = false;
+    this.authRejected = false;
+    this.openSocket();
+  }
+  close() {
+    this.closedByUser = true;
+    this.clearHeartbeat();
+    this.ws?.close();
+    this.ws = null;
+    this.statusValue = "closed";
+  }
+  onCommand(cb) {
+    this.commandCbs.push(cb);
+  }
+  onResync(provider) {
+    this.resyncProvider = provider;
+  }
+  onOpen(hook) {
+    this.resyncHooks.push(hook);
+  }
+  async reportReady(ready) {
+    this.sendFrame({ type: "ready", ...ready });
+  }
+  sendReady(ready) {
+    this.sendFrame({ type: "ready", ...ready });
+  }
+  async reportAgentSession(info) {
+    this.sendFrame({ type: "agent_session", ...info });
+  }
+  async reportAgentActivity(info) {
+    this.sendFrame({ type: "agent_activity", ...info });
+  }
+  reportAgentTyping(info) {
+    this.sendFrame({ type: "agent_typing", ...info });
+  }
+  reportAgentTypingStop(info) {
+    this.sendFrame({ type: "agent_typing_stop", ...info });
+  }
+  async reportBotAuditEvent(frame) {
+    this.sendFrame(frame);
+  }
+  async reportWakeAck(info) {
+    this.sendFrame({ type: "agent_wake_ack", ...info });
+  }
+  async reportStoppedAck(info) {
+    this.sendFrame({ type: "agent_stopped_ack", ...info });
+  }
+  async reportSessionError(frame) {
+    this.sendFrame(frame);
+  }
+  sendFrame(frame) {
+    if (this.statusValue !== "open" || !this.ws) {
       this.log.debug("frame dropped — socket not open", { type: frame.type });
       return;
     }
@@ -19850,7 +22407,10 @@ class WsControlChannel {
     const cmd = parsed.data;
     for (const cb of this.commandCbs) {
       try {
-        Promise.resolve(cb(cmd)).catch((err) => {
+        const result = cb(cmd);
+        if (result === WS_CONTROL_COMMAND_CONSUMED)
+          break;
+        Promise.resolve(result).catch((err) => {
           this.log.warn("command listener threw", { type: cmd.type, err: describeErr(err) });
         });
       } catch (err) {
@@ -19910,8 +22470,9 @@ class WsControlChannel {
   }
 }
 // src/timeline/timeline.ts
-import { appendFileSync as appendFileSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync6, renameSync as renameSync3, existsSync as existsSync6 } from "fs";
-import { join as join9 } from "path";
+import * as fs7 from "node:fs";
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { basename, dirname as dirname2, join as join9 } from "node:path";
 
 // src/timeline/filelock.ts
 import * as fs6 from "fs";
@@ -19974,6 +22535,261 @@ function reclaim(lockPath) {
 }
 
 // src/timeline/timeline.ts
+var TIMELINE_MAX_BYTES = 1048576;
+var TIMELINE_READ_CHUNK_BYTES = 65536;
+var DATE_FILENAME_PATTERN = /^\d{4}-\d{2}-\d{2}\.jsonl$/;
+function isBarrier(entry) {
+  return entry.system?.type === "reset_session" || entry.system?.type === "nap";
+}
+function canonicalTimelineEntry(value) {
+  if (!value || typeof value !== "object")
+    return null;
+  const entry = value;
+  if (entry.system) {
+    if (entry.system.type !== "reset_session" && entry.system.type !== "nap" || typeof entry.system.time !== "string")
+      return null;
+    return createSystemEntry(entry.system.type, entry.system.time);
+  }
+  if (entry.session_id !== null && typeof entry.session_id !== "string")
+    return null;
+  if (entry.provider !== null && typeof entry.provider !== "string")
+    return null;
+  if (!Array.isArray(entry.messages) || !Array.isArray(entry.agent_responses))
+    return null;
+  if (!entry.agent_responses.every((response) => typeof response === "string"))
+    return null;
+  return {
+    session_id: entry.session_id,
+    messages: entry.messages,
+    agent_responses: entry.agent_responses.slice(-5),
+    provider: entry.provider
+  };
+}
+function timelineLine(entry) {
+  const boundedEntry = entry.system ? createSystemEntry(entry.system.type, entry.system.time) : { ...entry, agent_responses: entry.agent_responses.slice(-5) };
+  const text2 = JSON.stringify(boundedEntry);
+  const bytes = Buffer.byteLength(text2, "utf8") + 1;
+  if (bytes > TIMELINE_MAX_BYTES)
+    return null;
+  return { text: text2, bytes, entry: boundedEntry, barrier: isBarrier(boundedEntry) };
+}
+function compactLines(input) {
+  let head = 0;
+  let bytes = input.reduce((total, line) => total + line.bytes, 0);
+  let latestEvictedBarrier = null;
+  while (bytes > TIMELINE_MAX_BYTES && head < input.length) {
+    const removed = input[head++];
+    bytes -= removed.bytes;
+    if (removed.barrier)
+      latestEvictedBarrier = removed;
+  }
+  let suffix = input.slice(head);
+  if (!suffix.some((line) => line.barrier) && latestEvictedBarrier) {
+    let suffixHead = 0;
+    while (latestEvictedBarrier.bytes + bytes > TIMELINE_MAX_BYTES && suffixHead < suffix.length) {
+      bytes -= suffix[suffixHead++].bytes;
+    }
+    suffix = [latestEvictedBarrier, ...suffix.slice(suffixHead)];
+  }
+  return suffix;
+}
+function isRealDirectory(path8) {
+  try {
+    return fs7.lstatSync(path8).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function timelineDirectoryState(timelineDir) {
+  if (!isRealDirectory(dirname2(timelineDir)))
+    return "unsafe";
+  try {
+    return fs7.lstatSync(timelineDir).isDirectory() ? "safe" : "unsafe";
+  } catch (error51) {
+    return error51.code === "ENOENT" ? "missing" : "unsafe";
+  }
+}
+function prepareTimelineDirectory(timelineDir) {
+  const state = timelineDirectoryState(timelineDir);
+  if (state === "safe")
+    return true;
+  if (state === "unsafe")
+    return false;
+  try {
+    fs7.mkdirSync(timelineDir);
+  } catch (error51) {
+    if (error51.code !== "EEXIST")
+      return false;
+  }
+  return timelineDirectoryState(timelineDir) === "safe";
+}
+function scanTimelineFile(filePath) {
+  let source;
+  try {
+    source = fs7.lstatSync(filePath);
+  } catch (error51) {
+    return error51.code === "ENOENT" ? [] : null;
+  }
+  if (!source.isFile())
+    return null;
+  let fd = null;
+  try {
+    fd = fs7.openSync(filePath, fs7.constants.O_RDONLY | (fs7.constants.O_NOFOLLOW ?? 0));
+    const stat = fs7.fstatSync(fd);
+    if (!stat.isFile())
+      return null;
+    const chunk = Buffer.allocUnsafe(TIMELINE_READ_CHUNK_BYTES);
+    const newest = [];
+    let retainedBytes = 0;
+    let overflowed = false;
+    let suffixHasBarrier = false;
+    let latestEvictedBarrier = null;
+    let parts = [];
+    let partBytes = 0;
+    let oversized = false;
+    let stop = false;
+    let discardIncompleteTail = false;
+    if (stat.size > 0) {
+      const last = Buffer.allocUnsafe(1);
+      fs7.readSync(fd, last, 0, 1, stat.size - 1);
+      discardIncompleteTail = last[0] !== 10;
+    }
+    const resetPhysicalLine = () => {
+      parts = [];
+      partBytes = 0;
+      oversized = false;
+    };
+    const addPart = (part) => {
+      if (oversized)
+        return;
+      if (partBytes + part.length > TIMELINE_MAX_BYTES) {
+        parts = [];
+        partBytes = 0;
+        oversized = true;
+        return;
+      }
+      if (part.length > 0)
+        parts.push(Buffer.from(part));
+      partBytes += part.length;
+    };
+    const retain = (line) => {
+      if (!overflowed && retainedBytes + line.bytes <= TIMELINE_MAX_BYTES) {
+        newest.push(line);
+        retainedBytes += line.bytes;
+        if (line.barrier)
+          suffixHasBarrier = true;
+        return;
+      }
+      overflowed = true;
+      if (suffixHasBarrier) {
+        stop = true;
+      } else if (line.barrier) {
+        latestEvictedBarrier = line;
+        stop = true;
+      }
+    };
+    const finishPhysicalLine = (part) => {
+      addPart(part);
+      if (discardIncompleteTail) {
+        discardIncompleteTail = false;
+        resetPhysicalLine();
+        return;
+      }
+      if (!oversized && partBytes > 0) {
+        let physical = Buffer.concat([...parts].reverse(), partBytes);
+        if (physical[physical.length - 1] === 13)
+          physical = physical.subarray(0, -1);
+        if (physical.length > 0) {
+          try {
+            const entry = canonicalTimelineEntry(JSON.parse(physical.toString("utf8")));
+            const line = entry ? timelineLine(entry) : null;
+            if (line)
+              retain(line);
+          } catch {}
+        }
+      }
+      resetPhysicalLine();
+    };
+    let position = stat.size;
+    while (position > 0 && !stop) {
+      const start = Math.max(0, position - chunk.length);
+      const requested = position - start;
+      let count = 0;
+      while (count < requested) {
+        const read = fs7.readSync(fd, chunk, count, requested - count, start + count);
+        if (read <= 0)
+          break;
+        count += read;
+      }
+      if (count !== requested)
+        return null;
+      let segmentEnd = count;
+      for (let index2 = count - 1;index2 >= 0; index2--) {
+        if (chunk[index2] !== 10)
+          continue;
+        finishPhysicalLine(chunk.subarray(index2 + 1, segmentEnd));
+        segmentEnd = index2;
+        if (stop)
+          break;
+      }
+      if (!stop && segmentEnd > 0)
+        addPart(chunk.subarray(0, segmentEnd));
+      position = start;
+    }
+    if (!stop && position === 0 && (parts.length > 0 || oversized) && !discardIncompleteTail) {
+      finishPhysicalLine(Buffer.alloc(0));
+    }
+    const sentinel = latestEvictedBarrier;
+    if (sentinel && !suffixHasBarrier) {
+      while (newest.length > 0 && sentinel.bytes + retainedBytes > TIMELINE_MAX_BYTES) {
+        retainedBytes -= newest.pop().bytes;
+      }
+    }
+    const chronological = newest.reverse();
+    return sentinel && !suffixHasBarrier ? [sentinel, ...chronological] : chronological;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== null) {
+      try {
+        fs7.closeSync(fd);
+      } catch {}
+    }
+  }
+}
+function atomicReplaceTimeline(filePath, lines) {
+  const tempPath = join9(dirname2(filePath), `.${basename(filePath)}.${process.pid}.${randomBytes2(12).toString("hex")}.tmp`);
+  let fd = null;
+  try {
+    fd = fs7.openSync(tempPath, "wx", 384);
+    const body = lines.map((line) => line.text).join(`
+`) + (lines.length > 0 ? `
+` : "");
+    fs7.writeFileSync(fd, body, "utf8");
+    fs7.fsyncSync(fd);
+    fs7.closeSync(fd);
+    fd = null;
+    fs7.renameSync(tempPath, filePath);
+    return true;
+  } catch {
+    return false;
+  } finally {
+    if (fd !== null) {
+      try {
+        fs7.closeSync(fd);
+      } catch {}
+    }
+    try {
+      fs7.unlinkSync(tempPath);
+    } catch {}
+  }
+}
+function writeRequiredTimeline(filePath, input, required2) {
+  const compacted = compactLines(input);
+  if (!compacted.includes(required2))
+    return false;
+  return atomicReplaceTimeline(filePath, compacted);
+}
 function filenameForDate(date5) {
   const y = date5.getFullYear();
   const m = String(date5.getMonth() + 1).padStart(2, "0");
@@ -19990,24 +22806,11 @@ function recentFilenames(maxDays, now) {
   return out;
 }
 function readJsonl(filePath) {
-  let content;
-  try {
-    content = readFileSync4(filePath, "utf-8");
-  } catch {
-    return [];
-  }
-  const entries = [];
-  for (const line of content.trimEnd().split(`
-`)) {
-    if (!line)
-      continue;
-    try {
-      entries.push(JSON.parse(line));
-    } catch {}
-  }
-  return entries;
+  return scanTimelineFile(filePath)?.map((line) => line.entry) ?? [];
 }
 function readRecentEntries(timelineDir, opts = {}) {
+  if (timelineDirectoryState(timelineDir) !== "safe")
+    return [];
   const now = opts.now ?? new Date;
   const maxDays = opts.maxDays ?? 7;
   const filenames = recentFilenames(maxDays, now).reverse();
@@ -20018,15 +22821,19 @@ function readRecentEntries(timelineDir, opts = {}) {
   return entries;
 }
 function appendEntry(timelineDir, entry, now = new Date) {
+  if (timelineDirectoryState(timelineDir) !== "safe")
+    return false;
   const filename = filenameForDate(now);
   const filePath = join9(timelineDir, filename);
   const lockPath = lockPathFor(timelineDir, filename);
   if (!acquireLock(lockPath))
     return false;
   try {
-    appendFileSync2(filePath, JSON.stringify(entry) + `
-`);
-    return true;
+    const existing = scanTimelineFile(filePath);
+    const required2 = timelineLine(entry);
+    if (!existing || !required2)
+      return false;
+    return writeRequiredTimeline(filePath, [...existing, required2], required2);
   } catch {
     return false;
   } finally {
@@ -20034,77 +22841,147 @@ function appendEntry(timelineDir, entry, now = new Date) {
   }
 }
 function appendOrMergeEntry(timelineDir, entry, now = new Date) {
+  if (timelineDirectoryState(timelineDir) !== "safe")
+    return false;
   const filename = filenameForDate(now);
   const filePath = join9(timelineDir, filename);
   const lockPath = lockPathFor(timelineDir, filename);
   if (!acquireLock(lockPath))
     return false;
   try {
-    let lines = [];
-    if (existsSync6(filePath)) {
-      lines = readFileSync4(filePath, "utf-8").trimEnd().split(`
-`).filter(Boolean);
-    }
-    if (lines.length > 0) {
-      const latest = JSON.parse(lines[lines.length - 1]);
+    const existing = scanTimelineFile(filePath);
+    if (!existing)
+      return false;
+    if (existing.length > 0) {
+      const latest = existing[existing.length - 1].entry;
       const mergeable = !latest.system && !entry.system && latest.session_id === entry.session_id && latest.provider === entry.provider && latest.agent_responses.length === 0;
       if (mergeable) {
-        latest.messages = [...latest.messages, ...entry.messages];
-        lines[lines.length - 1] = JSON.stringify(latest);
-        const tmpPath = join9(timelineDir, `.${filename}.tmp`);
-        writeFileSync6(tmpPath, lines.join(`
-`) + `
-`);
-        renameSync3(tmpPath, filePath);
-        return true;
+        const merged = {
+          ...latest,
+          messages: [...latest.messages, ...entry.messages],
+          agent_responses: [...latest.agent_responses]
+        };
+        const required3 = timelineLine(merged);
+        if (!required3)
+          return false;
+        return writeRequiredTimeline(filePath, [...existing.slice(0, -1), required3], required3);
       }
     }
-    appendFileSync2(filePath, JSON.stringify(entry) + `
-`);
-    return true;
+    const required2 = timelineLine(entry);
+    if (!required2)
+      return false;
+    return writeRequiredTimeline(filePath, [...existing, required2], required2);
   } catch {
     return false;
   } finally {
     releaseLock(lockPath);
   }
 }
-function updateLatestEntry(timelineDir, updater, opts = {}) {
+function updateLatestEntryResult(timelineDir, updater, opts = {}) {
+  const directoryState = timelineDirectoryState(timelineDir);
+  if (directoryState !== "safe")
+    return directoryState === "missing" ? "missing" : "rejected";
   const now = opts.now ?? new Date;
   const maxDays = opts.maxDays ?? 7;
   for (const filename of recentFilenames(maxDays, now)) {
     const filePath = join9(timelineDir, filename);
-    if (!existsSync6(filePath))
-      continue;
+    let source;
+    try {
+      source = fs7.lstatSync(filePath);
+    } catch (error51) {
+      if (error51.code === "ENOENT")
+        continue;
+      return "rejected";
+    }
+    if (!source.isFile())
+      return "rejected";
     const lockPath = lockPathFor(timelineDir, filename);
     if (!acquireLock(lockPath))
+      return "rejected";
+    try {
+      const lines = scanTimelineFile(filePath);
+      if (!lines)
+        return "rejected";
+      if (lines.length === 0)
+        continue;
+      const latest = lines[lines.length - 1].entry;
+      if (latest.system)
+        return "missing";
+      const updated = {
+        ...latest,
+        messages: [...latest.messages],
+        agent_responses: [...latest.agent_responses]
+      };
+      try {
+        updater(updated);
+      } catch {
+        return "rejected";
+      }
+      const required2 = timelineLine(updated);
+      if (!required2)
+        return "rejected";
+      return writeRequiredTimeline(filePath, [...lines.slice(0, -1), required2], required2) ? "updated" : "rejected";
+    } catch {
+      return "rejected";
+    } finally {
+      releaseLock(lockPath);
+    }
+  }
+  return "missing";
+}
+function yieldToEventLoop() {
+  return new Promise((resolve3) => setImmediate(resolve3));
+}
+async function sweepTimelineHistory(workingDirectoryBase, opts = {}) {
+  const yieldAfterFile = opts.yieldAfterFile ?? (() => yieldToEventLoop());
+  if (!opts.yieldAfterFile)
+    await yieldToEventLoop();
+  if (!isRealDirectory(workingDirectoryBase))
+    return;
+  let agentNames;
+  try {
+    agentNames = fs7.readdirSync(workingDirectoryBase).sort();
+  } catch {
+    return;
+  }
+  for (const agentName of agentNames) {
+    const agentDir = join9(workingDirectoryBase, agentName);
+    if (!isRealDirectory(agentDir))
       continue;
+    const timelineDir = join9(agentDir, ".context_timeline");
+    if (!isRealDirectory(timelineDir))
+      continue;
+    let filenames;
     try {
-      let content;
+      filenames = fs7.readdirSync(timelineDir).filter((name) => DATE_FILENAME_PATTERN.test(name)).sort();
+    } catch {
+      continue;
+    }
+    for (const filename of filenames) {
+      const filePath = join9(timelineDir, filename);
+      let source;
       try {
-        content = readFileSync4(filePath, "utf-8");
+        source = fs7.lstatSync(filePath);
       } catch {
         continue;
       }
-      const lines = content.trimEnd().split(`
-`).filter(Boolean);
-      if (lines.length === 0)
+      if (!source.isFile())
         continue;
-      const entries = lines.map((l) => JSON.parse(l));
-      const latest = entries[entries.length - 1];
-      if (latest.system)
-        return false;
-      updater(latest);
-      const tmpPath = join9(timelineDir, `.${filename}.tmp`);
-      writeFileSync6(tmpPath, entries.map((e) => JSON.stringify(e)).join(`
-`) + `
-`);
-      renameSync3(tmpPath, filePath);
-      return true;
-    } catch {} finally {
-      releaseLock(lockPath);
+      try {
+        const lockPath = lockPathFor(timelineDir, filename);
+        if (acquireLock(lockPath)) {
+          try {
+            const lines = scanTimelineFile(filePath);
+            if (lines)
+              atomicReplaceTimeline(filePath, lines);
+          } finally {
+            releaseLock(lockPath);
+          }
+        }
+      } catch {}
+      await yieldAfterFile(filePath);
     }
   }
-  return false;
 }
 function createTimelineEntry(fields) {
   return {
@@ -20137,7 +23014,13 @@ function findResumableSession(rows, provider) {
   return null;
 }
 // src/timeline/recorder.ts
-import { mkdirSync as mkdirSync5 } from "fs";
+var MAX_AGENT_RESPONSES = 5;
+function appendAgentResponse(entry, text2) {
+  entry.agent_responses.push(text2);
+  if (entry.agent_responses.length > MAX_AGENT_RESPONSES) {
+    entry.agent_responses.splice(0, entry.agent_responses.length - MAX_AGENT_RESPONSES);
+  }
+}
 function createTimelineRecorder(opts) {
   const now = opts.now ?? (() => new Date);
   const dirFor = (agentId) => opts.timelineDirFor(agentId);
@@ -20148,29 +23031,27 @@ function createTimelineRecorder(opts) {
     },
     appendEntryForAgent(agentId, messages) {
       const dir = dirFor(agentId);
-      try {
-        mkdirSync5(dir, { recursive: true });
-      } catch {}
+      if (!prepareTimelineDirectory(dir))
+        return;
       appendOrMergeEntry(dir, createTimelineEntry({
         messages,
         sessionId: sessionByAgent.get(agentId) ?? null,
         provider: opts.providerFor?.(agentId) ?? null
       }), now());
     },
-    appendResponseToLatest(agentId, text) {
+    appendResponseToLatest(agentId, text2) {
       const dir = dirFor(agentId);
-      const updated = updateLatestEntry(dir, (e) => e.agent_responses.push(text), { now: now() });
-      if (updated)
+      if (!prepareTimelineDirectory(dir))
+        return;
+      const result = updateLatestEntryResult(dir, (entry2) => appendAgentResponse(entry2, text2), { now: now() });
+      if (result === "updated" || result === "rejected")
         return;
-      try {
-        mkdirSync5(dir, { recursive: true });
-      } catch {}
       const entry = createTimelineEntry({
         messages: [],
         sessionId: sessionByAgent.get(agentId) ?? null,
         provider: opts.providerFor?.(agentId) ?? null
       });
-      entry.agent_responses.push(text);
+      appendAgentResponse(entry, text2);
       appendEntry(dir, entry, now());
     },
     resumeSessionId(agentId, provider) {
@@ -20179,10 +23060,9 @@ function createTimelineRecorder(opts) {
     },
     forgetSession(agentId, barrierType = "reset_session") {
       const dir = dirFor(agentId);
-      try {
-        mkdirSync5(dir, { recursive: true });
-      } catch {}
       sessionByAgent.delete(agentId);
+      if (!prepareTimelineDirectory(dir))
+        return;
       const stamp = now();
       appendEntry(dir, createSystemEntry(barrierType, stamp.toISOString()), stamp);
     }
@@ -20190,13 +23070,13 @@ function createTimelineRecorder(opts) {
 }
 // src/discovery.ts
 import * as path8 from "path";
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 import { fileURLToPath } from "url";
 var SELECTABLE_RUNTIMES = new Set(["claude", "codex", "opencode", "pi", "cursor"]);
 function resolveAlookCliPath(moduleDir) {
   const thisDir = moduleDir ?? path8.dirname(fileURLToPath(import.meta.url));
   const target = path8.basename(thisDir) === "dist" ? path8.resolve(thisDir, "cli", "index.js") : path8.resolve(thisDir, "..", "scripts", "alook-shim.mjs");
-  return fs7.existsSync(target) ? target : null;
+  return fs8.existsSync(target) ? target : null;
 }
 function deriveCliFallbackCandidates(cliPath) {
   if (!cliPath)
@@ -20214,12 +23094,12 @@ function deriveCliFallbackCandidates(cliPath) {
 }
 function resolveAlookCliPathWithFallback(primary) {
   const resolved = primary ?? resolveAlookCliPath();
-  if (resolved && fs7.existsSync(resolved))
+  if (resolved && fs8.existsSync(resolved))
     return resolved;
   if (resolved) {
     const fallbacks = deriveCliFallbackCandidates(resolved);
     for (const fallback of fallbacks) {
-      if (fs7.existsSync(fallback))
+      if (fs8.existsSync(fallback))
         return fallback;
     }
   }
@@ -20258,7 +23138,7 @@ async function getAvailableRuntimes() {
 }
 
 // src/drivers/piSdkDeps.ts
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import * as path9 from "path";
 import { pathToFileURL } from "url";
 var PI_SDK_PACKAGE_NAME2 = "@earendil-works/pi-coding-agent";
@@ -20268,7 +23148,7 @@ async function importPiSdkFromGlobalInstall() {
   if (!dir) {
     throw new Error(`${PI_SDK_PACKAGE_NAME2} not found — install it (e.g. \`npm install -g ${PI_SDK_PACKAGE_NAME2}\`) before launching a pi agent`);
   }
-  const pkg = JSON.parse(readFileSync5(path9.join(dir, "package.json"), "utf-8"));
+  const pkg = JSON.parse(readFileSync4(path9.join(dir, "package.json"), "utf-8"));
   const entry = pkg.exports?.["."]?.import ?? pkg.main ?? "./dist/index.js";
   const entryPath = path9.join(dir, entry);
   const barrel = await import(pathToFileURL(entryPath).href);
@@ -20341,7 +23221,7 @@ function createPiSdkDriverDeps(ctx, loadSdk = loadPiSdkModule) {
       const bashTool = sdk.createBashToolDefinition(cwd, {
         spawnHook: (spawnCtx) => ({ ...spawnCtx, env: { ...spawnCtx.env, ...spawnEnv } })
       });
-      const { session, sessionId } = await sdk.createAgentSession({
+      const { session: session2, sessionId } = await sdk.createAgentSession({
         cwd,
         model,
         thinkingLevel: opts.thinkingLevel,
@@ -20350,18 +23230,48 @@ function createPiSdkDriverDeps(ctx, loadSdk = loadPiSdkModule) {
         sessionManager,
         customTools: [bashTool]
       });
-      const resolvedSessionId = sessionId ?? session.sessionId;
+      const resolvedSessionId = sessionId ?? session2.sessionId;
       if (!resolvedSessionId)
         throw new Error("pi SDK createAgentSession did not produce a sessionId");
-      return { session, sessionId: resolvedSessionId };
+      return { session: session2, sessionId: resolvedSessionId };
+    }
+  };
+}
+
+// src/daemon/diagnosticsCommand.ts
+function reportUnavailable(options, reportId) {
+  if (!options.reportDiagnosticFailure)
+    return;
+  try {
+    Promise.resolve(options.reportDiagnosticFailure({
+      reportId,
+      failureCode: "diagnostics_unavailable"
+    })).catch(() => {});
+  } catch {}
+}
+function createDiagnosticsCommandListener(options) {
+  return (command) => {
+    if (command.type !== "diagnostics:collect")
+      return;
+    const handler = options.handleDiagnosticCommand;
+    if (!handler) {
+      reportUnavailable(options, command.reportId);
+      return WS_CONTROL_COMMAND_CONSUMED;
+    }
+    try {
+      Promise.resolve(handler(command)).catch(() => {
+        reportUnavailable(options, command.reportId);
+      });
+    } catch {
+      reportUnavailable(options, command.reportId);
     }
+    return WS_CONTROL_COMMAND_CONSUMED;
   };
 }
 
 // src/daemon/createDaemon.ts
 var WARMUP_BACKOFF_MS = [250, 500, 1000, 2000, 4000];
 var WARMUP_CEILING_MS = 30000;
-var FSM_TRACE_MAX_BYTES = 8 * 1024 * 1024;
 var RUNTIME_RAW_TRACE_MAX_BYTES = 8 * 1024 * 1024;
 var RUNTIME_RAW_TRACE_AGENT_IDS_ENV = "ALOOK_RUNTIME_RAW_TRACE_AGENT_IDS";
 var STATUS_WRITE_INTERVAL_MS = 5000;
@@ -20463,7 +23373,11 @@ function emitImplicitTypingStopOnSend(args) {
 async function createDaemon(opts) {
   const log = opts.logger ?? createLogger({ header: "@alook/daemon" });
   const fallbackBase = (process.env.ALOOK_PROJECT_ROOT || `${homedir3()}/.alook`) + "/daemon";
-  const workdirFor = (agentId) => `${opts.workingDirectoryBase ?? fallbackBase}/${agentId}`;
+  const workingDirectoryBase = opts.workingDirectoryBase ?? fallbackBase;
+  const workdirFor = (agentId) => `${workingDirectoryBase}/${agentId}`;
+  sweepTimelineHistory(workingDirectoryBase).catch(() => {
+    log.warn("timeline startup sweep failed");
+  });
   const resolvedCliPath = resolveAlookCliPathWithFallback(opts.agentCliPath);
   const onRuntimeRawLine = createRuntimeRawLineTap({
     traceDir: opts.fsmTraceDir,
@@ -20519,16 +23433,16 @@ async function createDaemon(opts) {
   function reassertAgentActivity(agentId) {
     const state = managerRef?.agentActivity(agentId);
     if (state)
-      channel.reportAgentActivity?.({ agentId, state });
+      channel2.reportAgentActivity?.({ agentId, state });
   }
   function startTypingHeartbeat(agentId) {
     stopTypingHeartbeat(agentId);
     for (const channelId of typingTracker.snapshot(agentId)) {
-      channel.reportAgentTyping?.({ agentId, channelId });
+      channel2.reportAgentTyping?.({ agentId, channelId });
     }
     const timer = setInterval(() => {
       for (const channelId of typingTracker.snapshot(agentId)) {
-        channel.reportAgentTyping?.({ agentId, channelId });
+        channel2.reportAgentTyping?.({ agentId, channelId });
       }
       reassertAgentActivity(agentId);
     }, TYPING_HEARTBEAT_MS);
@@ -20538,7 +23452,7 @@ async function createDaemon(opts) {
   function emitTypingStopsAndClear(agentId) {
     stopTypingHeartbeat(agentId);
     for (const channelId of typingTracker.snapshot(agentId)) {
-      channel.reportAgentTypingStop?.({ agentId, channelId });
+      channel2.reportAgentTypingStop?.({ agentId, channelId });
     }
     typingTracker.clear(agentId);
   }
@@ -20603,11 +23517,11 @@ async function createDaemon(opts) {
         headers: { "content-type": "application/json", authorization: `Bearer ${opts.machineKey}` },
         body: JSON.stringify({ agentId })
       });
-      const text = await res.text();
+      const text2 = await res.text();
       let json2 = {};
-      if (text) {
+      if (text2) {
         try {
-          json2 = JSON.parse(text);
+          json2 = JSON.parse(text2);
         } catch {
           json2 = {};
         }
@@ -20616,7 +23530,7 @@ async function createDaemon(opts) {
         if (res.status === 404) {
           throw new UnknownBotError(agentId);
         }
-        throw new BotEnrollFailedError(agentId, new Error(json2.error ?? `enroll failed (${res.status})${text ? `: ${text.slice(0, 512)}` : ""}`));
+        throw new BotEnrollFailedError(agentId, new Error(json2.error ?? `enroll failed (${res.status})${text2 ? `: ${text2.slice(0, 512)}` : ""}`));
       }
       enrolledKeys.set(agentId, json2.runnerKey);
       return json2.runnerKey;
@@ -20630,14 +23544,14 @@ async function createDaemon(opts) {
       throw wrapped;
     }
   };
-  const channel = new WsControlChannel({
+  const channel2 = new WsControlChannel({
     url: opts.serverWsUrl,
     headers: { Authorization: `Bearer ${opts.machineKey}` },
     webSocketFactory: opts.webSocketFactory,
     onAuthRejected: opts.onAuthRejected,
     logger: log.child("ws")
   });
-  channelRef = channel;
+  channelRef = channel2;
   function handleBotFrame(cmd) {
     switch (cmd.type) {
       case "bot:added":
@@ -20678,6 +23592,31 @@ async function createDaemon(opts) {
     }
   }
   let router = null;
+  const diagnosticTrace = (() => {
+    const overridePath = process.env.ALOOK_FSM_TRACE;
+    if (overridePath) {
+      return {
+        source: null,
+        onFsmTransition: (rec) => {
+          try {
+            appendFileSync2(overridePath, JSON.stringify(rec) + `
+`);
+          } catch {}
+        }
+      };
+    }
+    if (!opts.fsmTraceDir)
+      return { source: null };
+    try {
+      mkdirSync6(opts.fsmTraceDir, { recursive: true });
+    } catch {}
+    const source = createRotatingFileSink(`${opts.fsmTraceDir}/fsm-trace.jsonl`, DEFAULT_TRACE_FILE_MAX_BYTES);
+    const sampler = createTraceSampler((rec) => source.write(JSON.stringify(rec)));
+    return {
+      source,
+      onFsmTransition: (rec) => sampler.offer(rec)
+    };
+  })();
   const manager = new AgentProcessManager({
     driverFor: (agentId, runtimeConfig) => {
       const requested = runtimeConfig?.runtime;
@@ -20712,9 +23651,9 @@ async function createDaemon(opts) {
       };
     },
     tickIntervalMs: opts.tickIntervalMs ?? 2000,
-    onAgentSession: (info) => void channel.reportAgentSession(info),
+    onAgentSession: (info) => void channel2.reportAgentSession(info),
     onAgentActivity: (info) => {
-      channel.reportAgentActivity?.(info);
+      channel2.reportAgentActivity?.(info);
       if (info.state === "starting" || info.state === "running") {
         if (!typingHeartbeats.has(info.agentId)) {
           startTypingHeartbeat(info.agentId);
@@ -20726,30 +23665,7 @@ async function createDaemon(opts) {
     onBotAuditEvent: (agentId, event, context) => emitBotAuditEvent(agentId, event, context),
     onAgentLocallyStopped: (info) => router?.markLocallyStopped(info.agentId),
     onRuntimeRawLine,
-    ...(() => {
-      const overridePath = process.env.ALOOK_FSM_TRACE;
-      if (overridePath) {
-        return {
-          onFsmTransition: (rec) => {
-            try {
-              appendFileSync3(overridePath, JSON.stringify(rec) + `
-`);
-            } catch {}
-          }
-        };
-      }
-      if (opts.fsmTraceDir) {
-        try {
-          mkdirSync6(opts.fsmTraceDir, { recursive: true });
-        } catch {}
-        const sink = createRotatingFileSink(`${opts.fsmTraceDir}/fsm-trace.jsonl`, FSM_TRACE_MAX_BYTES);
-        const sampler = createTraceSampler((rec) => sink.write(JSON.stringify(rec)));
-        return {
-          onFsmTransition: (rec) => sampler.offer(rec)
-        };
-      }
-      return {};
-    })(),
+    ...diagnosticTrace.onFsmTransition ? { onFsmTransition: diagnosticTrace.onFsmTransition } : {},
     sdkDriverDepsFor: (ctx) => createPiSdkDriverDeps(ctx),
     timeline: timeline2,
     wakePromptFooter: "Use `alook inbox pull` to read your messages.",
@@ -20766,9 +23682,13 @@ async function createDaemon(opts) {
     statusTimer = setInterval(writeStatus, STATUS_WRITE_INTERVAL_MS);
     statusTimer.unref?.();
   }
+  opts.onDiagnosticSources?.({
+    fsmTraceSource: diagnosticTrace.source,
+    statusFilePath: opts.statusFilePath
+  });
   router = new AgentRouter({
     manager,
-    channel,
+    channel: channel2,
     runtimeReport: opts.runtimeReport,
     hostname: opts.hostname,
     platform: opts.platform,
@@ -20799,20 +23719,24 @@ async function createDaemon(opts) {
     },
     formatUnreadNoticeText: (notice) => `You have unread messages in channel ${notice.channel}.`
   });
-  channel.onCommand((cmd) => {
+  channel2.onCommand(createDiagnosticsCommandListener({
+    handleDiagnosticCommand: opts.handleDiagnosticCommand,
+    reportDiagnosticFailure: opts.reportDiagnosticFailure
+  }));
+  channel2.onCommand((cmd) => {
     handleBotFrame(cmd);
   });
-  channel.onOpen(() => {
+  channel2.onOpen(() => {
     coldStartWarmup();
     resyncPendingWakes();
   });
-  channel.connect();
+  channel2.connect();
   await router.start();
   return {
-    isOpen: () => channel.status === "open",
+    isOpen: () => channel2.status === "open",
     onOpen: (hook) => {
-      channel.onOpen(hook);
-      if (channel.status === "open")
+      channel2.onOpen(hook);
+      if (channel2.status === "open")
         queueMicrotask(hook);
     },
     proxyUrl: proxy.url,
@@ -20822,7 +23746,7 @@ async function createDaemon(opts) {
       }
       if (statusTimer)
         clearInterval(statusTimer);
-      channel.close();
+      channel2.close();
       await proxy.close();
       await manager.stopAll();
     }