@usejarvis/brain 0.1.0

package/src/goals/accountability.ts

@@ -0,0 +1,240 @@
+/**
+ * Accountability Engine — Drill Sergeant Escalation
+ *
+ * Staged escalation for goals that are behind or at risk:
+ * - Week 1-2: Pressure — daily blunt reminders
+ * - Week 3: Root Cause — LLM analyzes why the goal is failing
+ * - Week 4+: Suggest Kill — recommend killing or replanning the goal
+ *
+ * Also generates replan options when goals need course correction.
+ */
+
+import type { Goal, EscalationStage } from './types.ts';
+import * as vault from '../vault/goals.ts';
+
+export type EscalationAction = {
+  goalId: string;
+  goalTitle: string;
+  currentStage: EscalationStage;
+  newStage: EscalationStage;
+  message: string;
+  weeksBehind: number;
+};
+
+export type ReplanOption = {
+  id: string;
+  label: string;
+  description: string;
+  impact: 'low' | 'medium' | 'high';
+};
+
+export type ReplanAnalysis = {
+  options: ReplanOption[];
+  analysis: string;
+  recommendation: string;
+};
+
+export class AccountabilityEngine {
+  private llmManager: any; // LLMManager
+  private accountabilityStyle: 'drill_sergeant' | 'supportive' | 'balanced';
+  private escalationWeeks: { pressure: number; root_cause: number; suggest_kill: number };
+
+  constructor(
+    llmManager: unknown,
+    style: 'drill_sergeant' | 'supportive' | 'balanced' = 'drill_sergeant',
+    escalationWeeks = { pressure: 1, root_cause: 3, suggest_kill: 4 },
+  ) {
+    this.llmManager = llmManager;
+    this.accountabilityStyle = style;
+    this.escalationWeeks = escalationWeeks;
+  }
+
+  /**
+   * Check all active goals and return escalation actions needed.
+   */
+  runEscalationCheck(): EscalationAction[] {
+    const needingEscalation = vault.getGoalsNeedingEscalation();
+    const actions: EscalationAction[] = [];
+
+    for (const goal of needingEscalation) {
+      const action = this.evaluateEscalation(goal);
+      if (action) actions.push(action);
+    }
+
+    return actions;
+  }
+
+  /**
+   * Generate an escalation message for a goal at a given stage.
+   */
+  async generateEscalationMessage(goal: Goal, stage: EscalationStage): Promise<string> {
+    if (stage === 'none') return '';
+
+    const history = vault.getProgressHistory(goal.id, 10);
+    const progressContext = history.length > 0
+      ? `\nProgress history:\n${history.map(h => `  ${new Date(h.created_at).toLocaleDateString()}: ${h.score_before} → ${h.score_after} (${h.note})`).join('\n')}`
+      : '';
+
+    const prompt = [
+      {
+        role: 'system' as const,
+        content: this.getEscalationSystemPrompt(stage),
+      },
+      {
+        role: 'user' as const,
+        content: `Goal: ${goal.title}\nLevel: ${goal.level}\nScore: ${goal.score}\nHealth: ${goal.health}\nDeadline: ${goal.deadline ? new Date(goal.deadline).toLocaleDateString() : 'none'}\nStarted: ${goal.started_at ? new Date(goal.started_at).toLocaleDateString() : 'unknown'}${progressContext}\n\nGenerate the escalation message.`,
+      },
+    ];
+
+    try {
+      const response = await this.llmManager.chat(prompt, {
+        temperature: 0.5,
+        max_tokens: 500,
+      });
+      return typeof response.content === 'string' ? response.content : String(response.content);
+    } catch {
+      return this.getFallbackMessage(goal, stage);
+    }
+  }
+
+  /**
+   * Generate replan options for a struggling goal.
+   */
+  async generateReplanOptions(goal: Goal): Promise<ReplanAnalysis> {
+    const children = vault.getGoalChildren(goal.id);
+    const history = vault.getProgressHistory(goal.id, 20);
+
+    const childContext = children.length > 0
+      ? `\nChild goals:\n${children.map(c => `- ${c.title} (${c.level}, score: ${c.score}, status: ${c.status})`).join('\n')}`
+      : '';
+
+    const historyContext = history.length > 0
+      ? `\nRecent progress:\n${history.slice(0, 5).map(h => `  ${h.score_before} → ${h.score_after}: ${h.note}`).join('\n')}`
+      : '';
+
+    const prompt = [
+      {
+        role: 'system' as const,
+        content: `You are an OKR coach analyzing a struggling goal. Generate replan options.
+
+Respond with ONLY valid JSON:
+{
+  "options": [
+    { "id": "unique_id", "label": "short label", "description": "what this option means", "impact": "low|medium|high" }
+  ],
+  "analysis": "why the goal is struggling",
+  "recommendation": "which option you recommend and why"
+}
+
+Always include these standard options:
+- Extend deadline
+- Reduce scope
+- Change approach
+- Kill the goal
+Plus 1-2 context-specific options.`,
+      },
+      {
+        role: 'user' as const,
+        content: `Goal: ${goal.title}\nDescription: ${goal.description}\nSuccess criteria: ${goal.success_criteria}\nScore: ${goal.score}\nHealth: ${goal.health}\nDeadline: ${goal.deadline ? new Date(goal.deadline).toLocaleDateString() : 'none'}${childContext}${historyContext}`,
+      },
+    ];
+
+    try {
+      const response = await this.llmManager.chat(prompt, {
+        temperature: 0.3,
+        max_tokens: 1500,
+      });
+
+      const text = typeof response.content === 'string' ? response.content : JSON.stringify(response.content);
+      const json = text.match(/\{[\s\S]*\}/)?.[0];
+      if (!json) throw new Error('No JSON in response');
+
+      return JSON.parse(json) as ReplanAnalysis;
+    } catch {
+      return this.getFallbackReplanOptions(goal);
+    }
+  }
+
+  // ── Private ──────────────────────────────────────────────────────
+
+  private evaluateEscalation(goal: Goal): EscalationAction | null {
+    const startedAt = goal.escalation_started_at ?? goal.updated_at;
+    const weeksBehind = (Date.now() - startedAt) / (7 * 24 * 60 * 60 * 1000);
+
+    let newStage: EscalationStage | null = null;
+
+    if (goal.escalation_stage === 'none' && weeksBehind >= this.escalationWeeks.pressure) {
+      newStage = 'pressure';
+    } else if (goal.escalation_stage === 'pressure') {
+      const escalationStart = goal.escalation_started_at ?? goal.updated_at;
+      const weeksSinceEscalation = (Date.now() - escalationStart) / (7 * 24 * 60 * 60 * 1000);
+      if (weeksSinceEscalation >= this.escalationWeeks.root_cause) {
+        newStage = 'root_cause';
+      }
+    } else if (goal.escalation_stage === 'root_cause') {
+      const escalationStart = goal.escalation_started_at ?? goal.updated_at;
+      const weeksSinceEscalation = (Date.now() - escalationStart) / (7 * 24 * 60 * 60 * 1000);
+      if (weeksSinceEscalation >= this.escalationWeeks.suggest_kill) {
+        newStage = 'suggest_kill';
+      }
+    }
+
+    if (!newStage) return null;
+
+    return {
+      goalId: goal.id,
+      goalTitle: goal.title,
+      currentStage: goal.escalation_stage,
+      newStage,
+      message: this.getFallbackMessage(goal, newStage),
+      weeksBehind: Math.round(weeksBehind * 10) / 10,
+    };
+  }
+
+  private getEscalationSystemPrompt(stage: EscalationStage): string {
+    const tone = this.accountabilityStyle === 'drill_sergeant'
+      ? 'Be brutally honest. No sugarcoating. Short, punchy sentences.'
+      : this.accountabilityStyle === 'supportive'
+        ? 'Be encouraging but honest about the situation.'
+        : 'Be direct but fair.';
+
+    switch (stage) {
+      case 'pressure':
+        return `You are generating a PRESSURE escalation message for a goal that's falling behind. ${tone} Focus on urgency and the consequences of continued inaction. Keep it under 100 words.`;
+      case 'root_cause':
+        return `You are generating a ROOT CAUSE analysis for a failing goal. ${tone} Identify why this goal is stalling and what needs to change. Keep it under 150 words.`;
+      case 'suggest_kill':
+        return `You are generating a KILL SUGGESTION for a goal that has been failing for too long. ${tone} Make the case for either killing the goal or doing a major replan. Be direct about sunk cost. Keep it under 150 words.`;
+      default:
+        return '';
+    }
+  }
+
+  private getFallbackMessage(goal: Goal, stage: EscalationStage): string {
+    switch (stage) {
+      case 'pressure':
+        return `"${goal.title}" is behind schedule. Score: ${goal.score}. ${goal.deadline ? `Deadline: ${new Date(goal.deadline).toLocaleDateString()}.` : ''} Stop making excuses and deliver.`;
+      case 'root_cause':
+        return `"${goal.title}" has been behind for weeks. Score: ${goal.score}. Time to figure out what's actually wrong. Is the goal realistic? Are you avoiding something? Fix it or kill it.`;
+      case 'suggest_kill':
+        return `"${goal.title}" has been failing for over a month. Score: ${goal.score}. Consider killing this goal. Sunk cost is sunk. Either commit to a radical replan or move on.`;
+      default:
+        return '';
+    }
+  }
+
+  private getFallbackReplanOptions(goal: Goal): ReplanAnalysis {
+    return {
+      options: [
+        { id: 'extend', label: 'Extend deadline', description: 'Push the deadline back 2-4 weeks', impact: 'low' },
+        { id: 'reduce', label: 'Reduce scope', description: 'Cut non-essential success criteria', impact: 'medium' },
+        { id: 'pivot', label: 'Change approach', description: 'Try a fundamentally different strategy', impact: 'high' },
+        { id: 'kill', label: 'Kill the goal', description: 'Accept the loss and reallocate effort', impact: 'high' },
+      ],
+      analysis: `"${goal.title}" has a score of ${goal.score} and is ${goal.health}. The current approach isn't working.`,
+      recommendation: goal.score < 0.2
+        ? 'Consider killing this goal or making a major pivot.'
+        : 'Extend the deadline and reduce scope to focus on the most impactful parts.',
+    };
+  }
+}

package/src/goals/awareness-bridge.ts

@@ -0,0 +1,185 @@
+/**
+ * Awareness → Goals Bridge
+ *
+ * Subscribes to awareness events and fuzzy-matches detected context
+ * (apps, windows, files, text) against active goal descriptions.
+ * Auto-logs progress entries as 'auto_detected' when matches are found.
+ * Feeds the evening review with detected activity.
+ */
+
+import type { Goal } from './types.ts';
+import * as vault from '../vault/goals.ts';
+
+export type AwarenessGoalMatch = {
+  goalId: string;
+  goalTitle: string;
+  matchScore: number;
+  matchedTerms: string[];
+  source: string;
+};
+
+/**
+ * Process an awareness event and check if it relates to any active goals.
+ * Returns any matches found so the caller can log them.
+ */
+export function matchAwarenessToGoals(
+  eventData: Record<string, unknown>,
+): AwarenessGoalMatch[] {
+  const activeGoals = vault.findGoals({ status: 'active' });
+  if (activeGoals.length === 0) return [];
+
+  // Extract searchable text from awareness event
+  const eventText = extractEventText(eventData);
+  if (!eventText) return [];
+
+  const eventWords = tokenize(eventText);
+  if (eventWords.length === 0) return [];
+
+  const matches: AwarenessGoalMatch[] = [];
+
+  for (const goal of activeGoals) {
+    const goalWords = tokenize(`${goal.title} ${goal.description} ${goal.success_criteria}`);
+    if (goalWords.length === 0) continue;
+
+    const { score, matched } = fuzzyMatch(eventWords, goalWords);
+
+    // Threshold: require at least 2 matching terms and 0.15 score
+    if (score >= 0.15 && matched.length >= 2) {
+      matches.push({
+        goalId: goal.id,
+        goalTitle: goal.title,
+        matchScore: score,
+        matchedTerms: matched,
+        source: String(eventData.app_name ?? eventData.window_title ?? 'awareness'),
+      });
+    }
+  }
+
+  // Sort by match score descending
+  matches.sort((a, b) => b.matchScore - a.matchScore);
+
+  return matches;
+}
+
+/**
+ * Log auto-detected progress for matched goals.
+ * Only logs if the goal hasn't had a recent auto-detection (within 30 min).
+ */
+export function logAutoDetectedProgress(
+  matches: AwarenessGoalMatch[],
+  eventType: string,
+): void {
+  const now = Date.now();
+  const thirtyMinutes = 30 * 60 * 1000;
+
+  for (const match of matches) {
+    // Check for recent auto-detection to avoid spam
+    const recentProgress = vault.getProgressHistory(match.goalId, 5);
+    const hasRecentAutoDetect = recentProgress.some(
+      p => p.type === 'auto_detected' && (now - p.created_at) < thirtyMinutes
+    );
+
+    if (hasRecentAutoDetect) continue;
+
+    const goal = vault.getGoal(match.goalId);
+    if (!goal) continue;
+
+    // Log progress entry (no score change, just detection)
+    vault.addProgressEntry(
+      match.goalId,
+      'auto_detected',
+      goal.score,
+      goal.score, // no automatic score change
+      `Activity detected: ${eventType} via ${match.source} (matched: ${match.matchedTerms.join(', ')})`,
+      'awareness',
+    );
+  }
+}
+
+/**
+ * Extract searchable text from an awareness event's data payload.
+ */
+function extractEventText(data: Record<string, unknown>): string {
+  const parts: string[] = [];
+
+  // Common awareness event fields
+  if (data.app_name) parts.push(String(data.app_name));
+  if (data.window_title) parts.push(String(data.window_title));
+  if (data.ocr_text) parts.push(String(data.ocr_text));
+  if (data.file_path) parts.push(String(data.file_path));
+  if (data.url) parts.push(String(data.url));
+  if (data.title) parts.push(String(data.title));
+  if (data.body) parts.push(String(data.body));
+  if (data.description) parts.push(String(data.description));
+  if (data.context) parts.push(String(data.context));
+
+  // Session data
+  if (data.dominant_app) parts.push(String(data.dominant_app));
+  if (data.summary) parts.push(String(data.summary));
+  if (data.activities && Array.isArray(data.activities)) {
+    for (const a of data.activities) {
+      if (typeof a === 'string') parts.push(a);
+      else if (a && typeof a === 'object' && 'description' in a) parts.push(String(a.description));
+    }
+  }
+
+  return parts.join(' ');
+}
+
+// Common words to filter from matching
+const STOP_WORDS = new Set([
+  'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+  'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+  'should', 'may', 'might', 'must', 'shall', 'can', 'to', 'of', 'in',
+  'for', 'on', 'with', 'at', 'by', 'from', 'as', 'into', 'about',
+  'and', 'but', 'or', 'not', 'no', 'if', 'than', 'so', 'up', 'out',
+  'that', 'this', 'it', 'its', 'my', 'your', 'his', 'her', 'our',
+  'all', 'each', 'every', 'both', 'few', 'more', 'most', 'some',
+  'new', 'file', 'window', 'app', 'application', 'open', 'close',
+]);
+
+/**
+ * Tokenize text into meaningful words (lowercase, filtered).
+ */
+function tokenize(text: string): string[] {
+  return text
+    .toLowerCase()
+    .split(/[^a-zA-Z0-9]+/)
+    .filter(w => w.length >= 3 && !STOP_WORDS.has(w));
+}
+
+/**
+ * Fuzzy match: check how many of the event words overlap with goal words.
+ * Returns a score (0-1) and the matched terms.
+ */
+function fuzzyMatch(
+  eventWords: string[],
+  goalWords: string[],
+): { score: number; matched: string[] } {
+  const goalSet = new Set(goalWords);
+  const matched: string[] = [];
+
+  for (const word of eventWords) {
+    if (goalSet.has(word)) {
+      matched.push(word);
+    } else {
+      // Partial match: check if event word is substring of any goal word or vice versa
+      for (const gw of goalSet) {
+        if (gw.length >= 4 && word.length >= 4) {
+          if (gw.includes(word) || word.includes(gw)) {
+            matched.push(word);
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  // Deduplicate
+  const uniqueMatched = [...new Set(matched)];
+
+  // Score: proportion of goal words that were matched
+  const score = goalWords.length > 0 ? uniqueMatched.length / goalWords.length : 0;
+
+  return { score, matched: uniqueMatched };
+}

package/src/goals/estimator.ts

@@ -0,0 +1,185 @@
+/**
+ * Goal Estimator — Hybrid LLM + historical estimation
+ *
+ * Blends LLM estimates with personal historical data from completed goals.
+ * 60/40 split (history/LLM) when history is available, 100% LLM otherwise.
+ */
+
+import type { GoalEstimate, GoalLevel } from './types.ts';
+import * as vault from '../vault/goals.ts';
+
+export class GoalEstimator {
+  private llmManager: any; // LLMManager
+
+  constructor(llmManager: unknown) {
+    this.llmManager = llmManager;
+  }
+
+  /**
+   * Estimate hours for a goal by combining LLM judgment with historical data.
+   */
+  async estimate(goalId: string): Promise<GoalEstimate | null> {
+    const goal = vault.getGoal(goalId);
+    if (!goal) return null;
+
+    // Find similar completed goals
+    const similarGoals = this.findSimilarCompleted(goal.title, goal.level, goal.description);
+
+    // Get LLM estimate
+    const llmEstimate = await this.getLLMEstimate(goal.title, goal.level, goal.description, goal.success_criteria);
+
+    // Calculate historical estimate
+    const historicalEstimate = this.calculateHistoricalEstimate(similarGoals);
+
+    // Blend estimates
+    let finalEstimate: number;
+    let confidence: number;
+    let reasoning: string;
+
+    if (historicalEstimate !== null && similarGoals.length >= 2) {
+      // 60% history, 40% LLM when we have good historical data
+      finalEstimate = historicalEstimate * 0.6 + llmEstimate.hours * 0.4;
+      confidence = Math.min(0.9, 0.5 + similarGoals.length * 0.1);
+      reasoning = `Blended estimate: ${similarGoals.length} similar past goals averaged ${historicalEstimate.toFixed(1)}h (actual), LLM estimates ${llmEstimate.hours.toFixed(1)}h. ${llmEstimate.reasoning}`;
+    } else if (historicalEstimate !== null) {
+      // Some history, less weight
+      finalEstimate = historicalEstimate * 0.4 + llmEstimate.hours * 0.6;
+      confidence = 0.4;
+      reasoning = `Limited history (${similarGoals.length} similar goal${similarGoals.length === 1 ? '' : 's'}): ${historicalEstimate.toFixed(1)}h actual. LLM estimates ${llmEstimate.hours.toFixed(1)}h. ${llmEstimate.reasoning}`;
+    } else {
+      // No history, pure LLM
+      finalEstimate = llmEstimate.hours;
+      confidence = Math.min(0.5, llmEstimate.confidence);
+      reasoning = `No historical data. LLM estimate: ${llmEstimate.reasoning}`;
+    }
+
+    return {
+      llm_estimate_hours: llmEstimate.hours,
+      historical_estimate_hours: historicalEstimate,
+      final_estimate_hours: Math.round(finalEstimate * 10) / 10,
+      confidence: Math.round(confidence * 100) / 100,
+      reasoning,
+      similar_past_goals: similarGoals.map(g => g.id),
+    };
+  }
+
+  /**
+   * Quick estimate without LLM — uses only historical data and heuristics.
+   */
+  quickEstimate(title: string, level: GoalLevel): { hours: number; confidence: number } {
+    const similar = this.findSimilarCompleted(title, level);
+    const historical = this.calculateHistoricalEstimate(similar);
+
+    if (historical !== null && similar.length >= 2) {
+      return { hours: Math.round(historical * 10) / 10, confidence: 0.6 };
+    }
+
+    // Heuristic fallback based on level
+    const levelDefaults: Record<GoalLevel, number> = {
+      objective: 200,
+      key_result: 40,
+      milestone: 20,
+      task: 4,
+      daily_action: 1,
+    };
+    return { hours: levelDefaults[level], confidence: 0.2 };
+  }
+
+  // ── Private ──────────────────────────────────────────────────────
+
+  private findSimilarCompleted(title: string, level: GoalLevel, description?: string): ReturnType<typeof vault.findGoals> {
+    // Find completed goals at the same level
+    const completed = vault.findGoals({ status: 'completed', level, limit: 50 });
+
+    // Score similarity using simple word overlap
+    const titleWords = new Set(title.toLowerCase().split(/\s+/).filter(w => w.length > 2));
+    const descWords = description
+      ? new Set(description.toLowerCase().split(/\s+/).filter(w => w.length > 2))
+      : new Set<string>();
+
+    const scored = completed
+      .map(goal => {
+        const goalWords = new Set([
+          ...goal.title.toLowerCase().split(/\s+/).filter(w => w.length > 2),
+          ...goal.description.toLowerCase().split(/\s+/).filter(w => w.length > 2),
+        ]);
+
+        let overlap = 0;
+        for (const word of titleWords) {
+          if (goalWords.has(word)) overlap += 2; // Title matches worth more
+        }
+        for (const word of descWords) {
+          if (goalWords.has(word)) overlap += 1;
+        }
+
+        return { goal, score: overlap };
+      })
+      .filter(({ score }) => score > 0)
+      .sort((a, b) => b.score - a.score)
+      .slice(0, 5);
+
+    return scored.map(s => s.goal);
+  }
+
+  private calculateHistoricalEstimate(goals: ReturnType<typeof vault.findGoals>): number | null {
+    const withHours = goals.filter(g => g.actual_hours > 0);
+    if (withHours.length === 0) return null;
+
+    const total = withHours.reduce((sum, g) => sum + g.actual_hours, 0);
+    return total / withHours.length;
+  }
+
+  private async getLLMEstimate(
+    title: string,
+    level: GoalLevel,
+    description: string,
+    successCriteria: string,
+  ): Promise<{ hours: number; confidence: number; reasoning: string }> {
+    const prompt = [
+      {
+        role: 'system' as const,
+        content: `You are a project estimation expert. Estimate the total hours needed to complete a goal.
+
+Consider:
+- Goal level: objective (large), key_result (medium), milestone (small), task (tiny), daily_action (1-2h)
+- Include planning, execution, review, and buffer time
+- Be realistic, not optimistic
+
+Respond with ONLY valid JSON: { "hours": number, "confidence": number (0-1), "reasoning": "brief explanation" }`,
+      },
+      {
+        role: 'user' as const,
+        content: `Estimate hours for:\nLevel: ${level}\nTitle: ${title}\nDescription: ${description}\nSuccess Criteria: ${successCriteria}`,
+      },
+    ];
+
+    try {
+      const response = await this.llmManager.chat(prompt, {
+        temperature: 0.2,
+        max_tokens: 500,
+      });
+
+      const text = typeof response.content === 'string' ? response.content : JSON.stringify(response.content);
+      const json = text.match(/\{[\s\S]*\}/)?.[0];
+      if (!json) throw new Error('No JSON in response');
+
+      const parsed = JSON.parse(json);
+      return {
+        hours: Math.max(0.5, Number(parsed.hours) || 4),
+        confidence: Math.max(0, Math.min(1, Number(parsed.confidence) || 0.3)),
+        reasoning: String(parsed.reasoning || 'LLM estimate'),
+      };
+    } catch (err) {
+      console.error('[GoalEstimator] LLM estimate failed:', err instanceof Error ? err.message : err);
+      // Fallback heuristic
+      const defaults: Record<GoalLevel, number> = {
+        objective: 200, key_result: 40, milestone: 20, task: 4, daily_action: 1,
+      };
+      return {
+        hours: defaults[level],
+        confidence: 0.1,
+        reasoning: 'Fallback heuristic (LLM unavailable)',
+      };
+    }
+  }
+}

package/src/goals/events.ts

@@ -0,0 +1,28 @@
+/**
+ * Goal Event Types for M16 — Autonomous Goal Pursuit
+ *
+ * Events emitted by GoalService and broadcast via WebSocket.
+ */
+
+export type GoalEventType =
+  | 'goal_created'
+  | 'goal_updated'
+  | 'goal_scored'
+  | 'goal_status_changed'
+  | 'goal_completed'
+  | 'goal_failed'
+  | 'goal_killed'
+  | 'goal_health_changed'
+  | 'goal_escalated'
+  | 'goal_deleted'
+  | 'check_in_morning'
+  | 'check_in_evening'
+  | 'daily_actions_generated'
+  | 'replan_triggered';
+
+export type GoalEvent = {
+  type: GoalEventType;
+  goalId?: string;
+  data: Record<string, unknown>;
+  timestamp: number;
+};