portable-agent-layer 0.78.1 → 0.78.3

package/src/hooks/lib/retrieval-index.ts

@@ -8,7 +8,7 @@
  */
 
 import { spawn } from "node:child_process";
-import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { SIMILARITY_THRESHOLD } from "./graduation";
 import { readFailures, readReflections } from "./learning-store";
@@ -197,14 +197,21 @@ export function readIndex(): RetrievalIndex | null {
 }
 
 /** True if any source directory was modified after the index was built. */
+function newestFileMtime(dir: string): number {
+  let newest = 0;
+  for (const entry of readdirSync(dir, { recursive: true, withFileTypes: true })) {
+    if (!entry.isFile()) continue;
+    newest = Math.max(newest, statSync(resolve(entry.parentPath, entry.name)).mtimeMs);
+  }
+  return newest;
+}
+
 export function isStale(index: RetrievalIndex): boolean {
   try {
     const builtMs = new Date(index.builtAt).getTime();
-    for (const dir of [paths.failures(), paths.wisdom(), paths.reflections()]) {
-      if (!existsSync(dir)) continue;
-      if (statSync(dir).mtimeMs > builtMs) return true;
-    }
-    return false;
+    return [paths.failures(), paths.wisdom(), paths.reflections()].some(
+      (dir) => newestFileMtime(dir) > builtMs
+    );
   } catch {
     return false;
   }

package/src/hooks/lib/security.ts

@@ -4,6 +4,9 @@
  */
 
 import { lstatSync } from "node:fs";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { palHome, platform } from "./paths";
 
 // PowerShell aliases rm, rmdir, del, erase, rd and ri all to Remove-Item, and
 // cmd ships its own rd and del — so the verb alone never says which shell ran it.
@@ -76,9 +79,14 @@ const WIN_ELEVATED_THREATS: [RegExp, string][] = [
   [/\bdiskpart\b/i, "Disk partitioning"],
 ];
 
+const POSIX_ROOT_TARGET = String.raw`["']?(?:(?:~|\$HOME|\$\{HOME\})/?|/)\*?["']?(?=\s|[;&|]|$)`;
+
 /** Dangerous command patterns — always blocked */
 const BLOCKED_COMMANDS: [RegExp, string][] = [
-  [/rm\s+-rf\s+[/~]/, "Recursive delete of root or home"],
+  [
+    new RegExp(String.raw`rm\s+-rf\s+${POSIX_ROOT_TARGET}`),
+    "Recursive delete of root or home",
+  ],
   [/mkfs\./, "Filesystem format"],
   [/dd\s+if=.*of=\/dev\//, "Raw disk write"],
   [/>\s*\/dev\/sd/, "Direct device write"],
@@ -137,13 +145,8 @@ const HOOK_MANAGED_DIRS = [
   "debug",
 ];
 
-/** Escape a string for use in a RegExp */
-function escapeRegExp(s: string): string {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
 /** PAL-deployed dirs — engine-managed, overwritten on every `pal install` */
-const PAL_INSTALLED_DIRS_RE = /[/\\]\.pal[/\\](?:docs|skills|tools)[/\\]/;
+const PAL_INSTALLED_DIRS = ["docs", "skills", "tools"];
 
 /** Paths that should never be written to */
 const PROTECTED_PATHS: RegExp[] = [
@@ -154,31 +157,108 @@ const PROTECTED_PATHS: RegExp[] = [
   /\.gnupg\//,
   // Claude Code auto-memory — PAL owns memory; writes here indicate wrong system is being used
   /\.claude\/projects\/[^/]+\/memory\//,
-  // PAL_INSTALLED_DIRS_RE is enforced by the dedicated branch in checkFilePath
-  // (which exempts personal skill dirs); keeping it here would re-block them.
-  // Derived from HOOK_MANAGED_FILES — scoped to managed roots only
-  ...HOOK_MANAGED_FILES.map(
-    (name) =>
-      new RegExp(
-        String.raw`[/\\]\.(?:pal|claude|agents|cursor)[/\\].*${escapeRegExp(name)}$`
-      )
-  ),
 ];
 
-/** Roots where managed files/dirs are protected (user state, not repo templates) */
-const MANAGED_ROOTS = [".pal/", ".claude/", ".agents/", ".config/opencode/", ".cursor/"];
+function comparable(path: string): string {
+  const forward = path.replaceAll("\\", "/").replace(/\/+$/, "");
+  return process.platform === "win32" ? forward.toLowerCase() : forward;
+}
+
+function absoluteComparable(path: string): string {
+  return comparable(resolve(path.replaceAll("\\", "/")));
+}
+
+/** The part of `path` below `root`, or null when `path` is outside it. */
+function pathBelow(root: string, path: string): string | null {
+  const base = absoluteComparable(root);
+  const target = absoluteComparable(path);
+  return target.startsWith(`${base}/`) ? target.slice(base.length + 1) : null;
+}
+
+/** The real directories PAL writes user state into, not any folder that shares their name. */
+function managedRoots(): string[] {
+  return [
+    palHome(),
+    platform.claudeDir(),
+    platform.agentsDir(),
+    platform.cursorDir(),
+    platform.opencodeDir(),
+  ];
+}
+
+function pathInsideManagedRoot(path: string): string | null {
+  for (const root of managedRoots()) {
+    const below = pathBelow(root, path);
+    if (below !== null) return below;
+  }
+  return null;
+}
 
-function isUnderManagedRoot(path: string): boolean {
-  const normalized = path.replaceAll("\\", "/");
-  return MANAGED_ROOTS.some(
-    (root) => normalized.includes(`/${root}`) || normalized.includes(`\\.${root}`)
-  );
+function managedFileAt(below: string): string | undefined {
+  return HOOK_MANAGED_FILES.find((name) => {
+    const file = comparable(name);
+    return below === file || below.endsWith(`/${file}`);
+  });
+}
+
+function managedDirAt(below: string): string | undefined {
+  return HOOK_MANAGED_DIRS.find((dir) => `/${below}/`.includes(`/${comparable(dir)}/`));
+}
+
+function managedPathReason(path: string): string | null {
+  const below = pathInsideManagedRoot(path);
+  if (below === null) return null;
+  const file = managedFileAt(below);
+  if (file) return `${file} is managed automatically by hooks — do not edit directly`;
+  const dir = managedDirAt(below);
+  if (dir) return `${dir}/ is managed automatically by hooks — do not edit directly`;
+  return null;
+}
+
+const HOME_PREFIX =
+  /^(?:~|\$HOME|\$\{HOME\}|\$env:USERPROFILE|%USERPROFILE%)(?=[/\\]|$)/i;
+const COMMAND_TOKEN = /[^\s'"`<>|;&()=]+/g;
+
+function pathsNamedIn(segment: string): string[] {
+  return Array.from(segment.matchAll(COMMAND_TOKEN), (m) => m[0])
+    .filter((token) => HOME_PREFIX.test(token) || /[/\\]/.test(token))
+    .map((token) => token.replace(HOME_PREFIX, () => homedir()));
+}
+
+function managedReasonInSegment(segment: string): string | null {
+  for (const path of pathsNamedIn(segment)) {
+    const reason = managedPathReason(path);
+    if (reason) return reason;
+  }
+  return null;
 }
 
 /** Read-only commands allowed to reference protected files */
 const READ_ONLY_COMMANDS =
   /^\s*(?:cat|head|tail|less|more|grep|rg|wc|diff|stat|file|ls|dir|find|git\s+(?:log|diff|blame|show|status)|bat)\b/;
 
+const COMMAND_SEPARATORS = new Set(["|", ";", "&"]);
+
+function unquotedSegments(cmd: string): string[] {
+  const segments: string[] = [];
+  let current = "";
+  let quote: string | null = null;
+  for (const char of cmd) {
+    if (quote) {
+      if (char === quote) quote = null;
+    } else if (char === "'" || char === '"') {
+      quote = char;
+    } else if (COMMAND_SEPARATORS.has(char)) {
+      segments.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  segments.push(current.trim());
+  return segments;
+}
+
 /** Check a bash command against blocked patterns. Returns reason string or null. */
 export function checkBashCommand(cmd: string): string | null {
   for (const [pattern, reason] of BLOCKED_COMMANDS) {
@@ -189,26 +269,9 @@ export function checkBashCommand(cmd: string): string | null {
       if (pattern.test(cmd)) return reason;
     }
   }
-  // If command references a managed file in a managed root path, block unless read-only.
-  // The filename must appear IN the same path as the managed root (e.g. .pal/.../file.json).
-  const segments = cmd.split(/[|;&&]/).map((s) => s.trim());
-  for (const name of HOOK_MANAGED_FILES) {
-    const pattern = new RegExp(
-      String.raw`\.(?:pal|claude|agents|cursor|config/opencode)[/\\]\S*${escapeRegExp(name)}`
-    );
-    const managed = segments.filter((s) => pattern.test(s));
-    if (managed.length > 0 && !managed.every((s) => READ_ONLY_COMMANDS.test(s))) {
-      return `${name} is managed automatically by hooks — do not edit directly`;
-    }
-  }
-  for (const dir of HOOK_MANAGED_DIRS) {
-    const pattern = new RegExp(
-      String.raw`\.(?:pal|claude|agents|cursor|config/opencode)[/\\]\S*${escapeRegExp(dir)}`
-    );
-    const managed = segments.filter((s) => pattern.test(s));
-    if (managed.length > 0 && !managed.every((s) => READ_ONLY_COMMANDS.test(s))) {
-      return `${dir} is managed automatically by hooks — do not edit directly`;
-    }
+  for (const segment of unquotedSegments(cmd)) {
+    const reason = managedReasonInSegment(segment);
+    if (reason && !READ_ONLY_COMMANDS.test(segment)) return reason;
   }
   return null;
 }
@@ -218,44 +281,25 @@ export function checkBashCommand(cmd: string): string | null {
  * skills are real dirs authored in place. A not-yet-created skill dir is also
  * personal (scaffolding). So: symlink → shipped/protected, otherwise → personal.
  */
-function isShippedSkillPath(normalized: string): boolean {
-  const m = /\.pal\/skills\/([^/]+)/.exec(normalized);
-  if (!m) return false;
-  const skillRoot = normalized.slice(0, m.index + m[0].length);
+function isShippedSkill(name: string): boolean {
   try {
-    return lstatSync(skillRoot).isSymbolicLink();
+    return lstatSync(resolve(palHome(), "skills", name)).isSymbolicLink();
   } catch {
     return false;
   }
 }
 
+function palInstalledReason(path: string): string | null {
+  const [dir, entry] = pathBelow(palHome(), path)?.split("/") ?? [];
+  if (!dir || !entry || !PAL_INSTALLED_DIRS.includes(dir)) return null;
+  if (dir === "skills" && !isShippedSkill(entry)) return null;
+  return `~/.pal/${dir}/ is managed by 'pal install' — edit the source in the PAL repo instead`;
+}
+
 /** Check a file path against protected patterns. Returns a reason string or null. */
 export function checkFilePath(filePath: string): string | null {
-  const normalized = filePath.replaceAll("\\", "/");
-  // Check hook-managed files — only under managed roots (not repo templates)
-  if (isUnderManagedRoot(normalized)) {
-    const matchedFile = HOOK_MANAGED_FILES.find((name) =>
-      normalized.endsWith(`/${name}`)
-    );
-    if (matchedFile) {
-      return `${matchedFile} is managed automatically by hooks — do not edit directly`;
-    }
-  }
-  // Check hook-managed directories
-  const matchedDir = HOOK_MANAGED_DIRS.find((dir) => normalized.includes(`/${dir}/`));
-  if (matchedDir) {
-    return `${matchedDir}/ is managed automatically by hooks — do not edit directly`;
-  }
-  // PAL-deployed dirs — edit source in the PAL repo, not the installed copy
-  if (PAL_INSTALLED_DIRS_RE.test(normalized)) {
-    const match = new RegExp(/\.pal[/\\](docs|skills|tools)/).exec(normalized);
-    const dir = match ? match[1] : "docs/skills/tools";
-    const isPersonalSkill = dir === "skills" && !isShippedSkillPath(normalized);
-    if (!isPersonalSkill) {
-      return `~/.pal/${dir}/ is managed by 'pal install' — edit the source in the PAL repo instead`;
-    }
-  }
-  // Check remaining system-protected paths
+  const reason = managedPathReason(filePath) ?? palInstalledReason(filePath);
+  if (reason) return reason;
   if (PROTECTED_PATHS.some((pattern) => pattern.test(filePath))) {
     return `Protected path: ${filePath}`;
   }

package/src/hooks/lib/semi-static.ts

@@ -7,10 +7,11 @@
  */
 
 import { existsSync, readFileSync } from "node:fs";
-import { resolve } from "node:path";
+import { basename, resolve } from "node:path";
 import { type FailureEntry, readFailures } from "./learning-store";
 import { loadOpinionContext } from "./opinions";
 import { palHome, paths } from "./paths";
+import { type ProjectProgress, readAllProjects, resolveProjectFromCwd } from "./projects";
 import { readFramePrinciples } from "./wisdom";
 
 /** A single semi-static context source — built at session stop, loaded natively at session start. */
@@ -67,6 +68,12 @@ export function rankFailures(
     .slice(0, limit);
 }
 
+function projectTag(cwd: string, projects: ProjectProgress[]): string {
+  if (!cwd) return "";
+  const name = resolveProjectFromCwd(cwd, projects)?.name ?? basename(cwd);
+  return `[${name}]`;
+}
+
 /** Build the failure avoid-list, prioritized by relevance to the current project. */
 export function loadFailurePatterns(): string {
   try {
@@ -74,11 +81,11 @@ export function loadFailurePatterns(): string {
     const all = readFailures(paths.failures());
     if (all.length === 0) return "";
 
+    const projects = readAllProjects();
     const lines = rankFailures(all, cwd).map((e) => {
       const label = e.rating ? `[${e.rating}/10]` : "";
-      const tag = e.cwd === cwd ? "[project]" : "[other]";
       const text = e.principle || e.context;
-      return `- ${label} ${tag} ${text}`.trim();
+      return ["-", label, projectTag(e.cwd, projects), text].filter(Boolean).join(" ");
     });
 
     return ["## Lessons from Recent Failures — Apply These Now", ...lines].join("\n");

package/src/hooks/lib/settings.ts

@@ -54,28 +54,27 @@ const IDENTITY_DEFAULTS: Identity = {
 
 // ── Singleton ──
 
-let cached: PalSettingsData | null = null;
+let cached: { path: string; data: PalSettingsData } | null = null;
 
 function settingsPath(): string {
   return resolve(paths.memory(), "pal-settings.json");
 }
 
-function load(): PalSettingsData {
-  if (cached) return cached;
-  const p = settingsPath();
-  if (!existsSync(p)) {
-    cached = {};
-    return cached;
-  }
+function readSettingsFile(p: string): PalSettingsData {
+  if (!existsSync(p)) return {};
   try {
-    cached = JSON.parse(readFileSync(p, "utf-8")) as PalSettingsData;
-    return cached;
+    return JSON.parse(readFileSync(p, "utf-8")) as PalSettingsData;
   } catch {
-    cached = {};
-    return cached;
+    return {};
   }
 }
 
+function load(): PalSettingsData {
+  const p = settingsPath();
+  if (cached?.path !== p) cached = { path: p, data: readSettingsFile(p) };
+  return cached.data;
+}
+
 /** Force re-read from disk (useful after writes) */
 export function reload(): PalSettingsData {
   cached = null;

package/src/tools/{relationship-reflect.ts → agent/relationship-reflect.ts}

@@ -8,17 +8,17 @@
  * - Generate a summary report
  *
  * Usage:
- *   bun run tool:reflect              # Reflect on last 7 days
- *   bun run tool:reflect -- --month   # Reflect on last 30 days
- *   bun run tool:reflect -- --dry-run # Preview without writing
+ *   pal cli relationship-reflect             # Reflect on last 7 days
+ *   pal cli relationship-reflect --month     # Reflect on last 30 days
+ *   pal cli relationship-reflect --dry-run   # Preview without writing
  */
 
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { parseArgs } from "node:util";
-import { readOpinions, saveOpinion, setLastReflectDate } from "../hooks/lib/opinions";
-import { palHome } from "../hooks/lib/paths";
-import { emit } from "./lib/emit";
+import { readOpinions, saveOpinion, setLastReflectDate } from "../../hooks/lib/opinions";
+import { palHome } from "../../hooks/lib/paths";
+import { emit } from "../lib/emit";
 import {
   consoleLines,
   formatReport,
@@ -27,7 +27,8 @@ import {
   loadRatings,
   planPromotions,
   reportPath,
-} from "./lib/relationship-reflect";
+} from "../lib/relationship-reflect";
+import { scriptArgs } from "../lib/script-args";
 
 const HELP = `
 RelationshipReflect — Periodic reflection + opinion promotion
@@ -36,9 +37,9 @@ Reads recent relationship notes and ratings. Promotes recurring
 observations (O type) into tracked opinions with confidence scoring.
 
 Usage:
-  bun run tool:reflect              Reflect on last 7 days (default)
-  bun run tool:reflect -- --month   Reflect on last 30 days
-  bun run tool:reflect -- --dry-run Preview without writing
+  pal cli relationship-reflect             Reflect on last 7 days (default)
+  pal cli relationship-reflect --month     Reflect on last 30 days
+  pal cli relationship-reflect --dry-run   Preview without writing
 
 Output:
   - Updates memory/relationship/opinions.json (confidence tracking)
@@ -56,9 +57,9 @@ function saveReport(report: string, period: string): string {
   return filepath;
 }
 
-function run() {
+export function run(argv: string[] = scriptArgs()) {
   const { values } = parseArgs({
-    args: Bun.argv.slice(2),
+    args: argv,
     options: {
       month: { type: "boolean" },
       "dry-run": { type: "boolean" },