@prevalentware/opencode-goal-plugin 0.1.41 → 0.1.42

package/README.md

@@ -231,6 +231,8 @@ Ordinary fsync improves crash consistency but is not `F_FULLFSYNC`, so sudden po
 
 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.
+
 ## Credits
 
 This plugin follows Codex's native goal-mode semantics where OpenCode plugin hooks allow it. Several hardening ideas were adapted from William Ricchiuti's [`willytop8/OpenCode-goal-plugin`](https://github.com/willytop8/OpenCode-goal-plugin), especially lifecycle history, checkpoints, no-progress safeguards, budget wrap-up behavior, and strict-provider-safe system prompt merging. Thank you, William.

package/dist/server.js

@@ -3,6 +3,7 @@
 import { z } from "zod";
 
 // src/state.ts
+import { randomUUID as randomUUID2 } from "crypto";
 import { mkdir, readFile } from "fs/promises";
 import { homedir } from "os";
 import { dirname as dirname2, join } from "path";
@@ -220,6 +221,23 @@ function mutableState(state) {
   return JSON.parse(JSON.stringify(state));
 }
 var warnedEmptyStatePaths = new Set;
+var stateRecoveryListeners = new Set;
+function onStateRecovery(stateFile, report) {
+  const listener = { stateFile, report };
+  stateRecoveryListeners.add(listener);
+  return () => stateRecoveryListeners.delete(listener);
+}
+function notifyStateRecovery(notice) {
+  for (const listener of stateRecoveryListeners) {
+    if (listener.stateFile !== notice.stateFile)
+      continue;
+    Promise.resolve().then(() => listener.report(notice)).catch((error) => {
+      try {
+        console.error(`[opencode-goal-plugin] Failed to report quarantined state at ${notice.quarantineFile}:`, error instanceof Error ? error.message : String(error));
+      } catch {}
+    });
+  }
+}
 function isStatePadding(character) {
   return character === "\x00" || character.trim() === "";
 }
@@ -232,24 +250,53 @@ function parseStateText(raw, file) {
     end -= 1;
   const content = raw.slice(start, end);
   if (content)
-    return JSON.parse(content);
+    return { value: JSON.parse(content), recoveryContent: null };
   if (!warnedEmptyStatePaths.has(file)) {
     warnedEmptyStatePaths.add(file);
     console.warn(`[opencode-goal-plugin] Empty or zero-filled state file at ${file}; recovering with empty state.`);
   }
-  return emptyState();
+  return { value: emptyState(), recoveryContent: raw || null };
 }
 function decodeState(value) {
   return Schema.decodeUnknown(StateSchema)(value).pipe(Effect.map(mutableState), Effect.map(normalizeState), Effect.mapError((cause) => new StateDecodeError({ cause })));
 }
-function readStateEffect(file = statePath()) {
+function readStateResultEffect(file = statePath()) {
   return Effect.tryPromise({
     try: () => readFile(file, "utf8"),
     catch: (cause) => new StateReadError({ cause })
   }).pipe(Effect.flatMap((raw) => Effect.try({
     try: () => parseStateText(raw, file),
     catch: (cause) => new StateDecodeError({ cause })
-  })), Effect.flatMap(decodeState), Effect.catchAll((error) => error._tag === "StateReadError" && isMissingStateFile(error.cause) ? Effect.succeed(emptyState()) : Effect.fail(error)));
+  })), Effect.flatMap(({ value, recoveryContent }) => decodeState(value).pipe(Effect.map((state) => ({ state, recoveryContent })))), Effect.catchAll((error) => error._tag === "StateReadError" && isMissingStateFile(error.cause) ? Effect.succeed({ state: emptyState(), recoveryContent: null }) : Effect.fail(error)));
+}
+function readStateEffect(file = statePath()) {
+  return readStateResultEffect(file).pipe(Effect.map(({ state }) => state));
+}
+function quarantineStateEffect(file, content) {
+  return Effect.promise(async () => {
+    const quarantineFile = `${file}.corrupt-${Date.now()}-${randomUUID2()}`;
+    try {
+      await mkdir(dirname2(file), { recursive: true, mode: 448 });
+      await atomicWriteFile(quarantineFile, content);
+      return { quarantineFile, error: null };
+    } catch (error) {
+      return { quarantineFile, error: error instanceof Error ? error.message : String(error) };
+    }
+  });
+}
+function verifyRecoverySourceEffect(file, expectedContent, quarantineFile) {
+  return Effect.promise(async () => {
+    try {
+      return await readFile(file, "utf8") === expectedContent;
+    } catch (error) {
+      if (!isMissingStateFile(error)) {
+        try {
+          console.error(`[opencode-goal-plugin] Could not re-read ${file} after preserving it at ${quarantineFile}; continuing recovery:`, error instanceof Error ? error.message : String(error));
+        } catch {}
+      }
+      return true;
+    }
+  });
 }
 function writeStateEffect(state, file = statePath()) {
   return Effect.tryPromise({
@@ -278,11 +325,46 @@ async function mutate(fn) {
   return enqueueMutation(() => {
     const file = statePath();
     return Effect.runPromise(Effect.gen(function* () {
-      const state = yield* readStateEffect(file);
+      const { state, recoveryContent } = yield* readStateResultEffect(file);
       const result = yield* Effect.tryPromise({
         try: () => Promise.resolve(fn(state)),
         catch: (cause) => cause instanceof Error ? cause : new Error(String(cause))
       });
+      if (recoveryContent != null) {
+        const quarantine = yield* quarantineStateEffect(file, recoveryContent);
+        if (quarantine.error != null) {
+          const notice = {
+            stateFile: file,
+            quarantineFile: quarantine.quarantineFile,
+            outcome: "quarantineFailed",
+            error: quarantine.error
+          };
+          try {
+            console.error(`[opencode-goal-plugin] Could not quarantine corrupt state at ${file}; continuing recovery:`, quarantine.error);
+          } catch {}
+          notifyStateRecovery(notice);
+        } else {
+          const unchanged = yield* verifyRecoverySourceEffect(file, recoveryContent, quarantine.quarantineFile);
+          if (!unchanged) {
+            const message = "goal state changed while recovery was being quarantined; refusing to overwrite it";
+            notifyStateRecovery({
+              stateFile: file,
+              quarantineFile: quarantine.quarantineFile,
+              outcome: "sourceChanged",
+              error: message
+            });
+            return yield* Effect.fail(new StateWriteError({ cause: new Error(message) }));
+          }
+          try {
+            console.warn(`[opencode-goal-plugin] Preserved corrupt state from ${file} at ${quarantine.quarantineFile}; continuing recovery.`);
+          } catch {}
+          notifyStateRecovery({
+            stateFile: file,
+            quarantineFile: quarantine.quarantineFile,
+            outcome: "quarantined"
+          });
+        }
+      }
       yield* writeStateEffect(state, file);
       return result;
     }));
@@ -903,8 +985,8 @@ async function markPendingContinuationStarted(sessionID) {
     return current ? snapshotInternal(current) : null;
   if (current.pendingAttempt == null || current.pendingAttempt.started)
     return snapshotInternal(current);
-  return mutate((state2) => {
-    const goal = state2.goals[sessionID];
+  return mutate((state) => {
+    const goal = state.goals[sessionID];
     if (!goal || goal.status !== "active")
       return goal ? snapshotInternal(goal) : null;
     if (goal.pendingAttempt == null || goal.pendingAttempt.started)
@@ -1851,10 +1933,10 @@ async function updateGoalObjectiveFromTool(input, context, services) {
 }
 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 completeGoal(context.sessionID, input.evidence ?? "");
+    const budget = goal.tokenBudget == null ? "" : ` Token usage: ${goal.tokensUsed}/${goal.tokenBudget}.`;
+    const report = `Goal achieved. Time used: ${goal.timeUsedSeconds} seconds.${budget} Evidence: ${goal.completionEvidence}.`;
+    return JSON.stringify({ goal, completion_report: report }, null, 2);
   }
   const goal = await markGoalUnmet(context.sessionID, input.blocker ?? "");
   const report = `Goal unmet. Time used: ${goal.timeUsedSeconds} seconds. Blocker: ${goal.blocker}.`;
@@ -1932,6 +2014,16 @@ var server = async ({ client }, options) => {
   const planAgents = restrictedAgentSet(options);
   const isPlanAgent = (agent) => typeof agent === "string" && planAgents.has(agent.trim().toLowerCase());
   const goalServices = { options: options ?? {}, isPlanAgent };
+  const stopStateRecoveryReporting = onStateRecovery(statePath(), async ({ stateFile, quarantineFile, outcome, error }) => {
+    await client.app?.log?.({
+      body: {
+        service: "opencode-goal-plugin",
+        level: "error",
+        message: outcome === "quarantined" ? "Corrupt goal state quarantined before recovery" : outcome === "sourceChanged" ? "Goal state changed during recovery; refusing to overwrite it" : "Corrupt goal state could not be quarantined; continuing recovery",
+        extra: { stateFile, quarantineFile, outcome, ...error ? { error } : {} }
+      }
+    });
+  });
   let disposed = false;
   async function taskBlockStatus(sessionID) {
     if (!deferWhileTasksActive)
@@ -2180,6 +2272,7 @@ var server = async ({ client }, options) => {
   return {
     async dispose() {
       disposed = true;
+      stopStateRecoveryReporting();
       for (const scheduled of scheduledContinuations.values())
         clearTimeout(scheduled.timer);
       scheduledContinuations.clear();
@@ -2496,10 +2589,10 @@ async function setupV2(context) {
   };
   const registrations = [];
   let disposed = false;
-  function stepKey(sessionID, messageID2) {
-    return `${sessionID}\x00${messageID2}`;
+  function stepKey(sessionID, messageID) {
+    return `${sessionID}\x00${messageID}`;
   }
-  async function sendContinuation2(sessionID, prompt, agent) {
+  async function sendContinuation(sessionID, prompt, agent) {
     await context.session.prompt({
       sessionID,
       text: prompt,
@@ -2564,7 +2657,7 @@ async function setupV2(context) {
       activeContinuationsV2.add(sessionID);
       claimedContinuation = true;
       watchdogRescuedSessions.add(sessionID);
-      await sendContinuation2(sessionID, continuationPrompt(current), current.lastPromptAgent ?? latestStep?.agent ?? null);
+      await sendContinuation(sessionID, continuationPrompt(current), current.lastPromptAgent ?? latestStep?.agent ?? null);
       await recordContinuationResult(sessionID, "success", maxPromptFailures, { armNoProgress: false, started: true });
       locallyDeliveredPendingSessions.add(sessionID);
       clearTurnWatchdog(sessionID);
@@ -2716,7 +2809,7 @@ async function setupV2(context) {
         await rollbackContinuationAttempt(sessionID);
         return;
       }
-      await sendContinuation2(sessionID, goal.status === "active" ? continuationPrompt(goal) : limitPrompt(goal), goal.lastPromptAgent ?? latestTurnAgent ?? null);
+      await sendContinuation(sessionID, goal.status === "active" ? continuationPrompt(goal) : limitPrompt(goal), goal.lastPromptAgent ?? latestTurnAgent ?? null);
       if (disposed) {
         await rollbackContinuationAttempt(sessionID);
         return;
@@ -2861,16 +2954,16 @@ async function setupV2(context) {
       case "session.step.started": {
         if (!sessionID || typeof data.assistantMessageID !== "string")
           return;
-        const messageID2 = data.assistantMessageID;
+        const messageID = 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 } }
+          info: { id: messageID, 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, completedAt: event.created });
+        if (!stepTextBuffers.has(stepKey(sessionID, messageID)))
+          stepTextBuffers.set(stepKey(sessionID, messageID), "");
+        latestStepBySession.set(sessionID, { messageID, agent, text: "", outputTokens: null, completedAt: event.created });
         return;
       }
       case "session.text.delta": {
@@ -2889,7 +2982,7 @@ async function setupV2(context) {
       case "session.step.ended": {
         if (!sessionID || typeof data.assistantMessageID !== "string")
           return;
-        const messageID2 = data.assistantMessageID;
+        const messageID = data.assistantMessageID;
         const tokens = tokensFromRecord(data.tokens);
         if (typeof tokens === "number") {
           const sum = (stepTokenSums.get(sessionID) ?? 0) + tokens;
@@ -2900,11 +2993,11 @@ async function setupV2(context) {
             initialBaseline: Math.ceil(sum - tokens)
           });
         }
-        const text = stepTextBuffers.get(stepKey(sessionID, messageID2)) ?? "";
-        stepTextBuffers.delete(stepKey(sessionID, messageID2));
+        const text = stepTextBuffers.get(stepKey(sessionID, messageID)) ?? "";
+        stepTextBuffers.delete(stepKey(sessionID, messageID));
         const outputTokens = outputTokensFromRecord(data.tokens) ?? null;
         const afterStep = await recordAssistantProgress(sessionID, {
-          messageID: messageID2,
+          messageID,
           text,
           outputTokens,
           noProgressTokenThreshold: positiveIntegerOrNull2(options.no_progress_token_threshold),
@@ -2918,7 +3011,7 @@ async function setupV2(context) {
             cancelScheduledContinuation(sessionID);
         }
         latestStepBySession.set(sessionID, {
-          messageID: messageID2,
+          messageID,
           agent: latestStepBySession.get(sessionID)?.agent,
           text,
           outputTokens,
@@ -2929,7 +3022,7 @@ async function setupV2(context) {
       case "session.step.failed": {
         if (!sessionID || typeof data.assistantMessageID !== "string")
           return;
-        const messageID2 = data.assistantMessageID;
+        const messageID = data.assistantMessageID;
         const tokens = tokensFromRecord(data.tokens);
         if (typeof tokens === "number") {
           const sum = (stepTokenSums.get(sessionID) ?? 0) + tokens;
@@ -2940,11 +3033,11 @@ async function setupV2(context) {
             initialBaseline: Math.ceil(sum - tokens)
           });
         }
-        const text = stepTextBuffers.get(stepKey(sessionID, messageID2)) ?? "";
-        stepTextBuffers.delete(stepKey(sessionID, messageID2));
+        const text = stepTextBuffers.get(stepKey(sessionID, messageID)) ?? "";
+        stepTextBuffers.delete(stepKey(sessionID, messageID));
         const outputTokens = outputTokensFromRecord(data.tokens) ?? null;
         const afterStep = await recordAssistantProgress(sessionID, {
-          messageID: messageID2,
+          messageID,
           text,
           outputTokens,
           noProgressTokenThreshold: positiveIntegerOrNull2(options.no_progress_token_threshold),
@@ -2958,7 +3051,7 @@ async function setupV2(context) {
             cancelScheduledContinuation(sessionID);
         }
         latestStepBySession.set(sessionID, {
-          messageID: messageID2,
+          messageID,
           agent: latestStepBySession.get(sessionID)?.agent,
           text,
           outputTokens,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prevalentware/opencode-goal-plugin",
-  "version": "0.1.41",
+  "version": "0.1.42",
   "description": "OpenCode goal plugin that adds Codex-style long-running goal mode, /goal commands, persistence, and TUI status for AI coding agents.",
   "keywords": [
     "opencode",