portable-agent-layer 0.8.0 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "portable-agent-layer",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "PAL — Portable Agent Layer: persistent personal context for AI coding assistants",
   "type": "module",
   "bin": {
@@ -48,7 +48,6 @@
     "ai:fyzz-api": "bun run src/tools/fyzz-api.ts",
     "ai:pdf-download": "bun run src/tools/pdf-download.ts",
     "ai:youtube-analyze": "bun run src/tools/youtube-analyze.ts",
-    "tool:eval": "bun run src/tools/eval-principles.ts",
     "tool:analyze": "bun run src/tools/analyze.ts",
     "tool:reflect": "bun run src/tools/relationship-reflect.ts",
     "tool:export": "bun run src/tools/export.ts",

package/src/hooks/LoadContext.ts

@@ -7,7 +7,7 @@
  */
 
 import { regenerateIfNeeded } from "./lib/claude-md";
-import { buildGreeting, buildSystemReminder } from "./lib/context";
+import { buildSystemReminder } from "./lib/context";
 import { logDebug, logError } from "./lib/log";
 
 // --- Skip heavy context for subagents ---
@@ -28,9 +28,6 @@ try {
   logError("LoadContext:regenerate", err);
 }
 
-// --- Visible greeting to stderr ---
-process.stderr.write(`${buildGreeting().join("\n")}\n`);
-
 // --- Dynamic system-reminder to stdout (empty = nothing injected) ---
 try {
   const reminder = buildSystemReminder();

package/src/hooks/handlers/rating.ts

@@ -46,11 +46,11 @@ function getLastResponse(sessionId?: string): string {
  * Matches: "7", "8 - good work", "6: needs work", "9 excellent", "10!"
  * Rejects: "3 items", "5 things to fix", "7th thing", "10/10"
  */
-function parseExplicitRating(
+export function parseExplicitRating(
   prompt: string
 ): { rating: number; comment?: string } | null {
   const trimmed = prompt.trim();
-  const match = trimmed.match(/^(10|[1-9])(?:\s*[-:]\s*|\s+)?(.*)$/);
+  const match = trimmed.match(/^(10|[1-9])(?:\s*[-:,]\s*|\s+)?(.*)$/);
   if (!match) return null;
 
   const rating = parseInt(match[1], 10);
@@ -67,6 +67,9 @@ function parseExplicitRating(
     const sentenceStarters =
       /^(items?|things?|steps?|files?|lines?|bugs?|issues?|errors?|times?|minutes?|hours?|days?|seconds?|percent|%|th\b|st\b|nd\b|rd\b|of\b|in\b|at\b|to\b|the\b|a\b|an\b)/i;
     if (sentenceStarters.test(rest)) return null;
+
+    // Reject item selections: "1 and 2", "2 3 5", "1, 3, 5", "1-3"
+    if (/^(and\b|\d|,\s*\d|-\d)/.test(rest)) return null;
   }
 
   return { rating, comment: rest };

package/src/hooks/handlers/update-check.ts

@@ -183,10 +183,7 @@ export function getUpdateNotice(): string | null {
     const cache = JSON.parse(readFileSync(fp, "utf-8")) as UpdateCache;
     if (!cache.available) return null;
 
-    if (cache.mode === "repo") {
-      return `📦 Update available: ${cache.current} → ${cache.latest} (git pull)`;
-    }
-    return `📦 Update available: ${cache.current} → ${cache.latest} (bun update -g portable-agent-layer)`;
+    return `📦 Update available: ${cache.current} → ${cache.latest} (pal cli update)`;
   } catch {
     return null;
   }

package/src/hooks/lib/log.ts

@@ -5,7 +5,7 @@
  * Only writes when PAL_DEBUG=1 or when called via logError (always logged).
  */
 
-import { appendFileSync, existsSync, statSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { paths } from "./paths";
 
@@ -21,8 +21,6 @@ function rotateIfNeeded(): void {
     if (existsSync(LOG_FILE) && statSync(LOG_FILE).size > MAX_LOG_SIZE) {
       const prev = `${LOG_FILE}.prev`;
       writeFileSync(prev, "");
-      // Swap: current → prev, start fresh
-      const { renameSync } = require("node:fs");
       renameSync(LOG_FILE, prev);
     }
   } catch {

package/src/hooks/lib/security.ts

@@ -31,6 +31,7 @@ export const HOOK_MANAGED_FILES = [
   "token-usage.jsonl",
   "graduated.json",
   "update-available.json",
+  "debug.log.prev",
 ];
 
 /** Hook-managed directories — AI must not write to or delete from these */
@@ -40,6 +41,7 @@ export const HOOK_MANAGED_DIRS = [
   "memory/learning/session",
   "memory/learning/synthesis",
   "memory/relationship",
+  "memory/wisdom/state",
 ];
 
 /** Escape a string for use in a RegExp */

package/src/hooks/lib/work-tracking.ts

@@ -1,6 +1,6 @@
 /**
  * Structured work tracking: session history + persistent projects.
- * Replaces the single-file current-work.json approach.
+ * Used by both Claude Code (StopOrchestrator) and opencode (plugin).
  */
 
 import { existsSync, readFileSync, writeFileSync } from "node:fs";

package/src/targets/opencode/install.ts

@@ -3,7 +3,7 @@
  * Deploys plugin, installs skills, generates AGENTS.md.
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { regenerateIfNeeded } from "../../hooks/lib/claude-md";
 import { palPkg, platform } from "../../hooks/lib/paths";
@@ -15,7 +15,11 @@ const OC_PLUGINS_DIR = resolve(OC_GLOBAL_DIR, "plugins");
 
 mkdirSync(OC_PLUGINS_DIR, { recursive: true });
 
-// --- 1. Deploy plugin ---
+// --- 1. Deploy plugin (clean up legacy filename) ---
+const legacyPlugin = resolve(OC_PLUGINS_DIR, "pai-plugin.ts");
+if (existsSync(legacyPlugin)) {
+  unlinkSync(legacyPlugin);
+}
 const pluginSrc = resolve(PKG_ROOT, "src", "targets", "opencode", "plugin.ts");
 const pluginDst = resolve(OC_PLUGINS_DIR, "pal-plugin.ts");
 // Embed PKG_ROOT as a hardcoded constant so no env config is needed

package/src/targets/opencode/plugin.ts

@@ -5,7 +5,6 @@
  * This plugin just wires opencode's hook API to those shared functions.
  */
 
-import { writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import type { Plugin, PluginInput } from "@opencode-ai/plugin";
 
@@ -20,25 +19,21 @@ type TranscriptMessage = { role: string; content: string };
 
 const PALPlugin: Plugin = async ({ directory, client }: PluginInput) => {
   // Pre-load shared modules
-  const { buildGreeting, buildSystemReminder } =
+  const { buildSystemReminder } =
     await lib<typeof import("../../hooks/lib/context")>("context.ts");
   const { checkBashCommand, checkFilePath } =
     await lib<typeof import("../../hooks/lib/security")>("security.ts");
-  const { paths, ensureDir } =
-    await lib<typeof import("../../hooks/lib/paths")>("paths.ts");
-  const { emitRating } =
-    await lib<typeof import("../../hooks/lib/signals")>("signals.ts");
-  const { now } = await lib<typeof import("../../hooks/lib/time")>("time.ts");
-  const { monthPath, fileTimestamp } =
-    await lib<typeof import("../../hooks/lib/time")>("time.ts");
   const { logDebug, logError } =
     await lib<typeof import("../../hooks/lib/log")>("log.ts");
 
-  // Load shared stop-orchestrator handler
+  // Load shared handlers
   const { runStopHandlers } = await lib<typeof import("../../hooks/lib/stop")>("stop.ts");
   const { captureSessionName } = await lib<
     typeof import("../../hooks/handlers/session-name")
   >("../handlers/session-name.ts");
+  const { captureRating } = await lib<typeof import("../../hooks/handlers/rating")>(
+    "../handlers/rating.ts"
+  );
 
   function partsToText(parts: Array<Record<string, unknown>>): string {
     return parts
@@ -76,59 +71,6 @@ const PALPlugin: Plugin = async ({ directory, client }: PluginInput) => {
       .filter((m) => m.content.length > 0);
   }
 
-  const { categorizeLearning } =
-    await lib<typeof import("../../hooks/lib/learning-category")>("learning-category.ts");
-
-  // Local helpers for rating (thin wrappers around shared signals)
-  function handleRating(
-    rating: number,
-    context: string,
-    source: string,
-    detailedContext?: string,
-    userMessage?: string
-  ): void {
-    emitRating(rating, context, source);
-
-    if (rating < 5) {
-      const category = categorizeLearning(context, detailedContext ?? "");
-      const dir = ensureDir(resolve(paths.sessionLearning(), monthPath()));
-      const filename = `${fileTimestamp()}_${source}-rating-${rating}_${category}.md`;
-      writeFileSync(
-        resolve(dir, filename),
-        [
-          "---",
-          `title: "${(context.slice(0, 100) || "(low rating)").replace(/"/g, '\\"')}"`,
-          `category: "${category}"`,
-          `date: "${new Date().toISOString().slice(0, 10)}"`,
-          `rating: ${rating}`,
-          `source: "${source}"`,
-          "---",
-          "",
-          "## Context",
-          context || "*(unavailable)*",
-          "",
-          ...(detailedContext ? ["## Analysis", detailedContext, ""] : []),
-        ].join("\n")
-      );
-    }
-
-    if (rating <= 3) {
-      const userPreview = userMessage?.slice(0, 400);
-      writeFileSync(
-        resolve(paths.state(), "pending-failure.json"),
-        JSON.stringify(
-          { rating, context, source, detailedContext, userPreview, ts: now() },
-          null,
-          2
-        ),
-        "utf-8"
-      );
-    }
-  }
-
-  const PRAISE_PATTERNS =
-    /^(great\s*job|nice|perfect|awesome|excellent|thanks|thank\s*you|well\s*done|good\s*job|love\s*it|amazing|brilliant|fantastic|wonderful|superb|nailed\s*it)[.!?]?$/i;
-
   return {
     // --- Per-message: Inject dynamic system reminder ---
     "experimental.chat.system.transform": async (_input, output) => {
@@ -144,7 +86,6 @@ const PALPlugin: Plugin = async ({ directory, client }: PluginInput) => {
         const { regenerateIfNeeded } =
           await lib<typeof import("../../hooks/lib/claude-md")>("claude-md.ts");
         regenerateIfNeeded();
-        console.log(buildGreeting().join("\n"));
       }
 
       if (event.type === "session.idle" || event.type === "session.diff") {
@@ -161,13 +102,15 @@ const PALPlugin: Plugin = async ({ directory, client }: PluginInput) => {
           logDebug("opencode:event", `Got ${messages.length} transcript messages`);
           if (messages.length < 2) return;
 
-          // Name session from first user message (if not already named)
-          const firstUser = messages.find((m: TranscriptMessage) => m.role === "user");
-          if (firstUser) {
-            await captureSessionName(firstUser.content, sessionID);
-          }
+          // Extract last assistant message for response caching (parity with Claude Code)
+          const lastAssistant = messages
+            .filter((m: TranscriptMessage) => m.role === "assistant")
+            .pop();
 
-          await runStopHandlers(JSON.stringify(messages), { sessionId: sessionID });
+          await runStopHandlers(JSON.stringify(messages), {
+            sessionId: sessionID,
+            lastAssistantMessage: lastAssistant?.content,
+          });
           logDebug("opencode:event", "Stop handlers complete");
         } catch (err) {
           logError("opencode:session.stop", err);
@@ -175,98 +118,19 @@ const PALPlugin: Plugin = async ({ directory, client }: PluginInput) => {
       }
     },
 
-    // --- Capture ratings from user messages ---
-    "chat.message": async (_input, output) => {
+    // --- Capture ratings + session naming from user messages (shared handlers) ---
+    "chat.message": async (input, output) => {
       const text =
         output.parts
           ?.filter((p) => p.type === "text")
           .map((p) => p.text || "")
           .join(" ") ?? "";
 
-      // Explicit rating
-      const match = text.match(
-        /(?:^|rating:?\s*|score:?\s*)(\d|10)(?:\s*(?:\/10|[-.])|$|\s)/i
-      );
-      if (match) {
-        const rating = parseInt(match[1], 10);
-        if (rating >= 1 && rating <= 10) {
-          handleRating(rating, text.slice(0, 200), "explicit", undefined, text);
-          return;
-        }
-      }
-
-      // Implicit sentiment: auto-enabled when ANTHROPIC_API_KEY is set
-      if (process.env.ANTHROPIC_API_KEY) {
-        const trimmed = text.trim();
-        if (PRAISE_PATTERNS.test(trimmed)) {
-          handleRating(8, trimmed, "implicit", undefined, trimmed);
-          return;
-        }
-
-        // Full implicit via API — only for medium-length messages
-        if (
-          trimmed.length >= 5 &&
-          trimmed.length <= 500 &&
-          !/^[/$`{]/.test(trimmed) &&
-          !trimmed.includes("\n\n")
-        ) {
-          const apiKey = process.env.ANTHROPIC_API_KEY;
-          if (apiKey) {
-            try {
-              const response = await fetch("https://api.anthropic.com/v1/messages", {
-                method: "POST",
-                headers: {
-                  "x-api-key": apiKey,
-                  "anthropic-version": "2023-06-01",
-                  "content-type": "application/json",
-                },
-                body: JSON.stringify({
-                  model: (await lib<{ HAIKU_MODEL: string }>("models")).HAIKU_MODEL,
-                  max_tokens: 100,
-                  messages: [
-                    {
-                      role: "user",
-                      content: `Rate the sentiment of this user message toward an AI assistant on a 1-10 scale (1=very negative, 5=neutral, 10=very positive). If the message has no clear sentiment toward the assistant, respond with just "neutral". Otherwise respond with just a JSON object: {"rating": N, "sentiment": "one-word"}\n\nMessage: "${trimmed.slice(0, 300)}"`,
-                    },
-                  ],
-                }),
-              });
-
-              if (response.ok) {
-                const data = (await response.json()) as {
-                  content?: Array<{ text?: string }>;
-                };
-                const rText = data?.content?.[0]?.text?.trim();
-                if (rText && rText !== "neutral") {
-                  try {
-                    const parsed = JSON.parse(rText) as {
-                      rating?: number;
-                      sentiment?: string;
-                    };
-                    if (
-                      typeof parsed.rating === "number" &&
-                      parsed.rating >= 1 &&
-                      parsed.rating <= 10 &&
-                      parsed.rating !== 5
-                    ) {
-                      handleRating(
-                        parsed.rating,
-                        `${parsed.sentiment || "inferred"}: ${trimmed.slice(0, 150)}`,
-                        "implicit",
-                        undefined,
-                        trimmed
-                      );
-                    }
-                  } catch {
-                    // Ignore parse errors
-                  }
-                }
-              }
-            } catch {
-              // Ignore API errors
-            }
-          }
-        }
+      if (text.trim()) {
+        await Promise.allSettled([
+          captureRating(text, input.sessionID),
+          captureSessionName(text, input.sessionID),
+        ]);
       }
     },
 
@@ -298,21 +162,6 @@ const PALPlugin: Plugin = async ({ directory, client }: PluginInput) => {
       }
     },
 
-    // --- Capture work state after tool use ---
-    "tool.execute.after": async (
-      input: { tool: string; sessionID: string; callID: string; args: unknown },
-      _output: { title: string; output: string; metadata: unknown }
-    ) => {
-      try {
-        writeFileSync(
-          resolve(ensureDir(paths.state()), "current-work.json"),
-          JSON.stringify({ ts: now(), tool: input.tool, cwd: directory }, null, 2)
-        );
-      } catch {
-        // Ignore write errors
-      }
-    },
-
     // --- Inject PAL_DIR into shell environment ---
     "shell.env": async (
       _input: { cwd: string; sessionID?: string; callID?: string },

package/src/hooks/lib/prompts.ts

@@ -1,11 +0,0 @@
-/**
- * Shared prompt fragments — single source of truth for inference instructions.
- */
-
-/** Principle extraction instruction for failed interactions. */
-export const FAILURE_PRINCIPLE_PROMPT =
-  "Write one actionable sentence that would prevent this issue from happening again. If no clear lesson, leave principle empty. Be concise.";
-
-/** Principle extraction instruction for session learnings. */
-export const LEARNING_PRINCIPLE_PROMPT =
-  "If this session taught a reusable lesson, write one actionable sentence that would prevent the same issue in the future. If no clear lesson, leave empty. Be concise.";

package/src/tools/eval-principles.ts

@@ -1,234 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Principle Evaluation — generate, regenerate, or compare candidate principles.
- *
- * Reads failures (capture.md) and learnings (frontmatter .md) and uses Haiku
- * to generate candidate principles. Useful for tuning prompt quality.
- *
- * Modes:
- *   --dry-run     Preview which files would be updated
- *   --evaluate    Show current vs new principle for comparison (does not write)
- *   --force       Regenerate principles even if one already exists
- *   (default)     Generate missing principles only
- *
- * Usage:
- *   bun run tool:eval                    # generate missing
- *   bun run tool:eval -- --dry-run       # preview
- *   bun run tool:eval -- --evaluate      # compare current vs new
- *   bun run tool:eval -- --force         # regenerate all
- */
-
-import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { hasFrontmatter, parse, stringify } from "../hooks/lib/frontmatter";
-import { inference } from "../hooks/lib/inference";
-import { palHome } from "../hooks/lib/paths";
-import {
-  FAILURE_PRINCIPLE_PROMPT,
-  LEARNING_PRINCIPLE_PROMPT,
-} from "../hooks/lib/prompts";
-
-const args = process.argv.slice(2);
-const dryRun = args.includes("--dry-run");
-const evaluate = args.includes("--evaluate");
-const force = args.includes("--force");
-
-const home = palHome();
-let processed = 0;
-let skipped = 0;
-let failed = 0;
-
-async function generatePrinciple(systemPrompt: string, context: string): Promise<string> {
-  const result = await inference({
-    system: systemPrompt,
-    user: context,
-    maxTokens: 100,
-    timeout: 10000,
-    jsonSchema: {
-      type: "object" as const,
-      additionalProperties: false,
-      properties: {
-        principle: { type: "string" as const },
-      },
-      required: ["principle"],
-    },
-  });
-
-  if (result.success && result.output) {
-    const parsed = JSON.parse(result.output) as { principle?: string };
-    const principle = parsed.principle?.trim() || "";
-    if (principle.length > 10) return principle;
-  }
-  return "";
-}
-
-// ── Failures ──
-
-async function processFailures() {
-  const failuresDir = resolve(home, "memory", "learning", "failures");
-  if (!existsSync(failuresDir)) return;
-
-  for (const year of readdirSync(failuresDir)) {
-    const yearDir = resolve(failuresDir, year);
-    for (const month of readdirSync(yearDir)) {
-      const monthDir = resolve(yearDir, month);
-      for (const slug of readdirSync(monthDir)) {
-        const capturePath = resolve(monthDir, slug, "capture.md");
-        if (!existsSync(capturePath)) continue;
-
-        const content = readFileSync(capturePath, "utf-8");
-        if (!hasFrontmatter(content)) continue;
-
-        const { meta, body } = parse<{
-          principle?: string;
-          context?: string;
-          rating?: number;
-        }>(content);
-
-        const hasPrinciple = !!meta.principle;
-        if (hasPrinciple && !force && !evaluate) {
-          skipped++;
-          continue;
-        }
-
-        const context = meta.context || "";
-        if (!context) {
-          skipped++;
-          continue;
-        }
-
-        const inputContext = `Rating: ${meta.rating}/10\nContext: ${context}\n\n${body.slice(0, 400)}`;
-
-        if (dryRun) {
-          console.log(`  [failure] ${slug.slice(0, 60)}`);
-          processed++;
-          continue;
-        }
-
-        try {
-          const newPrinciple = await generatePrinciple(
-            FAILURE_PRINCIPLE_PROMPT,
-            inputContext
-          );
-          if (!newPrinciple) {
-            skipped++;
-            continue;
-          }
-
-          if (evaluate) {
-            console.log(`  [failure] ${slug.slice(0, 50)}`);
-            if (hasPrinciple) {
-              console.log(`    OLD: ${meta.principle}`);
-            }
-            console.log(`    NEW: ${newPrinciple}`);
-            console.log("");
-            processed++;
-            continue;
-          }
-
-          const newMeta = { ...meta, principle: newPrinciple } as Record<string, unknown>;
-          writeFileSync(capturePath, stringify(newMeta, body), "utf-8");
-          console.log(`  [failure] ${slug.slice(0, 60)}`);
-          processed++;
-        } catch {
-          failed++;
-        }
-      }
-    }
-  }
-}
-
-// ── Learnings ──
-
-async function processLearnings() {
-  const learningDir = resolve(home, "memory", "learning", "session");
-  if (!existsSync(learningDir)) return;
-
-  for (const year of readdirSync(learningDir)) {
-    const yearDir = resolve(learningDir, year);
-    for (const month of readdirSync(yearDir)) {
-      const monthDir = resolve(yearDir, month);
-      for (const file of readdirSync(monthDir).filter((f) => f.endsWith(".md"))) {
-        const filepath = resolve(monthDir, file);
-        const content = readFileSync(filepath, "utf-8");
-
-        if (!hasFrontmatter(content)) {
-          skipped++;
-          continue;
-        }
-
-        const { meta, body } = parse<{
-          principle?: string;
-          title?: string;
-        }>(content);
-
-        const hasPrinciple = !!meta.principle;
-        if (hasPrinciple && !force && !evaluate) {
-          skipped++;
-          continue;
-        }
-
-        const title = meta.title || "";
-        if (!title) {
-          skipped++;
-          continue;
-        }
-
-        const inputContext = `Title: ${title}\n\n${body.slice(0, 400)}`;
-
-        if (dryRun) {
-          console.log(`  [learning] ${file.slice(0, 60)}`);
-          processed++;
-          continue;
-        }
-
-        try {
-          const newPrinciple = await generatePrinciple(
-            LEARNING_PRINCIPLE_PROMPT,
-            inputContext
-          );
-          if (!newPrinciple) {
-            skipped++;
-            continue;
-          }
-
-          if (evaluate) {
-            console.log(`  [learning] ${file.slice(0, 50)}`);
-            if (hasPrinciple) {
-              console.log(`    OLD: ${meta.principle}`);
-            }
-            console.log(`    NEW: ${newPrinciple}`);
-            console.log("");
-            processed++;
-            continue;
-          }
-
-          const newMeta = { ...meta, principle: newPrinciple } as Record<string, unknown>;
-          writeFileSync(filepath, stringify(newMeta, body), "utf-8");
-          console.log(`  [learning] ${file.slice(0, 60)}`);
-          processed++;
-        } catch {
-          failed++;
-        }
-      }
-    }
-  }
-}
-
-// ── Main ──
-
-const mode = evaluate
-  ? "evaluate"
-  : force
-    ? "force regenerate"
-    : dryRun
-      ? "dry run"
-      : "backfill";
-console.log(`\n  Principle ${mode}...\n`);
-
-await processFailures();
-await processLearnings();
-
-console.log(
-  `\n  Done: ${processed} ${evaluate ? "compared" : "processed"}, ${skipped} skipped, ${failed} failed\n`
-);