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/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/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) {