gru-ai 0.1.0

package/dist-server/server/state/work-item-types.js

@@ -0,0 +1,168 @@
+/**
+ * Structured work item types for the conductor state system.
+ *
+ * These types replace free-form markdown as the queryable source of truth.
+ * The indexer (scripts/index-state.ts) reads .context/ and produces JSON
+ * arrays of these records. The dashboard watches and serves them.
+ */
+import { z } from 'zod';
+// ---------------------------------------------------------------------------
+// Enums
+// ---------------------------------------------------------------------------
+export const WorkItemType = z.enum([
+    'feature',
+    'task',
+    'backlog-item',
+    'directive',
+    'report',
+    'discussion',
+    'research',
+]);
+export const LifecycleState = z.enum([
+    'pending',
+    'in_progress',
+    'blocked',
+    'deferred',
+    'completed',
+    'abandoned',
+]);
+export const Priority = z.enum(['P0', 'P1', 'P2']);
+// ---------------------------------------------------------------------------
+// Base schema
+// ---------------------------------------------------------------------------
+export const BaseWorkItem = z.object({
+    id: z.string(),
+    type: WorkItemType,
+    title: z.string(),
+    status: LifecycleState,
+    parentId: z.string().optional(),
+    category: z.string().optional(),
+    createdAt: z.string(), // ISO date
+    updatedAt: z.string(), // ISO date
+    tags: z.array(z.string()).optional(),
+});
+// ---------------------------------------------------------------------------
+// Extended types (discriminated on `type`)
+// ---------------------------------------------------------------------------
+export const FeatureRecord = BaseWorkItem.extend({
+    type: z.literal('feature'),
+    category: z.string().optional(),
+    taskCount: z.number(),
+    completedTaskCount: z.number(),
+    hasSpec: z.boolean(),
+    hasDesign: z.boolean(),
+    specSummary: z.string().optional(),
+    repoId: z.string().optional(),
+    repoName: z.string().optional(),
+});
+export const TaskRecord = BaseWorkItem.extend({
+    type: z.literal('task'),
+    featureId: z.string(),
+    deps: z.array(z.string()),
+    files: z.array(z.string()),
+    role: z.string().optional(),
+});
+export const BacklogRecord = BaseWorkItem.extend({
+    type: z.literal('backlog-item'),
+    category: z.string().optional(),
+    priority: Priority.optional(),
+    description: z.string().optional(),
+    trigger: z.string().optional(),
+    sourceContext: z.string().optional(),
+    sourceDirective: z.string().optional(),
+    repoId: z.string().optional(),
+    repoName: z.string().optional(),
+});
+export const DirectiveRecord = BaseWorkItem.extend({
+    type: z.literal('directive'),
+    projects: z.array(z.string()),
+    checkpoint: z.string().optional(),
+    reportPath: z.string().optional(),
+    // Structured fields from directive.json
+    weight: z.string().optional(),
+    category: z.string().optional(),
+    producedFeatures: z.array(z.string()).optional(),
+    report: z.string().nullable().optional(),
+    backlogSources: z.array(z.string()).optional(),
+    artifacts: z.array(z.string()).optional(),
+});
+export const LessonRecord = z.object({
+    id: z.string(),
+    title: z.string(),
+    filePath: z.string(),
+    contentSummary: z.string().optional(),
+    topics: z.array(z.string()).optional(),
+    updatedAt: z.string(),
+});
+export const ArtifactRecord = BaseWorkItem.extend({
+    type: z.literal('report').or(z.literal('discussion')).or(z.literal('research')),
+    participants: z.array(z.string()).optional(),
+    sourceDirective: z.string().optional(),
+    filePath: z.string(),
+    contentSummary: z.string().optional(),
+});
+// ---------------------------------------------------------------------------
+// Discriminated union
+// ---------------------------------------------------------------------------
+export const WorkItem = z.discriminatedUnion('type', [
+    FeatureRecord,
+    TaskRecord,
+    BacklogRecord,
+    DirectiveRecord,
+    // ArtifactRecord covers report, discussion, research — but discriminatedUnion
+    // needs literal type values, so we split:
+    BaseWorkItem.extend({
+        type: z.literal('report'),
+        participants: z.array(z.string()).optional(),
+        sourceDirective: z.string().optional(),
+        filePath: z.string(),
+        contentSummary: z.string().optional(),
+    }),
+    BaseWorkItem.extend({
+        type: z.literal('discussion'),
+        participants: z.array(z.string()).optional(),
+        sourceDirective: z.string().optional(),
+        filePath: z.string(),
+        contentSummary: z.string().optional(),
+    }),
+    BaseWorkItem.extend({
+        type: z.literal('research'),
+        participants: z.array(z.string()).optional(),
+        sourceDirective: z.string().optional(),
+        filePath: z.string(),
+        contentSummary: z.string().optional(),
+    }),
+]);
+// ---------------------------------------------------------------------------
+// State file schemas (what the JSON files contain)
+// ---------------------------------------------------------------------------
+export const FeaturesState = z.object({
+    generated: z.string(),
+    features: z.array(FeatureRecord),
+});
+export const BacklogsState = z.object({
+    generated: z.string(),
+    items: z.array(BacklogRecord),
+});
+export const ConductorState = z.object({
+    generated: z.string(),
+    directives: z.array(DirectiveRecord),
+    reports: z.array(ArtifactRecord),
+    discussions: z.array(ArtifactRecord),
+    research: z.array(ArtifactRecord),
+    lessons: z.array(LessonRecord).optional(),
+});
+export const IndexState = z.object({
+    generated: z.string(),
+    counts: z.object({
+        activeFeatures: z.number(),
+        doneFeatures: z.number(),
+        pendingTasks: z.number(),
+        completedTasks: z.number(),
+        backlogItems: z.number(),
+        directives: z.number(),
+        reports: z.number(),
+        discussions: z.number(),
+        lessons: z.number().optional(),
+    }),
+});

package/dist-server/server/types.d.ts

@@ -0,0 +1,237 @@
+export interface Team {
+    name: string;
+    description: string;
+    members: TeamMember[];
+    createdAt: string;
+    leadAgentId: string;
+    leadSessionId: string;
+    stale: boolean;
+}
+export interface TeamMember {
+    name: string;
+    agentId: string;
+    agentType: string;
+    model: string;
+    tmuxPaneId: string;
+    cwd: string;
+    color: string;
+    isActive: boolean;
+    backendType: string;
+    joinedAt: string;
+}
+export interface TeamTask {
+    id: string;
+    subject: string;
+    description: string;
+    activeForm: string;
+    status: 'pending' | 'in_progress' | 'completed';
+    owner: string;
+    blocks: string[];
+    blockedBy: string[];
+}
+export interface Session {
+    id: string;
+    project: string;
+    projectDir: string;
+    status: 'working' | 'waiting-approval' | 'waiting-input' | 'done' | 'paused' | 'idle' | 'error';
+    lastActivity: string;
+    feature?: string;
+    model?: string;
+    cwd?: string;
+    gitBranch?: string;
+    version?: string;
+    slug?: string;
+    initialPrompt?: string;
+    latestPrompt?: string;
+    tasksId?: string;
+    paneId?: string;
+    terminalApp?: 'iterm2' | 'warp' | 'terminal' | 'tmux' | 'unknown';
+    isSubagent: boolean;
+    parentSessionId?: string;
+    agentId?: string;
+    agentName?: string;
+    agentRole?: string;
+    subagentIds: string[];
+    fileSize: number;
+    /** True when a subagent has error/waiting status that needs parent attention */
+    subagentAttention?: boolean;
+    /** Names of active subagents (propagated from working parent) */
+    activeSubagentNames?: string[];
+}
+export interface ProjectGroup {
+    name: string;
+    dirName: string;
+    sessions: Session[];
+}
+export interface HookEvent {
+    id: string;
+    type: string;
+    sessionId: string;
+    timestamp: string;
+    message: string;
+    project?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface DirectiveProjectTask {
+    title: string;
+    status: string;
+    agent?: string;
+    dod?: Array<{
+        criterion: string;
+        met: boolean;
+    }>;
+}
+export interface DirectiveProject {
+    id: string;
+    title: string;
+    status: 'pending' | 'in_progress' | 'completed' | 'skipped' | 'failed';
+    phase: 'audit' | 'design' | 'build' | 'review' | null;
+    totalTasks?: number;
+    completedTasks?: number;
+    tasks?: DirectiveProjectTask[];
+}
+export type PipelineStepStatus = 'pending' | 'active' | 'completed' | 'skipped' | 'failed';
+export interface PipelineStep {
+    id: string;
+    label: string;
+    status: PipelineStepStatus;
+    artifacts?: Record<string, string>;
+    needsAction?: boolean;
+    startedAt?: string;
+}
+export interface DirectiveState {
+    directiveName: string;
+    /** Human-readable title (from directive .json or .md heading) */
+    title?: string;
+    status: 'pending' | 'in_progress' | 'awaiting_completion' | 'completed' | 'failed';
+    totalProjects: number;
+    currentProject: number;
+    currentPhase: string;
+    projects: DirectiveProject[];
+    startedAt: string;
+    lastUpdated: string;
+    /** Pipeline step progress derived from checkpoint data */
+    pipelineSteps?: PipelineStep[];
+    /** Current pipeline step ID */
+    currentStepId?: string;
+    /** Directive weight class */
+    weight?: string;
+    /** Directive category (e.g. game, ui, framework) */
+    category?: string;
+    /** Triage rationale — why this weight was assigned */
+    triageRationale?: string;
+    /** CEO approval status */
+    approvalStatus?: string;
+    /** Brainstorm summary from brainstorm step output */
+    brainstormSummary?: string;
+    /** Plan summary from plan step output */
+    planSummary?: string;
+    /** Full brainstorm markdown content */
+    brainstormContent?: string;
+    /** Full directive brief markdown content (often contains plan) */
+    directiveBrief?: string;
+}
+export interface DashboardState {
+    teams: Team[];
+    sessions: Session[];
+    projects: ProjectGroup[];
+    tasksByTeam: Record<string, TeamTask[]>;
+    tasksBySession: Record<string, TeamTask[]>;
+    events: HookEvent[];
+    sessionActivities: Record<string, SessionActivity>;
+    directiveState: DirectiveState | null;
+    directiveHistory: DirectiveState[];
+    activeDirectives: DirectiveState[];
+    lastUpdated: string;
+}
+export interface ProjectConfig {
+    name: string;
+    path: string;
+    /** Source of this project config: 'config' (from config.json) or 'discovered' (from ~/.claude/projects/) */
+    source?: 'config' | 'discovered';
+}
+export interface NotificationConfig {
+    macOS: boolean;
+    browser: boolean;
+}
+export interface ConductorConfig {
+    projects: ProjectConfig[];
+    claudeHome: string;
+    server: {
+        port: number;
+    };
+    notifications: NotificationConfig;
+}
+export interface SendInputRequest {
+    paneId: string;
+    input: string;
+    type: 'approve' | 'reject' | 'abort' | 'text';
+}
+export interface SessionActivity {
+    sessionId: string;
+    tool?: string;
+    detail?: string;
+    thinking?: boolean;
+    model?: string;
+    lastSeen: string;
+    active: boolean;
+}
+export type WsMessageType = 'full_state' | 'sessions_updated' | 'projects_updated' | 'teams_updated' | 'tasks_updated' | 'event_added' | 'events_updated' | 'session_activities_updated' | 'notification_fired' | 'directive_updated' | 'state_updated';
+export interface WsMessage {
+    version: 1;
+    type: WsMessageType;
+    payload: unknown;
+}
+export interface IntelligenceAgentStats {
+    agent: string;
+    domain: string;
+    totalFindings: number;
+    findingsByUrgency: Record<string, number>;
+    findingsByType: Record<string, number>;
+    proposalsSubmitted: number;
+    proposalsAccepted: number;
+    acceptanceRate: number;
+    topProducts: string[];
+}
+export interface IntelligenceTopicCluster {
+    topic: string;
+    keywords: string[];
+    mentionCount: number;
+    agents: string[];
+    urgencyMax: string;
+    items: Array<{
+        id: string;
+        title: string;
+        agent: string;
+        urgency: string;
+    }>;
+}
+export interface IntelligenceCrossScoutSignal {
+    topic: string;
+    agentCount: number;
+    agents: string[];
+    totalMentions: number;
+    highestUrgency: string;
+    items: Array<{
+        id: string;
+        title: string;
+        agent: string;
+        urgency: string;
+    }>;
+    strength: 'strong' | 'moderate' | 'weak';
+    shouldPromote: boolean;
+}
+export interface IntelligenceTrendsResult {
+    generated: string;
+    scoutDate: string | null;
+    totalFindings: number;
+    totalProposals: number;
+    totalAccepted: number;
+    overallAcceptanceRate: number;
+    agentStats: IntelligenceAgentStats[];
+    topTopics: IntelligenceTopicCluster[];
+    crossScoutSignals: IntelligenceCrossScoutSignal[];
+    urgencyBreakdown: Record<string, number>;
+    typeBreakdown: Record<string, number>;
+    productHeatmap: Record<string, number>;
+}

package/dist-server/server/types.js

@@ -0,0 +1 @@
+export {};

package/dist-server/server/watchers/claude-watcher.d.ts

@@ -0,0 +1,17 @@
+import type { AggregatorHandle } from '../platform/types.js';
+export declare class ClaudeWatcher {
+    private watcher;
+    private aggregator;
+    private claudeHome;
+    private teamsDebounceTimer;
+    private tasksDebounceTimers;
+    private pollTimer;
+    private lastTeamsMtime;
+    private _ready;
+    constructor(aggregator: AggregatorHandle, claudeHome: string);
+    start(): void;
+    get ready(): boolean;
+    stop(): Promise<void>;
+    private startPollFallback;
+    private handleChange;
+}

package/dist-server/server/watchers/claude-watcher.js

@@ -0,0 +1,130 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { watch } from 'chokidar';
+const UUID_DIR_REGEX = /^[0-9a-f]{8}-/;
+export class ClaudeWatcher {
+    watcher = null;
+    aggregator;
+    claudeHome;
+    teamsDebounceTimer = null;
+    tasksDebounceTimers = new Map();
+    pollTimer = null;
+    lastTeamsMtime = 0;
+    _ready = false;
+    constructor(aggregator, claudeHome) {
+        this.aggregator = aggregator;
+        this.claudeHome = claudeHome;
+    }
+    start() {
+        const teamsDir = path.join(this.claudeHome, 'teams');
+        // If directory doesn't exist yet, just start poll fallback (will pick it up when created)
+        if (!fs.existsSync(teamsDir)) {
+            console.log(`[claude-watcher] Teams directory not found: ${teamsDir}, polling only`);
+            this._ready = true;
+            this.startPollFallback();
+            return;
+        }
+        const watchPaths = [teamsDir];
+        // Also watch tasks dir if it exists
+        const tasksDir = path.join(this.claudeHome, 'tasks');
+        if (fs.existsSync(tasksDir)) {
+            watchPaths.push(tasksDir);
+        }
+        console.log(`[claude-watcher] Watching ${watchPaths.join(', ')}`);
+        this.watcher = watch(watchPaths, {
+            ignoreInitial: true,
+            persistent: true,
+            awaitWriteFinish: {
+                stabilityThreshold: 200,
+                pollInterval: 50,
+            },
+        });
+        this.watcher.on('all', (_event, filePath) => {
+            // Only care about JSON files
+            if (!filePath.endsWith('.json'))
+                return;
+            this.handleChange(filePath);
+        });
+        this.watcher.on('ready', () => {
+            this._ready = true;
+            console.log(`[claude-watcher] Ready`);
+        });
+        this.watcher.on('error', (err) => {
+            console.error(`[claude-watcher] Error:`, err);
+        });
+        this.startPollFallback();
+    }
+    get ready() {
+        return this._ready;
+    }
+    async stop() {
+        if (this.teamsDebounceTimer) {
+            clearTimeout(this.teamsDebounceTimer);
+        }
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+        for (const timer of this.tasksDebounceTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.tasksDebounceTimers.clear();
+        if (this.watcher) {
+            await this.watcher.close();
+            this.watcher = null;
+        }
+    }
+    startPollFallback() {
+        if (this.pollTimer)
+            return;
+        this.pollTimer = setInterval(() => {
+            const teamsDir = path.join(this.claudeHome, 'teams');
+            try {
+                const stat = fs.statSync(teamsDir);
+                if (stat.mtimeMs !== this.lastTeamsMtime) {
+                    this.lastTeamsMtime = stat.mtimeMs;
+                    this.aggregator.refreshTeams();
+                }
+            }
+            catch {
+                // teams dir may not exist yet
+            }
+        }, 5000);
+    }
+    handleChange(filePath) {
+        const teamsDir = path.join(this.claudeHome, 'teams');
+        const tasksDir = path.join(this.claudeHome, 'tasks');
+        if (filePath.startsWith(teamsDir)) {
+            // Teams config changed — debounce per teams dir
+            if (this.teamsDebounceTimer) {
+                clearTimeout(this.teamsDebounceTimer);
+            }
+            this.teamsDebounceTimer = setTimeout(() => {
+                console.log(`[claude-watcher] Teams config changed, refreshing teams`);
+                this.aggregator.refreshTeams();
+                this.teamsDebounceTimer = null;
+            }, 300);
+        }
+        else if (filePath.startsWith(tasksDir)) {
+            // Task file changed — extract teamName and debounce per team
+            const relative = path.relative(tasksDir, filePath);
+            const parts = relative.split(path.sep);
+            if (parts.length < 1)
+                return;
+            const teamName = parts[0];
+            // Skip UUID-named directories
+            if (UUID_DIR_REGEX.test(teamName))
+                return;
+            // Debounce per team name
+            const existing = this.tasksDebounceTimers.get(teamName);
+            if (existing) {
+                clearTimeout(existing);
+            }
+            this.tasksDebounceTimers.set(teamName, setTimeout(() => {
+                console.log(`[claude-watcher] Tasks changed for team "${teamName}", refreshing tasks`);
+                this.aggregator.refreshTasks(teamName);
+                this.tasksDebounceTimers.delete(teamName);
+            }, 300));
+        }
+    }
+}

package/dist-server/server/watchers/context-watcher.d.ts

@@ -0,0 +1,22 @@
+import type { ConductorConfig } from '../types.js';
+/**
+ * Watches .context/ for changes to source files (md, json, tasks.json)
+ * and automatically re-runs the state indexer to keep .context/state/ fresh.
+ *
+ * Pipeline: .context/*.md changes → ContextWatcher → runs index-state.ts →
+ * outputs .context/state/*.json → StateWatcher picks up → dashboard updates
+ */
+export declare class ContextWatcher {
+    private watchers;
+    private config;
+    private debounceTimer;
+    private indexing;
+    private pendingReindex;
+    private _ready;
+    constructor(config: ConductorConfig);
+    start(): void;
+    get ready(): boolean;
+    stop(): Promise<void>;
+    private handleChange;
+    private runIndexer;
+}

package/dist-server/server/watchers/context-watcher.js

@@ -0,0 +1,125 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { execFile } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+import { watch } from 'chokidar';
+/**
+ * Watches .context/ for changes to source files (md, json, tasks.json)
+ * and automatically re-runs the state indexer to keep .context/state/ fresh.
+ *
+ * Pipeline: .context/*.md changes → ContextWatcher → runs index-state.ts →
+ * outputs .context/state/*.json → StateWatcher picks up → dashboard updates
+ */
+export class ContextWatcher {
+    watchers = [];
+    config;
+    debounceTimer = null;
+    indexing = false;
+    pendingReindex = false;
+    _ready = false;
+    constructor(config) {
+        this.config = config;
+    }
+    start() {
+        if (this.config.projects.length === 0) {
+            console.log('[context-watcher] No projects configured, skipping');
+            this._ready = true;
+            return;
+        }
+        for (const project of this.config.projects) {
+            const contextDir = path.join(project.path, '.context');
+            if (!fs.existsSync(contextDir)) {
+                console.log(`[context-watcher] No .context/ dir for ${project.name}, skipping`);
+                continue;
+            }
+            console.log(`[context-watcher] Watching ${contextDir} (${project.name})`);
+            const watcher = watch(contextDir, {
+                ignoreInitial: true,
+                persistent: true,
+                // Ignore state/ directory (that's our output, not input)
+                ignored: [
+                    path.join(contextDir, 'state', '**'),
+                    '**/node_modules/**',
+                ],
+                awaitWriteFinish: {
+                    stabilityThreshold: 500,
+                    pollInterval: 100,
+                },
+                // Don't watch too deep to avoid performance issues
+                depth: 6,
+            });
+            watcher.on('all', (_event, filePath) => {
+                // Only care about relevant file types
+                if (!filePath.endsWith('.md') && !filePath.endsWith('.json'))
+                    return;
+                this.handleChange(project.path);
+            });
+            watcher.on('ready', () => {
+                console.log(`[context-watcher] Ready for ${project.name}`);
+            });
+            watcher.on('error', (err) => {
+                console.error(`[context-watcher] Error for ${project.name}:`, err);
+            });
+            this.watchers.push(watcher);
+        }
+        this._ready = true;
+    }
+    get ready() {
+        return this._ready;
+    }
+    async stop() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        for (const watcher of this.watchers) {
+            await watcher.close();
+        }
+        this.watchers = [];
+    }
+    handleChange(projectPath) {
+        // Debounce: wait 2 seconds after last change before indexing
+        // (multiple files often change together during a directive)
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        this.debounceTimer = setTimeout(() => {
+            this.debounceTimer = null;
+            this.runIndexer(projectPath);
+        }, 2000);
+    }
+    runIndexer(projectPath) {
+        // If already indexing, queue a re-run
+        if (this.indexing) {
+            this.pendingReindex = true;
+            return;
+        }
+        this.indexing = true;
+        const conductorRoot = path.resolve(__dirname, '../..');
+        const scriptPath = path.join(conductorRoot, 'scripts', 'index-state.ts');
+        if (!fs.existsSync(scriptPath)) {
+            console.log(`[context-watcher] No indexer script at ${scriptPath}, skipping`);
+            this.indexing = false;
+            return;
+        }
+        console.log('[context-watcher] Re-indexing .context/ ...');
+        execFile('npx', ['tsx', scriptPath, '--context-path', path.join(projectPath, '.context')], {
+            cwd: conductorRoot,
+            timeout: 30000,
+        }, (error, _stdout, stderr) => {
+            this.indexing = false;
+            if (error) {
+                console.error('[context-watcher] Indexer failed:', stderr || error.message);
+            }
+            else {
+                console.log('[context-watcher] Re-index complete');
+            }
+            // If changes came in while indexing, run again
+            if (this.pendingReindex) {
+                this.pendingReindex = false;
+                this.runIndexer(projectPath);
+            }
+        });
+    }
+}