@bybrawe/opencode-loop 0.5.33 → 0.5.35

package/scripts/schedule-syntax-test.mjs

@@ -0,0 +1,75 @@
+import assert from "node:assert/strict"
+import { normalizeLoopScheduleArgs } from "../src/source/core/schedule-syntax.js"
+
+{
+  const result = normalizeLoopScheduleArgs("continue the project")
+  assert.equal(result.ok, true)
+  assert.equal(result.args, "continue the project")
+  assert.equal(result.defaults.intervalMs, 0)
+  assert.equal(result.defaults.immediate, true)
+  assert.equal(result.scheduleMode, "idle")
+  assert.equal(result.scheduleSyntax, "idle-shorthand")
+}
+
+{
+  const result = normalizeLoopScheduleArgs("--safe --ask-never continue the project")
+  assert.equal(result.ok, true)
+  assert.equal(result.defaults.intervalMs, 0)
+  assert.equal(result.args, "--safe --ask-never continue the project")
+}
+
+{
+  const result = normalizeLoopScheduleArgs("idle continue forever")
+  assert.equal(result.args, "continue forever")
+  assert.equal(result.defaults.intervalMs, 0)
+  assert.equal(result.defaults.immediate, true)
+  assert.equal(result.scheduleMode, "idle")
+}
+
+{
+  const result = normalizeLoopScheduleArgs("every 5m continue forever")
+  assert.equal(result.args, "continue forever")
+  assert.equal(result.defaults.intervalMs, 300_000)
+  assert.equal(result.defaults.immediate, false)
+  assert.equal(result.scheduleMode, "interval")
+  assert.equal(result.scheduleSyntax, "every")
+}
+
+{
+  const result = normalizeLoopScheduleArgs("after 5m continue once")
+  assert.equal(result.args, "continue once")
+  assert.equal(result.defaults.intervalMs, 300_000)
+  assert.equal(result.defaults.immediate, false)
+  assert.equal(result.defaults.maxRuns, 1)
+  assert.equal(result.scheduleMode, "once")
+}
+
+{
+  const result = normalizeLoopScheduleArgs("in 30s ping once")
+  assert.equal(result.args, "ping once")
+  assert.equal(result.defaults.intervalMs, 30_000)
+  assert.equal(result.defaults.maxRuns, 1)
+  assert.equal(result.scheduleSyntax, "after")
+}
+
+{
+  const result = normalizeLoopScheduleArgs("5m continue legacy")
+  assert.equal(result.args, "5m continue legacy")
+  assert.equal(result.scheduleMode, "interval")
+  assert.equal(result.scheduleSyntax, "legacy")
+}
+
+{
+  const result = normalizeLoopScheduleArgs("--allow-goal-overlap continue")
+  assert.equal(result.args, "continue")
+  assert.equal(result.allowGoalOverlap, true)
+  assert.equal(result.scheduleMode, "idle")
+}
+
+{
+  const result = normalizeLoopScheduleArgs("every nope continue")
+  assert.equal(result.ok, false)
+  assert.match(result.error, /Invalid every schedule/)
+}
+
+console.log("schedule syntax tests passed")

package/scripts/session-status-idle-recovery-test.mjs

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict"
+import { clearSessionActivity } from "../src/source/runtime/session-activity.js"
+import { createSessionStatusRuntime } from "../src/source/runtime/session-status.js"
+
+const activeRuns = new Map()
+const logs = []
+let clock = 100_000
+let completion = "completed"
+
+const runtime = createSessionStatusRuntime({
+  activeRuns,
+  now: () => clock,
+  sessionStatusCacheMs: 0,
+  appendLoopLog: async (...args) => logs.push(args),
+  activeRunCompletionFromMessages: async () => completion,
+})
+
+const busyClient = {
+  session: {
+    status: async () => ({ data: { session: { type: "busy" } } }),
+  },
+}
+
+try {
+  runtime.markSessionStatus("session", "busy", clock - 2_000)
+  assert.equal(await runtime.sessionStatusType(busyClient, "session", "/repo"), "idle")
+  assert.equal(logs.at(-1)[1], "status-message-idle-recovery")
+  assert.equal(logs.at(-1)[2].staleStatus, "busy")
+
+  runtime.clearSessionStatus("session")
+  completion = "incomplete"
+  clock += 5_000
+  assert.equal(await runtime.sessionStatusType(busyClient, "session", "/repo"), "busy", "an unfinished tail must never be force-recovered")
+
+  runtime.clearSessionStatus("session")
+  completion = "unknown"
+  clock += 5_000
+  assert.equal(await runtime.sessionStatusType(busyClient, "session", "/repo"), "busy", "unknown tail completion must remain conservative")
+
+  console.log("session status idle recovery tests passed")
+} finally {
+  activeRuns.clear()
+  clearSessionActivity("session")
+}

package/scripts/session-status-test.mjs

@@ -158,17 +158,31 @@ try {
   }
 
   {
-    const sessionID = "stale-recovery"
+    const sessionID = "retry-remains-owned"
     track(sessionID)
     runtime.clearSessionStatus(sessionID)
     activeRuns.set(sessionID, { jobId: "job-2", job: { id: "job-2" }, startedAt: 1_000 })
     completion = "unknown"
+    const beforeLogs = logs.length
     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 }])
+    assert.equal(await runtime.sessionStatusType(client, sessionID, "/repo"), "retry")
+    assert.equal(logs.length, beforeLogs, "unknown retry must not use stale-busy recovery")
     activeRuns.delete(sessionID)
   }
 
+  {
+    const sessionID = "retry-message-complete"
+    track(sessionID)
+    runtime.clearSessionStatus(sessionID)
+    activeRuns.set(sessionID, { jobId: "job-retry-complete", job: { id: "job-retry-complete", name: "retry-complete" }, startedAt: 1_000 })
+    completion = "completed"
+    const client = { session: { status: async () => ({ data: { [sessionID]: { type: "retry" } } }) } }
+    assert.equal(await runtime.sessionStatusType(client, sessionID, "/repo"), "idle", "a genuinely completed current assistant turn may release stale retry")
+    assert.deepEqual(logs.at(-1), ["/repo", "status-message-complete-recovery", { sessionID, job: "retry-complete", startedAt: 1_000 }])
+    activeRuns.delete(sessionID)
+    completion = "unknown"
+  }
+
   {
     const sessionID = "fallback-fresh"
     track(sessionID)
@@ -178,7 +192,7 @@ try {
     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")
+    assert.equal(await runtime.sessionStatusType(client, sessionID, "/repo"), "busy", "status transport failure must fail closed even for an old active run")
     activeRuns.delete(sessionID)
   }