osuite 2.8.0 → 2.9.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 DashClaw
+Copyright (c) 2026 Osuite
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,4 +1,4 @@
-# OSuite SDK (v2.8.0)
+# OSuite SDK (v2.9.0)
 
 **Minimal governance runtime for AI agents.**
 
@@ -70,9 +70,9 @@ claw.update_outcome(action_id, status="completed")
 
 ---
 
-## SDK Surface Area (v2.5.0)
+## SDK Surface Area
 
-The v2 SDK exposes **45 methods** optimized for stability and zero-overhead governance:
+The v2 SDK exposes the core governance loop plus first-class PCAA, replay, proof, and evidence helpers:
 
 ### Core Runtime
 - `guard(context)` -- Policy evaluation ("Can I do X?"). Returns `risk_score` (server-computed) and `agent_risk_score` (raw agent value)
@@ -88,6 +88,60 @@ The v2 SDK exposes **45 methods** optimized for stability and zero-overhead gove
 - `resolveOpenLoop(loopId, status, res)` -- Resolve pending loops.
 - `getSignals()` -- Get current risk signals across all agents.
 
+### Proof And Attestation
+- `GET /api/governance/proof` -- Return the operator-facing governance proof snapshot.
+- `GET /api/governance/proof?format=bundle` -- Return the machine-readable organization proof bundle (`dc.proof.v1`).
+- `GET /api/governance/proof?action_id=<id>&format=bundle` -- Return the machine-readable action proof bundle (`dc.proof.v1`).
+- `POST /api/governance/proof/verify` -- Verify one action attestation against the canonical action digest and stored wallet material.
+- `getActionTrace(actionId)` -- Fetch replay traces, assumptions, loops, and root-cause indicators for one action.
+- `getGovernanceProof({ actionId, format })` -- Read proof snapshots through the SDK instead of hand-building URLs.
+- `getGovernanceProofBundle({ actionId })` -- Fetch machine-readable PCAA / proof bundles for an org or one action.
+- `verifyGovernanceProof(actionId)` -- Verify attestation/proof integrity and return structured checks.
+- `getComplianceEvidence({ window })` -- Pull live evidence aggregates for compliance and PCAA health.
+- `exportProof({ actionId, bundleId })` -- Export the portable verifier-facing proof package.
+- `getPcaaHealth({ window })` -- Compute checkpoint coverage, approval trigger rate, and evidence completion.
+- `getPcaaAction(actionId)` -- Fetch one action's replay/proof/export bundle and derive checkpoint states.
+- `events()` -- Subscribe to live approval and governance events over SSE.
+- `PCAA_CHECKPOINTS` / `buildPcaaCheckpointStates(...)` -- Reuse the portable checkpoint contract in your own tooling.
+
+Example:
+
+```bash
+curl -H "x-api-key: $DASHCLAW_API_KEY" \
+  "$DASHCLAW_BASE_URL/api/governance/proof?format=bundle"
+```
+
+Bundle verification example:
+
+```bash
+curl -X POST \
+  -H "content-type: application/json" \
+  -H "x-api-key: $DASHCLAW_API_KEY" \
+  -d '{"action_id":"act_123"}' \
+  "$DASHCLAW_BASE_URL/api/governance/proof/verify"
+```
+
+PCAA health example:
+
+```javascript
+const health = await claw.getPcaaHealth({ window: '30d' });
+console.log(health.checkpointCoverage);   // 0-100
+console.log(health.approvalRate);         // 0-100
+console.log(health.evidenceCompletion);   // 0-100
+```
+
+PCAA replay example:
+
+```javascript
+const pcaa = await claw.getPcaaAction('act_123');
+console.log(pcaa.checkpoints);
+// [
+//   { id: 'pre_action_admissibility', status: 'complete', value: 'require_approval' },
+//   { id: 'action_open', status: 'complete', value: 'act_123' },
+//   ...
+// ]
+```
+
 ### Swarm & Connectivity
 - `heartbeat(status, metadata)` -- Report agent presence and health.
 - `reportConnections(connections)` -- Report active provider connections.

package/cli.js

@@ -14,12 +14,11 @@ Usage:
   osuite deny <actionId> [--reason "Outside change window"]
 
 Environment:
-  DASHCLAW_BASE_URL   Required, your OSuite base URL
-  DASHCLAW_API_KEY    Required, admin API key for approval operations
-  DASHCLAW_AGENT_ID   Optional, defaults to "osuite-cli"
-
-Compatibility:
-  The legacy "dashclaw" binary name is still available as an alias in this package.
+  OSUITE_BASE_URL     Required, your OSuite base URL
+  OSUITE_URL          Optional fallback for hosted/base URL
+  NEXTAUTH_URL        Optional fallback when reusing app env files
+  OSUITE_API_KEY      Required, admin API key for approval operations
+  OSUITE_AGENT_ID     Optional, defaults to "osuite-cli"
 `);
 }
 
@@ -47,12 +46,16 @@ function parseArgs(argv) {
 }
 
 function getClient() {
-  const baseUrl = process.env.DASHCLAW_BASE_URL;
-  const apiKey = process.env.DASHCLAW_API_KEY;
-  const agentId = process.env.DASHCLAW_AGENT_ID || 'osuite-cli';
+  const baseUrl = process.env.OSUITE_BASE_URL
+    || process.env.DASHCLAW_BASE_URL
+    || process.env.OSUITE_URL
+    || process.env.DASHCLAW_URL
+    || process.env.NEXTAUTH_URL;
+  const apiKey = process.env.OSUITE_API_KEY || process.env.DASHCLAW_API_KEY;
+  const agentId = process.env.OSUITE_AGENT_ID || process.env.DASHCLAW_AGENT_ID || 'osuite-cli';
 
   if (!baseUrl || !apiKey) {
-    process.stderr.write('Missing DASHCLAW_BASE_URL or DASHCLAW_API_KEY.\n');
+    process.stderr.write('Missing a base URL env (OSUITE_BASE_URL / OSUITE_URL / NEXTAUTH_URL) or OSUITE_API_KEY.\n');
     process.exit(1);
   }
 

package/dashclaw.js

@@ -19,6 +19,118 @@ class GuardBlockedError extends Error {
   }
 }
 
+const PCAA_CHECKPOINTS = [
+  {
+    id: 'pre_action_admissibility',
+    title: 'Pre-action admissibility',
+    summary: 'Evaluate whether the proposed action is allowed, simulated first, blocked, or approval-gated before side effects happen.',
+    sdkMethod: 'guard',
+  },
+  {
+    id: 'action_open',
+    title: 'Action open',
+    summary: 'Create the portable action record that becomes the trust object for replay, scoring, and proof.',
+    sdkMethod: 'createAction',
+  },
+  {
+    id: 'assumption_capture',
+    title: 'Assumption capture',
+    summary: 'Record what the runtime believed or depended on so operators can replay the reasoning boundary later.',
+    sdkMethod: 'recordAssumption',
+  },
+  {
+    id: 'approval_checkpoint',
+    title: 'Approval checkpoint',
+    summary: 'Pause, wait, or externally hold execution when policy requires a human checkpoint.',
+    sdkMethod: 'waitForApproval',
+  },
+  {
+    id: 'outcome_closure',
+    title: 'Outcome closure',
+    summary: 'Write the final result, evidence, and status so the action certificate closes cleanly.',
+    sdkMethod: 'updateOutcome',
+  },
+];
+
+function toPercent(numerator, denominator) {
+  if (!denominator || denominator <= 0) return 0;
+  return Math.max(0, Math.min(100, Math.round((numerator / denominator) * 100)));
+}
+
+function resolveRouteDecision({ action = null, proofBundle = null } = {}) {
+  return (
+    proofBundle?.route_decision
+    || proofBundle?.action_certificate?.route_decision
+    || action?.policy_snapshot?.effective_decision
+    || null
+  );
+}
+
+function resolveOutcomeStatus(status) {
+  const normalized = String(status || '').toLowerCase();
+  if (['completed', 'failed', 'blocked', 'cancelled', 'denied'].includes(normalized)) return 'complete';
+  if (['running', 'pending', 'pending_approval'].includes(normalized)) return 'pending';
+  return 'inactive';
+}
+
+function buildPcaaCheckpointStates({ action = null, trace = null, proofBundle = null } = {}) {
+  const routeDecision = resolveRouteDecision({ action, proofBundle });
+  const assumptionCount = Number(
+    trace?.trace?.assumptions?.total
+    ?? trace?.assumptions?.total
+    ?? (Array.isArray(trace?.assumptions) ? trace.assumptions.length : 0),
+  );
+  const approvalTriggered = ['require_approval', 'require_dual_approval', 'simulate_first', 'warn', 'block']
+    .includes(String(routeDecision || '').toLowerCase())
+    || String(action?.status || '').toLowerCase() === 'pending_approval';
+  const approvalComplete = Boolean(
+    action?.approved_by
+    || action?.approved_at
+    || (Array.isArray(proofBundle?.approvals) && proofBundle.approvals.length > 0),
+  );
+  const outcomeStatus = resolveOutcomeStatus(action?.status);
+
+  return PCAA_CHECKPOINTS.map((checkpoint) => {
+    if (checkpoint.id === 'pre_action_admissibility') {
+      return {
+        ...checkpoint,
+        status: routeDecision ? 'complete' : 'inactive',
+        value: routeDecision || 'not evaluated',
+      };
+    }
+
+    if (checkpoint.id === 'action_open') {
+      return {
+        ...checkpoint,
+        status: action?.action_id ? 'complete' : 'inactive',
+        value: action?.action_id || '--',
+      };
+    }
+
+    if (checkpoint.id === 'assumption_capture') {
+      return {
+        ...checkpoint,
+        status: assumptionCount > 0 ? 'complete' : 'inactive',
+        value: assumptionCount > 0 ? `${assumptionCount} recorded` : 'none recorded',
+      };
+    }
+
+    if (checkpoint.id === 'approval_checkpoint') {
+      return {
+        ...checkpoint,
+        status: approvalComplete ? 'complete' : approvalTriggered ? 'active' : 'inactive',
+        value: approvalComplete ? 'approved' : approvalTriggered ? (routeDecision || 'active') : 'not required',
+      };
+    }
+
+    return {
+      ...checkpoint,
+      status: outcomeStatus,
+      value: action?.status || '--',
+    };
+  });
+}
+
 class DashClaw {
   /**
    * @param {Object} options
@@ -60,7 +172,7 @@ class DashClaw {
     return body;
   }
 
-  async _request(path, method = 'GET', body = null, params = null) {
+  async _request(path, method = 'GET', body = null, params = null, options = {}) {
     let url = `${this.baseUrl}${path}`;
     if (params) {
       const qs = new URLSearchParams(params).toString();
@@ -78,9 +190,16 @@ class DashClaw {
       body: body ? JSON.stringify(body) : undefined
     });
 
-    const data = await res.json();
+    let data = {};
+    if (typeof res.text === 'function') {
+      const text = await res.text();
+      data = text ? JSON.parse(text) : {};
+    } else if (typeof res.json === 'function') {
+      data = await res.json();
+    }
+    const allowedStatuses = new Set(options.allowStatuses || []);
 
-    if (!res.ok) {
+    if (!res.ok && !allowedStatuses.has(res.status)) {
       if (res.status === 403 && data.decision && data.decision.decision === 'block') {
         throw new GuardBlockedError(data.decision);
       }
@@ -136,6 +255,13 @@ class DashClaw {
     return this._request(`/api/actions/${actionId}`, 'GET');
   }
 
+  /**
+   * GET /api/actions/:id/trace — Fetch replay trace, assumptions, loops, and root-cause indicators.
+   */
+  async getActionTrace(actionId) {
+    return this._request(`/api/actions/${actionId}/trace`, 'GET');
+  }
+
   /**
    * GET /api/actions?status=pending_approval — List actions awaiting approval.
    */
@@ -237,6 +363,125 @@ class DashClaw {
     throw new Error(`Timed out waiting for approval of action ${actionId}`);
   }
 
+  /**
+   * Subscribe to real-time SSE events from the OSuite server.
+   * Uses fetch-based SSE parsing for Node 18+ compatibility.
+   */
+  events({ reconnect = true, maxRetries = Infinity, retryInterval = 3000 } = {}) {
+    const url = `${this.baseUrl}/api/stream`;
+    const handlers = new Map();
+    let closed = false;
+    let controller = null;
+    let lastEventId = null;
+    let retryCount = 0;
+
+    const emit = (eventType, data) => {
+      const callbacks = handlers.get(eventType) || [];
+      for (const callback of callbacks) {
+        try {
+          callback(data);
+        } catch {
+          // Event handlers are intentionally isolated from stream health
+        }
+      }
+    };
+
+    const connect = async () => {
+      controller = new AbortController();
+      const headers = { 'x-api-key': this.apiKey };
+      if (lastEventId) headers['last-event-id'] = lastEventId;
+
+      const res = await fetch(url, {
+        headers,
+        signal: controller.signal,
+      });
+
+      if (!res.ok) {
+        throw new Error(`SSE connection failed: ${res.status} ${res.statusText}`);
+      }
+
+      retryCount = 0;
+
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = '';
+      let currentEvent = null;
+      let currentData = '';
+
+      while (!closed) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (line.startsWith('id: ')) {
+            lastEventId = line.slice(4).trim();
+          } else if (line.startsWith('event: ')) {
+            currentEvent = line.slice(7).trim();
+          } else if (line.startsWith('data: ')) {
+            currentData += line.slice(6);
+          } else if (line.startsWith(':')) {
+            continue;
+          } else if (line === '' && currentEvent) {
+            if (currentData) {
+              try {
+                emit(currentEvent, JSON.parse(currentData));
+              } catch {
+                // Ignore malformed frames to keep the stream alive
+              }
+            }
+            currentEvent = null;
+            currentData = '';
+          } else if (line === '') {
+            currentEvent = null;
+            currentData = '';
+          }
+        }
+      }
+    };
+
+    const connectLoop = async () => {
+      while (!closed) {
+        try {
+          await connect();
+        } catch (error) {
+          if (closed) return;
+          emit('error', error);
+        }
+
+        if (closed) return;
+        if (!reconnect || retryCount >= maxRetries) {
+          emit('error', new Error('SSE stream ended'));
+          return;
+        }
+
+        retryCount += 1;
+        emit('reconnecting', { attempt: retryCount, maxRetries });
+        await new Promise((resolve) => setTimeout(resolve, retryInterval));
+      }
+    };
+
+    const connectionPromise = connectLoop();
+
+    const handle = {
+      on(eventType, callback) {
+        if (!handlers.has(eventType)) handlers.set(eventType, []);
+        handlers.get(eventType).push(callback);
+        return handle;
+      },
+      close() {
+        closed = true;
+        if (controller) controller.abort();
+      },
+      _promise: connectionPromise,
+    };
+
+    return handle;
+  }
+
   /**
    * POST /api/agents/heartbeat
    */
@@ -287,6 +532,112 @@ class DashClaw {
     return this._request('/api/actions/signals');
   }
 
+  /**
+   * GET /api/governance/proof — Fetch operator-facing or bundle-form governance proof.
+   */
+  async getGovernanceProof({ actionId = null, format = null } = {}) {
+    return this._request('/api/governance/proof', 'GET', null, {
+      ...(actionId ? { action_id: actionId } : {}),
+      ...(format ? { format } : {}),
+    });
+  }
+
+  /**
+   * GET /api/governance/proof?format=bundle — Fetch machine-readable PCAA / proof bundle output.
+   */
+  async getGovernanceProofBundle({ actionId = null } = {}) {
+    return this.getGovernanceProof({ actionId, format: 'bundle' });
+  }
+
+  /**
+   * POST /api/governance/proof/verify — Verify one action attestation and proof bundle.
+   */
+  async verifyGovernanceProof(actionId, { throwOnInvalid = false } = {}) {
+    return this._request(
+      '/api/governance/proof/verify',
+      'POST',
+      { action_id: actionId },
+      null,
+      throwOnInvalid ? {} : { allowStatuses: [422] },
+    );
+  }
+
+  /**
+   * GET /api/compliance/evidence — Fetch live evidence aggregates for PCAA / compliance.
+   */
+  async getComplianceEvidence({ window = '30d' } = {}) {
+    return this._request('/api/compliance/evidence', 'GET', null, { window });
+  }
+
+  /**
+   * GET /api/proof/export — Fetch a portable proof export by action or bundle id.
+   */
+  async exportProof({ actionId = null, bundleId = null } = {}) {
+    if (!actionId && !bundleId) {
+      throw new Error('actionId or bundleId is required');
+    }
+    return this._request('/api/proof/export', 'GET', null, {
+      ...(actionId ? { action_id: actionId } : {}),
+      ...(bundleId ? { bundle_id: bundleId } : {}),
+    });
+  }
+
+  /**
+   * Build the same PCAA health summary used by the workspace banner.
+   */
+  async getPcaaHealth({ window = '30d', agentId = null } = {}) {
+    const [actionsStats, complianceEvidence] = await Promise.all([
+      this._request('/api/actions/stats', 'GET', null, {
+        ...(agentId ? { agent_id: agentId } : {}),
+      }),
+      this.getComplianceEvidence({ window }),
+    ]);
+
+    const evidence = complianceEvidence?.evidence || {};
+    const totalActions = Number(actionsStats?.total || 0);
+    const recordedActions = Number(evidence.action_records_total || 0);
+    const approvals = Number(evidence.approval_requests || actionsStats?.approval || 0);
+    const proofBundles = Number(evidence.proof_bundles_total || 0);
+    const completeBundles = Number(evidence.complete_proof_bundles || 0);
+
+    return {
+      totalActions,
+      recordedActions,
+      approvals,
+      proofBundles,
+      completeBundles,
+      checkpointCoverage: toPercent(recordedActions, totalActions || recordedActions || 1),
+      approvalRate: toPercent(approvals, totalActions || approvals || 1),
+      evidenceCompletion: toPercent(completeBundles, proofBundles || completeBundles || 1),
+      window,
+      generatedAt: complianceEvidence?.generated_at || new Date().toISOString(),
+    };
+  }
+
+  /**
+   * Fetch one action's PCAA view: action, trace, proof bundle, export bundle, and derived checkpoints.
+   */
+  async getPcaaAction(actionId) {
+    const [actionPayload, trace, proofBundle, proofExport] = await Promise.all([
+      this.getAction(actionId),
+      this.getActionTrace(actionId),
+      this.getGovernanceProofBundle({ actionId }),
+      this.exportProof({ actionId }).catch((error) => {
+        if (error?.status === 404) return null;
+        throw error;
+      }),
+    ]);
+
+    const action = actionPayload?.action || actionPayload || null;
+    return {
+      action,
+      trace,
+      proofBundle,
+      proofExport,
+      checkpoints: buildPcaaCheckpointStates({ action, trace, proofBundle }),
+    };
+  }
+
   /**
    * GET /api/learning/analytics/velocity
    */
@@ -623,6 +974,15 @@ class DashClaw {
 }
 
 const OSuite = DashClaw;
+const Osuite = DashClaw;
 
 export default OSuite;
-export { DashClaw, OSuite, ApprovalDeniedError, GuardBlockedError };
+export {
+  DashClaw,
+  OSuite,
+  Osuite,
+  ApprovalDeniedError,
+  GuardBlockedError,
+  PCAA_CHECKPOINTS,
+  buildPcaaCheckpointStates,
+};

package/index.cjs

@@ -10,6 +10,113 @@
 // We use a simplified bridge that forwards calls to the async ESM import
 let _module;
 
+const PCAA_CHECKPOINTS = [
+  {
+    id: 'pre_action_admissibility',
+    title: 'Pre-action admissibility',
+    summary: 'Evaluate whether the proposed action is allowed, simulated first, blocked, or approval-gated before side effects happen.',
+    sdkMethod: 'guard',
+  },
+  {
+    id: 'action_open',
+    title: 'Action open',
+    summary: 'Create the portable action record that becomes the trust object for replay, scoring, and proof.',
+    sdkMethod: 'createAction',
+  },
+  {
+    id: 'assumption_capture',
+    title: 'Assumption capture',
+    summary: 'Record what the runtime believed or depended on so operators can replay the reasoning boundary later.',
+    sdkMethod: 'recordAssumption',
+  },
+  {
+    id: 'approval_checkpoint',
+    title: 'Approval checkpoint',
+    summary: 'Pause, wait, or externally hold execution when policy requires a human checkpoint.',
+    sdkMethod: 'waitForApproval',
+  },
+  {
+    id: 'outcome_closure',
+    title: 'Outcome closure',
+    summary: 'Write the final result, evidence, and status so the action certificate closes cleanly.',
+    sdkMethod: 'updateOutcome',
+  },
+];
+
+function resolveRouteDecision({ action = null, proofBundle = null } = {}) {
+  return (
+    proofBundle?.route_decision
+    || proofBundle?.action_certificate?.route_decision
+    || action?.policy_snapshot?.effective_decision
+    || null
+  );
+}
+
+function resolveOutcomeStatus(status) {
+  const normalized = String(status || '').toLowerCase();
+  if (['completed', 'failed', 'blocked', 'cancelled', 'denied'].includes(normalized)) return 'complete';
+  if (['running', 'pending', 'pending_approval'].includes(normalized)) return 'pending';
+  return 'inactive';
+}
+
+function buildPcaaCheckpointStates({ action = null, trace = null, proofBundle = null } = {}) {
+  const routeDecision = resolveRouteDecision({ action, proofBundle });
+  const assumptionCount = Number(
+    trace?.trace?.assumptions?.total
+    ?? trace?.assumptions?.total
+    ?? (Array.isArray(trace?.assumptions) ? trace.assumptions.length : 0),
+  );
+  const approvalTriggered = ['require_approval', 'require_dual_approval', 'simulate_first', 'warn', 'block']
+    .includes(String(routeDecision || '').toLowerCase())
+    || String(action?.status || '').toLowerCase() === 'pending_approval';
+  const approvalComplete = Boolean(
+    action?.approved_by
+    || action?.approved_at
+    || (Array.isArray(proofBundle?.approvals) && proofBundle.approvals.length > 0),
+  );
+  const outcomeStatus = resolveOutcomeStatus(action?.status);
+
+  return PCAA_CHECKPOINTS.map((checkpoint) => {
+    if (checkpoint.id === 'pre_action_admissibility') {
+      return {
+        ...checkpoint,
+        status: routeDecision ? 'complete' : 'inactive',
+        value: routeDecision || 'not evaluated',
+      };
+    }
+
+    if (checkpoint.id === 'action_open') {
+      return {
+        ...checkpoint,
+        status: action?.action_id ? 'complete' : 'inactive',
+        value: action?.action_id || '--',
+      };
+    }
+
+    if (checkpoint.id === 'assumption_capture') {
+      return {
+        ...checkpoint,
+        status: assumptionCount > 0 ? 'complete' : 'inactive',
+        value: assumptionCount > 0 ? `${assumptionCount} recorded` : 'none recorded',
+      };
+    }
+
+    if (checkpoint.id === 'approval_checkpoint') {
+      return {
+        ...checkpoint,
+        status: approvalComplete ? 'complete' : approvalTriggered ? 'active' : 'inactive',
+        value: approvalComplete ? 'approved' : approvalTriggered ? (routeDecision || 'active') : 'not required',
+      };
+    }
+
+    return {
+      ...checkpoint,
+      status: outcomeStatus,
+      value: action?.status || '--',
+    };
+  });
+}
+
 async function loadModule() {
   if (!_module) {
     _module = await import('./osuite.js');
@@ -67,4 +174,6 @@ module.exports = {
   DashClaw: OSuiteProxy,
   ApprovalDeniedError,
   GuardBlockedError,
+  PCAA_CHECKPOINTS,
+  buildPcaaCheckpointStates,
 };

package/osuite.js

@@ -1 +1,10 @@
-export { default, DashClaw, OSuite, ApprovalDeniedError, GuardBlockedError } from './dashclaw.js';
+export {
+  default,
+  DashClaw,
+  OSuite,
+  Osuite,
+  ApprovalDeniedError,
+  GuardBlockedError,
+  PCAA_CHECKPOINTS,
+  buildPcaaCheckpointStates,
+} from './dashclaw.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osuite",
-  "version": "2.8.0",
+  "version": "2.9.0",
   "description": "OSuite governance runtime for AI agents. Intercept, govern, and verify agent actions.",
   "type": "module",
   "publishConfig": {
@@ -9,8 +9,7 @@
   "main": "./index.cjs",
   "module": "./osuite.js",
   "bin": {
-    "osuite": "cli.js",
-    "dashclaw": "cli.js"
+    "osuite": "cli.js"
   },
   "exports": {
     ".": {
@@ -50,7 +49,6 @@
     "node": ">=18.0.0"
   },
   "dependencies": {},
-  "devDependencies": {},
   "scripts": {},
   "sideEffects": false
 }