memorix 1.6.0 → 1.6.1

package/src/cli/commands/formation.ts

@@ -1,48 +1,48 @@
-import { defineCommand } from 'citty';
-import { getBeforeAfterMetrics, getMetricsSummary } from '../../memory/formation/index.js';
-import { emitError, emitResult } from './operator-shared.js';
-
-export default defineCommand({
-  meta: {
-    name: 'formation',
-    description: 'Inspect Memory Formation Pipeline runtime metrics',
-  },
-  args: {
-    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
-  },
-  run: async ({ args }) => {
-    const action = (args._ as string[])?.[0] || '';
-    const asJson = !!args.json;
-
-    try {
-      switch (action) {
-        case 'metrics': {
-          const summary = getMetricsSummary();
-          const beforeAfter = getBeforeAfterMetrics();
-          emitResult(
-            { summary, beforeAfter },
-            summary.total === 0
-              ? 'Formation Pipeline: No metrics collected yet.'
-              : [
-                  'Formation Pipeline Metrics',
-                  `- Total observations processed: ${summary.total}`,
-                  `- Average value score: ${summary.avgValueScore.toFixed(3)}`,
-                  `- Average processing time: ${summary.avgDurationMs.toFixed(1)}ms`,
-                ].join('\n'),
-            asJson,
-          );
-          return;
-        }
-
-        default:
-          console.log('Memorix Formation Commands');
-          console.log('');
-          console.log('Usage:');
-          console.log('  memorix formation metrics');
-      }
-    } catch (error) {
-      emitError(error instanceof Error ? error.message : String(error), asJson);
-    }
-  },
-});
-
+import { defineCommand } from 'citty';
+import { getBeforeAfterMetrics, getMetricsSummary } from '../../memory/formation/index.js';
+import { emitError, emitResult } from './operator-shared.js';
+
+export default defineCommand({
+  meta: {
+    name: 'formation',
+    description: 'Inspect Memory Formation Pipeline runtime metrics',
+  },
+  args: {
+    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
+  },
+  run: async ({ args }) => {
+    const action = (args._ as string[])?.[0] || '';
+    const asJson = !!args.json;
+
+    try {
+      switch (action) {
+        case 'metrics': {
+          const summary = getMetricsSummary();
+          const beforeAfter = getBeforeAfterMetrics();
+          emitResult(
+            { summary, beforeAfter },
+            summary.total === 0
+              ? 'Formation Pipeline: No metrics collected yet.'
+              : [
+                  'Formation Pipeline Metrics',
+                  `- Total observations processed: ${summary.total}`,
+                  `- Average value score: ${summary.avgValueScore.toFixed(3)}`,
+                  `- Average processing time: ${summary.avgDurationMs.toFixed(1)}ms`,
+                ].join('\n'),
+            asJson,
+          );
+          return;
+        }
+
+        default:
+          console.log('Memorix Formation Commands');
+          console.log('');
+          console.log('Usage:');
+          console.log('  memorix formation metrics');
+      }
+    } catch (error) {
+      emitError(error instanceof Error ? error.message : String(error), asJson);
+    }
+  },
+});
+

package/src/cli/commands/git-hook-install.ts

@@ -1,111 +1,111 @@
-/**
- * CLI Command: memorix git-hook install
- *
- * Installs a git post-commit hook that automatically ingests commits as memories.
- * This is the Git→Memory automation — every commit becomes a searchable memory.
- *
- * Cross-platform: generates both bash (Unix) and PowerShell (Windows) hooks.
- */
-
-import { defineCommand } from 'citty';
-import * as p from '@clack/prompts';
-import { existsSync, readFileSync, writeFileSync, chmodSync } from 'node:fs';
-import { ensureHooksDir } from '../../git/hooks-path.js';
-
-const HOOK_MARKER = '# [memorix-git-hook]';
-
-export default defineCommand({
-  meta: {
-    name: 'git-hook-install',
-    description: 'Install git post-commit hook for automatic memory capture',
-  },
-  args: {
-    cwd: {
-      type: 'string',
-      description: 'Project directory (default: current directory)',
-      required: false,
-    },
-    force: {
-      type: 'boolean',
-      description: 'Overwrite existing hook without asking',
-      required: false,
-    },
-  },
-  run: async ({ args }) => {
-    const projectDir = args.cwd || process.cwd();
-
-    p.intro('Install Git post-commit hook');
-
-    // 1. Resolve git hooks directory (handles normal repos and worktrees)
-    const resolved = ensureHooksDir(projectDir);
-    if (!resolved) {
-      p.log.error(`No .git found in ${projectDir} (checked both directory and worktree file)`);
-      p.outro('Run this command from a git repository root.');
-      return;
-    }
-
-    const { hookPath } = resolved;
-
-    // 3. Check for existing hook
-    if (existsSync(hookPath)) {
-      const existing = readFileSync(hookPath, 'utf-8');
-
-      if (existing.includes(HOOK_MARKER)) {
-        p.log.warn('Memorix git hook is already installed.');
-        p.outro('Use `memorix git-hook uninstall` to remove it first.');
-        return;
-      }
-
-      // Existing non-memorix hook — ask to append
-      if (!args.force) {
-        const action = await p.select({
-          message: 'A post-commit hook already exists. What would you like to do?',
-          options: [
-            { value: 'append', label: 'Append', hint: 'Add memorix hook after existing content' },
-            { value: 'skip', label: 'Skip', hint: 'Do not modify the existing hook' },
-          ],
-        });
-
-        if (p.isCancel(action) || action === 'skip') {
-          p.outro('Installation cancelled.');
-          return;
-        }
-      }
-
-      // Append to existing hook
-      const appended = existing.trimEnd() + '\n\n' + generateHookScript();
-      writeFileSync(hookPath, appended, 'utf-8');
-      try { chmodSync(hookPath, 0o755); } catch { /* Windows doesn't need chmod */ }
-
-      p.log.success('Memorix hook appended to existing post-commit hook.');
-    } else {
-      // Create new hook
-      const script = '#!/bin/sh\n' + generateHookScript();
-      writeFileSync(hookPath, script, 'utf-8');
-      try { chmodSync(hookPath, 0o755); } catch { /* Windows doesn't need chmod */ }
-
-      p.log.success('Git post-commit hook installed.');
-    }
-
-    p.log.info(`Hook path: ${hookPath}`);
-    p.log.info('Every commit will now be automatically captured as a memory.');
-    p.log.info('Memories are tagged with source="git" and include the commit hash.');
-    p.outro('Done! Try making a commit to see it in action.');
-  },
-});
-
-/**
- * Generate the hook script content.
- * Uses `memorix ingest commit --auto` for non-interactive ingest.
- * Runs in background to not block the commit.
- */
-function generateHookScript(): string {
-  return `${HOOK_MARKER}
-# Memorix: Auto-ingest git commits as memories
-# Runs in background — does not block your commit workflow.
-# To remove: memorix git-hook uninstall
-if command -v memorix >/dev/null 2>&1; then
-  memorix ingest commit --auto >/dev/null 2>&1 &
-fi
-`;
-}
+/**
+ * CLI Command: memorix git-hook install
+ *
+ * Installs a git post-commit hook that automatically ingests commits as memories.
+ * This is the Git→Memory automation — every commit becomes a searchable memory.
+ *
+ * Cross-platform: generates both bash (Unix) and PowerShell (Windows) hooks.
+ */
+
+import { defineCommand } from 'citty';
+import * as p from '@clack/prompts';
+import { existsSync, readFileSync, writeFileSync, chmodSync } from 'node:fs';
+import { ensureHooksDir } from '../../git/hooks-path.js';
+
+const HOOK_MARKER = '# [memorix-git-hook]';
+
+export default defineCommand({
+  meta: {
+    name: 'git-hook-install',
+    description: 'Install git post-commit hook for automatic memory capture',
+  },
+  args: {
+    cwd: {
+      type: 'string',
+      description: 'Project directory (default: current directory)',
+      required: false,
+    },
+    force: {
+      type: 'boolean',
+      description: 'Overwrite existing hook without asking',
+      required: false,
+    },
+  },
+  run: async ({ args }) => {
+    const projectDir = args.cwd || process.cwd();
+
+    p.intro('Install Git post-commit hook');
+
+    // 1. Resolve git hooks directory (handles normal repos and worktrees)
+    const resolved = ensureHooksDir(projectDir);
+    if (!resolved) {
+      p.log.error(`No .git found in ${projectDir} (checked both directory and worktree file)`);
+      p.outro('Run this command from a git repository root.');
+      return;
+    }
+
+    const { hookPath } = resolved;
+
+    // 3. Check for existing hook
+    if (existsSync(hookPath)) {
+      const existing = readFileSync(hookPath, 'utf-8');
+
+      if (existing.includes(HOOK_MARKER)) {
+        p.log.warn('Memorix git hook is already installed.');
+        p.outro('Use `memorix git-hook uninstall` to remove it first.');
+        return;
+      }
+
+      // Existing non-memorix hook — ask to append
+      if (!args.force) {
+        const action = await p.select({
+          message: 'A post-commit hook already exists. What would you like to do?',
+          options: [
+            { value: 'append', label: 'Append', hint: 'Add memorix hook after existing content' },
+            { value: 'skip', label: 'Skip', hint: 'Do not modify the existing hook' },
+          ],
+        });
+
+        if (p.isCancel(action) || action === 'skip') {
+          p.outro('Installation cancelled.');
+          return;
+        }
+      }
+
+      // Append to existing hook
+      const appended = existing.trimEnd() + '\n\n' + generateHookScript();
+      writeFileSync(hookPath, appended, 'utf-8');
+      try { chmodSync(hookPath, 0o755); } catch { /* Windows doesn't need chmod */ }
+
+      p.log.success('Memorix hook appended to existing post-commit hook.');
+    } else {
+      // Create new hook
+      const script = '#!/bin/sh\n' + generateHookScript();
+      writeFileSync(hookPath, script, 'utf-8');
+      try { chmodSync(hookPath, 0o755); } catch { /* Windows doesn't need chmod */ }
+
+      p.log.success('Git post-commit hook installed.');
+    }
+
+    p.log.info(`Hook path: ${hookPath}`);
+    p.log.info('Every commit will now be automatically captured as a memory.');
+    p.log.info('Memories are tagged with source="git" and include the commit hash.');
+    p.outro('Done! Try making a commit to see it in action.');
+  },
+});
+
+/**
+ * Generate the hook script content.
+ * Uses `memorix ingest commit --auto` for non-interactive ingest.
+ * Runs in background to not block the commit.
+ */
+function generateHookScript(): string {
+  return `${HOOK_MARKER}
+# Memorix: Auto-ingest git commits as memories
+# Runs in background — does not block your commit workflow.
+# To remove: memorix git-hook uninstall
+if command -v memorix >/dev/null 2>&1; then
+  memorix ingest commit --auto >/dev/null 2>&1 &
+fi
+`;
+}

package/src/cli/commands/handoff.ts

@@ -1,33 +1,33 @@
-import { defineCommand } from 'citty';
-import { storeObservation } from '../../memory/observations.js';
-import { createHandoffArtifact } from '../../team/handoff.js';
+import { defineCommand } from 'citty';
+import { storeObservation } from '../../memory/observations.js';
+import { createHandoffArtifact } from '../../team/handoff.js';
 import { emitError, emitResult, getCliProjectContext, parseCsvList, resolveCliActorId, shortId } from './operator-shared.js';
-
-export default defineCommand({
-  meta: {
-    name: 'handoff',
-    description: 'Create structured handoff artifacts between agents',
-  },
-  args: {
-    fromAgentId: { type: 'string', description: 'Sender agent ID' },
-    toAgentId: { type: 'string', description: 'Optional recipient agent ID' },
-    taskId: { type: 'string', description: 'Optional related task ID' },
-    summary: { type: 'string', description: 'Human-readable summary of the handoff' },
-    context: { type: 'string', description: 'Detailed machine-readable context for the next agent' },
-    filesModified: { type: 'string', description: 'Comma-separated file list' },
-    concepts: { type: 'string', description: 'Comma-separated discoverability concepts' },
-    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
-  },
-  run: async ({ args }) => {
-    const action = (args._ as string[])?.[0] || '';
-    const asJson = !!args.json;
-
-    try {
+
+export default defineCommand({
+  meta: {
+    name: 'handoff',
+    description: 'Create structured handoff artifacts between agents',
+  },
+  args: {
+    fromAgentId: { type: 'string', description: 'Sender agent ID' },
+    toAgentId: { type: 'string', description: 'Optional recipient agent ID' },
+    taskId: { type: 'string', description: 'Optional related task ID' },
+    summary: { type: 'string', description: 'Human-readable summary of the handoff' },
+    context: { type: 'string', description: 'Detailed machine-readable context for the next agent' },
+    filesModified: { type: 'string', description: 'Comma-separated file list' },
+    concepts: { type: 'string', description: 'Comma-separated discoverability concepts' },
+    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
+  },
+  run: async ({ args }) => {
+    const action = (args._ as string[])?.[0] || '';
+    const asJson = !!args.json;
+
+    try {
       const { project, teamStore, identity } = await getCliProjectContext();
       const fromAgentId = resolveCliActorId(args.fromAgentId, identity, 'fromAgentId');
-
-      switch (action) {
-        case 'send': {
+
+      switch (action) {
+        case 'send': {
           if (!fromAgentId || !args.summary || !args.context) {
             emitError('summary, context, and an active CLI identity or fromAgentId are required for "memorix handoff send"', asJson);
             return;
@@ -50,31 +50,31 @@ export default defineCommand({
               projectId: project.id,
               fromAgentId,
               toAgentId,
-              taskId: args.taskId as string | undefined,
-              summary: args.summary as string,
-              context: args.context as string,
-              filesModified: parseCsvList(args.filesModified as string | undefined),
-              concepts: parseCsvList(args.concepts as string | undefined),
-            },
-            storeObservation,
-            teamStore,
-          );
-          emitResult(
-            { project, handoff: result },
-            `Handoff created: observation #${result.observationId} from ${shortId(result.fromAgentId)}${result.toAgentId ? ` to ${shortId(result.toAgentId)}` : ' (broadcast)'}`,
-            asJson,
-          );
-          return;
-        }
-
-        default:
-          console.log('Memorix Handoff Commands');
-          console.log('');
-          console.log('Usage:');
+              taskId: args.taskId as string | undefined,
+              summary: args.summary as string,
+              context: args.context as string,
+              filesModified: parseCsvList(args.filesModified as string | undefined),
+              concepts: parseCsvList(args.concepts as string | undefined),
+            },
+            storeObservation,
+            teamStore,
+          );
+          emitResult(
+            { project, handoff: result },
+            `Handoff created: observation #${result.observationId} from ${shortId(result.fromAgentId)}${result.toAgentId ? ` to ${shortId(result.toAgentId)}` : ' (broadcast)'}`,
+            asJson,
+          );
+          return;
+        }
+
+        default:
+          console.log('Memorix Handoff Commands');
+          console.log('');
+          console.log('Usage:');
           console.log('  memorix handoff send --summary "..." --context "..." [--fromAgentId <id>] [--toAgentId <id>] [--taskId <id>]');
-      }
-    } catch (error) {
-      emitError(error instanceof Error ? error.message : String(error), asJson);
-    }
-  },
-});
+      }
+    } catch (error) {
+      emitError(error instanceof Error ? error.message : String(error), asJson);
+    }
+  },
+});

package/src/cli/commands/hook.ts

@@ -4,8 +4,16 @@
  * Entry point called by agent hooks via stdin/stdout.
  * Reads agent's JSON from stdin, normalizes, auto-stores, outputs response.
  *
+ * This command is short-lived. A leftover `memorix hook` process is a bug:
+ * hosts invoke it on every event, and hung copies exhaust RAM.
+ *
  * Usage (called by agent hook configs, not by users directly):
  *   memorix hook
+ *
+ * Env:
+ *   MEMORIX_HOOK_TIMEOUT_MS — wall-clock budget (default 20000)
+ *   MEMORIX_HOOK_STDIN_TIMEOUT_MS — stdin idle budget (default 3000)
+ *   MEMORIX_HOOK_HEAP_MB — V8 heap for this command only (default 512)
  */
 
 import { defineCommand } from 'citty';
@@ -29,6 +37,10 @@ export default defineCommand({
   },
   run: async ({ args }) => {
     const { runHook } = await import('../../hooks/handler.js');
-    await runHook(args.agent as string | undefined, args.event as string | undefined);
+    const { resolveHookTimeoutMs, runHookWithDeadline } = await import('../../hooks/lifecycle.js');
+    await runHookWithDeadline({
+      timeoutMs: resolveHookTimeoutMs(),
+      run: () => runHook(args.agent as string | undefined, args.event as string | undefined),
+    });
   },
 });

package/src/cli/commands/hooks-status.ts

@@ -1,71 +1,71 @@
-/**
- * CLI Command: memorix hooks status
- *
- * Show hook installation status for all agents.
+/**
+ * CLI Command: memorix hooks status
+ *
+ * Show hook installation status for all agents.
  * Status marks:
  *   [OK]  - installed and verified (config-based agent, file read directly)
  *   [??]  - installed but unverified (plugin-based agent, runtime load not confirmed)
  *   [!!]  - installed but outdated
  *   [ ]   - not installed
- */
-
-import { defineCommand } from 'citty';
-
-export default defineCommand({
-  meta: {
-    name: 'status',
-    description: 'Show hook installation status for all agents',
-  },
-  run: async () => {
-    const { getHookStatus } = await import('../../hooks/installers/index.js');
-    const { AGENT_SUPPORT_TIER } = await import('../../hooks/types.js');
-    const os = await import('node:os');
-    let cwd: string;
-    try { cwd = process.cwd(); } catch { cwd = os.homedir(); }
-
-    const statuses = await getHookStatus(cwd);
-
-    console.log('\nMemorix Hooks Status');
+ */
+
+import { defineCommand } from 'citty';
+
+export default defineCommand({
+  meta: {
+    name: 'status',
+    description: 'Show hook installation status for all agents',
+  },
+  run: async () => {
+    const { getHookStatus } = await import('../../hooks/installers/index.js');
+    const { AGENT_SUPPORT_TIER } = await import('../../hooks/types.js');
+    const os = await import('node:os');
+    let cwd: string;
+    try { cwd = process.cwd(); } catch { cwd = os.homedir(); }
+
+    const statuses = await getHookStatus(cwd);
+
+    console.log('\nMemorix Hooks Status');
     console.log('-'.repeat(50));
-
-    let hasOutdated = false;
-    let hasUnverified = false;
-    let hasRuntimeIssue = false;
-    for (const { agent, installed, outdated, verified, runtimeReady, configPath } of statuses) {
-      const icon = installed
-        ? (!runtimeReady ? '[!!]' : (outdated ? '[!!]' : (verified ? '[OK]' : '[??]')))
-        : '[ ]';
-      const label = agent.charAt(0).toUpperCase() + agent.slice(1);
-      const tier = AGENT_SUPPORT_TIER[agent];
+
+    let hasOutdated = false;
+    let hasUnverified = false;
+    let hasRuntimeIssue = false;
+    for (const { agent, installed, outdated, verified, runtimeReady, configPath } of statuses) {
+      const icon = installed
+        ? (!runtimeReady ? '[!!]' : (outdated ? '[!!]' : (verified ? '[OK]' : '[??]')))
+        : '[ ]';
+      const label = agent.charAt(0).toUpperCase() + agent.slice(1);
+      const tier = AGENT_SUPPORT_TIER[agent];
       const tierLabel = tier === 'core' ? '[core]' : tier === 'extended' ? '[extended]' : '[community]';
-      const suffix = !runtimeReady && installed
-        ? ' (installed but runtime NOT ready — missing pwsh on Windows)'
-        : outdated
-          ? ' (outdated - re-run `memorix hooks install`)'
-          : (!verified && installed ? ' (plugin file installed, runtime load unverified)' : '');
-      console.log(`${icon} ${tierLabel} ${label.padEnd(12)} ${installed ? configPath + suffix : '(not installed)'}`);
-      if (outdated) hasOutdated = true;
-      if (!verified && installed) hasUnverified = true;
-      if (!runtimeReady && installed) hasRuntimeIssue = true;
-    }
-
+      const suffix = !runtimeReady && installed
+        ? ' (installed but runtime NOT ready — missing pwsh on Windows)'
+        : outdated
+          ? ' (outdated - re-run `memorix hooks install`)'
+          : (!verified && installed ? ' (plugin file installed, runtime load unverified)' : '');
+      console.log(`${icon} ${tierLabel} ${label.padEnd(12)} ${installed ? configPath + suffix : '(not installed)'}`);
+      if (outdated) hasOutdated = true;
+      if (!verified && installed) hasUnverified = true;
+      if (!runtimeReady && installed) hasRuntimeIssue = true;
+    }
+
     console.log('\nSupport tiers: [core] core | [extended] extended | [community] community');
-
-    if (hasOutdated) {
-      console.log('\n[warn] Outdated hooks detected. Run `memorix hooks install` to update.');
-    }
-    if (hasUnverified) {
-      console.log('\n[info] [??] = plugin file installed but runtime load unverified.');
-      console.log('       For OpenCode: verify by running `opencode --log-level DEBUG` and checking');
-      console.log('       for [memorix-plugin] messages in the log output.');
-    }
-    if (hasRuntimeIssue) {
-      console.log('\n[warn] [!!] = installed but runtime will fail.');
-      console.log('       Copilot on Windows requires PowerShell v6+ (pwsh.exe) for hook execution.');
-      console.log('       Install pwsh: https://learn.microsoft.com/powershell/scripting/install/installing-powershell');
-      console.log('       Without pwsh, Copilot hooks will fail at runtime with "spawn pwsh.exe ENOENT".');
-    }
-
-    console.log('\nRun `memorix hooks install` to set up hooks for detected agents.');
-  },
-});
+
+    if (hasOutdated) {
+      console.log('\n[warn] Outdated hooks detected. Run `memorix hooks install` to update.');
+    }
+    if (hasUnverified) {
+      console.log('\n[info] [??] = plugin file installed but runtime load unverified.');
+      console.log('       For OpenCode: verify by running `opencode --log-level DEBUG` and checking');
+      console.log('       for [memorix-plugin] messages in the log output.');
+    }
+    if (hasRuntimeIssue) {
+      console.log('\n[warn] [!!] = installed but runtime will fail.');
+      console.log('       Copilot on Windows requires PowerShell v6+ (pwsh.exe) for hook execution.');
+      console.log('       Install pwsh: https://learn.microsoft.com/powershell/scripting/install/installing-powershell');
+      console.log('       Without pwsh, Copilot hooks will fail at runtime with "spawn pwsh.exe ENOENT".');
+    }
+
+    console.log('\nRun `memorix hooks install` to set up hooks for detected agents.');
+  },
+});