pi-continuous-learning 0.7.0 → 0.9.0

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

@@ -88,11 +88,50 @@ 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
+- Confirmed: instinct was active, agent followed guidance, user did NOT correct
 - 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.
+When updating, increment the corresponding count field.
+
+### Confirmation confidence deltas (diminishing returns)
+Do NOT apply a flat +0.05 for every confirmation. Use these tiers based on the
+instinct's current confirmed_count BEFORE this update:
+- 1st-3rd confirmation (confirmed_count 0-2):  +0.05
+- 4th-6th confirmation (confirmed_count 3-5):  +0.03
+- 7th+ confirmation   (confirmed_count 6+):    +0.01
+
+Note: the client applies these deltas automatically from confirmed_count.
+You should still set the correct confirmed_count so the client can compute it.
+
+### Per-session confirmation deduplication
+An instinct may only be confirmed ONCE per unique session_id. Each existing
+instinct includes a last_confirmed_session field (if it has been confirmed before).
+
+Rules:
+- If all observations showing this instinct active belong to the same session as
+  last_confirmed_session, do NOT increment confirmed_count. The instinct already
+  received credit for that session.
+- If a NEW session_id (different from last_confirmed_session) shows the instinct
+  active and followed, increment confirmed_count by 1 and set last_confirmed_session
+  to that new session_id.
+- When creating a new instinct with initial confirmed_count > 0, set
+  last_confirmed_session to the session_id that provided the confirmation.
+
+### Baseline behavior filtering
+Do NOT mark an instinct as "confirmed" if the agent's behavior would be expected
+baseline practice regardless of whether the instinct was injected.
+
+Examples of baseline behavior that should NOT count as confirmation:
+- Reading a file before editing it
+- Running a linter or type-checker after code changes
+- Using conventional commit message format
+- Checking for errors after tool calls
+- Clarifying ambiguous requirements before starting
+
+Only count a confirmation when the instinct guided behavior that would plausibly
+NOT have occurred without it (e.g., a project-specific workflow, a non-obvious
+convention, or a recovery pattern the agent had to learn).
 
 ## Confidence Scoring Rules
 
@@ -111,6 +150,21 @@ Use project scope when the pattern is specific to this project's tech stack or c
 Use global scope when the pattern applies universally to any coding session.
 When in doubt, prefer project scope.
 
+## Contradiction Detection
+
+Before creating or updating instincts, check existing instincts for contradictions:
+two instincts with similar triggers but semantically opposing actions.
+
+Examples of contradictory pairs:
+- "When designing APIs" -> "prefer interfaces" vs "avoid interfaces, use concrete types"
+- "When writing tests" -> "always mock dependencies" vs "never mock, use real implementations"
+- "When handling errors" -> "throw exceptions" vs "avoid exceptions, use Result types"
+
+When you detect a contradiction:
+1. **If observations clearly support one side**: Delete the contradicted instinct (emit a "delete" change) and optionally boost the confirmed instinct's confidence.
+2. **If evidence is ambiguous**: Delete BOTH and create a single nuanced instinct that captures the context-dependent guidance (e.g., "prefer interfaces for public APIs, concrete types for internal helpers").
+3. **Do not create a new instinct that contradicts an existing one** without resolving the conflict first.
+
 ## Conservativeness Rules
 
 1. Only create a new instinct with 3+ clear independent observations supporting the pattern.
@@ -120,6 +174,7 @@ When in doubt, prefer project scope.
 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.
+8. Before creating, verify the new instinct does not contradict any existing instinct (see Contradiction Detection above).
 
 ## Quality Tiers
 

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

@@ -3,7 +3,7 @@
  * 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";
+import { formatInstinctsCompact } from "../cli/analyze-single-shot.js";
 
 export interface SingleShotPromptOptions {
   agentsMdProject?: string | null;
@@ -34,7 +34,10 @@ export function buildSingleShotUserPrompt(
       ? observationLines.join("\n")
       : "(no observations recorded yet)";
 
-  const instinctBlock = formatInstinctsForPrompt(existingInstincts);
+  const instinctBlock =
+    existingInstincts.length > 0
+      ? formatInstinctsCompact(existingInstincts)
+      : "(no existing instincts)";
 
   const parts: string[] = [
     "## Project Context",
@@ -86,6 +89,8 @@ export function buildSingleShotUserPrompt(
     "   - Generic agent behaviors (read-before-edit, clarify-before-implement) -> skip entirely",
     "   - Project-specific patterns -> project-scoped instinct",
     "   - Universal workflow patterns -> global-scoped instinct",
+    "8. Check existing instincts for contradictions (similar triggers, opposing actions).",
+    "   Resolve by deleting the weaker instinct or merging into a nuanced one.",
     "",
     "Return ONLY the JSON object. No prose, no markdown fences."
   );

package/src/prompts/consolidate-system.ts

@@ -0,0 +1,101 @@
+/**
+ * System prompt for the consolidation (dream) pass.
+ * Reviews the entire instinct corpus holistically - no observations needed.
+ */
+export function buildConsolidateSystemPrompt(): string {
+  return `You are a coding behavior analyst performing a periodic consolidation review.
+Your job is to review the entire instinct corpus holistically and produce a JSON change-set
+that merges duplicates, removes stale entries, resolves contradictions, and promotes mature instincts.
+
+## 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.
+
+## Consolidation Tasks
+
+Perform these analyses on the full instinct corpus:
+
+### 1. Merge Candidates
+Find instincts with semantically similar triggers or actions, even if worded differently.
+Merge them into a single stronger instinct:
+- Delete both originals
+- Create one merged instinct with combined evidence
+- Set confidence to the higher of the two (capped at 0.9)
+- Sum observation_count and confirmed_count from both
+
+### 2. Contradiction Resolution
+Find instincts with similar triggers but opposing actions:
+- "prefer X" vs "avoid X"
+- "always do Y" vs "never do Y"
+- "use A" vs "don't use A"
+
+Resolution strategy:
+- If one has clearly higher confidence (>0.1 difference): delete the weaker one
+- If confidence is similar but one has more confirmations: keep the more confirmed one
+- If evidence is truly ambiguous: delete both, create a nuanced context-dependent instinct
+
+### 3. Stale Instinct Detection
+Flag instincts that reference patterns unlikely to still be relevant:
+- Evidence references specific files or tools that may no longer exist
+- Very old instincts (28+ days) with zero confirmations
+- Instincts with high inactive_count relative to confirmed_count
+
+### 4. Promotion Candidates
+Identify project-scoped instincts that should become global:
+- Confidence >= 0.7
+- confirmed_count >= 3
+- Pattern is not project-specific (no project-specific file paths, tools, or conventions)
+
+To promote: delete the project-scoped version and create a global-scoped version with the same data.
+
+### 5. AGENTS.md Deduplication
+Check if any instincts are already covered by AGENTS.md guidelines.
+Delete instincts that duplicate existing written guidelines.
+
+### 6. Quality Cleanup
+- Delete instincts with confidence < 0.2
+- Delete instincts flagged_for_removal
+- Rewrite vague triggers or actions to be more specific (update action)
+
+## Conservativeness Rules
+
+1. Prefer fewer changes over many - only act when the improvement is clear
+2. When merging, preserve the essence of both instincts in the merged version
+3. Do not create new instincts from scratch - only merge or modify existing ones
+4. Clamping: always keep confidence in [0.1, 0.9]
+5. Write actions as clear instructions starting with a verb
+6. If unsure about a change, skip it - the next consolidation will catch it`;
+}

package/src/prompts/consolidate-user.ts

@@ -0,0 +1,88 @@
+/**
+ * User prompt builder for the consolidation (dream) pass.
+ * Embeds all instincts and optional AGENTS.md context.
+ */
+
+import type { Instinct, InstalledSkill } from "../types.js";
+import { formatInstinctsCompact } from "../cli/analyze-single-shot.js";
+
+export interface ConsolidatePromptOptions {
+  agentsMdProject?: string | null;
+  agentsMdGlobal?: string | null;
+  installedSkills?: InstalledSkill[];
+  projectName?: string;
+  projectId?: string;
+}
+
+/**
+ * Builds the user prompt for a consolidation pass.
+ * Unlike the observation analyzer, this prompt contains only instincts
+ * and guidelines - no observations.
+ */
+export function buildConsolidateUserPrompt(
+  instincts: readonly Instinct[],
+  options: ConsolidatePromptOptions = {}
+): string {
+  const {
+    agentsMdProject = null,
+    agentsMdGlobal = null,
+    installedSkills = [],
+    projectName,
+    projectId,
+  } = options;
+
+  const instinctBlock =
+    instincts.length > 0
+      ? formatInstinctsCompact([...instincts])
+      : "(no instincts)";
+
+  const parts: string[] = [];
+
+  if (projectId || projectName) {
+    parts.push("## Project Context", "");
+    if (projectId) parts.push(`project_id: ${projectId}`);
+    if (projectName) parts.push(`project_name: ${projectName}`);
+    parts.push("");
+  }
+
+  parts.push(
+    "## Full Instinct Corpus",
+    "",
+    instinctBlock,
+    "",
+    `Total instincts: ${instincts.length}`,
+    ""
+  );
+
+  if (agentsMdProject != null || agentsMdGlobal != null) {
+    parts.push("## Existing Guidelines (AGENTS.md)", "");
+    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 ALL instincts above as a complete corpus.",
+    "2. Identify merge candidates, contradictions, stale entries, and promotion candidates.",
+    "3. Check for instincts duplicated by AGENTS.md guidelines.",
+    "4. Return a JSON change-set with your proposed modifications.",
+    "5. Prefer conservative changes - only act when the improvement is clear.",
+    "",
+    "Return ONLY the JSON object. No prose, no markdown fences."
+  );
+
+  return parts.join("\n");
+}

package/src/prompts/dream-prompt.ts

@@ -0,0 +1,88 @@
+/**
+ * Prompt builder for the interactive /instinct-dream command.
+ * Similar to evolve-prompt but focused on holistic consolidation tasks.
+ */
+
+import type { Instinct, InstalledSkill } from "../types.js";
+
+interface InstinctSummary {
+  id: string;
+  title: string;
+  trigger: string;
+  action: string;
+  confidence: number;
+  domain: string;
+  scope: string;
+  confirmed_count: number;
+  contradicted_count: number;
+  inactive_count: number;
+}
+
+function summarizeInstinct(i: Instinct): InstinctSummary {
+  return {
+    id: i.id,
+    title: i.title,
+    trigger: i.trigger,
+    action: i.action,
+    confidence: i.confidence,
+    domain: i.domain,
+    scope: i.scope,
+    confirmed_count: i.confirmed_count,
+    contradicted_count: i.contradicted_count,
+    inactive_count: i.inactive_count,
+  };
+}
+
+export function buildDreamPrompt(
+  instincts: Instinct[],
+  agentsMdProject?: string | null,
+  agentsMdGlobal?: string | null,
+  installedSkills?: InstalledSkill[]
+): string {
+  const parts: string[] = [
+    "Perform a holistic consolidation review of my learned instincts.",
+    "You have access to instinct tools (instinct_merge, instinct_delete, instinct_write) to act on your findings.",
+    "",
+    "## Full Instinct Corpus",
+    "",
+    "```json",
+    JSON.stringify(instincts.map(summarizeInstinct), null, 2),
+    "```",
+    "",
+    `Total: ${instincts.length} instincts`,
+    "",
+    "## Consolidation Tasks",
+    "",
+    "Review the entire corpus and identify:",
+    "",
+    "1. **Merge candidates**: Instincts with semantically similar triggers or actions (even if worded differently). Merge into a single, stronger instinct using instinct_merge.",
+    "2. **Contradictions**: Instincts with similar triggers but opposing actions. Resolve by keeping the stronger one or merging into a nuanced context-dependent instinct.",
+    "3. **Stale instincts**: Entries with zero confirmations, high inactive_count, or references to outdated patterns. Delete them.",
+    "4. **AGENTS.md duplicates**: Instincts already covered by the guidelines below. Delete them.",
+    "5. **Promotion candidates**: Project-scoped instincts with confidence >= 0.7 and confirmed_count >= 3 that apply universally. Promote to global scope.",
+    "6. **Skill shadows**: Instincts whose purpose is already served by an installed skill. Delete them.",
+    "7. **Quality cleanup**: Instincts with confidence < 0.2, vague triggers, or flagged_for_removal. Clean up or delete.",
+    "",
+    "Present your findings conversationally. For each suggestion, explain your reasoning and ask if I'd like you to take action using the instinct tools.",
+    "If the corpus looks healthy, say so briefly.",
+  ];
+
+  if (agentsMdProject || agentsMdGlobal) {
+    parts.push("", "## Current Guidelines (AGENTS.md)", "");
+    if (agentsMdProject) {
+      parts.push("### Project AGENTS.md", "", agentsMdProject, "");
+    }
+    if (agentsMdGlobal) {
+      parts.push("### Global AGENTS.md", "", agentsMdGlobal, "");
+    }
+  }
+
+  if (installedSkills && installedSkills.length > 0) {
+    parts.push("", "## Installed Skills", "");
+    for (const skill of installedSkills) {
+      parts.push(`- **${skill.name}**: ${skill.description}`);
+    }
+  }
+
+  return parts.join("\n");
+}

package/src/prompts/evolve-prompt.ts

@@ -40,11 +40,12 @@ export function buildEvolvePrompt(
     "",
     "## Analysis Tasks",
     "",
-    "1. **Merge candidates**: Find instincts with semantically similar triggers or actions (even if worded differently). Offer to merge them using the instinct_merge tool.",
-    "2. **Duplicates of AGENTS.md**: Flag instincts already covered by the guidelines below. Offer to delete them.",
-    "3. **Promotion candidates**: Project-scoped instincts with confidence >= 0.7 that could become global.",
-    "4. **Skill shadows**: Instincts whose purpose is already served by an installed skill (listed below). Offer to delete them.",
-    "5. **Low-confidence cleanup**: Instincts with confidence < 0.3 or flagged_for_removal that should be deleted.",
+    "1. **Contradictions**: Find instincts with similar triggers but opposing actions (e.g., 'prefer X' vs 'avoid X', 'always do Y' vs 'never do Y'). Offer to delete the weaker one, or merge both into a nuanced context-dependent instinct.",
+    "2. **Merge candidates**: Find instincts with semantically similar triggers or actions (even if worded differently). Offer to merge them using the instinct_merge tool.",
+    "3. **Duplicates of AGENTS.md**: Flag instincts already covered by the guidelines below. Offer to delete them.",
+    "4. **Promotion candidates**: Project-scoped instincts with confidence >= 0.7 that could become global.",
+    "5. **Skill shadows**: Instincts whose purpose is already served by an installed skill (listed below). Offer to delete them.",
+    "6. **Low-confidence cleanup**: Instincts with confidence < 0.3 or flagged_for_removal that should be deleted.",
     "",
     "Present your findings conversationally. For each suggestion, explain your reasoning and ask if I'd like you to take action using the instinct tools.",
     "If there are no issues, say so briefly.",

package/src/types.ts

@@ -69,6 +69,7 @@ export interface Instinct {
   flagged_for_removal?: boolean;
   graduated_to?: GraduationTarget;
   graduated_at?: string; // ISO 8601
+  last_confirmed_session?: string; // session ID that last provided a confirmation
 }
 
 export type GraduationTarget = "agents-md" | "skill" | "command";
@@ -113,4 +114,8 @@ export interface Config {
   max_new_instincts_per_run: number; // creation rate limit per analyzer run
   flagged_cleanup_days: number; // auto-delete flagged instincts after N days
   instinct_ttl_days: number; // auto-delete zero-confirmation instincts after N days
+  // Consolidation (dream) settings
+  dreaming_enabled: boolean; // whether automatic consolidation runs during normal analysis
+  consolidation_interval_days: number; // minimum days between consolidation runs
+  consolidation_min_sessions: number; // minimum sessions since last consolidation
 }