@bojackduy/opencode-loopd 1.9.1 → 1.9.3

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();
@@ -34,6 +46,7 @@ function acquireLease(rt, timeoutMs) {
     idleConfirmFailedAt: undefined,
     idleConfirmFailedGeneration: undefined,
     idleStuckNotifiedGeneration: undefined,
+    workerAbortedAt: undefined,
     activePromptObservedAt: undefined,
     activeAssistantMessageID: undefined,
     activeAssistantCompletedAt: undefined,
@@ -112,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: [] };
 }
@@ -139,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 });
@@ -475,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) {
@@ -595,12 +612,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);
@@ -749,6 +771,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);
@@ -770,12 +807,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);
-        const goal = state.goals.find((g) => g.id === request.goalID);
         response = {
           ...base,
-          message: `sent to "${goal?.name || request.goalID}"`,
+          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);
+        response = {
+          ...base,
+          ok: result.ok,
+          message: result.message,
           stateRevision: state.revision
         };
         break;
@@ -896,6 +948,7 @@ function createControlWorker(options) {
 }
 
 // src/application/loop-engine.ts
+init_state_repository();
 import { randomUUID as randomUUID2 } from "crypto";
 
 // src/domain/goal.ts
@@ -1835,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";
 
@@ -2053,6 +2107,16 @@ function createWorkerManager(host) {
       });
       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;
+    },
     async isIdle(workerSessionID) {
       const status = await host.sessionStatus(workerSessionID);
       return status === "idle";
@@ -2511,6 +2575,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) => ({
@@ -2818,6 +2896,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));
   }
@@ -2836,13 +2948,52 @@ function createGoalService(host) {
   function nudge(directory, goalID) {
     return withGoalOperation(goalID, () => nudgeUnlocked(directory, goalID));
   }
+  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 };
+  return { start, continueTurn, nudge, pause, resume, retry, clear, getWorker, getActiveWorkers, reconcile, accountUsage, abortWorker, sendUserMessage };
 }
 
 // src/application/schedule-worker.ts
+init_state_repository();
 import { randomUUID as randomUUID4 } from "crypto";
 function createScheduleWorker(options) {
   const { directory, goalService } = options;
@@ -2957,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
@@ -3534,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) {
@@ -3698,6 +3851,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,
@@ -3760,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.")
@@ -3775,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
           })
         };
       }
@@ -3915,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: {
@@ -3955,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);
@@ -4099,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