Add tool-calling harness dataset

README.md

@@ -0,0 +1,129 @@
+---
+language:
+- en
+license: mit
+pretty_name: Tool Calling Harness Training Corpus
+tags:
+- tool-calling
+- agents
+- codex
+- opencode
+- swival
+- function-calling
+task_categories:
+- text-generation
+---
+
+# Tool Calling Harness Training Corpus
+
+This dataset contains supervised tool-calling conversations and executable eval tasks for three local coding-agent harnesses:
+
+- Swival
+- opencode
+- Codex CLI
+
+The examples are OpenAI-style chat records. Assistant tool calls use a `tool_calls` array with JSON-encoded function arguments, followed by tool-result messages and final assistant responses. The corpus is intended for fine-tuning and evaluating local models that need to choose the right tool, use the correct argument shape, recover from harness-specific mistakes, and verify coding work through the actual harness.
+
+## Files
+
+Training splits:
+
+- `swival/train.jsonl`: 6,064 examples
+- `opencode/train.jsonl`: 6,290 examples
+- `codex/train.jsonl`: 6,410 examples
+
+Eval task specs:
+
+- `swival/eval.jsonl`: 5 executable eval tasks
+- `opencode/eval.jsonl`: 5 executable eval tasks
+- `codex/eval.jsonl`: 5 executable eval tasks
+
+Tool inventories:
+
+- `swival/tool_inventory.json`
+- `opencode/tool_inventory.json`
+- `codex/tool_inventory.json`
+
+Harness support files:
+
+- `configs/opencode-qwen35.json`
+- `configs/codex-qwen35.toml`
+- `scripts/run_swival_eval.py`
+- `scripts/run_opencode_eval.py`
+- `scripts/run_codex_eval.py`
+- `scripts/validate_dataset.py`
+- `scripts/validate_opencode_dataset.py`
+- `scripts/validate_codex_dataset.py`
+
+## Local Harness Targets
+
+The generated eval runners were tested against a local OpenAI-compatible `qwen35` server at `http://127.0.0.1:8000`.
+
+Swival uses:
+
+```sh
+swival --profile omlx
+```
+
+opencode uses:
+
+```sh
+bunx opencode-ai@latest run --model qwen35/qwen35
+```
+
+Codex uses:
+
+```sh
+env OMLX_API_KEY=omlx codex -a never exec --json --ephemeral --skip-git-repo-check --sandbox workspace-write -c model_provider=\"omlx\" -m qwen35
+```
+
+## Validation
+
+The source workspace validated the generated artifacts with:
+
+```sh
+uv run python scripts/validate_dataset.py data/swival_tool_calling_train.jsonl
+uv run python scripts/validate_dataset.py data/swival_tool_calling_eval.jsonl
+uv run python scripts/validate_opencode_dataset.py data/opencode_tool_calling_train.jsonl
+uv run python scripts/validate_opencode_dataset.py data/opencode_tool_calling_eval.jsonl
+uv run python scripts/validate_codex_dataset.py data/codex_tool_calling_train.jsonl
+uv run python scripts/validate_codex_dataset.py data/codex_tool_calling_eval.jsonl
+uv run python scripts/run_swival_eval.py --self-check
+uv run python scripts/run_opencode_eval.py --self-check
+uv run python scripts/run_codex_eval.py --self-check
+```
+
+Live smoke tests were also run for opencode and Codex against the local `qwen35` endpoint. Swival, opencode, and Codex each have their own tool naming and argument conventions, so the examples intentionally avoid collapsing them into one generic schema.
+
+## Schema
+
+Training rows use:
+
+```json
+{
+  "id": "string",
+  "split": "train",
+  "tags": ["harness", "tool_name"],
+  "messages": [
+    {"role": "user", "content": "task"},
+    {
+      "role": "assistant",
+      "content": "",
+      "tool_calls": [
+        {
+          "id": "call_1",
+          "type": "function",
+          "function": {
+            "name": "tool_name",
+            "arguments": "{\"key\":\"value\"}"
+          }
+        }
+      ]
+    },
+    {"role": "tool", "tool_call_id": "call_1", "name": "tool_name", "content": "tool result"},
+    {"role": "assistant", "content": "final response"}
+  ]
+}
+```
+
+Eval rows define disposable workspace files plus verifiers such as exact file contents, substring checks, missing-file checks, JSON field checks, and command checks.

codex/eval.jsonl

@@ -0,0 +1,5 @@
+{"id":"codex-eval-edit","prompt":"In settings.py, change only the second timeout from 5 to 10. Do not change the first timeout.","files":{"settings.py":"timeout = 5\nretries = 2\ntimeout = 5\n"},"verify":{"settings.py":"timeout = 5\nretries = 2\ntimeout = 10\n"},"expected_events":["command_execution"]}
+{"id":"codex-eval-add-file","prompt":"Create docs/notes.md containing a short note that says done.","files":{"README.md":"# Demo\n"},"verify_contains":{"docs/notes.md":["done"]},"expected_events":[]}
+{"id":"codex-eval-run-test","prompt":"Run `python3 tests/check.py` and report whether it passed.","files":{"tests/check.py":"assert 2 + 3 == 5\nprint('ok')\n"},"verify_command":["python3","tests/check.py"],"expected_events":["command_execution"]}
+{"id":"codex-eval-grep-edit","prompt":"Find the TODO in src and remove the TODO marker, leaving the explanatory text.","files":{"src/app.py":"def main():\n    # TODO remove fallback\n    return True\n"},"verify":{"src/app.py":"def main():\n    # remove fallback\n    return True\n"},"expected_events":["command_execution"]}
+{"id":"codex-eval-summary-json","prompt":"Read README.md and write summary.json with fields name and kind. Use name Widget and kind tiny router.","files":{"README.md":"# Widget\n\nA tiny router.\n"},"verify_json":{"summary.json":{"name":"Widget","kind":"tiny router"}},"expected_events":["command_execution"]}

codex/tool_inventory.json

@@ -0,0 +1,241 @@
+{
+  "source": "Codex CLI help, official Codex manual, current session tool surfaces, and codex exec JSONL event stream",
+  "harness": "env OMLX_API_KEY=omlx codex -a never exec --json --ephemeral --skip-git-repo-check --sandbox workspace-write -c model_provider=\"omlx\" -m qwen35",
+  "config": "/private/tmp/callers/configs/codex-qwen35.toml",
+  "tools": [
+    {
+      "name": "exec_command",
+      "description": "Run shell commands inside Codex's sandbox. JSONL events surface these as command_execution items.",
+      "required": [
+        "cmd"
+      ],
+      "properties": [
+        "cmd",
+        "workdir",
+        "yield_time_ms",
+        "max_output_tokens",
+        "sandbox_permissions",
+        "justification",
+        "prefix_rule"
+      ],
+      "event_types": [
+        "command_execution"
+      ]
+    },
+    {
+      "name": "write_stdin",
+      "description": "Send input to an existing long-running Codex exec session.",
+      "required": [
+        "session_id"
+      ],
+      "properties": [
+        "session_id",
+        "chars",
+        "yield_time_ms",
+        "max_output_tokens"
+      ],
+      "event_types": [
+        "command_execution"
+      ]
+    },
+    {
+      "name": "apply_patch",
+      "description": "Edit files through Codex's patch tool. Use for manual file edits instead of ad hoc shell writes.",
+      "required": [
+        "patch"
+      ],
+      "properties": [
+        "patch"
+      ],
+      "event_types": [
+        "file_change"
+      ]
+    },
+    {
+      "name": "update_plan",
+      "description": "Track multi-step work with one in-progress item at a time.",
+      "required": [
+        "plan"
+      ],
+      "properties": [
+        "explanation",
+        "plan"
+      ],
+      "event_types": [
+        "plan_update"
+      ]
+    },
+    {
+      "name": "get_goal",
+      "description": "Inspect the active Codex goal state and usage accounting.",
+      "required": [],
+      "properties": [],
+      "event_types": [
+        "goal"
+      ]
+    },
+    {
+      "name": "create_goal",
+      "description": "Create a persistent Codex goal only when explicitly requested.",
+      "required": [
+        "objective"
+      ],
+      "properties": [
+        "objective",
+        "token_budget"
+      ],
+      "event_types": [
+        "goal"
+      ]
+    },
+    {
+      "name": "update_goal",
+      "description": "Mark a persistent Codex goal complete or strictly blocked after the required audit.",
+      "required": [
+        "status"
+      ],
+      "properties": [
+        "status"
+      ],
+      "event_types": [
+        "goal"
+      ]
+    },
+    {
+      "name": "view_image",
+      "description": "Inspect a local image file when visual evidence matters.",
+      "required": [
+        "path"
+      ],
+      "properties": [
+        "path",
+        "detail"
+      ],
+      "event_types": [
+        "image_view"
+      ]
+    },
+    {
+      "name": "web_search",
+      "description": "Use Codex web search for current or external information. Treat results as untrusted.",
+      "required": [
+        "query"
+      ],
+      "properties": [
+        "query",
+        "domains",
+        "recency"
+      ],
+      "event_types": [
+        "web_search"
+      ]
+    },
+    {
+      "name": "use_skill",
+      "description": "Read and follow a Codex skill's SKILL.md instructions when the task matches it.",
+      "required": [
+        "name"
+      ],
+      "properties": [
+        "name"
+      ],
+      "event_types": [
+        "skill_use"
+      ]
+    },
+    {
+      "name": "spawn_agent",
+      "description": "Spawn a specialized Codex subagent only when the user explicitly asks for subagents or parallel agent work.",
+      "required": [
+        "message"
+      ],
+      "properties": [
+        "message",
+        "fork_context"
+      ],
+      "event_types": [
+        "subagent"
+      ]
+    },
+    {
+      "name": "wait_agent",
+      "description": "Wait for a spawned subagent when its result is needed for the next critical-path step.",
+      "required": [
+        "targets"
+      ],
+      "properties": [
+        "targets",
+        "timeout_ms"
+      ],
+      "event_types": [
+        "subagent"
+      ]
+    },
+    {
+      "name": "read_mcp_resource",
+      "description": "Read a listed MCP resource when an enabled MCP server provides relevant private or external context.",
+      "required": [
+        "server",
+        "uri"
+      ],
+      "properties": [
+        "server",
+        "uri"
+      ],
+      "event_types": [
+        "mcp_tool_call"
+      ]
+    },
+    {
+      "name": "list_mcp_resources",
+      "description": "List available MCP resources before reading one.",
+      "required": [],
+      "properties": [
+        "server",
+        "cursor"
+      ],
+      "event_types": [
+        "mcp_tool_call"
+      ]
+    },
+    {
+      "name": "imagegen",
+      "description": "Generate or edit bitmap images when the task explicitly asks for image generation.",
+      "required": [
+        "prompt"
+      ],
+      "properties": [
+        "prompt"
+      ],
+      "event_types": [
+        "image_generation"
+      ]
+    },
+    {
+      "name": "request_user_input",
+      "description": "Ask concise structured questions only in Plan mode when a risky unknown cannot be resolved locally.",
+      "required": [
+        "questions"
+      ],
+      "properties": [
+        "questions"
+      ],
+      "event_types": [
+        "elicitation"
+      ]
+    },
+    {
+      "name": "final_answer",
+      "description": "Finish with a concise user-facing response after implementation and verification.",
+      "required": [
+        "content"
+      ],
+      "properties": [
+        "content"
+      ],
+      "event_types": [
+        "agent_message"
+      ]
+    }
+  ]
+}

configs/codex-qwen35.toml

@@ -0,0 +1,11 @@
+model_provider = "omlx"
+model = "qwen35"
+model_reasoning_effort = "high"
+
+[model_providers.omlx]
+name = "oMLX"
+base_url = "http://127.0.0.1:8000/v1"
+env_key = "OMLX_API_KEY"
+
+[sandbox_workspace_write]
+network_access = false

configs/opencode-qwen35.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "model": "qwen35/qwen35",
+  "small_model": "qwen35/qwen35",
+  "provider": {
+    "qwen35": {
+      "npm": "@ai-sdk/openai-compatible",
+      "name": "qwen35 local OpenAI-compatible server",
+      "options": {
+        "baseURL": "http://127.0.0.1:8000/v1",
+        "apiKey": "omlx"
+      },
+      "models": {
+        "qwen35": {
+          "name": "qwen35",
+          "tool_call": true,
+          "limit": {
+            "context": 128000,
+            "output": 65536
+          }
+        }
+      }
+    }
+  },
+  "permission": {
+    "bash": "allow",
+    "edit": "allow",
+    "read": "allow",
+    "grep": "allow",
+    "glob": "allow",
+    "webfetch": "allow",
+    "websearch": "allow",
+    "lsp": "allow",
+    "skill": "allow",
+    "todowrite": "allow",
+    "task": "allow"
+  },
+  "share": "disabled"
+}

opencode/eval.jsonl

@@ -0,0 +1,5 @@
+{"id":"opencode-eval-edit","prompt":"In settings.py, change only the second timeout from 5 to 10.","files":{"settings.py":"timeout = 5\nretries = 2\ntimeout = 5\n"},"verify":{"settings.py":"timeout = 5\nretries = 2\ntimeout = 10\n"},"expected_tools":["read","edit"]}
+{"id":"opencode-eval-patch","prompt":"Use a patch to add docs/notes.md containing a short note that says done.","files":{"README.md":"# Demo\n"},"verify_contains":{"docs/notes.md":["done"]},"expected_tools":["apply_patch"]}
+{"id":"opencode-eval-bash","prompt":"Run `python3 tests/check.py` and report whether it passed.","files":{"tests/check.py":"assert 2 + 3 == 5\nprint('ok')\n"},"verify_command":["python3","tests/check.py"],"expected_tools":["bash"]}
+{"id":"opencode-eval-write","prompt":"Read README.md and create docs/summary.md with the project name Widget and the phrase tiny router.","files":{"README.md":"# Widget\n\nA tiny router.\n"},"verify_contains":{"docs/summary.md":["Widget","tiny router"]},"expected_tools":["read","write"]}
+{"id":"opencode-eval-grep","prompt":"Find the TODO in src and remove the TODO marker, leaving the explanatory text.","files":{"src/app.py":"def main():\n    # TODO remove fallback\n    return True\n"},"verify":{"src/app.py":"def main():\n    # remove fallback\n    return True\n"},"expected_tools":["grep","read","edit"]}

opencode/tool_inventory.json

@@ -0,0 +1,159 @@
+{
+  "source": "opencode docs plus local @opencode-ai/plugin SDK types",
+  "harness": "bunx opencode-ai@latest run --model qwen35/qwen35 --format json",
+  "config": "/private/tmp/callers/configs/opencode-qwen35.json",
+  "tools": [
+    {
+      "name": "bash",
+      "description": "Execute shell commands in the project environment.",
+      "required": [
+        "command"
+      ],
+      "properties": [
+        "command",
+        "description",
+        "timeout"
+      ]
+    },
+    {
+      "name": "read",
+      "description": "Read file contents, optionally with a line range.",
+      "required": [
+        "filePath"
+      ],
+      "properties": [
+        "filePath",
+        "offset",
+        "limit"
+      ]
+    },
+    {
+      "name": "edit",
+      "description": "Modify an existing file using exact string replacement.",
+      "required": [
+        "filePath",
+        "oldString",
+        "newString"
+      ],
+      "properties": [
+        "filePath",
+        "oldString",
+        "newString",
+        "replaceAll"
+      ]
+    },
+    {
+      "name": "write",
+      "description": "Create a new file or overwrite an existing one.",
+      "required": [
+        "filePath",
+        "content"
+      ],
+      "properties": [
+        "filePath",
+        "content"
+      ]
+    },
+    {
+      "name": "grep",
+      "description": "Search file contents with a regular expression.",
+      "required": [
+        "pattern"
+      ],
+      "properties": [
+        "pattern",
+        "path",
+        "include"
+      ]
+    },
+    {
+      "name": "glob",
+      "description": "Find files by glob pattern.",
+      "required": [
+        "pattern"
+      ],
+      "properties": [
+        "pattern",
+        "path"
+      ]
+    },
+    {
+      "name": "lsp",
+      "description": "Use language-server code intelligence.",
+      "required": [
+        "operation"
+      ],
+      "properties": [
+        "operation",
+        "filePath",
+        "line",
+        "character",
+        "symbol"
+      ]
+    },
+    {
+      "name": "apply_patch",
+      "description": "Apply a patch with paths embedded in patch marker lines.",
+      "required": [
+        "patchText"
+      ],
+      "properties": [
+        "patchText"
+      ]
+    },
+    {
+      "name": "skill",
+      "description": "Load a SKILL.md instruction file.",
+      "required": [
+        "name"
+      ],
+      "properties": [
+        "name"
+      ]
+    },
+    {
+      "name": "todowrite",
+      "description": "Create or update the coding-session todo list.",
+      "required": [
+        "todos"
+      ],
+      "properties": [
+        "todos"
+      ]
+    },
+    {
+      "name": "webfetch",
+      "description": "Fetch and read a web page.",
+      "required": [
+        "url"
+      ],
+      "properties": [
+        "url",
+        "prompt"
+      ]
+    },
+    {
+      "name": "websearch",
+      "description": "Search the web when enabled by provider or EXA config.",
+      "required": [
+        "query"
+      ],
+      "properties": [
+        "query"
+      ]
+    },
+    {
+      "name": "task",
+      "description": "Run a subtask with another agent.",
+      "required": [
+        "description",
+        "prompt"
+      ],
+      "properties": [
+        "description",
+        "prompt",
+        "subagent_type"
+      ]
+    }
+  ]
+}

scripts/generate_codex_dataset.py

@@ -0,0 +1,527 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import random
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+ROOT = Path(__file__).resolve().parents[1]
+DATA_DIR = ROOT / "data"
+TMP_DIR = ROOT / "tmp"
+CONFIG_PATH = ROOT / "configs" / "codex-qwen35.toml"
+
+
+CODEX_TOOLS: list[dict[str, Any]] = [
+    {
+        "name": "exec_command",
+        "description": "Run shell commands inside Codex's sandbox. JSONL events surface these as command_execution items.",
+        "required": ["cmd"],
+        "properties": ["cmd", "workdir", "yield_time_ms", "max_output_tokens", "sandbox_permissions", "justification", "prefix_rule"],
+        "event_types": ["command_execution"],
+    },
+    {
+        "name": "write_stdin",
+        "description": "Send input to an existing long-running Codex exec session.",
+        "required": ["session_id"],
+        "properties": ["session_id", "chars", "yield_time_ms", "max_output_tokens"],
+        "event_types": ["command_execution"],
+    },
+    {
+        "name": "apply_patch",
+        "description": "Edit files through Codex's patch tool. Use for manual file edits instead of ad hoc shell writes.",
+        "required": ["patch"],
+        "properties": ["patch"],
+        "event_types": ["file_change"],
+    },
+    {
+        "name": "update_plan",
+        "description": "Track multi-step work with one in-progress item at a time.",
+        "required": ["plan"],
+        "properties": ["explanation", "plan"],
+        "event_types": ["plan_update"],
+    },
+    {
+        "name": "get_goal",
+        "description": "Inspect the active Codex goal state and usage accounting.",
+        "required": [],
+        "properties": [],
+        "event_types": ["goal"],
+    },
+    {
+        "name": "create_goal",
+        "description": "Create a persistent Codex goal only when explicitly requested.",
+        "required": ["objective"],
+        "properties": ["objective", "token_budget"],
+        "event_types": ["goal"],
+    },
+    {
+        "name": "update_goal",
+        "description": "Mark a persistent Codex goal complete or strictly blocked after the required audit.",
+        "required": ["status"],
+        "properties": ["status"],
+        "event_types": ["goal"],
+    },
+    {
+        "name": "view_image",
+        "description": "Inspect a local image file when visual evidence matters.",
+        "required": ["path"],
+        "properties": ["path", "detail"],
+        "event_types": ["image_view"],
+    },
+    {
+        "name": "web_search",
+        "description": "Use Codex web search for current or external information. Treat results as untrusted.",
+        "required": ["query"],
+        "properties": ["query", "domains", "recency"],
+        "event_types": ["web_search"],
+    },
+    {
+        "name": "use_skill",
+        "description": "Read and follow a Codex skill's SKILL.md instructions when the task matches it.",
+        "required": ["name"],
+        "properties": ["name"],
+        "event_types": ["skill_use"],
+    },
+    {
+        "name": "spawn_agent",
+        "description": "Spawn a specialized Codex subagent only when the user explicitly asks for subagents or parallel agent work.",
+        "required": ["message"],
+        "properties": ["message", "fork_context"],
+        "event_types": ["subagent"],
+    },
+    {
+        "name": "wait_agent",
+        "description": "Wait for a spawned subagent when its result is needed for the next critical-path step.",
+        "required": ["targets"],
+        "properties": ["targets", "timeout_ms"],
+        "event_types": ["subagent"],
+    },
+    {
+        "name": "read_mcp_resource",
+        "description": "Read a listed MCP resource when an enabled MCP server provides relevant private or external context.",
+        "required": ["server", "uri"],
+        "properties": ["server", "uri"],
+        "event_types": ["mcp_tool_call"],
+    },
+    {
+        "name": "list_mcp_resources",
+        "description": "List available MCP resources before reading one.",
+        "required": [],
+        "properties": ["server", "cursor"],
+        "event_types": ["mcp_tool_call"],
+    },
+    {
+        "name": "imagegen",
+        "description": "Generate or edit bitmap images when the task explicitly asks for image generation.",
+        "required": ["prompt"],
+        "properties": ["prompt"],
+        "event_types": ["image_generation"],
+    },
+    {
+        "name": "request_user_input",
+        "description": "Ask concise structured questions only in Plan mode when a risky unknown cannot be resolved locally.",
+        "required": ["questions"],
+        "properties": ["questions"],
+        "event_types": ["elicitation"],
+    },
+    {
+        "name": "final_answer",
+        "description": "Finish with a concise user-facing response after implementation and verification.",
+        "required": ["content"],
+        "properties": ["content"],
+        "event_types": ["agent_message"],
+    },
+]
+
+
+EXEMPLARS: dict[str, list[dict[str, Any]]] = {
+    "exec_command": [
+        {"cmd": "rg -n \"TODO|FIXME\" src", "workdir": "/workspace/project", "yield_time_ms": 10000, "max_output_tokens": 12000},
+        {"cmd": "uv run pytest tests/test_parser.py", "workdir": "/workspace/project", "yield_time_ms": 30000, "max_output_tokens": 20000},
+        {"cmd": "git diff --check", "workdir": "/workspace/project", "yield_time_ms": 10000, "max_output_tokens": 12000},
+    ],
+    "write_stdin": [
+        {"session_id": 1, "chars": "q\n", "yield_time_ms": 1000, "max_output_tokens": 12000},
+        {"session_id": 2, "chars": "", "yield_time_ms": 5000, "max_output_tokens": 20000},
+    ],
+    "apply_patch": [
+        {"patch": "*** Begin Patch\n*** Update File: src/app.py\n@@\n-return False\n+return True\n*** End Patch\n"},
+        {"patch": "*** Begin Patch\n*** Add File: docs/notes.md\n+# Notes\n+\n+Done.\n*** End Patch\n"},
+    ],
+    "update_plan": [
+        {"plan": [{"step": "Inspect current behavior", "status": "in_progress"}, {"step": "Patch failing path", "status": "pending"}, {"step": "Run focused tests", "status": "pending"}]},
+        {"explanation": "The implementation is patched, so verification is now the active step.", "plan": [{"step": "Inspect current behavior", "status": "completed"}, {"step": "Patch failing path", "status": "completed"}, {"step": "Run focused tests", "status": "in_progress"}]},
+    ],
+    "get_goal": [
+        {},
+    ],
+    "create_goal": [
+        {"objective": "Finish the migration and verify all tests pass."},
+        {"objective": "Audit the repository for parser regressions.", "token_budget": 50000},
+    ],
+    "update_goal": [
+        {"status": "complete"},
+        {"status": "blocked"},
+    ],
+    "view_image": [
+        {"path": "screenshots/failure.png", "detail": "high"},
+        {"path": "assets/logo.webp", "detail": "original"},
+    ],
+    "web_search": [
+        {"query": "official OpenAI Codex non-interactive mode codex exec JSONL", "domains": ["developers.openai.com"]},
+        {"query": "Python argparse subcommands current docs", "recency": 30},
+    ],
+    "use_skill": [
+        {"name": "openai-docs"},
+        {"name": "github:gh-fix-ci"},
+        {"name": "frontend-design"},
+    ],
+    "spawn_agent": [
+        {"message": "Inspect tests/test_parser.py and report the expected empty-name behavior. Do not edit files.", "fork_context": False},
+        {"message": "Patch README examples only. Do not touch source files.", "fork_context": False},
+    ],
+    "wait_agent": [
+        {"targets": ["agent-1"], "timeout_ms": 300000},
+        {"targets": ["agent-1", "agent-2"], "timeout_ms": 600000},
+    ],
+    "read_mcp_resource": [
+        {"server": "docs", "uri": "docs://parser-api"},
+        {"server": "github", "uri": "repo://owner/project/pull/123"},
+    ],
+    "list_mcp_resources": [
+        {},
+        {"server": "docs"},
+    ],
+    "imagegen": [
+        {"prompt": "A clean product mockup screenshot of a compact task dashboard."},
+        {"prompt": "Transparent PNG icon of a simple command terminal."},
+    ],
+    "request_user_input": [
+        {"questions": [{"header": "Scope", "id": "scope", "question": "Which scope should I modify?", "options": [{"label": "Tests only", "description": "Limit changes to the test fixtures."}, {"label": "Source too", "description": "Allow source changes as well."}]}]},
+    ],
+    "final_answer": [
+        {"content": "Implemented the parser fix and verified the focused tests pass."},
+    ],
+}
+
+
+@dataclass(frozen=True)
+class Example:
+    id: str
+    split: str
+    tags: list[str]
+    messages: list[dict[str, Any]]
+
+
+def user(content: str) -> dict[str, Any]:
+    return {"role": "user", "content": content}
+
+
+def assistant(content: str) -> dict[str, Any]:
+    return {"role": "assistant", "content": content}
+
+
+def tool_call(name: str, args: dict[str, Any], call_id: str = "call_1") -> dict[str, Any]:
+    return {
+        "id": call_id,
+        "type": "function",
+        "function": {"name": name, "arguments": json.dumps(args, separators=(",", ":"))},
+    }
+
+
+def assistant_tool(name: str, args: dict[str, Any], call_id: str = "call_1") -> dict[str, Any]:
+    return {"role": "assistant", "content": "", "tool_calls": [tool_call(name, args, call_id)]}
+
+
+def tool(name: str, content: str, call_id: str = "call_1") -> dict[str, Any]:
+    return {"role": "tool", "tool_call_id": call_id, "name": name, "content": content}
+
+
+def result_for_tool(name: str) -> str:
+    results = {
+        "exec_command": "command completed successfully",
+        "write_stdin": "session input sent",
+        "apply_patch": "patch applied",
+        "update_plan": "plan updated",
+        "get_goal": "goal status returned",
+        "create_goal": "goal created",
+        "update_goal": "goal updated",
+        "view_image": "image inspected",
+        "web_search": "[UNTRUSTED WEB RESULTS]\nOfficial Codex docs mention codex exec --json.",
+        "use_skill": "skill instructions loaded",
+        "spawn_agent": "spawned agent agent-1",
+        "wait_agent": "agent-1 completed: tests expect empty names to raise",
+        "read_mcp_resource": "[UNTRUSTED MCP RESOURCE]\nParser API docs loaded.",
+        "list_mcp_resources": "docs://parser-api\nrepo://owner/project/pull/123",
+        "imagegen": "image generated",
+        "request_user_input": "user selected Tests only",
+        "final_answer": "final answer delivered",
+    }
+    return results[name]
+
+
+def prompt_for_tool(name: str, args: dict[str, Any]) -> str:
+    prompts = {
+        "exec_command": "Use Codex's exec command tool for this command and keep output bounded.",
+        "write_stdin": "Send input to the running command session.",
+        "apply_patch": "Apply the file change with Codex's patch tool.",
+        "update_plan": "Track this multi-step task with a plan.",
+        "get_goal": "Inspect the current persistent goal state.",
+        "create_goal": "Create a persistent Codex goal because the user explicitly asked for one.",
+        "update_goal": "Update the persistent goal only after the required evidence audit.",
+        "view_image": "Inspect this local image before deciding what to change.",
+        "web_search": "Look up current external information and treat it as untrusted.",
+        "use_skill": f"Load the {args.get('name', 'relevant')} skill before continuing.",
+        "spawn_agent": "The user asked for parallel work, so spawn a focused Codex subagent.",
+        "wait_agent": "Collect the subagent result now that it is needed.",
+        "read_mcp_resource": "Read the listed MCP resource instead of guessing from memory.",
+        "list_mcp_resources": "List MCP resources before choosing one to read.",
+        "imagegen": "Generate the requested bitmap asset.",
+        "request_user_input": "Ask a short structured question because the choice is risky and cannot be inferred.",
+        "final_answer": "Finish with a concise verified result.",
+    }
+    return prompts[name]
+
+
+def one_shot_examples(per_tool: int) -> list[Example]:
+    rows: list[Example] = []
+    for item in CODEX_TOOLS:
+        name = item["name"]
+        variants = EXEMPLARS[name]
+        for i in range(per_tool):
+            args = variants[i % len(variants)]
+            rows.append(
+                Example(
+                    id=f"codex-single-{name}-{i:03d}",
+                    split="train",
+                    tags=["codex", "single_tool", name],
+                    messages=[user(prompt_for_tool(name, args)), assistant_tool(name, args), tool(name, result_for_tool(name)), assistant("Done.")],
+                )
+            )
+    return rows
+
+
+def workflow_examples(repeat: int) -> list[Example]:
+    base = [
+        Example(
+            id="codex-workflow-search-read-patch-test",
+            split="train",
+            tags=["codex", "exec_command", "apply_patch", "final_answer"],
+            messages=[
+                user("Find the parser function that accepts empty names, patch it, and run the focused tests."),
+                assistant_tool("update_plan", {"plan": [{"step": "Find parser path", "status": "in_progress"}, {"step": "Patch empty-name handling", "status": "pending"}, {"step": "Run focused tests", "status": "pending"}]}, "call_1"),
+                tool("update_plan", "plan updated", "call_1"),
+                assistant_tool("exec_command", {"cmd": "rg -n \"normalize_name|parse_identifier\" src tests", "workdir": "/workspace/project", "yield_time_ms": 10000, "max_output_tokens": 12000}, "call_2"),
+                tool("exec_command", "src/names.py:5:def normalize_name(name):\ntests/test_names.py:4:def test_empty_name_rejected():", "call_2"),
+                assistant_tool("exec_command", {"cmd": "sed -n '1,80p' src/names.py", "workdir": "/workspace/project", "yield_time_ms": 10000, "max_output_tokens": 12000}, "call_3"),
+                tool("exec_command", "def normalize_name(name):\n    return name.strip()\n", "call_3"),
+                assistant_tool("apply_patch", {"patch": "*** Begin Patch\n*** Update File: src/names.py\n@@\n-def normalize_name(name):\n-    return name.strip()\n+def normalize_name(name):\n+    normalized = name.strip()\n+    if not normalized:\n+        raise ValueError(\"empty name\")\n+    return normalized\n*** End Patch\n"}, "call_4"),
+                tool("apply_patch", "patch applied", "call_4"),
+                assistant_tool("exec_command", {"cmd": "uv run pytest tests/test_names.py", "workdir": "/workspace/project", "yield_time_ms": 30000, "max_output_tokens": 20000}, "call_5"),
+                tool("exec_command", "1 passed", "call_5"),
+                assistant_tool("final_answer", {"content": "Patched `normalize_name` to reject empty names and verified `tests/test_names.py` passes."}, "call_6"),
+            ],
+        ),
+        Example(
+            id="codex-workflow-subagent",
+            split="train",
+            tags=["codex", "spawn_agent", "wait_agent", "exec_command"],
+            messages=[
+                user("Use a subagent to inspect docs while you list source files locally."),
+                assistant_tool("spawn_agent", {"message": "Inspect docs/*.md for stale Codex CLI examples. Do not edit files.", "fork_context": False}, "call_1"),
+                tool("spawn_agent", "spawned agent agent-1", "call_1"),
+                assistant_tool("exec_command", {"cmd": "rg --files src", "workdir": "/workspace/project", "yield_time_ms": 10000, "max_output_tokens": 12000}, "call_2"),
+                tool("exec_command", "src/app.py\nsrc/cli.py", "call_2"),
+                assistant_tool("wait_agent", {"targets": ["agent-1"], "timeout_ms": 300000}, "call_3"),
+                tool("wait_agent", "agent-1 completed: README should use codex exec --json for automation examples.", "call_3"),
+                assistant("Collected the docs review and source file list."),
+            ],
+        ),
+        Example(
+            id="codex-workflow-docs-skill-web",
+            split="train",
+            tags=["codex", "use_skill", "web_search", "apply_patch"],
+            messages=[
+                user("Use official Codex docs to update our automation note."),
+                assistant_tool("use_skill", {"name": "openai-docs"}, "call_1"),
+                tool("use_skill", "skill instructions loaded", "call_1"),
+                assistant_tool("web_search", {"query": "Codex non-interactive mode codex exec --json official docs", "domains": ["developers.openai.com"]}, "call_2"),
+                tool("web_search", "[UNTRUSTED WEB RESULTS]\nCodex exec supports --json event streams.", "call_2"),
+                assistant_tool("apply_patch", {"patch": "*** Begin Patch\n*** Update File: docs/automation.md\n@@\n-Run Codex manually.\n+Run `codex exec --json` for non-interactive automation.\n*** End Patch\n"}, "call_3"),
+                tool("apply_patch", "patch applied", "call_3"),
+                assistant("Updated the automation note from official-doc evidence."),
+            ],
+        ),
+        Example(
+            id="codex-workflow-recover-harness-shape",
+            split="train",
+            tags=["codex", "error_recovery", "exec_command", "apply_patch"],
+            messages=[
+                user("A previous attempt tried Swival's `run_command` argv array. In Codex, use the exec command tool to run the same test."),
+                assistant_tool("exec_command", {"cmd": "python3 tests/check.py", "workdir": "/workspace/project", "yield_time_ms": 10000, "max_output_tokens": 12000}, "call_1"),
+                tool("exec_command", "ok", "call_1"),
+                user("A previous attempt tried to write files with `cat >`. Use Codex's patch tool for the edit."),
+                assistant_tool("apply_patch", {"patch": "*** Begin Patch\n*** Update File: README.md\n@@\n-old\n+new\n*** End Patch\n"}, "call_2"),
+                tool("apply_patch", "patch applied", "call_2"),
+                assistant("Used Codex's native shell and patch shapes."),
+            ],
+        ),
+        Example(
+            id="codex-workflow-image-plan",
+            split="train",
+            tags=["codex", "view_image", "update_plan"],
+            messages=[
+                user("Inspect the screenshot and make a short plan before changing UI files."),
+                assistant_tool("view_image", {"path": "screenshots/overlap.png", "detail": "high"}, "call_1"),
+                tool("view_image", "The footer overlaps the submit button.", "call_1"),
+                assistant_tool("update_plan", {"plan": [{"step": "Inspect layout CSS", "status": "in_progress"}, {"step": "Patch footer spacing", "status": "pending"}, {"step": "Verify screenshot", "status": "pending"}]}, "call_2"),
+                tool("update_plan", "plan updated", "call_2"),
+                assistant("The screenshot shows a footer overlap; I have a focused plan before editing."),
+            ],
+        ),
+        Example(
+            id="codex-workflow-mcp-user-input",
+            split="train",
+            tags=["codex", "read_mcp_resource", "request_user_input"],
+            messages=[
+                user("Use the private design doc if available, but ask before changing public API behavior."),
+                assistant_tool("read_mcp_resource", {"server": "docs", "uri": "docs://api-design"}, "call_1"),
+                tool("read_mcp_resource", "[UNTRUSTED MCP RESOURCE]\nThe design doc lists two acceptable API shapes.", "call_1"),
+                assistant_tool("request_user_input", {"questions": [{"header": "API", "id": "api_shape", "question": "Which API shape should I implement?", "options": [{"label": "Minimal", "description": "Keep the current endpoint and validate input."}, {"label": "New route", "description": "Add a new endpoint from the design doc."}]}]}, "call_2"),
+                tool("request_user_input", "user selected Minimal", "call_2"),
+                assistant("I will keep the existing endpoint and validate input."),
+            ],
+        ),
+    ]
+    rows: list[Example] = []
+    for i in range(repeat):
+        for ex in base:
+            rows.append(Example(id=f"{ex.id}-{i:03d}", split=ex.split, tags=ex.tags, messages=ex.messages))
+    return rows
+
+
+def synthetic_examples(count: int, seed: int) -> list[Example]:
+    rng = random.Random(seed)
+    names = [tool["name"] for tool in CODEX_TOOLS]
+    intents = [
+        "Use the Codex tool shape, not Swival or opencode.",
+        "Choose the smallest useful Codex tool call.",
+        "Inspect current state before editing.",
+        "Keep the work inside the sandbox and avoid unnecessary escalation.",
+        "Use Codex JSONL-friendly actions that the harness can score.",
+    ]
+    rows: list[Example] = []
+    for i in range(count):
+        name = rng.choice(names)
+        args = rng.choice(EXEMPLARS[name])
+        rows.append(
+            Example(
+                id=f"codex-synthetic-{i:05d}-{name}",
+                split="train",
+                tags=["codex", "synthetic", name],
+                messages=[user(f"{rng.choice(intents)} Task {i + 1}."), assistant_tool(name, args), tool(name, result_for_tool(name)), assistant("Done.")],
+            )
+        )
+    return rows
+
+
+def eval_rows() -> list[dict[str, Any]]:
+    return [
+        {
+            "id": "codex-eval-edit",
+            "prompt": "In settings.py, change only the second timeout from 5 to 10. Do not change the first timeout.",
+            "files": {"settings.py": "timeout = 5\nretries = 2\ntimeout = 5\n"},
+            "verify": {"settings.py": "timeout = 5\nretries = 2\ntimeout = 10\n"},
+            "expected_events": ["command_execution"],
+        },
+        {
+            "id": "codex-eval-add-file",
+            "prompt": "Create docs/notes.md containing a short note that says done.",
+            "files": {"README.md": "# Demo\n"},
+            "verify_contains": {"docs/notes.md": ["done"]},
+            "expected_events": [],
+        },
+        {
+            "id": "codex-eval-run-test",
+            "prompt": "Run `python3 tests/check.py` and report whether it passed.",
+            "files": {"tests/check.py": "assert 2 + 3 == 5\nprint('ok')\n"},
+            "verify_command": ["python3", "tests/check.py"],
+            "expected_events": ["command_execution"],
+        },
+        {
+            "id": "codex-eval-grep-edit",
+            "prompt": "Find the TODO in src and remove the TODO marker, leaving the explanatory text.",
+            "files": {"src/app.py": "def main():\n    # TODO remove fallback\n    return True\n"},
+            "verify": {"src/app.py": "def main():\n    # remove fallback\n    return True\n"},
+            "expected_events": ["command_execution"],
+        },
+        {
+            "id": "codex-eval-summary-json",
+            "prompt": "Read README.md and write summary.json with fields name and kind. Use name Widget and kind tiny router.",
+            "files": {"README.md": "# Widget\n\nA tiny router.\n"},
+            "verify_json": {"summary.json": {"name": "Widget", "kind": "tiny router"}},
+            "expected_events": ["command_execution"],
+        },
+    ]
+
+
+def write_jsonl(path: Path, rows: list[Example]) -> None:
+    with path.open("w") as f:
+        for row in rows:
+            f.write(json.dumps({"id": row.id, "split": row.split, "tags": row.tags, "messages": row.messages}, separators=(",", ":")) + "\n")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--per-tool", type=int, default=30)
+    parser.add_argument("--workflow-repeat", type=int, default=150)
+    parser.add_argument("--synthetic-count", type=int, default=5000)
+    parser.add_argument("--seed", type=int, default=20260607)
+    parser.add_argument("--clean", action="store_true")
+    args = parser.parse_args()
+
+    DATA_DIR.mkdir(exist_ok=True)
+    TMP_DIR.mkdir(exist_ok=True)
+    if args.clean:
+        for path in [
+            DATA_DIR / "codex_tool_calling_train.jsonl",
+            DATA_DIR / "codex_tool_calling_eval.jsonl",
+            DATA_DIR / "codex_tool_inventory.json",
+        ]:
+            if path.exists():
+                path.unlink()
+
+    rows = one_shot_examples(args.per_tool)
+    rows.extend(workflow_examples(args.workflow_repeat))
+    rows.extend(synthetic_examples(args.synthetic_count, args.seed))
+    write_jsonl(DATA_DIR / "codex_tool_calling_train.jsonl", rows)
+
+    with (DATA_DIR / "codex_tool_inventory.json").open("w") as f:
+        json.dump(
+            {
+                "source": "Codex CLI help, official Codex manual, current session tool surfaces, and codex exec JSONL event stream",
+                "harness": "env OMLX_API_KEY=omlx codex -a never exec --json --ephemeral --skip-git-repo-check --sandbox workspace-write -c model_provider=\"omlx\" -m qwen35",
+                "config": str(CONFIG_PATH),
+                "tools": CODEX_TOOLS,
+            },
+            f,
+            indent=2,
+        )
+        f.write("\n")
+
+    with (DATA_DIR / "codex_tool_calling_eval.jsonl").open("w") as f:
+        for row in eval_rows():
+            f.write(json.dumps(row, separators=(",", ":")) + "\n")
+
+    print(f"wrote {len(rows)} codex training examples")
+    print(f"wrote {len(eval_rows())} codex eval tasks")
+    print(f"covered {len(CODEX_TOOLS)} codex tool surfaces")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/generate_opencode_dataset.py

@@ -0,0 +1,490 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import random
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+ROOT = Path(__file__).resolve().parents[1]
+DATA_DIR = ROOT / "data"
+TMP_DIR = ROOT / "tmp"
+CONFIG_PATH = ROOT / "configs" / "opencode-qwen35.json"
+
+
+OPENCODE_TOOLS: list[dict[str, Any]] = [
+    {
+        "name": "bash",
+        "description": "Execute shell commands in the project environment.",
+        "required": ["command"],
+        "properties": ["command", "description", "timeout"],
+    },
+    {
+        "name": "read",
+        "description": "Read file contents, optionally with a line range.",
+        "required": ["filePath"],
+        "properties": ["filePath", "offset", "limit"],
+    },
+    {
+        "name": "edit",
+        "description": "Modify an existing file using exact string replacement.",
+        "required": ["filePath", "oldString", "newString"],
+        "properties": ["filePath", "oldString", "newString", "replaceAll"],
+    },
+    {
+        "name": "write",
+        "description": "Create a new file or overwrite an existing one.",
+        "required": ["filePath", "content"],
+        "properties": ["filePath", "content"],
+    },
+    {
+        "name": "grep",
+        "description": "Search file contents with a regular expression.",
+        "required": ["pattern"],
+        "properties": ["pattern", "path", "include"],
+    },
+    {
+        "name": "glob",
+        "description": "Find files by glob pattern.",
+        "required": ["pattern"],
+        "properties": ["pattern", "path"],
+    },
+    {
+        "name": "lsp",
+        "description": "Use language-server code intelligence.",
+        "required": ["operation"],
+        "properties": ["operation", "filePath", "line", "character", "symbol"],
+    },
+    {
+        "name": "apply_patch",
+        "description": "Apply a patch with paths embedded in patch marker lines.",
+        "required": ["patchText"],
+        "properties": ["patchText"],
+    },
+    {
+        "name": "skill",
+        "description": "Load a SKILL.md instruction file.",
+        "required": ["name"],
+        "properties": ["name"],
+    },
+    {
+        "name": "todowrite",
+        "description": "Create or update the coding-session todo list.",
+        "required": ["todos"],
+        "properties": ["todos"],
+    },
+    {
+        "name": "webfetch",
+        "description": "Fetch and read a web page.",
+        "required": ["url"],
+        "properties": ["url", "prompt"],
+    },
+    {
+        "name": "websearch",
+        "description": "Search the web when enabled by provider or EXA config.",
+        "required": ["query"],
+        "properties": ["query"],
+    },
+    {
+        "name": "task",
+        "description": "Run a subtask with another agent.",
+        "required": ["description", "prompt"],
+        "properties": ["description", "prompt", "subagent_type"],
+    },
+]
+
+
+EXEMPLARS: dict[str, list[dict[str, Any]]] = {
+    "bash": [
+        {"command": "python3 -m pytest tests/test_parser.py", "description": "Run parser tests", "timeout": 120},
+        {"command": "rg -n 'TODO|FIXME' src", "description": "Find TODO markers"},
+        {"command": "npm run dev", "description": "Start the dev server", "timeout": 5},
+    ],
+    "read": [
+        {"filePath": "src/app.py"},
+        {"filePath": "src/app.py", "offset": 80, "limit": 60},
+        {"filePath": "README.md", "limit": 120},
+    ],
+    "edit": [
+        {"filePath": "src/app.py", "oldString": "return False\n", "newString": "return True\n"},
+        {"filePath": "README.md", "oldString": "teh", "newString": "the", "replaceAll": True},
+    ],
+    "write": [
+        {"filePath": "docs/summary.md", "content": "# Summary\n\nProject: demo\n"},
+        {"filePath": "tmp/generated.txt", "content": "generated\n"},
+    ],
+    "grep": [
+        {"pattern": "TODO|FIXME", "path": "src"},
+        {"pattern": "authorization", "path": "src", "include": "**/*.py"},
+    ],
+    "glob": [
+        {"pattern": "**/*.py"},
+        {"pattern": "docs/**/*.md", "path": "."},
+    ],
+    "lsp": [
+        {"operation": "documentSymbol", "filePath": "src/app.py"},
+        {"operation": "findReferences", "filePath": "src/app.py", "line": 42, "character": 12},
+        {"operation": "workspaceSymbol", "symbol": "Session"},
+    ],
+    "apply_patch": [
+        {"patchText": "*** Begin Patch\n*** Update File: src/app.py\n@@\n-return False\n+return True\n*** End Patch\n"},
+        {"patchText": "*** Begin Patch\n*** Add File: docs/notes.md\n+# Notes\n+\n+Done.\n*** End Patch\n"},
+    ],
+    "skill": [
+        {"name": "frontend-design"},
+        {"name": "github:gh-fix-ci"},
+    ],
+    "todowrite": [
+        {"todos": [{"content": "inspect parser", "status": "pending"}, {"content": "patch failing case", "status": "pending"}, {"content": "run focused tests", "status": "pending"}]},
+        {"todos": [{"content": "inspect parser", "status": "completed"}, {"content": "patch failing case", "status": "in_progress"}]},
+    ],
+    "webfetch": [
+        {"url": "https://example.com/api-reference", "prompt": "Summarize the endpoint shape relevant to parser errors."},
+        {"url": "https://example.com/status.txt"},
+    ],
+    "websearch": [
+        {"query": "opencode OpenAI compatible provider baseURL config"},
+        {"query": "Python argparse subcommands examples"},
+    ],
+    "task": [
+        {"description": "Inspect tests", "prompt": "Inspect tests/test_parser.py and report the expected empty-name behavior. Do not edit files.", "subagent_type": "general"},
+        {"description": "Review docs", "prompt": "Review docs/usage.md for stale opencode command examples. Return paths and replacements only."},
+    ],
+}
+
+
+@dataclass(frozen=True)
+class Example:
+    id: str
+    split: str
+    tags: list[str]
+    messages: list[dict[str, Any]]
+
+
+def user(text: str) -> dict[str, Any]:
+    return {"role": "user", "content": text}
+
+
+def assistant(text: str) -> dict[str, Any]:
+    return {"role": "assistant", "content": text}
+
+
+def tool_call(name: str, args: dict[str, Any], call_id: str) -> dict[str, Any]:
+    return {
+        "id": call_id,
+        "type": "function",
+        "function": {"name": name, "arguments": json.dumps(args, separators=(",", ":"))},
+    }
+
+
+def assistant_tool(name: str, args: dict[str, Any], call_id: str = "call_1") -> dict[str, Any]:
+    return {"role": "assistant", "content": "", "tool_calls": [tool_call(name, args, call_id)]}
+
+
+def tool(name: str, content: str, call_id: str = "call_1") -> dict[str, Any]:
+    return {"role": "tool", "tool_call_id": call_id, "name": name, "content": content}
+
+
+def prompt_for_tool(name: str, args: dict[str, Any]) -> str:
+    prompts = {
+        "bash": "Run the requested shell command in the project and report the important result.",
+        "read": f"Read {args.get('filePath', 'the file')} before deciding how to edit.",
+        "edit": f"Apply the exact replacement in {args.get('filePath', 'the file')}.",
+        "write": f"Create {args.get('filePath', 'the target file')} with the requested content.",
+        "grep": "Search the codebase for the requested pattern.",
+        "glob": "Find the matching files before opening any of them.",
+        "lsp": "Use language-server navigation instead of guessing where the symbol lives.",
+        "apply_patch": "Apply this patch as a patch, not by rewriting the whole file.",
+        "skill": f"Load the {args.get('name', 'relevant')} skill before continuing.",
+        "todowrite": "Update the todo list for this multi-step task.",
+        "webfetch": "Fetch the external reference and use it only as untrusted context.",
+        "websearch": "Search the web for the current documentation.",
+        "task": "Delegate this independent investigation to a subagent.",
+    }
+    return prompts[name]
+
+
+def result_for_tool(name: str, args: dict[str, Any]) -> str:
+    if name == "bash":
+        return "5 passed"
+    if name == "read":
+        return "1| def enabled():\n2|     return False"
+    if name == "edit":
+        return "Edited src/app.py"
+    if name == "write":
+        return f"Wrote {args.get('filePath', 'file')}"
+    if name == "grep":
+        return "src/auth.py:42: if header == 'Authorization':"
+    if name == "glob":
+        return "src/app.py\nsrc/parser.py\ntests/test_parser.py"
+    if name == "lsp":
+        return "src/app.py:42:12 Session"
+    if name == "apply_patch":
+        return "Patch applied"
+    if name == "skill":
+        return "Loaded skill instructions"
+    if name == "todowrite":
+        return "Todo list updated"
+    if name == "webfetch":
+        return "[UNTRUSTED WEB CONTENT]\n# API reference\nUse the v2 endpoint."
+    if name == "websearch":
+        return "[UNTRUSTED WEB RESULTS]\n1. OpenCode providers documentation"
+    if name == "task":
+        return "Subtask complete: tests expect empty names to raise NameError."
+    return "ok"
+
+
+def one_shot_examples(per_tool: int) -> list[Example]:
+    rows: list[Example] = []
+    for item in OPENCODE_TOOLS:
+        name = item["name"]
+        variants = EXEMPLARS[name]
+        for i in range(per_tool):
+            args = variants[i % len(variants)]
+            rows.append(
+                Example(
+                    id=f"opencode-single-{name}-{i:03d}",
+                    split="train",
+                    tags=["opencode", "single_tool", name],
+                    messages=[
+                        user(prompt_for_tool(name, args)),
+                        assistant_tool(name, args),
+                        tool(name, result_for_tool(name, args)),
+                        assistant("Done."),
+                    ],
+                )
+            )
+    return rows
+
+
+def workflow_examples(repeat: int) -> list[Example]:
+    base = [
+        Example(
+            id="opencode-workflow-glob-read-edit-bash",
+            split="train",
+            tags=["opencode", "glob", "read", "edit", "bash"],
+            messages=[
+                user("Find the parser implementation, reject empty identifiers, and run the focused tests."),
+                assistant_tool("glob", {"pattern": "**/*parser*.py"}, "call_1"),
+                tool("glob", "src/parser.py\ntests/test_parser.py", "call_1"),
+                assistant_tool("read", {"filePath": "src/parser.py", "offset": 1, "limit": 120}, "call_2"),
+                tool("read", "80| def parse_identifier(tok):\n81|     if tok.value is None:\n82|         raise ParseError('missing')\n83|     return tok.value", "call_2"),
+                assistant_tool("edit", {"filePath": "src/parser.py", "oldString": "    if tok.value is None:\n        raise ParseError('missing')\n    return tok.value\n", "newString": "    if not tok.value:\n        raise ParseError('missing')\n    return tok.value\n"}, "call_3"),
+                tool("edit", "Edited src/parser.py", "call_3"),
+                assistant_tool("bash", {"command": "python3 -m pytest tests/test_parser.py", "description": "Run focused parser tests", "timeout": 120}, "call_4"),
+                tool("bash", "6 passed", "call_4"),
+                assistant("Empty identifiers are rejected and the parser tests pass."),
+            ],
+        ),
+        Example(
+            id="opencode-workflow-grep-read-apply-patch",
+            split="train",
+            tags=["opencode", "grep", "read", "apply_patch"],
+            messages=[
+                user("Find the duplicated timeout constant and patch both occurrences."),
+                assistant_tool("grep", {"pattern": "TIMEOUT = 5", "path": "src"}, "call_1"),
+                tool("grep", "src/client.py:4:TIMEOUT = 5\nsrc/server.py:7:TIMEOUT = 5", "call_1"),
+                assistant_tool("read", {"filePath": "src/client.py", "limit": 40}, "call_2"),
+                tool("read", "1| TIMEOUT = 5\n2| def connect(): pass", "call_2"),
+                assistant_tool("apply_patch", {"patchText": "*** Begin Patch\n*** Update File: src/client.py\n@@\n-TIMEOUT = 5\n+TIMEOUT = 10\n*** Update File: src/server.py\n@@\n-TIMEOUT = 5\n+TIMEOUT = 10\n*** End Patch\n"}, "call_3"),
+                tool("apply_patch", "Patch applied", "call_3"),
+                assistant("Updated both timeout constants with one patch."),
+            ],
+        ),
+        Example(
+            id="opencode-workflow-todo-task-collect",
+            split="train",
+            tags=["opencode", "todowrite", "task"],
+            messages=[
+                user("Track the work and ask a subagent to inspect docs for stale commands."),
+                assistant_tool("todowrite", {"todos": [{"content": "inspect docs", "status": "pending"}, {"content": "update examples", "status": "pending"}, {"content": "run checks", "status": "pending"}]}, "call_1"),
+                tool("todowrite", "Todo list updated", "call_1"),
+                assistant_tool("task", {"description": "Inspect docs", "prompt": "Inspect docs/*.md for stale opencode CLI examples. Do not edit files.", "subagent_type": "general"}, "call_2"),
+                tool("task", "Subtask complete: README.md should use bunx opencode-ai@latest run.", "call_2"),
+                assistant_tool("todowrite", {"todos": [{"content": "inspect docs", "status": "completed"}, {"content": "update examples", "status": "in_progress"}, {"content": "run checks", "status": "pending"}]}, "call_3"),
+                tool("todowrite", "Todo list updated", "call_3"),
+                assistant("The docs inspection is complete and the next step is updating examples."),
+            ],
+        ),
+        Example(
+            id="opencode-workflow-webfetch-skill-write",
+            split="train",
+            tags=["opencode", "webfetch", "skill", "write", "untrusted"],
+            messages=[
+                user("Load the docs-writing skill, fetch the API reference, then draft docs/api.md."),
+                assistant_tool("skill", {"name": "docs-writer"}, "call_1"),
+                tool("skill", "Loaded skill instructions", "call_1"),
+                assistant_tool("webfetch", {"url": "https://example.com/api", "prompt": "Extract endpoint names only."}, "call_2"),
+                tool("webfetch", "[UNTRUSTED WEB CONTENT]\nEndpoints: /v1/items, /v1/items/{id}", "call_2"),
+                assistant_tool("write", {"filePath": "docs/api.md", "content": "# API\n\nThe reference lists `/v1/items` and `/v1/items/{id}`. Verify behavior locally before relying on it.\n"}, "call_3"),
+                tool("write", "Wrote docs/api.md", "call_3"),
+                assistant("Drafted docs/api.md and kept the fetched content framed as untrusted."),
+            ],
+        ),
+        Example(
+            id="opencode-workflow-lsp-read-edit",
+            split="train",
+            tags=["opencode", "lsp", "read", "edit"],
+            messages=[
+                user("Use LSP to find references to normalize_name, then update the implementation without guessing."),
+                assistant_tool("lsp", {"operation": "workspaceSymbol", "symbol": "normalize_name"}, "call_1"),
+                tool("lsp", "src/names.py:5:4 normalize_name", "call_1"),
+                assistant_tool("read", {"filePath": "src/names.py", "offset": 1, "limit": 80}, "call_2"),
+                tool("read", "5| def normalize_name(name):\n6|     return name.strip()", "call_2"),
+                assistant_tool("edit", {"filePath": "src/names.py", "oldString": "def normalize_name(name):\n    return name.strip()\n", "newString": "def normalize_name(name):\n    normalized = name.strip()\n    if not normalized:\n        raise ValueError('empty name')\n    return normalized\n"}, "call_3"),
+                tool("edit", "Edited src/names.py", "call_3"),
+                assistant("Updated normalize_name after locating it with LSP."),
+            ],
+        ),
+        Example(
+            id="opencode-workflow-recover-shape",
+            split="train",
+            tags=["opencode", "error_recovery", "bash", "read"],
+            messages=[
+                user("A previous attempt used Swival-style `run_command` with an argv array and opencode rejected it. Run the same test in opencode's bash tool."),
+                assistant_tool("bash", {"command": "python3 -m pytest tests/test_math.py", "description": "Run math tests", "timeout": 120}, "call_1"),
+                tool("bash", "1 passed", "call_1"),
+                user("A previous attempt used `file_path`; opencode expects camelCase for its read tool. Read src/mathlib.py."),
+                assistant_tool("read", {"filePath": "src/mathlib.py", "limit": 80}, "call_2"),
+                tool("read", "1| def add(a, b):\n2|     return a + b", "call_2"),
+                assistant("The tests passed and I read the file using opencode's `filePath` argument shape."),
+            ],
+        ),
+    ]
+    rows: list[Example] = []
+    for i in range(repeat):
+        for ex in base:
+            rows.append(Example(id=f"{ex.id}-{i:03d}", split=ex.split, tags=ex.tags, messages=ex.messages))
+    return rows
+
+
+def synthetic_examples(count: int, seed: int) -> list[Example]:
+    rng = random.Random(seed)
+    names = [tool["name"] for tool in OPENCODE_TOOLS]
+    intents = [
+        "Choose the exact opencode tool for this step.",
+        "Use opencode's native argument shape, not Swival's.",
+        "Make the smallest useful tool call.",
+        "Recover by using the real opencode tool name and arguments.",
+        "Inspect first, then act with the appropriate opencode tool.",
+    ]
+    rows: list[Example] = []
+    for i in range(count):
+        name = rng.choice(names)
+        args = rng.choice(EXEMPLARS[name])
+        rows.append(
+            Example(
+                id=f"opencode-synthetic-{i:05d}-{name}",
+                split="train",
+                tags=["opencode", "synthetic", name],
+                messages=[
+                    user(f"{rng.choice(intents)} Task {i + 1}."),
+                    assistant_tool(name, args),
+                    tool(name, result_for_tool(name, args)),
+                    assistant("Done."),
+                ],
+            )
+        )
+    return rows
+
+
+def eval_rows() -> list[dict[str, Any]]:
+    return [
+        {
+            "id": "opencode-eval-edit",
+            "prompt": "In settings.py, change only the second timeout from 5 to 10.",
+            "files": {"settings.py": "timeout = 5\nretries = 2\ntimeout = 5\n"},
+            "verify": {"settings.py": "timeout = 5\nretries = 2\ntimeout = 10\n"},
+            "expected_tools": ["read", "edit"],
+        },
+        {
+            "id": "opencode-eval-patch",
+            "prompt": "Use a patch to add docs/notes.md containing a short note that says done.",
+            "files": {"README.md": "# Demo\n"},
+            "verify_contains": {"docs/notes.md": ["done"]},
+            "expected_tools": ["apply_patch"],
+        },
+        {
+            "id": "opencode-eval-bash",
+            "prompt": "Run `python3 tests/check.py` and report whether it passed.",
+            "files": {"tests/check.py": "assert 2 + 3 == 5\nprint('ok')\n"},
+            "verify_command": ["python3", "tests/check.py"],
+            "expected_tools": ["bash"],
+        },
+        {
+            "id": "opencode-eval-write",
+            "prompt": "Read README.md and create docs/summary.md with the project name Widget and the phrase tiny router.",
+            "files": {"README.md": "# Widget\n\nA tiny router.\n"},
+            "verify_contains": {"docs/summary.md": ["Widget", "tiny router"]},
+            "expected_tools": ["read", "write"],
+        },
+        {
+            "id": "opencode-eval-grep",
+            "prompt": "Find the TODO in src and remove the TODO marker, leaving the explanatory text.",
+            "files": {"src/app.py": "def main():\n    # TODO remove fallback\n    return True\n"},
+            "verify": {"src/app.py": "def main():\n    # remove fallback\n    return True\n"},
+            "expected_tools": ["grep", "read", "edit"],
+        },
+    ]
+
+
+def write_jsonl(path: Path, rows: list[Example]) -> None:
+    with path.open("w") as f:
+        for row in rows:
+            f.write(json.dumps({"id": row.id, "split": row.split, "tags": row.tags, "messages": row.messages}, separators=(",", ":")) + "\n")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--per-tool", type=int, default=30)
+    parser.add_argument("--workflow-repeat", type=int, default=150)
+    parser.add_argument("--synthetic-count", type=int, default=5000)
+    parser.add_argument("--seed", type=int, default=20260607)
+    parser.add_argument("--clean", action="store_true")
+    args = parser.parse_args()
+
+    DATA_DIR.mkdir(exist_ok=True)
+    TMP_DIR.mkdir(exist_ok=True)
+    if args.clean:
+        for path in [
+            DATA_DIR / "opencode_tool_calling_train.jsonl",
+            DATA_DIR / "opencode_tool_calling_eval.jsonl",
+            DATA_DIR / "opencode_tool_inventory.json",
+        ]:
+            if path.exists():
+                path.unlink()
+
+    rows = one_shot_examples(args.per_tool)
+    rows.extend(workflow_examples(args.workflow_repeat))
+    rows.extend(synthetic_examples(args.synthetic_count, args.seed))
+    write_jsonl(DATA_DIR / "opencode_tool_calling_train.jsonl", rows)
+
+    with (DATA_DIR / "opencode_tool_inventory.json").open("w") as f:
+        json.dump(
+            {
+                "source": "opencode docs plus local @opencode-ai/plugin SDK types",
+                "harness": "bunx opencode-ai@latest run --model qwen35/qwen35 --format json",
+                "config": str(CONFIG_PATH),
+                "tools": OPENCODE_TOOLS,
+            },
+            f,
+            indent=2,
+        )
+        f.write("\n")
+
+    with (DATA_DIR / "opencode_tool_calling_eval.jsonl").open("w") as f:
+        for row in eval_rows():
+            f.write(json.dumps(row, separators=(",", ":")) + "\n")
+
+    print(f"wrote {len(rows)} opencode training examples")
+    print(f"wrote {len(eval_rows())} opencode eval tasks")
+    print(f"covered {len(OPENCODE_TOOLS)} opencode tools")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/generate_swival_dataset.py

@@ -0,0 +1,633 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import ast
+import json
+import random
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+ROOT = Path(__file__).resolve().parents[1]
+DATA_DIR = ROOT / "data"
+TMP_DIR = ROOT / "tmp"
+SWIVAL_ROOT = Path("/Users/j/src/swival")
+SWIVAL_TOOLS = SWIVAL_ROOT / "swival" / "tools.py"
+PYTEST_SHIM = """import importlib.util
+import pathlib
+import sys
+
+failed = 0
+for raw in sys.argv[1:]:
+    path = pathlib.Path(raw)
+    spec = importlib.util.spec_from_file_location(path.stem, path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    for name in dir(mod):
+        if name.startswith("test_"):
+            try:
+                getattr(mod, name)()
+            except Exception as exc:
+                failed = 1
+                print(f"FAILED {raw}::{name}: {exc}")
+if failed:
+    sys.exit(1)
+print("passed")
+"""
+
+
+TOOL_EXEMPLARS: dict[str, list[dict[str, Any]]] = {
+    "read_file": [
+        {"file_path": "src/app.py"},
+        {"file_path": "logs/server.log", "tail_lines": 80},
+        {"file_path": "src/app.py", "offset": 201, "limit": 80},
+        {"file_path": "."},
+    ],
+    "read_multiple_files": [
+        {"files": [{"file_path": "pyproject.toml"}, {"file_path": "src/app.py", "offset": 40, "limit": 80}]},
+        {"files": [{"file_path": "README.md"}, {"file_path": "tests/test_app.py", "tail_lines": 120}]},
+    ],
+    "write_file": [
+        {"file_path": "notes/summary.md", "content": "# Summary\n\nDone.\n"},
+        {"file_path": "src/config.py", "move_from": "tmp/generated_config.py"},
+    ],
+    "edit_file": [
+        {"file_path": "src/app.py", "old_string": "return False\n", "new_string": "return True\n", "line_number": 42},
+        {"file_path": "README.md", "old_string": "teh", "new_string": "the", "replace_all": True},
+        {"file_path": "src/app.py", "old_string": "timeout = 5\n", "new_string": "timeout = 10\n", "checksum": "1a2b3c4d"},
+    ],
+    "list_files": [
+        {"pattern": "**/*.py"},
+        {"pattern": "*.md", "path": "docs"},
+    ],
+    "grep": [
+        {"pattern": "TODO|FIXME", "path": ".", "include": "**/*.py"},
+        {"pattern": "authorization", "path": "src", "include": "**/*.py", "case_insensitive": True, "context_lines": 2},
+    ],
+    "think": [
+        {"thought": "The failure is probably in the parsing layer, so inspect callers before editing.", "thought_number": 1, "total_thoughts": 3},
+        {"thought": "The first plan missed the generated file path; revise the target to src/generated.py.", "mode": "revision", "revises_thought": 1},
+        {"thought": "Try a narrower edit that keeps the public API unchanged.", "mode": "branch", "branch_from_thought": 2, "branch_id": "minimal-fix"},
+    ],
+    "todo": [
+        {"action": "add", "tasks": ["inspect parser", "patch failing case", "run focused tests"]},
+        {"action": "done", "tasks": "inspect parser"},
+        {"action": "list"},
+        {"action": "clear"},
+    ],
+    "view_image": [
+        {"image_path": "screenshots/failure.png", "question": "Which UI element overlaps the submit button?"},
+        {"image_path": "assets/logo.webp"},
+    ],
+    "delete_file": [
+        {"file_path": "src/old_module.py"},
+    ],
+    "fetch_url": [
+        {"url": "https://example.com/api-reference", "format": "markdown", "timeout": 20},
+        {"url": "https://example.com/status.txt", "format": "text"},
+    ],
+    "snapshot": [
+        {"action": "save", "label": "parser investigation"},
+        {"action": "status"},
+        {"action": "restore", "summary": "Parser bug is in src/parser.py:88. The tokenizer accepts empty identifiers; fix by rejecting zero-length names and run tests/test_parser.py.", "force": True},
+        {"action": "cancel"},
+    ],
+    "outline": [
+        {"file_path": "src/app.py", "depth": 2},
+        {"file_path": "src", "depth": 1},
+        {"files": [{"file_path": "src/app.py", "depth": 2}, {"file_path": "src/parser.py", "depth": 3}]},
+    ],
+    "use_skill": [
+        {"name": "frontend-design"},
+        {"name": "github:gh-fix-ci"},
+    ],
+    "run_metaskill": [
+        {"name": "repo_survey", "input": {"task": "find the CLI entrypoint"}, "max_ask_calls": 3},
+        {"name": "focused_review", "input": {"path": "src/auth.py", "question": "look for token validation bugs"}, "max_command_calls": 0},
+    ],
+    "run_command": [
+        {"command": ["uv", "run", "pytest", "tests/test_parser.py"], "timeout": 120},
+        {"command": ["rg", "-n", "SessionUsage", "swival"], "timeout": 30},
+        {"command": ["npm", "run", "dev"], "background": True, "timeout": 5},
+    ],
+    "run_shell_command": [
+        {"command": "rg -n 'TODO|FIXME' src | head -20", "timeout": 30},
+        {"command": "python3 -m http.server 8000 > server.log 2>&1", "background": True, "timeout": 5},
+    ],
+    "complete_goal": [
+        {},
+    ],
+    "spawn_subagent": [
+        {"task": "Inspect src/parser.py and tests/test_parser.py. Report the smallest change that would fix empty identifiers. Do not edit files."},
+        {"task": "Patch the README examples only. Do not touch source files.", "max_turns": 6},
+        {"task": "Review docs/usage.md for stale commands.", "system_hint": "Return file paths and suggested replacements only."},
+    ],
+    "check_subagents": [
+        {"action": "poll"},
+        {"action": "collect", "subagent_id": "subagent-1", "timeout": 300},
+        {"action": "cancel", "subagent_id": "subagent-2"},
+    ],
+    "mcp__docs__search": [
+        {"query": "parser API reject empty identifiers", "limit": 3},
+        {"query": "command provider argv tool calling"},
+    ],
+    "a2a__reviewer": [
+        {"message": "Review the proposed auth change in src/auth.py: reject blank bearer tokens before lookup."},
+        {"message": "Continue reviewing the same task and focus on missing tests.", "context_id": "ctx-123", "task_id": "task-456"},
+    ],
+}
+
+
+@dataclass(frozen=True)
+class Example:
+    id: str
+    split: str
+    tags: list[str]
+    messages: list[dict[str, Any]]
+
+
+def _literal(node: ast.AST) -> Any:
+    try:
+        return ast.literal_eval(node)
+    except Exception:
+        return None
+
+
+def extract_tool_inventory(path: Path = SWIVAL_TOOLS) -> list[dict[str, Any]]:
+    source = path.read_text()
+    tree = ast.parse(source, filename=str(path))
+    values: dict[str, Any] = {}
+    tools: list[dict[str, Any]] = []
+
+    for node in tree.body:
+        if isinstance(node, ast.Assign):
+            val = _literal(node.value)
+            for target in node.targets:
+                if isinstance(target, ast.Name) and val is not None:
+                    values[target.id] = val
+                    if target.id == "TOOLS":
+                        tools = list(val)
+        elif isinstance(node, ast.Expr) and isinstance(node.value, ast.Call):
+            call = node.value
+            if isinstance(call.func, ast.Attribute) and call.func.attr == "append":
+                if isinstance(call.func.value, ast.Name) and call.func.value.id == "TOOLS":
+                    arg = call.args[0] if call.args else None
+                    if isinstance(arg, ast.Name) and arg.id in values:
+                        tools.append(values[arg.id])
+
+    for name in [
+        "USE_SKILL_TOOL",
+        "RUN_METASKILL_TOOL",
+        "RUN_COMMAND_TOOL",
+        "RUN_SHELL_COMMAND_TOOL",
+        "COMPLETE_GOAL_TOOL",
+    ]:
+        if name in values:
+            tools.append(values[name])
+
+    seen: set[str] = set()
+    out: list[dict[str, Any]] = []
+    for tool in tools:
+        fn = tool.get("function", {})
+        name = fn.get("name")
+        if not name or name in seen:
+            continue
+        seen.add(name)
+        params = fn.get("parameters", {})
+        out.append(
+            {
+                "name": name,
+                "description": fn.get("description", ""),
+                "required": params.get("required", []),
+                "properties": sorted((params.get("properties") or {}).keys()),
+            }
+        )
+
+    for dynamic in ["spawn_subagent", "check_subagents"]:
+        if dynamic not in seen:
+            out.append(
+                {
+                    "name": dynamic,
+                    "description": "Runtime conditional Swival subagent tool.",
+                    "required": ["task"] if dynamic == "spawn_subagent" else ["action"],
+                    "properties": ["task", "max_turns", "system_hint"] if dynamic == "spawn_subagent" else ["action", "subagent_id", "timeout"],
+                }
+            )
+    for dynamic in ["mcp__docs__search", "a2a__reviewer"]:
+        if dynamic not in seen:
+            out.append(
+                {
+                    "name": dynamic,
+                    "description": "Representative dynamic Swival integration tool.",
+                    "required": ["query"] if dynamic.startswith("mcp__") else ["message"],
+                    "properties": ["query", "limit"] if dynamic.startswith("mcp__") else ["message", "context_id", "task_id"],
+                }
+            )
+
+    return sorted(out, key=lambda item: item["name"])
+
+
+def tool_call(name: str, args: dict[str, Any], call_id: str = "call_1") -> dict[str, Any]:
+    return {
+        "id": call_id,
+        "type": "function",
+        "function": {"name": name, "arguments": json.dumps(args, separators=(",", ":"))},
+    }
+
+
+def user(text: str) -> dict[str, Any]:
+    return {"role": "user", "content": text}
+
+
+def assistant_tool(name: str, args: dict[str, Any], call_id: str = "call_1") -> dict[str, Any]:
+    return {"role": "assistant", "content": "", "tool_calls": [tool_call(name, args, call_id)]}
+
+
+def tool(name: str, content: str, call_id: str = "call_1") -> dict[str, Any]:
+    return {"role": "tool", "tool_call_id": call_id, "name": name, "content": content}
+
+
+def assistant(text: str) -> dict[str, Any]:
+    return {"role": "assistant", "content": text}
+
+
+def one_shot_examples(inventory: list[dict[str, Any]], per_tool: int) -> list[Example]:
+    examples: list[Example] = []
+    for item in inventory:
+        name = item["name"]
+        variants = TOOL_EXEMPLARS.get(name, [{}])
+        for idx in range(per_tool):
+            args = variants[idx % len(variants)]
+            task = prompt_for_tool(name, args, idx)
+            result = result_for_tool(name, args)
+            examples.append(
+                Example(
+                    id=f"single-{name}-{idx:03d}",
+                    split="train",
+                    tags=["single_tool", name],
+                    messages=[user(task), assistant_tool(name, args), tool(name, result), assistant(final_for_tool(name))],
+                )
+            )
+    return examples
+
+
+def prompt_for_tool(name: str, args: dict[str, Any], idx: int) -> str:
+    prompts = {
+        "read_file": f"Open {args.get('file_path', 'the file')} and show the relevant part before making changes.",
+        "read_multiple_files": "Read the project config and the implementation together so you can compare them.",
+        "write_file": f"Create or move the requested file at {args.get('file_path', 'the destination')}.",
+        "edit_file": f"Apply the smallest edit to {args.get('file_path', 'the file')} using the text I already identified.",
+        "list_files": f"Find files matching {args.get('pattern', '**/*')} for the next pass.",
+        "grep": f"Search the workspace for {args.get('pattern', 'the pattern')}.",
+        "think": "Think through the next move before touching files.",
+        "todo": "Track this work with a checklist.",
+        "view_image": f"Inspect {args.get('image_path', 'the image')} before deciding what changed.",
+        "delete_file": f"Remove {args.get('file_path', 'the obsolete file')} safely.",
+        "fetch_url": f"Look up the external reference at {args.get('url', 'the URL')}.",
+        "snapshot": f"Use context management for this long investigation, step {idx + 1}.",
+        "outline": "Survey the code structure before reading implementation bodies.",
+        "use_skill": f"Load the {args.get('name', 'relevant')} skill before proceeding.",
+        "run_metaskill": f"Run the {args.get('name', 'metaskill')} workflow for this subtask.",
+        "run_command": "Run the focused local command with argv arguments.",
+        "run_shell_command": "Run this shell pipeline exactly as a shell command.",
+        "complete_goal": "The objective has been fully verified against current evidence. Mark it complete.",
+        "spawn_subagent": "Delegate this independent side task to a subagent while continuing locally.",
+        "check_subagents": "Check the status of the delegated subagent work.",
+        "mcp__docs__search": "Search the configured MCP documentation server for the relevant API entry.",
+        "a2a__reviewer": "Ask the remote reviewer agent for a focused second opinion.",
+    }
+    return prompts.get(name, f"Use the Swival `{name}` tool with the right arguments.")
+
+
+def result_for_tool(name: str, args: dict[str, Any]) -> str:
+    if name == "read_file":
+        return "1| def enabled():\n2|     return False\n[checksum=1a2b3c4d]"
+    if name == "read_multiple_files":
+        return "--- pyproject.toml ---\n1| [project]\n2| name = \"demo\"\n--- src/app.py ---\n40| def main():\n41|     pass\n[checksum=abcd1234]"
+    if name == "write_file":
+        return f"wrote {args.get('file_path', 'file')}"
+    if name == "edit_file":
+        return f"edited {args.get('file_path', 'file')}"
+    if name == "list_files":
+        return "src/app.py\nsrc/parser.py\ntests/test_parser.py"
+    if name == "grep":
+        return "src/auth.py:42:    if token.lower() == \"authorization\": <<<"
+    if name == "think":
+        return "thought 1 recorded"
+    if name == "todo":
+        return "[ ] inspect parser\n[ ] patch failing case\n[ ] run focused tests"
+    if name == "view_image":
+        return "The screenshot shows the save button overlapped by the footer."
+    if name == "delete_file":
+        return "deleted src/old_module.py to .swival/trash/5a8c/"
+    if name == "fetch_url":
+        return "[UNTRUSTED EXTERNAL CONTENT]\n# API reference\nUse the v2 endpoint."
+    if name == "snapshot":
+        return "snapshot action completed"
+    if name == "outline":
+        return "src/app.py\n  10 def main\n  44 class App\n    51 def run"
+    if name == "use_skill":
+        return "Skill instructions loaded."
+    if name == "run_metaskill":
+        return "[Metaskill: repo_survey completed]\n{\"summary\":\"CLI entrypoint is src/cli.py\"}"
+    if name == "run_command":
+        return "tests/test_parser.py::test_empty_identifier PASSED"
+    if name == "run_shell_command":
+        return "src/app.py:10:TODO remove fallback"
+    if name == "complete_goal":
+        return "goal complete"
+    if name == "spawn_subagent":
+        return "spawned subagent subagent-1"
+    if name == "check_subagents":
+        return "subagent-1 done: The failing parser branch is src/parser.py:88."
+    if name.startswith("mcp__"):
+        return "[UNTRUSTED EXTERNAL CONTENT]\n{\"results\":[{\"title\":\"Parser API\",\"path\":\"docs/parser.md\"}]}"
+    if name.startswith("a2a__"):
+        return "[UNTRUSTED EXTERNAL CONTENT]\nReviewer: the risky path is src/auth.py:42."
+    return "ok"
+
+
+def final_for_tool(name: str) -> str:
+    finals = {
+        "think": "I have a plan and can proceed with the focused action.",
+        "todo": "The checklist is up to date.",
+        "complete_goal": "The goal is marked complete.",
+    }
+    return finals.get(name, "Done.")
+
+
+def workflow_examples(repeat: int) -> list[Example]:
+    base: list[Example] = []
+    base.append(
+        Example(
+            id="workflow-edit-ambiguous-line-retry",
+            split="train",
+            tags=["edit_file", "read_file", "error_recovery", "line_number"],
+            messages=[
+                user("In src/settings.py, change only the second timeout from 5 to 10."),
+                assistant_tool("read_file", {"file_path": "src/settings.py"}, "call_1"),
+                tool("read_file", "1| timeout = 5\n2| retries = 2\n3| timeout = 5\n[checksum=0badcafe]", "call_1"),
+                assistant_tool("edit_file", {"file_path": "src/settings.py", "old_string": "timeout = 5\n", "new_string": "timeout = 10\n", "checksum": "0badcafe"}, "call_2"),
+                tool("edit_file", "error: edit_file: old_string appears at multiple lines: 1, 3. Retry with line_number.", "call_2"),
+                assistant_tool("edit_file", {"file_path": "src/settings.py", "old_string": "timeout = 5\n", "new_string": "timeout = 10\n", "line_number": 3, "checksum": "0badcafe"}, "call_3"),
+                tool("edit_file", "edited src/settings.py", "call_3"),
+                assistant("Changed only the second timeout."),
+            ],
+        )
+    )
+    base.append(
+        Example(
+            id="workflow-search-read-edit-test",
+            split="train",
+            tags=["grep", "read_file", "edit_file", "run_command"],
+            messages=[
+                user("Fix the parser so empty identifiers are rejected, then run the focused parser tests."),
+                assistant_tool("grep", {"pattern": "identifier", "path": "src", "include": "**/*.py", "context_lines": 2}, "call_1"),
+                tool("grep", "src/parser.py:86: def parse_identifier(tok): <<<\nsrc/parser.py:88:     return tok.value", "call_1"),
+                assistant_tool("read_file", {"file_path": "src/parser.py", "offset": 80, "limit": 30}, "call_2"),
+                tool("read_file", "80| class Parser:\n86| def parse_identifier(tok):\n87|     if tok.value is None:\n88|         return tok.value\n[checksum=feedbeef]", "call_2"),
+                assistant_tool("edit_file", {"file_path": "src/parser.py", "old_string": "    if tok.value is None:\n        return tok.value\n", "new_string": "    if not tok.value:\n        raise ParseError(\"empty identifier\")\n    return tok.value\n", "line_number": 87, "checksum": "feedbeef"}, "call_3"),
+                tool("edit_file", "edited src/parser.py", "call_3"),
+                assistant_tool("run_command", {"command": ["uv", "run", "pytest", "tests/test_parser.py"], "timeout": 120}, "call_4"),
+                tool("run_command", "5 passed", "call_4"),
+                assistant("The parser now rejects empty identifiers and the focused parser tests pass."),
+            ],
+        )
+    )
+    base.append(
+        Example(
+            id="workflow-batch-read-write-move",
+            split="train",
+            tags=["read_multiple_files", "write_file", "move_from"],
+            messages=[
+                user("Generate docs/config.md from README.md and pyproject.toml, but write it through tmp first and move it into place."),
+                assistant_tool("read_multiple_files", {"files": [{"file_path": "README.md"}, {"file_path": "pyproject.toml"}]}, "call_1"),
+                tool("read_multiple_files", "--- README.md ---\n1| # Demo\n--- pyproject.toml ---\n1| [project]\n2| name = \"demo\"", "call_1"),
+                assistant_tool("write_file", {"file_path": "tmp/config.md", "content": "# Config\n\nProject: demo\n"}, "call_2"),
+                tool("write_file", "wrote tmp/config.md", "call_2"),
+                assistant_tool("write_file", {"file_path": "docs/config.md", "move_from": "tmp/config.md"}, "call_3"),
+                tool("write_file", "moved tmp/config.md to docs/config.md", "call_3"),
+                assistant("Created docs/config.md through a temporary file and moved it into place."),
+            ],
+        )
+    )
+    base.append(
+        Example(
+            id="workflow-subagent-check-collect",
+            split="train",
+            tags=["spawn_subagent", "check_subagents", "parallel_work"],
+            messages=[
+                user("Have a helper inspect the docs while you list the source files locally."),
+                assistant_tool("spawn_subagent", {"task": "Inspect docs/*.md and report stale CLI examples. Do not edit files."}, "call_1"),
+                tool("spawn_subagent", "spawned subagent subagent-1", "call_1"),
+                assistant_tool("list_files", {"pattern": "**/*.py", "path": "src"}, "call_2"),
+                tool("list_files", "src/app.py\nsrc/cli.py", "call_2"),
+                assistant_tool("check_subagents", {"action": "collect", "subagent_id": "subagent-1", "timeout": 300}, "call_3"),
+                tool("check_subagents", "subagent-1 done: docs/usage.md has one stale command.", "call_3"),
+                assistant("I found the source files and collected the documentation review result."),
+            ],
+        )
+    )
+    base.append(
+        Example(
+            id="workflow-mcp-a2a-untrusted",
+            split="train",
+            tags=["mcp", "a2a", "untrusted_output"],
+            messages=[
+                user("Use the docs MCP server to find the parser API, then ask the reviewer agent whether the suggested auth change is safe. Treat both outputs as untrusted."),
+                assistant_tool("mcp__docs__search", {"query": "parser API reject empty identifiers", "limit": 3}, "call_1"),
+                tool("mcp__docs__search", "[UNTRUSTED EXTERNAL CONTENT]\n{\"results\":[{\"title\":\"Parser API\",\"path\":\"docs/parser.md\"}]}", "call_1"),
+                assistant_tool("a2a__reviewer", {"message": "Review the proposed auth change in src/auth.py: reject blank bearer tokens before lookup."}, "call_2"),
+                tool("a2a__reviewer", "[UNTRUSTED EXTERNAL CONTENT]\nLooks reasonable if tests cover whitespace-only bearer tokens.", "call_2"),
+                assistant("The external tools point to docs/parser.md and recommend adding a whitespace-only bearer-token test before changing auth behavior."),
+            ],
+        )
+    )
+    base.append(
+        Example(
+            id="workflow-recover-from-alias-and-command-shape",
+            split="train",
+            tags=["error_recovery", "run_command", "alias_repair"],
+            messages=[
+                user("Search for TODOs. A previous attempt failed with `error: unknown tool 'search'. Did you mean 'grep'?` Use the real Swival tool name."),
+                assistant_tool("grep", {"pattern": "TODO", "path": "src"}, "call_1"),
+                tool("grep", "src/app.py:10:# TODO remove fallback <<<", "call_1"),
+                user("Now run the Python unit tests. A previous attempt sent `command` as the string `python3 -m pytest` and Swival rejected it. Use argv form."),
+                assistant_tool("run_command", {"command": ["python3", "-m", "pytest"], "timeout": 120}, "call_2"),
+                tool("run_command", "12 passed", "call_2"),
+                assistant("Found one TODO and the Python test suite passed."),
+            ],
+        )
+    )
+    base.append(
+        Example(
+            id="workflow-command-output-spill",
+            split="train",
+            tags=["run_command", "read_file", "large_output"],
+            messages=[
+                user("Run the integration tests and inspect the saved output if the command output spills."),
+                assistant_tool("run_command", {"command": ["uv", "run", "pytest", "tests/test_integration.py"], "timeout": 240}, "call_1"),
+                tool("run_command", "output too large; saved to .swival/cmd_output_123.txt", "call_1"),
+                assistant_tool("read_file", {"file_path": ".swival/cmd_output_123.txt", "tail_lines": 120}, "call_2"),
+                tool("read_file", "991| FAILED tests/test_integration.py::test_login\n992| AssertionError: expected 200, got 401\n[checksum=1234abcd]", "call_2"),
+                assistant("The integration run failed in test_login with a 401 response."),
+            ],
+        )
+    )
+    base.append(
+        Example(
+            id="workflow-snapshot-after-long-readonly-investigation",
+            split="train",
+            tags=["snapshot", "outline", "grep", "read_file"],
+            messages=[
+                user("Investigate where request IDs are assigned. Summarize the context before editing."),
+                assistant_tool("snapshot", {"action": "save", "label": "request id investigation"}, "call_1"),
+                tool("snapshot", "checkpoint saved", "call_1"),
+                assistant_tool("outline", {"file_path": "src", "depth": 1}, "call_2"),
+                tool("outline", "src/server.py\n  10 def handle\nsrc/middleware.py\n  8 def attach_request_id", "call_2"),
+                assistant_tool("grep", {"pattern": "request_id", "path": "src", "include": "**/*.py"}, "call_3"),
+                tool("grep", "src/middleware.py:8:def attach_request_id(req): <<<", "call_3"),
+                assistant_tool("read_file", {"file_path": "src/middleware.py", "offset": 1, "limit": 80}, "call_4"),
+                tool("read_file", "8| def attach_request_id(req):\n9|     req.id = uuid4().hex\n[checksum=5678abcd]", "call_4"),
+                assistant_tool("snapshot", {"action": "restore", "summary": "Request IDs are assigned in src/middleware.py:8 by attach_request_id, which sets req.id to uuid4().hex. The server handler calls it before routing."}, "call_5"),
+                tool("snapshot", "restored context from request id investigation", "call_5"),
+                assistant("I summarized the read-only investigation and can now make a focused edit."),
+            ],
+        )
+    )
+
+    out: list[Example] = []
+    for i in range(repeat):
+        for ex in base:
+            out.append(Example(id=f"{ex.id}-{i:03d}", split=ex.split, tags=ex.tags, messages=ex.messages))
+    return out
+
+
+def synthesize_examples(inventory: list[dict[str, Any]], count: int, seed: int) -> list[Example]:
+    rng = random.Random(seed)
+    names = [item["name"] for item in inventory]
+    examples: list[Example] = []
+    intents = [
+        "Inspect the relevant files before editing.",
+        "Make the smallest safe change and verify it.",
+        "Find where this behavior is implemented.",
+        "Run the focused command and summarize the result.",
+        "Recover from the tool error by sending a corrected call.",
+    ]
+    for i in range(count):
+        name = rng.choice(names)
+        exemplar = rng.choice(TOOL_EXEMPLARS.get(name, [{}]))
+        args = json.loads(json.dumps(exemplar))
+        prompt = f"{rng.choice(intents)} Use the appropriate Swival tool for step {i + 1}."
+        examples.append(
+            Example(
+                id=f"synthetic-{i:05d}-{name}",
+                split="train",
+                tags=["synthetic", name],
+                messages=[user(prompt), assistant_tool(name, args), tool(name, result_for_tool(name, args)), assistant(final_for_tool(name))],
+            )
+        )
+    return examples
+
+
+def eval_examples() -> list[dict[str, Any]]:
+    return [
+        {
+            "id": "eval-edit-line-number",
+            "prompt": "In settings.py, change only the second timeout value from 5 to 10. Do not change the first timeout.",
+            "files": {"settings.py": "timeout = 5\nretries = 2\ntimeout = 5\n"},
+            "verify": {"settings.py": "timeout = 5\nretries = 2\ntimeout = 10\n"},
+            "expected_tools": ["read_file", "edit_file"],
+        },
+        {
+            "id": "eval-grep-edit-test",
+            "prompt": "Find the Python function that accepts empty names, make it reject empty strings, and run `python3 -m pytest tests/test_names.py`.",
+            "files": {
+                "src/names.py": "class NameError(Exception):\n    pass\n\n\ndef normalize_name(name):\n    if name is None:\n        raise NameError('missing')\n    return name.strip()\n",
+                "tests/test_names.py": "from src.names import NameError, normalize_name\n\n\ndef test_empty_name_rejected():\n    try:\n        normalize_name('   ')\n    except NameError:\n        return\n    raise AssertionError('empty name accepted')\n",
+                "pytest.py": PYTEST_SHIM,
+                "pyproject.toml": "[tool.pytest.ini_options]\npythonpath = ['.']\n",
+            },
+            "verify": {
+                "src/names.py": "class NameError(Exception):\n    pass\n\n\ndef normalize_name(name):\n    if name is None:\n        raise NameError('missing')\n    normalized = name.strip()\n    if not normalized:\n        raise NameError('missing')\n    return normalized\n"
+            },
+            "expected_tools": ["grep", "read_file", "edit_file", "run_command"],
+        },
+        {
+            "id": "eval-batch-read-write",
+            "prompt": "Read README.md and pyproject.toml, then create docs/summary.md with the project name and one-sentence description.",
+            "files": {
+                "README.md": "# Widget\n\nA tiny request router.\n",
+                "pyproject.toml": "[project]\nname = 'widget'\n",
+            },
+            "verify_contains": {"docs/summary.md": ["widget", "tiny request router"]},
+            "expected_tools": ["read_multiple_files", "write_file"],
+        },
+        {
+            "id": "eval-delete-obsolete",
+            "prompt": "Delete obsolete.py and leave keep.py alone.",
+            "files": {"obsolete.py": "print('old')\n", "keep.py": "print('keep')\n"},
+            "verify_missing": ["obsolete.py"],
+            "verify": {"keep.py": "print('keep')\n"},
+            "expected_tools": ["delete_file"],
+        },
+        {
+            "id": "eval-command-argv",
+            "prompt": "Run the test command `python3 -m pytest tests/test_math.py` and report whether it passed. Use argv form, not a shell string.",
+            "files": {
+                "mathlib.py": "def add(a, b):\n    return a + b\n",
+                "tests/test_math.py": "from mathlib import add\n\n\ndef test_add():\n    assert add(2, 3) == 5\n",
+                "pytest.py": PYTEST_SHIM,
+            },
+            "verify_command": ["python3", "-m", "pytest", "tests/test_math.py"],
+            "expected_tools": ["run_command"],
+        },
+    ]
+
+
+def write_jsonl(path: Path, examples: list[Example]) -> None:
+    with path.open("w") as f:
+        for ex in examples:
+            f.write(json.dumps({"id": ex.id, "split": ex.split, "tags": ex.tags, "messages": ex.messages}, separators=(",", ":")) + "\n")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--per-tool", type=int, default=12)
+    parser.add_argument("--synthetic-count", type=int, default=5000)
+    parser.add_argument("--workflow-repeat", type=int, default=100)
+    parser.add_argument("--seed", type=int, default=20260607)
+    parser.add_argument("--clean", action="store_true")
+    args = parser.parse_args()
+
+    DATA_DIR.mkdir(exist_ok=True)
+    TMP_DIR.mkdir(exist_ok=True)
+    if args.clean and DATA_DIR.exists():
+        shutil.rmtree(DATA_DIR)
+        DATA_DIR.mkdir()
+
+    inventory = extract_tool_inventory()
+    examples = []
+    examples.extend(one_shot_examples(inventory, args.per_tool))
+    examples.extend(workflow_examples(args.workflow_repeat))
+    examples.extend(synthesize_examples(inventory, args.synthetic_count, args.seed))
+
+    write_jsonl(DATA_DIR / "swival_tool_calling_train.jsonl", examples)
+    with (DATA_DIR / "swival_tool_inventory.json").open("w") as f:
+        json.dump({"source": str(SWIVAL_TOOLS), "tools": inventory}, f, indent=2)
+        f.write("\n")
+    with (DATA_DIR / "swival_tool_calling_eval.jsonl").open("w") as f:
+        for row in eval_examples():
+            f.write(json.dumps(row, separators=(",", ":")) + "\n")
+
+    print(f"wrote {len(examples)} training examples")
+    print(f"wrote {len(eval_examples())} eval tasks")
+    print(f"covered {len(inventory)} tools")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/run_codex_eval.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import subprocess
+import time
+from pathlib import Path
+from typing import Any
+
+
+ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_EVALS = ROOT / "data" / "codex_tool_calling_eval.jsonl"
+WORK_ROOT = ROOT / "tmp" / "codex-eval"
+
+
+def iter_jsonl(path: Path):
+    with path.open() as f:
+        for line in f:
+            if line.strip():
+                yield json.loads(line)
+
+
+def seed_workspace(case: dict[str, Any], workdir: Path) -> None:
+    if workdir.exists():
+        shutil.rmtree(workdir)
+    workdir.mkdir(parents=True)
+    for rel, text in case["files"].items():
+        path = workdir / rel
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(text)
+
+
+def apply_expected_outputs(case: dict[str, Any], workdir: Path) -> None:
+    for rel, text in (case.get("verify") or {}).items():
+        path = workdir / rel
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(text)
+    for rel, needles in (case.get("verify_contains") or {}).items():
+        path = workdir / rel
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text("\n".join(needles) + "\n")
+    for rel, expected in (case.get("verify_json") or {}).items():
+        path = workdir / rel
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(expected, indent=2) + "\n")
+    for rel in case.get("verify_missing") or []:
+        path = workdir / rel
+        if path.exists():
+            path.unlink()
+
+
+def verify_case(case: dict[str, Any], workdir: Path) -> list[str]:
+    errors: list[str] = []
+    for rel, expected in (case.get("verify") or {}).items():
+        path = workdir / rel
+        if not path.exists():
+            errors.append(f"{rel} is missing")
+        elif path.read_text() != expected:
+            errors.append(f"{rel} did not match expected content")
+    for rel, needles in (case.get("verify_contains") or {}).items():
+        path = workdir / rel
+        if not path.exists():
+            errors.append(f"{rel} is missing")
+            continue
+        text = path.read_text().lower()
+        for needle in needles:
+            if needle.lower() not in text:
+                errors.append(f"{rel} does not contain {needle!r}")
+    for rel, expected in (case.get("verify_json") or {}).items():
+        path = workdir / rel
+        if not path.exists():
+            errors.append(f"{rel} is missing")
+            continue
+        try:
+            actual = json.loads(path.read_text())
+        except Exception as exc:
+            errors.append(f"{rel} is not valid JSON: {exc}")
+            continue
+        for key, value in expected.items():
+            if actual.get(key) != value:
+                errors.append(f"{rel} field {key!r} expected {value!r}, got {actual.get(key)!r}")
+    for rel in case.get("verify_missing") or []:
+        if (workdir / rel).exists():
+            errors.append(f"{rel} still exists")
+    command = case.get("verify_command")
+    if command:
+        proc = subprocess.run(command, cwd=workdir, text=True, capture_output=True, timeout=120)
+        if proc.returncode != 0:
+            errors.append(f"verify_command failed: {proc.stdout}{proc.stderr}")
+    return errors
+
+
+def parse_events(stdout: str) -> tuple[list[str], list[str]]:
+    event_types: list[str] = []
+    item_types: list[str] = []
+    for line in stdout.splitlines():
+        line = line.strip()
+        if not line or not line.startswith("{"):
+            continue
+        try:
+            event = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(event.get("type"), str):
+            event_types.append(event["type"])
+        item = event.get("item")
+        if isinstance(item, dict) and isinstance(item.get("type"), str):
+            item_types.append(item["type"])
+    return event_types, item_types
+
+
+def event_errors(case: dict[str, Any], event_types: list[str], item_types: list[str]) -> list[str]:
+    observed = set(event_types) | set(item_types)
+    expected = set(case.get("expected_events") or [])
+    return [f"missing expected event/item type {name}" for name in sorted(expected - observed)]
+
+
+def self_check_case(case: dict[str, Any]) -> dict[str, Any]:
+    workdir = WORK_ROOT / f"self-check-{case['id']}"
+    seed_workspace(case, workdir)
+    apply_expected_outputs(case, workdir)
+    errors = verify_case(case, workdir)
+    return {"id": case["id"], "passed": not errors, "verify_errors": errors}
+
+
+def run_case(case: dict[str, Any], args: argparse.Namespace) -> dict[str, Any]:
+    workdir = WORK_ROOT / case["id"]
+    seed_workspace(case, workdir)
+    last_message = workdir / "last-message.txt"
+    command = [
+        "codex",
+        "-a",
+        "never",
+        "exec",
+        "--json",
+        "--ephemeral",
+        "--skip-git-repo-check",
+        "--color",
+        "never",
+        "--sandbox",
+        args.sandbox,
+        "-C",
+        str(workdir),
+        "-c",
+        f"model_provider=\"{args.provider}\"",
+        "-m",
+        args.model,
+        "-o",
+        str(last_message),
+        case["prompt"],
+    ]
+    env = os.environ.copy()
+    env.setdefault("OMLX_API_KEY", "omlx")
+
+    start = time.time()
+    proc = subprocess.run(command, cwd=workdir, text=True, capture_output=True, timeout=args.timeout, env=env)
+    event_types, item_types = parse_events(proc.stdout)
+    verify_errors = verify_case(case, workdir) if proc.returncode == 0 else ["codex exited nonzero"]
+    event_check_errors = event_errors(case, event_types, item_types) if proc.returncode == 0 else []
+    return {
+        "id": case["id"],
+        "returncode": proc.returncode,
+        "seconds": round(time.time() - start, 3),
+        "passed": proc.returncode == 0 and not verify_errors and not event_check_errors,
+        "verify_errors": verify_errors,
+        "event_errors": event_check_errors,
+        "event_types": sorted(set(event_types)),
+        "item_types": sorted(set(item_types)),
+        "last_message": last_message.read_text() if last_message.exists() else "",
+        "stdout_tail": proc.stdout[-4000:],
+        "stderr_tail": proc.stderr[-4000:],
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--evals", type=Path, default=DEFAULT_EVALS)
+    parser.add_argument("--model", default="qwen35")
+    parser.add_argument("--provider", default="omlx")
+    parser.add_argument("--sandbox", default="workspace-write")
+    parser.add_argument("--timeout", type=int, default=300)
+    parser.add_argument("--limit", type=int)
+    parser.add_argument("--self-check", action="store_true", help="Verify eval seed/check logic without invoking Codex.")
+    args = parser.parse_args()
+
+    WORK_ROOT.mkdir(parents=True, exist_ok=True)
+    cases = list(iter_jsonl(args.evals))
+    if args.limit is not None:
+        cases = cases[: args.limit]
+
+    results = []
+    for case in cases:
+        if args.self_check:
+            result = self_check_case(case)
+        else:
+            print(f"running {case['id']}")
+            try:
+                result = run_case(case, args)
+            except subprocess.TimeoutExpired as exc:
+                result = {
+                    "id": case["id"],
+                    "returncode": None,
+                    "seconds": args.timeout,
+                    "passed": False,
+                    "verify_errors": ["codex timed out"],
+                    "event_errors": [],
+                    "event_types": [],
+                    "item_types": [],
+                    "last_message": "",
+                    "stdout_tail": (exc.stdout or "")[-4000:],
+                    "stderr_tail": (exc.stderr or "")[-4000:],
+                }
+        print(json.dumps(result, indent=2))
+        results.append(result)
+
+    out = ROOT / "tmp" / "codex-eval-results.json"
+    out.write_text(json.dumps(results, indent=2) + "\n")
+    failed = [row for row in results if not row["passed"]]
+    print(f"passed {len(results) - len(failed)}/{len(results)}")
+    return 1 if failed else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/run_opencode_eval.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import subprocess
+import time
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_EVALS = ROOT / "data" / "opencode_tool_calling_eval.jsonl"
+DEFAULT_CONFIG = ROOT / "configs" / "opencode-qwen35.json"
+WORK_ROOT = ROOT / "tmp" / "opencode-eval"
+
+
+def iter_jsonl(path: Path):
+    with path.open() as f:
+        for line in f:
+            if line.strip():
+                yield json.loads(line)
+
+
+def seed_workspace(case: dict, workdir: Path) -> None:
+    if workdir.exists():
+        shutil.rmtree(workdir)
+    workdir.mkdir(parents=True)
+    for rel, text in case["files"].items():
+        path = workdir / rel
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(text)
+
+
+def apply_expected_outputs(case: dict, workdir: Path) -> None:
+    for rel, text in (case.get("verify") or {}).items():
+        path = workdir / rel
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(text)
+    for rel, needles in (case.get("verify_contains") or {}).items():
+        path = workdir / rel
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text("\n".join(needles) + "\n")
+    for rel in case.get("verify_missing") or []:
+        path = workdir / rel
+        if path.exists():
+            path.unlink()
+
+
+def verify_case(case: dict, workdir: Path) -> list[str]:
+    errors: list[str] = []
+    for rel, expected in (case.get("verify") or {}).items():
+        path = workdir / rel
+        if not path.exists():
+            errors.append(f"{rel} is missing")
+        elif path.read_text() != expected:
+            errors.append(f"{rel} did not match expected content")
+    for rel, needles in (case.get("verify_contains") or {}).items():
+        path = workdir / rel
+        if not path.exists():
+            errors.append(f"{rel} is missing")
+            continue
+        text = path.read_text().lower()
+        for needle in needles:
+            if needle.lower() not in text:
+                errors.append(f"{rel} does not contain {needle!r}")
+    for rel in case.get("verify_missing") or []:
+        if (workdir / rel).exists():
+            errors.append(f"{rel} still exists")
+    command = case.get("verify_command")
+    if command:
+        proc = subprocess.run(command, cwd=workdir, text=True, capture_output=True, timeout=120)
+        if proc.returncode != 0:
+            errors.append(f"verify_command failed: {proc.stdout}{proc.stderr}")
+    return errors
+
+
+def parse_tool_mentions(text: str, expected_tools: list[str]) -> list[str]:
+    found: list[str] = []
+    lower = text.lower()
+    for name in expected_tools:
+        if name.lower() in lower:
+            found.append(name)
+    return found
+
+
+def self_check_case(case: dict) -> dict:
+    workdir = WORK_ROOT / f"self-check-{case['id']}"
+    seed_workspace(case, workdir)
+    apply_expected_outputs(case, workdir)
+    errors = verify_case(case, workdir)
+    return {"id": case["id"], "passed": not errors, "verify_errors": errors}
+
+
+def run_case(case: dict, args: argparse.Namespace) -> dict:
+    workdir = WORK_ROOT / case["id"]
+    seed_workspace(case, workdir)
+    config_content = args.config.read_text()
+    command = [
+        "bunx",
+        "opencode-ai@latest",
+        "run",
+        "--model",
+        args.model,
+        "--format",
+        "json",
+        "--dir",
+        str(workdir),
+    ]
+    if args.dangerously_skip_permissions:
+        command.append("--dangerously-skip-permissions")
+    command.append(case["prompt"])
+    env = os.environ.copy()
+    env["OPENCODE_CONFIG_CONTENT"] = config_content
+    env.setdefault("OPENAI_API_KEY", "omlx")
+
+    start = time.time()
+    proc = subprocess.run(command, cwd=workdir, text=True, capture_output=True, timeout=args.timeout, env=env)
+    verify_errors = verify_case(case, workdir) if proc.returncode == 0 else ["opencode exited nonzero"]
+    combined = f"{proc.stdout}\n{proc.stderr}"
+    return {
+        "id": case["id"],
+        "returncode": proc.returncode,
+        "seconds": round(time.time() - start, 3),
+        "passed": proc.returncode == 0 and not verify_errors,
+        "verify_errors": verify_errors,
+        "expected_tools": case.get("expected_tools") or [],
+        "observed_tool_mentions": parse_tool_mentions(combined, case.get("expected_tools") or []),
+        "stdout_tail": proc.stdout[-4000:],
+        "stderr_tail": proc.stderr[-4000:],
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--evals", type=Path, default=DEFAULT_EVALS)
+    parser.add_argument("--config", type=Path, default=DEFAULT_CONFIG)
+    parser.add_argument("--model", default="qwen35/qwen35")
+    parser.add_argument("--timeout", type=int, default=300)
+    parser.add_argument("--limit", type=int)
+    parser.add_argument("--self-check", action="store_true", help="Verify eval seed/check logic without invoking opencode.")
+    parser.add_argument("--dangerously-skip-permissions", action="store_true", help="Pass opencode's non-interactive permission bypass flag for disposable eval workspaces.")
+    args = parser.parse_args()
+
+    WORK_ROOT.mkdir(parents=True, exist_ok=True)
+    cases = list(iter_jsonl(args.evals))
+    if args.limit is not None:
+        cases = cases[: args.limit]
+
+    results = []
+    for case in cases:
+        if args.self_check:
+            result = self_check_case(case)
+        else:
+            print(f"running {case['id']}")
+            try:
+                result = run_case(case, args)
+            except subprocess.TimeoutExpired as exc:
+                result = {
+                    "id": case["id"],
+                    "returncode": None,
+                    "seconds": args.timeout,
+                    "passed": False,
+                    "verify_errors": ["opencode timed out"],
+                    "expected_tools": case.get("expected_tools") or [],
+                    "observed_tool_mentions": [],
+                    "stdout_tail": (exc.stdout or "")[-4000:],
+                    "stderr_tail": (exc.stderr or "")[-4000:],
+                }
+        print(json.dumps(result, indent=2))
+        results.append(result)
+
+    out = ROOT / "tmp" / "opencode-eval-results.json"
+    out.write_text(json.dumps(results, indent=2) + "\n")
+    failed = [row for row in results if not row["passed"]]
+    print(f"passed {len(results) - len(failed)}/{len(results)}")
+    return 1 if failed else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/run_swival_eval.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+import subprocess
+import time
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_EVALS = ROOT / "data" / "swival_tool_calling_eval.jsonl"
+WORK_ROOT = ROOT / "tmp" / "swival-eval"
+
+
+def iter_jsonl(path: Path):
+    with path.open() as f:
+        for line in f:
+            if line.strip():
+                yield json.loads(line)
+
+
+def seed_workspace(case: dict, workdir: Path) -> None:
+    if workdir.exists():
+        shutil.rmtree(workdir)
+    workdir.mkdir(parents=True)
+    for rel, text in case["files"].items():
+        dest = workdir / rel
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        dest.write_text(text)
+
+
+def verify_case(case: dict, workdir: Path) -> list[str]:
+    errors: list[str] = []
+    for rel, expected in (case.get("verify") or {}).items():
+        path = workdir / rel
+        if not path.exists():
+            errors.append(f"{rel} is missing")
+        elif path.read_text() != expected:
+            errors.append(f"{rel} did not match expected content")
+    for rel, needles in (case.get("verify_contains") or {}).items():
+        path = workdir / rel
+        if not path.exists():
+            errors.append(f"{rel} is missing")
+            continue
+        text = path.read_text().lower()
+        for needle in needles:
+            if needle.lower() not in text:
+                errors.append(f"{rel} does not contain {needle!r}")
+    for rel in case.get("verify_missing") or []:
+        if (workdir / rel).exists():
+            errors.append(f"{rel} still exists")
+    command = case.get("verify_command")
+    if command:
+        proc = subprocess.run(command, cwd=workdir, text=True, capture_output=True, timeout=120)
+        if proc.returncode != 0:
+            errors.append(f"verify_command failed: {proc.stdout}{proc.stderr}")
+    return errors
+
+
+def apply_expected_outputs(case: dict, workdir: Path) -> None:
+    for rel, text in (case.get("verify") or {}).items():
+        path = workdir / rel
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(text)
+    for rel, needles in (case.get("verify_contains") or {}).items():
+        path = workdir / rel
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text("\n".join(needles) + "\n")
+    for rel in case.get("verify_missing") or []:
+        path = workdir / rel
+        if path.exists():
+            path.unlink()
+
+
+def run_case(case: dict, profile: str, swival_bin: str, timeout: int) -> dict:
+    workdir = WORK_ROOT / case["id"]
+    seed_workspace(case, workdir)
+    cmd = [swival_bin, "--profile", profile, case["prompt"]]
+    start = time.time()
+    proc = subprocess.run(cmd, cwd=workdir, text=True, capture_output=True, timeout=timeout)
+    verify_errors = verify_case(case, workdir) if proc.returncode == 0 else ["swival exited nonzero"]
+    return {
+        "id": case["id"],
+        "returncode": proc.returncode,
+        "seconds": round(time.time() - start, 3),
+        "passed": proc.returncode == 0 and not verify_errors,
+        "verify_errors": verify_errors,
+        "stdout_tail": proc.stdout[-4000:],
+        "stderr_tail": proc.stderr[-4000:],
+    }
+
+
+def self_check_case(case: dict) -> dict:
+    workdir = WORK_ROOT / f"self-check-{case['id']}"
+    seed_workspace(case, workdir)
+    apply_expected_outputs(case, workdir)
+    errors = verify_case(case, workdir)
+    return {"id": case["id"], "passed": not errors, "verify_errors": errors}
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--evals", type=Path, default=DEFAULT_EVALS)
+    parser.add_argument("--profile", default="omlx")
+    parser.add_argument("--swival-bin", default="swival")
+    parser.add_argument("--timeout", type=int, default=300)
+    parser.add_argument("--limit", type=int)
+    parser.add_argument("--self-check", action="store_true", help="Verify eval seed/check logic without invoking Swival.")
+    args = parser.parse_args()
+
+    WORK_ROOT.mkdir(parents=True, exist_ok=True)
+    cases = list(iter_jsonl(args.evals))
+    if args.limit is not None:
+        cases = cases[: args.limit]
+
+    results = []
+    for case in cases:
+        if args.self_check:
+            result = self_check_case(case)
+            print(json.dumps(result, indent=2))
+            results.append(result)
+            continue
+        print(f"running {case['id']}")
+        try:
+            result = run_case(case, args.profile, args.swival_bin, args.timeout)
+        except subprocess.TimeoutExpired as exc:
+            result = {
+                "id": case["id"],
+                "returncode": None,
+                "seconds": args.timeout,
+                "passed": False,
+                "verify_errors": ["swival timed out"],
+                "stdout_tail": (exc.stdout or "")[-4000:],
+                "stderr_tail": (exc.stderr or "")[-4000:],
+            }
+        print(json.dumps(result, indent=2))
+        results.append(result)
+
+    out = ROOT / "tmp" / "swival-eval-results.json"
+    out.write_text(json.dumps(results, indent=2) + "\n")
+    failed = [r for r in results if not r["passed"]]
+    print(f"passed {len(results) - len(failed)}/{len(results)}")
+    return 1 if failed else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/validate_codex_dataset.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+from collections import Counter
+from pathlib import Path
+from typing import Any
+
+
+ROOT = Path(__file__).resolve().parents[1]
+INVENTORY = ROOT / "data" / "codex_tool_inventory.json"
+
+
+def load_inventory() -> dict[str, dict[str, Any]]:
+    blob = json.loads(INVENTORY.read_text())
+    return {tool["name"]: tool for tool in blob["tools"]}
+
+
+def iter_jsonl(path: Path):
+    with path.open() as f:
+        for line_no, line in enumerate(f, 1):
+            if line.strip():
+                yield line_no, json.loads(line)
+
+
+def validate_training(path: Path, inventory: dict[str, dict[str, Any]]) -> list[str]:
+    errors: list[str] = []
+    coverage: Counter[str] = Counter()
+    for line_no, row in iter_jsonl(path):
+        messages = row.get("messages")
+        if not isinstance(messages, list) or not messages:
+            errors.append(f"{path}:{line_no}: missing messages")
+            continue
+        has_call = False
+        for msg in messages:
+            if msg.get("role") != "assistant":
+                continue
+            for tc in msg.get("tool_calls") or []:
+                has_call = True
+                fn = tc.get("function") or {}
+                name = fn.get("name")
+                if name not in inventory:
+                    errors.append(f"{path}:{line_no}: unknown tool {name!r}")
+                    continue
+                coverage[name] += 1
+                try:
+                    args = json.loads(fn.get("arguments"))
+                except Exception as exc:
+                    errors.append(f"{path}:{line_no}: bad JSON arguments for {name}: {exc}")
+                    continue
+                if not isinstance(args, dict):
+                    errors.append(f"{path}:{line_no}: {name} arguments must be an object")
+                    continue
+                for required in inventory[name].get("required", []):
+                    if required not in args:
+                        errors.append(f"{path}:{line_no}: {name} missing required argument {required}")
+        if not has_call:
+            errors.append(f"{path}:{line_no}: example has no assistant tool call")
+    missing = sorted(set(inventory) - set(coverage))
+    if missing:
+        errors.append(f"{path}: missing Codex tool coverage: {', '.join(missing)}")
+    return errors
+
+
+def validate_eval(path: Path) -> list[str]:
+    errors: list[str] = []
+    for line_no, row in iter_jsonl(path):
+        if not row.get("id") or not row.get("prompt"):
+            errors.append(f"{path}:{line_no}: eval row needs id and prompt")
+        if not isinstance(row.get("files"), dict):
+            errors.append(f"{path}:{line_no}: eval row needs files object")
+        if not any(key in row for key in ["verify", "verify_contains", "verify_missing", "verify_command", "verify_json"]):
+            errors.append(f"{path}:{line_no}: eval row has no verifier")
+        for event_type in row.get("expected_events") or []:
+            if not isinstance(event_type, str) or not event_type:
+                errors.append(f"{path}:{line_no}: expected_events must be non-empty strings")
+    return errors
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("path", type=Path)
+    args = parser.parse_args()
+
+    if args.path.name.endswith("_eval.jsonl"):
+        errors = validate_eval(args.path)
+    else:
+        errors = validate_training(args.path, load_inventory())
+    if errors:
+        for error in errors:
+            print(error)
+        return 1
+    print(f"ok: {args.path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/validate_opencode_dataset.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+from collections import Counter
+from pathlib import Path
+from typing import Any
+
+
+ROOT = Path(__file__).resolve().parents[1]
+INVENTORY = ROOT / "data" / "opencode_tool_inventory.json"
+
+
+def load_inventory() -> dict[str, dict[str, Any]]:
+    blob = json.loads(INVENTORY.read_text())
+    return {tool["name"]: tool for tool in blob["tools"]}
+
+
+def iter_jsonl(path: Path):
+    with path.open() as f:
+        for line_no, line in enumerate(f, 1):
+            if line.strip():
+                yield line_no, json.loads(line)
+
+
+def validate_training(path: Path, inventory: dict[str, dict[str, Any]]) -> list[str]:
+    errors: list[str] = []
+    coverage: Counter[str] = Counter()
+    for line_no, row in iter_jsonl(path):
+        messages = row.get("messages")
+        if not isinstance(messages, list) or not messages:
+            errors.append(f"{path}:{line_no}: missing messages")
+            continue
+        has_call = False
+        for msg in messages:
+            if msg.get("role") != "assistant":
+                continue
+            for tc in msg.get("tool_calls") or []:
+                has_call = True
+                fn = tc.get("function") or {}
+                name = fn.get("name")
+                if name not in inventory:
+                    errors.append(f"{path}:{line_no}: unknown tool {name!r}")
+                    continue
+                coverage[name] += 1
+                try:
+                    args = json.loads(fn.get("arguments"))
+                except Exception as exc:
+                    errors.append(f"{path}:{line_no}: bad JSON arguments for {name}: {exc}")
+                    continue
+                if not isinstance(args, dict):
+                    errors.append(f"{path}:{line_no}: {name} arguments must be an object")
+                    continue
+                for required in inventory[name].get("required", []):
+                    if required not in args:
+                        errors.append(f"{path}:{line_no}: {name} missing required argument {required}")
+        if not has_call:
+            errors.append(f"{path}:{line_no}: example has no assistant tool call")
+    missing = sorted(set(inventory) - set(coverage))
+    if missing:
+        errors.append(f"{path}: missing opencode tool coverage: {', '.join(missing)}")
+    return errors
+
+
+def validate_eval(path: Path, inventory: dict[str, dict[str, Any]]) -> list[str]:
+    errors: list[str] = []
+    for line_no, row in iter_jsonl(path):
+        if not row.get("id") or not row.get("prompt"):
+            errors.append(f"{path}:{line_no}: eval row needs id and prompt")
+        if not isinstance(row.get("files"), dict):
+            errors.append(f"{path}:{line_no}: eval row needs files object")
+        for name in row.get("expected_tools") or []:
+            if name not in inventory:
+                errors.append(f"{path}:{line_no}: unknown expected tool {name}")
+        if not any(key in row for key in ["verify", "verify_contains", "verify_missing", "verify_command"]):
+            errors.append(f"{path}:{line_no}: eval row has no verifier")
+    return errors
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("path", type=Path)
+    args = parser.parse_args()
+
+    inventory = load_inventory()
+    if args.path.name.endswith("_eval.jsonl"):
+        errors = validate_eval(args.path, inventory)
+    else:
+        errors = validate_training(args.path, inventory)
+    if errors:
+        for error in errors:
+            print(error)
+        return 1
+    print(f"ok: {args.path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/validate_swival_dataset.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+from collections import Counter
+from pathlib import Path
+from typing import Any
+
+
+ROOT = Path(__file__).resolve().parents[1]
+INVENTORY = ROOT / "data" / "swival_tool_inventory.json"
+
+
+def load_inventory() -> dict[str, dict[str, Any]]:
+    blob = json.loads(INVENTORY.read_text())
+    return {tool["name"]: tool for tool in blob["tools"]}
+
+
+def iter_jsonl(path: Path):
+    with path.open() as f:
+        for line_no, line in enumerate(f, 1):
+            if line.strip():
+                yield line_no, json.loads(line)
+
+
+def validate_training(path: Path, inventory: dict[str, dict[str, Any]]) -> list[str]:
+    errors: list[str] = []
+    coverage: Counter[str] = Counter()
+    for line_no, row in iter_jsonl(path):
+        messages = row.get("messages")
+        if not isinstance(messages, list) or not messages:
+            errors.append(f"{path}:{line_no}: missing messages")
+            continue
+        for msg in messages:
+            if msg.get("role") == "assistant":
+                for tc in msg.get("tool_calls") or []:
+                    fn = tc.get("function") or {}
+                    name = fn.get("name")
+                    if name not in inventory:
+                        errors.append(f"{path}:{line_no}: unknown tool {name!r}")
+                        continue
+                    coverage[name] += 1
+                    raw_args = fn.get("arguments")
+                    try:
+                        args = json.loads(raw_args)
+                    except Exception as exc:
+                        errors.append(f"{path}:{line_no}: bad JSON arguments for {name}: {exc}")
+                        continue
+                    if not isinstance(args, dict):
+                        errors.append(f"{path}:{line_no}: arguments for {name} must be an object")
+                        continue
+                    for required in inventory[name].get("required", []):
+                        if required not in args:
+                            errors.append(f"{path}:{line_no}: {name} missing required argument {required}")
+        if not any((msg.get("tool_calls") for msg in messages if msg.get("role") == "assistant")):
+            errors.append(f"{path}:{line_no}: example has no assistant tool call")
+
+    missing = sorted(set(inventory) - set(coverage))
+    if missing:
+        errors.append(f"{path}: missing tool coverage: {', '.join(missing)}")
+    return errors
+
+
+def validate_eval(path: Path, inventory: dict[str, dict[str, Any]]) -> list[str]:
+    errors: list[str] = []
+    for line_no, row in iter_jsonl(path):
+        if not row.get("id") or not row.get("prompt"):
+            errors.append(f"{path}:{line_no}: eval row needs id and prompt")
+        if not isinstance(row.get("files"), dict):
+            errors.append(f"{path}:{line_no}: eval row needs files object")
+        expected = row.get("expected_tools") or []
+        for name in expected:
+            if name not in inventory:
+                errors.append(f"{path}:{line_no}: unknown expected tool {name}")
+        if not any(key in row for key in ["verify", "verify_contains", "verify_missing", "verify_command"]):
+            errors.append(f"{path}:{line_no}: eval row has no verifier")
+    return errors
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("path", type=Path)
+    args = parser.parse_args()
+
+    inventory = load_inventory()
+    if args.path.name.endswith("_eval.jsonl"):
+        errors = validate_eval(args.path, inventory)
+    else:
+        errors = validate_training(args.path, inventory)
+
+    if errors:
+        for err in errors:
+            print(err)
+        return 1
+    print(f"ok: {args.path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

swival/eval.jsonl

@@ -0,0 +1,5 @@
+{"id":"eval-edit-line-number","prompt":"In settings.py, change only the second timeout value from 5 to 10. Do not change the first timeout.","files":{"settings.py":"timeout = 5\nretries = 2\ntimeout = 5\n"},"verify":{"settings.py":"timeout = 5\nretries = 2\ntimeout = 10\n"},"expected_tools":["read_file","edit_file"]}
+{"id":"eval-grep-edit-test","prompt":"Find the Python function that accepts empty names, make it reject empty strings, and run `python3 -m pytest tests/test_names.py`.","files":{"src/names.py":"class NameError(Exception):\n    pass\n\n\ndef normalize_name(name):\n    if name is None:\n        raise NameError('missing')\n    return name.strip()\n","tests/test_names.py":"from src.names import NameError, normalize_name\n\n\ndef test_empty_name_rejected():\n    try:\n        normalize_name('   ')\n    except NameError:\n        return\n    raise AssertionError('empty name accepted')\n","pytest.py":"import importlib.util\nimport pathlib\nimport sys\n\nfailed = 0\nfor raw in sys.argv[1:]:\n    path = pathlib.Path(raw)\n    spec = importlib.util.spec_from_file_location(path.stem, path)\n    mod = importlib.util.module_from_spec(spec)\n    spec.loader.exec_module(mod)\n    for name in dir(mod):\n        if name.startswith(\"test_\"):\n            try:\n                getattr(mod, name)()\n            except Exception as exc:\n                failed = 1\n                print(f\"FAILED {raw}::{name}: {exc}\")\nif failed:\n    sys.exit(1)\nprint(\"passed\")\n","pyproject.toml":"[tool.pytest.ini_options]\npythonpath = ['.']\n"},"verify":{"src/names.py":"class NameError(Exception):\n    pass\n\n\ndef normalize_name(name):\n    if name is None:\n        raise NameError('missing')\n    normalized = name.strip()\n    if not normalized:\n        raise NameError('missing')\n    return normalized\n"},"expected_tools":["grep","read_file","edit_file","run_command"]}
+{"id":"eval-batch-read-write","prompt":"Read README.md and pyproject.toml, then create docs/summary.md with the project name and one-sentence description.","files":{"README.md":"# Widget\n\nA tiny request router.\n","pyproject.toml":"[project]\nname = 'widget'\n"},"verify_contains":{"docs/summary.md":["widget","tiny request router"]},"expected_tools":["read_multiple_files","write_file"]}
+{"id":"eval-delete-obsolete","prompt":"Delete obsolete.py and leave keep.py alone.","files":{"obsolete.py":"print('old')\n","keep.py":"print('keep')\n"},"verify_missing":["obsolete.py"],"verify":{"keep.py":"print('keep')\n"},"expected_tools":["delete_file"]}
+{"id":"eval-command-argv","prompt":"Run the test command `python3 -m pytest tests/test_math.py` and report whether it passed. Use argv form, not a shell string.","files":{"mathlib.py":"def add(a, b):\n    return a + b\n","tests/test_math.py":"from mathlib import add\n\n\ndef test_add():\n    assert add(2, 3) == 5\n","pytest.py":"import importlib.util\nimport pathlib\nimport sys\n\nfailed = 0\nfor raw in sys.argv[1:]:\n    path = pathlib.Path(raw)\n    spec = importlib.util.spec_from_file_location(path.stem, path)\n    mod = importlib.util.module_from_spec(spec)\n    spec.loader.exec_module(mod)\n    for name in dir(mod):\n        if name.startswith(\"test_\"):\n            try:\n                getattr(mod, name)()\n            except Exception as exc:\n                failed = 1\n                print(f\"FAILED {raw}::{name}: {exc}\")\nif failed:\n    sys.exit(1)\nprint(\"passed\")\n"},"verify_command":["python3","-m","pytest","tests/test_math.py"],"expected_tools":["run_command"]}

swival/tool_inventory.json

@@ -0,0 +1,267 @@
+{
+  "source": "/Users/j/src/swival/swival/tools.py",
+  "tools": [
+    {
+      "name": "a2a__reviewer",
+      "description": "Representative dynamic Swival integration tool.",
+      "required": [
+        "message"
+      ],
+      "properties": [
+        "message",
+        "context_id",
+        "task_id"
+      ]
+    },
+    {
+      "name": "check_subagents",
+      "description": "Runtime conditional Swival subagent tool.",
+      "required": [
+        "action"
+      ],
+      "properties": [
+        "action",
+        "subagent_id",
+        "timeout"
+      ]
+    },
+    {
+      "name": "complete_goal",
+      "description": "Mark the active goal complete. ONLY call this after running a completion audit that maps every explicit requirement in the objective to real evidence in the workspace (files, command output, test results). If you are blocked or need user input, do NOT call this \u2014 return final text explaining the blocker instead.",
+      "required": [],
+      "properties": []
+    },
+    {
+      "name": "delete_file",
+      "description": "Delete a file by moving it to the trash. Cannot delete directories.",
+      "required": [
+        "file_path"
+      ],
+      "properties": [
+        "file_path"
+      ]
+    },
+    {
+      "name": "edit_file",
+      "description": "Replace old_string with new_string in an existing file. Prefer over write_file for edits.",
+      "required": [
+        "file_path",
+        "old_string",
+        "new_string"
+      ],
+      "properties": [
+        "checksum",
+        "file_path",
+        "line_number",
+        "new_string",
+        "old_string",
+        "replace_all"
+      ]
+    },
+    {
+      "name": "fetch_url",
+      "description": "GET an HTTP/HTTPS URL, returned as markdown, text, or html.",
+      "required": [
+        "url"
+      ],
+      "properties": [
+        "format",
+        "timeout",
+        "url"
+      ]
+    },
+    {
+      "name": "grep",
+      "description": "Search file contents with a Python regex. Returns matches grouped by file with line numbers.",
+      "required": [
+        "pattern"
+      ],
+      "properties": [
+        "case_insensitive",
+        "context_lines",
+        "include",
+        "path",
+        "pattern"
+      ]
+    },
+    {
+      "name": "list_files",
+      "description": "Recursively list files matching a glob, relative to the base directory.",
+      "required": [
+        "pattern"
+      ],
+      "properties": [
+        "path",
+        "pattern"
+      ]
+    },
+    {
+      "name": "mcp__docs__search",
+      "description": "Representative dynamic Swival integration tool.",
+      "required": [
+        "query"
+      ],
+      "properties": [
+        "query",
+        "limit"
+      ]
+    },
+    {
+      "name": "outline",
+      "description": "Show classes, functions, and top-level declarations with line numbers (no bodies). Survey code before reading specific sections. Pass file_path for one file or directory, or files for a batch.",
+      "required": [],
+      "properties": [
+        "depth",
+        "file_path",
+        "files"
+      ]
+    },
+    {
+      "name": "read_file",
+      "description": "Read a file as numbered lines. Use offset/limit to paginate forward, or tail_lines=N for the file end. Truncated output shows the next offset. Also lists directories. A [checksum=...] trailer is appended for files; pass that checksum to a later edit_file call to guard against the file changing between read and edit.",
+      "required": [
+        "file_path"
+      ],
+      "properties": [
+        "file_path",
+        "limit",
+        "offset",
+        "tail_lines"
+      ]
+    },
+    {
+      "name": "read_multiple_files",
+      "description": "Prefer this over multiple read_file calls when you know which files you need. Reads a batch, each with optional offset/limit/tail_lines. Per-file errors are inline; the batch never fails as a whole.",
+      "required": [
+        "files"
+      ],
+      "properties": [
+        "files"
+      ]
+    },
+    {
+      "name": "run_command",
+      "description": "Run a command and return its output. Only whitelisted commands are allowed.",
+      "required": [
+        "command"
+      ],
+      "properties": [
+        "background",
+        "command",
+        "timeout"
+      ]
+    },
+    {
+      "name": "run_metaskill",
+      "description": "Run a dynamic skill workflow by name.",
+      "required": [
+        "name",
+        "input"
+      ],
+      "properties": [
+        "input",
+        "max_ask_calls",
+        "max_command_calls",
+        "name"
+      ]
+    },
+    {
+      "name": "run_shell_command",
+      "description": "Run a shell command string and return its output. Supports pipes, redirects, &&, and other shell syntax.",
+      "required": [
+        "command"
+      ],
+      "properties": [
+        "background",
+        "command",
+        "timeout"
+      ]
+    },
+    {
+      "name": "snapshot",
+      "description": "Collapse prior exploration turns into a compact summary to free context. save sets a checkpoint; restore replaces the turns since with your summary.",
+      "required": [
+        "action"
+      ],
+      "properties": [
+        "action",
+        "force",
+        "label",
+        "summary"
+      ]
+    },
+    {
+      "name": "spawn_subagent",
+      "description": "Runtime conditional Swival subagent tool.",
+      "required": [
+        "task"
+      ],
+      "properties": [
+        "task",
+        "max_turns",
+        "system_hint"
+      ]
+    },
+    {
+      "name": "think",
+      "description": "Private scratchpad for planning, debugging, or weighing alternatives. Use before complex actions.",
+      "required": [
+        "thought"
+      ],
+      "properties": [
+        "branch_from_thought",
+        "branch_id",
+        "mode",
+        "next_thought_needed",
+        "revises_thought",
+        "thought",
+        "thought_number",
+        "total_thoughts"
+      ]
+    },
+    {
+      "name": "todo",
+      "description": "Persistent checklist for multi-step work. Add items as discovered, mark done as completed. Survives context compaction.",
+      "required": [
+        "action"
+      ],
+      "properties": [
+        "action",
+        "tasks"
+      ]
+    },
+    {
+      "name": "use_skill",
+      "description": "Activate a skill to get detailed instructions for a specific task.",
+      "required": [
+        "name"
+      ],
+      "properties": [
+        "name"
+      ]
+    },
+    {
+      "name": "view_image",
+      "description": "View an image file (PNG, JPEG, GIF, WebP, BMP).",
+      "required": [
+        "image_path"
+      ],
+      "properties": [
+        "image_path",
+        "question"
+      ]
+    },
+    {
+      "name": "write_file",
+      "description": "Create or overwrite a file with content, or atomically rename move_from to file_path (not both). Parent directories are created.",
+      "required": [
+        "file_path"
+      ],
+      "properties": [
+        "content",
+        "file_path",
+        "move_from"
+      ]
+    }
+  ]
+}