tulingcode 0.1.0

package/src/server/routes/ui.ts

@@ -0,0 +1,55 @@
+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.tulingcode_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

@@ -0,0 +1,136 @@
+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.tulingcode_WORKSPACE_ID) {
+    return {
+      app: app
+        .use(InstanceMiddleware(Flag.tulingcode_WORKSPACE_ID ? WorkspaceID.make(Flag.tulingcode_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

@@ -0,0 +1,122 @@
+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.tulingcode_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-tulingcode-workspace")
+
+    const req = new Request(c.req.raw, { headers })
+    return ServerProxy.http(proxyURL, target.headers, req, workspace.id)
+  }
+}

package/src/session/auto-dream.ts

@@ -0,0 +1,123 @@
+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 tulingcode 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 tulingcode 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

@@ -0,0 +1,77 @@
+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

@@ -0,0 +1,118 @@
+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

@@ -0,0 +1,29 @@
+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
+}