osuite 2.9.0 → 2.9.1

package/index.cjs

@@ -1,155 +1,38 @@
-/**
- * OSuite SDK v2 (Stable Runtime API)
- * CommonJS compatibility bridge.
- * 
- * ESM: import { OSuite } from 'osuite'
- * CJS: const { OSuite } = require('osuite')
- */
+'use strict';
 
-// Minimal CommonJS shim for the v2 SDK
-// We use a simplified bridge that forwards calls to the async ESM import
-let _module;
+let modulePromise;
 
-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');
-  }
-  return _module;
+function loadModule() {
+  if (!modulePromise) modulePromise = import('./osuite.js');
+  return modulePromise;
 }
 
 class OSuiteProxy {
-  constructor(opts) {
-    this._opts = opts;
-    this._ready = loadModule().then((m) => {
-      this._instance = new m.OSuite(opts);
+  constructor(options) {
+    this._ready = loadModule().then((mod) => {
+      this._instance = new mod.OSuite(options);
     });
 
     return new Proxy(this, {
-      get(target, prop) {
-        if (prop in target) return target[prop];
-        if (prop === 'then') return undefined;
+      get(target, property) {
+        if (property in target) return target[property];
+        if (property === 'then') return undefined;
 
         return async (...args) => {
           await target._ready;
-          if (!target._instance[prop]) {
-            throw new Error(`Method ${String(prop)} does not exist on OSuite v2`);
+          const value = target._instance[property];
+          if (typeof value !== 'function') {
+            throw new Error(`Method ${String(property)} does not exist on OSuite.`);
           }
-          return target._instance[prop](...args);
+          return value.apply(target._instance, args);
         };
       },
     });
   }
 
-  static async create(opts) {
+  static async create(options) {
     const mod = await loadModule();
-    return new mod.OSuite(opts);
+    return new mod.OSuite(options);
   }
 }
 
@@ -163,17 +46,24 @@ class ApprovalDeniedError extends Error {
 
 class GuardBlockedError extends Error {
   constructor(decision) {
-    super(decision.reason || 'Action blocked by policy');
+    super((decision && decision.reason) || 'Action blocked by policy');
     this.name = 'GuardBlockedError';
     this.decision = decision;
   }
 }
 
+async function buildReviewSurface(...args) {
+  const mod = await loadModule();
+  return mod.buildReviewSurface(...args);
+}
+
 module.exports = {
-  OSuite: OSuiteProxy,
-  DashClaw: OSuiteProxy,
   ApprovalDeniedError,
+  DashClaw: OSuiteProxy,
   GuardBlockedError,
-  PCAA_CHECKPOINTS,
-  buildPcaaCheckpointStates,
+  OpenClawAgent: OSuiteProxy,
+  OSuite: OSuiteProxy,
+  Osuite: OSuiteProxy,
+  buildReviewSurface,
+  default: OSuiteProxy,
 };

package/legacy/index-v1.cjs

@@ -1,91 +1,3 @@
-/**
- * OSuite SDK v1 (Legacy): CommonJS compatibility wrapper.
- * For ESM: import { OSuite } from 'osuite/legacy'
- * For CJS: const { OSuite } = require('osuite/legacy')
- */
+'use strict';
 
-let _module;
-
-async function loadModule() {
-  if (!_module) {
-    _module = await import('./osuite-v1.js');
-  }
-  return _module;
-}
-
-// Re-export via dynamic import (CJS → ESM bridge)
-module.exports = new Proxy({}, {
-  get(target, prop) {
-    if (prop === '__esModule') return true;
-    if (prop === 'then') return undefined; // Prevent Promise-like behavior
-
-    // Return a lazy-loading constructor wrapper
-    if (prop === 'GuardBlockedError') {
-      const Placeholder = class GuardBlockedError extends Error {
-        constructor(decision) {
-          const reasons = (decision.reasons || []).join('; ') || 'no reason';
-          super(`Guard blocked action: ${decision.decision}. Reasons: ${reasons}`);
-          this.name = 'GuardBlockedError';
-          this.decision = decision.decision;
-          this.reasons = decision.reasons || [];
-          this.warnings = decision.warnings || [];
-          this.matchedPolicies = decision.matched_policies || [];
-          this.riskScore = decision.risk_score ?? null;
-        }
-      };
-      
-      // Support instanceof across ESM/CJS boundary
-      loadModule().then(m => {
-        if (m.GuardBlockedError) {
-          Object.defineProperty(Placeholder, Symbol.hasInstance, {
-            value: (instance) => instance && (instance.name === 'GuardBlockedError' || instance instanceof m.GuardBlockedError)
-          });
-        }
-      });
-      
-      return Placeholder;
-    }
-    if (prop === 'OSuite' || prop === 'DashClaw' || prop === 'OpenClawAgent' || prop === 'default') {
-      return class OSuiteProxy {
-        constructor(opts) {
-          this._opts = opts;
-          this._ready = loadModule().then(m => {
-            const Cls = m.OSuite || m.DashClaw || m.default;
-            this._instance = new Cls(opts);
-          });
-
-          // Return a proxy that forwards all method calls to the async instance
-          return new Proxy(this, {
-            get(target, prop) {
-              if (prop in target) return target[prop];
-              if (prop === 'then') return undefined;
-
-              return async (...args) => {
-                await target._ready;
-                if (!target._instance[prop]) {
-                  throw new Error(`Method ${String(prop)} does not exist on OSuite`);
-                }
-                return target._instance[prop](...args);
-              };
-            }
-          });
-        }
-
-        // For synchronous construction, use OSuite.create()
-        static async create(opts) {
-          const mod = await loadModule();
-          const Cls = mod.OSuite || mod.DashClaw || mod.default;
-          return new Cls(opts);
-        }
-      };
-    }
-    return undefined;
-  }
-});
-
-// Preferred: async factory
-module.exports.create = async function create(opts) {
-  const mod = await loadModule();
-  const Cls = mod.OSuite || mod.DashClaw || mod.default;
-  return new Cls(opts);
-};
+module.exports = require('../index.cjs');

package/legacy/osuite-v1-runtime.js

@@ -0,0 +1,7 @@
+export {
+  default,
+  OSuite,
+  OpenClawAgent,
+  GuardBlockedError,
+  ApprovalDeniedError,
+} from '../osuite.js';

package/legacy/osuite-v1.js

@@ -1 +1 @@
-export { default, DashClaw, OSuite, OpenClawAgent, GuardBlockedError, ApprovalDeniedError } from './dashclaw-v1.js';
+export { default, OSuite, OpenClawAgent, GuardBlockedError, ApprovalDeniedError } from './osuite-v1-runtime.js';