fix: drop session diff patches from tui cache

Allows beta releases to include properly signed Windows CLI executables, ensuring consistent security verification across all release channels.

.github/workflows/publish.yml

@@ -114,7 +114,7 @@ jobs:
       - build-cli
       - version
     runs-on: blacksmith-4vcpu-windows-2025
-    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'beta'
+    if: github.repository == 'anomalyco/opencode'
     env:
       AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
       AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
@@ -591,7 +591,6 @@ jobs:
           path: packages/opencode/dist
 
       - uses: actions/download-artifact@v4
-        if: github.ref_name != 'beta'
         with:
           name: opencode-cli-signed-windows
           path: packages/opencode/dist

packages/opencode/src/cli/cmd/tui/context/sync.tsx

@@ -31,6 +31,16 @@ import { batch, createEffect, on } from "solid-js"
 import { Log } from "@/util/log"
 import { ConsoleState, emptyConsoleState, type ConsoleState as ConsoleStateType } from "@/config/console-state"
 
+type SessionDiffSummary = Pick<Snapshot.FileDiff, "file" | "additions" | "deletions">
+
+function summarizeDiff(diff?: Snapshot.FileDiff[]): SessionDiffSummary[] {
+  return (diff ?? []).map((item) => ({
+    file: item.file,
+    additions: item.additions,
+    deletions: item.deletions,
+  }))
+}
+
 export const { use: useSync, provider: SyncProvider } = createSimpleContext({
   name: "Sync",
   init: () => {
@@ -55,7 +65,7 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
         [sessionID: string]: SessionStatus
       }
       session_diff: {
-        [sessionID: string]: Snapshot.FileDiff[]
+        [sessionID: string]: SessionDiffSummary[]
       }
       todo: {
         [sessionID: string]: Todo[]
@@ -193,7 +203,7 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
           break
 
         case "session.diff":
-          setStore("session_diff", event.properties.sessionID, event.properties.diff)
+          setStore("session_diff", event.properties.sessionID, summarizeDiff(event.properties.diff))
           break
 
         case "session.deleted": {
@@ -503,7 +513,7 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
               for (const message of messages.data!) {
                 draft.part[message.info.id] = message.parts
               }
-              draft.session_diff[sessionID] = diff.data ?? []
+              draft.session_diff[sessionID] = summarizeDiff(diff.data)
             }),
           )
           fullSyncedSessions.add(sessionID)

packages/opencode/src/plugin/github-copilot/copilot.ts

@@ -5,6 +5,7 @@ import { iife } from "@/util/iife"
 import { Log } from "../../util/log"
 import { setTimeout as sleep } from "node:timers/promises"
 import { CopilotModels } from "./models"
+import { MessageV2 } from "@/session/message-v2"
 
 const log = Log.create({ service: "plugin.copilot" })
 
@@ -27,6 +28,21 @@ function base(enterpriseUrl?: string) {
   return enterpriseUrl ? `https://copilot-api.${normalizeDomain(enterpriseUrl)}` : "https://api.githubcopilot.com"
 }
 
+// Check if a message is a synthetic user msg used to attach an image from a tool call
+function imgMsg(msg: any): boolean {
+  if (msg?.role !== "user") return false
+
+  // Handle the 3 api formats
+
+  const content = msg.content
+  if (typeof content === "string") return content === MessageV2.SYNTHETIC_ATTACHMENT_PROMPT
+  if (!Array.isArray(content)) return false
+  return content.some(
+    (part: any) =>
+      (part?.type === "text" || part?.type === "input_text") && part.text === MessageV2.SYNTHETIC_ATTACHMENT_PROMPT,
+  )
+}
+
 function fix(model: Model, url: string): Model {
   return {
     ...model,
@@ -90,7 +106,7 @@ export async function CopilotAuthPlugin(input: PluginInput): Promise<Hooks> {
                       (msg: any) =>
                         Array.isArray(msg.content) && msg.content.some((part: any) => part.type === "image_url"),
                     ),
-                    isAgent: last?.role !== "user",
+                    isAgent: last?.role !== "user" || imgMsg(last),
                   }
                 }
 
@@ -102,7 +118,7 @@ export async function CopilotAuthPlugin(input: PluginInput): Promise<Hooks> {
                       (item: any) =>
                         Array.isArray(item?.content) && item.content.some((part: any) => part.type === "input_image"),
                     ),
-                    isAgent: last?.role !== "user",
+                    isAgent: last?.role !== "user" || imgMsg(last),
                   }
                 }
 
@@ -124,7 +140,7 @@ export async function CopilotAuthPlugin(input: PluginInput): Promise<Hooks> {
                               part.content.some((nested: any) => nested?.type === "image")),
                         ),
                     ),
-                    isAgent: !(last?.role === "user" && hasNonToolCalls),
+                    isAgent: !(last?.role === "user" && hasNonToolCalls) || imgMsg(last),
                   }
                 }
               } catch {}

packages/opencode/src/session/message-v2.ts

@@ -25,6 +25,8 @@ interface FetchDecompressionError extends Error {
 }
 
 export namespace MessageV2 {
+  export const SYNTHETIC_ATTACHMENT_PROMPT = "Attached image(s) from tool result:"
+
   export function isMedia(mime: string) {
     return mime.startsWith("image/") || mime === "application/pdf"
   }
@@ -808,7 +810,7 @@ export namespace MessageV2 {
               parts: [
                 {
                   type: "text" as const,
-                  text: "Attached image(s) from tool result:",
+                  text: SYNTHETIC_ATTACHMENT_PROMPT,
                 },
                 ...media.map((attachment) => ({
                   type: "file" as const,

packages/opencode/src/v2/message.ts

@@ -10,59 +10,106 @@ export namespace Message {
     })),
   )
 
-  export class File extends Schema.Class<File>("Message.File")({
-    url: Schema.String,
+  export class Source extends Schema.Class<Source>("Message.Source")({
+    start: Schema.Number,
+    end: Schema.Number,
+    text: Schema.String,
+  }) {}
+
+  export class FileAttachment extends Schema.Class<FileAttachment>("Message.File.Attachment")({
+    uri: Schema.String,
     mime: Schema.String,
+    name: Schema.String.pipe(Schema.optional),
+    description: Schema.String.pipe(Schema.optional),
+    source: Source.pipe(Schema.optional),
   }) {
     static create(url: string) {
-      return new File({
-        url,
+      return new FileAttachment({
+        uri: url,
         mime: "text/plain",
       })
     }
   }
 
-  export class UserContent extends Schema.Class<UserContent>("Message.User.Content")({
-    text: Schema.String,
-    synthetic: Schema.Boolean.pipe(Schema.optional),
-    agent: Schema.String.pipe(Schema.optional),
-    files: Schema.Array(File).pipe(Schema.optional),
+  export class AgentAttachment extends Schema.Class<AgentAttachment>("Message.Agent.Attachment")({
+    name: Schema.String,
+    source: Source.pipe(Schema.optional),
   }) {}
 
   export class User extends Schema.Class<User>("Message.User")({
     id: ID,
     type: Schema.Literal("user"),
+    text: Schema.String,
+    files: Schema.Array(FileAttachment).pipe(Schema.optional),
+    agents: Schema.Array(AgentAttachment).pipe(Schema.optional),
     time: Schema.Struct({
       created: Schema.DateTimeUtc,
     }),
-    content: UserContent,
   }) {
-    static create(content: Schema.Schema.Type<typeof UserContent>) {
+    static create(input: { text: User["text"]; files?: User["files"]; agents?: User["agents"] }) {
       const msg = new User({
         id: ID.create(),
         type: "user",
+        ...input,
         time: {
           created: Effect.runSync(DateTime.now),
         },
-        content,
       })
       return msg
     }
-
-    static file(url: string) {
-      return new File({
-        url,
-        mime: "text/plain",
-      })
-    }
   }
 
-  export namespace User {}
+  export class Synthetic extends Schema.Class<Synthetic>("Message.Synthetic")({
+    id: ID,
+    type: Schema.Literal("synthetic"),
+    text: Schema.String,
+    time: Schema.Struct({
+      created: Schema.DateTimeUtc,
+    }),
+  }) {}
+
+  export class Request extends Schema.Class<Request>("Message.Request")({
+    id: ID,
+    type: Schema.Literal("start"),
+    model: Schema.Struct({
+      id: Schema.String,
+      providerID: Schema.String,
+      variant: Schema.String.pipe(Schema.optional),
+    }),
+    time: Schema.Struct({
+      created: Schema.DateTimeUtc,
+    }),
+  }) {}
+
+  export class Text extends Schema.Class<Text>("Message.Text")({
+    id: ID,
+    type: Schema.Literal("text"),
+    text: Schema.String,
+    time: Schema.Struct({
+      created: Schema.DateTimeUtc,
+      completed: Schema.DateTimeUtc.pipe(Schema.optional),
+    }),
+  }) {}
+
+  export class Complete extends Schema.Class<Complete>("Message.Complete")({
+    id: ID,
+    type: Schema.Literal("complete"),
+    time: Schema.Struct({
+      created: Schema.DateTimeUtc,
+    }),
+    cost: Schema.Number,
+    tokens: Schema.Struct({
+      total: Schema.Number,
+      input: Schema.Number,
+      output: Schema.Number,
+      reasoning: Schema.Number,
+      cache: Schema.Struct({
+        read: Schema.Number,
+        write: Schema.Number,
+      }),
+    }),
+  }) {}
+
+  export const Info = Schema.Union([User, Text])
+  export type Info = Schema.Schema.Type<typeof Info>
 }
-
-const msg = Message.User.create({
-  text: "Hello world",
-  files: [Message.File.create("file://example.com/file.txt")],
-})
-
-console.log(JSON.stringify(msg, null, 2))

packages/opencode/src/v2/session.ts

@@ -0,0 +1,71 @@
+import { Context, Layer, Schema, Effect } from "effect"
+import { Message } from "./message"
+import { Struct } from "effect"
+import { Identifier } from "@/id/id"
+import { withStatics } from "@/util/schema"
+import { Session } from "@/session"
+import { SessionID } from "@/session/schema"
+
+export namespace SessionV2 {
+  export const ID = SessionID
+
+  export type ID = Schema.Schema.Type<typeof ID>
+
+  export class PromptInput extends Schema.Class<PromptInput>("Session.PromptInput")({
+    ...Struct.omit(Message.User.fields, ["time", "type"]),
+    id: Schema.optionalKey(Message.ID),
+    sessionID: SessionV2.ID,
+  }) {}
+
+  export class CreateInput extends Schema.Class<CreateInput>("Session.CreateInput")({
+    id: Schema.optionalKey(SessionV2.ID),
+  }) {}
+
+  export class Info extends Schema.Class<Info>("Session.Info")({
+    id: SessionV2.ID,
+    model: Schema.Struct({
+      id: Schema.String,
+      providerID: Schema.String,
+      modelID: Schema.String,
+    }).pipe(Schema.optional),
+  }) {}
+
+  export interface Interface {
+    fromID: (id: SessionV2.ID) => Effect.Effect<Info>
+    create: (input: CreateInput) => Effect.Effect<Info>
+    prompt: (input: PromptInput) => Effect.Effect<Message.User>
+  }
+
+  export class Service extends Context.Service<Service, Interface>()("Session.Service") {}
+
+  export const layer = Layer.effect(Service)(
+    Effect.gen(function* () {
+      const session = yield* Session.Service
+
+      const create: Interface["create"] = Effect.fn("Session.create")(function* (input) {
+        throw new Error("Not implemented")
+      })
+
+      const prompt: Interface["prompt"] = Effect.fn("Session.prompt")(function* (input) {
+        throw new Error("Not implemented")
+      })
+
+      const fromID: Interface["fromID"] = Effect.fn("Session.fromID")(function* (id) {
+        const match = yield* session.get(id)
+        return fromV1(match)
+      })
+
+      return Service.of({
+        create,
+        prompt,
+        fromID,
+      })
+    }),
+  )
+
+  function fromV1(input: Session.Info): Info {
+    return new Info({
+      id: SessionV2.ID.make(input.id),
+    })
+  }
+}

packages/opencode/test/cli/tui/sync-provider.test.tsx

@@ -270,6 +270,7 @@ describe("SyncProvider", () => {
       expect(sync.data.message.ses_1[0]?.id).toBe("msg_1")
       expect(sync.data.part.msg_1[0]).toMatchObject({ type: "text", text: "part-ws_a" })
       expect(sync.data.session_diff.ses_1[0]?.file).toBe("ws_a.ts")
+      expect(sync.data.session_diff.ses_1[0]).not.toHaveProperty("patch")
 
       log.length = 0
       project.workspace.set("ws_b")
@@ -285,6 +286,7 @@ describe("SyncProvider", () => {
       expect(sync.data.message.ses_1[0]?.id).toBe("msg_1")
       expect(sync.data.part.msg_1[0]).toMatchObject({ type: "text", text: "part-ws_b" })
       expect(sync.data.session_diff.ses_1[0]?.file).toBe("ws_b.ts")
+      expect(sync.data.session_diff.ses_1[0]).not.toHaveProperty("patch")
     } finally {
       app.renderer.destroy()
     }