portable-agent-layer 0.45.0 → 0.45.1

package/package.json

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

package/src/hooks/handlers/self-model-trigger.ts

@@ -1,27 +1,26 @@
 /**
  * Auto-trigger for self-model synthesis — runs daily.
- * writeSelfModel has a 24h TTL guard, so this is safe to call every session.
- * Respects dynamicContext.selfModel — if disabled, skips generation entirely.
+ *
+ * Spawns synthesis as a DETACHED child instead of awaiting it inline. A cold
+ * `claude -p` Sonnet spawn routinely exceeds a minute; awaiting it inside the
+ * Stop hook forced a tight 30s timeout that killed every synthesis and fell
+ * back to a raw data dump. Detaching lets self-model.ts use a real 90s budget
+ * without blocking session end. self-model.ts carries its own 24h TTL guard,
+ * so this is safe to call every session. Respects dynamicContext.selfModel.
  */
 
-import { writeSelfModel } from "../../tools/self-model";
+import { resolve } from "node:path";
+import { spawnDetachedInference } from "../lib/detached-inference";
 import { logDebug } from "../lib/log";
+import { assets } from "../lib/paths";
 import { isEnabled } from "../lib/settings";
 
-export async function checkSelfModelTrigger(): Promise<void> {
+export function checkSelfModelTrigger(): void {
   if (!isEnabled("selfModel")) {
     logDebug("self-model-trigger", "Disabled in pal-settings.json");
     return;
   }
 
-  try {
-    const result = await writeSelfModel(30);
-    if (result.skipped) {
-      logDebug("self-model-trigger", "Skipped — last synthesis < 24h ago");
-    } else {
-      logDebug("self-model-trigger", `Self-model written: ${result.path}`);
-    }
-  } catch {
-    // Non-critical — self-model is best-effort
-  }
+  const scriptPath = resolve(assets.tools(), "self-model.ts");
+  spawnDetachedInference(scriptPath, [], "self-model");
 }

package/src/hooks/lib/paths.ts

@@ -83,5 +83,6 @@ export const assets = {
   codexHooksTemplate: () => pkg("assets", "templates", "hooks.codex.json"),
   codexRulesTemplate: () => pkg("assets", "templates", "rules.codex.rules"),
   agentTools: () => pkg("src", "tools", "agent"),
+  tools: () => pkg("src", "tools"),
   palDocs: () => pkg("assets", "templates", "PAL"),
 } as const;

package/src/hooks/lib/stop.ts

@@ -47,11 +47,12 @@ export async function runStopHandlers(
   // Detach inference-bearing handlers — claude --print cold-start can exceed
   // any in-hook budget. These spawn detached bun subprocesses that run the
   // inference and write results to disk; they don't block this hook.
-  // autoGraduate is idempotent (24h TTL + state-dedup + content-dedup), so
-  // concurrent or overlapping detached runs are safe.
   await detachSessionIntelligence(transcript, options.sessionId);
   await detachFailurePrinciple(transcript);
-  detachAutoGraduate();
+  // Failure auto-graduation is intentionally NOT wired here: every pattern it
+  // ever promoted was a frustration log, not a principle. Wisdom frames are
+  // populated by Claude in-conversation (see wisdom.ts header). The handler
+  // (handlers/auto-graduate.ts) remains runnable manually via `--run`.
 
   // Run remaining (non-inference) handlers concurrently.
   // project-touch only fires when cwd resolves to an active registered project.
@@ -177,16 +178,6 @@ async function detachSessionIntelligence(
   }
 }
 
-/** Spawn a detached child to run the full autoGraduate cycle. */
-function detachAutoGraduate(): void {
-  try {
-    const scriptPath = resolve(assets.hooks(), "handlers", "auto-graduate.ts");
-    spawnDetachedInference(scriptPath, ["--run"], "auto-graduate");
-  } catch (err) {
-    logError("detachAutoGraduate", err);
-  }
-}
-
 /**
  * If a pending-failure exists, rename it to a unique path (race-free claim),
  * write the transcript to tmp, spawn the failure-principle handler detached.

package/src/tools/self-model.ts

@@ -524,7 +524,11 @@ async function composeSelfModel(days: number): Promise<string> {
   const currentPath = selfModelPath();
   if (existsSync(currentPath)) {
     try {
-      previousModel = readFileSync(currentPath, "utf-8");
+      const prev = readFileSync(currentPath, "utf-8");
+      // Never feed a failed-synthesis fallback back in — it is a raw data dump,
+      // not a model. Doing so bloats the prompt and drives the next run into the
+      // same timeout, a self-reinforcing failure loop. Skip it and synthesize fresh.
+      if (!prev.includes("Synthesis failed — raw data below")) previousModel = prev;
     } catch {
       /* best effort */
     }
@@ -539,7 +543,7 @@ async function composeSelfModel(days: number): Promise<string> {
     user: userContent,
     model: SONNET_MODEL,
     maxTokens: 1500,
-    timeout: 30000,
+    timeout: 90000,
     caller: "self-model",
   });
 
@@ -565,7 +569,7 @@ async function composeSelfModel(days: number): Promise<string> {
 
 // ── Write ──
 
-export async function writeSelfModel(
+async function writeSelfModel(
   days: number,
   force = false
 ): Promise<{ path: string; content: string; skipped?: boolean }> {