@ory/continue 0.14.0 → 1.0.1

package/README.md

@@ -2,9 +2,12 @@
 
 Security and developer experience for [Continue](https://continue.dev)'s `cn` CLI, powered by [Ory](https://ory.com).
 
-**Security.** Continue runs real actions on your machine — editing files, running shell commands, calling APIs. The plugin gives every session a verifiable identity (you sign in once; Continue and any sub-agents it spawns each get their own), checks every tool call against permissions you control, and records each decision as an audit trace you can ship to your observability stack. It starts in watch mode so nothing is blocked on day one, and if Ory is ever unreachable it steps aside rather than locking you out.
+Continue runs real actions on your machine — editing files, running shell commands, calling APIs. This plugin gives those actions an identity, a permission check, and an audit trail.
 
-**Developer experience.** A single command installs the plugin and walks you through connecting — choose Ory Network, a local Docker stack, or audit-only, and it wires up the project, sign-in client, login, and permissions for you. It also helps you build Ory into your own app: ask in plain language to scaffold login, registration, and recovery pages, run a local Ory, or manage identities and permissions through the bundled MCP server.
+One command installs two independent halves:
+
+- **Developer experience** — the Ory skill catalog, the local Ory dev stack, an MCP server, and activity logging. No account, no keys, nothing to configure: it works the moment it's installed.
+- **Ory Agent Security** — browser sign-in, brokered permission checks before tool calls, and the delegation trail. Opt-in connection details from the [Ory Console](https://console.ory.sh) switch it on, and it takes nothing away from the half above. See [Connect to Ory Agent Security](#connect-to-ory-agent-security).
 
 This targets the **`cn` CLI** (not the Continue IDE extension), verified against `@continuedev/cli`.
 
@@ -17,7 +20,7 @@ This targets the **`cn` CLI** (not the Continue IDE extension), verified against
 
 ## Get started
 
-Run one command. It installs the plugin and walks you through connecting:
+Run one command:
 
 ```bash
 npx -y -p @ory/continue ory-cn install
@@ -25,31 +28,53 @@ npx -y -p @ory/continue ory-cn install
 
 Continue has no native install command, so this writes the Ory hooks into your project settings and drops the Ory skills into your project — Continue turns each skill into a slash command automatically (so the local Ory commands show up as `/ory-local-up`, `/ory-local-down`, and `/ory-temporal-up`).
 
-It opens a guided setup **in your browser** where you pick how to connect — the default takes just a click:
-
-- **Ory Network** *(default)* — sign in, or create a free account, in your browser. The project, keys, permissions, and login are all set up for you. Nothing to configure by hand.
-- **Local** — run a complete Ory on your laptop with Docker. No account, no signup, no keys. Great for trying it out.
-- **Audit-only** — skip Ory entirely and just log what Continue does.
-
-> No browser available (CI, SSH, headless)? The same walkthrough runs right in your terminal instead — or force it with `--no-web`.
-
-That's it. Confirm everything landed with:
+Confirm everything landed with:
 
 ```bash
 npx -y -p @ory/continue ory-cn status
 ```
 
-`status` is your one-stop check: what's configured, who's signed in, which tools are covered by permissions, and recent activity. Anything not set up yet shows as `(unset)`.
+`status` is your one-stop check: what's configured, who's signed in, which tools are covered by permissions, and recent activity. Until you connect Agent Security, the identity and permission rows say so and name what's missing.
+
+## Skills and commands
+
+Installing the plugin drops the full Ory playbook catalog into Continue. **Skills** are model-invoked — say what you want in plain language. Continue also surfaces every skill as a slash command, so `/ory-auth-setup` works too.
+
+| Skill | What it does for you |
+|---|---|
+| `ory-auth-setup` | Adds a complete auth system to your app — login, registration, recovery, verification, settings — on [Ory Elements](https://github.com/ory/elements) |
+| `ory-login-flow` | Builds just the pages, wired to Ory's self-service flows |
+| `ory-social-login` | "Sign in with…" for Google, GitHub, Apple, Microsoft, Discord, Slack, GitLab, Facebook |
+| `ory-local-dev` | Develops and tests login/permission flows against a local Ory — no project, no account, offline |
+| `ory-permissions-onboarding` | Walks a fresh install from observe mode to enforced per-tool permissions without getting blocked |
+| `ory-build-agent` | Drops `@ory/argus` into an agent *you* own — Claude Agent SDK, OpenAI Agents, Mastra, Vercel AI, LangGraph/PydanticAI |
+| `ory-build-integration` | Wires Ory into your app: Action webhooks, JWT validation at a gateway, live event streams |
+| `ory-contribute-integration` | Authors and submits an integration to the public `ory/integrates` registry |
+| `ory-e2b-sandbox` | Scaffolds an E2B sandbox template that boots with this plugin preinstalled |
+| `ory-temporal-worker` | Scaffolds a Temporal TypeScript worker where every Activity is authenticated, authorized, and audited |
+
+The local-stack playbooks install as skills too, so they show up as slash commands:
+
+| Command | What it does |
+|---|---|
+| `/ory-local-up` | Starts a local Ory (Identities, OAuth2, Permissions) in Docker and seeds a test user — it prints the email + password to sign in with |
+| `/ory-local-down` | Stops it, keeping your data volumes |
+| `/ory-temporal-up` | Starts a local Temporal dev server for the `ory-temporal-worker` scaffold |
 
-> Re-run install with `--reconfigure` to change your connection later, or `--no-configure` to skip the wizard and configure by hand.
+The local stack runs entirely on your laptop: Ory APIs at `http://localhost:4000`, a login UI on `:4455` (not `:3000`, to dodge Next.js port clashes), and the Ory Console on `:4100`.
+
+A built-in **Ory MCP server** rounds it out — Continue can manage identities, projects, and permissions straight from chat.
+
+So: ask Continue *"add Ory login to this app"* and it scaffolds the pages, starts a local Ory, and wires them together.
 
 ## What you get
 
-Once connected, every tool Continue runs is governed by Ory — three things happen automatically:
+Out of the box, every tool Continue runs produces a privacy-safe structured activity event in the unified local log.
+
+Once you connect to Ory Agent Security, two more things happen automatically:
 
-- **Who's driving.** You sign in once in your browser (a quick, secure handoff — no passwords or tokens to copy around). Continue itself registers its own identity automatically the first time it runs, and any sub-agents get their own too. The "who acted on whose behalf" trail stays queryable later.
-- **What it's allowed to do.** Before a tool runs, Ory checks whether it's permitted. It starts in **watch mode** — nothing is blocked, you just *see* what would be — so it never gets in your way on day one.
-- **A record of everything.** Every decision (allowed, denied, skipped) is logged as a trace you can send to Jaeger, Honeycomb, Grafana, or just a file.
+- **Who's driving.** You sign in once in your browser; Continue (and any sub-agents it spawns) each get their own identity. No tokens to copy around, and the "who acted on whose behalf" trail stays queryable later.
+- **What it's allowed to do.** Before a tool runs, Ory checks whether it's permitted. It starts in **observe mode** — nothing is blocked, you just *see* what would be — so it never gets in your way on day one.
 
 If Ory is ever unreachable, the plugin gets out of the way and lets Continue keep working — so it can't lock you out.
 
@@ -57,81 +82,63 @@ Under the hood, Continue runs the plugin the same way [Claude Code](https://gith
 
 ### See what's happening
 
-Everything the plugin does is observable out of the box — no configuration required:
+Everything the plugin does is observable out of the box:
 
-- **Status at a glance.** `npx -y -p @ory/continue ory-cn status` shows what's configured, who's signed in, how many built-in tools your permissions cover, and the most recent tool-call activity.
-- **Live dashboard.** `npx -y -p @ory/continue ory-cn dashboard` opens the same picture in your browser — configuration, identities, permission coverage, Ory service health, and the latest tool-call activity, all refreshing live. From there you can flip **enforcement** on or off, toggle **user login**, and use **Change stack** to reconnect to a different Ory — no CLI required.
-- **Live traces.** Every tool call is recorded as an OpenTelemetry-style span. Watch them stream as the agent works:
+- **Activity log.** Privacy-safe activity is always appended to `~/.config/ory-agent-plugins/continue/ory-agent-debug.log`. View events, decisions, and errors live with:
 
   ```bash
   npx -y -p @ory/continue ory-cn watch
   ```
 
-  Spans are also written to `~/.config/ory-agent-plugins/continue/ory-agent-trace.ndjson` (NDJSON, one span per line) — tail that file, or point `OTEL_EXPORTER_OTLP_ENDPOINT` at a collector to ship them straight to Jaeger, Honeycomb, or Grafana.
-- **Debug log.** For a verbose play-by-play, set `ORY_AGENT_DEBUG=true`; structured logs land in `~/.config/ory-agent-plugins/continue/ory-agent-debug.log`.
+  Set `ORY_AGENT_LOG_FILE` to override the path; set it empty to disable file persistence.
+- **Live debug.** Launch Continue with `ORY_AGENT_DEBUG=true` to add verbose local diagnostics, including raw shell commands, to the watched log and stderr. Secrets are recursively redacted; pass `watch --json` for NDJSON.
 
 ### Ready to enforce?
 
-When the watch-mode logs look right, turn on blocking with one command (setup already granted you the built-in tools):
+Once connected, the deny posture lives on the Ory project: when the observe-mode activity looks right, an admin promotes it to **enforce** in the **Ory Console** (Agent Security). Every session reads that posture live, so nothing has to be reinstalled.
 
 ```bash
-npx -y -p @ory/continue ory-cn permissions enforce
+npx -y -p @ory/continue ory-cn permissions   # what the project grants, and the live mode
 ```
 
-Now a denied tool is actually blocked. Go back to watch mode anytime with `permissions observe`. Prefer clicking? The dashboard has the same **Enforce** switch — flip it on, or back to watch mode, without touching the CLI. Use `permissions status` to see what's covered and `permissions bootstrap` to (re-)grant the built-in tools.
-
-## Also: add login to your own app
-
-Beyond securing Continue, the plugin helps you build Ory into whatever you're working on. Ask Continue *"add Ory login to this app"* and it scaffolds the login, registration, recovery, and settings pages (using [Ory Elements](https://github.com/ory/elements)) wired to a local Ory — no signup or keys needed. Start that local Ory with `/ory-local-up` (it prints a test email + password to sign in with) and tear it down with `/ory-local-down`.
+Then a denied tool is actually blocked and Continue shows why.
 
-Bundled **skills** (just ask in plain language, and Continue surfaces each as a slash command) cover more: `ory-auth-setup`, `ory-login-flow`, `ory-social-login` (Google, GitHub, Apple…), `ory-permissions-onboarding`, and playbooks for wiring Ory into your own agents, E2B sandboxes, or Temporal workers.
+## Connect to Ory Agent Security
 
-## Configure by hand (CI / advanced)
+Copy the connection details from the [Ory Console](https://console.ory.sh) under **Agent Security**:
 
-The guided setup covers most people. For scripted or CI setups, or to point at an existing Ory Network project, configure directly. Settings are saved to `~/.config/ory-agent-plugins/config.json` and shared across all your Ory agent plugins; environment variables win when both are set.
+| Value | Flag | Environment variable |
+|---|---|---|
+| Project URL | `--project-url` | `ORY_PROJECT_URL` |
+| Agent Security URL | `--agent-security-url` | `ORY_AGENT_SECURITY_URL` |
+| Sign-in client id override (default `ory-agent-security-login`) | `--oauth2-client-id` | `ORY_OAUTH2_CLIENT_ID` |
 
 ```bash
 npx -y -p @ory/continue ory-cn configure \
   --project-url https://<slug>.projects.oryapis.com \
-  --oauth2-client-id <login client id>
+  --agent-security-url https://agents.console.ory.com
 ```
 
-Continue's own identity registers itself automatically on first run — nothing to create. The `--oauth2-client-id` is the one piece browser sign-in needs; the guided setup makes it for you, or see below to do it by hand. For logging-only with no checks, use `--audit-only`.
+`install` accepts the same flags, so you can register the plugin **and** connect in one shot (`install --project-url <URL> --agent-security-url <URL>`). The login client defaults to `ory-agent-security-login`; custom deployments can override it with `--oauth2-client-id`. Existing configurations fall back to the project URL when the Agent Security URL is unset. To turn sign-in and checks back off later, use `configure --disconnect`.
 
-<details>
-<summary>Create the sign-in client by hand</summary>
-
-The guided setup normally does this. To do it yourself, create a **public** OAuth2 client (no secret) listing all four loopback URLs — the plugin tries each in turn so sign-in survives a busy port:
-
-```bash
-ory create oauth2-client --project <project-id> \
-  --name "Ory Agent Security · user login (PKCE)" \
-  --grant-type authorization_code,refresh_token \
-  --response-type code \
-  --scope openid,offline_access \
-  --token-endpoint-auth-method none \
-  --redirect-uri http://127.0.0.1:47823/callback \
-  --redirect-uri http://127.0.0.1:47824/callback \
-  --redirect-uri http://127.0.0.1:47825/callback \
-  --redirect-uri http://127.0.0.1:47826/callback
-```
+**Ory Network or OEL.** Either works. For an Ory Network project the URL is `https://<slug>.projects.oryapis.com`; for a self-hosted **Ory Enterprise License** deployment, point `--project-url` at that deployment's base URL and use the sign-in client id from its Agent Security configuration. Everything downstream — sign-in, checks, delegation — is identical.
 
-Pass the resulting id to `configure --oauth2-client-id`. Running headless with a session token already? Set `ORY_USER_SESSION_TOKEN` and skip the browser step entirely.
+**There is nothing else for you to create.** The sign-in client, the permission model, the per-tool grants and blocks, and the observe/enforce posture are all provisioned in the Console by someone with project access. At runtime the plugin only *reads* permissions — it has no write path into your project, which is why installing it needs no workspace privilege. Each Continue session registers its own identity automatically on first use.
 
-</details>
+Sign-in runs at the start of every session and never blocks — a declined, skipped, or timed-out login simply leaves that session without a user identity.
 
-With nothing configured, the plugin still loads and runs in **pass-through mode**: skills and their slash commands work, but no checks run and nothing is blocked. Perfectly fine if you only want the app-building features.
+Settings are saved to `~/.config/ory-agent-plugins/config.json` and shared across all your Ory agent plugins; environment variables win when both are set. Running headless with an OAuth2 access token already? Set `ORY_USER_OAUTH2_TOKEN` and the browser step is skipped entirely.
 
 ## Commands
 
 ```
-ory-cn install | uninstall        Install/remove; --reconfigure re-runs setup, --no-web forces the terminal wizard, --no-configure skips it
+ory-cn install | uninstall         Install (add --project-url to also connect Agent Security) / remove
 ory-cn status                      Show configuration, identities, permission coverage, recent activity
-ory-cn dashboard                   Open the live browser dashboard (status + service health + Change stack)
-ory-cn watch                       Tail the live trace stream (OTel spans)
-ory-cn permissions <cmd>           status | bootstrap | observe (watch) | enforce (block)
-ory-cn configure <flags>           Point at a project by hand (--project-url, --oauth2-client-id, --audit-only)
+ory-cn permissions <cmd>           status  (read-only; grants + posture live in the Ory Console)
+ory-cn configure <flags>           Connect a project (--project-url) or --disconnect
 ory-cn agent <status|unregister>   Manage Continue's own auto-created identity
+ory-cn local <up|down|status|…>    Run / manage a local Ory in Docker
+ory-cn version                     Print plugin, core, and Node versions (--json for machine-readable)
 ```
 
 All prefixed with `npx -y -p @ory/continue`.
@@ -139,10 +146,9 @@ All prefixed with `npx -y -p @ory/continue`.
 ## Troubleshooting
 
 - **`/ory-local-up` fails** — make sure Docker is running and ports `4000`, `4100`, `4455`, and `16686` are free.
-- **Browser sign-in loops** — reset with `ory-cn agent unregister` and try again.
-- **Install ran but never asked how to connect** — you're almost certainly on a stale `npx` cache. `npx -p @ory/continue` (no version pin) reuses a previously-downloaded copy instead of re-resolving to the latest, so an older CLI whose install predates the setup wizard can run while you believe you're on the current release. The install banner prints the running version; confirm it with `npx -y -p @ory/continue ory-cn version`. To force the current release, clear the cache and reinstall: `rm -rf ~/.npm/_npx` then `npx -y -p @ory/continue ory-cn install`. Pinning an exact version (`@ory/continue@<version>`) also bypasses the cached copy.
+- **Browser sign-in loops** (after connecting) — reset with `ory-cn agent unregister` and try again.
+- **Running an older CLI than expected** — `npx -p @ory/continue` (no version pin) reuses a previously-downloaded copy instead of re-resolving to the latest. The install banner prints the running version; confirm it with `npx -y -p @ory/continue ory-cn version`. To force the current release, clear the cache and reinstall: `rm -rf ~/.npm/_npx` then `npx -y -p @ory/continue ory-cn install`. Pinning an exact version (`@ory/continue@<version>`) also bypasses the cached copy.
 - **Hooks stuck on an old version** — re-run the installer.
-- **Want to see what's happening** — `npx -y -p @ory/continue ory-cn status` for a snapshot, `npx -y -p @ory/continue ory-cn watch` for the live trace stream, or set `ORY_AGENT_DEBUG=true` for a verbose log. Traces and logs live under `~/.config/ory-agent-plugins/continue/` (see [See what's happening](#see-whats-happening)).
 
 ## Learn more
 

package/dist/cli/main.js

@@ -54,6 +54,11 @@ const argus_1 = require("@ory/argus");
 const PACKAGE_ROOT = path.resolve(__dirname, "..", "..");
 function main() {
     const [command, ...args] = process.argv.slice(2);
+    // `--help` after a matched subcommand: print usage, do nothing else.
+    // Without this the switch below ignores the flag and `install --help`
+    // performs a real install (#221).
+    if ((0, argus_1.shouldPrintHelp)(command, args))
+        return help();
     switch (command) {
         case "install":
             (0, argus_1.beginDeferNextSteps)();
@@ -65,7 +70,10 @@ function main() {
             break;
         case "uninstall":
             uninstall(args);
-            (0, argus_1.clearCredentialsForUninstall)().then(() => process.exit(0), (err) => {
+            (0, argus_1.clearCredentialsForUninstall)({
+                harness: "continue",
+                purge: args.includes("--purge"),
+            }).then(() => process.exit(0), (err) => {
                 console.error(err.message ?? err);
                 process.exit(1);
             });
@@ -74,7 +82,7 @@ function main() {
             (0, argus_1.runConfigureCommand)("ory-cn", args);
             break;
         case "agent":
-            (0, argus_1.runAgentCommand)("ory-cn", args).then((code) => process.exit(code), (err) => {
+            (0, argus_1.runAgentCommand)("ory-cn", "continue", args).then((code) => process.exit(code), (err) => {
                 console.error(err.message ?? err);
                 process.exit(1);
             });
@@ -94,17 +102,11 @@ function main() {
                 process.exit(1);
             });
             break;
-        case "local":
-            (0, argus_1.runLocalCommand)("ory-cn", args).catch((err) => {
-                console.error(err.message ?? err);
-                process.exit(1);
-            });
-            break;
         case "watch":
-            (0, argus_1.runWatchCommand)("continue", args);
+            (0, argus_1.runWatchCommand)("ory-cn", "continue", args).then((code) => process.exit(code), (err) => { console.error(err.message ?? err); process.exit(1); });
             break;
-        case "dashboard":
-            (0, argus_1.runDashboardCommand)("ory-cn", "continue", args).then((code) => process.exit(code), (err) => {
+        case "local":
+            (0, argus_1.runLocalCommand)("ory-cn", args).catch((err) => {
                 console.error(err.message ?? err);
                 process.exit(1);
             });
@@ -176,11 +178,11 @@ Commands:
   uninstall              Remove the Ory hooks and skills
   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)
+  permissions            Show the live permission mode and per-tool coverage
   setup [--project-dir]  Write hooks directly to .continue/settings.json
   status                 Show plugin status and configuration
-  dashboard            Open the Ory Agent dashboard (system health + configuration)
-  watch [trace-file]     Tail the trace stream (OTel spans) live
+  watch [--json] [--lines <count>]
+                         Follow the live activity/debug log
   version                Show version and the ory-agent-plugins build commit
   local <cmd>            Manage local Ory dev environment (up, down, status, seed, ...)
 

package/dist/cli/setup.js

@@ -56,11 +56,11 @@ const argus_1 = require("@ory/argus");
 const assets_js_1 = require("./assets.js");
 const BIN_NAME = "ory-cn-hook";
 const PACKAGE_NAME = "@ory/continue";
+const PACKAGE_ROOT = path.resolve(__dirname, "..", "..");
 function getSettingsPath(args) {
     return path.join(args.projectDir, ".continue", "settings.json");
 }
-function generateHooksConfig() {
-    const cmd = (0, argus_1.resolveHookCommand)(PACKAGE_NAME, BIN_NAME);
+function generateHooksConfig(cmd) {
     return {
         SessionStart: (0, argus_1.matcherHookEntry)(cmd),
         PreToolUse: (0, argus_1.matcherHookEntry)(cmd),
@@ -81,9 +81,9 @@ function main() {
         process.exit(0);
     }
     const args = (0, argus_1.parseSetupArgs)();
-    const hooksConfig = generateHooksConfig();
     if (args.print) {
-        console.log(JSON.stringify({ hooks: hooksConfig }, null, 2));
+        // Nothing is resolved or written on a --print run.
+        console.log(JSON.stringify({ hooks: generateHooksConfig('node "<runtime shim>"') }, null, 2));
         return;
     }
     const settingsPath = getSettingsPath(args);
@@ -101,10 +101,30 @@ function main() {
         (0, assets_js_1.uninstallContinueOryAssets)(continueDir);
         console.log(`Removed Ory hooks and MCP server from ${settingsPath}`);
         console.log(`Removed Ory skills from ${continueDir}`);
+        (0, argus_1.removeRuntimeWiring)("continue");
+        for (const pruned of (0, argus_1.pruneRuntimeStores)()) {
+            console.log(`  Removed runtime: ${pruned}`);
+        }
         return;
     }
+    const runtime = (0, argus_1.wireRuntime)({
+        harness: "continue",
+        packageName: PACKAGE_NAME,
+        packageRoot: PACKAGE_ROOT,
+        installCommand: "npx -y -p @ory/continue ory-cn install",
+        args: process.argv.slice(2),
+    });
+    console.log(runtime.target.kind === "linked"
+        ? `Runtime: linked to ${runtime.target.packageDir} (dev)`
+        : `Runtime: ${runtime.target.packageName}@${runtime.target.version} in ${runtime.target.storeDir}`);
+    for (const pruned of runtime.prunedStores) {
+        console.log(`  Removed stale runtime: ${pruned}`);
+    }
+    const hooksConfig = generateHooksConfig((0, argus_1.requireHookCommand)(runtime));
     let merged = (0, argus_1.mergeMatcherHooks)(existing, hooksConfig, BIN_NAME);
-    merged = (0, argus_1.mergeMcpServer)(merged);
+    if (runtime.mcpServer) {
+        merged = (0, argus_1.mergeMcpServer)(merged, runtime.mcpServer);
+    }
     (0, argus_1.writeJsonFile)(settingsPath, merged);
     (0, assets_js_1.installContinueOryAssets)(continueDir);
     console.log(`Ory hooks and MCP server installed to ${settingsPath}`);
@@ -119,7 +139,10 @@ main();
 // stored Ory credentials. When required by the plugin's main CLI, that
 // command owns the purge, so the `require.main` guard prevents a double run.
 if (require.main === module && process.argv.includes("--uninstall")) {
-    (0, argus_1.clearCredentialsForUninstall)().then(() => process.exit(0), (err) => {
+    (0, argus_1.clearCredentialsForUninstall)({
+        harness: "continue",
+        purge: process.argv.includes("--purge"),
+    }).then(() => process.exit(0), (err) => {
         console.error(err.message ?? err);
         process.exit(1);
     });

package/dist/handlers.d.ts

@@ -1,17 +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 { ContinueHookInput, ContinueHookOutput } 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 Continue CLI hook event to the appropriate Ory integration.
- *
- * Event names are verified against @continuedev/cli. Unknown events pass
- * through.
- */
 export declare function handleHookEvent(input: ContinueHookInput, client: OryAgentClient, deps?: HandleHookEventDeps): Promise<ContinueHookOutput>;

package/dist/handlers.js

@@ -3,62 +3,44 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleHookEvent = handleHookEvent;
 const argus_1 = require("@ory/argus");
 const HARNESS = "continue";
-const BIN_NAME = "ory-cn";
-/**
- * Route a Continue CLI hook event to the appropriate Ory integration.
- *
- * Event names are verified against @continuedev/cli. Unknown events pass
- * through.
- */
-async function handleHookEvent(input, client, deps = {}) {
+function handleHookEvent(input, client, deps = {}) {
     const event = input.hook_event_name;
     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 {
+    return (0, argus_1.withHookContext)(client, { sessionId: input.session_id }, async () => {
         switch (event) {
             case "SessionStart":
-                return await handleSessionStart(input, client, deps);
+                return handleSessionStart(input, client, deps);
             case "PreToolUse":
-                return await handlePreToolUse(input, client, deps);
+                return handlePreToolUse(input, client, deps);
             case "PostToolUse":
-                return await handlePostToolUse(input, client);
+                return handlePostToolUse(input, client);
             case "PostToolUseFailure":
-                return await handlePostToolUseFailure(input, client);
+                return handlePostToolUseFailure(input, client);
             case "PermissionRequest":
-                return await handlePermissionRequest(input, client);
+                return handlePermissionRequest(input, client);
             case "UserPromptSubmit":
-                return await handleUserPromptSubmit(input, client);
+                return handleUserPromptSubmit(input, client);
             case "SubagentStart":
-                return await handleSubagentStart(input, client, deps);
+                return handleSubagentStart(input, client, deps);
             case "SubagentStop":
-                return await handleSubagentStop(input, client);
+                return handleSubagentStop(input, client);
             case "Stop":
-                return await handleStop(input, client);
+                return handleStop(input, client);
             case "SessionEnd":
-                return await handleSessionEnd(input, client);
+                return handleSessionEnd(input, client);
             case "PreCompact":
-                return await handlePreCompact(input, client);
+                return handlePreCompact(input, client);
             default:
                 client.logger.debug("hook.passthrough", { event });
-                client.tracer.record("hook.passthrough", "skipped", {
-                    attributes: { event },
-                });
+                client.logger.activity("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,
@@ -66,107 +48,65 @@ async function handleSessionStart(input, client, deps) {
         source: input.source,
         cwd: input.cwd,
     });
-    client.tracer.record("session.start", "ok", {
-        attributes: { model: input.model, source: input.source },
-    });
-    // Run the user login (interactive PKCE on first session, refresh when
-    // needed). This runs on every session and never blocks — enforcement is
-    // governed solely by permissionMode at tool-call time.
-    const userGate = deps.userLogin ?? argus_1.ensureUserAuthenticated;
-    await userGate(client, {
-        binName: BIN_NAME,
+    await (0, argus_1.sessionStart)(client, {
         harness: HARNESS,
+        binName: "ory-cn",
+        userLogin: deps.userLogin,
+        agentGate: deps.agentGate,
+        activityAttributes: { model: input.model, source: input.source },
     });
-    // Resolve the agent identity (machine credentials) regardless of how user
-    // auth went — 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: HARNESS });
-    // Record the user→agent delegation for the audit trail. Best-effort,
-    // fail-open, and written at most once per install.
-    await (0, argus_1.writeUserDelegatesAgent)(client);
     return {};
 }
-// ─── PreToolUse ─────────────────────────────────────────────────────
-async function handlePreToolUse(input, client, deps = {}) {
+async function handlePreToolUse(input, client, deps) {
     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);
-    // If the agent is invoking a sub-agent (a Task/Agent tool call with a
-    // subagent_type), resolve a distinct OAuth2 identity for it and record the
-    // delegation. Best-effort — never blocks the actual tool call.
-    await maybeRegisterSubAgent(toolName, input.tool_input, client, deps);
-    // 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 {
-        // No Continue-specific MCP tool parser exists in core, so gate every tool
-        // by name. MCP tools (if Continue namespaces them) flow through the same
-        // path keyed on the tool name.
-        const outcome = await (0, argus_1.gateToolCall)(client, {
+    const subAgentType = subagentType(toolName, input.tool_input);
+    if (subAgentType) {
+        await (0, argus_1.registerSubagent)(client, {
             harness: HARNESS,
-            toolName,
-            check: { namespace, object: toolName, relation: "use", ...subject },
-            spanAttributes: { toolName },
-        });
-        // Interactive tools surface UI to the user and aren't external-system tool
-        // executions. gateToolCall has already recorded the `user.interaction`
-        // audit span; pass through with no tool.invoke/tool.block.
-        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 {};
-        }
-        // deny
-        client.tracer.record("tool.block", "denied", {
-            attributes: { ...attrs, ...decisionAttrs, allowed: false, ...(0, argus_1.alertAttributes)(true) },
+            subAgentType,
+            perSpawnId: input.tool_use_id,
+            subAgentGate: deps.subAgentGate,
         });
-        const reason = (0, argus_1.formatDenialMessage)({ tool: toolName, subjectId, namespace });
-        return {
-            decision: "block",
-            reason,
-            hookSpecificOutput: {
-                hookEventName: "PreToolUse",
-                permissionDecision: "deny",
-                permissionDecisionReason: reason,
-            },
-        };
-    }
-    catch (err) {
-        return handlePermissionError(err, toolName, client);
     }
+    const result = await (0, argus_1.gate)(client, {
+        harness: HARNESS,
+        toolName,
+        toolArgs: input.tool_input,
+        subjectFallback: `session:${input.session_id}`,
+        principals: actingSubagentPrincipals(input),
+    });
+    if (!result.blocked)
+        return {};
+    const reason = result.denialMessage ?? "Ory permission denied";
+    return {
+        decision: "block",
+        reason,
+        hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            permissionDecision: "deny",
+            permissionDecisionReason: reason,
+        },
+    };
+}
+function actingSubagentPrincipals(input) {
+    const type = input.agent_type;
+    if (!input.agent_id || !type)
+        return undefined;
+    const credential = (0, argus_1.loadSubAgentDynamicCredentials)(HARNESS, input.session_id, type);
+    if (!credential)
+        return undefined;
+    return {
+        subAgentClientId: credential.clientId,
+        subAgentType: type,
+        perSpawnId: input.agent_id,
+        sessionId: input.session_id,
+    };
 }
-// ─── PostToolUse ────────────────────────────────────────────────────
 async function handlePostToolUse(input, client) {
     const toolName = input.tool_name ?? "unknown";
     client.logger.info("lifecycle.post_tool_use", {
@@ -174,17 +114,14 @@ async function handlePostToolUse(input, client) {
         toolName,
         toolResponse: input.tool_response,
     });
-    client.tracer.record("tool.complete", "ok", {
-        attributes: {
-            toolName,
-            toolUseId: input.tool_use_id,
-            ...(0, argus_1.summarizeToolInput)(toolName, input.tool_input),
-            ...(0, argus_1.summarizeToolOutput)(toolName, input.tool_response),
-        },
+    (0, argus_1.complete)(client, {
+        toolName,
+        input: input.tool_input,
+        output: input.tool_response,
+        extraActivityAttributes: { toolUseId: input.tool_use_id },
     });
     return {};
 }
-// ─── PostToolUseFailure ─────────────────────────────────────────────
 async function handlePostToolUseFailure(input, client) {
     const toolName = input.tool_name ?? "unknown";
     client.logger.info("lifecycle.post_tool_use_failure", {
@@ -192,252 +129,142 @@ async function handlePostToolUseFailure(input, client) {
         toolName,
         toolUseId: input.tool_use_id,
     });
-    client.tracer.record("tool.fail", "error", {
-        attributes: {
-            toolName,
-            toolUseId: input.tool_use_id,
-            toolError: typeof input.error === "string"
-                ? input.error.slice(0, 500)
-                : undefined,
-            ...(0, argus_1.summarizeToolInput)(toolName, input.tool_input),
-        },
+    (0, argus_1.fail)(client, {
+        toolName,
+        input: input.tool_input,
+        error: input.error,
+        extraActivityAttributes: { toolUseId: input.tool_use_id },
     });
     return {};
 }
-// ─── UserPromptSubmit ──────────────────────────────────────────────
+async function handlePermissionRequest(input, client) {
+    const toolName = input.tool_name ?? "unknown";
+    client.logger.info("lifecycle.permission_request", {
+        sessionId: input.session_id,
+        toolName,
+        toolInput: input.tool_input,
+    });
+    const result = await (0, argus_1.decideTool)(client, {
+        harness: HARNESS,
+        toolName,
+        toolArgs: input.tool_input,
+        subjectFallback: `session:${input.session_id}`,
+    });
+    if (result.kind === "not_connected") {
+        return permissionRequestFallback("Ory Agent Security not connected — deferring to user");
+    }
+    if (result.kind === "interactive") {
+        return permissionRequestFallback("Interactive tool — deferring to user");
+    }
+    if (result.kind === "fail_open") {
+        return permissionRequestFallback(permissionFailureReason(result.decision));
+    }
+    if (result.kind === "deny") {
+        return permissionRequestDecision("deny", result.denialMessage ?? "Ory permission denied");
+    }
+    if (result.kind === "observe") {
+        return permissionRequestFallback("Ory observe mode — denied by policy, deferring to user");
+    }
+    return permissionRequestDecision("allow", "Ory permission granted");
+}
+function permissionRequestDecision(behavior, reason) {
+    return {
+        hookSpecificOutput: {
+            hookEventName: "PermissionRequest",
+            decision: { behavior },
+            message: reason,
+        },
+    };
+}
+function permissionRequestFallback(reason) {
+    return {
+        hookSpecificOutput: { hookEventName: "PermissionRequest", message: reason },
+    };
+}
+function permissionFailureReason(decision) {
+    if (decision.kind !== "fail_open")
+        return "Ory permission check failed";
+    const { code, message } = decision.error;
+    return code === "network_error" || code === "rate_limited"
+        ? `Ory unavailable (${code}), falling back to user prompt`
+        : `Ory permission check failed: ${message}`;
+}
 async function handleUserPromptSubmit(input, client) {
     client.logger.info("lifecycle.user_prompt_submit", {
         sessionId: input.session_id,
         promptLen: input.prompt?.length,
     });
-    client.tracer.record("user.prompt", "ok", {
+    client.logger.activity("user.prompt", "ok", {
         attributes: { promptLen: input.prompt?.length },
     });
     return {};
 }
-// ─── SubagentStart ─────────────────────────────────────────────────
 async function handleSubagentStart(input, client, deps) {
     const subAgentType = input.subagent_type ?? input.agent_type;
-    const agentId = input.agent_id;
     client.logger.info("lifecycle.subagent_start", {
         sessionId: input.session_id,
         subAgentType,
-        agentId,
+        agentId: input.agent_id,
     });
-    client.tracer.record("subagent.start", "ok", {
-        attributes: { subAgentType, agentId },
+    client.logger.activity("subagent.start", "ok", {
+        attributes: { subAgentType, agentId: input.agent_id },
     });
     if (subAgentType) {
-        await registerSubAgent(subAgentType, client, deps);
-    }
-    else {
-        client.logger.debug("subagent_start.no_type", {
-            message: "SubagentStart event without subagent_type — skipping DCR.",
+        await (0, argus_1.registerSubagent)(client, {
+            harness: HARNESS,
+            subAgentType,
+            perSpawnId: input.agent_id,
+            subAgentGate: deps.subAgentGate,
         });
     }
     return {};
 }
-// ─── SubagentStop ──────────────────────────────────────────────────
 async function handleSubagentStop(input, client) {
+    const subAgentType = input.subagent_type ?? input.agent_type;
     client.logger.info("lifecycle.subagent_stop", {
         sessionId: input.session_id,
-        subAgentType: input.subagent_type ?? input.agent_type,
+        subAgentType,
         agentId: input.agent_id,
     });
-    client.tracer.record("subagent.stop", "ok", {
+    client.logger.activity("subagent.stop", "ok", {
         attributes: {
-            subAgentType: input.subagent_type ?? input.agent_type,
+            subAgentType,
             agentId: input.agent_id,
             responseLen: input.subagent_response?.length,
         },
     });
     return {};
 }
-// ─── Stop ──────────────────────────────────────────────────────────
 async function handleStop(input, client) {
-    client.logger.info("lifecycle.stop", {
-        sessionId: input.session_id,
-    });
-    client.tracer.record("turn.stop", "ok", {
+    client.logger.info("lifecycle.stop", { sessionId: input.session_id });
+    client.logger.activity("turn.stop", "ok", {
         attributes: { responseLen: input.last_assistant_message?.length },
     });
     return {};
 }
-// ─── SessionEnd ────────────────────────────────────────────────────
 async function handleSessionEnd(input, client) {
     client.logger.info("lifecycle.session_end", {
         sessionId: input.session_id,
         reason: input.reason,
     });
-    client.tracer.record("session.end", "ok", {
-        attributes: { reason: input.reason },
-    });
+    client.logger.activity("session.end", "ok", { attributes: { reason: input.reason } });
     return {};
 }
-// ─── PreCompact ────────────────────────────────────────────────────
 async function handlePreCompact(input, client) {
     client.logger.info("lifecycle.pre_compact", {
         sessionId: input.session_id,
         trigger: input.trigger,
     });
-    client.tracer.record("compaction", "ok", {
+    client.logger.activity("compaction", "ok", {
         attributes: { trigger: input.trigger, stage: "pre_compact" },
     });
     return {};
 }
-// ─── PermissionRequest ──────────────────────────────────────────────
-//
-// Continue surfaces a structured permission decision via
-// hookSpecificOutput.decision.{behavior}. Omitting `decision` falls through to
-// Continue's normal user prompt. This event is trace-only on the auth side: it
-// records the audit span and answers allow/deny based on policy, but never
-// hard-blocks the session (the answer is advisory to the user prompt).
-async function handlePermissionRequest(input, client) {
-    const toolName = input.tool_name ?? "unknown";
-    client.logger.info("lifecycle.permission_request", {
-        sessionId: input.session_id,
-        toolName,
-        toolInput: input.tool_input,
-    });
-    // Audit-only mode: omit `decision` so Continue falls through to its normal
-    // user-permission prompt.
-    if ((0, argus_1.resolveConfig)().auditOnly) {
-        return permissionRequestFallback("Audit-only mode — deferring to user");
-    }
-    // Interactive tools: the harness is about to surface UI to the user. Trace
-    // and fall through — Ory shouldn't pre-answer a prompt meant for the human.
-    if ((0, argus_1.isInteractiveTool)(HARNESS, toolName)) {
-        client.tracer.record("user.interaction", "ok", {
-            attributes: { harness: HARNESS, toolName, kind: "permission-request" },
-        });
-        return permissionRequestFallback("Interactive tool — deferring to user");
-    }
-    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: HARNESS,
-            toolName,
-            check: { namespace, object: toolName, relation: "use", ...subject },
-            spanAttributes: { toolName },
-        });
-        if (outcome.kind === "interactive") {
-            return permissionRequestFallback("Interactive tool — deferring to user");
-        }
-        const decision = outcome;
-        if (decision.kind === "fail_open") {
-            const code = decision.error.code;
-            const fallbackReason = code === "network_error" || code === "rate_limited"
-                ? `Ory unavailable (${code}), falling back to user prompt`
-                : `Ory permission check failed: ${decision.error.message}`;
-            return permissionRequestFallback(fallbackReason);
-        }
-        if (decision.kind === "deny") {
-            return permissionRequestDecision("deny", (0, argus_1.formatDenialMessage)({ tool: toolName, subjectId, namespace }));
-        }
-        if (decision.kind === "observe") {
-            // Observe-mode deny: the permission.observe_deny audit span is already
-            // recorded by the gate. Omit `decision` so Continue falls through to
-            // its native user prompt — observe mode must never escalate a
-            // policy-denied tool into an auto-approval.
-            return permissionRequestFallback("Ory observe mode — denied by policy, deferring to user");
-        }
-        return permissionRequestDecision("allow", "Ory permission granted");
-    }
-    catch (err) {
-        const oryErr = err;
-        const fallbackReason = oryErr.code === "network_error" || oryErr.code === "rate_limited"
-            ? `Ory unavailable (${oryErr.code}), falling back to user prompt`
-            : `Ory permission check failed: ${oryErr.message}`;
-        return permissionRequestFallback(fallbackReason);
-    }
-}
-function permissionRequestDecision(behavior, reason) {
-    return {
-        hookSpecificOutput: {
-            hookEventName: "PermissionRequest",
-            decision: { behavior },
-            message: reason,
-        },
-    };
-}
-function permissionRequestFallback(reason) {
-    return {
-        hookSpecificOutput: {
-            hookEventName: "PermissionRequest",
-            message: reason,
-        },
-    };
-}
-// ─── Helpers ────────────────────────────────────────────────────────
-function resolveNamespace() {
-    return process.env.ORY_PERMISSION_NAMESPACE ?? "AgentTools";
-}
-/**
- * Register an OAuth2 identity for a sub-agent and write the
- * `agent → subagent` delegation tuple. Fail-open and written at most once
- * per install.
- */
-async function registerSubAgent(subAgentType, client, deps) {
-    const subAgentGate = deps.subAgentGate ?? argus_1.ensureSubAgentIdentity;
-    let identity;
-    try {
-        identity = await subAgentGate(client, {
-            subAgentType,
-            projectUrl: (0, argus_1.resolveConfig)().projectUrl,
-            harness: HARNESS,
-        });
-    }
-    catch (err) {
-        client.logger.warn("subagent.identity.failed", {
-            subAgentType,
-            message: err instanceof Error ? err.message : String(err),
-        });
-        return;
-    }
-    if (identity.kind !== "dynamic" || !identity.subject)
-        return;
-    await (0, argus_1.writeAgentDelegatesSubagent)(client, identity.subject, subAgentType);
-}
-/**
- * Fallback for the case where a sub-agent invocation appears as a Task/Agent
- * tool call in PreToolUse with a `subagent_type` field on tool_input.
- * registerSubAgent is idempotent so running both this and the dedicated
- * SubagentStart path is harmless.
- */
-async function maybeRegisterSubAgent(toolName, toolInput, client, deps) {
+function subagentType(toolName, toolInput) {
     if (toolName !== "Task" && toolName !== "Agent")
-        return;
-    const subAgentType = typeof toolInput === "object"
-        && toolInput !== null
-        && typeof toolInput.subagent_type === "string"
-        ? toolInput.subagent_type
-        : undefined;
-    if (!subAgentType)
-        return;
-    await registerSubAgent(subAgentType, client, deps);
-}
-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 {};
+        return undefined;
+    if (typeof toolInput !== "object" || toolInput === null)
+        return undefined;
+    const value = toolInput.subagent_type;
+    return typeof value === "string" ? value : undefined;
 }

package/dist/hook.js

@@ -14,6 +14,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const argus_1 = require("@ory/argus");
 const handlers_js_1 = require("./handlers.js");
+const EVENT_FLUSH_TIMEOUT_MS = 750;
+let client;
+async function flushEvents() {
+    try {
+        await client?.flushEvents(EVENT_FLUSH_TIMEOUT_MS);
+    }
+    catch {
+        // The hook decision must not depend on activity delivery.
+    }
+}
 /**
  * Read all of stdin as a string.
  *
@@ -47,7 +57,7 @@ function readStdin() {
     });
 }
 async function main() {
-    const client = argus_1.OryAgentClient.fromEnv("continue");
+    client = argus_1.OryAgentClient.fromEnv("continue");
     const raw = await readStdin();
     let input;
     try {
@@ -55,22 +65,22 @@ async function main() {
     }
     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.decision === "block") {
         process.stdout.write(JSON.stringify(output));
-        await client.tracer.shutdown();
+        await flushEvents();
         process.exit(2);
     }
     if (output.hookSpecificOutput || output.systemMessage) {
         process.stdout.write(JSON.stringify(output));
     }
-    await client.tracer.shutdown();
+    await flushEvents();
     process.exit(0);
 }
-main().catch((err) => {
+main().catch(async (err) => {
     process.stderr.write(`[ory-agent] fatal: ${err}\n`);
+    await flushEvents();
     process.exit(0); // Fail open
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ory/continue",
-  "version": "0.14.0",
+  "version": "1.0.1",
   "description": "Ory plugin for Continue CLI (cn): scaffolding skills, a local Ory instance, and authentication, authorization, and audit for every tool call",
   "license": "Apache-2.0",
   "homepage": "https://ory.com",
@@ -36,8 +36,7 @@
     "agent-security",
     "guardrails",
     "llm",
-    "tracing",
-    "distributed-tracing",
+    "activity-auditing",
     "observability",
     "kratos",
     "keto",
@@ -48,6 +47,10 @@
     "registry": "https://registry.npmjs.org/",
     "provenance": true
   },
+  "reova": {
+    "enabled": true,
+    "endpoint": "https://telemetry.reo.dev/data"
+  },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -63,12 +66,11 @@
   },
   "files": [
     "dist",
-    "!dist/dev",
     "!dist/**/*.tsbuildinfo"
   ],
   "dependencies": {
-    "reo-census": "^1.2.8",
-    "@ory/argus": "0.14.0"
+    "reova": "^0.7.0",
+    "@ory/argus": "1.0.1"
   },
   "engines": {
     "node": ">=22"
@@ -78,7 +80,6 @@
     "clean": "rm -rf dist *.tsbuildinfo",
     "test": "vitest run",
     "test:watch": "vitest",
-    "typecheck": "tsc --noEmit",
-    "dev": "node dist/dev/launcher.js"
+    "typecheck": "tsc --noEmit"
   }
 }