monomind 2.7.5 → 2.7.7

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/pin.mjs

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+/**
+ * Pin/unpin sub-commands as standalone skill shortcuts.
+ *
+ * Usage:
+ *   node <scripts_path>/pin.mjs pin <command>
+ *   node <scripts_path>/pin.mjs unpin <command>
+ *
+ * `pin audit` creates a lightweight audit skill that redirects to Monodesign's audit workflow.
+ * `unpin audit` removes that shortcut.
+ *
+ * The script discovers harness directories (.claude/skills, .cursor/skills, etc.)
+ * in the project root and creates/removes the pin in all of them.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync, readdirSync } from 'node:fs';
+import { basename, join, resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// All known harness directories
+const HARNESS_DIRS = [
+  '.claude', '.cursor', '.gemini', '.codex', '.agents',
+  '.trae', '.trae-cn', '.pi', '.opencode', '.kiro', '.rovodev',
+];
+
+const CODEX_HARNESSES = new Set(['.codex', '.agents']);
+
+// Valid sub-command names
+const VALID_COMMANDS = [
+  'craft', 'init', 'extract', 'document', 'shape',
+  'critique', 'audit',
+  'polish', 'bolder', 'quieter', 'distill', 'harden', 'onboard', 'live',
+  'animate', 'colorize', 'typeset', 'layout', 'delight', 'overdrive',
+  'clarify', 'adapt', 'optimize',
+];
+
+// Marker to identify pinned skills (so unpin doesn't delete user skills)
+const PIN_MARKER = '<!-- monodesign-pinned-skill -->';
+
+/**
+ * Walk up from startDir to find a project root.
+ */
+function findProjectRoot(startDir = process.cwd()) {
+  let dir = resolve(startDir);
+  while (dir !== '/') {
+    if (
+      existsSync(join(dir, 'package.json')) ||
+      existsSync(join(dir, '.git')) ||
+      existsSync(join(dir, 'skills-lock.json'))
+    ) {
+      return dir;
+    }
+    const parent = resolve(dir, '..');
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return resolve(startDir);
+}
+
+/**
+ * Find harness skill directories that have an monodesign skill installed.
+ */
+function findHarnessDirs(projectRoot) {
+  const dirs = [];
+  for (const harness of HARNESS_DIRS) {
+    const skillsDir = join(projectRoot, harness, 'skills');
+    // Only pin in harness dirs that already have monodesign installed
+    const monodesignDir = join(skillsDir, 'monodesign');
+    if (existsSync(monodesignDir) || existsSync(join(skillsDir, 'i-monodesign'))) {
+      dirs.push(skillsDir);
+    }
+  }
+  return dirs;
+}
+
+/**
+ * Load command metadata (descriptions for pinned skills).
+ */
+function loadCommandMetadata() {
+  const metadataPath = join(__dirname, 'command-metadata.json');
+  if (existsSync(metadataPath)) {
+    return JSON.parse(readFileSync(metadataPath, 'utf-8'));
+  }
+  return {};
+}
+
+/**
+ * Generate a pinned skill's SKILL.md content.
+ */
+function commandPrefixForSkillsDir(skillsDir) {
+  return CODEX_HARNESSES.has(basename(dirname(skillsDir))) ? '$' : '/';
+}
+
+function generatePinnedSkill(command, metadata, commandPrefix) {
+  const desc = metadata[command]?.description || `Shortcut for ${commandPrefix}monodesign ${command}.`;
+  const hint = metadata[command]?.argumentHint || '[target]';
+
+  return `---
+name: ${command}
+description: "${desc}"
+argument-hint: "${hint}"
+user-invocable: true
+---
+
+${PIN_MARKER}
+
+This is a pinned shortcut for \`${commandPrefix}monodesign ${command}\`.
+
+Invoke ${commandPrefix}monodesign ${command}, passing along any arguments provided here, and follow its instructions.
+`;
+}
+
+/**
+ * Pin a command: create shortcut skill in all harness dirs.
+ */
+function pin(command, projectRoot) {
+  const metadata = loadCommandMetadata();
+  const harnessDirs = findHarnessDirs(projectRoot);
+
+  if (harnessDirs.length === 0) {
+    console.log('No harness directories with monodesign installed found.');
+    return false;
+  }
+
+  let created = 0;
+
+  for (const skillsDir of harnessDirs) {
+    const commandPrefix = commandPrefixForSkillsDir(skillsDir);
+    const content = generatePinnedSkill(command, metadata, commandPrefix);
+    // Check if skill already exists (and isn't a pin)
+    const skillDir = join(skillsDir, command);
+    if (existsSync(skillDir)) {
+      const existingMd = join(skillDir, 'SKILL.md');
+      if (existsSync(existingMd)) {
+        const existing = readFileSync(existingMd, 'utf-8');
+        if (!existing.includes(PIN_MARKER)) {
+          console.log(`  SKIP: ${skillDir} (non-pinned skill already exists)`);
+          continue;
+        }
+      }
+    }
+
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(join(skillDir, 'SKILL.md'), content, 'utf-8');
+    console.log(`  + ${skillDir}`);
+    created++;
+  }
+
+  if (created > 0) {
+    console.log(`\nPinned '${command}' as a standalone shortcut in ${created} location(s).`);
+    console.log('Use the pinned command directly in each harness.');
+  }
+
+  return created > 0;
+}
+
+/**
+ * Unpin a command: remove shortcut skill from all harness dirs.
+ */
+function unpin(command, projectRoot) {
+  const harnessDirs = findHarnessDirs(projectRoot);
+  let removed = 0;
+
+  for (const skillsDir of harnessDirs) {
+    const skillDir = join(skillsDir, command);
+    if (!existsSync(skillDir)) continue;
+
+    const skillMd = join(skillDir, 'SKILL.md');
+    if (!existsSync(skillMd)) continue;
+
+    // Safety: only remove if it's a pinned skill
+    const content = readFileSync(skillMd, 'utf-8');
+    if (!content.includes(PIN_MARKER)) {
+      console.log(`  SKIP: ${skillDir} (not a pinned skill)`);
+      continue;
+    }
+
+    rmSync(skillDir, { recursive: true, force: true });
+    console.log(`  - ${skillDir}`);
+    removed++;
+  }
+
+  if (removed > 0) {
+    console.log(`\nUnpinned '${command}' from ${removed} location(s).`);
+    console.log(`Use Monodesign's '${command}' workflow directly to access it.`);
+  } else {
+    console.log(`No pinned '${command}' shortcut found.`);
+  }
+
+  return removed > 0;
+}
+
+// --- CLI ---
+const [,, action, command] = process.argv;
+
+if (!action || !command) {
+  console.log('Usage: node pin.mjs <pin|unpin> <command>');
+  console.log(`\nAvailable commands: ${VALID_COMMANDS.join(', ')}`);
+  process.exit(1);
+}
+
+if (action !== 'pin' && action !== 'unpin') {
+  console.error(`Unknown action: ${action}. Use 'pin' or 'unpin'.`);
+  process.exit(1);
+}
+
+if (!VALID_COMMANDS.includes(command)) {
+  console.error(`Unknown command: ${command}`);
+  console.error(`Available commands: ${VALID_COMMANDS.join(', ')}`);
+  process.exit(1);
+}
+
+const root = findProjectRoot();
+
+if (action === 'pin') {
+  pin(command, root);
+} else {
+  unpin(command, root);
+}

package/packages/@monomind/cli/.claude/skills/monodesign/shape.md

@@ -0,0 +1,71 @@
+---
+name: monodesign-shape
+description: Shape the UX and UI for a feature before any code is written — produces a structured design brief through discovery, not guesswork. Design planning only; no code written. Output is a brief for monodesign:craft.
+type: design-sub-command
+argument-hint: "[feature description]"
+user-invocable: true
+---
+
+# Monodesign: Shape
+
+Shape the UX and UI for a feature before any code is written. This command produces a **design brief**: a structured artifact that guides implementation through discovery.
+
+**Scope**: Design planning only. No code written. Output: a design brief for `/monodesign craft`.
+
+## Setup
+Read `PRODUCT.md` and (if present) `DESIGN.md` from the project root before starting. These are required anchors.
+
+Read `reference/shape.md` from the monodesign skill directory for the full command flow.
+
+## Phase 1: Discovery Interview
+
+Do NOT write any code or make design decisions during this phase. Ask 2–3 questions per round, then wait for answers. Have a natural dialogue; don't dump all questions at once.
+
+**Purpose & Context**
+- What is this feature for? What problem does it solve?
+- Who specifically will use it? (Role, context, frequency — not "users")
+- What's the user's state of mind when they reach this? (Rushed? Exploring? Anxious?)
+
+**Content & Data**
+- What content or data does this display or collect?
+- What are the realistic ranges? (0 items, typical, max, edge cases)
+- What are the empty state, error state, first-time use, power-user scenarios?
+
+**Design Direction** — force a visual decision on three fronts:
+- **Color strategy**: Restrained / Committed / Full palette / Drenched
+- **Theme via scene sentence**: one sentence of physical context that forces dark vs. light
+- **Two or three named anchor references** — specific products, brands, objects (not adjectives)
+
+**Scope** — always ask explicitly:
+- Fidelity: Sketch / mid-fi / high-fi / production-ready?
+- Breadth: One screen / a flow / a whole surface?
+- Time intent: Quick exploration or polish until it ships?
+
+## Phase 2: Brief Synthesis
+
+After the discovery round, synthesize and present a structured **Design Brief**:
+
+```
+## Design Brief: [Feature Name]
+
+**User**: [concrete description]
+**Problem**: [one sentence]
+**Success**: [measurable outcome]
+**User state**: [emotional/contextual state]
+
+**Content**: [what's displayed/collected + realistic ranges]
+**Edge cases**: [empty, error, overload, first-use]
+
+**Visual direction**:
+- Color strategy: [Restrained|Committed|Full palette|Drenched]
+- Theme: [dark|light] — [scene sentence]
+- References: [3 named references]
+
+**Scope**: [fidelity] / [breadth] / [time intent]
+```
+
+Stop and wait for explicit user confirmation before advancing to `/monodesign craft`. Do not start coding until the brief is approved.
+
+## Assert-then-confirm
+
+When PRODUCT.md and the prompt make one option obvious, name it and ask the user to confirm or override. Don't present four-option menus when the answer is already clear.

package/packages/@monomind/cli/.claude/skills/monodesign/teach.md

@@ -0,0 +1,18 @@
+---
+name: monodesign-teach
+description: Alias of /monodesign init — set up a project for monodesign by producing PRODUCT.md (strategic context), optionally DESIGN.md (visual system), and pre-configuring live mode.
+type: design-sub-command
+argument-hint: "[project path or description]"
+user-invocable: true
+---
+
+# Monodesign: Teach (alias of Init)
+
+`teach` is the historical name for the setup command and remains fully supported; it is an alias of `init`. Both invocations behave identically.
+
+Follow `commands/init.md` and the authoritative flow in `reference/init.md` from the monodesign skill directory: one codebase crawl plus a short strategic interview produces **PRODUCT.md** (register, users, purpose, brand personality, anti-references, design principles), offers **DESIGN.md** via `/monodesign document`, and pre-configures `.monodesign/live/config.json` for `/monodesign live`.
+
+Notes preserved from the teach era:
+
+- A legacy `.monodesign.md` at the project root is auto-renamed to `PRODUCT.md` by the context loader; mention this once and merge into that content rather than starting fresh.
+- If teach was invoked as a setup blocker by another monodesign command, complete the init flow, then resume the original task with the fresh context.

package/packages/@monomind/cli/.claude/skills/monodesign/typeset.md

@@ -0,0 +1,59 @@
+---
+name: monodesign-typeset
+description: Replace generic type defaults with fonts that reflect the brand and scale with intentional contrast — font selection, hierarchy, scale, and responsive type systems.
+type: design-sub-command
+argument-hint: "[target page, component, or whole site]"
+user-invocable: true
+---
+
+# Monodesign: Typeset
+
+Typography carries most of the information on the page. Replace generic defaults (Inter, Roboto, system fallback at flat scale) with type that reflects the brand and scales with intentional contrast.
+
+Read `reference/typeset.md` and `reference/typography.md` from the monodesign skill directory for the full protocol.
+
+## Register
+
+**Brand**: font selection procedure in `reference/brand.md`. Fluid `clamp()` scale, ≥1.25 ratio between steps.
+
+**Product**: system fonts and familiar sans stacks are legitimate. One well-tuned family typically carries the whole UI. Fixed `rem` scale, 1.125–1.2 ratio.
+
+## Assess Current Typography
+
+**Font choices**
+- Are we using invisible defaults? (Inter, Roboto, Arial, Open Sans, system defaults)
+- Does the font match the brand personality?
+- Are there too many families? (More than 2–3 is almost always a mess)
+
+**Hierarchy**
+- Can you tell headings from body from captions at a glance?
+- Are sizes too close together? (14px, 15px, 16px = muddy hierarchy)
+- Are weight contrasts strong enough? (Medium vs Regular is barely visible)
+
+**Sizing & scale**
+- Is there a consistent type scale, or are sizes arbitrary?
+- Body text ≥16px?
+- Fixed `rem` scales for app UIs; fluid `clamp()` for marketing/content page headings
+
+## Typographic Rules (non-negotiable)
+
+- Cap body line length at **65–75ch**
+- Hero/display heading ceiling: `clamp()` max ≤ **6rem (~96px)**
+- Display letter-spacing floor: **≥ -0.04em** (anything tighter makes letters touch)
+- Use `text-wrap: balance` on h1–h3; `text-wrap: pretty` on long prose
+- Pair fonts on a contrast axis (serif + sans, geometric + humanist) — NOT similar families
+- Hierarchy through scale + weight contrast (≥1.25 ratio between steps)
+
+## Font Selection Process
+
+1. Load brand context from PRODUCT.md and DESIGN.md
+2. Identify brand personality from 3 words or the product description
+3. Propose 2–3 Google Fonts / variable font pairings with rationale
+4. Load one via `<link>` and demonstrate it on a real page section
+5. Iterate until the type feels native to the brand
+
+## Output
+
+- Updated CSS custom properties or tokens for `--font-heading`, `--font-body`, `--font-mono`
+- Fluid or fixed type scale as CSS custom properties
+- Applied to all heading levels and body copy on the target

package/packages/@monomind/cli/bin/cli.js

@@ -287,15 +287,22 @@ if (isMCPMode) {
   const isDaemonChild = cliArgs.includes('--foreground-worker-internal');
   cli.run().then(() => {
     if (!isDaemonChild) {
-      // Prefer a natural exit over process.exit(). Any command that touched
-      // embeddings has onnxruntime-node's thread pool loaded in-process (via
-      // memory-bridge -> @huggingface/transformers), and forcing exit out from
-      // under it aborts the process:
+      // Do NOT call process.exit() here. See
+      // docs/adrs/ADR-R001-onnxruntime-process-teardown.md.
+      //
+      // Any command that touched embeddings has onnxruntime-node's thread pool
+      // loaded in-process (memory-bridge -> @huggingface/transformers), and
+      // forcing exit out from under it aborts:
       //   libc++abi: terminating due to uncaught exception of type
       //   std::__1::system_error: mutex lock failed: Invalid argument
-      // — an exit code of 134 on `doctor`, `memory store`, `memory search`,
-      // etc., despite the command itself having succeeded. Disposing the
-      // pipeline first does NOT help; only letting the loop drain does.
+      // — exit code 134 on `doctor`, `memory store`, `memory search` etc.,
+      // despite the command itself having succeeded. Disposing the pipeline
+      // first does NOT help; only letting the loop drain does. (v2.7.4 bug,
+      // fixed 2.7.5. Guarded by src/__tests__/bin-cli-exit-path.test.ts.)
+      //
+      // NOTE the rule inverts for short-lived worker children, where onnx
+      // instead keeps the loop alive forever and you MUST force-exit — see
+      // src/routing/embed-worker.ts. Do not "unify" the two.
       //
       // So: publish the exit code and let node exit on its own once the loop
       // empties. The unref'd timer below still fires if something lingers

package/packages/@monomind/cli/dist/src/commands/agent-ops.js

@@ -180,6 +180,36 @@ export const healthCommand = {
         { command: 'monomind agent health -i agent-001 -d', description: 'Detailed health for specific agent' },
     ],
     action: async (ctx) => {
+        // --watch was declared (and documented as "refresh every 5s") but never
+        // read, so the command rendered once and exited. Mirrors the watch loop in
+        // commands/status.ts.
+        if (ctx.flags.watch) {
+            return watchAgentHealth(ctx);
+        }
+        return renderAgentHealth(ctx);
+    },
+};
+const WATCH_INTERVAL_MS = 5000;
+async function watchAgentHealth(ctx) {
+    const refresh = async () => {
+        process.stdout.write('\x1b[2J\x1b[H');
+        output.writeln(output.dim(`Last updated: ${new Date().toLocaleTimeString()} — refreshing every 5s. Press Ctrl+C to exit.`));
+        await renderAgentHealth(ctx);
+    };
+    await refresh();
+    const intervalId = setInterval(() => { void refresh(); }, WATCH_INTERVAL_MS);
+    // `once` so repeated invocations don't accumulate SIGINT handlers.
+    return new Promise((resolve) => {
+        process.once('SIGINT', () => {
+            clearInterval(intervalId);
+            output.writeln();
+            output.printInfo('Watch mode stopped');
+            resolve({ success: true });
+        });
+    });
+}
+async function renderAgentHealth(ctx) {
+    {
         const agentId = ctx.args[0] || ctx.flags.id;
         const detailed = ctx.flags.detailed;
         try {
@@ -242,6 +272,6 @@ export const healthCommand = {
             output.printError(error instanceof MCPClientError ? `Health check error: ${error.message}` : `Unexpected error: ${String(error)}`);
             return { success: false, exitCode: 1 };
         }
-    },
-};
+    }
+}
 //# sourceMappingURL=agent-ops.js.map

package/packages/@monomind/cli/dist/src/commands/browse-workflow.js

@@ -53,6 +53,35 @@ const runSubcommand = {
         const wf = await readWorkflow(filePath).catch(e => { output.printError(e.message); return null; });
         if (!wf)
             return { success: false, exitCode: 1 };
+        // --items feeds the run's input set. Previously the flag was parsed and
+        // then dropped, so every run silently used the single empty default item.
+        let items;
+        const itemsFlag = ctx.flags.items;
+        if (itemsFlag) {
+            const itemsPath = isAbsolute(itemsFlag) ? itemsFlag : resolve(ctx.cwd, itemsFlag);
+            let parsed;
+            try {
+                const { readFile } = await import('fs/promises');
+                parsed = JSON.parse(await readFile(itemsPath, 'utf8'));
+            }
+            catch (e) {
+                output.printError(`Cannot read items file ${itemsPath}: ${e.message}`);
+                return { success: false, exitCode: 1 };
+            }
+            if (!Array.isArray(parsed)) {
+                output.printError(`Items file ${itemsPath} must contain a JSON array`);
+                return { success: false, exitCode: 1 };
+            }
+            // Accept both the engine's `{ data: {...} }` envelope and a bare array
+            // of objects, which is the shape people naturally write by hand.
+            items = parsed.map((entry) => {
+                const rec = entry;
+                return rec && typeof rec === 'object' && 'data' in rec && typeof rec.data === 'object' && rec.data !== null
+                    ? { data: rec.data }
+                    : { data: (rec ?? {}) };
+            });
+            output.printInfo(`Loaded ${items.length} input item(s) from ${itemsFlag}`);
+        }
         const port = ctx.flags.port ?? 4243;
         const dashboard = getDashboardServer(port);
         if (!ctx.flags['no-dashboard']) {
@@ -65,6 +94,7 @@ const runSubcommand = {
         spinner.start();
         const record = await runWorkflow(wf, {
             onEvent: (ev) => dashboard.broadcast(ev),
+            ...(items ? { items } : {}),
         });
         if (record.status === 'completed') {
             spinner.succeed(`Done — ${record.itemsProcessed} items in ${((record.completedAt - record.startedAt) / 1000).toFixed(1)}s`);

package/packages/@monomind/cli/dist/src/commands/cleanup.js

@@ -7,6 +7,11 @@
 import { output } from '../output.js';
 import { existsSync, lstatSync, rmSync, readdirSync, readFileSync, writeFileSync, mkdirSync, unlinkSync, statSync } from 'fs';
 import { join, dirname } from 'path';
+// Static imports: this package is ESM ("type": "module"), so a bare require()
+// here throws "require is not defined" in the built output even though it
+// typechecks and passes tests. Guarded by no-cjs-require-in-esm.test.ts.
+import { execSync } from 'node:child_process';
+import { homedir } from 'node:os';
 /**
  * Artifact directories and files that monomind/monomind may create
  */
@@ -381,7 +386,6 @@ export const cleanupCommand = {
             // process actually looks like ours before signaling it.
             const looksLikeOurProcess = (pid) => {
                 try {
-                    const { execSync } = require('child_process');
                     const cmd = execSync(`ps -p ${pid} -o command=`, { timeout: 2000, encoding: 'utf-8' }).trim();
                     // Covers direct `node ...` spawns as well as the npx fallback in
                     // control-start.cjs's findCliPath(), which shows up in `ps` as
@@ -427,7 +431,7 @@ export const cleanupCommand = {
             }
             // Kill stale MCP server processes
             const mcpPidPaths = [
-                join(require('os').homedir(), '.monomind', 'mcp.pid'),
+                join(homedir(), '.monomind', 'mcp.pid'),
                 join(cwd, '.monomind', 'mcp-server.pid'),
             ];
             for (const pp of mcpPidPaths) {

package/packages/@monomind/cli/dist/src/commands/hooks-extended-commands.js

@@ -200,7 +200,7 @@ export const notifyCommand = {
     options: [
         { name: 'message', short: 'm', type: 'string', description: 'Notification message', required: true },
         { name: 'level', short: 'l', type: 'string', description: 'Level: info, warn, error', default: 'info' },
-        { name: 'channel', short: 'c', type: 'string', description: 'Notification channel', default: 'console' },
+        { name: 'channel', short: 'c', type: 'string', description: 'Notification channel (only "console" is implemented)', default: 'console' },
     ],
     examples: [
         { command: 'monomind hooks notify -m "Build complete"', description: 'Send info notification' },
@@ -213,6 +213,14 @@ export const notifyCommand = {
             output.printError('Message is required: --message "your message"');
             return { success: false, exitCode: 1 };
         }
+        // Console is the only delivery mechanism that exists. Accepting
+        // `--channel slack` and then printing to the console anyway would tell the
+        // user their message went somewhere it did not.
+        const channel = ctx.flags.channel || 'console';
+        if (channel !== 'console') {
+            output.writeln(output.warning(`Channel "${channel}" is not implemented — delivering to console. ` +
+                `Only "console" is supported today.`));
+        }
         const timestamp = new Date().toISOString();
         if (level === 'error') {
             output.printError(`[${timestamp}] ${message}`);
@@ -229,7 +237,7 @@ export const notifyCommand = {
             await storeEntry({ key: `notify-${Date.now()}`, value: `[${level}] ${message}`, namespace: 'notifications' });
         }
         catch { /* memory not available */ }
-        return { success: true, data: { timestamp, level, message } };
+        return { success: true, data: { timestamp, level, message, channel: 'console' } };
     }
 };
 //# sourceMappingURL=hooks-extended-commands.js.map