monomind 1.10.0 → 1.10.2

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

@@ -0,0 +1,106 @@
+/**
+ * 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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,22 @@
+/**
+ * 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

@@ -0,0 +1,33 @@
+/**
+ * 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

@@ -0,0 +1,24 @@
+/**
+ * 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

@@ -0,0 +1,65 @@
+/**
+ * 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

@@ -0,0 +1,40 @@
+/**
+ * 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

@@ -0,0 +1,138 @@
+/**
+ * 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

@@ -0,0 +1,7 @@
+/**
+ * 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

@@ -0,0 +1,6 @@
+/**
+ * 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

@@ -0,0 +1,11 @@
+/**
+ * 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

@@ -0,0 +1,31 @@
+/**
+ * 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

@@ -0,0 +1,68 @@
+/**
+ * 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