@fenixforce/edition-pro 0.1.0

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

@@ -0,0 +1,25 @@
+import type { RoleTask, EscalationRequest, RoleEventEmitter } from "./types.js";
+export interface WorkerContext {
+    workspaceId: string;
+    taskScope?: string;
+    loopWarningCount: number;
+}
+export type TaskExecutorFn = (task: RoleTask) => Promise<unknown>;
+export interface WorkerResult {
+    task: RoleTask;
+    output: unknown;
+    escalated: boolean;
+}
+/**
+ * Execute a single task as a worker. Returns result or escalation.
+ */
+export declare function executeWorkerTask(ctx: WorkerContext, task: RoleTask, executor: TaskExecutorFn, emit?: RoleEventEmitter): Promise<WorkerResult>;
+/**
+ * Claim the next eligible task from a task queue.
+ * Filters by worker's task scope if configured.
+ */
+export declare function claimNextTask(tasks: RoleTask[], ctx: WorkerContext): RoleTask | null;
+/**
+ * Create an escalation request for the planner.
+ */
+export declare function createEscalation(task: RoleTask, workerId: string, reason: string): EscalationRequest;

package/dist/business/router.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Fleet Router — Task B1.2
+ *
+ * Three-strategy message routing: explicit mention, channel binding,
+ * intent classification via LLM. Executes strategies in priority order
+ * and falls back to the configured default workspace.
+ */
+import type { FleetRouterConfig, ChannelBinding } from "./fleet-config.js";
+/** Inbound message envelope to be routed. */
+export interface RouteEnvelope {
+    /** Raw message text. */
+    text: string;
+    /** Channel the message arrived on (e.g. "telegram", "discord"). */
+    channel: string;
+    /** Sender user ID. */
+    userId: string;
+    /** Optional metadata. */
+    metadata?: Record<string, unknown>;
+}
+/** Result of routing a message to a workspace. */
+export interface RouteResult {
+    /** Workspace ID to handle this message. */
+    workspaceId: string;
+    /** Which strategy matched. */
+    strategy: "mention" | "channel_binding" | "intent_classification" | "fallback";
+    /** Confidence (1.0 for deterministic strategies, 0.0–1.0 for classification). */
+    confidence: number;
+    /** Message text after stripping any mention prefix. */
+    cleanedText: string;
+    /** Optional reasoning from LLM classification. */
+    reasoning?: string;
+}
+/** Minimal LLM provider interface for intent classification. */
+export interface ClassificationProviderLike {
+    complete(params: {
+        messages: Array<{
+            role: string;
+            content: string;
+        }>;
+        temperature?: number;
+    }): Promise<{
+        content: string;
+    }>;
+}
+/** Workspace summary used for intent classification prompt. */
+export interface WorkspaceSummary {
+    id: string;
+    name: string;
+    description: string;
+    tools: string[];
+}
+export interface MentionResult {
+    workspaceName: string;
+    remainingText: string;
+}
+/**
+ * Extract a mention from the start of a message.
+ * Example: "@support how do I reset?" → { workspaceName: "support", remainingText: "how do I reset?" }
+ */
+export declare function extractMention(text: string, prefix: string): MentionResult | null;
+/**
+ * Find the workspace bound to a specific channel.
+ */
+export declare function matchChannelBinding(channel: string, bindings: ChannelBinding[]): string | null;
+export interface FleetRouter {
+    /** Route an envelope to the appropriate workspace. */
+    route(envelope: RouteEnvelope, workspaces: WorkspaceSummary[], channelBindings: ChannelBinding[]): Promise<RouteResult>;
+    /** Classify intent via LLM (exposed for testing). */
+    classifyIntent(text: string, workspaces: WorkspaceSummary[]): Promise<{
+        workspace: string;
+        confidence: number;
+        reasoning: string;
+    } | null>;
+}
+export declare function createFleetRouter(config: FleetRouterConfig, provider?: ClassificationProviderLike): FleetRouter;

package/dist/business/shared-memory.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Shared Memory Bridge — Task B0.3
+ *
+ * Wraps the kernel MemoryEngine to provide fleet-wide MTM/LPM sharing
+ * with per-workspace STM isolation and source tagging.
+ *
+ * The bridge does NOT touch STM. Each workspace's STM is created and
+ * owned by the workspace manager. The bridge only mediates shared
+ * access to MTM (medium-term memory) and LPM (long-term/persistent memory).
+ */
+/** A memory fact with source workspace tagging. */
+export interface SharedMemoryFact {
+    id: string;
+    userId: string;
+    content: string;
+    category: "fact" | "preference" | "experience" | "knowledge";
+    sourceWorkspace: string;
+    confidence: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/** Search result from shared memory. */
+export interface SharedMemorySearchResult {
+    fact: SharedMemoryFact;
+    score: number;
+}
+/** Minimal memory engine interface — mirrors kernel MemoryEngine/StorageAdapter. */
+export interface MemoryEngineLike {
+    /** Save a memory segment. Returns the saved segment with its ID. */
+    saveMemorySegment(segment: {
+        userId: string;
+        content: string;
+        category: string;
+        embedding: number[] | null;
+        heat: number;
+    }): Promise<{
+        id: string;
+        userId: string;
+        content: string;
+        category: string;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    /** Search memory by embedding vector similarity. */
+    searchMemoryByEmbedding(userId: string, embedding: number[], limit?: number): Promise<Array<{
+        segment: {
+            id: string;
+            userId: string;
+            content: string;
+            category: string;
+            createdAt: Date;
+            updatedAt: Date;
+        };
+        score: number;
+    }>>;
+}
+/** Optional embedding provider for vector searches. */
+export interface EmbedFn {
+    (text: string): Promise<number[]>;
+}
+export interface SharedMemoryBridgeConfig {
+    /** Fleet ID this bridge serves. */
+    fleetId: string;
+    /** Kernel memory engine for shared storage. */
+    memoryEngine: MemoryEngineLike;
+    /** Optional embedding function for semantic search. */
+    embed?: EmbedFn;
+}
+export interface SharedMemoryBridge {
+    /** Save a fact to shared memory with source workspace tagging. */
+    saveFact(userId: string, fact: {
+        content: string;
+        category: SharedMemoryFact["category"];
+        confidence?: number;
+    }, sourceWorkspace: string): Promise<SharedMemoryFact>;
+    /** Recall facts from shared memory pool, optionally filtered by source workspace. */
+    recallFacts(userId: string, query: string, limit?: number, fromWorkspace?: string): Promise<SharedMemorySearchResult[]>;
+    /** Get relevant context from shared pool for identity assembly injection. */
+    getRelevantContext(userId: string, workspaceId: string, limit?: number): Promise<SharedMemoryFact[]>;
+    /** The fleet ID this bridge serves. */
+    readonly fleetId: string;
+    /** Number of facts stored (across all workspaces). */
+    readonly factCount: number;
+}
+export declare function createSharedMemoryBridge(config: SharedMemoryBridgeConfig): SharedMemoryBridge;

package/dist/business/status-detector.d.ts

@@ -0,0 +1,52 @@
+export type AgentExecutionStatus = "idle" | "processing" | "awaiting-approval" | "awaiting-hil" | "error" | "unknown";
+export interface StatusSignal {
+    type: string;
+    timestamp: number;
+    agentInstanceId: string;
+    data?: Record<string, unknown>;
+}
+export interface AgentStatusRecord {
+    agentInstanceId: string;
+    status: AgentExecutionStatus;
+    lastSignalAt: number;
+    detail?: string;
+}
+export type StatusEventType = "worker:status:changed";
+export interface StatusChangeEvent {
+    type: StatusEventType;
+    agentInstanceId: string;
+    previousStatus: AgentExecutionStatus;
+    newStatus: AgentExecutionStatus;
+    timestamp: number;
+}
+export type StatusChangeHandler = (event: StatusChangeEvent) => void;
+export interface StatusDetectorConfig {
+    /** Seconds of no signal before "unknown". Default 30. */
+    unknownThresholdMs?: number;
+    /** Seconds of activity signals considered "recent". Default 5000. */
+    recentWindowMs?: number;
+}
+export declare class StatusDetector {
+    private statuses;
+    private pendingApprovals;
+    private pendingHIL;
+    private handlers;
+    private config;
+    constructor(config?: StatusDetectorConfig);
+    /** Ingest a signal from the event stream. */
+    ingest(signal: StatusSignal): void;
+    /** Get the current status of an agent instance. */
+    getStatus(agentInstanceId: string): AgentExecutionStatus;
+    /** Get full status record for an agent. */
+    getRecord(agentInstanceId: string): AgentStatusRecord | undefined;
+    /** List all tracked agents with their statuses. */
+    listAll(): AgentStatusRecord[];
+    /** Get agents available for new task assignment. */
+    getAvailable(): string[];
+    /** Subscribe to status change events. */
+    on(handler: StatusChangeHandler): () => void;
+    /** Clear all state. */
+    clear(): void;
+    private classify;
+    private emit;
+}

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

@@ -0,0 +1,63 @@
+import type { FleetCoordinator, FleetCoordinatorDeps } from "./fleet.js";
+import type { FleetConfig } from "./fleet-config.js";
+import type { RouteEnvelope, RouteResult } from "./router.js";
+export interface SwarmRegistration {
+    /** The child FleetCoordinator instance. */
+    coordinator: FleetCoordinator;
+    /** Human-readable description for routing. */
+    description: string;
+    /** Whether to maintain context across delegations. Default false. */
+    keepContext?: boolean;
+}
+export interface SwarmRegistryEntry extends SwarmRegistration {
+    id: string;
+    /** Swarm hierarchy path for nested event tracking. */
+    hierarchy: string[];
+    started: boolean;
+}
+export interface SwarmFileConfig {
+    fleetConfig: FleetConfig;
+    deps?: FleetCoordinatorDeps;
+    description: string;
+    keepContext?: boolean;
+}
+export declare class CircularSwarmDependencyError extends Error {
+    readonly cycle: string[];
+    constructor(cycle: string[]);
+}
+export type SwarmRegistryEventType = "swarm:registered" | "swarm:unregistered" | "swarm:delegation:start" | "swarm:delegation:complete" | "swarm:delegation:error";
+export interface SwarmRegistryEvent {
+    type: SwarmRegistryEventType;
+    swarmId: string;
+    hierarchy: string[];
+    timestamp: number;
+    detail?: string;
+}
+export type SwarmRegistryEventHandler = (event: SwarmRegistryEvent) => void;
+export declare class SwarmRegistry {
+    private entries;
+    private handlers;
+    private parentId;
+    constructor(parentSwarmId: string);
+    /** Register a sub-swarm by ID. */
+    register(id: string, registration: SwarmRegistration): void;
+    /** Unregister and stop a sub-swarm. */
+    unregister(id: string): Promise<void>;
+    /** Check if a swarm is registered. */
+    has(id: string): boolean;
+    /** Get a registered swarm entry. */
+    get(id: string): SwarmRegistryEntry | undefined;
+    /** List all registered swarm IDs. */
+    list(): string[];
+    /**
+     * Delegate a task to a registered sub-swarm.
+     * Starts the coordinator if not already running.
+     */
+    delegate(id: string, envelope: RouteEnvelope): Promise<RouteResult>;
+    /** Subscribe to registry events. Returns unsubscribe function. */
+    on(handler: SwarmRegistryEventHandler): () => void;
+    /** Stop all registered sub-swarms. */
+    stopAll(): Promise<void>;
+    private detectCycles;
+    private emit;
+}

package/dist/business/templates.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Workspace Templates — Task B2.1
+ *
+ * Provides 8 built-in workspace templates with well-crafted identity
+ * personas, domain knowledge, and tool scoping. Templates can be
+ * customized and applied to workspace directories.
+ */
+export interface WorkspaceTemplate {
+    /** Unique template identifier. */
+    id: string;
+    /** Human-readable display name. */
+    name: string;
+    /** Short description of the template. */
+    description: string;
+    /** Persona markdown content (identity text, 15–25 lines). */
+    persona: string;
+    /** Knowledge markdown content (domain expertise, 20–40 lines). */
+    knowledge: string;
+    /** Tools this template has access to. */
+    tools: string[];
+    /** Default channels. */
+    channels: string[];
+    /** Default domain layers. */
+    layers: string[];
+}
+export interface TemplateCustomizations {
+    /** Override or append to persona text. */
+    personaAppend?: string;
+    /** Override or append to knowledge text. */
+    knowledgeAppend?: string;
+    /** Override tools list entirely. */
+    tools?: string[];
+    /** Override channels list entirely. */
+    channels?: string[];
+    /** Override layers list entirely. */
+    layers?: string[];
+    /** Additional metadata. */
+    metadata?: Record<string, unknown>;
+}
+export declare const BUILTIN_TEMPLATES: WorkspaceTemplate[];
+/** List all built-in templates. */
+export declare function listTemplates(): WorkspaceTemplate[];
+/** Get a single template by ID. Returns undefined if not found. */
+export declare function getTemplate(id: string): WorkspaceTemplate | undefined;
+/**
+ * Apply a template to a workspace directory, optionally merging customizations.
+ * Writes persona.md and knowledge.md to the target directory.
+ */
+export declare function applyTemplate(template: WorkspaceTemplate, targetDir: string, customizations?: TemplateCustomizations): {
+    personaPath: string;
+    knowledgePath: string;
+    tools: string[];
+    channels: string[];
+    layers: string[];
+};

package/dist/business/workspace-manager.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Workspace Manager — Task B0.2
+ *
+ * Manages creation, startup, shutdown, and deletion of individual
+ * workspace instances within a fleet. Each workspace gets its own
+ * agent loop configuration, identity assembly, and STM.
+ */
+import type { WorkspaceConfig } from "./fleet-config.js";
+export type WorkspaceStatus = "created" | "starting" | "running" | "stopping" | "stopped" | "error";
+export interface WorkspaceInstance {
+    id: string;
+    fleetId: string;
+    name: string;
+    config: WorkspaceConfig;
+    status: WorkspaceStatus;
+    identityDir: string;
+    createdAt: Date;
+    startedAt: Date | null;
+    stoppedAt: Date | null;
+}
+/** Minimal identity assembler interface — mirrors kernel IdentityAssembler. */
+export interface IdentityAssemblerLike {
+    assemble(workspaceId: string, options?: {
+        channel?: string;
+    }): Promise<{
+        name: string;
+        content: string;
+        tokenEstimate: number;
+    }>;
+}
+/** Minimal STM (short-term memory) interface for workspace-scoped memory. */
+export interface STMLike {
+    /** Add a message to short-term memory. */
+    add(entry: {
+        role: string;
+        content: string;
+        timestamp: number;
+    }): void;
+    /** Get recent entries. */
+    recent(limit?: number): Array<{
+        role: string;
+        content: string;
+        timestamp: number;
+    }>;
+    /** Flush STM contents (e.g. for MTM promotion). */
+    flush(): Array<{
+        role: string;
+        content: string;
+        timestamp: number;
+    }>;
+    /** Current entry count. */
+    readonly size: number;
+}
+/** Minimal storage adapter interface for workspace registration. */
+export interface WorkspaceStorageLike {
+    saveIdentityFile(file: {
+        workspaceId: string;
+        fileName: string;
+        content: string;
+        metadata: Record<string, unknown>;
+    }): Promise<{
+        id: string;
+    }>;
+}
+export interface WorkspaceManagerConfig {
+    /** Function to create a workspace-scoped STM instance. */
+    createSTM: () => STMLike;
+    /** Identity assembler instance (from kernel). */
+    identityAssembler?: IdentityAssemblerLike;
+    /** Storage adapter for workspace persistence. */
+    storage?: WorkspaceStorageLike;
+    /** Timeout in ms for draining in-flight messages on stop (default: 10000). */
+    drainTimeoutMs?: number;
+}
+export interface WorkspaceManagerEvents {
+    onCreated?: (workspace: WorkspaceInstance) => void;
+    onStarted?: (workspace: WorkspaceInstance) => void;
+    onStopped?: (workspace: WorkspaceInstance) => void;
+    onDeleted?: (workspaceId: string) => void;
+    onError?: (workspaceId: string, error: Error) => void;
+}
+export declare function createInMemorySTM(maxEntries?: number): STMLike;
+export interface WorkspaceManager {
+    /** Create a new workspace and register it in the fleet. */
+    createWorkspace(fleetId: string, name: string, config: WorkspaceConfig, identityDir?: string): Promise<WorkspaceInstance>;
+    /** Start a workspace — load identity, create STM, set running. */
+    startWorkspace(workspaceId: string): Promise<WorkspaceInstance>;
+    /** Stop a workspace — drain STM, set stopped. */
+    stopWorkspace(workspaceId: string): Promise<WorkspaceInstance>;
+    /** Delete a workspace — stops if running, removes from registry. */
+    deleteWorkspace(workspaceId: string): Promise<void>;
+    /** Get a workspace by ID. */
+    getWorkspace(workspaceId: string): WorkspaceInstance | undefined;
+    /** List all workspaces for a fleet. */
+    listWorkspaces(fleetId: string): WorkspaceInstance[];
+    /** Get the STM for a workspace (only available while running). */
+    getSTM(workspaceId: string): STMLike | undefined;
+    /** Get the assembled identity for a workspace. */
+    getIdentity(workspaceId: string): Promise<{
+        name: string;
+        content: string;
+        tokenEstimate: number;
+    } | null>;
+}
+export declare function createWorkspaceManager(managerConfig: WorkspaceManagerConfig, events?: WorkspaceManagerEvents): WorkspaceManager;

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Fenix Pro Edition — Full-featured agent with all channels, tools,
+ * and domain layers. Intended for power users and server deployments.
+ */
+import { createKernel, KERNEL_VERSION, type KernelConfig, type Kernel, type EditionManifest } from "@fenixforce/kernel";
+export declare const EDITION: "pro";
+export declare const PRO_MANIFEST: EditionManifest;
+export declare const PRO_KERNEL_CONFIG: KernelConfig;
+export declare function startPro(overrides?: Partial<KernelConfig>): Kernel;
+export { createKernel, KERNEL_VERSION };
+export * from "./business/index.js";
+export { bootPro } from "./boot.js";
+export type { ProInstance, ProBootMode, HealthStatus, ProBootOptions } from "./boot.js";
+export { createFleetRoutes } from "./api/fleet-routes.js";
+export type { FleetRouteDeps } from "./api/fleet-routes.js";
+export { createIntegrationRoutes } from "./api/integration-routes.js";
+export type { IntegrationRouteDeps } from "./api/integration-routes.js";
+export { createApprovalRoutes } from "./api/approval-routes.js";
+export type { ApprovalRouteDeps } from "./api/approval-routes.js";
+export { buildRoute, matchRoute, jsonResponse, errorResponse, validateAuth, parseJsonBody, validateRequired, ApiException, withErrorHandling, corsPreflightResponse, CORS_HEADERS, } from "./api/middleware.js";
+export type { Route, RouteHandler } from "./api/middleware.js";