refactor(app): finish moving persisted stores off Effect Schema

The composer, prompt history and comment stores port to plain codecs, persisted() becomes codec-only and the Effect-based Persistence helpers are removed. Session-file import keeps validating against the shared Effect schema from a lazily loaded module with static imports, so the bundler keeps only what it uses. The desktop renderer's SSH reconnect polls with a timer instead of an Effect schedule. Effect remains in the renderer's initial graph only through the shared schema package's ID helpers.

packages/app/package.json

@@ -10,7 +10,8 @@
     "./i18n/desktop-native": "./src/runtime/i18n/desktop-native.ts",
     "./updater": "./src/shell/updates/types.ts",
     "./wsl/types": "./src/servers/wsl/types.ts",
-    "./ssh": "./src/servers/ssh/types.ts",
+    "./ssh": "./src/servers/ssh/types.ts",
+    "./ssh/schema": "./src/servers/ssh/schema.ts",
     "./vite": "./vite.js",
     "./index.css": "./src/index.css"
   },
@@ -94,3 +95,4 @@
     "tailwindcss": "4.3.3"
   }
 }
+

packages/app/src/composer/history/entry.test.ts

@@ -1,9 +1,8 @@
 import { describe, expect, test } from "bun:test"
 import type { Prompt } from "@/composer/state"
 import { prependHistoryEntry, removeHistoryEntry, type PromptHistoryComment } from "./entry"
-import { Schema } from "effect"
 import { PromptHistoryState } from "../schema"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
 
 const DEFAULT_PROMPT: Prompt = [{ type: "text", content: "", start: 0, end: 0 }]
 
@@ -79,7 +78,7 @@ describe("Composer history", () => {
 
   test("upgrades stored prompt arrays once at the persistence boundary", () => {
     expect(
-      Schema.decodeUnknownSync(Persistence.withInitial(PromptHistoryState, { entries: [] }))({
+      Codec.decodeOrThrow(Codec.withInitial(PromptHistoryState, { entries: [] }), {
         entries: [text("stored")],
       }),
     ).toEqual({

packages/app/src/composer/schema.test.ts

@@ -1,6 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { Schema } from "effect"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
 import { SessionMessage } from "@opencode/schema/session-message"
 import {
   CommentStore,
@@ -24,9 +23,8 @@ const comment = { id: "comment", path: "src/app.ts", selection: { start: 1, end:
 
 describe("composer persistence schemas", () => {
   test("defaults missing or invalid fields independently and normalizes the cursor", () => {
-    const decode = Schema.decodeUnknownSync(
-      Persistence.withInitial(ComposerStore, { prompt: DEFAULT_PROMPT, context: { items: [] } }),
-    )
+    const decode = (input: unknown) =>
+      Codec.decodeOrThrow(Codec.withInitial(ComposerStore, { prompt: DEFAULT_PROMPT, context: { items: [] } }), input)
     expect(decode({})).toEqual({ prompt: DEFAULT_PROMPT, context: { items: [] } })
     const value = decode({
       prompt: [null, { type: "unknown" }],
@@ -54,29 +52,30 @@ describe("composer persistence schemas", () => {
   })
 
   test("drops invalid parts without losing valid mentions or optional field recovery", () => {
-    const value = Schema.decodeUnknownSync(
-      Persistence.withInitial(ComposerStore, { prompt: DEFAULT_PROMPT, context: { items: [] } }),
-    )({
-      prompt: [
-        text,
-        { type: "agent", content: "@build", start: 5, end: 11, name: "build" },
-        { type: "skill", content: "@effect", start: 11, end: 18, id: "effect", name: "Effect" },
-        { type: "agent", content: "@broken", start: 18, end: 25, name: 42 },
-        {
-          type: "file",
-          path: "src/app.ts",
-          content: "@src/app.ts",
-          start: 18,
-          end: 29,
-          selection: { startLine: "broken" },
-          mime: 42,
-          filename: "app.ts",
-          source: { type: "invalid" },
-        },
-      ],
-      model: { providerID: "provider", modelID: "model", variant: null },
-      retry: { id: "msg_retry", agent: "build", providerID: "provider", modelID: "model", variant: false },
-    })
+    const value = Codec.decodeOrThrow(
+      Codec.withInitial(ComposerStore, { prompt: DEFAULT_PROMPT, context: { items: [] } }),
+      {
+        prompt: [
+          text,
+          { type: "agent", content: "@build", start: 5, end: 11, name: "build" },
+          { type: "skill", content: "@effect", start: 11, end: 18, id: "effect", name: "Effect" },
+          { type: "agent", content: "@broken", start: 18, end: 25, name: 42 },
+          {
+            type: "file",
+            path: "src/app.ts",
+            content: "@src/app.ts",
+            start: 18,
+            end: 29,
+            selection: { startLine: "broken" },
+            mime: 42,
+            filename: "app.ts",
+            source: { type: "invalid" },
+          },
+        ],
+        model: { providerID: "provider", modelID: "model", variant: null },
+        retry: { id: "msg_retry", agent: "build", providerID: "provider", modelID: "model", variant: false },
+      },
+    )
     expect(value.prompt.map((part) => part.type)).toEqual(["text", "agent", "skill", "file"])
     expect(value.prompt[3]).toEqual({
       type: "file",
@@ -94,9 +93,10 @@ describe("composer persistence schemas", () => {
       modelID: "model",
     })
     expect(
-      Schema.decodeUnknownSync(
-        Persistence.withInitial(ComposerStore, { prompt: DEFAULT_PROMPT, context: { items: [] } }),
-      )(Schema.encodeSync(ComposerStore)(value)),
+      Codec.decodeOrThrow(
+        Codec.withInitial(ComposerStore, { prompt: DEFAULT_PROMPT, context: { items: [] } }),
+        ComposerStore.encode(value),
+      ),
     ).toEqual(value)
   })
 
@@ -114,41 +114,44 @@ describe("composer persistence schemas", () => {
         text: sourceText,
       },
     ]
-    const value = Schema.decodeUnknownSync(
-      Persistence.withInitial(ComposerStore, { prompt: DEFAULT_PROMPT, context: { items: [] } }),
-    )({
-      prompt: sources.map((source) => ({
-        type: "file",
-        path: "src/app.ts",
-        content: "@source",
-        start: 0,
-        end: 7,
-        source,
-        selection: { startLine: 1, startChar: 0, endLine: 2, endChar: 1 },
-      })),
-    })
+    const value = Codec.decodeOrThrow(
+      Codec.withInitial(ComposerStore, { prompt: DEFAULT_PROMPT, context: { items: [] } }),
+      {
+        prompt: sources.map((source) => ({
+          type: "file",
+          path: "src/app.ts",
+          content: "@source",
+          start: 0,
+          end: 7,
+          source,
+          selection: { startLine: 1, startChar: 0, endLine: 2, endChar: 1 },
+        })),
+      },
+    )
     expect(value.prompt).toHaveLength(3)
     expect(value.prompt.map((part) => part.type === "file" && part.source)).toEqual(sources)
     expect(
-      Schema.decodeUnknownSync(
-        Persistence.withInitial(ComposerStore, { prompt: DEFAULT_PROMPT, context: { items: [] } }),
-      )(Schema.encodeSync(ComposerStore)(value)),
+      Codec.decodeOrThrow(
+        Codec.withInitial(ComposerStore, { prompt: DEFAULT_PROMPT, context: { items: [] } }),
+        ComposerStore.encode(value),
+      ),
     ).toEqual(value)
   })
 
   test("migrates inline images, keeps store references without a URL, and never encodes dataUrl", () => {
-    const value = Schema.decodeUnknownSync(
-      Persistence.withInitial(ComposerStore, { prompt: DEFAULT_PROMPT, context: { items: [] } }),
-    )({
-      prompt: [
-        { ...image, dataUrl: "data:image/png;base64,YQ==", sourcePath: "/image.png" },
-        { ...image, blob: { id: "data:image/png;base64,Yg==" } },
-        { ...image, blob: { id: "hash", url: "blob:hydrated" } },
-        { ...image, blob: { id: "missing" } },
-        { ...image, blob: { id: "bad", url: "https://example.com/image.png" } },
-        { ...image, blob: { id: "missing" }, dataUrl: "data:image/png;base64,YQ==" },
-      ],
-    })
+    const value = Codec.decodeOrThrow(
+      Codec.withInitial(ComposerStore, { prompt: DEFAULT_PROMPT, context: { items: [] } }),
+      {
+        prompt: [
+          { ...image, dataUrl: "data:image/png;base64,YQ==", sourcePath: "/image.png" },
+          { ...image, blob: { id: "data:image/png;base64,Yg==" } },
+          { ...image, blob: { id: "hash", url: "blob:hydrated" } },
+          { ...image, blob: { id: "missing" } },
+          { ...image, blob: { id: "bad", url: "https://example.com/image.png" } },
+          { ...image, blob: { id: "missing" }, dataUrl: "data:image/png;base64,YQ==" },
+        ],
+      },
+    )
     expect(value.prompt).toHaveLength(6)
     expect(value.prompt[0]).toEqual({
       ...image,
@@ -159,17 +162,18 @@ describe("composer persistence schemas", () => {
     expect(value.prompt[3]).toEqual({ ...image, blob: { id: "missing", url: "" } })
     expect(value.prompt[4]).toEqual({ ...image, blob: { id: "bad", url: "" } })
     expect(value.prompt[5]).toEqual({ ...image, blob: { id: "missing", url: "" } })
-    const encoded = Schema.encodeSync(ComposerStore)(value)
+    const encoded = ComposerStore.encode(value)
     expect(JSON.stringify(encoded)).not.toContain("dataUrl")
     expect(
-      Schema.decodeUnknownSync(
-        Persistence.withInitial(ComposerStore, { prompt: DEFAULT_PROMPT, context: { items: [] } }),
-      )(encoded),
+      Codec.decodeOrThrow(
+        Codec.withInitial(ComposerStore, { prompt: DEFAULT_PROMPT, context: { items: [] } }),
+        encoded,
+      ),
     ).toEqual(value)
   })
 
   test("migrates legacy history arrays and recovers entries, parts, and comments independently", () => {
-    const value = Schema.decodeUnknownSync(Persistence.withInitial(PromptHistoryState, { entries: [] }))({
+    const value = Codec.decodeOrThrow(Codec.withInitial(PromptHistoryState, { entries: [] }), {
       entries: [
         [text, null, { ...image, dataUrl: "data:image/png;base64,YQ==" }],
         null,
@@ -184,15 +188,13 @@ describe("composer persistence schemas", () => {
     expect(value.entries[0].comments).toEqual([])
     expect(value.entries[1]).toEqual({ prompt: [text], comments: [comment] })
     expect(value.entries[2]).toEqual({ prompt: [text], comments: [] })
-    const encoded = Schema.encodeSync(PromptHistoryState)(value)
+    const encoded = PromptHistoryState.encode(value)
     expect(encoded.entries?.every((entry) => !Array.isArray(entry))).toBe(true)
     expect(JSON.stringify(encoded)).not.toContain("dataUrl")
-    expect(Schema.decodeUnknownSync(Persistence.withInitial(PromptHistoryState, { entries: [] }))(encoded)).toEqual(
-      value,
+    expect(Codec.decodeOrThrow(Codec.withInitial(PromptHistoryState, { entries: [] }), encoded)).toEqual(value)
+    expect(Codec.decodeOrThrow(Codec.withInitial(PromptHistoryState, { entries: [] }), { entries: "invalid" })).toEqual(
+      { entries: [] },
     )
-    expect(
-      Schema.decodeUnknownSync(Persistence.withInitial(PromptHistoryState, { entries: [] }))({ entries: "invalid" }),
-    ).toEqual({ entries: [] })
   })
 
   test("recovers comments per file and entry without discarding healthy siblings", () => {
@@ -203,7 +205,7 @@ describe("composer persistence schemas", () => {
       comment: "note",
       time: 1,
     }
-    const value = Schema.decodeUnknownSync(Persistence.withInitial(CommentStore, { comments: {} }))({
+    const value = Codec.decodeOrThrow(Codec.withInitial(CommentStore, { comments: {} }), {
       comments: {
         "src/app.ts": [line, null, { ...line, time: "bad" }, { ...line, selection: { start: 2, end: 4, side: "bad" } }],
         "broken.ts": { invalid: true },
@@ -213,16 +215,14 @@ describe("composer persistence schemas", () => {
     expect(value.comments["src/app.ts"]).toEqual([line, { ...line, selection: { start: 2, end: 4 } }])
     expect(value.comments["broken.ts"]).toEqual([])
     expect(value.comments["healthy.ts"]).toEqual([{ ...line, file: "healthy.ts" }])
-    expect(
-      Schema.decodeUnknownSync(Persistence.withInitial(CommentStore, { comments: {} }))(
-        Schema.encodeSync(CommentStore)(value),
-      ),
-    ).toEqual(value)
-    expect(Schema.decodeUnknownSync(Persistence.withInitial(CommentStore, { comments: {} }))({})).toEqual({
+    expect(Codec.decodeOrThrow(Codec.withInitial(CommentStore, { comments: {} }), CommentStore.encode(value))).toEqual(
+      value,
+    )
+    expect(Codec.decodeOrThrow(Codec.withInitial(CommentStore, { comments: {} }), {})).toEqual({
+      comments: {},
+    })
+    expect(Codec.decodeOrThrow(Codec.withInitial(CommentStore, { comments: {} }), { comments: [] })).toEqual({
       comments: {},
     })
-    expect(Schema.decodeUnknownSync(Persistence.withInitial(CommentStore, { comments: {} }))({ comments: [] })).toEqual(
-      { comments: {} },
-    )
   })
 })

packages/app/src/composer/schema.ts

@@ -1,111 +1,133 @@
-import { Schema, SchemaGetter } from "effect"
 import { checksum } from "@opencode/util/encode"
-import { SessionMessage } from "@opencode/schema/session-message"
-import { Skill } from "@opencode/schema/skill"
-import { Persistence } from "@/runtime/persistence/schema"
+import type { SessionMessage } from "@opencode/schema/session-message"
+import type { Skill } from "@opencode/schema/skill"
+import { Codec } from "@/runtime/persistence/codec"
 import { FileSelection, SelectedLineRange } from "@/workspaces/files/types"
 
+// Identifiers defined by the shared Effect schemas keep their branded types; the renderer checks
+// them as strings so the shared schema module stays out of its startup path.
+const branded = <T extends string>() =>
+  Codec.make<T, string>(
+    (v) => (typeof v === "string" ? (v as T) : Codec.INVALID),
+    (v) => v,
+  )
+const SkillID = branded<typeof Skill.ID.Type>()
+const SkillName = branded<typeof Skill.Name.Type>()
+const MessageID = Codec.make<typeof SessionMessage.ID.Type, string>(
+  (v) => (typeof v === "string" && v.startsWith("msg_") ? (v as typeof SessionMessage.ID.Type) : Codec.INVALID),
+  (v) => v,
+)
+const nonEmptyString = Codec.make<string, string>(
+  (v) => (typeof v === "string" && v.length > 0 ? v : Codec.INVALID),
+  (v) => v,
+)
+
 const PartBase = {
-  content: Schema.String,
-  start: Schema.Number,
-  end: Schema.Number,
+  content: Codec.string,
+  start: Codec.number,
+  end: Codec.number,
 }
 
-const SourceText = Schema.Struct({ value: Schema.String, start: Schema.Number, end: Schema.Number })
-const Position = Schema.Struct({ line: Schema.Number, character: Schema.Number })
-const FilePartSource = Schema.Union([
-  Schema.Struct({ type: Schema.Literal("file"), text: SourceText, path: Schema.String }),
-  Schema.Struct({
-    type: Schema.Literal("symbol"),
+const SourceText = Codec.struct({ value: Codec.string, start: Codec.number, end: Codec.number })
+const Position = Codec.struct({ line: Codec.number, character: Codec.number })
+const FilePartSource = Codec.union([
+  Codec.struct({ type: Codec.literal("file"), text: SourceText, path: Codec.string }),
+  Codec.struct({
+    type: Codec.literal("symbol"),
     text: SourceText,
-    path: Schema.String,
-    range: Schema.Struct({ start: Position, end: Position }),
-    name: Schema.String,
-    kind: Schema.Number,
+    path: Codec.string,
+    range: Codec.struct({ start: Position, end: Position }),
+    name: Codec.string,
+    kind: Codec.number,
   }),
-  Schema.Struct({ type: Schema.Literal("resource"), text: SourceText, clientName: Schema.String, uri: Schema.String }),
+  Codec.struct({ type: Codec.literal("resource"), text: SourceText, clientName: Codec.string, uri: Codec.string }),
 ])
 
-export const TextPart = Persistence.struct({ type: Schema.Literal("text"), ...PartBase })
+export const TextPart = Codec.struct({ type: Codec.literal("text"), ...PartBase })
 export type TextPart = typeof TextPart.Type
 
-export const FileAttachmentPart = Persistence.struct({
-  type: Schema.Literal("file"),
+export const FileAttachmentPart = Codec.struct({
+  type: Codec.literal("file"),
   ...PartBase,
-  path: Schema.String,
-  selection: Persistence.optional(FileSelection),
-  mime: Persistence.optional(Schema.String),
-  filename: Persistence.optional(Schema.String),
-  url: Persistence.optional(Schema.String),
-  source: Persistence.optional(FilePartSource),
+  path: Codec.string,
+  selection: Codec.lenientOptional(FileSelection),
+  mime: Codec.lenientOptional(Codec.string),
+  filename: Codec.lenientOptional(Codec.string),
+  url: Codec.lenientOptional(Codec.string),
+  source: Codec.lenientOptional(FilePartSource),
 })
 export type FileAttachmentPart = typeof FileAttachmentPart.Type
 
-export const AgentPart = Persistence.struct({ type: Schema.Literal("agent"), ...PartBase, name: Schema.String })
+export const AgentPart = Codec.struct({ type: Codec.literal("agent"), ...PartBase, name: Codec.string })
 export type AgentPart = typeof AgentPart.Type
 
-export const SkillPart = Persistence.struct({
-  type: Schema.Literal("skill"),
+export const SkillPart = Codec.struct({
+  type: Codec.literal("skill"),
   ...PartBase,
-  id: Skill.ID,
-  name: Skill.Name,
+  id: SkillID,
+  name: SkillName,
 })
 export type SkillPart = typeof SkillPart.Type
 
 const ImageFields = {
-  type: Schema.Literal("image"),
-  id: Schema.String,
-  filename: Schema.String,
-  sourcePath: Persistence.optional(Schema.String),
-  mime: Schema.String,
+  type: Codec.literal("image"),
+  id: Codec.string,
+  filename: Codec.string,
+  sourcePath: Codec.lenientOptional(Codec.string),
+  mime: Codec.string,
 }
-const Image = Persistence.struct({
+const Image = Codec.struct({
   ...ImageFields,
   // An empty URL is an image whose bytes are still in the draft store; see `resolveBlobUrl`.
-  blob: Schema.Struct({ id: Schema.NonEmptyString, url: Schema.String.check(Schema.isPattern(/^(blob:|data:|$)/)) }),
+  blob: Codec.struct({
+    id: nonEmptyString,
+    url: Codec.make<string, string>(
+      (v) => (typeof v === "string" && /^(blob:|data:|$)/.test(v) ? v : Codec.INVALID),
+      (v) => v,
+    ),
+  }),
+})
+const StoredImage = Codec.struct({
+  ...ImageFields,
+  blob: Codec.lenientOptional(
+    Codec.struct({ id: Codec.lenientOptional(Codec.string), url: Codec.lenientOptional(Codec.string) }),
+  ),
+  dataUrl: Codec.lenientOptional(Codec.string),
 })
 
 // Draft storage keeps content-addressed blobs in the store until an image is shown or sent; a
 // reference without a URL resolves through `resolveBlobUrl`. Legacy inline data remains usable.
-export const ImageAttachmentPart = Schema.Struct({
-  ...ImageFields,
-  blob: Persistence.optional(
-    Schema.Struct({ id: Persistence.optional(Schema.String), url: Persistence.optional(Schema.String) }),
-  ),
-  dataUrl: Persistence.optional(Schema.String),
-}).pipe(
-  Schema.decodeTo(Schema.toType(Image), {
-    decode: SchemaGetter.transform((value) => {
-      const id = value.blob?.id ?? value.dataUrl ?? ""
-      const url = value.blob?.url
-      return {
-        type: value.type,
-        id: value.id,
-        filename: value.filename,
-        sourcePath: value.sourcePath,
-        mime: value.mime,
-        blob: {
-          id,
-          url: url?.startsWith("blob:") || url?.startsWith("data:") ? url : id.startsWith("data:") ? id : "",
-        },
-      }
-    }),
-    encode: SchemaGetter.transform((value) => value),
-  }),
-)
+export const ImageAttachmentPart = Codec.decodeTo(StoredImage, Image, {
+  decode: (value) => {
+    const id = value.blob?.id ?? value.dataUrl ?? ""
+    const url = value.blob?.url
+    return {
+      type: value.type,
+      id: value.id,
+      filename: value.filename,
+      sourcePath: value.sourcePath,
+      mime: value.mime,
+      blob: {
+        id,
+        url: url?.startsWith("blob:") || url?.startsWith("data:") ? url : id.startsWith("data:") ? id : "",
+      },
+    }
+  },
+  encode: (value) => value,
+})
 export type ImageAttachmentPart = typeof ImageAttachmentPart.Type
 
 // A file the model receives as a path on the server: its bytes never enter the draft store.
-export const PathAttachmentPart = Persistence.struct({
-  type: Schema.Literal("path"),
-  id: Schema.String,
-  filename: Schema.String,
-  mime: Schema.String,
-  path: Schema.String,
+export const PathAttachmentPart = Codec.struct({
+  type: Codec.literal("path"),
+  id: Codec.string,
+  filename: Codec.string,
+  mime: Codec.string,
+  path: Codec.string,
 })
 export type PathAttachmentPart = typeof PathAttachmentPart.Type
 
-export const ContentPart = Schema.Union([
+export const ContentPart = Codec.union([
   TextPart,
   FileAttachmentPart,
   AgentPart,
@@ -114,24 +136,24 @@ export const ContentPart = Schema.Union([
   PathAttachmentPart,
 ])
 export type ContentPart = typeof ContentPart.Type
-export const Prompt = Persistence.array(ContentPart)
+export const Prompt = Codec.lenientArray(ContentPart)
 export type Prompt = typeof Prompt.Type
 
-export const PromptModel = Persistence.struct({
-  providerID: Schema.String,
-  modelID: Schema.String,
-  variant: Persistence.optional(Schema.NullOr(Schema.String)),
+export const PromptModel = Codec.struct({
+  providerID: Codec.string,
+  modelID: Codec.string,
+  variant: Codec.lenientOptional(Codec.nullOr(Codec.string)),
 })
 export type PromptModel = typeof PromptModel.Type
 
-export const FileContextItem = Persistence.struct({
-  type: Schema.Literal("file"),
-  path: Schema.String,
-  selection: Persistence.optional(FileSelection),
-  comment: Persistence.optional(Schema.String),
-  commentID: Persistence.optional(Schema.String),
-  commentOrigin: Persistence.optional(Schema.Literals(["review", "file"])),
-  preview: Persistence.optional(Schema.String),
+export const FileContextItem = Codec.struct({
+  type: Codec.literal("file"),
+  path: Codec.string,
+  selection: Codec.lenientOptional(FileSelection),
+  comment: Codec.lenientOptional(Codec.string),
+  commentID: Codec.lenientOptional(Codec.string),
+  commentOrigin: Codec.lenientOptional(Codec.literals(["review", "file"])),
+  preview: Codec.lenientOptional(Codec.string),
 })
 export type FileContextItem = typeof FileContextItem.Type
 export type ContextItem = FileContextItem
@@ -145,86 +167,73 @@ export function contextItemKey(item: ContextItem) {
   return `${key}:c=${digest.slice(0, 8)}`
 }
 
-const ContextEntry = Schema.Struct({ ...FileContextItem.fields, key: Persistence.optional(Schema.String) }).pipe(
-  Schema.decodeTo(Persistence.struct({ ...FileContextItem.fields, key: Schema.String }).pipe(Schema.toType), {
-    decode: SchemaGetter.transform((item) => ({ ...item, key: contextItemKey(item) })),
-    encode: SchemaGetter.transform((item) => item),
-  }),
-)
+const StoredContextEntry = Codec.struct({ ...FileContextItem.fields, key: Codec.lenientOptional(Codec.string) })
+const ContextEntry = Codec.transform(StoredContextEntry, {
+  decode: (item) => ({ ...item, key: contextItemKey(item) }),
+  encode: (item) => item,
+})
 
 export const DEFAULT_PROMPT: Prompt = [{ type: "text", content: "", start: 0, end: 0 }]
 
-export const ComposerStore = Persistence.struct({
-  prompt: Prompt.pipe(
-    Schema.decode({
-      decode: SchemaGetter.transform((prompt) =>
-        prompt.length ? prompt : DEFAULT_PROMPT.map((part) => ({ ...part })),
-      ),
-      encode: SchemaGetter.transform((prompt) => prompt),
+const Cursor = Codec.transform(Codec.number, { decode: (cursor) => Math.max(0, cursor), encode: (cursor) => cursor })
+
+export const ComposerStore = Codec.struct({
+  prompt: Codec.transform(Prompt, {
+    decode: (prompt) => (prompt.length ? prompt : DEFAULT_PROMPT.map((part) => ({ ...part }))),
+    encode: (prompt) => prompt,
+  }),
+  cursor: Codec.lenientOptional(Cursor),
+  model: Codec.lenientOptional(PromptModel),
+  mode: Codec.lenientOptional(Codec.literals(["normal", "shell"])),
+  retry: Codec.lenientOptional(
+    Codec.struct({
+      id: MessageID,
+      agent: Codec.string,
+      providerID: Codec.string,
+      modelID: Codec.string,
+      variant: Codec.lenientOptional(Codec.string),
     }),
   ),
-  cursor: Persistence.optional(
-    Schema.Finite.pipe(
-      Schema.decode({
-        decode: SchemaGetter.transform((cursor) => Math.max(0, cursor)),
-        encode: SchemaGetter.transform((cursor) => cursor),
-      }),
-    ),
-  ),
-  model: Persistence.optional(PromptModel),
-  mode: Persistence.optional(Schema.Literals(["normal", "shell"])),
-  retry: Persistence.optional(
-    Schema.Struct({
-      id: SessionMessage.ID,
-      agent: Schema.String,
-      providerID: Schema.String,
-      modelID: Schema.String,
-      variant: Persistence.optional(Schema.String),
-    }),
-  ),
-  context: Persistence.struct({ items: Persistence.array(ContextEntry) }),
+  context: Codec.struct({ items: Codec.lenientArray(ContextEntry) }),
 })
 export type ComposerStore = typeof ComposerStore.Type
 
-export const LineComment = Persistence.struct({
-  id: Schema.String,
-  file: Schema.String,
+export const LineComment = Codec.struct({
+  id: Codec.string,
+  file: Codec.string,
   selection: SelectedLineRange,
-  comment: Schema.String,
-  time: Schema.Number,
+  comment: Codec.string,
+  time: Codec.number,
 })
 export type LineComment = typeof LineComment.Type
 
-export const CommentStore = Persistence.struct({
-  comments: Schema.Record(Schema.String, Schema.mutableKey(Persistence.array(LineComment))),
+export const CommentStore = Codec.struct({
+  comments: Codec.record(Codec.lenientArray(LineComment)),
 })
 export type CommentStore = typeof CommentStore.Type
 
-export const PromptHistoryComment = Persistence.struct({
-  id: Schema.String,
-  path: Schema.String,
+export const PromptHistoryComment = Codec.struct({
+  id: Codec.string,
+  path: Codec.string,
   selection: SelectedLineRange,
-  comment: Schema.String,
-  time: Schema.Number,
-  origin: Persistence.optional(Schema.Literals(["review", "file"])),
-  preview: Persistence.optional(Schema.String),
+  comment: Codec.string,
+  time: Codec.number,
+  origin: Codec.lenientOptional(Codec.literals(["review", "file"])),
+  preview: Codec.lenientOptional(Codec.string),
 })
 export type PromptHistoryComment = typeof PromptHistoryComment.Type
 
 // History entries require a prompt array; only its individual parts recover.
-const HistoryPrompt = Schema.Array(Persistence.fallback(Schema.UndefinedOr(ContentPart), () => undefined)).pipe(
-  Schema.decodeTo(Schema.toType(Prompt), {
-    decode: SchemaGetter.transform((parts) => parts.filter((part) => part !== undefined)),
-    encode: SchemaGetter.transform((parts) => parts),
-  }),
-)
-const HistoryEntry = Schema.Struct({ prompt: HistoryPrompt, comments: Persistence.array(PromptHistoryComment) })
-export const PromptHistoryEntry = Schema.Union([HistoryEntry, HistoryPrompt]).pipe(
-  Schema.decodeTo(Schema.toType(HistoryEntry), {
-    decode: SchemaGetter.transform((entry) => ("prompt" in entry ? entry : { prompt: entry, comments: [] })),
-    encode: SchemaGetter.transform((entry) => entry),
-  }),
-)
+const HistoryPrompt = Codec.transform(Codec.array(Codec.fallback(Codec.undefinedOr(ContentPart), () => undefined)), {
+  decode: (parts): Prompt => parts.filter((part) => part !== undefined),
+  encode: (parts) => parts,
+})
+const HistoryEntry = Codec.struct({ prompt: HistoryPrompt, comments: Codec.lenientArray(PromptHistoryComment) })
+export const PromptHistoryEntry = Codec.transform(Codec.union([HistoryEntry, HistoryPrompt]), {
+  decode: (entry): typeof HistoryEntry.Type => ("prompt" in entry ? entry : { prompt: entry, comments: [] }),
+  encode: (entry) => entry,
+})
 export type PromptHistoryEntry = typeof PromptHistoryEntry.Type
 
-export const PromptHistoryState = Persistence.struct({ entries: Persistence.array(PromptHistoryEntry) })
+export const PromptHistoryState = Codec.struct({ entries: Codec.lenientArray(PromptHistoryEntry) })
+

packages/app/src/composer/state.test.ts

@@ -1,8 +1,7 @@
 import { describe, expect, test } from "bun:test"
 import { createRoot } from "solid-js"
 import { Skill } from "@opencode/schema/skill"
-import { Schema, Option } from "effect"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
 import { createMemoryComposerState, DEFAULT_PROMPT } from "./state"
 import { ComposerStore } from "./schema"
 
@@ -32,51 +31,52 @@ describe("prompt state initialization", () => {
   })
 
   test("parses persisted state into one trusted current shape", () => {
-    const parsed = Schema.decodeUnknownSync(
-      Persistence.withInitial(ComposerStore, { prompt: DEFAULT_PROMPT, context: { items: [] } }),
-    )({
-      prompt: [
-        { type: "text", content: "hello", start: 0, end: 5 },
-        { type: "skill", id: "effect", name: "Effect", content: "@effect", start: 5, end: 12 },
-        { type: "image", id: "broken", filename: "broken.png", mime: "image/png", blob: { id: 42 } },
-        {
-          type: "image",
-          id: "missing-blob",
-          filename: "missing.png",
-          mime: "image/png",
-          blob: { id: "content-hash-without-a-url" },
-        },
-        {
-          type: "image",
-          id: "invalid-url",
-          filename: "invalid.png",
-          mime: "image/png",
-          blob: { id: "hash", url: "relative-url" },
-        },
-        {
-          type: "image",
-          id: "legacy",
-          filename: "legacy.png",
-          mime: "image/png",
-          dataUrl: "data:image/png;base64,AAA",
-        },
-      ],
-      cursor: -2,
-      model: { providerID: "anthropic", modelID: "claude", variant: "high" },
-      retry: { id: "invalid", agent: "build", providerID: "anthropic", modelID: "claude" },
-      context: {
-        items: [
+    const parsed = Codec.decodeOrThrow(
+      Codec.withInitial(ComposerStore, { prompt: DEFAULT_PROMPT, context: { items: [] } }),
+      {
+        prompt: [
+          { type: "text", content: "hello", start: 0, end: 5 },
+          { type: "skill", id: "effect", name: "Effect", content: "@effect", start: 5, end: 12 },
+          { type: "image", id: "broken", filename: "broken.png", mime: "image/png", blob: { id: 42 } },
           {
-            type: "file",
-            path: "src/app.ts",
-            selection: { startLine: 1, startChar: 0, endLine: 2, endChar: 3 },
-            comment: "Check this",
-            key: "untrusted",
+            type: "image",
+            id: "missing-blob",
+            filename: "missing.png",
+            mime: "image/png",
+            blob: { id: "content-hash-without-a-url" },
+          },
+          {
+            type: "image",
+            id: "invalid-url",
+            filename: "invalid.png",
+            mime: "image/png",
+            blob: { id: "hash", url: "relative-url" },
+          },
+          {
+            type: "image",
+            id: "legacy",
+            filename: "legacy.png",
+            mime: "image/png",
+            dataUrl: "data:image/png;base64,AAA",
           },
-          { type: "file", path: 42 },
         ],
+        cursor: -2,
+        model: { providerID: "anthropic", modelID: "claude", variant: "high" },
+        retry: { id: "invalid", agent: "build", providerID: "anthropic", modelID: "claude" },
+        context: {
+          items: [
+            {
+              type: "file",
+              path: "src/app.ts",
+              selection: { startLine: 1, startChar: 0, endLine: 2, endChar: 3 },
+              comment: "Check this",
+              key: "untrusted",
+            },
+            { type: "file", path: 42 },
+          ],
+        },
       },
-    })
+    )
     expect(parsed).toEqual({
       prompt: [
         { type: "text", content: "hello", start: 0, end: 5 },
@@ -119,6 +119,6 @@ describe("prompt state initialization", () => {
         ],
       },
     })
-    expect(Option.isNone(Schema.decodeUnknownOption(ComposerStore)("not an object"))).toBe(true)
+    expect(Codec.decodeOption(ComposerStore, "not an object")).toBeUndefined()
   })
 })

packages/app/src/home/projects/controller.tsx

@@ -1,186 +1,190 @@
-import { useDirectoryPicker } from "@/workspaces/selection/picker"
-import { useServerActionsController } from "@/servers/registry/controller"
-import { useSettingsCommand } from "@/settings/command"
-import { useSettingsSurface } from "@/settings/surface"
-import { type LocalProject } from "@/shell/state/layout"
-import { useLanguage } from "@/runtime/i18n/language"
-import { usePlatform } from "@/runtime/platform/platform"
-import { ServerConnection } from "@/runtime/server/registry"
-import { closeHomeProject, errorMessage, homeProjectDirectories } from "@/shell/layout/helpers"
-import { Persist, persisted } from "@/runtime/persistence/storage"
-import { showToast } from "@/shell/notifications/toast"
-import { useDialog } from "@opencode/ui/context/dialog"
-import { createResource } from "solid-js"
-import { Schema } from "effect"
-import { Persistence } from "@/runtime/persistence/schema"
-import type { HomeController } from "../model"
-import { useGlobal } from "@/runtime/server/runtime"
-import { SessionTransfer } from "@opencode/schema/session-transfer"
-import { useSshAuthenticate } from "@/servers/ssh/authenticate"
-
-export const HomeServersSchema = Schema.Struct({
-  collapsed: Persistence.record(Persistence.fallback(Schema.Boolean, () => false)),
-})
-
-export function createHomeProjectsController(home: HomeController) {
-  const platform = usePlatform()
-  const pickDirectory = useDirectoryPicker()
-  const dialog = useDialog()
-  const language = useLanguage()
-  const openSettings = useSettingsCommand()
-  const settings = useSettingsSurface()
-  const serverManagement = useServerActionsController()
-  const global = useGlobal()
-  const authenticate = useSshAuthenticate()
-  const [_state, setState, _, ready] = persisted(Persist.global("home.servers"), HomeServersSchema, { collapsed: {} })
-  const [state] = createResource(
-    () => ready.promise ?? Promise.resolve(),
-    (promise) => promise.then(() => _state),
-    { initialValue: _state },
-  )
-  function directories(project: LocalProject) {
-    return [project.worktree, ...(project.sandboxes ?? [])]
-  }
-
-  function canRevealProject(conn: ServerConnection.Any) {
-    return platform.platform === "desktop" && !!platform.openPath && ServerConnection.local(conn)
-  }
-
-  function choose(conn: ServerConnection.Any) {
-    pickDirectory({
-      server: conn,
-      title: language.t("command.project.open"),
-      multiple: true,
-      onSelect: (result) => home.project.add(conn, homeProjectDirectories(result)),
-    })
-  }
-
-  return {
-    copy: {
-      language,
-    },
-    selection: {
-      value: home.selection.value,
-    },
-    server: {
-      list: home.server.list,
-      health: home.server.health,
-      projects: home.project.forServer,
-      collapsed: (conn: ServerConnection.Any) => state().collapsed[ServerConnection.key(conn)] ?? false,
-      toggleCollapsed: (conn: ServerConnection.Any) => {
-        const key = ServerConnection.key(conn)
-        setState("collapsed", key, !state().collapsed[key])
-      },
-      canDefault: serverManagement.defaults.available,
-      defaultKey: serverManagement.defaults.key,
-      setDefault: (conn: ServerConnection.Any | undefined) =>
-        serverManagement.defaults.set(conn ? ServerConnection.key(conn) : null),
-      canRemove: (conn: ServerConnection.Any) => serverManagement.connection.canRemove(ServerConnection.key(conn)),
-      remove: (conn: ServerConnection.Any) => serverManagement.connection.remove(ServerConnection.key(conn)),
-      canHide: (conn: ServerConnection.Any) => serverManagement.connection.canHide(ServerConnection.key(conn)),
-      hide: (conn: ServerConnection.Any) => serverManagement.connection.setHidden(ServerConnection.key(conn), true),
-      edit: (conn: ServerConnection.Http) => {
-        void import("@/servers/connect/dialog").then(({ DialogServer }) => {
-          void dialog.show(() => <DialogServer mode="edit" server={conn} />)
-        })
-      },
-      authenticate: (conn: ServerConnection.Any) => authenticate(conn),
-      focus: (conn: ServerConnection.Any) => {
-        if (authenticate(conn, () => home.selection.focusServer(conn))) return
-        home.selection.focusServer(conn)
-      },
-    },
-    project: {
-      list: home.project.list,
-      recentlyClosed: home.project.recentlyClosed,
-      homedir: home.project.homedir,
-      select: (conn: ServerConnection.Any, directory: string) => {
-        if (authenticate(conn, () => home.project.select(conn, directory))) return
-        home.project.select(conn, directory)
-      },
-      add: home.project.add,
-      openNewSession: (conn: ServerConnection.Any, directory: string) => {
-        if (authenticate(conn, () => home.project.openProjectNewSession(conn, directory))) return
-        home.project.openProjectNewSession(conn, directory)
-      },
-      canImportSession: !!platform.openAttachmentPickerDialog,
-      importSession: (conn: ServerConnection.Any, project: LocalProject) => {
-        if (!platform.openAttachmentPickerDialog) return
-        void platform
-          .openAttachmentPickerDialog(
-            {
-              title: language.t("command.session.import"),
-              accept: ["application/json"],
-              extensions: ["json"],
-            },
-            async (file) => {
-              const data = await Schema.decodeUnknownPromise(Schema.fromJsonString(SessionTransfer.Data))(
-                await file.text(),
-              )
-              const api = home.server.context(conn).sdk.api.session
-              const imported = await api.import({
-                ...Schema.encodeSync(SessionTransfer.Data)(data),
-                location: { directory: project.worktree },
-              } as Parameters<typeof api.import>[0])
-              home.project.openProjectSession(conn, project.worktree, imported)
-            },
-          )
-          .catch((cause: unknown) => {
-            showToast({
-              title: language.t("common.requestFailed"),
-              description: errorMessage(cause, language.t("common.requestFailed")),
-            })
-          })
-      },
-      edit: (conn: ServerConnection.Any, project: LocalProject) => {
-        settings.openProject({
-          server: ServerConnection.key(conn),
-          project: project.worktree,
-        })
-      },
-      unseenCount: (conn: ServerConnection.Any, project: LocalProject) => {
-        const notification = global.ensureServerCtx(conn).notification
-        return directories(project).reduce((total, directory) => total + notification.project.unseenCount(directory), 0)
-      },
-      clearNotifications: (conn: ServerConnection.Any, project: LocalProject) => {
-        const notification = global.ensureServerCtx(conn).notification
-        directories(project)
-          .filter((directory) => notification.project.unseenCount(directory) > 0)
-          .forEach((directory) => notification.project.markViewed(directory))
-      },
-      choose: (conn: ServerConnection.Any) => {
-        if (authenticate(conn, () => choose(conn))) return
-        if (home.server.health(conn)?.healthy === false) return
-        choose(conn)
-      },
-      close: (conn: ServerConnection.Any, directory: string) => {
-        const next = closeHomeProject(
-          home.selection.value(),
-          ServerConnection.key(conn),
-          home.server.context(conn).projects,
-          directory,
-        )
-        if (next) home.selection.set(next)
-      },
-      move: (conn: ServerConnection.Any, worktree: string, index: number) => {
-        home.server.context(conn).projects.move(worktree, index)
-      },
-      canReveal: canRevealProject,
-      reveal: (conn: ServerConnection.Any, project: LocalProject) => {
-        if (!platform.openPath || !canRevealProject(conn)) return
-        platform.openPath(project.worktree).catch((cause: unknown) =>
-          showToast({
-            title: language.t("common.requestFailed"),
-            description: errorMessage(cause, language.t("common.requestFailed")),
-          }),
-        )
-      },
-    },
-    utility: {
-      settings: openSettings,
-      help: () => platform.openExternal("https://opencode.ai/desktop-feedback"),
-    },
-  }
-}
-
-export type HomeProjectsController = ReturnType<typeof createHomeProjectsController>
+import { useDirectoryPicker } from "@/workspaces/selection/picker"
+import { useServerActionsController } from "@/servers/registry/controller"
+import { useSettingsCommand } from "@/settings/command"
+import { useSettingsSurface } from "@/settings/surface"
+import { type LocalProject } from "@/shell/state/layout"
+import { useLanguage } from "@/runtime/i18n/language"
+import { usePlatform } from "@/runtime/platform/platform"
+import { ServerConnection } from "@/runtime/server/registry"
+import { closeHomeProject, errorMessage, homeProjectDirectories } from "@/shell/layout/helpers"
+import { Persist, persisted } from "@/runtime/persistence/storage"
+import { showToast } from "@/shell/notifications/toast"
+import { useDialog } from "@opencode/ui/context/dialog"
+import { createResource } from "solid-js"
+import { Codec } from "@/runtime/persistence/codec"
+
+import type { HomeController } from "../model"
+import { useGlobal } from "@/runtime/server/runtime"
+
+import { useSshAuthenticate } from "@/servers/ssh/authenticate"
+
+export const HomeServersSchema = Codec.struct({
+  collapsed: Codec.lenientRecord(Codec.fallback(Codec.boolean, () => false)),
+})
+
+export function createHomeProjectsController(home: HomeController) {
+  const platform = usePlatform()
+  const pickDirectory = useDirectoryPicker()
+  const dialog = useDialog()
+  const language = useLanguage()
+  const openSettings = useSettingsCommand()
+  const settings = useSettingsSurface()
+  const serverManagement = useServerActionsController()
+  const global = useGlobal()
+  const authenticate = useSshAuthenticate()
+  const [_state, setState, _, ready] = persisted(Persist.global("home.servers"), HomeServersSchema, { collapsed: {} })
+  const [state] = createResource(
+    () => ready.promise ?? Promise.resolve(),
+    (promise) => promise.then(() => _state),
+    { initialValue: _state },
+  )
+  function directories(project: LocalProject) {
+    return [project.worktree, ...(project.sandboxes ?? [])]
+  }
+
+  function canRevealProject(conn: ServerConnection.Any) {
+    return platform.platform === "desktop" && !!platform.openPath && ServerConnection.local(conn)
+  }
+
+  function choose(conn: ServerConnection.Any) {
+    pickDirectory({
+      server: conn,
+      title: language.t("command.project.open"),
+      multiple: true,
+      onSelect: (result) => home.project.add(conn, homeProjectDirectories(result)),
+    })
+  }
+
+  return {
+    copy: {
+      language,
+    },
+    selection: {
+      value: home.selection.value,
+    },
+    server: {
+      list: home.server.list,
+      health: home.server.health,
+      projects: home.project.forServer,
+      collapsed: (conn: ServerConnection.Any) => state().collapsed[ServerConnection.key(conn)] ?? false,
+      toggleCollapsed: (conn: ServerConnection.Any) => {
+        const key = ServerConnection.key(conn)
+        setState("collapsed", key, !state().collapsed[key])
+      },
+      canDefault: serverManagement.defaults.available,
+      defaultKey: serverManagement.defaults.key,
+      setDefault: (conn: ServerConnection.Any | undefined) =>
+        serverManagement.defaults.set(conn ? ServerConnection.key(conn) : null),
+      canRemove: (conn: ServerConnection.Any) => serverManagement.connection.canRemove(ServerConnection.key(conn)),
+      remove: (conn: ServerConnection.Any) => serverManagement.connection.remove(ServerConnection.key(conn)),
+      canHide: (conn: ServerConnection.Any) => serverManagement.connection.canHide(ServerConnection.key(conn)),
+      hide: (conn: ServerConnection.Any) => serverManagement.connection.setHidden(ServerConnection.key(conn), true),
+      edit: (conn: ServerConnection.Http) => {
+        void import("@/servers/connect/dialog").then(({ DialogServer }) => {
+          void dialog.show(() => <DialogServer mode="edit" server={conn} />)
+        })
+      },
+      authenticate: (conn: ServerConnection.Any) => authenticate(conn),
+      focus: (conn: ServerConnection.Any) => {
+        if (authenticate(conn, () => home.selection.focusServer(conn))) return
+        home.selection.focusServer(conn)
+      },
+    },
+    project: {
+      list: home.project.list,
+      recentlyClosed: home.project.recentlyClosed,
+      homedir: home.project.homedir,
+      select: (conn: ServerConnection.Any, directory: string) => {
+        if (authenticate(conn, () => home.project.select(conn, directory))) return
+        home.project.select(conn, directory)
+      },
+      add: home.project.add,
+      openNewSession: (conn: ServerConnection.Any, directory: string) => {
+        if (authenticate(conn, () => home.project.openProjectNewSession(conn, directory))) return
+        home.project.openProjectNewSession(conn, directory)
+      },
+      canImportSession: !!platform.openAttachmentPickerDialog,
+      importSession: (conn: ServerConnection.Any, project: LocalProject) => {
+        if (!platform.openAttachmentPickerDialog) return
+        void platform
+          .openAttachmentPickerDialog(
+            {
+              title: language.t("command.session.import"),
+              accept: ["application/json"],
+              extensions: ["json"],
+            },
+            async (file) => {
+              const { decodeSessionTransfer } = await import("./import-session")
+              const data = await decodeSessionTransfer(await file.text())
+              const api = home.server.context(conn).sdk.api.session
+              const imported = await api.import({
+                ...data,
+                location: { directory: project.worktree },
+              } as Parameters<typeof api.import>[0])
+              home.project.openProjectSession(conn, project.worktree, imported)
+            },
+          )
+          .catch((cause: unknown) => {
+            showToast({
+              title: language.t("common.requestFailed"),
+              description: errorMessage(cause, language.t("common.requestFailed")),
+            })
+          })
+      },
+      edit: (conn: ServerConnection.Any, project: LocalProject) => {
+        settings.openProject({
+          server: ServerConnection.key(conn),
+          project: project.worktree,
+        })
+      },
+      unseenCount: (conn: ServerConnection.Any, project: LocalProject) => {
+        const notification = global.ensureServerCtx(conn).notification
+        return directories(project).reduce((total, directory) => total + notification.project.unseenCount(directory), 0)
+      },
+      clearNotifications: (conn: ServerConnection.Any, project: LocalProject) => {
+        const notification = global.ensureServerCtx(conn).notification
+        directories(project)
+          .filter((directory) => notification.project.unseenCount(directory) > 0)
+          .forEach((directory) => notification.project.markViewed(directory))
+      },
+      choose: (conn: ServerConnection.Any) => {
+        if (authenticate(conn, () => choose(conn))) return
+        if (home.server.health(conn)?.healthy === false) return
+        choose(conn)
+      },
+      close: (conn: ServerConnection.Any, directory: string) => {
+        const next = closeHomeProject(
+          home.selection.value(),
+          ServerConnection.key(conn),
+          home.server.context(conn).projects,
+          directory,
+        )
+        if (next) home.selection.set(next)
+      },
+      move: (conn: ServerConnection.Any, worktree: string, index: number) => {
+        home.server.context(conn).projects.move(worktree, index)
+      },
+      canReveal: canRevealProject,
+      reveal: (conn: ServerConnection.Any, project: LocalProject) => {
+        if (!platform.openPath || !canRevealProject(conn)) return
+        platform.openPath(project.worktree).catch((cause: unknown) =>
+          showToast({
+            title: language.t("common.requestFailed"),
+            description: errorMessage(cause, language.t("common.requestFailed")),
+          }),
+        )
+      },
+    },
+    utility: {
+      settings: openSettings,
+      help: () => platform.openExternal("https://opencode.ai/desktop-feedback"),
+    },
+  }
+}
+
+export type HomeProjectsController = ReturnType<typeof createHomeProjectsController>
+
+
+
+
+

packages/app/src/home/projects/import-session.ts

@@ -0,0 +1,9 @@
+import { Schema } from "effect"
+import { SessionTransfer } from "@opencode/schema/session-transfer"
+
+// Loaded on demand when a session file is imported: validating it needs the shared Effect schema,
+// which stays out of the renderer's startup path this way.
+export async function decodeSessionTransfer(text: string) {
+  const data = await Schema.decodeUnknownPromise(Schema.fromJsonString(SessionTransfer.Data))(text)
+  return Schema.encodeSync(SessionTransfer.Data)(data)
+}

packages/app/src/new-session/view.tsx

@@ -5,7 +5,7 @@ import { Show, Suspense, createMemo, createSignal, lazy, onMount } from "solid-j
 import { createStore } from "solid-js/store"
 import { makeEventListener } from "@solid-primitives/event-listener"
 import { debounce } from "@solid-primitives/scheduled"
-import { Schema } from "effect"
+import { Codec } from "@/runtime/persistence/codec"
 import createPresence from "solid-presence"
 import { Composer } from "@/composer/composer"
 import { ComposerDropzone } from "@/composer/dropzone"
@@ -21,7 +21,6 @@ import { useWorkspaceLocation } from "@/workspaces/location"
 import { useProviders } from "@/providers/catalog/providers"
 import { NEW_SESSION_CONTENT_WIDTH } from "@/new-session/layout"
 import { Persist, persisted } from "@/runtime/persistence/storage"
-import { Persistence } from "@/runtime/persistence/schema"
 import type { NewSessionWorkspaceController } from "./workspace/controller"
 import { NewSessionWordmark } from "./wordmark"
 import { SummaryPopover } from "@/session/summary/popover"
@@ -34,12 +33,12 @@ const NewSessionSummary = lazy(async () => {
 
 const providerTipDismissalDuration = 30 * 24 * 60 * 60 * 1000
 
-export const WorkspaceOnboardingSchema = Persistence.struct({
-  used: Schema.Boolean,
+export const WorkspaceOnboardingSchema = Codec.struct({
+  used: Codec.boolean,
 })
 
-export const ProviderTipSchema = Persistence.struct({
-  dismissedAt: Schema.Finite,
+export const ProviderTipSchema = Codec.struct({
+  dismissedAt: Codec.number,
 })
 
 export const WorkspaceTipSchema = ProviderTipSchema
@@ -267,3 +266,4 @@ function NewSessionTips(props: { workspaceEligible: boolean; onWorkspace: () =>
     </Show>
   )
 }
+

packages/app/src/providers/catalog/providers.ts

@@ -1,7 +1,6 @@
 import { useData } from "@/runtime/server/current"
 import { useServerSDK } from "@/runtime/server/client"
 import { normalizeProviderList } from "@/runtime/server/global-sync/utils"
-import { Iterable, pipe } from "effect"
 import { createEffect, createMemo, type Accessor } from "solid-js"
 import type { ProviderListResponse } from "@/runtime/server/types"
 import { useIntegrations } from "./integrations"
@@ -53,34 +52,24 @@ export function useProviders(directory: Accessor<string | undefined>) {
         .filter((integration) => popularProviderSet.has(integration.id))
         .map((integration) => ({ id: integration.id, name: integration.name }))
       const seen = new Set(catalog.map((integration) => integration.id))
-      return pipe(
-        providers().all,
-        Iterable.map(([, p]) => p),
-        Iterable.filter((p) => popularProviderSet.has(p.id) && !seen.has(p.id)),
-        Iterable.map((p) => ({ id: p.id, name: p.name })),
-        (v) => [...catalog, ...v],
-      )
+      const more = [...providers().all.values()]
+        .filter((p) => popularProviderSet.has(p.id) && !seen.has(p.id))
+        .map((p) => ({ id: p.id, name: p.name }))
+      return [...catalog, ...more]
     },
     connected: () => {
       const connected = new Set(providers().connected)
-      return pipe(
-        providers().all,
-        Iterable.map(([, p]) => p),
-        Iterable.filter((p) => connected.has(p.id)),
-        (v) => Array.from(v),
-      )
+      return [...providers().all.values()].filter((p) => connected.has(p.id))
     },
     paid: () => {
       const connected = new Set(providers().connected)
-      const paid = [
-        ...Iterable.filter(
-          providers().all,
-          ([id]) =>
-            connected.has(id) &&
-            (id !== "opencode" || Object.values(providers().all.get(id)?.models ?? {}).some((m) => m.cost?.input)),
-        ),
-      ]
+      const paid = [...providers().all].filter(
+        ([id]) =>
+          connected.has(id) &&
+          (id !== "opencode" || Object.values(providers().all.get(id)?.models ?? {}).some((m) => m.cost?.input)),
+      )
       return paid
     },
   }
 }
+

packages/app/src/providers/models/selection.tsx

@@ -3,12 +3,11 @@ import { base64Encode } from "@opencode/util/encode"
 import { useParams } from "@solidjs/router"
 import { batch, createEffect, createMemo, onCleanup } from "solid-js"
 import { createStore } from "solid-js/store"
-import { Schema, SchemaGetter } from "effect"
+import { Codec } from "@/runtime/persistence/codec"
 import { useModels } from "@/providers/models/models"
 import { useSettings } from "@/settings/model"
 import { useProviders } from "@/providers/catalog/providers"
 import { Persist, persisted } from "@/runtime/persistence/storage"
-import { Persistence } from "@/runtime/persistence/schema"
 import { hasCustomAgent, resolveAgent } from "./agent"
 import { cycleModelVariant, getConfiguredAgentVariant, resolveModelVariant } from "./variant"
 import { useWorkspaceLocation } from "@/workspaces/location"
@@ -18,46 +17,45 @@ import { useServerSDK } from "@/runtime/server/client"
 import { ScopedKey, type ServerScope } from "@/runtime/server/scope"
 import { useConfiguredModel } from "./configured"
 
-const ModelKeySchema = Schema.Struct({
-  providerID: Schema.String,
-  modelID: Schema.String,
-  variant: Schema.optional(Schema.String),
+const ModelKeySchema = Codec.struct({
+  providerID: Codec.string,
+  modelID: Codec.string,
+  variant: Codec.optional(Codec.string),
 })
 export type ModelKey = typeof ModelKeySchema.Type
 
-const ChoiceSchema = Schema.Struct({
-  model: Persistence.optional(ModelKeySchema),
-  variant: Persistence.optional(Schema.NullOr(Schema.String)),
+const ChoiceSchema = Codec.struct({
+  model: Codec.lenientOptional(ModelKeySchema),
+  variant: Codec.lenientOptional(Codec.nullOr(Codec.string)),
 })
-const StateSchema = Schema.Struct({
+const StateSchema = Codec.struct({
   ...ChoiceSchema.fields,
-  agent: Persistence.optional(Schema.String),
-  choices: Persistence.optional(Schema.Record(Schema.String, ChoiceSchema)),
+  agent: Codec.lenientOptional(Codec.string),
+  choices: Codec.lenientOptional(Codec.record(ChoiceSchema)),
 })
 type State = typeof StateSchema.Type
 
-const SessionsSchema = Schema.Record(
-  Schema.String,
-  Schema.mutableKey(Persistence.fallback(Schema.UndefinedOr(StateSchema), () => undefined)),
+const SessionsSchema = Codec.record(Codec.fallback(Codec.undefinedOr(StateSchema), () => undefined))
+
+const Current = Codec.struct({ session: SessionsSchema })
+const StoredSelection = Codec.struct(
+  {
+    session: Codec.lenientOptional(Codec.record(Codec.unknown)),
+    pick: Codec.lenientOptional(Codec.record(Codec.unknown)),
+  },
+  { preserve: true },
 )
 
-const Current = Persistence.struct({ session: SessionsSchema })
-
-export const ModelSelectionSchema = Persistence.migrate(
+export const ModelSelectionSchema = Codec.migrate(
   Current,
-  Schema.Struct({
-    session: Persistence.optional(Schema.Record(Schema.String, Schema.Unknown)),
-    pick: Persistence.optional(Schema.Record(Schema.String, Schema.Unknown)),
-  }).pipe(
-    Schema.decode({
-      decode: SchemaGetter.transform((value) => ({
-        session:
-          value.session ??
-          Object.fromEntries(Object.entries(value.pick ?? {}).filter(([key]) => key !== WORKSPACE_KEY)),
-      })),
-      encode: SchemaGetter.transform((value) => value),
+  Codec.transform(StoredSelection, {
+    decode: (value) => ({
+      ...value,
+      session:
+        value.session ?? Object.fromEntries(Object.entries(value.pick ?? {}).filter(([key]) => key !== WORKSPACE_KEY)),
     }),
-  ),
+    encode: (value) => value,
+  }),
 )
 
 const WORKSPACE_KEY = "__workspace__"

packages/app/src/runtime/i18n/language.tsx

@@ -1,7 +1,7 @@
 import { flatten, resolveTemplate, translator, type Flatten } from "@solid-primitives/i18n"
 import { createEffect, createMemo, createResource, type JSX } from "solid-js"
 import { createStore } from "solid-js/store"
-import { Option, Schema, SchemaGetter } from "effect"
+import { Codec } from "@/runtime/persistence/codec"
 import { createSimpleContext } from "@opencode/ui/context"
 import {
   I18nProvider,
@@ -12,7 +12,6 @@ import {
   type UiPluralCategory,
 } from "@opencode/ui/context/i18n"
 import { Persist, persisted } from "@/runtime/persistence/storage"
-import { Persistence } from "@/runtime/persistence/schema"
 import en from "@/runtime/i18n/en"
 import { dict } from "@opencode/ui/i18n/en"
 import {
@@ -56,14 +55,9 @@ function cookie(locale: Locale) {
 
 const LOCALES: readonly Locale[] = DESKTOP_NATIVE_LOCALES
 
-const LocaleSchema = Schema.Literals(DESKTOP_NATIVE_LOCALES)
-const StoredLocaleSchema = Schema.Struct({
-  locale: Schema.String.pipe(
-    Schema.decodeTo(LocaleSchema, {
-      decode: SchemaGetter.transform(normalizeLocale),
-      encode: SchemaGetter.transform((locale) => locale),
-    }),
-  ),
+const LocaleSchema = Codec.literals(DESKTOP_NATIVE_LOCALES)
+const StoredLocaleSchema = Codec.struct({
+  locale: Codec.transform(Codec.string, { decode: normalizeLocale, encode: (locale) => locale }),
 })
 
 const INTL = DESKTOP_NATIVE_LOCALE_TAGS
@@ -160,11 +154,11 @@ function detectLocale(): Locale {
 }
 
 export function normalizeLocale(value: string): Locale {
-  return Option.getOrElse(Schema.decodeUnknownOption(LocaleSchema)(value), () => "en")
+  return Codec.decodeOption(LocaleSchema, value) ?? "en"
 }
 
-export const languageSchema = Persistence.struct({
-  locale: StoredLocaleSchema.fields.locale,
+export const languageSchema = Codec.struct({
+  locale: StoredLocaleSchema.fields.locale,
 })
 
 function readStoredLocale() {
@@ -172,9 +166,7 @@ function readStoredLocale() {
   try {
     const raw = localStorage.getItem("opencode.global.dat:language")
     if (!raw) return
-    const next = Schema.decodeUnknownOption(Schema.fromJsonString(StoredLocaleSchema))(raw)
-    if (Option.isNone(next)) return
-    return next.value.locale
+    return Codec.decodeOption(Codec.fromJsonString(StoredLocaleSchema), raw)?.locale
   } catch {
     return
   }
@@ -296,3 +288,4 @@ export function UiI18nBridge(props: { children?: JSX.Element }) {
     </I18nProvider>
   )
 }
+

packages/app/src/runtime/persistence/codec.ts

@@ -46,6 +46,13 @@ export function decodeOrThrow<T>(codec: Of<T>, input: unknown): T {
   return value
 }
 
+/** Encodes and checks the result decodes, so an invalid in-memory value fails loudly instead of persisting. */
+export function encodeOrThrow<T, E>(codec: Of<T, E>, value: T): E {
+  const encoded = codec.encode(value)
+  if (codec.decode(encoded) === INVALID) throw new Error("Value does not match its codec")
+  return encoded
+}
+
 const identity = <T>(value: T) => value
 
 export const string: Of<string, string> = make((v) => (typeof v === "string" ? v : INVALID), identity)
@@ -120,20 +127,24 @@ export interface Struct<F extends Fields> extends Of<StructType<F>, StructEncode
   readonly fields: F
 }
 
-export function struct<const F extends Fields>(fields: F): Struct<F> {
-  const entries = Object.entries(fields)
-  return {
-    ...make<StructType<F>, StructEncoded<F>>(
-      (input) => {
-        if (typeof input !== "object" || input === null || Array.isArray(input)) return INVALID
-        const record = input as Record<string, unknown>
-        const out: Record<string, unknown> = {}
+// `preserve` keeps keys the struct does not declare, for migration shapes that only describe the
+// fields they rewrite (Effect's `onExcessProperty: "preserve"`); the current schema then decides.
+export function struct<const F extends Fields>(fields: F, options?: { preserve?: boolean }): Struct<F> {
+  const entries = Object.entries(fields)
+  return {
+    ...make<StructType<F>, StructEncoded<F>>(
+      (input) => {
+        if (typeof input !== "object" || input === null || Array.isArray(input)) return INVALID
+        const record = input as Record<string, unknown>
+        const out: Record<string, unknown> = options?.preserve ? { ...record } : {}
         for (const [key, codec] of entries) {
-          const present = Object.hasOwn(record, key)
-          if (!present && codec.optional) continue
-          const value = codec.decode(record[key])
-          if (value === INVALID) return INVALID
-          if (value !== undefined || present) out[key] = value
+          const present = Object.hasOwn(record, key)
+          if (!present && codec.optional) continue
+          const value = codec.decode(record[key])
+          if (value === INVALID) return INVALID
+          // An optional field that decodes to undefined is absent, as with Effect's optional keys.
+          if (value !== undefined || (present && !codec.optional)) out[key] = value
+          else delete out[key]
         }
         return out as StructType<F>
       },
@@ -317,11 +328,10 @@ export function withInitial<C extends Any>(definition: C | Migrated<C>, initial:
   const read = isMigrated(definition) ? definition.read : unknown
   return make(
     (input) => {
-      const migrated = read.decode(input)
-      if (migrated === INVALID) return INVALID
-      // A migration only describes the fields it rewrites; everything else stored stays as it was.
-      const stored = isObject(input) && isObject(migrated) ? { ...input, ...migrated } : migrated
-      return merge(initial, recover(codec, stored, initial))
+      const stored = read.decode(input)
+      if (stored === INVALID) return INVALID
+      // Re-decoding validates the merged value and copies it, so the store never aliases `initial`.
+      return codec.decode(codec.encode(merge(initial, recover(codec, stored, initial)) as Type<C>))
     },
     (value) => codec.encode(value),
   )
@@ -356,3 +366,4 @@ function isObject(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value)
 }
 
+

packages/app/src/runtime/persistence/consumers.test.ts

@@ -1,8 +1,7 @@
 import { describe, expect, test } from "bun:test"
-import { Schema } from "effect"
 import { WorkspaceOnboardingSchema, ProviderTipSchema, WorkspaceTipSchema } from "@/new-session/view"
 import { ModelSelectionSchema } from "@/providers/models/selection"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
 import { FileViewsSchema } from "@/workspaces/files/view-cache"
 import { languageSchema } from "@/runtime/i18n/language"
 import { HomeServersSchema } from "@/home/projects/controller"
@@ -10,9 +9,9 @@ import { ModelProvidersSchema } from "@/settings/models/models"
 
 describe("persisted consumer schemas", () => {
   test("onboarding and provider tip retain defaults and validate stored values", () => {
-    const onboarding = Schema.decodeUnknownSync(Persistence.withInitial(WorkspaceOnboardingSchema, { used: false }))
-    const tip = Schema.decodeUnknownSync(Persistence.withInitial(ProviderTipSchema, { dismissedAt: 0 }))
-    const workspaceTip = Schema.decodeUnknownSync(Persistence.withInitial(WorkspaceTipSchema, { dismissedAt: 0 }))
+    const onboarding = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(WorkspaceOnboardingSchema, { used: false }), input))
+    const tip = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(ProviderTipSchema, { dismissedAt: 0 }), input))
+    const workspaceTip = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(WorkspaceTipSchema, { dismissedAt: 0 }), input))
     expect(onboarding({})).toEqual({ used: false })
     expect(onboarding({ used: "true" })).toEqual({ used: false })
     expect(onboarding({ used: true })).toEqual({ used: true })
@@ -25,7 +24,7 @@ describe("persisted consumer schemas", () => {
 
   test("collapse records recover malformed entries without losing valid siblings", () => {
     for (const schema of [HomeServersSchema, ModelProvidersSchema]) {
-      const decode = Schema.decodeUnknownSync(Persistence.withInitial(schema, { collapsed: {} }))
+      const decode = (input: unknown) => Codec.decodeOrThrow(Codec.withInitial(schema, { collapsed: {} }), input)
       expect(decode({})).toEqual({ collapsed: {} })
       expect(decode({ collapsed: [] })).toEqual({ collapsed: {} })
       expect(decode({ collapsed: { open: false, closed: true, invalid: "false" } })).toEqual({
@@ -35,21 +34,19 @@ describe("persisted consumer schemas", () => {
   })
 
   test("model selection migrates legacy picks and omits workspace state", () => {
-    const decode = Schema.decodeUnknownSync(Persistence.withInitial(ModelSelectionSchema, { session: {} }))
+    const decode = (input: unknown) => Codec.decodeOrThrow(Codec.withInitial(ModelSelectionSchema, { session: {} }), input)
     expect(decode({})).toEqual({ session: {} })
     const state = decode({ pick: { __workspace__: { agent: "plan" }, session1: { agent: "build" } } })
     expect(state.session.session1?.agent).toBe("build")
     expect(state.session.__workspace__).toBeUndefined()
-    const encoded = Schema.encodeSync(
-      Schema.fromJsonString(Persistence.withInitial(ModelSelectionSchema, { session: {} })),
-    )(state)
+    const encoded = Codec.fromJsonString(Codec.withInitial(ModelSelectionSchema, { session: {} })).encode(state)
     expect(JSON.parse(encoded)).toEqual({ session: { session1: { agent: "build" } } })
     expect(decode(JSON.parse(encoded))).toEqual(state)
   })
 
   test("current model selections take precedence over legacy picks", () => {
     expect(
-      Schema.decodeUnknownSync(Persistence.withInitial(ModelSelectionSchema, { session: {} }))({
+      Codec.decodeOrThrow(Codec.withInitial(ModelSelectionSchema, { session: {} }), {
         session: {},
         pick: { session1: { agent: "plan" } },
       }),
@@ -57,7 +54,7 @@ describe("persisted consumer schemas", () => {
   })
 
   test("model selection validates nested model keys and preserves explicit null variants", () => {
-    const state = Schema.decodeUnknownSync(Persistence.withInitial(ModelSelectionSchema, { session: {} }))({
+    const state = Codec.decodeOrThrow(Codec.withInitial(ModelSelectionSchema, { session: {} }), {
       session: {
         good: { agent: "build", model: { providerID: "provider", modelID: "model", variant: "high" }, variant: null },
         partial: { agent: "plan", model: { providerID: "provider", modelID: 42 }, variant: false },
@@ -76,7 +73,7 @@ describe("persisted consumer schemas", () => {
   })
 
   test("file views validate scroll positions and line sides independently", () => {
-    const decode = Schema.decodeUnknownSync(Persistence.withInitial(FileViewsSchema, { file: {} }))
+    const decode = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(FileViewsSchema, { file: {} }), input))
     expect(decode({})).toEqual({ file: {} })
     const state = decode({
       file: {
@@ -103,7 +100,7 @@ describe("persisted consumer schemas", () => {
   })
 
   test("language preserves runtime defaults and normalizes unsupported locales to English", () => {
-    const decode = Schema.decodeUnknownSync(Persistence.withInitial(languageSchema, { locale: "fr" }))
+    const decode = (input: unknown) => Codec.decodeOrThrow(Codec.withInitial(languageSchema, { locale: "fr" }), input)
     expect(decode({})).toEqual({ locale: "fr" })
     expect(decode({ locale: undefined })).toEqual({ locale: "fr" })
     expect(decode({ locale: 42 })).toEqual({ locale: "fr" })
@@ -111,3 +108,7 @@ describe("persisted consumer schemas", () => {
     expect(decode({ locale: "ar" })).toEqual({ locale: "ar" })
   })
 })
+
+
+
+

packages/app/src/runtime/persistence/drafts.ts

@@ -1,5 +1,5 @@
 import type { AsyncStorage } from "@solid-primitives/storage"
-import { Option, Schema } from "effect"
+import { Codec } from "./codec"
 
 export type BlobReference = { id: string; url: string }
 
@@ -312,12 +312,12 @@ export function createDraftStore(driver: Driver, options: { grace?: number } = {
     getItem: async (key) => {
       const value = await driver.get(key)
       if (value === null) return null
-      const parsed = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown))(value)
-      // Let the owning persistence codec apply its invalid-document policy.
-      if (Option.isNone(parsed)) return value
-      // A loaded document is live in the composer: pin its images before decode mints their URLs.
-      retain(key, imageIDs(parsed.value), grace)
-      return JSON.stringify(await decode(parsed.value))
+      const parsed = Codec.fromJsonString(Codec.unknown).decode(value)
+      // Let the owning persistence codec apply its invalid-document policy.
+      if (parsed === Codec.INVALID) return value
+      // A loaded document is live in the composer: pin its images before decode mints their URLs.
+      retain(key, imageIDs(parsed), grace)
+      return JSON.stringify(await decode(parsed))
     },
     setItem: (key, value) => setDocument(key, JSON.parse(value)),
     setDocument,
@@ -455,3 +455,4 @@ export async function blobDataUrl(blob: BlobReference, mime: string) {
 export function createLegacyBlobReference(dataUrl: string): BlobReference {
   return { id: dataUrl, url: dataUrl }
 }
+

packages/app/src/runtime/persistence/schema.test.ts

@@ -1,162 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Effect, Schema, SchemaGetter } from "effect"
-import { Persistence } from "./schema"
-
-describe("persistence schemas", () => {
-  test("initial state supplies nested defaults without hiding valid siblings", () => {
-    const schema = Persistence.withInitial(
-      Persistence.struct({
-        enabled: Schema.Boolean,
-        appearance: Persistence.struct({ width: Schema.Number, font: Schema.String }),
-        variant: Schema.optional(Schema.NullOr(Schema.String)),
-      }),
-      { enabled: true, appearance: { width: 240, font: "default" }, variant: "high" },
-    )
-    const decode = Schema.decodeUnknownSync(schema)
-    expect(decode({ appearance: { width: 300 } })).toEqual({
-      enabled: true,
-      appearance: { width: 300, font: "default" },
-      variant: "high",
-    })
-    expect(decode({ enabled: "false", appearance: { width: "wide", font: "saved" }, variant: null })).toEqual({
-      enabled: true,
-      appearance: { width: 240, font: "saved" },
-      variant: null,
-    })
-    expect(decode({ appearance: null })).toEqual({
-      enabled: true,
-      appearance: { width: 240, font: "default" },
-      variant: "high",
-    })
-  })
-
-  test("legacy migration observes missing fields before initial defaults are applied", () => {
-    const current = Persistence.struct({ mode: Schema.Literals(["compact", "full"]), enabled: Schema.Boolean })
-    const stored = Schema.Struct({
-      mode: Schema.optional(Schema.Unknown),
-      expanded: Schema.optional(Schema.Boolean),
-    }).pipe(
-      Schema.decode({
-        decode: SchemaGetter.transform((value) =>
-          value.mode !== undefined || value.expanded === undefined
-            ? value
-            : { ...value, mode: value.expanded ? "full" : "compact" },
-        ),
-        encode: SchemaGetter.passthrough(),
-      }),
-    )
-    const schema = Persistence.withInitial(Persistence.migrate(current, stored), { mode: "compact", enabled: true })
-    const decode = Schema.decodeUnknownSync(schema)
-    expect(decode({ expanded: true, enabled: false })).toEqual({ mode: "full", enabled: false })
-    expect(decode({ expanded: true, mode: "compact" })).toEqual({ mode: "compact", enabled: true })
-    expect(decode({ expanded: true, mode: "invalid" })).toEqual({ mode: "compact", enabled: true })
-    expect(Schema.encodeSync(schema)(decode({ expanded: true }))).toEqual({ mode: "full", enabled: true })
-  })
-
-  test("initial merging preserves field codecs and replaces arrays rather than merging indexes", () => {
-    const current = Persistence.struct({
-      amount: Schema.NumberFromString.check(Schema.isFinite()),
-      items: Schema.mutable(Schema.Array(Schema.String)),
-    })
-    const schema = Persistence.withInitial(current, { amount: 7, items: ["initial"] })
-    const decode = Schema.decodeUnknownSync(schema)
-    expect(decode({ amount: "12", items: [] })).toEqual({ amount: 12, items: [] })
-    expect(decode({ amount: "invalid", items: ["saved"] })).toEqual({ amount: 7, items: ["saved"] })
-    expect(Schema.encodeSync(schema)(decode({}))).toEqual({ amount: "7", items: ["initial"] })
-  })
-
-  test("built-in defaults only recover absent values, not invalid ones", () => {
-    const schema = Persistence.struct({
-      enabled: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(true))),
-    })
-    const decode = Schema.decodeUnknownSync(schema)
-    expect(decode({})).toEqual({ enabled: true })
-    expect(decode({ enabled: undefined })).toEqual({ enabled: true })
-    expect(() => decode({ enabled: "true" })).toThrow()
-    const state: typeof schema.Type = { enabled: false }
-    state.enabled = true
-    expect(Schema.encodeSync(schema)(state)).toEqual({ enabled: true })
-  })
-
-  test("defaults missing and invalid fields without discarding valid siblings", () => {
-    const schema = Schema.Struct({
-      enabled: Persistence.fallback(Schema.Boolean, () => true),
-      label: Persistence.fallback(Schema.String, () => "default"),
-    })
-    const decode = Schema.decodeUnknownSync(schema)
-    expect(decode({})).toEqual({ enabled: true, label: "default" })
-    expect(decode({ enabled: "false", label: "saved" })).toEqual({ enabled: true, label: "saved" })
-    expect(decode({ enabled: undefined, label: null })).toEqual({ enabled: true, label: "default" })
-    expect(Schema.encodeSync(schema)(decode({}))).toEqual({ enabled: true, label: "default" })
-  })
-
-  test("optional recovery keeps fields optional without adding an undefined default", () => {
-    const number = Schema.NumberFromString.check(Schema.isFinite())
-    const schema = Persistence.struct({ value: Persistence.optional(number) })
-    const decode = Schema.decodeUnknownSync(schema)
-    const empty: typeof schema.Type = {}
-    expect(decode({})).toEqual(empty)
-    expect(decode({ value: "invalid" })).toEqual(empty)
-    expect(Object.hasOwn(decode({ value: "invalid" }), "value")).toBe(false)
-    expect(decode({ value: undefined })).toEqual({ value: undefined })
-    expect(decode({ value: "42" })).toEqual({ value: 42 })
-    expect(Schema.encodeSync(schema)({ value: 42 })).toEqual({ value: "42" })
-    expect(Schema.encodeSync(schema)(empty)).toEqual({})
-    expect(() =>
-      Schema.decodeUnknownSync(Schema.Struct({ value: Schema.optional(number) }))({ value: "invalid" }),
-    ).toThrow()
-  })
-
-  test("fallbacks use decoded values and retain the codec on writes", () => {
-    const schema = Persistence.struct({
-      value: Persistence.fallback(Schema.NumberFromString.check(Schema.isFinite()), () => 7),
-    })
-    const decode = Schema.decodeUnknownSync(schema)
-    expect(decode({})).toEqual({ value: 7 })
-    expect(decode({ value: "invalid" })).toEqual({ value: 7 })
-    expect(Schema.encodeSync(schema)(decode({}))).toEqual({ value: "7" })
-  })
-
-  test("records default to fresh mutable objects and keep entry recovery explicit", () => {
-    const strict = Persistence.record(Schema.Boolean)
-    const decode = Schema.decodeUnknownSync(strict)
-    expect(decode(undefined)).toEqual({})
-    expect(decode([])).toEqual({})
-    expect(decode({ valid: true, invalid: "true" })).toEqual({})
-    const first: typeof strict.Type = decode(undefined)
-    first.changed = true
-    expect(decode(undefined)).toEqual({})
-
-    const recover = Persistence.record(Persistence.optional(Schema.Boolean))
-    const state = Schema.decodeUnknownSync(recover)({ valid: true, invalid: "true" })
-    expect(state).toEqual({ valid: true })
-    expect(Schema.encodeSync(recover)(state)).toEqual({ valid: true })
-  })
-
-  test("creates fresh default collections", () => {
-    const schema = Schema.Struct({ items: Persistence.array(Schema.String) })
-    const decode = Schema.decodeUnknownSync(schema)
-    const first = decode({})
-    first.items.push("changed")
-    expect(decode({}).items).toEqual([])
-  })
-
-  test("recovers and migrates individual array entries", () => {
-    const current = Schema.Struct({ name: Schema.String })
-    const schema = Persistence.array(
-      Schema.Union([current, Schema.String]).pipe(
-        Schema.decodeTo(current, {
-          decode: SchemaGetter.transform((value) => (typeof value === "string" ? { name: value } : value)),
-          encode: SchemaGetter.passthrough(),
-        }),
-      ),
-    )
-    const decode = Schema.decodeUnknownSync(schema)
-    const value = decode(["old", { name: "new" }, null, { name: false }])
-    expect(value).toEqual([{ name: "old" }, { name: "new" }])
-    expect(Schema.encodeSync(schema)(value)).toEqual(value)
-    expect(decode(Schema.encodeSync(schema)(value))).toEqual(value)
-    expect(decode(undefined)).toEqual([])
-    expect(decode({})).toEqual([])
-  })
-})

packages/app/src/runtime/persistence/schema.ts

@@ -1,99 +0,0 @@
-export * as Persistence from "./schema"
-
-import { Effect, Option, Predicate, Result, Schema, SchemaAST, SchemaGetter, SchemaParser, Struct } from "effect"
-
-export type Migrated<S extends Schema.ConstraintCodec<object, unknown>> = {
-  current: S
-  read: Schema.ConstraintDecoder<unknown>
-}
-
-export function migrate<S extends Schema.ConstraintCodec<object, unknown>>(
-  current: S,
-  read: Schema.ConstraintDecoder<unknown>,
-): Migrated<S> {
-  return { current, read }
-}
-
-function isMigrated<S extends Schema.ConstraintCodec<object, unknown>>(schema: S | Migrated<S>): schema is Migrated<S> {
-  return "current" in schema
-}
-
-export function withInitial<S extends Schema.ConstraintCodec<object, unknown>>(
-  definition: S | Migrated<S>,
-  initial: NoInfer<S["Type"]>,
-) {
-  const schema = isMigrated(definition) ? definition.current : definition
-  const read = isMigrated(definition)
-    ? SchemaParser.decodeUnknownResult(definition.read, { onExcessProperty: "preserve" })
-    : Result.succeed<unknown>
-  const encode = Schema.encodeUnknownSync(schema)
-  return Schema.Unknown.pipe(
-    Schema.decode<Schema.Unknown>({
-      decode: SchemaGetter.transformOrFail((value) =>
-        Effect.fromResult(Result.map(read(value), (stored) => merge(initial, recover(schema.ast, stored, initial)))),
-      ),
-      encode: SchemaGetter.transform((value) => encode(value)),
-    }),
-    Schema.decodeTo(Schema.toType(schema)),
-  )
-}
-
-// Object-level codecs own their recovery. Plain structs can recover fields independently.
-function recover(ast: SchemaAST.AST, value: unknown, initial: unknown): unknown {
-  if (value === undefined) return initial
-  if (ast._tag === "Objects" && !ast.encoding && ast.indexSignatures.length === 0 && Predicate.isObject(value)) {
-    return Object.fromEntries(
-      ast.propertySignatures.flatMap((field) => {
-        const defaults = Predicate.isObject(initial) ? initial[field.name] : undefined
-        const next = recover(field.type, value[field.name], defaults)
-        if (next === undefined && !Object.hasOwn(value, field.name) && defaults === undefined) return []
-        return [[field.name, next]]
-      }),
-    )
-  }
-  const decoded = Schema.decodeUnknownOption(Schema.make<Schema.Codec<unknown, unknown>>(ast))(value)
-  return Option.isSome(decoded) ? decoded.value : initial
-}
-
-function merge(initial: unknown, value: unknown): unknown {
-  if (value === undefined) return initial
-  if (!Predicate.isObject(initial) || !Predicate.isObject(value)) return value
-  return Object.fromEntries(
-    [...new Set([...Object.keys(initial), ...Object.keys(value)])].map((key) => [key, merge(initial[key], value[key])]),
-  )
-}
-
-// Unlike a decoding default, a fallback also replaces invalid persisted values.
-export function fallback<S extends Schema.ConstraintCodec<unknown, unknown>>(schema: S, value: () => S["Type"]) {
-  const defaulted = Schema.withDecodingDefaultType<S>(Effect.sync(value))(schema)
-  return Schema.catchDecoding<typeof defaulted>(() => Effect.sync(() => Option.some(value())))(defaulted)
-}
-
-export function optional<S extends Schema.ConstraintCodec<unknown, unknown>>(schema: S) {
-  const field = Schema.optional(schema)
-  return Schema.catchDecoding<typeof field>(() => Effect.succeed(Option.none()))(field)
-}
-
-export function struct<const Fields extends Schema.Struct.Fields>(fields: Fields) {
-  return Schema.Struct(fields).mapFields(Struct.map(Schema.mutableKey))
-}
-
-export function record<S extends Schema.ConstraintCodec<unknown, unknown>>(schema: S) {
-  const entries = Schema.Record(Schema.String, Schema.mutableKey(schema))
-  return fallback(entries, () => Schema.decodeUnknownSync(entries)({}))
-}
-
-// Recover individual entries rather than discarding a whole history or collection.
-export function array<S extends Schema.ConstraintCodec<unknown, unknown>>(schema: S) {
-  const decode = Schema.decodeUnknownOption(schema)
-  const encode = Schema.encodeSync(schema)
-  return fallback(
-    Schema.Array(Schema.Unknown).pipe(
-      Schema.decodeTo(Schema.mutable(Schema.Array(Schema.toType(schema))), {
-        decode: SchemaGetter.transform((items) => items.flatMap((item) => Option.toArray(decode(item)))),
-        encode: SchemaGetter.transform((items) => items.map((item) => encode(item))),
-      }),
-    ),
-    () => [],
-  )
-}

packages/app/src/runtime/persistence/storage.ts

@@ -3,12 +3,10 @@ import { messageSync, type AsyncStorage, type SyncStorage } from "@solid-primiti
 import { checksum } from "@opencode/util/encode"
 import { createResource, onCleanup, type Accessor } from "solid-js"
 import { createStore, type SetStoreFunction, type Store } from "solid-js/store"
-import { Option, Schema } from "effect"
 import { pathKey } from "@/workspaces/path-key"
 import { ScopedKey, ServerScope } from "@/runtime/server/scope"
 import { Codec } from "./codec"
 import { persistStore } from "./persist"
-import { Persistence } from "./schema"
 
 type InitType = Promise<string | null> | string | null
 type PersistedWithReady<T> = [
@@ -473,57 +471,31 @@ export function removePersisted(
   }
 }
 
-type Definition<S extends Schema.ConstraintCodec<object, unknown> | Codec.Any> =
-  | S
-  | Persistence.Migrated<Extract<S, Schema.ConstraintCodec<object, unknown>>>
-  | Codec.Migrated<Extract<S, Codec.Any>>
-
-// Persisted stores are moving from Effect Schema to the plain codecs in ./codec so the renderer
-// stops paying for Effect at startup; both are accepted while the migration is underway.
-function serializer<S extends Schema.ConstraintCodec<object, unknown> | Codec.Any>(
-  definition: Definition<S>,
-  initial: S["Type"],
-) {
-  if (Codec.isCodec(definition) || (!("current" in definition) ? false : Codec.isCodec(definition.current))) {
-    const codec = Codec.withInitial(definition as Codec.Any | Codec.Migrated<Codec.Any>, initial)
-    const json = Codec.fromJsonString(codec)
-    return {
-      decode: (raw: string) => Codec.decodeOption(json, raw) as S["Type"] | undefined,
-      deserialize: (raw: unknown) => Codec.decodeOrThrow(json, raw) as S["Type"],
-      serialize: (value: S["Type"]) => json.encode(value),
-      encode: (value: S["Type"]) => codec.encode(value),
-      initial: Codec.decodeOrThrow(codec, codec.encode(initial)) as S["Type"],
-    }
-  }
-  const schema = definition as Schema.ConstraintCodec<object, unknown> | Persistence.Migrated<Schema.ConstraintCodec<object, unknown>>
-  const initialized = Persistence.withInitial(schema, initial as object)
-  const json = Schema.fromJsonString(initialized)
-  const decode = Schema.decodeUnknownOption(json)
-  return {
-    decode: (raw: string) => Option.getOrUndefined(decode(raw)) as S["Type"] | undefined,
-    deserialize: Schema.decodeUnknownSync(json) as (raw: unknown) => S["Type"],
-    serialize: Schema.encodeSync(json) as (value: S["Type"]) => string,
-    encode: Schema.encodeSync(initialized) as (value: S["Type"]) => unknown,
-    initial: Schema.decodeUnknownSync(Schema.toType(initialized))(initial as object) as S["Type"],
-  }
-}
-
-export function persisted<S extends Schema.ConstraintCodec<object, unknown> | Codec.Any>(
-  target: string | PersistTarget,
-  schema: Definition<S>,
-  initial: NoInfer<S["Type"]>,
-  platformOverride?: Platform,
-): PersistedWithReady<S["Type"]> {
+export function persisted<C extends Codec.Any>(
+  target: string | PersistTarget,
+  definition: C | Codec.Migrated<C>,
+  initial: NoInfer<Codec.Type<C>>,
+  platformOverride?: Platform,
+): PersistedWithReady<Codec.Type<C>> {
+  type T = Codec.Type<C>
+  const initialized = Codec.withInitial(definition, initial)
+  const json = Codec.fromJsonString(initialized)
+  const codec = {
+    decode: (raw: string) => Codec.decodeOption(json, raw),
+    deserialize: (raw: unknown) => Codec.decodeOrThrow(json, raw),
+    serialize: (value: T) => Codec.encodeOrThrow(json, value),
+    encode: (value: T) => Codec.encodeOrThrow(initialized, value),
+    initial: Codec.decodeOrThrow(initialized, initialized.encode(initial)),
+  }
   const platform = platformOverride ?? usePlatform()
   const config = resolveTarget(typeof target === "string" ? { key: target } : target, platform)
 
-  const codec = serializer<S>(schema, initial)
   const { encode, serialize } = codec
   const normalize = (raw: string) => {
     const value = codec.decode(raw)
     if (value !== undefined) return serialize(value)
   }
-  const store = createStore<S["Type"]>(codec.initial)
+  const store = createStore<T>(codec.initial)
   const isDesktop = platform.platform === "desktop" && !!platform.storage
   const draft = config.draft ? platform.draftStore : undefined
   const prefix = `${config.storage ?? "default"}:`
@@ -672,3 +644,4 @@ export function persisted<S extends Schema.ConstraintCodec<object, unknown> | Co
     }),
   ]
 }
+

packages/app/src/runtime/server/persistence.ts

@@ -43,7 +43,7 @@ const State = Codec.struct({
   recentlyClosed: Codec.record(Codec.lenientArray(Codec.string)),
 })
 
-const StoredState = Codec.struct({ projects: Projects, lastProject: LastProject })
+const StoredState = Codec.struct({ projects: Projects, lastProject: LastProject }, { preserve: true })
 
 // Projects and last-opened entries recorded under the canonical local server's URL move under
 // "local" when that URL is known, so they survive the server changing address.
@@ -124,3 +124,4 @@ export const ProjectState = Codec.struct({
 export const IconState = Codec.struct({
   value: Codec.optional(Codec.string),
 })
+

packages/app/src/servers/connect/pairing.ts

@@ -1,12 +1,12 @@
-import { Option, Schema } from "effect"
+import { Codec } from "@/runtime/persistence/codec"
 import { normalizeServerUrl } from "@/runtime/server/registry"
 
-const pairing = Schema.fromJsonString(
-  Schema.Struct({
-    urls: Schema.Array(Schema.String),
-    username: Schema.Literal("opencode"),
-    password: Schema.String,
-  }),
+const pairing = Codec.fromJsonString(
+  Codec.struct({
+    urls: Codec.array(Codec.string),
+    username: Codec.literal("opencode"),
+    password: Codec.string,
+  }),
 )
 
 export function serverAddress(value: string) {
@@ -20,9 +20,10 @@ export function serverAddress(value: string) {
 }
 
 export function decodePairingCode(value: string) {
-  const result = Schema.decodeUnknownOption(pairing)(value)
-  if (Option.isNone(result)) return
-  const urls = [...new Set(result.value.urls.map(serverAddress).filter((url) => url !== undefined))]
-  if (!urls.length) return
-  return { urls, password: result.value.password }
+  const result = Codec.decodeOption(pairing, value)
+  if (!result) return
+  const urls = [...new Set(result.urls.map(serverAddress).filter((url) => url !== undefined))]
+  if (!urls.length) return
+  return { urls, password: result.password }
 }
+

packages/app/src/servers/ssh/controller.ts

@@ -1,4 +1,3 @@
-import { Effect, Fiber } from "effect"
 import { createEffect, onCleanup } from "solid-js"
 import { createStore } from "solid-js/store"
 import type { SshConfig, SshItem, SshPlatform } from "./types"
@@ -24,7 +23,8 @@ export function createSshController(input: {
       | undefined
     >
   >({})
-  const tasks = new Map<string, Fiber.Fiber<void>>()
+  // One in-flight request per server; cancelling settles it immediately and ignores its outcome.
+  const tasks = new Map<string, { cancelled: boolean }>()
   const item = (id: string) => input.items().find((item) => item.config.id === id)
   const settle = (id: string) => {
     const attempt = attempts[id]
@@ -33,31 +33,32 @@ export function createSshController(input: {
     setAttempts(id, { active: false, onConnected: undefined })
     if (item(id)?.stage === "ready" && onConnected) queueMicrotask(onConnected)
   }
-  const run = (id: string, effect: Effect.Effect<unknown, unknown>) => {
-    setAttempts(id, { submitting: true, error: false })
-    tasks.set(
-      id,
-      Effect.runFork(
-        effect.pipe(
-          Effect.asVoid,
-          Effect.catch(() =>
-            Effect.sync(() => {
-              setAttempts(id, "error", true)
-              if (!attempts[id]?.prompted) input.error()
-            }),
-          ),
-          Effect.ensuring(
-            Effect.sync(() => {
-              tasks.delete(id)
-              setAttempts(id, "submitting", false)
-            }),
-          ),
-        ),
-      ),
-    )
-  }
-  onCleanup(() => {
-    Effect.runFork(Effect.forEach([...tasks.values()], Fiber.interrupt, { discard: true }))
+  const finish = (id: string, task: { cancelled: boolean }) => {
+    if (task.cancelled) return
+    task.cancelled = true
+    if (tasks.get(id) === task) tasks.delete(id)
+    setAttempts(id, "submitting", false)
+  }
+  const interrupt = (id: string) => {
+    const task = tasks.get(id)
+    if (task) finish(id, task)
+  }
+  const run = (id: string, work: () => Promise<unknown>) => {
+    setAttempts(id, { submitting: true, error: false })
+    const task = { cancelled: false }
+    tasks.set(id, task)
+    work().then(
+      () => finish(id, task),
+      () => {
+        if (task.cancelled) return
+        setAttempts(id, "error", true)
+        if (!attempts[id]?.prompted) input.error()
+        finish(id, task)
+      },
+    )
+  }
+  onCleanup(() => {
+    for (const id of [...tasks.keys()]) interrupt(id)
   })
   createEffect(() => {
     for (const item of input.items()) {
@@ -114,40 +115,32 @@ export function createSshController(input: {
         error: false,
         onConnected: options?.onConnected ?? (options?.replace ? attempts[config.id]?.onConnected : undefined),
       })
-      run(
-        config.id,
-        Effect.gen(function* () {
-          yield* Effect.tryPromise(() => api.start({ ...config, replace: options?.replace }))
-          // Observe admission before treating an older disconnected snapshot as cancellation.
-          yield* Effect.tryPromise(input.refresh)
-        }),
-      )
+      run(config.id, async () => {
+        await api.start({ ...config, replace: options?.replace })
+        // Observe admission before treating an older disconnected snapshot as cancellation.
+        await input.refresh()
+      })
     },
     respond: (id: string, prompt: string, value: string) => {
       const api = input.api
       if (!api || item(id)?.prompt?.id !== prompt || attempts[id]?.submitting) return
       if (attempts[id]?.answered === prompt && !attempts[id]?.error) return
       setAttempts(id, "answered", prompt)
-      run(
-        id,
-        Effect.tryPromise(() => api.respond(id, prompt, value)),
-      )
+      run(id, () => api.respond(id, prompt, value))
     },
-    cancel: (id: string) => {
-      const task = tasks.get(id)
-      const api = input.api
-      Effect.runFork(
-        Effect.gen(function* () {
-          if (task) yield* Fiber.interrupt(task)
-          setAttempts(id, undefined)
-          if (!api) return
-          yield* Effect.tryPromise(() => api.cancel(id))
-          if (!item(id)?.saved) yield* Effect.tryPromise(() => api.forget(id))
-        }).pipe(Effect.ignore),
-      )
+    cancel: (id: string) => {
+      const api = input.api
+      interrupt(id)
+      setAttempts(id, undefined)
+      if (!api) return
+      void api
+        .cancel(id)
+        .then(() => (item(id)?.saved ? undefined : api.forget(id)))
+        .catch(() => undefined)
     },
     restore: (config: SshConfig) => input.api?.start({ ...config, background: true }),
     disconnect: (id: string) => input.api?.disconnect(id),
     forget: (id: string) => input.api?.forget(id),
   }
 }
+

packages/app/src/servers/ssh/schema.ts

@@ -0,0 +1,61 @@
+import { Schema } from "effect"
+
+// The SSH state contract between the desktop main process and its renderer. Only the main process
+// needs the schemas (its RPC server validates with them); the renderer imports the types from ./types.
+
+export const SshConfig = Schema.Struct({ id: Schema.String, target: Schema.String, name: Schema.String })
+export type SshConfig = typeof SshConfig.Type
+export const SshHttp = Schema.Struct({ url: Schema.String, password: Schema.String })
+export type SshHttp = typeof SshHttp.Type
+export const SshStage = Schema.Literals([
+  "disconnected",
+  "connecting",
+  "checking",
+  "downloading",
+  "uploading",
+  "starting",
+  "ready",
+  "authentication",
+  "incompatible",
+  "failed",
+])
+export const SshPrompt = Schema.Struct({
+  id: Schema.String,
+  text: Schema.String,
+  confirm: Schema.Boolean,
+})
+export const SshItem = Schema.Struct({
+  config: SshConfig,
+  saved: Schema.Boolean,
+  destination: Schema.optional(Schema.String),
+  stage: SshStage,
+  http: Schema.optional(SshHttp),
+  prompt: Schema.optional(SshPrompt),
+  authenticatingElsewhere: Schema.optional(Schema.Boolean),
+  detail: Schema.String,
+  error: Schema.optional(
+    Schema.Literals([
+      "connection",
+      "input",
+      "platform",
+      "version",
+      "install",
+      "service",
+      "host-key",
+      "ssh-missing",
+      "unpublished",
+    ]),
+  ),
+})
+export type SshItem = typeof SshItem.Type
+export const SshState = Schema.Struct({ servers: Schema.Array(SshItem) })
+export type SshState = typeof SshState.Type
+export const SshStart = Schema.Struct({
+  id: Schema.String,
+  target: Schema.String,
+  name: Schema.String,
+  replace: Schema.optional(Schema.Boolean),
+  background: Schema.optional(Schema.Boolean),
+})
+export type SshStart = typeof SshStart.Type
+

packages/app/src/servers/ssh/types.ts

@@ -1,63 +1,9 @@
-import { Schema } from "effect"
-export { sshHostname, sshName } from "./name"
-export { isSshConnecting } from "./status"
-
-export const SshConfig = Schema.Struct({ id: Schema.String, target: Schema.String, name: Schema.String })
-export type SshConfig = typeof SshConfig.Type
-export const SshHttp = Schema.Struct({ url: Schema.String, password: Schema.String })
-export type SshHttp = typeof SshHttp.Type
-export const SshStage = Schema.Literals([
-  "disconnected",
-  "connecting",
-  "checking",
-  "downloading",
-  "uploading",
-  "starting",
-  "ready",
-  "authentication",
-  "incompatible",
-  "failed",
-])
-export const SshPrompt = Schema.Struct({
-  id: Schema.String,
-  text: Schema.String,
-  confirm: Schema.Boolean,
-})
-export const SshItem = Schema.Struct({
-  config: SshConfig,
-  saved: Schema.Boolean,
-  destination: Schema.optional(Schema.String),
-  stage: SshStage,
-  http: Schema.optional(SshHttp),
-  prompt: Schema.optional(SshPrompt),
-  authenticatingElsewhere: Schema.optional(Schema.Boolean),
-  detail: Schema.String,
-  error: Schema.optional(
-    Schema.Literals([
-      "connection",
-      "input",
-      "platform",
-      "version",
-      "install",
-      "service",
-      "host-key",
-      "ssh-missing",
-      "unpublished",
-    ]),
-  ),
-})
-export type SshItem = typeof SshItem.Type
-export const SshState = Schema.Struct({ servers: Schema.Array(SshItem) })
-export type SshState = typeof SshState.Type
-export const SshStart = Schema.Struct({
-  id: Schema.String,
-  target: Schema.String,
-  name: Schema.String,
-  replace: Schema.optional(Schema.Boolean),
-  background: Schema.optional(Schema.Boolean),
-})
-export type SshStart = typeof SshStart.Type
-
+export { sshHostname, sshName } from "./name"
+export { isSshConnecting } from "./status"
+import type { SshConfig, SshHttp, SshItem, SshStart, SshState } from "./schema"
+
+export type { SshConfig, SshHttp, SshItem, SshStart, SshState }
+
 export type SshPlatform = {
   getState(): Promise<SshState>
   subscribe(callback: (state: SshState) => void): () => void
@@ -70,3 +16,5 @@ export type SshPlatform = {
   forget(id: string): Promise<void>
   openConfig(): Promise<void>
 }
+
+

packages/app/src/session/files/open-in-app.test.ts

@@ -1,9 +1,8 @@
 import { describe, expect, test } from "bun:test"
-import { Schema } from "effect"
 import { OPEN_APPS, OpenAppPreferences } from "./open-in-app"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
 
-const decode = Schema.decodeUnknownSync(Persistence.withInitial(OpenAppPreferences, { app: "finder" }))
+const decode = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(OpenAppPreferences, { app: "finder" }), input))
 
 describe("open app preferences", () => {
   test.each([...OPEN_APPS])("preserves the %s preference", (app) => {
@@ -18,3 +17,4 @@ describe("open app preferences", () => {
     expect(decode({})).toEqual({ app: "finder" })
   })
 })
+

packages/app/src/session/files/open-in-app.tsx

@@ -5,8 +5,7 @@ import { usePlatform } from "@/runtime/platform/platform"
 import { Persist, persisted } from "@/runtime/persistence/storage"
 import { showToast } from "@/shell/notifications/toast"
 import { useServer } from "@/runtime/server/current"
-import { Schema } from "effect"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
 import { fileManagerApp } from "@/home/projects/file-manager"
 import { openInAppParentPath } from "@/session/files/open-in-app-path"
 
@@ -30,8 +29,8 @@ export const OPEN_APPS = [
 export type OpenApp = (typeof OPEN_APPS)[number]
 export type OpenAppOS = "macos" | "windows" | "linux" | "unknown"
 
-export const OpenAppPreferences = Persistence.struct({
-  app: Schema.Literals(OPEN_APPS),
+export const OpenAppPreferences = Codec.struct({
+  app: Codec.literals(OPEN_APPS),
 })
 
 const appExistence = new Map<string, Promise<boolean>>()
@@ -242,3 +241,4 @@ function checkAppExists(platform: ReturnType<typeof usePlatform>, app: string) {
   appExistence.set(app, request)
   return request
 }
+

packages/app/src/session/review/panel-state.ts

@@ -5,17 +5,20 @@ import {
   type SessionReviewExpandMode,
 } from "@opencode/session-ui/v2/session-review-v2"
 import { createSignal } from "solid-js"
-import { Schema } from "effect"
+import { Codec } from "@/runtime/persistence/codec"
 import type { Platform } from "@/runtime/platform/platform"
 import { Persist, persisted } from "@/runtime/persistence/storage"
-import { Persistence } from "@/runtime/persistence/schema"
 
-const ReviewPanel = Persistence.struct({
-  sidebarOpened: Schema.Boolean,
-  sidebarWidth: Schema.Finite.check(
-    Schema.isBetween({ minimum: SESSION_REVIEW_V2_SIDEBAR_WIDTH_MIN, maximum: SESSION_REVIEW_V2_SIDEBAR_WIDTH_MAX }),
-  ),
-  expandMode: Schema.Literals(["expand", "collapse"]),
+const ReviewPanel = Codec.struct({
+  sidebarOpened: Codec.boolean,
+  sidebarWidth: Codec.make<number, number>(
+    (v) =>
+      typeof v === "number" && v >= SESSION_REVIEW_V2_SIDEBAR_WIDTH_MIN && v <= SESSION_REVIEW_V2_SIDEBAR_WIDTH_MAX
+        ? v
+        : Codec.INVALID,
+    (v) => v,
+  ),
+  expandMode: Codec.literals(["expand", "collapse"]),
 })
 
 export function createReviewPanelState(platform?: Platform) {
@@ -47,3 +50,4 @@ export function createReviewPanelState(platform?: Platform) {
 }
 
 export type ReviewPanelState = ReturnType<typeof createReviewPanelState>
+

packages/app/src/session/terminal/context.test.ts

@@ -2,9 +2,8 @@ import { beforeAll, describe, expect, mock, test } from "bun:test"
 import { ServerScope } from "@/runtime/server/scope"
 import { base64Encode } from "@opencode/util/encode"
 import { Persist } from "@/runtime/persistence/storage"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
 import type { Platform } from "@/runtime/platform/platform"
-import { Schema } from "effect"
 
 let getWorkspaceTerminalCacheKey: typeof import("./context").getWorkspaceTerminalCacheKey
 let clearWorkspaceTerminals: typeof import("./context").clearWorkspaceTerminals
@@ -21,10 +20,10 @@ beforeAll(async () => {
   const mod = await import("./context")
   getWorkspaceTerminalCacheKey = mod.getWorkspaceTerminalCacheKey
   clearWorkspaceTerminals = mod.clearWorkspaceTerminals
-  const schema = Persistence.withInitial(mod.TerminalState, { all: [] })
-  decodeTerminalState = Schema.decodeUnknownSync(schema)
+  const schema = Codec.withInitial(mod.TerminalState, { all: [] })
+  decodeTerminalState = ((input: unknown) => Codec.decodeOrThrow(schema, input))
   roundTripTerminalState = (value) =>
-    Schema.decodeUnknownSync(schema)(Schema.encodeSync(schema)(Schema.decodeUnknownSync(schema)(value)))
+    Codec.decodeOrThrow(schema, schema.encode(Codec.decodeOrThrow(schema, value)))
 })
 
 describe("getWorkspaceTerminalCacheKey", () => {
@@ -141,3 +140,4 @@ describe("TerminalState", () => {
     expect(roundTripTerminalState(value)).toEqual(value)
   })
 })
+

packages/app/src/session/terminal/context.tsx

@@ -8,18 +8,20 @@ import { base64Encode } from "@opencode/util/encode"
 import { defaultTitle, titleNumber } from "./title"
 import { Persist, persisted, removePersisted } from "@/runtime/persistence/storage"
 import { ScopedKey, ServerScope } from "@/runtime/server/scope"
-import { Persistence } from "@/runtime/persistence/schema"
-import { Schema, SchemaGetter } from "effect"
+import { Codec } from "@/runtime/persistence/codec"
 
-const PTY = Persistence.struct({
-  id: Schema.NonEmptyString,
-  title: Persistence.fallback(Schema.String, () => ""),
-  titleNumber: Persistence.fallback(Schema.Finite, () => 0),
-  rows: Persistence.optional(Schema.Finite),
-  cols: Persistence.optional(Schema.Finite),
-  buffer: Persistence.optional(Schema.String),
-  scrollY: Persistence.optional(Schema.Finite),
-  cursor: Persistence.optional(Schema.Finite),
+const PTY = Codec.struct({
+  id: Codec.make<string, string>(
+    (v) => (typeof v === "string" && v.length > 0 ? v : Codec.INVALID),
+    (v) => v,
+  ),
+  title: Codec.fallback(Codec.string, () => ""),
+  titleNumber: Codec.fallback(Codec.number, () => 0),
+  rows: Codec.lenientOptional(Codec.number),
+  cols: Codec.lenientOptional(Codec.number),
+  buffer: Codec.lenientOptional(Codec.string),
+  scrollY: Codec.lenientOptional(Codec.number),
+  cursor: Codec.lenientOptional(Codec.number),
 })
 
 export type LocalPTY = typeof PTY.Type
@@ -31,28 +33,26 @@ function numberFromTitle(title: string) {
   return titleNumber(title, MAX_TERMINAL_SESSIONS)
 }
 
-const State = Persistence.struct({
-  active: Persistence.optional(Schema.String),
-  all: Persistence.array(PTY),
+const State = Codec.struct({
+  active: Codec.lenientOptional(Codec.string),
+  all: Codec.lenientArray(PTY),
 })
 
-export const TerminalState = State.pipe(
-  Schema.decodeTo(Schema.toType(State), {
-    decode: SchemaGetter.transform((value) => {
-      const seen = new Set<string>()
-      const all = value.all.flatMap((pty) => {
-        if (seen.has(pty.id)) return []
-        seen.add(pty.id)
-        return [{ ...pty, titleNumber: pty.titleNumber > 0 ? pty.titleNumber : (numberFromTitle(pty.title) ?? 0) }]
-      })
-      return {
-        active: value.active && seen.has(value.active) ? value.active : all[0]?.id,
-        all,
-      }
-    }),
-    encode: SchemaGetter.transform((value) => value),
-  }),
-)
+export const TerminalState = Codec.transform(State, {
+  decode: (value): typeof State.Type => {
+    const seen = new Set<string>()
+    const all = value.all.flatMap((pty) => {
+      if (seen.has(pty.id)) return []
+      seen.add(pty.id)
+      return [{ ...pty, titleNumber: pty.titleNumber > 0 ? pty.titleNumber : (numberFromTitle(pty.title) ?? 0) }]
+    })
+    return {
+      active: value.active && seen.has(value.active) ? value.active : all[0]?.id,
+      all,
+    }
+  },
+  encode: (value) => value,
+})
 
 export function getWorkspaceTerminalCacheKey(dir: string, scope: ServerScope = ServerScope.local) {
   return ScopedKey.from(scope, dir, WORKSPACE_KEY)
@@ -458,3 +458,5 @@ export const { use: useTerminal, provider: TerminalProvider } = createSimpleCont
     }
   },
 })
+
+

packages/app/src/session/usage-exceeded-dialogs.test.ts

@@ -1,40 +1,40 @@
-import { describe, expect, test } from "bun:test"
-import { Schema } from "effect"
-import { GoUpsellState } from "./usage-exceeded-dialogs"
-import { Persistence } from "@/runtime/persistence/schema"
-
-const decode = Schema.decodeUnknownSync(
-  Persistence.withInitial(GoUpsellState, {
-    go_upsell_last_seen_at: null,
-    go_upsell_dont_show: null,
-    go_upsell_account_rate_limit_last_seen_at: null,
-    go_upsell_account_rate_limit_dont_show: null,
-  }),
-)
-
-describe("usage exceeded preferences", () => {
-  test("defaults unseen prompts", () => {
-    expect(decode({})).toEqual({
-      go_upsell_last_seen_at: null,
-      go_upsell_dont_show: null,
-      go_upsell_account_rate_limit_last_seen_at: null,
-      go_upsell_account_rate_limit_dont_show: null,
-    })
-  })
-
-  test("preserves timestamps while recovering malformed siblings", () => {
-    expect(
-      decode({
-        go_upsell_last_seen_at: 123,
-        go_upsell_dont_show: "true",
-        go_upsell_account_rate_limit_last_seen_at: Infinity,
-        go_upsell_account_rate_limit_dont_show: 456,
-      }),
-    ).toEqual({
-      go_upsell_last_seen_at: 123,
-      go_upsell_dont_show: null,
-      go_upsell_account_rate_limit_last_seen_at: null,
-      go_upsell_account_rate_limit_dont_show: 456,
-    })
-  })
-})
+import { describe, expect, test } from "bun:test"
+import { GoUpsellState } from "./usage-exceeded-dialogs"
+import { Codec } from "@/runtime/persistence/codec"
+
+const schema = Codec.withInitial(GoUpsellState, {
+  go_upsell_last_seen_at: null,
+  go_upsell_dont_show: null,
+  go_upsell_account_rate_limit_last_seen_at: null,
+  go_upsell_account_rate_limit_dont_show: null,
+})
+const decode = (input: unknown) => Codec.decodeOrThrow(schema, input)
+
+describe("usage exceeded preferences", () => {
+  test("defaults unseen prompts", () => {
+    expect(decode({})).toEqual({
+      go_upsell_last_seen_at: null,
+      go_upsell_dont_show: null,
+      go_upsell_account_rate_limit_last_seen_at: null,
+      go_upsell_account_rate_limit_dont_show: null,
+    })
+  })
+
+  test("preserves timestamps while recovering malformed siblings", () => {
+    expect(
+      decode({
+        go_upsell_last_seen_at: 123,
+        go_upsell_dont_show: "true",
+        go_upsell_account_rate_limit_last_seen_at: Infinity,
+        go_upsell_account_rate_limit_dont_show: 456,
+      }),
+    ).toEqual({
+      go_upsell_last_seen_at: 123,
+      go_upsell_dont_show: null,
+      go_upsell_account_rate_limit_last_seen_at: null,
+      go_upsell_account_rate_limit_dont_show: 456,
+    })
+  })
+})
+
+

packages/app/src/session/usage-exceeded-dialogs.tsx

@@ -2,8 +2,7 @@ import { useWorkspaceLocation } from "@/workspaces/location"
 import { Persist, persisted } from "@/runtime/persistence/storage"
 import type { SessionStatus } from "@opencode/client/promise"
 import { onCleanup } from "solid-js"
-import { Schema } from "effect"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
 import { useSessionLayout } from "./session-layout"
 import { useDialog, useI18n } from "@opencode/ui/context"
 import { DialogUsageExceeded } from "@/providers/connect/usage-exceeded"
@@ -15,11 +14,11 @@ const GO_UPSELL_ACCOUNT_RATE_LIMIT_DONT_SHOW = "go_upsell_account_rate_limit_don
 const GO_UPSELL_WINDOW = 86_400_000 // 24 hrs
 const GO_UPSELL_PROVIDERS = new Set(["opencode", "opencode-go"])
 
-export const GoUpsellState = Persistence.struct({
-  [GO_UPSELL_FREE_TIER_LAST_SEEN_AT]: Schema.NullOr(Schema.Finite),
-  [GO_UPSELL_FREE_TIER_DONT_SHOW]: Schema.NullOr(Schema.Finite),
-  [GO_UPSELL_ACCOUNT_RATE_LIMIT_LAST_SEEN_AT]: Schema.NullOr(Schema.Finite),
-  [GO_UPSELL_ACCOUNT_RATE_LIMIT_DONT_SHOW]: Schema.NullOr(Schema.Finite),
+export const GoUpsellState = Codec.struct({
+  [GO_UPSELL_FREE_TIER_LAST_SEEN_AT]: Codec.nullOr(Codec.number),
+  [GO_UPSELL_FREE_TIER_DONT_SHOW]: Codec.nullOr(Codec.number),
+  [GO_UPSELL_ACCOUNT_RATE_LIMIT_LAST_SEEN_AT]: Codec.nullOr(Codec.number),
+  [GO_UPSELL_ACCOUNT_RATE_LIMIT_DONT_SHOW]: Codec.nullOr(Codec.number),
 })
 
 function goUpsellKeys(status: SessionStatus) {
@@ -106,3 +105,4 @@ export function useUsageExceededDialogs() {
     }),
   )
 }
+

packages/app/src/settings/model.test.ts

@@ -1,7 +1,6 @@
 import { describe, expect, test } from "bun:test"
-import { Schema } from "effect"
 import { timelinePresets } from "@opencode/session-ui/timeline/detail"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
 import {
   settingsSchema,
   settingsPersistence,
@@ -13,9 +12,9 @@ import {
   terminalFontFamily,
 } from "./model"
 
-const schema = Persistence.withInitial(settingsPersistence, defaultSettings)
-const decode = Schema.decodeUnknownSync(schema)
-const encode = Schema.encodeSync(schema)
+const schema = Codec.withInitial(settingsPersistence, defaultSettings)
+const decode = (input: unknown) => Codec.decodeOrThrow(schema, input)
+const encode = (value: typeof settingsSchema.Type) => schema.encode(value)
 
 describe("settings timeline detail migration", () => {
   test("migrates saved switches and round trips the current settings", () => {
@@ -51,14 +50,14 @@ describe("settings schema", () => {
       general: { ...defaultSettings.general, timelineDetail: timelinePresets[4].value, autoSave: false },
       appearance: { ...defaultSettings.appearance, fontSize: 20 },
     }
-    const restore = Schema.decodeUnknownSync(Persistence.withInitial(settingsPersistence, initial))
+    const restore = (input: unknown) => Codec.decodeOrThrow(Codec.withInitial(settingsPersistence, initial), input)
     expect(restore({})).toEqual(initial)
     expect(restore({ general: { reasoningMode: "invalid", showReasoningSummaries: true } })).toEqual(initial)
     expect(restore({ general: { showReasoningSummaries: true } }).general.timelineDetail.thinking).toEqual({
       placement: "separate",
       details: "expanded",
     })
-    expect(() => Schema.decodeUnknownSync(settingsSchema)({})).toThrow()
+    expect(() => Codec.decodeOrThrow(settingsSchema, {})).toThrow()
   })
 
   test("supplies the existing defaults for an empty document", () => {
@@ -171,7 +170,7 @@ describe("settings schema", () => {
 
   test("does not silently repair invalid values during encoding", () => {
     expect(() =>
-      Schema.encodeUnknownSync(settingsSchema)({ ...decode({}), appearance: { fontSize: "large" } }),
+      Codec.encodeOrThrow(settingsSchema, { ...decode({}), appearance: { fontSize: "large" } } as never),
     ).toThrow()
   })
 })
@@ -203,3 +202,6 @@ describe("settings font families", () => {
     expect(terminalFontFamily(undefined)).toStartWith('"JetBrainsMono Nerd Font Mono", ')
   })
 })
+
+
+

packages/app/src/settings/model.tsx

@@ -1,10 +1,9 @@
 import { reconcile, unwrap } from "solid-js/store"
 import { createEffect, createMemo } from "solid-js"
-import { Effect, Option, Schema, SchemaGetter } from "effect"
 import { createSimpleContext } from "@opencode/ui/context"
 import { timelinePresets, type TimelineCategory, type TimelineDetail } from "@opencode/session-ui/timeline/detail"
 import { persisted } from "@/runtime/persistence/storage"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
 import { ScopedKey, type ServerScope } from "@/runtime/server/scope"
 
 export type Settings = typeof settingsSchema.Type
@@ -68,20 +67,20 @@ export function terminalFontFamily(font: string | undefined) {
   return stack(font, terminalBase)
 }
 
-const placementSchema = Schema.Literals(["separate", "grouped", "hidden"])
-const detailsSchema = Schema.Literals(["collapsed", "expanded"])
-const activitySchema = Persistence.struct({ placement: placementSchema, details: detailsSchema })
-const placementOnlySchema = Persistence.struct({ placement: placementSchema })
+const placementSchema = Codec.literals(["separate", "grouped", "hidden"])
+const detailsSchema = Codec.literals(["collapsed", "expanded"])
+const activitySchema = Codec.struct({ placement: placementSchema, details: detailsSchema })
+const placementOnlySchema = Codec.struct({ placement: placementSchema })
 
-const generalSchema = Persistence.struct({
-  autoSave: Schema.Boolean,
-  releaseNotes: Schema.Boolean,
-  showFileTree: Schema.Boolean,
-  showNavigation: Schema.Boolean,
-  showSearch: Schema.Boolean,
-  showProjectIcon: Schema.Boolean,
-  showTerminal: Schema.Boolean,
-  timelineDetail: Persistence.struct({
+const generalSchema = Codec.struct({
+  autoSave: Codec.boolean,
+  releaseNotes: Codec.boolean,
+  showFileTree: Codec.boolean,
+  showNavigation: Codec.boolean,
+  showSearch: Codec.boolean,
+  showProjectIcon: Codec.boolean,
+  showTerminal: Codec.boolean,
+  timelineDetail: Codec.struct({
     shell: activitySchema,
     edit: activitySchema,
     thinking: activitySchema,
@@ -89,91 +88,90 @@ const generalSchema = Persistence.struct({
     notices: placementOnlySchema,
     tools: placementOnlySchema,
   }),
-  showCustomAgents: Schema.Boolean,
-  mobileTitlebarPosition: Schema.Literals(["top", "bottom"]),
-  mobileDiffWrap: Schema.Boolean,
-  terminalPlacement: Schema.Literals(["side", "bottom"]),
-  followUpBehavior: Schema.Literals(["queue", "steer"]),
-  experimentalBrowser: Schema.Boolean,
+  showCustomAgents: Codec.boolean,
+  mobileTitlebarPosition: Codec.literals(["top", "bottom"]),
+  mobileDiffWrap: Codec.boolean,
+  terminalPlacement: Codec.literals(["side", "bottom"]),
+  followUpBehavior: Codec.literals(["queue", "steer"]),
+  experimentalBrowser: Codec.boolean,
 })
 
-const appearanceSchema = Persistence.struct({
-  fontSize: Schema.Number,
-  mono: Schema.String,
-  sans: Schema.String,
-  terminal: Schema.String,
-  tabLayout: Schema.Literals(["horizontal", "vertical"]),
-  showProjectName: Schema.Boolean,
+const appearanceSchema = Codec.struct({
+  fontSize: Codec.number,
+  mono: Codec.string,
+  sans: Codec.string,
+  terminal: Codec.string,
+  tabLayout: Codec.literals(["horizontal", "vertical"]),
+  showProjectName: Codec.boolean,
 })
 
-const permissionsSchema = Persistence.struct({
-  autoApprove: Schema.Boolean,
+const permissionsSchema = Codec.struct({
+  autoApprove: Codec.boolean,
 })
 
-const workspacesSchema = Persistence.struct({
-  defaultDestination: Schema.Literals(["last-used", "local", "new"]),
-  lastUsed: Persistence.record(
-    Schema.Literals(["local", "workspace"]).pipe(Schema.catchDecoding(() => Effect.succeed(Option.none()))),
-  ),
+const workspacesSchema = Codec.struct({
+  defaultDestination: Codec.literals(["last-used", "local", "new"]),
+  lastUsed: Codec.fallback(Codec.sparseRecord(Codec.literals(["local", "workspace"])), () => ({})),
 })
 
-const notificationsSchema = Persistence.struct({
-  agent: Schema.Boolean,
-  permissions: Schema.Boolean,
-  errors: Schema.Boolean,
+const notificationsSchema = Codec.struct({
+  agent: Codec.boolean,
+  permissions: Codec.boolean,
+  errors: Codec.boolean,
 })
 
-const soundsSchema = Persistence.struct({
-  agentEnabled: Schema.Boolean,
-  agent: Schema.String,
-  permissionsEnabled: Schema.Boolean,
-  permissions: Schema.String,
-  errorsEnabled: Schema.Boolean,
-  errors: Schema.String,
+const soundsSchema = Codec.struct({
+  agentEnabled: Codec.boolean,
+  agent: Codec.string,
+  permissionsEnabled: Codec.boolean,
+  permissions: Codec.string,
+  errorsEnabled: Codec.boolean,
+  errors: Codec.string,
 })
 
-export const settingsSchema = Persistence.struct({
+export const settingsSchema = Codec.struct({
   general: generalSchema,
-  sessionSummary: Persistence.struct({ projectExpanded: Schema.Boolean, serverExpanded: Schema.Boolean }),
+  sessionSummary: Codec.struct({ projectExpanded: Codec.boolean, serverExpanded: Codec.boolean }),
   appearance: appearanceSchema,
-  keybinds: Persistence.record(Schema.String.pipe(Schema.catchDecoding(() => Effect.succeed(Option.none())))),
+  keybinds: Codec.fallback(Codec.sparseRecord(Codec.string), () => ({})),
   permissions: permissionsSchema,
   workspaces: workspacesSchema,
   notifications: notificationsSchema,
   sounds: soundsSchema,
 })
 
+const storedActivity = Codec.struct(
+  {
+    placement: Codec.lenientOptional(placementSchema),
+    details: Codec.lenientOptional(detailsSchema),
+  },
+  { preserve: true },
+)
+const storedActivityWord = Codec.literals(["expanded", "collapsed", "hidden", "visible"])
+
 function storedTimelineCategory(category: TimelineCategory) {
-  return Persistence.optional(
-    Schema.Union([
-      Schema.Struct({
-        placement: Persistence.optional(placementSchema),
-        details: Persistence.optional(detailsSchema),
-      }),
-      Schema.Literals(["expanded", "collapsed", "hidden", "visible"]),
-    ]).pipe(
-      Schema.decode({
-        decode: SchemaGetter.transform((value) => {
-          if (typeof value !== "string") return value
-          return {
-            placement:
-              value === "hidden"
-                ? "hidden"
-                : category === "subagents"
-                  ? "separate"
-                  : category === "tools"
-                    ? "grouped"
-                    : value === "expanded"
-                      ? "separate"
-                      : value === "collapsed"
-                        ? "grouped"
-                        : undefined,
-            details: value === "expanded" ? "expanded" : "collapsed",
-          }
-        }),
-        encode: SchemaGetter.passthrough(),
-      }),
-    ),
+  return Codec.lenientOptional(
+    Codec.transform(Codec.union([storedActivity, storedActivityWord]), {
+      decode: (value) => {
+        if (typeof value !== "string") return value
+        return {
+          placement:
+            value === "hidden"
+              ? ("hidden" as const)
+              : category === "subagents"
+                ? ("separate" as const)
+                : category === "tools"
+                  ? ("grouped" as const)
+                  : value === "expanded"
+                    ? ("separate" as const)
+                    : value === "collapsed"
+                      ? ("grouped" as const)
+                      : undefined,
+          details: value === "expanded" ? ("expanded" as const) : ("collapsed" as const),
+        }
+      },
+      encode: (value) => value,
+    }),
   )
 }
 
@@ -186,54 +184,55 @@ function legacyTimelineActivity(value: boolean | "hidden" | "compact" | "full" |
   } as const
 }
 
-export const settingsPersistence = Persistence.migrate(
+// An explicit but invalid value decodes to null, distinct from absent, so a legacy preference
+// cannot replace a setting the user did set.
+const explicitOrNull = <T, E>(codec: Codec.Of<T, E>) => Codec.optional(Codec.fallback(Codec.nullOr(codec), () => null))
+
+const storedTimelineDetail = Codec.struct(
+  {
+    shell: storedTimelineCategory("shell"),
+    edit: storedTimelineCategory("edit"),
+    thinking: storedTimelineCategory("thinking"),
+    subagents: storedTimelineCategory("subagents"),
+    notices: storedTimelineCategory("notices"),
+    tools: storedTimelineCategory("tools"),
+  },
+  { preserve: true },
+)
+const storedGeneral = Codec.struct(
+  {
+    timelineDetail: explicitOrNull(storedTimelineDetail),
+    reasoningMode: explicitOrNull(Codec.literals(["hidden", "compact", "full"])),
+    showReasoningSummaries: Codec.lenientOptional(Codec.boolean),
+    shellToolPartsExpanded: Codec.lenientOptional(Codec.boolean),
+    editToolPartsExpanded: Codec.lenientOptional(Codec.boolean),
+  },
+  { preserve: true },
+)
+const storedSettings = Codec.struct({ general: Codec.lenientOptional(storedGeneral) }, { preserve: true })
+
+export const settingsPersistence = Codec.migrate(
   settingsSchema,
-  Schema.Struct({
-    general: Persistence.optional(
-      Schema.Struct({
-        // Keep invalid explicit values distinct from absent values so legacy preferences cannot replace them.
-        timelineDetail: Schema.optional(
-          Schema.NullOr(
-            Schema.Struct({
-              shell: storedTimelineCategory("shell"),
-              edit: storedTimelineCategory("edit"),
-              thinking: storedTimelineCategory("thinking"),
-              subagents: storedTimelineCategory("subagents"),
-              notices: storedTimelineCategory("notices"),
-              tools: storedTimelineCategory("tools"),
-            }),
-          ),
-        ).pipe(Schema.catchDecoding(() => Effect.succeed(Option.some(null)))),
-        reasoningMode: Schema.optional(Schema.NullOr(Schema.Literals(["hidden", "compact", "full"]))).pipe(
-          Schema.catchDecoding(() => Effect.succeed(Option.some(null))),
-        ),
-        showReasoningSummaries: Persistence.optional(Schema.Boolean),
-        shellToolPartsExpanded: Persistence.optional(Schema.Boolean),
-        editToolPartsExpanded: Persistence.optional(Schema.Boolean),
-      }),
-    ),
-  }).pipe(
-    Schema.decode({
-      decode: SchemaGetter.transform((value) => {
-        const general = value.general
-        if (!general || general.timelineDetail !== undefined) return value
-        return {
-          ...value,
-          general: {
-            ...general,
-            timelineDetail: {
-              shell: legacyTimelineActivity(general.shellToolPartsExpanded),
-              edit: legacyTimelineActivity(general.editToolPartsExpanded),
-              thinking: legacyTimelineActivity(
-                general.reasoningMode === undefined ? general.showReasoningSummaries : general.reasoningMode,
-              ),
-            },
+  Codec.transform(storedSettings, {
+    decode: (value) => {
+      const general = value.general
+      if (!general || general.timelineDetail !== undefined) return value
+      return {
+        ...value,
+        general: {
+          ...general,
+          timelineDetail: {
+            shell: legacyTimelineActivity(general.shellToolPartsExpanded),
+            edit: legacyTimelineActivity(general.editToolPartsExpanded),
+            thinking: legacyTimelineActivity(
+              general.reasoningMode === undefined ? general.showReasoningSummaries : general.reasoningMode,
+            ),
           },
-        }
-      }),
-      encode: SchemaGetter.transform((value) => value),
-    }),
-  ),
+        },
+      }
+    },
+    encode: (value) => value,
+  }),
 )
 
 export const defaultSettings: Settings = {

packages/app/src/settings/models/models.tsx

@@ -5,8 +5,7 @@ import { Icon } from "@opencode/ui/icon"
 import { IconButton } from "@opencode/ui/icon-button"
 import { TextInput } from "@opencode/ui/text-input"
 import { type Component, createEffect, For, on, onCleanup, Show } from "solid-js"
-import { Schema } from "effect"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
 import { useLanguage } from "@/runtime/i18n/language"
 import { useModels } from "@/providers/models/models"
 import { useServerSDK } from "@/runtime/server/client"
@@ -20,8 +19,8 @@ type ModelItem = ReturnType<ReturnType<typeof useModels>["list"]>[number]
 
 const PROVIDER_ICON_SIZE = 16
 
-export const ModelProvidersSchema = Schema.Struct({
-  collapsed: Persistence.record(Persistence.fallback(Schema.Boolean, () => false)),
+export const ModelProvidersSchema = Codec.struct({
+  collapsed: Codec.lenientRecord(Codec.fallback(Codec.boolean, () => false)),
 })
 
 export const SettingsModels: Component<{ active?: boolean; autofocus?: boolean }> = (props) => {
@@ -211,3 +210,4 @@ export const SettingsModels: Component<{ active?: boolean; autofocus?: boolean }
     </>
   )
 }
+

packages/app/src/shell/commands/command.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { Schema } from "effect"
+import { Codec } from "@/runtime/persistence/codec"
 import {
   activeCommandRegistrations,
   addCommandRegistration,
@@ -10,12 +10,12 @@ import {
 } from "./command"
 
 test("command catalog persistence validates metadata and omits executable fields", () => {
-  const decode = Schema.decodeUnknownSync(CommandCatalog)
+  const decode = ((input: unknown) => Codec.decodeOrThrow(CommandCatalog, input))
   const catalog = decode({ open: { title: "Open", keybind: "mod+o", hidden: false, onSelect: "invalid" } })
   expect(catalog).toEqual({ open: { title: "Open", keybind: "mod+o", hidden: false } })
   expect(decode({})).toEqual({})
   expect(() => decode({ open: { title: 1 } })).toThrow()
-  expect(decode(Schema.encodeSync(CommandCatalog)(catalog))).toEqual(catalog)
+  expect(decode(CommandCatalog.encode(catalog))).toEqual(catalog)
 })
 
 const paletteOptions: CommandOption[] = [
@@ -79,3 +79,4 @@ describe("resolveKeybindOption", () => {
     expect(resolveKeybindOption([fallback, contextual], new KeyboardEvent("keydown"))).toBe(fallback)
   })
 })
+

packages/app/src/shell/commands/command.tsx

@@ -2,8 +2,8 @@ import { createSimpleContext } from "@opencode/ui/context"
 import { useDialog } from "@opencode/ui/context/dialog"
 import { type Accessor, batch, createEffect, createMemo, onCleanup, onMount } from "solid-js"
 import { createStore, reconcile } from "solid-js/store"
-import { Schema } from "effect"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
+
 import { makeEventListener } from "@solid-primitives/event-listener"
 import { useLanguage } from "@/runtime/i18n/language"
 import { useSettings } from "@/settings/model"
@@ -109,16 +109,16 @@ export function resolveKeybindOption(candidates: CommandOption[] | undefined, ev
 
 type CommandSource = "palette" | "keybind" | "slash"
 
-export const CommandCatalogItem = Persistence.struct({
-  title: Schema.String,
-  description: Schema.optional(Schema.String),
-  category: Schema.optional(Schema.String),
-  keybind: Schema.optional(Schema.String),
-  slash: Schema.optional(Schema.String),
-  hidden: Schema.optional(Schema.Boolean),
+export const CommandCatalogItem = Codec.struct({
+  title: Codec.string,
+  description: Codec.optional(Codec.string),
+  category: Codec.optional(Codec.string),
+  keybind: Codec.optional(Codec.string),
+  slash: Codec.optional(Codec.string),
+  hidden: Codec.optional(Codec.boolean),
 })
 export type CommandCatalogItem = typeof CommandCatalogItem.Type
-export const CommandCatalog = Schema.Record(Schema.String, Schema.mutableKey(CommandCatalogItem))
+export const CommandCatalog = Codec.record(CommandCatalogItem)
 export type CommandCatalog = typeof CommandCatalog.Type
 
 export type CommandRegistration = {
@@ -480,3 +480,4 @@ export const { use: useCommand, provider: CommandProvider } = createSimpleContex
     }
   },
 })
+

packages/app/src/shell/notifications/notification.test.ts

@@ -1,23 +1,22 @@
 import { expect, test } from "bun:test"
-import { Schema } from "effect"
 import type { ServerConnection } from "@/runtime/server/registry"
 import type { Tab } from "@/shell/tabs/tabs"
 import { NotificationStore, openNotificationSession, type Notification } from "./notification"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
 
 test("notification persistence validates and salvages individual notifications", () => {
   const valid: Notification[] = [
     { type: "turn-complete", time: 123, viewed: false, session: "session-1" },
     { type: "error", time: 124, viewed: true, error: { type: "api", message: "failed", status: 500 } },
   ]
-  const decode = Schema.decodeUnknownSync(Persistence.withInitial(NotificationStore, { list: [] }))
+  const decode = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(NotificationStore, { list: [] }), input))
   const store = decode({
     list: [valid[0], null, { type: "unknown", time: 123, viewed: false }, { ...valid[1], error: "invalid" }, valid[1]],
   })
   expect(store.list).toEqual(valid)
   expect(decode({})).toEqual({ list: [] })
   expect(decode({ list: {} })).toEqual({ list: [] })
-  expect(decode(Schema.encodeSync(NotificationStore)(store))).toEqual(store)
+  expect(decode(NotificationStore.encode(store))).toEqual(store)
 })
 
 test("opens notification sessions through the tab router", () => {
@@ -41,3 +40,4 @@ test("opens notification sessions through the tab router", () => {
 
   expect(calls).toEqual(["add:session-1", "route:session-1", "select:session-1"])
 })
+

packages/app/src/shell/notifications/notification.tsx

@@ -1,6 +1,6 @@
 import { createStore, reconcile } from "solid-js/store"
-import { Schema } from "effect"
-import { SessionError } from "@opencode/schema/session-error"
+import { Codec } from "@/runtime/persistence/codec"
+import type { SessionError } from "@opencode/schema/session-error"
 import { type Accessor, batch, createEffect, createMemo, createRoot, getOwner, onCleanup } from "solid-js"
 import { createSimpleContext } from "@opencode/ui/context"
 import type { ServerSDK } from "@/runtime/server/client"
@@ -10,7 +10,7 @@ import { useLanguage } from "@/runtime/i18n/language"
 import { useSettings } from "@/settings/model"
 import { decode64 } from "@/runtime/persistence/base64"
 import { Persist, persisted } from "@/runtime/persistence/storage"
-import { Persistence } from "@/runtime/persistence/schema"
+
 import { playSoundById } from "@/shell/notifications/sound"
 import type { createNotificationCoordinator } from "@/shell/notifications/coordinator"
 import { useGlobal } from "@/runtime/server/runtime"
@@ -20,19 +20,28 @@ import { requireServerKey, sessionHref } from "@/shell/routes/session"
 import type { ServerScope } from "@/runtime/server/scope"
 import { useServer } from "@/runtime/server/current"
 
-const NotificationBase = {
-  directory: Schema.optional(Schema.String),
-  session: Schema.optional(Schema.String),
-  metadata: Schema.optional(Schema.Unknown),
-  time: Schema.Finite,
-  viewed: Schema.Boolean,
-}
-export const Notification = Schema.Union([
-  Persistence.struct({ ...NotificationBase, type: Schema.Literal("turn-complete") }),
-  Persistence.struct({ ...NotificationBase, type: Schema.Literal("error"), error: SessionError.Error }),
+const NotificationBase = {
+  directory: Codec.optional(Codec.string),
+  session: Codec.optional(Codec.string),
+  metadata: Codec.optional(Codec.unknown),
+  time: Codec.number,
+  viewed: Codec.boolean,
+}
+// The error payload is whatever the server reported; shape-checking it here would load the shared
+// Effect schema into the renderer's startup path for a value the server already validated.
+const StoredSessionError = Codec.make<SessionError.Error, unknown>(
+  (value) =>
+    typeof value === "object" && value !== null && "name" in value && "message" in value
+      ? (value as unknown as SessionError.Error)
+      : Codec.INVALID,
+  (value) => value,
+)
+export const Notification = Codec.union([
+  Codec.struct({ ...NotificationBase, type: Codec.literal("turn-complete") }),
+  Codec.struct({ ...NotificationBase, type: Codec.literal("error"), error: StoredSessionError }),
 ])
 export type Notification = typeof Notification.Type
-export const NotificationStore = Persistence.struct({ list: Persistence.array(Notification) })
+export const NotificationStore = Codec.struct({ list: Codec.lenientArray(Notification) })
 
 type NotificationIndex = {
   session: {
@@ -368,3 +377,5 @@ export const useNotification = () => {
   const server = useServer()
   return server.ctx.notification
 }
+
+

packages/app/src/shell/updates/highlights.test.ts

@@ -1,13 +1,13 @@
 import { expect, test } from "bun:test"
-import { Schema } from "effect"
 import { HighlightsStore } from "./highlights"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
 
 test("highlight persistence defaults missing or invalid versions and round-trips valid versions", () => {
-  const decode = Schema.decodeUnknownSync(Persistence.withInitial(HighlightsStore, { version: undefined }))
+  const decode = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(HighlightsStore, { version: undefined }), input))
   expect(decode({})).toEqual({ version: undefined })
   expect(decode({ version: null })).toEqual({ version: undefined })
   const value = decode({ version: "1.2.3", legacy: true })
   expect(value).toEqual({ version: "1.2.3" })
-  expect(Schema.encodeSync(HighlightsStore)(value)).toEqual(value)
+  expect(HighlightsStore.encode(value)).toEqual(value)
 })
+

packages/app/src/shell/updates/highlights.tsx

@@ -1,18 +1,18 @@
 import { createEffect, onCleanup } from "solid-js"
 import { createStore } from "solid-js/store"
-import { Schema } from "effect"
+import { Codec } from "@/runtime/persistence/codec"
 import { createSimpleContext } from "@opencode/ui/context"
 import { useDialog } from "@opencode/ui/context/dialog"
 import { usePlatform } from "@/runtime/platform/platform"
 import { useSettings } from "@/settings/model"
 import { persisted } from "@/runtime/persistence/storage"
-import { Persistence } from "@/runtime/persistence/schema"
+
 import { DialogReleaseNotes, type Highlight } from "@/shell/updates/release-notes"
 
 const CHANGELOG_URL = "https://opencode.ai/changelog.json"
 
-export const HighlightsStore = Persistence.struct({
-  version: Schema.UndefinedOr(Schema.String),
+export const HighlightsStore = Codec.struct({
+  version: Codec.undefinedOr(Codec.string),
 })
 
 type ParsedRelease = {
@@ -233,3 +233,4 @@ export const { use: useHighlights, provider: HighlightsProvider } = createSimple
     }
   },
 })
+

packages/app/src/workspaces/files/types.ts

@@ -1,20 +1,19 @@
 import type { FileContent } from "@/runtime/server/types"
-import { Schema } from "effect"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
 
-export const FileSelection = Persistence.struct({
-  startLine: Schema.Number,
-  startChar: Schema.Number,
-  endLine: Schema.Number,
-  endChar: Schema.Number,
+export const FileSelection = Codec.struct({
+  startLine: Codec.number,
+  startChar: Codec.number,
+  endLine: Codec.number,
+  endChar: Codec.number,
 })
 export type FileSelection = typeof FileSelection.Type
 
-export const SelectedLineRange = Persistence.struct({
-  start: Schema.Number,
-  end: Schema.Number,
-  side: Persistence.optional(Schema.Literals(["additions", "deletions"])),
-  endSide: Persistence.optional(Schema.Literals(["additions", "deletions"])),
+export const SelectedLineRange = Codec.struct({
+  start: Codec.number,
+  end: Codec.number,
+  side: Codec.lenientOptional(Codec.literals(["additions", "deletions"])),
+  endSide: Codec.lenientOptional(Codec.literals(["additions", "deletions"])),
 })
 export type SelectedLineRange = typeof SelectedLineRange.Type
 
@@ -44,3 +43,4 @@ export function selectionFromLines(range: SelectedLineRange): FileSelection {
     endChar: 0,
   }
 }
+

packages/app/src/workspaces/files/view-cache.ts

@@ -1,8 +1,7 @@
 import { createEffect, createRoot } from "solid-js"
 import { produce } from "solid-js/store"
-import { Schema } from "effect"
+import { Codec } from "@/runtime/persistence/codec"
 import { Persist, persisted } from "@/runtime/persistence/storage"
-import { Persistence } from "@/runtime/persistence/schema"
 import { createScopedCache } from "@/runtime/server/scoped-cache"
 import { SelectedLineRange } from "./types"
 import type { ServerScope } from "@/runtime/server/scope"
@@ -11,14 +10,14 @@ const WORKSPACE_KEY = "__workspace__"
 const MAX_FILE_VIEW_SESSIONS = 20
 const MAX_VIEW_FILES = 500
 
-const FileViewSchema = Persistence.struct({
-  scrollTop: Persistence.optional(Schema.Finite),
-  scrollLeft: Persistence.optional(Schema.Finite),
-  selectedLines: Persistence.optional(Schema.NullOr(SelectedLineRange)),
+const FileViewSchema = Codec.struct({
+  scrollTop: Codec.lenientOptional(Codec.number),
+  scrollLeft: Codec.lenientOptional(Codec.number),
+  selectedLines: Codec.lenientOptional(Codec.nullOr(SelectedLineRange)),
 })
 
-export const FileViewsSchema = Schema.Struct({
-  file: Persistence.record(Persistence.fallback(FileViewSchema, () => ({}))),
+export const FileViewsSchema = Codec.struct({
+  file: Codec.lenientRecord(Codec.fallback(FileViewSchema, () => ({}))),
 })
 
 function normalizeSelectedLines(range: SelectedLineRange): SelectedLineRange {
@@ -150,3 +149,4 @@ export function createFileViewCache(scope: ServerScope) {
     clear: () => cache.clear(),
   }
 }
+

packages/desktop/src/main/ssh/service.ts

@@ -5,7 +5,7 @@ import { NodeChildProcessSpawner } from "@effect/platform-node"
 import { FetchHttpClient } from "effect/unstable/http"
 import { app, shell, type WebContents } from "electron"
 import { homedir } from "node:os"
-import { SshConfig, type SshState } from "@opencode/app/ssh"
+import { SshConfig, type SshState } from "@opencode/app/ssh/schema"
 import { SshChanged } from "../../shared/ipc-rpc/events"
 import { DesktopCli } from "../service/desktop-cli"
 import { Shutdown } from "../lifecycle/shutdown"
@@ -88,3 +88,4 @@ export const layer = Layer.effect(
     return service
   }),
 ).pipe(Layer.provide(NodeChildProcessSpawner.layer), Layer.provide(FetchHttpClient.layer))
+

packages/desktop/src/renderer/ssh/connections.ts

@@ -1,7 +1,6 @@
 import type { SshItem, SshPlatform, SshState } from "@opencode/app/ssh"
 import { isSshConnecting, sshHostname, sshName } from "@opencode/app/ssh"
 import { createStore } from "solid-js/store"
-import { Effect, Schedule } from "effect"
 
 // Routes key on the connection object. Preserve it across progress/endpoint
 // changes so reconnecting never unmounts an open conversation or composer.
@@ -57,14 +56,26 @@ function connection(item: SshItem, api: Pick<SshPlatform, "resolve">, label: str
       get http() {
         return state.current.http ?? { url: "http://127.0.0.1:0" }
       },
-      reconnect: (signal: AbortSignal) =>
-        Effect.runPromise(
-          Effect.tryPromise(() => api.resolve(item.config.id)).pipe(
-            Effect.repeat({ until: (http) => http !== null, schedule: Schedule.spaced(3000) }),
-            Effect.flatMap((http) => (http === null ? Effect.interrupt : Effect.succeed(http))),
-          ),
-          { signal },
-        ),
+      // Poll every 3 s until the host reports an address, or the caller aborts.
+      reconnect: async (signal: AbortSignal) => {
+        while (true) {
+          signal.throwIfAborted()
+          const http = await api.resolve(item.config.id)
+          if (http !== null) return http
+          await new Promise<void>((resolve, reject) => {
+            const timer = setTimeout(() => {
+              signal.removeEventListener("abort", abort)
+              resolve()
+            }, 3000)
+            const abort = () => {
+              clearTimeout(timer)
+              reject(signal.reason)
+            }
+            signal.addEventListener("abort", abort, { once: true })
+          })
+        }
+      },
     },
   }
 }
+

packages/desktop/src/shared/ipc-rpc/events.ts

@@ -3,7 +3,7 @@ import { Rpc, RpcGroup } from "effect/unstable/rpc"
 import { BrowserPaneEventSchema, BrowserPaneRpc } from "./browser"
 import { UpdaterStateSchema } from "./updater"
 import { WslServersEventSchema } from "./wsl"
-import { SshState } from "@opencode/app/ssh"
+import { SshState } from "@opencode/app/ssh/schema"
 
 export class SshChanged extends Schema.TaggedClass<SshChanged>()("SshChanged", { state: SshState }) {}
 
@@ -64,3 +64,4 @@ export type DesktopEvent = Schema.Schema.Type<typeof DesktopEvent>
 
 export const DesktopEvents = Rpc.make("DesktopEvents", { success: DesktopEvent, stream: true })
 export const EventRpcs = RpcGroup.make(DesktopEvents, BrowserPaneRpc)
+

packages/desktop/src/shared/ipc-rpc/ssh.ts

@@ -1,6 +1,6 @@
 import { Schema } from "effect"
 import { Rpc, RpcGroup } from "effect/unstable/rpc"
-import { SshHttp, SshStart, SshState } from "@opencode/app/ssh"
+import { SshHttp, SshStart, SshState } from "@opencode/app/ssh/schema"
 
 export const SshRpcs = RpcGroup.make(
   Rpc.make("SshGetState", { success: SshState }),
@@ -15,3 +15,4 @@ export const SshRpcs = RpcGroup.make(
   Rpc.make("SshForget", { payload: { id: Schema.String } }),
   Rpc.make("SshOpenConfig"),
 )
+