portable-agent-layer 0.23.0 → 0.23.1

package/assets/templates/PAL/ALGORITHM.md

@@ -216,7 +216,26 @@ Only add threads that genuinely need follow-up. Resolve existing threads if this
 bun ~/.pal/tools/thread.ts --resolve --id <id>
 ```
 
-**4. Wisdom Frame** (Extended+ only) — if the session produced a genuine, reusable insight:
+**4. Opinion capture** — scan the conversation for moments where the user:
+- Confirmed something you did: "yes exactly", "keep doing that", "10 rated", accepted without pushback
+- Corrected something you did: "no", "don't do that", "stop", "that's not what I meant"
+- Revealed a preference by repeating a pattern (asked for concise answers twice, always checked PAI first, etc.)
+
+For each, invoke the opinion tool:
+```bash
+# User confirmed a preference
+bun ~/.pal/skills/opinion/tools/opinion.ts evidence "matching keywords" --confirmation "what they confirmed"
+
+# User corrected a preference
+bun ~/.pal/skills/opinion/tools/opinion.ts evidence "matching keywords" --contradiction "what they corrected"
+
+# New pattern observed (no existing opinion matches)
+bun ~/.pal/skills/opinion/tools/opinion.ts add "the preference" --category communication|technical|workflow|general
+```
+
+Skip if nothing in the conversation touched preferences or working style.
+
+**5. Wisdom Frame** (Extended+ only) — if the session produced a genuine, reusable insight:
 
 ```bash
 bun ~/.pal/tools/wisdom-frame.ts --domain <domain> --observation "insight" [--type principle|contextual-rule|anti-pattern|evolution]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "portable-agent-layer",
-  "version": "0.23.0",
+  "version": "0.23.1",
   "description": "PAL — Portable Agent Layer: persistent personal context for AI coding assistants",
   "type": "module",
   "bin": {

package/src/hooks/handlers/failure.ts

@@ -30,7 +30,8 @@ export async function captureFailure(
   rating: number,
   context: string,
   transcript: string,
-  detailedContext?: string
+  detailedContext?: string,
+  principle?: string
 ): Promise<void> {
   const messages = parseMessages(transcript);
 
@@ -55,6 +56,7 @@ export async function captureFailure(
     ts: new Date().toISOString(),
     slug,
   };
+  if (principle) meta.principle = principle;
 
   const body = [
     "## What Happened",

package/src/hooks/handlers/rating.ts

@@ -166,8 +166,16 @@ const SENTIMENT_SCHEMA = {
     confidence: { type: "number" },
     summary: { type: "string" },
     detailed_context: { type: "string" },
+    principle: { type: "string" },
   },
-  required: ["rating", "sentiment", "confidence", "summary", "detailed_context"],
+  required: [
+    "rating",
+    "sentiment",
+    "confidence",
+    "summary",
+    "detailed_context",
+    "principle",
+  ],
   additionalProperties: false,
 } as const;
 
@@ -177,6 +185,7 @@ interface SentimentResult {
   confidence: number;
   summary: string;
   detailed_context: string;
+  principle: string;
 }
 
 const SENTIMENT_SYSTEM_PROMPT = `Analyze the user's message for emotional sentiment toward the AI assistant.
@@ -187,7 +196,8 @@ OUTPUT FORMAT (JSON only):
   "sentiment": "positive" | "negative" | "neutral",
   "confidence": <0.0-1.0>,
   "summary": "<brief explanation, 10 words max>",
-  "detailed_context": "<comprehensive analysis, 50-150 words>"
+  "detailed_context": "<comprehensive analysis, 50-150 words>",
+  "principle": "<one actionable rule the AI should follow to avoid this failure or repeat this success, 10-20 words. Start with a verb: 'Verify...', 'Always...', 'Never...', 'Ask before...'>"
 }
 
 DETAILED_CONTEXT REQUIREMENTS:
@@ -240,6 +250,7 @@ function handleRating(
   context: string,
   source: string,
   detailedContext?: string,
+  principle?: string,
   sessionId?: string,
   userMessage?: string
 ): void {
@@ -257,6 +268,7 @@ function handleRating(
           context,
           source,
           detailedContext,
+          principle,
           responsePreview,
           userPreview,
           ts: now(),
@@ -284,6 +296,7 @@ async function handleImplicitSentiment(
       `Direct praise: "${trimmed}"`,
       "implicit",
       undefined,
+      undefined,
       sessionId,
       trimmed
     );
@@ -328,6 +341,7 @@ async function handleImplicitSentiment(
         `${parsed.summary}: ${trimmed.slice(0, 200)}`,
         "implicit",
         parsed.detailed_context,
+        parsed.principle,
         sessionId,
         trimmed
       );
@@ -352,6 +366,7 @@ export async function captureRating(message: string, sessionId?: string): Promis
       explicit.comment || cleaned.slice(0, 200),
       "explicit",
       undefined,
+      undefined,
       sessionId,
       cleaned
     );

package/src/hooks/handlers/reflect-trigger.ts

@@ -1,7 +1,7 @@
 /**
  * Auto-trigger for relationship reflect — runs when conditions are met:
- * - 7+ days since last reflect
- * - 10+ new relationship notes since last reflect
+ * - 1+ days since last reflect
+ * - 5+ new relationship notes since last reflect
  *
  * Spawns `bun run tool:reflect` as a detached background process.
  */
@@ -12,8 +12,8 @@ import { logDebug } from "../lib/log";
 import { getLastReflectDate } from "../lib/opinions";
 import { palPkg, paths } from "../lib/paths";
 
-const MIN_DAYS_BETWEEN = 7;
-const MIN_NEW_NOTES = 10;
+const MIN_DAYS_BETWEEN = 1;
+const MIN_NEW_NOTES = 5;
 
 function countNotesSince(since: string): number {
   const relDir = paths.relationship();

package/src/hooks/lib/context.ts

@@ -231,10 +231,11 @@ export function loadFailurePatterns(): string {
 
     const lines = entries.map((e) => {
       const label = e.rating ? `[${e.rating}/10]` : "";
-      return `- ${label} ${e.context}`.trim();
+      const text = e.principle || e.context;
+      return `- ${label} ${text}`.trim();
     });
 
-    return ["## Recent Failure Patterns (Avoid)", ...lines].join("\n");
+    return ["## Lessons from Recent Failures — Apply These Now", ...lines].join("\n");
   } catch {
     return "";
   }

package/src/hooks/lib/stop.ts

@@ -13,6 +13,7 @@ import { runSynthesis } from "../handlers/synthesis";
 import { resetTab } from "../handlers/tab";
 import { updateCounts } from "../handlers/update-counts";
 import { captureWorkSession } from "../handlers/work-session";
+import { inference } from "./inference";
 import { logDebug, logError } from "./log";
 import { ensureDir, paths } from "./paths";
 import { extractContent, extractLastAssistant, parseMessages } from "./transcript";
@@ -137,15 +138,63 @@ async function checkPendingFailure(transcript: string): Promise<void> {
       rating: number;
       context: string;
       detailedContext?: string;
+      principle?: string;
       responsePreview?: string;
       userPreview?: string;
     };
     unlinkSync(pendingPath);
+
+    // Extract principle from full transcript if not already present
+    let { principle, detailedContext } = pending;
+    if (!principle) {
+      try {
+        const msgs = parseMessages(transcript);
+        const recent = msgs
+          .slice(-10)
+          .map((m) => `${m.role.toUpperCase()}: ${extractContent(m).slice(0, 300)}`)
+          .join("\n\n");
+
+        const result = await inference({
+          system: `Analyze this failed AI interaction. The user rated it ${pending.rating}/10.
+
+Return JSON:
+{
+  "principle": "<one actionable rule the AI should follow, 10-20 words. Start with a verb: 'Verify...', 'Always...', 'Never...', 'Ask before...'>",
+  "detailed_context": "<what went wrong and why, 50-150 words>"
+}`,
+          user: `User feedback: ${pending.context}\n\nConversation:\n${recent}`,
+          maxTokens: 400,
+          timeout: 10000,
+          jsonSchema: {
+            type: "object" as const,
+            properties: {
+              principle: { type: "string" as const },
+              detailed_context: { type: "string" as const },
+            },
+            required: ["principle", "detailed_context"],
+            additionalProperties: false,
+          },
+        });
+
+        if (result.success && result.output) {
+          const parsed = JSON.parse(result.output) as {
+            principle?: string;
+            detailed_context?: string;
+          };
+          principle = parsed.principle || undefined;
+          if (!detailedContext) detailedContext = parsed.detailed_context || undefined;
+        }
+      } catch {
+        /* graceful fallback — capture without principle */
+      }
+    }
+
     await captureFailure(
       pending.rating,
       pending.context,
       transcript,
-      pending.detailedContext
+      detailedContext,
+      principle
     );
   } catch {
     // Non-critical