fix: apply upstream PRs anomalyco#29949 (cache stability) and anomalyco#30072 (O(N²)→O(N) streaming)

anomalyco#29949 — fix(session): move env block to tail of system prompt for cache stability
  Reorders system prompt so volatile env fields (cwd, date, model id) sit at
  the tail, enabling 95-98% prefix cache hit rate across fresh sessions.
  Adds \n prefix to env block for canonical byte seam.

anomalyco#30072 — fix(opencode): O(N²)→O(N) text/reasoning delta accumulation
  Replaces string concatenation in streaming deltas with chunked array +
  lazy getter pattern, eliminating quadratic memmove in long thinking-mode
  sessions (per-step drops from 61s to 21s on SWE-bench).

Author: raz123

packages/opencode/src/session/processor.ts

@@ -32,6 +32,41 @@ import { Usage, type LLMEvent } from "@opencode-ai/llm"
 const DOOM_LOOP_THRESHOLD = 3
 const log = Log.create({ service: "session.processor" })
 
+/**
+ * Replace `obj.text` with a lazy getter backed by an array of chunks so
+ * streaming text/reasoning deltas can be appended in O(1) instead of
+ * accumulated via `text += delta` (which is O(N²) once anything reads
+ * `.text` between writes — V8/JSC flatten the rope on every read and then
+ * re-copy on every subsequent `+=`).
+ *
+ * `_chunks` is non-enumerable so it does NOT leak through
+ * `JSON.stringify` / `structuredClone` / `{...obj}` to consumers. The
+ * `.text` getter materializes on first read, caches the joined string back
+ * into `_chunks` (so subsequent reads stay O(1)), and the setter resets
+ * `_chunks = [v]` so `obj.text = "..."` reassignments still work as
+ * expected. Same shape as the fix landed in vercel/ai for
+ * `processUIMessageStream` / `DefaultStreamTextResult`.
+ */
+function installChunkedText(obj: { text: string }): void {
+  Object.defineProperty(obj, "_chunks", {
+    value: [obj.text || ""],
+    writable: true,
+    enumerable: false,
+    configurable: true,
+  })
+  Object.defineProperty(obj, "text", {
+    get(): string {
+      const c = (this as any)._chunks as string[]
+      return c.length === 1 ? c[0] : ((this as any)._chunks = [c.join("")])[0]
+    },
+    set(v: string) {
+      ;(this as any)._chunks = [v]
+    },
+    enumerable: true,
+    configurable: true,
+  })
+}
+
 export type Result = "compact" | "stop" | "continue"
 
 export interface Handle {
@@ -323,13 +358,20 @@ export const layer = Layer.effect(
               time: { start: Date.now() },
               metadata: value.providerMetadata,
             }
+            installChunkedText(ctx.reasoningMap[value.id])
             yield* session.updatePart(ctx.reasoningMap[value.id])
             return
 
           case "reasoning-delta":
             // Match dev: silently drop orphan deltas (no preceding reasoning-start).
             if (!(value.id in ctx.reasoningMap)) return
-            ctx.reasoningMap[value.id].text += value.text
+            // O(N) chunk-append instead of O(N²) string concat. For
+            // thinking-mode models emitting 1500+ reasoning tokens per turn
+            // over 80+ turns, `text += value.text` here pegs JSC's GC with
+            // hundreds of MB of cumulative memmove work. The lazy getter
+            // installed at reasoning-start joins chunks on read; here we
+            // just push.
+            ;(ctx.reasoningMap[value.id] as any)._chunks.push(value.text)
             if (value.providerMetadata) ctx.reasoningMap[value.id].metadata = value.providerMetadata
             yield* session.updatePartDelta({
               sessionID: ctx.reasoningMap[value.id].sessionID,
@@ -635,12 +677,15 @@ export const layer = Layer.effect(
               time: { start: Date.now() },
               metadata: value.providerMetadata,
             }
+            installChunkedText(ctx.currentText)
             yield* session.updatePart(ctx.currentText)
             return
 
           case "text-delta":
             if (!ctx.currentText) return
-            ctx.currentText.text += value.text
+            // Same O(N²) fix as reasoning-delta above. The lazy getter
+            // installed at text-start joins chunks on read; here we just push.
+            ;(ctx.currentText as any)._chunks.push(value.text)
             if (value.providerMetadata) ctx.currentText.metadata = value.providerMetadata
             yield* session.updatePartDelta({
               sessionID: ctx.currentText.sessionID,

packages/opencode/src/session/prompt.ts

@@ -1438,7 +1438,12 @@ export const layer = Layer.effect(
               instruction.system().pipe(Effect.orDie),
               MessageV2.toModelMessagesEffect(msgs, model),
             ])
-            const system = [...env, ...instructions, ...(skills ? [skills] : [])]
+            // Cache-friendly order: place stable instructions/skills first so byte 0 of
+            // the assembled system payload is invariant across sessions, days, and users.
+            // The env block (which contains a per-session datetime, per-project cwd, and
+            // per-agent model id) goes at the tail so it cannot defeat prefix-cache hits
+            // on the upstream model. See anomalyco/opencode#20110, anomalyco/opencode#5224.
+            const system = [...instructions, ...(skills ? [skills] : []), ...env]
             const format = lastUser.format ?? { type: "text" as const }
             if (format.type === "json_schema") system.push(STRUCTURED_OUTPUT_SYSTEM_PROMPT)
             const result = yield* handle.process({

packages/opencode/src/session/system.ts

@@ -49,7 +49,7 @@ export const layer = Layer.effect(
         const ctx = yield* InstanceState.context
         return [
           [
-            `You are powered by the model named ${model.api.id}. The exact model ID is ${model.providerID}/${model.api.id}`,
+            `\nYou are powered by the model named ${model.api.id}. The exact model ID is ${model.providerID}/${model.api.id}`,
             `Here is some useful information about the environment you are running in:`,
             `<env>`,
             `  Working directory: ${ctx.directory}`,

packages/opencode/test/session/prompt.test.ts

@@ -1,6 +1,7 @@
 import { NodeFileSystem } from "@effect/platform-node"
 import { FetchHttpClient } from "effect/unstable/http"
-import { expect } from "bun:test"
+import { readFileSync } from "fs"
+import { expect, test } from "bun:test"
 import { Cause, Deferred, Duration, Effect, Exit, Fiber, Layer } from "effect"
 import path from "path"
 import { fileURLToPath, pathToFileURL } from "url"
@@ -2343,3 +2344,25 @@ noLLMServer.instance(
     }),
   30_000,
 )
+
+test("session/prompt: source assembles system array with env at tail for cache stability", () => {
+  const source = readFileSync(
+    path.resolve(__dirname, "../../src/session/prompt.ts"),
+    "utf8",
+  )
+  const match = source.match(
+    /const system = \[\.\.\.(\w+),\s*\.\.\.\(skills \? \[skills\] : \[\]\),\s*\.\.\.(\w+)\]/,
+  )
+  expect(match).not.toBeNull()
+  expect(match![1]).toBe("instructions")
+  expect(match![2]).toBe("env")
+})
+
+test("session/prompt: env block leads with \\n so the skills/env seam is a blank line", () => {
+  const source = readFileSync(
+    path.resolve(__dirname, "../../src/session/system.ts"),
+    "utf8",
+  )
+  const match = source.match(/`\\nYou are powered by the model/)
+  expect(match).not.toBeNull()
+})