@bybrawe/opencode-loop 0.5.27 → 0.5.29

package/scripts/runtime-event-test.mjs

@@ -0,0 +1,78 @@
+import assert from "node:assert/strict"
+import { normalizeOpenCodeEvent } from "../src/source/runtime/events.js"
+
+assert.deepEqual(
+  normalizeOpenCodeEvent({ type: "session.idle", properties: { sessionID: "ses_idle" } }),
+  { kind: "session", action: "idle", sessionID: "ses_idle", directory: undefined },
+)
+
+assert.deepEqual(
+  normalizeOpenCodeEvent({
+    directory: "/workspace",
+    payload: { type: "session.status", properties: { sessionID: "ses_busy", status: { type: "busy" } } },
+  }),
+  { kind: "session", action: "status", sessionID: "ses_busy", directory: "/workspace", status: "busy" },
+)
+
+assert.deepEqual(
+  normalizeOpenCodeEvent({
+    type: "session.created",
+    properties: { info: { id: "ses_child", directory: "/project", parentID: "ses_parent" } },
+  }),
+  { kind: "session", action: "created", sessionID: "ses_child", directory: "/project", parentID: "ses_parent" },
+)
+
+assert.deepEqual(
+  normalizeOpenCodeEvent({
+    directory: "/workspace",
+    payload: {
+      type: "message.updated",
+      properties: {
+        info: {
+          id: "msg_done",
+          sessionID: "ses_message",
+          role: "assistant",
+          time: { created: 10, completed: 20 },
+          finish: "stop",
+        },
+      },
+    },
+  }),
+  {
+    kind: "message",
+    action: "updated",
+    sessionID: "ses_message",
+    directory: "/workspace",
+    messageID: "msg_done",
+    role: "assistant",
+    completedAt: 20,
+    finish: "stop",
+  },
+)
+
+assert.deepEqual(
+  normalizeOpenCodeEvent({
+    type: "command.executed",
+    properties: { name: "loop-status", sessionID: "ses_command", arguments: "--json", messageID: "msg_command" },
+  }),
+  {
+    kind: "command",
+    action: "executed",
+    sessionID: "ses_command",
+    directory: undefined,
+    name: "loop-status",
+    arguments: "--json",
+    messageID: "msg_command",
+  },
+)
+
+assert.deepEqual(
+  normalizeOpenCodeEvent({ type: "server.instance.disposed", properties: { directory: "/old" } }),
+  { kind: "server", action: "disposed", directory: "/old" },
+)
+
+assert.equal(normalizeOpenCodeEvent({ type: "session.idle", properties: {} }), undefined)
+assert.equal(normalizeOpenCodeEvent({ payload: { properties: {} } }), undefined)
+assert.equal(normalizeOpenCodeEvent({ type: "file.edited", properties: { file: "x.txt" } }), undefined)
+
+console.log("OpenCode runtime event normalization test passed")

package/scripts/runtime-scope-test.mjs

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict"
+import { createRuntimeScope } from "../src/source/runtime/scope.js"
+import { createRuntimeTimers } from "../src/source/runtime/timers.js"
+
+const scope = createRuntimeScope()
+const events = []
+scope.track(() => events.push("first"))
+const release = scope.track(() => events.push("released"))
+scope.track(() => events.push("last"))
+assert.equal(release(), true)
+
+let calls = 0
+const guarded = scope.guard(() => ++calls)
+assert.equal(guarded(), 1)
+
+const cleared = []
+const api = {
+  setTimeout(callback) { return { callback } },
+  clearTimeout(handle) { cleared.push(handle) },
+  setInterval(callback) { return { callback } },
+  clearInterval(handle) { cleared.push(handle) },
+}
+const timers = createRuntimeTimers(scope, api)
+const repeating = timers.interval(() => ++calls, 1)
+repeating.handle.callback()
+assert.equal(calls, 2)
+assert.equal(repeating.cancel(), true)
+repeating.handle.callback()
+assert.equal(calls, 2)
+const pending = timers.interval(() => ++calls, 1)
+
+assert.equal(scope.dispose("done"), true)
+assert.deepEqual(events, ["last", "first"])
+assert.equal(scope.signal.aborted, true)
+assert.equal(scope.isActive(), false)
+pending.handle.callback()
+assert.equal(calls, 2)
+assert.ok(cleared.includes(pending.handle))
+assert.equal(timers.timeout(() => {}, 1), undefined)
+assert.equal(scope.dispose(), false)
+assert.equal(guarded(), undefined)
+
+scope.track(() => events.push("late"))
+assert.deepEqual(events, ["last", "first", "late"])
+
+console.log("OpenCode runtime scope test passed")

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")

package/scripts/session-manager-test.mjs

@@ -0,0 +1,48 @@
+import assert from "node:assert/strict"
+import { createSessionRuntimeManager } from "../src/source/runtime/session-manager.js"
+
+let clock = 1000
+const cleared = []
+const timerAPI = {
+  setTimeout(callback) { return { callback } },
+  clearTimeout(handle) { cleared.push(handle) },
+  setInterval(callback) { return { callback } },
+  clearInterval(handle) { cleared.push(handle) },
+}
+const manager = createSessionRuntimeManager({ now: () => clock, staleAfterMs: 100, timerAPI })
+
+const first = manager.observeExternal("ses_a")
+assert.equal(manager.entries()[0].seenAt, 1000)
+clock = 1050
+assert.equal(manager.peek("ses_a"), first)
+assert.equal(manager.entries()[0].seenAt, 1000, "reads must not refresh external activity")
+assert.equal(manager.observeExternal("ses_a"), first)
+assert.equal(manager.entries()[0].seenAt, 1050)
+
+first.dispose("replace")
+clock = 1060
+const second = manager.observeExternal("ses_a")
+assert.notEqual(second, first)
+assert.equal(manager.remove("ses_a", { expectedRuntime: first }), false)
+assert.equal(manager.peek("ses_a"), second)
+
+let calls = 0
+const pending = second.timers.interval(() => ++calls, 10)
+clock = 1159
+assert.deepEqual(manager.pruneStale(), [])
+clock = 1160
+assert.deepEqual(manager.pruneStale(), ["ses_a"])
+assert.equal(manager.peek("ses_a"), undefined)
+assert.ok(cleared.includes(pending.handle))
+pending.handle.callback()
+assert.equal(calls, 0)
+
+const third = manager.observeExternal("ses_a")
+assert.notEqual(third, second)
+assert.equal(manager.remove("ses_a", { expectedRuntime: third, reason: "done" }), true)
+assert.equal(third.scope.isActive(), false)
+assert.equal(manager.dispose(), true)
+assert.equal(manager.dispose(), false)
+assert.throws(() => manager.observeExternal("ses_b"), /disposed/)
+
+console.log("OpenCode session runtime manager test passed")

package/scripts/session-status-test.mjs

@@ -0,0 +1,220 @@
+import assert from "node:assert/strict"
+import {
+  clearSessionActivity,
+  markToolCallActive,
+  markToolCallFinished,
+  sessionParents,
+  sessionStatuses,
+  sessionStatusSeenAt,
+  updateSessionRelationship,
+} from "../src/source/runtime/session-activity.js"
+import { createSessionStatusRuntime } from "../src/source/runtime/session-status.js"
+
+assert.throws(() => createSessionStatusRuntime({}), /activeRuns Map/)
+
+const activeRuns = new Map()
+const logs = []
+let clock = 100_000
+let completion = "unknown"
+const runtime = createSessionStatusRuntime({
+  activeRuns,
+  now: () => clock,
+  sessionStatusCacheMs: 0,
+  appendLoopLog: async (...args) => { logs.push(args) },
+  activeRunCompletionFromMessages: async () => completion,
+})
+
+const ids = new Set()
+const track = (...values) => {
+  for (const value of values) if (typeof value === "string") ids.add(value)
+}
+
+try {
+  {
+    const sessionID = "event-idle"
+    track(sessionID)
+    const result = runtime.updateSessionStatusFromEvent({ type: "session.idle", properties: { sessionID } })
+    assert.deepEqual(result, { sessionID, idle: true })
+    assert.equal(sessionStatuses.get(sessionID), "idle")
+    assert.equal(sessionStatusSeenAt.get(sessionID), clock)
+
+    clock++
+    assert.deepEqual(
+      runtime.updateSessionStatusFromEvent({ type: "session.status", properties: { sessionID, status: { type: "retry" } } }),
+      { sessionID, idle: false },
+    )
+    assert.equal(sessionStatuses.get(sessionID), "retry")
+    assert.equal(sessionStatusSeenAt.get(sessionID), clock)
+    assert.equal(runtime.updateSessionStatusFromEvent({ type: "message.updated", properties: { sessionID } }), undefined)
+    assert.equal(runtime.updateSessionStatusFromEvent({ type: "session.idle", properties: {} }), undefined)
+  }
+
+  {
+    const sessionID = "mark-clear"
+    track(sessionID)
+    assert.equal(runtime.markSessionStatus(sessionID, "busy", 1234), true)
+    assert.equal(sessionStatuses.get(sessionID), "busy")
+    assert.equal(sessionStatusSeenAt.get(sessionID), 1234)
+    assert.equal(runtime.markSessionStatus(undefined, "busy"), false)
+    runtime.clearSessionStatus(sessionID)
+    assert.equal(sessionStatuses.has(sessionID), false)
+    assert.equal(sessionStatusSeenAt.has(sessionID), false)
+  }
+
+  {
+    const sessionID = "sdk-data-wrapper"
+    track(sessionID)
+    const calls = []
+    const client = {
+      session: {
+        status: async (args) => {
+          calls.push(args)
+          return { data: { [sessionID]: { type: "busy" } } }
+        },
+      },
+    }
+    const live = await runtime.readLiveSessionStatus(client, sessionID, "/repo")
+    assert.deepEqual(live, { type: "busy", source: "sdk" })
+    assert.deepEqual(calls, [{ query: { directory: "/repo" } }])
+    assert.equal(sessionStatuses.get(sessionID), "busy")
+    assert.equal(sessionStatusSeenAt.get(sessionID), clock)
+  }
+
+  {
+    const sessionID = "sdk-error-fallback"
+    track(sessionID)
+    const calls = []
+    const client = {
+      session: {
+        status: async (args) => {
+          calls.push(args)
+          if (calls.length === 1) return { error: { message: "unsupported query shape" } }
+          return { data: { [sessionID]: { type: "idle" } } }
+        },
+      },
+    }
+    const live = await runtime.readLiveSessionStatus(client, sessionID, "/repo")
+    assert.deepEqual(live, { type: "idle", source: "sdk" })
+    assert.equal(calls.length, 2)
+    assert.deepEqual(calls[0], { query: { directory: "/repo" } })
+    assert.deepEqual(calls[1], { directory: "/repo" })
+  }
+
+  {
+    const parentID = "parent-busy-child"
+    const childID = "child-busy"
+    track(parentID, childID)
+    updateSessionRelationship({ id: childID, parentID })
+    const client = {
+      session: {
+        status: async () => ({ data: { [childID]: { type: "busy" } } }),
+      },
+    }
+    const live = await runtime.readLiveSessionStatus(client, parentID, "/repo")
+    assert.deepEqual(live, { type: "busy", source: "descendant" })
+    assert.equal(sessionParents.get(childID), parentID)
+    assert.equal(sessionStatuses.get(childID), "busy")
+  }
+
+  {
+    const parentID = "parent-finished-child"
+    const childID = "child-finished"
+    track(parentID, childID)
+    updateSessionRelationship({ id: childID, parentID })
+    runtime.markSessionStatus(childID, "busy")
+    const client = {
+      session: {
+        status: async () => ({ data: { [parentID]: { type: "idle" } } }),
+      },
+    }
+    const live = await runtime.readLiveSessionStatus(client, parentID, "/repo")
+    assert.deepEqual(live, { type: "idle", source: "sdk" })
+    assert.equal(sessionStatuses.get(childID), "idle", "omitted descendant must be cleared to idle")
+  }
+
+  {
+    const sessionID = "active-tool"
+    track(sessionID)
+    runtime.clearSessionStatus(sessionID)
+    markToolCallActive({ sessionID, callID: "tool-1" })
+    const client = { session: { status: async () => ({ data: { [sessionID]: { type: "idle" } } }) } }
+    assert.equal(await runtime.sessionStatusType(client, sessionID, "/repo"), "busy")
+    assert.equal(sessionStatuses.get(sessionID), "busy")
+    markToolCallFinished({ sessionID, callID: "tool-1" })
+  }
+
+  {
+    const sessionID = "message-complete-recovery"
+    track(sessionID)
+    runtime.clearSessionStatus(sessionID)
+    activeRuns.set(sessionID, { jobId: "job-1", job: { id: "job-1", name: "dev" }, startedAt: 1_000 })
+    completion = "completed"
+    const client = { session: { status: async () => ({ data: { [sessionID]: { type: "busy" } } }) } }
+    assert.equal(await runtime.sessionStatusType(client, sessionID, "/repo"), "idle")
+    assert.equal(sessionStatuses.get(sessionID), "idle")
+    assert.deepEqual(logs.at(-1), ["/repo", "status-message-complete-recovery", { sessionID, job: "dev", startedAt: 1_000 }])
+    activeRuns.delete(sessionID)
+    completion = "unknown"
+  }
+
+  {
+    const sessionID = "stale-recovery"
+    track(sessionID)
+    runtime.clearSessionStatus(sessionID)
+    activeRuns.set(sessionID, { jobId: "job-2", job: { id: "job-2" }, startedAt: 1_000 })
+    completion = "unknown"
+    const client = { session: { status: async () => ({ data: { [sessionID]: { type: "retry" } } }) } }
+    assert.equal(await runtime.sessionStatusType(client, sessionID, "/repo"), "idle")
+    assert.deepEqual(logs.at(-1), ["/repo", "status-stale-recovery", { sessionID, job: "job-2", startedAt: 1_000 }])
+    activeRuns.delete(sessionID)
+  }
+
+  {
+    const sessionID = "fallback-fresh"
+    track(sessionID)
+    runtime.clearSessionStatus(sessionID)
+    activeRuns.set(sessionID, { jobId: "fresh", job: {}, startedAt: clock - 1_000 })
+    const client = { session: { status: async () => { throw new Error("offline") } } }
+    assert.equal(await runtime.sessionStatusType(client, sessionID, "/repo"), "busy")
+    activeRuns.set(sessionID, { jobId: "stale", job: {}, startedAt: clock - 60_000 })
+    runtime.clearSessionStatus(sessionID)
+    assert.equal(await runtime.sessionStatusType(client, sessionID, "/repo"), "idle")
+    activeRuns.delete(sessionID)
+  }
+
+  {
+    const sessionID = "finalize-basic"
+    track(sessionID)
+    runtime.clearSessionStatus(sessionID)
+    const active = { jobId: "job", job: {}, startedAt: clock - 100 }
+    assert.equal(await runtime.canFinalizeActiveRun("/repo", {}, sessionID, active), true)
+
+    markToolCallActive({ sessionID, callID: "tool-finalize" })
+    assert.equal(await runtime.canFinalizeActiveRun("/repo", {}, sessionID, active), false)
+    markToolCallFinished({ sessionID, callID: "tool-finalize" })
+
+    runtime.markSessionStatus(sessionID, "idle", clock + 1)
+    const client = { session: { status: async () => { throw new Error("status unavailable") } } }
+    assert.equal(await runtime.canFinalizeActiveRun("/repo", client, sessionID, active, { requireIdle: true }), true)
+  }
+
+  {
+    const sessionID = "force-stale"
+    track(sessionID)
+    runtime.clearSessionStatus(sessionID)
+    activeRuns.set(sessionID, { jobId: "force", job: {}, startedAt: clock - 60_000 })
+    completion = "unknown"
+    const active = activeRuns.get(sessionID)
+    const client = { session: { status: async () => ({ data: { [sessionID]: { type: "busy" } } }) } }
+    assert.equal(await runtime.canFinalizeActiveRun("/repo", client, sessionID, active, { requireIdle: true, forceStale: true }), true)
+    activeRuns.delete(sessionID)
+  }
+
+  assert.equal(await runtime.readLiveSessionStatus({}, "missing-client", "/repo"), undefined)
+  assert.equal(await runtime.sessionIsIdle({ session: { status: async () => ({ data: {} }) } }, "unlisted", "/repo"), true)
+
+  console.log("session status tests passed")
+} finally {
+  activeRuns.clear()
+  for (const sessionID of ids) clearSessionActivity(sessionID)
+}