@bojackduy/opencode-loopd 1.8.3 → 1.9.2

package/dist/server.js

@@ -11,6 +11,7 @@ function createRuntimeState(goalID) {
     noProgressCount: 0,
     progressDuringTurn: false,
     unknownStatusCount: 0,
+    accountedMessageIDs: [],
     runGeneration: 0,
     createdAt: now,
     updatedAt: now
@@ -30,6 +31,10 @@ function acquireLease(rt, timeoutMs) {
     lastActivityAt: new Date(now).toISOString(),
     idleCandidateAt: undefined,
     idleCandidateGeneration: undefined,
+    idleConfirmFailedAt: undefined,
+    idleConfirmFailedGeneration: undefined,
+    idleStuckNotifiedGeneration: undefined,
+    workerAbortedAt: undefined,
     activePromptObservedAt: undefined,
     activeAssistantMessageID: undefined,
     activeAssistantCompletedAt: undefined,
@@ -479,6 +484,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"]) : [];
@@ -495,16 +510,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;
@@ -567,12 +596,17 @@ function createControlWorker(options) {
     if (running)
       return;
     running = true;
-    processPending();
+    processPending().catch((error) => {
+      logServerEvent(directory, "control.worker.error", { detail: describeError(error) }).catch(() => {});
+    });
     pollTimer = setInterval(() => {
       if (running && lastProcessDone) {
         lastProcessDone = false;
         processPending().then(() => {
           lastProcessDone = true;
+        }, (error) => {
+          lastProcessDone = true;
+          logServerEvent(directory, "control.worker.error", { detail: describeError(error) }).catch(() => {});
         });
       }
     }, pollMs);
@@ -721,6 +755,21 @@ function createControlWorker(options) {
         };
         break;
       }
+      case "nudge": {
+        if (!request.goalID) {
+          response = { ...base, ok: false, message: "goalID is required", errorCode: "bad_request" };
+          break;
+        }
+        const result = await goalSvc.nudge(directory, request.goalID);
+        const state = await readState(directory);
+        response = {
+          ...base,
+          ok: result.ok,
+          message: result.message,
+          stateRevision: state.revision
+        };
+        break;
+      }
       case "clear": {
         await goalSvc.clear(directory, request.goalID);
         const state = await readState(directory);
@@ -742,12 +791,27 @@ function createControlWorker(options) {
           response = { ...base, ok: false, message: "goalID is required", errorCode: "bad_request" };
           break;
         }
-        await appendGoalInbox(directory, request.goalID, "user", text);
+        const sent = await goalSvc.sendUserMessage(directory, request.goalID, text);
+        const state = await readState(directory);
+        response = {
+          ...base,
+          ok: sent.ok,
+          message: sent.message,
+          stateRevision: state.revision
+        };
+        break;
+      }
+      case "abort_worker": {
+        if (!request.goalID) {
+          response = { ...base, ok: false, message: "goalID is required", errorCode: "bad_request" };
+          break;
+        }
+        const result = await goalSvc.abortWorker(directory, 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}"`,
+          ok: result.ok,
+          message: result.message,
           stateRevision: state.revision
         };
         break;
@@ -904,7 +968,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;
@@ -921,6 +985,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;
@@ -1044,6 +1111,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;
         }
@@ -1083,7 +1152,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;
@@ -1105,8 +1176,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) => {
@@ -1124,14 +1222,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;
       });
     }
@@ -1174,6 +1277,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)
@@ -1244,7 +1353,7 @@ function createLoopEngine(options) {
       return noMatch;
     let messages;
     try {
-      messages = await host.readMessages(workerSessionID, 50);
+      messages = await host.readMessages(workerSessionID, 200);
     } catch {
       return noMatch;
     }
@@ -1402,6 +1511,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) {
@@ -1440,6 +1559,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)
@@ -1476,6 +1656,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) => {
@@ -1558,6 +1743,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);
@@ -1566,6 +1832,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.`);
+          }
+        }
       }
     }
   }
@@ -1577,6 +1874,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 {
@@ -1584,7 +2069,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,
@@ -1598,7 +2084,18 @@ 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;
+    },
+    async sendBare(worker, goal, runtime, text) {
+      const result = await host.promptWorker({
+        sessionID: worker.workerSessionID,
+        prompt: text,
+        messageID: runtime.activePromptMessageID,
+        agent: goal.config.agent,
+        model: parseModelRef(goal.config.model)
       });
       return result;
     },
@@ -1832,6 +2329,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)
@@ -1940,6 +2439,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);
@@ -2001,6 +2557,20 @@ function createGoalService(host) {
       timestamp: new Date().toISOString(),
       revision: state.revision
     });
+    if (opts?.bare) {
+      const bareWords = await drainGoalInbox(directory, goalID);
+      const bareText = bareWords.join(`
+`).trim();
+      if (bareText) {
+        try {
+          await workers.sendBare(session, freshGoal, freshRuntime, bareText);
+        } catch (error) {
+          await recordPromptFailure(directory, goalID, error);
+          throw error;
+        }
+        return;
+      }
+    }
     const inboxMessages = await drainGoalInbox(directory, goalID);
     const allEvents = await readEvents(directory, 200);
     const progressHistory = allEvents.filter((e) => e.goalID === goalID && e.type === "goal.progress").map((e) => ({
@@ -2014,6 +2584,7 @@ function createGoalService(host) {
     } catch {
       transcriptTail = [];
     }
+    await accountTailUsage(directory, goalID, freshRuntime, transcriptTail ?? []);
     let verification;
     try {
       const artifactDir = freshGoal.config.artifactDir;
@@ -2307,6 +2878,40 @@ function createGoalService(host) {
     await continueTurnUnlocked(directory, goalID, { force: true });
     return { ok: true, message: `Re-prompted worker for "${freshGoal.name}".` };
   }
+  async function sendUnlocked(directory, goalID, text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+      return { ok: false, message: "Nothing to send." };
+    const preState = await readState(directory);
+    const goal = preState.goals.find((g) => g.id === goalID);
+    if (!goal)
+      return { ok: false, message: "Goal not found." };
+    await appendGoalInbox(directory, goalID, "user", trimmed);
+    if (goal.status !== "active") {
+      return { ok: true, message: `Queued for "${goal.name}" (goal is ${goal.status}; delivers on the next active turn).` };
+    }
+    const cleared = await mutateState(directory, `goal.send:${goalID}`, async (s) => {
+      const rt = s.runtimes.find((r) => r.goalID === goalID);
+      if (!rt)
+        return s;
+      rt.phase = "idle";
+      rt.activeRunID = undefined;
+      rt.idleCandidateAt = undefined;
+      rt.activePromptMessageID = undefined;
+      rt.activeToolCallIDs = [];
+      rt.updatedAt = new Date().toISOString();
+      return s;
+    });
+    const freshGoal = cleared.goals.find((g) => g.id === goalID);
+    if (!freshGoal || !freshGoal.workerSessionID) {
+      return { ok: true, message: `Queued for "${goal.name}" (no worker session yet; delivers on the next turn).` };
+    }
+    await continueTurnUnlocked(directory, goalID, { force: true, bare: true });
+    return { ok: true, message: `Sent to "${freshGoal.name}" as its own turn.` };
+  }
+  function sendUserMessage(directory, goalID, text) {
+    return withGoalOperation(goalID, () => sendUnlocked(directory, goalID, text));
+  }
   function continueTurn(directory, goalID, opts) {
     return withGoalOperation(goalID, () => continueTurnUnlocked(directory, goalID, opts));
   }
@@ -2325,7 +2930,48 @@ function createGoalService(host) {
   function nudge(directory, goalID) {
     return withGoalOperation(goalID, () => nudgeUnlocked(directory, goalID));
   }
-  return { start, continueTurn, nudge, pause, resume, retry, clear, getWorker, getActiveWorkers, reconcile };
+  async function abortWorkerUnlocked(directory, goalID) {
+    const preState = await readState(directory);
+    const goal = preState.goals.find((g) => g.id === goalID);
+    if (!goal)
+      return { ok: false, message: "Goal not found." };
+    const workerID = sessions.get(goalID)?.workerSessionID || goal.workerSessionID;
+    if (!workerID)
+      return { ok: false, message: `Goal "${goal.name}" has no worker session to abort.` };
+    try {
+      await workers.abortWorker(workerID);
+    } catch {}
+    sessions.delete(goalID);
+    await mutateState(directory, `goal.abort-worker:${goalID}`, async (s) => {
+      const rt = s.runtimes.find((r) => r.goalID === goalID);
+      if (rt) {
+        Object.assign(rt, releaseLease(rt));
+        rt.activeRunID = undefined;
+        rt.activePromptMessageID = undefined;
+        rt.activeToolCallIDs = [];
+        rt.idleCandidateAt = undefined;
+        rt.idleCandidateGeneration = undefined;
+        rt.workerAbortedAt = new Date().toISOString();
+        rt.updatedAt = new Date().toISOString();
+      }
+      const g = s.goals.find((item) => item.id === goalID);
+      if (g)
+        g.updatedAt = new Date().toISOString();
+      return s;
+    });
+    await logServerEvent(directory, "worker.aborted-manual", { goalID, workerSessionID: workerID });
+    return {
+      ok: true,
+      message: `Worker run for "${goal.name}" aborted, session kept for inspection (status unchanged: ${goal.status}).` + (goal.status === "active" ? " Engine continues the same session next turn." : "")
+    };
+  }
+  function abortWorker(directory, goalID) {
+    return withGoalOperation(goalID, () => abortWorkerUnlocked(directory, goalID));
+  }
+  function accountUsage(directory, goalID) {
+    return withGoalOperation(goalID, () => accountUsageUnlocked(directory, goalID));
+  }
+  return { start, continueTurn, nudge, pause, resume, retry, clear, getWorker, getActiveWorkers, reconcile, accountUsage, abortWorker, sendUserMessage };
 }
 
 // src/application/schedule-worker.ts
@@ -2442,161 +3088,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({});
-        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) => ({
-          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";
@@ -2617,11 +3108,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."),
@@ -2650,6 +3143,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)
@@ -2690,6 +3185,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,
@@ -2711,7 +3216,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",
@@ -2721,6 +3227,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,
@@ -2933,11 +3441,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) {
@@ -3022,11 +3536,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);
@@ -3076,6 +3596,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,
@@ -3087,6 +3608,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) {
@@ -3186,6 +3710,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),
@@ -3206,7 +3732,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."),
@@ -3261,12 +3787,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,
@@ -3300,6 +3830,7 @@ function ownerTools(options) {
               unknownStatusCount: runtime.unknownStatusCount,
               lastUnknownStatusAt: runtime.lastUnknownStatusAt,
               workerUnreachableNotifiedAt: runtime.workerUnreachableNotifiedAt,
+              workerAbortedAt: runtime.workerAbortedAt,
               retryAfter: runtime.retryAfter,
               forceFinishRequested: runtime.forceFinishRequested,
               scheduleRunCount: runtime.scheduleRunCount,
@@ -3693,9 +4224,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
   };
 }