@ory/claude-code 0.13.9 → 1.0.0

package/dist/cli/setup.js

@@ -3,11 +3,20 @@
 /**
  * Setup CLI for the Ory Claude Code plugin.
  *
- * Uses the `claude` CLI to manage plugin installation via the marketplace:
+ * Assembles the plugin locally and hands it to the `claude` CLI as a
+ * local-file marketplace:
  *   npx ory-claude-setup                  # Install plugin (project scope)
  *   npx ory-claude-setup --global         # Install plugin (user scope)
- *   npx ory-claude-setup --from-source    # Install from the local source tree (dev only)
+ *   npx ory-claude-setup --runtime-dir <d> # Wire a workspace build (dev only)
  *   npx ory-claude-setup --uninstall      # Remove plugin
+ *
+ * The plugin's runtime is resolved **once, here** — materialized into the
+ * shared runtime store (or linked to a workspace build) and wired through a
+ * stable shim, so no package resolution happens on the tool-call path. That is
+ * why the install always assembles: the generated `hooks.json` / `.mcp.json`
+ * carry this machine's shim paths, which a marketplace fetched from GitHub
+ * cannot. The public `ory/claude-plugins` mirror stays a valid install route
+ * on its own terms (it ships a bootstrap keyed off `${CLAUDE_PLUGIN_ROOT}`).
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -43,42 +52,28 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAssembledFromSource = isAssembledFromSource;
+exports.assemblePluginDir = assemblePluginDir;
+exports.isPluginAssembled = isPluginAssembled;
 exports.install = install;
+exports.printInstallPlan = printInstallPlan;
 exports.uninstall = uninstall;
 const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const argus_1 = require("@ory/argus");
 const PACKAGE_ROOT = path.resolve(__dirname, "..", "..");
+const PACKAGE_NAME = "@ory/claude-code";
+const HARNESS = "claude-code";
+const INSTALL_COMMAND = "npx -y -p @ory/claude-code ory-claude install";
 /**
- * Production marketplace published by the release workflow as the read-only
- * mirror of this monorepo's Claude Code plugin. The `name` field below is the
- * short identifier declared by that repo's top-level
- * `.claude-plugin/marketplace.json` — that's what the `claude` CLI registers
- * the marketplace under, and what `claude plugin install <plugin>@<name>`
- * dereferences. The plugin name matches the local `.claude-plugin/plugin.json`
- * because the sync script preserves it.
- *
- * Keep these in sync with whatever the production marketplace declares — if
- * the repo's marketplace.json `name` changes, update `PROD_MARKETPLACE_NAME`
- * here too.
- */
-const PROD_MARKETPLACE_REPO = "ory/claude-plugins";
-const PROD_MARKETPLACE_NAME = "ory";
-const PROD_PLUGIN_NAME = "ory-agent-plugin";
-/**
- * For `--from-source` installs, resolve the marketplace and plugin names from
- * the local `.claude-plugin/` JSON files instead of hardcoding them.
+ * Resolve the marketplace and plugin names from the `.claude-plugin/` JSON
+ * files shipped in the package, rather than hardcoding them here.
  *
  * Source of truth is `packages/claude-code/.claude-plugin/marketplace.json`
- * (marketplace name) and `.claude-plugin/plugin.json` (plugin name). The local
- * marketplace uses intentionally dev-flavored names — e.g.
- * `ory-plugins-local-development` — so a developer can see at a glance the
- * install came from this monorepo and not the production
- * `ory/claude-plugins` repo. The default install path (no `--from-source`)
- * bypasses these entirely and points the `claude` CLI at the production
- * GitHub marketplace.
+ * (marketplace name) and `.claude-plugin/plugin.json` (plugin name). The
+ * marketplace name is deliberately distinct from the one the public
+ * `ory/claude-plugins` mirror declares, so a user who has registered both
+ * sees two clearly-labelled sources instead of a silent collision.
  */
 function readLocalMarketplaceName() {
     const mfPath = path.join(PACKAGE_ROOT, ".claude-plugin", "marketplace.json");
@@ -101,101 +96,131 @@ const RENDER_OPTS = {
     packageName: "@ory/claude-code",
 };
 /**
- * Persistent install location used as the marketplace root for `--from-source`
- * installs. Lives under the shared OS-agnostic data dir so all plugin state —
- * config, DCR creds, harness assets — sits in one place per platform. The
- * production install path never touches this directory: the `claude` CLI
- * fetches everything directly from the GitHub marketplace.
- */
-const PERSISTENT_DIR = (0, argus_1.getHarnessDataDir)("claude-code");
-/** Hook command that resolves the binary via the npm registry. */
-const HOOK_CMD_REMOTE = "npx -y -p @ory/claude-code ory-claude-hook";
-/**
- * Detect if we're running from a temporary npx/pnpm-dlx cache directory
- * rather than a proper local or global npm installation. Only consulted on
- * the `--from-source` path to pick the right hook command.
+ * Persistent install location: the marketplace root the `claude` CLI is
+ * pointed at. Lives under the shared OS-agnostic data dir so all plugin state
+ * — config, DCR creds, harness assets — sits in one place per platform.
+ *
+ * Resolved on each call rather than captured at module load: `getHarnessDataDir`
+ * reads `XDG_CONFIG_HOME`, so a module-level constant would freeze whatever the
+ * env said at import time — which silently defeats test isolation (and any
+ * caller that sets the var itself).
  */
-function isRemoteContext() {
-    const normalized = PACKAGE_ROOT.replace(/\\/g, "/");
-    return normalized.includes("/_npx/") || normalized.includes("/dlx-");
-}
-/** Hook command for a local/global install — runs the built hook directly. */
-function localHookCommand() {
-    return `node "${path.join(PACKAGE_ROOT, "dist", "hook.js")}"`;
+function persistentDir() {
+    return (0, argus_1.getHarnessDataDir)(HARNESS);
 }
 /**
  * Assemble the Claude Code plugin directory in the persistent location and
- * return its path (used as the marketplace root for `--from-source`).
+ * return its path (the marketplace root).
  *
- * The plugin manifest (`.claude-plugin/`) and MCP config (`.mcp.json`) are
- * copied from the package; the skills, commands, and hooks are generated:
- * skills/commands are materialized from the shared `@ory/argus` templates (the
- * single source of truth across every harness), and `hooks.json` is written
- * with a hook command appropriate for the install context.
+ * The plugin manifest (`.claude-plugin/`) is copied from the package; the
+ * skills, commands, hooks, and MCP config are generated: skills/commands come
+ * from the shared `@ory/argus` templates (the single source of truth across
+ * every harness), and `hooks.json` / `.mcp.json` are written with the shim
+ * paths this machine's runtime resolved to.
  */
-function assemblePluginDir(hookCommand) {
-    fs.mkdirSync(PERSISTENT_DIR, { recursive: true });
-    // Static manifests copied straight from the package.
-    for (const asset of [".claude-plugin", ".mcp.json"]) {
-        const src = path.join(PACKAGE_ROOT, asset);
+function assemblePluginDir(runtime) {
+    fs.mkdirSync(persistentDir(), { recursive: true });
+    // Static manifest copied straight from the package. `.mcp.json` is NOT
+    // copied — it is generated below from the resolved runtime, so the server
+    // starts from the materialized copy instead of being re-resolved by npx.
+    {
+        const src = path.join(PACKAGE_ROOT, ".claude-plugin");
         if (fs.existsSync(src)) {
-            fs.cpSync(src, path.join(PERSISTENT_DIR, asset), {
+            fs.cpSync(src, path.join(persistentDir(), ".claude-plugin"), {
                 recursive: true,
                 force: true,
             });
         }
     }
+    // Stamp the assembled plugin manifest with this package's version. The
+    // committed manifest carries a frozen placeholder version, and the `claude`
+    // CLI keys its cached component inventory (commands, skills) on the plugin
+    // version — so without this, a release that adds a command would keep the
+    // stale command set until the user manually removed the plugin. Tracking the
+    // package version means every release advertises a new plugin version and
+    // Claude Code refreshes.
+    const manifestPath = path.join(persistentDir(), ".claude-plugin", "plugin.json");
+    try {
+        const pkgVersion = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, "package.json"), "utf8")).version;
+        if (pkgVersion && fs.existsSync(manifestPath)) {
+            const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+            manifest.version = pkgVersion;
+            fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+        }
+    }
+    catch {
+        /* best-effort — a missing/unreadable manifest just keeps its default version */
+    }
     // Skills — materialized fresh from the shared core templates.
-    const skillsDir = path.join(PERSISTENT_DIR, "skills");
+    const skillsDir = path.join(persistentDir(), "skills");
     fs.rmSync(skillsDir, { recursive: true, force: true });
     (0, argus_1.writeSkillTree)(skillsDir, (0, argus_1.renderOrySkills)("claude-code", RENDER_OPTS));
     // Commands — plain markdown command files (Claude Code's `/ory:<name>`).
-    const commandsDir = path.join(PERSISTENT_DIR, "commands");
+    const commandsDir = path.join(persistentDir(), "commands");
     fs.rmSync(commandsDir, { recursive: true, force: true });
     fs.mkdirSync(commandsDir, { recursive: true });
     for (const cmd of (0, argus_1.renderOryCommands)("claude-code", RENDER_OPTS)) {
         fs.writeFileSync(path.join(commandsDir, `${cmd.slug}.md`), (0, argus_1.commandToPlainMarkdown)(cmd));
     }
-    // Hooks — generated with a command appropriate for the install context.
-    const hooksDir = path.join(PERSISTENT_DIR, "hooks");
+    // MCP server — points at the shim, so the server starts from the resolved
+    // runtime. Omitted entirely when this runtime ships no MCP server, rather
+    // than writing a registration that would fail to start.
+    const mcpPath = path.join(persistentDir(), ".mcp.json");
+    if (runtime.mcpServer) {
+        fs.writeFileSync(mcpPath, JSON.stringify({
+            description: "Ory Claude Code MCP Server",
+            mcpServers: { "ory-claude-mcp": runtime.mcpServer },
+        }, null, 2) + "\n");
+    }
+    else {
+        fs.rmSync(mcpPath, { force: true });
+    }
+    // Hooks — every event routed through the stable runtime shim.
+    const hooksDir = path.join(persistentDir(), "hooks");
     fs.mkdirSync(hooksDir, { recursive: true });
-    const entry = [
-        { matcher: "", hooks: [{ type: "command", command: hookCommand }] },
+    // Claude Code's hook timeout is in SECONDS and defaults to 60 — half the
+    // window the interactive login needs, so leaving it undeclared let the hook
+    // be killed mid-sign-in (#220). Both values come from core so they cannot
+    // drift from the login timeout they have to outlast.
+    const command = (0, argus_1.requireHookCommand)(runtime);
+    const entry = (timeout) => [
+        { matcher: "", hooks: [{ type: "command", command, timeout }] },
     ];
+    const sessionStart = entry((0, argus_1.sessionStartHookTimeout)("claude-code", "seconds"));
+    const tool = entry((0, argus_1.toolHookTimeout)("claude-code", "seconds"));
     fs.writeFileSync(path.join(hooksDir, "hooks.json"), JSON.stringify({
         description: "Ory Claude Code Hooks",
         hooks: {
-            SessionStart: entry,
-            SessionEnd: entry,
-            UserPromptSubmit: entry,
-            PreToolUse: entry,
-            PostToolUse: entry,
-            PostToolUseFailure: entry,
-            SubagentStart: entry,
-            SubagentStop: entry,
-            PermissionRequest: entry,
+            SessionStart: sessionStart,
+            SessionEnd: tool,
+            UserPromptSubmit: tool,
+            PreToolUse: tool,
+            PostToolUse: tool,
+            PostToolUseFailure: tool,
+            SubagentStart: tool,
+            SubagentStop: tool,
+            PermissionRequest: tool,
         },
     }, null, 2) + "\n");
-    return PERSISTENT_DIR;
+    return persistentDir();
 }
 /**
- * Whether a `--from-source` plugin was assembled into `dir`.
+ * Whether an Ory plugin tree was assembled into `dir`.
  *
- * The data dir doubles as the default trace/debug-log home (`fromEnv` writes
- * `ory-agent-trace.ndjson` / `ory-agent-debug.log` there on every session), so
- * its mere existence does NOT indicate a local assembly — a production
- * marketplace install that has run once already creates it. The plugin
- * manifest (`.claude-plugin`) is written only by {@link assemblePluginDir}, so
- * it's the reliable signal that this dir holds a from-source plugin.
+ * The data dir doubles as the default activity/debug-log home (`fromEnv` writes
+ * `ory-agent-debug.log` there on every session), so
+ * its mere existence does NOT indicate an install. The plugin manifest
+ * (`.claude-plugin`) is written only by {@link assemblePluginDir}, so it's the
+ * reliable signal that this dir holds an assembled plugin.
  */
-function isAssembledFromSource(dir) {
+function isPluginAssembled(dir) {
     return fs.existsSync(path.join(dir, ".claude-plugin"));
 }
 /** Remove the persistent install directory if it exists. */
 function cleanPersistentDir() {
-    if (fs.existsSync(PERSISTENT_DIR)) {
-        fs.rmSync(PERSISTENT_DIR, { recursive: true, force: true });
-        console.log(`  Removed ${PERSISTENT_DIR}`);
+    if (fs.existsSync(persistentDir())) {
+        fs.rmSync(persistentDir(), { recursive: true, force: true });
+        console.log(`  Removed ${persistentDir()}`);
     }
 }
 /** Map --global flag to the claude CLI's scope values. */
@@ -229,99 +254,69 @@ function checkClaudeCli() {
 /**
  * Install the Ory plugin via the `claude` CLI.
  *
- * Two paths exist:
- *
- *   1. Default (production) — point the `claude` CLI at the public
- *      `ory/claude-plugins` GitHub marketplace and install from there. The
- *      release workflow keeps that repo's plugin subtree pinned to the latest
- *      `@ory/claude-code` version, so the hook commands, skills, commands,
- *      and MCP config all come from the published artifact. The install CLI
- *      writes nothing to the persistent data dir on this path.
- *
- *   2. `--from-source` (dev only) — assemble the plugin directory from this
- *      checkout's `.claude-plugin/`, register it as a local-file marketplace,
- *      and install from there. The dev launcher uses this so changes in the
- *      monorepo are exercised end-to-end without going through the release
- *      mirror. End users should never need this flag.
+ * The runtime is resolved here, once: materialized into the shared runtime
+ * store from npm (or linked to a workspace build with `--link`), then wired
+ * through a stable shim that the generated `hooks.json` / `.mcp.json` point
+ * at. Because those files carry machine-specific shim paths, the plugin tree
+ * is always assembled locally and registered as a local-file marketplace.
  */
 function install(args) {
     const isGlobal = args.includes("--global");
-    const fromSource = args.includes("--from-source");
     const scope = claudeScope(isGlobal);
     if (!checkClaudeCli()) {
         console.error("Error: 'claude' CLI not found in PATH.");
         console.error("Install Claude Code first: https://docs.anthropic.com/en/docs/claude-code");
         process.exit(1);
     }
-    if (fromSource) {
-        installFromSource(scope);
-    }
-    else {
-        installFromProductionMarketplace(scope);
-    }
-    (0, argus_1.printNextSteps)("Claude Code", fromSource
-        ? "npx -y -p @ory/claude-code ory-claude uninstall --from-source"
-        : isRemoteContext()
-            ? "npx @ory/claude-code uninstall"
-            : "npx -y -p @ory/claude-code ory-claude uninstall", { binName: "ory-claude", harness: "claude-code" });
+    installAssembled(scope, args);
+    (0, argus_1.printNextSteps)("Claude Code", "npx -y -p @ory/claude-code ory-claude uninstall", {
+        binName: "ory-claude",
+        harness: HARNESS,
+    });
 }
-/**
- * Default production install path: register the `ory/claude-plugins` GitHub
- * marketplace and install `ory-agent-plugin` from it. Nothing is assembled
- * locally — the marketplace and the plugin tree both live in the GitHub repo,
- * and the `claude` CLI fetches them on demand.
- */
-function installFromProductionMarketplace(scope) {
-    console.log(`Registering Ory plugin marketplace from ${PROD_MARKETPLACE_REPO}...`);
-    const addResult = runClaude([
-        "plugin",
-        "marketplace",
-        "add",
-        PROD_MARKETPLACE_REPO,
-        "--scope",
-        scope,
-    ]);
-    if (!addResult.ok) {
-        if (addResult.output.toLowerCase().includes("already")) {
-            console.log("  Marketplace already registered, updating...");
-            runClaude(["plugin", "marketplace", "update", PROD_MARKETPLACE_NAME]);
-        }
-        else {
-            console.error(`Failed to add marketplace: ${addResult.output}`);
-            process.exit(1);
-        }
-    }
-    else {
-        console.log("  Marketplace added.");
-    }
-    console.log(`Installing ${PROD_PLUGIN_NAME}@${PROD_MARKETPLACE_NAME} plugin...`);
-    const installResult = runClaude([
-        "plugin",
-        "install",
-        `${PROD_PLUGIN_NAME}@${PROD_MARKETPLACE_NAME}`,
-        "--scope",
-        scope,
-    ]);
-    if (!installResult.ok) {
-        console.error(`Failed to install plugin: ${installResult.output}`);
-        process.exit(1);
-    }
-    console.log("  Plugin installed.");
+function printInstallPlan(args) {
+    console.log(JSON.stringify({
+        scope: claudeScope(args.includes("--global")),
+        marketplaceRoot: persistentDir(),
+        hooks: 'node "<runtime shim>"',
+        mcpServer: { command: "node", args: ["<MCP runtime shim>"] },
+        assets: ["skills/", "commands/"],
+    }, null, 2));
 }
 /**
- * Dev-only install path: assemble the plugin from this checkout and register
- * it as a local-file marketplace. Used by the dev launcher (which publishes
- * the monorepo packages to a local Verdaccio registry and then calls this CLI
- * with `--from-source`) and by anyone hand-iterating on plugin code locally.
+ * Resolve the runtime, assemble the plugin tree around it, and register that
+ * tree with the `claude` CLI as a local-file marketplace.
  */
-function installFromSource(scope) {
-    const remote = isRemoteContext();
+function installAssembled(scope, args) {
+    const runtime = (0, argus_1.wireRuntime)({
+        harness: HARNESS,
+        packageName: PACKAGE_NAME,
+        packageRoot: PACKAGE_ROOT,
+        installCommand: INSTALL_COMMAND,
+        args,
+    });
+    console.log(runtime.target.kind === "linked"
+        ? `Runtime: linked to ${runtime.target.packageDir} (dev)`
+        : `Runtime: ${runtime.target.packageName}@${runtime.target.version} in ${runtime.target.storeDir}`);
+    console.log(`  Hook: ${runtime.hookShim}`);
+    for (const pruned of runtime.prunedStores) {
+        console.log(`  Removed stale runtime: ${pruned}`);
+    }
     console.log("Assembling Ory plugin (skills, commands, hooks, MCP) at:");
-    console.log(`  ${PERSISTENT_DIR}`);
-    const pluginRoot = assemblePluginDir(remote ? HOOK_CMD_REMOTE : localHookCommand());
+    console.log(`  ${persistentDir()}`);
+    const pluginRoot = assemblePluginDir(runtime);
     const marketplaceName = readLocalMarketplaceName();
     const pluginName = readLocalPluginName();
     console.log(`Source: ${pluginName}@${marketplaceName} (from ${pluginRoot})`);
+    // Force a clean slate before re-adding. The `claude` CLI caches an
+    // already-installed plugin by version and won't re-read its command/skill
+    // files on a same-version re-install — so a freshly-assembled command (e.g.
+    // `dashboard`) would be missing after a republish. Removing the plugin and
+    // its marketplace first guarantees the current command set is picked up on
+    // every dev iteration. Best-effort and quiet: a not-yet-installed plugin
+    // just no-ops here.
+    runClaude(["plugin", "uninstall", pluginName, "--scope", scope]);
+    runClaude(["plugin", "marketplace", "remove", marketplaceName]);
     console.log("Adding local Ory plugin marketplace...");
     const addResult = runClaude([
         "plugin",
@@ -356,27 +351,32 @@ function installFromSource(scope) {
         console.error(`Failed to install plugin: ${installResult.output}`);
         process.exit(1);
     }
+    // Claude Code stores this marketplace path and re-reads it, so a data-dir
+    // wipe that skips uninstall would leave it pointing at nothing. Record how to
+    // undo the registration so the destructive paths can replay it (#206).
+    (0, argus_1.recordExternalRegistration)({
+        harness: "claude-code",
+        tool: "claude",
+        description: `Claude Code marketplace "${marketplaceName}"`,
+        root: persistentDir(),
+        remove: { command: "claude", args: ["plugin", "marketplace", "remove", marketplaceName] },
+    });
     console.log("  Plugin installed.");
 }
 /**
- * Uninstall the Ory plugin via the `claude` CLI. Mirrors `install`:
- *
- *   - Default: uninstall `ory-agent-plugin`, remove the production marketplace.
- *   - `--from-source`: uninstall the locally-assembled plugin, remove its
- *     marketplace entry, and clean up the assembled directory.
+ * Uninstall the Ory plugin via the `claude` CLI: remove the plugin and its
+ * marketplace entry, delete the assembled plugin tree, and drop the runtime
+ * wiring (shim + any store no other harness still references).
  */
 function uninstall(args) {
     const isGlobal = args.includes("--global");
-    const fromSource = args.includes("--from-source");
     const scope = claudeScope(isGlobal);
     if (!checkClaudeCli()) {
         console.error("Error: 'claude' CLI not found in PATH.");
         process.exit(1);
     }
-    const pluginName = fromSource ? readLocalPluginName() : PROD_PLUGIN_NAME;
-    const marketplaceName = fromSource
-        ? readLocalMarketplaceName()
-        : PROD_MARKETPLACE_NAME;
+    const pluginName = readLocalPluginName();
+    const marketplaceName = readLocalMarketplaceName();
     console.log(`Uninstalling ${pluginName} plugin...`);
     const uninstallResult = runClaude([
         "plugin",
@@ -404,8 +404,14 @@ function uninstall(args) {
     else {
         console.log("  Marketplace removed.");
     }
-    if (fromSource) {
-        cleanPersistentDir();
+    // Deregistered above, so nothing is left to undo.
+    (0, argus_1.clearExternalRegistration)("claude-code");
+    cleanPersistentDir();
+    // Drop the shim and GC the runtime store, unless another harness still
+    // points at it.
+    (0, argus_1.removeRuntimeWiring)(HARNESS);
+    for (const pruned of (0, argus_1.pruneRuntimeStores)()) {
+        console.log(`  Removed runtime: ${pruned}`);
     }
 }
 // --- Standalone binary entry point (ory-claude-setup) ---
@@ -419,13 +425,15 @@ Usage:
 
 Options:
   --global       Install to user scope (default: project scope)
-  --from-source  Install from this checkout's local marketplace (dev only)
+  --runtime-dir <dir>
+                 Wire the runtime to a built package directory instead of
+                 installing it from npm (dev only)
   --uninstall    Remove the Ory plugin and marketplace
   -h, --help     Show this help
 
-By default, points the 'claude' CLI at the public ory/claude-plugins
-marketplace and installs ory-agent-plugin from it. Pass --from-source to
-install from the local monorepo checkout instead (used by the dev launcher).
+Resolves the plugin runtime once (installing it into the shared runtime store),
+assembles the plugin tree around the resulting shim, and registers that tree
+with the 'claude' CLI as a local-file marketplace.
 `);
         process.exit(0);
     }
@@ -434,7 +442,10 @@ install from the local monorepo checkout instead (used by the dev launcher).
         uninstall(args);
         // Direct `-setup --uninstall` path: also clear stored Ory credentials.
         // (The `ory-claude uninstall` command handles this itself.)
-        (0, argus_1.clearCredentialsForUninstall)().then(() => process.exit(0), (err) => {
+        (0, argus_1.clearCredentialsForUninstall)({
+            harness: "claude-code",
+            purge: process.argv.includes("--purge"),
+        }).then(() => process.exit(0), (err) => {
             console.error(err.message ?? err);
             process.exit(1);
         });

package/dist/handlers.d.ts

@@ -1,14 +1,9 @@
-import { OryAgentClient, ensureUserAuthenticated, ensureAgentIdentity, ensureSubAgentIdentity } from "@ory/argus";
+import { ensureAgentIdentity, ensureSubAgentIdentity, ensureUserAuthenticated } from "@ory/argus";
+import type { OryAgentClient } from "@ory/argus";
 import type { ClaudeCodeHookInput, ClaudeCodeHookOutput } 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;
-    /** Test injection point for the sub-agent identity resolver. */
     subAgentGate?: typeof ensureSubAgentIdentity;
 }
-/**
- * Route a Claude Code hook event to the appropriate Ory integration.
- */
 export declare function handleHookEvent(input: ClaudeCodeHookInput, client: OryAgentClient, deps?: HandleHookEventDeps): Promise<ClaudeCodeHookOutput>;