@akalsey/openclaw-sapience 0.1.0

package/README.md

@@ -0,0 +1,169 @@
+# Sapience Suite for OpenClaw
+
+The Sapience Suite transforms OpenClaw from a reactive assistant into a proactive agent with genuine autonomy. It learns when to act, when to propose, when to ask, and when to explore — calibrated to your actual preferences, not a static policy you had to configure upfront.
+
+The suite has four plugins that each work independently and compose into a whole:
+
+| Plugin | Does |
+|--------|------|
+| `openclaw-proactive-thinking` | Periodic thinking passes; generates observations and proposals |
+| `openclaw-sapience` *(this plugin)* | Routes proposals through autonomy tiers; calibrates to your preferences; delivers weekly digest |
+| `openclaw-feedback` | Captures corrections and confirmations from chat; recalibrates autonomy profile |
+| `openclaw-goals` | Accepts fuzzy long-running goals; decomposes them; tracks progress; weekly status |
+
+## How it works
+
+`openclaw-proactive-thinking` runs a thinking pass every 15 minutes and writes proposals to `proposals.jsonl`. `openclaw-sapience` reads that sidecar, routes each proposal through an autonomy decision function, and delivers it to your main session at the right level:
+
+- **Act** — high-confidence, reversible, low-blast-radius → done immediately, brief notification
+- **Propose** — worth doing, needs your approval → surfaces it for a yes/no
+- **Ask** — agent can do it but needs one piece of information → asks exactly what's needed
+- **Explore** — the problem is real but the right path is unclear → presents 2–3 options with tradeoffs
+- **Learning** — new domain or low confidence → calibration question before acting
+
+The routing decision uses a calibration profile: per-domain, per-action-class entries with a confidence score. Until a domain is calibrated, everything goes through **Learning** mode and will ask you to confirm it's choices before acting.
+
+## Setup
+
+### Prerequisites
+
+Install `openclaw-proactive-thinking` first. Sapience reads its output.
+
+### Install order
+
+```bash
+openclaw plugins install local:/path/to/openclaw-proactive-thinking
+openclaw plugins install local:/path/to/openclaw-sapience
+openclaw plugins install local:/path/to/openclaw-feedback   # optional
+openclaw plugins install local:/path/to/openclaw-goals       # optional
+```
+
+### Configuration (sapience)
+
+```json
+{
+  "plugins": {
+    "sapience": {
+      "autonomy": {
+        "defaultTier": "propose",
+        "domainFloors": {
+          "github": "propose",
+          "salesforce": "ask"
+        }
+      },
+      "learning": {
+        "enabled": true,
+        "confidenceDropThreshold": 0.4
+      },
+      "digest": {
+        "enabled": true,
+        "day": "friday",
+        "time": "17:00"
+      }
+    }
+  }
+}
+```
+
+**`defaultTier`** — What tier to use for uncalibrated actions when learning mode is off. Default: `"propose"`.
+
+**`domainFloors`** — Minimum tier for a domain. If calibration says `act` for a domain with floor `propose`, it routes as `propose`. Use this for domains where you never want autonomous action regardless of confidence.
+
+**`confidenceDropThreshold`** — Below this confidence, Learning mode fires instead of the calibrated tier. Default: `0.4`.
+
+**`digest`** — Weekly summary of what was acted on, what's pending review, and what's planned. Delivered at the configured day and time.
+
+### Output files
+
+| File | Purpose |
+|------|---------|
+| `~/.openclaw/sapience/calibration.json` | Autonomy calibration profile (shared with `openclaw-feedback`) |
+| `~/.openclaw/sapience/processed-passes.json` | Tracks which proactive-thinking passes have been routed |
+| `~/.openclaw/sapience/action-log.md` | Log of every Act-tier item delivered |
+
+## Training: calibrating autonomy
+
+Calibration is the process of teaching the agent your preferences per domain and action type.
+
+### Learning mode
+
+When sapience sees a domain/action-class combination with no calibration data (or low confidence), it fires a **Learning** prompt instead of acting:
+
+> "I noticed [item]. My instinct is to surface this as a proposal. Is that the right level of initiative, or would you prefer I handle this differently?"
+
+You respond to confirm or redirect. The calibration profile updates accordingly.
+
+### How confidence builds
+
+| Event | Effect |
+|-------|--------|
+| You confirm the proposed approach ("yes, that's right") | Confidence +0.1 |
+| You correct the approach ("no, just do it") | Confidence −0.3, tier updated |
+| No feedback | Confidence unchanged |
+
+Confidence caps at 1.0 and floors at 0.0. A domain needs roughly 3–5 confirmations to reach the default threshold (0.4) from zero.
+
+### Reading the calibration profile
+
+```bash
+cat ~/.openclaw/sapience/calibration.json
+```
+
+Each entry:
+```json
+{
+  "domain": "github",
+  "action_class": "github/action",
+  "tier": "propose",
+  "confidence": 0.7,
+  "confirmed_count": 4,
+  "corrected_count": 1,
+  "last_calibrated": "2026-05-20T14:00:00Z",
+  "notes": ""
+}
+```
+
+### Resetting a domain
+
+Delete the entry from `calibration.json` to reset a domain to Learning mode.
+
+## Day-to-day use
+
+Once installed, the suite runs in the background. What you'll see in your sessions:
+
+- `[SAPIENCE: PROPOSE]` — a proposal needing your yes/no
+- `[SAPIENCE: ACT]` — notification of something just done
+- `[SAPIENCE: ASK]` — a question needed before proceeding
+- `[SAPIENCE: EXPLORE]` — a problem with options for you to choose from
+- `[SAPIENCE: CALIBRATE]` — a calibration question for a new domain
+- `[SAPIENCE: WEEKLY DIGEST]` — Friday summary of actions, pending items, and plans
+
+You don't need to do anything to receive these — they arrive as injected turns in your active session.
+
+### Weekly digest
+
+Every Friday at 5pm (or your configured time), the digest summarizes:
+- What was acted on this week
+- Proposals still waiting on your input
+- What's planned for next week
+
+## Troubleshooting
+
+**Nothing being delivered to my session**
+Check that proactive-thinking is writing `proposals.jsonl`:
+```bash
+cat ~/.openclaw/proactive-thinking/proposals.jsonl | tail -1 | python3 -m json.tool
+```
+If the file is empty or missing, proactive-thinking isn't running. Check its logs first.
+
+**Everything is going to Learning mode**
+Expected behavior for the first week or two. Each calibration response builds confidence. If it continues beyond 2–3 weeks for a domain you use daily, check `calibration.json` — entries may not be getting written.
+
+**Calibration profile not updating**
+Feedback plugin (`openclaw-feedback`) handles explicit correction/confirmation capture. If it's not installed, calibrations only happen through the Learning mode prompts. Install `openclaw-feedback` for passive capture from chat messages.
+
+**`domainFloors` not respected**
+Floors only prevent routing *above* the floor — they don't push Act-tier items down to propose. `"github": "propose"` means github/action can be at most `propose`, `ask`, or `explore`, never `act`. If you're seeing Act-tier github items, check the floor config key matches the domain name exactly (lowercase).
+
+**Duplicate deliveries**
+`processed-passes.json` tracks which proactive-thinking passes have been routed. If it's missing or corrupt, passes get re-delivered. Delete it and it will rebuild from the current pass forward.

package/dist/index.js

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

package/dist/src/action-log.js

@@ -0,0 +1,20 @@
+import { appendFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+import { resolvePath } from "./utils.js";
+export async function appendAction(item, note, logPath) {
+    const resolved = resolvePath(logPath);
+    await mkdir(dirname(resolved), { recursive: true });
+    const ts = new Date().toISOString();
+    const entry = [
+        `## ${ts}`,
+        ``,
+        `**Action:** ${item.text}`,
+        `**Domain/class:** ${item.domain} / ${item.action_class}`,
+        `**Tier:** Act (confidence ${item.confidence.toFixed(2)})`,
+        `**Note:** ${note}`,
+        ``,
+        `---`,
+        ``,
+    ].join("\n");
+    await appendFile(resolved, entry, "utf-8");
+}

package/dist/src/autonomy.js

@@ -0,0 +1,18 @@
+import { getEntry, needsCalibration } from "./calibration.js";
+const TIER_ORDER = ["act", "propose", "ask", "explore"];
+export function routeItem(item, profile, config) {
+    const entry = getEntry(profile, item.domain, item.action_class);
+    if (config.learning.enabled && needsCalibration(entry, config.learning.confidenceDropThreshold)) {
+        return { ...item, tier: "learning", confidence: entry?.confidence ?? 0 };
+    }
+    let tier = (entry?.tier ?? config.autonomy.defaultTier);
+    const confidence = entry?.confidence ?? 0;
+    const floor = config.autonomy.domainFloors[item.domain];
+    if (floor) {
+        const tierIdx = TIER_ORDER.indexOf(tier);
+        const floorIdx = TIER_ORDER.indexOf(floor);
+        if (tierIdx !== -1 && floorIdx !== -1 && tierIdx < floorIdx)
+            tier = floor;
+    }
+    return { ...item, tier, confidence };
+}

package/dist/src/calibration.js

@@ -0,0 +1,53 @@
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+import { resolvePath } from "./utils.js";
+export async function loadProfile(path) {
+    try {
+        return JSON.parse(await readFile(resolvePath(path), "utf-8"));
+    }
+    catch {
+        return [];
+    }
+}
+export 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 function getEntry(profile, domain, action_class) {
+    return profile.find(e => e.domain === domain && e.action_class === action_class) ?? null;
+}
+export function needsCalibration(entry, threshold) {
+    return !entry || entry.confidence < threshold;
+}
+export function upsertEntry(profile, domain, action_class, update) {
+    const idx = profile.findIndex(e => e.domain === domain && e.action_class === action_class);
+    const base = idx === -1
+        ? {
+            domain, action_class, tier: "propose", confidence: 0,
+            confirmed_count: 0, corrected_count: 0,
+            last_calibrated: new Date().toISOString(), notes: "",
+        }
+        : profile[idx];
+    const updated = { ...base, ...update, last_calibrated: new Date().toISOString() };
+    if (idx === -1)
+        return [...profile, updated];
+    return profile.map((e, i) => i === idx ? updated : e);
+}
+export function applyConfirmation(entry) {
+    return {
+        ...entry,
+        confidence: Math.min(1, entry.confidence + 0.1),
+        confirmed_count: entry.confirmed_count + 1,
+        last_calibrated: new Date().toISOString(),
+    };
+}
+export function applyCorrection(entry, newTier) {
+    return {
+        ...entry,
+        tier: newTier,
+        confidence: Math.max(0, entry.confidence - 0.3),
+        corrected_count: entry.corrected_count + 1,
+        last_calibrated: new Date().toISOString(),
+    };
+}

package/dist/src/delivery.js

@@ -0,0 +1,54 @@
+import { appendAction } from "./action-log.js";
+export function buildTierPrompt(item) {
+    switch (item.tier) {
+        case "act":
+            return `[SAPIENCE: ACT] High-confidence action — execute immediately without asking the user for approval, then notify them briefly.
+
+Action: ${item.text}
+Domain: ${item.domain} / ${item.action_class}
+Confidence: ${(item.confidence * 100).toFixed(0)}%
+
+Execute now. After completion, send a brief message: "I just [what you did]. [Reversible/not reversible]."`;
+        case "propose":
+            return `[SAPIENCE: PROPOSE] A thinking pass identified this as worth doing. Surface it to the user for approval.
+
+Proposal: ${item.text}
+Priority: ${item.priority}/5
+
+Present this concisely and ask if they'd like you to proceed.`;
+        case "ask":
+            return `[SAPIENCE: ASK] You're capable of this but need information to proceed. Ask the user for exactly what you need.
+
+Action: ${item.text}
+Domain: ${item.domain}
+
+State what you can do, then ask the one or two specific questions that would unblock you.`;
+        case "explore":
+            return `[SAPIENCE: EXPLORE] A problem was identified but the right approach isn't obvious. Present it with options.
+
+Problem: ${item.text}
+Priority: ${item.priority}/5
+
+Name the problem, offer 2–3 concrete approaches with their tradeoffs, and ask which fits what they're trying to accomplish.`;
+        case "learning":
+            return `[SAPIENCE: CALIBRATE] This domain/action class hasn't been calibrated yet. Check with the user before routing.
+
+Item: ${item.text}
+Domain: ${item.domain} / ${item.action_class}
+Current confidence: ${(item.confidence * 100).toFixed(0)}%
+
+Tell the user: "I noticed [item]. My instinct is to [what you'd do at the propose tier]. Is that the right level of initiative, or would you prefer I handle this differently?"`;
+    }
+}
+export async function deliverItems(items, api, config) {
+    const sorted = [...items].sort((a, b) => (a.tier === "act" ? 0 : 1) - (b.tier === "act" ? 0 : 1));
+    for (const item of sorted) {
+        if (item.tier === "act") {
+            await appendAction(item, "Queued for immediate execution", config.output.actionLogPath);
+        }
+        await api.session.workflow.enqueueNextTurnInjection({
+            sessionTarget: "main",
+            text: buildTierPrompt(item),
+        });
+    }
+}

package/dist/src/processed-passes.js

@@ -0,0 +1,20 @@
+// src/processed-passes.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+import { resolvePath } from "./utils.js";
+export async function loadProcessedPasses(path) {
+    try {
+        const data = JSON.parse(await readFile(resolvePath(path), "utf-8"));
+        return new Set(data.pass_ids);
+    }
+    catch {
+        return new Set();
+    }
+}
+export async function markPassProcessed(passId, path, processed) {
+    const updated = new Set([...processed, passId]);
+    const resolved = resolvePath(path);
+    await mkdir(dirname(resolved), { recursive: true });
+    await writeFile(resolved, JSON.stringify({ pass_ids: [...updated] }, null, 2), "utf-8");
+    return updated;
+}

package/dist/src/proposal-adapter.js

@@ -0,0 +1,52 @@
+import { readFile } from "fs/promises";
+import { resolvePath } from "./utils.js";
+const DOMAIN_PATTERNS = [
+    [/github/i, "github"],
+    [/salesforce/i, "salesforce"],
+    [/posthog/i, "posthog"],
+    [/lovable/i, "lovable"],
+    [/slack/i, "slack"],
+    [/google[\s-]?docs?/i, "google-docs"],
+    [/slides?|deck/i, "slides"],
+    [/okr/i, "okr-system"],
+    [/linear/i, "linear"],
+];
+export function extractDomain(text) {
+    for (const [pattern, domain] of DOMAIN_PATTERNS) {
+        if (pattern.test(text))
+            return domain;
+    }
+    return "general";
+}
+export function proposalSetToItems(raw) {
+    if (raw.nothing_to_report)
+        return [];
+    const items = [];
+    for (const obs of raw.observations) {
+        const domain = extractDomain(obs.text + " " + obs.evidence);
+        items.push({ id: obs.id, type: "observation", text: obs.text, domain, action_class: "observation", priority: obs.priority, pass_id: raw.pass_id, pass_timestamp: raw.timestamp });
+    }
+    for (const action of raw.proposed_actions) {
+        const domain = extractDomain(action.text + " " + action.rationale);
+        items.push({ id: action.id, type: "action", text: action.text, domain, action_class: `${domain}/action`, priority: action.priority, pass_id: raw.pass_id, pass_timestamp: raw.timestamp });
+    }
+    for (const audit of raw.proposed_audits) {
+        const domain = extractDomain(audit.domain + " " + audit.rationale);
+        items.push({ id: audit.id, type: "audit", text: `${audit.domain}: ${audit.rationale}`, domain, action_class: `${domain}/audit`, priority: audit.priority, pass_id: raw.pass_id, pass_timestamp: raw.timestamp });
+    }
+    for (const q of raw.open_questions) {
+        const domain = extractDomain(q.text + " " + q.blocking_what);
+        items.push({ id: q.id, type: "question", text: q.text, domain, action_class: "question", priority: 3, pass_id: raw.pass_id, pass_timestamp: raw.timestamp });
+    }
+    return items;
+}
+export async function readUnprocessedPasses(proposalsPath, processedIds) {
+    try {
+        const content = await readFile(resolvePath(proposalsPath), "utf-8");
+        const lines = content.trim().split("\n").filter(Boolean);
+        return lines.map(l => JSON.parse(l)).filter(p => !processedIds.has(p.pass_id));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/src/service.js

@@ -0,0 +1,86 @@
+// src/service.ts
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { DEFAULT_CONFIG } from "./types.js";
+import { resolveDataPath, isWithinActiveHours } from "./utils.js";
+import { loadProfile, saveProfile, upsertEntry } from "./calibration.js";
+import { routeItem } from "./autonomy.js";
+import { readUnprocessedPasses, proposalSetToItems } from "./proposal-adapter.js";
+import { loadProcessedPasses, markPassProcessed } from "./processed-passes.js";
+import { deliverItems } from "./delivery.js";
+import { isDigestDay, buildDigestPrompt } from "./weekly-digest.js";
+function mergeConfig(raw, workspaceDir) {
+    return {
+        ...DEFAULT_CONFIG,
+        ...raw,
+        activeHours: { ...DEFAULT_CONFIG.activeHours, ...(raw.activeHours ?? {}) },
+        proactiveThinking: {
+            ...DEFAULT_CONFIG.proactiveThinking,
+            ...(raw.proactiveThinking ?? {}),
+            proposalsPath: resolveDataPath(raw.proactiveThinking?.proposalsPath, workspaceDir, DEFAULT_CONFIG.proactiveThinking.proposalsPath),
+        },
+        learning: { ...DEFAULT_CONFIG.learning, ...(raw.learning ?? {}) },
+        autonomy: { ...DEFAULT_CONFIG.autonomy, ...(raw.autonomy ?? {}) },
+        digest: { ...DEFAULT_CONFIG.digest, ...(raw.digest ?? {}) },
+        output: {
+            ...DEFAULT_CONFIG.output,
+            ...(raw.output ?? {}),
+            calibrationPath: resolveDataPath(raw.output?.calibrationPath, workspaceDir, DEFAULT_CONFIG.output.calibrationPath),
+            actionLogPath: resolveDataPath(raw.output?.actionLogPath, workspaceDir, DEFAULT_CONFIG.output.actionLogPath),
+            processedPassesPath: resolveDataPath(raw.output?.processedPassesPath, workspaceDir, DEFAULT_CONFIG.output.processedPassesPath),
+        },
+    };
+}
+export default definePluginEntry({
+    id: "sapience",
+    name: "Sapience",
+    description: "Autonomy layer: routes proactive-thinking proposals through tier function, calibrates to human preferences, delivers weekly digest",
+    register(api) {
+        const workspaceDir = api.runtime.agent.resolveAgentWorkspaceDir(api.pluginConfig);
+        const config = mergeConfig(api.pluginConfig, workspaceDir);
+        api.registerTool({
+            name: "process_proposals",
+            description: "Process new proposals from the proactive-thinking log and route them through the autonomy tier function. Called by the sapience cron.",
+            parameters: {},
+            async execute(_id, _params) {
+                if (!isWithinActiveHours(config)) {
+                    return { content: [{ type: "text", text: "SILENT_REPLY_TOKEN" }] };
+                }
+                const [processed, profile] = await Promise.all([
+                    loadProcessedPasses(config.output.processedPassesPath),
+                    loadProfile(config.output.calibrationPath),
+                ]);
+                const newPasses = await readUnprocessedPasses(config.proactiveThinking.proposalsPath, processed);
+                let updatedProcessed = processed;
+                let updatedProfile = profile;
+                for (const pass of newPasses) {
+                    const items = proposalSetToItems(pass);
+                    const routed = items.map(item => routeItem(item, updatedProfile, config));
+                    await deliverItems(routed, api, config);
+                    updatedProcessed = await markPassProcessed(pass.pass_id, config.output.processedPassesPath, updatedProcessed);
+                    for (const item of routed) {
+                        const exists = updatedProfile.find(e => e.domain === item.domain && e.action_class === item.action_class);
+                        if (!exists) {
+                            updatedProfile = upsertEntry(updatedProfile, item.domain, item.action_class, {
+                                tier: config.autonomy.defaultTier,
+                                confidence: 0,
+                            });
+                        }
+                    }
+                }
+                await saveProfile(updatedProfile, config.output.calibrationPath);
+                if (config.digest.enabled && isDigestDay(config) && newPasses.length === 0) {
+                    const prompt = await buildDigestPrompt(config);
+                    await api.session.workflow.enqueueNextTurnInjection({ sessionTarget: "main", text: prompt });
+                }
+                return { content: [{ type: "text", text: "SILENT_REPLY_TOKEN" }] };
+            },
+        });
+        api.session.workflow.scheduleSessionTurn({
+            schedule: { cron: config.schedule },
+            sessionTarget: "isolated",
+            tag: "sapience-routing-pass",
+            systemPrompt: `You are the sapience routing agent. Call process_proposals() to route new thinking pass proposals. Reply SILENT_REPLY_TOKEN after the tool call.`,
+            maxTurns: 2,
+        });
+    },
+});

package/dist/src/types.js

@@ -0,0 +1,22 @@
+export const DEFAULT_CONFIG = {
+    schedule: "*/15 * * * *",
+    activeHours: { start: "08:00", end: "20:00", timezone: "America/Los_Angeles" },
+    proactiveThinking: {
+        proposalsPath: "proactive-thinking/proposals.jsonl",
+    },
+    learning: {
+        enabled: true,
+        recalibrateOnNewDomain: true,
+        confidenceDropThreshold: 0.4,
+    },
+    autonomy: {
+        defaultTier: "propose",
+        domainFloors: {},
+    },
+    digest: { enabled: true, day: "friday", time: "17:00" },
+    output: {
+        calibrationPath: "sapience/calibration.json",
+        actionLogPath: "sapience/action-log.md",
+        processedPassesPath: "sapience/processed-passes.json",
+    },
+};

package/dist/src/utils.js

@@ -0,0 +1,23 @@
+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 isWithinActiveHours(config) {
+    const formatter = new Intl.DateTimeFormat("en-US", {
+        timeZone: config.activeHours.timezone,
+        hour: "2-digit", minute: "2-digit", hour12: false,
+    });
+    const [hours, minutes] = formatter.format(new Date()).split(":").map(Number);
+    const now = (hours ?? 0) * 60 + (minutes ?? 0);
+    const [sh, sm] = config.activeHours.start.split(":").map(Number);
+    const [eh, em] = config.activeHours.end.split(":").map(Number);
+    return now >= (sh ?? 0) * 60 + (sm ?? 0) && now <= (eh ?? 0) * 60 + (em ?? 0);
+}

package/dist/src/weekly-digest.js

@@ -0,0 +1,42 @@
+import { readFile } from "fs/promises";
+import { resolvePath } from "./utils.js";
+export function isDigestDay(config) {
+    const now = new Date();
+    const parts = new Intl.DateTimeFormat("en-US", {
+        timeZone: config.activeHours.timezone,
+        weekday: "long", hour: "2-digit", minute: "2-digit", hour12: false,
+    }).formatToParts(now);
+    const weekday = parts.find(p => p.type === "weekday")?.value?.toLowerCase() ?? "";
+    const hour = parseInt(parts.find(p => p.type === "hour")?.value ?? "0");
+    const minute = parseInt(parts.find(p => p.type === "minute")?.value ?? "0");
+    const [digestHour, digestMinute] = config.digest.time.split(":").map(Number);
+    return weekday === config.digest.day.toLowerCase()
+        && hour === (digestHour ?? 17)
+        && minute < 30;
+}
+export async function buildDigestPrompt(config) {
+    let actionLog = "No actions logged this week.";
+    try {
+        const raw = await readFile(resolvePath(config.output.actionLogPath), "utf-8");
+        actionLog = raw.length > 3000
+            ? "...(earlier entries omitted)\n\n" + raw.slice(-3000)
+            : raw;
+    }
+    catch { /* file absent is fine */ }
+    return `[SAPIENCE: WEEKLY DIGEST] Build and deliver a weekly summary to the user.
+
+## Action log from this week
+${actionLog}
+
+## Instructions
+
+Deliver a brief weekly summary with these sections:
+
+**What I did this week:** List actions actually taken (from the action log above). If nothing was logged, say so.
+
+**Pending your review:** Any proposals from this week that are still waiting on human input.
+
+**What I plan next week:** Based on any active goals or pending work you're aware of.
+
+Keep it concise. This is a status ping, not a report. Omit sections you have nothing meaningful to say about.`;
+}

package/openclaw.plugin.json

@@ -0,0 +1,16 @@
+{
+  "id": "sapience",
+  "name": "Sapience",
+  "version": "0.1.0",
+  "description": "Autonomy layer: routes proactive-thinking proposals through tier function, calibrates to human preferences, delivers weekly digest",
+  "contracts": {
+    "tools": ["process_proposals"]
+  },
+  "activation": {
+    "onStartup": true
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": true
+  }
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@akalsey/openclaw-sapience",
+  "version": "0.1.0",
+  "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": "."
+    }
+  },
+  "dependencies": {
+    "@sinclair/typebox": "^0.33.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "openclaw": "latest",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0"
+  },
+  "peerDependencies": {
+    "openclaw": ">=2026.3.24-beta.2"
+  }
+}