kongbrain 0.1.0

package/src/index.ts

@@ -0,0 +1,435 @@
+/**
+ * KongBrain — OpenClaw context-engine plugin entry point.
+ *
+ * Replaces the default context engine with graph-based retrieval using
+ * SurrealDB persistence and BGE-M3 embeddings.
+ */
+
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { parsePluginConfig } from "./config.js";
+import { SurrealStore } from "./surreal.js";
+import { EmbeddingService } from "./embeddings.js";
+import { GlobalPluginState } from "./state.js";
+import { KongBrainContextEngine } from "./context-engine.js";
+import { createRecallToolDef } from "./tools/recall.js";
+import { createCoreMemoryToolDef } from "./tools/core-memory.js";
+import { createIntrospectToolDef } from "./tools/introspect.js";
+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 { startMemoryDaemon } from "./daemon-manager.js";
+import { seedIdentity } from "./identity.js";
+import { synthesizeWakeup, synthesizeStartupCognition } from "./wakeup.js";
+import { extractSkill } from "./skills.js";
+import { generateReflection, setReflectionContextWindow } from "./reflection.js";
+import { graduateCausalToSkills } from "./skills.js";
+import { attemptGraduation, evolveSoul, checkStageTransition } from "./soul.js";
+import { hasMigratableFiles, migrateWorkspace } from "./workspace-migrate.js";
+import { swallow } from "./errors.js";
+
+let globalState: GlobalPluginState | null = null;
+let shutdownPromise: Promise<void> | null = null;
+let registeredExitHandler: (() => void) | null = null;
+let registered = false;
+
+/**
+ * Run the critical session-end extraction for all active sessions.
+ * Called from both session_end hook and process exit handler.
+ */
+async function runSessionCleanup(
+  session: import("./state.js").SessionState,
+  state: GlobalPluginState,
+): Promise<void> {
+  const { store: s, embeddings: emb } = state;
+  const endOps: Promise<unknown>[] = [];
+
+  // Final daemon flush — send full session for extraction
+  if (session.daemon) {
+    endOps.push(
+      (async () => {
+        try {
+          const recentTurns = await s.getSessionTurns(session.sessionId, 50);
+          const turnData = recentTurns.map(t => ({
+            role: t.role as "user" | "assistant",
+            text: t.text,
+            turnId: (t as any).id,
+          }));
+          session.daemon!.sendTurnBatch(turnData, [...session.pendingThinking], []);
+        } catch (e) { swallow.warn("cleanup:finalDaemonFlush", e); }
+        await session.daemon!.shutdown(45_000).catch(e => swallow.warn("cleanup:daemonShutdown", e));
+        session.daemon = null;
+      })(),
+    );
+  }
+
+  const { complete } = state;
+
+  // Skill extraction
+  if (session.taskId) {
+    endOps.push(
+      extractSkill(session.sessionId, session.taskId, s, emb, complete)
+        .catch(e => swallow.warn("cleanup:extractSkill", e)),
+    );
+  }
+
+  // Metacognitive reflection
+  endOps.push(
+    generateReflection(session.sessionId, s, emb, complete)
+      .catch(e => swallow.warn("cleanup:reflection", e)),
+  );
+
+  // Graduate causal chains -> skills
+  endOps.push(
+    graduateCausalToSkills(s, emb, complete)
+      .catch(e => swallow.warn("cleanup:graduateCausal", e)),
+  );
+
+  // Soul graduation attempt — capture result for user notification
+  const graduationPromise = attemptGraduation(s, complete, state.workspaceDir)
+    .catch(e => { swallow.warn("cleanup:soulGraduation", e); return null; });
+  endOps.push(graduationPromise);
+
+  // The session-end Opus call is critical and needs the full 45s.
+  await Promise.race([
+    Promise.allSettled(endOps),
+    new Promise(resolve => setTimeout(resolve, 45_000)),
+  ]);
+
+  // 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";
+      if (isNewGraduation) {
+        // Persist graduation event for next session pickup
+        await s.queryExec(
+          `CREATE graduation_event CONTENT $data`,
+          {
+            data: {
+              session_id: session.sessionId,
+              acknowledged: false,
+              quality_score: gradResult.report.qualityScore,
+              volume_score: gradResult.report.volumeScore,
+              stage: gradResult.report.stage,
+              created_at: new Date().toISOString(),
+            },
+          },
+        ).catch(e => swallow.warn("cleanup:graduationEvent", e));
+
+        // Fire system event for immediate user notification
+        if (state.enqueueSystemEvent) {
+          state.enqueueSystemEvent(
+            "[GRADUATION] KongBrain has achieved soul graduation! " +
+            "The agent has accumulated enough experience and demonstrated sufficient quality " +
+            "to author its own identity document. It will share this milestone at the start of the next session.",
+            { sessionKey: session.sessionKey },
+          );
+        }
+      }
+    }
+  } catch (e) {
+    swallow.warn("cleanup:graduationNotify", e);
+  }
+
+  // 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);
+    }
+  } catch (e) {
+    swallow.warn("cleanup:soulEvolution", e);
+  }
+
+  // Stage transition tracking — record progress and notify on level-ups
+  try {
+    const transition = await checkStageTransition(s);
+    if (transition.transitioned && state.enqueueSystemEvent) {
+      const stageLabels: Record<string, string> = {
+        nascent: "Nascent (0-3/7)",
+        developing: "Developing (4/7)",
+        emerging: "Emerging (5/7)",
+        maturing: "Maturing (6/7)",
+        ready: "Ready (7/7 + quality gate)",
+      };
+      const prev = stageLabels[transition.previousStage ?? "nascent"] ?? transition.previousStage;
+      const curr = stageLabels[transition.currentStage] ?? transition.currentStage;
+      state.enqueueSystemEvent(
+        `[MATURITY] Stage transition: ${prev} → ${curr}. ` +
+        `Volume: ${transition.report.met.length}/7 | Quality: ${transition.report.qualityScore.toFixed(2)}`,
+        { sessionKey: session.sessionKey },
+      );
+    }
+  } catch (e) {
+    swallow.warn("cleanup:stageTransition", e);
+  }
+}
+
+/**
+ * Check if the agent just graduated in a recent session and hasn't told the user yet.
+ * Sets a flag on the session so the context engine can inject graduation context.
+ */
+async function detectGraduationEvent(
+  store: SurrealStore,
+  session: import("./state.js").SessionState,
+  state: GlobalPluginState,
+): Promise<void> {
+  if (!store.isAvailable()) return;
+
+  // Check for unacknowledged graduation events
+  const events = await store.queryFirst<{
+    id: string;
+    quality_score: number;
+    volume_score: number;
+  }>(
+    `SELECT id, quality_score, volume_score FROM graduation_event
+     WHERE acknowledged = false
+     ORDER BY created_at DESC LIMIT 1`,
+  ).catch(() => []);
+
+  if (events.length === 0) return;
+
+  const event = events[0];
+
+  // Mark as acknowledged so we don't repeat
+  await store.queryExec(
+    `UPDATE $id SET acknowledged = true, acknowledged_at = time::now(), acknowledged_session = $sid`,
+    { id: event.id, sid: session.sessionId },
+  ).catch(e => swallow.warn("graduationDetect:ack", e));
+
+  // Get the soul document for the agent to reference
+  const soulRows = await store.queryFirst<{
+    working_style: string[];
+    self_observations: string[];
+    earned_values: { value: string; grounded_in: string }[];
+  }>(`SELECT working_style, self_observations, earned_values FROM soul:kongbrain`).catch(() => []);
+  const soul = soulRows[0];
+
+  // Build a summary the agent can use to talk about itself
+  let soulSummary = "";
+  if (soul) {
+    const styles = (soul.working_style ?? []).slice(0, 3).map(s => `- ${s}`).join("\n");
+    const obs = (soul.self_observations ?? []).slice(0, 3).map(s => `- ${s}`).join("\n");
+    const vals = (soul.earned_values ?? []).slice(0, 3).map(v => `- ${v.value}: ${v.grounded_in}`).join("\n");
+    soulSummary = `\n\nYour soul document contains:\nWorking style:\n${styles}\n\nSelf-observations:\n${obs}\n\nEarned values:\n${vals}`;
+  }
+
+  // Read SOUL.md — the user's original nudge about who they wanted the agent to be.
+  // The agent should reflect on how this aligns (or doesn't) with what actually emerged.
+  let userNudge = "";
+  if (state.workspaceDir) {
+    try {
+      const soulMd = await readFile(join(state.workspaceDir, "SOUL.md"), "utf-8");
+      if (soulMd.trim().length > 50) {
+        userNudge = soulMd.trim().slice(0, 2000);
+      }
+    } catch {
+      // No SOUL.md — that's fine, graduation happened without user guidance
+    }
+  }
+
+  // Flag the session for context engine injection
+  (session as any)._graduationCelebration = {
+    qualityScore: event.quality_score,
+    volumeScore: event.volume_score,
+    soulSummary,
+    userNudge,
+  };
+
+  // Also fire a system event so the user sees it immediately
+  if (state.enqueueSystemEvent) {
+    state.enqueueSystemEvent(
+      "[MILESTONE] This is a special session — KongBrain has graduated and authored its own Soul document. " +
+      "The agent will share what this means.",
+      { sessionKey: session.sessionKey },
+    );
+  }
+}
+
+export default definePluginEntry({
+  id: "kongbrain",
+  name: "KongBrain",
+  description: "Graph-backed cognitive context engine with SurrealDB persistence and BGE-M3 embeddings.",
+  kind: "context-engine",
+
+  register(api) {
+    const config = parsePluginConfig(api.pluginConfig as Record<string, unknown> | undefined);
+    const logger = api.logger;
+
+    // Initialize shared resources
+    const store = new SurrealStore(config.surreal);
+    const embeddings = new EmbeddingService(config.embedding);
+    globalState = new GlobalPluginState(config, store, embeddings, api.runtime.complete);
+    globalState.workspaceDir = api.resolvePath(".");
+    globalState.enqueueSystemEvent = (text, opts) =>
+      api.runtime.system.enqueueSystemEvent(text, opts);
+
+    // Register the context engine factory
+    api.registerContextEngine("kongbrain", async () => {
+      // Connect to SurrealDB
+      try {
+        await store.initialize();
+        logger.info(`SurrealDB connected: ${config.surreal.url}`);
+      } catch (e) {
+        logger.error(`SurrealDB connection failed: ${e}`);
+        throw e;
+      }
+
+      // Initialize BGE-M3 embeddings
+      try {
+        await embeddings.initialize();
+        logger.info(`BGE-M3 embeddings initialized: ${config.embedding.modelPath}`);
+      } catch (e) {
+        logger.warn(`Embeddings init failed — running in degraded mode: ${e}`);
+      }
+
+      return new KongBrainContextEngine(globalState!);
+    });
+
+    // ── Hook handlers ──────────────────────────────────────────────────
+
+    api.on("before_prompt_build", createBeforePromptBuildHandler(globalState));
+    api.on("before_tool_call", createBeforeToolCallHandler(globalState));
+    api.on("after_tool_call", createAfterToolCallHandler(globalState));
+    api.on("llm_output", createLlmOutputHandler(globalState));
+
+    // ── Session lifecycle ──────────────────────────────────────────────
+
+    api.on("session_start", async (event) => {
+      if (!globalState) return;
+      const sessionKey = event.sessionKey ?? event.sessionId;
+      const session = globalState.getOrCreateSession(sessionKey, event.sessionId);
+
+      // Register tools
+      try {
+        api.registerTool(
+          createRecallToolDef(globalState, session),
+          { name: "recall" },
+        );
+        api.registerTool(
+          createCoreMemoryToolDef(globalState, session),
+          { name: "core_memory" },
+        );
+        api.registerTool(
+          createIntrospectToolDef(globalState, session),
+          { name: "introspect" },
+        );
+      } catch (e) {
+        swallow.warn("index:registerTools", e);
+      }
+
+      // Start memory daemon worker thread
+      try {
+        session.daemon = startMemoryDaemon(
+          config.surreal,
+          config.embedding,
+          session.sessionId,
+          { provider: api.runtime.agent.defaults.provider, model: api.runtime.agent.defaults.model },
+        );
+      } catch (e) {
+        swallow.warn("index:startDaemon", e);
+      }
+
+      // Seed identity chunks (idempotent — skips if already seeded)
+      seedIdentity(store, embeddings)
+        .catch(e => swallow.warn("index:seedIdentity", e));
+
+      // Check for workspace .md files from the default context engine
+      if (globalState!.workspaceDir) {
+        hasMigratableFiles(globalState!.workspaceDir)
+          .then(hasMigratable => {
+            if (hasMigratable) {
+              (session as any)._hasMigratableFiles = true;
+            }
+          })
+          .catch(e => swallow("index:migrationCheck", e));
+      }
+
+      // Set reflection context window from config
+      setReflectionContextWindow(200000);
+
+      // Check for recent graduation event (from a previous session)
+      detectGraduationEvent(store, session, globalState!)
+        .catch(e => swallow("index:graduationDetect", e));
+
+      // Synthesize wakeup briefing (background, non-blocking)
+      // The briefing is stored and later injected via assemble()'s systemPromptAddition
+      console.log("[kongbrain:wakeup] starting synthesis...");
+      synthesizeWakeup(store, globalState!.complete, session.sessionId)
+        .then(briefing => {
+          console.log(`[kongbrain:wakeup] result: ${briefing ? briefing.length + " chars" : "null (no prior state)"}`);
+          if (briefing) {
+            (session as any)._wakeupBriefing = briefing;
+          }
+        })
+        .catch(e => { console.error("[kongbrain:wakeup] FAILED:", e); swallow.warn("index:wakeup", e); });
+
+      // Startup cognition (background)
+      console.log("[kongbrain:cognition] starting synthesis...");
+      synthesizeStartupCognition(store, globalState!.complete)
+        .then(cognition => {
+          console.log(`[kongbrain:cognition] result: ${cognition ? JSON.stringify(cognition).slice(0, 200) : "null"}`);
+          if (cognition) {
+            (session as any)._startupCognition = cognition;
+          }
+        })
+        .catch(e => { console.error("[kongbrain:cognition] FAILED:", e); swallow.warn("index:startupCognition", e); });
+    });
+
+    api.on("session_end", async (event) => {
+      if (!globalState) return;
+      const sessionKey = event.sessionKey ?? event.sessionId;
+      const session = globalState.getSession(sessionKey);
+      if (!session) return;
+
+      shutdownPromise = runSessionCleanup(session, globalState);
+      await shutdownPromise;
+      shutdownPromise = null;
+
+      globalState.removeSession(sessionKey);
+    });
+
+    // OpenClaw's session_end is fire-and-forget and doesn't fire on CLI exit.
+    // Register a process exit handler to ensure the critical Opus extraction
+    // completes even when the user exits with Ctrl+D or /exit.
+    // Clean up previous listeners first (register() can be called multiple times).
+    if (registeredExitHandler) {
+      process.removeListener("beforeExit", registeredExitHandler);
+      process.removeListener("SIGINT", registeredExitHandler);
+      process.removeListener("SIGTERM", registeredExitHandler);
+    }
+
+    const onProcessExit = () => {
+      if (!globalState) return;
+      const sessions = [...(globalState as any).sessions.values()] as import("./state.js").SessionState[];
+      if (sessions.length === 0 && !shutdownPromise) return;
+
+      const cleanups = sessions.map(s => runSessionCleanup(s, globalState!));
+      if (shutdownPromise) cleanups.push(shutdownPromise);
+
+      const done = Promise.allSettled(cleanups).then(() => {
+        globalState?.shutdown().catch(() => {});
+      });
+
+      done.then(() => process.exit(0)).catch(() => process.exit(1));
+    };
+
+    registeredExitHandler = onProcessExit;
+    process.once("beforeExit", onProcessExit);
+    process.once("SIGINT", onProcessExit);
+    process.once("SIGTERM", onProcessExit);
+
+    if (!registered) {
+      logger.info("KongBrain plugin registered");
+      registered = true;
+    }
+  },
+});

package/src/intent.ts

@@ -0,0 +1,190 @@
+/**
+ * Zero-shot intent classification via BGE-M3 embeddings.
+ * No LLM call — embed user input, cosine similarity against prototypes.
+ * ~25ms total (16ms embed + 5ms cosine + heuristics).
+ *
+ * Ported from kongbrain — takes EmbeddingService instead of module-level embed.
+ */
+
+import type { EmbeddingService } from "./embeddings.js";
+
+// --- Intent categories ---
+
+export type IntentCategory =
+  | "simple-question"
+  | "code-read"
+  | "code-write"
+  | "code-debug"
+  | "deep-explore"
+  | "reference-prior"
+  | "meta-session"
+  | "multi-step"
+  | "continuation"
+  | "unknown";
+
+export interface IntentResult {
+  category: IntentCategory;
+  confidence: number;
+  scores: { category: IntentCategory; score: number }[];
+}
+
+export type ComplexityLevel = "trivial" | "simple" | "moderate" | "complex" | "deep";
+export type ThinkingLevel = "none" | "low" | "medium" | "high";
+
+export interface ComplexityEstimate {
+  level: ComplexityLevel;
+  estimatedToolCalls: number;
+  suggestedThinking: ThinkingLevel;
+}
+
+// --- Prototype definitions ---
+
+interface Prototype {
+  category: IntentCategory;
+  text: string;
+}
+
+const PROTOTYPES: Prototype[] = [
+  { category: "simple-question", text: "What is two plus two?" },
+  { category: "simple-question", text: "What is the capital of France?" },
+  { category: "simple-question", text: "Explain what a linked list is." },
+  { category: "simple-question", text: "What does async await mean in JavaScript?" },
+
+  { category: "code-read", text: "Read the file src/agent.ts and explain what it does." },
+  { category: "code-read", text: "Show me the contents of package.json." },
+  { category: "code-read", text: "What functions are defined in utils.ts?" },
+
+  { category: "code-write", text: "Write a new function that sorts an array." },
+  { category: "code-write", text: "Create a new file called validator.ts with email validation." },
+  { category: "code-write", text: "Implement a REST API endpoint for user registration." },
+
+  { category: "code-debug", text: "Fix the bug in the authentication module." },
+  { category: "code-debug", text: "Debug this TypeError: Cannot read property of undefined." },
+  { category: "code-debug", text: "Fix the null pointer exception in the login handler." },
+
+  { category: "deep-explore", text: "Analyze every file in this entire codebase and document the full architecture." },
+  { category: "deep-explore", text: "Map out every module and its dependencies across the whole project." },
+
+  { category: "reference-prior", text: "That bug we fixed yesterday, remember what we discussed?" },
+  { category: "reference-prior", text: "What did we decide about the database schema earlier?" },
+
+  { category: "meta-session", text: "What have we been working on? Summarize our progress." },
+  { category: "meta-session", text: "Give me a summary of everything we accomplished today." },
+
+  { category: "multi-step", text: "First refactor the auth module, then update the tests, then update the docs." },
+  { category: "multi-step", text: "Step one: add the new field. Step two: migrate the database. Step three: update the API." },
+
+  { category: "continuation", text: "Keep going. Continue. Yes do that." },
+  { category: "continuation", text: "Go ahead. Yes, proceed with that approach." },
+];
+
+const CONFIDENCE_THRESHOLD = 0.65;
+
+// --- Intent classifier (instance-based, caches centroids per EmbeddingService) ---
+
+const centroidCache = new WeakMap<EmbeddingService, { category: IntentCategory; vec: number[] }[]>();
+const centroidInitPromise = new WeakMap<EmbeddingService, Promise<void>>();
+
+async function ensurePrototypes(embeddings: EmbeddingService): Promise<{ category: IntentCategory; vec: number[] }[]> {
+  const existing = centroidCache.get(embeddings);
+  if (existing) return existing;
+
+  let promise = centroidInitPromise.get(embeddings);
+  if (!promise) {
+    promise = (async () => {
+      const byCategory = new Map<IntentCategory, number[][]>();
+      for (const proto of PROTOTYPES) {
+        const vec = await embeddings.embed(proto.text);
+        if (!byCategory.has(proto.category)) byCategory.set(proto.category, []);
+        byCategory.get(proto.category)!.push(vec);
+      }
+      const centroids: { category: IntentCategory; vec: number[] }[] = [];
+      for (const [category, vecs] of byCategory) {
+        const dim = vecs[0].length;
+        const centroid = new Array(dim).fill(0);
+        for (const v of vecs) {
+          for (let d = 0; d < dim; d++) centroid[d] += v[d];
+        }
+        for (let d = 0; d < dim; d++) centroid[d] /= vecs.length;
+        centroids.push({ category, vec: centroid });
+      }
+      centroidCache.set(embeddings, centroids);
+    })();
+    centroidInitPromise.set(embeddings, promise);
+  }
+  await promise;
+  return centroidCache.get(embeddings)!;
+}
+
+function cosine(a: number[], b: number[]): number {
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom > 0 ? dot / denom : 0;
+}
+
+// --- Public API ---
+
+export async function classifyIntent(text: string, embeddings: EmbeddingService): Promise<IntentResult> {
+  if (!embeddings.isAvailable()) {
+    return { category: "unknown", confidence: 0, scores: [] };
+  }
+
+  const prototypeVecs = await ensurePrototypes(embeddings);
+  const inputVec = await embeddings.embed(text);
+  const scores: { category: IntentCategory; score: number }[] = [];
+
+  for (const proto of prototypeVecs) {
+    scores.push({ category: proto.category, score: cosine(inputVec, proto.vec) });
+  }
+
+  scores.sort((a, b) => b.score - a.score);
+  const top = scores[0];
+
+  if (top.score < CONFIDENCE_THRESHOLD) {
+    return { category: "unknown", confidence: top.score, scores };
+  }
+
+  return { category: top.category, confidence: top.score, scores };
+}
+
+export function estimateComplexity(text: string, intent: IntentResult): ComplexityEstimate {
+  const words = text.split(/\s+/).length;
+  const hasMultiStep = /\b(then|also|after that|next|finally|first|second)\b/i.test(text);
+  const hasEvery = /\b(every|all|each|entire|whole|full)\b/i.test(text);
+
+  const baseMap: Record<IntentCategory, { level: ComplexityLevel; tools: number; thinking: ThinkingLevel }> = {
+    "simple-question": { level: "trivial", tools: 0, thinking: "low" },
+    "code-read":       { level: "simple", tools: 4, thinking: "medium" },
+    "code-write":      { level: "moderate", tools: 8, thinking: "high" },
+    "code-debug":      { level: "moderate", tools: 10, thinking: "high" },
+    "deep-explore":    { level: "deep", tools: 20, thinking: "medium" },
+    "reference-prior": { level: "simple", tools: 4, thinking: "medium" },
+    "meta-session":    { level: "trivial", tools: 0, thinking: "low" },
+    "multi-step":      { level: "complex", tools: 15, thinking: "high" },
+    "continuation":    { level: "simple", tools: 8, thinking: "medium" },
+    "unknown":         { level: "moderate", tools: 10, thinking: "medium" },
+  };
+
+  const base = baseMap[intent.category];
+  let { level, tools, thinking } = base;
+
+  if (hasMultiStep && level !== "deep") {
+    level = "complex";
+    tools = Math.max(tools, 12);
+    thinking = "high";
+  }
+  if (hasEvery && level !== "deep") {
+    level = "deep";
+    tools = Math.max(tools, 20);
+  }
+  if (words > 100) {
+    tools = Math.max(tools, 12);
+  }
+
+  return { level, estimatedToolCalls: tools, suggestedThinking: thinking };
+}