@bojackduy/opencode-loopd 1.9.6 → 1.10.0

package/dist/server.js

@@ -487,7 +487,7 @@ var CURRENT_VERSION = 6, LOCK_STALE_MS = 1e4;
 var init_state_repository = () => {};
 
 // src/server/plugin.ts
-import { define } from "@opencode-ai/plugin/v2/promise";
+import { tool as v1Tool } from "@opencode-ai/plugin/tool";
 
 // src/application/control-worker.ts
 init_state_repository();
@@ -1334,7 +1334,7 @@ function createLoopEngine(options) {
         revision: blockedState.revision
       });
       if (shouldNotifyBlocked) {
-        await host.notifyOwner(goal.ownerSessionID, `Loop goal "${goal.name}" stopped: ${limitResult.reason} (child did not wrap up). Status: blocked. Last progress: ${goal.lastProgress?.summary || "none"}.`);
+        await host.notifyOwner(goal.ownerSessionID, `Loop goal "${goal.name}" stopped: ${limitResult.reason} (child did not wrap up). Status: blocked. Last progress: ${goal.lastProgress?.summary || "none"}.`, goal.parentAgent);
       }
       return true;
     }
@@ -1473,7 +1473,7 @@ function createLoopEngine(options) {
         revision: newState.revision
       });
       if (shouldNotify) {
-        await host.notifyOwner(goal.ownerSessionID, `Loop goal "${goal.name}" blocked after ${runtime.consecutiveFailures + 1} failures. Last error: ${message}.`);
+        await host.notifyOwner(goal.ownerSessionID, `Loop goal "${goal.name}" blocked after ${runtime.consecutiveFailures + 1} failures. Last error: ${message}.`, goal.parentAgent);
       }
     }
     return true;
@@ -1635,7 +1635,7 @@ function createLoopEngine(options) {
       costUsed: stoppedGoal.costUsed
     });
     if (shouldNotify) {
-      await host.notifyOwner(goal.ownerSessionID, `Loop goal "${goal.name}" stopped: ${reason}. Worker aborted, status: budget_limited. Resume with resume_goal to continue spending.`);
+      await host.notifyOwner(goal.ownerSessionID, `Loop goal "${goal.name}" stopped: ${reason}. Worker aborted, status: budget_limited. Resume with resume_goal to continue spending.`, goal.parentAgent);
     }
     return true;
   }
@@ -1745,7 +1745,7 @@ function createLoopEngine(options) {
               workerSessionID: goal.workerSessionID,
               count: unknownRuntime?.unknownStatusCount
             });
-            await host.notifyOwner(goal.ownerSessionID, `Loop goal "${goal.name}" worker is unreachable after ${unknownRuntime?.unknownStatusCount ?? unknownStatusThreshold} status checks. The goal remains active; use inspect_background_goal, nudge_goal, pause_goal, or resume_goal to recover it.`);
+            await host.notifyOwner(goal.ownerSessionID, `Loop goal "${goal.name}" worker is unreachable after ${unknownRuntime?.unknownStatusCount ?? unknownStatusThreshold} status checks. The goal remains active; use inspect_background_goal, nudge_goal, pause_goal, or resume_goal to recover it.`, goal.parentAgent);
           }
           continue;
         }
@@ -1840,7 +1840,7 @@ function createLoopEngine(options) {
             stuckSeconds
           });
           const quietMinutes = Math.max(1, Math.floor(stuckSeconds / 60));
-          await host.notifyOwner(goal.ownerSessionID, `Loop goal "${goal.name}" worker is idle but its turn will not confirm (unconfirmed for ${quietMinutes}m, no activity). The goal remains active; use inspect_background_goal to look, nudge_goal to re-prompt, or pause_goal to stop it.`);
+          await host.notifyOwner(goal.ownerSessionID, `Loop goal "${goal.name}" worker is idle but its turn will not confirm (unconfirmed for ${quietMinutes}m, no activity). The goal remains active; use inspect_background_goal to look, nudge_goal to re-prompt, or pause_goal to stop it.`, goal.parentAgent);
           continue;
         }
         if (status === "idle") {
@@ -1879,7 +1879,7 @@ function createLoopEngine(options) {
               runID: runtime.activeRunID,
               stuckSeconds
             });
-            await host.notifyOwner(goal.ownerSessionID, `Loop goal "${goal.name}" worker may be stuck: no activity for ${Math.floor(stuckSeconds / 60)}m while reporting ${status}, lease expired. The goal remains active; use inspect_background_goal to look, nudge_goal to re-prompt, or pause_goal to stop it.`);
+            await host.notifyOwner(goal.ownerSessionID, `Loop goal "${goal.name}" worker may be stuck: no activity for ${Math.floor(stuckSeconds / 60)}m while reporting ${status}, lease expired. The goal remains active; use inspect_background_goal to look, nudge_goal to re-prompt, or pause_goal to stop it.`, goal.parentAgent);
           }
         }
       }
@@ -2070,15 +2070,27 @@ function createRealHost(client, directory) {
         await client.session.compact({ sessionID });
       } catch {}
     },
-    async notifyOwner(ownerSessionID, message) {
+    async notifyOwner(ownerSessionID, message, agent) {
       if (shouldDedupParentNotify(ownerSessionID, message)) {
         await logServerEvent(directory, "parent.notify.deduped", { ownerSessionID, preview: message.slice(0, 160) });
         return;
       }
+      let resolvedAgent = agent?.trim() || undefined;
+      if (!resolvedAgent) {
+        try {
+          const sess = await client.session.get({ path: { id: ownerSessionID } });
+          const liveAgent = sess?.data?.agent;
+          if (typeof liveAgent === "string" && liveAgent.trim())
+            resolvedAgent = liveAgent.trim();
+        } catch {}
+      }
       try {
+        const body = { parts: [{ type: "text", text: message }] };
+        if (resolvedAgent)
+          body.agent = resolvedAgent;
         const result = await withTimeout(client.session.promptAsync({
           path: { id: ownerSessionID },
-          body: { parts: [{ type: "text", text: message }] }
+          body
         }), 1e4, "OpenCode parent notify");
         if (result?.error) {
           await logServerEvent(directory, "parent.notify.failed", { ownerSessionID, detail: describeError(result.error) });
@@ -2091,6 +2103,115 @@ function createRealHost(client, directory) {
     }
   };
 }
+function createV2Host(context, statuses) {
+  const directory = context.location.directory;
+  return {
+    async createWorker({ parentID, title, agent, model }) {
+      const session = await context.session.create({
+        title,
+        agent,
+        model: model ? { id: model.modelID, providerID: model.providerID } : undefined,
+        location: { directory },
+        metadata: { "loopd.parentID": parentID }
+      });
+      statuses.set(session.id, "idle");
+      await logServerEvent(directory, "worker.created", { parentID, workerSessionID: session.id, title });
+      return session.id;
+    },
+    async promptWorker({ sessionID, prompt, messageID, model, agent }) {
+      if (agent)
+        await context.session.switchAgent({ sessionID, agent });
+      if (model) {
+        await context.session.switchModel({
+          sessionID,
+          model: { id: model.modelID, providerID: model.providerID }
+        });
+      }
+      const result = await context.session.prompt({
+        sessionID,
+        id: messageID,
+        text: prompt
+      });
+      statuses.set(sessionID, "busy");
+      await logServerEvent(directory, "worker.prompted", { sessionID });
+      return { messageID: result.id };
+    },
+    async readSession(sessionID) {
+      try {
+        const session = await context.session.get({ sessionID });
+        const model = session.model ? { providerID: session.model.providerID, modelID: session.model.id } : undefined;
+        if (!session.agent && !model)
+          return;
+        return { agent: session.agent, model };
+      } catch {
+        return;
+      }
+    },
+    async sessionStatus(sessionID) {
+      return statuses.get(sessionID) ?? "unknown";
+    },
+    async abortSession(sessionID) {
+      try {
+        await context.session.interrupt({ sessionID });
+        statuses.set(sessionID, "idle");
+      } catch {}
+    },
+    async readMessages(sessionID, limit = 10) {
+      try {
+        const messages = await context.session.context({ sessionID });
+        let parentMessageID;
+        return messages.flatMap((message) => {
+          if (message.type === "user") {
+            parentMessageID = message.id;
+            return [{
+              role: "user",
+              content: message.text,
+              timestamp: new Date(message.time.created).toISOString(),
+              messageID: message.id
+            }];
+          }
+          if (message.type !== "assistant")
+            return [];
+          const created = message.time.created;
+          const completed = message.time.completed;
+          return [{
+            role: "assistant",
+            content: message.content.filter((part) => part.type === "text").map((part) => part.text).join(`
+`),
+            timestamp: new Date(completed ?? created).toISOString(),
+            messageID: message.id,
+            parentMessageID,
+            completedAt: completed ? new Date(completed).toISOString() : undefined,
+            tokens: message.tokens ? {
+              input: message.tokens.input,
+              output: message.tokens.output,
+              reasoning: message.tokens.reasoning,
+              cacheRead: message.tokens.cache.read,
+              cacheWrite: message.tokens.cache.write
+            } : undefined,
+            cost: message.cost,
+            durationMs: completed && completed >= created ? completed - created : undefined
+          }];
+        }).slice(-limit);
+      } catch {
+        return [];
+      }
+    },
+    async compactSession(sessionID) {
+      try {
+        await context.session.command({ sessionID, name: "compact", text: "" });
+      } catch {}
+    },
+    async notifyOwner(ownerSessionID, message) {
+      try {
+        await context.session.prompt({ sessionID: ownerSessionID, text: message });
+        await logServerEvent(directory, "parent.notified", { ownerSessionID, preview: message.slice(0, 160) });
+      } catch (error) {
+        await logServerEvent(directory, "parent.notify.failed", { ownerSessionID, detail: describeError(error) });
+      }
+    }
+  };
+}
 async function withTimeout(promise, timeoutMs, operation) {
   let timer;
   try {
@@ -2361,6 +2482,17 @@ function createGoalService(host) {
     return withGoalOperation(id, () => startUnlocked(directory, input, id));
   }
   async function startUnlocked(directory, input, id) {
+    let parentAgent = input.parentAgent;
+    let parentModel = input.parentModel;
+    if ((!parentAgent || !parentModel) && host.readSession) {
+      try {
+        const identity = await host.readSession(input.ownerSessionID);
+        if (!parentAgent && identity?.agent)
+          parentAgent = identity.agent;
+        if (!parentModel && identity?.model)
+          parentModel = `${identity.model.providerID}/${identity.model.modelID}`;
+      } catch {}
+    }
     const goal = createGoal({
       id,
       name: input.name,
@@ -2375,10 +2507,10 @@ function createGoalService(host) {
     });
     if (typeof input.costBudget === "number")
       goal.costBudget = input.costBudget;
-    if (input.parentAgent)
-      goal.parentAgent = input.parentAgent;
-    if (input.parentModel)
-      goal.parentModel = input.parentModel;
+    if (parentAgent)
+      goal.parentAgent = parentAgent;
+    if (parentModel)
+      goal.parentModel = parentModel;
     const artifactDir = goalArtifactDir(directory, id);
     goal.config.artifactDir = artifactDir;
     if (!goal.config.progressFile)
@@ -4314,6 +4446,9 @@ var PLUGIN_ID = "opencode-loopd.server";
 var server = async ({ client, directory }, pluginOptions) => {
   const defaults = parsePluginDefaults(pluginOptions);
   const host = createRealHost(client, directory);
+  return createServerHooks(directory, host, defaults);
+};
+function createServerHooks(directory, host, defaults) {
   const goalService = createGoalService(host);
   const worker = createControlWorker({
     directory,
@@ -4432,7 +4567,7 @@ var server = async ({ client, directory }, pluginOptions) => {
             });
           }
           const message = parsed.status === "complete" ? `Loop goal "${goal.name}" completed: ${parsed.summary || ""}. Evidence: ${parsed.evidence || ""}. Artifacts: ${goal.config.artifactDir || "n/a"}.` : `Loop goal "${goal.name}" blocked: ${parsed.reason || ""}. Needed: ${parsed.needed || ""}.`;
-          await host.notifyOwner(goal.ownerSessionID, message);
+          await host.notifyOwner(goal.ownerSessionID, message, goal.parentAgent);
         } catch {}
       }
     },
@@ -4442,7 +4577,7 @@ var server = async ({ client, directory }, pluginOptions) => {
       scheduleWorker.stop();
     }
   };
-};
+}
 function parsePluginDefaults(options) {
   const agent = typeof options?.defaultAgent === "string" ? options.defaultAgent.trim() : "";
   const model = typeof options?.defaultModel === "string" ? options.defaultModel.trim() : "";
@@ -4453,10 +4588,127 @@ function parsePluginDefaults(options) {
     defaultChecks: checks.length > 0 ? checks : undefined
   };
 }
-var v2 = define({
+var v2 = {
   id: PLUGIN_ID,
-  async setup() {}
-});
+  async setup(context) {
+    const directory = context.location.directory;
+    const statuses = new Map;
+    const host = createV2Host(context, statuses);
+    const hooks = createServerHooks(directory, host, parsePluginDefaults(context.options));
+    const registrations = [];
+    const eventController = new AbortController;
+    let eventTask = Promise.resolve();
+    let disposed = false;
+    const cleanup = async () => {
+      if (disposed)
+        return;
+      disposed = true;
+      eventController.abort();
+      await eventTask;
+      try {
+        await Promise.allSettled(registrations.reverse().map((registration) => registration.dispose()));
+      } finally {
+        await hooks.dispose?.();
+      }
+    };
+    try {
+      registrations.push(await context.tool.transform((editor) => {
+        for (const [id, definition] of Object.entries(hooks.tool ?? {})) {
+          editor.add(toV2Tool(id, definition, directory));
+        }
+      }));
+      registrations.push(await context.tool.hook("execute.before", async (input) => {
+        await hooks["tool.execute.before"]?.({
+          tool: input.tool,
+          sessionID: input.sessionID,
+          callID: input.id
+        }, { args: input.input });
+      }));
+      registrations.push(await context.tool.hook("execute.after", async (input) => {
+        const output = input.status === "completed" ? input.result : { content: JSON.stringify(input.error) };
+        await hooks["tool.execute.after"]?.({
+          tool: input.tool,
+          sessionID: input.sessionID,
+          callID: input.id,
+          args: input.input
+        }, {
+          title: "",
+          output: typeof output.content === "string" ? output.content : JSON.stringify(output.content ?? ""),
+          metadata: output.metadata ?? {}
+        });
+      }));
+      eventTask = consumeV2Events(context, eventController.signal, statuses, hooks).catch(async (error) => {
+        if (!eventController.signal.aborted) {
+          await logServerEvent(directory, "events.failed", { detail: describeError(error) });
+        }
+      });
+      return cleanup;
+    } catch (error) {
+      await cleanup();
+      throw error;
+    }
+  }
+};
+function toV2Tool(id, definition, directory) {
+  return {
+    name: id,
+    description: definition.description,
+    input: v1Tool.schema.object(definition.args),
+    async execute(input, context) {
+      const result = await definition.execute(input, {
+        sessionID: context.sessionID,
+        agent: context.agent,
+        messageID: context.messageID,
+        directory,
+        worktree: directory,
+        abort: new AbortController().signal,
+        metadata() {},
+        async ask() {}
+      });
+      if (typeof result === "string")
+        return { content: result };
+      return {
+        content: result.output,
+        metadata: {
+          ...result.metadata,
+          ...result.title ? { title: result.title } : {}
+        }
+      };
+    }
+  };
+}
+async function consumeV2Events(context, signal, statuses, hooks) {
+  for await (const event of context.event.subscribe({ signal })) {
+    const data = "data" in event && event.data && typeof event.data === "object" ? event.data : {};
+    const sessionID = typeof data.sessionID === "string" ? data.sessionID : undefined;
+    if (sessionID) {
+      if (event.type === "session.status")
+        statuses.set(sessionID, data.status?.type ?? "unknown");
+      else if (event.type === "session.idle")
+        statuses.set(sessionID, "idle");
+      else if (event.type === "session.execution.started")
+        statuses.set(sessionID, "busy");
+    }
+    await hooks.event?.({ event: normalizeV2Event(event) });
+  }
+}
+function normalizeV2Event(event) {
+  const properties = event?.data && typeof event.data === "object" ? event.data : {};
+  if (event?.type === "session.compaction.ended")
+    return { type: "session.compacted", properties };
+  if (event?.type === "session.execution.failed")
+    return { type: "session.error", properties };
+  if (event?.type === "session.message.content.updated") {
+    return {
+      type: "message.part.updated",
+      properties: {
+        sessionID: properties.sessionID,
+        part: { messageID: properties.messageID }
+      }
+    };
+  }
+  return { type: event?.type, properties };
+}
 var plugin_default = {
   id: PLUGIN_ID,
   server,

package/dist/tui.js

@@ -2373,9 +2373,171 @@ var tui = async (api) => {
   });
   api.lifecycle.onDispose(() => {});
 };
+function adaptThemeV2(theme) {
+  const t = theme ?? {};
+  const text = t.text ?? {};
+  const fb = text.feedback ?? {};
+  const bg = t.background ?? {};
+  const surface = bg.surface ?? {};
+  const diff = t.diff ?? {};
+  const diffText = diff.text ?? {};
+  const diffBg = diff.background ?? {};
+  const diffHi = diff.highlight ?? {};
+  const diffLn = diff.lineNumber ?? {};
+  const syntax = t.syntax ?? {};
+  const md = t.markdown ?? {};
+  const dv = (v, fallback) => typeof v === "string" ? v : fallback;
+  const base = dv(text.default, "#ffffff");
+  const muted = dv(text.subdued, "#888888");
+  return {
+    text: base,
+    textMuted: muted,
+    primary: base,
+    accent: base,
+    success: dv(fb.success?.default, "#22c55e"),
+    warning: dv(fb.warning?.default, "#eab308"),
+    error: dv(fb.error?.default, "#ef4444"),
+    info: dv(fb.info?.default, base),
+    background: dv(bg.default, "#000000"),
+    backgroundPanel: dv(surface.overlay, dv(bg.default, "#000000")),
+    backgroundElement: dv(surface.offset, dv(bg.default, "#000000")),
+    diffAdded: dv(diffText.added, base),
+    diffRemoved: dv(diffText.removed, base),
+    diffContext: dv(diffText.context, muted),
+    diffAddedBg: dv(diffBg.added, dv(bg.default, "#000000")),
+    diffRemovedBg: dv(diffBg.removed, dv(bg.default, "#000000")),
+    diffContextBg: dv(diffBg.context, dv(bg.default, "#000000")),
+    diffHighlightAdded: dv(diffHi.added, base),
+    diffHighlightRemoved: dv(diffHi.removed, base),
+    diffLineNumber: dv(diffLn.text, muted),
+    diffAddedLineNumberBg: dv(diffLn.background?.added, dv(bg.default, "#000000")),
+    diffRemovedLineNumberBg: dv(diffLn.background?.removed, dv(bg.default, "#000000")),
+    syntaxComment: dv(syntax.comment, muted),
+    syntaxKeyword: dv(syntax.keyword, base),
+    syntaxFunction: dv(syntax.function, base),
+    syntaxVariable: dv(syntax.variable, base),
+    syntaxString: dv(syntax.string, base),
+    syntaxNumber: dv(syntax.number, base),
+    syntaxType: dv(syntax.type, base),
+    syntaxOperator: dv(syntax.operator, base),
+    syntaxPunctuation: dv(syntax.punctuation, muted),
+    markdownText: dv(md.text, base),
+    markdownHeading: dv(md.heading, base),
+    markdownLink: dv(md.link, base),
+    markdownLinkText: dv(md.linkText, base),
+    markdownCode: dv(md.code, base),
+    markdownBlockQuote: dv(md.blockQuote, muted),
+    markdownEmph: dv(md.emphasis, base),
+    markdownStrong: dv(md.strong, base),
+    markdownListItem: dv(md.listItem, base)
+  };
+}
+var v2setup = (ctx) => {
+  const directory = ctx.location?.directory ?? ctx.data.location.default().directory;
+  let dialogOpen = false;
+  const closeDialog = () => {
+    dialogOpen = false;
+    ctx.ui.dialog.clear();
+  };
+  const facade = {
+    theme: {
+      get current() {
+        return adaptThemeV2(ctx.theme);
+      }
+    },
+    mode: {
+      push: (name) => ctx.keymap.mode.push(name)
+    },
+    renderer: ctx.renderer,
+    client: ctx.client,
+    event: {
+      on: (name, callback) => {
+        if (name === "session.idle")
+          return ctx.data.on("session.idle", callback);
+        if (name === "session.status") {
+          const unsubs = [ctx.data.on("session.execution.started", callback), ctx.data.on("session.execution.succeeded", callback)];
+          return () => void unsubs.forEach((un) => un());
+        }
+        if (name === "session.error")
+          return ctx.data.on("session.execution.failed", callback);
+        if (name === "session.compacted")
+          return ctx.data.on("session.compaction.ended", callback);
+        return ctx.data.on(name, callback);
+      }
+    },
+    ui: {
+      dialog: {
+        clear: closeDialog,
+        get open() {
+          return dialogOpen;
+        },
+        replace: (render) => {
+          dialogOpen = true;
+          ctx.ui.dialog.show(render);
+        },
+        setSize: (_size) => ctx.ui.dialog.set({
+          size: "xlarge"
+        })
+      }
+    },
+    route: {
+      navigate: (name, params) => {
+        if (name === "session")
+          ctx.ui.router.navigate({
+            type: "session",
+            sessionID: params?.sessionID
+          });
+      }
+    }
+  };
+  const open = () => {
+    const previousFocus = ctx.renderer.currentFocusedRenderable;
+    dialogOpen = true;
+    ctx.ui.dialog.show(() => _$createComponent2(LoopDashboard, {
+      api: facade,
+      directory
+    }), () => {
+      dialogOpen = false;
+    });
+    ctx.ui.dialog.set({
+      size: "xlarge"
+    });
+    previousFocus?.blur();
+  };
+  const command = "opencode.loopd.dashboard";
+  let layerRegistered = false;
+  const unclaimSlot = ctx.ui.slot({
+    append: "app",
+    render: () => {
+      if (!layerRegistered) {
+        layerRegistered = true;
+        ctx.keymap.layer(() => ({
+          commands: [{
+            id: command,
+            title: "Loop Dashboard",
+            group: "Loop",
+            palette: true,
+            slash: {
+              name: "loop"
+            },
+            bind: "<leader>o",
+            run: open
+          }],
+          bindings: [command]
+        }));
+      }
+      return null;
+    }
+  });
+  return () => {
+    closeDialog();
+    unclaimSlot();
+  };
+};
 var plugin_default = {
   id: PLUGIN_ID,
-  tui
+  tui,
+  setup: v2setup
 };
 export {
   plugin_default as default

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@bojackduy/opencode-loopd",
-  "version": "1.9.6",
+  "version": "1.10.0",
   "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",
@@ -80,6 +80,7 @@
   },
   "devDependencies": {
     "@opencode-ai/plugin": "^1.18.30",
+    "@opencode/plugin": "^2.0.11",
     "@opentui/core": "^0.4.1",
     "@opentui/solid": "^0.4.1",
     "@types/bun": "^1.3.14",