fix(opencode): clear the task result when a session is reused

Author: iceteaSA

packages/core/src/session/projector.ts

@@ -60,7 +60,7 @@ function sessionRow(info: SessionV1.SessionInfo): typeof SessionTable.$inferInse
     summary_files: info.summary?.files,
     summary_diffs: info.summary?.diffs ? [...info.summary.diffs] : undefined,
     metadata: info.metadata,
-    result: info.result,
+    result: info.result ?? null,
     cost: info.cost ?? 0,
     tokens_input: (info.tokens ?? { input: 0 }).input,
     tokens_output: (info.tokens ?? { output: 0 }).output,

packages/opencode/src/session/session.ts

@@ -296,7 +296,7 @@ export const SetMetadataInput = Schema.Struct({
 })
 export const SetResultInput = Schema.Struct({
   sessionID: SessionID,
-  result: Result,
+  result: Schema.NullOr(Result),
 })
 export const SetPermissionInput = Schema.Struct({
   sessionID: SessionID,
@@ -491,12 +491,13 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/Se
 
 export const use = serviceUse(Service)
 
-export type Patch = Omit<Partial<Info>, "time" | "share" | "summary" | "revert" | "permission"> & {
+export type Patch = Omit<Partial<Info>, "time" | "share" | "summary" | "revert" | "permission" | "result"> & {
   time?: Partial<Info["time"]>
   share?: Partial<NonNullable<Info["share"]>> | null
   summary?: Info["summary"] | null
   revert?: Info["revert"] | null
   permission?: Info["permission"] | null
+  result?: Info["result"] | null
 }
 
 const layer: Layer.Layer<
@@ -762,6 +763,7 @@ const layer: Layer.Layer<
           summary: info.summary === null ? undefined : (info.summary ?? current.summary),
           revert: info.revert === null ? undefined : (info.revert ?? current.revert),
           permission: info.permission === null ? undefined : (info.permission ?? current.permission),
+          result: info.result === null ? undefined : (info.result ?? current.result),
         } as Info
         yield* events.publish(SessionV1.Event.Updated, { sessionID, info: next })
       })

packages/opencode/src/tool/task.ts

@@ -449,6 +449,8 @@ export const TaskTool = Tool.define(
       // before starting (or extending) so a reused task_id doesn't inherit a
       // cancelled terminal record from its previous run.
       yield* interrupt.clear(nextSession.id)
+      // A reused task_id must not inherit a structured result envelope from its previous run.
+      if (session) yield* sessions.setResult({ sessionID: nextSession.id, result: null })
 
       if (yield* background.extend({ id: nextSession.id, run: runTask() })) {
         return {

packages/opencode/test/tool/task.test.ts

@@ -18,6 +18,7 @@ import { SessionStatus } from "@/session/status"
 
 import { Interrupt } from "../../src/session/interrupt"
 import { TaskTool, renderOutput, Event as TaskEventDef, type TaskPromptOps, childResultBlock } from "../../src/tool/task"
+import { TaskReturnTool } from "../../src/tool/task-return"
 import { Truncate } from "@/tool/truncate"
 import { ToolRegistry } from "@/tool/registry"
 import { RuntimeFlags } from "@/effect/runtime-flags"
@@ -276,6 +277,60 @@ describe("tool.task", () => {
     }),
   )
 
+  it.instance("does not replay a prior task_return result when resuming a task session", () =>
+    Effect.gen(function* () {
+      const events = yield* EventV2Bridge.Service
+      const sessions = yield* Session.Service
+      const { chat, assistant } = yield* seed()
+      const child = yield* sessions.create({ parentID: chat.id, title: "Existing child" })
+      const taskReturn = yield* TaskReturnTool
+      const taskReturnDef = yield* taskReturn.init()
+      const staleResult = { verdict: "OLD" }
+
+      yield* taskReturnDef.execute({ result: staleResult }, {
+        sessionID: child.id,
+        messageID: MessageID.ascending(),
+        agent: "general",
+        abort: new AbortController().signal,
+        messages: [],
+        metadata: () => Effect.void,
+        ask: () => Effect.void,
+      })
+
+      const captured = yield* Deferred.make<any>()
+      yield* events.listen((event) => {
+        if (event.type === TaskEventDef.Completed.type) return Deferred.succeed(captured, event)
+        return Effect.void
+      })
+
+      const tool = yield* TaskTool
+      const def = yield* tool.init()
+      const result = yield* def.execute(
+        {
+          description: "continue investigation",
+          prompt: "continue the investigation without returning a structured result",
+          subagent_type: "general",
+          task_id: child.id,
+        },
+        {
+          sessionID: chat.id,
+          messageID: assistant.id,
+          agent: "build",
+          abort: new AbortController().signal,
+          extra: { promptOps: stubOps({ text: "round two" }) },
+          messages: [],
+          metadata: () => Effect.void,
+          ask: () => Effect.void,
+        },
+      )
+
+      expect(result.output).not.toContain(JSON.stringify(staleResult, null, 2))
+      expect(result.output).not.toContain("<task_return>")
+      const event = yield* Deferred.await(captured)
+      expect(event.data.result).toBeUndefined()
+    }),
+  )
+
   it.instance("execute asks by default and skips checks when bypassed", () =>
     Effect.gen(function* () {
       const { chat, assistant } = yield* seed()