@prevalentware/opencode-goal-plugin 0.1.55 → 0.1.57

package/README.md

@@ -259,6 +259,8 @@ Ordinary fsync improves crash consistency but is not `F_FULLFSYNC`, so sudden po
 
 The plugin migrates version 1 state files to version 2 on the next write. Version 2 adds stable goal identities, the terminal `cancelled` status, and compact archives. Older plugin versions intentionally reject version 2 instead of silently dropping archived history on their next write; back up or isolate `OPENCODE_GOAL_STATE_PATH` before downgrading.
 
+Planless version 3 files from the planning development build are also compatible: empty `plan: null` and `planRevision: 0` metadata survives reads, updates, and archival, and writes retain version 3. This prevents an otherwise valid shared state file from breaking ordinary OpenCode tool calls in sessions without a goal. Populated plans, nonzero planning revisions, and unknown future versions remain rejected without rewriting the file; use the corresponding planning build or an isolated `OPENCODE_GOAL_STATE_PATH` for those files.
+
 If the rename succeeds but syncing the parent directory reports a genuine I/O error, the mutation reports a write failure even though the new valid state may already be present. This avoids claiming durability that the filesystem did not confirm.
 
 If a non-empty state file contains only whitespace, a UTF-8 BOM, or NUL bytes after an interrupted write, the next mutation preserves its exact contents beside the state file as `goals.json.corrupt-<timestamp>-<uuid>` before writing recovered state. If another process replaces the state during recovery, the mutation refuses to overwrite that newer content. If the quarantine copy itself cannot be created, the plugin reports the failure and continues recovery rather than making every prompt fail indefinitely. OpenCode 1 also records the quarantine outcome and path through its application log so the data-loss event remains discoverable.
@@ -324,4 +326,7 @@ The goal sidebar shows the current status, elapsed time, token usage, auto-conti
 
 Cancelling an active goal from an ACP client is durable when OpenCode emits the user-cancellation events described above. The plugin prevents subsequent goal continuations, including callbacks still preparing a prompt when cancellation arrives. OpenCode owns cancellation of in-flight model requests, tools, subprocesses, and already submitted prompts; the plugin cannot guarantee process termination if the host does not abort them or does not publish a cancellation signal. It does not interpret ordinary idle events, provider-error text, or completed tool calls as user cancellation.
 
-Goal lifetime and ACP prompt-turn lifetime are separate. The plugin continues an active goal across successful executions, but does not control the ACP adapter's response to `session/prompt`. A host that returns `end_turn` after the initial execution can therefore show an idle client while subsequent goal work runs. In an isolated OpenCode 2.0.21 ACP test, registered `/goal` commands returned `end_turn` while their submitted execution was still running; a normal `session/prompt` remained open and returned `cancelled` after Cancel. Keeping that ACP request open across goal continuations, and exposing structured goal plans as ACP `plan` updates, requires host integration. Request or phase completion alone must not mark a goal complete. Long-running goals remain supported within the configured budgets; this cancellation handling adds no timeout.
+Registered `/goal <objective>` and `/resume_goal` commands use the host's public session-wait API to remain pending across automatic continuations until the goal stops, completes, reaches a safety limit, or auto-continuation is disabled. Hosts without that API keep their previous admission behavior. The ACP adapter must also stream each execution owned by the command: an adapter that ends its event consumer after the first execution can still hide later work. Ordinary prompts retain their host-defined turn lifetime.
+
+
+The Promise-based persistence layer uses Effect 3 under the private `effect-goal-state` npm alias. This keeps it separate from modern OpenCode's shared Effect 4 SDK runtime. It remains an external runtime dependency, and no private Effect values cross the plugin API.

package/dist/server.js

@@ -6,7 +6,7 @@ import { z } from "zod";
 import { randomUUID as randomUUID2 } from "crypto";
 import { mkdir, readFile } from "fs/promises";
 import { dirname as dirname2 } from "path";
-import { Data, Effect, Schema } from "effect";
+import { Data, Effect, Schema } from "effect-goal-state";
 
 // src/atomic-write.ts
 import { randomUUID } from "crypto";
@@ -179,6 +179,8 @@ var GoalSchema = Schema.Struct({
   id: Schema.optionalWith(Schema.String, { default: () => "" }),
   sessionID: Schema.String,
   objective: Schema.String,
+  plan: Schema.optional(Schema.Null),
+  planRevision: Schema.optional(Schema.Literal(0)),
   status: Schema.Literal("active", "paused", "budgetLimited", "usageLimited", "complete", "unmet", "cancelled"),
   tokenBudget: NullableNumber,
   tokensUsed: Schema.Number,
@@ -216,6 +218,8 @@ var ArchivedGoalSchema = Schema.Struct({
   id: Schema.String,
   sessionID: Schema.String,
   objective: Schema.String,
+  plan: Schema.optional(Schema.Null),
+  planRevision: Schema.optional(Schema.Literal(0)),
   status: Schema.Literal("active", "paused", "budgetLimited", "usageLimited", "complete", "unmet", "cancelled"),
   tokenBudget: NullableNumber,
   tokensUsed: Schema.Number,
@@ -234,7 +238,7 @@ var LegacyStateSchema = Schema.Struct({
   goals: Schema.Record({ key: Schema.String, value: GoalSchema })
 });
 var StateSchema = Schema.Struct({
-  version: Schema.Literal(2),
+  version: Schema.Literal(2, 3),
   goals: Schema.Record({ key: Schema.String, value: GoalSchema }),
   archives: Schema.optionalWith(Schema.Record({ key: Schema.String, value: Schema.Array(ArchivedGoalSchema) }), {
     default: () => ({})
@@ -551,6 +555,8 @@ function snapshot(goal) {
     id: goal.id,
     sessionID: goal.sessionID,
     objective: goal.objective,
+    ...goal.plan === null ? { plan: null } : {},
+    ...goal.planRevision === 0 ? { planRevision: 0 } : {},
     status: goal.status,
     tokenBudget: goal.tokenBudget,
     tokensUsed: goal.tokensUsed,
@@ -678,6 +684,8 @@ function archivedGoal(goal) {
     id: goal.id,
     sessionID: goal.sessionID,
     objective: summarizeText(goal.objective, MAX_ARCHIVED_OBJECTIVE_CHARS),
+    ...goal.plan === null ? { plan: null } : {},
+    ...goal.planRevision === 0 ? { planRevision: 0 } : {},
     status: goal.status,
     tokenBudget: goal.tokenBudget,
     tokensUsed: goal.tokensUsed,
@@ -3736,6 +3744,7 @@ async function setupV2(context) {
   };
   const registrations = [];
   let disposed = false;
+  let eventConsumerStopped = false;
   function stepKey(sessionID, messageID) {
     return `${sessionID}\x00${messageID}`;
   }
@@ -4383,7 +4392,7 @@ async function setupV2(context) {
         draft.add({
           name: command.name,
           description: command.description,
-          execute: async (input) => {
+          execute: async (input, execution) => {
             markSessionOwnership(input.sessionID, true);
             if (command.action === "pause") {
               const goal = await getGoal(input.sessionID);
@@ -4406,12 +4415,63 @@ async function setupV2(context) {
                 ...skills ? { skills: skills.map(stripMention) } : {}
               };
             }
-            await context.session.prompt({
-              ...forwardedPrompt,
-              sessionID: input.sessionID,
-              text: command.template.replaceAll("$ARGUMENTS", () => escapeXmlText2(input.prompt.text.trim())),
-              delivery: input.delivery
-            });
+            const args = input.prompt.text.trim().toLowerCase();
+            const controlOnly = /^(history|status|show|current|pause|stop|cancel|clear|off|reset|none|edit)(?:\s|$)/.test(args);
+            const pursue = command.action === "resume" || command.action === "goal" && args !== "" && !controlOnly;
+            const signal = execution?.signal ? AbortSignal.any([abortController.signal, execution.signal]) : abortController.signal;
+            let admitted = false;
+            let cancellation;
+            const cancel = () => {
+              if (!pursue || disposed)
+                return;
+              goalServices.stopAutonomy?.(input.sessionID);
+              cancellation = cancelActiveGoal(input.sessionID).catch((error) => v2ErrorLog("Failed to persist command cancellation", error));
+            };
+            execution?.signal?.addEventListener("abort", cancel, { once: true });
+            try {
+              if (execution?.signal?.aborted) {
+                cancel();
+                return;
+              }
+              await context.session.prompt({
+                ...forwardedPrompt,
+                sessionID: input.sessionID,
+                text: command.template.replaceAll("$ARGUMENTS", () => escapeXmlText2(input.prompt.text.trim())),
+                delivery: input.delivery
+              });
+              admitted = true;
+              if (pursue && typeof context.session.wait === "function") {
+                let pursuedGoalID;
+                do {
+                  await context.session.wait({ sessionID: input.sessionID }, { signal });
+                  if (eventConsumerStopped)
+                    throw new Error("goal event stream stopped");
+                  const goal = await getGoal(input.sessionID);
+                  if (signal.aborted || disposed || stoppedExecutions.has(input.sessionID) || !autoContinue || goal?.status !== "active")
+                    break;
+                  pursuedGoalID ??= goal.id;
+                  if (goal.id !== pursuedGoalID)
+                    break;
+                  await new Promise((resolve) => setTimeout(resolve, 250));
+                } while (!disposed && !signal.aborted);
+              }
+            } catch (error) {
+              if (!admitted && !disposed && !execution?.signal?.aborted)
+                throw error;
+              if (!disposed && !execution?.signal?.aborted) {
+                goalServices.stopAutonomy?.(input.sessionID);
+                v2ErrorLog("Goal command wait failed; autonomous continuation stopped", error);
+                try {
+                  if ((await getGoal(input.sessionID))?.status === "active")
+                    await setGoalStatus(input.sessionID, "paused");
+                } catch (stateError) {
+                  v2ErrorLog("Failed to pause goal after command failure", stateError);
+                }
+              }
+            } finally {
+              execution?.signal?.removeEventListener("abort", cancel);
+              await cancellation;
+            }
           }
         });
       }
@@ -4544,6 +4604,9 @@ async function setupV2(context) {
     } catch (error) {
       if (!abortController.signal.aborted)
         v2ErrorLog("V2 event consumer stopped", error);
+    } finally {
+      if (!disposed && !abortController.signal.aborted)
+        eventConsumerStopped = true;
     }
   })();
   return async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prevalentware/opencode-goal-plugin",
-  "version": "0.1.55",
+  "version": "0.1.57",
   "description": "OpenCode goal plugin that adds Codex-style long-running goal mode, /goal commands, persistence, and TUI status for AI coding agents.",
   "keywords": [
     "opencode",
@@ -46,7 +46,7 @@
   ],
   "scripts": {
     "clean": "rm -rf dist",
-    "build": "bun run clean && bun build ./src/server.ts --outdir ./dist --target bun --external @opencode-ai/plugin --external effect --external zod",
+    "build": "bun run clean && bun build ./src/server.ts --outdir ./dist --target bun --external @opencode-ai/plugin --external effect-goal-state --external zod",
     "ci:version": "bun scripts/resolve-ci-version.ts",
     "lint": "eslint .",
     "pack:dry-run": "npm pack --dry-run",
@@ -58,8 +58,8 @@
   },
   "dependencies": {
     "@opencode-ai/plugin": "^1.17.1",
-    "effect": "^3.21.2",
-    "zod": "^4.1.8"
+    "zod": "^4.1.8",
+    "effect-goal-state": "npm:effect@^3.21.2"
   },
   "peerDependencies": {
     "@opentui/solid": ">=0.5.8",

package/src/tui.ts

@@ -419,10 +419,12 @@ function isGoalSnapshot(value: unknown): value is GoalSnapshot {
 export async function readPersistedGoal(sessionID: string): Promise<GoalSnapshot | null | undefined> {
   try {
     const state: unknown = JSON.parse(await readFile(statePath(), "utf8"))
-    if (!isRecord(state) || (state.version !== 1 && state.version !== 2) || !isRecord(state.goals)) return undefined
+    if (!isRecord(state) || (state.version !== 1 && state.version !== 2 && state.version !== 3) || !isRecord(state.goals)) return undefined
     const stored = state.goals[sessionID]
     if (stored === undefined) return null
     if (!isRecord(stored) || stored.sessionID !== sessionID) return undefined
+    if (stored.plan !== undefined && stored.plan !== null) return undefined
+    if (stored.planRevision !== undefined && stored.planRevision !== 0) return undefined
     const sampledAt = currentEpochSeconds()
     const timeUsedSeconds = typeof stored.timeUsedSeconds === "number" ? stored.timeUsedSeconds : 0
     const activeSeconds = stored.status === "active" && typeof stored.lastAccountedAt === "number"