@bybrawe/opencode-loop 0.5.35 → 0.5.37

package/src/source/legacy-v1.js

@@ -17,6 +17,7 @@ import { createGoalExecutionPolicy } from "./runtime/goal-policy.js"
 import { createJobWorkspaceRuntime, dangerousShell } from "./runtime/job-workspace.js"
 import { createLoopExecutor } from "./runtime/executor.js"
 import { createGoalSteeringRuntime } from "./runtime/goal-steering.js"
+import { findDedicatedGoalForSession } from "./runtime/companion-goal.js"
 
 const DEFAULT_ACTIVE_GUARD_MS = 45_000
 
@@ -162,44 +163,66 @@ function steeringToolRejection(sessionID) {
   }
 }
 
+async function dedicatedGoalToolRejection(directory, sessionID) {
+  const goal = await findDedicatedGoalForSession(directory, sessionID)
+  if (!goal || goal.status === "completed") return undefined
+  return {
+    title: "Dedicated Goal owns lifecycle",
+    output: [
+      `A dedicated OpenCode Goal is persisted for this session (status=${String(goal.status || "unknown")}).`,
+      "The opencode_loop_goal_* tools control only experimental /loop-goal jobs and will not mutate the dedicated Goal.",
+      "Use opencode_goal_progress for checkpoints, opencode_goal_wait_for_user when user/manual input is required, opencode_goal_blocked for a genuine blocker, or opencode_goal_complete for verified completion.",
+    ].join("\n"),
+  }
+}
+
 function goalTools(defaultDirectory) {
   return {
     opencode_loop_goal_complete: tool({
-      description: "Mark the current OpenCode Loop experimental goal as completed. Use only after acceptance criteria are satisfied and you have evidence from tests, typecheck, build, or code inspection.",
+      description: "Experimental /loop-goal ONLY: mark the current OpenCode Loop experimental goal as completed. Never use this tool to control a dedicated @bybrawe/opencode-goal Goal; use opencode_goal_complete there. Use only after acceptance criteria are satisfied and you have evidence from tests, typecheck, build, or code inspection.",
       args: {
         summary: tool.schema.string().describe("Short human-readable summary of what was completed."),
         evidence: tool.schema.string().describe("Concrete evidence that the goal is complete, such as commands run, passing checks, files changed, and important results."),
       },
       execute: async (args, context) => {
+        const directory = context.directory || defaultDirectory
+        const dedicated = await dedicatedGoalToolRejection(directory, context.sessionID)
+        if (dedicated) return dedicated
         const steering = steeringToolRejection(context.sessionID)
         if (steering) return steering
-        const result = await setGoalComplete(context.directory || defaultDirectory, context.sessionID, args)
+        const result = await setGoalComplete(directory, context.sessionID, args)
         return { title: result.ok ? "Goal completed" : result.rejected ? "Goal completion rejected" : "Goal not found", output: result.message }
       },
     }),
     opencode_loop_goal_blocked: tool({
-      description: "Mark the current OpenCode Loop experimental goal as blocked when user input or manual intervention is required.",
+      description: "Experimental /loop-goal ONLY: mark the current OpenCode Loop experimental goal as blocked. Never use this tool for a dedicated @bybrawe/opencode-goal Goal; use opencode_goal_wait_for_user for user/manual input or opencode_goal_blocked for a genuine dedicated-Goal blocker.",
       args: {
         reason: tool.schema.string().describe("Why the goal is blocked."),
         needed: tool.schema.string().describe("What user input, credential, decision, or manual action is needed to continue."),
       },
       execute: async (args, context) => {
+        const directory = context.directory || defaultDirectory
+        const dedicated = await dedicatedGoalToolRejection(directory, context.sessionID)
+        if (dedicated) return dedicated
         const steering = steeringToolRejection(context.sessionID)
         if (steering) return steering
-        const result = await setGoalBlocked(context.directory || defaultDirectory, context.sessionID, args)
+        const result = await setGoalBlocked(directory, context.sessionID, args)
         return { title: result.ok ? "Goal blocked" : "Goal not found", output: result.message }
       },
     }),
     opencode_loop_goal_progress: tool({
-      description: "Record meaningful progress on the current OpenCode Loop experimental goal without completing it.",
+      description: "Experimental /loop-goal ONLY: record meaningful progress on the current OpenCode Loop experimental goal. Never use this tool for a dedicated @bybrawe/opencode-goal Goal; use opencode_goal_progress there.",
       args: {
         summary: tool.schema.string().describe("What useful progress was made."),
         next: tool.schema.string().describe("The next step toward completing the goal."),
       },
       execute: async (args, context) => {
+        const directory = context.directory || defaultDirectory
+        const dedicated = await dedicatedGoalToolRejection(directory, context.sessionID)
+        if (dedicated) return dedicated
         const steering = steeringToolRejection(context.sessionID)
         if (steering) return steering
-        const result = await setGoalProgress(context.directory || defaultDirectory, context.sessionID, args)
+        const result = await setGoalProgress(directory, context.sessionID, args)
         return { title: result.ok ? "Goal progress" : "Goal not found", output: result.message }
       },
     }),

package/src/source/opencode/host.js

@@ -54,10 +54,22 @@ export function orderedSessionMessages(messages) {
     .map((entry) => entry.message)
 }
 
+export function assistantMessageHasMeaningfulActivity(message) {
+  const parts = Array.isArray(message?.parts) ? message.parts : []
+  for (const part of parts) {
+    if (!part || typeof part !== "object") continue
+    if (part.type === "text" && typeof part.text === "string" && part.text.trim()) return true
+    if (["tool", "file", "patch", "artifact"].includes(String(part.type || ""))) return true
+  }
+  const info = message?.info || message || {}
+  return [info.text, info.content, info.summary].some((value) => typeof value === "string" && value.trim())
+}
+
 export async function activeRunCompletionFromMessages(directory, client, sessionID, active) {
   const messages = await readRecentSessionMessages(client, sessionID, directory)
   if (!messages) return "unknown"
-  const tail = orderedSessionMessages(messages).at(-1)
+  const ordered = orderedSessionMessages(messages)
+  const tail = ordered.at(-1)
   const info = tail?.info || tail
   if (!info || info.role !== "assistant") return "incomplete"
   const completed = Number(info?.time?.completed || 0)
@@ -65,7 +77,16 @@ export async function activeRunCompletionFromMessages(directory, client, session
   if (!Number.isFinite(completed) || completed <= 0) return "incomplete"
   const startedAt = Number(active?.startedAt || 0)
   if (startedAt > 0 && completed < startedAt && (!Number.isFinite(created) || created < startedAt)) return "incomplete"
-  return "completed"
+
+  const relevant = ordered.filter((message) => {
+    const candidate = message?.info || message || {}
+    if (candidate.role !== "assistant") return false
+    if (startedAt <= 0) return true
+    const candidateCreated = Number(candidate?.time?.created || 0)
+    const candidateCompleted = Number(candidate?.time?.completed || 0)
+    return candidateCreated >= startedAt || candidateCompleted >= startedAt
+  })
+  return relevant.some(assistantMessageHasMeaningfulActivity) ? "completed" : "empty"
 }
 
 export async function resolveCompactionModel(directory, client, sessionID, preferredModel) {

package/src/source/runtime/empty-turn.js

@@ -0,0 +1,46 @@
+import { actionKind } from "../core/jobs.js"
+
+export const DEFAULT_MAX_EMPTY_TURNS = 2
+
+export function guardsEmptyAssistantTurn(job) {
+  const kind = actionKind(job?.action, job || {})
+  return kind === "prompt" || kind === "goal"
+}
+
+export function emptyTurnLimit(job) {
+  const configured = Number(job?.maxEmptyTurns || 0)
+  if (Number.isFinite(configured) && configured > 0) return Math.max(1, Math.floor(configured))
+  return DEFAULT_MAX_EMPTY_TURNS
+}
+
+export function refundEmptyAssistantTurn(job, active = {}, timestamp = Date.now()) {
+  const chargedCount = Number(active?.job?.runCount ?? job?.runCount ?? 0)
+  const currentCount = Number(job?.runCount || 0)
+  if (chargedCount > 0 && currentCount >= chargedCount) job.runCount = Math.max(0, currentCount - 1)
+
+  if (Number.isFinite(Number(active?.previousLastRunAt))) job.lastRunAt = Number(active.previousLastRunAt)
+  if (active?.disabledByMaxRuns && Number(job?.maxRuns || 0) > 0 && Number(job?.runCount || 0) < Number(job.maxRuns)) {
+    job.enabled = true
+  }
+
+  job.emptyTurnCount = Number(job.emptyTurnCount || 0) + 1
+  job.lastEmptyTurnAt = Number(timestamp) || Date.now()
+  job.lastFailureReason = "empty_turn"
+
+  const limit = emptyTurnLimit(job)
+  const paused = job.emptyTurnCount >= limit
+  if (paused) {
+    job.paused = true
+    delete job.runNowRequestedAt
+  } else {
+    job.runNowRequestedAt = Math.max(1, Number(timestamp) || Date.now())
+  }
+  return { job, paused, count: job.emptyTurnCount, limit }
+}
+
+export function clearEmptyAssistantTurnStreak(job) {
+  if (!job) return job
+  job.emptyTurnCount = 0
+  if (job.lastFailureReason === "empty_turn") delete job.lastFailureReason
+  return job
+}

package/src/source/runtime/executor.js

@@ -11,6 +11,7 @@ import { createActionDispatcher } from "./action-dispatch.js"
 import { createRunFinalizationRuntime } from "./run-finalization.js"
 import { createRunAdmissionRuntime } from "./run-admission.js"
 import { isTransientNetworkError, networkRetryDelayMs, refundInfrastructureRun } from "./network-recovery.js"
+import { guardsEmptyAssistantTurn, refundEmptyAssistantTurn, clearEmptyAssistantTurnStreak } from "./empty-turn.js"
 
 const DEFAULT_ACTIVE_GUARD_MS = 45_000
 const DEFAULT_BUSY_RETRY_MS = 5_000
@@ -77,6 +78,7 @@ export function createLoopExecutor(options = {}) {
     updateSessionStatusFromEvent,
     staleActiveRun,
     canFinalizeActiveRun,
+    activeRunCompletion,
     sessionStatusType,
     sessionIsIdle,
     markSessionStatus,
@@ -267,6 +269,7 @@ export function createLoopExecutor(options = {}) {
     const active = activeRuns.get(sessionID)
     if (!active) return
     if (!await canFinalizeActiveRun(directory, client, sessionID, active, finalizeOptions)) return false
+    const completion = await activeRunCompletion(directory, client, sessionID, active)
     const recoveredStale = staleActiveRun(sessionID)
     if (active.compactionOnly) {
       const pending = compactionRuntime.getPending(sessionID)
@@ -287,6 +290,31 @@ export function createLoopExecutor(options = {}) {
     let job = (state.jobs || []).find((candidate) => candidate.id === active.jobId)
     if (!job) return
     job.lastFinishedAt = now()
+
+    if (completion === "empty" && guardsEmptyAssistantTurn(job)) {
+      const empty = refundEmptyAssistantTurn(job, active, now())
+      state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate)
+      await writeState(directory, sessionID, state)
+      await appendLoopLog(directory, "empty-assistant-turn", {
+        sessionID,
+        job: job.name || job.id,
+        count: empty.count,
+        limit: empty.limit,
+        paused: empty.paused,
+        refunded: true,
+      })
+      if (empty.paused) {
+        await notifyJob(directory, job, "empty_turn")
+        await toast(client, "Loop paused after " + empty.count + " consecutive completed assistant turns with no visible output or tool activity. Resume after changing the model/prompt or use /loop-resume.", "warning")
+        await scheduleDueWork(directory, client, sessionID)
+      } else {
+        await toast(client, "Loop received an empty completed assistant turn; the logical run was refunded and will retry once.", "warning")
+        await scheduleDueWork(directory, client, sessionID, busyRetryMs)
+      }
+      return true
+    }
+
+    if (completion === "completed") clearEmptyAssistantTurnStreak(job)
     if (recoveredStale) {
       await appendLoopLog(directory, "active-stale-recovery", {
         sessionID,

package/src/source/runtime/session-status.js

@@ -24,6 +24,10 @@ function nonNegativeNumber(value, fallback) {
   return Number.isFinite(number) && number >= 0 ? number : fallback
 }
 
+function settledAssistantCompletion(value) {
+  return value === "completed" || value === "empty"
+}
+
 export function createSessionStatusRuntime(options = {}) {
   const activeRuns = options.activeRuns
   if (!(activeRuns instanceof Map)) throw new TypeError("createSessionStatusRuntime requires activeRuns Map")
@@ -114,7 +118,7 @@ export function createSessionStatusRuntime(options = {}) {
     const completion = options.forceStale
       ? await activeRunCompletionFromMessages(directory, client, sessionID, active)
       : undefined
-    if (completion === "completed") return true
+    if (settledAssistantCompletion(completion)) return true
     if (!options.requireIdle) return completion === "unknown" && staleActiveRun(sessionID)
 
     const cached = sessionStatuses.get(sessionID)
@@ -142,7 +146,7 @@ export function createSessionStatusRuntime(options = {}) {
     if (liveType !== "busy") return false
     if (!seenAt || now() - seenAt < sessionStatusCacheMs) return false
     const completion = await activeRunCompletionFromMessages(directory, client, sessionID, { startedAt: 0 })
-    if (completion !== "completed") return false
+    if (!settledAssistantCompletion(completion)) return false
     markSessionStatus(sessionID, "idle")
     await appendLoopLog(directory, "status-message-idle-recovery", {
       sessionID,
@@ -177,7 +181,7 @@ export function createSessionStatusRuntime(options = {}) {
         const active = activeRuns.get(sessionID)
         if (active) {
           const completion = await activeRunCompletionFromMessages(directory, client, sessionID, active)
-          if (completion === "completed" || (live.type === "busy" && completion === "unknown" && staleActiveRun(sessionID))) {
+          if (settledAssistantCompletion(completion) || (live.type === "busy" && completion === "unknown" && staleActiveRun(sessionID))) {
             markSessionStatus(sessionID, "idle")
             const logDetails = {
               sessionID,
@@ -185,11 +189,12 @@ export function createSessionStatusRuntime(options = {}) {
               startedAt: active.startedAt,
               ...(completion === "completed" ? {} : { staleStatus: live.type }),
             }
-            await appendLoopLog(
-              directory,
-              completion === "completed" ? "status-message-complete-recovery" : "status-stale-recovery",
-              logDetails,
-            )
+            const recoveryEvent = completion === "empty"
+              ? "status-message-empty-recovery"
+              : completion === "completed"
+                ? "status-message-complete-recovery"
+                : "status-stale-recovery"
+            await appendLoopLog(directory, recoveryEvent, logDetails)
             return "idle"
           }
         }
@@ -214,6 +219,7 @@ export function createSessionStatusRuntime(options = {}) {
     staleActiveRun,
     canFinalizeActiveRun,
     readLiveSessionStatus,
+    activeRunCompletion: activeRunCompletionFromMessages,
     sessionStatusType,
     sessionIsIdle,
   }