portable-agent-layer 0.85.13 → 0.85.14

package/package.json

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

package/src/cli/doctor/health.ts

@@ -11,29 +11,49 @@ interface PendingMigration {
   detail?: string;
 }
 
+interface ErrorContext {
+  now: number;
+  env: Record<string, string | undefined>;
+}
+
 const CLAUDE_LOGIN_EXPIRED = /Failed to authenticate/;
+const MINUTE_MS = 60_000;
 
-function claudeLoginExpiredFinding(group: HookErrorGroup): Finding {
-  return failing(
-    `hook-errors.${group.source}`,
-    `Background calls to Claude cannot log in — ${group.count} failed in the last 24h: ${group.last}`,
-    {
-      say: "Create a year-long token, then export it as CLAUDE_CODE_OAUTH_TOKEN in your shell profile",
+function ago(at: number, now: number): string {
+  const minutes = Math.max(0, Math.round((now - at) / MINUTE_MS));
+  return minutes < 60 ? `${minutes}m ago` : `${Math.floor(minutes / 60)}h ago`;
+}
+
+function claudeLoginExpiredFinding(
+  group: HookErrorGroup,
+  context: ErrorContext
+): Finding {
+  const title = `Background calls to Claude could not log in — ${group.count} failed in the last 24h, last ${ago(group.lastAt, context.now)}: ${group.last}`;
+  if (context.env.CLAUDE_CODE_OAUTH_TOKEN)
+    return warning(`hook-errors.${group.source}`, title, {
+      say: "CLAUDE_CODE_OAUTH_TOKEN is set — if these failures predate it, they clear 24h after the last one; if not, the token is invalid, so create a new one",
       command: "claude setup-token",
-    }
-  );
+    });
+  return failing(`hook-errors.${group.source}`, title, {
+    say: "Create a year-long token, then export it as CLAUDE_CODE_OAUTH_TOKEN in your shell profile",
+    command: "claude setup-token",
+  });
 }
 
-export function hookErrorFindings(groups: HookErrorGroup[]): Finding[] {
+export function hookErrorFindings(
+  groups: HookErrorGroup[],
+  context: ErrorContext = { now: Date.now(), env: process.env }
+): Finding[] {
   if (groups.length === 0)
     return [passed("hook-errors", "No hook errors in the last 24h")];
   const log = resolve(palHome(), "debug", "debug.log");
   return groups.map((group) => {
-    if (CLAUDE_LOGIN_EXPIRED.test(group.last)) return claudeLoginExpiredFinding(group);
+    if (CLAUDE_LOGIN_EXPIRED.test(group.last))
+      return claudeLoginExpiredFinding(group, context);
     const times = group.count === 1 ? "once" : `${group.count} times`;
     return warning(
       `hook-errors.${group.source}`,
-      `${group.source} failed ${times} in the last 24h — last: ${group.last}`,
+      `${group.source} failed ${times} in the last 24h, last ${ago(group.lastAt, context.now)}: ${group.last}`,
       { say: `Full trace in ${log}` }
     );
   });

package/src/cli/doctor/state.ts

@@ -3,6 +3,7 @@ import { resolve } from "node:path";
 import { palHome, palPkg } from "../../hooks/lib/paths";
 import { auditBindings, type BindingIssue } from "../../hooks/lib/projects";
 import { telosStatus } from "../../hooks/lib/telos-topics";
+import { retiredKeysIn } from "../migrate";
 import { type Finding, failing, optional, passed, warning } from "./finding";
 
 interface SchemaNode {
@@ -142,7 +143,12 @@ function settingsFindings(): Finding[] {
       }),
     ];
   const schema = readSettingsSchema();
-  const unknown = schema ? unknownSettingsKeys(settings, schema) : [];
+  const leftToMigration = new Set(
+    retiredKeysIn(settings as Record<string, Record<string, unknown>>)
+  );
+  const unknown = schema
+    ? unknownSettingsKeys(settings, schema).filter((k) => !leftToMigration.has(k.path))
+    : [];
   return [identityFinding(settings), unknownKeysFinding(unknown)];
 }
 

package/src/cli/migrate.ts

@@ -671,7 +671,9 @@ function readSettingsObject(): Record<string, Record<string, unknown>> | null {
   }
 }
 
-function retiredKeysIn(settings: Record<string, Record<string, unknown>>): string[] {
+export function retiredKeysIn(
+  settings: Record<string, Record<string, unknown>>
+): string[] {
   return Object.entries(RETIRED_SETTINGS_KEYS).flatMap(([section, keys]) => {
     const value = settings[section];
     if (typeof value !== "object" || value === null) return [];

package/src/hooks/lib/log.ts

@@ -83,6 +83,12 @@ export interface HookErrorGroup {
   source: string;
   count: number;
   last: string;
+  lastAt: number;
+}
+
+interface LoggedError {
+  at: number;
+  message: string;
 }
 
 const DAY_MS = 24 * 60 * 60 * 1000;
@@ -114,13 +120,14 @@ function whatTheAgentSaid(message: string): string {
   return output[1].trim() || output[2].trim() || message;
 }
 
-function groupBySource(errors: string[]): HookErrorGroup[] {
+function groupBySource(errors: LoggedError[]): HookErrorGroup[] {
   const groups = new Map<string, HookErrorGroup>();
-  for (const error of errors) {
-    const source = /^([^:]+):/.exec(error)?.[1] ?? "unknown";
-    const group = groups.get(source) ?? { source, count: 0, last: "" };
+  for (const { at, message } of errors) {
+    const source = /^([^:]+):/.exec(message)?.[1] ?? "unknown";
+    const group = groups.get(source) ?? { source, count: 0, last: "", lastAt: 0 };
     group.count++;
-    group.last = whatTheAgentSaid(error.slice(source.length + 1).trim()).slice(0, 120);
+    group.last = whatTheAgentSaid(message.slice(source.length + 1).trim()).slice(0, 120);
+    group.lastAt = at;
     groups.set(source, group);
   }
   return [...groups.values()].sort((a, b) => b.count - a.count);
@@ -131,7 +138,10 @@ export function recentHookErrors(now: number = Date.now()): HookErrorGroup[] {
     const recent = readAllLogs()
       .split("\n")
       .filter((line) => line.includes("] ERROR ") && loggedAt(line) > now - DAY_MS)
-      .map((line) => line.replace(/^\[.*?\] ERROR /, ""));
+      .map((line) => ({
+        at: loggedAt(line),
+        message: line.replace(/^\[.*?\] ERROR /, ""),
+      }));
     return groupBySource(recent);
   } catch {
     return [];