fix(cli): stop setting exit code when run cancels a form

Co-authored-by: Alireza Haghdoost <haghdoost@uber.com>
Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Co-authored-by: Aiden Cline <aidenpcline@gmail.com>

.github/workflows/publish.yml

@@ -24,6 +24,10 @@ on:
         description: "Override version (optional)"
         required: false
         type: string
+      release_notes:
+        description: "Reviewed V2 release notes for the Discord announcement (optional)"
+        required: false
+        type: string
 
 concurrency: ${{ github.workflow }}-${{ github.ref }}-${{ (github.ref_name == 'v2' && (inputs.version || inputs.bump) && 'release') || inputs.version || inputs.bump }}
 
@@ -653,3 +657,19 @@ jobs:
           OPENCODE_DESKTOP_DIST: /tmp/desktop
           CLOUDFLARE_ACCOUNT_ID: 15d29c8639fd3733b1b5486a2acfd968
           CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+
+  notify-discord-v2:
+    needs:
+      - version
+      - publish
+    if: github.repository == 'anomalyco/opencode' && github.ref_name == 'v2' && needs.version.outputs.release && needs.publish.result == 'success'
+    runs-on: blacksmith-4vcpu-ubuntu-2404
+    steps:
+      # Unlike dev, V2 publishes a tag rather than a GitHub Release event.
+      - name: Announce V2 release in Discord
+        uses: SethCohen/github-releases-to-discord@24d166886aee4646d448c8a389ff9e1ebcab3682 # v1.20.0
+        with:
+          webhook_url: ${{ secrets.DISCORD_WEBHOOK }}
+          release_name: OpenCode V2 ${{ needs.version.outputs.tag }}
+          release_body: ${{ inputs.release_notes }}
+          release_html_url: https://github.com/${{ github.repository }}/tree/${{ needs.version.outputs.tag }}

packages/ai/README.md

@@ -129,8 +129,9 @@ VercelAIGateway.configure().experimental.evaluation("typesafe-ai/jev")
 
 OpenRouter reads `OPENROUTER_API_KEY`. Vercel reads `AI_GATEWAY_API_KEY`, then `VERCEL_OIDC_TOKEN`.
 The common API uses `boolean`; System One routes lower it to native `noul`.
-Choice and score confidence plus score legends remain available in provider metadata, and the
-provider's rounded probabilities are returned unchanged.
+Choice and score answers include `confidence` when the provider returns it, such as
+`response.answers.department.confidence`. Score legends remain available in provider metadata, and
+the provider's rounded probabilities are returned unchanged.
 
 ## Alibaba Cloud Model Studio
 

packages/ai/src/experimental/evaluation.ts

@@ -63,6 +63,7 @@ export const ChoiceAnswer = Schema.Struct({
   type: Schema.Literal("choice"),
   choice: Schema.String,
   probabilities: Schema.optional(Schema.Record(Schema.String, Probability)),
+  confidence: Schema.optional(Probability),
 })
 export type ChoiceAnswer = Schema.Schema.Type<typeof ChoiceAnswer>
 
@@ -70,6 +71,7 @@ export const ScoreAnswer = Schema.Struct({
   type: Schema.Literal("score"),
   score: Schema.Number,
   probabilities: Schema.optional(Schema.Record(Schema.String, Probability)),
+  confidence: Schema.optional(Probability),
 })
 export type ScoreAnswer = Schema.Schema.Type<typeof ScoreAnswer>
 
@@ -92,6 +94,7 @@ export type AnswerFor<Question extends EvaluationQuestion> = Question extends {
       readonly type: "choice"
       readonly choice: Extract<keyof Criteria, string>
       readonly probabilities?: Readonly<Record<Extract<keyof Criteria, string>, number>>
+      readonly confidence?: number
     }
   : Question extends { readonly type: "score" }
     ? ScoreAnswer

packages/ai/src/experimental/system-one.ts

@@ -142,32 +142,37 @@ export const model = <Options extends EvaluationOptions = EvaluationOptions>(cfg
             Effect.mapError((cause) => fail("System One returned an invalid response", cause, text)),
           )
 
-          const confidence: Record<string, number> = {}
           const legend: Record<string, Record<string, Schema.Json>> = {}
           const answers = Object.fromEntries(
             Object.entries(data.answers).map(([id, answer]): [string, EvaluationAnswer] => {
               if (answer.type === "noul") return [id, { type: "boolean", probability: answer.noul }]
               if (answer.type === "choice") {
-                if (answer.confidence !== undefined) confidence[id] = answer.confidence
                 return [
                   id,
                   {
                     type: "choice",
                     choice: answer.choice,
                     probabilities: answer.probabilities,
+                    ...(answer.confidence === undefined ? {} : { confidence: answer.confidence }),
                   },
                 ]
               }
-              if (answer.confidence !== undefined) confidence[id] = answer.confidence
               if (answer.legend !== undefined) legend[id] = answer.legend
-              return [id, { type: "score", score: answer.score, probabilities: answer.probabilities }]
+              return [
+                id,
+                {
+                  type: "score",
+                  score: answer.score,
+                  probabilities: answer.probabilities,
+                  ...(answer.confidence === undefined ? {} : { confidence: answer.confidence }),
+                },
+              ]
             }),
           )
           const meta = {
             ...(data.id === undefined ? {} : { responseId: data.id }),
             ...(data.provider === undefined ? {} : { provider: data.provider }),
             ...data.provider_metadata?.[cfg.providerMetadataKey],
-            ...(Object.keys(confidence).length === 0 ? {} : { confidence }),
             ...(Object.keys(legend).length === 0 ? {} : { legend }),
           }
           return new EvaluationResponse({

packages/ai/test/evaluation.test.ts

@@ -39,17 +39,18 @@ describe("experimental Evaluation", () => {
         type: "choice",
         choice: "billing",
         probabilities: { billing: 0.9, technical: 0.1 },
+        confidence: 0.8,
       })
       expect(response.answers.urgency).toEqual({
         type: "score",
         score: 1.2,
         probabilities: { "0": 0, "1": 0.8, "2": 0.2 },
+        confidence: 0.6,
       })
       expect(response.answers.refund).toEqual({ type: "boolean", probability: 0.97 })
       expect(response.usage?.totalTokens).toBe(36)
       expect(response.providerMetadata).toEqual({
         typesafe: {
-          confidence: { department: 0.8, urgency: 0.6 },
           legend: { urgency: { "0": "Can wait", "1": "Needs attention", "2": "Blocking" } },
         },
       })

packages/ai/test/evaluation.types.ts

@@ -26,8 +26,10 @@ const request = Evaluation.request({
 const result = EvaluationClient.evaluate(request)
 type Result = Success<typeof result>
 type Choice = Assert<Equal<Result["answers"]["topic"]["choice"], "billing" | "support">>
+type Confidence = Assert<Equal<Result["answers"]["topic"]["confidence"], number | undefined>>
 type ClientRequirements = Assert<Equal<Requirements<typeof result>, Service>>
 void (true satisfies Choice)
+void (true satisfies Confidence)
 void (true satisfies ClientRequirements)
 
 Effect.gen(function* () {

packages/ai/test/provider/evaluation.recorded.test.ts

@@ -92,5 +92,6 @@ const assertEvaluation = <Options extends EvaluationOptions>(
     expect(response.answers.refund.probability).toBeGreaterThan(0.5)
     expect(response.usage?.inputTokens).toBeGreaterThan(0)
     expect(response.usage?.outputTokens).toBeGreaterThan(0)
-    expect(response.providerMetadata?.[metadataKey]?.confidence).toBeDefined()
+    expect(response.answers.department.confidence).toBeGreaterThan(0)
+    expect(response.answers.urgency.confidence).toBeGreaterThan(0)
   })

packages/cli/src/commands/commands.ts

@@ -51,7 +51,7 @@ const Root = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME
     ),
     session: Flag.string("session").pipe(
       Flag.withAlias("s"),
-      Flag.withDescription("Session ID to continue"),
+      Flag.withDescription("Session ID to continue, or to create if it does not exist"),
       Flag.optional,
     ),
     prompt: Flag.string("prompt").pipe(Flag.withDescription("Prompt to use"), Flag.optional),
@@ -328,7 +328,7 @@ const Root = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME
         ),
         session: Flag.string("session").pipe(
           Flag.withAlias("s"),
-          Flag.withDescription("Session ID to continue"),
+          Flag.withDescription("Session ID to continue, or to create if it does not exist"),
           Flag.optional,
         ),
         fork: Flag.boolean("fork").pipe(
@@ -368,7 +368,7 @@ const Root = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME
         ),
         session: Flag.string("session").pipe(
           Flag.withAlias("s"),
-          Flag.withDescription("Session ID to continue"),
+          Flag.withDescription("Session ID to continue, or to create if it does not exist"),
           Flag.optional,
         ),
         fork: Flag.boolean("fork").pipe(

packages/cli/src/commands/handlers/default.ts

@@ -11,6 +11,10 @@ import { UpdatePreflight } from "../../services/update-preflight"
 import { Npm } from "@opencode/util/npm"
 import { OPENCODE_ARTIFACT, OPENCODE_CHANNEL, OPENCODE_VERSION } from "../../version"
 import { Env } from "../../env"
+import { Service } from "@opencode/client/effect/service"
+import { OpenCode } from "@opencode/client/promise"
+import { findSession } from "../../session-target"
+import { errorMessage } from "../../util/error"
 
 export default Runtime.handler(Commands, (input) =>
   Effect.gen(function* () {
@@ -46,6 +50,15 @@ export default Runtime.handler(Commands, (input) =>
         Effect.promise(() => preflight.fail("OpenCode update could not start the new background service")),
       ),
     )
+    const session = Option.getOrUndefined(input.session)
+    // A missing --session ID becomes the ID of the session the first prompt creates.
+    const sessionExists =
+      session !== undefined &&
+      (yield* Effect.tryPromise({
+        try: () =>
+          findSession(OpenCode.make({ baseUrl: server.endpoint.url, headers: Service.headers(server.endpoint) }), session),
+        catch: (cause) => new Error(errorMessage(cause)),
+      })) !== undefined
     const updater = yield* Updater.Service
     let installing: string | undefined
     const updateListeners = new Set<(version: string) => void>()
@@ -81,7 +94,8 @@ export default Runtime.handler(Commands, (input) =>
       },
       args: {
         continue: input.continue,
-        sessionID: Option.getOrUndefined(input.session),
+        sessionID: sessionExists ? session : undefined,
+        newSessionID: sessionExists ? undefined : session,
         prompt: Option.getOrUndefined(input.prompt),
         auto: input.auto || input.yolo || input.dangerouslySkipPermissions,
       },

packages/cli/src/run/noninteractive.ts

@@ -135,6 +135,7 @@ export async function runNonInteractivePrompt(input: Input) {
   const replyPermission = async (request: { id: string; action: string; resources: ReadonlyArray<string> }) => {
     if (!input.auto) {
       permissionRejected = true
+      if (input.compatibility !== "v1") process.exitCode = 1
       UI.println(
         UI.Style.TEXT_WARNING_BOLD + "!",
         UI.Style.TEXT_NORMAL +
@@ -493,7 +494,8 @@ export async function runNonInteractivePrompt(input: Input) {
       if (event.type === "session.execution.interrupted") {
         if (input.compatibility === "v1" && (permissionRejected || formCancelled)) return
         if (event.data.reason === "user" && interrupted) process.exitCode = 130
-        if (event.data.reason !== "user" && !emittedError) {
+        // A declined tool call ends the step with an interruption; it was already reported above.
+        if (event.data.reason !== "user" && !emittedError && !permissionRejected && !formCancelled) {
           emittedError = true
           process.exitCode = 1
           const error = { type: "aborted" as const, message: `Session interrupted: ${event.data.reason}` }
@@ -620,7 +622,9 @@ export async function runNonInteractivePrompt(input: Input) {
         UI.error(item.state.error.message)
       }
 
-      if (message.error && !emittedError) {
+      // A declined tool call ends its step with an interrupted-step error that is
+      // only a consequence of our own rejection; it was already reported above.
+      if (message.error && !emittedError && !permissionRejected && !formCancelled) {
         emittedError = true
         process.exitCode = 1
         if (!emit("error", timestamp, { error: message.error })) UI.error(message.error.message)

packages/cli/src/session-target.ts

@@ -63,6 +63,7 @@ export async function resolveSessionTarget(input: {
     (await input.client.session
       .create(
         {
+          id: input.session,
           agent: prepared.agent,
           model: prepared.model,
           location: { directory: location.directory },
@@ -101,14 +102,11 @@ async function selectSession(input: {
   fork?: boolean
   signal?: AbortSignal
 }) {
-  const explicit = input.session
-    ? await input.client.session.get({ sessionID: input.session }, ...requestOptions(input.signal)).catch((error) => {
-        if (error && typeof error === "object" && "_tag" in error && error._tag === "SessionNotFoundError")
-          return undefined
-        throw error
-      })
-    : undefined
-  if (input.session && !explicit) throw new Error("Session not found")
+  const explicit = input.session ? await findSession(input.client, input.session, input.signal) : undefined
+  if (input.session && !explicit) {
+    if (input.fork) throw new Error("Session not found")
+    return { session: undefined }
+  }
   if (explicit)
     return {
       session: input.fork
@@ -133,6 +131,13 @@ async function selectSession(input: {
   }
 }
 
+export function findSession(client: OpenCodeClient, sessionID: string, signal?: AbortSignal) {
+  return client.session.get({ sessionID }, ...requestOptions(signal)).catch((error) => {
+    if (error && typeof error === "object" && "_tag" in error && error._tag === "SessionNotFoundError") return undefined
+    throw error
+  })
+}
+
 async function latestSession(
   client: OpenCodeClient,
   location: LocationGetOutput,

packages/cli/test/session-target.test.ts

@@ -42,6 +42,28 @@ describe("session target resolver", () => {
     })
   })
 
+  test("creates a missing explicit Session with its ID", async () => {
+    const client = OpenCode.make({ baseUrl: "https://opencode.test" })
+    spyOn(client.session, "get").mockRejectedValue({ _tag: "SessionNotFoundError" })
+    spyOn(client.location, "get").mockResolvedValue(location("/project"))
+    const create = spyOn(client.session, "create").mockResolvedValue(session("ses_chosen", "/project"))
+
+    const target = await resolveSessionTarget({ client, session: "ses_chosen", prepare })
+    expect(create).toHaveBeenCalledWith(expect.objectContaining({ id: "ses_chosen" }))
+    expect(target).toMatchObject({ session: { id: "ses_chosen" }, resume: false })
+  })
+
+  test("does not create a missing explicit Session to fork", async () => {
+    const client = OpenCode.make({ baseUrl: "https://opencode.test" })
+    spyOn(client.session, "get").mockRejectedValue({ _tag: "SessionNotFoundError" })
+    const create = spyOn(client.session, "create")
+
+    await expect(resolveSessionTarget({ client, session: "ses_chosen", fork: true, prepare })).rejects.toThrow(
+      "Session not found",
+    )
+    expect(create).not.toHaveBeenCalled()
+  })
+
   test("paginates to continue the exact directory", async () => {
     const client = OpenCode.make({ baseUrl: "https://opencode.test" })
     spyOn(client.location, "get").mockResolvedValue(location("/project"))

packages/core/src/config/normalize.ts

@@ -10,7 +10,6 @@ import { ConfigCompaction } from "@opencode/schema/config/compaction"
 import { ConfigFormatter } from "@opencode/schema/config/formatter"
 import { ConfigLSP } from "@opencode/schema/config/lsp"
 import { ConfigMedia } from "@opencode/schema/config/media"
-import { ConfigModel } from "@opencode/schema/config/model"
 import { ConfigMCP } from "@opencode/schema/config/mcp"
 import { ConfigPlugin } from "@opencode/schema/config/plugin"
 import { ConfigPolicy } from "@opencode/schema/config/policy"
@@ -19,11 +18,13 @@ import { ConfigReference } from "@opencode/schema/config/reference"
 import { ConfigExperimental } from "@opencode/schema/config/experimental"
 import { Permission } from "@opencode/schema/permission"
 import { ConfigAgentV1 } from "../v1/config/agent.js"
+import { ConfigAttachmentV1 } from "../v1/config/attachment.js"
 import { ConfigCommandV1 } from "../v1/config/command.js"
 import { ConfigMCPV1 } from "../v1/config/mcp.js"
 import { ConfigPermissionV1 } from "../v1/config/permission.js"
 import { ConfigPluginV1 } from "../v1/config/plugin.js"
 import { ConfigProviderV1 } from "../v1/config/provider.js"
+import { ConfigV1 } from "../v1/config/config.js"
 import { ConfigMigrateV1 } from "../v1/config/migrate.js"
 import { PositiveInt } from "../schema.js"
 
@@ -52,7 +53,6 @@ const unsupportedExperimental = [
 ] as const
 const unsupportedProvider = ["id", "whitelist", "blacklist"] as const
 const unsupportedModel = ["release_date", "attachment", "reasoning", "temperature", "experimental"] as const
-const LegacyAutoupdate = Schema.Literals([true, false, "notify"])
 
 export function normalize(input: unknown): Result {
   if (!isRecord(input))
@@ -71,7 +71,7 @@ export function normalize(input: unknown): Result {
     ? decodeEncoded(Schema.Boolean, input.snapshot, ["snapshot"], diagnostics)
     : undefined
   const legacyUpdate = own(input, "autoupdate")
-    ? decodeValue(LegacyAutoupdate, input.autoupdate, ["autoupdate"], diagnostics)
+    ? decodeValue(ConfigV1.Info.fields.autoupdate, input.autoupdate, ["autoupdate"], diagnostics)
     : undefined
   const nativeUpdate = own(input, "update")
     ? decodeEncoded(Info.fields.update, input.update, ["update"], diagnostics)
@@ -82,18 +82,15 @@ export function normalize(input: unknown): Result {
       : undefined
     : undefined
   const legacyMedia = own(input, "attachment")
-    ? decodeEncoded(ConfigMedia.Info, input.attachment, ["attachment"], diagnostics)
+    ? decodeValue(ConfigAttachmentV1.Info, input.attachment, ["attachment"], diagnostics)
     : undefined
-  if (legacyMedia !== undefined) encoded.media = legacyMedia
+  if (legacyMedia !== undefined) {
+    const migrated = ConfigMigrateV1.migrate({ attachment: legacyMedia }).media
+    if (migrated !== undefined) encoded.media = canonical(ConfigMedia.Info, migrated)
+  }
   if (legacySnapshots !== undefined) encoded.snapshots = legacySnapshots
   const migratedUpdate =
-    legacyUpdate === false
-      ? "disable"
-      : legacyUpdate === "notify"
-        ? "notify"
-        : legacyUpdate === true
-          ? "auto"
-          : undefined
+    legacyUpdate === undefined ? undefined : ConfigMigrateV1.migrate({ autoupdate: legacyUpdate }).update
   const update = prefer(migratedUpdate, nativeUpdate, ["update"], diagnostics)
   if (update !== undefined) encoded.update = update
   if (legacyShare !== undefined) encoded.share = legacyShare
@@ -138,7 +135,9 @@ export function normalize(input: unknown): Result {
   const legacySmallModel = own(input, "small_model")
     ? decodeValue(Schema.String, input.small_model, ["small_model"], diagnostics)
     : undefined
-  const migratedSmallModel = ConfigMigrateV1.modelSelection(legacySmallModel)
+  const migratedSmallModel = legacySmallModel
+    ? ConfigMigrateV1.migrate({ small_model: legacySmallModel }).agents?.title?.model
+    : undefined
   if (legacySmallModel && !migratedSmallModel)
     diagnostics.push({
       kind: "unsupported",
@@ -198,14 +197,10 @@ export function normalize(input: unknown): Result {
   normalizeFormatter(input, encoded, diagnostics)
   normalizeLsp(input, encoded, diagnostics)
 
-  const model = own(input, "model")
-    ? decodeValue(ConfigModel.Selection, input.model, ["model"], diagnostics)
-    : undefined
-  if (model) encoded.model = { ...model, providerID: ConfigMigrateV1.providerID(model.providerID) }
-
   const nativeAtomic = {
     $schema: Info.fields.$schema,
     shell: Info.fields.shell,
+    model: Info.fields.model,
     default_agent: Info.fields.default_agent,
     share: Info.fields.share,
     enterprise: Info.fields.enterprise,

packages/core/src/generate.ts

@@ -1,6 +1,7 @@
 export * as Generate from "./generate.js"
 
 import { LLM, LLMClient, AIError } from "@opencode/ai"
+import { SessionID } from "@opencode/schema/session-id"
 import { Context, Effect, Layer, Schema } from "effect"
 import { makeLocationNode } from "@opencode/util/effect/app-node"
 import { llmClient } from "./effect/app-node-platform.js"
@@ -60,15 +61,24 @@ export const layer = Layer.effect(
             ? `Model unavailable: ${input.model.providerID}/${input.model.id}`
             : "No model specified and no supported model is available",
         })
-      const response = yield* llm.generate(LLM.request({ model: resolved.model, prompt: input.prompt })).pipe(
-        Effect.mapError(
-          (error: AIError) =>
-            new UnavailableError({
-              message: error.message,
-              service: resolved.ref.providerID,
-            }),
-        ),
-      )
+      const response = yield* llm
+        .generate(
+          LLM.request({
+            model: resolved.model,
+            prompt: input.prompt,
+            // Gateways require session attribution even for a stateless call; no Session is stored.
+            http: { headers: { "x-opencode-session": SessionID.create() } },
+          }),
+        )
+        .pipe(
+          Effect.mapError(
+            (error: AIError) =>
+              new UnavailableError({
+                message: error.message,
+                service: resolved.ref.providerID,
+              }),
+          ),
+        )
       return response.text
     })
 

packages/core/src/session/model-request.ts

@@ -273,12 +273,12 @@ export const layer = Layer.effect(
         model: model.model,
         http: {
           headers: {
-            "x-session-affinity": session.id,
-            "X-Session-Id": session.id,
+            "x-session-affinity": affinity,
+            "X-Session-Id": affinity,
             ...(session.parentID ? { "x-parent-session-id": session.parentID } : {}),
             "User-Agent": App.useragent(app),
             "x-opencode-project": session.projectID,
-            "x-opencode-session": session.id,
+            "x-opencode-session": affinity,
             "x-opencode-client": app.name,
           },
         },

packages/core/src/v1/config/attachment.ts

@@ -1,7 +1,7 @@
-export * as ConfigAttachmentV1 from "./attachment"
+export * as ConfigAttachmentV1 from "./attachment.js"
 
 import { Schema } from "effect"
-import { PositiveInt } from "@opencode/core/schema"
+import { PositiveInt } from "../../schema.js"
 
 export const Image = Schema.Struct({
   auto_resize: Schema.optional(Schema.Boolean).annotate({

packages/core/src/v1/config/config.ts

@@ -1,20 +1,27 @@
-export * as ConfigV1 from "./config"
+export * as ConfigV1 from "./config.js"
 
 import { Schema } from "effect"
 import { ConfigReference } from "@opencode/schema/config/reference"
-import { NonNegativeInt, PositiveInt } from "@opencode/core/schema"
-import { ConfigAgentV1 } from "@opencode/core/v1/config/agent"
-import { ConfigAttachmentV1 } from "./attachment"
-import { ConfigCommandV1 } from "@opencode/core/v1/config/command"
-import { ConfigFormatterV1 } from "./formatter"
-import { ConfigLayoutV1 } from "./layout"
-import { ConfigLSPV1 } from "./lsp"
-import { ConfigMCPV1 } from "@opencode/core/v1/config/mcp"
-import { ConfigPermissionV1 } from "@opencode/core/v1/config/permission"
-import { ConfigPluginV1 } from "@opencode/core/v1/config/plugin"
-import { ConfigProviderV1 } from "@opencode/core/v1/config/provider"
-import { ConfigServerV1 } from "./server"
-import { ConfigSkillsV1 } from "./skills"
+import { NonNegativeInt, PositiveInt, type DeepMutable } from "../../schema.js"
+import { ConfigAgentV1 } from "./agent.js"
+import { ConfigAttachmentV1 } from "./attachment.js"
+import { ConfigCommandV1 } from "./command.js"
+import { ConfigFormatterV1 } from "./formatter.js"
+import { ConfigLayoutV1 } from "./layout.js"
+import { ConfigLSPV1 } from "./lsp.js"
+import { ConfigMCPV1 } from "./mcp.js"
+import { ConfigPermissionV1 } from "./permission.js"
+import { ConfigPluginV1 } from "./plugin.js"
+import { ConfigProviderV1 } from "./provider.js"
+import { ConfigServerV1 } from "./server.js"
+import { ConfigSkillsV1 } from "./skills.js"
+
+export type Layout = ConfigLayoutV1.Layout
+
+export const WellKnown = Schema.Struct({
+  config: Schema.optional(Schema.Json),
+  remote_config: Schema.optional(Schema.Json),
+})
 
 const LogLevelRef = Schema.Literals(["DEBUG", "INFO", "WARN", "ERROR"]).annotate({
   identifier: "LogLevel",
@@ -180,3 +187,5 @@ export const Info = Schema.Struct({
     }),
   ),
 }).annotate({ identifier: "Config" })
+
+export type Info = DeepMutable<Schema.Schema.Type<typeof Info>>

packages/core/src/v1/config/formatter.ts

@@ -1,4 +1,4 @@
-export * as ConfigFormatterV1 from "./formatter"
+export * as ConfigFormatterV1 from "./formatter.js"
 
 import { Schema } from "effect"
 

packages/core/src/v1/config/layout.ts

@@ -1,4 +1,4 @@
-export * as ConfigLayoutV1 from "./layout"
+export * as ConfigLayoutV1 from "./layout.js"
 
 import { Schema } from "effect"
 

packages/core/src/v1/config/lsp.ts

@@ -1,4 +1,4 @@
-export * as ConfigLSPV1 from "./lsp"
+export * as ConfigLSPV1 from "./lsp.js"
 
 import { Schema } from "effect"
 

packages/core/src/v1/config/migrate.ts

@@ -1,7 +1,9 @@
 export * as ConfigMigrateV1 from "./migrate.js"
 
+import { Info } from "@opencode/schema/config"
 import { ConfigAgent } from "@opencode/schema/config/agent"
 import { Schema } from "effect"
+import { ConfigV1 } from "./config.js"
 import { ConfigAgentV1 } from "./agent.js"
 import { ConfigCommandV1 } from "./command.js"
 import { ConfigMCPV1 } from "./mcp.js"
@@ -12,16 +14,102 @@ import { Provider } from "../../provider.js"
 import { Model } from "../../model.js"
 
 const decodeOptions = { errors: "all", onExcessProperty: "ignore", propertyOrder: "original" } as const
+const decodeInfo = Schema.decodeUnknownSync(Schema.fromJsonString(Info), decodeOptions)
+const encodeInfo = Schema.encodeSync(Info)
 const decodeAgent = Schema.decodeUnknownSync(Schema.fromJsonString(ConfigAgent.Info), decodeOptions)
 const encodeAgent = Schema.encodeSync(ConfigAgent.Info)
+export function migrate(info: typeof ConfigV1.Info.Type) {
+  return encodeInfo(
+    decodeInfo(
+      JSON.stringify({
+        $schema: info.$schema,
+        shell: info.shell,
+        model: modelSelection(info.model),
+        default_agent: info.default_agent,
+        update:
+          info.autoupdate === false
+            ? "disable"
+            : info.autoupdate === "notify"
+              ? "notify"
+              : info.autoupdate === true
+                ? "auto"
+                : undefined,
+        share: info.share ?? (info.autoshare ? "auto" : undefined),
+        enterprise: info.enterprise,
+        username: info.username,
+        permissions: permissions(info.permission, info.tools),
+        agents: agents(info),
+        snapshots: info.snapshot,
+        watcher: info.watcher,
+        formatter: info.formatter,
+        lsp: info.lsp,
+        media: info.attachment,
+        tool_output: info.tool_output,
+        mcp: mcp(info),
+        compaction: info.compaction && {
+          auto: info.compaction.auto,
+          prune: info.compaction.prune,
+          keep: {
+            tokens: info.compaction.preserve_recent_tokens,
+          },
+          buffer: info.compaction.reserved,
+        },
+        skills: info.skills && [...(info.skills.paths ?? []), ...(info.skills.urls ?? [])],
+        commands: commands(info.command),
+        instructions: info.instructions,
+        references: info.references ?? info.reference,
+        experimental: experimental(info),
+        plugins: info.plugin?.map((plugin) =>
+          typeof plugin === "string" ? plugin : { package: plugin[0], options: plugin[1] },
+        ),
+        providers: providers(info.provider),
+      }),
+    ),
+  )
+}
 
-function permissions(info?: ConfigPermissionV1.Info) {
-  const rules = Object.entries(info ?? {}).flatMap(([key, rule]) => {
-    if (!rule) return []
+function experimental(info: typeof ConfigV1.Info.Type) {
+  const policies = [
+    ...(info.enabled_providers === undefined
+      ? []
+      : [
+          { action: "provider.use" as const, resource: "*", effect: "deny" as const },
+          ...info.enabled_providers.map((resource) => ({
+            action: "provider.use" as const,
+            resource: providerID(resource),
+            effect: "allow" as const,
+          })),
+        ]),
+    ...(info.disabled_providers ?? []).map((resource) => ({
+      action: "provider.use" as const,
+      resource: providerID(resource),
+      effect: "deny" as const,
+    })),
+  ]
+  if (info.experimental?.subagent_depth === undefined && !policies.length) return
+  return {
+    subagent_depth: info.experimental?.subagent_depth,
+    policies: policies.length ? policies : undefined,
+  }
+}
+
+function permissions(info?: ConfigPermissionV1.Info, tools?: Readonly<Record<string, boolean>>) {
+  const rules: Array<{ action: string; resource: string; effect: ConfigPermissionV1.Action }> = Object.entries(
+    tools ?? {},
+  ).map(([action, enabled]) => ({
+    action: normalizeAction(action),
+    resource: "*",
+    effect: enabled ? ("allow" as const) : ("deny" as const),
+  }))
+  for (const [key, rule] of Object.entries(info ?? {})) {
+    if (!rule) continue
     const action = normalizeAction(key)
-    if (typeof rule === "string") return [{ action, resource: "*", effect: rule }]
-    return Object.entries(rule).map(([resource, effect]) => ({ action, resource, effect }))
-  })
+    if (typeof rule === "string") {
+      rules.push({ action, resource: "*", effect: rule })
+      continue
+    }
+    rules.push(...Object.entries(rule).map(([resource, effect]) => ({ action, resource, effect })))
+  }
   return rules.length ? rules : undefined
 }
 
@@ -33,6 +121,23 @@ export function normalizeAction(action: string) {
   return action
 }
 
+function agents(info: typeof ConfigV1.Info.Type) {
+  const entries = [
+    ...Object.entries(info.agent ?? {}),
+    ...Object.entries(info.mode ?? {}).map(([name, agent]) => [name, { ...agent, mode: "primary" as const }] as const),
+  ]
+  const result = Object.fromEntries(entries.flatMap(([name, agent]) => (agent ? [[name, migrateAgent(agent)]] : [])))
+  const small = modelSelection(info.small_model)
+  if (!small) return entries.length ? result : undefined
+  return {
+    ...result,
+    title: {
+      model: small,
+      ...result.title,
+    },
+  }
+}
+
 export function migrateAgent(info: ConfigAgentV1.Info) {
   const body = {
     ...info.options,
@@ -73,7 +178,7 @@ export function commands(info?: Readonly<Record<string, ConfigCommandV1.Info>>)
   )
 }
 
-export function modelSelection(input?: string, variant?: string) {
+function modelSelection(input?: string, variant?: string) {
   if (input === undefined || !/^[^/#]+\/[^#]+$/.test(input)) return undefined
   const separator = input.indexOf("/")
   return {
@@ -83,6 +188,17 @@ export function modelSelection(input?: string, variant?: string) {
   }
 }
 
+function mcp(info: typeof ConfigV1.Info.Type) {
+  const servers = Object.fromEntries(
+    Object.entries(info.mcp ?? {}).flatMap(([name, server]) =>
+      "type" in server ? [[name, migrateMcp(server)] as const] : [],
+    ),
+  )
+  const timeout = info.experimental?.mcp_timeout
+  if (!timeout && !Object.keys(servers).length) return undefined
+  return { timeout: timeout === undefined ? undefined : { catalog: timeout, execution: timeout }, servers }
+}
+
 export function migrateMcp(info: ConfigMCPV1.Info) {
   const disabled = info.enabled === undefined ? undefined : !info.enabled
   if (info.type === "local")
@@ -110,6 +226,18 @@ export function migrateMcp(info: ConfigMCPV1.Info) {
   }
 }
 
+function providers(info?: Readonly<Record<string, ConfigProviderV1.Info>>) {
+  if (!info) return undefined
+  return Object.fromEntries(
+    Object.entries(info).flatMap(([name, provider]) => {
+      const id = providerID(name)
+      // If both names are present, keep the settings under the current name and ignore the old one.
+      if (id !== name && info[id]) return []
+      return [[id, migrateProvider(name, provider)]]
+    }),
+  )
+}
+
 export function migrateProvider(sourceID: string, info: ConfigProviderV1.Info) {
   if (sourceID === "azure-cognitive-services") return migrateAzureCognitiveServicesProvider(info)
   if (sourceID === "google-vertex-anthropic") return migrateGoogleVertexAnthropicProvider(info)

packages/core/src/v1/config/server.ts

@@ -1,7 +1,7 @@
-export * as ConfigServerV1 from "./server"
+export * as ConfigServerV1 from "./server.js"
 
 import { Schema } from "effect"
-import { PositiveInt } from "@opencode/core/schema"
+import { PositiveInt } from "../../schema.js"
 
 export const Server = Schema.Struct({
   port: Schema.optional(PositiveInt).annotate({

packages/core/src/v1/config/skills.ts

@@ -1,4 +1,4 @@
-export * as ConfigSkillsV1 from "./skills"
+export * as ConfigSkillsV1 from "./skills.js"
 
 import { Schema } from "effect"
 

packages/core/test/config/agent.test.ts

@@ -15,7 +15,7 @@ import { Global } from "@opencode/util/global"
 import { Permission } from "@opencode/core/permission"
 import { AgentPlugin } from "@opencode/core/plugin/agent"
 import { AbsolutePath } from "@opencode/core/schema"
-import { ConfigNormalize } from "@opencode/core/config/normalize"
+import { ConfigMigrateV1 } from "@opencode/core/v1/config/migrate"
 import { ConfigAgentV1 } from "@opencode/core/v1/config/agent"
 import { advance, drain } from "../lib/clock"
 import { tmpdir, tmpdirScoped } from "../fixture/tmpdir"
@@ -24,12 +24,6 @@ import { agentHost, host } from "../plugin/host"
 
 const it = testEffect(AppNodeBuilder.build(LayerNode.group([Agent.node, Bus.node, FSUtil.node, Global.node])))
 const decode = Schema.decodeUnknownSync(Info)
-
-function migrateV1(input: unknown) {
-  const result = ConfigNormalize.normalize(input)
-  if (result.type !== "normalized") throw new Error("expected normalized config")
-  return result.encoded
-}
 const defaultPermissions = (global: Global.Interface): Permission.Ruleset => [
   ...Agent.Info.default(Agent.ID.make("test")).permissions,
   { action: "external_directory", resource: path.join(global.data, "shell", "*", "*"), effect: "allow" },
@@ -177,7 +171,7 @@ permissions:
         new Document({
           type: "document",
           info: decode(
-            migrateV1({
+            ConfigMigrateV1.migrate({
               permission: {
                 bash: "ask",
                 edit: "ask",
@@ -758,7 +752,7 @@ function loadHomePermissions(home: string) {
       new Document({
         type: "document",
         info: decode(
-          migrateV1({
+          ConfigMigrateV1.migrate({
             permission: {
               external_directory: {
                 "~/p/**": "allow",

packages/core/test/config/config.test.ts

@@ -11,7 +11,8 @@ import { AppNodeBuilder } from "@opencode/core/effect/app-node-builder"
 import { makeGlobalNode } from "@opencode/util/effect/app-node"
 import { LayerNode } from "@opencode/util/effect/layer-node"
 import { Credential } from "@opencode/core/credential"
-import { ConfigV1 } from "../fixture/v1-config/config"
+import { ConfigMigrateV1 } from "@opencode/core/v1/config/migrate"
+import { ConfigV1 } from "@opencode/core/v1/config/config"
 import { ConfigNormalize } from "@opencode/core/config/normalize"
 import { Watcher } from "@opencode/core/filesystem/watcher"
 import { Bus } from "@opencode/core/bus"
@@ -29,18 +30,6 @@ import { testEffect } from "../lib/effect"
 
 const it = testEffect(Layer.empty)
 const selection = Schema.decodeUnknownSync(ConfigModel.Selection)
-const decodeInfo = Schema.decodeUnknownSync(Info, {
-  errors: "all",
-  onExcessProperty: "ignore",
-  propertyOrder: "original",
-})
-const encodeInfo = Schema.encodeSync(Info)
-
-function migrateV1(input: unknown) {
-  const result = ConfigNormalize.normalize(input)
-  if (result.type !== "normalized") throw new Error("expected normalized config")
-  return encodeInfo(decodeInfo(result.encoded))
-}
 
 function inFixture(root: string, target: string) {
   const relative = path.relative(root, target)
@@ -645,19 +634,24 @@ describe("Config", () => {
   test("migrates arbitrary v1 configuration into valid v2 configuration", () => {
     FastCheck.assert(
       FastCheck.property(Schema.toArbitrary(ConfigV1.Info)(FastCheck), (info) => {
-        migrateV1(JSON.parse(JSON.stringify(info)))
+        const parsed = Schema.decodeUnknownSync(ConfigV1.Info)(
+          Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown))(
+            Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unknown))(info),
+          ),
+        )
+        Schema.decodeUnknownSync(Info)(ConfigMigrateV1.migrate(parsed), { errors: "all" })
       }),
       { numRuns: 100 },
     )
   }, 30_000)
 
   test("migrates the v1 experimental subagent depth", () => {
-    expect(migrateV1({ experimental: { subagent_depth: 2 } }).experimental?.subagent_depth).toBe(2)
+    expect(ConfigMigrateV1.migrate({ experimental: { subagent_depth: 2 } }).experimental?.subagent_depth).toBe(2)
   })
 
   test("migrates the v1 small model to the title agent", () => {
     expect(
-      migrateV1({
+      ConfigMigrateV1.migrate({
         small_model: "anthropic/claude-haiku-4-5",
         agent: { title: { prompt: "Custom title prompt" } },
       }).agents?.title,
@@ -668,10 +662,10 @@ describe("Config", () => {
   })
 
   test("migrates the v1 update policy", () => {
-    expect(migrateV1({ autoupdate: false }).update).toBe("disable")
-    expect(migrateV1({ autoupdate: "notify" }).update).toBe("notify")
-    expect(migrateV1({ autoupdate: true }).update).toBe("auto")
-    expect(migrateV1({}).update).toBeUndefined()
+    expect(ConfigMigrateV1.migrate({ autoupdate: false }).update).toBe("disable")
+    expect(ConfigMigrateV1.migrate({ autoupdate: "notify" }).update).toBe("notify")
+    expect(ConfigMigrateV1.migrate({ autoupdate: true }).update).toBe("auto")
+    expect(ConfigMigrateV1.migrate({}).update).toBeUndefined()
   })
 
   test("normalizes the native auto update policy", () => {
@@ -684,7 +678,7 @@ describe("Config", () => {
 
   test("migrates v1 provider lists to policies", () => {
     expect(
-      migrateV1({
+      ConfigMigrateV1.migrate({
         enabled_providers: ["anthropic", "openai"],
         disabled_providers: ["openai"],
       }).experimental?.policies,
@@ -694,13 +688,13 @@ describe("Config", () => {
       { action: "provider.use", resource: "openai", effect: "allow" },
       { action: "provider.use", resource: "openai", effect: "deny" },
     ])
-    expect(migrateV1({ enabled_providers: [] }).experimental?.policies).toEqual([
+    expect(ConfigMigrateV1.migrate({ enabled_providers: [] }).experimental?.policies).toEqual([
       { action: "provider.use", resource: "*", effect: "deny" },
     ])
   })
 
   test("migrates v1 provider setup options into AISDK settings", () => {
-    const migrated = migrateV1({
+    const migrated = ConfigMigrateV1.migrate({
       provider: {
         bedrock: {
           npm: "@ai-sdk/amazon-bedrock",
@@ -725,7 +719,7 @@ describe("Config", () => {
   })
 
   test("renames old provider IDs while migrating v1 configuration", () => {
-    const migrated = migrateV1({
+    const migrated = ConfigMigrateV1.migrate({
       model: "azure-cognitive-services/deployment",
       enabled_providers: ["google-vertex-anthropic"],
       disabled_providers: ["azure-cognitive-services"],
@@ -774,7 +768,7 @@ describe("Config", () => {
   })
 
   test("preserves the generated base URL for v1 Azure OpenAI-compatible providers", () => {
-    const migrated = migrateV1({
+    const migrated = ConfigMigrateV1.migrate({
       provider: {
         "azure-cognitive-services": {
           npm: "@ai-sdk/openai-compatible",
@@ -793,7 +787,7 @@ describe("Config", () => {
   })
 
   test("ignores old provider IDs when the current provider ID is configured", () => {
-    const migrated = migrateV1({
+    const migrated = ConfigMigrateV1.migrate({
       provider: {
         azure: { models: { current: {} } },
         "azure-cognitive-services": { models: { legacy: {} } },
@@ -807,7 +801,7 @@ describe("Config", () => {
   })
 
   test("preserves the built-in package for v1 Vertex Anthropic custom models", () => {
-    const migrated = migrateV1({
+    const migrated = ConfigMigrateV1.migrate({
       provider: {
         "google-vertex-anthropic": {
           models: { claude: {} },
@@ -822,7 +816,7 @@ describe("Config", () => {
   })
 
   test("migrates v1 interleaved fields to compatibility", () => {
-    const migrated = migrateV1({
+    const migrated = ConfigMigrateV1.migrate({
       provider: {
         custom: {
           models: {
@@ -844,7 +838,7 @@ describe("Config", () => {
   for (const subtask of [true, false]) {
     test(`migrates v1 command configuration with subtask: ${subtask}`, () => {
       expect(
-        migrateV1({
+        ConfigMigrateV1.migrate({
           command: {
             review: {
               template: "Review changes",
@@ -870,7 +864,7 @@ describe("Config", () => {
 
   test("normalizes renamed permission actions when migrating v1 permissions", () => {
     expect(
-      migrateV1({
+      ConfigMigrateV1.migrate({
         permission: {
           task: "ask",
           bash: { "git status": "allow", "*": "deny" },

packages/core/test/config/normalization.test.ts

@@ -149,21 +149,6 @@ describe("ConfigNormalize", () => {
     expect(() => Schema.decodeUnknownSync(Info)(result.encoded)).not.toThrow()
   })
 
-  test("renames legacy provider IDs in the top-level model", () => {
-    expect(normalized({ model: "google-vertex-anthropic/claude#high" }).encoded.model).toEqual({
-      providerID: "google-vertex",
-      model: "claude",
-      variant: "high",
-    })
-    expect(
-      normalized({ model: { providerID: "azure-cognitive-services", model: "deployment" } }).encoded.model,
-    ).toEqual({ providerID: "azure", model: "deployment" })
-    expect(normalized({ model: "anthropic/claude" }).encoded.model).toEqual({
-      providerID: "anthropic",
-      model: "claude",
-    })
-  })
-
   test("migrates the legacy small model to the title agent", () => {
     const result = normalized({ small_model: "anthropic/claude-haiku-4-5" })
     expect(result.encoded.agents).toEqual({

packages/core/test/generate.test.ts

@@ -1,5 +1,6 @@
 import { expect } from "bun:test"
-import { LanguageModel } from "@opencode/ai"
+import { LanguageModel, LLMClient } from "@opencode/ai"
+import { RequestExecutor } from "@opencode/ai/route"
 import { OpenAIChat } from "@opencode/ai/protocols"
 import { TestLLM } from "@opencode/ai/testing"
 import { AISDK } from "@opencode/core/aisdk"
@@ -10,6 +11,7 @@ import { ID, Info, Model, Ref } from "@opencode/core/model"
 import { Provider } from "@opencode/core/provider"
 import { Npm } from "@opencode/util/npm"
 import { Effect, Layer } from "effect"
+import { HttpClient, HttpClientResponse } from "effect/unstable/http"
 import { testEffect } from "./lib/effect"
 
 const selected = Info.make({
@@ -89,3 +91,56 @@ resolverIt.effect("resolves dynamic models with their catalog metadata", () =>
     })
   }),
 )
+
+testEffect(Layer.empty).effect("attributes each stateless completion without creating a stored session", () =>
+  Effect.gen(function* () {
+    const sessions: string[] = []
+    const http = Layer.succeed(
+      HttpClient.HttpClient,
+      HttpClient.make((request) =>
+        Effect.sync(() => {
+          const session = request.headers["x-opencode-session"]
+          if (!session)
+            return HttpClientResponse.fromWeb(
+              request,
+              Response.json(
+                {
+                  error: { type: "MissingSessionID", message: "Session ID is required" },
+                },
+                { status: 400 },
+              ),
+            )
+          sessions.push(session)
+          return HttpClientResponse.fromWeb(
+            request,
+            new Response(
+              `data: ${JSON.stringify({
+                id: "completion",
+                object: "chat.completion.chunk",
+                created: 1,
+                model: "gemini",
+                choices: [{ index: 0, delta: { content: "OK" }, finish_reason: "stop" }],
+              })}\n\ndata: [DONE]\n\n`,
+              { headers: { "content-type": "text/event-stream" } },
+            ),
+          )
+        }),
+      ),
+    )
+    const native = LLMClient.layer.pipe(Layer.provide(RequestExecutor.layer.pipe(Layer.provide(http))))
+    yield* Effect.gen(function* () {
+      const generate = yield* Generate.Service
+      for (let index = 0; index < 2; index++) {
+        expect(
+          yield* generate.text({
+            prompt: "Return exactly OK",
+            model: Ref.make({ providerID: selected.providerID, id: selected.id }),
+          }),
+        ).toBe("OK")
+      }
+    }).pipe(Effect.provide(Generate.layer.pipe(Layer.provide(Layer.merge(resolver, native)))))
+    expect(sessions).toHaveLength(2)
+    expect(sessions[0]).toStartWith("ses_")
+    expect(sessions[1]).not.toBe(sessions[0])
+  }),
+)

packages/core/test/session-compaction.test.ts

@@ -445,12 +445,12 @@ it.effect("manual compaction summarizes short context instead of no-op", () =>
     expect(requests).toHaveLength(1)
     expect(requests[0]?.promptCacheKey).toBe(parentID)
     expect(requests[0]?.http?.headers).toEqual({
-      "x-session-affinity": sessionID,
-      "X-Session-Id": sessionID,
+      "x-session-affinity": parentID,
+      "X-Session-Id": parentID,
       "x-parent-session-id": parentID,
       "User-Agent": App.useragent(App.make()),
       "x-opencode-project": Project.ID.global,
-      "x-opencode-session": sessionID,
+      "x-opencode-session": parentID,
       "x-opencode-client": "opencode",
     })
     expect(requests[0]?.generation).toEqual(GenerationOptions.make({ maxTokens: 20_000 }))

packages/core/test/session-runner.test.ts

@@ -4693,7 +4693,12 @@ describe("SessionRunnerLLM", () => {
       .pipe(Effect.orDie)
     yield* s.runPrompt("Run child request")
 
-    expect(s.requests[0]?.http?.headers?.["x-parent-session-id"]).toBe(parentID)
+    expect(s.requests[0]?.http?.headers).toMatchObject({
+      "x-session-affinity": parentID,
+      "X-Session-Id": parentID,
+      "x-parent-session-id": parentID,
+      "x-opencode-session": parentID,
+    })
     expect(s.requests[0]?.promptCacheKey).toBe(parentID)
   })
 

packages/tui/src/component/dialog-open.tsx

@@ -208,6 +208,8 @@ export function DialogOpen(props: { sessions: SessionInfo[]; onLoad: (sessions:
     const projectOptions = data.project
       .list()
       .filter((project) => project.canonical !== "/")
+      // Historical project identities can share a checkout. The list is newest-active first.
+      .filter((project, index, projects) => projects.findIndex((item) => item.canonical === project.canonical) === index)
       .map((project) => ({ directory: project.canonical, project }))
       .map((item) => {
         const title =

packages/tui/src/component/prompt/index.tsx

@@ -53,6 +53,7 @@ import { usePromptMove } from "./move"
 import { resolvePastedAttachments } from "./local-attachment"
 import { locationKey, useData } from "../../context/data"
 import { useLocation } from "../../context/location"
+import { useArgs } from "../../context/args"
 import { Keymap, type KeymapCommand } from "../../context/keymap"
 import { useInteractivity } from "../../context/interactivity"
 import { abbreviateHome } from "../../runtime"
@@ -206,6 +207,7 @@ export function Prompt(props: PromptProps) {
   const directoryRecents = useDirectoryRecents()
   const keymapCommands = Keymap.useCommands()
   const currentLocation = useLocation()
+  const args = useArgs()
   const config = useConfig().data
   const dialog = useDialog()
   const toast = useToast()
@@ -1229,7 +1231,9 @@ export function Prompt(props: PromptProps) {
       // a local session record synchronously, so the navigation below happens
       // immediately — enter feels sent even while the create round-trip is in
       // flight. Sends against the new session gate on the request.
+      const newSessionID = args.takeNewSessionID()
       const created = data.session.create({
+        id: newSessionID,
         location: directory ? { directory } : location,
         agent: agent.id,
         model: {
@@ -1238,6 +1242,7 @@ export function Prompt(props: PromptProps) {
           variant,
         },
       })
+      if (newSessionID !== undefined) created.request.catch(() => args.restoreNewSessionID(newSessionID))
       sessionID = created.id
       session = data.session.get(created.id)
       newSession = {

packages/tui/src/context/args.tsx

@@ -1,3 +1,4 @@
+import { mergeProps } from "solid-js"
 import { createSimpleContext } from "./helper"
 
 export interface Args {
@@ -6,11 +7,25 @@ export interface Args {
   prompt?: string
   continue?: boolean
   sessionID?: string
+  newSessionID?: string
   fork?: boolean
   auto?: boolean
 }
 
 export const { use: useArgs, provider: ArgsProvider } = createSimpleContext({
   name: "Args",
-  init: (props: Args) => props,
+  init: (props: Args) => {
+    // The first new session created from home takes this ID; later ones mint their own.
+    let pending = props.newSessionID
+    return mergeProps(props, {
+      takeNewSessionID() {
+        const id = pending
+        pending = undefined
+        return id
+      },
+      restoreNewSessionID(id: string) {
+        pending ??= id
+      },
+    })
+  },
 })

packages/tui/src/routes/home.tsx

@@ -65,12 +65,13 @@ export function Home() {
     untrack(() => composer.set(prompt))
   })
 
-  // Wait for the model store to be ready before auto-submitting --prompt.
+  // Wait for everything submit needs before auto-submitting --prompt; it runs once.
   createEffect(() => {
     const r = ref()
     if (sent) return
     if (!r) return
-    if (!local.model.ready) return
+    if (!local.model.ready || !local.model.catalogReady) return
+    if (!local.agent.current() || !local.model.current()) return
     if (!args.prompt) return
     if (r.current.text !== args.prompt) return
     sent = true

packages/tui/test/app-lifecycle.test.tsx

@@ -876,6 +876,61 @@ test("session startup prompt is submitted exactly once", async () => {
   }
 })
 
+test("home startup prompt is submitted exactly once", async () => {
+  await using state = await tmpdir()
+  const cwd = process.cwd()
+  const location = { directory: cwd, project: { id: "project", directory: cwd, canonical: cwd } }
+  const bodies: unknown[] = []
+  const submitted = Promise.withResolvers<void>()
+  let session: unknown
+  await using setup = await createAppFixture({
+    state: state.path,
+    args: { prompt: "HOME_READY" },
+    config: { animations: false, tabs: { mode: "off" } },
+    fetch: async (url, request) => {
+      if (url.pathname === "/api/location") return json(location)
+      if (url.pathname === "/api/fs/list") return json({ location, data: [] })
+      if (url.pathname === "/api/agent")
+        return json({ location, data: [{ id: "build", mode: "primary", hidden: false, permissions: [] }] })
+      if (url.pathname === "/api/model")
+        return json({ location, data: [{ id: "model", providerID: "provider", name: "Model", variants: [] }] })
+      if (url.pathname === "/api/provider") return json({ location, data: [{ id: "provider", name: "Provider" }] })
+      if (url.pathname === "/api/session" && request.method === "POST") {
+        const input: unknown = await request.json()
+        if (typeof input !== "object" || input === null) throw new Error("Expected a session input")
+        session = {
+          ...input,
+          projectID: "project",
+          cost: 0,
+          tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+          time: { created: 0, updated: 0 },
+        }
+        return json({ data: session })
+      }
+      if (/^\/api\/session\/[^/]+\/prompt$/.test(url.pathname)) {
+        bodies.push(await request.json())
+        submitted.resolve()
+        return json({ data: {} })
+      }
+      if (/^\/api\/session\/[^/]+\/(message|inbox|permission)$/.test(url.pathname))
+        return json({ data: [], cursor: {} })
+      if (session && /^\/api\/session\/[^/]+$/.test(url.pathname)) return json({ data: session })
+      return undefined
+    },
+  })
+
+  await setup.ready
+  await Promise.race([
+    submitted.promise,
+    Bun.sleep(2000).then(() => {
+      throw new Error("startup prompt was not submitted")
+    }),
+  ])
+  await Bun.sleep(20)
+  expect(bodies).toHaveLength(1)
+  expect(bodies[0]).toMatchObject({ text: "HOME_READY" })
+})
+
 test.each([false, true])("uses the resolved launch directory for new prompts (fallback: %s)", async (fallback) => {
   await using state = await tmpdir()
   const target = fallback ? directory : process.cwd()

packages/tui/test/new-session-id.test.tsx

@@ -0,0 +1,100 @@
+import { expect, test } from "bun:test"
+import { createAppFixture } from "./fixture/app"
+import { json } from "./fixture/tui-client"
+
+type SessionInput = { id?: string; location?: { directory: string } }
+
+const location = {
+  directory: "/tmp/opencode/packages/tui",
+  project: { id: "project", directory: "/tmp/opencode", canonical: "/tmp/opencode" },
+}
+
+function sessionInfo(record: SessionInput) {
+  return {
+    ...record,
+    location: record.location ?? { directory: location.directory },
+    projectID: "project",
+    cost: 0,
+    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+    time: { created: 0, updated: 0 },
+  }
+}
+
+async function launch(options: { failCreates?: number } = {}) {
+  const attempts: (string | undefined)[] = []
+  const created: SessionInput[] = []
+  const prompts: string[] = []
+  let failures = options.failCreates ?? 0
+  const setup = await createAppFixture({
+    args: { newSessionID: "ses_chosen" },
+    config: { animations: false, keybinds: { "session.new": "f6" } },
+    fetch: async (url, request) => {
+      if (url.pathname === "/api/agent")
+        return json({ location, data: [{ id: "build", mode: "primary", hidden: false, permissions: [] }] })
+      if (url.pathname === "/api/provider") return json({ location, data: [{ id: "demo", name: "Demo" }] })
+      if (url.pathname === "/api/model")
+        return json({ location, data: [{ id: "model", providerID: "demo", name: "Demo Model", variants: [] }] })
+      if (url.pathname === "/api/session" && request.method === "POST") {
+        const record: SessionInput = await request.json()
+        attempts.push(record.id)
+        if (failures > 0) {
+          failures--
+          return json({ message: "create failed" }, { status: 500 })
+        }
+        created.push(record)
+        return json({ data: sessionInfo(record) })
+      }
+      if (/^\/api\/session\/[^/]+\/prompt$/.test(url.pathname)) {
+        prompts.push(url.pathname.split("/")[3] ?? "")
+        return json({ data: {} })
+      }
+      if (/^\/api\/session\/[^/]+\/(message|inbox|permission)$/.test(url.pathname))
+        return json({ data: [], cursor: {} })
+      if (/^\/api\/session\/[^/]+\/(agent|model)$/.test(url.pathname)) return new Response(null, { status: 204 })
+      if (/^\/api\/session\/[^/]+$/.test(url.pathname)) {
+        const record = created.find((item) => item.id === url.pathname.split("/")[3])
+        if (!record) return json({ message: "not found" }, { status: 404 })
+        return json({ data: sessionInfo(record) })
+      }
+      return undefined
+    },
+  })
+  return { setup, attempts, created, prompts }
+}
+
+test("the first new session uses the launch session ID and later ones mint their own", async () => {
+  const run = await launch()
+  await using setup = run.setup
+
+  await setup.ready
+  await setup.waitForFrame((frame) => frame.includes("Demo Model"))
+  await setup.mockInput.typeText("hello")
+  setup.mockInput.pressEnter()
+  await setup.waitForFrame(() => run.prompts.length === 1)
+  expect(run.prompts[0]).toBe("ses_chosen")
+  expect(run.created.map((item) => item.id)).toEqual(["ses_chosen"])
+
+  setup.mockInput.pressKey("F6")
+  await setup.renderOnce()
+  await setup.mockInput.typeText("again")
+  setup.mockInput.pressEnter()
+  await setup.waitForFrame(() => run.created.length === 2)
+  expect(run.created[1]?.id).toMatch(/^ses/)
+  expect(run.created[1]?.id).not.toBe("ses_chosen")
+})
+
+test("a failed first create keeps the launch session ID for the retry", async () => {
+  const run = await launch({ failCreates: 1 })
+  await using setup = run.setup
+
+  await setup.ready
+  await setup.waitForFrame((frame) => frame.includes("Demo Model"))
+  await setup.mockInput.typeText("hello")
+  setup.mockInput.pressEnter()
+  await setup.waitForFrame((frame) => frame.includes("Creating a session failed") && frame.includes("hello"))
+  expect(run.attempts).toEqual(["ses_chosen"])
+
+  setup.mockInput.pressEnter()
+  await setup.waitForFrame(() => run.created.length === 1)
+  expect(run.attempts).toEqual(["ses_chosen", "ses_chosen"])
+})

script/release.ts

@@ -61,7 +61,9 @@ if ((await editor.exited) !== 0) {
 const document = await Bun.file(review).text()
 const notes = document.match(/<!-- changelog:start -->\s*([\s\S]*?)\s*<!-- changelog:end -->/)
 if (!notes) throw new Error("Release review is missing its changelog markers")
-await Bun.write(changelog, `${notes[1].trim()}\n`)
+const releaseNotes = notes[1].trim()
+if (!releaseNotes) throw new Error("Release review has no changelog")
+await Bun.write(changelog, `${releaseNotes}\n`)
 
 const answer = prompt(`Trigger the ${version} release? [y/N]`)
 if (answer?.trim().toLowerCase() !== "y" && answer?.trim().toLowerCase() !== "yes") {
@@ -69,7 +71,7 @@ if (answer?.trim().toLowerCase() !== "y" && answer?.trim().toLowerCase() !== "ye
   process.exit(0)
 }
 
-await $`gh workflow run publish.yml --ref v2 ${input}`
+await $`gh workflow run publish.yml --ref v2 ${input} -f release_notes=${releaseNotes}`
 console.log(`Triggered the ${version} release`)
 
 async function generateReview(base: string) {