@usejarvis/brain 0.1.0

package/src/goals/service.ts

@@ -0,0 +1,348 @@
+/**
+ * GoalService — Core service for M16 Autonomous Goal Pursuit
+ *
+ * Manages goal lifecycle, daily rhythm (morning plan + evening review),
+ * accountability checks, health recalculation, and escalation.
+ * Implements the Service interface for daemon integration.
+ */
+
+import type { Service, ServiceStatus } from '../daemon/services.ts';
+import type { GoalEvent } from './events.ts';
+import type { GoalConfig } from '../config/types.ts';
+import type { Goal, GoalLevel, GoalStatus, GoalHealth } from './types.ts';
+import * as vault from '../vault/goals.ts';
+
+export class GoalService implements Service {
+  name = 'goals';
+  private _status: ServiceStatus = 'stopped';
+  private config: GoalConfig;
+  private eventCallback: ((event: GoalEvent) => void) | null = null;
+
+  // Timers
+  private rhythmTimer: Timer | null = null;        // daily rhythm check (60s)
+  private accountabilityTimer: Timer | null = null; // accountability check (5min)
+  private healthTimer: Timer | null = null;         // health recalc (15min)
+
+  constructor(config: GoalConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Set callback for broadcasting goal events via WebSocket.
+   */
+  setEventCallback(cb: (event: GoalEvent) => void): void {
+    this.eventCallback = cb;
+  }
+
+  private emit(event: GoalEvent): void {
+    if (this.eventCallback) {
+      this.eventCallback(event);
+    }
+  }
+
+  async start(): Promise<void> {
+    if (!this.config.enabled) {
+      this._status = 'stopped';
+      console.log('[GoalService] Disabled by config');
+      return;
+    }
+
+    this._status = 'starting';
+
+    // Daily rhythm check — runs every 60s to detect morning/evening windows
+    this.rhythmTimer = setInterval(() => {
+      this.checkDailyRhythm().catch(err =>
+        console.error('[GoalService] Rhythm check error:', err)
+      );
+    }, 60_000);
+
+    // Accountability check — runs every 5min for escalation monitoring
+    this.accountabilityTimer = setInterval(() => {
+      this.checkAccountability().catch(err =>
+        console.error('[GoalService] Accountability check error:', err)
+      );
+    }, 5 * 60_000);
+
+    // Health recalculation — runs every 15min
+    this.healthTimer = setInterval(() => {
+      this.recalculateAllHealth().catch(err =>
+        console.error('[GoalService] Health recalc error:', err)
+      );
+    }, 15 * 60_000);
+
+    this._status = 'running';
+    console.log('[GoalService] Started (rhythm=60s, accountability=5min, health=15min)');
+  }
+
+  async stop(): Promise<void> {
+    this._status = 'stopping';
+
+    if (this.rhythmTimer) { clearInterval(this.rhythmTimer); this.rhythmTimer = null; }
+    if (this.accountabilityTimer) { clearInterval(this.accountabilityTimer); this.accountabilityTimer = null; }
+    if (this.healthTimer) { clearInterval(this.healthTimer); this.healthTimer = null; }
+
+    this._status = 'stopped';
+    console.log('[GoalService] Stopped');
+  }
+
+  status(): ServiceStatus {
+    return this._status;
+  }
+
+  // ── Goal CRUD with events ─────────────────────────────────────────
+
+  createGoal(title: string, level: GoalLevel, opts?: Parameters<typeof vault.createGoal>[2]): Goal {
+    const goal = vault.createGoal(title, level, opts);
+    this.emit({
+      type: 'goal_created',
+      goalId: goal.id,
+      data: { title, level, parent_id: goal.parent_id },
+      timestamp: Date.now(),
+    });
+    return goal;
+  }
+
+  getGoal(id: string): Goal | null {
+    return vault.getGoal(id);
+  }
+
+  updateGoal(id: string, updates: Parameters<typeof vault.updateGoal>[1]): Goal | null {
+    const goal = vault.updateGoal(id, updates);
+    if (goal) {
+      this.emit({
+        type: 'goal_updated',
+        goalId: id,
+        data: { updates },
+        timestamp: Date.now(),
+      });
+    }
+    return goal;
+  }
+
+  scoreGoal(id: string, score: number, reason: string, source = 'user'): Goal | null {
+    const goal = vault.updateGoalScore(id, score, reason, source);
+    if (goal) {
+      this.emit({
+        type: 'goal_scored',
+        goalId: id,
+        data: { score: goal.score, reason, source },
+        timestamp: Date.now(),
+      });
+    }
+    return goal;
+  }
+
+  updateStatus(id: string, status: GoalStatus): Goal | null {
+    const goal = vault.updateGoalStatus(id, status);
+    if (!goal) return null;
+
+    const eventType = status === 'completed' ? 'goal_completed'
+      : status === 'failed' ? 'goal_failed'
+      : status === 'killed' ? 'goal_killed'
+      : 'goal_status_changed';
+
+    this.emit({
+      type: eventType,
+      goalId: id,
+      data: { status },
+      timestamp: Date.now(),
+    });
+
+    // Extract goal completion data for vault knowledge
+    if (status === 'completed' || status === 'failed' || status === 'killed') {
+      try {
+        const { extractGoalCompletion } = require('../vault/extractor.ts');
+        extractGoalCompletion(goal);
+      } catch {
+        // Extractor may not be available — ignore
+      }
+    }
+
+    return goal;
+  }
+
+  updateHealth(id: string, health: GoalHealth): Goal | null {
+    const goal = vault.updateGoalHealth(id, health);
+    if (goal) {
+      this.emit({
+        type: 'goal_health_changed',
+        goalId: id,
+        data: { health },
+        timestamp: Date.now(),
+      });
+    }
+    return goal;
+  }
+
+  deleteGoal(id: string): boolean {
+    const result = vault.deleteGoal(id);
+    if (result) {
+      this.emit({
+        type: 'goal_deleted',
+        goalId: id,
+        data: {},
+        timestamp: Date.now(),
+      });
+    }
+    return result;
+  }
+
+  // ── Daily Rhythm ──────────────────────────────────────────────────
+
+  /**
+   * Check if we're in a morning or evening window and trigger check-ins.
+   * This is a lightweight timer check — the actual NL-driven rhythm
+   * is in src/goals/rhythm.ts (Phase 4).
+   */
+  private async checkDailyRhythm(): Promise<void> {
+    const now = new Date();
+    const hour = now.getHours();
+
+    const morningWindow = this.config.morning_window ?? { start: 7, end: 9 };
+    const eveningWindow = this.config.evening_window ?? { start: 20, end: 22 };
+
+    // Check morning window
+    if (hour >= morningWindow.start && hour < morningWindow.end) {
+      const existing = vault.getTodayCheckIn('morning_plan');
+      if (!existing) {
+        // Morning plan needed — Phase 4 (rhythm.ts) will handle the LLM-driven planning
+        // For now, just log that it's time
+        console.log('[GoalService] Morning plan window — check-in needed');
+      }
+    }
+
+    // Check evening window
+    if (hour >= eveningWindow.start && hour < eveningWindow.end) {
+      const existing = vault.getTodayCheckIn('evening_review');
+      if (!existing) {
+        console.log('[GoalService] Evening review window — check-in needed');
+      }
+    }
+  }
+
+  // ── Accountability ────────────────────────────────────────────────
+
+  /**
+   * Check active goals for escalation needs.
+   * Full drill-sergeant logic is in src/goals/accountability.ts (Phase 4).
+   */
+  private async checkAccountability(): Promise<void> {
+    const needingEscalation = vault.getGoalsNeedingEscalation();
+    const overdue = vault.getOverdueGoals();
+
+    for (const goal of needingEscalation) {
+      if (goal.escalation_stage === 'none') {
+        // Auto-escalate to 'pressure' stage
+        const escalationWeeks = this.config.escalation_weeks ?? { pressure: 1, root_cause: 3, suggest_kill: 4 };
+        const behindSince = goal.updated_at;
+        const weeksBehind = (Date.now() - behindSince) / (7 * 24 * 60 * 60 * 1000);
+
+        if (weeksBehind >= escalationWeeks.pressure) {
+          vault.updateGoalEscalation(goal.id, 'pressure');
+          this.emit({
+            type: 'goal_escalated',
+            goalId: goal.id,
+            data: { stage: 'pressure', weeksBehind },
+            timestamp: Date.now(),
+          });
+        }
+      } else if (goal.escalation_stage === 'pressure') {
+        const escalationWeeks = this.config.escalation_weeks ?? { pressure: 1, root_cause: 3, suggest_kill: 4 };
+        const startedAt = goal.escalation_started_at ?? goal.updated_at;
+        const weeksSinceEscalation = (Date.now() - startedAt) / (7 * 24 * 60 * 60 * 1000);
+
+        if (weeksSinceEscalation >= escalationWeeks.root_cause) {
+          vault.updateGoalEscalation(goal.id, 'root_cause');
+          this.emit({
+            type: 'goal_escalated',
+            goalId: goal.id,
+            data: { stage: 'root_cause', weeksSinceEscalation },
+            timestamp: Date.now(),
+          });
+        }
+      } else if (goal.escalation_stage === 'root_cause') {
+        const escalationWeeks = this.config.escalation_weeks ?? { pressure: 1, root_cause: 3, suggest_kill: 4 };
+        const startedAt = goal.escalation_started_at ?? goal.updated_at;
+        const weeksSinceEscalation = (Date.now() - startedAt) / (7 * 24 * 60 * 60 * 1000);
+
+        if (weeksSinceEscalation >= escalationWeeks.suggest_kill) {
+          vault.updateGoalEscalation(goal.id, 'suggest_kill');
+          this.emit({
+            type: 'goal_escalated',
+            goalId: goal.id,
+            data: { stage: 'suggest_kill', weeksSinceEscalation },
+            timestamp: Date.now(),
+          });
+        }
+      }
+    }
+
+    // Log overdue goals (Phase 4 will handle the drill-sergeant messaging)
+    if (overdue.length > 0) {
+      console.log(`[GoalService] ${overdue.length} overdue goal(s) detected`);
+    }
+  }
+
+  // ── Health Recalculation ──────────────────────────────────────────
+
+  /**
+   * Recalculate health for all active goals based on score and deadline.
+   */
+  private async recalculateAllHealth(): Promise<void> {
+    const activeGoals = vault.findGoals({ status: 'active' });
+    let changed = 0;
+
+    for (const goal of activeGoals) {
+      const newHealth = this.calculateHealth(goal);
+      if (newHealth !== goal.health) {
+        this.updateHealth(goal.id, newHealth);
+        changed++;
+      }
+    }
+
+    if (changed > 0) {
+      console.log(`[GoalService] Health recalculated: ${changed} goal(s) changed`);
+    }
+  }
+
+  /**
+   * Calculate health for a single goal based on score progress vs time elapsed.
+   */
+  private calculateHealth(goal: Goal): GoalHealth {
+    // If no deadline, base purely on score
+    if (!goal.deadline) {
+      if (goal.score >= 0.6) return 'on_track';
+      if (goal.score >= 0.3) return 'at_risk';
+      return 'behind';
+    }
+
+    const now = Date.now();
+    const startTime = goal.started_at ?? goal.created_at;
+    const totalDuration = goal.deadline - startTime;
+    const elapsed = now - startTime;
+
+    // If past deadline
+    if (now > goal.deadline) {
+      if (goal.score >= 0.7) return 'on_track'; // nearly done
+      if (goal.score >= 0.4) return 'behind';
+      return 'critical';
+    }
+
+    // Ratio: how far along are we in time vs score
+    const timeRatio = totalDuration > 0 ? elapsed / totalDuration : 0;
+    const expectedScore = timeRatio * 0.7; // expecting 0.7 = good at deadline
+
+    const gap = expectedScore - goal.score;
+
+    if (gap <= 0) return 'on_track';      // ahead of pace
+    if (gap <= 0.15) return 'at_risk';     // slightly behind
+    if (gap <= 0.3) return 'behind';       // significantly behind
+    return 'critical';                      // way behind
+  }
+
+  // ── Metrics ───────────────────────────────────────────────────────
+
+  getMetrics() {
+    return vault.getGoalMetrics();
+  }
+}

package/src/goals/types.ts

@@ -0,0 +1,106 @@
+/**
+ * Goal Pursuit Types for M16 — Autonomous Goal Pursuit & Long-Term Planning
+ *
+ * OKR-style hierarchical goal system with Google-style 0.0-1.0 scoring.
+ * Goals nest: objective → key_result → milestone → task → daily_action.
+ */
+
+// ── Enums ───────────────────────────────────────────────────────────
+
+export type GoalLevel = 'objective' | 'key_result' | 'milestone' | 'task' | 'daily_action';
+
+export type GoalStatus = 'draft' | 'active' | 'paused' | 'completed' | 'failed' | 'killed';
+
+export type GoalHealth = 'on_track' | 'at_risk' | 'behind' | 'critical';
+
+export type TimeHorizon = 'life' | 'yearly' | 'quarterly' | 'monthly' | 'weekly' | 'daily';
+
+export type EscalationStage = 'none' | 'pressure' | 'root_cause' | 'suggest_kill';
+
+export type ProgressType = 'manual' | 'auto_detected' | 'review' | 'system';
+
+export type CheckInType = 'morning_plan' | 'evening_review';
+
+// ── Core Types ──────────────────────────────────────────────────────
+
+export type Goal = {
+  id: string;
+  parent_id: string | null;
+  level: GoalLevel;
+  title: string;
+  description: string;
+  success_criteria: string;
+  time_horizon: TimeHorizon;
+  score: number;                     // 0.0-1.0 OKR score (0.7 = good)
+  score_reason: string | null;
+  status: GoalStatus;
+  health: GoalHealth;
+  deadline: number | null;           // epoch ms
+  started_at: number | null;
+  estimated_hours: number | null;
+  actual_hours: number;
+  authority_level: number;           // min authority for actions within this goal
+  tags: string[];
+  dependencies: string[];            // goal IDs that must complete first
+  escalation_stage: EscalationStage;
+  escalation_started_at: number | null;
+  sort_order: number;
+  created_at: number;
+  updated_at: number;
+  completed_at: number | null;
+};
+
+export type GoalProgressEntry = {
+  id: string;
+  goal_id: string;
+  type: ProgressType;
+  score_before: number;
+  score_after: number;
+  note: string;
+  source: string;                    // 'user', 'awareness', 'daily_review', etc.
+  created_at: number;
+};
+
+export type GoalCheckIn = {
+  id: string;
+  type: CheckInType;
+  summary: string;
+  goals_reviewed: string[];          // goal IDs
+  actions_planned: string[];         // for morning
+  actions_completed: string[];       // for evening
+  created_at: number;
+};
+
+export type GoalEstimate = {
+  llm_estimate_hours: number;
+  historical_estimate_hours: number | null;
+  final_estimate_hours: number;
+  confidence: number;                // 0.0-1.0
+  reasoning: string;
+  similar_past_goals: string[];      // vault entity IDs
+};
+
+// ── Query Types ─────────────────────────────────────────────────────
+
+export type GoalQuery = {
+  status?: GoalStatus;
+  level?: GoalLevel;
+  parent_id?: string | null;
+  health?: GoalHealth;
+  tag?: string;
+  time_horizon?: TimeHorizon;
+  limit?: number;
+};
+
+export type GoalUpdate = {
+  title?: string;
+  description?: string;
+  success_criteria?: string;
+  time_horizon?: TimeHorizon;
+  deadline?: number | null;
+  estimated_hours?: number | null;
+  authority_level?: number;
+  tags?: string[];
+  dependencies?: string[];
+  sort_order?: number;
+};

package/src/goals/workflow-bridge.ts

@@ -0,0 +1,96 @@
+/**
+ * Goal → Workflow Bridge
+ *
+ * Auto-generates cron-triggered workflows for morning plan and evening review.
+ * Also supports creating recurring task workflows for goals with repeating work.
+ */
+
+import type { GoalConfig } from '../config/types.ts';
+
+/**
+ * Workflow definition for the goal system's daily rhythm.
+ * These can be registered with the TriggerManager when both
+ * the workflow engine and goal service are available.
+ */
+export type GoalWorkflowDefinition = {
+  id: string;
+  name: string;
+  description: string;
+  triggerType: 'cron';
+  cronExpression: string;
+  action: 'morning_plan' | 'evening_review';
+};
+
+/**
+ * Generate workflow definitions for the daily rhythm check-ins.
+ * Returns cron-triggered workflow specs that can be registered with the engine.
+ */
+export function generateRhythmWorkflows(config: GoalConfig): GoalWorkflowDefinition[] {
+  if (!config.enabled) return [];
+
+  const workflows: GoalWorkflowDefinition[] = [];
+
+  const morningWindow = config.morning_window ?? { start: 7, end: 9 };
+  const eveningWindow = config.evening_window ?? { start: 20, end: 22 };
+
+  // Morning plan: fire at the start of the morning window
+  workflows.push({
+    id: 'goal_morning_plan',
+    name: 'Morning Goal Plan',
+    description: 'Automated morning planning session — reviews active goals, generates daily actions, and sets focus areas.',
+    triggerType: 'cron',
+    cronExpression: `0 ${morningWindow.start} * * *`, // e.g., "0 7 * * *"
+    action: 'morning_plan',
+  });
+
+  // Evening review: fire at the start of the evening window
+  workflows.push({
+    id: 'goal_evening_review',
+    name: 'Evening Goal Review',
+    description: 'Automated evening review — scores daily progress, generates accountability assessment, and updates goal health.',
+    triggerType: 'cron',
+    cronExpression: `0 ${eveningWindow.start} * * *`, // e.g., "0 20 * * *"
+    action: 'evening_review',
+  });
+
+  return workflows;
+}
+
+/**
+ * Register goal rhythm workflows with the trigger manager.
+ * This bridges goal check-ins with the workflow execution system.
+ *
+ * When the workflow fires, it calls the goalService's daily rhythm methods.
+ */
+export function registerGoalWorkflows(
+  goalWorkflows: GoalWorkflowDefinition[],
+  triggerManager: { fireTrigger: (workflowId: string, triggerType: string, data?: Record<string, unknown>) => void },
+): void {
+  // Note: The actual cron scheduling is handled by the GoalService's own timers
+  // (checkDailyRhythm runs every 60s and checks the time window).
+  // This function exists for future use when we want to create
+  // full workflow graph executions for morning/evening routines.
+  //
+  // For now, we just log the available workflows.
+  for (const wf of goalWorkflows) {
+    console.log(`[GoalWorkflowBridge] Registered: ${wf.name} (${wf.cronExpression})`);
+  }
+}
+
+/**
+ * Handle a goal workflow trigger firing.
+ * Called from the goal service when daily rhythm check-ins happen.
+ */
+export async function handleGoalWorkflowTrigger(
+  action: 'morning_plan' | 'evening_review',
+  goalService: { getGoal: (id: string) => unknown },
+  onComplete?: (result: Record<string, unknown>) => void,
+): Promise<void> {
+  console.log(`[GoalWorkflowBridge] Executing ${action}`);
+
+  // The actual planning/review logic is in rhythm.ts
+  // This bridge just provides the workflow integration layer
+  if (onComplete) {
+    onComplete({ action, completedAt: Date.now() });
+  }
+}

package/src/integrations/google-api.ts

@@ -0,0 +1,134 @@
+/**
+ * Google API Wrappers
+ *
+ * Thin wrappers around Gmail and Calendar REST APIs.
+ * Uses raw fetch() — no googleapis package needed.
+ */
+
+const GMAIL_BASE = 'https://gmail.googleapis.com/gmail/v1/users/me';
+const CALENDAR_BASE = 'https://www.googleapis.com/calendar/v3';
+
+// --- Types ---
+
+export type GmailMessage = {
+  id: string;
+  threadId: string;
+};
+
+export type GmailMessageDetail = {
+  id: string;
+  threadId: string;
+  subject: string;
+  from: string;
+  to: string;
+  date: string;
+  snippet: string;
+  labels: string[];
+};
+
+export type CalendarEvent = {
+  id: string;
+  summary: string;
+  description?: string;
+  start: string;
+  end: string;
+  location?: string;
+  attendees: string[];
+  htmlLink?: string;
+};
+
+// --- Gmail ---
+
+export async function listUnreadEmails(
+  accessToken: string,
+  maxResults: number = 10
+): Promise<GmailMessage[]> {
+  const params = new URLSearchParams({
+    q: 'is:unread',
+    maxResults: String(maxResults),
+  });
+
+  const resp = await fetch(`${GMAIL_BASE}/messages?${params}`, {
+    headers: { Authorization: `Bearer ${accessToken}` },
+  });
+
+  if (!resp.ok) {
+    throw new Error(`Gmail list failed: ${resp.status} ${resp.statusText}`);
+  }
+
+  const data = await resp.json() as any;
+  return (data.messages ?? []).map((m: any) => ({
+    id: m.id,
+    threadId: m.threadId,
+  }));
+}
+
+export async function getEmailDetail(
+  accessToken: string,
+  messageId: string
+): Promise<GmailMessageDetail> {
+  const resp = await fetch(`${GMAIL_BASE}/messages/${messageId}?format=metadata&metadataHeaders=Subject&metadataHeaders=From&metadataHeaders=To&metadataHeaders=Date`, {
+    headers: { Authorization: `Bearer ${accessToken}` },
+  });
+
+  if (!resp.ok) {
+    throw new Error(`Gmail get failed: ${resp.status} ${resp.statusText}`);
+  }
+
+  const data = await resp.json() as any;
+  const headers = data.payload?.headers ?? [];
+
+  function getHeader(name: string): string {
+    return headers.find((h: any) => h.name === name)?.value ?? '';
+  }
+
+  return {
+    id: data.id,
+    threadId: data.threadId,
+    subject: getHeader('Subject'),
+    from: getHeader('From'),
+    to: getHeader('To'),
+    date: getHeader('Date'),
+    snippet: data.snippet ?? '',
+    labels: data.labelIds ?? [],
+  };
+}
+
+// --- Calendar ---
+
+export async function listUpcomingEvents(
+  accessToken: string,
+  calendarId: string,
+  timeMin: string,
+  timeMax: string,
+  maxResults: number = 20
+): Promise<CalendarEvent[]> {
+  const params = new URLSearchParams({
+    timeMin,
+    timeMax,
+    maxResults: String(maxResults),
+    singleEvents: 'true',
+    orderBy: 'startTime',
+  });
+
+  const resp = await fetch(
+    `${CALENDAR_BASE}/calendars/${encodeURIComponent(calendarId)}/events?${params}`,
+    { headers: { Authorization: `Bearer ${accessToken}` } }
+  );
+
+  if (!resp.ok) {
+    throw new Error(`Calendar list failed: ${resp.status} ${resp.statusText}`);
+  }
+
+  const data = await resp.json() as any;
+  return (data.items ?? []).map((event: any) => ({
+    id: event.id,
+    summary: event.summary ?? '(No title)',
+    description: event.description,
+    start: event.start?.dateTime ?? event.start?.date ?? '',
+    end: event.end?.dateTime ?? event.end?.date ?? '',
+    location: event.location,
+    attendees: (event.attendees ?? []).map((a: any) => a.email).filter(Boolean),
+    htmlLink: event.htmlLink,
+  }));
+}