@remnic/core 9.66.0 → 9.66.2

package/dist/{chunk-56IV4J5W.js → chunk-47WWTCJY.js}

@@ -13,7 +13,7 @@ import {
 import {
   ActivityStore,
   MaintenanceScheduler
-} from "./chunk-YXFCALVT.js";
+} from "./chunk-U4HZEW2B.js";
 import {
   runPeerProfileReasoner
 } from "./chunk-I74SUMNI.js";
@@ -22,7 +22,7 @@ import {
 } from "./chunk-7HYPN2GC.js";
 import {
   LcmEngine
-} from "./chunk-Z3YEGSR4.js";
+} from "./chunk-UMZUKOJU.js";
 import {
   chunkTranscriptEntries
 } from "./chunk-TECVW3JP.js";
@@ -32,7 +32,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-OAJMQKQR.js";
+} from "./chunk-EQRD4NMH.js";
 import {
   SharedContextManager
 } from "./chunk-VI637ILW.js";
@@ -44,6 +44,9 @@ import {
   applyUtilityRankingRuntimeDelta,
   loadUtilityRuntimeValues
 } from "./chunk-SEF4IOFE.js";
+import {
+  TmtBuilder
+} from "./chunk-ECZU5BJH.js";
 import {
   extractTopics
 } from "./chunk-KVDUKH5E.js";
@@ -59,9 +62,6 @@ import {
 import {
   decideTierTransition
 } from "./chunk-DD5JFCWM.js";
-import {
-  TmtBuilder
-} from "./chunk-ECZU5BJH.js";
 import {
   HourlySummarizer
 } from "./chunk-IEZ6CGTW.js";
@@ -72,6 +72,14 @@ import {
 import {
   SessionObserverState
 } from "./chunk-ODZKV2F7.js";
+import {
+  applyRuntimeRetrievalPolicy
+} from "./chunk-5IZL4DCV.js";
+import {
+  RerankCache,
+  reorderByRankedKeys,
+  rerankLocalOrNoop
+} from "./chunk-LUDXM7MD.js";
 import {
   buildResponseGuidanceRecallSection,
   shouldRecallResponseGuidance
@@ -97,9 +105,6 @@ import {
   recencyWindowFromPrompt,
   resolvePromptTagPrefilterAsync
 } from "./chunk-ZOKZIR5K.js";
-import {
-  applyRuntimeRetrievalPolicy
-} from "./chunk-5IZL4DCV.js";
 import {
   findUnresolvedEntityRefs
 } from "./chunk-X7XN6YU4.js";
@@ -107,10 +112,8 @@ import {
   RelevanceStore
 } from "./chunk-KATEWTQJ.js";
 import {
-  RerankCache,
-  reorderByRankedKeys,
-  rerankLocalOrNoop
-} from "./chunk-LUDXM7MD.js";
+  applyRecallStateViews
+} from "./chunk-FYDW33ZB.js";
 import {
   dedupeResultsByNamespace,
   hasMemoryForResult,
@@ -138,6 +141,9 @@ import {
 import {
   runLiveConnectorsOnce
 } from "./chunk-HTIIXNJQ.js";
+import {
+  classifyMemoryKind
+} from "./chunk-YAZNBMNF.js";
 import {
   scoreEvidencePathDetail
 } from "./chunk-XXSOVESA.js";
@@ -148,16 +154,13 @@ import {
   normalizedHarmonicEntityIdentity,
   persistHarmonicRecords
 } from "./chunk-MEW53VQJ.js";
-import {
-  classifyMemoryKind
-} from "./chunk-YAZNBMNF.js";
 import {
   buildFocusedListRecallSection,
   shouldRecallFocusedListEvidence
 } from "./chunk-OH7QLI6W.js";
 import {
   ExtractionEngine
-} from "./chunk-XKNHFDTT.js";
+} from "./chunk-3A2Z4OOS.js";
 import {
   parseMemoryActionEligibilityContext
 } from "./chunk-AJTG3CP7.js";
@@ -191,7 +194,7 @@ import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-EZSCW4EM.js";
+} from "./chunk-25OLNWYG.js";
 import {
   planEpisodeWindowsWithFallback
 } from "./chunk-T3GIETKV.js";
@@ -206,31 +209,31 @@ import {
 } from "./chunk-LVXBC6YB.js";
 import {
   refreshConvergedNamespaces
-} from "./chunk-33MFRY25.js";
+} from "./chunk-R2Q6FTOX.js";
 import {
   builtInConnectorPackageSpecifier,
   ensureBuiltInWearableConnectors,
   getWearableConnector,
   listWearableConnectors,
   screenCandidateFact
-} from "./chunk-6QDXA26G.js";
-import {
-  RoutingRulesStore
-} from "./chunk-TBUEE7XF.js";
+} from "./chunk-ZXROBS53.js";
 import {
   normalizeReplaySessionKey
 } from "./chunk-AJVLDJU6.js";
+import {
+  RoutingRulesStore
+} from "./chunk-TBUEE7XF.js";
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-ZJPM7GZ3.js";
+} from "./chunk-OIDICRH7.js";
 import {
   ThreadingManager
 } from "./chunk-OJP3N7UK.js";
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-I5VB44ZK.js";
+} from "./chunk-BLHKR4GJ.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-NRLELHAY.js";
@@ -243,17 +246,17 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-2LBAFHOQ.js";
+} from "./chunk-2QSGJTDG.js";
 import {
   planNamespaceMaintenance
-} from "./chunk-72OIT7KS.js";
+} from "./chunk-UVYL5G7A.js";
+import {
+  searchHarmonicRetrieval
+} from "./chunk-ZBIEX4XN.js";
 import {
   isAboveImportanceThreshold,
   scoreImportance
 } from "./chunk-UOBPK2OS.js";
-import {
-  searchHarmonicRetrieval
-} from "./chunk-VQ4AMTGZ.js";
 import {
   EXTRACTION_JUDGE_VERDICT_CATEGORY,
   recordJudgeVerdict
@@ -281,7 +284,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-CN4VKV3S.js";
+} from "./chunk-RH3XLQG4.js";
 import {
   semanticChunkContent
 } from "./chunk-2GBFKHBZ.js";
@@ -290,7 +293,7 @@ import {
 } from "./chunk-6TBIWIAG.js";
 import {
   SmartBuffer
-} from "./chunk-NACLNNFQ.js";
+} from "./chunk-KSZKQTZS.js";
 import {
   buildRecallQueryPolicy
 } from "./chunk-C6WMSXCJ.js";
@@ -311,8 +314,10 @@ import {
   evaluateMemoryActionPolicy
 } from "./chunk-MI2OTWV5.js";
 import {
-  detectMeetings
-} from "./chunk-PEBH5DCK.js";
+  applyNoveltyGate,
+  detectMeetings,
+  embeddingsFromCosineHits
+} from "./chunk-EH7BNIUN.js";
 import {
   compileCorrectionRule,
   correctionsFilePath,
@@ -325,14 +330,14 @@ import {
 } from "./chunk-QW27DOHG.js";
 import {
   MeetingsInputError
-} from "./chunk-KXIXO76C.js";
+} from "./chunk-JMXHVJ2V.js";
 import {
   WearablesInputError,
   describeErrorForOperator
 } from "./chunk-V7IZKJI3.js";
 import {
   NamespaceCatalog
-} from "./chunk-GX6FTSYH.js";
+} from "./chunk-PRRUK2ZH.js";
 import {
   recordDreamsPhaseRun
 } from "./chunk-EQWEIIKQ.js";
@@ -348,14 +353,20 @@ import {
   detectPassiveCorrections,
   filterRecallCandidates,
   isGenericRecallExcludedPath,
-  isTopLevelArchivePath
-} from "./chunk-IHGMRDEE.js";
+  isTopLevelArchivePath,
+  journalPath,
+  writeJournalFile
+} from "./chunk-B4B3QDV3.js";
 import {
   importCapsule
-} from "./chunk-CTCGHNWN.js";
+} from "./chunk-J2R275FN.js";
 import {
   isCodingGraphInstalled
 } from "./chunk-VQ7B2Q6M.js";
+import {
+  listTrustZoneRecords,
+  searchTrustZoneRecords
+} from "./chunk-5QZR2RA3.js";
 import {
   applyTrustScoreStage,
   buildTrustSignalsForRerank,
@@ -363,10 +374,6 @@ import {
   trustResultFor,
   trustResultKey
 } from "./chunk-GNVZQ5JN.js";
-import {
-  listTrustZoneRecords,
-  searchTrustZoneRecords
-} from "./chunk-5QZR2RA3.js";
 import {
   LastRecallStore,
   RecallHandleHistoryStore,
@@ -375,7 +382,7 @@ import {
 } from "./chunk-ZVZHG7AI.js";
 import {
   buildXraySnapshot
-} from "./chunk-NPIBN2VL.js";
+} from "./chunk-LK4TOYPU.js";
 import {
   objectiveStateStoreOverrideForNamespace,
   searchObjectiveStateSnapshots
@@ -403,10 +410,10 @@ import {
 } from "./chunk-7ZNJN5WZ.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-HJXA6ZM7.js";
+} from "./chunk-6545JDIM.js";
 import {
   GraphIndex
-} from "./chunk-YMOPYG3K.js";
+} from "./chunk-BIJAWZYW.js";
 import {
   BulkImportBatchPartialFailureError,
   COMPACTION_SIGNAL_MAX_AGE_MS,
@@ -447,7 +454,7 @@ import {
   throwIfRecallAborted,
   tokenizeRecallQuery,
   utcDateKeysForLocalDay
-} from "./chunk-RDGKVH6T.js";
+} from "./chunk-4NKIGSJM.js";
 import {
   inferIntentFromText,
   intentCompatibilityScore,
@@ -460,7 +467,7 @@ import {
 } from "./chunk-TBBDFYXW.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-FESUGFIL.js";
+} from "./chunk-WKWY7YF3.js";
 import {
   QmdResultResolver,
   StorageManager,
@@ -479,7 +486,7 @@ import {
   reconstructFusionInputs,
   selfDeps,
   serializeFusionDay
-} from "./chunk-GEJKYA7D.js";
+} from "./chunk-DSEHPUID.js";
 import {
   bodyIsEscaped,
   decodeTranscriptBody,
@@ -496,12 +503,12 @@ import {
 import {
   NamespaceSearchRouter,
   namespaceCollectionName
-} from "./chunk-FYWLSFFS.js";
+} from "./chunk-OERZXNSK.js";
 import {
   createConversationIndexRuntime,
   createSearchBackend,
   isSearchBackendEnabled
-} from "./chunk-HNPE66LB.js";
+} from "./chunk-6BYJQ3L2.js";
 import {
   NoopSearchBackend
 } from "./chunk-CYEPCZN5.js";
@@ -515,7 +522,7 @@ import {
 } from "./chunk-S2V7RUCL.js";
 import {
   confidenceTier
-} from "./chunk-MINHJ55X.js";
+} from "./chunk-XXW32OL7.js";
 import {
   lintWorkspaceFiles,
   rotateMarkdownFileToArchive
@@ -577,6 +584,9 @@ import {
   fallbackLlmRuntimeContextFromConfig,
   gatewayTaskChainOptions
 } from "./chunk-JALOAKSZ.js";
+import {
+  extractJsonCandidates
+} from "./chunk-RGMVMVMF.js";
 import {
   estimateTokenCount
 } from "./chunk-TOTT6S2V.js";
@@ -588,12 +598,14 @@ import {
 } from "./chunk-QDW3E4RD.js";
 import {
   activityDayWindow,
+  assertValidTimezone,
+  hashActivityBody,
   isValidActivityDate,
   timezoneOffsetIso
 } from "./chunk-M6L7HI7R.js";
 import {
   searchCausalTrajectories
-} from "./chunk-GPFZFCRN.js";
+} from "./chunk-PP7R754B.js";
 import {
   evaluateSubjectGuard,
   isSharedPromotionTarget,
@@ -606,7 +618,9 @@ import {
   normalizeRecallTokenSet
 } from "./chunk-YCVB7X56.js";
 import {
-  coerceBool
+  coerceBool,
+  coerceBooleanLike,
+  coerceNumber
 } from "./chunk-PQVCH2AE.js";
 import {
   graphemeUnits,
@@ -673,6 +687,9 @@ import {
   assertIsDirectoryNotSymlink,
   assertRealpathInsideRoot
 } from "./chunk-GCGJW34D.js";
+import {
+  parseFlexibleIsoTimestamp
+} from "./chunk-P7FMDTKL.js";
 import {
   canReadNamespace,
   defaultNamespaceForPrincipal,
@@ -2306,7 +2323,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
       namespaces,
       {
         readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
-        readMemoryFrontmatter: async (path35, preferredNamespace) => {
+        readMemoryFrontmatter: async (path38, preferredNamespace) => {
           if (!fallbackReader) {
             for (const ns of namespaces) {
               try {
@@ -2318,7 +2335,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
           }
           if (!fallbackReader) return null;
           const memory = await this.readQmdResultMemory(
-            path35,
+            path38,
             fallbackReader,
             namespaces,
             preferredNamespace
@@ -6072,8 +6089,23 @@ var ExtractionPersistCoordinator = class {
       );
       const requireSpansPendingStatus = this.deps.config.provenance?.requireSpans === true && fact.requireSpansPending === true ? "pending_review" : void 0;
       const faithfulnessEnforceStatus = faithfulnessGateStatus ?? requireSpansPendingStatus ?? injectionScreenStatus;
+      const novelty = await applyNoveltyGate({
+        enabled: this.deps.config["noveltyGateEnabled"] === true,
+        addThreshold: this.deps.config.noveltyAddThreshold,
+        noopThreshold: this.deps.config.noveltyNoopThreshold,
+        lookup: async () => embeddingsFromCosineHits(
+          await this.deps.semanticDedupLookup(
+            fact.content,
+            this.deps.config.semanticDedupCandidates,
+            targetStorage
+          ),
+          // Same connector scoping as decideSemanticDedup below: a
+          // cross-connector neighbor must not noop this candidate.
+          { candidateConnector: sourceContext?.sourceConnector }
+        )
+      });
       let pendingSemanticSkip = null;
-      if (resolvePipelineProcessingCapabilities(this.deps.config).semanticDedup && injectionScreenStatus !== "pending_review") {
+      if (novelty.decision !== "add" && resolvePipelineProcessingCapabilities(this.deps.config).semanticDedup && injectionScreenStatus !== "pending_review") {
         let semanticDecision;
         if (batchBackendUnavailable) {
           semanticDecision = { action: "keep", reason: "backend_unavailable" };
@@ -6149,11 +6181,11 @@ var ExtractionPersistCoordinator = class {
         }
       }
       const isCorrection = writeCategory === "correction";
-      if (pendingSemanticSkip && !contradictionDetected && !isCorrection && faithfulnessEnforceStatus !== "pending_review") {
+      if ((pendingSemanticSkip || novelty.decision === "noop") && !contradictionDetected && !isCorrection && faithfulnessEnforceStatus !== "pending_review") {
         log.debug(
-          `dedup: skipping semantic near-duplicate fact "${fact.content.slice(0, 60).replace(/\s+/g, " ")}\u2026" score=${pendingSemanticSkip.topScore.toFixed(
+          `dedup: skipping ${pendingSemanticSkip ? "semantic near-duplicate" : "novelty-noop"} fact "${fact.content.slice(0, 60).replace(/\s+/g, " ")}\u2026" score=${(pendingSemanticSkip?.topScore ?? novelty.score).toFixed(
             3
-          )} neighbor=${pendingSemanticSkip.topId}`
+          )} neighbor=${pendingSemanticSkip?.topId ?? novelty.neighborId}`
         );
         dedupedCount++;
         continue;
@@ -17058,8 +17090,8 @@ function fuseMeeting(input, config, options = {}) {
   }
   const clipped = [];
   for (const conv of input.conversations) {
-    const clip = clipConversation(conv, windowStartMs, windowEndMs);
-    if (clip !== null) clipped.push(clip);
+    const clip2 = clipConversation(conv, windowStartMs, windowEndMs);
+    if (clip2 !== null) clipped.push(clip2);
   }
   const fused = clipped.length > 0 ? fuseCluster(clipped, {
     ...options.sourceTrust !== void 0 ? { sourceTrust: options.sourceTrust } : {},
@@ -18959,14 +18991,14 @@ var NamespaceReadFanoutCoordinator = class {
     for (const { memory, namespace } of memories) {
       const status = memory.frontmatter.status ?? "active";
       if (!options?.allowArchived && status !== "active") continue;
-      const haystack = [
+      const haystack2 = [
         memory.content,
         memory.frontmatter.category,
         ...memory.frontmatter.tags ?? []
       ].join(" ").toLowerCase();
       let hits = 0;
       for (const token of tokens) {
-        if (haystack.includes(token)) hits += 1;
+        if (haystack2.includes(token)) hits += 1;
       }
       const score = tokens.length > 0 ? hits / tokens.length : 0.01;
       if (tokens.length > 0 && hits === 0) continue;
@@ -19182,7 +19214,11 @@ var RecallEntryCoordinator = class {
   publishRecallResults(options) {
     const sectionId = "memories";
     const trustByPath = options.trustByPath ?? null;
-    const injectable = trustByPath ? options.results.filter((r) => !trustResultFor(trustByPath, r)?.quarantined) : options.results;
+    const injectable = applyRecallStateViews(
+      trustByPath ? options.results.filter((r) => !trustResultFor(trustByPath, r)?.quarantined) : options.results,
+      options.retrievalQuery,
+      this.deps.config
+    );
     if (injectable.length === 0) return;
     const formatted = this.deps.recallResultFormatter.formatQmdResultEntries(
       options.title,
@@ -22301,9 +22337,9 @@ function readStructuralSymbol(entry) {
   const rec = entry;
   const symbol = typeof rec.symbol === "string" ? rec.symbol.trim() : "";
   if (!symbol) return null;
-  const path35 = typeof rec.path === "string" && rec.path.length > 0 ? rec.path : void 0;
+  const path38 = 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 = path35 !== void 0 && kind !== void 0 ? { symbol, path: path35, kind } : path35 !== void 0 ? { symbol, path: path35 } : kind !== void 0 ? { symbol, kind } : { symbol };
+  const item = path38 !== void 0 && kind !== void 0 ? { symbol, path: path38, kind } : path38 !== void 0 ? { symbol, path: path38 } : kind !== void 0 ? { symbol, kind } : { symbol };
   return item;
 }
 function classifySpawnError(err) {
@@ -26299,6 +26335,1000 @@ function applyTimelineCorrections(cards, corrections) {
   });
 }
 
+// src/activity/timeline/query.ts
+var RANGE_FORMATS = ["cards", "compact"];
+var MS_PER_DAY = 864e5;
+var DEFAULT_MAX_RANGE_DAYS = 31;
+var DEFAULT_SEARCH_LIMIT = 10;
+var MIN_SEARCH_LIMIT = 1;
+var MAX_SEARCH_LIMIT = 50;
+var USAGE = `Usage: timeline <command> [options]
+
+Commands:
+  range --from <ISO> --to <ISO> [--format cards|compact] [--categories id,id] [--include-distractions]
+  search --query <text> [--from <ISO>] [--to <ISO>] [--limit N]
+`;
+var VALUE_FLAGS = {
+  "--from": true,
+  "--to": true,
+  "--format": true,
+  "--categories": true,
+  "--query": true,
+  "--limit": true
+};
+var BOOLEAN_FLAGS = { "--include-distractions": true };
+function parseInstant(value, label) {
+  const ms = parseFlexibleIsoTimestamp(value);
+  if (ms === null) {
+    throw new TypeError(`${label} must be an ISO date or datetime`);
+  }
+  return ms;
+}
+function assertRange(fromMs, toMs, maxRangeDays) {
+  if (fromMs > toMs) {
+    throw new RangeError("reversed range: from must be <= to");
+  }
+  if (fromMs === toMs) return;
+  if (toMs - fromMs > maxRangeDays * MS_PER_DAY) {
+    throw new RangeError(`range exceeds timeline.qa.maxRangeDays (${maxRangeDays})`);
+  }
+}
+function cardOverlaps(card, fromMs, toMs) {
+  const start = Date.parse(card.startUtc);
+  const end = Date.parse(card.endUtc);
+  if (fromMs === toMs) return start <= fromMs && fromMs < end;
+  return start < toMs && end > fromMs;
+}
+function passesFilters(card, categories, includeDistractions) {
+  if (!includeDistractions && card.distraction === true) return false;
+  if (categories && !categories.has(card.categoryId)) return false;
+  return true;
+}
+function filterRange(cards, fromMs, toMs, categories, includeDistractions) {
+  return cards.filter(
+    (card) => cardOverlaps(card, fromMs, toMs) && passesFilters(card, categories, includeDistractions)
+  );
+}
+function toCompact(cards, from) {
+  const day = from.length >= 10 ? from.slice(0, 10) : cards[0]?.dayKey ?? from;
+  return {
+    day,
+    cards: cards.map((card) => ({
+      start: card.startUtc,
+      end: card.endUtc,
+      category: card.categoryId,
+      title: card.title,
+      summary: card.summary
+    }))
+  };
+}
+function queryTimelineRange(cards, 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;
+  const fromMs = parseInstant(query.from, "from");
+  const toMs = parseInstant(query.to, "to");
+  assertRange(fromMs, toMs, maxRangeDays);
+  const categories = query.categories ? new Set(query.categories) : void 0;
+  const matched = filterRange(cards, fromMs, toMs, categories, query.includeDistractions === true);
+  if (query.format === "compact") return toCompact(matched, query.from);
+  return matched;
+}
+function haystack(card) {
+  const parts = [card.title, card.summary];
+  if (card.detailedSummary) parts.push(card.detailedSummary);
+  return parts.join(" ").toLowerCase();
+}
+function tokenMatchCount(card, tokens) {
+  const text = haystack(card);
+  let count = 0;
+  for (const token of tokens) {
+    if (text.includes(token)) count += 1;
+  }
+  return count;
+}
+function queryTimelineSearch(cards, query) {
+  if (!Array.isArray(cards)) return { ok: false, error: "store_unreadable" };
+  const tokens = query.query.trim().toLowerCase().split(/\s+/).filter(Boolean);
+  const limit = query.limit ?? DEFAULT_SEARCH_LIMIT;
+  if (!Number.isInteger(limit) || limit < MIN_SEARCH_LIMIT || limit > MAX_SEARCH_LIMIT) {
+    throw new RangeError(`limit must be an integer from ${MIN_SEARCH_LIMIT} to ${MAX_SEARCH_LIMIT}`);
+  }
+  let pool = cards;
+  if (query.from !== void 0 || query.to !== void 0) {
+    const fromMs = parseInstant(query.from ?? query.to, "from");
+    const toMs = parseInstant(query.to ?? query.from, "to");
+    assertRange(fromMs, toMs, DEFAULT_MAX_RANGE_DAYS);
+    pool = filterRange(cards, fromMs, toMs, void 0, true);
+  }
+  if (tokens.length === 0) return { ok: true, results: [] };
+  const ranked = pool.map((card) => ({ card, matches: tokenMatchCount(card, tokens) })).filter((row) => row.matches > 0).sort((a, b) => {
+    if (a.matches !== b.matches) return b.matches - a.matches;
+    const recency = Date.parse(b.card.endUtc) - Date.parse(a.card.endUtc);
+    if (recency !== 0) return recency;
+    return a.card.id < b.card.id ? -1 : a.card.id > b.card.id ? 1 : 0;
+  }).slice(0, limit).map((row) => row.card);
+  return { ok: true, results: ranked };
+}
+function parseFlags(args) {
+  const flags = /* @__PURE__ */ new Map();
+  const positional = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg.startsWith("--")) {
+      positional.push(arg);
+      continue;
+    }
+    if (VALUE_FLAGS[arg] === true) {
+      const value = args[i + 1];
+      if (value === void 0 || value.startsWith("--")) {
+        throw new TypeError(`flag ${arg} requires a value`);
+      }
+      flags.set(arg, value);
+      i += 1;
+      continue;
+    }
+    if (BOOLEAN_FLAGS[arg] === true) {
+      flags.set(arg, true);
+      continue;
+    }
+    const known = [...Object.keys(VALUE_FLAGS), ...Object.keys(BOOLEAN_FLAGS)].sort().join(", ");
+    throw new TypeError(`unknown flag ${arg} (valid: ${known})`);
+  }
+  return { flags, positional };
+}
+function flagString(flags, name) {
+  const value = flags.get(name);
+  return typeof value === "string" ? value : void 0;
+}
+async function runTimelineCliCommand(deps, args, io) {
+  const [command, ...rest] = args;
+  try {
+    if (command === void 0 || command === "help" || command === "--help") {
+      io.stdout.write(USAGE);
+      return command === void 0 ? 1 : 0;
+    }
+    if (deps.timelineEnabled === false || !deps.qa.enabled) {
+      io.stderr.write("timeline qa disabled \u2014 set activity.timeline.qa.enabled=true\n");
+      return 1;
+    }
+    const { flags } = parseFlags(rest);
+    if (command === "range") {
+      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");
+      }
+      const categoriesRaw = flagString(flags, "--categories");
+      const result = queryTimelineRange(deps.cards, {
+        from,
+        to,
+        format: formatRaw,
+        categories: categoriesRaw ? categoriesRaw.split(",").filter(Boolean) : void 0,
+        includeDistractions: flags.get("--include-distractions") === true,
+        maxRangeDays: deps.qa.maxRangeDays
+      });
+      io.stdout.write(`${JSON.stringify(result)}
+`);
+      return 0;
+    }
+    if (command === "search") {
+      const q = flagString(flags, "--query");
+      if (q === void 0) throw new TypeError("search requires --query");
+      const limitRaw = flagString(flags, "--limit");
+      const limit = limitRaw === void 0 ? void 0 : Number(limitRaw);
+      if (limitRaw !== void 0 && !Number.isInteger(limit)) {
+        throw new RangeError("limit must be an integer from 1 to 50");
+      }
+      const result = queryTimelineSearch(deps.cards, {
+        query: q,
+        from: flagString(flags, "--from"),
+        to: flagString(flags, "--to"),
+        limit
+      });
+      io.stdout.write(`${JSON.stringify(result)}
+`);
+      return result.ok ? 0 : 1;
+    }
+    throw new TypeError(`unknown command ${command} (valid: range, search)`);
+  } catch (err) {
+    io.stderr.write(`${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  }
+}
+
+// src/activity/timeline/journal-recap.ts
+function formatMinutes(ms) {
+  return `${Math.round(ms / 6e4)}m`;
+}
+function clipToWindow(cards, winStart, winEnd) {
+  const clipped = [];
+  for (const card of cards) {
+    const start = Date.parse(card.startUtc);
+    const end = Date.parse(card.endUtc);
+    if (!Number.isFinite(start) || !Number.isFinite(end)) continue;
+    const startMs = Math.max(start, winStart);
+    const endMs = Math.min(end, winEnd);
+    if (endMs <= startMs) continue;
+    clipped.push({ card, startMs, endMs, durationMs: endMs - startMs });
+  }
+  clipped.sort((left, right) => {
+    const byStart = left.startMs - right.startMs;
+    if (byStart !== 0) return byStart;
+    const byTitle = left.card.title.localeCompare(right.card.title);
+    if (byTitle !== 0) return byTitle;
+    return left.card.id.localeCompare(right.card.id);
+  });
+  return clipped;
+}
+function categoryLines(clipped) {
+  const totals = /* @__PURE__ */ new Map();
+  for (const row of clipped) {
+    totals.set(row.card.categoryId, (totals.get(row.card.categoryId) ?? 0) + row.durationMs);
+  }
+  const rows = [...totals.entries()].sort((left, right) => {
+    const byDuration = right[1] - left[1];
+    return byDuration !== 0 ? byDuration : left[0].localeCompare(right[0]);
+  });
+  if (rows.length === 0) return ["_No categories._"];
+  return rows.map(([categoryId, durationMs]) => `- ${formatMinutes(durationMs)} ${categoryId}`);
+}
+function mergeIntervals(intervals) {
+  const ordered = [...intervals].sort((left, right) => left[0] - right[0] || left[1] - right[1]);
+  const merged = [];
+  for (const [start, end] of ordered) {
+    const last = merged[merged.length - 1];
+    if (!last || start > last[1]) merged.push([start, end]);
+    else last[1] = Math.max(last[1], end);
+  }
+  return merged;
+}
+function countGaps(winStart, winEnd, intervals) {
+  const merged = mergeIntervals(intervals);
+  let gaps = 0;
+  let cursor = winStart;
+  for (const [start, end] of merged) {
+    if (start > cursor) gaps += 1;
+    cursor = Math.max(cursor, end);
+  }
+  if (cursor < winEnd) gaps += 1;
+  return gaps;
+}
+function renderDeterministicJournal(cards, options) {
+  const window = activityDayWindow(options.date, options.timezone);
+  const winStart = Date.parse(window.startUtc);
+  const winEnd = Date.parse(window.endUtc);
+  const clipped = clipToWindow(cards, winStart, winEnd);
+  const idle = clipped.filter((row) => row.card.kind === "idle").length;
+  const pause = clipped.filter((row) => row.card.kind === "pause").length;
+  const gaps = countGaps(
+    winStart,
+    winEnd,
+    clipped.map((row) => [row.startMs, row.endMs])
+  );
+  const cardLines = clipped.length === 0 ? ["_No cards._"] : clipped.map((row) => `- ${formatMinutes(row.durationMs)} ${row.card.title}`);
+  return [
+    `# Journal \u2014 ${options.date} (${options.timezone})`,
+    "",
+    "## Categories",
+    "",
+    ...categoryLines(clipped),
+    "",
+    "## Cards",
+    "",
+    ...cardLines,
+    "",
+    "## Gaps / idle / pause",
+    "",
+    `- Gaps: ${gaps}`,
+    `- Idle: ${idle}`,
+    `- Pause: ${pause}`,
+    ""
+  ].join("\n");
+}
+
+// src/activity/timeline/journal-recap-persist.ts
+function persistDeterministicJournal(input) {
+  const filePath = journalPath(input.memoryDir, input.date);
+  const wrote = writeJournalFile(
+    filePath,
+    renderDeterministicJournal(input.cards, {
+      date: input.date,
+      timezone: input.timezone
+    }),
+    input.force === true
+  );
+  return { path: filePath, wrote };
+}
+
+// src/activity/timeline/weekly.ts
+var WEEKLY_ACTIVITY_FORMAT_VERSION = 1;
+function parseBound(value, label) {
+  const ms = parseFlexibleIsoTimestamp(value);
+  if (ms === null) {
+    throw new RangeError(`${label} is not a valid ISO timestamp`);
+  }
+  return ms;
+}
+function clip(start, end, winStart, winEnd) {
+  const clippedStart = Math.max(start, winStart);
+  const clippedEnd = Math.min(end, winEnd);
+  return clippedEnd > clippedStart ? [clippedStart, clippedEnd] : null;
+}
+function unionDuration(intervals) {
+  const sorted = [...intervals].sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  let total = 0;
+  let curStart = Number.NaN;
+  let curEnd = Number.NaN;
+  for (const [start, end] of sorted) {
+    if (!Number.isFinite(curStart)) {
+      curStart = start;
+      curEnd = end;
+      continue;
+    }
+    if (start <= curEnd) {
+      curEnd = Math.max(curEnd, end);
+      continue;
+    }
+    total += curEnd - curStart;
+    curStart = start;
+    curEnd = end;
+  }
+  if (Number.isFinite(curStart)) total += curEnd - curStart;
+  return total;
+}
+function localDateOf(ms, timezone) {
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone: timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(new Date(ms));
+  const get = (type) => parts.find((part) => part.type === type)?.value ?? "";
+  return `${get("year")}-${get("month")}-${get("day")}`;
+}
+function shiftIsoDate(date, days) {
+  const parsed = /* @__PURE__ */ new Date(`${date}T00:00:00Z`);
+  parsed.setUTCDate(parsed.getUTCDate() + days);
+  return parsed.toISOString().slice(0, 10);
+}
+function daysOverlappingWeek(weekStartMs, weekEndMs, timezone) {
+  if (weekEndMs <= weekStartMs) return [];
+  let date = localDateOf(weekStartMs, timezone);
+  let window = activityDayWindow(date, timezone);
+  if (Date.parse(window.startUtc) > weekStartMs) {
+    date = shiftIsoDate(date, -1);
+    window = activityDayWindow(date, timezone);
+  }
+  const days = [];
+  while (Date.parse(window.startUtc) < weekEndMs) {
+    const startMs = Math.max(Date.parse(window.startUtc), weekStartMs);
+    const endMs = Math.min(Date.parse(window.endUtc), weekEndMs);
+    if (endMs > startMs) days.push({ date, startMs, endMs });
+    date = shiftIsoDate(date, 1);
+    window = activityDayWindow(date, timezone);
+  }
+  return days;
+}
+function emptyAcc(categoryIds) {
+  return {
+    activeMs: 0,
+    idleMs: 0,
+    pauseMs: 0,
+    gapMs: 0,
+    unclassifiedMs: 0,
+    byCategory: new Map(categoryIds.map((id) => [id, 0])),
+    intervals: []
+  };
+}
+function addClipped(acc, kind, categoryId, known, start, end) {
+  const duration = end - start;
+  acc.intervals.push([start, end]);
+  if (kind === "idle") acc.idleMs += duration;
+  else if (kind === "pause") acc.pauseMs += duration;
+  else acc.activeMs += duration;
+  if (known.has(categoryId)) {
+    acc.byCategory.set(categoryId, (acc.byCategory.get(categoryId) ?? 0) + duration);
+  } else {
+    acc.unclassifiedMs += duration;
+  }
+}
+function sortCategoryTotals(byCategory) {
+  return [...byCategory.entries()].map(([categoryId, durationMs]) => ({ categoryId, durationMs })).sort((a, b) => b.durationMs - a.durationMs || (a.categoryId < b.categoryId ? -1 : a.categoryId > b.categoryId ? 1 : 0));
+}
+function finish(acc, windowMs) {
+  const covered = unionDuration(acc.intervals);
+  return {
+    activeMs: acc.activeMs,
+    idleMs: acc.idleMs,
+    pauseMs: acc.pauseMs,
+    gapMs: Math.max(0, windowMs - covered),
+    unclassifiedMs: acc.unclassifiedMs,
+    categories: sortCategoryTotals(acc.byCategory)
+  };
+}
+function buildWeeklyActivitySummary(cards, options) {
+  assertValidTimezone(options.timezone);
+  const weekStartMs = parseBound(options.weekStartUtc, "weekStartUtc");
+  const weekEndMs = parseBound(options.weekEndUtc, "weekEndUtc");
+  if (weekStartMs > weekEndMs) {
+    throw new RangeError("reversed range: weekStartUtc must be <= weekEndUtc");
+  }
+  const categoryIds = options.categories.map((category) => category.id);
+  const known = new Set(categoryIds);
+  const week = emptyAcc(categoryIds);
+  const dayWindows = daysOverlappingWeek(weekStartMs, weekEndMs, options.timezone);
+  const dayAccs = dayWindows.map(() => emptyAcc(categoryIds));
+  for (const card of cards) {
+    const start = Date.parse(card.startUtc);
+    const end = Date.parse(card.endUtc);
+    if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start) continue;
+    const weekClip = clip(start, end, weekStartMs, weekEndMs);
+    if (!weekClip) continue;
+    addClipped(week, card.kind, card.categoryId, known, weekClip[0], weekClip[1]);
+    for (let i = 0; i < dayWindows.length; i++) {
+      const day = dayWindows[i];
+      const dayClip = clip(start, end, day.startMs, day.endMs);
+      if (dayClip) addClipped(dayAccs[i], card.kind, card.categoryId, known, dayClip[0], dayClip[1]);
+    }
+  }
+  const weekTotals = finish(week, weekEndMs - weekStartMs);
+  const days = dayWindows.map((day, i) => {
+    const totals = finish(dayAccs[i], day.endMs - day.startMs);
+    return {
+      date: day.date,
+      startUtc: new Date(day.startMs).toISOString(),
+      endUtc: new Date(day.endMs).toISOString(),
+      ...totals
+    };
+  });
+  return {
+    formatVersion: WEEKLY_ACTIVITY_FORMAT_VERSION,
+    timezone: options.timezone,
+    weekStartUtc: new Date(weekStartMs).toISOString(),
+    weekEndUtc: new Date(weekEndMs).toISOString(),
+    ...weekTotals,
+    days,
+    previousPeriod: { available: false }
+  };
+}
+
+// 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 path33 from "path";
+var WEEKLY_SNAPSHOT_FORMAT_VERSION = 1;
+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`);
+  }
+  return value.trim();
+}
+function weeklySnapshotPath(input) {
+  const memoryDir = requireToken(input.memoryDir, "memoryDir");
+  const namespace = requireToken(input.namespace, "namespace");
+  const sourceRevision = requireToken(input.sourceRevision, "sourceRevision");
+  const configHash = requireToken(input.configHash, "configHash");
+  const weekStartUtc = input.summary?.weekStartUtc;
+  if (typeof weekStartUtc !== "string") {
+    throw new TypeError("summary.weekStartUtc must be an ISO timestamp");
+  }
+  const weekDate = weekStartUtc.slice(0, 10);
+  if (!isValidActivityDate(weekDate)) {
+    throw new RangeError("summary.weekStartUtc must be an ISO timestamp");
+  }
+  const identity = hashActivityBody(
+    `${input.summary.weekStartUtc}\0${input.summary.weekEndUtc}\0${sourceRevision}\0${configHash}`
+  );
+  return path33.join(
+    path33.resolve(memoryDir),
+    WEEKLY_SNAPSHOT_DIR,
+    namespaceIdentityToken(namespace),
+    `${weekDate}--${identity}.json`
+  );
+}
+function persistWeeklySnapshot(input) {
+  const namespace = requireToken(input.namespace, "namespace");
+  const sourceRevision = requireToken(input.sourceRevision, "sourceRevision");
+  const configHash = requireToken(input.configHash, "configHash");
+  const filePath = weeklySnapshotPath(input);
+  const payload = {
+    formatVersion: WEEKLY_SNAPSHOT_FORMAT_VERSION,
+    namespace,
+    sourceRevision,
+    configHash,
+    summary: input.summary
+  };
+  const contentHash = hashActivityBody(JSON.stringify(payload));
+  const text = `${JSON.stringify({ ...payload, contentHash })}
+`;
+  try {
+    if (readFileSync2(filePath, "utf8") === text) {
+      return { path: filePath, written: false };
+    }
+  } catch (error) {
+    if (!(typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT")) {
+      throw error;
+    }
+  }
+  mkdirSync2(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 {
+    renameSync(tmpPath, filePath);
+  } catch (error) {
+    try {
+      unlinkSync(tmpPath);
+    } catch {
+    }
+    throw error;
+  }
+  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/analysis-batch.ts
+function compareObservations(a, b) {
+  const time = Date.parse(a.capturedAtUtc) - Date.parse(b.capturedAtUtc);
+  if (time !== 0) return time;
+  return a.id - b.id;
+}
+function batchObservations2(observations, options) {
+  const { maxBatch, overlap } = options;
+  if (!Number.isInteger(overlap) || overlap < 0) {
+    throw new RangeError("overlap must be a non-negative integer");
+  }
+  if (maxBatch === 0) return [];
+  if (!Number.isInteger(maxBatch) || maxBatch < 1) {
+    throw new RangeError("maxBatch must be 0 or a positive integer");
+  }
+  if (overlap >= maxBatch) {
+    throw new RangeError("overlap must be less than maxBatch");
+  }
+  if (observations.length === 0) return [];
+  const ordered = [...observations].sort(compareObservations);
+  const step = maxBatch - overlap;
+  const batches = [];
+  for (let start = 0; start < ordered.length; start += step) {
+    batches.push(ordered.slice(start, start + maxBatch));
+    if (start + maxBatch >= ordered.length) break;
+  }
+  return batches;
+}
+
+// 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/memory-gen.ts
 var ACTIVITY_ALLOWED_CATEGORIES = {
   decision: true,
@@ -26555,10 +27585,237 @@ async function generateActivityMemories(date, digestBody, config, deps) {
   return result;
 }
 
+// src/activity/privacy.ts
+var MS_PER_DAY2 = 864e5;
+function asRecord(value, name) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TypeError(`${name} must be an object`);
+  }
+  return value;
+}
+function parseGate(value, key, fallback) {
+  if (value === void 0) return fallback;
+  const parsed = coerceBooleanLike(value, key);
+  if (parsed === void 0) throw new TypeError(`${key} must be a boolean`);
+  return parsed;
+}
+function parseActivityPrivacy(raw) {
+  if (raw === void 0 || raw === null) {
+    return { enabled: false, retentionDays: 0, exportIncludeObservations: false };
+  }
+  const config = asRecord(raw, "activity");
+  const enabled = parseGate(config.enabled, "activity.enabled", false);
+  let retentionDays = 0;
+  if (config.retentionDays !== void 0) {
+    const parsed = coerceNumber(config.retentionDays, "activity.retentionDays");
+    if (parsed === void 0 || !Number.isInteger(parsed) || parsed < 0) {
+      throw new RangeError("activity.retentionDays must be a non-negative integer");
+    }
+    retentionDays = parsed;
+  }
+  const exportIncludeObservations = parseGate(
+    config.exportIncludeObservations,
+    "activity.exportIncludeObservations",
+    false
+  );
+  return { enabled, retentionDays, exportIncludeObservations };
+}
+function shouldRetain(capturedAtMs, nowMs, retentionDays, enabled = true) {
+  if (!enabled) return false;
+  if (retentionDays < 0 || !Number.isInteger(retentionDays)) {
+    throw new RangeError("activity.retentionDays must be a non-negative integer");
+  }
+  if (retentionDays === 0) return true;
+  return nowMs - capturedAtMs < retentionDays * MS_PER_DAY2;
+}
+function observationsForExport(observations, policy) {
+  if (!policy.enabled || !policy.exportIncludeObservations) return [];
+  return observations;
+}
+
+// src/activity/vault-path.ts
+import path34 from "path";
+var TOKEN_RE = /\{yyyy\}|\{yy\}|\{MM\}|\{dd\}|\{M\}|\{d\}|\{ww\}/g;
+function resolveVaultNotePath(template, date, options) {
+  if (!isValidActivityDate(date)) {
+    throw new RangeError(`Invalid vault date "${date}"; expected YYYY-MM-DD.`);
+  }
+  if (options?.timezone !== void 0) {
+    assertValidTimezone(options.timezone);
+  }
+  if (typeof template !== "string" || template.length === 0) {
+    throw new RangeError("Vault note path template must be a non-empty relative path.");
+  }
+  if (path34.posix.isAbsolute(template) || path34.win32.isAbsolute(template)) {
+    throw new RangeError("Vault note path template must be relative; absolute templates are rejected.");
+  }
+  const [yyyy, mm, dd] = date.split("-");
+  const tokens = {
+    "{yyyy}": yyyy,
+    "{yy}": yyyy.slice(2),
+    "{MM}": mm,
+    "{dd}": dd,
+    "{M}": String(Number(mm)),
+    "{d}": String(Number(dd)),
+    "{ww}": isoWeekNumber(date)
+  };
+  const expanded = template.replace(TOKEN_RE, (token) => tokens[token] ?? token);
+  if (expanded.split(/[\\/]/).some((segment) => segment === "..")) {
+    throw new RangeError("Vault note path template must not contain `..` segments.");
+  }
+  if (path34.posix.isAbsolute(expanded) || path34.win32.isAbsolute(expanded)) {
+    throw new RangeError("Vault note path template must be relative; absolute templates are rejected.");
+  }
+  return expanded;
+}
+function isoWeekNumber(date) {
+  const [year, month, day] = date.split("-").map(Number);
+  const utc = new Date(Date.UTC(year, month - 1, day));
+  const dayNum = utc.getUTCDay() || 7;
+  utc.setUTCDate(utc.getUTCDate() + 4 - dayNum);
+  const yearStart = new Date(Date.UTC(utc.getUTCFullYear(), 0, 1));
+  const weekNo = Math.ceil(((utc.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+  return String(weekNo).padStart(2, "0");
+}
+
+// src/activity/vault-publish.ts
+import { createHash as createHash10, randomBytes as randomBytes4 } from "crypto";
+import { readFileSync as readFileSync3, renameSync as renameSync2, statSync as statSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import path35 from "path";
+function applyManagedRegion(fileText, opts) {
+  if (opts.strategy === "heading") return applyHeadingRegion(fileText, opts.name, opts.content);
+  const startMarker = `<!-- remnic:${opts.name}:start -->`;
+  const endMarker = `<!-- remnic:${opts.name}:end -->`;
+  const startIdx = fileText.indexOf(startMarker);
+  if (startIdx === -1) return { ok: false, reason: "no_marker", text: fileText };
+  const endIdx = fileText.indexOf(endMarker, startIdx + startMarker.length);
+  if (endIdx === -1) return { ok: false, reason: "no_marker", text: fileText };
+  const { body, eol } = ownedBody(fileText, opts.content);
+  return {
+    ok: true,
+    text: `${fileText.slice(0, startIdx + startMarker.length)}${eol}${body}${eol}${fileText.slice(endIdx)}`
+  };
+}
+function applyHeadingRegion(fileText, name, content) {
+  const wanted = name.trim();
+  const hits = [];
+  for (const row of fileLines(fileText)) {
+    const heading = parseAtxHeading2(row.line);
+    if (heading && heading.text === wanted) {
+      hits.push({ line: row.number, level: heading.level, next: row.next });
+    }
+  }
+  if (hits.length === 0) return { ok: false, reason: "no_heading", text: fileText };
+  if (hits.length > 1) {
+    return { ok: false, reason: "duplicate_heading", lines: hits.map((hit2) => hit2.line), text: fileText };
+  }
+  const hit = hits[0];
+  let sectionEnd = fileText.length;
+  for (const row of fileLines(fileText)) {
+    if (row.start < hit.next) continue;
+    const heading = parseAtxHeading2(row.line);
+    if (heading && heading.level <= hit.level) {
+      sectionEnd = row.start;
+      break;
+    }
+  }
+  const { body, eol } = ownedBody(fileText, content);
+  const prefix = hit.next === fileText.length && !fileText.endsWith("\n") && !fileText.endsWith("\r") ? `${fileText}${eol}` : fileText.slice(0, hit.next);
+  return { ok: true, text: `${prefix}${body}${eol}${fileText.slice(sectionEnd)}` };
+}
+function ownedBody(fileText, content) {
+  const eol = fileText.includes("\r\n") ? "\r\n" : "\n";
+  let body = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  if (eol === "\r\n") body = body.replace(/\n/g, "\r\n");
+  if (body.endsWith(eol)) body = body.slice(0, -eol.length);
+  return { body, eol };
+}
+function fileLines(fileText) {
+  const rows = [];
+  let start = 0;
+  let number = 1;
+  while (start < fileText.length) {
+    let i = start;
+    while (i < fileText.length && fileText[i] !== "\n" && fileText[i] !== "\r") i++;
+    let next = i;
+    if (fileText[i] === "\r" && fileText[i + 1] === "\n") next = i + 2;
+    else if (fileText[i] === "\n" || fileText[i] === "\r") next = i + 1;
+    else next = fileText.length;
+    rows.push({ line: fileText.slice(start, i), start, next, number });
+    number += 1;
+    start = next;
+  }
+  return rows;
+}
+function parseAtxHeading2(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 publishVaultRegion(input) {
+  const vault = expandTildePath(input.vaultPath);
+  try {
+    if (!statSync2(vault).isDirectory()) return { ok: false, reason: "not_directory" };
+  } catch {
+    return { ok: false, reason: "not_directory" };
+  }
+  if (input.relativeFile.length === 0 || path35.isAbsolute(input.relativeFile)) {
+    return { ok: false, reason: "missing_file" };
+  }
+  const root = path35.resolve(vault);
+  const dest = path35.resolve(root, input.relativeFile);
+  const rel = path35.relative(root, dest);
+  if (rel.length === 0 || rel.startsWith("..") || path35.isAbsolute(rel)) {
+    return { ok: false, reason: "missing_file" };
+  }
+  let existing;
+  try {
+    if (!statSync2(dest).isFile()) return { ok: false, reason: "missing_file" };
+    existing = readFileSync3(dest, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return { ok: false, reason: "missing_file" };
+    throw err;
+  }
+  const applied = applyManagedRegion(existing, {
+    strategy: "markers",
+    name: input.name,
+    content: input.content
+  });
+  if (!applied.ok) return { ok: false, reason: "no_marker" };
+  const prevHash = createHash10("sha256").update(existing, "utf8").digest("hex");
+  const nextHash = createHash10("sha256").update(applied.text, "utf8").digest("hex");
+  if (prevHash === nextHash) return { ok: true, status: "unchanged" };
+  const tmpPath = path35.join(path35.dirname(dest), `.remnic-vault-${randomBytes4(8).toString("hex")}.tmp`);
+  writeFileSync2(tmpPath, applied.text);
+  try {
+    renameSync2(tmpPath, dest);
+  } catch (renameErr) {
+    try {
+      unlinkSync2(tmpPath);
+    } catch {
+    }
+    throw renameErr;
+  }
+  return { ok: true, status: "updated" };
+}
+
 // src/session-summaries/index.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 import { lstat as lstat3, mkdir as mkdir7, readFile as readFile7, readdir as readdir4, rename, rm, stat as stat4, writeFile as writeFile7 } from "fs/promises";
-import path33 from "path";
+import path36 from "path";
 
 // src/session-summaries/adapters.ts
 var VALID_ROLES = /* @__PURE__ */ new Set(["user", "assistant", "tool", "system", "other"]);
@@ -27058,12 +28315,12 @@ var DEFAULT_MAX_FILES = 5e3;
 var DEFAULT_MAX_SESSIONS = 500;
 var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".json", ".jsonl"]);
 function shortHash(value, length = 16) {
-  return createHash10("sha256").update(value).digest("hex").slice(0, length);
+  return createHash11("sha256").update(value).digest("hex").slice(0, length);
 }
 async function listTranscriptFiles(root, maxFiles) {
   const out = [];
   let truncated = false;
-  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path33.sep}` : entryName;
+  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path36.sep}` : entryName;
   async function visit(dir) {
     if (truncated) return;
     const entries = (await readdir4(dir, { withFileTypes: true })).sort(
@@ -27073,13 +28330,13 @@ async function listTranscriptFiles(root, maxFiles) {
       if (truncated) return;
       if (entry.name.startsWith(".")) continue;
       if (entry.isSymbolicLink()) continue;
-      const fullPath = path33.join(dir, entry.name);
+      const fullPath = path36.join(dir, entry.name);
       if (entry.isDirectory()) {
         await visit(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      const ext = path33.extname(entry.name).toLowerCase();
+      const ext = path36.extname(entry.name).toLowerCase();
       if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
       out.push(fullPath);
       if (out.length > maxFiles) {
@@ -27106,7 +28363,7 @@ function normalizeInputDir(inputDir) {
   if (typeof inputDir !== "string" || inputDir.trim().length === 0) {
     throw new Error("inputDir must be a non-empty string");
   }
-  return path33.resolve(expandTildePath(inputDir.trim()));
+  return path36.resolve(expandTildePath(inputDir.trim()));
 }
 function initRoleCounts() {
   return {
@@ -27263,11 +28520,11 @@ async function collectLocalSessionSummaries(options) {
       continue;
     }
     seenFileHashes.add(fileHash);
-    const fileExtension = path33.extname(filePath).toLowerCase();
+    const fileExtension = path36.extname(filePath).toLowerCase();
     const parsed = await adapter.parseFile(
       {
         content,
-        fileName: path33.basename(filePath),
+        fileName: path36.basename(filePath),
         fileExtension,
         fileRef: fileHash
       },
@@ -27323,7 +28580,7 @@ async function collectLocalSessionSummaries(options) {
 }
 async function readRedactionConfig(pathLike) {
   if (!pathLike) return void 0;
-  const raw = await readFile7(path33.resolve(expandTildePath(pathLike)), "utf-8");
+  const raw = await readFile7(path36.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");
@@ -27336,15 +28593,15 @@ function toJsonl(drafts) {
 }
 function defaultDraftOutputPath(memoryDir, generatedAt) {
   const stamp = generatedAt.replace(/[:.]/g, "-");
-  return path33.join(
-    path33.resolve(expandTildePath(memoryDir)),
+  return path36.join(
+    path36.resolve(expandTildePath(memoryDir)),
     "state",
     "session-summary-drafts",
     `session-summaries-${stamp}.jsonl`
   );
 }
 async function writeDrafts(filePath, drafts) {
-  await mkdir7(path33.dirname(filePath), { recursive: true });
+  await mkdir7(path36.dirname(filePath), { recursive: true });
   const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
   try {
     await writeFile7(tempPath, toJsonl(drafts), "utf-8");
@@ -27362,7 +28619,7 @@ async function runLocalSessionSummaryCliCommand(options) {
   });
   const wroteFiles = [];
   if (options.output) {
-    const outputPath = path33.resolve(expandTildePath(options.output));
+    const outputPath = path36.resolve(expandTildePath(options.output));
     await writeDrafts(outputPath, report.drafts);
     wroteFiles.push(outputPath);
   }
@@ -27397,19 +28654,19 @@ async function runLocalSessionSummaryCliCommand(options) {
 
 // src/transfer/capsule-fork.ts
 import { lstat as lstat4, mkdir as mkdir8, readFile as readFile8, realpath as realpath3, writeFile as writeFile8 } from "fs/promises";
-import path34 from "path";
+import path37 from "path";
 async function forkCapsule(opts) {
   validateForkId(opts.forkId);
-  const rootAbs = path34.resolve(opts.targetRoot);
+  const rootAbs = path37.resolve(opts.targetRoot);
   await assertIsDirectoryNotSymlink(rootAbs, "forkCapsule", "targetRoot");
-  const forkDirAbs = path34.join(rootAbs, "forks", opts.forkId);
+  const forkDirAbs = path37.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 = path34.resolve(opts.sourceArchive);
+  const archiveAbs = path37.resolve(opts.sourceArchive);
   const importResult = await importCapsule({
     archivePath: archiveAbs,
     root: rootAbs,
@@ -27431,10 +28688,10 @@ async function forkCapsule(opts) {
     importedRecords: importResult.imported.length,
     skippedRecords: importResult.skipped.length
   };
-  const lineagePath = path34.join(forkDirAbs, "lineage.json");
+  const lineagePath = path37.join(forkDirAbs, "lineage.json");
   const rootReal = await realpath3(rootAbs);
   await assertRealpathInsideRoot(rootReal, lineagePath, `forks/${opts.forkId}/lineage.json`, "forkCapsule");
-  await mkdir8(path34.dirname(lineagePath), { recursive: true });
+  await mkdir8(path37.dirname(lineagePath), { recursive: true });
   await writeFile8(lineagePath, JSON.stringify(lineage, null, 2) + "\n", "utf-8");
   return {
     archivePath: archiveAbs,
@@ -27448,11 +28705,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 = path34.resolve(targetRoot);
+  const rootAbs = path37.resolve(targetRoot);
   const rootReal = await realpath3(rootAbs).catch(() => rootAbs);
-  const lineagePath = path34.join(rootReal, "forks", forkId, "lineage.json");
-  const rel = path34.relative(rootReal, lineagePath);
-  if (rel.startsWith("..") || path34.isAbsolute(rel)) {
+  const lineagePath = path37.join(rootReal, "forks", forkId, "lineage.json");
+  const rel = path37.relative(rootReal, lineagePath);
+  if (rel.startsWith("..") || path37.isAbsolute(rel)) {
     return null;
   }
   if (!await isLineagePathContained(rootReal, lineagePath)) {
@@ -27493,19 +28750,19 @@ async function pathEntryExists(absPath) {
 async function isLineagePathContained(rootReal, lineagePath) {
   let existing = lineagePath;
   const suffix = [];
-  while (existing !== path34.dirname(existing)) {
+  while (existing !== path37.dirname(existing)) {
     const st = await lstat4(existing).catch(() => null);
     if (st !== null) break;
-    suffix.unshift(path34.basename(existing));
-    existing = path34.dirname(existing);
+    suffix.unshift(path37.basename(existing));
+    existing = path37.dirname(existing);
   }
   const existingReal = await realpath3(existing).catch(() => existing);
-  const targetReal = suffix.length > 0 ? path34.join(existingReal, ...suffix) : existingReal;
-  const rel = path34.relative(rootReal, targetReal);
+  const targetReal = suffix.length > 0 ? path37.join(existingReal, ...suffix) : existingReal;
+  const rel = path37.relative(rootReal, targetReal);
   if (rel === "") return true;
   if (rel === "..") return false;
-  if (rel.startsWith(`..${path34.sep}`)) return false;
-  if (path34.isAbsolute(rel)) return false;
+  if (rel.startsWith(`..${path37.sep}`)) return false;
+  if (path37.isAbsolute(rel)) return false;
   return true;
 }
 
@@ -27605,8 +28862,36 @@ export {
   timelineCorrectionDatabasePath,
   TimelineCorrectionStore,
   applyTimelineCorrections,
+  queryTimelineRange,
+  queryTimelineSearch,
+  runTimelineCliCommand,
+  renderDeterministicJournal,
+  persistDeterministicJournal,
+  WEEKLY_ACTIVITY_FORMAT_VERSION,
+  buildWeeklyActivitySummary,
+  WEEKLY_SNAPSHOT_FORMAT_VERSION,
+  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,
+  batchObservations2 as batchObservations,
+  readVaultJournal,
+  stripRemnicOwnedRegions,
   isEligibleActivityFact,
   generateActivityMemories,
+  MS_PER_DAY2 as MS_PER_DAY,
+  parseActivityPrivacy,
+  shouldRetain,
+  observationsForExport,
+  resolveVaultNotePath,
+  applyManagedRegion,
+  publishVaultRegion,
   fuseMeeting,
   buildMeetingRecordsForDay,
   MeetingsBuilder,
@@ -27640,4 +28925,4 @@ export {
   blendGraphExpandedRecallScore,
   Orchestrator
 };
-//# sourceMappingURL=chunk-56IV4J5W.js.map
+//# sourceMappingURL=chunk-47WWTCJY.js.map