@brainforge/core 3.1.4 → 3.1.6

package/dist/index.d.ts

@@ -1,10 +1,14 @@
 import { EventEmitter } from 'events';
 
-type ProjectType = 'student' | 'junior' | 'solo';
+type ProjectType = 'student' | 'junior' | 'solo' | 'personal' | 'pro';
 type StudentLevel = 'beginner' | 'intermediate' | 'advanced';
-type Language = 'typescript' | 'javascript' | 'python' | 'java' | 'go' | 'php';
+type Language = 'typescript' | 'javascript' | 'python' | 'java' | 'go' | 'php' | 'rust' | 'csharp' | 'ruby';
 type PhaseStatus = 'pending' | 'active' | 'completed' | 'blocked';
 type TaskStatus = 'todo' | 'in-progress' | 'done' | 'skipped';
+type TaskPriority = 'low' | 'medium' | 'high' | 'critical';
+type TaskType = 'backend' | 'frontend' | 'database' | 'devops' | 'security' | 'test' | 'docs' | 'general';
+type BugSeverity = 'blocker' | 'high' | 'medium' | 'low';
+type AgentId = 'orchestrator' | 'researcher' | 'codebase-mapper' | 'requirements-analyst' | 'architect' | 'planner' | 'backend-engineer' | 'frontend-engineer' | 'fullstack-engineer' | 'database-engineer' | 'devops-engineer' | 'security-reviewer' | 'test-engineer' | 'ui-reviewer' | 'debugger' | 'verifier' | 'docs-writer' | 'professor' | 'student-explainer' | 'ship-manager';
 interface ProjectConfig {
     name: string;
     description: string;
@@ -19,11 +23,61 @@ interface Task {
     title: string;
     description: string;
     status: TaskStatus;
+    priority: TaskPriority;
+    type?: TaskType;
     files?: string[];
+    agent?: AgentId;
+    parallelGroup?: string;
+    dependsOn?: string[];
+    acceptanceCriteria?: string[];
+    verificationCommands?: string[];
+    riskLevel?: 'low' | 'medium' | 'high';
     context?: Record<string, unknown>;
     createdAt: string;
     updatedAt: string;
 }
+interface BugReport {
+    id: string;
+    phaseId: string;
+    title: string;
+    description: string;
+    severity: BugSeverity;
+    likelyFiles: string[];
+    suggestedFix: string;
+    status: 'open' | 'in-progress' | 'fixed' | 'wont-fix';
+    createdAt: string;
+    resolvedAt?: string;
+}
+interface AcceptanceCriterionResult {
+    criterion: string;
+    passed: boolean;
+    note?: string;
+}
+interface VerificationResult {
+    phaseId: string;
+    verifiedAt: string;
+    passed: boolean;
+    acceptanceCriteria: AcceptanceCriterionResult[];
+    bugs: BugReport[];
+    testsPassed: boolean;
+    buildPassed: boolean;
+    summary: string;
+}
+interface WaveGroup {
+    wave: number;
+    taskIds: string[];
+    canRunParallel: boolean;
+    conflicts: string[][];
+}
+interface RunRecord {
+    id: string;
+    phaseId?: string;
+    command: string;
+    startedAt: string;
+    completedAt?: string;
+    status: 'running' | 'completed' | 'failed';
+    dir: string;
+}
 interface Phase {
     id: string;
     name: string;
@@ -53,6 +107,46 @@ interface BrainforgeState {
     };
 }
 
+type WorkflowMode = 'student' | 'simple' | 'pro';
+type RuntimeName = 'claude-code' | 'codex' | 'opencode' | 'gemini-cli' | 'cursor' | 'windsurf' | 'copilot' | 'vscode' | 'cline' | 'generic';
+interface BrainForgeConfig {
+    version: number;
+    mode: WorkflowMode;
+    runtime: RuntimeName;
+    parallelization: {
+        enabled: boolean;
+        maxAgents: number;
+    };
+    automation: {
+        autoCommit: boolean;
+        verifyEachPhase: boolean;
+        shipEachPhase: boolean;
+        stopOnFailure: boolean;
+    };
+    memory: {
+        contextPacketMaxTokens: number;
+        summarizeAfterEachRun: boolean;
+        keepRawLogs: boolean;
+    };
+    student: {
+        enabled: boolean;
+        level: 'beginner' | 'intermediate' | 'advanced';
+        professorMode: boolean;
+    };
+    safety: {
+        redactSecrets: boolean;
+        requireCleanGit: boolean;
+        dryRunByDefault: boolean;
+    };
+    dashboard: {
+        enabled: boolean;
+        port: number;
+    };
+}
+declare const DEFAULT_CONFIG: BrainForgeConfig;
+declare function loadConfig(cwd: string): Promise<BrainForgeConfig>;
+declare function saveConfig(cwd: string, config: BrainForgeConfig): Promise<void>;
+
 declare class StateManager {
     private readonly workingDir;
     private statePath;
@@ -61,6 +155,8 @@ declare class StateManager {
     load(): Promise<BrainforgeState>;
     save(): Promise<void>;
     init(project: ProjectConfig): Promise<BrainforgeState>;
+    loadWorkspaceConfig(): Promise<BrainForgeConfig>;
+    saveWorkspaceConfig(config: BrainForgeConfig): Promise<void>;
     get(): BrainforgeState;
     set(updater: (state: BrainforgeState) => void): void;
     configureAI(config: AIConfig): Promise<void>;
@@ -72,7 +168,50 @@ declare class StateManager {
     private writeStateMd;
 }
 
+declare class Workspace {
+    private readonly cwd;
+    readonly brainforgeDir: string;
+    constructor(cwd: string);
+    ensureDirectories(): Promise<void>;
+    loadConfig(): Promise<BrainForgeConfig>;
+    saveConfig(config: BrainForgeConfig): Promise<void>;
+    initConfig(overrides?: Partial<BrainForgeConfig>): Promise<BrainForgeConfig>;
+    configExists(): Promise<boolean>;
+    stateExists(): Promise<boolean>;
+    phasePath(phaseId: string): string;
+    memoryPath(): string;
+    codebasePath(): string;
+    runsPath(): string;
+    runPath(runId: string): string;
+    skillsPath(): string;
+    forensicsPath(): string;
+    ensurePhaseDir(phaseId: string): Promise<void>;
+    ensureRunDir(runId: string): Promise<void>;
+    private ensureInitialFiles;
+}
+
+interface MigrationResult {
+    ran: boolean;
+    actions: string[];
+}
+declare function detectAndMigrate(cwd: string): Promise<MigrationResult>;
+
+interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+declare function validateConfig(config: unknown): ValidationResult;
+declare function validatePhase(phase: unknown): ValidationResult;
+declare function validateTask(task: unknown): ValidationResult;
+declare function validateProjectConfig(config: unknown): ValidationResult;
+
 type StateAction = {
+    type: 'ADD_PHASE';
+    phase: Omit<Phase, 'completedAt' | 'description'> & {
+        description?: string;
+    };
+} | {
     type: 'SET_ACTIVE_PHASE';
     phaseId: string;
 } | {
@@ -82,6 +221,10 @@ type StateAction = {
     type: 'UPDATE_TASK';
     taskId: string;
     updates: Partial<Task>;
+} | {
+    type: 'UPDATE_TASK_STATUS';
+    taskId: string;
+    status: Task['status'];
 } | {
     type: 'SET_CONTEXT';
     key: string;
@@ -392,4 +535,509 @@ declare class DeepSeekAdapter implements AIAdapter {
     complete(prompt: string, options?: CompletionOptions): Promise<string>;
 }
 
-export { type AIAdapter, type AIConfig, type AIProvider, AdapterManager, BUILT_IN_SKILLS, BrainForgeServer, type BrainforgeState, type ClassInfo, ClaudeAdapter, type CodebaseMap, CodebaseMapper, type CompletionOptions, type ContextField, DeepSeekAdapter, type DefenseAnswer, type DefenseSession, type DynamicQuestion, type FileChangeEvent, type FileNode, FileWatcher, type FunctionInfo, GeminiAdapter, type HeuristicPattern, type Language, MockDefense, OpenAIAdapter, type PatternMatch, type Phase, type PhaseStatus, type PlanAction, type PlanStep, ProfessorScanner, type ProjectConfig, type ProjectType, PromptEngine, type Question, type ScanReport, type Severity, type Skill, type SkillCategory, type SkillContext, SkillRegistry, type StateAction, StateManager, type StudentLevel, type Task, type TaskPlan, TaskPlanner, type TaskStatus, buildQuestionSet, reduce };
+type RuntimeId = 'claude-code' | 'codex' | 'opencode' | 'gemini-cli' | 'cursor' | 'windsurf' | 'copilot' | 'vscode' | 'generic';
+type RuntimeCapability = 'slash-commands' | 'rules' | 'snippets' | 'instructions';
+interface RuntimeDefinition {
+    id: RuntimeId;
+    name: string;
+    commandPrefix: string;
+    globalConfigPath: string;
+    localConfigPath: string;
+    commandFileExt: string;
+    capabilities: RuntimeCapability[];
+    notes: string;
+    supportLevel: 'full' | 'partial' | 'fallback';
+}
+declare const RUNTIME_REGISTRY: RuntimeDefinition[];
+declare function getRuntime(id: RuntimeId): RuntimeDefinition | undefined;
+declare function listRuntimes(): RuntimeDefinition[];
+
+interface DetectionResult {
+    id: RuntimeId;
+    name: string;
+    detected: boolean;
+    method?: string;
+    configPath?: string;
+    supportLevel: 'full' | 'partial' | 'fallback';
+}
+declare function detectRuntimes(cwd: string): Promise<DetectionResult[]>;
+
+interface InstallResult {
+    runtimeId: RuntimeId;
+    runtimeName: string;
+    filesWritten: string[];
+    targetDir: string;
+    commandCount: number;
+}
+declare function installRuntime(runtimeId: RuntimeId, opts: {
+    global: boolean;
+    cwd: string;
+}): Promise<InstallResult>;
+
+interface CommandDef {
+    name: string;
+    description: string;
+    cliCommand: string;
+    instruction: string;
+}
+declare const COMMAND_DEFINITIONS: CommandDef[];
+declare const COMMANDS_BY_NAME: Map<string, CommandDef>;
+
+interface AgentContract {
+    id: AgentId;
+    name: string;
+    purpose: string;
+    inputs: string[];
+    outputs: string[];
+    forbidden: string[];
+    qualityChecks: string[];
+    taskTypes: string[];
+}
+
+declare const AGENT_REGISTRY: AgentContract[];
+declare function getAgent(id: AgentId): AgentContract | undefined;
+declare function listAgents(): AgentContract[];
+
+interface Wave {
+    index: number;
+    label: string;
+    tasks: Task[];
+    canParallelize: boolean;
+}
+declare class WavePlanner {
+    plan(tasks: Task[]): Wave[];
+    assignAgents(tasks: Task[]): Map<string, AgentId>;
+}
+
+interface StackInfo {
+    language: string;
+    secondaryLanguages: string[];
+    framework?: string;
+    runtime?: string;
+    buildTool?: string;
+    linter?: string;
+    formatter?: string;
+    packageManager?: string;
+    cssFramework?: string;
+}
+declare function detectStack(cwd: string): Promise<StackInfo>;
+
+interface OrchestratorResult {
+    waves: number;
+    totalTasks: number;
+    files: string[];
+    waveDir: string;
+}
+declare class ParallelOrchestrator {
+    private readonly cwd;
+    private readonly phasesDir;
+    constructor(cwd: string);
+    orchestrate(phase: Phase, stack?: StackInfo): Promise<OrchestratorResult>;
+}
+
+interface ConflictWarning {
+    taskA: string;
+    taskB: string;
+    reason: string;
+    filePaths?: string[];
+}
+declare function detectConflicts(tasks: Task[]): ConflictWarning[];
+
+interface WaveResult {
+    waveIndex: number;
+    completedTaskIds: string[];
+    failedTaskIds: string[];
+    blockers: string[];
+}
+interface MergeReport {
+    totalWaves: number;
+    totalTasks: number;
+    completed: number;
+    failed: number;
+    blocked: boolean;
+    summary: string;
+}
+declare function mergeResults(waves: Wave[], results: WaveResult[]): MergeReport;
+declare function buildMergeReport(tasks: Task[], results: WaveResult[]): string;
+
+interface AgentPromptContext {
+    projectName: string;
+    phaseName: string;
+    stack?: StackInfo;
+    phaseGoal?: string;
+}
+declare function buildAgentPrompt(agent: AgentContract, task: Task, ctx: AgentPromptContext): string;
+declare function buildWaveSummary(wave: number, tasks: Task[], phase: Phase, ctx: AgentPromptContext): string;
+
+interface CreatePhaseInput {
+    id: string;
+    name: string;
+    description?: string;
+    tasks: Omit<Task, 'status'>[];
+}
+declare class WorkflowEngine {
+    buildCreatePhaseAction(input: CreatePhaseInput): StateAction;
+    buildSwitchPhaseAction(phaseId: string): StateAction;
+    buildStartTaskAction(taskId: string): StateAction;
+    buildCompleteTaskAction(taskId: string): StateAction;
+    buildCompletePhaseAction(phaseId: string): StateAction;
+    isPhaseComplete(phase: Phase): boolean;
+    getNextAction(state: BrainforgeState): string;
+    slugify(name: string): string;
+    generatePhaseId(name: string, existingIds: string[]): string;
+}
+
+interface PhaseStepStatus {
+    phaseId: string;
+    step: 'discussion' | 'plan' | 'execution' | 'verification' | 'shipped';
+    updatedAt: string;
+}
+declare class PhaseEngine {
+    private readonly cwd;
+    constructor(cwd: string);
+    phaseDir(phaseId: string): string;
+    ensurePhaseDir(phaseId: string): Promise<void>;
+    writeStatus(phaseId: string, step: PhaseStepStatus['step']): Promise<void>;
+    readStatus(phaseId: string): Promise<PhaseStepStatus | null>;
+    writeArtifact(phaseId: string, filename: string, content: string): Promise<string>;
+    readArtifact(phaseId: string, filename: string): Promise<string | null>;
+    listArtifacts(phaseId: string): Promise<string[]>;
+    relPath(phaseId: string, filename: string): string;
+}
+
+interface ConventionInfo {
+    namingStyle: 'camelCase' | 'snake_case' | 'kebab-case' | 'PascalCase' | 'mixed';
+    folderPattern: string;
+    moduleStyle: 'esm' | 'cjs' | 'mixed' | 'unknown';
+    typescriptStrict: boolean;
+    hasEditorConfig: boolean;
+    hasHusky: boolean;
+    hasLintStaged: boolean;
+    entryPoint?: string;
+}
+declare function detectConventions(cwd: string, files: string[]): Promise<ConventionInfo>;
+
+interface ExecutionContext {
+    projectName: string;
+    stack?: StackInfo;
+    conventions?: ConventionInfo;
+    phaseGoal?: string;
+}
+interface TaskPrompt {
+    taskId: string;
+    taskTitle: string;
+    content: string;
+}
+declare class ExecutionEngine {
+    buildTaskPrompt(phase: Phase, task: Task, ctx: ExecutionContext): TaskPrompt;
+    buildPhasePrompt(phase: Phase, ctx: ExecutionContext): string;
+    buildDryRunSummary(phase: Phase): string;
+}
+
+interface BugEntry {
+    id: string;
+    title: string;
+    severity: 'critical' | 'major' | 'minor';
+    taskId?: string;
+    description?: string;
+}
+interface VerifyResult {
+    phaseId: string;
+    phaseName: string;
+    checkedAt: string;
+    totalCriteria: number;
+    passed: number;
+    bugs: BugEntry[];
+    blocked: boolean;
+}
+declare class VerificationEngine {
+    buildVerifyPrompt(phase: Phase, stack?: StackInfo): string;
+    buildVerifyMd(phase: Phase, bugs?: BugEntry[]): string;
+    buildBugsMd(bugs: BugEntry[]): string;
+}
+
+interface ShipResult {
+    phaseId: string;
+    phaseName: string;
+    shippedAt: string;
+    tasksCompleted: number;
+    memorySummary: string;
+    changelogEntry: string;
+}
+declare class ShipEngine {
+    build(phase: Phase, verifyPassed: boolean): ShipResult;
+    buildShipMd(phase: Phase, result: ShipResult): string;
+    buildMemorySummary(phase: Phase, shippedAt: string): string;
+    private buildChangelogEntry;
+}
+
+interface BugContext {
+    description: string;
+    errorMessage?: string;
+    reproSteps?: string;
+    expectedBehavior?: string;
+    actualBehavior?: string;
+    phaseId?: string;
+}
+interface DebugPlan {
+    bugId: string;
+    title: string;
+    hypotheses: string[];
+    filesToInspect: string[];
+    diagnosticCommands: string[];
+    prompt: string;
+    fixPlanPrompt: string;
+}
+declare class DebugEngine {
+    build(ctx: BugContext, phase: Phase | undefined, stack?: StackInfo): DebugPlan;
+    buildDebugsMd(plans: DebugPlan[]): string;
+    private buildDebugPrompt;
+    private buildFixPlanPrompt;
+    private generateHypotheses;
+    private inferRelevantFiles;
+    private buildDiagnosticCommands;
+}
+
+interface AutoStep {
+    step: number;
+    phaseId: string;
+    phaseName: string;
+    action: 'map' | 'execute' | 'verify' | 'ship';
+    description: string;
+    blocked: boolean;
+    blockReason?: string;
+}
+interface AutoPlan {
+    steps: AutoStep[];
+    totalPhases: number;
+    phasesToRun: number;
+    canRun: boolean;
+    blockers: string[];
+    estimatedPrompts: number;
+}
+interface AutoGates {
+    requireCleanGit: boolean;
+    stopOnFailure: boolean;
+    verifyEachPhase: boolean;
+    shipEachPhase: boolean;
+}
+declare class AutoEngine {
+    buildPlan(state: BrainforgeState, opts: {
+        fromPhaseId?: string;
+        toPhaseId?: string;
+        gates: AutoGates;
+    }): AutoPlan;
+    buildDryRunOutput(plan: AutoPlan): string;
+    buildAutoSummaryPrompt(plan: AutoPlan, state: BrainforgeState): string;
+}
+
+interface Dependency {
+    name: string;
+    version: string;
+    dev: boolean;
+}
+interface DependencyInfo {
+    runtime: Dependency[];
+    dev: Dependency[];
+    total: number;
+    manifestType: string;
+    highlights: string[];
+}
+declare function analyzeDependencies(cwd: string): Promise<DependencyInfo>;
+
+type RiskLevel = 'high' | 'medium' | 'low';
+interface RiskItem {
+    level: RiskLevel;
+    category: string;
+    message: string;
+    file?: string;
+}
+interface RiskInfo {
+    items: RiskItem[];
+    summary: {
+        high: number;
+        medium: number;
+        low: number;
+    };
+}
+declare function detectRisks(cwd: string, files: string[], fileContents: Map<string, string>): Promise<RiskInfo>;
+declare function loadFileContents(cwd: string, files: string[], maxLines?: number): Promise<Map<string, string>>;
+
+interface TestInfo {
+    framework?: string;
+    testFiles: string[];
+    testCount: number;
+    sourceFileCount: number;
+    coverageRatio: number;
+    hasConfig: boolean;
+    coverageEnabled: boolean;
+    testCommand?: string;
+}
+declare function detectTests(files: string[], deps: Record<string, string>, scripts?: Record<string, string>): TestInfo;
+
+interface FileEntry {
+    path: string;
+    size: number;
+    lines: number;
+    role: string;
+}
+interface CodebaseMapResult {
+    generatedAt: string;
+    projectName: string;
+    stack: StackInfo;
+    dependencies: DependencyInfo;
+    conventions: ConventionInfo;
+    risks: RiskInfo;
+    tests: TestInfo;
+    files: FileEntry[];
+    totalFiles: number;
+    totalLines: number;
+}
+declare class CodebaseScanner {
+    private readonly cwd;
+    private readonly codebaseDir;
+    constructor(cwd: string);
+    scan(deep?: boolean): Promise<CodebaseMapResult>;
+    save(result: CodebaseMapResult): Promise<void>;
+    loadLatest(): Promise<CodebaseMapResult | null>;
+    private toMapMd;
+    private toConventionsMd;
+    private toRisksMd;
+    private toTestsMd;
+    private buildFileInventory;
+    private walkFiles;
+    private readProjectName;
+}
+
+type MemoryEntryType = 'decision' | 'summary' | 'gotcha' | 'pattern';
+interface MemoryEntry {
+    id: string;
+    type: MemoryEntryType;
+    title: string;
+    content: string;
+    tags: string[];
+    phaseId?: string;
+    createdAt: string;
+}
+declare class MemoryStore {
+    private readonly cwd;
+    private readonly memoryDir;
+    constructor(cwd: string);
+    append(entry: Omit<MemoryEntry, 'id' | 'createdAt'> & {
+        id?: string;
+        createdAt?: string;
+    }): Promise<MemoryEntry>;
+    readAll(type?: MemoryEntryType): Promise<MemoryEntry[]>;
+    recent(type?: MemoryEntryType, limit?: number): Promise<MemoryEntry[]>;
+    search(query: string): Promise<MemoryEntry[]>;
+    count(): Promise<Record<MemoryEntryType, number>>;
+    overwrite(type: MemoryEntryType, entries: MemoryEntry[]): Promise<void>;
+    private readFile;
+    private updateIndex;
+}
+
+interface Decision {
+    title: string;
+    description: string;
+    rationale: string;
+    consequences?: string;
+    phaseId?: string;
+    tags?: string[];
+}
+declare class DecisionLogger {
+    private readonly store;
+    constructor(store: MemoryStore);
+    log(decision: Decision): Promise<MemoryEntry>;
+    list(): Promise<MemoryEntry[]>;
+    recent(limit?: number): Promise<MemoryEntry[]>;
+}
+
+interface Gotcha {
+    title: string;
+    description: string;
+    solution: string;
+    phaseId?: string;
+    tags?: string[];
+}
+declare class GotchaLogger {
+    private readonly store;
+    constructor(store: MemoryStore);
+    log(gotcha: Gotcha): Promise<MemoryEntry>;
+    list(): Promise<MemoryEntry[]>;
+    recent(limit?: number): Promise<MemoryEntry[]>;
+}
+
+interface CompactionResult {
+    type: MemoryEntryType;
+    before: number;
+    kept: number;
+    compacted: number;
+}
+interface CompactionReport {
+    ranAt: string;
+    results: CompactionResult[];
+    totalBefore: number;
+    totalAfter: number;
+}
+declare function compact(store: MemoryStore, keepLast?: number): Promise<CompactionReport>;
+
+interface ContextPacket {
+    version: number;
+    generatedAt: string;
+    project: {
+        name: string;
+        language: string;
+        framework?: string;
+        type: string;
+    };
+    workflow: {
+        mode: string;
+        runtime: string;
+    };
+    phases: {
+        total: number;
+        completed: number;
+        pending: number;
+        activeId?: string;
+        activeName?: string;
+    };
+    currentPhase?: {
+        id: string;
+        name: string;
+        status: string;
+        tasksTotal: number;
+        tasksDone: number;
+        tasksInProgress: number;
+        nextTask?: string;
+    };
+    recentDecisions: Array<{
+        title: string;
+        content: string;
+        createdAt: string;
+    }>;
+    knownGotchas: Array<{
+        title: string;
+        content: string;
+    }>;
+    recentSummaries: Array<{
+        title: string;
+        content: string;
+        createdAt: string;
+    }>;
+    nextActions: string[];
+    resumeCommands: string[];
+}
+declare class ContextPacketBuilder {
+    private readonly cwd;
+    private readonly packetDir;
+    constructor(cwd: string);
+    build(): Promise<ContextPacket>;
+    save(packet: ContextPacket): Promise<{
+        jsonPath: string;
+        mdPath: string;
+    }>;
+    loadLatest(): Promise<ContextPacket | null>;
+    toMarkdown(p: ContextPacket): string;
+}
+
+export { AGENT_REGISTRY, type AIAdapter, type AIConfig, type AIProvider, type AcceptanceCriterionResult, AdapterManager, type AgentContract, type AgentId, type AgentPromptContext, AutoEngine, type AutoGates, type AutoPlan, type AutoStep, BUILT_IN_SKILLS, type BrainForgeConfig, BrainForgeServer, type BrainforgeState, type BugContext, type BugEntry, type BugReport, type BugSeverity, COMMANDS_BY_NAME, COMMAND_DEFINITIONS, type ClassInfo, ClaudeAdapter, type CodebaseMap, type CodebaseMapResult, CodebaseMapper, CodebaseScanner, type CommandDef, type CompactionReport, type CompactionResult, type CompletionOptions, type ConflictWarning, type ContextField, type ContextPacket, ContextPacketBuilder, type ConventionInfo, type CreatePhaseInput, DEFAULT_CONFIG, DebugEngine, type DebugPlan, type Decision, DecisionLogger, DeepSeekAdapter, type DefenseAnswer, type DefenseSession, type Dependency, type DependencyInfo, type DetectionResult, type DynamicQuestion, type ExecutionContext, ExecutionEngine, type FileChangeEvent, type FileEntry, type FileNode, FileWatcher, type FunctionInfo, GeminiAdapter, type Gotcha, GotchaLogger, type HeuristicPattern, type InstallResult, type Language, type MemoryEntry, type MemoryEntryType, MemoryStore, type MergeReport, type MigrationResult, MockDefense, OpenAIAdapter, type OrchestratorResult, ParallelOrchestrator, type PatternMatch, type Phase, PhaseEngine, type PhaseStatus, type PhaseStepStatus, type PlanAction, type PlanStep, ProfessorScanner, type ProjectConfig, type ProjectType, PromptEngine, type Question, RUNTIME_REGISTRY, type RiskInfo, type RiskItem, type RiskLevel, type RunRecord, type RuntimeCapability, type RuntimeDefinition, type RuntimeId, type RuntimeName, type ScanReport, type Severity, ShipEngine, type ShipResult, type Skill, type SkillCategory, type SkillContext, SkillRegistry, type StackInfo, type StateAction, StateManager, type StudentLevel, type Task, type TaskPlan, TaskPlanner, type TaskPriority, type TaskPrompt, type TaskStatus, type TaskType, type TestInfo, type ValidationResult, VerificationEngine, type VerificationResult, type VerifyResult, type Wave, type WaveGroup, WavePlanner, type WaveResult, WorkflowEngine, type WorkflowMode, Workspace, analyzeDependencies, buildAgentPrompt, buildMergeReport, buildQuestionSet, buildWaveSummary, compact, detectAndMigrate, detectConflicts, detectConventions, detectRisks, detectRuntimes, detectStack, detectTests, getAgent, getRuntime, installRuntime, listAgents, listRuntimes, loadConfig, loadFileContents, mergeResults, reduce, saveConfig, validateConfig, validatePhase, validateProjectConfig, validateTask };