@lucieri/daxiom 0.2.1 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucieri/daxiom",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "DAXIOM SDK — Pattern database client with quality gates, tier management, and semantic search via RuVector PostgreSQL",
   "main": "src/index.js",
   "bin": {

package/src/cli.js

@@ -398,7 +398,7 @@ if (cmd === 'hooks') {
       }
 
       default:
-        console.log('daxiom — Self-Learning Second Brain SDK v0.2.0');
+        console.log('daxiom — Self-Learning Second Brain SDK v0.2.3');
         console.log('');
         console.log('Knowledge:    search | store | coherence | quality-check | stats');
         console.log('Tiers:        tiers | tier-check | tier-promote');
@@ -407,7 +407,8 @@ if (cmd === 'hooks') {
         console.log('Registry:     namespaces');
         console.log('Rollback:     demote | rollback-check');
         console.log('Decay:        decay | drift | decay-preview');
-        console.log('Hooks:        hooks pre-task | hooks post-task | hooks session-start | hooks pre-compact | hooks summarize');
+        console.log('Hooks:        hooks <subcommand> — 16 Claude Code hook handlers');
+        console.log('              Run "daxiom hooks" for full list');
         console.log('');
         console.log('All self-mgmt commands accept --namespace <ns> to target a specific repo.');
         console.log('todo/changelog with no args list entries. Use --namespace to filter.');

package/src/constants.js

@@ -28,6 +28,7 @@ const KNOWN_CLASSES = [
   'tool', 'guidance', 'interface', 'algorithm', 'integration',
   'ui', 'adapter', 'skill', 'session-context', 'session-summary',
   'wire_integrate', 'general',
+  'file-edit', 'command', 'activity', 'session',
 ];
 
 const KNOWN_NAMESPACES = [
@@ -49,6 +50,8 @@ const KNOWN_NAMESPACES = [
   'forge', 'vibe-cast', 'agentic-qe',
   'plugin-ecosystem', 'plugin-prime-radiant', 'gastown',
   'plugin-code-intelligence', 'plugin-test-intelligence',
+  // Additional project namespaces
+  'openclaw', 'memu', 'voicemode', 'mission-control',
 ];
 
 const SECURITY_PATTERNS = [

package/src/hooks/index.js

@@ -7,11 +7,22 @@ const { loadEnv } = require('./env');
  * Usage: daxiom hooks <subcommand> [args...]
  *
  * Subcommands:
- *   pre-task     - Search DAXIOM for relevant patterns before agent task
- *   post-task    - Store learnings after agent task completion
- *   session-start - Inject SOUL.md + DAXIOM context on session start
- *   pre-compact  - Capture transcript before context compaction
- *   summarize    - Process and embed daily session logs
+ *   pre-task        - Search DAXIOM for relevant patterns before agent task
+ *   post-task       - Store learnings after agent task completion
+ *   pre-edit        - Search DAXIOM for patterns before file edit
+ *   post-edit       - Record file edits for cross-repo learning
+ *   pre-command     - Search DAXIOM for patterns before shell command
+ *   post-command    - Record significant commands for learning
+ *   post-failure    - Learn from tool failures, suggest known fixes
+ *   remember        - Track file access, searches, agent spawns
+ *   session-start   - Inject SOUL.md + DAXIOM context on session start
+ *   session-end     - Store session summary and run tier maintenance
+ *   subagent-start  - Inject DAXIOM patterns into subagent context
+ *   subagent-stop   - Extract learnings from subagent transcript
+ *   suggest-context - Surface relevant patterns on user prompt
+ *   task-completed  - Record task completions for learning
+ *   pre-compact     - Capture transcript before context compaction
+ *   summarize       - Process and embed daily session logs
  */
 async function dispatch(args) {
   // Load env before any hook runs
@@ -29,10 +40,54 @@ async function dispatch(args) {
       const { run } = require('./post-task');
       return run(subArgs);
     }
+    case 'pre-edit': {
+      const { run } = require('./pre-edit');
+      return run(subArgs);
+    }
+    case 'post-edit': {
+      const { run } = require('./post-edit');
+      return run(subArgs);
+    }
+    case 'pre-command': {
+      const { run } = require('./pre-command');
+      return run(subArgs);
+    }
+    case 'post-command': {
+      const { run } = require('./post-command');
+      return run(subArgs);
+    }
+    case 'post-failure': {
+      const { run } = require('./post-failure');
+      return run(subArgs);
+    }
+    case 'remember': {
+      const { run } = require('./remember');
+      return run(subArgs);
+    }
     case 'session-start': {
       const { run } = require('./session-start');
       return run(subArgs);
     }
+    case 'session-end': {
+      const { run } = require('./session-end');
+      return run(subArgs);
+    }
+    case 'subagent-start': {
+      const { run } = require('./subagent-start');
+      return run(subArgs);
+    }
+    case 'subagent-stop': {
+      const { run } = require('./subagent-stop');
+      return run(subArgs);
+    }
+    case 'suggest-context': {
+      const { run } = require('./suggest-context');
+      return run(subArgs);
+    }
+    case 'task-completed': {
+      const { run } = require('./task-completed');
+      return run(subArgs);
+    }
     case 'pre-compact': {
       const { run } = require('./pre-compact');
       return run(subArgs);
@@ -45,11 +100,22 @@ async function dispatch(args) {
       console.log('daxiom hooks — Claude Code hook handlers');
       console.log('');
       console.log('Subcommands:');
-      console.log('  pre-task       Search DAXIOM before agent task');
-      console.log('  post-task      Store learnings after agent task');
-      console.log('  session-start  Inject context on session start');
-      console.log('  pre-compact    Capture transcript before compaction');
-      console.log('  summarize      Process daily session logs');
+      console.log('  pre-task         Search DAXIOM before agent task');
+      console.log('  post-task        Store learnings after agent task');
+      console.log('  pre-edit         Search DAXIOM before file edit');
+      console.log('  post-edit        Record file edits for learning');
+      console.log('  pre-command      Search DAXIOM before shell command');
+      console.log('  post-command     Record significant commands');
+      console.log('  post-failure     Learn from tool failures, suggest fixes');
+      console.log('  remember         Track file access, searches, agent spawns');
+      console.log('  session-start    Inject context on session start');
+      console.log('  session-end      Store session summary, run tier maintenance');
+      console.log('  subagent-start   Inject DAXIOM patterns into subagent');
+      console.log('  subagent-stop    Extract learnings from subagent transcript');
+      console.log('  suggest-context  Surface relevant patterns on user prompt');
+      console.log('  task-completed   Record task completions for learning');
+      console.log('  pre-compact      Capture transcript before compaction');
+      console.log('  summarize        Process daily session logs');
       console.log('');
       console.log('Env: DAXIOM_DATABASE_URL or DATABASE_URL, GEMINI_API_KEY');
       console.log('Auto-loads from ~/.daxiom/.env if env vars not set.');

package/src/hooks/post-command.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const path = require('path');
+const { init, close, storeLearnedPattern } = require('../index');
+
+/**
+ * Post-command hook: record significant commands in DAXIOM for cross-repo learning.
+ * Only stores non-trivial commands (builds, deploys, migrations, installs, etc.)
+ *
+ * @param {string[]} args - [command string]
+ */
+async function run(args) {
+  const command = args.join(' ');
+  if (!command) return;
+
+  // Only record significant commands
+  const significant = /\b(npm|pnpm|yarn|npx|docker|psql|git push|git merge|deploy|migrate|build|test|publish)\b/i;
+  if (!significant.test(command)) return;
+
+  try {
+    await init();
+
+    const repo = path.basename(process.cwd());
+    const cmdSlug = command.replace(/[^a-z0-9\s]/gi, '').trim()
+      .split(/\s+/).slice(0, 5).join('_').substring(0, 60);
+
+    await storeLearnedPattern({
+      patternName: `cmd_${repo}_${cmdSlug}`,
+      description: `Command: ${command.substring(0, 300)}`,
+      compactText: `Ran command in ${repo}: ${command.substring(0, 200)}`,
+      patternClass: 'command',
+      namespace: repo,
+      category: 'activity',
+      tier: 'warm',
+      tags: [repo, 'command'],
+      metadata: {
+        command: command.substring(0, 500),
+        repo,
+        cwd: process.cwd(),
+        ranAt: new Date().toISOString(),
+      },
+    });
+  } catch {
+    // Non-fatal
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };

package/src/hooks/post-edit.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const path = require('path');
+const { init, close, storeLearnedPattern } = require('../index');
+
+/**
+ * Post-edit hook: record file edits in DAXIOM for cross-repo learning.
+ *
+ * @param {string[]} args - [filePath, ...flags]
+ */
+async function run(args) {
+  const filePath = args[0];
+  if (!filePath) return;
+
+  try {
+    await init();
+
+    const fileName = path.basename(filePath);
+    const ext = path.extname(filePath).slice(1);
+    const repo = path.basename(process.cwd());
+    const dir = path.dirname(filePath).split('/').slice(-2).join('/');
+
+    await storeLearnedPattern({
+      patternName: `edit_${repo}_${fileName}`.replace(/[^a-z0-9_.-]/gi, '_').substring(0, 80),
+      description: `Edited ${fileName} in ${dir} (${repo})`,
+      compactText: `File edit: ${filePath} in repo ${repo}. Extension: ${ext}.`,
+      patternClass: 'file-edit',
+      namespace: repo,
+      category: 'activity',
+      tier: 'warm',
+      tags: [ext, repo, 'edit'].filter(Boolean),
+      metadata: {
+        filePath,
+        extension: ext,
+        repo,
+        editedAt: new Date().toISOString(),
+      },
+    });
+
+    console.log(JSON.stringify({ recorded: true, file: fileName, repo }));
+  } catch (err) {
+    // Non-fatal — don't block edits
+    console.log(JSON.stringify({ recorded: false, error: err.message }));
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };

package/src/hooks/post-failure.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { init, close, storeLearnedPattern, searchWithSalience } = require('../index');
+
+/**
+ * PostToolUseFailure hook: learn from tool failures.
+ * Records what failed and why, searches for known fixes.
+ *
+ * Reads stdin JSON: { tool_name, tool_input, error, is_interrupt }
+ * Outputs JSON: { additionalContext: "..." } with known fixes if found
+ *
+ * @param {string[]} args - unused (stdin-driven)
+ */
+async function run(args) {
+  let input = {};
+  try {
+    const stdin = fs.readFileSync(0, 'utf8').trim();
+    if (stdin) input = JSON.parse(stdin);
+  } catch { /* No stdin */ }
+
+  const toolName = input.tool_name || args[0] || '';
+  const error = input.error || '';
+  const isInterrupt = input.is_interrupt || false;
+
+  // Skip user interruptions — nothing to learn
+  if (isInterrupt || !toolName || !error) {
+    process.stdout.write('{}');
+    return;
+  }
+
+  try {
+    await init();
+
+    const repo = path.basename(input.cwd || process.cwd());
+    const errorSnippet = error.substring(0, 300);
+
+    // Store the failure for future learning
+    const slug = `${toolName}_${error.replace(/[^a-z0-9]/gi, '_').substring(0, 40)}`.toLowerCase();
+    await storeLearnedPattern({
+      patternName: `failure_${repo}_${slug}`,
+      description: `Tool ${toolName} failed in ${repo}: ${errorSnippet}`,
+      compactText: `${toolName} failure: ${errorSnippet}`,
+      patternClass: 'error-fix',
+      namespace: repo,
+      category: 'failure',
+      tier: 'warm',
+      tags: [repo, 'failure', toolName.toLowerCase()],
+      metadata: {
+        toolName,
+        error: error.substring(0, 1000),
+        toolInput: JSON.stringify(input.tool_input || {}).substring(0, 500),
+        repo,
+        failedAt: new Date().toISOString(),
+      },
+    });
+
+    // Search for known fixes to similar errors
+    const fixes = await searchWithSalience(`fix ${toolName} error: ${errorSnippet}`, {
+      limit: 3,
+      threshold: 0.5,
+      decay: 0.03,
+      candidatePool: 15,
+    });
+
+    const knownFixes = fixes.filter(r =>
+      r.patternClass === 'error-fix' || r.patternClass === 'learned'
+    );
+
+    if (knownFixes.length > 0) {
+      const fixText = knownFixes.map((r, i) =>
+        `${i + 1}. [${r.namespace}] ${r.patternName}: ${r.description.substring(0, 200)}`
+      ).join('\n');
+
+      const fixContext = `DAXIOM found ${knownFixes.length} known fix(es) for this ${toolName} failure:\n${fixText}\nConsider applying these learned solutions.`;
+      process.stdout.write(JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'PostToolUseFailure',
+          additionalContext: fixContext,
+        },
+      }));
+    } else {
+      process.stdout.write('{}');
+    }
+  } catch {
+    process.stdout.write('{}');
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };

package/src/hooks/pre-command.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const { init, close, searchWithSalience } = require('../index');
+
+/**
+ * Pre-command hook: search DAXIOM for patterns related to the command being run.
+ * Surfaces relevant learnings before executing shell commands.
+ *
+ * @param {string[]} args - [command string]
+ */
+async function run(args) {
+  const command = args.join(' ');
+  if (!command) return;
+
+  // Skip trivial commands
+  const trivial = /^(ls|pwd|cd|echo|cat|head|tail|which|true|false)\b/;
+  if (trivial.test(command.trim())) return;
+
+  try {
+    await init();
+
+    const results = await searchWithSalience(command, {
+      limit: 2,
+      threshold: 0.5,
+      decay: 0.03,
+      candidatePool: 10,
+    });
+
+    if (results.length > 0) {
+      const hints = results.map(r => `${r.patternName} (${r.namespace}): ${r.description.substring(0, 100)}`);
+      const additionalContext = `DAXIOM hints for command: ${hints.join('; ')}`;
+      console.log(JSON.stringify({
+        hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext },
+        daxiom_intel: true,
+      }));
+    }
+  } catch {
+    // Non-fatal
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };

package/src/hooks/pre-edit.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const { init, close, searchWithSalience } = require('../index');
+
+/**
+ * Pre-edit hook: search DAXIOM for patterns related to the file being edited.
+ * Provides relevant context before making changes.
+ *
+ * @param {string[]} args - [filePath, ...flags]
+ */
+async function run(args) {
+  const filePath = args[0];
+  if (!filePath) {
+    console.log(JSON.stringify({ daxiom_intel: false, message: 'No file path' }));
+    return;
+  }
+
+  try {
+    await init();
+
+    const fileName = filePath.split('/').pop();
+    const ext = fileName.split('.').pop();
+    const query = `editing ${fileName} ${ext} file patterns conventions`;
+
+    const results = await searchWithSalience(query, {
+      limit: 3,
+      threshold: 0.4,
+      decay: 0.03,
+      candidatePool: 15,
+    });
+
+    if (results.length === 0) {
+      console.log(JSON.stringify({ daxiom_intel: false }));
+      return;
+    }
+
+    const hints = results.map(r => `${r.patternName}: ${r.description.substring(0, 120)}`);
+    const additionalContext = hints.length > 0
+      ? `DAXIOM patterns for ${fileName}: ${hints.join('; ')}`
+      : undefined;
+    const output = { daxiom_intel: true, file: filePath, patterns: results.length };
+    if (additionalContext) {
+      output.hookSpecificOutput = { hookEventName: 'PreToolUse', additionalContext };
+    }
+    console.log(JSON.stringify(output));
+  } catch (err) {
+    console.log(JSON.stringify({ daxiom_intel: false, error: err.message }));
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };

package/src/hooks/pre-task.js

@@ -65,7 +65,23 @@ async function run(args) {
       });
     }
 
+    // Build human-readable context for injection into agent
+    const patternSummary = results.slice(0, 5).map((r, i) =>
+      `${i + 1}. [${r.namespace}/${r.patternClass}] ${r.patternName} (sim=${r.similarity.toFixed(2)}): ${r.description.substring(0, 180)}`
+    ).join('\n');
+
+    const additionalContext = [
+      `DAXIOM Intelligence: ${results.length} patterns found for this task.`,
+      patternSummary,
+      '',
+      'Apply these learned patterns where relevant.',
+    ].join('\n');
+
     const output = {
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        additionalContext,
+      },
       daxiom_intel: true,
       ranking: 'salience',
       patterns_found: results.length,
@@ -80,7 +96,7 @@ async function run(args) {
       task: taskDescription,
     };
 
-    console.log(JSON.stringify(output, null, 2));
+    console.log(JSON.stringify(output));
 
     // Record usage for top 3 patterns
     for (const r of results.slice(0, 3)) {

package/src/hooks/remember.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const path = require('path');
+const { init, close, storeLearnedPattern } = require('../index');
+
+/**
+ * Remember hook: track file access, search patterns, and agent spawns in DAXIOM.
+ * Builds a cross-repo activity graph for learning and context retrieval.
+ *
+ * Usage:
+ *   daxiom hooks remember "Reading: src/foo.ts" -t file_access
+ *   daxiom hooks remember "Search: auth pattern" -t search_pattern
+ *   daxiom hooks remember "Agent: coder" -t agent_spawn
+ *
+ * @param {string[]} args - [description, -t type]
+ */
+async function run(args) {
+  let description = '';
+  let activityType = 'general';
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '-t' && i + 1 < args.length) {
+      activityType = args[++i];
+    } else {
+      description += (description ? ' ' : '') + args[i];
+    }
+  }
+
+  if (!description) return;
+
+  // Throttle: only record 1 in 5 file reads to avoid flooding
+  if (activityType === 'file_access' && Math.random() > 0.2) return;
+
+  try {
+    await init();
+
+    const repo = path.basename(process.cwd());
+    const slug = description.replace(/[^a-z0-9\s]/gi, '').trim()
+      .split(/\s+/).slice(0, 5).join('_').substring(0, 60);
+
+    await storeLearnedPattern({
+      patternName: `mem_${activityType}_${slug}`,
+      description,
+      compactText: `${activityType}: ${description} (${repo})`,
+      patternClass: 'activity',
+      namespace: repo,
+      category: activityType,
+      tier: 'cold',
+      tags: [repo, activityType],
+      metadata: {
+        activityType,
+        repo,
+        trackedAt: new Date().toISOString(),
+      },
+    });
+  } catch {
+    // Non-fatal
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };

package/src/hooks/session-end.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const path = require('path');
+const { init, close, storeLearnedPattern, updateTiers } = require('../index');
+
+/**
+ * Session-end hook: store session summary in DAXIOM and run tier maintenance.
+ * Captures what repo was worked on, when, and triggers tier decay.
+ *
+ * @param {string[]} args - unused
+ */
+async function run(args) {
+  try {
+    await init();
+
+    const repo = path.basename(process.cwd());
+    const now = new Date();
+    const sessionId = `${now.toISOString().slice(0, 10)}-${repo}-${now.getHours()}${now.getMinutes()}`;
+
+    await storeLearnedPattern({
+      patternName: `session_end_${sessionId}`,
+      description: `Session ended in ${repo} at ${now.toISOString()}`,
+      compactText: `Claude session in ${repo} ended. Date: ${now.toISOString().slice(0, 10)}.`,
+      patternClass: 'session',
+      namespace: 'session-memory',
+      category: 'session',
+      tier: 'warm',
+      tags: [repo, 'session-end'],
+      metadata: {
+        repo,
+        endedAt: now.toISOString(),
+        cwd: process.cwd(),
+      },
+    });
+
+    // Run tier maintenance on every session end
+    const tierResult = await updateTiers();
+    if (tierResult.promoted + tierResult.demotedToWarm + tierResult.demotedToCold > 0) {
+      console.error(`[DAXIOM] Tier maintenance: ${JSON.stringify(tierResult)}`);
+    }
+
+    console.log(JSON.stringify({ session_ended: true, repo, tiers: tierResult }));
+  } catch (err) {
+    console.error('DAXIOM session-end error:', err.message);
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };

package/src/hooks/session-start.js

@@ -102,7 +102,12 @@ async function run(args) {
   }
 
   const context = parts.join('\n\n---\n\n');
-  process.stdout.write(JSON.stringify({ additionalContext: context }));
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'SessionStart',
+      additionalContext: context,
+    },
+  }));
 }
 
 module.exports = { run };

package/src/hooks/subagent-start.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { init, close, searchWithSalience } = require('../index');
+
+/**
+ * SubagentStart hook: inject DAXIOM patterns directly into subagent context.
+ * Uses additionalContext field so patterns appear in the subagent's system prompt.
+ *
+ * Reads stdin JSON: { agent_id, agent_type, session_id, cwd }
+ * Outputs JSON: { additionalContext: "..." }
+ *
+ * @param {string[]} args - unused (stdin-driven)
+ */
+async function run(args) {
+  let input = {};
+  try {
+    const stdin = fs.readFileSync(0, 'utf8').trim();
+    if (stdin) input = JSON.parse(stdin);
+  } catch { /* No stdin */ }
+
+  const agentType = input.agent_type || args[0] || '';
+  if (!agentType) {
+    process.stdout.write('{}');
+    return;
+  }
+
+  try {
+    await init();
+
+    const repo = path.basename(input.cwd || process.cwd());
+    const query = `${agentType} agent patterns conventions ${repo}`;
+
+    const results = await searchWithSalience(query, {
+      limit: 5,
+      threshold: 0.4,
+      decay: 0.03,
+      candidatePool: 20,
+    });
+
+    if (results.length === 0) {
+      process.stdout.write('{}');
+      return;
+    }
+
+    // Build context string for the subagent
+    const patterns = results.map((r, i) =>
+      `${i + 1}. [${r.namespace}/${r.patternClass}] ${r.patternName}: ${r.description.substring(0, 200)}`
+    ).join('\n');
+
+    const context = [
+      `DAXIOM Intelligence (${results.length} patterns for ${agentType} agent in ${repo}):`,
+      patterns,
+      '',
+      'Use these learned patterns to inform your work. They represent cross-repo knowledge.',
+    ].join('\n');
+
+    process.stdout.write(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'SubagentStart',
+        additionalContext: context,
+      },
+    }));
+  } catch {
+    process.stdout.write('{}');
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };

package/src/hooks/subagent-stop.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { init, close, storeLearnedPattern } = require('../index');
+
+/**
+ * SubagentStop hook: extract learnings from subagent transcript.
+ * Reads the agent transcript and stores key findings in DAXIOM.
+ *
+ * Reads stdin JSON: { agent_id, agent_type, agent_transcript_path, session_id, cwd }
+ * Outputs JSON: {} (async, non-blocking)
+ *
+ * @param {string[]} args - unused (stdin-driven)
+ */
+async function run(args) {
+  let input = {};
+  try {
+    const stdin = fs.readFileSync(0, 'utf8').trim();
+    if (stdin) input = JSON.parse(stdin);
+  } catch { /* No stdin */ }
+
+  const agentType = input.agent_type || '';
+  const transcriptPath = input.agent_transcript_path || '';
+
+  if (!agentType) return;
+
+  try {
+    await init();
+
+    const repo = path.basename(input.cwd || process.cwd());
+    let transcriptSummary = '';
+
+    // Read last portion of transcript if available
+    if (transcriptPath && fs.existsSync(transcriptPath)) {
+      try {
+        const content = fs.readFileSync(transcriptPath, 'utf8');
+        const lines = content.split('\n').filter(Boolean);
+
+        // Extract assistant messages from last 10 JSONL entries
+        const recentEntries = lines.slice(-10);
+        const discoveries = [];
+
+        for (const line of recentEntries) {
+          try {
+            const entry = JSON.parse(line);
+            if (entry.role === 'assistant' && typeof entry.content === 'string') {
+              // Look for findings, conclusions, or results
+              const text = entry.content.substring(0, 300);
+              if (text.length > 30) discoveries.push(text);
+            }
+          } catch { /* skip malformed lines */ }
+        }
+
+        if (discoveries.length > 0) {
+          transcriptSummary = discoveries.slice(0, 3).join(' | ');
+        }
+      } catch { /* transcript read failed, non-fatal */ }
+    }
+
+    const description = transcriptSummary
+      ? `${agentType} agent completed in ${repo}. Key findings: ${transcriptSummary.substring(0, 500)}`
+      : `${agentType} agent completed work in ${repo}`;
+
+    await storeLearnedPattern({
+      patternName: `agent_${repo}_${agentType}_${Date.now()}`,
+      description,
+      compactText: `${agentType} agent finished in ${repo}`,
+      patternClass: 'activity',
+      namespace: repo,
+      category: 'agent-completion',
+      tier: 'warm',
+      tags: [repo, 'agent-completion', agentType],
+      metadata: {
+        agentType,
+        agentId: input.agent_id,
+        repo,
+        hadTranscript: !!transcriptSummary,
+        completedAt: new Date().toISOString(),
+      },
+    });
+  } catch {
+    // Non-fatal
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };

package/src/hooks/suggest-context.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const path = require('path');
+const { init, close, searchWithSalience } = require('../index');
+
+/**
+ * Suggest-context hook: on each user prompt, surface relevant DAXIOM patterns.
+ * Reads CLAUDE_USER_PROMPT env var or args to find matching patterns.
+ *
+ * @param {string[]} args - [prompt text] or reads $CLAUDE_USER_PROMPT
+ */
+async function run(args) {
+  const prompt = args.join(' ') || process.env.CLAUDE_USER_PROMPT || '';
+  if (!prompt || prompt.length < 5) return;
+
+  try {
+    await init();
+
+    const repo = path.basename(process.cwd());
+
+    const results = await searchWithSalience(prompt, {
+      limit: 3,
+      threshold: 0.45,
+      decay: 0.03,
+      candidatePool: 15,
+    });
+
+    if (results.length === 0) return;
+
+    const learned = results.filter(r => r.patternClass === 'learned' || r.namespace === repo);
+    const display = (learned.length > 0 ? learned : results).slice(0, 2);
+
+    const hints = display.map(r =>
+      `${r.patternName} (${r.namespace}, ${r.patternClass}): ${r.description.substring(0, 150)}`
+    );
+
+    const additionalContext = `DAXIOM Intelligence: ${hints.join('; ')}`;
+    console.log(JSON.stringify({
+      hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext },
+    }));
+  } catch {
+    // Non-fatal
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };

package/src/hooks/task-completed.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { init, close, storeLearnedPattern } = require('../index');
+
+/**
+ * TaskCompleted hook: record task completions for learning.
+ * Captures what was accomplished for cross-session intelligence.
+ *
+ * Reads stdin JSON: { task_id, task_subject, task_description }
+ * Exit code 2 would block completion (not used currently).
+ *
+ * @param {string[]} args - unused (stdin-driven)
+ */
+async function run(args) {
+  let input = {};
+  try {
+    const stdin = fs.readFileSync(0, 'utf8').trim();
+    if (stdin) input = JSON.parse(stdin);
+  } catch { /* No stdin */ }
+
+  const taskSubject = input.task_subject || args[0] || '';
+  if (!taskSubject) return;
+
+  try {
+    await init();
+
+    const repo = path.basename(input.cwd || process.cwd());
+    const slug = taskSubject.replace(/[^a-z0-9\s]/gi, '').trim()
+      .split(/\s+/).slice(0, 6).join('_').substring(0, 60).toLowerCase();
+
+    await storeLearnedPattern({
+      patternName: `completed_${repo}_${slug}`,
+      description: `Completed: ${taskSubject}${input.task_description ? ' — ' + input.task_description.substring(0, 200) : ''}`,
+      compactText: `Task completed in ${repo}: ${taskSubject}`,
+      patternClass: 'activity',
+      namespace: repo,
+      category: 'task-completed',
+      tier: 'warm',
+      tags: [repo, 'completed'],
+      metadata: {
+        taskId: input.task_id,
+        taskSubject,
+        taskDescription: (input.task_description || '').substring(0, 500),
+        repo,
+        completedAt: new Date().toISOString(),
+      },
+    });
+  } catch {
+    // Non-fatal
+  } finally {
+    await close();
+  }
+}
+
+module.exports = { run };