wicked-brain 0.4.15 → 0.6.0

package/install.mjs

@@ -126,6 +126,31 @@ if (installHooks) {
   }
 }
 
+// Register as a wicked-bus provider if bus is available
+try {
+  const { openDb, resolveDbPath, register } = await import("wicked-bus");
+  const busDbPath = resolveDbPath();
+  const busDb = openDb(busDbPath);
+  try {
+    register(busDb, {
+      plugin: "wicked-brain",
+      role: "provider",
+      filter: "wicked.*",
+    });
+    console.log("\nwicked-bus: registered wicked-brain as provider");
+  } catch (err) {
+    // Already registered or other non-fatal issue
+    if (err.message && err.message.includes("UNIQUE")) {
+      console.log("\nwicked-bus: wicked-brain already registered as provider");
+    } else {
+      console.log(`\nwicked-bus: could not register (${err.message})`);
+    }
+  }
+  busDb.close();
+} catch {
+  console.log("\nwicked-bus: not available (install wicked-bus to enable event integration)");
+}
+
 // Server binary is bundled — npx wicked-brain-server works automatically
 // Skills reference it as: npx wicked-brain-server --brain {path} --port {port}
 console.log("\nServer: bundled (use 'npx wicked-brain-server' to start)");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wicked-brain",
-  "version": "0.4.15",
+  "version": "0.6.0",
   "type": "module",
   "description": "Digital brain as skills for AI coding CLIs — no vector DB, no embeddings, no infrastructure",
   "keywords": [
@@ -31,7 +31,8 @@
     "wicked-brain-server": "./server/bin/wicked-brain-server.mjs"
   },
   "dependencies": {
-    "better-sqlite3": "^12.0.0"
+    "better-sqlite3": "^12.0.0",
+    "wicked-bus": "^1.0.0"
   },
   "files": [
     "install.mjs",

package/server/bin/wicked-brain-server.mjs

@@ -6,6 +6,7 @@ import { argv, pid, exit } from "node:process";
 import { FileWatcher } from "../lib/file-watcher.mjs";
 import { SqliteSearch } from "../lib/sqlite-search.mjs";
 import { LspClient } from "../lib/lsp-client.mjs";
+import { emitEvent, waitForBus } from "../lib/bus.mjs";
 
 // Parse args
 const args = argv.slice(2);
@@ -88,11 +89,38 @@ process.on("SIGINT", () => shutdown());
 // Action dispatch
 const actions = {
   health: () => db.health(),
-  search: (p) => db.search(p),
-  federated_search: (p) => db.federatedSearch(p),
-  index: (p) => db.index(p),
-  remove: (p) => db.remove(p.id),
-  reindex: (p) => db.reindex(p.docs),
+  search: (p) => {
+    const result = db.search(p);
+    emitEvent("wicked.search.executed", "brain.search", {
+      query: p.query, result_count: result.total_matches, brain_id: brainId,
+    });
+    return result;
+  },
+  federated_search: (p) => {
+    const result = db.federatedSearch(p);
+    emitEvent("wicked.search.executed", "brain.search", {
+      query: p.query, federated: true, brain_id: brainId,
+    });
+    return result;
+  },
+  index: (p) => {
+    db.index(p);
+    emitEvent("wicked.chunk.indexed", "brain.chunk", {
+      id: p.id, path: p.path, brain_id: brainId,
+    });
+  },
+  remove: (p) => {
+    db.remove(p.id);
+    emitEvent("wicked.chunk.removed", "brain.chunk", {
+      id: p.id, brain_id: brainId,
+    });
+  },
+  reindex: (p) => {
+    db.reindex(p.docs);
+    emitEvent("wicked.brain.reindexed", "brain", {
+      doc_count: p.docs.length, brain_id: brainId,
+    });
+  },
   backlinks: (p) => ({ links: db.backlinks(p.id) }),
   forward_links: (p) => ({ links: db.forwardLinks(p.id) }),
   stats: () => db.stats(),
@@ -125,7 +153,13 @@ const actions = {
   access_log: (p) => db.accessLog(p.id),
   recent_memories: (p) => ({ memories: db.recentMemories(p) }),
   contradictions: () => ({ links: db.contradictions() }),
-  confirm_link: (p) => db.confirmLink(p.source_id, p.target_path, p.verdict),
+  confirm_link: (p) => {
+    const result = db.confirmLink(p.source_id, p.target_path, p.verdict);
+    emitEvent("wicked.link.confirmed", "brain.link", {
+      source_id: p.source_id, target_path: p.target_path, verdict: p.verdict, brain_id: brainId,
+    });
+    return result;
+  },
   link_health: () => db.linkHealth(),
   tag_frequency: () => ({ tags: db.tagFrequency() }),
   search_misses: (p) => ({ misses: db.searchMisses(p) }),
@@ -201,7 +235,11 @@ try {
   console.error(`Warning: could not write port to config: ${err.message}`);
 }
 
-server.listen(port, () => {
+server.listen(port, async () => {
   console.log(`wicked-brain-server running on port ${port} (brain: ${brainId}, pid: ${pid})`);
   watcher.start();
+  await waitForBus();
+  emitEvent("wicked.server.started", "brain.system", {
+    brain_id: brainId, port, pid,
+  });
 });

package/server/lib/bus.mjs

@@ -0,0 +1,75 @@
+/**
+ * wicked-bus integration for wicked-brain-server.
+ *
+ * Emits events to the bus when the bus is available.
+ * Degrades gracefully — if wicked-bus is not installed or the DB
+ * is unreachable, events are silently dropped.
+ *
+ * @module lib/bus
+ */
+
+const DOMAIN = "wicked-brain";
+
+let busEmit = null;
+let busDb = null;
+let busConfig = null;
+let available = false;
+
+/**
+ * Try to load wicked-bus at startup. If unavailable, all emit calls are no-ops.
+ */
+async function init() {
+  try {
+    const bus = await import("wicked-bus");
+    busConfig = bus.loadConfig();
+    const dbPath = bus.resolveDbPath();
+    busDb = bus.openDb(dbPath);
+    busEmit = bus.emit;
+    available = true;
+  } catch {
+    // wicked-bus not installed or not initialized — degrade silently
+    available = false;
+  }
+}
+
+// Initialize on module load (non-blocking)
+const ready = init();
+
+/**
+ * Emit an event to the bus.
+ * Fire-and-forget — never throws, never blocks the caller.
+ *
+ * @param {string} eventType - e.g. "wicked.chunk.indexed"
+ * @param {string} subdomain - e.g. "brain.chunk"
+ * @param {object} payload - event-specific data
+ */
+export function emitEvent(eventType, subdomain, payload) {
+  if (!available) return;
+  try {
+    busEmit(busDb, busConfig, {
+      event_type: eventType,
+      domain: DOMAIN,
+      subdomain,
+      payload,
+    });
+  } catch {
+    // Bus emit failed — degrade silently
+  }
+}
+
+/**
+ * Whether the bus is available.
+ * @returns {boolean}
+ */
+export function busAvailable() {
+  return available;
+}
+
+/**
+ * Wait for bus initialization to complete.
+ * Only needed if you must know availability before the first emit.
+ */
+export async function waitForBus() {
+  await ready;
+  return available;
+}

package/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wicked-brain-server",
-  "version": "0.4.15",
+  "version": "0.6.0",
   "type": "module",
   "description": "SQLite FTS5 search server for wicked-brain digital knowledge bases",
   "keywords": [

package/skills/wicked-brain-agent/SKILL.md

@@ -58,6 +58,30 @@ context or produce incomplete results.
 
 If the host CLI does not support subagent dispatch, fall back to inline execution — run the pipeline steps directly in the current context.
 
+## Bus Events
+
+When dispatching an agent, emit:
+
+```bash
+npx wicked-bus emit \
+  --type "wicked.agent.dispatched" \
+  --domain "wicked-brain" \
+  --subdomain "brain.agent" \
+  --payload '{"agent":"{agent_name}","brain_id":"{brain_id}"}' 2>/dev/null || true
+```
+
+The consolidate agent should also emit `wicked.brain.consolidated` on completion:
+
+```bash
+npx wicked-bus emit \
+  --type "wicked.brain.consolidated" \
+  --domain "wicked-brain" \
+  --subdomain "brain" \
+  --payload '{"brain_id":"{brain_id}","archived":{N},"promoted":{M},"merged":{P}}' 2>/dev/null || true
+```
+
+Fire-and-forget — if the bus is not installed, silently skip.
+
 ## Cross-Platform Notes
 
 - Agent definitions are portable markdown — they work on all platforms

package/skills/wicked-brain-compile/SKILL.md

@@ -215,7 +215,21 @@ Append to `{brain_path}/_meta/log.jsonl` for each article:
 {"ts":"{ISO}","op":"write","path":"{article_path}","author":"llm:compile","content_hash":"{hash}"}
 ```
 
-## Step 7: Report
+## Step 7: Emit bus events
+
+For each article written or updated, emit:
+
+```bash
+npx wicked-bus emit \
+  --type "wicked.article.compiled" \
+  --domain "wicked-brain" \
+  --subdomain "brain.wiki" \
+  --payload '{"path":"{article_path}","brain_id":"{brain_id}","source_chunk_count":{N},"persona":"{synthesis_persona}"}' 2>/dev/null || true
+```
+
+Fire-and-forget — if the bus is not installed, silently skip.
+
+## Step 8: Report
 
 State how many articles were created/updated and what concepts they cover.
 ```

package/skills/wicked-brain-configure/SKILL.md

@@ -105,7 +105,19 @@ Digital brain: {brain_id} | {total} indexed items | {chunks} chunks, {wiki} wiki
 - Capture non-obvious decisions, patterns, and gotchas with `wicked-brain:memory`
 ```
 
-### Step 4: Confirm
+### Step 4: Emit bus event
+
+```bash
+npx wicked-bus emit \
+  --type "wicked.config.updated" \
+  --domain "wicked-brain" \
+  --subdomain "brain.system" \
+  --payload '{"config_file":"{path}","platform":"{detected_platform}","brain_id":"{brain_id}"}' 2>/dev/null || true
+```
+
+Fire-and-forget — if the bus is not installed, silently skip.
+
+### Step 5: Confirm
 
 Report what was written and where:
 - Config file: {path}

package/skills/wicked-brain-enhance/SKILL.md

@@ -137,7 +137,21 @@ Only synthesize connections and summaries from what already exists.}
 Index each new chunk via the server API.
 Append to log.jsonl for each chunk written.
 
-## Step 5: Report
+## Step 5: Emit bus events
+
+For each inferred chunk created, emit:
+
+```bash
+npx wicked-bus emit \
+  --type "wicked.chunk.enhanced" \
+  --domain "wicked-brain" \
+  --subdomain "brain.chunk" \
+  --payload '{"path":"{chunk_path}","brain_id":"{brain_id}","topic":"{topic}","confidence":0.6}' 2>/dev/null || true
+```
+
+Fire-and-forget — if the bus is not installed, silently skip.
+
+## Step 6: Report
 
 State what gaps were identified and how many inferred chunks were created.
 ```

package/skills/wicked-brain-forget/SKILL.md

@@ -88,7 +88,19 @@ Append to `{brain_path}/_meta/log.jsonl`:
 {"ts":"{ISO}","op":"memory_forget","path":"{path}","id":"{id}","mode":"{mode}","reason":"{reason}","author":"agent:forget"}
 ```
 
-### Step 6: Report
+### Step 6: Emit bus event
+
+```bash
+npx wicked-bus emit \
+  --type "wicked.memory.archived" \
+  --domain "wicked-brain" \
+  --subdomain "brain.memory" \
+  --payload '{"path":"{path}","id":"{id}","mode":"{mode}","reason":"{reason}"}' 2>/dev/null || true
+```
+
+Fire-and-forget — if the bus is not installed, silently skip.
+
+### Step 7: Report
 
 Report: path, id, previous frontmatter type/tier (if memory), archive filename,
 and whether index removal succeeded. Always surface the archive path so the

package/skills/wicked-brain-init/SKILL.md

@@ -280,7 +280,21 @@ Invoke `wicked-brain:configure` to write routing instructions into the active
 CLI's agent config (CLAUDE.md, GEMINI.md, etc.). This is what makes the brain
 the default for search and exploration — do not skip this step.
 
-### Step 10: Confirm
+### Step 10: Emit bus event
+
+If wicked-bus is available, emit an initialization event:
+
+```bash
+npx wicked-bus emit \
+  --type "wicked.brain.initialized" \
+  --domain "wicked-brain" \
+  --subdomain "brain" \
+  --payload '{"brain_id":"{id}","brain_path":"{brain_path}","name":"{name}"}' 2>/dev/null || true
+```
+
+This is fire-and-forget — if the bus is not installed, the command silently fails.
+
+### Step 11: Confirm
 
 Tell the user:
 "Brain `{name}` is ready at `{brain_path}` — {N} files ingested, {M} chunks indexed.

package/skills/wicked-brain-memory/SKILL.md

@@ -35,10 +35,12 @@ project root.
 
 - **mode** (required): `store` or `recall`
 - **content** (store mode): the memory content to store
-- **type** (store mode, optional): `decision`, `pattern`, `preference`, `gotcha`, or `discovery`. Auto-detected if omitted.
+- **type** (store mode, optional): `decision`, `pattern` (alias: `procedural`), `preference`, `gotcha`, or `discovery`. Auto-detected if omitted. `procedural` is an input alias only — storage frontmatter always writes `type: pattern`.
 - **ttl_days** (store mode, optional): number of days before this memory expires. Defaults by type.
+- **importance** (store mode, optional): `low`, `medium`, or `high`. Overrides the type default. Bands: low = 1-3, medium = 4-6, high = 7-10. Used to derive the initial tier (see Step 2b).
+- **tier** (store mode, optional): explicit tier override (`working`, `episodic`, `semantic`). Takes precedence over `importance`.
 - **query** (recall mode): search term for finding memories
-- **filter_type** (recall mode, optional): filter by memory type
+- **filter_type** (recall mode, optional): filter by memory type. `procedural` is normalized to `pattern`.
 - **filter_tier** (recall mode, optional): filter by tier (`working`, `episodic`, `semantic`)
 
 ## Store Mode
@@ -47,11 +49,15 @@ project root.
 
 If type is not provided, classify the content:
 - Contains "decided", "chose", "will use", "going with" → `decision`
-- Contains "pattern", "always", "tends to", "convention" → `pattern`
+- Contains "pattern", "always", "tends to", "convention" → `pattern` (if the caller explicitly passed `type: procedural`, normalize to `pattern` before continuing)
 - Contains "prefer", "like", "want", "should always" → `preference`
 - Contains "watch out", "careful", "gotcha", "trap", "bug" → `gotcha`
 - Otherwise → `discovery`
 
+#### Type aliases
+
+- `procedural` → `pattern` (normalize on input; storage always writes `type: pattern`)
+
 ### Step 2: Apply type defaults
 
 | Type | Default importance | Default ttl_days |
@@ -62,7 +68,14 @@ If type is not provided, classify the content:
 | gotcha | 5 | 30 |
 | discovery | 4 | 14 |
 
-Agent-provided overrides take precedence.
+Agent-provided overrides take precedence. An explicit `importance` arg overrides the type default.
+
+### Step 2b: Resolve initial tier from importance
+
+- If `tier` is explicitly passed → use that, skip the rest.
+- Else if `importance` is `high` (or numeric importance >= 7) → `semantic`
+- Else if `importance` is `low` (or numeric importance <= 3) → `working`
+- Else (medium, or 4-6) → `episodic`
 
 ### Step 3: Generate tags with synonym expansion
 
@@ -88,7 +101,7 @@ Write to `{brain_path}/memory/{safe_name}.md`:
 ```yaml
 ---
 type: {detected or provided type}
-tier: working
+tier: {resolved tier from Step 2b}
 confidence: 0.5
 importance: {from type defaults or override}
 ttl_days: {from type defaults or override, null if permanent}
@@ -112,14 +125,14 @@ indexed_at: "{ISO 8601 timestamp}"
 - **episodic**: Specific events or decisions from past sessions. Medium longevity. Use for "we decided X on date Y" or "this happened in project Z".
 - **semantic**: Generalized patterns and facts extracted from experience. Permanent by default. Use for stable conventions, recurring patterns, and distilled knowledge that transcends any single session.
 
-New memories always start at `tier: working`. Consolidation (wicked-brain:consolidate) promotes them to `episodic` or `semantic` based on access frequency and age.
+New memories start at the tier resolved from importance (default `episodic` for medium importance, `working` for low, `semantic` for high). Consolidation (wicked-brain:consolidate) still promotes them across tiers based on access frequency and age.
 
 #### Complete example
 
 ```yaml
 ---
 type: decision
-tier: working
+tier: semantic
 confidence: 0.9
 importance: 7
 ttl_days: null
@@ -151,9 +164,21 @@ The server's file watcher will auto-index this file.
 Append to `{brain_path}/_meta/log.jsonl`:
 
 ```json
-{"ts":"{ISO}","op":"memory_store","path":"memory/{safe_name}.md","type":"{type}","tier":"working","author":"agent:memory"}
+{"ts":"{ISO}","op":"memory_store","path":"memory/{safe_name}.md","type":"{type}","tier":"{resolved tier}","author":"agent:memory"}
 ```
 
+### Step 7: Emit bus event
+
+```bash
+npx wicked-bus emit \
+  --type "wicked.memory.stored" \
+  --domain "wicked-brain" \
+  --subdomain "brain.memory" \
+  --payload '{"path":"memory/{safe_name}.md","type":"{type}","tier":"{resolved tier}","brain_id":"{brain_id}"}' 2>/dev/null || true
+```
+
+Fire-and-forget — if the bus is not installed, silently skip.
+
 ## Recall Mode
 
 ### Progressive loading
@@ -175,7 +200,7 @@ consolidation. Use a consistent session_id for the entire conversation.
 
 ### Step 2: Filter results
 
-Filter to paths starting with `memory/`. If filter_type or filter_tier provided, read frontmatter and filter accordingly.
+Filter to paths starting with `memory/`. If filter_type or filter_tier provided, read frontmatter and filter accordingly. Normalize `filter_type: procedural` to `pattern` before matching, so it matches memories stored with `type: pattern`.
 
 ### Step 3: Apply tier weighting
 

package/skills/wicked-brain-migrate/SKILL.md

@@ -246,7 +246,19 @@ Delete the flat `_meta/` directory:
 
 The flat path is now a pure container with only `projects/` beneath it.
 
-### Step 10: Report
+### Step 10: Emit bus event
+
+```bash
+npx wicked-bus emit \
+  --type "wicked.schema.migrated" \
+  --domain "wicked-brain" \
+  --subdomain "brain.system" \
+  --payload '{"from":"{flat_path}","to":"{target_path}","brain_id":"{brain_id}","doc_count":{N}}' 2>/dev/null || true
+```
+
+Fire-and-forget — if the bus is not installed, silently skip.
+
+### Step 11: Report
 
 Tell the user:
 

package/skills/wicked-brain-query/SKILL.md

@@ -177,7 +177,19 @@ Sources:
 - {path}: {one-line description of what it contributed}
 - {path}: {one-line description}
 
-## Step 5: Log search effectiveness
+## Step 5: Emit bus event
+
+```bash
+npx wicked-bus emit \
+  --type "wicked.query.executed" \
+  --domain "wicked-brain" \
+  --subdomain "brain.query" \
+  --payload '{"question":"{question}","sources_found":{count},"brain_id":"{brain_id}"}' 2>/dev/null || true
+```
+
+Fire-and-forget — if the bus is not installed, silently skip.
+
+## Step 6: Log search effectiveness
 
 If evidence was insufficient to answer the question fully, append a
 search-miss event to the brain's log:

package/skills/wicked-brain-retag/SKILL.md

@@ -83,7 +83,21 @@ If **dry_run**: report the file path, current tag count, and proposed new tags.
 
 If not dry_run: update the `contains:` field in the YAML frontmatter in-place using the Edit tool. The server's file watcher will detect the change and re-index.
 
-### Step 5: Summary
+### Step 5: Emit bus event
+
+After all files are updated (not in dry_run mode), emit a single summary event:
+
+```bash
+npx wicked-bus emit \
+  --type "wicked.tag.backfilled" \
+  --domain "wicked-brain" \
+  --subdomain "brain.chunk" \
+  --payload '{"files_updated":{N},"files_scanned":{total},"brain_id":"{brain_id}"}' 2>/dev/null || true
+```
+
+Fire-and-forget — if the bus is not installed, silently skip.
+
+### Step 6: Summary
 
 Report:
 - Total files scanned

package/skills/wicked-brain-synonyms/SKILL.md

@@ -138,3 +138,17 @@ Ask: "Apply all, apply some (specify numbers), or cancel?"
 
 Only write to `synonyms.json` after explicit user approval. Merge approved
 suggestions with any existing entries using the same add-synonym logic above.
+
+## Bus Events
+
+After any write to `synonyms.json` (add, remove, or auto-suggest apply), emit:
+
+```bash
+npx wicked-bus emit \
+  --type "wicked.synonym.updated" \
+  --domain "wicked-brain" \
+  --subdomain "brain.taxonomy" \
+  --payload '{"operation":"{add|remove|auto-apply}","term":"{term}","brain_id":"{brain_id}"}' 2>/dev/null || true
+```
+
+Fire-and-forget — if the bus is not installed, silently skip.