@bojackduy/opencode-loopd 1.8.2 → 1.8.3

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 {
@@ -135,9 +106,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 +144,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 });
         }
@@ -712,54 +680,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 +743,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 +771,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 +787,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 +812,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 +828,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 +846,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 +860,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();
@@ -1879,9 +1847,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);
@@ -2122,17 +2090,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 +2130,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 +2148,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)
@@ -2541,16 +2509,22 @@ function createRealHost(client, directory) {
     async sessionStatus(sessionID) {
       try {
         const result = await client.session.status({});
+        if (result?.error)
+          return "unknown";
         const data = result?.data;
-        if (!data || typeof data !== "object")
+        if (!data || typeof data !== "object" || Array.isArray(data))
           return "unknown";
         const status = data[sessionID];
-        if (!status || typeof status !== "object")
+        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;
-        return "idle";
+        if (type === "idle")
+          return "idle";
+        return "unknown";
       } catch {
         return "unknown";
       }
@@ -2861,9 +2835,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 +2848,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 +2856,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 +2871,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 +2887,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 +2908,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 +2920,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
               })
             };
@@ -3637,8 +3611,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 +3635,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 +3662,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;
             });
           }

package/dist/tui.js

@@ -574,10 +574,10 @@ function LoopDashboard(props) {
     try {
       const s = await client.getState();
       setState(s);
-      const goals2 = s.goals.filter((g) => showCompleted() || g.status !== "complete");
-      if (goals2.length > 0 && selected() >= goals2.length)
-        setSelected(goals2.length - 1);
-      setSelectedGoal(goals2[selected()] || null);
+      const goals = s.goals.filter((g) => showCompleted() || g.status !== "complete");
+      if (goals.length > 0 && selected() >= goals.length)
+        setSelected(goals.length - 1);
+      setSelectedGoal(goals[selected()] || null);
       setEvents(await client.getEvents(20));
     } catch (e) {
       setStatusText(`Error: ${e instanceof Error ? e.message : String(e)}`);
@@ -1077,7 +1077,7 @@ function LoopDashboard(props) {
                 children: (seg, idx) => {
                   const hasArrow = seg.includes("\u2192");
                   if (hasArrow) {
-                    const [k2, d2] = seg.split("\u2192").map((s) => s.trim());
+                    const [k, d] = seg.split("\u2192").map((s) => s.trim());
                     return [_$memo(() => _$memo(() => idx() > 0)() && (() => {
                       var _el$54 = _$createElement("span");
                       _$insertNode(_el$54, _$createTextNode(` | `));
@@ -1087,7 +1087,7 @@ function LoopDashboard(props) {
                       return _el$54;
                     })()), (() => {
                       var _el$50 = _$createElement("span");
-                      _$insert(_el$50, k2);
+                      _$insert(_el$50, k);
                       _$effect((_$p) => _$setProp(_el$50, "style", {
                         fg: theme().warning,
                         bold: true
@@ -1102,7 +1102,7 @@ function LoopDashboard(props) {
                       return _el$51;
                     })(), (() => {
                       var _el$53 = _$createElement("span");
-                      _$insert(_el$53, d2);
+                      _$insert(_el$53, d);
                       _$effect((_$p) => _$setProp(_el$53, "style", {
                         fg: theme().text
                       }, _$p));

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@bojackduy/opencode-loopd",
-  "version": "1.8.2",
+  "version": "1.8.3",
   "description": "Codex-inspired background goal engine for OpenCode — autonomous subagents, engine-driven loop, child worker sessions and modal TUI dashboard. Like Claude Code loop for OpenCode.",
   "type": "module",
   "license": "AGPL-3.0-or-later",