fix(sandbox): round 7 align spawn evidence

packages/bash/bash-sandbox/tests/partial-landlock.spec.ts

@@ -10,7 +10,7 @@ import { join } from 'node:path'
 import { afterEach, describe, expect, it } from 'vitest'
 import { Context } from 'cordis'
 import { LAUNCHER_FAILURE_EXIT } from 'node-addon-landlock-run'
-import { SANDBOX_UNAVAILABLE } from '@deepseek-ai/dsh-sandbox'
+import { SANDBOX_UNAVAILABLE, SandboxUnavailableError } from '@deepseek-ai/dsh-sandbox'
 import { LocalSandboxProvider } from '@deepseek-ai/dsh-sandbox-local'
 import { SandboxPolicyService } from '@deepseek-ai/dsh-sandbox-policy'
 import { SandboxBashExecutor } from '@deepseek-ai/dsh-bash-sandbox'
@@ -108,6 +108,55 @@ describe('partial Landlock runner-failure classification', () => {
     expect(accounting.size).toBe(0)
   })
 
+  it('classifies a bare-name runner whose shebang interpreter is missing', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'dsh-bare-sandbox-runner-'))
+    tempDirs.push(dir)
+    const runner = 'bare-missing-interpreter-runner'
+    await writeFile(join(dir, runner), '#!/dsh-definitely-missing-sandbox-interpreter\nexit 0\n', { mode: 0o755 })
+    const bash = await setupConfiguredRunner(runner)
+    const request = { command: 'true', env: { PATH: dir } }
+
+    const error = await bash.run(bash.resolve(request)).catch((value: unknown) => value)
+    expect(error).toMatchObject({ name: 'SandboxUnavailableError', code: SANDBOX_UNAVAILABLE })
+    expect(error).toBeInstanceOf(Error)
+    expect((error as Error).message).toContain(`spawn ${runner} ENOENT`)
+
+    const task = bash.start(bash.resolve(request))
+    await task.done
+    expect(task.readOutput().delta).toContain(`spawn failed: Error: spawn ${runner} ENOENT`)
+    expect(task.sandbox).toEqual({
+      mode: 'read-only',
+      denied: false,
+      enforcement: 'full',
+      runnerFailed: true,
+    })
+  })
+
+  it('keeps a real malformed executable ENOEXEC as an ordinary spawn failure', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'dsh-malformed-sandbox-runner-'))
+    tempDirs.push(dir)
+    const runner = join(dir, 'malformed-runner')
+    await writeFile(runner, 'not a native executable or shebang script\n', { mode: 0o755 })
+    const bash = await setupConfiguredRunner(runner)
+
+    const foreground = await bash.run(bash.resolve({ command: 'true' })).catch((value: unknown) => value)
+    expect(foreground).toMatchObject({ code: 'ENOEXEC', syscall: 'spawn' })
+    expect((foreground as { path?: unknown }).path).toBeUndefined()
+    expect(foreground).not.toBeInstanceOf(SandboxUnavailableError)
+
+    let background: unknown
+    try {
+      bash.start(bash.resolve({ command: 'true' }))
+    } catch (error) {
+      background = error
+    }
+    expect(background).toMatchObject({ code: 'ENOEXEC', syscall: 'spawn' })
+    expect((background as { path?: unknown }).path).toBeUndefined()
+    expect(background).not.toBeInstanceOf(SandboxUnavailableError)
+    const accounting = (bash as unknown as { processFacts: Map<unknown, unknown> }).processFacts
+    expect(accounting.size).toBe(0)
+  })
+
   it.each([0, 1, 2, LAUNCHER_FAILURE_EXIT])(
     'keeps child exit %i ordinary when the partial-enforcement notice is the only runner line',
     async (exitCode) => {

packages/bash/bash-sandbox/tests/sandbox.spec.ts

@@ -214,7 +214,7 @@ describe('fail closed', () => {
     }
   })
 
-  it('classifies synchronous ENOEXEC as runner loading failure in run() and start()', async () => {
+  it('keeps Node-shaped synchronous ENOEXEC ordinary in run() and start()', async () => {
     const runner = join(spillDir, 'malformed-runner')
     const { ctx, bash } = await setup({}, argv => ({
       argv: [runner, ...argv],
@@ -223,7 +223,33 @@ describe('fail closed', () => {
       runnerFailureRules: RUNNER_FAILURE,
     }))
     vi.spyOn(ctx.subprocess, 'spawn').mockImplementation(() => {
-      throw Object.assign(new Error('spawn ENOEXEC'), { code: 'ENOEXEC', syscall: 'spawn', path: runner })
+      throw Object.assign(new Error('spawn ENOEXEC'), { code: 'ENOEXEC', syscall: 'spawn' })
+    })
+
+    const foreground = await bash.run(bash.resolve({ command: 'true' })).catch((error: unknown) => error)
+    expect(foreground).toMatchObject({ code: 'ENOEXEC', syscall: 'spawn' })
+    expect(foreground).not.toBeInstanceOf(SandboxUnavailableError)
+
+    let background: unknown
+    try {
+      bash.start(bash.resolve({ command: 'true' }))
+    } catch (error) {
+      background = error
+    }
+    expect(background).toMatchObject({ code: 'ENOEXEC', syscall: 'spawn' })
+    expect(background).not.toBeInstanceOf(SandboxUnavailableError)
+  })
+
+  it('classifies a synchronous SubprocessService EACCES with exact runner provenance', async () => {
+    const runner = join(spillDir, 'unexecutable-runner')
+    const { ctx, bash } = await setup({}, argv => ({
+      argv: [runner, ...argv],
+      enforcement: 'full',
+      denialSignatures: UNIX_SIGNATURES,
+      runnerFailureRules: RUNNER_FAILURE,
+    }))
+    vi.spyOn(ctx.subprocess, 'spawn').mockImplementation(() => {
+      throw Object.assign(new Error('spawn EACCES'), { code: 'EACCES', syscall: 'spawn', path: runner })
     })
 
     await expect(bash.run(bash.resolve({ command: 'true' })))
@@ -359,7 +385,7 @@ describe('classifyDenial', () => {
 })
 
 describe('isRunnerSpawnFailure', () => {
-  it.each(['EACCES', 'ENOENT', 'ENOEXEC', 'ENOTDIR', 'EPERM'])(
+  it.each(['EACCES', 'ENOENT'])(
     'attributes executable-class spawn code %s to argv[0] once cwd ambiguity is eliminated',
     (code) => {
       const runner = join(spillDir, 'runner')
@@ -368,6 +394,15 @@ describe('isRunnerSpawnFailure', () => {
     },
   )
 
+  it.each(['ENOEXEC', 'ENOTDIR', 'EPERM'])(
+    'keeps unproven executable code %s ordinary despite synthetic argv[0] fields',
+    (code) => {
+      const runner = join(spillDir, 'runner')
+      const error = Object.assign(new Error('spawn failed'), { code, syscall: `spawn ${runner}`, path: runner })
+      expect(isRunnerSpawnFailure(error, runner, process.cwd())).toBe(false)
+    },
+  )
+
   it('requires a usable caller cwd before classifying absolute, bare, or relative runners', () => {
     const missingWorkdir = join(spillDir, 'missing-workdir')
     for (const [, runner] of RUNNER_FORMS) {
@@ -405,7 +440,7 @@ describe('isRunnerSpawnFailure', () => {
   it('accepts only syscall provenance compatible with the exact runner program', () => {
     const runner = join(spillDir, 'runner with spaces')
     const spawnError = (syscall: string, path?: string) =>
-      Object.assign(new Error('spawn failed'), { code: 'ENOEXEC', syscall, path })
+      Object.assign(new Error('spawn failed'), { code: 'ENOENT', syscall, path })
 
     expect(isRunnerSpawnFailure(spawnError('spawn', runner), runner, process.cwd())).toBe(true)
     expect(isRunnerSpawnFailure(spawnError(`spawn ${runner}`, runner), runner, process.cwd())).toBe(true)