@obora/runtime 0.1.0

package/dist/consensus/ConsensusGate.d.ts

@@ -0,0 +1,83 @@
+import type { AuditTrail } from "../audit/AuditTrail.js";
+import { VotingSessionStore } from "./voting/VotingSessionStore.js";
+export interface ConsensusVoterSpec {
+    id: string;
+    weight?: number;
+}
+export interface ConsensusIssue {
+    severity: "P0" | "P1" | "P2";
+    description: string;
+}
+export interface ConsensusVoteInput {
+    voterId: string;
+    score?: number;
+    approved: boolean;
+    issues?: ConsensusIssue[];
+    timestamp?: Date;
+}
+export interface ConsensusVote {
+    voterId: string;
+    score?: number;
+    approved: boolean;
+    issues?: ConsensusIssue[];
+    timestamp: Date;
+}
+export interface ConsensusConfig {
+    type: "majority" | "unanimous" | "weighted" | "score-threshold" | "custom";
+    voters: ConsensusVoterSpec[];
+    minRequired: number;
+    threshold?: number;
+    timeout?: string;
+    bestEffort?: string[];
+    customEvaluate?: (votes: ConsensusVote[]) => GateConsensusResult;
+}
+export interface ConsensusSession {
+    id: string;
+    config: ConsensusConfig;
+    startedAt: Date;
+    bestEffortMarked: string[];
+}
+export type GateConsensusResult = {
+    status: "pass";
+    votes: ConsensusVote[];
+} | {
+    status: "fail";
+    reason: string;
+    votes: ConsensusVote[];
+} | {
+    status: "pending";
+    received: number;
+    required: number;
+} | {
+    status: "timeout";
+    partial: ConsensusVote[];
+};
+export interface ConsensusGate {
+    setup(config: ConsensusConfig): ConsensusSession;
+    registerVote(sessionId: string, vote: ConsensusVoteInput): void;
+    evaluate(sessionId: string): GateConsensusResult;
+    onTimeout(sessionId: string): GateConsensusResult;
+    markBestEffort(sessionId: string, voterId: string): void;
+}
+export declare class DefaultConsensusGate implements ConsensusGate {
+    private readonly options;
+    private readonly sessions;
+    private readonly votingSessionStore;
+    constructor(options: {
+        executionId: string;
+        auditTrail?: AuditTrail;
+        votingSessionStore?: VotingSessionStore;
+        now?: () => Date;
+        sessionIdFactory?: () => string;
+    });
+    setup(config: ConsensusConfig): ConsensusSession;
+    registerVote(sessionId: string, vote: ConsensusVoteInput): void;
+    evaluate(sessionId: string): GateConsensusResult;
+    onTimeout(sessionId: string): GateConsensusResult;
+    markBestEffort(sessionId: string, voterId: string): void;
+    private evaluateInternal;
+    private findVotingSessionId;
+    private findWeight;
+    private requireState;
+    private recordConsensusResult;
+}

package/dist/consensus/ConsensusRuleEngine.d.ts

@@ -0,0 +1 @@
+export * from "../_legacy/blackboard/domains/consensus/ConsensusRuleEngine.js";

package/dist/consensus/agenda/AgendaStore.d.ts

@@ -0,0 +1 @@
+export * from "../../_legacy/blackboard/domains/agenda/AgendaStore.js";

package/dist/consensus/agenda/events.d.ts

@@ -0,0 +1 @@
+export * from "../../_legacy/blackboard/domains/agenda/events.js";

package/dist/consensus/agenda/index.d.ts

@@ -0,0 +1 @@
+export * from "../../_legacy/blackboard/domains/agenda/index.js";

package/dist/consensus/agenda/types.d.ts

@@ -0,0 +1 @@
+export * from "../../_legacy/blackboard/domains/agenda/types.js";

package/dist/consensus/index.d.ts

@@ -0,0 +1,2 @@
+export * from "../_legacy/blackboard/domains/consensus/index.js";
+export * from "./ConsensusGate.js";

package/dist/consensus/types.d.ts

@@ -0,0 +1 @@
+export * from "../_legacy/blackboard/domains/consensus/types.js";

package/dist/consensus/voting/VotingSessionStore.d.ts

@@ -0,0 +1 @@
+export * from "../../_legacy/blackboard/domains/voting/VotingSessionStore.js";

package/dist/consensus/voting/index.d.ts

@@ -0,0 +1 @@
+export * from "../../_legacy/blackboard/domains/voting/index.js";

package/dist/consensus/voting/types.d.ts

@@ -0,0 +1 @@
+export * from "../../_legacy/blackboard/domains/voting/types.js";

package/dist/errors/OboraErrorCode.d.ts

@@ -0,0 +1,28 @@
+export declare enum OboraErrorCode {
+    CELL_TIMEOUT = "CELL_1001",
+    CELL_TOOL_DENIED = "CELL_1002",
+    CELL_LLM_ERROR = "CELL_1003",
+    CELL_ABORTED = "CELL_1004",
+    POLICY_DENY = "POLICY_2001",
+    POLICY_GATE_REQUIRED = "POLICY_2002",
+    POLICY_GATE_TIMEOUT = "POLICY_2003",
+    POLICY_GATE_REJECTED = "POLICY_2004",
+    POLICY_SANDBOX_VIOLATION = "POLICY_2005",
+    POLICY_RESOURCE_EXCEEDED = "POLICY_2006",
+    POLICY_LOAD_FAILED = "POLICY_2007",
+    CONSENSUS_FAIL = "CONSENSUS_3001",
+    CONSENSUS_TIMEOUT = "CONSENSUS_3002",
+    CONSENSUS_QUORUM_NOT_MET = "CONSENSUS_3003",
+    RECOVERY_RETRY_EXHAUSTED = "RECOVERY_4001",
+    RECOVERY_ROLLBACK_FAILED = "RECOVERY_4002",
+    RECOVERY_ESCALATION_TIMEOUT = "RECOVERY_4003",
+    ORCH_WORKFLOW_NOT_FOUND = "ORCH_5001",
+    ORCH_STEP_NOT_FOUND = "ORCH_5002",
+    ORCH_DEPENDENCY_FAILED = "ORCH_5003",
+    ORCH_EXECUTION_TIMEOUT = "ORCH_5004",
+    AUDIT_STORE_ERROR = "AUDIT_6001",
+    AUDIT_REPLAY_NOT_FOUND = "AUDIT_6002",
+    ADAPTER_LLM_UNAVAILABLE = "ADAPTER_7001",
+    ADAPTER_AUTH_FAILED = "ADAPTER_7002",
+    ADAPTER_TOOL_NOT_FOUND = "ADAPTER_7003"
+}

package/dist/errors/index.d.ts

@@ -0,0 +1 @@
+export * from "./OboraErrorCode.js";

package/dist/gates/GateAssignment.d.ts

@@ -0,0 +1,28 @@
+import { type GateRuntimeContext } from "./types.js";
+export interface GateAssignment {
+    gateId: string;
+    stepName: string;
+    assignedTo: string;
+    assignedAt: Date;
+    expiresAt?: Date;
+    status: "pending" | "completed" | "expired" | "reassigned";
+    reassignedFrom?: string;
+    reassignmentReason?: string;
+}
+export declare class GateAssignmentManager {
+    private readonly context;
+    private readonly assignments;
+    constructor(context?: GateRuntimeContext);
+    assign(gateId: string, stepName: string, assignee: string, timeout?: string): GateAssignment;
+    /**
+     * Reassign a gate to a new assignee. The expiresAt is refreshed:
+     * - If an explicit `timeout` is provided, use it from now.
+     * - Otherwise, preserve the original timeout duration relative to new assignedAt.
+     * - If the original had no timeout, expiresAt remains undefined.
+     */
+    reassign(gateId: string, newAssignee: string, reason: string, timeout?: string): GateAssignment;
+    expire(gateId: string): GateAssignment;
+    getAssignment(gateId: string): GateAssignment | undefined;
+    getActiveAssignments(): GateAssignment[];
+    private now;
+}

package/dist/gates/MultiStageApproval.d.ts

@@ -0,0 +1,74 @@
+import { type GateFallback, type GateRuntimeContext } from "./types.js";
+export interface ApprovalStage {
+    name: string;
+    approvers: string[];
+    required: number;
+    timeout?: string;
+    fallback?: GateFallback;
+    escalation_to?: string;
+    condition?: string;
+}
+export interface MultiStageGateConfig {
+    stages: ApprovalStage[];
+    on_reject?: "fail" | "restart" | "reassign";
+    allow_comments?: boolean;
+    track_history?: boolean;
+}
+export interface ApprovalDecision {
+    stageIndex: number;
+    stageName: string;
+    approver: string;
+    decision: "approved" | "rejected" | "abstained";
+    comment?: string;
+    timestamp: Date;
+}
+export interface MultiStageApprovalResult {
+    approved: boolean;
+    stages: Array<{
+        name: string;
+        status: "approved" | "rejected" | "pending" | "skipped" | "timeout";
+        decisions: ApprovalDecision[];
+    }>;
+    reason?: string;
+    /**
+     * Signals the distinct on_reject action the caller should take:
+     * - "fail": terminal rejection, no retry.
+     * - "restart": caller should reset all stages and re-collect decisions from stage 0.
+     * - "reassign": caller should reassign the rejecting stage to a different approver.
+     * Only set when a rejection occurs.
+     */
+    action?: "fail" | "restart" | "reassign";
+    /** When action="reassign", identifies the stage index to reassign. */
+    reassignStageIndex?: number;
+}
+/**
+ * Stage-level timeout/fallback/escalation_to mapping to SLAManager:
+ *
+ * Each ApprovalStage may declare `timeout`, `fallback`, and `escalation_to`.
+ * These fields map to SLAManager.checkSLA() as follows:
+ *   - stage.timeout   → SLAConfig.timeout
+ *   - stage.fallback   → SLAConfig.fallback (defaults to "fail")
+ *   - stage.escalation_to → SLAConfig.escalation_chain[0]
+ *
+ * The caller is responsible for constructing an SLAConfig from stage fields
+ * and invoking SLAManager.checkSLA() with the relevant GateAssignment.
+ * Use `buildSLAConfigFromStage()` below for the canonical mapping.
+ */
+export interface StageSLAConfig {
+    timeout: string;
+    fallback: GateFallback;
+    escalation_chain?: string[];
+}
+/**
+ * Build an SLAConfig from stage-level timeout/fallback/escalation_to fields.
+ * Returns undefined if the stage has no timeout configured.
+ */
+export declare function buildSLAConfigFromStage(stage: ApprovalStage): StageSLAConfig | undefined;
+export declare class MultiStageApprovalGate {
+    private readonly config;
+    private readonly context;
+    constructor(config: MultiStageGateConfig, context?: GateRuntimeContext);
+    evaluate(decisions: ApprovalDecision[]): Promise<MultiStageApprovalResult>;
+    private normalizeDecisions;
+    private pickStageDecisions;
+}

package/dist/gates/SLAManager.d.ts

@@ -0,0 +1,21 @@
+import type { GateAssignment } from "./GateAssignment.js";
+import { type GateFallback, type GateRuntimeContext } from "./types.js";
+export interface SLAConfig {
+    timeout: string;
+    warning_at?: string;
+    fallback: GateFallback;
+    escalation_chain?: string[];
+}
+export interface SLACheckResult {
+    status: "ok" | "warning" | "expired";
+    remainingMs?: number;
+    action?: "none" | "warn" | "escalate" | "auto-approve" | "fail";
+    escalationTarget?: string;
+}
+export declare class SLAManager {
+    private readonly context;
+    constructor(context?: GateRuntimeContext);
+    checkSLA(assignment: GateAssignment, config: SLAConfig): SLACheckResult;
+    private resolveExpired;
+    private now;
+}

package/dist/gates/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./MultiStageApproval.js";
+export * from "./GateAssignment.js";
+export * from "./SLAManager.js";

package/dist/gates/types.d.ts

@@ -0,0 +1,19 @@
+export type GateFallback = "fail" | "escalate" | "auto-approve";
+export type HITLAuditEventType = "gate_assignment_created" | "gate_assignment_reassigned" | "gate_assignment_expired" | "gate_approval_decision" | "gate_sla_warning" | "gate_sla_expired";
+export interface GateAuditEvent {
+    type: HITLAuditEventType;
+    payload: Record<string, unknown>;
+}
+export interface GateRuntimeContext {
+    emit?: (event: GateAuditEvent) => Promise<void> | void;
+    now?: () => Date;
+    conditionContext?: Record<string, unknown>;
+}
+export declare function parseDurationToMs(duration?: string): number | undefined;
+/**
+ * Evaluate a gate condition expression.
+ *
+ * @throws {Error} When parsing or evaluation fails. Callers must handle this
+ *   as a fail-closed error path (stage failure), not as a skipped stage.
+ */
+export declare function evaluateGateCondition(condition: string | undefined, context: Record<string, unknown>): boolean;