@obora/runtime 0.1.0

package/dist/_legacy/blackboard/types/message.d.ts

@@ -0,0 +1,162 @@
+/**
+ * @module message
+ * @description 메시지 관련 타입 정의
+ */
+import type { Identifiable, Timestamped } from './base';
+import type { AgentId, TaskId } from './base';
+/**
+ * 메시지 타입 enum
+ * @description 시스템 내 모든 메시지 유형
+ */
+export declare enum MessageType {
+    /** 상태 읽기 요청 */
+    STATE_READ = "state.read",
+    /** 상태 쓰기 요청 */
+    STATE_WRITE = "state.write",
+    /** 상태 구독 */
+    STATE_SUBSCRIBE = "state.subscribe",
+    /** 상태 변경 알림 */
+    STATE_UPDATED = "state.updated",
+    /** 안건 제출 요청 */
+    DECISION_REQUEST = "decision.request",
+    /** 의견 제출 */
+    OPINION_SUBMIT = "opinion.submit",
+    /** 투표 제출 */
+    VOTE_SUBMIT = "vote.submit",
+    /** 합의 도달 알림 */
+    CONSENSUS_REACHED = "consensus.reached",
+    /** 작업 할당 */
+    TASK_ASSIGN = "task.assign",
+    /** 작업 완료 */
+    TASK_COMPLETE = "task.complete",
+    /** 작업 실패 */
+    TASK_FAILED = "task.failed",
+    /** 작업 진행 상황 */
+    TASK_PROGRESS = "task.progress",
+    /** 사실 추가 */
+    KNOWLEDGE_FACT_ADD = "knowledge.fact.add",
+    /** 추론 추가 */
+    KNOWLEDGE_INFERENCE_ADD = "knowledge.inference.add",
+    /** 하트비트 */
+    HEARTBEAT = "heartbeat",
+    /** 에러 */
+    ERROR = "error",
+    /** 시스템 알림 */
+    SYSTEM_NOTIFICATION = "system.notification"
+}
+/**
+ * 메시지 기본 인터페이스
+ * @description 시스템 내에서 주고받는 모든 메시지의 기본 구조
+ * @typeParam T - 페이로드 타입
+ *
+ * @example
+ * ```typescript
+ * const message: Message<string> = {
+ *   id: 'msg-001',
+ *   type: MessageType.HEARTBEAT,
+ *   from: createAgentId('agent-001'),
+ *   to: 'broadcast',
+ *   payload: 'ping',
+ *   priority: 1,
+ *   ttl: null,
+ *   createdAt: new Date(),
+ *   updatedAt: new Date(),
+ * };
+ * ```
+ */
+export interface Message<T = unknown> extends Identifiable, Timestamped {
+    /** 메시지 타입 */
+    type: MessageType;
+    /** 발신자 ID */
+    from: AgentId;
+    /** 수신자 ID ('broadcast'면 전체) */
+    to: AgentId | 'broadcast';
+    /** 메시지 내용 */
+    payload: T;
+    /** 상관 ID (요청-응답 연결용) */
+    correlationId?: string;
+    /** 우선순위 */
+    priority: number;
+    /** TTL (밀리초, null이면 무제한) */
+    ttl: number | null;
+}
+/**
+ * 상태 읽기 요청 페이로드
+ * @description Blackboard의 특정 섹션을 읽기 위한 요청
+ */
+export interface StateReadPayload {
+    /** 읽을 섹션 */
+    section: 'state' | 'knowledge' | 'decisions';
+    /** 경로 */
+    path: string;
+    /** 쿼리 파라미터 */
+    query?: Record<string, unknown>;
+}
+/**
+ * 상태 쓰기 요청 페이로드
+ * @description Blackboard의 특정 섹션에 쓰기 위한 요청
+ */
+export interface StateWritePayload {
+    /** 쓸 섹션 */
+    section: 'state' | 'knowledge' | 'decisions';
+    /** 경로 */
+    path: string;
+    /** 데이터 */
+    data: unknown;
+    /** 기대 버전 (optimistic locking용) */
+    expectedVersion?: number;
+}
+/**
+ * 에러 페이로드
+ * @description 에러 발생 시 전달하는 정보
+ */
+export interface ErrorPayload {
+    /** 에러 코드 */
+    code: string;
+    /** 에러 메시지 */
+    message: string;
+    /** 상세 정보 */
+    details?: Record<string, unknown>;
+    /** 재시도 가능 여부 */
+    retryable: boolean;
+}
+/**
+ * 하트비트 페이로드
+ * @description 에이전트 하트비트 정보
+ */
+export interface HeartbeatPayload {
+    /** 에이전트 ID */
+    agentId: AgentId;
+    /** 현재 작업 ID (없으면 null) */
+    currentTask?: TaskId | null;
+    /** 타임스탬프 */
+    timestamp: Date;
+    /** 추가 상태 정보 */
+    status?: Record<string, unknown>;
+}
+/**
+ * 메시지 전송 옵션
+ * @description 메시지 전송 시 설정 가능한 옵션
+ */
+export interface MessageSendOptions {
+    /** 수신자 ID */
+    to: AgentId | 'broadcast';
+    /** 메시지 타입 */
+    type: MessageType;
+    /** 우선순위 (기본: 1) */
+    priority?: number;
+    /** TTL (밀리초) */
+    ttl?: number | null;
+    /** 상관 ID */
+    correlationId?: string;
+}
+/**
+ * 메시지 핸들러 타입
+ * @description 메시지를 처리하는 핸들러 함수의 타입
+ */
+export type MessageHandler<T = unknown> = (message: Message<T>) => void | Promise<void>;
+/**
+ * 메시지 필터 타입
+ * @description 메시지를 필터링하는 조건 함수의 타입
+ */
+export type MessageFilter<T = unknown> = (message: Message<T>) => boolean;

package/dist/_legacy/blackboard/types/task.d.ts

@@ -0,0 +1,154 @@
+/**
+ * @module task
+ * @description 작업(Task) 관련 타입 정의
+ */
+import type { Identifiable, Timestamped, Versioned } from './base';
+import type { AgentId, TaskId } from './base';
+/**
+ * 작업 상태 enum
+ * @description 작업의 진행 상태를 나타냄
+ */
+export declare enum TaskStatus {
+    /** 대기 중 */
+    PENDING = "pending",
+    /** 실행 중 */
+    RUNNING = "running",
+    /** 완료됨 */
+    COMPLETED = "completed",
+    /** 실패함 */
+    FAILED = "failed",
+    /** 취소됨 */
+    CANCELLED = "cancelled"
+}
+/**
+ * 작업 우선순위
+ * @description 작업의 중요도를 나타내는 순위
+ */
+export declare enum TaskPriority {
+    LOW = 0,
+    NORMAL = 1,
+    HIGH = 2,
+    CRITICAL = 3
+}
+/**
+ * 작업 정의
+ * @description 시스템에서 실행할 작업의 정의
+ *
+ * @example
+ * ```typescript
+ * const task: Task = {
+ *   id: createTaskId('task-001'),
+ *   name: '데이터 분석',
+ *   description: '사용자 행동 데이터 분석',
+ *   assignedTo: createAgentId('agent-001'),
+ *   status: TaskStatus.PENDING,
+ *   priority: TaskPriority.HIGH,
+ *   inputs: { dataset: 'users-2026-01' },
+ *   outputs: null,
+ *   dependsOn: [],
+ *   error: null,
+ *   startedAt: null,
+ *   completedAt: null,
+ *   timeout: 3600000,
+ *   version: 1,
+ *   createdAt: new Date(),
+ *   updatedAt: new Date(),
+ * };
+ * ```
+ */
+export interface Task extends Identifiable<TaskId>, Timestamped, Versioned {
+    /** 작업 이름 */
+    name: string;
+    /** 작업 설명 */
+    description: string;
+    /** 할당된 에이전트 */
+    assignedTo: AgentId | null;
+    /** 현재 상태 */
+    status: TaskStatus;
+    /** 우선순위 */
+    priority: TaskPriority;
+    /** 입력 데이터 */
+    inputs: Record<string, unknown>;
+    /** 출력 데이터 (완료 시) */
+    outputs: Record<string, unknown> | null;
+    /** 의존하는 작업 ID 목록 */
+    dependsOn: TaskId[];
+    /** 에러 정보 (실패 시) */
+    error: TaskError | null;
+    /** 시작 시간 */
+    startedAt: Date | null;
+    /** 완료 시간 */
+    completedAt: Date | null;
+    /** 제한 시간 (밀리초) */
+    timeout: number | null;
+}
+/**
+ * 작업 에러 정보
+ * @description 작업 실행 중 발생한 에러의 상세 정보
+ */
+export interface TaskError {
+    /** 에러 코드 */
+    code: string;
+    /** 에러 메시지 */
+    message: string;
+    /** 스택 트레이스 */
+    stack?: string;
+    /** 재시도 가능 여부 */
+    retryable: boolean;
+}
+/**
+ * 작업 생성 옵션
+ * @description 새 작업 생성 시 필요한 필드
+ */
+export interface TaskCreateInput {
+    /** 작업 이름 */
+    name: string;
+    /** 작업 설명 */
+    description: string;
+    /** 할당할 에이전트 (선택) */
+    assignedTo?: AgentId | null;
+    /** 우선순위 (기본: NORMAL) */
+    priority?: TaskPriority;
+    /** 입력 데이터 */
+    inputs?: Record<string, unknown>;
+    /** 의존하는 작업 ID 목록 */
+    dependsOn?: TaskId[];
+    /** 제한 시간 (밀리초) */
+    timeout?: number | null;
+}
+/**
+ * 작업 업데이트 옵션
+ * @description 작업 상태 업데이트를 위한 선택적 필드
+ */
+export interface TaskUpdateInput {
+    /** 새로운 상태 */
+    status?: TaskStatus;
+    /** 할당된 에이전트 */
+    assignedTo?: AgentId | null;
+    /** 우선순위 */
+    priority?: TaskPriority;
+    /** 출력 데이터 */
+    outputs?: Record<string, unknown> | null;
+    /** 에러 정보 */
+    error?: TaskError | null;
+    /** 시작 시간 */
+    startedAt?: Date | null;
+    /** 완료 시간 */
+    completedAt?: Date | null;
+}
+/**
+ * 작업 진행 상황
+ * @description 작업 실행 중의 진행 상황 보고
+ */
+export interface TaskProgress {
+    /** 작업 ID */
+    taskId: TaskId;
+    /** 진행률 (0.0 - 1.0) */
+    progress: number;
+    /** 현재 단계 설명 */
+    currentStep: string;
+    /** 남은 예상 시간 (밀리초) */
+    estimatedTimeRemaining?: number;
+    /** 추가 메시지 */
+    message?: string;
+}

package/dist/_legacy/blackboard/types/tkg.d.ts

@@ -0,0 +1,189 @@
+/**
+ * @module types/tkg
+ * @description Temporal Knowledge Graph(TKG) 타입/계약 (spec/12 정렬)
+ */
+import type { AgentId } from './base';
+/** TKG 노드 ID */
+export type NodeId = string & {
+    readonly __brand: 'NodeId';
+};
+/** TKG 엣지 ID */
+export type EdgeId = string & {
+    readonly __brand: 'EdgeId';
+};
+/** 노드 ID 생성기 */
+export declare function createNodeId(id: string): NodeId;
+/** 엣지 ID 생성기 */
+export declare function createEdgeId(id: string): EdgeId;
+/** 노드 종류 */
+export type TemporalNodeType = 'entity' | 'fact' | 'decision' | 'task' | 'pattern';
+/** 엣지 종류 */
+export type EdgeType = 'relates_to' | 'part_of' | 'contains' | 'supports' | 'contradicts' | 'explains' | 'based_on' | 'decided_by' | 'decided_on' | 'leads_to' | 'assigned_to' | 'depends_on' | 'blocks' | 'precedes' | 'exemplifies' | 'generalizes' | 'specializes';
+export interface EntityData {
+    readonly name: string;
+    readonly entityType: 'agent' | 'task' | 'resource' | 'concept';
+    readonly attributes: Readonly<Record<string, unknown>>;
+}
+export interface FactData {
+    readonly statement: string;
+    readonly context?: string;
+    readonly evidence?: readonly NodeId[];
+    readonly verified: boolean;
+}
+export interface DecisionData {
+    readonly agendaId: string;
+    readonly outcome: 'approve' | 'reject' | 'deferred';
+    readonly reason: string;
+    readonly participants: readonly AgentId[];
+}
+export interface TaskData {
+    readonly description: string;
+    readonly status: 'pending' | 'running' | 'completed' | 'failed';
+    readonly assignedTo?: AgentId;
+    readonly result?: unknown;
+}
+export interface PatternData {
+    readonly description: string;
+    readonly frequency: number;
+    readonly examples: readonly string[];
+    readonly accuracy?: number;
+}
+export type NodeData = EntityData | FactData | DecisionData | TaskData | PatternData;
+/**
+ * 시간축을 가진 TKG 노드
+ */
+export interface TemporalNode {
+    readonly id: NodeId;
+    readonly type: TemporalNodeType;
+    readonly valid_from: Date;
+    readonly valid_to?: Date;
+    readonly observed_at: Date;
+    readonly updated_at: Date;
+    readonly confidence: number;
+    readonly source: AgentId;
+    readonly version: number;
+    readonly tags?: readonly string[];
+    readonly data: NodeData;
+}
+/**
+ * 시간축을 가진 TKG 엣지
+ */
+export interface TemporalEdge {
+    readonly id: EdgeId;
+    readonly from: NodeId;
+    readonly to: NodeId;
+    readonly type: EdgeType;
+    readonly valid_from: Date;
+    readonly valid_to?: Date;
+    readonly observed_at: Date;
+    readonly confidence: number;
+    readonly source: AgentId;
+    readonly weight?: number;
+}
+/**
+ * TKG 조회 쿼리
+ */
+export interface GraphQuery {
+    readonly nodeTypes?: readonly TemporalNodeType[];
+    readonly nodeIds?: readonly NodeId[];
+    readonly tags?: readonly string[];
+    readonly minConfidence?: number;
+    readonly edgeTypes?: readonly EdgeType[];
+    readonly from?: NodeId;
+    readonly to?: NodeId;
+    readonly depth?: number;
+}
+/**
+ * TKG 조회 결과
+ */
+export interface QueryResult {
+    readonly nodes: readonly TemporalNode[];
+    readonly edges: readonly TemporalEdge[];
+    readonly metadata: {
+        readonly queryTime: Date;
+        readonly resultCount: number;
+        readonly confidenceRange: readonly [number, number];
+    };
+}
+export interface ValidationError {
+    readonly field: string;
+    readonly message: string;
+    readonly code: string;
+}
+export interface ValidationWarning {
+    readonly field: string;
+    readonly message: string;
+    readonly code: string;
+}
+/**
+ * 유효성 검사 결과
+ */
+export interface ValidationResult {
+    readonly valid: boolean;
+    readonly errors: readonly ValidationError[];
+    readonly warnings: readonly ValidationWarning[];
+}
+export type ConflictResolution = 'pending' | 'supersedes' | 'higher_confidence' | 'merge' | 'discard' | 'soft_delete';
+export interface Conflict {
+    readonly id: string;
+    readonly type: 'version' | 'contradiction' | 'supersedes' | 'confidence';
+    readonly nodes: readonly [TemporalNode, TemporalNode];
+    readonly detectedAt: Date;
+    readonly status: 'pending' | 'resolved' | 'deferred';
+    readonly resolution?: ConflictResolution;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/**
+ * 승격(Promotion) 메타데이터
+ */
+export interface PromotionMeta {
+    readonly promotedBy?: string;
+    readonly reason?: string;
+    readonly promotedAt?: Date;
+}
+/**
+ * 개별 승격 결과
+ */
+export interface PromotionResult {
+    readonly nodeId: NodeId;
+    readonly success: boolean;
+    readonly timestamp: Date;
+    readonly reason?: string;
+    readonly conflict?: Conflict;
+}
+/**
+ * 병합 옵션
+ */
+export interface ReflectionOptions {
+    readonly minConfidence?: number;
+    readonly resolveConflicts?: boolean;
+    readonly softDeleteOnConflict?: boolean;
+    readonly maxAge?: number;
+}
+/**
+ * Staging/Production 병합 결과
+ */
+export interface MergeResult {
+    readonly mergeId: string;
+    readonly timestamp: Date;
+    readonly nodesPromoted: number;
+    readonly nodesSkipped: number;
+    readonly nodesFailed: number;
+    readonly edgesPromoted: number;
+    readonly edgesSkipped: number;
+    readonly conflicts: readonly Conflict[];
+    readonly duration: number;
+}
+/**
+ * Production 승격 전용 Port 계약.
+ * Reflector는 ProductionTKG 내부 맵에 직접 쓰지 않고 반드시 이 포트를 사용해야 합니다.
+ */
+export interface IProductionPromotionPort {
+    promoteNode(node: TemporalNode, meta?: PromotionMeta): PromotionResult;
+    promoteEdge(edge: TemporalEdge, meta?: PromotionMeta): PromotionResult;
+    promoteBatch(payload: {
+        nodes: readonly TemporalNode[];
+        edges: readonly TemporalEdge[];
+        meta?: PromotionMeta;
+    }): MergeResult;
+}

package/dist/_legacy/blackboard/workflow/meeting-state-machine/MeetingStateMachine.d.ts

@@ -0,0 +1,22 @@
+import type { ConsensusResult } from '../../domains/consensus';
+import { EventBus } from '../../events';
+import type { MeetingEvent, MeetingState, MeetingStateMachineOptions, MeetingStateSnapshot, TransitionLog } from './types';
+export declare class MeetingStateMachine {
+    private readonly eventBus;
+    private state;
+    private enteredAt;
+    private lastEventAt;
+    private logs;
+    private readonly discussionTimeoutMs;
+    private readonly votingTimeoutMs;
+    constructor(eventBus?: EventBus, options?: MeetingStateMachineOptions);
+    getState(): MeetingState;
+    getLogs(): readonly TransitionLog[];
+    apply(event: MeetingEvent): MeetingState;
+    tick(now?: Date): MeetingState;
+    toSnapshot(): MeetingStateSnapshot;
+    static fromSnapshot(snapshot: MeetingStateSnapshot, eventBus?: EventBus): MeetingStateMachine;
+    private resolveNextState;
+    private emitTransitionEvent;
+    static consensusEvent(consensus: ConsensusResult, timestamp?: Date): MeetingEvent;
+}

package/dist/_legacy/blackboard/workflow/meeting-state-machine/types.d.ts

@@ -0,0 +1,30 @@
+import type { ConsensusResult } from '../../domains/consensus';
+export declare const MEETING_STATES: readonly ["idle", "agenda_setting", "discussion", "debate", "voting", "resolving", "resolved"];
+export type MeetingState = (typeof MEETING_STATES)[number];
+export type MeetingEventType = 'agenda.created' | 'agenda.status.changed' | 'decisions.voting.started' | 'decisions.voting.ended' | 'workflow.consensus.computed' | 'workflow.timeout' | 'workflow.quorum.lost' | 'workflow.cancelled';
+export interface MeetingEvent {
+    readonly type: MeetingEventType;
+    readonly timestamp?: Date;
+    readonly payload?: {
+        readonly status?: string;
+        readonly consensus?: ConsensusResult;
+        readonly reason?: string;
+    };
+}
+export interface TransitionLog {
+    readonly from: MeetingState;
+    readonly to: MeetingState;
+    readonly eventType: MeetingEventType;
+    readonly timestamp: Date;
+    readonly reason?: string;
+}
+export interface MeetingStateSnapshot {
+    readonly state: MeetingState;
+    readonly enteredAt: Date;
+    readonly lastEventAt: Date;
+    readonly logs: readonly TransitionLog[];
+}
+export interface MeetingStateMachineOptions {
+    readonly discussionTimeoutMs?: number;
+    readonly votingTimeoutMs?: number;
+}

package/dist/_legacy/cli-runtime/runtime/agent-registry.d.ts

@@ -0,0 +1,33 @@
+/**
+ * AgentRegistry — resolves step.agent strings to BaseAgent instances.
+ *
+ * Registry responsibility is intentionally narrow:
+ * - lookup role for agent name
+ * - create/reuse provider adapter
+ * - create BaseAgent from fully-resolved config
+ */
+import { type AgentConfig, type LLMAdapter, type ToolRegistry } from "@obora/adapters";
+import { type BaseAgent, AgentRole } from "../../agents/roles/index.js";
+import type { AgentResolver } from "./step-executor.js";
+export interface AgentRegistryConfig {
+    llm?: LLMAdapter;
+    toolRegistry?: ToolRegistry;
+    roleMap?: Record<string, AgentRole>;
+}
+export declare class AgentRegistry implements AgentResolver {
+    private readonly fallbackLlm?;
+    private readonly toolRegistry?;
+    private readonly roleMap;
+    private readonly adapterByConfig;
+    constructor(config: AgentRegistryConfig);
+    resolve(agentName: string): Promise<BaseAgent>;
+    resolve(query: {
+        agent?: string;
+        type?: string;
+        config?: AgentConfig;
+    }): Promise<BaseAgent>;
+    getAdapterForProvider(provider: string, config: AgentConfig): Promise<LLMAdapter>;
+    has(agentName: string): boolean;
+    listAvailable(): string[];
+    private mapToRole;
+}

package/dist/_legacy/cli-runtime/runtime/blackboard.d.ts

@@ -0,0 +1,41 @@
+import type { StepErrorMetadata } from "./types.js";
+export interface StepRuntimeRecord {
+    success: boolean;
+    output: string | null;
+    error: string | null;
+    errorMeta?: StepErrorMetadata | null;
+    diagnosisCode: string | null;
+    completedAt: string | null;
+    failedAt: string | null;
+}
+export interface RuntimeState {
+    state: {
+        context: {
+            workflow?: Record<string, unknown>;
+            steps: Record<string, StepRuntimeRecord>;
+            [key: string]: unknown;
+        };
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export declare class Blackboard {
+    #private;
+    constructor(initialState?: Partial<RuntimeState>);
+    get version(): number;
+    read<T = unknown>(path: string, options?: {
+        strict?: boolean;
+    }): T;
+    exists(path: string): boolean;
+    on(_event: string, _listener: (...args: unknown[]) => void): this;
+    off(_event: string, _listener: (...args: unknown[]) => void): this;
+    once(_event: string, _listener: (...args: unknown[]) => void): this;
+    emit(_event: string, ..._args: unknown[]): boolean;
+    removeAllListeners(_event?: string): this;
+    listenerCount(_event: string): number;
+    recordStepResult(name: string, result: StepRuntimeRecord): void;
+    recordStepError(name: string, error: Omit<StepErrorMetadata, "code"> & {
+        code?: StepErrorMetadata["code"];
+    }): void;
+    getSnapshot(): Readonly<RuntimeState>;
+}