monomind 1.19.0 → 2.0.1

package/packages/@monomind/cli/dist/src/orgrt/types.js

@@ -0,0 +1,51 @@
+// packages/@monomind/cli/src/orgrt/types.ts
+import { z } from 'zod';
+/** Per-role provider config. Default (absent) = subscription login of local Claude Code. */
+export const ProviderSchema = z.object({
+    kind: z.enum(['subscription', 'api-key', 'base-url', 'bedrock', 'vertex']).default('subscription'),
+    /** env var NAME holding the API key (never the key itself) */
+    apiKeyEnv: z.string().optional(),
+    baseUrl: z.string().optional(),
+    /** env var NAME holding the auth token for base-url providers */
+    authTokenEnv: z.string().optional(),
+}).strict();
+export const RolePolicySchema = z.object({
+    allowTools: z.array(z.string()).optional(),
+    denyTools: z.array(z.string()).default([]),
+    /** glob patterns relative to org cwd */
+    fileWrite: z.array(z.string()).default(['**']),
+    fileRead: z.array(z.string()).default(['**']),
+    /** allowed domains for WebFetch/WebSearch; empty array = no web */
+    webAllow: z.array(z.string()).optional(),
+    maxTokens: z.number().int().positive().optional(),
+}).partial().passthrough();
+export const RoleSchema = z.object({
+    id: z.string().min(1),
+    title: z.string().default(''),
+    type: z.string().default('specialist'),
+    reports_to: z.string().nullable().default(null),
+    responsibilities: z.array(z.string()).default([]),
+    instructions_file: z.string().optional(),
+    adapter_config: z.object({
+        model: z.string().default('claude-sonnet-4-5'),
+        max_tokens: z.number().optional(),
+    }).partial().optional(),
+    provider: ProviderSchema.optional(),
+    policy: RolePolicySchema.optional(),
+}).passthrough();
+export const OrgDefSchema = z.object({
+    name: z.string().min(1),
+    goal: z.string().default(''),
+    status: z.string().default('stopped'),
+    schedule: z.union([z.string(), z.number(), z.null()]).default(null),
+    run_config: z.object({
+        max_concurrent_agents: z.number().int().positive().default(4),
+        budget_tokens: z.number().int().positive().default(1_000_000),
+        memory_namespace: z.string().optional(),
+        max_turns_per_message: z.number().int().positive().default(30),
+    }).partial().passthrough().default({})
+        .transform(rc => ({ max_concurrent_agents: 4, budget_tokens: 1_000_000, max_turns_per_message: 30, ...rc })),
+    roles: z.array(RoleSchema).min(1),
+}).passthrough();
+export const ORG_DIR = '.monomind/orgs';
+//# sourceMappingURL=types.js.map

package/packages/@monomind/cli/dist/src/parser.js

@@ -159,11 +159,13 @@ export class CommandParser {
                 result.command.push(arg);
                 // Check for subcommand (level 1)
                 const cmd = this.commands.get(arg);
+                resolvedCmd = cmd;
                 if (cmd?.subcommands && i + 1 < args.length) {
                     const nextArg = args[i + 1];
                     const subCmd = cmd.subcommands.find(sc => sc.name === nextArg || sc.aliases?.includes(nextArg));
                     if (subCmd) {
                         result.command.push(nextArg);
+                        resolvedCmd = subCmd;
                         i++;
                         // Check for nested subcommand (level 2)
                         if (subCmd.subcommands && i + 1 < args.length) {
@@ -171,6 +173,7 @@ export class CommandParser {
                             const nestedCmd = subCmd.subcommands.find(sc => sc.name === nestedArg || sc.aliases?.includes(nestedArg));
                             if (nestedCmd) {
                                 result.command.push(nestedArg);
+                                resolvedCmd = nestedCmd;
                                 i++;
                                 // Check for deeply nested subcommand (level 3)
                                 if (nestedCmd.subcommands && i + 1 < args.length) {
@@ -178,6 +181,7 @@ export class CommandParser {
                                     const deepCmd = nestedCmd.subcommands.find(sc => sc.name === deepArg || sc.aliases?.includes(deepArg));
                                     if (deepCmd) {
                                         result.command.push(deepArg);
+                                        resolvedCmd = deepCmd;
                                         i++;
                                     }
                                 }
@@ -193,8 +197,10 @@ export class CommandParser {
             }
             i++;
         }
-        // Apply defaults
-        this.applyDefaults(result.flags);
+        // Apply defaults — the resolved (sub)command's own option definitions
+        // shadow same-name global options (e.g. `browse screenshot --format` is an
+        // image format, not the global text|json|table output format).
+        this.applyDefaults(result.flags, resolvedCmd);
         return result;
     }
     parseFlag(args, index, aliases, booleanFlags) {
@@ -398,10 +404,24 @@ export class CommandParser {
         }
         return flags;
     }
-    applyDefaults(flags) {
+    applyDefaults(flags, resolvedCmd) {
+        // The resolved command's own options shadow same-name globals: apply the
+        // command's defaults and suppress the global default for those names.
+        const shadowed = new Set();
+        if (resolvedCmd?.options) {
+            for (const opt of resolvedCmd.options) {
+                const key = this.normalizeKey(opt.name);
+                shadowed.add(key);
+                if (flags[key] === undefined && opt.default !== undefined) {
+                    flags[key] = opt.default;
+                }
+            }
+        }
         // Apply global option defaults
         for (const opt of this.globalOptions) {
             const key = this.normalizeKey(opt.name);
+            if (shadowed.has(key))
+                continue;
             if (flags[key] === undefined && opt.default !== undefined) {
                 flags[key] = opt.default;
             }
@@ -418,10 +438,16 @@ export class CommandParser {
     }
     validateFlags(flags, command) {
         const errors = [];
-        const allOptions = [...this.globalOptions];
+        // Command options shadow same-name globals — validate against the
+        // command's definition (its choices/validators), not the global's.
+        const byName = new Map();
+        for (const opt of this.globalOptions)
+            byName.set(opt.name, opt);
         if (command?.options) {
-            allOptions.push(...command.options);
+            for (const opt of command.options)
+                byName.set(opt.name, opt);
         }
+        const allOptions = [...byName.values()];
         // Check required flags
         for (const opt of allOptions) {
             const key = this.normalizeKey(opt.name);

package/packages/@monomind/cli/dist/src/suggest.js

@@ -130,11 +130,8 @@ export const COMMON_TYPOS = {
     'perf': 'performance',
     'performace': 'performance',
     'provider': 'providers',
-    'claim': 'claims',
     'embed': 'embeddings',
     'embeding': 'embeddings',
-    'daemon': 'daemon',
-    'deamon': 'daemon',
     'doc': 'doctor',
     'docter': 'doctor',
     'complete': 'completions',
@@ -144,10 +141,7 @@ export const COMMON_TYPOS = {
     'taks': 'task',
     'sessio': 'session',
     'sess': 'session',
-    'sesssion': 'session',
-    'workflow': 'workflow',
-    'wf': 'workflow',
-    'wokflow': 'workflow'
+    'sesssion': 'session'
 };
 /**
  * Get corrected command if it's a common typo

package/packages/@monomind/cli/dist/src/transfer/store/discovery.d.ts

@@ -49,9 +49,10 @@ export declare class PatternDiscovery {
      */
     fetchRegistry(cid: string, gateway: string): Promise<PatternRegistry | null>;
     /**
-     * Get built-in genesis registry (always available offline)
+     * Honest empty registry returned when no registry is reachable.
+     * Contains no patterns and no fabricated stats.
      */
-    private getGenesisRegistry;
+    private getEmptyRegistry;
     /**
      * Verify registry signature.
      *

package/packages/@monomind/cli/dist/src/transfer/store/discovery.js

@@ -325,83 +325,35 @@ export class PatternDiscovery {
         catch {
             // GCS not available
         }
-        // Return fallback genesis registry if all else fails
-        console.log(`[Discovery] Using built-in genesis registry`);
-        return this.getGenesisRegistry(cid);
+        // No registry could be reached. Previously this fell back to a built-in
+        // "genesis registry" that invented a pattern with fabricated stats
+        // (1,000 downloads, 5.0 rating, 42 reviews). Return an honest empty
+        // registry instead.
+        console.log(`[Discovery] No registry reachable — transfer store requires a configured registry`);
+        return this.getEmptyRegistry();
     }
     /**
-     * Get built-in genesis registry (always available offline)
+     * Honest empty registry returned when no registry is reachable.
+     * Contains no patterns and no fabricated stats.
      */
-    getGenesisRegistry(cid) {
+    getEmptyRegistry() {
         return {
             version: '1.0.0',
             updatedAt: new Date().toISOString(),
-            ipnsName: 'k51qzi5uqu5dj0w8q1xvqn8ql2g4p7x8qpk9vz3xm1y2n3o4p5q6r7s8t9u0v',
+            ipnsName: '',
             previousCid: undefined,
-            patterns: [
-                {
-                    id: 'seraphine-genesis-v1',
-                    name: 'seraphine-genesis',
-                    displayName: 'Seraphine Genesis',
-                    description: 'The foundational Monomind pattern model. Contains core routing patterns, complexity heuristics, and coordination trajectories for multi-agent swarms.',
-                    version: '1.0.0',
-                    cid: 'bafybeibqsa442vty2cvhku4ujlrkupyl75536ene7ybqsa442v',
-                    size: 8808,
-                    checksum: '8df766b89d044815c84796e7f33ba30d7806bff7eb2a75e2a0b7d26b64c45231',
-                    author: {
-                        id: 'monomind-team',
-                        displayName: 'Monomind Team',
-                        verified: true,
-                        patterns: 1,
-                        totalDownloads: 1000,
-                    },
-                    license: 'MIT',
-                    categories: ['routing', 'coordination'],
-                    tags: ['genesis', 'foundational', 'routing', 'swarm', 'coordination', 'multi-agent', 'hello-world'],
-                    language: 'typescript',
-                    framework: 'monomind',
-                    downloads: 1000,
-                    rating: 5.0,
-                    ratingCount: 42,
-                    lastUpdated: new Date().toISOString(),
-                    createdAt: '2026-01-08T18:42:31.126Z',
-                    minMonomindVersion: '3.0.0',
-                    verified: true,
-                    trustLevel: 'verified',
-                    signature: 'ed25519:genesis-pattern-signature',
-                    publicKey: 'ed25519:monomind-team-key',
-                },
-            ],
-            categories: [
-                { id: 'routing', name: 'Task Routing', description: 'Task routing patterns', patternCount: 1, icon: '🔀' },
-                { id: 'coordination', name: 'Swarm Coordination', description: 'Multi-agent coordination', patternCount: 1, icon: '🐝' },
-                { id: 'security', name: 'Security', description: 'Security patterns', patternCount: 0, icon: '🔒' },
-                { id: 'performance', name: 'Performance', description: 'Performance patterns', patternCount: 0, icon: '⚡' },
-                { id: 'testing', name: 'Testing', description: 'Testing patterns', patternCount: 0, icon: '🧪' },
-            ],
-            authors: [
-                {
-                    id: 'monomind-team',
-                    displayName: 'Monomind Team',
-                    publicKey: 'ed25519:monomind-team-key',
-                    verified: true,
-                    patterns: 1,
-                    totalDownloads: 1000,
-                },
-            ],
-            totalPatterns: 1,
-            totalDownloads: 1000,
-            totalAuthors: 1,
-            featured: ['seraphine-genesis-v1'],
-            trending: ['seraphine-genesis-v1'],
-            newest: ['seraphine-genesis-v1'],
-            // No signature on the genesis fallback. Previously this slot used
-            // `crypto.randomBytes(32)` which is meaningless by construction — every
-            // call would produce a different "valid" signature that no real key
-            // signed. Trusted-registry callers must reject this fallback (the
-            // verification path requires `registrySignature` to be present and
-            // verified against a pinned public key).
-            registryPublicKey: 'ed25519:monomind-registry-key',
+            patterns: [],
+            categories: [],
+            authors: [],
+            totalPatterns: 0,
+            totalDownloads: 0,
+            totalAuthors: 0,
+            featured: [],
+            trending: [],
+            newest: [],
+            // No signature — trusted-registry callers must reject this fallback
+            // (the verification path requires `registrySignature` to be present
+            // and verified against a pinned public key).
         };
     }
     /**

package/packages/@monomind/cli/dist/src/ui/collector.mjs

@@ -277,12 +277,17 @@ function collectAgents(projectDir) {
 // Single source-of-truth for all model pricing (canonical list from src/pricing/model-pricing.ts).
 // server.mjs imports _tokPrice and _tokCost from here instead of duplicating this table.
 const _TOK_PRICES = {
+  // Frontier (Fable/Mythos)
+  'claude-fable-5':    { in: 10e-6,   out: 50e-6,   cw: 12.5e-6,  cr: 1e-6     },
+  'claude-mythos-5':   { in: 10e-6,   out: 50e-6,   cw: 12.5e-6,  cr: 1e-6     },
   // Opus
   'claude-opus-4-8':   { in: 5e-6,    out: 25e-6,   cw: 6.25e-6,  cr: 0.5e-6   },
+  'claude-opus-4-7':   { in: 5e-6,    out: 25e-6,   cw: 6.25e-6,  cr: 0.5e-6   },
   'claude-opus-4-6':   { in: 5e-6,    out: 25e-6,   cw: 6.25e-6,  cr: 0.5e-6   },
   'claude-opus-4-5':   { in: 5e-6,    out: 25e-6,   cw: 6.25e-6,  cr: 0.5e-6   },
   'claude-opus-4':     { in: 15e-6,   out: 75e-6,   cw: 18.75e-6, cr: 1.5e-6   },
   // Sonnet
+  'claude-sonnet-5':   { in: 3e-6,    out: 15e-6,   cw: 3.75e-6,  cr: 0.3e-6   },
   'claude-sonnet-4-6': { in: 3e-6,    out: 15e-6,   cw: 3.75e-6,  cr: 0.3e-6   },
   'claude-sonnet-4-5': { in: 3e-6,    out: 15e-6,   cw: 3.75e-6,  cr: 0.3e-6   },
   'claude-sonnet-4':   { in: 3e-6,    out: 15e-6,   cw: 3.75e-6,  cr: 0.3e-6   },
@@ -489,6 +494,15 @@ function collectMetrics(projectDir) {
   const avgConf = routingConfCount > 0 ? Math.round((routingConfSum / routingConfCount) * 100) : null;
   const topAgent = Object.entries(agentCounts).sort((a, b) => b[1] - a[1])[0];
 
+  // Worker freshness: stat the live worker output files so the frontend can
+  // render freshness pills. Shape: workers: [{name, exists, ageMs}]
+  const workerFiles = ['codebase-map', 'security-audit', 'performance', 'consolidation', 'ddd-progress'];
+  const now = Date.now();
+  const workers = workerFiles.map(name => {
+    const s = fileStat(path.join(base, 'metrics', name + '.json'));
+    return { name, exists: !!s, ageMs: s ? Math.max(0, now - s.mtimeMs) : null };
+  });
+
   return {
     routing: {
       total: routingTotal,
@@ -507,7 +521,9 @@ function collectMetrics(projectDir) {
       monthCost: tokenSummary.monthCost,
       monthCalls: tokenSummary.monthCalls,
     },
-    security: readJSON(path.join(base, 'security', 'audit-status.json')) || {}
+    // Live worker output (audit worker) — fields include riskLevel, recommendations
+    security: readJSON(path.join(base, 'metrics', 'security-audit.json')) || {},
+    workers,
   };
 }
 
@@ -554,43 +570,56 @@ function collectMemory(projectDir) {
   const d = path.resolve(projectDir);
   const monomindDir = path.join(d, '.monomind');
 
-  // AgentDB — check all known locations across different init styles
-  const dbCandidates = [
-    path.join(d, 'data', 'memory.db'),         // custom --path ./data/memory.db
-    path.join(d, '.swarm', 'memory.db'),        // default init path
-    path.join(monomindDir, 'memory.db'),        // legacy .monomind path
-    path.join(d, '.claude', 'memory.db'),       // .claude dir (some setups)
-  ];
-  const dbHit = probeFile(...dbCandidates);
-  const dbSize = dbHit ? dbHit.size : 0;
-  const dbPath = dbHit ? dbHit.path : null;
-
-  // HNSW — lives alongside the DB or at the .swarm default
-  const hnswCandidates = dbPath ? [
-    path.join(path.dirname(dbPath), 'memory.graph'),  // alongside DB (hybrid backend)
-    path.join(path.dirname(dbPath), 'hnsw.index'),    // default init name
-  ] : [
-    path.join(d, 'data', 'memory.graph'),
-    path.join(d, '.swarm', 'hnsw.index'),
-  ];
-  const hnswHit = probeFile(...hnswCandidates);
-  const hnsw = !!hnswHit;
+  // Auto-memory pattern store — array of pattern entries written by hooks
+  let patternCount = 0;
+  let patternsUpdated = null;
+  const storePath = path.join(monomindDir, 'data', 'auto-memory-store.json');
+  const store = readJSON(storePath);
+  if (Array.isArray(store)) {
+    patternCount = store.length;
+    for (const e of store) {
+      if (e && typeof e.ts === 'number' && (!patternsUpdated || e.ts > patternsUpdated)) patternsUpdated = e.ts;
+    }
+  }
+  if (!patternsUpdated) {
+    const s = fileStat(storePath);
+    if (s) patternsUpdated = s.mtimeMs;
+  }
 
-  // MonoVector DB
-  const monovectorHit = probeFile(
-    path.join(monomindDir, 'data', 'monovector.db'),
-    path.join(d, 'data', 'monovector.db'),
-  );
-  const monovectorSize = monovectorHit ? monovectorHit.size : 0;
-  const monovectorExists = !!monovectorHit;
+  // Episodic memory — one JSON line per episode
+  let episodeCount = 0;
+  let lastEpisode = null;
+  try {
+    const raw = fs.readFileSync(path.join(monomindDir, 'episodic', 'episodes.jsonl'), 'utf8');
+    const lines = raw.split('\n').filter(Boolean);
+    episodeCount = lines.length;
+    if (lines.length) {
+      try {
+        const last = JSON.parse(lines[lines.length - 1]);
+        lastEpisode = last.ts || last.timestamp || null;
+      } catch {}
+    }
+  } catch {}
 
-  let monovectorPatterns = 0;
-  const ranked = readJSON(path.join(monomindDir, 'data', 'ranked-context.json'));
-  if (ranked && ranked.entries) monovectorPatterns = ranked.entries.length;
+  // Last consolidation run (consolidate worker output)
+  let lastConsolidated = null;
+  const consolidation = readJSON(path.join(monomindDir, 'metrics', 'consolidation.json'));
+  if (consolidation && consolidation.timestamp) lastConsolidated = consolidation.timestamp;
 
   const files = collectMemoryFiles(projectDir);
 
-  return { dbSize, dbPath, hnsw, monovectorSize, monovectorExists, monovectorPatterns, files, count: files.length };
+  return {
+    patternCount,
+    patternsUpdated,
+    episodeCount,
+    lastEpisode,
+    lastConsolidated,
+    files,
+    count: files.length,
+    // Legacy keys kept for frontend backward-safety (v1 backends no longer written in v2)
+    dbSize: 0, dbPath: null, hnsw: false,
+    monovectorSize: 0, monovectorExists: false, monovectorPatterns: 0,
+  };
 }
 
 function collectSystem() {
@@ -771,7 +800,10 @@ export function getWatchPaths(projectDir) {
     path.join(m, 'metrics', 'token-summary.json'),
     path.join(m, 'metrics', 'token-sessions.json'),
     path.join(m, 'metrics', 'ddd-progress.json'),
-    path.join(m, 'metrics', 'learning.json'),
+    path.join(m, 'metrics', 'codebase-map.json'),
+    path.join(m, 'metrics', 'security-audit.json'),
+    path.join(m, 'metrics', 'performance.json'),
+    path.join(m, 'metrics', 'consolidation.json'),
     // Agents
     path.join(m, 'registry.json'),
     path.join(m, 'agents', 'registrations'),
@@ -782,17 +814,10 @@ export function getWatchPaths(projectDir) {
     // Knowledge
     path.join(m, 'knowledge', 'chunks.jsonl'),
     path.join(m, 'skills.jsonl'),
-    // Security
-    path.join(m, 'security', 'audit-status.json'),
-    // Triggers & memory — watch all candidate locations
+    // Triggers & memory — live v2 sources
     path.join(m, 'trigger-index.json'),
-    path.join(resolvedDir, 'data', 'memory.db'),
-    path.join(resolvedDir, 'data', 'memory.graph'),
-    path.join(resolvedDir, '.swarm', 'memory.db'),
-    path.join(resolvedDir, '.swarm', 'hnsw.index'),
-    path.join(m, 'memory.db'),
-    path.join(m, 'data', 'monovector.db'),
-    path.join(m, 'data', 'ranked-context.json'),
+    path.join(m, 'data', 'auto-memory-store.json'),
+    path.join(m, 'episodic', 'episodes.jsonl'),
     // Sessions
     path.join(c, 'sessions')
   ];