@remnic/core 9.65.8 → 9.66.1

package/dist/{chunk-LKYIOCWL.js → chunk-TCF4MU7L.js}

@@ -6,14 +6,14 @@ import {
   loadSyncState,
   syncWearableSource,
   wearableSourceLabel
-} from "./chunk-UEBDCMOO.js";
+} from "./chunk-3TSU662L.js";
 import {
   CompressionGuidelineCoordinator
 } from "./chunk-UXREWVW4.js";
 import {
   ActivityStore,
   MaintenanceScheduler
-} from "./chunk-LPNCR4QK.js";
+} from "./chunk-NSTNGMSS.js";
 import {
   runPeerProfileReasoner
 } from "./chunk-I74SUMNI.js";
@@ -22,7 +22,7 @@ import {
 } from "./chunk-7HYPN2GC.js";
 import {
   LcmEngine
-} from "./chunk-Z3YEGSR4.js";
+} from "./chunk-D3UXGE5D.js";
 import {
   chunkTranscriptEntries
 } from "./chunk-TECVW3JP.js";
@@ -32,39 +32,39 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-3SZD4CYO.js";
+} from "./chunk-IGZCAHFL.js";
 import {
   SharedContextManager
 } from "./chunk-VI637ILW.js";
-import {
-  cleanArchivedUserMessage
-} from "./chunk-47DU4SGJ.js";
 import {
   applyUtilityPromotionRuntimePolicy,
   applyUtilityRankingRuntimeDelta,
   loadUtilityRuntimeValues
 } from "./chunk-SEF4IOFE.js";
 import {
-  extractTopics
-} from "./chunk-KVDUKH5E.js";
-import {
-  buildTemporalTimelineRecallSection
-} from "./chunk-2NKY7OC6.js";
-import {
-  CODEX_THREAD_KEY_PREFIX
-} from "./chunk-4EX5WZ4M.js";
+  cleanArchivedUserMessage
+} from "./chunk-47DU4SGJ.js";
 import {
   TierMigrationExecutor
 } from "./chunk-YRFAYOFQ.js";
 import {
   decideTierTransition
-} from "./chunk-EGBDFJ36.js";
+} from "./chunk-DD5JFCWM.js";
 import {
   TmtBuilder
 } from "./chunk-ECZU5BJH.js";
+import {
+  extractTopics
+} from "./chunk-KVDUKH5E.js";
+import {
+  buildTemporalTimelineRecallSection
+} from "./chunk-2NKY7OC6.js";
+import {
+  CODEX_THREAD_KEY_PREFIX
+} from "./chunk-4EX5WZ4M.js";
 import {
   HourlySummarizer
-} from "./chunk-EUYWQ7TS.js";
+} from "./chunk-IEZ6CGTW.js";
 import {
   buildTargetedFactRecallSection,
   shouldRecallTargetedFactEvidence
@@ -72,10 +72,6 @@ import {
 import {
   SessionObserverState
 } from "./chunk-ODZKV2F7.js";
-import {
-  buildResponseGuidanceRecallSection,
-  shouldRecallResponseGuidance
-} from "./chunk-6TCXIRP5.js";
 import {
   mergeWithAgentResults,
   runDirectAgent,
@@ -100,9 +96,6 @@ import {
 import {
   applyRuntimeRetrievalPolicy
 } from "./chunk-5IZL4DCV.js";
-import {
-  findUnresolvedEntityRefs
-} from "./chunk-X7XN6YU4.js";
 import {
   RelevanceStore
 } from "./chunk-KATEWTQJ.js";
@@ -111,6 +104,16 @@ import {
   reorderByRankedKeys,
   rerankLocalOrNoop
 } from "./chunk-LUDXM7MD.js";
+import {
+  buildResponseGuidanceRecallSection,
+  shouldRecallResponseGuidance
+} from "./chunk-6TCXIRP5.js";
+import {
+  findUnresolvedEntityRefs
+} from "./chunk-X7XN6YU4.js";
+import {
+  applyRecallStateViews
+} from "./chunk-WFCWP4XU.js";
 import {
   dedupeResultsByNamespace,
   hasMemoryForResult,
@@ -157,10 +160,10 @@ import {
 } from "./chunk-OH7QLI6W.js";
 import {
   ExtractionEngine
-} from "./chunk-U7EW2W4W.js";
+} from "./chunk-XKNHFDTT.js";
 import {
   parseMemoryActionEligibilityContext
-} from "./chunk-7BDZTALN.js";
+} from "./chunk-AJTG3CP7.js";
 import {
   ModelRegistry
 } from "./chunk-WLZYGLJ4.js";
@@ -173,7 +176,7 @@ import {
   getVerdictKind,
   judgeFactDurability,
   validateProcedureExtraction
-} from "./chunk-HSZMX3ZJ.js";
+} from "./chunk-ODW5GDFE.js";
 import {
   buildEventOrderRecallSection
 } from "./chunk-645WOU5I.js";
@@ -191,7 +194,7 @@ import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-PU56CXZA.js";
+} from "./chunk-LYUUA6QB.js";
 import {
   planEpisodeWindowsWithFallback
 } from "./chunk-T3GIETKV.js";
@@ -206,31 +209,31 @@ import {
 } from "./chunk-LVXBC6YB.js";
 import {
   refreshConvergedNamespaces
-} from "./chunk-AZMLH5UT.js";
+} from "./chunk-KI64TTBL.js";
 import {
   builtInConnectorPackageSpecifier,
   ensureBuiltInWearableConnectors,
   getWearableConnector,
   listWearableConnectors,
   screenCandidateFact
-} from "./chunk-JYSN42VN.js";
-import {
-  RoutingRulesStore
-} from "./chunk-TBUEE7XF.js";
+} from "./chunk-RPIS5FQ7.js";
 import {
   normalizeReplaySessionKey
 } from "./chunk-AJVLDJU6.js";
+import {
+  RoutingRulesStore
+} from "./chunk-TBUEE7XF.js";
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-GTO56JY5.js";
+} from "./chunk-ZPS724LT.js";
 import {
   ThreadingManager
 } from "./chunk-OJP3N7UK.js";
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-P36Z4JRA.js";
+} from "./chunk-M5ERTI4I.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-NRLELHAY.js";
@@ -243,17 +246,17 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-MY2BC6UE.js";
+} from "./chunk-2X6BGKQL.js";
 import {
   planNamespaceMaintenance
-} from "./chunk-WNXYT4MK.js";
+} from "./chunk-S4Z2OBTX.js";
 import {
   isAboveImportanceThreshold,
   scoreImportance
 } from "./chunk-UOBPK2OS.js";
 import {
   searchHarmonicRetrieval
-} from "./chunk-TUHBYJXL.js";
+} from "./chunk-EWKVYCFP.js";
 import {
   EXTRACTION_JUDGE_VERDICT_CATEGORY,
   recordJudgeVerdict
@@ -281,7 +284,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-UPFNQJC7.js";
+} from "./chunk-INUBU6I5.js";
 import {
   semanticChunkContent
 } from "./chunk-2GBFKHBZ.js";
@@ -290,7 +293,7 @@ import {
 } from "./chunk-6TBIWIAG.js";
 import {
   SmartBuffer
-} from "./chunk-JOZUBF4A.js";
+} from "./chunk-NACLNNFQ.js";
 import {
   buildRecallQueryPolicy
 } from "./chunk-C6WMSXCJ.js";
@@ -311,8 +314,10 @@ import {
   evaluateMemoryActionPolicy
 } from "./chunk-MI2OTWV5.js";
 import {
-  detectMeetings
-} from "./chunk-7WOWGRAU.js";
+  applyNoveltyGate,
+  detectMeetings,
+  embeddingsFromCosineHits
+} from "./chunk-AF5H7TKI.js";
 import {
   compileCorrectionRule,
   correctionsFilePath,
@@ -325,19 +330,14 @@ import {
 } from "./chunk-QW27DOHG.js";
 import {
   MeetingsInputError
-} from "./chunk-KZIF6XHX.js";
+} from "./chunk-U65VJSCJ.js";
 import {
   WearablesInputError,
   describeErrorForOperator
 } from "./chunk-V7IZKJI3.js";
 import {
   NamespaceCatalog
-} from "./chunk-3PKAS6VL.js";
-import {
-  activityDayWindow,
-  isValidActivityDate,
-  timezoneOffsetIso
-} from "./chunk-M6L7HI7R.js";
+} from "./chunk-GAJK3DQ5.js";
 import {
   recordDreamsPhaseRun
 } from "./chunk-EQWEIIKQ.js";
@@ -354,10 +354,10 @@ import {
   filterRecallCandidates,
   isGenericRecallExcludedPath,
   isTopLevelArchivePath
-} from "./chunk-OXRRJXPR.js";
+} from "./chunk-MUEGIKKY.js";
 import {
   importCapsule
-} from "./chunk-PMVPCZJZ.js";
+} from "./chunk-J2R275FN.js";
 import {
   isCodingGraphInstalled
 } from "./chunk-VQ7B2Q6M.js";
@@ -380,7 +380,7 @@ import {
 } from "./chunk-ZVZHG7AI.js";
 import {
   buildXraySnapshot
-} from "./chunk-NPIBN2VL.js";
+} from "./chunk-LK4TOYPU.js";
 import {
   objectiveStateStoreOverrideForNamespace,
   searchObjectiveStateSnapshots
@@ -397,7 +397,7 @@ import {
 } from "./chunk-IVKIODHO.js";
 import {
   shouldSkipImplicitExtraction
-} from "./chunk-CRML27CO.js";
+} from "./chunk-X5YYSAZX.js";
 import {
   boundRecallContextComposition,
   composeRecallContext,
@@ -408,7 +408,7 @@ import {
 } from "./chunk-7ZNJN5WZ.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-F7XUD3PL.js";
+} from "./chunk-S4CDUXQY.js";
 import {
   GraphIndex
 } from "./chunk-YMOPYG3K.js";
@@ -452,7 +452,7 @@ import {
   throwIfRecallAborted,
   tokenizeRecallQuery,
   utcDateKeysForLocalDay
-} from "./chunk-YEUXERJ6.js";
+} from "./chunk-RDGKVH6T.js";
 import {
   inferIntentFromText,
   intentCompatibilityScore,
@@ -465,7 +465,7 @@ import {
 } from "./chunk-TBBDFYXW.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-HMZKGHMD.js";
+} from "./chunk-7UOXCCCI.js";
 import {
   QmdResultResolver,
   StorageManager,
@@ -484,7 +484,10 @@ import {
   reconstructFusionInputs,
   selfDeps,
   serializeFusionDay
-} from "./chunk-W2BAGGEW.js";
+} from "./chunk-2ITZ74A6.js";
+import {
+  buildRetiredFactTombstoneInputs
+} from "./chunk-4ZWCQJNM.js";
 import {
   bodyIsEscaped,
   decodeTranscriptBody,
@@ -495,18 +498,15 @@ import {
   saveSpeakerRegistry,
   speakerRegistryKey
 } from "./chunk-UHVXE24Y.js";
-import {
-  buildRetiredFactTombstoneInputs
-} from "./chunk-4ZWCQJNM.js";
 import {
   NamespaceSearchRouter,
   namespaceCollectionName
-} from "./chunk-ODU2CNNX.js";
+} from "./chunk-C5IUOBCN.js";
 import {
   createConversationIndexRuntime,
   createSearchBackend,
   isSearchBackendEnabled
-} from "./chunk-4QEYREAV.js";
+} from "./chunk-U6NGKS32.js";
 import {
   NoopSearchBackend
 } from "./chunk-CYEPCZN5.js";
@@ -520,7 +520,7 @@ import {
 } from "./chunk-S2V7RUCL.js";
 import {
   confidenceTier
-} from "./chunk-MINHJ55X.js";
+} from "./chunk-XXW32OL7.js";
 import {
   lintWorkspaceFiles,
   rotateMarkdownFileToArchive
@@ -529,15 +529,7 @@ import {
   applyFaithfulnessVerdict,
   createFaithfulnessCounters,
   runFaithfulnessGateBatch
-} from "./chunk-UG6VXIOK.js";
-import {
-  TAG_LIMITS,
-  composeMemoryEnvelope,
-  isMemoryCategory
-} from "./chunk-H2YSH3DG.js";
-import {
-  normalizeTags
-} from "./chunk-BT7NVCML.js";
+} from "./chunk-XSTNGNJP.js";
 import {
   checkCorpusReadAbort
 } from "./chunk-5GINB5LC.js";
@@ -559,7 +551,7 @@ import {
   requestEntityCanonicalIdReconcile,
   requestEntityCanonicalIdReconcileSync,
   withRawEntityPageMutation
-} from "./chunk-ZVPVTPGI.js";
+} from "./chunk-NNZFPYYX.js";
 import {
   applyTemporalSupersession,
   applyTemporalSupersessionPrimaryMutation,
@@ -572,6 +564,14 @@ import {
   isValidAsOf,
   isValidityExpiredNow
 } from "./chunk-6CIAGZ6X.js";
+import {
+  TAG_LIMITS,
+  composeMemoryEnvelope,
+  isMemoryCategory
+} from "./chunk-WKAXBXVA.js";
+import {
+  normalizeTags
+} from "./chunk-BT7NVCML.js";
 import {
   buildQmdRecallCacheKey,
   getCachedQmdRecall,
@@ -581,7 +581,7 @@ import {
   FallbackLlmClient,
   fallbackLlmRuntimeContextFromConfig,
   gatewayTaskChainOptions
-} from "./chunk-UW5NPZJ2.js";
+} from "./chunk-JALOAKSZ.js";
 import {
   estimateTokenCount
 } from "./chunk-TOTT6S2V.js";
@@ -591,6 +591,11 @@ import {
 import {
   buildProcedurePersistBody
 } from "./chunk-QDW3E4RD.js";
+import {
+  activityDayWindow,
+  isValidActivityDate,
+  timezoneOffsetIso
+} from "./chunk-M6L7HI7R.js";
 import {
   searchCausalTrajectories
 } from "./chunk-GPFZFCRN.js";
@@ -598,7 +603,7 @@ import {
   evaluateSubjectGuard,
   isSharedPromotionTarget,
   resolveWriteSubject
-} from "./chunk-LDKPDODJ.js";
+} from "./chunk-ME35HVDJ.js";
 import {
   parseOriginClass
 } from "./chunk-6Q3ZTEF6.js";
@@ -606,7 +611,9 @@ import {
   normalizeRecallTokenSet
 } from "./chunk-YCVB7X56.js";
 import {
-  coerceBool
+  coerceBool,
+  coerceBooleanLike,
+  coerceNumber
 } from "./chunk-PQVCH2AE.js";
 import {
   graphemeUnits,
@@ -632,27 +639,30 @@ import {
   getConfiguredNamespaces,
   resolveNamespaceFromStorageDir,
   resolveScopePlan
-} from "./chunk-Q57GOHLF.js";
+} from "./chunk-EGALNSZ4.js";
 import {
   attachCitation,
   hasCitationForTemplate,
   stripCitationForTemplate
 } from "./chunk-J6A3CX5N.js";
-import {
-  assertPathInsideRoot
-} from "./chunk-GCASGYIO.js";
 import {
   inferMemoryStatus,
   isActiveMemoryStatus,
   toMemoryPathRel
 } from "./chunk-7RJUVTVF.js";
+import {
+  openBetterSqlite3
+} from "./chunk-RL6NEVXT.js";
+import {
+  assertPathInsideRoot
+} from "./chunk-GCASGYIO.js";
 import {
   excludeSupportPassportPrivateMemories,
   isSupportPassportPrivateMemory
-} from "./chunk-XDL5CYZN.js";
+} from "./chunk-EEOUMG3J.js";
 import {
   ContentHashIndex
-} from "./chunk-BEC4YBNA.js";
+} from "./chunk-TVW4C7PV.js";
 import {
   normalizeAttributePairs,
   stripAttributesSuffix
@@ -670,6 +680,9 @@ import {
   assertIsDirectoryNotSymlink,
   assertRealpathInsideRoot
 } from "./chunk-GCGJW34D.js";
+import {
+  parseFlexibleIsoTimestamp
+} from "./chunk-P7FMDTKL.js";
 import {
   canReadNamespace,
   defaultNamespaceForPrincipal,
@@ -709,7 +722,7 @@ import {
 import {
   lcmSessionKeyForNamespace,
   resolveCodingNamespaceOverlay
-} from "./chunk-J2WC5LF4.js";
+} from "./chunk-QBC33MPY.js";
 import {
   expandTildePath
 } from "./chunk-EYIEWJNI.js";
@@ -737,16 +750,16 @@ import {
 } from "./chunk-FF4KLI5W.js";
 import {
   SecureStoreLockedError
-} from "./chunk-XQ3HXAQH.js";
-import {
-  isErrnoCode
-} from "./chunk-5UZXUTVO.js";
+} from "./chunk-ET2CNMLD.js";
 import {
   ALL_CATEGORY_DIRS,
   ALL_CATEGORY_KEYS,
   RECALL_FALLBACK_DIRS,
   getCategoryDir
 } from "./chunk-VS2IYZRU.js";
+import {
+  isErrnoCode
+} from "./chunk-5UZXUTVO.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -2303,7 +2316,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
       namespaces,
       {
         readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
-        readMemoryFrontmatter: async (path34, preferredNamespace) => {
+        readMemoryFrontmatter: async (path35, preferredNamespace) => {
           if (!fallbackReader) {
             for (const ns of namespaces) {
               try {
@@ -2315,7 +2328,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
           }
           if (!fallbackReader) return null;
           const memory = await this.readQmdResultMemory(
-            path34,
+            path35,
             fallbackReader,
             namespaces,
             preferredNamespace
@@ -6069,8 +6082,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" };
@@ -6146,11 +6174,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;
@@ -15629,7 +15657,7 @@ var OrchestratorInitCoordinator = class {
     if (signal.aborted) return;
     if (lifecycleCaps.lifecyclePolicy && resolveQmdCapabilities(this.deps.config).qmdTierMigration) {
       try {
-        const { runFirstStartMigration } = await import("./first-start-migration-4NETATFF.js");
+        const { runFirstStartMigration } = await import("./first-start-migration-KHIMCBIC.js");
         const result = await runFirstStartMigration({
           storage: this.deps.storage,
           config: this.deps.config,
@@ -15652,7 +15680,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-2YPITIWN.js");
+        const { startWearablesAutoSync } = await import("./auto-sync-Q6Q2FVSC.js");
         if (signal.aborted) return;
         this.deps.wearablesAutoSyncHandle = startWearablesAutoSync(
           {
@@ -18956,14 +18984,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;
@@ -19179,7 +19207,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,
@@ -22298,9 +22330,9 @@ function readStructuralSymbol(entry) {
   const rec = entry;
   const symbol = typeof rec.symbol === "string" ? rec.symbol.trim() : "";
   if (!symbol) return null;
-  const path34 = typeof rec.path === "string" && rec.path.length > 0 ? rec.path : void 0;
+  const path35 = 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 = path34 !== void 0 && kind !== void 0 ? { symbol, path: path34, kind } : path34 !== void 0 ? { symbol, path: path34 } : kind !== void 0 ? { symbol, kind } : { symbol };
+  const item = path35 !== void 0 && kind !== void 0 ? { symbol, path: path35, kind } : path35 !== void 0 ? { symbol, path: path35 } : kind !== void 0 ? { symbol, kind } : { symbol };
   return item;
 }
 function classifySpawnError(err) {
@@ -25864,6 +25896,738 @@ 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 path32 from "path";
+function timelineCorrectionDatabasePath(memoryDir) {
+  return path32.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(path32.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;
+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/memory-gen.ts
 var ACTIVITY_ALLOWED_CATEGORIES = {
   decision: true,
@@ -26120,10 +26884,58 @@ 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/session-summaries/index.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } 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 path32 from "path";
+import path33 from "path";
 
 // src/session-summaries/adapters.ts
 var VALID_ROLES = /* @__PURE__ */ new Set(["user", "assistant", "tool", "system", "other"]);
@@ -26623,12 +27435,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 createHash9("sha256").update(value).digest("hex").slice(0, length);
+  return createHash10("sha256").update(value).digest("hex").slice(0, length);
 }
 async function listTranscriptFiles(root, maxFiles) {
   const out = [];
   let truncated = false;
-  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path32.sep}` : entryName;
+  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path33.sep}` : entryName;
   async function visit(dir) {
     if (truncated) return;
     const entries = (await readdir4(dir, { withFileTypes: true })).sort(
@@ -26638,13 +27450,13 @@ async function listTranscriptFiles(root, maxFiles) {
       if (truncated) return;
       if (entry.name.startsWith(".")) continue;
       if (entry.isSymbolicLink()) continue;
-      const fullPath = path32.join(dir, entry.name);
+      const fullPath = path33.join(dir, entry.name);
       if (entry.isDirectory()) {
         await visit(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      const ext = path32.extname(entry.name).toLowerCase();
+      const ext = path33.extname(entry.name).toLowerCase();
       if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
       out.push(fullPath);
       if (out.length > maxFiles) {
@@ -26671,7 +27483,7 @@ function normalizeInputDir(inputDir) {
   if (typeof inputDir !== "string" || inputDir.trim().length === 0) {
     throw new Error("inputDir must be a non-empty string");
   }
-  return path32.resolve(expandTildePath(inputDir.trim()));
+  return path33.resolve(expandTildePath(inputDir.trim()));
 }
 function initRoleCounts() {
   return {
@@ -26828,11 +27640,11 @@ async function collectLocalSessionSummaries(options) {
       continue;
     }
     seenFileHashes.add(fileHash);
-    const fileExtension = path32.extname(filePath).toLowerCase();
+    const fileExtension = path33.extname(filePath).toLowerCase();
     const parsed = await adapter.parseFile(
       {
         content,
-        fileName: path32.basename(filePath),
+        fileName: path33.basename(filePath),
         fileExtension,
         fileRef: fileHash
       },
@@ -26888,7 +27700,7 @@ async function collectLocalSessionSummaries(options) {
 }
 async function readRedactionConfig(pathLike) {
   if (!pathLike) return void 0;
-  const raw = await readFile7(path32.resolve(expandTildePath(pathLike)), "utf-8");
+  const raw = await readFile7(path33.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");
@@ -26901,15 +27713,15 @@ function toJsonl(drafts) {
 }
 function defaultDraftOutputPath(memoryDir, generatedAt) {
   const stamp = generatedAt.replace(/[:.]/g, "-");
-  return path32.join(
-    path32.resolve(expandTildePath(memoryDir)),
+  return path33.join(
+    path33.resolve(expandTildePath(memoryDir)),
     "state",
     "session-summary-drafts",
     `session-summaries-${stamp}.jsonl`
   );
 }
 async function writeDrafts(filePath, drafts) {
-  await mkdir7(path32.dirname(filePath), { recursive: true });
+  await mkdir7(path33.dirname(filePath), { recursive: true });
   const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
   try {
     await writeFile7(tempPath, toJsonl(drafts), "utf-8");
@@ -26927,7 +27739,7 @@ async function runLocalSessionSummaryCliCommand(options) {
   });
   const wroteFiles = [];
   if (options.output) {
-    const outputPath = path32.resolve(expandTildePath(options.output));
+    const outputPath = path33.resolve(expandTildePath(options.output));
     await writeDrafts(outputPath, report.drafts);
     wroteFiles.push(outputPath);
   }
@@ -26962,19 +27774,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 path33 from "path";
+import path34 from "path";
 async function forkCapsule(opts) {
   validateForkId(opts.forkId);
-  const rootAbs = path33.resolve(opts.targetRoot);
+  const rootAbs = path34.resolve(opts.targetRoot);
   await assertIsDirectoryNotSymlink(rootAbs, "forkCapsule", "targetRoot");
-  const forkDirAbs = path33.join(rootAbs, "forks", opts.forkId);
+  const forkDirAbs = path34.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 = path33.resolve(opts.sourceArchive);
+  const archiveAbs = path34.resolve(opts.sourceArchive);
   const importResult = await importCapsule({
     archivePath: archiveAbs,
     root: rootAbs,
@@ -26996,10 +27808,10 @@ async function forkCapsule(opts) {
     importedRecords: importResult.imported.length,
     skippedRecords: importResult.skipped.length
   };
-  const lineagePath = path33.join(forkDirAbs, "lineage.json");
+  const lineagePath = path34.join(forkDirAbs, "lineage.json");
   const rootReal = await realpath3(rootAbs);
   await assertRealpathInsideRoot(rootReal, lineagePath, `forks/${opts.forkId}/lineage.json`, "forkCapsule");
-  await mkdir8(path33.dirname(lineagePath), { recursive: true });
+  await mkdir8(path34.dirname(lineagePath), { recursive: true });
   await writeFile8(lineagePath, JSON.stringify(lineage, null, 2) + "\n", "utf-8");
   return {
     archivePath: archiveAbs,
@@ -27013,11 +27825,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 = path33.resolve(targetRoot);
+  const rootAbs = path34.resolve(targetRoot);
   const rootReal = await realpath3(rootAbs).catch(() => rootAbs);
-  const lineagePath = path33.join(rootReal, "forks", forkId, "lineage.json");
-  const rel = path33.relative(rootReal, lineagePath);
-  if (rel.startsWith("..") || path33.isAbsolute(rel)) {
+  const lineagePath = path34.join(rootReal, "forks", forkId, "lineage.json");
+  const rel = path34.relative(rootReal, lineagePath);
+  if (rel.startsWith("..") || path34.isAbsolute(rel)) {
     return null;
   }
   if (!await isLineagePathContained(rootReal, lineagePath)) {
@@ -27058,19 +27870,19 @@ async function pathEntryExists(absPath) {
 async function isLineagePathContained(rootReal, lineagePath) {
   let existing = lineagePath;
   const suffix = [];
-  while (existing !== path33.dirname(existing)) {
+  while (existing !== path34.dirname(existing)) {
     const st = await lstat4(existing).catch(() => null);
     if (st !== null) break;
-    suffix.unshift(path33.basename(existing));
-    existing = path33.dirname(existing);
+    suffix.unshift(path34.basename(existing));
+    existing = path34.dirname(existing);
   }
   const existingReal = await realpath3(existing).catch(() => existing);
-  const targetReal = suffix.length > 0 ? path33.join(existingReal, ...suffix) : existingReal;
-  const rel = path33.relative(rootReal, targetReal);
+  const targetReal = suffix.length > 0 ? path34.join(existingReal, ...suffix) : existingReal;
+  const rel = path34.relative(rootReal, targetReal);
   if (rel === "") return true;
   if (rel === "..") return false;
-  if (rel.startsWith(`..${path33.sep}`)) return false;
-  if (path33.isAbsolute(rel)) return false;
+  if (rel.startsWith(`..${path34.sep}`)) return false;
+  if (path34.isAbsolute(rel)) return false;
   return true;
 }
 
@@ -27155,8 +27967,31 @@ 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,
+  queryTimelineRange,
+  queryTimelineSearch,
+  runTimelineCliCommand,
+  renderDeterministicJournal,
   isEligibleActivityFact,
   generateActivityMemories,
+  MS_PER_DAY2 as MS_PER_DAY,
+  parseActivityPrivacy,
+  shouldRetain,
+  observationsForExport,
   fuseMeeting,
   buildMeetingRecordsForDay,
   MeetingsBuilder,
@@ -27190,4 +28025,4 @@ export {
   blendGraphExpandedRecallScore,
   Orchestrator
 };
-//# sourceMappingURL=chunk-LKYIOCWL.js.map
+//# sourceMappingURL=chunk-TCF4MU7L.js.map