maskweaver 0.9.4 → 0.9.6

package/dist/shared/model-registry.js

@@ -1,62 +1,25 @@
-/**
- * Model Registry
- *
- * Manages the pool of available AI models with:
- * - Concurrency tracking (max N simultaneous uses per model)
- * - Capability-based matching (task → best model)
- * - Tier-based fallback (if preferred model is full, find similar)
- * - Cost-aware scheduling (prefer cheaper models for simple tasks)
- *
- * "The art of programming is the art of organizing complexity." - Dijkstra
- *
- * @author Mask Weaver
- */
 import { loadRuntimeConfig, normalizeDummyHumansConfig } from './config.js';
-// ============================================================================
-// Cost tier ordering
-// ============================================================================
 const COST_ORDER = {
     low: 1,
     medium: 2,
     high: 3,
 };
-// ============================================================================
-// Tier fallback chain - when preferred tier is full
-// ============================================================================
 const TIER_FALLBACK = {
-    flash: ['human', 'premium'], // Flash full → try human → premium
-    human: ['premium', 'flash'], // Human full → try premium → flash
-    premium: ['human', 'flash'], // Premium full → try human → flash
+    flash: ['human', 'premium'],
+    human: ['premium', 'flash'],
+    premium: ['human', 'flash'],
 };
-// ============================================================================
-// Model Registry
-// ============================================================================
 export class ModelRegistry {
     pool;
     activeCountMap = new Map();
     constructor(pool) {
         this.pool = pool;
-        // Initialize all counts to 0
         for (const entry of pool) {
             this.activeCountMap.set(entry.id, 0);
         }
     }
-    // --------------------------------------------------------------------------
-    // Core: Acquire / Release
-    // --------------------------------------------------------------------------
-    /**
-     * Acquire a model from the pool.
-     *
-     * Selection strategy:
-     * 1. If modelId specified → try that exact model
-     * 2. Filter by tier preference
-     * 3. Filter by required capabilities
-     * 4. Among candidates, pick best available (cost-aware)
-     * 5. If no match in preferred tier, try fallback tiers
-     */
     acquire(options = {}) {
         const { tier, capabilities, preferCheap = true, modelId } = options;
-        // Specific model requested
         if (modelId) {
             const entry = this.pool.find(e => e.id === modelId);
             if (!entry) {
@@ -64,23 +27,19 @@ export class ModelRegistry {
             }
             return this.tryAcquire(entry);
         }
-        // Tier + capabilities based selection
         const tiersToTry = [];
         if (tier) {
             tiersToTry.push(tier, ...TIER_FALLBACK[tier]);
         }
         else {
-            // No tier specified → try all from cheapest
             tiersToTry.push('flash', 'human', 'premium');
         }
         for (const tryTier of tiersToTry) {
             const candidates = this.findCandidates(tryTier, capabilities);
-            // Sort by availability then cost
             const sorted = this.sortCandidates(candidates, preferCheap);
             for (const entry of sorted) {
                 const result = this.tryAcquire(entry);
                 if (result.success) {
-                    // If we fell back to a different tier, note it
                     if (tier && tryTier !== tier) {
                         result.suggestion = `Preferred tier "${tier}" was full. Using "${tryTier}" model "${entry.id}" instead.`;
                     }
@@ -88,32 +47,23 @@ export class ModelRegistry {
                 }
             }
         }
-        // All models exhausted
         return {
             success: false,
             reason: 'All suitable models are at maximum concurrency',
             suggestion: this.suggestWait(tier, capabilities),
         };
     }
-    /**
-     * Release a model back to the pool.
-     * Must be called when a task using this model completes.
-     */
     release(modelId) {
         const current = this.activeCountMap.get(modelId);
         if (current === undefined) {
-            return false; // Unknown model
+            return false;
         }
         if (current <= 0) {
-            return false; // Already at 0
+            return false;
         }
         this.activeCountMap.set(modelId, current - 1);
         return true;
     }
-    // --------------------------------------------------------------------------
-    // Query: Status and availability
-    // --------------------------------------------------------------------------
-    /** Get the current status of all models in the pool */
     getStatus() {
         const models = this.pool.map(entry => this.getSlot(entry));
         const totalCapacity = models.reduce((sum, m) => sum + m.entry.maxConcurrent, 0);
@@ -125,20 +75,17 @@ export class ModelRegistry {
             totalAvailable: totalCapacity - totalActive,
         };
     }
-    /** Get available models for a specific tier */
     getAvailableForTier(tier) {
         return this.pool
             .filter(e => e.tier === tier)
             .map(e => this.getSlot(e))
             .filter(s => s.available);
     }
-    /** Get all models with a specific capability */
     getModelsWithCapability(capability) {
         return this.pool
             .filter(e => e.capabilities.includes(capability))
             .map(e => this.getSlot(e));
     }
-    /** Get the total concurrency available for a tier (including fallbacks) */
     getTierConcurrency(tier) {
         const tiersToInclude = [tier, ...TIER_FALLBACK[tier]];
         const entries = this.pool.filter(e => tiersToInclude.includes(e.tier));
@@ -154,21 +101,12 @@ export class ModelRegistry {
         }
         return { total, available, models };
     }
-    /** Get the pool entries */
     getPool() {
         return [...this.pool];
     }
-    /** Get the agent name for a pool entry */
     getAgentName(entry) {
         return `dummy-${entry.id}`;
     }
-    // --------------------------------------------------------------------------
-    // Recommend: Smart model selection
-    // --------------------------------------------------------------------------
-    /**
-     * Recommend the best model for a task based on its capabilities.
-     * Does NOT acquire — just suggests.
-     */
     recommend(options = {}) {
         const { tier, capabilities, preferCheap = true } = options;
         const tiersToTry = tier
@@ -186,17 +124,11 @@ export class ModelRegistry {
         }
         return null;
     }
-    /**
-     * Compute maximum parallelism for a set of tasks.
-     * Given N tasks of different tiers, returns how many can run simultaneously.
-     */
     computeMaxParallelism(taskTiers) {
-        // Count tasks per tier
         const tierCounts = new Map();
         for (const tier of taskTiers) {
             tierCounts.set(tier, (tierCounts.get(tier) ?? 0) + 1);
         }
-        // For each tier, compute available concurrency
         let maxParallel = 0;
         for (const [tier, count] of tierCounts) {
             const entries = this.pool.filter(e => e.tier === tier);
@@ -205,9 +137,6 @@ export class ModelRegistry {
         }
         return maxParallel;
     }
-    // --------------------------------------------------------------------------
-    // Internal helpers
-    // --------------------------------------------------------------------------
     getSlot(entry) {
         const activeCount = this.activeCountMap.get(entry.id) ?? 0;
         const remainingSlots = entry.maxConcurrent - activeCount;
@@ -226,7 +155,6 @@ export class ModelRegistry {
                 reason: `Model "${entry.id}" at max concurrency (${entry.maxConcurrent})`,
             };
         }
-        // Increment active count
         this.activeCountMap.set(entry.id, slot.activeCount + 1);
         return {
             success: true,
@@ -241,10 +169,8 @@ export class ModelRegistry {
     }
     findCandidates(tier, capabilities) {
         return this.pool.filter(entry => {
-            // Must match tier
             if (entry.tier !== tier)
                 return false;
-            // If capabilities specified, at least one must match
             if (capabilities && capabilities.length > 0) {
                 const hasMatch = capabilities.some(c => entry.capabilities.includes(c));
                 if (!hasMatch)
@@ -255,20 +181,17 @@ export class ModelRegistry {
     }
     sortCandidates(entries, preferCheap) {
         return [...entries].sort((a, b) => {
-            // 1. Available slots first
             const slotA = this.getSlot(a);
             const slotB = this.getSlot(b);
             if (slotA.available && !slotB.available)
                 return -1;
             if (!slotA.available && slotB.available)
                 return 1;
-            // 2. Cost ordering
             if (preferCheap) {
                 const costDiff = COST_ORDER[a.costTier] - COST_ORDER[b.costTier];
                 if (costDiff !== 0)
                     return costDiff;
             }
-            // 3. More remaining slots = better
             return slotB.remainingSlots - slotA.remainingSlots;
         });
     }
@@ -284,14 +207,7 @@ export class ModelRegistry {
         return `All models are busy. Current usage:\n${hints.join('\n')}\nWait for a task to complete or add more models to the pool.`;
     }
 }
-// ============================================================================
-// Singleton Instance
-// ============================================================================
 let registryInstance = null;
-/**
- * Get the global model registry.
- * Lazily initialized from maskweaver.config.json.
- */
 export function getModelRegistry(basePath) {
     if (!registryInstance) {
         const config = loadRuntimeConfig(basePath);
@@ -302,15 +218,9 @@ export function getModelRegistry(basePath) {
     }
     return registryInstance;
 }
-/**
- * Reset the registry (for testing or config reload).
- */
 export function resetModelRegistry() {
     registryInstance = null;
 }
-/**
- * Create a fresh registry from explicit pool entries.
- */
 export function createModelRegistry(pool) {
     registryInstance = new ModelRegistry(pool);
     return registryInstance;

package/dist/shared/types.d.ts

@@ -1,9 +1,3 @@
-/**
- * Common types used across Maskweaver packages
- */
-/**
- * Result type for operations that can fail gracefully
- */
 export type Result<T> = {
     success: true;
     data: T;
@@ -11,21 +5,12 @@ export type Result<T> = {
     success: false;
     error: string;
 };
-/**
- * Health check result for system components
- */
 export interface HealthCheckResult {
     ok: boolean;
     reason?: string;
     hint?: string;
 }
-/**
- * Log levels for the system
- */
 export type LogLevel = "error" | "warn" | "info" | "debug";
-/**
- * Feature status
- */
 export interface FeatureStatus {
     enabled: boolean;
     healthy?: boolean;

package/dist/shared/types.js

@@ -1,4 +1 @@
-/**
- * Common types used across Maskweaver packages
- */
 export {};

package/dist/shared-context/dag.d.ts

@@ -1,34 +1,14 @@
-/**
- * DAG (Directed Acyclic Graph) Dependency Analysis
- *
- * Analyzes task dependencies to enable parallel execution.
- * Uses Kahn's algorithm for topological sorting and wave grouping.
- *
- * "Make the implicit explicit" - Eric Evans
- * Task dependencies are the implicit structure; DAG makes it explicit.
- *
- * @author Jeff Dean's Dummy Human
- */
 import type { TaskState } from "./types.js";
-/**
- * DAG node representation
- */
 export interface DAGNode {
     taskId: string;
     dependencies: string[];
     dependents: string[];
     inDegree: number;
 }
-/**
- * Execution wave — tasks in same wave can run in parallel
- */
 export interface ExecutionWave {
     waveIndex: number;
     taskIds: string[];
 }
-/**
- * DAG analysis result
- */
 export interface DAGAnalysis {
     nodes: Map<string, DAGNode>;
     waves: ExecutionWave[];
@@ -36,94 +16,9 @@ export interface DAGAnalysis {
     hasCycle: boolean;
     parallelismFactor: number;
 }
-/**
- * Build DAG from task list
- * - Validates no cycles exist (throws if cycle detected)
- * - Computes topological sort
- * - Groups into parallel execution waves (Kahn's algorithm)
- * - Identifies critical path
- * @param tasks - List of tasks to build the DAG from.
- * @returns An object containing the DAG analysis result.
- * @throws {ValidationError} If a cycle is detected or dependencies are invalid.
- * @example
- * import { buildDAG } from './dag.js';
- * import { TaskState } from './types.js';
- *
- * const tasks: TaskState[] = [
- *   { taskId: "A", dependencies: [], status: "pending", assignee: "worker-1", priority: "medium", description: "Task A", createdAt: new Date().toISOString() },
- *   { taskId: "B", dependencies: ["A"], status: "pending", assignee: "worker-1", priority: "medium", description: "Task B", createdAt: new Date().toISOString() },
- *   { taskId: "C", dependencies: ["A"], status: "pending", assignee: "worker-2", priority: "medium", description: "Task C", createdAt: new Date().toISOString() },
- *   { taskId: "D", dependencies: ["B", "C"], status: "pending", assignee: "worker-3", priority: "medium", description: "Task D", createdAt: new Date().toISOString() },
- * ];
- * try {
- *   const dag = buildDAG(tasks);
- *   console.log(dag.waves);
- *   // Expected:
- *   // [
- *   //   { waveIndex: 0, taskIds: ["A"] },
- *   //   { waveIndex: 1, taskIds: ["B", "C"] },
- *   //   { waveIndex: 2, taskIds: ["D"] }
- *   // ]
- *   console.log(dag.criticalPath); // Expected: ["A", "B", "D"] or ["A", "C", "D"]
- * } catch (error) {
- *   if (error instanceof ValidationError) {
- *     console.error("DAG Error:", error.message);
- *   }
- * }
- */
 export declare function buildDAG(tasks: TaskState[]): DAGAnalysis;
-/**
- * Get next executable tasks (all dependencies completed)
- * Used at runtime to determine what can be dispatched now
- * @param tasks - All tasks in the squad.
- * @returns An array of TaskState objects that are ready to be executed.
- * @example
- * import { getReadyTasks } from './dag.js';
- * import { TaskState } from './types.js';
- *
- * const tasks: TaskState[] = [
- *   { taskId: "A", dependencies: [], status: "completed", assignee: "worker-1", priority: "medium", description: "Task A", createdAt: new Date().toISOString() },
- *   { taskId: "B", dependencies: ["A"], status: "pending", assignee: "worker-1", priority: "medium", description: "Task B", createdAt: new Date().toISOString() },
- *   { taskId: "C", dependencies: [], status: "pending", assignee: "worker-2", priority: "medium", description: "Task C", createdAt: new Date().toISOString() },
- * ];
- * const ready = getReadyTasks(tasks);
- * console.log(ready.map(t => t.taskId)); // Expected: ["B", "C"]
- */
 export declare function getReadyTasks(tasks: TaskState[]): TaskState[];
-/**
- * Check if a task's dependencies are all satisfied
- * @param task - The task to check.
- * @param allTasks - All tasks in the squad.
- * @returns True if all dependencies are completed, false otherwise.
- * @example
- * import { areDependenciesMet } from './dag.js';
- * import { TaskState } from './types.js';
- *
- * const tasks: TaskState[] = [
- *   { taskId: "A", dependencies: [], status: "completed", assignee: "worker-1", priority: "medium", description: "Task A", createdAt: new Date().toISOString() },
- *   { taskId: "B", dependencies: ["A"], status: "pending", assignee: "worker-1", priority: "medium", description: "Task B", createdAt: new Date().toISOString() },
- * ];
- * const taskB = tasks[1];
- * const met = areDependenciesMet(taskB, tasks);
- * console.log(met); // Expected: true
- */
 export declare function areDependenciesMet(task: TaskState, allTasks: TaskState[]): boolean;
-/**
- * Validate that dependencies reference valid task IDs (no dangling refs)
- * @param tasks - List of tasks to validate.
- * @returns An object indicating validity and a list of errors if any.
- * @example
- * import { validateDependencies } from './dag.js';
- * import { TaskState } from './types.js';
- *
- * const tasks: TaskState[] = [
- *   { taskId: "A", dependencies: [], status: "pending", assignee: "worker-1", priority: "medium", description: "Task A", createdAt: new Date().toISOString() },
- *   { taskId: "B", dependencies: ["A", "X"], status: "pending", assignee: "worker-1", priority: "medium", description: "Task B", createdAt: new Date().toISOString() }, // X is invalid
- * ];
- * const validation = validateDependencies(tasks);
- * console.log(validation.valid); // Expected: false
- * console.log(validation.errors); // Expected: ["Task B depends on non-existent task X"]
- */
 export declare function validateDependencies(tasks: TaskState[]): {
     valid: boolean;
     errors: string[];

package/dist/shared-context/dag.js

@@ -1,52 +1,5 @@
-/**
- * DAG (Directed Acyclic Graph) Dependency Analysis
- *
- * Analyzes task dependencies to enable parallel execution.
- * Uses Kahn's algorithm for topological sorting and wave grouping.
- *
- * "Make the implicit explicit" - Eric Evans
- * Task dependencies are the implicit structure; DAG makes it explicit.
- *
- * @author Jeff Dean's Dummy Human
- */
 import { ValidationError } from "../shared/errors.js";
-/**
- * Build DAG from task list
- * - Validates no cycles exist (throws if cycle detected)
- * - Computes topological sort
- * - Groups into parallel execution waves (Kahn's algorithm)
- * - Identifies critical path
- * @param tasks - List of tasks to build the DAG from.
- * @returns An object containing the DAG analysis result.
- * @throws {ValidationError} If a cycle is detected or dependencies are invalid.
- * @example
- * import { buildDAG } from './dag.js';
- * import { TaskState } from './types.js';
- *
- * const tasks: TaskState[] = [
- *   { taskId: "A", dependencies: [], status: "pending", assignee: "worker-1", priority: "medium", description: "Task A", createdAt: new Date().toISOString() },
- *   { taskId: "B", dependencies: ["A"], status: "pending", assignee: "worker-1", priority: "medium", description: "Task B", createdAt: new Date().toISOString() },
- *   { taskId: "C", dependencies: ["A"], status: "pending", assignee: "worker-2", priority: "medium", description: "Task C", createdAt: new Date().toISOString() },
- *   { taskId: "D", dependencies: ["B", "C"], status: "pending", assignee: "worker-3", priority: "medium", description: "Task D", createdAt: new Date().toISOString() },
- * ];
- * try {
- *   const dag = buildDAG(tasks);
- *   console.log(dag.waves);
- *   // Expected:
- *   // [
- *   //   { waveIndex: 0, taskIds: ["A"] },
- *   //   { waveIndex: 1, taskIds: ["B", "C"] },
- *   //   { waveIndex: 2, taskIds: ["D"] }
- *   // ]
- *   console.log(dag.criticalPath); // Expected: ["A", "B", "D"] or ["A", "C", "D"]
- * } catch (error) {
- *   if (error instanceof ValidationError) {
- *     console.error("DAG Error:", error.message);
- *   }
- * }
- */
 export function buildDAG(tasks) {
-    // Handle empty input
     if (tasks.length === 0) {
         return {
             nodes: new Map(),
@@ -58,7 +11,6 @@ export function buildDAG(tasks) {
     }
     const nodes = new Map();
     const taskMap = new Map();
-    // Initialize nodes and taskMap
     for (const task of tasks) {
         taskMap.set(task.taskId, task);
         nodes.set(task.taskId, {
@@ -68,7 +20,6 @@ export function buildDAG(tasks) {
             inDegree: 0,
         });
     }
-    // Validate dependencies and build graph (dependents, inDegree)
     const validationResult = validateDependencies(tasks);
     if (!validationResult.valid) {
         throw new ValidationError(`Invalid dependencies: ${validationResult.errors.join(", ")}`);
@@ -81,9 +32,8 @@ export function buildDAG(tasks) {
             taskNode.inDegree++;
         }
     }
-    // Kahn's algorithm for topological sort and wave grouping
-    const q = []; // Queue for nodes with inDegree 0
-    const inDegreeCopy = new Map(); // Copy for Kahn's algorithm
+    const q = [];
+    const inDegreeCopy = new Map();
     for (const [taskId, node] of nodes) {
         inDegreeCopy.set(taskId, node.inDegree);
         if (node.inDegree === 0) {
@@ -110,19 +60,15 @@ export function buildDAG(tasks) {
             }
         }
         if (currentWaveTaskIds.length > 0) {
-            waves.push({ waveIndex: currentWaveIndex, taskIds: currentWaveTaskIds.sort() }); // Sort for deterministic output
+            waves.push({ waveIndex: currentWaveIndex, taskIds: currentWaveTaskIds.sort() });
             currentWaveIndex++;
         }
         q.push(...nextQ);
     }
-    // Cycle detection
     const hasCycle = topologicalOrder.length !== tasks.length;
     if (hasCycle) {
         throw new ValidationError("Cycle detected in task dependencies.");
     }
-    // Critical Path (simple longest path by number of tasks)
-    // This is a simplified critical path calculation, assuming all tasks take equal "time".
-    // For more complex scenarios, task durations would be needed.
     const distances = new Map();
     for (const task of tasks) {
         distances.set(task.taskId, 0);
@@ -144,7 +90,6 @@ export function buildDAG(tasks) {
             endNodeId = taskId;
         }
     }
-    // Reconstruct critical path by backtracking
     if (endNodeId) {
         criticalPath.unshift(endNodeId);
         let currentTaskId = endNodeId;
@@ -160,22 +105,16 @@ export function buildDAG(tasks) {
                 }
             }
             if (!foundPrev) {
-                // This should not happen if distances are calculated correctly for a DAG
-                // Fallback to just the current task if no predecessor is found (e.g., start of path)
                 break;
             }
         }
     }
     else if (tasks.length > 0) {
-        // If there's only one task or all tasks have distance 0 (no dependencies),
-        // the critical path is just the task itself.
-        // Find a task with 0 dependencies to be the start of a critical path if no endNodeId was found.
         const startTask = tasks.find(t => (t.dependencies || []).length === 0);
         if (startTask) {
             criticalPath = [startTask.taskId];
         }
     }
-    // Parallelism Factor
     const totalTasks = tasks.length;
     const totalWaves = waves.length;
     const parallelismFactor = totalWaves > 0 ? totalTasks / totalWaves : 0;
@@ -187,43 +126,9 @@ export function buildDAG(tasks) {
         parallelismFactor,
     };
 }
-/**
- * Get next executable tasks (all dependencies completed)
- * Used at runtime to determine what can be dispatched now
- * @param tasks - All tasks in the squad.
- * @returns An array of TaskState objects that are ready to be executed.
- * @example
- * import { getReadyTasks } from './dag.js';
- * import { TaskState } from './types.js';
- *
- * const tasks: TaskState[] = [
- *   { taskId: "A", dependencies: [], status: "completed", assignee: "worker-1", priority: "medium", description: "Task A", createdAt: new Date().toISOString() },
- *   { taskId: "B", dependencies: ["A"], status: "pending", assignee: "worker-1", priority: "medium", description: "Task B", createdAt: new Date().toISOString() },
- *   { taskId: "C", dependencies: [], status: "pending", assignee: "worker-2", priority: "medium", description: "Task C", createdAt: new Date().toISOString() },
- * ];
- * const ready = getReadyTasks(tasks);
- * console.log(ready.map(t => t.taskId)); // Expected: ["B", "C"]
- */
 export function getReadyTasks(tasks) {
     return tasks.filter(task => task.status === "pending" && areDependenciesMet(task, tasks));
 }
-/**
- * Check if a task's dependencies are all satisfied
- * @param task - The task to check.
- * @param allTasks - All tasks in the squad.
- * @returns True if all dependencies are completed, false otherwise.
- * @example
- * import { areDependenciesMet } from './dag.js';
- * import { TaskState } from './types.js';
- *
- * const tasks: TaskState[] = [
- *   { taskId: "A", dependencies: [], status: "completed", assignee: "worker-1", priority: "medium", description: "Task A", createdAt: new Date().toISOString() },
- *   { taskId: "B", dependencies: ["A"], status: "pending", assignee: "worker-1", priority: "medium", description: "Task B", createdAt: new Date().toISOString() },
- * ];
- * const taskB = tasks[1];
- * const met = areDependenciesMet(taskB, tasks);
- * console.log(met); // Expected: true
- */
 export function areDependenciesMet(task, allTasks) {
     if (!task.dependencies || task.dependencies.length === 0) {
         return true;
@@ -233,22 +138,6 @@ export function areDependenciesMet(task, allTasks) {
         return depTask && depTask.status === "completed";
     });
 }
-/**
- * Validate that dependencies reference valid task IDs (no dangling refs)
- * @param tasks - List of tasks to validate.
- * @returns An object indicating validity and a list of errors if any.
- * @example
- * import { validateDependencies } from './dag.js';
- * import { TaskState } from './types.js';
- *
- * const tasks: TaskState[] = [
- *   { taskId: "A", dependencies: [], status: "pending", assignee: "worker-1", priority: "medium", description: "Task A", createdAt: new Date().toISOString() },
- *   { taskId: "B", dependencies: ["A", "X"], status: "pending", assignee: "worker-1", priority: "medium", description: "Task B", createdAt: new Date().toISOString() }, // X is invalid
- * ];
- * const validation = validateDependencies(tasks);
- * console.log(validation.valid); // Expected: false
- * console.log(validation.errors); // Expected: ["Task B depends on non-existent task X"]
- */
 export function validateDependencies(tasks) {
     const taskIds = new Set(tasks.map(t => t.taskId));
     const errors = [];

package/dist/shared-context/index.d.ts

@@ -1,8 +1,3 @@
-/**
- * @maskweaver/shared-context
- *
- * Multi-agent collaboration with shared context
- */
 export * from "./types.js";
 export { FileStorageAdapter, validatePath, type StorageAdapter, type LockOptions } from "./storage.js";
 export { createSession, loadSession, type Session, type CreateSessionOptions } from "./session.js";

package/dist/shared-context/index.js

@@ -1,25 +1,10 @@
-/**
- * @maskweaver/shared-context
- *
- * Multi-agent collaboration with shared context
- */
-// Types
 export * from "./types.js";
-// Storage
 export { FileStorageAdapter, validatePath } from "./storage.js";
-// Session
 export { createSession, loadSession } from "./session.js";
-// Squad
 export { createSquad, getSquad, updateSquadState } from "./squad.js";
-// Task
 export { assignTask, getTask, updateTask, completeTask } from "./task.js";
-// DAG Analysis
 export { buildDAG, getReadyTasks, areDependenciesMet, validateDependencies } from "./dag.js";
-// Worktree
 export { createWorktreeManager } from "./worktree.js";
-// Parallel Execution
 export { createExecutionPlan, executeWave } from "./parallel-executor.js";
-// Watchdog
 export { checkSquadTimeout, checkTaskTimeout, markSquadExpired, runWatchdog } from "./watchdog.js";
-// Logger
 export { logEvent, readLog } from "./logger.js";