@remnic/core 9.16.2 → 9.17.0

package/dist/{chunk-YHURQ3M5.js → chunk-UH7VNQ7O.js}

@@ -1,16 +1,18 @@
 import {
   WEARABLE_SOURCE_PREFIX,
+  computeTrustScore,
+  decideSmart,
   defaultTimezone,
   loadSyncState,
   syncWearableSource,
   wearableSourceLabel
-} from "./chunk-5SB7SC2G.js";
+} from "./chunk-UX3ZXN34.js";
 import {
   CompressionGuidelineCoordinator
 } from "./chunk-JECBQBEX.js";
 import {
   MaintenanceScheduler
-} from "./chunk-V6LYAXGW.js";
+} from "./chunk-F7BWFIDK.js";
 import {
   runPeerProfileReasoner
 } from "./chunk-I74SUMNI.js";
@@ -238,7 +240,7 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-BTK2PIFL.js";
+} from "./chunk-GBT4TFV7.js";
 import {
   NamespaceCatalog,
   planNamespaceMaintenance
@@ -305,6 +307,9 @@ import {
   loadCorrectionsFile,
   saveCorrectionsFile
 } from "./chunk-NDAH7BJ5.js";
+import {
+  activityDayWindow
+} from "./chunk-MONWCSVL.js";
 import {
   buildRecallQueryPolicy
 } from "./chunk-LBJBNWS2.js";
@@ -13415,7 +13420,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-UZG3XQZ5.js");
+        const { startWearablesAutoSync } = await import("./auto-sync-IH3G25MT.js");
         if (signal.aborted) return;
         this.deps.wearablesAutoSyncHandle = startWearablesAutoSync(
           {
@@ -22926,6 +22931,262 @@ function publisherForConnector(connectorId) {
   return publisherFor(hostIdForConnector(connectorId));
 }
 
+// src/activity/memory-gen.ts
+var ACTIVITY_ALLOWED_CATEGORIES = {
+  decision: true,
+  commitment: true,
+  preference: true,
+  moment: true
+};
+var FIRST_PERSON = /\b(?:i|we|my|our|i['’]ve|we['’]ve)\b/i;
+var ATTRIBUTION_SPEAKER = String.raw`(?!(?:i|we|us|me|my|our)\b)[A-Za-z][\w.'’-]*`;
+var SPEECH_VERB = String.raw`(?:said|says|wrote|writes|posted|typed|asked|replied|messaged|commented|noted|announced|added|responded|mentioned|told)`;
+var VERB_ATTRIBUTION = new RegExp(String.raw`^\s*${ATTRIBUTION_SPEAKER}\s+${SPEECH_VERB}\b`, "i");
+var LABEL_ATTRIBUTION = new RegExp(
+  String.raw`^\s*(${ATTRIBUTION_SPEAKER}(?:\s+[A-Za-z][\w.'’-]*){0,3})\s*:\s*`,
+  "i"
+);
+var LABEL_NAMES_SENDER = /\b(?:from|by)\s+[A-Z][a-z]/;
+var NON_SENDER_LABELS = {
+  note: true,
+  notes: true,
+  todo: true,
+  fixme: true,
+  reminder: true,
+  update: true,
+  updates: true,
+  warning: true,
+  info: true,
+  tip: true,
+  tips: true,
+  summary: true,
+  status: true,
+  tldr: true,
+  fyi: true,
+  idea: true,
+  goal: true,
+  goals: true,
+  plan: true,
+  plans: true,
+  action: true,
+  actions: true,
+  context: true,
+  question: true
+};
+var TRUST_ATTRIBUTE_KEYS = {
+  trustscore: true,
+  trustdecision: true,
+  judgeverdict: true
+};
+function isEligibleActivityFact(fact) {
+  if (ACTIVITY_ALLOWED_CATEGORIES[fact.category] !== true) return false;
+  if (!FIRST_PERSON.test(fact.content)) return false;
+  if (VERB_ATTRIBUTION.test(fact.content)) return false;
+  const label = LABEL_ATTRIBUTION.exec(fact.content);
+  if (label !== null) {
+    const labelText = label[1].trim();
+    const firstToken = labelText.split(/\s+/)[0].toLowerCase();
+    if (NON_SENDER_LABELS[firstToken] !== true || LABEL_NAMES_SENDER.test(labelText)) return false;
+  }
+  return true;
+}
+function composeSalvagedActivityEnvelope(input, ctx) {
+  const envelope = composeMemoryEnvelope(input, ctx, { salvage: true });
+  if (envelope.salvageNotes.length > 0) {
+    log.warn(`activity write salvaged invalid fields: ${envelope.salvageNotes.join("; ")}`);
+  }
+  return envelope;
+}
+async function generateActivityMemories(date, digestBody, config, deps) {
+  const result = {
+    created: 0,
+    promoted: 0,
+    demoted: 0,
+    pendingReview: 0,
+    rejectedDisplayedContent: 0,
+    rejectedByJudge: 0,
+    skipped: 0
+  };
+  if (config.extractionMode !== "smart" || digestBody.trim().length === 0) return result;
+  const { startUtc, endUtc } = activityDayWindow(date, config.timezone);
+  let extracted;
+  try {
+    extracted = await deps.extract(digestBody);
+  } catch (err) {
+    log.warn(
+      `activity extraction failed; skipping the day's memory pass: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return result;
+  }
+  if (extracted.extractionFailure !== void 0) {
+    log.warn(
+      `activity extraction reported a failure; skipping the day's memory pass: ${extracted.extractionFailure}`
+    );
+    return result;
+  }
+  const candidates = extracted.facts.filter((fact) => {
+    if (!isEligibleActivityFact(fact)) {
+      result.rejectedDisplayedContent += 1;
+      return false;
+    }
+    const importance = scoreImportance(fact.content, fact.category, fact.tags);
+    if (!Number.isFinite(fact.confidence) || fact.confidence < config.minConfidence || !isAboveImportanceThreshold(importance.level, config.minImportance)) {
+      result.skipped += 1;
+      return false;
+    }
+    return true;
+  });
+  let verdicts;
+  try {
+    verdicts = await deps.judge(candidates.map((fact) => ({
+      text: fact.content,
+      category: fact.category,
+      confidence: fact.confidence,
+      tags: fact.tags,
+      importanceLevel: scoreImportance(fact.content, fact.category, fact.tags).level
+    })));
+  } catch (err) {
+    log.warn(
+      `activity extraction judge unavailable; using trust scoring only: ${err instanceof Error ? err.message : String(err)}`
+    );
+    verdicts = /* @__PURE__ */ new Map();
+  }
+  const strongestByKey = /* @__PURE__ */ new Map();
+  for (let index = 0; index < candidates.length; index += 1) {
+    const fact = candidates[index];
+    const verdict = verdicts.get(index);
+    const verdictKind = verdict === void 0 ? void 0 : getVerdictKind(verdict);
+    const trust = computeTrustScore({
+      extractionConfidence: fact.confidence,
+      sourceTrust: config.sourceTrust,
+      judgeVerdict: verdictKind,
+      evidence: { corroboratedBySources: [] }
+    });
+    const decision = decideSmart(trust, verdictKind, {
+      autoApproveTrust: config.autoApproveTrust,
+      reviewTrust: config.reviewTrust
+    });
+    const key = fact.content.trim().toLowerCase();
+    const scored = {
+      fact,
+      key,
+      trust,
+      verdictKind,
+      decision,
+      importance: scoreImportance(fact.content, fact.category, fact.tags)
+    };
+    const prev = strongestByKey.get(key);
+    if (prev === void 0) {
+      strongestByKey.set(key, scored);
+    } else {
+      result.skipped += 1;
+      const rankOf = (outcome) => outcome === "active" ? 2 : outcome === "review" ? 1 : 0;
+      const curRank = rankOf(scored.decision.outcome);
+      const prevRank = rankOf(prev.decision.outcome);
+      if (curRank > prevRank || curRank === prevRank && trust > prev.trust) {
+        strongestByKey.set(key, scored);
+      }
+    }
+  }
+  const writable = [];
+  for (const scored of strongestByKey.values()) {
+    const existing = await deps.writer.findActivityMemoryByContent(scored.key, startUtc, endUtc);
+    if (existing !== null) {
+      if (existing.status === "pending_review") {
+        if (scored.decision.outcome === "drop" && scored.decision.reason === "judge-rejected") {
+          if (await deps.writer.demoteActivityMemory(existing.id, {
+            trustScore: scored.trust.toFixed(3),
+            trustDecision: "demoted-by-rejection",
+            judgeVerdict: "reject"
+          })) {
+            result.demoted += 1;
+            continue;
+          }
+        } else if (scored.decision.outcome === "active") {
+          if (await deps.writer.promoteActivityMemory(
+            existing.id,
+            {
+              trustScore: scored.trust.toFixed(3),
+              trustDecision: "promoted-by-reassessment",
+              ...scored.verdictKind !== void 0 ? { judgeVerdict: scored.verdictKind } : {}
+            },
+            scored.trust
+          )) {
+            result.promoted += 1;
+            continue;
+          }
+        }
+      }
+      result.skipped += 1;
+      continue;
+    }
+    if (scored.decision.outcome === "drop") {
+      if (scored.decision.reason === "judge-rejected") result.rejectedByJudge += 1;
+      else result.skipped += 1;
+      continue;
+    }
+    writable.push({
+      fact: scored.fact,
+      key: scored.key,
+      status: scored.decision.outcome === "active" ? "active" : "pending_review",
+      trust: scored.trust,
+      trustDecision: scored.decision.reason,
+      ...scored.verdictKind !== void 0 ? { judgeVerdict: scored.verdictKind } : {},
+      importance: scored.importance
+    });
+  }
+  writable.sort((a, b) => {
+    if (a.trust !== b.trust) return b.trust - a.trust;
+    return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+  });
+  const alreadyWritten = config.maxMemoriesPerDay > 0 ? await deps.writer.countActivityMemoriesForDay(startUtc, endUtc) : 0;
+  let remaining = config.maxMemoriesPerDay > 0 ? Math.max(0, config.maxMemoriesPerDay - alreadyWritten) : Number.POSITIVE_INFINITY;
+  for (const entry of writable) {
+    if (remaining <= 0) {
+      result.skipped += 1;
+      continue;
+    }
+    const structuredAttributes = {
+      trustScore: entry.trust.toFixed(3),
+      trustDecision: entry.trustDecision,
+      ...entry.judgeVerdict !== void 0 ? { judgeVerdict: entry.judgeVerdict } : {}
+    };
+    for (const [key, value] of Object.entries(entry.fact.structuredAttributes ?? {})) {
+      if (TRUST_ATTRIBUTE_KEYS[key.trim().toLowerCase()] !== true) structuredAttributes[key] = value;
+    }
+    const envelope = composeSalvagedActivityEnvelope(
+      {
+        content: entry.fact.content,
+        category: entry.fact.category,
+        tags: [...entry.fact.tags, "activity"],
+        entityRef: entry.fact.entityRef,
+        // Persist the decision-derived trust as confidence; extractor attributes
+        // ride along, with trust score/decision + judge verdict added last so
+        // downstream sees the active/pending rationale (wearable-path parity).
+        confidence: entry.trust,
+        validAt: startUtc,
+        structuredAttributes,
+        sourceConnector: "activity",
+        sourceReason: "screen activity digest"
+      },
+      { source: "activity", now: deps.now }
+    );
+    const write = await deps.writer.writeSealedMemory(envelope, {
+      status: entry.status,
+      contentHashSource: entry.key,
+      importance: entry.importance
+    });
+    if (write.tombstoneBlocked) {
+      result.skipped += 1;
+      continue;
+    }
+    if (entry.status === "active") result.created += 1;
+    else result.pendingReview += 1;
+    remaining -= 1;
+  }
+  return result;
+}
+
 // src/meetings/detect.ts
 import { createHash as createHash9 } from "crypto";
 var DEFAULT_MEETING_APP_PATTERNS = [
@@ -24180,6 +24441,8 @@ export {
   ensureBuiltInWearableConnectors,
   WearablesService,
   locateTranscriptPath,
+  isEligibleActivityFact,
+  generateActivityMemories,
   DEFAULT_MEETING_APP_PATTERNS,
   DEFAULT_MEETINGS_DETECTION_CONFIG,
   meetingId,
@@ -24199,4 +24462,4 @@ export {
   blendGraphExpandedRecallScore,
   Orchestrator
 };
-//# sourceMappingURL=chunk-YHURQ3M5.js.map
+//# sourceMappingURL=chunk-UH7VNQ7O.js.map