@akalsey/sapience-thinking 0.1.4

package/README.md

@@ -0,0 +1,92 @@
+# OpenClaw Thinking
+
+Your agent notices things. While it works, it watches for anomalies, patterns, and opportunities that don't fit neatly into scheduled tasks — the kind of "I noticed this while doing something else" observations that a thoughtful colleague would flag. Every 15 minutes during working hours, it runs a brief thinking pass over recent activity, produces a structured list of observations and proposed actions, and surfaces anything worth your attention.
+
+The output is a reviewable log file, not autonomous action. You see what it noticed, you decide what to do with it.
+
+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 surface observations to the human.
+
+## Setup
+
+### Install
+
+```bash
+openclaw plugins install npm:@akalsey/sapience-thinking
+```
+
+### Configuration
+
+Add to your OpenClaw config:
+
+```json
+{
+  "plugins": {
+    "sapience-thinking": {
+      "schedule": "*/15 * * * *",
+      "activeHours": {
+        "start": "08:00",
+        "end": "20:00",
+        "timezone": "America/Los_Angeles"
+      },
+      "output": {
+        "logPath": "~/.openclaw/proactive-thinking/thinking-log.md"
+      }
+    }
+  }
+}
+```
+
+All settings are optional — the defaults above are used if omitted.
+
+### Output files
+
+| File | Purpose |
+|------|---------|
+| `~/.openclaw/proactive-thinking/thinking-log.md` | Human-readable log of every pass |
+| `~/.openclaw/proactive-thinking/outcomes.json` | Tracks which proposals you acted on |
+| `~/.openclaw/proactive-thinking/proposals.jsonl` | Structured sidecar read by `sapience` |
+
+---
+
+## What a pass looks like
+
+Each entry in `thinking-log.md` has:
+
+- **Observations** — things noticed with supporting evidence and priority (1–5)
+- **Proposed actions** — concrete things to do, with estimated effort
+- **Proposed audits** — domains worth reviewing
+- **Open questions** — things blocking analysis
+- **Summary** — one-paragraph overview
+
+A pass that found nothing useful logs `nothing_to_report: true`. Over time, this data shows when thinking passes are productive.
+
+---
+
+## Active hours
+
+Passes only fire within `activeHours`. Outside that window, the cron fires but silently skips — no log entry. Set the window to match your working hours.
+
+---
+
+## Troubleshooting
+
+**Nothing in the log after install**
+The plugin fires on cron schedule, not immediately. Wait for the next 15-minute boundary, or manually trigger:
+```bash
+openclaw cron run sapience-thinking-pass
+```
+
+**Passes are running but log is empty**
+Check that `logPath` is writable and that the path (including `~`) is resolving correctly. Try an absolute path first.
+
+**Too many proposals, too much noise**
+The signal-to-noise data in `outcomes.json` feeds back into future prompts after 14 days. Mark proposals as acted-on or dismissed to train the signal:
+```bash
+openclaw thinking resolve <proposal-id> acted_on
+openclaw thinking resolve <proposal-id> dismissed
+```
+
+**`nothing_to_report` on every pass**
+This usually means the context bundle is too thin — no recent session activity to analyze. The plugin needs active use of OpenClaw to have something to think about.

package/dist/index.js

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

package/dist/src/context-builder.js

@@ -0,0 +1,87 @@
+import { readdir, readFile, stat } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+import { estimateTokens, resolvePath } from "./utils.js";
+function extractText(entry) {
+    if (!entry.content)
+        return "";
+    if (typeof entry.content === "string")
+        return entry.content;
+    return entry.content.filter((c) => c.type === "text").map((c) => c.text ?? "").join(" ");
+}
+export async function buildContextFromDirs(config, sessionDir, memoryDir) {
+    const cutoff = Date.now() - config.context.lookbackHours * 60 * 60 * 1000;
+    const transcriptBudget = Math.floor(config.context.maxContextTokens * 0.7);
+    const memoryBudget = Math.floor(config.context.maxContextTokens * 0.2);
+    const chunks = [];
+    let usedTokens = 0;
+    try {
+        const files = (await readdir(sessionDir)).filter((f) => f.endsWith(".jsonl")).sort().reverse();
+        for (const file of files) {
+            if (usedTokens >= transcriptBudget)
+                break;
+            const filePath = join(sessionDir, file);
+            const fileStat = await stat(filePath);
+            if (fileStat.mtimeMs < cutoff)
+                continue;
+            const lines = (await readFile(filePath, "utf-8")).trim().split("\n").filter(Boolean);
+            const entries = lines
+                .map((l) => { try {
+                return JSON.parse(l);
+            }
+            catch {
+                return null;
+            } })
+                .filter((e) => e !== null);
+            for (const entry of entries.slice(-50).reverse()) {
+                if (!entry.role || !["user", "assistant"].includes(entry.role))
+                    continue;
+                const text = extractText(entry).slice(0, 500);
+                if (!text)
+                    continue;
+                const chunk = `[${entry.role}]: ${text}`;
+                const tokens = estimateTokens(chunk);
+                if (usedTokens + tokens > transcriptBudget)
+                    break;
+                chunks.push(chunk);
+                usedTokens += tokens;
+            }
+        }
+    }
+    catch { /* session dir absent — proceed with empty */ }
+    let memoryText = "";
+    try {
+        const files = (await readdir(memoryDir)).filter((f) => f.endsWith(".md")).slice(0, 20);
+        const memChunks = [];
+        let memTokens = 0;
+        for (const file of files) {
+            const content = (await readFile(join(memoryDir, file), "utf-8")).slice(0, 1000);
+            const t = estimateTokens(content);
+            if (memTokens + t > memoryBudget)
+                break;
+            memChunks.push(content);
+            memTokens += t;
+        }
+        if (memChunks.length > 0)
+            memoryText = `\n\n## Recent Memory\n\n${memChunks.join("\n---\n")}`;
+    }
+    catch { /* memory dir absent — skip */ }
+    // chunks were pushed newest-first (files desc, entries reversed); restore chronological order
+    const activity = chunks.length > 0 ? chunks.reverse().join("\n") : "No recent session activity found.";
+    const full = activity + memoryText;
+    return { recentActivity: full, recentPasses: "", tokenEstimate: estimateTokens(full) };
+}
+export async function buildContext(config, agentId) {
+    const base = join(homedir(), ".openclaw", "agents", agentId);
+    return buildContextFromDirs(config, join(base, "sessions"), join(base, "memory"));
+}
+export async function getLastThreePasses(logPath) {
+    try {
+        const content = await readFile(resolvePath(logPath), "utf-8");
+        const sections = content.split(/^## /m).filter(Boolean).slice(-3);
+        return sections.length > 0 ? "## " + sections.join("## ") : "";
+    }
+    catch {
+        return "";
+    }
+}

package/dist/src/delivery.js

@@ -0,0 +1,34 @@
+import { buildHeartbeatPrompt } from "./prompt-builder.js";
+export function getHighPriorityProposals(proposals, threshold, maxCount) {
+    const items = [
+        ...proposals.observations
+            .filter((o) => o.priority >= threshold)
+            .map((o) => ({ id: o.id, type: "observation", priority: o.priority, text: o.text })),
+        ...proposals.proposed_actions
+            .filter((a) => a.priority >= threshold)
+            .map((a) => ({ id: a.id, type: "action", priority: a.priority, text: a.text })),
+        ...proposals.proposed_audits
+            .filter((a) => a.priority >= threshold)
+            .map((a) => ({ id: a.id, type: "audit", priority: a.priority, text: `${a.domain}: ${a.rationale}` })),
+    ];
+    return items.sort((a, b) => b.priority - a.priority).slice(0, maxCount);
+}
+export async function maybeDeliver(proposals, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+api, config) {
+    if (!config.delivery.heartbeatTrigger)
+        return;
+    const high = getHighPriorityProposals(proposals, config.delivery.priorityThreshold, config.delivery.maxProposalsPerHeartbeat);
+    if (high.length === 0)
+        return;
+    const proposalsList = high
+        .map((p) => `- (P${p.priority}) [${p.type}] ${p.text}`)
+        .join("\n");
+    const heartbeatContent = await buildHeartbeatPrompt(proposalsList);
+    // Inject into main session's next turn.
+    // NOTE: exact API shape may need adjustment based on installed SDK version.
+    await api.session.workflow.enqueueNextTurnInjection({
+        content: heartbeatContent,
+        sessionTarget: "main",
+    });
+}

package/dist/src/log-writer.js

@@ -0,0 +1,53 @@
+import { appendFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+export async function appendPass(proposals, logPath) {
+    await mkdir(dirname(logPath), { recursive: true });
+    const lines = [`## ${proposals.timestamp} — Pass ${proposals.pass_id}`, ""];
+    lines.push(`**Summary:** ${proposals.summary}`, "");
+    if (proposals.nothing_to_report) {
+        lines.push("**nothing_to_report: true**", "");
+    }
+    else {
+        if (proposals.observations.length > 0) {
+            lines.push("**Observations:**");
+            for (const o of proposals.observations)
+                lines.push(`- (P${o.priority}) ${o.text} [${o.id}]`);
+            lines.push("");
+        }
+        if (proposals.proposed_actions.length > 0) {
+            lines.push("**Proposed Actions:**");
+            for (const a of proposals.proposed_actions)
+                lines.push(`- (P${a.priority}) ${a.text}. Effort: ${a.estimated_effort}. [${a.id}]`);
+            lines.push("");
+        }
+        if (proposals.proposed_audits.length > 0) {
+            lines.push("**Proposed Audits:**");
+            for (const a of proposals.proposed_audits)
+                lines.push(`- (P${a.priority}) ${a.domain}: ${a.rationale} [${a.id}]`);
+            lines.push("");
+        }
+        if (proposals.open_questions.length > 0) {
+            lines.push("**Open Questions:**");
+            for (const q of proposals.open_questions)
+                lines.push(`- ${q.text} (blocking: ${q.blocking_what}) [${q.id}]`);
+            lines.push("");
+        }
+    }
+    lines.push("---", "");
+    await appendFile(logPath, lines.join("\n") + "\n");
+}
+export async function appendError(passId, reason, logPath) {
+    await mkdir(dirname(logPath), { recursive: true });
+    const ts = new Date().toISOString();
+    await appendFile(logPath, `## ${ts} — Pass ${passId}\n\n**parse error:** ${reason}\n\n---\n\n`);
+}
+export async function appendSkipped(reason, logPath) {
+    await mkdir(dirname(logPath), { recursive: true });
+    const ts = new Date().toISOString();
+    await appendFile(logPath, `## ${ts} — Skipped: ${reason}\n\n---\n\n`);
+}
+export async function appendStructuredProposals(proposals, logPath) {
+    const jsonlPath = logPath.replace(/\.md$/, ".jsonl");
+    await mkdir(dirname(jsonlPath), { recursive: true });
+    await appendFile(jsonlPath, JSON.stringify(proposals) + "\n", "utf-8");
+}

package/dist/src/outcome-tracker.js

@@ -0,0 +1,47 @@
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+export async function loadOutcomes(trackerPath) {
+    try {
+        return JSON.parse(await readFile(trackerPath, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+export async function saveOutcomes(outcomes, trackerPath) {
+    await mkdir(dirname(trackerPath), { recursive: true });
+    await writeFile(trackerPath, JSON.stringify(outcomes, null, 2), "utf-8");
+}
+export function addProposals(outcomes, proposals) {
+    const updated = { ...outcomes };
+    const now = new Date().toISOString();
+    const add = (id, type) => {
+        if (!updated[id]) {
+            updated[id] = { proposal_id: id, proposal_type: type, pass_id: proposals.pass_id, created_at: now, state: "pending" };
+        }
+    };
+    for (const o of proposals.observations)
+        add(o.id, "observation");
+    for (const a of proposals.proposed_actions)
+        add(a.id, "action");
+    for (const a of proposals.proposed_audits)
+        add(a.id, "audit");
+    for (const q of proposals.open_questions)
+        add(q.id, "question");
+    return updated;
+}
+export function expireOldProposals(outcomes, expiryDays = 7) {
+    const updated = { ...outcomes };
+    const cutoff = Date.now() - expiryDays * 24 * 60 * 60 * 1000;
+    for (const [id, r] of Object.entries(updated)) {
+        if (r.state === "pending" && new Date(r.created_at).getTime() < cutoff) {
+            updated[id] = { ...r, state: "expired", resolved_at: new Date().toISOString() };
+        }
+    }
+    return updated;
+}
+export function resolveProposal(outcomes, id, state) {
+    if (!outcomes[id])
+        throw new Error(`Proposal ${id} not found`);
+    return { ...outcomes, [id]: { ...outcomes[id], state, resolved_at: new Date().toISOString() } };
+}

package/dist/src/output-parser.js

@@ -0,0 +1,16 @@
+import { Value } from "@sinclair/typebox/value";
+import { ProposalSetSchema } from "./types.js";
+export class ParseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ParseError";
+    }
+}
+export function parseProposals(raw) {
+    if (!Value.Check(ProposalSetSchema, raw)) {
+        const errors = [...Value.Errors(ProposalSetSchema, raw)];
+        const detail = errors.map((e) => `${e.path}: ${e.message}`).join("; ");
+        throw new ParseError(`Invalid proposal schema: ${detail}`);
+    }
+    return raw;
+}

package/dist/src/prompt-builder.js

@@ -0,0 +1,34 @@
+import { readFile } from "fs/promises";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function pct(n, total) {
+    return total === 0 ? "0%" : `${Math.round((n / total) * 100)}%`;
+}
+function formatSignal(signal) {
+    return [
+        "## Your Recent Proposal Signal-to-Noise",
+        "",
+        `- Observations: ${pct(signal.observations.reviewed, signal.observations.total)} reviewed, ${pct(signal.observations.acted_on, signal.observations.total)} acted on`,
+        `- Proposed actions: ${pct(signal.actions.acted_on, signal.actions.total)} acted on, ${pct(signal.actions.rejected, signal.actions.total)} rejected`,
+        `- Proposed audits: ${pct(signal.audits.accepted, signal.audits.total)} accepted`,
+        `- Open questions: ${pct(signal.questions.answered, signal.questions.total)} answered`,
+        "",
+        "Use this signal to calibrate. Be more selective in categories with low acceptance.",
+    ].join("\n");
+}
+export async function buildPrompt(bundle, signal) {
+    const template = await readFile(join(__dirname, "prompts", "thinking-prompt.md"), "utf-8");
+    const sections = [template];
+    sections.push(["## Recent Activity Context", "", bundle.recentActivity].join("\n"));
+    if (bundle.recentPasses) {
+        sections.push(["## Your Recent Proposals (Last 3 Passes)", "", bundle.recentPasses].join("\n"));
+    }
+    if (signal)
+        sections.push(formatSignal(signal));
+    return sections.join("\n\n");
+}
+export async function buildHeartbeatPrompt(proposalsList) {
+    const template = await readFile(join(__dirname, "prompts", "heartbeat-prompt.md"), "utf-8");
+    return template.replace("[PROPOSALS LIST]", proposalsList);
+}

package/dist/src/service.js

@@ -0,0 +1,152 @@
+import { readFile, writeFile, unlink, mkdir, access } from "fs/promises";
+import { join } from "path";
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { Type } from "@sinclair/typebox";
+import { buildContext, getLastThreePasses } from "./context-builder.js";
+import { buildPrompt } from "./prompt-builder.js";
+import { parseProposals, ParseError } from "./output-parser.js";
+import { appendPass, appendError, appendSkipped, appendStructuredProposals } from "./log-writer.js";
+import { loadOutcomes, saveOutcomes, addProposals, expireOldProposals } from "./outcome-tracker.js";
+import { computeSignal } from "./signal-analyzer.js";
+import { maybeDeliver } from "./delivery.js";
+import { DEFAULT_CONFIG } from "./types.js";
+import { resolveDataPath } from "./utils.js";
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function acquireLock(lockDir, lockFile) {
+    await mkdir(lockDir, { recursive: true });
+    try {
+        const lock = JSON.parse(await readFile(lockFile, "utf-8"));
+        const ageHours = (Date.now() - new Date(lock.started_at).getTime()) / (1000 * 60 * 60);
+        if (isProcessAlive(lock.pid)) {
+            if (ageHours < 2)
+                return false;
+            // > 2 hours old with live PID: stuck process; kill and take the lock
+            try {
+                process.kill(lock.pid, "SIGTERM");
+            }
+            catch { }
+            await new Promise((r) => setTimeout(r, 1000));
+            if (isProcessAlive(lock.pid)) {
+                try {
+                    process.kill(lock.pid, "SIGKILL");
+                }
+                catch { }
+            }
+        }
+    }
+    catch { /* no lock file */ }
+    await writeFile(lockFile, JSON.stringify({ pid: process.pid, started_at: new Date().toISOString() }), "utf-8");
+    return true;
+}
+async function releaseLock(lockFile) {
+    try {
+        await unlink(lockFile);
+    }
+    catch { }
+}
+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);
+}
+function mergeConfig(raw, workspaceDir) {
+    return {
+        ...DEFAULT_CONFIG,
+        ...raw,
+        activeHours: { ...DEFAULT_CONFIG.activeHours, ...(raw.activeHours ?? {}) },
+        context: { ...DEFAULT_CONFIG.context, ...(raw.context ?? {}) },
+        output: {
+            ...DEFAULT_CONFIG.output,
+            ...(raw.output ?? {}),
+            logPath: resolveDataPath(raw.output?.logPath, workspaceDir, DEFAULT_CONFIG.output.logPath),
+            trackerPath: resolveDataPath(raw.output?.trackerPath, workspaceDir, DEFAULT_CONFIG.output.trackerPath),
+        },
+        delivery: { ...DEFAULT_CONFIG.delivery, ...(raw.delivery ?? {}) },
+        learning: { ...DEFAULT_CONFIG.learning, ...(raw.learning ?? {}) },
+    };
+}
+export default definePluginEntry({
+    id: "sapience-thinking",
+    name: "Sapience Thinking",
+    description: "Periodic isolated thinking passes that produce structured proposals",
+    register(api) {
+        const workspaceDir = api.runtime.agent.resolveAgentWorkspaceDir(api.pluginConfig);
+        const config = mergeConfig(api.pluginConfig, workspaceDir);
+        const lockDir = join(workspaceDir, "proactive-thinking");
+        const lockFile = join(lockDir, ".pass.lock");
+        const agentId = api.config?.agent?.id ?? "default";
+        api.registerTool({
+            name: "get_thinking_context",
+            description: "Fetch context bundle and thinking instructions. Call this first in every thinking pass.",
+            parameters: Type.Object({}),
+            async execute(_id, _params) {
+                if (!isWithinActiveHours(config)) {
+                    return { content: [{ type: "text", text: JSON.stringify({ status: "skip", reason: "outside_active_hours" }) }] };
+                }
+                const acquired = await acquireLock(lockDir, lockFile);
+                if (!acquired) {
+                    await appendSkipped("pass_already_running", config.output.logPath);
+                    return { content: [{ type: "text", text: JSON.stringify({ status: "skip", reason: "pass_already_running" }) }] };
+                }
+                try {
+                    const [bundle, recentPasses, outcomes] = await Promise.all([
+                        buildContext(config, agentId),
+                        getLastThreePasses(config.output.logPath),
+                        loadOutcomes(config.output.trackerPath),
+                    ]);
+                    bundle.recentPasses = recentPasses;
+                    const signal = config.learning.adjustPromptBasedOnSignal ? computeSignal(outcomes, config) : null;
+                    const prompt = await buildPrompt(bundle, signal);
+                    return { content: [{ type: "text", text: prompt }] };
+                }
+                catch (err) {
+                    await releaseLock(lockFile);
+                    throw err;
+                }
+            },
+        });
+        api.registerTool({
+            name: "record_thinking_output",
+            description: "Record structured thinking proposals from this pass. Call after get_thinking_context.",
+            parameters: Type.Object({ proposals: Type.Unknown() }),
+            async execute(_id, params) {
+                try {
+                    const proposals = parseProposals(params.proposals);
+                    await appendPass(proposals, config.output.logPath);
+                    await appendStructuredProposals(proposals, config.output.logPath);
+                    if (config.learning.trackOutcomes) {
+                        let outcomes = await loadOutcomes(config.output.trackerPath);
+                        outcomes = addProposals(outcomes, proposals);
+                        outcomes = expireOldProposals(outcomes);
+                        await saveOutcomes(outcomes, config.output.trackerPath);
+                    }
+                    const sapienceActive = await access(join(workspaceDir, "sapience", ".present")).then(() => true, () => false);
+                    if (!sapienceActive)
+                        await maybeDeliver(proposals, api, config);
+                }
+                catch (err) {
+                    const passId = params.proposals?.pass_id ?? "unknown";
+                    await appendError(passId, err instanceof ParseError ? err.message : String(err), config.output.logPath);
+                }
+                finally {
+                    await releaseLock(lockFile);
+                }
+                return { content: [{ type: "text", text: "SILENT_REPLY_TOKEN" }] };
+            },
+        });
+    },
+});

package/dist/src/signal-analyzer.js

@@ -0,0 +1,30 @@
+export function computeSignal(outcomes, config) {
+    const records = Object.values(outcomes);
+    if (records.length === 0)
+        return null;
+    const earliest = records.reduce((min, r) => new Date(r.created_at) < new Date(min.created_at) ? r : min);
+    const ageDays = (Date.now() - new Date(earliest.created_at).getTime()) / (24 * 60 * 60 * 1000);
+    if (ageDays < config.learning.bootstrapDays)
+        return null;
+    const byType = (type) => records.filter((r) => r.proposal_type === type);
+    const resolved = (recs) => recs.filter((r) => r.state !== "pending" && r.state !== "expired");
+    const actedOn = (recs) => recs.filter((r) => r.state === "acted_on" || r.state === "accepted");
+    const obss = byType("observation");
+    const actions = byType("action");
+    const audits = byType("audit");
+    const questions = byType("question");
+    return {
+        observations: { total: obss.length, reviewed: resolved(obss).length, acted_on: actedOn(obss).length },
+        actions: {
+            total: actions.length,
+            acted_on: actedOn(actions).length,
+            rejected: actions.filter((r) => r.state === "rejected").length,
+        },
+        audits: { total: audits.length, accepted: actedOn(audits).length },
+        questions: {
+            total: questions.length,
+            answered: questions.filter((r) => r.state === "acknowledged" || r.state === "acted_on" || r.state === "accepted").length,
+        },
+        computed_at: new Date().toISOString(),
+    };
+}

package/dist/src/types.js

@@ -0,0 +1,49 @@
+import { Type } from "@sinclair/typebox";
+const PrioritySchema = Type.Union([
+    Type.Literal(1), Type.Literal(2), Type.Literal(3), Type.Literal(4), Type.Literal(5),
+]);
+export const ObservationSchema = Type.Object({
+    id: Type.String(),
+    text: Type.String(),
+    evidence: Type.String(),
+    priority: PrioritySchema,
+});
+export const ProposedActionSchema = Type.Object({
+    id: Type.String(),
+    text: Type.String(),
+    rationale: Type.String(),
+    estimated_effort: Type.Union([Type.Literal("small"), Type.Literal("medium"), Type.Literal("large")]),
+    priority: PrioritySchema,
+});
+export const ProposedAuditSchema = Type.Object({
+    id: Type.String(),
+    domain: Type.String(),
+    rationale: Type.String(),
+    priority: PrioritySchema,
+});
+export const OpenQuestionSchema = Type.Object({
+    id: Type.String(),
+    text: Type.String(),
+    blocking_what: Type.String(),
+});
+export const ProposalSetSchema = Type.Object({
+    pass_id: Type.String(),
+    timestamp: Type.String(),
+    observations: Type.Array(ObservationSchema),
+    proposed_actions: Type.Array(ProposedActionSchema),
+    proposed_audits: Type.Array(ProposedAuditSchema),
+    open_questions: Type.Array(OpenQuestionSchema),
+    nothing_to_report: Type.Boolean(),
+    summary: Type.String(),
+});
+export const DEFAULT_CONFIG = {
+    schedule: "*/15 * * * *",
+    activeHours: { start: "08:00", end: "20:00", timezone: "America/Los_Angeles" },
+    context: { lookbackHours: 2, maxContextTokens: 8000 },
+    output: {
+        logPath: "proactive-thinking/log.md",
+        trackerPath: "proactive-thinking/outcomes.json",
+    },
+    delivery: { heartbeatTrigger: true, priorityThreshold: 4, maxProposalsPerHeartbeat: 3 },
+    learning: { trackOutcomes: true, adjustPromptBasedOnSignal: true, bootstrapDays: 14 },
+};

package/dist/src/utils.js

@@ -0,0 +1,16 @@
+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);
+}
+// Rough estimate: ~4 chars per token on average; intentionally imprecise
+export function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}

package/openclaw.plugin.json

@@ -0,0 +1,16 @@
+{
+  "id": "sapience-thinking",
+  "name": "Sapience Thinking",
+  "version": "0.1.0",
+  "description": "Periodic isolated thinking passes that produce structured proposals",
+  "contracts": {
+    "tools": ["get_thinking_context", "record_thinking_output"]
+  },
+  "activation": {
+    "onStartup": true
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": true
+  }
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@akalsey/sapience-thinking",
+  "version": "0.1.4",
+  "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"
+  }
+}