portable-agent-layer 0.78.2 → 0.79.0

package/README.md

@@ -77,7 +77,7 @@ pal cli status        # check your setup
 | `pal cli init` | Scaffold PAL home directory and install hooks |
 | `pal cli install` | Register hooks/skills for targets |
 | `pal cli uninstall` | Remove hooks/skills for targets |
-| `pal cli update` | Update PAL (git pull or npm update) and reinstall hooks. Install asks once whether to do this daily on its own, applied when a session closes so opening PAL is never slowed; the switch lives in the control room under Settings → Updates. On a repo install a daily run waits while the clone has uncommitted changes |
+| `pal cli update` | Update PAL (git pull or npm update) and reinstall hooks. Install asks once whether to do this on its own: when a session closes PAL checks for a release (at most hourly) and installs it, so opening PAL is never slowed. A failed update waits a day before retrying. The switch lives in the control room under Settings → Updates. On a repo install an update waits while the clone has uncommitted changes |
 | `pal cli export` | Export user state (telos, memory) to a zip |
 | `pal cli import` | Import user state from a zip |
 | `pal cli status` | Show current PAL configuration |
@@ -156,7 +156,7 @@ PAL routes inference through the host agent's subscription CLI by default. API k
 Enable verbose hook logging with:
 
 ```
-pal cli debug on    # enable  → logs to memory/state/debug.log
+pal cli debug on    # enable  → logs to debug/debug.log
 pal cli debug off   # disable
 pal cli debug       # show current status and log path
 ```
@@ -165,6 +165,7 @@ pal cli debug       # show current status and log path
 |----------|-------------|
 | `PAL_INFERENCE_DISABLED` | Set to `1` to disable all inference (used by the test suite to prevent real CLI spawns) |
 | `PAL_NOTIFICATIONS_DISABLED` | Set to `1` to suppress desktop notifications (used by the test suite) |
+| `PAL_TEST_SANDBOX` | Set by the test suite. Without a `PAL_HOME`, state goes to a temp directory instead of `~/.pal`, and installers refuse to touch real agent directories |
 
 ---
 

package/assets/schema/pal-settings.schema.json

@@ -57,7 +57,6 @@
         "wisdom": { "type": "boolean", "description": "Crystallized wisdom principles." },
         "opinions": { "type": "boolean", "description": "Tracked user opinions." },
         "relationship": { "type": "boolean", "description": "Recent relationship notes." },
-        "learningDigest": { "type": "boolean", "description": "Lessons-from-failures digest." },
         "failurePatterns": { "type": "boolean", "description": "Recurring failure patterns." },
         "projectHistory": { "type": "boolean", "description": "Per-project session history." },
         "projects": { "type": "boolean", "description": "Active projects list." },

package/assets/skills/pal-reflect/SKILL.md

@@ -19,10 +19,10 @@ When `/pal-reflect` is invoked (by you in response to a nudge, or by the user di
 ## 1. Run the reflect tool
 
 ```bash
-bun run tool:reflect
+pal cli relationship-reflect
 ```
 
-If the user passed `--dry-run`, append it: `bun run tool:reflect -- --dry-run`
+If the user passed `--dry-run`, append it: `pal cli relationship-reflect --dry-run`
 
 ## 2. Parse and present the output
 

package/assets/templates/PAL/SYSTEM_ARCHITECTURE.md

@@ -383,7 +383,7 @@ Relationship notes (O/B types)
 - Content is global/user-level — safe to pre-compile (not project-scoped)
 
 **Tier 3 — Dynamic** (injected fresh each session by LoadContext hook):
-- Handoff notes, session intelligence, open threads, relationship notes, project history
+- Handoff notes, session intelligence, relationship notes, project history
 - Changes per-session or is project-scoped — can't be pre-compiled
 - Injected as `<system-reminder>` block via stdout
 - Each section independently toggleable in `pal-settings.json → dynamicContext`
@@ -402,12 +402,12 @@ LoadContext.ts
   └─► Build system-reminder (dynamic sections only):
       1. loadAtStartup files (user-configured)
       2. Handoff note (in-progress work from last session)
-      3. Session intelligence (rating trend, algorithm performance)
-      4. Open threads (current project only)
+      3. Due nudges (algorithm review, relationship reflect, learning analysis)
+      4. Session intelligence (rating trend, algorithm performance)
       5. Recent interaction notes (last 2 days)
       6. Active projects
       7. Project session history (this project)
-      8. Signal trends (today/week/trend)
+      8. Other recent learnings (other projects, titles only)
 ```
 
 ### On-Demand Context

package/assets/templates/pal-settings.json

@@ -19,7 +19,6 @@
     "wisdom": true,
     "opinions": true,
     "relationship": true,
-    "learningDigest": true,
     "failurePatterns": true,
     "projectHistory": true,
     "projects": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "portable-agent-layer",
-  "version": "0.78.2",
+  "version": "0.79.0",
   "description": "PAL — Portable Agent Layer: persistent personal context for AI coding assistants",
   "type": "module",
   "bin": {
@@ -64,7 +64,7 @@
     "tool:synthesize": "bun run src/tools/agent/synthesize.ts",
     "tool:thread": "bun run src/tools/agent/thread.ts",
     "tool:wisdom-frame": "bun run src/tools/agent/wisdom-frame.ts",
-    "tool:reflect": "bun run src/tools/relationship-reflect.ts",
+    "tool:reflect": "bun run src/tools/agent/relationship-reflect.ts",
     "eval:sentiment": "bun eval/run.ts sentiment",
     "eval:failure-principle": "bun eval/run.ts failure-principle",
     "eval:goal-links": "bun eval/run.ts goal-links",

package/src/cli/builtin-tools.ts

@@ -13,6 +13,7 @@ const BUILTIN_TOOLS = {
   "handoff-note": () => import("../tools/agent/handoff-note"),
   project: () => import("../tools/agent/project"),
   "relationship-note": () => import("../tools/agent/relationship-note"),
+  "relationship-reflect": () => import("../tools/agent/relationship-reflect"),
   synthesize: () => import("../tools/agent/synthesize"),
   thread: () => import("../tools/agent/thread"),
   "wisdom-frame": () => import("../tools/agent/wisdom-frame"),

package/src/cli/index.ts

@@ -47,7 +47,7 @@ import {
   summarize,
 } from "../hooks/lib/import-merge";
 import { inference, previewInferenceRoute } from "../hooks/lib/inference";
-import { DEBUG_LOG_MAX_ROTATED, logDebug } from "../hooks/lib/log";
+import { logDebug, recentHookErrors } from "../hooks/lib/log";
 import { ensureRegistered, writeRegistryEntry } from "../hooks/lib/machine";
 import { palHome, palPkg, paths, platform, toPath } from "../hooks/lib/paths";
 import { auditBindings, describeBindingIssue } from "../hooks/lib/projects";
@@ -462,11 +462,6 @@ function resolveTargets(args: string[], health?: DoctorResult): Targets {
 
 // ── Hook health ──
 
-interface HookHealth {
-  totalErrors: number;
-  lastError: string | null;
-}
-
 function checkClaudeHooksRegistered(): boolean {
   const settingsPath = resolve(platform.claudeDir(), "settings.json");
   if (!existsSync(settingsPath)) return false;
@@ -645,7 +640,7 @@ async function probeInference(): Promise<void> {
         );
       } else {
         console.log(
-          `  ${red}✗${reset} ${tag} ${String(elapsedMs).padStart(6)}ms  ${dim}failed — see ~/.pal/memory/state/debug.log${reset}`
+          `  ${red}✗${reset} ${tag} ${String(elapsedMs).padStart(6)}ms  ${dim}failed — see ~/.pal/debug/debug.log${reset}`
         );
       }
     }
@@ -733,46 +728,6 @@ function rtkInstallHint(): string {
   return "`curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh`";
 }
 
-function checkHookHealth(home: string): HookHealth {
-  const stateDir = resolve(home, "memory", "state");
-  // Read current + all rotated logs (`.1`..`.5`) + legacy `.prev` so a recent
-  // rotation doesn't make the 24h window appear empty.
-  const candidates = [
-    resolve(stateDir, "debug.log"),
-    resolve(stateDir, "debug.log.prev"),
-    ...Array.from({ length: DEBUG_LOG_MAX_ROTATED }, (_, i) =>
-      resolve(stateDir, `debug.log.${i + 1}`)
-    ),
-  ];
-
-  try {
-    let content = "";
-    for (const path of candidates) {
-      if (existsSync(path)) content += `${readFileSync(path, "utf-8")}\n`;
-    }
-    if (!content) return { totalErrors: 0, lastError: null };
-
-    const lines = content.split("\n").filter((l) => l.includes("] ERROR "));
-
-    // Filter to last 24h
-    const cutoff = new Date(Date.now() - 24 * 60 * 60 * 1000);
-    const recentErrors = lines.filter((line) => {
-      const match = new RegExp(/^\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\]/).exec(line);
-      if (!match) return false;
-      return new Date(match[1]) > cutoff;
-    });
-
-    const lastError =
-      recentErrors.length > 0
-        ? (recentErrors.at(-1) ?? "").replace(/^\[.*?\] ERROR /, "").slice(0, 120)
-        : null;
-
-    return { totalErrors: recentErrors.length, lastError };
-  } catch {
-    return { totalErrors: 0, lastError: null };
-  }
-}
-
 // ── Doctor ──
 
 interface DoctorResult {
@@ -1131,7 +1086,7 @@ function doctor(silent = false): DoctorResult {
       : warn("PAL_PERPLEXITY_API_KEY — not set (optional, for Perplexity researcher)");
 
     // Hook health from debug.log
-    const hookHealth = checkHookHealth(home);
+    const hookHealth = recentHookErrors();
     if (hookHealth.totalErrors === 0) {
       ok("Hooks: no recent errors");
     } else {

package/src/cli/setup-auto-update.ts

@@ -1,5 +1,5 @@
 /**
- * Daily unattended updates — one-time opt-in prompt.
+ * Unattended updates — one-time opt-in prompt.
  *
  * Asked once during `pal install`, the same seam git attribution uses, so a new
  * user sees it at init and an existing one on their next update. The non-TTY
@@ -14,11 +14,11 @@ import { raw as readSettings, write as writeSettings } from "../hooks/lib/settin
 
 /** Only a git clone can be mid-change; a global package install has no such state. */
 function whatItDoes(): string {
-  const daily =
-    "Once a day, when you close a session, PAL updates itself in the background.\nOpening PAL is never slowed down, and the statusline says when to restart.";
+  const onClose =
+    "When you close a session, PAL checks for a new release (at most hourly) and installs it in the background.\nOpening PAL is never slowed down, and the statusline says when to restart.";
   return isRepoMode()
-    ? `${daily}\nIt waits while this clone has uncommitted changes.`
-    : daily;
+    ? `${onClose}\nIt waits while this clone has uncommitted changes.`
+    : onClose;
 }
 
 export async function promptAutoUpdate(): Promise<void> {
@@ -31,7 +31,7 @@ export async function promptAutoUpdate(): Promise<void> {
   clack.note(whatItDoes(), "Keep PAL up to date on its own?");
 
   const enabled = await clack.confirm({
-    message: "Turn on daily automatic updates?",
+    message: "Turn on automatic updates?",
     initialValue: false,
   });
   if (clack.isCancel(enabled)) {
@@ -41,6 +41,6 @@ export async function promptAutoUpdate(): Promise<void> {
 
   settings.autoUpdate = { enabled: enabled === true, decided: true };
   writeSettings(settings);
-  const state = enabled ? "Daily updates on" : "Daily updates off";
+  const state = enabled ? "Automatic updates on" : "Automatic updates off";
   clack.outro(`${state} ✓  ·  change later: control room → Settings → Updates`);
 }

package/src/hooks/AutoUpdate.ts

@@ -1,5 +1,5 @@
 /**
- * Spawned, never awaited — runs the daily self-update in a process of its own.
+ * Spawned, never awaited — runs the unattended self-update in a process of its own.
  *
  * LoadContext decides whether today's update is due; the control room's button
  * starts this directly. Either way the work happens here so nothing waits on a

package/src/hooks/LoadContext.ts

@@ -18,11 +18,13 @@ import { logContextSnapshot, logDebug, logError } from "./lib/log";
 import { platform } from "./lib/paths";
 import {
   contextEnvelope,
+  contextForSource,
   copilotInstructions,
   isSubagentSession,
   needsAgentsMd,
 } from "./lib/session-context";
 import { isPalSpawnedInference } from "./lib/spawn-guard";
+import { readStdinJSON } from "./lib/stdin";
 
 // Recursion guard — when this process is a PAL-spawned inference subprocess,
 // skip all context loading so we don't trigger another inference call.
@@ -47,11 +49,21 @@ try {
 
 try {
   const active = getActiveAgent();
+  const input = await readStdinJSON<{ source?: string }>();
+  const wanted = contextForSource(active, input?.source);
+  if (wanted === "none") {
+    logDebug("LoadContext", `source=${input?.source}, context already present`);
+    process.exit(0);
+  }
+
   // The reminder is built for one of three targets; every other agent reads the
   // same shape Claude Code does.
   const target: AgentTarget =
     active === "copilot" || active === "cursor" ? active : "claude";
-  const reminder = buildSystemReminder({ agent: target });
+  const reminder = buildSystemReminder({
+    agent: target,
+    withoutHandoff: wanted === "without-handoff",
+  });
   if (!reminder) process.exit(0);
   logContextSnapshot(reminder);
 

package/src/hooks/PreCompactPersist.ts

@@ -17,6 +17,7 @@ import { resolve } from "node:path";
 import { persistLastExchange } from "./handlers/persist-last-exchange";
 import { logDebug, logError } from "./lib/log";
 import { paths } from "./lib/paths";
+import { sessionDir } from "./lib/session-dir";
 import { isPalSpawnedInference } from "./lib/spawn-guard";
 import { readStdinJSON } from "./lib/stdin";
 import { readTranscriptFile } from "./lib/transcript";
@@ -27,7 +28,6 @@ if (isPalSpawnedInference()) process.exit(0);
 interface PreCompactInput {
   session_id?: string;
   transcript_path?: string;
-  cwd?: string;
   hook_event_name?: string;
   trigger?: "manual" | "auto";
   custom_instructions?: string;
@@ -47,7 +47,7 @@ const main = async () => {
       process.exit(0);
     }
     const sessionId = input.session_id ?? "unknown";
-    const cwd = input.cwd ?? process.cwd();
+    const cwd = sessionDir();
 
     // Stop fires after every response and is authoritative. Skip if it already
     // wrote latest.json for this session — PreCompact is a safety net only.

package/src/hooks/handlers/persist-last-exchange.ts

@@ -4,22 +4,22 @@
  * Writes two outputs:
  *  1. last-exchange/{sessionId}.json + last-exchange/latest.json
  *     → read by CompactRecover to re-inject after compaction
- *  2. last-handoff.json keyed by cwd
- *     → read by loadHandoff() to surface "Pick Up Where You Left Off"
+ *  2. last-handoff.json keyed by the session's start folder
+ *     → read by loadHandoffContext() to surface "Pick Up Where You Left Off"
  *
- * last-exchange is always overwritten — Stop is its source of truth. last-handoff
- * is NOT: a deliberate LEARN-phase note (written by handoff-note.ts with
- * source:"deliberate") outranks this raw auto-snapshot, so we leave it intact
- * while it is still fresh and in-progress. Otherwise the auto-snapshot would
- * clobber the curated handoff the moment the session stopped (ISC-39).
+ * last-exchange is always overwritten — Stop is its source of truth. In
+ * last-handoff only the exchange fields are: a deliberate LEARN-phase note
+ * (source:"deliberate") and the summary session intelligence wrote for this
+ * session both stay beside it (ISC-39).
  */
 
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
+import { trimAtWord } from "../lib/handoff-context";
 import { logDebug, logError } from "../lib/log";
 import { ensureDir, paths } from "../lib/paths";
+import { sessionDir } from "../lib/session-dir";
 import { extractContent, extractLastAssistant, extractLastUser } from "../lib/transcript";
-import { detectStatus } from "../lib/work-tracking";
 
 type ParsedMessage = { role: string; content: unknown };
 
@@ -35,10 +35,128 @@ function isProtectedHandoff(entry: unknown): boolean {
   return Date.now() - new Date(e.timestamp).getTime() <= HANDOFF_STALE_MS;
 }
 
+interface AutoHandoff {
+  title: string;
+  status: string;
+  handoff: string;
+  waitingOn?: string;
+  sessionId?: string;
+}
+
+interface LastExchange {
+  sessionId: string;
+  lastUser: string;
+  lastAssistant: string;
+}
+
+type StoredHandoff = Partial<AutoHandoff & LastExchange> & {
+  timestamp?: string;
+  source?: string;
+  artifacts?: string[];
+};
+
+const LAST_USER_MAX_CHARS = 200;
+const LAST_ASSISTANT_MAX_CHARS = 300;
+
+function handoffPath(): string {
+  return resolve(ensureDir(paths.state()), "last-handoff.json");
+}
+
+function readHandoffs(): Record<string, StoredHandoff> {
+  try {
+    const p = handoffPath();
+    return existsSync(p) ? JSON.parse(readFileSync(p, "utf-8")) : {};
+  } catch {
+    return {};
+  }
+}
+
+function writeHandoffs(handoffs: Record<string, StoredHandoff>): void {
+  writeFileSync(handoffPath(), JSON.stringify(handoffs, null, 2), "utf-8");
+}
+
+export function structuredHandoff(parts: {
+  done: string;
+  next: string;
+  waitingOn: string;
+}): string {
+  return [
+    parts.done && `Done: ${parts.done}`,
+    parts.next && `Next: ${parts.next}`,
+    parts.waitingOn && `Waiting on you: ${parts.waitingOn}`,
+  ]
+    .filter(Boolean)
+    .join("\n");
+}
+
+function sameSession(entry: StoredHandoff | undefined, sessionId?: string): boolean {
+  return sessionId !== undefined && entry?.sessionId === sessionId;
+}
+
+/** Record this folder's summary unless a fresh deliberate note already owns it (ISC-39). */
+export function writeAutoHandoff(cwd: string, entry: AutoHandoff): void {
+  const handoffs = readHandoffs();
+  const existing = handoffs[cwd];
+  if (isProtectedHandoff(existing)) return;
+  const exchange = sameSession(existing, entry.sessionId)
+    ? { lastUser: existing?.lastUser, lastAssistant: existing?.lastAssistant }
+    : {};
+  handoffs[cwd] = {
+    timestamp: new Date().toISOString(),
+    ...entry,
+    ...exchange,
+    artifacts: [],
+    source: "auto",
+  };
+  writeHandoffs(handoffs);
+}
+
+function closingParagraph(text: string): string {
+  const paragraphs = text
+    .split(/\n\s*\n/)
+    .map((p) => p.trim())
+    .filter((p) => p.length >= 15);
+  return paragraphs.at(-1) ?? text;
+}
+
+/**
+ * The raw exchange is written on every stop; the summary only every few
+ * messages. So within one session the exchange is refreshed beside the
+ * summary rather than over it, and a new session starts a clean entry.
+ */
+function recordLastExchange(cwd: string, exchange: LastExchange): void {
+  const handoffs = readHandoffs();
+  const existing = handoffs[cwd];
+  const trimmed = {
+    sessionId: exchange.sessionId,
+    lastUser: trimAtWord(exchange.lastUser, LAST_USER_MAX_CHARS),
+    lastAssistant: trimAtWord(
+      closingParagraph(exchange.lastAssistant),
+      LAST_ASSISTANT_MAX_CHARS
+    ),
+  };
+  if (isProtectedHandoff(existing)) {
+    handoffs[cwd] = { ...existing, ...trimmed };
+  } else if (sameSession(existing, exchange.sessionId)) {
+    handoffs[cwd] = { ...existing, ...trimmed, timestamp: new Date().toISOString() };
+  } else {
+    handoffs[cwd] = {
+      timestamp: new Date().toISOString(),
+      title: trimAtWord(exchange.lastUser, 80) || "Session",
+      status: "in-progress",
+      handoff: "",
+      artifacts: [],
+      source: "auto",
+      ...trimmed,
+    };
+  }
+  writeHandoffs(handoffs);
+}
+
 export function persistLastExchange(
   messages: ParsedMessage[],
   sessionId: string,
-  cwd: string = process.cwd()
+  cwd: string = sessionDir()
 ): void {
   try {
     const lastUser = extractContent(extractLastUser(messages));
@@ -59,30 +177,7 @@ export function persistLastExchange(
     writeFileSync(resolve(stateDir, `${sessionId}.json`), json, "utf-8");
     writeFileSync(resolve(stateDir, "latest.json"), json, "utf-8");
 
-    // 2. Write last-handoff.json for "Pick Up Where You Left Off" — unless a
-    //    fresh deliberate note already owns this cwd (ISC-39).
-    const handoffPath = resolve(paths.state(), "last-handoff.json");
-    const existing: Record<string, unknown> = existsSync(handoffPath)
-      ? JSON.parse(readFileSync(handoffPath, "utf-8"))
-      : {};
-    if (!isProtectedHandoff(existing[cwd])) {
-      const title = (lastUser.slice(0, 80).replace(/\n/g, " ") || "Session").trim();
-      const handoff = [
-        lastUser ? `Last user message:\n${lastUser.slice(0, 500)}` : "",
-        lastAssistant ? `\nLast assistant response:\n${lastAssistant.slice(0, 500)}` : "",
-      ]
-        .filter(Boolean)
-        .join("");
-      existing[cwd] = {
-        timestamp: new Date().toISOString(),
-        title,
-        status: detectStatus(lastAssistant),
-        handoff,
-        artifacts: [],
-        source: "auto",
-      };
-      writeFileSync(handoffPath, JSON.stringify(existing, null, 2), "utf-8");
-    }
+    recordLastExchange(cwd, { sessionId, lastUser, lastAssistant });
 
     logDebug(
       "persist-last-exchange",

package/src/hooks/handlers/session-intelligence.ts

@@ -1,8 +1,8 @@
 /**
  * Stop handler: unified session intelligence capture.
  *
- * Produces: title, summary, insights via Haiku.
- * Writes: session learning file, project history.
+ * Produces: title, summary, insights, status and a done/next/waiting handoff via Haiku.
+ * Writes: session learning file, project history, auto handoff.
  *
  * Relationship notes → written in ALGORITHM LEARN phase via relationship-note.ts
  * Handoff notes     → written in ALGORITHM LEARN phase via handoff-note.ts
@@ -23,6 +23,7 @@ import { canInfer, inference } from "../lib/inference";
 import { categorizeLearning } from "../lib/learning-category";
 import { logDebug, logError } from "../lib/log";
 import { ensureDir, paths } from "../lib/paths";
+import { sessionDir } from "../lib/session-dir";
 import { fileTimestamp, monthPath } from "../lib/time";
 import { logTokenUsage } from "../lib/token-usage";
 import {
@@ -31,7 +32,8 @@ import {
   extractLastUser,
   parseMessages,
 } from "../lib/transcript";
-import { appendProjectHistory, detectStatus } from "../lib/work-tracking";
+import { appendProjectHistory } from "../lib/work-tracking";
+import { structuredHandoff, writeAutoHandoff } from "./persist-last-exchange";
 
 // ── JSON schema for merged Haiku call ──
 
@@ -50,20 +52,51 @@ const INTELLIGENCE_SCHEMA = {
       description:
         "What worked, what was surprising, what to do differently, 2-3 bullet points",
     },
-    handoff: {
+    status: {
       type: "string" as const,
+      enum: ["in-progress", "completed"],
       description:
-        "If status is in-progress: what remains to be done, key decisions made, blockers. If completed: empty string.",
+        "in-progress if work remains or the AI's last message awaits the user's answer; completed only if nothing is left",
+    },
+    done: {
+      type: "string" as const,
+      description: "What the latest piece of work finished, one sentence",
+    },
+    next: {
+      type: "string" as const,
+      description: "The concrete next step, one sentence, empty if none",
+    },
+    waitingOn: {
+      type: "string" as const,
+      description:
+        "What the AI needs from the user before it can continue, empty if nothing",
     },
   },
-  required: ["title", "summary", "insights", "handoff"] as const,
+  required: [
+    "title",
+    "summary",
+    "insights",
+    "status",
+    "done",
+    "next",
+    "waitingOn",
+  ] as const,
 };
 
 interface IntelligenceOutput {
   title: string;
   summary: string;
   insights: string;
-  handoff: string;
+  status: "in-progress" | "completed";
+  done: string;
+  next: string;
+  waitingOn: string;
+}
+
+/** A reply states its verdict first and its question to the user last. */
+export function openingAndClosing(text: string, each: number): string {
+  if (text.length <= each * 2) return text;
+  return `${text.slice(0, each)} … ${text.slice(-each)}`;
 }
 
 // ── Main handler ──
@@ -95,10 +128,9 @@ export async function captureSessionIntelligence(
   const lastAssistant = extractLastAssistant(messages);
   const lastAssistantText = extractContent(lastAssistant);
   const lastUser = extractLastUser(messages);
-  const status = detectStatus(lastAssistantText);
 
   const userWindow = userMessages.slice(-10).map((t) => t.slice(0, 200));
-  const assistantWindow = lastAssistantText.slice(0, 600);
+  const assistantWindow = openingAndClosing(lastAssistantText, 300);
 
   if (userWindow.length < 3) return;
 
@@ -110,17 +142,15 @@ export async function captureSessionIntelligence(
     const result = await inference({
       system: [
         "You analyze a session between a human user and an AI assistant. Sessions may involve coding, research, writing, planning, analysis, or any other task.",
-        `Session status: ${status}.`,
         "Produce ALL of the following:",
         "1. title: short title (5-10 words) describing what was accomplished",
         "2. summary: what the AI did for the user (2-4 sentences, AI perspective using 'we')",
         "3. insights: what worked, what was surprising, what to do differently (2-3 points, no markdown)",
-        status === "in-progress"
-          ? "4. handoff: what remains unfinished — decisions made so far, next steps, blockers (2-4 sentences)"
-          : "4. handoff: empty string (session completed)",
+        "4. status: in-progress if work remains or the last AI response ends with a question or offer awaiting the user; completed only if nothing is left",
+        "5. done, next, waitingOn: a handoff for whoever picks this up next. Describe the LATEST thread of work, the one the last messages are about, not earlier topics of the session. One sentence each; next and waitingOn may be empty.",
       ].join("\n"),
       user: `User messages:\n${numberedMessages}\n\nLast AI response:\n${assistantWindow}`,
-      maxTokens: 350,
+      maxTokens: 450,
       timeout: 90000,
       jsonSchema: INTELLIGENCE_SCHEMA,
       caller: "session-intelligence",
@@ -140,6 +170,15 @@ export async function captureSessionIntelligence(
   const title = output?.title || extractContent(lastUser).slice(0, 80) || "session";
   const summary = output?.summary || lastAssistantText.slice(0, 600);
   const insights = output?.insights || "";
+  if (output) {
+    writeAutoHandoff(sessionDir(), {
+      title,
+      status: output.status,
+      handoff: structuredHandoff(output),
+      waitingOn: output.waitingOn,
+      sessionId,
+    });
+  }
   // ── Write session learning file ──
 
   const category = categorizeLearning(title, summary);

package/src/hooks/lib/algorithm-review.ts

@@ -35,11 +35,13 @@ export function writeReviewMark(ts: string): void {
   writeFileSync(markFile(), `${JSON.stringify({ lastReviewedTs: ts }, null, 2)}\n`);
 }
 
-/** True only in a maintainer repo checkout — the repo-only update skill is present. */
-export function isMaintainerEnv(): boolean {
-  return existsSync(
-    resolve(palPkg(), ".agents", "skills", "algorithm-update", "SKILL.md")
-  );
+function hasAlgorithmUpdateSkill(root: string): boolean {
+  return existsSync(resolve(root, ".agents", "skills", "algorithm-update", "SKILL.md"));
+}
+
+/** True when PAL runs from its checkout, or a session is working inside one. */
+export function isMaintainerEnv(cwd: string = process.cwd()): boolean {
+  return hasAlgorithmUpdateSkill(palPkg()) || hasAlgorithmUpdateSkill(cwd);
 }
 
 /** Count reflections newer than the last review mark (all of them, if never reviewed). */
@@ -60,8 +62,11 @@ export interface ReviewNudge {
  * Nudge data when BOTH thresholds are met (≥25 new AND ≥7 days) in a maintainer
  * env, else null. `now` is injected for testability.
  */
-export function algorithmReviewNudge(now: Date): ReviewNudge | null {
-  if (!isMaintainerEnv()) return null;
+export function algorithmReviewNudge(
+  now: Date,
+  cwd: string = process.cwd()
+): ReviewNudge | null {
+  if (!isMaintainerEnv(cwd)) return null;
   const mark = readReviewMark();
   const count = countUnreviewed(mark);
   if (count < NUDGE_MIN_COUNT) return null;