pi-continuous-learning 0.7.0 → 0.8.0

package/src/index.ts

@@ -35,6 +35,7 @@ import { handleInstinctProjects, COMMAND_NAME as PROJECTS_CMD } from "./instinct
 import { handleInstinctGraduate, COMMAND_NAME as GRADUATE_CMD } from "./instinct-graduate.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 +71,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);

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;
+}

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
 

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",

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";