@aperant/framework 0.8.4 → 0.8.7

package/drivers/browser/README.md

@@ -0,0 +1,105 @@
+# Browser Driver
+
+Bundled, first-party verify-proof driver targeting Chromium / Firefox /
+WebKit via two transports: the Puppeteer MCP server OR the
+`agent-browser` skill (Claude Code / OpenCode hosts).
+
+## When Aperant picks this driver
+
+`/apt:verify-proof` auto-selects `browser` when:
+
+- The project's `package.json` declares a web framework (Next.js, React,
+  Vue, Svelte, Angular, Solid) AND the project is NOT an Electron /
+  Tauri / React Native container.
+- The required IDL capabilities are a subset of: `navigate`, `click`,
+  `type`, `screenshot`, `assert_visible`, `assert_text`, `wait_for_idle`,
+  `execute_js`.
+
+## Capabilities
+
+The driver maps each IDL verb to BOTH transports. The workflow runner
+picks the transport at dispatch time via `chooseTransport({has_skill_tool})`;
+the chosen transport is recorded on each VerbResult as `transport: "skill" | "mcp"`.
+
+| IDL verb | Puppeteer MCP tool | agent-browser CLI |
+|----------|--------------------|--------------------|
+| `navigate` | `mcp__puppeteer__puppeteer_navigate` | `agent-browser open <url>` |
+| `click` | `mcp__puppeteer__puppeteer_click` | `agent-browser click @e<N>` |
+| `type` | `mcp__puppeteer__puppeteer_fill` | `agent-browser fill @e<N> <text>` |
+| `screenshot` | `mcp__puppeteer__puppeteer_screenshot` | `agent-browser screenshot` |
+| `assert_visible` | `mcp__puppeteer__puppeteer_evaluate` (selector check) | `agent-browser snapshot` + `agent-browser get role <sel>` |
+| `assert_text` | `mcp__puppeteer__puppeteer_evaluate` (textContent match) | `agent-browser snapshot` + `agent-browser get text <sel>` |
+| `wait_for_idle` | `mcp__puppeteer__puppeteer_evaluate` (networkidle check) | `agent-browser wait --load networkidle` |
+| `execute_js` | `mcp__puppeteer__puppeteer_evaluate` | `agent-browser eval <script>` |
+
+## Transport selection
+
+The driver carries TWO transport declarations on its manifest:
+
+```json
+"transport": { "mcp_server_id": "puppeteer", "skill_id": "agent-browser" }
+```
+
+The workflow runner picks between them via the driver's exported
+`chooseTransport({has_skill_tool})` helper. The selection rule:
+
+- **`Skill` tool exposed by host CLI** (Claude Code, OpenCode) → `'skill'`.
+  Dispatches via `Skill({skill: "agent-browser", args: ...})`. One fewer
+  external dep (no MCP server install).
+- **No Skill tool** (legacy host, MCP-only environment) → `'mcp'`.
+  Dispatches via `mcp__puppeteer__*` (the existing path).
+
+The resolver's "one driver per runtime tag" invariant is preserved —
+`browser` stays one driver with two transport options. No new
+driverId; no resolver disambiguation needed.
+
+## Manifest
+
+- **Priority:** 100 (highest among bundled drivers — browser is the most
+  common target).
+- **Stability:** `ga`.
+- **Trust:** `first_party_signed` (default-allow).
+- **Transport:** `{ mcp_server_id: "puppeteer", skill_id: "agent-browser" }`.
+  The `McpRegistry` handles consent gating for the MCP path per AC21;
+  the existing skill-permissions registry handles consent for the
+  Skill path.
+
+## V1 scope — adapter is thin
+
+This driver's `driver.mjs` is a manifest-conformant **adapter shim** in
+v1. Each verb validates its args against `IDL_VERB_ARGS`, then returns
+a VerbResult stub. **The actual transport dispatch — invoking
+`mcp__puppeteer__*` tools OR `Skill({skill: "agent-browser", ...})` —
+happens at the workflow-runner layer**, not inside this file: the model
+loads the workflow prose, the workflow names IDL verbs, and the model
+calls the tool whose name the driver manifest binds via
+`transport.mcp_server_id` (MCP path) or `transport.skill_id` (Skill
+path). The split exists because both tool surfaces are the model's, not
+the driver's runtime — drivers in v1 are the validator + manifest +
+resolver-anchor, not the executor.
+
+The driver's adapter shim DOES record the chosen transport on the
+returned VerbResult (`transport: "skill" | "mcp"`) so the workflow
+runner can populate the corresponding field on each
+`verification.json:tests[]` entry for audit purposes.
+
+Follow-up `verify-proof-driver-transport-wiring-v2` will lift transport
+dispatch into the driver process itself for drivers that want
+out-of-band execution (e.g. node-side fetch for the api driver, or
+direct Puppeteer.connect for headless CI).
+
+## Overriding
+
+To force the resolver to pick a different driver:
+
+```json
+// .aperant/config.json
+{
+  "verification": {
+    "runtimes": ["electron", "cli"]
+  }
+}
+```
+
+The resolver places listed driver IDs first; the highest-coverage / most-
+compatible / highest-priority driver still wins within the override list.

package/drivers/browser/driver.mjs

@@ -0,0 +1,134 @@
+/**
+ * browser/driver.mjs — bundled browser driver.
+ *
+ * Maps IDL verbs to one of two transports: the Puppeteer MCP server or
+ * the `agent-browser` skill. The manifest declares both:
+ *   transport.mcp_server_id = "puppeteer"   (legacy / non-Skill hosts)
+ *   transport.skill_id      = "agent-browser" (Claude Code / OpenCode)
+ *
+ * Transport selection lives in the WORKFLOW RUNNER layer — that's the
+ * site that knows whether the host CLI exposes the Skill tool. This
+ * driver exposes `chooseTransport({has_skill_tool})` as a helper so the
+ * workflow runner can ask the driver which transport it would pick;
+ * the driver records the chosen transport on each VerbResult via the
+ * optional `transport: 'skill' | 'mcp'` field (additive — existing
+ * consumers that ignore the field keep working).
+ *
+ * Per ID-01 — the workflow prose NEVER names mcp__puppeteer__* tools
+ * OR concrete `agent-browser` CLI subcommands. Both mappings live ONLY
+ * here in driver.mjs.
+ *
+ * IDL verb → MCP tool mapping (legacy transport):
+ *   navigate       → mcp__puppeteer__puppeteer_navigate
+ *   click          → mcp__puppeteer__puppeteer_click
+ *   type           → mcp__puppeteer__puppeteer_fill
+ *   screenshot     → mcp__puppeteer__puppeteer_screenshot
+ *   assert_visible → mcp__puppeteer__puppeteer_evaluate (DOM selector)
+ *   assert_text    → mcp__puppeteer__puppeteer_evaluate (textContent match)
+ *   wait_for_idle  → mcp__puppeteer__puppeteer_evaluate (networkidle check)
+ *   execute_js     → mcp__puppeteer__puppeteer_evaluate
+ *
+ * IDL verb → agent-browser CLI mapping (Skill transport):
+ *   navigate       → agent-browser open <url>
+ *   click          → agent-browser click @e<N>
+ *   type           → agent-browser fill @e<N> <text>
+ *   screenshot     → agent-browser screenshot
+ *   assert_visible → agent-browser snapshot + agent-browser get role <selector>
+ *   assert_text    → agent-browser snapshot + agent-browser get text <selector>
+ *   wait_for_idle  → agent-browser wait --load networkidle
+ *   execute_js     → agent-browser eval <script>
+ *
+ * The driver is a thin adapter: it validates input shape via the IDL
+ * arg-metadata, builds the transport-specific args, and returns a
+ * VerbResult. The actual transport dispatch happens at the workflow
+ * runner layer (which holds the model's tool surface — `Skill(...)` for
+ * skill transport, `mcp__puppeteer__*` for MCP transport). For
+ * conformance testing we expose the verb signatures as identity stubs
+ * returning VerbResult — the SDK conformance kit then validates the
+ * shape contract.
+ */
+
+import { validateVerbArgs } from '../../src/cli/verify-proof/idl/index.mjs'
+
+/**
+ * Pick a transport given the host environment's capabilities. When the
+ * host exposes the Skill tool (Claude Code, OpenCode), prefer the
+ * `agent-browser` skill — one fewer external dependency (no Puppeteer
+ * MCP server install). Otherwise fall back to the MCP transport.
+ *
+ * @param {{has_skill_tool: boolean}} env
+ * @returns {('skill'|'mcp')}
+ */
+export function chooseTransport(env) {
+	if (env && env.has_skill_tool === true) return 'skill'
+	return 'mcp'
+}
+
+/** Build a VerbResult given the actual transport-layer result. */
+function ok(evidence_paths = [], transport) {
+	const result = { status: 'success', evidence_paths, duration_ms: 0, retry_count: 0 }
+	if (transport) result.transport = transport
+	return result
+}
+function fail(error, transport) {
+	const result = { status: 'fail', evidence_paths: [], duration_ms: 0, retry_count: 0, error }
+	if (transport) result.transport = transport
+	return result
+}
+
+/**
+ * Validate args + return a VerbResult shape stub. Real transport
+ * invocation happens at the workflow-runner layer (model holds the tool
+ * surface — `Skill({skill: "agent-browser", args})` OR
+ * `mcp__puppeteer__*` depending on host capabilities).
+ *
+ * @param {string} verb
+ * @param {Record<string, unknown>} args
+ * @param {('skill'|'mcp')} [transport] — optional, recorded on the result for audit
+ * @returns {{status: 'success'|'fail'|'skip', evidence_paths: string[], duration_ms: number, retry_count: number, error?: string, transport?: 'skill'|'mcp'}}
+ */
+function adaptVerb(verb, args, transport) {
+	const check = validateVerbArgs(verb, args)
+	if (!check.valid) {
+		return fail(`browser.${verb}: missing required args: ${check.missing.join(', ')}`, transport)
+	}
+	// Identity stub for the conformance test surface. Production execution
+	// dispatches to Skill({skill: "agent-browser", ...}) OR mcp__puppeteer__*
+	// at the workflow-runner layer.
+	if (verb === 'screenshot' && typeof args.output_path === 'string') {
+		return ok([args.output_path], transport)
+	}
+	return ok([], transport)
+}
+
+export async function navigate(args) {
+	return adaptVerb('navigate', args)
+}
+
+export async function click(args) {
+	return adaptVerb('click', args)
+}
+
+export async function type(args) {
+	return adaptVerb('type', args)
+}
+
+export async function screenshot(args) {
+	return adaptVerb('screenshot', args)
+}
+
+export async function assert_visible(args) {
+	return adaptVerb('assert_visible', args)
+}
+
+export async function assert_text(args) {
+	return adaptVerb('assert_text', args)
+}
+
+export async function wait_for_idle(args) {
+	return adaptVerb('wait_for_idle', args)
+}
+
+export async function execute_js(args) {
+	return adaptVerb('execute_js', args)
+}

package/drivers/browser/manifest.json

@@ -0,0 +1,35 @@
+{
+	"driverId": "browser",
+	"version": "0.1.0",
+	"targets": ["browser@chrome", "browser@firefox", "browser@webkit"],
+	"capabilities": [
+		"navigate",
+		"click",
+		"type",
+		"screenshot",
+		"assert_visible",
+		"assert_text",
+		"wait_for_idle",
+		"execute_js"
+	],
+	"evidence_capabilities": ["screenshot", "dom_dump", "capture_logs"],
+	"frameworkApiRange": "^1.0.0",
+	"priority": 100,
+	"stability": "ga",
+	"trust": {
+		"tier": "first_party_signed",
+		"publisher": {
+			"name": "Aperant",
+			"npm_scope": "@aperant",
+			"github_org": "Mikalsen-AI",
+			"verified": true
+		}
+	},
+	"security": {
+		"sandbox_profile": "workspace_write",
+		"network": "allowlist",
+		"requires_user_approval": false
+	},
+	"audit": { "log_invocations": true, "log_manifest_hash": true },
+	"transport": { "mcp_server_id": "puppeteer", "skill_id": "agent-browser" }
+}

package/drivers/cli/README.md

@@ -0,0 +1,44 @@
+# CLI Driver
+
+Bundled headless verify-proof driver for CI / non-GUI environments.
+Doesn't open a browser, doesn't render anything — asserts on command
+output, captured logs, and runtime state.
+
+## When Aperant picks this driver
+
+`/apt:verify-proof` auto-selects `cli` when:
+
+- The project has no GUI runtime (no Electron, no Tauri, no web frontend).
+- The required IDL capabilities are: `execute_js`, `capture_logs`,
+  `assert_output`, `assert_text`, `dump_state`.
+- Used as a fallback for CI runs where the higher-priority browser /
+  electron drivers can't be reached.
+
+## Capabilities
+
+| IDL verb | Behavior |
+|----------|----------|
+| `execute_js` | Run a Node snippet via `execFile('node', ['-e', script])` |
+| `capture_logs` | Append stdout/stderr to an evidence file |
+| `assert_output` | Match a pattern against captured stdout/stderr |
+| `assert_text` | Match a pattern against a captured text artifact |
+| `dump_state` | Write a JSON dump of runner CWD + env keys |
+
+## Manifest
+
+- **Priority:** 60 (below browser=100 / electron=90 / api=50).
+- **Stability:** `ga`.
+- **Trust:** `first_party_signed`.
+- **Network posture:** `deny`.
+- **Transport:** `{ builtin: true }` — the driver IS the transport.
+- **Security:** `allow_shell: false`. The driver routes every spawn
+  through `execFile` (no shell, no pipes, no redirects) per ID-03.
+
+## V1 scope — adapter is thin
+
+Like the other bundled drivers, `driver.mjs` is a v1 manifest-conformant
+adapter shim: each verb validates its args via `IDL_VERB_ARGS` and
+returns a VerbResult stub. Actual Node-side execution lands in
+`verify-proof-driver-transport-wiring-v2` (follow-up). The CLI driver
+is the most natural candidate for first direct-dispatch since
+`{ builtin: true }` already means "driver process owns the transport."

package/drivers/cli/driver.mjs

@@ -0,0 +1,62 @@
+/**
+ * cli/driver.mjs — bundled headless CLI driver.
+ *
+ * Targets non-GUI CI verify-proof runs. Asserts on command stdout / stderr
+ * and on captured log streams. The transport is `{ builtin: true }` — the
+ * driver itself shells out via packages/framework/src/cli/verify-proof/exec.mjs
+ * (execFile, no shell) for the rare cases it needs to spawn a tool.
+ *
+ * Capabilities (5, the AC8 minimum):
+ *   - execute_js — run a Node snippet via execFile('node', ['-e', script])
+ *   - capture_logs — append stdout/stderr to an evidence file
+ *   - assert_output — match an expected pattern against stdout/stderr
+ *   - assert_text — match against a captured text artifact
+ *   - dump_state — write a JSON describing the runner's CWD + env keys
+ *
+ * Per ID-03 — `transport: { builtin: true }` means the driver IS the
+ * transport; it never shells out to free-form strings. Any `execute_js`
+ * invocation routes through exec.mjs which uses execFile (no shell).
+ */
+
+import { validateVerbArgs } from '../../src/cli/verify-proof/idl/index.mjs'
+
+function ok(evidence_paths = []) {
+	return { status: 'success', evidence_paths, duration_ms: 0, retry_count: 0 }
+}
+function fail(error) {
+	return { status: 'fail', evidence_paths: [], duration_ms: 0, retry_count: 0, error }
+}
+
+function adaptVerb(verb, args) {
+	const check = validateVerbArgs(verb, args)
+	if (!check.valid) {
+		return fail(`cli.${verb}: missing required args: ${check.missing.join(', ')}`)
+	}
+	if (verb === 'capture_logs' && typeof args.output_path === 'string') {
+		return ok([args.output_path])
+	}
+	if (verb === 'dump_state' && typeof args.output_path === 'string') {
+		return ok([args.output_path])
+	}
+	return ok()
+}
+
+export async function execute_js(args) {
+	return adaptVerb('execute_js', args)
+}
+
+export async function capture_logs(args) {
+	return adaptVerb('capture_logs', args)
+}
+
+export async function assert_output(args) {
+	return adaptVerb('assert_output', args)
+}
+
+export async function assert_text(args) {
+	return adaptVerb('assert_text', args)
+}
+
+export async function dump_state(args) {
+	return adaptVerb('dump_state', args)
+}

package/drivers/cli/manifest.json

@@ -0,0 +1,28 @@
+{
+	"driverId": "cli",
+	"version": "0.1.0",
+	"targets": ["cli", "node"],
+	"capabilities": ["execute_js", "capture_logs", "assert_output", "assert_text", "dump_state"],
+	"evidence_capabilities": ["capture_logs", "dump_state"],
+	"frameworkApiRange": "^1.0.0",
+	"priority": 60,
+	"stability": "ga",
+	"trust": {
+		"tier": "first_party_signed",
+		"publisher": {
+			"name": "Aperant",
+			"npm_scope": "@aperant",
+			"github_org": "Mikalsen-AI",
+			"verified": true
+		}
+	},
+	"security": {
+		"sandbox_profile": "workspace_write",
+		"network": "deny",
+		"allowed_executables": ["node", "sh", "bash"],
+		"allow_shell": false,
+		"requires_user_approval": false
+	},
+	"audit": { "log_invocations": true, "log_manifest_hash": true },
+	"transport": { "builtin": true }
+}

package/drivers/electron/README.md

@@ -0,0 +1,64 @@
+# Electron Driver
+
+Bundled, first-party verify-proof driver for Electron-based desktop
+applications. This driver is the one Aperant itself uses internally
+(this monorepo is an Electron app).
+
+## When Aperant picks this driver
+
+`/apt:verify-proof` auto-selects `electron` when:
+
+- The project's `package.json` declares `electron` (or `@electron/*`) as
+  a dependency.
+- The required IDL capabilities are a subset of: `click`, `type`, `key`,
+  `navigate`, `screenshot`, `assert_visible`, `assert_text`,
+  `wait_for_idle`, `execute_js`, `dump_state`.
+
+## Capabilities
+
+| IDL verb | Maps to Electron MCP tool |
+|----------|---------------------------|
+| `click` | `mcp__electron__send_command_to_electron` (button_click) |
+| `type` | `mcp__electron__send_command_to_electron` (fill_input) |
+| `key` | `mcp__electron__send_command_to_electron` (send_keyboard_shortcut) |
+| `navigate` | `mcp__electron__send_command_to_electron` (navigate) |
+| `screenshot` | `mcp__electron__take_screenshot` |
+| `assert_visible` | `mcp__electron__send_command_to_electron` (selector check) |
+| `assert_text` | `mcp__electron__send_command_to_electron` (textContent match) |
+| `wait_for_idle` | `mcp__electron__send_command_to_electron` (renderer-idle) |
+| `execute_js` | `mcp__electron__send_command_to_electron` (evaluate) |
+| `dump_state` | `mcp__electron__get_electron_window_info` |
+
+## Manifest
+
+- **Priority:** 90 (second-highest among bundled drivers — Electron is
+  rarer than browser but covers the desktop-app case).
+- **Stability:** `ga`.
+- **Trust:** `first_party_signed` (default-allow).
+- **Network posture:** `deny` (Electron apps shouldn't be hitting the
+  network during proof verification).
+- **Transport:** `{ mcp_server_id: "electron" }`.
+
+## Why hardcoded MCP tool names live here
+
+Per [ID-01](../../docs/frameworks/spec-gaps.md): the verify-proof workflow
+prose refers ONLY to IDL verbs (`driver.click(target)`,
+`driver.screenshot(path)`). The mapping from a verb to a concrete
+`mcp__electron__*` tool name exists in exactly one place — this driver
+file. The grep guard in
+`packages/framework/src/__tests__/verify-proof-workflow-grep-guard.test.ts`
+asserts zero `mcp__electron__*` matches in
+`workflows/verify-proof.md`. Adding a Tauri driver requires zero edits
+to the workflow.
+
+## V1 scope — adapter is thin
+
+This driver's `driver.mjs` is a manifest-conformant **adapter shim** in
+v1: each verb validates its args against `IDL_VERB_ARGS` and returns a
+VerbResult stub. The actual `mcp__electron__*` tool invocations happen
+at the workflow-runner layer (the model holds the MCP tool surface,
+NOT the driver process). The verb→tool mapping table above is the
+contract the workflow runner consults; the driver itself is the
+validator + manifest + resolver-anchor in v1. See
+`verify-proof-driver-transport-wiring-v2` (follow-up) for direct-
+dispatch evolution.

package/drivers/electron/driver.mjs

@@ -0,0 +1,87 @@
+/**
+ * electron/driver.mjs — bundled Electron driver.
+ *
+ * Maps IDL verbs to the Electron MCP server's tool surface. The
+ * transport.mcp_server_id="electron" string in manifest.json names the
+ * MCP server config the resolver hands off to.
+ *
+ * Per ID-01 — the workflow prose NEVER names mcp__electron__* tools.
+ * That mapping lives ONLY here in driver.mjs.
+ *
+ * IDL verb → MCP tool mapping (one place, one purpose):
+ *   click          → mcp__electron__send_command_to_electron (button_click)
+ *   type           → mcp__electron__send_command_to_electron (fill_input)
+ *   key            → mcp__electron__send_command_to_electron (send_keyboard_shortcut)
+ *   navigate       → mcp__electron__send_command_to_electron (navigate)
+ *   screenshot     → mcp__electron__take_screenshot
+ *   assert_visible → mcp__electron__send_command_to_electron (selector check)
+ *   assert_text    → mcp__electron__send_command_to_electron (textContent match)
+ *   wait_for_idle  → mcp__electron__send_command_to_electron (renderer-idle check)
+ *   execute_js     → mcp__electron__send_command_to_electron (evaluate)
+ *   dump_state     → mcp__electron__get_electron_window_info
+ *
+ * The driver is a thin adapter — same shape as browser/driver.mjs.
+ */
+
+import { validateVerbArgs } from '../../src/cli/verify-proof/idl/index.mjs'
+
+function ok(evidence_paths = []) {
+	return { status: 'success', evidence_paths, duration_ms: 0, retry_count: 0 }
+}
+function fail(error) {
+	return { status: 'fail', evidence_paths: [], duration_ms: 0, retry_count: 0, error }
+}
+
+function adaptVerb(verb, args) {
+	const check = validateVerbArgs(verb, args)
+	if (!check.valid) {
+		return fail(`electron.${verb}: missing required args: ${check.missing.join(', ')}`)
+	}
+	if (verb === 'screenshot' && typeof args.output_path === 'string') {
+		return ok([args.output_path])
+	}
+	if (verb === 'dump_state' && typeof args.output_path === 'string') {
+		return ok([args.output_path])
+	}
+	return ok()
+}
+
+export async function click(args) {
+	return adaptVerb('click', args)
+}
+
+export async function type(args) {
+	return adaptVerb('type', args)
+}
+
+export async function key(args) {
+	return adaptVerb('key', args)
+}
+
+export async function navigate(args) {
+	return adaptVerb('navigate', args)
+}
+
+export async function screenshot(args) {
+	return adaptVerb('screenshot', args)
+}
+
+export async function assert_visible(args) {
+	return adaptVerb('assert_visible', args)
+}
+
+export async function assert_text(args) {
+	return adaptVerb('assert_text', args)
+}
+
+export async function wait_for_idle(args) {
+	return adaptVerb('wait_for_idle', args)
+}
+
+export async function execute_js(args) {
+	return adaptVerb('execute_js', args)
+}
+
+export async function dump_state(args) {
+	return adaptVerb('dump_state', args)
+}

package/drivers/electron/manifest.json

@@ -0,0 +1,37 @@
+{
+	"driverId": "electron",
+	"version": "0.1.0",
+	"targets": ["electron@>=25"],
+	"capabilities": [
+		"click",
+		"type",
+		"key",
+		"navigate",
+		"screenshot",
+		"assert_visible",
+		"assert_text",
+		"wait_for_idle",
+		"execute_js",
+		"dump_state"
+	],
+	"evidence_capabilities": ["screenshot", "dom_dump", "capture_logs"],
+	"frameworkApiRange": "^1.0.0",
+	"priority": 90,
+	"stability": "ga",
+	"trust": {
+		"tier": "first_party_signed",
+		"publisher": {
+			"name": "Aperant",
+			"npm_scope": "@aperant",
+			"github_org": "Mikalsen-AI",
+			"verified": true
+		}
+	},
+	"security": {
+		"sandbox_profile": "workspace_write",
+		"network": "deny",
+		"requires_user_approval": false
+	},
+	"audit": { "log_invocations": true, "log_manifest_hash": true },
+	"transport": { "mcp_server_id": "electron" }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aperant/framework",
-  "version": "0.8.4",
+  "version": "0.8.7",
   "description": "AI coding framework — composable skills for planning, executing, verifying, and reviewing code with any LLM provider. Works as Claude Code commands, Codex tasks, or programmatically.",
   "author": "Mikalsen AI <hello@mikalsen.ai>",
   "type": "module",
@@ -36,6 +36,10 @@
       "types": "./dist/standalone/index.d.ts",
       "import": "./dist/standalone/index.js"
     },
+    "./driver-sdk": {
+      "types": "./dist/driver-sdk/index.d.ts",
+      "import": "./dist/driver-sdk/index.js"
+    },
     "./coordination/event-schema": {
       "types": "./src/cli/coordination/event-schema.d.ts",
       "import": "./src/cli/coordination/event-schema.mjs"
@@ -66,6 +70,7 @@
     "templates/",
     "context/",
     "workflows/",
+    "drivers/",
     "examples/",
     "LICENSE",
     "README.md",
@@ -104,8 +109,7 @@
     "@clack/prompts": "^1.2.0",
     "proper-lockfile": "^4.1.2",
     "yaml": "^2.8.3",
-    "zod": "^4.3.6",
-    "@aperant/driver-sdk": "0.1.0"
+    "zod": "^4.3.6"
   },
   "optionalDependencies": {
     "@babel/parser": "^7.29.2",