opencode-secrets-obfuscation 0.1.0 → 0.1.1

package/tests/unit/harness.test.ts

@@ -1,228 +0,0 @@
-import assert from "node:assert/strict"
-import { createHash, randomUUID } from "node:crypto"
-import { lstat, mkdir, readFile, rm, rmdir, symlink, writeFile } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import { test } from "node:test"
-import { dirname, join } from "node:path"
-import { ChildProcessError, runChild, type ChildOptions } from "../support/child-process.ts"
-import { createRunDirectory } from "../support/run-directory.ts"
-
-const fixture = join(import.meta.dirname, "../fixtures/process-child.mjs")
-const nodeHash = createHash("sha256").update(await readFile(process.execPath)).digest("hex")
-const artifacts = join(import.meta.dirname, "../../.artifacts")
-const staleFixedRoot = join(artifacts, "harness-test-root")
-
-async function createPrivateTestRun(label: string) {
-  const root = join(artifacts, `harness-${label}-${process.pid}-${randomUUID()}`)
-  if (await lstat(root).catch(() => undefined)) throw new Error("TEST_RUN_ROOT_ALREADY_EXISTS")
-  try {
-    const run = await createRunDirectory(root)
-    return {
-      run,
-      cleanupRoot: async () => { await rmdir(root) },
-    }
-  } catch (error) {
-    await rmdir(root).catch(() => undefined)
-    throw error
-  }
-}
-
-async function removeTestRun(run: Awaited<ReturnType<typeof createPrivateTestRun>>): Promise<void> {
-  await rm(run.run.path, { recursive: true, force: true })
-  await run.cleanupRoot()
-}
-
-function child(cwd: string, args: readonly string[], extra: Partial<ChildOptions> = {}): ChildOptions {
-  return {
-    executable: process.execPath,
-    expectedExecutableSha256: nodeHash,
-    args,
-    cwd,
-    env: {},
-    allowedEnv: [],
-    startupTimeoutMs: 2_000,
-    overallTimeoutMs: 2_000,
-    ...extra,
-  }
-}
-
-test("run directories are private, marked, and cleanup refuses unsafe nested content", async () => {
-  const testRun = await createPrivateTestRun("private")
-  const { run } = testRun
-  const outside = join(run.path, "..", "outside.txt")
-  const link = join(run.path, "outside-link")
-  const childPath = join(run.path, "private-child")
-  try {
-    await writeFile(outside, "keep")
-    await mkdir(childPath, { mode: 0o700 })
-    await run.verifyPrivateChild(childPath)
-    await rmdir(childPath)
-    if (process.platform !== "win32") {
-      await symlink(outside, link)
-      await assert.rejects(run.cleanup(), (error: unknown) => error instanceof Error && error.message === "RUN_DIRECTORY_CONTENT_UNSAFE")
-      await rm(link)
-    }
-    assert.equal(await readFile(run.marker, "utf8"), "opencode-secrets-obfuscation run-directory v1\n")
-    await run.cleanup()
-    await assert.rejects(lstat(run.path), { code: "ENOENT" })
-    assert.equal(await readFile(outside, "utf8"), "keep")
-  } finally {
-    await rm(outside, { force: true })
-    await removeTestRun(testRun)
-  }
-})
-
-test("cleanup refuses a path without the exact ownership marker", async () => {
-  const testRun = await createPrivateTestRun("marker")
-  const { run } = testRun
-  try {
-    await writeFile(run.marker, "wrong\n")
-    await assert.rejects(run.cleanup(), (error: unknown) => error instanceof Error && error.message === "RUN_DIRECTORY_NOT_OWNED")
-    await writeFile(run.marker, "opencode-secrets-obfuscation run-directory v1\n")
-    await run.cleanup()
-  } finally {
-    await removeTestRun(testRun)
-  }
-})
-
-test("child execution uses only the supplied environment and cwd", async () => {
-  const testRun = await createPrivateTestRun("environment")
-  const { run } = testRun
-  try {
-    const result = await runChild(child(run.path, [fixture, "env", "HARNESS_SYNTHETIC"], {
-      env: { HARNESS_SYNTHETIC: "fixture-value" },
-      allowedEnv: ["HARNESS_SYNTHETIC"],
-    }))
-    assert.equal(result.exitCode, 0)
-    assert.equal(result.stdout, "fixture-value\n")
-    assert.equal(result.stderr, "")
-    assert.equal(result.cwd, run.path)
-  } finally {
-    await removeTestRun(testRun)
-  }
-})
-
-test("child output is bounded and teardown completes before cleanup", async () => {
-  const testRun = await createPrivateTestRun("output")
-  const { run } = testRun
-  try {
-    await assert.rejects(runChild(child(run.path, [fixture, "stdout", "64"], { stdoutLimitBytes: 16 })),
-      (error: unknown) => error instanceof ChildProcessError && error.code === "OUTPUT_LIMIT")
-    await run.cleanup()
-  } finally {
-    await removeTestRun(testRun)
-  }
-})
-
-test("overall timeout escalates a stubborn owned child and waits for close", { skip: process.platform !== "win32" }, async () => {
-  const testRun = await createPrivateTestRun("timeout")
-  const { run } = testRun
-  try {
-    await assert.rejects(runChild(child(run.path, [fixture, "ignore-term"], { overallTimeoutMs: 50 })),
-      (error: unknown) => error instanceof ChildProcessError && error.code === "TIMEOUT")
-    await run.cleanup()
-  } finally {
-    await removeTestRun(testRun)
-  }
-})
-
-test("pre-cancelled child execution does not spawn", async () => {
-  const testRun = await createPrivateTestRun("pre-cancel")
-  const { run } = testRun
-  const marker = join(run.path, "spawned")
-  const controller = new AbortController()
-  controller.abort()
-  try {
-    await assert.rejects(runChild(child(run.path, [fixture, "marker", marker], { signal: controller.signal })),
-      (error: unknown) => error instanceof ChildProcessError && error.code === "CANCELLED")
-    await assert.rejects(lstat(marker), { code: "ENOENT" })
-  } finally {
-    await removeTestRun(testRun)
-  }
-})
-
-test("post-spawn cancellation waits for the child to close before cleanup", async () => {
-  const testRun = await createPrivateTestRun("cancel")
-  const { run } = testRun
-  const controller = new AbortController()
-  try {
-    const pending = runChild(child(run.path, [fixture, "sleep", "5000"], { signal: controller.signal }))
-    setTimeout(() => controller.abort(), 25)
-    await assert.rejects(pending, (error: unknown) => error instanceof ChildProcessError && error.code === "CANCELLED")
-    await run.cleanup()
-  } finally {
-    await removeTestRun(testRun)
-  }
-})
-
-test("malformed options and executable identity mismatch fail safely", async () => {
-  await assert.rejects(runChild(null), (error: unknown) => error instanceof ChildProcessError && error.code === "INVALID_OPTIONS")
-  await assert.rejects(runChild({ args: [], env: {}, allowedEnv: [] }), (error: unknown) => error instanceof ChildProcessError && error.code === "INVALID_OPTIONS")
-  const testRun = await createPrivateTestRun("options")
-  const { run } = testRun
-  try {
-    await assert.rejects(runChild(child(run.path, [fixture], { expectedExecutableSha256: "0".repeat(64) })),
-      (error: unknown) => error instanceof ChildProcessError && error.code === "EXECUTABLE_MISMATCH")
-  } finally {
-    await removeTestRun(testRun)
-  }
-})
-
-test("Windows environment names cannot be duplicated case-insensitively", async () => {
-  const testRun = await createPrivateTestRun("windows-env")
-  const { run } = testRun
-  try {
-    const options = child(run.path, [fixture], {
-      env: { PATH: "one", path: "two" },
-      allowedEnv: ["PATH", "path"],
-    })
-    if (process.platform === "win32") {
-      await assert.rejects(runChild(options), (error: unknown) => error instanceof ChildProcessError && error.code === "INVALID_OPTIONS")
-    }
-  } finally {
-    await removeTestRun(testRun)
-  }
-})
-
-test("fresh missing private-root hierarchy is created without changing existing ancestors", async () => {
-  const testRun = await createPrivateTestRun("fresh-missing")
-  const { run } = testRun
-  try {
-    assert.equal((await lstat(run.path)).isDirectory(), true)
-    await run.cleanup()
-  } finally {
-    await removeTestRun(testRun)
-  }
-})
-
-test("root-owned sticky ancestor is accepted while the run directory remains current-owned", { skip: process.platform === "win32" }, async () => {
-  const freshRoot = join(tmpdir(), `opencode-harness-${process.pid}-${Date.now()}`, "nested")
-  const run = await createRunDirectory(freshRoot)
-  try {
-    await run.cleanup()
-  } finally {
-    await rmdir(freshRoot).catch(() => undefined)
-    await rmdir(dirname(freshRoot)).catch(() => undefined)
-  }
-})
-
-test("cross-volume child paths are rejected before ACL inspection on Windows", { skip: process.platform !== "win32" }, async () => {
-  const testRun = await createPrivateTestRun("cross-volume")
-  const { run } = testRun
-  try {
-    await assert.rejects(run.verifyPrivateChild("D:\\outside"), (error: unknown) => error instanceof Error && error.message === "RUN_DIRECTORY_UNSAFE_ROOT")
-  } finally {
-    await removeTestRun(testRun)
-  }
-})
-
-test("a stale legacy fixed root does not affect a fresh test root", async () => {
-  const testRun = await createPrivateTestRun("stale-root-regression")
-  try {
-    assert.notEqual(testRun.run.path, staleFixedRoot)
-    assert.equal(testRun.run.path.startsWith(`${staleFixedRoot}-`), false)
-    assert.equal((await lstat(testRun.run.path)).isDirectory(), true)
-  } finally {
-    await removeTestRun(testRun)
-  }
-})

package/tests/unit/host-api.test.ts

@@ -1,122 +0,0 @@
-import assert from "node:assert/strict"
-import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http"
-import test from "node:test"
-import { join, resolve } from "node:path"
-import { requestHostInfo } from "../support/host-api.ts"
-
-const password = "b".repeat(64)
-const root = resolve(process.cwd(), ".artifacts", "host-api-test", "private")
-
-interface FixtureResponse {
-  readonly status?: number
-  readonly headers?: Record<string, string>
-  readonly body?: string
-  readonly delay?: number
-  readonly redirect?: string
-}
-
-async function fixture(response: FixtureResponse): Promise<{ server: Server; origin: string; close: () => Promise<void> }> {
-  const server = createServer((request: IncomingMessage, reply: ServerResponse) => {
-    if (request.url !== "/api/info" || request.method !== "GET") {
-      reply.writeHead(404).end()
-      return
-    }
-    const authenticated = request.headers.authorization === `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}`
-    if (!authenticated) {
-      reply.writeHead(401).end()
-      return
-    }
-    const send = () => {
-      if (response.redirect) {
-        reply.writeHead(302, { location: response.redirect }).end()
-        return
-      }
-      reply.writeHead(response.status ?? 200, { "content-type": "application/json", ...response.headers })
-      reply.end(response.body ?? JSON.stringify({ version: "2.0.28", pid: 42, urls: [], paths: { tmp: join(root, "temp") } }))
-    }
-    if (response.delay === undefined) send()
-    else setTimeout(send, response.delay)
-  })
-  await new Promise<void>((resolvePromise, reject) => {
-    server.once("error", reject)
-    server.listen(0, "127.0.0.1", () => resolvePromise())
-  })
-  const address = server.address()
-  assert.equal(address !== null && typeof address === "object", true)
-  const origin = `http://127.0.0.1:${(address as { port: number }).port}`
-  return { server, origin, close: () => new Promise<void>((resolvePromise) => server.close(() => resolvePromise())) }
-}
-
-function input(origin: string, extra: Record<string, unknown> = {}): Record<string, unknown> {
-  return { origin, password, expectedVersion: "2.0.28", expectedTmpRoot: root, ...extra }
-}
-
-async function withFixture(response: FixtureResponse, run: (origin: string) => Promise<void>): Promise<void> {
-  const server = await fixture(response)
-  try { await run(server.origin) } finally { await server.close() }
-}
-
-test("gets only the authenticated safe ServerInfo projection", async () => {
-  await withFixture({}, async (origin) => {
-    const result = await requestHostInfo(input(origin, { expectedPID: 42 }))
-    assert.deepEqual(result, { version: "2.0.28", pid: 42, urls: [], paths: { tmp: join(root, "temp") } })
-  })
-})
-
-test("projects required identity fields without requiring optional ServerInfo fields", async () => {
-  await withFixture({ body: JSON.stringify({ version: "2.0.28", pid: 42, urls: [], paths: { tmp: join(root, "temp"), home: "ignored" }, capabilities: { future: true } }) }, async (origin) => {
-    const result = await requestHostInfo(input(origin))
-    assert.equal(result.version === "2.0.28" && result.pid === 42 && result.paths.tmp === join(root, "temp"), true)
-    assert.equal(Object.hasOwn(result, "capabilities"), false)
-  })
-})
-
-test("rejects wrong version, wrong PID, and a temporary path outside the private root", async () => {
-  await withFixture({ body: JSON.stringify({ version: "wrong", pid: 42, urls: [], paths: { tmp: join(root, "temp") } }) }, async (origin) => {
-    await assert.rejects(requestHostInfo(input(origin)), { message: "HOST_API_VERSION" })
-  })
-  await withFixture({ body: JSON.stringify({ version: "2.0.28", pid: 7, urls: [], paths: { tmp: join(root, "temp") } }) }, async (origin) => {
-    await assert.rejects(requestHostInfo(input(origin, { expectedPID: 42 })), { message: "HOST_API_PID" })
-  })
-  await withFixture({ body: JSON.stringify({ version: "2.0.28", pid: 42, urls: [], paths: { tmp: resolve(root, "..", "not-private") } }) }, async (origin) => {
-    await assert.rejects(requestHostInfo(input(origin)), { message: "HOST_API_TMP_ROOT" })
-  })
-})
-
-test("rejects an unowned advertised URL", async () => {
-  await withFixture({ body: JSON.stringify({ version: "2.0.28", pid: 42, urls: ["http://127.0.0.1:9"], paths: { tmp: join(root, "temp") } }) }, async (origin) => {
-    await assert.rejects(requestHostInfo(input(origin)), { message: "HOST_API_URL" })
-  })
-})
-
-test("requires authentication and does not follow redirects", async () => {
-  await withFixture({ status: 401 }, async (origin) => {
-    await assert.rejects(requestHostInfo(input(origin)), { message: "HOST_API_STATUS" })
-  })
-  await withFixture({ redirect: "http://127.0.0.1:9/api/info" }, async (origin) => {
-    await assert.rejects(requestHostInfo(input(origin)), { message: "HOST_API_REDIRECT" })
-  })
-})
-
-test("bounds body and deadline, and reports fixed codes only", async () => {
-  await withFixture({ body: "{" + "x".repeat(70_000) }, async (origin) => {
-    await assert.rejects(requestHostInfo(input(origin)), { message: "HOST_API_BODY" })
-  })
-  await withFixture({ delay: 100 }, async (origin) => {
-    await assert.rejects(requestHostInfo(input(origin, { timeoutMs: 10 })), { message: "HOST_API_TIMEOUT" })
-  })
-})
-
-test("rejects malformed input without invoking getters or exposing arbitrary errors", async () => {
-  let invoked = false
-  const malformed: unknown[] = [
-    null, {}, { origin: "https://127.0.0.1:1", password, expectedVersion: "2.0.28", expectedTmpRoot: root },
-    { origin: "http://localhost:1", password, expectedVersion: "2.0.28", expectedTmpRoot: root },
-    { origin: "http://127.0.0.1:1/path", password, expectedVersion: "2.0.28", expectedTmpRoot: root },
-    { origin: "http://127.0.0.1:1", password, expectedVersion: "2.0.28", expectedTmpRoot: root, get timeoutMs() { invoked = true; throw new Error("private") } },
-  ]
-  for (const value of malformed) {
-    await assert.rejects(requestHostInfo(value), (error: unknown) => error instanceof Error && error.message === "HOST_API_INVALID")
-  }
-  assert.equal(invoked, false)
-})

package/tests/unit/opencode-environment.test.ts

@@ -1,161 +0,0 @@
-import assert from "node:assert/strict"
-import test from "node:test"
-import { join, resolve, sep } from "node:path"
-import { buildOpenCodeEnvironment } from "../support/opencode-environment.ts"
-
-// Public synthetic fixture password; real smoke runs generate their own CSPRNG value.
-const password = "a".repeat(64)
-const build = (input: Record<string, unknown>) => buildOpenCodeEnvironment({ password, ...input })
-const root = resolve(process.cwd(), ".artifacts", "opencode-environment-test")
-const trustedOs = {
-  userProfile: join(root, "home"),
-  home: join(root, "home"),
-  programData: join(root, "programdata"),
-  temp: join(root, "temp"),
-  tmp: join(root, "temp"),
-  path: join(root, "os", "bin"),
-  systemRoot: join(root, "os"),
-  comspec: join(root, "os", "cmd.exe"),
-  pathext: ".COM;.EXE;.BAT;.CMD",
-}
-
-test("builds only fixture-rooted OpenCode paths and a complete allowlist", () => {
-  const result = build({ root, trustedOs })
-  const expected = [result.cwd, ...Object.values(result.paths)]
-
-  for (const value of expected) {
-    assert.equal(value === root || value.startsWith(`${root}${sep}`), true)
-  }
-  assert.deepEqual(result.env, Object.fromEntries(result.allowedEnv.map((key: string) => [key, result.env[key]])))
-  assert.equal(result.env.OPENCODE_CONFIG_PROJECT_DISABLE, "1")
-  assert.equal(result.env.OPENCODE_DB, result.paths.database)
-  assert.deepEqual(JSON.parse(result.env.OPENCODE_CONFIG_CONTENT!), {
-    snapshots: false,
-    warming: false,
-    update: "disable",
-  })
-})
-
-test("does not copy ambient credentials, runtime controls, proxies, or plugin paths", () => {
-  const marker = "OPENCODE_ENVIRONMENT_TEST_MARKER_7f3a"
-  const previous = process.env[marker]
-  process.env[marker] = "harmless-marker"
-  try {
-    const result = build({ root, trustedOs })
-    assert.equal(Object.keys(result.env).includes(marker), false)
-    assert.equal(Object.keys(result.env).some((key) => /proxy|node_options|plugin|credential|token/i.test(key)), false)
-  } finally {
-    if (previous === undefined) delete process.env[marker]
-    else process.env[marker] = previous
-  }
-})
-
-test("rejects relative or escaping roots and unsafe trusted values", () => {
-  assert.throws(() => build({ root: "relative", trustedOs }), /OPENCODE_ENVIRONMENT_INVALID/)
-  assert.throws(
-    () => build({ root, trustedOs: { ...trustedOs, temp: join(root, "..", "other") } }),
-    /OPENCODE_ENVIRONMENT_INVALID/,
-  )
-  assert.throws(() => build({ root, trustedOs: { ...trustedOs, path: "bad\npath" } }), /OPENCODE_ENVIRONMENT_INVALID/)
-})
-
-test("locks the boot config and rejects unsafe or malformed overrides", () => {
-  assert.throws(() => build({ root, trustedOs, configContent: { snapshots: true } }), /OPENCODE_ENVIRONMENT_INVALID/)
-  assert.throws(() => build({ root, trustedOs, configContent: { extra: false } }), /OPENCODE_ENVIRONMENT_INVALID/)
-  const cyclic: Record<string, unknown> = {}
-  cyclic.self = cyclic
-  assert.throws(() => build({ root, trustedOs, configContent: cyclic }), /OPENCODE_ENVIRONMENT_INVALID/)
-  const getter = Object.defineProperty({}, "snapshots", { get: () => false })
-  assert.throws(() => build({ root, trustedOs, configContent: getter }), /OPENCODE_ENVIRONMENT_INVALID/)
-  const result = build({ root, trustedOs })
-  assert.throws(() => (result.env as Record<string, string>).PATH = "changed", TypeError)
-  assert.throws(() => (result.allowedEnv as string[]).push("BAD"), TypeError)
-})
-
-test("malformed builder input cannot invoke accessors or echo arbitrary causes", () => {
-  let invoked = false
-  const inputs: unknown[] = [
-    null, {}, { root, password, trustedOs: null },
-    { root: `${root}\0`, password, trustedOs },
-    { root, password, trustedOs: { ...trustedOs, unexpected: "fixture" } },
-    { root, password, trustedOs: { ...trustedOs, systemRoot: "relative" } },
-    { get root() { invoked = true; throw new Error("synthetic-private") }, password, trustedOs },
-    { root, password, trustedOs: { ...trustedOs, get path() { invoked = true; throw new Error("synthetic-private") } } },
-  ]
-  for (const input of inputs) {
-    assert.throws(() => (buildOpenCodeEnvironment as (value: unknown) => unknown)(input),
-      (error: unknown) => error instanceof Error && error.message === "OPENCODE_ENVIRONMENT_INVALID")
-  }
-  assert.equal(invoked, false)
-})
-
-test("sandbox config merges host-neutral keys while boot locks win", () => {
-  const result = build({
-    root,
-    trustedOs,
-    sandboxConfig: {
-      plugins: ["./plugin.mjs"],
-      provider: { smoke: { npm: "@ai-sdk/openai-compatible" } },
-      temperature: 0,
-    },
-  })
-  assert.deepEqual(JSON.parse(result.env.OPENCODE_CONFIG_CONTENT!), {
-    plugins: ["./plugin.mjs"],
-    provider: { smoke: { npm: "@ai-sdk/openai-compatible" } },
-    temperature: 0,
-    snapshots: false,
-    warming: false,
-    update: "disable",
-  })
-  // configContent keeps its own lock alongside the sandbox channel.
-  assert.throws(() => build({ root, trustedOs, configContent: { warming: true }, sandboxConfig: { plugins: [] } }),
-    /OPENCODE_ENVIRONMENT_INVALID/)
-})
-
-test("sandbox config cannot flip locked host behaviors or smuggle malformed payloads", () => {
-  assert.throws(() => build({ root, trustedOs, sandboxConfig: { snapshots: true } }), /OPENCODE_ENVIRONMENT_INVALID/)
-  assert.throws(() => build({ root, trustedOs, sandboxConfig: { warming: true } }), /OPENCODE_ENVIRONMENT_INVALID/)
-  assert.throws(() => build({ root, trustedOs, sandboxConfig: { update: "manual" } }), /OPENCODE_ENVIRONMENT_INVALID/)
-  assert.throws(() => build({ root, trustedOs, sandboxConfig: [] }), /OPENCODE_ENVIRONMENT_INVALID/)
-  assert.throws(() => build({ root, trustedOs, sandboxConfig: "plugins" }), /OPENCODE_ENVIRONMENT_INVALID/)
-  assert.throws(() => build({ root, trustedOs, sandboxConfig: { temperature: Number.NaN } }), /OPENCODE_ENVIRONMENT_INVALID/)
-  const cyclic: Record<string, unknown> = { plugins: [] as unknown[] }
-  ;(cyclic.plugins as unknown[]).push(cyclic)
-  assert.throws(() => build({ root, trustedOs, sandboxConfig: cyclic }), /OPENCODE_ENVIRONMENT_INVALID/)
-  let invoked = false
-  const accessor = {
-    provider: {
-      get smoke() {
-        invoked = true
-        throw new Error("synthetic-private")
-      },
-    },
-  }
-  assert.throws(() => build({ root, trustedOs, sandboxConfig: accessor }), /OPENCODE_ENVIRONMENT_INVALID/)
-  assert.equal(invoked, false, "sandbox config accessors are never evaluated")
-})
-
-test("sandbox launch pins the host-control switches that keep runs self-contained", () => {
-  const result = build({ root, trustedOs })
-  const switches = [
-    "OPENCODE_DISABLE_MODELS_FETCH",
-    "OPENCODE_DISABLE_AUTOUPDATE",
-    "OPENCODE_DISABLE_FILEWATCHER",
-    "OPENCODE_DISABLE_PROJECT_CONFIG",
-  ] as const
-  for (const key of switches) {
-    assert.equal(result.env[key], "1", `${key} must be set`)
-    assert.equal(result.allowedEnv.includes(key), true, `${key} must be allowlisted`)
-  }
-})
-
-test("authenticated launch requires an explicit run-owned password and rooted file database", () => {
-  const result = build({ root, trustedOs })
-  assert.equal(result.env.OPENCODE_PASSWORD === password, true)
-  assert.equal(result.allowedEnv.includes("OPENCODE_PASSWORD"), true)
-  assert.equal(result.env.OPENCODE_DB === join(root, "data", "opencode.db"), true)
-  for (const value of [undefined, "", "short", "a".repeat(63), `${password}\n`]) {
-    assert.throws(() => buildOpenCodeEnvironment({ root, trustedOs, password: value }),
-      (error: unknown) => error instanceof Error && error.message === "OPENCODE_ENVIRONMENT_INVALID")
-  }
-})

package/tests/unit/qualification.test.ts

@@ -1,128 +0,0 @@
-import assert from "node:assert/strict"
-import { test } from "node:test"
-import { assessCases, type CaseEvidence, type RequiredCase } from "../support/qualification.ts"
-
-const required: RequiredCase[] = [
-  { id: "P0-BOOT", expectation: "behavior", platform: "win32", profile: "active-only" },
-  { id: "P0-ABORT", expectation: "denied", platform: "win32", profile: "active-only" },
-]
-
-const evidence = (item: RequiredCase): CaseEvidence => ({
-  ...item,
-  runID: "run-001",
-  buildID: "build-001",
-  status: "passed",
-  assertions: 1,
-  captureIDs: ["capture-001"],
-})
-
-test("qualification: complete matching executed evidence satisfies selected cases only", () => {
-  assert.deepEqual(assessCases(required, required.map(evidence), {
-    runID: "run-001", buildID: "build-001", profile: "active-only", platform: "win32",
-  }), { satisfied: true, failures: [] })
-})
-
-test("qualification: empty selection cannot qualify", () => {
-  assert.equal(assessCases([], [], {
-    runID: "run-001", buildID: "build-001", profile: "active-only", platform: "win32",
-  }).satisfied, false)
-})
-
-for (const status of ["planned", "todo", "skipped", "failed", "unavailable"] as const) {
-  test(`qualification: ${status} is not executed passing evidence`, () => {
-    const records = required.map(evidence)
-    records[0] = { ...records[0]!, status }
-    const result = assessCases(required, records, {
-      runID: "run-001", buildID: "build-001", profile: "active-only", platform: "win32",
-    })
-    assert.equal(result.satisfied, false)
-    assert.ok(result.failures.some((failure) => failure.code === "CASE_NOT_PASSED"))
-  })
-}
-
-test("qualification: missing and duplicate evidence cannot satisfy a required case", () => {
-  for (const records of [[], [evidence(required[0]!), evidence(required[0]!), evidence(required[1]!)]]) {
-    assert.equal(assessCases(required, records, {
-      runID: "run-001", buildID: "build-001", profile: "active-only", platform: "win32",
-    }).satisfied, false)
-  }
-})
-
-test("qualification: stale build/run, wrong profile/platform and wrong expectation are rejected", () => {
-  for (const change of [
-    { runID: "old-run" }, { buildID: "old-build" }, { profile: "enforced" as const },
-    { platform: "linux" }, { expectation: "expected-gap" as const },
-    { assertions: 0 }, { captureIDs: [] },
-  ]) {
-    const records = required.map(evidence)
-    records[0] = { ...records[0]!, ...change }
-    assert.equal(assessCases(required, records, {
-      runID: "run-001", buildID: "build-001", profile: "active-only", platform: "win32",
-    }).satisfied, false)
-  }
-})
-
-test("qualification: expected-gap never satisfies an enforced profile", () => {
-  const item: RequiredCase = {
-    id: "P6-GATE", profile: "enforced", platform: "win32", expectation: "expected-gap",
-  }
-  assert.equal(assessCases([item], [evidence(item)], {
-    runID: "run-001", buildID: "build-001", profile: "enforced", platform: "win32",
-  }).satisfied, false)
-})
-
-test("qualification: an observed gap is valid only as explicitly selected active-only gap evidence", () => {
-  const item: RequiredCase = {
-    id: "P5-GAP", profile: "active-only", platform: "win32", expectation: "expected-gap",
-  }
-  assert.equal(assessCases([item], [{ ...evidence(item), status: "observed-gap" }], {
-    runID: "run-001", buildID: "build-001", profile: "active-only", platform: "win32",
-  }).satisfied, true)
-  assert.equal(assessCases([item], [evidence(item)], {
-    runID: "run-001", buildID: "build-001", profile: "active-only", platform: "win32",
-  }).satisfied, false)
-})
-
-test("qualification: invalid IDs are not echoed into safe failure output", () => {
-  const bad = { ...required[0]!, id: "arbitrary-sensitive-input" }
-  const result = assessCases([bad], [evidence(bad)], {
-    runID: "run-001", buildID: "build-001", profile: "active-only", platform: "win32",
-  })
-  assert.equal(result.satisfied, false)
-  assert.equal(JSON.stringify(result).includes(bad.id), false)
-})
-
-test("qualification: invalid requirements and unexpected evidence fail rather than disappear", () => {
-  const options = { runID: "run-001", buildID: "build-001", profile: "active-only" as const, platform: "win32" }
-  assert.equal(assessCases([required[0]!, required[0]!], required.map(evidence), options).satisfied, false)
-  assert.equal(assessCases(required, [...required.map(evidence), evidence({ ...required[0]!, id: "P0-EXTRA" })], options).satisfied, false)
-  assert.equal(assessCases(required, required.map(evidence), { ...options, runID: "" }).satisfied, false)
-})
-
-test("qualification: malformed external evidence always returns fixed failure codes", () => {
-  const options = { runID: "run-001", buildID: "build-001", profile: "active-only", platform: "win32" }
-  for (const inputs of [
-    [null, [], options], [required, null, options], [required, [], null],
-    [[null], [], options], [required, [null], options],
-    [required, [{ ...evidence(required[0]!), captureIDs: null }], options],
-    [required, [{ ...evidence(required[0]!), captureIDs: "sensitive-malformed-value" }], options],
-    [[{ ...required[0]!, id: {} }], [], options],
-    [required, [], { ...options, runID: {} }],
-  ]) {
-    // Simulate raw JSON crossing into the assessor; TypeScript is not a validator.
-    const result = (assessCases as (...args: unknown[]) => { satisfied: boolean; failures: { code: string }[] })(...inputs)
-    assert.equal(result.satisfied, false)
-    assert.ok(result.failures.length > 0)
-    assert.equal(JSON.stringify(result).includes("sensitive-malformed-value"), false)
-  }
-})
-
-test("qualification: accessor properties are rejected without invoking them", () => {
-  let invoked = false
-  const item = { ...required[0]!, get id() { invoked = true; throw new Error("private-value") } }
-  const result = assessCases([item], [], {
-    runID: "run-001", buildID: "build-001", profile: "active-only", platform: "win32",
-  })
-  assert.equal(result.satisfied, false)
-  assert.equal(invoked, false)
-})