@bojackduy/opencode-loopd 1.8.2 → 1.9.1

package/dist/server.js

@@ -1,34 +1,5 @@
 // @bun
-var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-
 // src/domain/runtime.ts
-var exports_runtime = {};
-__export(exports_runtime, {
-  acquireLease: () => acquireLease,
-  addToolCall: () => addToolCall,
-  createRuntimeState: () => createRuntimeState,
-  hasActiveToolCalls: () => hasActiveToolCalls,
-  leaseIsValid: () => leaseIsValid,
-  markParentNotified: () => markParentNotified,
-  markProgress: () => markProgress,
-  recordActivity: () => recordActivity,
-  releaseLease: () => releaseLease,
-  removeToolCall: () => removeToolCall,
-  shouldNotifyParent: () => shouldNotifyParent
-});
 function createRuntimeState(goalID) {
   const now = new Date().toISOString();
   return {
@@ -40,6 +11,7 @@ function createRuntimeState(goalID) {
     noProgressCount: 0,
     progressDuringTurn: false,
     unknownStatusCount: 0,
+    accountedMessageIDs: [],
     runGeneration: 0,
     createdAt: now,
     updatedAt: now
@@ -59,6 +31,9 @@ function acquireLease(rt, timeoutMs) {
     lastActivityAt: new Date(now).toISOString(),
     idleCandidateAt: undefined,
     idleCandidateGeneration: undefined,
+    idleConfirmFailedAt: undefined,
+    idleConfirmFailedGeneration: undefined,
+    idleStuckNotifiedGeneration: undefined,
     activePromptObservedAt: undefined,
     activeAssistantMessageID: undefined,
     activeAssistantCompletedAt: undefined,
@@ -135,9 +110,6 @@ function removeToolCall(rt, callID) {
     updatedAt: new Date().toISOString()
   };
 }
-function hasActiveToolCalls(rt) {
-  return (rt.activeToolCallIDs?.length ?? 0) > 0;
-}
 var PARENT_NOTIFY_DEDUPE_MS = 60000;
 
 // src/application/control-worker.ts
@@ -176,8 +148,8 @@ async function acquireLock(directory, key, operation) {
     try {
       try {
         const raw = await fs.readFile(lockPath, "utf8");
-        const meta2 = JSON.parse(raw);
-        const age = Date.now() - Date.parse(meta2.acquiredAt);
+        const meta = JSON.parse(raw);
+        const age = Date.now() - Date.parse(meta.acquiredAt);
         if (age > LOCK_STALE_MS) {
           await fs.rm(lockPath, { force: true });
         }
@@ -511,6 +483,16 @@ function resolveGoalCreationConfig(input) {
   const explicitAgent = cleanText(requested.agent);
   const defaultAgent = cleanText(defaults.defaultAgent);
   const agent = explicitAgent || defaultAgent || undefined;
+  const explicitModel = cleanText(requested.model);
+  const defaultModel = cleanText(defaults.defaultModel);
+  const model = explicitModel || defaultModel || undefined;
+  if (model && !isValidModelRef(model)) {
+    return {
+      ok: false,
+      errorCode: "invalid_model",
+      message: `Invalid model "${model}". Use "providerID/modelID" (e.g. "openai/gpt-5.6-sol", "ollama/qwen3.8:27b"). Discover with \`opencode models\`.`
+    };
+  }
   const workspaceWrite = requested.workspaceWrite ?? true;
   const explicitChecks = cleanList(requested.checks);
   const defaultChecks = workspaceWrite ? cleanList(defaults.defaultChecks || ["bun test"]) : [];
@@ -527,16 +509,30 @@ function resolveGoalCreationConfig(input) {
     config: {
       ...requested,
       agent,
+      model,
       workspaceWrite,
       checks: checks.length > 0 ? checks : undefined,
       checkCwd: requested.checkCwd || (workspaceWrite ? input.directory : undefined)
     },
     defaultsApplied: {
       agent: !explicitAgent && Boolean(defaultAgent),
+      model: !explicitModel && Boolean(defaultModel),
       checks: explicitChecks.length === 0 && defaultChecks.length > 0
     }
   };
 }
+function isValidModelRef(value) {
+  const slash = value.indexOf("/");
+  if (slash <= 0 || slash >= value.length - 1)
+    return false;
+  const providerID = value.slice(0, slash).trim();
+  const modelID = value.slice(slash + 1).trim();
+  if (!providerID || !modelID)
+    return false;
+  if (/\s/.test(providerID) || /\s/.test(modelID))
+    return false;
+  return true;
+}
 function cleanText(value) {
   if (typeof value !== "string")
     return;
@@ -712,54 +708,54 @@ function createControlWorker(options) {
           ownerSessionID: args.ownerSessionID,
           config: resolution.config
         });
-        const state2 = await readState(directory);
+        const state = await readState(directory);
         response = {
           ...base,
           message: `goal "${args.name}" created (${goal.id.slice(0, 8)}...)`,
-          stateRevision: state2.revision
+          stateRevision: state.revision
         };
         break;
       }
       case "pause": {
         await goalSvc.pause(directory, request.goalID);
-        const state2 = await readState(directory);
-        const goal = state2.goals.find((g) => g.id === request.goalID);
+        const state = await readState(directory);
+        const goal = state.goals.find((g) => g.id === request.goalID);
         response = {
           ...base,
           message: `goal "${goal?.name || request.goalID}" paused`,
-          stateRevision: state2.revision
+          stateRevision: state.revision
         };
         break;
       }
       case "resume": {
         await goalSvc.resume(directory, request.goalID);
-        const state2 = await readState(directory);
-        const goal = state2.goals.find((g) => g.id === request.goalID);
+        const state = await readState(directory);
+        const goal = state.goals.find((g) => g.id === request.goalID);
         response = {
           ...base,
           message: `goal "${goal?.name || request.goalID}" resumed`,
-          stateRevision: state2.revision
+          stateRevision: state.revision
         };
         break;
       }
       case "retry": {
         await goalSvc.retry(directory, request.goalID);
-        const state2 = await readState(directory);
-        const goal = state2.goals.find((g) => g.id === request.goalID);
+        const state = await readState(directory);
+        const goal = state.goals.find((g) => g.id === request.goalID);
         response = {
           ...base,
           message: `goal "${goal?.name || request.goalID}" retried`,
-          stateRevision: state2.revision
+          stateRevision: state.revision
         };
         break;
       }
       case "clear": {
         await goalSvc.clear(directory, request.goalID);
-        const state2 = await readState(directory);
+        const state = await readState(directory);
         response = {
           ...base,
           message: `goal cleared`,
-          stateRevision: state2.revision
+          stateRevision: state.revision
         };
         break;
       }
@@ -775,25 +771,25 @@ function createControlWorker(options) {
           break;
         }
         await appendGoalInbox(directory, request.goalID, "user", text);
-        const state2 = await readState(directory);
-        const goal = state2.goals.find((g) => g.id === request.goalID);
+        const state = await readState(directory);
+        const goal = state.goals.find((g) => g.id === request.goalID);
         response = {
           ...base,
           message: `sent to "${goal?.name || request.goalID}"`,
-          stateRevision: state2.revision
+          stateRevision: state.revision
         };
         break;
       }
       case "force_complete": {
         const args = request.args;
-        const state2 = await readState(directory);
-        const goal = state2.goals.find((g) => g.id === request.goalID);
+        const state = await readState(directory);
+        const goal = state.goals.find((g) => g.id === request.goalID);
         if (!goal) {
           response = { ...base, ok: false, message: "goal not found", errorCode: "not_found" };
           break;
         }
         if (goal.status === "complete") {
-          response = { ...base, message: `goal "${goal.name}" already complete`, stateRevision: state2.revision };
+          response = { ...base, message: `goal "${goal.name}" already complete`, stateRevision: state.revision };
           break;
         }
         goal.status = "complete";
@@ -803,14 +799,14 @@ function createControlWorker(options) {
           evidence: String(args.evidence || "Manual override \u2014 no verification checks run."),
           at: new Date().toISOString()
         };
-        const runtime = state2.runtimes.find((r) => r.goalID === goal.id);
+        const runtime = state.runtimes.find((r) => r.goalID === goal.id);
         if (runtime) {
           Object.assign(runtime, releaseLease(runtime));
           runtime.activeRunID = undefined;
           runtime.lastError = undefined;
           runtime.updatedAt = new Date().toISOString();
         }
-        await writeState(directory, state2);
+        await writeState(directory, state);
         await appendEvent(directory, {
           version: 1,
           eventID: randomUUID(),
@@ -819,22 +815,22 @@ function createControlWorker(options) {
           summary: goal.completionEvidence.summary,
           evidence: goal.completionEvidence.evidence,
           timestamp: new Date().toISOString(),
-          revision: state2.revision
+          revision: state.revision
         });
-        response = { ...base, message: `goal "${goal.name}" force-completed`, stateRevision: state2.revision };
+        response = { ...base, message: `goal "${goal.name}" force-completed`, stateRevision: state.revision };
         break;
       }
       case "force_block":
       case "block": {
         const args = request.args;
-        const state2 = await readState(directory);
-        const goal = state2.goals.find((g) => g.id === request.goalID);
+        const state = await readState(directory);
+        const goal = state.goals.find((g) => g.id === request.goalID);
         if (!goal) {
           response = { ...base, ok: false, message: "goal not found", errorCode: "not_found" };
           break;
         }
         if (goal.status === "blocked") {
-          response = { ...base, message: `goal "${goal.name}" already blocked`, stateRevision: state2.revision };
+          response = { ...base, message: `goal "${goal.name}" already blocked`, stateRevision: state.revision };
           break;
         }
         goal.status = "blocked";
@@ -844,14 +840,14 @@ function createControlWorker(options) {
           needed: String(args.needed || "User intervention required."),
           at: new Date().toISOString()
         };
-        const runtime = state2.runtimes.find((r) => r.goalID === goal.id);
+        const runtime = state.runtimes.find((r) => r.goalID === goal.id);
         if (runtime) {
           Object.assign(runtime, releaseLease(runtime));
           runtime.activeRunID = undefined;
           runtime.lastError = undefined;
           runtime.updatedAt = new Date().toISOString();
         }
-        await writeState(directory, state2);
+        await writeState(directory, state);
         await appendEvent(directory, {
           version: 1,
           eventID: randomUUID(),
@@ -860,9 +856,9 @@ function createControlWorker(options) {
           reason: goal.blocker.reason,
           needed: goal.blocker.needed,
           timestamp: new Date().toISOString(),
-          revision: state2.revision
+          revision: state.revision
         });
-        response = { ...base, message: `goal "${goal.name}" blocked`, stateRevision: state2.revision };
+        response = { ...base, message: `goal "${goal.name}" blocked`, stateRevision: state.revision };
         break;
       }
       default: {
@@ -878,8 +874,8 @@ function createControlWorker(options) {
     await recordInLedger(directory, request);
     return response;
   }
-  async function recordInLedger(directory2, request) {
-    const state = await readState(directory2);
+  async function recordInLedger(directory, request) {
+    const state = await readState(directory);
     if (!state.commandLedger)
       state.commandLedger = [];
     state.commandLedger.push({
@@ -892,7 +888,7 @@ function createControlWorker(options) {
     if (state.commandLedger.length > MAX_LEDGER_SIZE) {
       state.commandLedger = state.commandLedger.slice(-MAX_LEDGER_SIZE);
     }
-    await writeState(directory2, state);
+    await writeState(directory, state);
   }
   return { start, stop: async () => {
     await stop();
@@ -936,7 +932,7 @@ function isTerminal(status) {
 }
 function createGoal(input) {
   const now = new Date().toISOString();
-  return { ...input, tokensUsed: 0, timeUsedSeconds: 0, createdAt: now, updatedAt: now };
+  return { ...input, tokensUsed: 0, costUsed: 0, timeUsedSeconds: 0, createdAt: now, updatedAt: now };
 }
 // src/application/loop-engine.ts
 var CONFIRM_IDLE_DURATION_MS = 2000;
@@ -953,6 +949,9 @@ function createLoopEngine(options) {
   const maintenanceMs = options.pollIntervalMs ?? 30000;
   const confirmIdleMs = options.confirmIdleMs ?? CONFIRM_IDLE_DURATION_MS;
   const unknownStatusThreshold = Math.max(1, options.unknownStatusThreshold ?? 3);
+  const stuckRunningMs = options.stuckRunningMs ?? 10 * 60000;
+  const idleUnconfirmedMs = options.idleUnconfirmedMs ?? 5 * 60000;
+  const idleRecoverMs = options.idleRecoverMs ?? 3 * 60000;
   let running = false;
   let maintenanceTimer;
   let knownWorkerSessions = new Set;
@@ -1076,6 +1075,8 @@ function createLoopEngine(options) {
       } else {
         const part = event.properties?.part;
         if (part?.messageID && part.messageID === rt.activeAssistantMessageID) {
+          if (rt.activeAssistantCompletedAt)
+            return s;
           Object.assign(rt, recordActivity(rt));
           matched = true;
         }
@@ -1115,7 +1116,9 @@ function createLoopEngine(options) {
       const elapsed = now - Date.parse(rt.idleCandidateAt);
       if (elapsed < confirmIdleMs)
         return s;
-      if (rt.lastActivityAt && rt.lastActivityAt > rt.idleCandidateAt) {
+      const anchoredHere = Boolean(rt.activeAssistantCompletedAt);
+      const quietSince = anchoredHere && rt.activeAssistantCompletedAt ? rt.activeAssistantCompletedAt : rt.idleCandidateAt;
+      if (rt.lastActivityAt && rt.lastActivityAt > rt.idleCandidateAt && rt.lastActivityAt > quietSince) {
         rt.idleCandidateAt = undefined;
         rt.idleCandidateGeneration = undefined;
         return s;
@@ -1137,8 +1140,35 @@ function createLoopEngine(options) {
     });
     if (confirmation) {
       const candidate = confirmation;
+      const stagedRt = afterIdle.runtimes.find((r) => r.goalID === goalID);
+      const eventAnchored = stagedRt?.runGeneration === candidate.generation && Boolean(stagedRt?.activeAssistantCompletedAt);
       const transcript = await inspectPromptTurn(goal.workerSessionID, candidate.promptMessageID);
-      if (!transcript.latestUserPrompt || !candidate.assistantCompleted && !transcript.assistantCompleted) {
+      const failureReason = !transcript.latestUserPrompt && !eventAnchored ? "prompt-outside-window" : !eventAnchored && !candidate.assistantCompleted && !transcript.assistantCompleted ? "assistant-incomplete" : undefined;
+      if (failureReason) {
+        let newlyStamped = false;
+        await mutateState(directory, `idle.confirm-stamp:${goalID}`, async (s) => {
+          const rt = s.runtimes.find((r) => r.goalID === goalID);
+          if (!rt || rt.runGeneration !== candidate.generation)
+            return s;
+          if (rt.idleConfirmFailedGeneration !== candidate.generation) {
+            rt.idleConfirmFailedAt = new Date().toISOString();
+            rt.idleConfirmFailedGeneration = candidate.generation;
+            newlyStamped = true;
+          }
+          return s;
+        });
+        if (newlyStamped) {
+          await appendEvent(directory, {
+            version: 1,
+            eventID: randomUUID2(),
+            goalID,
+            type: "idle.confirm-failed",
+            reason: failureReason,
+            runGeneration: candidate.generation,
+            timestamp: new Date().toISOString(),
+            revision: afterIdle.revision
+          });
+        }
         return true;
       }
       afterIdle = await mutateState(directory, `idle.confirm:${goalID}`, async (s) => {
@@ -1156,14 +1186,19 @@ function createLoopEngine(options) {
           return s;
         if (rt.idleCandidateAt !== candidate.candidateAt)
           return s;
-        if (rt.lastActivityAt && rt.lastActivityAt > candidate.candidateAt)
-          return s;
+        if (rt.lastActivityAt && rt.lastActivityAt > candidate.candidateAt) {
+          const quiet = rt.runGeneration === candidate.generation && rt.activeAssistantCompletedAt ? rt.activeAssistantCompletedAt : candidate.candidateAt;
+          if (rt.lastActivityAt > quiet)
+            return s;
+        }
         if ((rt.activeToolCallIDs?.length ?? 0) > 0)
           return s;
         completedRunID = rt.activeRunID;
         Object.assign(rt, releaseLease(rt));
         rt.activeRunID = undefined;
         rt.lastWorkerStatus = "idle";
+        rt.idleConfirmFailedAt = undefined;
+        rt.idleConfirmFailedGeneration = undefined;
         return s;
       });
     }
@@ -1206,6 +1241,12 @@ function createLoopEngine(options) {
         return true;
       recentForceFinishBlocked.set(blockedKey, nowBlocked);
       let shouldNotifyBlocked = false;
+      await goalService.accountUsage(directory, goalID).catch(() => ({
+        tokenDelta: 0,
+        costDelta: 0,
+        timeDeltaSeconds: 0,
+        counted: []
+      }));
       const blockedState = await mutateState(directory, `idle.blocked:${goalID}`, async (s) => {
         const g = s.goals.find((item) => item.id === goalID);
         if (!g)
@@ -1276,7 +1317,7 @@ function createLoopEngine(options) {
       return noMatch;
     let messages;
     try {
-      messages = await host.readMessages(workerSessionID, 50);
+      messages = await host.readMessages(workerSessionID, 200);
     } catch {
       return noMatch;
     }
@@ -1434,6 +1475,16 @@ function createLoopEngine(options) {
         reason: `Token budget exhausted (${goal.tokensUsed}/${goal.tokenBudget})`
       };
     }
+    if (typeof goal.costBudget === "number" && (goal.costUsed ?? 0) >= goal.costBudget) {
+      goal.status = "budget_limited";
+      goal.updatedAt = new Date().toISOString();
+      return {
+        stop: "budget",
+        blocked: true,
+        event: "goal.status_changed",
+        reason: `Cost budget exhausted ($${(goal.costUsed ?? 0).toFixed(4)}/$${goal.costBudget})`
+      };
+    }
     return noResult;
   }
   function shouldCompact(goal, runtime) {
@@ -1472,6 +1523,67 @@ function createLoopEngine(options) {
       return s;
     });
   }
+  async function accountAndEnforceBudget(goal) {
+    try {
+      await goalService.accountUsage(directory, goal.id);
+    } catch {}
+    const fresh = await readState(directory);
+    const g = fresh.goals.find((item) => item.id === goal.id);
+    if (!g || g.status !== "active")
+      return false;
+    const overTokens = typeof g.tokenBudget === "number" && g.tokensUsed >= g.tokenBudget;
+    const overCost = typeof g.costBudget === "number" && (g.costUsed ?? 0) >= g.costBudget;
+    if (!overTokens && !overCost)
+      return false;
+    const reason = overCost ? `Cost budget exhausted ($${(g.costUsed ?? 0).toFixed(4)}/$${g.costBudget})` : `Token budget exhausted (${g.tokensUsed}/${g.tokenBudget})`;
+    if (g.workerSessionID) {
+      try {
+        await host.abortSession(g.workerSessionID);
+      } catch {}
+    }
+    let shouldNotify = false;
+    const stoppedState = await mutateState(directory, `maintenance.budget:${goal.id}`, async (s) => {
+      const target = s.goals.find((item) => item.id === goal.id);
+      if (!target || target.status !== "active")
+        return s;
+      target.status = "budget_limited";
+      target.updatedAt = new Date().toISOString();
+      const rt = s.runtimes.find((r) => r.goalID === goal.id);
+      if (rt) {
+        Object.assign(rt, releaseLease(rt));
+        rt.activeRunID = undefined;
+        rt.updatedAt = new Date().toISOString();
+        if (shouldNotifyParent(rt, "stopped")) {
+          markParentNotified(rt, "stopped");
+          shouldNotify = true;
+        }
+      }
+      return s;
+    });
+    const stoppedGoal = stoppedState.goals.find((item) => item.id === goal.id);
+    if (stoppedGoal?.status !== "budget_limited")
+      return false;
+    await appendEvent(directory, {
+      version: 1,
+      eventID: randomUUID2(),
+      goalID: goal.id,
+      type: "goal.status_changed",
+      from: "active",
+      to: "budget_limited",
+      timestamp: new Date().toISOString(),
+      revision: stoppedState.revision
+    });
+    await logServerEvent(directory, "maintenance.budget-exhausted", {
+      goalID: goal.id,
+      reason,
+      tokensUsed: stoppedGoal.tokensUsed,
+      costUsed: stoppedGoal.costUsed
+    });
+    if (shouldNotify) {
+      await host.notifyOwner(goal.ownerSessionID, `Loop goal "${goal.name}" stopped: ${reason}. Worker aborted, status: budget_limited. Resume with resume_goal to continue spending.`);
+    }
+    return true;
+  }
   async function maintenance() {
     syncWorkerSessionsFromService();
     if (knownWorkerSessions.size === 0)
@@ -1508,6 +1620,11 @@ function createLoopEngine(options) {
       const runtime = state.runtimes.find((r) => r.goalID === goal.id);
       if (!runtime)
         continue;
+      if (goal.workerSessionID) {
+        const stopped = await accountAndEnforceBudget(goal);
+        if (stopped)
+          continue;
+      }
       if (runtime.phase === "waiting_retry" && runtime.retryAfter) {
         if (Date.now() >= Date.parse(runtime.retryAfter)) {
           await mutateState(directory, `retry-ready:${goal.id}`, async (s) => {
@@ -1590,6 +1707,87 @@ function createLoopEngine(options) {
           });
           await logServerEvent(directory, "maintenance.worker-recovered", { goalID: goal.id });
         }
+        if (status === "idle" && runtime.phase === "running") {
+          const lastSignal = Math.max(runtime.lastActivityAt ? Date.parse(runtime.lastActivityAt) : 0, runtime.lastRunAt ? Date.parse(runtime.lastRunAt) : 0, runtime.turnStartedAt ? Date.parse(runtime.turnStartedAt) : 0);
+          const quietMs = Date.now() - lastSignal;
+          if (lastSignal > 0 && quietMs > idleRecoverMs) {
+            const generation = runtime.runGeneration;
+            const stalledRunID = runtime.activeRunID;
+            let clearedToolCalls = 0;
+            let recovered = false;
+            const recoveredState = await mutateState(directory, `maintenance.idle-recover:${goal.id}`, async (s) => {
+              const g = s.goals.find((item) => item.id === goal.id);
+              const rt = s.runtimes.find((r) => r.goalID === goal.id);
+              if (!g || !rt || g.status !== "active")
+                return s;
+              if (rt.phase !== "running")
+                return s;
+              if (rt.runGeneration !== generation)
+                return s;
+              clearedToolCalls = rt.activeToolCallIDs?.length ?? 0;
+              Object.assign(rt, releaseLease(rt));
+              rt.activeRunID = undefined;
+              rt.lastWorkerStatus = "idle";
+              rt.idleConfirmFailedAt = undefined;
+              rt.idleConfirmFailedGeneration = undefined;
+              rt.idleStuckNotifiedGeneration = undefined;
+              recovered = true;
+              return s;
+            });
+            if (recovered) {
+              await appendEvent(directory, {
+                version: 1,
+                eventID: randomUUID2(),
+                goalID: goal.id,
+                type: "run.recovered",
+                runID: stalledRunID ?? "unknown",
+                quietSeconds: Math.floor(quietMs / 1000),
+                clearedToolCalls,
+                timestamp: new Date().toISOString(),
+                revision: recoveredState.revision
+              });
+              await logServerEvent(directory, "maintenance.idle-recovered", {
+                goalID: goal.id,
+                generation,
+                quietSeconds: Math.floor(quietMs / 1000),
+                clearedToolCalls
+              });
+              await continueGoal(goal.id);
+              continue;
+            }
+          }
+        }
+        if (status === "idle" && runtime.phase === "running" && runtime.idleConfirmFailedGeneration === runtime.runGeneration && runtime.idleConfirmFailedAt && runtime.idleStuckNotifiedGeneration !== runtime.runGeneration && Date.now() - Date.parse(runtime.idleConfirmFailedAt) > idleUnconfirmedMs) {
+          const failedAt = runtime.idleConfirmFailedAt;
+          const generation = runtime.runGeneration;
+          const stuckState = await mutateState(directory, `maintenance.idle-stuck:${goal.id}`, async (s) => {
+            const rt = s.runtimes.find((r) => r.goalID === goal.id);
+            if (!rt || rt.runGeneration !== generation || rt.phase !== "running")
+              return s;
+            rt.idleStuckNotifiedGeneration = generation;
+            rt.updatedAt = new Date().toISOString();
+            return s;
+          });
+          const stuckSeconds = Math.floor((Date.now() - Date.parse(failedAt)) / 1000);
+          await appendEvent(directory, {
+            version: 1,
+            eventID: randomUUID2(),
+            goalID: goal.id,
+            type: "run.stuck",
+            runID: runtime.activeRunID ?? "unknown",
+            stuckSeconds,
+            timestamp: new Date().toISOString(),
+            revision: stuckState.revision
+          });
+          await logServerEvent(directory, "maintenance.idle-stuck", {
+            goalID: goal.id,
+            generation,
+            stuckSeconds
+          });
+          const quietMinutes = Math.max(1, Math.floor(stuckSeconds / 60));
+          await host.notifyOwner(goal.ownerSessionID, `Loop goal "${goal.name}" worker is idle but its turn will not confirm (unconfirmed for ${quietMinutes}m, no activity). The goal remains active; use inspect_background_goal to look, nudge_goal to re-prompt, or pause_goal to stop it.`);
+          continue;
+        }
         if (status === "idle") {
           if (runtime.phase === "idle") {
             await continueGoal(goal.id);
@@ -1598,6 +1796,37 @@ function createLoopEngine(options) {
           }
           continue;
         }
+        if ((status === "busy" || status === "retry") && runtime.phase === "running" && runtime.activeRunID && runtime.stuckNotifiedRunID !== runtime.activeRunID) {
+          const leaseExpired = !runtime.leaseExpiresAt || Date.now() >= Date.parse(runtime.leaseExpiresAt);
+          const lastActive = runtime.lastActivityAt ? Date.parse(runtime.lastActivityAt) : 0;
+          if (leaseExpired && Date.now() - lastActive > stuckRunningMs) {
+            const stuckSeconds = Math.floor((Date.now() - lastActive) / 1000);
+            const stuckState = await mutateState(directory, `maintenance.run-stuck:${goal.id}`, async (s) => {
+              const rt = s.runtimes.find((r) => r.goalID === goal.id);
+              if (!rt || rt.activeRunID !== runtime.activeRunID)
+                return s;
+              rt.stuckNotifiedRunID = rt.activeRunID;
+              rt.updatedAt = new Date().toISOString();
+              return s;
+            });
+            await appendEvent(directory, {
+              version: 1,
+              eventID: randomUUID2(),
+              goalID: goal.id,
+              type: "run.stuck",
+              runID: runtime.activeRunID,
+              stuckSeconds,
+              timestamp: new Date().toISOString(),
+              revision: stuckState.revision
+            });
+            await logServerEvent(directory, "maintenance.run-stuck", {
+              goalID: goal.id,
+              runID: runtime.activeRunID,
+              stuckSeconds
+            });
+            await host.notifyOwner(goal.ownerSessionID, `Loop goal "${goal.name}" worker may be stuck: no activity for ${Math.floor(stuckSeconds / 60)}m while reporting ${status}, lease expired. The goal remains active; use inspect_background_goal to look, nudge_goal to re-prompt, or pause_goal to stop it.`);
+          }
+        }
       }
     }
   }
@@ -1609,6 +1838,194 @@ import { randomUUID as randomUUID3 } from "crypto";
 import * as path2 from "path";
 import { promises as fs2 } from "fs";
 
+// src/server/host-adapter.ts
+function parseModelRef(value) {
+  if (value === undefined)
+    return;
+  const trimmed = value.trim();
+  if (!trimmed)
+    return;
+  const slash = trimmed.indexOf("/");
+  if (slash <= 0 || slash >= trimmed.length - 1) {
+    throw new Error(`Invalid model "${value}". Use "providerID/modelID" (e.g. "openai/gpt-5.6-sol").`);
+  }
+  const providerID = trimmed.slice(0, slash).trim();
+  const modelID = trimmed.slice(slash + 1).trim();
+  if (!providerID || !modelID || /\s/.test(providerID) || /\s/.test(modelID)) {
+    throw new Error(`Invalid model "${value}". Use "providerID/modelID" (e.g. "openai/gpt-5.6-sol").`);
+  }
+  return { providerID, modelID };
+}
+var recentParentNotifies = new Map;
+function shouldDedupParentNotify(ownerSessionID, message) {
+  const key = `${ownerSessionID}:${message.slice(0, 200)}`;
+  const now = Date.now();
+  const last = recentParentNotifies.get(key);
+  if (last !== undefined && now - last < 60000)
+    return true;
+  recentParentNotifies.set(key, now);
+  if (recentParentNotifies.size > 200) {
+    for (const [k, t] of recentParentNotifies.entries())
+      if (now - t > 60000)
+        recentParentNotifies.delete(k);
+  }
+  return false;
+}
+function createRealHost(client, directory) {
+  return {
+    async createWorker({ parentID, title, agent, model }) {
+      try {
+        const body = { parentID, title };
+        if (agent)
+          body.agent = agent;
+        if (model)
+          body.model = { id: model.modelID, providerID: model.providerID };
+        const result = await withTimeout(client.session.create({ body }), 1e4, "OpenCode session.create");
+        const data = result?.data;
+        if (result?.error || !data?.id) {
+          const detail = describeError(result?.error || "response contained no session ID");
+          await logServerEvent(directory, "worker.create.failed", { parentID, title, detail });
+          throw new Error(`OpenCode session.create failed for parent "${parentID}": ${detail}`);
+        }
+        await logServerEvent(directory, "worker.created", { parentID, workerSessionID: data.id, title });
+        return data.id;
+      } catch (error) {
+        if (error instanceof Error && error.message.startsWith("OpenCode session.create failed"))
+          throw error;
+        const detail = describeError(error);
+        await logServerEvent(directory, "worker.create.failed", { parentID, title, detail });
+        throw new Error(`OpenCode session.create failed for parent "${parentID}": ${detail}`);
+      }
+    },
+    async promptWorker({ sessionID, prompt, messageID, model, agent }) {
+      const body = {
+        parts: [{ type: "text", text: prompt }]
+      };
+      if (messageID) {
+        const collapsed = messageID.replace(/^(msg-)+/, "msg-");
+        body.messageID = collapsed.startsWith("msg-") ? collapsed : `msg-${messageID}`;
+      }
+      if (model)
+        body.model = model;
+      if (agent)
+        body.agent = agent;
+      const result = await withTimeout(client.session.promptAsync({
+        path: { id: sessionID },
+        body
+      }), 1e4, "OpenCode session.promptAsync");
+      if (result?.error) {
+        const detail = describeError(result.error);
+        await logServerEvent(directory, "worker.prompt.failed", { sessionID, detail });
+        throw new Error(`OpenCode session.promptAsync failed for worker "${sessionID}": ${detail}`);
+      }
+      await logServerEvent(directory, "worker.prompted", { sessionID });
+      return { messageID: result?.data?.messageID };
+    },
+    async sessionStatus(sessionID) {
+      try {
+        const result = await client.session.status({});
+        if (result?.error)
+          return "unknown";
+        const data = result?.data;
+        if (!data || typeof data !== "object" || Array.isArray(data))
+          return "unknown";
+        const status = data[sessionID];
+        if (status === undefined || status === null)
+          return "idle";
+        if (typeof status !== "object" || Array.isArray(status))
+          return "unknown";
+        const type = status.type;
+        if (type === "busy" || type === "retry")
+          return type;
+        if (type === "idle")
+          return "idle";
+        return "unknown";
+      } catch {
+        return "unknown";
+      }
+    },
+    async abortSession(sessionID) {
+      try {
+        await client.session.abort({ path: { id: sessionID } });
+      } catch {}
+    },
+    async readMessages(sessionID, limit = 10) {
+      try {
+        const result = await client.session.messages({
+          path: { id: sessionID },
+          query: { limit }
+        });
+        const data = result?.data;
+        if (!Array.isArray(data))
+          return [];
+        return data.map((m) => {
+          const createdMs = m.info?.time?.created;
+          const completedMs = m.info?.time?.completed;
+          const tokens = m.info?.tokens;
+          return {
+            role: m.info?.role || "assistant",
+            content: m.parts?.filter((p) => p.type === "text").map((p) => p.text).join(`
+`) || "",
+            timestamp: completedMs || createdMs ? new Date(completedMs || createdMs).toISOString() : undefined,
+            messageID: m.info?.id || m.id,
+            parentMessageID: m.info?.parentID,
+            completedAt: completedMs ? new Date(completedMs).toISOString() : undefined,
+            tokens: tokens && typeof tokens.input === "number" ? {
+              input: tokens.input || 0,
+              output: tokens.output || 0,
+              reasoning: tokens.reasoning || 0,
+              cacheRead: tokens.cache?.read || 0,
+              cacheWrite: tokens.cache?.write || 0
+            } : undefined,
+            cost: typeof m.info?.cost === "number" ? m.info.cost : undefined,
+            durationMs: typeof createdMs === "number" && typeof completedMs === "number" && completedMs >= createdMs ? completedMs - createdMs : undefined
+          };
+        });
+      } catch {
+        return [];
+      }
+    },
+    async compactSession(sessionID) {
+      try {
+        await client.session.compact({ sessionID });
+      } catch {}
+    },
+    async notifyOwner(ownerSessionID, message) {
+      if (shouldDedupParentNotify(ownerSessionID, message)) {
+        await logServerEvent(directory, "parent.notify.deduped", { ownerSessionID, preview: message.slice(0, 160) });
+        return;
+      }
+      try {
+        const result = await withTimeout(client.session.promptAsync({
+          path: { id: ownerSessionID },
+          body: { parts: [{ type: "text", text: message }] }
+        }), 1e4, "OpenCode parent notify");
+        if (result?.error) {
+          await logServerEvent(directory, "parent.notify.failed", { ownerSessionID, detail: describeError(result.error) });
+        } else {
+          await logServerEvent(directory, "parent.notified", { ownerSessionID, preview: message.slice(0, 160) });
+        }
+      } catch (error) {
+        await logServerEvent(directory, "parent.notify.failed", { ownerSessionID, detail: describeError(error) });
+      }
+    }
+  };
+}
+async function withTimeout(promise, timeoutMs, operation) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`${operation} timed out after ${timeoutMs}ms`)), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
+
 // src/server/worker-session.ts
 function createWorkerManager(host) {
   return {
@@ -1616,7 +2033,8 @@ function createWorkerManager(host) {
       const workerSessionID = await host.createWorker({
         parentID: goal.ownerSessionID,
         title: `loopd: ${goal.name}`,
-        agent: goal.config.agent
+        agent: goal.config.agent,
+        model: parseModelRef(goal.config.model)
       });
       return {
         goalID: goal.id,
@@ -1630,7 +2048,8 @@ function createWorkerManager(host) {
         sessionID: worker.workerSessionID,
         prompt,
         messageID: runtime.activePromptMessageID,
-        agent: goal.config.agent
+        agent: goal.config.agent,
+        model: parseModelRef(goal.config.model)
       });
       return result;
     },
@@ -1864,6 +2283,8 @@ function createGoalService(host) {
         ...input.config
       }
     });
+    if (typeof input.costBudget === "number")
+      goal.costBudget = input.costBudget;
     const artifactDir = goalArtifactDir(directory, id);
     goal.config.artifactDir = artifactDir;
     if (!goal.config.progressFile)
@@ -1879,9 +2300,9 @@ function createGoalService(host) {
         rt.lastScheduleAt = undefined;
       }
       state.runtimes.push(rt);
-      const runtime2 = state.runtimes.find((r) => r.goalID === id);
-      if (runtime2)
-        runtime2.phase = "queued";
+      const runtime = state.runtimes.find((r) => r.goalID === id);
+      if (runtime)
+        runtime.phase = "queued";
       return state;
     });
     let runtime = state1.runtimes.find((r) => r.goalID === id);
@@ -1972,6 +2393,63 @@ function createGoalService(host) {
     }
     return { goal, worker };
   }
+  async function accountTailUsage(directory, goalID, runtime, tail) {
+    const seenIDs = new Set(runtime.accountedMessageIDs ?? []);
+    let tokenDelta = 0;
+    let costDelta = 0;
+    let timeDeltaSeconds = 0;
+    const counted = [];
+    for (const m of tail) {
+      if (m.role !== "assistant" || !m.messageID || !m.completedAt)
+        continue;
+      if (seenIDs.has(m.messageID))
+        continue;
+      seenIDs.add(m.messageID);
+      counted.push(m.messageID);
+      if (m.tokens) {
+        tokenDelta += (m.tokens.input || 0) + (m.tokens.output || 0) + (m.tokens.reasoning || 0) + (m.tokens.cacheRead || 0) + (m.tokens.cacheWrite || 0);
+      }
+      if (typeof m.cost === "number")
+        costDelta += m.cost;
+      if (typeof m.durationMs === "number")
+        timeDeltaSeconds += m.durationMs / 1000;
+    }
+    if (counted.length === 0)
+      return { tokenDelta: 0, costDelta: 0, timeDeltaSeconds: 0, counted };
+    const mergedWatermark = [...runtime.accountedMessageIDs ?? [], ...counted].slice(-200);
+    await mutateState(directory, `turn.account-usage:${goalID}`, async (s) => {
+      const g = s.goals.find((item) => item.id === goalID);
+      if (g) {
+        g.tokensUsed += tokenDelta;
+        g.costUsed = (g.costUsed ?? 0) + costDelta;
+        g.timeUsedSeconds += timeDeltaSeconds;
+        g.updatedAt = new Date().toISOString();
+      }
+      const rt = s.runtimes.find((item) => item.goalID === goalID);
+      if (rt) {
+        rt.turnTokensUsed = (rt.turnTokensUsed ?? 0) + tokenDelta;
+        rt.accountedMessageIDs = mergedWatermark;
+        rt.updatedAt = new Date().toISOString();
+      }
+      return s;
+    });
+    return { tokenDelta, costDelta, timeDeltaSeconds, counted };
+  }
+  async function accountUsageUnlocked(directory, goalID) {
+    const preState = await readState(directory);
+    const goal = preState.goals.find((g) => g.id === goalID);
+    const runtime = preState.runtimes.find((r) => r.goalID === goalID);
+    if (!goal?.workerSessionID || !runtime) {
+      return { tokenDelta: 0, costDelta: 0, timeDeltaSeconds: 0, counted: [] };
+    }
+    let tail = [];
+    try {
+      tail = await host.readMessages(goal.workerSessionID, 50);
+    } catch {
+      return { tokenDelta: 0, costDelta: 0, timeDeltaSeconds: 0, counted: [] };
+    }
+    return accountTailUsage(directory, goalID, runtime, tail);
+  }
   async function continueTurnUnlocked(directory, goalID, opts) {
     const preState = await readState(directory);
     const goal = preState.goals.find((g) => g.id === goalID);
@@ -2046,6 +2524,7 @@ function createGoalService(host) {
     } catch {
       transcriptTail = [];
     }
+    await accountTailUsage(directory, goalID, freshRuntime, transcriptTail ?? []);
     let verification;
     try {
       const artifactDir = freshGoal.config.artifactDir;
@@ -2122,17 +2601,17 @@ function createGoalService(host) {
   }
   async function resumeUnlocked(directory, goalID) {
     let resumed = false;
-    const state = await mutateState(directory, `goal.resume:${goalID}`, async (state2) => {
-      const goal2 = state2.goals.find((g) => g.id === goalID);
-      if (!goal2)
-        return state2;
-      if (!canTransition(goal2.status, "active", "user"))
-        return state2;
-      assertWorkspaceWriteAvailable(state2, goal2);
-      goal2.status = "active";
-      goal2.updatedAt = new Date().toISOString();
+    const state = await mutateState(directory, `goal.resume:${goalID}`, async (state) => {
+      const goal = state.goals.find((g) => g.id === goalID);
+      if (!goal)
+        return state;
+      if (!canTransition(goal.status, "active", "user"))
+        return state;
+      assertWorkspaceWriteAvailable(state, goal);
+      goal.status = "active";
+      goal.updatedAt = new Date().toISOString();
       resumed = true;
-      return state2;
+      return state;
     });
     const goal = state.goals.find((g) => g.id === goalID);
     if (!goal || !resumed)
@@ -2162,15 +2641,15 @@ function createGoalService(host) {
   }
   async function retryUnlocked(directory, goalID) {
     let retried = false;
-    const state = await mutateState(directory, `goal.retry:${goalID}`, async (state2) => {
-      const goal2 = state2.goals.find((g) => g.id === goalID);
-      if (!goal2 || goal2.status !== "blocked")
-        return state2;
-      assertWorkspaceWriteAvailable(state2, goal2);
-      goal2.status = "active";
-      goal2.updatedAt = new Date().toISOString();
+    const state = await mutateState(directory, `goal.retry:${goalID}`, async (state) => {
+      const goal = state.goals.find((g) => g.id === goalID);
+      if (!goal || goal.status !== "blocked")
+        return state;
+      assertWorkspaceWriteAvailable(state, goal);
+      goal.status = "active";
+      goal.updatedAt = new Date().toISOString();
       retried = true;
-      const runtime = state2.runtimes.find((r) => r.goalID === goalID);
+      const runtime = state.runtimes.find((r) => r.goalID === goalID);
       if (runtime) {
         runtime.consecutiveFailures = 0;
         runtime.lastError = undefined;
@@ -2180,7 +2659,7 @@ function createGoalService(host) {
         runtime.phase = "idle";
         runtime.updatedAt = new Date().toISOString();
       }
-      return state2;
+      return state;
     });
     const goal = state.goals.find((g) => g.id === goalID);
     if (!goal || !retried)
@@ -2357,7 +2836,10 @@ function createGoalService(host) {
   function nudge(directory, goalID) {
     return withGoalOperation(goalID, () => nudgeUnlocked(directory, goalID));
   }
-  return { start, continueTurn, nudge, pause, resume, retry, clear, getWorker, getActiveWorkers, reconcile };
+  function accountUsage(directory, goalID) {
+    return withGoalOperation(goalID, () => accountUsageUnlocked(directory, goalID));
+  }
+  return { start, continueTurn, nudge, pause, resume, retry, clear, getWorker, getActiveWorkers, reconcile, accountUsage };
 }
 
 // src/application/schedule-worker.ts
@@ -2474,155 +2956,6 @@ function createScheduleWorker(options) {
   return { start, stop, isRunning, tick };
 }
 
-// src/server/host-adapter.ts
-var recentParentNotifies = new Map;
-function shouldDedupParentNotify(ownerSessionID, message) {
-  const key = `${ownerSessionID}:${message.slice(0, 200)}`;
-  const now = Date.now();
-  const last = recentParentNotifies.get(key);
-  if (last !== undefined && now - last < 60000)
-    return true;
-  recentParentNotifies.set(key, now);
-  if (recentParentNotifies.size > 200) {
-    for (const [k, t] of recentParentNotifies.entries())
-      if (now - t > 60000)
-        recentParentNotifies.delete(k);
-  }
-  return false;
-}
-function createRealHost(client, directory) {
-  return {
-    async createWorker({ parentID, title, agent }) {
-      try {
-        const body = { parentID, title };
-        if (agent)
-          body.agent = agent;
-        const result = await withTimeout(client.session.create({ body }), 1e4, "OpenCode session.create");
-        const data = result?.data;
-        if (result?.error || !data?.id) {
-          const detail = describeError(result?.error || "response contained no session ID");
-          await logServerEvent(directory, "worker.create.failed", { parentID, title, detail });
-          throw new Error(`OpenCode session.create failed for parent "${parentID}": ${detail}`);
-        }
-        await logServerEvent(directory, "worker.created", { parentID, workerSessionID: data.id, title });
-        return data.id;
-      } catch (error) {
-        if (error instanceof Error && error.message.startsWith("OpenCode session.create failed"))
-          throw error;
-        const detail = describeError(error);
-        await logServerEvent(directory, "worker.create.failed", { parentID, title, detail });
-        throw new Error(`OpenCode session.create failed for parent "${parentID}": ${detail}`);
-      }
-    },
-    async promptWorker({ sessionID, prompt, messageID, model, agent }) {
-      const body = {
-        parts: [{ type: "text", text: prompt }]
-      };
-      if (messageID) {
-        const collapsed = messageID.replace(/^(msg-)+/, "msg-");
-        body.messageID = collapsed.startsWith("msg-") ? collapsed : `msg-${messageID}`;
-      }
-      if (model)
-        body.model = model;
-      if (agent)
-        body.agent = agent;
-      const result = await withTimeout(client.session.promptAsync({
-        path: { id: sessionID },
-        body
-      }), 1e4, "OpenCode session.promptAsync");
-      if (result?.error) {
-        const detail = describeError(result.error);
-        await logServerEvent(directory, "worker.prompt.failed", { sessionID, detail });
-        throw new Error(`OpenCode session.promptAsync failed for worker "${sessionID}": ${detail}`);
-      }
-      await logServerEvent(directory, "worker.prompted", { sessionID });
-      return { messageID: result?.data?.messageID };
-    },
-    async sessionStatus(sessionID) {
-      try {
-        const result = await client.session.status({});
-        const data = result?.data;
-        if (!data || typeof data !== "object")
-          return "unknown";
-        const status = data[sessionID];
-        if (!status || typeof status !== "object")
-          return "unknown";
-        const type = status.type;
-        if (type === "busy" || type === "retry")
-          return type;
-        return "idle";
-      } catch {
-        return "unknown";
-      }
-    },
-    async abortSession(sessionID) {
-      try {
-        await client.session.abort({ path: { id: sessionID } });
-      } catch {}
-    },
-    async readMessages(sessionID, limit = 10) {
-      try {
-        const result = await client.session.messages({
-          path: { id: sessionID },
-          query: { limit }
-        });
-        const data = result?.data;
-        if (!Array.isArray(data))
-          return [];
-        return data.map((m) => ({
-          role: m.info?.role || "assistant",
-          content: m.parts?.filter((p) => p.type === "text").map((p) => p.text).join(`
-`) || "",
-          timestamp: m.info?.time?.completed || m.info?.time?.created ? new Date(m.info.time.completed || m.info.time.created).toISOString() : undefined,
-          messageID: m.info?.id || m.id,
-          parentMessageID: m.info?.parentID,
-          completedAt: m.info?.time?.completed ? new Date(m.info.time.completed).toISOString() : undefined
-        }));
-      } catch {
-        return [];
-      }
-    },
-    async compactSession(sessionID) {
-      try {
-        await client.session.compact({ sessionID });
-      } catch {}
-    },
-    async notifyOwner(ownerSessionID, message) {
-      if (shouldDedupParentNotify(ownerSessionID, message)) {
-        await logServerEvent(directory, "parent.notify.deduped", { ownerSessionID, preview: message.slice(0, 160) });
-        return;
-      }
-      try {
-        const result = await withTimeout(client.session.promptAsync({
-          path: { id: ownerSessionID },
-          body: { parts: [{ type: "text", text: message }] }
-        }), 1e4, "OpenCode parent notify");
-        if (result?.error) {
-          await logServerEvent(directory, "parent.notify.failed", { ownerSessionID, detail: describeError(result.error) });
-        } else {
-          await logServerEvent(directory, "parent.notified", { ownerSessionID, preview: message.slice(0, 160) });
-        }
-      } catch (error) {
-        await logServerEvent(directory, "parent.notify.failed", { ownerSessionID, detail: describeError(error) });
-      }
-    }
-  };
-}
-async function withTimeout(promise, timeoutMs, operation) {
-  let timer;
-  try {
-    return await Promise.race([
-      promise,
-      new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new Error(`${operation} timed out after ${timeoutMs}ms`)), timeoutMs);
-      })
-    ]);
-  } finally {
-    if (timer)
-      clearTimeout(timer);
-  }
-}
-
 // src/server/goal-tools.ts
 import { randomUUID as randomUUID5 } from "crypto";
 import { tool } from "@opencode-ai/plugin/tool";
@@ -2643,11 +2976,13 @@ var execAsync = promisify(execChild);
 function goalTools(dir, goalService, hostSessionID, defaults = {}) {
   return {
     loopd_create_goal: tool({
-      description: "Create a new background loop goal (contract: objective + checks + agent + workspaceWrite). " + "The engine spawns a dedicated worker session that does the work autonomously \u2014 it never runs in this chat. " + "Call this after clarifying the contract with the user. " + "Host is the acceptance authority: checks must pass for complete_goal (free retry if rejected <3, blocked after 3). " + "Workspace-writing goals are serialized (only one active writer) and require checks. " + "agent is optional \u2014 uses the parent session's agent if omitted, or configure plugin defaultAgent in opencode.jsonc.",
+      description: "Create a new background loop goal (contract: objective + checks + agent/model + workspaceWrite). " + "The engine spawns a dedicated worker session that does the work autonomously \u2014 it never runs in this chat. " + "Call this after clarifying the contract with the user. " + "Worker identity is free-form: agent is any OpenCode agent name (built-in, ~/.config/opencode/agents/*.md, or opencode.jsonc agent.* \u2014 discover with `opencode agent list`), " + 'model is any "providerID/modelID" (discover with `opencode models [provider]`). Both are sent on every worker prompt. ' + "Host is the acceptance authority: checks must pass for complete_goal (free retry if rejected <3, blocked after 3). " + "Workspace-writing goals are serialized (only one active writer) and require checks. " + "agent/model are optional \u2014 fall back to the parent session's agent/model, or plugin defaultAgent/defaultModel in opencode.jsonc.",
       args: {
         name: tool.schema.string().describe("Short goal name (used in the dashboard)."),
         objective: tool.schema.string().describe("What the goal should accomplish, in detail."),
-        agent: tool.schema.string().optional().describe("Agent to run the worker as. Optional \u2014 uses parent session's agent if omitted, or configure plugin defaultAgent in opencode.jsonc."),
+        agent: tool.schema.string().optional().describe(`Agent to run the worker as (e.g. "researcher", "smart-agent"). Optional \u2014 uses parent session's agent if omitted, or plugin defaultAgent.`),
+        model: tool.schema.string().optional().describe(`Model to run the worker as, as "providerID/modelID" (e.g. "openai/gpt-5.6-sol", "ollama/qwen3.8:27b"). Optional \u2014 uses parent session's model if omitted, or plugin defaultModel.`),
+        costBudget: tool.schema.number().optional().describe("Max provider cost in dollars before the engine stops the goal as budget_limited (e.g. 0.5). Optional \u2014 unlimited if omitted."),
         checks: tool.schema.array(tool.schema.string()).optional().describe('Shell commands that must pass for completion to be accepted. E.g. ["npm test"].'),
         checkCwd: tool.schema.string().optional().describe("Directory where completion checks run. Workspace-writing goals default to the project root."),
         workspaceWrite: tool.schema.boolean().optional().describe("Whether this goal edits the shared project workspace. Defaults to true; explicitly set false for artifact-only/read-only work."),
@@ -2676,6 +3011,8 @@ function goalTools(dir, goalService, hostSessionID, defaults = {}) {
         };
         if (args.agent)
           config.agent = args.agent;
+        if (args.model)
+          config.model = args.model;
         if (args.checks)
           config.checks = args.checks;
         if (args.checkCwd)
@@ -2716,6 +3053,16 @@ function goalTools(dir, goalService, hostSessionID, defaults = {}) {
             output: JSON.stringify({ ok: false, message: "scheduleMaxRuns requires scheduleEveryMs", errorCode: "invalid_schedule" })
           };
         }
+        let costBudget;
+        if (args.costBudget !== undefined) {
+          if (typeof args.costBudget !== "number" || !Number.isFinite(args.costBudget) || args.costBudget <= 0) {
+            return {
+              title: "Goal not created",
+              output: JSON.stringify({ ok: false, message: "costBudget must be a positive number of dollars", errorCode: "invalid_cost_budget" })
+            };
+          }
+          costBudget = args.costBudget;
+        }
         const resolution = resolveGoalCreationConfig({
           directory: dir,
           objective: args.objective,
@@ -2737,7 +3084,8 @@ function goalTools(dir, goalService, hostSessionID, defaults = {}) {
             name: args.name,
             objective: args.objective,
             ownerSessionID: sessionID,
-            config: resolution.config
+            config: resolution.config,
+            costBudget
           });
           return {
             title: "Goal created",
@@ -2747,6 +3095,8 @@ function goalTools(dir, goalService, hostSessionID, defaults = {}) {
               workerSessionID: worker.workerSessionID,
               artifactDir: goal.config.artifactDir,
               agent: resolution.config.agent,
+              model: resolution.config.model,
+              costBudget: goal.costBudget,
               checks: resolution.config.checks || [],
               workspaceWrite: resolution.config.workspaceWrite,
               defaultsApplied: resolution.defaultsApplied,
@@ -2861,9 +3211,9 @@ function goalTools(dir, goalService, hostSessionID, defaults = {}) {
           const cwd = goal.config.checkCwd || goal.config.artifactDir || dir;
           const checkResults = await runCompletionChecks(goal.config.checks, cwd);
           if (!checkResults.passed) {
-            const runtime2 = state.runtimes.find((r) => r.goalID === goal.id);
-            if (runtime2) {
-              runtime2.evaluatorRejectionCount = (runtime2.evaluatorRejectionCount || 0) + 1;
+            const runtime = state.runtimes.find((r) => r.goalID === goal.id);
+            if (runtime) {
+              runtime.evaluatorRejectionCount = (runtime.evaluatorRejectionCount || 0) + 1;
               const failureDetails = checkResults.failures.map((f) => {
                 const stdoutSnippet = f.stdout ? `
 Stdout: ${f.stdout.slice(0, 500)}` : "";
@@ -2874,7 +3224,7 @@ Exit code: ${f.exitCode}${stdoutSnippet}${stderrSnippet}`;
               }).join(`
 
 `);
-              runtime2.lastRejectionDetails = `Rejection #${runtime2.evaluatorRejectionCount} at ${new Date().toISOString()}
+              runtime.lastRejectionDetails = `Rejection #${runtime.evaluatorRejectionCount} at ${new Date().toISOString()}
 
 Working directory: ${cwd}
 
@@ -2882,8 +3232,8 @@ ${failureDetails}`;
               const attemptID = randomUUID5();
               const verificationAttempt = {
                 id: attemptID,
-                sequence: runtime2.evaluatorRejectionCount,
-                runGeneration: runtime2.runGeneration,
+                sequence: runtime.evaluatorRejectionCount,
+                runGeneration: runtime.runGeneration,
                 claimedSummary: args.summary,
                 claimedEvidence: args.evidence,
                 startedAt: new Date().toISOString(),
@@ -2897,15 +3247,15 @@ ${failureDetails}`;
                   stdout: f.stdout
                 }))
               };
-              runtime2.lastVerificationAttempt = verificationAttempt;
-              runtime2.recentVerificationAttempts = appendVerificationAttempt(runtime2.recentVerificationAttempts || [], verificationAttempt);
+              runtime.lastVerificationAttempt = verificationAttempt;
+              runtime.recentVerificationAttempts = appendVerificationAttempt(runtime.recentVerificationAttempts || [], verificationAttempt);
               const rejectEvent = {
                 version: 1,
                 eventID: randomUUID5(),
                 goalID: goal.id,
                 type: "goal.completion_rejected",
                 attemptID,
-                rejectionCount: runtime2.evaluatorRejectionCount,
+                rejectionCount: runtime.evaluatorRejectionCount,
                 failedCheckCount: checkResults.failures.length,
                 failureSummary: failureDetails.slice(0, 500),
                 timestamp: new Date().toISOString(),
@@ -2913,16 +3263,16 @@ ${failureDetails}`;
               };
               await appendEvent(dir, rejectEvent);
               const maxRejections = goal.config.maxEvaluatorRejections || 3;
-              if (runtime2.evaluatorRejectionCount >= maxRejections) {
+              if (runtime.evaluatorRejectionCount >= maxRejections) {
                 goal.status = "blocked";
                 goal.updatedAt = new Date().toISOString();
                 goal.blocker = {
-                  reason: `Evaluator rejected ${runtime2.evaluatorRejectionCount} time(s). Last failure:
+                  reason: `Evaluator rejected ${runtime.evaluatorRejectionCount} time(s). Last failure:
 ${failureDetails.slice(0, 500)}`,
                   needed: "Fix the failing checks and retry the goal.",
                   at: new Date().toISOString()
                 };
-                runtime2.forceFinishRequested = undefined;
+                runtime.forceFinishRequested = undefined;
                 await appendEvent(dir, {
                   version: 1,
                   eventID: randomUUID5(),
@@ -2934,10 +3284,10 @@ ${failureDetails.slice(0, 500)}`,
                   revision: state.revision
                 });
               } else {
-                runtime2.forceFinishRequested = false;
-                runtime2.freeRetryPending = true;
+                runtime.forceFinishRequested = false;
+                runtime.freeRetryPending = true;
               }
-              runtime2.updatedAt = new Date().toISOString();
+              runtime.updatedAt = new Date().toISOString();
               await writeState(dir, state);
             }
             return {
@@ -2946,7 +3296,7 @@ ${failureDetails.slice(0, 500)}`,
                 passed: false,
                 failedChecks: checkResults.failures,
                 message: "Evaluator rejected completion. Fix the issues above and try again.",
-                rejectionCount: runtime2?.evaluatorRejectionCount || 0,
+                rejectionCount: runtime?.evaluatorRejectionCount || 0,
                 status: goal.status
               })
             };
@@ -2959,11 +3309,17 @@ ${failureDetails.slice(0, 500)}`,
           evidence: args.evidence,
           at: new Date().toISOString()
         };
+        const finalUsage = await goalService.accountUsage(dir, goal.id);
+        goal.tokensUsed += finalUsage.tokenDelta;
+        goal.costUsed = (goal.costUsed ?? 0) + finalUsage.costDelta;
+        goal.timeUsedSeconds += finalUsage.timeDeltaSeconds;
         const runtime = state.runtimes.find((r) => r.goalID === goal.id);
         if (runtime) {
           Object.assign(runtime, releaseLease(runtime));
           runtime.activeRunID = undefined;
           runtime.lastError = undefined;
+          runtime.turnTokensUsed = (runtime.turnTokensUsed ?? 0) + finalUsage.tokenDelta;
+          runtime.accountedMessageIDs = [...runtime.accountedMessageIDs ?? [], ...finalUsage.counted].slice(-200);
           runtime.updatedAt = new Date().toISOString();
           const schedule = goal.config.schedule;
           if (schedule && typeof schedule.everyMs === "number" && schedule.everyMs >= 1000) {
@@ -3048,11 +3404,17 @@ ${failureDetails.slice(0, 500)}`,
           needed: args.needed,
           at: new Date().toISOString()
         };
+        const finalUsage = await goalService.accountUsage(dir, goal.id);
+        goal.tokensUsed += finalUsage.tokenDelta;
+        goal.costUsed = (goal.costUsed ?? 0) + finalUsage.costDelta;
+        goal.timeUsedSeconds += finalUsage.timeDeltaSeconds;
         const runtime = state.runtimes.find((r) => r.goalID === goal.id);
         if (runtime) {
           Object.assign(runtime, releaseLease(runtime));
           runtime.activeRunID = undefined;
           runtime.lastError = undefined;
+          runtime.turnTokensUsed = (runtime.turnTokensUsed ?? 0) + finalUsage.tokenDelta;
+          runtime.accountedMessageIDs = [...runtime.accountedMessageIDs ?? [], ...finalUsage.counted].slice(-200);
           runtime.updatedAt = new Date().toISOString();
         }
         await writeState(dir, state);
@@ -3102,6 +3464,7 @@ function formatGoalStructured(goal, runtime) {
       checkCwd: goal.config.checkCwd,
       workspaceWrite: goal.config.workspaceWrite,
       agent: goal.config.agent,
+      model: goal.config.model,
       maxTurns: goal.config.maxTurns,
       maxNoProgress: goal.config.maxNoProgress,
       maxFailures: goal.config.maxFailures,
@@ -3113,6 +3476,9 @@ function formatGoalStructured(goal, runtime) {
     completionEvidence: goal.completionEvidence,
     blocker: goal.blocker,
     tokensUsed: goal.tokensUsed,
+    tokenBudget: goal.tokenBudget,
+    costUsed: goal.costUsed ?? 0,
+    costBudget: goal.costBudget,
     timeUsedSeconds: goal.timeUsedSeconds
   };
   if (runtime) {
@@ -3212,6 +3578,8 @@ function ownerTools(options) {
             turn: runtime?.runCount ?? 0,
             budgetTurnCount: runtime?.budgetTurnCount ?? 0,
             maxTurns: g.config.maxTurns,
+            agent: g.config.agent,
+            model: g.config.model,
             lastProgress: g.lastProgress?.summary?.slice(0, 120),
             lastProgressAt: g.lastProgress?.at,
             blocker: g.blocker?.reason?.slice(0, 120),
@@ -3232,7 +3600,7 @@ function ownerTools(options) {
       }
     }),
     inspect_background_goal: tool2({
-      description: "Inspect a goal\u2019s full contract, runtime, and live execution state: objective, config{agent,checks,checkCwd,workspaceWrite,limits}, progress, blocker, runtime{phase,runCount,budgetTurnCount,runGeneration,evaluatorRejectionCount,unknownStatusCount,lastActivityAt,activePromptMessageID}, plus live transcriptTail, activeToolCallIDs, progressHistory, artifactSummary, pendingInbox. Single-call follow-up for parent to see what child is actually doing.",
+      description: "Inspect a goal\u2019s full contract, runtime, and live execution state: objective, config{agent,model,checks,checkCwd,workspaceWrite,limits}, progress, blocker, runtime{phase,runCount,budgetTurnCount,runGeneration,evaluatorRejectionCount,unknownStatusCount,lastActivityAt,activePromptMessageID}, plus live transcriptTail, activeToolCallIDs, progressHistory, artifactSummary, pendingInbox. Single-call follow-up for parent to see what child is actually doing.",
       args: {
         goal_id: tool2.schema.string().optional().describe("Goal ID. Omit to inspect the first active goal."),
         includeTranscript: tool2.schema.boolean().optional().describe("Include live transcript tail (adds ~100ms). Default true. Set false for fast metadata-only."),
@@ -3287,12 +3655,16 @@ function ownerTools(options) {
               checkCwd: goal.config.checkCwd,
               workspaceWrite: goal.config.workspaceWrite,
               agent: goal.config.agent,
+              model: goal.config.model,
               schedule: goal.config.schedule
             },
             lastProgress: goal.lastProgress,
             completionEvidence: goal.completionEvidence,
             blocker: goal.blocker,
             tokensUsed: goal.tokensUsed,
+            tokenBudget: goal.tokenBudget,
+            costUsed: goal.costUsed ?? 0,
+            costBudget: goal.costBudget,
             timeUsedSeconds: goal.timeUsedSeconds,
             progressHistory,
             pendingInbox,
@@ -3637,8 +4009,8 @@ var server = async ({ client, directory }, pluginOptions) => {
     "tool.execute.before": async (input, _output) => {
       const activeWorkers = goalService.getActiveWorkers();
       let matchedGoalID;
-      for (const [goalID, worker2] of activeWorkers) {
-        if (worker2.workerSessionID === input.sessionID) {
+      for (const [goalID, worker] of activeWorkers) {
+        if (worker.workerSessionID === input.sessionID) {
           matchedGoalID = goalID;
           break;
         }
@@ -3661,8 +4033,8 @@ var server = async ({ client, directory }, pluginOptions) => {
       }
       const activeWorkers = goalService.getActiveWorkers();
       let matchedGoalID;
-      for (const [goalID, worker2] of activeWorkers) {
-        if (worker2.workerSessionID === input.sessionID) {
+      for (const [goalID, worker] of activeWorkers) {
+        if (worker.workerSessionID === input.sessionID) {
           matchedGoalID = goalID;
           break;
         }
@@ -3688,20 +4060,20 @@ var server = async ({ client, directory }, pluginOptions) => {
           const goalID = parsed.goalID;
           if (!goalID)
             return;
-          const { shouldNotifyParent: shouldNotifyParent2, markParentNotified: markParentNotified2 } = await Promise.resolve().then(() => exports_runtime);
+          await Promise.resolve();
           const state = await readState(directory);
           const goal = state.goals.find((g) => g.id === goalID);
           if (!goal)
             return;
           const runtime = state.runtimes.find((r) => r.goalID === goalID);
           const notifyType = parsed.status === "complete" ? "complete" : "blocked";
-          if (runtime && !shouldNotifyParent2(runtime, notifyType))
+          if (runtime && !shouldNotifyParent(runtime, notifyType))
             return;
           if (runtime) {
             await mutateState(directory, `notify-parent:${goalID}`, async (s) => {
               const rt = s.runtimes.find((r) => r.goalID === goalID);
               if (rt)
-                markParentNotified2(rt, notifyType);
+                markParentNotified(rt, notifyType);
               return s;
             });
           }
@@ -3719,9 +4091,11 @@ var server = async ({ client, directory }, pluginOptions) => {
 };
 function parsePluginDefaults(options) {
   const agent = typeof options?.defaultAgent === "string" ? options.defaultAgent.trim() : "";
+  const model = typeof options?.defaultModel === "string" ? options.defaultModel.trim() : "";
   const checks = Array.isArray(options?.defaultChecks) ? options.defaultChecks.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean) : [];
   return {
     defaultAgent: agent || undefined,
+    defaultModel: model || undefined,
     defaultChecks: checks.length > 0 ? checks : undefined
   };
 }