@bybrawe/opencode-loop 0.5.28 → 0.5.29

package/scripts/opencode2-loop-canary.mjs

@@ -0,0 +1,433 @@
+import assert from "node:assert/strict"
+import { createServer } from "node:http"
+import net from "node:net"
+import { execFileSync, spawn } from "node:child_process"
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import process from "node:process"
+import { fileURLToPath, pathToFileURL } from "node:url"
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+const LOOP_OBJECTIVE = "real OpenCode 2 loop canary"
+const EXPECTED_TURNS = 2
+const EXPECTED_COMMANDS = ["loop", "loop-pause", "loop-resume", "loop-stop", "loop-remove", "loop-clear"]
+const SERVER_USERNAME = "opencode"
+const SERVER_PASSWORD = "opencode-loop-v2-canary"
+
+function appendLog(current, chunk, limit = 100_000) {
+  return (current + String(chunk)).slice(-limit)
+}
+
+async function reservePort() {
+  return await new Promise((resolve, reject) => {
+    const server = net.createServer()
+    server.once("error", reject)
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address()
+      if (!address || typeof address === "string") return reject(new Error("failed to reserve TCP port"))
+      server.close((error) => error ? reject(error) : resolve(address.port))
+    })
+  })
+}
+
+async function waitForTcp(port, child, logs, timeoutMs = 30_000) {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    if (child.exitCode !== null) throw new Error(`OpenCode 2 server exited before ready.\n${logs()}`)
+    const connected = await new Promise((resolve) => {
+      const socket = net.createConnection({ host: "127.0.0.1", port })
+      socket.once("connect", () => { socket.destroy(); resolve(true) })
+      socket.once("error", () => resolve(false))
+      socket.setTimeout(500, () => { socket.destroy(); resolve(false) })
+    })
+    if (connected) return
+    await new Promise((resolve) => setTimeout(resolve, 100))
+  }
+  throw new Error(`timed out waiting for OpenCode 2 server on ${port}\n${logs()}`)
+}
+
+async function stopProcess(child, timeoutMs = 5_000) {
+  if (!child || child.exitCode !== null) return
+  child.kill("SIGTERM")
+  await new Promise((resolve) => {
+    if (child.exitCode !== null) return resolve()
+    const timer = setTimeout(resolve, timeoutMs)
+    child.once("close", () => { clearTimeout(timer); resolve() })
+  })
+}
+
+async function waitFor(predicate, description, diagnostics, timeoutMs = 60_000) {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    if (await predicate()) return
+    await new Promise((resolve) => setTimeout(resolve, 100))
+  }
+  throw new Error(`timed out waiting for ${description}\n${await diagnostics()}`)
+}
+
+function contentText(content) {
+  if (typeof content === "string") return content
+  if (!Array.isArray(content)) return ""
+  return content.map((part) => typeof part?.text === "string" ? part.text : typeof part?.content === "string" ? part.content : "").join("\n")
+}
+
+function lastUserText(body) {
+  const messages = Array.isArray(body.messages) ? body.messages : []
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (messages[index]?.role === "user") return contentText(messages[index]?.content)
+  }
+  return ""
+}
+
+function streamHeaders(res) {
+  res.writeHead(200, {
+    "content-type": "text/event-stream; charset=utf-8",
+    "cache-control": "no-cache",
+    connection: "keep-alive",
+  })
+}
+
+function writeSse(res, value) {
+  res.write(`data: ${JSON.stringify(value)}\n\n`)
+}
+
+function streamText(res, content, sequence) {
+  const id = `chatcmpl-v2-loop-${sequence}`
+  const created = Math.floor(Date.now() / 1000)
+  streamHeaders(res)
+  writeSse(res, {
+    id,
+    object: "chat.completion.chunk",
+    created,
+    model: "canary",
+    choices: [{ index: 0, delta: { role: "assistant", content }, finish_reason: null }],
+  })
+  writeSse(res, {
+    id,
+    object: "chat.completion.chunk",
+    created,
+    model: "canary",
+    choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+    usage: { prompt_tokens: 30, completion_tokens: 4, total_tokens: 34 },
+  })
+  res.end("data: [DONE]\n\n")
+}
+
+function startProvider() {
+  const stats = { chatRequests: 0, loopRequests: 0, paths: [] }
+  const server = createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1")
+    stats.paths.push(`${req.method} ${url.pathname}`)
+    if (req.method === "GET" && url.pathname.endsWith("/models")) {
+      res.writeHead(200, { "content-type": "application/json" })
+      res.end(JSON.stringify({ object: "list", data: [{ id: "canary", object: "model", owned_by: "canary" }] }))
+      return
+    }
+    if (req.method !== "POST" || !url.pathname.endsWith("/chat/completions")) {
+      res.writeHead(404, { "content-type": "application/json" })
+      res.end(JSON.stringify({ error: { message: `unexpected endpoint: ${req.method} ${url.pathname}` } }))
+      return
+    }
+
+    let raw = ""
+    for await (const chunk of req) raw += String(chunk)
+    const body = raw ? JSON.parse(raw) : {}
+    stats.chatRequests += 1
+    const text = lastUserText(body)
+    if (text.includes("AUTONOMOUS OPENCODE LOOP ITERATION")) {
+      stats.loopRequests += 1
+      streamText(res, `V2_LOOP_TURN_${stats.loopRequests}`, stats.chatRequests)
+      return
+    }
+    streamText(res, "OK", stats.chatRequests)
+  })
+
+  return {
+    stats,
+    async listen() {
+      await new Promise((resolve, reject) => {
+        server.once("error", reject)
+        server.listen(0, "127.0.0.1", resolve)
+      })
+      const address = server.address()
+      if (!address || typeof address === "string") throw new Error("failed to start deterministic V2 provider")
+      return address.port
+    },
+    async close() {
+      await new Promise((resolve) => server.close(() => resolve()))
+    },
+  }
+}
+
+function bridgePluginSource() {
+  return `import { writeFile } from "node:fs/promises"
+
+export default {
+  id: "bybrawe.opencode-loop.v2.loop-canary-bridge",
+  async setup(ctx) {
+    const module = await import(process.env.OPENCODE_LOOP_V2_PLUGIN_URL)
+    const cleanup = await module.default.setup(ctx)
+    await writeFile(process.env.OPENCODE_LOOP_V2_MARKER, JSON.stringify({ activated: true }, null, 2), "utf8")
+    return async () => {
+      if (typeof cleanup === "function") await cleanup()
+    }
+  },
+}
+`
+}
+
+function commandNames(payload) {
+  const data = Array.isArray(payload?.data) ? payload.data : Array.isArray(payload) ? payload : []
+  return new Set(data.map((item) => item?.name).filter((name) => typeof name === "string"))
+}
+
+async function main() {
+  assert.equal(process.platform, "linux", "the real OpenCode 2 Loop canary is intentionally Ubuntu-only")
+
+  const workspace = await mkdtemp(path.join(os.tmpdir(), "opencode-loop-v2-e2e-"))
+  const home = path.join(workspace, ".home")
+  const pluginDir = path.join(workspace, ".opencode", "plugins")
+  const marker = path.join(workspace, "v2-real-adapter-marker.json")
+  const provider = startProvider()
+  const providerPort = await provider.listen()
+  let server
+  let serverLog = ""
+  let apiPrefix = null
+  let latestCommands = new Set()
+  let sessionID = ""
+  let commandError = null
+
+  await Promise.all([
+    mkdir(pluginDir, { recursive: true }),
+    mkdir(path.join(home, ".config"), { recursive: true }),
+    mkdir(path.join(home, ".local", "share"), { recursive: true }),
+    mkdir(path.join(home, ".local", "state"), { recursive: true }),
+  ])
+
+  await writeFile(path.join(pluginDir, "opencode-loop-v2-real.js"), bridgePluginSource(), "utf8")
+  await writeFile(path.join(workspace, "opencode.json"), `${JSON.stringify({
+    $schema: "https://opencode.ai/config.json",
+    model: "canary/canary",
+    providers: {
+      canary: {
+        name: "Deterministic OpenCode 2 Loop Canary",
+        package: "@opencode-ai/ai/providers/openai-compatible",
+        settings: { baseURL: `http://127.0.0.1:${providerPort}/v1` },
+        models: {
+          canary: {
+            name: "Deterministic OpenCode 2 Loop Canary",
+            capabilities: { tools: true, input: ["text"], output: ["text"] },
+            limit: { context: 100000, output: 4096 },
+          },
+        },
+      },
+    },
+  }, null, 2)}\n`)
+
+  execFileSync("git", ["init", "--quiet", workspace], { stdio: "ignore" })
+  execFileSync("git", ["-C", workspace, "config", "user.email", "opencode-loop-ci@example.invalid"], { stdio: "ignore" })
+  execFileSync("git", ["-C", workspace, "config", "user.name", "OpenCode Loop CI"], { stdio: "ignore" })
+  execFileSync("git", ["-C", workspace, "add", "."], { stdio: "ignore" })
+  execFileSync("git", ["-C", workspace, "commit", "--quiet", "-m", "init"], { stdio: "ignore" })
+
+  const env = {
+    ...process.env,
+    HOME: home,
+    USERPROFILE: home,
+    XDG_CONFIG_HOME: path.join(home, ".config"),
+    XDG_DATA_HOME: path.join(home, ".local", "share"),
+    XDG_STATE_HOME: path.join(home, ".local", "state"),
+    XDG_CACHE_HOME: path.join(home, ".cache"),
+    OPENCODE_LOOP_V2_PLUGIN_URL: pathToFileURL(path.join(repoRoot, "src", "source", "opencode2", "experimental.js")).href,
+    OPENCODE_LOOP_V2_MARKER: marker,
+    OPENCODE_SERVER_USERNAME: SERVER_USERNAME,
+    OPENCODE_SERVER_PASSWORD: SERVER_PASSWORD,
+    OPENCODE_DISABLE_AUTOUPDATE: "true",
+    OPENCODE_DISABLE_LSP_DOWNLOAD: "true",
+    CI: "true",
+  }
+
+  const diagnostics = async () => {
+    let state = "missing"
+    if (sessionID) {
+      try { state = await readFile(path.join(workspace, ".opencode", "opencode-loop", `${sessionID}.json`), "utf8") } catch {}
+    }
+    return [
+      `apiPrefix=${String(apiPrefix)}`,
+      `commands=${JSON.stringify([...latestCommands])}`,
+      `provider=${JSON.stringify(provider.stats)}`,
+      `sessionID=${sessionID || "none"}`,
+      `commandError=${String(commandError ?? "none")}`,
+      `state=${state}`,
+      `serverExit=${server?.exitCode}`,
+      `serverLog=${serverLog}`,
+    ].join("\n")
+  }
+
+  try {
+    const port = await reservePort()
+    server = spawn("opencode2", ["serve", "--hostname", "127.0.0.1", "--port", String(port)], {
+      cwd: workspace,
+      env,
+      windowsHide: true,
+    })
+    server.stdout?.on("data", (chunk) => { serverLog = appendLog(serverLog, chunk) })
+    server.stderr?.on("data", (chunk) => { serverLog = appendLog(serverLog, chunk) })
+    await waitForTcp(port, server, () => serverLog)
+
+    const baseURL = `http://127.0.0.1:${port}`
+    const authorization = `Basic ${Buffer.from(`${SERVER_USERNAME}:${SERVER_PASSWORD}`).toString("base64")}`
+    const request = async (pathname, init = {}, timeoutMs = 30_000) => {
+      const response = await fetch(`${baseURL}${pathname}`, {
+        ...init,
+        headers: {
+          "content-type": "application/json",
+          "x-opencode-directory": workspace,
+          authorization,
+          ...(init.headers ?? {}),
+        },
+        signal: init.signal ?? AbortSignal.timeout(timeoutMs),
+      })
+      const text = await response.text()
+      let body = null
+      if (text) {
+        try { body = JSON.parse(text) } catch { body = text }
+      }
+      return { ok: response.ok, status: response.status, body, text }
+    }
+
+    for (const prefix of ["/api", ""]) {
+      const deadline = Date.now() + 30_000
+      while (Date.now() < deadline) {
+        let response
+        try { response = await request(`${prefix}/command`, { method: "GET" }, 5_000) } catch {}
+        if (response?.ok) {
+          apiPrefix = prefix
+          break
+        }
+        if (response && ![404, 503].includes(response.status)) {
+          throw new Error(`command registry probe failed with HTTP ${response.status}: ${response.text}\n${await diagnostics()}`)
+        }
+        if (response?.status === 404) break
+        await new Promise((resolve) => setTimeout(resolve, 250))
+      }
+      if (apiPrefix !== null) break
+    }
+    assert.notEqual(apiPrefix, null, `OpenCode 2 command API never became ready\n${await diagnostics()}`)
+
+    await waitFor(async () => {
+      try { return Boolean(JSON.parse(await readFile(marker, "utf8"))?.activated) } catch { return false }
+    }, "experimental V2 plugin activation", diagnostics, 30_000)
+
+    await waitFor(async () => {
+      const response = await request(`${apiPrefix}/command`, { method: "GET" }, 5_000)
+      if (!response.ok) return false
+      latestCommands = commandNames(response.body)
+      return EXPECTED_COMMANDS.every((name) => latestCommands.has(name))
+    }, "plugin-registered Loop commands to enter the real V2 registry", diagnostics, 30_000)
+
+    const createdResponse = await request(`${apiPrefix}/session`, {
+      method: "POST",
+      body: JSON.stringify({ title: "OpenCode 2 Loop canary" }),
+    })
+    if (!createdResponse.ok) throw new Error(`session create failed: HTTP ${createdResponse.status} ${createdResponse.text}\n${await diagnostics()}`)
+    const session = createdResponse.body?.data ?? createdResponse.body
+    sessionID = String(session?.id ?? "")
+    assert.ok(sessionID, `OpenCode 2 did not create a session: ${createdResponse.text}\n${await diagnostics()}`)
+
+    const commandPromise = request(`${apiPrefix}/session/${encodeURIComponent(sessionID)}/command`, {
+      method: "POST",
+      body: JSON.stringify({ command: "loop", arguments: `0s --max-runs ${EXPECTED_TURNS} ${LOOP_OBJECTIVE}` }),
+    }, 120_000).catch((error) => {
+      commandError = error
+      return null
+    })
+
+    await waitFor(() => provider.stats.loopRequests >= EXPECTED_TURNS, `${EXPECTED_TURNS} autonomous OpenCode 2 Loop turns`, diagnostics, 90_000)
+    await new Promise((resolve) => setTimeout(resolve, 1_000))
+    assert.equal(provider.stats.loopRequests, EXPECTED_TURNS, `V2 Loop exceeded --max-runs ${EXPECTED_TURNS}\n${await diagnostics()}`)
+
+    const stateFile = path.join(workspace, ".opencode", "opencode-loop", `${sessionID}.json`)
+    const persisted = JSON.parse(await readFile(stateFile, "utf8"))
+    const loop = persisted.jobs?.find((job) => job.name === "default")
+    assert.ok(loop, `persisted V2 Loop job was missing\n${await diagnostics()}`)
+    assert.equal(loop.runCount, EXPECTED_TURNS)
+    assert.equal(loop.enabled, false)
+
+    const commandResponse = await commandPromise
+    if (commandError) throw commandError
+    assert.ok(commandResponse?.ok, `Loop command request failed: ${commandResponse?.status} ${commandResponse?.text}\n${await diagnostics()}`)
+    assert.equal(server.exitCode, null, `OpenCode 2 server exited during canary\n${await diagnostics()}`)
+
+    const readPersisted = async () => {
+      try { return JSON.parse(await readFile(stateFile, "utf8")) }
+      catch (error) {
+        if (error?.code === "ENOENT") return { jobs: [] }
+        throw error
+      }
+    }
+    const jobNamed = async (name) => (await readPersisted()).jobs?.find((job) => String(job?.name || "default") === name)
+    const sendControl = async (command, argumentsText = "") => {
+      const response = await request(`${apiPrefix}/session/${encodeURIComponent(sessionID)}/command`, {
+        method: "POST",
+        body: JSON.stringify({ command, arguments: argumentsText }),
+      }, 120_000)
+      if (!response.ok) throw new Error(`${command} failed: HTTP ${response.status} ${response.text}\n${await diagnostics()}`)
+      return response
+    }
+
+    await sendControl("loop-pause", "default")
+    await waitFor(async () => (await jobNamed("default"))?.paused === true, "real V2 loop-pause state mutation", diagnostics, 30_000)
+
+    await sendControl("loop-resume", "default")
+    await waitFor(async () => {
+      const job = await jobNamed("default")
+      return job?.paused === false && job?.lastRunAt === 0
+    }, "real V2 loop-resume state mutation", diagnostics, 30_000)
+
+    await sendControl("loop-stop", "default")
+    await waitFor(async () => !(await jobNamed("default")), "real V2 loop-stop removal", diagnostics, 30_000)
+
+    const beforeRemoveTurn = provider.stats.loopRequests
+    await sendControl("loop", "0s --max-runs 1 --name removable removable control lifecycle task")
+    await waitFor(() => provider.stats.loopRequests === beforeRemoveTurn + 1, "real V2 removable Loop turn", diagnostics, 60_000)
+    await waitFor(async () => {
+      const job = await jobNamed("removable")
+      return job?.runCount === 1 && job?.enabled === false
+    }, "real V2 removable Loop persisted completion", diagnostics, 30_000)
+    await sendControl("loop-remove", "removable")
+    await waitFor(async () => !(await jobNamed("removable")), "real V2 loop-remove removal", diagnostics, 30_000)
+
+    const beforeClearTurn = provider.stats.loopRequests
+    await sendControl("loop", "0s --max-runs 1 --name clearable clearable control lifecycle task")
+    await waitFor(() => provider.stats.loopRequests === beforeClearTurn + 1, "real V2 clearable Loop turn", diagnostics, 60_000)
+    await waitFor(async () => Boolean(await jobNamed("clearable")), "real V2 clearable Loop persistence", diagnostics, 30_000)
+    await sendControl("loop-clear")
+    await waitFor(async () => (await readPersisted()).jobs?.length === 0, "real V2 loop-clear state removal", diagnostics, 30_000)
+
+    assert.equal(provider.stats.loopRequests, EXPECTED_TURNS + 2, `control lifecycle should add exactly two autonomous Loop turns\n${await diagnostics()}`)
+    assert.equal(server.exitCode, null, `OpenCode 2 server exited during control lifecycle canary\n${await diagnostics()}`)
+
+    console.log(JSON.stringify({
+      ok: true,
+      apiPrefix,
+      sessionID,
+      registeredCommands: [...latestCommands],
+      loopRequests: provider.stats.loopRequests,
+      chatRequests: provider.stats.chatRequests,
+      initialRunCount: loop.runCount,
+      initialEnabled: loop.enabled,
+      controlsVerified: ["loop-pause", "loop-resume", "loop-stop", "loop-remove", "loop-clear"],
+    }, null, 2))
+  } finally {
+    await stopProcess(server)
+    await provider.close().catch(() => undefined)
+    await rm(workspace, { recursive: true, force: true }).catch(() => undefined)
+  }
+}
+
+main().catch((error) => {
+  console.error(error?.stack || error)
+  process.exitCode = 1
+})

package/scripts/scheduler-runtime-test.mjs

@@ -0,0 +1,147 @@
+import assert from "node:assert/strict"
+import { createSchedulerRuntime, jobDueAt, nextDueDelay } from "../src/source/runtime/scheduler.js"
+
+const baseJob = (overrides = {}) => ({
+  id: "job-1",
+  enabled: true,
+  paused: false,
+  maxRuns: 0,
+  runCount: 0,
+  watchPaths: [],
+  createdAt: new Date(0).toISOString(),
+  intervalMs: 100,
+  lastRunAt: 950,
+  ...overrides,
+})
+
+assert.equal(jobDueAt(baseJob(), 1_000), 1_050)
+assert.equal(jobDueAt(baseJob({ intervalMs: 0 }), 1_000), 1_000)
+assert.equal(jobDueAt(baseJob({ lastRunAt: 0 }), 1_000), 1_000)
+assert.equal(jobDueAt(baseJob({ lastRunAt: 0, immediate: true, createdAt: new Date(900).toISOString(), intervalMs: 200 }), 1_000), 1_000)
+assert.equal(jobDueAt(baseJob({ lastRunAt: 0, immediate: false, createdAt: new Date(900).toISOString(), intervalMs: 200 }), 1_000), 1_100)
+assert.equal(nextDueDelay({ jobs: [baseJob({ lastRunAt: 0, immediate: false, createdAt: new Date(900).toISOString(), intervalMs: 200 })] }, 1_000), 100)
+assert.equal(jobDueAt(baseJob({ lastRunAt: 0, immediate: false, createdAt: new Date(900).toISOString(), intervalMs: 200, watchPaths: ["x"], runNowRequestedAt: 999 }), 1_000), 1_000)
+assert.equal(nextDueDelay({ jobs: [baseJob({ lastRunAt: 0, immediate: false, intervalMs: 200, watchPaths: ["x"], runNowRequestedAt: 999 })] }, 1_000), 0)
+assert.equal(jobDueAt(baseJob({ paused: true, runNowRequestedAt: 999 }), 1_000), Infinity)
+assert.equal(jobDueAt(baseJob({ enabled: false, runNowRequestedAt: 999 }), 1_000), Infinity)
+assert.equal(jobDueAt(baseJob({ maxRuns: 2, runCount: 2, runNowRequestedAt: 999 }), 1_000), Infinity)
+assert.equal(jobDueAt(baseJob({ kind: "goal", goalStatus: "completed", runNowRequestedAt: 999 }), 1_000), Infinity)
+assert.equal(nextDueDelay({ jobs: [baseJob(), baseJob({ paused: true })] }, 1_000), 50)
+assert.equal(nextDueDelay({ jobs: [baseJob({ paused: true })] }, 1_000), Infinity)
+
+function fakeTimers() {
+  let id = 0
+  const timeouts = new Map()
+  const intervals = new Map()
+  const setTimeout = (fn, ms) => {
+    const timer = { id: ++id, fn, ms }
+    timeouts.set(timer.id, timer)
+    return timer
+  }
+  const clearTimeout = (timer) => { if (timer) timeouts.delete(timer.id) }
+  const setInterval = (fn, ms) => {
+    const timer = { id: ++id, fn, ms }
+    intervals.set(timer.id, timer)
+    return timer
+  }
+  const clearInterval = (timer) => { if (timer) intervals.delete(timer.id) }
+  const flush = async () => { for (let i = 0; i < 10; i++) await Promise.resolve() }
+  const fireTimeout = async (timer) => {
+    timeouts.delete(timer.id)
+    timer.fn()
+    await flush()
+  }
+  const fireInterval = async (timer) => {
+    timer.fn()
+    await flush()
+  }
+  return { timeouts, intervals, setTimeout, clearTimeout, setInterval, clearInterval, fireTimeout, fireInterval }
+}
+
+const timers = fakeTimers()
+let clock = 1_000
+const events = []
+const state = { jobs: [baseJob()] }
+const client = { name: "fake-client" }
+const runtime = createSchedulerRuntime({
+  now: () => clock,
+  readState: async () => state,
+  sessionIsIdle: async () => true,
+  finalizeActiveRun: async (_directory, _client, _sessionID, options) => events.push(options?.forceStale ? "heartbeat-finalize" : "finalize"),
+  maybeRunDueJobs: async (_directory, _client, _sessionID, options) => events.push(options?.heartbeat ? "heartbeat-run" : "run"),
+  appendLoopLog: async () => {},
+  toast: async () => {},
+  errorMessage: (error) => error?.message || String(error),
+  setTimeout: timers.setTimeout,
+  clearTimeout: timers.clearTimeout,
+  setInterval: timers.setInterval,
+  clearInterval: timers.clearInterval,
+  idleDebounceMs: 5,
+  busyRetryMs: 7,
+  minDueTimerMs: 1,
+  maxDueTimerMs: 1_000,
+  heartbeatMs: 10,
+  sessionTtlMs: 1_000,
+})
+
+runtime.rememberSession("/workspace", client, "ses-1")
+runtime.rememberSession("/workspace", client, "ses-1")
+assert.equal(runtime.knownSessionCount(), 1)
+assert.equal(timers.intervals.size, 1, "heartbeat must be deduplicated")
+
+runtime.scheduleIdleWork("/workspace", client, "ses-1")
+runtime.scheduleIdleWork("/workspace", client, "ses-1")
+assert.equal(timers.timeouts.size, 1, "idle timer must replace the previous timer")
+const idleTimer = [...timers.timeouts.values()][0]
+assert.equal(idleTimer.ms, 5)
+await timers.fireTimeout(idleTimer)
+assert.deepEqual(events.splice(0), ["finalize", "run"])
+
+await runtime.scheduleDueWork("/workspace", client, "ses-1")
+assert.equal(timers.intervals.size, 2, "watchdog should run alongside heartbeat")
+const dueTimer = [...timers.timeouts.values()][0]
+assert.equal(dueTimer.ms, 50)
+await timers.fireTimeout(dueTimer)
+assert.deepEqual(events.splice(0), ["finalize", "run"])
+
+const heartbeat = [...timers.intervals.values()].find((timer) => timer.ms === 10)
+assert.ok(heartbeat)
+await timers.fireInterval(heartbeat)
+assert.deepEqual(events.splice(0), ["heartbeat-finalize", "heartbeat-run"])
+
+await runtime.scheduleDueWork("/workspace", client, "ses-1")
+assert.ok(timers.timeouts.size > 0)
+runtime.clearSessionScheduling("ses-1")
+assert.equal(runtime.knownSessionCount(), 0)
+assert.equal(timers.timeouts.size, 0)
+assert.equal(timers.intervals.size, 0, "clearing the last session should stop watchdog and heartbeat")
+
+const busyTimers = fakeTimers()
+let idleChecks = 0
+const busyRuntime = createSchedulerRuntime({
+  now: () => 2_000,
+  readState: async () => ({ jobs: [baseJob({ intervalMs: 0, lastRunAt: 0 })] }),
+  sessionIsIdle: async () => (++idleChecks > 1),
+  finalizeActiveRun: async () => { throw new Error("finalize should not run while first idle check is busy") },
+  maybeRunDueJobs: async () => {},
+  appendLoopLog: async () => {},
+  toast: async () => {},
+  setTimeout: busyTimers.setTimeout,
+  clearTimeout: busyTimers.clearTimeout,
+  setInterval: busyTimers.setInterval,
+  clearInterval: busyTimers.clearInterval,
+  idleDebounceMs: 3,
+  busyRetryMs: 7,
+  minDueTimerMs: 1,
+  heartbeatMs: 10,
+})
+
+busyRuntime.scheduleIdleWork("/workspace", client, "ses-busy")
+const busyIdleTimer = [...busyTimers.timeouts.values()][0]
+await busyTimers.fireTimeout(busyIdleTimer)
+const retryTimer = [...busyTimers.timeouts.values()][0]
+assert.ok(retryTimer)
+assert.equal(retryTimer.ms, 7, "busy idle handler should reschedule with busy retry delay")
+busyRuntime.clearSessionScheduling("ses-busy")
+
+console.log("scheduler runtime tests passed")

package/scripts/session-activity-test.mjs

@@ -0,0 +1,95 @@
+import assert from "node:assert/strict"
+import {
+  activeToolCalls,
+  sessionParents,
+  sessionStatuses,
+  sessionStatusSeenAt,
+  hasActiveToolCalls,
+  markToolCallActive,
+  markToolCallFinished,
+  updateSessionRelationship,
+  updateSessionRelationshipFromEvent,
+  isDescendantSession,
+  hasBusyDescendant,
+  refreshSessionRelationships,
+  updateToolActivityFromEvent,
+  clearSessionActivity,
+} from "../src/source/runtime/session-activity.js"
+
+const parentID = "ses_parent"
+const childID = "ses_child"
+const listedChildID = "ses_listed_child"
+
+for (const sessionID of [parentID, childID, listedChildID]) clearSessionActivity(sessionID)
+
+updateSessionRelationship({ id: childID, parentID })
+assert.equal(sessionParents.get(childID), parentID)
+assert.equal(isDescendantSession(childID, parentID), true)
+assert.equal(isDescendantSession(parentID, childID), false)
+
+markToolCallActive({ sessionID: childID, callID: "call_1" })
+assert.equal(hasActiveToolCalls(childID), true)
+assert.equal(sessionStatuses.get(childID), "busy")
+assert.ok((sessionStatusSeenAt.get(childID) || 0) > 0)
+assert.equal(hasBusyDescendant(parentID), true)
+
+markToolCallFinished({ sessionID: childID, callID: "call_1" })
+assert.equal(hasActiveToolCalls(childID), false)
+sessionStatuses.set(childID, "idle")
+assert.equal(hasBusyDescendant(parentID), false)
+
+updateToolActivityFromEvent({
+  type: "message.part.updated",
+  properties: {
+    part: {
+      type: "tool",
+      sessionID: childID,
+      callID: "call_2",
+      id: "part_2",
+      state: { status: "running" },
+    },
+  },
+})
+assert.equal(activeToolCalls.get(childID)?.has("call_2"), true)
+
+updateToolActivityFromEvent({
+  type: "message.part.updated",
+  properties: {
+    part: {
+      type: "tool",
+      sessionID: childID,
+      callID: "call_2",
+      id: "part_2",
+      state: { status: "completed" },
+    },
+  },
+})
+assert.equal(hasActiveToolCalls(childID), false)
+
+await refreshSessionRelationships({
+  session: {
+    list: async () => [{ id: listedChildID, parentID }],
+  },
+}, "/tmp/opencode-loop-session-activity")
+assert.equal(sessionParents.get(listedChildID), parentID)
+
+updateSessionRelationshipFromEvent({
+  type: "session.deleted",
+  properties: { info: { id: listedChildID, parentID } },
+})
+assert.equal(sessionParents.has(listedChildID), false)
+
+sessionParents.set(parentID, childID)
+sessionParents.set(childID, parentID)
+assert.equal(isDescendantSession(parentID, "ses_missing"), false)
+sessionParents.delete(parentID)
+
+clearSessionActivity(childID)
+assert.equal(activeToolCalls.has(childID), false)
+assert.equal(sessionParents.has(childID), false)
+assert.equal(sessionStatuses.has(childID), false)
+assert.equal(sessionStatusSeenAt.has(childID), false)
+clearSessionActivity(parentID)
+clearSessionActivity(listedChildID)
+
+console.log("session activity runtime tests passed")