diff --git a/.github/workflows/dreamcode-ci.yml b/.github/workflows/dreamcode-ci.yml
new file mode 100644
index 0000000000..15008b0a6d
--- /dev/null
+++ b/.github/workflows/dreamcode-ci.yml
@@ -0,0 +1,77 @@
+name: Dreamcode CI
+
+on:
+  push:
+    branches: [main, dev]
+  pull_request:
+  workflow_dispatch:
+
+env:
+  CI: true
+  OPENCODE_DISABLE_SHARE: 1
+
+jobs:
+  typecheck:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+      - run: bun install --frozen-lockfile
+      # Scope typecheck to packages/opencode only — the server (packages/cli)
+      # has pre-existing Effect-TS v4 HttpApi error-type incompatibilities
+      # that are unrelated to dreamcode changes.
+      - name: Typecheck
+        run: bun run --cwd packages/opencode typecheck
+
+  unit-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+      - run: bun install --frozen-lockfile
+      - name: Run unit tests (skill package)
+        run: bun test test/skill/
+        working-directory: packages/opencode
+
+  integration-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+      - run: bun install --frozen-lockfile
+      - name: Run integration tests (sensor gate)
+        run: bun test test/skill/sensor-gate.integration.test.ts
+        working-directory: packages/opencode
+      - name: Run integration tests (token predictor)
+        run: bun test test/skill/token-predictor.integration.test.ts
+        working-directory: packages/opencode
+
+  build:
+    runs-on: ubuntu-latest
+    needs: [typecheck, unit-tests, integration-tests]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+      - run: bun install --frozen-lockfile
+      - name: Build dreamcode binary
+        run: bun run packages/opencode/script/build.ts
+      - name: Binary smoke test
+        run: |
+          chmod +x packages/opencode/dist/dreamcode-linux-x64/bin/dreamcode
+          packages/opencode/dist/dreamcode-linux-x64/bin/dreamcode --version
+          packages/opencode/dist/dreamcode-linux-x64/bin/dreamcode --help
+      - name: Binary regression tests
+        run: bun test test/build/binary-regression.test.ts
+        working-directory: packages/opencode
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dreamcode-linux-x64
+          path: packages/opencode/dist/dreamcode-linux-x64/
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 4c36f41106..3e3a5f6a0e 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -10,7 +10,11 @@ on:
 concurrency:
   # Keep every run on dev so cancelled checks do not pollute the default branch
   # commit history. PRs and other branches still share a group and cancel stale runs.
-  group: ${{ case(github.ref == 'refs/heads/dev', format('{0}-{1}', github.workflow, github.run_id), format('{0}-{1}', github.workflow, github.event.pull_request.number || github.ref)) }}
+  # NOTE: `case()` is not a valid GitHub Actions expression function.
+  # We use &&/|| as a ternary-like alternative:
+  #   dev branch → unique per-run ID (never cancelled)
+  #   PRs/other → shared group key (stale runs cancelled)
+  group: ${{ github.ref == 'refs/heads/dev' && format('{0}-{1}', github.workflow, github.run_id) || format('{0}-{1}', github.workflow, github.event.pull_request.number || github.ref) }}
   cancel-in-progress: true
 
 permissions:
diff --git a/.husky/pre-push b/.husky/pre-push
index 65f441ce31..964c3fa0c6 100755
--- a/.husky/pre-push
+++ b/.husky/pre-push
@@ -17,6 +17,5 @@ if (process.versions.bun !== expectedBunVersion) {
   console.warn(`Warning: Bun version ${process.versions.bun} differs from expected ${expectedBunVersion}`);
 }
 '
-cd packages/core && bun run typecheck
-cd packages/llm && bun run typecheck
-cd packages/core && bun run typecheck && cd ../llm && bun run typecheck && cd ../opencode && bun run typecheck
+# packages/core and packages/llm do not exist in this fork — skipped.
+cd packages/opencode && bun run typecheck
diff --git a/install.ps1 b/install.ps1
index 51e5eda24a..ca22367e49 100644
--- a/install.ps1
+++ b/install.ps1
@@ -60,23 +60,24 @@ if (-not $BuildFromSource) {
     $release = Invoke-RestMethod -Uri $apiUrl -Headers @{ "User-Agent" = "dreamcode-installer" }
     $tag = $release.tag_name
     Write-Color "Latest release: $tag" $MUTED
-  } catch {
-    Write-Color "WARN: Could not fetch latest release. Using v1.3.1." $ORANGE
-    $tag = "v1.3.1"
-  }
 
-  # Find the windows-x64 asset (build system produces .zip for Windows)
-  $assetName = "dreamcode-windows-x64.zip"
-  $downloadUrl = "https://github.com/$OWNER/$REPO/releases/download/$tag/$assetName"
-  $tempArchive = "$tempDir\$assetName"
-  $extractDir = "$tempDir\extracted"
+    # Find the windows-x64 asset (build system produces .zip for Windows)
+    $assetName = "dreamcode-windows-x64.zip"
+    $downloadUrl = "https://github.com/$OWNER/$REPO/releases/download/$tag/$assetName"
+    $tempArchive = "$tempDir\$assetName"
+    $extractDir = "$tempDir\extracted"
 
-  New-Item -ItemType Directory -Force -Path $tempDir, $extractDir | Out-Null
+    New-Item -ItemType Directory -Force -Path $tempDir, $extractDir | Out-Null
 
-  try {
-    Download-File $downloadUrl $tempArchive
+    try {
+      Download-File $downloadUrl $tempArchive
+    } catch {
+      Write-Color "ERROR: Failed to download $downloadUrl" $RED
+      Write-Color "Falling back to source build (requires git + bun)..." $ORANGE
+      $BuildFromSource = $true
+    }
   } catch {
-    Write-Color "ERROR: Failed to download $downloadUrl" $RED
+    Write-Color "ERROR: Failed to fetch latest release from GitHub API." $RED
     Write-Color "Falling back to source build (requires git + bun)..." $ORANGE
     $BuildFromSource = $true
   }
@@ -165,7 +166,10 @@ if ($BuildFromSource) {
   Write-Color "Building version: $VERSION" $MUTED
 
   Set-Location $INSTALL_DIR
-  bun install
+  # Windows requires --linker hoisted for symlink compatibility (bun#12385)
+  $bunInstallArgs = @("install")
+  if ($env:OS -eq "Windows_NT") { $bunInstallArgs += "--linker", "hoisted" }
+  & "bun" @bunInstallArgs
 
   Set-Location packages\opencode
   bun run build --single --skip-embed-web-ui --skip-install
diff --git a/packages/opencode/src/session/prompt.ts b/packages/opencode/src/session/prompt.ts
index 4069ca88a0..a5e76610c9 100644
--- a/packages/opencode/src/session/prompt.ts
+++ b/packages/opencode/src/session/prompt.ts
@@ -86,9 +86,11 @@ IMPORTANT:
 const STRUCTURED_OUTPUT_SYSTEM_PROMPT = `IMPORTANT: The user has requested structured output. You MUST use the StructuredOutput tool to provide your final response. Do NOT respond with plain text - you MUST call the StructuredOutput tool with your answer formatted according to the schema.`
 
 function sanitizeForSystemPrompt(text: string): string {
-  // Escape HTML/XML metacharacters to prevent prompt injection via tag injection.
-  // Order matters: & first to avoid double-escaping.
+  // Strip known dreamcode XML tags before HTML/XML escaping to prevent
+  // prompt injection via fake system tags (e.g. </sensor-gate>, <chain-gap>).
+  // Order matters: escape HTML/XML metacharacters, & first to avoid double-escaping.
   return text
+    .replace(/<\/?(sensor-gate|chain-gap|chain-verification|chain-executor-result|skill-result|skill-missing|loaded-skill|neuro-analysis|rate-budget|rate-limit|context-summary|persona-profiles?)\b[^>]*>/gi, "")
     .replace(/&/g, "&amp;")
     .replace(/</g, "&lt;")
     .replace(/>/g, "&gt;")
@@ -1558,8 +1560,12 @@ Before every response, verify your reasoning:
                     }
 
                     // Phase 5: Wire orphaned Python scripts — run for any task with 2+ skills
+                    // Note: runFullPipeline() takes no arguments. It uses --dashboard --json internally,
+                    // reading prompt/chain from the orchestrator's dashboards file. The old signature
+                    // (chain, userPrompt) was removed because the dashboard mode is stateless and
+                    // informational — it prints ecosystem health, not per-prompt results.
                     if (gateResult.complexity === "high" || gateResult.chain.length > 1) {
-                      const pipelineResults = yield* chainExecutor.runFullPipeline(gateResult.chain, userText).pipe(
+                      const pipelineResults = yield* chainExecutor.runFullPipeline().pipe(
                         Effect.catch((e) => {
                           console.warn("[chain-executor] runFullPipeline() failed:", e)
                           return Effect.succeed([])
@@ -1585,9 +1591,13 @@ Before every response, verify your reasoning:
                     }
 
                     // ─── Chain-Gap Detection ──────────────────────────
-                    // Hard enforcement: warn if any chain skill wasn't executed
+                    // Hard enforcement: warn if any chain skill wasn't executed.
+                    // Only count script-type results as "executed" — content-only (passive SKILL.md
+                    // injection) skills don't count because they don't run any code.
                     const missingSkills = gateResult.chain.filter(
-                      (name) => !chainResults.some((r) => r.name === name && r.status === "ok"),
+                      (name) => !chainResults.some(
+                        (r) => r.name === name && r.status === "ok" && r.executionType === "script",
+                      ),
                     )
                     // Mandated skills that MUST execute when in DREAM_INNOVATION mode
                     const MANDATED_SKILLS = new Set(["breakthrough-overdrive-innovation"])
@@ -1608,7 +1618,9 @@ Before every response, verify your reasoning:
                       }
                       // Update missing list after re-execution — warn about ALL remaining gaps
                       const stillMissing = gateResult.chain.filter(
-                        (name) => !chainResults.some((r) => r.name === name && r.status === "ok"),
+                        (name) => !chainResults.some(
+                          (r) => r.name === name && r.status === "ok" && r.executionType === "script",
+                        ),
                       )
                       if (stillMissing.length > 0) {
                         system.push(
diff --git a/packages/opencode/src/skill/chain-executor.ts b/packages/opencode/src/skill/chain-executor.ts
index 6e7679bc10..0e7b3e94d9 100644
--- a/packages/opencode/src/skill/chain-executor.ts
+++ b/packages/opencode/src/skill/chain-executor.ts
@@ -4,49 +4,14 @@ import { InstanceState } from "@/effect/instance-state"
 import { Skill } from "@/skill"
 import { Glob } from "@opencode-ai/core/util/glob"
 import path from "path"
-import fs from "fs"
-import { resolvePythonCommand, getPythonArgs, resolveSkillsDir, HOME } from "./python-resolver"
-
-function isUnderPrefix(realpath: string, allowedPrefix: string): boolean {
-  // Normalize: ensure prefix ends with separator to prevent sibling-directory escape
-  // e.g. prefix "/home/user/.dreamcode/skills" should NOT match "/home/user/.dreamcode/skills-evil"
-  const normalized = allowedPrefix.endsWith(path.sep) ? allowedPrefix : allowedPrefix + path.sep
-  return realpath === allowedPrefix || realpath.startsWith(normalized)
-}
-
-export function validateScriptPath(resolved: string, cwd?: string): boolean {
-  if (!resolved || !path.isAbsolute(resolved)) return false
-  // Resolve symlinks before checking to prevent sandbox escape
-  let realpath: string
-  try {
-    realpath = fs.realpathSync(resolved)
-  } catch (error) {
-    // Differentiate between ENOENT (normal — file doesn't exist yet) and
-    // other errors (symlink loops, permission denied) which are real problems.
-    const code = (error as NodeJS.ErrnoException)?.code
-    if (code !== "ENOENT") {
-      console.warn("[chain-executor] Unexpected realpath error", resolved, error)
-    }
+import { resolvePythonCommand, getPythonArgs, resolveSkillsDir, HOME, writePromptToTmpFile, cleanupTmpFile, validateScriptPath, BASE_SUBPROCESS_ENV } from "./python-resolver"
     // realpathSync throws when the file doesn't exist or permission denied.
-    // path.resolve does NOT resolve `..` segments — reject traversal patterns.
-    realpath = path.resolve(resolved)
-    if (realpath.includes("..")) return false
-  }
-  const skillsDir = resolveSkillsDir()
-  const allowedGlobal = skillsDir ? path.resolve(skillsDir) : null
-  const allowedHome = path.resolve(HOME, ".dreamcode", "skills")
-  const allowedProject = path.resolve(cwd ?? process.cwd(), ".dreamcode", "skills")
-  return (
-    (allowedGlobal !== null && isUnderPrefix(realpath, allowedGlobal)) ||
-    isUnderPrefix(realpath, allowedHome) ||
-    isUnderPrefix(realpath, allowedProject)
-  )
-}
-
 export interface ChainResult {
   name: string
   output: string
   status: "ok" | "not_found" | "error"
+  /** Distinguishes actual Python subprocess execution from passive SKILL.md content injection */
+  executionType: "script" | "content"
 }
 
 export interface Interface {
@@ -54,10 +19,7 @@ export interface Interface {
     chain: string[],
     userPrompt: string,
   ) => Effect.Effect<ChainResult[]>
-  readonly runFullPipeline: (
-    chain: string[],
-    userPrompt: string,
-  ) => Effect.Effect<ChainResult[]>
+  readonly runFullPipeline: () => Effect.Effect<ChainResult[]>
   readonly verify: (
     results: ChainResult[],
   ) => Effect.Effect<string>
@@ -79,26 +41,30 @@ const runPythonScript = Effect.fn("ChainExecutor.runPythonScript")(function* (
   if (!validateScriptPath(path.resolve(script), cwd)) {
     return { output: "[SKIPPED] Script path outside allowed skills directory", exitCode: 0 }
   }
-  // Pass prompt as --prompt argument instead of piping via stdin.
+  // Pass prompt via temp file + --prompt-file to avoid leaking it in process listings.
   // Bun.spawn creates Unix domain sockets (not pipes) in compiled binaries,
   // and writer.close() doesn't send EOF through them, causing Python's
-  // sys.stdin.read() to block forever. --prompt arg avoids this entirely.
-  // Most skill scripts already support --prompt (required=True).
+  // sys.stdin.read() to block forever. --prompt-file avoids this entirely.
+  let tmpFile = ""
+  try {
+    tmpFile = writePromptToTmpFile(prompt, cwd, "ce-")
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e)
+    console.warn("[chain-executor] failed to create tmp file for prompt", msg)
+    return { output: `[ERROR] Failed to create temp file: ${msg}`, exitCode: -1 }
+  }
   // Cross-platform Python resolution
   const pythonCmd = resolvePythonCommand()
   const versionArgs = getPythonArgs()
   return yield* Effect.tryPromise({
     try: async () => {
-      const proc = Bun.spawn([pythonCmd, ...versionArgs, script, "--prompt", prompt], {
+      const proc = Bun.spawn([pythonCmd, ...versionArgs, script, "--prompt-file", tmpFile], {
         cwd,
         stdin: "ignore",
         stdout: "pipe",
         stderr: "pipe",
         env: {
-          PATH: process.env.PATH,
-          HOME: process.env.HOME,
-          PYTHONPATH: process.env.PYTHONPATH ?? "",
-          NEURO_API_KEY: process.env.NEUCODE_NEURO_API_KEY ?? process.env.NEURO_API_KEY ?? "",
+          ...BASE_SUBPROCESS_ENV,
           PROJECT_ROOT: cwd,
         },
       })
@@ -122,6 +88,10 @@ const runPythonScript = Effect.fn("ChainExecutor.runPythonScript")(function* (
       console.warn("[chain-executor] python script failed", { script, error: msg })
       return Effect.succeed({ output: `[ERROR] ${msg}`, exitCode: -1 })
     }),
+    Effect.tap(() => {
+      cleanupTmpFile(tmpFile)
+      return Effect.void
+    }),
   )
 })
 
@@ -144,10 +114,7 @@ const runPythonScriptAdvanced = Effect.fn("ChainExecutor.runPythonScriptAdvanced
         stdout: "pipe",
         stderr: "pipe",
         env: {
-          PATH: process.env.PATH,
-          HOME: process.env.HOME,
-          PYTHONPATH: process.env.PYTHONPATH ?? "",
-          NEURO_API_KEY: process.env.NEUCODE_NEURO_API_KEY ?? process.env.NEURO_API_KEY ?? "",
+          ...BASE_SUBPROCESS_ENV,
           PROJECT_ROOT: cwd,
         },
       })
@@ -186,7 +153,7 @@ export const execute = Effect.fn("ChainExecutor.execute")(function* (
   for (const skillName of chain) {
     const skillInfo = yield* skillService.require(skillName).pipe(Effect.option)
     if (skillInfo._tag === "None") {
-      results.push({ name: skillName, output: "", status: "not_found" })
+      results.push({ name: skillName, output: "", status: "not_found", executionType: "content" })
       continue
     }
 
@@ -200,6 +167,7 @@ export const execute = Effect.fn("ChainExecutor.execute")(function* (
         name: skillName,
         output: skill.content,
         status: "ok",
+        executionType: "content",
       })
       continue
     }
@@ -214,12 +182,14 @@ export const execute = Effect.fn("ChainExecutor.execute")(function* (
         name: skillName,
         output: scriptResult.output || `[ERROR] Script ${script} exited with code ${scriptResult.exitCode}`,
         status: "error",
+        executionType: "script",
       })
     } else {
       results.push({
         name: skillName,
         output: scriptResult.output || "[SKILL EXECUTED: no output]",
         status: scriptResult.output ? "ok" : "error",
+        executionType: "script",
       })
     }
   }
@@ -227,10 +197,7 @@ export const execute = Effect.fn("ChainExecutor.execute")(function* (
   return results
 })
 
-export const runFullPipeline = Effect.fn("ChainExecutor.runFullPipeline")(function* (
-  chain: string[],
-  userPrompt: string,
-) {
+export const runFullPipeline = Effect.fn("ChainExecutor.runFullPipeline")(function* () {
   const ctx = yield* InstanceState.contextOrNull
   const cwd = ctx?.directory ?? process.cwd()
   const skillsDir = resolveSkillsDir()
@@ -255,12 +222,13 @@ export const runFullPipeline = Effect.fn("ChainExecutor.runFullPipeline")(functi
         name: "chain-executor-pipeline",
         output: `[WARNING] Pipeline orchestrator not found: ${executorScript}`,
         status: "error",
+        executionType: "content",
       })
       return results
     }
     const pipelineResult = yield* runPythonScriptAdvanced(
       executorScript,
-      ["--mode", chain.length > 3 ? "DREAM_INNOVATION" : "STANDARD", "--prompt", userPrompt],
+      ["--dashboard", "--json"],
       cwd,
     )
     if (pipelineResult.exitCode !== 0) {
@@ -268,12 +236,14 @@ export const runFullPipeline = Effect.fn("ChainExecutor.runFullPipeline")(functi
         name: "chain-executor-pipeline",
         output: pipelineResult.output || `[ERROR] Pipeline script exited with code ${pipelineResult.exitCode}`,
         status: "error",
+        executionType: "script",
       })
     } else if (pipelineResult.output) {
       results.push({
         name: "chain-executor-pipeline",
         output: pipelineResult.output,
         status: "ok",
+        executionType: "script",
       })
     }
   } catch (e) {
@@ -281,6 +251,7 @@ export const runFullPipeline = Effect.fn("ChainExecutor.runFullPipeline")(functi
       name: "chain-executor-pipeline",
       output: `[ERROR] Pipeline execution failed: ${String(e)}`,
       status: "error",
+      executionType: "content",
     })
   }
 
@@ -330,7 +301,7 @@ export const layer = Layer.effect(
   Effect.gen(function* () {
     return Service.of({
       execute: (chain, userPrompt) => execute(chain, userPrompt),
-      runFullPipeline: (chain, userPrompt) => runFullPipeline(chain, userPrompt),
+      runFullPipeline: () => runFullPipeline(),
       verify: (results) => verify(results),
     })
   }),
@@ -340,4 +311,4 @@ export const defaultLayer = layer
 
 export const node = LayerNode.make(layer, [])
 
-export const ChainExecutor = { Service, layer, defaultLayer, node, validateScriptPath }
+export const ChainExecutor = { Service, layer, defaultLayer, node }
diff --git a/packages/opencode/src/skill/dreamcode/skills/chain-orchestrator/scripts/classifier.py b/packages/opencode/src/skill/dreamcode/skills/chain-orchestrator/scripts/classifier.py
index 7709f2ac95..a20bc414af 100644
--- a/packages/opencode/src/skill/dreamcode/skills/chain-orchestrator/scripts/classifier.py
+++ b/packages/opencode/src/skill/dreamcode/skills/chain-orchestrator/scripts/classifier.py
@@ -7,6 +7,7 @@
 
 import json
 import re
+from pathlib import Path
 
 # ---------------------------------------------------------------------------
 # Task Detection Rules
@@ -161,11 +162,19 @@ def build_chain(tasks: list[dict], complexity: str) -> list[str]:
     import argparse
 
     parser = argparse.ArgumentParser(description="Prompt Classifier")
-    parser.add_argument("--prompt", required=True, help="User prompt to classify")
+    parser.add_argument("--prompt", default=None, help="User prompt to classify")
+    parser.add_argument("--prompt-file", default=None, help="Read prompt from file")
     parser.add_argument("--json", action="store_true", help="JSON output")
     args = parser.parse_args()
 
-    result = classify_prompt(args.prompt)
+    if args.prompt_file:
+        prompt = Path(args.prompt_file).read_text().strip()
+    elif args.prompt:
+        prompt = args.prompt
+    else:
+        parser.error("Either --prompt or --prompt-file is required")
+
+    result = classify_prompt(prompt)
 
     if args.json:
         print(json.dumps(result, indent=2))
diff --git a/packages/opencode/src/skill/dreamcode/skills/chain-orchestrator/scripts/orchestrator.py b/packages/opencode/src/skill/dreamcode/skills/chain-orchestrator/scripts/orchestrator.py
index 33e3b5033d..b07d738c7c 100644
--- a/packages/opencode/src/skill/dreamcode/skills/chain-orchestrator/scripts/orchestrator.py
+++ b/packages/opencode/src/skill/dreamcode/skills/chain-orchestrator/scripts/orchestrator.py
@@ -309,6 +309,8 @@ def print_dashboard():
     parser.add_argument("--validate", action="store_true", help="Validate chains")
     parser.add_argument("--order", help="Get execution order for task type")
     parser.add_argument("--json", action="store_true", help="JSON output")
+    parser.add_argument("--prompt-file", default=None, help="Read prompt from file (reserved for future use)")
+    parser.add_argument("--mode", default=None, help="Pipeline mode (reserved for future use)")
     args = parser.parse_args()
 
     if args.dashboard:
diff --git a/packages/opencode/src/skill/dreamcode/skills/guardian-ai/scripts/guardian_ai.py b/packages/opencode/src/skill/dreamcode/skills/guardian-ai/scripts/guardian_ai.py
index 3b539bcfed..d49418b49a 100644
--- a/packages/opencode/src/skill/dreamcode/skills/guardian-ai/scripts/guardian_ai.py
+++ b/packages/opencode/src/skill/dreamcode/skills/guardian-ai/scripts/guardian_ai.py
@@ -299,13 +299,21 @@ def run_guardian(prompt: str, context: dict = None) -> dict:
     import argparse
 
     parser = argparse.ArgumentParser(description="Guardian AI — NEURO-powered safety supervisor")
-    parser.add_argument("--prompt", required=True, help="User prompt to review")
+    parser.add_argument("--prompt", default=None, help="User prompt to review")
+    parser.add_argument("--prompt-file", default=None, help="Read prompt from file")
     parser.add_argument("--context", default="{}", help="JSON context (files, etc.)")
     parser.add_argument("--json", action="store_true", help="JSON output")
     args = parser.parse_args()
 
+    if args.prompt_file:
+        prompt = Path(args.prompt_file).read_text().strip()
+    elif args.prompt:
+        prompt = args.prompt
+    else:
+        parser.error("Either --prompt or --prompt-file is required")
+
     context = json.loads(args.context) if args.context else {}
-    result = run_guardian(args.prompt, context)
+    result = run_guardian(prompt, context)
 
     if args.json:
         print(json.dumps(result, indent=2))
diff --git a/packages/opencode/src/skill/dreamcode/skills/scheduled-automations/scripts/scheduler.py b/packages/opencode/src/skill/dreamcode/skills/scheduled-automations/scripts/scheduler.py
index 0f3006e478..5e0a8a6033 100644
--- a/packages/opencode/src/skill/dreamcode/skills/scheduled-automations/scripts/scheduler.py
+++ b/packages/opencode/src/skill/dreamcode/skills/scheduled-automations/scripts/scheduler.py
@@ -181,11 +181,19 @@ def cmd_add(args: argparse.Namespace) -> None:
         print(f"Job '{args.name}' already exists. Use 'update' to modify.")
         sys.exit(1)
 
+    if args.prompt_file:
+        prompt = Path(args.prompt_file).read_text().strip()
+    elif args.prompt:
+        prompt = args.prompt
+    else:
+        print("Error: --prompt or --prompt-file is required")
+        sys.exit(1)
+
     job = Job(
         name=args.name,
         schedule=args.schedule,
         chain=args.chain,
-        prompt=args.prompt,
+        prompt=prompt,
         enabled=not args.disabled,
         notify=args.notify,
     )
@@ -196,7 +204,7 @@ def cmd_add(args: argparse.Namespace) -> None:
     print(f"✓ Added job '{args.name}'")
     print(f"  Schedule: {args.schedule}")
     print(f"  Chain: {args.chain}")
-    print(f"  Prompt: {args.prompt[:80]}...")
+    print(f"  Prompt: {prompt[:80]}...")
 
 
 def cmd_run(args: argparse.Namespace) -> None:
@@ -352,8 +360,10 @@ def main() -> None:
                        help="Cron schedule (e.g. '0 2 * * *')")
     p_add.add_argument("--chain", "-c", required=True,
                        help="Skill chain (e.g. 'security → quality')")
-    p_add.add_argument("--prompt", "-p", required=True,
+    p_add.add_argument("--prompt", "-p", default=None,
                        help="Prompt to send to agent")
+    p_add.add_argument("--prompt-file", default=None,
+                       help="Read prompt from file")
     p_add.add_argument("--notify", action="store_true",
                        help="Notify on completion")
     p_add.add_argument("--disabled", action="store_true",
diff --git a/packages/opencode/src/skill/python-resolver.ts b/packages/opencode/src/skill/python-resolver.ts
index ccdbdcef18..77774c82a6 100644
--- a/packages/opencode/src/skill/python-resolver.ts
+++ b/packages/opencode/src/skill/python-resolver.ts
@@ -7,8 +7,8 @@
  * This module also resolves the path to Python scripts that are installed
  * alongside the dreamcode binary.
  */
-import { existsSync, statSync, appendFileSync, mkdirSync } from "fs"
-import { join, dirname } from "path"
+import { existsSync, statSync, appendFileSync, mkdirSync, writeFileSync, mkdtempSync, chmodSync, unlinkSync, rmdirSync, realpathSync } from "fs"
+import { join, dirname, sep, resolve, isAbsolute } from "path"
 import { homedir } from "os"
 
 /**
@@ -45,6 +45,46 @@ export function isWindows(): boolean {
   return process.platform === "win32"
 }
 
+/**
+ * Write a prompt string to a temporary file and return the file path.
+ * This avoids leaking the prompt via CLI arguments in process listings.
+ *
+ * @param prompt - The prompt text to write
+ * @param cwd - Working directory to use for the temp base path
+ * @param prefix - Directory name prefix (e.g. "sg-", "ce-", "tp-")
+ * @returns The absolute path to the temp file
+ * @throws If temp file creation fails
+ */
+export function writePromptToTmpFile(prompt: string, cwd: string, prefix: string): string {
+  const tmpBase = isWindows()
+    ? join(process.env.TEMP || process.env.TMP || HOME, "dreamcode")
+    : join(cwd, ".dreamcode", "tmp")
+  mkdirSync(tmpBase, { recursive: true })
+  const tmpDir = mkdtempSync(join(tmpBase, prefix))
+  if (!isWindows()) chmodSync(tmpDir, 0o700)
+  const tmpFile = join(tmpDir, "prompt.txt")
+  writeFileSync(tmpFile, prompt, "utf-8")
+  return tmpFile
+}
+
+/**
+ * Clean up a temporary prompt file and its parent directory.
+ * Safe to call even if the file or directory doesn't exist (errors are swallowed).
+ */
+export function cleanupTmpFile(tmpFile: string): void {
+  if (!tmpFile) return
+  try { unlinkSync(tmpFile) } catch (e) {
+    if ((e as NodeJS.ErrnoException)?.code !== "ENOENT") {
+      console.warn("[python-resolver] cleanupTmpFile failed to unlink", tmpFile, e)
+    }
+  }
+  try { rmdirSync(dirname(tmpFile)) } catch (e) {
+    if ((e as NodeJS.ErrnoException)?.code !== "ENOENT") {
+      console.warn("[python-resolver] cleanupTmpFile failed to rmdir", dirname(tmpFile), e)
+    }
+  }
+}
+
 /**
  * Resolve the Python command for the current platform.
  * Returns the command and arguments prefix to use with Bun.spawn.
@@ -175,4 +215,75 @@ export function resolveScript(relativePath: string): string | undefined {
   return undefined
 }
 
+// ---------------------------------------------------------------------------
+// Path Validation (moved from chain-executor.ts to break circular dependency)
+// ---------------------------------------------------------------------------
+
+/**
+ * Check if a realpath falls under an allowed prefix.
+ * Normalizes the prefix with a trailing separator to prevent sibling-directory
+ * escape (e.g. prefix "/skills" should NOT match "/skills-evil").
+ */
+export function isUnderPrefix(realpath: string, allowedPrefix: string): boolean {
+  const normalized = allowedPrefix.endsWith(sep) ? allowedPrefix : allowedPrefix + sep
+  return realpath === allowedPrefix || realpath.startsWith(normalized)
+}
+
+/**
+ * Validate that a script path is inside one of the allowed skills directories.
+ * Resolves symlinks before checking to prevent sandbox escape.
+ *
+ * Exported from python-resolver.ts so all skill subprocess modules can share it
+ * without depending on chain-executor.ts.
+ */
+export function validateScriptPath(resolved: string, cwd?: string): boolean {
+  if (!resolved || !isAbsolute(resolved)) return false
+  let realpath: string
+  try {
+    realpath = realpathSync(resolved)
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException)?.code
+    if (code !== "ENOENT") {
+      console.warn("[python-resolver] Unexpected realpath error", resolved, error)
+    }
+    // Check `..` in resolved BEFORE resolve() which normalizes them away.
+    if (resolved.includes("..")) return false
+    realpath = resolve(resolved)
+  }
+  const skillsDir = resolveSkillsDir()
+  const allowedGlobal = skillsDir ? resolve(skillsDir) : null
+  const allowedHome = resolve(HOME, ".dreamcode", "skills")
+  const allowedProject = resolve(cwd ?? process.cwd(), ".dreamcode", "skills")
+  return (
+    (allowedGlobal !== null && isUnderPrefix(realpath, allowedGlobal)) ||
+    isUnderPrefix(realpath, allowedHome) ||
+    isUnderPrefix(realpath, allowedProject)
+  )
+}
+
+// ---------------------------------------------------------------------------
+// Shared Subprocess Environment Allowlist
+// ---------------------------------------------------------------------------
+
+/**
+ * Base environment variables allowed in subprocess spawns.
+ *
+ * Using an allowlist (not a denylist) prevents accidental credential leakage
+ * via inherited environment variables. Add new variables here rather than
+ * duplicating env blocks across spawn sites.
+ *
+ * Each spawn site spreads this and adds site-specific overrides:
+ * ```
+ * env: { ...BASE_SUBPROCESS_ENV, PROJECT_ROOT: cwd }
+ * ```
+ *
+ * NOTE: The NEURO harness in sensor-gate.ts also passes NEURO_API_KEY — that
+ * is intentional and site-specific (NEURO backend auth).
+ */
+export const BASE_SUBPROCESS_ENV: Record<string, string | undefined> = {
+  PATH: process.env.PATH,
+  HOME: process.env.HOME,
+  PYTHONPATH: process.env.PYTHONPATH ?? "",
+}
+
 
diff --git a/packages/opencode/src/skill/sensor-gate-enforcer.ts b/packages/opencode/src/skill/sensor-gate-enforcer.ts
index ba63128d62..54668f8a10 100644
--- a/packages/opencode/src/skill/sensor-gate-enforcer.ts
+++ b/packages/opencode/src/skill/sensor-gate-enforcer.ts
@@ -16,8 +16,7 @@
 
 import type { Hooks, PluginInput, Plugin as PluginInstance } from "@opencode-ai/plugin"
 import { resetPeriodicTimer, categorizeQuestion, predictorBreaker } from "./token-predictor.js"
-import { resolvePythonCommand, resolveSkillsDir, getPythonArgs } from "./python-resolver.js"
-import { validateScriptPath } from "./chain-executor.js"
+import { resolvePythonCommand, resolveSkillsDir, getPythonArgs, writePromptToTmpFile, cleanupTmpFile, validateScriptPath, BASE_SUBPROCESS_ENV } from "./python-resolver.js"
 import path from "path"
 
 // ---------------------------------------------------------------------------
@@ -84,12 +83,21 @@ async function runPredictorScript(prompt: string, projectRoot?: string): Promise
     return null
   }
 
+  // Write prompt to temp file — avoids leaking it in process listings
+  let tmpFile = ""
+  try {
+    tmpFile = writePromptToTmpFile(prompt, projectRoot || process.cwd(), "enf-")
+  } catch (e) {
+    console.warn("[sensor-gate-enforcer] Failed to create temp file for prompt:", e)
+    return null
+  }
+
   const args = [
     ...pythonArgs,
     scriptPath,
     "--json",
-    "--prompt",
-    prompt,
+    "--prompt-file",
+    tmpFile,
     "--count",
     String(MAX_QUESTIONS),
   ]
@@ -102,10 +110,7 @@ async function runPredictorScript(prompt: string, projectRoot?: string): Promise
       stdout: "pipe",
       stderr: "pipe",
       env: {
-        PATH: process.env.PATH,
-        HOME: process.env.HOME,
-        PYTHONPATH: process.env.PYTHONPATH ?? "",
-        NEURO_API_KEY: process.env.NEUCODE_NEURO_API_KEY ?? process.env.NEURO_API_KEY ?? "",
+        ...BASE_SUBPROCESS_ENV,
         PROJECT_ROOT: projectRoot || process.cwd(),
       },
     })
@@ -126,7 +131,7 @@ async function runPredictorScript(prompt: string, projectRoot?: string): Promise
 
       if (exitCode !== 0) {
         predictorBreaker.recordFailure()
-        console.warn("[sensor-gate-enforcer] Predictor script failed:", stderr.slice(0, 200))
+        console.warn("[sensor-gate-enforcer] Predictor script failed:", stderr.slice(0, 500))
         return null
       }
 
@@ -141,6 +146,8 @@ async function runPredictorScript(prompt: string, projectRoot?: string): Promise
     predictorBreaker.recordFailure()
     console.warn("[sensor-gate-enforcer] Failed to spawn predictor:", String(e))
     return null
+  } finally {
+    cleanupTmpFile(tmpFile)
   }
 }
 
diff --git a/packages/opencode/src/skill/sensor-gate.ts b/packages/opencode/src/skill/sensor-gate.ts
index 42ef2cfc53..b4444d0e5d 100644
--- a/packages/opencode/src/skill/sensor-gate.ts
+++ b/packages/opencode/src/skill/sensor-gate.ts
@@ -4,33 +4,11 @@ import * as fs from "fs"
 import * as path from "path"
 import { InstanceState } from "@/effect/instance-state"
 import { buildPrompt } from "./prompt-engine"
-import { resolvePythonCommand, resolvePythonCommands, getPythonArgs, resolveSkillsDir, resolveScript as resolveScriptImpl, HOME, isWindows, debugLog } from "./python-resolver"
+import { resolvePythonCommand, resolvePythonCommands, getPythonArgs, resolveSkillsDir, resolveScript as resolveScriptImpl, HOME, isWindows, debugLog, writePromptToTmpFile, cleanupTmpFile, BASE_SUBPROCESS_ENV } from "./python-resolver"
 
 const SAFE_PROMPT_MAX = 100_000
 const USER_AGENT_COUNT_RE = /(?:spawn|use|run|deploy)\s+(\d+)\s+(?:agent|subagent|specialist|persona)/i
 
-/** Resolve a writable temp directory, trying project-local first then fallbacks. */
-function resolveTmpBase(projectRoot: string): string {
-  if (isWindows()) {
-    return path.join(process.env.TEMP || process.env.TMP || HOME, "dreamcode")
-  }
-  const candidates = [
-    path.join(projectRoot, ".dreamcode", "tmp"),
-    ...(process.env.XDG_RUNTIME_DIR ? [path.join(process.env.XDG_RUNTIME_DIR, "dreamcode")] : []),
-    path.join(HOME, ".dreamcode", "tmp"),
-  ]
-  for (const dir of candidates) {
-    try {
-      fs.mkdirSync(dir, { recursive: true })
-      const testFile = path.join(dir, ".write-test")
-      fs.writeFileSync(testFile, "")
-      fs.unlinkSync(testFile)
-      return dir
-    } catch {}
-  }
-  return candidates[0]
-}
-
 const RATE_MAX_SPAWNS = 5
 
 export interface Persona {
@@ -341,7 +319,7 @@ export function evaluateSpawnNecessity(
   }
 }
 
-function depthScore(result: SensorGateResult): number {
+export function depthScore(result: SensorGateResult): number {
   // Compute task depth from multiple signals on a 1-5 scale
   const tags = result.domain_tags.filter(Boolean).length
   const chainLen = result.chain.filter(Boolean).length
@@ -550,6 +528,16 @@ export function parseSensorGateOutput(output: string): SensorGateResult {
     }
   }
 
+  // Post-validate critical fields
+  if (!["low", "medium", "high"].includes(result.risk_level)) {
+    console.warn(`[sensor-gate] Invalid risk_level "${result.risk_level}" — defaulting to "medium"`)
+    result.risk_level = "medium"
+  }
+  if (!Number.isFinite(result.confidence) || result.confidence < 0 || result.confidence > 1) {
+    console.warn(`[sensor-gate] Invalid confidence "${result.confidence}" — clamping to [0,1]`)
+    result.confidence = Math.max(0, Math.min(1, result.confidence))
+  }
+
   return result
 }
 
@@ -585,24 +573,20 @@ function runSensorGateEffect(
 
   const runWithTimeout = (timeoutMs: number) =>
     Effect.gen(function* () {
-      // Write prompt to temp file instead of piping via stdin.
+      // Write prompt to temp file instead of piping via stdin or CLI --prompt arg.
       // Bun.spawn creates Unix domain sockets (not pipes) in compiled binaries,
       // and writer.close() doesn't send EOF through them, causing Python's
       // sys.stdin.read() to block forever. Temp file avoids this entirely.
-      const tmpBase = resolveTmpBase(projectRoot)
-      let tmpDir = ""
+      // Using --prompt-file also avoids leaking the prompt in process listings.
       let tmpFile = ""
       try {
-        fs.mkdirSync(tmpBase, { recursive: true })
-        tmpDir = fs.mkdtempSync(path.join(tmpBase, "sg-"))
-        // chmod is a no-op on Windows; skip it to avoid potential throw in edge cases
-        if (!isWindows()) fs.chmodSync(tmpDir, 0o700)
-        tmpFile = path.join(tmpDir, "prompt.txt")
-        fs.writeFileSync(tmpFile, clamped, "utf-8")
+        tmpFile = writePromptToTmpFile(clamped, projectRoot, "sg-")
         debugLog("[sensor-gate] temp file created:", tmpFile)
       } catch (e) {
-        debugLog("[sensor-gate] failed to create tmp file, falling back to --prompt arg:", e)
-        tmpFile = ""
+        // Temp file creation failed — do NOT fall back to --prompt CLI arg
+        // which would leak the prompt in process listings.
+        debugLog("[sensor-gate] failed to create tmp file:", e)
+        return Effect.fail(new Error(`[sensor-gate] Failed to create temp file for prompt: ${e}`))
       }
 
       // Cross-platform Python resolution with fallback chain.
@@ -617,9 +601,7 @@ function runSensorGateEffect(
           debugLog("[sensor-gate] sensor gate script:", sensorGate)
           for (const cmd of pythonCmds) {
             const versionArgs = getPythonArgs(cmd)
-            const args = tmpFile
-              ? [cmd, ...versionArgs, sensorGate, "--prompt-file", tmpFile]
-              : [cmd, ...versionArgs, sensorGate, "--prompt", clamped]
+            const args = [cmd, ...versionArgs, sensorGate, "--prompt-file", tmpFile]
             debugLog("[sensor-gate] trying:", cmd, "args:", args)
             try {
               proc = Bun.spawn(args, {
@@ -627,9 +609,7 @@ function runSensorGateEffect(
                 stdout: "pipe",
                 stderr: "pipe",
                 env: {
-                  PATH: process.env.PATH,
-                  HOME: process.env.HOME,
-                  PYTHONPATH: process.env.PYTHONPATH ?? "",
+                  ...BASE_SUBPROCESS_ENV,
                   PROJECT_ROOT: projectRoot,
                 },
               })
@@ -667,10 +647,7 @@ function runSensorGateEffect(
         try { proc.kill(9) } catch {}
       }
       // Clean up temp file
-      if (tmpFile) {
-        try { fs.unlinkSync(tmpFile) } catch {}
-        try { fs.rmdirSync(tmpDir) } catch {}
-      }
+      cleanupTmpFile(tmpFile)
       if (!output) {
         debugLog("[sensor-gate] empty output from subprocess — returning default result")
         return parseSensorGateOutput("")
@@ -721,26 +698,14 @@ function runNeuroHarnessEffect(
 
   const runWithTimeout = (timeoutMs: number) =>
     Effect.gen(function* () {
-      const tmpBase = resolveTmpBase(projectRoot)
-      try { fs.mkdirSync(tmpBase, { recursive: true }) } catch (e) {
-        debugLog("[sensor-gate] failed to create tmp base dir:", String(e), "tmpBase:", tmpBase)
-      }
-      let tmpDir = ""
-      try {
-        tmpDir = fs.mkdtempSync(path.join(tmpBase, "neuro-"))
-        if (!isWindows()) fs.chmodSync(tmpDir, 0o700)
-      } catch {}
-      const tmpFile = tmpDir ? path.join(tmpDir, "prompt.txt") : ""
+      let tmpFile = ""
       try {
         const promptResult = buildPrompt({
           scanType,
           files: [{ path: "user_prompt", content: clamped }],
           context: clamped.slice(0, 8000),
         })
-
-        if (tmpFile) {
-          fs.writeFileSync(tmpFile, promptResult.userPrompt, { mode: 0o600 })
-        }
+        tmpFile = writePromptToTmpFile(promptResult.userPrompt, projectRoot, "neuro-")
 
         const automationContext = JSON.stringify({
           task: clamped,
@@ -758,16 +723,14 @@ function runNeuroHarnessEffect(
               ...versionArgs,
               neuroHarness,
               "--scan-type", scanType,
-              ...(tmpFile ? ["--file", tmpFile] : ["--prompt", clamped.slice(0, 8000)]),
+              "--file", tmpFile,
               "--task", clamped.slice(0, 8000),
               "--automation-context", automationContext,
             ], {
               cwd: projectRoot,
               stdio: ["pipe", "pipe", "pipe"],
               env: {
-                PATH: process.env.PATH,
-                HOME: process.env.HOME,
-                PYTHONPATH: process.env.PYTHONPATH ?? "",
+                ...BASE_SUBPROCESS_ENV,
                 NEURO_API_KEY: process.env.NEUCODE_NEURO_API_KEY ?? process.env.NEURO_API_KEY ?? "",
                 PROJECT_ROOT: projectRoot,
               },
@@ -786,7 +749,7 @@ function runNeuroHarnessEffect(
         debugLog("[sensor-gate] runNeuroHarness subprocess failed:", String(e), "timeoutMs:", timeoutMs)
         return null
       } finally {
-        try { fs.rmSync(tmpDir, { recursive: true, force: true }) } catch {}
+        cleanupTmpFile(tmpFile)
       }
     }).pipe(
       Effect.catch(() => Effect.succeed(null) as Effect.Effect<string | null>),
diff --git a/packages/opencode/src/skill/token-predictor.ts b/packages/opencode/src/skill/token-predictor.ts
index 5706c3f3e0..8e996f81fe 100644
--- a/packages/opencode/src/skill/token-predictor.ts
+++ b/packages/opencode/src/skill/token-predictor.ts
@@ -13,10 +13,9 @@
  */
 
 import { Effect } from "effect"
-import { resolvePythonCommand, resolveSkillsDir, getPythonArgs } from "./python-resolver.js"
+import { resolvePythonCommand, resolveSkillsDir, getPythonArgs, writePromptToTmpFile, cleanupTmpFile, validateScriptPath, BASE_SUBPROCESS_ENV } from "./python-resolver.js"
 import { createCircuitBreaker, type CircuitBreaker } from "./circuit-breaker.js"
 import { createHash } from "crypto"
-import { validateScriptPath } from "./chain-executor.js"
 import path from "path"
 
 // ---------------------------------------------------------------------------
@@ -115,13 +114,21 @@ const generateImpl = (params: {
       return yield* Effect.fail(`Script path validation failed: ${scriptPath}`)
     }
 
+    // Write prompt to temp file — avoids leaking it in process listings
+    let tmpFile = ""
+    try {
+      tmpFile = writePromptToTmpFile(params.prompt, params.projectRoot || process.cwd(), "tp-")
+    } catch (e) {
+      return yield* Effect.fail(`Failed to create temp file for prompt: ${e}`)
+    }
+
     // Build args
     const args: string[] = [
       ...pythonArgs,
       scriptPath,
       "--json",
-      "--prompt",
-      params.prompt,
+      "--prompt-file",
+      tmpFile,
       "--count",
       String(params.count ?? 5),
     ]
@@ -141,13 +148,10 @@ const generateImpl = (params: {
         const proc = Bun.spawn([pythonCmd, ...args], {
           stdout: "pipe",
           stderr: "pipe",
-          env: {
-            PATH: process.env.PATH,
-            HOME: process.env.HOME,
-            PYTHONPATH: process.env.PYTHONPATH ?? "",
-            NEURO_API_KEY: process.env.NEUCODE_NEURO_API_KEY ?? process.env.NEURO_API_KEY ?? "",
-            PROJECT_ROOT: params.projectRoot || process.cwd(),
-          },
+        env: {
+          ...BASE_SUBPROCESS_ENV,
+          PROJECT_ROOT: params.projectRoot || process.cwd(),
+        },
         })
 
         const timeout = setTimeout(() => {
@@ -188,7 +192,7 @@ const generateImpl = (params: {
         project_context: string
         timestamp: string
       },
-      catch: () => `Failed to parse predictor output: ${result.stdout.slice(0, 200)}`,
+      catch: () => `Failed to parse predictor output: ${result.stdout.slice(0, 500)}`,
     })
 
     predictorBreaker.recordSuccess()
@@ -200,6 +204,9 @@ const generateImpl = (params: {
       category: categorizeQuestion(q),
     }))
 
+    // Clean up temp file
+    cleanupTmpFile(tmpFile)
+
     return {
       questions,
       contextHash: parsed.context_hash,
diff --git a/packages/opencode/src/tool/skill.ts b/packages/opencode/src/tool/skill.ts
index eeefb54791..8a644407c8 100644
--- a/packages/opencode/src/tool/skill.ts
+++ b/packages/opencode/src/tool/skill.ts
@@ -12,7 +12,7 @@ import * as Tool from "./tool"
 import * as path from "path"
 import * as fs from "fs"
 import DESCRIPTION from "./skill.txt"
-import { resolvePythonCommand, getPythonArgs, resolveSkillsDir, HOME } from "@/skill/python-resolver"
+import { resolvePythonCommand, getPythonArgs, resolveSkillsDir, HOME, writePromptToTmpFile, cleanupTmpFile } from "@/skill/python-resolver"
 
 const SKILLS_DIR = resolveSkillsDir()
 const CHAIN_LOG = path.join(HOME, ".dreamcode", "chain_log.jsonl")
@@ -133,26 +133,18 @@ function sanitizeSensorGateOutput(raw: string): string {
 // Unix socket EOF issue in compiled binaries.
 const runSensorGateAsync = Effect.fn("SkillTool.runSensorGate")(function* (prompt: string) {
   if (!SENSOR_GATE || !fs.existsSync(SENSOR_GATE)) return ""
-  const tmpBase = process.env.XDG_RUNTIME_DIR
-    ? path.join(process.env.XDG_RUNTIME_DIR, "dreamcode")
-    : path.join(HOME, ".dreamcode", "tmp")
-  let tmpDir = ""
   let tmpFile = ""
   try {
-    fs.mkdirSync(tmpBase, { recursive: true })
-    tmpDir = fs.mkdtempSync(path.join(tmpBase, "sg-"))
-    fs.chmodSync(tmpDir, 0o700)
-    tmpFile = path.join(tmpDir, "prompt.txt")
-    fs.writeFileSync(tmpFile, prompt, "utf-8")
-  } catch {
-    tmpFile = ""
+    tmpFile = writePromptToTmpFile(prompt, process.cwd(), "sg-")
+  } catch (e) {
+    // Temp file creation failed — do NOT fall back to --prompt CLI arg
+    // which would leak the prompt in process listings.
+    return Effect.fail(new Error(`[skill-tool] Failed to create temp file for prompt: ${e}`))
   }
   // Cross-platform Python resolution
   const pythonCmd = resolvePythonCommand()
   const versionArgs = getPythonArgs()
-  const args = tmpFile
-    ? [pythonCmd, ...versionArgs, SENSOR_GATE!, "--prompt-file", tmpFile]
-    : [pythonCmd, ...versionArgs, SENSOR_GATE!, "--prompt", prompt]
+  const args = [pythonCmd, ...versionArgs, SENSOR_GATE!, "--prompt-file", tmpFile]
   return yield* Effect.tryPromise({
     try: async () => {
       const proc = Bun.spawn(args, {
@@ -162,18 +154,12 @@ const runSensorGateAsync = Effect.fn("SkillTool.runSensorGate")(function* (promp
       const text = await proc.stdout.text()
       await proc.exited
       // Clean up temp file
-      if (tmpFile) {
-        try { fs.unlinkSync(tmpFile) } catch {}
-        try { fs.rmdirSync(tmpDir) } catch {}
-      }
+      cleanupTmpFile(tmpFile)
       return text || ""
     },
     catch: (err) => {
       // Clean up temp file on error too
-      if (tmpFile) {
-        try { fs.unlinkSync(tmpFile) } catch {}
-        try { fs.rmdirSync(tmpDir) } catch {}
-      }
+      cleanupTmpFile(tmpFile)
       return new Error(String(err))
     },
   }).pipe(
@@ -186,26 +172,18 @@ const runSensorGateAsync = Effect.fn("SkillTool.runSensorGate")(function* (promp
 // Prompt is written to a temp file instead of stdin pipe to avoid Bun.spawn
 // Unix socket EOF issue in compiled binaries.
 const runSkillScriptAsync = Effect.fn("SkillTool.runSkillScript")(function* (script: string, prompt: string) {
-  const tmpBase = process.env.XDG_RUNTIME_DIR
-    ? path.join(process.env.XDG_RUNTIME_DIR, "dreamcode")
-    : path.join(HOME, ".dreamcode", "tmp")
-  let tmpDir = ""
   let tmpFile = ""
   try {
-    fs.mkdirSync(tmpBase, { recursive: true })
-    tmpDir = fs.mkdtempSync(path.join(tmpBase, "sk-"))
-    fs.chmodSync(tmpDir, 0o700)
-    tmpFile = path.join(tmpDir, "prompt.txt")
-    fs.writeFileSync(tmpFile, prompt, "utf-8")
-  } catch {
-    tmpFile = ""
+    tmpFile = writePromptToTmpFile(prompt, process.cwd(), "sk-")
+  } catch (e) {
+    // Temp file creation failed — do NOT fall back to --prompt CLI arg
+    // which would leak the prompt in process listings.
+    return Effect.fail(new Error(`[skill-tool] Failed to create temp file for prompt: ${e}`))
   }
   // Cross-platform Python resolution
   const pythonCmd = resolvePythonCommand()
   const versionArgs = getPythonArgs()
-  const args = tmpFile
-    ? [pythonCmd, ...versionArgs, script, "--prompt-file", tmpFile]
-    : [pythonCmd, ...versionArgs, script, "--prompt", prompt]
+  const args = [pythonCmd, ...versionArgs, script, "--prompt-file", tmpFile]
   return yield* Effect.tryPromise({
     try: async () => {
       const proc = Bun.spawn(args, {
@@ -214,19 +192,11 @@ const runSkillScriptAsync = Effect.fn("SkillTool.runSkillScript")(function* (scr
       })
       const text = await proc.stdout.text()
       await proc.exited
-      // Clean up temp file
-      if (tmpFile) {
-        try { fs.unlinkSync(tmpFile) } catch {}
-        try { fs.rmdirSync(tmpDir) } catch {}
-      }
+      cleanupTmpFile(tmpFile)
       return text || ""
     },
     catch: (err) => {
-      // Clean up temp file on error too
-      if (tmpFile) {
-        try { fs.unlinkSync(tmpFile) } catch {}
-        try { fs.rmdirSync(tmpDir) } catch {}
-      }
+      cleanupTmpFile(tmpFile)
       return new Error(String(err))
     },
   }).pipe(
diff --git a/packages/opencode/test/build/binary-regression.test.ts b/packages/opencode/test/build/binary-regression.test.ts
new file mode 100644
index 0000000000..232123d03f
--- /dev/null
+++ b/packages/opencode/test/build/binary-regression.test.ts
@@ -0,0 +1,73 @@
+/**
+ * Binary Regression Tests
+ *
+ * Validates the compiled dreamcode binary is healthy.
+ * These are live tests — they require the binary to exist at the expected path.
+ */
+
+import { describe, expect, test } from "bun:test"
+import { existsSync, statSync } from "fs"
+import { resolve } from "path"
+
+// Platform-aware binary path — resolves to the platform-appropriate dist dir.
+// The build script (script/build.ts) produces artifacts under
+// dist/dreamcode-{platform}-{arch}/bin/dreamcode[.exe].
+const PLATFORM_MAP: Record<string, string> = {
+  linux: "linux",
+  darwin: "darwin",
+  win32: "windows",
+}
+const plat = PLATFORM_MAP[process.platform] ?? "linux"
+const ext = process.platform === "win32" ? ".exe" : ""
+const BINARY = resolve(import.meta.dir, `../../dist/dreamcode-${plat}-x64/bin/dreamcode${ext}`)
+
+describe("binary regression", () => {
+  test("binary exists at expected path", () => {
+    expect(existsSync(BINARY)).toBe(true)
+  })
+
+  test("binary is executable", () => {
+    const stat = statSync(BINARY)
+    // Check that at least one execute bit is set
+    const isExecutable = (stat.mode & 0o111) !== 0
+    expect(isExecutable).toBe(true)
+  })
+
+  test("binary is non-empty", () => {
+    const stat = statSync(BINARY)
+    expect(stat.size).toBeGreaterThan(1_000_000) // Should be > 1MB
+  })
+
+  test(
+    "binary reports version via --version",
+    async () => {
+      // Increase timeout for this test — spawning the 175MB ELF binary can be
+      // slow when the test runner is under concurrent load from other suites.
+      const proc = Bun.spawnSync([BINARY, "--version"], {
+        stdin: "ignore",
+        stdout: "pipe",
+        stderr: "pipe",
+        env: { ...process.env, DREAMCODE_CI: "1" },
+      })
+      expect(proc.exitCode).toBe(0)
+      const output = proc.stdout.toString().trim()
+      // Should output semver like "1.3.4"
+      expect(output).toMatch(/^\d+\.\d+\.\d+/)
+    },
+    { timeout: 15000 },
+  )
+
+  test("binary produces help-like output on --help", () => {
+    // --help may exit non-zero or produce output to stderr; we just check it
+    // doesn't crash and produces some text on either stream.
+    const proc = Bun.spawnSync([BINARY, "--help"], {
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "pipe",
+      env: { ...process.env, DREAMCODE_CI: "1" },
+    })
+    // Accept any exit code — TUI may exit 0 or non-zero for unknown flags
+    const allOutput = (proc.stdout.toString() + proc.stderr.toString()).trim()
+    expect(allOutput.length).toBeGreaterThan(0)
+  })
+})
diff --git a/packages/opencode/test/skill/chain-executor.test.ts b/packages/opencode/test/skill/chain-executor.test.ts
index 0339efeadf..ef0b3edb34 100644
--- a/packages/opencode/test/skill/chain-executor.test.ts
+++ b/packages/opencode/test/skill/chain-executor.test.ts
@@ -146,46 +146,12 @@ describe("ChainExecutor", () => {
   it.live("runFullPipeline returns array when no skills dir", () =>
     Effect.gen(function* () {
       const executor = yield* ChainExecutor.Service
-      const results = yield* executor.runFullPipeline(["nonexistent-skill"], "test prompt")
+      const results = yield* executor.runFullPipeline()
       expect(Array.isArray(results)).toBe(true)
     }),
   )
 })
 
-// ─────────────────────────────────────────────────────────────
-// validateScriptPath pure function tests
-// ─────────────────────────────────────────────────────────────
-
-describe("validateScriptPath", () => {
-  const cwd = "/tmp/test-project"
-
-  test("rejects empty string", () => {
-    expect(ChainExecutor.validateScriptPath("", cwd)).toBe(false)
-  })
-
-  test("rejects path traversal escape", () => {
-    const malicious = "/tmp/test-project/.dreamcode/skills/../../etc/passwd"
-    expect(ChainExecutor.validateScriptPath(malicious, cwd)).toBe(false)
-  })
-
-  test("rejects path pointing outside allowed dirs", () => {
-    expect(ChainExecutor.validateScriptPath("/bin/sh", cwd)).toBe(false)
-  })
-
-  test("rejects absolute path outside project", () => {
-    expect(ChainExecutor.validateScriptPath("/usr/local/bin/malware", cwd)).toBe(false)
-  })
-
-  test("rejects relative path that escapes cwd", () => {
-    const resolved = "/tmp/test-project/../../../etc/passwd"
-    expect(ChainExecutor.validateScriptPath(resolved, cwd)).toBe(false)
-  })
-
-  test("rejects non-absolute path", () => {
-    expect(ChainExecutor.validateScriptPath("relative/path/script.py", cwd)).toBe(false)
-  })
-})
-
 // ─────────────────────────────────────────────────────────────
 // Integration: real skill with scripts via tmpdir
 // ─────────────────────────────────────────────────────────────
@@ -386,7 +352,7 @@ describe("ChainExecutor integration (tmpdir)", () => {
     Effect.gen(function* () {
       const executor = yield* ChainExecutor.Service
       const verifyResult = yield* executor.verify([
-        { name: "test", output: "ok", status: "ok" },
+        { name: "test", output: "ok", status: "ok", executionType: "content" },
       ])
       // With no skills dir, verify should return a visible warning, not empty string
       expect(typeof verifyResult).toBe("string")
@@ -394,13 +360,19 @@ describe("ChainExecutor integration (tmpdir)", () => {
     }),
   )
 
-  it.instance("runFullPipeline returns error result when orchestrator not found", () =>
+  it.instance("runFullPipeline returns ChainResult[] (error or empty) when orchestrator not found", () =>
     Effect.gen(function* () {
       const executor = yield* ChainExecutor.Service
-      const results = yield* executor.runFullPipeline(["nonexistent-skill"], "test prompt")
-      // Should either return a result (if orchestrator exists) or empty array
-      // But should NOT throw or hang
+      const results = yield* executor.runFullPipeline()
+      // Should NOT throw or hang
       expect(Array.isArray(results)).toBe(true)
+      // Every result has the expected shape
+      for (const r of results) {
+        expect(typeof r.name).toBe("string")
+        expect(typeof r.output).toBe("string")
+        expect(["ok", "not_found", "error"]).toContain(r.status)
+        expect(["script", "content"]).toContain(r.executionType)
+      }
     }),
   )
 })
diff --git a/packages/opencode/test/skill/prompt-engine.test.ts b/packages/opencode/test/skill/prompt-engine.test.ts
new file mode 100644
index 0000000000..e1aed58e7a
--- /dev/null
+++ b/packages/opencode/test/skill/prompt-engine.test.ts
@@ -0,0 +1,149 @@
+import { describe, expect, it } from "bun:test"
+import { buildPrompt, getSupportedScanTypes } from "../../src/skill/prompt-engine"
+
+describe("prompt-engine", () => {
+  describe("buildPrompt", () => {
+    it("returns full_audit system prompt for unknown scan type", () => {
+      const result = buildPrompt({
+        scanType: "nonexistent",
+        files: [{ path: "test.ts", content: "const x = 1" }],
+      })
+      expect(result.scanType).toBe("nonexistent")
+      expect(result.systemPrompt).toContain("expert software architect")
+      expect(result.fileCount).toBe(1)
+    })
+
+    it("returns security system prompt for security scan type", () => {
+      const result = buildPrompt({
+        scanType: "security",
+        files: [{ path: "auth.ts", content: "const token = 'abc'" }],
+      })
+      expect(result.systemPrompt).toContain("security expert")
+      expect(result.systemPrompt).toContain("OWASP Top 10")
+    })
+
+    it("returns bug_hunt system prompt", () => {
+      const result = buildPrompt({
+        scanType: "bug_hunt",
+        files: [{ path: "handler.ts", content: "function handle() {}" }],
+      })
+      expect(result.systemPrompt).toContain("debugging expert")
+      expect(result.systemPrompt).toContain("Race conditions")
+    })
+
+    it("returns test_gap system prompt", () => {
+      const result = buildPrompt({
+        scanType: "test_gap",
+        files: [{ path: "utils.ts", content: "export const add = (a: number, b: number) => a + b" }],
+      })
+      expect(result.systemPrompt).toContain("testing expert")
+      expect(result.systemPrompt).toContain("coverage gaps")
+    })
+
+    it("returns refactor system prompt", () => {
+      const result = buildPrompt({
+        scanType: "refactor",
+        files: [{ path: "big.ts", content: "function doEverything() { /* ... */ }" }],
+      })
+      expect(result.systemPrompt).toContain("refactoring expert")
+      expect(result.systemPrompt).toContain("Code duplication")
+    })
+
+    it("formats file contents with markdown code blocks", () => {
+      const result = buildPrompt({
+        scanType: "full_audit",
+        files: [{ path: "src/index.ts", content: "console.log('hello')" }],
+      })
+      expect(result.userPrompt).toContain("## File: src/index.ts")
+      expect(result.userPrompt).toContain("```")
+      expect(result.userPrompt).toContain("console.log('hello')")
+    })
+
+    it("handles multiple files", () => {
+      const result = buildPrompt({
+        scanType: "full_audit",
+        files: [
+          { path: "a.ts", content: "const a = 1" },
+          { path: "b.ts", content: "const b = 2" },
+        ],
+      })
+      expect(result.fileCount).toBe(2)
+      expect(result.userPrompt).toContain("## File: a.ts")
+      expect(result.userPrompt).toContain("## File: b.ts")
+    })
+
+    it("appends context when provided", () => {
+      const result = buildPrompt({
+        scanType: "full_audit",
+        files: [{ path: "x.ts", content: "const x = 1" }],
+        context: "This is a Express.js REST API",
+      })
+      expect(result.userPrompt).toContain("Additional context: This is a Express.js REST API")
+    })
+
+    it("does not append context when absent", () => {
+      const result = buildPrompt({
+        scanType: "full_audit",
+        files: [{ path: "x.ts", content: "const x = 1" }],
+      })
+      expect(result.userPrompt).not.toContain("Additional context:")
+    })
+
+    it("handles empty content gracefully", () => {
+      const result = buildPrompt({
+        scanType: "full_audit",
+        files: [{ path: "empty.ts", content: "" }],
+      })
+      expect(result.userPrompt).toContain("## File: empty.ts")
+      expect(result.userPrompt).toContain("```")
+    })
+
+    it("handles missing path gracefully", () => {
+      const result = buildPrompt({
+        scanType: "full_audit",
+        files: [{ path: "", content: "some code" }],
+      })
+      expect(result.userPrompt).toContain("## File: unknown")
+    })
+
+    it("estimates tokens based on character count / 4", () => {
+      const result = buildPrompt({
+        scanType: "full_audit",
+        files: [{ path: "t.ts", content: "abcd" }],
+      })
+      const expectedChars = result.systemPrompt.length + result.userPrompt.length
+      expect(result.estimatedTokens).toBe(Math.ceil(expectedChars / 4))
+    })
+
+    it("fileCount matches input array length", () => {
+      const result = buildPrompt({
+        scanType: "full_audit",
+        files: [
+          { path: "a.ts", content: "1" },
+          { path: "b.ts", content: "2" },
+          { path: "c.ts", content: "3" },
+        ],
+      })
+      expect(result.fileCount).toBe(3)
+    })
+  })
+
+  describe("getSupportedScanTypes", () => {
+    it("returns all 5 scan types", () => {
+      const types = getSupportedScanTypes()
+      expect(types).toHaveLength(5)
+      expect(types).toContain("full_audit")
+      expect(types).toContain("security")
+      expect(types).toContain("bug_hunt")
+      expect(types).toContain("test_gap")
+      expect(types).toContain("refactor")
+    })
+
+    it("returns a copy (not mutable reference)", () => {
+      const types1 = getSupportedScanTypes()
+      const types2 = getSupportedScanTypes()
+      expect(types1).toEqual(types2)
+      expect(types1).not.toBe(types2)
+    })
+  })
+})
diff --git a/packages/opencode/test/skill/python-resolver.test.ts b/packages/opencode/test/skill/python-resolver.test.ts
index 53b148d3b3..6b584e03e7 100644
--- a/packages/opencode/test/skill/python-resolver.test.ts
+++ b/packages/opencode/test/skill/python-resolver.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it, beforeEach, afterEach } from "bun:test"
-import { mkdirSync, writeFileSync, rmSync } from "fs"
+import { mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from "fs"
 import { join } from "path"
 import { tmpdir } from "os"
 import { randomBytes } from "crypto"
@@ -10,6 +10,9 @@ import {
   getPythonArgs,
   resolveSkillsDir,
   resolveScript,
+  validateScriptPath,
+  cleanupTmpFile,
+  writePromptToTmpFile,
   HOME,
 } from "../../src/skill/python-resolver"
 
@@ -147,3 +150,74 @@ describe("resolveScript", () => {
     }
   })
 })
+
+// ---------------------------------------------------------------------------
+// validateScriptPath — moved from chain-executor.test.ts
+// ---------------------------------------------------------------------------
+
+describe("validateScriptPath", () => {
+  const cwd = "/tmp/test-project"
+
+  it("rejects empty string", () => {
+    expect(validateScriptPath("", cwd)).toBe(false)
+  })
+
+  it("rejects path traversal escape", () => {
+    const malicious = "/tmp/test-project/.dreamcode/skills/../../etc/passwd"
+    expect(validateScriptPath(malicious, cwd)).toBe(false)
+  })
+
+  it("rejects path pointing outside allowed dirs", () => {
+    expect(validateScriptPath("/bin/sh", cwd)).toBe(false)
+  })
+
+  it("rejects absolute path outside project", () => {
+    expect(validateScriptPath("/usr/local/bin/malware", cwd)).toBe(false)
+  })
+
+  it("rejects relative path that escapes cwd", () => {
+    const resolved = "/tmp/test-project/../../../etc/passwd"
+    expect(validateScriptPath(resolved, cwd)).toBe(false)
+  })
+
+  it("rejects non-absolute path", () => {
+    expect(validateScriptPath("relative/path/script.py", cwd)).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// writePromptToTmpFile / cleanupTmpFile
+// ---------------------------------------------------------------------------
+
+describe("writePromptToTmpFile / cleanupTmpFile", () => {
+  const sandbox = join(tmpdir(), `dreamcode-tmpfile-test-${randomBytes(4).toString("hex")}`)
+  beforeEach(() => mkdirSync(sandbox, { recursive: true }))
+  afterEach(() => rmSync(sandbox, { recursive: true, force: true }))
+
+  it("writes and cleans up a temp file", () => {
+    const p = writePromptToTmpFile("hello world", sandbox, "test-")
+    expect(p).toBeTruthy()
+    expect(join("")).toBe(".") // sanity: path.join("") returns "." on POSIX
+    // File exists before cleanup
+    expect(existsSync(p)).toBe(true)
+    cleanupTmpFile(p)
+    // File is gone after cleanup
+    expect(existsSync(p)).toBe(false)
+  })
+
+  it("cleanupTmpFile does not throw on non-existent file", () => {
+    expect(() => cleanupTmpFile("/nonexistent/path")).not.toThrow()
+  })
+
+  it("cleanupTmpFile does not throw on empty string", () => {
+    expect(() => cleanupTmpFile("")).not.toThrow()
+  })
+
+  it("writes content that can be read back", () => {
+    const content = "test content 123"
+    const p = writePromptToTmpFile(content, sandbox, "verify-")
+    const actual = readFileSync(p, "utf-8")
+    expect(actual).toBe(content)
+    cleanupTmpFile(p)
+  })
+})
diff --git a/packages/opencode/test/skill/sensor-gate-enforcer.test.ts b/packages/opencode/test/skill/sensor-gate-enforcer.test.ts
new file mode 100644
index 0000000000..ede954a054
--- /dev/null
+++ b/packages/opencode/test/skill/sensor-gate-enforcer.test.ts
@@ -0,0 +1,52 @@
+import { describe, expect, test } from "bun:test"
+import { SensorGateEnforcerPlugin } from "@/skill/sensor-gate-enforcer"
+
+describe("SensorGateEnforcerPlugin", () => {
+  test("returns a plugin instance (async function)", () => {
+    const instance = SensorGateEnforcerPlugin({} as any)
+    expect(typeof instance).toBe("function")
+  })
+
+  test("plugin instance returns a hooks object", async () => {
+    const instance = SensorGateEnforcerPlugin({} as any)
+    const hooks = await instance()
+    expect(hooks).toBeDefined()
+    expect(typeof hooks).toBe("object")
+    expect(hooks).toHaveProperty(["chat.message"])
+    expect(hooks).toHaveProperty(["experimental.chat.system.transform"])
+    expect(typeof hooks["chat.message"]).toBe("function")
+    expect(typeof hooks["experimental.chat.system.transform"]).toBe("function")
+  })
+
+  test("chat.message handler skips on empty prompt", async () => {
+    const instance = SensorGateEnforcerPlugin({} as any)
+    const hooks = await instance()
+    // Should not throw when given an empty prompt
+    const chatMessage = hooks["chat.message"]!
+    await expect(
+      chatMessage(
+        { client: { directory: "/tmp" }, sessionID: "test-1" } as any,
+        { parts: [] } as any,
+      ),
+    ).resolves.toBeUndefined()
+
+    await expect(
+      chatMessage(
+        { client: { directory: "/tmp" }, sessionID: "test-1" } as any,
+        { parts: [{ type: "text", text: "   " }] } as any,
+      ),
+    ).resolves.toBeUndefined()
+  })
+
+  test("transform handler does not throw when no session state exists", async () => {
+    const instance = SensorGateEnforcerPlugin({} as any)
+    const hooks = await instance()
+    const transform = hooks["experimental.chat.system.transform"]!
+    await expect(
+      transform(
+        { client: { directory: "/tmp" }, sessionID: "nonexistent" } as any,
+        { system: "" } as any,
+      ),
+    ).resolves.toBeUndefined()
+  })
+})
diff --git a/packages/opencode/test/skill/sensor-gate.integration.test.ts b/packages/opencode/test/skill/sensor-gate.integration.test.ts
new file mode 100644
index 0000000000..60b32cc715
--- /dev/null
+++ b/packages/opencode/test/skill/sensor-gate.integration.test.ts
@@ -0,0 +1,84 @@
+/**
+ * Sensor Gate Integration Tests
+ *
+ * Tests that the real Python classifier subprocess works end-to-end.
+ * These are live tests — they require Python3 and the classifier script.
+ */
+
+import { describe, expect, test } from "bun:test"
+import { resolvePythonCommand, getPythonArgs } from "../../src/skill/python-resolver"
+import path from "path"
+
+const SCRIPT_TIMEOUT = 15_000
+
+// Point directly at the source tree skills so integration tests work in dev
+const SKILLS_DIR = path.resolve(import.meta.dir, "../../src/skill/dreamcode/skills")
+
+describe("sensor gate integration (Python subprocess)", () => {
+  test("classifier.py produces valid JSON output", async () => {
+    const classifierScript = path.join(SKILLS_DIR, "chain-orchestrator", "scripts", "classifier.py")
+    const pythonCmd = resolvePythonCommand()
+    const pythonArgs = getPythonArgs()
+
+    const proc = Bun.spawn([pythonCmd, ...pythonArgs, classifierScript, "--prompt", "fix the login button color", "--json"], {
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "pipe",
+    })
+
+    const timeout = setTimeout(() => proc.kill(), SCRIPT_TIMEOUT)
+    const exitCode = await proc.exited
+    clearTimeout(timeout)
+    const stdout = await new Response(proc.stdout).text()
+    const stderr = await new Response(proc.stderr).text()
+
+    expect(exitCode).toBe(0)
+    expect(stderr).toBe("")
+
+    // Should produce parseable JSON
+    const parsed = JSON.parse(stdout)
+    expect(parsed).toBeDefined()
+    expect(typeof parsed).toBe("object")
+    // Classifier returns primary_task/detected_tasks/chain etc.
+    expect(parsed).toHaveProperty("primary_task")
+    expect(typeof parsed.primary_task).toBe("string")
+  }, SCRIPT_TIMEOUT + 5000)
+
+  test("classifier.py handles minimal prompt", async () => {
+    const classifierScript = path.join(SKILLS_DIR, "chain-orchestrator", "scripts", "classifier.py")
+    const pythonCmd = resolvePythonCommand()
+
+    const proc = Bun.spawn([pythonCmd, classifierScript, "--prompt", "a", "--json"], {
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "pipe",
+    })
+
+    const timeout = setTimeout(() => proc.kill(), SCRIPT_TIMEOUT)
+    const exitCode = await proc.exited
+    clearTimeout(timeout)
+
+    // Minimal prompt should exit 0 with default-classified JSON
+    expect(exitCode).toBe(0)
+  }, SCRIPT_TIMEOUT + 5000)
+
+  test("classifier.py --help produces usage text", async () => {
+    const classifierScript = path.join(SKILLS_DIR, "chain-orchestrator", "scripts", "classifier.py")
+    const pythonCmd = resolvePythonCommand()
+
+    const proc = Bun.spawn([pythonCmd, classifierScript, "--help"], {
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "pipe",
+    })
+
+    const timeout = setTimeout(() => proc.kill(), SCRIPT_TIMEOUT)
+    const exitCode = await proc.exited
+    clearTimeout(timeout)
+    const stdout = await new Response(proc.stdout).text()
+
+    expect(exitCode).toBe(0)
+    expect(stdout).toContain("usage:")
+    expect(stdout).toContain("--prompt")
+  }, SCRIPT_TIMEOUT + 5000)
+})
diff --git a/packages/opencode/test/skill/sensor-gate.test.ts b/packages/opencode/test/skill/sensor-gate.test.ts
index 0687e21181..5d30964ab7 100644
--- a/packages/opencode/test/skill/sensor-gate.test.ts
+++ b/packages/opencode/test/skill/sensor-gate.test.ts
@@ -12,6 +12,7 @@ import {
   evaluateSpawnNecessity,
   selectPersonas,
   validateNeuroOutput,
+  depthScore,
   type SensorGateResult,
   type Persona,
 } from "../../src/skill/sensor-gate"
@@ -165,6 +166,36 @@ describe("parseSensorGateOutput", () => {
     const result = parseSensorGateOutput(output)
     expect(result.raw_output).toBe(output)
   })
+
+  test("invalid risk_level defaults to medium", () => {
+    const output = "- risk_level: critical"
+    const result = parseSensorGateOutput(output)
+    expect(result.risk_level).toBe("medium")
+  })
+
+  test("risk_level low is accepted", () => {
+    const output = "- risk_level: low"
+    const result = parseSensorGateOutput(output)
+    expect(result.risk_level).toBe("low")
+  })
+
+  test("risk_level high is accepted", () => {
+    const output = "- risk_level: high"
+    const result = parseSensorGateOutput(output)
+    expect(result.risk_level).toBe("high")
+  })
+
+  test("confidence above 1 is clamped", () => {
+    const output = "- confidence: 2.5"
+    const result = parseSensorGateOutput(output)
+    expect(result.confidence).toBe(1)
+  })
+
+  test("negative confidence is clamped to 0", () => {
+    const output = "- confidence: -1"
+    const result = parseSensorGateOutput(output)
+    expect(result.confidence).toBe(0)
+  })
 })
 
 // ---------------------------------------------------------------------------
@@ -299,7 +330,7 @@ describe("selectPersonas", () => {
     })
     const personas = selectPersonas(result)
     // Should select security-related personas due to matching tags
-    expect(personas.length).toBeGreaterThanOrEqual(0)
+    expect(personas.length).toBeGreaterThanOrEqual(1)
   })
 
   test("no matching tags → 0 personas for low complexity", () => {
@@ -404,3 +435,86 @@ describe("validateNeuroOutput", () => {
     expect(result).toBe(JSON.stringify({ status: "success", step: 2 }))
   })
 })
+
+// ---------------------------------------------------------------------------
+// depthScore
+// ---------------------------------------------------------------------------
+
+describe("depthScore", () => {
+  test("empty inputs → minimum score is 1", () => {
+    // Even with empty inputs, the formula (risk + tagDiversity + chainDepth) / 3
+    // with risk=1 (low) gives Math.ceil(1/3) = 1
+    const result = depthScore(makeResult({ domain_tags: [], chain: [], risk_level: "low" }))
+    expect(result).toBe(1)
+  })
+
+  test("single domain, short chain, low risk → 1", () => {
+    const result = depthScore(makeResult({
+      domain_tags: ["typescript"],
+      chain: ["general"],
+      risk_level: "low",
+    }))
+    expect(result).toBe(1)
+  })
+
+  test("medium risk, moderate domains → 3", () => {
+    const result = depthScore(makeResult({
+      domain_tags: ["typescript", "react"],
+      chain: ["general", "frontend"],
+      risk_level: "medium",
+    }))
+    expect(result).toBeGreaterThanOrEqual(2)
+    expect(result).toBeLessThanOrEqual(4)
+  })
+
+  test("high risk, many domains, long chain → 4 (ceiling of (3+5+4)/3 = 4)", () => {
+    // risk=3 (high), tagDiversity=5, chainDepth=4 (capped)
+    // result = ceil((3+5+4)/3) = ceil(12/3) = 4
+    const result = depthScore(makeResult({
+      domain_tags: ["typescript", "react", "security", "database", "api"],
+      chain: ["general", "security", "quality", "testing", "frontend"],
+      risk_level: "high",
+    }))
+    expect(result).toBe(4)
+  })
+
+  test("handles empty domain_tags", () => {
+    const result = depthScore(makeResult({ domain_tags: [], chain: ["general"], risk_level: "low" }))
+    expect(result).toBeGreaterThanOrEqual(0)
+    expect(result).toBeLessThanOrEqual(5)
+  })
+
+  test("handles empty chain", () => {
+    const result = depthScore(makeResult({ domain_tags: ["typescript"], chain: [], risk_level: "low" }))
+    expect(result).toBeGreaterThanOrEqual(0)
+    expect(result).toBeLessThanOrEqual(5)
+  })
+
+  test("clamps to 0-5 range", () => {
+    const low = depthScore(makeResult({ domain_tags: [], chain: [], risk_level: "low" }))
+    const high = depthScore(makeResult({
+      domain_tags: ["a", "b", "c", "d", "e"],
+      chain: ["1", "2", "3", "4", "5", "6", "7"],
+      risk_level: "high",
+    }))
+    expect(low).toBeGreaterThanOrEqual(0)
+    expect(high).toBeLessThanOrEqual(5)
+  })
+
+  test("DREAM_INNOVATION mode does not affect depthScore directly", () => {
+    // depthScore is mode-agnostic — mode bonus is applied in selectPersonas
+    const standard = depthScore(makeResult({
+      mode: "STANDARD",
+      domain_tags: ["typescript"],
+      chain: ["general"],
+      risk_level: "low",
+    }))
+    const dream = depthScore(makeResult({
+      mode: "DREAM_INNOVATION",
+      domain_tags: ["typescript"],
+      chain: ["general"],
+      risk_level: "low",
+    }))
+    expect(standard).toBe(dream)
+  })
+})
diff --git a/packages/opencode/test/skill/skills-integrity.test.ts b/packages/opencode/test/skill/skills-integrity.test.ts
index 24e34b5b6c..7a41f5f36c 100644
--- a/packages/opencode/test/skill/skills-integrity.test.ts
+++ b/packages/opencode/test/skill/skills-integrity.test.ts
@@ -4,14 +4,18 @@ import path from "path"
 
 const skillsDir = path.resolve(import.meta.dir, "../../src/skill/dreamcode/skills")
 
+function readSkillDirs(): fs.Dirent[] {
+  return fs.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory())
+}
+
 describe("embedded skills integrity", () => {
   it("contains all 40 expected skill directories", () => {
-    const dirs = fs.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory())
+    const dirs = readSkillDirs()
     expect(dirs.length).toBe(40)
   })
 
   it("includes chain-orchestrator, effect, research, security, neuro", () => {
-    const names = fs.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name)
+    const names = readSkillDirs().map((d) => d.name)
     expect(names).toContain("chain-orchestrator")
     expect(names).toContain("effect")
     expect(names).toContain("research")
@@ -20,16 +24,14 @@ describe("embedded skills integrity", () => {
   })
 
   it("all skills have a SKILL.md", () => {
-    const dirs = fs.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory())
-    for (const dir of dirs) {
+    for (const dir of readSkillDirs()) {
       const skillMd = path.join(skillsDir, dir.name, "SKILL.md")
       expect(fs.existsSync(skillMd)).toBe(true)
     }
   })
 
   it("all skills with scripts/ directories have at least one .py file", () => {
-    const dirs = fs.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory())
-    for (const dir of dirs) {
+    for (const dir of readSkillDirs()) {
       const scriptsDir = path.join(skillsDir, dir.name, "scripts")
       if (fs.existsSync(scriptsDir)) {
         const pyFiles = fs.readdirSync(scriptsDir).filter((f) => f.endsWith(".py"))
@@ -44,4 +46,47 @@ describe("embedded skills integrity", () => {
     expect(pyFiles).toContain("orchestrator.py")
     expect(pyFiles).toContain("sensor_gate.py")
   })
+
+  it("all SKILL.md files have parseable YAML frontmatter", () => {
+    for (const dir of readSkillDirs()) {
+      const skillMd = path.join(skillsDir, dir.name, "SKILL.md")
+      const content = fs.readFileSync(skillMd, "utf-8")
+      // Frontmatter is delimited by --- at start and end
+      const match = content.match(/^---\n(.*?)\n---/s)
+      expect(match).not.toBeNull()
+      expect(match![1].length).toBeGreaterThan(0)
+    }
+  })
+
+  it("all SKILL.md files have non-empty name and description", () => {
+    for (const dir of readSkillDirs()) {
+      const skillMd = path.join(skillsDir, dir.name, "SKILL.md")
+      const content = fs.readFileSync(skillMd, "utf-8")
+      const match = content.match(/^---\n(.*?)\n---/s)
+      expect(match).not.toBeNull()
+      const frontmatter = match![1]
+
+      // Check for name field
+      expect(frontmatter).toMatch(/^name:/m)
+      const nameLine = frontmatter.match(/^name:\s*(.+)$/m)
+      expect(nameLine).not.toBeNull()
+      expect(nameLine![1].trim().length).toBeGreaterThan(0)
+
+      // Check for description field (inline or multi-line)
+      if (frontmatter.includes("description:")) {
+        // Multi-line description uses | or > after "description:"
+        if (frontmatter.match(/^description:\s*[|>]/m)) {
+          // Multi-line — just ensure there's content after
+          expect(frontmatter).toMatch(/^description:/m)
+        } else {
+          // Inline — check non-empty
+          const descLine = frontmatter.match(/^description:\s*(.+)$/m)
+          expect(descLine![1].trim().length).toBeGreaterThan(0)
+        }
+      } else {
+        // description field is optional for some skills
+        // If it's missing, that's also OK
+      }
+    }
+  })
 })
diff --git a/packages/opencode/test/skill/token-predictor.integration.test.ts b/packages/opencode/test/skill/token-predictor.integration.test.ts
new file mode 100644
index 0000000000..a8203c2074
--- /dev/null
+++ b/packages/opencode/test/skill/token-predictor.integration.test.ts
@@ -0,0 +1,102 @@
+/**
+ * Token Predictor Integration Tests
+ *
+ * Tests that the real Python predictor subprocess works end-to-end.
+ * These are live tests — they require Python3 and the predict.py script.
+ */
+
+import { describe, expect, test } from "bun:test"
+import { resolvePythonCommand, getPythonArgs } from "../../src/skill/python-resolver"
+import path from "path"
+
+const SCRIPT_TIMEOUT = 15_000
+const SKILLS_DIR = path.resolve(import.meta.dir, "../../src/skill/dreamcode/skills")
+
+describe("token predictor integration (Python subprocess)", () => {
+  test("predict.py produces valid JSON output", async () => {
+    const predictorScript = path.join(SKILLS_DIR, "token-predictor", "scripts", "predict.py")
+    const pythonCmd = resolvePythonCommand()
+    const pythonArgs = getPythonArgs()
+
+    const proc = Bun.spawn(
+      [pythonCmd, ...pythonArgs, predictorScript, "--prompt", "test the login feature", "--json", "--count", "3"],
+      {
+        stdin: "ignore",
+        stdout: "pipe",
+        stderr: "pipe",
+      },
+    )
+
+    const timeout = setTimeout(() => proc.kill(), SCRIPT_TIMEOUT)
+    const exitCode = await proc.exited
+    clearTimeout(timeout)
+    const stdout = await new Response(proc.stdout).text()
+    const stderr = await new Response(proc.stderr).text()
+
+    expect(exitCode).toBe(0)
+    expect(stderr).toBe("")
+
+    // Should produce parseable JSON with questions array
+    const parsed = JSON.parse(stdout)
+    expect(parsed).toBeDefined()
+    expect(Array.isArray(parsed.questions)).toBe(true)
+    expect(parsed.questions.length).toBeGreaterThan(0)
+    expect(parsed.questions.length).toBeLessThanOrEqual(3)
+    // Each question should be a non-empty string
+    for (const q of parsed.questions) {
+      expect(typeof q).toBe("string")
+      expect(q.length).toBeGreaterThan(0)
+    }
+  }, SCRIPT_TIMEOUT + 5000)
+
+  test("predict.py generates different questions for different prompts", async () => {
+    const predictorScript = path.join(SKILLS_DIR, "token-predictor", "scripts", "predict.py")
+    const pythonCmd = resolvePythonCommand()
+    const pythonArgs = getPythonArgs()
+
+    // Run for "security" prompt
+    const proc1 = Bun.spawn(
+      [pythonCmd, ...pythonArgs, predictorScript, "--prompt", "audit database security", "--json", "--count", "2"],
+      { stdout: "pipe", stderr: "pipe" },
+    )
+    const exit1 = await proc1.exited
+    const out1 = await new Response(proc1.stdout).text()
+    const parsed1 = JSON.parse(out1)
+
+    // Run for "ui" prompt
+    const proc2 = Bun.spawn(
+      [pythonCmd, ...pythonArgs, predictorScript, "--prompt", "change button color to blue", "--json", "--count", "2"],
+      { stdout: "pipe", stderr: "pipe" },
+    )
+    const exit2 = await proc2.exited
+    const out2 = await new Response(proc2.stdout).text()
+    const parsed2 = JSON.parse(out2)
+
+    expect(exit1).toBe(0)
+    expect(exit2).toBe(0)
+    // Different prompts should produce different questions
+    const q1 = parsed1.questions.join(" ")
+    const q2 = parsed2.questions.join(" ")
+    expect(q1).not.toBe(q2)
+  }, SCRIPT_TIMEOUT * 2 + 5000)
+
+  test("predict.py --help produces usage text", async () => {
+    const predictorScript = path.join(SKILLS_DIR, "token-predictor", "scripts", "predict.py")
+    const pythonCmd = resolvePythonCommand()
+
+    const proc = Bun.spawn([pythonCmd, predictorScript, "--help"], {
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "pipe",
+    })
+
+    const timeout = setTimeout(() => proc.kill(), SCRIPT_TIMEOUT)
+    const exitCode = await proc.exited
+    clearTimeout(timeout)
+    const stdout = await new Response(proc.stdout).text()
+
+    expect(exitCode).toBe(0)
+    expect(stdout).toContain("usage:")
+    expect(stdout).toContain("--prompt")
+  }, SCRIPT_TIMEOUT + 5000)
+})
diff --git a/turbo.json b/turbo.json
index 220cd96e58..3aa2b5b3fc 100644
--- a/turbo.json
+++ b/turbo.json
@@ -13,6 +13,11 @@
       "outputs": [],
       "passThroughEnv": ["*"]
     },
+    "opencode#test:integration": {
+      "dependsOn": ["^build"],
+      "outputs": [],
+      "passThroughEnv": ["*"]
+    },
     "@opencode-ai/app#test": {
       "dependsOn": ["^build"],
       "outputs": []