stratagate-dsh 0.2.37 → 0.2.39

package/dist/index.js

@@ -1263,7 +1263,7 @@ function normalizeRetrievalAssessment(input, batchEvidenceRefs) {
 }
 
 // packages/core/src/storage.ts
-var STRATAGATE_STORAGE_SCHEMA_VERSION = 9;
+var STRATAGATE_STORAGE_SCHEMA_VERSION = 10;
 var KNOWLEDGE_GRAPH_PROJECTOR_VERSION = 1;
 var StorageConflictError = class extends Error {
   constructor(namespace, expectedRevision, actualRevision) {
@@ -1387,7 +1387,15 @@ function normalizeSnapshot(value) {
       schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
       blocks: readyLegacyBlocks(legacy.blocks),
       summaryJobs: [],
-      extractionJobs: legacyExtractionJobs(legacy.extractionJobs)
+      extractionJobs: legacyExtractionJobs(legacy.extractionJobs),
+      externalMemoryImportJobs: []
+    };
+  } else if (schemaVersion === 9) {
+    const legacy = value;
+    snapshot = {
+      ...structuredClone(legacy),
+      schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
+      externalMemoryImportJobs: []
     };
   } else if (schemaVersion === STRATAGATE_STORAGE_SCHEMA_VERSION) {
     snapshot = structuredClone(value);
@@ -1403,7 +1411,8 @@ function normalizeSnapshot(value) {
   if (!Number.isFinite(snapshot.blockDecayLambda) || snapshot.blockDecayLambda < 0) {
     throw new TypeError("Invalid StrataGate snapshot: blockDecayLambda must be a non-negative finite number");
   }
-  for (const key of ["openTail", "blocks", "summaryJobs", "events", "graphNodes", "graphEdges", "graphProjectionJobs", "elements", "extractionJobs", "elementProjectionJobs", "usageReceipts", "ingestionReceipts"]) {
+  if (!Array.isArray(snapshot.externalMemoryImportJobs)) snapshot.externalMemoryImportJobs = [];
+  for (const key of ["openTail", "blocks", "summaryJobs", "events", "graphNodes", "graphEdges", "graphProjectionJobs", "elements", "extractionJobs", "elementProjectionJobs", "usageReceipts", "ingestionReceipts", "externalMemoryImportJobs"]) {
     if (!Array.isArray(snapshot[key])) throw new TypeError(`Invalid StrataGate snapshot: ${key} must be an array`);
   }
   if (!Array.isArray(snapshot.successfulModelResponses)) snapshot.successfulModelResponses = [];
@@ -1817,6 +1826,16 @@ CREATE TABLE IF NOT EXISTS ingestion_receipts (
   PRIMARY KEY (namespace, receipt_id),
   FOREIGN KEY (namespace) REFERENCES memory_spaces(namespace) ON DELETE CASCADE
 ) STRICT;
+
+CREATE TABLE IF NOT EXISTS external_memory_import_jobs (
+  namespace TEXT NOT NULL,
+  id TEXT NOT NULL,
+  payload_json TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (namespace, id),
+  FOREIGN KEY (namespace) REFERENCES memory_spaces(namespace) ON DELETE CASCADE
+) STRICT;
 `;
 var THREAD_INDEXES = `
 CREATE INDEX IF NOT EXISTS messages_thread_idx ON messages(namespace, thread_id, position);
@@ -2092,6 +2111,10 @@ var SqliteStorage = class {
       id: row.receipt_id,
       createdAt: row.created_at
     }));
+    const externalMemoryImportJobs = this.database.prepare(`
+      SELECT id, payload_json FROM external_memory_import_jobs
+      WHERE namespace = ? ORDER BY created_at, id
+    `).all(key).map((row) => parseJson(row.payload_json, "external_memory_import_jobs.payload_json"));
     const graphState = this.database.prepare(`
       SELECT nodes_json, edges_json, jobs_json FROM graph_state WHERE namespace = ?
     `).get(key);
@@ -2115,6 +2138,7 @@ var SqliteStorage = class {
       elementProjectionJobs,
       usageReceipts,
       ingestionReceipts,
+      externalMemoryImportJobs,
       successfulModelResponses
     };
     assertValidSnapshot(snapshot);
@@ -2498,6 +2522,14 @@ var SqliteStorage = class {
     for (const receipt of snapshot.ingestionReceipts) {
       insertIngestionReceipt.run(namespace, receipt.id, receipt.createdAt);
     }
+    this.database.prepare("DELETE FROM external_memory_import_jobs WHERE namespace = ?").run(namespace);
+    const insertExternalMemoryImportJob = this.database.prepare(`
+      INSERT INTO external_memory_import_jobs (namespace, id, payload_json, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+    for (const job of snapshot.externalMemoryImportJobs) {
+      insertExternalMemoryImportJob.run(namespace, job.id, JSON.stringify(job), job.createdAt, job.updatedAt);
+    }
     this.database.prepare("DELETE FROM model_response_history WHERE namespace = ?").run(namespace);
     const insertSuccessfulModelResponse = this.database.prepare(`
       INSERT INTO model_response_history (namespace, id, kind, response, created_at)
@@ -2607,6 +2639,10 @@ var SqliteStorage = class {
     this.assertOpen();
     return this.database.prepare("SELECT namespace FROM memory_spaces ORDER BY namespace").all().map(({ namespace }) => namespace);
   }
+  listNamespaceRevisions() {
+    this.assertOpen();
+    return this.database.prepare("SELECT namespace, revision FROM memory_spaces ORDER BY namespace").all();
+  }
 };
 
 // packages/core/src/store.ts
@@ -2642,6 +2678,10 @@ function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 var STRATAGATE_CONSTRUCTOR_TOKEN = /* @__PURE__ */ Symbol("StrataGate constructor");
+var EXTERNAL_MEMORY_AUTO_APPLY_CONFIDENCE = 0.85;
+function externalMemoryFingerprint(value) {
+  return `${normalizeSearchText(value.title)}\0${normalizeSearchText(value.summary)}`;
+}
 var DERIVATION_MAX_ATTEMPTS = 3;
 var DERIVATION_BACKOFF_MS = 1e3;
 var StrataGate = class _StrataGate {
@@ -2669,6 +2709,7 @@ var StrataGate = class _StrataGate {
   usageReceipts = /* @__PURE__ */ new Map();
   successfulModelResponses = [];
   ingestionReceipts = /* @__PURE__ */ new Map();
+  externalMemoryImportJobs = /* @__PURE__ */ new Map();
   currentTurn = 0;
   storage;
   namespace;
@@ -2842,6 +2883,25 @@ var StrataGate = class _StrataGate {
   get storageRevision() {
     return this.revision;
   }
+  /** Replace an out-of-date in-memory view with the latest durable namespace snapshot. */
+  async reloadFromStorage() {
+    if (!this.storage || !this.namespace) return false;
+    const previous = this.mutationQueue;
+    let release;
+    this.mutationQueue = new Promise((resolve2) => {
+      release = resolve2;
+    });
+    await previous;
+    try {
+      const loaded = await this.storage.load(this.namespace);
+      if (!loaded || loaded.revision === this.revision) return false;
+      this.restoreSnapshot(loaded.snapshot);
+      this.revision = loaded.revision;
+      return true;
+    } finally {
+      release();
+    }
+  }
   get blockTurnSize() {
     return this.blockTurnSizeValue;
   }
@@ -2903,6 +2963,9 @@ var StrataGate = class _StrataGate {
   listSuccessfulModelResponses() {
     return this.successfulModelResponses;
   }
+  listExternalMemoryImportJobs() {
+    return [...this.externalMemoryImportJobs.values()].map((job) => structuredClone(job));
+  }
   async recordSuccessfulModelResponses(responses) {
     if (responses.length === 0) return;
     await this.commitMutation(() => {
@@ -2933,6 +2996,7 @@ var StrataGate = class _StrataGate {
       elementProjectionJobs: [...this.elementProjectionJobs.values()],
       usageReceipts: [...this.usageReceipts.values()],
       ingestionReceipts: [...this.ingestionReceipts.values()],
+      externalMemoryImportJobs: [...this.externalMemoryImportJobs.values()],
       successfulModelResponses: this.successfulModelResponses
     });
   }
@@ -3040,7 +3104,41 @@ var StrataGate = class _StrataGate {
    * overwritten: MERGE and SUPERSEDE create a new canonical Event that points
    * back to the older Events.
    */
-  async importExternalMemory(options) {
+  normalizeExternalMemoryDecision(candidate, matches, decision, forceConfirmation = false) {
+    const allowed = new Set(matches.map(({ event }) => event.id));
+    const exact = this.events.find((event) => event.status !== "forgotten" && event.status !== "archived" && externalMemoryFingerprint(event) === externalMemoryFingerprint(candidate));
+    if (exact) allowed.add(exact.id);
+    const existingEventIds = [...new Set((decision.existingEventIds ?? []).filter((id) => allowed.has(id)))];
+    const requestedAction = this.normalizeExternalAction(decision.action);
+    const missingTarget = requestedAction !== "ADD" && requestedAction !== "IGNORE" && existingEventIds.length === 0;
+    const action = missingTarget ? "IGNORE" : requestedAction;
+    const confidence2 = missingTarget ? 0.5 : Number.isFinite(decision.confidence) ? Math.max(0, Math.min(1, decision.confidence)) : 0.5;
+    return {
+      candidate: structuredClone(candidate),
+      action,
+      existingEventIds,
+      matches: structuredClone([...matches]),
+      confidence: confidence2,
+      requiresConfirmation: forceConfirmation || confidence2 < EXTERNAL_MEMORY_AUTO_APPLY_CONFIDENCE,
+      ...decision.mergedCandidate ? { mergedCandidate: structuredClone(decision.mergedCandidate) } : {},
+      ...missingTarget ? { reason: "\u6A21\u578B\u672A\u5173\u8054\u5230\u5141\u8BB8\u8303\u56F4\u5185\u7684\u73B0\u6709\u8BB0\u5FC6\uFF0C\u5DF2\u5B89\u5168\u964D\u7EA7\u4E3A\u5FFD\u7565" } : typeof decision.reason === "string" && decision.reason.trim() ? { reason: decision.reason.trim().slice(0, 500) } : {}
+    };
+  }
+  async decideExternalMemoryCandidate(candidate, priorFingerprints, decider, topK, forceConfirmation = false) {
+    const fingerprint = externalMemoryFingerprint(candidate);
+    const exact = this.events.find((event) => event.status !== "forgotten" && event.status !== "archived" && externalMemoryFingerprint(event) === fingerprint);
+    const duplicateInImport = priorFingerprints.has(fingerprint);
+    const query = `${candidate.title} ${candidate.summary} ${(candidate.tags ?? []).join(" ")}`.trim();
+    const matches = await this.searchEvents(query, { limit: topK, trackRetrieval: false });
+    const decision = exact || duplicateInImport ? {
+      action: "IGNORE",
+      existingEventIds: exact ? [exact.id] : [],
+      reason: exact ? "\u4E0E\u73B0\u6709\u8BB0\u5FC6\u5B8C\u5168\u91CD\u590D" : "\u4E0E\u672C\u6279\u6B21\u4E2D\u7684\u5019\u9009\u5B8C\u5168\u91CD\u590D",
+      confidence: 1
+    } : await decider({ candidate: structuredClone(candidate), matches: structuredClone(matches) });
+    return this.normalizeExternalMemoryDecision(candidate, matches, decision, forceConfirmation);
+  }
+  async previewExternalMemoryImport(options) {
     const text3 = options.text.trim();
     if (!text3) throw new TypeError("External memory text must not be empty");
     if (typeof options.decider !== "function") {
@@ -3051,28 +3149,198 @@ var StrataGate = class _StrataGate {
     const extracted = await extractor({ text: text3, importedAt });
     const candidates = Array.isArray(extracted?.candidates) ? extracted.candidates.slice(0, 200) : [];
     const topK = Math.max(1, Math.min(20, Math.floor(options.topK ?? 5)));
-    const source = await this.commitMutation(() => this.createExternalSourceBlock(text3, importedAt));
-    const prepared = [];
+    const seenFingerprints = /* @__PURE__ */ new Set();
+    const decisions = [];
     for (const candidate of candidates) {
       if (!candidate || typeof candidate.title !== "string" || typeof candidate.summary !== "string") continue;
-      const query = `${candidate.title} ${candidate.summary} ${(candidate.tags ?? []).join(" ")}`.trim();
-      const matches = await this.searchEvents(query, { limit: topK });
-      const decision = await options.decider({ candidate, matches });
-      const allowed = new Set(matches.map(({ event }) => event.id));
-      const existingEventIds = [...new Set((decision.existingEventIds ?? []).filter((id) => allowed.has(id)))];
-      prepared.push({ candidate, decision, existingEventIds });
+      const fingerprint = externalMemoryFingerprint(candidate);
+      const preview = await this.decideExternalMemoryCandidate(candidate, seenFingerprints, options.decider, topK);
+      seenFingerprints.add(fingerprint);
+      decisions.push(preview);
+    }
+    return { importedAt, baseRevision: this.revision, decisions };
+  }
+  getExternalMemoryImportJob(jobId) {
+    const job = this.externalMemoryImportJobs.get(jobId.trim());
+    return job ? structuredClone(job) : null;
+  }
+  async createExternalMemoryImportJob(text3) {
+    const normalized = text3.trim();
+    if (!normalized) throw new TypeError("External memory text must not be empty");
+    const now = toUtc8Iso(this.now());
+    let candidates = [];
+    let parseError = null;
+    try {
+      candidates = parseExternalMemoryExport(normalized).candidates;
+    } catch (error) {
+      parseError = errorMessage(error).slice(0, 2e3);
     }
+    const job = {
+      id: `import_${crypto.randomUUID()}`,
+      text: normalized,
+      importedAt: now,
+      status: parseError ? "extracting" : candidates.length > 0 ? "processing" : "ready",
+      candidates: structuredClone(candidates),
+      decisions: [],
+      processedCount: 0,
+      totalCount: candidates.length,
+      recoveredFromInvalidJson: false,
+      parseError,
+      lastError: null,
+      sourceBlockId: null,
+      importedCount: 0,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.commitMutation(() => this.externalMemoryImportJobs.set(job.id, structuredClone(job)));
+    return structuredClone(job);
+  }
+  async completeExternalMemoryFallback(jobId, result) {
+    const candidates = (Array.isArray(result.candidates) ? result.candidates : []).filter((candidate) => candidate && typeof candidate.title === "string" && typeof candidate.summary === "string").slice(0, 200);
     return this.commitMutation(() => {
+      const job = this.requireExternalMemoryImportJob(jobId);
+      if (job.status !== "extracting") return structuredClone(job);
+      job.candidates = structuredClone(candidates);
+      job.decisions = [];
+      job.processedCount = 0;
+      job.totalCount = candidates.length;
+      job.recoveredFromInvalidJson = true;
+      job.status = candidates.length > 0 ? "processing" : "failed";
+      job.lastError = candidates.length > 0 ? null : "\u6A21\u578B\u672A\u80FD\u4ECE\u4E0D\u5408\u683C\u5185\u5BB9\u4E2D\u6062\u590D\u51FA\u4EFB\u4F55\u5019\u9009\u8BB0\u5FC6";
+      job.updatedAt = toUtc8Iso(this.now());
+      return structuredClone(job);
+    });
+  }
+  async processNextExternalMemoryImport(jobId, decider, topK = 5) {
+    if (typeof decider !== "function") throw new TypeError("External memory decider is required");
+    const work = await this.prepareNextExternalMemoryImport(jobId, topK);
+    if (!work) {
+      const current = this.requireExternalMemoryImportJob(jobId);
+      return structuredClone(current);
+    }
+    const decision = work.deterministicDecision ?? await decider({
+      candidate: structuredClone(work.candidate),
+      matches: structuredClone(work.matches)
+    });
+    return this.completeNextExternalMemoryImport(
+      work.jobId,
+      work.index,
+      decision,
+      work.matches,
+      work.forceConfirmation
+    );
+  }
+  async prepareNextExternalMemoryImport(jobId, topK = 5) {
+    const current = this.requireExternalMemoryImportJob(jobId);
+    if (current.status !== "processing") return null;
+    const index = current.processedCount;
+    const candidate = current.candidates[index];
+    if (!candidate) return null;
+    const priorFingerprints = new Set(current.candidates.slice(0, index).map(externalMemoryFingerprint));
+    const fingerprint = externalMemoryFingerprint(candidate);
+    const exact = this.events.find((event) => event.status !== "forgotten" && event.status !== "archived" && externalMemoryFingerprint(event) === fingerprint);
+    const duplicateInImport = priorFingerprints.has(fingerprint);
+    const query = `${candidate.title} ${candidate.summary} ${(candidate.tags ?? []).join(" ")}`.trim();
+    const matches = await this.searchEvents(query, {
+      limit: Math.max(1, Math.min(20, Math.floor(topK))),
+      trackRetrieval: false
+    });
+    const deterministicDecision = exact || duplicateInImport ? {
+      action: "IGNORE",
+      existingEventIds: exact ? [exact.id] : [],
+      reason: exact ? "\u4E0E\u73B0\u6709\u8BB0\u5FC6\u5B8C\u5168\u91CD\u590D" : "\u4E0E\u672C\u6279\u6B21\u4E2D\u7684\u5019\u9009\u5B8C\u5168\u91CD\u590D",
+      confidence: 1
+    } : void 0;
+    return {
+      jobId: current.id,
+      index,
+      candidate: structuredClone(candidate),
+      matches: structuredClone(matches),
+      forceConfirmation: current.recoveredFromInvalidJson,
+      ...deterministicDecision ? { deterministicDecision } : {}
+    };
+  }
+  async completeNextExternalMemoryImport(jobId, index, decision, matches, forceConfirmation = false) {
+    return this.commitMutation(() => {
+      const job = this.requireExternalMemoryImportJob(jobId);
+      if (job.processedCount > index) return structuredClone(job);
+      if (job.status !== "processing" || job.processedCount !== index) {
+        throw new Error(`External memory import ${jobId} is no longer at candidate ${index}`);
+      }
+      const candidate = job.candidates[index];
+      if (!candidate) throw new Error(`External memory import ${jobId} has no candidate ${index}`);
+      const normalized = this.normalizeExternalMemoryDecision(candidate, matches, decision, forceConfirmation);
+      job.decisions.push(structuredClone(normalized));
+      job.processedCount += 1;
+      if (job.processedCount >= job.totalCount) {
+        job.status = job.decisions.some(({ requiresConfirmation }) => requiresConfirmation) ? "awaiting_confirmation" : "ready";
+      }
+      job.lastError = null;
+      job.updatedAt = toUtc8Iso(this.now());
+      return structuredClone(job);
+    });
+  }
+  async failExternalMemoryImportJob(jobId, error) {
+    return this.commitMutation(() => {
+      const job = this.requireExternalMemoryImportJob(jobId);
+      job.status = "failed";
+      job.lastError = errorMessage(error).slice(0, 2e3);
+      job.updatedAt = toUtc8Iso(this.now());
+      return structuredClone(job);
+    });
+  }
+  async retryExternalMemoryImportJob(jobId) {
+    return this.commitMutation(() => {
+      const job = this.requireExternalMemoryImportJob(jobId);
+      if (job.status !== "failed") return structuredClone(job);
+      job.status = job.candidates.length === 0 && job.parseError ? "extracting" : "processing";
+      job.lastError = null;
+      job.updatedAt = toUtc8Iso(this.now());
+      return structuredClone(job);
+    });
+  }
+  async completeExternalMemoryImportJob(jobId, result) {
+    return this.commitMutation(() => {
+      const job = this.requireExternalMemoryImportJob(jobId);
+      job.status = "committed";
+      job.sourceBlockId = result.sourceBlockId;
+      job.importedCount = result.addedEvents.length;
+      job.updatedAt = toUtc8Iso(this.now());
+      return structuredClone(job);
+    });
+  }
+  async markExternalMemoryImportUndone(jobId) {
+    return this.commitMutation(() => {
+      const job = this.requireExternalMemoryImportJob(jobId);
+      job.status = "undone";
+      job.updatedAt = toUtc8Iso(this.now());
+      return structuredClone(job);
+    });
+  }
+  async commitExternalMemoryImport(options) {
+    const text3 = options.text.trim();
+    if (!text3) throw new TypeError("External memory text must not be empty");
+    if (options.candidates.length !== options.decisions.length) {
+      throw new TypeError("External memory candidates and decisions must have the same length");
+    }
+    return this.commitMutation(() => {
+      if (this.revision !== options.baseRevision) {
+        throw new Error(`External memory preview is stale: expected revision ${options.baseRevision}, found ${this.revision}`);
+      }
+      const importedAt = toUtc8Iso(options.importedAt);
+      const source = this.createExternalSourceBlock(text3, importedAt);
       const addedEvents = [];
       const changedEventIds = /* @__PURE__ */ new Set();
       const decisions = [];
-      for (const item of prepared) {
-        const action = this.normalizeExternalAction(item.decision.action);
-        const targets = item.existingEventIds;
-        const reason = typeof item.decision.reason === "string" ? item.decision.reason.trim().slice(0, 500) : void 0;
+      for (const [index, item] of options.decisions.entries()) {
+        const action = this.normalizeExternalAction(item.action);
+        const allowed = new Set(item.matches.map(({ event }) => event.id));
+        const targets = [...new Set(item.existingEventIds.filter((id) => allowed.has(id)))];
+        const reason = typeof item.reason === "string" ? item.reason.trim().slice(0, 500) : void 0;
         let createdEvent;
-        const proposed = item.decision.mergedCandidate;
-        const candidate = proposed && typeof proposed.title === "string" && typeof proposed.summary === "string" ? proposed : item.candidate;
+        const proposed = item.mergedCandidate;
+        const original = options.candidates[index];
+        const candidate = proposed && typeof proposed.title === "string" && typeof proposed.summary === "string" ? proposed : original;
         if ((action === "ADD" || action === "MERGE" || action === "SUPERSEDE" || action === "CONFLICT") && (action === "ADD" || targets.length > 0)) {
           const temporal = {
             ...candidate.temporal ?? {},
@@ -3098,11 +3366,12 @@ var StrataGate = class _StrataGate {
           }
         }
         const audit2 = {
-          candidate: structuredClone(item.candidate),
+          candidate: structuredClone(original),
           action,
           existingEventIds: targets,
           ...createdEvent ? { createdEventId: createdEvent.id } : {},
-          ...reason ? { reason } : {}
+          ...reason ? { reason } : {},
+          ...typeof item.confidence === "number" ? { confidence: item.confidence } : {}
         };
         decisions.push(audit2);
       }
@@ -3119,6 +3388,92 @@ var StrataGate = class _StrataGate {
       };
     });
   }
+  async importExternalMemory(options) {
+    const preview = await this.previewExternalMemoryImport(options);
+    return this.commitExternalMemoryImport({
+      text: options.text,
+      importedAt: preview.importedAt,
+      baseRevision: preview.baseRevision,
+      candidates: preview.decisions.map(({ candidate }) => candidate),
+      decisions: preview.decisions
+    });
+  }
+  async undoExternalMemoryImport(sourceBlockId) {
+    const id = sourceBlockId.trim();
+    if (!id) throw new TypeError("External memory source block ID must not be empty");
+    return this.commitMutation(() => {
+      const sourceIndex = this.blocks.findIndex((block) => block.id === id && block.l0Tags?.includes("external-memory-import"));
+      if (sourceIndex < 0) throw new Error(`Unknown external memory import: ${id}`);
+      const source = this.blocks[sourceIndex];
+      const sourceMessageIds = new Set(source.l5Raw.map(({ id: id2 }) => id2));
+      const importedEventIds = new Set(this.events.filter((event) => event.sourceBlockId === id).map(({ id: id2 }) => id2));
+      const restoredEventIds = /* @__PURE__ */ new Set();
+      const now = toUtc8Iso(this.now());
+      this.events.splice(0, this.events.length, ...this.events.filter((event) => !importedEventIds.has(event.id)));
+      for (const event of this.events) {
+        for (const field of ["conflictsWithEventIds", "supersedesEventIds", "beforeEventIds", "afterEventIds", "relatedEventIds"]) {
+          const previous = event.temporal[field] ?? [];
+          const filtered = previous.filter((target) => !importedEventIds.has(target));
+          if (filtered.length !== previous.length) {
+            event.temporal[field] = filtered;
+            restoredEventIds.add(event.id);
+          }
+        }
+        if (event.temporal.sameEventId && importedEventIds.has(event.temporal.sameEventId)) {
+          delete event.temporal.sameEventId;
+          restoredEventIds.add(event.id);
+        }
+        if (event.supersededBy && importedEventIds.has(event.supersededBy)) {
+          const replacement = this.events.find((candidate) => candidate.id !== event.id && (candidate.temporal.supersedesEventIds ?? []).includes(event.id));
+          event.status = replacement ? "superseded" : "active";
+          event.supersededBy = replacement?.id ?? null;
+          if (!replacement && event.weight.forcedCap === 0.1) event.weight.forcedCap = null;
+          restoredEventIds.add(event.id);
+        }
+        if (restoredEventIds.has(event.id)) event.updatedAt = now;
+      }
+      for (const [jobId, job] of this.elementProjectionJobs) {
+        if (job.sourceEventIds.some((eventId) => importedEventIds.has(eventId))) this.elementProjectionJobs.delete(jobId);
+      }
+      for (const [jobId, job] of this.graphProjectionJobs) {
+        if (job.sourceEventIds.some((eventId) => importedEventIds.has(eventId))) this.graphProjectionJobs.delete(jobId);
+      }
+      for (const element of this.elements) {
+        element.sourceEventIds = element.sourceEventIds.filter((eventId) => !importedEventIds.has(eventId));
+        element.sourceMessageIds = element.sourceMessageIds.filter((messageId) => !sourceMessageIds.has(messageId));
+        element.facts = element.facts.flatMap((fact) => {
+          fact.sourceEventIds = fact.sourceEventIds.filter((eventId) => !importedEventIds.has(eventId));
+          return fact.sourceEventIds.length > 0 ? [fact] : [];
+        });
+        const current = [...element.facts].reverse().find((fact) => fact.status === "active" && fact.mode === "state");
+        element.currentState = current ? Array.isArray(current.value) ? current.value.join("\u3001") : current.value : "";
+      }
+      this.elements.splice(0, this.elements.length, ...this.elements.filter((element) => element.sourceEventIds.length > 0 || element.facts.length > 0));
+      for (const node of this.graphNodes) {
+        node.sourceEventIds = node.sourceEventIds.filter((eventId) => !importedEventIds.has(eventId));
+        node.facts = node.facts.flatMap((fact) => {
+          fact.sourceEventIds = fact.sourceEventIds.filter((eventId) => !importedEventIds.has(eventId));
+          return fact.sourceEventIds.length > 0 ? [fact] : [];
+        });
+      }
+      const removedNodeIds = new Set(this.graphNodes.filter((node) => node.sourceEventIds.length === 0 && node.facts.length === 0).map(({ id: id2 }) => id2));
+      this.graphNodes.splice(0, this.graphNodes.length, ...this.graphNodes.filter((node) => !removedNodeIds.has(node.id)));
+      for (const edge of this.graphEdges) {
+        edge.sourceEventIds = edge.sourceEventIds.filter((eventId) => !importedEventIds.has(eventId));
+      }
+      this.graphEdges.splice(0, this.graphEdges.length, ...this.graphEdges.filter((edge) => edge.sourceEventIds.length > 0 && !removedNodeIds.has(edge.fromNodeId) && !removedNodeIds.has(edge.toNodeId)));
+      for (const [receiptId, receipt] of this.usageReceipts) {
+        receipt.eventIds = receipt.eventIds.filter((eventId) => !importedEventIds.has(eventId));
+        if (receipt.eventIds.length === 0 && receipt.elementIds.length === 0) this.usageReceipts.delete(receiptId);
+      }
+      this.blocks.splice(sourceIndex, 1);
+      return {
+        sourceBlockId: id,
+        removedEventIds: [...importedEventIds],
+        restoredEventIds: [...restoredEventIds]
+      };
+    });
+  }
   async searchEvents(query, options = {}) {
     const limit = Math.max(1, Math.min(20, options.limit ?? 6));
     const participants = (options.participants ?? []).map(normalizeSearchText).filter(Boolean);
@@ -3172,7 +3527,7 @@ var StrataGate = class _StrataGate {
       rankings.push(structured(candidates));
     }
     const ranked = rrfRank(rankings).slice(0, limit).map(({ item: event, score }) => ({ event, score }));
-    if (ranked.length > 0) {
+    if (ranked.length > 0 && options.trackRetrieval !== false) {
       const now = toUtc8Iso(this.now());
       await this.commitMutation(() => {
         for (const { event } of ranked) event.weight.lastRetrievedAt = now;
@@ -3509,6 +3864,11 @@ var StrataGate = class _StrataGate {
     const action = typeof value === "string" ? value.trim().toUpperCase() : "";
     return action === "ADD" || action === "MERGE" || action === "SUPERSEDE" || action === "CONFLICT" || action === "IGNORE" ? action : "IGNORE";
   }
+  requireExternalMemoryImportJob(id) {
+    const job = this.externalMemoryImportJobs.get(id.trim());
+    if (!job) throw new Error(`Unknown external memory import job: ${id}`);
+    return job;
+  }
   createExternalSourceBlock(text3, importedAt) {
     const blockId = this.idFactory("blk");
     const threadId = `external-import:${blockId}`;
@@ -3523,7 +3883,7 @@ var StrataGate = class _StrataGate {
     const block = {
       id: blockId,
       threadId,
-      sequence: this.blocks.length + 1,
+      sequence: Math.max(0, ...this.blocks.map(({ sequence }) => sequence)) + 1,
       startTurn: 1,
       endTurn: 1,
       createdAt: importedAt,
@@ -4055,6 +4415,8 @@ var StrataGate = class _StrataGate {
     for (const receipt of copy.usageReceipts) this.usageReceipts.set(receipt.id, receipt);
     this.ingestionReceipts.clear();
     for (const receipt of copy.ingestionReceipts) this.ingestionReceipts.set(receipt.id, receipt);
+    this.externalMemoryImportJobs.clear();
+    for (const job of copy.externalMemoryImportJobs) this.externalMemoryImportJobs.set(job.id, job);
     this.successfulModelResponses.splice(0, this.successfulModelResponses.length, ...copy.successfulModelResponses ?? []);
     this.validateReferences();
   }
@@ -4323,7 +4685,9 @@ var STRUCTURED_FIELDS = {
   summarizer: ["l0Title", "l0Tags", "l1Summary", "l2Keypoints", "shouldExtract"],
   extractor: ["shouldExtract", "reason", "events"],
   projector: ["reason", "changes"],
-  graphProjector: ["reason", "nodes", "edges"]
+  graphProjector: ["reason", "nodes", "edges"],
+  externalMemoryExtractor: ["reason", "candidates"],
+  externalMemoryDecider: ["action", "reason", "confidence"]
 };
 var STRING_ARRAY = { type: "array", items: { type: "string" } };
 var OPEN_OBJECT = { type: "object", additionalProperties: true };
@@ -4431,6 +4795,17 @@ var GRAPH_PROJECTOR_PARAMETERS = {
   nodes: { type: "array", items: GRAPH_NODE, required: true },
   edges: { type: "array", items: GRAPH_EDGE, required: true }
 };
+var EXTERNAL_MEMORY_DECIDER_PARAMETERS = {
+  action: { type: "string", enum: ["ADD", "MERGE", "SUPERSEDE", "CONFLICT", "IGNORE"], required: true },
+  existingEventIds: STRING_ARRAY,
+  mergedCandidate: OPEN_OBJECT,
+  reason: { type: "string", required: true },
+  confidence: { type: "number", required: true }
+};
+var EXTERNAL_MEMORY_EXTRACTOR_PARAMETERS = {
+  reason: { type: "string", required: true },
+  candidates: { type: "array", items: OPEN_OBJECT, required: true }
+};
 var STRUCTURED_TOOLS = {
   summarizer: {
     name: "stratagate_summarize_block",
@@ -4451,6 +4826,16 @@ var STRUCTURED_TOOLS = {
     name: "stratagate_project_knowledge_graph",
     description: "Project stable graph nodes and directed edges from supplied event evidence.",
     parameters: GRAPH_PROJECTOR_PARAMETERS
+  },
+  externalMemoryDecider: {
+    name: "stratagate_decide_external_memory",
+    description: "Decide how one external memory candidate relates to retrieved local events.",
+    parameters: EXTERNAL_MEMORY_DECIDER_PARAMETERS
+  },
+  externalMemoryExtractor: {
+    name: "stratagate_recover_external_memory",
+    description: "Recover structured external-memory candidates from malformed JSON or plain text.",
+    parameters: EXTERNAL_MEMORY_EXTRACTOR_PARAMETERS
   }
 };
 function toolSchema(kind) {
@@ -4479,7 +4864,10 @@ var DshModelBridge = class {
   successfulResponses = [];
   offCapabilities = /* @__PURE__ */ new Map();
   run(session, operation) {
-    return this.sessions.run(session, operation);
+    return this.sessions.run({ session, sessionId: session.id }, operation);
+  }
+  runDetached(sessionId, operation) {
+    return this.sessions.run({ sessionId }, operation);
   }
   takeSuccessfulResponses() {
     const responses = this.successfulResponses.splice(0, this.successfulResponses.length);
@@ -4621,10 +5009,43 @@ var DshModelBridge = class {
     });
     return { reason: text2(raw.reason, "Projected Event evidence into the Knowledge Graph."), nodes, edges };
   };
+  externalMemoryDecider = async (context) => {
+    const raw = object(await this.callStructured(
+      "externalMemoryDecider",
+      `${EXTERNAL_MEMORY_DECIDER_PROMPT_ZH_CN}
+
+\u8C03\u7528 ${STRUCTURED_TOOLS.externalMemoryDecider.name} \u6070\u597D\u4E00\u6B21\uFF0C\u4E0D\u8981\u8FD4\u56DE\u666E\u901A\u6587\u672C\u3002confidence \u5FC5\u987B\u662F 0 \u5230 1\uFF0C\u8868\u793A\u8BE5 action \u5224\u65AD\u7684\u628A\u63E1\u7A0B\u5EA6\u3002`,
+      context
+    ));
+    const action = text2(raw.action).toUpperCase();
+    const allowedActions = /* @__PURE__ */ new Set(["ADD", "MERGE", "SUPERSEDE", "CONFLICT", "IGNORE"]);
+    const proposed = object(raw.mergedCandidate);
+    const mergedCandidate = text2(proposed.title) && text2(proposed.summary) ? proposed : void 0;
+    return {
+      action: allowedActions.has(action) ? action : "IGNORE",
+      existingEventIds: strings2(raw.existingEventIds),
+      ...mergedCandidate ? { mergedCandidate } : {},
+      reason: text2(raw.reason, "\u6A21\u578B\u672A\u63D0\u4F9B\u88C1\u51B3\u7406\u7531\u3002").slice(0, 500),
+      confidence: typeof raw.confidence === "number" ? Math.max(0, Math.min(1, raw.confidence)) : 0.5
+    };
+  };
+  externalMemoryExtractor = async ({ text: source, importedAt }) => {
+    const raw = object(await this.callStructured(
+      "externalMemoryExtractor",
+      `Recover durable memory candidates from the supplied malformed external-memory export. Use only facts present in sourceText; never invent missing facts. Preserve uncertainty and omit unsupported dates. Call ${STRUCTURED_TOOLS.externalMemoryExtractor.name} exactly once with reason and candidates. Each candidate needs a concise title and self-contained summary. Do not return ordinary text.`,
+      { sourceText: source, importedAt }
+    ));
+    const parsed = parseExternalMemoryExport(JSON.stringify({
+      schemaVersion: "stratagate.external-memory.v2",
+      sourceType: "external_ai_memory_export",
+      candidates: Array.isArray(raw.candidates) ? raw.candidates : []
+    }));
+    return { candidates: parsed.candidates, reason: text2(raw.reason, parsed.reason) };
+  };
   async callStructured(kind, system, payload) {
-    const session = this.sessions.getStore();
-    if (!session) throw new Error("StrataGate model callback ran without a DSH session");
-    const baseRoute = this.resolveRoute(session);
+    const execution = this.sessions.getStore();
+    if (!execution) throw new Error("StrataGate model callback ran without an execution context");
+    const baseRoute = this.resolveRoute(execution.session);
     const routeKey = `${baseRoute.provider}\0${baseRoute.model}`;
     let useOff = await this.shouldUseOff(baseRoute);
     let lastError;
@@ -4652,7 +5073,7 @@ ${JSON_RETRY_INSTRUCTION}`,
           function: { name: STRUCTURED_TOOLS[kind].name }
         },
         maxTokens: this.config.maxOutputTokens,
-        sessionId: session.id,
+        sessionId: execution.sessionId,
         purpose: "compaction"
       };
       try {
@@ -4801,7 +5222,7 @@ ${JSON_RETRY_INSTRUCTION}`,
     }
   }
   resolveRoute(session) {
-    const request = session.requestHeader()?.config;
+    const request = session?.requestHeader()?.config;
     if (this.config.provider && this.config.model) {
       return { provider: this.config.provider, model: this.config.model };
     }
@@ -5047,6 +5468,8 @@ var StrataGateRuntime = class {
   migrationTimers = /* @__PURE__ */ new Map();
   derivationTimers = /* @__PURE__ */ new Map();
   derivationRuns = /* @__PURE__ */ new Map();
+  adminSnapshotCache = /* @__PURE__ */ new Map();
+  externalImportRuns = /* @__PURE__ */ new Map();
   ingestTail = Promise.resolve();
   settingsTail = Promise.resolve();
   batchSequence = 0;
@@ -5388,6 +5811,7 @@ var StrataGateRuntime = class {
     }
     const settled = await Promise.allSettled(this.spaces.values());
     await Promise.allSettled(this.derivationRuns.values());
+    await Promise.allSettled(this.externalImportRuns.values());
     await Promise.all(settled.flatMap((result) => result.status === "fulfilled" ? [result.value.close()] : []));
     if (flushError !== void 0) throw flushError;
   }
@@ -5406,6 +5830,42 @@ var StrataGateRuntime = class {
       await storage.close();
     }
   }
+  async adminSnapshotEntries() {
+    if (this.config.database === ":memory:" || !existsSync(this.config.database)) return [];
+    const storage = new SqliteStorage({ filename: this.config.database, readonly: true });
+    try {
+      const entries = [];
+      for (const { namespace, revision } of storage.listNamespaceRevisions()) {
+        const opening = this.spaces.get(namespace);
+        if (opening) {
+          const memory = await opening;
+          const currentRevision = memory.storageRevision;
+          const cached2 = this.adminSnapshotCache.get(namespace);
+          const entry2 = cached2?.revision === currentRevision ? cached2 : { namespace, revision: currentRevision, snapshot: memory.exportSnapshot() };
+          this.adminSnapshotCache.set(namespace, entry2);
+          entries.push(entry2);
+          continue;
+        }
+        const cached = this.adminSnapshotCache.get(namespace);
+        if (cached?.revision === revision) {
+          entries.push(cached);
+          continue;
+        }
+        const loaded = await storage.load(namespace);
+        if (!loaded) continue;
+        const entry = { namespace, revision: loaded.revision, snapshot: loaded.snapshot };
+        this.adminSnapshotCache.set(namespace, entry);
+        entries.push(entry);
+      }
+      const activeNamespaces = new Set(entries.map(({ namespace }) => namespace));
+      for (const namespace of this.adminSnapshotCache.keys()) {
+        if (!activeNamespaces.has(namespace)) this.adminSnapshotCache.delete(namespace);
+      }
+      return entries;
+    } finally {
+      await storage.close();
+    }
+  }
   async syncConfiguredSettings() {
     if (this.config.database === ":memory:" || !existsSync(this.config.database)) return;
     const metadata = new DshMetadataStore(this.config.database);
@@ -5434,43 +5894,238 @@ var StrataGateRuntime = class {
     const key = namespace.trim();
     if (!key) throw new TypeError("StrataGate admin namespace must not be empty");
     if (this.config.database === ":memory:" || !existsSync(this.config.database)) return null;
+    const opening = this.spaces.get(key);
+    if (opening) {
+      const memory = await opening;
+      const revision = memory.storageRevision;
+      const cached = this.adminSnapshotCache.get(key);
+      if (cached?.revision === revision) return cached.snapshot;
+      const entry = { namespace: key, revision, snapshot: memory.exportSnapshot() };
+      this.adminSnapshotCache.set(key, entry);
+      return entry.snapshot;
+    }
     const storage = new SqliteStorage({ filename: this.config.database, readonly: true });
     try {
-      return (await storage.load(key))?.snapshot ?? null;
+      const head = storage.listNamespaceRevisions().find(({ namespace: namespace2 }) => namespace2 === key);
+      if (!head) return null;
+      const cached = this.adminSnapshotCache.get(key);
+      if (cached?.revision === head.revision) return cached.snapshot;
+      const loaded = await storage.load(key);
+      if (!loaded) return null;
+      const entry = { namespace: key, revision: loaded.revision, snapshot: loaded.snapshot };
+      this.adminSnapshotCache.set(key, entry);
+      return entry.snapshot;
     } finally {
       await storage.close();
     }
   }
-  /** Import a v2 external-AI export from the admin UI. */
-  async adminImportExternalMemory(namespace, text3) {
+  externalImportView(job) {
+    return {
+      jobId: job.id,
+      status: job.status,
+      processedCount: job.processedCount,
+      totalCount: job.totalCount,
+      recoveredFromInvalidJson: job.recoveredFromInvalidJson,
+      parseError: job.parseError,
+      lastError: job.lastError,
+      sourceBlockId: job.sourceBlockId,
+      importedCount: job.importedCount,
+      createdAt: job.createdAt,
+      updatedAt: job.updatedAt,
+      decisions: job.decisions.map(({ matches: _matches, mergedCandidate: _mergedCandidate, ...decision }) => decision),
+      requiresConfirmationCount: job.decisions.filter(({ requiresConfirmation }) => requiresConfirmation).length
+    };
+  }
+  async refreshExternalImportMemory(namespace, memory) {
+    if (this.config.database === ":memory:" || !existsSync(this.config.database)) return;
+    const storage = new SqliteStorage({ filename: this.config.database, readonly: true });
+    try {
+      const head = storage.listNamespaceRevisions().find((entry) => entry.namespace === namespace);
+      if (head && head.revision !== memory.storageRevision) await memory.reloadFromStorage();
+    } finally {
+      await storage.close();
+    }
+  }
+  async refreshActiveExternalImportMemory(namespace) {
+    const opening = this.spaces.get(namespace);
+    if (!opening) return;
+    await (await opening).reloadFromStorage();
+  }
+  async retryExternalImportWrite(namespace, operation) {
+    let lastConflict;
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+      const { memory, owned } = await this.openAdminMemory(namespace);
+      try {
+        await this.refreshExternalImportMemory(namespace, memory);
+        const result = await operation(memory);
+        if (owned) await this.refreshActiveExternalImportMemory(namespace);
+        return result;
+      } catch (error) {
+        if (!(error instanceof StorageConflictError)) throw error;
+        lastConflict = error;
+        if (!owned) await memory.reloadFromStorage();
+      } finally {
+        if (owned) await memory.close();
+      }
+    }
+    throw lastConflict ?? new Error(`Unable to update external memory import ${namespace}`);
+  }
+  takeSuccessfulResponses() {
+    return typeof this.models.takeSuccessfulResponses === "function" ? this.models.takeSuccessfulResponses() : [];
+  }
+  async persistExternalImportResponses(namespace, responses) {
+    if (responses.length === 0) return;
+    await this.retryExternalImportWrite(namespace, (memory) => memory.recordSuccessfulModelResponses(responses));
+  }
+  scheduleExternalMemoryImport(namespace, jobId) {
+    if (this.closed || this.externalImportRuns.has(jobId)) return;
+    const run = (async () => {
+      while (!this.closed) {
+        let job = null;
+        let work = null;
+        const prepared = await this.openAdminMemory(namespace);
+        try {
+          await this.refreshExternalImportMemory(namespace, prepared.memory);
+          job = prepared.memory.getExternalMemoryImportJob(jobId);
+          if (!job) return;
+          if (job.status === "processing") {
+            work = await prepared.memory.prepareNextExternalMemoryImport(jobId);
+          } else if (job.status !== "extracting") return;
+        } finally {
+          if (prepared.owned) await prepared.memory.close();
+        }
+        try {
+          if (job.status === "extracting") {
+            const recovered = await this.models.runDetached(`admin-import-recovery:${jobId}`, () => this.models.externalMemoryExtractor({ text: job.text, importedAt: job.importedAt }));
+            const responses2 = this.takeSuccessfulResponses();
+            await this.retryExternalImportWrite(namespace, (memory) => memory.completeExternalMemoryFallback(jobId, recovered));
+            await this.persistExternalImportResponses(namespace, responses2);
+            continue;
+          }
+          if (!work) return;
+          let decision;
+          let responses = [];
+          if (work.deterministicDecision) {
+            decision = work.deterministicDecision;
+          } else {
+            decision = await this.models.runDetached(`admin-import:${jobId}`, () => this.models.externalMemoryDecider({
+              candidate: structuredClone(work.candidate),
+              matches: structuredClone(work.matches)
+            }));
+            responses = this.takeSuccessfulResponses();
+          }
+          await this.retryExternalImportWrite(namespace, (memory) => memory.completeNextExternalMemoryImport(
+            work.jobId,
+            work.index,
+            decision,
+            work.matches,
+            work.forceConfirmation
+          ));
+          await this.persistExternalImportResponses(namespace, responses);
+        } catch (error) {
+          if (error instanceof StorageConflictError) {
+            this.onIngestError(error);
+            return;
+          }
+          try {
+            await this.retryExternalImportWrite(namespace, (memory) => memory.failExternalMemoryImportJob(jobId, error));
+          } catch (persistError) {
+            this.onIngestError(persistError);
+          }
+          return;
+        }
+      }
+    })().catch((error) => this.onIngestError(error)).finally(() => {
+      this.externalImportRuns.delete(jobId);
+    });
+    this.externalImportRuns.set(jobId, run);
+  }
+  /** Create a durable analysis job and return before model-backed work begins. */
+  async adminPreviewExternalMemory(namespace, text3) {
     const key = namespace.trim();
     if (!key) throw new TypeError("StrataGate admin namespace must not be empty");
+    if (!text3.trim()) throw new TypeError("External memory text must not be empty");
     await this.flush();
-    const active = this.spaces.get(key);
-    let memory;
-    let owned = false;
-    if (active) {
-      memory = await active;
-    } else {
-      if (this.config.database === ":memory:" || !existsSync(this.config.database)) {
-        throw new Error(`Unknown StrataGate namespace: ${key}`);
+    const { memory, owned } = await this.openAdminMemory(key);
+    try {
+      await this.refreshExternalImportMemory(key, memory);
+      const job = await memory.createExternalMemoryImportJob(text3);
+      this.scheduleExternalMemoryImport(key, job.id);
+      return this.externalImportView(job);
+    } finally {
+      if (owned) await memory.close();
+    }
+  }
+  async adminExternalMemoryStatus(namespace, jobId) {
+    const key = namespace.trim();
+    if (!key) throw new TypeError("StrataGate admin namespace must not be empty");
+    const { memory, owned } = await this.openAdminMemory(key);
+    try {
+      await this.refreshExternalImportMemory(key, memory);
+      const jobs = memory.listExternalMemoryImportJobs();
+      const job = jobId ? jobs.find(({ id }) => id === jobId) : [...jobs].sort((left, right) => right.createdAt.localeCompare(left.createdAt))[0];
+      if (!job) return { job: null };
+      if (job.status === "extracting" || job.status === "processing") this.scheduleExternalMemoryImport(key, job.id);
+      return this.externalImportView(job);
+    } finally {
+      if (owned) await memory.close();
+    }
+  }
+  async adminRetryExternalMemory(namespace, jobId) {
+    const key = namespace.trim();
+    let lastConflict;
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+      const { memory, owned } = await this.openAdminMemory(key);
+      try {
+        await this.refreshExternalImportMemory(key, memory);
+        const job = await memory.retryExternalMemoryImportJob(jobId);
+        this.scheduleExternalMemoryImport(key, job.id);
+        return this.externalImportView(job);
+      } catch (error) {
+        if (!(error instanceof StorageConflictError)) throw error;
+        lastConflict = error;
+        if (!owned) await memory.reloadFromStorage();
+      } finally {
+        if (owned) await memory.close();
       }
-      memory = await StrataGate.open({
-        database: this.config.database,
-        namespace: key,
-        blockTurnSize: this.blockTurnSize,
-        blockDecayLambda: this.blockDecayLambda,
-        graphProjector: this.models.graphProjector,
-        disableElementProjection: true
-      });
-      owned = true;
     }
+    throw lastConflict;
+  }
+  async adminCommitExternalMemory(namespace, jobId, choices) {
+    const key = namespace.trim();
+    const { memory, owned } = await this.openAdminMemory(key);
     try {
-      const result = await memory.importExternalMemory({
-        text: text3,
-        decider: async () => ({ action: "ADD" })
+      await this.refreshExternalImportMemory(key, memory);
+      const job = memory.getExternalMemoryImportJob(jobId);
+      if (!job) throw new Error("\u627E\u4E0D\u5230\u5BFC\u5165\u4EFB\u52A1");
+      if (job.status !== "ready" && job.status !== "awaiting_confirmation") {
+        throw new Error("\u5BFC\u5165\u5206\u6790\u5C1A\u672A\u5B8C\u6210");
+      }
+      const selected = new Map(choices.filter(({ index, action }) => Number.isSafeInteger(index) && ["ADD", "MERGE", "SUPERSEDE", "CONFLICT", "IGNORE"].includes(action)).map(({ index, action }) => [index, action]));
+      const decisions = job.decisions.map((decision, index) => {
+        if (!decision.requiresConfirmation) return decision;
+        const action = selected.get(index) ?? "IGNORE";
+        const needsTarget = action === "MERGE" || action === "SUPERSEDE" || action === "CONFLICT";
+        if (needsTarget && decision.existingEventIds.length === 0) {
+          return { ...decision, action: "IGNORE", existingEventIds: [], reason: "\u7528\u6237\u9009\u62E9\u7684\u64CD\u4F5C\u6CA1\u6709\u53EF\u5173\u8054\u65E7\u8BB0\u5FC6\uFF0C\u5DF2\u5B89\u5168\u5FFD\u7565" };
+        }
+        return {
+          ...decision,
+          action,
+          existingEventIds: action === "ADD" || action === "IGNORE" ? [] : decision.existingEventIds,
+          reason: `\u7528\u6237\u786E\u8BA4\uFF1A${action}`
+        };
+      });
+      const result = await memory.commitExternalMemoryImport({
+        text: job.text,
+        importedAt: job.importedAt,
+        baseRevision: memory.storageRevision,
+        candidates: job.candidates,
+        decisions
       });
+      const completed = await memory.completeExternalMemoryImportJob(job.id, result);
       return {
+        ...this.externalImportView(completed),
         sourceBlockId: result.sourceBlockId,
         decisions: result.decisions,
         importedCount: result.addedEvents.length,
@@ -5480,6 +6135,19 @@ var StrataGateRuntime = class {
       if (owned) await memory.close();
     }
   }
+  async adminUndoExternalMemory(namespace, sourceBlockId) {
+    const key = namespace.trim();
+    const { memory, owned } = await this.openAdminMemory(key);
+    try {
+      await this.refreshExternalImportMemory(key, memory);
+      const result = await memory.undoExternalMemoryImport(sourceBlockId);
+      const job = memory.listExternalMemoryImportJobs().find((candidate) => candidate.sourceBlockId === sourceBlockId);
+      if (job) await memory.markExternalMemoryImportUndone(job.id);
+      return result;
+    } finally {
+      if (owned) await memory.close();
+    }
+  }
   adminWorkspaceName(namespace) {
     const remembered = this.workspaceNames.get(namespace);
     if (remembered) return remembered;
@@ -5725,6 +6393,24 @@ var StrataGateRuntime = class {
     timer.unref?.();
     this.migrationTimers.set(namespace, timer);
   }
+  async openAdminMemory(namespace) {
+    const active = this.spaces.get(namespace);
+    if (active) return { memory: await active, owned: false };
+    if (this.config.database === ":memory:" || !existsSync(this.config.database)) {
+      throw new Error(`Unknown StrataGate namespace: ${namespace}`);
+    }
+    return {
+      memory: await StrataGate.open({
+        database: this.config.database,
+        namespace,
+        blockTurnSize: this.blockTurnSize,
+        blockDecayLambda: this.blockDecayLambda,
+        graphProjector: this.models.graphProjector,
+        disableElementProjection: true
+      }),
+      owned: true
+    };
+  }
   rememberWorkspace(namespace, cwd) {
     const name2 = workspaceDisplayName(cwd);
     this.workspaceNames.set(namespace, name2);
@@ -6230,6 +6916,7 @@ function registerMemoryTools(ctx, runtime) {
 }
 
 // src/web.ts
+import { createHash as createHash2 } from "node:crypto";
 import { createRequire } from "node:module";
 
 // src/graph-clustering.ts
@@ -6467,14 +7154,17 @@ var AdminHttpError = class extends Error {
   }
   status;
 };
-async function overview(runtime) {
-  const namespaces = await runtime.adminNamespaces();
+async function overview(runtime, cachedEntries) {
+  const entries = cachedEntries ?? await Promise.all((await runtime.adminNamespaces()).map(async (namespace) => ({
+    namespace,
+    revision: 0,
+    snapshot: await runtime.adminSnapshot(namespace)
+  })));
   const rows = [];
-  for (const namespace of namespaces) {
-    const snapshot = await runtime.adminSnapshot(namespace);
+  for (const { namespace, snapshot } of entries) {
     if (!snapshot) continue;
     const failedJobs = snapshot.extractionJobs.filter(({ status }) => status === "failed").length + snapshot.graphProjectionJobs.filter(({ status }) => status === "failed").length;
-    const processingJobs = snapshot.extractionJobs.filter(({ status }) => status === "running").length + snapshot.graphProjectionJobs.filter(({ status }) => status === "pending" || status === "running").length;
+    const processingJobs = snapshot.summaryJobs.filter(({ status, nextRetryAt }) => status === "pending" || status === "running" || status === "failed" && nextRetryAt !== null).length + snapshot.extractionJobs.filter(({ status, nextRetryAt }) => status === "running" || status === "failed" && nextRetryAt !== null).length + snapshot.graphProjectionJobs.filter(({ status }) => status === "pending" || status === "running").length;
     const failedJobDetails = [
       ...snapshot.extractionJobs.filter(({ status }) => status === "failed").map((job) => ({
         id: job.blockId,
@@ -6591,10 +7281,41 @@ async function importExternalMemory(runtime, req) {
     throw new AdminHttpError(400, "\u5BFC\u5165\u8BF7\u6C42\u7F3A\u5C11 JSON body");
   }
   const namespace = typeof body.namespace === "string" ? body.namespace.trim() : "";
-  const text3 = typeof body.text === "string" ? body.text.trim() : "";
   if (!namespace) throw new AdminHttpError(400, "namespace is required");
-  if (!text3) throw new AdminHttpError(400, "text is required");
-  return runtime.adminImportExternalMemory(namespace, text3);
+  const operation = typeof body.operation === "string" ? body.operation : "preview";
+  if (operation === "preview") {
+    const text3 = typeof body.text === "string" ? body.text.trim() : "";
+    if (!text3) throw new AdminHttpError(400, "text is required");
+    return runtime.adminPreviewExternalMemory(namespace, text3);
+  }
+  if (operation === "status") {
+    const jobId = typeof body.jobId === "string" ? body.jobId.trim() : void 0;
+    return runtime.adminExternalMemoryStatus(namespace, jobId);
+  }
+  if (operation === "retry") {
+    const jobId = typeof body.jobId === "string" ? body.jobId.trim() : "";
+    if (!jobId) throw new AdminHttpError(400, "jobId is required");
+    return runtime.adminRetryExternalMemory(namespace, jobId);
+  }
+  if (operation === "commit") {
+    const jobId = typeof body.jobId === "string" ? body.jobId.trim() : "";
+    if (!jobId) throw new AdminHttpError(400, "jobId is required");
+    const allowed = /* @__PURE__ */ new Set(["ADD", "MERGE", "SUPERSEDE", "CONFLICT", "IGNORE"]);
+    const choices = Array.isArray(body.choices) ? body.choices.flatMap((value) => {
+      if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+      const item = value;
+      const index = item.index;
+      const action = typeof item.action === "string" ? item.action.toUpperCase() : "IGNORE";
+      return Number.isSafeInteger(index) && allowed.has(action) ? [{ index, action }] : [];
+    }) : [];
+    return runtime.adminCommitExternalMemory(namespace, jobId, choices);
+  }
+  if (operation === "undo") {
+    const sourceBlockId = typeof body.sourceBlockId === "string" ? body.sourceBlockId.trim() : "";
+    if (!sourceBlockId) throw new AdminHttpError(400, "sourceBlockId is required");
+    return runtime.adminUndoExternalMemory(namespace, sourceBlockId);
+  }
+  throw new AdminHttpError(400, "operation must be preview, status, retry, commit, or undo");
 }
 function externalMemoryPrompt() {
   return { prompt: EXTERNAL_MEMORY_EXPORT_PROMPT_ZH_CN, schemaVersion: "stratagate.external-memory.v2" };
@@ -6943,6 +7664,73 @@ async function audit(runtime, url) {
     items: receipts.slice(offset, offset + limit).map((receipt) => receiptSources(snapshot, receipt))
   };
 }
+function requestHeader(req, name2) {
+  const headers = req.headers ?? {};
+  const key = Object.keys(headers).find((candidate) => candidate.toLocaleLowerCase() === name2.toLocaleLowerCase());
+  const value = key ? headers[key] : void 0;
+  return Array.isArray(value) ? value.join(", ") : value ?? "";
+}
+async function dashboard(runtime, url, ifNoneMatch) {
+  const entries = await runtime.adminSnapshotEntries();
+  const requestedNamespace = url.searchParams.get("namespace")?.trim() ?? "";
+  const selected = entries.find(({ namespace }) => namespace === requestedNamespace) ?? entries[0];
+  const threadId = url.searchParams.get("threadId")?.trim() ?? "";
+  const revisionKey = entries.map(({ namespace, revision }) => `${namespace}:${revision}`).join("|");
+  const etag = `"${createHash2("sha256").update(`${revisionKey}\0${selected?.namespace ?? ""}\0${threadId}`).digest("base64url").slice(0, 24)}"`;
+  if (ifNoneMatch.split(",").map((value) => value.trim()).includes(etag)) return { etag, notModified: true };
+  const overviewValue = await overview(runtime, entries);
+  if (!selected) {
+    return { etag, notModified: false, body: { namespace: null, overview: overviewValue, data: null, processing: false } };
+  }
+  const snapshotRuntime = {
+    adminSnapshot: async (namespace) => namespace === selected.namespace ? selected.snapshot : null
+  };
+  const memoryUrl = (kind, limit) => {
+    const target = new URL(url);
+    target.searchParams.set("namespace", selected.namespace);
+    target.searchParams.set("kind", kind);
+    if (limit) target.searchParams.set("limit", limit);
+    return target;
+  };
+  const [eventResult, graphResult, blockResult, auditResult] = await Promise.all([
+    memories(snapshotRuntime, memoryUrl("events", "200")),
+    memories(snapshotRuntime, memoryUrl("graph")),
+    memories(snapshotRuntime, memoryUrl("blocks", "200")),
+    audit(snapshotRuntime, memoryUrl("audit", "100"))
+  ]);
+  const selectedOverview = overviewValue.namespaces?.find(({ namespace }) => namespace === selected.namespace);
+  return {
+    etag,
+    notModified: false,
+    body: {
+      namespace: selected.namespace,
+      revision: selected.revision,
+      overview: overviewValue,
+      processing: Number(selectedOverview?.processingJobs ?? 0) > 0,
+      data: {
+        events: eventResult.items ?? [],
+        graph: graphResult,
+        blocks: blockResult.items ?? [],
+        openBlock: blockResult.openBlock ?? null,
+        conversations: blockResult.conversations ?? [],
+        activeThreadId: blockResult.activeThreadId ?? null,
+        audit: auditResult.items ?? []
+      }
+    }
+  };
+}
+function sendDashboard(res, result) {
+  res.setHeader("ETag", result.etag);
+  res.setHeader("Cache-Control", "private, no-cache");
+  if (result.notModified) {
+    res.statusCode = 304;
+    res.end("");
+    return;
+  }
+  res.statusCode = 200;
+  res.setHeader("Content-Type", "application/json; charset=utf-8");
+  res.end(JSON.stringify(redactValue(result.body)));
+}
 async function handleAdminRequest(runtime, req, res) {
   try {
     const url = new URL(req.url ?? "/", "http://localhost");
@@ -6954,10 +7742,20 @@ async function handleAdminRequest(runtime, req, res) {
       if (req.method !== "PATCH") throw new AdminHttpError(405, "StrataGate Block expansion requires PATCH");
       sendJson(res, 200, await expandBlock(runtime, url));
     } else if (path === "/api/stratagate/import") {
-      if (req.method === "GET") sendJson(res, 200, externalMemoryPrompt());
-      else if (req.method === "POST") sendJson(res, 200, await importExternalMemory(runtime, req));
+      if (req.method === "GET") {
+        const operation = url.searchParams.get("operation");
+        if (operation === "status") {
+          const namespace = url.searchParams.get("namespace")?.trim() ?? "";
+          if (!namespace) throw new AdminHttpError(400, "namespace is required");
+          const jobId = url.searchParams.get("jobId")?.trim() || void 0;
+          sendJson(res, 200, await runtime.adminExternalMemoryStatus(namespace, jobId));
+        } else {
+          sendJson(res, 200, externalMemoryPrompt());
+        }
+      } else if (req.method === "POST") sendJson(res, 200, await importExternalMemory(runtime, req));
       else throw new AdminHttpError(405, "External memory import requires GET or POST");
     } else if (req.method !== "GET") throw new AdminHttpError(405, "StrataGate memory data is read-only");
+    else if (path === "/api/stratagate/dashboard") sendDashboard(res, await dashboard(runtime, url, requestHeader(req, "if-none-match")));
     else if (path === "/api/stratagate/overview") sendJson(res, 200, await overview(runtime));
     else if (path === "/api/stratagate/memories") sendJson(res, 200, await memories(runtime, url));
     else if (path === "/api/stratagate/sources") sendJson(res, 200, await sources(runtime, url));