/** * Workspace State — structured current-state reconstruction for a workspace. * * Assembles typed, classified items from workspace memory, session files, * and awareness layer into a coherent model of "what's going on now." * * Design principles: * - Freshness comes from timestamps, not item type (a blocker can be stale) * - Stale means "not recently touched", not "unimportant" * - Compounding quality > quantity — deduplicate, distill, don't spam */ import fs from 'node:fs'; import path from 'node:path'; import { AwarenessLayer, WaggleDB, workspaceDataScope } from '@waggle/core'; import { workspaceScope, type MemoryRecord, type MemoryScope, type MemoryStore, } from '@waggle/memory-contract'; import { extractProgressItems, extractOpenQuestions, classifyThreads, type ProgressItem, type OpenQuestion, type ThreadInfo, } from './routes/sessions.js'; import { sanitizeExtracted } from './routes/session-utils.js'; // ── Types ────────────────────────────────────────────────────────────── export type Freshness = 'fresh' | 'aging' | 'stale'; export type StateSource = 'memory' | 'session' | 'awareness'; export interface StateItem { content: string; freshness: Freshness; source: StateSource; sourceId?: string; dateLastTouched: string; // ISO date (YYYY-MM-DD) } export interface WorkspaceState { /** Currently active threads (fresh sessions, active awareness items) */ active: StateItem[]; /** Unresolved questions / undecided items from recent sessions */ openQuestions: StateItem[]; /** Tasks mentioned but not yet completed */ pending: StateItem[]; /** Items explicitly blocked */ blocked: StateItem[]; /** Recently completed work */ completed: StateItem[]; /** Threads not touched in 7+ days */ stale: StateItem[]; /** Recent decisions from memory */ recentDecisions: StateItem[]; /** Derived: prioritized list of what to do next */ nextActions: string[]; } // ── Freshness calculation ────────────────────────────────────────────── /** Thresholds in days */ const FRESH_DAYS = 2; const AGING_DAYS = 7; export function computeFreshness(dateStr: string): Freshness { const date = new Date(dateStr); const now = new Date(); const diffMs = now.getTime() - date.getTime(); const diffDays = diffMs / (86400 * 1000); if (diffDays < FRESH_DAYS) return 'fresh'; if (diffDays < AGING_DAYS) return 'aging'; return 'stale'; } // ── Workspace memory reads ───────────────────────────────────────────── /** Recent memories scanned for decisions. */ const DECISION_SCAN = 200; /** Wording that marks a note as a decision when its kind does not. */ const DECISION_WORDING = /^decision|decided|decision made|chose |selected |agreed /i; /** A decision: its kind says so, it is critical, or its wording records one. */ function isDecision(record: MemoryRecord): boolean { return record.kind === 'decision' || record.importance === 'critical' || DECISION_WORDING.test(record.text); } /** The newest decisions of a scope, temporary memories excluded. */ export async function listDecisions( memory: MemoryStore, scope: MemoryScope, max: number, ): Promise { const recent = await memory.list({ scopes: [scope], minImportance: 'normal', limit: DECISION_SCAN }); return recent.filter(isDecision).slice(0, max); } /** * Up to `limit` memories of a scope, most important first and newest first * within one importance level; temporary memories are excluded. */ export async function listByImportance( memory: MemoryStore, scope: MemoryScope, limit: number, ): Promise { const records: MemoryRecord[] = []; for (const level of ['critical', 'important', 'normal'] as const) { if (records.length >= limit) break; // Every memory above `level` is already in `records`, so the newest // `limit + records.length` memories at or above `level` contain the // newest `limit` memories at `level`. const candidates = await memory.list({ scopes: [scope], minImportance: level, limit: limit + records.length }); records.push(...candidates.filter(r => r.importance === level).slice(0, limit - records.length)); } return records; } function toDecisionItem(record: MemoryRecord): StateItem { const firstLine = record.text.split('\n')[0]; const sentenceMatch = firstLine.match(/^(.+?\.\s)(?=[A-Z])/); const text = sentenceMatch ? sentenceMatch[1] : firstLine; return { // Strip cursor/markdown artifacts (leaking `|` pipes etc.) + tail-truncate. content: sanitizeExtracted(text, 150), freshness: computeFreshness(record.createdAt), source: 'memory', sourceId: record.id, dateLastTouched: record.createdAt.slice(0, 10), }; } // ── Active items from awareness layer ────────────────────────────────── function extractAwarenessItems(waggleDb: WaggleDB, workspaceId: string): StateItem[] { const items = new AwarenessLayer(waggleDb, workspaceDataScope(workspaceId)).getAll(); return items .filter(i => i.category === 'task' || i.category === 'action' || i.category === 'pending') .map(i => ({ content: i.content, freshness: computeFreshness(i.created_at), source: 'awareness' as StateSource, sourceId: String(i.id), dateLastTouched: i.created_at.slice(0, 10), })); } // ── Progress items → StateItems ──────────────────────────────────────── function progressToStateItems(items: ProgressItem[], type: 'task' | 'completed' | 'blocker'): StateItem[] { return items .filter(p => p.type === type) .map(p => ({ content: p.content, freshness: computeFreshness(p.date), source: 'session' as StateSource, sourceId: p.sessionId, dateLastTouched: p.date, })); } // ── Open questions → StateItems ──────────────────────────────────────── function questionsToStateItems(questions: OpenQuestion[]): StateItem[] { return questions.map(q => ({ content: q.content, freshness: computeFreshness(q.date), source: 'session' as StateSource, sourceId: q.sessionId, dateLastTouched: q.date, })); } // ── Threads → StateItems ─────────────────────────────────────────────── function threadsToStateItems(threads: ThreadInfo[], freshness: Freshness): StateItem[] { return threads .filter(t => t.freshness === freshness || (freshness === 'fresh' && t.freshness === 'fresh')) .map(t => ({ content: t.title, freshness: t.freshness, source: 'session' as StateSource, sourceId: t.sessionId, dateLastTouched: t.lastActive.slice(0, 10), })); } // ── Next-action derivation (priority cascade) ────────────────────────── function deriveNextActions(state: Omit, max: number): string[] { const actions: string[] = []; // 1. Blocked items (by freshness — fresher blockers first) const freshBlockers = state.blocked.filter(b => b.freshness !== 'stale'); for (const b of freshBlockers) { if (actions.length >= max) break; actions.push(`Resolve: ${b.content}`); } // 2. Open questions const freshQuestions = state.openQuestions.filter(q => q.freshness !== 'stale'); for (const q of freshQuestions) { if (actions.length >= max) break; actions.push(`Decide: ${q.content}`); } // 3. Pending tasks const freshPending = state.pending.filter(p => p.freshness !== 'stale'); for (const p of freshPending) { if (actions.length >= max) break; actions.push(p.content); } // 4. Stale threads with work for (const s of state.stale) { if (actions.length >= max) break; actions.push(`Resume: ${s.content}`); } // 5. Fallback if (actions.length === 0 && state.recentDecisions.length > 0) { actions.push('Review recent decisions and plan next steps'); } return actions.slice(0, max); } // ── Main builder ─────────────────────────────────────────────────────── interface WsManagerLike { get: (id: string) => { id: string; name: string } | null | undefined; } export interface BuildWorkspaceStateOpts { dataDir: string; workspaceId: string; wsManager: WsManagerLike; /** waggle.db, which holds the workspace's awareness items. */ waggleDb: WaggleDB; memory: MemoryStore; } /** Null when the workspace is unknown, has no memories yet, or its memory cannot be read. */ export async function buildWorkspaceState(opts: BuildWorkspaceStateOpts): Promise { const { dataDir, workspaceId, wsManager, waggleDb, memory } = opts; const ws = wsManager.get(workspaceId); if (!ws) return null; // ── Memory-sourced state ───────────────────────────────────────── let recentDecisions: StateItem[] = []; let awarenessItems: StateItem[] = []; try { const scope = workspaceScope(workspaceId); if (await memory.count({ scopes: [scope] }) === 0) return null; recentDecisions = (await listDecisions(memory, scope, 5)).map(toDecisionItem); } catch { return null; } // Awareness items live in waggle.db; failing to read them must not drop the // memory-sourced state above. try { awarenessItems = extractAwarenessItems(waggleDb, workspaceId); } catch { /* non-blocking */ } // ── Session-sourced state ──────────────────────────────────────── const sessionsDir = path.join(dataDir, 'workspaces', workspaceId, 'sessions'); let progress: ProgressItem[] = []; let openQuestions: OpenQuestion[] = []; let threads: ThreadInfo[] = []; if (fs.existsSync(sessionsDir)) { try { progress = extractProgressItems(sessionsDir, 10); } catch { /* non-blocking */ } try { openQuestions = extractOpenQuestions(sessionsDir, 10); } catch { /* non-blocking */ } try { threads = classifyThreads(sessionsDir, 20); } catch { /* non-blocking */ } } // ── Assemble state ────────────────────────────────────────────── const pending = progressToStateItems(progress, 'task').slice(0, 5); const blocked = progressToStateItems(progress, 'blocker').slice(0, 5); const completed = progressToStateItems(progress, 'completed').slice(0, 5); // Active = fresh threads + awareness items const activeThreadItems = threadsToStateItems(threads.filter(t => t.freshness === 'fresh'), 'fresh').slice(0, 5); const active = [...awarenessItems, ...activeThreadItems].slice(0, 5); // Stale = threads not recently touched (but potentially still important!) const staleThreads = threadsToStateItems(threads.filter(t => t.freshness === 'stale'), 'stale').slice(0, 3); const openQuestionItems = questionsToStateItems(openQuestions).slice(0, 5); const stateWithoutActions = { active, openQuestions: openQuestionItems, pending, blocked, completed, stale: staleThreads, recentDecisions: recentDecisions.slice(0, 5), }; const nextActions = deriveNextActions(stateWithoutActions, 5); return { ...stateWithoutActions, nextActions }; } // ── Formatter (for system prompt injection) ──────────────────────────── export function formatWorkspaceStatePrompt(state: WorkspaceState, workspaceName: string): string { const sections: string[] = []; sections.push(`# Workspace Now — ${workspaceName}`); sections.push(''); if (state.active.length > 0) { sections.push('## Active'); for (const a of state.active) { sections.push(`- ${a.content}${a.freshness === 'aging' ? ' (aging)' : ''}`); } sections.push(''); } if (state.openQuestions.length > 0) { sections.push('## Open Questions'); for (const q of state.openQuestions) { sections.push(`- ${q.content}${q.freshness !== 'fresh' ? ` (${q.freshness})` : ''}`); } sections.push(''); } if (state.blocked.length > 0) { sections.push('## Blocked'); for (const b of state.blocked) { sections.push(`- ${b.content}${b.freshness !== 'fresh' ? ` (${b.freshness})` : ''}`); } sections.push(''); } if (state.pending.length > 0) { sections.push('## Pending'); for (const p of state.pending) { sections.push(`- ${p.content}`); } sections.push(''); } if (state.recentDecisions.length > 0) { sections.push('## Recent Decisions'); for (const d of state.recentDecisions) { sections.push(`- ${d.content}${d.freshness !== 'fresh' ? ` (${d.freshness})` : ''}`); } sections.push(''); } if (state.completed.length > 0) { sections.push('## Completed'); for (const c of state.completed) { sections.push(`- ${c.content}`); } sections.push(''); } if (state.stale.length > 0) { sections.push('## Needs Attention (stale)'); for (const s of state.stale) { sections.push(`- ${s.content} — not touched recently`); } sections.push(''); } if (state.nextActions.length > 0) { sections.push('## Likely Next Actions'); for (const a of state.nextActions) { sections.push(`- ${a}`); } sections.push(''); } return sections.join('\n').trimEnd(); }