@bojackduy/opencode-loopd 1.9.2 → 1.9.4

package/commands/goal.md

@@ -20,7 +20,8 @@ When you have enough to write a concrete contract:
     - `workspaceWrite` — default `true` (safe — may touch the shared repo; only one active writer allowed — second `start`/`resume` fails with `already active`); set `false` explicitly for artifact-only/read-only work to allow concurrency
     - `checkCwd` — optional directory where `checks` run; writers default to project root, artifact-only jobs default to their `artifactDir`
     - `progressFile` — optional path to a markdown progress file (defaults to `<artifactDir>/progress.md`)
-    - limits — optional `maxTurns` (default 50), `maxNoProgress`, `maxFailures`, `compactEvery`, `timeoutMs`
+    - `costBudget` — max dollars before `budget_limited` (e.g. `0.5`); enforced continuously, worker aborted mid-turn when exceeded
+    - limits — optional `maxTurns` (default 50), `maxNoProgress`, `maxFailures`, `compactEvery`, `timeoutMs` (also `costBudget` / `tokenBudget` for hard caps)
 2. After it returns (`ok:true` with `goalID`/`artifactDir`/`defaultsApplied`, or `ok:false` with `errorCode: "missing_agent"|"missing_checks"|"already active"`), tell the user the goal is running in the background and they can monitor it with `/loop` (or <leader>o). On `missing_*`, explain the contract violation and ask for the missing piece; on `already active`, tell them to `pause`/`clear` the current writer or use `workspaceWrite:false`.
 
 Important: the worker session runs autonomously — do not try to do the goal's work in this chat. This chat only creates the goal. Completion is host-judged: if `checks` fail, the worker will see `HOST VERDICT: COMPLETION REJECTED` with exact `stderr` and must fix the behavior (not just rewrite evidence) before retrying.

package/dist/server.js

@@ -1,4 +1,16 @@
 // @bun
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
+
 // src/domain/runtime.ts
 function createRuntimeState(goalID) {
   const now = new Date().toISOString();
@@ -113,14 +125,10 @@ function removeToolCall(rt, callID) {
 }
 var PARENT_NOTIFY_DEDUPE_MS = 60000;
 
-// src/application/control-worker.ts
-import { randomUUID } from "crypto";
-
 // src/infrastructure/state-repository.ts
 import { promises as fs } from "fs";
 import path from "path";
 import os from "os";
-var CURRENT_VERSION = 6;
 function emptyState() {
   return { version: CURRENT_VERSION, revision: 0, goals: [], runtimes: [], commandLedger: [] };
 }
@@ -140,7 +148,6 @@ function lockDir(directory) {
 function lockFile(directory, key) {
   return path.join(lockDir(directory), `${key}.lock`);
 }
-var LOCK_STALE_MS = 1e4;
 async function acquireLock(directory, key, operation) {
   const dir = lockDir(directory);
   await fs.mkdir(dir, { recursive: true });
@@ -476,6 +483,15 @@ async function peekGoalInbox(directory, goalID) {
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+var CURRENT_VERSION = 6, LOCK_STALE_MS = 1e4;
+var init_state_repository = () => {};
+
+// src/server/plugin.ts
+import { define } from "@opencode-ai/plugin/v2/promise";
+
+// src/application/control-worker.ts
+init_state_repository();
+import { randomUUID } from "crypto";
 
 // src/application/goal-policy.ts
 function resolveGoalCreationConfig(input) {
@@ -932,6 +948,7 @@ function createControlWorker(options) {
 }
 
 // src/application/loop-engine.ts
+init_state_repository();
 import { randomUUID as randomUUID2 } from "crypto";
 
 // src/domain/goal.ts
@@ -1871,6 +1888,7 @@ function createLoopEngine(options) {
 
 // src/application/goal-service.ts
 import { randomUUID as randomUUID3 } from "crypto";
+init_state_repository();
 import * as path2 from "path";
 import { promises as fs2 } from "fs";
 
@@ -2975,6 +2993,7 @@ function createGoalService(host) {
 }
 
 // src/application/schedule-worker.ts
+init_state_repository();
 import { randomUUID as randomUUID4 } from "crypto";
 function createScheduleWorker(options) {
   const { directory, goalService } = options;
@@ -3089,6 +3108,7 @@ function createScheduleWorker(options) {
 }
 
 // src/server/goal-tools.ts
+init_state_repository();
 import { randomUUID as randomUUID5 } from "crypto";
 import { tool } from "@opencode-ai/plugin/tool";
 // src/domain/verification.ts
@@ -3666,6 +3686,7 @@ async function runCompletionChecks(checks, cwd) {
 }
 
 // src/server/owner-tools.ts
+init_state_repository();
 import { tool as tool2 } from "@opencode-ai/plugin/tool";
 import { promises as fs3 } from "fs";
 function withTimeout2(promise, ms) {
@@ -3893,7 +3914,7 @@ function ownerTools(options) {
       }
     }),
     send_goal_input: tool2({
-      description: "Send an inbox message to the worker (injected as ## USER INSTRUCTIONS on next turn). Use to answer `question`, redirect, or refine scope. Does NOT itself re-prompt \u2014 the engine re-prompts on next idle/maintenance; use nudge_goal if the worker is stuck with no activity.",
+      description: "Send bare words to the worker as their own turn (no steering wrapper). Delivers immediately if the goal is active, otherwise queues for the next active turn. Use to answer `question`, redirect, or nudge with a short message.",
       args: {
         goal_id: tool2.schema.string().optional().describe("Goal ID. Omit to target the first active goal."),
         message: tool2.schema.string().describe("Message to send to the worker.")
@@ -3908,14 +3929,14 @@ function ownerTools(options) {
             output: JSON.stringify({ ok: false, message: "No matching active goal for this session." })
           };
         }
-        await appendGoalInbox(directory, goal.id, "user", args.message);
+        const result = await goalService.sendUserMessage(directory, goal.id, args.message);
         return {
-          title: "Message sent",
+          title: result.ok ? "Message sent" : "Send failed",
           output: JSON.stringify({
-            ok: true,
+            ok: result.ok,
             goalID: goal.id,
             goalName: goal.name,
-            message: `Message delivered to "${goal.name}". It will appear in the worker's next turn.`
+            message: result.message
           })
         };
       }
@@ -4048,6 +4069,141 @@ function ownerTools(options) {
         }
       }
     }),
+    abort_goal_worker: tool2({
+      description: "Abort the worker session only (N / :abort in TUI). Keeps goal+transcript+session browsable, clears the run lease. Use for compaction-spin or stuck runs. Status unchanged; active goals resume next turn in the same session.",
+      args: {
+        goal_id: tool2.schema.string().optional().describe("Goal ID. Omit to abort the first active goal.")
+      },
+      execute: async (args, context) => {
+        const state = await readState(directory);
+        const ownerID = context?.sessionID;
+        const goal = args.goal_id ? state.goals.find((g) => g.id === args.goal_id && g.ownerSessionID === ownerID) : state.goals.find((g) => g.ownerSessionID === ownerID && g.status !== "complete");
+        if (!goal) {
+          return {
+            title: "No goal found",
+            output: JSON.stringify({ ok: false, message: "No matching active goal for this session." })
+          };
+        }
+        try {
+          const result = await goalService.abortWorker(directory, goal.id);
+          return {
+            title: result.ok ? "Worker aborted" : "Abort failed",
+            output: JSON.stringify({ ...result, goalID: goal.id, goalName: goal.name })
+          };
+        } catch (error) {
+          return {
+            title: "Abort failed",
+            output: JSON.stringify({
+              ok: false,
+              goalName: goal.name,
+              message: error instanceof Error ? error.message : String(error)
+            })
+          };
+        }
+      }
+    }),
+    force_complete_goal: tool2({
+      description: "Force-complete a goal with summary/evidence, bypassing checks (:force in TUI). Use when the worker produced the right artifact but checks are stale or you have verified manually.",
+      args: {
+        goal_id: tool2.schema.string().optional().describe("Goal ID. Omit to target the first non-complete goal."),
+        summary: tool2.schema.string().describe("What was completed."),
+        evidence: tool2.schema.string().describe("Concrete evidence of completion.")
+      },
+      execute: async (args, context) => {
+        const state = await readState(directory);
+        const ownerID = context?.sessionID;
+        const goal = args.goal_id ? state.goals.find((g) => g.id === args.goal_id && g.ownerSessionID === ownerID) : state.goals.find((g) => g.ownerSessionID === ownerID && g.status !== "complete");
+        if (!goal) {
+          return {
+            title: "No goal found",
+            output: JSON.stringify({ ok: false, message: "No matching active goal for this session." })
+          };
+        }
+        await Promise.resolve().then(() => init_state_repository());
+        await Promise.resolve();
+        const { randomUUID } = await import("crypto");
+        const st = await readState(directory);
+        const g = st.goals.find((x) => x.id === goal.id);
+        if (!g)
+          return { title: "No goal", output: JSON.stringify({ ok: false, message: "Goal not found." }) };
+        if (g.status === "complete") {
+          return { title: "Already complete", output: JSON.stringify({ ok: true, message: `Goal "${g.name}" already complete.` }) };
+        }
+        g.status = "complete";
+        g.updatedAt = new Date().toISOString();
+        g.completionEvidence = { summary: args.summary, evidence: args.evidence, at: new Date().toISOString() };
+        const rt = st.runtimes.find((r) => r.goalID === goal.id);
+        if (rt) {
+          Object.assign(rt, releaseLease(rt));
+          rt.activeRunID = undefined;
+          rt.lastError = undefined;
+          rt.updatedAt = new Date().toISOString();
+        }
+        await writeState(directory, st);
+        await appendEvent(directory, {
+          version: 1,
+          eventID: randomUUID(),
+          goalID: goal.id,
+          type: "goal.completed",
+          summary: args.summary,
+          evidence: args.evidence,
+          timestamp: new Date().toISOString(),
+          revision: st.revision
+        });
+        return { title: "Goal force-completed", output: JSON.stringify({ ok: true, goalID: goal.id, goalName: g.name }) };
+      }
+    }),
+    force_block_goal: tool2({
+      description: "Force-block a goal with reason/needed (:block in TUI). Use when the goal is stuck on an external blocker and should stop retrying.",
+      args: {
+        goal_id: tool2.schema.string().optional().describe("Goal ID. Omit to target the first non-complete goal."),
+        reason: tool2.schema.string().describe("Why the goal is blocked."),
+        needed: tool2.schema.string().describe("What is needed to unblock.")
+      },
+      execute: async (args, context) => {
+        const state = await readState(directory);
+        const ownerID = context?.sessionID;
+        const goal = args.goal_id ? state.goals.find((g) => g.id === args.goal_id && g.ownerSessionID === ownerID) : state.goals.find((g) => g.ownerSessionID === ownerID && g.status !== "complete");
+        if (!goal) {
+          return {
+            title: "No goal found",
+            output: JSON.stringify({ ok: false, message: "No matching active goal for this session." })
+          };
+        }
+        await Promise.resolve().then(() => init_state_repository());
+        await Promise.resolve();
+        const { randomUUID } = await import("crypto");
+        const st = await readState(directory);
+        const g = st.goals.find((x) => x.id === goal.id);
+        if (!g)
+          return { title: "No goal", output: JSON.stringify({ ok: false, message: "Goal not found." }) };
+        if (g.status === "blocked") {
+          return { title: "Already blocked", output: JSON.stringify({ ok: true, message: `Goal "${g.name}" already blocked.` }) };
+        }
+        g.status = "blocked";
+        g.updatedAt = new Date().toISOString();
+        g.blocker = { reason: args.reason, needed: args.needed, at: new Date().toISOString() };
+        const rt = st.runtimes.find((r) => r.goalID === goal.id);
+        if (rt) {
+          Object.assign(rt, releaseLease(rt));
+          rt.activeRunID = undefined;
+          rt.lastError = undefined;
+          rt.updatedAt = new Date().toISOString();
+        }
+        await writeState(directory, st);
+        await appendEvent(directory, {
+          version: 1,
+          eventID: randomUUID(),
+          goalID: goal.id,
+          type: "goal.blocked",
+          reason: args.reason,
+          needed: args.needed,
+          timestamp: new Date().toISOString(),
+          revision: st.revision
+        });
+        return { title: "Goal blocked", output: JSON.stringify({ ok: true, goalID: goal.id, goalName: g.name }) };
+      }
+    }),
     clear_goal: tool2({
       description: "Clear a goal: aborts worker and removes goal+runtime+ledger (cannot be undone). Use when the goal is no longer needed or to free a stuck writer slot after inspection.",
       args: {
@@ -4088,7 +4244,9 @@ function ownerTools(options) {
     })
   };
 }
+
 // src/server/plugin.ts
+init_state_repository();
 var PLUGIN_ID = "opencode-loopd.server";
 var server = async ({ client, directory }, pluginOptions) => {
   const defaults = parsePluginDefaults(pluginOptions);
@@ -4232,9 +4390,14 @@ function parsePluginDefaults(options) {
     defaultChecks: checks.length > 0 ? checks : undefined
   };
 }
+var v2 = define({
+  id: PLUGIN_ID,
+  async setup() {}
+});
 var plugin_default = {
   id: PLUGIN_ID,
-  server
+  server,
+  setup: v2.setup
 };
 export {
   plugin_default as default