portable-agent-layer 0.104.0 → 0.104.2

package/package.json

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

package/src/cli/usage-render.ts

@@ -4,7 +4,6 @@ import {
   fmt,
   fmtCost,
   grandBucket,
-  inferenceLabel,
   modelLabel,
   modelsByCost,
   projectsByCost,
@@ -100,7 +99,7 @@ function projectSection(style: Style, agents: AgentReport[]): string[] {
 
 function inferenceSections(style: Style, data: UsageData): string[] {
   return usedInferenceModels(data.pal).flatMap(([model, buckets]) => [
-    subtle(style, "PAL inference", inferenceLabel(model)),
+    subtle(style, "PAL inference", modelLabel(model)),
     ...windowRows(style, buckets),
     "",
   ]);

package/src/hooks/lib/transcript-preserve.ts

@@ -34,10 +34,12 @@ interface PreserveLocations {
 
 type Manifest = Record<string, string>;
 
+export const transcriptArchive = () => resolve(paths.content(), "claude");
+
 function defaultLocations(): PreserveLocations {
   return {
     source: resolve(platform.claudeDir(), "projects"),
-    target: resolve(paths.content(), "claude"),
+    target: transcriptArchive(),
     manifest: resolve(paths.state(), "transcript-copies.json"),
   };
 }

package/src/tools/lib/token-report.ts

@@ -105,9 +105,9 @@ function byCost<T>(entries: [string, T][], costOf: (value: T) => number): [strin
   return entries.sort((a, b) => costOf(b[1]) - costOf(a[1]));
 }
 
-/** Drops the vendor's prefix and any provider path, so `accounts/x/models/kimi` reads `kimi`. */
+/** Drops the vendor's prefix, any provider path and a release date, so `accounts/x/models/kimi` reads `kimi`. */
 export function modelLabel(model: string): string {
-  return (model.split("/").at(-1) ?? model).replace("claude-", "");
+  return (model.split("/").at(-1) ?? model).replace("claude-", "").replace(/-\d{8}$/, "");
 }
 
 export const usedAgents = (agents: AgentReport[]) =>
@@ -160,18 +160,12 @@ function byProjectLines(agents: AgentReport[]): string[] {
   ];
 }
 
-export function inferenceLabel(model: string): string {
-  if (model.includes("haiku")) return "Haiku";
-  if (model.includes("sonnet")) return "Sonnet";
-  return model.replace("claude-", "");
-}
-
 export const usedInferenceModels = (pal: PalInferenceUsage) =>
   Object.entries(pal.byModel).filter(([, buckets]) => buckets.total.calls > 0);
 
 function palInferenceLines(pal: PalInferenceUsage): string[] {
   return usedInferenceModels(pal).flatMap(([model, buckets]) => [
-    `\n  PAL Inference (${inferenceLabel(model)})\n`,
+    `\n  PAL Inference (${modelLabel(model)})\n`,
     ...windowLines(buckets),
   ]);
 }

package/src/tools/lib/usage-buckets.ts

@@ -4,8 +4,8 @@
  * rather than finding it themselves, which is what makes them testable.
  */
 
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { resolve } from "node:path";
+import { type Dirent, existsSync, readdirSync, readFileSync } from "node:fs";
+import { relative, resolve } from "node:path";
 import type { LoggedEvent } from "../../hooks/lib/events";
 import { costOfUsage } from "../../hooks/lib/models";
 import { cacheWritesOf, finalPerMessage, type TranscriptUsage } from "./transcript-usage";
@@ -194,10 +194,18 @@ interface TranscriptLine {
  * wrote — those sit one level down and are billed to the same project, so
  * missing them undercounts every session that spawned one.
  */
-function transcriptsIn(projPath: string): string[] {
+function entriesOf(dir: string): Dirent[] {
+  try {
+    return readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+
+function transcriptsIn(projPath: string, extension = ".jsonl"): string[] {
   const files: string[] = [];
-  for (const entry of readdirSync(projPath, { withFileTypes: true })) {
-    if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+  for (const entry of entriesOf(projPath)) {
+    if (entry.isFile() && entry.name.endsWith(extension)) {
       files.push(resolve(projPath, entry.name));
       continue;
     }
@@ -205,7 +213,7 @@ function transcriptsIn(projPath: string): string[] {
     const subagentsDir = resolve(projPath, entry.name, "subagents");
     try {
       for (const sub of readdirSync(subagentsDir)) {
-        if (sub.endsWith(".jsonl")) files.push(resolve(subagentsDir, sub));
+        if (sub.endsWith(extension)) files.push(resolve(subagentsDir, sub));
       }
     } catch {
       /* no subagents dir */
@@ -256,30 +264,64 @@ function pricedCallOf(line: string): PricedCall | null {
   };
 }
 
+const projectDirsIn = (dir: string) =>
+  entriesOf(dir)
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name);
+
+const GZIP = ".gz";
+
+/** Claude Code deletes a transcript after cleanupPeriodDays; PAL's gzipped copy outlives it. */
+function deletedTranscriptsIn(archivedProject: string, liveProject: string): string[] {
+  return transcriptsIn(archivedProject, `.jsonl${GZIP}`).filter((copy) => {
+    const original = relative(archivedProject, copy).slice(0, -GZIP.length);
+    return !existsSync(resolve(liveProject, original));
+  });
+}
+
+function transcriptText(filepath: string): string | null {
+  try {
+    const raw = readFileSync(filepath);
+    return filepath.endsWith(GZIP)
+      ? new TextDecoder().decode(Bun.gunzipSync(raw))
+      : raw.toString("utf-8");
+  } catch {
+    return null;
+  }
+}
+
+function projectTranscripts(
+  claudeDir: string,
+  archiveDir: string | undefined,
+  dirName: string
+) {
+  const live = resolve(claudeDir, dirName);
+  return [
+    ...transcriptsIn(live),
+    ...(archiveDir ? deletedTranscriptsIn(resolve(archiveDir, dirName), live) : []),
+  ];
+}
+
 export function readClaudeCode(
   claudeDir: string,
   projectFilter?: string,
-  now: Date = new Date()
+  now: Date = new Date(),
+  archiveDir?: string
 ): AgentUsage {
   const tally = usageTally(projectFilter, now);
-  if (!existsSync(claudeDir)) return tally.usage;
   const calls: (PricedCall & { project: string })[] = [];
-
-  const projectDirs = readdirSync(claudeDir, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory())
-    .map((entry) => entry.name);
+  const projectDirs = new Set([
+    ...projectDirsIn(claudeDir),
+    ...(archiveDir ? projectDirsIn(archiveDir) : []),
+  ]);
 
   for (const dirName of projectDirs) {
     const projName = projectNameOf(dirName);
     if (typeof projectFilter === "string" && !projName.includes(projectFilter)) continue;
 
-    for (const filepath of transcriptsIn(resolve(claudeDir, dirName))) {
-      let content: string;
-      try {
-        content = readFileSync(filepath, "utf-8");
-      } catch {
-        continue;
-      }
+    for (const filepath of projectTranscripts(claudeDir, archiveDir, dirName)) {
+      const content = transcriptText(filepath);
+      if (content === null) continue;
 
       for (const line of content.split("\n")) {
         // Cheap reject before the parse: most lines are not model turns.

package/src/tools/token-cost.ts

@@ -8,6 +8,7 @@ import { resolve } from "node:path";
 import { AGENT_REGISTRY, type AgentName } from "../hooks/lib/agent-registry";
 import { eventsSince } from "../hooks/lib/events";
 import { platform } from "../hooks/lib/paths";
+import { transcriptArchive } from "../hooks/lib/transcript-preserve";
 import { findBinaryOnPath } from "../hooks/lib/which";
 import {
   opencodeDatabase,
@@ -32,7 +33,12 @@ function agentReports(project: string | undefined): AgentReport[] {
   });
   return [
     report("claude", () =>
-      readClaudeCode(resolve(platform.claudeDir(), "projects"), project)
+      readClaudeCode(
+        resolve(platform.claudeDir(), "projects"),
+        project,
+        new Date(),
+        transcriptArchive()
+      )
     ),
     report("codex", () => readCodex(platform.codexDir(), project)),
     report("opencode", () => readOpencode(opencodeDatabase(), project)),