claude-memory-layer 1.0.27 → 1.0.29

package/src/services/session-history-importer.ts

@@ -11,7 +11,8 @@ import * as path from 'path';
 import * as os from 'os';
 import * as readline from 'readline';
 import { randomUUID } from 'crypto';
-import { MemoryService, registerSession } from './memory-service.js';
+import { MemoryService } from './memory-service.js';
+import { registerSession } from '../core/registry/session-registry.js';
 
 export type ProgressEvent =
   | { phase: 'scan'; message: string }
@@ -25,6 +26,8 @@ export interface ImportOptions {
   projectPath?: string;
   sessionId?: string;
   limit?: number;
+  /** Limit how many matching sessions are imported. Useful for freshness jobs that only need the latest active session. */
+  sessionLimit?: number;
   skipExisting?: boolean;
   force?: boolean;
   verbose?: boolean;
@@ -63,14 +66,48 @@ export interface ClaudeMessage {
  * Filter trivial user inputs that aren't worth storing.
  * Mirrors the shouldStorePrompt() logic from user-prompt-submit.ts.
  */
-function isWorthStoringPrompt(content: string): boolean {
+export function isClaudeLocalCommandArtifact(content: string): boolean {
   const trimmed = content.trim();
+  return (
+    /^<local-command-(stdout|stderr)>/.test(trimmed) ||
+    /^<command-(name|message)>/.test(trimmed) ||
+    (trimmed.includes('<command-name>') && trimmed.includes('<local-command-stdout>'))
+  );
+}
+
+export function isWorthStoringPrompt(content: string): boolean {
+  const trimmed = content.trim();
+  if (isClaudeLocalCommandArtifact(trimmed)) return false;
   if (trimmed.startsWith('/')) return false;
   if (trimmed.length < 15) return false;
   if (!/[a-zA-Z가-힣]{2,}/.test(trimmed)) return false;
   return true;
 }
 
+function getFileMtimeMs(filePath: string): number {
+  try {
+    return fs.statSync(filePath).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+function selectRecentSessionFiles(files: string[], sessionLimit?: number): string[] {
+  if (sessionLimit === undefined) return files;
+  return [...files]
+    .sort((a, b) => getFileMtimeMs(b) - getFileMtimeMs(a) || b.localeCompare(a))
+    .slice(0, sessionLimit);
+}
+
+function parseSessionLimit(value?: number): number | undefined {
+  if (value === undefined) return undefined;
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : undefined;
+}
+
+function applySessionLimit(files: string[], options: ImportOptions): string[] {
+  return selectRecentSessionFiles(files, parseSessionLimit(options.sessionLimit));
+}
+
 function classifyEntry(entry: ClaudeMessage): 'user_prompt' | 'tool_result' | 'agent_text' | 'tool_use' | 'thinking' | 'skip' {
   if (entry.type !== 'user' && entry.type !== 'assistant') {
     return 'skip';
@@ -151,7 +188,8 @@ export class SessionHistoryImporter {
       allSessionFiles.push(...files);
     }
     const sessionFiles = [...new Set(allSessionFiles)];
-    result.totalSessions = sessionFiles.length;
+    const selectedSessionFiles = applySessionLimit(sessionFiles, options);
+    result.totalSessions = selectedSessionFiles.length;
     onProgress?.({
       phase: 'scan',
       message: `Found ${sessionFiles.length} sessions in ${projectDirs.length} matched project folder(s)`
@@ -165,11 +203,11 @@ export class SessionHistoryImporter {
       console.log(`Found ${sessionFiles.length} session files across matched folders`);
     }
 
-    // Import each session
-    for (let i = 0; i < sessionFiles.length; i++) {
-      const sessionFile = sessionFiles[i];
+    // Import each selected session
+    for (let i = 0; i < selectedSessionFiles.length; i++) {
+      const sessionFile = selectedSessionFiles[i];
       try {
-        onProgress?.({ phase: 'session-start', sessionIndex: i, totalSessions: sessionFiles.length, filePath: sessionFile });
+        onProgress?.({ phase: 'session-start', sessionIndex: i, totalSessions: selectedSessionFiles.length, filePath: sessionFile });
         const sessionResult = await this.importSessionFile(sessionFile, {
           ...options,
           _sessionIndex: i,
@@ -270,7 +308,7 @@ export class SessionHistoryImporter {
         { importedFrom: filePath, originalTimestamp: lastTimestamp, turnId: currentTurnId }
       );
 
-      if (appendResult.isDuplicate) {
+      if (appendResult.success && appendResult.isDuplicate) {
         result.skippedDuplicates++;
       } else {
         result.importedResponses++;
@@ -310,7 +348,7 @@ export class SessionHistoryImporter {
             { importedFrom: filePath, originalTimestamp: entry.timestamp, turnId: currentTurnId }
           );
 
-          if (appendResult.isDuplicate) {
+          if (appendResult.success && appendResult.isDuplicate) {
             result.skippedDuplicates++;
           } else {
             result.importedPrompts++;
@@ -401,16 +439,22 @@ export class SessionHistoryImporter {
       console.log(`Found ${projectDirs.length} project directories, ${allSessionFiles.length} sessions`);
     }
 
-    // Import all session files with progress tracking
-    for (let i = 0; i < allSessionFiles.length; i++) {
-      const sessionFile = allSessionFiles[i];
+    const selectedSessionFiles = applySessionLimit(allSessionFiles, options);
+    result.totalSessions = selectedSessionFiles.length;
+    onProgress?.({
+      phase: 'scan',
+      message: `Selected ${selectedSessionFiles.length} of ${allSessionFiles.length} session(s) for import`
+    });
+
+    // Import selected session files with progress tracking
+    for (let i = 0; i < selectedSessionFiles.length; i++) {
+      const sessionFile = selectedSessionFiles[i];
       try {
-        onProgress?.({ phase: 'session-start', sessionIndex: i, totalSessions: allSessionFiles.length, filePath: sessionFile });
+        onProgress?.({ phase: 'session-start', sessionIndex: i, totalSessions: selectedSessionFiles.length, filePath: sessionFile });
         const sessionResult = await this.importSessionFile(sessionFile, {
           ...options,
           _sessionIndex: i,
         } as ImportOptions & { _sessionIndex: number });
-        result.totalSessions++;
         result.totalMessages += sessionResult.totalMessages;
         result.importedPrompts += sessionResult.importedPrompts;
         result.importedResponses += sessionResult.importedResponses;

package/tests/README.md

@@ -0,0 +1,23 @@
+# Test Matrix
+
+The test suite mirrors the thin-core architecture so regressions are easier to localize.
+
+- `core/` — core models, stores, retrieval, ingestion, derivation, runtime services, and service facades.
+- `adapters/claude/` — Claude Code hook and transcript adapter behavior.
+- `extensions/` — optional vector, shared-memory, endless-memory, and MCP extension boundaries/services.
+- `apps/` — CLI, server/API, dashboard/UI, and packaging-facing application behavior.
+
+Run all tests with:
+
+```bash
+npm test -- --run
+```
+
+Run one architecture slice with:
+
+```bash
+npm test -- --run tests/core
+npm test -- --run tests/adapters/claude
+npm test -- --run tests/extensions
+npm test -- --run tests/apps
+```

package/tests/adapters/claude/claude-semantic-daemon-adapter.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest';
+import {
+  handleSemanticDaemonRequest,
+  isValidSemanticDaemonRequest,
+  isVectorSessionFilterError,
+  makeSemanticDaemonErrorResponse,
+  parseSemanticDaemonRequest
+} from '../../../src/adapters/claude/hooks/semantic-daemon.js';
+
+describe('Claude semantic daemon adapter', () => {
+  it('parses JSON requests and treats malformed payloads as empty requests', () => {
+    expect(parseSemanticDaemonRequest('{"type":"retrieve","sessionId":"s1"}')).toEqual({
+      type: 'retrieve',
+      sessionId: 's1'
+    });
+    expect(parseSemanticDaemonRequest('{not-json')).toEqual({});
+  });
+
+  it('validates retrieve requests before touching MemoryService', () => {
+    expect(isValidSemanticDaemonRequest({
+      type: 'retrieve',
+      sessionId: 'session-1',
+      prompt: 'find checkout fix',
+      topK: 5,
+      minScore: 0.2
+    })).toBe(true);
+
+    expect(isValidSemanticDaemonRequest({
+      type: 'retrieve',
+      sessionId: 'session-1',
+      prompt: 'find checkout fix',
+      topK: Number.NaN,
+      minScore: 0.2
+    })).toBe(false);
+  });
+
+  it('returns a deterministic invalid request response without initializing retrieval', async () => {
+    await expect(handleSemanticDaemonRequest('{"type":"retrieve"}')).resolves.toEqual({
+      ok: false,
+      error: 'invalid request'
+    });
+  });
+
+  it('detects LanceDB sessionId field-case filter failures', () => {
+    expect(isVectorSessionFilterError(new Error('No field named sessionId in schema'))).toBe(true);
+    expect(isVectorSessionFilterError(new Error('connection refused'))).toBe(false);
+    expect(isVectorSessionFilterError('no field named sessionId')).toBe(false);
+  });
+
+  it('formats daemon errors without leaking non-Error values', () => {
+    expect(makeSemanticDaemonErrorResponse(new Error('boom'))).toEqual({ ok: false, error: 'boom' });
+    expect(makeSemanticDaemonErrorResponse('boom')).toEqual({ ok: false, error: 'unknown daemon error' });
+  });
+});

package/tests/adapters/claude/claude-transcript-reconstructor.test.ts

@@ -0,0 +1,98 @@
+import { mkdtemp, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { readTranscriptTailEntries } from '../../../src/adapters/claude/transcript/transcript-reader.js';
+import {
+  extractAssistantTextMessages,
+  extractAssistantMessages,
+  generateSessionSummary
+} from '../../../src/adapters/claude/transcript/turn-reconstructor.js';
+
+describe('Claude transcript reader', () => {
+  it('reads JSONL transcript tail entries and skips malformed partial lines', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'cml-transcript-'));
+    const transcriptPath = join(dir, 'transcript.jsonl');
+    await writeFile(
+      transcriptPath,
+      [
+        '{"type":"user","message":{"content":"hello"}}',
+        'not-json',
+        'null',
+        '42',
+        '{"type":"assistant","message":{"content":[{"type":"text","text":"answer"}]}}'
+      ].join('\n'),
+      'utf8'
+    );
+
+    const entries = await readTranscriptTailEntries(transcriptPath);
+
+    expect(entries.map((entry) => entry.type)).toEqual(['user', 'assistant']);
+  });
+
+  it('skips a partial first line when tail reading starts mid-record', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'cml-transcript-'));
+    const transcriptPath = join(dir, 'transcript.jsonl');
+    const firstLine = `{"type":"user","message":{"content":"${'x'.repeat(500)}"}}`;
+    const secondLine = '{"type":"user","message":{"content":"recent question"}}';
+    const thirdLine = '{"type":"assistant","message":{"content":[{"type":"text","text":"recent answer"}]}}';
+    await writeFile(transcriptPath, [firstLine, secondLine, thirdLine].join('\n'), 'utf8');
+
+    const maxBytes = Buffer.byteLength(`${secondLine}\n${thirdLine}`) + 10;
+    const entries = await readTranscriptTailEntries(transcriptPath, { maxBytes });
+
+    expect(entries.map((entry) => entry.type)).toEqual(['user', 'assistant']);
+    expect(entries[0]?.message?.content).toBe('recent question');
+  });
+
+  it('returns an empty entry list for missing transcript files', async () => {
+    await expect(readTranscriptTailEntries('/tmp/non-existent-claude-transcript.jsonl')).resolves.toEqual([]);
+  });
+});
+
+describe('Claude turn reconstructor', () => {
+  it('extracts assistant text blocks and joins multi-part text content', async () => {
+    const messages = extractAssistantTextMessages([
+      { type: 'user', message: { content: 'ignored' } },
+      {
+        type: 'assistant',
+        message: {
+          content: [
+            { type: 'text', text: 'first' },
+            { type: 'tool_use', id: 'tool-1' },
+            { type: 'text', text: 'second' }
+          ]
+        }
+      },
+      { type: 'assistant', message: { content: [{ type: 'tool_use', id: 'tool-2' }] } }
+    ]);
+
+    expect(messages).toEqual(['first\nsecond']);
+  });
+
+  it('reads assistant text messages from a transcript file', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'cml-transcript-'));
+    const transcriptPath = join(dir, 'transcript.jsonl');
+    await writeFile(
+      transcriptPath,
+      '{"type":"assistant","message":{"content":[{"type":"text","text":"final answer"}]}}\n',
+      'utf8'
+    );
+
+    await expect(extractAssistantMessages(transcriptPath)).resolves.toEqual(['final answer']);
+  });
+
+  it('generates deterministic summaries from session events', () => {
+    const summary = generateSessionSummary([
+      { eventType: 'user_prompt', content: 'How should we refactor transcript parsing?' },
+      { eventType: 'agent_response', content: 'Move it behind adapter modules.' },
+      { eventType: 'tool_observation', content: 'ignored' }
+    ]);
+
+    expect(summary).toBe(
+      'Session with 1 user prompts and 1 responses.\n' +
+      'Topics discussed:\n' +
+      '- How should we refactor transcript parsing?'
+    );
+  });
+});

package/tests/adapters/claude-hook-prompt-injection-policy.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, it } from 'vitest';
+
+import { MemoryQueryService } from '../../src/core/engine/memory-query-service.js';
+import type { MemoryEvent } from '../../src/core/types.js';
+import {
+  filterHookInjectableMemories,
+  getHookInjectionPolicy,
+  summarizeHookInjectionConfidence,
+  type HookMemoryCandidate
+} from '../../src/adapters/claude/hooks/prompt-injection-policy.js';
+
+function event(id: string, content = 'low confidence keyword result'): MemoryEvent {
+  return {
+    id,
+    eventType: 'user_prompt',
+    sessionId: 'session-1',
+    timestamp: new Date('2026-05-02T00:00:00.000Z'),
+    content,
+    canonicalKey: `test/${id}`,
+    dedupeKey: `session-1:${id}`,
+    metadata: {}
+  };
+}
+
+describe('Claude hook prompt injection policy', () => {
+  it('filters low-confidence hook candidates before prompt injection', () => {
+    const candidates: HookMemoryCandidate[] = [
+      { id: 'low-semantic', type: 'agent_response', content: 'maybe related', score: 0.58, source: 'semantic' },
+      { id: 'low-keyword', type: 'user_prompt', content: 'weak keyword rescue', score: 0.49, source: 'keyword' },
+      { id: 'high-keyword', type: 'user_prompt', content: 'exact high-confidence keyword', score: 0.84, source: 'keyword' },
+      { id: 'high-semantic', type: 'session_summary', content: 'high semantic match', score: 0.76, source: 'semantic' }
+    ];
+
+    expect(filterHookInjectableMemories(candidates, getHookInjectionPolicy())).toEqual([
+      candidates[2],
+      candidates[3]
+    ]);
+    expect(summarizeHookInjectionConfidence(candidates)).toBe('high');
+    expect(summarizeHookInjectionConfidence([])).toBe('none');
+  });
+
+  it('limits injected hook memories by highest confidence rather than first passing candidate', () => {
+    const candidates: HookMemoryCandidate[] = [
+      { id: 'medium-first', type: 'session_summary', content: 'passes but weaker', score: 0.67, source: 'semantic' },
+      { id: 'best-later', type: 'user_prompt', content: 'best exact keyword', score: 0.93, source: 'keyword' },
+      { id: 'second-best-later', type: 'agent_response', content: 'strong semantic match', score: 0.88, source: 'semantic' }
+    ];
+
+    expect(filterHookInjectableMemories(candidates, { ...getHookInjectionPolicy(), maxMemories: 2 }))
+      .toEqual([candidates[1], candidates[2]]);
+  });
+
+  it('uses bounded hook policy thresholds so unsafe env overrides cannot inject weak memories', () => {
+    const policy = getHookInjectionPolicy({
+      CLAUDE_MEMORY_HOOK_INJECTION_MIN_SCORE: '-1',
+      CLAUDE_MEMORY_HOOK_SEMANTIC_MIN_SCORE: '2',
+      CLAUDE_MEMORY_HOOK_KEYWORD_MIN_SCORE: 'not-a-number',
+      CLAUDE_MEMORY_HOOK_FALLBACK_KEYWORD_MIN_SCORE: '-0.2',
+      CLAUDE_MEMORY_HOOK_MAX_INJECTED: '2'
+    } as NodeJS.ProcessEnv);
+
+    expect(policy).toEqual({
+      minScore: 0.65,
+      semanticMinScore: 0.65,
+      keywordMinScore: 0.7,
+      fallbackKeywordMinScore: 0.8,
+      maxMemories: 2
+    });
+
+    expect(filterHookInjectableMemories([
+      { id: 'weak-unknown', type: 'user_prompt', content: 'weak unknown source', score: 0.1, source: 'unknown' },
+      { id: 'fallback-too-weak', type: 'user_prompt', content: 'weak fallback', score: 0.79, source: 'keyword', fallback: true }
+    ], policy)).toEqual([]);
+  });
+
+  it('keeps regular CLI/query search behavior independent from hook injection policy', async () => {
+    const memory = event('regular-low');
+    const service = new MemoryQueryService(
+      async () => {},
+      {
+        keywordSearch: async () => [{ event: memory, rank: -0.5 }],
+        getSessionEvents: async () => [memory],
+        getRecentEvents: async () => [memory]
+      }
+    );
+
+    const regularResults = await service.keywordSearch('weak keyword rescue', { topK: 1, minScore: 0.2 });
+    expect(regularResults).toEqual([{ event: memory, score: 1 }]);
+
+    const hookCandidates: HookMemoryCandidate[] = regularResults.map((result) => ({
+      id: result.event.id,
+      type: result.event.eventType,
+      content: result.event.content,
+      score: 0.5,
+      source: 'keyword'
+    }));
+    expect(filterHookInjectableMemories(hookCandidates, getHookInjectionPolicy())).toEqual([]);
+  });
+});

package/tests/apps/app-layer-boundary.test.ts

@@ -0,0 +1,48 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+
+const apiModules = [
+  'chat',
+  'citations',
+  'events',
+  'health',
+  'projects',
+  'search',
+  'sessions',
+  'stats',
+  'turns',
+  'utils'
+];
+
+describe('app-layer entrypoint boundaries', () => {
+  it('keeps CLI implementation under src/apps/cli while preserving src/cli compatibility', () => {
+    const packageJson = JSON.parse(readFileSync('package.json', 'utf8')) as {
+      scripts?: Record<string, string>;
+    };
+    const buildScript = readFileSync('scripts/build.ts', 'utf8');
+    const cliCompatSource = readFileSync('src/cli/index.ts', 'utf8');
+    const cliDisclosureCompatSource = readFileSync('src/cli/retrieval-disclosure-output.ts', 'utf8');
+
+    expect(packageJson.scripts?.dev).toBe('tsx src/apps/cli/index.ts');
+    expect(buildScript).toContain("entryPoints: ['src/apps/cli/index.ts']");
+    expect(cliCompatSource).toContain("../apps/cli/index.js");
+    expect(cliDisclosureCompatSource).toContain("../apps/cli/retrieval-disclosure-output.js");
+  });
+
+  it('keeps server implementation under src/apps/server while preserving src/server compatibility', () => {
+    const buildScript = readFileSync('scripts/build.ts', 'utf8');
+    const serverCompatSource = readFileSync('src/server/index.ts', 'utf8');
+    const apiIndexCompatSource = readFileSync('src/server/api/index.ts', 'utf8');
+
+    expect(buildScript).toContain("entryPoints: ['src/apps/server/index.ts']");
+    expect(buildScript).toContain("entryPoints: ['src/apps/server/api/index.ts']");
+    expect(serverCompatSource).toContain("../apps/server/index.js");
+    expect(apiIndexCompatSource).toContain("../../apps/server/api/index.js");
+
+    for (const moduleName of apiModules) {
+      const compatPath = `src/server/api/${moduleName}.ts`;
+      expect(existsSync(compatPath), `${compatPath} should exist`).toBe(true);
+      expect(readFileSync(compatPath, 'utf8')).toContain(`../../apps/server/api/${moduleName}.js`);
+    }
+  });
+});

package/tests/apps/claude-settings-hooks.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  buildHookCommand,
+  getHooksConfig,
+  mergePluginHooksIntoSettings,
+  removePluginHooksFromSettings,
+  type ClaudeSettingsWithHooks
+} from '../../src/apps/cli/claude-settings-hooks.js';
+
+describe('Claude Code hook settings helpers', () => {
+  it('quotes hook paths so plugin installs work when the path contains spaces', () => {
+    expect(buildHookCommand('/tmp/project with spaces/dist', 'user-prompt-submit.js'))
+      .toBe("node '/tmp/project with spaces/dist/hooks/user-prompt-submit.js'");
+
+    const complexCommand = buildHookCommand("/tmp/project with $dollars 'quotes' and `ticks`/dist", 'stop.js');
+    expect(complexCommand).toContain("'\\''quotes'\\''");
+    expect(complexCommand).toContain('$dollars');
+    expect(complexCommand).toContain('`ticks`');
+
+    expect(getHooksConfig('/tmp/project with spaces/dist').UserPromptSubmit?.[0].hooks[0].command)
+      .toBe("node '/tmp/project with spaces/dist/hooks/user-prompt-submit.js'");
+  });
+
+  it('merges plugin hooks without replacing unrelated hooks in the same categories', () => {
+    const settings: ClaudeSettingsWithHooks = {
+      theme: 'dark',
+      hooks: {
+        UserPromptSubmit: [
+          {
+            matcher: 'existing',
+            hooks: [{ type: 'command', command: 'node /other/plugin.js' }]
+          }
+        ],
+        Stop: [
+          {
+            matcher: 'old-plugin',
+            hooks: [{ type: 'command', command: 'node /old/claude-memory-layer/dist/hooks/stop.js' }]
+          }
+        ]
+      }
+    };
+
+    const merged = mergePluginHooksIntoSettings(settings, '/new/plugin dist');
+
+    expect(merged.theme).toBe('dark');
+    expect(merged.hooks?.UserPromptSubmit).toEqual([
+      {
+        matcher: 'existing',
+        hooks: [{ type: 'command', command: 'node /other/plugin.js' }]
+      },
+      {
+        matcher: '',
+        hooks: [{ type: 'command', command: "node '/new/plugin dist/hooks/user-prompt-submit.js'" }]
+      }
+    ]);
+    expect(merged.hooks?.Stop).toEqual([
+      {
+        matcher: '',
+        hooks: [{ type: 'command', command: "node '/new/plugin dist/hooks/stop.js'" }]
+      }
+    ]);
+  });
+
+  it('uninstall removes only claude-memory-layer hook commands and leaves other hooks intact', () => {
+    const settings: ClaudeSettingsWithHooks = {
+      hooks: {
+        SessionStart: [
+          {
+            matcher: 'keep-and-remove',
+            hooks: [
+              { type: 'command', command: 'node /opt/claude-memory-layer/dist/hooks/session-start.js' },
+              { type: 'command', command: 'node /other/session-start-helper.js' }
+            ]
+          }
+        ],
+        PostToolUse: [
+          {
+            matcher: 'keep',
+            hooks: [
+              { type: 'command', command: 'node /other/post-tool-use-helper.js' },
+              { type: 'command', command: 'node /other-plugin/hooks/post-tool-use.js' }
+            ]
+          }
+        ]
+      }
+    };
+
+    const removed = removePluginHooksFromSettings(settings, '/opt/claude-memory-layer/dist');
+
+    expect(removed.hooks?.SessionStart).toEqual([
+      {
+        matcher: 'keep-and-remove',
+        hooks: [{ type: 'command', command: 'node /other/session-start-helper.js' }]
+      }
+    ]);
+    expect(removed.hooks?.PostToolUse).toEqual([
+      {
+        matcher: 'keep',
+        hooks: [
+          { type: 'command', command: 'node /other/post-tool-use-helper.js' },
+          { type: 'command', command: 'node /other-plugin/hooks/post-tool-use.js' }
+        ]
+      }
+    ]);
+  });
+});