woozlit 2.3.0 → 2.3.1

package/src/server/routes/ui.ts

@@ -1,55 +0,0 @@
-import { Flag } from "@/flag/flag"
-import { Hono } from "hono"
-import { proxy } from "hono/proxy"
-import { getMimeType } from "hono/utils/mime"
-import { createHash } from "node:crypto"
-import fs from "node:fs/promises"
-
-const embeddedUIPromise = Flag.WOOZLIT_CODE_DISABLE_EMBEDDED_WEB_UI
-  ? Promise.resolve(null)
-  : // @ts-expect-error - generated file at build time
-    import("opencode-web-ui.gen.ts").then((module) => module.default as Record<string, string>).catch(() => null)
-
-const DEFAULT_CSP =
-  "default-src 'self'; script-src 'self' 'wasm-unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self' data:; media-src 'self' data:; connect-src 'self' data:"
-
-const csp = (hash = "") =>
-  `default-src 'self'; script-src 'self' 'wasm-unsafe-eval'${hash ? ` 'sha256-${hash}'` : ""}; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self' data:; media-src 'self' data:; connect-src 'self' data:`
-
-export const UIRoutes = (): Hono =>
-  new Hono().all("/*", async (c) => {
-    const embeddedWebUI = await embeddedUIPromise
-    const path = c.req.path
-
-    if (embeddedWebUI) {
-      const match = embeddedWebUI[path.replace(/^\//, "")] ?? embeddedWebUI["index.html"] ?? null
-      if (!match) return c.json({ error: "Not Found" }, 404)
-
-      if (await fs.exists(match)) {
-        const mime = getMimeType(match) ?? "text/plain"
-        c.header("Content-Type", mime)
-        if (mime.startsWith("text/html")) {
-          c.header("Content-Security-Policy", DEFAULT_CSP)
-        }
-        return c.body(new Uint8Array(await fs.readFile(match)))
-      } else {
-        return c.json({ error: "Not Found" }, 404)
-      }
-    } else {
-      const response = await proxy(`https://app.opencode.ai${path}`, {
-        raw: c.req.raw,
-        headers: {
-          ...Object.fromEntries(c.req.raw.headers.entries()),
-          host: "app.opencode.ai",
-        },
-      })
-      const match = response.headers.get("content-type")?.includes("text/html")
-        ? (await response.clone().text()).match(
-            /<script\b(?![^>]*\bsrc\s*=)[^>]*\bid=(['"])oc-theme-preload-script\1[^>]*>([\s\S]*?)<\/script>/i,
-          )
-        : undefined
-      const hash = match ? createHash("sha256").update(match[2]).digest("base64") : ""
-      response.headers.set("Content-Security-Policy", csp(hash))
-      return response
-    }
-  })

package/src/server/server.ts

@@ -1,136 +0,0 @@
-import { generateSpecs } from "hono-openapi"
-import { Hono } from "hono"
-import { adapter } from "#hono"
-import { lazy } from "@/util/lazy"
-import { Log } from "@/util"
-import { Flag } from "@/flag/flag"
-import { WorkspaceID } from "@/control-plane/schema"
-import { MDNS } from "./mdns"
-import { AuthMiddleware, CompressionMiddleware, CorsMiddleware, ErrorMiddleware, LoggerMiddleware } from "./middleware"
-import { FenceMiddleware } from "./fence"
-import { initProjectors } from "./projectors"
-import { InstanceRoutes } from "./routes/instance"
-import { ControlPlaneRoutes } from "./routes/control"
-import { UIRoutes } from "./routes/ui"
-import { GlobalRoutes } from "./routes/global"
-import { WorkspaceRouterMiddleware } from "./workspace"
-import { InstanceMiddleware } from "./routes/instance/middleware"
-import { WorkspaceRoutes } from "./routes/control/workspace"
-
-// @ts-ignore This global is needed to prevent ai-sdk from logging warnings to stdout https://github.com/vercel/ai/blob/2dc67e0ef538307f21368db32d5a12345d98831b/packages/ai/src/logger/log-warnings.ts#L85
-globalThis.AI_SDK_LOG_WARNINGS = false
-
-initProjectors()
-
-const log = Log.create({ service: "server" })
-
-export type Listener = {
-  hostname: string
-  port: number
-  url: URL
-  stop: (close?: boolean) => Promise<void>
-}
-
-export const Default = lazy(() => create({}))
-
-function create(opts: { cors?: string[] }) {
-  const app = new Hono()
-    .onError(ErrorMiddleware)
-    .use(AuthMiddleware)
-    .use(LoggerMiddleware)
-    .use(CompressionMiddleware)
-    .use(CorsMiddleware(opts))
-    .route("/global", GlobalRoutes())
-
-  const runtime = adapter.create(app)
-
-  if (Flag.WOOZLIT_CODE_WORKSPACE_ID) {
-    return {
-      app: app
-        .use(InstanceMiddleware(Flag.WOOZLIT_CODE_WORKSPACE_ID ? WorkspaceID.make(Flag.WOOZLIT_CODE_WORKSPACE_ID) : undefined))
-        .use(FenceMiddleware)
-        .route("/", InstanceRoutes(runtime.upgradeWebSocket)),
-      runtime,
-    }
-  }
-
-  return {
-    app: app
-      .route("/", ControlPlaneRoutes())
-      .route(
-        "/",
-        new Hono()
-          .use(InstanceMiddleware())
-          .route("/experimental/workspace", WorkspaceRoutes())
-          .use(WorkspaceRouterMiddleware(runtime.upgradeWebSocket)),
-      )
-      .route("/", InstanceRoutes(runtime.upgradeWebSocket))
-      .route("/", UIRoutes()),
-    runtime,
-  }
-}
-
-export async function openapi() {
-  // Build a fresh app with all routes registered directly so
-  // hono-openapi can see describeRoute metadata (`.route()` wraps
-  // handlers when the sub-app has a custom errorHandler, which
-  // strips the metadata symbol).
-  const { app } = create({})
-  const result = await generateSpecs(app, {
-    documentation: {
-      info: {
-        title: "opencode",
-        version: "1.0.0",
-        description: "opencode api",
-      },
-      openapi: "3.1.1",
-    },
-  })
-  return result
-}
-
-export let url: URL
-
-export async function listen(opts: {
-  port: number
-  hostname: string
-  mdns?: boolean
-  mdnsDomain?: string
-  cors?: string[]
-}): Promise<Listener> {
-  const built = create(opts)
-  const server = await built.runtime.listen(opts)
-
-  const next = new URL("http://localhost")
-  next.hostname = opts.hostname
-  next.port = String(server.port)
-  url = next
-
-  const mdns =
-    opts.mdns &&
-    server.port &&
-    opts.hostname !== "127.0.0.1" &&
-    opts.hostname !== "localhost" &&
-    opts.hostname !== "::1"
-  if (mdns) {
-    MDNS.publish(server.port, opts.mdnsDomain)
-  } else if (opts.mdns) {
-    log.warn("mDNS enabled but hostname is loopback; skipping mDNS publish")
-  }
-
-  let closing: Promise<void> | undefined
-  return {
-    hostname: opts.hostname,
-    port: server.port,
-    url: next,
-    stop(close?: boolean) {
-      closing ??= (async () => {
-        if (mdns) MDNS.unpublish()
-        await server.stop(close)
-      })()
-      return closing
-    },
-  }
-}
-
-export * as Server from "./server"

package/src/server/workspace.ts

@@ -1,122 +0,0 @@
-import type { MiddlewareHandler } from "hono"
-import type { UpgradeWebSocket } from "hono/ws"
-import { getAdaptor } from "@/control-plane/adaptors"
-import { WorkspaceID } from "@/control-plane/schema"
-import { WorkspaceContext } from "@/control-plane/workspace-context"
-import { Workspace } from "@/control-plane/workspace"
-import { Flag } from "@/flag/flag"
-import { InstanceBootstrap } from "@/project/bootstrap"
-import { Instance } from "@/project/instance"
-import { Session } from "@/session"
-import { SessionID } from "@/session/schema"
-import { AppRuntime } from "@/effect/app-runtime"
-import { Effect } from "effect"
-import { Log } from "@/util"
-import { ServerProxy } from "./proxy"
-
-type Rule = { method?: string; path: string; exact?: boolean; action: "local" | "forward" }
-
-const RULES: Array<Rule> = [
-  { path: "/session/status", action: "forward" },
-  { method: "GET", path: "/session", action: "local" },
-]
-
-function local(method: string, path: string) {
-  for (const rule of RULES) {
-    if (rule.method && rule.method !== method) continue
-    const match = rule.exact ? path === rule.path : path === rule.path || path.startsWith(rule.path + "/")
-    if (match) return rule.action === "local"
-  }
-  return false
-}
-
-function getSessionID(url: URL) {
-  if (url.pathname === "/session/status") return null
-
-  const id = url.pathname.match(/^\/session\/([^/]+)(?:\/|$)/)?.[1]
-  if (!id) return null
-
-  return SessionID.make(id)
-}
-
-async function getSessionWorkspace(url: URL) {
-  const id = getSessionID(url)
-  if (!id) return null
-
-  const session = await AppRuntime.runPromise(
-    Session.Service.use((svc) => svc.get(id)).pipe(Effect.withSpan("WorkspaceRouter.lookup")),
-  ).catch(() => undefined)
-  return session?.workspaceID
-}
-
-export function WorkspaceRouterMiddleware(upgrade: UpgradeWebSocket): MiddlewareHandler {
-  const log = Log.create({ service: "workspace-router" })
-
-  return async (c, next) => {
-    const url = new URL(c.req.url)
-
-    const sessionWorkspaceID = await getSessionWorkspace(url)
-    const workspaceID = sessionWorkspaceID || url.searchParams.get("workspace")
-
-    if (!workspaceID || url.pathname.startsWith("/console") || Flag.WOOZLIT_CODE_WORKSPACE_ID) {
-      return next()
-    }
-
-    const workspace = await Workspace.get(WorkspaceID.make(workspaceID))
-
-    if (!workspace) {
-      return new Response(`Workspace not found: ${workspaceID}`, {
-        status: 500,
-        headers: {
-          "content-type": "text/plain; charset=utf-8",
-        },
-      })
-    }
-
-    if (local(c.req.method, url.pathname)) {
-      // No instance provided because we are serving cached data; there
-      // is no instance to work with
-      return next()
-    }
-
-    const adaptor = await getAdaptor(workspace.projectID, workspace.type)
-    const target = await adaptor.target(workspace)
-
-    if (target.type === "local") {
-      return WorkspaceContext.provide({
-        workspaceID: WorkspaceID.make(workspaceID),
-        fn: () =>
-          Instance.provide({
-            directory: target.directory,
-            init: () => AppRuntime.runPromise(InstanceBootstrap),
-            async fn() {
-              return next()
-            },
-          }),
-      })
-    }
-
-    const proxyURL = new URL(target.url)
-    proxyURL.pathname = `${proxyURL.pathname.replace(/\/$/, "")}${url.pathname}`
-    proxyURL.search = url.search
-    proxyURL.hash = url.hash
-    proxyURL.searchParams.delete("workspace")
-
-    log.info("workspace proxy forwarding", {
-      workspaceID,
-      request: url.toString(),
-      target: String(target.url),
-      proxy: proxyURL.toString(),
-    })
-
-    if (c.req.header("upgrade")?.toLowerCase() === "websocket") {
-      return ServerProxy.websocket(upgrade, proxyURL, target.headers, c.req.raw, c.env)
-    }
-
-    const headers = new Headers(c.req.raw.headers)
-    headers.delete("x-WOOZLIT_CODE-workspace")
-
-    const req = new Request(c.req.raw, { headers })
-    return ServerProxy.http(proxyURL, target.headers, req, workspace.id)
-  }
-}

package/src/session/auto-dream.ts

@@ -1,123 +0,0 @@
-import { Effect } from "effect"
-import { Database, eq, desc, asc, isNull } from "@/storage"
-import { SessionTable } from "./session.sql"
-import { Log } from "@/util"
-import type { Config } from "@/config"
-
-const log = Log.create({ service: "auto-dream" })
-
-const DAY_MS = 24 * 60 * 60 * 1000
-const DEFAULT_DREAM_INTERVAL_DAYS = 7
-const DEFAULT_DISTILL_INTERVAL_DAYS = 30
-const MIN_SPAWN_GAP_MS = 10_000
-
-export const AUTO_DREAM_TITLE = "Auto Dream"
-export const AUTO_DISTILL_TITLE = "Auto Distill"
-
-let lastDreamSpawnTime = 0
-let lastDistillSpawnTime = 0
-
-export const DREAM_TASK = [
-  "Run one automatic dream memory consolidation pass for the current project.",
-  "",
-  "Use the memory files as the working index and the raw WOOZLIT_CODE trajectory database as the source of truth.",
-  "Use bash for read-only SQLite and filesystem inspection. Do not modify the database.",
-  "Consolidate only durable, verified information into project memory.",
-].join("\n")
-
-export const DISTILL_TASK = [
-  "Run one automatic distill pass for the current project.",
-  "",
-  "Review the past month of sessions and identify repeated manual workflows worth packaging.",
-  "Use the raw WOOZLIT_CODE trajectory database as the source of truth and memory files to spot cross-session patterns.",
-  "Inventory existing skills, agents, and commands first so you reuse or extend instead of duplicating.",
-  "Use bash for read-only SQLite and filesystem inspection. Do not modify the database.",
-  "Produce a compact shortlist, then create only the high-confidence missing assets.",
-].join("\n")
-
-function shouldAutoRun(input: {
-  enabled: boolean
-  intervalDays: number
-  title: string
-  label: string
-}) {
-  return Effect.gen(function* () {
-    if (!input.enabled) return false
-
-    const intervalMs = input.intervalDays * DAY_MS
-
-    const lastRun = yield* Effect.sync(() =>
-      Database.use((db) =>
-        db
-          .select({ time_created: SessionTable.time_created })
-          .from(SessionTable)
-          .where(eq(SessionTable.title, input.title))
-          .orderBy(desc(SessionTable.time_created))
-          .limit(1)
-          .get(),
-      ),
-    )
-
-    const now = Date.now()
-    const elapsed = lastRun ? now - lastRun.time_created : Infinity
-
-    // First time ever: check if the project is old enough to have anything worth consolidating.
-    // Look at the earliest top-level session (no parent) as the project start time.
-    if (!lastRun) {
-      const earliest = yield* Effect.sync(() =>
-        Database.use((db) =>
-          db
-            .select({ time_created: SessionTable.time_created })
-            .from(SessionTable)
-            .where(isNull(SessionTable.parent_id))
-            .orderBy(asc(SessionTable.time_created))
-            .limit(1)
-            .get(),
-        ),
-      )
-      if (!earliest || now - earliest.time_created < intervalMs) {
-        log.info(`auto-${input.label} skipped — project too young`, {
-          projectAge: earliest ? Math.round((now - earliest.time_created) / DAY_MS) + "d" : "empty",
-          interval: input.intervalDays + "d",
-        })
-        return false
-      }
-    }
-
-    if (elapsed < intervalMs) {
-      log.info(`auto-${input.label} skipped — last run too recent`, {
-        lastRunAgo: Math.round(elapsed / DAY_MS) + "d",
-        interval: input.intervalDays + "d",
-      })
-      return false
-    }
-
-    log.info(`auto-${input.label} triggering`, {
-      lastRun: lastRun ? new Date(lastRun.time_created).toISOString() : "never",
-      interval: input.intervalDays + "d",
-    })
-    return true
-  })
-}
-
-export function shouldAutoDream(cfg: Config.Info) {
-  const enabled = cfg.dream?.auto !== false
-  if (!enabled) return Effect.succeed(false)
-  const now = Date.now()
-  if (now - lastDreamSpawnTime < MIN_SPAWN_GAP_MS) return Effect.succeed(false)
-  lastDreamSpawnTime = now
-  const intervalDays = cfg.dream?.interval_days ?? DEFAULT_DREAM_INTERVAL_DAYS
-  return shouldAutoRun({ enabled, intervalDays, title: AUTO_DREAM_TITLE, label: "dream" })
-}
-
-export function shouldAutoDistill(cfg: Config.Info) {
-  const enabled = cfg.distill?.auto !== false
-  if (!enabled) return Effect.succeed(false)
-  const now = Date.now()
-  if (now - lastDistillSpawnTime < MIN_SPAWN_GAP_MS) return Effect.succeed(false)
-  lastDistillSpawnTime = now
-  const intervalDays = cfg.distill?.interval_days ?? DEFAULT_DISTILL_INTERVAL_DAYS
-  return shouldAutoRun({ enabled, intervalDays, title: AUTO_DISTILL_TITLE, label: "distill" })
-}
-
-export * as AutoDream from "./auto-dream"

package/src/session/boundary.ts

@@ -1,77 +0,0 @@
-type AnyMessage = {
-  role: string
-  content?: unknown[]
-  id?: string
-}
-
-function getToolResultIds(msg: AnyMessage): string[] {
-  if (!Array.isArray(msg.content)) return []
-  const ids: string[] = []
-  for (const block of msg.content as Array<Record<string, unknown>>) {
-    if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
-      ids.push(block.tool_use_id)
-    }
-  }
-  return ids
-}
-
-function getToolUseIds(msg: AnyMessage): string[] {
-  if (!Array.isArray(msg.content)) return []
-  const ids: string[] = []
-  for (const block of msg.content as Array<Record<string, unknown>>) {
-    if (block.type === "tool_use" && typeof block.id === "string") {
-      ids.push(block.id)
-    }
-  }
-  return ids
-}
-
-/**
- * Walk the boundary backward to ensure tool_use/tool_result pairs are not
- * split across the summary/tail divide, and that thinking blocks sharing
- * a message.id with kept assistants are included.
- */
-export function adjustBoundaryForApiInvariants(
-  messages: AnyMessage[],
-  candidateBoundary: number,
-): number {
-  if (candidateBoundary <= 0 || candidateBoundary >= messages.length) {
-    return candidateBoundary
-  }
-
-  let idx = candidateBoundary
-
-  // Step 1: tool_use/tool_result pairing.
-  const tailToolResults: string[] = []
-  const tailToolUses = new Set<string>()
-  for (let i = idx; i < messages.length; i++) {
-    tailToolResults.push(...getToolResultIds(messages[i]))
-    for (const useId of getToolUseIds(messages[i])) tailToolUses.add(useId)
-  }
-  let orphans = tailToolResults.filter((id) => !tailToolUses.has(id))
-
-  for (let i = idx - 1; i >= 0 && orphans.length > 0; i--) {
-    const m = messages[i]
-    if (m.role !== "assistant") continue
-    const useIds = getToolUseIds(m)
-    const matched = useIds.filter((id) => orphans.includes(id))
-    if (matched.length > 0) {
-      idx = i
-      orphans = orphans.filter((id) => !matched.includes(id))
-    }
-  }
-
-  // Step 2: same message.id walk-back (thinking blocks share id with sibling).
-  const boundaryMsgId = messages[idx]?.id
-  if (boundaryMsgId) {
-    for (let i = idx - 1; i >= 0; i--) {
-      if (messages[i].id === boundaryMsgId) {
-        idx = i
-      } else {
-        break
-      }
-    }
-  }
-
-  return idx
-}

package/src/session/budgeted-read.ts

@@ -1,118 +0,0 @@
-import { Token } from "../util"
-
-export interface BudgetedReadResult {
-  text: string
-  truncated: boolean
-  totalTokens: number
-}
-
-export async function readBudgeted(
-  filePath: string,
-  budgetTokens: number,
-): Promise<BudgetedReadResult | undefined> {
-  const fullText = await Bun.file(filePath).text().catch(() => undefined as string | undefined)
-  if (fullText === undefined) return undefined
-  const totalTokens = Token.estimate(fullText)
-  if (totalTokens <= budgetTokens)
-    return { text: fullText, truncated: false, totalTokens }
-  const ratio = budgetTokens / totalTokens
-  const truncatedText = fullText.slice(0, Math.floor(fullText.length * ratio * 0.95))
-  const lastNewline = truncatedText.lastIndexOf("\n")
-  const clean = lastNewline > 0 ? truncatedText.slice(0, lastNewline) : truncatedText
-  const hint =
-    `\n\n⚠️ Truncated at ~${budgetTokens} tokens. ` +
-    `${filePath} is ~${totalTokens} tokens total. ` +
-    `Read("${filePath}", offset=${clean.length}) for the rest.`
-  return { text: clean + hint, truncated: true, totalTokens }
-}
-
-type Section = {
-  header: string
-  italic: string
-  body: string[]
-  indexLines: string[]
-}
-
-function parseSections(text: string): { preamble: string[]; sections: Section[] } {
-  const preamble: string[] = []
-  const sections: Section[] = []
-  let current: Section | null = null
-  let italicSeen = false
-
-  for (const line of text.split("\n")) {
-    if (line.startsWith("## ")) {
-      if (current) sections.push(current)
-      current = { header: line, italic: "", body: [], indexLines: [] }
-      italicSeen = false
-      continue
-    }
-    if (current) {
-      if (!italicSeen && line.startsWith("_") && line.endsWith("_")) {
-        current.italic = line
-        italicSeen = true
-        continue
-      }
-      if (/^- See \S+\.md \(\d+/.test(line.trim())) current.indexLines.push(line)
-      current.body.push(line)
-    } else {
-      preamble.push(line)
-    }
-  }
-  if (current) sections.push(current)
-  return { preamble, sections }
-}
-
-export async function readBudgetedSectionAware(
-  filePath: string,
-  budgetTokens: number,
-): Promise<BudgetedReadResult | undefined> {
-  const fullText = await Bun.file(filePath).text().catch(() => undefined as string | undefined)
-  if (fullText === undefined) return undefined
-  const totalTokens = Token.estimate(fullText)
-  if (totalTokens <= budgetTokens) return { text: fullText, truncated: false, totalTokens }
-
-  const { preamble, sections } = parseSections(fullText)
-  const headerOnlyTokens = Token.estimate(
-    [...preamble, ...sections.flatMap((s) => [s.header, s.italic, ...s.indexLines])].join("\n"),
-  )
-
-  if (headerOnlyTokens >= budgetTokens) {
-    const skeleton = [
-      ...preamble,
-      ...sections.flatMap((s) => [s.header, s.italic, ...s.indexLines, ""]),
-    ].join("\n")
-    const hint =
-      `\n\n⚠️ File extremely large (${totalTokens} tokens vs budget ${budgetTokens}). ` +
-      `Only structure shown.\n   Read("${filePath}") for full content.`
-    return { text: skeleton + hint, truncated: true, totalTokens }
-  }
-
-  const out: string[] = [...preamble]
-  let used = Token.estimate(out.join("\n"))
-
-  for (const sec of sections) {
-    used += Token.estimate([sec.header, sec.italic, ...sec.indexLines].join("\n"))
-    out.push(sec.header, sec.italic, ...sec.indexLines)
-
-    const fullBody = sec.body.filter((l) => !sec.indexLines.includes(l)).join("\n")
-    const bodyTokens = Token.estimate(fullBody)
-    if (used + bodyTokens <= budgetTokens) {
-      out.push(fullBody)
-      used += bodyTokens
-    } else {
-      const remaining = budgetTokens - used
-      if (remaining > 50) {
-        const cutLen = Math.floor(fullBody.length * (remaining / bodyTokens) * 0.95)
-        out.push(fullBody.slice(0, cutLen))
-        used += remaining
-      }
-    }
-    out.push("")
-  }
-
-  const hint =
-    `\n\n⚠️ Truncated at ~${budgetTokens} tokens. ` +
-    `${filePath} is ~${totalTokens} tokens total. ` +
-    `Read("${filePath}") for full content.`
-  return { text: out.join("\n") + hint, truncated: true, totalTokens }
-}

package/src/session/checkpoint-align.ts

@@ -1,29 +0,0 @@
-type AlignMsg = {
-  readonly info: { readonly role: "user" | "assistant" }
-  readonly parts: ReadonlyArray<{ readonly type: string }>
-}
-
-/**
- * Walk backwards from `idx` to find the nearest message satisfying:
- *   - role === "user", AND
- *   - parts is not entirely tool_result parts.
- *
- * Used to align a delta slice's start so the LLM does not see an orphan
- * tool_result. If no qualifying message exists in `[0, idx]`, returns 0
- * (caller may still receive an LLM rejection, in which case writerFailures
- * increments via the existing path — degenerate sessions only).
- *
- * If `idx` is past the end of `msgs`, returns `idx` unchanged: the empty
- * delta is a legitimate (post-watermark) state.
- */
-export function alignToNonToolResultUser(msgs: ReadonlyArray<AlignMsg>, idx: number): number {
-  if (idx >= msgs.length) return idx
-  for (let i = idx; i >= 0; i--) {
-    const m = msgs[i]
-    if (m.info.role !== "user") continue
-    // empty-parts message treated as valid: cannot be an orphan tool_result
-    const allToolResult = m.parts.length > 0 && m.parts.every((p) => p.type === "tool_result")
-    if (!allToolResult) return i
-  }
-  return 0
-}