openmatrix 0.2.3 → 0.2.5

package/dist/orchestrator/task-planner.js

@@ -108,8 +108,173 @@ class TaskPlanner {
                 this.analyzeModuleDependencies(modules, planText);
             }
         }
+        // 模式3: 英文格式 "N modules: A, B, C" 或 "N components: A, B, C"
+        if (modules.length === 0) {
+            const enModuleMatch = planText.match(/(\d+)\s*(?:modules?|components?|domains?|features?)\s*[:：]\s*(.+)/i);
+            if (enModuleMatch) {
+                const moduleNames = enModuleMatch[2]
+                    .split(/[,，、]/)
+                    .map(s => s.trim())
+                    .filter(s => s.length > 0 && s.length < 30);
+                for (const modName of moduleNames) {
+                    modules.push({
+                        name: modName,
+                        description: `${modName} module`,
+                        tables: [],
+                        type: 'domain',
+                        dependsOn: [],
+                        complexity: this.estimateModuleComplexity(modName, [])
+                    });
+                }
+                this.analyzeModuleDependencies(modules, planText);
+            }
+        }
+        // 模式4: Markdown 标题下的列表 "## Modules\n- A\n- B" 或 "## Architecture\n1. A\n2. B"
+        if (modules.length === 0) {
+            const mdPatterns = [
+                /##\s*(?:模块|Modules?|架构|Architecture|领域|Domains?|功能|Features?)[\s\S]*?((?:[-*\d]+\.\s*.+(?:\n|$))+)/i,
+                /##\s*(?:实现|Implementation|开发|Development)[\s\S]*?((?:[-*\d]+\.\s*.+(?:\n|$))+)/i,
+            ];
+            for (const pattern of mdPatterns) {
+                const mdMatch = planText.match(pattern);
+                if (mdMatch) {
+                    const lines = mdMatch[1].split('\n').filter(l => l.trim());
+                    for (const line of lines) {
+                        // 匹配 "- Name" 或 "1. Name" 或 "1. Name: Description"
+                        const itemMatch = line.match(/[-*\d]+\.\s*(.+?)(?:[：:\s](.*))?/);
+                        if (itemMatch) {
+                            const name = itemMatch[1].trim();
+                            const desc = itemMatch[2]?.trim() || `${name} module`;
+                            if (name.length > 0 && name.length < 30 && !modules.some(m => m.name === name)) {
+                                modules.push({
+                                    name,
+                                    description: desc,
+                                    tables: [],
+                                    type: 'domain',
+                                    dependsOn: [],
+                                    complexity: this.estimateModuleComplexity(name, [])
+                                });
+                            }
+                        }
+                    }
+                }
+                if (modules.length > 0) {
+                    this.analyzeModuleDependencies(modules, planText);
+                    break;
+                }
+            }
+        }
         return { modules, techStack, raw: planText };
     }
+    /**
+     * 从 plan 中提取结构化信息（用于 fallback 时注入任务描述）
+     * 即使无法解析模块，也能保留关键技术信息
+     */
+    extractPlanMetadata(plan) {
+        const techStack = [];
+        const interfaces = [];
+        const dataModels = [];
+        const keyDecisions = [];
+        // 1. 提取技术栈
+        const techMatch = plan.match(/(?:技术栈|Technology|Tech Stack)[\s\S]*?((?:[-*]\s*.+(?:\n|$))+)/i);
+        if (techMatch) {
+            techMatch[1].split('\n').forEach(line => {
+                const trimmed = line.replace(/^[-*]\s*/, '').trim();
+                if (trimmed && trimmed.length < 50)
+                    techStack.push(trimmed);
+            });
+        }
+        // 2. 提取接口/API
+        const interfacePatterns = [
+            /(?:接口|API|Endpoints?|接口定义)[\s\S]*?((?:[-*]\s*.+(?:\n|$))+)/i,
+            /(?:##\s*(?:接口|API|Endpoints?))[\s\S]*?((?:[-*\d]+\.\s*.+(?:\n|$))+)/i,
+        ];
+        for (const pattern of interfacePatterns) {
+            const match = plan.match(pattern);
+            if (match) {
+                match[1].split('\n').forEach(line => {
+                    const trimmed = line.replace(/^[-*\d]+\.\s*/, '').trim();
+                    if (trimmed && trimmed.length < 80 && !interfaces.includes(trimmed)) {
+                        interfaces.push(trimmed);
+                    }
+                });
+                if (interfaces.length > 0)
+                    break;
+            }
+        }
+        // 3. 提取数据模型/表
+        const dataPatterns = [
+            /(?:数据模型|Database|Tables?|Schema|实体|模型)[\s\S]*?((?:[-*]\s*.+(?:\n|$))+)/i,
+            /(?:##\s*(?:数据模型|Database|实体))[\s\S]*?((?:[-*\d]+\.\s*.+(?:\n|$))+)/i,
+        ];
+        for (const pattern of dataPatterns) {
+            const match = plan.match(pattern);
+            if (match) {
+                match[1].split('\n').forEach(line => {
+                    const trimmed = line.replace(/^[-*\d]+\.\s*/, '').trim();
+                    if (trimmed && trimmed.length < 50 && !dataModels.includes(trimmed)) {
+                        dataModels.push(trimmed);
+                    }
+                });
+                if (dataModels.length > 0)
+                    break;
+            }
+        }
+        // 4. 提取关键决策
+        const decisionPatterns = [
+            /(?:关键决策|Key Decisions|重要决策|决策点)[\s\S]*?((?:[-*]\s*.+(?:\n|$))+)/i,
+            /(?:##\s*(?:关键决策|Key Decisions|决策))[\s\S]*?((?:[-*\d]+\.\s*.+(?:\n|$))+)/i,
+        ];
+        for (const pattern of decisionPatterns) {
+            const match = plan.match(pattern);
+            if (match) {
+                match[1].split('\n').forEach(line => {
+                    const trimmed = line.replace(/^[-*\d]+\.\s*/, '').trim();
+                    if (trimmed && trimmed.length < 100 && !keyDecisions.includes(trimmed)) {
+                        keyDecisions.push(trimmed);
+                    }
+                });
+                if (keyDecisions.length > 0)
+                    break;
+            }
+        }
+        return { techStack, interfaces, dataModels, keyDecisions };
+    }
+    /**
+     * 从 goals 推断模块结构（当 plan 无法解析模块时使用）
+     */
+    inferModulesFromGoals(parsedTask) {
+        const modules = [];
+        if (!parsedTask.goalTypes || parsedTask.goals.length < 3) {
+            return modules;
+        }
+        for (let i = 0; i < parsedTask.goals.length; i++) {
+            const goal = parsedTask.goals[i];
+            const goalType = parsedTask.goalTypes[i];
+            // 只将 development 类型的 goal 作为模块
+            if (goalType === 'development') {
+                modules.push({
+                    name: goal.replace(/^(实现|开发|完成|Develop|Implement)\s*:?\s*/i, '').trim(),
+                    description: goal,
+                    tables: [],
+                    type: 'domain',
+                    dependsOn: [],
+                    complexity: this.estimateComplexity(goal)
+                });
+            }
+        }
+        // 添加基础依赖：第一个模块无依赖，后续模块依赖前一模块
+        for (let i = 1; i < modules.length; i++) {
+            // 默认并行，除非 goal 描述中明确提到依赖
+            if (parsedTask.goals[i].toLowerCase().includes('基于') ||
+                parsedTask.goals[i].toLowerCase().includes('依赖') ||
+                parsedTask.goals[i].toLowerCase().includes('需要') ||
+                parsedTask.goals[i].toLowerCase().includes('after')) {
+                modules[i].dependsOn.push(modules[i - 1].name);
+            }
+        }
+        return modules;
+    }
     /**
      * 分析模块间依赖关系
      *
@@ -190,15 +355,26 @@ class TaskPlanner {
         return 'medium';
     }
     breakdown(parsedTask, answers, qualityConfig, plan) {
-        // 如果提供了 plan 且解析出模块信息，使用细粒度的模块级拆分
+        // 如果提供了 plan，尝试解析模块
         if (plan) {
             const parsed = this.parsePlan(plan);
             if (parsed.modules.length > 0) {
                 return this.breakdownByModules(parsedTask, answers, qualityConfig, parsed, plan);
             }
+            // plan 无法解析模块时，尝试从 goals 推断
+            const inferredModules = this.inferModulesFromGoals(parsedTask);
+            if (inferredModules.length > 0) {
+                const inferredPlan = {
+                    modules: inferredModules,
+                    techStack: parsed.techStack,
+                    raw: plan
+                };
+                return this.breakdownByModules(parsedTask, answers, qualityConfig, inferredPlan, plan);
+            }
         }
-        // fallback: 按目标拆分的传统方式
-        return this.breakdownByGoals(parsedTask, answers, qualityConfig, plan);
+        // fallback: 按目标拆分，但保留 plan metadata
+        const planMetadata = plan ? this.extractPlanMetadata(plan) : undefined;
+        return this.breakdownByGoals(parsedTask, answers, qualityConfig, plan, planMetadata);
     }
     /**
      * 基于 plan 解析出的模块做细粒度任务拆分
@@ -502,7 +678,7 @@ ${userContext.documentationLevel}
     /**
      * 按目标拆分的传统方式（fallback）
      */
-    breakdownByGoals(parsedTask, answers, qualityConfig, plan) {
+    breakdownByGoals(parsedTask, answers, qualityConfig, plan, planMetadata) {
         const breakdowns = [];
         const seenTitles = new Set();
         const userContext = this.extractUserContext(answers);
@@ -567,7 +743,7 @@ ${globalContext}
                 breakdowns.push({
                     taskId: devTaskId,
                     title: `实现: ${goal}`,
-                    description: this.buildTaskDescription(goal, globalContext),
+                    description: this.buildTaskDescription(goal, globalContext, planMetadata),
                     priority: this.determinePriority(i),
                     dependencies: deps,
                     estimatedComplexity: this.estimateComplexity(goal),
@@ -909,12 +1085,24 @@ ${userContext.documentationLevel}
         }
         return parts.join('\n');
     }
-    buildTaskDescription(goal, globalContext) {
-        return `## 当前子任务目标\n${goal}\n\n${globalContext}\n\n## 输出要求
+    buildTaskDescription(goal, globalContext, planMetadata) {
+        let desc = `## 当前子任务目标\n${goal}\n\n${globalContext}`;
+        // 注入 plan 提取的关键信息
+        if (planMetadata && planMetadata.interfaces.length > 0) {
+            desc += `\n\n## 相关接口/API\n${planMetadata.interfaces.slice(0, 10).map(i => `- ${i}`).join('\n')}`;
+        }
+        if (planMetadata && planMetadata.dataModels.length > 0) {
+            desc += `\n\n## 相关数据模型\n${planMetadata.dataModels.slice(0, 10).map(d => `- ${d}`).join('\n')}`;
+        }
+        if (planMetadata && planMetadata.keyDecisions.length > 0) {
+            desc += `\n\n## 关键决策参考\n${planMetadata.keyDecisions.slice(0, 5).map(d => `- ${d}`).join('\n')}`;
+        }
+        desc += `\n\n## 输出要求
 - 完成功能实现
 - 代码可编译
 - 遵循项目规范
 - 添加必要注释`;
+        return desc;
     }
     buildTestDescription(goal, devTaskId, coverageTarget, globalContext) {
         return `## 测试目标

package/dist/storage/file-store.d.ts

@@ -22,4 +22,17 @@ export declare class FileStore {
     exists(path: string): Promise<boolean>;
     listFiles(dir: string): Promise<string[]>;
     listDirs(dir: string): Promise<string[]>;
+    /**
+     * 同步写入 JSON 文件
+     */
+    writeJsonSync<T>(path: string, data: T): void;
+    /**
+     * 同步读取 JSON 文件
+     * @returns 文件内容，如果文件不存在则返回 null
+     */
+    readJsonSync<T>(path: string): T | null;
+    /**
+     * 同步检查文件是否存在
+     */
+    existsSync(path: string): boolean;
 }

package/dist/storage/file-store.js

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileStore = void 0;
 const promises_1 = require("fs/promises");
-const path_1 = require("path");
 const fs_1 = require("fs");
+const path_1 = require("path");
+const fs_2 = require("fs");
+const error_handler_js_1 = require("../utils/error-handler.js");
 class FileStore {
     basePath;
     constructor(basePath) {
@@ -71,7 +73,7 @@ class FileStore {
     async exists(path) {
         const fullPath = (0, path_1.join)(this.basePath, path);
         try {
-            await (0, promises_1.access)(fullPath, fs_1.constants.F_OK);
+            await (0, promises_1.access)(fullPath, fs_2.constants.F_OK);
             return true;
         }
         catch {
@@ -86,7 +88,8 @@ class FileStore {
                 .filter((f) => f.isFile())
                 .map((f) => f.name);
         }
-        catch {
+        catch (error) {
+            (0, error_handler_js_1.logError)(error, { operation: 'listFiles', file: fullPath });
             return [];
         }
     }
@@ -98,9 +101,43 @@ class FileStore {
                 .filter((f) => f.isDirectory())
                 .map((f) => f.name);
         }
-        catch {
+        catch (error) {
+            (0, error_handler_js_1.logError)(error, { operation: 'listDirs', file: fullPath });
             return [];
         }
     }
+    // ============ 同步方法（用于构造器等场景）============
+    /**
+     * 同步写入 JSON 文件
+     */
+    writeJsonSync(path, data) {
+        const fullPath = (0, path_1.join)(this.basePath, path);
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(fullPath), { recursive: true });
+        (0, fs_1.writeFileSync)(fullPath, JSON.stringify(data, null, 2), 'utf-8');
+    }
+    /**
+     * 同步读取 JSON 文件
+     * @returns 文件内容，如果文件不存在则返回 null
+     */
+    readJsonSync(path) {
+        const fullPath = (0, path_1.join)(this.basePath, path);
+        try {
+            const content = (0, fs_1.readFileSync)(fullPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT' || error.code === 'EISDIR') {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * 同步检查文件是否存在
+     */
+    existsSync(path) {
+        const fullPath = (0, path_1.join)(this.basePath, path);
+        return (0, fs_1.existsSync)(fullPath);
+    }
 }
 exports.FileStore = FileStore;

package/dist/storage/state-manager.d.ts

@@ -1,4 +1,4 @@
-import type { GlobalState, Task, Approval, ApprovalStatus } from '../types/index.js';
+import type { GlobalState, Task, Approval, ApprovalStatus, Meeting, MeetingStatus } from '../types/index.js';
 export declare class StateManager {
     private store;
     private stateCache;
@@ -55,7 +55,7 @@ export declare class StateManager {
     updateApproval(approval: Approval): Promise<void>;
     getApprovalsByStatus(status: ApprovalStatus): Promise<Approval[]>;
     getAllApprovals(): Promise<Approval[]>;
-    saveMeeting(meeting: any): Promise<void>;
-    getMeeting(meetingId: string): Promise<any | null>;
-    getMeetingsByStatus(status: string): Promise<any[]>;
+    saveMeeting(meeting: Meeting): Promise<void>;
+    getMeeting(meetingId: string): Promise<Meeting | null>;
+    getMeetingsByStatus(status: MeetingStatus): Promise<Meeting[]>;
 }

package/dist/storage/state-manager.js

@@ -6,6 +6,7 @@ const promises_1 = require("fs/promises");
 const path_1 = require("path");
 const DEFAULT_CONFIG = {
     timeout: 120,
+    taskTimeout: 600000, // 10 分钟（毫秒）
     maxRetries: 3,
     approvalPoints: ['plan', 'merge'],
     maxConcurrentAgents: 3,
@@ -164,6 +165,9 @@ class StateManager {
     }
     async createTask(input) {
         return this.withFileLock(async () => {
+            // 先从磁盘读取最新状态，避免使用过期缓存
+            const latestState = await this.store.readJson('state.json') ?? await this.getState();
+            this.stateCache = latestState;
             const taskId = this.generateTaskId();
             const now = new Date().toISOString();
             const task = {
@@ -189,13 +193,12 @@ class StateManager {
             // Create artifacts subdirectory
             await this.store.ensureDir(`tasks/${taskId}/artifacts`);
             // Update statistics
-            const state = await this.getState();
             const newState = {
-                ...state,
+                ...latestState,
                 statistics: {
-                    ...state.statistics,
-                    totalTasks: state.statistics.totalTasks + 1,
-                    pending: state.statistics.pending + 1
+                    ...latestState.statistics,
+                    totalTasks: latestState.statistics.totalTasks + 1,
+                    pending: latestState.statistics.pending + 1
                 }
             };
             await this.store.writeJson('state.json', newState);

package/dist/types/index.d.ts

@@ -94,7 +94,10 @@ export interface GlobalState {
     };
 }
 export interface AppConfig {
+    /** 单个任务超时时间（秒） */
     timeout: number;
+    /** 任务执行超时时间（毫秒） */
+    taskTimeout?: number;
     maxRetries: number;
     approvalPoints: ('plan' | 'merge' | 'deploy')[];
     maxConcurrentAgents: number;
@@ -200,6 +203,23 @@ export interface ApprovalOption {
     key: string;
     label: string;
 }
+export type MeetingStatus = 'pending' | 'in_progress' | 'resolved' | 'cancelled';
+export type MeetingType = 'blocking' | 'decision' | 'review' | 'planning';
+export interface Meeting {
+    id: string;
+    type: MeetingType;
+    status: MeetingStatus;
+    taskId: string;
+    title: string;
+    description: string;
+    blockingReason?: string;
+    impactScope: string[];
+    participants: string[];
+    resolution?: string;
+    createdAt: string;
+    startedAt?: string;
+    resolvedAt?: string;
+}
 export interface ParsedTask {
     title: string;
     description: string;

package/dist/utils/error-handler.d.ts

@@ -0,0 +1,46 @@
+/**
+ * 错误上下文信息
+ */
+export interface ErrorContext {
+    operation: string;
+    file?: string;
+    taskId?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * 将任意错误转换为 Error 对象并保留 stack trace
+ */
+export declare function toError(error: unknown): Error;
+/**
+ * 记录错误日志（保留 stack trace）
+ */
+export declare function logError(error: unknown, context: ErrorContext): void;
+/**
+ * 包装错误，添加上下文信息到错误消息
+ */
+export declare function wrapError(error: unknown, context: ErrorContext): Error;
+/**
+ * 包装并抛出错误
+ */
+export declare function throwWrapped(error: unknown, context: ErrorContext): never;
+/**
+ * 安全执行函数，捕获并记录错误但不抛出
+ * @returns 返回值或 null（如果发生错误）
+ */
+export declare function safeExecute<T>(fn: () => Promise<T>, context: ErrorContext): Promise<T | null>;
+/**
+ * 安全执行同步函数
+ */
+export declare function safeExecuteSync<T>(fn: () => T, context: ErrorContext): T | null;
+/**
+ * 执行函数，捕获错误并包装后抛出
+ */
+export declare function executeWithError<T>(fn: () => Promise<T>, context: ErrorContext): Promise<T>;
+/**
+ * 判断错误是否可恢复（如网络超时、临时文件锁等）
+ */
+export declare function isRecoverableError(error: unknown): boolean;
+/**
+ * 判断错误是否为文件系统错误
+ */
+export declare function isFileSystemError(error: unknown): boolean;

package/dist/utils/error-handler.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toError = toError;
+exports.logError = logError;
+exports.wrapError = wrapError;
+exports.throwWrapped = throwWrapped;
+exports.safeExecute = safeExecute;
+exports.safeExecuteSync = safeExecuteSync;
+exports.executeWithError = executeWithError;
+exports.isRecoverableError = isRecoverableError;
+exports.isFileSystemError = isFileSystemError;
+// src/utils/error-handler.ts
+const logger_js_1 = require("./logger.js");
+/**
+ * 将任意错误转换为 Error 对象并保留 stack trace
+ */
+function toError(error) {
+    if (error instanceof Error) {
+        return error;
+    }
+    if (typeof error === 'string') {
+        return new Error(error);
+    }
+    return new Error(JSON.stringify(error));
+}
+/**
+ * 记录错误日志（保留 stack trace）
+ */
+function logError(error, context) {
+    const err = toError(error);
+    const logger = (0, logger_js_1.getLogger)();
+    logger.error({
+        message: err.message,
+        stack: err.stack,
+        operation: context.operation,
+        file: context.file,
+        taskId: context.taskId,
+        ...context.metadata,
+        timestamp: new Date().toISOString()
+    });
+}
+/**
+ * 包装错误，添加上下文信息到错误消息
+ */
+function wrapError(error, context) {
+    const err = toError(error);
+    const wrapped = new Error(`${context.operation}: ${err.message}`);
+    wrapped.stack = err.stack;
+    wrapped.cause = err;
+    return wrapped;
+}
+/**
+ * 包装并抛出错误
+ */
+function throwWrapped(error, context) {
+    throw wrapError(error, context);
+}
+/**
+ * 安全执行函数，捕获并记录错误但不抛出
+ * @returns 返回值或 null（如果发生错误）
+ */
+async function safeExecute(fn, context) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        logError(error, context);
+        return null;
+    }
+}
+/**
+ * 安全执行同步函数
+ */
+function safeExecuteSync(fn, context) {
+    try {
+        return fn();
+    }
+    catch (error) {
+        logError(error, context);
+        return null;
+    }
+}
+/**
+ * 执行函数，捕获错误并包装后抛出
+ */
+async function executeWithError(fn, context) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        throwWrapped(error, context);
+    }
+}
+/**
+ * 判断错误是否可恢复（如网络超时、临时文件锁等）
+ */
+function isRecoverableError(error) {
+    const err = toError(error);
+    const recoverablePatterns = [
+        /timeout/i,
+        /temporarily unavailable/i,
+        /ECONNRESET/i,
+        /ENOTFOUND/i,
+        /lock/i,
+        /retry/i
+    ];
+    return recoverablePatterns.some(p => p.test(err.message));
+}
+/**
+ * 判断错误是否为文件系统错误
+ */
+function isFileSystemError(error) {
+    const err = toError(error);
+    const fsPatterns = [
+        /ENOENT/i,
+        /EACCES/i,
+        /EPERM/i,
+        /EISDIR/i,
+        /ENOTDIR/i,
+        /EMFILE/i
+    ];
+    return fsPatterns.some(p => p.test(err.message));
+}

package/dist/utils/logger.d.ts

@@ -3,7 +3,25 @@ export interface LoggerOptions {
     level?: string;
     logDir?: string;
     console?: boolean;
+    runId?: string;
 }
+/**
+ * 结构化日志格式
+ */
+export interface StructuredLog {
+    level: 'info' | 'warn' | 'error' | 'debug';
+    runId?: string;
+    taskId?: string;
+    operation: string;
+    message: string;
+    metadata?: Record<string, unknown>;
+    timestamp: string;
+}
+/**
+ * 持久化日志到文件（追加模式）
+ * 用于关键操作的审计追踪
+ */
+export declare function persistLog(log: StructuredLog, omPath: string): void;
 /**
  * 创建或获取默认 Logger
  */
@@ -16,6 +34,10 @@ export declare function getLogger(): winston.Logger;
  * 设置默认 logger
  */
 export declare function setLogger(logger: winston.Logger): void;
+/**
+ * 使用 runId 初始化 logger
+ */
+export declare function initLoggerWithRunId(runId: string, omPath?: string): void;
 /**
  * 便捷方法: 直接记录日志
  */
@@ -24,11 +46,17 @@ export declare const logger: {
     error: (message: string, meta?: any) => winston.Logger;
     warn: (message: string, meta?: any) => winston.Logger;
     debug: (message: string, meta?: any) => winston.Logger;
+    structured: {
+        info: (operation: string, message: string, meta?: Record<string, unknown>, omPath?: string) => void;
+        error: (operation: string, message: string, meta?: Record<string, unknown>, omPath?: string) => void;
+        warn: (operation: string, message: string, meta?: Record<string, unknown>, omPath?: string) => void;
+    };
     task: {
         start: (taskId: string, title: string) => void;
         complete: (taskId: string, duration?: number) => void;
         fail: (taskId: string, error: string) => void;
         retry: (taskId: string, attempt: number) => void;
+        timeout: (taskId: string, timeout: number, phase?: string, omPath?: string) => void;
     };
     agent: {
         call: (agentType: string, taskId: string) => void;
@@ -38,4 +66,9 @@ export declare const logger: {
         request: (approvalId: string, type: string) => void;
         decision: (approvalId: string, decision: string) => void;
     };
+    orchestration: {
+        breakdown: (moduleCount: number, moduleNames: string[], omPath?: string) => void;
+        schedule: (taskId: string, dependencies: string[]) => void;
+        dependencyResolved: (taskId: string) => void;
+    };
 };