monomind 1.9.16 → 1.10.0

package/packages/@monomind/cli/dist/src/model/complexity-scorer.js

@@ -1,106 +0,0 @@
-/**
- * Heuristic complexity scorer for task descriptions.
- *
- * Returns a score in [0, 100] that drives automatic model-tier selection.
- * Higher scores indicate tasks that benefit from more capable (and costly)
- * models.
- */
-// ---------------------------------------------------------------------------
-// Keyword sets
-// ---------------------------------------------------------------------------
-const HIGH_COMPLEXITY_KEYWORDS = [
-    'architecture',
-    'distributed',
-    'security audit',
-    'cve',
-    'consensus',
-    'fault-tolerant',
-    'migrate',
-    'refactor across',
-    'orchestrat',
-    'design system',
-    'database schema',
-    'performance optim',
-    'threat model',
-    'encryption',
-    'zero-knowledge',
-];
-const LOW_COMPLEXITY_KEYWORDS = [
-    'format',
-    'list',
-    'rename',
-    'sort',
-    'typo',
-    'lint',
-    'log',
-    'comment',
-    'print',
-    'echo',
-    'delete unused',
-    'remove import',
-];
-/**
- * Agent slugs that inherently deal with high-complexity work.
- * When one of these agents is involved the score gets a +20 bonus.
- */
-export const HIGH_COMPLEXITY_AGENTS = new Set([
-    'engineering-software-architect',
-    'security-architect',
-    'security-auditor',
-    'system-architect',
-    'performance-engineer',
-    'byzantine-coordinator',
-    'collective-intelligence-coordinator',
-]);
-// ---------------------------------------------------------------------------
-// Patterns
-// ---------------------------------------------------------------------------
-const STEP_INDICATOR_RE = /(?:step\s*\d|first[\s,].*then[\s,]|phase\s*\d)/i;
-const CODE_BLOCK_RE = /```[\s\S]*?```/;
-const FILE_REF_RE = /\b[\w./-]+\.\w{1,5}\b/;
-// ---------------------------------------------------------------------------
-// Scorer
-// ---------------------------------------------------------------------------
-/**
- * Score the complexity of a task description.
- *
- * @param taskDescription - Free-text description of the task.
- * @param agentSlug       - Optional agent identifier; certain agents boost the score.
- * @returns A number in [0, 100].
- */
-export function scoreComplexity(taskDescription, agentSlug) {
-    let score = 50;
-    const lower = taskDescription.toLowerCase();
-    const wordCount = taskDescription.trim().split(/\s+/).length;
-    // -- Word-count adjustments ------------------------------------------------
-    if (wordCount < 20) {
-        score -= 20;
-    }
-    if (wordCount > 100) {
-        score += 20;
-    }
-    if (wordCount > 200) {
-        score += 10;
-    }
-    // -- Keyword adjustments (first match only) --------------------------------
-    if (HIGH_COMPLEXITY_KEYWORDS.some((kw) => lower.includes(kw))) {
-        score += 10;
-    }
-    if (LOW_COMPLEXITY_KEYWORDS.some((kw) => lower.includes(kw))) {
-        score -= 10;
-    }
-    // -- Structural indicators -------------------------------------------------
-    if (STEP_INDICATOR_RE.test(taskDescription)) {
-        score += 10;
-    }
-    if (CODE_BLOCK_RE.test(taskDescription) || FILE_REF_RE.test(taskDescription)) {
-        score += 5;
-    }
-    // -- Agent bonus -----------------------------------------------------------
-    if (agentSlug && HIGH_COMPLEXITY_AGENTS.has(agentSlug)) {
-        score += 20;
-    }
-    // -- Clamp -----------------------------------------------------------------
-    return Math.max(0, Math.min(100, score));
-}
-//# sourceMappingURL=complexity-scorer.js.map

package/packages/@monomind/cli/dist/src/model/index.d.ts

@@ -1,4 +0,0 @@
-export { type ModelTier, type ModelSettings, type ModelPreference, TIER_DEFAULTS, MODEL_IDS, } from './model-settings.js';
-export { scoreComplexity, HIGH_COMPLEXITY_AGENTS, } from './complexity-scorer.js';
-export { type ResolvedModelSettings, resolveModelTier, } from './model-tier-resolver.js';
-//# sourceMappingURL=index.d.ts.map

package/packages/@monomind/cli/dist/src/model/index.js

@@ -1,4 +0,0 @@
-export { TIER_DEFAULTS, MODEL_IDS, } from './model-settings.js';
-export { scoreComplexity, HIGH_COMPLEXITY_AGENTS, } from './complexity-scorer.js';
-export { resolveModelTier, } from './model-tier-resolver.js';
-//# sourceMappingURL=index.js.map

package/packages/@monomind/cli/dist/src/model/model-settings.d.ts

@@ -1,22 +0,0 @@
-/**
- * Per-run model tier selection — types and constants.
- *
- * Each tier maps to a concrete Claude model ID and carries sensible defaults
- * for token budget, temperature, and extended-thinking.
- */
-export type ModelTier = 'haiku' | 'sonnet' | 'opus';
-export interface ModelSettings {
-    model: ModelTier;
-    maxTokens?: number;
-    maxCostUsd?: number;
-    extendedThinking?: boolean;
-    temperature?: number;
-}
-export interface ModelPreference {
-    default: ModelTier;
-    maxCostUsd?: number;
-    extendedThinking?: boolean;
-}
-export declare const TIER_DEFAULTS: Record<ModelTier, ModelSettings>;
-export declare const MODEL_IDS: Record<ModelTier, string>;
-//# sourceMappingURL=model-settings.d.ts.map

package/packages/@monomind/cli/dist/src/model/model-settings.js

@@ -1,33 +0,0 @@
-/**
- * Per-run model tier selection — types and constants.
- *
- * Each tier maps to a concrete Claude model ID and carries sensible defaults
- * for token budget, temperature, and extended-thinking.
- */
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-export const TIER_DEFAULTS = {
-    haiku: {
-        model: 'haiku',
-        maxTokens: 2048,
-        temperature: 0.3,
-    },
-    sonnet: {
-        model: 'sonnet',
-        maxTokens: 8192,
-        temperature: 0.5,
-    },
-    opus: {
-        model: 'opus',
-        maxTokens: 16384,
-        temperature: 0.7,
-        extendedThinking: true,
-    },
-};
-export const MODEL_IDS = {
-    haiku: 'claude-haiku-4-5',
-    sonnet: 'claude-sonnet-4-5',
-    opus: 'claude-opus-4-5',
-};
-//# sourceMappingURL=model-settings.js.map

package/packages/@monomind/cli/dist/src/model/model-tier-resolver.d.ts

@@ -1,24 +0,0 @@
-/**
- * Resolves the concrete model tier for a given agent + task combination.
- *
- * Resolution order:
- *   1. Orchestrator override (explicit)
- *   2. Complexity-based automatic selection
- *   3. Agent preference default
- *   4. Fallback to sonnet
- */
-import type { ModelSettings, ModelPreference } from './model-settings.js';
-export interface ResolvedModelSettings extends ModelSettings {
-    complexityScore: number;
-    resolutionReason: string;
-}
-/**
- * Determine the best model tier for a task.
- *
- * @param agentSlug            - The agent that will execute the task.
- * @param taskDescription      - Free-text task description.
- * @param agentPreference      - Optional per-agent preference.
- * @param orchestratorOverride - Optional hard override from the orchestrator.
- */
-export declare function resolveModelTier(agentSlug: string, taskDescription: string, agentPreference?: ModelPreference, orchestratorOverride?: Partial<ModelSettings>): ResolvedModelSettings;
-//# sourceMappingURL=model-tier-resolver.d.ts.map

package/packages/@monomind/cli/dist/src/model/model-tier-resolver.js

@@ -1,65 +0,0 @@
-/**
- * Resolves the concrete model tier for a given agent + task combination.
- *
- * Resolution order:
- *   1. Orchestrator override (explicit)
- *   2. Complexity-based automatic selection
- *   3. Agent preference default
- *   4. Fallback to sonnet
- */
-import { TIER_DEFAULTS } from './model-settings.js';
-import { scoreComplexity, HIGH_COMPLEXITY_AGENTS } from './complexity-scorer.js';
-// ---------------------------------------------------------------------------
-// Resolver
-// ---------------------------------------------------------------------------
-/**
- * Determine the best model tier for a task.
- *
- * @param agentSlug            - The agent that will execute the task.
- * @param taskDescription      - Free-text task description.
- * @param agentPreference      - Optional per-agent preference.
- * @param orchestratorOverride - Optional hard override from the orchestrator.
- */
-export function resolveModelTier(agentSlug, taskDescription, agentPreference, orchestratorOverride) {
-    const complexity = scoreComplexity(taskDescription, agentSlug);
-    // ----- 1. Orchestrator override ------------------------------------------
-    if (orchestratorOverride?.model) {
-        return buildResult(orchestratorOverride.model, complexity, 'orchestrator_override', agentPreference);
-    }
-    // ----- 2. Complexity-based selection -------------------------------------
-    const preferredDefault = agentPreference?.default ?? 'sonnet';
-    let tier;
-    let reason;
-    if (complexity < 30 && preferredDefault !== 'opus') {
-        tier = 'haiku';
-        reason = 'low_complexity';
-    }
-    else if (complexity >= 70 || HIGH_COMPLEXITY_AGENTS.has(agentSlug)) {
-        tier = 'opus';
-        reason = complexity >= 70 ? 'high_complexity' : 'high_complexity_agent';
-    }
-    else {
-        tier = preferredDefault;
-        reason = 'default_preference';
-    }
-    return buildResult(tier, complexity, reason, agentPreference);
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function buildResult(tier, complexityScore, resolutionReason, preference) {
-    const base = { ...TIER_DEFAULTS[tier] };
-    // Propagate preference overrides
-    if (preference?.maxCostUsd !== undefined) {
-        base.maxCostUsd = preference.maxCostUsd;
-    }
-    if (preference?.extendedThinking !== undefined) {
-        base.extendedThinking = preference.extendedThinking;
-    }
-    return {
-        ...base,
-        complexityScore,
-        resolutionReason,
-    };
-}
-//# sourceMappingURL=model-tier-resolver.js.map

package/packages/@monomind/cli/dist/src/observability/replay-reader.d.ts

@@ -1,40 +0,0 @@
-/**
- * ReplayReader
- *
- * Reads session files from .monomind/sessions/ for replay and listing.
- * Session files follow the pattern session-{id}.json. current.json is a
- * regular file (not a symlink) pointing to the active session data.
- */
-export interface SessionSummary {
-    id: string;
-    startedAt: string;
-    endedAt?: string;
-    tokenUsage?: {
-        total?: number;
-    };
-    taskCount?: number;
-    filePath: string;
-}
-export interface SessionReplay extends SessionSummary {
-    raw: Record<string, unknown>;
-}
-export declare class ReplayReader {
-    private sessionsDir;
-    constructor(cwd?: string);
-    /**
-     * Find and return the session data for a given session ID.
-     * The ID may be a bare ID (e.g. "session-1234567890") or a timestamp number.
-     * Falls back to current.json if the id matches the current session.
-     */
-    show(sessionId: string): Promise<SessionReplay | null>;
-    /**
-     * List sessions ordered by startedAt descending (most recent first).
-     * current.json is excluded — only persisted session-*.json files are listed.
-     */
-    list(limit?: number): Promise<SessionSummary[]>;
-    private parseReplay;
-    private parseSummary;
-    private buildSummary;
-    private readJson;
-}
-//# sourceMappingURL=replay-reader.d.ts.map

package/packages/@monomind/cli/dist/src/observability/replay-reader.js

@@ -1,138 +0,0 @@
-/**
- * ReplayReader
- *
- * Reads session files from .monomind/sessions/ for replay and listing.
- * Session files follow the pattern session-{id}.json. current.json is a
- * regular file (not a symlink) pointing to the active session data.
- */
-import { readdirSync, readFileSync, existsSync, statSync } from 'fs';
-import { join, sep, resolve } from 'path';
-export class ReplayReader {
-    sessionsDir;
-    constructor(cwd = process.cwd()) {
-        this.sessionsDir = join(cwd, '.monomind', 'sessions');
-    }
-    /**
-     * Find and return the session data for a given session ID.
-     * The ID may be a bare ID (e.g. "session-1234567890") or a timestamp number.
-     * Falls back to current.json if the id matches the current session.
-     */
-    async show(sessionId) {
-        if (!existsSync(this.sessionsDir)) {
-            return null;
-        }
-        // Normalize: allow bare numeric IDs or full "session-<id>" form
-        const normalized = sessionId.startsWith('session-')
-            ? sessionId
-            : `session-${sessionId}`;
-        // Guard against path traversal (e.g. sessionId = "../../../etc/passwd")
-        const filePath = join(this.sessionsDir, `${normalized}.json`);
-        if (!resolve(filePath).startsWith(resolve(this.sessionsDir) + sep))
-            return null;
-        if (existsSync(filePath)) {
-            return this.parseReplay(filePath);
-        }
-        // Fall back to current.json if the id matches
-        const currentPath = join(this.sessionsDir, 'current.json');
-        if (existsSync(currentPath)) {
-            const current = this.parseReplay(currentPath);
-            if (current && (current.id === sessionId || current.id === normalized)) {
-                return current;
-            }
-        }
-        return null;
-    }
-    /**
-     * List sessions ordered by startedAt descending (most recent first).
-     * current.json is excluded — only persisted session-*.json files are listed.
-     */
-    async list(limit = 20) {
-        if (!existsSync(this.sessionsDir)) {
-            return [];
-        }
-        let entries;
-        try {
-            entries = readdirSync(this.sessionsDir);
-        }
-        catch {
-            return [];
-        }
-        const summaries = [];
-        for (const entry of entries) {
-            if (!entry.startsWith('session-') || !entry.endsWith('.json')) {
-                continue;
-            }
-            const filePath = join(this.sessionsDir, entry);
-            const summary = this.parseSummary(filePath);
-            if (summary) {
-                summaries.push(summary);
-            }
-        }
-        // Sort by startedAt descending; push invalid dates to the end
-        summaries.sort((a, b) => {
-            const ta = new Date(a.startedAt).getTime();
-            const tb = new Date(b.startedAt).getTime();
-            if (isNaN(ta) && isNaN(tb))
-                return 0;
-            if (isNaN(ta))
-                return 1;
-            if (isNaN(tb))
-                return -1;
-            return tb - ta;
-        });
-        return summaries.slice(0, limit);
-    }
-    // ── private helpers ──────────────────────────────────────────────────────────
-    parseReplay(filePath) {
-        const raw = this.readJson(filePath);
-        if (!raw)
-            return null;
-        const summary = this.buildSummary(raw, filePath);
-        if (!summary)
-            return null;
-        return { ...summary, raw };
-    }
-    parseSummary(filePath) {
-        const raw = this.readJson(filePath);
-        if (!raw)
-            return null;
-        return this.buildSummary(raw, filePath);
-    }
-    buildSummary(raw, filePath) {
-        const id = typeof raw.id === 'string' ? raw.id : null;
-        const startedAt = typeof raw.startedAt === 'string' ? raw.startedAt : null;
-        if (!id || !startedAt)
-            return null;
-        const endedAt = typeof raw.endedAt === 'string' ? raw.endedAt : undefined;
-        // tokenUsage is not present in current session files but kept optional per interface
-        const tokenUsage = raw.tokenUsage && typeof raw.tokenUsage === 'object'
-            ? raw.tokenUsage
-            : undefined;
-        // taskCount comes from metrics.tasks
-        const metrics = raw.metrics && typeof raw.metrics === 'object'
-            ? raw.metrics
-            : undefined;
-        const taskCount = metrics && typeof metrics.tasks === 'number' ? metrics.tasks : undefined;
-        return { id, startedAt, endedAt, tokenUsage, taskCount, filePath };
-    }
-    readJson(filePath) {
-        try {
-            // Hard size cap. Without this, a single planted multi-GB session-*.json
-            // (or a runaway log) crashes the CLI with allocation failure when
-            // any code path touches `list()` or `show()`.
-            const stat = statSync(filePath);
-            if (stat.size > 25 * 1024 * 1024)
-                return null;
-            const content = readFileSync(filePath, 'utf-8');
-            const parsed = JSON.parse(content);
-            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-                return parsed;
-            }
-            return null;
-        }
-        catch {
-            return null;
-        }
-    }
-}
-//# sourceMappingURL=replay-reader.js.map

package/packages/@monomind/cli/dist/src/orchestration/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * Orchestration — barrel exports for Three-Mode Team Routing (Task 22)
- */
-export { RouteModeExecutor, CoordinateModeExecutor, CollaborateModeExecutor, parsePlan, } from './routing-modes.js';
-export type { OrchestrationMode, RouteModeConfig, CoordinateModeConfig, CollaborateModeConfig, ModeResult, AgentDispatcher, ModeExecutor, } from './routing-modes.js';
-export { ModeDispatcher } from './mode-dispatcher.js';
-//# sourceMappingURL=index.d.ts.map

package/packages/@monomind/cli/dist/src/orchestration/index.js

@@ -1,6 +0,0 @@
-/**
- * Orchestration — barrel exports for Three-Mode Team Routing (Task 22)
- */
-export { RouteModeExecutor, CoordinateModeExecutor, CollaborateModeExecutor, parsePlan, } from './routing-modes.js';
-export { ModeDispatcher } from './mode-dispatcher.js';
-//# sourceMappingURL=index.js.map

package/packages/@monomind/cli/dist/src/orchestration/mode-dispatcher.d.ts

@@ -1,11 +0,0 @@
-/**
- * ModeDispatcher — selects and executes the correct mode executor
- * based on the requested OrchestrationMode.
- */
-import type { AgentDispatcher, CollaborateModeConfig, CoordinateModeConfig, ModeResult, OrchestrationMode, RouteModeConfig } from './routing-modes.js';
-export declare class ModeDispatcher {
-    private readonly dispatcher;
-    constructor(dispatcher: AgentDispatcher);
-    dispatchWithMode(mode: OrchestrationMode | undefined, config: RouteModeConfig | CoordinateModeConfig | CollaborateModeConfig): Promise<ModeResult>;
-}
-//# sourceMappingURL=mode-dispatcher.d.ts.map

package/packages/@monomind/cli/dist/src/orchestration/mode-dispatcher.js

@@ -1,31 +0,0 @@
-/**
- * ModeDispatcher — selects and executes the correct mode executor
- * based on the requested OrchestrationMode.
- */
-import { CollaborateModeExecutor, CoordinateModeExecutor, RouteModeExecutor, } from './routing-modes.js';
-export class ModeDispatcher {
-    dispatcher;
-    constructor(dispatcher) {
-        this.dispatcher = dispatcher;
-    }
-    async dispatchWithMode(mode = 'route', config) {
-        switch (mode) {
-            case 'route': {
-                const executor = new RouteModeExecutor(this.dispatcher);
-                return executor.execute(config);
-            }
-            case 'coordinate': {
-                const executor = new CoordinateModeExecutor(this.dispatcher);
-                return executor.execute(config);
-            }
-            case 'collaborate': {
-                const executor = new CollaborateModeExecutor(this.dispatcher);
-                return executor.execute(config);
-            }
-            default: {
-                throw new Error(`Unknown orchestration mode: ${mode}`);
-            }
-        }
-    }
-}
-//# sourceMappingURL=mode-dispatcher.js.map

package/packages/@monomind/cli/dist/src/orchestration/routing-modes.d.ts

@@ -1,68 +0,0 @@
-/**
- * Three-Mode Team Routing — Task 22
- *
- * Provides three orchestration modes:
- *  - route:       single-agent dispatch
- *  - coordinate:  planner → fan-out → synthesizer
- *  - collaborate: iterative A↔B with shared scratchpad
- */
-export type OrchestrationMode = 'route' | 'coordinate' | 'collaborate';
-export interface RouteModeConfig {
-    agentSlug: string;
-    task: string;
-}
-export interface CoordinateModeConfig {
-    plannerSlug?: string;
-    synthesizerSlug?: string;
-    task: string;
-    maxSubtasks?: number;
-}
-export interface CollaborateModeConfig {
-    agentA: string;
-    agentB: string;
-    task: string;
-    maxIterations?: number;
-    convergencePhrase?: string;
-}
-export interface ModeResult {
-    mode: OrchestrationMode;
-    output: unknown;
-    agentsInvolved: string[];
-    iterationCount: number;
-    tokenUsage: {
-        input: number;
-        output: number;
-    };
-    latencyMs: number;
-}
-export interface AgentDispatcher {
-    dispatch(agentSlug: string, task: string, context?: string): Promise<{
-        output: unknown;
-        tokenUsage?: {
-            input: number;
-            output: number;
-        };
-    }>;
-}
-export declare abstract class ModeExecutor<TConfig> {
-    protected readonly dispatcher: AgentDispatcher;
-    constructor(dispatcher: AgentDispatcher);
-    abstract execute(config: TConfig): Promise<ModeResult>;
-}
-export declare class RouteModeExecutor extends ModeExecutor<RouteModeConfig> {
-    execute(config: RouteModeConfig): Promise<ModeResult>;
-}
-/**
- * Extract a subtasks array from the planner output.
- * Accepts either a raw array or JSON containing a `subtasks` key.
- */
-export declare function parsePlan(output: unknown): string[];
-export declare class CoordinateModeExecutor extends ModeExecutor<CoordinateModeConfig> {
-    execute(config: CoordinateModeConfig): Promise<ModeResult>;
-    private addTokens;
-}
-export declare class CollaborateModeExecutor extends ModeExecutor<CollaborateModeConfig> {
-    execute(config: CollaborateModeConfig): Promise<ModeResult>;
-    private addTokens;
-}
-//# sourceMappingURL=routing-modes.d.ts.map