agentboss 0.1.0 → 0.1.2

package/server/analysis/job.js

@@ -27,27 +27,77 @@ const { aggregateDailySummary } = require('./daily-aggregator');
 /**
  * Build a list of YYYY-MM-DD strings starting from today going back
  * `days` days, ordered most-recent first.  Today is included so the
- * current day's sessions get scored too; sessions that keep growing
- * after being scored are re-picked by getUnanalyzedSessions (ended_at
- * newer than analyzed_at).
+ * Today is EXCLUDED — sessions on the current calendar day are still
+ * actively being held (judge / advice analysing them would race against
+ * the user typing more messages, churn the cache, and waste LLM calls).
+ * Yesterday + N earlier days only.  Callers who really want to (re)
+ * analyze today must pass `dates: ['YYYY-MM-DD']` explicitly to
+ * runAnalysisJob, or use the per-session reanalyze endpoint
+ * (`POST /api/analysis/session/:id`) which bypasses this path.
  *
- * @param {number} days
+ * Default `days = 7` therefore produces 7 dates (yesterday through 7
+ * days ago), not 8.
+ *
+ * @param {number} days  number of past days to include (yesterday-anchored)
  * @returns {string[]}
  */
 function buildDateList(days) {
   const dates = [];
   const now = new Date();
-  for (let i = 0; i <= days; i++) {
+  // Start at i=1 → yesterday; end at i=days inclusive → `days` total dates.
+  for (let i = 1; i <= days; i++) {
     const d = new Date(now);
     d.setDate(d.getDate() - i);
-    const yyyy = d.getFullYear();
-    const mm = String(d.getMonth() + 1).padStart(2, '0');
-    const dd = String(d.getDate()).padStart(2, '0');
-    dates.push(`${yyyy}-${mm}-${dd}`);
+    dates.push(formatDate(d));
   }
   return dates; // already most-recent first
 }
 
+/**
+ * Local-time YYYY-MM-DD for a Date.  Must match buildDateList so the
+ * "today" string we compute lines up with the date strings we iterate.
+ */
+function formatDate(d) {
+  const yyyy = d.getFullYear();
+  const mm = String(d.getMonth() + 1).padStart(2, '0');
+  const dd = String(d.getDate()).padStart(2, '0');
+  return `${yyyy}-${mm}-${dd}`;
+}
+
+/**
+ * Pick the id of the "currently active" session for `date` — defined
+ * (per user spec) as the today-bucket session with the largest
+ * ended_at.  Returns null if `date` isn't today or the bucket is empty.
+ * We skip this session in the job so we don't analyze a still-growing
+ * conversation; the next job pass will pick it up once it settles.
+ *
+ * Note: the default invocation of runAnalysisJob no longer includes
+ * today at all (see buildDateList).  This function only fires when a
+ * caller explicitly passes `dates` that includes today — in which case
+ * we still shield the actively-typed-in session.
+ *
+ * @param {object} db
+ * @param {string} date  YYYY-MM-DD
+ * @param {object[]} sessions  candidate session rows for that date
+ * @returns {string|null}  session_id to skip, or null
+ */
+function pickCurrentSessionId(db, date, sessions) {
+  const today = formatDate(new Date());
+  if (date !== today) return null;
+  // Compare against ALL today's sessions (not just unanalyzed) so a
+  // fully-analyzed but freshly-touched session still counts as "current"
+  // and shields a slightly older still-running session from being
+  // wrongly considered the active one.
+  const allToday = getSessionsByDate(db, today);
+  const pool = allToday.length > 0 ? allToday : sessions;
+  let best = null;
+  for (const s of pool) {
+    if (!s.ended_at) continue;
+    if (!best || s.ended_at > best.ended_at) best = s;
+  }
+  return best ? best.id : null;
+}
+
 // ---------------------------------------------------------------------------
 // Per-session analyze + persist (shared by the job loop and the
 // per-session reanalyze endpoint)
@@ -119,7 +169,24 @@ async function analyzeAndStoreSession(db, session, opts = {}) {
 
 /**
  * Run analysis job: analyze unanalyzed sessions in reverse chronological order.
- * Default: last 7 days. Processes one date at a time, most recent first.
+ *
+ * # Today policy
+ *
+ * Default invocation ({days}) skips TODAY entirely — sessions on the
+ * current calendar day are likely still being held, and analysing
+ * them now means churning the LLM cache for results that will be stale
+ * within minutes.  The boot path (bin/aboss.js) uses this default, so
+ * "open aboss → background scan" never touches today.
+ *
+ * Two escape hatches keep today analysable when the user really asks:
+ *   - `dates: ['YYYY-MM-DD']` explicit list → not filtered.  Used by
+ *     manual triggers that pass a specific date set.
+ *   - `POST /api/analysis/session/:id` → goes straight through
+ *     `analyzeAndStoreSession`, doesn't use this job loop, so today's
+ *     "Re-analyze" button in the UI keeps working.
+ *
+ * Default: last 7 days (yesterday → 7 days ago).  Processes one date at
+ * a time, most recent first.
  *
  * @param {object} db - sql.js boss.db instance
  * @param {object} options - {
@@ -127,6 +194,7 @@ async function analyzeAndStoreSession(db, session, opts = {}) {
  *   onProgress: fn,
  *   forceReanalyze: false,
  *   dates: string[]  // optional explicit YYYY-MM-DD list; overrides `days`
+ *                    // AND bypasses the "skip today" rule
  * }
  * @returns {Promise<{analyzed: number, errors: number, skipped: number}>}
  */
@@ -154,13 +222,15 @@ async function runAnalysisJob(db, options = {}) {
     : buildDateList(days);
 
   try {
-    // Pre-calculate total count for progress reporting
+    // Pre-calculate total count for progress reporting.  Subtract the
+    // "current" (still-running) session if it falls in the candidate set.
     let totalSessions = 0;
     for (const date of dates) {
       const sessions = forceReanalyze
         ? getSessionsByDate(db, date)
         : getUnanalyzedSessions(db, date);
-      totalSessions += sessions.length;
+      const skipId = pickCurrentSessionId(db, date, sessions);
+      totalSessions += sessions.filter((s) => s.id !== skipId).length;
     }
 
     updateAnalysisState(db, {
@@ -181,10 +251,17 @@ async function runAnalysisJob(db, options = {}) {
         last_analyzed_at: null,
       });
 
-      // 2a. Get unanalyzed sessions for this date
-      const sessions = forceReanalyze
+      // 2a. Get unanalyzed sessions for this date, minus the currently-
+      // active session (today's session with the largest ended_at).  We
+      // skip it so the job doesn't score a conversation that's still
+      // being written to — the next pass will catch it.
+      const rawSessions = forceReanalyze
         ? getSessionsByDate(db, date)
         : getUnanalyzedSessions(db, date);
+      const skipId = pickCurrentSessionId(db, date, rawSessions);
+      const sessions = skipId
+        ? rawSessions.filter((s) => s.id !== skipId)
+        : rawSessions;
 
       if (sessions.length === 0) {
         result.skipped++;