@remnic/core 9.69.44 → 9.69.46

package/src/providers/codex-subscription.ts

@@ -177,7 +177,7 @@ export interface CodexSubscriptionRunnerDeps {
   /** Runs `codex exec`. Default: isolated subprocess via launchProcess. */
   runCodexExec?: (request: CodexSubscriptionExecRequest) => Promise<CodexSubscriptionExecResult>;
   /** Runs `codex login status`. Default: isolated subprocess. Receives the
-   * login-status timeout budget (capped by the request deadline) and the
+   * shared login-status ceiling (not any one caller's deadline) and the
    * shared-check abort signal (fires when the last waiter leaves). */
   runLoginStatus?: (
     executable: string,
@@ -210,6 +210,7 @@ interface LoginStatusCacheEntry {
 }
 
 const loginStatusCache = new Map<string, LoginStatusCacheEntry>();
+const inFlightLoginByRunner = new WeakMap<CodexCliFallbackRunner, Map<string, LoginStatusCacheEntry>>();
 const childrenByRunner = new WeakMap<CodexCliFallbackRunner, Set<number>>();
 const runnerByOwner = new WeakMap<object, CodexCliFallbackRunner>();
 const shutdownByRunner = new WeakMap<CodexCliFallbackRunner, AbortController>();
@@ -239,6 +240,7 @@ export function createCodexSubscriptionRunner(deps: CodexSubscriptionRunnerDeps
       { ...request, options: { ...request.options, signal } },
       runnerDeps,
       envSource,
+      runner,
     );
   };
   childrenByRunner.set(runner, children);
@@ -320,7 +322,8 @@ export function beginCodexSubscriptionShutdown(
 async function runCodexSubscriptionRequest(
   request: CodexCliFallbackRequest,
   deps: CodexSubscriptionRunnerDeps,
-  envSource: NodeJS.ProcessEnv
+  envSource: NodeJS.ProcessEnv,
+  runner: CodexCliFallbackRunner,
 ): Promise<CodexCliFallbackResult> {
   const { config } = request;
   assertNoApiKeyConfig(config);
@@ -339,7 +342,7 @@ async function runCodexSubscriptionRequest(
     throw abortErrorOf(request.options.signal);
   }
   await assertSubscriptionLogin(executable, env, deps, {
-    loginStatusTimeoutMs: Math.min(LOGIN_STATUS_TIMEOUT_MS, timeoutMs),
+    runner,
     callerTimeoutMs: timeoutMs,
     deadlineStartedAt,
     signal: request.options.signal,
@@ -460,8 +463,7 @@ function isAllowedEnvKey(key: string): boolean {
 }
 
 interface LoginCheckContext {
-  /** Budget for the login-status subprocess itself. */
-  loginStatusTimeoutMs: number;
+  runner: CodexCliFallbackRunner;
   /** The caller's overall effective deadline (login + exec). */
   callerTimeoutMs: number;
   deadlineStartedAt: number;
@@ -483,16 +485,32 @@ async function assertSubscriptionLogin(
   ctx: LoginCheckContext
 ): Promise<void> {
   const now = deps.now ?? Date.now;
-  const cacheKey = `${executable}\0${resolveCodexAuthHome(env) ?? ""}`;
+  const cacheKey = loginCacheKey(executable, env);
+  const inflight = inFlightLoginsFor(ctx.runner).get(cacheKey);
+  if (inflight && now() - inflight.at < LOGIN_STATUS_CACHE_TTL_MS) {
+    await waitForLoginEntry(inflight, cacheKey, ctx, now);
+    return;
+  }
   const cached = loginStatusCache.get(cacheKey);
   if (cached && now() - cached.at < LOGIN_STATUS_CACHE_TTL_MS) {
     if (!cached.settled || (await authStoreFingerprint(env)) === cached.fingerprint) {
       await waitForLoginEntry(cached, cacheKey, ctx, now);
       return;
     }
-
+    if (loginStatusCache.get(cacheKey) === cached) {
+      loginStatusCache.delete(cacheKey);
+    }
+  }
+  const raced = inFlightLoginsFor(ctx.runner).get(cacheKey);
+  if (raced && now() - raced.at < LOGIN_STATUS_CACHE_TTL_MS) {
+    await waitForLoginEntry(raced, cacheKey, ctx, now);
+    return;
+  }
+  const published = loginStatusCache.get(cacheKey);
+  if (published && now() - published.at < LOGIN_STATUS_CACHE_TTL_MS) {
+    await waitForLoginEntry(published, cacheKey, ctx, now);
+    return;
   }
-  loginStatusCache.delete(cacheKey);
   if (ctx.signal?.aborted) {
     throw abortErrorOf(ctx.signal);
   }
@@ -504,19 +522,19 @@ async function assertSubscriptionLogin(
     controller: new AbortController(),
     promise: Promise.resolve(undefined),
   };
-  entry.promise = runLoginStatusCheck(executable, env, deps, ctx, entry);
+  entry.promise = runLoginStatusCheck(executable, env, deps, entry);
   entry.promise.then(
     () => {
       entry.settled = true;
+      loginStatusCache.set(cacheKey, entry);
+      dropInFlightLogin(ctx.runner, cacheKey, entry);
     },
     () => {
       entry.settled = true;
-      if (loginStatusCache.get(cacheKey) === entry) {
-        loginStatusCache.delete(cacheKey);
-      }
+      dropInFlightLogin(ctx.runner, cacheKey, entry);
     }
   );
-  loginStatusCache.set(cacheKey, entry);
+  inFlightLoginsFor(ctx.runner).set(cacheKey, entry);
   await waitForLoginEntry(entry, cacheKey, ctx, now);
 }
 
@@ -524,16 +542,15 @@ async function runLoginStatusCheck(
   executable: string,
   env: NodeJS.ProcessEnv,
   deps: CodexSubscriptionRunnerDeps,
-  ctx: LoginCheckContext,
   entry: LoginStatusCacheEntry
 ): Promise<void> {
   const runLoginStatus = deps.runLoginStatus!;
-  const result = await runLoginStatus(executable, env, ctx.loginStatusTimeoutMs, entry.controller.signal);
+  const result = await runLoginStatus(executable, env, LOGIN_STATUS_TIMEOUT_MS, entry.controller.signal);
   const output = `${result.stdout}\n${result.stderr}`.trim();
   if (TIMEOUT_PATTERN.test(output)) {
     // A login-status subprocess timeout is a deadline expiry, not an auth
     // failure — never report it as "unauthenticated".
-    throw new CodexSubscriptionTimeoutError(ctx.loginStatusTimeoutMs);
+    throw new CodexSubscriptionTimeoutError(LOGIN_STATUS_TIMEOUT_MS);
   }
   if (result.status === 0 && LOGIN_OK_PATTERN.test(output)) {
     entry.fingerprint = await authStoreFingerprint(env);
@@ -602,6 +619,7 @@ async function waitForLoginEntry(
     entry.waiters--;
     if (entry.waiters <= 0 && !entry.settled) {
       entry.controller.abort();
+      dropInFlightLogin(ctx.runner, cacheKey, entry);
       if (loginStatusCache.get(cacheKey) === entry) {
         loginStatusCache.delete(cacheKey);
       }
@@ -633,6 +651,28 @@ function resolveCodexAuthHome(env: NodeJS.ProcessEnv): string | undefined {
   return profile ? path.join(profile, ".codex") : undefined;
 }
 
+function loginCacheKey(executable: string, env: NodeJS.ProcessEnv): string {
+  return `${executable}\0${resolveCodexAuthHome(env) ?? ""}`;
+}
+
+function inFlightLoginsFor(runner: CodexCliFallbackRunner): Map<string, LoginStatusCacheEntry> {
+  let map = inFlightLoginByRunner.get(runner);
+  if (!map) {
+    map = new Map();
+    inFlightLoginByRunner.set(runner, map);
+  }
+  return map;
+}
+
+function dropInFlightLogin(
+  runner: CodexCliFallbackRunner,
+  cacheKey: string,
+  entry: LoginStatusCacheEntry,
+): void {
+  const map = inFlightLoginByRunner.get(runner);
+  if (map?.get(cacheKey) === entry) map.delete(cacheKey);
+}
+
 /**
  * Args mirror the bench provider: fully sandboxed, ephemeral, no tools/hooks/
  * plugins/memories — extraction must behave as a plain completion endpoint.
@@ -755,7 +795,7 @@ function execFailureError(
   }
   if (AUTH_FAILURE_PATTERN.test(combined)) {
     // Re-check login on the next request; the cached status is now stale.
-    loginStatusCache.delete(`${executable}\0${env.CODEX_HOME ?? env.HOME ?? ""}`);
+    loginStatusCache.delete(loginCacheKey(executable, env));
     return new CodexSubscriptionAuthError(
       "expired_or_revoked",
       "codex-subscription: the Codex CLI rejected the request as unauthenticated " +

package/src/source-attribution.test.ts

@@ -16,6 +16,7 @@ import {
   formatCitation,
   hasCitation,
   hasCitationForTemplate,
+  lastRecognizedCitationMarker,
   parseAllCitations,
   parseCitation,
   stripCitation,
@@ -578,6 +579,32 @@ test("citationTemplatesToRecognize drops undetectable shapes and keeps prior his
   ]);
 });
 
+test("stripCitationForTemplate: literal template strips the exact marker (#2951)", () => {
+  const template = "[cited-fixed]";
+  const body = "Fact body. [cited-fixed]";
+  assert.equal(citationTemplateIsDetectable(template), true);
+  assert.equal(hasCitationForTemplate(body, template), true);
+  assert.equal(stripCitationForTemplate(body, template), "Fact body.");
+});
+
+test("citationTemplatesToRecognize: overlapping custom marker wins over inner default (#2951)", () => {
+  const custom = "[Source: agent={agent}, session={sessionId}, ts={ts}; via={agent}]";
+  const ctx = {
+    agent: "planner",
+    session: "agent:planner:main",
+    ts: "2026-04-10T14:25:07Z",
+  };
+  const marker = formatCitation(ctx, custom);
+  const body = `The cadence is weekly. ${marker}`;
+  const recognized = citationTemplatesToRecognize(custom);
+  assert.ok(
+    recognized.indexOf(custom) < recognized.indexOf(DEFAULT_CITATION_FORMAT),
+    "current overlapping template must be recognized before the inner default",
+  );
+  assert.equal(lastRecognizedCitationMarker(body, recognized), marker);
+  assert.equal(stripRecognizedCitations(body, recognized), "The cadence is weekly.");
+});
+
 test("formatCitation: substituted values containing placeholder syntax are not re-interpreted", () => {
   // Regression for PR #401 (low-severity): the previous implementation chained
   // `.replace(/\{agent\}/g, ...)`, `.replace(/\{ts\}/g, ...)` etc. If the agent

package/src/source-attribution.ts

@@ -499,10 +499,10 @@ export function citationTemplateIsDetectable(template: string): boolean {
 }
 
 /**
- * Templates the merge path may lift, preserve, or strip: the default
- * format, the current format when it is detectable, then any prior
- * configured formats the caller still holds. Undetectable shapes are
- * dropped so we never hash or attach a marker we cannot re-match.
+ * Templates the merge path may lift, preserve, or strip. Longest
+ * templates first so an overlapping custom marker beats an inner default
+ * match; the current template wins equal-length ties. Undetectable
+ * shapes are dropped so we never hash or attach a marker we cannot re-match.
  */
 export function citationTemplatesToRecognize(
   primary: string | undefined,
@@ -514,9 +514,15 @@ export function citationTemplatesToRecognize(
     if (!citationTemplateIsDetectable(template)) return;
     if (!out.includes(template)) out.push(template);
   };
-  add(DEFAULT_CITATION_FORMAT);
   add(primary);
   for (const template of extra) add(template);
+  add(DEFAULT_CITATION_FORMAT);
+  out.sort((a, b) => {
+    if (b.length !== a.length) return b.length - a.length;
+    if (a === primary && b !== primary) return -1;
+    if (b === primary && a !== primary) return 1;
+    return 0;
+  });
   return out;
 }
 
@@ -708,6 +714,9 @@ export function stripCitation(text: string): string {
  *    written under the default format can carry the default marker plus a
  *    custom marker appended after a config change; returning after the
  *    default pass alone left the custom marker inside hash inputs (#2330).
+ *  - Fully-literal templates (no placeholders) are stripped by exact match
+ *    of the template text, the same inclusion check `hasCitationForTemplate`
+ *    uses.
  *  - All-placeholder templates (no literal prefix/suffix/separator) cannot
  *    produce a reliable matcher. `hasCitationForTemplate` already returns
  *    `false` for such templates, so this function never attempts to strip an
@@ -731,6 +740,13 @@ export function stripCitationForTemplate(
 
   if (!hasCitationForTemplate(afterDefault, template)) return afterDefault;
 
+  PLACEHOLDER_REGEX.lastIndex = 0;
+  if (!PLACEHOLDER_REGEX.test(template)) {
+    PLACEHOLDER_REGEX.lastIndex = 0;
+    return stripExactLiteralCitation(afterDefault, template);
+  }
+  PLACEHOLDER_REGEX.lastIndex = 0;
+
   // Build the template matcher. hasCitationForTemplate already returned true,
   // which means templateMatcher produced a non-null result. The null branch
   // here is a defensive fallback only — the default pass already ran.
@@ -769,6 +785,26 @@ export function stripCitationForTemplate(
   return result.trimEnd();
 }
 
+function stripExactLiteralCitation(text: string, marker: string): string {
+  if (marker.length === 0) return text;
+  let result = "";
+  let lastIndex = 0;
+  let idx = text.indexOf(marker);
+  if (idx === -1) return text;
+  while (idx !== -1) {
+    const before = text.slice(lastIndex, idx).replace(/[ \t]+$/, "");
+    result += before;
+    lastIndex = idx + marker.length;
+    idx = text.indexOf(marker, lastIndex);
+  }
+  const after = text.slice(lastIndex).replace(/^[ \t]+/, "");
+  if (after.length > 0) {
+    if (result.length > 0) result += " ";
+    result += after;
+  }
+  return result.trimEnd();
+}
+
 function enclosingDelimiterRange(
   text: string,
   start: number,

package/src/storage/cas-revision-host.ts

@@ -72,4 +72,26 @@ export class CasRevisionHost extends CasRevisionStore {
     await this.recoverPendingRevision(pathname);
     return await this.beginRevisionTransaction(pathname, expectedContent);
   }
+
+  /** #2837: best-effort post-deletion sweep of the target's receipt shard.
+   * The durable memory file is already gone, so a failed sweep must never
+   * fail the deletion itself — it logs instead. A PENDING shard (crash
+   * recovery evidence) and a foreign shard (another target's receipt) are
+   * kept, with a warning naming the recovery path. */
+  async sweepShardAfterDeletion(filePath: string): Promise<void> {
+    try {
+      const outcome = await this.removeRevisionShard(filePath);
+      if (outcome === "pending") {
+        log.warn(
+          `CAS revision shard for ${filePath} kept after memory deletion: a pending reservation stands — run recovery before the path is reused`,
+        );
+      } else if (outcome === "foreign") {
+        log.warn(
+          `CAS revision shard for ${filePath} kept after memory deletion: the shard names another target`,
+        );
+      }
+    } catch (err) {
+      log.warn(`failed to sweep CAS revision shard for deleted memory ${filePath}: ${err}`);
+    }
+  }
 }

package/src/storage/cas-revision-store.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { createHash } from "node:crypto";
-import { mkdir, mkdtemp, readFile, readdir, rm, symlink, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, readdir, rm, stat, symlink, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
@@ -461,3 +461,46 @@ test("legacy landed pending whose file no longer matches expectedDigest is ambig
     assert.equal((await store.readRevisionStatus(target)).status, "unavailable");
   });
 });
+
+test("removeRevisionShard sweeps a committed shard, keeps pending evidence, never touches a foreign shard (#2837)", async () => {
+  await withStore(async (store, root) => {
+    const target = path.join(root, "memories", "fact-deleted.md");
+    const shard = shardPathFor(root, target);
+    const shardExists = async () =>
+      stat(shard).then(
+        () => true,
+        () => false,
+      );
+
+    // No receipt was ever minted: the sweep reports absence, not an error.
+    assert.equal(await store.removeRevisionShard(target), "absent");
+
+    const a = await store.beginRevisionTransaction(target);
+    await a.commit();
+    assert.equal(await shardExists(), true);
+    assert.equal(await store.removeRevisionShard(target), "removed");
+    assert.equal(await shardExists(), false, "the committed shard is gone once its memory is deleted");
+    assert.equal((await store.readRevisionStatus(target)).status, "absent");
+
+    // A PENDING marker is crash-recovery evidence: the sweep must keep it.
+    const b = await store.beginRevisionTransaction(target);
+    assert.equal(await store.removeRevisionShard(target), "pending");
+    assert.equal(await shardExists(), true, "the pending marker survives the deletion sweep");
+    await b.abort();
+
+    // A shard naming another target is never destroyed by this target's sweep.
+    await mkdir(path.dirname(shard), { recursive: true });
+    await writeFile(
+      shard,
+      `${JSON.stringify({
+        version: 1,
+        path: "memories/someone-else.md",
+        revision: "2026-08-01T00:00:00.000Z",
+        state: "committed",
+      })}\n`,
+      "utf8",
+    );
+    assert.equal(await store.removeRevisionShard(target), "foreign");
+    assert.equal(await shardExists(), true, "a foreign shard is kept — it names another target");
+  });
+});

package/src/storage/cas-revision-store.ts

@@ -641,6 +641,29 @@ export class CasRevisionStore {
     });
   }
 
+  /** #2837: remove the target's receipt shard once its durable memory file
+   * has been deleted, so orphan shards cannot accumulate. Under the shard
+   * lock: a PENDING marker is crash-recovery evidence for
+   * {@link recoverPendingRevision} and is KEPT ("pending"); a shard naming
+   * another target is KEPT ("foreign") — never destroy a receipt you cannot
+   * attribute. Never touches the durable memory file or the legacy global
+   * metadata: a stale legacy entry keeps per-path monotonicity if the path
+   * is ever reused. */
+  async removeRevisionShard(
+    filePath: string,
+  ): Promise<"removed" | "absent" | "pending" | "foreign"> {
+    const relativePath = await this.resolveRelativePath(filePath);
+    return await this.withShardLock(relativePath, async () => {
+      const { shardPath } = await this.getSafeShardInfo(relativePath);
+      const view = await this.readShardView(shardPath, relativePath);
+      if (view.kind === "missing") return "absent";
+      if (view.kind === "pending") return view.foreign ? "foreign" : "pending";
+      if (view.kind === "foreign" || view.foreign) return "foreign";
+      await unlink(shardPath);
+      return "removed";
+    });
+  }
+
   /** #2813 (P1 C): recovery for a reservation left PENDING by a crash or a
    * failed publication. The caller supplies the KNOWN outcome of the
    * durable memory write: `fileWriteLanded` publishes the pending token as

package/src/storage/tombstone-blocked-capture-sync.ts

@@ -10,6 +10,7 @@ import { withRawEntityPageMutation } from "./entity-canonical-id-lock.js";
 import { readMaybeEncryptedFileFromChunks, writeMaybeEncryptedFileFromChunks } from "../secure-store/secure-fs.js";
 import * as archiveMutation from "../archive-mutation-version.js";
 import { invalidationCommitFingerprint, isSemanticFrontmatterChange } from "./deletion-revision-store.js";
+import { CasRevisionHost } from "./cas-revision-host.js";
 import type { CasRevisionTransaction } from "./cas-revision-store.js";
 import {
   buildExplicitCaptureDedupKey,
@@ -208,7 +209,11 @@ export abstract class TombstoneBlockedCaptureIndexHost {
   protected abstract bumpMemoryStatusVersion(): void;
   protected abstract bumpMemoryCorpusVersion(): void;
   protected abstract markFactHashIndexNotAuthoritative(): void;
-  protected abstract deleteManagedStorageFile(filePath: string, deletionMtimeMs?: number | null): Promise<boolean>;
+  /** #2837: durable unlink plus deletion-revision record, WITHOUT the CAS
+   * shard sweep — the concrete {@link deleteManagedStorageFile} composes the
+   * two so every deletion funnel (invalidation, maintenance purge, archive
+   * move, offline sync) sweeps. */
+  protected abstract deleteManagedStorageFileDurable(filePath: string, deletionMtimeMs?: number | null): Promise<boolean>;
   protected abstract writeManagedStorageFile(filePath: string, write: () => Promise<void>): Promise<void>;
 
   /** #2813 (P1 C, #2807): reserve the target's next durable CAS revision
@@ -221,6 +226,26 @@ export abstract class TombstoneBlockedCaptureIndexHost {
     return undefined;
   }
 
+  /** #2837 (shard cleanup): after a managed memory file is durably deleted,
+   * sweep its per-target CAS receipt shard so orphan shards cannot grow
+   * forever. The sweep runs under the shard's own lock and is best-effort —
+   * the memory file is already gone, so a sweep failure logs and never
+   * fails the delete. The sweeper is a second CasRevisionHost over the same
+   * memory dir; the host is stateless and every mutation serializes through
+   * the sidecar's file locks, so it shares the same shard files
+   * StorageManager's own host operates on. */
+  private deletedMemoryShardSweeper: CasRevisionHost | null = null;
+
+  protected async deleteManagedStorageFile(filePath: string, deletionMtimeMs?: number | null): Promise<boolean> {
+    const deleted = await this.deleteManagedStorageFileDurable(filePath, deletionMtimeMs);
+    if (!deleted) return false;
+    if (this.deletedMemoryShardSweeper === null) {
+      this.deletedMemoryShardSweeper = new CasRevisionHost(this.tombstoneBlockedCaptureIndexOptions().memoryDir);
+    }
+    await this.deletedMemoryShardSweeper.sweepShardAfterDeletion(filePath);
+    return true;
+  }
+
   private async writeStorageSecureFileChunks(filePath: string, chunks: AsyncIterable<Buffer>): Promise<void> {
     const options = this.tombstoneBlockedCaptureIndexOptions();
     await writeMaybeEncryptedFileFromChunks(

package/src/storage-frontmatter-cas.test.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdir, mkdtemp, readdir, readFile, rm, symlink, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readdir, readFile, rm, stat, symlink, writeFile } from "node:fs/promises";
 import { createHash } from "node:crypto";
 import os from "node:os";
 import path from "node:path";
@@ -838,3 +838,51 @@ test("crash after memory write before writeLanded recovers from host-forwarded e
     );
   });
 });
+
+test("deleting a memory sweeps its CAS revision shard (#2837)", async () => {
+  await withStorageDir(async (dir) => {
+    const storage = new StorageManager(dir);
+    const created = await storage.writeMemory("fact", "Deletion shard sweep content.", { source: "test" });
+    const memory = await storage.getMemoryById(created.id);
+    assert.ok(memory);
+
+    // Mint a standing receipt, then delete the memory through the public
+    // invalidation funnel (the same funnel maintenance purge and archive
+    // moves use underneath).
+    assert.equal(await storage.writeMemoryFrontmatter(memory, { tags: ["sweep"] }), true);
+    const shard = casShardPath(dir, memory.path);
+    assert.equal((await storage.readCasRevisionStatus(memory.path)).status, "present");
+    await stat(shard);
+
+    assert.equal(await storage.invalidateMemory(created.id), true);
+    assert.equal(await stat(shard).then(() => true, () => false), false, "the deleted memory's shard is swept");
+    assert.equal(
+      (await storage.readCasRevisionStatus(memory.path)).status,
+      "absent",
+      "no standing receipt survives the memory",
+    );
+  });
+});
+
+test("a pending shard survives memory deletion as recovery evidence, and the delete still succeeds (#2837)", async () => {
+  await withStorageDir(async (dir) => {
+    const storage = new StorageManager(dir);
+    const created = await storage.writeMemory("fact", "Pending shard kept on delete.", { source: "test" });
+    const memory = await storage.getMemoryById(created.id);
+    assert.ok(memory);
+
+    // Crash simulation: a reservation left PENDING for this target.
+    const seams = storage as unknown as { casRevisions: CasRevisionStore };
+    await seams.casRevisions.beginRevisionTransaction(memory.path);
+    const shard = casShardPath(dir, memory.path);
+    await stat(shard);
+
+    assert.equal(await storage.invalidateMemory(created.id), true, "the deletion itself never fails on the sweep");
+    assert.equal(
+      await stat(shard).then(() => true, () => false),
+      true,
+      "a PENDING marker is crash-recovery evidence and is kept",
+    );
+    assert.equal((await storage.readCasRevisionStatus(memory.path)).status, "unavailable");
+  });
+});

package/src/storage.ts

@@ -2732,7 +2732,7 @@ export class StorageManager extends TombstoneBlockedCaptureIndexHost {
   protected async writeManagedStorageFile(filePath: string, write: () => Promise<void>): Promise<void> {
     return this.deletionRevisionStore.writeManagedStorageFile(filePath, write);
   }
-  protected async deleteManagedStorageFile(filePath: string, deletionMtimeMs?: number | null): Promise<boolean> {
+  protected async deleteManagedStorageFileDurable(filePath: string, deletionMtimeMs?: number | null): Promise<boolean> {
     return this.deletionRevisionStore.deleteManagedStorageFile(filePath, deletionMtimeMs);
   }
 

package/src/summarizer.ts

@@ -360,6 +360,24 @@ Respond with valid JSON matching this schema:
 
     const user = `Hour: ${hourIso}\nSession: ${sessionKey}\n\n${statsLine}${toolStatsLine}Conversation:\n${conversation}\n`;
 
+    if (this.config.backgroundGeneration) {
+      try {
+        const text = await completeBackgroundGeneration(this.config, [
+          { role: "system", content: sys },
+          { role: "user", content: user },
+        ]);
+        const parsed = parseBackgroundGenerationJson(text, (value) => HourlySummaryExtendedSchema.parse(value));
+        if (parsed) {
+          log.debug(
+            `generated extended hourly summary for ${sessionKey} at ${hourIso} in ${Date.now() - startTime}ms (background)`
+          );
+          return { ...parsed, _meta: { userTurns, assistantTurns, toolCalls, toolCounts } };
+        }
+      } catch {
+        log.info("extended summary: background generation unavailable, continuing");
+      }
+    }
+
     // Try local LLM first if enabled
     if (this.shouldUseLocalLlm) {
       try {