engrm 0.4.6 → 0.4.7

package/dist/hooks/stop.js

@@ -2,6 +2,39 @@
 import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// src/intelligence/observation-priority.ts
+var RECENCY_WINDOW_SECONDS = 30 * 86400;
+function computeBlendedScore(quality, createdAtEpoch, nowEpoch) {
+  const age = nowEpoch - createdAtEpoch;
+  const recencyNorm = Math.max(0, Math.min(1, 1 - age / RECENCY_WINDOW_SECONDS));
+  return quality * 0.6 + recencyNorm * 0.4;
+}
+function observationTypeBoost(type) {
+  switch (type) {
+    case "decision":
+      return 0.2;
+    case "pattern":
+      return 0.18;
+    case "bugfix":
+      return 0.14;
+    case "feature":
+      return 0.12;
+    case "discovery":
+      return 0.1;
+    case "refactor":
+      return 0.05;
+    case "digest":
+      return 0.03;
+    case "change":
+      return 0;
+    default:
+      return 0;
+  }
+}
+function computeObservationPriority(obs, nowEpoch) {
+  return computeBlendedScore(obs.quality, obs.created_at_epoch, nowEpoch) + observationTypeBoost(obs.type);
+}
+
 // src/capture/retrospective.ts
 function extractRetrospective(observations, sessionId, projectId, userId) {
   if (observations.length === 0)
@@ -26,13 +59,16 @@ function extractRetrospective(observations, sessionId, projectId, userId) {
   };
 }
 function extractRequest(observations) {
+  const requestCandidate = observations.find((obs) => ["decision", "feature", "change", "bugfix", "discovery"].includes(obs.type) && obs.title.trim().length > 0 && !looksLikeFileOperation(obs.title));
+  if (requestCandidate)
+    return requestCandidate.title;
   const first = observations[0];
-  if (!first)
+  if (!first || !first.title.trim())
     return null;
   return first.title;
 }
 function extractInvestigated(observations) {
-  const discoveries = observations.filter((o) => o.type === "discovery");
+  const discoveries = observations.filter((o) => o.type === "discovery").sort((a, b) => scoreNarrativeObservation(b) - scoreNarrativeObservation(a));
   if (discoveries.length === 0)
     return null;
   return formatObservationGroup(discoveries, {
@@ -42,7 +78,7 @@ function extractInvestigated(observations) {
 }
 function extractLearned(observations) {
   const learnTypes = new Set(["bugfix", "decision", "pattern"]);
-  const learned = observations.filter((o) => learnTypes.has(o.type));
+  const learned = observations.filter((o) => learnTypes.has(o.type)).sort((a, b) => scoreNarrativeObservation(b) - scoreNarrativeObservation(a));
   if (learned.length === 0)
     return null;
   return formatObservationGroup(learned, {
@@ -68,16 +104,18 @@ ${facts}` : `- ${title}`;
 function extractNextSteps(observations) {
   if (observations.length < 2)
     return null;
-  const lastQuarterStart = Math.floor(observations.length * 0.75);
+  const lastQuarterStart = Math.max(0, Math.min(observations.length - 1, observations.length - 3, Math.floor(observations.length * 0.75)));
   const lastQuarter = observations.slice(lastQuarterStart);
   const unresolved = lastQuarter.filter((o) => o.type === "bugfix" && o.narrative && /error|fail|exception/i.test(o.narrative));
-  if (unresolved.length === 0)
+  const explicitDecisions = lastQuarter.filter((o) => o.type === "decision").sort((a, b) => scoreNarrativeObservation(b) - scoreNarrativeObservation(a)).slice(0, 2).map((o) => `- Follow through: ${o.title}`);
+  if (unresolved.length === 0 && explicitDecisions.length === 0)
     return null;
-  return unresolved.map((o) => `- Investigate: ${o.title}`).slice(0, 3).join(`
+  const lines = unresolved.map((o) => `- Investigate: ${o.title}`).slice(0, 3).concat(explicitDecisions);
+  return dedupeBulletLines(lines).join(`
 `);
 }
 function formatObservationGroup(observations, options) {
-  const lines = dedupeObservationsByTitle(observations).slice(0, options.limit).map((o) => {
+  const lines = dedupeObservationsByTitle(observations).sort((a, b) => scoreNarrativeObservation(b) - scoreNarrativeObservation(a)).slice(0, options.limit).map((o) => {
     const facts = extractTopFacts(o, options.factsPerItem);
     return facts ? `- ${o.title}
 ${facts}` : `- ${o.title}`;
@@ -111,17 +149,24 @@ function dedupeObservationsByTitle(observations) {
   return deduped;
 }
 function scoreCompletedObservation(obs) {
-  let score = obs.quality || 0;
+  let score = scoreNarrativeObservation(obs);
   if (obs.type === "feature")
     score += 0.5;
   if (obs.type === "refactor")
     score += 0.2;
-  if (hasMeaningfulFacts(obs))
-    score += 0.4;
   if (looksLikeFileOperation(obs.title))
     score -= 0.6;
+  return score;
+}
+function scoreNarrativeObservation(obs) {
+  const nowEpoch = Math.floor(Date.now() / 1000);
+  let score = computeObservationPriority(obs, nowEpoch);
+  if (hasMeaningfulFacts(obs))
+    score += 0.4;
   if (obs.narrative && obs.narrative.length > 80)
     score += 0.2;
+  if (looksLikeFileOperation(obs.title))
+    score -= 0.25;
   return score;
 }
 function hasMeaningfulFacts(obs) {
@@ -1506,6 +1551,31 @@ function markFailed(db, entryId, error) {
       WHERE id = ?`).run(error, now, entryId);
 }
 
+// src/intelligence/value-signals.ts
+var LESSON_TYPES = new Set(["bugfix", "decision", "pattern"]);
+function computeSessionValueSignals(observations, securityFindings = []) {
+  const decisionsCount = observations.filter((o) => o.type === "decision").length;
+  const lessonsCount = observations.filter((o) => LESSON_TYPES.has(o.type)).length;
+  const discoveriesCount = observations.filter((o) => o.type === "discovery").length;
+  const featuresCount = observations.filter((o) => o.type === "feature").length;
+  const refactorsCount = observations.filter((o) => o.type === "refactor").length;
+  const repeatedPatternsCount = observations.filter((o) => o.type === "pattern").length;
+  const hasRequestSignal = observations.some((o) => ["feature", "decision", "change", "bugfix", "discovery"].includes(o.type));
+  const hasCompletionSignal = observations.some((o) => ["feature", "change", "refactor", "bugfix"].includes(o.type));
+  return {
+    decisions_count: decisionsCount,
+    lessons_count: lessonsCount,
+    discoveries_count: discoveriesCount,
+    features_count: featuresCount,
+    refactors_count: refactorsCount,
+    repeated_patterns_count: repeatedPatternsCount,
+    security_findings_count: securityFindings.length,
+    critical_security_findings_count: securityFindings.filter((f) => f.severity === "critical").length,
+    delivery_review_ready: hasRequestSignal && hasCompletionSignal,
+    vibe_guardian_active: securityFindings.length > 0
+  };
+}
+
 // src/sync/push.ts
 function buildVectorDocument(obs, config, project) {
   const parts = [obs.title];
@@ -1554,7 +1624,7 @@ function buildVectorDocument(obs, config, project) {
     }
   };
 }
-function buildSummaryVectorDocument(summary, config, project) {
+function buildSummaryVectorDocument(summary, config, project, observations = []) {
   const parts = [];
   if (summary.request)
     parts.push(`Request: ${summary.request}`);
@@ -1566,6 +1636,7 @@ function buildSummaryVectorDocument(summary, config, project) {
     parts.push(`Completed: ${summary.completed}`);
   if (summary.next_steps)
     parts.push(`Next Steps: ${summary.next_steps}`);
+  const valueSignals = computeSessionValueSignals(observations, []);
   return {
     site_id: config.site_id,
     namespace: config.namespace,
@@ -1584,6 +1655,19 @@ function buildSummaryVectorDocument(summary, config, project) {
       learned: summary.learned,
       completed: summary.completed,
       next_steps: summary.next_steps,
+      summary_sections_present: countPresentSections(summary),
+      investigated_items: extractSectionItems(summary.investigated),
+      learned_items: extractSectionItems(summary.learned),
+      completed_items: extractSectionItems(summary.completed),
+      next_step_items: extractSectionItems(summary.next_steps),
+      decisions_count: valueSignals.decisions_count,
+      lessons_count: valueSignals.lessons_count,
+      discoveries_count: valueSignals.discoveries_count,
+      features_count: valueSignals.features_count,
+      refactors_count: valueSignals.refactors_count,
+      repeated_patterns_count: valueSignals.repeated_patterns_count,
+      delivery_review_ready: valueSignals.delivery_review_ready,
+      vibe_guardian_active: valueSignals.vibe_guardian_active,
       created_at_epoch: summary.created_at_epoch,
       local_id: summary.id
     }
@@ -1613,10 +1697,11 @@ async function pushOutbox(db, client, config, batchSize = 50) {
         continue;
       }
       markSyncing(db, entry.id);
+      const summaryObservations = db.getObservationsBySession(summary.session_id);
       const doc2 = buildSummaryVectorDocument(summary, config, {
         canonical_id: project2.canonical_id,
         name: project2.name
-      });
+      }, summaryObservations);
       batch.push({ entryId: entry.id, doc: doc2 });
       continue;
     }
@@ -1675,6 +1760,21 @@ async function pushOutbox(db, client, config, batchSize = 50) {
   }
   return { pushed, failed, skipped };
 }
+function countPresentSections(summary) {
+  return [
+    summary.request,
+    summary.investigated,
+    summary.learned,
+    summary.completed,
+    summary.next_steps
+  ].filter((value) => Boolean(value && value.trim())).length;
+}
+function extractSectionItems(section) {
+  if (!section)
+    return [];
+  return section.split(`
+`).map((line) => line.trim()).filter(Boolean).map((line) => line.replace(/^[-*]\s*/, "").trim()).filter(Boolean).slice(0, 4);
+}
 
 // src/embeddings/embedder.ts
 var _available = null;
@@ -1847,6 +1947,77 @@ function detectStacks(filePaths) {
   return Array.from(stacks).sort();
 }
 
+// src/intelligence/session-insights.ts
+function computeSessionInsights(summaries, observations) {
+  const orderedSummaries = [...summaries].sort((a, b) => (b.created_at_epoch ?? 0) - (a.created_at_epoch ?? 0));
+  const summaryCount = orderedSummaries.length;
+  const summariesWithLearned = orderedSummaries.filter((s) => hasContent(s.learned)).length;
+  const summariesWithCompleted = orderedSummaries.filter((s) => hasContent(s.completed)).length;
+  const summariesWithNextSteps = orderedSummaries.filter((s) => hasContent(s.next_steps)).length;
+  const totalSummarySectionsPresent = orderedSummaries.reduce((total, summary) => total + countPresentSections2(summary), 0);
+  const recentRequests = dedupeLines(orderedSummaries.map((summary) => summary.request?.trim() ?? "").filter(Boolean)).slice(0, 3);
+  const recentLessons = dedupeLines([
+    ...orderedSummaries.flatMap((summary) => extractSectionItems2(summary.learned)),
+    ...extractObservationTitles(observations, ["decision", "pattern", "bugfix"])
+  ]).slice(0, 4);
+  const recentCompleted = dedupeLines([
+    ...orderedSummaries.flatMap((summary) => extractSectionItems2(summary.completed)),
+    ...extractObservationTitles(observations, ["feature", "refactor", "change"])
+  ]).slice(0, 4);
+  const nextSteps = dedupeLines([
+    ...orderedSummaries.flatMap((summary) => extractSectionItems2(summary.next_steps)),
+    ...extractObservationTitles(observations, ["decision"]).map((title) => `Follow through: ${title}`)
+  ]).slice(0, 4);
+  return {
+    summary_count: summaryCount,
+    summaries_with_learned: summariesWithLearned,
+    summaries_with_completed: summariesWithCompleted,
+    summaries_with_next_steps: summariesWithNextSteps,
+    total_summary_sections_present: totalSummarySectionsPresent,
+    recent_requests: recentRequests,
+    recent_lessons: recentLessons,
+    recent_completed: recentCompleted,
+    next_steps: nextSteps
+  };
+}
+function countPresentSections2(summary) {
+  return [
+    summary.request,
+    summary.investigated,
+    summary.learned,
+    summary.completed,
+    summary.next_steps
+  ].filter(hasContent).length;
+}
+function extractSectionItems2(section) {
+  if (!hasContent(section))
+    return [];
+  return section.split(`
+`).map((line) => line.trim()).filter(Boolean).map((line) => line.replace(/^[-*]\s*/, "").trim()).filter(Boolean);
+}
+function extractObservationTitles(observations, types) {
+  const typeSet = new Set(types);
+  return observations.filter((obs) => typeSet.has(obs.type)).sort((a, b) => b.created_at_epoch - a.created_at_epoch).map((obs) => obs.title.trim()).filter(Boolean);
+}
+function dedupeLines(lines) {
+  const seen = new Set;
+  const result = [];
+  for (const line of lines) {
+    const cleaned = line.replace(/\s+/g, " ").trim();
+    if (!cleaned)
+      continue;
+    const key = cleaned.toLowerCase();
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    result.push(cleaned);
+  }
+  return result;
+}
+function hasContent(value) {
+  return Boolean(value && value.trim());
+}
+
 // src/telemetry/beacon.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
 import { join as join3 } from "node:path";
@@ -1877,6 +2048,17 @@ function buildBeacon(db, config, sessionId, metrics) {
   for (const obs of observations) {
     byType[obs.type] = (byType[obs.type] ?? 0) + 1;
   }
+  let securityFindings = [];
+  try {
+    if (session.project_id) {
+      securityFindings = db.getSecurityFindings(session.project_id, { limit: 200 }).filter((f) => f.session_id === sessionId);
+    }
+  } catch {
+    securityFindings = [];
+  }
+  const valueSignals = computeSessionValueSignals(observations, securityFindings);
+  const summaries = session.project_id ? db.getRecentSummaries(session.project_id, 20).filter((summary) => summary.session_id === sessionId) : [];
+  const sessionInsights = computeSessionInsights(summaries, observations);
   const filePaths = [];
   for (const obs of observations) {
     if (obs.files_modified) {
@@ -1926,7 +2108,7 @@ function buildBeacon(db, config, sessionId, metrics) {
     observer_events: observerEvents,
     observer_observations: observerObservations,
     observer_skips: observerSkips,
-    sentinel_used: false,
+    sentinel_used: valueSignals.security_findings_count > 0,
     risk_score: riskScore,
     stacks_detected: stacks,
     client_version: "0.4.0",
@@ -1936,6 +2118,20 @@ function buildBeacon(db, config, sessionId, metrics) {
     recall_hits: metrics?.recallHits ?? 0,
     search_count: metrics?.searchCount ?? 0,
     search_results_total: metrics?.searchResultsTotal ?? 0,
+    decisions_count: valueSignals.decisions_count,
+    lessons_count: valueSignals.lessons_count,
+    discoveries_count: valueSignals.discoveries_count,
+    features_count: valueSignals.features_count,
+    refactors_count: valueSignals.refactors_count,
+    repeated_patterns_count: valueSignals.repeated_patterns_count,
+    security_findings_count: valueSignals.security_findings_count,
+    critical_security_findings_count: valueSignals.critical_security_findings_count,
+    delivery_review_ready: valueSignals.delivery_review_ready,
+    vibe_guardian_active: valueSignals.vibe_guardian_active,
+    summaries_with_learned: sessionInsights.summaries_with_learned,
+    summaries_with_completed: sessionInsights.summaries_with_completed,
+    summaries_with_next_steps: sessionInsights.summaries_with_next_steps,
+    total_summary_sections_present: sessionInsights.total_summary_sections_present,
     config_hash: configHash,
     config_changed: configChanged,
     config_fingerprint_detail: configFingerprintDetail
@@ -2315,6 +2511,80 @@ function findDuplicate(newTitle, candidates) {
   return bestMatch;
 }
 
+// src/capture/facts.ts
+var FACT_ELIGIBLE_TYPES = new Set([
+  "bugfix",
+  "decision",
+  "discovery",
+  "pattern",
+  "feature",
+  "refactor",
+  "change"
+]);
+function buildStructuredFacts(input) {
+  const seedFacts = dedupeFacts(input.facts ?? []);
+  if (!FACT_ELIGIBLE_TYPES.has(input.type)) {
+    return seedFacts;
+  }
+  const derived = [...seedFacts];
+  if (seedFacts.length === 0 && looksMeaningful(input.title)) {
+    derived.push(input.title.trim());
+  }
+  for (const sentence of extractNarrativeFacts(input.narrative)) {
+    derived.push(sentence);
+  }
+  const fileFact = buildFilesFact(input.filesModified);
+  if (fileFact) {
+    derived.push(fileFact);
+  }
+  return dedupeFacts(derived).slice(0, 4);
+}
+function extractNarrativeFacts(narrative) {
+  if (!narrative)
+    return [];
+  const cleaned = narrative.replace(/\s+/g, " ").trim();
+  if (cleaned.length < 24)
+    return [];
+  const parts = cleaned.split(/(?<=[.!?;])\s+/).map((part) => part.trim().replace(/[.!?;]+$/, "")).filter(Boolean).filter(looksMeaningful);
+  return parts.slice(0, 2);
+}
+function buildFilesFact(filesModified) {
+  if (!filesModified || filesModified.length === 0)
+    return null;
+  const cleaned = filesModified.map((file) => file.trim()).filter(Boolean).slice(0, 3);
+  if (cleaned.length === 0)
+    return null;
+  if (cleaned.length === 1) {
+    return `Touched ${cleaned[0]}`;
+  }
+  return `Touched ${cleaned.join(", ")}`;
+}
+function dedupeFacts(facts) {
+  const seen = new Set;
+  const result = [];
+  for (const fact of facts) {
+    const cleaned = fact.trim().replace(/\s+/g, " ");
+    if (!looksMeaningful(cleaned))
+      continue;
+    const key = cleaned.toLowerCase().replace(/\([^)]*\)/g, "").replace(/\s+/g, " ").trim();
+    if (!key || seen.has(key))
+      continue;
+    seen.add(key);
+    result.push(cleaned);
+  }
+  return result;
+}
+function looksMeaningful(value) {
+  const cleaned = value.trim();
+  if (cleaned.length < 12)
+    return false;
+  if (/^[A-Za-z0-9_.\-\/]+\.[A-Za-z0-9]+$/.test(cleaned))
+    return false;
+  if (/^(updated|modified|edited|changed|touched)\s+[A-Za-z0-9_.\-\/]+$/i.test(cleaned))
+    return false;
+  return true;
+}
+
 // src/capture/recurrence.ts
 var DISTANCE_THRESHOLD = 0.15;
 async function detectRecurrence(db, config, observation) {
@@ -2532,10 +2802,17 @@ async function saveObservation(db, config, input) {
   const customPatterns = config.scrubbing.enabled ? config.scrubbing.custom_patterns : [];
   const title = config.scrubbing.enabled ? scrubSecrets(input.title, customPatterns) : input.title;
   const narrative = input.narrative ? config.scrubbing.enabled ? scrubSecrets(input.narrative, customPatterns) : input.narrative : null;
-  const factsJson = input.facts ? config.scrubbing.enabled ? scrubSecrets(JSON.stringify(input.facts), customPatterns) : JSON.stringify(input.facts) : null;
   const conceptsJson = input.concepts ? JSON.stringify(input.concepts) : null;
   const filesRead = input.files_read ? input.files_read.map((f) => toRelativePath(f, cwd)) : null;
   const filesModified = input.files_modified ? input.files_modified.map((f) => toRelativePath(f, cwd)) : null;
+  const structuredFacts = buildStructuredFacts({
+    type: input.type,
+    title: input.title,
+    narrative: input.narrative,
+    facts: input.facts,
+    filesModified
+  });
+  const factsJson = structuredFacts.length > 0 ? config.scrubbing.enabled ? scrubSecrets(JSON.stringify(structuredFacts), customPatterns) : JSON.stringify(structuredFacts) : null;
   const filesReadJson = filesRead ? JSON.stringify(filesRead) : null;
   const filesModifiedJson = filesModified ? JSON.stringify(filesModified) : null;
   let sensitivity = input.sensitivity ?? config.scrubbing.default_sensitivity;