portable-agent-layer 0.79.2 → 0.79.3

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

@@ -59,7 +59,6 @@
         "relationship": { "type": "boolean", "description": "Recent relationship notes." },
         "failurePatterns": { "type": "boolean", "description": "Recurring failure patterns." },
         "projects": { "type": "boolean", "description": "Active projects list." },
-        "sessionIntelligence": { "type": "boolean", "description": "Algorithm reflection stats and this project's self-observations." },
         "handoff": { "type": "boolean", "description": "Handoff note from the previous session." },
         "selfModel": { "type": "boolean", "description": "The assistant's self-model synthesis." },
         "contextualSteering": { "type": "boolean", "description": "Prompt-time steering self-checks (see the steering section)." },

package/assets/templates/pal-settings.json

@@ -21,7 +21,6 @@
     "relationship": true,
     "failurePatterns": true,
     "projects": true,
-    "sessionIntelligence": true,
     "handoff": true,
     "selfModel": true,
     "contextualSteering": true,

package/package.json

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

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

@@ -71,8 +71,20 @@ function readHandoffs(): Record<string, StoredHandoff> {
   }
 }
 
+function isWithinReadWindow(entry: StoredHandoff): boolean {
+  if (!entry.timestamp) return false;
+  return Date.now() - new Date(entry.timestamp).getTime() <= HANDOFF_STALE_MS;
+}
+
 function writeHandoffs(handoffs: Record<string, StoredHandoff>): void {
-  writeFileSync(handoffPath(), JSON.stringify(handoffs, null, 2), "utf-8");
+  const readable = Object.entries(handoffs).filter(([, entry]) =>
+    isWithinReadWindow(entry)
+  );
+  writeFileSync(
+    handoffPath(),
+    JSON.stringify(Object.fromEntries(readable), null, 2),
+    "utf-8"
+  );
 }
 
 export function structuredHandoff(parts: {

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

@@ -232,6 +232,7 @@ export async function captureSessionIntelligence(
       title,
       summary,
       insights,
+      session: sessionId,
     });
   }
 

package/src/hooks/lib/context.ts

@@ -117,8 +117,11 @@ export function loadRelationshipContext(): string {
   }
 }
 
-/** Load session intelligence from compact synthesis state */
-function loadSessionIntelligence(): string {
+/**
+ * Off the startup context until the reflection stats are reliable enough to act on.
+ * @lintignore exercised directly by test/context-build.test.ts
+ */
+export function loadSessionIntelligence(): string {
   try {
     const p = resolve(paths.state(), "synthesis.json");
     if (!existsSync(p)) return "";
@@ -211,9 +214,6 @@ export function buildSystemReminder(
     !skipSemiStatic && settings.isEnabled("opinions") ? loadOpinionContext() : "";
   const selfModel =
     !skipSemiStatic && settings.isEnabled("selfModel") ? loadSelfModel() : "";
-  const intelligence = settings.isEnabled("sessionIntelligence")
-    ? loadSessionIntelligence()
-    : "";
   const handoff =
     !opts.withoutHandoff && settings.isEnabled("handoff")
       ? loadHandoffContext(sessionDir())
@@ -231,7 +231,6 @@ export function buildSystemReminder(
   if (selfModel) parts.push(selfModel);
   if (wisdom) parts.push(wisdom);
   if (opinions) parts.push(opinions);
-  if (intelligence) parts.push(intelligence);
   if (relationship) parts.push(relationship);
   if (activeProjects) parts.push(activeProjects);
   if (failures) parts.push(failures);

package/src/hooks/lib/stop.ts

@@ -22,7 +22,12 @@ import { captureWorkSession } from "../handlers/work-session";
 import { spawnDetachedInference } from "./detached-inference";
 import { logDebug, logError } from "./log";
 import { assets, ensureDir, paths } from "./paths";
-import { extractContent, extractLastAssistant, parseMessages } from "./transcript";
+import {
+  extractContent,
+  extractLastAssistant,
+  parseMessages,
+  withFinalReply,
+} from "./transcript";
 
 interface RunStopHandlersOptions {
   lastAssistantMessage?: string;
@@ -31,11 +36,13 @@ interface RunStopHandlersOptions {
 
 /** Run all stop handlers with a transcript string */
 export async function runStopHandlers(
-  transcript: string,
+  fileTranscript: string,
   options: RunStopHandlersOptions = {}
 ): Promise<void> {
-  const messages = parseMessages(transcript);
-  if (messages.length < 2) return;
+  const fileMessages = parseMessages(fileTranscript);
+  if (fileMessages.length < 2) return;
+  const messages = withFinalReply(fileMessages, options.lastAssistantMessage);
+  const transcript = JSON.stringify(messages);
 
   logDebug("runStopHandlers", `Running handlers (${messages.length} messages)`);
 

package/src/hooks/lib/transcript.ts

@@ -89,6 +89,15 @@ export function extractLastAssistant(messages: Message[]): Message | undefined {
   return messages.filter((m) => m.role === "assistant").pop();
 }
 
+/** The agent hands its final reply to the Stop hook before that reply reaches the transcript file. */
+export function withFinalReply(messages: Message[], finalReply?: string): Message[] {
+  const reply = finalReply?.trim();
+  if (!reply) return messages;
+  const last = messages.at(-1);
+  if (last?.role === "assistant" && extractContent(last).includes(reply)) return messages;
+  return [...messages, { role: "assistant", content: reply }];
+}
+
 /** Get the last user message from a messages array */
 export function extractLastUser(messages: Message[]): Message | undefined {
   return messages.filter((m) => m.role === "user").pop();

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

@@ -145,6 +145,7 @@ interface ProjectHistoryEntry {
   title: string;
   summary: string;
   insights: string;
+  session?: string;
 }
 
 /**
@@ -160,11 +161,28 @@ function historyFileFor(cwd: string): string {
     : resolve(paths.unboundHistory(), `${defaultSlug(cwd)}.jsonl`);
 }
 
-/** Append a learning entry to the history file owning this cwd */
+function withoutSession(lines: string[], session: string): string[] {
+  return lines.filter((line) => {
+    try {
+      return (JSON.parse(line) as ProjectHistoryEntry).session !== session;
+    } catch {
+      return true;
+    }
+  });
+}
+
+/** A session is summarised again as it grows; its entry is replaced, not repeated. */
 export function appendProjectHistory(cwd: string, entry: ProjectHistoryEntry): void {
   const historyPath = historyFileFor(cwd);
   ensureDir(dirname(historyPath));
-  appendFileSync(historyPath, `${JSON.stringify(entry)}\n`, "utf-8");
+  const line = JSON.stringify(entry);
+  if (!entry.session || !existsSync(historyPath)) {
+    appendFileSync(historyPath, `${line}\n`, "utf-8");
+    return;
+  }
+  const lines = readFileSync(historyPath, "utf-8").split("\n").filter(Boolean);
+  const kept = withoutSession(lines, entry.session);
+  writeFileSync(historyPath, `${[...kept, line].join("\n")}\n`, "utf-8");
 }
 
 /** Read the session history for a given cwd */