@intutic/clawde 2.3.0 → 2.5.0

package/dist/control-plane.js

@@ -1,7 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ControlPlaneClient = void 0;
+const crypto_1 = require("crypto");
 const errors_1 = require("./errors");
+const toon_1 = require("./toon");
+/** The connector providers `intutic guardrails sources` lists: the ones that are policy sources. */
+const POLICY_SOURCE_PROVIDERS = new Set(['notion', 'confluence', 'github', 'gdrive']);
+/** The coverage report's format names on the route, by the CLI's names. */
+const COVERAGE_FORMATS = { json: 'json', md: 'markdown', csv: 'csv', pdf: 'pdf' };
 /**
  * Control-plane management client — org/team/gateway/credentials
  * administration, as distinct from `ClawdeClient`'s data-plane chat calls.
@@ -13,14 +19,25 @@ const errors_1 = require("./errors");
  * management calls onto `ClawdeClient` would silently need a second base URL
  * on a class whose whole contract today is "one client, one proxy."
  *
- * Every endpoint here is mirrored 1:1 from `tools/cli/src/commands/{org,
- * team,gateway,credentials,settings,whoami}.ts` — the CLI's own already-tested
- * contracts, not re-derived. Endpoints deliberately NOT included: session
- * establishment (`login`/`logout` — an SDK caller supplies `apiKey`
- * directly), and local-environment/terminal concerns (`init`, `doctor`,
- * `install-daemon`, `integrity`, `rollback`, `connect`, `exec`, `start`,
- * `syncContext`, `skill`) that have no meaning for a library embedded in
- * someone else's process.
+ * Every endpoint here comes from the control-plane calls in
+ * `tools/cli/src/commands/*` — the CLI's own already-tested contracts, not
+ * re-derived — and the Python SDK's `control_plane.py` has the same methods
+ * in snake_case. `packages/shared-types/fixtures/control-plane-operations.json`
+ * lists every method with the request it makes and the answer it returns, and
+ * both SDKs' tests run against it, so neither can grow a method the other
+ * lacks. Method names follow one pattern for whatever is added next: a verb
+ * (`list`, `get`, `create`, `update`, `delete`, `rotate…Secret`, `download`,
+ * or the CLI subcommand's own verb, such as `approve` or `promote`), then the
+ * resource.
+ *
+ * Not included: session establishment (`login`/`logout`; an SDK caller
+ * supplies `apiKey` directly, and `ClawdeClient` registers its own session),
+ * the CLI's workspace budget (`ClawdeClient.checkBudget()`), and commands
+ * that act on the machine they run on: `init`, `setup`, `doctor`,
+ * `install-daemon`, `connect`, `disconnect`, `exec`, `start`, `syncContext`,
+ * `rollback`, `enforce`, `rules`, `judge`, `skill` (its loop commands are
+ * here), `sops status`, `guardrails pull`, and `policy
+ * compile|install|snapshot|list-local`.
  *
  * Works unmodified against a self-hosted control plane — there is no
  * SaaS-vs-self-hosted branch anywhere in this file. An open-core user who
@@ -32,9 +49,10 @@ const errors_1 = require("./errors");
  *
  * Auth: the same `apiKey` type `ClawdeClient` accepts — a `vk_` token or a
  * JWT both satisfy `services/control-plane/src/middleware/auth.ts`, which
- * resolves either to an `AuthContext` with a role; endpoints gated
- * `requireRole('OWNER','ADMIN')` server-side reject an under-privileged
- * token exactly as they would for the CLI using the same token.
+ * resolves either to an `AuthContext` with a role. A call the role may not
+ * make throws `ClawdeConnectionError` with the control plane's answer; for a
+ * 403 that names the roles allowed (`detail`), the message is that sentence,
+ * as the CLI prints it.
  */
 class ControlPlaneClient {
     apiKey;
@@ -47,26 +65,41 @@ class ControlPlaneClient {
         this.baseUrl =
             options.baseUrl || process.env.INTUTIC_CONTROL_PLANE_URL || 'https://app.intutic.ai';
     }
-    async request(method, path, body, auth = true) {
-        const headers = { 'Content-Type': 'application/json' };
-        if (auth)
+    async send(method, path, init = {}) {
+        // A form body sets its own multipart content type, boundary included.
+        const headers = init.form ? {} : { 'Content-Type': 'application/json' };
+        if (init.auth !== false)
             headers['Authorization'] = `Bearer ${this.apiKey}`;
-        let res;
         try {
-            res = await fetch(`${this.baseUrl}${path}`, {
+            return await fetch(`${this.baseUrl}${path}`, {
                 method,
                 headers,
-                body: body !== undefined ? JSON.stringify(body) : undefined,
+                body: init.form ?? (init.body !== undefined ? JSON.stringify(init.body) : undefined),
             });
         }
         catch (err) {
             throw new errors_1.ClawdeConnectionError(`Could not reach control plane at ${this.baseUrl}: ${err.message}`);
         }
+    }
+    /**
+     * A JSON call. `answers` lists the error statuses whose body is the answer
+     * rather than a failure: the integrity chain walk answers a break with 409.
+     */
+    async request(method, path, body, auth = true, answers = [], form) {
+        const res = await this.send(method, path, { body, form, auth });
+        const text = await res.text().catch(() => 'Unknown error');
+        if (!res.ok && !answers.includes(res.status))
+            throw controlPlaneFailure(method, path, res.status, text);
+        return (text ? (0, toon_1.unwrapToonEnvelope)(JSON.parse(text)) : undefined);
+    }
+    /** A file download: the body as bytes. Its errors are JSON, as every other call's. */
+    async download(path) {
+        const res = await this.send('GET', path);
         if (!res.ok) {
             const text = await res.text().catch(() => 'Unknown error');
-            throw new errors_1.ClawdeConnectionError(`Control plane ${method} ${path} failed (${res.status}): ${text}`);
+            throw controlPlaneFailure('GET', path, res.status, text);
         }
-        return (await res.json());
+        return new Uint8Array(await res.arrayBuffer());
     }
     /** GET /api/v1/auth/me */
     async whoami() {
@@ -203,6 +236,596 @@ class ControlPlaneClient {
     async unsetProviderCredential(provider) {
         await this.request('DELETE', `/api/v1/workspace/provider-credentials/${encodeURIComponent(provider)}`);
     }
+    /** GET /api/v1/workspace/provider-credentials/:provider/models */
+    async listProviderModels(provider) {
+        return this.request('GET', `/api/v1/workspace/provider-credentials/${encodeURIComponent(provider)}/models`);
+    }
+    // ─── MCP server registry (`intutic mcp`) ───
+    /** GET /api/v1/mcp/servers — every server the workspace's MCP proxies have reported, and the registry-wide policy. */
+    async listMcpServers() {
+        return this.request('GET', '/api/v1/mcp/servers');
+    }
+    /** POST /api/v1/mcp/servers/:serverId/status — approve a server (OWNER, ADMIN). */
+    async approveMcpServer(serverId) {
+        return this.setMcpServerStatus(serverId, 'approved');
+    }
+    /** POST /api/v1/mcp/servers/:serverId/status — block a server (OWNER, ADMIN). */
+    async blockMcpServer(serverId) {
+        return this.setMcpServerStatus(serverId, 'blocked');
+    }
+    /** POST /api/v1/mcp/servers/:serverId/status — return a server to the approval queue (OWNER, ADMIN). */
+    async resetMcpServer(serverId) {
+        return this.setMcpServerStatus(serverId, 'candidate');
+    }
+    /** POST /api/v1/mcp/servers/:serverId/tools — switch one tool on (OWNER, ADMIN). */
+    async enableMcpTool(serverId, tool) {
+        return this.request('POST', `/api/v1/mcp/servers/${seg(serverId)}/tools`, { tool, enabled: true });
+    }
+    /** POST /api/v1/mcp/servers/:serverId/tools — switch one tool off (OWNER, ADMIN). */
+    async disableMcpTool(serverId, tool) {
+        return this.request('POST', `/api/v1/mcp/servers/${seg(serverId)}/tools`, { tool, enabled: false });
+    }
+    async setMcpServerStatus(serverId, status) {
+        return this.request('POST', `/api/v1/mcp/servers/${seg(serverId)}/status`, { status });
+    }
+    // ─── Notification rules (`intutic notifications`) ───
+    /** GET /api/v1/notifications/rules */
+    async listNotificationRules() {
+        const res = await this.request('GET', '/api/v1/notifications/rules');
+        return res.rules ?? [];
+    }
+    /**
+     * POST /api/v1/notifications/rules. A webhook rule comes back with its
+     * `signingSecret`, which is not shown again.
+     */
+    async createNotificationRule(rule) {
+        return this.request('POST', '/api/v1/notifications/rules', rule);
+    }
+    /**
+     * PUT /api/v1/notifications/rules/:ruleId — only the fields given change.
+     * A switch to the webhook channel comes back with the new `signingSecret`.
+     */
+    async updateNotificationRule(ruleId, changes) {
+        return this.request('PUT', `/api/v1/notifications/rules/${seg(ruleId)}`, changes);
+    }
+    /** DELETE /api/v1/notifications/rules/:ruleId */
+    async deleteNotificationRule(ruleId) {
+        await this.request('DELETE', `/api/v1/notifications/rules/${seg(ruleId)}`);
+    }
+    /** POST /api/v1/notifications/rules/:ruleId/signing-secret — deliveries are signed with the new secret from now on. */
+    async rotateNotificationRuleSecret(ruleId) {
+        return this.request('POST', `/api/v1/notifications/rules/${seg(ruleId)}/signing-secret`);
+    }
+    // ─── SIEM export (`intutic siem`) ───
+    /** GET /api/v1/siem/destinations — the destinations and the event sources they can receive. */
+    async listSiemDestinations() {
+        return this.request('GET', '/api/v1/siem/destinations');
+    }
+    /** GET /api/v1/siem/destinations/:destinationId */
+    async getSiemDestination(destinationId) {
+        return this.request('GET', `/api/v1/siem/destinations/${seg(destinationId)}`);
+    }
+    /** The event sources a destination can receive; `defaults` are the ones an empty `sourceTables` means. */
+    async listSiemSources() {
+        return (await this.listSiemDestinations()).sources;
+    }
+    /**
+     * POST /api/v1/siem/destinations (OWNER, ADMIN). The control plane refuses
+     * a destination that points at an internal address. A webhook destination
+     * comes back with its `signingSecret`, which is not shown again.
+     */
+    async createSiemDestination(destination) {
+        return this.request('POST', '/api/v1/siem/destinations', destination);
+    }
+    /** PUT /api/v1/siem/destinations/:destinationId (OWNER, ADMIN) — only the fields given change. */
+    async updateSiemDestination(destinationId, changes) {
+        return this.request('PUT', `/api/v1/siem/destinations/${seg(destinationId)}`, changes);
+    }
+    /** DELETE /api/v1/siem/destinations/:destinationId (OWNER, ADMIN) — deactivates it; `updateSiemDestination(id, { isActive: true })` turns it back on. */
+    async deleteSiemDestination(destinationId) {
+        await this.request('DELETE', `/api/v1/siem/destinations/${seg(destinationId)}`);
+    }
+    /** POST /api/v1/siem/destinations/:destinationId/signing-secret (OWNER, ADMIN) */
+    async rotateSiemDestinationSecret(destinationId) {
+        return this.request('POST', `/api/v1/siem/destinations/${seg(destinationId)}/signing-secret`);
+    }
+    // ─── Usage (`intutic usage`) ───
+    //
+    // OWNER, ADMIN and EM see the whole workspace; anyone else their own calls
+    // (`scope: 'self'`). `getTeamUsage` is refused below EM.
+    /** GET /api/v1/usage/members */
+    async getMemberUsage(options = {}) {
+        return this.request('GET', `/api/v1/usage/members${usagePeriod(options)}`);
+    }
+    /** GET /api/v1/usage/teams — per SCIM group. */
+    async getTeamUsage(options = {}) {
+        return this.request('GET', `/api/v1/usage/teams${usagePeriod(options)}`);
+    }
+    /** GET /api/v1/usage/branches */
+    async getBranchUsage(options = {}) {
+        return this.request('GET', `/api/v1/usage/branches${usagePeriod(options)}`);
+    }
+    /** GET /api/v1/usage/commits */
+    async getCommitUsage(options = {}) {
+        return this.request('GET', `/api/v1/usage/commits${usagePeriod(options)}`);
+    }
+    /** GET /api/v1/usage/pull-requests */
+    async getPullRequestUsage(options = {}) {
+        return this.request('GET', `/api/v1/usage/pull-requests${usagePeriod(options)}`);
+    }
+    /** POST /api/v1/usage/pull-requests/refresh — look the branches up on GitHub now (OWNER, ADMIN, EM). */
+    async refreshPullRequestUsage() {
+        return this.request('POST', '/api/v1/usage/pull-requests/refresh');
+    }
+    // ─── AI inventory (`intutic inventory`) ───
+    //
+    // OWNER, ADMIN and EM see every machine; a DEVELOPER only their own.
+    /** GET /api/v1/inventory/summary */
+    async getInventorySummary() {
+        return (await this.request('GET', '/api/v1/inventory/summary')).data;
+    }
+    /** GET /api/v1/inventory/devices — one row per machine. */
+    async listInventoryDevices() {
+        return this.listData('/api/v1/inventory/devices');
+    }
+    /** GET /api/v1/inventory/harnesses */
+    async listInventoryHarnesses(filters = {}) {
+        return this.listData(`/api/v1/inventory/harnesses${inventoryQuery(filters)}`);
+    }
+    /** GET /api/v1/inventory/mcp-servers */
+    async listInventoryMcpServers(filters = {}) {
+        return this.listData(`/api/v1/inventory/mcp-servers${inventoryQuery(filters)}`);
+    }
+    /** GET /api/v1/inventory/skills */
+    async listInventorySkills(filters = {}) {
+        return this.listData(`/api/v1/inventory/skills${inventoryQuery(filters)}`);
+    }
+    /** GET /api/v1/inventory/disconnects — machines that ran `intutic disconnect`, newest first (default 100, at most 500). */
+    async listInventoryDisconnects(options = {}) {
+        return this.listData(`/api/v1/inventory/disconnects${query({ limit: options.limit })}`);
+    }
+    /** GET /api/v1/inventory/harnesses?format=csv — the CSV the dashboard downloads. */
+    async downloadInventoryHarnessesCsv(filters = {}) {
+        return this.download(`/api/v1/inventory/harnesses${inventoryQuery(filters, true)}`);
+    }
+    /** GET /api/v1/inventory/mcp-servers?format=csv */
+    async downloadInventoryMcpServersCsv(filters = {}) {
+        return this.download(`/api/v1/inventory/mcp-servers${inventoryQuery(filters, true)}`);
+    }
+    async listData(path) {
+        return (await this.request('GET', path)).data ?? [];
+    }
+    // ─── Compliance (`intutic compliance`) ───
+    /** GET /api/v1/compliance/frameworks/:frameworkId/coverage — `eu_ai_act`, `iso_42001`, `nist_ai_rmf` or `mitre_atlas`. */
+    async getFrameworkCoverage(frameworkId) {
+        return this.request('GET', `/api/v1/compliance/frameworks/${seg(frameworkId)}/coverage`);
+    }
+    /**
+     * GET /api/v1/compliance/frameworks/:frameworkId/coverage?format= — the
+     * report as a file. Unsigned: the signed copies are the ones sealed in the
+     * evidence archive.
+     */
+    async downloadFrameworkCoverage(frameworkId, format) {
+        const routeFormat = COVERAGE_FORMATS[format];
+        if (!routeFormat)
+            throw new Error(`format must be one of ${Object.keys(COVERAGE_FORMATS).join(', ')}, got "${format}"`);
+        return this.download(`/api/v1/compliance/frameworks/${seg(frameworkId)}/coverage${query({ format: routeFormat })}`);
+    }
+    /** POST /api/v1/compliance/soc2-collect (OWNER, ADMIN) — run a fresh evidence collection and seal it. */
+    async collectEvidence(options = {}) {
+        return this.request('POST', '/api/v1/compliance/soc2-collect', defined({ periodStart: options.periodStart, periodEnd: options.periodEnd }));
+    }
+    /** GET /api/v1/compliance/soc2-export/:runId (OWNER, ADMIN) — a stored archive, as the file. Check it with `verifyEvidenceArchive`. */
+    async downloadEvidence(runId) {
+        return this.download(`/api/v1/compliance/soc2-export/${seg(runId)}`);
+    }
+    /**
+     * GET /.well-known/intutic-trace-signing.json — the published signing keys,
+     * fetched without credentials. `verifyEvidenceArchive` takes them.
+     */
+    async getSigningKeys() {
+        return this.request('GET', '/.well-known/intutic-trace-signing.json', undefined, false);
+    }
+    // ─── Gate liveness and the GitHub webhook ───
+    /** GET /api/v1/governance/gate-liveness (OWNER, ADMIN, EM) — whether each installed harness's gate is reporting. */
+    async getGateLiveness() {
+        return this.request('GET', '/api/v1/governance/gate-liveness');
+    }
+    /** GET /api/v1/integrations/github/webhook (OWNER, ADMIN) — the payload URL; never the secret. */
+    async getGithubWebhook() {
+        return this.request('GET', '/api/v1/integrations/github/webhook');
+    }
+    /**
+     * POST /api/v1/integrations/github/webhook/secret (OWNER, ADMIN) — make the
+     * webhook, or replace its secret. Deliveries signed with an earlier secret
+     * are refused from then on.
+     */
+    async rotateGithubWebhookSecret() {
+        return this.request('POST', '/api/v1/integrations/github/webhook/secret');
+    }
+    // ─── Policy guardrails (`intutic guardrails`) ───
+    /** GET /api/v1/connectors — the workspace's policy sources (Notion, Confluence, GitHub, Google Drive). */
+    async listPolicySources() {
+        const res = await this.request('GET', '/api/v1/connectors');
+        return (res.items ?? []).filter((c) => POLICY_SOURCE_PROVIDERS.has(c.provider));
+    }
+    /** POST /api/v1/connectors */
+    async addPolicySource(source) {
+        return this.request('POST', '/api/v1/connectors', { config: {}, ...source });
+    }
+    /** POST /api/v1/connectors/:connectorId/sync */
+    async syncPolicySource(connectorId) {
+        return this.request('POST', `/api/v1/connectors/${seg(connectorId)}/sync`, {});
+    }
+    /** GET /api/v1/policy-guardrails/documents */
+    async listPolicyDocuments() {
+        return (await this.request('GET', `${GUARDRAILS}/documents`)).documents ?? [];
+    }
+    /** GET /api/v1/policy-guardrails/documents/:docId — passages, clauses and extraction runs. */
+    async getPolicyDocument(docId) {
+        return (await this.request('GET', `${GUARDRAILS}/documents/${seg(docId)}`)).document;
+    }
+    /** POST /api/v1/policy-guardrails/documents/:docId/extract — propose guardrails from the document's clauses. */
+    async extractPolicyDocument(docId, options = {}) {
+        const res = await this.request('POST', `${GUARDRAILS}/documents/${seg(docId)}/extract`, {
+            llm: options.llm ?? true,
+        });
+        return res.result;
+    }
+    /** GET /api/v1/policy-guardrails/coverage?token= — the passages that mention a tool or action, and the guardrails on them. */
+    async getGuardrailCoverage(token) {
+        return (await this.request('GET', `${GUARDRAILS}/coverage${query({ token })}`)).coverage;
+    }
+    /** GET /api/v1/policy-guardrails/search?q= — full-text search over live passages, best match first. */
+    async searchPolicyPassages(text) {
+        return (await this.request('GET', `${GUARDRAILS}/search${query({ q: text })}`)).search;
+    }
+    /** GET /api/v1/policy-guardrails/impact — what a change to a document or a passage reaches. Name one of them. */
+    async getGuardrailImpact(seed) {
+        const path = `${GUARDRAILS}/impact${query({ docId: seed.docId, passageId: seed.passageId })}`;
+        return (await this.request('GET', path)).impact;
+    }
+    /** GET /api/v1/policy-guardrails/duplicates — overlapping passages and rules cited more than once. */
+    async listGuardrailDuplicates(options = {}) {
+        const path = `${GUARDRAILS}/duplicates${query({ minJaccard: options.minJaccard })}`;
+        return (await this.request('GET', path)).duplicates;
+    }
+    /** GET /api/v1/policy-guardrails/guardrails */
+    async listGuardrails(filters = {}) {
+        const path = `${GUARDRAILS}/guardrails${query({
+            status: filters.status,
+            target: filters.target,
+            provenance: filters.provenance,
+            docId: filters.docId,
+            limit: filters.limit,
+        })}`;
+        return (await this.request('GET', path)).guardrails ?? [];
+    }
+    /** GET /api/v1/policy-guardrails/guardrails/:guardrailId */
+    async getGuardrail(guardrailId) {
+        return (await this.request('GET', `${GUARDRAILS}/guardrails/${seg(guardrailId)}`)).guardrail;
+    }
+    /** GET /api/v1/policy-guardrails/guardrails/:guardrailId/readiness — whether a SHADOW guardrail's evidence clears promotion. */
+    async getGuardrailReadiness(guardrailId) {
+        const res = await this.request('GET', `${GUARDRAILS}/guardrails/${seg(guardrailId)}/readiness`);
+        return res.readiness;
+    }
+    /** POST …/guardrails/:guardrailId/approve-shadow — into SHADOW: distributed as warn, measuring, enforcing nothing. */
+    async approveGuardrailShadow(guardrailId) {
+        return this.transitionGuardrail(guardrailId, 'approve-shadow', {});
+    }
+    /**
+     * POST …/guardrails/:guardrailId/promote — into ENFORCING. Refused with a
+     * 409 until the shadow evidence clears the thresholds; a guardrail that
+     * never fired needs `acknowledgeNoTraffic`.
+     */
+    async promoteGuardrail(guardrailId, options = {}) {
+        return this.transitionGuardrail(guardrailId, 'promote', { acknowledgeNoTraffic: options.acknowledgeNoTraffic === true });
+    }
+    /** POST …/guardrails/:guardrailId/reject — recorded with the reason. */
+    async rejectGuardrail(guardrailId, reason) {
+        return this.transitionGuardrail(guardrailId, 'reject', { reason });
+    }
+    /** POST …/guardrails/:guardrailId/retire — gone from every rule endpoint on the next poll. */
+    async retireGuardrail(guardrailId) {
+        return this.transitionGuardrail(guardrailId, 'retire', {});
+    }
+    /** POST …/guardrails/:guardrailId/reconfirm — re-confirm a stale citation against a live passage. */
+    async reconfirmGuardrail(guardrailId) {
+        return this.transitionGuardrail(guardrailId, 'reconfirm', {});
+    }
+    /**
+     * POST /api/v1/policy-guardrails/guardrails (OWNER, ADMIN) — an authored
+     * guardrail, created PROPOSED. An IR a check refuses is a 400 naming the
+     * check.
+     */
+    async createGuardrail(guardrail) {
+        return this.request('POST', `${GUARDRAILS}/guardrails`, guardrail);
+    }
+    /**
+     * PUT /api/v1/policy-guardrails/guardrails/:guardrailId (OWNER, ADMIN). A
+     * changed IR creates the next version (`forked`), PROPOSED with no
+     * evidence; a name or description edit keeps the evidence.
+     */
+    async updateGuardrail(guardrailId, changes) {
+        return this.request('PUT', `${GUARDRAILS}/guardrails/${seg(guardrailId)}`, changes);
+    }
+    /** DELETE /api/v1/policy-guardrails/guardrails/:guardrailId (OWNER, ADMIN) — retires it; its history is kept. */
+    async deleteGuardrail(guardrailId) {
+        return this.request('DELETE', `${GUARDRAILS}/guardrails/${seg(guardrailId)}`);
+    }
+    /** POST …/guardrails/:guardrailId/replay — what the guardrail would have done on captured traffic. */
+    async replayGuardrail(guardrailId) {
+        return (await this.request('POST', `${GUARDRAILS}/guardrails/${seg(guardrailId)}/replay`, {})).replay;
+    }
+    /** GET /api/v1/policy-guardrails/conflicts — live guardrails and front-matter rules that contradict each other. */
+    async listGuardrailConflicts() {
+        return (await this.request('GET', `${GUARDRAILS}/conflicts`)).conflicts ?? [];
+    }
+    async transitionGuardrail(guardrailId, action, body) {
+        return this.request('POST', `${GUARDRAILS}/guardrails/${seg(guardrailId)}/${action}`, body);
+    }
+    // ─── Held decisions and loop runs (`intutic decision`, `intutic loop`) ───
+    /** POST /api/v1/decisions/:holdId/review (OWNER, ADMIN, EM) — approve a held call. */
+    async approveDecision(holdId, options = {}) {
+        return this.request('POST', `/api/v1/decisions/${seg(holdId)}/review`, defined({ action: 'approve', reason: options.reason }));
+    }
+    /** POST /api/v1/decisions/:holdId/review (OWNER, ADMIN, EM) — reject a held call. */
+    async rejectDecision(holdId, options = {}) {
+        return this.request('POST', `/api/v1/decisions/${seg(holdId)}/review`, defined({ action: 'reject', reason: options.reason }));
+    }
+    /**
+     * POST /api/v1/loops/start — register a loop run. Send its id with the run's
+     * requests (`INTUTIC_LOOP_RUN_ID`, as `intutic loop exec` sets it) so the
+     * proxy files them under it.
+     */
+    async startLoopRun(name, options = {}) {
+        const body = defined({ name, budgetLimitUsd: options.budgetLimitUsd, sops: options.sops, autoJudge: options.autoJudge });
+        return (await this.request('POST', '/api/v1/loops/start', body)).loop;
+    }
+    /** GET /api/v1/loops/:loopRunId */
+    async getLoopRun(loopRunId) {
+        return (await this.request('GET', `/api/v1/loops/${seg(loopRunId)}`)).loop;
+    }
+    /** GET /api/v1/loops */
+    async listLoopRuns() {
+        return (await this.request('GET', '/api/v1/loops')).loops ?? [];
+    }
+    /** POST /api/v1/loops/:loopRunId/complete — `outcome` records how the run ended. */
+    async completeLoopRun(loopRunId, options = {}) {
+        const body = options.outcome === undefined ? undefined : { outcome: options.outcome };
+        return this.request('POST', `/api/v1/loops/${seg(loopRunId)}/complete`, body);
+    }
+    /** POST /api/v1/loops/:loopRunId/kill */
+    async killLoopRun(loopRunId) {
+        return this.request('POST', `/api/v1/loops/${seg(loopRunId)}/kill`);
+    }
+    /** POST /api/v1/loops/:loopRunId/review (OWNER, ADMIN, EM) — approve a run held for review; it is ACTIVE again. */
+    async approveLoopRun(loopRunId, options = {}) {
+        return this.request('POST', `/api/v1/loops/${seg(loopRunId)}/review`, defined({ action: 'approve', note: options.note }));
+    }
+    /** POST /api/v1/loops/:loopRunId/review (OWNER, ADMIN, EM) — reject a run held for review; it is KILLED. */
+    async rejectLoopRun(loopRunId, options = {}) {
+        return this.request('POST', `/api/v1/loops/${seg(loopRunId)}/review`, defined({ action: 'reject', note: options.note }));
+    }
+    // ─── Findings (`intutic findings`) ───
+    /** GET /api/v1/findings — detector findings, newest first. */
+    async listFindings(filters = {}) {
+        const path = `/api/v1/findings${query({
+            unadjudicated: filters.unadjudicated ? 'true' : undefined,
+            detector_id: filters.detectorId,
+            limit: filters.limit,
+        })}`;
+        return (await this.request('GET', path)).findings ?? [];
+    }
+    /** POST /api/v1/findings/:findingId/adjudicate — the ruling is recorded under the key's member. */
+    async adjudicateFinding(findingId, outcome, options = {}) {
+        return this.request('POST', `/api/v1/findings/${seg(findingId)}/adjudicate`, defined({ outcome, note: options.note }));
+    }
+    /** GET /api/v1/findings/stats — false-positive rate per detector, over adjudicated findings. */
+    async getFindingStats() {
+        return this.request('GET', '/api/v1/findings/stats');
+    }
+    /** GET /api/v1/findings/response-echo/report */
+    async getResponseEchoReport(options = {}) {
+        return this.request('GET', `/api/v1/findings/response-echo/report${query({ since: options.since, until: options.until })}`);
+    }
+    // ─── Governance incidents (`intutic incidents`) ───
+    //
+    // OWNER, ADMIN and EM only: incidents carry tool arguments and DLP reasons.
+    /** GET /api/v1/incidents — ranked by review priority; filter by status, severity and type. */
+    async listIncidents(filters = {}) {
+        const path = `/api/v1/incidents${query({
+            status: filters.status,
+            severity: filters.severity,
+            type: filters.type,
+            page: filters.page,
+            limit: filters.limit,
+        })}`;
+        return this.request('GET', path);
+    }
+    /** GET /api/v1/incidents/:incidentId */
+    async getIncident(incidentId) {
+        return (await this.request('GET', `/api/v1/incidents/${seg(incidentId)}`)).data;
+    }
+    // ─── Traces (`intutic traces`) ───
+    /** GET /api/v1/traces — newest first. */
+    async listTraces(filters = {}) {
+        const path = `/api/v1/traces${query({
+            limit: filters.limit,
+            offset: filters.offset,
+            since: filters.since,
+            enforcement: filters.enforcement,
+            model: filters.model,
+        })}`;
+        return this.request('GET', path);
+    }
+    /** GET /api/v1/traces/:traceId */
+    async getTrace(traceId) {
+        return this.request('GET', `/api/v1/traces/${seg(traceId)}`);
+    }
+    // ─── Trace integrity (`intutic integrity`) ───
+    /** GET /api/v1/integrity/roots — the sealed trace roots. */
+    async listIntegrityRoots(options = {}) {
+        return this.request('GET', `/api/v1/integrity/roots${query({ loopRunId: options.loopRunId })}`);
+    }
+    /** GET /api/v1/integrity/roots/:rootId — the root, its signature and its leaves. */
+    async getIntegrityRoot(rootId) {
+        return this.request('GET', `/api/v1/integrity/roots/${seg(rootId)}`);
+    }
+    /** POST /api/v1/integrity/roots/:rootId/recompute — re-derive the root from the stored traces. */
+    async recomputeIntegrityRoot(rootId) {
+        return this.request('POST', `/api/v1/integrity/roots/${seg(rootId)}/recompute`, {});
+    }
+    /** GET /api/v1/integrity/chain — the root chain walk; `intact: false` lists the breaks. */
+    async getIntegrityChain() {
+        return this.request('GET', '/api/v1/integrity/chain', undefined, true, [409]);
+    }
+    /** GET /api/v1/integrity/config-chain — the harness config snapshot chain walk. */
+    async getIntegrityConfigChain() {
+        return this.request('GET', '/api/v1/integrity/config-chain', undefined, true, [409]);
+    }
+    // ─── Compliance policies and WASM rules (`intutic policy`) ───
+    /** GET /api/v1/policies */
+    async listPolicies() {
+        return (await this.request('GET', '/api/v1/policies')).policies ?? [];
+    }
+    /** POST /api/v1/policies/:policyId/enable */
+    async enablePolicy(policyId) {
+        return this.request('POST', `/api/v1/policies/${seg(policyId)}/enable`);
+    }
+    /** POST /api/v1/policies/:policyId/disable */
+    async disablePolicy(policyId) {
+        return this.request('POST', `/api/v1/policies/${seg(policyId)}/disable`);
+    }
+    /** POST /api/v1/policies/:policyId/rollback */
+    async rollbackPolicy(policyId, version) {
+        return this.request('POST', `/api/v1/policies/${seg(policyId)}/rollback`, { version });
+    }
+    /**
+     * GET /api/v1/rule-candidates/:candidateId/source — the source of record a
+     * candidate's bundle must be compiled from. A source that does not hash to
+     * the `sourceSha256` served with it is refused (`ClawdeConnectionError`):
+     * something between the control plane and this process changed it.
+     */
+    async getRuleCandidateSource(candidateId) {
+        const res = await this.request('GET', `/api/v1/rule-candidates/${seg(candidateId)}/source`);
+        const local = (0, crypto_1.createHash)('sha256').update(res.source, 'utf8').digest('hex');
+        const stated = res.sourceSha256.toLowerCase();
+        if (local !== stated) {
+            throw new errors_1.ClawdeConnectionError(`The served source hashes to ${local}, not the ${stated} the control plane states.`);
+        }
+        return { ...res, sourceSha256: stated };
+    }
+    /**
+     * POST /api/v1/rule-candidates/:candidateId/bundle (OWNER, ADMIN) — upload
+     * a compiled rule with the hash of the source it was compiled from. The
+     * control plane runs its gates; `accepted` says whether the rule went into
+     * shadow, and `gates` why.
+     */
+    async uploadRuleCandidateBundle(candidateId, wasm, sourceSha256, options = {}) {
+        const form = new FormData();
+        form.append('file', new Blob([new Uint8Array(wasm)], { type: 'application/wasm' }), options.fileName ?? 'rule.wasm');
+        form.append('source_sha256', sourceSha256);
+        return this.request('POST', `/api/v1/rule-candidates/${seg(candidateId)}/bundle`, undefined, true, [], form);
+    }
+    /** POST /api/v1/wasm-rules/:ruleId/replay — what a rule would have done on sampled traffic, without enforcing. */
+    async replayWasmRule(ruleId, options = {}) {
+        return this.request('POST', `/api/v1/wasm-rules/${seg(ruleId)}/replay`, defined({ limit: options.limit, since: options.since }));
+    }
+    // ─── SOPs (`intutic sops`) ───
+    /** GET /api/v1/sops */
+    async listSops(options = {}) {
+        return (await this.request('GET', `/api/v1/sops${query({ limit: options.limit })}`)).items ?? [];
+    }
+    /** GET /api/v1/sops/:sopId */
+    async getSop(sopId) {
+        return this.request('GET', `/api/v1/sops/${seg(sopId)}`);
+    }
+    /** POST /api/v1/sops — one workspace SOP; `markdown_content` without front matter. */
+    async createSop(sop) {
+        return this.request('POST', '/api/v1/sops', sop);
+    }
+    /** GET /api/v1/workspace/org-sops — the org-wide SOP floors of the key's org. */
+    async listOrgSops() {
+        return this.listData('/api/v1/workspace/org-sops');
+    }
+    /** POST /api/v1/workspace/org-sops — a mandatory org-wide floor (OWNER, ADMIN of a workspace in the org). */
+    async createOrgSop(sop) {
+        return this.request('POST', '/api/v1/workspace/org-sops', sop);
+    }
+    /** DELETE /api/v1/workspace/org-sops/:orgSopId — answers 404 both for no such SOP and for a member without admin access. */
+    async deleteOrgSop(orgSopId) {
+        await this.request('DELETE', `/api/v1/workspace/org-sops/${seg(orgSopId)}`);
+    }
+    // ─── Key attenuation, cost prediction, routing ───
+    /**
+     * POST /api/v1/attenuate — a child key narrowed to a subset of the parent
+     * key's capabilities. The child key is in the response once and never
+     * stored.
+     */
+    async attenuateKey(parentKeyId, requestedCaps, options = {}) {
+        return this.request('POST', '/api/v1/attenuate', defined({ parentKeyId, requestedCaps, ttlSeconds: options.ttlSeconds }));
+    }
+    /** GET /api/v1/attenuate/chain/:chainId (OWNER, ADMIN) — the delegation lineage. */
+    async getAttenuationChain(chainId) {
+        return (await this.request('GET', `/api/v1/attenuate/chain/${seg(chainId)}`)).chain ?? [];
+    }
+    /** POST /api/v1/predict-cost — estimate a call's cost before it runs. Size the input with a token count or the text. */
+    async predictCost(params) {
+        return this.request('POST', '/api/v1/predict-cost', params);
+    }
+    /** GET /api/v1/routing/mirror-adoption-report — how a mirror-tested candidate model compared. Reported only; changes nothing. */
+    async getMirrorAdoptionReport(candidateModel) {
+        return this.request('GET', `/api/v1/routing/mirror-adoption-report${query({ candidateModel })}`);
+    }
 }
 exports.ControlPlaneClient = ControlPlaneClient;
+const GUARDRAILS = '/api/v1/policy-guardrails';
+const seg = encodeURIComponent;
+/** A query string of the parameters that are set, with its `?`; empty when none is. */
+function query(params) {
+    const q = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined)
+            q.set(key, String(value));
+    }
+    const s = q.toString();
+    return s ? `?${s}` : '';
+}
+function usagePeriod(options) {
+    return query({ period: options.period ?? 'monthly' });
+}
+function inventoryQuery(filters, csv = false) {
+    return query({
+        status: filters.status,
+        harness: filters.harness,
+        device: filters.device,
+        q: filters.search,
+        format: csv ? 'csv' : undefined,
+    });
+}
+/** The object without its undefined members, which is also what JSON sends. */
+function defined(body) {
+    return Object.fromEntries(Object.entries(body).filter(([, v]) => v !== undefined));
+}
+/**
+ * The error a failed call throws. A 403 carries the control plane's `detail`
+ * when it gives one (a role guard names the roles that may make the call), so
+ * the message says which role can, as the CLI's does.
+ */
+function controlPlaneFailure(method, path, status, text) {
+    if (status === 403) {
+        try {
+            const body = JSON.parse(text);
+            if (typeof body.detail === 'string') {
+                return new errors_1.ClawdeConnectionError(`Control plane ${method} ${path} refused (403): ${body.detail}`);
+            }
+        }
+        catch {
+            // Not JSON: the raw answer below.
+        }
+    }
+    return new errors_1.ClawdeConnectionError(`Control plane ${method} ${path} failed (${status}): ${text}`);
+}
 //# sourceMappingURL=control-plane.js.map