@remnic/core 9.69.32 → 9.69.34

package/dist/{chunk-CZYYJZB6.js → chunk-ND2O2PVN.js}

@@ -6,36 +6,36 @@ import {
   loadSyncState,
   syncWearableSource,
   wearableSourceLabel
-} from "./chunk-YQAXP5AC.js";
+} from "./chunk-YXLUTALO.js";
 import {
   CompressionGuidelineCoordinator
 } from "./chunk-UXREWVW4.js";
 import {
   ActivityStore,
   MaintenanceScheduler
-} from "./chunk-WJBZMNNS.js";
+} from "./chunk-7CAY3YKP.js";
 import {
   runPeerProfileReasoner
 } from "./chunk-I74SUMNI.js";
 import {
   migrateFromEngram
-} from "./chunk-ZG74PWRW.js";
+} from "./chunk-VZAKYDMJ.js";
 import {
   LcmEngine
-} from "./chunk-X2NFFBTO.js";
-import {
-  chunkTranscriptEntries
-} from "./chunk-TECVW3JP.js";
+} from "./chunk-A7GQBJP5.js";
 import {
   cleanupConversationChunks
 } from "./chunk-C5JF6EZ7.js";
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-IY2FVXM6.js";
+} from "./chunk-2AU4D4HQ.js";
 import {
   SharedContextManager
 } from "./chunk-CARRTDKC.js";
+import {
+  chunkTranscriptEntries
+} from "./chunk-TECVW3JP.js";
 import {
   cleanArchivedUserMessage
 } from "./chunk-47DU4SGJ.js";
@@ -47,6 +47,9 @@ import {
 import {
   extractTopics
 } from "./chunk-KVDUKH5E.js";
+import {
+  buildTemporalTimelineRecallSection
+} from "./chunk-2NKY7OC6.js";
 import {
   CODEX_THREAD_KEY_PREFIX
 } from "./chunk-4EX5WZ4M.js";
@@ -55,7 +58,7 @@ import {
 } from "./chunk-YRFAYOFQ.js";
 import {
   decideTierTransition
-} from "./chunk-DD5JFCWM.js";
+} from "./chunk-GCBIXUPT.js";
 import {
   TmtBuilder
 } from "./chunk-ECZU5BJH.js";
@@ -63,9 +66,6 @@ import {
   buildTargetedFactRecallSection,
   shouldRecallTargetedFactEvidence
 } from "./chunk-T67LUYCR.js";
-import {
-  buildTemporalTimelineRecallSection
-} from "./chunk-2NKY7OC6.js";
 import {
   SessionObserverState
 } from "./chunk-ODZKV2F7.js";
@@ -108,9 +108,14 @@ import {
   reorderByRankedKeys,
   rerankLocalOrNoop
 } from "./chunk-LUDXM7MD.js";
+import {
+  filterRecentScanMemoriesForStateView,
+  indexStateViewAnnotatedResults,
+  resolveRecallStateViewActive
+} from "./chunk-W6IJMWTZ.js";
 import {
   applyRecallStateViews
-} from "./chunk-FYDW33ZB.js";
+} from "./chunk-BRZWWUCJ.js";
 import {
   reorderRecallResultsWithMmr
 } from "./chunk-YDBIWGNI.js";
@@ -153,7 +158,7 @@ import {
 } from "./chunk-XXSOVESA.js";
 import {
   ExtractionEngine
-} from "./chunk-QMGXMJ2O.js";
+} from "./chunk-T2YFZ27G.js";
 import {
   parseMemoryActionEligibilityContext
 } from "./chunk-AJTG3CP7.js";
@@ -170,7 +175,7 @@ import {
   getVerdictKind,
   judgeFactDurability,
   validateProcedureExtraction
-} from "./chunk-JT3EB7ZL.js";
+} from "./chunk-BNGHPYZU.js";
 import {
   pickFactEventTimeAnchor,
   resolveFactEventTime
@@ -194,7 +199,7 @@ import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-VP67GZ7T.js";
+} from "./chunk-APFKZVJS.js";
 import {
   tryDirectAnswer
 } from "./chunk-VY47VI2T.js";
@@ -203,7 +208,7 @@ import {
 } from "./chunk-LVXBC6YB.js";
 import {
   refreshConvergedNamespaces
-} from "./chunk-CBCNKKZD.js";
+} from "./chunk-VIZR45AN.js";
 import {
   builtInConnectorPackageSpecifier,
   ensureBuiltInWearableConnectors,
@@ -212,24 +217,24 @@ import {
   runTimelinePublishCli,
   screenCandidateFact,
   summarizeVaultPublish
-} from "./chunk-MYMNC6O5.js";
-import {
-  RoutingRulesStore
-} from "./chunk-TBUEE7XF.js";
+} from "./chunk-ISYZ5DUI.js";
 import {
   normalizeReplaySessionKey
 } from "./chunk-AJVLDJU6.js";
+import {
+  RoutingRulesStore
+} from "./chunk-TBUEE7XF.js";
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-MPYD657E.js";
+} from "./chunk-A7WOWDZK.js";
 import {
   ThreadingManager
 } from "./chunk-OJP3N7UK.js";
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-FGGYSN4P.js";
+} from "./chunk-X424T5JQ.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-G7NYVKD6.js";
@@ -242,10 +247,10 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-WHBVXTUI.js";
+} from "./chunk-4PB2MBY6.js";
 import {
   planNamespaceMaintenance
-} from "./chunk-AOCP6JA7.js";
+} from "./chunk-D3IZCN5P.js";
 import {
   isAboveImportanceThreshold,
   scoreImportance
@@ -274,7 +279,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-47DEYNMR.js";
+} from "./chunk-PEXW2JCK.js";
 import {
   BoxBuilder
 } from "./chunk-B7RWBZXW.js";
@@ -286,7 +291,7 @@ import {
 } from "./chunk-6TBIWIAG.js";
 import {
   SmartBuffer
-} from "./chunk-VED2YHUD.js";
+} from "./chunk-YEDVOYL2.js";
 import {
   REFUSED_MERGE_CATEGORIES,
   applyNoveltyGate,
@@ -295,7 +300,7 @@ import {
   detectMeetings,
   embeddingsFromCosineHits,
   normalizeConnectorScope
-} from "./chunk-SQJ3SDIW.js";
+} from "./chunk-SZWEDG3H.js";
 import {
   compileCorrectionRule,
   correctionsFilePath,
@@ -303,8 +308,10 @@ import {
   saveCorrectionsFile
 } from "./chunk-ZKOPY4WW.js";
 import {
-  resolveJournalSource
-} from "./chunk-4UDQUPT5.js";
+  isAnalysisFailureKind,
+  resolveJournalSource,
+  resolveVaultNotePath
+} from "./chunk-5HYUUFMQ.js";
 import {
   AMBIENT_CAPTURE_PROMPT_RULE,
   isHighImpactPersonalFact
@@ -327,7 +334,7 @@ import {
 } from "./chunk-MI2OTWV5.js";
 import {
   MeetingsInputError
-} from "./chunk-42SDNZCU.js";
+} from "./chunk-QF4J3KMV.js";
 import {
   WearablesInputError,
   describeErrorForOperator
@@ -345,19 +352,14 @@ import {
 } from "./chunk-DGS34QSY.js";
 import {
   NamespaceCatalog
-} from "./chunk-565C6ZFO.js";
+} from "./chunk-Z7YDVHDI.js";
 import {
   RecallResultFormatter,
   SessionContextCoordinator,
   capturePassiveCorrections,
   clusterByKey,
-  detectPassiveCorrections,
-  filterRecallCandidates,
-  isGenericRecallExcludedPath,
-  isTopLevelArchivePath,
-  journalPath,
-  writeJournalFile
-} from "./chunk-Z4PCVRTN.js";
+  detectPassiveCorrections
+} from "./chunk-5A7ZUOBA.js";
 import {
   importCapsule
 } from "./chunk-ZHXSOMYH.js";
@@ -377,23 +379,30 @@ import {
 } from "./chunk-ROBHL3GL.js";
 import {
   HourlySummarizer
-} from "./chunk-FCSZ4K2X.js";
+} from "./chunk-BJJWRWER.js";
 import {
   LastRecallStore,
   RecallHandleHistoryStore,
   TierMigrationStatusStore,
   clampGraphRecallExpandedEntries
 } from "./chunk-5UBH37SL.js";
+import {
+  filterRecallCandidates,
+  isGenericRecallExcludedPath,
+  isTopLevelArchivePath,
+  journalPath,
+  writeJournalFile
+} from "./chunk-A5UQ52YQ.js";
 import {
   buildXraySnapshot
-} from "./chunk-2JVJ7UHC.js";
+} from "./chunk-XQU3CPF2.js";
 import {
   objectiveStateStoreOverrideForNamespace,
   searchObjectiveStateSnapshots
 } from "./chunk-HM7RHKS4.js";
 import {
   searchHarmonicRetrieval
-} from "./chunk-SB6PSOP7.js";
+} from "./chunk-QLJ6762U.js";
 import {
   ProfilingCollector
 } from "./chunk-NLE6TSLG.js";
@@ -402,14 +411,14 @@ import {
 } from "./chunk-WLZYGLJ4.js";
 import {
   LocalLlmClient
-} from "./chunk-A7XEPMQ6.js";
+} from "./chunk-LAVJC57X.js";
 import {
   contentMatchesRedactionRules,
   loadRedactionRules
 } from "./chunk-LTHVM4XN.js";
 import {
   shouldSkipImplicitExtraction
-} from "./chunk-XUE46UYW.js";
+} from "./chunk-ZLN7AROH.js";
 import {
   boundRecallContextComposition,
   composeRecallContext,
@@ -423,7 +432,7 @@ import {
 } from "./chunk-BMWN7B3Y.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-ROKKIMON.js";
+} from "./chunk-EJIEQOPB.js";
 import {
   GraphIndex
 } from "./chunk-5FAGCOZD.js";
@@ -432,7 +441,7 @@ import {
 } from "./chunk-GKCXTSFF.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-5N53UBH2.js";
+} from "./chunk-RR7G2X7C.js";
 import {
   QmdResultResolver,
   StorageManager,
@@ -451,7 +460,10 @@ import {
   reconstructFusionInputs,
   selfDeps,
   serializeFusionDay
-} from "./chunk-GVG3JYBI.js";
+} from "./chunk-ZMKYCFJ7.js";
+import {
+  buildRetiredFactTombstoneInputs
+} from "./chunk-46WM6JX2.js";
 import {
   bodyIsEscaped,
   decodeTranscriptBody,
@@ -462,18 +474,15 @@ import {
   saveSpeakerRegistry,
   speakerRegistryKey
 } from "./chunk-UHVXE24Y.js";
-import {
-  buildRetiredFactTombstoneInputs
-} from "./chunk-46WM6JX2.js";
 import {
   NamespaceSearchRouter,
   namespaceCollectionName
-} from "./chunk-FHQSPTPZ.js";
+} from "./chunk-6YAIN5XJ.js";
 import {
   createConversationIndexRuntime,
   createSearchBackend,
   isSearchBackendEnabled
-} from "./chunk-7VJXIDOC.js";
+} from "./chunk-4JVQRFZD.js";
 import {
   NoopSearchBackend
 } from "./chunk-CYEPCZN5.js";
@@ -487,7 +496,7 @@ import {
 } from "./chunk-S2V7RUCL.js";
 import {
   confidenceTier
-} from "./chunk-SO7SV523.js";
+} from "./chunk-Q6LCCIZN.js";
 import {
   lintWorkspaceFiles,
   rotateMarkdownFileToArchive
@@ -496,7 +505,10 @@ import {
   applyFaithfulnessVerdict,
   createFaithfulnessCounters,
   runFaithfulnessGateBatch
-} from "./chunk-DCJ3YFIC.js";
+} from "./chunk-S2ULTQZR.js";
+import {
+  casCommittedRevisionOf
+} from "./chunk-SHEHQBCG.js";
 import {
   checkCorpusReadAbort
 } from "./chunk-5GINB5LC.js";
@@ -537,18 +549,20 @@ import {
   isValidAsOf,
   isValidityExpiredNow
 } from "./chunk-6CIAGZ6X.js";
+import {
+  ExtractionDeadlineError,
+  ExtractionRunCoordinator,
+  classifyExtractionOrigin
+} from "./chunk-326KUXIR.js";
 import {
   ARTIFACT_STATUS_CACHE_TTL_MS,
   BulkImportBatchPartialFailureError,
   COMPACTION_SIGNAL_MAX_AGE_MS,
-  ExtractionDeadlineError,
-  ExtractionRunCoordinator,
   abortRecallError,
   appendMemoryToGraphContext,
   applyQueryAwareCandidateFilter,
   buildMemoryPathById,
   buildQmdIntentHint,
-  classifyExtractionOrigin,
   computeArtifactCandidateFetchLimit,
   computeArtifactRecallLimit,
   computeQmdHybridFetchLimit,
@@ -578,21 +592,13 @@ import {
   throwIfRecallAborted,
   tokenizeRecallQuery,
   utcDateKeysForLocalDay
-} from "./chunk-XQ2Q43XD.js";
+} from "./chunk-TLHNF6GA.js";
 import {
   inferIntentFromText,
   intentCompatibilityScore,
   isTaskInitiationIntent,
   planRecallMode
 } from "./chunk-CSAKJVXW.js";
-import {
-  TAG_LIMITS,
-  composeMemoryEnvelope,
-  isMemoryCategory
-} from "./chunk-3QQTXYZ6.js";
-import {
-  normalizeTags
-} from "./chunk-BT7NVCML.js";
 import {
   buildQmdRecallCacheKey,
   getCachedQmdRecall,
@@ -602,10 +608,7 @@ import {
   FallbackLlmClient,
   fallbackLlmRuntimeContextFromConfig,
   gatewayTaskChainOptions
-} from "./chunk-TLPZ6MKZ.js";
-import {
-  extractJsonCandidates
-} from "./chunk-RGMVMVMF.js";
+} from "./chunk-YEN4TREG.js";
 import {
   assertExternalWikiRootOutsideMemoryDirCanonical
 } from "./chunk-JV3C2MNQ.js";
@@ -621,16 +624,14 @@ import {
   hashActivityBody,
   isValidActivityDate,
   timezoneOffsetIso
-} from "./chunk-S7DPKM5W.js";
-import {
-  evaluateSubjectGuard,
-  isSharedPromotionTarget,
-  resolveWriteSubject
-} from "./chunk-VYCOJKSX.js";
+} from "./chunk-353C5UNV.js";
 import {
   isUntrustedOrigin,
   parseOriginClass
 } from "./chunk-6Q3ZTEF6.js";
+import {
+  extractJsonCandidates
+} from "./chunk-RGMVMVMF.js";
 import {
   createBoundedCoreSectionRunner,
   createRecallSectionMetricRecorder,
@@ -660,16 +661,13 @@ import {
   getConfiguredNamespaces,
   resolveNamespaceFromStorageDir,
   resolveScopePlan
-} from "./chunk-XU6OEECT.js";
+} from "./chunk-OQQXGYMX.js";
 import {
   attachCitation,
   hasCitationForTemplate,
   lastCitationMarkerForTemplate,
   stripCitationForTemplate
 } from "./chunk-TG3FAM2S.js";
-import {
-  openBetterSqlite3
-} from "./chunk-RL6NEVXT.js";
 import {
   assertPathInsideRoot
 } from "./chunk-C7HJ3NEI.js";
@@ -678,26 +676,10 @@ import {
   isActiveMemoryStatus,
   toMemoryPathRel
 } from "./chunk-7RJUVTVF.js";
-import {
-  ContentHashIndex
-} from "./chunk-NB3LRY4T.js";
 import {
   excludeSupportPassportPrivateMemories,
   isSupportPassportPrivateMemory
-} from "./chunk-EEOUMG3J.js";
-import {
-  normalizeAttributePairs,
-  stripAttributesSuffix
-} from "./chunk-JDSVLVCG.js";
-import {
-  sanitizeMemoryContent
-} from "./chunk-5GKPFL3S.js";
-import {
-  MEMORY_ID_PATTERN,
-  parseIdOrHandle,
-  resolveHandle,
-  stripHandles
-} from "./chunk-JAKIDQB2.js";
+} from "./chunk-PWPIERBM.js";
 import {
   CAPSULE_ID_PATTERN
 } from "./chunk-WEHSQBFR.js";
@@ -705,6 +687,19 @@ import {
   keyring_exports,
   secureStoreDir
 } from "./chunk-BJMBJZ2Y.js";
+import {
+  TAG_LIMITS,
+  composeMemoryEnvelope,
+  isMemoryCategory
+} from "./chunk-LSLCFCCQ.js";
+import {
+  normalizeTags
+} from "./chunk-BT7NVCML.js";
+import {
+  evaluateSubjectGuard,
+  isSharedPromotionTarget,
+  resolveWriteSubject
+} from "./chunk-VYCOJKSX.js";
 import {
   buildRetrievedMemoryProvenance
 } from "./chunk-I4WBNM3M.js";
@@ -712,6 +707,25 @@ import {
   assertIsDirectoryNotSymlink,
   assertRealpathInsideRoot
 } from "./chunk-GCGJW34D.js";
+import {
+  ContentHashIndex
+} from "./chunk-NB3LRY4T.js";
+import {
+  withHeldFileLock
+} from "./chunk-FFAZ2XFU.js";
+import {
+  normalizeAttributePairs,
+  stripAttributesSuffix
+} from "./chunk-JDSVLVCG.js";
+import {
+  sanitizeMemoryContent
+} from "./chunk-5GKPFL3S.js";
+import {
+  MEMORY_ID_PATTERN,
+  parseIdOrHandle,
+  resolveHandle,
+  stripHandles
+} from "./chunk-JAKIDQB2.js";
 import {
   parseFlexibleIsoTimestamp
 } from "./chunk-P7FMDTKL.js";
@@ -754,7 +768,7 @@ import {
 import {
   lcmSessionKeyForNamespace,
   resolveCodingNamespaceOverlay
-} from "./chunk-NZXEK3UF.js";
+} from "./chunk-3Q3N35W7.js";
 import {
   expandTildePath
 } from "./chunk-6KH5NLQS.js";
@@ -2348,7 +2362,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
       namespaces,
       {
         readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
-        readMemoryFrontmatter: async (path39, preferredNamespace) => {
+        readMemoryFrontmatter: async (path40, preferredNamespace) => {
           if (!fallbackReader) {
             for (const ns of namespaces) {
               try {
@@ -2360,7 +2374,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
           }
           if (!fallbackReader) return null;
           const memory = await this.readQmdResultMemory(
-            path39,
+            path40,
             fallbackReader,
             namespaces,
             preferredNamespace
@@ -4909,6 +4923,89 @@ async function decideSemanticDedup(content, lookup, options) {
   };
 }
 
+// src/orchestration/semantic-merge-promotion-payload.ts
+async function buildMergedTargetPromotionPayload(storage, merge) {
+  if (!merge.provenancePatched) {
+    log.warn(
+      `semantic-merge: skipping merged-target promotion for ${merge.targetId} \u2014 provenance patch did not land; the record still holds pre-merge trust metadata`
+    );
+    return { payload: null, readFailed: false };
+  }
+  let committed;
+  try {
+    committed = await storage.getMemoryByIdIncludingArchived(merge.targetId);
+  } catch (err) {
+    log.warn(
+      `semantic-merge: merged-target promotion reread failed for ${merge.targetId} (non-fatal; promotion skipped, the committed merge stands): ${err instanceof Error ? err.message : String(err)}`
+    );
+    return { payload: null, readFailed: true };
+  }
+  if (!committed || committed.content !== merge.mergedContent) {
+    return { payload: null, readFailed: false };
+  }
+  if (inferMemoryStatus(committed.frontmatter, committed.path) !== "active") {
+    return { payload: null, readFailed: false };
+  }
+  const fm = committed.frontmatter;
+  const snapshotDigest = typeof storage.readDurableFileDigest === "function" ? await storage.readDurableFileDigest(committed.path).catch(() => null) : null;
+  const receipt = await readPromotionReceiptStatus(storage, committed.path);
+  if (!receipt.available) {
+    log.warn(
+      `semantic-merge: merged-target promotion refused for ${merge.targetId} \u2014 the CAS revision receipt for ${committed.path} is unavailable (${receipt.reason}); promotion and reconciliation retry on the next merge`
+    );
+    return { payload: null, readFailed: true };
+  }
+  if (receipt.committedDigest !== void 0 && snapshotDigest !== receipt.committedDigest) {
+    log.warn(
+      snapshotDigest == null ? `semantic-merge: merged-target promotion refused for ${merge.targetId} \u2014 the record snapshot digest is unavailable while the CAS receipt carries committed digest ${receipt.committedDigest}; promotion and reconciliation retry on the next merge` : `semantic-merge: merged-target promotion refused for ${merge.targetId} \u2014 record snapshot digest (${snapshotDigest}) does not match committed receipt digest (${receipt.committedDigest}); record metadata was mutated concurrently`
+    );
+    return { payload: null, readFailed: true };
+  }
+  return {
+    payload: {
+      category: fm.category,
+      content: committed.content,
+      confidence: fm.confidence,
+      tags: fm.tags ?? [],
+      sourceMemoryId: fm.id,
+      origin: parseOriginClass(fm.origin),
+      source: fm.source,
+      ...fm.entityRef !== void 0 ? { entityRef: fm.entityRef } : {},
+      ...fm.structuredAttributes !== void 0 ? { structuredAttributes: { ...fm.structuredAttributes } } : {},
+      ...fm.importance !== void 0 ? { importance: fm.importance } : {},
+      ...fm.intentGoal !== void 0 ? { intentGoal: fm.intentGoal } : {},
+      ...fm.intentActionType !== void 0 ? { intentActionType: fm.intentActionType } : {},
+      ...fm.intentEntityTypes !== void 0 ? { intentEntityTypes: [...fm.intentEntityTypes] } : {},
+      ...fm.memoryKind !== void 0 ? { memoryKind: fm.memoryKind } : {},
+      ...fm.valid_at !== void 0 ? { validAt: fm.valid_at } : {},
+      ...fm.invalid_at !== void 0 ? { invalidAt: fm.invalid_at } : {},
+      ...fm.observedAt !== void 0 ? { observedAt: fm.observedAt } : {},
+      ...fm.eventTimeSource !== void 0 ? { eventTimeSource: fm.eventTimeSource } : {},
+      ...fm.sources && fm.sources.length > 0 ? { sources: fm.sources.map((source) => ({ ...source })) } : {},
+      ...fm.provenance !== void 0 ? { provenance: fm.provenance } : {},
+      ...fm.subject !== void 0 ? { subject: fm.subject } : {},
+      ...fm.toolScoped === true ? { toolScoped: true } : {},
+      ...fm.sourceConnector !== void 0 ? { sourceConnector: fm.sourceConnector } : {},
+      ...receipt.revision !== void 0 ? { committedRevision: receipt.revision } : {},
+      ...receipt.committedDigest !== void 0 ? { committedDigest: receipt.committedDigest } : snapshotDigest !== null ? { committedDigest: snapshotDigest } : {}
+    },
+    readFailed: false
+  };
+}
+async function readPromotionReceiptStatus(storage, filePath) {
+  try {
+    const status = await storage.readCasRevisionStatus(filePath);
+    if (status.status === "unavailable") return { available: false, reason: status.reason };
+    return {
+      available: true,
+      revision: status.status === "present" ? status.revision : void 0,
+      committedDigest: status.status === "present" ? status.committedDigest : void 0
+    };
+  } catch (err) {
+    return { available: false, reason: err instanceof Error ? err.message : String(err) };
+  }
+}
+
 // src/orchestration/extraction-persist-promotion.ts
 var confidenceTierOrder = [
   "explicit",
@@ -5045,16 +5142,30 @@ function createBatchPromotedCopyProbe(config, getStorageRouter, scopeProfileWrit
   };
 }
 async function promoteAndReconcileMergedTarget(args) {
+  if (args.mergedPromotion === null && args.mergedPromotionReadFailed === true) {
+    log.warn(
+      `persistExtraction: merged-target promotion reconciliation skipped for ${args.sourceMemoryId} \u2014 the committed record was unreadable at payload-build time, so no promotion outcome is confirmed`
+    );
+    return;
+  }
   let promotedCopyId;
   if (args.mergedPromotion) {
     const payload = args.mergedPromotion;
     const current = await args.sourceStorage.getMemoryByIdIncludingArchived(args.sourceMemoryId).catch(() => null);
-    if (!current || inferMemoryStatus(current.frontmatter, current.path) !== "active" || current.content !== payload.content || (current.frontmatter.updated ?? void 0) !== (payload.committedRevision ?? void 0)) {
+    if (!current || inferMemoryStatus(current.frontmatter, current.path) !== "active" || current.content !== payload.content) {
       log.warn(
         `persistExtraction: merged-target promotion abandoned for ${args.sourceMemoryId} \u2014 the committed record advanced past the cached payload, so the newer writer's copy stands`
       );
       return;
     }
+    const standingReceipt = await readPromotionReceiptStatus(args.sourceStorage, current.path);
+    const standingDigest = typeof args.sourceStorage.readDurableFileDigest === "function" ? await args.sourceStorage.readDurableFileDigest(current.path).catch(() => null) : null;
+    if (!standingReceipt.available || (standingReceipt.revision ?? void 0) !== (payload.committedRevision ?? void 0) || payload.committedDigest !== void 0 && standingReceipt.committedDigest !== void 0 && standingReceipt.committedDigest !== payload.committedDigest || payload.committedDigest !== void 0 && standingDigest !== null && standingDigest !== payload.committedDigest) {
+      log.warn(
+        `persistExtraction: merged-target promotion abandoned for ${args.sourceMemoryId} \u2014 the committed record's CAS receipt or digest ${standingReceipt.available ? "does not match the cached payload's" : "is unreadable"}, so the cached body is not confirmed`
+      );
+      return;
+    }
     try {
       promotedCopyId = await args.promote(payload);
     } catch (err) {
@@ -5140,22 +5251,35 @@ function filterHarmonicEntityMentions(facts, entityMentions) {
     return activeFacts.length > 0 ? [{ ...entity, facts: activeFacts.map((fact) => fact.content) }] : [];
   });
 }
-function enqueueMergedTargetForHarmonicConstruction(entries, storage, fact, memoryId, content, insertedAt) {
+async function enqueueMergedTargetForHarmonicConstruction(entries, storage, fact, memoryId, content, insertedAt) {
+  let committed = null;
+  try {
+    committed = await storage.getMemoryByIdIncludingArchived(memoryId);
+  } catch {
+    committed = null;
+  }
+  const derived = committed && committed.content === content ? {
+    ...fact,
+    category: committed.frontmatter.category,
+    tags: [.../* @__PURE__ */ new Set([...committed.frontmatter.tags ?? [], ...fact.tags])],
+    entityRef: committed.frontmatter.entityRef ?? fact.entityRef,
+    validAt: committed.frontmatter.valid_at ?? fact.validAt
+  } : fact;
   const entry = entries.get(storage.dir) ?? { storage, facts: [] };
   const prior = entry.facts.findIndex((existing) => existing.memoryId === memoryId);
   if (prior !== -1) {
     entry.facts[prior] = {
-      ...fact,
+      ...derived,
       content,
       memoryId,
       insertedAt,
       cueAnchors: [
         ...entry.facts[prior].cueAnchors ?? [],
-        ...fact.cueAnchors ?? []
+        ...derived.cueAnchors ?? []
       ]
     };
   } else {
-    entry.facts.push({ ...fact, content, memoryId, insertedAt });
+    entry.facts.push({ ...derived, content, memoryId, insertedAt });
   }
   entries.set(storage.dir, entry);
 }
@@ -5236,16 +5360,42 @@ async function readTargetSnapshot(storage, target) {
   if (!current || current.frontmatter.id !== target.frontmatter.id) return null;
   return current;
 }
-async function revertMergedContent(storage, target, mergedContent) {
+async function revertMergedContent(storage, target, mergedContent, committedRevision) {
   try {
     const current = await readTargetSnapshot(storage, target);
-    if (!current) return false;
-    if (current.content !== mergedContent) return true;
+    if (!current) return "stands";
+    if (current.content !== mergedContent) return "reverted";
+    if (committedRevision !== void 0) {
+      let standing;
+      try {
+        standing = await storage.readCasRevisionStatus(target.path);
+      } catch (err) {
+        standing = {
+          status: "unavailable",
+          reason: err instanceof Error ? err.message : String(err)
+        };
+      }
+      if (standing.status === "present") {
+        if (standing.revision !== committedRevision) {
+          return "superseded";
+        }
+      } else if (standing.status === "unavailable") {
+        log.warn(
+          `revertMergedContent: CAS revision status for ${target.path} is unavailable (${standing.reason}); ownership cannot be verified \u2014 keeping the recovery snapshot instead of discarding or reverting`
+        );
+        return "stands";
+      } else {
+        log.warn(
+          `revertMergedContent: CAS revision receipt for ${target.path} is absent although this writer holds receipt ${committedRevision}; ownership cannot be verified \u2014 keeping the recovery snapshot`
+        );
+        return "stands";
+      }
+    }
     return await storage.updateMemoryIfUnchanged(current, target.content, {
       actor: "semantic-merge-rollback"
-    });
+    }) ? "reverted" : "stands";
   } catch {
-    return false;
+    return "stands";
   }
 }
 async function persistMergedTargetThreadEpisode(threading, threadId, targetId) {
@@ -5270,7 +5420,11 @@ async function rewriteMergedTargetGraphEdges(storage, input) {
   try {
     appended = await input.build() ?? void 0;
     const committedNow = await storage.getMemoryByIdIncludingArchived(input.targetId);
-    if (!committedNow || committedNow.content !== input.mergedContent || committedNow.frontmatter.updated !== input.revisionChecked) {
+    const committedRevision = committedNow === null ? void 0 : await storage.readCasRevision(committedNow.path).catch((err) => {
+      log.warn(`rewriteMergedTargetGraphEdges: failed to read CAS revision for ${committedNow.path}: ${err}`);
+      return void 0;
+    });
+    if (!committedNow || committedNow.content !== input.mergedContent || committedRevision !== input.revisionChecked) {
       await rollbackNodeEdgeRewrite(storage.dir, input.memoryRelPath, input.rewriteTypes, removedEdges, input.targetId, appended);
       return false;
     }
@@ -5730,7 +5884,7 @@ async function applySemanticMergeAtPersist(deps, options) {
     }
   };
   const nowIso = (options.now ? options.now() : /* @__PURE__ */ new Date()).toISOString();
-  let contentCommitted = false;
+  let casRevision;
   let mergePatch;
   try {
     mergePatch = buildMergeFrontmatterUpdate({
@@ -5752,7 +5906,7 @@ async function applySemanticMergeAtPersist(deps, options) {
       );
       return { action: "created", reason: "target_changed" };
     }
-    contentCommitted = true;
+    casRevision = updated;
     const merged = await readTargetSnapshot(options.storage, target);
     if (!merged || merged.content !== committedContent) {
       throw new Error("target replaced before the provenance patch");
@@ -5770,6 +5924,8 @@ async function applySemanticMergeAtPersist(deps, options) {
     const patched = await options.storage.writeMemoryFrontmatterIfUnchanged(
       merged,
       {
+        // #2807: business/event time, exactly what an ordinary write would
+        // stamp — receipt identity is the sidecar token storage mints.
         updated: mergePatch.updated,
         derived_via: mergePatch.derived_via,
         reinforcement_count: mergePatch.reinforcement_count,
@@ -5800,7 +5956,67 @@ async function applySemanticMergeAtPersist(deps, options) {
     if (!patched) throw new Error("frontmatter patch rejected (target changed)");
   } catch (err) {
     const detail = err instanceof Error ? err.message : String(err);
-    if (contentCommitted && !await revertMergedContent(options.storage, target, committedContent)) {
+    const committedRevision = casCommittedRevisionOf(err) ?? casRevision;
+    const landed = committedRevision !== void 0;
+    if (!landed) {
+      let observed = null;
+      try {
+        observed = await readTargetSnapshot(options.storage, target);
+      } catch {
+      }
+      if (observed?.content === committedContent) {
+        await discardMergedTargetSnapshot(
+          target.path,
+          versioning,
+          options.storage.dir,
+          decision.targetId,
+          versionId
+        );
+        await repairIndexes(committedMergedFactHash(deps, options.category, committedContent));
+        log.warn(
+          `semantic-merge: update failed for ${decision.targetId} (the compare-and-swap threw before this writer's mutation; the standing merged body is another writer's identical commit \u2014 snapshot ${versionId} discarded, the concurrent commit left untouched): ${detail}`
+        );
+        return {
+          action: "merged",
+          targetId: decision.targetId,
+          mergedContent: committedContent,
+          provenancePatched: false
+        };
+      } else if (observed?.content === target.content) {
+        await discardMergedTargetSnapshot(
+          target.path,
+          versioning,
+          options.storage.dir,
+          decision.targetId,
+          versionId
+        );
+        log.warn(
+          `semantic-merge: update failed for ${decision.targetId} (the compare-and-swap threw before changing the target; snapshot ${versionId} discarded \u2014 the reread holds the pre-merge body): ${detail}`
+        );
+        return { action: "created", reason: "update_failed" };
+      }
+    }
+    const revert = landed ? await revertMergedContent(options.storage, target, committedContent, committedRevision) : void 0;
+    if (revert === "superseded") {
+      await discardMergedTargetSnapshot(
+        target.path,
+        versioning,
+        options.storage.dir,
+        decision.targetId,
+        versionId
+      );
+      await repairIndexes(committedMergedFactHash(deps, options.category, committedContent));
+      log.warn(
+        `semantic-merge: update failed for ${decision.targetId} (the standing merged body advanced past this writer's commit receipt \u2014 another writer's identical commit stands; snapshot ${versionId} discarded, the concurrent commit left untouched): ${detail}`
+      );
+      return {
+        action: "merged",
+        targetId: decision.targetId,
+        mergedContent: committedContent,
+        provenancePatched: false
+      };
+    }
+    if (landed && revert !== "reverted") {
       log.error(
         `semantic-merge: ${decision.targetId} holds merged content without provenance metadata and the rollback failed (${detail}); snapshot ${versionId} holds the pre-merge state \u2014 recover with revertToVersion. Not creating a duplicate fact.`
       );
@@ -5813,7 +6029,7 @@ async function applySemanticMergeAtPersist(deps, options) {
         provenancePatched: false
       };
     }
-    if (contentCommitted) {
+    if (landed) {
       await discardMergedTargetSnapshot(
         target.path,
         versioning,
@@ -5823,7 +6039,7 @@ async function applySemanticMergeAtPersist(deps, options) {
       );
     }
     log.warn(
-      `semantic-merge: update failed for ${decision.targetId}${contentCommitted ? ` (content rolled back; snapshot ${versionId} rolled back out of history)` : ` (snapshot ${versionId} staged)`}: ${detail}`
+      `semantic-merge: update failed for ${decision.targetId}${landed ? ` (content rolled back; snapshot ${versionId} rolled back out of history)` : ` (snapshot ${versionId} staged)`}: ${detail}`
     );
     return { action: "created", reason: "update_failed" };
   }
@@ -5880,6 +6096,7 @@ async function runMergedTargetPostEffects(deps, storage, merge, input) {
     episodes.push(merge.targetId);
   }
   if (!input.graphCaps.multiGraphMemory) return signals;
+  let rewriteInstalled = false;
   try {
     const committed = await storage.getMemoryByIdIncludingArchived(merge.targetId);
     if (!committed || committed.content !== merge.mergedContent) return signals;
@@ -5897,11 +6114,12 @@ async function runMergedTargetPostEffects(deps, storage, merge, input) {
     if (input.graphCaps.entityGraph) rewriteTypes.push("entity");
     if (input.graphCaps.timeGraph) rewriteTypes.push("time");
     if (input.graphCaps.causalGraph) rewriteTypes.push("causal");
-    const installed = await rewriteMergedTargetGraphEdges(storage, {
+    rewriteInstalled = await rewriteMergedTargetGraphEdges(storage, {
       targetId: merge.targetId,
       memoryRelPath,
       mergedContent: merge.mergedContent,
-      revisionChecked: committed.frontmatter.updated,
+      // #2807: the dedicated CAS revision token, not public `updated`.
+      revisionChecked: await storage.readCasRevision(committed.path),
       rewriteTypes,
       build: () => deps.buildGraphEdge(
         storage,
@@ -5917,60 +6135,13 @@ async function runMergedTargetPostEffects(deps, storage, merge, input) {
         input.graphCaps
       )
     });
-    if (installed) input.graphContext.previousPersistedRelPath = memoryRelPath;
+    if (rewriteInstalled) input.graphContext.previousPersistedRelPath = memoryRelPath;
   } catch {
   }
-  return signals;
-}
-
-// src/orchestration/semantic-merge-promotion-payload.ts
-async function buildMergedTargetPromotionPayload(storage, merge) {
-  if (!merge.provenancePatched) {
-    log.warn(
-      `semantic-merge: skipping merged-target promotion for ${merge.targetId} \u2014 provenance patch did not land; the record still holds pre-merge trust metadata`
-    );
-    return null;
-  }
-  let committed;
-  try {
-    committed = await storage.getMemoryByIdIncludingArchived(merge.targetId);
-  } catch (err) {
-    log.warn(
-      `semantic-merge: merged-target promotion reread failed for ${merge.targetId} (non-fatal; promotion skipped, the committed merge stands): ${err instanceof Error ? err.message : String(err)}`
-    );
-    return null;
-  }
-  if (!committed || committed.content !== merge.mergedContent) return null;
-  if (inferMemoryStatus(committed.frontmatter, committed.path) !== "active") {
-    return null;
+  if (!rewriteInstalled) {
+    deps.invalidateGraphEdgeCache?.(storage);
   }
-  const fm = committed.frontmatter;
-  return {
-    category: fm.category,
-    content: committed.content,
-    confidence: fm.confidence,
-    tags: fm.tags ?? [],
-    sourceMemoryId: fm.id,
-    origin: parseOriginClass(fm.origin),
-    source: fm.source,
-    ...fm.entityRef !== void 0 ? { entityRef: fm.entityRef } : {},
-    ...fm.structuredAttributes !== void 0 ? { structuredAttributes: { ...fm.structuredAttributes } } : {},
-    ...fm.importance !== void 0 ? { importance: fm.importance } : {},
-    ...fm.intentGoal !== void 0 ? { intentGoal: fm.intentGoal } : {},
-    ...fm.intentActionType !== void 0 ? { intentActionType: fm.intentActionType } : {},
-    ...fm.intentEntityTypes !== void 0 ? { intentEntityTypes: [...fm.intentEntityTypes] } : {},
-    ...fm.memoryKind !== void 0 ? { memoryKind: fm.memoryKind } : {},
-    ...fm.valid_at !== void 0 ? { validAt: fm.valid_at } : {},
-    ...fm.invalid_at !== void 0 ? { invalidAt: fm.invalid_at } : {},
-    ...fm.observedAt !== void 0 ? { observedAt: fm.observedAt } : {},
-    ...fm.eventTimeSource !== void 0 ? { eventTimeSource: fm.eventTimeSource } : {},
-    ...fm.sources && fm.sources.length > 0 ? { sources: fm.sources.map((source) => ({ ...source })) } : {},
-    ...fm.provenance !== void 0 ? { provenance: fm.provenance } : {},
-    ...fm.subject !== void 0 ? { subject: fm.subject } : {},
-    ...fm.toolScoped === true ? { toolScoped: true } : {},
-    ...fm.sourceConnector !== void 0 ? { sourceConnector: fm.sourceConnector } : {},
-    ...fm.updated !== void 0 ? { committedRevision: fm.updated } : {}
-  };
+  return signals;
 }
 
 // src/orchestration/extraction-anchor-snapshot.ts
@@ -7486,11 +7657,11 @@ var ExtractionPersistCoordinator = class {
         semanticMergedCount++;
         await anchorSnapshots.replace(targetStorage, semanticMerge.targetId, writeCategory, memoryPathById);
         const mergedPromotion = await buildMergedTargetPromotionPayload(targetStorage, semanticMerge);
-        await promoteAndReconcileMergedTarget({ promote: (payload) => promoteMemoryToShared({ sourceStorage: targetStorage, ...payload }), config: this.deps.config, getStorageRouter: this.deps.getStorageRouter, scopeProfileWritePlan, sourceStorage: targetStorage, sourceMemoryId: semanticMerge.targetId, mergedPromotion, normalize: normalizeStoredHashSource, onReconciled: () => promotedCopyProbe.invalidate() });
+        await promoteAndReconcileMergedTarget({ promote: (payload) => promoteMemoryToShared({ sourceStorage: targetStorage, ...payload }), config: this.deps.config, getStorageRouter: this.deps.getStorageRouter, scopeProfileWritePlan, sourceStorage: targetStorage, sourceMemoryId: semanticMerge.targetId, mergedPromotion: mergedPromotion.payload, mergedPromotionReadFailed: mergedPromotion.readFailed, normalize: normalizeStoredHashSource, onReconciled: () => promotedCopyProbe.invalidate() });
         trackPersistedId(targetStorage, semanticMerge.targetId, { includeReturnedIds: false });
         await persistMergedTargetThreadEpisode(this.deps.getThreading(), threadIdForExtraction, semanticMerge.targetId);
         if (harmonicConstructionEnabled) {
-          enqueueMergedTargetForHarmonicConstruction(harmonicFactsByStorage, targetStorage, harmonicFact, semanticMerge.targetId, semanticMerge.mergedContent, new Date(harmonicSourceInsertedAtBase + harmonicSourceOrder++).toISOString());
+          await enqueueMergedTargetForHarmonicConstruction(harmonicFactsByStorage, targetStorage, harmonicFact, semanticMerge.targetId, semanticMerge.mergedContent, new Date(harmonicSourceInsertedAtBase + harmonicSourceOrder++).toISOString());
         }
         trackBehaviorSignals(targetStorage, await runMergedTargetPostEffects(this.deps, targetStorage, semanticMerge, {
           category: writeCategory,
@@ -10070,6 +10241,7 @@ var RecallInternalCoordinator = class {
         cronConversationRecallMode: this.deps.config.cronConversationRecallMode
       });
       const retrievalQuery = queryPolicy.retrievalQuery || prompt;
+      const stateViewActive = resolveRecallStateViewActive(options, this.deps.config, retrievalQuery);
       const retrievalQueryHash = createHash5("sha256").update(retrievalQuery).digest("hex");
       const policyVersion = this.deps.currentPolicyVersion();
       let recallSource = "none";
@@ -12798,6 +12970,7 @@ ${tmtNode.summary}`
           void 0,
           {
             asOfMs,
+            stateViewActive,
             // If QMD had already settled before the ordered assembly reached it,
             // do not let unrelated slow enrichment turn those known results into
             // unchecked misses. QMD that only settles during its own wait remains
@@ -12816,7 +12989,7 @@ ${tmtNode.summary}`
             recallNamespaces,
             retrievalQuery,
             qmdBoostInput.memoryByPath,
-            { asOfMs, requestingConnector: options.sourceConnector }
+            { asOfMs, stateViewActive, requestingConnector: options.sourceConnector }
           ),
           qmdBoostInput.results
         );
@@ -12957,6 +13130,8 @@ ${tmtNode.summary}`
               injectedChars: identityInjectedChars,
               truncated: identityInjectionTruncated
             },
+            stateViewActive,
+            asOfMs,
             trustByPath: recallTrustByPath
           });
           recalledMemoryPaths = memoryResults.map((result) => result.path).filter(Boolean);
@@ -12990,7 +13165,7 @@ ${tmtNode.summary}`
                   recallNamespaces,
                   retrievalQuery,
                   void 0,
-                  { asOfMs, requestingConnector: options.sourceConnector }
+                  { asOfMs, stateViewActive, requestingConnector: options.sourceConnector }
                 );
                 xrayBranchPoolSize.hot_embedding = Math.max(
                   xrayBranchPoolSize.hot_embedding,
@@ -13062,6 +13237,8 @@ ${tmtNode.summary}`
                   injectedChars: identityInjectedChars,
                   truncated: identityInjectionTruncated
                 },
+                stateViewActive,
+                asOfMs,
                 trustByPath: recallTrustByPath
               });
               recalledMemoryPaths = scoped.map((result) => result.path).filter(Boolean);
@@ -13070,6 +13247,7 @@ ${tmtNode.summary}`
               const coldPartitionSink = options.xrayCapture === true ? { partition: null } : void 0;
               const longTerm = await this.deps.applyColdFallbackPipeline({
                 prompt: retrievalQuery,
+                stateViewActive,
                 recallNamespaces,
                 recallResultLimit,
                 recallMode,
@@ -13110,6 +13288,8 @@ ${tmtNode.summary}`
                     injectedChars: identityInjectedChars,
                     truncated: identityInjectionTruncated
                   },
+                  stateViewActive,
+                  asOfMs,
                   trustByPath: recallTrustByPath
                 });
                 recalledMemoryPaths = longTerm.map((result) => result.path).filter(Boolean);
@@ -13178,7 +13358,7 @@ ${tmtNode.summary}`
                 recallNamespaces,
                 retrievalQuery,
                 void 0,
-                { asOfMs, requestingConnector: options.sourceConnector }
+                { asOfMs, stateViewActive, requestingConnector: options.sourceConnector }
               );
               xrayBranchPoolSize.hot_embedding = Math.max(
                 xrayBranchPoolSize.hot_embedding,
@@ -13250,6 +13430,8 @@ ${tmtNode.summary}`
                 injectedChars: identityInjectedChars,
                 truncated: identityInjectionTruncated
               },
+              stateViewActive,
+              asOfMs,
               trustByPath: recallTrustByPath
             });
             recalledMemoryPaths = scoped.map((result) => result.path).filter(Boolean);
@@ -13263,22 +13445,15 @@ ${tmtNode.summary}`
               []
             );
             if (memories.length > 0) {
-              const supersessionOptions = {
-                enabled: lifecycleCaps.temporalSupersession,
-                includeInRecall: this.deps.config.temporalSupersessionIncludeInRecall
-              };
-              const asOfActive = typeof asOfMs === "number" && Number.isFinite(asOfMs);
-              const activeMemories = memories.filter(
-                (m) => {
-                  if (isGenericRecallExcludedPath(m.path, this.deps.config)) return false;
-                  const status = m.frontmatter.status;
-                  if (!status || status === "active") return true;
-                  if (status === "superseded") {
-                    if (asOfActive) return true;
-                    return !shouldFilterSupersededFromRecall(m.frontmatter, supersessionOptions);
-                  }
-                  return false;
-                }
+              const activeMemories = filterRecentScanMemoriesForStateView(
+                memories,
+                this.deps.config,
+                {
+                  enabled: lifecycleCaps.temporalSupersession,
+                  includeInRecall: this.deps.config.temporalSupersessionIncludeInRecall
+                },
+                stateViewActive,
+                asOfMs
               );
               const queryAwareScopedMemories = queryAwarePrefilter.candidatePaths ? activeMemories.filter(
                 (memory) => queryAwarePrefilter.candidatePaths?.has(memory.path)
@@ -13287,6 +13462,7 @@ ${tmtNode.summary}`
                 const coldPartitionSink = options.xrayCapture === true ? { partition: null } : void 0;
                 const longTerm = await this.deps.applyColdFallbackPipeline({
                   prompt: retrievalQuery,
+                  stateViewActive,
                   recallNamespaces,
                   recallResultLimit,
                   recallMode,
@@ -13321,6 +13497,8 @@ ${tmtNode.summary}`
                       injectedChars: identityInjectedChars,
                       truncated: identityInjectionTruncated
                     },
+                    stateViewActive,
+                    asOfMs,
                     trustByPath: recallTrustByPath
                   });
                   recalledMemoryPaths = longTerm.map((result) => result.path).filter(Boolean);
@@ -13351,7 +13529,7 @@ ${tmtNode.summary}`
                       recallNamespaces,
                       retrievalQuery,
                       preloadedMap,
-                      { asOfMs, requestingConnector: options.sourceConnector }
+                      { asOfMs, stateViewActive, requestingConnector: options.sourceConnector }
                     )).sort((a, b) => b.score - a.score);
                     xrayBranchPoolSize.recent_scan = Math.max(
                       xrayBranchPoolSize.recent_scan,
@@ -13426,6 +13604,8 @@ ${tmtNode.summary}`
                       injectedChars: identityInjectedChars,
                       truncated: identityInjectionTruncated
                     },
+                    stateViewActive,
+                    asOfMs,
                     trustByPath: recallTrustByPath
                   });
                   recalledMemoryPaths = recent.map((result) => result.path).filter(Boolean);
@@ -13434,6 +13614,7 @@ ${tmtNode.summary}`
                   const coldPartitionSink = options.xrayCapture === true ? { partition: null } : void 0;
                   const longTerm = await this.deps.applyColdFallbackPipeline({
                     prompt: retrievalQuery,
+                    stateViewActive,
                     recallNamespaces,
                     recallResultLimit,
                     recallMode,
@@ -13474,6 +13655,8 @@ ${tmtNode.summary}`
                         injectedChars: identityInjectedChars,
                         truncated: identityInjectionTruncated
                       },
+                      stateViewActive,
+                      asOfMs,
                       trustByPath: recallTrustByPath
                     });
                     recalledMemoryPaths = longTerm.map((result) => result.path).filter(Boolean);
@@ -13485,6 +13668,7 @@ ${tmtNode.summary}`
               const coldPartitionSink = options.xrayCapture === true ? { partition: null } : void 0;
               const longTerm = await this.deps.applyColdFallbackPipeline({
                 prompt: retrievalQuery,
+                stateViewActive,
                 recallNamespaces,
                 recallResultLimit,
                 recallMode,
@@ -13525,6 +13709,8 @@ ${tmtNode.summary}`
                     injectedChars: identityInjectedChars,
                     truncated: identityInjectionTruncated
                   },
+                  stateViewActive,
+                  asOfMs,
                   trustByPath: recallTrustByPath
                 });
                 recalledMemoryPaths = longTerm.map((result) => result.path).filter(Boolean);
@@ -13769,8 +13955,12 @@ ${tmtNode.summary}`
             const match = p.match(/([^/\\]+)\.md$/);
             return match ? match[1] ?? null : null;
           };
-          const xrayResultByPath = new Map(
-            xrayRecalledResults.map((xr) => [`${xr.namespace ?? ""}\0${xr.path}`, xr])
+          const xrayResultByPath = indexStateViewAnnotatedResults(
+            xrayRecalledResults,
+            retrievalQuery,
+            this.deps.config,
+            stateViewActive,
+            asOfMs
           );
           const results = [];
           for (let xrayIdx = 0; xrayIdx < recalledMemoryPaths.length; xrayIdx += 1) {
@@ -13815,6 +14005,7 @@ ${tmtNode.summary}`
               servedBy,
               scoreDecomposition,
               admittedBy: [],
+              ...xrayResult?.stateLabel ? { stateView: xrayResult.stateLabel } : {},
               ...xrayResult?.pathNodeIds ? { pathNodeIds: xrayResult.pathNodeIds } : {},
               ...typeof xrayResult?.pathPenaltyApplied === "boolean" ? { pathPenaltyApplied: xrayResult.pathPenaltyApplied } : {},
               ...provenance ? { provenance } : {},
@@ -14582,7 +14773,8 @@ var RecallSearchPipelineCoordinator = class {
         abortSignal: options.abortSignal,
         dropUnresolved: true,
         recallNamespaces: options.recallNamespaces,
-        requestingConnector: options.requestingConnector
+        requestingConnector: options.requestingConnector,
+        stateViewActive: options.stateViewActive
       }
     );
     results = boostInput.results;
@@ -14599,6 +14791,7 @@ var RecallSearchPipelineCoordinator = class {
             {
               allowLifecycleFiltered: true,
               asOfMs: options.asOfMs,
+              stateViewActive: options.stateViewActive,
               requestingConnector: options.requestingConnector
             }
           ),
@@ -14616,6 +14809,7 @@ var RecallSearchPipelineCoordinator = class {
           {
             allowLifecycleFiltered: true,
             asOfMs: options.asOfMs,
+            stateViewActive: options.stateViewActive,
             requestingConnector: options.requestingConnector
           }
         ));
@@ -14796,6 +14990,24 @@ var RecallSearchPipelineCoordinator = class {
     return { memoryByPath, checkedPaths, unreadablePaths, completed: true };
   }
   filterSearchResultsByRecallSafety(results, memoryByPath, options) {
+    const stateViewActive = options?.stateViewActive === true;
+    const stateViewSurvivorIds = stateViewActive ? /* @__PURE__ */ new Set() : null;
+    const stateViewDeferred = [];
+    const stateViewBuilt = stateViewActive ? new Array(results.length).fill(null) : null;
+    const buildRecallRow = (r, memory) => ({
+      ...r,
+      sourceConnector: memory ? memory.frontmatter.sourceConnector : void 0,
+      origin: memory ? memory.frontmatter.origin : void 0,
+      // #1952: an active state view carries the chain fields the inject
+      // seam labels from (id/status/supersededBy/supersededAt).
+      ...stateViewActive && memory ? {
+        id: memory.frontmatter.id,
+        status: memory.frontmatter.status,
+        supersededBy: memory.frontmatter.supersededBy,
+        supersededAt: memory.frontmatter.supersededAt
+      } : {}
+    });
+    let stateViewAdmittedCount = 0;
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(this.deps.config);
     let lifecycleFilteredCount = 0;
     let temporalSupersededFilteredCount = 0;
@@ -14806,7 +15018,9 @@ var RecallSearchPipelineCoordinator = class {
     let connectorPartitionFilteredCount = 0;
     let supportPassportFilteredCount = 0;
     const filtered = [];
-    for (const r of results) {
+    for (let resultIdx = 0; resultIdx < results.length; resultIdx += 1) {
+      const r = results[resultIdx];
+      let stateViewPending = false;
       if (options?.blockedPaths && resultHasKey(options.blockedPaths, r)) {
         blockedPathFilteredCount += 1;
         continue;
@@ -14849,16 +15063,23 @@ var RecallSearchPipelineCoordinator = class {
           // allowLifecycleFiltered=true to include archived/retired
           // candidates, but superseded memories must still be filtered
           // unless temporalSupersessionIncludeInRecall is set.
-          // Skipped entirely when `as_of` is active (above branch); the
-          // half-open `[valid_at, invalid_at)` evaluation in isValidAsOf
-          // is the authoritative gate for historical recall.
+          // #1952: an active state view ADMITS the superseded row when its
+          // successor also survives this filter — history never renders
+          // unanchored, and a successor rejected by any gate here can
+          // never anchor. Admission defers to the post-pass fixpoint.
+          // Skipped entirely when `as_of` is active (above branch);
+          // isValidAsOf stays the authoritative historical gate.
           shouldFilterSupersededFromRecall(memory.frontmatter, {
             enabled: lifecycleCaps.temporalSupersession,
             includeInRecall: this.deps.config.temporalSupersessionIncludeInRecall
           })
         ) {
-          temporalSupersededFilteredCount += 1;
-          continue;
+          if (stateViewActive) {
+            stateViewPending = true;
+          } else {
+            temporalSupersededFilteredCount += 1;
+            continue;
+          }
         }
         if (!asOfActive && this.deps.config.temporalBiTemporal && !this.deps.config.temporalExpiredInInjection && isValidityExpiredNow(memory.frontmatter, Date.now())) {
           biTemporalExpiredFilteredCount += 1;
@@ -14869,16 +15090,54 @@ var RecallSearchPipelineCoordinator = class {
           continue;
         }
       }
-      filtered.push({
-        ...r,
-        sourceConnector: memory ? memory.frontmatter.sourceConnector : void 0,
-        origin: memory ? memory.frontmatter.origin : void 0
-      });
-    }
-    if (connectorPartitionFilteredCount > 0) {
-      log.debug(
-        `connector partition filter removed ${connectorPartitionFilteredCount} tool-scoped candidates from recall`
-      );
+      if (stateViewPending) {
+        stateViewDeferred.push(resultIdx);
+        continue;
+      }
+      const builtRow = buildRecallRow(r, memory);
+      if (stateViewBuilt !== null) {
+        stateViewBuilt[resultIdx] = builtRow;
+        if (memory) {
+          const id = memory.frontmatter.id;
+          if (typeof id === "string" && id.length > 0) stateViewSurvivorIds.add(id);
+        }
+      }
+      filtered.push(builtRow);
+    }
+    if (stateViewDeferred.length > 0) {
+      const admitted = /* @__PURE__ */ new Set();
+      for (let progress = true; progress; ) {
+        progress = false;
+        for (const deferredIdx of stateViewDeferred) {
+          if (admitted.has(deferredIdx)) continue;
+          const deferredMemory = memoryForResult(memoryByPath, results[deferredIdx]);
+          if (!deferredMemory) continue;
+          if (stateViewSurvivorIds.has(deferredMemory.frontmatter.supersededBy ?? "")) {
+            admitted.add(deferredIdx);
+            const id = deferredMemory.frontmatter.id;
+            if (typeof id === "string" && id.length > 0) stateViewSurvivorIds.add(id);
+            progress = true;
+          }
+        }
+      }
+      for (const deferredIdx of stateViewDeferred) {
+        const deferredMemory = memoryForResult(memoryByPath, results[deferredIdx]);
+        if (admitted.has(deferredIdx) && deferredMemory) {
+          stateViewAdmittedCount += 1;
+          stateViewBuilt[deferredIdx] = buildRecallRow(results[deferredIdx], deferredMemory);
+        } else {
+          temporalSupersededFilteredCount += 1;
+        }
+      }
+      filtered.length = 0;
+      for (const builtRow of stateViewBuilt) {
+        if (builtRow) filtered.push(builtRow);
+      }
+    }
+    if (connectorPartitionFilteredCount > 0) {
+      log.debug(
+        `connector partition filter removed ${connectorPartitionFilteredCount} tool-scoped candidates from recall`
+      );
     }
     if (supportPassportFilteredCount > 0) {
       log.debug(
@@ -14895,6 +15154,11 @@ var RecallSearchPipelineCoordinator = class {
         `temporal supersession filter removed ${temporalSupersededFilteredCount} superseded candidates`
       );
     }
+    if (stateViewAdmittedCount > 0) {
+      log.debug(
+        `state views admitted ${stateViewAdmittedCount} superseded candidates anchored on in-set successors (#1952)`
+      );
+    }
     if (biTemporalExpiredFilteredCount > 0) {
       log.debug(
         `bi-temporal validity filter removed ${biTemporalExpiredFilteredCount} expired-validity candidates from injection (temporal.biTemporal on)`
@@ -16683,7 +16947,7 @@ var OrchestratorInitCoordinator = class {
     if (signal.aborted) return;
     if (lifecycleCaps.lifecyclePolicy && resolveQmdCapabilities(this.deps.config).qmdTierMigration) {
       try {
-        const { runFirstStartMigration } = await import("./first-start-migration-RC345GPL.js");
+        const { runFirstStartMigration } = await import("./first-start-migration-L3UFX5CU.js");
         const result = await runFirstStartMigration({
           storage: this.deps.storage,
           config: this.deps.config,
@@ -16706,7 +16970,7 @@ var OrchestratorInitCoordinator = class {
     if (signal.aborted) return;
     if (!this.deps.wearablesAutoSyncHandle && this.deps.config.wearables.enabled && this.deps.config.wearables.autoSyncEnabled && Object.values(this.deps.config.wearables.sources).some((source) => source.enabled)) {
       try {
-        const { startWearablesAutoSync } = await import("./auto-sync-NSHLUAQI.js");
+        const { startWearablesAutoSync } = await import("./auto-sync-4YFATLFQ.js");
         if (signal.aborted) return;
         this.deps.wearablesAutoSyncHandle = startWearablesAutoSync(
           {
@@ -20248,7 +20512,9 @@ var RecallEntryCoordinator = class {
     const injectable = applyRecallStateViews(
       trustByPath ? options.results.filter((r) => !trustResultFor(trustByPath, r)?.quarantined) : options.results,
       options.retrievalQuery,
-      this.deps.config
+      this.deps.config,
+      options.stateViewActive === true,
+      options.asOfMs
     );
     if (injectable.length === 0) return;
     const formatted = this.deps.recallResultFormatter.formatQmdResultEntries(
@@ -20612,6 +20878,7 @@ var Orchestrator = class {
         storageDirNamespace: (storageDir) => this.storageDirNamespace(storageDir),
         indexPersistedMemory: (storage, memoryId) => this.indexPersistedMemory(storage, memoryId),
         buildGraphEdge: (storage, memoryRelPath, entityRef, memoryId, factContent, allMemsForGraph, memoryPathById, threadIdForEdge, threadEpisodeIdsForGraph, fallbackCausalPredecessor, graphCaps) => this.buildGraphEdge(storage, memoryRelPath, entityRef, memoryId, factContent, allMemsForGraph, memoryPathById, threadIdForEdge, threadEpisodeIdsForGraph, fallbackCausalPredecessor, graphCaps),
+        invalidateGraphEdgeCache: (storage) => this.graphIndexFor(storage).invalidateEdgeCache(),
         updateTemporalTagIndexes: (storage, persistedIds) => this.updateTemporalTagIndexes(storage, persistedIds)
       });
     }
@@ -22236,20 +22503,9 @@ ${doc.content}` : doc.content,
       memoryId
     );
   }
+  /** Delegation wrapper so the persist wiring and root-test stubs route through `this` (#2813 CI-0). */
   async buildGraphEdge(storage, memoryRelPath, entityRef, memoryId, factContent, allMemsForGraph, memoryPathById, threadIdForEdge, threadEpisodeIdsForGraph, fallbackCausalPredecessor, graphCaps = resolveGraphConstructionCapabilities(this.config)) {
-    return this.persistenceIndexCoordinator.buildGraphEdge(
-      storage,
-      memoryRelPath,
-      entityRef,
-      memoryId,
-      factContent,
-      allMemsForGraph,
-      memoryPathById,
-      threadIdForEdge,
-      threadEpisodeIdsForGraph,
-      fallbackCausalPredecessor,
-      graphCaps
-    );
+    return this.persistenceIndexCoordinator.buildGraphEdge(storage, memoryRelPath, entityRef, memoryId, factContent, allMemsForGraph, memoryPathById, threadIdForEdge, threadEpisodeIdsForGraph, fallbackCausalPredecessor, graphCaps);
   }
   graphIndexFor(storage) {
     const key = storage.dir;
@@ -23366,9 +23622,9 @@ function readStructuralSymbol(entry) {
   const rec = entry;
   const symbol = typeof rec.symbol === "string" ? rec.symbol.trim() : "";
   if (!symbol) return null;
-  const path39 = typeof rec.path === "string" && rec.path.length > 0 ? rec.path : void 0;
+  const path40 = typeof rec.path === "string" && rec.path.length > 0 ? rec.path : void 0;
   const kind = typeof rec.kind === "string" && rec.kind.length > 0 ? rec.kind : void 0;
-  const item = path39 !== void 0 && kind !== void 0 ? { symbol, path: path39, kind } : path39 !== void 0 ? { symbol, path: path39 } : kind !== void 0 ? { symbol, kind } : { symbol };
+  const item = path40 !== void 0 && kind !== void 0 ? { symbol, path: path40, kind } : path40 !== void 0 ? { symbol, path: path40 } : kind !== void 0 ? { symbol, kind } : { symbol };
   return item;
 }
 function classifySpawnError(err) {
@@ -26932,438 +27188,6 @@ function publisherForConnector(connectorId) {
   return publisherFor(hostIdForConnector(connectorId));
 }
 
-// src/activity/timeline/categories.ts
-var TIMELINE_RESERVED_UNKNOWN = "system.unknown";
-var TIMELINE_RESERVED_IDLE = "system.idle";
-var TIMELINE_RESERVED_PAUSE = "system.pause";
-var COLOR_PATTERN = /^#[0-9a-fA-F]{6}$/;
-function isTimelineCategoryId(id) {
-  const parts = id.split(".");
-  if (parts.length === 0) return false;
-  for (const part of parts) {
-    if (part.length === 0) return false;
-    const first = part.charCodeAt(0);
-    if (first < 97 || first > 122) return false;
-    for (let i = 1; i < part.length; i += 1) {
-      const code = part.charCodeAt(i);
-      const ok = code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 45;
-      if (!ok) return false;
-    }
-  }
-  return true;
-}
-var DEFAULT_TIMELINE_CATEGORIES = [
-  { id: "development", name: "Development", color: "#3b82f6", description: "Editors, terminals, IDEs, and code forges.", order: 10 },
-  { id: "communication", name: "Communication", color: "#f59e0b", description: "Mail, chat, and meetings.", order: 20 },
-  { id: "browsing", name: "Browsing", color: "#6366f1", description: "Web browsing without a more specific domain match.", order: 30 },
-  { id: "documents", name: "Documents", color: "#10b981", description: "Writing, notes, and PDFs.", order: 40 },
-  { id: "design", name: "Design & Media", color: "#ec4899", description: "Design, audio, and video tools.", order: 50 },
-  { id: "data", name: "Data & Analysis", color: "#84cc16", description: "Spreadsheets, dashboards, and databases.", order: 60 },
-  { id: "admin", name: "Admin", color: "#64748b", description: "File managers, settings, and system utilities.", order: 70 },
-  { id: "entertainment", name: "Entertainment", color: "#ef4444", description: "Video, music, and games.", order: 80 },
-  { id: TIMELINE_RESERVED_UNKNOWN, name: "Uncategorized", color: "#9ca3af", description: "Activity with no matching classification signal. Kept visible, never silently reassigned.", order: 990, system: true },
-  { id: TIMELINE_RESERVED_IDLE, name: "Idle", color: "#d1d5db", description: "Derived gap between cards where no activity was observed.", order: 991, system: true, idle: true },
-  { id: TIMELINE_RESERVED_PAUSE, name: "Paused", color: "#a78bfa", description: "User-declared pause interval.", order: 992, system: true }
-];
-function validateTimelineCategories(categories) {
-  if (!Array.isArray(categories) || categories.length === 0) {
-    throw new RangeError("timeline categories must be a non-empty array");
-  }
-  const seen = /* @__PURE__ */ new Set();
-  for (const category of categories) {
-    if (typeof category.id !== "string" || !isTimelineCategoryId(category.id)) {
-      throw new RangeError(`timeline category id must be dotted kebab-case: ${String(category.id)}`);
-    }
-    if (seen.has(category.id)) {
-      throw new RangeError(`timeline category id must be unique: ${category.id}`);
-    }
-    seen.add(category.id);
-    if (typeof category.name !== "string" || category.name.length === 0) {
-      throw new RangeError(`timeline category ${category.id}: name must be a non-empty string`);
-    }
-    if (typeof category.color !== "string" || !COLOR_PATTERN.test(category.color)) {
-      throw new RangeError(`timeline category ${category.id}: color must be #RRGGBB`);
-    }
-    if (typeof category.description !== "string" || category.description.length === 0) {
-      throw new RangeError(`timeline category ${category.id}: description must be a non-empty string`);
-    }
-    if (!Number.isInteger(category.order)) {
-      throw new RangeError(`timeline category ${category.id}: order must be an integer`);
-    }
-    const isReserved = category.id === TIMELINE_RESERVED_UNKNOWN || category.id === TIMELINE_RESERVED_IDLE || category.id === TIMELINE_RESERVED_PAUSE;
-    if (isReserved && category.system !== true) {
-      throw new RangeError(`timeline category ${category.id} is reserved and must set system: true`);
-    }
-    if (!isReserved) {
-      if (category.id.startsWith("system.")) {
-        throw new RangeError(`timeline category id namespace "system." is reserved: ${category.id}`);
-      }
-      if (category.system === true || category.idle === true) {
-        throw new RangeError(`timeline category ${category.id}: only reserved categories may set system/idle flags`);
-      }
-    }
-  }
-  const idle = categories.find((category) => category.id === TIMELINE_RESERVED_IDLE);
-  if (idle !== void 0 && idle.idle !== true) {
-    throw new RangeError(`timeline category ${TIMELINE_RESERVED_IDLE} must set idle: true`);
-  }
-  for (const reserved of [TIMELINE_RESERVED_UNKNOWN, TIMELINE_RESERVED_IDLE, TIMELINE_RESERVED_PAUSE]) {
-    if (!categories.some((category) => category.id === reserved)) {
-      throw new RangeError(`timeline categories must include the reserved "${reserved}" category`);
-    }
-  }
-}
-function sortTimelineCategories(categories) {
-  return [...categories].sort((a, b) => a.order - b.order || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
-}
-
-// src/activity/timeline/classify.ts
-var DOMAIN_CONFIDENCE = 0.85;
-var APP_CONFIDENCE = 0.9;
-var TITLE_CONFIDENCE = 0.7;
-var UNKNOWN_CONFIDENCE = 0;
-var RULES = [
-  { categoryId: "development", domains: ["github.com", "gitlab.com", "stackoverflow.com", "linear.app", "atlassian.net"] },
-  { categoryId: "communication", domains: ["mail.google.com", "gmail.com", "outlook.com", "outlook.office.com", "slack.com"] },
-  { categoryId: "design", domains: ["figma.com", "canva.com"] },
-  { categoryId: "documents", domains: ["docs.google.com", "notion.so", "dropbox.com"] },
-  { categoryId: "entertainment", domains: ["youtube.com", "netflix.com", "spotify.com"] },
-  { categoryId: "data", domains: ["metabase", "tableau", "grafana"] },
-  { categoryId: "development", apps: ["code", "cursor", "neovim", "vim", "emacs", "xcode", "intellij", "terminal", "iterm", "warp", "wezterm", "kitty", "alacritty", "zed", "sublime", "datagrip"] },
-  { categoryId: "communication", apps: ["slack", "discord", "teams", "mail", "outlook", "thunderbird", "messages", "signal", "whatsapp", "telegram", "zoom", "facetime", "meet"] },
-  { categoryId: "design", apps: ["figma", "sketch", "photoshop", "illustrator", "indesign", "premiere", "after effects", "davinci", "blender", "ableton", "logic pro", "final cut"] },
-  { categoryId: "documents", apps: ["word", "pages", "notion", "obsidian", "notes", "typora", "bear", "preview", "acrobat"] },
-  { categoryId: "data", apps: ["excel", "numbers", "sheets", "tableau"] },
-  { categoryId: "admin", apps: ["finder", "settings", "system preferences", "activity monitor", "files", "explorer"] },
-  { categoryId: "entertainment", apps: ["spotify", "music", "youtube", "vlc", "quicktime", "steam", "netflix", "podcast", "tv"] },
-  { categoryId: "browsing", apps: ["chrome", "safari", "firefox", "edge", "arc", "brave", "browser"] },
-  { categoryId: "development", titles: ["pull request", "merge conflict", "terminal \u2014", "repository"] },
-  { categoryId: "communication", titles: ["inbox"] },
-  { categoryId: "data", titles: ["spreadsheet", "pivot table"] }
-];
-function classifyTimelineObservation(observation, categories) {
-  const app = observation.app.toLowerCase();
-  const title = observation.windowTitle.toLowerCase();
-  const domain = observation.browserUrl === void 0 ? "" : hostOf(observation.browserUrl);
-  for (const rule of RULES) {
-    if (rule.domains !== void 0 && domain !== "" && rule.domains.some((pattern) => domain.includes(pattern))) {
-      return checkedRule(rule, DOMAIN_CONFIDENCE, categories);
-    }
-  }
-  for (const rule of RULES) {
-    if (rule.apps !== void 0 && rule.apps.some((pattern) => app.includes(pattern))) {
-      return checkedRule(rule, APP_CONFIDENCE, categories);
-    }
-  }
-  for (const rule of RULES) {
-    if (rule.titles !== void 0 && rule.titles.some((pattern) => title.includes(pattern))) {
-      return checkedRule(rule, TITLE_CONFIDENCE, categories);
-    }
-  }
-  return { categoryId: TIMELINE_RESERVED_UNKNOWN, confidence: UNKNOWN_CONFIDENCE };
-}
-function checkedRule(rule, confidence, categories) {
-  if (!categories.some((category) => category.id === rule.categoryId)) {
-    throw new RangeError(`timeline classification rule targets unknown category: ${rule.categoryId}`);
-  }
-  return { categoryId: rule.categoryId, confidence };
-}
-function hostOf(url) {
-  try {
-    return new URL(url).hostname.toLowerCase();
-  } catch {
-    return url.toLowerCase();
-  }
-}
-
-// src/activity/timeline/build.ts
-import { createHash as createHash9 } from "crypto";
-var TIMELINE_FORMAT_VERSION = 1;
-var TIMELINE_MERGE_GAP_MS = 12e4;
-var TIMELINE_MAX_DWELL_MS = 15 * 6e4;
-function canonicalMs(iso) {
-  const parsed = Date.parse(iso);
-  return Number.isFinite(parsed) ? parsed : Number.NaN;
-}
-function isoOf(ms) {
-  return new Date(ms).toISOString();
-}
-function evidenceKeyOf(observation) {
-  return `${observation.machine}|${isoOf(canonicalMs(observation.capturedAtUtc))}|${observation.contentHash}`;
-}
-function stableCardId(identity) {
-  return `tlc_${createHash9("sha256").update(identity, "utf8").digest("hex").slice(0, 16)}`;
-}
-function formatDurationMinutes(ms) {
-  return `${Math.round(ms / 6e4)}m`;
-}
-function unionIntervals(intervals) {
-  const sorted = [...intervals].sort((a, b) => a[0] - b[0] || a[1] - b[1]);
-  const merged = [];
-  for (const interval of sorted) {
-    const last = merged[merged.length - 1];
-    if (last !== void 0 && interval[0] <= last[1]) {
-      last[1] = Math.max(last[1], interval[1]);
-    } else {
-      merged.push([interval[0], interval[1]]);
-    }
-  }
-  return merged;
-}
-function subtractInterval(start, end, cutStart, cutEnd) {
-  if (cutEnd <= start || cutStart >= end) return [[start, end]];
-  const pieces = [];
-  if (cutStart > start) pieces.push([start, cutStart]);
-  if (cutEnd < end) pieces.push([cutEnd, end]);
-  return pieces;
-}
-function mergeTrack(machine, track, pauses) {
-  const cards = [];
-  let current = [];
-  const pauseStartsAfter = (fromMs, toMs) => pauses.some(([ps, pe]) => ps >= fromMs && ps < toMs && pe > ps);
-  for (const observation of track) {
-    const last = current[current.length - 1];
-    if (last !== void 0) {
-      const gap = canonicalMs(observation.capturedAtUtc) - canonicalMs(last.capturedAtUtc);
-      const sameKey = observation.app === last.app && observation.windowTitle === last.windowTitle;
-      const pauseBetween = pauseStartsAfter(canonicalMs(last.capturedAtUtc), canonicalMs(observation.capturedAtUtc));
-      if (!sameKey || gap > TIMELINE_MERGE_GAP_MS || pauseBetween) {
-        cards.push({ machine, observations: current });
-        current = [];
-      }
-    }
-    current.push(observation);
-  }
-  if (current.length > 0) cards.push({ machine, observations: current });
-  return cards;
-}
-function buildTimelineDay(input) {
-  const categories = input.categories ?? DEFAULT_TIMELINE_CATEGORIES;
-  validateTimelineCategories(categories);
-  const window = activityDayWindow(input.date, input.timezone);
-  const dayStartMs = Date.parse(window.startUtc);
-  const dayEndMs = Date.parse(window.endUtc);
-  const observations = input.observations.filter((observation) => Number.isFinite(canonicalMs(observation.capturedAtUtc))).filter((observation) => {
-    const ms = canonicalMs(observation.capturedAtUtc);
-    return ms >= dayStartMs && ms < dayEndMs;
-  });
-  for (const pause of input.pauses ?? []) {
-    const startMs = canonicalMs(pause.startUtc);
-    const endMs = canonicalMs(pause.endUtc);
-    if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || startMs >= endMs) {
-      throw new RangeError("timeline pause must be a valid half-open [startUtc, endUtc) interval");
-    }
-  }
-  const pauseIntervals = unionIntervals(
-    (input.pauses ?? []).map((pause) => [canonicalMs(pause.startUtc), canonicalMs(pause.endUtc)]).map(([startMs, endMs]) => [Math.max(startMs, dayStartMs), Math.min(endMs, dayEndMs)]).filter(([startMs, endMs]) => endMs > startMs)
-  );
-  const tracks = /* @__PURE__ */ new Map();
-  for (const observation of observations) {
-    const track = tracks.get(observation.machine) ?? [];
-    track.push(observation);
-    tracks.set(observation.machine, track);
-  }
-  for (const track of tracks.values()) {
-    track.sort(
-      (a, b) => canonicalMs(a.capturedAtUtc) - canonicalMs(b.capturedAtUtc) || (a.contentHash < b.contentHash ? -1 : a.contentHash > b.contentHash ? 1 : 0)
-    );
-  }
-  const cards = [];
-  const machines = [...tracks.keys()].sort();
-  for (const machine of machines) {
-    const track = tracks.get(machine) ?? [];
-    const merged = mergeTrack(machine, track, pauseIntervals);
-    const trackIntervals = [];
-    for (let index = 0; index < merged.length; index++) {
-      const group = merged[index];
-      const first = group.observations[0];
-      const last = group.observations[group.observations.length - 1];
-      const startMs = canonicalMs(first.capturedAtUtc);
-      const lastMs = canonicalMs(last.capturedAtUtc);
-      const nextObsMs = index + 1 < merged.length ? canonicalMs(merged[index + 1].observations[0].capturedAtUtc) : Number.POSITIVE_INFINITY;
-      const pauseStartMs = pauseIntervals.find(([ps]) => ps > lastMs)?.[0] ?? Number.POSITIVE_INFINITY;
-      const endMs = Math.max(lastMs, Math.min(lastMs + TIMELINE_MAX_DWELL_MS, nextObsMs, pauseStartMs, dayEndMs));
-      trackIntervals.push([startMs, endMs]);
-      const evidenceIds = group.observations.map((observation) => observation.id);
-      const classification = classifyTimelineObservation(first, categories);
-      cards.push({
-        id: stableCardId(`activity|${machine}|${evidenceKeyOf(first)}|${evidenceKeyOf(last)}`),
-        kind: "activity",
-        title: first.windowTitle.length > 0 ? first.windowTitle : first.app,
-        summary: `${first.app} \xB7 ${machine} \xB7 ${evidenceIds.length} obs \xB7 ${formatDurationMinutes(endMs - startMs)}`,
-        categoryId: classification.categoryId,
-        confidence: classification.confidence,
-        startUtc: isoOf(startMs),
-        endUtc: isoOf(endMs),
-        dayKey: input.date,
-        timezone: input.timezone,
-        machine,
-        evidenceIds,
-        evidenceRange: { firstKey: evidenceKeyOf(first), lastKey: evidenceKeyOf(last) }
-      });
-    }
-    for (let index = 0; index + 1 < trackIntervals.length; index++) {
-      const gapStart = trackIntervals[index][1];
-      const gapEnd = trackIntervals[index + 1][0];
-      if (gapEnd <= gapStart) continue;
-      let pieces = [[gapStart, gapEnd]];
-      for (const [pauseStart, pauseEnd] of pauseIntervals) {
-        pieces = pieces.flatMap(([start, end]) => subtractInterval(start, end, pauseStart, pauseEnd));
-      }
-      for (const [start, end] of pieces) {
-        cards.push({
-          id: stableCardId(`idle|${machine}|${isoOf(start)}|${isoOf(end)}`),
-          kind: "idle",
-          title: "Idle",
-          summary: `${formatDurationMinutes(end - start)} gap on ${machine}`,
-          categoryId: TIMELINE_RESERVED_IDLE,
-          confidence: 1,
-          startUtc: isoOf(start),
-          endUtc: isoOf(end),
-          dayKey: input.date,
-          timezone: input.timezone,
-          machine,
-          evidenceIds: [],
-          evidenceRange: null
-        });
-      }
-    }
-  }
-  for (const [pauseStart, pauseEnd] of pauseIntervals) {
-    const reason = (input.pauses ?? []).find((pause) => canonicalMs(pause.startUtc) === pauseStart)?.reason;
-    cards.push({
-      id: stableCardId(`pause|${isoOf(pauseStart)}|${isoOf(pauseEnd)}`),
-      kind: "pause",
-      title: "Paused",
-      summary: reason === void 0 ? `${formatDurationMinutes(pauseEnd - pauseStart)} user pause` : `${formatDurationMinutes(pauseEnd - pauseStart)} user pause \u2014 ${reason}`,
-      categoryId: TIMELINE_RESERVED_PAUSE,
-      confidence: 1,
-      startUtc: isoOf(pauseStart),
-      endUtc: isoOf(pauseEnd),
-      dayKey: input.date,
-      timezone: input.timezone,
-      machine: null,
-      evidenceIds: [],
-      evidenceRange: null
-    });
-  }
-  cards.sort((a, b) => a.startUtc < b.startUtc ? -1 : a.startUtc > b.startUtc ? 1 : a.endUtc < b.endUtc ? -1 : a.endUtc > b.endUtc ? 1 : (a.machine ?? "") < (b.machine ?? "") ? -1 : (a.machine ?? "") > (b.machine ?? "") ? 1 : a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
-  return {
-    formatVersion: TIMELINE_FORMAT_VERSION,
-    date: input.date,
-    timezone: input.timezone,
-    startUtc: window.startUtc,
-    endUtc: window.endUtc,
-    cards
-  };
-}
-function serializeTimelineDay(day) {
-  return JSON.stringify(day);
-}
-
-// src/activity/timeline/corrections.ts
-import { mkdirSync } from "fs";
-import path33 from "path";
-function timelineCorrectionDatabasePath(memoryDir) {
-  return path33.join(memoryDir, "state", "activity-timeline.sqlite");
-}
-function rowToCorrection(row) {
-  return {
-    cardId: row.card_id,
-    categoryId: row.category_id ?? void 0,
-    title: row.title ?? void 0,
-    editedAtUtc: row.edited_at_utc
-  };
-}
-var TimelineCorrectionStore = class _TimelineCorrectionStore {
-  db;
-  constructor(db) {
-    this.db = db;
-  }
-  static open(memoryDir) {
-    mkdirSync(path33.join(memoryDir, "state"), { recursive: true });
-    const db = openBetterSqlite3(timelineCorrectionDatabasePath(memoryDir));
-    db.pragma("journal_mode = WAL");
-    db.pragma("busy_timeout = 5000");
-    db.exec(`
-      CREATE TABLE IF NOT EXISTS timeline_corrections (
-        card_id       TEXT PRIMARY KEY,
-        category_id   TEXT,
-        title         TEXT,
-        edited_at_utc TEXT NOT NULL
-      );
-    `);
-    return new _TimelineCorrectionStore(db);
-  }
-  /**
-   * Persist one correction. `categoryId`, when set, must exist in `categories`
-   * (defaults to the built-in registry) — an unknown category is a malformed
-   * edit and must fail rather than silently strand the card.
-   */
-  upsert(correction, categories = DEFAULT_TIMELINE_CATEGORIES) {
-    validateTimelineCategories(categories);
-    if (typeof correction.cardId !== "string" || correction.cardId.length === 0) {
-      throw new RangeError("timeline correction requires a non-empty cardId");
-    }
-    if (typeof correction.editedAtUtc !== "string" || Number.isNaN(Date.parse(correction.editedAtUtc))) {
-      throw new RangeError("timeline correction requires a valid editedAtUtc instant");
-    }
-    if (correction.categoryId === void 0 && correction.title === void 0 || correction.title !== void 0 && correction.title.length === 0) {
-      throw new RangeError("timeline correction must set a categoryId and/or a non-empty title");
-    }
-    if (correction.categoryId !== void 0 && !categories.some((category) => category.id === correction.categoryId)) {
-      throw new RangeError(`timeline correction targets unknown category: ${correction.categoryId}`);
-    }
-    this.db.prepare(
-      `INSERT INTO timeline_corrections (card_id, category_id, title, edited_at_utc)
-         VALUES (?, ?, ?, ?)
-         ON CONFLICT(card_id) DO UPDATE SET category_id = excluded.category_id, title = excluded.title, edited_at_utc = excluded.edited_at_utc`
-    ).run(correction.cardId, correction.categoryId ?? null, correction.title ?? null, correction.editedAtUtc);
-  }
-  get(cardId) {
-    const row = this.db.prepare("SELECT card_id, category_id, title, edited_at_utc FROM timeline_corrections WHERE card_id = ?").get(cardId);
-    return row === void 0 ? void 0 : rowToCorrection(row);
-  }
-  /** All corrections ordered by card id (deterministic listing). */
-  list() {
-    return this.db.prepare("SELECT card_id, category_id, title, edited_at_utc FROM timeline_corrections ORDER BY card_id ASC").all().map((row) => rowToCorrection(row));
-  }
-  /** Explicitly reset a card to its derived values; true when a correction existed. */
-  reset(cardId) {
-    return this.db.prepare("DELETE FROM timeline_corrections WHERE card_id = ?").run(cardId).changes > 0;
-  }
-  close() {
-    this.db.close();
-  }
-};
-function applyTimelineCorrections(cards, corrections) {
-  const byCardId = new Map(corrections.map((correction) => [correction.cardId, correction]));
-  return cards.map((card) => {
-    const correction = byCardId.get(card.id);
-    if (correction === void 0) return card;
-    return {
-      id: card.id,
-      kind: card.kind,
-      title: correction.title ?? card.title,
-      summary: card.summary,
-      categoryId: correction.categoryId ?? card.categoryId,
-      confidence: 1,
-      startUtc: card.startUtc,
-      endUtc: card.endUtc,
-      dayKey: card.dayKey,
-      timezone: card.timezone,
-      machine: card.machine,
-      evidenceIds: card.evidenceIds,
-      evidenceRange: card.evidenceRange,
-      manualEdit: {
-        ...correction.categoryId !== void 0 ? { categoryId: correction.categoryId } : {},
-        ...correction.title !== void 0 ? { title: correction.title } : {},
-        editedAtUtc: correction.editedAtUtc
-      }
-    };
-  });
-}
-
 // src/activity/timeline/query.ts
 var RANGE_FORMATS = ["cards", "compact"];
 var MS_PER_DAY = 864e5;
@@ -27406,6 +27230,18 @@ function assertRange(fromMs, toMs, maxRangeDays) {
     throw new RangeError(`range exceeds timeline.qa.maxRangeDays (${maxRangeDays})`);
   }
 }
+function validateTimelineRangeQuery(query) {
+  if (!RANGE_FORMATS.includes(query.format)) {
+    throw new TypeError(`format must be one of: ${RANGE_FORMATS.join(", ")}`);
+  }
+  const maxRangeDays = query.maxRangeDays ?? DEFAULT_MAX_RANGE_DAYS;
+  assertRange(parseInstant(query.from, "from"), parseInstant(query.to, "to"), maxRangeDays);
+}
+function validateTimelineSearchBounds(bounds) {
+  const fromMs = parseInstant(bounds.from ?? bounds.to, "from");
+  const toMs = parseInstant(bounds.to ?? bounds.from, "to");
+  assertRange(fromMs, toMs, DEFAULT_MAX_RANGE_DAYS);
+}
 function cardOverlaps(card, fromMs, toMs) {
   const start = Date.parse(card.startUtc);
   const end = Date.parse(card.endUtc);
@@ -27548,16 +27384,18 @@ async function runTimelineCliCommand(deps, args, io) {
       const from = flagString(flags, "--from");
       const to = flagString(flags, "--to");
       if (!from || !to) throw new TypeError("range requires --from and --to");
-      if (!Array.isArray(deps.cards)) {
-        io.stderr.write("store_unreadable\n");
-        return 1;
-      }
       const formatRaw = flagString(flags, "--format") ?? "compact";
       if (formatRaw !== "cards" && formatRaw !== "compact") {
         throw new TypeError("format must be one of: cards, compact");
       }
+      validateTimelineRangeQuery({ from, to, format: formatRaw, maxRangeDays: deps.qa.maxRangeDays });
+      const cards = Array.isArray(deps.cards) ? deps.cards : deps.loadCards === void 0 ? null : await deps.loadCards({ from, to });
+      if (!Array.isArray(cards)) {
+        io.stderr.write("store_unreadable\n");
+        return 1;
+      }
       const categoriesRaw = flagString(flags, "--categories");
-      const result = queryTimelineRange(deps.cards, {
+      const result = queryTimelineRange(cards, {
         from,
         to,
         format: formatRaw,
@@ -27577,10 +27415,16 @@ async function runTimelineCliCommand(deps, args, io) {
       if (limitRaw !== void 0 && !Number.isInteger(limit)) {
         throw new RangeError("limit must be an integer from 1 to 50");
       }
-      const result = queryTimelineSearch(deps.cards, {
+      const from = flagString(flags, "--from");
+      const to = flagString(flags, "--to");
+      if (from !== void 0 || to !== void 0) {
+        validateTimelineSearchBounds({ from, to });
+      }
+      const cards = Array.isArray(deps.cards) ? deps.cards : deps.loadCards === void 0 ? null : await deps.loadCards({ from, to });
+      const result = queryTimelineSearch(cards, {
         query: q,
-        from: flagString(flags, "--from"),
-        to: flagString(flags, "--to"),
+        from,
+        to,
         limit
       });
       io.stdout.write(`${JSON.stringify(result)}
@@ -27853,10 +27697,10 @@ function buildWeeklyActivitySummary(cards, options) {
 
 // src/activity/timeline/weekly-persist.ts
 import { randomBytes as randomBytes3 } from "crypto";
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, unlinkSync, writeFileSync } from "fs";
-import path34 from "path";
+import { mkdirSync, readFileSync as readFileSync2, renameSync, unlinkSync, writeFileSync } from "fs";
+import path33 from "path";
 var WEEKLY_SNAPSHOT_FORMAT_VERSION = 1;
-var WEEKLY_SNAPSHOT_DIR = path34.join("activity", "weekly");
+var WEEKLY_SNAPSHOT_DIR = path33.join("activity", "weekly");
 function requireToken(value, name) {
   if (typeof value !== "string" || value.trim().length === 0) {
     throw new TypeError(`${name} must be a non-empty string`);
@@ -27879,8 +27723,8 @@ function weeklySnapshotPath(input) {
   const identity = hashActivityBody(
     `${input.summary.weekStartUtc}\0${input.summary.weekEndUtc}\0${sourceRevision}\0${configHash}`
   );
-  return path34.join(
-    path34.resolve(memoryDir),
+  return path33.join(
+    path33.resolve(memoryDir),
     WEEKLY_SNAPSHOT_DIR,
     namespaceIdentityToken(namespace),
     `${weekDate}--${identity}.json`
@@ -27910,7 +27754,7 @@ function persistWeeklySnapshot(input) {
       throw error;
     }
   }
-  mkdirSync2(path34.dirname(filePath), { recursive: true, mode: 448 });
+  mkdirSync(path33.dirname(filePath), { recursive: true, mode: 448 });
   const tmpPath = `${filePath}.${process.pid}.${randomBytes3(8).toString("hex")}.tmp`;
   writeFileSync(tmpPath, text, { encoding: "utf8", mode: 384 });
   try {
@@ -27925,264 +27769,6 @@ function persistWeeklySnapshot(input) {
   return { path: filePath, written: true };
 }
 
-// src/activity/timeline/analysis.ts
-var TIMELINE_ANALYSIS_PROMPT_VERSION = 1;
-var TIMELINE_ANALYSIS_BATCH_SIZE = 40;
-var TIMELINE_ANALYSIS_BATCH_OVERLAP = 2;
-var TIMELINE_ANALYSIS_DEFAULT_TIMEOUT_MS = 15e3;
-var TimelineAnalysisConfigError = class extends Error {
-  name = "TimelineAnalysisConfigError";
-  code = "invalid_config";
-  constructor(message) {
-    super(message);
-  }
-};
-var INSTRUCTIONS = [
-  "Use only supplied evidence.",
-  "Preserve chronology.",
-  "Do not invent people, places, or tasks.",
-  "Avoid productivity or emotional claims.",
-  "Merge adjacent activity only when the evidence justifies it.",
-  'Return strict JSON: {"ops":[...]} with evidenceRange, title, summary, categoryId, confidence, uncertainty.',
-  "Cite evidence ranges for every op. Empty ops is a valid no-op."
-].join(" ");
-function fail(status, cards, provider, model) {
-  log.info(`timeline analysis status=${status} provider=${provider} model=${model} promptVersion=${TIMELINE_ANALYSIS_PROMPT_VERSION}`);
-  return {
-    status,
-    cards,
-    provider,
-    model,
-    promptVersion: TIMELINE_ANALYSIS_PROMPT_VERSION
-  };
-}
-function requiredToken(value, name) {
-  if (typeof value !== "string" || value.trim().length === 0) {
-    throw new TimelineAnalysisConfigError(`${name} is required`);
-  }
-  return value.trim();
-}
-function evidenceKeyOf2(observation) {
-  const parsed = Date.parse(observation.capturedAtUtc);
-  const instant = Number.isFinite(parsed) ? new Date(parsed).toISOString() : observation.capturedAtUtc;
-  return `${observation.machine}|${instant}|${observation.contentHash}`;
-}
-function sortObservations(observations) {
-  return [...observations].sort((a, b) => {
-    const time = Date.parse(a.capturedAtUtc) - Date.parse(b.capturedAtUtc);
-    if (time !== 0) return time;
-    if (a.contentHash !== b.contentHash) return a.contentHash < b.contentHash ? -1 : 1;
-    return a.id - b.id;
-  });
-}
-function batchObservations(observations) {
-  if (observations.length === 0) return [[]];
-  const size = TIMELINE_ANALYSIS_BATCH_SIZE;
-  const overlap = TIMELINE_ANALYSIS_BATCH_OVERLAP;
-  const step = size - overlap;
-  const batches = [];
-  for (let start = 0; start < observations.length; start += step) {
-    batches.push(observations.slice(start, start + size));
-    if (start + size >= observations.length) break;
-  }
-  return batches;
-}
-function safeObservation(observation) {
-  return {
-    id: observation.id,
-    machine: observation.machine,
-    capturedAtUtc: observation.capturedAtUtc,
-    app: observation.app,
-    windowTitle: observation.windowTitle,
-    ...observation.browserUrl ? { browserUrl: observation.browserUrl } : {},
-    contentHash: observation.contentHash
-  };
-}
-function safeCard(card) {
-  return {
-    id: card.id,
-    kind: card.kind,
-    title: card.title,
-    summary: card.summary,
-    categoryId: card.categoryId,
-    confidence: card.confidence,
-    startUtc: card.startUtc,
-    endUtc: card.endUtc,
-    machine: card.machine,
-    evidenceIds: card.evidenceIds,
-    evidenceRange: card.evidenceRange,
-    ...card.manualEdit ? { manualEdit: card.manualEdit } : {}
-  };
-}
-function buildTimelineAnalysisPrompt(input) {
-  const payload = {
-    date: input.date ?? null,
-    timezone: input.timezone ?? null,
-    categories: input.categories.map((category) => ({ id: category.id, name: category.name })),
-    preferences: input.preferences ?? [],
-    priorEdits: input.priorEdits ?? [],
-    cards: input.cards.map(safeCard),
-    observations: input.observations.map(safeObservation)
-  };
-  return `${INSTRUCTIONS}
-${JSON.stringify(payload)}`;
-}
-async function callComplete(complete, prompt, provider, model, timeoutMs, parent) {
-  const { promise: timeoutPromise, reject } = Promise.withResolvers();
-  const failOnce = (message, name) => {
-    reject(Object.assign(new Error(message), { name }));
-  };
-  const timer = setTimeout(() => failOnce("timeline analysis timed out", "TimeoutError"), timeoutMs);
-  if (parent?.aborted) {
-    clearTimeout(timer);
-    throw Object.assign(new Error("timeline analysis aborted"), { name: "AbortError" });
-  }
-  const onAbort = () => failOnce("timeline analysis aborted", "AbortError");
-  parent?.addEventListener("abort", onAbort, { once: true });
-  const signal = parent ? AbortSignal.any([parent, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs);
-  try {
-    return await Promise.race([complete({ prompt, provider, model, signal }), timeoutPromise]);
-  } finally {
-    clearTimeout(timer);
-    parent?.removeEventListener("abort", onAbort);
-  }
-}
-function parseOps(raw) {
-  if (typeof raw !== "string" || raw.trim().length === 0) return null;
-  for (const candidate of extractJsonCandidates(raw)) {
-    try {
-      const parsed = JSON.parse(candidate);
-      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || !("ops" in parsed)) continue;
-      const ops = parsed.ops;
-      if (!Array.isArray(ops)) continue;
-      const out = [];
-      let valid = true;
-      for (const item of ops) {
-        const op = asOp(item);
-        if (!op) {
-          valid = false;
-          break;
-        }
-        out.push(op);
-      }
-      if (valid) return out;
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-function asOp(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  if (!("cardId" in value) || typeof value.cardId !== "string" || value.cardId.length === 0) return null;
-  if (!("evidenceRange" in value)) return null;
-  const range = value.evidenceRange;
-  if (!range || typeof range !== "object" || Array.isArray(range)) return null;
-  if (!("firstKey" in range) || typeof range.firstKey !== "string" || range.firstKey.length === 0) return null;
-  if (!("lastKey" in range) || typeof range.lastKey !== "string" || range.lastKey.length === 0) return null;
-  if ("title" in value && value.title !== void 0 && typeof value.title !== "string") return null;
-  if ("summary" in value && value.summary !== void 0 && typeof value.summary !== "string") return null;
-  if ("categoryId" in value && value.categoryId !== void 0 && typeof value.categoryId !== "string") return null;
-  if ("uncertainty" in value && value.uncertainty !== void 0 && typeof value.uncertainty !== "string") return null;
-  if ("confidence" in value && value.confidence !== void 0 && (typeof value.confidence !== "number" || value.confidence < 0 || value.confidence > 1)) {
-    return null;
-  }
-  return {
-    cardId: value.cardId,
-    title: "title" in value && typeof value.title === "string" ? value.title : void 0,
-    summary: "summary" in value && typeof value.summary === "string" ? value.summary : void 0,
-    categoryId: "categoryId" in value && typeof value.categoryId === "string" ? value.categoryId : void 0,
-    confidence: "confidence" in value && typeof value.confidence === "number" ? value.confidence : void 0,
-    uncertainty: "uncertainty" in value && typeof value.uncertainty === "string" ? value.uncertainty : void 0,
-    evidenceRange: { firstKey: range.firstKey, lastKey: range.lastKey }
-  };
-}
-function knownEvidenceKeys(cards, observations) {
-  const keys = /* @__PURE__ */ new Set();
-  for (const observation of observations) keys.add(evidenceKeyOf2(observation));
-  for (const card of cards) {
-    if (card.evidenceRange) {
-      keys.add(card.evidenceRange.firstKey);
-      keys.add(card.evidenceRange.lastKey);
-    }
-  }
-  return keys;
-}
-function applyOps(cards, ops, categories, evidenceKeys) {
-  if (ops.length === 0) return cards;
-  const byId = new Map(cards.map((card) => [card.id, card]));
-  const allowedCategories = new Set(categories.map((category) => category.id));
-  const next = /* @__PURE__ */ new Map();
-  for (const op of ops) {
-    const card = byId.get(op.cardId);
-    if (!card) return null;
-    if (!evidenceKeys.has(op.evidenceRange.firstKey) || !evidenceKeys.has(op.evidenceRange.lastKey)) return null;
-    if (op.categoryId !== void 0 && !allowedCategories.has(op.categoryId)) return null;
-    if (card.manualEdit) continue;
-    next.set(card.id, {
-      ...card,
-      ...op.title !== void 0 ? { title: op.title } : {},
-      ...op.summary !== void 0 ? { summary: op.summary } : {},
-      ...op.categoryId !== void 0 ? { categoryId: op.categoryId } : {},
-      ...op.confidence !== void 0 ? { confidence: op.confidence } : {}
-    });
-  }
-  if (next.size === 0) return cards;
-  return cards.map((card) => next.get(card.id) ?? card);
-}
-async function analyzeTimelineCards(input) {
-  const cards = input.cards;
-  if (!input.enabled) {
-    return { status: "disabled", cards };
-  }
-  const provider = requiredToken(input.provider, "provider");
-  const model = requiredToken(input.model, "model");
-  const complete = input.complete;
-  if (typeof complete !== "function") {
-    throw new TimelineAnalysisConfigError("complete is required");
-  }
-  const timeoutMs = input.timeoutMs ?? TIMELINE_ANALYSIS_DEFAULT_TIMEOUT_MS;
-  if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) {
-    throw new TimelineAnalysisConfigError("timeoutMs must be a positive integer");
-  }
-  if (input.cards.length === 0 && input.observations.length === 0) {
-    return fail("invalid_output", cards, provider, model);
-  }
-  const categories = input.categories ?? DEFAULT_TIMELINE_CATEGORIES;
-  const ordered = sortObservations(input.observations);
-  const batches = batchObservations(ordered);
-  const merged = /* @__PURE__ */ new Map();
-  try {
-    for (const batch of batches) {
-      const prompt = buildTimelineAnalysisPrompt({
-        date: input.date,
-        timezone: input.timezone,
-        cards: input.cards,
-        observations: batch,
-        categories,
-        preferences: input.preferences,
-        priorEdits: input.priorEdits
-      });
-      const raw = await callComplete(complete, prompt, provider, model, timeoutMs, input.signal);
-      const ops = parseOps(raw);
-      if (!ops) return fail("invalid_output", cards, provider, model);
-      for (const op of ops) merged.set(op.cardId, op);
-    }
-  } catch {
-    return fail("provider_failed", cards, provider, model);
-  }
-  const applied = applyOps(cards, [...merged.values()], categories, knownEvidenceKeys(cards, ordered));
-  if (!applied) return fail("invalid_output", cards, provider, model);
-  log.info(`timeline analysis status=ok provider=${provider} model=${model} promptVersion=${TIMELINE_ANALYSIS_PROMPT_VERSION}`);
-  return {
-    status: "ok",
-    cards: applied,
-    provider,
-    model,
-    promptVersion: TIMELINE_ANALYSIS_PROMPT_VERSION
-  };
-}
-
 // src/activity/timeline/recap-export.ts
 function compareCardIds(a, b) {
   if (a.id < b.id) return -1;
@@ -28383,7 +27969,7 @@ function compareObservations(a, b) {
   if (time !== 0) return time;
   return a.id - b.id;
 }
-function batchObservations2(observations, options) {
+function batchObservations(observations, options) {
   const { maxBatch, overlap } = options;
   if (!Number.isInteger(overlap) || overlap < 0) {
     throw new RangeError("overlap must be a non-negative integer");
@@ -28414,14 +28000,14 @@ function boundEvidence(claims, observations) {
 }
 
 // src/activity/timeline/analysis-prompt.ts
-var INSTRUCTIONS2 = "Use only supplied evidence. Preserve chronology. Do not invent people, places, or tasks. Return strict JSON.";
+var INSTRUCTIONS = "Use only supplied evidence. Preserve chronology. Do not invent people, places, or tasks. Return strict JSON.";
 function listedObservation(observation) {
   return { id: observation.id, capturedAtUtc: observation.capturedAtUtc };
 }
 function buildAnalysisPrompt(input) {
   const listed = [...input.observations].sort((a, b) => a.id - b.id).map(listedObservation);
   const body = listed.length === 0 ? "(empty)" : JSON.stringify(listed);
-  return `${INSTRUCTIONS2}
+  return `${INSTRUCTIONS}
 Observations: ${body}`;
 }
 
@@ -28470,43 +28056,6 @@ function clipCardsToRecapWindow(cards, windowStartMs, windowEndMs) {
   return out;
 }
 
-// src/activity/timeline/analysis-failure.ts
-var ANALYSIS_FAILURE_KINDS = [
-  "provider_unavailable",
-  "timeout",
-  "aborted",
-  "rate_limited",
-  "malformed_json",
-  "invalid_schema",
-  "partial_output",
-  "invalid_config"
-];
-var RETRYABLE_BY_KIND = {
-  provider_unavailable: true,
-  timeout: true,
-  rate_limited: true,
-  aborted: false,
-  malformed_json: false,
-  invalid_schema: false,
-  partial_output: false,
-  invalid_config: false
-};
-function isAnalysisFailureKind(value) {
-  return typeof value === "string" && ANALYSIS_FAILURE_KINDS.includes(value);
-}
-function classifyAnalysisFailure(kind) {
-  if (!isAnalysisFailureKind(kind)) {
-    throw new TypeError(
-      `unknown analysis failure kind: ${String(kind)}; allowed kinds: ${ANALYSIS_FAILURE_KINDS.join(", ")}`
-    );
-  }
-  return {
-    kind,
-    retryable: RETRYABLE_BY_KIND[kind],
-    preservesDeterministic: true
-  };
-}
-
 // src/activity/timeline/recap-merge-edits.ts
 function dedupeByFirst(list) {
   const seen = /* @__PURE__ */ new Set();
@@ -28546,55 +28095,6 @@ function mergeRecapUserEdits(input) {
   return { sections, preserved, regenerated };
 }
 
-// src/activity/timeline/analysis-metadata.ts
-var ANALYSIS_METADATA_MAX_FIELD_LENGTH = 120;
-var IDENTIFIER = /^[A-Za-z0-9][A-Za-z0-9._:\-\/]*$/;
-var FIELD_PATTERNS = {
-  provider: IDENTIFIER,
-  model: IDENTIFIER,
-  promptVersion: IDENTIFIER
-};
-function validateMetadataField(field, value) {
-  if (typeof value !== "string") {
-    throw new RangeError(
-      `analysis run metadata ${field} must be a string; received ${typeof value}`
-    );
-  }
-  if (value.length === 0) {
-    throw new RangeError(`analysis run metadata ${field} must not be empty`);
-  }
-  if (value.length > ANALYSIS_METADATA_MAX_FIELD_LENGTH) {
-    throw new RangeError(
-      `analysis run metadata ${field} is too long (max ${ANALYSIS_METADATA_MAX_FIELD_LENGTH} characters)`
-    );
-  }
-  if (/[\n\r\u2028\u2029]/.test(value)) {
-    throw new RangeError(`analysis run metadata ${field} must not contain a line break`);
-  }
-  const pattern = FIELD_PATTERNS[field];
-  if (pattern === void 0) {
-    throw new RangeError(`analysis run metadata has no pattern for field ${field}`);
-  }
-  if (!pattern.test(value)) {
-    throw new RangeError(
-      `analysis run metadata ${field} must be an identifier (letters, digits, and ._:-/ only)`
-    );
-  }
-  return value;
-}
-function buildAnalysisRunMetadata(input) {
-  const provider = validateMetadataField("provider", input.provider);
-  const model = validateMetadataField("model", input.model);
-  const promptVersion = validateMetadataField("promptVersion", input.promptVersion);
-  const observationCount = input.observationCount;
-  if (typeof observationCount !== "number" || !Number.isInteger(observationCount) || observationCount < 0) {
-    throw new RangeError(
-      `analysis run metadata observationCount must be a non-negative integer; received ${typeof observationCount}`
-    );
-  }
-  return { provider, model, promptVersion, observationCount };
-}
-
 // src/activity/timeline/recap-fallback.ts
 var RECAP_SOURCE_KINDS = ["ai", "deterministic", "previous"];
 var SLOT_ORDER = [
@@ -28644,234 +28144,12 @@ function selectRecapForDay(input) {
   return failure === void 0 ? { ok: false, error: "no_recap_available" } : { ok: false, error: "no_recap_available", failure };
 }
 
-// src/activity/journal-vault-read.ts
-var REMNIC_OPEN = "<!-- remnic:";
-function readVaultJournal(input) {
-  if (input.fileText === null || input.fileText === void 0) {
-    return { ok: true, exists: false, reason: "missing_file" };
-  }
-  if (input.journalSection.length === 0) {
-    return { ok: true, exists: false, reason: "missing_heading" };
-  }
-  const lines = splitFileLines(input.fileText);
-  const hits = [];
-  const levels = [];
-  for (let i = 0; i < lines.length; i++) {
-    const heading = parseAtxHeading(lines[i]);
-    if (heading && heading.text === input.journalSection) {
-      hits.push(i + 1);
-      levels.push(heading.level);
-    }
-  }
-  if (hits.length === 0) return { ok: true, exists: false, reason: "missing_heading" };
-  if (hits.length > 1) return { ok: false, reason: "duplicate_heading", lines: hits };
-  const headingIndex = hits[0] - 1;
-  const level = levels[0];
-  let endIndex = lines.length;
-  for (let i = headingIndex + 1; i < lines.length; i++) {
-    const heading = parseAtxHeading(lines[i]);
-    if (heading && heading.level <= level) {
-      endIndex = i;
-      break;
-    }
-  }
-  const body = lines.slice(headingIndex + 1, endIndex).join("\n");
-  const stripped = stripRemnicOwnedRegions(body, input.publishSectionNames ?? []);
-  return {
-    ok: true,
-    exists: true,
-    text: trimNewlines(stripped.text),
-    heading: input.journalSection,
-    warnings: stripped.warnings
-  };
-}
-function stripRemnicOwnedRegions(text, publishSectionNames = []) {
-  const marked = cutIntervals(text, remnicIntervals(text));
-  return {
-    text: stripPublishHeadings(marked.text, publishSectionNames),
-    warnings: marked.warnings
-  };
-}
-function splitFileLines(fileText) {
-  const lines = fileText.split("\n");
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (line.endsWith("\r")) lines[i] = line.slice(0, -1);
-  }
-  return lines;
-}
-function parseAtxHeading(line) {
-  let level = 0;
-  while (level < line.length && level < 6 && line[level] === "#") level++;
-  if (level === 0) return null;
-  const after = line[level];
-  if (after !== " " && after !== "	") return null;
-  let start = level + 1;
-  let end = line.length;
-  while (start < end && (line[start] === " " || line[start] === "	")) start++;
-  while (end > start && (line[end - 1] === " " || line[end - 1] === "	")) end--;
-  let hashEnd = end;
-  while (hashEnd > start && line[hashEnd - 1] === "#") hashEnd--;
-  if (hashEnd < end && hashEnd > start && (line[hashEnd - 1] === " " || line[hashEnd - 1] === "	")) {
-    end = hashEnd;
-    while (end > start && (line[end - 1] === " " || line[end - 1] === "	")) end--;
-  }
-  return { level, text: line.slice(start, end) };
-}
-function remnicIntervals(text) {
-  const starts = [];
-  const ends = [];
-  let from = 0;
-  while (from < text.length) {
-    const open = text.indexOf(REMNIC_OPEN, from);
-    if (open === -1) break;
-    const afterOpen = open + REMNIC_OPEN.length;
-    const commentEnd = text.indexOf("-->", afterOpen);
-    if (commentEnd === -1) break;
-    const inner = text.slice(afterOpen, commentEnd).trim();
-    if (inner.endsWith(":start")) {
-      const name = inner.slice(0, -":start".length);
-      if (name.length > 0) starts.push({ name, start: open, after: commentEnd + 3 });
-    } else if (inner.endsWith(":end")) {
-      const name = inner.slice(0, -":end".length);
-      if (name.length > 0) ends.push({ name, start: open, end: commentEnd + 3 });
-    }
-    from = commentEnd + 3;
-  }
-  const usedEnds = /* @__PURE__ */ new Set();
-  const intervals = [];
-  const warnings = [];
-  for (const start of starts) {
-    const match = ends.find((end) => end.name === start.name && end.start >= start.after && !usedEnds.has(end.start));
-    if (match) {
-      usedEnds.add(match.start);
-      intervals.push({ start: start.start, end: eatTrailingNewline(text, match.end) });
-    } else {
-      intervals.push({ start: start.start, end: text.length });
-      warnings.push(`unclosed remnic region "${start.name}"`);
-    }
-  }
-  for (const end of ends) {
-    if (usedEnds.has(end.start)) continue;
-    const startBefore = starts.some((start) => start.start < end.start);
-    if (!startBefore) intervals.push({ start: 0, end: eatTrailingNewline(text, end.end) });
-  }
-  return { intervals: mergeIntervals2(intervals), warnings };
-}
-function eatTrailingNewline(text, index) {
-  if (text[index] === "\n") return index + 1;
-  if (text[index] === "\r" && text[index + 1] === "\n") return index + 2;
-  if (text[index] === "\r") return index + 1;
-  return index;
-}
-function mergeIntervals2(items) {
-  if (items.length === 0) return [];
-  const sorted = items.slice().sort((a, b) => a.start - b.start || a.end - b.end);
-  const out = [{ start: sorted[0].start, end: sorted[0].end }];
-  for (let i = 1; i < sorted.length; i++) {
-    const cur = sorted[i];
-    const last = out[out.length - 1];
-    if (cur.start <= last.end) last.end = Math.max(last.end, cur.end);
-    else out.push({ start: cur.start, end: cur.end });
-  }
-  return out;
-}
-function cutIntervals(text, found) {
-  let out = "";
-  let pos = 0;
-  for (const interval of found.intervals) {
-    if (interval.start > pos) out += text.slice(pos, interval.start);
-    pos = Math.max(pos, interval.end);
-  }
-  if (pos < text.length) out += text.slice(pos);
-  return { text: out, warnings: found.warnings };
-}
-function stripPublishHeadings(text, names) {
-  if (names.length === 0 || text.length === 0) return text;
-  const lines = text.split("\n");
-  const keep = lines.map(() => true);
-  for (let i = 0; i < lines.length; i++) {
-    if (!keep[i]) continue;
-    const heading = parseAtxHeading(lines[i]);
-    if (!heading || !names.includes(heading.text)) continue;
-    keep[i] = false;
-    for (let j = i + 1; j < lines.length; j++) {
-      const next = parseAtxHeading(lines[j]);
-      if (next && next.level <= heading.level) break;
-      keep[j] = false;
-    }
-  }
-  return lines.filter((_, i) => keep[i]).join("\n");
-}
-function trimNewlines(text) {
-  let start = 0;
-  let end = text.length;
-  while (start < end && (text[start] === "\n" || text[start] === "\r")) start++;
-  while (end > start && (text[end - 1] === "\n" || text[end - 1] === "\r")) end--;
-  return text.slice(start, end);
-}
-
-// src/activity/journal-vault-prereq.ts
-var VAULT_JOURNAL_PREREQUISITES = [
-  "vault.enabled",
-  "vault.dailyNotePath",
-  "vault.readback.journalSection"
-];
-function checkVaultJournalPrerequisites(input) {
-  const missing = [];
-  if (input.vaultEnabled !== true) missing.push("vault.enabled");
-  if (typeof input.dailyNotePath !== "string" || input.dailyNotePath.trim().length === 0) {
-    missing.push("vault.dailyNotePath");
-  }
-  if (typeof input.journalSection !== "string" || input.journalSection.trim().length === 0) {
-    missing.push("vault.readback.journalSection");
-  }
-  if (missing.length === 0) return { ok: true };
-  return {
-    ok: false,
-    missing,
-    message: `vault journal read-back prerequisites unmet: ${missing.join(", ")}`
-  };
-}
-
-// src/activity/journal-vault-provenance.ts
-var DAY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
-function buildJournalMemoryProvenance(input) {
-  if (typeof input.source !== "string") {
-    throw new RangeError("journal provenance source must be a string");
-  }
-  const resolved = resolveJournalSource({
-    source: input.source,
-    // Provenance never consumes the heading; vault mode just requires a
-    // non-empty one to resolve.
-    heading: "journal"
-  });
-  if (!resolved.ok) {
-    throw new RangeError(
-      `journal provenance source must be one of "file", "vault": ${JSON.stringify(input.source)}`
-    );
-  }
-  if (typeof input.date !== "string" || !DAY_PATTERN.test(input.date)) {
-    throw new RangeError(
-      `journal provenance date must be exactly YYYY-MM-DD: ${JSON.stringify(input.date)}`
-    );
-  }
-  const [year, month, day] = input.date.split("-").map(Number);
-  const utc = new Date(Date.UTC(year, month - 1, day));
-  if (utc.getUTCFullYear() !== year || utc.getUTCMonth() !== month - 1 || utc.getUTCDate() !== day) {
-    throw new RangeError(
-      `journal provenance date must be a real calendar day: ${input.date}`
-    );
-  }
-  return {
-    tags: ["journal", `journal-day:${input.date}`],
-    structuredAttributes: { journalSource: resolved.mode },
-    validAt: `${input.date}T00:00:00.000Z`
-  };
-}
+// src/activity/journal-read.ts
+import { closeSync, constants as fsConstants, fstatSync, lstatSync, openSync, readFileSync as readFileSync3, realpathSync, statSync as statSync2 } from "fs";
+import path34 from "path";
 
 // src/activity/journal-section.ts
-function parseAtxHeading2(line) {
+function parseAtxHeading(line) {
   let level = 0;
   while (level < line.length && level < 6 && line[level] === "#") level++;
   if (level === 0) return null;
@@ -28895,10 +28173,12 @@ var MARKER_OPEN = "<!-- remnic:";
 var MARKER_CLOSE = "-->";
 var START_SUFFIX = ":start";
 var END_SUFFIX = ":end";
-function stripRemnicOwnedRegions2(sectionText, ownedHeadings) {
-  return stripOwnedHeadings(stripMarkerRegions(sectionText), ownedHeadings);
+function stripRemnicOwnedRegions(sectionText, ownedHeadings) {
+  const warnings = [];
+  const marked = stripMarkerRegions(sectionText, warnings);
+  return { text: stripOwnedHeadings(marked, ownedHeadings), warnings };
 }
-function stripMarkerRegions(text) {
+function stripMarkerRegions(text, warnings) {
   const lines = text.split("\n");
   const keep = lines.map(() => true);
   let openName = null;
@@ -28911,9 +28191,17 @@ function stripMarkerRegions(text) {
     }
     if (marker) {
       keep[i] = false;
-      if (marker.kind === "start") openName = marker.name;
+      if (marker.kind === "start") {
+        openName = marker.name;
+      } else {
+        for (let j = 0; j < i; j++) keep[j] = false;
+        warnings.push(`unmatched remnic region end "${marker.name}"`);
+      }
     }
   }
+  if (openName !== null) {
+    warnings.push(`unclosed remnic region "${openName}"`);
+  }
   return emitKeptLines(lines, keep);
 }
 function stripOwnedHeadings(text, ownedHeadings) {
@@ -28923,11 +28211,11 @@ function stripOwnedHeadings(text, ownedHeadings) {
   const keep = lines.map(() => true);
   for (let i = 0; i < lines.length; i++) {
     if (!keep[i]) continue;
-    const heading = parseAtxHeading2(lines[i]);
+    const heading = parseAtxHeading(lines[i]);
     if (!heading || !wanted.has(heading.text)) continue;
     keep[i] = false;
     for (let j = i + 1; j < lines.length; j++) {
-      const next = parseAtxHeading2(lines[j]);
+      const next = parseAtxHeading(lines[j]);
       if (next && next.level <= heading.level) break;
       keep[j] = false;
     }
@@ -28977,6 +28265,427 @@ function ownedHeadingSet(ownedHeadings) {
   return wanted;
 }
 
+// src/activity/journal-vault-read.ts
+function readVaultJournal(input) {
+  if (input.fileText === null || input.fileText === void 0) {
+    return { ok: true, exists: false, reason: "missing_file" };
+  }
+  if (input.journalSection.length === 0) {
+    return { ok: true, exists: false, reason: "missing_heading" };
+  }
+  const lines = splitFileLines(input.fileText);
+  const hits = [];
+  const levels = [];
+  for (let i = 0; i < lines.length; i++) {
+    const heading = parseAtxHeading(lines[i]);
+    if (heading && heading.text === input.journalSection) {
+      hits.push(i + 1);
+      levels.push(heading.level);
+    }
+  }
+  if (hits.length === 0) return { ok: true, exists: false, reason: "missing_heading" };
+  if (hits.length > 1) return { ok: false, reason: "duplicate_heading", lines: hits };
+  const headingIndex = hits[0] - 1;
+  const level = levels[0];
+  let endIndex = lines.length;
+  for (let i = headingIndex + 1; i < lines.length; i++) {
+    const heading = parseAtxHeading(lines[i]);
+    if (heading && heading.level <= level) {
+      endIndex = i;
+      break;
+    }
+  }
+  const body = lines.slice(headingIndex + 1, endIndex).join("\n");
+  const stripped = stripRemnicOwnedRegions(body, input.publishSectionNames ?? []);
+  return {
+    ok: true,
+    exists: true,
+    text: trimNewlines(stripped.text),
+    heading: input.journalSection,
+    warnings: stripped.warnings
+  };
+}
+function splitFileLines(fileText) {
+  const lines = fileText.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.endsWith("\r")) lines[i] = line.slice(0, -1);
+  }
+  return lines;
+}
+function trimNewlines(text) {
+  let start = 0;
+  let end = text.length;
+  while (start < end && (text[start] === "\n" || text[start] === "\r")) start++;
+  while (end > start && (text[end - 1] === "\n" || text[end - 1] === "\r")) end--;
+  return text.slice(start, end);
+}
+
+// src/activity/journal-read.ts
+function publisherOwnedSectionNames(vault) {
+  if (vault.sectionStrategy !== "heading") return [];
+  const names = [];
+  for (const target of Object.values(vault.publish)) {
+    if (target.enabled && target.target === "daily" && target.section.trim().length > 0) {
+      names.push(target.section);
+    }
+  }
+  return names;
+}
+function readJournalForDate(input) {
+  const journalSection = input.vault.readback.journalSection;
+  const relative = resolveVaultNotePath(input.vault.dailyNotePath, input.date, {
+    timezone: input.timezone
+  });
+  const root = path34.resolve(expandTildePath(input.vault.vaultPath));
+  const filePath = path34.join(root, relative);
+  try {
+    const rootStat = lstatSync(root);
+    if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
+      return { ok: false, reason: "not_directory", filePath };
+    }
+  } catch {
+    return { ok: true, exists: false, reason: "missing_file", filePath };
+  }
+  const lexical = path34.relative(root, filePath);
+  if (lexical.length === 0 || lexical === ".." || lexical.startsWith(`..${path34.sep}`) || path34.isAbsolute(lexical)) {
+    return { ok: false, reason: "path_escape", filePath };
+  }
+  if (!containedBySymlinks(root, filePath)) {
+    return { ok: false, reason: "symlink_escape", filePath };
+  }
+  let fileText;
+  try {
+    fileText = readVerifiedDailyNote(root, filePath);
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      return { ok: true, exists: false, reason: "missing_file", filePath };
+    }
+    if (code === "ELOOP" || code === "EISDIR") {
+      return { ok: false, reason: "symlink_escape", filePath };
+    }
+    throw err;
+  }
+  const result = readVaultJournal({
+    fileText,
+    journalSection,
+    publishSectionNames: publisherOwnedSectionNames(input.vault)
+  });
+  return { ...result, filePath };
+}
+function containedBySymlinks(root, dest) {
+  const realRoot = realpathSync(root);
+  let probe = dest;
+  for (; ; ) {
+    try {
+      if (statSync2(probe).isFile() || statSync2(probe).isDirectory()) {
+        const real = realpathSync(probe);
+        return real === realRoot || real.startsWith(`${realRoot}${path34.sep}`);
+      }
+    } catch {
+    }
+    const parent = path34.dirname(probe);
+    if (parent === probe) return false;
+    probe = parent;
+  }
+}
+function symlinkRejected() {
+  const err = new Error("symlink refused");
+  err.code = "ELOOP";
+  return err;
+}
+function readVerifiedDailyNote(root, filePath) {
+  const relative = path34.relative(root, filePath);
+  const parts = relative.split(path34.sep).filter((part) => part.length > 0 && part !== ".");
+  let cursor = root;
+  for (const part of parts) {
+    cursor = path34.join(cursor, part);
+    const st = lstatSync(cursor);
+    if (st.isSymbolicLink()) throw symlinkRejected();
+  }
+  const parent = path34.dirname(filePath);
+  const parentLstat = lstatSync(parent);
+  if (parentLstat.isSymbolicLink() || !parentLstat.isDirectory()) throw symlinkRejected();
+  const nofollow = fsConstants.O_NOFOLLOW ?? 0;
+  const parentFd = openSync(parent, fsConstants.O_RDONLY | fsConstants.O_DIRECTORY | nofollow);
+  try {
+    const parentFstat = fstatSync(parentFd);
+    if (parentFstat.ino !== parentLstat.ino || parentFstat.dev !== parentLstat.dev) {
+      throw symlinkRejected();
+    }
+  } finally {
+    closeSync(parentFd);
+  }
+  const fd = openSync(filePath, fsConstants.O_RDONLY | nofollow);
+  try {
+    const opened = fstatSync(fd);
+    if (!opened.isFile()) throw symlinkRejected();
+    const pathLstat = lstatSync(filePath);
+    if (pathLstat.isSymbolicLink() || pathLstat.ino !== opened.ino || pathLstat.dev !== opened.dev) {
+      throw symlinkRejected();
+    }
+    try {
+      const fdPath = realpathSync(`/proc/self/fd/${fd}`);
+      const realRoot = realpathSync(root);
+      if (fdPath !== realRoot && !fdPath.startsWith(`${realRoot}${path34.sep}`)) {
+        throw symlinkRejected();
+      }
+    } catch (err) {
+      if (err.code === "ELOOP") throw err;
+    }
+    return readFileSync3(fd, "utf8");
+  } finally {
+    closeSync(fd);
+  }
+}
+
+// src/activity/journal-state.ts
+import { createHash as createHash9, randomBytes as randomBytes4 } from "crypto";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "fs";
+import path35 from "path";
+var STATE_DIR_NAME = "state";
+var STATE_FILE_NAME = "timeline.json";
+function timelineStatePath(memoryDir) {
+  return path35.join(memoryDir, STATE_DIR_NAME, STATE_FILE_NAME);
+}
+function hashJournalText(text) {
+  return createHash9("sha256").update(text, "utf8").digest("hex");
+}
+function readTimelineState(memoryDir) {
+  const filePath = timelineStatePath(memoryDir);
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync4(filePath, "utf8"));
+  } catch {
+    return { version: 1, journal: {} };
+  }
+  if (typeof parsed !== "object" || parsed === null || !("journal" in parsed)) {
+    return { version: 1, journal: {} };
+  }
+  const journal = parsed.journal;
+  if (typeof journal !== "object" || journal === null) return { version: 1, journal: {} };
+  const hashes = {};
+  for (const [date, value] of Object.entries(journal)) {
+    if (typeof value === "string" && value.length > 0) hashes[date] = value;
+  }
+  return { version: 1, journal: hashes };
+}
+function writeTimelineState(memoryDir, state) {
+  const filePath = timelineStatePath(memoryDir);
+  mkdirSync2(path35.dirname(filePath), { recursive: true });
+  const tempPath = `${filePath}.${process.pid}.${randomBytes4(8).toString("hex")}.tmp`;
+  writeFileSync2(tempPath, `${JSON.stringify(state, null, 2)}
+`);
+  renameSync2(tempPath, filePath);
+}
+function journalDateLockPath(memoryDir, date) {
+  return path35.join(memoryDir, STATE_DIR_NAME, `journal-extract-${date}.lock`);
+}
+function timelineStateLockPath(memoryDir) {
+  return `${timelineStatePath(memoryDir)}.lock`;
+}
+var DATE_LOCK_OPTS = { staleMs: 12e4, maxWaitMs: 6e4 };
+var STATE_LOCK_OPTS = { staleMs: 3e4, maxWaitMs: 15e3 };
+async function withJournalDateLock(memoryDir, date, task) {
+  return withHeldFileLock(journalDateLockPath(memoryDir, date), DATE_LOCK_OPTS, async (acquired) => {
+    if (!acquired) {
+      throw new Error(`journal: could not acquire the extract lock for ${date}`);
+    }
+    return task();
+  });
+}
+async function commitJournalHash(memoryDir, date, hash) {
+  await withHeldFileLock(timelineStateLockPath(memoryDir), STATE_LOCK_OPTS, async (acquired) => {
+    if (!acquired) {
+      throw new Error("journal: could not acquire the timeline state lock");
+    }
+    const latest = readTimelineState(memoryDir);
+    writeTimelineState(memoryDir, setJournalHash(latest, date, hash));
+  });
+}
+function setJournalHash(state, date, hash) {
+  return { ...state, journal: { ...state.journal, [date]: hash } };
+}
+function journalUnchanged(state, date, text) {
+  const stored = state.journal[date];
+  return typeof stored === "string" && stored === hashJournalText(text);
+}
+
+// src/activity/journal-vault-provenance.ts
+var DAY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+function buildJournalMemoryProvenance(input) {
+  if (typeof input.source !== "string") {
+    throw new RangeError("journal provenance source must be a string");
+  }
+  const resolved = resolveJournalSource({ source: input.source });
+  if (!resolved.ok) {
+    throw new RangeError(
+      `journal provenance source must be one of "memoryDir", "vault": ${JSON.stringify(input.source)}`
+    );
+  }
+  if (typeof input.date !== "string" || !DAY_PATTERN.test(input.date)) {
+    throw new RangeError(
+      `journal provenance date must be exactly YYYY-MM-DD: ${JSON.stringify(input.date)}`
+    );
+  }
+  const [year, month, day] = input.date.split("-").map(Number);
+  const utc = new Date(Date.UTC(year, month - 1, day));
+  if (utc.getUTCFullYear() !== year || utc.getUTCMonth() !== month - 1 || utc.getUTCDate() !== day) {
+    throw new RangeError(
+      `journal provenance date must be a real calendar day: ${input.date}`
+    );
+  }
+  return {
+    tags: ["journal", `journal-day:${input.date}`],
+    structuredAttributes: { journalSource: resolved.mode },
+    validAt: `${input.date}T00:00:00.000Z`
+  };
+}
+
+// src/activity/journal-extract.ts
+function createJournalMemoryWriter(storage) {
+  return {
+    writeSealedMemory: storage.writeSealedMemory.bind(storage),
+    hasJournalMemoryContent: async (content) => {
+      if (await storage.hasFactContentHash(content)) return true;
+      const needle = stripAttributesSuffix(content);
+      const memories = await storage.readAllMemories();
+      return memories.some(
+        (memory) => Array.isArray(memory.frontmatter.tags) && memory.frontmatter.tags.includes("journal") && stripAttributesSuffix(memory.content) === needle
+      );
+    }
+  };
+}
+async function runJournalReviewExtraction(input) {
+  const result = {
+    pendingReview: 0,
+    rejectedByJudge: 0,
+    skipped: 0,
+    completed: false,
+    warnings: []
+  };
+  if (input.journalConfig.extractionMode !== "review") return result;
+  if (input.journalText.trim().length === 0) {
+    result.completed = true;
+    return result;
+  }
+  const sanitized = sanitizeMemoryContent(input.journalText);
+  if (!sanitized.clean) {
+    result.warnings.push(
+      `journal text for ${input.date} failed sanitization (${sanitized.violations.length} violation(s)); extraction skipped`
+    );
+    result.completed = true;
+    return result;
+  }
+  const provenance = buildJournalMemoryProvenance({ source: input.source, date: input.date });
+  let extracted;
+  try {
+    extracted = await input.deps.extract([
+      {
+        role: "user",
+        content: sanitized.text,
+        timestamp: (input.deps.now ?? (() => /* @__PURE__ */ new Date()))().toISOString()
+      }
+    ]);
+  } catch (err) {
+    log.warn(
+      `journal extraction failed for ${input.date}: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return result;
+  }
+  if (extracted.extractionFailure !== void 0) {
+    log.warn(
+      `journal extraction reported a failure for ${input.date}: ${extracted.extractionFailure}`
+    );
+    return result;
+  }
+  result.completed = true;
+  let verdicts = /* @__PURE__ */ new Map();
+  const candidates = dedupeInRun(extracted.facts, result);
+  if (input.deps.judge !== void 0 && candidates.length > 0) {
+    try {
+      verdicts = await input.deps.judge(
+        candidates.map((fact) => ({
+          text: fact.content,
+          category: fact.category,
+          confidence: fact.confidence,
+          tags: fact.tags,
+          importanceLevel: scoreImportance(fact.content, fact.category, fact.tags).level
+        }))
+      );
+    } catch (err) {
+      log.warn(
+        `journal extraction judge unavailable for ${input.date}: ${err instanceof Error ? err.message : String(err)} \u2014 review-only writes continue without verdicts`
+      );
+    }
+  }
+  let wrote = false;
+  const ctx = { source: "journal", now: input.deps.now };
+  for (let index = 0; index < candidates.length; index += 1) {
+    const fact = candidates[index];
+    const verdict = verdicts.get(index);
+    const verdictKind = verdict === void 0 ? void 0 : getVerdictKind(verdict);
+    if (verdictKind === "reject") {
+      result.rejectedByJudge += 1;
+      continue;
+    }
+    const normalizedKey = fact.content.trim().toLowerCase();
+    if (await input.deps.writer.hasJournalMemoryContent(fact.content)) {
+      result.skipped += 1;
+      continue;
+    }
+    const envelope = composeMemoryEnvelope(
+      {
+        content: fact.content,
+        category: fact.category,
+        tags: [...fact.tags, ...provenance.tags],
+        entityRef: fact.entityRef,
+        confidence: fact.confidence,
+        validAt: provenance.validAt,
+        structuredAttributes: { ...provenance.structuredAttributes },
+        sourceConnector: "journal",
+        sourceReason: input.source === "vault" ? "vault daily-note journal" : "memoryDir journal"
+      },
+      ctx,
+      { salvage: true }
+    );
+    if (envelope.salvageNotes.length > 0) {
+      log.warn(`journal write salvaged invalid fields: ${envelope.salvageNotes.join("; ")}`);
+    }
+    const write = await input.deps.writer.writeSealedMemory(envelope, {
+      status: "pending_review",
+      contentHashSource: normalizedKey,
+      importance: scoreImportance(fact.content, fact.category, fact.tags)
+    });
+    if (write.tombstoneBlocked) {
+      result.skipped += 1;
+      continue;
+    }
+    result.pendingReview += 1;
+    wrote = true;
+  }
+  if (wrote && input.deps.afterWrites !== void 0) {
+    try {
+      await input.deps.afterWrites();
+    } catch (err) {
+      result.warnings.push(
+        `reindex after journal writes failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return result;
+}
+function dedupeInRun(facts, result) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const fact of facts) {
+    const key = fact.content.trim().toLowerCase();
+    if (!seen.has(key)) seen.set(key, fact);
+    else result.skipped += 1;
+  }
+  return [...seen.values()];
+}
+
 // src/activity/memory-gen.ts
 var ACTIVITY_ALLOWED_CATEGORIES = {
   decision: true,
@@ -29488,7 +29197,7 @@ function applyVaultFrontmatter(existingYaml, updates) {
 }
 
 // src/activity/vault-wikilink.ts
-import path35 from "path";
+import path36 from "path";
 function formatVaultWikilink(notePath) {
   if (typeof notePath !== "string" || notePath.trim().length === 0) {
     throw new RangeError("Vault wikilink path must be a non-empty relative path.");
@@ -29496,7 +29205,7 @@ function formatVaultWikilink(notePath) {
   if (notePath.includes("\n") || notePath.includes("\r")) {
     throw new RangeError("Vault wikilink path must not contain newlines.");
   }
-  if (path35.posix.isAbsolute(notePath) || path35.win32.isAbsolute(notePath)) {
+  if (path36.posix.isAbsolute(notePath) || path36.win32.isAbsolute(notePath)) {
     throw new RangeError("Vault wikilink path must be relative; absolute paths are rejected.");
   }
   if (notePath.split(/[\\/]/).some((segment) => segment === "..")) {
@@ -29518,7 +29227,7 @@ function stripVaultMdSuffix(notePath) {
 }
 
 // src/activity/vault-join.ts
-import path36 from "path";
+import path37 from "path";
 function joinVaultSegments(parts) {
   if (parts.length === 0) {
     throw new RangeError("Vault path parts must be a non-empty list.");
@@ -29533,7 +29242,7 @@ function joinVaultSegments(parts) {
     if (part.includes("\n") || part.includes("\r")) {
       throw new RangeError("Vault path part must not contain a newline.");
     }
-    if (path36.posix.isAbsolute(part) || path36.win32.isAbsolute(part)) {
+    if (path37.posix.isAbsolute(part) || path37.win32.isAbsolute(part)) {
       throw new RangeError("Vault path part must be relative.");
     }
     if (part.split("/").includes("..")) {
@@ -29588,7 +29297,7 @@ function planVaultDryRun(inputs) {
 // src/session-summaries/index.ts
 import { createHash as createHash10 } from "crypto";
 import { lstat as lstat3, mkdir as mkdir7, readFile as readFile8, readdir as readdir4, rename, rm, stat as stat4, writeFile as writeFile7 } from "fs/promises";
-import path37 from "path";
+import path38 from "path";
 
 // src/session-summaries/adapters.ts
 var VALID_ROLES = /* @__PURE__ */ new Set(["user", "assistant", "tool", "system", "other"]);
@@ -30093,7 +29802,7 @@ function shortHash(value, length = 16) {
 async function listTranscriptFiles(root, maxFiles) {
   const out = [];
   let truncated = false;
-  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path37.sep}` : entryName;
+  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path38.sep}` : entryName;
   async function visit(dir) {
     if (truncated) return;
     const entries = (await readdir4(dir, { withFileTypes: true })).sort(
@@ -30103,13 +29812,13 @@ async function listTranscriptFiles(root, maxFiles) {
       if (truncated) return;
       if (entry.name.startsWith(".")) continue;
       if (entry.isSymbolicLink()) continue;
-      const fullPath = path37.join(dir, entry.name);
+      const fullPath = path38.join(dir, entry.name);
       if (entry.isDirectory()) {
         await visit(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      const ext = path37.extname(entry.name).toLowerCase();
+      const ext = path38.extname(entry.name).toLowerCase();
       if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
       out.push(fullPath);
       if (out.length > maxFiles) {
@@ -30136,7 +29845,7 @@ function normalizeInputDir(inputDir) {
   if (typeof inputDir !== "string" || inputDir.trim().length === 0) {
     throw new Error("inputDir must be a non-empty string");
   }
-  return path37.resolve(expandTildePath(inputDir.trim()));
+  return path38.resolve(expandTildePath(inputDir.trim()));
 }
 function initRoleCounts() {
   return {
@@ -30293,11 +30002,11 @@ async function collectLocalSessionSummaries(options) {
       continue;
     }
     seenFileHashes.add(fileHash);
-    const fileExtension = path37.extname(filePath).toLowerCase();
+    const fileExtension = path38.extname(filePath).toLowerCase();
     const parsed = await adapter.parseFile(
       {
         content,
-        fileName: path37.basename(filePath),
+        fileName: path38.basename(filePath),
         fileExtension,
         fileRef: fileHash
       },
@@ -30353,7 +30062,7 @@ async function collectLocalSessionSummaries(options) {
 }
 async function readRedactionConfig(pathLike) {
   if (!pathLike) return void 0;
-  const raw = await readFile8(path37.resolve(expandTildePath(pathLike)), "utf-8");
+  const raw = await readFile8(path38.resolve(expandTildePath(pathLike)), "utf-8");
   const parsed = JSON.parse(raw);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error("redaction config must be a JSON object");
@@ -30366,15 +30075,15 @@ function toJsonl(drafts) {
 }
 function defaultDraftOutputPath(memoryDir, generatedAt) {
   const stamp = generatedAt.replace(/[:.]/g, "-");
-  return path37.join(
-    path37.resolve(expandTildePath(memoryDir)),
+  return path38.join(
+    path38.resolve(expandTildePath(memoryDir)),
     "state",
     "session-summary-drafts",
     `session-summaries-${stamp}.jsonl`
   );
 }
 async function writeDrafts(filePath, drafts) {
-  await mkdir7(path37.dirname(filePath), { recursive: true });
+  await mkdir7(path38.dirname(filePath), { recursive: true });
   const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
   try {
     await writeFile7(tempPath, toJsonl(drafts), "utf-8");
@@ -30392,7 +30101,7 @@ async function runLocalSessionSummaryCliCommand(options) {
   });
   const wroteFiles = [];
   if (options.output) {
-    const outputPath = path37.resolve(expandTildePath(options.output));
+    const outputPath = path38.resolve(expandTildePath(options.output));
     await writeDrafts(outputPath, report.drafts);
     wroteFiles.push(outputPath);
   }
@@ -30427,19 +30136,19 @@ async function runLocalSessionSummaryCliCommand(options) {
 
 // src/transfer/capsule-fork.ts
 import { lstat as lstat4, mkdir as mkdir8, readFile as readFile9, realpath as realpath3, writeFile as writeFile8 } from "fs/promises";
-import path38 from "path";
+import path39 from "path";
 async function forkCapsule(opts) {
   validateForkId(opts.forkId);
-  const rootAbs = path38.resolve(opts.targetRoot);
+  const rootAbs = path39.resolve(opts.targetRoot);
   await assertIsDirectoryNotSymlink(rootAbs, "forkCapsule", "targetRoot");
-  const forkDirAbs = path38.join(rootAbs, "forks", opts.forkId);
+  const forkDirAbs = path39.join(rootAbs, "forks", opts.forkId);
   const forkEntryExists = await pathEntryExists(forkDirAbs);
   if (forkEntryExists) {
     throw new Error(
       `forkCapsule: fork path already exists \u2014 forkId "${opts.forkId}" is already in use at: ${forkDirAbs}`
     );
   }
-  const archiveAbs = path38.resolve(opts.sourceArchive);
+  const archiveAbs = path39.resolve(opts.sourceArchive);
   const importResult = await importCapsule({
     archivePath: archiveAbs,
     root: rootAbs,
@@ -30461,10 +30170,10 @@ async function forkCapsule(opts) {
     importedRecords: importResult.imported.length,
     skippedRecords: importResult.skipped.length
   };
-  const lineagePath = path38.join(forkDirAbs, "lineage.json");
+  const lineagePath = path39.join(forkDirAbs, "lineage.json");
   const rootReal = await realpath3(rootAbs);
   await assertRealpathInsideRoot(rootReal, lineagePath, `forks/${opts.forkId}/lineage.json`, "forkCapsule");
-  await mkdir8(path38.dirname(lineagePath), { recursive: true });
+  await mkdir8(path39.dirname(lineagePath), { recursive: true });
   await writeFile8(lineagePath, JSON.stringify(lineage, null, 2) + "\n", "utf-8");
   return {
     archivePath: archiveAbs,
@@ -30478,11 +30187,11 @@ async function readForkLineage(targetRoot, forkId) {
   if (typeof forkId !== "string" || forkId.length === 0 || forkId.length > 64 || !CAPSULE_ID_PATTERN.test(forkId)) {
     return null;
   }
-  const rootAbs = path38.resolve(targetRoot);
+  const rootAbs = path39.resolve(targetRoot);
   const rootReal = await realpath3(rootAbs).catch(() => rootAbs);
-  const lineagePath = path38.join(rootReal, "forks", forkId, "lineage.json");
-  const rel = path38.relative(rootReal, lineagePath);
-  if (rel.startsWith("..") || path38.isAbsolute(rel)) {
+  const lineagePath = path39.join(rootReal, "forks", forkId, "lineage.json");
+  const rel = path39.relative(rootReal, lineagePath);
+  if (rel.startsWith("..") || path39.isAbsolute(rel)) {
     return null;
   }
   if (!await isLineagePathContained(rootReal, lineagePath)) {
@@ -30523,19 +30232,19 @@ async function pathEntryExists(absPath) {
 async function isLineagePathContained(rootReal, lineagePath) {
   let existing = lineagePath;
   const suffix = [];
-  while (existing !== path38.dirname(existing)) {
+  while (existing !== path39.dirname(existing)) {
     const st = await lstat4(existing).catch(() => null);
     if (st !== null) break;
-    suffix.unshift(path38.basename(existing));
-    existing = path38.dirname(existing);
+    suffix.unshift(path39.basename(existing));
+    existing = path39.dirname(existing);
   }
   const existingReal = await realpath3(existing).catch(() => existing);
-  const targetReal = suffix.length > 0 ? path38.join(existingReal, ...suffix) : existingReal;
-  const rel = path38.relative(rootReal, targetReal);
+  const targetReal = suffix.length > 0 ? path39.join(existingReal, ...suffix) : existingReal;
+  const rel = path39.relative(rootReal, targetReal);
   if (rel === "") return true;
   if (rel === "..") return false;
-  if (rel.startsWith(`..${path38.sep}`)) return false;
-  if (path38.isAbsolute(rel)) return false;
+  if (rel.startsWith(`..${path39.sep}`)) return false;
+  if (path39.isAbsolute(rel)) return false;
   return true;
 }
 
@@ -30620,21 +30329,8 @@ export {
   getTaxonomyFilePath,
   WearablesService,
   locateTranscriptPath,
-  TIMELINE_RESERVED_UNKNOWN,
-  TIMELINE_RESERVED_IDLE,
-  TIMELINE_RESERVED_PAUSE,
-  DEFAULT_TIMELINE_CATEGORIES,
-  validateTimelineCategories,
-  sortTimelineCategories,
-  classifyTimelineObservation,
-  TIMELINE_FORMAT_VERSION,
-  TIMELINE_MERGE_GAP_MS,
-  TIMELINE_MAX_DWELL_MS,
-  buildTimelineDay,
-  serializeTimelineDay,
-  timelineCorrectionDatabasePath,
-  TimelineCorrectionStore,
-  applyTimelineCorrections,
+  validateTimelineRangeQuery,
+  validateTimelineSearchBounds,
   queryTimelineRange,
   queryTimelineSearch,
   runTimelineCliCommand,
@@ -30646,13 +30342,6 @@ export {
   WEEKLY_SNAPSHOT_DIR,
   weeklySnapshotPath,
   persistWeeklySnapshot,
-  TIMELINE_ANALYSIS_PROMPT_VERSION,
-  TIMELINE_ANALYSIS_BATCH_SIZE,
-  TIMELINE_ANALYSIS_BATCH_OVERLAP,
-  TIMELINE_ANALYSIS_DEFAULT_TIMEOUT_MS,
-  TimelineAnalysisConfigError,
-  buildTimelineAnalysisPrompt,
-  analyzeTimelineCards,
   exportDeterministicRecap,
   renderRecapMarkdown,
   exportDeterministicWeek,
@@ -30663,25 +30352,32 @@ export {
   findRecurringPatterns,
   WEEK_START_DAYS,
   computeWeeklyConfigHash,
-  batchObservations2 as batchObservations,
+  batchObservations,
   boundEvidence,
   buildAnalysisPrompt,
   parseClaimObservationId,
   sortObservationIds,
   clipCardsToRecapWindow,
-  ANALYSIS_FAILURE_KINDS,
-  isAnalysisFailureKind,
-  classifyAnalysisFailure,
   mergeRecapUserEdits,
-  ANALYSIS_METADATA_MAX_FIELD_LENGTH,
-  buildAnalysisRunMetadata,
   RECAP_SOURCE_KINDS,
   selectRecapForDay,
+  stripRemnicOwnedRegions,
   readVaultJournal,
-  VAULT_JOURNAL_PREREQUISITES,
-  checkVaultJournalPrerequisites,
+  publisherOwnedSectionNames,
+  readJournalForDate,
+  timelineStatePath,
+  hashJournalText,
+  readTimelineState,
+  writeTimelineState,
+  journalDateLockPath,
+  timelineStateLockPath,
+  withJournalDateLock,
+  commitJournalHash,
+  setJournalHash,
+  journalUnchanged,
   buildJournalMemoryProvenance,
-  stripRemnicOwnedRegions2 as stripRemnicOwnedRegions,
+  createJournalMemoryWriter,
+  runJournalReviewExtraction,
   isEligibleActivityFact,
   generateActivityMemories,
   MS_PER_DAY2 as MS_PER_DAY,
@@ -30733,4 +30429,4 @@ export {
   blendGraphExpandedRecallScore,
   Orchestrator
 };
-//# sourceMappingURL=chunk-CZYYJZB6.js.map
+//# sourceMappingURL=chunk-ND2O2PVN.js.map