pi-continuous-learning 0.7.0 → 0.9.0

package/src/consolidation.ts

@@ -0,0 +1,162 @@
+/**
+ * Pure consolidation gate logic for the "instinct-dream" holistic review.
+ *
+ * Determines whether enough time and sessions have elapsed since the last
+ * consolidation to justify a new pass. No I/O - all inputs are passed in.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getBaseDir } from "./storage.js";
+
+// ---------------------------------------------------------------------------
+// Constants (defaults - overridable via config)
+// ---------------------------------------------------------------------------
+
+/** Minimum days between consolidation runs. */
+export const DEFAULT_CONSOLIDATION_INTERVAL_DAYS = 7;
+
+/** Minimum distinct sessions since last consolidation. */
+export const DEFAULT_CONSOLIDATION_MIN_SESSIONS = 10;
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface ConsolidationMeta {
+  last_consolidation_at?: string; // ISO 8601
+  last_consolidation_session_count?: number;
+}
+
+export interface ConsolidationGateInput {
+  meta: ConsolidationMeta;
+  currentSessionCount: number;
+  now?: Date;
+  intervalDays?: number;
+  minSessions?: number;
+}
+
+export interface ConsolidationGateResult {
+  eligible: boolean;
+  reason: string;
+}
+
+// ---------------------------------------------------------------------------
+// Gate check (pure)
+// ---------------------------------------------------------------------------
+
+/**
+ * Determines whether a consolidation pass should run based on
+ * elapsed time and session count since the last consolidation.
+ *
+ * Both conditions must be met (dual-gate):
+ * 1. At least `intervalDays` since last consolidation
+ * 2. At least `minSessions` new sessions since last consolidation
+ */
+export function checkConsolidationGate(
+  input: ConsolidationGateInput
+): ConsolidationGateResult {
+  const {
+    meta,
+    currentSessionCount,
+    now = new Date(),
+    intervalDays = DEFAULT_CONSOLIDATION_INTERVAL_DAYS,
+    minSessions = DEFAULT_CONSOLIDATION_MIN_SESSIONS,
+  } = input;
+
+  // First run - no prior consolidation
+  if (!meta.last_consolidation_at) {
+    const sessionsSinceStart = currentSessionCount;
+    if (sessionsSinceStart < minSessions) {
+      return {
+        eligible: false,
+        reason: `only ${sessionsSinceStart} sessions recorded (need ${minSessions})`,
+      };
+    }
+    return { eligible: true, reason: "first consolidation run" };
+  }
+
+  const lastRun = new Date(meta.last_consolidation_at);
+  const daysSince = (now.getTime() - lastRun.getTime()) / (1000 * 60 * 60 * 24);
+
+  if (daysSince < intervalDays) {
+    return {
+      eligible: false,
+      reason: `only ${daysSince.toFixed(1)} days since last consolidation (need ${intervalDays})`,
+    };
+  }
+
+  const sessionsSinceLast =
+    currentSessionCount - (meta.last_consolidation_session_count ?? 0);
+
+  if (sessionsSinceLast < minSessions) {
+    return {
+      eligible: false,
+      reason: `only ${sessionsSinceLast} sessions since last consolidation (need ${minSessions})`,
+    };
+  }
+
+  return { eligible: true, reason: "gate conditions met" };
+}
+
+// ---------------------------------------------------------------------------
+// Session counting (from observations)
+// ---------------------------------------------------------------------------
+
+/**
+ * Counts distinct session IDs in a JSONL observations file.
+ * Scans all lines and extracts unique `"session":"..."` values.
+ */
+export function countDistinctSessions(obsPath: string): number {
+  if (!existsSync(obsPath)) return 0;
+
+  const content = readFileSync(obsPath, "utf-8");
+  const sessions = new Set<string>();
+
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    // Fast regex extraction avoids full JSON parse per line
+    const match = /"session"\s*:\s*"([^"]+)"/.exec(line);
+    if (match?.[1]) {
+      sessions.add(match[1]);
+    }
+  }
+
+  return sessions.size;
+}
+
+// ---------------------------------------------------------------------------
+// Consolidation meta persistence
+// ---------------------------------------------------------------------------
+
+const CONSOLIDATION_META_FILENAME = "consolidation.json";
+
+export function getConsolidationMetaPath(
+  projectId: string,
+  baseDir = getBaseDir()
+): string {
+  return join(baseDir, "projects", projectId, CONSOLIDATION_META_FILENAME);
+}
+
+export function loadConsolidationMeta(
+  projectId: string,
+  baseDir = getBaseDir()
+): ConsolidationMeta {
+  const metaPath = getConsolidationMetaPath(projectId, baseDir);
+  if (!existsSync(metaPath)) return {};
+  try {
+    return JSON.parse(readFileSync(metaPath, "utf-8")) as ConsolidationMeta;
+  } catch {
+    return {};
+  }
+}
+
+export function saveConsolidationMeta(
+  projectId: string,
+  meta: ConsolidationMeta,
+  baseDir = getBaseDir()
+): void {
+  const metaPath = getConsolidationMetaPath(projectId, baseDir);
+  mkdirSync(dirname(metaPath), { recursive: true });
+  writeFileSync(metaPath, JSON.stringify(meta, null, 2), "utf-8");
+}

package/src/index.ts

@@ -33,8 +33,10 @@ import { handleInstinctPromote, COMMAND_NAME as PROMOTE_CMD } from "./instinct-p
 import { handleInstinctEvolve, COMMAND_NAME as EVOLVE_CMD } from "./instinct-evolve.js";
 import { handleInstinctProjects, COMMAND_NAME as PROJECTS_CMD } from "./instinct-projects.js";
 import { handleInstinctGraduate, COMMAND_NAME as GRADUATE_CMD } from "./instinct-graduate.js";
+import { handleInstinctDream, COMMAND_NAME as DREAM_CMD } from "./instinct-dream.js";
 import { registerAllTools } from "./instinct-tools.js";
 import { logError } from "./error-logger.js";
+import { checkAnalysisNotifications } from "./analysis-notification.js";
 import type { Config, InstalledSkill, ProjectEntry } from "./types.js";
 
 export default function (pi: ExtensionAPI): void {
@@ -70,6 +72,7 @@ export default function (pi: ExtensionAPI): void {
     try {
       if (!project || !config) return;
       handleBeforeAgentStart(event, ctx, project);
+      checkAnalysisNotifications(ctx, project.id);
       return handleBeforeAgentStartInjection(event, ctx, config, project.id) ?? undefined;
     } catch (err) {
       logError(project?.id ?? null, "before_agent_start", err);
@@ -207,4 +210,18 @@ export default function (pi: ExtensionAPI): void {
         project?.root ?? null
       ),
   });
+
+  pi.registerCommand(DREAM_CMD, {
+    description: "Holistic consolidation review of all instincts (merge, deduplicate, resolve contradictions)",
+    handler: (args: string, ctx: ExtensionCommandContext) =>
+      handleInstinctDream(
+        args,
+        ctx,
+        pi,
+        project?.id,
+        undefined,
+        project?.root ?? null,
+        installedSkills
+      ),
+  });
 }

package/src/instinct-cleanup.ts

@@ -11,12 +11,13 @@
 import { unlinkSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import type { Instinct, Config } from "./types.js";
-import { listInstincts, invalidateCache } from "./instinct-store.js";
+import { listInstincts, saveInstinct, invalidateCache } from "./instinct-store.js";
 import {
   getBaseDir,
   getProjectInstinctsDir,
   getGlobalInstinctsDir,
 } from "./storage.js";
+import { findContradictions } from "./instinct-contradiction.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -124,9 +125,58 @@ export function enforceInstinctCap(dir: string, maxCount: number): number {
 // Result type
 // ---------------------------------------------------------------------------
 
+/**
+ * Flags the lower-confidence instinct in each contradictory pair.
+ * When confidence is equal, both are flagged.
+ * Already-flagged instincts are excluded from contradiction detection.
+ *
+ * @returns Number of instincts newly flagged.
+ */
+export function cleanupContradictions(dir: string): number {
+  const instincts = listInstincts(dir);
+  const matches = findContradictions(instincts);
+  if (matches.length === 0) return 0;
+
+  const toFlag = new Set<string>();
+
+  for (const match of matches) {
+    const { instinctA, instinctB } = match;
+    if (instinctA.confidence > instinctB.confidence) {
+      toFlag.add(instinctB.id);
+    } else if (instinctB.confidence > instinctA.confidence) {
+      toFlag.add(instinctA.id);
+    } else {
+      // Equal confidence - flag both for user review
+      toFlag.add(instinctA.id);
+      toFlag.add(instinctB.id);
+    }
+  }
+
+  let flagged = 0;
+  for (const instinct of instincts) {
+    if (toFlag.has(instinct.id)) {
+      const updated: Instinct = {
+        ...instinct,
+        flagged_for_removal: true,
+        updated_at: new Date().toISOString(),
+      };
+      saveInstinct(updated, dir);
+      flagged++;
+    }
+  }
+
+  if (flagged > 0) invalidateCache(dir);
+  return flagged;
+}
+
+// ---------------------------------------------------------------------------
+// Result type
+// ---------------------------------------------------------------------------
+
 export interface CleanupResult {
   flaggedDeleted: number;
   zeroConfirmedDeleted: number;
+  contradictionsFlagged: number;
   capDeleted: number;
   total: number;
 }
@@ -140,6 +190,11 @@ export interface CleanupResult {
  * Order: flagged → zero-confirmed → cap enforcement (cap runs last so it
  * accounts for deletions made by the earlier rules).
  */
+/**
+ * Runs all cleanup rules against a single directory.
+ * Order: flagged → zero-confirmed → contradictions → cap enforcement
+ * (cap runs last so it accounts for deletions/flags from earlier rules).
+ */
 export function cleanupDir(
   dir: string,
   config: Config,
@@ -150,9 +205,10 @@ export function cleanupDir(
     dir,
     config.instinct_ttl_days
   );
+  const contradictionsFlagged = cleanupContradictions(dir);
   const capDeleted = enforceInstinctCap(dir, maxCount);
-  const total = flaggedDeleted + zeroConfirmedDeleted + capDeleted;
-  return { flaggedDeleted, zeroConfirmedDeleted, capDeleted, total };
+  const total = flaggedDeleted + zeroConfirmedDeleted + contradictionsFlagged + capDeleted;
+  return { flaggedDeleted, zeroConfirmedDeleted, contradictionsFlagged, capDeleted, total };
 }
 
 /**
@@ -172,6 +228,7 @@ export function runCleanupPass(
   const result: CleanupResult = {
     flaggedDeleted: 0,
     zeroConfirmedDeleted: 0,
+    contradictionsFlagged: 0,
     capDeleted: 0,
     total: 0,
   };
@@ -185,6 +242,7 @@ export function runCleanupPass(
     );
     result.flaggedDeleted += projectResult.flaggedDeleted;
     result.zeroConfirmedDeleted += projectResult.zeroConfirmedDeleted;
+    result.contradictionsFlagged += projectResult.contradictionsFlagged;
     result.capDeleted += projectResult.capDeleted;
     result.total += projectResult.total;
   }
@@ -197,6 +255,7 @@ export function runCleanupPass(
   );
   result.flaggedDeleted += globalResult.flaggedDeleted;
   result.zeroConfirmedDeleted += globalResult.zeroConfirmedDeleted;
+  result.contradictionsFlagged += globalResult.contradictionsFlagged;
   result.capDeleted += globalResult.capDeleted;
   result.total += globalResult.total;
 

package/src/instinct-contradiction.ts

@@ -0,0 +1,202 @@
+/**
+ * Contradiction detection for instincts with opposing actions.
+ *
+ * Detects instincts that have similar triggers but semantically opposed actions
+ * using pattern-based heuristics (negation words, antonym verb pairs).
+ * No LLM cost - purely deterministic.
+ */
+
+import type { Instinct } from "./types.js";
+import { tokenize, jaccardSimilarity } from "./instinct-validator.js";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+/** Default Jaccard similarity threshold for trigger comparison. */
+const DEFAULT_TRIGGER_THRESHOLD = 0.4;
+
+/**
+ * Pairs of verbs/keywords that indicate opposing intent when one appears
+ * in each action. Order within each pair does not matter.
+ */
+export const OPPOSING_VERB_PAIRS: ReadonlyArray<readonly [string, string]> = [
+  ["avoid", "prefer"],
+  ["avoid", "use"],
+  ["avoid", "always"],
+  ["avoid", "ensure"],
+  ["never", "always"],
+  ["never", "prefer"],
+  ["never", "use"],
+  ["never", "ensure"],
+  ["skip", "always"],
+  ["skip", "ensure"],
+  ["skip", "require"],
+  ["reject", "prefer"],
+  ["reject", "use"],
+  ["reject", "accept"],
+] as const;
+
+/**
+ * Negation prefixes that invert the meaning of a following verb.
+ * Matched as word boundaries in lowercase text.
+ */
+const NEGATION_PATTERNS: ReadonlyArray<string> = [
+  "do not ",
+  "don't ",
+  "do not",
+  "don't",
+];
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Extracts the set of action-relevant keywords from an action string.
+ * Lowercases and splits on word boundaries.
+ */
+function extractActionWords(action: string): Set<string> {
+  return new Set(
+    action
+      .toLowerCase()
+      .split(/[^a-z']+/)
+      .filter((w) => w.length > 0)
+  );
+}
+
+/**
+ * Checks whether a negation prefix appears in the action text,
+ * followed by a verb that appears in the other action.
+ */
+function hasNegationConflict(actionA: string, actionB: string): string | null {
+  const lowerA = actionA.toLowerCase();
+  const lowerB = actionB.toLowerCase();
+  const wordsA = extractActionWords(actionA);
+  const wordsB = extractActionWords(actionB);
+
+  for (const neg of NEGATION_PATTERNS) {
+    // Check if A has negation + verb that B uses affirmatively
+    const idxA = lowerA.indexOf(neg);
+    if (idxA !== -1) {
+      const afterNeg = lowerA.slice(idxA + neg.length).trim();
+      const negatedVerb = afterNeg.split(/[^a-z]+/)[0];
+      if (negatedVerb && negatedVerb.length > 1 && wordsB.has(negatedVerb)) {
+        return `"${neg}${negatedVerb}" vs "${negatedVerb}"`;
+      }
+    }
+
+    // Check if B has negation + verb that A uses affirmatively
+    const idxB = lowerB.indexOf(neg);
+    if (idxB !== -1) {
+      const afterNeg = lowerB.slice(idxB + neg.length).trim();
+      const negatedVerb = afterNeg.split(/[^a-z]+/)[0];
+      if (negatedVerb && negatedVerb.length > 1 && wordsA.has(negatedVerb)) {
+        return `"${neg}${negatedVerb}" vs "${negatedVerb}"`;
+      }
+    }
+  }
+
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export interface ContradictionMatch {
+  instinctA: Instinct;
+  instinctB: Instinct;
+  triggerSimilarity: number;
+  reason: string;
+}
+
+/**
+ * Checks whether two actions are semantically opposing using verb pair matching
+ * and negation pattern detection.
+ *
+ * @returns A reason string if opposing, null otherwise.
+ */
+export function hasOpposingAction(actionA: string, actionB: string): string | null {
+  if (!actionA || !actionB) return null;
+  if (actionA === actionB) return null;
+
+  const wordsA = extractActionWords(actionA);
+  const wordsB = extractActionWords(actionB);
+
+  // Check opposing verb pairs
+  for (const [verbX, verbY] of OPPOSING_VERB_PAIRS) {
+    if (
+      (wordsA.has(verbX) && wordsB.has(verbY)) ||
+      (wordsA.has(verbY) && wordsB.has(verbX))
+    ) {
+      return `opposing verbs: "${verbX}" vs "${verbY}"`;
+    }
+  }
+
+  // Check negation patterns (e.g., "do not use" vs "use")
+  const negationResult = hasNegationConflict(actionA, actionB);
+  if (negationResult) {
+    return `negation conflict: ${negationResult}`;
+  }
+
+  return null;
+}
+
+/**
+ * Finds all contradictory pairs in a set of instincts.
+ *
+ * A contradiction is defined as:
+ * 1. Similar triggers (Jaccard similarity >= threshold on trigger tokens)
+ * 2. Opposing actions (detected via verb pairs or negation patterns)
+ *
+ * Instincts with `flagged_for_removal` are excluded.
+ * Each pair is reported once (no duplicates).
+ *
+ * @param instincts - All instincts to check
+ * @param triggerThreshold - Jaccard similarity threshold for triggers (default 0.4)
+ * @returns Array of contradiction matches
+ */
+export function findContradictions(
+  instincts: readonly Instinct[],
+  triggerThreshold = DEFAULT_TRIGGER_THRESHOLD
+): ContradictionMatch[] {
+  const active = instincts.filter((i) => !i.flagged_for_removal);
+  if (active.length < 2) return [];
+
+  const matches: ContradictionMatch[] = [];
+
+  // Pre-compute trigger tokens
+  const triggerTokens = new Map<string, Set<string>>();
+  for (const inst of active) {
+    triggerTokens.set(inst.id, tokenize(inst.trigger));
+  }
+
+  // Compare all unique pairs
+  for (let i = 0; i < active.length; i++) {
+    for (let j = i + 1; j < active.length; j++) {
+      const a = active[i]!;
+      const b = active[j]!;
+
+      // Step 1: Check trigger similarity
+      const tokensA = triggerTokens.get(a.id)!;
+      const tokensB = triggerTokens.get(b.id)!;
+      const similarity = jaccardSimilarity(tokensA, tokensB);
+
+      if (similarity < triggerThreshold) continue;
+
+      // Step 2: Check action opposition
+      const reason = hasOpposingAction(a.action, b.action);
+      if (reason) {
+        matches.push({
+          instinctA: a,
+          instinctB: b,
+          triggerSimilarity: similarity,
+          reason,
+        });
+      }
+    }
+  }
+
+  return matches;
+}

package/src/instinct-dream.ts

@@ -0,0 +1,62 @@
+/**
+ * /instinct-dream slash command handler.
+ *
+ * Interactive version of consolidation that runs inside a Pi session.
+ * Loads all instincts, builds a consolidation prompt, and sends it as
+ * a followUp message for the LLM to review with the user.
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import type { InstalledSkill } from "./types.js";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getBaseDir } from "./storage.js";
+import { readAgentsMd } from "./agents-md.js";
+import { loadProjectInstincts, loadGlobalInstincts } from "./instinct-store.js";
+import { filterInstincts } from "./instinct-loader.js";
+import { buildDreamPrompt } from "./prompts/dream-prompt.js";
+
+const MAX_DREAM_INSTINCTS = 100;
+
+export const COMMAND_NAME = "instinct-dream";
+
+export async function handleInstinctDream(
+  _args: string,
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+  projectId?: string | null,
+  baseDir?: string,
+  projectRoot?: string | null,
+  installedSkills?: InstalledSkill[]
+): Promise<void> {
+  const effectiveBase = baseDir ?? getBaseDir();
+  const projectInstincts = projectId
+    ? loadProjectInstincts(projectId, effectiveBase)
+    : [];
+  const globalInstincts = loadGlobalInstincts(effectiveBase);
+  const allInstincts = filterInstincts(
+    [...projectInstincts, ...globalInstincts],
+    0.1,
+    MAX_DREAM_INSTINCTS
+  );
+
+  if (allInstincts.length === 0) {
+    ctx.ui.notify(
+      "No instincts to consolidate. Keep using pi to accumulate instincts first.",
+      "info"
+    );
+    return;
+  }
+
+  const agentsMdProject =
+    projectRoot != null ? readAgentsMd(join(projectRoot, "AGENTS.md")) : null;
+  const agentsMdGlobal = readAgentsMd(join(homedir(), ".pi", "agent", "AGENTS.md"));
+
+  const prompt = buildDreamPrompt(
+    allInstincts,
+    agentsMdProject,
+    agentsMdGlobal,
+    installedSkills
+  );
+  pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+}

package/src/instinct-parser.ts

@@ -132,6 +132,9 @@ export function parseInstinct(content: string): Instinct {
   if (fm["graduated_at"] !== undefined && fm["graduated_at"] !== null) {
     instinct.graduated_at = String(fm["graduated_at"]);
   }
+  if (fm["last_confirmed_session"] !== undefined && fm["last_confirmed_session"] !== null) {
+    instinct.last_confirmed_session = String(fm["last_confirmed_session"]);
+  }
 
   return instinct;
 }
@@ -177,6 +180,9 @@ export function serializeInstinct(instinct: Instinct): string {
   if (instinct.graduated_at !== undefined) {
     frontmatter["graduated_at"] = instinct.graduated_at;
   }
+  if (instinct.last_confirmed_session !== undefined) {
+    frontmatter["last_confirmed_session"] = instinct.last_confirmed_session;
+  }
 
   const yamlStr = stringifyYaml(frontmatter);
   return `---\n${yamlStr}---\n\n${instinct.action}\n`;

package/src/observation-signal.ts

@@ -0,0 +1,80 @@
+/**
+ * Observation batch signal scoring.
+ * Determines whether a batch of observations contains enough signal
+ * to warrant running the analyzer (and spending tokens).
+ */
+
+import type { Observation } from "./types.js";
+
+/**
+ * Score threshold below which a batch is considered low-signal.
+ * Batches scoring below this are skipped with a log entry.
+ */
+export const LOW_SIGNAL_THRESHOLD = 3;
+
+interface ScoreResult {
+  readonly score: number;
+  readonly errors: number;
+  readonly corrections: number;
+  readonly userPrompts: number;
+}
+
+/**
+ * Scores an observation batch for signal richness.
+ *
+ * Scoring rules:
+ * - Error observation (is_error: true): +2 points
+ * - user_prompt after an error (user correction): +3 points
+ * - Other user_prompt events (potential corrections/redirections): +1 point
+ *
+ * @param lines - Raw JSONL observation lines (preprocessed or raw)
+ * @returns Score result with breakdown
+ */
+export function scoreObservationBatch(lines: string[]): ScoreResult {
+  let score = 0;
+  let errors = 0;
+  let corrections = 0;
+  let userPrompts = 0;
+  let lastWasError = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    let obs: Partial<Observation>;
+    try {
+      obs = JSON.parse(trimmed) as Partial<Observation>;
+    } catch {
+      continue; // Skip malformed lines
+    }
+
+    if (obs.is_error) {
+      score += 2;
+      errors++;
+      lastWasError = true;
+      continue;
+    }
+
+    if (obs.event === "user_prompt") {
+      userPrompts++;
+      if (lastWasError) {
+        score += 3;
+        corrections++;
+      } else {
+        score += 1;
+      }
+    }
+
+    lastWasError = false;
+  }
+
+  return { score, errors, corrections, userPrompts };
+}
+
+/**
+ * Returns true if the batch is low-signal and analysis should be skipped.
+ */
+export function isLowSignalBatch(lines: string[]): boolean {
+  const { score } = scoreObservationBatch(lines);
+  return score < LOW_SIGNAL_THRESHOLD;
+}