talon-agent 5.26.3 → 5.26.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "5.26.3",
+  "version": "5.26.5",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "The Falconry",
   "license": "Apache-2.0",

package/src/app.ts

@@ -212,6 +212,14 @@ const { config } = await withConfigGuard(() =>
   ),
 );
 
+// Before any backend resumes a session: carry Claude transcripts over a
+// Talon-home move (their project slug is the cwd), and in a container
+// alert when a backend's session store isn't on a persistent volume.
+await bootPhase("storage layout", async () => {
+  const { runStorageLayoutChecks } = await import("./core/layout/index.js");
+  await runStorageLayoutChecks(config as unknown as Record<string, unknown>);
+});
+
 // Record this process as the daemon. The gateway port is appended once
 // the gateway binds (it may fall back from the default on EADDRINUSE).
 const bootedAt = new Date().toISOString();

package/src/backend/agy/auth.ts

@@ -14,16 +14,16 @@
  * the host.
  */
 
-import { homedir } from "node:os";
 import { join } from "node:path";
 import { readFileSync } from "node:fs";
+import { userHome } from "../../util/fs-path.js";
 
 /** Where the CLI caches its OAuth token. Env override for tests. */
 function agyTokenPath(override?: string): string {
   return (
     override ||
     process.env.TALON_AGY_TOKEN_FILE ||
-    join(homedir(), ".gemini", "antigravity-cli", "antigravity-oauth-token")
+    join(userHome(), ".gemini", "antigravity-cli", "antigravity-oauth-token")
   );
 }
 

package/src/backend/agy/mcp/config.ts

@@ -28,7 +28,6 @@
  * touch the real files.
  */
 
-import { homedir } from "node:os";
 import { join, dirname } from "node:path";
 import { randomBytes } from "node:crypto";
 import {
@@ -47,6 +46,7 @@ import { frontendsForChat } from "../../runtime/frontends.js";
 import { logWarn } from "../../../util/log.js";
 import { gatewayAuthHeaders } from "../../../core/engine/gateway-auth.js";
 import { AGY_MCP_PREFIX } from "../constants.js";
+import { userHome } from "../../../util/fs-path.js";
 
 // ── Paths ───────────────────────────────────────────────────────────────────
 
@@ -55,7 +55,7 @@ function agyMcpConfigPath(override?: string): string {
   return (
     override ||
     process.env.TALON_AGY_MCP_CONFIG ||
-    join(homedir(), ".gemini", "config", "mcp_config.json")
+    join(userHome(), ".gemini", "config", "mcp_config.json")
   );
 }
 
@@ -64,7 +64,7 @@ function agyMcpSnapshotDir(override?: string): string {
   return (
     override ||
     process.env.TALON_AGY_MCP_SNAPSHOT_DIR ||
-    join(homedir(), ".gemini", "antigravity-cli", "mcp")
+    join(userHome(), ".gemini", "antigravity-cli", "mcp")
   );
 }
 

package/src/backend/claude-sdk/usage/plan-usage.ts

@@ -13,13 +13,13 @@
  */
 
 import { readFile } from "node:fs/promises";
-import { homedir } from "node:os";
 import { join } from "node:path";
 import { logWarn } from "../../../util/log.js";
 import type {
   PlanUsage,
   PlanWindow,
 } from "../../../core/agent-runtime/capabilities.js";
+import { userHome } from "../../../util/fs-path.js";
 
 // `cedar_ember=1` asks the endpoint to include banked limit resets (the
 // claude.ai "Reset for free" grants); `skip_spend=1` drops the spend block we
@@ -38,7 +38,7 @@ let inFlight: Promise<PlanUsage | undefined> | undefined;
 function credentialsPath(): string {
   const configDir = process.env.CLAUDE_CONFIG_DIR?.trim();
   return join(
-    configDir && configDir.length > 0 ? configDir : join(homedir(), ".claude"),
+    configDir && configDir.length > 0 ? configDir : join(userHome(), ".claude"),
     ".credentials.json",
   );
 }

package/src/backend/codex/discovery.ts

@@ -39,12 +39,12 @@
  */
 
 import { promises as fs } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
 import { log, logDebug } from "../../util/log.js";
 import { getState } from "./state.js";
 import type { CodexAuthInfo } from "./auth.js";
 import { normalizeReasoningLevels } from "../../core/models/reasoning-levels.js";
+import { userHome } from "../../util/fs-path.js";
 
 /** Shape of one entry returned by OpenAI's `/v1/models`. Sparse — only `id` is reliably present. */
 interface OpenAiModelEntry {
@@ -99,7 +99,7 @@ export function getCodexCachePath(): string {
   const home = process.env.CODEX_HOME?.trim();
   return home && home.length > 0
     ? join(home, "models_cache.json")
-    : join(homedir(), ".codex", "models_cache.json");
+    : join(userHome(), ".codex", "models_cache.json");
 }
 
 /** Default soft timeout when callers await an in-flight discovery. */

package/src/backend/codex/plan-usage.ts

@@ -12,13 +12,13 @@
  */
 
 import { readFile, stat } from "node:fs/promises";
-import { homedir } from "node:os";
 import { join } from "node:path";
 import { logWarn } from "../../util/log.js";
 import type {
   PlanUsage,
   PlanWindow,
 } from "../../core/agent-runtime/capabilities.js";
+import { userHome } from "../../util/fs-path.js";
 
 const USAGE_ENDPOINT = "https://chatgpt.com/backend-api/wham/usage";
 const REQUEST_TIMEOUT_MS = 5_000;
@@ -37,7 +37,7 @@ function authPath(): string {
   const home = process.env.CODEX_HOME?.trim();
   return home && home.length > 0
     ? join(home, "auth.json")
-    : join(homedir(), ".codex", "auth.json");
+    : join(userHome(), ".codex", "auth.json");
 }
 
 interface CodexAuth {

package/src/backend/codex/token-usage.ts

@@ -29,8 +29,8 @@
  */
 
 import { readFile, readdir } from "node:fs/promises";
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { userHome } from "../../util/fs-path.js";
 
 export interface CodexLastTokenUsage {
   /** Last API call's prompt size = current context fill in tokens. */
@@ -120,7 +120,7 @@ export interface CodexRolloutSnapshot {
  * Codex CLI resolves its data directory.
  */
 function codexHome(): string {
-  return process.env.CODEX_HOME ?? join(homedir(), ".codex");
+  return process.env.CODEX_HOME ?? join(userHome(), ".codex");
 }
 
 /**

package/src/backend/remote-server/sessions.ts

@@ -15,6 +15,7 @@ import {
   setSessionId,
 } from "../../storage/sessions.js";
 import { log, logWarn } from "../../util/log.js";
+import { TalonError } from "../../core/errors.js";
 import type { RemoteAgentClient, RemotePermissionRule } from "./client.js";
 import type { RemoteServerState } from "./state.js";
 import {
@@ -73,32 +74,100 @@ export function buildPermissionRuleset(chatId: string): RemotePermissionRule[] {
   ];
 }
 
+/** Pull an HTTP status out of whatever shape the SDK client threw. */
+function errorStatus(err: unknown): number | undefined {
+  if (typeof err !== "object" || err === null) return undefined;
+  const e = err as Record<string, unknown>;
+  const cause = e.cause as Record<string, unknown> | undefined;
+  const response = e.response as Record<string, unknown> | undefined;
+  for (const candidate of [
+    e.status,
+    e.statusCode,
+    response?.status,
+    cause?.status,
+  ]) {
+    if (typeof candidate === "number") return candidate;
+  }
+  return undefined;
+}
+
+/** The error's `name`, from the thrown object or the parsed body behind it. */
+function errorNames(err: unknown): string[] {
+  if (typeof err !== "object" || err === null) return [];
+  const e = err as Record<string, unknown>;
+  const cause = e.cause as Record<string, unknown> | undefined;
+  const body = (cause?.body ?? e.body) as Record<string, unknown> | undefined;
+  return [e.name, body?.name, (e.data as Record<string, unknown>)?.name].filter(
+    (name): name is string => typeof name === "string",
+  );
+}
+
+/**
+ * True only when the server definitely says the session does not exist:
+ * an HTTP 404, or the server's `NotFoundError`. Everything else — a
+ * refused connection while the server is still starting, a 5xx, a
+ * timeout, a body that would not parse — is not proof the session is
+ * gone, and must not cost the chat its session.
+ */
+export function isRemoteSessionNotFound(err: unknown): boolean {
+  if (errorStatus(err) === 404) return true;
+  return errorNames(err).includes("NotFoundError");
+}
+
+/** Waits between `session.get` attempts on a transient failure. */
+const RESUME_RETRY_DELAYS_MS: readonly number[] = [500, 1_500];
+
 /**
  * Ensure a session exists for this chat on the remote agent server.
  *
  * Resumes the stored session id if `session.get` confirms it's still
- * alive. If the stored id is stale (any failure from `session.get`),
- * resets local state and creates a fresh session, returning the new
- * id. The fresh session is created with Talon's standard permission
- * ruleset (see {@link buildPermissionRuleset}).
+ * alive. Only a definite not-found (see {@link isRemoteSessionNotFound})
+ * resets the chat — archiving the old id — and creates a fresh session
+ * with Talon's standard permission ruleset (see
+ * {@link buildPermissionRuleset}). Any other failure is retried a couple
+ * of times and then fails the turn with the session left in place: a
+ * server that is still starting after an update must not wipe every
+ * chat's session mapping.
  */
 export async function ensureRemoteSession<TClient extends RemoteAgentClient>(
   client: TClient,
   state: RemoteServerState<TClient>,
   chatId: string,
+  retryDelaysMs: readonly number[] = RESUME_RETRY_DELAYS_MS,
 ): Promise<string> {
   const session = getSession(chatId);
 
   if (session.sessionId) {
-    try {
-      await client.session.get({ sessionID: session.sessionId });
-      return session.sessionId;
-    } catch {
-      logWarn(
-        "agent",
-        `[${chatId}] Session ${session.sessionId} expired, creating new`,
-      );
-      resetSession(chatId);
+    const sessionId = session.sessionId;
+    for (let attempt = 0; ; attempt++) {
+      try {
+        await client.session.get({ sessionID: sessionId });
+        return sessionId;
+      } catch (err) {
+        if (isRemoteSessionNotFound(err)) {
+          logWarn(
+            "agent",
+            `[${chatId}] ${state.label} session ${sessionId} not found on the server, creating new`,
+          );
+          resetSession(chatId, "remote_session_not_found");
+          break;
+        }
+        const delay = retryDelaysMs[attempt];
+        const detail = err instanceof Error ? err.message : String(err);
+        if (delay === undefined) {
+          throw new TalonError(
+            `Could not check ${state.label} session ${sessionId} (${detail}); ` +
+              `kept it — try again once the server is up`,
+            { reason: "network", retryable: true, cause: err },
+          );
+        }
+        logWarn(
+          "agent",
+          `[${chatId}] ${state.label} session check failed (${detail}); ` +
+            `retrying in ${delay}ms, session kept`,
+        );
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
     }
   }
 

package/src/backend/runtime/turn/handle-retry.ts

@@ -111,7 +111,8 @@ export interface ApplyRetryDecisionResult {
  *
  * Side effects (when a retry fires):
  *   - `incrementCounter('errors.<reason>')` exactly once per call.
- *   - `resetSession(chatId)` before recursion.
+ *   - `resetSession(chatId, reason)` before recursion (the old id is
+ *     archived under that reason).
  *   - For `fallback_model`: the fallback model id is spread into the
  *     recursion's params (`params.model` outranks chat settings).
  *
@@ -156,7 +157,7 @@ export async function applyRetryDecision(
       "agent",
       `[${chatId}] ${prefix}${decision.reason}, resetting ${resetNoun} and retrying`,
     );
-    resetSession(chatId);
+    resetSession(chatId, decision.reason);
     return { retry: await recurseWithRetried(params), classified };
   }
 
@@ -165,7 +166,7 @@ export async function applyRetryDecision(
       "agent",
       `[${chatId}] ${classified.reason}, falling back to ${decision.fallbackModelId}`,
     );
-    resetSession(chatId);
+    resetSession(chatId, `fallback_model:${decision.fallbackModelId}`);
     return {
       retry: await recurseWithRetried({
         ...params,
@@ -270,7 +271,7 @@ export async function* applyRetryDecisionStream(
       "agent",
       `[${chatId}] ${prefix}${decision.reason}, resetting ${resetNoun} and retrying`,
     );
-    resetSession(chatId);
+    resetSession(chatId, decision.reason);
     yield* buildRetryStream();
     return { retried: true, classified };
   }
@@ -280,7 +281,7 @@ export async function* applyRetryDecisionStream(
       "agent",
       `[${chatId}] ${classified.reason}, falling back to ${decision.fallbackModelId}`,
     );
-    resetSession(chatId);
+    resetSession(chatId, `fallback_model:${decision.fallbackModelId}`);
     yield* buildRetryStream(decision.fallbackModelId);
     return { retried: true, classified };
   }

package/src/cli/commands/backup.ts

@@ -46,6 +46,10 @@ import {
 import { resolveBackupSettings } from "../../core/backup/plan.js";
 import { buildSnapshot } from "../../core/backup/snapshot.js";
 import { pruneLocal, reconcileIndex } from "../../core/backup/store.js";
+import {
+  describeRetention,
+  localRetention,
+} from "../../core/backup/retention/policy.js";
 import { generatePassphraseFile } from "../../core/backup/passphrase.js";
 import { dirs } from "../../util/paths.js";
 import { fetchGateway } from "../daemon-api.js";
@@ -170,7 +174,7 @@ async function backupNow(flags: Flags): Promise<void> {
     pinned: pin,
     settings,
   });
-  await pruneLocal(settings.keepLocal);
+  await pruneLocal(localRetention(settings));
   console.log(
     `  ${pc.green("●")} ${manifest.id} — ${manifest.parts.length} part(s), ` +
       `${formatBytes(manifest.sizeBytes)}\n`,
@@ -246,10 +250,10 @@ async function backupPin(id: string, pinned: boolean): Promise<void> {
 
 async function backupPrune(): Promise<void> {
   const settings = resolveBackupSettings(loadConfig().backup);
-  const removed = await pruneLocal(settings.keepLocal);
+  const removed = await pruneLocal(localRetention(settings));
   console.log(
     removed.length === 0
-      ? `  ${pc.dim(`Nothing to prune (keepLocal=${settings.keepLocal}).`)}\n`
+      ? `  ${pc.dim(`Nothing to prune (${describeRetention(localRetention(settings))}).`)}\n`
       : `  ${pc.green("●")} Pruned ${removed.length}: ${removed.join(", ")}\n`,
   );
 }

package/src/core/auth/status.ts

@@ -13,9 +13,9 @@
  */
 
 import { readFile, stat } from "node:fs/promises";
-import { homedir } from "node:os";
 import { join } from "node:path";
 import { logWarn } from "../../util/log.js";
+import { userHome } from "../../util/fs-path.js";
 
 export type AuthProvider = "claude" | "codex";
 
@@ -44,14 +44,14 @@ export function claudeCredentialsPath(
 ): string {
   const configDir = env.CLAUDE_CONFIG_DIR?.trim();
   return join(
-    configDir ? configDir : join(homedir(), ".claude"),
+    configDir ? configDir : join(userHome(), ".claude"),
     ".credentials.json",
   );
 }
 
 export function codexAuthPath(env: NodeJS.ProcessEnv = process.env): string {
   const home = env.CODEX_HOME?.trim();
-  return join(home ? home : join(homedir(), ".codex"), "auth.json");
+  return join(home ? home : join(userHome(), ".codex"), "auth.json");
 }
 
 /** Providers the backends reported as dead since boot (cleared on login). */

package/src/core/backup/archive/verify.ts

@@ -0,0 +1,53 @@
+/**
+ * Read-back verification of a freshly written snapshot.
+ *
+ * A digest taken off the bytes on their way to disk says what was sent,
+ * not what landed. Before a snapshot is allowed to count as good, every
+ * part is read back from disk and re-hashed, and an encrypted part is
+ * decrypted end to end (and discarded) so a broken encryptor cannot
+ * produce a snapshot nobody can open. The result is `verifiedAt` in the
+ * manifest, and retention never prunes the newest snapshot that has one
+ * (see retention/policy.ts).
+ *
+ * Runs before the manifest is signed, so `verifiedAt` is covered by the
+ * MAC like every other field written at build time.
+ */
+
+import { join } from "node:path";
+import { TalonError } from "../../errors.js";
+import { isEncryptedFile, verifyDecryptable } from "./crypt.js";
+import { sha256File } from "./digest.js";
+import type { SnapshotPart } from "../types.js";
+
+/**
+ * Throws a TalonError naming the first part that does not read back.
+ * Returns the time verification finished.
+ */
+export async function verifyWrittenParts(
+  dir: string,
+  parts: readonly SnapshotPart[],
+  passphrase: string | null,
+  now: () => number = Date.now,
+): Promise<number> {
+  for (const part of parts) {
+    const path = join(dir, part.name);
+    const actual = await sha256File(path);
+    if (actual !== part.sha256) {
+      throw new TalonError(
+        `Part ${part.name} does not read back (sha256 mismatch)`,
+        { reason: "unknown" },
+      );
+    }
+    if (passphrase && (await isEncryptedFile(path))) {
+      try {
+        await verifyDecryptable(path, passphrase);
+      } catch (err) {
+        throw new TalonError(
+          `Part ${part.name} cannot be decrypted after writing: ${err instanceof Error ? err.message : String(err)}`,
+          { reason: "unknown", cause: err },
+        );
+      }
+    }
+  }
+  return now();
+}

package/src/core/backup/plan.ts

@@ -21,8 +21,8 @@
 
 import { lstat, readdir, readlink } from "node:fs/promises";
 import { isAbsolute, join, resolve, sep } from "node:path";
-import { homedir } from "node:os";
 import type { BackupSettings } from "./types.js";
+import { userHome } from "../../util/fs-path.js";
 
 /**
  * The workspace is mostly machine-generated bulk (uploads, media, build
@@ -51,6 +51,9 @@ export const DEFAULT_BACKUP_SETTINGS = {
   intervalHours: 6,
   keepLocal: 12,
   keepRemote: 30,
+  keepDaily: 7,
+  keepWeekly: 4,
+  keepCheckpoints: 10,
   includePalace: true,
   loginSessions: "local",
   includeSessions: true,
@@ -216,9 +219,9 @@ export function workspaceRoots(patterns: readonly string[]): string[] {
 /** Expand a leading `~` and resolve against the home directory. */
 export function expandUserPath(path: string): string {
   const trimmed = path.trim();
-  if (trimmed === "~") return homedir();
-  if (trimmed.startsWith("~/")) return resolve(homedir(), trimmed.slice(2));
-  return isAbsolute(trimmed) ? resolve(trimmed) : resolve(homedir(), trimmed);
+  if (trimmed === "~") return userHome();
+  if (trimmed.startsWith("~/")) return resolve(userHome(), trimmed.slice(2));
+  return isAbsolute(trimmed) ? resolve(trimmed) : resolve(userHome(), trimmed);
 }
 
 /** One member the builder will hand to the tar writer. */

package/src/core/backup/restore.ts

@@ -36,7 +36,6 @@ import {
   unlink,
   copyFile,
 } from "node:fs/promises";
-import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import writeFileAtomic from "write-file-atomic";
 import { dirs } from "../../util/paths.js";
@@ -73,6 +72,7 @@ import {
 } from "./store.js";
 import type { BackupTarget } from "./targets.js";
 import type { BackupSettings, Manifest, SnapshotPart } from "./types.js";
+import { userHome } from "../../util/fs-path.js";
 
 /** A staged request older than this is stale and ignored. */
 export const RESTORE_PENDING_MAX_AGE_MS = 10 * 60_000;
@@ -571,7 +571,7 @@ export async function restoreSnapshot(
   const realHome = options.home === undefined;
   const cloneTarget: CloneTarget = {
     home,
-    userHome: options.userHome ?? homedir(),
+    userHome: options.userHome ?? userHome(),
     env: options.env ?? (realHome ? process.env : {}),
   };
   const missing = await missingParts(manifest, home);
@@ -597,7 +597,7 @@ export async function restoreSnapshot(
       pinned: true,
       settings: options.settings,
       home,
-      userHome: options.userHome ?? (realHome ? homedir() : null),
+      userHome: options.userHome ?? (realHome ? userHome() : null),
       env: cloneTarget.env,
     });
     checkpointId = checkpoint.id;