maestro-flow 0.1.4 → 0.2.1

package/dashboard/dist-server/src/shared/requirement-types.d.ts

@@ -0,0 +1,73 @@
+/** Requirement expansion lifecycle status */
+export type RequirementStatus = 'draft' | 'expanding' | 'reviewing' | 'committing' | 'done' | 'failed';
+/** Controls granularity of requirement decomposition */
+export type ExpansionDepth = 'high-level' | 'standard' | 'atomic';
+/** Single item in an expanded requirement checklist */
+export interface ChecklistItem {
+    id: string;
+    title: string;
+    description: string;
+    type: 'feature' | 'task' | 'bug' | 'improvement';
+    priority: 'low' | 'medium' | 'high' | 'urgent';
+    dependencies: string[];
+    estimated_effort: string;
+}
+/** Full expanded requirement with metadata and checklist items */
+export interface ExpandedRequirement {
+    id: string;
+    status: RequirementStatus;
+    userInput: string;
+    title: string;
+    summary: string;
+    items: ChecklistItem[];
+    depth: ExpansionDepth;
+    createdAt: string;
+    updatedAt: string;
+    error?: string;
+}
+/** Client requests requirement expansion */
+export interface RequirementExpandMessage {
+    action: 'requirement:expand';
+    text: string;
+    depth?: ExpansionDepth;
+    /** When continuing from a prior expansion, include its ID as context */
+    previousRequirementId?: string;
+}
+/** Client requests refinement of an existing expansion */
+export interface RequirementRefineMessage {
+    action: 'requirement:refine';
+    requirementId: string;
+    feedback: string;
+}
+/** Client requests commit (dual mode: issues or coordinate) */
+export interface RequirementCommitMessage {
+    action: 'requirement:commit';
+    requirementId: string;
+    mode: 'issues' | 'coordinate';
+}
+/** Server sends expansion progress updates */
+export interface RequirementProgressPayload {
+    requirementId: string;
+    status: RequirementStatus;
+    stage: string;
+    progress: number;
+    message?: string;
+}
+/** Server sends the expanded requirement result */
+export interface RequirementExpandedPayload {
+    requirement: ExpandedRequirement;
+}
+/** Server sends commit result */
+export interface RequirementCommittedPayload {
+    requirementId: string;
+    mode: 'issues' | 'coordinate';
+    /** For issues mode: the created issue IDs */
+    issueIds?: string[];
+    /** For coordinate mode: the session ID */
+    coordinateSessionId?: string;
+}
+/** Server sends error */
+export interface RequirementErrorPayload {
+    requirementId?: string;
+    error: string;
+}

package/dashboard/dist-server/src/shared/requirement-types.js

@@ -0,0 +1,5 @@
+// ---------------------------------------------------------------------------
+// Requirement expansion types -- shared between server and client
+// ---------------------------------------------------------------------------
+export {};
+//# sourceMappingURL=requirement-types.js.map

package/dashboard/dist-server/src/shared/requirement-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"requirement-types.js","sourceRoot":"","sources":["../../../src/shared/requirement-types.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,kEAAkE;AAClE,8EAA8E"}

package/dashboard/dist-server/src/shared/schedule-types.d.ts

@@ -0,0 +1,18 @@
+export interface TaskRunHistory {
+    timestamp: string;
+    status: 'success' | 'failed' | 'skipped';
+    duration: number;
+    result?: string;
+}
+export type ScheduledTaskType = 'auto-dispatch' | 'cleanup' | 'report' | 'health-check' | 'learning-analysis' | 'custom';
+export interface ScheduledTask {
+    id: string;
+    name: string;
+    cronExpression: string;
+    taskType: ScheduledTaskType;
+    config: Record<string, unknown>;
+    enabled: boolean;
+    lastRun: string | null;
+    nextRun: string | null;
+    history: TaskRunHistory[];
+}

package/dashboard/dist-server/src/shared/schedule-types.js

@@ -0,0 +1,5 @@
+// ---------------------------------------------------------------------------
+// Schedule types -- scheduled tasks and run history
+// ---------------------------------------------------------------------------
+export {};
+//# sourceMappingURL=schedule-types.js.map

package/dashboard/dist-server/src/shared/schedule-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule-types.js","sourceRoot":"","sources":["../../../src/shared/schedule-types.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,oDAAoD;AACpD,8EAA8E"}

package/dashboard/dist-server/src/shared/team-types.d.ts

@@ -0,0 +1,65 @@
+export interface PipelineNode {
+    id: string;
+    name: string;
+    status: 'done' | 'in_progress' | 'pending' | 'skipped';
+    wave?: number;
+}
+export interface TeamRole {
+    name: string;
+    prefix: string;
+    status: 'done' | 'active' | 'pending' | 'injected';
+    taskCount: number;
+    innerLoop: boolean;
+    injected?: boolean;
+    injectionReason?: string;
+}
+export interface TeamMessage {
+    id: string;
+    ts: string;
+    from: string;
+    to: string;
+    type: string;
+    summary: string;
+    data?: Record<string, unknown>;
+}
+export interface SessionFileEntry {
+    id: string;
+    path: string;
+    name: string;
+    category: 'artifacts' | 'role-specs' | 'session' | 'wisdom' | 'message-bus';
+    status?: string;
+    isNew?: boolean;
+}
+export interface TeamSessionSummary {
+    sessionId: string;
+    title: string;
+    description: string;
+    status: 'active' | 'completed' | 'failed' | 'archived';
+    skill: string;
+    roles: string[];
+    taskProgress: {
+        completed: number;
+        total: number;
+    };
+    messageCount: number;
+    duration: string;
+    createdAt: string;
+    updatedAt: string;
+    pipelineStages: PipelineNode[];
+}
+export interface TeamSessionDetail extends TeamSessionSummary {
+    roleDetails: TeamRole[];
+    messages: TeamMessage[];
+    files: SessionFileEntry[];
+    pipeline: {
+        waves: {
+            number: number;
+            nodes: PipelineNode[];
+        }[];
+    };
+}
+export declare const SKILL_PREFIX_MAP: Record<string, string>;
+export declare function inferSkill(sessionId: string): string;
+export declare const TEAM_STATUS_COLORS: Record<TeamSessionSummary['status'], string>;
+export declare const PIPELINE_STATUS_COLORS: Record<PipelineNode['status'], string>;
+export declare const ROLE_STATUS_COLORS: Record<TeamRole['status'], string>;

package/dashboard/dist-server/src/shared/team-types.js

@@ -0,0 +1,54 @@
+// ---------------------------------------------------------------------------
+// Team Session Types — shared between server and client
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Skill prefix → label mapping
+// ---------------------------------------------------------------------------
+export const SKILL_PREFIX_MAP = {
+    'TC-': 'Coordinate',
+    'TLV4-': 'Lifecycle',
+    'QA-': 'QA',
+    'RV-': 'Review',
+    'TST-': 'Testing',
+    'TFD-': 'Frontend Debug',
+    'TPO-': 'Perf Opt',
+    'TTD-': 'Tech Debt',
+    'TPX-': 'Plan & Execute',
+    'TBS-': 'Brainstorm',
+    'TRD-': 'Roadmap Dev',
+    'TIS-': 'Issue',
+    'TID-': 'Iter Dev',
+    'TUA-': 'Ultra Analyze',
+    'TUX-': 'UX Improve',
+    'TUI-': 'UI Design',
+    'TAO-': 'Arch Opt',
+};
+export function inferSkill(sessionId) {
+    for (const [prefix, label] of Object.entries(SKILL_PREFIX_MAP)) {
+        if (sessionId.startsWith(prefix))
+            return label;
+    }
+    return 'Team';
+}
+// ---------------------------------------------------------------------------
+// Status colors for team sessions
+// ---------------------------------------------------------------------------
+export const TEAM_STATUS_COLORS = {
+    active: '#B89540',
+    completed: '#5A9E78',
+    failed: '#C46555',
+    archived: '#A09D97',
+};
+export const PIPELINE_STATUS_COLORS = {
+    done: '#5A9E78',
+    in_progress: '#B89540',
+    pending: '#A09D97',
+    skipped: '#D1CEC8',
+};
+export const ROLE_STATUS_COLORS = {
+    done: '#5A9E78',
+    active: '#B89540',
+    pending: '#A09D97',
+    injected: '#8B6BBF',
+};
+//# sourceMappingURL=team-types.js.map

package/dashboard/dist-server/src/shared/team-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"team-types.js","sourceRoot":"","sources":["../../../src/shared/team-types.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,wDAAwD;AACxD,8EAA8E;AA4D9E,8EAA8E;AAC9E,+BAA+B;AAC/B,8EAA8E;AAE9E,MAAM,CAAC,MAAM,gBAAgB,GAA2B;IACtD,KAAK,EAAE,YAAY;IACnB,OAAO,EAAE,WAAW;IACpB,KAAK,EAAE,IAAI;IACX,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,SAAS;IACjB,MAAM,EAAE,gBAAgB;IACxB,MAAM,EAAE,UAAU;IAClB,MAAM,EAAE,WAAW;IACnB,MAAM,EAAE,gBAAgB;IACxB,MAAM,EAAE,YAAY;IACpB,MAAM,EAAE,aAAa;IACrB,MAAM,EAAE,OAAO;IACf,MAAM,EAAE,UAAU;IAClB,MAAM,EAAE,eAAe;IACvB,MAAM,EAAE,YAAY;IACpB,MAAM,EAAE,WAAW;IACnB,MAAM,EAAE,UAAU;CACV,CAAC;AAEX,MAAM,UAAU,UAAU,CAAC,SAAiB;IAC1C,KAAK,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAE,CAAC;QAC/D,IAAI,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC;YAAE,OAAO,KAAK,CAAC;IACjD,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,8EAA8E;AAC9E,kCAAkC;AAClC,8EAA8E;AAE9E,MAAM,CAAC,MAAM,kBAAkB,GAAiD;IAC9E,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,SAAS;IACpB,MAAM,EAAE,SAAS;IACjB,QAAQ,EAAE,SAAS;CACX,CAAC;AAEX,MAAM,CAAC,MAAM,sBAAsB,GAA2C;IAC5E,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,SAAS;IACtB,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,SAAS;CACV,CAAC;AAEX,MAAM,CAAC,MAAM,kBAAkB,GAAuC;IACpE,IAAI,EAAE,SAAS;IACf,MAAM,EAAE,SAAS;IACjB,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,SAAS;CACX,CAAC"}

package/dashboard/dist-server/src/shared/types.d.ts

@@ -0,0 +1,223 @@
+export type PhaseStatus = 'pending' | 'exploring' | 'planning' | 'executing' | 'verifying' | 'testing' | 'completed' | 'blocked';
+export type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed';
+export type TaskType = 'feature' | 'fix' | 'refactor' | 'test' | 'docs';
+export type ProjectStatus = 'planning' | 'executing' | 'verifying' | 'idle';
+import type { LinearIssue } from './linear-types.js';
+import type { Issue } from './issue-types.js';
+export type SelectedKanbanItem = {
+    type: 'phase';
+    phaseId: number;
+} | {
+    type: 'linearIssue';
+    issue: LinearIssue;
+} | {
+    type: 'issue';
+    issue: Issue;
+} | {
+    type: 'task';
+    task: TaskCard;
+    phaseId: number;
+};
+export type { AgentProcess, NormalizedEntry, ApprovalRequest, AgentStatusPayload, AgentStoppedPayload } from './agent-types.js';
+import type { AgentProcess, NormalizedEntry, ApprovalRequest, AgentStatusPayload, AgentStoppedPayload, AgentTurnCompletedPayload } from './agent-types.js';
+import type { SupervisorStatus } from './execution-types.js';
+import type { LearningStats } from './learning-types.js';
+import type { CommanderState, Decision, CommanderConfig, AssessMetrics } from './commander-types.js';
+import type { ExecutionStartedPayload, ExecutionCompletedPayload, ExecutionFailedPayload } from './ws-protocol.js';
+import type { CoordinateStatusPayload, CoordinateStepPayload, CoordinateAnalysisPayload, CoordinateClarificationPayload } from './coordinate-types.js';
+import type { RequirementProgressPayload, RequirementExpandedPayload, RequirementCommittedPayload, RequirementErrorPayload } from './requirement-types.js';
+import type { ScheduledTask } from './schedule-types.js';
+import type { ExtensionInfo } from './extension-types.js';
+import type { CollabMember, CollabActivityEntry } from './collab-types.js';
+export type SSEEventType = 'board:full' | 'phase:updated' | 'task:updated' | 'scratch:updated' | 'project:updated' | 'watcher:error' | 'heartbeat' | 'connected' | 'agent:spawned' | 'agent:entry' | 'agent:approval' | 'agent:status' | 'agent:stopped' | 'agent:turnCompleted' | 'execution:started' | 'execution:completed' | 'execution:failed' | 'execution:scheduler_status' | 'supervisor:status' | 'supervisor:learning_update' | 'supervisor:schedule_triggered' | 'supervisor:schedule_update' | 'supervisor:extension_loaded' | 'supervisor:extension_error' | 'commander:status' | 'commander:tick' | 'commander:decision' | 'commander:config' | 'commander:assess_metrics' | 'commander:error' | 'coordinate:status' | 'coordinate:analyze_metrics' | 'coordinate:step' | 'coordinate:analysis' | 'coordinate:clarification_needed' | 'coordinate:error' | 'requirement:expanded' | 'requirement:refined' | 'requirement:committed' | 'requirement:progress' | 'workspace:switched' | 'wiki:invalidated' | 'collab:members_updated' | 'collab:activity';
+/** Mirrors state.json — top-level project state */
+export interface ProjectState {
+    version: string;
+    project_name: string;
+    current_milestone: string;
+    current_phase: number;
+    status: ProjectStatus;
+    phases_summary: {
+        total: number;
+        completed: number;
+        in_progress: number;
+        pending: number;
+    };
+    last_updated: string;
+    accumulated_context: {
+        key_decisions: string[];
+        blockers: string[];
+        deferred: string[];
+    };
+}
+/** Mirrors index.json — one phase in the lifecycle pipeline */
+export interface PhaseCard {
+    phase: number;
+    slug: string;
+    title: string;
+    status: PhaseStatus;
+    created_at: string;
+    updated_at: string;
+    goal: string;
+    success_criteria: string[];
+    requirements: string[];
+    spec_ref: string | null;
+    plan: {
+        task_ids: string[];
+        task_count: number;
+        complexity: string | null;
+        waves: (string[] | {
+            wave: number;
+            tasks: string[];
+        })[];
+    };
+    execution: {
+        method: string;
+        started_at: string | null;
+        completed_at: string | null;
+        tasks_completed: number;
+        tasks_total: number;
+        current_wave: number;
+        commits: (string | {
+            hash: string;
+            task: string;
+            message: string;
+        })[];
+    };
+    verification: {
+        status: string;
+        verified_at: string | null;
+        must_haves: string[];
+        gaps: (string | {
+            id?: string;
+            severity?: string;
+            description?: string;
+        })[];
+    };
+    validation: {
+        status: string;
+        test_coverage: number | {
+            statements: number;
+            branches: number;
+            functions: number;
+            lines: number;
+        } | null;
+        gaps: (string | {
+            requirement?: string;
+            status?: string;
+            description?: string;
+        })[];
+    };
+    uat: {
+        status: string;
+        test_count: number;
+        passed: number;
+        gaps: (string | {
+            description?: string;
+        })[];
+    };
+    reflection: {
+        rounds: number;
+        strategy_adjustments: string[];
+    };
+}
+/** Mirrors TASK-*.json — a task within a phase */
+export interface TaskCard {
+    id: string;
+    title: string;
+    description: string;
+    type: TaskType;
+    priority: string;
+    effort: string;
+    action: string;
+    scope: string;
+    focus_paths: string[];
+    depends_on: string[];
+    parallel_group: string | null;
+    convergence: {
+        criteria: string[];
+        verification: string;
+        definition_of_done: string;
+    };
+    files: Array<{
+        path: string;
+        action: string;
+        target: string;
+        change: string;
+    }>;
+    implementation: string[];
+    test: {
+        commands: string[];
+        unit: string[];
+        integration: string[];
+        success_metrics: string[];
+    };
+    reference: {
+        pattern: string;
+        files: string[];
+        examples: string | null;
+    };
+    rationale: {
+        chosen_approach: string;
+        decision_factors: string[];
+        tradeoffs: string | null;
+    };
+    risks: string[];
+    code_skeleton: string | null;
+    doc_context: {
+        affected_features: string[];
+        affected_components: string[];
+        affected_requirements: string[];
+        adr_ids: string[];
+    };
+    meta: {
+        status: TaskStatus;
+        estimated_time: string | null;
+        risk: string;
+        autonomous: boolean;
+        checkpoint: boolean;
+        wave: number;
+        execution_group: string | null;
+        executor: string;
+    };
+}
+/** Non-phase scratch tasks (from scratch-index.json) */
+export interface ScratchCard {
+    id: string;
+    title: string;
+    status: TaskStatus;
+    type: TaskType;
+    created_at: string;
+    updated_at: string;
+    description: string;
+    files: string[];
+}
+/** Full board state — assembled by the server from .workflow/ files */
+export interface BoardState {
+    project: ProjectState;
+    phases: PhaseCard[];
+    scratch: ScratchCard[];
+    lastUpdated: string;
+}
+/** SSE event envelope */
+export interface SSEEvent {
+    type: SSEEventType;
+    data: BoardState | PhaseCard | TaskCard | ScratchCard | ProjectState | AgentProcess | NormalizedEntry | ApprovalRequest | AgentStatusPayload | AgentStoppedPayload | AgentTurnCompletedPayload | ExecutionStartedPayload | ExecutionCompletedPayload | ExecutionFailedPayload | SupervisorStatus | CommanderState | Decision | CommanderConfig | AssessMetrics | CoordinateStatusPayload | CoordinateStepPayload | CoordinateAnalysisPayload | CoordinateClarificationPayload | RequirementProgressPayload | RequirementExpandedPayload | RequirementCommittedPayload | RequirementErrorPayload | LearningStats | {
+        taskId: string;
+        taskName: string;
+        taskType: string;
+    } | {
+        tasks: ScheduledTask[];
+    } | {
+        extensions: ExtensionInfo[];
+    } | {
+        name: string;
+        error: string;
+    } | {
+        workspace: string;
+    } | {
+        at: number;
+        path?: string;
+    } | CollabMember[] | CollabActivityEntry | string | null;
+    timestamp: string;
+}

package/dashboard/dist-server/src/shared/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dashboard/dist-server/src/shared/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/shared/types.ts"],"names":[],"mappings":""}

package/dashboard/dist-server/src/shared/utils.d.ts

@@ -0,0 +1,2 @@
+/** Convert OS-specific path separators to forward slashes */
+export declare function toForwardSlash(p: string): string;

package/dashboard/dist-server/src/shared/utils.js

@@ -0,0 +1,6 @@
+import { sep, posix } from 'node:path';
+/** Convert OS-specific path separators to forward slashes */
+export function toForwardSlash(p) {
+    return p.split(sep).join(posix.sep);
+}
+//# sourceMappingURL=utils.js.map

package/dashboard/dist-server/src/shared/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/shared/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAEvC,6DAA6D;AAC7D,MAAM,UAAU,cAAc,CAAC,CAAS;IACtC,OAAO,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AACtC,CAAC"}

package/dashboard/dist-server/src/shared/utils.test.d.ts

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

package/dashboard/dist-server/src/shared/utils.test.js

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import { toForwardSlash } from './utils.js';
+describe('toForwardSlash', () => {
+    it('converts backslashes to forward slashes', () => {
+        expect(toForwardSlash('a\\b\\c')).toBe('a/b/c');
+    });
+    it('leaves forward slashes unchanged', () => {
+        expect(toForwardSlash('a/b/c')).toBe('a/b/c');
+    });
+    it('handles empty string', () => {
+        expect(toForwardSlash('')).toBe('');
+    });
+    it('handles single segment (no separators)', () => {
+        expect(toForwardSlash('file.ts')).toBe('file.ts');
+    });
+    it('handles Windows absolute paths', () => {
+        const result = toForwardSlash('C:\\Users\\dyw\\project');
+        expect(result).toContain('/');
+        expect(result).not.toContain('\\');
+    });
+});
+//# sourceMappingURL=utils.test.js.map

package/dashboard/dist-server/src/shared/utils.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.test.js","sourceRoot":"","sources":["../../../src/shared/utils.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;IAC9B,EAAE,CAAC,yCAAyC,EAAE,GAAG,EAAE;QACjD,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAClD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,kCAAkC,EAAE,GAAG,EAAE;QAC1C,MAAM,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAChD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,sBAAsB,EAAE,GAAG,EAAE;QAC9B,MAAM,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,wCAAwC,EAAE,GAAG,EAAE;QAChD,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACpD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;QACxC,MAAM,MAAM,GAAG,cAAc,CAAC,yBAAyB,CAAC,CAAC;QACzD,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QAC9B,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IACrC,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dashboard/dist-server/src/shared/wave-types.d.ts

@@ -0,0 +1,41 @@
+/** A single subtask decomposed from an issue */
+export interface WaveTask {
+    id: string;
+    title: string;
+    description: string;
+    /** IDs of tasks this depends on (must complete before this runs) */
+    deps: string[];
+    /** IDs of tasks whose results should be injected as context */
+    contextFrom: string[];
+    /** Computed wave number (0-based), set by topological sort */
+    wave: number;
+    /** Current execution status */
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    /** Result summary after completion */
+    findings?: string;
+    /** Files modified by this task */
+    filesModified?: string[];
+    /** Error message if failed */
+    error?: string;
+}
+/** Wave execution session state */
+export interface WaveSession {
+    issueId: string;
+    processId: string;
+    status: 'decomposing' | 'executing' | 'completed' | 'failed';
+    tasks: WaveTask[];
+    totalWaves: number;
+    currentWave: number;
+    startedAt: string;
+    completedAt?: string;
+}
+/** Structured output from the decomposition Agent SDK query */
+export interface DecompositionResult {
+    tasks: Array<{
+        id: string;
+        title: string;
+        description: string;
+        deps: string[];
+        contextFrom: string[];
+    }>;
+}

package/dashboard/dist-server/src/shared/wave-types.js

@@ -0,0 +1,5 @@
+// ---------------------------------------------------------------------------
+// Wave execution types — CSV-wave-inspired parallel task execution
+// ---------------------------------------------------------------------------
+export {};
+//# sourceMappingURL=wave-types.js.map

package/dashboard/dist-server/src/shared/wave-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wave-types.js","sourceRoot":"","sources":["../../../src/shared/wave-types.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,mEAAmE;AACnE,8EAA8E"}