@cortexkit/opencode-magic-context 0.31.3 → 0.31.5

package/dist/index.js

@@ -490,7 +490,7 @@ __export(exports_util, {
   jsonStringifyReplacer: () => jsonStringifyReplacer,
   joinValues: () => joinValues,
   issue: () => issue,
-  isPlainObject: () => isPlainObject3,
+  isPlainObject: () => isPlainObject,
   isObject: () => isObject,
   hexToUint8Array: () => hexToUint8Array,
   getSizableOrigin: () => getSizableOrigin,
@@ -655,7 +655,7 @@ function slugify(input) {
 function isObject(data) {
   return typeof data === "object" && data !== null && !Array.isArray(data);
 }
-function isPlainObject3(o) {
+function isPlainObject(o) {
   if (isObject(o) === false)
     return false;
   const ctor = o.constructor;
@@ -672,7 +672,7 @@ function isPlainObject3(o) {
   return true;
 }
 function shallowClone(o) {
-  if (isPlainObject3(o))
+  if (isPlainObject(o))
     return { ...o };
   if (Array.isArray(o))
     return [...o];
@@ -812,7 +812,7 @@ function omit(schema, mask) {
   return clone(schema, def);
 }
 function extend(schema, shape) {
-  if (!isPlainObject3(shape)) {
+  if (!isPlainObject(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
   const checks = schema._zod.def.checks;
@@ -835,7 +835,7 @@ function extend(schema, shape) {
   return clone(schema, def);
 }
 function safeExtend(schema, shape) {
-  if (!isPlainObject3(shape)) {
+  if (!isPlainObject(shape)) {
     throw new Error("Invalid input to safeExtend: expected a plain object");
   }
   const def = mergeDefs(schema._zod.def, {
@@ -2318,7 +2318,7 @@ function mergeValues(a, b) {
   if (a instanceof Date && b instanceof Date && +a === +b) {
     return { valid: true, data: a };
   }
-  if (isPlainObject3(a) && isPlainObject3(b)) {
+  if (isPlainObject(a) && isPlainObject(b)) {
     const bKeys = Object.keys(b);
     const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
     const newObj = { ...a, ...b };
@@ -3575,7 +3575,7 @@ var init_schemas = __esm(() => {
     $ZodType.init(inst, def);
     inst._zod.parse = (payload, ctx) => {
       const input = payload.value;
-      if (!isPlainObject3(input)) {
+      if (!isPlainObject(input)) {
         payload.issues.push({
           expected: "record",
           code: "invalid_type",
@@ -16662,6 +16662,22 @@ function extractLatestAssistantText(messages) {
   return getTextParts(latest).map((part) => part.text).join(`
 `) || null;
 }
+function hasLengthCappedOutput(value) {
+  if (Array.isArray(value))
+    return value.some((item) => hasLengthCappedOutput(item));
+  if (!isRecord(value))
+    return false;
+  if (value.length_capped === true || value.lengthCapped === true)
+    return true;
+  const finishReason = value.finish_reason ?? value.finishReason;
+  if (typeof finishReason === "string") {
+    const normalized = finishReason.toLowerCase();
+    if (normalized === "length" || normalized === "max_tokens" || normalized === "max_output_tokens") {
+      return true;
+    }
+  }
+  return Object.values(value).some((item) => hasLengthCappedOutput(item));
+}
 var init_assistant_message_extractor = () => {};
 
 // src/shared/keep-subagents.ts
@@ -17330,7 +17346,8 @@ function isMidTurn(_deps, sessionId) {
 }
 function isMidTurnFromOpenCodeDb(db, sessionId) {
   const latestAssistant = db.prepare(`SELECT id,
-                    json_extract(data, '$.finish') as finish
+                    json_extract(data, '$.finish') as finish,
+                    time_created as timeCreated
              FROM message
              WHERE session_id = ?
                AND json_extract(data, '$.role') = 'assistant'
@@ -17338,6 +17355,8 @@ function isMidTurnFromOpenCodeDb(db, sessionId) {
              LIMIT 1`).get(sessionId);
   if (typeof latestAssistant?.id !== "string")
     return false;
+  if (hasNewerRealUserMessage(db, sessionId, latestAssistant.timeCreated))
+    return false;
   if (latestAssistant.finish === "tool-calls")
     return true;
   const partRows = db.prepare("SELECT data FROM part WHERE session_id = ? AND message_id = ?").all(sessionId, latestAssistant.id);
@@ -17352,6 +17371,18 @@ function isMidTurnFromOpenCodeDb(db, sessionId) {
     }
   });
 }
+function hasNewerRealUserMessage(db, sessionId, latestAssistantTimeCreated) {
+  if (typeof latestAssistantTimeCreated !== "number")
+    return false;
+  const row = db.prepare(`SELECT 1 as one
+             FROM message
+             WHERE session_id = ?
+               AND time_created > ?
+               AND json_extract(data, '$.role') = 'user'
+               AND COALESCE(json_extract(data, '$.synthetic'), 0) NOT IN (1, 'true')
+             LIMIT 1`).get(sessionId, latestAssistantTimeCreated);
+  return row?.one === 1;
+}
 function getMessageTimesFromOpenCodeDb(sessionId, messageIds) {
   const result = new Map;
   if (messageIds.length === 0)
@@ -150820,12 +150851,19 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
   let totalTokens = 0;
   let messagesProcessed = 0;
   let lastOrdinal = startOrdinal - 1;
+  let highestScannedOrdinal = startOrdinal - 1;
   let lastMessageId = "";
   let firstMessageId = "";
   let currentBlock = null;
   let pendingNoiseMeta = [];
   let commitClusters = 0;
   let lastFlushedRole = "";
+  function recordFilteredNoise(meta3) {
+    pendingNoiseMeta.push(meta3);
+    if (!currentBlock) {
+      highestScannedOrdinal = Math.max(highestScannedOrdinal, meta3.ordinal);
+    }
+  }
   function flushCurrentBlock() {
     if (!currentBlock)
       return true;
@@ -150841,6 +150879,7 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
     if (!firstMessageId)
       firstMessageId = currentBlock.meta[0]?.messageId ?? "";
     lastOrdinal = currentBlock.meta[currentBlock.meta.length - 1]?.ordinal ?? currentBlock.endOrdinal;
+    highestScannedOrdinal = Math.max(highestScannedOrdinal, lastOrdinal);
     lastMessageId = currentBlock.meta[currentBlock.meta.length - 1]?.messageId ?? "";
     messagesProcessed += currentBlock.meta.length;
     lines.push(blockText);
@@ -150864,7 +150903,7 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
     if (msg.role === "user" && !hasMeaningfulUserText(msg.parts)) {
       const tcSummaries = extractToolCallSummaries(msg.parts);
       if (tcSummaries.length === 0) {
-        pendingNoiseMeta.push(meta3);
+        recordFilteredNoise(meta3);
         continue;
       }
       const tcText = tcSummaries.join(" / ");
@@ -150896,7 +150935,7 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
     const compacted = compactTextForSummary(allParts.join(" / "), msg.role);
     const text = compacted.text;
     if (!text) {
-      pendingNoiseMeta.push(meta3);
+      recordFilteredNoise(meta3);
       continue;
     }
     const msgHasNarrative = textParts.length > 0;
@@ -150923,7 +150962,9 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
     };
     pendingNoiseMeta = [];
   }
-  flushCurrentBlock();
+  if (flushCurrentBlock() && pendingNoiseMeta.length > 0) {
+    highestScannedOrdinal = Math.max(highestScannedOrdinal, pendingNoiseMeta[pendingNoiseMeta.length - 1]?.ordinal ?? highestScannedOrdinal);
+  }
   const toolOnlyRanges = [];
   for (const range of flushedToolOnlyBlocks) {
     const last = toolOnlyRanges[toolOnlyRanges.length - 1];
@@ -150940,7 +150981,7 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
     endMessageId: lastMessageId,
     messageCount: messagesProcessed,
     tokenEstimate: totalTokens,
-    hasMore: lastOrdinal < (eligibleEndOrdinal !== undefined ? Math.min(eligibleEndOrdinal - 1, totalMessageCount) : totalMessageCount),
+    hasMore: Math.max(lastOrdinal, highestScannedOrdinal) < (eligibleEndOrdinal !== undefined ? Math.min(eligibleEndOrdinal - 1, totalMessageCount) : totalMessageCount),
     text: lines.join(`
 `),
     lines: lineMeta,
@@ -150966,7 +151007,7 @@ function normalizeIndexText(text) {
 function getLastIndexedStatement(db) {
   let stmt = lastIndexedStatements.get(db);
   if (!stmt) {
-    stmt = db.prepare("SELECT last_indexed_ordinal FROM message_history_index WHERE session_id = ?");
+    stmt = db.prepare("SELECT last_indexed_ordinal, dirty_floor_ordinal FROM message_history_index WHERE session_id = ?");
     lastIndexedStatements.set(db, stmt);
   }
   return stmt;
@@ -150987,6 +151028,22 @@ function getUpsertIndexStatement(db) {
   }
   return stmt;
 }
+function getUpsertCleanIndexStatement(db) {
+  let stmt = upsertCleanIndexStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("INSERT INTO message_history_index (session_id, last_indexed_ordinal, dirty_floor_ordinal, updated_at, harness) VALUES (?, ?, 0, ?, ?) ON CONFLICT(session_id) DO UPDATE SET last_indexed_ordinal = excluded.last_indexed_ordinal, dirty_floor_ordinal = 0, updated_at = excluded.updated_at");
+    upsertCleanIndexStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getUpsertDirtyFloorStatement(db) {
+  let stmt = upsertDirtyFloorStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("INSERT INTO message_history_index (session_id, last_indexed_ordinal, dirty_floor_ordinal, updated_at, harness) VALUES (?, ?, ?, ?, ?) ON CONFLICT(session_id) DO UPDATE SET last_indexed_ordinal = MAX(message_history_index.last_indexed_ordinal, excluded.last_indexed_ordinal), dirty_floor_ordinal = CASE WHEN message_history_index.dirty_floor_ordinal <= 0 THEN excluded.dirty_floor_ordinal WHEN excluded.dirty_floor_ordinal <= 0 THEN message_history_index.dirty_floor_ordinal ELSE MIN(message_history_index.dirty_floor_ordinal, excluded.dirty_floor_ordinal) END, updated_at = excluded.updated_at");
+    upsertDirtyFloorStatements.set(db, stmt);
+  }
+  return stmt;
+}
 function getDeleteFtsStatement(db) {
   let stmt = deleteFtsStatements.get(db);
   if (!stmt) {
@@ -150995,6 +151052,14 @@ function getDeleteFtsStatement(db) {
   }
   return stmt;
 }
+function getDeleteFtsFromOrdinalStatement(db) {
+  let stmt = deleteFtsFromOrdinalStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("DELETE FROM message_history_fts WHERE session_id = ? AND CAST(message_ordinal AS INTEGER) >= ?");
+    deleteFtsFromOrdinalStatements.set(db, stmt);
+  }
+  return stmt;
+}
 function getDeleteIndexStatement(db) {
   let stmt = deleteIndexStatements.get(db);
   if (!stmt) {
@@ -151015,6 +151080,14 @@ function getLastIndexedOrdinal(db, sessionId) {
   const row = getLastIndexedStatement(db).get(sessionId);
   return typeof row?.last_indexed_ordinal === "number" ? row.last_indexed_ordinal : 0;
 }
+function getDirtyIndexFloor(db, sessionId) {
+  const row = getLastIndexedStatement(db).get(sessionId);
+  return typeof row?.dirty_floor_ordinal === "number" && row.dirty_floor_ordinal > 0 ? row.dirty_floor_ordinal : null;
+}
+function markMessageIndexDirty(db, sessionId, floorOrdinal) {
+  const dirtyFloor = Math.max(1, Math.floor(floorOrdinal));
+  getUpsertDirtyFloorStatement(db).run(sessionId, getLastIndexedOrdinal(db, sessionId), dirtyFloor, Date.now(), getHarness());
+}
 function isMessageAlreadyIndexed(db, sessionId, messageId) {
   const row = getCountIndexedMessageStatement(db).get(sessionId, messageId);
   return (typeof row?.count === "number" ? row.count : 0) > 0;
@@ -151088,7 +151161,15 @@ function indexMessagesAfterOrdinal(db, sessionId, messages, lastIndexedOrdinal,
   db.exec("BEGIN IMMEDIATE");
   let committed = false;
   try {
-    const effectiveWatermark = Math.max(lastIndexedOrdinal, getLastIndexedOrdinal(db, sessionId));
+    let effectiveWatermark = Math.max(lastIndexedOrdinal, getLastIndexedOrdinal(db, sessionId));
+    const dirtyFloor = getDirtyIndexFloor(db, sessionId);
+    if (dirtyFloor !== null) {
+      const rewindOrdinal = Math.max(1, Math.min(dirtyFloor, finalWatermark + 1));
+      if (rewindOrdinal <= finalWatermark) {
+        getDeleteFtsFromOrdinalStatement(db).run(sessionId, rewindOrdinal);
+      }
+      effectiveWatermark = Math.min(effectiveWatermark, rewindOrdinal - 1);
+    }
     const insertMessage = getInsertMessageStatement(db);
     for (const message of messages) {
       if (message.ordinal <= effectiveWatermark) {
@@ -151105,7 +151186,7 @@ function indexMessagesAfterOrdinal(db, sessionId, messages, lastIndexedOrdinal,
       inserted++;
     }
     const newWatermark = Math.max(effectiveWatermark, finalWatermark);
-    getUpsertIndexStatement(db).run(sessionId, newWatermark, now, getHarness());
+    getUpsertCleanIndexStatement(db).run(sessionId, newWatermark, now, getHarness());
     db.exec("COMMIT");
     committed = true;
   } finally {
@@ -151117,14 +151198,17 @@ function indexMessagesAfterOrdinal(db, sessionId, messages, lastIndexedOrdinal,
   }
   return inserted;
 }
-var lastIndexedStatements, insertMessageStatements, upsertIndexStatements, deleteFtsStatements, deleteIndexStatements, countIndexedMessageStatements;
+var lastIndexedStatements, insertMessageStatements, upsertIndexStatements, upsertCleanIndexStatements, upsertDirtyFloorStatements, deleteFtsStatements, deleteFtsFromOrdinalStatements, deleteIndexStatements, countIndexedMessageStatements;
 var init_message_index = __esm(async () => {
   init_compression_depth_storage();
   await init_read_session_chunk();
   lastIndexedStatements = new WeakMap;
   insertMessageStatements = new WeakMap;
   upsertIndexStatements = new WeakMap;
+  upsertCleanIndexStatements = new WeakMap;
+  upsertDirtyFloorStatements = new WeakMap;
   deleteFtsStatements = new WeakMap;
+  deleteFtsFromOrdinalStatements = new WeakMap;
   deleteIndexStatements = new WeakMap;
   countIndexedMessageStatements = new WeakMap;
 });
@@ -151163,6 +151247,7 @@ function healNullTextColumns(db) {
     ["cache_ttl", ""],
     ["last_nudge_band", ""],
     ["last_nudge_level", ""],
+    ["channel2_nudge_claim_token", ""],
     ["last_transform_error", ""],
     ["nudge_anchor_message_id", ""],
     ["nudge_anchor_text", ""],
@@ -151295,23 +151380,39 @@ function uniqueSorted(values) {
 function placeholders(values) {
   return values.map(() => "?").join(", ");
 }
+function defaultWorkspaceShareCategories() {
+  return [...DEFAULT_WORKSPACE_SHARE_CATEGORIES];
+}
+function warnInvalidShareCategories(reason, raw) {
+  log("[magic-context] WARN: invalid workspace share_categories; sharing no foreign memory categories", {
+    reason,
+    raw
+  });
+}
 function normalizeShareCategories(raw) {
-  if (raw === null || raw === undefined)
-    return null;
-  if (typeof raw !== "string")
-    return null;
+  if (raw === null || raw === undefined) {
+    return defaultWorkspaceShareCategories();
+  }
+  if (typeof raw !== "string") {
+    warnInvalidShareCategories("not a string", raw);
+    return [];
+  }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch {
-    return null;
+    warnInvalidShareCategories("malformed JSON", raw);
+    return [];
+  }
+  if (!Array.isArray(parsed)) {
+    warnInvalidShareCategories("not a JSON array", raw);
+    return [];
   }
-  if (!Array.isArray(parsed))
-    return null;
   const categories = [];
   for (const value of parsed) {
     if (typeof value !== "string" || !VALID_SHARE_CATEGORIES.has(value)) {
-      return null;
+      warnInvalidShareCategories("unknown category", raw);
+      return [];
     }
     if (!categories.includes(value))
       categories.push(value);
@@ -151320,16 +151421,33 @@ function normalizeShareCategories(raw) {
 }
 function selectWorkspaceShareCategories(db, identities) {
   const candidates = uniqueSorted(identities.filter((identity) => identity.length > 0));
-  if (candidates.length === 0 || !tableExists(db, "workspace_members") || !tableExists(db, "workspaces") || !columnExists(db, "workspaces", "share_categories")) {
+  if (candidates.length === 0 || !tableExists(db, "workspace_members")) {
     return null;
   }
+  const hasMembership = Boolean(db.prepare(`SELECT 1
+                   FROM workspace_members
+                  WHERE project_path IN (${placeholders(candidates)})
+                  LIMIT 1`).get(...candidates));
+  if (!hasMembership)
+    return null;
+  if (!tableExists(db, "workspaces")) {
+    log("[magic-context] WARN: workspace member has no workspaces table; sharing no foreign memory categories");
+    return [];
+  }
+  if (!columnExists(db, "workspaces", "share_categories")) {
+    return defaultWorkspaceShareCategories();
+  }
   const row = db.prepare(`SELECT workspace.share_categories AS shareCategories
                FROM workspace_members AS member
                JOIN workspaces AS workspace ON workspace.id = member.workspace_id
               WHERE member.project_path IN (${placeholders(candidates)})
               ORDER BY workspace.id ASC
               LIMIT 1`).get(...candidates);
-  return normalizeShareCategories(row?.shareCategories ?? null);
+  if (!row) {
+    log("[magic-context] WARN: workspace member has no workspace share_categories row; sharing no foreign memory categories");
+    return [];
+  }
+  return normalizeShareCategories(row.shareCategories);
 }
 function resolveWorkspaceShareCategories(db, projectIdentity) {
   return selectWorkspaceShareCategories(db, [projectIdentity]);
@@ -151434,7 +151552,7 @@ function computeWorkspaceEpochFingerprint(db, identities) {
   const hash2 = createHash2("sha256");
   hash2.update("share_categories", "utf8");
   hash2.update("\x00");
-  hash2.update(shareCategories === null ? "ALL" : JSON.stringify(shareCategories), "utf8");
+  hash2.update(shareCategories === null ? "NO_WORKSPACE" : JSON.stringify(shareCategories), "utf8");
   hash2.update(`
 `);
   for (const identity of canonical) {
@@ -151506,11 +151624,13 @@ function bumpEpochsForWorkspaceMemberSet(db, identities, now = Date.now()) {
     throw error51;
   }
 }
-var VALID_SHARE_CATEGORIES;
+var VALID_SHARE_CATEGORIES, DEFAULT_WORKSPACE_SHARE_CATEGORIES;
 var init_workspaces = __esm(() => {
+  init_logger();
   init_constants();
   init_project_identity2();
   VALID_SHARE_CATEGORIES = new Set(V2_MEMORY_CATEGORIES);
+  DEFAULT_WORKSPACE_SHARE_CATEGORIES = ["CONSTRAINTS"];
 });
 
 // src/features/magic-context/migrations.ts
@@ -153995,6 +154115,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
     CREATE TABLE IF NOT EXISTS message_history_index (
       session_id TEXT PRIMARY KEY,
       last_indexed_ordinal INTEGER NOT NULL DEFAULT 0,
+      dirty_floor_ordinal INTEGER NOT NULL DEFAULT 0,
       updated_at INTEGER NOT NULL,
       harness TEXT NOT NULL DEFAULT 'opencode'
     );
@@ -154024,6 +154145,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       last_nudge_level TEXT DEFAULT '',
       channel2_nudge_state TEXT DEFAULT '',
       channel2_nudge_claimed_at INTEGER DEFAULT 0,
+      channel2_nudge_claim_token TEXT DEFAULT '',
       last_emergency_input_sample INTEGER DEFAULT 0,
       last_transform_error TEXT DEFAULT '',
       nudge_anchor_message_id TEXT DEFAULT '',
@@ -154270,6 +154392,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "session_meta", "last_nudge_level", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "channel2_nudge_state", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "channel2_nudge_claimed_at", "INTEGER DEFAULT 0");
+  ensureColumn(db, "session_meta", "channel2_nudge_claim_token", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "last_emergency_input_sample", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "last_transform_error", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "nudge_anchor_message_id", "TEXT DEFAULT ''");
@@ -154482,6 +154605,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
         ON transform_decisions(session_id, harness);
     `);
   ensureColumn(db, "tags", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
+  ensureColumn(db, "message_history_index", "dirty_floor_ordinal", "INTEGER NOT NULL DEFAULT 0");
   ensureColumn(db, "pending_ops", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
   ensureColumn(db, "source_contents", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
   ensureColumn(db, "compartments", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
@@ -154496,7 +154620,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
 function healWedgedChannel2Claims(db) {
   try {
     const staleBefore = Date.now() - CHANNEL2_CLAIM_TTL_MS;
-    db.prepare("UPDATE session_meta SET channel2_nudge_state = 'pending', channel2_nudge_claimed_at = 0 WHERE channel2_nudge_state = 'claimed' AND (channel2_nudge_claimed_at IS NULL OR channel2_nudge_claimed_at = 0 OR channel2_nudge_claimed_at <= ?)").run(staleBefore);
+    db.prepare("UPDATE session_meta SET channel2_nudge_state = 'pending', channel2_nudge_claimed_at = 0, channel2_nudge_claim_token = '' WHERE channel2_nudge_state = 'claimed' AND (channel2_nudge_claimed_at IS NULL OR channel2_nudge_claimed_at = 0 OR channel2_nudge_claimed_at <= ?)").run(staleBefore);
   } catch {}
 }
 function openDatabase(dbPathOrOptions) {
@@ -155230,19 +155354,42 @@ function getChannel2NudgeState(db, sessionId) {
   const raw = result.channel2_nudge_state;
   return raw === "pending" || raw === "claimed" || raw === "delivered" ? raw : "";
 }
-function setChannel2NudgeState(db, sessionId, state) {
+function getChannel2NudgeClaim(db, sessionId) {
+  const result = db.prepare("SELECT channel2_nudge_state, channel2_nudge_claimed_at, channel2_nudge_claim_token FROM session_meta WHERE session_id = ?").get(sessionId);
+  const rawState = typeof result?.channel2_nudge_state === "string" ? result.channel2_nudge_state : "";
+  const state = rawState === "pending" || rawState === "claimed" || rawState === "delivered" ? rawState : "";
+  return {
+    state,
+    claimedAt: typeof result?.channel2_nudge_claimed_at === "number" ? result.channel2_nudge_claimed_at : 0,
+    claimToken: typeof result?.channel2_nudge_claim_token === "string" ? result.channel2_nudge_claim_token : ""
+  };
+}
+function casChannel2NudgeState(db, sessionId, from, to) {
+  let changed = false;
   db.transaction(() => {
     ensureSessionMetaRow(db, sessionId);
-    const claimedAt = state === "claimed" ? Date.now() : 0;
-    db.prepare("UPDATE session_meta SET channel2_nudge_state = ?, channel2_nudge_claimed_at = ? WHERE session_id = ?").run(state, claimedAt, sessionId);
+    const claimedAt = to === "claimed" ? Date.now() : 0;
+    const result = db.prepare("UPDATE session_meta SET channel2_nudge_state = ?, channel2_nudge_claimed_at = ?, channel2_nudge_claim_token = '' WHERE session_id = ? AND channel2_nudge_state = ?").run(to, claimedAt, sessionId, from);
+    changed = (result.changes ?? 0) > 0;
   })();
+  return changed;
 }
-function casChannel2NudgeState(db, sessionId, from, to) {
+function claimChannel2NudgeState(db, sessionId, claimToken) {
+  let changed = false;
+  db.transaction(() => {
+    ensureSessionMetaRow(db, sessionId);
+    const result = db.prepare("UPDATE session_meta SET channel2_nudge_state = 'claimed', channel2_nudge_claimed_at = ?, channel2_nudge_claim_token = ? WHERE session_id = ? AND channel2_nudge_state = 'pending'").run(Date.now(), claimToken, sessionId);
+    changed = (result.changes ?? 0) > 0;
+  })();
+  return changed;
+}
+function casChannel2NudgeClaim(db, sessionId, to, claimToken) {
   let changed = false;
   db.transaction(() => {
     ensureSessionMetaRow(db, sessionId);
     const claimedAt = to === "claimed" ? Date.now() : 0;
-    const result = db.prepare("UPDATE session_meta SET channel2_nudge_state = ?, channel2_nudge_claimed_at = ? WHERE session_id = ? AND channel2_nudge_state = ?").run(to, claimedAt, sessionId, from);
+    const nextClaimToken = to === "claimed" ? claimToken : "";
+    const result = db.prepare("UPDATE session_meta SET channel2_nudge_state = ?, channel2_nudge_claimed_at = ?, channel2_nudge_claim_token = ? WHERE session_id = ? AND channel2_nudge_state = 'claimed' AND channel2_nudge_claim_token = ?").run(to, claimedAt, nextClaimToken, sessionId, claimToken);
     changed = (result.changes ?? 0) > 0;
   })();
   return changed;
@@ -166118,12 +166265,41 @@ function pushNotification(type, payload, sessionId) {
     queue = kept.sort((a, b) => a.id - b.id);
   }
 }
-function drainNotifications(lastReceivedId = 0, sessionId) {
+function cursor(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function drainNotifications(lastReceivedId = 0, sessionId, options = {}) {
+  const sessionCursor = cursor(lastReceivedId);
+  if (options.globalOnly) {
+    queue = queue.filter((notification) => notification.sessionId !== undefined || notification.id > sessionCursor);
+    return queue.filter((notification) => notification.sessionId === undefined && notification.id > sessionCursor);
+  }
+  if (options.sessionOnly) {
+    if (sessionId === undefined)
+      return [];
+    queue = queue.filter((notification) => notification.sessionId !== sessionId || notification.id > sessionCursor);
+    return queue.filter((notification) => notification.sessionId === sessionId && notification.id > sessionCursor);
+  }
+  if (sessionId !== undefined && options.globalLastReceivedId !== undefined) {
+    const globalCursor = cursor(options.globalLastReceivedId);
+    queue = queue.filter((notification) => {
+      if (notification.sessionId === undefined)
+        return notification.id > globalCursor;
+      if (notification.sessionId === sessionId)
+        return notification.id > sessionCursor;
+      return true;
+    });
+    return queue.filter((notification) => {
+      if (notification.sessionId === undefined)
+        return notification.id > globalCursor;
+      return notification.sessionId === sessionId && notification.id > sessionCursor;
+    });
+  }
   const matchesClient = (notification) => sessionId === undefined || notification.sessionId === undefined || notification.sessionId === sessionId;
-  if (lastReceivedId > 0) {
-    queue = queue.filter((notification) => !(notification.id <= lastReceivedId && matchesClient(notification)));
+  if (sessionCursor > 0) {
+    queue = queue.filter((notification) => !(notification.id <= sessionCursor && matchesClient(notification)));
   }
-  return queue.filter((notification) => notification.id > lastReceivedId && matchesClient(notification));
+  return queue.filter((notification) => notification.id > sessionCursor && matchesClient(notification));
 }
 function isTuiConnected(sessionId) {
   if (sinks.size === 0)
@@ -167962,6 +168138,14 @@ function getSaveEmbeddingStatement(db) {
   }
   return stmt;
 }
+function getSaveEmbeddingIfHashMatchesStatement(db) {
+  let stmt = saveEmbeddingIfHashMatchesStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("INSERT INTO memory_embeddings (memory_id, embedding, model_id) SELECT ?, ?, ? FROM memories WHERE id = ? AND normalized_hash = ? ON CONFLICT(memory_id, model_id) DO UPDATE SET embedding = excluded.embedding");
+    saveEmbeddingIfHashMatchesStatements.set(db, stmt);
+  }
+  return stmt;
+}
 function getLoadAllEmbeddingsStatement(db) {
   let stmt = loadAllEmbeddingsStatements.get(db);
   if (!stmt) {
@@ -167990,6 +168174,10 @@ function saveEmbedding(db, memoryId, embedding, modelId) {
   const blob = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
   getSaveEmbeddingStatement(db).run(memoryId, blob, modelId);
 }
+function saveEmbeddingIfHashMatches(db, memoryId, embedding, modelId, normalizedHash) {
+  const blob = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
+  return getSaveEmbeddingIfHashMatchesStatement(db).run(memoryId, blob, modelId, memoryId, normalizedHash).changes > 0;
+}
 function loadAllEmbeddings(db, projectPath, modelId) {
   const rows = getLoadAllEmbeddingsStatement(db).all(projectPath, modelId).filter(isEmbeddingRow);
   const embeddings = new Map;
@@ -168021,9 +168209,10 @@ function getMemoryEmbedCoverage(db, projectPath, modelId) {
     embedded: typeof row?.embedded === "number" ? row.embedded : 0
   };
 }
-var saveEmbeddingStatements, loadAllEmbeddingsStatements, deleteEmbeddingStatements, getStoredModelIdStatements, clearAllEmbeddingsStatements, clearModelEmbeddingsStatements, getDistinctStoredModelIdsStatements;
+var saveEmbeddingStatements, saveEmbeddingIfHashMatchesStatements, loadAllEmbeddingsStatements, deleteEmbeddingStatements, getStoredModelIdStatements, clearAllEmbeddingsStatements, clearModelEmbeddingsStatements, getDistinctStoredModelIdsStatements;
 var init_storage_memory_embeddings = __esm(() => {
   saveEmbeddingStatements = new WeakMap;
+  saveEmbeddingIfHashMatchesStatements = new WeakMap;
   loadAllEmbeddingsStatements = new WeakMap;
   deleteEmbeddingStatements = new WeakMap;
   getStoredModelIdStatements = new WeakMap;
@@ -168848,12 +169037,12 @@ function isUnembeddedMemoryRow(row) {
   if (row === null || typeof row !== "object")
     return false;
   const candidate = row;
-  return typeof candidate.id === "number" && typeof candidate.content === "string";
+  return typeof candidate.id === "number" && typeof candidate.content === "string" && typeof candidate.normalized_hash === "string";
 }
 function getLoadUnembeddedMemoriesStatement(db) {
   let stmt = loadUnembeddedMemoriesStatements.get(db);
   if (!stmt) {
-    stmt = db.prepare("SELECT m.id AS id, m.content AS content FROM memories m LEFT JOIN memory_embeddings me ON m.id = me.memory_id AND me.model_id = ? WHERE m.project_path = ? AND m.status = 'active' AND me.memory_id IS NULL LIMIT ?");
+    stmt = db.prepare("SELECT m.id AS id, m.content AS content, m.normalized_hash AS normalized_hash FROM memories m LEFT JOIN memory_embeddings me ON m.id = me.memory_id AND me.model_id = ? WHERE m.project_path = ? AND m.status = 'active' AND me.memory_id IS NULL LIMIT ?");
     loadUnembeddedMemoriesStatements.set(db, stmt);
   }
   return stmt;
@@ -168876,8 +169065,9 @@ async function embedUnembeddedMemoriesForProject(db, projectIdentity, batchSize
         const embedding = result.vectors[index];
         if (!embedding)
           continue;
-        saveEmbedding(db, memory.id, embedding, result.modelId);
-        embeddedCount += 1;
+        if (saveEmbeddingIfHashMatches(db, memory.id, embedding, result.modelId, memory.normalized_hash)) {
+          embeddedCount += 1;
+        }
       }
     })();
     return embeddedCount;
@@ -169343,6 +169533,9 @@ function isMemorySourceType(value) {
 function isVerificationStatus(value) {
   return typeof value === "string" && value in VERIFICATION_STATUS_LOOKUP;
 }
+function isUniqueConstraintError(error51) {
+  return error51 instanceof Error && "code" in error51 && error51.code === "SQLITE_CONSTRAINT_UNIQUE";
+}
 function isNullableString(value) {
   return value === null || typeof value === "string";
 }
@@ -169508,28 +169701,55 @@ function getMemoryCountsByStatusStatement(db) {
   }
   return stmt;
 }
-function insertMemory(db, input) {
-  const now = Date.now();
-  const normalizedHash = computeNormalizedHash(input.content);
+function buildInsertMemoryValues(input, normalizedHash, now, includeImportance) {
   const insertValues = [
     input.projectPath,
     input.category,
     input.content,
     normalizedHash
   ];
-  if (hasMemoryImportanceColumn(db)) {
+  if (includeImportance) {
     insertValues.push(input.importance ?? 50);
   }
   insertValues.push(input.sourceSessionId ?? null, input.sourceType ?? "historian", 1, 0, now, now, now, now, null, "active", input.expiresAt ?? null, "unverified", null, null, null, input.metadataJson ?? null);
-  const result = getInsertMemoryStatement(db).run(...insertValues);
-  const insertedResult = result;
-  const inserted = getMemoryById(db, Number(insertedResult.lastInsertRowid));
+  return insertValues;
+}
+function loadInsertedMemory(db, rowid) {
+  const inserted = getMemoryById(db, Number(rowid));
   if (!inserted) {
     throw new Error("Failed to load inserted memory row");
   }
+  return inserted;
+}
+function insertMemory(db, input) {
+  const now = Date.now();
+  const normalizedHash = computeNormalizedHash(input.content);
+  const insertValues = buildInsertMemoryValues(input, normalizedHash, now, hasMemoryImportanceColumn(db));
+  const result = getInsertMemoryStatement(db).run(...insertValues);
+  const insertedResult = result;
+  const inserted = loadInsertedMemory(db, insertedResult.lastInsertRowid);
   invalidateProject(input.projectPath);
   return inserted;
 }
+function insertMemoryIdempotent(db, input) {
+  try {
+    return { memory: insertMemory(db, input), inserted: true };
+  } catch (error51) {
+    if (!isUniqueConstraintError(error51)) {
+      throw error51;
+    }
+    const normalizedHash = computeNormalizedHash(input.content);
+    const existing = getMemoryByHash(db, input.projectPath, input.category, normalizedHash);
+    if (!existing) {
+      throw error51;
+    }
+    updateMemorySeenCount(db, existing.id);
+    return {
+      memory: getMemoryById(db, existing.id) ?? existing,
+      inserted: false
+    };
+  }
+}
 function getMemoryByHash(db, projectPath, category, normalizedHash) {
   const result = getMemoryByHashStatement(db).get(projectPath, category, normalizedHash);
   if (!isMemoryRow(result)) {
@@ -180435,6 +180655,23 @@ function recursiveByteLength(value) {
   }
   return String(value).length;
 }
+function updateFnv1a32(hash2, text) {
+  let next = hash2;
+  for (let index = 0;index < text.length; index += 1) {
+    next ^= text.charCodeAt(index);
+    next = Math.imul(next, FNV1A_32_PRIME) >>> 0;
+  }
+  return next;
+}
+function contentStringsHash(fields) {
+  let hash2 = FNV1A_32_OFFSET;
+  for (const field of fields) {
+    hash2 = updateFnv1a32(hash2, `${field.length}:`);
+    hash2 = updateFnv1a32(hash2, field);
+    hash2 = updateFnv1a32(hash2, "\x00");
+  }
+  return hash2.toString(16).padStart(8, "0");
+}
 function rawPartVersion(part) {
   return part.__magicContextPartUpdatedAt ?? part.updated_at ?? part.updatedAt ?? part.version ?? part.revision ?? "";
 }
@@ -180782,13 +181019,12 @@ function buildTrueRawTokenIndex(sessionId, messages, options) {
 function partContentFingerprint(part) {
   if (!isRecord(part))
     return `${typeof part}:${recursiveByteLength(part)}`;
-  const type = partType(part);
   const tool = toolSignalFromPart(part);
   if (tool) {
-    return `${type}:${tool.callId}:${tool.inputText.length}:${tool.outputText.length}`;
+    return contentStringsHash([tool.inputText, tool.outputText]);
   }
   const text = firstStringField(part, ["text", "thinking", "reasoning", "content", "url"]) ?? "";
-  return `${type}:${text.length}`;
+  return contentStringsHash([text]);
 }
 function computeRawRangeFingerprint(messages, startInclusive, endExclusive) {
   const pieces = [];
@@ -180813,7 +181049,7 @@ function invalidateTrueRawTokenCache(args) {
   }
   args.reason;
 }
-var MAX_MESSAGE_CACHE_ENTRIES = 1e5, MAX_MESSAGE_CACHE_KEY_BYTES, messageEstimateCache, messageEstimateCacheBytes = 0, EMPTY_BREAKDOWN;
+var MAX_MESSAGE_CACHE_ENTRIES = 1e5, MAX_MESSAGE_CACHE_KEY_BYTES, FNV1A_32_OFFSET = 2166136261, FNV1A_32_PRIME = 16777619, messageEstimateCache, messageEstimateCacheBytes = 0, EMPTY_BREAKDOWN;
 var init_read_session_true_raw_tokens = __esm(() => {
   init_read_session_formatting();
   MAX_MESSAGE_CACHE_KEY_BYTES = 64 * 1024 * 1024;
@@ -184824,6 +185060,15 @@ async function executeContextRecompWithResult(deps, options = {}) {
       published: false
     };
   }
+  options.onLeaseAcquired?.();
+  if (isWrapupInProgress(deps.db, sessionId)) {
+    sessionLog(sessionId, "recomp skipped: /ctx-wrapup became active");
+    releaseCompartmentLease(deps.db, sessionId, holderId);
+    return {
+      message: "## Magic Recomp — Skipped\n\n/ctx-wrapup is already compacting this session. Wait for it to finish, then try `/ctx-recomp` again.",
+      published: false
+    };
+  }
   const renewal = startLeaseRenewal(deps, holderId);
   const runnerDeps = withPublishedCallback({ ...deps, compartmentLeaseHolderId: holderId });
   const promise2 = options.range ? executePartialRecompInternal(runnerDeps, options.range) : executeContextRecompInternal(runnerDeps);
@@ -186338,12 +186583,108 @@ function migrateLegacyExperimental(rawConfig, warnings) {
 }
 
 // src/config/project-security.ts
+init_magic_context();
 var HIDDEN_AGENT_KEYS = ["historian", "dreamer", "sidekick"];
+var HISTORIAN_USER_ONLY_FIELDS = ["model", "fallback_models"];
 var AGENT_ESCALATION_FIELDS = ["prompt", "permission", "tools", "system_prompt"];
 var EMBEDDING_DESTINATION_FIELDS = ["endpoint", "provider"];
-function isPlainObject(value) {
+var PERCENTAGE_THRESHOLD_REASON = "security: a repository may only raise compaction thresholds above the user's effective value; it cannot force earlier historian work or cloned-repo cost escalation.";
+var TOKEN_THRESHOLD_REASON = "security: a repository may only raise execute_threshold_tokens above the user's trusted token threshold; it cannot force earlier historian work or cloned-repo cost escalation.";
+var TOKEN_THRESHOLD_INTRODUCTION_REASON = "security: a repository cannot introduce a new execute_threshold_tokens override when the user has no trusted token threshold for that key; that could force earlier historian work or cloned-repo cost escalation.";
+function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isValidPercentageThreshold(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 20 && value <= 80;
+}
+function isValidTokenThreshold(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 5000 && value <= 2000000;
+}
+function normalizeTrustedPercentageThresholds(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return { defaultValue: value, overrides: new Map };
+  }
+  if (isPlainObject2(value) && typeof value.default === "number" && Number.isFinite(value.default)) {
+    const overrides = new Map;
+    for (const [key, child] of Object.entries(value)) {
+      if (key === "default")
+        continue;
+      if (typeof child === "number" && Number.isFinite(child)) {
+        overrides.set(key, child);
+      }
+    }
+    return { defaultValue: value.default, overrides };
+  }
+  return { defaultValue: DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, overrides: new Map };
+}
+function normalizeTrustedTokenThresholds(value) {
+  if (!isPlainObject2(value)) {
+    return { defaultValue: undefined, overrides: new Map };
+  }
+  const overrides = new Map;
+  for (const [key, child] of Object.entries(value)) {
+    if (key === "default")
+      continue;
+    if (typeof child === "number" && Number.isFinite(child)) {
+      overrides.set(key, child);
+    }
+  }
+  return {
+    defaultValue: typeof value.default === "number" && Number.isFinite(value.default) ? value.default : undefined,
+    overrides
+  };
+}
+function clonePercentageThresholds(value) {
+  return {
+    defaultValue: value.defaultValue,
+    overrides: new Map(value.overrides)
+  };
+}
+function cloneTokenThresholds(value) {
+  return {
+    defaultValue: value.defaultValue,
+    overrides: new Map(value.overrides)
+  };
+}
+function percentageThresholdsEqual(left, right) {
+  if (left.defaultValue !== right.defaultValue)
+    return false;
+  if (left.overrides.size !== right.overrides.size)
+    return false;
+  for (const [key, value] of left.overrides) {
+    if (right.overrides.get(key) !== value)
+      return false;
+  }
+  return true;
+}
+function setMergedPercentageThreshold(mergedRaw, value) {
+  if (value.overrides.size === 0) {
+    mergedRaw.execute_threshold_percentage = value.defaultValue;
+    return;
+  }
+  const serialized = { default: value.defaultValue };
+  for (const [key, threshold] of value.overrides) {
+    serialized[key] = threshold;
+  }
+  mergedRaw.execute_threshold_percentage = serialized;
+}
+function setMergedTokenThreshold(mergedRaw, value) {
+  if (value.defaultValue === undefined && value.overrides.size === 0) {
+    delete mergedRaw.execute_threshold_tokens;
+    return;
+  }
+  const serialized = {};
+  if (value.defaultValue !== undefined) {
+    serialized.default = value.defaultValue;
+  }
+  for (const [key, threshold] of value.overrides) {
+    serialized[key] = threshold;
+  }
+  mergedRaw.execute_threshold_tokens = serialized;
+}
+function makeProjectThresholdWarning(field, reason) {
+  return `Ignoring ${field} from project config (${reason})`;
+}
 function stripUnsafeProjectConfigFields(projectRaw) {
   const warnings = [];
   if ("auto_update" in projectRaw) {
@@ -186359,7 +186700,7 @@ function stripUnsafeProjectConfigFields(projectRaw) {
     warnings.push("Ignoring sqlite.* from project config (security: SQLite cache/mmap PRAGMAs apply to the " + "process-global shared database handle; only user-level config may set them).");
   }
   const embedding = projectRaw.embedding;
-  if (isPlainObject(embedding)) {
+  if (isPlainObject2(embedding)) {
     const removed = [];
     for (const field of EMBEDDING_DESTINATION_FIELDS) {
       if (field in embedding) {
@@ -186371,9 +186712,22 @@ function stripUnsafeProjectConfigFields(projectRaw) {
       warnings.push(`Ignoring embedding.${removed.join("/")} from project config ` + "(security: a repository cannot choose where private text is embedded).");
     }
   }
+  const historian = projectRaw.historian;
+  if (isPlainObject2(historian)) {
+    const removed = [];
+    for (const field of HISTORIAN_USER_ONLY_FIELDS) {
+      if (field in historian) {
+        delete historian[field];
+        removed.push(field);
+      }
+    }
+    if (removed.length > 0) {
+      warnings.push(`Ignoring historian.${removed.join("/")} from project config ` + "(security: historian model selection is user-level only; a repository cannot force extra compaction cost).");
+    }
+  }
   for (const agentKey of HIDDEN_AGENT_KEYS) {
     const block = projectRaw[agentKey];
-    if (!isPlainObject(block))
+    if (!isPlainObject2(block))
       continue;
     const removed = [];
     for (const field of AGENT_ESCALATION_FIELDS) {
@@ -186388,6 +186742,101 @@ function stripUnsafeProjectConfigFields(projectRaw) {
   }
   return warnings;
 }
+function constrainProjectThresholdOverrides(args) {
+  const warnings = [];
+  const basePercentage = normalizeTrustedPercentageThresholds(args.trustedBaseConfig.execute_threshold_percentage);
+  const baseTokens = normalizeTrustedTokenThresholds(args.trustedBaseConfig.execute_threshold_tokens);
+  if ("execute_threshold_percentage" in args.projectRaw) {
+    const projectValue = args.projectRaw.execute_threshold_percentage;
+    if (isValidPercentageThreshold(projectValue)) {
+      const constrained = clonePercentageThresholds(basePercentage);
+      constrained.defaultValue = Math.max(basePercentage.defaultValue, projectValue);
+      for (const [modelKey, threshold] of basePercentage.overrides) {
+        const raisedThreshold = Math.max(threshold, projectValue);
+        if (raisedThreshold === constrained.defaultValue) {
+          constrained.overrides.delete(modelKey);
+        } else {
+          constrained.overrides.set(modelKey, raisedThreshold);
+        }
+      }
+      setMergedPercentageThreshold(args.mergedRaw, constrained);
+      if (percentageThresholdsEqual(constrained, basePercentage)) {
+        warnings.push(makeProjectThresholdWarning("execute_threshold_percentage", PERCENTAGE_THRESHOLD_REASON));
+      }
+    } else if (isPlainObject2(projectValue)) {
+      const constrained = clonePercentageThresholds(basePercentage);
+      let touchedValidEntry = false;
+      if (isValidPercentageThreshold(projectValue.default)) {
+        touchedValidEntry = true;
+        if (projectValue.default > basePercentage.defaultValue) {
+          constrained.defaultValue = projectValue.default;
+        } else {
+          warnings.push(makeProjectThresholdWarning("execute_threshold_percentage.default", PERCENTAGE_THRESHOLD_REASON));
+        }
+      }
+      for (const [modelKey, rawValue] of Object.entries(projectValue)) {
+        if (modelKey === "default")
+          continue;
+        if (!isValidPercentageThreshold(rawValue))
+          continue;
+        touchedValidEntry = true;
+        const baseValue = basePercentage.overrides.get(modelKey) ?? basePercentage.defaultValue;
+        if (rawValue > baseValue) {
+          if (rawValue === constrained.defaultValue) {
+            constrained.overrides.delete(modelKey);
+          } else {
+            constrained.overrides.set(modelKey, rawValue);
+          }
+        } else {
+          warnings.push(makeProjectThresholdWarning(`execute_threshold_percentage.${modelKey}`, PERCENTAGE_THRESHOLD_REASON));
+        }
+      }
+      if (touchedValidEntry) {
+        setMergedPercentageThreshold(args.mergedRaw, constrained);
+      }
+    }
+  }
+  if ("execute_threshold_tokens" in args.projectRaw && isPlainObject2(args.projectRaw.execute_threshold_tokens)) {
+    const projectValue = args.projectRaw.execute_threshold_tokens;
+    const constrained = cloneTokenThresholds(baseTokens);
+    let touchedValidEntry = false;
+    if (isValidTokenThreshold(projectValue.default)) {
+      touchedValidEntry = true;
+      if (baseTokens.defaultValue === undefined) {
+        warnings.push(makeProjectThresholdWarning("execute_threshold_tokens.default", TOKEN_THRESHOLD_INTRODUCTION_REASON));
+      } else if (projectValue.default > baseTokens.defaultValue) {
+        constrained.defaultValue = projectValue.default;
+      } else {
+        warnings.push(makeProjectThresholdWarning("execute_threshold_tokens.default", TOKEN_THRESHOLD_REASON));
+      }
+    }
+    for (const [modelKey, rawValue] of Object.entries(projectValue)) {
+      if (modelKey === "default")
+        continue;
+      if (!isValidTokenThreshold(rawValue))
+        continue;
+      touchedValidEntry = true;
+      const baseValue = baseTokens.overrides.get(modelKey) ?? baseTokens.defaultValue;
+      if (baseValue === undefined) {
+        warnings.push(makeProjectThresholdWarning(`execute_threshold_tokens.${modelKey}`, TOKEN_THRESHOLD_INTRODUCTION_REASON));
+        continue;
+      }
+      if (rawValue > baseValue) {
+        if (rawValue === constrained.defaultValue) {
+          constrained.overrides.delete(modelKey);
+        } else {
+          constrained.overrides.set(modelKey, rawValue);
+        }
+      } else {
+        warnings.push(makeProjectThresholdWarning(`execute_threshold_tokens.${modelKey}`, TOKEN_THRESHOLD_REASON));
+      }
+    }
+    if (touchedValidEntry) {
+      setMergedTokenThreshold(args.mergedRaw, constrained);
+    }
+  }
+  return warnings;
+}
 function normalizeEndpoint(value) {
   if (typeof value !== "string")
     return;
@@ -186396,13 +186845,13 @@ function normalizeEndpoint(value) {
 }
 function dropInheritedEmbeddingKeyOnRedirect(projectRaw, mergedRaw, userRaw) {
   const projectEmbedding = projectRaw.embedding;
-  if (!isPlainObject(projectEmbedding))
+  if (!isPlainObject2(projectEmbedding))
     return [];
   const redirectsEndpoint = "endpoint" in projectEmbedding;
   if (!redirectsEndpoint)
     return [];
   const userEmbedding = userRaw?.embedding;
-  if (isPlainObject(userEmbedding)) {
+  if (isPlainObject2(userEmbedding)) {
     const projectEndpoint = normalizeEndpoint(projectEmbedding.endpoint);
     const userEndpoint = normalizeEndpoint(userEmbedding.endpoint);
     if (projectEndpoint !== undefined && projectEndpoint === userEndpoint) {
@@ -186413,7 +186862,7 @@ function dropInheritedEmbeddingKeyOnRedirect(projectRaw, mergedRaw, userRaw) {
   if (providesOwnKey)
     return [];
   const mergedEmbedding = mergedRaw.embedding;
-  if (!isPlainObject(mergedEmbedding))
+  if (!isPlainObject2(mergedEmbedding))
     return [];
   if (!("api_key" in mergedEmbedding))
     return [];
@@ -186424,7 +186873,7 @@ function dropInheritedEmbeddingKeyOnRedirect(projectRaw, mergedRaw, userRaw) {
 }
 
 // src/config/prune-config-leaf.ts
-function isPlainObject2(value) {
+function isPlainObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function pruneNestedConfigLeaf(block, relativePath) {
@@ -186435,7 +186884,7 @@ function pruneNestedConfigLeaf(block, relativePath) {
   for (let i = 0;i < relativePath.length - 1; i++) {
     const seg = String(relativePath[i]);
     const child = cursor[seg];
-    if (!isPlainObject2(child)) {
+    if (!isPlainObject3(child)) {
       if (!(seg in cursor))
         return null;
       delete cursor[seg];
@@ -186787,6 +187236,7 @@ function loadPluginConfigDetailed(directory) {
   const projectLoaded = projectDetected.format !== "none" ? loadConfigFileDetailed(projectDetected.path, "project") : projectLegacyFallback.source ? loadConfigFileDetailed(projectLegacyFallback.source.path, "project") : null;
   const allWarnings = [];
   let mergedRaw = {};
+  const trustedBaseConfig = parsePluginConfig(userLoaded?.config ?? {});
   if (userLegacyFallback.source) {
     allWarnings.push(`[user config] reading legacy config from ${userLegacyFallback.source.path} until migration completes; run \`npx @cortexkit/magic-context doctor\` to consolidate into the shared CortexKit location.`);
   } else if (legacyUserUnmigrated) {
@@ -186811,6 +187261,13 @@ function loadPluginConfigDetailed(directory) {
     for (const warning of dropInheritedEmbeddingKeyOnRedirect(projectRaw, mergedRaw, userLoaded?.config)) {
       allWarnings.push(`[project config] ${warning}`);
     }
+    for (const warning of constrainProjectThresholdOverrides({
+      mergedRaw,
+      projectRaw,
+      trustedBaseConfig
+    })) {
+      allWarnings.push(`[project config] ${warning}`);
+    }
   }
   const recoveredTopLevelKeys = [];
   const config2 = parsePluginConfig(mergedRaw, recoveredTopLevelKeys);
@@ -188534,6 +188991,14 @@ function renewLease(db, holderId, leaseKey = DREAMING_LEASE_KEY) {
     return true;
   });
 }
+function runLeaseGuardedWrite(db, holderId, leaseKey, fn) {
+  return runImmediate(db, () => {
+    if (!peekLeaseHolderAndExpiry(db, holderId, leaseKey)) {
+      throw new Error("Dream lease lost before guarded write");
+    }
+    return fn();
+  });
+}
 var LEASE_HEARTBEAT_INTERVAL_MS = 60 * 1000;
 function startLeaseHeartbeat(db, holderId, leaseKey, onLost, intervalMs = LEASE_HEARTBEAT_INTERVAL_MS) {
   let lost = false;
@@ -188692,8 +189157,7 @@ class OpenCodeRetrospectiveRawProvider {
                    LEFT JOIN session_meta m ON m.session_id = sp.session_id
                   WHERE sp.project_path = ? AND sp.harness = 'opencode'
                     AND COALESCE(m.is_subagent, 0) = 0
-                  ORDER BY sp.updated_at DESC, sp.session_id DESC
-                  LIMIT ?`).all(projectIdentity, RETROSPECTIVE_MAX_SESSIONS_PER_RUN);
+                  ORDER BY sp.updated_at ASC, sp.session_id ASC`).all(projectIdentity);
     return rows.map((row) => ({
       sessionId: row.session_id,
       updatedAt: typeof row.updated_at === "number" ? row.updated_at : undefined
@@ -188718,6 +189182,12 @@ class OpenCodeRetrospectiveRawProvider {
       return { messages: [], truncated: false };
     }
   }
+  readOldestMessageTimesSince(sessionIds, sinceMs) {
+    const db = this.resolveDb();
+    if (!db || sessionIds.length === 0)
+      return new Map;
+    return readOpenCodeOldestMessageTimesSince(db, sessionIds, sinceMs);
+  }
   readUserMessagesBefore(sessionId, beforeMs, count) {
     const db = this.resolveDb();
     if (!db)
@@ -188739,13 +189209,28 @@ class OpenCodeRetrospectiveRawProvider {
 async function readRetrospectiveScanWindow(provider, projectIdentity, watermarkMs, overlapUserCount, options) {
   const maxMessages = options?.maxMessagesPerRun ?? RETROSPECTIVE_MAX_MESSAGES_PER_RUN;
   const capPerSession = options?.capPerSession ?? RETROSPECTIVE_MAX_MESSAGES_PER_SESSION;
-  const sessionReadPageSize = Math.max(1, Math.floor(options?.maxSessionsPerRun ?? RETROSPECTIVE_MAX_SESSIONS_PER_RUN));
+  const sessionLimit = Math.max(1, Math.floor(options?.maxSessionsPerRun ?? RETROSPECTIVE_MAX_SESSIONS_PER_RUN));
   try {
-    const sessions = await provider.listProjectSessions(projectIdentity);
+    const allSessions = await provider.listProjectSessions(projectIdentity);
+    const eligibleSessions = allSessions.map((session, index) => ({ session, index })).filter(({ session }) => (session.updatedAt ?? Number.POSITIVE_INFINITY) > watermarkMs);
+    const oldestBySession = provider.readOldestMessageTimesSince ? await provider.readOldestMessageTimesSince(eligibleSessions.map(({ session }) => session.sessionId), watermarkMs) : null;
+    const sessions = (oldestBySession ? eligibleSessions.filter(({ session }) => oldestBySession.has(session.sessionId)) : eligibleSessions).sort((a, b) => {
+      const aFrontier = oldestBySession?.get(a.session.sessionId);
+      const bFrontier = oldestBySession?.get(b.session.sessionId);
+      if (aFrontier !== undefined || bFrontier !== undefined) {
+        return (aFrontier ?? Number.POSITIVE_INFINITY) - (bFrontier ?? Number.POSITIVE_INFINITY) || a.index - b.index;
+      }
+      const aUpdated = a.session.updatedAt ?? Number.POSITIVE_INFINITY;
+      const bUpdated = b.session.updatedAt ?? Number.POSITIVE_INFINITY;
+      const byUpdated = aUpdated - bUpdated;
+      return byUpdated || a.index - b.index;
+    });
+    const sessionsToRead = sessions.slice(0, sessionLimit).map(({ session }) => session);
+    const firstExcludedSession = sessions[sessionLimit]?.session;
+    const firstExcludedPendingTs = firstExcludedSession ? oldestBySession?.get(firstExcludedSession.sessionId) : undefined;
     const sinceReads = [];
-    for (let i = 0;i < sessions.length; i += sessionReadPageSize) {
-      const page = sessions.slice(i, i + sessionReadPageSize);
-      sinceReads.push(...await Promise.all(page.map((session) => provider.readUserMessagesSince(session.sessionId, watermarkMs, capPerSession))));
+    if (sessionsToRead.length > 0) {
+      sinceReads.push(...await Promise.all(sessionsToRead.map((session) => provider.readUserMessagesSince(session.sessionId, watermarkMs, capPerSession))));
     }
     let saturatedFrontier = Number.POSITIVE_INFINITY;
     for (const read of sinceReads) {
@@ -188767,9 +189252,14 @@ async function readRetrospectiveScanWindow(provider, projectIdentity, watermarkM
     if (firstDropped) {
       frontier = Math.min(frontier, firstDropped.ts - 1);
     }
+    if (typeof firstExcludedPendingTs === "number") {
+      frontier = Math.min(frontier, firstExcludedPendingTs - 1);
+    } else if (typeof firstExcludedSession?.updatedAt === "number") {
+      frontier = Math.min(frontier, firstExcludedSession.updatedAt - 1);
+    }
     maxScannedTs = Math.max(watermarkMs, Math.min(maxScannedTs, frontier));
     const keptSessionIds = new Set(keptSince.map((message) => message.sessionId));
-    const overlapSessions = sessions.filter((session) => keptSessionIds.has(session.sessionId));
+    const overlapSessions = sessionsToRead.filter((session) => keptSessionIds.has(session.sessionId));
     const overlapBatches = overlapUserCount > 0 && watermarkMs > 0 ? await Promise.all(overlapSessions.map((session) => provider.readUserMessagesBefore(session.sessionId, watermarkMs, overlapUserCount))) : [];
     const seen = new Set;
     const merged = [];
@@ -188797,6 +189287,24 @@ function readOpenCodeMessagesSince(db, sessionId, sinceMs, capPerSession) {
   const kept = truncated ? rows.slice(0, limit) : rows;
   return { messages: normalizeOpenCodeRows(db, sessionId, kept), truncated };
 }
+function readOpenCodeOldestMessageTimesSince(db, sessionIds, sinceMs) {
+  const result = new Map;
+  const uniqueIds = Array.from(new Set(sessionIds.filter((id) => id.length > 0)));
+  const chunkSize = 500;
+  for (let i = 0;i < uniqueIds.length; i += chunkSize) {
+    const chunk = uniqueIds.slice(i, i + chunkSize);
+    const placeholders3 = chunk.map(() => "?").join(", ");
+    const rows = db.prepare(`SELECT session_id, MIN(time_created) AS oldest_ts
+                   FROM message
+                  WHERE time_created > ? AND session_id IN (${placeholders3})
+                  GROUP BY session_id`).all(sinceMs, ...chunk);
+    for (const row of rows) {
+      if (typeof row.oldest_ts === "number")
+        result.set(row.session_id, row.oldest_ts);
+    }
+  }
+  return result;
+}
 function readOpenCodeUserMessagesBefore(db, sessionId, beforeMs, count) {
   const want = Math.max(1, Math.floor(count));
   const window = Math.max(want * 5, 32);
@@ -189415,6 +189923,39 @@ function hasShareabilitySensitiveText(text) {
 init_memory();
 init_subagent_token_capture();
 
+// src/features/magic-context/dreamer/manifest-parser.ts
+function extractCompleteManifestBody(text, rootName) {
+  const escapedRoot = rootName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const rootMatch = new RegExp(`<${escapedRoot}\\b[^>]*>([\\s\\S]*?)<\\/${escapedRoot}>`, "i").exec(text);
+  if (rootMatch)
+    return rootMatch[1];
+  const hasOpenRoot = new RegExp(`<${escapedRoot}\\b`, "i").test(text);
+  const hasCloseRoot = new RegExp(`<\\/${escapedRoot}>`, "i").test(text);
+  if (hasOpenRoot && !hasCloseRoot) {
+    throw new Error(`${rootName} manifest missing closing root tag`);
+  }
+  throw new Error(`${rootName} manifest missing complete root element`);
+}
+function assertNoDuplicateManifestIds(ids, rootName) {
+  const seen = new Set;
+  for (const id of ids) {
+    if (seen.has(id))
+      throw new Error(`${rootName} manifest contains duplicate id ${id}`);
+    seen.add(id);
+  }
+}
+function assertManifestCoversExactly(ids, expectedIds, rootName) {
+  assertNoDuplicateManifestIds(ids, rootName);
+  for (const id of ids) {
+    if (!expectedIds.has(id))
+      throw new Error(`${rootName} manifest contains unknown id ${id}`);
+  }
+  for (const id of expectedIds) {
+    if (!ids.includes(id))
+      throw new Error(`${rootName} manifest missing id ${id}`);
+  }
+}
+
 // src/features/magic-context/dreamer/classify-prompt.ts
 var SCORING_GUIDANCE = `### How to score importance (1-100)
 Importance decides which memories survive when the injected memory block is over budget: high scores stay in context, low scores drop first. So the score is only useful if it **discriminates** — if most memories land in the same band, you have not classified them, you have just labelled them.
@@ -189481,14 +190022,15 @@ ${renderPool(args.memories)}`;
 var SCOPES = new Set(["project", "ecosystem", "universe"]);
 function parseClassifyManifest(text) {
   const out = [];
-  for (const m of text.matchAll(/<memory\b([^>]*)\/?>/g)) {
+  const body = extractCompleteManifestBody(text, "classify");
+  for (const m of body.matchAll(/<memory\b([^>]*)\/?>/g)) {
     const attrs = m[1];
     const idMatch = attrs.match(/\bid\s*=\s*"(\d+)"/);
     if (!idMatch)
-      continue;
+      throw new Error("classify manifest entry missing numeric id");
     const id = Number.parseInt(idMatch[1], 10);
     if (!Number.isInteger(id))
-      continue;
+      throw new Error("classify manifest entry missing numeric id");
     const entry = { id };
     const impMatch = attrs.match(/\bimportance\s*=\s*"(\d+)"/);
     if (impMatch) {
@@ -189497,18 +190039,23 @@ function parseClassifyManifest(text) {
         entry.importance = Math.max(1, Math.min(100, imp));
     }
     const scopeMatch = attrs.match(/\bscope\s*=\s*"([a-z]+)"/i);
-    if (scopeMatch && SCOPES.has(scopeMatch[1].toLowerCase())) {
-      entry.scope = scopeMatch[1].toLowerCase();
+    if (scopeMatch) {
+      const scope = scopeMatch[1].toLowerCase();
+      if (!SCOPES.has(scope))
+        throw new Error(`classify manifest invalid scope ${scope}`);
+      entry.scope = scope;
     }
     const shareMatch = attrs.match(/\bshareable\s*=\s*"(true|false|1|0)"/i);
     if (shareMatch) {
       const v = shareMatch[1].toLowerCase();
       entry.shareable = v === "true" || v === "1";
     }
-    if (entry.importance !== undefined || entry.scope || entry.shareable !== undefined) {
-      out.push(entry);
+    if (entry.importance === undefined && !entry.scope && entry.shareable === undefined) {
+      throw new Error(`classify manifest entry ${id} missing classification fields`);
     }
+    out.push(entry);
   }
+  assertNoDuplicateManifestIds(out.map((entry) => entry.id), "classify");
   return out;
 }
 
@@ -189643,9 +190190,13 @@ async function classifyOneChunk(args, chunk, anchors, sliceMs, signal) {
         });
       },
       validateOutput: (messages) => {
+        if (hasLengthCappedOutput(messages)) {
+          throw new Error("classify returned length-capped output");
+        }
         const text = extractLatestAssistantText(messages);
         if (!text)
           throw new Error("classify returned no output");
+        parseClassifyManifest(text);
         return text;
       }
     });
@@ -189671,17 +190222,13 @@ async function classifyOneChunk(args, chunk, anchors, sliceMs, signal) {
 }
 function applyClassifications(args, chunk, manifestText) {
   const byId = new Map(chunk.map((m) => [m.id, m]));
-  const parsed = parseClassifyManifest(manifestText).filter((p) => byId.has(p.id));
+  const parsed = parseClassifyManifest(manifestText);
+  assertManifestCoversExactly(parsed.map((entry) => entry.id), new Set(byId.keys()), "classify");
   if (parsed.length === 0)
     return { classified: 0, changed: 0 };
   let classified = 0;
   let changed = 0;
-  let leaseLost = false;
-  args.db.transaction(() => {
-    if (!peekLeaseHolderAndExpiry(args.db, args.holderId, args.leaseKey)) {
-      leaseLost = true;
-      return;
-    }
+  runLeaseGuardedWrite(args.db, args.holderId, args.leaseKey, () => {
     for (const p of parsed) {
       const memory = byId.get(p.id);
       if (!memory)
@@ -189696,9 +190243,7 @@ function applyClassifications(args, chunk, manifestText) {
       if (didChange)
         changed += 1;
     }
-  })();
-  if (leaseLost)
-    throw new Error("Dream lease lost during classify commit");
+  });
   return { classified, changed };
 }
 function recordInvocation(args, startedAt, params) {
@@ -189748,9 +190293,11 @@ var SMART_NOTE_CHECK_LIVENESS_RECHECK_MS = 24 * 60 * 60 * 1000;
 
 class SmartNoteNetworkError extends Error {
   isSmartNoteNetworkError = true;
-  constructor(message) {
+  terminal;
+  constructor(message, options = {}) {
     super(message);
     this.name = "SmartNoteNetworkError";
+    this.terminal = options.terminal ?? false;
   }
 }
 
@@ -189764,6 +190311,9 @@ class SmartNoteSecurityError extends Error {
 function isSmartNoteNetworkError(error51) {
   return error51 instanceof SmartNoteNetworkError || error51 instanceof Error && (error51.name === "SmartNoteNetworkError" || error51.message.includes("SmartNoteNetworkError") || error51.message.includes("SMART_NOTE_NETWORK"));
 }
+function isTerminalSmartNoteNetworkError(error51) {
+  return error51 instanceof SmartNoteNetworkError && error51.terminal;
+}
 function parseSmartNoteManifest(json2) {
   if (!json2)
     return { capabilities: [] };
@@ -189793,6 +190343,7 @@ function stringArray(value) {
 var DNS_TIMEOUT_MS = 3000;
 var DEFAULT_HTTP_TIMEOUT_MS = 5000;
 var DEFAULT_HTTP_BODY_LIMIT_BYTES = 64 * 1024;
+var MAX_HTTP_ADDRESS_CANDIDATES = 4;
 var defaultResolver = {
   async lookup(hostname3, signal) {
     return await withAbortAndTimeout(dnsLookup(hostname3, { all: true, verbatim: true }), signal, DNS_TIMEOUT_MS, "DNS lookup timed out").then((rows) => rows.filter((row) => row.family === 4 || row.family === 6).map((row) => ({ address: row.address, family: row.family })));
@@ -189829,18 +190380,21 @@ async function guardedSmartNoteHttpGet(input, options) {
   });
   const timeoutMs = options.timeoutMs ?? DEFAULT_HTTP_TIMEOUT_MS;
   const bodyLimitBytes = options.bodyLimitBytes ?? DEFAULT_HTTP_BODY_LIMIT_BYTES;
+  const requestAddress = options.requestAddress ?? requestValidatedAddress;
+  const candidates = validation.addresses.slice(0, MAX_HTTP_ADDRESS_CANDIDATES);
   let lastError;
-  for (const candidate of validation.addresses) {
+  for (const candidate of candidates) {
     try {
-      return await requestValidatedAddress(validation, candidate, {
+      return await requestAddress(validation, candidate, {
         signal: options.signal,
         timeoutMs,
         bodyLimitBytes
       });
     } catch (error51) {
       lastError = error51;
-      if (error51 instanceof SmartNoteSecurityError || options.signal.aborted)
+      if (error51 instanceof SmartNoteSecurityError || options.signal.aborted || isTerminalSmartNoteNetworkError(error51)) {
         throw error51;
+      }
     }
   }
   throw toNetworkError(lastError, "all validated addresses failed");
@@ -189910,7 +190464,9 @@ function requestValidatedAddress(validation, candidate, options) {
         const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
         bytes += buf.byteLength;
         if (bytes > options.bodyLimitBytes) {
-          request2.destroy(new SmartNoteNetworkError("SMART_NOTE_NETWORK: response body too large"));
+          reject(new SmartNoteNetworkError("SMART_NOTE_NETWORK: response body too large", { terminal: true }));
+          response.destroy();
+          request2.destroy();
           return;
         }
         chunks.push(buf);
@@ -189927,10 +190483,16 @@ function requestValidatedAddress(validation, candidate, options) {
         resolve4({ status, body: Buffer.concat(chunks).toString("utf8") });
       });
     });
-    const onAbort = () => request2.destroy(new SmartNoteNetworkError("SMART_NOTE_NETWORK: aborted"));
+    const onAbort = () => {
+      reject(new SmartNoteNetworkError("SMART_NOTE_NETWORK: aborted"));
+      request2.destroy();
+    };
     options.signal.addEventListener("abort", onAbort, { once: true });
     request2.on("timeout", () => {
-      request2.destroy(new SmartNoteNetworkError("SMART_NOTE_NETWORK: request timed out"));
+      reject(new SmartNoteNetworkError("SMART_NOTE_NETWORK: request timed out", {
+        terminal: true
+      }));
+      request2.destroy();
     });
     request2.on("error", (error51) => {
       options.signal.removeEventListener("abort", onAbort);
@@ -190251,6 +190813,20 @@ function withSandboxLock(fn) {
 var DEFAULT_TIMEOUT_MS = 2000;
 var DEFAULT_HEAP_LIMIT_BYTES = 8 * 1024 * 1024;
 var DEFAULT_STACK_LIMIT_BYTES = 512 * 1024;
+function resolveCapabilitiesForRun(options, signal) {
+  if (options.capabilityFactory) {
+    return options.capabilityFactory(signal);
+  }
+  if (options.capabilities) {
+    return options.capabilities;
+  }
+  throw new Error("smart-note check requires capabilities");
+}
+function throwIfRunAborted(signal) {
+  if (signal.aborted) {
+    throw signal.reason ?? new Error("smart-note check aborted");
+  }
+}
 async function runCompiledSmartNoteCheck(options) {
   return withSandboxLock(() => runCompiledSmartNoteCheckLocked(options));
 }
@@ -190258,17 +190834,24 @@ async function runCompiledSmartNoteCheckLocked(options) {
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const controller = new AbortController;
   const externalAbort = () => controller.abort(options.signal?.reason);
-  options.signal?.addEventListener("abort", externalAbort, { once: true });
+  if (options.signal?.aborted) {
+    externalAbort();
+  } else {
+    options.signal?.addEventListener("abort", externalAbort, { once: true });
+  }
   const timer = setTimeout(() => controller.abort(new Error("smart-note check timed out")), timeoutMs);
   try {
+    throwIfRunAborted(controller.signal);
+    const capabilities = resolveCapabilitiesForRun(options, controller.signal);
     const deadline = Date.now() + timeoutMs;
     const quickjs = await getAsyncModule();
+    throwIfRunAborted(controller.signal);
     const context = quickjs.newContext();
     try {
       context.runtime.setMemoryLimit(options.heapLimitBytes ?? DEFAULT_HEAP_LIMIT_BYTES);
       context.runtime.setMaxStackSize(options.stackLimitBytes ?? DEFAULT_STACK_LIMIT_BYTES);
       context.runtime.setInterruptHandler(() => controller.signal.aborted || Date.now() > deadline);
-      installCapabilityObject(context, options.capabilities);
+      installCapabilityObject(context, capabilities);
       disableAmbientDynamicCode(context);
       const result = await evalCheck(context, options.compiledCheck);
       const checkResult = result;
@@ -190421,6 +191004,7 @@ Remember: output only the JSON object described by the system prompt.`;
       }
     }, {
       timeoutMs: remainingMs,
+      signal: args.signal,
       fallbackModels: args.fallbackModels,
       callContext: "dreamer:smart-note-compiler",
       fetchOutput: async () => {
@@ -190445,7 +191029,8 @@ Remember: output only the JSON object described by the system prompt.`;
     }
     const dryRun = await runCompiledSmartNoteCheck({
       compiledCheck,
-      capabilities: args.capabilities,
+      capabilityFactory: args.capabilityFactory,
+      signal: args.signal,
       timeoutMs: 2000
     });
     if (!dryRun.ok) {
@@ -190598,7 +191183,9 @@ function nextSmartNoteCheckDueAt(cron, options = {}) {
   const rawNext = cron?.trim() ? nextDueAtMs(cron, now) : null;
   const rawDelta = rawNext ? rawNext - now : SMART_NOTE_CHECK_DEFAULT_INTERVAL_MS;
   const clamped = Math.min(ceilingMs, Math.max(floorMs, rawDelta));
-  return now + clamped + deterministicJitterMs(clamped, options.noteId, options.hash);
+  const jittered = clamped + deterministicJitterMs(clamped, options.noteId, options.hash);
+  const bounded = Math.min(ceilingMs, Math.max(floorMs, jittered));
+  return now + bounded;
 }
 function deterministicJitterMs(intervalMs, noteId, hash2) {
   const max = Math.min(60000, Math.floor(intervalMs * 0.1));
@@ -190768,9 +191355,9 @@ async function runDueCompiledSmartNoteChecks(args) {
     try {
       const result = await runCompiledSmartNoteCheck({
         compiledCheck: note.compiledCheck,
-        capabilities: createSmartNoteCapabilities({
+        capabilityFactory: (signal) => createSmartNoteCapabilities({
           projectRoot: args.projectRoot,
-          signal: controller.signal
+          signal
         }),
         signal: controller.signal,
         timeoutMs: Math.min(2000, remaining)
@@ -190835,6 +191422,24 @@ var MAX_COMPILE_PER_RUN = 5;
 var MAX_FALLBACK_PER_RUN = 3;
 var MAX_COMPILATION_FAILURES = 3;
 var SMART_NOTE_CONFIRMATION_SYSTEM_PROMPT = 'You are a no-tool smart-note confirmation evaluator. Output only JSON shaped as {"met": boolean}. Return true only when the supplied text alone proves the condition is satisfied.';
+function createPromptAbortSignal(parent, timeoutMs, timeoutMessage) {
+  const controller = new AbortController;
+  const abortFromParent = () => {
+    controller.abort(parent.reason ?? new Error("smart-note prompt aborted by lease loss"));
+  };
+  if (parent.aborted)
+    abortFromParent();
+  else
+    parent.addEventListener("abort", abortFromParent, { once: true });
+  const timer = setTimeout(() => controller.abort(new Error(timeoutMessage)), timeoutMs);
+  return {
+    signal: controller.signal,
+    cleanup: () => {
+      clearTimeout(timer);
+      parent.removeEventListener("abort", abortFromParent);
+    }
+  };
+}
 async function evaluateSmartNotes(args) {
   const projectRoot = args.sessionDirectory ?? args.projectIdentity;
   const pendingAtStart = getPendingSmartNotes(args.db, args.projectIdentity).length;
@@ -190843,6 +191448,7 @@ async function evaluateSmartNotes(args) {
     return { surfaced: 0, pending: 0, ran: false };
   }
   let leaseLost = false;
+  const leaseAbortController = new AbortController;
   const leaseHeld = () => !leaseLost && peekLeaseHolderAndExpiry(args.db, args.holderId, args.leaseKey);
   const assertLeaseHeld = (phase) => {
     if (!leaseHeld()) {
@@ -190852,6 +191458,7 @@ async function evaluateSmartNotes(args) {
   };
   const heartbeat = startLeaseHeartbeat(args.db, args.holderId, args.leaseKey, () => {
     leaseLost = true;
+    leaseAbortController.abort(new Error("Dream lease lost during smart notes"));
     log("[dreamer] smart notes: lease lost — aborting");
     args.onLeaseLost?.("smart notes");
   });
@@ -190874,7 +191481,7 @@ async function evaluateSmartNotes(args) {
         break;
       assertLeaseHeld("compile start");
       didWork = true;
-      const compiled = await compileNote(args, note, projectRoot, assertLeaseHeld, leaseHeld);
+      const compiled = await compileNote(args, note, projectRoot, assertLeaseHeld, leaseHeld, leaseAbortController.signal);
       if (compiled)
         surfaced += 1;
     }
@@ -190894,7 +191501,7 @@ async function evaluateSmartNotes(args) {
         break;
       assertLeaseHeld("fallback start");
       didWork = true;
-      const met = await confirmReadOnly(args, note.id, note.content, note.surfaceCondition);
+      const met = await confirmReadOnly(args, note.id, note.content, note.surfaceCondition, leaseAbortController.signal);
       const now = Date.now();
       assertLeaseHeld("fallback commit");
       commitSmartNoteState(args.db, {
@@ -190920,9 +191527,8 @@ async function evaluateSmartNotes(args) {
     heartbeat.stop();
   }
 }
-async function compileNote(args, note, projectRoot, assertLeaseHeld, leaseHeld) {
-  const controller = new AbortController;
-  const timer = setTimeout(() => controller.abort(new Error("smart-note compile deadline")), Math.max(1000, args.deadline - Date.now()));
+async function compileNote(args, note, projectRoot, assertLeaseHeld, leaseHeld, leaseSignal) {
+  const promptSignal = createPromptAbortSignal(leaseSignal, Math.max(1000, args.deadline - Date.now()), "smart-note compile deadline");
   try {
     const result = await compileSmartNoteCheck({
       client: args.client,
@@ -190931,7 +191537,8 @@ async function compileNote(args, note, projectRoot, assertLeaseHeld, leaseHeld)
       sessionDirectory: args.sessionDirectory,
       projectIdentity: args.projectIdentity,
       note,
-      capabilities: createSmartNoteCapabilities({ projectRoot, signal: controller.signal }),
+      capabilityFactory: (signal) => createSmartNoteCapabilities({ projectRoot, signal }),
+      signal: promptSignal.signal,
       deadline: args.deadline,
       model: args.model,
       fallbackModels: args.fallbackModels
@@ -190976,7 +191583,7 @@ async function compileNote(args, note, projectRoot, assertLeaseHeld, leaseHeld)
     });
     return result.dryRun.met;
   } finally {
-    clearTimeout(timer);
+    promptSignal.cleanup();
   }
 }
 async function runLivenessCheck(args, note, projectRoot, assertLeaseHeld, leaseHeld) {
@@ -190987,7 +191594,7 @@ async function runLivenessCheck(args, note, projectRoot, assertLeaseHeld, leaseH
   try {
     const result = await runCompiledSmartNoteCheck({
       compiledCheck: note.compiledCheck,
-      capabilities: createSmartNoteCapabilities({ projectRoot, signal: controller.signal }),
+      capabilityFactory: (signal) => createSmartNoteCapabilities({ projectRoot, signal }),
       signal: controller.signal,
       timeoutMs: 2000
     });
@@ -191016,7 +191623,7 @@ async function runLivenessCheck(args, note, projectRoot, assertLeaseHeld, leaseH
     clearTimeout(timer);
   }
 }
-async function confirmReadOnly(args, noteId, content, surfaceCondition) {
+async function confirmReadOnly(args, noteId, content, surfaceCondition, leaseSignal) {
   let childSessionId = null;
   const startedAt = Date.now();
   let invocationRecorded = false;
@@ -191059,42 +191666,49 @@ Note content: ${JSON.stringify(content)}
 Surface condition: ${JSON.stringify(surfaceCondition ?? "")}
 
 Output exactly JSON: {"met": false}`;
-    const run = await promptSyncWithValidatedOutputRetry(args.client, {
-      path: { id: childSessionId },
-      query: { directory: args.sessionDirectory ?? args.projectIdentity },
-      body: {
-        agent: SMART_NOTE_COMPILER_AGENT,
-        system: SMART_NOTE_CONFIRMATION_SYSTEM_PROMPT,
-        ...modelBodyField(args.model),
-        parts: [{ type: "text", text: prompt, synthetic: true }]
-      }
-    }, {
-      timeoutMs: Math.max(1000, args.deadline - Date.now()),
-      fallbackModels: args.fallbackModels,
-      callContext: "dreamer:smart-note-read-only-confirm",
-      fetchOutput: async () => {
-        const messagesResponse = await args.client.session.messages({
-          path: { id: childSessionId },
-          query: {
-            directory: args.sessionDirectory ?? args.projectIdentity,
-            limit: 20
-          }
-        });
-        return normalizeSDKResponse(messagesResponse, [], {
-          preferResponseOnMissingData: true
-        });
-      },
-      validateOutput: (messages) => {
-        const text = extractLatestAssistantText(messages) ?? "";
-        const match = text.match(/\{[\s\S]*\}/);
-        if (!match)
-          throw new Error("confirmation evaluator returned no JSON");
-        const parsed = JSON.parse(match[0]);
-        if (typeof parsed.met !== "boolean")
-          throw new Error("confirmation met missing");
-        return parsed.met;
-      }
-    });
+    const promptSignal = createPromptAbortSignal(leaseSignal, Math.max(1000, args.deadline - Date.now()), "smart-note confirmation deadline");
+    let run;
+    try {
+      run = await promptSyncWithValidatedOutputRetry(args.client, {
+        path: { id: childSessionId },
+        query: { directory: args.sessionDirectory ?? args.projectIdentity },
+        body: {
+          agent: SMART_NOTE_COMPILER_AGENT,
+          system: SMART_NOTE_CONFIRMATION_SYSTEM_PROMPT,
+          ...modelBodyField(args.model),
+          parts: [{ type: "text", text: prompt, synthetic: true }]
+        }
+      }, {
+        timeoutMs: Math.max(1000, args.deadline - Date.now()),
+        signal: promptSignal.signal,
+        fallbackModels: args.fallbackModels,
+        callContext: "dreamer:smart-note-read-only-confirm",
+        fetchOutput: async () => {
+          const messagesResponse = await args.client.session.messages({
+            path: { id: childSessionId },
+            query: {
+              directory: args.sessionDirectory ?? args.projectIdentity,
+              limit: 20
+            }
+          });
+          return normalizeSDKResponse(messagesResponse, [], {
+            preferResponseOnMissingData: true
+          });
+        },
+        validateOutput: (messages) => {
+          const text = extractLatestAssistantText(messages) ?? "";
+          const match = text.match(/\{[\s\S]*\}/);
+          if (!match)
+            throw new Error("confirmation evaluator returned no JSON");
+          const parsed = JSON.parse(match[0]);
+          if (typeof parsed.met !== "boolean")
+            throw new Error("confirmation met missing");
+          return parsed.met;
+        }
+      });
+    } finally {
+      promptSignal.cleanup();
+    }
     recordInvocation2({ status: "completed", messages: run.output });
     return run.validated;
   } catch (error51) {
@@ -191313,19 +191927,21 @@ ${list}
 }
 function parseMapMemoriesManifest(text) {
   const out = [];
-  for (const m of text.matchAll(/<memory\b([^>]*)\/?>/g)) {
+  const body = extractCompleteManifestBody(text, "mappings");
+  for (const m of body.matchAll(/<memory\b([^>]*)\/?>/g)) {
     const attrs = m[1];
     const idMatch = attrs.match(/\bid\s*=\s*"(\d+)"/);
     if (!idMatch)
-      continue;
+      throw new Error("mappings manifest entry missing numeric id");
     const id = Number.parseInt(idMatch[1], 10);
     if (!Number.isInteger(id))
-      continue;
+      throw new Error("mappings manifest entry missing numeric id");
     const independent = /\bindependent\s*=\s*"(?:true|1)"/i.test(attrs);
     const filesMatch = attrs.match(/\bfiles\s*=\s*"([^"]*)"/);
     const files = filesMatch ? filesMatch[1].split(",").map((f) => f.trim()).filter(Boolean) : [];
     out.push({ id, files, independent: independent || files.length === 0 });
   }
+  assertNoDuplicateManifestIds(out.map((entry) => entry.id), "mappings");
   return out;
 }
 
@@ -191414,9 +192030,13 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
         });
       },
       validateOutput: (messages) => {
+        if (hasLengthCappedOutput(messages)) {
+          throw new Error("map-memories returned length-capped output");
+        }
         const text = extractLatestAssistantText(messages);
         if (!text)
           throw new Error("map-memories returned no output");
+        parseMapMemoriesManifest(text);
         return text;
       }
     });
@@ -191442,7 +192062,8 @@ async function mapOneBatch(args, batch, sliceMs, signal) {
 }
 async function applyBatchMappings(args, batch, manifestText) {
   const batchIds = new Set(batch.map((m) => m.id));
-  const parsed = parseMapMemoriesManifest(manifestText).filter((p) => batchIds.has(p.id));
+  const parsed = parseMapMemoriesManifest(manifestText);
+  assertManifestCoversExactly(parsed.map((entry) => entry.id), batchIds, "mappings");
   if (parsed.length === 0)
     return { mapped: 0, independent: 0 };
   const planned = [];
@@ -191464,12 +192085,7 @@ async function applyBatchMappings(args, batch, manifestText) {
   const now = Date.now();
   let mapped = 0;
   let independent = 0;
-  let leaseLost = false;
-  args.db.transaction(() => {
-    if (!peekLeaseHolderAndExpiry(args.db, args.holderId, args.leaseKey)) {
-      leaseLost = true;
-      return;
-    }
+  runLeaseGuardedWrite(args.db, args.holderId, args.leaseKey, () => {
     for (const item of planned) {
       recordMemoryMapping(args.db, item.id, item.files, now);
       if (item.independent)
@@ -191477,9 +192093,7 @@ async function applyBatchMappings(args, batch, manifestText) {
       else
         mapped += 1;
     }
-  })();
-  if (leaseLost)
-    throw new Error("Dream lease lost during map-memories commit");
+  });
   return { mapped, independent };
 }
 function recordInvocation2(args, startedAt, params) {
@@ -191710,11 +192324,7 @@ async function promotePrimers(args) {
       activePrimers: primers,
       threshold: PRIMER_CLUSTER_THRESHOLD
     });
-    args.db.transaction(() => {
-      if (!peekLeaseHolderAndExpiry(args.db, args.holderId, args.leaseKey)) {
-        leaseLost = true;
-        return;
-      }
+    runLeaseGuardedWrite(args.db, args.holderId, args.leaseKey, () => {
       for (const cluster of clusters) {
         if (cluster.candidates.length === 0)
           continue;
@@ -191745,7 +192355,7 @@ async function promotePrimers(args) {
         });
         result.promoted += 1;
       }
-    })();
+    });
     if (leaseLost)
       throw new Error("Dream lease lost during promote-primers commit");
     log(`[dreamer] primers: candidates=${result.candidates} promoted=${result.promoted} updated=${result.updated}`);
@@ -192023,16 +192633,9 @@ async function refreshOnePrimer(args, primer, sliceMs, signal) {
       log(`[dreamer] refresh-primers: primer #${primer.id} answer not committed (no investigation tool calls)`);
       return false;
     }
-    let leaseLost = false;
-    args.db.transaction(() => {
-      if (!peekLeaseHolderAndExpiry(args.db, args.holderId, args.leaseKey)) {
-        leaseLost = true;
-        return;
-      }
+    runLeaseGuardedWrite(args.db, args.holderId, args.leaseKey, () => {
       updatePrimerAnswer(args.db, primer.id, answer);
-    })();
-    if (leaseLost)
-      throw new Error("Dream lease lost during refresh-primers commit");
+    });
     return true;
   } catch (error51) {
     const desc = describeError(error51);
@@ -192301,7 +192904,7 @@ async function partitionVerifyScope(args) {
       continue;
     }
     const files = v?.files ?? [];
-    const needs = files.some((file2) => !verificationFileExists(gitRoot, file2) || uncommitted.has(file2) || (changeTimes.get(file2) ?? 0) > verifiedAt);
+    const needs = files.some((file2) => !verificationFileExists(gitRoot, file2) || uncommitted.has(file2) || (changeTimes.get(file2) ?? 0) >= verifiedAt - 1000);
     if (needs)
       inScope.push(toPrompt(m));
     else
@@ -192367,22 +192970,26 @@ function filesOf(s) {
 }
 function parseVerifyManifest(text) {
   const out = { verified: [], updated: [], archived: [] };
-  for (const m of text.matchAll(/<verified\b([^>]*)\/?>/g)) {
+  const body = extractCompleteManifestBody(text, "verify");
+  for (const m of body.matchAll(/<verified\b([^>]*)\/?>/g)) {
     const id = Number.parseInt(attrOf(m[1], "id") ?? "", 10);
-    if (Number.isInteger(id))
-      out.verified.push({ id, files: filesOf(m[1]) });
+    if (!Number.isInteger(id))
+      throw new Error("verify manifest entry missing numeric id");
+    out.verified.push({ id, files: filesOf(m[1]) });
   }
-  for (const m of text.matchAll(/<update\b([^>]*?)(?:\/>|>([\s\S]*?)<\/update>)/g)) {
+  for (const m of body.matchAll(/<update\b([^>]*?)(?:\/>|>([\s\S]*?)<\/update>)/g)) {
     const id = Number.parseInt(attrOf(m[1], "id") ?? "", 10);
-    if (Number.isInteger(id)) {
-      out.updated.push({ id, files: filesOf(m[1]), content: (m[2] ?? "").trim() });
-    }
+    if (!Number.isInteger(id))
+      throw new Error("verify manifest entry missing numeric id");
+    out.updated.push({ id, files: filesOf(m[1]), content: (m[2] ?? "").trim() });
   }
-  for (const m of text.matchAll(/<archive\b([^>]*)\/?>/g)) {
+  for (const m of body.matchAll(/<archive\b([^>]*)\/?>/g)) {
     const id = Number.parseInt(attrOf(m[1], "id") ?? "", 10);
-    if (Number.isInteger(id))
-      out.archived.push({ id, reason: attrOf(m[1], "reason") ?? "" });
+    if (!Number.isInteger(id))
+      throw new Error("verify manifest entry missing numeric id");
+    out.archived.push({ id, reason: attrOf(m[1], "reason") ?? "" });
   }
+  assertNoDuplicateManifestIds([...out.verified, ...out.updated, ...out.archived].map((entry) => entry.id), "verify");
   return out;
 }
 
@@ -192475,9 +193082,13 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
         });
       },
       validateOutput: (messages) => {
+        if (hasLengthCappedOutput(messages)) {
+          throw new Error("verify returned length-capped output");
+        }
         const text = extractLatestAssistantText(messages);
         if (!text)
           throw new Error("verify returned no output");
+        parseVerifyManifest(text);
         return text;
       }
     });
@@ -192504,24 +193115,14 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
 async function applyVerifyManifest(args, batch, manifestText) {
   const batchIds = new Set(batch.map((m) => m.id));
   const parsed = parseVerifyManifest(manifestText);
+  assertManifestCoversExactly([...parsed.verified, ...parsed.updated, ...parsed.archived].map((entry) => entry.id), batchIds, "verify");
   const now = Date.now();
   const writes = [];
-  const verdictCounts = new Map;
-  for (const verdict of [...parsed.verified, ...parsed.updated, ...parsed.archived]) {
-    if (!batchIds.has(verdict.id))
-      continue;
-    verdictCounts.set(verdict.id, (verdictCounts.get(verdict.id) ?? 0) + 1);
-  }
-  const conflictingIds = new Set(Array.from(verdictCounts.entries()).filter(([, count]) => count !== 1).map(([id]) => id));
   for (const v of parsed.verified) {
-    if (!batchIds.has(v.id) || conflictingIds.has(v.id))
-      continue;
     const files = await normalizeFiles(args, v.files);
     writes.push({ kind: "verify", id: v.id, files });
   }
   for (const u of parsed.updated) {
-    if (!batchIds.has(u.id) || conflictingIds.has(u.id))
-      continue;
     const content = u.content.trim();
     if (!content || content.length > 20000) {
       const files2 = await normalizeFiles(args, u.files);
@@ -192538,8 +193139,6 @@ async function applyVerifyManifest(args, batch, manifestText) {
     });
   }
   for (const a of parsed.archived) {
-    if (!batchIds.has(a.id) || conflictingIds.has(a.id))
-      continue;
     writes.push({ kind: "archive", id: a.id, reason: a.reason });
   }
   if (writes.length === 0)
@@ -192547,12 +193146,7 @@ async function applyVerifyManifest(args, batch, manifestText) {
   let verified = 0;
   let updated = 0;
   let archived = 0;
-  let leaseLost = false;
-  args.db.transaction(() => {
-    if (!peekLeaseHolderAndExpiry(args.db, args.holderId, args.leaseKey)) {
-      leaseLost = true;
-      return;
-    }
+  runLeaseGuardedWrite(args.db, args.holderId, args.leaseKey, () => {
     for (const w of writes) {
       const memory = getMemoryById(args.db, w.id);
       if (!isPrimaryMutable(memory))
@@ -192580,9 +193174,7 @@ async function applyVerifyManifest(args, batch, manifestText) {
         archived += 1;
       }
     }
-  })();
-  if (leaseLost)
-    throw new Error("Dream lease lost during verify commit");
+  });
   return { verified, updated, archived };
 }
 async function normalizeFiles(args, rawFiles) {
@@ -193076,11 +193668,7 @@ async function runRetrospectiveTask(config2, ctx, helpers) {
       throw new Error("Dream lease lost during retrospective");
     const sourceSessionId = flagged[0]?.sessionId ?? userMessages[0]?.sessionId ?? "retrospective";
     const learnings = parseRetrospectiveLearnings(deepenRun.validated);
-    const applied = db.transaction(() => {
-      if (!peekLeaseHolderAndExpiry(db, holderId, leaseKey)) {
-        leaseLost = true;
-        return null;
-      }
+    const applied = runLeaseGuardedWrite(db, holderId, leaseKey, () => {
       const result = applyRetrospectiveLearnings({
         db,
         projectIdentity,
@@ -193091,7 +193679,7 @@ async function runRetrospectiveTask(config2, ctx, helpers) {
       });
       recordRetrospectiveWindowProcessed(db, projectIdentity, windowKey);
       return result;
-    })();
+    });
     if (leaseLost || !applied)
       throw new Error("Dream lease lost during retrospective commit");
     log(`[dreamer] retrospective: flagged=${flagged.length} learnings=${learnings.length} memory=${applied.memoryWritten} observations=${applied.observationsInserted} dropped=${applied.observationsDropped} rejected=${applied.rejected.length}`);
@@ -194613,7 +195201,7 @@ function createTagger() {
     }
     return map2;
   }
-  function isUniqueConstraintError(error51) {
+  function isUniqueConstraintError2(error51) {
     return error51 instanceof Error && "code" in error51 && error51.code === "SQLITE_CONSTRAINT_UNIQUE";
   }
   function syncCounterAtLeast(sessionId, db, value) {
@@ -194651,7 +195239,7 @@ function createTagger() {
           getUpsertCounterStatement(db).run(sessionId, next, getHarness());
         })();
       } catch (error51) {
-        if (!isUniqueConstraintError(error51)) {
+        if (!isUniqueConstraintError2(error51)) {
           throw error51;
         }
         const racedRow = dbExistingLookup();
@@ -195818,8 +196406,9 @@ function scheduleReconciliation(db, sessionId, readMessages) {
   reconciliationScheduledSessions.add(sessionId);
   defer(() => {
     reconcileSessionIndex(db, sessionId, readMessages).catch((error51) => {
-      reconciliationScheduledSessions.delete(sessionId);
       logIndexingError(sessionId, "reconciliation", error51);
+    }).finally(() => {
+      reconciliationScheduledSessions.delete(sessionId);
     });
   });
 }
@@ -195831,13 +196420,17 @@ function scheduleIncrementalIndex(db, sessionId, messageId, readSingleMessage) {
   const timer = setTimeout(() => {
     incrementalTimers.delete(key);
     pendingIncrementalKeys.add(key);
+    let attemptedOrdinal = null;
     runWithSessionLock(sessionId, () => {
       const message = readSingleMessage(sessionId, messageId);
       if (!message) {
         return;
       }
+      attemptedOrdinal = message.ordinal;
       indexSingleMessage(db, sessionId, message);
     }).catch((error51) => {
+      markMessageIndexDirty(db, sessionId, attemptedOrdinal ?? getLastIndexedOrdinal(db, sessionId) + 1);
+      reconciledSessions.delete(sessionId);
       logIndexingError(sessionId, `incremental index for ${messageId}`, error51);
     }).finally(() => {
       pendingIncrementalKeys.delete(key);
@@ -196031,6 +196624,7 @@ init_models_dev_cache();
 // src/hooks/magic-context/channel2-delivery.ts
 init_storage_meta_persisted();
 init_logger();
+import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/hooks/magic-context/ctx-reduce-nudge.ts
 init_tag_content_primitives();
@@ -196211,19 +196805,6 @@ ${body}${hintText}
 }
 
 // src/hooks/magic-context/channel2-delivery.ts
-function sealDeliveredAfterUnconfirmedSend(db, sessionId) {
-  try {
-    if (getChannel2NudgeState(db, sessionId) === "delivered") {
-      return "already-delivered";
-    }
-  } catch {}
-  try {
-    setChannel2NudgeState(db, sessionId, "delivered");
-    return "sealed";
-  } catch {
-    return "stuck-claimed";
-  }
-}
 async function maybeDeliverChannel2(sessionId, deps) {
   let state;
   try {
@@ -196249,7 +196830,8 @@ async function maybeDeliverChannel2(sessionId, deps) {
   const client = deps.client;
   if (!client)
     return false;
-  if (!casChannel2NudgeState(deps.db, sessionId, "pending", "claimed")) {
+  const claimToken = randomUUID2();
+  if (!claimChannel2NudgeState(deps.db, sessionId, claimToken)) {
     return false;
   }
   try {
@@ -196273,40 +196855,36 @@ async function maybeDeliverChannel2(sessionId, deps) {
     if (typeof session?.promptAsync !== "function") {
       throw new Error("client has no session.promptAsync");
     }
+    const claim = getChannel2NudgeClaim(deps.db, sessionId);
+    if (claim.state !== "claimed" || claim.claimToken !== claimToken) {
+      sessionLog(sessionId, `channel2 ceiling nudge delivery skipped: claim no longer owned before send (state=${claim.state || "empty"})`);
+      return false;
+    }
     await session.promptAsync({ path: { id: sessionId }, body });
   } catch (error51) {
     try {
-      casChannel2NudgeState(deps.db, sessionId, "claimed", "pending");
-      sessionLog(sessionId, "channel2 ceiling nudge delivery failed (will retry):", error51);
+      const restored = casChannel2NudgeClaim(deps.db, sessionId, "pending", claimToken);
+      if (restored) {
+        sessionLog(sessionId, "channel2 ceiling nudge delivery failed (will retry):", error51);
+      } else {
+        sessionLog(sessionId, "channel2 ceiling nudge delivery failed after its claim was no longer owned; lease state left unchanged:", error51);
+      }
     } catch (revertError) {
       sessionLog(sessionId, "channel2 ceiling nudge delivery failed; pending restore was busy so the stale claim will heal later:", { deliveryError: error51, revertError });
     }
     return false;
   }
   try {
-    const confirmed = casChannel2NudgeState(deps.db, sessionId, "claimed", "delivered");
+    const confirmed = casChannel2NudgeClaim(deps.db, sessionId, "delivered", claimToken);
     if (confirmed) {
       sessionLog(sessionId, "channel2 ceiling nudge delivered");
       return true;
     }
-    const outcome = sealDeliveredAfterUnconfirmedSend(deps.db, sessionId);
-    if (outcome === "already-delivered") {
-      sessionLog(sessionId, "channel2 ceiling nudge duplicate window: our send returned after a sibling reclaimed the stale lease and already delivered");
-    } else if (outcome === "sealed") {
-      sessionLog(sessionId, "channel2 ceiling nudge sent but claim confirmation was lost; sealed delivered without an authoritative confirm");
-    } else {
-      sessionLog(sessionId, "channel2 ceiling nudge sent but claim confirmation was lost; lease stayed claimed and will heal later");
-    }
+    const claim = getChannel2NudgeClaim(deps.db, sessionId);
+    sessionLog(sessionId, `channel2 ceiling nudge sent but claim confirmation was not ours (state=${claim.state || "empty"}); leaving existing lease state unchanged`);
     return false;
   } catch (error51) {
-    const outcome = sealDeliveredAfterUnconfirmedSend(deps.db, sessionId);
-    if (outcome === "already-delivered") {
-      sessionLog(sessionId, "channel2 ceiling nudge duplicate window: our send returned after a sibling reclaimed the stale lease and already delivered");
-    } else if (outcome === "sealed") {
-      sessionLog(sessionId, "channel2 ceiling nudge sent but confirm failed:", error51);
-    } else {
-      sessionLog(sessionId, "channel2 ceiling nudge sent but confirm failed; lease stayed claimed and will heal later:", error51);
-    }
+    sessionLog(sessionId, "channel2 ceiling nudge sent but token-confirm failed; lease state left unchanged:", error51);
     return false;
   }
 }
@@ -197736,6 +198314,8 @@ function injectToolPartIntoLatestAssistant(messages, part) {
       continue;
     if (typeof message.info.id !== "string")
       continue;
+    if (!isReplayableAssistantAnchor(message))
+      continue;
     if (hasToolPartWithCallId(message, part.callID)) {
       return message.info.id;
     }
@@ -197750,6 +198330,8 @@ function injectToolPartIntoAssistantById(messages, messageId, part) {
       continue;
     if (message.info.role !== "assistant")
       continue;
+    if (!isReplayableAssistantAnchor(message))
+      return false;
     if (hasToolPartWithCallId(message, part.callID))
       return true;
     message.parts.push(part);
@@ -197769,6 +198351,9 @@ function hasToolPartWithCallId(message, callId) {
   }
   return false;
 }
+function isReplayableAssistantAnchor(message) {
+  return message.info.error === undefined || message.info.error === null;
+}
 function appendReminderToUserMessage(message, reminder) {
   for (const part of message.parts) {
     if (!isTextPart(part)) {
@@ -198625,24 +199210,46 @@ function getMessageSearchStatementWithCutoff(db) {
   return stmt;
 }
 var ftsRowCountStatements = new WeakMap;
+var ftsRowCountStatementsWithCutoff = new WeakMap;
 var ftsMatchCountStatements = new WeakMap;
-function getSessionFtsRowCount(db, sessionId) {
-  let stmt = ftsRowCountStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("SELECT COUNT(*) AS n FROM message_history_fts WHERE session_id = ?");
-    ftsRowCountStatements.set(db, stmt);
-  }
-  const row = stmt.get(sessionId);
+var ftsMatchCountStatementsWithCutoff = new WeakMap;
+function getSessionFtsRowCount(db, sessionId, cutoff) {
+  const stmt = cutoff === null ? (() => {
+    let cached2 = ftsRowCountStatements.get(db);
+    if (!cached2) {
+      cached2 = db.prepare("SELECT COUNT(*) AS n FROM message_history_fts WHERE session_id = ?");
+      ftsRowCountStatements.set(db, cached2);
+    }
+    return cached2;
+  })() : (() => {
+    let cached2 = ftsRowCountStatementsWithCutoff.get(db);
+    if (!cached2) {
+      cached2 = db.prepare("SELECT COUNT(*) AS n FROM message_history_fts WHERE session_id = ? AND CAST(message_ordinal AS INTEGER) <= ?");
+      ftsRowCountStatementsWithCutoff.set(db, cached2);
+    }
+    return cached2;
+  })();
+  const row = cutoff === null ? stmt.get(sessionId) : stmt.get(sessionId, cutoff);
   return typeof row?.n === "number" ? row.n : 0;
 }
-function countSessionFtsMatches(db, sessionId, ftsQuery) {
-  let stmt = ftsMatchCountStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("SELECT COUNT(*) AS n FROM message_history_fts WHERE session_id = ? AND message_history_fts MATCH ?");
-    ftsMatchCountStatements.set(db, stmt);
-  }
+function countSessionFtsMatches(db, sessionId, ftsQuery, cutoff) {
+  const stmt = cutoff === null ? (() => {
+    let cached2 = ftsMatchCountStatements.get(db);
+    if (!cached2) {
+      cached2 = db.prepare("SELECT COUNT(*) AS n FROM message_history_fts WHERE session_id = ? AND message_history_fts MATCH ?");
+      ftsMatchCountStatements.set(db, cached2);
+    }
+    return cached2;
+  })() : (() => {
+    let cached2 = ftsMatchCountStatementsWithCutoff.get(db);
+    if (!cached2) {
+      cached2 = db.prepare("SELECT COUNT(*) AS n FROM message_history_fts WHERE session_id = ? AND message_history_fts MATCH ? AND CAST(message_ordinal AS INTEGER) <= ?");
+      ftsMatchCountStatementsWithCutoff.set(db, cached2);
+    }
+    return cached2;
+  })();
   try {
-    const row = stmt.get(sessionId, ftsQuery);
+    const row = cutoff === null ? stmt.get(sessionId, ftsQuery) : stmt.get(sessionId, ftsQuery, cutoff);
     return typeof row?.n === "number" ? row.n : 0;
   } catch {
     return 0;
@@ -198892,7 +199499,7 @@ function searchMessages(args) {
       role: row.role
     }));
   }
-  const corpusSize = getSessionFtsRowCount(args.db, args.sessionId);
+  const corpusSize = getSessionFtsRowCount(args.db, args.sessionId, cutoff);
   const queryLists = [];
   if (baseQuery.length > 0) {
     queryLists.push({
@@ -198905,7 +199512,7 @@ function searchMessages(args) {
     const probeQuery = sanitizeFtsQuery(probe);
     if (probeQuery.length === 0)
       continue;
-    const df = countSessionFtsMatches(args.db, args.sessionId, probeQuery);
+    const df = countSessionFtsMatches(args.db, args.sessionId, probeQuery, cutoff);
     const weight = probeDiscriminationWeight(df, corpusSize);
     probeWeights.set(probe, weight);
     queryLists.push({
@@ -200199,8 +200806,31 @@ function readFilePath(target) {
 
 // src/hooks/magic-context/todo-view.ts
 import { createHash as createHash12 } from "node:crypto";
-var TERMINAL_STATUSES = new Set(["completed", "cancelled"]);
-var TITLE_DONE_STATUSES = new Set(["completed"]);
+var TODO_STATUS_PENDING = "pending";
+var TODO_STATUS_IN_PROGRESS = "in_progress";
+var TODO_STATUS_COMPLETED = "completed";
+var TODO_STATUS_CANCELLED = "cancelled";
+var TODO_PRIORITY_HIGH = "high";
+var TODO_PRIORITY_MEDIUM = "medium";
+var TODO_PRIORITY_LOW = "low";
+var TODO_STATUSES = [
+  TODO_STATUS_PENDING,
+  TODO_STATUS_IN_PROGRESS,
+  TODO_STATUS_COMPLETED,
+  TODO_STATUS_CANCELLED
+];
+var TODO_PRIORITIES = [
+  TODO_PRIORITY_HIGH,
+  TODO_PRIORITY_MEDIUM,
+  TODO_PRIORITY_LOW
+];
+var TODO_STATUS_SET = new Set(TODO_STATUSES);
+var TODO_PRIORITY_SET = new Set(TODO_PRIORITIES);
+var TERMINAL_STATUSES = new Set([
+  TODO_STATUS_COMPLETED,
+  TODO_STATUS_CANCELLED
+]);
+var TITLE_DONE_STATUSES = new Set([TODO_STATUS_COMPLETED]);
 var SYNTHETIC_CALL_ID_PREFIX = "mc_synthetic_todo_";
 function normalizeTodoStateJson(todos) {
   if (!Array.isArray(todos))
@@ -200212,7 +200842,7 @@ function normalizeTodoStateJson(todos) {
     normalized.push({
       content: todo.content,
       status: todo.status,
-      priority: todo.priority ?? "medium"
+      priority: todo.priority ?? TODO_PRIORITY_MEDIUM
     });
   }
   return JSON.stringify(normalized);
@@ -200256,11 +200886,11 @@ function parseTodoState(stateJson) {
     const result = [];
     for (const item of parsed) {
       if (!isTodoItem(item))
-        continue;
+        return null;
       result.push({
         content: item.content,
         status: item.status,
-        priority: item.priority ?? "medium"
+        priority: item.priority ?? TODO_PRIORITY_MEDIUM
       });
     }
     return result;
@@ -200268,11 +200898,17 @@ function parseTodoState(stateJson) {
     return null;
   }
 }
+function isTodoStatus(value) {
+  return typeof value === "string" && TODO_STATUS_SET.has(value);
+}
+function isTodoPriority(value) {
+  return typeof value === "string" && TODO_PRIORITY_SET.has(value);
+}
 function isTodoItem(value) {
   if (value === null || typeof value !== "object")
     return false;
   const todo = value;
-  return typeof todo.content === "string" && typeof todo.status === "string" && (todo.priority === undefined || typeof todo.priority === "string");
+  return typeof todo.content === "string" && isTodoStatus(todo.status) && (todo.priority === undefined || isTodoPriority(todo.priority));
 }
 
 // src/hooks/magic-context/tool-reclaim.ts
@@ -200462,7 +201098,7 @@ async function runPostTransformPhase(args) {
     if (args.schedulerDecision === "execute" && !materializationRequested) {
       updateSessionMeta(args.db, args.sessionId, { lastResponseTime: Date.now() });
     }
-    const toolReclaimExecutePass = args.schedulerDecision === "execute";
+    const toolReclaimExecutePass = args.schedulerDecision === "execute" || m0HardFoldThisPass;
     const alreadyMutatingThisPass = pendingOpsDidMutate || heuristicOrReasoningDidMutate;
     let autoReclaimTargetCount = 0;
     let autoReclaimDidMutate = false;
@@ -200554,12 +201190,12 @@ async function runPostTransformPhase(args) {
       sessionLog(args.sessionId, "transform failed dropping stale ctx_reduce calls:", error51);
     }
   }
-  if (canUseEmptySentinels && args.watermark > 0) {
+  if (canUseEmptySentinels) {
     try {
       const tImg = performance.now();
       const frozenImageIds = getProcessedImageStrippedIds(args.db, args.sessionId);
       const imageResult = stripProcessedImages(args.messages, frozenImageIds, {
-        detect: isCacheBustingPass,
+        detect: isCacheBustingPass && args.watermark > 0,
         watermark: args.watermark,
         messageTagNumbers: args.messageTagNumbers
       });
@@ -202125,12 +202761,25 @@ await __promiseAll([
 ]);
 import * as crypto3 from "node:crypto";
 var WAIT_FOR_LEASE_MS = 1000;
+var MAX_WRAPUP_LEASE_WAIT_MS = 10 * 60 * 1000;
 function sleep2(ms) {
   return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 function plural(value, word) {
   return `${value} ${word}${value === 1 ? "" : "s"}`;
 }
+function resolveWrapupLeaseWaitTimeout(ctx) {
+  const configured = ctx.wrapupLeaseWaitTimeoutMs ?? MAX_WRAPUP_LEASE_WAIT_MS;
+  return Number.isFinite(configured) && configured >= 0 ? configured : MAX_WRAPUP_LEASE_WAIT_MS;
+}
+async function waitForActiveRunWithin(promise2, timeoutMs) {
+  if (timeoutMs <= 0)
+    return "timeout";
+  return Promise.race([
+    promise2.then(() => "settled", () => "settled"),
+    sleep2(timeoutMs).then(() => "timeout")
+  ]);
+}
 function formatAlreadyRunningMessage(state) {
   if (!state)
     return "/ctx-wrapup is already running for this session.";
@@ -202173,44 +202822,55 @@ function emitWrapupProgress(ctx, sessionId, progress) {
     note: progress.note
   });
 }
-async function waitForExistingIncrementalRun(sessionId) {
+async function waitForExistingIncrementalRun(sessionId, maxWaitMs) {
   const active = getActiveCompartmentRun(sessionId);
   if (!active)
     return "ok";
   if (active.kind === "recomp" || active.kind === "wrapup")
     return "busy";
-  try {
-    await active.promise;
-  } catch {}
+  const outcome = await waitForActiveRunWithin(active.promise, maxWaitMs);
+  if (outcome === "timeout")
+    return "timeout";
   return "ok";
 }
 async function acquireCompartmentLeaseForWrapup(ctx, sessionId, renewWrapupMarker) {
   const holderId = crypto3.randomUUID();
+  const waitStartedAt = Date.now();
+  const maxWaitMs = resolveWrapupLeaseWaitTimeout(ctx);
+  const remainingMs = () => Math.max(0, waitStartedAt + maxWaitMs - Date.now());
   for (;; ) {
+    if (remainingMs() <= 0) {
+      sessionLog(sessionId, "wrapup: timed out waiting for the compartment-state lease");
+      return { ok: false, reason: "timeout" };
+    }
     const active = getActiveCompartmentRun(sessionId);
-    if (active?.kind === "recomp" || active?.kind === "wrapup")
-      return null;
+    if (active?.kind === "recomp" || active?.kind === "wrapup") {
+      return { ok: false, reason: "busy" };
+    }
     if (active) {
       emitWrapupProgress(ctx, sessionId, { note: "Waiting for the active historian run…" });
-      try {
-        await active.promise;
-      } catch {}
+      const outcome = await waitForActiveRunWithin(active.promise, remainingMs());
+      if (outcome === "timeout") {
+        sessionLog(sessionId, "wrapup: timed out waiting for the active historian run");
+        return { ok: false, reason: "timeout" };
+      }
       continue;
     }
     const lease = acquireCompartmentLease(ctx.db, sessionId, holderId);
     if (lease)
-      return holderId;
+      return { ok: true, holderId };
     emitWrapupProgress(ctx, sessionId, { note: "Waiting for the compartment-state lease…" });
     if (!renewWrapupMarker({}))
-      return null;
-    await sleep2(WAIT_FOR_LEASE_MS);
+      return { ok: false, reason: "ownership_lost" };
+    await sleep2(Math.min(WAIT_FOR_LEASE_MS, remainingMs()));
   }
 }
 async function runOneWrapupIteration(args) {
   const { ctx, sessionId, plan, messagesToKeep, anchorRawMessageCount } = args;
-  const leaseHolderId = await acquireCompartmentLeaseForWrapup(ctx, sessionId, args.renewWrapupMarker);
-  if (!leaseHolderId)
-    return false;
+  const acquired = await acquireCompartmentLeaseForWrapup(ctx, sessionId, args.renewWrapupMarker);
+  if (!acquired.ok)
+    return { ran: false, reason: acquired.reason };
+  const leaseHolderId = acquired.holderId;
   const renewal = setInterval(() => {
     try {
       if (!renewCompartmentLease(ctx.db, sessionId, leaseHolderId)) {
@@ -202255,7 +202915,7 @@ async function runOneWrapupIteration(args) {
   registerActiveCompartmentRun(sessionId, runnerPromise, "wrapup");
   try {
     await runnerPromise;
-    return true;
+    return { ran: true };
   } finally {
     clearInterval(renewal);
     releaseCompartmentLease(ctx.db, sessionId, leaseHolderId);
@@ -202330,7 +202990,7 @@ ${message2}`;
   }, 60000);
   markerRenewal.unref?.();
   try {
-    const activeAtStart = await waitForExistingIncrementalRun(sessionId);
+    const activeAtStart = await waitForExistingIncrementalRun(sessionId, resolveWrapupLeaseWaitTimeout(ctx));
     if (activeAtStart === "busy") {
       const message2 = "Another Magic Context rebuild is already running for this session.";
       setRecompTerminal(ctx.liveSessionState, sessionId, "skipped", message2);
@@ -202338,16 +202998,22 @@ ${message2}`;
 
 ${message2}`;
     }
-    try {
-      sendIgnoredMessage(ctx.client, sessionId, `Magic Wrapup started — compacting about ${plural(expectedChunks, "chunk")} of history. This can take a few minutes; the result posts here when done.`, ctx.getNotificationParams(sessionId));
-    } catch {}
-    try {
-      pushNotification("action", { action: "wrapup-progress-kick" }, sessionId);
-    } catch {}
-    if (ownershipLost) {
+    if (activeAtStart === "timeout") {
+      stoppedForFailure = true;
+      stoppedReason = "Timed out waiting for the active historian run.";
+    }
+    if (!stoppedForFailure) {
+      try {
+        sendIgnoredMessage(ctx.client, sessionId, `Magic Wrapup started — compacting about ${plural(expectedChunks, "chunk")} of history. This can take a few minutes; the result posts here when done.`, ctx.getNotificationParams(sessionId));
+      } catch {}
+      try {
+        pushNotification("action", { action: "wrapup-progress-kick" }, sessionId);
+      } catch {}
+    }
+    if (!stoppedForFailure && ownershipLost) {
       stoppedForFailure = true;
       stoppedReason = ownershipLostReason;
-    } else {
+    } else if (!stoppedForFailure) {
       emitWrapupProgress(ctx, sessionId, {
         processedMessages: Math.max(0, lastEnd),
         totalMessages: Math.max(0, initialPlan.targetEligibleEndOrdinal - 1),
@@ -202394,7 +203060,7 @@ ${message2}`;
         }
         const beforeEnd = lastEnd;
         const beforeFailures = getHistorianFailureState(ctx.db, sessionId).failureCount;
-        const ran = await runOneWrapupIteration({
+        const iteration = await runOneWrapupIteration({
           ctx,
           sessionId,
           plan,
@@ -202402,9 +203068,9 @@ ${message2}`;
           anchorRawMessageCount: initialPlan.anchorRawMessageCount,
           renewWrapupMarker
         });
-        if (!ran) {
+        if (!iteration.ran) {
           stoppedForFailure = true;
-          stoppedReason = ownershipLost ? ownershipLostReason : "Another Magic Context rebuild started while wrapup was waiting.";
+          stoppedReason = ownershipLost || iteration.reason === "ownership_lost" ? ownershipLostReason : iteration.reason === "timeout" ? "Timed out waiting for another process to release the compartment-state lease." : "Another Magic Context rebuild started while wrapup was waiting.";
           break;
         }
         const afterEnd = getLastCompartmentEndMessage(ctx.db, sessionId);
@@ -204962,13 +205628,18 @@ function queueMemoryEmbedding(args) {
   if (!snapshot?.enabled) {
     return;
   }
+  const normalizedHash = computeNormalizedHash(args.content);
   (async () => {
     const result = await embedTextForProject(args.projectPath, args.content);
     if (!result) {
       sessionLog(args.sessionId, `memory embedding skipped for memory ${args.memoryId}: provider unavailable or embedding generation failed.`);
       return;
     }
-    saveEmbedding(args.deps.db, args.memoryId, result.vector, result.modelId);
+    const saved = saveEmbeddingIfHashMatches(args.deps.db, args.memoryId, result.vector, result.modelId, normalizedHash);
+    if (!saved) {
+      sessionLog(args.sessionId, `memory embedding skipped for memory ${args.memoryId}: content changed before the embedding finished.`);
+      return;
+    }
     sessionLog(args.sessionId, `proactively embedded memory ${args.memoryId}.`);
   })().catch((error51) => {
     sessionLog(args.sessionId, `memory embedding failed for memory ${args.memoryId}:`, error51);
@@ -205053,8 +205724,9 @@ function createCtxMemoryTool(deps) {
         const isOwn = targetIdentityForStoredPath(memory.projectPath) === projectPath;
         if (isOwn)
           return true;
-        return toolShareCategories === null || toolShareCategories.includes(memory.category);
+        return toolShareCategories?.includes(memory.category) ?? false;
       };
+      const memoryOwnedByTool = (memory) => workspaceIdentitySet.identities.length > 1 ? targetIdentityForStoredPath(memory.projectPath) === projectPath : memoryBelongsToProject(memory, projectPath);
       const embeddingSnapshot = getProjectEmbeddingSnapshot(projectPath);
       if (embeddingSnapshot ? !embeddingSnapshot.features.memoryEnabled : deps.memoryEnabled === false) {
         return getDisabledMessage();
@@ -205077,21 +205749,24 @@ function createCtxMemoryTool(deps) {
           updateMemorySeenCount(deps.db, existingMemory.id);
           return `Memory already exists [ID: ${existingMemory.id}] in ${category} (seen count incremented).`;
         }
-        const memory = insertMemory(deps.db, {
+        const insertResult = insertMemoryIdempotent(deps.db, {
           projectPath,
           category,
           content,
           sourceSessionId: toolContext.sessionID,
           sourceType: toolContext.agent === DREAMER_AGENT ? "dreamer" : getSourceType(deps)
         });
+        if (!insertResult.inserted) {
+          return `Memory already exists [ID: ${insertResult.memory.id}] in ${category} (seen count incremented).`;
+        }
         queueMemoryEmbedding({
           deps,
           sessionId: toolContext.sessionID,
           projectPath,
-          memoryId: memory.id,
+          memoryId: insertResult.memory.id,
           content
         });
-        return `Saved memory [ID: ${memory.id}] in ${category}.`;
+        return `Saved memory [ID: ${insertResult.memory.id}] in ${category}.`;
       }
       if (args.action === "list") {
         const limit = normalizeLimit2(args.limit);
@@ -205111,7 +205786,8 @@ function createCtxMemoryTool(deps) {
         }
         const rawProjectPath = projectPathForMemoryId(deps.db, updateId);
         const memory = getMemoryById(deps.db, updateId);
-        if (!memory || !rawProjectPath || !memoryVisibleToTool(memory)) {
+        const updateAllowed = memory ? toolContext.agent === DREAMER_AGENT ? memoryVisibleToTool(memory) : memoryOwnedByTool(memory) : false;
+        if (!memory || !rawProjectPath || !updateAllowed) {
           return `Error: Memory with ID ${updateId} was not found.`;
         }
         if (toolContext.agent !== DREAMER_AGENT && !isPrimaryMutableMemory(memory)) {
@@ -205159,7 +205835,7 @@ function createCtxMemoryTool(deps) {
           return "Error: One or more source memories were not found.";
         }
         if (toolContext.agent !== DREAMER_AGENT) {
-          const foreign = sourceMemories.find((memory) => !memoryVisibleToTool(memory));
+          const foreign = sourceMemories.find((memory) => !memoryOwnedByTool(memory));
           if (foreign) {
             return `Error: Memory with ID ${foreign.id} was not found.`;
           }
@@ -205182,11 +205858,6 @@ function createCtxMemoryTool(deps) {
           return "Error: A valid category is required when action is 'merge'.";
         }
         const normalizedHash = computeNormalizedHash(content);
-        const duplicate = getMemoryByHash(deps.db, projectPath, category, normalizedHash);
-        const canonicalExisting = duplicate && ids.includes(duplicate.id) ? duplicate : null;
-        if (duplicate && !canonicalExisting) {
-          return `Error: Memory content already exists as ID ${duplicate.id}; update or archive existing duplicates instead.`;
-        }
         const mergedFrom = JSON.stringify(Array.from(new Set(sourceMemories.flatMap((memory) => {
           let parsed;
           try {
@@ -205202,14 +205873,21 @@ function createCtxMemoryTool(deps) {
         const mergedSeenCount = sourceMemories.reduce((sum, memory) => sum + memory.seenCount, 0);
         const mergedRetrievalCount = sourceMemories.reduce((sum, memory) => sum + memory.retrievalCount, 0);
         const mergedStatus = sourceMemories.some((memory) => memory.status === "permanent") ? "permanent" : "active";
-        const canonicalMemory = deps.db.transaction(() => {
-          const nextCanonical = canonicalExisting ?? insertMemory(deps.db, {
+        let mergeConflict = null;
+        const canonicalMemory = runImmediateTransaction(deps.db, () => {
+          const lockedDuplicate = getMemoryByHash(deps.db, projectPath, category, normalizedHash);
+          const canonicalExisting = lockedDuplicate && ids.includes(lockedDuplicate.id) ? lockedDuplicate : null;
+          if (lockedDuplicate && !canonicalExisting) {
+            mergeConflict = `Error: Memory content already exists as ID ${lockedDuplicate.id}; update or archive existing duplicates instead.`;
+            return null;
+          }
+          const nextCanonical = canonicalExisting?.id != null ? canonicalExisting : insertMemoryIdempotent(deps.db, {
             projectPath,
             category,
             content,
             sourceSessionId: toolContext.sessionID,
             sourceType: toolContext.agent === DREAMER_AGENT ? "dreamer" : getSourceType(deps)
-          });
+          }).memory;
           const canonicalContentChanged = nextCanonical.content !== content || nextCanonical.normalizedHash !== normalizedHash;
           if (canonicalContentChanged) {
             updateMemoryContentInCurrentTransaction(deps.db, nextCanonical, content, normalizedHash);
@@ -205237,7 +205915,10 @@ function createCtxMemoryTool(deps) {
             });
           }
           return nextCanonical;
-        })();
+        });
+        if (mergeConflict || !canonicalMemory) {
+          return mergeConflict ?? "Error: Failed to merge memories.";
+        }
         queueMemoryEmbedding({
           deps,
           sessionId: toolContext.sessionID,
@@ -205258,7 +205939,8 @@ function createCtxMemoryTool(deps) {
         for (const memoryId of archiveIds) {
           const rawProjectPath = projectPathForMemoryId(deps.db, memoryId);
           const memory = getMemoryById(deps.db, memoryId);
-          if (!memory || !rawProjectPath || !memoryVisibleToTool(memory)) {
+          const archiveAllowed = memory ? toolContext.agent === DREAMER_AGENT ? memoryVisibleToTool(memory) : memoryOwnedByTool(memory) : false;
+          if (!memory || !rawProjectPath || !archiveAllowed) {
             return `Error: Memory with ID ${memoryId} was not found.`;
           }
           if (toolContext.agent !== DREAMER_AGENT && !isPrimaryMutableMemory(memory)) {
@@ -205713,7 +206395,7 @@ function normalizeLimit3(limit) {
   return Math.max(1, Math.floor(limit));
 }
 function normalizeSources(sources) {
-  if (!sources || sources.length === 0)
+  if (sources === undefined)
     return;
   const result = [];
   const seen = new Set;
@@ -205726,7 +206408,7 @@ function normalizeSources(sources) {
       }
     }
   }
-  return result.length > 0 ? result : undefined;
+  return result;
 }
 function formatAge2(committedAtMs) {
   const ageMs = Date.now() - committedAtMs;
@@ -205818,7 +206500,7 @@ function createCtxSearchTool(deps) {
     args: {
       query: tool5.schema.string().describe("Search query. Matches against memory content, Primers, git commit messages, and raw user/assistant message text."),
       limit: tool5.schema.number().optional().describe("Maximum results to return (default: 10)"),
-      sources: tool5.schema.array(tool5.schema.enum(["memory", "message", "git_commit", "primer", "note"])).optional().describe('Optional. Restrict to specific sources. Examples: ["primer"] for standing project explanations, ["git_commit"] for "when did we change X", ["memory"] for naming conventions, ["message"] for "did we discuss this earlier", ["note"] for parked decisions or follow-ups, ["git_commit","message"] for regression hunts. Omit for a broad search across all enabled sources.')
+      sources: tool5.schema.array(tool5.schema.enum(["memory", "message", "git_commit", "primer", "note"])).optional().describe('Optional. Restrict to specific sources. Examples: ["primer"] for standing project explanations, ["git_commit"] for "when did we change X", ["memory"] for naming conventions, ["message"] for "did we discuss this earlier", ["note"] for parked decisions or follow-ups, ["git_commit","message"] for regression hunts. Omit for a broad search across all enabled sources; pass [] to search no sources.')
     },
     async execute(args, toolContext) {
       const query = args.query?.trim();
@@ -205993,8 +206675,9 @@ function projectHash(directory) {
 function rpcPortDir(storageDir, directory) {
   return join20(storageDir, "rpc", projectHash(directory));
 }
-function rpcPortFilePath(storageDir, directory, pid = process.pid) {
-  return join20(rpcPortDir(storageDir, directory), `port-${pid}.json`);
+function rpcPortFilePath(storageDir, directory, pid = process.pid, instanceId) {
+  const suffix = instanceId ? `-${instanceId}` : "";
+  return join20(rpcPortDir(storageDir, directory), `port-${pid}${suffix}.json`);
 }
 function isPidAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0)
@@ -206022,7 +206705,8 @@ function parseRpcPortFile(content, fallbackPid = 0) {
         port: port2,
         pid,
         started_at: Number.isFinite(startedAt) ? startedAt : 0,
-        token: typeof parsed.token === "string" ? parsed.token : undefined
+        token: typeof parsed.token === "string" ? parsed.token : undefined,
+        instance_id: typeof parsed.instance_id === "string" ? parsed.instance_id : undefined
       };
     } catch {
       return null;
@@ -206048,6 +206732,13 @@ function tokensMatch(presented, expected) {
     return false;
   return timingSafeEqual(a, b);
 }
+function bearerToken(req) {
+  const auth = req.headers.get("authorization");
+  return typeof auth === "string" ? auth.replace(/^Bearer\s+/i, "") : "";
+}
+function websocketToken(req, url2) {
+  return bearerToken(req) || url2.searchParams.get("token") || "";
+}
 
 class MagicContextRpcServer {
   server = null;
@@ -206056,16 +206747,18 @@ class MagicContextRpcServer {
   portFilePath;
   portDir;
   startedAt = Date.now();
+  instanceId = randomBytes(8).toString("hex");
   sockets = new Set;
   token = randomBytes(32).toString("hex");
   constructor(storageDir, directory) {
-    this.portFilePath = rpcPortFilePath(storageDir, directory);
+    this.portFilePath = rpcPortFilePath(storageDir, directory, process.pid, this.instanceId);
     this.portDir = rpcPortDir(storageDir, directory);
   }
   handle(method, handler) {
     this.handlers.set(method, handler);
   }
   async start() {
+    this.startedAt = Date.now();
     const self2 = this;
     const server = Bun.serve({
       port: 0,
@@ -206108,7 +206801,8 @@ class MagicContextRpcServer {
         port: this.port,
         pid: process.pid,
         started_at: this.startedAt,
-        token: this.token
+        token: this.token,
+        instance_id: this.instanceId
       }), { encoding: "utf-8", mode: 384 });
       renameSync5(tmpPath, this.portFilePath);
       try {
@@ -206154,6 +206848,9 @@ class MagicContextRpcServer {
   async handleFetch(req, srv) {
     const url2 = new URL(req.url);
     if (url2.pathname === "/ws") {
+      if (!tokensMatch(websocketToken(req, url2), this.token)) {
+        return new Response("Unauthorized", { status: 401 });
+      }
       const ok = srv.upgrade(req, { data: { authed: false } });
       if (ok)
         return;
@@ -206165,9 +206862,7 @@ class MagicContextRpcServer {
     if (req.method !== "POST" || !url2.pathname.startsWith("/rpc/")) {
       return new Response("Not Found", { status: 404 });
     }
-    const auth = req.headers.get("authorization");
-    const presented = typeof auth === "string" ? auth.replace(/^Bearer\s+/i, "") : "";
-    if (!tokensMatch(presented, this.token)) {
+    if (!tokensMatch(bearerToken(req), this.token)) {
       return json2({ error: "Unauthorized" }, 401);
     }
     const method = url2.pathname.slice(5);
@@ -206202,6 +206897,8 @@ class MagicContextRpcServer {
     } catch {
       return;
     }
+    if (msg.type !== "hello" && !ws.data.authed)
+      return;
     if (msg.type === "hello") {
       if (!tokensMatch(typeof msg.token === "string" ? msg.token : "", this.token)) {
         ws.send(JSON.stringify({ type: "error", error: "unauthorized" }));
@@ -206214,6 +206911,8 @@ class MagicContextRpcServer {
       }
       ws.data.authed = true;
       ws.data.sessionId = typeof msg.sessionId === "string" && msg.sessionId.length > 0 ? msg.sessionId : undefined;
+      ws.data.unregister?.();
+      ws.data.unregister = undefined;
       const sink = {
         sessionId: ws.data.sessionId,
         send: (notification) => {
@@ -206223,7 +206922,10 @@ class MagicContextRpcServer {
       ws.data.unregister = registerNotificationSink(sink);
       this.sockets.add(ws);
       const lastReceivedId = Number(msg.lastReceivedId ?? 0);
-      const backlog = drainNotifications(Number.isFinite(lastReceivedId) ? lastReceivedId : 0, ws.data.sessionId);
+      const sessionCursor = Number.isFinite(lastReceivedId) ? lastReceivedId : 0;
+      const hasGlobalCursor = typeof msg.globalLastReceivedId === "number";
+      const globalLastReceivedId = hasGlobalCursor ? Number.isFinite(msg.globalLastReceivedId) ? msg.globalLastReceivedId : 0 : 0;
+      const backlog = ws.data.sessionId === undefined && hasGlobalCursor ? drainNotifications(globalLastReceivedId, undefined, { globalOnly: true }) : drainNotifications(sessionCursor, ws.data.sessionId, hasGlobalCursor ? { globalLastReceivedId } : undefined);
       for (const notification of backlog) {
         ws.send(JSON.stringify({ type: "notification", notification }));
       }
@@ -206233,7 +206935,13 @@ class MagicContextRpcServer {
     if (msg.type === "ack") {
       const lastReceivedId = Number(msg.lastReceivedId ?? 0);
       if (Number.isFinite(lastReceivedId) && lastReceivedId > 0) {
-        drainNotifications(lastReceivedId, ws.data.sessionId);
+        if (msg.ackScope === "global") {
+          drainNotifications(lastReceivedId, undefined, { globalOnly: true });
+        } else if (typeof msg.sessionId === "string" && msg.sessionId.length > 0) {
+          drainNotifications(lastReceivedId, msg.sessionId, { sessionOnly: true });
+        } else {
+          drainNotifications(lastReceivedId, ws.data.sessionId);
+        }
       }
     }
   }