@prevalentware/opencode-goal-plugin 0.1.29 → 0.1.31

package/README.md

@@ -38,7 +38,18 @@ Common use cases:
 
 ## Install
 
-Install locally for the current OpenCode project:
+Choose the instructions that match the CLI you run:
+
+| OpenCode version | How to identify it | Instructions |
+| --- | --- | --- |
+| OpenCode 1 stable | You run `opencode` and `opencode --version` prints `1.x` | [OpenCode 1](#opencode-1-stable) |
+| OpenCode 2 beta | You run `opencode2` | [OpenCode 2](#opencode-2-beta) |
+
+Do not mix the configuration formats. OpenCode 1 uses `plugin` and `tui.json`; OpenCode 2 uses `plugins` and the global `cli.json`.
+
+### OpenCode 1 Stable
+
+Install for the current project:
 
 ```bash
 opencode plugin @prevalentware/opencode-goal-plugin
@@ -52,9 +63,7 @@ opencode plugin -g @prevalentware/opencode-goal-plugin
 
 OpenCode detects both package entrypoints and writes the plugin into the server and TUI config targets.
 
-## Manual Config
-
-If you configure it manually, add the package to both config files.
+For manual installation, add the package to both V1 config files.
 
 `opencode.json`:
 
@@ -72,9 +81,35 @@ If you configure it manually, add the package to both config files.
 }
 ```
 
+### OpenCode 2 Beta
+
+Use this section only when running `opencode2`. Plugin release `0.1.30` and newer supports OpenCode 2 preview `0.0.0-next-17055` while remaining compatible with OpenCode 1.
+
+Add the package to both V2 plugin lists:
+
+`opencode.json`:
+
+```json
+{
+  "plugins": ["@prevalentware/opencode-goal-plugin"]
+}
+```
+
+`~/.config/opencode/cli.json`:
+
+```json
+{
+  "plugins": ["@prevalentware/opencode-goal-plugin"]
+}
+```
+
+OpenCode 2 does not read the V1 `tui.json` file. The server entrypoint comes from `opencode.json`, while the sidebar and palette integration come from `~/.config/opencode/cli.json`.
+
+OpenCode 2 plugin APIs are still beta. This package pins its V2 development contract to the preview version above; later previews may require a compatible plugin update. V2 currently supports the goal command, tools, persistent state, usage accounting, idle continuation, Plan-mode safety, and TUI sidebar/palette integration. Goal-specific compaction context and recovery of already-running child sessions after a plugin restart remain V1-only because the current V2 plugin context does not expose equivalent hooks or history queries.
+
 ## Options
 
-Server options can be configured in `opencode.json`:
+In OpenCode 1, server options use the package-and-options tuple in `opencode.json`:
 
 ```json
 {
@@ -100,6 +135,24 @@ Server options can be configured in `opencode.json`:
 }
 ```
 
+In OpenCode 2, use the plugin object form instead:
+
+```json
+{
+  "plugins": [
+    {
+      "package": "@prevalentware/opencode-goal-plugin",
+      "options": {
+        "auto_continue": true,
+        "max_auto_turns": 25,
+        "default_token_budget": 200000,
+        "restricted_agents": ["plan"]
+      }
+    }
+  ]
+}
+```
+
 Defaults:
 
 - `auto_continue`: `true`

package/dist/server.js

@@ -1043,7 +1043,7 @@ class TaskTracker {
   snapshotIdleHolds = new Map;
   settledSnapshotIdleTasks = new Set;
   noteTaskCall(input) {
-    if (typeof input.tool !== "string" || input.tool.toLowerCase() !== "task")
+    if (typeof input.tool !== "string" || !["task", "subagent"].includes(input.tool.toLowerCase()))
       return;
     if (typeof input.sessionID !== "string")
       return;
@@ -1051,7 +1051,7 @@ class TaskTracker {
       this.pendingTaskCalls.set(input.callID, input.sessionID);
   }
   noteTaskOutput(input, output) {
-    if (typeof input.tool !== "string" || input.tool.toLowerCase() !== "task")
+    if (typeof input.tool !== "string" || !["task", "subagent"].includes(input.tool.toLowerCase()))
       return;
     const parentSessionID = typeof input.callID === "string" ? this.pendingTaskCalls.get(input.callID) ?? input.sessionID : input.sessionID;
     if (typeof input.callID === "string")
@@ -1307,6 +1307,66 @@ function getGoalToolResult(goal) {
   }
   return JSON.stringify(result, null, 2);
 }
+async function createGoalFromTool(input, context, services) {
+  const planningOnly = services.isPlanAgent(context.agent);
+  const goal = await createGoal(context.sessionID, input.objective, {
+    tokenBudget: input.token_budget ?? services.options.default_token_budget ?? null,
+    maxAutoTurns: input.max_auto_turns ?? null,
+    maxDurationSeconds: input.max_duration_seconds ?? services.options.max_goal_duration_seconds ?? null,
+    noProgressTokenThreshold: services.options.no_progress_token_threshold ?? null,
+    maxNoProgressTurns: services.options.max_no_progress_turns ?? null,
+    agent: typeof context.agent === "string" ? context.agent : null,
+    initialStatus: planningOnly ? "paused" : "active"
+  });
+  return JSON.stringify(planningOnly ? { goal, plan_mode_notice: PLAN_MODE_CREATE_NOTICE } : { goal }, null, 2);
+}
+async function updateGoalObjectiveFromTool(input, context, services) {
+  const requested = input.status ?? "active";
+  const planningOnly = requested === "active" && services.isPlanAgent(context.agent);
+  const goal = await updateGoalObjective(context.sessionID, input.objective, planningOnly ? "paused" : requested, {
+    agent: typeof context.agent === "string" ? context.agent : null,
+    planModePause: planningOnly
+  });
+  return JSON.stringify(planningOnly ? { goal, plan_mode_notice: PLAN_MODE_CREATE_NOTICE } : { goal }, null, 2);
+}
+async function closeGoalFromTool(input, context) {
+  if (input.status === "complete") {
+    const goal2 = await completeGoal(context.sessionID, input.evidence ?? "");
+    const budget = goal2.tokenBudget == null ? "" : ` Token usage: ${goal2.tokensUsed}/${goal2.tokenBudget}.`;
+    const report2 = `Goal achieved. Time used: ${goal2.timeUsedSeconds} seconds.${budget} Evidence: ${goal2.completionEvidence}.`;
+    return JSON.stringify({ goal: goal2, completion_report: report2 }, null, 2);
+  }
+  const goal = await markGoalUnmet(context.sessionID, input.blocker ?? "");
+  const report = `Goal unmet. Time used: ${goal.timeUsedSeconds} seconds. Blocker: ${goal.blocker}.`;
+  return JSON.stringify({ goal, unmet_report: report }, null, 2);
+}
+async function updateGoalStatusFromTool(input, context, services) {
+  if (input.status === "active" && services.isPlanAgent(context.agent)) {
+    throw new Error("cannot resume the goal while the session is in Plan mode; ask the user to switch to Build mode and resume the goal from there");
+  }
+  const goal = await setGoalStatus(context.sessionID, input.status, typeof context.agent === "string" ? context.agent : null);
+  return JSON.stringify({ goal }, null, 2);
+}
+function v2ObjectSchema(properties, required = []) {
+  return {
+    type: "object",
+    properties,
+    required,
+    additionalProperties: false
+  };
+}
+function textFromToolResult(result) {
+  if (typeof result.output === "string")
+    return result.output;
+  if (typeof result.content === "string")
+    return result.content;
+  if (Array.isArray(result.content)) {
+    const text = result.content.map(textFromPart).filter(Boolean).join(`
+`).trim();
+    return text || undefined;
+  }
+  return;
+}
 var server = async ({ client }, options) => {
   const autoContinue = options?.auto_continue ?? true;
   const deferWhileTasksActive = options?.defer_while_tasks_active ?? true;
@@ -1323,19 +1383,7 @@ var server = async ({ client }, options) => {
   const busySessions = new Set;
   const planAgents = restrictedAgentSet(options);
   const isPlanAgent = (agent) => typeof agent === "string" && planAgents.has(agent.trim().toLowerCase());
-  async function createGoalFromTool(input, context) {
-    const planningOnly = isPlanAgent(context.agent);
-    const goal = await createGoal(context.sessionID, input.objective, {
-      tokenBudget: input.token_budget ?? options?.default_token_budget ?? null,
-      maxAutoTurns: input.max_auto_turns ?? null,
-      maxDurationSeconds: input.max_duration_seconds ?? options?.max_goal_duration_seconds ?? null,
-      noProgressTokenThreshold: options?.no_progress_token_threshold ?? null,
-      maxNoProgressTurns: options?.max_no_progress_turns ?? null,
-      agent: typeof context.agent === "string" ? context.agent : null,
-      initialStatus: planningOnly ? "paused" : "active"
-    });
-    return JSON.stringify(planningOnly ? { goal, plan_mode_notice: PLAN_MODE_CREATE_NOTICE } : { goal }, null, 2);
-  }
+  const goalServices = { options: options ?? {}, isPlanAgent };
   async function taskBlockStatus(sessionID) {
     if (!deferWhileTasksActive)
       return false;
@@ -1519,7 +1567,7 @@ var server = async ({ client }, options) => {
           max_duration_seconds: z.number().int().positive().nullable().optional().describe("Optional per-goal duration limit.")
         },
         async execute(args, context) {
-          return createGoalFromTool(args, context);
+          return createGoalFromTool(args, context, goalServices);
         }
       },
       set_goal: {
@@ -1531,7 +1579,7 @@ var server = async ({ client }, options) => {
           max_duration_seconds: z.number().int().positive().nullable().optional().describe("Optional per-goal duration limit.")
         },
         async execute(args, context) {
-          return createGoalFromTool(args, context);
+          return createGoalFromTool(args, context, goalServices);
         }
       },
       update_goal_objective: {
@@ -1541,14 +1589,7 @@ var server = async ({ client }, options) => {
           status: z.enum(["active", "paused"]).optional().describe("Whether the edited goal should be active or paused.")
         },
         async execute(args, context) {
-          const input = args;
-          const requested = input.status ?? "active";
-          const planningOnly = requested === "active" && isPlanAgent(context.agent);
-          const goal = await updateGoalObjective(context.sessionID, input.objective, planningOnly ? "paused" : requested, {
-            agent: typeof context.agent === "string" ? context.agent : null,
-            planModePause: planningOnly
-          });
-          return JSON.stringify(planningOnly ? { goal, plan_mode_notice: PLAN_MODE_CREATE_NOTICE } : { goal }, null, 2);
+          return updateGoalObjectiveFromTool(args, context, goalServices);
         }
       },
       update_goal: {
@@ -1559,16 +1600,7 @@ var server = async ({ client }, options) => {
           blocker: z.string().min(1).max(4000).optional().describe("Required when status is unmet. Explain the concrete blocker or impossibility.")
         },
         async execute(args, context) {
-          const input = args;
-          if (input.status === "complete") {
-            const goal2 = await completeGoal(context.sessionID, input.evidence ?? "");
-            const budget = goal2.tokenBudget == null ? "" : ` Token usage: ${goal2.tokensUsed}/${goal2.tokenBudget}.`;
-            const report2 = `Goal achieved. Time used: ${goal2.timeUsedSeconds} seconds.${budget} Evidence: ${goal2.completionEvidence}.`;
-            return JSON.stringify({ goal: goal2, completion_report: report2 }, null, 2);
-          }
-          const goal = await markGoalUnmet(context.sessionID, input.blocker ?? "");
-          const report = `Goal unmet. Time used: ${goal.timeUsedSeconds} seconds. Blocker: ${goal.blocker}.`;
-          return JSON.stringify({ goal, unmet_report: report }, null, 2);
+          return closeGoalFromTool(args, context);
         }
       },
       update_goal_status: {
@@ -1577,12 +1609,7 @@ var server = async ({ client }, options) => {
           status: z.enum(["active", "paused"]).describe("active resumes a goal; paused pauses it without clearing it.")
         },
         async execute(args, context) {
-          const input = args;
-          if (input.status === "active" && isPlanAgent(context.agent)) {
-            throw new Error("cannot resume the goal while the session is in Plan mode; ask the user to switch to Build mode and resume the goal from there");
-          }
-          const goal = await setGoalStatus(context.sessionID, input.status, typeof context.agent === "string" ? context.agent : null);
-          return JSON.stringify({ goal }, null, 2);
+          return updateGoalStatusFromTool(args, context, goalServices);
         }
       },
       clear_goal: {
@@ -1681,9 +1708,520 @@ var server = async ({ client }, options) => {
     }
   };
 };
+function v2ErrorLog(message, error) {
+  try {
+    console.error(`[opencode-goal-plugin] ${message}:`, error instanceof Error ? error.message : String(error));
+  } catch {}
+}
+async function setupV2(context) {
+  const options = context.options ?? {};
+  const autoContinue = options.auto_continue ?? true;
+  const deferWhileTasksActive = options.defer_while_tasks_active ?? true;
+  const maxAutoTurns = positiveIntegerOrNull2(options.max_auto_turns) ?? DEFAULT_MAX_AUTO_TURNS;
+  const minInterval = positiveIntegerOrNull2(options.min_continue_interval_seconds) ?? DEFAULT_CONTINUE_INTERVAL_SECONDS;
+  const maxTurnTimeMs = timeoutMillisecondsFromSeconds(options.max_turn_time);
+  const maxPromptFailures = positiveIntegerOrNull2(options.max_prompt_failures) ?? DEFAULT_MAX_PROMPT_FAILURES;
+  const registerCommand = options.register_command ?? true;
+  const commandName = commandNameFromOptions(options);
+  const taskTracker = new TaskTracker;
+  const taskDeferredSessions = new Set;
+  const scheduledContinuations = new Map;
+  const turnWatchdogs = new Map;
+  const busySessions = new Set;
+  const planAgents = restrictedAgentSet(options);
+  const isPlanAgent = (agent) => typeof agent === "string" && planAgents.has(agent.trim().toLowerCase());
+  const goalServices = { options, isPlanAgent };
+  const activeContinuationsV2 = new Set;
+  const latestStepBySession = new Map;
+  const stepTextBuffers = new Map;
+  const stepTokenSums = new Map;
+  const registrations = [];
+  function stepKey(sessionID, messageID2) {
+    return `${sessionID}\x00${messageID2}`;
+  }
+  async function sendContinuation2(sessionID, prompt, agent) {
+    await context.session.prompt({
+      sessionID,
+      text: prompt,
+      ...agent ? { agents: [{ name: agent }] } : {}
+    });
+  }
+  function taskBlockStatus(sessionID) {
+    if (!deferWhileTasksActive)
+      return false;
+    return {
+      blocked: taskTracker.hasBlockingTasks(sessionID),
+      retryAt: taskTracker.nextSnapshotIdleRetryAt(sessionID)
+    };
+  }
+  function clearTurnWatchdog(sessionID) {
+    const watchdog = turnWatchdogs.get(sessionID);
+    if (!watchdog)
+      return;
+    clearTimeout(watchdog.timer);
+    turnWatchdogs.delete(sessionID);
+  }
+  function armTurnWatchdog(sessionID) {
+    if (maxTurnTimeMs == null)
+      return;
+    clearTurnWatchdog(sessionID);
+    const watchdog = {
+      timer: setTimeout(() => void runTurnWatchdog(sessionID, watchdog), maxTurnTimeMs)
+    };
+    const maybeUnref = watchdog.timer;
+    if (typeof maybeUnref.unref === "function")
+      maybeUnref.unref();
+    turnWatchdogs.set(sessionID, watchdog);
+  }
+  async function runTurnWatchdog(sessionID, watchdog) {
+    let claimedContinuation = false;
+    try {
+      if (turnWatchdogs.get(sessionID) !== watchdog || !busySessions.has(sessionID))
+        return;
+      const goal = await getGoal(sessionID);
+      if (turnWatchdogs.get(sessionID) !== watchdog || !busySessions.has(sessionID))
+        return;
+      if (goal?.status !== "active" || isPlanAgent(goal.lastPromptAgent))
+        return;
+      const latestStep = latestStepBySession.get(sessionID);
+      if (isPlanAgent(latestStep?.agent))
+        return;
+      const taskStatus = taskBlockStatus(sessionID);
+      if (turnWatchdogs.get(sessionID) !== watchdog || !busySessions.has(sessionID))
+        return;
+      if (taskStatus && taskStatus.blocked)
+        return;
+      const current = await getGoal(sessionID);
+      if (turnWatchdogs.get(sessionID) !== watchdog || !busySessions.has(sessionID))
+        return;
+      if (current?.status !== "active" || isPlanAgent(current.lastPromptAgent) || activeContinuationsV2.has(sessionID))
+        return;
+      turnWatchdogs.delete(sessionID);
+      activeContinuationsV2.add(sessionID);
+      claimedContinuation = true;
+      await sendContinuation2(sessionID, continuationPrompt(current), current.lastPromptAgent ?? latestStep?.agent ?? null);
+    } catch (error) {
+      v2ErrorLog("Turn watchdog retry failed", error);
+    } finally {
+      if (claimedContinuation)
+        activeContinuationsV2.delete(sessionID);
+      if (turnWatchdogs.get(sessionID) === watchdog)
+        turnWatchdogs.delete(sessionID);
+    }
+  }
+  function scheduleSettledContinuation(sessionID, delayMs = TASK_SETTLE_DELAY_MS) {
+    if (scheduledContinuations.has(sessionID))
+      return;
+    const timer = setTimeout(() => {
+      scheduledContinuations.delete(sessionID);
+      runAutoContinue(sessionID, true);
+    }, Math.max(0, delayMs));
+    const maybeUnref = timer;
+    if (typeof maybeUnref.unref === "function")
+      maybeUnref.unref();
+    scheduledContinuations.set(sessionID, timer);
+  }
+  async function runAutoContinue(sessionID, fromTaskDeferral = false) {
+    if (busySessions.has(sessionID))
+      return;
+    if (activeContinuationsV2.has(sessionID))
+      return;
+    activeContinuationsV2.add(sessionID);
+    try {
+      const latestStep = latestStepBySession.get(sessionID);
+      if (latestStep?.messageID) {
+        taskTracker.observeAssistantMessage(sessionID, { info: { id: latestStep.messageID, role: "assistant" } });
+      }
+      const taskStatus = taskBlockStatus(sessionID);
+      if (taskStatus && taskStatus.blocked) {
+        taskDeferredSessions.add(sessionID);
+        if (taskStatus.retryAt != null)
+          scheduleSettledContinuation(sessionID, taskStatus.retryAt - Date.now());
+        return;
+      }
+      if (busySessions.has(sessionID))
+        return;
+      if (latestStep) {
+        await recordAssistantProgress(sessionID, {
+          messageID: latestStep.messageID,
+          text: latestStep.text,
+          outputTokens: latestStep.outputTokens,
+          noProgressTokenThreshold: positiveIntegerOrNull2(options.no_progress_token_threshold),
+          maxNoProgressTurns: positiveIntegerOrNull2(options.max_no_progress_turns),
+          evaluateContinuation: true
+        });
+      }
+      const current = await getGoal(sessionID);
+      if (!current)
+        return;
+      const latestTurnAgent = latestStep?.agent;
+      if (isPlanAgent(current.lastPromptAgent) || isPlanAgent(latestTurnAgent)) {
+        if (current.status === "active")
+          await pauseGoalForPlanMode(sessionID);
+        return;
+      }
+      if (busySessions.has(sessionID))
+        return;
+      if (!fromTaskDeferral && taskDeferredSessions.has(sessionID)) {
+        scheduleSettledContinuation(sessionID);
+        return;
+      }
+      taskDeferredSessions.delete(sessionID);
+      const goal = await reserveContinuation(sessionID, maxAutoTurns, minInterval);
+      if (!goal)
+        return;
+      await sendContinuation2(sessionID, goal.status === "active" ? continuationPrompt(goal) : limitPrompt(goal), goal.lastPromptAgent ?? latestTurnAgent ?? null);
+      await recordContinuationResult(sessionID, "success", maxPromptFailures);
+    } catch (error) {
+      await recordContinuationResult(sessionID, "failure", maxPromptFailures);
+      v2ErrorLog("Auto-continue failed", error);
+    } finally {
+      activeContinuationsV2.delete(sessionID);
+    }
+  }
+  async function handleV2Event(event) {
+    const data = event.data;
+    const sessionID = typeof data.sessionID === "string" ? data.sessionID : undefined;
+    switch (event.type) {
+      case "session.created": {
+        const parentID = data.parentID;
+        if (sessionID && typeof parentID === "string") {
+          taskTracker.observeSessionCreated({ properties: { info: { id: sessionID, parentID } } });
+        }
+        return;
+      }
+      case "session.status": {
+        const status = data.status;
+        if (sessionID && isRecord(status) && typeof status.type === "string") {
+          if (status.type === "busy")
+            busySessions.add(sessionID);
+          if (status.type === "busy")
+            armTurnWatchdog(sessionID);
+          if (status.type === "idle") {
+            busySessions.delete(sessionID);
+            clearTurnWatchdog(sessionID);
+          }
+          if (status.type === "retry")
+            clearTurnWatchdog(sessionID);
+          taskTracker.observeSessionStatus(sessionID, status.type);
+        }
+        if (autoContinue && sessionID && isRecord(status) && status.type === "idle") {
+          await runAutoContinue(sessionID);
+        }
+        return;
+      }
+      case "session.idle": {
+        if (sessionID) {
+          busySessions.delete(sessionID);
+          clearTurnWatchdog(sessionID);
+          taskTracker.observeSessionStatus(sessionID, "idle");
+        }
+        if (autoContinue && sessionID)
+          await runAutoContinue(sessionID);
+        return;
+      }
+      case "session.deleted": {
+        if (!sessionID)
+          return;
+        busySessions.delete(sessionID);
+        clearTurnWatchdog(sessionID);
+        const scheduled = scheduledContinuations.get(sessionID);
+        if (scheduled)
+          clearTimeout(scheduled);
+        scheduledContinuations.delete(sessionID);
+        taskDeferredSessions.delete(sessionID);
+        taskTracker.observeSessionDeleted(sessionID);
+        latestStepBySession.delete(sessionID);
+        stepTokenSums.delete(sessionID);
+        for (const key of [...stepTextBuffers.keys()]) {
+          if (key.startsWith(`${sessionID}\x00`))
+            stepTextBuffers.delete(key);
+        }
+        return;
+      }
+      case "session.agent.selected": {
+        if (sessionID && typeof data.agent === "string")
+          await recordPromptAgent(sessionID, data.agent);
+        return;
+      }
+      case "session.step.started": {
+        if (!sessionID || typeof data.assistantMessageID !== "string")
+          return;
+        const messageID2 = data.assistantMessageID;
+        const agent = typeof data.agent === "string" ? data.agent : undefined;
+        if (agent)
+          await recordPromptAgent(sessionID, agent);
+        taskTracker.observeAssistantMessage(sessionID, {
+          info: { id: messageID2, role: "assistant", time: { completed: event.created } }
+        });
+        if (!stepTextBuffers.has(stepKey(sessionID, messageID2)))
+          stepTextBuffers.set(stepKey(sessionID, messageID2), "");
+        latestStepBySession.set(sessionID, { messageID: messageID2, agent, text: "", outputTokens: null });
+        return;
+      }
+      case "session.text.delta": {
+        if (sessionID && typeof data.assistantMessageID === "string" && typeof data.delta === "string") {
+          const key = stepKey(sessionID, data.assistantMessageID);
+          stepTextBuffers.set(key, (stepTextBuffers.get(key) ?? "") + data.delta);
+        }
+        return;
+      }
+      case "session.text.ended": {
+        if (sessionID && typeof data.assistantMessageID === "string" && typeof data.text === "string") {
+          stepTextBuffers.set(stepKey(sessionID, data.assistantMessageID), data.text);
+        }
+        return;
+      }
+      case "session.step.ended": {
+        if (!sessionID || typeof data.assistantMessageID !== "string")
+          return;
+        const messageID2 = data.assistantMessageID;
+        const tokens = tokensFromRecord(data.tokens);
+        if (typeof tokens === "number") {
+          const sum = (stepTokenSums.get(sessionID) ?? 0) + tokens;
+          stepTokenSums.set(sessionID, sum);
+          await accountUsage(sessionID, sum);
+        }
+        const text = stepTextBuffers.get(stepKey(sessionID, messageID2)) ?? "";
+        stepTextBuffers.delete(stepKey(sessionID, messageID2));
+        const outputTokens = outputTokensFromRecord(data.tokens) ?? null;
+        await recordAssistantProgress(sessionID, {
+          messageID: messageID2,
+          text,
+          outputTokens,
+          noProgressTokenThreshold: positiveIntegerOrNull2(options.no_progress_token_threshold),
+          maxNoProgressTurns: positiveIntegerOrNull2(options.max_no_progress_turns)
+        });
+        latestStepBySession.set(sessionID, {
+          messageID: messageID2,
+          agent: latestStepBySession.get(sessionID)?.agent,
+          text,
+          outputTokens
+        });
+        return;
+      }
+      case "session.step.failed": {
+        if (!sessionID || typeof data.assistantMessageID !== "string")
+          return;
+        const messageID2 = data.assistantMessageID;
+        const tokens = tokensFromRecord(data.tokens);
+        if (typeof tokens === "number") {
+          const sum = (stepTokenSums.get(sessionID) ?? 0) + tokens;
+          stepTokenSums.set(sessionID, sum);
+          await accountUsage(sessionID, sum);
+        }
+        const text = stepTextBuffers.get(stepKey(sessionID, messageID2)) ?? "";
+        stepTextBuffers.delete(stepKey(sessionID, messageID2));
+        const outputTokens = outputTokensFromRecord(data.tokens) ?? null;
+        await recordAssistantProgress(sessionID, {
+          messageID: messageID2,
+          text,
+          outputTokens,
+          noProgressTokenThreshold: positiveIntegerOrNull2(options.no_progress_token_threshold),
+          maxNoProgressTurns: positiveIntegerOrNull2(options.max_no_progress_turns)
+        });
+        latestStepBySession.set(sessionID, {
+          messageID: messageID2,
+          agent: latestStepBySession.get(sessionID)?.agent,
+          text,
+          outputTokens
+        });
+        return;
+      }
+      case "session.usage.updated": {
+        if (!sessionID)
+          return;
+        const tokens = tokensFromRecord(data.tokens);
+        if (typeof tokens === "number")
+          await accountUsage(sessionID, tokens);
+        return;
+      }
+    }
+  }
+  if (registerCommand) {
+    registrations.push(await context.command.transform((draft) => {
+      if (draft.get(commandName))
+        return;
+      draft.update(commandName, (command) => {
+        command.description = "Set or view the long-running session goal";
+        command.template = goalCommandTemplate(commandName);
+      });
+    }));
+  }
+  registrations.push(await context.tool.transform((draft) => {
+    for (const tool of goalToolsV2(goalServices))
+      draft.add(tool);
+  }));
+  registrations.push(await context.tool.hook("execute.before", (input) => {
+    taskTracker.noteTaskCall({ tool: input.tool, sessionID: input.sessionID, callID: input.id });
+  }));
+  registrations.push(await context.tool.hook("execute.after", (input) => {
+    if (input.status !== "completed")
+      return;
+    taskTracker.noteTaskOutput({ tool: input.tool, sessionID: input.sessionID, callID: input.id }, { output: textFromToolResult(input.result) });
+  }));
+  registrations.push(await context.session.hook("context", (sessionContext) => {
+    const reminder = systemReminder();
+    if (sessionContext.system.some((part) => part.type === "text" && part.text.includes(reminder)))
+      return;
+    sessionContext.system.push({ type: "text", text: reminder });
+  }));
+  const abortController = new AbortController;
+  let eventIterator;
+  const consumer = (async () => {
+    const subscription = context.event.subscribe({ signal: abortController.signal });
+    const iterator = subscription[Symbol.asyncIterator]();
+    eventIterator = iterator;
+    try {
+      while (true) {
+        const { done, value } = await iterator.next();
+        if (done)
+          break;
+        await handleV2Event(value);
+      }
+    } catch (error) {
+      if (!abortController.signal.aborted)
+        v2ErrorLog("V2 event consumer stopped", error);
+    }
+  })();
+  return async () => {
+    abortController.abort();
+    for (const timer of scheduledContinuations.values())
+      clearTimeout(timer);
+    scheduledContinuations.clear();
+    for (const watchdog of turnWatchdogs.values())
+      clearTimeout(watchdog.timer);
+    turnWatchdogs.clear();
+    activeContinuationsV2.clear();
+    for (const registration of registrations)
+      await registration.dispose();
+    const termination = Promise.allSettled([consumer, eventIterator?.return?.()]);
+    await Promise.race([termination, new Promise((resolve) => setTimeout(resolve, 2000))]);
+  };
+}
+function goalToolsV2(services) {
+  return [
+    {
+      name: "get_goal",
+      description: "Get the current goal for this OpenCode session, including status, observed token usage, elapsed-time usage, budgets, checkpoints, and history.",
+      input: v2ObjectSchema({}),
+      options: { codemode: false },
+      execute: async (_args, toolContext) => ({
+        content: await getGoalToolResult(await getGoal(toolContext.sessionID))
+      })
+    },
+    {
+      name: "get_goal_history",
+      description: "Get the current goal lifecycle history and recent checkpoints for this OpenCode session.",
+      input: v2ObjectSchema({}),
+      options: { codemode: false },
+      execute: async (_args, toolContext) => {
+        const goal = await getGoal(toolContext.sessionID);
+        return { content: JSON.stringify({ goal, history_report: formatGoalHistory(goal) }, null, 2) };
+      }
+    },
+    {
+      name: "create_goal",
+      description: "Create a goal only when explicitly requested by the user or system/developer instructions; do not infer goals from ordinary tasks. Fails if a non-complete goal exists. While the session is in Plan mode, the goal is recorded as paused and execution requires the user to switch to Build mode.",
+      input: v2ObjectSchema({
+        objective: { type: "string", minLength: 1, maxLength: 4000, description: "The concrete objective to start pursuing." },
+        token_budget: { type: ["integer", "null"], minimum: 1, description: "Optional positive token budget." },
+        max_auto_turns: { type: ["integer", "null"], minimum: 1, description: "Optional per-goal auto-continue limit." },
+        max_duration_seconds: { type: ["integer", "null"], minimum: 1, description: "Optional per-goal duration limit." }
+      }, ["objective"]),
+      options: { codemode: false },
+      execute: async (args, toolContext) => ({
+        content: await createGoalFromTool(args, toolContext, services)
+      })
+    },
+    {
+      name: "set_goal",
+      description: "Set a new goal when the user explicitly asks the agent to formulate and set its own goal. The model should write the objective itself based on the user's explicit request. Fails if a non-complete goal exists. While the session is in Plan mode, the goal is recorded as paused and execution requires the user to switch to Build mode.",
+      input: v2ObjectSchema({
+        objective: {
+          type: "string",
+          minLength: 1,
+          maxLength: 4000,
+          description: "The model-formulated concrete objective to start pursuing."
+        },
+        token_budget: { type: ["integer", "null"], minimum: 1, description: "Optional positive token budget." },
+        max_auto_turns: { type: ["integer", "null"], minimum: 1, description: "Optional per-goal auto-continue limit." },
+        max_duration_seconds: { type: ["integer", "null"], minimum: 1, description: "Optional per-goal duration limit." }
+      }, ["objective"]),
+      options: { codemode: false },
+      execute: async (args, toolContext) => ({
+        content: await createGoalFromTool(args, toolContext, services)
+      })
+    },
+    {
+      name: "update_goal_objective",
+      description: "Edit the current OpenCode goal objective when the user explicitly asks to edit or replace it.",
+      input: v2ObjectSchema({
+        objective: { type: "string", minLength: 1, maxLength: 4000, description: "The updated concrete objective." },
+        status: { type: "string", enum: ["active", "paused"], description: "Whether the edited goal should be active or paused." }
+      }, ["objective"]),
+      options: { codemode: false },
+      execute: async (args, toolContext) => ({
+        content: await updateGoalObjectiveFromTool(args, toolContext, services)
+      })
+    },
+    {
+      name: "update_goal",
+      description: "Close the existing goal only after an audit against real evidence. Use status complete only when the objective is achieved and no required work remains, and include evidence. Use status unmet only when the objective cannot be achieved or is blocked, and include the blocker. Do not close a goal merely because work is stopping.",
+      input: v2ObjectSchema({
+        status: {
+          type: "string",
+          enum: ["complete", "unmet"],
+          description: "Required. complete means achieved; unmet means blocked or impossible."
+        },
+        evidence: {
+          type: "string",
+          minLength: 1,
+          maxLength: 4000,
+          description: "Required when status is complete. Summarize the concrete evidence verified."
+        },
+        blocker: {
+          type: "string",
+          minLength: 1,
+          maxLength: 4000,
+          description: "Required when status is unmet. Explain the concrete blocker or impossibility."
+        }
+      }, ["status"]),
+      options: { codemode: false },
+      execute: async (args, toolContext) => ({
+        content: await closeGoalFromTool(args, toolContext)
+      })
+    },
+    {
+      name: "update_goal_status",
+      description: "Pause or resume the current OpenCode goal when the user explicitly asks to pause or resume it. Resuming is not allowed while the session is in Plan mode; the user must switch to Build mode first.",
+      input: v2ObjectSchema({
+        status: {
+          type: "string",
+          enum: ["active", "paused"],
+          description: "active resumes a goal; paused pauses it without clearing it."
+        }
+      }, ["status"]),
+      options: { codemode: false },
+      execute: async (args, toolContext) => ({
+        content: await updateGoalStatusFromTool(args, toolContext, services)
+      })
+    },
+    {
+      name: "clear_goal",
+      description: "Clear the current OpenCode goal for this session when the user explicitly asks to clear it.",
+      input: v2ObjectSchema({}),
+      options: { codemode: false },
+      execute: async (_args, toolContext) => ({
+        content: JSON.stringify({ cleared: await clearGoal(toolContext.sessionID) }, null, 2)
+      })
+    }
+  ];
+}
 var server_default = {
   id: "local.goal-mode.server",
-  server
+  server,
+  setup: setupV2
 };
 export {
   server_default as default

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prevalentware/opencode-goal-plugin",
-  "version": "0.1.29",
+  "version": "0.1.31",
   "description": "OpenCode goal plugin that adds Codex-style long-running goal mode, /goal commands, persistence, and TUI status for AI coding agents.",
   "keywords": [
     "opencode",
@@ -61,6 +61,7 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
+    "@opencode-ai/plugin-v2": "npm:@opencode-ai/plugin@0.0.0-next-17055",
     "@opentui/core": "^0.4.0",
     "@types/bun": "^1.3.13",
     "eslint": "^10.3.0",

package/src/tui.ts

@@ -1,6 +1,8 @@
 import type { TuiCommand, TuiPlugin, TuiPluginApi, TuiPluginModule } from "@opencode-ai/plugin/tui"
+import type { Plugin as TuiPluginV2 } from "@opencode-ai/plugin-v2/tui"
+import type { SessionMessageInfo } from "@opencode-ai/client"
 import { createElement, insert, setProp } from "@opentui/solid"
-import { createSignal, onCleanup } from "solid-js"
+import { createEffect, createMemo, createSignal, onCleanup } from "solid-js"
 
 type GoalCheckpoint = {
   summary: string
@@ -63,7 +65,7 @@ type GoalSessionState = {
   goal: GoalSnapshot | null
   messageIndex: number
 }
-type ElementChild = string | number | boolean | null | undefined | object | (() => string)
+type ElementChild = string | number | boolean | null | undefined | object | (() => ElementChild)
 
 type ModernTuiApi = TuiPluginApi & {
   keymap?: {
@@ -83,6 +85,17 @@ type ModernTuiApi = TuiPluginApi & {
 
 const goalCache = new Map<string, GoalSnapshot>()
 
+const GOAL_TOOL_NAMES: readonly string[] = [
+  "get_goal",
+  "get_goal_history",
+  "create_goal",
+  "set_goal",
+  "update_goal",
+  "update_goal_objective",
+  "update_goal_status",
+  "clear_goal",
+]
+
 function element(tag: string, props: Record<string, unknown>, children: ElementChild[] = []) {
   const node = createElement(tag)
   for (const [key, value] of Object.entries(props)) if (value !== undefined) setProp(node, key, value)
@@ -280,19 +293,7 @@ function isGoalSnapshot(value: unknown): value is GoalSnapshot {
 
 function parseGoalToolOutput(part: GoalToolPart): GoalSnapshot | null | undefined {
   if (part.type !== "tool") return undefined
-  if (
-    ![
-      "get_goal",
-      "get_goal_history",
-      "create_goal",
-      "set_goal",
-      "update_goal",
-      "update_goal_objective",
-      "update_goal_status",
-      "clear_goal",
-    ].includes(part.tool ?? "")
-  )
-    return undefined
+  if (!GOAL_TOOL_NAMES.includes(part.tool ?? "")) return undefined
   if (part.state?.status !== "completed") return undefined
   if (part.tool === "clear_goal") return null
   if (typeof part.state.output !== "string") return undefined
@@ -419,9 +420,171 @@ const tui: TuiPlugin = async (api) => {
   })
 }
 
-const plugin: TuiPluginModule = {
+// --- V2 TUI plugin ---
+
+/**
+ * Scans the V2 session message list for the newest completed goal tool result.
+ * Assistant tool content entries carry `name` plus a completed `state.content`
+ * array; goal tool output is serialized in text ToolContent parts. Returns
+ * `undefined` when no goal tool output is present (so callers can fall back to
+ * a cached snapshot), `null` after a completed clear_goal, or the snapshot.
+ */
+export function goalFromV2Messages(messages: readonly SessionMessageInfo[]): GoalSnapshot | null | undefined {
+  for (let messageIndex = messages.length - 1; messageIndex >= 0; messageIndex -= 1) {
+    const message = messages[messageIndex]
+    if (!message || message.type !== "assistant") continue
+    const parts = message.content
+    for (let partIndex = parts.length - 1; partIndex >= 0; partIndex -= 1) {
+      const part = parts[partIndex]
+      if (!part || part.type !== "tool") continue
+      if (!GOAL_TOOL_NAMES.includes(part.name)) continue
+      if (part.state.status !== "completed") continue
+      if (part.name === "clear_goal") return null
+      const textContent = part.state.content.find((entry) => entry.type === "text")
+      if (!textContent) continue
+      try {
+        const parsed: unknown = JSON.parse(textContent.text)
+        if (!isRecord(parsed)) continue
+        if (parsed.goal === null) return null
+        if (isGoalSnapshot(parsed.goal)) return parsed.goal
+      } catch {
+        // Malformed tool output: keep scanning older tool entries.
+      }
+    }
+  }
+  return undefined
+}
+
+function currentSessionIDV2(api: TuiPluginV2.Context) {
+  const route = api.ui.router.current()
+  if (route.type !== "session") return undefined
+  return route.sessionID
+}
+
+function toastV2(api: TuiPluginV2.Context, message: string, variant: "info" | "success" | "warning" | "error" = "info") {
+  api.ui.toast.show({ title: "Goal", message, variant, duration: 2500 })
+}
+
+async function showSummaryV2(api: TuiPluginV2.Context, sessionID: string, goal: GoalSnapshot | null) {
+  const options = [
+    { title: "Refresh", value: "refresh", description: "Ask the agent to read the current goal state" },
+    ...(goal
+      ? [
+          { title: "History", value: "history", description: "Ask the agent to show lifecycle history" },
+          ...(goal.status === "active"
+            ? [{ title: "Pause", value: "pause", description: "Pause auto-continuation without clearing" }]
+            : []),
+          ...(goal.status === "paused" || goal.status === "budgetLimited" || goal.status === "usageLimited"
+            ? [{ title: "Resume", value: "resume", description: "Resume the goal and continue" }]
+            : []),
+          { title: "Clear", value: "clear", description: "Ask the agent to clear this session goal" },
+        ]
+      : []),
+  ]
+  api.ui.dialog.set({ size: "large" })
+  const selected = await api.ui.dialog.select({ title: "Goal", placeholder: formatGoal(goal), options })
+  const prompt = selected === "refresh" ? refreshGoalPrompt()
+    : selected === "history" ? historyGoalPrompt()
+    : selected === "pause" ? pauseGoalPrompt()
+    : selected === "resume" ? resumeGoalPrompt()
+    : selected === "clear" ? clearGoalPrompt()
+    : undefined
+  if (!prompt) return
+  try {
+    await api.client.session.prompt({ sessionID, text: prompt })
+  } catch (error) {
+    toastV2(api, error instanceof Error ? error.message : String(error), "error")
+  }
+}
+
+function GoalSidebarV2(api: TuiPluginV2.Context, sessionID: string) {
+  const theme = api.theme
+  const [cache, setCache] = api.storage.memory<{ goal: GoalSnapshot | null }>(`goal-mode.v2.${sessionID}`, {
+    initial: { goal: null },
+  })
+  const goal = createMemo<GoalSnapshot | null>(() => {
+    const found = goalFromV2Messages(api.data.session.message.list(sessionID))
+    return found === undefined ? cache.goal : found
+  })
+  createEffect(() =>
+    setCache((draft) => {
+      draft.goal = goal()
+    }),
+  )
+
+  const [nowSeconds, setNowSeconds] = createSignal(currentEpochSeconds())
+  createEffect(() => {
+    if (goal()?.status !== "active") return
+    const timer = setInterval(() => setNowSeconds(currentEpochSeconds()), 1000)
+    onCleanup(() => clearInterval(timer))
+  })
+  return box({}, [() => {
+    const snapshot = goal()
+    if (!snapshot) return null
+    if (snapshot.status === "complete" || snapshot.status === "unmet") {
+      const elapsed = liveTimeUsedSeconds(snapshot)
+      return text({ fg: snapshot.status === "complete" ? theme.primary : theme.textMuted }, [
+        `${snapshot.status === "complete" ? "Goal achieved" : "Goal unmet"} (${formatDurationBadge(elapsed)})`,
+      ])
+    }
+    return box({}, [
+      text({ fg: theme.text }, ["Goal"]),
+      text({ fg: theme.textMuted }, [`Status: ${snapshot.status}`]),
+      text({ fg: theme.textMuted }, [`Time: ${formatDuration(liveTimeUsedSeconds(snapshot, nowSeconds()))}`]),
+      text({ fg: theme.textMuted }, [`Tokens: ${snapshot.tokensUsed}${snapshot.tokenBudget == null ? "" : `/${snapshot.tokenBudget}`}`]),
+      text({ fg: theme.textMuted }, [`Auto-continues: ${snapshot.autoTurns}${snapshot.maxAutoTurns == null ? "" : `/${snapshot.maxAutoTurns}`}`]),
+      ...(snapshot.lastCheckpoint ? [text({ fg: theme.textMuted }, [`Checkpoint: ${snapshot.lastCheckpoint.summary}`])] : []),
+      ...(snapshot.stopReason ? [text({ fg: theme.textMuted }, [`Stop: ${snapshot.stopReason}`])] : []),
+      ...(snapshot.lastStatus ? [text({ fg: theme.textMuted }, [snapshot.lastStatus])] : []),
+      text({ fg: theme.textMuted }, [snapshot.objective]),
+    ])
+  }])
+}
+
+function GoalKeymapLayerV2(api: TuiPluginV2.Context) {
+  api.keymap.layer(() => ({
+    commands: [
+      {
+        id: "goal.show",
+        title: "Goal",
+        description: "View, pause, resume, or clear the long-running session goal",
+        group: "Goal",
+        palette: true,
+        run: () => {
+          const sessionID = currentSessionIDV2(api)
+          if (!sessionID) {
+            toastV2(api, "Open a session before viewing goal state.", "warning")
+            return
+          }
+          void showSummaryV2(api, sessionID, goalFromV2Messages(api.data.session.message.list(sessionID)) ?? null)
+        },
+      },
+    ],
+  }))
+  return null
+}
+
+/**
+ * V2 TUI setup: registers the goal sidebar via `ui.slot` and a palette command
+ * through a keymap layer mounted from the global `app` slot. `keymap.layer`
+ * must be invoked from a Solid component scope, so the layer lives inside a
+ * component rendered by the `app` slot; its cleanup is owned by that component
+ * and released automatically when the slot unmounts. The setup cleanup only
+ * needs to dispose the two `ui.slot` registrations.
+ */
+export function setupTuiV2(context: TuiPluginV2.Context): TuiPluginV2.Cleanup {
+  const offSidebar = context.ui.slot("sidebar.content", (props) => GoalSidebarV2(context, props.sessionID))
+  const offApp = context.ui.slot("app", () => GoalKeymapLayerV2(context))
+  return () => {
+    offSidebar()
+    offApp()
+  }
+}
+
+const plugin: TuiPluginModule & TuiPluginV2.Definition = {
   id: "local.goal-mode.tui",
   tui,
+  setup: setupTuiV2,
 }
 
 export default plugin