dashclaw 1.9.4 → 2.0.0

package/README.md

@@ -2,9 +2,9 @@
 
 Full reference for the DashClaw SDK (Node.js). For Python, see the [Python SDK docs](../sdk-python/README.md).
 
-DashClaw treats every agent action as a governed decision. The SDK provides decision recording, policy enforcement, assumption tracking, and compliance mapping. It proves what your agents decided and why.
+DashClaw treats every agent action as a governed decision. The SDK provides decision recording, policy enforcement, evaluation, and compliance mapping. It proves what your agents decided and why.
 
-Install, configure, and govern your AI agents with 95+ methods across 21+ categories including action recording, behavior guard, context management, session handoffs, security scanning, agent messaging, agent pairing, identity binding, organization management, webhooks, policy testing, compliance, task routing, and more.
+Install, configure, and govern your AI agents with 178+ methods across 30+ categories including action recording, behavior guard, evaluation framework, scoring profiles, learning analytics, prompt management, feedback loops, behavioral drift, compliance exports, and more. Native adapters for **OpenClaw**, **CrewAI**, **AutoGen**, and **LangChain**.
 
 ---
 
@@ -314,6 +314,268 @@ Get root-cause trace for an action, including its assumptions, open loops, paren
 
 ---
 
+## Evaluation Framework
+
+Track output quality automatically with 5 built-in scorer types. No LLM required for most scorers.
+
+### claw.createScorer({ name, scorerType, config, description })
+Create a new evaluation scorer.
+
+**Parameters:**
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| name | string | Yes | Scorer name |
+| scorerType | string | Yes | regex, keywords, numeric_range, custom_function, or llm_judge |
+| config | Object | Yes | Configuration for the scorer |
+| description | string | No | Purpose of this scorer |
+
+**Returns:** `Promise<Object>`
+
+**Example:**
+```javascript
+await claw.createScorer({
+  name: 'JSON Validator',
+  scorerType: 'regex',
+  config: { pattern: '^\\{.*\\}$' },
+});
+```
+
+### claw.getScorers()
+List all available scorers.
+
+**Returns:** `Promise<{ scorers: Object[], llm_available: boolean }>`
+
+### claw.getEvalRuns(filters?)
+List evaluation runs with status and result summaries.
+
+**Parameters:**
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| status | string | No | running, completed, failed |
+| limit | number | No | Max results |
+
+**Returns:** `Promise<{ runs: Object[] }>`
+
+### claw.getEvalStats(filters?)
+Get aggregate evaluation statistics across scorers and agents.
+
+**Parameters:**
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| agent_id | string | No | Filter by agent |
+| scorer_name | string | No | Filter by scorer |
+| days | number | No | Lookback period |
+
+**Returns:** `Promise<Object>`
+
+---
+
+## Prompt Management
+
+Version-controlled prompt templates with mustache variable rendering.
+
+### claw.createPromptTemplate({ name, content, category })
+Create a new prompt template.
+
+**Parameters:**
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| name | string | Yes | Template name |
+| content | string | Yes | Template content with {{variables}} |
+| category | string | No | Optional grouping category |
+
+**Returns:** `Promise<Object>`
+
+### claw.getPromptTemplate(templateId)
+Get a template by ID, including its current active version.
+
+**Returns:** `Promise<Object>`
+
+### claw.renderPrompt({ template_id, variables, action_id })
+Render a template with variables on the server. Optionally link to an action for usage tracking.
+
+**Parameters:**
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| template_id | string | Yes | Template ID |
+| variables | Object | Yes | Mustache variables |
+| action_id | string | No | Link to an action |
+
+**Returns:** `Promise<{ rendered: string }>`
+
+### claw.listPromptVersions(templateId)
+List all versions of a prompt template.
+
+**Returns:** `Promise<Object[]>`
+
+### claw.activatePromptVersion(templateId, versionId)
+Set a specific version as the active one for a template.
+
+**Returns:** `Promise<Object>`
+
+---
+
+## User Feedback
+
+Collect and analyze human feedback on agent actions.
+
+### claw.submitFeedback({ action_id, agent_id, rating, comment, category, tags })
+Submit feedback for a specific action.
+
+**Parameters:**
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| action_id | string | Yes | Action ID |
+| agent_id | string | No | Agent ID |
+| rating | number | Yes | Rating 1-5 |
+| comment | string | No | Optional text feedback |
+| category | string | No | Optional category |
+| tags | string[] | No | Optional tags |
+
+**Returns:** `Promise<Object>`
+
+### claw.getFeedback(feedbackId)
+Retrieve a single feedback entry.
+
+**Returns:** `Promise<Object>`
+
+### claw.getFeedbackStats({ agent_id })
+Get feedback statistics, including average rating and sentiment trends.
+
+**Returns:** `Promise<Object>`
+
+---
+
+## Behavioral Drift
+
+Monitor agent behavior deviations from statistical baselines using z-scores.
+
+### claw.computeDriftBaselines({ agent_id, lookback_days })
+Establish statistical baselines for an agent's behavior metrics.
+
+**Returns:** `Promise<Object>`
+
+### claw.detectDrift({ agent_id, window_days })
+Run drift detection against the established baselines.
+
+**Returns:** `Promise<Object>`
+
+### claw.listDriftAlerts(filters?)
+List behavioral drift alerts with severity and status.
+
+**Returns:** `Promise<Object[]>`
+
+---
+
+## Compliance Exports
+
+Generate evidence packages for SOC 2, NIST AI RMF, EU AI Act, and ISO 42001.
+
+### claw.createComplianceExport({ name, frameworks, format, window_days })
+Generate a compliance export bundle.
+
+**Returns:** `Promise<Object>`
+
+### claw.getComplianceExport(exportId)
+Get the status and details of a compliance export.
+
+**Returns:** `Promise<Object>`
+
+### claw.listComplianceExports({ limit })
+List recent compliance exports.
+
+**Returns:** `Promise<Object[]>`
+
+---
+
+## Learning Analytics
+
+Track agent improvement velocity, maturity levels, and learning curves per skill.
+
+### claw.getLearningVelocity({ agent_id })
+Get agent improvement rate over time.
+
+**Returns:** `Promise<Object>`
+
+### claw.getMaturityLevels()
+Get the 6-level maturity model distribution for the agent.
+
+**Returns:** `Promise<Object>`
+
+### claw.getLearningCurves({ agent_id, action_type })
+Get performance improvement curves for a specific skill/action type.
+
+**Returns:** `Promise<Object>`
+
+---
+
+## Scoring Profiles
+
+User-defined weighted quality scoring with 3 composite methods, 8 data sources, risk templates, and auto-calibration. Zero LLM required.
+
+### claw.createScoringProfile({ name, action_type, composite_method, dimensions })
+Create a scoring profile with optional inline dimensions.
+
+**Parameters:**
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| name | string | Yes | Profile name |
+| action_type | string | No | Filter to specific action type (null = all) |
+| composite_method | string | No | weighted_average (default), minimum, or geometric_mean |
+| dimensions | Array | No | Inline dimension definitions (name, data_source, weight, scale) |
+
+**Returns:** `Promise<Object>`
+
+**Example:**
+```javascript
+const profile = await dc.createScoringProfile({
+  name: 'deploy-quality',
+  action_type: 'deploy',
+  composite_method: 'weighted_average',
+  dimensions: [
+    { name: 'Speed', data_source: 'duration_ms', weight: 0.3,
+      scale: [
+        { label: 'excellent', operator: 'lt', value: 30000, score: 100 },
+        { label: 'good', operator: 'lt', value: 60000, score: 75 },
+        { label: 'poor', operator: 'gte', value: 60000, score: 20 },
+      ]},
+    { name: 'Reliability', data_source: 'confidence', weight: 0.7,
+      scale: [
+        { label: 'excellent', operator: 'gte', value: 0.9, score: 100 },
+        { label: 'poor', operator: 'lt', value: 0.7, score: 25 },
+      ]},
+  ],
+});
+```
+
+### claw.scoreWithProfile(profile_id, action)
+Score a single action against a profile. Returns composite score + per-dimension breakdown.
+
+**Parameters:**
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| profile_id | string | Yes | Profile to score against |
+| action | Object | Yes | Action data object |
+
+**Returns:** `Promise<Object>`
+
+### claw.batchScoreWithProfile(profile_id, actions)
+Score multiple actions at once. Returns per-action results + summary.
+
+**Returns:** `Promise<Object>`
+
+### claw.createRiskTemplate({ name, base_risk, rules })
+Create a rule-based risk template. Replaces hardcoded agent risk numbers.
+
+**Returns:** `Promise<Object>`
+
+### claw.autoCalibrate({ action_type, lookback_days })
+Analyze historical action data to suggest scoring thresholds from percentile distribution.
+
+**Returns:** `Promise<Object>`
+
+---
+
 ## Agent Presence & Health
 
 Monitor agent uptime and status in real-time. Use heartbeats to detect when an agent crashes or loses network connectivity.

package/dashclaw.js

@@ -112,7 +112,27 @@ class DashClaw {
     }
   }
 
-  async _request(path, method, body) {
+  async _request(pathOrMethod, methodOrPath, body, params) {
+    let path, method;
+    if (typeof pathOrMethod === 'string' && pathOrMethod.startsWith('/')) {
+      path = pathOrMethod;
+      method = methodOrPath || 'GET';
+    } else {
+      method = pathOrMethod;
+      path = methodOrPath;
+    }
+
+    if (params) {
+      const qs = new URLSearchParams();
+      for (const [k, v] of Object.entries(params)) {
+        if (v !== undefined && v !== null) qs.append(k, String(v));
+      }
+      const qsStr = qs.toString();
+      if (qsStr) {
+        path += (path.includes('?') ? '&' : '?') + qsStr;
+      }
+    }
+
     const url = `${this.baseUrl}${path}`;
     const headers = {
       'Content-Type': 'application/json',
@@ -2277,6 +2297,459 @@ class DashClaw {
       ...state,
     });
   }
+
+  // ----------------------------------------------
+  // Category: Evaluations
+  // ----------------------------------------------
+
+  /**
+   * Create an evaluation score for an action.
+   * @param {Object} params
+   * @param {string} params.actionId - Action record ID
+   * @param {string} params.scorerName - Name of the scorer
+   * @param {number} params.score - Score between 0.0 and 1.0
+   * @param {string} [params.label] - Category label (e.g., 'correct', 'incorrect')
+   * @param {string} [params.reasoning] - Explanation of the score
+   * @param {string} [params.evaluatedBy] - 'auto', 'human', or 'llm_judge'
+   * @param {Object} [params.metadata] - Additional metadata
+   * @returns {Promise<Object>}
+   */
+  async createScore({ actionId, scorerName, score, label, reasoning, evaluatedBy, metadata }) {
+    return this._request('/api/evaluations', 'POST', {
+      action_id: actionId,
+      scorer_name: scorerName,
+      score,
+      label,
+      reasoning,
+      evaluated_by: evaluatedBy,
+      metadata,
+    });
+  }
+
+  /**
+   * List evaluation scores with optional filters.
+   * @param {Object} [filters] - { action_id, scorer_name, evaluated_by, min_score, max_score, limit, offset, agent_id }
+   * @returns {Promise<{ scores: Object[], total: number }>}
+   */
+  async getScores(filters = {}) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(filters)) {
+      if (value !== undefined && value !== null && value !== '') {
+        params.set(key, String(value));
+      }
+    }
+    return this._request(`/api/evaluations?${params}`, 'GET');
+  }
+
+  /**
+   * Create a reusable scorer definition.
+   * @param {Object} params
+   * @param {string} params.name - Scorer name (unique per org)
+   * @param {string} params.scorerType - 'regex', 'contains', 'numeric_range', 'custom_function', or 'llm_judge'
+   * @param {Object} params.config - Scorer configuration
+   * @param {string} [params.description] - Description
+   * @returns {Promise<Object>}
+   */
+  async createScorer({ name, scorerType, config, description }) {
+    return this._request('/api/evaluations/scorers', 'POST', {
+      name,
+      scorer_type: scorerType,
+      config,
+      description,
+    });
+  }
+
+  /**
+   * List all scorers for this org.
+   * @returns {Promise<{ scorers: Object[], llm_available: boolean }>}
+   */
+  async getScorers() {
+    return this._request('/api/evaluations/scorers', 'GET');
+  }
+
+  /**
+   * Update a scorer.
+   * @param {string} scorerId
+   * @param {Object} updates - { name?, description?, config? }
+   * @returns {Promise<Object>}
+   */
+  async updateScorer(scorerId, updates) {
+    return this._request(`/api/evaluations/scorers/${scorerId}`, 'PATCH', updates);
+  }
+
+  /**
+   * Delete a scorer.
+   * @param {string} scorerId
+   * @returns {Promise<Object>}
+   */
+  async deleteScorer(scorerId) {
+    return this._request(`/api/evaluations/scorers/${scorerId}`, 'DELETE');
+  }
+
+  /**
+   * Create and start an evaluation run.
+   * @param {Object} params
+   * @param {string} params.name - Run name
+   * @param {string} params.scorerId - Scorer to use
+   * @param {Object} [params.actionFilters] - Filters for which actions to evaluate
+   * @returns {Promise<Object>}
+   */
+  async createEvalRun({ name, scorerId, actionFilters }) {
+    return this._request('/api/evaluations/runs', 'POST', {
+      name,
+      scorer_id: scorerId,
+      action_filters: actionFilters,
+    });
+  }
+
+  /**
+   * List evaluation runs.
+   * @param {Object} [filters] - { status, limit, offset }
+   * @returns {Promise<{ runs: Object[] }>}
+   */
+  async getEvalRuns(filters = {}) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(filters)) {
+      if (value !== undefined && value !== null && value !== '') {
+        params.set(key, String(value));
+      }
+    }
+    return this._request(`/api/evaluations/runs?${params}`, 'GET');
+  }
+
+  /**
+   * Get details of an evaluation run.
+   * @param {string} runId
+   * @returns {Promise<{ run: Object, distribution: Object[] }>}
+   */
+  async getEvalRun(runId) {
+    return this._request(`/api/evaluations/runs/${runId}`, 'GET');
+  }
+
+  /**
+   * Get aggregate evaluation statistics.
+   * @param {Object} [filters] - { agent_id, scorer_name, days }
+   * @returns {Promise<Object>}
+   */
+  async getEvalStats(filters = {}) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(filters)) {
+      if (value !== undefined && value !== null && value !== '') {
+        params.set(key, String(value));
+      }
+    }
+    return this._request(`/api/evaluations/stats?${params}`, 'GET');
+  }
+
+  // -----------------------------------------------
+  // Prompt Management
+  // -----------------------------------------------
+
+  async listPromptTemplates({ category } = {}) {
+    const params = category ? `?category=${encodeURIComponent(category)}` : '';
+    return this._request(`/api/prompts/templates${params}`, 'GET');
+  }
+
+  async createPromptTemplate({ name, description, category }) {
+    return this._request('/api/prompts/templates', 'POST', { name, description, category });
+  }
+
+  async getPromptTemplate(templateId) {
+    return this._request(`/api/prompts/templates/${templateId}`, 'GET');
+  }
+
+  async updatePromptTemplate(templateId, fields) {
+    return this._request(`/api/prompts/templates/${templateId}`, 'PATCH', fields);
+  }
+
+  async deletePromptTemplate(templateId) {
+    return this._request(`/api/prompts/templates/${templateId}`, 'DELETE');
+  }
+
+  async listPromptVersions(templateId) {
+    return this._request(`/api/prompts/templates/${templateId}/versions`, 'GET');
+  }
+
+  async createPromptVersion(templateId, { content, model_hint, parameters, changelog }) {
+    return this._request(`/api/prompts/templates/${templateId}/versions`, 'POST', { content, model_hint, parameters, changelog });
+  }
+
+  async getPromptVersion(templateId, versionId) {
+    return this._request(`/api/prompts/templates/${templateId}/versions/${versionId}`, 'GET');
+  }
+
+  async activatePromptVersion(templateId, versionId) {
+    return this._request(`/api/prompts/templates/${templateId}/versions/${versionId}`, 'POST');
+  }
+
+  async renderPrompt({ template_id, version_id, variables, action_id, agent_id, record }) {
+    return this._request('/api/prompts/render', 'POST', { template_id, version_id, variables, action_id, agent_id, record });
+  }
+
+  async listPromptRuns({ template_id, version_id, limit } = {}) {
+    const params = new URLSearchParams();
+    if (template_id) params.set('template_id', template_id);
+    if (version_id) params.set('version_id', version_id);
+    if (limit) params.set('limit', String(limit));
+    const qs = params.toString() ? `?${params.toString()}` : '';
+    return this._request(`/api/prompts/runs${qs}`, 'GET');
+  }
+
+  async getPromptStats({ template_id } = {}) {
+    const params = template_id ? `?template_id=${encodeURIComponent(template_id)}` : '';
+    return this._request(`/api/prompts/stats${params}`, 'GET');
+  }
+
+  // -----------------------------------------------
+  // User Feedback
+  // -----------------------------------------------
+
+  async submitFeedback({ action_id, agent_id, rating, comment, category, tags, metadata }) {
+    return this._request('/api/feedback', 'POST', { action_id, agent_id, rating, comment, category, tags, metadata, source: 'sdk' });
+  }
+
+  async listFeedback({ action_id, agent_id, category, sentiment, resolved, limit, offset } = {}) {
+    const params = new URLSearchParams();
+    if (action_id) params.set('action_id', action_id);
+    if (agent_id) params.set('agent_id', agent_id);
+    if (category) params.set('category', category);
+    if (sentiment) params.set('sentiment', sentiment);
+    if (resolved !== undefined) params.set('resolved', String(resolved));
+    if (limit) params.set('limit', String(limit));
+    if (offset) params.set('offset', String(offset));
+    const qs = params.toString() ? `?${params.toString()}` : '';
+    return this._request(`/api/feedback${qs}`, 'GET');
+  }
+
+  async getFeedback(feedbackId) {
+    return this._request(`/api/feedback/${feedbackId}`, 'GET');
+  }
+
+  async resolveFeedback(feedbackId) {
+    return this._request(`/api/feedback/${feedbackId}`, 'PATCH', { resolved_by: 'sdk' });
+  }
+
+  async deleteFeedback(feedbackId) {
+    return this._request(`/api/feedback/${feedbackId}`, 'DELETE');
+  }
+
+  async getFeedbackStats({ agent_id } = {}) {
+    const params = agent_id ? `?agent_id=${encodeURIComponent(agent_id)}` : '';
+    return this._request(`/api/feedback/stats${params}`, 'GET');
+  }
+
+  // -----------------------------------------------
+  // Compliance Export
+  // -----------------------------------------------
+
+  async createComplianceExport({ name, frameworks, format, window_days, include_evidence, include_remediation, include_trends }) {
+    return this._request('/api/compliance/exports', 'POST', { name, frameworks, format, window_days, include_evidence, include_remediation, include_trends });
+  }
+
+  async listComplianceExports({ limit } = {}) {
+    const params = limit ? `?limit=${limit}` : '';
+    return this._request(`/api/compliance/exports${params}`, 'GET');
+  }
+
+  async getComplianceExport(exportId) {
+    return this._request(`/api/compliance/exports/${exportId}`, 'GET');
+  }
+
+  async downloadComplianceExport(exportId) {
+    return this._request(`/api/compliance/exports/${exportId}/download`, 'GET');
+  }
+
+  async deleteComplianceExport(exportId) {
+    return this._request(`/api/compliance/exports/${exportId}`, 'DELETE');
+  }
+
+  async createComplianceSchedule({ name, frameworks, format, window_days, cron_expression, include_evidence, include_remediation, include_trends }) {
+    return this._request('/api/compliance/schedules', 'POST', { name, frameworks, format, window_days, cron_expression, include_evidence, include_remediation, include_trends });
+  }
+
+  async listComplianceSchedules() {
+    return this._request('/api/compliance/schedules', 'GET');
+  }
+
+  async updateComplianceSchedule(scheduleId, fields) {
+    return this._request(`/api/compliance/schedules/${scheduleId}`, 'PATCH', fields);
+  }
+
+  async deleteComplianceSchedule(scheduleId) {
+    return this._request(`/api/compliance/schedules/${scheduleId}`, 'DELETE');
+  }
+
+  async getComplianceTrends({ framework, limit } = {}) {
+    const params = new URLSearchParams();
+    if (framework) params.set('framework', framework);
+    if (limit) params.set('limit', String(limit));
+    const qs = params.toString() ? `?${params.toString()}` : '';
+    return this._request(`/api/compliance/trends${qs}`, 'GET');
+  }
+
+  // -----------------------------------------------
+  // Drift Detection
+  // -----------------------------------------------
+
+  async computeDriftBaselines({ agent_id, lookback_days } = {}) {
+    return this._request('/api/drift/alerts', 'POST', { action: 'compute_baselines', agent_id, lookback_days });
+  }
+
+  async detectDrift({ agent_id, window_days } = {}) {
+    return this._request('/api/drift/alerts', 'POST', { action: 'detect', agent_id, window_days });
+  }
+
+  async recordDriftSnapshots() {
+    return this._request('/api/drift/alerts', 'POST', { action: 'record_snapshots' });
+  }
+
+  async listDriftAlerts({ agent_id, severity, acknowledged, limit } = {}) {
+    const params = new URLSearchParams();
+    if (agent_id) params.set('agent_id', agent_id);
+    if (severity) params.set('severity', severity);
+    if (acknowledged !== undefined) params.set('acknowledged', String(acknowledged));
+    if (limit) params.set('limit', String(limit));
+    const qs = params.toString() ? `?${params.toString()}` : '';
+    return this._request(`/api/drift/alerts${qs}`, 'GET');
+  }
+
+  async acknowledgeDriftAlert(alertId) {
+    return this._request(`/api/drift/alerts/${alertId}`, 'PATCH');
+  }
+
+  async deleteDriftAlert(alertId) {
+    return this._request(`/api/drift/alerts/${alertId}`, 'DELETE');
+  }
+
+  async getDriftStats({ agent_id } = {}) {
+    const params = agent_id ? `?agent_id=${encodeURIComponent(agent_id)}` : '';
+    return this._request(`/api/drift/stats${params}`, 'GET');
+  }
+
+  async getDriftSnapshots({ agent_id, metric, limit } = {}) {
+    const params = new URLSearchParams();
+    if (agent_id) params.set('agent_id', agent_id);
+    if (metric) params.set('metric', metric);
+    if (limit) params.set('limit', String(limit));
+    const qs = params.toString() ? `?${params.toString()}` : '';
+    return this._request(`/api/drift/snapshots${qs}`, 'GET');
+  }
+
+  async getDriftMetrics() {
+    return this._request('/api/drift/metrics', 'GET');
+  }
+
+  // -----------------------------------------------
+  // Learning Analytics
+  // -----------------------------------------------
+
+  async computeLearningVelocity({ agent_id, lookback_days, period } = {}) {
+    return this._request('/api/learning/analytics/velocity', 'POST', { agent_id, lookback_days, period });
+  }
+
+  async getLearningVelocity({ agent_id, limit } = {}) {
+    const params = new URLSearchParams();
+    if (agent_id) params.set('agent_id', agent_id);
+    if (limit) params.set('limit', String(limit));
+    const qs = params.toString() ? `?${params.toString()}` : '';
+    return this._request(`/api/learning/analytics/velocity${qs}`, 'GET');
+  }
+
+  async computeLearningCurves({ agent_id, lookback_days } = {}) {
+    return this._request('/api/learning/analytics/curves', 'POST', { agent_id, lookback_days });
+  }
+
+  async getLearningCurves({ agent_id, action_type, limit } = {}) {
+    const params = new URLSearchParams();
+    if (agent_id) params.set('agent_id', agent_id);
+    if (action_type) params.set('action_type', action_type);
+    if (limit) params.set('limit', String(limit));
+    const qs = params.toString() ? `?${params.toString()}` : '';
+    return this._request(`/api/learning/analytics/curves${qs}`, 'GET');
+  }
+
+  async getLearningAnalyticsSummary({ agent_id } = {}) {
+    const params = agent_id ? `?agent_id=${encodeURIComponent(agent_id)}` : '';
+    return this._request(`/api/learning/analytics/summary${params}`, 'GET');
+  }
+
+  async getMaturityLevels() {
+    return this._request('/api/learning/analytics/maturity', 'GET');
+  }
+
+  // --- Scoring Profiles -----------------------------------
+
+  async createScoringProfile(data) {
+    return this._request('POST', '/api/scoring/profiles', data);
+  }
+
+  async listScoringProfiles(params = {}) {
+    return this._request('GET', '/api/scoring/profiles', null, params);
+  }
+
+  async getScoringProfile(profileId) {
+    return this._request('GET', `/api/scoring/profiles/${profileId}`);
+  }
+
+  async updateScoringProfile(profileId, data) {
+    return this._request('PATCH', `/api/scoring/profiles/${profileId}`, data);
+  }
+
+  async deleteScoringProfile(profileId) {
+    return this._request('DELETE', `/api/scoring/profiles/${profileId}`);
+  }
+
+  async addScoringDimension(profileId, data) {
+    return this._request('POST', `/api/scoring/profiles/${profileId}/dimensions`, data);
+  }
+
+  async updateScoringDimension(profileId, dimensionId, data) {
+    return this._request('PATCH', `/api/scoring/profiles/${profileId}/dimensions/${dimensionId}`, data);
+  }
+
+  async deleteScoringDimension(profileId, dimensionId) {
+    return this._request('DELETE', `/api/scoring/profiles/${profileId}/dimensions/${dimensionId}`);
+  }
+
+  async scoreWithProfile(profileId, action) {
+    return this._request('POST', '/api/scoring/score', { profile_id: profileId, action });
+  }
+
+  async batchScoreWithProfile(profileId, actions) {
+    return this._request('POST', '/api/scoring/score', { profile_id: profileId, actions });
+  }
+
+  async getProfileScores(params = {}) {
+    return this._request('GET', '/api/scoring/score', null, params);
+  }
+
+  async getProfileScoreStats(profileId) {
+    return this._request('GET', '/api/scoring/score', null, { profile_id: profileId, view: 'stats' });
+  }
+
+  // --- Risk Templates ------------------------------------
+
+  async createRiskTemplate(data) {
+    return this._request('POST', '/api/scoring/risk-templates', data);
+  }
+
+  async listRiskTemplates(params = {}) {
+    return this._request('GET', '/api/scoring/risk-templates', null, params);
+  }
+
+  async updateRiskTemplate(templateId, data) {
+    return this._request('PATCH', `/api/scoring/risk-templates/${templateId}`, data);
+  }
+
+  async deleteRiskTemplate(templateId) {
+    return this._request('DELETE', `/api/scoring/risk-templates/${templateId}`);
+  }
+
+  // --- Auto-Calibration ----------------------------------
+
+  async autoCalibrate(options = {}) {
+    return this._request('POST', '/api/scoring/calibrate', options);
+  }
 }
 
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dashclaw",
-  "version": "1.9.4",
-  "description": "Full-featured agent toolkit for the DashClaw platform. 96+ methods across 22+ categories for action recording, context management, session handoffs, security scanning, behavior guard, compliance, task routing, identity binding, organization management, webhooks, bulk sync, and more.",
+  "version": "2.0.0",
+  "description": "Full-featured agent toolkit for the DashClaw platform. 178+ methods across 30+ categories for action recording, context management, session handoffs, security scanning, behavior guard, compliance, task routing, identity binding, organization management, webhooks, bulk sync, and more.",
   "type": "module",
   "publishConfig": {
     "access": "public"