portable-agent-layer 0.93.0 → 0.95.0

package/README.md

@@ -85,6 +85,8 @@ pal cli status        # check your setup
 | `pal cli migrate` | Run pending data migrations (non-destructive) |
 | `pal cli analyze [--actionable]` | Learning analysis: rating trends, failure patterns, graduation candidates |
 | `pal cli usage` | Summarize token usage and estimated cost |
+| `pal cli content preserve` | Copy every Claude Code transcript, gzipped, into `memory/content/` before Claude Code deletes it (30 days by default). Runs on its own whenever a session closes; the content store never leaves the machine, so `export` skips it |
+| `pal cli events discord-nag <sent\|answered>` | For a bot outside PAL: record a nag it sent (`--kind <kind>`), or the answer to one and how long it took (`--after-sec <n>`), in the local event log |
 | `pal cli infer` | One model call for scripts and bots, on the active agent's route: prompt on stdin, reply on stdout. `--tier small\|medium`, `--system <file>`, `--schema <file>` for a JSON reply checked against it, `--timeout <seconds>`. The call loads no PAL hooks or context; exits 1 with the reason when no route answers |
 | `pal cli actor [label <name>]` | Show or rename the actor — who caused a record. Travels with an export, so a shared memory can tell two people apart |
 | `pal cli machine [label <name>]` | Show or rename this install — where a record was written. Never leaves the machine |
@@ -208,7 +210,9 @@ PAL ships with built-in skills that extend your agent's capabilities:
 | `presentation` | Build branded slide decks from outlines |
 | `projects` | Look up, resume, register, or manage tracked projects |
 | `reflect` | Diagnose why a PAL behavior didn't trigger |
-| `rule-review` | Approve or deny the rules PAL drafted from your corrections || `telos` | Inspect or update goals, beliefs, strategies, narratives |
+| `research-entity` | Research a company or person on the web: links, registry entry, recent news |
+| `rule-review` | Approve or deny the rules PAL drafted from your corrections |
+| `telos` | Inspect or update goals, beliefs, strategies, narratives |
 | `think` | Structured first-pass reasoning on a problem |
 
 ---

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

@@ -106,6 +106,10 @@
           "type": "boolean",
           "description": "After a session stops, ask a background model which people and companies your own messages mentioned, and write clear matches and new full names to the knowledge store with the message as source. A name that could be more than one entry, or a first name alone, waits for `pal cli knowledge review` instead."
         },
+        "entityResearch": {
+          "type": "boolean",
+          "description": "Opt-in, off by default. When extraction creates a company, or a person with a known organization, research it on the web through the active agent (up to three per stop): website, LinkedIn, social accounts, the company registry entry, recent news, each with its source. A profile the model is sure of waits in `pal cli knowledge review`; accepting writes it to the entry. The name and what you said about it reach the agent's web search. Claude Code, Codex and Copilot only. Needs entityExtraction."
+        },
         "steeringTestReport": { "type": "boolean", "description": "When true, the assistant notes to the user which steering self-check fired. For the dual-live test period; ships false." }
       }
     },

package/assets/skills/research-entity/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: research-entity
+license: MIT
+description: "Research one company or person on the web and build a sourced profile: official website, LinkedIn, social accounts, the company registry entry (cégjegyzék for Hungarian companies), and recent news or statements. Use when the user asks to research, look up, profile, or background-check a specific company or person, or to enrich a knowledge-store entry."
+argument-hint: <company or person name> [what you know about them]
+metadata:
+  source: portable-agent-layer
+  triggers:
+    - "research-entity"
+    - "research entity"
+    - "research this company"
+    - "research this person"
+    - "look up the company"
+    - "company background"
+    - "background check"
+    - "cégjegyzék"
+---
+
+Research the company or person named in $ARGUMENTS and show a sourced profile. The research runs through `pal cli knowledge research`, which picks the active agent's web search and limits it to searching and reading pages. Never research with your own tools instead: the command is what keeps the result in the same shape on every agent.
+
+## Workflow
+
+1. Work out from $ARGUMENTS and the conversation:
+   - the exact name;
+   - whether it is a company or a person;
+   - for a person, where they work;
+   - one sentence of what the user said about them.
+   If you cannot tell a company from a person, ask.
+2. Run the research. For a company:
+   ```bash
+   pal cli knowledge research "<name>" --context "<what the user said>"
+   ```
+   For a person, add `--person` and, when known, `--organization "<employer>"`:
+   ```bash
+   pal cli knowledge research "<name>" --person --organization "<employer>" --context "<what the user said>"
+   ```
+   It takes one to several minutes. Add `--queue` when the user wants the profile saved; it then waits in the review queue.
+3. If the command exits 1, tell the user the reason it printed. Usual reasons:
+   - the model found only namesakes (`match: unsure`): ask for something that tells them apart, such as an employer, a city or a website, and run it again with that in `--context` or `--organization`;
+   - nothing was found (`match: none`);
+   - the active agent cannot search the web yet.
+4. If it succeeds, show the profile it printed as it is. Do not add facts it did not print.
+5. If you queued it, tell the user the review command it printed: `pal cli knowledge review accept <id>` writes the profile to the entry, and `pal cli knowledge review reject <id>` drops it.
+
+## Output format
+
+The profile as printed: summary, links, registry, news and sources. Then one line saying whether it was queued for review, with the accept command.
+
+## When to use
+
+- The user names a specific company or person and wants to know who they are, or their website, LinkedIn, accounts, registry data or recent news.
+- The user wants an entry in the knowledge store filled in from the web.
+
+## Do NOT use
+
+- To pull every person and company out of an article, video or paste. Use `entities` for that.
+- For a broad topic, market or question rather than one named entity. Use `deep-research` for that.

package/assets/templates/hooks.antigravity.json

@@ -27,7 +27,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "bun run {{PKG_ROOT}}/src/hooks/LedgerCommit.ts --agent=antigravity"
+            "command": "bun run {{PKG_ROOT}}/src/hooks/PostToolOrchestrator.ts --agent=antigravity"
           }
         ]
       }

package/assets/templates/hooks.codex.json

@@ -39,7 +39,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "bun run {{PKG_ROOT}}/src/hooks/LedgerCommit.ts --agent=codex"
+            "command": "bun run {{PKG_ROOT}}/src/hooks/PostToolOrchestrator.ts --agent=codex"
           }
         ]
       }
@@ -54,6 +54,16 @@
         ]
       }
     ],
+    "PreCompact": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun run {{PKG_ROOT}}/src/hooks/PreCompactPersist.ts --agent=codex"
+          }
+        ]
+      }
+    ],
     "SessionEnd": [
       {
         "hooks": [

package/assets/templates/hooks.copilot.json

@@ -47,15 +47,15 @@
     "postToolUse": [
       {
         "type": "command",
-        "bash": "bun run {{PKG_ROOT}}/src/hooks/LedgerCommit.ts --agent=copilot",
-        "powershell": "bun run {{PKG_ROOT}}/src/hooks/LedgerCommit.ts --agent=copilot"
+        "bash": "bun run {{PKG_ROOT}}/src/hooks/PostToolOrchestrator.ts --agent=copilot",
+        "powershell": "bun run {{PKG_ROOT}}/src/hooks/PostToolOrchestrator.ts --agent=copilot"
       }
     ],
     "postToolUseFailure": [
       {
         "type": "command",
-        "bash": "bun run {{PKG_ROOT}}/src/hooks/LedgerUnapplied.ts --agent=copilot --event=postToolUseFailure",
-        "powershell": "bun run {{PKG_ROOT}}/src/hooks/LedgerUnapplied.ts --agent=copilot --event=postToolUseFailure"
+        "bash": "bun run {{PKG_ROOT}}/src/hooks/PostToolOrchestrator.ts --agent=copilot --event=postToolUseFailure",
+        "powershell": "bun run {{PKG_ROOT}}/src/hooks/PostToolOrchestrator.ts --agent=copilot --event=postToolUseFailure"
       }
     ],
     "agentStop": [
@@ -65,6 +65,13 @@
         "powershell": "bun run {{PKG_ROOT}}/src/hooks/StopOrchestrator.ts --agent=copilot"
       }
     ],
+    "preCompact": [
+      {
+        "type": "command",
+        "bash": "bun run {{PKG_ROOT}}/src/hooks/PreCompactPersist.ts --agent=copilot",
+        "powershell": "bun run {{PKG_ROOT}}/src/hooks/PreCompactPersist.ts --agent=copilot"
+      }
+    ],
     "sessionEnd": [
       {
         "type": "command",

package/assets/templates/hooks.cursor.json

@@ -34,13 +34,13 @@
     "postToolUse": [
       {
         "type": "command",
-        "command": "bun run {{PKG_ROOT}}/src/hooks/LedgerCommit.ts --agent=cursor"
+        "command": "bun run {{PKG_ROOT}}/src/hooks/PostToolOrchestrator.ts --agent=cursor"
       }
     ],
     "postToolUseFailure": [
       {
         "type": "command",
-        "command": "bun run {{PKG_ROOT}}/src/hooks/LedgerUnapplied.ts --agent=cursor"
+        "command": "bun run {{PKG_ROOT}}/src/hooks/PostToolOrchestrator.ts --agent=cursor"
       }
     ],
     "beforeShellExecution": [
@@ -61,6 +61,12 @@
         "command": "bun run {{PKG_ROOT}}/src/hooks/StopOrchestrator.ts --agent=cursor"
       }
     ],
+    "preCompact": [
+      {
+        "type": "command",
+        "command": "bun run {{PKG_ROOT}}/src/hooks/PreCompactPersist.ts --agent=cursor"
+      }
+    ],
     "sessionEnd": [
       {
         "type": "command",

package/assets/templates/pal-settings.json

@@ -35,6 +35,7 @@
     "adaptationRules": true,
     "entityCards": true,
     "entityExtraction": true,
+    "entityResearch": false,
     "steeringTestReport": false
   },
   "steering": {

package/assets/templates/settings.claude.json

@@ -158,7 +158,17 @@
         "hooks": [
           {
             "type": "command",
-            "command": "bun run {{PKG_ROOT}}/src/hooks/LedgerCommit.ts --agent=claude"
+            "command": "bun run {{PKG_ROOT}}/src/hooks/PostToolOrchestrator.ts --agent=claude --only=ledger"
+          }
+        ]
+      },
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun run {{PKG_ROOT}}/src/hooks/PostToolOrchestrator.ts --agent=claude --only=events",
+            "async": true
           }
         ]
       }
@@ -169,7 +179,39 @@
         "hooks": [
           {
             "type": "command",
-            "command": "bun run {{PKG_ROOT}}/src/hooks/LedgerUnapplied.ts --agent=claude"
+            "command": "bun run {{PKG_ROOT}}/src/hooks/PostToolOrchestrator.ts --agent=claude --only=ledger"
+          }
+        ]
+      },
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun run {{PKG_ROOT}}/src/hooks/PostToolOrchestrator.ts --agent=claude --only=events",
+            "async": true
+          }
+        ]
+      }
+    ],
+    "PermissionRequest": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun run {{PKG_ROOT}}/src/hooks/AttentionEvent.ts --agent=claude"
+          }
+        ]
+      }
+    ],
+    "Notification": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun run {{PKG_ROOT}}/src/hooks/AttentionEvent.ts --agent=claude"
           }
         ]
       }
@@ -180,7 +222,17 @@
         "hooks": [
           {
             "type": "command",
-            "command": "bun run {{PKG_ROOT}}/src/hooks/LedgerUnapplied.ts --agent=claude"
+            "command": "bun run {{PKG_ROOT}}/src/hooks/PostToolOrchestrator.ts --agent=claude --only=ledger"
+          }
+        ]
+      },
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun run {{PKG_ROOT}}/src/hooks/PostToolOrchestrator.ts --agent=claude --only=events",
+            "async": true
           }
         ]
       }

package/package.json

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

package/src/cli/content.ts

@@ -0,0 +1,23 @@
+import { preserveTranscriptsOnce } from "../hooks/lib/transcript-preserve";
+import { group, leaf } from "../tools/lib/command";
+
+function printPreserve(): undefined {
+  const result = preserveTranscriptsOnce();
+  if (!result) {
+    console.log("Another copy is already running.");
+    return;
+  }
+  console.log(
+    `Copied ${result.copied}, unchanged ${result.unchanged}, failed ${result.failed}`
+  );
+}
+
+export const contentCommand = group({
+  summary: "PAL's local content store (never exported)",
+  commands: {
+    preserve: leaf({
+      summary: "Copy Claude Code transcripts, gzipped, before Claude Code deletes them",
+      run: printPreserve,
+    }),
+  },
+});

package/src/cli/events.ts

@@ -0,0 +1,47 @@
+import { isNagStage, logDiscordNag, NAG_STAGES } from "../hooks/lib/discord-events";
+import { group, leaf, UsageError } from "../tools/lib/command";
+
+function secondsFrom(raw: string | undefined): number | null {
+  if (raw === undefined) return null;
+  const seconds = Number(raw);
+  if (!Number.isFinite(seconds) || seconds < 0) {
+    throw new UsageError(`--after-sec must be a number of seconds, got "${raw}"`);
+  }
+  return Math.round(seconds);
+}
+
+function recordDiscordNag(
+  stage: string | undefined,
+  kind: string | undefined,
+  afterSec: string | undefined
+): undefined {
+  if (!isNagStage(stage)) {
+    throw new UsageError(`the stage is one of ${NAG_STAGES.join(", ")}`);
+  }
+  const responseSec = secondsFrom(afterSec);
+  if (stage === "answered" && responseSec === null) {
+    throw new UsageError("an answered nag needs --after-sec");
+  }
+  const id = logDiscordNag(stage, kind ?? null, responseSec);
+  console.log(id ? `Recorded ${id}` : "The event log is off; nothing recorded.");
+}
+
+export const eventsCommand = group({
+  summary: "PAL's local event log",
+  commands: {
+    "discord-nag": leaf({
+      summary: "Record a nag the Discord bot sent, or how long its answer took",
+      args: "<sent|answered>",
+      options: {
+        kind: { type: "string", value: "<kind>", description: "What the nag was about" },
+        "after-sec": {
+          type: "string",
+          value: "<n>",
+          description: "Seconds from the nag to the answer",
+        },
+      },
+      run: ({ positionals, values }) =>
+        recordDiscordNag(positionals[0], values.kind, values["after-sec"]),
+    }),
+  },
+});

package/src/cli/infer.ts

@@ -18,6 +18,7 @@ interface InferValues {
   schema?: string;
   timeout?: string;
   caller?: string;
+  web?: boolean;
 }
 
 type Infer = typeof inference;
@@ -81,6 +82,7 @@ function requestFrom(values: InferValues, stdin: string): Parameters<Infer>[0] {
     tier: tierOf(values.tier),
     timeout: timeoutMs(values.timeout),
     caller: values.caller ?? "cli-infer",
+    web: values.web ?? false,
   };
 }
 
@@ -137,6 +139,10 @@ export const inferCommand = leaf({
       value: "<label>",
       description: "Label for PAL's debug log",
     },
+    web: {
+      type: "boolean",
+      description: "Let the model search and read the web (Claude, Codex, Copilot)",
+    },
   },
   run: async ({ values }) => inferFromCli(values, await Bun.stdin.text()),
 });

package/src/cli/knowledge-research.ts

@@ -0,0 +1,93 @@
+/**
+ * pal cli knowledge research — research one person or company on the web through
+ * the active agent, print the profile, and optionally queue it for review.
+ */
+
+import { loadKnownEntities, loadNameIndex } from "../hooks/lib/entity-cards";
+import { queueForReview } from "../hooks/lib/entity-extraction";
+import { lookupName } from "../hooks/lib/entity-names";
+import {
+  type ResearchDeps,
+  type ResearchTarget,
+  renderProfile,
+  researchEntity,
+  researchItem,
+} from "../hooks/lib/entity-research";
+import { inference } from "../hooks/lib/inference";
+import { identity } from "../hooks/lib/settings";
+import { leaf, UsageError } from "../tools/lib/command";
+
+interface ResearchValues {
+  person?: boolean;
+  organization?: string;
+  context?: string;
+  queue?: boolean;
+  json?: boolean;
+}
+
+function storedSlug(name: string, kind: ResearchTarget["kind"]): string {
+  const domain = kind === "person" ? "People" : "Companies";
+  const { entities, exact } = lookupName(name, loadNameIndex(loadKnownEntities()));
+  const matches = entities.filter((e) => e.domain === domain);
+  return exact && matches.length === 1 ? matches[0].slug : "";
+}
+
+function targetFrom(name: string, values: ResearchValues): ResearchTarget {
+  const kind = values.person ? "person" : "company";
+  return {
+    kind,
+    name,
+    slug: storedSlug(name, kind),
+    organization: values.organization ?? "",
+    fact: values.context ?? "",
+  };
+}
+
+export async function researchFromCli(
+  name: string | undefined,
+  values: ResearchValues,
+  deps: ResearchDeps = { principal: identity().principal.name, infer: inference }
+): Promise<number> {
+  if (!name?.trim()) throw new UsageError("name the person or company to research");
+  const target = targetFrom(name.trim(), values);
+  const outcome = await researchEntity(target, deps);
+  if (!outcome.found) {
+    console.error(`Nothing kept for "${target.name}": ${outcome.reason}`);
+    return 1;
+  }
+  console.log(
+    values.json
+      ? JSON.stringify(outcome.profile, null, 2)
+      : renderProfile(outcome.profile)
+  );
+  if (values.queue) {
+    const item = researchItem(target, outcome.profile);
+    queueForReview([item]);
+    console.log(`\nQueued for review: pal cli knowledge review accept ${item.id}`);
+  }
+  return 0;
+}
+
+export const researchCommand = leaf({
+  summary: "Research a company (or --person) on the web: links, registry, news",
+  args: "<name>",
+  options: {
+    person: { type: "boolean", description: "Research a person, not a company" },
+    organization: {
+      type: "string",
+      value: "<name>",
+      description: "Where the person works, to tell namesakes apart",
+    },
+    context: {
+      type: "string",
+      value: "<text>",
+      description: "What you know about them, to tell namesakes apart",
+    },
+    queue: {
+      type: "boolean",
+      description: "Also queue the profile for `pal cli knowledge review`",
+    },
+    json: { type: "boolean", description: "Print the profile as JSON" },
+  },
+  run: ({ positionals, values }) => researchFromCli(positionals.join(" "), values),
+});

package/src/cli/knowledge.ts

@@ -7,6 +7,7 @@
 
 import { readFileSync } from "node:fs";
 import type { ReviewItem } from "../hooks/lib/entity-extraction";
+import { renderProfile } from "../hooks/lib/entity-research";
 import {
   type AcceptChoice,
   acceptReview,
@@ -34,6 +35,7 @@ import {
   type Status,
 } from "../tools/knowledge/lib";
 import { group, leaf, runCommand, UsageError } from "../tools/lib/command";
+import { researchCommand } from "./knowledge-research";
 
 const VOCABULARY = `Domains: ${DOMAINS.join(", ")}
 Relation types: ${RELATION_TYPES.join(", ")}`;
@@ -120,6 +122,7 @@ export const knowledgeCommand = group({
       },
       run: ({ values }) => cmdIngest(values.source ?? "manual", values.file),
     }),
+    research: researchCommand,
     review: group({
       summary: "People and companies the background extractor would not guess",
       fallback: "list",
@@ -623,17 +626,27 @@ function reviewReason(reason: ReviewItem["reason"]): string {
     ambiguous: "could be more than one known entry",
     "unknown-existing": "named an entry the store does not have",
     "first-name-only": "first name only",
+    "web-profile": "found on the web",
   };
   return reasons[reason];
 }
 
-function reviewLines(item: ReviewItem): string[] {
-  const { kind, name, fact } = item.entity;
+function reviewDetails(item: ReviewItem): string[] {
+  if (item.profile)
+    return [
+      item.entity.existing ? `for ${item.entity.existing}` : "as a new entry",
+      ...renderProfile(item.profile).split("\n"),
+    ];
   const candidates =
-    item.candidates.length > 0 ? `could be: ${item.candidates.join(", ")}` : "";
+    item.candidates.length > 0 ? [`could be: ${item.candidates.join(", ")}`] : [];
+  return [item.entity.fact, ...candidates, `from ${item.source}`];
+}
+
+function reviewLines(item: ReviewItem): string[] {
+  const { kind, name } = item.entity;
   return [
     `  ${item.id}  ${kind} "${name}" — ${reviewReason(item.reason)}`,
-    ...[fact, candidates, `from ${item.source}`]
+    ...reviewDetails(item)
       .filter(Boolean)
       .map((line) => `            ${line}`),
   ];

package/src/cli/tree.ts

@@ -14,6 +14,8 @@ import {
   type OptionSpecs,
 } from "../tools/lib/command";
 import { builtinTools, builtinToolVerbs } from "./builtin-tools";
+import { contentCommand } from "./content";
+import { eventsCommand } from "./events";
 import { identityCommand } from "./identity";
 import { inferCommand } from "./infer";
 import { knowledgeCommand } from "./knowledge";
@@ -151,6 +153,8 @@ export function cliTree(admin: AdminHandlers): Group {
     commands: {
       ...adminCommands(admin),
       usage: usageCommand,
+      content: contentCommand,
+      events: eventsCommand,
       infer: inferCommand,
       actor: identityCommand("actor"),
       machine: identityCommand("machine"),

package/src/hooks/AttentionEvent.ts

@@ -0,0 +1,22 @@
+/**
+ * Hook: PermissionRequest and Notification — logs that the agent is waiting on
+ * the user. Logging only: it prints nothing, so it never answers the prompt, and
+ * always exits 0.
+ */
+
+import { logAttention } from "./lib/attention-events";
+import { duplicatesCursorHooks } from "./lib/cursor-shadow";
+import { enterHookWorkspace } from "./lib/hook-turn";
+import { isPalSpawnedInference } from "./lib/spawn-guard";
+import { readStdinJSON } from "./lib/stdin";
+
+if (isPalSpawnedInference()) process.exit(0);
+if (duplicatesCursorHooks()) process.exit(0);
+
+try {
+  const input = await readStdinJSON<Record<string, unknown>>();
+  enterHookWorkspace(input);
+  logAttention(input);
+} catch {
+  process.exit(0);
+}

package/src/hooks/LoadContext.ts

@@ -24,11 +24,10 @@ import {
   isSubagentSession,
   needsAgentsMd,
 } from "./lib/session-context";
+import { logSessionStart } from "./lib/session-events";
 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.
 if (isPalSpawnedInference()) process.exit(0);
 if (duplicatesCursorHooks()) process.exit(0);
 if (isSubagentSession(process.env)) {
@@ -51,6 +50,7 @@ try {
 try {
   const active = getActiveAgent();
   const input = await readStdinJSON<{ source?: string }>();
+  logSessionStart(input);
   const wanted = contextForSource(active, input?.source);
   if (wanted === "none") {
     logDebug("LoadContext", `source=${input?.source}, context already present`);

package/src/hooks/PostToolOrchestrator.ts

@@ -0,0 +1,20 @@
+/**
+ * Hook: after a tool call, a failed call or a denied one. Silent and fail-open:
+ * it prints nothing and always exits 0, so it can never disturb a turn.
+ */
+
+import { duplicatesCursorHooks } from "./lib/cursor-shadow";
+import { enterHookWorkspace } from "./lib/hook-turn";
+import { runPostToolHandlers } from "./lib/post-tool";
+import { readStdinJSON } from "./lib/stdin";
+
+if (duplicatesCursorHooks()) process.exit(0);
+
+try {
+  const input = await readStdinJSON<Record<string, unknown>>();
+  if (!input) process.exit(0);
+  enterHookWorkspace(input);
+  runPostToolHandlers(input);
+} catch {
+  process.exit(0);
+}

package/src/hooks/PreCompactPersist.ts

@@ -7,8 +7,8 @@
  *
  * Storage: ~/.pal/memory/state/last-exchange/{session_id}.json + latest.json.
  * Path lives under PAL_HOME so other agents (OpenCode, Copilot, Cursor) can read the
- * same state if/when they grow equivalent compaction-recovery hooks. PreCompact itself
- * is currently a Claude Code event.
+ * same state if/when they grow equivalent compaction-recovery hooks. Cursor, Copilot
+ * and Codex run it too, which logs their compactions.
  */
 
 import { existsSync } from "node:fs";
@@ -19,6 +19,7 @@ import { duplicatesCursorHooks } from "./lib/cursor-shadow";
 import { logDebug, logError } from "./lib/log";
 import { paths } from "./lib/paths";
 import { sessionDir } from "./lib/session-dir";
+import { logCompaction } from "./lib/session-events";
 import { isPalSpawnedInference } from "./lib/spawn-guard";
 import { readStdinJSON } from "./lib/stdin";
 import { readTranscriptFile } from "./lib/transcript";
@@ -37,6 +38,7 @@ interface PreCompactInput {
 
 const main = async () => {
   const input = await readStdinJSON<PreCompactInput>();
+  logCompaction(input);
   if (!input?.transcript_path) {
     logDebug("PreCompactPersist", "No transcript_path in input — skipping");
     process.exit(0);

package/src/hooks/PreserveTranscripts.ts

@@ -0,0 +1,13 @@
+/**
+ * Spawned, never awaited — copies Claude Code transcripts into PAL's content
+ * store in a process of its own, so no session waits on the gzip.
+ */
+
+import { logError } from "./lib/log";
+import { preserveTranscriptsOnce } from "./lib/transcript-preserve";
+
+try {
+  preserveTranscriptsOnce();
+} catch (err) {
+  logError("PreserveTranscripts", err);
+}