portable-agent-layer 0.35.0 → 0.37.0

package/src/targets/opencode/uninstall.ts

@@ -1,11 +1,12 @@
 /**
  * PAL — opencode uninstaller (TypeScript)
- * Removes plugin and AGENTS.md.
+ * Removes plugin, AGENTS.md, and PAL entries from config.json.
  */
 
-import { unlinkSync } from "node:fs";
+import { existsSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { platform } from "../../hooks/lib/paths";
+import { getSemiStaticSources } from "../../hooks/lib/semi-static";
 import { log, removeAgentsFromOpencode, removePalDocs, removeSkills } from "../lib";
 
 const OC_GLOBAL_DIR = platform.opencodeDir() || "";
@@ -41,7 +42,7 @@ if (removedAgents.length > 0)
 // --- Remove PAL system docs ---
 removePalDocs();
 
-// --- Remove AGENTS.md and CLAUDE.md symlink ---
+// --- Remove AGENTS.md and CLAUDE.md ---
 const agentsMd = resolve(OC_GLOBAL_DIR, "AGENTS.md");
 const claudeMd = resolve(PAL_CLAUDE_DIR, "CLAUDE.md");
 try {
@@ -57,4 +58,30 @@ try {
   /* gone */
 }
 
+// --- Remove PAL entries from config.json instructions[] ---
+const configPath = resolve(OC_GLOBAL_DIR, "config.json");
+if (existsSync(configPath) && statSync(configPath).size > 0) {
+  try {
+    const ocConfig = JSON.parse(readFileSync(configPath, "utf-8")) as Record<
+      string,
+      unknown
+    >;
+    if (Array.isArray(ocConfig.instructions)) {
+      const palFiles = new Set(getSemiStaticSources().map((s) => s.path));
+      const filtered = (ocConfig.instructions as string[]).filter(
+        (p) => !palFiles.has(p)
+      );
+      if (filtered.length === 0) {
+        delete ocConfig.instructions;
+      } else {
+        ocConfig.instructions = filtered;
+      }
+      writeFileSync(configPath, `${JSON.stringify(ocConfig, null, 2)}\n`, "utf-8");
+      log.success("Removed PAL entries from config.json instructions[]");
+    }
+  } catch {
+    log.warn("Could not clean config.json instructions[] — check manually");
+  }
+}
+
 log.success("opencode uninstall complete");

package/src/tools/agent/algorithm-reflect.ts

@@ -40,7 +40,7 @@ function reflectionsPath(): string {
   return resolve(dir, "algorithm-reflections.jsonl");
 }
 
-export function appendReflection(reflection: AlgorithmReflection): {
+function appendReflection(reflection: AlgorithmReflection): {
   success: boolean;
   message: string;
   path: string;

package/src/tools/agent/analyze.ts

@@ -34,25 +34,26 @@ export function printReport(result: AnalysisResult): void {
 
   if (result.ratings) {
     const r = result.ratings;
-    const avgColor = r.average >= 7 ? c.green : r.average <= 4 ? c.red : c.yellow;
+    const lowOrMid = r.average <= 4 ? c.red : c.yellow;
+    const avgColor = r.average >= 7 ? c.green : lowOrMid;
+    const ratingStr = `${r.average.toFixed(1)}/10`;
+    const lowStr = `Low (≤4): ${r.low.count}`;
+    const highStr = `High (≥7): ${r.high.count}`;
     console.log(
-      `\n  ${c.bold("Ratings:")} ${avgColor(`${r.average.toFixed(1)}/10`)} avg (${r.total} total)`
-    );
-    console.log(
-      `  ${c.red(`Low (≤4): ${r.low.count}`)} | ${c.green(`High (≥7): ${r.high.count}`)}`
+      `\n  ${c.bold("Ratings:")} ${avgColor(ratingStr)} avg (${r.total} total)`
     );
+    console.log(`  ${c.red(lowStr)} | ${c.green(highStr)}`);
   }
 
   if (result.candidates.length > 0) {
-    console.log(
-      `\n  ${c.bold(c.green(`Graduation Report — ${result.candidates.length} pattern(s) detected`))}\n`
-    );
+    const graduationHeader = `Graduation Report — ${result.candidates.length} pattern(s) detected`;
+    console.log(`\n  ${c.bold(c.green(graduationHeader))}\n`);
     console.log(`  ${c.dim("─────────────────────────────────────────────────")}\n`);
 
     for (const candidate of result.candidates) {
-      console.log(
-        `  ${c.cyan(`[${candidate.domain}]`)} ${c.bold(`${candidate.entries.length}x`)} occurrences`
-      );
+      const domain = `[${candidate.domain}]`;
+      const count = `${candidate.entries.length}x`;
+      console.log(`  ${c.cyan(domain)} ${c.bold(count)} occurrences`);
       console.log("");
 
       for (const entry of candidate.entries) {
@@ -72,9 +73,8 @@ export function printReport(result: AnalysisResult): void {
       }
 
       console.log("");
-      console.log(
-        `  Target frame: ${c.magenta(`memory/wisdom/frames/${candidate.domain}.md`)}`
-      );
+      const framePath = `memory/wisdom/frames/${candidate.domain}.md`;
+      console.log(`  Target frame: ${c.magenta(framePath)}`);
       console.log(`  ${c.dim("─────────────────────────────────────────────────")}\n`);
     }
   }
@@ -82,9 +82,9 @@ export function printReport(result: AnalysisResult): void {
   if (result.emerging.length > 0) {
     console.log(`  ${c.bold(c.yellow("Emerging (2x — one more to graduate)"))}\n`);
     for (const group of result.emerging) {
-      console.log(
-        `  ${c.cyan(`[${group.domain}]`)} ${c.bold(`${group.entries.length}x`)}`
-      );
+      const domain = `[${group.domain}]`;
+      const count = `${group.entries.length}x`;
+      console.log(`  ${c.cyan(domain)} ${c.bold(count)}`);
       for (const entry of group.entries) {
         const sourceType = entry.source.startsWith("failure:") ? "failure" : "learning";
         const tag =
@@ -154,4 +154,4 @@ async function run() {
   printReport(result);
 }
 
-if (import.meta.main) run();
+if (import.meta.main) await run();

package/src/tools/agent/handoff-note.ts

@@ -0,0 +1,116 @@
+#!/usr/bin/env bun
+/**
+ * HandoffNote — Write or clear a handoff note for the current project.
+ *
+ * Called in the ALGORITHM LEARN phase when work is unfinished.
+ * Written by Claude in-session — no inference call needed.
+ *
+ * Usage:
+ *   bun ~/.pal/tools/handoff-note.ts --title "what we were doing" --text "what remains + next steps"
+ *   bun ~/.pal/tools/handoff-note.ts --done   # mark completed, suppress next-session injection
+ */
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { parseArgs } from "node:util";
+import { ensureDir, paths } from "../../hooks/lib/paths";
+
+interface HandoffEntry {
+  timestamp: string;
+  title: string;
+  status: "in-progress" | "completed";
+  handoff: string;
+  artifacts: string[];
+}
+
+function handoffPath(): string {
+  return resolve(ensureDir(paths.state()), "last-handoff.json");
+}
+
+function readHandoffs(): Record<string, HandoffEntry> {
+  const p = handoffPath();
+  if (!existsSync(p)) return {};
+  try {
+    return JSON.parse(readFileSync(p, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+function writeHandoffs(handoffs: Record<string, HandoffEntry>): void {
+  const entries = Object.entries(handoffs);
+  const trimmed = entries.length > 20 ? Object.fromEntries(entries.slice(-20)) : handoffs;
+  writeFileSync(handoffPath(), JSON.stringify(trimmed, null, 2), "utf-8");
+}
+
+function writeHandoffNote(
+  cwd: string,
+  title: string,
+  text: string,
+  done: boolean
+): { success: boolean; message: string } {
+  const handoffs = readHandoffs();
+  handoffs[cwd] = {
+    timestamp: new Date().toISOString(),
+    title,
+    status: done ? "completed" : "in-progress",
+    handoff: text,
+    artifacts: [],
+  };
+  writeHandoffs(handoffs);
+  return {
+    success: true,
+    message: done ? "Handoff cleared (marked completed)" : "Handoff note written",
+  };
+}
+
+function run() {
+  const { values } = parseArgs({
+    args: Bun.argv.slice(2),
+    options: {
+      title: { type: "string" },
+      text: { type: "string" },
+      done: { type: "boolean" },
+      help: { type: "boolean", short: "h" },
+    },
+  });
+
+  if (values.help) {
+    console.log(`
+HandoffNote — Write a handoff note for the current project
+
+Usage:
+  bun ~/.pal/tools/handoff-note.ts --title "what we were doing" --text "what remains"
+  bun ~/.pal/tools/handoff-note.ts --done    # mark session completed
+
+Arguments:
+  --title   Brief title of what was being worked on (5-10 words)
+  --text    What remains unfinished — decisions made, next steps, blockers
+  --done    Mark as completed; suppresses "pick up where you left off" injection
+
+Output: writes to memory/state/last-handoff.json keyed by cwd
+`);
+    process.exit(0);
+  }
+
+  if (values.done) {
+    const result = writeHandoffNote(
+      process.cwd(),
+      values.title || "session",
+      values.text || "",
+      true
+    );
+    console.log(JSON.stringify(result, null, 2));
+    process.exit(0);
+  }
+
+  if (!values.title || !values.text) {
+    console.error("Required: --title and --text (or --done to close)");
+    process.exit(1);
+  }
+
+  const result = writeHandoffNote(process.cwd(), values.title, values.text, false);
+  console.log(JSON.stringify(result, null, 2));
+}
+
+if (import.meta.main) run();