@prevalentware/opencode-goal-plugin 0.1.11 → 0.1.13

package/README.md

@@ -6,7 +6,7 @@ This plugin adds:
 
 - `/goal <objective>` as an OpenCode command for TUI, desktop, and web.
 - A sidebar goal indicator with status, elapsed time, and objective.
-- Agent tools: `get_goal`, `create_goal`, `update_goal`, and `clear_goal`.
+- Agent tools: `get_goal`, `create_goal`, `set_goal`, `update_goal`, and `clear_goal`.
 - Goal close evidence: `complete` requires verified evidence, and `unmet` requires a concrete blocker.
 - Persistent per-session goal state.
 - Optional automatic continuation on `session.idle`.
@@ -85,6 +85,8 @@ Use `/goal <objective>` in a fresh OpenCode chat to create a long-running goal:
 
 Bare `/goal` reports the current goal state. `/goal clear` clears the goal. The TUI also includes a `Goal` command-palette entry for viewing, refreshing, or clearing the current goal state without creating a new goal.
 
+You can also ask the agent to formulate the objective and call `set_goal` itself, for example: "set your own goal to finish this refactor safely." The tool uses the agent-written objective but still only creates a goal when explicitly requested.
+
 When writing the objective, include the scope, non-goals, and verification path when they matter. The agent is reminded to audit real files, command output, tests, or PR state before closing the goal.
 
 The `update_goal` tool can close a goal in two ways:

package/dist/server.js

@@ -6,6 +6,38 @@ import { z } from "zod";
 import { homedir } from "os";
 import { dirname, join } from "path";
 import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import { Data, Effect, Schema } from "effect";
+
+class StateReadError extends Data.TaggedError("StateReadError") {
+}
+
+class StateDecodeError extends Data.TaggedError("StateDecodeError") {
+}
+
+class StateWriteError extends Data.TaggedError("StateWriteError") {
+}
+var NullableString = Schema.NullOr(Schema.String);
+var NullableNumber = Schema.NullOr(Schema.Number);
+var GoalSchema = Schema.Struct({
+  sessionID: Schema.String,
+  objective: Schema.String,
+  status: Schema.Literal("active", "paused", "budgetLimited", "complete", "unmet"),
+  tokenBudget: NullableNumber,
+  tokensUsed: Schema.Number,
+  timeUsedSeconds: Schema.Number,
+  createdAt: Schema.Number,
+  updatedAt: Schema.Number,
+  completionEvidence: Schema.optionalWith(NullableString, { default: () => null }),
+  blocker: Schema.optionalWith(NullableString, { default: () => null }),
+  closedAt: Schema.optionalWith(NullableNumber, { default: () => null }),
+  lastAccountedAt: NullableNumber,
+  autoTurns: Schema.Number,
+  lastContinuationAt: NullableNumber
+});
+var StateSchema = Schema.Struct({
+  version: Schema.Literal(1),
+  goals: Schema.Record({ key: Schema.String, value: GoalSchema })
+});
 function defaultStateFile() {
   const dataHome = process.env.XDG_DATA_HOME || (process.platform === "win32" && process.env.APPDATA ? process.env.APPDATA : join(homedir(), ".local", "share"));
   return join(dataHome, "opencode-goal-plugin", "goals.json");
@@ -19,30 +51,60 @@ function nowSeconds() {
 function emptyState() {
   return { version: 1, goals: {} };
 }
+function isMissingStateFile(error) {
+  return typeof error === "object" && error !== null && error.code === "ENOENT";
+}
+function mutableState(state) {
+  return JSON.parse(JSON.stringify(state));
+}
+function decodeState(value) {
+  return Schema.decodeUnknown(StateSchema)(value).pipe(Effect.map(mutableState), Effect.mapError((cause) => new StateDecodeError({ cause })));
+}
+function readStateEffect() {
+  return Effect.tryPromise({
+    try: () => readFile(statePath(), "utf8"),
+    catch: (cause) => new StateReadError({ cause })
+  }).pipe(Effect.flatMap((raw) => Effect.try({
+    try: () => JSON.parse(raw),
+    catch: (cause) => new StateDecodeError({ cause })
+  })), Effect.flatMap(decodeState), Effect.catchAll((error) => error._tag === "StateReadError" && isMissingStateFile(error.cause) ? Effect.succeed(emptyState()) : Effect.fail(error)));
+}
+function writeStateEffect(state) {
+  return Effect.tryPromise({
+    try: async () => {
+      const file = statePath();
+      await mkdir(dirname(file), { recursive: true });
+      const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+      await writeFile(tmp, JSON.stringify(state, null, 2) + `
+`);
+      await rename(tmp, file);
+    },
+    catch: (cause) => new StateWriteError({ cause })
+  });
+}
 async function readState() {
-  try {
-    const raw = await readFile(statePath(), "utf8");
-    const parsed = JSON.parse(raw);
-    return parsed && parsed.version === 1 && parsed.goals ? parsed : emptyState();
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return emptyState();
-    throw error;
-  }
+  return Effect.runPromise(readStateEffect());
 }
-async function writeState(state) {
-  const file = statePath();
-  await mkdir(dirname(file), { recursive: true });
-  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
-  await writeFile(tmp, JSON.stringify(state, null, 2) + `
-`);
-  await rename(tmp, file);
+var mutationQueue = Promise.resolve();
+function enqueueMutation(operation) {
+  const current = mutationQueue.then(operation, operation);
+  mutationQueue = current.then(() => {
+    return;
+  }, () => {
+    return;
+  });
+  return current;
 }
 async function mutate(fn) {
-  const state = await readState();
-  const result = await fn(state);
-  await writeState(state);
-  return result;
+  return enqueueMutation(() => Effect.runPromise(Effect.gen(function* () {
+    const state = yield* readStateEffect();
+    const result = yield* Effect.tryPromise({
+      try: () => Promise.resolve(fn(state)),
+      catch: (cause) => cause instanceof Error ? cause : new Error(String(cause))
+    });
+    yield* writeStateEffect(state);
+    return result;
+  })));
 }
 function validateObjective(objective) {
   const value = objective.trim();
@@ -250,9 +312,9 @@ Do not rely on intent, partial progress, elapsed effort, memory of earlier work,
 }
 function systemReminder(goal) {
   if (!goal) {
-    return `OpenCode goal mode is available through get_goal, create_goal, and update_goal tools.
+    return `OpenCode goal mode is available through get_goal, create_goal, set_goal, and update_goal tools.
 
-Create a goal only when explicitly requested by the user or system/developer instructions. Do not infer goals from ordinary tasks. When closing a goal, update_goal requires evidence for status "complete" or a blocker for status "unmet".`;
+Create a goal only when explicitly requested by the user or system/developer instructions. Use set_goal when the user asks you to formulate and set your own goal. Do not infer goals from ordinary tasks. When closing a goal, update_goal requires evidence for status "complete" or a blocker for status "unmet".`;
   }
   if (goal.status === "active")
     return continuationPrompt(goal);
@@ -395,6 +457,17 @@ var server = async ({ client }, options) => {
           return JSON.stringify({ goal }, null, 2);
         }
       },
+      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.",
+        args: {
+          objective: z.string().min(1).max(4000).describe("The model-formulated concrete objective to start pursuing.")
+        },
+        async execute(args, context) {
+          const input = args;
+          const goal = await createGoal(context.sessionID, input.objective);
+          return JSON.stringify({ goal }, null, 2);
+        }
+      },
       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.",
         args: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prevalentware/opencode-goal-plugin",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Codex-style long-running goal mode for OpenCode.",
   "keywords": [
     "opencode",
@@ -36,7 +36,7 @@
   ],
   "scripts": {
     "clean": "rm -rf dist",
-    "build": "bun run clean && bun build ./src/server.ts --outdir ./dist --target bun --external @opencode-ai/plugin --external zod",
+    "build": "bun run clean && bun build ./src/server.ts --outdir ./dist --target bun --external @opencode-ai/plugin --external effect --external zod",
     "ci:version": "bun scripts/resolve-ci-version.ts",
     "lint": "eslint .",
     "pack:dry-run": "npm pack --dry-run",
@@ -46,6 +46,7 @@
   },
   "dependencies": {
     "@opencode-ai/plugin": "^1.14.39",
+    "effect": "^3.21.2",
     "zod": "^4.1.8"
   },
   "devDependencies": {