@remnic/core 9.16.3 → 9.17.1

package/src/activity/memory-gen.ts

@@ -0,0 +1,409 @@
+import { scoreImportance, isAboveImportanceThreshold } from "../importance.js";
+import { getVerdictKind, type JudgeCandidate, type JudgeVerdict, type JudgeVerdictKind } from "../extraction-judge.js";
+import { log } from "../logger.js";
+import type { ExtractedFact, ExtractionResult, ImportanceScore, MemoryStatus } from "../types.js";
+import {
+  composeMemoryEnvelope,
+  type MemoryWriteInput,
+  type SealedMemoryEnvelope,
+  type WriteContext,
+} from "../write-envelope.js";
+import { computeTrustScore, decideSmart, type SmartDecision } from "../wearables/trust.js";
+import { activityDayWindow } from "./digest.js";
+import type { ActivityConfig } from "./types.js";
+
+const ACTIVITY_ALLOWED_CATEGORIES: Record<string, true> = {
+  decision: true,
+  commitment: true,
+  preference: true,
+  moment: true,
+};
+const FIRST_PERSON = /\b(?:i|we|my|our|i['’]ve|we['’]ve)\b/i;
+/**
+ * Attribution detection. On-screen text routinely quotes other people, so a
+ * first-person pronoun is not ownership evidence. Two shapes are rejected,
+ * case-insensitively, with the speaker slot excluding bare first-person
+ * pronouns (word-anchored) so "We decided" stays eligible while names that
+ * merely begin with a pronoun ("Wendy", "Ian") do not:
+ *   - verb attribution:  "Alice wrote: I decided ..." (leading speaker + verb)
+ *   - leading label:     "Alice: I decided ..." (chat/comment sender headers)
+ * Common document labels ("Note:", "TODO:") are not senders and stay eligible.
+ */
+const ATTRIBUTION_SPEAKER = String.raw`(?!(?:i|we|us|me|my|our)\b)[A-Za-z][\w.'’-]*`;
+const SPEECH_VERB =
+  String.raw`(?:said|says|wrote|writes|posted|typed|asked|replied|messaged|commented|noted|announced|added|responded|mentioned|told)`;
+const VERB_ATTRIBUTION = new RegExp(String.raw`^\s*${ATTRIBUTION_SPEAKER}\s+${SPEECH_VERB}\b`, "i");
+const LABEL_ATTRIBUTION = new RegExp(
+  String.raw`^\s*(${ATTRIBUTION_SPEAKER}(?:\s+[A-Za-z][\w.'’-]*){0,3})\s*:\s*`,
+  "i",
+);
+// A sender named inside an otherwise-allowlisted label ("Update from Alice:",
+// "Note by Bob:") is still attribution. Case-sensitive on the capitalized name
+// so generic labels ("Summary by section:") stay eligible.
+const LABEL_NAMES_SENDER = /\b(?:from|by)\s+[A-Z][a-z]/;
+const NON_SENDER_LABELS: Record<string, true> = {
+  note: true, notes: true, todo: true, fixme: true, reminder: true, update: true,
+  updates: true, warning: true, info: true, tip: true, tips: true, summary: true,
+  status: true, tldr: true, fyi: true, idea: true, goal: true, goals: true,
+  plan: true, plans: true, action: true, actions: true, context: true, question: true,
+};
+const TRUST_ATTRIBUTE_KEYS: Record<string, true> = {
+  trustscore: true,
+  trustdecision: true,
+  judgeverdict: true,
+};
+
+export interface ActivityMemoryWriter {
+  /**
+   * Locate an existing activity memory for this day whose normalized content
+   * matches, or null. The dedup identity is `(activity day, normalized content)`:
+   * `dayStartUtc`/`dayEndUtc` bound the half-open day window and `normalizedKey`
+   * is trim+lowercase content — so whitespace/case variants collapse, while the
+   * SAME text on a different day is NOT a duplicate (recurring actions persist
+   * per day). Enables dedup and in-place promotion instead of duplicate or
+   * frozen-pending records.
+   */
+  findActivityMemoryByContent(
+    normalizedKey: string,
+    dayStartUtc: string,
+    dayEndUtc: string,
+  ): Promise<{ id: string; status: MemoryStatus | undefined } | null>;
+  /**
+   * Count active + pending_review activity memories whose event time falls in
+   * the half-open [startUtc, endUtc) day window. Seeds `maxMemoriesPerDay` so
+   * the cap holds across repeated digest runs on the same day rather than
+   * resetting on every call.
+   */
+  countActivityMemoriesForDay(startUtc: string, endUtc: string): Promise<number>;
+  /**
+   * Promote a pending_review activity memory to active, merging trust evidence.
+   * Returns false when the row is missing or no longer pending.
+   */
+  promoteActivityMemory(
+    id: string,
+    attributeUpdates: Record<string, string>,
+    confidence?: number,
+  ): Promise<boolean>;
+  /**
+   * Demote a pending_review activity memory to rejected on a fresh judge-reject
+   * re-verdict. Active rows are never auto-demoted. Returns false when missing
+   * or no longer pending.
+   */
+  demoteActivityMemory(id: string, attributeUpdates: Record<string, string>): Promise<boolean>;
+  writeSealedMemory(
+    envelope: SealedMemoryEnvelope,
+    extras: { status: MemoryStatus; contentHashSource: string; importance?: ImportanceScore },
+  ): Promise<{ tombstoneBlocked?: boolean }>;
+}
+
+export interface ActivityMemoryGenerationDeps {
+  extract(digestBody: string): Promise<ExtractionResult>;
+  judge(candidates: JudgeCandidate[]): Promise<Map<number, JudgeVerdict>>;
+  writer: ActivityMemoryWriter;
+  now?: () => Date;
+}
+
+export interface ActivityMemoryGenerationResult {
+  created: number;
+  /** Earlier pending_review writes promoted to active by a stronger reassessment. */
+  promoted: number;
+  /** Earlier pending_review writes retired by a fresh judge-reject verdict. */
+  demoted: number;
+  pendingReview: number;
+  rejectedDisplayedContent: number;
+  rejectedByJudge: number;
+  skipped: number;
+}
+
+/**
+ * Activity snapshots contain arbitrary third-party text. Only durable claims
+ * explicitly framed as the user's or team's own action, decision, commitment,
+ * preference, or moment may enter the trust gate. A first-person pronoun alone
+ * is not ownership evidence: quoted or attributed third-party speech (e.g.
+ * "Alice wrote: I decided to leave") is rejected.
+ */
+export function isEligibleActivityFact(fact: ExtractionResult["facts"][number]): boolean {
+  if (ACTIVITY_ALLOWED_CATEGORIES[fact.category] !== true) return false;
+  if (!FIRST_PERSON.test(fact.content)) return false;
+  if (VERB_ATTRIBUTION.test(fact.content)) return false;
+  const label = LABEL_ATTRIBUTION.exec(fact.content);
+  if (label !== null) {
+    const labelText = label[1].trim();
+    const firstToken = labelText.split(/\s+/)[0].toLowerCase();
+    if (NON_SENDER_LABELS[firstToken] !== true || LABEL_NAMES_SENDER.test(labelText)) return false;
+  }
+  return true;
+}
+
+/**
+ * Compose an activity envelope in salvage mode (issue #1989 pattern): digest
+ * facts are MACHINE-generated, so one malformed optional field must not abort a
+ * whole day's writes. Dropped fields are warn-logged, never silent.
+ */
+function composeSalvagedActivityEnvelope(
+  input: MemoryWriteInput,
+  ctx: WriteContext,
+): SealedMemoryEnvelope {
+  const envelope = composeMemoryEnvelope(input, ctx, { salvage: true });
+  if (envelope.salvageNotes.length > 0) {
+    log.warn(`activity write salvaged invalid fields: ${envelope.salvageNotes.join("; ")}`);
+  }
+  return envelope;
+}
+
+interface WritableCandidate {
+  fact: ExtractedFact;
+  key: string;
+  status: Extract<MemoryStatus, "active" | "pending_review">;
+  trust: number;
+  trustDecision: string;
+  judgeVerdict?: JudgeVerdictKind;
+  importance: ImportanceScore;
+}
+
+export async function generateActivityMemories(
+  date: string,
+  digestBody: string,
+  config: ActivityConfig,
+  deps: ActivityMemoryGenerationDeps,
+): Promise<ActivityMemoryGenerationResult> {
+  const result: ActivityMemoryGenerationResult = {
+    created: 0,
+    promoted: 0,
+    demoted: 0,
+    pendingReview: 0,
+    rejectedDisplayedContent: 0,
+    rejectedByJudge: 0,
+    skipped: 0,
+  };
+  // `extractionMode` is the independent extraction gate (per the config contract);
+  // `enabled` gates source ingestion, not extraction of a supplied digest.
+  if (config.extractionMode !== "smart" || digestBody.trim().length === 0) return result;
+
+  // Event-time bound: the digest's local day. Backfilled or delayed digests
+  // then land on the day they describe rather than at write time.
+  const { startUtc, endUtc } = activityDayWindow(date, config.timezone);
+
+  let extracted: ExtractionResult;
+  try {
+    extracted = await deps.extract(digestBody);
+  } catch (err) {
+    // A provider/parse failure must not throw out of the pass; return the
+    // structured zero-result so the caller can retry on the next digest run.
+    log.warn(
+      `activity extraction failed; skipping the day's memory pass: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    return result;
+  }
+  if (extracted.extractionFailure !== undefined) {
+    // In-band failure marker (partial/failed provider result): treat like a
+    // thrown extraction — warn and return the structured zero-result.
+    log.warn(
+      `activity extraction reported a failure; skipping the day's memory pass: ${extracted.extractionFailure}`,
+    );
+    return result;
+  }
+  const candidates = extracted.facts.filter((fact) => {
+    if (!isEligibleActivityFact(fact)) {
+      result.rejectedDisplayedContent += 1;
+      return false;
+    }
+    const importance = scoreImportance(fact.content, fact.category, fact.tags);
+    if (
+      !Number.isFinite(fact.confidence) ||
+      fact.confidence < config.minConfidence ||
+      !isAboveImportanceThreshold(importance.level, config.minImportance)
+    ) {
+      result.skipped += 1;
+      return false;
+    }
+    return true;
+  });
+  let verdicts: Map<number, JudgeVerdict>;
+  try {
+    verdicts = await deps.judge(candidates.map((fact) => ({
+      text: fact.content,
+      category: fact.category,
+      confidence: fact.confidence,
+      tags: fact.tags,
+      importanceLevel: scoreImportance(fact.content, fact.category, fact.tags).level,
+    })));
+  } catch (err) {
+    // Degraded smart mode (wearables parity): a judge failure must not abort the
+    // day's writes. Fall back to trust scoring alone (no judge accept boost).
+    log.warn(
+      `activity extraction judge unavailable; using trust scoring only: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    verdicts = new Map();
+  }
+
+  // Score every candidate once, then keep the STRONGEST (highest-trust) copy per
+  // normalized key so a weaker earlier duplicate (e.g. a judge-rejected one)
+  // cannot crowd out a stronger later one. The day is fixed for this digest, so
+  // the normalized content alone keys the in-run set.
+  interface ScoredCandidate {
+    fact: ExtractedFact;
+    key: string;
+    trust: number;
+    verdictKind?: JudgeVerdictKind;
+    decision: SmartDecision;
+    importance: ImportanceScore;
+  }
+  const strongestByKey = new Map<string, ScoredCandidate>();
+  for (let index = 0; index < candidates.length; index += 1) {
+    const fact = candidates[index];
+    const verdict = verdicts.get(index);
+    const verdictKind = verdict === undefined ? undefined : getVerdictKind(verdict);
+    const trust = computeTrustScore({
+      extractionConfidence: fact.confidence,
+      sourceTrust: config.sourceTrust,
+      judgeVerdict: verdictKind,
+      evidence: { corroboratedBySources: [] },
+    });
+    const decision = decideSmart(trust, verdictKind, {
+      autoApproveTrust: config.autoApproveTrust,
+      reviewTrust: config.reviewTrust,
+    });
+    // Dedup key: trim + lowercase so whitespace/case variants collapse (day-scoped).
+    const key = fact.content.trim().toLowerCase();
+    const scored: ScoredCandidate = {
+      fact,
+      key,
+      trust,
+      verdictKind,
+      decision,
+      importance: scoreImportance(fact.content, fact.category, fact.tags),
+    };
+    const prev = strongestByKey.get(key);
+    if (prev === undefined) {
+      strongestByKey.set(key, scored);
+    } else {
+      // In-run duplicate: keep the copy with the more durable decision (active >
+      // review > drop), breaking ties by trust — so a higher-confidence reject
+      // cannot crowd out a lower-trust accepted copy.
+      result.skipped += 1;
+      const rankOf = (outcome: SmartDecision["outcome"]): number =>
+        outcome === "active" ? 2 : outcome === "review" ? 1 : 0;
+      const curRank = rankOf(scored.decision.outcome);
+      const prevRank = rankOf(prev.decision.outcome);
+      if (curRank > prevRank || (curRank === prevRank && trust > prev.trust)) {
+        strongestByKey.set(key, scored);
+      }
+    }
+  }
+
+  const writable: WritableCandidate[] = [];
+  for (const scored of strongestByKey.values()) {
+    const existing = await deps.writer.findActivityMemoryByContent(scored.key, startUtc, endUtc);
+    if (existing !== null) {
+      // Same-day duplicate of a persisted row: reassess in place; never write new
+      // or use a cap slot. (The same text on another day is not found here.)
+      if (existing.status === "pending_review") {
+        if (scored.decision.outcome === "drop" && scored.decision.reason === "judge-rejected") {
+          if (
+            await deps.writer.demoteActivityMemory(existing.id, {
+              trustScore: scored.trust.toFixed(3),
+              trustDecision: "demoted-by-rejection",
+              judgeVerdict: "reject",
+            })
+          ) {
+            result.demoted += 1;
+            continue;
+          }
+        } else if (scored.decision.outcome === "active") {
+          if (
+            await deps.writer.promoteActivityMemory(
+              existing.id,
+              {
+                trustScore: scored.trust.toFixed(3),
+                trustDecision: "promoted-by-reassessment",
+                ...(scored.verdictKind !== undefined ? { judgeVerdict: scored.verdictKind } : {}),
+              },
+              scored.trust,
+            )
+          ) {
+            result.promoted += 1;
+            continue;
+          }
+        }
+      }
+      result.skipped += 1;
+      continue;
+    }
+    if (scored.decision.outcome === "drop") {
+      if (scored.decision.reason === "judge-rejected") result.rejectedByJudge += 1;
+      else result.skipped += 1;
+      continue;
+    }
+    writable.push({
+      fact: scored.fact,
+      key: scored.key,
+      status: scored.decision.outcome === "active" ? "active" : "pending_review",
+      trust: scored.trust,
+      trustDecision: scored.decision.reason,
+      ...(scored.verdictKind !== undefined ? { judgeVerdict: scored.verdictKind } : {}),
+      importance: scored.importance,
+    });
+  }
+  writable.sort((a, b) => {
+    if (a.trust !== b.trust) return b.trust - a.trust;
+    return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+  });
+
+  // Seed the cap from memories already persisted for this day so repeated digest
+  // runs cannot each write up to the limit. `0` stays uncapped.
+  const alreadyWritten =
+    config.maxMemoriesPerDay > 0 ? await deps.writer.countActivityMemoriesForDay(startUtc, endUtc) : 0;
+  let remaining =
+    config.maxMemoriesPerDay > 0
+      ? Math.max(0, config.maxMemoriesPerDay - alreadyWritten)
+      : Number.POSITIVE_INFINITY;
+
+  for (const entry of writable) {
+    if (remaining <= 0) {
+      result.skipped += 1;
+      continue;
+    }
+    // Trust fields FIRST so the salvage-mode 64-entry cap can never trim these
+    // load-bearing keys; extractor attributes ride along after and never override
+    // them (collisions are compared against the canonical lowercase form).
+    const structuredAttributes: Record<string, string> = {
+      trustScore: entry.trust.toFixed(3),
+      trustDecision: entry.trustDecision,
+      ...(entry.judgeVerdict !== undefined ? { judgeVerdict: entry.judgeVerdict } : {}),
+    };
+    for (const [key, value] of Object.entries(entry.fact.structuredAttributes ?? {})) {
+      if (TRUST_ATTRIBUTE_KEYS[key.trim().toLowerCase()] !== true) structuredAttributes[key] = value;
+    }
+    const envelope = composeSalvagedActivityEnvelope(
+      {
+        content: entry.fact.content,
+        category: entry.fact.category,
+        tags: [...entry.fact.tags, "activity"],
+        entityRef: entry.fact.entityRef,
+        // Persist the decision-derived trust as confidence; extractor attributes
+        // ride along, with trust score/decision + judge verdict added last so
+        // downstream sees the active/pending rationale (wearable-path parity).
+        confidence: entry.trust,
+        validAt: startUtc,
+        structuredAttributes,
+        sourceConnector: "activity",
+        sourceReason: "screen activity digest",
+      },
+      { source: "activity", now: deps.now },
+    );
+    const write = await deps.writer.writeSealedMemory(envelope, {
+      status: entry.status,
+      contentHashSource: entry.key,
+      importance: entry.importance,
+    });
+    if (write.tombstoneBlocked) {
+      result.skipped += 1;
+      continue;
+    }
+    if (entry.status === "active") result.created += 1;
+    else result.pendingReview += 1;
+    remaining -= 1;
+  }
+  return result;
+}

package/src/activity/runner.test.ts

@@ -8,6 +8,7 @@ import { activityDatabasePath, ActivityStore } from "./store.js";
 import { activityDigestPath } from "./digest.js";
 import { runActivitySyncOnce } from "./runner.js";
 import { activityCursorKey } from "./pipeline.js";
+import { defaultActivityConfig } from "./config.js";
 import type {
   ActivityConfig,
   ActivitySnapshot,
@@ -55,6 +56,7 @@ function fixtureClient(
 
 function enabledConfig(overrides: Partial<ActivityConfig> = {}): ActivityConfig {
   return {
+    ...defaultActivityConfig(),
     enabled: true,
     timezone: "UTC",
     syncDays: 1,
@@ -70,6 +72,7 @@ test("disabled config makes no client, no HTTP call, and no store write", async
     let clientBuilt = false;
     const summary = await runActivitySyncOnce({
       config: {
+        ...defaultActivityConfig(),
         enabled: false,
         timezone: "UTC",
         syncDays: 1,

package/src/activity/scheduler.test.ts

@@ -8,6 +8,7 @@ import { ACTIVITY_SYNC_DEFAULT_INTERVAL_MS, ActivitySyncScheduler } from "./sche
 import { runActivitySyncOnce, type ActivitySyncRunSummary } from "./runner.js";
 import { ActivityStore } from "./store.js";
 import { activityCursorKey } from "./pipeline.js";
+import { defaultActivityConfig } from "./config.js";
 import type { ActivityConfig, ActivitySnapshot, ActivitySourceClient } from "./types.js";
 
 /** A hand-driven timer: records armed callbacks + intervals, fires on demand. */
@@ -53,6 +54,7 @@ const SUMMARY: ActivitySyncRunSummary = {
 
 function enabledConfig(): ActivityConfig {
   return {
+    ...defaultActivityConfig(),
     enabled: true,
     timezone: "UTC",
     syncDays: 1,
@@ -63,6 +65,7 @@ function enabledConfig(): ActivityConfig {
 
 function disabledConfig(): ActivityConfig {
   return {
+    ...defaultActivityConfig(),
     enabled: false,
     timezone: "UTC",
     syncDays: 1,

package/src/activity/sync-registration.test.ts

@@ -8,6 +8,7 @@ import {
   type ActivitySyncRegistrarDeps,
   type ActivitySyncSchedulerLike,
 } from "./sync-registration.js";
+import { defaultActivityConfig } from "./config.js";
 
 class FakeScheduler implements ActivitySyncSchedulerLike {
   starts = 0;
@@ -33,7 +34,7 @@ function makeDeps(overrides: Partial<ActivitySyncRegistrarDeps> = {}): {
   const created: FakeScheduler[] = [];
   const state = { retries: 0 };
   const deps: ActivitySyncRegistrarDeps = {
-    config: { enabled: true, timezone: "UTC", syncDays: 1, autoSyncIntervalMinutes: 15, sources: [] },
+    config: { ...defaultActivityConfig(), enabled: true, sources: [] },
     memoryDir: "/tmp/remnic-activity-registrar",
     qmdCollection: "openclaw-engram",
     secureStoreEnabled: false,

package/src/activity/types.ts

@@ -11,6 +11,10 @@
  * All timestamps are UTC ISO-8601; day bucketing is half-open [start, end).
  */
 
+import type { ImportanceLevel } from "../types.js";
+
+export type ActivityExtractionMode = "off" | "smart";
+
 /** One captured on-screen text snapshot (a single window at a single instant). */
 export interface ActivitySnapshot {
   /** Store row id (assigned on insert; absent before persistence). */
@@ -92,7 +96,7 @@ export interface ActivitySourceConfig {
   token?: string;
 }
 
-/** Opt-in activity synchronization settings. */
+/** Opt-in activity synchronization + trust-gated extraction settings. */
 export interface ActivityConfig {
   enabled: boolean;
   timezone: string;
@@ -100,4 +104,14 @@ export interface ActivityConfig {
   /** Periodic auto-sync cadence in minutes (default 15). */
   autoSyncIntervalMinutes: number;
   sources: ActivitySourceConfig[];
+  /** `off` keeps activity searchable only; `smart` trust-gates durable first-person claims. */
+  extractionMode: ActivityExtractionMode;
+  /** Baseline confidence in activity as a source of the user's own actions. */
+  sourceTrust: number;
+  autoApproveTrust: number;
+  reviewTrust: number;
+  minConfidence: number;
+  minImportance: ImportanceLevel;
+  /** `0` means no count cap. */
+  maxMemoriesPerDay: number;
 }

package/src/config.test.ts

@@ -2365,5 +2365,12 @@ test("parseConfig forwards activity source settings", () => {
     syncDays: 2,
     autoSyncIntervalMinutes: 15,
     sources: [{ machineLabel: "fixture-machine", baseUrl: "http://127.0.0.1:4319" }],
+    extractionMode: "off",
+    sourceTrust: 0.6,
+    autoApproveTrust: 0.8,
+    reviewTrust: 0.5,
+    minConfidence: 0.7,
+    minImportance: "normal",
+    maxMemoriesPerDay: 0,
   });
 });

package/src/offline-sync-impression-drain.test.ts

@@ -8,7 +8,9 @@ import {
   drainPendingImpressionsForOfflineSync,
   drainPendingLifecycleForOfflineSync,
   getOfflineSyncStorage,
+  listOfflineSyncNamespaces,
 } from "./offline-sync-impression-drain.js";
+import { namespaceIdentityToken } from "./namespaces/identity.js";
 import { isEncryptedFile } from "./secure-store/secure-fs.js";
 import { StorageManager } from "./storage.js";
 
@@ -314,3 +316,55 @@ test("getOfflineSyncStorage never double-folds the root ledger when it is listed
 
   assert.deepEqual(lifecycleDrains, ["root", "team"], "root ledger is folded exactly once");
 });
+
+test("listOfflineSyncNamespaces decodes canonical token dirs and skips names the router would reject", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-offline-ns-enum-"));
+  try {
+    // A project namespace whose canonical token dir `ns-<hex>` exceeds the
+    // 64-char route-namespace cap: `getStorage` on the RAW basename throws
+    // `unsafe namespace` and 500s the whole root snapshot-stream (the regression).
+    const longName = "generalist-project-origin-6d1ad1f2";
+    const longToken = namespaceIdentityToken(longName); // ns-<hex>, 71 chars
+    assert.ok(longToken.length > 64, "token dir must exceed the route-namespace cap");
+    // A namespace whose DECODED name itself exceeds the 64-char route cap:
+    // decoding succeeds but isSafeRouteNamespace must still reject it.
+    const overCapName = `generalist-project-tag-${"x".repeat(60)}`;
+    const overCapToken = namespaceIdentityToken(overCapName);
+    assert.ok(overCapName.length > 64, "decoded name must exceed the route cap");
+    for (const dir of [longToken, overCapToken, "blend", "ns-default"]) {
+      await mkdir(path.join(root, "namespaces", dir, "state"), { recursive: true });
+      await writeFile(
+        path.join(root, "namespaces", dir, LIFECYCLE_LEDGER_REL),
+        "",
+        "utf-8",
+      );
+    }
+    const host = {
+      config: {
+        memoryDir: root,
+        defaultNamespace: "generalist",
+        sharedNamespace: "shared",
+        namespacePolicies: [],
+      },
+      namespaceCatalog: { listNamespaces: async () => [] },
+    } as unknown as Parameters<typeof listOfflineSyncNamespaces>[0];
+
+    const names = new Set(await listOfflineSyncNamespaces(host));
+
+    // The canonical token dir is decoded back to its namespace NAME...
+    assert.ok(names.has(longName), "canonical token dir must be decoded to its namespace name");
+    // ...never surfaced as the raw >64-char token that getStorage would reject.
+    assert.ok(!names.has(longToken), "raw over-cap token must never be enumerated as a namespace");
+    // A decoded name that is ITSELF over the route cap is skipped entirely
+    // (the isSafeRouteNamespace rejection branch).
+    assert.ok(!names.has(overCapName), "over-cap decoded name must be skipped");
+    assert.ok(!names.has(overCapToken), "over-cap raw token must be skipped");
+    // A raw plain-named dir is used verbatim.
+    assert.ok(names.has("blend"), "plain namespace dir must be enumerated verbatim");
+    // The literal ns-default token decodes to the EMPTY default identity and
+    // must map to the configured default namespace, not be skipped as "".
+    assert.ok(names.has("generalist"), "ns-default dir maps to the configured default namespace");
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});

package/src/offline-sync-impression-drain.ts

@@ -12,6 +12,8 @@ import { isErrnoCode } from "./utils/errno.js";
 import { assertPathInsideRoot, pathIsInside } from "./utils/path-containment.js";
 import { displayErrorDetail } from "./runtime/better-sqlite.js";
 import { getConfiguredNamespaces } from "./scopes/scope-plan.js";
+import { isSafeRouteNamespace } from "./routing/engine.js";
+import { namespaceIdentityFromToken } from "./namespaces/identity.js";
 import type { PluginConfig } from "./types.js";
 
 type PendingImpressionDrain = () => Promise<{ pendingDeferred: boolean }>;
@@ -89,7 +91,17 @@ export async function getOfflineSyncStorage<T extends PendingLifecycleDrain & {
   if (path.resolve(storage.dir) === memoryRoot && orchestrator.listOfflineSyncNamespaces) {
     const drained = new Set<string>([memoryRoot]);
     for (const ns of await orchestrator.listOfflineSyncNamespaces()) {
-      const nsStorage = await orchestrator.getStorage(ns);
+      // A single unresolvable namespace (e.g. a legacy canonical token dir whose
+      // name exceeds the route-namespace length cap) must not abort the whole root
+      // snapshot — degrade to draining the rest. listOfflineSyncNamespaces already
+      // normalizes token dirs, so this is defense-in-depth.
+      let nsStorage: T;
+      try {
+        nsStorage = await orchestrator.getStorage(ns);
+      } catch (err) {
+        log.debug(`offline-sync root drain: skipping namespace ${ns} (non-fatal): ${err}`);
+        continue;
+      }
       const nsDir = path.resolve(nsStorage.dir);
       if (drained.has(nsDir)) continue;
       drained.add(nsDir);
@@ -114,8 +126,28 @@ export async function listOfflineSyncNamespaces(host: OfflineSyncNamespaceHost):
   try {
     for (const ledgerPath of await offlineSyncLifecycleLedgerPaths(host.config.memoryDir)) {
       const namespaceDir = path.dirname(path.dirname(ledgerPath));
-      if (path.basename(path.dirname(namespaceDir)) === "namespaces") {
-        names.add(path.basename(namespaceDir));
+      if (path.basename(path.dirname(namespaceDir)) !== "namespaces") continue;
+      // A namespace is stored under its canonical token dir `ns-<hex>`. Decode the
+      // token back to the namespace NAME so the drain fanout resolves the SAME
+      // storage the token dir belongs to (the catalog rebuild scanner decodes the
+      // same way, catalog.ts finishRebuild). A raw dir already named as a plain
+      // namespace is used verbatim. Skip any name the router would reject — e.g. a
+      // canonical token dir whose decoded-or-raw name exceeds isSafeRouteNamespace's
+      // 64-char cap — because getStorage() would throw `unsafe namespace` and 500
+      // the whole root snapshot-stream (the offline-sync regression this fixes).
+      const dirName = path.basename(namespaceDir);
+      // namespaceIdentityFromToken returns "" for the ns-default token (the
+      // default-namespace identity) — map that to the configured default
+      // namespace instead of skipping the directory as an unsafe empty name.
+      const decoded = namespaceIdentityFromToken(dirName);
+      const name =
+        decoded === null
+          ? dirName
+          : decoded.length > 0
+            ? decoded
+            : host.config.defaultNamespace;
+      if (isSafeRouteNamespace(name)) {
+        names.add(name);
       }
     }
   } catch {