@fenixforce/edition-pro 0.1.0

package/dist/business/fleet-config.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Fleet Configuration Schema — Task B0.1
+ *
+ * TypeScript interfaces and Zod schemas for fleet (multi-workspace)
+ * configuration. Includes routing rules, budget limits, channel bindings,
+ * workspace configs, approval settings, and a loader that reads fleet.json,
+ * validates with Zod, and merges sensible defaults.
+ */
+import { z } from "zod";
+export declare function resolveEnvVar(value: string): string;
+export declare const ApprovalConfigSchema: z.ZodObject<{
+    requireApproval: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    autoApprove: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    expirationDays: z.ZodDefault<z.ZodNumber>;
+    notifyOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    notifyChannel: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type ApprovalConfig = z.infer<typeof ApprovalConfigSchema>;
+export declare const BudgetConfigSchema: z.ZodObject<{
+    dailyLimit: z.ZodDefault<z.ZodNumber>;
+    monthlyLimit: z.ZodDefault<z.ZodNumber>;
+    perWorkspaceDailyLimit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type BudgetConfig = z.infer<typeof BudgetConfigSchema>;
+export declare const FleetRouterConfigSchema: z.ZodObject<{
+    mentionPrefix: z.ZodDefault<z.ZodString>;
+    fallbackWorkspace: z.ZodDefault<z.ZodString>;
+    classificationModel: z.ZodDefault<z.ZodString>;
+    confidenceThreshold: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type FleetRouterConfig = z.infer<typeof FleetRouterConfigSchema>;
+export declare const WorkspaceConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    identityDir: z.ZodDefault<z.ZodString>;
+    channels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    layers: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    approval: z.ZodOptional<z.ZodObject<{
+        requireApproval: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        autoApprove: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        expirationDays: z.ZodDefault<z.ZodNumber>;
+        notifyOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        notifyChannel: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    budget: z.ZodOptional<z.ZodObject<{
+        dailyLimit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        monthlyLimit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        perWorkspaceDailyLimit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    integrationGrants: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type WorkspaceConfig = z.infer<typeof WorkspaceConfigSchema>;
+export declare const ChannelBindingSchema: z.ZodObject<{
+    channel: z.ZodString;
+    workspaceId: z.ZodString;
+    config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type ChannelBinding = z.infer<typeof ChannelBindingSchema>;
+export declare const FleetConfigSchema: z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    name: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<1>>;
+    routing: z.ZodDefault<z.ZodObject<{
+        mentionPrefix: z.ZodDefault<z.ZodString>;
+        fallbackWorkspace: z.ZodDefault<z.ZodString>;
+        classificationModel: z.ZodDefault<z.ZodString>;
+        confidenceThreshold: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    budget: z.ZodDefault<z.ZodObject<{
+        dailyLimit: z.ZodDefault<z.ZodNumber>;
+        monthlyLimit: z.ZodDefault<z.ZodNumber>;
+        perWorkspaceDailyLimit: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    channelBindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        channel: z.ZodString;
+        workspaceId: z.ZodString;
+        config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    workspaces: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        identityDir: z.ZodDefault<z.ZodString>;
+        channels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        layers: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        approval: z.ZodOptional<z.ZodObject<{
+            requireApproval: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            autoApprove: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            expirationDays: z.ZodDefault<z.ZodNumber>;
+            notifyOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            notifyChannel: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+        budget: z.ZodOptional<z.ZodObject<{
+            dailyLimit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            monthlyLimit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            perWorkspaceDailyLimit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        }, z.core.$strip>>;
+        integrationGrants: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    approval: z.ZodDefault<z.ZodObject<{
+        requireApproval: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        autoApprove: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        expirationDays: z.ZodDefault<z.ZodNumber>;
+        notifyOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        notifyChannel: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type FleetConfig = z.infer<typeof FleetConfigSchema>;
+export declare const DEFAULT_FLEET_CONFIG: FleetConfig;
+export interface LoadFleetConfigOptions {
+    /** If true, resolve ${ENV_VAR} placeholders in string values. */
+    resolveEnv?: boolean;
+}
+/**
+ * Parse and validate a fleet configuration object.
+ * Merges with sensible defaults, optionally resolves env vars.
+ */
+export declare function loadFleetConfig(raw: unknown, options?: LoadFleetConfigOptions): FleetConfig;
+/**
+ * Parse fleet config from a JSON string (e.g. read from fleet.json).
+ */
+export declare function loadFleetConfigFromJSON(json: string, options?: LoadFleetConfigOptions): FleetConfig;

package/dist/business/fleet.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Fleet Coordinator — Task B1.1
+ *
+ * Top-level orchestrator that composes the workspace manager, shared memory
+ * bridge, fleet router, and budget tracking into a single lifecycle manager.
+ */
+import type { FleetConfig, WorkspaceConfig, BudgetConfig } from "./fleet-config.js";
+import { type WorkspaceManager, type WorkspaceInstance, type IdentityAssemblerLike, type WorkspaceStorageLike } from "./workspace-manager.js";
+import { type SharedMemoryBridge, type MemoryEngineLike, type EmbedFn } from "./shared-memory.js";
+import { type RouteEnvelope, type RouteResult, type ClassificationProviderLike } from "./router.js";
+export type FleetStatus = "created" | "starting" | "running" | "stopping" | "stopped";
+export interface FleetStatusReport {
+    fleetId: string;
+    customerId: string;
+    status: FleetStatus;
+    workspaces: Array<{
+        id: string;
+        name: string;
+        status: WorkspaceInstance["status"];
+    }>;
+    budget: {
+        dailySpent: number;
+        monthlySpent: number;
+        dailyLimit: number;
+        monthlyLimit: number;
+    };
+    messageCount: number;
+    startedAt: Date | null;
+}
+export type FleetEventType = "fleet:started" | "fleet:stopped" | "workspace:started" | "workspace:stopped" | "workspace:error" | "message:routed";
+export interface FleetEvent {
+    type: FleetEventType;
+    fleetId: string;
+    timestamp: number;
+    workspaceId?: string;
+    error?: string;
+    routeResult?: RouteResult;
+}
+export type FleetEventHandler = (event: FleetEvent) => void;
+export interface FleetCoordinatorDeps {
+    /** Identity assembler (from kernel). */
+    identityAssembler?: IdentityAssemblerLike;
+    /** Storage adapter for workspace persistence. */
+    storage?: WorkspaceStorageLike;
+    /** Memory engine for shared memory bridge. */
+    memoryEngine?: MemoryEngineLike;
+    /** Embedding function for semantic memory search. */
+    embed?: EmbedFn;
+    /** LLM provider for intent classification routing. */
+    classificationProvider?: ClassificationProviderLike;
+}
+export interface FleetBudgetTracker {
+    recordCost(amount: number, workspaceId?: string): void;
+    getDailySpent(): number;
+    getMonthlySpent(): number;
+    getWorkspaceDailySpent(workspaceId: string): number;
+    isOverBudget(config: BudgetConfig): boolean;
+    reset(): void;
+}
+export declare function createFleetBudgetTracker(): FleetBudgetTracker;
+export interface FleetCoordinator {
+    /** Start the fleet — create and start all configured workspaces. */
+    start(): Promise<void>;
+    /** Stop the fleet — drain and stop all running workspaces. */
+    stop(): Promise<void>;
+    /** Route an inbound message envelope to the appropriate workspace. */
+    route(envelope: RouteEnvelope): Promise<RouteResult>;
+    /** Get fleet status report with aggregated workspace statuses and costs. */
+    status(): FleetStatusReport;
+    /** Add and start a new workspace at runtime. */
+    addWorkspace(config: WorkspaceConfig): Promise<WorkspaceInstance>;
+    /** Stop and remove a workspace at runtime. */
+    removeWorkspace(workspaceId: string): Promise<void>;
+    /** Subscribe to fleet events. Returns unsubscribe function. */
+    on(handler: FleetEventHandler): () => void;
+    /** Access the underlying workspace manager. */
+    readonly workspaceManager: WorkspaceManager;
+    /** Access the shared memory bridge. */
+    readonly sharedMemory: SharedMemoryBridge | null;
+    /** Access the budget tracker. */
+    readonly budget: FleetBudgetTracker;
+    /** Current fleet status. */
+    readonly fleetStatus: FleetStatus;
+}
+export declare function createFleetCoordinator(customerId: string, config: FleetConfig, deps?: FleetCoordinatorDeps): FleetCoordinator;

package/dist/business/handoff.d.ts

@@ -0,0 +1,56 @@
+export interface HandoffSummary {
+    taskId: string;
+    /** Bulleted actions taken */
+    completedSteps: string[];
+    /** What the agent was doing when handed off */
+    currentState: string;
+    /** What it couldn't resolve */
+    openQuestions: string[];
+    /** File paths, git branch, PR URL */
+    artifacts: string[];
+    /** What a human should do next */
+    suggestedNextActions: string[];
+    /** 10:1 compressed working context */
+    compressedContext: string;
+}
+export interface HandoffRequest {
+    taskId: string;
+    workspaceId: string;
+    /** Trigger source */
+    trigger: "api" | "agent" | "approval-queue";
+    /** Last N tool calls to summarize */
+    recentToolCalls?: ToolCallEntry[];
+    /** Modified files from the background task */
+    modifiedFiles?: string[];
+    /** Git branch the background task was working on */
+    gitBranch?: string;
+}
+export interface ToolCallEntry {
+    tool: string;
+    input: string;
+    output: string;
+    timestamp: number;
+}
+export interface HandoffTarget {
+    /** New foreground session ID */
+    sessionId: string;
+    /** Workspace ID for the foreground session */
+    workspaceId: string;
+}
+export type CompressionLLMFn = (prompt: string) => Promise<string>;
+export type ArtifactStoreFn = (key: string, content: string) => Promise<void>;
+export type HandoffEventEmitter = (event: string, payload: Record<string, unknown>) => void;
+/**
+ * Generate a handoff summary from a background task's tool call history.
+ * Compresses the last 50 tool calls into a 10:1 summary.
+ */
+export declare function generateHandoffSummary(request: HandoffRequest, compress: CompressionLLMFn, emit?: HandoffEventEmitter): Promise<HandoffSummary>;
+/**
+ * Format the handoff summary for injection as the first message
+ * in a new interactive foreground session.
+ */
+export declare function formatHandoffMessage(summary: HandoffSummary): string;
+/**
+ * Store handoff summary as a brain artifact for later retrieval.
+ */
+export declare function persistHandoff(summary: HandoffSummary, storeArtifact: ArtifactStoreFn): Promise<void>;

package/dist/business/hat-system.d.ts

@@ -0,0 +1,57 @@
+export interface Hat {
+    id: string;
+    name: string;
+    description: string;
+    triggers: string[];
+    identityOverride: Partial<IdentityOverride>;
+    toolRestrictions: string[];
+    systemPromptAddendum: string;
+    preferredProviderSlot: string;
+}
+export interface IdentityOverride {
+    name: string;
+    tone: string;
+    role: string;
+    traits: string[];
+}
+export interface HatSelectionResult {
+    hat: Hat;
+    score: number;
+    matchedTriggers: string[];
+}
+export interface HatCollectionConfig {
+    customHatsDir?: string;
+    defaultHatId?: string;
+    selectionThreshold?: number;
+}
+export interface QueryClassification {
+    intent: string;
+    confidence: number;
+    entities?: string[];
+}
+export type HatEventEmitter = (event: string, payload: Record<string, unknown>) => void;
+export type YamlLoader = (path: string) => Promise<Hat | null>;
+export declare const BUILTIN_HATS: Hat[];
+export declare class HatSystem {
+    private hats;
+    private config;
+    private emit;
+    constructor(config?: HatCollectionConfig, opts?: {
+        emit?: HatEventEmitter;
+    });
+    /**
+     * Load custom hats from workspace directory and merge with built-ins.
+     */
+    loadCustomHats(loader: YamlLoader): Promise<number>;
+    /**
+     * Select the best hat for a given task based on classification.
+     */
+    select(taskText: string, classification?: QueryClassification): HatSelectionResult;
+    /** Get a specific hat by ID. */
+    getHat(id: string): Hat | undefined;
+    /** Register a hat at runtime. */
+    registerHat(hat: Hat): void;
+    /** List all available hats. */
+    listHats(): Hat[];
+    private scoreHat;
+}

package/dist/business/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Business module — Fleet orchestration for Fenix Pro edition.
+ * Re-exports all public types and functions from the business package.
+ */
+export { resolveEnvVar, loadFleetConfig, loadFleetConfigFromJSON, FleetConfigSchema, FleetRouterConfigSchema, BudgetConfigSchema, ApprovalConfigSchema, WorkspaceConfigSchema, ChannelBindingSchema, DEFAULT_FLEET_CONFIG, } from "./fleet-config.js";
+export type { FleetConfig, FleetRouterConfig, BudgetConfig, ApprovalConfig, WorkspaceConfig, ChannelBinding, LoadFleetConfigOptions, } from "./fleet-config.js";
+export { createWorkspaceManager, createInMemorySTM, } from "./workspace-manager.js";
+export type { WorkspaceStatus, WorkspaceInstance, WorkspaceManager, WorkspaceManagerConfig, WorkspaceManagerEvents, IdentityAssemblerLike, STMLike, WorkspaceStorageLike, } from "./workspace-manager.js";
+export { createSharedMemoryBridge, } from "./shared-memory.js";
+export type { SharedMemoryFact, SharedMemorySearchResult, SharedMemoryBridge, SharedMemoryBridgeConfig, MemoryEngineLike, EmbedFn, } from "./shared-memory.js";
+export { createFleetRouter, extractMention, matchChannelBinding, } from "./router.js";
+export type { FleetRouter, RouteEnvelope, RouteResult, ClassificationProviderLike, WorkspaceSummary, MentionResult, } from "./router.js";
+export { createFleetCoordinator, createFleetBudgetTracker, } from "./fleet.js";
+export type { FleetCoordinator, FleetCoordinatorDeps, FleetStatus, FleetStatusReport, FleetEvent, FleetEventType, FleetEventHandler, FleetBudgetTracker, } from "./fleet.js";
+export { BUILTIN_TEMPLATES, listTemplates, getTemplate, applyTemplate, } from "./templates.js";
+export type { WorkspaceTemplate, TemplateCustomizations, } from "./templates.js";
+export { ApprovalQueue, checkAutoApproval, } from "./approval-queue.js";
+export type { ApprovalItem, ApprovalStatus, ApprovalListFilters, StorageAdapter, ToolExecutor, NotificationDispatcher, ApprovalQueueConfig, } from "./approval-queue.js";
+export { IntegrationRegistry, KNOWN_INTEGRATIONS, createInMemoryIntegrationStorage, } from "./integration-registry.js";
+export type { IntegrationProtocol, AuthMethod, IntegrationDefinition, IntegrationConnectionStatus, IntegrationConnection, WorkspaceIntegrationGrant, IntegrationStorageLike, SecretStoreLike, } from "./integration-registry.js";
+export { FleetBudget, } from "./fleet-budget.js";
+export type { FleetBudgetConfig, CostEntry, CostTrackerLike, BudgetExceededType, BudgetExceededInfo, BudgetExceededHandler, WorkspaceCostBreakdown, } from "./fleet-budget.js";
+export { runPlannerCycle, assignTaskToWorker, executeWorkerTask, claimNextTask, createEscalation, evaluateCycle, shouldContinue, DEFAULT_JUDGE_CONFIG, } from "./roles/index.js";
+export type { AgentRole, RoleConfig, RoleTask, EscalationRequest, CycleEvaluation, RoleEventEmitter, PlannerContext, PlannerDecision, LLMPlanFn, WorkerContext, TaskExecutorFn, WorkerResult, JudgeContext, JudgeConfig, LLMJudgeFn, } from "./roles/index.js";
+export { OracleHandler, OracleBudgetExceededError, DEFAULT_ORACLE_CONFIG } from "./oracle.js";
+export type { OracleConfig, OracleConsultation, OracleResponse, OracleLLMCallFn, CostRecorderFn, OracleEventEmitter, } from "./oracle.js";
+export { BestOfNEngine, BudgetExceededError as BestOfNBudgetError, DEFAULT_BEST_OF_N } from "./best-of-n.js";
+export type { BestOfNConfig, CandidateResult, JudgeScore, BestOfNResult, SubTask, CandidateExecutorFn, JudgeFn as BestOfNJudgeFn, InvestigatorFn, BudgetCheckFn, BestOfNEventEmitter, } from "./best-of-n.js";
+export { runDebate, DEFAULT_DEBATE_CONFIG } from "./debate.js";
+export type { DebateConfig, DebateRound, DebateResult, DebateLLMCallFn, DebateEventEmitter, } from "./debate.js";
+export { runBrainstorm, DEFAULT_BRAINSTORM_CONFIG } from "./brainstorm.js";
+export type { BrainstormConfig, BrainstormIdea, ThemeCluster, BrainstormResult, ScoredIdea, BrainstormLLMCallFn, BrainstormEventEmitter, } from "./brainstorm.js";
+export { runCompileCheck, formatErrorSummary, parseCompileErrors, DEFAULT_COMPILE_TIMEOUT, } from "./compile-checker.js";
+export type { CompileCheckJob, CompileError, CompileCheckResult, PackageCompileResult, CompileEventEmitter, ArtifactStoreFn as CompileArtifactStoreFn, } from "./compile-checker.js";
+export { generateHandoffSummary, formatHandoffMessage, persistHandoff, } from "./handoff.js";
+export type { HandoffSummary, HandoffRequest, ToolCallEntry, HandoffTarget, CompressionLLMFn, HandoffEventEmitter, } from "./handoff.js";
+export { ArenaEngine, formatArenaForApproval, DEFAULT_ARENA_CONFIG } from "./arena.js";
+export type { ArenaConfig, ArenaContestant, ArenaScore, ArenaDiff, ArenaResult, ContestantExecutorFn, ArenaJudgeFn, DiffGeneratorFn, ArenaEventEmitter, } from "./arena.js";
+export { executePipeline, validateDAG, getExecutionOrder, } from "./node-pipeline.js";
+export type { PipelineNode, NodeInput, NodeResult, Transformer, NodeStatus, PipelineConfig, NodeExecutor, PipelineExecution, PipelineEventType, PipelineEvent, PipelineEventHandler, } from "./node-pipeline.js";
+export { SwarmRegistry, CircularSwarmDependencyError, } from "./swarm-registry.js";
+export type { SwarmRegistration, SwarmRegistryEntry, SwarmFileConfig, SwarmRegistryEventType, SwarmRegistryEvent, SwarmRegistryEventHandler, } from "./swarm-registry.js";
+export { StatusDetector } from "./status-detector.js";
+export type { AgentExecutionStatus, StatusSignal, AgentStatusRecord, StatusEventType, StatusChangeEvent, StatusChangeHandler, StatusDetectorConfig, } from "./status-detector.js";

package/dist/business/integration-registry.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Integration Registry — Task B2.3
+ *
+ * Manages external service integrations (MCP servers, APIs) for fleets.
+ * Stores credentials via the kernel's SecretStore and tracks which
+ * workspaces have access to which integrations.
+ */
+export type IntegrationProtocol = "MCP" | "builtin";
+export type AuthMethod = "oauth2" | "api_key";
+export interface IntegrationDefinition {
+    id: string;
+    name: string;
+    protocol: IntegrationProtocol;
+    authMethod: AuthMethod;
+    capabilities: string[];
+}
+export type IntegrationConnectionStatus = "connected" | "disconnected" | "error";
+export interface IntegrationConnection {
+    fleetId: string;
+    integrationId: string;
+    status: IntegrationConnectionStatus;
+    connectedAt: Date | null;
+    error?: string;
+}
+export interface WorkspaceIntegrationGrant {
+    workspaceId: string;
+    integrationId: string;
+    grantedAt: Date;
+}
+export interface IntegrationStorageLike {
+    getConnection(fleetId: string, integrationId: string): IntegrationConnection | undefined;
+    saveConnection(connection: IntegrationConnection): void;
+    deleteConnection(fleetId: string, integrationId: string): boolean;
+    listConnections(fleetId: string): IntegrationConnection[];
+    getWorkspaceGrant(workspaceId: string, integrationId: string): WorkspaceIntegrationGrant | undefined;
+    saveWorkspaceGrant(grant: WorkspaceIntegrationGrant): void;
+    deleteWorkspaceGrant(workspaceId: string, integrationId: string): boolean;
+    listWorkspaceGrants(workspaceId: string): WorkspaceIntegrationGrant[];
+}
+export interface SecretStoreLike {
+    store(userId: string, provider: string, key: string): Promise<void>;
+    retrieve(userId: string, provider: string): Promise<string | null>;
+    delete(userId: string, provider: string): boolean;
+    has(userId: string, provider: string): boolean;
+}
+export declare const KNOWN_INTEGRATIONS: readonly IntegrationDefinition[];
+export declare function createInMemoryIntegrationStorage(): IntegrationStorageLike;
+export declare class IntegrationRegistry {
+    private readonly storage;
+    private readonly secretStore;
+    constructor(storage: IntegrationStorageLike, secretStore: SecretStoreLike);
+    /** Returns all known/supported integrations. */
+    listAvailable(): readonly IntegrationDefinition[];
+    /** Connect a fleet to an integration, storing credentials securely. */
+    connect(fleetId: string, integrationId: string, credentials: string): Promise<IntegrationConnection>;
+    /** Disconnect a fleet from an integration, removing stored credentials. */
+    disconnect(fleetId: string, integrationId: string): void;
+    /** Get the current connection status for a fleet + integration pair. */
+    getStatus(fleetId: string, integrationId: string): IntegrationConnection;
+    /** Grant a workspace access to an integration. */
+    grantAccess(workspaceId: string, integrationId: string): void;
+    /** Revoke a workspace's access to an integration. */
+    revokeAccess(workspaceId: string, integrationId: string): void;
+    /** Get all integrations accessible to a workspace. */
+    getWorkspaceIntegrations(workspaceId: string): WorkspaceIntegrationGrant[];
+}

package/dist/business/node-pipeline.d.ts

@@ -0,0 +1,62 @@
+import type { FinishReason } from "@fenixforce/kernel";
+export interface NodeInput {
+    prompt: string;
+    context?: Record<string, unknown>;
+    previous: Record<string, NodeResult>;
+}
+export interface NodeResult {
+    nodeId: string;
+    output: string;
+    metadata: Record<string, unknown>;
+    finishReason: FinishReason;
+    durationMs: number;
+}
+export type Transformer = (input: NodeInput) => NodeInput | Promise<NodeInput>;
+export interface PipelineNode {
+    id: string;
+    /** Which agent (or worker hat) handles this stage. */
+    agent?: string;
+    /** Upstream node IDs (DAG edges). */
+    dependsOn: string[];
+    /** Reshape upstream output before injection. */
+    inputTransformer?: Transformer;
+    /** Reshape this node's output before passing downstream. */
+    outputTransformer?: Transformer;
+    /** Skip node if condition met. */
+    skipCondition?: (input: NodeInput) => boolean;
+}
+export type NodeStatus = "pending" | "running" | "completed" | "skipped" | "failed";
+export interface PipelineConfig {
+    id: string;
+    nodes: PipelineNode[];
+    /** Max concurrent nodes. Default 3. */
+    concurrentNodes?: number;
+}
+export type NodeExecutor = (nodeId: string, agent: string | undefined, input: NodeInput) => Promise<{
+    output: string;
+    metadata?: Record<string, unknown>;
+    finishReason?: FinishReason;
+}>;
+export interface PipelineExecution {
+    pipelineId: string;
+    status: "running" | "completed" | "failed";
+    results: Record<string, NodeResult>;
+    nodeStatuses: Record<string, NodeStatus>;
+    startedAt: number;
+    completedAt?: number;
+    error?: string;
+}
+export type PipelineEventType = "pipeline:start" | "pipeline:complete" | "pipeline:error" | "node:start" | "node:complete" | "node:skip" | "node:error";
+export interface PipelineEvent {
+    type: PipelineEventType;
+    pipelineId: string;
+    nodeId?: string;
+    timestamp: number;
+    detail?: string;
+}
+export type PipelineEventHandler = (event: PipelineEvent) => void;
+export declare function executePipeline(config: PipelineConfig, executor: NodeExecutor, eventHandler?: PipelineEventHandler): Promise<PipelineExecution>;
+/** Validate DAG has no cycles (throws if cycle found). */
+export declare function validateDAG(nodes: PipelineNode[]): void;
+/** Get execution order as flat array of node IDs. */
+export declare function getExecutionOrder(nodes: PipelineNode[]): string[];

package/dist/business/oracle.d.ts

@@ -0,0 +1,64 @@
+export interface OracleConfig {
+    /** Named slot in provider config — maps to high-capability model */
+    slot: "oracle";
+    /** Cap on context tokens sent to oracle */
+    maxTokensIn: number;
+    /** Cap on oracle response tokens */
+    maxTokensOut: number;
+    /** Max oracle calls per session */
+    invocationBudget: number;
+}
+export declare const DEFAULT_ORACLE_CONFIG: OracleConfig;
+export interface OracleConsultation {
+    /** Text description of the stuck problem */
+    problem: string;
+    /** Relevant context excerpt (capped at maxTokensIn) */
+    contextExcerpt: string;
+    /** Specific question for the oracle */
+    question: string;
+    /** Worker workspace ID */
+    workerId: string;
+    /** Session ID for budget tracking */
+    sessionId: string;
+}
+export interface OracleResponse {
+    guidance: string;
+    tokensCost: number;
+    consultationId: string;
+}
+export type OracleLLMCallFn = (prompt: string, maxTokens: number) => Promise<{
+    text: string;
+    tokensUsed: number;
+}>;
+export type CostRecorderFn = (amount: number, category: string, sessionId: string) => void;
+export type OracleEventEmitter = (event: string, payload: Record<string, unknown>) => void;
+export declare class OracleHandler {
+    private config;
+    private llmCall;
+    private recordCost;
+    private emit;
+    private sessionInvocations;
+    constructor(config: Partial<OracleConfig> | undefined, llmCall: OracleLLMCallFn, opts?: {
+        recordCost?: CostRecorderFn;
+        emit?: OracleEventEmitter;
+    });
+    /**
+     * Consult the oracle with a focused problem excerpt.
+     * Returns strategic guidance injected as "## Oracle Guidance".
+     */
+    consult(req: OracleConsultation): Promise<OracleResponse>;
+    /**
+     * Format oracle response for injection into worker's next turn.
+     */
+    formatGuidanceBlock(response: OracleResponse): string;
+    /** Get remaining oracle budget for a session. */
+    getRemainingBudget(sessionId: string): number;
+    /** Reset session invocation counter. */
+    resetSession(sessionId: string): void;
+}
+export declare class OracleBudgetExceededError extends Error {
+    sessionId: string;
+    used: number;
+    budget: number;
+    constructor(sessionId: string, used: number, budget: number);
+}

package/dist/business/roles/index.d.ts

@@ -0,0 +1,7 @@
+export type { AgentRole, RoleConfig, RoleTask, EscalationRequest, CycleEvaluation, RoleEventEmitter, } from "./types.js";
+export { runPlannerCycle, assignTaskToWorker } from "./planner.js";
+export type { PlannerContext, PlannerDecision, LLMPlanFn } from "./planner.js";
+export { executeWorkerTask, claimNextTask, createEscalation } from "./worker.js";
+export type { WorkerContext, TaskExecutorFn, WorkerResult } from "./worker.js";
+export { evaluateCycle, shouldContinue, DEFAULT_JUDGE_CONFIG } from "./judge.js";
+export type { JudgeContext, JudgeConfig, LLMJudgeFn } from "./judge.js";

package/dist/business/roles/judge.d.ts

@@ -0,0 +1,24 @@
+import type { RoleConfig, RoleTask, CycleEvaluation, RoleEventEmitter } from "./types.js";
+export interface JudgeContext {
+    workspaceId: string;
+    roleConfig: RoleConfig;
+    tasks: RoleTask[];
+}
+export interface JudgeConfig {
+    /** Minimum goal achievement rate to consider cycle complete (0-1) */
+    completionThreshold: number;
+    /** Maximum acceptable worker error rate (0-1) */
+    maxErrorRate: number;
+    /** Whether to route cycle:escalate through approval queue */
+    requireHumanApproval: boolean;
+}
+export declare const DEFAULT_JUDGE_CONFIG: JudgeConfig;
+export type LLMJudgeFn = (prompt: string) => Promise<string>;
+/**
+ * Evaluate a planning cycle and return a verdict.
+ */
+export declare function evaluateCycle(ctx: JudgeContext, config?: JudgeConfig, llmJudge?: LLMJudgeFn, emit?: RoleEventEmitter): Promise<CycleEvaluation>;
+/**
+ * Quick check: should the cycle continue based on task states?
+ */
+export declare function shouldContinue(tasks: RoleTask[]): boolean;

package/dist/business/roles/planner.d.ts

@@ -0,0 +1,30 @@
+import type { RoleConfig, RoleTask, RoleEventEmitter } from "./types.js";
+export interface PlannerContext {
+    workspaceId: string;
+    roleConfig: RoleConfig;
+    /** Available worker workspace IDs */
+    workerIds: string[];
+    /** Current task backlog */
+    taskQueue: RoleTask[];
+}
+export interface PlannerDecision {
+    newTasks: Array<{
+        title: string;
+        description: string;
+        scope: string;
+        assignToWorkerId?: string;
+    }>;
+    spawnSubPlanner?: {
+        domain: string;
+        scope: string;
+    };
+}
+export type LLMPlanFn = (prompt: string) => Promise<string>;
+/**
+ * Run a single planner cycle: analyze workspace context and produce tasks.
+ */
+export declare function runPlannerCycle(ctx: PlannerContext, llmPlan: LLMPlanFn, emit?: RoleEventEmitter): Promise<RoleTask[]>;
+/**
+ * Assign a pending task to a specific worker.
+ */
+export declare function assignTaskToWorker(task: RoleTask, workerId: string, emit?: RoleEventEmitter): RoleTask;

package/dist/business/roles/types.d.ts

@@ -0,0 +1,37 @@
+export type AgentRole = "planner" | "worker" | "judge";
+export interface RoleConfig {
+    role: AgentRole;
+    /** For sub-planners — parent planner's workspace ID */
+    parentPlannerWorkspaceId?: string;
+    /** For workers — restricts to a single task focus */
+    taskScope?: string;
+    /** For judges — evaluation criteria strings */
+    evaluationCriteria?: string[];
+}
+export interface RoleTask {
+    id: string;
+    workspaceId: string;
+    title: string;
+    description: string;
+    scope: string;
+    status: "pending" | "assigned" | "running" | "completed" | "failed" | "escalated";
+    assignedWorkerIds: string[];
+    result?: unknown;
+    error?: string;
+    createdAt: Date;
+    completedAt?: Date;
+}
+export interface EscalationRequest {
+    taskId: string;
+    workerId: string;
+    reason: string;
+    context: string;
+}
+export interface CycleEvaluation {
+    verdict: "cycle:continue" | "cycle:complete" | "cycle:escalate";
+    goalAchievementRate: number;
+    openTaskCount: number;
+    workerErrorRate: number;
+    notes: string;
+}
+export type RoleEventEmitter = (event: string, payload: Record<string, unknown>) => void;