@bojackduy/opencode-loopd 1.8.1 → 1.8.3

package/README.md

@@ -11,7 +11,7 @@
 
 ![Loop Dashboard — modal TUI with goals, running indicator, and insert mode](assets/demo.png)
 
-*Modal dashboard (`/loop` / `<leader>d`): zero chat pollution — keys are trapped inside the dialog, NORMAL vs INSERT modes, vivid per-status coloring.*
+*Modal dashboard (`/loop` / `<leader>o`): zero chat pollution — keys are trapped inside the dialog, NORMAL vs INSERT modes, vivid per-status coloring.*
 
 ## Why opencode-loopd
 
@@ -20,7 +20,7 @@
 - **Parent ↔ child visibility** — `list/inspect/read_transcript/send_input` give the parent full observability. Bidirectional inbox lets you steer mid-run.
 - **Safe by default** — per-goal artifact isolation (`.opencode/loopd/goals/<id>/`), `maxTurns`/`maxFailures`/`maxNoProgress`, force-finish → semantic `complete_goal` summary → parent notification via wake-up injection.
 - **Scheduled intervals** — `scheduleEveryMs`/`scheduleMaxRuns` auto-requeues the same goal every N ms (e.g., `10s` monitor, `1h` report) without manual `/goal` spam — `5s` poll, `skip-if-running`, `workspaceWrite` serialization, inbox `Scheduled tick N/M`.
-- **Modal TUI dashboard** — `<leader>d` or `/loop` opens a focused dialog (no leak to chat prompt). Vim-style navigation, live running indicator, per-status borders.
+- **Modal TUI dashboard** — `<leader>o` or `/loop` opens a focused dialog (no leak to chat prompt). Vim-style navigation, live running indicator, per-status borders.
 
 Keywords: `opencode` `opencode-plugin` `background-agent` `autonomous` `subagent` `loop` `goal` `tui` `codex` `claude-code` `worker`
 
@@ -50,7 +50,7 @@ Add the package to **both** configs.
 }
 ```
 
-Then restart OpenCode. Verify with `/loop` (palette → Loop Dashboard) or `<leader>d`.
+Then restart OpenCode. Verify with `/loop` (palette → Loop Dashboard) or `<leader>o`.
 
 For a local checkout:
 
@@ -142,7 +142,7 @@ The agent will clarify (what/where/how to verify) and then call `loopd_create_go
 
 ### 2. Monitor with dashboard — `/loop`
 
-Press **`<leader>d`** or open the command palette → **"Loop Dashboard"** (also `/loop`).
+Press **`<leader>o`** or open the command palette → **"Loop Dashboard"** (also `/loop`).
 
 Dashboard (NORMAL / INSERT `:`):
 

package/commands/goal.md

@@ -20,6 +20,6 @@ When you have enough to write a concrete contract:
     - `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`
-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>d). 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`.
+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,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,8 +1,8 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@bojackduy/opencode-loopd",
-  "version": "1.8.1",
-  "description": "Codex-inspired background goal engine for OpenCode \u2014 autonomous subagents, engine-driven loop, child worker sessions and modal TUI dashboard. Like Claude Code loop for OpenCode.",
+  "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",
   "private": false,

package/scripts/install-node.mjs

@@ -6,14 +6,16 @@ import { fileURLToPath } from "node:url"
 
 const root = dirname(dirname(fileURLToPath(import.meta.url)))
 const config = process.env.OPENCODE_CONFIG_DIR || join(homedir(), ".config", "opencode")
-const pluginDir = join(config, "plugins")
 const commandDir = join(config, "commands")
 const skillDir = join(config, "skills", "loopd")
 const packagePath = join(config, "package.json")
-const packageName = "opencode-loopd"
-const packageVersion = JSON.parse(await readFile(join(root, "package.json"), "utf8")).version
+const rootPackageJson = JSON.parse(await readFile(join(root, "package.json"), "utf8"))
+const packageName = rootPackageJson.name // "@bojackduy/opencode-loopd"
+const legacyPackageName = "opencode-loopd" // unscoped name used by older installs; matched for cleanup/upgrade only
+const packageVersion = rootPackageJson.version
 const packageSpec = `${packageName}@${packageVersion}`
 const configCandidates = ["opencode.json", "opencode.jsonc", "config.json", "config.jsonc"]
+const tuiConfigName = "tui.json"
 const installerArgs = process.argv.slice(2)
 const uninstallRequested = installerArgs.length === 1 && ["--uninstall", "uninstall", "--remove"].includes(installerArgs[0] || "")
 
@@ -62,32 +64,76 @@ function parseJsonc(input) {
   if (!p || typeof p !== "object" || Array.isArray(p)) throw new Error("OpenCode config root must be an object")
   return p
 }
-function isPackageSpec(v) { const s = String(v||"").trim(); return s === packageName || s.startsWith(`${packageName}@`) }
+function isPackageSpec(v) {
+  const s = String(v||"").trim()
+  return s === packageName || s.startsWith(`${packageName}@`) || s === legacyPackageName || s.startsWith(`${legacyPackageName}@`)
+}
 function skipTrivia(s, i) { while (i < s.length) { const c=s[i]||"", n=s[i+1]||""; if (/\s/.test(c)) {i++;continue} if (c==="/"&&n==="/") {i+=2; while(i<s.length&&s[i]!=="\n"&&s[i]!=="\r") i++; continue} if (c==="/"&&n==="*") { const e=s.indexOf("*/",i+2); if(e<0) throw new Error("unterminated block comment"); i=e+2; continue } break } return i }
 function readJsonString(s, i) { if(s[i]!=='"') throw new Error("expected JSON string"); let esc=false; for(let j=i+1;j<s.length;j++){const c=s[j]||""; if(esc){esc=false; continue} if(c==="\\"){esc=true;continue} if(c==='"'){return {value:JSON.parse(s.slice(i,j+1)), end:j+1}}} throw new Error("unterminated JSON string") }
 function skipJsonValue(s,i){ const vs=skipTrivia(s,i), f=s[vs]; if(f==='"') return readJsonString(s,vs).end; if(f==="{"||f==="["){const st=[]; let q=false,esc=false,lc=false,bc=false; for(let j=vs;j<s.length;j++){const c=s[j]||"",n=s[j+1]||""; if(lc){if(c==="\n"||c==="\r") lc=false; continue} if(bc){if(c==="*"&&n==="/"){bc=false;j++} continue} if(q){if(esc) esc=false; else if(c==="\\") esc=true; else if(c==='"') q=false; continue} if(c==='"'){q=true;continue} if(c==="/"&&n==="/"){lc=true;j++;continue} if(c==="/"&&n==="*"){bc=true;j++;continue} if(c==="{"||c==="[") st.push(c); else if(c==="}"||c==="]"){const e=c==="}"?"{":"["; if(st.at(-1)!==e) throw new Error("mismatched delimiters"); st.pop(); if(!st.length) return j+1} } throw new Error("unterminated JSON value") } let j=vs; while(j<s.length&&![",","}","]"].includes(s[j])) j++; return j }
 function findRootProperty(s, name){ let i=skipTrivia(s,0); if(s[i]!=="{") throw new Error("OpenCode config must be root object"); i++; while(true){ i=skipTrivia(s,i); if(s[i]==="}") return null; const k=readJsonString(s,i); i=skipTrivia(s,k.end); if(s[i]!==":") throw new Error(`expected ':' after ${k.value}`); const vs=skipTrivia(s,i+1), ve=skipJsonValue(s,vs); if(k.value===name){ const ls=Math.max(s.lastIndexOf("\n",vs-1),s.lastIndexOf("\r",vs-1))+1; const kls=Math.max(s.lastIndexOf("\n",k.end-1),s.lastIndexOf("\r",k.end-1))+1; const indent=s.slice(kls,k.end-k.value.length-2).match(/^[\t ]*/)?.[0]||"  "; return {valueStart:vs,valueEnd:ve,indent,lineStart:ls} } const av=skipTrivia(s,ve); if(s[av]===",") i=av+1; else if(s[av]==="}") return null; else throw new Error(`expected ',' or '}' after ${k.value}`) } }
 function formatPluginArray(vals, indent, eol){ if(!vals.length) return "[]"; const ci=`${indent}  `; return `[${eol}${vals.map(v=>`${ci}${JSON.stringify(v)}`).join(`,${eol}`)}${eol}${indent}]` }
 function rewriteExistingPluginArray(source, next){ const prop=findRootProperty(source,"plugin"); if(!prop) return source; const eol=source.includes("\r\n")?"\r\n":"\n"; const rep=formatPluginArray(next,prop.indent,eol); return `${source.slice(0,prop.valueStart)}${rep}${source.slice(prop.valueEnd)}` }
+function insertPluginProperty(source, vals) {
+  const eol = source.includes("\r\n") ? "\r\n" : "\n"
+  const i = skipTrivia(source, 0)
+  if (source[i] !== "{") throw new Error("OpenCode config must be root object")
+  const openEnd = i + 1
+  const after = skipTrivia(source, openEnd)
+  const propLine = `  "plugin": ${formatPluginArray(vals, "  ", eol)}`
+  if (source[after] === "}") return `${source.slice(0, openEnd)}${eol}${propLine}${eol}${source.slice(after)}`
+  return `${source.slice(0, openEnd)}${eol}${propLine},${source.slice(openEnd)}`
+}
 
-async function configurePackagePlugin() {
-  let configured = false; const updatedFiles=[]
+// Adds/updates the plugin entry in `target`, creating the file (with a minimal
+// `{ "plugin": [...] }`) if it doesn't exist yet. Returns true if the file changed.
+async function ensurePluginRegistered(target) {
+  let source
+  try {
+    source = await readFile(target, "utf8")
+  } catch (e) {
+    if (e?.code !== "ENOENT") throw new Error(`Could not read ${target}: ${e.message}`)
+    await mkdir(dirname(target), { recursive: true })
+    await writeFile(target, JSON.stringify({ plugin: [packageSpec] }, null, 2) + "\n", "utf8")
+    return true
+  }
+  const parsed = parseJsonc(source)
+  if (parsed.plugin !== undefined && !Array.isArray(parsed.plugin)) throw new Error(`plugin must be array in ${target}`)
+  const plugins = parsed.plugin || []
+  const next = plugins.filter(v => !isPackageSpec(v))
+  next.push(packageSpec)
+  const updated = parsed.plugin !== undefined ? rewriteExistingPluginArray(source, next) : insertPluginProperty(source, next)
+  if (updated === source) return false
+  await writeFile(target, updated, "utf8")
+  return true
+}
+// Removes the plugin entry from `target` if present. Returns true if the file changed.
+async function removePluginFromFile(target) {
+  let source
+  try {
+    source = await readFile(target, "utf8")
+  } catch (e) {
+    if (e?.code !== "ENOENT") throw new Error(`Could not inspect ${target}: ${e.message}`)
+    return false
+  }
+  const parsed = parseJsonc(source)
+  if (parsed.plugin !== undefined && !Array.isArray(parsed.plugin)) throw new Error(`plugin must be array in ${target}`)
+  const plugins = parsed.plugin || []
+  const next = plugins.filter(v => !isPackageSpec(v))
+  if (next.length === plugins.length) return false
+  const updated = rewriteExistingPluginArray(source, next)
+  if (updated === source) return false
+  await writeFile(target, updated, "utf8")
+  return true
+}
+// The server plugin registers into whichever main config file the user already
+// has (first match wins); falls back to opencode.jsonc if none exist yet.
+async function findExistingServerConfig() {
   for (const name of configCandidates) {
     const target = join(config, name)
-    try {
-      const source = await readFile(target, "utf8")
-      const parsed = parseJsonc(source)
-      if (parsed.plugin !== undefined && !Array.isArray(parsed.plugin)) throw new Error("plugin must be array")
-      const plugins = parsed.plugin || []
-      if (!plugins.some(isPackageSpec)) continue
-      configured = true
-      const next = plugins.filter(v=>!isPackageSpec(v))
-      next.push(packageSpec)
-      const upd = rewriteExistingPluginArray(source, next)
-      if (upd !== source) { await writeFile(target, upd, "utf8"); updatedFiles.push(target) }
-    } catch(e){ if(e?.code!=="ENOENT") throw new Error(`Could not inspect ${target}: ${e.message}`) }
+    try { await readFile(target, "utf8"); return target } catch (e) { if (e?.code !== "ENOENT") throw new Error(`Could not inspect ${target}: ${e.message}`) }
   }
-  return {configured, updatedFiles}
+  return null
 }
 async function ensureDependency(){
   let pkg={}
@@ -100,52 +146,48 @@ async function removePackagedFiles(srcDir, tgtDir){
   try{ for(const n of await readdir(srcDir)) if(n.endsWith(".md")) await rm(join(tgtDir,n),{force:true}) }catch{}
 }
 async function uninstall(){
-  const plans=[]
-  for(const name of configCandidates){
-    const target=join(config,name)
-    try{
-      const source=await readFile(target,"utf8")
-      const parsed=parseJsonc(source)
-      if(parsed.plugin!==undefined&&!Array.isArray(parsed.plugin)) throw new Error("plugin must be array")
-      const plugins=parsed.plugin||[]
-      const next=plugins.filter(v=>!isPackageSpec(v))
-      const upd= next.length===plugins.length ? source : rewriteExistingPluginArray(source,next)
-      plans.push({target,source,updated:upd})
-    }catch(e){ if(e?.code!=="ENOENT") throw new Error(`Could not inspect ${target}: ${e.message}`) }
+  const targets = [...configCandidates.map(name => join(config, name)), join(config, tuiConfigName)]
+  let changed = 0
+  for (const target of targets) {
+    if (await removePluginFromFile(target)) changed++
   }
-  for(const p of plans) if(p.updated!==p.source) await writeFile(p.target,p.updated,"utf8")
   // remove loopd artifacts
-  await rm(join(config,"tui.json"),{force:true}).catch(()=>{}) // legacy if any
   await removePackagedFiles(join(root,"commands"), join(config,"commands"))
   await rm(join(config,"skills","loopd","SKILL.md"),{force:true})
   try{ const d=join(config,"skills","loopd"); const files=await readdir(d); if(!files.length) await rm(d,{force:true}) }catch{}
-  const changed=plans.filter(p=>p.updated!==p.source).length
   console.log(changed ? `Removed ${packageName} from ${changed} config file(s).` : `${packageName} was not registered.`)
   console.log("Removed loopd command and skill when present. Project state under .opencode/loopd is preserved.")
   console.log("Restart OpenCode to finish unloading.")
 }
 async function installOrUpdate(){
-  await mkdir(join(config,"plugins"),{recursive:true})
+  await mkdir(config,{recursive:true})
   await mkdir(join(config,"commands"),{recursive:true})
   await mkdir(join(config,"skills","loopd"),{recursive:true})
-  const pc=await configurePackagePlugin()
-  const usePkg=pc.configured
-  if(!usePkg){ await ensureDependency() }
+
+  // Server engine plugin: registers into whichever main config file the user
+  // already has, creating opencode.jsonc if none exist yet.
+  const serverTarget = (await findExistingServerConfig()) || join(config, "opencode.jsonc")
+  const serverChanged = await ensurePluginRegistered(serverTarget)
+
+  // TUI dashboard plugin: separate config file, loaded by the TUI process.
+  // Without this, `/loop` and the `<leader>o` binding never register.
+  const tuiTarget = join(config, tuiConfigName)
+  const tuiChanged = await ensurePluginRegistered(tuiTarget)
+
+  await ensureDependency()
+
   // commands
   for(const n of await readdir(join(root,"commands"))){
     if(n.endsWith(".md")) await copyFile(join(root,"commands",n), join(config,"commands",n))
   }
   // skill
   await copyFile(join(root,"skills","loopd","SKILL.md"), join(config,"skills","loopd","SKILL.md"))
-  if(usePkg){
-    const pin=pc.updatedFiles.length ? `pinned to ${packageSpec}` : `already pinned to ${packageSpec}`
-    console.log(`OpenCode Loopd is already configured as package in ${config}; ${pin}.`)
-  } else {
-    console.log(`Installed opencode-loopd to ${config}`)
-  }
+
+  console.log(serverChanged ? `Registered ${packageSpec} in ${serverTarget}` : `${packageSpec} already registered in ${serverTarget}`)
+  console.log(tuiChanged ? `Registered ${packageSpec} in ${tuiTarget}` : `${packageSpec} already registered in ${tuiTarget}`)
   console.log(`Installed ${packageName} command to ${join(config,"commands","goal.md")}`)
   console.log(`Installed ${packageName} skill to ${join(config,"skills","loopd","SKILL.md")}`)
-  console.log("Restart OpenCode, then run: /goal  or  /loop")
+  console.log("Restart OpenCode, then run: /goal  or  /loop  (<leader>o)")
 }
 if(uninstallRequested) await uninstall()
 else await installOrUpdate()

package/skills/loopd/SKILL.md

@@ -83,7 +83,7 @@ loopd_create_goal({
 
 Returns `ok:true` with `goalID`, `workerSessionID`, `artifactDir`, `agent`, `checks`, `workspaceWrite`, `defaultsApplied:{agent,checks}`. On contract violation you get `ok:false` with `errorCode: "missing_agent"` or `"missing_checks"` or `"already active"` (writer serialization).
 
-The goal starts immediately. The user can monitor it via `/loop` (<leader>d). Plugin options `defaultAgent` / `defaultChecks` in `opencode.jsonc` can supply defaults so callers don’t have to repeat them.
+The goal starts immediately. The user can monitor it via `/loop` (<leader>o). Plugin options `defaultAgent` / `defaultChecks` in `opencode.jsonc` can supply defaults so callers don’t have to repeat them.
 
 ## Worker Tools (Running Inside the Goal)
 
@@ -174,7 +174,7 @@ Force re-prompts a stuck worker even if `sessionStatus` is not `idle`. Clears st
 
 ## Dashboard Commands
 
-Open the dashboard with `/loop` or <leader>d.
+Open the dashboard with `/loop` or <leader>o.
 
 ### Keyboard Shortcuts (Normal Mode)