@prevalentware/opencode-goal-plugin 0.1.44 → 0.1.46

package/README.md

@@ -128,7 +128,8 @@ In OpenCode 1, server options use the package-and-options tuple in `opencode.jso
         "no_progress_token_threshold": 50,
         "max_no_progress_turns": 2,
         "restricted_agents": ["plan"],
-        "allow_goal_execution_from_plan": false
+        "allow_goal_execution_from_plan": false,
+        "max_objective_chars": 100000
       }
     ]
   ]
@@ -159,6 +160,7 @@ Defaults:
 - `defer_while_tasks_active`: `true`; when enabled, goal auto-continuation waits for active OpenCode Task child sessions and their orchestrator reconciliation before sending the next goal prompt.
 - `max_auto_turns`: `25`
 - `min_continue_interval_seconds`: `3`
+- Fast V2 executions that finish inside this interval schedule a delayed continuation; they do not require another user message to wake up.
 - `max_turn_time`: unset by default; set a positive number of seconds to retry one active-goal continuation prompt when a model turn remains busy for that long. Each new busy event resets the watchdog. Idle, built-in retry, session deletion, active Task children, and restricted agents suppress the retry. Watchdog retries are independent of `min_continue_interval_seconds` and never consume auto-turn or no-progress budgets, but recognized transport failures still count toward the `max_prompt_failures` ceiling.
 - `max_prompt_failures`: `3`; consecutive transport or no-response continuation failures pause the goal at this ceiling. Prompt delivery alone does not reset the count; substantive assistant or tool progress, a new goal, or an explicit resume does.
 - `default_token_budget`: unset by default; when set, new goals inherit this token budget.
@@ -169,6 +171,10 @@ Defaults:
 - `command_name`: `"goal"`; renames the main goal command only. The reserved names `pause_goal` and `resume_goal` fall back to `goal` so the standalone controls remain available.
 - `restricted_agents`: `["plan"]`; agents (matched case-insensitively) treated as planning-only for goal execution.
 - `allow_goal_execution_from_plan`: `false`; when `true`, disables Plan-mode goal restrictions entirely.
+- `max_objective_chars`: `100000`; maximum Unicode code-point length of the submitted goal objective, completion evidence,
+  and blocker text. The previous 4000-character cap was a defect, not a compatibility constraint. The same limit is
+  advertised on V1 and V2 tool schemas and enforced at runtime, independently per plugin instance. Accepted values are
+  trimmed before persistence. Large objectives are echoed into continuation and compaction prompts.
 
 ## Goal Workflow
 
@@ -248,6 +254,17 @@ bun run build
 npm pack --dry-run
 ```
 
+With `opencode2` installed, run `bun run build && bun run smoke:v2` to exercise the
+native V2 lifecycle, not just mocked events. The smoke test uses a private server,
+isolated home/config/database/goal state, and a deterministic local model with no
+real provider credentials. It invokes `/goal`, requires **two** automatic
+continuations with the default minimum interval, then verifies completion. A
+second loaded location checks that server-wide events do not duplicate delivery.
+The test prints its temporary artifact directory and shuts down its private
+server. Use `OPENCODE_V2_BIN` to select another V2 binary, or run
+`bun run smoke:v2 @prevalentware/opencode-goal-plugin@<version>` to install and
+verify an exact published package in the isolated environment.
+
 ## Publishing
 
 This package is set up for npm Trusted Publishing from GitHub Actions. On every push to `main`, CI runs typecheck, lint, and unit tests in parallel. If they all pass, the publish job computes the next patch version from the latest version on npm, builds the package, and runs `npm publish`.
@@ -274,6 +291,6 @@ OpenCode plugin modules are target-specific. This package exports separate modul
 }
 ```
 
-Codex goal mode has deeper runtime integration for thread lifecycle control. This plugin implements the same workflow using OpenCode plugin hooks. Token usage is read from OpenCode step-finish usage when available and falls back to message token metadata or text estimation when exact usage is unavailable. Continuation is driven by OpenCode idle events, including `session.idle` and `session.status` idle notifications. The optional `max_turn_time` watchdog can retry one goal continuation prompt when a model turn remains busy, without consuming the goal's auto-turn, no-progress, or prompt-failure budgets. By default, continuation is deferred while OpenCode Task child sessions are active or their terminal result still needs an orchestrator turn. During compaction, the plugin disables OpenCode's generic synthetic auto-continue while an active goal exists so the goal-specific continuation prompt remains authoritative.
+Codex goal mode has deeper runtime integration for thread lifecycle control. This plugin implements the same workflow using OpenCode plugin hooks. Token usage is read from OpenCode step-finish usage when available and falls back to message token metadata or text estimation when exact usage is unavailable. Continuation is driven by V2 `session.execution.succeeded` events and legacy `session.idle` / `session.status` idle notifications, never by intermediate model-step completion. V2 execution starts arm busy tracking; native `session.retry.scheduled` events cancel plugin recovery while OpenCode retries. Terminal execution transport failures use bounded recovery, while interruptions (user, shutdown, or superseded) cancel local timers without starting another turn or charging a prompt failure. Interrupted or non-transport-failed executions remain suppressed until the host starts a new execution; this does not change the persisted goal status. Use `/pause_goal` for a durable pause. Each V2 plugin instance handles goal events only for its own location while still observing cross-location child task lifecycles. The optional `max_turn_time` watchdog can retry one goal continuation prompt when a model turn remains busy, without consuming the goal's auto-turn or no-progress budgets; recognized transport failures do count toward the prompt-failure ceiling. By default, continuation is deferred while OpenCode Task child sessions are active or their terminal result still needs an orchestrator turn. During compaction, the plugin disables OpenCode's generic synthetic auto-continue while an active goal exists so the goal-specific continuation prompt remains authoritative.
 
 The goal sidebar shows the current status, elapsed time, token usage, auto-continue count, latest checkpoint, latest status message, stop reason, and objective when a goal is active, paused, or safety-limited. Closed goals remain visible briefly through the latest tool state as achieved or unmet.

package/dist/server.js

@@ -370,21 +370,23 @@ async function mutate(fn) {
     }));
   });
 }
-function validateObjective(objective) {
-  const value = objective.trim();
-  if (!value)
-    throw new Error("goal objective must not be empty");
-  if ([...value].length > 4000)
-    throw new Error("goal objective must be at most 4000 characters");
-  return value;
-}
-function validateEvidence(evidence, label) {
-  const value = evidence?.trim();
-  if (!value)
+var DEFAULT_MAX_OBJECTIVE_CHARS = 1e5;
+function resolveMaxObjectiveChars(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : DEFAULT_MAX_OBJECTIVE_CHARS;
+}
+function boundedText(value, limit, label) {
+  if ([...value].length > limit)
+    throw new Error(`${label} must be at most ${limit} characters`);
+  const trimmed = value.trim();
+  if (!trimmed)
     throw new Error(`${label} must not be empty`);
-  if ([...value].length > 4000)
-    throw new Error(`${label} must be at most 4000 characters`);
-  return value;
+  return trimmed;
+}
+function validateObjective(objective, limit = DEFAULT_MAX_OBJECTIVE_CHARS) {
+  return boundedText(objective, limit, "goal objective");
+}
+function validateEvidence(evidence, label, limit = DEFAULT_MAX_OBJECTIVE_CHARS) {
+  return boundedText(evidence ?? "", limit, label);
 }
 function normalizeState(state) {
   for (const goal of Object.values(state.goals))
@@ -460,7 +462,8 @@ function normalizeCreateOptions(input) {
       noProgressTokenThreshold: DEFAULT_NO_PROGRESS_TOKEN_THRESHOLD,
       maxNoProgressTurns: DEFAULT_MAX_NO_PROGRESS_TURNS,
       agent: null,
-      initialStatus: "active"
+      initialStatus: "active",
+      maxObjectiveChars: DEFAULT_MAX_OBJECTIVE_CHARS
     };
   }
   return {
@@ -470,7 +473,8 @@ function normalizeCreateOptions(input) {
     noProgressTokenThreshold: positiveIntegerOrNull(input?.noProgressTokenThreshold) ?? DEFAULT_NO_PROGRESS_TOKEN_THRESHOLD,
     maxNoProgressTurns: positiveIntegerOrNull(input?.maxNoProgressTurns) ?? DEFAULT_MAX_NO_PROGRESS_TURNS,
     agent: typeof input?.agent === "string" && input.agent.trim() ? input.agent.trim() : null,
-    initialStatus: input?.initialStatus === "paused" ? "paused" : "active"
+    initialStatus: input?.initialStatus === "paused" ? "paused" : "active",
+    maxObjectiveChars: resolveMaxObjectiveChars(input?.maxObjectiveChars)
   };
 }
 function positiveIntegerOrNull(value) {
@@ -570,8 +574,8 @@ async function getGoalInternal(sessionID) {
   return goal ? snapshotInternal(goal) : null;
 }
 async function createGoal(sessionID, objective, options) {
-  const value = validateObjective(objective);
   const normalizedOptions = normalizeCreateOptions(options);
+  const value = validateObjective(objective, resolveMaxObjectiveChars(normalizedOptions.maxObjectiveChars));
   return mutate((state) => {
     const existing = state.goals[sessionID];
     if (existing && !isClosed(existing.status)) {
@@ -623,7 +627,7 @@ async function createGoal(sessionID, objective, options) {
   });
 }
 async function updateGoalObjective(sessionID, objective, status = "active", options) {
-  const value = validateObjective(objective);
+  const value = validateObjective(objective, resolveMaxObjectiveChars(options?.maxObjectiveChars));
   const agent = typeof options?.agent === "string" && options.agent.trim() ? options.agent.trim() : null;
   const planModePause = options?.planModePause === true;
   return mutate((state) => {
@@ -714,7 +718,8 @@ async function setGoalStatus(sessionID, status, agent) {
     return snapshot(goal);
   });
 }
-async function closeGoal(sessionID, input) {
+async function closeGoal(sessionID, input, maxObjectiveChars = DEFAULT_MAX_OBJECTIVE_CHARS) {
+  const limit = resolveMaxObjectiveChars(maxObjectiveChars);
   return mutate((state) => {
     const goal = state.goals[sessionID];
     if (!goal)
@@ -727,12 +732,12 @@ async function closeGoal(sessionID, input) {
     goal.lastAccountedAt = null;
     goal.stopReason = input.status === "complete" ? null : "blocked";
     if (input.status === "complete") {
-      goal.completionEvidence = validateEvidence(input.evidence, "completion evidence");
+      goal.completionEvidence = validateEvidence(input.evidence, "completion evidence", limit);
       goal.blocker = null;
       goal.lastStatus = "Goal completed.";
       pushHistory(goal, "completed", goal.completionEvidence);
     } else {
-      goal.blocker = validateEvidence(input.blocker, "blocker");
+      goal.blocker = validateEvidence(input.blocker, "blocker", limit);
       goal.completionEvidence = null;
       goal.lastStatus = "Goal marked unmet.";
       pushHistory(goal, "unmet", goal.blocker);
@@ -740,11 +745,11 @@ async function closeGoal(sessionID, input) {
     return snapshot(goal);
   });
 }
-async function completeGoal(sessionID, evidence) {
-  return closeGoal(sessionID, { status: "complete", evidence });
+async function completeGoal(sessionID, evidence, maxObjectiveChars = DEFAULT_MAX_OBJECTIVE_CHARS) {
+  return closeGoal(sessionID, { status: "complete", evidence }, maxObjectiveChars);
 }
-async function markGoalUnmet(sessionID, blocker) {
-  return closeGoal(sessionID, { status: "unmet", blocker });
+async function markGoalUnmet(sessionID, blocker, maxObjectiveChars = DEFAULT_MAX_OBJECTIVE_CHARS) {
+  return closeGoal(sessionID, { status: "unmet", blocker }, maxObjectiveChars);
 }
 async function clearGoal(sessionID) {
   return mutate((state) => {
@@ -1269,6 +1274,15 @@ function restrictedAgentSet(options) {
   return new Set(names.map((name) => typeof name === "string" ? name.trim().toLowerCase() : "").filter(Boolean));
 }
 function goalCommandTemplate(commandName) {
+  const createGuidance = [
+    "Otherwise, call get_goal first.",
+    "If it returns a non-closed goal with the same objective, do not create it again; " + "continue working from the returned state.",
+    "If it returns a different non-closed goal, report that conflict instead of replacing it.",
+    "Only when there is no non-closed goal, call create_goal once.",
+    "Build the objective as a complete, faithful representation of the arguments: keep every requirement, constraint, " + "scope boundary, and success criterion with no omissions or loss of meaning.",
+    "You may restructure and rephrase for clarity and coherence, but do NOT compress, truncate, or drop any content, " + "and do NOT substitute the content with references or pointers to external files.",
+    "If the user includes explicit budget instructions, pass token_budget, max_auto_turns, or max_duration_seconds to " + "create_goal rather than leaving those words in the objective."
+  ].join(" ");
   return `OpenCode goal mode command "/${commandName}" was invoked.
 
 Arguments:
@@ -1287,7 +1301,7 @@ Use the goal tools to handle this command:
 - If the arguments start with "edit ", update the current goal objective by calling update_goal_objective with the remaining text.
 - If the arguments start with "complete " or "done ", perform a completion audit against real artifacts and command output. Call update_goal with status "complete" only if the goal is achieved, using concise evidence from the audit.
 - If the arguments start with "unmet ", "blocked ", or "blocker ", call update_goal with status "unmet" only when the goal cannot be achieved or needs external input, using the remaining arguments as the blocker.
-- Otherwise, call get_goal first. If it returns a non-closed goal with the same objective, do not create it again; continue working from the returned state. If it returns a different non-closed goal, report that conflict instead of replacing it. Only when there is no non-closed goal, call create_goal once. Use the full arguments as the objective. If the user includes explicit budget instructions, pass token_budget, max_auto_turns, or max_duration_seconds to create_goal rather than leaving those words in the objective.
+- ${createGuidance}
 
 Create a goal only from these explicit command arguments. Do not infer a goal from unrelated session context. After create_goal succeeds or returns an existing matching goal, never call it again for this command; continue working from the returned goal state.`;
 }
@@ -1949,9 +1963,24 @@ function getGoalToolResult(goal) {
   }
   return JSON.stringify(result, null, 2);
 }
+function boundedGoalTextSchema(limit, description, validate) {
+  return z.string().superRefine((value, ctx) => {
+    try {
+      validate(value);
+    } catch (error) {
+      ctx.addIssue({
+        code: "custom",
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }).meta({ minLength: 1, maxLength: limit, pattern: "\\S", description });
+}
+function v2GoalTextSchema(limit, description) {
+  return { type: "string", minLength: 1, maxLength: limit, pattern: "\\S", description };
+}
 async function createGoalFromTool(input, context, services) {
   const planningOnly = services.isPlanAgent(context.agent);
-  const objective = validateObjective(input.objective);
+  const objective = validateObjective(input.objective, services.maxObjectiveChars);
   const existing = await getGoal(context.sessionID);
   if (existing && !isClosedGoal(existing))
     return existingGoalResult(existing, objective, planningOnly);
@@ -1964,7 +1993,8 @@ async function createGoalFromTool(input, context, services) {
       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"
+      initialStatus: planningOnly ? "paused" : "active",
+      maxObjectiveChars: services.maxObjectiveChars
     });
   } catch (error) {
     if (!(error instanceof Error) || !error.message.includes("non-closed goal"))
@@ -1994,18 +2024,19 @@ async function updateGoalObjectiveFromTool(input, context, services) {
   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
+    planModePause: planningOnly,
+    maxObjectiveChars: services.maxObjectiveChars
   });
   return JSON.stringify(planningOnly ? { goal, plan_mode_notice: PLAN_MODE_CREATE_NOTICE } : { goal }, null, 2);
 }
-async function closeGoalFromTool(input, context) {
+async function closeGoalFromTool(input, context, services) {
   if (input.status === "complete") {
-    const goal = await completeGoal(context.sessionID, input.evidence ?? "");
+    const goal = await completeGoal(context.sessionID, input.evidence ?? "", services.maxObjectiveChars);
     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 goal = await markGoalUnmet(context.sessionID, input.blocker ?? "", services.maxObjectiveChars);
   const report = `Goal unmet. Time used: ${goal.timeUsedSeconds} seconds. Blocker: ${goal.blocker}.`;
   return JSON.stringify({ goal, unmet_report: report }, null, 2);
 }
@@ -2069,6 +2100,7 @@ var server = async ({ client }, options) => {
   const maxPromptFailures = positiveIntegerOrNull2(options?.max_prompt_failures) ?? DEFAULT_MAX_PROMPT_FAILURES;
   const registerCommand = options?.register_command ?? true;
   const commandName = commandNameFromOptions(options);
+  const objectiveChars = resolveMaxObjectiveChars(options?.max_objective_chars);
   const taskTracker = new TaskTracker;
   const taskDeferredSessions = new Set;
   const scheduledContinuations = new Map;
@@ -2080,7 +2112,7 @@ var server = async ({ client }, options) => {
   const watchdogRescuedSessions = new Set;
   const planAgents = restrictedAgentSet(options);
   const isPlanAgent = (agent) => typeof agent === "string" && planAgents.has(agent.trim().toLowerCase());
-  const goalServices = { options: options ?? {}, isPlanAgent };
+  const goalServices = { options: options ?? {}, isPlanAgent, maxObjectiveChars: objectiveChars };
   const stopStateRecoveryReporting = onStateRecovery(statePath(), async ({ stateFile, quarantineFile, outcome, error }) => {
     await client.app?.log?.({
       body: {
@@ -2382,7 +2414,7 @@ var server = async ({ client }, options) => {
       create_goal: {
         description: "Create a goal only when explicitly requested by the user or system/developer instructions; do not infer goals from ordinary tasks. If any non-closed goal exists, this returns the existing goal as either reused or conflicting and must not be retried. While the session is in Plan mode, the goal is recorded as paused and execution requires the user to switch to Build mode.",
         args: {
-          objective: z.string().min(1).max(4000).describe("The concrete objective to start pursuing."),
+          objective: boundedGoalTextSchema(objectiveChars, "The concrete objective to start pursuing.", (value) => validateObjective(value, objectiveChars)),
           token_budget: z.number().int().positive().nullable().optional().describe("Optional positive token budget."),
           max_auto_turns: z.number().int().positive().nullable().optional().describe("Optional per-goal auto-continue limit."),
           max_duration_seconds: z.number().int().positive().nullable().optional().describe("Optional per-goal duration limit.")
@@ -2394,7 +2426,7 @@ var server = async ({ client }, options) => {
       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. If any non-closed goal exists, this returns the existing goal as either reused or conflicting and must not be retried. While the session is in Plan mode, the goal is recorded as paused and execution requires the user to switch to Build mode.",
         args: {
-          objective: z.string().min(1).max(4000).describe("The model-formulated concrete objective to start pursuing."),
+          objective: boundedGoalTextSchema(objectiveChars, "The model-formulated concrete objective to start pursuing.", (value) => validateObjective(value, objectiveChars)),
           token_budget: z.number().int().positive().nullable().optional().describe("Optional positive token budget."),
           max_auto_turns: z.number().int().positive().nullable().optional().describe("Optional per-goal auto-continue limit."),
           max_duration_seconds: z.number().int().positive().nullable().optional().describe("Optional per-goal duration limit.")
@@ -2406,7 +2438,7 @@ var server = async ({ client }, options) => {
       update_goal_objective: {
         description: "Edit the current OpenCode goal objective when the user explicitly asks to edit or replace it.",
         args: {
-          objective: z.string().min(1).max(4000).describe("The updated concrete objective."),
+          objective: boundedGoalTextSchema(objectiveChars, "The updated concrete objective.", (value) => validateObjective(value, objectiveChars)),
           status: z.enum(["active", "paused"]).optional().describe("Whether the edited goal should be active or paused.")
         },
         async execute(args, context) {
@@ -2417,11 +2449,11 @@ var server = async ({ client }, options) => {
         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: {
           status: z.enum(["complete", "unmet"]).describe("Required. complete means achieved; unmet means blocked or impossible."),
-          evidence: z.string().min(1).max(4000).optional().describe("Required when status is complete. Summarize the concrete evidence verified."),
-          blocker: z.string().min(1).max(4000).optional().describe("Required when status is unmet. Explain the concrete blocker or impossibility.")
+          evidence: boundedGoalTextSchema(objectiveChars, "Required when status is complete. Summarize the concrete evidence verified.", (value) => validateEvidence(value, "completion evidence", objectiveChars)).optional(),
+          blocker: boundedGoalTextSchema(objectiveChars, "Required when status is unmet. Explain the concrete blocker or impossibility.", (value) => validateEvidence(value, "blocker", objectiveChars)).optional()
         },
         async execute(args, context) {
-          return closeGoalFromTool(args, context);
+          return closeGoalFromTool(args, context, goalServices);
         }
       },
       update_goal_status: {
@@ -2642,6 +2674,7 @@ async function setupV2(context) {
   const maxPromptFailures = positiveIntegerOrNull2(options.max_prompt_failures) ?? DEFAULT_MAX_PROMPT_FAILURES;
   const registerCommand = options.register_command ?? true;
   const commandName = commandNameFromOptions(options);
+  const objectiveChars = resolveMaxObjectiveChars(options.max_objective_chars);
   const taskTracker = new TaskTracker;
   const taskDeferredSessions = new Set;
   const scheduledContinuations = new Map;
@@ -2654,11 +2687,13 @@ async function setupV2(context) {
   const planAgents = restrictedAgentSet(options);
   const isPlanAgent = (agent) => typeof agent === "string" && planAgents.has(agent.trim().toLowerCase());
   const activeContinuationsV2 = new Set;
+  const stoppedExecutions = new Set;
   const latestStepBySession = new Map;
   const stepTextBuffers = new Map;
   const stepTokenSums = new Map;
   const goalServices = {
     options,
+    maxObjectiveChars: objectiveChars,
     isPlanAgent,
     initializeUsage: async (sessionID) => {
       try {
@@ -2799,6 +2834,8 @@ async function setupV2(context) {
   async function runAutoContinue(sessionID, fromTaskDeferral = false, scheduled) {
     if (disposed)
       return;
+    if (stoppedExecutions.has(sessionID))
+      return;
     if (busySessions.has(sessionID))
       return;
     if (activeContinuationsV2.has(sessionID))
@@ -2879,8 +2916,13 @@ async function setupV2(context) {
       if (nativeRetrySessions.has(sessionID))
         return;
       const goal = await reserveContinuation(sessionID, maxAutoTurns, minInterval);
-      if (!goal)
+      if (!goal) {
+        const waiting = await getGoalInternal(sessionID);
+        if (waiting?.status === "active" && waiting.pendingAttempt == null && waiting.lastContinuationAt != null && minInterval > 0) {
+          scheduleSettledContinuation(sessionID, continuationDelayFromSnapshot(minInterval, waiting.lastContinuationAt), scheduled != null);
+        }
         return;
+      }
       attemptReservedAt = goal.pendingAttempt?.reservedAt ?? Date.now();
       if (nativeRetrySessions.has(sessionID)) {
         await rollbackContinuationAttempt(sessionID);
@@ -2921,6 +2963,23 @@ async function setupV2(context) {
   async function handleV2Event(event) {
     const data = event.data;
     const sessionID = typeof data.sessionID === "string" ? data.sessionID : undefined;
+    if (context.location && event.location && (event.location.directory !== context.location.directory || event.location.workspaceID !== context.location.workspaceID)) {
+      if (event.type === "session.created" && sessionID && typeof data.parentID === "string") {
+        taskTracker.observeSessionCreated({ properties: { info: { id: sessionID, parentID: data.parentID } } });
+      } else if (sessionID) {
+        if (event.type === "session.execution.started")
+          taskTracker.observeSessionStatus(sessionID, "busy");
+        if (["session.execution.succeeded", "session.execution.failed", "session.execution.interrupted", "session.idle"].includes(event.type)) {
+          taskTracker.observeSessionStatus(sessionID, "idle");
+        }
+        if (event.type === "session.status" && isRecord(data.status) && typeof data.status.type === "string") {
+          taskTracker.observeSessionStatus(sessionID, data.status.type);
+        }
+        if (event.type === "session.deleted")
+          taskTracker.observeSessionDeleted(sessionID);
+      }
+      return;
+    }
     switch (event.type) {
       case "session.created": {
         const parentID = data.parentID;
@@ -2929,10 +2988,13 @@ async function setupV2(context) {
         }
         return;
       }
+      case "session.execution.started":
+      case "session.retry.scheduled":
       case "session.status": {
-        const status = data.status;
+        const status = event.type === "session.execution.started" ? { type: "busy" } : event.type === "session.retry.scheduled" ? { type: "retry" } : data.status;
         if (sessionID && isRecord(status) && typeof status.type === "string") {
           if (status.type === "busy") {
+            stoppedExecutions.delete(sessionID);
             busySessions.add(sessionID);
             nativeRetrySessions.delete(sessionID);
             armTurnWatchdog(sessionID);
@@ -2958,6 +3020,7 @@ async function setupV2(context) {
         }
         return;
       }
+      case "session.execution.succeeded":
       case "session.idle": {
         if (sessionID) {
           busySessions.delete(sessionID);
@@ -2973,9 +3036,25 @@ async function setupV2(context) {
         }
         return;
       }
+      case "session.execution.interrupted": {
+        if (!sessionID)
+          return;
+        stoppedExecutions.add(sessionID);
+        busySessions.delete(sessionID);
+        nativeRetrySessions.delete(sessionID);
+        clearTurnWatchdog(sessionID);
+        watchdogRescuedSessions.delete(sessionID);
+        cancelScheduledContinuation(sessionID);
+        taskDeferredSessions.delete(sessionID);
+        taskTracker.observeSessionStatus(sessionID, "idle");
+        return;
+      }
+      case "session.execution.failed":
       case "session.error": {
         if (!sessionID)
           return;
+        if (event.type === "session.execution.failed")
+          nativeRetrySessions.delete(sessionID);
         const inNativeRetry = nativeRetrySessions.has(sessionID);
         busySessions.delete(sessionID);
         clearTurnWatchdog(sessionID);
@@ -2984,6 +3063,13 @@ async function setupV2(context) {
         nativeRetrySessions.delete(sessionID);
         watchdogRescuedSessions.delete(sessionID);
         const errorMessage = transportErrorMessageFromEvent(data);
+        if (event.type === "session.execution.failed" && !isTransportError(errorMessage)) {
+          stoppedExecutions.add(sessionID);
+          cancelScheduledContinuation(sessionID);
+          taskDeferredSessions.delete(sessionID);
+        }
+        if (event.type === "session.execution.failed")
+          taskTracker.observeSessionStatus(sessionID, "idle");
         if (errorMessage && isTransportError(errorMessage)) {
           const goal = await getGoalInternal(sessionID);
           if (goal?.status === "active") {
@@ -3007,6 +3093,7 @@ async function setupV2(context) {
       case "session.deleted": {
         if (!sessionID)
           return;
+        stoppedExecutions.delete(sessionID);
         busySessions.delete(sessionID);
         clearTurnWatchdog(sessionID);
         watchdogRescuedSessions.delete(sessionID);
@@ -3283,6 +3370,7 @@ async function setupV2(context) {
       clearTimeout(watchdog.timer);
     turnWatchdogs.clear();
     activeContinuationsV2.clear();
+    stoppedExecutions.clear();
     nativeRetrySessions.clear();
     locallyDeliveredPendingSessions.clear();
     watchdogRescuedSessions.clear();
@@ -3327,7 +3415,7 @@ function goalToolsV2(services) {
       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. If any non-closed goal exists, this returns the existing goal as either reused or conflicting and must not be retried. 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." },
+        objective: v2GoalTextSchema(services.maxObjectiveChars, "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." }
@@ -3341,12 +3429,7 @@ function goalToolsV2(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. If any non-closed goal exists, this returns the existing goal as either reused or conflicting and must not be retried. 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."
-        },
+        objective: v2GoalTextSchema(services.maxObjectiveChars, "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." }
@@ -3360,7 +3443,7 @@ function goalToolsV2(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." },
+        objective: v2GoalTextSchema(services.maxObjectiveChars, "The updated concrete objective."),
         status: { type: "string", enum: ["active", "paused"], description: "Whether the edited goal should be active or paused." }
       }, ["objective"]),
       options: { codemode: false },
@@ -3377,22 +3460,12 @@ function goalToolsV2(services) {
           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."
-        }
+        evidence: v2GoalTextSchema(services.maxObjectiveChars, "Required when status is complete. Summarize the concrete evidence verified."),
+        blocker: v2GoalTextSchema(services.maxObjectiveChars, "Required when status is unmet. Explain the concrete blocker or impossibility.")
       }, ["status"]),
       options: { codemode: false },
       execute: async (args, toolContext) => ({
-        content: await closeGoalFromTool(args, toolContext)
+        content: await closeGoalFromTool(args, toolContext, services)
       })
     },
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prevalentware/opencode-goal-plugin",
-  "version": "0.1.44",
+  "version": "0.1.46",
   "description": "OpenCode goal plugin that adds Codex-style long-running goal mode, /goal commands, persistence, and TUI status for AI coding agents.",
   "keywords": [
     "opencode",
@@ -49,6 +49,7 @@
     "lint": "eslint .",
     "pack:dry-run": "npm pack --dry-run",
     "test": "bun test",
+    "smoke:v2": "bun scripts/smoke-v2-lifecycle.ts",
     "test:coverage": "bun test --coverage",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "bun run test && bun run build"