@bybrawe/opencode-loop 0.5.38 → 0.6.1

package/scripts/pulse-check.mjs

@@ -0,0 +1,246 @@
+import { promises as fs } from "node:fs"
+import path from "node:path"
+import { dedicatedGoalOwnsContinuation } from "../src/source/runtime/companion-goal.js"
+
+const LOCK_STALE_MS = 30_000
+const LOCK_RETRY_MS = 25
+const LOCK_RETRIES = 80
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+export function parsePulseDurationMs(value) {
+  const text = String(value ?? "").trim().toLowerCase()
+  if (text === "0" || text === "0s" || text === "now") return 0
+  const match = text.match(/^(\d+(?:\.\d+)?)\s*(ms|s|sec|secs|m|min|mins|h|hr|hrs|d|day|days)$/)
+  if (!match) throw new Error(`Invalid duration: ${value}`)
+  const amount = Number(match[1])
+  const unit = match[2]
+  if (unit === "ms") return amount
+  if (unit.startsWith("s")) return amount * 1000
+  if (unit.startsWith("m")) return amount * 60_000
+  if (unit.startsWith("h")) return amount * 3_600_000
+  if (unit.startsWith("d")) return amount * 86_400_000
+  return amount
+}
+
+function pulseDirectory(project) {
+  return path.join(project, ".opencode", "opencode-loop")
+}
+
+function pulseStateFile(project) {
+  return path.join(pulseDirectory(project), "pulse-check.json")
+}
+
+function pulseLockDirectory(project) {
+  return path.join(pulseDirectory(project), "pulse-check.lock")
+}
+
+function goalDirectory(project) {
+  return path.join(project, ".opencode", "goals")
+}
+
+function timestamp(value) {
+  const parsed = Number(value)
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined
+}
+
+function revision(value) {
+  const parsed = Number(value)
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0
+}
+
+function goalFingerprint(goal) {
+  return [
+    String(goal?.status || "unknown"),
+    timestamp(goal?.updatedAt) ?? 0,
+    revision(goal?.progressRevision),
+    revision(goal?.revision),
+    revision(goal?.storageGeneration),
+  ].join(":")
+}
+
+function formatAge(ms) {
+  if (ms < 60_000) return `${Math.max(0, Math.round(ms / 1000))}s`
+  if (ms < 3_600_000) return `${Math.round(ms / 60_000)}m`
+  if (ms < 86_400_000) return `${(ms / 3_600_000).toFixed(ms < 36_000_000 ? 1 : 0)}h`
+  return `${(ms / 86_400_000).toFixed(ms < 864_000_000 ? 1 : 0)}d`
+}
+
+function iso(value) {
+  const parsed = timestamp(value)
+  if (parsed === undefined) return "unknown"
+  try { return new Date(parsed).toISOString() } catch { return "unknown" }
+}
+
+async function readJson(file, fallback) {
+  try {
+    return JSON.parse(await fs.readFile(file, "utf8"))
+  } catch (error) {
+    if (error?.code === "ENOENT") return fallback
+    throw error
+  }
+}
+
+async function writeJsonAtomic(file, value) {
+  await fs.mkdir(path.dirname(file), { recursive: true })
+  const temporary = `${file}.${process.pid}.${Date.now()}.tmp`
+  await fs.writeFile(temporary, JSON.stringify(value, null, 2) + "\n", "utf8")
+  try {
+    await fs.rename(temporary, file)
+  } catch (error) {
+    try { await fs.rm(temporary, { force: true }) } catch {}
+    throw error
+  }
+}
+
+async function acquireLock(project) {
+  const directory = pulseDirectory(project)
+  const lock = pulseLockDirectory(project)
+  await fs.mkdir(directory, { recursive: true })
+
+  for (let attempt = 0; attempt < LOCK_RETRIES; attempt += 1) {
+    try {
+      await fs.mkdir(lock)
+      return async () => {
+        try { await fs.rm(lock, { recursive: true, force: true }) } catch {}
+      }
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error
+      try {
+        const stat = await fs.stat(lock)
+        if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
+          await fs.rm(lock, { recursive: true, force: true })
+          continue
+        }
+      } catch (statError) {
+        if (statError?.code !== "ENOENT") throw statError
+      }
+      await sleep(LOCK_RETRY_MS)
+    }
+  }
+
+  throw new Error("Goal pulse-check state is busy; another checker still holds the lock")
+}
+
+async function readGoalSnapshots(project, target) {
+  let names
+  try {
+    names = await fs.readdir(goalDirectory(project))
+  } catch (error) {
+    if (error?.code === "ENOENT") return []
+    throw error
+  }
+
+  const goals = []
+  for (const name of names.sort()) {
+    if (!name.endsWith(".json")) continue
+    try {
+      const goal = JSON.parse(await fs.readFile(path.join(goalDirectory(project), name), "utf8"))
+      if (!goal?.id || !goal?.sessionID) continue
+      if (target && goal.id !== target && goal.sessionID !== target) continue
+      goals.push(goal)
+    } catch {}
+  }
+  return goals
+}
+
+export async function checkGoalPulse(project, options = {}) {
+  const staleAfterMs = Number(options.staleAfterMs)
+  if (!Number.isFinite(staleAfterMs) || staleAfterMs < 0) throw new Error("staleAfterMs must be a non-negative number")
+  const now = Number.isFinite(Number(options.now)) ? Number(options.now) : Date.now()
+  const target = options.target ? String(options.target) : undefined
+  const sessionActivity = options.sessionActivity && typeof options.sessionActivity === "object" ? options.sessionActivity : {}
+  const release = await acquireLock(project)
+
+  try {
+    const goals = await readGoalSnapshots(project, target)
+    const stateFile = pulseStateFile(project)
+    const state = await readJson(stateFile, { schemaVersion: 1, goals: {} })
+    if (!state.goals || typeof state.goals !== "object") state.goals = {}
+
+    const alerts = []
+    for (const goal of goals) {
+      const id = String(goal.id)
+      const status = String(goal.status || "unknown")
+      const progressRevision = revision(goal.progressRevision)
+      const goalUpdatedAt = timestamp(goal.updatedAt) ?? now
+      const fingerprint = goalFingerprint(goal)
+      const previous = state.goals[id]
+      const changed = !previous || previous.fingerprint !== fingerprint
+      const statusChanged = Boolean(previous && previous.status !== status)
+      const progressChanged = Boolean(previous && Number(previous.progressRevision || 0) !== progressRevision)
+      const updatedAdvanced = Boolean(previous && goalUpdatedAt > Number(previous.goalUpdatedAt || 0))
+
+      let lastActivityAt
+      if (!previous) {
+        lastActivityAt = goalUpdatedAt
+      } else if (!changed) {
+        lastActivityAt = Number(previous.lastActivityAt || goalUpdatedAt)
+      } else if (updatedAdvanced) {
+        lastActivityAt = goalUpdatedAt
+      } else if (statusChanged || progressChanged || Number(previous.revision || 0) !== revision(goal.revision)) {
+        lastActivityAt = now
+      } else {
+        lastActivityAt = Math.max(Number(previous.lastActivityAt || 0), goalUpdatedAt)
+      }
+
+      let alerted = changed ? false : Boolean(previous?.alerted)
+      let newAlert = false
+      const active = dedicatedGoalOwnsContinuation(goal)
+      const ageMs = Math.max(0, now - lastActivityAt)
+      const sessionUpdatedAt = timestamp(sessionActivity[goal.sessionID])
+
+      if (!active) {
+        alerted = false
+      } else if (ageMs >= staleAfterMs && !alerted) {
+        alerted = true
+        newAlert = true
+        const message = [
+          "[opencode-loopd] GOAL PULSE STALLED",
+          `goal=${id}`,
+          `session=${goal.sessionID}`,
+          `stale=${formatAge(ageMs)}`,
+          `goalUpdated=${iso(goalUpdatedAt)}`,
+          sessionUpdatedAt === undefined ? undefined : `sessionUpdated=${iso(sessionUpdatedAt)}`,
+          'action="/goal resume"',
+        ].filter(Boolean).join(" ")
+        alerts.push({
+          goalID: id,
+          sessionID: String(goal.sessionID),
+          ageMs,
+          goalUpdatedAt,
+          sessionUpdatedAt,
+          progressRevision,
+          message,
+        })
+      } else if (ageMs < staleAfterMs) {
+        alerted = false
+      }
+
+      state.goals[id] = {
+        fingerprint,
+        status,
+        progressRevision,
+        revision: revision(goal.revision),
+        goalUpdatedAt,
+        lastActivityAt,
+        alerted,
+        ...(alerted ? { lastAlertAt: newAlert ? now : previous?.lastAlertAt } : {}),
+        sessionID: String(goal.sessionID),
+      }
+    }
+
+    state.schemaVersion = 1
+    state.updatedAt = now
+    await writeJsonAtomic(stateFile, state)
+    return {
+      alerts,
+      checked: goals.length,
+      stateFile,
+    }
+  } finally {
+    await release()
+  }
+}

package/scripts/session-status-test.mjs

@@ -231,6 +231,17 @@ try {
     track(sessionID)
     runtime.clearSessionStatus(sessionID)
     const active = { jobId: "job", job: {}, startedAt: clock - 100 }
+    completion = "unknown"
+    assert.equal(await runtime.canFinalizeActiveRun("/repo", {}, sessionID, active), true)
+
+    completion = "incomplete"
+    assert.equal(
+      await runtime.canFinalizeActiveRun("/repo", {}, sessionID, active),
+      false,
+      "a transient idle boundary must not finalize a Loop-owned run while the assistant turn is still incomplete",
+    )
+
+    completion = "completed"
     assert.equal(await runtime.canFinalizeActiveRun("/repo", {}, sessionID, active), true)
 
     markToolCallActive({ sessionID, callID: "tool-finalize" })
@@ -240,6 +251,7 @@ try {
     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)
+    completion = "unknown"
   }
 
   {

package/src/index.js

@@ -619,7 +619,9 @@ async function runProcess(command, args, cwd, timeoutMs = 60000) {
     const child = spawn(command, args, { cwd, shell: false, windowsHide: true });
     const stdout = [];
     const stderr = [];
+    let timedOut = false;
     const timer = setTimeout(() => {
+      timedOut = true;
       try {
         child.kill("SIGTERM");
       } catch {}
@@ -632,7 +634,7 @@ async function runProcess(command, args, cwd, timeoutMs = 60000) {
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve({ code: code ?? 0, stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8") });
+      resolve({ code: timedOut ? 124 : code ?? -1, stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8") });
     });
   });
 }
@@ -641,7 +643,9 @@ async function runShellCommand(command, cwd, timeoutMs = 120000) {
     const child = spawn(command, [], { cwd, shell: true, windowsHide: true });
     const stdout = [];
     const stderr = [];
+    let timedOut = false;
     const timer = setTimeout(() => {
+      timedOut = true;
       try {
         child.kill("SIGTERM");
       } catch {}
@@ -654,7 +658,7 @@ async function runShellCommand(command, cwd, timeoutMs = 120000) {
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve({ code: code ?? 0, stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8") });
+      resolve({ code: timedOut ? 124 : code ?? -1, stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8") });
     });
   });
 }
@@ -819,6 +823,8 @@ async function activeRunCompletionFromMessages(directory, client, sessionID, act
   if (!messages)
     return "unknown";
   const ordered = orderedSessionMessages(messages);
+  if (ordered.length === 0)
+    return "unknown";
   const tail = ordered.at(-1);
   const info = tail?.info || tail;
   if (!info || info.role !== "assistant")
@@ -1238,6 +1244,20 @@ function goalStatusText(job) {
     return "paused";
   return status;
 }
+function applyTestfixPreset(job, defaults = {}) {
+  if (defaults.testfixPreset) {
+    const defaultCommand = String(defaults.verifyCommand || "npm test");
+    const parsedAction = String(job.action || "").trim();
+    const usedDefaultAction = parsedAction === String(defaults.action || "").trim();
+    if (!usedDefaultAction && job.verifyCommand === defaults.verifyCommand) {
+      job.verifyCommand = parsedAction;
+      job.action = `Run the project tests. Fix failures. Re-run the tests. Test command hint: ${parsedAction}`;
+    } else if (usedDefaultAction && job.verifyCommand !== defaults.verifyCommand) {
+      job.action = `Run the project tests. Fix failures. Re-run the tests. Test command hint: ${job.verifyCommand || defaultCommand}`;
+    }
+  }
+  return job;
+}
 
 // src/source/opencode/command-router.js
 var HANDLER_NAMES = [
@@ -1739,6 +1759,34 @@ function createGoalCommandHandlers(options = {}) {
 import { promises as fs6 } from "fs";
 import path7 from "path";
 
+// src/source/core/progress.js
+var DEFAULT_PROGRESS_MD = `# Progress
+
+## Current Goal
+Describe the current project goal here.
+
+## Agent Rules
+- Do not ask questions unless truly blocked.
+- Make reasonable assumptions and continue.
+- Work on unfinished TODOs in order.
+- Mark completed TODOs with [x].
+- Add new bugs, ideas, and follow-up work as TODOs.
+- Run tests, lint, or build when available.
+- Do not run destructive commands, force pushes, production deploys, or database resets.
+
+## Active TODO
+- [ ] Review the project structure and pick the next safe improvement.
+
+## Completed
+- [x] Created progress.md.
+
+## Backlog Ideas
+- [ ] Add more project-specific tasks here.
+
+## Blocked
+- None.
+`;
+
 // src/source/runtime/companion-goal.js
 import { promises as fs4 } from "fs";
 import path5 from "path";
@@ -1916,32 +1964,6 @@ async function listPersistedLoopSessions(directory, currentSessionID) {
 
 // src/source/opencode/loop-commands.js
 var SERVICE2 = "opencode-loop";
-var DEFAULT_PROGRESS_MD = `# Progress
-
-## Current Goal
-Describe the current project goal here.
-
-## Agent Rules
-- Do not ask questions unless truly blocked.
-- Make reasonable assumptions and continue.
-- Work on unfinished TODOs in order.
-- Mark completed TODOs with [x].
-- Add new bugs, ideas, and follow-up work as TODOs.
-- Run tests, lint, or build when available.
-- Do not run destructive commands, force pushes, production deploys, or database resets.
-
-## Active TODO
-- [ ] Review the project structure and pick the next safe improvement.
-
-## Completed
-- [x] Created progress.md.
-
-## Backlog Ideas
-- [ ] Add more project-specific tasks here.
-
-## Blocked
-- None.
-`;
 function requireFunction3(value, name) {
   if (typeof value !== "function")
     throw new TypeError(`createLoopCommandHandlers requires ${name}`);
@@ -2241,17 +2263,7 @@ function createLoopRegistration(options = {}) {
     const executionContext = getSessionExecutionContext2(sessionID) || { agent: "build" };
     parsed.job.agent = defaults.agent || executionContext.agent || "build";
     parsed.job.model = normalizedModelRef2(defaults.model) || executionContext.model;
-    if (defaults.testfixPreset) {
-      const defaultCommand = String(defaults.verifyCommand || "npm test");
-      const parsedAction = String(parsed.job.action || "").trim();
-      const usedDefaultAction = parsedAction === String(defaults.action || "").trim();
-      if (!usedDefaultAction && parsed.job.verifyCommand === defaults.verifyCommand) {
-        parsed.job.verifyCommand = parsedAction;
-        parsed.job.action = `Run the project tests. Fix failures. Re-run the tests. Test command hint: ${parsedAction}`;
-      } else if (usedDefaultAction && parsed.job.verifyCommand !== defaults.verifyCommand) {
-        parsed.job.action = `Run the project tests. Fix failures. Re-run the tests. Test command hint: ${parsed.job.verifyCommand || defaultCommand}`;
-      }
-    }
+    applyTestfixPreset(parsed.job, defaults);
     if (parsed.job.watchPaths.length)
       parsed.job.watchSnapshot = await snapshotPaths(directory, parsed.job.watchPaths);
     if (!parsed.job.activeRecoveryMs) {
@@ -2776,13 +2788,14 @@ ${text.trim().slice(0, 20000)}`);
     const branch = safeID(job.branch);
     const inRepo = await runProcess2("git", ["rev-parse", "--is-inside-work-tree"], directory, 1e4);
     if (inRepo.code !== 0) {
-      job.branchDone = true;
+      job.branchDone = false;
+      job.branchUnavailable = true;
       return job;
     }
     let result = await runProcess2("git", ["switch", branch], directory, 30000);
     if (result.code !== 0)
       result = await runProcess2("git", ["switch", "-c", branch], directory, 30000);
-    job.branchDone = true;
+    job.branchDone = result.code === 0;
     await toast(client, result.code === 0 ? `Loop branch active: ${branch}` : `Could not switch/create branch: ${branch}`, result.code === 0 ? "success" : "warning");
     await appendLoopLog2(directory, "branch", { sessionID, branch, code: result.code });
     return job;
@@ -2822,6 +2835,10 @@ ${text.trim().slice(0, 20000)}`);
   async function untilReached(directory, job) {
     if (!job.until)
       return false;
+    const controlRoots = new Set([
+      stateDir(directory),
+      ...["goals", "goal-locks", "goal-handoff-locks", "goal-sequences"].map((name) => path8.join(directory, ".opencode", name))
+    ].map((root) => path8.resolve(root).toLowerCase()));
     const files = ["progress.md", "PROGRESS.md", "todo.md", "TODO.md", "todolist.md", "TODOLIST.md", path8.join(".opencode", "opencode-loop", "until.txt")];
     for (const file of files)
       if (await fileContains(path8.resolve(directory, file), job.until))
@@ -2842,6 +2859,8 @@ ${text.trim().slice(0, 20000)}`);
         if ([".git", "node_modules", "dist", "build", ".next", "coverage"].includes(entry.name))
           continue;
         const full = path8.join(current, entry.name);
+        if (controlRoots.has(path8.resolve(full).toLowerCase()))
+          continue;
         if (entry.isDirectory()) {
           if (await walk(full))
             return true;
@@ -2994,8 +3013,10 @@ function createSessionStatusRuntime(options = {}) {
   async function canFinalizeActiveRun(directory, client, sessionID, active, options = {}) {
     if (hasActiveToolCalls(sessionID) || hasBusyDescendant(sessionID))
       return false;
-    if (!options.requireIdle && !options.forceStale)
-      return true;
+    if (!options.requireIdle && !options.forceStale) {
+      const completion = await activeRunCompletionFromMessages2(directory, client, sessionID, active);
+      return completion !== "incomplete";
+    }
     const completion = options.forceStale ? await activeRunCompletionFromMessages2(directory, client, sessionID, active) : undefined;
     if (settledAssistantCompletion(completion))
       return true;
@@ -4268,6 +4289,7 @@ function createGoalSteeringRuntime(options = {}) {
   const now2 = typeof options.now === "function" ? options.now : now;
   const suppressionMs = Number.isFinite(Number(options.suppressionMs)) && Number(options.suppressionMs) > 0 ? Number(options.suppressionMs) : DEFAULT_STEERING_SUPPRESSION_MS;
   const seenUserMessageMs = Number.isFinite(Number(options.seenUserMessageMs)) && Number(options.seenUserMessageMs) > 0 ? Number(options.seenUserMessageMs) : DEFAULT_SEEN_USER_MESSAGE_MS;
+  const compactingSessions = new Set;
   const pendingSteering = new Map;
   const seenUserMessages = new Map;
   function pendingForSession(sessionID) {
@@ -4341,7 +4363,7 @@ function createGoalSteeringRuntime(options = {}) {
       return { handled: false, sessionID, messageID };
     const active = getActiveRun(sessionID);
     const activeGoalIDs = new Set(goals.map((goal) => goal.id));
-    const canPreempt = active && activeGoalIDs.has(active.jobId) && isGoalJob(active.job) && typeof client?.session?.abort === "function";
+    const canPreempt = !compactingSessions.has(sessionID) && active && activeGoalIDs.has(active.jobId) && isGoalJob(active.job) && typeof client?.session?.abort === "function";
     let preempted = false;
     let abortError = "";
     if (canPreempt) {
@@ -4353,7 +4375,8 @@ function createGoalSteeringRuntime(options = {}) {
       });
       try {
         await fireSdk2(client, "session.abort", client.session.abort.bind(client.session), { path: { id: sessionID }, body: {} }, { path: { sessionID }, body: {} }, { sessionID });
-        clearActiveRun(sessionID);
+        if (getActiveRun(sessionID) === active)
+          clearActiveRun(sessionID);
         preempted = true;
       } catch (error) {
         pendingSteering.delete(sessionID);
@@ -4374,9 +4397,20 @@ function createGoalSteeringRuntime(options = {}) {
     const user = userMessageFromEvent(event);
     if (!user)
       return;
-    return await handleUserMessage(directory, client, user);
+    if (alreadyHandled(user.sessionID, user.messageID))
+      return { handled: false, duplicate: true, ...user };
+    return { handled: false, reason: "untrusted-message-event", ...user };
+  }
+  function setCompacting(sessionID, value = true) {
+    if (typeof sessionID !== "string" || !sessionID)
+      return;
+    if (value)
+      compactingSessions.add(sessionID);
+    else
+      compactingSessions.delete(sessionID);
   }
   function clearSession(sessionID) {
+    compactingSessions.delete(sessionID);
     pendingSteering.delete(sessionID);
     const prefix = `${sessionID}\x00`;
     for (const key of seenUserMessages.keys())
@@ -4390,6 +4424,7 @@ function createGoalSteeringRuntime(options = {}) {
     shouldSuppressIdle,
     hasPendingSteering: shouldSuppressIdle,
     pendingForSession,
+    setCompacting,
     clearSession
   };
 }
@@ -4616,10 +4651,10 @@ var OpenCodeLoopPlugin = async ({ client, directory }) => {
     "command.execute.before": async (input, output) => {
       await handleCommand(directory, client, input, undefined, undefined, output);
     },
-    "chat.message": async (input) => {
+    "chat.message": async (input, output) => {
       const steering = await goalSteeringRuntime.handleUserMessage(directory, client, {
         sessionID: input?.sessionID,
-        messageID: input?.messageID
+        messageID: input?.messageID || output?.message?.id
       });
       if (steering?.handled && steering.sessionID)
         rememberSession(directory, client, steering.sessionID);
@@ -4631,9 +4666,13 @@ var OpenCodeLoopPlugin = async ({ client, directory }) => {
       markToolCallFinished(input);
     },
     "experimental.session.compacting": async (input) => {
+      goalSteeringRuntime.setCompacting(input?.sessionID);
       await noteLoopCompactionStarted(directory, input?.sessionID);
     },
     event: async ({ event }) => {
+      if (["session.compacted", "session.error", "session.deleted"].includes(event?.type)) {
+        goalSteeringRuntime.setCompacting(event?.properties?.sessionID || event?.properties?.info?.id, false);
+      }
       if (event.type === "session.compacted")
         await noteLoopCompactionCompleted(directory, client, event?.properties?.sessionID);
       updateSessionRelationshipFromEvent(event);