kongbrain 0.3.16 → 0.4.1

package/src/hooks/llm-output.ts

@@ -33,14 +33,34 @@ export function createLlmOutputHandler(state: GlobalPluginState) {
     // Measure assistant text output (used for token estimation and planning gate)
     const textLen = event.assistantTexts.reduce((s, t) => s + t.length, 0);
 
-    // Extract token counts — fall back to text-length estimate when provider
-    // doesn't report usage (OpenClaw often passes 0 or undefined)
-    let inputTokens = event.usage?.input ?? 0;
-    let outputTokens = event.usage?.output ?? 0;
-    if (inputTokens + outputTokens === 0 && textLen > 0) {
-      outputTokens = Math.ceil(textLen / 4); // ~4 chars per token
+    // Extract token counts — OpenClaw's getUsageTotals() returns CUMULATIVE totals
+    // across all API calls in the session, not per-response values.
+    // Compute the delta since last call to avoid quadratic overcounting.
+    const reportedInput = event.usage?.input ?? 0;
+    const reportedOutput = event.usage?.output ?? 0;
+    const reportedCacheRead = event.usage?.cacheRead ?? 0;
+    const reportedCacheWrite = event.usage?.cacheWrite ?? 0;
+    const reportedTotal = reportedInput + reportedOutput + reportedCacheRead + reportedCacheWrite;
+
+    let deltaTokens: number;
+    if (reportedTotal > 0) {
+      deltaTokens = Math.max(0, reportedTotal - session.lastSeenUsageTotal);
+      session.lastSeenUsageTotal = reportedTotal;
+    } else if (textLen > 0) {
+      // No usage data — fall back to text-length estimate
+      deltaTokens = Math.ceil(textLen / 4); // ~4 chars per token
+    } else {
+      deltaTokens = 0;
     }
 
+    // DB stats: approximate input/output split from the delta
+    const inputTokens = reportedTotal > 0 && deltaTokens > 0
+      ? Math.round(deltaTokens * (reportedInput / reportedTotal))
+      : 0;
+    const outputTokens = reportedTotal > 0 && deltaTokens > 0
+      ? Math.round(deltaTokens * (reportedOutput / reportedTotal))
+      : (deltaTokens > 0 ? deltaTokens : Math.ceil(textLen / 4));
+
     // Always update session stats — turn_count must increment even without usage data
     if (session.surrealSessionId) {
       try {
@@ -55,8 +75,8 @@ export function createLlmOutputHandler(state: GlobalPluginState) {
     }
 
     // Accumulate for daemon batching and mid-session cleanup
-    session.newContentTokens += inputTokens + outputTokens;
-    session.cumulativeTokens += inputTokens + outputTokens;
+    session.newContentTokens += deltaTokens;
+    session.cumulativeTokens += deltaTokens;
 
     // Track accumulated text output for planning gate
     session.turnTextLength += textLen;

package/src/hooks/subagent-lifecycle.ts

@@ -0,0 +1,142 @@
+/**
+ * subagent_spawned / subagent_ended hooks — track spawned subagents in the graph.
+ *
+ * Creates `subagent` records and `spawned` edges (session → subagent).
+ * Updates subagent records with outcome on completion.
+ */
+
+import type { GlobalPluginState } from "../state.js";
+import { swallow } from "../errors.js";
+
+// ── Event shapes (from OpenClaw gateway) ─────────────────────────────────
+
+interface SubagentSpawnedEvent {
+  runId: string;
+  childSessionKey: string;
+  agentId?: string;
+  label?: string;
+  requester?: {
+    channel?: string;
+    accountId?: string;
+    to?: string;
+    threadId?: string;
+  };
+  threadRequested?: boolean;
+  mode?: string; // "run" | "session"
+}
+
+interface SubagentSpawnedContext {
+  runId: string;
+  childSessionKey: string;
+  requesterSessionKey?: string;
+}
+
+interface SubagentEndedEvent {
+  targetSessionKey: string;
+  targetKind?: string;
+  reason?: string;
+  sendFarewell?: boolean;
+  accountId?: string;
+  runId: string;
+  endedAt?: string;
+  outcome?: string;
+  error?: string;
+}
+
+interface SubagentEndedContext {
+  runId: string;
+  childSessionKey: string;
+  requesterSessionKey?: string;
+}
+
+// ── Handlers ─────────────────────────────────────────────────────────────
+
+export function createSubagentSpawnedHandler(state: GlobalPluginState) {
+  return async (event: SubagentSpawnedEvent, ctx: SubagentSpawnedContext) => {
+    try {
+      const store = state.store;
+
+      // Create the subagent record
+      const rows = await store.queryFirst<{ id: string }>(
+        `CREATE subagent CONTENT {
+          run_id: $run_id,
+          parent_session_key: $parent_key,
+          child_session_key: $child_key,
+          parent_session_id: $parent_key,
+          child_session_id: $child_key,
+          agent_id: $agent_id,
+          label: $label,
+          mode: $mode,
+          task: $label,
+          status: "running",
+          created_at: time::now()
+        } RETURN id`,
+        {
+          run_id: event.runId,
+          parent_key: ctx.requesterSessionKey ?? "unknown",
+          child_key: event.childSessionKey,
+          agent_id: event.agentId ?? "default",
+          label: event.label ?? null,
+          mode: event.mode ?? "run",
+        },
+      );
+
+      const subagentId = String(rows[0]?.id ?? "");
+      if (!subagentId) return;
+
+      // Find the parent's surreal session ID to create the spawned edge.
+      // The requesterSessionKey is the OpenClaw session key — we need to
+      // find the matching surreal session record.
+      if (ctx.requesterSessionKey) {
+        // Look up active session state first (fast path)
+        const parentSession = state.getSession(ctx.requesterSessionKey);
+        if (parentSession?.surrealSessionId) {
+          await store.relate(parentSession.surrealSessionId, "spawned", subagentId);
+        } else {
+          // Fallback: find the most recent session record that's still active
+          const sessions = await store.queryFirst<{ id: string }>(
+            `SELECT id FROM session
+             WHERE ended_at IS NONE
+             ORDER BY started_at DESC LIMIT 1`,
+          );
+          if (sessions.length > 0) {
+            await store.relate(String(sessions[0].id), "spawned", subagentId);
+          }
+        }
+      }
+    } catch (e) {
+      swallow.warn("hook:subagentSpawned", e);
+    }
+  };
+}
+
+export function createSubagentEndedHandler(state: GlobalPluginState) {
+  return async (event: SubagentEndedEvent, ctx: SubagentEndedContext) => {
+    try {
+      const store = state.store;
+
+      // Update the subagent record by run_id
+      await store.queryExec(
+        `UPDATE subagent SET
+          status = $status,
+          outcome = $outcome,
+          error = $error,
+          reason = $reason,
+          ended_at = $ended_at
+        WHERE run_id = $run_id`,
+        {
+          run_id: event.runId,
+          status: event.outcome === "success" ? "completed"
+            : event.reason === "spawn-failed" ? "error"
+            : event.outcome ?? "completed",
+          outcome: event.outcome ?? null,
+          error: event.error ?? null,
+          reason: event.reason ?? null,
+          ended_at: event.endedAt ?? new Date().toISOString(),
+        },
+      );
+    } catch (e) {
+      swallow.warn("hook:subagentEnded", e);
+    }
+  };
+}

package/src/index.ts

@@ -20,6 +20,7 @@ import { createBeforePromptBuildHandler } from "./hooks/before-prompt-build.js";
 import { createBeforeToolCallHandler } from "./hooks/before-tool-call.js";
 import { createAfterToolCallHandler } from "./hooks/after-tool-call.js";
 import { createLlmOutputHandler } from "./hooks/llm-output.js";
+import { createSubagentSpawnedHandler, createSubagentEndedHandler } from "./hooks/subagent-lifecycle.js";
 import { startMemoryDaemon } from "./daemon-manager.js";
 import { seedIdentity } from "./identity.js";
 import { seedCognitiveBootstrap } from "./cognitive-bootstrap.js";
@@ -146,11 +147,18 @@ async function runSessionCleanup(
     new Promise(resolve => setTimeout(resolve, 150_000)),
   ]);
 
+  // Await the graduation promise once and reuse the result below
+  let gradResult: Awaited<typeof graduationPromise> = null;
+  try {
+    gradResult = await graduationPromise;
+  } catch (e) {
+    swallow.warn("cleanup:graduationAwait", e);
+  }
+
   // If soul graduation just happened, persist a graduation event so the next
   // session can celebrate with the user. We also fire a system event for
   // immediate visibility if the session is still active.
   try {
-    const gradResult = await graduationPromise;
     if (gradResult?.graduated && gradResult.soul) {
       // Check if this is a NEW graduation (not a pre-existing soul)
       const isNewGraduation = gradResult.report.stage === "ready";
@@ -188,7 +196,6 @@ async function runSessionCleanup(
   // Soul evolution — if soul already exists, check if it should be revised
   // based on new experience (runs every 10 sessions after last revision)
   try {
-    const gradResult = await graduationPromise;
     if (gradResult?.graduated && gradResult.report.stage !== "ready") {
       // Pre-existing soul — check for evolution
       await evolveSoul(s, complete);
@@ -421,6 +428,8 @@ export default definePluginEntry({
       api.on("before_tool_call", createBeforeToolCallHandler(globalState));
       api.on("after_tool_call", createAfterToolCallHandler(globalState));
       api.on("llm_output", createLlmOutputHandler(globalState));
+      api.on("subagent_spawned", createSubagentSpawnedHandler(globalState));
+      api.on("subagent_ended", createSubagentEndedHandler(globalState));
     }
 
     // ── Session lifecycle (also register once) ─────────────────────────

package/src/orchestrator.ts

@@ -192,7 +192,7 @@ export async function preflight(
 
   // Non-first-turn short inputs → continuation
   if (orch.turnIndex > 1 && input.length < 20 && !input.includes("?")) {
-    const inheritedLimit = Math.max(orch.lastConfig.toolLimit, 25);
+    const inheritedLimit = Math.min(orch.lastConfig.toolLimit, 25);
     const config: AdaptiveConfig = {
       ...orch.lastConfig, toolLimit: inheritedLimit, skipRetrieval: true,
       vectorSearchLimits: { turn: 0, identity: 0, concept: 0, memory: 0, artifact: 0 },

package/src/reflection.ts

@@ -207,6 +207,7 @@ export async function generateReflection(
       { record },
     );
     const reflectionId = String(rows[0]?.id ?? "");
+    store.clearReflectionCache();
 
     if (reflectionId && surrealSessionId) {
       await store.relate(reflectionId, "reflects_on", surrealSessionId).catch(e => swallow.warn("reflection:relate", e));

package/src/soul.ts

@@ -191,7 +191,7 @@ export async function getQualitySignals(store: SurrealStore): Promise<QualitySig
     const totalSuccess = Number(skillRow?.totalSuccess ?? 0);
     const totalFailure = Number(skillRow?.totalFailure ?? 0);
     const skillTotal = totalSuccess + totalFailure;
-    const skillSuccessRate = skillTotal > 0 ? totalSuccess / skillTotal : 0;
+    const skillSuccessRate = skillTotal > 0 && Number.isFinite(skillTotal) ? totalSuccess / skillTotal : 0;
 
     const critCount = Number(critRow?.count ?? 0);
     const reflCount = Number(totalRow?.count ?? 0);

package/src/state.ts

@@ -62,6 +62,9 @@ export class SessionState {
   cumulativeTokens = 0;
   lastCleanupTokens = 0;
   midSessionCleanupThreshold = 25_000;
+  /** Last cumulative usage total seen from OpenClaw — used to compute per-call deltas
+   *  since getUsageTotals() returns running totals, not per-response values. */
+  lastSeenUsageTotal = 0;
 
   // Cleanup tracking
   cleanedUp = false;
@@ -72,6 +75,17 @@ export class SessionState {
   // Pending tool args for artifact tracking
   readonly pendingToolArgs = new Map<string, unknown>();
 
+  // Tool call optimization state (claw-code patterns)
+  /** Query vector from this turn's context retrieval — used to detect redundant recall calls. */
+  lastQueryVec: number[] | null = null;
+  /** Summary of what graphTransformContext injected — shown in planning gate. */
+  lastRetrievalSummary = "";
+  /** API request cycle counter — hard cap prevents runaway token spend. */
+  apiCycleCount = 0;
+  /** Tracks which static context sections the model has already seen in the conversation window.
+   *  Persists across turns (NOT cleared in resetTurn) — cleared only when messages drop from window. */
+  readonly injectedSections = new Set<string>();
+
   // 5-pillar IDs (populated at bootstrap)
   agentId = "";
   projectId = "";
@@ -92,6 +106,10 @@ export class SessionState {
     this.softInterrupted = false;
     this.turnStartMs = Date.now();
     this.pendingThinking.length = 0;
+    this.lastRetrievalSummary = "";
+    this.apiCycleCount = 0;
+    // NOTE: lastQueryVec and injectedSections are NOT cleared here —
+    // they persist across turns within the session.
   }
 }
 

package/src/surreal.ts

@@ -1408,6 +1408,10 @@ export class SurrealStore {
 
   private _reflectionSessions: Set<string> | null = null;
 
+  clearReflectionCache(): void {
+    this._reflectionSessions = null;
+  }
+
   async getReflectionSessionIds(): Promise<Set<string>> {
     if (this._reflectionSessions) return this._reflectionSessions;
     try {

package/src/tools/core-memory.ts

@@ -46,7 +46,7 @@ export function createCoreMemoryToolDef(state: GlobalPluginState, session: Sessi
             }
             const formatted = entries.map((e, i) => {
               const sid = e.session_id ? ` session:${e.session_id}` : "";
-              return `${i + 1}. [T${e.tier}/${e.category}/p${e.priority}${sid}] ${e.id}\n   ${e.text.slice(0, 200)}`;
+              return `${i + 1}. [T${e.tier}/${e.category}/p${e.priority}${sid}] ${e.id}\n   ${e.text.slice(0, 120)}`;
             }).join("\n\n");
             return {
               content: [{ type: "text" as const, text: `${entries.length} core memory entries:\n\n${formatted}` }],
@@ -73,6 +73,8 @@ export function createCoreMemoryToolDef(state: GlobalPluginState, session: Sessi
                 details: { error: true },
               };
             }
+            // Invalidate cached section so updated content re-injects next turn
+            session.injectedSections.delete(tier === 0 ? "tier0" : "tier1");
             return {
               content: [{ type: "text" as const, text: `Created core memory: ${id} (tier ${tier}, ${params.category ?? "general"}, p${params.priority ?? 50})` }],
               details: { id },
@@ -95,6 +97,9 @@ export function createCoreMemoryToolDef(state: GlobalPluginState, session: Sessi
                 details: { error: true },
               };
             }
+            // Invalidate both tiers — update may have changed the tier
+            session.injectedSections.delete("tier0");
+            session.injectedSections.delete("tier1");
             return {
               content: [{ type: "text" as const, text: `Updated core memory: ${params.id}` }],
               details: { id: params.id },
@@ -106,6 +111,9 @@ export function createCoreMemoryToolDef(state: GlobalPluginState, session: Sessi
               return { content: [{ type: "text" as const, text: "Error: 'id' is required for deactivate action." }], details: null };
             }
             await store.deleteCoreMemory(params.id);
+            // Invalidate both tiers so removal is reflected next turn
+            session.injectedSections.delete("tier0");
+            session.injectedSections.delete("tier1");
             return {
               content: [{ type: "text" as const, text: `Deactivated core memory: ${params.id}` }],
               details: { id: params.id },

package/src/tools/recall.ts

@@ -34,7 +34,7 @@ export function createRecallToolDef(state: GlobalPluginState, session: SessionSt
         return { content: [{ type: "text" as const, text: "Memory system unavailable." }], details: null };
       }
 
-      const maxResults = Math.min(params.limit ?? 5, 15);
+      const maxResults = Math.min(params.limit ?? 3, 15);
 
       try {
         const queryVec = await embeddings.embed(params.query);
@@ -63,7 +63,7 @@ export function createRecallToolDef(state: GlobalPluginState, session: SessionSt
 
         const topIds = results
           .sort((a, b) => (b.score ?? 0) - (a.score ?? 0))
-          .slice(0, 5)
+          .slice(0, Math.min(maxResults, 8))
           .map((r) => r.id);
 
         let neighbors: VectorSearchResult[] = [];
@@ -87,7 +87,7 @@ export function createRecallToolDef(state: GlobalPluginState, session: SessionSt
           const tag = r.table === "turn" ? `[${r.role ?? "turn"}]` : `[${r.table}]`;
           const time = r.timestamp ? ` (${new Date(r.timestamp).toLocaleDateString()})` : "";
           const score = r.score ? ` score:${r.score.toFixed(2)}` : "";
-          return `${i + 1}. ${tag}${time}${score}\n   ${(r.text ?? "").slice(0, 500)}`;
+          return `${i + 1}. ${tag}${time}${score}\n   ${(r.text ?? "").slice(0, 300)}`;
         }).join("\n\n");
 
         return {