opencode-drive 0.1.0

package/src/experimental/generators/config.ts

@@ -0,0 +1,240 @@
+import { createRng, type Rng } from "./random.js"
+
+/**
+ * Profile-based OpenCode config generation.
+ *
+ * Unlike `Schema.toArbitrary`, these generators produce configs a person could
+ * plausibly have written, while still covering most schema branches:
+ *
+ * - minimal: the smallest useful configs
+ * - typical: realistic daily-driver configs
+ * - maximal: every major section populated
+ * - edge: unusual-but-valid shapes (disabled agents, deny-all permissions, ...)
+ */
+export type ConfigProfile = "minimal" | "typical" | "maximal" | "edge"
+
+export const configProfiles: ReadonlyArray<ConfigProfile> = ["minimal", "typical", "maximal", "edge"]
+
+export type ConfigJson = Record<string, unknown>
+
+const schemaUrl = "https://opencode.ai/config.json"
+
+const models = [
+  "opencode/gpt-5.5",
+  "opencode/big-pickle",
+  "opencode/claude-sonnet-4-5",
+  "anthropic/claude-sonnet-4-5",
+  "openai/gpt-5-codex",
+]
+
+const agentNames = ["reviewer", "researcher", "planner", "tester", "docs"]
+
+const agentDescriptions: Record<string, string> = {
+  reviewer: "Reviews changes for bugs, regressions, and risky patterns",
+  researcher: "Explores the codebase and summarizes findings with references",
+  planner: "Breaks work into small verifiable steps before editing",
+  tester: "Writes and runs focused tests around changed behavior",
+  docs: "Writes and updates documentation to match the code",
+}
+
+const permissionPool: ReadonlyArray<ConfigJson> = [
+  { action: "bash", resource: "git *", effect: "allow" },
+  { action: "bash", resource: "*", effect: "ask" },
+  { action: "edit", resource: "src/**", effect: "allow" },
+  { action: "edit", resource: "*", effect: "ask" },
+  { action: "read", resource: "*.env", effect: "deny" },
+  { action: "webfetch", resource: "*", effect: "allow" },
+  { action: "external_directory", resource: "*", effect: "deny" },
+  { action: "question", resource: "*", effect: "deny" },
+]
+
+const commandPool: Record<string, string> = {
+  review: "Review the current diff for bugs and risky changes.",
+  explain: "Explain what the selected code does and why it exists.",
+  triage: "Summarize this issue and propose concrete next steps.",
+  ship: "Prepare a release summary from recent commits.",
+}
+
+const permissions = (rng: Rng, minimum: number, maximum: number): ConfigJson[] =>
+  rng.subset(permissionPool, minimum, maximum).map((rule) => ({ ...rule }))
+
+const agent = (rng: Rng, name: string): ConfigJson => ({
+  description: agentDescriptions[name] ?? `Helps with ${name}`,
+  ...(rng.boolean(0.7) ? { model: rng.pick(models) } : {}),
+  ...(rng.boolean(0.4) ? { mode: rng.pick(["subagent", "primary", "all"]) } : {}),
+  ...(rng.boolean(0.3) ? { system: `You are the ${name} agent. Stay focused and concise.` } : {}),
+  ...(rng.boolean(0.3) ? { steps: rng.int(4, 24) } : {}),
+  ...(rng.boolean(0.25) ? { color: rng.pick(["primary", "accent", "#4f46e5", "#0ea5e9"]) } : {}),
+  ...(rng.boolean(0.3) ? { permissions: permissions(rng, 1, 3) } : {}),
+})
+
+const agents = (rng: Rng, names: ReadonlyArray<string>): ConfigJson =>
+  Object.fromEntries(names.map((name) => [name, agent(rng, name)]))
+
+const commands = (rng: Rng, count: number): ConfigJson =>
+  Object.fromEntries(
+    rng.sample(Object.keys(commandPool), count).map((name) => [
+      name,
+      {
+        template: commandPool[name]!,
+        ...(rng.boolean(0.4) ? { agent: rng.pick(agentNames) } : {}),
+        ...(rng.boolean(0.3) ? { model: rng.pick(models) } : {}),
+        ...(rng.boolean(0.2) ? { subtask: rng.boolean() } : {}),
+      },
+    ]),
+  )
+
+const references = (rng: Rng): ConfigJson => ({
+  docs: "./docs",
+  ...(rng.boolean(0.6) ? { design: { path: "./design", description: "Product and architecture notes" } } : {}),
+  ...(rng.boolean(0.4)
+    ? {
+        opencode: {
+          repository: "https://github.com/anomalyco/opencode",
+          branch: "dev",
+          description: "OpenCode source checkout",
+        },
+      }
+    : {}),
+})
+
+const mcp = (rng: Rng): ConfigJson => ({
+  ...(rng.boolean(0.4) ? { timeout: { startup: 10_000, request: 30_000 } } : {}),
+  servers: {
+    filesystem: {
+      type: "local",
+      command: ["npx", "-y", "@modelcontextprotocol/server-filesystem", "."],
+      ...(rng.boolean(0.3) ? { environment: { MCP_FS_READONLY: "1" } } : {}),
+    },
+    ...(rng.boolean(0.5)
+      ? {
+          linear: {
+            type: "remote",
+            url: "https://mcp.linear.app/sse",
+            ...(rng.boolean(0.5) ? { headers: { Authorization: "Bearer ${LINEAR_TOKEN}" } } : {}),
+          },
+        }
+      : {}),
+  },
+})
+
+const providers = (rng: Rng): ConfigJson => ({
+  local: {
+    name: "Local OpenAI-compatible",
+    api: { type: "aisdk", package: "@ai-sdk/openai-compatible", url: "http://localhost:11434/v1" },
+    ...(rng.boolean(0.3) ? { env: ["LOCAL_API_KEY"] } : {}),
+    models: {
+      "llama-3.3-70b": {
+        name: "Llama 3.3 70B",
+        capabilities: { tools: true, input: ["text"], output: ["text"] },
+        limit: { context: 131072, output: 8192 },
+        ...(rng.boolean(0.3) ? { cost: { input: 0, output: 0 } } : {}),
+      },
+    },
+  },
+})
+
+const formatter = (rng: Rng): ConfigJson => ({
+  prettier: { command: ["prettier", "--write", "$FILE"], extensions: [".ts", ".tsx", ".md"] },
+  ...(rng.boolean(0.3) ? { gofmt: { disabled: true } } : {}),
+})
+
+const lsp = (): ConfigJson => ({
+  typescript: { command: ["typescript-language-server", "--stdio"], extensions: [".ts", ".tsx"] },
+  eslint: { disabled: true },
+})
+
+const minimal = (rng: Rng): ConfigJson => ({
+  $schema: schemaUrl,
+  model: rng.pick(models),
+  ...(rng.boolean(0.3) ? { share: "manual" } : {}),
+})
+
+const typical = (rng: Rng): ConfigJson => {
+  const names = rng.sample(agentNames, rng.int(1, 2))
+  return {
+    $schema: schemaUrl,
+    model: rng.pick(models),
+    ...(rng.boolean(0.5) ? { default_agent: names[0] } : {}),
+    ...(rng.boolean(0.5) ? { autoupdate: rng.pick<boolean | string>([true, false, "notify"]) } : {}),
+    share: rng.pick(["manual", "auto"]),
+    permissions: permissions(rng, 2, 4),
+    agents: agents(rng, names),
+    ...(rng.boolean(0.6) ? { skills: ["./skills"] } : {}),
+    ...(rng.boolean(0.6) ? { instructions: ["AGENTS.md"] } : {}),
+    ...(rng.boolean(0.5) ? { commands: commands(rng, rng.int(1, 2)) } : {}),
+  }
+}
+
+const maximal = (rng: Rng): ConfigJson => {
+  const names = rng.sample(agentNames, rng.int(3, 4))
+  return {
+    $schema: schemaUrl,
+    model: rng.pick(models),
+    default_agent: names[0],
+    autoupdate: rng.pick<boolean | string>([true, "notify"]),
+    share: rng.pick(["manual", "auto"]),
+    username: rng.pick(["james", "kit", "dax", "adam"]),
+    snapshots: rng.boolean(0.8),
+    permissions: permissions(rng, 3, 6),
+    agents: agents(rng, names),
+    watcher: { ignore: ["node_modules/**", "dist/**", ...(rng.boolean(0.5) ? [".git/**"] : [])] },
+    formatter: formatter(rng),
+    lsp: lsp(),
+    attachments: { image: { auto_resize: true, max_width: 1568, max_height: 1568 } },
+    tool_output: { max_lines: rng.int(200, 2000), max_bytes: rng.int(16, 256) * 1024 },
+    mcp: mcp(rng),
+    compaction: {
+      auto: true,
+      ...(rng.boolean(0.5) ? { prune: true } : {}),
+      keep: { tokens: rng.int(4, 32) * 1024 },
+      buffer: rng.int(2, 16) * 1024,
+    },
+    skills: ["./skills", ...(rng.boolean(0.3) ? ["https://github.com/anomalyco/skills"] : [])],
+    commands: commands(rng, rng.int(2, 4)),
+    instructions: ["AGENTS.md", ...(rng.boolean(0.5) ? ["docs/style.md"] : [])],
+    references: references(rng),
+    plugins: ["opencode-notify", { package: "opencode-datadog", options: { site: "datadoghq.com" } }],
+    providers: providers(rng),
+  }
+}
+
+const edge = (rng: Rng): ConfigJson => {
+  const disabledAgent = rng.pick(agentNames)
+  return {
+    $schema: schemaUrl,
+    ...(rng.boolean(0.5) ? {} : { model: rng.pick(models) }),
+    autoupdate: "notify",
+    share: "disabled",
+    snapshots: false,
+    lsp: false,
+    formatter: false,
+    permissions: [
+      { action: "*", resource: "*", effect: "deny" },
+      ...(rng.boolean(0.5) ? [{ action: "read", resource: "*", effect: "allow" }] : []),
+    ],
+    agents: {
+      [disabledAgent]: { ...agent(rng, disabledAgent), disabled: true, hidden: true },
+    },
+    skills: [],
+    instructions: [],
+    commands: {},
+    mcp: {},
+    tool_output: { max_lines: 5, max_bytes: 1024 },
+    compaction: { auto: false, prune: true, keep: { tokens: 0 }, buffer: 0 },
+  }
+}
+
+export interface GenerateConfigOptions {
+  readonly seed: number
+  readonly profile?: ConfigProfile
+}
+
+export const generateConfigJson = (options: GenerateConfigOptions): ConfigJson => {
+  const rng = createRng(options.seed)
+  const profile = options.profile ?? rng.pick(configProfiles)
+  if (profile === "minimal") return minimal(rng)
+  if (profile === "typical") return typical(rng)
+  if (profile === "maximal") return maximal(rng)
+  return edge(rng)
+}

package/src/experimental/generators/filesystem.ts

@@ -0,0 +1,95 @@
+import { createRng, type Rng } from "./random.js"
+import type { ConfigJson } from "./config.js"
+
+/**
+ * Virtual filesystem generation.
+ *
+ * Configs reference files (skills, instructions, references); a coherent
+ * initial state must actually contain those files, otherwise the derived
+ * model and the real OpenCode behavior diverge for boring reasons.
+ */
+export interface VirtualFile {
+  readonly path: string
+  readonly content: string
+}
+
+export interface VirtualFileTree {
+  readonly files: ReadonlyArray<VirtualFile>
+}
+
+const skillPool: Record<string, string> = {
+  "code-review": "Review changes for bugs, regressions, and risky patterns.",
+  "diagnosing-bugs": "Build a tight pass/fail signal before guessing at causes.",
+  "release-notes": "Summarize shipped changes for users.",
+  "ast-grep": "Search code structurally with ast-grep patterns.",
+}
+
+const instructionPool = [
+  "Answer concisely. Lead with the conclusion.",
+  "Prefer small verifiable steps. Run the tests you touch.",
+  "Never commit secrets. Ask before external side effects.",
+]
+
+const title = (name: string): string =>
+  name
+    .split("-")
+    .map((part) => (part.length === 0 ? part : part[0]!.toUpperCase() + part.slice(1)))
+    .join(" ")
+
+export const normalizePath = (value: string): string => value.replace(/^\.\//, "").replace(/\/+$/, "")
+
+const isLocalPath = (value: string): boolean => !value.includes("://")
+
+const skillFile = (root: string, name: string, description: string): VirtualFile => ({
+  path: `${root}/${name}/SKILL.md`,
+  content: ["---", `name: ${name}`, `description: ${description}`, "---", "", `# ${title(name)}`, "", description, ""].join(
+    "\n",
+  ),
+})
+
+const stringArray = (value: unknown): string[] =>
+  Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : []
+
+const referencePath = (entry: unknown): string | undefined => {
+  if (typeof entry === "string") return entry
+  if (typeof entry === "object" && entry !== null && "path" in entry) {
+    const path = (entry as { readonly path: unknown }).path
+    if (typeof path === "string") return path
+  }
+  return undefined
+}
+
+const referenceFiles = (config: ConfigJson, rng: Rng): VirtualFile[] => {
+  const references = config.references
+  if (typeof references !== "object" || references === null || Array.isArray(references)) return []
+  return Object.entries(references).flatMap(([name, entry]) => {
+    const path = referencePath(entry)
+    if (path === undefined || !isLocalPath(path)) return []
+    return [
+      {
+        path: `${normalizePath(path)}/README.md`,
+        content: `# ${title(name)}\n\n${rng.pick(instructionPool)}\n`,
+      },
+    ]
+  })
+}
+
+export const generateFilesForConfig = (config: ConfigJson, seed: number): VirtualFileTree => {
+  const rng = createRng(seed)
+  const files: VirtualFile[] = []
+
+  for (const source of stringArray(config.skills).filter(isLocalPath)) {
+    const root = normalizePath(source)
+    for (const name of rng.sample(Object.keys(skillPool), rng.int(1, 3))) {
+      files.push(skillFile(root, name, skillPool[name]!))
+    }
+  }
+
+  for (const path of stringArray(config.instructions).filter(isLocalPath)) {
+    files.push({ path: normalizePath(path), content: `${rng.pick(instructionPool)}\n` })
+  }
+
+  files.push(...referenceFiles(config, rng))
+
+  return { files }
+}

package/src/experimental/generators/generate.ts

@@ -0,0 +1,32 @@
+import { Effect, Schema } from "effect"
+import { configProfiles, generateConfigJson, type ConfigJson } from "./config.js"
+
+// Imported through a variable so `tsgo` does not typecheck all of OpenCode
+// core; the runtime import still tracks the latest checkout.
+const opencodeConfigModule = "../../opencode-latest/packages/core/src/config.ts"
+
+export interface GenerateConfigsOptions {
+  readonly count?: number
+  readonly seed?: number
+}
+
+/**
+ * Generates realistic OpenCode config.json objects and validates every one of
+ * them against the latest checkout's `Config.Info` schema, so the generator
+ * fails loudly whenever upstream config contracts change.
+ */
+export const generateConfigs = (
+  options?: GenerateConfigsOptions,
+): Effect.Effect<ReadonlyArray<ConfigJson>> =>
+  Effect.promise(async () => {
+    const { Config } = await import(opencodeConfigModule)
+    const decode = Schema.decodeUnknownSync(Config.Info)
+    const count = options?.count ?? 8
+    const seed = options?.seed ?? 1
+    return Array.from({ length: count }, (_, index) => {
+      const profile = configProfiles[index % configProfiles.length]!
+      const config = generateConfigJson({ seed: seed + index, profile })
+      decode(config)
+      return config
+    })
+  })

package/src/experimental/generators/index.ts

@@ -0,0 +1,10 @@
+export { configProfiles, generateConfigJson } from "./config.js"
+export type { ConfigJson, ConfigProfile, GenerateConfigOptions } from "./config.js"
+export { generateFilesForConfig, normalizePath } from "./filesystem.js"
+export type { VirtualFile, VirtualFileTree } from "./filesystem.js"
+export { generateConfigs } from "./generate.js"
+export type { GenerateConfigsOptions } from "./generate.js"
+export { generateInitialState, generateInitialStates } from "./initial-state.js"
+export type { InitialState, InitialStateOptions } from "./initial-state.js"
+export { createRng } from "./random.js"
+export type { Rng } from "./random.js"

package/src/experimental/generators/initial-state.ts

@@ -0,0 +1,37 @@
+import { configProfiles, generateConfigJson, type ConfigJson, type ConfigProfile } from "./config.js"
+import { generateFilesForConfig, type VirtualFileTree } from "./filesystem.js"
+import { createRng } from "./random.js"
+
+/**
+ * One complete initial state for model-based testing:
+ * the config OpenCode reads, the files it can see, and the environment.
+ *
+ * The config generator stays pure (config objects only); this module is the
+ * coordination point that keeps config and filesystem coherent.
+ */
+export interface InitialState {
+  readonly config: ConfigJson
+  readonly files: VirtualFileTree
+  readonly env: Readonly<Record<string, string>>
+}
+
+export interface InitialStateOptions {
+  readonly seed?: number
+  readonly profile?: ConfigProfile
+}
+
+export const generateInitialState = (options?: InitialStateOptions): InitialState => {
+  const seed = options?.seed ?? 1
+  const rng = createRng(seed * 7919 + 17)
+  const config = generateConfigJson({ seed, ...(options?.profile === undefined ? {} : { profile: options.profile }) })
+  const files = generateFilesForConfig(config, seed * 31 + 7)
+  const env: Record<string, string> = rng.boolean(0.2) ? { OPENCODE_DISABLE_AUTOUPDATE: "1" } : {}
+  return { config, files, env }
+}
+
+export const generateInitialStates = (count: number, options?: { readonly seed?: number }): InitialState[] => {
+  const seed = options?.seed ?? 1
+  return Array.from({ length: count }, (_, index) =>
+    generateInitialState({ seed: seed + index, profile: configProfiles[index % configProfiles.length]! }),
+  )
+}

package/src/experimental/generators/random.ts

@@ -0,0 +1,35 @@
+export interface Rng {
+  readonly next: () => number
+  readonly int: (minimum: number, maximum: number) => number
+  readonly boolean: (probability?: number) => boolean
+  readonly pick: <T>(items: ReadonlyArray<T>) => T
+  readonly sample: <T>(items: ReadonlyArray<T>, count: number) => T[]
+  readonly subset: <T>(items: ReadonlyArray<T>, minimum?: number, maximum?: number) => T[]
+}
+
+/** Deterministic mulberry32-style RNG so generated fixtures are reproducible per seed. */
+export const createRng = (seed: number): Rng => {
+  let state = seed >>> 0 || 1
+  const next = () => {
+    state = (state + 0x6d2b79f5) >>> 0
+    let t = state
+    t = Math.imul(t ^ (t >>> 15), t | 1)
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+  }
+  const int = (minimum: number, maximum: number) => minimum + Math.floor(next() * (maximum - minimum + 1))
+  const boolean = (probability = 0.5) => next() < probability
+  const pick = <T>(items: ReadonlyArray<T>): T => {
+    if (items.length === 0) throw new Error("Cannot pick from an empty list")
+    return items[int(0, items.length - 1)]!
+  }
+  const sample = <T>(items: ReadonlyArray<T>, count: number): T[] => {
+    const copy = [...items]
+    const out: T[] = []
+    while (out.length < count && copy.length > 0) out.push(copy.splice(int(0, copy.length - 1), 1)[0]!)
+    return out
+  }
+  const subset = <T>(items: ReadonlyArray<T>, minimum = 0, maximum = items.length): T[] =>
+    sample(items, int(Math.min(minimum, items.length), Math.min(maximum, items.length)))
+  return { next, int, boolean, pick, sample, subset }
+}

package/src/experimental/hello-driver.ts

@@ -0,0 +1,42 @@
+import { connectBackendSimulation, connectSimulation, type OpenedExchange } from "../client/index.js"
+
+const ui = await connectSimulation({ url: requiredEnv("OPENCODE_SIMULATION_UI_WS") })
+const backend = await connectBackendSimulation({ url: requiredEnv("OPENCODE_SIMULATION_BACKEND_WS") })
+let completed!: () => void
+const responseCompleted = new Promise<void>((resolve) => {
+  completed = resolve
+})
+
+await backend.attach(async (request: OpenedExchange) => {
+  await backend.chunk(request.id, [{ type: "textDelta", text: "hello" }])
+  await backend.finish(request.id, "stop")
+  completed()
+})
+
+try {
+  await waitFor(async () => (await ui.state()).focused.editor)
+  await ui.typeText("Say hello")
+  await ui.pressEnter()
+  await responseCompleted
+  await waitFor(async () => (await backend.pendingExchanges()).exchanges.length === 0)
+  await ui.state()
+  await Bun.sleep(Number(process.env.OPENCODE_PROBE_HOLD_MS ?? "10000"))
+} finally {
+  ui.close()
+  backend.close()
+}
+
+function requiredEnv(name: string) {
+  const value = process.env[name]
+  if (value === undefined) throw new Error(`${name} is required`)
+  return value
+}
+
+async function waitFor(check: () => Promise<boolean>) {
+  const deadline = Date.now() + 30_000
+  while (Date.now() < deadline) {
+    if (await check()) return
+    await Bun.sleep(50)
+  }
+  throw new Error("timed out waiting for UI state")
+}

package/src/experimental/index.ts

@@ -0,0 +1,3 @@
+export * from "../client/index.js"
+export * from "./campaign-api.js"
+export * from "./drive.js"

package/src/experimental/model/derive.ts

@@ -0,0 +1,119 @@
+import type { InitialState } from "../generators/initial-state.js"
+import { normalizePath } from "../generators/filesystem.js"
+import type { ModelAgent, ModelPermission, ModelSkill, ProbeModel } from "./model.js"
+
+/**
+ * Derives the expected model from an initial state.
+ *
+ * Mirrors how OpenCode interprets the config and filesystem, but only for the
+ * facts the model asserts. Skill discovery intentionally follows core's
+ * `{*.md,**\/SKILL.md}` + frontmatter-name rules.
+ */
+const asRecord = (value: unknown): Record<string, unknown> | undefined =>
+  typeof value === "object" && value !== null && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined
+
+const asString = (value: unknown): string | undefined => (typeof value === "string" ? value : undefined)
+
+const stringArray = (value: unknown): string[] =>
+  Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : []
+
+const frontmatter = (content: string): Record<string, string> => {
+  const match = content.match(/^---\n([\s\S]*?)\n---/)
+  if (!match) return {}
+  const out: Record<string, string> = {}
+  for (const line of match[1]!.split("\n")) {
+    const colon = line.indexOf(":")
+    if (colon === -1) continue
+    out[line.slice(0, colon).trim()] = line.slice(colon + 1).trim()
+  }
+  return out
+}
+
+const deriveAgents = (config: Record<string, unknown>): Map<string, ModelAgent> => {
+  const out = new Map<string, ModelAgent>()
+  for (const [name, value] of Object.entries(asRecord(config.agents) ?? {})) {
+    const entry = asRecord(value) ?? {}
+    const mode = entry.mode
+    out.set(name, {
+      name,
+      disabled: entry.disabled === true,
+      hidden: entry.hidden === true,
+      ...(mode === "subagent" || mode === "primary" || mode === "all" ? { mode } : {}),
+      ...(asString(entry.model) === undefined ? {} : { model: asString(entry.model)! }),
+    })
+  }
+  return out
+}
+
+const derivePermissions = (config: Record<string, unknown>): ModelPermission[] => {
+  if (!Array.isArray(config.permissions)) return []
+  return config.permissions.flatMap((value) => {
+    const rule = asRecord(value)
+    const action = asString(rule?.action)
+    const resource = asString(rule?.resource)
+    const effect = rule?.effect
+    if (action === undefined || resource === undefined) return []
+    if (effect !== "allow" && effect !== "deny" && effect !== "ask") return []
+    return [{ action, resource, effect }]
+  })
+}
+
+const deriveSkills = (state: InitialState): ModelSkill[] => {
+  const sources = stringArray(state.config.skills)
+    .filter((source) => !source.includes("://"))
+    .map(normalizePath)
+  const skills: ModelSkill[] = []
+  for (const source of sources) {
+    const prefix = `${source}/`
+    for (const file of state.files.files) {
+      if (!file.path.startsWith(prefix)) continue
+      const rest = file.path.slice(prefix.length)
+      const isRootMarkdown = !rest.includes("/") && rest.endsWith(".md")
+      const isNestedSkill = rest.endsWith("/SKILL.md")
+      if (!isRootMarkdown && !isNestedSkill) continue
+      const name = frontmatter(file.content).name ?? (isRootMarkdown ? rest.slice(0, -3) : undefined)
+      if (name !== undefined) skills.push({ name, path: file.path })
+    }
+  }
+  return skills
+}
+
+const deriveReferences = (config: Record<string, unknown>): Map<string, string> => {
+  const out = new Map<string, string>()
+  for (const [name, value] of Object.entries(asRecord(config.references) ?? {})) {
+    const target =
+      asString(value) ?? asString(asRecord(value)?.path) ?? asString(asRecord(value)?.repository)
+    if (target !== undefined) out.set(name, target)
+  }
+  return out
+}
+
+const derivePlugins = (config: Record<string, unknown>): Set<string> => {
+  const out = new Set<string>()
+  if (!Array.isArray(config.plugins)) return out
+  for (const entry of config.plugins) {
+    const name = asString(entry) ?? asString(asRecord(entry)?.package)
+    if (name !== undefined) out.add(name)
+  }
+  return out
+}
+
+export const deriveModel = (state: InitialState): ProbeModel => {
+  const config = state.config
+  const share = config.share
+  const autoupdate = config.autoupdate
+  return {
+    ...(asString(config.model) === undefined ? {} : { configuredModel: asString(config.model)! }),
+    ...(asString(config.default_agent) === undefined ? {} : { defaultAgent: asString(config.default_agent)! }),
+    ...(share === "manual" || share === "auto" || share === "disabled" ? { share } : {}),
+    ...(typeof autoupdate === "boolean" || autoupdate === "notify" ? { autoupdate } : {}),
+    agents: deriveAgents(config),
+    commands: new Set(Object.keys(asRecord(config.commands) ?? {})),
+    skills: deriveSkills(state),
+    references: deriveReferences(config),
+    permissions: derivePermissions(config),
+    mcpServers: new Set(Object.keys(asRecord(asRecord(config.mcp)?.servers) ?? {})),
+    plugins: derivePlugins(config),
+    providers: new Set(Object.keys(asRecord(config.providers) ?? {})),
+  }
+}

package/src/experimental/model/index.ts

@@ -0,0 +1,2 @@
+export { deriveModel } from "./derive.js"
+export type { ModelAgent, ModelPermission, ModelSkill, ProbeModel } from "./model.js"

package/src/experimental/model/model.ts

@@ -0,0 +1,42 @@
+/**
+ * The simplified expected-state model for model-based testing.
+ *
+ * This is not a copy of OpenCode internals. It captures only the facts we
+ * intend to assert against a running OpenCode: which agents/skills/commands
+ * exist, which model is configured, what the permission posture is, etc.
+ *
+ * Initial states seed this model; test commands transition it.
+ */
+export interface ModelAgent {
+  readonly name: string
+  readonly disabled: boolean
+  readonly hidden: boolean
+  readonly mode?: "subagent" | "primary" | "all"
+  readonly model?: string
+}
+
+export interface ModelPermission {
+  readonly action: string
+  readonly resource: string
+  readonly effect: "allow" | "deny" | "ask"
+}
+
+export interface ModelSkill {
+  readonly name: string
+  readonly path: string
+}
+
+export interface ProbeModel {
+  readonly configuredModel?: string
+  readonly defaultAgent?: string
+  readonly share?: "manual" | "auto" | "disabled"
+  readonly autoupdate?: boolean | "notify"
+  readonly agents: ReadonlyMap<string, ModelAgent>
+  readonly commands: ReadonlySet<string>
+  readonly skills: ReadonlyArray<ModelSkill>
+  readonly references: ReadonlyMap<string, string>
+  readonly permissions: ReadonlyArray<ModelPermission>
+  readonly mcpServers: ReadonlySet<string>
+  readonly plugins: ReadonlySet<string>
+  readonly providers: ReadonlySet<string>
+}

package/src/experimental/opencode-simulation.ts

@@ -0,0 +1 @@
+export { SimulationProtocol } from "../../../opencode-latest/packages/simulation/src/protocol/index"