pi-continuous-learning 0.7.0 → 0.8.0

package/src/analysis-event-log.ts

@@ -0,0 +1,171 @@
+/**
+ * Append-only analysis event log with atomic rename for safe consumption.
+ *
+ * The background analyzer appends events to `analysis-events.jsonl`.
+ * The extension consumes events by atomically renaming the file to
+ * `.consumed`, reading it, then deleting it. On POSIX, rename is atomic -
+ * any in-flight appends follow the inode to the renamed file.
+ *
+ * Multiple analyzer runs can append before the extension reads. No events
+ * are lost because each run only appends; the file is never truncated by
+ * the analyzer.
+ */
+
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { getProjectDir } from "./storage.js";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const EVENTS_FILENAME = "analysis-events.jsonl";
+const CONSUMED_FILENAME = "analysis-events.consumed";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface InstinctChangeSummary {
+  readonly id: string;
+  readonly title: string;
+  readonly scope: "project" | "global";
+  readonly trigger?: string;
+  readonly action?: string;
+  readonly confidence_delta?: number;
+}
+
+export interface AnalysisEvent {
+  readonly timestamp: string;
+  readonly project_id: string;
+  readonly project_name: string;
+  readonly created: readonly InstinctChangeSummary[];
+  readonly updated: readonly InstinctChangeSummary[];
+  readonly deleted: readonly InstinctChangeSummary[];
+}
+
+// ---------------------------------------------------------------------------
+// Paths
+// ---------------------------------------------------------------------------
+
+export function getEventsPath(projectId: string, baseDir?: string): string {
+  return join(getProjectDir(projectId, baseDir), EVENTS_FILENAME);
+}
+
+export function getConsumedPath(projectId: string, baseDir?: string): string {
+  return join(getProjectDir(projectId, baseDir), CONSUMED_FILENAME);
+}
+
+// ---------------------------------------------------------------------------
+// Write (analyzer side)
+// ---------------------------------------------------------------------------
+
+/**
+ * Appends an analysis event to the project's event log.
+ * Skips writing if nothing changed (all arrays empty).
+ * Creates the parent directory if needed.
+ */
+export function appendAnalysisEvent(event: AnalysisEvent, baseDir?: string): void {
+  if (
+    event.created.length === 0 &&
+    event.updated.length === 0 &&
+    event.deleted.length === 0
+  ) {
+    return;
+  }
+
+  const eventsPath = getEventsPath(event.project_id, baseDir);
+  mkdirSync(dirname(eventsPath), { recursive: true });
+  appendFileSync(eventsPath, JSON.stringify(event) + "\n", "utf-8");
+}
+
+// ---------------------------------------------------------------------------
+// Read and clear (extension side)
+// ---------------------------------------------------------------------------
+
+/**
+ * Atomically consumes all pending analysis events for a project.
+ *
+ * Strategy:
+ * 1. Check for orphaned `.consumed` file from a prior crash - read it first
+ * 2. Rename `analysis-events.jsonl` to `.consumed` (atomic on POSIX)
+ * 3. Read and parse all lines from `.consumed`
+ * 4. Delete `.consumed`
+ *
+ * Returns an empty array if no events exist or rename fails (e.g. file
+ * doesn't exist, or another consumer raced us).
+ */
+export function consumeAnalysisEvents(
+  projectId: string,
+  baseDir?: string
+): readonly AnalysisEvent[] {
+  const eventsPath = getEventsPath(projectId, baseDir);
+  const consumedPath = getConsumedPath(projectId, baseDir);
+
+  const allEvents: AnalysisEvent[] = [];
+
+  // Step 1: recover orphaned consumed file from prior crash
+  if (existsSync(consumedPath)) {
+    allEvents.push(...parseEventsFile(consumedPath));
+    safeUnlink(consumedPath);
+  }
+
+  // Step 2: atomically rename the events file
+  if (existsSync(eventsPath)) {
+    try {
+      renameSync(eventsPath, consumedPath);
+    } catch {
+      // Rename failed (race with another consumer, or OS issue).
+      // Return whatever we recovered from step 1.
+      return allEvents;
+    }
+
+    // Step 3: read the renamed file
+    allEvents.push(...parseEventsFile(consumedPath));
+
+    // Step 4: delete consumed file
+    safeUnlink(consumedPath);
+  }
+
+  return allEvents;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function parseEventsFile(filePath: string): AnalysisEvent[] {
+  const events: AnalysisEvent[] = [];
+
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const lines = content.split("\n").filter((line) => line.trim().length > 0);
+
+    for (const line of lines) {
+      try {
+        events.push(JSON.parse(line) as AnalysisEvent);
+      } catch {
+        // Skip malformed lines - don't lose other events
+      }
+    }
+  } catch {
+    // File read failed - return empty
+  }
+
+  return events;
+}
+
+function safeUnlink(filePath: string): void {
+  try {
+    if (existsSync(filePath)) unlinkSync(filePath);
+  } catch {
+    // Best effort cleanup
+  }
+}

package/src/analysis-notification.ts

@@ -0,0 +1,79 @@
+/**
+ * Extension-side notification for analysis events.
+ *
+ * On `before_agent_start`, consumes pending analysis events and shows
+ * a brief one-line notification summarizing instinct changes since the
+ * last session interaction.
+ */
+
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import {
+  consumeAnalysisEvents,
+  type AnalysisEvent,
+} from "./analysis-event-log.js";
+
+// ---------------------------------------------------------------------------
+// Formatting
+// ---------------------------------------------------------------------------
+
+/**
+ * Aggregates multiple analysis events into a single summary line.
+ * Returns null when no changes occurred.
+ */
+export function formatNotification(events: readonly AnalysisEvent[]): string | null {
+  if (events.length === 0) return null;
+
+  let created = 0;
+  let updated = 0;
+  let deleted = 0;
+  const createdIds: string[] = [];
+
+  for (const event of events) {
+    created += event.created.length;
+    updated += event.updated.length;
+    deleted += event.deleted.length;
+    for (const c of event.created) {
+      createdIds.push(c.id);
+    }
+  }
+
+  if (created === 0 && updated === 0 && deleted === 0) return null;
+
+  const parts: string[] = [];
+  if (created > 0) {
+    const idList = createdIds.slice(0, 3).join(", ");
+    const suffix = createdIds.length > 3 ? ", ..." : "";
+    parts.push(`+${created} new (${idList}${suffix})`);
+  }
+  if (updated > 0) {
+    parts.push(`${updated} updated`);
+  }
+  if (deleted > 0) {
+    parts.push(`${deleted} deleted`);
+  }
+
+  return `[instincts] Background analysis: ${parts.join(", ")}`;
+}
+
+// ---------------------------------------------------------------------------
+// Handler
+// ---------------------------------------------------------------------------
+
+/**
+ * Checks for pending analysis events and shows a notification if any exist.
+ * Safe to call on every `before_agent_start` - no-ops when there's nothing.
+ */
+export function checkAnalysisNotifications(
+  ctx: ExtensionContext,
+  projectId: string | null,
+  baseDir?: string
+): void {
+  if (!projectId) return;
+
+  const events = consumeAnalysisEvents(projectId, baseDir);
+  const message = formatNotification(events);
+
+  if (message) {
+    ctx.ui.notify(message, "info");
+  }
+}

package/src/cli/analyze-single-shot.ts

@@ -9,7 +9,11 @@ import type { AssistantMessage, Context } from "@mariozechner/pi-ai";
 import { complete } from "@mariozechner/pi-ai";
 import type { Instinct } from "../types.js";
 import { serializeInstinct } from "../instinct-parser.js";
+
+/** Chars-per-token heuristic for prompt size estimation. */
+const CHARS_PER_TOKEN = 4;
 import { validateInstinct, findSimilarInstinct } from "../instinct-validator.js";
+import { confirmationDelta } from "../confidence.js";
 
 export interface InstinctChangePayload {
   id: string;
@@ -24,6 +28,7 @@ export interface InstinctChangePayload {
   contradicted_count?: number;
   inactive_count?: number;
   evidence?: string[];
+  last_confirmed_session?: string;
 }
 
 export interface InstinctChange {
@@ -117,12 +122,57 @@ export function buildInstinctFromChange(
 
   const now = new Date().toISOString();
 
+  // For updates, recompute confidence client-side to enforce:
+  // 1. Per-session deduplication: only one confirmation per unique session_id
+  // 2. Diminishing returns: each additional confirmation yields a smaller delta
+  let resolvedConfidence: number;
+  let resolvedConfirmedCount = payload.confirmed_count ?? existing?.confirmed_count ?? 0;
+  let resolvedLastConfirmedSession = payload.last_confirmed_session ?? existing?.last_confirmed_session;
+
+  if (change.action === "update" && existing !== null) {
+    const prevConfirmedCount = existing.confirmed_count;
+    const newConfirmedCount = payload.confirmed_count ?? prevConfirmedCount;
+    const contradictionsAdded = Math.max(
+      0,
+      (payload.contradicted_count ?? 0) - existing.contradicted_count,
+    );
+
+    // Detect whether the LLM intends to add a confirmation
+    const wantsToConfirm = newConfirmedCount > prevConfirmedCount;
+
+    // Session dedup: reject the confirmation if the confirming session is the
+    // same as the one that last confirmed this instinct.
+    const sessionDuplicate =
+      wantsToConfirm &&
+      resolvedLastConfirmedSession !== undefined &&
+      payload.last_confirmed_session !== undefined &&
+      payload.last_confirmed_session === existing.last_confirmed_session;
+
+    if (sessionDuplicate) {
+      // Revert to existing count - this session already confirmed the instinct
+      resolvedConfirmedCount = prevConfirmedCount;
+    }
+
+    // Recompute confidence from existing + explicit deltas (don't trust LLM arithmetic)
+    resolvedConfidence = existing.confidence;
+    if (wantsToConfirm && !sessionDuplicate) {
+      resolvedConfidence += confirmationDelta(prevConfirmedCount);
+    }
+    if (contradictionsAdded > 0) {
+      resolvedConfidence -= 0.15 * contradictionsAdded;
+    }
+    resolvedConfidence = Math.max(0.1, Math.min(0.9, resolvedConfidence));
+  } else {
+    // For creates, trust the LLM's initial confidence (no prior state to base delta on)
+    resolvedConfidence = Math.max(0.1, Math.min(0.9, payload.confidence));
+  }
+
   return {
     id: payload.id,
     title: payload.title,
     trigger: payload.trigger,
     action: payload.action,
-    confidence: Math.max(0.1, Math.min(0.9, payload.confidence)),
+    confidence: resolvedConfidence,
     domain: payload.domain,
     scope: payload.scope,
     source: "personal",
@@ -130,15 +180,61 @@ export function buildInstinctFromChange(
     created_at: existing?.created_at ?? now,
     updated_at: now,
     observation_count: payload.observation_count ?? 1,
-    confirmed_count: payload.confirmed_count ?? 0,
+    confirmed_count: resolvedConfirmedCount,
     contradicted_count: payload.contradicted_count ?? 0,
     inactive_count: payload.inactive_count ?? 0,
     ...(payload.evidence !== undefined ? { evidence: payload.evidence } : {}),
+    ...(resolvedLastConfirmedSession !== undefined
+      ? { last_confirmed_session: resolvedLastConfirmedSession }
+      : {}),
   };
 }
 
+/**
+ * Returns days elapsed since the given ISO 8601 date string.
+ */
+function daysSince(dateStr: string): number {
+  const ms = Date.now() - new Date(dateStr).getTime();
+  return Math.max(0, Math.floor(ms / (1000 * 60 * 60 * 24)));
+}
+
+/**
+ * Formats existing instincts as a compact JSON array for inline context.
+ * Reduces token usage by ~70% compared to full YAML+markdown serialization.
+ * Includes only the fields the analyzer needs to make decisions.
+ */
+export function formatInstinctsCompact(instincts: Instinct[]): string {
+  if (instincts.length === 0) {
+    return "[]";
+  }
+  const summaries = instincts.map((i) => ({
+    id: i.id,
+    trigger: i.trigger,
+    action: i.action,
+    confidence: i.confidence,
+    domain: i.domain,
+    scope: i.scope,
+    confirmed: i.confirmed_count,
+    contradicted: i.contradicted_count,
+    inactive: i.inactive_count,
+    age_days: daysSince(i.created_at),
+    ...(i.last_confirmed_session !== undefined
+      ? { last_confirmed_session: i.last_confirmed_session }
+      : {}),
+  }));
+  return JSON.stringify(summaries);
+}
+
+/**
+ * Estimates the token count of a text string using a chars/token heuristic.
+ */
+export function estimateTokens(text: string): number {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+
 /**
  * Formats existing instincts as serialized markdown blocks for inline context.
+ * @deprecated Use formatInstinctsCompact for lower token usage.
  */
 export function formatInstinctsForPrompt(instincts: Instinct[]): string {
   if (instincts.length === 0) {

package/src/cli/analyze.ts

@@ -6,6 +6,7 @@ import {
   writeFileSync,
   unlinkSync,
 } from "node:fs";
+import { createHash } from "node:crypto";
 import { join } from "node:path";
 import { AuthStorage } from "@mariozechner/pi-coding-agent";
 import { getModel } from "@mariozechner/pi-ai";
@@ -29,7 +30,14 @@ import { buildSingleShotUserPrompt } from "../prompts/analyzer-user-single-shot.
 import {
   runSingleShot,
   buildInstinctFromChange,
+  estimateTokens,
 } from "./analyze-single-shot.js";
+import { isLowSignalBatch } from "../observation-signal.js";
+import {
+  appendAnalysisEvent,
+  type InstinctChangeSummary,
+  type AnalysisEvent,
+} from "../analysis-event-log.js";
 import {
   loadProjectInstincts,
   loadGlobalInstincts,
@@ -107,9 +115,31 @@ function startGlobalTimeout(timeoutMs: number, logger: AnalyzeLogger): void {
 // Per-project analysis
 // ---------------------------------------------------------------------------
 
+/** Max estimated tokens before fallback strategies are applied. */
+const PROMPT_TOKEN_BUDGET = 40_000;
+
 interface ProjectMeta {
   last_analyzed_at?: string;
   last_observation_line_count?: number;
+  /** SHA-256 hash of the last AGENTS.md content sent for this project (project-level file). */
+  agents_md_project_hash?: string;
+  /** SHA-256 hash of the last AGENTS.md content sent (global file). */
+  agents_md_global_hash?: string;
+}
+
+function hashContent(content: string): string {
+  return createHash("sha256").update(content).digest("hex");
+}
+
+/**
+ * Truncates AGENTS.md content to section headers only (lines starting with #).
+ * Used as a fallback when the prompt is over the token budget.
+ */
+function truncateAgentsMdToHeaders(content: string): string {
+  return content
+    .split("\n")
+    .filter((line) => line.startsWith("#"))
+    .join("\n");
 }
 
 function loadProjectsRegistry(baseDir: string): Record<string, ProjectEntry> {
@@ -179,6 +209,10 @@ async function analyzeProject(
     return { ran: false, skippedReason: "no new observation lines after preprocessing" };
   }
 
+  if (isLowSignalBatch(newObsLines)) {
+    return { ran: false, skippedReason: "low-signal batch (no errors, corrections, or user redirections)" };
+  }
+
   const obsCount = countObservations(project.id, baseDir);
   if (obsCount < config.min_observations_to_analyze) {
     return { ran: false, skippedReason: `below threshold (${obsCount}/${config.min_observations_to_analyze})` };
@@ -195,8 +229,21 @@ async function analyzeProject(
   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"));
+  // Load AGENTS.md, skipping if content hash is unchanged since last run.
+  const rawAgentsMdProject = readAgentsMd(join(project.root, "AGENTS.md"));
+  const rawAgentsMdGlobal = readAgentsMd(join(homedir(), ".pi", "agent", "AGENTS.md"));
+
+  const projectMdHash = rawAgentsMdProject ? hashContent(rawAgentsMdProject) : null;
+  const globalMdHash = rawAgentsMdGlobal ? hashContent(rawAgentsMdGlobal) : null;
+
+  const agentsMdProject =
+    rawAgentsMdProject && projectMdHash !== meta.agents_md_project_hash
+      ? rawAgentsMdProject
+      : null;
+  const agentsMdGlobal =
+    rawAgentsMdGlobal && globalMdHash !== meta.agents_md_global_hash
+      ? rawAgentsMdGlobal
+      : null;
 
   let installedSkills: InstalledSkill[] = [];
   try {
@@ -210,9 +257,51 @@ async function analyzeProject(
     // Skills loading is best-effort - continue without them
   }
 
-  const userPrompt = buildSingleShotUserPrompt(project, allInstincts, newObsLines, {
-    agentsMdProject,
-    agentsMdGlobal,
+  let promptObsLines = newObsLines;
+  let promptAgentsMdProject = agentsMdProject;
+  let promptAgentsMdGlobal = agentsMdGlobal;
+
+  const userPrompt = buildSingleShotUserPrompt(project, allInstincts, promptObsLines, {
+    agentsMdProject: promptAgentsMdProject,
+    agentsMdGlobal: promptAgentsMdGlobal,
+    installedSkills,
+  });
+
+  // Estimate token budget and apply fallbacks if over limit.
+  const systemPromptTokens = estimateTokens(buildSingleShotSystemPrompt());
+  let estimatedTotal = systemPromptTokens + estimateTokens(userPrompt);
+
+  if (estimatedTotal > PROMPT_TOKEN_BUDGET) {
+    logger.warn(
+      `Prompt over budget (${estimatedTotal} est. tokens > ${PROMPT_TOKEN_BUDGET}). Applying fallbacks.`
+    );
+
+    // Fallback 1: truncate AGENTS.md to headers only.
+    if (promptAgentsMdProject) {
+      promptAgentsMdProject = truncateAgentsMdToHeaders(promptAgentsMdProject);
+    }
+    if (promptAgentsMdGlobal) {
+      promptAgentsMdGlobal = truncateAgentsMdToHeaders(promptAgentsMdGlobal);
+    }
+
+    // Fallback 2: reduce observation lines to fit budget.
+    // Use binary-search-like reduction: keep halving until under budget.
+    while (promptObsLines.length > 1) {
+      const trimmedPrompt = buildSingleShotUserPrompt(
+        project,
+        allInstincts,
+        promptObsLines,
+        { agentsMdProject: promptAgentsMdProject, agentsMdGlobal: promptAgentsMdGlobal, installedSkills }
+      );
+      estimatedTotal = systemPromptTokens + estimateTokens(trimmedPrompt);
+      if (estimatedTotal <= PROMPT_TOKEN_BUDGET) break;
+      promptObsLines = promptObsLines.slice(Math.floor(promptObsLines.length / 2));
+    }
+  }
+
+  const finalUserPrompt = buildSingleShotUserPrompt(project, allInstincts, promptObsLines, {
+    agentsMdProject: promptAgentsMdProject,
+    agentsMdGlobal: promptAgentsMdGlobal,
     installedSkills,
   });
 
@@ -228,7 +317,7 @@ async function analyzeProject(
   const context = {
     systemPrompt: buildSingleShotSystemPrompt(),
     messages: [
-      { role: "user" as const, content: userPrompt, timestamp: Date.now() },
+      { role: "user" as const, content: finalUserPrompt, timestamp: Date.now() },
     ],
   };
 
@@ -237,6 +326,9 @@ async function analyzeProject(
   const timeoutHandle = setTimeout(() => abortController.abort(), timeoutMs);
 
   const instinctCounts = { created: 0, updated: 0, deleted: 0 };
+  const createdSummaries: InstinctChangeSummary[] = [];
+  const updatedSummaries: InstinctChangeSummary[] = [];
+  const deletedSummaries: InstinctChangeSummary[] = [];
   const projectInstinctsDir = getProjectInstinctsDir(project.id, "personal", baseDir);
   const globalInstinctsDir = getGlobalInstinctsDir("personal", baseDir);
 
@@ -258,6 +350,11 @@ async function analyzeProject(
         if (existsSync(filePath)) {
           unlinkSync(filePath);
           instinctCounts.deleted++;
+          deletedSummaries.push({
+            id,
+            title: id,
+            scope: change.scope ?? "project",
+          });
         }
       } else if (change.action === "create") {
         if (createsRemaining <= 0) continue; // rate limit reached
@@ -269,6 +366,13 @@ async function analyzeProject(
         saveInstinct(instinct, dir);
         instinctCounts.created++;
         createsRemaining--;
+        createdSummaries.push({
+          id: instinct.id,
+          title: instinct.title,
+          scope: instinct.scope,
+          trigger: instinct.trigger,
+          action: instinct.action,
+        });
       } else {
         // update
         const existing = allInstincts.find((i) => i.id === change.instinct?.id) ?? null;
@@ -278,6 +382,15 @@ async function analyzeProject(
         const dir = instinct.scope === "global" ? globalInstinctsDir : projectInstinctsDir;
         saveInstinct(instinct, dir);
         instinctCounts.updated++;
+        const delta = existing
+          ? instinct.confidence - existing.confidence
+          : undefined;
+        updatedSummaries.push({
+          id: instinct.id,
+          title: instinct.title,
+          scope: instinct.scope,
+          ...(delta !== undefined ? { confidence_delta: delta } : {}),
+        });
       }
     }
   } finally {
@@ -307,9 +420,27 @@ async function analyzeProject(
 
   logger.projectComplete(stats);
 
+  // Write analysis event for extension notification
+  const analysisEvent: AnalysisEvent = {
+    timestamp: new Date().toISOString(),
+    project_id: project.id,
+    project_name: project.name,
+    created: createdSummaries,
+    updated: updatedSummaries,
+    deleted: deletedSummaries,
+  };
+  appendAnalysisEvent(analysisEvent, baseDir);
+
   saveProjectMeta(
     project.id,
-    { ...meta, last_analyzed_at: new Date().toISOString(), last_observation_line_count: totalLineCount },
+    {
+      ...meta,
+      last_analyzed_at: new Date().toISOString(),
+      last_observation_line_count: totalLineCount,
+      // Update AGENTS.md hashes only when the content was actually sent.
+      ...(agentsMdProject && projectMdHash ? { agents_md_project_hash: projectMdHash } : {}),
+      ...(agentsMdGlobal && globalMdHash ? { agents_md_global_hash: globalMdHash } : {}),
+    },
     baseDir
   );
 

package/src/confidence.ts

@@ -21,10 +21,16 @@ const OBS_BRACKET_MED_MAX = 5;
 const OBS_BRACKET_HIGH_MAX = 10;
 
 // adjustConfidence deltas
-const DELTA_CONFIRMED = 0.05;
+// Confirmation uses diminishing returns to prevent runaway confidence on trivially easy-to-confirm instincts.
+const DELTA_CONFIRMED_TIER1 = 0.05; // 1st–3rd confirmation
+const DELTA_CONFIRMED_TIER2 = 0.03; // 4th–6th confirmation
+const DELTA_CONFIRMED_TIER3 = 0.01; // 7th+ confirmation
 const DELTA_CONTRADICTED = -0.15;
 const DELTA_INACTIVE = 0;
 
+const CONFIRMED_TIER1_MAX = 3;
+const CONFIRMED_TIER2_MAX = 6;
+
 // applyPassiveDecay
 // Increased from 0.02 to 0.05: at 0.5 confidence, reaches 0.1 in ~8 weeks instead of 20.
 const DECAY_PER_WEEK = 0.05;
@@ -36,6 +42,16 @@ const MS_PER_WEEK = 7 * 24 * 60 * 60 * 1000;
 
 export type FeedbackOutcome = "confirmed" | "contradicted" | "inactive";
 
+/**
+ * Returns the confirmation confidence delta using diminishing returns.
+ * Higher confirmed_count yields smaller increments to prevent runaway scores.
+ */
+export function confirmationDelta(confirmedCount: number): number {
+  if (confirmedCount <= CONFIRMED_TIER1_MAX) return DELTA_CONFIRMED_TIER1;
+  if (confirmedCount <= CONFIRMED_TIER2_MAX) return DELTA_CONFIRMED_TIER2;
+  return DELTA_CONFIRMED_TIER3;
+}
+
 export interface ConfidenceResult {
   confidence: number;
   flaggedForRemoval: boolean;
@@ -71,18 +87,28 @@ export function initialConfidence(observationCount: number): number {
 
 /**
  * Adjusts confidence based on a feedback outcome from the observer loop.
+ * For "confirmed" outcomes, applies diminishing returns based on how many
+ * times the instinct has already been confirmed (higher count = smaller delta).
  * Returns the clamped confidence and a flag indicating if removal is warranted.
+ *
+ * @param current       - Current confidence value
+ * @param outcome       - Feedback outcome type
+ * @param confirmedCount - Current confirmed_count (used for diminishing returns on confirmations)
  */
 export function adjustConfidence(
   current: number,
   outcome: FeedbackOutcome,
+  confirmedCount = 0,
 ): ConfidenceResult {
-  const deltas: Record<FeedbackOutcome, number> = {
-    confirmed: DELTA_CONFIRMED,
-    contradicted: DELTA_CONTRADICTED,
-    inactive: DELTA_INACTIVE,
-  };
-  const raw = current + deltas[outcome];
+  let delta: number;
+  if (outcome === "confirmed") {
+    delta = confirmationDelta(confirmedCount);
+  } else if (outcome === "contradicted") {
+    delta = DELTA_CONTRADICTED;
+  } else {
+    delta = DELTA_INACTIVE;
+  }
+  const raw = current + delta;
   return toResult(raw);
 }