pi-continuous-learning 0.5.0 → 0.6.0

package/src/cli/analyze.ts

@@ -7,36 +7,35 @@ import {
   unlinkSync,
 } from "node:fs";
 import { join } from "node:path";
-import {
-  createAgentSession,
-  SessionManager,
-  AuthStorage,
-  ModelRegistry,
-  DefaultResourceLoader,
-} from "@mariozechner/pi-coding-agent";
+import { AuthStorage } from "@mariozechner/pi-coding-agent";
 import { getModel } from "@mariozechner/pi-ai";
 
 import { loadConfig, DEFAULT_CONFIG } from "../config.js";
-import type { ProjectEntry } from "../types.js";
+import type { InstalledSkill, ProjectEntry } from "../types.js";
 import {
   getBaseDir,
   getProjectsRegistryPath,
   getObservationsPath,
   getProjectDir,
+  getProjectInstinctsDir,
+  getGlobalInstinctsDir,
 } from "../storage.js";
 import { countObservations } from "../observations.js";
 import { runDecayPass } from "../instinct-decay.js";
-import { buildAnalyzerUserPrompt, tailObservationsSince } from "../prompts/analyzer-user.js";
-import { buildAnalyzerSystemPrompt } from "./analyze-prompt.js";
+import { tailObservationsSince } from "../prompts/analyzer-user.js";
+import { buildSingleShotSystemPrompt } from "../prompts/analyzer-system-single-shot.js";
+import { buildSingleShotUserPrompt } from "../prompts/analyzer-user-single-shot.js";
+import {
+  runSingleShot,
+  buildInstinctFromChange,
+} from "./analyze-single-shot.js";
 import {
-  createInstinctListTool,
-  createInstinctReadTool,
-  createInstinctWriteTool,
-  createInstinctDeleteTool,
-} from "../instinct-tools.js";
+  loadProjectInstincts,
+  loadGlobalInstincts,
+  saveInstinct,
+} from "../instinct-store.js";
 import { readAgentsMd } from "../agents-md.js";
 import { homedir } from "node:os";
-import type { InstalledSkill } from "../types.js";
 import { AnalyzeLogger, type ProjectRunStats, type RunSummary } from "./analyze-logger.js";
 
 // ---------------------------------------------------------------------------
@@ -59,7 +58,6 @@ function acquireLock(baseDir: string): boolean {
       const lock = JSON.parse(content) as { pid: number; started_at: string };
       const age = Date.now() - new Date(lock.started_at).getTime();
 
-      // Check if the owning process is still alive
       try {
         process.kill(lock.pid, 0); // signal 0 = existence check, no actual signal
         if (age < LOCK_STALE_MS) {
@@ -104,72 +102,6 @@ function startGlobalTimeout(timeoutMs: number, logger: AnalyzeLogger): void {
   }, timeoutMs).unref();
 }
 
-// ---------------------------------------------------------------------------
-// Instinct operation tracking
-// ---------------------------------------------------------------------------
-
-interface InstinctOpCounts {
-  created: number;
-  updated: number;
-  deleted: number;
-}
-
-/**
- * Wraps instinct tools to count create/update/delete operations.
- * Returns new tool instances that increment the provided counts.
- */
-function wrapInstinctToolsWithTracking(
-  projectId: string,
-  projectName: string,
-  baseDir: string,
-  counts: InstinctOpCounts
-) {
-  const writeTool = createInstinctWriteTool(projectId, projectName, baseDir);
-  const deleteTool = createInstinctDeleteTool(projectId, baseDir);
-
-  const trackedWrite = {
-    ...writeTool,
-    async execute(
-      toolCallId: string,
-      params: Parameters<typeof writeTool.execute>[1],
-      signal: AbortSignal | undefined,
-      onUpdate: unknown,
-      ctx: unknown
-    ) {
-      const result = await writeTool.execute(toolCallId, params, signal, onUpdate, ctx);
-      const details = result.details as { action?: string } | undefined;
-      if (details?.action === "created") {
-        counts.created++;
-      } else {
-        counts.updated++;
-      }
-      return result;
-    },
-  };
-
-  const trackedDelete = {
-    ...deleteTool,
-    async execute(
-      toolCallId: string,
-      params: Parameters<typeof deleteTool.execute>[1],
-      signal: AbortSignal | undefined,
-      onUpdate: unknown,
-      ctx: unknown
-    ) {
-      const result = await deleteTool.execute(toolCallId, params, signal, onUpdate, ctx);
-      counts.deleted++;
-      return result;
-    },
-  };
-
-  return {
-    listTool: createInstinctListTool(projectId, baseDir),
-    readTool: createInstinctReadTool(projectId, baseDir),
-    writeTool: trackedWrite,
-    deleteTool: trackedDelete,
-  };
-}
-
 // ---------------------------------------------------------------------------
 // Per-project analysis
 // ---------------------------------------------------------------------------
@@ -237,10 +169,13 @@ async function analyzeProject(
 
   const obsPath = getObservationsPath(project.id, baseDir);
   const sinceLineCount = meta.last_observation_line_count ?? 0;
-  const { lines: newObsLines, totalLineCount } = tailObservationsSince(obsPath, sinceLineCount);
+  const { lines: newObsLines, totalLineCount, rawLineCount } = tailObservationsSince(
+    obsPath,
+    sinceLineCount
+  );
 
   if (newObsLines.length === 0) {
-    return { ran: false, skippedReason: "no new observation lines" };
+    return { ran: false, skippedReason: "no new observation lines after preprocessing" };
   }
 
   const obsCount = countObservations(project.id, baseDir);
@@ -249,11 +184,14 @@ async function analyzeProject(
   }
 
   const startTime = Date.now();
-  logger.projectStart(project.id, project.name, newObsLines.length, obsCount);
+  logger.projectStart(project.id, project.name, rawLineCount, obsCount);
 
   runDecayPass(project.id, baseDir);
 
-  const instinctsDir = join(getProjectDir(project.id, baseDir), "instincts", "personal");
+  // Load current instincts inline - no tool calls needed
+  const projectInstincts = loadProjectInstincts(project.id, baseDir);
+  const globalInstincts = loadGlobalInstincts(baseDir);
+  const allInstincts = [...projectInstincts, ...globalInstincts];
 
   const agentsMdProject = readAgentsMd(join(project.root, "AGENTS.md"));
   const agentsMdGlobal = readAgentsMd(join(homedir(), ".pi", "agent", "AGENTS.md"));
@@ -270,68 +208,89 @@ async function analyzeProject(
     // Skills loading is best-effort - continue without them
   }
 
-  const userPrompt = buildAnalyzerUserPrompt(obsPath, instinctsDir, project, {
+  const userPrompt = buildSingleShotUserPrompt(project, allInstincts, newObsLines, {
     agentsMdProject,
     agentsMdGlobal,
     installedSkills,
-    observationLines: newObsLines,
   });
 
   const authStorage = AuthStorage.create();
-  const modelRegistry = new ModelRegistry(authStorage);
   const modelId = (config.model || DEFAULT_CONFIG.model) as Parameters<typeof getModel>[1];
   const model = getModel("anthropic", modelId);
+  const apiKey = await authStorage.getApiKey("anthropic");
+
+  if (!apiKey) {
+    throw new Error("No Anthropic API key configured. Set via auth.json or ANTHROPIC_API_KEY.");
+  }
 
-  // Track instinct operations
-  const instinctCounts: InstinctOpCounts = { created: 0, updated: 0, deleted: 0 };
-  const trackedTools = wrapInstinctToolsWithTracking(project.id, project.name, baseDir, instinctCounts);
+  const context = {
+    systemPrompt: buildSingleShotSystemPrompt(),
+    messages: [
+      { role: "user" as const, content: userPrompt, timestamp: Date.now() },
+    ],
+  };
 
-  const customTools = [
-    trackedTools.listTool,
-    trackedTools.readTool,
-    trackedTools.writeTool,
-    trackedTools.deleteTool,
-  ];
+  const timeoutMs = (config.timeout_seconds ?? DEFAULT_CONFIG.timeout_seconds) * 1000;
+  const abortController = new AbortController();
+  const timeoutHandle = setTimeout(() => abortController.abort(), timeoutMs);
 
-  const loader = new DefaultResourceLoader({
-    systemPromptOverride: () => buildAnalyzerSystemPrompt(),
-  });
-  await loader.reload();
-
-  const { session } = await createAgentSession({
-    model,
-    authStorage,
-    modelRegistry,
-    sessionManager: SessionManager.inMemory(),
-    customTools,
-    resourceLoader: loader,
-  });
+  const instinctCounts = { created: 0, updated: 0, deleted: 0 };
+  const projectInstinctsDir = getProjectInstinctsDir(project.id, "personal", baseDir);
+  const globalInstinctsDir = getGlobalInstinctsDir("personal", baseDir);
 
+  let singleShotMessage;
   try {
-    await session.prompt(userPrompt);
+    const result = await runSingleShot(context, model, apiKey, abortController.signal);
+    singleShotMessage = result.message;
+
+    for (const change of result.changes) {
+      if (change.action === "delete") {
+        const id = change.id;
+        if (!id) continue;
+        const dir = change.scope === "global" ? globalInstinctsDir : projectInstinctsDir;
+        const filePath = join(dir, `${id}.md`);
+        if (existsSync(filePath)) {
+          unlinkSync(filePath);
+          instinctCounts.deleted++;
+        }
+      } else {
+        // create or update
+        const existing = allInstincts.find((i) => i.id === change.instinct?.id) ?? null;
+        const instinct = buildInstinctFromChange(change, existing, project.id);
+        if (!instinct) continue;
+
+        const dir = instinct.scope === "global" ? globalInstinctsDir : projectInstinctsDir;
+        saveInstinct(instinct, dir);
+
+        if (change.action === "create") {
+          instinctCounts.created++;
+        } else {
+          instinctCounts.updated++;
+        }
+      }
+    }
   } finally {
-    session.dispose();
+    clearTimeout(timeoutHandle);
   }
 
-  // Collect stats after session completes
-  const sessionStats = session.getSessionStats();
+  const usage = singleShotMessage!.usage;
   const durationMs = Date.now() - startTime;
 
   const stats: ProjectRunStats = {
     project_id: project.id,
     project_name: project.name,
     duration_ms: durationMs,
-    observations_processed: newObsLines.length,
+    observations_processed: rawLineCount,
     observations_total: obsCount,
     instincts_created: instinctCounts.created,
     instincts_updated: instinctCounts.updated,
     instincts_deleted: instinctCounts.deleted,
-    tokens_input: sessionStats.tokens.input,
-    tokens_output: sessionStats.tokens.output,
-    tokens_cache_read: sessionStats.tokens.cacheRead,
-    tokens_cache_write: sessionStats.tokens.cacheWrite,
-    tokens_total: sessionStats.tokens.total,
-    cost_usd: sessionStats.cost,
+    tokens_input: usage.input,
+    tokens_output: usage.output,
+    tokens_cache_read: usage.cacheRead,
+    tokens_cache_write: usage.cacheWrite,
+    tokens_total: usage.totalTokens,
+    cost_usd: usage.cost.total,
     model: modelId,
   };
 
@@ -420,7 +379,6 @@ async function main(): Promise<void> {
 
 main().catch((err) => {
   releaseLock(getBaseDir());
-  // Last-resort logging - config may not have loaded
   const logger = new AnalyzeLogger();
   logger.error("Fatal error", err);
   process.exit(1);

package/src/instinct-tools.ts

@@ -72,6 +72,9 @@ const WriteParams = Type.Object({
 
 const DeleteParams = Type.Object({
   id: Type.String({ description: "Instinct ID to delete" }),
+  scope: Type.Optional(StringEnum(["project", "global"] as const, {
+    description: "Target scope. If omitted, falls back to priority order (project first, then global).",
+  })),
 });
 
 const MergeParams = Type.Object({
@@ -85,7 +88,14 @@ const MergeParams = Type.Object({
     scope: StringEnum(["project", "global"] as const),
     evidence: Type.Optional(Type.Array(Type.String())),
   }),
-  delete_ids: Type.Array(Type.String(), { description: "IDs of source instincts to remove after merge" }),
+  delete_ids: Type.Array(Type.String(), { description: "IDs of source instincts to remove after merge (uses priority lookup)" }),
+  delete_scoped_ids: Type.Optional(Type.Array(
+    Type.Object({
+      id: Type.String({ description: "Instinct ID" }),
+      scope: StringEnum(["project", "global"] as const, { description: "Scope of the copy to delete" }),
+    }),
+    { description: "Scope-aware deletions: [{id, scope}] to target a specific copy" }
+  )),
 });
 
 export type InstinctListInput = Static<typeof ListParams>;
@@ -247,6 +257,22 @@ export function createInstinctDeleteTool(
       _onUpdate: unknown,
       _ctx: unknown
     ) {
+      if (params.scope) {
+        const dir = getInstinctsDir(params.scope, projectId, baseDir);
+        if (!dir) {
+          throw new Error(`Cannot target project scope: no project detected`);
+        }
+        const path = join(dir, `${params.id}.md`);
+        if (!existsSync(path)) {
+          throw new Error(`Instinct not found: ${params.id} in ${params.scope} scope`);
+        }
+        unlinkSync(path);
+        return {
+          content: [{ type: "text" as const, text: `Deleted instinct: ${params.id} (${params.scope}-scoped)` }],
+          details: { id: params.id, scope: params.scope },
+        };
+      }
+
       const found = findInstinctFile(params.id, projectId, baseDir);
       if (!found) {
         throw new Error(`Instinct not found: ${params.id}`);
@@ -311,6 +337,21 @@ export function createInstinctMergeTool(
         }
       }
 
+      for (const { id, scope } of params.delete_scoped_ids ?? []) {
+        // Skip only when both ID and scope match the merged result (already written above)
+        if (id === merged.id && scope === merged.scope) continue;
+        const dir = getInstinctsDir(scope, projectId, baseDir);
+        if (!dir) {
+          throw new Error(`Cannot target project scope: no project detected`);
+        }
+        const path = join(dir, `${id}.md`);
+        if (!existsSync(path)) {
+          throw new Error(`Instinct not found: ${id} in ${scope} scope`);
+        }
+        unlinkSync(path);
+        deleted.push(`${id}(${scope})`);
+      }
+
       return {
         content: [{
           type: "text" as const,

package/src/observation-preprocessor.ts

@@ -0,0 +1,48 @@
+/**
+ * Observation preprocessing for cost reduction.
+ *
+ * Strips high-volume, low-signal data from raw observation events before
+ * sending to the LLM analyzer. Reduces context size by ~80% on typical sessions.
+ *
+ * Rules:
+ * - turn_start  → DROP (no information not already in turn_end)
+ * - tool_start  → DROP (tool name + sequence captured by tool_complete)
+ * - tool_complete, is_error: false → KEEP, strip output field
+ * - tool_complete, is_error: true  → KEEP as-is (error message needed)
+ * - all others  → KEEP as-is
+ */
+import type { Observation } from "./types.js";
+
+/**
+ * Preprocess a single observation.
+ * Returns null if the observation should be dropped entirely.
+ * Returns a new (immutable) observation with large fields stripped if applicable.
+ */
+export function preprocessObservation(obs: Observation): Observation | null {
+  if (obs.event === "turn_start" || obs.event === "tool_start") {
+    return null;
+  }
+
+  if (obs.event === "tool_complete" && !obs.is_error) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { output: _, ...stripped } = obs;
+    return stripped as Observation;
+  }
+
+  return obs;
+}
+
+/**
+ * Preprocess an array of raw observations.
+ * Drops nulls and returns only the meaningful events.
+ */
+export function preprocessObservations(observations: Observation[]): Observation[] {
+  const result: Observation[] = [];
+  for (const obs of observations) {
+    const processed = preprocessObservation(obs);
+    if (processed !== null) {
+      result.push(processed);
+    }
+  }
+  return result;
+}

package/src/prompts/analyzer-system-single-shot.ts

@@ -0,0 +1,123 @@
+/**
+ * System prompt for the single-shot (non-agentic) background analyzer.
+ * Instructs the model to return a JSON change-set instead of using tool calls.
+ */
+export function buildSingleShotSystemPrompt(): string {
+  return `You are a coding behavior analyst. Your job is to read session observations
+and produce a JSON change-set to create or update instinct files that capture reusable coding patterns.
+
+## Output Format
+
+Return ONLY a valid JSON object (no prose, no markdown fences) with this structure:
+
+{
+  "changes": [
+    {
+      "action": "create",
+      "instinct": {
+        "id": "kebab-case-id",
+        "title": "Short title",
+        "trigger": "When this should activate",
+        "action": "What the agent should do (verb phrase)",
+        "confidence": 0.5,
+        "domain": "typescript",
+        "scope": "project",
+        "observation_count": 3,
+        "confirmed_count": 0,
+        "contradicted_count": 0,
+        "inactive_count": 0,
+        "evidence": ["brief note 1", "brief note 2"]
+      }
+    },
+    {
+      "action": "update",
+      "instinct": { "...same fields as create..." }
+    },
+    {
+      "action": "delete",
+      "id": "instinct-id-to-delete",
+      "scope": "project"
+    }
+  ]
+}
+
+Return { "changes": [] } if no changes are needed.
+
+## Pattern Detection Heuristics
+
+Analyze observations for these categories:
+
+### User Corrections
+- User rephrases a request after an agent response
+- User explicitly rejects an approach
+- Trigger: the corrected behavior; Action: the preferred approach
+
+### Error Resolutions
+- Tool call returns is_error: true followed by a successful retry
+- Trigger: the error condition; Action: the proven resolution
+
+### Repeated Workflows
+- Same sequence of tool calls appears 3+ times
+- Trigger: the workflow start condition; Action: the efficient path
+
+### Tool Preferences
+- Agent consistently uses one tool over alternatives
+- Trigger: the task type; Action: the preferred tool and parameters
+
+### Anti-Patterns
+- Actions that consistently lead to errors or user corrections
+- Trigger: the bad pattern situation; Action: what to do instead
+
+### Turn Structure
+- turn_end events summarize turns: tool_count and error_count
+- High error_count turns suggest inefficient approaches
+
+### Context Pressure
+- session_compact events signal context window pressure
+
+### User Shell Commands
+- user_bash events capture manual shell commands the user runs
+- Repeated commands after agent actions reveal verification patterns
+
+### Model Preferences
+- model_select events track when users switch models
+
+## Feedback Analysis
+
+Each observation may include an active_instincts field listing instinct IDs
+that were injected into the agent's system prompt before that turn.
+
+Use this to update existing instinct confidence scores:
+- Confirmed (+0.05): instinct was active and agent followed guidance without correction
+- Contradicted (-0.15): instinct was active but user corrected the agent
+- Inactive (no change): instinct was injected but trigger never arose
+
+When updating, increment the corresponding count field and recalculate confidence.
+
+## Confidence Scoring Rules
+
+### Initial Confidence (new instincts)
+- 1-2 observations  -> 0.3
+- 3-5 observations  -> 0.5
+- 6-10 observations -> 0.7
+- 11+ observations  -> 0.85
+
+### Clamping
+- Always clamp to [0.1, 0.9]
+
+## Scope Decision Guide
+
+Use project scope when the pattern is specific to this project's tech stack or conventions.
+Use global scope when the pattern applies universally to any coding session.
+When in doubt, prefer project scope.
+
+## Conservativeness Rules
+
+1. Only create a new instinct with 3+ clear independent observations supporting the pattern.
+2. No code snippets in the action field - plain language only.
+3. Each instinct must have one well-defined trigger.
+4. New instincts from observation data alone are capped at 0.85 confidence.
+5. Check existing instincts (provided in the user message) for duplicates before creating. Update instead.
+6. Write actions as clear instructions starting with a verb.
+7. Be skeptical of outliers - patterns seen only in unusual circumstances should not become instincts.`;
+}

package/src/prompts/analyzer-user-single-shot.ts

@@ -0,0 +1,88 @@
+/**
+ * User prompt builder for the single-shot background analyzer.
+ * Includes current instincts inline (no tool calls needed) and filtered observations.
+ */
+import type { InstalledSkill, Instinct, ProjectEntry } from "../types.js";
+import { formatInstinctsForPrompt } from "../cli/analyze-single-shot.js";
+
+export interface SingleShotPromptOptions {
+  agentsMdProject?: string | null;
+  agentsMdGlobal?: string | null;
+  installedSkills?: InstalledSkill[];
+}
+
+/**
+ * Builds the user prompt for the single-shot analyzer.
+ * Embeds all current instincts inline so the model has full context
+ * without making any tool calls.
+ *
+ * @param project          - Project metadata
+ * @param existingInstincts - All current instincts (project + global)
+ * @param observationLines  - Preprocessed observation lines (JSONL strings)
+ * @param options           - Optional AGENTS.md content and installed skills
+ */
+export function buildSingleShotUserPrompt(
+  project: ProjectEntry,
+  existingInstincts: Instinct[],
+  observationLines: string[],
+  options: SingleShotPromptOptions = {}
+): string {
+  const { agentsMdProject = null, agentsMdGlobal = null, installedSkills = [] } = options;
+
+  const observationBlock =
+    observationLines.length > 0
+      ? observationLines.join("\n")
+      : "(no observations recorded yet)";
+
+  const instinctBlock = formatInstinctsForPrompt(existingInstincts);
+
+  const parts: string[] = [
+    "## Project Context",
+    "",
+    `project_id: ${project.id}`,
+    `project_name: ${project.name}`,
+    "",
+    "## Existing Instincts",
+    "",
+    instinctBlock,
+    "",
+    "## New Observations (preprocessed)",
+    "",
+    "```",
+    observationBlock,
+    "```",
+  ];
+
+  if (agentsMdProject != null || agentsMdGlobal != null) {
+    parts.push("", "## Existing Guidelines", "");
+    if (agentsMdProject != null) {
+      parts.push("### Project AGENTS.md", "", agentsMdProject, "");
+    }
+    if (agentsMdGlobal != null) {
+      parts.push("### Global AGENTS.md", "", agentsMdGlobal, "");
+    }
+  }
+
+  if (installedSkills.length > 0) {
+    parts.push("", "## Installed Skills", "");
+    for (const skill of installedSkills) {
+      parts.push(`- **${skill.name}**: ${skill.description}`);
+    }
+    parts.push("");
+  }
+
+  parts.push(
+    "",
+    "## Instructions",
+    "",
+    "1. Review the existing instincts above.",
+    "2. Analyze the new observations for patterns per the system prompt rules.",
+    "3. Return a JSON change-set: create new instincts, update existing ones, or delete obsolete ones.",
+    "4. Apply feedback analysis using the active_instincts field in each observation.",
+    "5. Passive confidence decay has already been applied before this analysis.",
+    "",
+    "Return ONLY the JSON object. No prose, no markdown fences."
+  );
+
+  return parts.join("\n");
+}

package/src/prompts/analyzer-user.ts

@@ -5,7 +5,8 @@
  */
 
 import { existsSync, readFileSync } from "node:fs";
-import type { InstalledSkill, ProjectEntry } from "../types.js";
+import type { InstalledSkill, Observation, ProjectEntry } from "../types.js";
+import { preprocessObservations } from "../observation-preprocessor.js";
 
 /** Maximum number of observation lines to include in analysis. */
 const MAX_TAIL_ENTRIES = 500;
@@ -35,15 +36,18 @@ export function tailObservations(
 export interface TailSinceResult {
   lines: string[];
   totalLineCount: number;
+  /** Number of raw new lines before preprocessing. */
+  rawLineCount: number;
 }
 
 export function tailObservationsSince(
   observationsPath: string,
   sinceLineCount: number,
-  maxEntries = MAX_TAIL_ENTRIES
+  maxEntries = MAX_TAIL_ENTRIES,
+  preprocess = true
 ): TailSinceResult {
   if (!existsSync(observationsPath)) {
-    return { lines: [], totalLineCount: 0 };
+    return { lines: [], totalLineCount: 0, rawLineCount: 0 };
   }
   const content = readFileSync(observationsPath, "utf-8");
   const allLines = content
@@ -55,12 +59,26 @@ export function tailObservationsSince(
 
   // If file was archived/reset (fewer lines than cursor), treat as fresh
   const effectiveSince = totalLineCount < sinceLineCount ? 0 : sinceLineCount;
-  const newLines = allLines.slice(effectiveSince);
+  const newLines = allLines.slice(effectiveSince).slice(-maxEntries);
+  const rawLineCount = newLines.length;
+
+  if (!preprocess) {
+    return { lines: newLines, totalLineCount, rawLineCount };
+  }
+
+  const parsed: Observation[] = [];
+  for (const line of newLines) {
+    try {
+      parsed.push(JSON.parse(line) as Observation);
+    } catch {
+      // skip malformed lines
+    }
+  }
+
+  const filtered = preprocessObservations(parsed);
+  const lines = filtered.map((obs) => JSON.stringify(obs));
 
-  return {
-    lines: newLines.slice(-maxEntries),
-    totalLineCount,
-  };
+  return { lines, totalLineCount, rawLineCount };
 }
 
 export interface AnalyzerUserPromptOptions {