talon-agent 5.26.2 → 5.26.4

package/src/core/backup/scheduler.ts

@@ -34,6 +34,11 @@ import { dirs } from "../../util/paths.js";
 import { passphraseProblem } from "./passphrase.js";
 import { buildSnapshot } from "./snapshot.js";
 import { listLocalManifests, pruneLocal, reconcileIndex } from "./store.js";
+import {
+  describeRetention,
+  localRetention,
+  remoteRetention,
+} from "./retention/policy.js";
 import { discoverTargets, selectTargets } from "./targets.js";
 import { pruneRemote, uploadSnapshot } from "./upload.js";
 import type { BackupSettings, Manifest, SnapshotKind } from "./types.js";
@@ -162,7 +167,7 @@ async function executeRun(request: RunRequest): Promise<Manifest> {
       parts: manifest.parts.length,
       durationMs: Date.now() - started,
     });
-    await _backupDeps.pruneLocal(settings.keepLocal, state.home);
+    await _backupDeps.pruneLocal(localRetention(settings), state.home);
     if (!request.localOnly) {
       const targets = selectTargets(
         await _backupDeps.discover(),
@@ -170,7 +175,7 @@ async function executeRun(request: RunRequest): Promise<Manifest> {
       );
       if (targets.length > 0) {
         await _backupDeps.upload(manifest, targets, state.home);
-        await _backupDeps.pruneRemote(targets, settings.keepRemote);
+        await _backupDeps.pruneRemote(targets, remoteRetention(settings));
       }
     }
     backoff.succeed();
@@ -379,8 +384,9 @@ export async function initBackup(options: {
   log(
     "backup",
     `Scheduled every ${options.settings.intervalHours}h; first run in ` +
-      `${Math.round(delay / 60_000)}m (keep ${options.settings.keepLocal} local, ` +
-      `${options.settings.keepRemote} remote)`,
+      `${Math.round(delay / 60_000)}m (retention ` +
+      `${describeRetention(localRetention(options.settings))}; ` +
+      `${options.settings.keepRemote} newest per remote target)`,
   );
 }
 

package/src/core/backup/snapshot.ts

@@ -54,6 +54,7 @@ import {
 import { signManifest } from "./archive/manifest-auth.js";
 import { TarWriter } from "./archive/tar.js";
 import { createCompressor } from "./archive/zstd.js";
+import { verifyWrittenParts } from "./archive/verify.js";
 import {
   collectTree,
   excludeForRoot,
@@ -755,6 +756,7 @@ export async function buildSnapshot(options: BuildOptions): Promise<Manifest> {
       }
     }
     await removeScratch(dir);
+    const verifiedAt = await verifyWrittenParts(dir, parts, passphrase);
 
     const gitHead = await readGitHead(process.cwd());
     const manifest: Manifest = {
@@ -776,6 +778,7 @@ export async function buildSnapshot(options: BuildOptions): Promise<Manifest> {
       ...(palaceHash ? { palaceHash } : {}),
       sizeBytes: parts.reduce((sum, part) => sum + part.bytes, 0),
       remote: {},
+      verifiedAt,
     };
     if (passphrase) manifest.auth = await signManifest(manifest, passphrase);
     await writeManifest(manifest, home);

package/src/core/backup/status.ts

@@ -53,6 +53,10 @@ export type BackupStatus = {
 type BackupPolicy = {
   keepLocal: number;
   keepRemote: number;
+  /** Absent on a policy built before tiered retention (older daemons). */
+  keepDaily?: number;
+  keepWeekly?: number;
+  keepCheckpoints?: number;
   /**
    * Snapshots are written encrypted: `backup.encryption` is configured or
    * the passphrase comes from the environment (see passphrase.ts). Off
@@ -69,6 +73,9 @@ function describePolicy(
   return {
     keepLocal: settings.keepLocal,
     keepRemote: settings.keepRemote,
+    keepDaily: settings.keepDaily,
+    keepWeekly: settings.keepWeekly,
+    keepCheckpoints: settings.keepCheckpoints,
     encrypted:
       settings.encryption !== undefined || Boolean(env[PASSPHRASE_ENV]?.trim()),
   };

package/src/core/backup/store.ts

@@ -33,6 +33,11 @@ import {
   updateBackupManifest,
 } from "../../storage/backup/index.js";
 import { pathExists } from "./sources/sessions.js";
+import {
+  describeRetention,
+  planRetention,
+  type RetentionPolicy,
+} from "./retention/policy.js";
 import type {
   Manifest,
   RemoteState,
@@ -236,26 +241,6 @@ export async function setSnapshotPinned(
 
 // ── Retention ───────────────────────────────────────────────────────────────
 
-/**
- * Which snapshots to drop so that at most `keep` unpinned ones remain.
- * Pure, and the order is the one the caller sees: newest first, pinned
- * snapshots kept unconditionally and not counted against the budget —
- * pinning is the user saying "this one outlives the policy".
- */
-export function selectPrunable<
-  T extends { id: string; createdAt: number; pinned: boolean },
->(snapshots: readonly T[], keep: number): T[] {
-  const ordered = [...snapshots].sort((a, b) => b.createdAt - a.createdAt);
-  const doomed: T[] = [];
-  let kept = 0;
-  for (const snapshot of ordered) {
-    if (snapshot.pinned) continue;
-    kept += 1;
-    if (kept > keep) doomed.push(snapshot);
-  }
-  return doomed;
-}
-
 /** Delete a snapshot directory and its index rows. */
 async function removeSnapshot(
   id: string,
@@ -266,14 +251,24 @@ async function removeSnapshot(
   deleteBackup(id);
 }
 
-/** Apply the local retention policy. Returns the ids removed. */
+/**
+ * Apply the local retention policy (see retention/policy.ts). Returns the ids
+ * removed. A directory whose manifest cannot be read never reaches the
+ * listing, so it is never pruned.
+ */
 export async function pruneLocal(
-  keep: number,
+  policy: RetentionPolicy,
   home: string = dirs.root,
 ): Promise<string[]> {
-  const doomed = selectPrunable(await listLocalManifests(home), keep);
+  const plan = planRetention(await listLocalManifests(home), policy);
+  for (const manifest of plan.skipped) {
+    logWarn(
+      "backup",
+      `Not pruning ${manifest.id}: its manifest has no usable createdAt`,
+    );
+  }
   const removed: string[] = [];
-  for (const manifest of doomed) {
+  for (const manifest of plan.prune) {
     try {
       await removeSnapshot(manifest.id, home);
       removed.push(manifest.id);
@@ -284,7 +279,7 @@ export async function pruneLocal(
   if (removed.length > 0) {
     log(
       "backup",
-      `Pruned ${removed.length} local snapshot(s) (keepLocal=${keep})`,
+      `Pruned ${removed.length} local snapshot(s) (${describeRetention(policy)})`,
     );
   }
   return removed;

package/src/core/backup/types.ts

@@ -123,6 +123,14 @@ export type Manifest = {
   /** Total bytes of all parts. */
   sizeBytes: number;
   remote: Record<string, RemoteState>;
+  /**
+   * Epoch ms at which every part was read back and matched its digest
+   * (and, when encrypted, decrypted end to end) — see archive/verify.ts. Set
+   * before signing, so the MAC covers it. Absent on snapshots written
+   * before verification existed. Retention never prunes the newest
+   * verified snapshot.
+   */
+  verifiedAt?: number;
   /** MAC under the backup passphrase; absent on plaintext/legacy snapshots. */
   auth?: ManifestAuth;
 };
@@ -146,6 +154,12 @@ export type BackupSettings = {
   intervalHours: number;
   keepLocal: number;
   keepRemote: number;
+  /** Newest snapshot per day, for this many days (0 = off). */
+  keepDaily: number;
+  /** Newest snapshot per ISO week, for this many weeks (0 = off). */
+  keepWeekly: number;
+  /** Unpinned checkpoints kept, apart from the scheduled snapshots. */
+  keepCheckpoints: number;
   includePalace: boolean;
   /** WhatsApp auth + userbot session: see {@link LoginSessionsPolicy}. */
   loginSessions: LoginSessionsPolicy;

package/src/core/backup/upload.ts

@@ -30,11 +30,11 @@ import {
 } from "../../storage/backup/index.js";
 import { isEncryptedFile } from "./archive/crypt.js";
 import {
-  partPath,
-  reindexSnapshot,
-  selectPrunable,
-  writeManifest,
-} from "./store.js";
+  describeRetention,
+  planRetention,
+  type RetentionPolicy,
+} from "./retention/policy.js";
+import { partPath, reindexSnapshot, writeManifest } from "./store.js";
 import type { BackupTarget } from "./targets.js";
 import type { Manifest, RemoteState, SnapshotPart } from "./types.js";
 
@@ -182,14 +182,19 @@ async function uploadToAll(
 }
 
 /**
- * Apply the remote retention policy on each target. Same rule as local:
- * the newest `keep` unpinned snapshots survive, pinned ones always do.
- * A target that cannot list is skipped — deleting on a partial listing is
- * how a retention pass turns into data loss.
+ * Apply the remote retention policy on each target — the same tiers as
+ * local (see retention/policy.ts), with `keepRemote` as the newest-N tier.
+ *
+ * Two refusals keep a retention pass from turning into data loss:
+ *   - A target that cannot list is skipped: deleting on a partial
+ *     listing is how that happens.
+ *   - An entry whose manifest is missing, unreadable, or has no
+ *     createdAt is never pruned. Without an age it cannot be ranked,
+ *     and treating it as the oldest would delete it first.
  */
 export async function pruneRemote(
   targets: readonly BackupTarget[],
-  keep: number,
+  policy: RetentionPolicy,
 ): Promise<void> {
   for (const target of targets) {
     if (!target.ready) continue;
@@ -203,15 +208,27 @@ export async function pruneRemote(
       );
       continue;
     }
-    const doomed = selectPrunable(
-      snapshots.map((entry) => ({
-        id: entry.snapshotId,
-        createdAt: entry.manifest?.createdAt ?? 0,
-        pinned: entry.manifest?.pinned === true,
-      })),
-      keep,
+    const plan = planRetention(
+      snapshots.map((entry) => {
+        const manifest = entry.manifest as Partial<Manifest> | undefined;
+        return {
+          id: entry.snapshotId,
+          createdAt: manifest?.createdAt as number,
+          pinned: manifest?.pinned === true,
+          kind: manifest?.kind,
+          verifiedAt: manifest?.verifiedAt,
+        };
+      }),
+      policy,
     );
-    for (const victim of doomed) {
+    if (plan.skipped.length > 0) {
+      logWarn(
+        "backup",
+        `Not pruning ${plan.skipped.length} snapshot(s) on ${target.id} whose manifest ` +
+          `is unreadable or has no createdAt: ${plan.skipped.map((s) => s.id).join(", ")}`,
+      );
+    }
+    for (const victim of plan.prune) {
       try {
         await target.remove(victim.id);
         deleteBackupRemote(victim.id, target.id);
@@ -222,10 +239,10 @@ export async function pruneRemote(
         );
       }
     }
-    if (doomed.length > 0) {
+    if (plan.prune.length > 0) {
       log(
         "backup",
-        `Pruned ${doomed.length} snapshot(s) from ${target.id} (keepRemote=${keep})`,
+        `Pruned ${plan.prune.length} snapshot(s) from ${target.id} (${describeRetention(policy)})`,
       );
     }
   }

package/src/core/config/index.ts

@@ -679,7 +679,8 @@ const configSchema = z.object({
    * Backups & checkpoints (docs/backups.md). Talon's only safety net, so
    * it is on by default: every `intervalHours` it writes a snapshot of
    * the identity, state, database and memory under ~/.talon/backups/,
-   * keeps `keepLocal` of them, and uploads to whatever remote targets
+   * keeps them on a tiered schedule (newest `keepLocal`, one a day for
+   * `keepDaily` days, one a week for `keepWeekly` weeks), and uploads to whatever remote targets
    * are registered (`targets: []` keeps everything local).
    *
    *   - `workspaceInclude` — the workspace is mostly bulk that can be
@@ -716,6 +717,30 @@ const configSchema = z.object({
         .min(1)
         .max(1000)
         .default(DEFAULT_BACKUP_SETTINGS.keepRemote),
+      /**
+       * Tiered retention on top of the newest `keepLocal`/`keepRemote`
+       * (docs/backups.md#retention): the newest snapshot of each of the
+       * last `keepDaily` days and `keepWeekly` weeks, plus up to
+       * `keepCheckpoints` unpinned checkpoints counted on their own.
+       */
+      keepDaily: z
+        .number()
+        .int()
+        .min(0)
+        .max(1000)
+        .default(DEFAULT_BACKUP_SETTINGS.keepDaily),
+      keepWeekly: z
+        .number()
+        .int()
+        .min(0)
+        .max(1000)
+        .default(DEFAULT_BACKUP_SETTINGS.keepWeekly),
+      keepCheckpoints: z
+        .number()
+        .int()
+        .min(1)
+        .max(1000)
+        .default(DEFAULT_BACKUP_SETTINGS.keepCheckpoints),
       includePalace: z.boolean().default(DEFAULT_BACKUP_SETTINGS.includePalace),
       /**
        * WhatsApp auth + the userbot's Telegram login. "local" (default)

package/src/core/errors.ts

@@ -139,6 +139,17 @@ function errorCodes(err: unknown, depth = 0): string[] {
 
 // ── Classify any error ──────────────────────────────────────────────────────
 
+/**
+ * A backend session that expired or no longer exists. Claude's CLI answers
+ * a resume of a session whose transcript is missing with "No conversation
+ * found with session ID: …" — a definite not-found; without the match
+ * every later turn in the chat fails the same way. The reset that follows
+ * archives the old id (resetSession), so a transcript that turns up again
+ * can be re-attached.
+ */
+const SESSION_EXPIRED_RE =
+  /session.*expired|expired.*session|invalid.*resume|no conversation found/i;
+
 /**
  * Wrap or classify any thrown value into a TalonError.
  * Call this at module boundaries (backend catch, bridge catch) to convert
@@ -259,8 +270,8 @@ export function classify(err: unknown): TalonError {
     });
   }
 
-  // Session expired
-  if (/session.*expired|expired.*session|invalid.*resume/i.test(msg)) {
+  // Session expired (or gone — see SESSION_EXPIRED_RE)
+  if (SESSION_EXPIRED_RE.test(msg)) {
     return new TalonError(msg, {
       reason: "session_expired",
       retryable: false,

package/src/frontend/discord/admin.ts

@@ -12,7 +12,7 @@ import { tailFile } from "../../util/tail-file.js";
 import type { TalonConfig } from "../../core/config/index.js";
 import type { Gateway } from "../../core/engine/gateway.js";
 import { resetSession, getAllSessions } from "../../storage/sessions.js";
-import { clearHistory } from "../../storage/history.js";
+import { markContextCleared } from "../../storage/history.js";
 import { todayLogDate } from "../../storage/daily-log.js";
 import { getChatSettings } from "../../storage/chat-settings.js";
 import {
@@ -87,7 +87,7 @@ export async function handleAdminSubcommand(
       const target = rest[0];
       if (!target) return send("Usage: /admin kill <chatId>");
       resetSession(target);
-      clearHistory(target);
+      markContextCleared(target); // soft reset: history rows are kept
       gateway?.backend?.sessions?.resetChat?.(target);
       return send(`Session ${target} reset.`);
     }

package/src/frontend/discord/callbacks/components/backend-select.ts

@@ -20,7 +20,6 @@ import {
   rebindChat,
 } from "../../../../core/engine/backend-controller/index.js";
 import { resetSession } from "../../../../storage/sessions.js";
-import { clearHistory } from "../../../../storage/history.js";
 import { resetPulseCheckpoint } from "../../../../core/background/pulse/pulse.js";
 import { resolveActiveModelForChat } from "../../../../core/models/active-model.js";
 import { logError } from "../../../../util/log.js";
@@ -109,12 +108,13 @@ export async function handleBackendSelect(
   }
 
   // Only now is the switch known to hold. Session state doesn't port across
-  // backends, so it goes — but each backend's remembered model pick stays.
+  // backends, so it goes — but each backend's remembered model pick stays,
+  // and chat history is never touched (a switch changes who answers, not
+  // what was said).
   // A re-pick of the backend already in use clears nothing: the retry after
   // a timed-out interaction must not cost the session a second time.
   if (!alreadyThere) {
-    resetSession(chatId);
-    clearHistory(chatId);
+    resetSession(chatId, "backend-switch");
     resetPulseCheckpoint(chatId);
     previous?.sessions?.resetChat?.(chatId);
   }

package/src/frontend/native/chats/chat-lifecycle.ts

@@ -6,7 +6,6 @@
 import { toClientChat } from "./chat-wire.js";
 import type { ClientChat } from "../protocol.js";
 import type { NativeRuntime } from "../runtime.js";
-import { clearTurnMeta } from "../turn/turn-meta.js";
 
 export function createChat(runtime: NativeRuntime, title?: string): ClientChat {
   const entry = runtime.chats.create(title);
@@ -27,10 +26,14 @@ export function renameChat(
   return chat;
 }
 
+/**
+ * Soft delete (see NativeChats.remove): the chat disappears from every
+ * client, but its history rows and their turn meta are kept for the
+ * operator — `talon history purge` is the only hard delete.
+ */
 export function deleteChat(runtime: NativeRuntime, chatId: string): boolean {
   const ok = runtime.chats.remove(chatId);
   if (ok) {
-    clearTurnMeta(chatId);
     runtime.contextByChat.delete(chatId);
     runtime.queuedByChat.delete(chatId);
     runtime.broadcast({ kind: "chat_deleted", chatId });

package/src/frontend/native/chats/chats.ts

@@ -17,7 +17,11 @@ import {
   setSessionName,
   deleteSession,
 } from "../../../storage/sessions.js";
-import { getRecentHistory, clearHistory } from "../../../storage/history.js";
+import {
+  getRecentHistory,
+  hideChatHistory,
+  isChatHistoryHidden,
+} from "../../../storage/history.js";
 import { previewOf } from "../protocol.js";
 
 export type ChatEntry = {
@@ -55,6 +59,8 @@ export class NativeChats {
   restore(): void {
     for (const { chatId, info } of getAllSessions()) {
       if (!isNativeChatId(chatId)) continue;
+      // Deleted by the user: its rows are kept, the chat stays gone.
+      if (isChatHistoryHidden(chatId)) continue;
       const recent = getRecentHistory(chatId, 1);
       const entry: ChatEntry = {
         id: chatId,
@@ -133,13 +139,19 @@ export class NativeChats {
     return entry;
   }
 
+  /**
+   * Delete the chat from the app. A soft delete: the chat leaves every list
+   * and its session goes, but its history rows are only hidden, never
+   * deleted — the operator can still find them, and only an explicit
+   * `talon history purge` removes them for good.
+   */
   remove(id: string): boolean {
     const entry = this.byId.get(id);
     if (!entry) return false;
     this.byId.delete(id);
     this.byNum.delete(entry.numericId);
     deleteSession(id);
-    clearHistory(id);
+    hideChatHistory(id);
     return true;
   }
 

package/src/frontend/native/chats/empty-chat-sweep.ts

@@ -28,7 +28,10 @@ function sweepEmptyChats(runtime: NativeRuntime): void {
   for (const entry of runtime.chats.unused(EMPTY_CHAT_MIN_AGE_MS)) {
     if (isBusy(runtime, entry.id) || runtime.queuedByChat.has(entry.id))
       continue;
-    if (getRecentHistory(entry.id, 1).length > 0) continue;
+    // Any stored row at all — even from before a reset — means the chat
+    // was used; never sweep it.
+    if (getRecentHistory(entry.id, 1, { includeCleared: true }).length > 0)
+      continue;
     if (deleteChat(runtime, entry.id)) {
       log("native", `Swept empty chat ${entry.id}`);
     }

package/src/frontend/native/chats/reset.ts

@@ -1,41 +1,63 @@
 /**
- * Chat reset — drop a chat's conversation (session, history, turn meta,
- * cached readouts, pulse checkpoint) while keeping the chat itself.
+ * Chat reset and backend hand-off — what a native chat forgets when its
+ * conversation restarts. Neither path deletes chat history: a reset is a
+ * soft reset (the context floor moves, the rows stay searchable), and a
+ * backend switch leaves history and the transcript exactly as they were.
  */
 
 import { resetSession } from "../../../storage/sessions.js";
-import { clearHistory } from "../../../storage/history.js";
+import { markContextCleared } from "../../../storage/history.js";
 import { resetPulseCheckpoint } from "../../../core/background/pulse/pulse.js";
 import { getBackendForChat } from "../../../core/engine/backend-controller/index.js";
 import { broadcastChatUpdated } from "./chat-wire.js";
 import { emitSystem } from "../turn/emit.js";
 import type { NativeRuntime } from "../runtime.js";
-import { clearTurnMeta } from "../turn/turn-meta.js";
 
-/**
- * Forget everything the conversation accumulated. Shared by the explicit
- * reset and a backend switch (sessions aren't portable across backends).
- */
-export function wipeChatConversation(
+/** Drop the per-process state tied to the chat's backend session. */
+function dropSessionState(
   runtime: NativeRuntime,
   chatId: string,
+  reason: string,
 ): void {
-  resetSession(chatId);
-  clearHistory(chatId);
-  clearTurnMeta(chatId);
+  resetSession(chatId, reason);
   runtime.contextByChat.delete(chatId);
   runtime.queuedByChat.delete(chatId);
   resetPulseCheckpoint(chatId);
 }
 
+/**
+ * A backend switch: session ids aren't portable across backends, so the
+ * session goes (its id is archived by resetSession). History, turn meta
+ * and the transcript stay — a switch changes who answers, not what was
+ * said.
+ */
+export function handOffChatBackend(
+  runtime: NativeRuntime,
+  chatId: string,
+): void {
+  dropSessionState(runtime, chatId, "backend-switch");
+}
+
+/**
+ * An explicit reset: the session goes and the chat's context starts fresh
+ * (a soft reset — every history row and its turn meta is kept, searchable
+ * and recoverable; the transcript and the bot's history tools start after
+ * the reset point).
+ */
+function resetChatContext(runtime: NativeRuntime, chatId: string): void {
+  dropSessionState(runtime, chatId, "reset");
+  markContextCleared(chatId);
+}
+
 export function resetChat(runtime: NativeRuntime, chatId: string): boolean {
   const entry = runtime.chats.get(chatId);
   if (!entry) return false;
-  // Full reset, matching /reset on the other frontends: session,
-  // history (the app re-fetches its transcript from us), pulse
-  // checkpoint, and any in-process backend memory. Warm the fresh
-  // session in the background — the bridge handler is sync.
-  wipeChatConversation(runtime, chatId);
+  // Full reset, matching /reset on the other frontends: session, the
+  // chat's context (soft — the app re-fetches a transcript that starts
+  // after the reset; nothing is deleted), pulse checkpoint, and any
+  // in-process backend memory. Warm the fresh session in the background —
+  // the bridge handler is sync.
+  resetChatContext(runtime, chatId);
   let backend = null;
   try {
     backend = getBackendForChat(chatId);

package/src/frontend/native/commands/session.ts

@@ -28,7 +28,7 @@ import {
   statusCommandReply,
 } from "../../presentation/text-commands.js";
 import { broadcastChatUpdated } from "../chats/chat-wire.js";
-import { resetChat, wipeChatConversation } from "../chats/reset.js";
+import { resetChat, handOffChatBackend } from "../chats/reset.js";
 import { setBackend } from "../surface/models.js";
 import { broadcastStatus } from "../surface/status.js";
 import { interruptTurn } from "../turn/turn.js";
@@ -48,7 +48,7 @@ async function model(ctx: NativeCommandContext): Promise<void> {
     },
     resetBackend: async () => {
       const outcome = await resetChatBackend(entry.id, deps);
-      wipeChatConversation(runtime, entry.id);
+      handOffChatBackend(runtime, entry.id);
       broadcastStatus(runtime);
       return outcome.text;
     },

package/src/frontend/native/surface/models.ts

@@ -25,7 +25,7 @@ import { getActiveReasoningLevels } from "../../presentation/reasoning-levels.js
 import { broadcastChatUpdated } from "../chats/chat-wire.js";
 import { emitSystem } from "../turn/emit.js";
 import type { BackendOption, ModelOption } from "../protocol.js";
-import { wipeChatConversation } from "../chats/reset.js";
+import { handOffChatBackend } from "../chats/reset.js";
 import type { NativeRuntime } from "../runtime.js";
 import { broadcastStatus } from "./status.js";
 
@@ -182,11 +182,11 @@ export async function setBackend(
   }
 
   setChatBackend(chatId, target);
-  wipeChatConversation(runtime, chatId);
+  handOffChatBackend(runtime, chatId);
   emitSystem(
     runtime,
     entry,
-    `Switched to ${target} — starting a fresh conversation.`,
+    `Switched to ${target} — new session, chat history kept.`,
   );
   broadcastChatUpdated(runtime, entry);
   broadcastStatus(runtime);

package/src/frontend/native/turn/turn-meta.ts

@@ -9,7 +9,6 @@
 import {
   recordTurnMeta as storeRecordTurnMeta,
   getTurnMeta as storeGetTurnMeta,
-  clearTurnMeta as storeClearTurnMeta,
 } from "../../../storage/turn-meta.js";
 import type { ClientToolCall } from "../protocol.js";
 
@@ -33,8 +32,3 @@ export function recordTurnMeta(
 export function getTurnMeta(chatId: string, msgId: string): TurnMeta | null {
   return storeGetTurnMeta<TurnMeta>(chatId, msgId);
 }
-
-/** Forget a chat entirely (chat deleted / history cleared). */
-export function clearTurnMeta(chatId: string): void {
-  storeClearTurnMeta(chatId);
-}

package/src/frontend/presentation/backup-panel.ts

@@ -180,7 +180,13 @@ function storageLines(f: ReportFormatter, status: BackupStatus): string[] {
   if (policy) {
     lines.push(
       `${f.bold("Retention:")} newest ${policy.keepLocal} kept here, ` +
-        `${policy.keepRemote} per target · pinned ones are never pruned`,
+        `${policy.keepRemote} per target` +
+        (policy.keepDaily ? ` · 1/day for ${policy.keepDaily}d` : "") +
+        (policy.keepWeekly ? ` · 1/week for ${policy.keepWeekly}w` : "") +
+        (policy.keepCheckpoints
+          ? ` · ${policy.keepCheckpoints} checkpoints`
+          : "") +
+        ` · pinned ones and the last verified are never pruned`,
     );
     lines.push(
       policy.encrypted