@ginkoai/cli 1.0.0 → 1.4.2

package/dist/utils/synthesis.js

@@ -0,0 +1,724 @@
+/**
+ * @fileType: utility
+ * @status: current
+ * @updated: 2025-10-20
+ * @tags: [synthesis, session-resumption, flow-state, context]
+ * @related: [../core/session-log-manager.ts, ../commands/start/start-reflection.ts]
+ * @priority: critical
+ * @complexity: high
+ * @dependencies: [fs, path, simple-git, session-log-manager]
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import simpleGit from 'simple-git';
+import { SessionLogManager } from '../core/session-log-manager.js';
+/**
+ * Session Synthesis Engine
+ *
+ * Reads session logs and context to synthesize a complete picture
+ * for instant flow state on session resumption.
+ */
+export class SessionSynthesizer {
+    git;
+    sessionDir;
+    projectRoot;
+    constructor(sessionDir, projectRoot) {
+        this.sessionDir = sessionDir;
+        this.projectRoot = projectRoot;
+        this.git = simpleGit(projectRoot);
+    }
+    /**
+     * Synthesize from event-based LoadedContext (ADR-043)
+     *
+     * When using event-based context loading, this method converts the loaded events
+     * into a SynthesisOutput for display during session startup.
+     *
+     * @param eventContext - Loaded context from event stream (API)
+     * @param projectRoot - Project root directory for git operations
+     * @returns Synthesis output with resume point based on loaded events
+     */
+    static async synthesizeFromEvents(eventContext, // LoadedContext from context-loader-events.ts
+    projectRoot) {
+        const { myEvents = [], sprint, cursor } = eventContext;
+        // Convert API events to LogEntry format
+        const timeline = myEvents.map((event) => ({
+            timestamp: event.timestamp,
+            category: event.category,
+            description: event.description,
+            files: event.files || [],
+            impact: event.impact || 'medium',
+            pressure: event.pressure,
+        }));
+        // Extract events by category
+        const decisions = timeline.filter(e => e.category === 'decision');
+        const insights = timeline.filter(e => e.category === 'insight');
+        const achievements = timeline.filter(e => e.category === 'achievement');
+        const gitOps = timeline.filter(e => e.category === 'git');
+        // Analyze work performed
+        const workPerformed = SessionSynthesizer.analyzeWorkPerformed(timeline, achievements);
+        // Build discoveries
+        const discoveries = {
+            decisions,
+            insights,
+            gotchas: insights
+                .filter(i => i.description.toLowerCase().includes('gotcha') ||
+                i.description.toLowerCase().includes('watch out') ||
+                i.description.toLowerCase().includes('careful'))
+                .map(i => i.description)
+        };
+        // Convert sprint to SprintContext
+        const sprintContext = sprint ? {
+            goal: sprint.title,
+            progress: sprint.progress || 0,
+            tasksCompleted: [],
+            tasksRemaining: [],
+            estimatedCompletion: 'Unknown',
+        } : null;
+        // Assess flow state
+        const flowState = SessionSynthesizer.assessFlowStateFromEvents(cursor?.last_active, timeline, achievements);
+        // Generate resume point
+        const resumePoint = SessionSynthesizer.generateResumePointFromEvents(timeline, workPerformed, sprintContext);
+        // Check for warnings (git operations)
+        const warnings = await SessionSynthesizer.checkWarningsFromGit(projectRoot);
+        return {
+            qualityTier: 'rich',
+            workPerformed,
+            discoveries,
+            sprintContext,
+            flowState,
+            resumePoint,
+            warnings
+        };
+    }
+    /**
+     * Analyze work performed (static helper for event-based synthesis)
+     */
+    static analyzeWorkPerformed(timeline, achievements) {
+        const completed = [];
+        const inProgress = [];
+        const blocked = [];
+        for (const entry of timeline) {
+            if (entry.category === 'achievement' || entry.category === 'fix') {
+                completed.push(entry.description);
+            }
+            else if (entry.category === 'feature') {
+                inProgress.push(entry.description);
+            }
+            // Check for blocked indicators
+            if (entry.description.toLowerCase().includes('block') ||
+                entry.description.toLowerCase().includes('stuck') ||
+                entry.description.toLowerCase().includes('waiting')) {
+                blocked.push(entry.description);
+            }
+        }
+        return { completed, inProgress, blocked };
+    }
+    /**
+     * Assess flow state from events (static helper)
+     */
+    static assessFlowStateFromEvents(lastActive, timeline, achievements) {
+        const now = new Date();
+        const lastActivityTime = lastActive || (timeline.length > 0 ? timeline[timeline.length - 1]?.timestamp : undefined);
+        const minutesAgo = lastActivityTime
+            ? Math.round((now.getTime() - new Date(lastActivityTime).getTime()) / (1000 * 60))
+            : 10000;
+        // Flow score based on recency and achievements
+        let score = 5;
+        if (minutesAgo < 5)
+            score = 10;
+        else if (minutesAgo < 30)
+            score = 8;
+        else if (minutesAgo < 120)
+            score = 7;
+        else if (minutesAgo < 1440)
+            score = 5;
+        else if (minutesAgo < 10080)
+            score = 3;
+        else
+            score = 1;
+        // Boost for recent achievements
+        if (achievements.length > 0) {
+            const recentAchievement = achievements[achievements.length - 1];
+            const achievementMinutesAgo = Math.round((now.getTime() - new Date(recentAchievement.timestamp).getTime()) / (1000 * 60));
+            if (achievementMinutesAgo < 60)
+                score = Math.min(10, score + 1);
+        }
+        // Energy assessment
+        let energy;
+        if (score >= 8)
+            energy = 'Hot';
+        else if (score >= 5)
+            energy = 'Warm';
+        else if (score >= 3)
+            energy = 'Cool';
+        else
+            energy = 'Cold';
+        const emotionalTone = score >= 7 ? 'Mid-stride' : score >= 4 ? 'Fresh start' : 'Needs context';
+        return {
+            score,
+            energy,
+            emotionalTone,
+            indicators: {
+                positive: score >= 7 ? ['Recent activity', 'Good momentum'] : [],
+                negative: score < 4 ? ['Long gap since last activity'] : []
+            },
+            timeContext: SessionSynthesizer.formatTimeAgoStatic(minutesAgo)
+        };
+    }
+    /**
+     * Generate resume point from events (static helper)
+     */
+    static generateResumePointFromEvents(timeline, workPerformed, sprintContext) {
+        const latest = timeline[timeline.length - 1];
+        if (!latest) {
+            return {
+                summary: 'No recent work logged',
+                nextAction: 'Review sprint goals and begin work',
+                suggestedCommand: 'git status',
+                contextFiles: []
+            };
+        }
+        // Generate summary
+        let summary = latest.description;
+        if (latest.files && latest.files.length > 0) {
+            summary += ` (${latest.files[0]})`;
+        }
+        // Determine next action based on latest entry
+        let nextAction;
+        let suggestedCommand;
+        if (latest.category === 'achievement') {
+            nextAction = sprintContext
+                ? `Begin next task: ${sprintContext.goal}`
+                : 'Review backlog for next task';
+            suggestedCommand = 'git status';
+        }
+        else if (latest.category === 'fix') {
+            nextAction = 'Verify fix and run tests';
+            suggestedCommand = 'npm test';
+        }
+        else if (latest.category === 'feature') {
+            nextAction = 'Continue implementing feature';
+            suggestedCommand = latest.files?.[0]
+                ? `code ${latest.files[0]}`
+                : 'git status';
+        }
+        else {
+            nextAction = 'Continue where you left off';
+            suggestedCommand = 'git status';
+        }
+        const contextFiles = latest.files || [];
+        return {
+            summary,
+            nextAction,
+            suggestedCommand,
+            contextFiles: contextFiles.slice(0, 3)
+        };
+    }
+    /**
+     * Format time ago (static helper)
+     */
+    static formatTimeAgoStatic(minutes) {
+        if (minutes < 1)
+            return 'just now';
+        if (minutes < 60)
+            return `${minutes} minute${minutes > 1 ? 's' : ''} ago`;
+        const hours = Math.floor(minutes / 60);
+        if (hours < 24)
+            return `${hours} hour${hours > 1 ? 's' : ''} ago`;
+        const days = Math.floor(hours / 24);
+        return `${days} day${days > 1 ? 's' : ''} ago`;
+    }
+    /**
+     * Check warnings from git (static helper)
+     */
+    static async checkWarningsFromGit(projectRoot) {
+        const warnings = [];
+        try {
+            const git = simpleGit(projectRoot);
+            const status = await git.status();
+            if (status.files.length > 10) {
+                warnings.push(`${status.files.length} uncommitted files - consider committing`);
+            }
+            if (status.conflicted.length > 0) {
+                warnings.push(`${status.conflicted.length} merge conflicts need resolution`);
+            }
+        }
+        catch (error) {
+            // Ignore git errors
+        }
+        return warnings;
+    }
+    /**
+     * Main synthesis method with progressive fail-safe
+     */
+    async synthesize() {
+        // Tier 1: Try session log (rich quality)
+        const sessionLog = await this.trySessionLog();
+        if (sessionLog) {
+            return sessionLog;
+        }
+        // Tier 2: Try handoff (medium quality)
+        const handoffSynthesis = await this.tryHandoff();
+        if (handoffSynthesis) {
+            return handoffSynthesis;
+        }
+        // Tier 3: Try git log (basic quality)
+        const gitSynthesis = await this.tryGitLog();
+        if (gitSynthesis) {
+            return gitSynthesis;
+        }
+        // Tier 4: Git status only (minimal quality)
+        return this.gitStatusFallback();
+    }
+    /**
+     * Tier 1: Synthesize from session log (rich quality)
+     */
+    async trySessionLog() {
+        try {
+            const hasLog = await SessionLogManager.hasSessionLog(this.sessionDir);
+            if (!hasLog) {
+                return null;
+            }
+            const logContent = await SessionLogManager.loadSessionLog(this.sessionDir);
+            const metadata = SessionLogManager.parseMetadata(logContent);
+            if (!metadata) {
+                return null;
+            }
+            // Extract all entries
+            const timeline = SessionLogManager.extractEntries(logContent, 'Timeline');
+            const decisions = SessionLogManager.extractEntries(logContent, 'Key Decisions');
+            const insights = SessionLogManager.extractEntries(logContent, 'Insights');
+            const gitOps = SessionLogManager.extractEntries(logContent, 'Git Operations');
+            const achievements = SessionLogManager.extractEntries(logContent, 'Achievements');
+            // Analyze work performed
+            const workPerformed = this.analyzeWorkPerformed(timeline, achievements);
+            // Extract discoveries
+            const discoveries = {
+                decisions,
+                insights,
+                gotchas: insights
+                    .filter(i => i.description.toLowerCase().includes('gotcha') ||
+                    i.description.toLowerCase().includes('watch out') ||
+                    i.description.toLowerCase().includes('careful'))
+                    .map(i => i.description)
+            };
+            // Load sprint context
+            const sprintContext = await this.loadSprintContext();
+            // Assess flow state
+            const flowState = this.assessFlowState(metadata.started, timeline, achievements);
+            // Generate resume point
+            const resumePoint = this.generateResumePoint(timeline, workPerformed, sprintContext);
+            // Check for warnings
+            const warnings = await this.checkWarnings(logContent);
+            return {
+                qualityTier: 'rich',
+                workPerformed,
+                discoveries,
+                sprintContext,
+                flowState,
+                resumePoint,
+                warnings
+            };
+        }
+        catch (error) {
+            console.error('Failed to synthesize from session log:', error);
+            return null;
+        }
+    }
+    /**
+     * Tier 2: Synthesize from handoff file (medium quality)
+     */
+    async tryHandoff() {
+        try {
+            const currentPath = path.join(this.sessionDir, 'current.md');
+            try {
+                await fs.access(currentPath);
+            }
+            catch {
+                // Check archive
+                const archiveDir = path.join(this.sessionDir, 'archive');
+                const files = await fs.readdir(archiveDir);
+                const handoffs = files
+                    .filter(f => f.endsWith('-handoff.md'))
+                    .sort()
+                    .reverse();
+                if (handoffs.length === 0) {
+                    return null;
+                }
+            }
+            const handoffContent = await fs.readFile(currentPath, 'utf-8');
+            // Parse handoff for context (simplified)
+            const workPerformed = {
+                completed: this.extractSection(handoffContent, 'Completed') || [],
+                inProgress: this.extractSection(handoffContent, 'In Progress') || [],
+                blocked: []
+            };
+            const sprintContext = await this.loadSprintContext();
+            const flowState = this.assessFlowStateFromHandoff(handoffContent);
+            const resumePoint = this.generateResumePointFromHandoff(handoffContent);
+            return {
+                qualityTier: 'medium',
+                workPerformed,
+                discoveries: { decisions: [], insights: [], gotchas: [] },
+                sprintContext,
+                flowState,
+                resumePoint,
+                warnings: ['Using handoff file - session log not found']
+            };
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Tier 3: Synthesize from git log (basic quality)
+     */
+    async tryGitLog() {
+        try {
+            const log = await this.git.log({ maxCount: 10 });
+            const workPerformed = {
+                completed: log.all.map(commit => commit.message.split('\n')[0]),
+                inProgress: [],
+                blocked: []
+            };
+            const sprintContext = await this.loadSprintContext();
+            const flowState = {
+                score: 5,
+                energy: 'Mid-stride',
+                emotionalTone: 'Continuing previous work from git history',
+                indicators: { positive: ['Recent commits found'], negative: ['No session log or handoff'] },
+                timeContext: this.formatTimeAgo(new Date(log.latest?.date || ''))
+            };
+            const resumePoint = {
+                summary: `Last commit: ${log.latest?.message.split('\n')[0] || 'Unknown'}`,
+                nextAction: 'Review recent changes and continue',
+                suggestedCommand: 'git log -5 --oneline',
+                contextFiles: []
+            };
+            return {
+                qualityTier: 'basic',
+                workPerformed,
+                discoveries: { decisions: [], insights: [], gotchas: [] },
+                sprintContext,
+                flowState,
+                resumePoint,
+                warnings: ['No session log or handoff - using git history only']
+            };
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Tier 4: Git status only (minimal quality)
+     */
+    async gitStatusFallback() {
+        const status = await this.git.status();
+        const workPerformed = {
+            completed: [],
+            inProgress: status.modified.concat(status.created),
+            blocked: []
+        };
+        const flowState = {
+            score: 3,
+            energy: 'Fresh start',
+            emotionalTone: 'Starting with minimal context',
+            indicators: {
+                positive: status.files.length > 0 ? ['Uncommitted work found'] : [],
+                negative: ['No session history available']
+            },
+            timeContext: 'Unknown'
+        };
+        const resumePoint = {
+            summary: 'Starting session with minimal context',
+            nextAction: 'Review uncommitted changes',
+            suggestedCommand: 'git status',
+            contextFiles: []
+        };
+        return {
+            qualityTier: 'minimal',
+            workPerformed,
+            discoveries: { decisions: [], insights: [], gotchas: [] },
+            sprintContext: await this.loadSprintContext(),
+            flowState,
+            resumePoint,
+            warnings: ['Minimal context - no session log, handoff, or git history found']
+        };
+    }
+    /**
+     * Analyze work performed from timeline entries
+     */
+    analyzeWorkPerformed(timeline, achievements) {
+        const completed = [];
+        const inProgress = [];
+        const blocked = [];
+        // Extract completed items from achievements
+        for (const achievement of achievements) {
+            completed.push(achievement.description);
+        }
+        // Extract in-progress from recent timeline entries
+        const recentEntries = timeline.slice(-5);
+        for (const entry of recentEntries) {
+            if (entry.category === 'feature' || entry.category === 'fix') {
+                if (!achievements.find(a => a.description.includes(entry.description))) {
+                    inProgress.push(entry.description);
+                }
+            }
+        }
+        // Extract blocked items (look for keywords)
+        for (const entry of timeline) {
+            if (entry.description.toLowerCase().includes('blocked') ||
+                entry.description.toLowerCase().includes('waiting') ||
+                entry.description.toLowerCase().includes('stuck')) {
+                blocked.push(entry.description);
+            }
+        }
+        return { completed, inProgress, blocked };
+    }
+    /**
+     * Load sprint context from docs/sprints/
+     */
+    async loadSprintContext() {
+        try {
+            const sprintsDir = path.join(this.projectRoot, 'docs', 'sprints');
+            const currentSprintPath = path.join(sprintsDir, 'CURRENT-SPRINT.md');
+            // Check if CURRENT-SPRINT.md exists
+            try {
+                await fs.access(currentSprintPath);
+                const content = await fs.readFile(currentSprintPath, 'utf-8');
+                // CURRENT-SPRINT.md has all readiness info (WHY, WHAT, HOW, status)
+                // No need to read full sprint file - parse CURRENT-SPRINT.md directly
+                return this.parseSprintContent(content);
+            }
+            catch {
+                // No CURRENT-SPRINT.md, look for most recent sprint
+                const files = await fs.readdir(sprintsDir);
+                const sprints = files.filter(f => f.startsWith('SPRINT-') && f.endsWith('.md'));
+                if (sprints.length > 0) {
+                    const latest = sprints.sort().reverse()[0];
+                    const sprintContent = await fs.readFile(path.join(sprintsDir, latest), 'utf-8');
+                    return this.parseSprintContent(sprintContent);
+                }
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Parse sprint markdown content
+     */
+    parseSprintContent(content) {
+        // Extract goal from "Sprint Goal" or "Overview" sections
+        const goalMatch = content.match(/##\s+Sprint Goal[\s\S]*?\n\n([^\n]+)/i) ||
+            content.match(/##\s+Overview[\s\S]*?Goal:\s*(.+)/i) ||
+            content.match(/##\s+Success Criteria[\s\S]*?-\s+\[.\]\s+(.+)/i);
+        const goal = goalMatch ? goalMatch[1].trim() : 'Continue sprint work';
+        // Count completed vs total tasks (support both [x] and ✅ styles)
+        const taskMatches = content.match(/- \[.\]/g);
+        const completedMatches = content.match(/- \[x\]/gi);
+        const emojiCompletedMatches = content.match(/- ✅/g);
+        const total = taskMatches?.length || 0;
+        const completed = (completedMatches?.length || 0) + (emojiCompletedMatches?.length || 0);
+        const progress = total > 0 ? Math.round((completed / total) * 100) : 0;
+        return {
+            goal,
+            progress,
+            tasksCompleted: [], // Could parse from markdown
+            tasksRemaining: [], // Could parse from markdown
+            estimatedCompletion: progress > 75 ? 'Nearly complete' : 'In progress'
+        };
+    }
+    /**
+     * Assess flow state from session log metadata and entries
+     */
+    assessFlowState(startedAt, timeline, achievements) {
+        // Use the most recent activity time, not session start time
+        const lastActivity = timeline.length > 0
+            ? new Date(timeline[timeline.length - 1].timestamp)
+            : new Date(startedAt);
+        const now = new Date();
+        const hoursAgo = (now.getTime() - lastActivity.getTime()) / (1000 * 60 * 60);
+        // Calculate score (1-10)
+        let score = 7; // Default mid-high score
+        // Positive indicators
+        const positive = [];
+        const negative = [];
+        if (achievements.length > 0) {
+            score += 1;
+            positive.push('Recent achievements');
+        }
+        if (timeline.length > 5) {
+            score += 1;
+            positive.push('Active session with multiple events');
+        }
+        // Time-based adjustments
+        let energy;
+        let emotionalTone;
+        if (hoursAgo < 1) {
+            energy = 'Mid-stride';
+            emotionalTone = 'You were just working on this - momentum is hot';
+            positive.push('Recent activity');
+        }
+        else if (hoursAgo < 8) {
+            energy = 'Fresh return';
+            emotionalTone = 'Back after a break - context still warm';
+            score -= 1;
+        }
+        else if (hoursAgo < 48) {
+            energy = 'Needs warmup';
+            emotionalTone = 'Day or two away - needs context refresh';
+            score -= 2;
+            negative.push('Been away for a while');
+        }
+        else {
+            energy = 'Fresh start';
+            emotionalTone = 'Extended break - treat as fresh start';
+            score -= 3;
+            negative.push('Long gap since last session');
+        }
+        // Clamp score
+        score = Math.max(1, Math.min(10, score));
+        return {
+            score,
+            energy,
+            emotionalTone,
+            indicators: { positive, negative },
+            timeContext: this.formatTimeAgo(lastActivity)
+        };
+    }
+    /**
+     * Generate resume point from timeline and work context
+     */
+    generateResumePoint(timeline, workPerformed, sprintContext) {
+        // Get most recent entry
+        const latest = timeline[timeline.length - 1];
+        if (!latest) {
+            return {
+                summary: 'No recent work logged',
+                nextAction: 'Review sprint goals and begin work',
+                suggestedCommand: 'git status',
+                contextFiles: []
+            };
+        }
+        // Generate summary
+        let summary = latest.description;
+        if (latest.files && latest.files.length > 0) {
+            summary += ` (${latest.files[0]})`;
+        }
+        // Determine next action based on latest entry
+        let nextAction;
+        let suggestedCommand;
+        if (latest.category === 'achievement') {
+            nextAction = sprintContext
+                ? `Begin next task: ${sprintContext.goal}`
+                : 'Review backlog for next task';
+            suggestedCommand = 'ginko backlog list --status=proposed';
+        }
+        else if (latest.category === 'fix') {
+            nextAction = 'Verify fix and run tests';
+            suggestedCommand = 'npm test';
+        }
+        else if (latest.category === 'feature') {
+            nextAction = 'Continue implementing feature';
+            suggestedCommand = latest.files?.[0]
+                ? `code ${latest.files[0]}`
+                : 'git status';
+        }
+        else {
+            nextAction = 'Continue where you left off';
+            suggestedCommand = 'git status';
+        }
+        const contextFiles = latest.files || [];
+        return {
+            summary,
+            nextAction,
+            suggestedCommand,
+            contextFiles
+        };
+    }
+    /**
+     * Check for warnings based on session state
+     */
+    async checkWarnings(logContent) {
+        const warnings = [];
+        // Check for blocked items
+        if (logContent.toLowerCase().includes('blocked')) {
+            warnings.push('Session has blocked items - may need assistance');
+        }
+        // Check for failed tests
+        if (logContent.toLowerCase().includes('test fail') ||
+            logContent.toLowerCase().includes('tests fail')) {
+            warnings.push('Tests were failing in last session');
+        }
+        // Check for uncommitted work
+        const status = await this.git.status();
+        if (status.files.length > 5) {
+            warnings.push(`${status.files.length} uncommitted files - consider committing`);
+        }
+        return warnings;
+    }
+    /**
+     * Helper: Format time ago
+     */
+    formatTimeAgo(date) {
+        const now = new Date();
+        const diffMs = now.getTime() - date.getTime();
+        const diffMins = Math.floor(diffMs / (1000 * 60));
+        const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+        const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+        if (diffMins < 60) {
+            return `${diffMins} minute${diffMins === 1 ? '' : 's'} ago`;
+        }
+        else if (diffHours < 24) {
+            return `${diffHours} hour${diffHours === 1 ? '' : 's'} ago`;
+        }
+        else {
+            return `${diffDays} day${diffDays === 1 ? '' : 's'} ago`;
+        }
+    }
+    /**
+     * Helper: Extract section from handoff markdown
+     */
+    extractSection(content, sectionName) {
+        const regex = new RegExp(`##\\s+${sectionName}[\\s\\S]*?([\\s\\S]*?)(?=\\n##|$)`, 'i');
+        const match = content.match(regex);
+        if (!match)
+            return null;
+        const items = match[1]
+            .split('\n')
+            .filter(line => line.trim().startsWith('-'))
+            .map(line => line.replace(/^-\s*/, '').trim());
+        return items.length > 0 ? items : null;
+    }
+    /**
+     * Helper: Assess flow state from handoff
+     */
+    assessFlowStateFromHandoff(content) {
+        // Simplified flow assessment
+        return {
+            score: 6,
+            energy: 'Mid-stride',
+            emotionalTone: 'Resuming from handoff',
+            indicators: {
+                positive: ['Handoff found'],
+                negative: ['Session log not available']
+            },
+            timeContext: 'Unknown'
+        };
+    }
+    /**
+     * Helper: Generate resume point from handoff
+     */
+    generateResumePointFromHandoff(content) {
+        const nextMatch = content.match(/Next Session[:\s]+(.+)/i);
+        return {
+            summary: 'Resuming from handoff',
+            nextAction: nextMatch ? nextMatch[1].trim() : 'Continue previous work',
+            suggestedCommand: 'git status',
+            contextFiles: []
+        };
+    }
+}
+//# sourceMappingURL=synthesis.js.map