@alook/daemon 0.1.49 → 0.1.51

package/dist/index.js

@@ -7065,14 +7065,16 @@ class OpenCodeServiceLane {
       if (!this.identity || this.identity.generation !== generation || this.isProcessClosed(this.identity.process)) {
         if (/EADDRINUSE|address already in use/i.test(this.stderrBuffer))
           throw new OpenCodePortBindError("OpenCode service port bind raced");
-        throw new Error("OpenCode service exited before readiness");
+        const process2 = this.identity?.process;
+        const detail = scrubDriverErrorMessage(this.stderrBuffer.replaceAll(this.password, "[redacted]"), "no native stderr");
+        throw new Error(`OpenCode service exited before readiness (code=${process2?.exitCode ?? "unknown"}, signal=${process2?.signalCode ?? "none"}): ${detail}`);
       }
       try {
         const healthTimeoutMs = Math.max(1, Math.min(1000, deadline - Date.now(), this.options.requestTimeoutMs ?? REQUEST_TIMEOUT_MS));
-        const { response, body } = await this.fetchJsonWithTimeout("/global/health", { method: "GET" }, "health", healthTimeoutMs);
+        const { response, body } = await this.fetchJsonWithTimeout(this.healthPath, { method: "GET" }, "health", healthTimeoutMs);
         if (response.ok) {
           const health = record4(body);
-          if (health?.healthy !== true) {
+          if (!this.acceptsHealth(health)) {
             throw new OpenCodeIncompatibleError("Installed OpenCode service did not report healthy status");
           }
           await this.verifyOpenApi();
@@ -7089,12 +7091,27 @@ class OpenCodeServiceLane {
     throw new Error("OpenCode service readiness timed out");
   }
   async verifyOpenApi() {
-    const { response, body } = await this.fetchJsonWithTimeout("/doc", { method: "GET" }, "OpenAPI");
+    const { response, body } = await this.fetchJsonWithTimeout(this.openApiPath, { method: "GET" }, "OpenAPI");
     if (!response.ok)
       throw new OpenCodeIncompatibleError("Installed OpenCode service does not expose its OpenAPI document");
     const document = record4(body);
     const paths = record4(document?.paths);
-    const required = [
+    const required = this.requiredApiPaths;
+    if (!paths || required.some((path9) => !record4(paths[path9]))) {
+      throw new OpenCodeIncompatibleError("Installed OpenCode service is missing required session capabilities");
+    }
+  }
+  get healthPath() {
+    return "/global/health";
+  }
+  get openApiPath() {
+    return "/doc";
+  }
+  acceptsHealth(health) {
+    return health?.healthy === true;
+  }
+  get requiredApiPaths() {
+    return [
       "/api/session",
       "/api/session/active",
       "/api/session/{sessionID}/prompt",
@@ -7106,12 +7123,12 @@ class OpenCodeServiceLane {
       "/api/session/{sessionID}/permission/{requestID}/reply",
       "/api/event"
     ];
-    if (!paths || required.some((path9) => !record4(paths[path9]))) {
-      throw new OpenCodeIncompatibleError("Installed OpenCode service is missing required v2 session capabilities");
-    }
+  }
+  get selectedModel() {
+    return parseModelRef(resolveLaunchFieldsOrDefault(this.ctx.config.runtimeConfig).model);
   }
   async openSession(resumeId) {
-    const model = parseModelRef(resolveLaunchFieldsOrDefault(this.ctx.config.runtimeConfig).model);
+    const model = this.selectedModel;
     if (resumeId) {
       const { response: response2, body: body2 } = await this.fetchJsonWithTimeout(`/api/session/${encodeURIComponent(resumeId)}`, { method: "GET" }, "session resume");
       if (response2.status === 404) {
@@ -7454,7 +7471,7 @@ class OpenCodeServiceLane {
   async handleLiveEvent(value) {
     const event = record4(value);
     const data = record4(event?.data);
-    if (event?.type !== "permission.v2.asked" || data?.sessionID !== this.sessionId)
+    if (event?.type !== this.permissionEventType || data?.sessionID !== this.sessionId)
       return;
     if (typeof data.id !== "string" || !/^per/.test(data.id)) {
       throw new OpenCodeProtocolError("OpenCode emitted a malformed permission request");
@@ -7477,13 +7494,19 @@ class OpenCodeServiceLane {
       }
     }
   }
+  get permissionEventType() {
+    return "permission.v2.asked";
+  }
+  get permissionReply() {
+    return { reply: "once" };
+  }
   async replyPermission(requestId) {
     if (this.handledPermissions.has(requestId))
       return;
     const existing = this.permissionFlights.get(requestId);
     if (existing)
       return existing;
-    const flight = this.requestNoContent(`/api/session/${encodeURIComponent(this.sessionId)}/permission/${encodeURIComponent(requestId)}/reply`, "POST", { reply: "once" }, "permission reply").catch((error) => {
+    const flight = this.requestNoContent(`/api/session/${encodeURIComponent(this.sessionId)}/permission/${encodeURIComponent(requestId)}/reply`, "POST", this.permissionReply, "permission reply").catch((error) => {
       if (!(error instanceof OpenCodeHttpError) || error.status !== 404)
         throw error;
     }).then(() => {
@@ -7860,6 +7883,28 @@ async function legacyOpenCodeApiEnvironment(environment, model) {
   return credential?.type === "api" && typeof credential.key === "string" && credential.key.trim() ? { [name]: credential.key } : {};
 }
 
+// agent-driver/dist/adapters/opencode/compatibility.js
+var OPEN_CODE_V1 = {
+  major: 1,
+  modelArgs: ["models", "--pure"],
+  serviceArgs: ["serve", "--pure"],
+  sessionListArgs: (maxCount) => ["session", "list", "--format", "json", "--max-count", String(maxCount), "--pure"]
+};
+var OPEN_CODE_V2 = {
+  major: 2,
+  modelArgs: ["models", "--standalone"],
+  serviceArgs: ["serve"],
+  sessionListArgs: (maxCount) => ["api", "--standalone", "GET", `/api/session?parentID=null&order=desc&limit=${maxCount}`]
+};
+function resolveOpenCodeCompatibility(version) {
+  const match = version?.trim().match(/^(?:opencode\s+)?v?(\d+)\.\d+\.\d+(?:[-+][\w.-]+)?$/i);
+  if (match?.[1] === "1")
+    return OPEN_CODE_V1;
+  if (match?.[1] === "2")
+    return OPEN_CODE_V2;
+  throw new Error("Installed OpenCode CLI version is unrecognized or has an unsupported major version");
+}
+
 // agent-driver/dist/adapters/opencode/recent-context.js
 var OPENCODE_DISCOVERY_TIMEOUT_MS = 15000;
 var OPENCODE_DISCOVERY_OUTPUT_MAX_BYTES = 4 * 1024 * 1024;
@@ -7893,6 +7938,7 @@ async function discoverOpenCodeRecentContext(request, dependencies = {}) {
   const collector = new RecentContextCollector(request, "unavailable");
   if (collector.satisfied)
     return collector.result();
+  const compatibility = dependencies.compatibility ?? OPEN_CODE_V1;
   const startedAt = Date.now();
   const timeoutMs = dependencies.timeoutMs ?? OPENCODE_DISCOVERY_TIMEOUT_MS;
   let remainingOutputBytes = dependencies.outputMaxBytes ?? OPENCODE_DISCOVERY_OUTPUT_MAX_BYTES;
@@ -7901,7 +7947,7 @@ async function discoverOpenCodeRecentContext(request, dependencies = {}) {
     const remainingTimeoutMs = timeoutMs - (Date.now() - startedAt);
     if (remainingTimeoutMs <= 0)
       throw new Error("OpenCode discovery timed out");
-    const spec = resolveSpawnSpec("opencode", ["session", "list", "--format", "json", "--max-count", String(maxCount), "--pure"], request.command);
+    const spec = resolveSpawnSpec("opencode", [...compatibility.sessionListArgs(maxCount)], request.command);
     const commandOutput = await collectCommandOutput(spec.command, spec.args, spec.shell, dependencies, remainingTimeoutMs, remainingOutputBytes);
     remainingOutputBytes -= commandOutput.outputBytes;
     let parsed;
@@ -7910,14 +7956,17 @@ async function discoverOpenCodeRecentContext(request, dependencies = {}) {
     } catch {
       throw new Error("OpenCode session listing returned invalid JSON");
     }
+    if (compatibility.major === 2)
+      parsed = asRecord(parsed)?.data;
     if (!Array.isArray(parsed))
       throw new Error("OpenCode session listing returned an invalid response");
     for (const value of parsed) {
       const session = asRecord(value);
       if (!session)
         continue;
-      const modifiedAt = session.updated ?? session.updatedAt;
-      collector.add({ projectPath: session.directory, modifiedAt });
+      const modifiedAt = compatibility.major === 2 ? asRecord(session.time)?.updated : session.updated ?? session.updatedAt;
+      const projectPath = compatibility.major === 2 ? asRecord(session.location)?.directory : session.directory;
+      collector.add({ projectPath, modifiedAt });
     }
     if (collector.satisfied || parsed.length < maxCount)
       break;
@@ -7929,6 +7978,419 @@ async function discoverOpenCodeRecentContext(request, dependencies = {}) {
   return collector.result();
 }
 
+// agent-driver/dist/adapters/opencode/v2-service-lane.js
+class OpenCodeV2ServiceLane extends OpenCodeServiceLane {
+  root = null;
+  v2AdmissionTail = Promise.resolve();
+  v2EvaluationTimer;
+  v2Evaluating = false;
+  projectedMessages = new Set;
+  liveTools = new Map;
+  settledTools = new Set;
+  usage = new SettledUsageProjector;
+  get healthPath() {
+    return "/api/info";
+  }
+  get openApiPath() {
+    return "/openapi.json";
+  }
+  acceptsHealth(health) {
+    if (typeof health?.version !== "string" || !Number.isInteger(health.pid) || Number(health.pid) < 1)
+      return false;
+    try {
+      return resolveOpenCodeCompatibility(health.version).major === 2;
+    } catch {
+      return false;
+    }
+  }
+  get requiredApiPaths() {
+    return [
+      "/api/session",
+      "/api/session/active",
+      "/api/session/{sessionID}",
+      "/api/session/{sessionID}/prompt",
+      "/api/session/{sessionID}/inbox",
+      "/api/session/{sessionID}/message",
+      "/api/session/{sessionID}/message/{messageID}",
+      "/api/session/{sessionID}/interrupt",
+      "/api/session/{sessionID}/model",
+      "/api/session/{sessionID}/permission",
+      "/api/session/{sessionID}/permission/{requestID}/reply",
+      "/api/event"
+    ];
+  }
+  get selectedModel() {
+    const model = super.selectedModel;
+    if (typeof model?.id !== "string")
+      return model;
+    const hash = model.id.lastIndexOf("#");
+    return hash > 0 && hash < model.id.length - 1 ? { ...model, id: model.id.slice(0, hash), variant: model.id.slice(hash + 1) } : model;
+  }
+  get permissionEventType() {
+    return "permission.asked";
+  }
+  get permissionReply() {
+    return { decision: "once" };
+  }
+  protocolFailure(message, cause) {
+    super.protocolFailure(cause === undefined ? message : `${message}: ${scrubDriverErrorMessage(cause)}`);
+  }
+  async primeHistory() {}
+  startStreams() {
+    const identity = this.identity;
+    this.liveTask = this.runLiveStream(identity).catch((error) => {
+      if (!this.stopping)
+        this.protocolFailure("OpenCode CLI v2 live stream failed", error);
+    });
+  }
+  async recoverPendingPermissions() {
+    await super.recoverPendingPermissions();
+    const root = this.root;
+    if (root)
+      for (const message of await this.messagesAfter(root))
+        this.projectTools(message);
+    this.schedule();
+  }
+  async handleLiveEvent(value) {
+    await super.handleLiveEvent(value);
+    const event = record4(value);
+    const data = record4(event?.data);
+    if (data?.sessionID !== this.sessionId || !this.root)
+      return;
+    switch (event?.type) {
+      case "session.step.started":
+        this.events.emit("runtime_event", {
+          kind: "internal_progress",
+          source: "opencode.service",
+          itemType: "step_started"
+        });
+        break;
+      case "session.tool.input.started": {
+        const key = this.toolKey(data.assistantMessageID, data.id);
+        if (key && typeof data.name === "string" && !this.liveTools.has(key) && !this.settledTools.has(key)) {
+          this.liveTools.set(key, { name: data.name, called: false });
+        }
+        break;
+      }
+      case "session.tool.called":
+        this.projectTool(data);
+        break;
+      case "session.tool.success":
+      case "session.tool.failed": {
+        this.finishTool(this.toolKey(data.assistantMessageID, data.id));
+        break;
+      }
+      case "session.compaction.started":
+        this.events.emit("runtime_event", { kind: "compaction_started" });
+        break;
+      case "session.compaction.failed":
+      case "session.compaction.ended":
+        this.events.emit("runtime_event", { kind: "compaction_finished" });
+        break;
+      default:
+        break;
+    }
+    this.schedule();
+  }
+  async send(input) {
+    if (!this.ready || this.stopping || !this.sessionId || !this.identityMatches())
+      return { ok: false, reason: "closed" };
+    if (input.mode === "idle") {
+      if (this.root)
+        return { ok: false, reason: "runtime_busy" };
+      return this.beginRoot(input);
+    }
+    const root = this.root;
+    if (!root)
+      return { ok: false, reason: "not_ready" };
+    return this.admit(input.text, "steer", this.newMessageId(), root);
+  }
+  async beginRoot(input) {
+    const page = await this.messagePage(undefined, 1);
+    if (this.stopping || !this.identityMatches())
+      return { ok: false, reason: "closed" };
+    const receipt = input.terminalOwner?.startsWith("msg_") ? input.terminalOwner : this.newMessageId();
+    const root = {
+      receipt,
+      baseline: typeof page.data[0]?.id === "string" ? page.data[0].id : null,
+      inputs: new Set,
+      generation: 0,
+      pending: 0
+    };
+    this.root = root;
+    return this.admit(input.text, "queue", receipt, root);
+  }
+  admit(text, delivery, id, root) {
+    root.generation += 1;
+    root.pending += 1;
+    const run = this.v2AdmissionTail.then(async () => {
+      await this.waitForLiveStream();
+      if (this.root !== root || this.stopping || !this.identityMatches())
+        return { ok: false, reason: "closed" };
+      const { response, body } = await this.fetchJsonWithTimeout(`/api/session/${encodeURIComponent(this.sessionId)}/prompt`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ id, text, delivery, resume: true }) }, "prompt admission");
+      if (!response.ok)
+        throw new OpenCodeHttpError(response.status, "prompt admission");
+      const input = record4(record4(body)?.data);
+      if (input?.id !== id || input.sessionID !== this.sessionId || input.type !== "user" || input.delivery !== delivery) {
+        throw new OpenCodeProtocolError("OpenCode CLI v2 returned an invalid prompt receipt");
+      }
+      if (this.root !== root || this.stopping || !this.identityMatches())
+        return { ok: false, reason: "closed" };
+      root.inputs.add(id);
+      return { ok: true, acceptedAs: delivery === "steer" ? "steer" : "prompt", receipt: id };
+    }).catch((error) => {
+      if (this.root === root && !this.stopping)
+        this.protocolFailure("OpenCode CLI v2 prompt admission failed", error);
+      throw error;
+    }).finally(() => {
+      root.pending -= 1;
+      this.schedule();
+    });
+    this.v2AdmissionTail = run.then(() => {}, () => {});
+    return run;
+  }
+  async messagePage(cursor, limit = 100) {
+    const query = new URLSearchParams({ limit: String(limit), ...cursor ? { cursor } : { order: "desc" } });
+    const { response, body } = await this.fetchJsonWithTimeout(`/api/session/${encodeURIComponent(this.sessionId)}/message?${query}`, { method: "GET" }, "message recovery");
+    if (!response.ok)
+      throw new OpenCodeHttpError(response.status, "message recovery");
+    const page = record4(body);
+    const cursors = record4(page?.cursor);
+    if (!Array.isArray(page?.data) || !cursors || page.data.some((item) => typeof record4(item)?.id !== "string")) {
+      throw new OpenCodeProtocolError("OpenCode CLI v2 returned an invalid message page");
+    }
+    if (cursors.next !== undefined && cursors.next !== null && typeof cursors.next !== "string")
+      throw new OpenCodeProtocolError("OpenCode CLI v2 returned an invalid message cursor");
+    return { data: page.data, next: typeof cursors.next === "string" ? cursors.next : undefined };
+  }
+  async messagesAfter(root) {
+    const messages = [];
+    const cursors = new Set;
+    let cursor;
+    for (;; ) {
+      const page = await this.messagePage(cursor);
+      if (this.root !== root || this.stopping)
+        return [];
+      for (const message of page.data) {
+        if (message.id === root.baseline)
+          return messages.reverse();
+        messages.push(message);
+      }
+      if (!page.next) {
+        if (root.baseline !== null)
+          throw new OpenCodeProtocolError("OpenCode CLI v2 message recovery lost its root boundary");
+        return messages.reverse();
+      }
+      if (cursors.has(page.next))
+        throw new OpenCodeProtocolError("OpenCode CLI v2 message cursor did not advance");
+      cursors.add(page.next);
+      cursor = page.next;
+    }
+  }
+  schedule() {
+    if (!this.root || this.stopping || this.v2EvaluationTimer || this.v2Evaluating)
+      return;
+    this.v2EvaluationTimer = setTimeout(() => {
+      this.v2EvaluationTimer = undefined;
+      this.evaluate();
+    }, this.options.activePollMs ?? 100);
+    this.v2EvaluationTimer.unref?.();
+  }
+  async isActive() {
+    const { response, body } = await this.fetchJsonWithTimeout("/api/session/active", { method: "GET" }, "active session query");
+    if (!response.ok)
+      throw new OpenCodeHttpError(response.status, "active session query");
+    const active = record4(record4(body)?.data);
+    if (!active)
+      throw new OpenCodeProtocolError("OpenCode CLI v2 returned invalid active session data");
+    return active[this.sessionId] !== undefined;
+  }
+  async evaluate() {
+    const root = this.root;
+    const identity = this.identity;
+    if (!root || !identity || this.stopping || root.pending > 0 || root.inputs.size === 0 || this.v2Evaluating)
+      return;
+    this.v2Evaluating = true;
+    const generation = root.generation;
+    const current = () => this.root === root && root.generation === generation && root.pending === 0 && this.isIdentity(identity);
+    try {
+      if (await this.isActive())
+        return;
+      if (!current())
+        return;
+      const messages = await this.messagesAfter(root);
+      if (!current())
+        return;
+      let lastInput = -1;
+      const delivered = new Set;
+      for (const [index, message] of messages.entries()) {
+        if (message.type === "user" && typeof message.id === "string" && root.inputs.has(message.id)) {
+          delivered.add(message.id);
+          lastInput = index;
+        }
+      }
+      const idle = messages.slice(lastInput + 1).reverse().find((message) => message.type === "idle");
+      if (delivered.size !== root.inputs.size) {
+        const { response, body } = await this.fetchJsonWithTimeout(`/api/session/${encodeURIComponent(this.sessionId)}/inbox`, { method: "GET" }, "pending input recovery");
+        if (!response.ok)
+          throw new OpenCodeHttpError(response.status, "pending input recovery");
+        const pending = record4(body)?.data;
+        if (!Array.isArray(pending))
+          throw new OpenCodeProtocolError("OpenCode CLI v2 returned invalid inbox data");
+        if (!current())
+          return;
+        const retained = new Set(pending.map((item) => record4(item)?.id));
+        for (const id of root.inputs) {
+          if (delivered.has(id) || retained.has(id))
+            continue;
+          const recovered = await this.fetchJsonWithTimeout(`/api/session/${encodeURIComponent(this.sessionId)}/message/${encodeURIComponent(id)}`, { method: "GET" }, "accepted input recovery");
+          if (!current())
+            return;
+          if (recovered.response.status === 404)
+            throw new OpenCodeProtocolError("OpenCode CLI v2 lost an accepted input from both inbox and messages");
+          if (!recovered.response.ok)
+            throw new OpenCodeHttpError(recovered.response.status, "accepted input recovery");
+          const message = record4(record4(recovered.body)?.data);
+          if (message?.id !== id || message.type !== "user")
+            throw new OpenCodeProtocolError("OpenCode CLI v2 returned an invalid recovered input");
+        }
+        return;
+      }
+      for (const message of messages) {
+        this.projectTools(message);
+        this.projectMessage(message);
+      }
+      if (!idle || await this.isActive() || !current())
+        return;
+      if (!["succeeded", "failed", "interrupted"].includes(String(idle.outcome))) {
+        throw new OpenCodeProtocolError("OpenCode CLI v2 returned an invalid idle outcome");
+      }
+      this.root = null;
+      if (idle.outcome === "failed") {
+        const error = record4(idle.error);
+        this.events.emit("runtime_event", {
+          kind: "error",
+          code: "opencode.turn_failed",
+          message: typeof error?.message === "string" ? error.message : "OpenCode CLI v2 execution failed"
+        });
+      }
+      this.events.emit("runtime_event", {
+        kind: "turn_end",
+        sessionId: this.sessionId,
+        turnOwner: root.receipt
+      });
+    } catch (error) {
+      if (!current() || this.stopping)
+        return;
+      if (error instanceof OpenCodeProtocolError || error instanceof OpenCodeHttpError && error.status < 500) {
+        this.protocolFailure("OpenCode CLI v2 durable message recovery failed", error);
+      } else
+        this.diagnostic("warning", "OpenCode CLI v2 message recovery temporarily unavailable; keeping the root active");
+    } finally {
+      this.v2Evaluating = false;
+      this.schedule();
+    }
+  }
+  toolKey(messageId, id) {
+    return typeof messageId === "string" && typeof id === "string" ? `${messageId}:${id}` : undefined;
+  }
+  projectTool(data) {
+    const key = this.toolKey(data.assistantMessageID, data.id);
+    if (!key || this.settledTools.has(key))
+      return;
+    const tool = this.liveTools.get(key) ?? { name: typeof data.name === "string" ? data.name : "OpenCode tool", called: false };
+    if (tool.called)
+      return;
+    tool.called = true;
+    this.liveTools.set(key, tool);
+    this.events.emit("runtime_event", { kind: "tool_call", callId: key, name: tool.name, input: data.input });
+  }
+  finishTool(key) {
+    if (!key || this.settledTools.has(key))
+      return;
+    const tool = this.liveTools.get(key);
+    if (!tool?.called)
+      return;
+    this.liveTools.delete(key);
+    this.settledTools.add(key);
+    this.events.emit("runtime_event", { kind: "tool_output", callId: key, name: tool.name });
+  }
+  projectTools(message) {
+    if (message.type !== "assistant" || !Array.isArray(message.content) || !this.root || this.stopping)
+      return;
+    for (const value of message.content) {
+      const tool = record4(value);
+      const state = record4(tool?.state);
+      if (tool?.type !== "tool" || !["running", "completed", "error"].includes(String(state?.status)))
+        continue;
+      this.projectTool({ assistantMessageID: message.id, id: tool.id, name: tool.name, input: state?.input });
+      if (state?.status !== "running")
+        this.finishTool(this.toolKey(message.id, tool.id));
+    }
+  }
+  projectMessage(message) {
+    if (message.type !== "assistant" || typeof message.id !== "string" || this.projectedMessages.has(message.id))
+      return;
+    const time = record4(message.time);
+    if (time?.completed === undefined)
+      return;
+    this.projectedMessages.add(message.id);
+    if (Array.isArray(message.content))
+      for (const value of message.content) {
+        const content = record4(value);
+        if (typeof content?.text !== "string" || !content.text)
+          continue;
+        if (content.type === "text")
+          this.events.emit("runtime_event", { kind: "assistant_message_completed", text: content.text });
+        if (content.type === "reasoning")
+          this.events.emit("runtime_event", { kind: "assistant_reasoning_completed", text: content.text });
+      }
+    const tokens = record4(message.tokens);
+    if (!tokens || !this.sessionId)
+      return;
+    const cache = record4(tokens.cache);
+    const identity = { runtime: "opencode", backendSessionId: this.sessionId, providerRecordId: message.id };
+    const usage = this.usage.project({
+      ...identity,
+      source: "opencode.v2",
+      input: tokens.input,
+      output: tokens.output,
+      reasoning: tokens.reasoning,
+      cacheRead: cache?.read,
+      cacheWrite: cache?.write,
+      inputIncludesCache: false,
+      outputIncludesReasoning: false
+    });
+    if (usage)
+      this.events.emit("runtime_event", usage);
+    this.usage.release(identity);
+  }
+  async interrupt(_input) {
+    const root = this.root;
+    if (!root || !this.ready || this.stopping || !this.identityMatches())
+      return false;
+    root.generation += 1;
+    root.pending += 1;
+    try {
+      await this.requestNoContent(`/api/session/${encodeURIComponent(this.sessionId)}/interrupt?resume=false`, "POST", undefined, "session interrupt");
+      return true;
+    } catch (error) {
+      if (!this.stopping)
+        this.stop({ reason: "interrupt_timeout", forceAfterMs: 0 });
+      throw error;
+    } finally {
+      root.pending -= 1;
+      this.schedule();
+    }
+  }
+  stop(input = {}) {
+    this.root = null;
+    if (this.v2EvaluationTimer)
+      clearTimeout(this.v2EvaluationTimer);
+    return super.stop(input);
+  }
+}
+
 // agent-driver/dist/adapters/opencode/index.js
 function createOpenCodeMessageId() {
   return `msg_${randomBytes4(16).toString("hex")}`;
@@ -7936,6 +8398,7 @@ function createOpenCodeMessageId() {
 
 class OpenCodeDriver {
   outputProbe;
+  versionProbe;
   id = "opencode";
   instructionDelivery = { kind: "workspace_file", canonical: "AGENTS.md", aliases: ["CLAUDE.md"] };
   execution = {
@@ -7944,17 +8407,29 @@ class OpenCodeDriver {
     wakeStart: "immediate",
     terminalOwnership: "transport_request"
   };
-  constructor(outputProbe = probeCommandOutput) {
+  constructor(outputProbe = probeCommandOutput, versionProbe = probeCliRuntime) {
     this.outputProbe = outputProbe;
+    this.versionProbe = versionProbe;
   }
   discoverRecentContext(request) {
-    return discoverOpenCodeRecentContext(request);
+    if (request.recentProjectsTopK === 0)
+      return discoverOpenCodeRecentContext(request);
+    const result = this.versionProbe("opencode", {}, request.command);
+    if (result.status !== "healthy")
+      throw new Error("Installed OpenCode CLI could not report its version");
+    return discoverOpenCodeRecentContext(request, { compatibility: resolveOpenCodeCompatibility(result.version) });
   }
   probe(command) {
-    const result = probeCliRuntime("opencode", {}, command);
+    const result = this.versionProbe("opencode", {}, command);
     if (result.status !== "healthy")
       return result;
-    const spec = resolveSpawnSpec("opencode", ["models", "--pure"], command);
+    let compatibility;
+    try {
+      compatibility = resolveOpenCodeCompatibility(result.version);
+    } catch {
+      return { ...result, status: "unhealthy", lastError: "unsupported_opencode_cli_version" };
+    }
+    const spec = resolveSpawnSpec("opencode", [...compatibility.modelArgs], command);
     const output = this.outputProbe(spec.command, spec.args);
     return {
       ...result,
@@ -7965,20 +8440,29 @@ class OpenCodeDriver {
     return createOpenCodeMessageId();
   }
   async openLane(ctx, options) {
-    return new OpenCodeServiceLane(this, ctx, {
+    const command = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig).command;
+    const result = this.versionProbe("opencode", {}, command);
+    if (result.status !== "healthy")
+      throw new Error("Installed OpenCode CLI could not report its version");
+    const compatibility = resolveOpenCodeCompatibility(result.version);
+    const factory = {
+      spawnService: (launch, port, password) => this.spawnService(launch, port, password, compatibility)
+    };
+    const Lane = compatibility.major === 1 ? OpenCodeServiceLane : OpenCodeV2ServiceLane;
+    return new Lane(factory, ctx, {
       onRawStdoutLine: options?.onRawStdoutLine
     });
   }
-  async spawnService(ctx, port, password) {
+  async spawnService(ctx, port, password, compatibility = OPEN_CODE_V1) {
     const { spawnEnv } = await prepareCliTransport(ctx, {
-      OPENCODE_SERVER_PASSWORD: password
+      OPENCODE_SERVER_PASSWORD: password,
+      ...compatibility.major === 2 ? { OPENCODE_PASSWORD: password } : {}
     });
     const fields2 = resolveLaunchFieldsOrDefault(ctx.config.runtimeConfig);
     Object.assign(spawnEnv, await legacyOpenCodeApiEnvironment(spawnEnv, fields2.model));
     const override = fields2.command;
     const args = [
-      "serve",
-      "--pure",
+      ...compatibility.serviceArgs,
       "--hostname",
       "127.0.0.1",
       "--port",
@@ -8173,15 +8657,14 @@ function createPiSessionDependencies(ctx, loadSdk = loadPiSdkModule) {
     },
     async createAgentSession(opts) {
       const sdk = await loadSdk();
-      const authStorage = sdk.AuthStorage.create();
+      const modelRuntime = await sdk.ModelRuntime.create();
       const runtimeConfig = ctx.config.runtimeConfig;
       const provider = runtimeConfig && "provider" in runtimeConfig ? runtimeConfig.provider : undefined;
       if (provider?.kind === "builtin") {
-        authStorage.setRuntimeApiKey(provider.providerId, provider.apiKey);
+        await modelRuntime.setRuntimeApiKey(provider.providerId, provider.apiKey);
       }
-      const modelRegistry = sdk.ModelRegistry.create(authStorage);
       const parsed = parseModelString(opts.model);
-      const model = parsed ? modelRegistry.find(parsed.provider, parsed.id) : undefined;
+      const model = parsed ? modelRuntime.getModel(parsed.provider, parsed.id) : undefined;
       const cwd = opts.cwd;
       const requestedSessionId = opts.sessionId;
       let sessionManager;
@@ -8200,8 +8683,7 @@ function createPiSessionDependencies(ctx, loadSdk = loadPiSdkModule) {
         cwd,
         model,
         thinkingLevel: opts.thinkingLevel,
-        authStorage,
-        modelRegistry,
+        modelRuntime,
         sessionManager,
         customTools: [bashTool]
       });
@@ -8436,9 +8918,8 @@ class PiDriver {
     try {
       const reasoning = await Promise.race([
         this.loadSdk().then(async (sdk) => {
-          const authStorage = sdk.AuthStorage.create();
-          const registry = sdk.ModelRegistry.create(authStorage);
-          return parsePiModelCatalog(await registry.getAvailable());
+          const modelRuntime = await sdk.ModelRuntime.create();
+          return parsePiModelCatalog(await modelRuntime.getAvailable());
         }),
         new Promise((resolve4) => {
           timer = setTimeout(() => resolve4(undefined), PI_MODEL_PROBE_TIMEOUT_MS);
@@ -11565,10 +12046,31 @@ function reduceManager(state, event) {
       return withAgent(state, event.agentId, (a) => a ?? freshAgent(event.agentId), []);
     case "wake":
       return onWake(state, event.agentId, event.message);
-    case "spawned":
+    case "spawned": {
+      const existing = state.agents[event.agentId];
+      if (!existing || existing.status !== "starting")
+        return { state, effects: [] };
+      const agent = clone(existing);
+      enterStable(agent, "running");
+      syncExecutionProjection(agent);
+      const mode = leaseIsWorking(agent.execution.lease) || agent.pendingAdmissions.length > 0 ? "busy" : "idle";
+      const messages = drainInbox(agent);
+      return commit(state, agent, messages.map((message) => ({ type: "send", agentId: event.agentId, message, mode })));
+    }
+    case "queue_delivery":
       return mutate(state, event.agentId, (a) => {
-        enterStable(a, "running");
+        const queuedById = new Map(a.inbox.filter((message) => message.id).map((message) => [message.id, message]));
+        const restoredIds = new Set;
+        const messages = event.messages.filter((message) => {
+          if (message.id && restoredIds.has(message.id))
+            return false;
+          if (message.id)
+            restoredIds.add(message.id);
+          return true;
+        }).map((message) => message.id ? queuedById.get(message.id) ?? message : message);
+        a.inbox = [...messages, ...a.inbox.filter((message) => !message.id || !restoredIds.has(message.id))];
         syncExecutionProjection(a);
+        a.idleSince = null;
       });
     case "backend_session":
       return mutate(state, event.agentId, (a) => {
@@ -11909,14 +12411,14 @@ function onTurnCompleted(state, agentId, sessionInstanceId, nowMs, turnId, endRe
     agent.stalledSessionId = null;
   syncExecutionProjection(agent);
   const clearEffects = clearedStallSessionId === null ? [] : [{ type: "clear_stall_recovery", agentId, sessionId: clearedStallSessionId }];
-  if (agent.inbox.length > 0 && !agent.resetting) {
+  if (agent.status === "running" && agent.inbox.length > 0 && !agent.resetting) {
     const messages = drainInbox(agent);
     return commit(state, agent, [
       ...clearEffects,
       ...messages.map((queued) => ({ type: "send", agentId, message: queued, mode: "idle" }))
     ]);
   }
-  agent.idleSince = nowMs;
+  agent.idleSince = agent.status === "running" && !agent.resetting ? nowMs : null;
   return commit(state, agent, clearEffects);
 }
 function onTurnToolLifecycle(state, event, lifecycle) {
@@ -13440,8 +13942,34 @@ class AgentProcessManager {
         }
       }
     }
-    for (const effect of effects)
-      this.applyEffect(effect);
+    const completed = new Set;
+    const deferSends = (agentId) => {
+      const remaining = effects.filter((candidate) => candidate.type === "send" && !completed.has(candidate) && (agentId === undefined || candidate.agentId === agentId));
+      for (const id of new Set(remaining.map((candidate) => candidate.agentId))) {
+        const batch = remaining.filter((candidate) => candidate.agentId === id);
+        batch.forEach((candidate) => completed.add(candidate));
+        this.dispatch({
+          type: "queue_delivery",
+          agentId: id,
+          messages: batch.map((candidate) => candidate.message)
+        });
+      }
+    };
+    try {
+      for (const effect of effects) {
+        if (completed.has(effect))
+          continue;
+        if (effect.type === "send" && !this.canSend(effect.agentId)) {
+          deferSends(effect.agentId);
+          continue;
+        }
+        this.applyEffect(effect);
+        completed.add(effect);
+      }
+    } catch (error) {
+      deferSends();
+      throw error;
+    }
     return effects;
   }
   deriveActivitySnapshot(state) {
@@ -13473,6 +14001,26 @@ ${this.opts.wakePromptFooter}` : text2;
   stampNow(text2) {
     return this.opts.stampWakePromptTime ? `[${nowLocalISO()}] ${text2}` : text2;
   }
+  prepareDelivery(message) {
+    return {
+      ...message,
+      preparedInput: message.preparedInput ?? {
+        id: message.id,
+        kind: "user",
+        text: this.stampNow(this.withFooter(message.text)),
+        sequence: message.seq
+      }
+    };
+  }
+  canSend(agentId) {
+    const session = this.sessions.get(agentId);
+    const owner = this.activeSpawnState.get(agentId);
+    const agent = this.state.agents[agentId];
+    if (!session || !owner || owner.session !== session || owner.torndown || owner.superseded || agent?.status !== "running" || agent.resetting || agent.execution.sessionInstanceId !== session.sessionInstanceId)
+      return false;
+    const driverState = session.snapshot().state;
+    return driverState !== "stopping" && driverState !== "closed";
+  }
   beginPendingDelivery(owner, commandId, message, mode, span, requeueOnFailure = true) {
     const sessionInstanceId = owner.sessionInstanceId;
     if (!sessionInstanceId || owner.pendingDeliverySpans.has(commandId))
@@ -13532,18 +14080,15 @@ ${this.opts.wakePromptFooter}` : text2;
         break;
       case "send": {
         const session = this.sessions.get(effect.agentId);
-        const input = {
-          id: effect.message.id,
-          kind: "user",
-          text: this.stampNow(this.withFooter(effect.message.text)),
-          sequence: effect.message.seq
-        };
-        if (session) {
+        if (session && this.canSend(effect.agentId)) {
+          const message = this.prepareDelivery(effect.message);
+          effect.message = message;
+          const input = message.preparedInput;
           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;
           if (exactOwner)
-            this.beginPendingDelivery(exactOwner, input.id, effect.message, effect.mode, associatedSpan);
+            this.beginPendingDelivery(exactOwner, input.id, message, effect.mode, associatedSpan);
           let sent;
           try {
             sent = session.send(input);
@@ -13752,9 +14297,11 @@ ${this.opts.wakePromptFooter}` : text2;
     this.log.info("agent session ended", { agentId, sessionId, reason });
   }
   doSpawn(agentId, messages, resumeSessionId) {
-    const [first, ...pending] = messages;
-    if (!first)
+    const [initial, ...pending] = messages;
+    if (!initial)
       throw new Error(`AgentProcessManager: spawn for ${agentId} has no command`);
+    this.dispatch({ type: "queue_delivery", agentId, messages: pending });
+    const first = this.prepareDelivery(initial);
     const prompt = this.withFooter(first.text);
     const driver = this.opts.driverFor(agentId, this.runtimeConfigs.get(agentId));
     this.liveBackendIds.set(agentId, driver.id);
@@ -13958,12 +14505,7 @@ ${this.opts.wakePromptFooter}` : text2;
       this.beginPendingDelivery(state, commandId, first, "idle", startedSpan, false);
       let startResult;
       try {
-        startResult = session.start({
-          id: commandId,
-          kind: "user",
-          text: this.stampNow(prompt),
-          sequence: first.seq
-        });
+        startResult = session.start(first.preparedInput);
         this.markPendingDeliveryObserved(state, commandId);
       } catch (error) {
         this.settlePendingDelivery(state, commandId);
@@ -13971,7 +14513,7 @@ ${this.opts.wakePromptFooter}` : text2;
         throw error;
       }
       startResult.then((receipt) => {
-        if (this.sessions.get(agentId) !== session || state.torndown)
+        if (this.sessions.get(agentId) !== session || state.torndown || state.superseded || this.activeSpawnState.get(agentId) !== state)
           return;
         if (receipt?.status === "rejected") {
           this.settlePendingDelivery(state, commandId);
@@ -13980,44 +14522,16 @@ ${this.opts.wakePromptFooter}` : text2;
           session.stop({ reason: "shutdown", forceAfterMs: SESSION_STOP_GRACE_MS2 });
           return;
         }
-        this.dispatch({ type: "spawned", agentId, nowMs: this.now() }, state);
-        (async () => {
-          for (const message of pending) {
-            if (state.torndown || this.sessions.get(agentId) !== session || this.activeSpawnState.get(agentId) !== state) {
-              return;
-            }
-            this.beginPendingDelivery(state, message.id, message, "busy", state.activeSpan);
-            let queuedReceipt;
-            try {
-              const queuedResult = session.send({
-                id: message.id,
-                kind: "user",
-                text: this.stampNow(this.withFooter(message.text)),
-                sequence: message.seq
-              });
-              this.markPendingDeliveryObserved(state, message.id);
-              queuedReceipt = await queuedResult;
-            } catch (error) {
-              this.settlePendingDelivery(state, message.id);
-              if (!state.torndown && this.sessions.get(agentId) === session && this.activeSpawnState.get(agentId) === state) {
-                this.emitErrorAudit(agentId, "runtime", "send_failed", String(error));
-                session.stop({ reason: "shutdown", forceAfterMs: SESSION_STOP_GRACE_MS2 });
-              }
-              return;
-            }
-            if (state.torndown || this.sessions.get(agentId) !== session || this.activeSpawnState.get(agentId) !== state) {
-              return;
-            }
-            if (queuedReceipt.status === "rejected") {
-              if (!state.pendingDeliverySpans.has(message.id))
-                return;
-              this.settlePendingDelivery(state, message.id);
-              this.emitErrorAudit(agentId, "runtime", queuedReceipt.error?.code ?? queuedReceipt.reason, queuedReceipt.error?.message ?? `Delivery rejected (${queuedReceipt.reason})`);
-              session.stop({ reason: "shutdown", forceAfterMs: SESSION_STOP_GRACE_MS2 });
-              return;
-            }
-          }
-        })().catch((error) => this.emitErrorAudit(agentId, "runtime", "send_failed", String(error)));
+        const driverState = session.snapshot().state;
+        if (this.state.agents[agentId]?.status !== "starting" || driverState === "stopping" || driverState === "closed")
+          return;
+        try {
+          this.dispatch({ type: "spawned", agentId, nowMs: this.now() }, state);
+        } catch (error) {
+          this.emitErrorAudit(agentId, "runtime", "send_failed", String(error));
+          session.stop({ reason: "shutdown", forceAfterMs: SESSION_STOP_GRACE_MS2 });
+          return;
+        }
         if (state.hasEstablished || state.hasReportedSpawnFailure)
           return;
         state.handshakeTimer = setTimeout(() => {
@@ -33725,7 +34239,7 @@ __export(exports_community_machine_schema, {
   DIAGNOSTIC_REPORT_FAILURE_CODES: () => DIAGNOSTIC_REPORT_FAILURE_CODES
 });
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/entity.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/entity.js
 var entityKind = Symbol.for("drizzle:entityKind");
 var hasOwnEntityKind = Symbol.for("drizzle:hasOwnEntityKind");
 function is(value, type) {
@@ -33750,7 +34264,7 @@ function is(value, type) {
   return false;
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/column.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/column.js
 class Column {
   constructor(table, config2) {
     this.table = table;
@@ -33800,7 +34314,7 @@ class Column {
   }
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/column-builder.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/column-builder.js
 class ColumnBuilder {
   static [entityKind] = "ColumnBuilder";
   config;
@@ -33856,20 +34370,20 @@ class ColumnBuilder {
   }
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/table.utils.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/table.utils.js
 var TableName = Symbol.for("drizzle:Name");
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/tracing-utils.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/tracing-utils.js
 function iife(fn, ...args) {
   return fn(...args);
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/pg-core/unique-constraint.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/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.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/pg-core/columns/common.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/pg-core/columns/common.js
 class PgColumn extends Column {
   constructor(table, config2) {
     if (!config2.uniqueName) {
@@ -33918,7 +34432,7 @@ class ExtraConfigColumn extends PgColumn {
   }
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/pg-core/columns/enum.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/pg-core/columns/enum.js
 class PgEnumObjectColumn extends PgColumn {
   static [entityKind] = "PgEnumObjectColumn";
   enum;
@@ -33948,7 +34462,7 @@ class PgEnumColumn extends PgColumn {
   }
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/subquery.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/subquery.js
 class Subquery {
   static [entityKind] = "Subquery";
   constructor(sql, fields2, alias, isWith = false, usedTables = []) {
@@ -33963,10 +34477,10 @@ class Subquery {
   }
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/version.js
-var version2 = "0.45.3";
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/version.js
+var version2 = "0.45.4";
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/tracing.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/tracing.js
 var otel;
 var rawTracer;
 var tracer = {
@@ -33993,10 +34507,10 @@ var tracer = {
   }
 };
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/view-common.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/view-common.js
 var ViewBaseConfig = Symbol.for("drizzle:ViewBaseConfig");
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/table.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/table.js
 var Schema = Symbol.for("drizzle:Schema");
 var Columns = Symbol.for("drizzle:Columns");
 var ExtraConfigColumns = Symbol.for("drizzle:ExtraConfigColumns");
@@ -34034,7 +34548,7 @@ class Table {
   }
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/sql/sql.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/sql/sql.js
 function isSQLWrapper(value) {
   return value !== null && value !== undefined && typeof value.getSQL === "function";
 }
@@ -34397,7 +34911,7 @@ Subquery.prototype.getSQL = function() {
   return new SQL([this]);
 };
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/alias.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/alias.js
 class ColumnAliasProxyHandler {
   constructor(table) {
     this.table = table;
@@ -34453,12 +34967,12 @@ class TableAliasProxyHandler {
   }
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/sqlite-core/alias.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/sqlite-core/alias.js
 function alias(table, alias2) {
   return new Proxy(table, new TableAliasProxyHandler(alias2, false));
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/sqlite-core/checks.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/sqlite-core/checks.js
 class CheckBuilder {
   constructor(name, value) {
     this.name = name;
@@ -34485,7 +34999,7 @@ function check2(name, value) {
   return new CheckBuilder(name, value);
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/utils.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/utils.js
 function getColumnNameAndConfig(a, b) {
   return {
     name: typeof a === "string" && a.length > 0 ? a : "",
@@ -34494,7 +35008,7 @@ function getColumnNameAndConfig(a, b) {
 }
 var textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder;
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/sqlite-core/foreign-keys.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/sqlite-core/foreign-keys.js
 class ForeignKeyBuilder {
   static [entityKind] = "SQLiteForeignKeyBuilder";
   reference;
@@ -34562,7 +35076,7 @@ function foreignKey(config2) {
   return new ForeignKeyBuilder(mappedConfig);
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/sqlite-core/unique-constraint.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/sqlite-core/unique-constraint.js
 function uniqueKeyName2(table, columns) {
   return `${table[TableName]}_${columns.join("_")}_unique`;
 }
@@ -34607,7 +35121,7 @@ class UniqueConstraint {
   }
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/sqlite-core/columns/common.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/sqlite-core/columns/common.js
 class SQLiteColumnBuilder extends ColumnBuilder {
   static [entityKind] = "SQLiteColumnBuilder";
   foreignKeyConfigs = [];
@@ -34658,7 +35172,7 @@ class SQLiteColumn extends Column {
   static [entityKind] = "SQLiteColumn";
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/sqlite-core/columns/blob.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/sqlite-core/columns/blob.js
 class SQLiteBigIntBuilder extends SQLiteColumnBuilder {
   static [entityKind] = "SQLiteBigIntBuilder";
   constructor(name) {
@@ -34746,7 +35260,7 @@ function blob(a, b) {
   return new SQLiteBlobBufferBuilder(name);
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/sqlite-core/columns/custom.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/sqlite-core/columns/custom.js
 class SQLiteCustomColumnBuilder extends SQLiteColumnBuilder {
   static [entityKind] = "SQLiteCustomColumnBuilder";
   constructor(name, fieldConfig, customTypeParams) {
@@ -34787,7 +35301,7 @@ function customType(customTypeParams) {
   };
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/sqlite-core/columns/integer.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/sqlite-core/columns/integer.js
 class SQLiteBaseIntegerBuilder extends SQLiteColumnBuilder {
   static [entityKind] = "SQLiteBaseIntegerBuilder";
   constructor(name, dataType, columnType) {
@@ -34889,7 +35403,7 @@ function integer2(a, b) {
   return new SQLiteIntegerBuilder(name);
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/sqlite-core/columns/numeric.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/sqlite-core/columns/numeric.js
 class SQLiteNumericBuilder extends SQLiteColumnBuilder {
   static [entityKind] = "SQLiteNumericBuilder";
   constructor(name) {
@@ -34959,7 +35473,7 @@ function numeric(a, b) {
   return mode === "number" ? new SQLiteNumericNumberBuilder(name) : mode === "bigint" ? new SQLiteNumericBigIntBuilder(name) : new SQLiteNumericBuilder(name);
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/sqlite-core/columns/real.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/sqlite-core/columns/real.js
 class SQLiteRealBuilder extends SQLiteColumnBuilder {
   static [entityKind] = "SQLiteRealBuilder";
   constructor(name) {
@@ -34980,7 +35494,7 @@ function real(name) {
   return new SQLiteRealBuilder(name ?? "");
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/sqlite-core/columns/text.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/sqlite-core/columns/text.js
 class SQLiteTextBuilder extends SQLiteColumnBuilder {
   static [entityKind] = "SQLiteTextBuilder";
   constructor(name, config2) {
@@ -35035,7 +35549,7 @@ function text2(a, b = {}) {
   return new SQLiteTextBuilder(name, config2);
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/sqlite-core/columns/all.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/sqlite-core/columns/all.js
 function getSQLiteColumnBuilders() {
   return {
     blob,
@@ -35047,7 +35561,7 @@ function getSQLiteColumnBuilders() {
   };
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/sqlite-core/table.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/sqlite-core/table.js
 var InlineForeignKeys = Symbol.for("drizzle:SQLiteInlineForeignKeys");
 
 class SQLiteTable extends Table {
@@ -35081,7 +35595,7 @@ var sqliteTable = (name, columns, extraConfig) => {
   return sqliteTableBase(name, columns, extraConfig);
 };
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/sqlite-core/indexes.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/sqlite-core/indexes.js
 class IndexBuilderOn {
   constructor(name, unique2) {
     this.name = name;
@@ -35127,7 +35641,7 @@ function uniqueIndex(name) {
   return new IndexBuilderOn(name, true);
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/sqlite-core/primary-keys.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/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);
@@ -35162,7 +35676,7 @@ class PrimaryKey {
   }
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/sql/expressions/conditions.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/sql/expressions/conditions.js
 function bindIfParam(value, column) {
   if (isDriverValueEncoder(column) && !isSQLWrapper(value) && !is(value, Param) && !is(value, Placeholder) && !is(value, Column) && !is(value, Table) && !is(value, View)) {
     return new Param(value, column);
@@ -35190,7 +35704,7 @@ function isNotNull(value) {
   return sql`${value} is not null`;
 }
 
-// ../../node_modules/.pnpm/drizzle-orm@0.45.3_@cloudflare+workers-types@5.20261002.1_@opentelemetry+api@1.9.1_@typ_63527d4415342e3b436227e1d40bc1bd/node_modules/drizzle-orm/sql/expressions/select.js
+// ../../node_modules/.pnpm/drizzle-orm@0.45.4_@cloudflare+workers-types@5.20261009.1_@opentelemetry+api@1.9.1_@typ_2c5bdbc2e285e95e03f6fc3b5df79b2b/node_modules/drizzle-orm/sql/expressions/select.js
 function desc(column) {
   return sql`${column} desc`;
 }
@@ -40386,46 +40900,8 @@ var communityFunnelAnalyticsEvent = sqliteTable("community_funnel_analytics_even
   index("idx_community_funnel_analytics_owner_claimed_created").on(t.ownerUserId, t.claimedAt, t.createdAt)
 ]);
 
-// ../shared/src/db/product-analytics-schema.ts
-var exports_product_analytics_schema = {};
-__export(exports_product_analytics_schema, {
-  productAnalyticsEvent: () => productAnalyticsEvent,
-  PRODUCT_ANALYTICS_EVENTS: () => PRODUCT_ANALYTICS_EVENTS
-});
-var PRODUCT_ANALYTICS_EVENTS = [
-  "landing_cta_clicked",
-  "login_page_view",
-  "sign_up",
-  "sign_in_success",
-  "sign_in_failed",
-  "onboarding_enter_clicked",
-  "onboarding_first_message",
-  "invitation_link_visit"
-];
-var productAnalyticsEvent = sqliteTable("product_analytics_event", {
-  id: text2("id").primaryKey(),
-  eventName: text2("event_name").notNull().$type(),
-  actorUserId: text2("actor_user_id").references(() => user.id, { onDelete: "cascade" }),
-  serverId: text2("server_id").references(() => communityServer.id, { onDelete: "cascade" }),
-  sourceId: text2("source_id"),
-  dedupeKey: text2("dedupe_key").notNull(),
-  clientId: text2("client_id").notNull(),
-  sessionId: text2("session_id").notNull(),
-  method: text2("method"),
-  accountKind: text2("account_kind").$type(),
-  ctaName: text2("cta_name"),
-  failureStage: text2("failure_stage").$type(),
-  createdAt: text2("created_at").notNull(),
-  deliveryStatus: text2("delivery_status").notNull().default("pending").$type(),
-  deliveryReason: text2("delivery_reason"),
-  attemptedAt: text2("attempted_at")
-}, (t) => [
-  uniqueIndex("uq_product_analytics_dedupe").on(t.dedupeKey),
-  index("idx_product_analytics_actor_server_event").on(t.actorUserId, t.serverId, t.eventName)
-]);
-
 // ../shared/src/db/index.ts
-var allSchema = { ...exports_schema, ...exports_community_schema, ...exports_community_machine_schema, ...exports_product_plan_schema, ...exports_billing_schema, ...exports_community_funnel_analytics_schema, ...exports_product_analytics_schema };
+var allSchema = { ...exports_schema, ...exports_community_schema, ...exports_community_machine_schema, ...exports_product_plan_schema, ...exports_billing_schema, ...exports_community_funnel_analytics_schema };
 // ../shared/src/community-server-rail.ts
 var MAX_SERVER_RAIL_COMMANDS = 3;
 var idSchema = exports_external.string().trim().min(1);