@cleocode/core 2026.4.35 → 2026.4.37

package/src/hooks/handlers/task-hooks.ts

@@ -5,6 +5,7 @@
  * Auto-registers on module load.
  *
  * T138: Triggers memory bridge refresh after task completion.
+ * T554: Triggers LLM observer after task completion when observation count ≥ threshold.
  */
 
 import { hooks } from '../registry.js';
@@ -37,6 +38,7 @@ export async function handleToolStart(
  * Handle PostToolUse (maps to task.complete in CLEO, canonical: was onToolComplete)
  *
  * T138: Refresh memory bridge after task completion.
+ * T554: Fire-and-forget LLM observer when observation count ≥ threshold.
  */
 export async function handleToolComplete(
   projectRoot: string,
@@ -55,6 +57,18 @@ export async function handleToolComplete(
     if (!isMissingBrainSchemaError(err)) throw err;
   }
 
+  // T554: Fire-and-forget observer — runs after observation is stored so the
+  // new observation is included in the count. setImmediate ensures the task
+  // complete response reaches the caller before the LLM call begins.
+  setImmediate(async () => {
+    try {
+      const { runObserver } = await import('../../memory/observer-reflector.js');
+      await runObserver(projectRoot);
+    } catch {
+      // Observer errors must never surface to the task complete flow
+    }
+  });
+
   // T138: Refresh memory bridge after task completes (best-effort)
   await maybeRefreshMemoryBridge(projectRoot);
 }

package/src/internal.ts

@@ -885,6 +885,14 @@ export type {
   BrainSearchHit,
   BrainTimelineNeighborRow,
 } from './memory/brain-row-types.js';
+// Memory — LLM extraction gate (additional)
+export type {
+  ExtractedMemory,
+  ExtractFromTranscriptOptions,
+  ExtractionReport,
+  ExtractionType,
+} from './memory/llm-extraction.js';
+export { extractFromTranscript as llmExtractFromTranscript } from './memory/llm-extraction.js';
 // Memory (additional)
 export {
   generateContextAwareContent,

package/src/memory/__tests__/auto-extract.test.ts

@@ -1,11 +1,10 @@
 /**
- * Unit tests for auto-extract memory pipeline.
+ * Unit tests for the auto-extract module.
  *
- * extractTaskCompletionMemory and extractSessionEndMemory are disabled no-ops
- * per T523 CA1 specification. Tests verify the no-op contract holds.
- *
- * @task T526
- * @epic T523
+ * The legacy `extractTaskCompletionMemory` and `extractSessionEndMemory`
+ * functions were removed entirely (the LLM extraction gate replaced the
+ * keyword regex in extractFromTranscript). Only `resolveTaskDetails` and
+ * `extractFromTranscript` remain.
  */
 
 import type { Task } from '@cleocode/contracts';
@@ -13,35 +12,25 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 // ---- mocks ----------------------------------------------------------------
 
-vi.mock('../learnings.js', () => ({
-  storeLearning: vi.fn().mockResolvedValue(undefined),
-}));
-
-vi.mock('../patterns.js', () => ({
-  storePattern: vi.fn().mockResolvedValue(undefined),
+vi.mock('../llm-extraction.js', () => ({
+  extractFromTranscript: vi.fn().mockResolvedValue({
+    extractedCount: 0,
+    storedCount: 0,
+    mergedCount: 0,
+    rejectedCount: 0,
+    warnings: [],
+  }),
 }));
 
-vi.mock('../decisions.js', () => ({
-  storeDecision: vi.fn().mockResolvedValue(undefined),
-}));
-
-// Mock getAccessor — should never be called by disabled functions
 vi.mock('../../store/data-accessor.js', () => ({
   getAccessor: vi.fn(),
 }));
 
 // ---- imports after mocks --------------------------------------------------
 
-import type { SessionBridgeData } from '../../sessions/session-memory-bridge.js';
 import { getAccessor } from '../../store/data-accessor.js';
-import {
-  extractSessionEndMemory,
-  extractTaskCompletionMemory,
-  resolveTaskDetails,
-} from '../auto-extract.js';
-import { storeDecision } from '../decisions.js';
-import { storeLearning } from '../learnings.js';
-import { storePattern } from '../patterns.js';
+import { extractFromTranscript, resolveTaskDetails } from '../auto-extract.js';
+import { extractFromTranscript as llmExtractFromTranscript } from '../llm-extraction.js';
 
 // ---- helpers --------------------------------------------------------------
 
@@ -57,16 +46,6 @@ function makeTask(overrides: Partial<Task> & { id: string; title: string }): Tas
   } as Task;
 }
 
-function makeSessionData(overrides: Partial<SessionBridgeData> = {}): SessionBridgeData {
-  return {
-    sessionId: 'S-test-001',
-    scope: 'test scope',
-    tasksCompleted: [],
-    duration: 3600,
-    ...overrides,
-  };
-}
-
 function setupAccessor(tasks: Task[]): void {
   (getAccessor as ReturnType<typeof vi.fn>).mockResolvedValue({
     queryTasks: vi.fn().mockResolvedValue({ tasks, total: tasks.length }),
@@ -83,96 +62,46 @@ beforeEach(() => {
   vi.clearAllMocks();
 });
 
-describe('extractTaskCompletionMemory', () => {
-  it('is a no-op — does not write learnings', async () => {
-    const task = makeTask({ id: 'T001', title: 'Fix auth bug', description: 'Auth was broken' });
-    setupAccessor([task]);
-
-    await extractTaskCompletionMemory('/mock/root', task);
-
-    expect(storeLearning).not.toHaveBeenCalled();
-  });
+describe('extractFromTranscript (wrapper)', () => {
+  it('delegates to the LLM extraction gate for non-empty input', async () => {
+    await extractFromTranscript('/mock/root', 'S-100', 'some transcript content');
 
-  it('is a no-op — does not write dependency learnings', async () => {
-    const task = makeTask({
-      id: 'T002',
-      title: 'Deploy feature',
-      description: 'Deploy the thing',
-      depends: ['T001', 'T003'],
+    expect(llmExtractFromTranscript).toHaveBeenCalledTimes(1);
+    expect(llmExtractFromTranscript).toHaveBeenCalledWith({
+      projectRoot: '/mock/root',
+      sessionId: 'S-100',
+      transcript: 'some transcript content',
     });
-    setupAccessor([task]);
-
-    await extractTaskCompletionMemory('/mock/root', task);
-
-    expect(storeLearning).not.toHaveBeenCalled();
   });
 
-  it('is a no-op — does not write label patterns', async () => {
-    const completedTasks = [
-      makeTask({ id: 'T010', title: 'A', labels: ['bug'] }),
-      makeTask({ id: 'T011', title: 'B', labels: ['bug'] }),
-      makeTask({ id: 'T012', title: 'C', labels: ['bug'] }),
-    ];
-    const trigger = makeTask({ id: 'T013', title: 'D', labels: ['bug'] });
-    setupAccessor([...completedTasks, trigger]);
-
-    await extractTaskCompletionMemory('/mock/root', trigger);
+  it('skips the LLM call when transcript is empty', async () => {
+    await extractFromTranscript('/mock/root', 'S-101', '');
+    expect(llmExtractFromTranscript).not.toHaveBeenCalled();
+  });
 
-    expect(storePattern).not.toHaveBeenCalled();
-    expect(getAccessor).not.toHaveBeenCalled();
+  it('skips the LLM call when transcript is whitespace-only', async () => {
+    await extractFromTranscript('/mock/root', 'S-102', '   \n  \t ');
+    expect(llmExtractFromTranscript).not.toHaveBeenCalled();
   });
 
-  it('resolves to undefined without throwing', async () => {
-    setupAccessor([]);
+  it('swallows errors from the LLM extraction gate', async () => {
+    (llmExtractFromTranscript as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
+      new Error('simulated failure'),
+    );
 
     await expect(
-      extractTaskCompletionMemory('/mock/root', makeTask({ id: 'T099', title: 'X' })),
+      extractFromTranscript('/mock/root', 'S-103', 'meaningful content'),
     ).resolves.toBeUndefined();
   });
-});
 
-describe('extractSessionEndMemory', () => {
-  it('is a no-op — does not write a session decision', async () => {
-    const tasks = [
-      makeTask({ id: 'T001', title: 'Task one' }),
-      makeTask({ id: 'T002', title: 'Task two' }),
-    ];
-    const session = makeSessionData({ sessionId: 'S-001', tasksCompleted: ['T001', 'T002'] });
-
-    await extractSessionEndMemory('/mock/root', session, tasks);
-
-    expect(storeDecision).not.toHaveBeenCalled();
-  });
-
-  it('is a no-op — does not write per-task learnings', async () => {
-    const tasks = [
-      makeTask({ id: 'T001', title: 'Task one', description: 'Desc one' }),
-      makeTask({ id: 'T002', title: 'Task two', description: 'Desc two' }),
-    ];
-    const session = makeSessionData({ sessionId: 'S-002', tasksCompleted: ['T001', 'T002'] });
-
-    await extractSessionEndMemory('/mock/root', session, tasks);
-
-    expect(storeLearning).not.toHaveBeenCalled();
-  });
-
-  it('is a no-op — does not write workflow patterns', async () => {
-    const tasks = [
-      makeTask({ id: 'T001', title: 'A', labels: ['feature'] }),
-      makeTask({ id: 'T002', title: 'B', labels: ['feature'] }),
-    ];
-    const session = makeSessionData({ sessionId: 'S-003', tasksCompleted: ['T001', 'T002'] });
-
-    await extractSessionEndMemory('/mock/root', session, tasks);
-
-    expect(storePattern).not.toHaveBeenCalled();
-  });
-
-  it('resolves to undefined without throwing', async () => {
-    const tasks = [makeTask({ id: 'T001', title: 'X' })];
-    const session = makeSessionData({ tasksCompleted: ['T001'] });
-
-    await expect(extractSessionEndMemory('/mock/root', session, tasks)).resolves.toBeUndefined();
+  it('returns undefined on non-string transcript input', async () => {
+    await expect(
+      extractFromTranscript('/mock/root', 'S-104', null as unknown as string),
+    ).resolves.toBeUndefined();
+    await expect(
+      extractFromTranscript('/mock/root', 'S-104', 123 as unknown as string),
+    ).resolves.toBeUndefined();
+    expect(llmExtractFromTranscript).not.toHaveBeenCalled();
   });
 });
 

package/src/memory/__tests__/brain-automation.test.ts

@@ -460,53 +460,24 @@ describe('ingestStructuredSummary', () => {
 });
 
 // ============================================================================
-// 4. extractFromTranscript (auto-extract.ts)
+// 4. extractFromTranscript (auto-extract.ts → llm-extraction.ts)
 // ============================================================================
 
-describe('extractFromTranscript', () => {
+describe('extractFromTranscript (wrapper)', () => {
   beforeEach(() => {
     vi.clearAllMocks();
+    // Prevent real network calls during these tests by unsetting the API key.
+    delete process.env.ANTHROPIC_API_KEY;
   });
 
-  it('extracts action-word lines from transcript', async () => {
+  it('returns without calling stores when transcript is empty', async () => {
     const { extractFromTranscript } = await import('../auto-extract.js');
     const { storeLearning } = await import('../learnings.js');
 
-    const transcript = [
-      'user: Can you implement the auth module?',
-      'assistant: I will implement the auth module now.',
-      'assistant: I have fixed the login bug in auth.ts.',
-      'assistant: This is a short line.',
-      'user: Great, what about the tests?',
-      'assistant: I will add tests for the auth module.',
-    ].join('\n');
-
-    await extractFromTranscript('/mock/root', 'S-001', transcript);
-
-    expect(storeLearning).toHaveBeenCalled();
-    const calls = (storeLearning as ReturnType<typeof vi.fn>).mock.calls;
-    // All stored learnings should come from action-word lines
-    for (const [, learning] of calls) {
-      expect(learning.source).toBe('transcript:S-001');
-      expect(learning.confidence).toBe(0.6);
-    }
-  });
-
-  it('limits to 5 learnings max', async () => {
-    const { extractFromTranscript } = await import('../auto-extract.js');
-    const { storeLearning } = await import('../learnings.js');
-
-    // Build a transcript with 10 action lines (all > 20 chars)
-    const lines = Array.from(
-      { length: 10 },
-      (_, i) => `assistant: I implemented feature number ${i + 1} successfully.`,
-    );
-    const transcript = lines.join('\n');
+    await extractFromTranscript('/mock/root', 'S-001', '');
+    await extractFromTranscript('/mock/root', 'S-001', '   \n  ');
 
-    await extractFromTranscript('/mock/root', 'S-002', transcript);
-
-    const calls = (storeLearning as ReturnType<typeof vi.fn>).mock.calls;
-    expect(calls.length).toBeLessThanOrEqual(5);
+    expect(storeLearning).not.toHaveBeenCalled();
   });
 
   it('never throws on malformed input', async () => {
@@ -531,13 +502,19 @@ describe('extractFromTranscript', () => {
     expect(result).toBeUndefined();
   });
 
-  it('does nothing when no action lines present', async () => {
+  it('skips storage when ANTHROPIC_API_KEY is absent', async () => {
     const { extractFromTranscript } = await import('../auto-extract.js');
     const { storeLearning } = await import('../learnings.js');
 
-    const transcript = ['user: Hello', 'assistant: Hi there', 'user: How are you?'].join('\n');
+    // No API key set — the LLM gate must gracefully skip.
+    const transcript = [
+      'user: Can you implement the auth module?',
+      'assistant: I will implement the auth module now.',
+      'assistant: I have fixed the login bug in auth.ts.',
+    ].join('\n');
 
     await extractFromTranscript('/mock/root', 'S-005', transcript);
+
     expect(storeLearning).not.toHaveBeenCalled();
   });
 });