dashclaw 2.13.0 → 3.0.0

package/README.md

@@ -1,4 +1,4 @@
-# DashClaw SDK (v2.12.0)
+# DashClaw SDK
 
 **Minimal governance runtime for AI agents.**
 
@@ -141,14 +141,16 @@ Telegram button.
 ### The rule every agent author needs to know
 
 **`waitForApproval()` must be called with the `action_id` returned by
-`createAction()`, NOT with the `action_id` returned by `guard()`.**
+`createAction()`, NOT with the guard decision's id.**
 
 These are two different records in two different tables:
 
-| Call | Returns `action_id` that refers to… | Prefix |
-|---|---|---|
-| `guard()` | A row in `guard_decisions` (the decision log) | `act_gd_…` |
-| `createAction()` | A row in `action_records` (the thing you're actually doing) | `act_…` |
+| Call | Returns an id that refers to… | Prefix | Field on the result |
+|---|---|---|---|
+| `guard()` | A row in `guard_decisions` (the decision log) | `act_gd_…` | `decision_id` (canonical); `action_id` is a **deprecated alias** of the same value |
+| `createAction()` | A row in `action_records` (the thing you're actually doing) | `act_…` | `action_id` |
+
+> The guard result's `action_id` field is a legacy alias of `decision_id` and will be removed in a future major — read `decision_id` from `guard()`, and `action_id` from `createAction()`.
 
 `waitForApproval()` polls `GET /api/actions/:id`, which is the
 `action_records` table. Passing it a `guard_decisions` ID (`act_gd_…`) will
@@ -221,6 +223,39 @@ answer to "does this need human review?" is always `action.status` on the
 Short version: **trust `action.status`, not `decision.decision`, for HITL
 branching.**
 
+### Non-fabrication checks
+
+When a `non_fabrication` guard policy is active, attach the outbound text and the
+facts it is allowed to state, and DashClaw verifies the content before the action
+proceeds — every amount, date, percentage, and registered ID must trace to an
+allowed fact, every required fact must be present, and no forbidden pattern may
+appear. A violation blocks (or routes to approval) and is recorded with a signed,
+re-verifiable receipt.
+
+```javascript
+const decision = await claw.guard({
+  action_type: 'message',
+  content: 'Hi Jane — your refund of $1,500.00 will arrive by June 1, 2026.',
+  sourceOfTruth: {
+    allowedFacts: [
+      { label: 'refund', value: '$1,500.00' },
+      { label: 'date', value: 'June 1, 2026' },
+    ],
+    requiredFacts: [{ label: 'name', value: 'Jane' }],
+    // forbiddenPatterns, extract (money/dates/percentages/patterns) are optional
+  },
+});
+// decision.decision === 'block' if the text states a fact not in sourceOfTruth.
+// decision.non_fabrication[0].receipt is an Ed25519-signed proof you can
+// re-verify at POST /api/integrity/verify (public key: /.well-known/jwks.json),
+// or null if the instance has no usable signing key — the verdict is enforced either way.
+```
+
+`createAction()` accepts the same `content` + `sourceOfTruth` fields. Fail-closed:
+a missing or malformed `sourceOfTruth` blocks. A signature proves integrity, the
+verdict, the ruleset version, and the issuer — not time-of-issuance or the
+correctness of prose with no extractable token.
+
 ---
 
 ## SDK Tiers
@@ -251,7 +286,7 @@ See:
 
 ---
 
-## SDK Surface Area (v2.12.0)
+## SDK Surface Area
 
 The v2 SDK exposes the stable governance runtime plus promoted execution domains in the canonical Node client:
 
@@ -264,6 +299,9 @@ The v2 SDK exposes the stable governance runtime plus promoted execution domains
 - `approveAction(id, decision, reasoning?)` -- Submit approval decisions from code
 - `getPendingApprovals()` -- List actions awaiting human review
 
+### Policies
+- `simulatePolicy({ policy_type, rules, days })` -- Side-effect-free dry-run of a proposed policy against recent historical actions before committing it (pairs with `guard()` for live enforcement). `policy_type` and `rules` are required; `days` is optional. Returns `{ summary: { total, matches, block, warn, require_approval, allow }, matches, sample_size, window_days }`. Persists nothing.
+
 ### Durable Execution Finality (v2.13.3+)
 Terminal outcome reporting that is one-shot, retry-safe, and immutable once non-pending. Separate from `updateOutcome`, which remains the lifecycle-PATCH path. Full spec: [`docs/architecture/durable-execution-finality.md`](../docs/architecture/durable-execution-finality.md). Detailed examples in the [Action Outcome](#action-outcome-durable-execution-finality) subsection of Execution Studio below.
 
@@ -289,6 +327,22 @@ Terminal outcome reporting that is one-shot, retry-safe, and immutable once non-
 - `getLessons({ actionType, limit })` -- Fetch consolidated lessons from scored outcomes.
 - `renderPrompt({ template_id, version_id, variables, record })` -- Fetch a rendered prompt template from DashClaw. `template_id` is required; `version_id` defaults to the active version; `variables` is an object of mustache values; `record: true` persists the render as a governance event.
 
+### Prompt Library
+
+Manage reusable prompt templates, their versions, and usage analytics. `renderPrompt` (above) fetches a rendered version; these manage the library itself. Mutations (`create*`, `update*`, `delete*`, version creation, and `activate*`) require an admin org role.
+
+- `listPromptTemplates({ category })` -- List prompt templates (each with `version_count` + `active_version`). Returns `{ templates }`.
+- `getPromptTemplate(templateId)` -- Fetch a single template.
+- `createPromptTemplate({ name, description, category })` -- Create a template (admin). `name` is required; `description` and `category` are optional. Returns `{ id, name, description, category }`.
+- `updatePromptTemplate(templateId, patch)` -- Update a template (admin). `patch` accepts `name`, `description`, `category`.
+- `deletePromptTemplate(templateId)` -- Delete a template plus its versions and runs (admin). Returns `{ deleted: true }`.
+- `listPromptVersions(templateId)` -- List versions for a template (newest first). Returns `{ versions }`.
+- `createPromptVersion(templateId, { content, model_hint, parameters, changelog })` -- Create a version (admin). `content` is required; `model_hint`, `parameters`, `changelog` are optional.
+- `getPromptVersion(templateId, versionId)` -- Fetch a single version.
+- `activatePromptVersion(templateId, versionId)` -- Activate a version (admin). Activating one version deactivates the others for that template.
+- `getPromptStats({ template_id })` -- Prompt usage analytics, optionally scoped to one template.
+- `listPromptRuns({ template_id, version_id, limit })` -- List recorded prompt runs.
+
 ### Learning Loop
 
 The guard response now includes a `learning` field when DashClaw has historical data for the agent and action type. This creates a closed learning loop: outcomes feed back into guard decisions automatically.
@@ -313,6 +367,9 @@ lessons.forEach(l => console.log(l.guidance));
 // guidance, sample_size
 ```
 
+- `recordDecision({ decision, context, reasoning, outcome, confidence, agent_id })` -- Record a decision/outcome into the learning ledger. `decision` is required; `agent_id` is auto-injected from the constructor when omitted. Returns `{ decision }`.
+- `getLearningRecommendations({ agent_id, action_type, include_metrics, lookback_days, limit })` -- Read learned recommendations for an agent/action type. `agent_id` defaults to the constructor's agent.
+
 ### Scoring Profiles
 - `createScorer(name, type, config)` -- Define automated evaluations.
 - `createScoringProfile(profile)` -- Create a weighted multi-dimensional scoring profile.
@@ -333,9 +390,17 @@ lessons.forEach(l => console.log(l.guidance));
 - `deleteRiskTemplate(templateId)` -- Delete a risk template.
 - `autoCalibrate(options)` -- Analyze historical actions and suggest percentile-based scoring scales.
 
+### Evaluations
+- `previewScorer({ scorer_type, config, sample })` -- Dry-run a scorer config against a sample action to validate a quality gate before creating a scorer or launching a run. `scorer_type` is required; `config` and `sample` are optional. Writes **no** `eval_scores` row (distinct from the scoring-profiles subsystem above). Returns `{ preview, scorer_type, result: { score, label, reasoning, error } }`.
+
 ### Messaging
 - `sendMessage({ to, type, subject, body, threadId, urgent })` -- Send a message to another agent or broadcast.
 - `getInbox({ type, unread, limit })` -- Retrieve inbox messages with optional filters.
+- `getSentMessages({ type, threadId, limit })` -- Retrieve messages this agent has sent.
+- `getMessages({ direction, type, unread, threadId, limit })` -- Retrieve messages with flexible filters.
+- `getMessage(messageId)` -- Fetch a single message by id.
+- `markRead(messageIds)` -- Mark messages as read for this agent (`PATCH /api/messages`, `action: 'read'`).
+- `archiveMessages(messageIds)` -- Archive messages for this agent (`PATCH /api/messages`, `action: 'archive'`).
 
 ```javascript
 // Send a message to another agent
@@ -382,21 +447,6 @@ if (result.recommendation === 'block') {
 }
 ```
 
-### Feedback
-- `submitFeedback({ action_id, rating, comment, category, tags, metadata })` -- Submit feedback on an action.
-
-```javascript
-// Submit feedback on an action
-await claw.submitFeedback({
-  action_id: 'act_123',
-  rating: 5,
-  comment: 'Deploy was smooth',
-  category: 'deployment',
-  tags: ['fast', 'clean'],
-  metadata: { deploy_duration_ms: 1200 }
-});
-```
-
 ### Context Threads
 - `createThread(thread)` -- Create a context thread for tracking multi-step work.
 - `addThreadEntry(threadId, content, entryType)` -- Add an entry to a context thread.
@@ -604,7 +654,7 @@ If your agent supports Model Context Protocol (Claude Code, Claude Desktop, Mana
 - **Open loops (3):** `dashclaw_loop_add`, `dashclaw_loop_list`, `dashclaw_loop_close` — action-scoped commitments (the "I will X later" tracker).
 - **Learning + retrospection (3):** `dashclaw_learning_log`, `dashclaw_learning_query`, `dashclaw_decisions_recent` — log + query non-obvious decisions; recent governed-action ledger.
 
-**4 resources:** `dashclaw://policies`, `dashclaw://capabilities`, `dashclaw://agent/{agent_id}/history`, `dashclaw://status`.
+**6 resources:** `dashclaw://policies`, `dashclaw://capabilities`, `dashclaw://agent/{agent_id}/history`, `dashclaw://status`, `dashclaw://code-sessions/projects`, `dashclaw://code-sessions/sessions/{session_id}`.
 
 ### Agent runtime endpoints (server-side, no SDK wrapper)
 
@@ -904,6 +954,9 @@ const { results } = await claw.searchKnowledgeCollection(
   { limit: 5 }
 );
 results.forEach(r => console.log(`${(r.score * 100).toFixed(1)}%: ${r.content.slice(0, 80)}...`));
+
+// Delete a collection (cascades its items + chunks)
+const { deleted, collection_id } = await claw.deleteKnowledgeCollection(collection.collection_id);
 ```
 
 ### Capability Runtime

package/dashclaw.js

@@ -1,6 +1,10 @@
 /**
- * DashClaw SDK v2.12.0 (Stable Runtime API)
+ * DashClaw SDK (Stable Runtime API)
  * Focused governance runtime client for AI agents.
+ *
+ * Version is the single source of truth in sdk/package.json — never
+ * hardcoded here, in the README header, or in app/ pages. Consumers
+ * read it at runtime via `import pkg from 'dashclaw/package.json'`.
  */
 
 import { createHash } from 'crypto';
@@ -62,8 +66,16 @@ class DashClaw {
   async _request(path, method = 'GET', body = null, params = null) {
     let url = `${this.baseUrl}${path}`;
     if (params) {
-      const qs = new URLSearchParams(params).toString();
-      if (qs) url += `?${qs}`;
+      // Skip undefined/null values. Passing them straight into URLSearchParams
+      // serializes the literal strings "undefined"/"null", which the receiving
+      // routes treat as real filter values and match zero rows. Falsy-but-valid
+      // values (0, false, '') are preserved. Mirrors the v1 SDK behavior.
+      const qs = new URLSearchParams();
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== null) qs.append(key, String(value));
+      }
+      const s = qs.toString();
+      if (s) url += `?${s}`;
     }
 
     const headers = {
@@ -78,7 +90,16 @@ class DashClaw {
       body: body ? JSON.stringify(body) : undefined
     });
 
-    const data = await res.json();
+    // Parse the body defensively. A non-JSON error body (a Vercel 502/504/413
+    // gateway page, a 429 rate-limit page) makes res.json() reject with a
+    // SyntaxError, which would propagate instead of the status-bearing error
+    // below and lose res.status. Fall back to {} so the real status is thrown.
+    let data = {};
+    try {
+      data = await res.json();
+    } catch {
+      data = {};
+    }
 
     if (!res.ok) {
       if (res.status === 403 && data.decision && data.decision.decision === 'block') {
@@ -100,6 +121,14 @@ class DashClaw {
   /**
    * POST /api/guard — "Can I do X?"
    * @param {Object} context
+   * @param {string} [context.content] - Outbound content to fabrication-check
+   *   (e.g. a drafted email/message). Pairs with `sourceOfTruth` and a
+   *   `non_fabrication` guard policy: every operational token (amounts, dates,
+   *   percentages, registered IDs) must trace to an allowed fact, or the action
+   *   is blocked / routed to approval. The response carries a signed,
+   *   re-verifiable receipt under `non_fabrication`.
+   * @param {Object} [context.sourceOfTruth] - The facts `content` is allowed to
+   *   state: `{ allowedFacts, requiredFacts, forbiddenPatterns?, extract? }`.
    * @returns {Promise<{
    *   decision: 'allow'|'block'|'require_approval'|'warn',
    *   action_id: string,
@@ -129,6 +158,13 @@ class DashClaw {
 
   /**
    * POST /api/actions — "I am attempting X."
+   *
+   * Optional non-fabrication fields: pass `content` (the outbound text) and
+   * `sourceOfTruth` ({ allowedFacts, requiredFacts, forbiddenPatterns?, extract? })
+   * to have a `non_fabrication` guard policy verify the content before the
+   * action proceeds. A violation blocks the action or routes it to approval and
+   * is recorded with a signed receipt in the decision ledger.
+   * @param {Object} action
    */
   async createAction(action) {
     return this._request('/api/actions', 'POST', {
@@ -289,7 +325,12 @@ class DashClaw {
     let printedBlock = false;
 
     while (Date.now() - startTime < timeout) {
-      const { action } = await this._request(`/api/actions/${actionId}`, 'GET');
+      // Return the full GET response (action + open_loops + assumptions +
+      // message_summary) so the polling fallback resolves to the same shape as
+      // the SSE fast-path above and the Python SDK. Returning only { action }
+      // dropped the related collections whenever SSE was unavailable.
+      const result = await this._request(`/api/actions/${actionId}`, 'GET');
+      const action = result.action;
 
       if (!printedBlock) {
         printedBlock = true;
@@ -319,14 +360,14 @@ class DashClaw {
       }
 
       if (action.status === 'pending_approval') wasPending = true;
-      if (action.approved_by) return { action };
+      if (action.approved_by) return result;
       if (action.status === 'failed' || action.status === 'cancelled') {
         throw new ApprovalDeniedError(action.error_message || 'Operator denied the action.', action.status);
       }
       if (wasPending && action.status !== 'pending_approval') {
         throw new Error(`Action ${actionId} left pending_approval state without explicit approval metadata (Status: ${action.status})`);
       }
-      if (!wasPending && action.status === 'running') return { action };
+      if (!wasPending && action.status === 'running') return result;
 
       await new Promise(r => setTimeout(r, interval));
     }
@@ -611,6 +652,68 @@ class DashClaw {
     });
   }
 
+  /**
+   * GET /api/messages — Fetch messages this agent has sent.
+   */
+  async getSentMessages({ type, threadId, limit } = {}) {
+    return this._request('/api/messages', 'GET', null, {
+      agent_id: this.agentId,
+      direction: 'sent',
+      ...(type && { type }),
+      ...(threadId && { thread_id: threadId }),
+      ...(limit && { limit }),
+    });
+  }
+
+  /**
+   * GET /api/messages — Fetch this agent's messages with flexible filters.
+   */
+  async getMessages({ direction, type, unread, threadId, limit } = {}) {
+    return this._request('/api/messages', 'GET', null, {
+      agent_id: this.agentId,
+      ...(direction && { direction }),
+      ...(type && { type }),
+      ...(unread != null && { unread }),
+      ...(threadId && { thread_id: threadId }),
+      ...(limit && { limit }),
+    });
+  }
+
+  /**
+   * GET /api/messages/:messageId — Fetch a single message by id.
+   */
+  async getMessage(messageId) {
+    return this._request(`/api/messages/${encodeURIComponent(messageId)}`, 'GET');
+  }
+
+  /**
+   * PATCH /api/messages — Mark messages as read for this agent. Direct messages
+   * are marked read only for the target agent (or dashboard); broadcasts update
+   * read_by for this agent.
+   * @param {string[]} messageIds - Message IDs (msg_*) to mark read.
+   * @returns {Promise<{ updated: number }>}
+   */
+  async markRead(messageIds) {
+    return this._request('/api/messages', 'PATCH', {
+      message_ids: messageIds,
+      action: 'read',
+      agent_id: this.agentId,
+    });
+  }
+
+  /**
+   * PATCH /api/messages — Archive messages for this agent.
+   * @param {string[]} messageIds - Message IDs (msg_*) to archive.
+   * @returns {Promise<{ updated: number }>}
+   */
+  async archiveMessages(messageIds) {
+    return this._request('/api/messages', 'PATCH', {
+      message_ids: messageIds,
+      action: 'archive',
+      agent_id: this.agentId,
+    });
+  }
+
   // ---------------------------------------------------------------------------
   // Session Handoffs
   // ---------------------------------------------------------------------------
@@ -650,25 +753,6 @@ class DashClaw {
     });
   }
 
-  // ---------------------------------------------------------------------------
-  // User Feedback
-  // ---------------------------------------------------------------------------
-
-  /**
-   * POST /api/feedback — Submit user feedback linked to an action.
-   */
-  async submitFeedback({ action_id, rating, comment, category, tags, metadata }) {
-    return this._request('/api/feedback', 'POST', {
-      action_id,
-      agent_id: this.agentId,
-      rating,
-      comment,
-      category,
-      tags,
-      metadata,
-    });
-  }
-
   // ---------------------------------------------------------------------------
   // Context Threads
   // ---------------------------------------------------------------------------
@@ -1041,6 +1125,13 @@ class DashClaw {
     });
   }
 
+  /**
+   * DELETE /api/knowledge/collections/:id — Delete a collection (cascades items + chunks).
+   */
+  async deleteKnowledgeCollection(collectionId) {
+    return this._request(`/api/knowledge/collections/${collectionId}`, 'DELETE');
+  }
+
   // ---------------------------------------------------------------------------
   // Execution Studio — Capability Registry
   // ---------------------------------------------------------------------------
@@ -1114,6 +1205,158 @@ class DashClaw {
   async getCapabilityHistory(capabilityId, filters = {}) {
     return this._request(`/api/capabilities/${capabilityId}/history`, 'GET', null, filters);
   }
+
+  // ---------------------------------------------------------------------------
+  // Prompt Library — reusable prompt templates, versions, render + analytics.
+  // renderPrompt() already lives in the rendering section above; these add the
+  // template/version management surface so the library is first-class in the SDK.
+  // Mutations (create/update/delete/version/activate) require an admin org role.
+  // ---------------------------------------------------------------------------
+
+  /**
+   * GET /api/prompts/templates — List prompt templates (each with version_count + active_version).
+   * @param {Object} [filters={}] - { category }
+   */
+  async listPromptTemplates(filters = {}) {
+    return this._request('/api/prompts/templates', 'GET', null, filters);
+  }
+
+  /**
+   * GET /api/prompts/templates/:id — Fetch a single template.
+   */
+  async getPromptTemplate(templateId) {
+    return this._request(`/api/prompts/templates/${templateId}`, 'GET');
+  }
+
+  /**
+   * POST /api/prompts/templates — Create a template (admin). { name, description?, category? }
+   */
+  async createPromptTemplate(data) {
+    return this._request('/api/prompts/templates', 'POST', data);
+  }
+
+  /**
+   * PATCH /api/prompts/templates/:id — Update a template (admin). { name?, description?, category? }
+   */
+  async updatePromptTemplate(templateId, patch) {
+    return this._request(`/api/prompts/templates/${templateId}`, 'PATCH', patch);
+  }
+
+  /**
+   * DELETE /api/prompts/templates/:id — Delete a template + its versions/runs (admin).
+   */
+  async deletePromptTemplate(templateId) {
+    return this._request(`/api/prompts/templates/${templateId}`, 'DELETE');
+  }
+
+  /**
+   * GET /api/prompts/templates/:id/versions — List versions (newest first).
+   */
+  async listPromptVersions(templateId) {
+    return this._request(`/api/prompts/templates/${templateId}/versions`, 'GET');
+  }
+
+  /**
+   * POST /api/prompts/templates/:id/versions — Create a version (admin).
+   * @param {string} templateId
+   * @param {Object} data - { content, model_hint?, parameters?, changelog? }
+   */
+  async createPromptVersion(templateId, data) {
+    return this._request(`/api/prompts/templates/${templateId}/versions`, 'POST', data);
+  }
+
+  /**
+   * GET /api/prompts/templates/:id/versions/:versionId — Fetch a single version.
+   */
+  async getPromptVersion(templateId, versionId) {
+    return this._request(`/api/prompts/templates/${templateId}/versions/${versionId}`, 'GET');
+  }
+
+  /**
+   * POST /api/prompts/templates/:id/versions/:versionId — Activate a version (admin).
+   * Activating one version deactivates the others for that template.
+   */
+  async activatePromptVersion(templateId, versionId) {
+    return this._request(`/api/prompts/templates/${templateId}/versions/${versionId}`, 'POST');
+  }
+
+  /**
+   * GET /api/prompts/stats — Prompt usage analytics.
+   * @param {Object} [filters={}] - { template_id }
+   */
+  async getPromptStats(filters = {}) {
+    return this._request('/api/prompts/stats', 'GET', null, filters);
+  }
+
+  /**
+   * GET /api/prompts/runs — List recorded prompt runs.
+   * @param {Object} [filters={}] - { template_id, version_id, limit }
+   */
+  async listPromptRuns(filters = {}) {
+    return this._request('/api/prompts/runs', 'GET', null, filters);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Learning — record decisions/outcomes and read back recommendations so the
+  // governance loop improves over time.
+  // ---------------------------------------------------------------------------
+
+  /**
+   * POST /api/learning — Record a decision/outcome into the learning ledger.
+   * @param {Object} entry - { decision (required), context?, reasoning?, outcome?, confidence?, agent_id? }
+   * @returns {Promise<{ decision: Object }>}
+   */
+  async recordDecision(entry) {
+    return this._request('/api/learning', 'POST', {
+      ...entry,
+      agent_id: entry.agent_id || this.agentId,
+    });
+  }
+
+  /**
+   * GET /api/learning/recommendations — Read learned recommendations for an agent/action_type.
+   * @param {Object} [filters={}] - { agent_id, action_type, include_metrics, lookback_days, limit }
+   */
+  async getLearningRecommendations(filters = {}) {
+    return this._request('/api/learning/recommendations', 'GET', null, {
+      ...filters,
+      agent_id: filters.agent_id || this.agentId,
+    });
+  }
+
+  // ---------------------------------------------------------------------------
+  // Policies — dry-run a proposed policy against historical actions before
+  // committing it (no persistence; pairs with guard() for live enforcement).
+  // ---------------------------------------------------------------------------
+
+  /**
+   * POST /api/policies/simulate — Simulate a single proposed policy against
+   * recent historical actions. Side-effect-free.
+   * @param {Object} args - { policy_type (required), rules (Object, required), days? }
+   * @returns {Promise<{ summary: { total, matches, block, warn, require_approval, allow }, matches: Array, sample_size, window_days }>}
+   */
+  async simulatePolicy({ policy_type, rules, days } = {}) {
+    return this._request('/api/policies/simulate', 'POST', {
+      policy_type,
+      rules,
+      ...(days !== undefined ? { days } : {}),
+    });
+  }
+
+  // ---------------------------------------------------------------------------
+  // Evaluations — preview a scorer (dry-run, no eval_scores written).
+  // ---------------------------------------------------------------------------
+
+  /**
+   * POST /api/evaluations/scorers/preview — Dry-run a scorer config against a
+   * sample action without persisting a score. Use to validate a quality gate
+   * (e.g. branch-finish scoring) before creating a scorer or launching a run.
+   * @param {Object} args - { scorer_type (required), config?, sample? }
+   * @returns {Promise<{ preview: true, scorer_type, result: { score, label, reasoning, error } }>}
+   */
+  async previewScorer({ scorer_type, config, sample } = {}) {
+    return this._request('/api/evaluations/scorers/preview', 'POST', { scorer_type, config, sample });
+  }
 }
 
 export { DashClaw, ApprovalDeniedError, GuardBlockedError };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dashclaw",
-  "version": "2.13.0",
+  "version": "3.0.0",
   "description": "Minimal governance runtime for AI agents. Intercept, govern, and verify agent actions.",
   "type": "module",
   "publishConfig": {