monomind 1.11.10 → 1.11.12

package/.claude/skills/mastermind/architect.md

@@ -88,14 +88,14 @@ If this skill is invoked directly (not by master):
    ```
    After the bash above completes, apply the 60% classification rule: sum the total file count across all extensions. If any single extension group exceeds 60% of the total, set `<stack>` to that stack's name (e.g. `typescript`, `python`, `go`); otherwise set `<stack>` to `multi-stack`. Use this value for `Stack: <stack>` in all subsequent briefings.
    If `scope` was not provided by the caller, infer it from the prompt: "review"/"audit"/"check"/"assess" → `review`; "deduplicate"/"dedup"/"consolidate" → `deduplicate`; "design"/"architect"/"model"/"bounded context" → `design`; "migrate"/"migration"/"port to"/"convert" → `migrate`; no keyword match or multiple keyword matches → `all`. Use the resolved scope for all subsequent steps.
-5. If `board_id` was not provided by the caller: find or create monotask space `<project_name>`, then create board `architect` within it. Before executing the bash block below, substitute the resolved `project_name` (or `basename "$PWD"` if not provided) for every `<project_name>` occurrence:
+5. If `board_id` was not provided by the caller: find or create monotask space `<project_name>`, then create board `architect` within it (optional — proceed without a board if monotask is not installed). Before executing the bash block below, substitute the resolved `project_name` (or `basename "$PWD"` if not provided) for every `<project_name>` occurrence:
    ```bash
    space_id=$(monotask space list 2>/dev/null | awk -F' \| ' -v n="<project_name>" '$2==n{print $1}' | head -1)
    [ -z "$space_id" ] && space_id=$(monotask space create "<project_name>" 2>&1 | grep -oE '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}')
    result=$(monotask board create "architect" --json 2>/dev/null)
    board_id=$(echo "$result" | jq -r '.id // empty')
    [ -n "$board_id" ] && [ -n "$space_id" ] && monotask space boards add "$space_id" "$board_id" >/dev/null 2>&1 || true
-   [ -z "$board_id" ] && { echo "ERROR: Failed to create monotask board — verify monotask is installed (run: monotask --version)"; exit 1; }
+   [ -z "$board_id" ] && echo "[architect] monotask board unavailable — board tracking skipped. Install monotask to enable progress tracking."
    echo "$board_id"
    ```
    If this block exits with an error (board_id is still empty), stop execution and return an error to the caller — do not proceed to complexity assessment.
@@ -363,10 +363,13 @@ For each stream, identify:
 - Dependencies between streams (e.g. coupling analysis before deduplication plan)
 
 STEP 3 — CREATE TASKS
-For each architecture stream, create a monotask card on the project board. First resolve column IDs (slash commands are not available inside background Task agents — use bash directly):
+For each architecture stream, create a monotask card on the project board if a board is available. If BOARD_ID is empty (monotask not installed), skip all monotask card operations in this step — proceed directly to STEP 4 with an in-memory task list instead.
+
+If BOARD_ID is non-empty: First resolve column IDs (slash commands are not available inside background Task agents — use bash directly):
 
 \`\`\`bash
-columns=$(monotask column list "$BOARD_ID" --json)
+[ -z "$BOARD_ID" ] && { echo "[architect] No board — skipping card creation, proceeding with in-memory tasks."; }
+columns=$([ -n "$BOARD_ID" ] && monotask column list "$BOARD_ID" --json || echo '[]')
 COL_TODO_ID=$(echo "$columns" | jq -r '.[] | select(.title == "Todo" or .title == "Backlog") | .id' | head -1)
 COL_DONE_ID=$(echo "$columns" | jq -r '.[] | select(.title == "Done") | .id' | head -1)
 \`\`\`

package/.claude/skills/mastermind/autodev.md

@@ -432,7 +432,7 @@ Invoke `Skill("mastermind:build")` with:
 - `brain_context`: the loaded brain context
 - `project_name`: `$(basename "$PWD")`
 - `mode`: `auto`
-- `board_id`: the autodev board (create once at startup, reuse)
+- `board_id`: the autodev board (only if non-empty; omit if monotask was unavailable)
 
 The brief passed to build MUST include:
 - What to build (concrete spec, not vague)
@@ -490,11 +490,13 @@ If `N < count`: log `[autodev] Moving to improvement <N+1>/<count>...` and repea
 
 1. Extract flags (leading integer for count, --newfeature N, --focus, --auto/--confirm)
 2. Load brain context via _protocol.md Brain Load Procedure (namespace: `autodev`)
-3. Create monotask board:
+3. Create monotask board (optional — skip gracefully if monotask is not installed):
    ```bash
    project_name="${project_name:-$(basename "$PWD")}"
    board_id=$(monotask board create "autodev" --json 2>/dev/null | jq -r '.id // empty')
+   [ -z "$board_id" ] && echo "[autodev] monotask board unavailable — board tracking skipped."
    ```
+   Pass `board_id` to `mastermind:build` only if non-empty; omit the parameter otherwise.
 4. **If `--newfeature` was parsed:** run the Feature Pipeline (FP-0 through FP-End) and skip the improvement loop entirely.
    **Otherwise:** run the Loop section above for each improvement.
 5. At end: follow _protocol.md Brain Write Procedure (namespace: `autodev`)

package/.claude/skills/mastermind/idea.md

@@ -9,6 +9,14 @@ default_mode: confirm
 
 This skill is invoked by `mastermind:master` or directly via `/mastermind:idea`.
 
+**Extract `--monotask` flag:** If present in `$ARGUMENTS`, set `USE_MONOTASK=true` and remove it. Default: `USE_MONOTASK=false`.
+
+**File mode (default, `USE_MONOTASK=false`):**
+
+Invoke `Skill("mastermind:ideate", $ARGUMENTS)` immediately — it provides the same research, evaluation, elaboration, and task-decomposition pipeline with file-first storage (`docs/ideas/` and `docs/tasks/`). The rest of this skill only runs in monotask mode.
+
+**Monotask mode (`USE_MONOTASK=true` only):** Continue with the steps below.
+
 ---
 
 ## Inputs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.11.10",
+  "version": "1.11.12",
   "description": "Monomind - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

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

@@ -11,7 +11,7 @@ import { commandParser } from './parser.js';
 import { output } from './output.js';
 import { commands, commandsByCategory, getCommand, getCommandAsync, getCommandNames, hasCommand } from './commands/index.js';
 import { suggestCommand } from './suggest.js';
-import { runStartupUpdateCheck } from './update/index.js';
+import { runStartupUpdateCheck, getUpdateTagline } from './update/index.js';
 // Read version from package.json at runtime
 function getPackageVersion() {
     try {
@@ -223,7 +223,8 @@ export class CLI {
      */
     showHelp() {
         this.output.writeln();
-        this.output.writeln(this.output.bold(`${this.name} v${this.version}`));
+        const tagline = getUpdateTagline(this.version);
+        this.output.writeln(this.output.bold(`${this.name} v${this.version}`) + this.output.dim(tagline));
         this.output.writeln(this.output.dim(this.description));
         this.output.writeln();
         this.output.writeln(this.output.bold('USAGE:'));
@@ -355,7 +356,8 @@ export class CLI {
      * Show version
      */
     showVersion() {
-        this.output.writeln(`${this.name} v${this.version}`);
+        const tagline = getUpdateTagline(this.version);
+        this.output.writeln(`${this.name} v${this.version}${tagline}`);
     }
     /**
      * Check for updates on startup (non-blocking)
@@ -363,17 +365,20 @@ export class CLI {
      */
     async checkForUpdatesOnStartup() {
         try {
-            const result = await runStartupUpdateCheck({ autoUpdate: true });
-            // Show notifications for available updates that weren't auto-applied
-            if (result.checked && result.updatesAvailable.length > 0) {
-                const nonAutoUpdates = result.updatesAvailable.filter(u => !u.shouldAutoUpdate);
-                if (result.updatesApplied.length > 0) {
-                    this.output.writeln(this.output.dim(`Auto-updated: ${result.updatesApplied.join(', ')}`));
-                }
-                if (nonAutoUpdates.length > 0) {
-                    this.output.writeln(this.output.dim(`Updates available: ${nonAutoUpdates.map(u => `${u.package}@${u.latestVersion}`).join(', ')}`));
-                    this.output.writeln(this.output.dim(`Run '${this.name} update check' for details`));
-                }
+            const result = await runStartupUpdateCheck({
+                autoUpdate: true,
+                onInstalling: (pkgs) => {
+                    this.output.writeln(this.output.dim(`  ↑ installing ${pkgs.join(', ')}...`));
+                },
+            });
+            if (!result.checked)
+                return;
+            if (result.updatesApplied.length > 0) {
+                this.output.writeln(this.output.dim(`  ✓ updated ${result.updatesApplied.join(', ')}`));
+            }
+            const manual = result.updatesAvailable.filter(u => !u.shouldAutoUpdate);
+            if (manual.length > 0) {
+                this.output.writeln(this.output.dim(`  ↑ ${manual.map(u => `${u.package} v${u.latestVersion}`).join(', ')} available  →  run: ${this.name} update all`));
             }
         }
         catch {

package/packages/@monomind/cli/dist/src/update/checker.js

@@ -11,19 +11,32 @@ const DEFAULT_CONFIG = {
     checkIntervalHours: 24,
     autoUpdate: {
         patch: true,
-        minor: false,
+        minor: true,
         major: false,
     },
     priority: {
-        '@monomind/security': 'critical',
-        '@monomind/cli': 'high',
+        'monofence-ai': 'critical',
+        '@monoes/monomindcli': 'high',
+        'monomind': 'high',
+        '@monoes/monograph': 'normal',
+        '@monoes/memory': 'normal',
+        '@monoes/monodesign': 'low',
     },
     exclude: [],
 };
-// Packages to check for updates
+// All monomind-ecosystem packages to check for updates.
+// getInstalledVersion() returns null for uninstalled packages — they are silently skipped.
 const MONOMIND_PACKAGES = [
     'monomind',
-    '@monomind/cli',
+    '@monoes/monomindcli',
+    'monofence-ai',
+    '@monoes/monograph',
+    '@monoes/memory',
+    '@monoes/monodesign',
+    '@monomind/guidance',
+    '@monomind/hooks',
+    '@monomind/mcp',
+    '@monomind/routing',
 ];
 // npm package name regex — covers plain names and @scope/name forms.
 // Validates before using the name in URLs or filesystem paths.

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

@@ -17,6 +17,15 @@ export type { ValidationResult } from './validator.js';
 export { executeUpdate, executeMultipleUpdates, rollbackUpdate, getUpdateHistory, clearHistory, loadHistory, } from './executor.js';
 export type { UpdateHistoryEntry, UpdateExecutionResult } from './executor.js';
 import type { UpdateCheckResult } from './checker.js';
+/**
+ * Synchronous — reads cached state from last check.
+ * Returns a short inline string for the CLI version tagline, e.g.
+ *   "  ↑ v1.11.12 available"
+ *   "  ↑ v1.11.12 installing..."
+ *   "  ✓ up to date"
+ *   ""  (no cache yet)
+ */
+export declare function getUpdateTagline(currentVersion: string): string;
 /**
  * Run auto-update check on startup
  * This is the main entry point for the auto-update system
@@ -24,6 +33,7 @@ import type { UpdateCheckResult } from './checker.js';
 export declare function runStartupUpdateCheck(options: {
     verbose?: boolean;
     autoUpdate?: boolean;
+    onInstalling?: (packages: string[]) => void;
 }): Promise<{
     checked: boolean;
     updatesAvailable: UpdateCheckResult[];

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

@@ -13,9 +13,37 @@ export { shouldCheckForUpdates, recordCheck, getCachedVersions, clearCache, load
 export { validateUpdate, validateBulkUpdate } from './validator.js';
 export { executeUpdate, executeMultipleUpdates, rollbackUpdate, getUpdateHistory, clearHistory, loadHistory, } from './executor.js';
 // Re-export a convenience function for startup
-import { checkForUpdates, DEFAULT_CONFIG } from './checker.js';
+import { checkForUpdates, DEFAULT_CONFIG, getInstalledVersion } from './checker.js';
 import { executeMultipleUpdates } from './executor.js';
-import { getInstalledVersion } from './checker.js';
+import { getCachedVersions } from './rate-limiter.js';
+import * as semver from 'semver';
+/**
+ * Synchronous — reads cached state from last check.
+ * Returns a short inline string for the CLI version tagline, e.g.
+ *   "  ↑ v1.11.12 available"
+ *   "  ↑ v1.11.12 installing..."
+ *   "  ✓ up to date"
+ *   ""  (no cache yet)
+ */
+export function getUpdateTagline(currentVersion) {
+    try {
+        const cached = getCachedVersions();
+        // Use the umbrella package as the canonical version signal
+        const latest = cached['monomind'] || cached['@monoes/monomindcli'];
+        if (!latest || !semver.valid(latest) || !semver.valid(currentVersion))
+            return '';
+        if (semver.lte(latest, currentVersion))
+            return '  ✓ up to date';
+        const type = semver.diff(currentVersion, latest);
+        if (type === 'patch' || type === 'minor') {
+            return `  ↑ v${latest} installing...`;
+        }
+        return `  ↑ v${latest} available`;
+    }
+    catch {
+        return '';
+    }
+}
 /**
  * Run auto-update check on startup
  * This is the main entry point for the auto-update system
@@ -39,6 +67,8 @@ export async function runStartupUpdateCheck(options) {
         if (options.autoUpdate !== false) {
             const autoUpdateable = results.filter((r) => r.shouldAutoUpdate);
             if (autoUpdateable.length > 0) {
+                // Notify caller before installation begins
+                options.onInstalling?.(autoUpdateable.map(u => `${u.package}@${u.latestVersion}`));
                 // Get current installed packages
                 const installedPackages = {};
                 for (const update of autoUpdateable) {

package/packages/@monomind/cli/dist/src/update/validator.js

@@ -3,19 +3,28 @@
  * Ensures updates don't break the ecosystem
  */
 import * as semver from 'semver';
-// Known compatibility matrix between @monomind packages
+// Known compatibility matrix between monomind packages
 const COMPATIBILITY_MATRIX = {
-    '@monomind/cli': {
-        '@monomind/security': { minVersion: '3.0.0-alpha.1' },
+    '@monoes/monomindcli': {
+        'monofence-ai': { minVersion: '1.0.0' },
+    },
+    'monomind': {
+        '@monoes/monomindcli': { minVersion: '1.11.0' },
     },
 };
 // Known breaking changes by version
 const BREAKING_CHANGES = {
-    '@monomind/cli': {
-        '3.0.0': [
+    'monomind': {
+        '2.0.0': [
+            'CLI commands renamed from monomind:* to mastermind:*',
             'Memory API changed from key-value to vector-based',
-            'Hooks system completely redesigned',
+            'Hooks system redesigned with 17 hook types',
+        ],
+    },
+    '@monoes/monomindcli': {
+        '2.0.0': [
             'Agent spawning now requires type parameter',
+            'Swarm topology options changed',
         ],
     },
 };

package/packages/@monomind/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.11.9",
+  "version": "1.11.11",
   "type": "module",
   "description": "Monomind CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",