@anuma/sdk 6.25.1 → 6.25.3

package/dist/server/index.mjs

@@ -15457,7 +15457,7 @@ __decorateClass([
 ], VaultFolder.prototype, "context", 2);
 
 // src/lib/db/schema.ts
-var SDK_SCHEMA_VERSION = 46;
+var SDK_SCHEMA_VERSION = 47;
 var sdkSchema = (0, import_watermelondb13.appSchema)({
   version: SDK_SCHEMA_VERSION,
   tables: [
@@ -15473,7 +15473,11 @@ var sdkSchema = (0, import_watermelondb13.appSchema)({
         // source. `watermark` alone is an id, and deleting that message erased
         // the anchor — see the column note in extractionJobs/models.ts.
         { name: "watermark_seq", type: "number", isOptional: true },
-        { name: "folder_id", type: "string", isOptional: true }
+        { name: "folder_id", type: "string", isOptional: true },
+        // Poison accounting for the head batch; see extractionJobs/models.ts.
+        { name: "failed_sessions", type: "number", isOptional: true },
+        { name: "failed_head", type: "string", isOptional: true },
+        { name: "failed_at", type: "number", isOptional: true }
       ]
     }),
     // Chat storage tables
@@ -16497,6 +16501,22 @@ var sdkMigrations = (0, import_migrations.schemaMigrations)({
           ]
         })
       ]
+    },
+    // v46 -> v47: persisted poison count (and when it was last counted) for a
+    // durable-extraction job's head batch. NULL = never failed, which is right
+    // for every existing row.
+    {
+      toVersion: 47,
+      steps: [
+        (0, import_migrations.addColumns)({
+          table: "memory_extraction_jobs",
+          columns: [
+            { name: "failed_sessions", type: "number", isOptional: true },
+            { name: "failed_head", type: "string", isOptional: true },
+            { name: "failed_at", type: "number", isOptional: true }
+          ]
+        })
+      ]
     }
   ]
 });
@@ -20382,8 +20402,42 @@ async function vaultMemoryToStored(memory, walletAddress, signMessage, embeddedW
   }
   return raw;
 }
+function populateNewVaultMemory(record, ctx, opts, encryptedContent) {
+  record._setRaw("content", encryptedContent);
+  record._setRaw("scope", opts.scope ?? "private");
+  record._setRaw("folder_id", opts.folderId ?? null);
+  record._setRaw("user_id", ctx.userId ?? null);
+  record._setRaw("is_deleted", false);
+  if (opts.embedding !== void 0) {
+    record._setRaw("embedding", opts.embedding);
+    record._setRaw("embedding_model", opts.embeddingModel ?? null);
+  }
+  if (opts.sourceChunkIds !== void 0) {
+    record._setRaw("source_chunk_ids", JSON.stringify(opts.sourceChunkIds));
+  }
+  record._setRaw("proof_count", opts.proofCount ?? 1);
+  record._setRaw("source", opts.source ?? "manual");
+  if (opts.eventTime) {
+    record._setRaw("event_time_start", opts.eventTime.start ?? null);
+    record._setRaw("event_time_end", opts.eventTime.end ?? null);
+    record._setRaw("event_time_kind", opts.eventTime.kind ?? null);
+  }
+  if (opts.factType !== void 0) {
+    record._setRaw("fact_type", opts.factType);
+  }
+  if (opts.trustTier !== void 0) {
+    record._setRaw("trust_tier", normalizeTrustTier(opts.trustTier));
+  }
+  record._setRaw("visibility", opts.visibility ?? "private");
+  record._setRaw(
+    "published_at",
+    opts.visibility && opts.visibility !== "private" ? opts.publishedAt ?? Date.now() : null
+  );
+  if (opts.geohash !== void 0) {
+    record._setRaw("geohash", opts.geohash);
+  }
+}
 async function createVaultMemoryOp(ctx, opts) {
-  const scope = opts.scope ?? "private";
   const encryptedContent = ctx.walletAddress && ctx.signMessage ? await encryptVaultMemoryContent(
     opts.content,
     ctx.walletAddress,
@@ -20393,47 +20447,14 @@ async function createVaultMemoryOp(ctx, opts) {
   const created = await ctx.database.write(async () => {
     if (ctx.canWrite && !await ctx.canWrite())
       throw new Error("Memory source is no longer eligible");
-    return ctx.vaultMemoryCollection.create((record) => {
-      record._setRaw("content", encryptedContent);
-      record._setRaw("scope", scope);
-      record._setRaw("folder_id", opts.folderId ?? null);
-      record._setRaw("user_id", ctx.userId ?? null);
-      record._setRaw("is_deleted", false);
-      if (opts.embedding !== void 0) {
-        record._setRaw("embedding", opts.embedding);
-        record._setRaw("embedding_model", opts.embeddingModel ?? null);
-      }
-      if (opts.sourceChunkIds !== void 0) {
-        record._setRaw("source_chunk_ids", JSON.stringify(opts.sourceChunkIds));
-      }
-      record._setRaw("proof_count", opts.proofCount ?? 1);
-      record._setRaw("source", opts.source ?? "manual");
-      if (opts.eventTime) {
-        record._setRaw("event_time_start", opts.eventTime.start ?? null);
-        record._setRaw("event_time_end", opts.eventTime.end ?? null);
-        record._setRaw("event_time_kind", opts.eventTime.kind ?? null);
-      }
-      if (opts.factType !== void 0) {
-        record._setRaw("fact_type", opts.factType);
-      }
-      if (opts.trustTier !== void 0) {
-        record._setRaw("trust_tier", normalizeTrustTier(opts.trustTier));
-      }
-      record._setRaw("visibility", opts.visibility ?? "private");
-      record._setRaw(
-        "published_at",
-        opts.visibility && opts.visibility !== "private" ? opts.publishedAt ?? Date.now() : null
-      );
-      if (opts.geohash !== void 0) {
-        record._setRaw("geohash", opts.geohash);
-      }
-    });
+    return ctx.vaultMemoryCollection.create(
+      (record) => populateNewVaultMemory(record, ctx, opts, encryptedContent)
+    );
   });
   return vaultMemoryToStored(created, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
 }
 async function createSupersedingMemoryOp(ctx, opts, targetId) {
   if (!targetId) return { created: null, retired: false };
-  const scope = opts.scope ?? "private";
   const encryptedContent = ctx.walletAddress && ctx.signMessage ? await encryptVaultMemoryContent(
     opts.content,
     ctx.walletAddress,
@@ -20451,27 +20472,9 @@ async function createSupersedingMemoryOp(ctx, opts, targetId) {
       return;
     }
     if (target.isDeleted || target.supersededBy || !isOwnedByCtxUser(ctx, target)) return;
-    createdRecord = await ctx.vaultMemoryCollection.create((record) => {
-      record._setRaw("content", encryptedContent);
-      record._setRaw("scope", scope);
-      record._setRaw("folder_id", opts.folderId ?? null);
-      record._setRaw("user_id", ctx.userId ?? null);
-      record._setRaw("is_deleted", false);
-      if (opts.embedding !== void 0) {
-        record._setRaw("embedding", opts.embedding);
-        record._setRaw("embedding_model", opts.embeddingModel ?? null);
-      }
-      if (opts.sourceChunkIds !== void 0) {
-        record._setRaw("source_chunk_ids", JSON.stringify(opts.sourceChunkIds));
-      }
-      record._setRaw("proof_count", opts.proofCount ?? 1);
-      record._setRaw("source", opts.source ?? "manual");
-      if (opts.eventTime) {
-        record._setRaw("event_time_start", opts.eventTime.start ?? null);
-        record._setRaw("event_time_end", opts.eventTime.end ?? null);
-        record._setRaw("event_time_kind", opts.eventTime.kind ?? null);
-      }
-    });
+    createdRecord = await ctx.vaultMemoryCollection.create(
+      (record) => populateNewVaultMemory(record, ctx, opts, encryptedContent)
+    );
     await target.update((r) => {
       r._setRaw("superseded_by", createdRecord.id);
       r._setRaw("superseded_at", Date.now());
@@ -20551,41 +20554,9 @@ async function createVaultMemoriesBatchOp(ctx, optionsArray) {
     if (ctx.canWrite && !await ctx.canWrite())
       throw new Error("Memory source is no longer eligible");
     const prepared = optionsArray.map(
-      (opts, i) => ctx.vaultMemoryCollection.prepareCreate((record) => {
-        record._setRaw("content", encryptedContents[i]);
-        record._setRaw("scope", opts.scope ?? "private");
-        record._setRaw("folder_id", opts.folderId ?? null);
-        record._setRaw("user_id", ctx.userId ?? null);
-        record._setRaw("is_deleted", false);
-        if (optionsArray[i].embedding !== void 0) {
-          record._setRaw("embedding", optionsArray[i].embedding);
-          record._setRaw("embedding_model", optionsArray[i].embeddingModel ?? null);
-        }
-        if (opts.sourceChunkIds !== void 0) {
-          record._setRaw("source_chunk_ids", JSON.stringify(opts.sourceChunkIds));
-        }
-        record._setRaw("proof_count", opts.proofCount ?? 1);
-        record._setRaw("source", opts.source ?? "manual");
-        if (opts.eventTime) {
-          record._setRaw("event_time_start", opts.eventTime.start ?? null);
-          record._setRaw("event_time_end", opts.eventTime.end ?? null);
-          record._setRaw("event_time_kind", opts.eventTime.kind ?? null);
-        }
-        if (opts.factType !== void 0) {
-          record._setRaw("fact_type", opts.factType);
-        }
-        if (opts.trustTier !== void 0) {
-          record._setRaw("trust_tier", normalizeTrustTier(opts.trustTier));
-        }
-        record._setRaw("visibility", opts.visibility ?? "private");
-        record._setRaw(
-          "published_at",
-          opts.visibility && opts.visibility !== "private" ? opts.publishedAt ?? Date.now() : null
-        );
-        if (opts.geohash !== void 0) {
-          record._setRaw("geohash", opts.geohash);
-        }
-      })
+      (opts, i) => ctx.vaultMemoryCollection.prepareCreate(
+        (record) => populateNewVaultMemory(record, ctx, opts, encryptedContents[i])
+      )
     );
     await ctx.database.batch(...prepared);
     return prepared;
@@ -21379,21 +21350,73 @@ async function hardDeleteDecayedOp(ctx, id, opts) {
     return false;
   }
 }
-async function updateVaultMemoryEmbeddingOp(ctx, id, embedding, embeddingModel) {
+async function updateVaultMemoryEmbeddingOp(ctx, id, embedding, embeddingModel, expected) {
   try {
     const record = await ctx.vaultMemoryCollection.find(id);
     if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) return false;
+    const readUpdatedAt = record.updatedAt.getTime();
+    const readStoredContent = record._getRaw("content");
+    if (expected?.updatedAt !== void 0 && expected.updatedAt !== readUpdatedAt) return false;
+    if (expected?.content !== void 0) {
+      const current = await vaultMemoryToStored(
+        record,
+        ctx.walletAddress,
+        ctx.signMessage,
+        ctx.embeddedWalletSigner
+      );
+      if (current.content !== expected.content) return false;
+    }
+    let written = false;
     await ctx.database.write(async () => {
+      if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) return;
+      const originalUpdatedAt = record.updatedAt.getTime();
+      if (originalUpdatedAt !== readUpdatedAt || record._getRaw("content") !== readStoredContent)
+        return;
       await record.update((r) => {
         r._setRaw("embedding", embedding);
         r._setRaw("embedding_model", embeddingModel);
+        r._setRaw("updated_at", originalUpdatedAt);
       });
+      written = true;
     });
-    return true;
+    return written;
   } catch {
     return false;
   }
 }
+function normalizeForDedupe(content) {
+  return content.normalize("NFKC").trim().replace(/\s+/g, " ").toLowerCase();
+}
+async function findQuarantinedDuplicateOp(ctx, content, sourceIds, where) {
+  const wanted = [...new Set(sourceIds)].sort().join("\0");
+  const target = normalizeForDedupe(content);
+  const rows = await ctx.vaultMemoryCollection.query(
+    import_watermelondb18.Q.where("trust_tier", "quarantined"),
+    import_watermelondb18.Q.where("is_deleted", false),
+    import_watermelondb18.Q.where("scope", where.scope),
+    import_watermelondb18.Q.where("folder_id", where.folderId),
+    ...ctx.userId !== void 0 ? [import_watermelondb18.Q.where("user_id", ctx.userId)] : []
+  ).unsafeFetchRaw();
+  for (const raw of rows) {
+    let ids;
+    try {
+      ids = JSON.parse(raw.source_chunk_ids ?? "[]");
+    } catch {
+      continue;
+    }
+    if (!Array.isArray(ids)) continue;
+    const key = [...new Set(ids.filter((id) => typeof id === "string"))].sort().join("\0");
+    if (key !== wanted) continue;
+    const stored = await vaultMemoryRawToStored(
+      raw,
+      ctx.walletAddress,
+      ctx.signMessage,
+      ctx.embeddedWalletSigner
+    );
+    if (normalizeForDedupe(stored.content) === target) return stored.uniqueId;
+  }
+  return null;
+}
 
 // src/lib/memory/decay.ts
 var DAY_MS = 24 * 60 * 60 * 1e3;
@@ -21417,6 +21440,10 @@ var DEFAULT_DECAY_POLICY = {
   hardDeleteWindowMs: HARD_DELETE_WINDOW_MS,
   pastEventGraceMs: PAST_EVENT_GRACE_MS
 };
+function lastActivityAt(m) {
+  const observedAt = Number.isFinite(m.lastObservedAt) ? m.lastObservedAt : m.updatedAt;
+  return Math.max(m.updatedAt, observedAt);
+}
 function resolvePolicy(policy) {
   if (!policy) return DEFAULT_DECAY_POLICY;
   return {
@@ -21456,8 +21483,7 @@ function classifyDecay(m, now, policy) {
     if (m.eventTimeEnd < now - resolved.pastEventGraceMs) return "archive";
     if (m.eventTimeEnd >= now) return "keep";
   }
-  const observedAt = Number.isFinite(m.lastObservedAt) ? m.lastObservedAt : m.updatedAt;
-  if (now - Math.max(m.updatedAt, observedAt) > ttlForType(m.factType, resolved)) return "archive";
+  if (now - lastActivityAt(m) > ttlForType(m.factType, resolved)) return "archive";
   return "keep";
 }
 
@@ -26996,6 +27022,9 @@ var MANUAL_FACT_TYPES = [
 function normalizeManualFactType(value) {
   return typeof value === "string" && MANUAL_FACT_TYPES.includes(value) ? value : void 0;
 }
+function isSharedScope(scope) {
+  return scope === "shared";
+}
 async function notifyWritten(options, input, outcome) {
   try {
     await options?.onWritten?.({ input, outcome });
@@ -27064,14 +27093,17 @@ function createMemoryVaultTool(vaultCtx, options, embeddingOptions, cache) {
       try {
         const isUpdate = !!id;
         let previousContent;
+        const scope = options?.scope ?? "private";
         if (isUpdate) {
           const existing = await getVaultMemoryOp(vaultCtx, id);
           if (!existing) {
             return `Error: Memory with ID "${id}" not found. Creating a new memory instead would require a separate call without an ID.`;
           }
+          if (isSharedScope(existing.scope) !== isSharedScope(scope)) {
+            return `Error: Memory "${id}" belongs to a different scope than this conversation and cannot be updated from here. It was not modified. To record this fact, save it as a new memory without an ID.`;
+          }
           previousContent = existing.content;
         }
-        const scope = options?.scope ?? "private";
         const operation = {
           action: isUpdate ? "update" : "add",
           content,
@@ -28271,6 +28303,24 @@ async function extractAndRetain(messages, retainCtx, options) {
   const tRetain = Date.now();
   for (const { candidate, isQuarantined, reason, signature } of toRetain) {
     try {
+      if (isQuarantined) {
+        const existingId = await findQuarantinedDuplicateOp(
+          retainCtx.vaultCtx,
+          candidate.content,
+          candidate.sourceMessageIds,
+          // The same defaults retain() writes the row with.
+          { scope: options.scope ?? "private", folderId: options.folderId ?? null }
+        ).catch(() => null);
+        if (existingId) {
+          quarantinedInfo.push({
+            candidate,
+            memoryId: existingId,
+            reason,
+            signature
+          });
+          continue;
+        }
+      }
       const result = await retain(candidate.content, retainCtx, {
         source: "auto-extracted",
         sourceChunkIds: candidate.sourceMessageIds,
@@ -28716,7 +28766,7 @@ function createLlmDecayClassifier(options) {
       if (!content || content.trim().length === 0) return ruleVerdict;
       const trimmed = content.trim().slice(0, MAX_CONTENT_CHARS);
       const safe = redactor ? (await redactor.redactTextAsync(trimmed)).text : trimmed;
-      const meta = `factType: ${input.factType ?? "none"}; ageDays: ${ageDays(input.updatedAt, now)}`;
+      const meta = `factType: ${input.factType ?? "none"}; ageDays: ${ageDays(lastActivityAt(input), now)}`;
       let parsed;
       try {
         parsed = await callPortalJsonCompletion({
@@ -28749,9 +28799,9 @@ Should this be kept or archived?`,
     }
   };
 }
-function ageDays(updatedAt, now) {
-  if (!Number.isFinite(updatedAt) || !Number.isFinite(now)) return 0;
-  return Math.max(0, Math.floor((now - updatedAt) / (24 * 60 * 60 * 1e3)));
+function ageDays(activityAt, now) {
+  if (!Number.isFinite(activityAt) || !Number.isFinite(now)) return 0;
+  return Math.max(0, Math.floor((now - activityAt) / (24 * 60 * 60 * 1e3)));
 }
 function parseVerdict(parsed) {
   if (typeof parsed !== "object" || parsed === null) return null;
@@ -28804,7 +28854,7 @@ function createDecaySweeper(options) {
     if (!classifier || !isBorderline(input)) return ruleVerdict;
     if (input.id) {
       const cached = classifierCache.get(input.id);
-      if (cached && cached.updatedAt === input.updatedAt) return cached.verdict;
+      if (cached && cached.activityAt === lastActivityAt(input)) return cached.verdict;
     }
     if (sweep.classifierCalls >= maxClassifierCalls) {
       if (!sweep.ceilingLogged) {
@@ -28818,7 +28868,7 @@ function createDecaySweeper(options) {
     sweep.classifierCalls++;
     try {
       const verdict = await classifier.classify(input, ruleVerdict, now);
-      if (input.id) classifierCache.set(input.id, { updatedAt: input.updatedAt, verdict });
+      if (input.id) classifierCache.set(input.id, { activityAt: lastActivityAt(input), verdict });
       return verdict;
     } catch (err) {
       getLogger().warn(
@@ -29560,7 +29610,10 @@ function reviewedMemoryIdsSignature(ids) {
   return [...new Set(ids)].sort().join("\n");
 }
 function facetsSignature(facets) {
-  return facets.map((f) => JSON.stringify([f.key, f.label, f.query, f.guidance, facetResponseSchema(f.key)])).sort().join("\n");
+  return [
+    JSON.stringify(FACET_SYSTEM_PROMPT),
+    ...facets.map((f) => JSON.stringify([f.key, f.label, f.query, f.guidance, facetResponseSchema(f.key)])).sort()
+  ].join("\n");
 }
 function trendsEqual(a, b) {
   if (!a) return false;
@@ -29782,7 +29835,7 @@ var FACET_SYSTEM_PROMPT = `You are writing one section of a person's shareable p
 Rules:
 - Ground every claim in the supplied memories \u2014 never invent, infer beyond, or embellish what they support.
 - If the memories don't cover this section, return an empty summary with hasEvidence=false. Do not pad or guess.
-- Write in third person about the person, in a natural voice suitable for a public profile (no "I"/"you", no name repetition).
+- Write in a pronoun-free profile voice: lead with the descriptor or the verb ("Thoughtful, detail-oriented builder. Values clear communication."). Never use "they"/"he"/"she", "I", "you", or the person's name \u2014 the person publishes this as their own profile, and strangers read it there.
 - Be concise and specific; no preamble, hedging, or meta-commentary.
 - Respond as JSON in exactly the shape the user turn states, with no extra fields.`;
 function buildFacetUserInstructions(facet) {
@@ -30451,6 +30504,37 @@ async function assembleMemoryContext(options) {
 var import_watermelondb24 = __toESM(require_watermelondb());
 var MAX_JOBS_PER_PASS = 3;
 var MAX_ATTEMPTS = 3;
+var MAX_FAILED_SESSIONS = 3;
+var MIN_FAILED_SESSION_GAP_MS = 60 * 60 * 1e3;
+var REQUEST_REJECTED_STATUSES = /* @__PURE__ */ new Set([400, 404, 413, 422]);
+var CONTENT_FAILURE_REASONS = /* @__PURE__ */ new Set([
+  "empty-content",
+  "invalid-json",
+  "null-completion",
+  "body-parse-failed"
+]);
+var BACKOFF_ALLOWANCE_MS = 2100;
+var RETAIN_BUDGET_MS = 12e4;
+function defaultBatchTimeoutMs(extract) {
+  const attempts = Math.max(1, extract.maxAttempts ?? 3);
+  const calls = (extract.timeoutMs ?? 6e4) * attempts + BACKOFF_ALLOWANCE_MS * (attempts - 1);
+  const extraction = extract.totalTimeoutMs !== void 0 ? Math.min(extract.totalTimeoutMs, calls) : calls;
+  return extraction + RETAIN_BUDGET_MS;
+}
+var BatchFailureError = class extends Error {
+  constructor(message, terminal) {
+    super(message);
+    this.terminal = terminal;
+  }
+};
+var AccountFailureError = class extends Error {
+};
+var LockedSourcesError = class extends Error {
+  constructor(persistentIds) {
+    super("Source messages are locked; retained for retry");
+    this.persistentIds = persistentIds;
+  }
+};
 function idsOf(job) {
   return JSON.parse(String(job._getRaw("message_ids")));
 }
@@ -30458,6 +30542,16 @@ function seqOf(job) {
   const raw = job._getRaw("watermark_seq");
   return typeof raw === "number" && raw > 0 ? raw : void 0;
 }
+function failedSessionsOf(job, head) {
+  if (job._getRaw("failed_head") !== head) return 0;
+  const raw = job._getRaw("failed_sessions");
+  return typeof raw === "number" && raw > 0 ? raw : 0;
+}
+function failedAtOf(job, head) {
+  if (job._getRaw("failed_head") !== head) return void 0;
+  const raw = job._getRaw("failed_at");
+  return typeof raw === "number" ? raw : void 0;
+}
 function createDurableAutoExtractor(options) {
   const vault = options.retainCtx.vaultCtx;
   const database = vault.database;
@@ -30480,6 +30574,9 @@ function createDurableAutoExtractor(options) {
   let writes = Promise.resolve();
   let storeFailures = 0;
   const attempts = /* @__PURE__ */ new Map();
+  const sessionFailures = /* @__PURE__ */ new Map();
+  const skippedThisSession = /* @__PURE__ */ new Set();
+  const clock = options.now ?? Date.now;
   const reportError = (error, conversationId) => {
     try {
       options.onError?.(error instanceof Error ? error : new Error(String(error)), conversationId);
@@ -30508,6 +30605,7 @@ function createDurableAutoExtractor(options) {
   }
   async function extractBatch(messages, conversationId, ids, jobScope, jobFolderId) {
     let watchdog;
+    let cancelled = false;
     const model = options.modelForScope?.(jobScope) ?? options.extract.model;
     try {
       return await Promise.race([
@@ -30518,7 +30616,7 @@ function createDurableAutoExtractor(options) {
               ...options.retainCtx,
               vaultCtx: {
                 ...vault,
-                canWrite: async () => !disposed && await storage.conversationsCollection.query(import_watermelondb24.Q.where("conversation_id", conversationId), import_watermelondb24.Q.where("is_deleted", false)).fetchCount() > 0 && await storage.messagesCollection.query(import_watermelondb24.Q.where("conversation_id", conversationId), import_watermelondb24.Q.where("id", import_watermelondb24.Q.oneOf(ids))).fetchCount() === ids.length && (!vault.canWrite || await vault.canWrite()) && !disposed
+                canWrite: async () => !disposed && !cancelled && await storage.conversationsCollection.query(import_watermelondb24.Q.where("conversation_id", conversationId), import_watermelondb24.Q.where("is_deleted", false)).fetchCount() > 0 && await storage.messagesCollection.query(import_watermelondb24.Q.where("conversation_id", conversationId), import_watermelondb24.Q.where("id", import_watermelondb24.Q.oneOf(ids))).fetchCount() === ids.length && (!vault.canWrite || await vault.canWrite()) && !disposed && !cancelled
               }
             },
             // The model follows the job's scope, not the mode alive at drain time.
@@ -30538,14 +30636,116 @@ function createDurableAutoExtractor(options) {
         new Promise((_resolve, reject) => {
           watchdog = setTimeout(
             () => reject(new Error("Extraction did not settle in time; retained for retry")),
-            options.batchTimeoutMs ?? 18e4
+            options.batchTimeoutMs ?? defaultBatchTimeoutMs(options.extract)
           );
         })
       ]);
     } finally {
+      cancelled = true;
       if (watchdog !== void 0) clearTimeout(watchdog);
     }
   }
+  async function acknowledge(job, ids, loaded, abandoned) {
+    attempts.delete(job.id);
+    sessionFailures.delete(job.id);
+    skippedThisSession.delete(job.id);
+    const sequences = /* @__PURE__ */ new Map();
+    for (const message of loaded)
+      if (message && message.messageId > 0) sequences.set(message.uniqueId, message.messageId);
+    await database.write(async () => {
+      const current = idsOf(job);
+      const acknowledged = ids.filter((id) => current.includes(id));
+      if (!acknowledged.length) return;
+      const done = new Set(acknowledged);
+      const remaining = current.filter((id) => !done.has(id));
+      await job.update((r) => {
+        r._setRaw(
+          "message_ids",
+          JSON.stringify(
+            remaining.length ? [...abandoned ? [] : acknowledged.slice(-2), ...remaining] : []
+          )
+        );
+        const newest = acknowledged[acknowledged.length - 1];
+        r._setRaw("watermark", newest);
+        const sequence = sequences.get(newest);
+        if (sequence !== void 0) {
+          const prior = seqOf(job);
+          r._setRaw("watermark_seq", prior === void 0 ? sequence : Math.max(prior, sequence));
+        }
+        r._setRaw("failed_sessions", abandoned ? MAX_FAILED_SESSIONS : null);
+        r._setRaw("failed_head", abandoned ? newest : null);
+        r._setRaw("failed_at", null);
+      });
+    });
+  }
+  async function recordFailure(job, ids, loaded, error, conversationId) {
+    const head = ids[0];
+    if (!head || !loaded.some(Boolean)) return false;
+    if (error instanceof AccountFailureError) {
+      skippedThisSession.add(job.id);
+      return false;
+    }
+    const counted = error instanceof BatchFailureError || error instanceof LockedSourcesError && error.persistentIds.length > 0;
+    if (!counted) return false;
+    const prior = sessionFailures.get(job.id);
+    const count = prior?.head === head ? prior.count + 1 : 1;
+    sessionFailures.set(job.id, { head, count });
+    const terminal = error instanceof BatchFailureError && error.terminal;
+    if (!terminal && count < MAX_ATTEMPTS) return false;
+    skippedThisSession.add(job.id);
+    const now = clock();
+    const lastCounted = failedAtOf(job, head);
+    if (lastCounted !== void 0 && now - lastCounted < MIN_FAILED_SESSION_GAP_MS) return false;
+    const failures = failedSessionsOf(job, head) + 1;
+    if (failures < MAX_FAILED_SESSIONS) {
+      await database.write(
+        () => job.update((r) => {
+          r._setRaw("failed_sessions", failures);
+          r._setRaw("failed_head", head);
+          r._setRaw("failed_at", now);
+        })
+      );
+      return false;
+    }
+    if (error instanceof LockedSourcesError) {
+      const dropped = new Set(error.persistentIds);
+      let newest;
+      for (const message of loaded)
+        if (message && dropped.has(message.uniqueId) && message.messageId > (newest?.seq ?? 0))
+          newest = { id: message.uniqueId, seq: message.messageId };
+      const advance = newest !== void 0 && newest.seq > (seqOf(job) ?? 0) ? newest : void 0;
+      await database.write(
+        () => job.update((r) => {
+          r._setRaw("message_ids", JSON.stringify(idsOf(job).filter((id) => !dropped.has(id))));
+          if (advance) {
+            r._setRaw("watermark", advance.id);
+            r._setRaw("watermark_seq", advance.seq);
+          }
+          r._setRaw("failed_sessions", advance ? MAX_FAILED_SESSIONS : null);
+          r._setRaw("failed_head", advance ? advance.id : null);
+          r._setRaw("failed_at", null);
+        })
+      );
+      attempts.delete(job.id);
+      sessionFailures.delete(job.id);
+      skippedThisSession.delete(job.id);
+      reportError(
+        new Error(
+          `Dropped ${dropped.size} source id(s) that stayed locked for ${failures} sessions to unblock extraction`
+        ),
+        conversationId
+      );
+      return true;
+    }
+    await acknowledge(job, ids, loaded, true);
+    reportError(
+      new Error(
+        `Abandoned an extraction batch of ${ids.length} source id(s) after it failed in ${failures} sessions`
+      ),
+      conversationId
+    );
+    return true;
+  }
   async function drain() {
     if (disposed || running) return;
     running = true;
@@ -30560,21 +30760,23 @@ function createDurableAutoExtractor(options) {
       for (const job of pending) {
         if (disposed) break;
         const attempted = attempts.get(job.id) ?? 0;
-        if (attempted >= MAX_ATTEMPTS) continue;
+        if (attempted >= MAX_ATTEMPTS || skippedThisSession.has(job.id)) continue;
         if (processed >= MAX_JOBS_PER_PASS) {
           scheduleAfterSuccess = true;
           break;
         }
         processed++;
         const conversationId = String(job._getRaw("conversation_id"));
+        let ids = [];
+        let loaded = [];
         try {
           const conversations = await storage.conversationsCollection.query(import_watermelondb24.Q.where("conversation_id", conversationId), import_watermelondb24.Q.where("is_deleted", false)).fetchCount();
           if (!conversations) {
             await database.write(() => job.destroyPermanently());
             continue;
           }
-          const ids = idsOf(job).slice(0, 20);
-          const loaded = await Promise.all(ids.map((id) => getMessageOp(storage, id)));
+          ids = idsOf(job).slice(0, 20);
+          loaded = await Promise.all(ids.map((id) => getMessageOp(storage, id)));
           const missing = ids.filter((_id, index) => loaded[index] === null);
           if (missing.length) {
             if (attempted < MAX_ATTEMPTS - 1)
@@ -30598,17 +30800,21 @@ function createDurableAutoExtractor(options) {
             );
             continue;
           }
-          if (loaded.some(
-            (message) => message && (message.decryptionStatus || isEncrypted(message.content))
-          )) {
-            throw new Error("Source messages are locked; retained for retry");
+          const locked = loaded.filter((message) => message && isEncrypted(message.content));
+          if (locked.length) {
+            throw new LockedSourcesError(
+              locked.flatMap(
+                (message) => message.decryptionStatus === "auth_mismatch" || message.decryptionStatus === "invalid_payload" ? [message.uniqueId] : []
+              )
+            );
           }
           const messages = loaded.flatMap(
             (m) => m && m.conversationId === conversationId && (m.role === "user" || m.role === "assistant") ? [{ id: m.uniqueId, role: m.role, content: m.content }] : []
           );
           let success = messages.length === 0;
+          let result;
           if (messages.length) {
-            const result = await extractBatch(
+            result = await extractBatch(
               messages,
               conversationId,
               ids,
@@ -30618,41 +30824,35 @@ function createDurableAutoExtractor(options) {
             success = result.failedCount === 0 && result.outcome !== "empty-after-retry";
             options.onTurnComplete?.(result);
           }
-          if (!success) throw new Error("Extraction batch incomplete; retained for retry");
-          attempts.delete(job.id);
-          const sequences = /* @__PURE__ */ new Map();
-          for (const message of loaded)
-            if (message && message.messageId > 0)
-              sequences.set(message.uniqueId, message.messageId);
-          await database.write(async () => {
-            const current = idsOf(job);
-            const acknowledged = ids.filter((id) => current.includes(id));
-            if (!acknowledged.length) return;
-            const done = new Set(acknowledged);
-            const remaining = current.filter((id) => !done.has(id));
-            if (remaining.length) {
-              await job.update(
-                (r) => r._setRaw("message_ids", JSON.stringify([...acknowledged.slice(-2), ...remaining]))
-              );
-            } else await job.update((r) => r._setRaw("message_ids", "[]"));
-            const newest = acknowledged[acknowledged.length - 1];
-            await job.update((r) => {
-              r._setRaw("watermark", newest);
-              const sequence = sequences.get(newest);
-              if (sequence !== void 0) {
-                const prior = seqOf(job);
-                r._setRaw(
-                  "watermark_seq",
-                  prior === void 0 ? sequence : Math.max(prior, sequence)
+          if (!success) {
+            const failure = result?.failure;
+            if (failure?.reason === "http-terminal") {
+              const status = failure.httpStatus;
+              if (status !== void 0 && REQUEST_REJECTED_STATUSES.has(status))
+                throw new BatchFailureError(
+                  `Extraction rejected the batch (HTTP ${status}); not retried this session`,
+                  true
                 );
-              }
-            });
-          });
+              throw new AccountFailureError(
+                `Extraction refused for the account (HTTP ${status ?? "unknown"}); retried next session`
+              );
+            }
+            if ((result?.failedCount ?? 0) > 0 || failure !== void 0 && CONTENT_FAILURE_REASONS.has(failure.reason))
+              throw new BatchFailureError("Extraction batch incomplete; retained for retry", false);
+            throw new Error("Extraction batch incomplete; retained for retry");
+          }
+          await acknowledge(job, ids, loaded, false);
           scheduleAfterSuccess = true;
         } catch (error) {
           attempts.set(job.id, attempted + 1);
           retry = true;
           reportError(error, conversationId);
+          try {
+            if (await recordFailure(job, ids, loaded, error, conversationId))
+              scheduleAfterSuccess = true;
+          } catch (recordError) {
+            reportError(recordError, conversationId);
+          }
         }
       }
     } catch (error) {
@@ -30722,7 +30922,7 @@ function createDurableAutoExtractor(options) {
           const start = boundary >= 0 ? boundary + 1 : Math.max(0, ids.length - Math.max(1, options.windowSize ?? 6));
           if (start >= ids.length) return;
           const ownWatermark = job?._getRaw("watermark");
-          const atOwnWatermark = !!job && boundary >= 0 && (ids[boundary] === ownWatermark || sequences.get(ids[boundary]) !== void 0 && sequences.get(ids[boundary]) === seqOf(job));
+          const atOwnWatermark = !!job && boundary >= 0 && failedSessionsOf(job, String(ownWatermark)) < MAX_FAILED_SESSIONS && (ids[boundary] === ownWatermark || sequences.get(ids[boundary]) !== void 0 && sequences.get(ids[boundary]) === seqOf(job));
           const overlapStart = atOwnWatermark ? Math.max(0, boundary - 1) : start;
           const fresh = ids.slice(overlapStart).filter((id) => !foreignSources.has(id));
           if (!fresh.length) return;