@digitalforgestudios/openclaw-sulcus 3.5.5 → 3.8.0

package/README.md

@@ -51,6 +51,46 @@ Then restart: `openclaw gateway restart`
 | `memory_store` | Store with auto-detected type |
 | `memory_forget` | Delete by ID |
 
+## Hooks & Extended Tools
+
+All hooks and tools are **enabled by default**. Override in your `openclaw.json` plugin config:
+
+```json
+"openclaw-sulcus": {
+  "enabled": true,
+  "config": {
+    "apiKey": "sk-YOUR_KEY_HERE",
+    "hooks": {
+      "before_prompt_build": { "action": "inject_awareness", "enabled": true },
+      "before_agent_start": { "action": "auto_recall", "enabled": true, "limit": 5, "minScore": 0.3 },
+      "agent_end": { "action": "none", "enabled": true }
+    },
+    "tools": {
+      "memory_recall": { "enabled": true },
+      "memory_store": { "enabled": true },
+      "memory_status": { "enabled": true },
+      "consolidate": { "enabled": true },
+      "export_markdown": { "enabled": true },
+      "import_markdown": { "enabled": true },
+      "evaluate_triggers": { "enabled": true }
+    }
+  }
+}
+```
+
+| Hook | Default | Description |
+|---|---|---|
+| `before_prompt_build` | ON | Inject memory awareness context into prompts |
+| `before_agent_start` | ON | Auto-recall relevant memories each turn |
+| `agent_end` | ON | Post-turn processing |
+
+| Extended Tool | Default | Description |
+|---|---|---|
+| `consolidate` | ON | Cluster and merge similar memories |
+| `export_markdown` | ON | Export memories as markdown |
+| `import_markdown` | ON | Import memories from markdown |
+| `evaluate_triggers` | ON | Run reactive trigger evaluations |
+
 ## Features
 
 - **Auto-recall** — relevant memories injected before each agent turn

package/bin/configure.mjs

@@ -1,10 +1,13 @@
 #!/usr/bin/env node
 /**
  * Sulcus Configuration Wizard
- * Interactive CLI to configure the openclaw-sulcus plugin in openclaw.json
+ * Interactive CLI to configure Sulcus for multiple AI tools.
  *
  * Usage:
- *   npx @digitalforgestudios/openclaw-sulcus configure
+ *   npx @digitalforgestudios/openclaw-sulcus configure             # OpenClaw
+ *   npx @digitalforgestudios/openclaw-sulcus configure --claude    # Claude CLI / Claude Code
+ *   npx @digitalforgestudios/openclaw-sulcus configure --openai    # OpenAI Codex CLI
+ *   npx @digitalforgestudios/openclaw-sulcus configure --gemini    # Google Gemini CLI
  *   node bin/configure.mjs [--no-color] [--help]
  */
 
@@ -43,31 +46,60 @@ const red     = (s) => `${c.red}${s}${c.reset}`;
 const cyan    = (s) => `${c.cyan}${s}${c.reset}`;
 const magenta = (s) => `${c.magenta}${s}${c.reset}`;
 
+// ─── Mode detection ───────────────────────────────────────────────────────────
+
+const MODE_OPENCLAW = 'openclaw';
+const MODE_CLAUDE   = 'claude';
+const MODE_OPENAI   = 'openai';
+const MODE_GEMINI   = 'gemini';
+
+function detectMode() {
+  if (process.argv.includes('--claude')) return MODE_CLAUDE;
+  if (process.argv.includes('--openai')) return MODE_OPENAI;
+  if (process.argv.includes('--gemini')) return MODE_GEMINI;
+  return MODE_OPENCLAW;
+}
+
 // ─── Help ─────────────────────────────────────────────────────────────────────
 
 if (process.argv.includes('--help') || process.argv.includes('-h')) {
   console.log(`
 ${bold('Sulcus Configuration Wizard')}
 
-Interactively configure the openclaw-sulcus plugin inside your openclaw.json.
+Interactively configure Sulcus as an MCP server for your AI tools.
 
 ${bold('Usage:')}
-  npx @digitalforgestudios/openclaw-sulcus configure [options]
-  node bin/configure.mjs [options]
+  npx @digitalforgestudios/openclaw-sulcus configure [mode] [options]
+  node bin/configure.mjs [mode] [options]
+
+${bold('Modes:')}
+  ${dim('(no flag)')}      Configure for ${cyan('OpenClaw')} (openclaw.json)
+  ${cyan('--claude')}       Configure for ${cyan('Claude CLI / Claude Code')}  (~/.claude/claude_desktop_config.json)
+  ${cyan('--openai')}       Configure for ${cyan('OpenAI Codex CLI')}           (~/.codex/config.toml)
+  ${cyan('--gemini')}       Configure for ${cyan('Google Gemini CLI')}          (~/.gemini/settings.json)
 
 ${bold('Options:')}
   --help, -h      Show this help message
   --no-color      Disable coloured output
 
-${bold('What it does:')}
-  1. Locates your openclaw.json (checks \$OPENCLAW_CONFIG_PATH, ~/.openclaw/, ./)
+${bold('OpenClaw mode (default):')}
+  1. Locates your openclaw.json (checks $OPENCLAW_CONFIG_PATH, ~/.openclaw/, ./)
   2. Walks you through backend mode, dylib path, namespace, hooks, and tools
   3. Deep-merges settings under plugins.entries.openclaw-sulcus.config
   4. Validates that your native dylibs exist and warns if they are missing
   5. Reminds you to restart the OpenClaw gateway
 
-${bold('Example:')}
+${bold('MCP server modes (--claude / --openai / --gemini):')}
+  1. Detects if the target CLI is installed
+  2. Asks: Cloud mode (Sulcus API) or Local mode (binary path)?
+  3. Merges the sulcus MCP server entry into the target config
+  4. Preserves all existing config settings
+
+${bold('Examples:')}
   npx @digitalforgestudios/openclaw-sulcus configure
+  npx @digitalforgestudios/openclaw-sulcus configure --claude
+  npx @digitalforgestudios/openclaw-sulcus configure --openai
+  npx @digitalforgestudios/openclaw-sulcus configure --gemini
 `);
   process.exit(0);
 }
@@ -101,8 +133,6 @@ function ask(question, defaultValue = '') {
 
 /**
  * Ask a yes/no question. Returns boolean.
- * @param {string} question
- * @param {boolean} defaultVal
  */
 function askYN(question, defaultVal = false) {
   return new Promise((resolve) => {
@@ -115,27 +145,13 @@ function askYN(question, defaultVal = false) {
   });
 }
 
-// ─── openclaw.json discovery ──────────────────────────────────────────────────
+// ─── Utility helpers ──────────────────────────────────────────────────────────
 
 function expandHome(p) {
   if (p.startsWith('~')) return path.join(os.homedir(), p.slice(1));
   return p;
 }
 
-function findOpenclawJson() {
-  const candidates = [
-    process.env.OPENCLAW_CONFIG_PATH,
-    path.join(os.homedir(), '.openclaw', 'openclaw.json'),
-    path.join(process.cwd(), 'openclaw.json'),
-  ].filter(Boolean);
-
-  for (const candidate of candidates) {
-    const resolved = expandHome(candidate);
-    if (fs.existsSync(resolved)) return resolved;
-  }
-  return null;
-}
-
 // Deep-merge two plain objects (target mutated).
 function deepMerge(target, source) {
   for (const key of Object.keys(source)) {
@@ -155,12 +171,448 @@ function deepMerge(target, source) {
   return target;
 }
 
-// ─── Prebuilt binary download ─────────────────────────────────────────────────
+// ─── Binary detection (sulcus executable) ────────────────────────────────────
+
+const SULCUS_BINARY_SEARCH_PATHS = [
+  path.join(os.homedir(), '.sulcus', 'bin', 'sulcus'),
+  path.join(os.homedir(), '.local', 'bin', 'sulcus'),
+  '/usr/local/bin/sulcus',
+];
 
 /**
- * Detect the current platform slug used in GitHub release asset names.
- * Returns { platform, ext } or throws if unsupported.
+ * Try to locate the sulcus binary.
+ * Returns the absolute path if found, or null.
  */
+function findSulcusBinary() {
+  for (const p of SULCUS_BINARY_SEARCH_PATHS) {
+    if (fs.existsSync(p)) return p;
+  }
+  try {
+    const result = execSync('which sulcus', { stdio: 'pipe' }).toString().trim();
+    if (result && fs.existsSync(result)) return result;
+  } catch (_) {
+    // not on PATH
+  }
+  return null;
+}
+
+/**
+ * Check if a CLI tool is installed by running `which <name>`.
+ */
+function isCliInstalled(name) {
+  try {
+    execSync(`which ${name}`, { stdio: 'pipe' });
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+// ─── JSON config helpers ──────────────────────────────────────────────────────
+
+function readJsonConfig(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return {};
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (_) {
+    return {};
+  }
+}
+
+function writeJsonConfig(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+// ─── Minimal hand-rolled TOML helpers ────────────────────────────────────────
+// Supports the subset needed for ~/.codex/config.toml:
+//   - Bare/quoted string values, integers, booleans
+//   - Arrays of quoted strings: key = ["a", "b"]
+//   - [table] and [table.subtable] headers
+//   - # line comments
+
+function parseToml(src) {
+  const lines = src.split('\n');
+  const root = {};
+  let current = root;
+
+  for (let rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+
+    // Table header: [a.b.c]
+    const tableMatch = line.match(/^\[([^\]]+)\]$/);
+    if (tableMatch) {
+      const parts = tableMatch[1].trim().split('.').map(s => s.trim());
+      current = root;
+      for (const part of parts) {
+        if (current[part] === undefined) current[part] = {};
+        else if (typeof current[part] !== 'object' || Array.isArray(current[part])) {
+          current[part] = {};
+        }
+        current = current[part];
+      }
+      continue;
+    }
+
+    const eqIdx = line.indexOf('=');
+    if (eqIdx === -1) continue;
+
+    const key = line.slice(0, eqIdx).trim();
+    let valStr = line.slice(eqIdx + 1).trim();
+    let value;
+
+    if (valStr.startsWith('[')) {
+      // Array of strings
+      const inner = valStr.slice(1, valStr.lastIndexOf(']'));
+      value = inner
+        .split(',')
+        .map(s => s.trim().replace(/^["']|["']$/g, ''))
+        .filter(s => s.length > 0);
+    } else if (valStr.startsWith('"') || valStr.startsWith("'")) {
+      const q = valStr[0];
+      const end = valStr.indexOf(q, 1);
+      value = end === -1 ? valStr.slice(1) : valStr.slice(1, end);
+    } else if (valStr === 'true') {
+      value = true;
+    } else if (valStr === 'false') {
+      value = false;
+    } else {
+      const commentIdx = valStr.indexOf('#');
+      if (commentIdx !== -1) valStr = valStr.slice(0, commentIdx).trim();
+      const num = Number(valStr);
+      value = isNaN(num) || valStr === '' ? valStr : num;
+    }
+
+    current[key] = value;
+  }
+
+  return root;
+}
+
+function serializeToml(obj, prefix = []) {
+  const scalarLines = [];
+  const subTables = [];
+
+  for (const [key, val] of Object.entries(obj)) {
+    if (val === null || val === undefined) continue;
+
+    if (Array.isArray(val)) {
+      const items = val.map(v => JSON.stringify(String(v))).join(', ');
+      scalarLines.push(`${key} = [${items}]`);
+    } else if (typeof val === 'object') {
+      subTables.push([key, val]);
+    } else if (typeof val === 'string') {
+      scalarLines.push(`${key} = ${JSON.stringify(val)}`);
+    } else {
+      scalarLines.push(`${key} = ${val}`);
+    }
+  }
+
+  const parts = [...scalarLines];
+
+  for (const [key, val] of subTables) {
+    const tablePath = [...prefix, key];
+    parts.push('');
+    parts.push(`[${tablePath.join('.')}]`);
+    const inner = serializeToml(val, tablePath);
+    if (inner) parts.push(inner);
+  }
+
+  return parts.join('\n');
+}
+
+function readTomlConfig(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return {};
+    return parseToml(fs.readFileSync(filePath, 'utf8'));
+  } catch (_) {
+    return {};
+  }
+}
+
+function writeTomlConfig(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const content = serializeToml(data).trimStart() + '\n';
+  fs.writeFileSync(filePath, content, 'utf8');
+}
+
+// ─── Shared MCP server config prompts ────────────────────────────────────────
+
+/**
+ * Ask cloud vs local, collect info, return an MCP server config object:
+ * { command, args, env? }
+ */
+async function askMcpServerConfig() {
+  console.log();
+  console.log(`  ${bold('Mode:')}`);
+  console.log(`    ${cyan('[1]')} Cloud  ${dim('(Sulcus API — requires server URL + API key)')}`);
+  console.log(`    ${cyan('[2]')} Local  ${dim('(sulcus binary installed on this machine)')}`);
+  const modeRaw = await ask(`  >`, '1');
+  const isCloud = modeRaw !== '2';
+  console.log();
+
+  if (isCloud) {
+    const serverUrl = await ask(
+      `  ${bold('Sulcus server URL:')}`,
+      'https://api.sulcus.ca',
+    );
+    const apiKey = await ask(`  ${bold('Sulcus API key')} ${dim('(sk-...)')}:`, '');
+    console.log();
+
+    const env = {};
+    if (serverUrl) env.SULCUS_SERVER_URL = serverUrl;
+    if (apiKey)    env.SULCUS_API_KEY    = apiKey;
+
+    return {
+      command: expandHome('~/.sulcus/bin/sulcus'),
+      args: ['stdio'],
+      ...(Object.keys(env).length > 0 ? { env } : {}),
+    };
+  } else {
+    // Local mode — detect binary
+    const detected = findSulcusBinary();
+    if (detected) {
+      console.log(`  ${green('✓')} Found sulcus binary: ${cyan(detected)}`);
+    } else {
+      console.log(`  ${yellow('⚠')}  sulcus binary not found in common locations.`);
+      console.log(`  ${dim('Search paths checked:')}`);
+      for (const p of SULCUS_BINARY_SEARCH_PATHS) {
+        console.log(`    ${dim('•')} ${dim(p)}`);
+      }
+      console.log(`  ${dim('Download from:')} ${cyan('https://github.com/digitalforgeca/sulcus/releases/latest')}`);
+      console.log();
+    }
+
+    const binaryPath = await ask(
+      `  ${bold('Path to sulcus binary:')}`,
+      detected || expandHome('~/.sulcus/bin/sulcus'),
+    );
+    console.log();
+
+    const wantCloudEnv = await askYN(
+      'Also add SULCUS_SERVER_URL / SULCUS_API_KEY? (for cloud sync)',
+      false,
+    );
+    console.log();
+
+    let env;
+    if (wantCloudEnv) {
+      const serverUrl = await ask(
+        `  ${bold('Sulcus server URL:')}`,
+        'https://api.sulcus.ca',
+      );
+      const apiKey = await ask(`  ${bold('Sulcus API key')} ${dim('(sk-...)')}:`, '');
+      console.log();
+      const e = {};
+      if (serverUrl) e.SULCUS_SERVER_URL = serverUrl;
+      if (apiKey)    e.SULCUS_API_KEY    = apiKey;
+      if (Object.keys(e).length > 0) env = e;
+    }
+
+    return {
+      command: binaryPath,
+      args: ['stdio'],
+      ...(env ? { env } : {}),
+    };
+  }
+}
+
+/**
+ * Print an MCP server summary block.
+ */
+function printMcpSummary(toolName, configFile, serverCfg) {
+  const displayFile = configFile.replace(os.homedir(), '~');
+  console.log(`  ${dim('──── Summary ────────────────────────────────────────')}`);
+  console.log(`  Tool:       ${cyan(toolName)}`);
+  console.log(`  Config:     ${cyan(displayFile)}`);
+  console.log(`  MCP server: ${cyan('sulcus')}`);
+  console.log(`  Command:    ${cyan(serverCfg.command)}`);
+  console.log(`  Args:       ${cyan(serverCfg.args.join(', '))}`);
+  if (serverCfg.env && Object.keys(serverCfg.env).length > 0) {
+    for (const [k, v] of Object.entries(serverCfg.env)) {
+      const display = k === 'SULCUS_API_KEY' && v && v.length > 8
+        ? v.slice(0, 8) + '...'
+        : v;
+      console.log(`  ${k}: ${cyan(display)}`);
+    }
+  }
+  console.log(`  ${dim('─────────────────────────────────────────────────────')}`);
+  console.log();
+}
+
+// ─── Claude wizard ────────────────────────────────────────────────────────────
+
+async function runClaudeWizard() {
+  const configFile = expandHome('~/.claude/claude_desktop_config.json');
+
+  console.log(`
+${bold(magenta('🧠  Sulcus → Claude CLI Configuration Wizard'))}
+${dim('──────────────────────────────────────────────────────')}
+Configures Sulcus as an MCP server for ${cyan('Claude CLI / Claude Code')}.
+Config file: ${cyan('~/.claude/claude_desktop_config.json')}
+Press ${bold('Enter')} to accept defaults. ${bold('Ctrl+C')} to cancel at any time.
+`);
+
+  // Detect claude CLI
+  const claudeInstalled = isCliInstalled('claude');
+  if (claudeInstalled) {
+    console.log(`  ${green('✓')} claude CLI detected on PATH`);
+  } else {
+    console.log(`  ${yellow('⚠')}  claude CLI not found on PATH`);
+    console.log(`  ${dim('Install Claude Code from:')} ${cyan('https://claude.ai/download')}`);
+  }
+
+  const serverCfg = await askMcpServerConfig();
+
+  console.log(`${bold('Writing config...')}`);
+
+  let existing = readJsonConfig(configFile);
+  if (!existing.mcpServers) existing.mcpServers = {};
+  existing.mcpServers.sulcus = serverCfg;
+
+  try {
+    writeJsonConfig(configFile, existing);
+  } catch (err) {
+    console.log(`  ${red('✗')} Failed to write ${cyan(configFile)}: ${err.message}`);
+    rl.close();
+    process.exit(1);
+  }
+
+  console.log(`  ${green('✓')} Written to ${cyan(configFile.replace(os.homedir(), '~'))}`);
+  console.log();
+
+  printMcpSummary('Claude CLI / Claude Code', configFile, serverCfg);
+
+  console.log(`  ${bold(green('✅  Configuration complete!'))} Restart Claude to pick up changes.`);
+  console.log();
+
+  rl.close();
+}
+
+// ─── OpenAI Codex wizard ──────────────────────────────────────────────────────
+
+async function runOpenAIWizard() {
+  const configFile = expandHome('~/.codex/config.toml');
+
+  console.log(`
+${bold(magenta('🧠  Sulcus → OpenAI Codex CLI Configuration Wizard'))}
+${dim('────────────────────────────────────────────────────────')}
+Configures Sulcus as an MCP server for ${cyan('OpenAI Codex CLI')}.
+Config file: ${cyan('~/.codex/config.toml')}
+Press ${bold('Enter')} to accept defaults. ${bold('Ctrl+C')} to cancel at any time.
+`);
+
+  // Detect codex CLI
+  const codexInstalled = isCliInstalled('codex');
+  if (codexInstalled) {
+    console.log(`  ${green('✓')} codex CLI detected on PATH`);
+  } else {
+    console.log(`  ${yellow('⚠')}  codex CLI not found on PATH`);
+    console.log(`  ${dim('Install from:')} ${cyan('https://github.com/openai/codex')}`);
+  }
+
+  const serverCfg = await askMcpServerConfig();
+
+  console.log(`${bold('Writing config...')}`);
+
+  // Read existing TOML and merge in the sulcus entry
+  let existing = readTomlConfig(configFile);
+  if (!existing.mcp_servers) existing.mcp_servers = {};
+  existing.mcp_servers.sulcus = {
+    command: serverCfg.command,
+    args: serverCfg.args,
+    ...(serverCfg.env && Object.keys(serverCfg.env).length > 0
+      ? { env: serverCfg.env }
+      : {}),
+  };
+
+  try {
+    writeTomlConfig(configFile, existing);
+  } catch (err) {
+    console.log(`  ${red('✗')} Failed to write ${cyan(configFile)}: ${err.message}`);
+    rl.close();
+    process.exit(1);
+  }
+
+  console.log(`  ${green('✓')} Written to ${cyan(configFile.replace(os.homedir(), '~'))}`);
+  console.log();
+
+  printMcpSummary('OpenAI Codex CLI', configFile, serverCfg);
+
+  console.log(`  ${bold(green('✅  Configuration complete!'))} Restart Codex to pick up changes.`);
+  console.log();
+
+  rl.close();
+}
+
+// ─── Gemini wizard ────────────────────────────────────────────────────────────
+
+async function runGeminiWizard() {
+  const configFile = expandHome('~/.gemini/settings.json');
+
+  console.log(`
+${bold(magenta('🧠  Sulcus → Google Gemini CLI Configuration Wizard'))}
+${dim('──────────────────────────────────────────────────────────')}
+Configures Sulcus as an MCP server for ${cyan('Google Gemini CLI')}.
+Config file: ${cyan('~/.gemini/settings.json')}
+Press ${bold('Enter')} to accept defaults. ${bold('Ctrl+C')} to cancel at any time.
+`);
+
+  // Detect gemini CLI
+  const geminiInstalled = isCliInstalled('gemini');
+  if (geminiInstalled) {
+    console.log(`  ${green('✓')} gemini CLI detected on PATH`);
+  } else {
+    console.log(`  ${yellow('⚠')}  gemini CLI not found on PATH`);
+    console.log(`  ${dim('Install from:')} ${cyan('https://github.com/google-gemini/gemini-cli')}`);
+  }
+
+  const serverCfg = await askMcpServerConfig();
+
+  console.log(`${bold('Writing config...')}`);
+
+  let existing = readJsonConfig(configFile);
+  if (!existing.mcpServers) existing.mcpServers = {};
+  existing.mcpServers.sulcus = serverCfg;
+
+  try {
+    writeJsonConfig(configFile, existing);
+  } catch (err) {
+    console.log(`  ${red('✗')} Failed to write ${cyan(configFile)}: ${err.message}`);
+    rl.close();
+    process.exit(1);
+  }
+
+  console.log(`  ${green('✓')} Written to ${cyan(configFile.replace(os.homedir(), '~'))}`);
+  console.log();
+
+  printMcpSummary('Google Gemini CLI', configFile, serverCfg);
+
+  console.log(`  ${bold(green('✅  Configuration complete!'))} Restart Gemini CLI to pick up changes.`);
+  console.log();
+
+  rl.close();
+}
+
+// ─── openclaw.json discovery ──────────────────────────────────────────────────
+
+function findOpenclawJson() {
+  const candidates = [
+    process.env.OPENCLAW_CONFIG_PATH,
+    path.join(os.homedir(), '.openclaw', 'openclaw.json'),
+    path.join(process.cwd(), 'openclaw.json'),
+  ].filter(Boolean);
+
+  for (const candidate of candidates) {
+    const resolved = expandHome(candidate);
+    if (fs.existsSync(resolved)) return resolved;
+  }
+  return null;
+}
+
+// ─── Prebuilt binary download (dylibs for OpenClaw mode) ─────────────────────
+
 function detectPlatform() {
   const plat = process.platform;
   const arch = process.arch;
@@ -178,11 +630,6 @@ function detectPlatform() {
   );
 }
 
-/**
- * Follow redirects and download `url` into `destFile`.
- * Shows a simple percentage progress bar (or dots when content-length is unknown).
- * Follows up to maxRedirects hops.
- */
 function downloadFile(url, destFile, maxRedirects = 5) {
   return new Promise((resolve, reject) => {
     let hops = 0;
@@ -204,13 +651,12 @@ function downloadFile(url, destFile, maxRedirects = 5) {
       const req = https.request(opts, (res) => {
         const { statusCode, headers: resHeaders } = res;
 
-        // Follow 301/302/307/308 redirects
         if (
           (statusCode === 301 || statusCode === 302 ||
            statusCode === 307 || statusCode === 308) &&
           resHeaders.location
         ) {
-          res.resume(); // drain
+          res.resume();
           return attempt(resHeaders.location);
         }
 
@@ -236,7 +682,6 @@ function downloadFile(url, destFile, maxRedirects = 5) {
               process.stdout.write(`\r    Downloading... ${pct}%   `);
             }
           } else {
-            // No content-length — show dots
             if (received % (64 * 1024) === 0) process.stdout.write('.');
           }
         });
@@ -262,13 +707,6 @@ function downloadFile(url, destFile, maxRedirects = 5) {
   });
 }
 
-/**
- * Download and install prebuilt dylibs for the current platform.
- * Returns true on success, false if the user skips or something goes wrong.
- *
- * @param {string} resolvedLibDir  Absolute path where dylibs should be placed
- * @param {string[]} dylibNames    Base names without extension, e.g. ['libsulcus_store', ...]
- */
 async function downloadAndInstallBinaries(resolvedLibDir, dylibNames) {
   let platformInfo;
   try {
@@ -292,7 +730,6 @@ async function downloadAndInstallBinaries(resolvedLibDir, dylibNames) {
     return false;
   }
 
-  // Create libDir if needed
   try {
     fs.mkdirSync(resolvedLibDir, { recursive: true });
   } catch (err) {
@@ -301,6 +738,7 @@ async function downloadAndInstallBinaries(resolvedLibDir, dylibNames) {
     return false;
   }
 
+
   const tmpDir  = fs.mkdtempSync(path.join(os.tmpdir(), 'sulcus-'));
   const tarPath = path.join(tmpDir, `sulcus-${platform}.tar.gz`);
 
@@ -317,7 +755,6 @@ async function downloadAndInstallBinaries(resolvedLibDir, dylibNames) {
     return false;
   }
 
-  // Extract
   console.log(`    Extracting...`);
   try {
     execSync(`tar xzf ${JSON.stringify(tarPath)} -C ${JSON.stringify(tmpDir)}`, { stdio: 'pipe' });
@@ -327,7 +764,6 @@ async function downloadAndInstallBinaries(resolvedLibDir, dylibNames) {
     return false;
   }
 
-  // Move each dylib into libDir
   let allInstalled = true;
   for (const lib of dylibNames) {
     const srcFile  = path.join(tmpDir, lib + ext);
@@ -351,15 +787,14 @@ async function downloadAndInstallBinaries(resolvedLibDir, dylibNames) {
     }
   }
 
-  // Cleanup temp dir
   try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch (_) {}
 
   return allInstalled;
 }
 
-// ─── Main wizard ──────────────────────────────────────────────────────────────
+// ─── OpenClaw wizard (original, unchanged) ───────────────────────────────────
 
-async function run() {
+async function runOpenclawWizard() {
   console.log(`
 ${bold(magenta('🧠  Sulcus Configuration Wizard'))}
 ${dim('────────────────────────────────────────────')}
@@ -367,7 +802,7 @@ Configures the ${cyan('openclaw-sulcus')} plugin inside your ${cyan('openclaw.js
 Press ${bold('Enter')} to accept defaults. ${bold('Ctrl+C')} to cancel at any time.
 `);
 
-  // ── Step 1: Locate openclaw.json ──────────────────────────────────────────
+  // ── Step 1: Locate openclaw.json ─────────────────────────────────────────
 
   console.log(`${bold('Step 1 · Locate openclaw.json')}`);
 
@@ -379,7 +814,7 @@ Press ${bold('Enter')} to accept defaults. ${bold('Ctrl+C')} to cancel at any ti
     console.log(`  ${yellow('⚠')}  Could not find openclaw.json in the usual locations.`);
     console.log(`     Checked:`);
     if (process.env.OPENCLAW_CONFIG_PATH)
-      console.log(`       • \$OPENCLAW_CONFIG_PATH → ${process.env.OPENCLAW_CONFIG_PATH}`);
+      console.log(`       • $OPENCLAW_CONFIG_PATH → ${process.env.OPENCLAW_CONFIG_PATH}`);
     console.log(`       • ~/.openclaw/openclaw.json`);
     console.log(`       • ./openclaw.json\n`);
 
@@ -399,7 +834,6 @@ Press ${bold('Enter')} to accept defaults. ${bold('Ctrl+C')} to cancel at any ti
     }
   }
 
-  // Read existing config
   let existingConfig = {};
   try {
     existingConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
@@ -410,12 +844,11 @@ Press ${bold('Enter')} to accept defaults. ${bold('Ctrl+C')} to cancel at any ti
     process.exit(1);
   }
 
-  // ── Step 2: Wizard questions ──────────────────────────────────────────────
+  // ── Step 2: Wizard questions ─────────────────────────────────────────────
 
   console.log(`${bold('Step 2 · Configure Sulcus')}`);
   console.log();
 
-  // Backend mode
   console.log(`  ${bold('Backend mode:')}`);
   console.log(`    ${cyan('[1]')} Local only ${dim('(WASM + native dylibs, no network)')}`);
   console.log(`    ${cyan('[2]')} Cloud sync  ${dim('(local + server replication)')}`);
@@ -423,7 +856,6 @@ Press ${bold('Enter')} to accept defaults. ${bold('Ctrl+C')} to cancel at any ti
   const cloudSync = modeRaw === '2';
   console.log();
 
-  // Native dylib path
   const libDirDefault = '~/.sulcus/lib';
   const libDirRaw = await ask(
     `  ${bold('Where are your native dylibs?')}`,
@@ -432,11 +864,9 @@ Press ${bold('Enter')} to accept defaults. ${bold('Ctrl+C')} to cancel at any ti
   const libDir = libDirRaw;
   console.log();
 
-  // Agent namespace
   const namespace = await ask(`  ${bold('Agent namespace:')}`, 'default');
   console.log();
 
-  // Hooks
   console.log(`  ${bold('Enable hooks:')}`);
   const injectAwareness = await askYN(
     'Inject memory awareness into prompts? (before_prompt_build)',
@@ -448,7 +878,6 @@ Press ${bold('Enter')} to accept defaults. ${bold('Ctrl+C')} to cancel at any ti
   );
   console.log();
 
-  // Tools
   console.log(`  ${bold('Enable tools:')}`);
   const toolMemoryRecall    = await askYN('memory_recall    — search memories',               true);
   const toolMemoryStore     = await askYN('memory_store     — save memories',                 true);
@@ -459,7 +888,6 @@ Press ${bold('Enter')} to accept defaults. ${bold('Ctrl+C')} to cancel at any ti
   const toolEvalTriggers    = await askYN('evaluate_triggers — reactive trigger engine',      false);
   console.log();
 
-  // Cloud sync extras
   let serverUrl = '';
   let apiKey    = '';
   if (cloudSync) {
@@ -469,7 +897,7 @@ Press ${bold('Enter')} to accept defaults. ${bold('Ctrl+C')} to cancel at any ti
     console.log();
   }
 
-  // ── Step 3: Build and write config ───────────────────────────────────────
+  // ── Step 3: Build and write config ──────────────────────────────────────
 
   console.log(`${bold('Step 3 · Write openclaw.json')}`);
 
@@ -493,12 +921,10 @@ Press ${bold('Enter')} to accept defaults. ${bold('Ctrl+C')} to cancel at any ti
     },
   };
 
-  // Remove undefined keys
   Object.keys(sulcusConfig).forEach(
     (k) => sulcusConfig[k] === undefined && delete sulcusConfig[k],
   );
 
-  // Deep-merge into existing config
   const merged = deepMerge(existingConfig, {
     plugins: {
       entries: {
@@ -524,7 +950,6 @@ Press ${bold('Enter')} to accept defaults. ${bold('Ctrl+C')} to cancel at any ti
     console.log(`  ${green('✓')} Written to ${cyan(configPath)}`);
     console.log();
 
-    // Summary
     console.log(`  ${dim('──── Summary ────────────────────────────────────')}`);
     console.log(`  Plugin:    ${cyan('openclaw-sulcus')}  ${green('enabled')}`);
     console.log(`  Backend:   ${cyan(cloudSync ? 'cloud sync' : 'local only')}`);
@@ -551,7 +976,7 @@ Press ${bold('Enter')} to accept defaults. ${bold('Ctrl+C')} to cancel at any ti
     console.log();
   }
 
-  // ── Step 4: Validate dylib path (+ auto-download if missing) ─────────────
+  // ── Step 4: Validate dylib path (+ auto-download if missing) ────────────
 
   console.log(`${bold('Step 4 · Validate')}`);
 
@@ -561,9 +986,6 @@ Press ${bold('Enter')} to accept defaults. ${bold('Ctrl+C')} to cancel at any ti
             : process.platform === 'win32'  ? '.dll'
             :                                 '.so';
 
-  /**
-   * Check which dylibs are present. Returns true when all are found.
-   */
   function checkDylibs() {
     if (!fs.existsSync(resolvedLibDir)) return false;
     return dylibNames.every((lib) => fs.existsSync(path.join(resolvedLibDir, lib + ext)));
@@ -572,24 +994,19 @@ Press ${bold('Enter')} to accept defaults. ${bold('Ctrl+C')} to cancel at any ti
   let dylibsOk = checkDylibs();
 
   if (dylibsOk) {
-    // All present — just print them
     for (const lib of dylibNames) {
       console.log(`  ${green('✓')} Found: ${dim(path.join(resolvedLibDir, lib + ext))}`);
     }
   } else {
-    // Some or all missing — try auto-download
     const downloaded = await downloadAndInstallBinaries(resolvedLibDir, dylibNames);
 
     if (downloaded) {
-      // Re-validate after successful download
       dylibsOk = checkDylibs();
       if (!dylibsOk) {
         console.log(`  ${yellow('⚠')}  Some dylibs still missing after installation.`);
       }
     } else if (!downloaded) {
-      // Download skipped or failed — show manual instructions
       if (fs.existsSync(resolvedLibDir)) {
-        // Directory exists but files missing — list what we found / didn't find
         for (const lib of dylibNames) {
           const full = path.join(resolvedLibDir, lib + ext);
           if (fs.existsSync(full)) {
@@ -619,6 +1036,19 @@ Press ${bold('Enter')} to accept defaults. ${bold('Ctrl+C')} to cancel at any ti
   rl.close();
 }
 
+// ─── Entry point ─────────────────────────────────────────────────────────────
+
+async function run() {
+  const mode = detectMode();
+
+  switch (mode) {
+    case MODE_CLAUDE:  return runClaudeWizard();
+    case MODE_OPENAI:  return runOpenAIWizard();
+    case MODE_GEMINI:  return runGeminiWizard();
+    default:           return runOpenclawWizard();
+  }
+}
+
 run().catch((err) => {
   console.error(`\n${red('Fatal error:')} ${err.message}\n`);
   rl.close();

package/hooks.defaults.json

@@ -18,12 +18,16 @@
     }
   },
   "tools": {
-    "memory_recall": { "enabled": false },
-    "memory_store": { "enabled": false },
-    "memory_status": { "enabled": false },
+    "memory_recall": { "enabled": true },
+    "memory_store": { "enabled": true },
+    "memory_status": { "enabled": true },
     "consolidate": { "enabled": false },
     "export_markdown": { "enabled": false },
     "import_markdown": { "enabled": false },
-    "evaluate_triggers": { "enabled": false }
+    "evaluate_triggers": { "enabled": false },
+    "siu_label": { "enabled": false },
+    "siu_status": { "enabled": false },
+    "siu_retrain": { "enabled": false },
+    "trigger_feedback": { "enabled": false }
   }
 }

package/index.ts

@@ -98,12 +98,14 @@ const hookHandlers: Record<string, HookHandler> = {
   auto_recall: async (event: any, config: HookConfig, ctx: HookHandlerCtx) => {
     const { sulcusMem, namespace, logger } = ctx;
     if (!sulcusMem) return;
-    logger.info(`sulcus: before_agent_start hook triggered for agent ${event.agentId}`);
-    if (!event.prompt) return;
+    const agentLabel = event?.agentId ?? "(unknown)";
+    logger.info(`sulcus: before_agent_start hook triggered for agent ${agentLabel}`);
+    const prompt = typeof event?.prompt === "string" ? event.prompt : "";
+    if (!prompt) return;
     try {
       const limit = config.limit ?? 5;
-      logger.debug(`sulcus: searching context for prompt: ${event.prompt.substring(0, 50)}...`);
-      const res = await sulcusMem.search_memory(event.prompt, limit);
+      logger.debug(`sulcus: searching context for prompt: ${prompt.substring(0, 50)}...`);
+      const res = await sulcusMem.search_memory(prompt, limit);
       const results = res?.results ?? [];
       if (!results || results.length === 0) {
         return { prependSystemContext: FALLBACK_AWARENESS };
@@ -129,6 +131,74 @@ const hookHandlers: Record<string, HookHandler> = {
   none: async (event: any, _config: HookConfig, ctx: HookHandlerCtx) => {
     ctx.logger.debug(`sulcus: hook fired (action=none) for agent ${event.agentId ?? "(unknown)"} (no-op)`);
   },
+
+  /**
+   * sivu_auto_capture — SIU v2 quality-gated auto-capture on agent_end.
+   *
+   * When fired after each turn, extracts the user message from the event,
+   * runs it through SIVU (store/reject gate) and SICU (type classifier),
+   * and stores the memory only if SIVU approves. Falls back to basic
+   * junk-filtering + episodic capture if SIU v2 endpoint is unavailable.
+   *
+   * Config options:
+   *   min_store_confidence: number (default 0.5) — minimum SIVU confidence to store
+   *   fallback_on_error: boolean (default true) — store as episodic if SIU unavailable
+   */
+  sivu_auto_capture: async (event: any, config: HookConfig, ctx: HookHandlerCtx) => {
+    const { sulcusMem, logger } = ctx;
+    if (!sulcusMem) return;
+
+    // Extract user message from the event
+    const userMessage = event?.userMessage ?? event?.prompt ?? event?.text ?? "";
+    if (!userMessage || typeof userMessage !== "string") {
+      logger.debug("sulcus: sivu_auto_capture — no user message in event, skipping");
+      return;
+    }
+
+    // Pre-filter obvious junk before hitting the API
+    if (isJunkMemory(userMessage)) {
+      logger.debug(`sulcus: sivu_auto_capture — pre-filtered junk: "${userMessage.substring(0, 50)}..."`);
+      return;
+    }
+
+    const minConfidence = config.min_store_confidence ?? 0.5;
+    const fallbackOnError = config.fallback_on_error !== false; // default true
+
+    // Try SIU v2 endpoint for quality-gated classification
+    if (sulcusMem instanceof SulcusCloudClient) {
+      try {
+        const siuResult = await (sulcusMem as SulcusCloudClient).request("POST", "/api/v2/siu/label", {
+          text: userMessage,
+        });
+
+        const shouldStore = siuResult?.store === true && (siuResult?.store_confidence ?? 0) >= minConfidence;
+        const memoryType = siuResult?.memory_type ?? "episodic";
+        const modelVersion = siuResult?.model_version ?? "unknown";
+
+        if (!shouldStore) {
+          logger.info(`sulcus: sivu_auto_capture — SIVU rejected (confidence: ${siuResult?.store_confidence?.toFixed(3) ?? "?"}, model: ${modelVersion}): "${userMessage.substring(0, 60)}..."`);
+          return;
+        }
+
+        // SIVU approved — store with SICU-predicted type
+        const res = await sulcusMem.add_memory(userMessage, memoryType);
+        logger.info(`sulcus: sivu_auto_capture — stored [${memoryType}] (id: ${res?.id ?? "?"}, sivu_conf: ${siuResult?.store_confidence?.toFixed(3)}, sicu_conf: ${siuResult?.type_confidence?.toFixed(3)}, model: ${modelVersion}): "${userMessage.substring(0, 60)}..."`);
+        return;
+      } catch (e: any) {
+        logger.warn(`sulcus: sivu_auto_capture — SIU v2 endpoint error: ${e.message}`);
+        if (!fallbackOnError) return;
+        // Fall through to basic capture
+      }
+    }
+
+    // Fallback: store as episodic (no SIU gating available)
+    try {
+      const res = await sulcusMem.add_memory(userMessage, "episodic");
+      logger.info(`sulcus: sivu_auto_capture — fallback stored [episodic] (id: ${res?.id ?? "?"}): "${userMessage.substring(0, 60)}..."`);
+    } catch (e: any) {
+      logger.warn(`sulcus: sivu_auto_capture — fallback store failed: ${e.message}`);
+    }
+  },
 };
 
 // ─── CLOUD HTTP CLIENT ───────────────────────────────────────────────────────
@@ -147,7 +217,7 @@ class SulcusCloudClient {
   }
 
   /** Low-level HTTP helper. Returns parsed JSON response body. */
-  private request(method: string, path: string, body?: any): Promise<any> {
+  request(method: string, path: string, body?: any): Promise<any> {
     return new Promise((resolve, reject) => {
       let parsedUrl: URL;
       try {
@@ -519,6 +589,8 @@ interface ToolDeps {
   wasmDir: string;
   logger: any;
   isAvailable: boolean;
+  /** HTTP request helper for SIU v2 endpoints — null when cloud backend is not configured. */
+  siuRequest: ((method: string, path: string, body?: any) => Promise<any>) | null;
 }
 
 const toolDefinitions: Record<string, ToolDefinition> = {
@@ -729,6 +801,155 @@ const toolDefinitions: Record<string, ToolDefinition> = {
         };
       },
   },
+
+  // ── SIU v2 Tools ───────────────────────────────────────────────────────────
+  // These tools call the SIU v2 server endpoints for text classification.
+  // Requires cloud backend (serverUrl + apiKey). Uses /api/v2/siu/* endpoints.
+
+  siu_label: {
+    schema: {
+      name: "siu_label",
+      label: "SIU Label",
+      description: "Classify text using SIU v2 — returns SIVU store/reject decision and SICU memory type classification with confidence scores.",
+      parameters: Type.Object({
+        text: Type.String({ description: "Text to classify." }),
+        classify_only: Type.Optional(Type.Boolean({ description: "Skip SIVU quality gate, only run SICU type classification." })),
+      }),
+    },
+    options: { name: "siu_label" },
+    makeExecute: ({ backendMode, siuRequest, logger }) =>
+      async (_id: string, params: any) => {
+        if (!siuRequest) {
+          return {
+            content: [{ type: "text", text: "SIU label requires cloud backend (serverUrl + apiKey)." }],
+            details: { error: "cloud_required" },
+          };
+        }
+        try {
+          const res = await siuRequest("POST", "/api/v2/siu/label", {
+            text: params.text,
+            classify_only: params.classify_only ?? false,
+          });
+          return {
+            content: [{ type: "text", text: JSON.stringify(res, null, 2) }],
+            details: res,
+          };
+        } catch (e: any) {
+          logger.warn(`sulcus: siu_label failed: ${e.message}`);
+          return {
+            content: [{ type: "text", text: `SIU label failed: ${e.message}` }],
+            details: { error: e.message },
+          };
+        }
+      },
+  },
+
+  siu_status: {
+    schema: {
+      name: "siu_status",
+      label: "SIU Status",
+      description: "Check SIU v2 model availability, deployed versions, and training signal statistics.",
+      parameters: Type.Object({}),
+    },
+    options: { name: "siu_status" },
+    makeExecute: ({ siuRequest, logger }) =>
+      async (_id: string, _params: any) => {
+        if (!siuRequest) {
+          return {
+            content: [{ type: "text", text: "SIU status requires cloud backend (serverUrl + apiKey)." }],
+            details: { error: "cloud_required" },
+          };
+        }
+        try {
+          const res = await siuRequest("GET", "/api/v2/siu/status");
+          return {
+            content: [{ type: "text", text: JSON.stringify(res, null, 2) }],
+            details: res,
+          };
+        } catch (e: any) {
+          logger.warn(`sulcus: siu_status failed: ${e.message}`);
+          return {
+            content: [{ type: "text", text: `SIU status failed: ${e.message}` }],
+            details: { error: e.message },
+          };
+        }
+      },
+  },
+
+  siu_retrain: {
+    schema: {
+      name: "siu_retrain",
+      label: "SIU Retrain",
+      description: "Trigger an async retrain of SIU v2 models using accumulated training signals. Returns job status.",
+      parameters: Type.Object({}),
+    },
+    options: { name: "siu_retrain" },
+    makeExecute: ({ siuRequest, logger }) =>
+      async (_id: string, _params: any) => {
+        if (!siuRequest) {
+          return {
+            content: [{ type: "text", text: "SIU retrain requires cloud backend (serverUrl + apiKey)." }],
+            details: { error: "cloud_required" },
+          };
+        }
+        try {
+          const res = await siuRequest("POST", "/api/v2/siu/retrain");
+          return {
+            content: [{ type: "text", text: JSON.stringify(res, null, 2) }],
+            details: res,
+          };
+        } catch (e: any) {
+          logger.warn(`sulcus: siu_retrain failed: ${e.message}`);
+          return {
+            content: [{ type: "text", text: `SIU retrain failed: ${e.message}` }],
+            details: { error: e.message },
+          };
+        }
+      },
+  },
+  trigger_feedback: {
+    schema: {
+      name: "trigger_feedback",
+      label: "Trigger Feedback",
+      description:
+        "Record feedback on a trigger fire (for SITU training). Use to report false positives (fired but shouldn't have), false negatives (should have fired but didn't), or confirm correct fires.",
+      parameters: Type.Object({
+        feedback_type: Type.String({
+          description:
+            'One of: "false_positive" (fired wrongly), "false_negative" (missed fire), "correct" (good fire), "wrong_action" (fired but wrong action)',
+        }),
+        trigger_id: Type.Optional(Type.String({ description: "UUID of the trigger rule" })),
+        trigger_log_id: Type.Optional(Type.String({ description: "UUID of the trigger fire log entry" })),
+        event_type: Type.Optional(Type.String({ description: "Event type: memory_created, heat_threshold, recall, etc." })),
+        memory_id: Type.Optional(Type.String({ description: "UUID of the memory involved" })),
+        expected_action: Type.Optional(Type.String({ description: "What should have happened: fire, no_fire, different_action" })),
+        notes: Type.Optional(Type.String({ description: "Free-text explanation of the feedback" })),
+      }),
+    },
+    options: { name: "trigger_feedback" },
+    makeExecute: ({ siuRequest, logger }) =>
+      async (_id: string, params: any) => {
+        if (!siuRequest) {
+          return {
+            content: [{ type: "text", text: "Trigger feedback requires cloud backend (serverUrl + apiKey)." }],
+            details: { error: "cloud_required" },
+          };
+        }
+        try {
+          const res = await siuRequest("POST", "/api/v1/triggers/feedback", params);
+          return {
+            content: [{ type: "text", text: JSON.stringify(res, null, 2) }],
+            details: res,
+          };
+        } catch (e: any) {
+          logger.warn(`sulcus: trigger_feedback failed: ${e.message}`);
+          return {
+            content: [{ type: "text", text: `Trigger feedback failed: ${e.message}` }],
+            details: { error: e.message },
+          };
+        }
+      },
+  },
 };
 
 // ─── PLUGIN ──────────────────────────────────────────────────────────────────
@@ -832,6 +1053,12 @@ const sulcusPlugin = {
       api.logger.warn(`sulcus: ✗ unavailable — ${hints.join("; ") || "unknown reason"}. Configure serverUrl+apiKey for cloud, or install native dylibs for local.`);
     }
 
+    // ── SIU v2 request helper (bound to cloud client if available) ──
+    // SIU endpoints live on the same server as the Sulcus API.
+    const siuRequestFn = (backendMode === "cloud" && sulcusMem instanceof SulcusCloudClient)
+      ? (method: string, path: string, body?: any) => (sulcusMem as SulcusCloudClient).request(method, path, body)
+      : null;
+
     // ── Shared deps for tool executors ──
     const toolDeps: ToolDeps = {
       sulcusMem,
@@ -843,6 +1070,7 @@ const sulcusPlugin = {
       wasmDir,
       logger: api.logger,
       isAvailable,
+      siuRequest: siuRequestFn,
     };
 
     // ── Shared context for hook handlers ──
@@ -858,11 +1086,21 @@ const sulcusPlugin = {
     };
 
     // ── Config-driven hook registration ──
+    // Each handler is wrapped in a defensive try-catch to prevent plugin errors
+    // from crashing the host agent's startup pipeline (OpenClaw bug workaround:
+    // normalizeResolvedModel() doesn't guard params.model being undefined).
     for (const [hookName, hookConfig] of Object.entries(hooksConfig.hooks)) {
       if (!hookConfig.enabled) continue;
       const handler = hookHandlers[hookConfig.action];
       if (handler) {
-        api.on(hookName, (event: any) => handler(event, hookConfig, handlerCtx));
+        api.on(hookName, async (event: any) => {
+          try {
+            return await handler(event, hookConfig, handlerCtx);
+          } catch (err) {
+            api.logger.warn(`sulcus: hook "${hookName}" (action=${hookConfig.action}) threw: ${err} — returning empty result`);
+            return undefined;
+          }
+        });
       } else {
         api.logger.warn(`sulcus: unknown hook action "${hookConfig.action}" for hook "${hookName}"`);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitalforgestudios/openclaw-sulcus",
-  "version": "3.5.5",
+  "version": "3.8.0",
   "description": "Sulcus — reactive, thermodynamic memory plugin for OpenClaw. Opt-in persistent memory with heat-based decay, semantic search, and cross-agent sync. Auto-recall and auto-capture disabled by default.",
   "keywords": [
     "openclaw",