thumbgate 1.14.1 → 1.16.0

package/scripts/contextfs.js

@@ -605,6 +605,137 @@ function selectFlatContextItems(candidates, maxItems, maxChars) {
   };
 }
 
+/* ── Summarize-then-expand selection ───────────────────────────────
+ *
+ * Two-pass retrieval that front-loads recall, then spends remaining char
+ * budget on depth for the highest-scoring candidates.
+ *
+ *   Pass 1 — breadth. Walk the ranked candidate list and add each as a
+ *   compact "summary tier" item: title + one-line hint drawn from the
+ *   structured fields (whatToChange / whatWentWrong / first content line).
+ *   A summary is small and bounded (SUMMARY_HINT_MAX chars), so many fit in
+ *   a fraction of the budget. Stops when maxItems or a summary-reservation
+ *   budget cap (SUMMARY_RESERVE_FRACTION of maxChars) is hit — this protects
+ *   enough headroom for Pass 2 to actually do something.
+ *
+ *   Pass 2 — depth. Walk the selected list top-down and try to upgrade each
+ *   summary to the full structured context. The upgrade cost is the delta
+ *   between full doc chars and the summary we already accounted for; if it
+ *   fits under the *overall* maxChars, swap the summary for the full item
+ *   and tag it tier='expanded'. Stop when the budget is exhausted.
+ *
+ * Rationale: the flat selector overcommits chars on the first few full-size
+ * hits and silently drops the tail. Summarize-then-expand means a consumer
+ * always knows which docs matched (full roster of titles), and the model
+ * sees full context for the top answers.
+ *
+ * The option is wired into constructContextPack via `strategy` or the
+ * explicit `summarizeThenExpand` flag. Default behavior is unchanged so
+ * existing callers / tests don't shift.
+ */
+
+const SUMMARY_HINT_MAX = 160;
+const SUMMARY_RESERVE_FRACTION = 0.35;
+
+function buildSummaryContext(doc) {
+  const full = buildStructuredContext(doc);
+  // Priority: explicit whatToChange > whatWentWrong > reasoning > first
+  // non-empty content line. We truncate aggressively because a summary's
+  // purpose is to fit dozens per pack, not to win a precision test.
+  const hint = (
+    full.whatToChange
+    || full.whatWentWrong
+    || full.reasoning
+    || (doc.content || '').split('\n').map((l) => l.trim()).find(Boolean)
+    || ''
+  ).slice(0, SUMMARY_HINT_MAX);
+  return {
+    rawContent: hint,
+    reasoning: null,
+    whatWentWrong: null,
+    whatToChange: null,
+    rubricFailure: null,
+  };
+}
+
+function measureSummaryChars(doc) {
+  const hint = buildSummaryContext(doc).rawContent;
+  return `${doc.title || ''}\n${hint}`.length;
+}
+
+function selectSummarizeThenExpand(candidates, maxItems, maxChars) {
+  // Pass 1 — breadth. Pack summaries greedily under a share of the budget.
+  const summaryBudget = Math.max(
+    Math.floor(maxChars * SUMMARY_RESERVE_FRACTION),
+    measureSummaryChars({ title: '', content: '' }) + 1,
+  );
+  const selected = [];
+  let usedChars = 0;
+  let skippedByMaxChars = 0;
+
+  for (const item of candidates) {
+    if (selected.length >= maxItems) break;
+
+    const summaryLen = measureSummaryChars(item.doc);
+    if (usedChars + summaryLen > summaryBudget) {
+      skippedByMaxChars += 1;
+      continue;
+    }
+
+    selected.push({
+      id: item.doc.id,
+      namespace: item.doc.namespace,
+      title: item.doc.title,
+      structuredContext: buildSummaryContext(item.doc),
+      tags: item.doc.tags || [],
+      score: item.score,
+      tier: 'summary',
+      _doc: item.doc,
+      _summaryLen: summaryLen,
+    });
+    usedChars += summaryLen;
+  }
+
+  // Pass 2 — depth. Upgrade top-ranked summaries to full items while the
+  // overall char budget can absorb the delta. Walks in current (score) order
+  // so the most relevant docs are expanded first.
+  let expandedCount = 0;
+  for (const entry of selected) {
+    const fullLen = measureDocumentChars(entry._doc);
+    const delta = fullLen - entry._summaryLen;
+    if (delta <= 0) continue; // already at or under summary size; leave it.
+    if (usedChars + delta > maxChars) continue;
+
+    entry.structuredContext = buildStructuredContext(entry._doc);
+    entry.tier = 'expanded';
+    usedChars += delta;
+    expandedCount += 1;
+  }
+
+  // Strip the private helpers before returning — they're builder-only state.
+  const items = selected.map(({ _doc, _summaryLen, ...rest }) => rest);
+
+  return {
+    items,
+    usedChars,
+    skippedByMaxChars,
+    retrieval: {
+      strategy: 'summarize-then-expand',
+      themeCount: 0,
+      semanticCount: 0,
+      selectedThemes: [],
+      selectedSemanticGroups: [],
+      representativeCount: items.length,
+      expandedEpisodes: expandedCount,
+      summaryCount: items.length - expandedCount,
+      summaryBudget,
+      queryCoverage: null,
+      initialCoverage: null,
+      coverageTarget: null,
+    },
+  };
+}
+
 /* ── Memex-style Indexed Memory ────────────────────────────────── */
 
 const MEMEX_INDEX_FILE = 'memex-index.jsonl';
@@ -750,17 +881,38 @@ function constructMemexPack({ query = '', maxItems = 8, maxChars = 6000, namespa
   return pack;
 }
 
-function constructContextPack({ query = '', maxItems = 8, maxChars = 6000, namespaces = [] } = {}) {
+function constructContextPack({
+  query = '',
+  maxItems = 8,
+  maxChars = 6000,
+  namespaces = [],
+  strategy = null,
+  summarizeThenExpand = false,
+} = {}) {
   const normalizedNamespaces = normalizeNamespaces(namespaces);
   const tokens = tokenizeQuery(query);
   const sourceHash = getSourceHash(normalizedNamespaces);
 
-  const cacheHit = findSemanticCacheHit({
-    query,
-    namespaces: normalizedNamespaces,
-    maxItems,
-    maxChars,
-  });
+  // Resolve the effective strategy. Explicit `strategy` wins; otherwise
+  // `summarizeThenExpand: true` flips the flag. Default remains auto
+  // (flat | hierarchical) so callers that don't opt in keep their cached
+  // packs addressable.
+  const effectiveStrategy = strategy
+    || (summarizeThenExpand ? 'summarize-then-expand' : null);
+
+  // Skip the semantic cache for summarize-then-expand packs. The cache key
+  // is (namespaces, maxItems, maxChars) — it doesn't include the strategy,
+  // so a cached flat pack would be served to an STE caller (and vice versa)
+  // with the wrong shape. Cheaper to recompute than to extend the cache key
+  // and invalidate every entry on disk.
+  const cacheHit = effectiveStrategy === 'summarize-then-expand'
+    ? null
+    : findSemanticCacheHit({
+      query,
+      namespaces: normalizedNamespaces,
+      maxItems,
+      maxChars,
+    });
 
   if (cacheHit) {
     const packId = `pack_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
@@ -796,25 +948,51 @@ function constructContextPack({ query = '', maxItems = 8, maxChars = 6000, names
     .sort((a, b) => b.score - a.score);
 
   const hierarchicalRetrievalEnabled = shouldUseHierarchicalRetrieval(normalizedNamespaces);
-  const selection = hierarchicalRetrievalEnabled
-    ? retrieveHierarchicalDocuments({
+  let selection;
+  if (effectiveStrategy === 'summarize-then-expand') {
+    // Explicit opt-in: bypass the hierarchical path entirely. The
+    // summarize-then-expand selector assumes a flat ranked list where each
+    // item is a single episode, and mixing it with theme-based hierarchical
+    // retrieval would double-compress the top-of-list.
+    selection = selectSummarizeThenExpand(candidates, maxItems, maxChars);
+  } else if (hierarchicalRetrievalEnabled) {
+    selection = retrieveHierarchicalDocuments({
       documents: candidates.map((candidate) => candidate.doc),
       query,
       maxItems,
       maxChars,
       scorer: scoreDocument,
       measureDocument: measureDocumentChars,
-    })
-    : selectFlatContextItems(candidates, maxItems, maxChars);
+    });
+  } else {
+    selection = selectFlatContextItems(candidates, maxItems, maxChars);
+  }
 
-  const selected = selection.items.map((doc) => ({
-    id: doc.id,
-    namespace: doc.namespace,
-    title: doc.title,
-    structuredContext: buildStructuredContext(doc),
-    tags: doc.tags || [],
-    score: scoreDocument(doc, tokens),
-  }));
+  // The flat + hierarchical paths emit raw docs; summarize-then-expand emits
+  // fully-shaped items that already carry structuredContext and a `tier`
+  // marker. Detect the shape so we don't double-canonicalize STE items
+  // (which would re-expand every summary into full content).
+  const selected = selection.items.map((item) => {
+    if (item && item.structuredContext) {
+      return {
+        id: item.id,
+        namespace: item.namespace,
+        title: item.title,
+        structuredContext: item.structuredContext,
+        tags: item.tags || [],
+        score: typeof item.score === 'number' ? item.score : scoreDocument(item, tokens),
+        ...(item.tier ? { tier: item.tier } : {}),
+      };
+    }
+    return {
+      id: item.id,
+      namespace: item.namespace,
+      title: item.title,
+      structuredContext: buildStructuredContext(item),
+      tags: item.tags || [],
+      score: scoreDocument(item, tokens),
+    };
+  });
   const usedChars = selection.usedChars;
   const skippedByMaxChars = selection.skippedByMaxChars;
 
@@ -848,19 +1026,23 @@ function constructContextPack({ query = '', maxItems = 8, maxChars = 6000, names
   };
 
   appendJsonl(contextFsPath(NAMESPACES.provenance, 'packs.jsonl'), pack);
-  appendSemanticCacheEntry({
-    id: `cache_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-    timestamp: nowIso(),
-    key: buildSemanticCacheKey({
-      namespaces: normalizedNamespaces,
-      maxItems,
-      maxChars,
-    }),
-    query,
-    tokens,
-    sourceHash,
-    pack,
-  });
+  // Symmetric with the cache read: don't persist STE packs into the shared
+  // semantic cache because the cache key is strategy-agnostic.
+  if (effectiveStrategy !== 'summarize-then-expand') {
+    appendSemanticCacheEntry({
+      id: `cache_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      timestamp: nowIso(),
+      key: buildSemanticCacheKey({
+        namespaces: normalizedNamespaces,
+        maxItems,
+        maxChars,
+      }),
+      query,
+      tokens,
+      sourceHash,
+      pack,
+    });
+  }
   recordProvenance({
     type: 'context_pack_constructed',
     packId,

package/scripts/dashboard-render-spec.js

@@ -243,7 +243,7 @@ function buildIncidentReviewSpec(data) {
         badge: String(gate.action || 'block').toUpperCase(),
         tone: gate.action === 'warn' ? 'info' : 'warning',
       })),
-      'No active gates configured.'
+      'No active checks configured.'
     ),
     buildList(
       'Root cause clusters',

package/scripts/dashboard.js

@@ -6,16 +6,36 @@ const path = require('path');
 const { aggregateFailureDiagnostics } = require('./failure-diagnostics');
 const { AUDIT_LOG_FILENAME } = require('./audit-trail');
 const { getBillingSummary, loadFunnelLedger, loadResolvedRevenueEvents } = require('./billing');
+const {
+  createUnavailableReport,
+  loadOptionalModule,
+} = require('./private-core-boundary');
 const { getTelemetryAnalytics, loadTelemetryEvents } = require('./telemetry-analytics');
 const { getAutoGatesPath } = require('./auto-promote-gates');
-const { summarizeDelegation } = require('./delegation-runtime');
 const { loadGatesConfig } = require('./gates-engine');
 const { filterEntriesForWindow, resolveAnalyticsWindow } = require('./analytics-window');
 const { resolveHostedBillingConfig } = require('./hosted-config');
 const { generateAgentReadinessReport } = require('./agent-readiness');
 const { summarizeGateTemplates } = require('./gate-templates');
-const { generateOrgDashboard } = require('./org-dashboard');
-const { buildPredictiveInsights } = require('./predictive-insights');
+const { buildPredictiveInsights } = loadOptionalModule('./predictive-insights', () => ({
+  buildPredictiveInsights: () => ({
+    upgradePropensity: {
+      pro: { band: 'unavailable', score: 0 },
+      team: { band: 'unavailable', score: 0 },
+    },
+    revenueForecast: {
+      predictedBookedRevenueCents: 0,
+      incrementalOpportunityCents: 0,
+    },
+    anomalySummary: {
+      count: 0,
+      severity: 'none',
+    },
+    topCreators: [],
+    topSources: [],
+    ...createUnavailableReport('Predictive insights'),
+  }),
+}));
 const { routeProfile } = require('./profile-router');
 const { getSettingsStatus } = require('./settings-hierarchy');
 const { summarizeWorkflowRuns } = require('./workflow-runs');
@@ -28,6 +48,40 @@ const DEFAULT_GATES_PATH = path.join(PROJECT_ROOT, 'config', 'gates', 'default.j
 const LANDING_PAGE_PATH = path.join(PROJECT_ROOT, 'public', 'index.html');
 const DASHBOARD_REVIEW_STATE_FILE = 'dashboard-review-state.json';
 
+function loadOrgDashboardModule() {
+  const modulePath = path.resolve(__dirname, 'org-dashboard.js');
+  if (!fs.existsSync(modulePath)) return null;
+  return loadOptionalModule('./org-dashboard', () => ({
+    generateOrgDashboard: ({ windowHours } = {}) => buildUnavailableOrgDashboard(windowHours || 24),
+  }));
+}
+
+function loadDelegationRuntimeModule() {
+  const modulePath = path.resolve(__dirname, 'delegation-runtime.js');
+  if (!fs.existsSync(modulePath)) return null;
+  return require(modulePath);
+}
+
+function buildUnavailableOrgDashboard(windowHours) {
+  return {
+    available: false,
+    windowHours,
+    totalAgents: 0,
+    activeAgents: 0,
+    totalToolCalls: 0,
+    totalBlocked: 0,
+    totalWarned: 0,
+    totalAllowed: 0,
+    orgAdherenceRate: 100,
+    topBlockedGates: [],
+    riskAgents: [],
+    agents: [],
+    proRequired: true,
+    upgradeMessage: 'Org dashboard is available only in the private ThumbGate Core runtime (ThumbGate-Core).',
+    availability: 'private_core',
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Data readers
 // ---------------------------------------------------------------------------
@@ -665,6 +719,197 @@ function countCoverage(entries, resolver) {
   return safeRate(matched, entries.length);
 }
 
+function sumCounterValues(counter = {}) {
+  return Object.values(counter).reduce((sum, value) => sum + (Number(value) || 0), 0);
+}
+
+function sumKeysMatching(counter = {}, matcher) {
+  return Object.entries(counter).reduce((sum, entry) => {
+    const [key, value] = entry;
+    return matcher(key) ? sum + (Number(value) || 0) : sum;
+  }, 0);
+}
+
+function rankCounter(counter = {}, limit = 5) {
+  return Object.entries(counter)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, limit)
+    .map(([key, count]) => ({ key, count }));
+}
+
+function mapBuyerLossTheme(reasonCode) {
+  const normalized = String(reasonCode || 'unknown').toLowerCase();
+  if (['too_expensive', 'price_shock', 'budget', 'need_budget_approval'].includes(normalized)) {
+    return 'pricing';
+  }
+  if (['need_more_proof', 'trust_gap', 'security_unclear'].includes(normalized)) {
+    return 'trust';
+  }
+  if (['not_ready', 'later', 'just_researching'].includes(normalized)) {
+    return 'timing';
+  }
+  if (['need_team_features', 'need_team_approval'].includes(normalized)) {
+    return 'team';
+  }
+  if (['integration_unclear', 'setup_confusing'].includes(normalized)) {
+    return 'integration';
+  }
+  if (['prefer_oss'].includes(normalized)) {
+    return 'open_source';
+  }
+  return 'unknown';
+}
+
+function buildLossAnalysis(analytics) {
+  const telemetry = analytics.telemetry || {};
+  const visitors = telemetry.visitors || {};
+  const ctas = telemetry.ctas || {};
+  const behavior = telemetry.behavior || {};
+  const buyerLoss = analytics.buyerLoss || {};
+  const conversionFunnel = telemetry.conversionFunnel || {};
+  const runtimeConfig = resolveHostedBillingConfig();
+  const monthlyPriceCents = Math.round((Number(runtimeConfig.proPriceDollars) || 19) * 100);
+  const pageViews = visitors.pageViews || 0;
+  const checkoutStarts = ctas.checkoutStarts || 0;
+  const paidOrders = analytics.funnel ? analytics.funnel.paidOrders || 0 : 0;
+  const trialEmails = conversionFunnel.trialEmails || 0;
+  const explicitReasons = buyerLoss.reasonsByCode || {};
+  const reasonThemes = {};
+  Object.entries(explicitReasons).forEach(([reasonCode, count]) => {
+    const theme = mapBuyerLossTheme(reasonCode);
+    reasonThemes[theme] = (reasonThemes[theme] || 0) + count;
+  });
+
+  const proImpressions = sumKeysMatching(behavior.ctaImpressionsById || {}, (key) => /pro|pricing/i.test(key));
+  const proClicks = sumKeysMatching(ctas.byId || {}, (key) => /pro|pricing/i.test(key));
+  const pricingViews = sumKeysMatching(behavior.sectionViewsById || {}, (key) => /pricing/i.test(key));
+  const proofViews = sumKeysMatching(behavior.sectionViewsById || {}, (key) => /proof/i.test(key));
+  const exitsBeforePricing = sumKeysMatching(behavior.exitsByLastVisibleSection || {}, (key) => !/pricing|faq/i.test(key));
+  const checkoutLossCount = Math.max(0, checkoutStarts - paidOrders);
+
+  const stageDropoff = [
+    {
+      key: 'landing_to_checkout',
+      stage: 'landing',
+      lostCount: Math.max(0, pageViews - checkoutStarts),
+      rate: safeRate(Math.max(0, pageViews - checkoutStarts), pageViews),
+    },
+    {
+      key: 'cta_impression_to_click',
+      stage: 'message',
+      lostCount: Math.max(0, proImpressions - proClicks),
+      rate: safeRate(Math.max(0, proImpressions - proClicks), proImpressions),
+    },
+    {
+      key: 'email_focus_to_capture',
+      stage: 'lead_capture',
+      lostCount: Math.max(0, (behavior.emailFocusEvents || 0) - trialEmails),
+      rate: safeRate(Math.max(0, (behavior.emailFocusEvents || 0) - trialEmails), behavior.emailFocusEvents || 0),
+    },
+    {
+      key: 'checkout_to_paid',
+      stage: 'checkout',
+      lostCount: checkoutLossCount,
+      rate: safeRate(checkoutLossCount, checkoutStarts),
+    },
+  ].sort((a, b) => b.lostCount - a.lostCount);
+
+  const inferredCauses = [];
+  if (exitsBeforePricing > 0) {
+    inferredCauses.push({
+      key: 'message_drop_before_pricing',
+      stage: 'landing',
+      count: exitsBeforePricing,
+      evidence: {
+        topExitSection: behavior.topExitSection,
+        pricingViews,
+        pageExits: behavior.pageExits || 0,
+      },
+    });
+  }
+  if (proImpressions > 0 && proClicks < proImpressions) {
+    inferredCauses.push({
+      key: 'weak_pricing_cta_response',
+      stage: 'message',
+      count: Math.max(0, proImpressions - proClicks),
+      evidence: {
+        proImpressions,
+        proClicks,
+        impressionToClickRate: safeRate(proClicks, proImpressions),
+      },
+    });
+  }
+  if ((behavior.emailAbandonEvents || 0) > 0) {
+    inferredCauses.push({
+      key: 'email_capture_friction',
+      stage: 'lead_capture',
+      count: behavior.emailAbandonEvents || 0,
+      evidence: {
+        emailFocusEvents: behavior.emailFocusEvents || 0,
+        emailAbandonEvents: behavior.emailAbandonEvents || 0,
+        emailAbandonRate: behavior.emailAbandonRate || 0,
+      },
+    });
+  }
+  if (checkoutLossCount > 0 || ctas.checkoutFailures || ctas.lookupFailures || ctas.checkoutCancelled || ctas.checkoutAbandoned) {
+    inferredCauses.push({
+      key: 'checkout_friction',
+      stage: 'checkout',
+      count: checkoutLossCount,
+      evidence: {
+        checkoutStarts,
+        paidOrders,
+        checkoutCancelled: ctas.checkoutCancelled || 0,
+        checkoutAbandoned: ctas.checkoutAbandoned || 0,
+        checkoutFailures: ctas.checkoutFailures || 0,
+        lookupFailures: ctas.lookupFailures || 0,
+      },
+    });
+  }
+  const topTheme = rankCounter(reasonThemes, 1)[0] || null;
+  if (topTheme) {
+    inferredCauses.push({
+      key: `explicit_${topTheme.key}`,
+      stage: topTheme.key === 'pricing' ? 'pricing' : 'objection',
+      count: topTheme.count,
+      evidence: {
+        theme: topTheme.key,
+        topReasons: rankCounter(explicitReasons, 3),
+      },
+    });
+  }
+
+  inferredCauses.sort((a, b) => b.count - a.count);
+
+  return {
+    primaryIssue: inferredCauses[0] || null,
+    stageDropoff,
+    inferredCauses,
+    explicitThemes: rankCounter(reasonThemes, 6),
+    explicitReasons: rankCounter(explicitReasons, 6),
+    behaviorSignals: {
+      topViewedSection: behavior.topViewedSection || null,
+      topExitSection: behavior.topExitSection || null,
+      topExitDwellBucket: behavior.topExitDwellBucket || null,
+      topImpressionCta: behavior.topImpressionCta || null,
+      pricingViews,
+      proofViews,
+      pageExits: behavior.pageExits || 0,
+      exitsBeforePricing,
+      averageExitEngagementMs: behavior.averageExitEngagementMs || 0,
+      averageExitScrollPercent: behavior.averageExitScrollPercent || 0,
+      emailFocusEvents: behavior.emailFocusEvents || 0,
+      emailAbandonEvents: behavior.emailAbandonEvents || 0,
+    },
+    revenueOpportunity: {
+      currentMonthlyPriceCents: monthlyPriceCents,
+      checkoutLossCount,
+      explicitBuyerLossCount: buyerLoss.totalSignals || 0,
+      opportunityAtCurrentMonthlyPriceCents: checkoutLossCount * monthlyPriceCents,
+    },
+  };
+}
+
 function computeAnalyticsSummary(feedbackDir, options = {}) {
   const analyticsWindow = resolveAnalyticsWindow(options.analyticsWindow || options);
   const telemetryEntries = filterEntriesForWindow(
@@ -749,6 +994,13 @@ function computeAnalyticsSummary(feedbackDir, options = {}) {
       topSurface: null,
       topQuery: null,
     },
+    trackedLinks: telemetry.trackedLinks || {
+      totalHits: 0,
+      totalCheckoutStarts: 0,
+      overallConversionRate: 0,
+      bySlug: {},
+      topSlug: null,
+    },
     efficiency,
     revenue: billing.revenue || {
       paidProviderEvents: 0,
@@ -1150,9 +1402,19 @@ function generateDashboard(feedbackDir, options = {}) {
     analyticsWindow,
     billingSummary,
   });
+  analytics.lossAnalysis = buildLossAnalysis(analytics);
   const observability = computeObservabilityStats(diagnosticEntries, diagnostics, secretGuard, analytics.telemetry);
   const instrumentation = computeInstrumentationReadiness(analytics, billingSummary);
-  const delegation = summarizeDelegation(feedbackDir);
+  const delegationRuntime = loadDelegationRuntimeModule();
+  const delegation = delegationRuntime
+    ? delegationRuntime.summarizeDelegation(feedbackDir)
+    : {
+      totalHandoffs: 0,
+      successfulHandoffs: 0,
+      blockedHandoffs: 0,
+      activePlans: [],
+      availability: 'private_core',
+    };
   const readiness = generateAgentReadinessReport({ projectRoot: PROJECT_ROOT });
   const harness = computeHarnessOverview(feedbackDir, entries);
   const interventionPolicy = getInterventionPolicySummary(feedbackDir);
@@ -1219,11 +1481,15 @@ function generateDashboard(feedbackDir, options = {}) {
     day.lessons = lessonPipeline.lessonsByDay.get(day.dayKey) || 0;
   }
 
-  const team = generateOrgDashboard({
-    windowHours: resolveTeamWindowHours(analyticsWindow),
-    authContext: options.authContext,
-    proOverride: options.teamProOverride,
-  });
+  const teamWindowHours = resolveTeamWindowHours(analyticsWindow);
+  const orgDashboard = loadOrgDashboardModule();
+  const team = orgDashboard
+    ? orgDashboard.generateOrgDashboard({
+      windowHours: teamWindowHours,
+      authContext: options.authContext,
+      proOverride: options.teamProOverride,
+    })
+    : buildUnavailableOrgDashboard(teamWindowHours);
   const templateLibrary = summarizeGateTemplates();
   const predictive = buildPredictiveInsights({
     telemetryAnalytics: analytics.telemetry,

package/scripts/decision-journal.js

@@ -192,8 +192,18 @@ function collapseDecisionTimeline(records) {
   });
 }
 
-function initializeDaySeries(dayCount) {
-  const today = new Date();
+function resolveNow(now) {
+  if (now instanceof Date) return new Date(now.getTime());
+  if (typeof now === 'number' && Number.isFinite(now)) return new Date(now);
+  if (typeof now === 'string' && now) {
+    const parsed = new Date(now);
+    if (!Number.isNaN(parsed.getTime())) return parsed;
+  }
+  return new Date();
+}
+
+function initializeDaySeries(dayCount, now) {
+  const today = resolveNow(now);
   today.setHours(0, 0, 0, 0);
   const days = [];
   for (let offset = dayCount - 1; offset >= 0; offset -= 1) {
@@ -224,7 +234,7 @@ function computeDecisionMetrics(feedbackDir, options = {}) {
   const dayCount = Number.isInteger(options.dayCount) ? options.dayCount : DEFAULT_DAY_COUNT;
   const records = readDecisionLog(getDecisionLogPath(feedbackDir));
   const actions = collapseDecisionTimeline(records).filter((entry) => entry.evaluation);
-  const series = initializeDaySeries(dayCount);
+  const series = initializeDaySeries(dayCount, options.now);
   const dayMap = new Map(series.map((day) => [day.dayKey, day]));
   const outcomeCounts = {
     accepted: 0,