@obora/runtime 0.1.0

package/dist/judgment/JudgmentEngine.d.ts

@@ -0,0 +1,24 @@
+/**
+ * JudgmentEngine — core state-transition and precedence logic.
+ * TASK-M1-25
+ */
+import type { EngineOptions, EngineResult, HumanResolution, JudgmentStatus, StepInput, TransitionLog } from './types.js';
+export interface JudgeFn {
+    (stepId: string): Promise<JudgmentStatus>;
+}
+export interface EngineLogger {
+    transition(log: TransitionLog): void;
+}
+export declare class JudgmentEngine {
+    private readonly opts;
+    private readonly judge;
+    private readonly logger;
+    constructor(opts: EngineOptions, judge: JudgeFn, logger?: EngineLogger);
+    run(input: StepInput): Promise<EngineResult>;
+    /**
+     * Resolve a needs-human-review state.
+     */
+    resolveHuman(result: EngineResult, resolution: HumanResolution): EngineResult;
+    private executeWithTimeout;
+    private sleep;
+}

package/dist/judgment/JudgmentNormalizer.d.ts

@@ -0,0 +1,37 @@
+/**
+ * JudgmentNormalizer — normalize raw model output + duplicate latest selection.
+ * TASK-M1-26
+ */
+export type NormalizeErrorCode = 'RESOLVE_ERROR' | 'VALIDATION_ERROR' | 'MALFORMED_JSON';
+export interface IssueEntry {
+    level: 'P0' | 'P1' | 'P2';
+    message: string;
+}
+export interface NormalizeInput {
+    rawModelOutput: unknown;
+    attempt: number;
+    receivedAt?: string;
+    ingestSeq: number;
+}
+export interface NormalizeOutput {
+    judgmentStatus: 'pass' | 'fail';
+    score: number;
+    issues: IssueEntry[];
+    errorCode?: NormalizeErrorCode;
+}
+/**
+ * Parse ISO-8601 receivedAt. Accepts ONLY UTC Z format (e.g. '2026-01-01T00:00:00Z').
+ * Returns epoch ms or -Infinity on failure/missing/non-Z format.
+ */
+export declare function parseReceivedAt(value?: string): number;
+export declare class JudgmentNormalizer {
+    /**
+     * Normalize a single raw model output into deterministic NormalizeOutput.
+     */
+    normalize(input: NormalizeInput): NormalizeOutput;
+    /**
+     * Select the latest entry among duplicates.
+     * Tie-break: attempt > receivedAt > ingestSeq (all descending / largest wins).
+     */
+    selectLatest(entries: NormalizeInput[]): NormalizeInput;
+}

package/dist/judgment/JudgmentPolicy.d.ts

@@ -0,0 +1,74 @@
+/**
+ * JudgmentPolicy — schema/policy resolve + snapshot hash.
+ * TASK-M1-26
+ */
+export interface ResolveInput {
+    policyRef: string;
+    schemaRef: string;
+    runId: string;
+    engineVersion: string;
+}
+export type ResolveSource = 'memory' | 'local';
+export interface ResolveOutput {
+    policy: object;
+    schema: object;
+    snapshotHash: string;
+    source: ResolveSource;
+}
+export interface ResolveError {
+    errorCode: 'RESOLVE_ERROR';
+    message: string;
+}
+export type ResolveResult = {
+    ok: true;
+    value: ResolveOutput;
+} | {
+    ok: false;
+    error: ResolveError;
+};
+/**
+ * Store abstraction — implemented by callers.
+ */
+export interface PolicyStore {
+    get(ref: string): object | undefined;
+}
+/**
+ * Structured log entry for resolve operations (observability).
+ */
+export interface ResolveLogEntry {
+    event: 'resolve_success' | 'resolve_fallback' | 'resolve_error';
+    source?: ResolveSource;
+    policyRef: string;
+    schemaRef: string;
+    snapshotHash?: string;
+    errorCode?: string;
+    message?: string;
+}
+/**
+ * Logger interface — callers can provide a structured logger.
+ * Defaults to console.log JSON if not provided.
+ */
+export interface StructuredLogger {
+    log(entry: ResolveLogEntry): void;
+}
+/**
+ * Canonical JSON string (no whitespace, sorted keys, NFC strings).
+ */
+export declare function canonicalJson(value: unknown): string;
+export declare function computeSnapshotHash(policyRef: string, schemaRef: string, policy: object, schema: object, engineVersion: string): string;
+export declare class JudgmentPolicyResolver {
+    private readonly memoryStore;
+    private readonly localStore;
+    private readonly logger;
+    constructor(memoryStore: PolicyStore, localStore: PolicyStore, logger?: StructuredLogger);
+    /**
+     * Resolve policy+schema with memory->local fallback.
+     *
+     * Cross-store semantics: memory store is checked first for BOTH policyRef
+     * and schemaRef. If either is missing from memory, the resolver falls back
+     * to local store for BOTH (no cross-store mixing). If local also fails,
+     * RESOLVE_ERROR is returned.
+     */
+    resolve(input: ResolveInput): ResolveResult;
+    private buildSuccess;
+}

package/dist/judgment/JudgmentReporter.d.ts

@@ -0,0 +1,70 @@
+/**
+ * JudgmentReporter — JSON & Markdown report generation.
+ * TASK-M1-27
+ */
+import type { RunState, JudgmentStatus } from './types.js';
+import type { IssueEntry } from './JudgmentNormalizer.js';
+export interface ModelResult {
+    model: string;
+    score: number;
+    judgmentStatus: JudgmentStatus;
+    runState: RunState;
+    issues: IssueEntry[];
+}
+export interface JudgmentReport {
+    runId: string;
+    workflow: string;
+    responses: number;
+    avgScore: number;
+    p0Count: number;
+    p1Count: number;
+    runState: RunState;
+    finalPass: boolean;
+    decisionReason: string;
+    results: ModelResult[];
+}
+declare const REQUIRED_JSON_FIELDS: readonly (keyof JudgmentReport)[];
+declare const REQUIRED_MD_SECTIONS: readonly ["# Judgment Report", "runId", "workflow", "runState", "finalPass", "decisionReason"];
+declare const REQUIRED_TABLE_COLUMNS: readonly ["model", "score", "judgmentStatus", "runState", "issues"];
+export { REQUIRED_JSON_FIELDS, REQUIRED_MD_SECTIONS, REQUIRED_TABLE_COLUMNS };
+export interface ReporterLogger {
+    log(entry: {
+        event: string;
+        runId: string;
+        workflow: string;
+        size: number;
+    }): void;
+}
+export declare class JudgmentReporter {
+    private readonly logger;
+    constructor(logger?: ReporterLogger);
+    /**
+     * Build a JudgmentReport from model results and workflow metadata.
+     */
+    buildReport(params: {
+        runId: string;
+        workflow: string;
+        results: ModelResult[];
+        runState: RunState;
+        decisionReason: string;
+    }): JudgmentReport;
+    /**
+     * Serialize report to JSON string.
+     */
+    toJSON(report: JudgmentReport): string;
+    /**
+     * Serialize report to Markdown string.
+     */
+    toMarkdown(report: JudgmentReport): string;
+    /**
+     * Validate that a JSON report object contains all required fields.
+     */
+    static validateJsonFields(report: Record<string, unknown>): string[];
+    /**
+     * Validate that a Markdown string contains all required sections and table columns.
+     */
+    static validateMarkdown(md: string): {
+        missingSections: string[];
+        missingColumns: string[];
+    };
+}

package/dist/judgment/OperationalLogger.d.ts

@@ -0,0 +1,68 @@
+/**
+ * OperationalLogger — standardized operational logging for judgment runtime.
+ * TASK-M1-28
+ *
+ * All judgment runtime events are emitted with required fields:
+ *   runId, workflow, runState, errorCode, snapshotHash, durationMs
+ *
+ * Event types:
+ *   resolve_success, resolve_fallback, resolve_error,
+ *   state_transition, report_generated
+ */
+import type { RunState, ErrorCode } from './types.js';
+export type OperationalEventType = 'resolve_success' | 'resolve_fallback' | 'resolve_error' | 'state_transition' | 'report_generated';
+/**
+ * Standard operational log entry — every event emitted by the judgment
+ * runtime MUST include all of these fields (nullable ones may be null).
+ */
+export interface OperationalLogEntry {
+    /** ISO-8601 timestamp */
+    timestamp: string;
+    /** Event type */
+    event: OperationalEventType;
+    /** Unique run identifier */
+    runId: string;
+    /** Workflow name (e.g. "review", "qa", "release") */
+    workflow: string;
+    /** Current run state */
+    runState: RunState;
+    /** Error code if applicable, null otherwise */
+    errorCode: ErrorCode | string | null;
+    /** Snapshot hash of policy+schema, null if not yet resolved */
+    snapshotHash: string | null;
+    /** Duration in milliseconds since run start, -1 if unknown */
+    durationMs: number;
+    /** Optional extra metadata */
+    meta?: Record<string, unknown>;
+}
+export declare const REQUIRED_LOG_FIELDS: readonly (keyof OperationalLogEntry)[];
+export interface LogSink {
+    write(entry: OperationalLogEntry): void;
+}
+export declare const stdoutSink: LogSink;
+export interface OperationalLoggerOptions {
+    workflow: string;
+    sink?: LogSink;
+}
+export declare class OperationalLogger {
+    private readonly workflow;
+    private readonly sink;
+    private runStartMs;
+    constructor(opts: OperationalLoggerOptions);
+    resetTimer(): void;
+    emit(params: {
+        event: OperationalEventType;
+        runId: string;
+        runState: RunState;
+        errorCode?: ErrorCode | string | null;
+        snapshotHash?: string | null;
+        durationMs?: number;
+        meta?: Record<string, unknown>;
+    }): OperationalLogEntry;
+    resolveSuccess(runId: string, runState: RunState, snapshotHash: string, meta?: Record<string, unknown>): OperationalLogEntry;
+    resolveFallback(runId: string, runState: RunState, snapshotHash: string, meta?: Record<string, unknown>): OperationalLogEntry;
+    resolveError(runId: string, runState: RunState, errorCode: string, meta?: Record<string, unknown>): OperationalLogEntry;
+    stateTransition(runId: string, runState: RunState, from: RunState, to: RunState, reason: string): OperationalLogEntry;
+    reportGenerated(runId: string, runState: RunState, snapshotHash: string | null, meta?: Record<string, unknown>): OperationalLogEntry;
+    static validateEntry(entry: Record<string, unknown>): string[];
+}

package/dist/judgment/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './JudgmentEngine.js';
+export * from './JudgmentPolicy.js';
+export * from './JudgmentNormalizer.js';
+export * from './JudgmentReporter.js';
+export * from './OperationalLogger.js';

package/dist/judgment/types.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Judgment Engine types — TASK-M1-25
+ */
+export type RunState = 'queued' | 'running' | 'retried' | 'timeout' | 'failed' | 'skipped' | 'needs-human-review' | 'done';
+export type ErrorCode = 'TIMEOUT' | 'GOTO_TARGET_NOT_FOUND' | 'ESCALATION_FAILED';
+export interface OnFailPolicy {
+    goto?: string;
+    escalateAfterConsecutiveFails?: number;
+}
+export interface EngineOptions {
+    timeoutMs: number;
+    batchDeadlineMs: number;
+    maxRetries: number;
+    backoffMs: number;
+    onFail?: OnFailPolicy;
+}
+export interface EngineResult {
+    runId: string;
+    runState: RunState;
+    retryCount: number;
+    nextStep?: string;
+    errorCode?: ErrorCode;
+    decisionTrace: string[];
+}
+export type JudgmentStatus = 'pass' | 'fail';
+export interface StepInput {
+    stepId: string;
+    /** Available goto targets */
+    validTargets?: string[];
+    /** If true, skip this step */
+    skipCondition?: boolean;
+}
+export interface HumanResolution {
+    action: 'approve' | 'reject';
+}
+export interface TransitionLog {
+    runId: string;
+    from: RunState;
+    to: RunState;
+    reason: string;
+    timestamp: number;
+}

package/dist/orchestrator/ExecutionContextBuilder.d.ts

@@ -0,0 +1 @@
+export * from "../_legacy/cli-runtime/runtime/context-builder.js";

package/dist/orchestrator/RuntimeOrchestrator.d.ts

@@ -0,0 +1,94 @@
+import { type Workflow } from "../_legacy/workflow/index.js";
+import type { CellManager } from "../cell/CellManager.js";
+import type { AuditTrail } from "../audit/AuditTrail.js";
+import type { ConsensusGate } from "../consensus/ConsensusGate.js";
+import type { PolicyEngine } from "../policy/PolicyEngine.js";
+import type { RecoveryEngine } from "../recovery/types.js";
+import type { StateBinder } from "../state/StateBinder.js";
+import type { StorageAdapter, ResumeOptions } from "../storage/types.js";
+import type { ArtifactStore } from "../artifacts/types.js";
+import type { PolicyHashInput } from "../checkpoint/policy-hash.js";
+import type { Execution, ExecutionFilter, GateWaitStateStore, ResumeResult, RuntimeOrchestrator as RuntimeOrchestratorContract, RuntimeOrchestratorOptions } from "./types.js";
+export interface RuntimeOrchestratorDependencies {
+    cellManager: CellManager;
+    policyEngine: PolicyEngine;
+    stateBinder?: StateBinder;
+    auditTrail?: AuditTrail;
+    consensusGate?: ConsensusGate;
+    recoveryEngine?: RecoveryEngine;
+    gateWaitStateStore?: GateWaitStateStore;
+    storageAdapter?: StorageAdapter;
+    artifactStore?: ArtifactStore;
+}
+export declare class DefaultRuntimeOrchestrator implements RuntimeOrchestratorContract {
+    private readonly dependencies;
+    private readonly options;
+    private readonly workflows;
+    private readonly executions;
+    private readonly waitingContexts;
+    private readonly approvedGateSteps;
+    private readonly createExecutionId;
+    private readonly now;
+    private readonly wait;
+    private readonly starvationTimeoutMs;
+    private readonly gateWaitStateStore;
+    private policyConfig;
+    private checkpointManager?;
+    constructor(dependencies: RuntimeOrchestratorDependencies, options?: RuntimeOrchestratorOptions);
+    /** Set the policy config used for checkpoint drift detection */
+    setPolicyConfig(config: PolicyHashInput): void;
+    define(name: string, workflow: Workflow | string): void;
+    run(name: string, input: unknown): Promise<Execution>;
+    resume(runId: string, options?: ResumeOptions): Promise<ResumeResult>;
+    approve(executionId: string): Promise<Execution>;
+    reject(executionId: string, reason?: string): Promise<Execution>;
+    onGateTimeout(executionId: string): Promise<Execution>;
+    getExecution(id: string): Execution;
+    listExecutions(filter?: ExecutionFilter): Execution[];
+    private requireExecution;
+    private executeLoop;
+    private createExecution;
+    private runStep;
+    private evaluateConsensusIfNeeded;
+    private handleStepFailure;
+    private tryHandleBackEdge;
+    private loopStateKey;
+    private validateBackEdgeIntegrity;
+    private getBackEdgeState;
+    private setBackEdgeState;
+    private getCachedGraph;
+    private trackLoopCost;
+    private isStepInBackEdgeChain;
+    private pruneForBackEdge;
+    private runRecovery;
+    private toBackEdgeEscalationStrategy;
+    private handleStarvation;
+    private extractGateConfig;
+    private mergeGateDecision;
+    /**
+     * Consensus schema compatibility:
+     * - Canonical (SCHEMAS.md): `step.consensus.rule`, `step.consensus.best_effort`
+     * - Legacy compatibility: `step.consensus.type`, `step.consensus.bestEffort`
+     * - Transitional fallback: `step.config.consensus` (older workflow fixtures)
+     */
+    private extractConsensusConfig;
+    private extractRecoveryStrategy;
+    private toRecoveryStrategyFromWorkflow;
+    private toRecoveryStrategyFromLegacy;
+    private createGateWaitState;
+    private stepToTask;
+    private buildCellConfig;
+    private buildStepOutput;
+    private bindStepState;
+    private extractStateBindings;
+    private readonly isStateBinding;
+    private recordExecutionEnd;
+    private static mapExecutionStatusToRunStatus;
+    private persistRun;
+    private persistStep;
+    private toStepError;
+    private captureArtifacts;
+    private recordAudit;
+    private extractError;
+    private cloneExecution;
+}

package/dist/orchestrator/StepScheduler.d.ts

@@ -0,0 +1,2 @@
+export { executeStep as scheduleStep } from "../_legacy/cli-runtime/runtime/step-executor.js";
+export * from "../_legacy/cli-runtime/runtime/step-executor.js";

package/dist/orchestrator/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./RuntimeOrchestrator.js";
+export * from "./StepScheduler.js";
+export * from "./ExecutionContextBuilder.js";
+export * from "./types.js";

package/dist/orchestrator/types.d.ts

@@ -0,0 +1,80 @@
+import type { Step, Workflow } from "../_legacy/workflow/index.js";
+import type { CellResult } from "../cell/types.js";
+import type { ConsensusConfig, ConsensusVoteInput, GateConsensusResult } from "../consensus/ConsensusGate.js";
+import type { PolicyDecision } from "../policy/types.js";
+import type { RecoveryResult, RecoveryStrategy } from "../recovery/types.js";
+export type ExecutionStatus = "running" | "completed" | "failed" | "waiting" | "suspended";
+export type ExecutionStepStatus = "pending" | "running" | "completed" | "failed" | "waiting" | "skipped";
+export interface GateWaitState {
+    executionId: string;
+    stepName: string;
+    gateType: "human-approval" | "consensus" | "external";
+    status: "waiting" | "approved" | "rejected" | "timeout";
+    createdAt: Date;
+    timeout?: string;
+    fallback?: "fail" | "escalate" | "auto-approve";
+    persisted: true;
+}
+export interface GateWaitStateStore {
+    save(state: GateWaitState): Promise<void>;
+    get(executionId: string): Promise<GateWaitState | undefined>;
+    delete(executionId: string): Promise<void>;
+}
+export interface StepExecutionRecord {
+    stepName: string;
+    status: ExecutionStepStatus;
+    startedAt?: Date;
+    endedAt?: Date;
+    policyDecision?: PolicyDecision;
+    result?: CellResult;
+    error?: string;
+    recovery?: RecoveryResult;
+    consensus?: GateConsensusResult;
+}
+export interface Execution {
+    id: string;
+    workflowName: string;
+    status: ExecutionStatus;
+    input: unknown;
+    startedAt: Date;
+    endedAt?: Date;
+    stepOrder: string[];
+    completedSteps: string[];
+    stepRecords: Record<string, StepExecutionRecord>;
+    outputs: Record<string, unknown>;
+    waitingGate?: GateWaitState;
+    error?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ExecutionFilter {
+    status?: ExecutionStatus;
+    workflowName?: string;
+}
+export interface ResumeResult {
+    execution: Execution;
+    restoredSteps: string[];
+    rerunSteps: string[];
+    driftDetected: boolean;
+}
+export interface RuntimeOrchestrator {
+    define(name: string, workflow: Workflow | string): void;
+    run(name: string, input: unknown): Promise<Execution>;
+    resume(runId: string, options?: import("../storage/types.js").ResumeOptions): Promise<ResumeResult>;
+    approve(executionId: string): Promise<Execution>;
+    reject(executionId: string, reason?: string): Promise<Execution>;
+    onGateTimeout(executionId: string): Promise<Execution>;
+    getExecution(id: string): Execution;
+    listExecutions(filter?: ExecutionFilter): Execution[];
+}
+export interface RuntimeOrchestratorOptions {
+    createExecutionId?: () => string;
+    now?: () => Date;
+    wait?: (ms: number) => Promise<void>;
+    starvationTimeoutMs?: number;
+    onGate?: (execution: Execution, step: Step, decision: Extract<PolicyDecision, {
+        type: "gate";
+    }>) => Promise<"approved" | "rejected"> | "approved" | "rejected";
+    consensusVoteProvider?: (step: Step, execution: Execution, config: ConsensusConfig) => Promise<ConsensusVoteInput[]> | ConsensusVoteInput[];
+    defaultRecoveryStrategy?: RecoveryStrategy;
+}
+export * from "../_legacy/cli-runtime/runtime/types.js";

package/dist/orchestrator/utils.d.ts

@@ -0,0 +1 @@
+export * from "../_legacy/cli-runtime/runtime/utils.js";

package/dist/patterns/CustomPatternAPI.d.ts

@@ -0,0 +1,10 @@
+import type { PatternRegistry } from "./PatternRegistry.js";
+import { type CollaborationPattern, type CustomPatternDefinition } from "./types.js";
+export type { CustomPatternDefinition } from "./types.js";
+export interface RegisterCustomPatternOptions {
+    replace?: boolean;
+    logger?: Pick<Console, "warn">;
+}
+export declare function registerCustomPattern(registry: PatternRegistry, pattern: CollaborationPattern, options?: RegisterCustomPatternOptions): void;
+export declare function registerCustomPatternFromConfig(registry: PatternRegistry, config: CustomPatternDefinition, options?: RegisterCustomPatternOptions): void;
+export declare function validatePatternContract(pattern: CollaborationPattern): void;

package/dist/patterns/PatternRegistry.d.ts

@@ -0,0 +1,19 @@
+import type { PluginRegistry } from "../plugins/PluginRegistry.js";
+import type { CollaborationPattern } from "./types.js";
+/**
+ * PatternRegistry is a convenience facade over the pattern bucket in PluginRegistry.
+ *
+ * - Runtime implementations may register plain CollaborationPattern instances here.
+ * - If a PluginRegistry facade is provided, lookup/list operations are type-linked to
+ *   `type = "pattern"` plugin entries.
+ */
+export declare class PatternRegistry {
+    private readonly pluginFacade?;
+    private readonly patterns;
+    constructor(pluginFacade?: Pick<PluginRegistry, "get" | "has" | "list"> | undefined);
+    register(pattern: CollaborationPattern): void;
+    unregister(name: string): void;
+    get(name: string): CollaborationPattern;
+    has(name: string): boolean;
+    list(): CollaborationPattern[];
+}

package/dist/patterns/builtin/BrainstormPattern.d.ts

@@ -0,0 +1,13 @@
+import { CollaborationPatternBase, type BrainstormingPatternConfig, type BuiltinPatternKind, type PatternPayloadResult, type PatternRuntimeContext } from "../types.js";
+export declare class BrainstormPattern extends CollaborationPatternBase {
+    readonly name = "brainstorming";
+    readonly kind: BuiltinPatternKind;
+    validateConfig(config: BrainstormingPatternConfig): void;
+    protected onExecute(context: PatternRuntimeContext): Promise<PatternPayloadResult>;
+    private getInput;
+    private generateIdeas;
+    private readParticipantIdeasFromInput;
+    private deduplicate;
+    private exactDedup;
+    private rankIdeas;
+}

package/dist/patterns/builtin/CompositePattern.d.ts

@@ -0,0 +1,11 @@
+import type { PatternRegistry } from "../PatternRegistry.js";
+import { CollaborationPatternBase, type PatternPayloadResult, type PatternRuntimeContext, type CompositePatternConfig } from "../types.js";
+export declare class CompositePattern extends CollaborationPatternBase {
+    private readonly registry;
+    readonly name = "composite";
+    readonly kind: "composite";
+    constructor(registry: PatternRegistry);
+    validateConfig(config: CompositePatternConfig): void;
+    protected onExecute(context: PatternRuntimeContext): Promise<PatternPayloadResult>;
+    private resolveStageInput;
+}

package/dist/patterns/builtin/ConsensusPattern.d.ts

@@ -0,0 +1,17 @@
+import { CollaborationPatternBase, type BuiltinPatternKind, type ConsensusPatternConfig, type PatternPayloadResult, type PatternRuntimeContext } from "../types.js";
+export declare class ConsensusPattern extends CollaborationPatternBase {
+    readonly name = "consensus";
+    readonly kind: BuiltinPatternKind;
+    validateConfig(config: ConsensusPatternConfig): void;
+    protected onExecute(context: PatternRuntimeContext): Promise<PatternPayloadResult>;
+    private buildVoterRoleMap;
+    private shouldEscalate;
+    private buildEscalationResult;
+    private getConsensusInput;
+    private collectVotes;
+    private normalizeVote;
+    private hasTimedOut;
+    private resolveNow;
+    private evaluateRule;
+    private resolveCustomEvaluator;
+}

package/dist/patterns/builtin/DiscussionPattern.d.ts

@@ -0,0 +1,13 @@
+import { CollaborationPatternBase, type BuiltinPatternKind, type DiscussionPatternConfig, type PatternPayloadResult, type PatternRuntimeContext } from "../types.js";
+export declare class DiscussionPattern extends CollaborationPatternBase {
+    readonly name = "discussion";
+    readonly kind: BuiltinPatternKind;
+    validateConfig(config: DiscussionPatternConfig): void;
+    protected onExecute(context: PatternRuntimeContext): Promise<PatternPayloadResult>;
+    private getDiscussionInput;
+    private collectRoundOpinions;
+    private evaluateConvergence;
+    private resolveCustomConvergence;
+    private countOpinions;
+    private handleDeadlock;
+}

package/dist/patterns/builtin/FanOutFanInPattern.d.ts

@@ -0,0 +1,21 @@
+import { CollaborationPatternBase, type BuiltinPatternKind, type FanOutFanInPatternConfig, type PatternPayloadResult, type PatternRuntimeContext } from "../types.js";
+export declare class FanOutFanInPattern extends CollaborationPatternBase {
+    readonly name = "fan-out-fan-in";
+    readonly kind: BuiltinPatternKind;
+    validateConfig(config: FanOutFanInPatternConfig): void;
+    protected onExecute(context: PatternRuntimeContext): Promise<PatternPayloadResult>;
+    private getInput;
+    private buildParticipantPayload;
+    private processParticipant;
+    private mergeOutputs;
+    private rankMerge;
+    /**
+     * Vote merge: tallies outputs by serialized key, returns the value with the highest count.
+     * Tie-breaker rule: when two or more values have the same vote count,
+     * the value that appeared first (lowest participant index) wins.
+     * This is deterministic and stable across runs with the same input order.
+     */
+    private voteMerge;
+    private extractScore;
+    private serializeVoteKey;
+}