@akalsey/sapience-feedback 0.1.1

package/README.md

@@ -0,0 +1,141 @@
+# OpenClaw Feedback
+
+You give feedback constantly — correcting a format choice, confirming something worked well, redirecting how the agent handled a decision. This plugin catches those signals from your normal chat messages and makes them permanent.
+
+A correction becomes a calibration. A confirmation reinforces a pattern. The sapience calibration profile updates in real time so the agent's behavior reflects how you actually want it to operate.
+
+This plugin is part of the Sapience Suite that gives your OpenClaw agent genuine agency — not just the ability to execute tasks, but the judgment to know when to act, when to ask, when to propose, and when to say "I'm not sure how you want me to handle this."
+
+This plugin can be used without Sapience if all you want to do is have the agent track and incorporate feedback.
+
+---
+
+## Setup
+
+### Prerequisites
+
+None required. This plugin works standalone.
+
+If `sapience` is also installed, the calibration profile at `~/.openclaw/sapience/calibration.json` feeds directly into autonomy routing. Without sapience, the profile is still written but nothing reads it.
+
+### Install
+
+```bash
+openclaw plugins install npm:@akalsey/sapience-feedback
+```
+
+### Configuration
+
+```json
+{
+  "plugins": {
+    "sapience-feedback": {
+      "logPath": "~/.openclaw/sapience/feedback.md",
+      "calibrationPath": "~/.openclaw/sapience/calibration.json",
+      "memoryEnabled": true
+    }
+  }
+}
+```
+
+All settings are optional — defaults are used if omitted.
+
+---
+
+## What it detects
+
+The plugin scans every message you send for three types of signals:
+
+### Corrections
+
+Phrases that express "don't do that" or "do it differently":
+
+- `don't update OKRs for other teams without asking`
+- `stop doing that`
+- `never push to main without a PR`
+- `use the company template, not the default`
+- `you shouldn't have done that without checking`
+
+**Effect:** Confidence on the matching domain/action-class drops by 0.3.
+
+### Confirmations
+
+Phrases that express "yes, that was right":
+
+- `yes exactly`
+- `good call`
+- `perfect, keep doing that`
+- `that's exactly right`
+
+**Effect:** Confidence on the matching domain/action-class increases by 0.1.
+
+### Tier adjustments
+
+Explicit instructions about how much autonomy you want:
+
+- `just do it` / `you don't need to ask` → bumps toward **Act**
+- `always ask me first` / `ask me before touching X` → bumps toward **Ask**
+
+**Effect:** Tier for matching domain/action-class is updated directly.
+
+---
+
+## Domain detection
+
+The plugin extracts domains from context in your message:
+
+| Text contains | Domain |
+|---------------|--------|
+| `github`, `PR`, `push` | `github` |
+| `Salesforce` | `salesforce` |
+| `PostHog` | `posthog` |
+| `Slack` | `slack` |
+| `slides`, `deck` | `slides` |
+| `OKR` | `okr-system` |
+| `Linear` | `linear` |
+| (nothing matched) | `general` |
+
+Domain detection is keyword-based, not semantic. Be explicit when giving feedback: "don't update Salesforce records" works better than "don't do that" (which routes to `general`).
+
+---
+
+## Reading the feedback log
+
+```bash
+cat ~/.openclaw/sapience/feedback.md
+```
+
+Each entry shows:
+- Signal type (correction / confirmation / tier_adjustment)
+- Domain and action class affected
+- The original message
+- Tier adjustment, if any
+- Meta-pointer written to memory, for corrections
+
+---
+
+## Meta-memory pointers
+
+For corrections, the plugin calls `api.memory.add` to write a behavioral reminder directly into OpenClaw's native memory:
+
+> "Before working on github / github/action: check feedback log — correction recorded: 'don't push to main without a PR'"
+
+Future sessions surface this pointer automatically through OpenClaw's standard memory system. No separate memory plugin is required — memory writes go through the same API OpenClaw itself uses.
+
+To disable memory writes, set `memoryEnabled: false` in config.
+
+---
+
+## Troubleshooting
+
+**Feedback not being detected**
+The plugin only scans messages you send (role: `user`), not the agent's responses. Make sure you're sending the correction as a chat message, not just thinking it.
+
+**Calibration not updating**
+Check that `calibration.json` exists and has an entry for the domain you're correcting. Feedback only updates *existing* entries — it doesn't create new ones. New domains are created by `sapience` when it first routes a proposal in that domain.
+
+**Domain matching to "general" when it shouldn't**
+Add more specific keywords to your feedback message. "Don't do that" → "Don't update the Salesforce contact without asking."
+
+**Too many false positives in the feedback log**
+The pattern matching is intentionally broad. If casual phrases are being captured incorrectly, check the log and note which patterns are misfiring. You can't currently tune the patterns without modifying `src/feedback-parser.ts`.

package/dist/index.js

@@ -0,0 +1 @@
+export { default } from "./src/service.js";

package/dist/src/calibration-bridge.js

@@ -0,0 +1,39 @@
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+import { resolvePath } from "./utils.js";
+async function loadProfile(path) {
+    try {
+        return JSON.parse(await readFile(resolvePath(path), "utf-8"));
+    }
+    catch {
+        return [];
+    }
+}
+async function saveProfile(profile, path) {
+    const resolved = resolvePath(path);
+    await mkdir(dirname(resolved), { recursive: true });
+    await writeFile(resolved, JSON.stringify(profile, null, 2), "utf-8");
+}
+export async function applyFeedbackToProfile(signal, calibrationPath) {
+    const profile = await loadProfile(calibrationPath);
+    if (profile.length === 0)
+        return;
+    const idx = profile.findIndex(e => e.domain === signal.domain && e.action_class === signal.action_class);
+    if (idx === -1)
+        return;
+    const entry = profile[idx];
+    let updated;
+    if (signal.type === "confirmation") {
+        updated = { ...entry, confidence: Math.min(1, entry.confidence + 0.1), confirmed_count: entry.confirmed_count + 1, last_calibrated: new Date().toISOString() };
+    }
+    else if (signal.type === "correction") {
+        updated = { ...entry, confidence: Math.max(0, entry.confidence - 0.3), corrected_count: entry.corrected_count + 1, last_calibrated: new Date().toISOString() };
+    }
+    else if (signal.type === "tier_adjustment" && signal.suggested_tier) {
+        updated = { ...entry, tier: signal.suggested_tier, last_calibrated: new Date().toISOString() };
+    }
+    else {
+        return;
+    }
+    await saveProfile(profile.map((e, i) => i === idx ? updated : e), calibrationPath);
+}

package/dist/src/feedback-parser.js

@@ -0,0 +1,73 @@
+const CORRECTION_PATTERNS = [
+    /\bdon'?t\b.{0,60}\b(do|update|change|delete|send|push|write|modify|set|use)\b/i,
+    /\bstop\b.{0,40}\b(doing|that|this)\b/i,
+    /\bnever\b.{0,60}\b(do|update|change|delete|send|push|write)\b/i,
+    /\bshouldn'?t\s+(have|be)\b/i,
+    /\bwrong\s+(format|approach|template|way)\b/i,
+    /\b(use|should use|always use)\s+the\s+\w/i,
+];
+const TIER_UP_PATTERNS = [
+    /\bjust\s+do\s+it\b/i,
+    /\byou\s+don'?t\s+need\s+to\s+ask\b/i,
+    /\bgo\s+ahead\s+without\s+asking\b/i,
+    /\bdo\s+it\s+automatically\b/i,
+];
+const TIER_DOWN_PATTERNS = [
+    /\balways\s+ask\s+(me\s+)?(first|before)\b/i,
+    /\bask\s+me\s+before\b/i,
+    /\bdon'?t\s+do\s+that\s+without\s+(asking|checking)\b/i,
+    /\bnext\s+time\s+(check|ask|confirm)\b/i,
+];
+const CONFIRMATION_PATTERNS = [
+    /\byes[\s,]+exactly\b/i,
+    /\bgood\s+call\b/i,
+    /\bperfect[,.]?\s*(keep|that'?s|yes)?\b/i,
+    /\bkeep\s+doing\s+that\b/i,
+    /\bthat'?s\s+(exactly\s+)?right\b/i,
+];
+const DOMAIN_PATTERNS = [
+    [/github/i, "github"],
+    [/salesforce/i, "salesforce"],
+    [/posthog/i, "posthog"],
+    [/lovable/i, "lovable"],
+    [/slack/i, "slack"],
+    [/slides?|deck/i, "slides"],
+    [/okr/i, "okr-system"],
+    [/linear/i, "linear"],
+];
+function extractDomain(text) {
+    for (const [pattern, domain] of DOMAIN_PATTERNS) {
+        if (pattern.test(text))
+            return domain;
+    }
+    return "general";
+}
+export function parseMessage(text) {
+    const signals = [];
+    const domain = extractDomain(text);
+    for (const pattern of TIER_UP_PATTERNS) {
+        if (pattern.test(text)) {
+            signals.push({ type: "tier_adjustment", domain, action_class: "general", message: text, suggested_tier: "act", raw_text: text });
+            return signals;
+        }
+    }
+    for (const pattern of TIER_DOWN_PATTERNS) {
+        if (pattern.test(text)) {
+            signals.push({ type: "tier_adjustment", domain, action_class: "general", message: text, suggested_tier: "ask", raw_text: text });
+            return signals;
+        }
+    }
+    for (const pattern of CORRECTION_PATTERNS) {
+        if (pattern.test(text)) {
+            signals.push({ type: "correction", domain, action_class: "general", message: text, raw_text: text });
+            return signals;
+        }
+    }
+    for (const pattern of CONFIRMATION_PATTERNS) {
+        if (pattern.test(text)) {
+            signals.push({ type: "confirmation", domain, action_class: "general", message: text, raw_text: text });
+            return signals;
+        }
+    }
+    return signals;
+}

package/dist/src/log-writer.js

@@ -0,0 +1,22 @@
+import { appendFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+import { resolvePath } from "./utils.js";
+export async function appendFeedback(entry, logPath) {
+    const resolved = resolvePath(logPath);
+    await mkdir(dirname(resolved), { recursive: true });
+    const lines = [
+        `## ${entry.detected_at}`,
+        ``,
+        `**Signal type:** ${entry.signal.type}`,
+        `**Domain:** ${entry.signal.domain} / ${entry.signal.action_class}`,
+        `**Message:** "${entry.signal.message}"`,
+    ];
+    if (entry.signal.suggested_tier) {
+        lines.push(`**Tier adjustment:** → ${entry.signal.suggested_tier}`);
+    }
+    if (entry.meta_pointer) {
+        lines.push(`**Meta-pointer written:** ${entry.meta_pointer}`);
+    }
+    lines.push(``, `---`, ``);
+    await appendFile(resolved, lines.join("\n") + "\n", "utf-8");
+}

package/dist/src/service.js

@@ -0,0 +1,56 @@
+// src/service.ts
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { DEFAULT_CONFIG } from "./types.js";
+import { resolveDataPath, generateId } from "./utils.js";
+import { parseMessage } from "./feedback-parser.js";
+import { appendFeedback } from "./log-writer.js";
+import { applyFeedbackToProfile } from "./calibration-bridge.js";
+function mergeConfig(raw, workspaceDir) {
+    return {
+        ...DEFAULT_CONFIG,
+        ...raw,
+        logPath: resolveDataPath(raw.logPath, workspaceDir, DEFAULT_CONFIG.logPath),
+        calibrationPath: resolveDataPath(raw.calibrationPath, workspaceDir, DEFAULT_CONFIG.calibrationPath),
+    };
+}
+function buildMetaPointer(signal) {
+    return `Before working on ${signal.domain} / ${signal.action_class}: check feedback log — correction recorded: "${signal.raw_text.slice(0, 80)}"`;
+}
+export default definePluginEntry({
+    id: "sapience-feedback",
+    name: "Sapience Feedback",
+    description: "Persists behavioral corrections and confirmations into the sapience calibration profile",
+    register(api) {
+        const workspaceDir = api.runtime.agent.resolveAgentWorkspaceDir(api.pluginConfig);
+        const config = mergeConfig(api.pluginConfig, workspaceDir);
+        if (api.session?.onMessage) {
+            api.session.onMessage(async (message) => {
+                if (message.role !== "user")
+                    return;
+                try {
+                    const signals = parseMessage(message.content);
+                    for (const signal of signals) {
+                        const metaPointer = signal.type === "correction" ? buildMetaPointer(signal) : undefined;
+                        const entry = {
+                            id: generateId(),
+                            detected_at: new Date().toISOString(),
+                            signal,
+                            meta_pointer: metaPointer,
+                        };
+                        await appendFeedback(entry, config.logPath);
+                        await applyFeedbackToProfile(signal, config.calibrationPath);
+                        if (metaPointer && config.memoryEnabled) {
+                            await api.memory?.add({
+                                content: metaPointer,
+                                metadata: { tags: ["feedback", "behavioral-correction", signal.domain], source: "feedback" },
+                            });
+                        }
+                    }
+                }
+                catch {
+                    // don't let feedback processing errors disrupt the session
+                }
+            });
+        }
+    },
+});

package/dist/src/types.js

@@ -0,0 +1,5 @@
+export const DEFAULT_CONFIG = {
+    logPath: "sapience/feedback.md",
+    calibrationPath: "sapience/calibration.json",
+    memoryEnabled: true,
+};

package/dist/src/utils.js

@@ -0,0 +1,15 @@
+import { homedir } from "os";
+import { join } from "path";
+export function resolvePath(p) {
+    return p.startsWith("~/") ? join(homedir(), p.slice(2)) : p;
+}
+export function resolveDataPath(override, workspaceDir, defaultRelative) {
+    if (!override)
+        return join(workspaceDir, defaultRelative);
+    if (override.startsWith('/') || override.startsWith('~/'))
+        return resolvePath(override);
+    return join(workspaceDir, override);
+}
+export function generateId() {
+    return `fb-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}

package/openclaw.plugin.json

@@ -0,0 +1,11 @@
+{
+  "id": "sapience-feedback",
+  "name": "Sapience Feedback",
+  "version": "0.1.0",
+  "description": "Persists behavioral corrections and confirmations from session messages into the sapience calibration profile",
+  "activation": { "onStartup": true },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": true
+  }
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@akalsey/sapience-feedback",
+  "version": "0.1.1",
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "openclaw.plugin.json",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "openclaw": {
+    "extensions": [
+      "./dist/index.js"
+    ],
+    "compat": {
+      "pluginApi": ">=2026.3.24-beta.2",
+      "minGatewayVersion": "2026.3.24-beta.2"
+    },
+    "install": {
+      "localPath": "."
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "openclaw": "latest",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0"
+  },
+  "peerDependencies": {
+    "openclaw": ">=2026.3.24-beta.2"
+  }
+}