@ory/goose 0.10.0

package/README.md

@@ -0,0 +1,115 @@
+# Ory Agent Plugin: Goose
+
+[Ory](https://ory.com) bundled into [Goose](https://github.com/block/goose) (Block's open-source coding agent): skills and slash commands that scaffold Ory authentication into your codebase, a local Ory stack you can spin up in one command, and (when pointed at an Ory project) authentication, authorization, and audit for every tool Goose runs.
+
+You don't need an Ory account or any prior Ory experience to start.
+
+This integration is verified against the `goose` binary (v1.39.0). The plugin-directory layout, the `hooks.json` schema, and the discovery paths all match the binary's shell-hook plugin contract (see [block/goose#9304](https://github.com/block/goose/pull/9304)).
+
+## New to Ory?
+
+[Ory](https://www.ory.com/docs/) is an open-source identity and access platform — login, registration, sessions, social sign-in, multi-factor auth, and fine-grained permissions, so you don't have to build any of that yourself. Two things make it easy to try with no prior experience:
+
+- **Ory Elements** are prebuilt, themeable UI components for the auth pages. The scaffolding skills wire them into your app for you.
+- **The local Ory stack** is a complete Ory running on your laptop in Docker — no account, no signup, no API key.
+
+## What this plugin does
+
+Two independent things, and you can use either on its own:
+
+1. **Build auth into your app.** Have Goose scaffold Ory login, registration, social sign-in, and permissions into the project you're working on, backed by the local stack. This needs nothing but Docker.
+2. **Govern the agent itself.** Authenticate Goose's own session and authorize every tool it runs against Ory Permissions, with a full audit trail. See [Agent security](#agent-security).
+
+## Prerequisites
+
+- [Goose](https://github.com/block/goose) installed
+- Node.js **≥ 22**
+- [Docker](https://docs.docker.com/get-docker/) (only needed for the local Ory stack)
+- macOS or Linux. Windows works via WSL2.
+
+## Install
+
+```bash
+npx -y -p @ory/goose ory-goose install
+```
+
+This is the simplest install of any harness in this repo: it drops a self-contained plugin tree at `<project>/.agents/plugins/ory/` (or `~/.agents/plugins/ory/` with `--global`) — a `plugin.json` manifest plus `hooks/hooks.json` and the Ory skills. **No config mutation, no MCP registration, no `goose configure` step.** Goose auto-discovers the plugin directory at startup.
+
+```bash
+npx -y -p @ory/goose ory-goose install --global   # install for all projects
+npx -y -p @ory/goose ory-goose status              # confirm what landed
+npx -y -p @ory/goose ory-goose uninstall           # remove the ory plugin dir
+```
+
+`status` prints configuration, user and agent identity, per-tool permission coverage, plugin registration (project + global), and a tail of recent debug logs.
+
+## Quickstart (≈ 3 minutes)
+
+From any project where you'd like Ory authentication, inside Goose:
+
+1. **Start a local Ory instance.** Ask Goose *"start the local Ory stack"* or run `/local-up`. A banner prints the seeded test user's email and password — note them.
+2. **Scaffold Ory into your project.** Ask Goose *"add Ory auth to this app"* (the `ory-auth-setup` skill). It installs Ory Elements, wires the SDK, and generates the login / registration / recovery / settings pages, all targeting the local stack.
+3. **Sign in.** Start your app, visit the login page, and sign in with the seeded credentials. You now have a real Ory session backed by a real Ory stack — locally, offline, zero configuration.
+
+Continue to [Agent security](#agent-security) when you're ready to enforce.
+
+## How the integration works
+
+Goose discovers external **shell-hook plugins** by directory and invokes the hook binary as a subprocess for each lifecycle event (Claude-Code-style: event payload as JSON on stdin, decision on stdout). A hook blocks a tool call by returning `{"action":"block","message":"…"}` (the `RawHookAction` shape); the plugin also exits with code 2 as a defensive secondary block signal.
+
+The `hooks.json` maps these phases to the Ory hook:
+
+- **SessionStart** — run the user and agent auth gates.
+- **PreToolUse** — the only blocking event; check the tool against Ory Permissions, deny blocks in enforce mode.
+- **PostToolUse / BeforeReadFile / AfterFileEdit / BeforeShellExecution / Stop / SessionEnd** — trace-only audit spans.
+
+The plugin is **fail-open** on its own infrastructure failures (network errors, rate limits, missing config): the agent always starts, and enforcement is only as strong as your permission grants.
+
+## Agent security
+
+Once pointed at an Ory project (local or hosted), Goose's session and every tool call can be governed by Ory.
+
+- **Authentication.** The human at the keyboard (the **user**) authenticates interactively via Ory Identities when user login is on (`ORY_USER_LOGIN=true`, off by default — browser PKCE flow on first session, persisted thereafter). The Goose process (the **agent**) gets its own OAuth2 identity via [Dynamic Client Registration (RFC 7591)](https://datatracker.ietf.org/doc/html/rfc7591) on first run.
+- **Authorization.** Before any tool runs, the plugin checks [Ory Permissions](https://www.ory.com/docs/keto) (Zanzibar-style relations) against the user's subject and blocks on `deny`.
+- **Audit.** Every decision is recorded as a structured trace span (NDJSON file and/or OTLP export).
+
+### Permission modes: observe → enforce
+
+After install the plugin runs in **observe mode**: every tool call is checked, but a deny is recorded as a `permission.observe_deny` audit span and the tool runs anyway.
+
+```bash
+# Grant the current user `use` on every built-in tool (idempotent):
+npx -y -p @ory/goose ory-goose permissions bootstrap
+
+# See allowed/denied per tool:
+npx -y -p @ory/goose ory-goose permissions status
+
+# Turn on hard blocking once the observe-mode logs look right:
+npx -y -p @ory/goose ory-goose permissions enforce
+```
+
+Switch back any time with `permissions observe`. To disable Ory entirely (audit logging only), run `ory-goose configure --audit-only`.
+
+## Pointing at a real Ory project
+
+The Quickstart uses the local stack. To point at a hosted [Ory Network](https://console.ory.sh) project:
+
+```bash
+npx -y -p @ory/goose ory-goose configure \
+  --project-url https://<id>.projects.oryapis.com \
+  --oauth2-client-id <public OAuth2 client id>
+```
+
+`--oauth2-client-id` is required whenever `--project-url` is set — the user PKCE flow needs a public OAuth2 client registered with the four loopback redirect URIs (`http://127.0.0.1:47823..47826/callback`). See the [repo README](../../README.md) and [`AGENTS.md`](../../AGENTS.md) for the full environment-variable reference and permission-mode semantics. Config is shared across every Ory agent plugin at `~/.config/ory-agent-plugins/config.json`.
+
+Without configuration the plugin still loads cleanly and runs in **pass-through mode**: skills and commands work, but nothing is blocked.
+
+## Links
+
+- [Ory documentation](https://www.ory.com/docs/)
+- [Goose repository](https://github.com/block/goose)
+- [Repo README](../../README.md) and [AGENTS.md](../../AGENTS.md) — full env-var and permission-mode reference
+
+## License
+
+Apache-2.0

package/dist/cli/assets.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Materialize / clean the Ory skill catalog and command-skills for the
+ * Goose plugin. The guide skills plus the local-stack commands (rendered as
+ * user-invocable skills, since Goose has no native slash-command system) land
+ * under the plugin tree at `<plugin>/skills/<name>/SKILL.md`.
+ *
+ * Goose has no native slash-command system, so we follow the Codex / OpenClaw
+ * model: wrap each command with `commandToSkill` and write it alongside the
+ * guide skills (see AGENTS.md Step 7.5).
+ */
+/** Skills directory under a Goose plugin root (e.g. `.agents/plugins/ory`). */
+export declare function skillsDir(pluginRoot: string): string;
+/**
+ * Render all Ory guide skills plus the local-stack command-skills into the
+ * plugin's `skills/` directory. Wipe-and-rewrite so renames or removals in the
+ * shared templates take effect.
+ */
+export declare function installGooseOryAssets(pluginRoot: string): void;
+/** Remove every skill + command-skill this plugin installed under `pluginRoot`. */
+export declare function uninstallGooseOryAssets(pluginRoot: string): void;

package/dist/cli/assets.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * Materialize / clean the Ory skill catalog and command-skills for the
+ * Goose plugin. The guide skills plus the local-stack commands (rendered as
+ * user-invocable skills, since Goose has no native slash-command system) land
+ * under the plugin tree at `<plugin>/skills/<name>/SKILL.md`.
+ *
+ * Goose has no native slash-command system, so we follow the Codex / OpenClaw
+ * model: wrap each command with `commandToSkill` and write it alongside the
+ * guide skills (see AGENTS.md Step 7.5).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skillsDir = skillsDir;
+exports.installGooseOryAssets = installGooseOryAssets;
+exports.uninstallGooseOryAssets = uninstallGooseOryAssets;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const argus_1 = require("@ory/argus");
+const RENDER_OPTS = {
+    binName: "ory-goose",
+    packageName: "@ory/goose",
+};
+/** Skills directory under a Goose plugin root (e.g. `.agents/plugins/ory`). */
+function skillsDir(pluginRoot) {
+    return path.join(pluginRoot, "skills");
+}
+/**
+ * Render all Ory guide skills plus the local-stack command-skills into the
+ * plugin's `skills/` directory. Wipe-and-rewrite so renames or removals in the
+ * shared templates take effect.
+ */
+function installGooseOryAssets(pluginRoot) {
+    const dir = skillsDir(pluginRoot);
+    fs.rmSync(dir, { recursive: true, force: true });
+    fs.mkdirSync(dir, { recursive: true });
+    const guideSkills = (0, argus_1.renderOrySkills)("goose", RENDER_OPTS);
+    const commandSkills = (0, argus_1.renderOryCommands)("goose", RENDER_OPTS).map(argus_1.commandToSkill);
+    (0, argus_1.writeSkillTree)(dir, [...guideSkills, ...commandSkills]);
+}
+function safeRmEmpty(dir) {
+    try {
+        if (fs.existsSync(dir) && fs.readdirSync(dir).length === 0) {
+            fs.rmdirSync(dir);
+        }
+    }
+    catch {
+        /* ignore — leave the dir if removal fails. */
+    }
+}
+/** Remove every skill + command-skill this plugin installed under `pluginRoot`. */
+function uninstallGooseOryAssets(pluginRoot) {
+    const dir = skillsDir(pluginRoot);
+    if (fs.existsSync(dir)) {
+        (0, argus_1.removeSkillDirs)(dir, [...argus_1.ORY_SKILL_NAMES, ...argus_1.ORY_COMMAND_SKILL_NAMES]);
+        safeRmEmpty(dir);
+    }
+}

package/dist/cli/main.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+/**
+ * Main CLI for @ory/goose.
+ *
+ * Usage:
+ *   npx ory-goose install [--global]        Install the Ory plugin for Goose
+ *   npx ory-goose uninstall [--global]      Remove the Ory plugin
+ *   npx ory-goose configure                 Set or view Ory credentials
+ *   npx ory-goose setup [--project-dir]     Write the plugin tree directly
+ *   npx ory-goose status                    Show plugin status
+ *
+ * Goose discovers external shell-hook plugins from `.agents/plugins/<name>/`
+ * (project-local) or `~/.agents/plugins/<name>/` (global). There is no native
+ * `goose` install command, so `install` simply materializes that tree.
+ */
+export {};

package/dist/cli/main.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Main CLI for @ory/goose.
+ *
+ * Usage:
+ *   npx ory-goose install [--global]        Install the Ory plugin for Goose
+ *   npx ory-goose uninstall [--global]      Remove the Ory plugin
+ *   npx ory-goose configure                 Set or view Ory credentials
+ *   npx ory-goose setup [--project-dir]     Write the plugin tree directly
+ *   npx ory-goose status                    Show plugin status
+ *
+ * Goose discovers external shell-hook plugins from `.agents/plugins/<name>/`
+ * (project-local) or `~/.agents/plugins/<name>/` (global). There is no native
+ * `goose` install command, so `install` simply materializes that tree.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const fs = __importStar(require("node:fs"));
+const argus_1 = require("@ory/argus");
+const setup_js_1 = require("./setup.js");
+const PLUGIN_NAME = "ory";
+function main() {
+    const [command, ...args] = process.argv.slice(2);
+    switch (command) {
+        case "install":
+            install(args);
+            postInstallPermissions("ory-goose", "goose").then(() => process.exit(0), (err) => {
+                console.error(err.message ?? err);
+                process.exit(1);
+            });
+            break;
+        case "uninstall":
+            uninstall(args);
+            break;
+        case "configure":
+            (0, argus_1.runConfigureCommand)("ory-goose", args);
+            break;
+        case "agent":
+            (0, argus_1.runAgentCommand)("ory-goose", args).then((code) => process.exit(code), (err) => {
+                console.error(err.message ?? err);
+                process.exit(1);
+            });
+            break;
+        case "permissions":
+            (0, argus_1.runPermissionsCommand)("ory-goose", "goose", args).then((code) => process.exit(code), (err) => {
+                console.error(err.message ?? err);
+                process.exit(1);
+            });
+            break;
+        case "setup":
+            (0, setup_js_1.runSetup)((0, argus_1.parseSetupArgs)({ supportsGlobal: true }));
+            break;
+        case "status":
+            status().then(() => process.exit(0), (err) => {
+                console.error(err.message ?? err);
+                process.exit(1);
+            });
+            break;
+        case "local":
+            (0, argus_1.runLocalCommand)("ory-goose", args).catch((err) => {
+                console.error(err.message ?? err);
+                process.exit(1);
+            });
+            break;
+        case "help":
+        case "--help":
+        case "-h":
+        case undefined:
+            help();
+            break;
+        default:
+            console.error(`Unknown command: ${command}`);
+            help();
+            process.exit(1);
+    }
+}
+function install(_args) {
+    console.log("Materializing the Ory plugin tree for Goose...");
+    (0, setup_js_1.runSetup)((0, argus_1.parseSetupArgs)({ supportsGlobal: true }));
+    (0, argus_1.printEnvHelp)("ory-goose");
+}
+function uninstall(_args) {
+    const setupArgs = (0, argus_1.parseSetupArgs)({ supportsGlobal: true });
+    (0, setup_js_1.runSetup)({ ...setupArgs, uninstall: true });
+}
+async function postInstallPermissions(binName, harness) {
+    const bootstrapped = await (0, argus_1.maybeAutoBootstrap)(binName, harness);
+    (0, argus_1.printPermissionsOnboardingHelp)(binName, harness, {
+        bootstrappedAutomatically: bootstrapped,
+    });
+}
+function pluginRoots() {
+    return {
+        project: path.join(process.cwd(), ".agents", "plugins", PLUGIN_NAME),
+        global: path.join(os.homedir(), ".agents", "plugins", PLUGIN_NAME),
+    };
+}
+async function status() {
+    await (0, argus_1.runStatusCommand)("ory-goose", "goose", {
+        title: "Goose",
+        printPluginSection: () => {
+            const roots = pluginRoots();
+            console.log("Plugin:");
+            for (const [label, root] of [
+                ["Project", roots.project],
+                ["Global", roots.global],
+            ]) {
+                const manifest = fs.existsSync(path.join(root, "plugin.json"));
+                const hooks = fs.existsSync(path.join(root, "hooks", "hooks.json"));
+                console.log(`  ${label}:    ${manifest && hooks ? `installed (${root})` : "not installed"}`);
+            }
+        },
+    });
+}
+function help() {
+    console.log(`
+ory-goose — Ory plugin for Goose
+
+Usage:
+  npx ory-goose <command> [options]
+
+Commands:
+  install [--global]     Install the Ory plugin (project-local, or --global)
+  uninstall [--global]   Remove the Ory plugin
+  configure              Set or view Ory project URL and API key
+  agent <cmd>            Manage the agent's OAuth2 (DCR) identity (status, unregister)
+  permissions <cmd>      Manage permission mode and tool permissions (status, bootstrap, observe, enforce)
+  setup [--project-dir]  Write the plugin tree directly (advanced)
+  status                 Show plugin status and configuration
+  local <cmd>            Manage local Ory dev environment (up, down, status, seed, ...)
+
+After installing, Goose auto-discovers the plugin and hooks into these
+lifecycle events:
+  SessionStart           Verify the user and agent identities via Ory
+  PreToolUse             Check tool permissions via Ory Permissions
+  PostToolUse            Audit log tool executions
+
+Examples:
+  npx ory-goose install            # Install into ./.agents/plugins/ory
+  npx ory-goose install --global   # Install into ~/.agents/plugins/ory
+  npx ory-goose status             # Check configuration
+  npx ory-goose uninstall          # Remove the plugin
+`);
+}
+main();

package/dist/cli/setup.d.ts

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+/**
+ * Setup CLI for the Ory Goose plugin.
+ *
+ * Goose auto-discovers external shell-hook plugins at startup from:
+ *   - `<project>/.agents/plugins/<name>/` (project-local)
+ *   - `~/.agents/plugins/<name>/`         (user-global, with --global)
+ *
+ * Each plugin dir holds a `plugin.json` manifest and `hooks/hooks.json`
+ * describing the hook commands. We render both fresh at install time so the
+ * version pin baked into the hook command always matches the installed
+ * package. No `goose configure`, config edit, or MCP registration is needed
+ * for the gate — discovery is purely directory-based.
+ *
+ * The plugin dir layout (plugin.json + hooks/hooks.json) and discovery paths
+ * are verified against goose v1.39.0.
+ *
+ * Usage:
+ *   npx ory-goose-setup                    # Install into <cwd>/.agents/plugins/ory
+ *   npx ory-goose-setup --global           # Install into ~/.agents/plugins/ory
+ *   npx ory-goose-setup --project-dir /repo
+ *   npx ory-goose-setup --print            # Print plugin.json + hooks.json to stdout
+ *   npx ory-goose-setup --uninstall        # Remove the ory plugin dir
+ */
+import { type SetupArgs } from "@ory/argus";
+export declare function runSetup(args: SetupArgs): void;

package/dist/cli/setup.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Setup CLI for the Ory Goose plugin.
+ *
+ * Goose auto-discovers external shell-hook plugins at startup from:
+ *   - `<project>/.agents/plugins/<name>/` (project-local)
+ *   - `~/.agents/plugins/<name>/`         (user-global, with --global)
+ *
+ * Each plugin dir holds a `plugin.json` manifest and `hooks/hooks.json`
+ * describing the hook commands. We render both fresh at install time so the
+ * version pin baked into the hook command always matches the installed
+ * package. No `goose configure`, config edit, or MCP registration is needed
+ * for the gate — discovery is purely directory-based.
+ *
+ * The plugin dir layout (plugin.json + hooks/hooks.json) and discovery paths
+ * are verified against goose v1.39.0.
+ *
+ * Usage:
+ *   npx ory-goose-setup                    # Install into <cwd>/.agents/plugins/ory
+ *   npx ory-goose-setup --global           # Install into ~/.agents/plugins/ory
+ *   npx ory-goose-setup --project-dir /repo
+ *   npx ory-goose-setup --print            # Print plugin.json + hooks.json to stdout
+ *   npx ory-goose-setup --uninstall        # Remove the ory plugin dir
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSetup = runSetup;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const argus_1 = require("@ory/argus");
+const assets_js_1 = require("./assets.js");
+const PACKAGE_NAME = "@ory/goose";
+const HOOK_BIN = "ory-goose-hook";
+const PLUGIN_NAME = "ory";
+/**
+ * Resolve the Goose plugin root: `~/.agents/plugins/ory` with --global, else
+ * `<projectDir>/.agents/plugins/ory`.
+ */
+function getPluginRoot(args) {
+    const base = args.global ? os.homedir() : args.projectDir;
+    return path.join(base, ".agents", "plugins", PLUGIN_NAME);
+}
+/**
+ * Read the plugin's own version from its package.json, walking up from
+ * dist/cli to the package root. Used to version-pin the npx invocation in
+ * hooks.json so installs keep running against the version they registered.
+ */
+function readPackageVersion() {
+    try {
+        const pkgPath = path.resolve(__dirname, "..", "..", "package.json");
+        const parsed = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        return parsed.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+/**
+ * Render plugin.json — Goose's plugin manifest. Names and describes the
+ * plugin so `goose` can list it.
+ */
+function renderManifest(version) {
+    return {
+        name: PLUGIN_NAME,
+        version,
+        description: "Ory authentication, authorization, and distributed tracing for Goose",
+    };
+}
+/**
+ * Render hooks/hooks.json. Each event maps to the version-pinned hook binary,
+ * resolved via npx so it needn't be on PATH after install. PreToolUse is the
+ * only event that can block; the rest are observability hooks.
+ *
+ * The hooks.json schema (per-event arrays of `{ type, command }`, optional
+ * regex `matcher`/`pattern`) is verified against goose v1.39.0.
+ */
+function renderHooks(version) {
+    const command = `npx -y -p ${PACKAGE_NAME}@${version} ${HOOK_BIN}`;
+    const entry = [{ type: "command", command }];
+    return {
+        hooks: {
+            SessionStart: entry,
+            SessionEnd: entry,
+            Stop: entry,
+            UserPromptSubmit: entry,
+            PreToolUse: entry,
+            PostToolUse: entry,
+            PostToolUseFailure: entry,
+            BeforeReadFile: entry,
+            AfterFileEdit: entry,
+            BeforeShellExecution: entry,
+            AfterShellExecution: entry,
+        },
+    };
+}
+function writePluginTree(pluginRoot, version) {
+    fs.mkdirSync(pluginRoot, { recursive: true });
+    fs.writeFileSync(path.join(pluginRoot, "plugin.json"), JSON.stringify(renderManifest(version), null, 2) + "\n");
+    const hooksDir = path.join(pluginRoot, "hooks");
+    fs.mkdirSync(hooksDir, { recursive: true });
+    fs.writeFileSync(path.join(hooksDir, "hooks.json"), JSON.stringify(renderHooks(version), null, 2) + "\n");
+    (0, assets_js_1.installGooseOryAssets)(pluginRoot);
+}
+function runSetup(args) {
+    const version = readPackageVersion();
+    if (args.print) {
+        console.log(JSON.stringify({
+            "plugin.json": renderManifest(version),
+            "hooks/hooks.json": renderHooks(version),
+        }, null, 2));
+        return;
+    }
+    const pluginRoot = getPluginRoot(args);
+    if (args.uninstall) {
+        if (!fs.existsSync(pluginRoot)) {
+            console.log("No Ory plugin found. Nothing to uninstall.");
+            return;
+        }
+        (0, assets_js_1.uninstallGooseOryAssets)(pluginRoot);
+        fs.rmSync(pluginRoot, { recursive: true, force: true });
+        console.log(`Removed Ory plugin from ${pluginRoot}`);
+        return;
+    }
+    writePluginTree(pluginRoot, version);
+    console.log(`Ory plugin installed to ${pluginRoot}`);
+    console.log(`  plugin.json + hooks/hooks.json + skills/ written.`);
+    (0, argus_1.printNextSteps)("Goose", "npx ory-goose-setup --uninstall");
+}
+function main() {
+    if (process.argv.includes("--help") || process.argv.includes("-h")) {
+        (0, argus_1.printSetupHelp)("ory-goose-setup", "Goose");
+        process.exit(0);
+    }
+    const args = (0, argus_1.parseSetupArgs)({ supportsGlobal: true });
+    runSetup(args);
+}
+if (require.main === module) {
+    main();
+}

package/dist/handlers.d.ts

@@ -0,0 +1,14 @@
+import { OryAgentClient, ensureUserAuthenticated, ensureAgentIdentity } from "@ory/argus";
+import type { GooseHookInput, GooseHookOutput } from "./types.js";
+export interface HandleHookEventDeps {
+    /** Test injection point for the user login flow. */
+    userLogin?: typeof ensureUserAuthenticated;
+    /** Test injection point for the agent identity gate. */
+    agentGate?: typeof ensureAgentIdentity;
+}
+/**
+ * Route a Goose hook event to the appropriate Ory integration.
+ *
+ * Event-name set verified against goose v1.39.0.
+ */
+export declare function handleHookEvent(input: GooseHookInput, client: OryAgentClient, deps?: HandleHookEventDeps): Promise<GooseHookOutput>;

package/dist/handlers.js

@@ -0,0 +1,338 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleHookEvent = handleHookEvent;
+const argus_1 = require("@ory/argus");
+/**
+ * Route a Goose hook event to the appropriate Ory integration.
+ *
+ * Event-name set verified against goose v1.39.0.
+ */
+async function handleHookEvent(input, client, deps = {}) {
+    const event = input.event;
+    client.logger.debug("hook.received", {
+        event,
+        sessionId: input.session_id,
+        toolName: input.tool_name,
+    });
+    // Set trace context so all spans within this hook invocation correlate.
+    client.tracer.setContext({
+        traceId: (0, argus_1.deriveTraceId)(input.session_id),
+        sessionId: input.session_id,
+    });
+    try {
+        switch (event) {
+            case "SessionStart":
+                return await handleSessionStart(input, client, deps);
+            case "SessionEnd":
+            case "Stop":
+                return await handleSessionEnd(input, client);
+            case "PreToolUse":
+                return await handlePreToolUse(input, client);
+            case "PostToolUse":
+            case "PostToolUseFailure":
+                return await handlePostToolUse(input, client);
+            case "UserPromptSubmit":
+                return await handleUserPromptSubmit(input, client);
+            case "BeforeReadFile":
+            case "AfterFileEdit":
+            case "BeforeShellExecution":
+            case "AfterShellExecution":
+                return await handleTraceOnly(input, client);
+            default:
+                client.logger.debug("hook.passthrough", { event });
+                client.tracer.record("hook.passthrough", "skipped", {
+                    attributes: { event },
+                });
+                return {};
+        }
+    }
+    finally {
+        client.tracer.clearContext();
+    }
+}
+// ─── SessionStart ───────────────────────────────────────────────────
+async function handleSessionStart(input, client, deps) {
+    client.logger.info("lifecycle.session_start", {
+        sessionId: input.session_id,
+        cwd: input.working_dir,
+    });
+    client.tracer.record("session.start", "ok", {});
+    const userGate = deps.userLogin ?? argus_1.ensureUserAuthenticated;
+    const decision = await userGate(client, {
+        binName: "ory-goose",
+        harness: "goose",
+        // Goose's PreToolUse carries exit code 2; SessionStart is a subprocess
+        // hook too, so a declined login can hard-block the session.
+        allowBlock: true,
+    });
+    // Resolve the agent identity (machine credentials). Never blocks;
+    // attaches the agent's bearer token to outgoing Ory API calls.
+    const agentGate = deps.agentGate ?? argus_1.ensureAgentIdentity;
+    await agentGate(client, { projectUrl: (0, argus_1.resolveConfig)().projectUrl, harness: "goose" });
+    // User → agent delegation tuple (best-effort, audit-trail only).
+    await recordUserDelegatesAgent(client);
+    if (!decision.proceed) {
+        return { action: "block", message: decision.reason };
+    }
+    if (decision.mode !== "disabled") {
+        return {};
+    }
+    const resolved = (0, argus_1.resolveConfig)();
+    if (resolved.auditOnly) {
+        client.logger.info("config.audit_only", {
+            message: "Audit-only mode enabled. Auth and permission checks are disabled.",
+        });
+        return {};
+    }
+    if (!resolved.projectUrl) {
+        client.logger.warn("config.not_configured", {
+            message: "Ory plugin is not configured. Auth and permission checks are disabled. " +
+                "Run 'npx ory-goose configure' to connect to an Ory project.",
+        });
+        return {};
+    }
+    // Legacy pre-supplied token verification (backward compat).
+    const sessionToken = process.env.ORY_SESSION_TOKEN;
+    const oauth2Token = process.env.ORY_OAUTH2_TOKEN;
+    if (sessionToken) {
+        await verifySessionToken(sessionToken, client);
+        return {};
+    }
+    if (oauth2Token) {
+        await verifyOAuth2Token(oauth2Token, client);
+        return {};
+    }
+    client.logger.warn("session.no_credentials", {
+        message: "Neither ORY_SESSION_TOKEN nor ORY_OAUTH2_TOKEN is set. " +
+            "Skipping authentication.",
+    });
+    return {};
+}
+async function verifySessionToken(token, client) {
+    try {
+        const session = await client.verifySession(token);
+        if (!session.active) {
+            client.logger.warn("session.inactive", {
+                message: "Ory session is not active. Re-authenticate to enable auth checks.",
+            });
+        }
+    }
+    catch (err) {
+        const oryErr = err;
+        client.logger.warn("session.verify_failed", {
+            code: oryErr.code,
+            message: oryErr.message,
+        });
+    }
+}
+async function verifyOAuth2Token(token, client) {
+    try {
+        const tokenInfo = await client.introspectToken(token);
+        if (!tokenInfo.active) {
+            client.logger.warn("oauth2.token_inactive", {
+                message: "Ory OAuth2 token is not active. Obtain a new token to enable auth checks.",
+            });
+            return;
+        }
+        client.logger.info("oauth2.session_authenticated", {
+            clientId: tokenInfo.clientId,
+            subject: tokenInfo.subject,
+            scope: tokenInfo.scope,
+        });
+    }
+    catch (err) {
+        const oryErr = err;
+        client.logger.warn("oauth2.introspect_failed", {
+            code: oryErr.code,
+            message: oryErr.message,
+        });
+    }
+}
+// ─── PreToolUse ────────────────────────────────────────────────────
+async function handlePreToolUse(input, client) {
+    const toolName = input.tool_name ?? "unknown";
+    client.logger.info("lifecycle.pre_tool_use", {
+        sessionId: input.session_id,
+        toolName,
+        toolInput: input.tool_input,
+    });
+    const inputSummary = (0, argus_1.summarizeToolInput)(toolName, input.tool_input);
+    // In audit-only mode, log the invocation but skip permission checks.
+    if ((0, argus_1.resolveConfig)().auditOnly) {
+        client.tracer.record("tool.invoke", "ok", {
+            attributes: { toolName, ...inputSummary },
+        });
+        return {};
+    }
+    const subject = (0, argus_1.resolveUserSubject)(client, `session:${input.session_id}`);
+    const subjectId = (0, argus_1.subjectLabel)(subject);
+    const namespace = resolveNamespace();
+    try {
+        const outcome = await (0, argus_1.gateToolCall)(client, {
+            harness: "goose",
+            toolName,
+            check: { namespace, object: toolName, relation: "use", ...subject },
+            spanAttributes: { toolName },
+        });
+        // Interactive tools (operator-extensible via ORY_INTERACTIVE_TOOLS):
+        // user.interaction span is already recorded; pass through.
+        if (outcome.kind === "interactive") {
+            return {};
+        }
+        const decision = outcome;
+        if (decision.kind === "fail_open") {
+            return handlePermissionError(decision.error, toolName, client);
+        }
+        const attrs = { toolName, ...inputSummary };
+        const decisionAttrs = decision.spanAttributes;
+        if (decision.kind === "allow") {
+            client.tracer.record("tool.invoke", "ok", {
+                attributes: { ...attrs, ...decisionAttrs, allowed: true },
+            });
+            return {};
+        }
+        if (decision.kind === "observe") {
+            client.tracer.record("tool.block", "denied", {
+                attributes: { ...attrs, ...decisionAttrs, allowed: false, ...(0, argus_1.alertAttributes)(false) },
+            });
+            client.tracer.record("tool.invoke", "ok", {
+                attributes: { ...attrs, ...decisionAttrs, allowed: false, observed: true },
+            });
+            return {};
+        }
+        client.tracer.record("tool.block", "denied", {
+            attributes: { ...attrs, ...decisionAttrs, allowed: false, ...(0, argus_1.alertAttributes)(true) },
+        });
+        return {
+            action: "block",
+            message: (0, argus_1.formatDenialMessage)({ tool: toolName, subjectId, namespace }),
+        };
+    }
+    catch (err) {
+        return handlePermissionError(err, toolName, client);
+    }
+}
+// ─── PostToolUse / PostToolUseFailure ──────────────────────────────
+async function handlePostToolUse(input, client) {
+    const toolName = input.tool_name ?? "unknown";
+    client.logger.info("lifecycle.post_tool_use", {
+        sessionId: input.session_id,
+        toolName,
+        error: input.error,
+    });
+    const status = input.event === "PostToolUseFailure" ? "error" : "ok";
+    client.tracer.record("tool.complete", status, {
+        attributes: {
+            toolName,
+            ...(0, argus_1.summarizeToolInput)(toolName, input.tool_input),
+            ...(0, argus_1.summarizeToolOutput)(toolName, input.tool_output),
+            ...(input.error ? { error: input.error } : {}),
+        },
+    });
+    return {};
+}
+// ─── SessionEnd / Stop ─────────────────────────────────────────────
+async function handleSessionEnd(input, client) {
+    client.logger.info("lifecycle.session_end", {
+        sessionId: input.session_id,
+        event: input.event,
+    });
+    client.tracer.record("session.end", "ok", {
+        attributes: { event: input.event },
+    });
+    return {};
+}
+// ─── UserPromptSubmit ──────────────────────────────────────────────
+//
+// User-facing phase. The human is the decision-maker; record an audit
+// span only and never block.
+async function handleUserPromptSubmit(input, client) {
+    client.logger.info("lifecycle.user_prompt_submit", {
+        sessionId: input.session_id,
+    });
+    client.tracer.record("user.prompt", "ok", {
+        attributes: { event: input.event },
+    });
+    return {};
+}
+// ─── Trace-only file / shell observation events ────────────────────
+//
+// BeforeReadFile, AfterFileEdit, BeforeShellExecution, AfterShellExecution
+// are fine-grained observability hooks. The PreToolUse gate already
+// authorizes the tool that drives them, so these are audit spans only.
+async function handleTraceOnly(input, client) {
+    client.logger.info("lifecycle.observe", {
+        sessionId: input.session_id,
+        event: input.event,
+        filePath: input.file_path,
+    });
+    client.tracer.record("notification", "ok", {
+        attributes: {
+            event: input.event,
+            ...(input.file_path ? { filePath: input.file_path } : {}),
+            ...(input.command ? { hasCommand: true } : {}),
+        },
+    });
+    return {};
+}
+// ─── Helpers ────────────────────────────────────────────────────────
+function resolveNamespace() {
+    return process.env.ORY_PERMISSION_NAMESPACE ?? "AgentTools";
+}
+/**
+ * Write the user→agent delegation tuple. Idempotent and fail-open:
+ * requires both principal subjects to be populated; any error (including
+ * unconfigured projectUrl, which manifests as a network_error) is logged
+ * and swallowed. The actual permission enforcement is unchanged — this
+ * tuple is purely audit-trail data.
+ */
+async function recordUserDelegatesAgent(client) {
+    const user = client.userPrincipal.subject;
+    const agent = client.agentPrincipal.subject;
+    if (!user || !agent) {
+        client.logger.debug("delegation.skip", {
+            reason: "missing principal",
+            hasUser: !!user,
+            hasAgent: !!agent,
+        });
+        return;
+    }
+    try {
+        await client.createRelationship({
+            namespace: resolveNamespace(),
+            object: `agent:${agent}`,
+            relation: "delegate",
+            subjectId: `user:${user}`,
+        }, { spanAttributes: { delegation: "user-to-agent" } });
+    }
+    catch (err) {
+        const oryErr = err;
+        client.logger.warn("delegation.user_to_agent.failed", {
+            code: oryErr.code,
+            message: oryErr.message,
+        });
+    }
+}
+function handlePermissionError(oryErr, toolName, client) {
+    if (oryErr.code === "network_error") {
+        client.logger.warn("permission.network_error", {
+            toolName,
+            message: "Ory unreachable, failing open",
+        });
+        return {};
+    }
+    if (oryErr.code === "rate_limited") {
+        client.logger.warn("permission.rate_limited", {
+            toolName,
+            message: "Ory rate limited, failing open",
+        });
+        return {};
+    }
+    // For other errors, also fail open but log prominently.
+    client.logger.error("permission.check.error", {
+        toolName,
+        code: oryErr.code,
+        message: oryErr.message,
+    });
+    return {};
+}

package/dist/hook.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * Goose hook entry point.
+ * This script is invoked by Goose for each hook event.
+ * Input: JSON on stdin
+ * Output: JSON on stdout (the `RawHookAction` shape — `{ action, message }`).
+ * A `{"action":"block"}` payload blocks the action (PreToolUse only); we also
+ * exit with code 2 as a defensive secondary block signal.
+ *
+ * Verified against goose v1.39.0.
+ */
+export {};

package/dist/hook.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Goose hook entry point.
+ * This script is invoked by Goose for each hook event.
+ * Input: JSON on stdin
+ * Output: JSON on stdout (the `RawHookAction` shape — `{ action, message }`).
+ * A `{"action":"block"}` payload blocks the action (PreToolUse only); we also
+ * exit with code 2 as a defensive secondary block signal.
+ *
+ * Verified against goose v1.39.0.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const argus_1 = require("@ory/argus");
+const handlers_js_1 = require("./handlers.js");
+/**
+ * Read all of stdin as a string.
+ *
+ * Uses event listeners instead of `for await` so that we don't depend on the
+ * parent process closing stdin (sending EOF). If no EOF arrives, we resolve
+ * after a short idle gap once data has been received.
+ */
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let resolved = false;
+        function done() {
+            if (!resolved) {
+                resolved = true;
+                resolve(Buffer.concat(chunks).toString("utf-8"));
+            }
+        }
+        process.stdin.on("data", (chunk) => {
+            chunks.push(chunk);
+            clearTimeout(idleTimer);
+            idleTimer = setTimeout(done, 100);
+        });
+        process.stdin.on("end", done);
+        process.stdin.on("error", (err) => {
+            if (!resolved) {
+                resolved = true;
+                reject(err);
+            }
+        });
+        let idleTimer;
+    });
+}
+async function main() {
+    const client = argus_1.OryAgentClient.fromEnv("goose");
+    const raw = await readStdin();
+    let input;
+    try {
+        input = JSON.parse(raw);
+    }
+    catch {
+        client.logger.error("hook.stdin.parse_failed", { raw: raw.slice(0, 200) });
+        await client.tracer.shutdown();
+        process.exit(0); // Don't block on parse errors
+    }
+    const output = await (0, handlers_js_1.handleHookEvent)(input, client);
+    if (output.action === "block") {
+        // Goose stops execution on the first explicit deny. The structured block
+        // signal is the `action` key; emit it on stdout and exit 2 as a defensive
+        // secondary signal — both indicate a hard deny.
+        process.stdout.write(JSON.stringify(output));
+        await client.tracer.shutdown();
+        process.exit(2);
+    }
+    await client.tracer.shutdown();
+    process.exit(0);
+}
+main().catch((err) => {
+    process.stderr.write(`[ory-agent] fatal: ${err}\n`);
+    process.exit(0); // Fail open
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { handleHookEvent } from "./handlers.js";
+export type { GooseHookInput, GooseHookOutput } from "./types.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleHookEvent = void 0;
+var handlers_js_1 = require("./handlers.js");
+Object.defineProperty(exports, "handleHookEvent", { enumerable: true, get: function () { return handlers_js_1.handleHookEvent; } });

package/dist/types.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Goose hook event payload delivered on stdin.
+ *
+ * Goose (Block's open-source agent CLI) invokes external shell hooks as
+ * child processes, passing JSON on stdin and reading JSON from stdout. For
+ * PreToolUse, a `{"action":"block"}` stdout payload blocks the action; any
+ * other action allows it (fail-open). Exit code 2 is honored as a defensive
+ * secondary block signal.
+ *
+ * Events: SessionStart, SessionEnd, Stop, UserPromptSubmit, PreToolUse,
+ * PostToolUse, PostToolUseFailure, BeforeReadFile, AfterFileEdit,
+ * BeforeShellExecution, AfterShellExecution.
+ *
+ * Verified against goose v1.39.0. Hooks landed via PR #9304.
+ */
+export interface GooseHookInput {
+    /** Lifecycle event name, e.g. "SessionStart" / "PreToolUse". */
+    event: string;
+    /** Stable identifier for the Goose session. */
+    session_id: string;
+    /** Optional matcher context supplied by the binary. Not consumed. */
+    matcher_context?: Record<string, unknown>;
+    /** Working directory of the session. */
+    working_dir?: string;
+    tool_name?: string;
+    tool_input?: Record<string, unknown>;
+    tool_output?: Record<string, unknown>;
+    /** Present on PostToolUseFailure. */
+    error?: string;
+    prompt?: string;
+    file_path?: string;
+    command?: string;
+}
+/**
+ * Goose hook output written to stdout (the `RawHookAction` shape).
+ *
+ * Only PreToolUse honors a block action. We emit `{ action: "block",
+ * message }` and pair it with exit code 2 as a defensive secondary block
+ * signal in the hook entry point.
+ *
+ * Verified against goose v1.39.0: the JSON key is `action` with values
+ * `allow` / `block` / `warn`, and the human-readable text field is `message`.
+ */
+export interface GooseHookOutput {
+    action?: "allow" | "block" | "warn";
+    message?: string;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@ory/goose",
+  "version": "0.10.0",
+  "description": "Ory plugin for Goose (Block's open-source agent CLI): scaffolding skills, a local Ory instance, and authentication, authorization, and audit for every tool call",
+  "license": "Apache-2.0",
+  "homepage": "https://ory.com",
+  "keywords": [
+    "ory",
+    "goose",
+    "goose-cli",
+    "block",
+    "hooks",
+    "plugin",
+    "identity",
+    "identity-management",
+    "iam",
+    "authentication",
+    "authorization",
+    "access-control",
+    "permissions",
+    "rbac",
+    "zanzibar",
+    "oauth",
+    "oauth2",
+    "openid-connect",
+    "oidc",
+    "session",
+    "mfa",
+    "sso",
+    "audit",
+    "audit-log",
+    "compliance",
+    "agent",
+    "ai-agent",
+    "agent-security",
+    "guardrails",
+    "llm",
+    "tracing",
+    "distributed-tracing",
+    "observability",
+    "kratos",
+    "keto",
+    "hydra"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/",
+    "provenance": true
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "ory-goose": "dist/cli/main.js",
+    "ory-goose-hook": "dist/hook.js",
+    "ory-goose-setup": "dist/cli/setup.js"
+  },
+  "files": [
+    "dist",
+    "!dist/dev",
+    "!dist/**/*.tsbuildinfo"
+  ],
+  "dependencies": {
+    "@ory/argus": "0.10.0"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.2",
+    "vitest": "4.1.4"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist *.tsbuildinfo",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "dev": "node dist/dev/launcher.js"
+  }
+}