feat: add component filtering and increase ring buffer capacity

- Add `component` field to `LogQueryOptions` for per-component log filtering
- Apply component filter in `LogRingBuffer.since()` before pushing entries
- Bump `LOG_RING_BUFFER_CAPACITY` from 1000 to 5000 for increased log producers
- Map `category` query param to `component` in the logs API handler

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

feat: enhance hook event logging with info and debug levels

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

feat: enhance context injection logging with info and debug detail

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

feat: route MCP tool activity logging through daemon

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

feat: add component filter chips and increase log capacity in viewer

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

feat: add logging audit points across pipeline, consolidation, digest, and lifecycle

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

refactor: code review cleanup for logging enhancement

- Extract LOG_PROMPT_PREVIEW_CHARS and LOG_MESSAGE_PREVIEW_CHARS constants
- Merge duplicate log lines (consolidation, extraction, embedding)
- Deduplicate session register and stop event logs
- Cache daemon port in MCP server's postToDaemon (avoid fs reads per call)
- Add DaemonLogger.log() method to eliminate duplicated dispatch pattern
- Move LEVEL_ORDER/LOG_LEVELS to shared ui/src/lib/constants.ts
- Make availableCategories incremental instead of full-scan on every poll
- Move searchStart after early-return guard
- Use DAEMON_CLIENT_TIMEOUT_MS constant in MCP server
- Remove redundant inline comment in api/logs.ts

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

feat: enhance operation handling with force digest capability

- Added `onForceDigest` callback to `OperationHandlerDeps` to signal metabolism timer for bypassing substrate threshold.
- Updated `handleDigest` function to trigger full cycle processing when `options.full` is set and `onForceDigest` is provided, ensuring items are reset to pending status.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: sirkirby

src/constants.ts

@@ -33,6 +33,12 @@ export const SESSION_SUMMARY_PREVIEW_CHARS = 300;
 /** Max chars for a recall summary preview. */
 export const RECALL_SUMMARY_PREVIEW_CHARS = 200;
 
+// --- Log preview limits (short previews for structured log fields) ---
+/** Max chars for a user prompt preview in log entries. */
+export const LOG_PROMPT_PREVIEW_CHARS = 50;
+/** Max chars for an assistant message preview in log entries. */
+export const LOG_MESSAGE_PREVIEW_CHARS = 80;
+
 // --- Context injection layer budgets (chars, not tokens — used with .slice()) ---
 export const CONTEXT_PLAN_PREVIEW_CHARS = 100;
 export const CONTEXT_SESSION_PREVIEW_CHARS = 80;

src/daemon/api/logs.ts

@@ -9,8 +9,9 @@ export async function handleGetLogs(
   const since = query.since || null;
   const level = query.level as LogLevel | undefined;
   const limit = query.limit ? parseInt(query.limit, 10) : undefined;
+  const component = query.category || undefined;
 
-  const result = ringBuffer.since(since, { level, limit: isNaN(limit as number) ? undefined : limit });
+  const result = ringBuffer.since(since, { level, component, limit: isNaN(limit as number) ? undefined : limit });
 
   // Map `component` to `category` in the response entries —
   // the logger uses `component` internally; the API spec uses `category`

src/daemon/api/operations.ts

@@ -36,6 +36,8 @@ export interface OperationHandlerDeps {
   embeddingProvider: EmbeddingProvider;
   progressTracker: ProgressTracker;
   pipeline?: PipelineManager;
+  /** Signal the metabolism timer to bypass the substrate threshold on next tick. */
+  onForceDigest?: () => void;
   log: (level: string, message: string, data?: Record<string, unknown>) => void;
 }
 
@@ -156,6 +158,15 @@ export async function handleDigest(
         tiers: result.tiersGenerated,
         duration: result.durationMs,
       });
+    } else if (options?.full && deps.onForceDigest) {
+      // Full cycle deferred to metabolism timer — signal it to bypass
+      // the substrate threshold so the reset items actually get processed.
+      deps.onForceDigest();
+      deps.progressTracker.update(token, {
+        status: 'completed',
+        percent: PROGRESS_COMPLETE,
+        message: 'Full cycle queued — items reset to pending',
+      });
     } else {
       deps.progressTracker.update(token, {
         status: 'completed',

src/daemon/consolidation.ts

@@ -226,6 +226,10 @@ export class ConsolidationEngine {
       }
 
       clustersFound++;
+      this.log('debug', 'Consolidation groups formed', {
+        group_count: clustersFound,
+        total_notes: cluster.length,
+      });
 
       // Build consolidation prompt
       const candidatesText = formatNotesForPrompt(cluster);
@@ -319,10 +323,11 @@ export class ConsolidationEngine {
         consolidated++;
         sporesSuperseded += consolidateResult.sources_archived;
 
-        this.log('info', 'ConsolidationEngine: consolidated cluster', {
+        this.log('info', 'Notes consolidated', {
           wisdomId: consolidateResult.wisdom_id,
           sourcesArchived: consolidateResult.sources_archived,
           clusterSize: cluster.length,
+          similarity: vectorResults[0]?.similarity ?? 0,
         });
       } catch (err) {
         this.log('warn', 'ConsolidationEngine: consolidateSpores failed', {
@@ -334,6 +339,10 @@ export class ConsolidationEngine {
       cluster.forEach((n) => processedIds.add(n.id));
     }
 
+    if (clustersFound === 0) {
+      this.log('debug', 'Consolidation: no groups above threshold');
+    }
+
     const passTimestamp = new Date().toISOString();
     const durationMs = Date.now() - startTime;
 

src/daemon/digest.ts

@@ -339,6 +339,14 @@ export class DigestEngine {
       }
     }
 
+    this.log('debug', 'Substrate breakdown', {
+      sessions: substrateIndex.sessions.length,
+      spores: substrateIndex.spores.length,
+      plans: substrateIndex.plans.length,
+      artifacts: substrateIndex.artifacts.length,
+      team: substrateIndex.team.length,
+    });
+
     // Record the cycle timestamp NOW, before tier processing. This ensures the
     // timestamp advances even if LLM calls fail, preventing the same substrate
     // from being rediscovered on every subsequent timer fire.

src/daemon/log-buffer.ts

@@ -1,7 +1,7 @@
 import type { LogEntry, LogLevel } from './logger.js';
 import { LEVEL_ORDER } from './logger.js';
 
-const LOG_RING_BUFFER_CAPACITY = 1000;
+const LOG_RING_BUFFER_CAPACITY = 5000;
 const LOG_QUERY_DEFAULT_LIMIT = 100;
 
 interface LogQueryResult {
@@ -12,6 +12,7 @@ interface LogQueryResult {
 
 interface LogQueryOptions {
   level?: LogLevel;
+  component?: string;
   limit?: number;
 }
 
@@ -64,6 +65,7 @@ export class LogRingBuffer {
       const bufIdx = (this.head - this.count + i + this.capacity) % this.capacity;
       const entry = this.buffer[bufIdx];
       if (entry && LEVEL_ORDER[entry.level as LogLevel] >= minLevel) {
+        if (options?.component && entry.component !== options.component) continue;
         entries.push(entry);
       }
     }

src/daemon/logger.ts

@@ -65,6 +65,13 @@ export class DaemonLogger {
     this.write('error', component, message, data);
   }
 
+  /** Dispatch a log entry by dynamic level string. */
+  log(level: string, component: string, message: string, data?: Record<string, unknown>): void {
+    if (level in LEVEL_ORDER) {
+      this.write(level as LogLevel, component, message, data);
+    }
+  }
+
   close(): void {
     if (this.fd !== null) {
       fs.closeSync(this.fd);