monomind 2.5.2 → 2.5.4

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/context-signals.mjs

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-// Pattern adapted from impeccable (Apache-2.0) — rebranded for monomind
 /**
  * Context-signals gatherer for the bare Monodesign invocation
  * (no-argument) path. Collects cheap, deterministic signals about the current
@@ -24,6 +23,7 @@ import { fileURLToPath } from 'node:url';
 import { execFileSync } from 'node:child_process';
 import { loadContext, extractRegister, extractPlatform } from './context.mjs';
 import { getCritiqueDir } from './lib/monodesign-paths.mjs';
+import { readTrend, extractIssueLines, trendDirection } from './critique-storage.mjs';
 
 /** Is there code here at all, or just context files / an empty repo? */
 function hasCode(cwd) {
@@ -37,7 +37,10 @@ function hasCode(cwd) {
 /**
  * The most recent critique snapshot across all targets. Filenames are
  * timestamp-prefixed (`<iso>__<slug>.md`), so a lexical sort is chronological.
- * Parses the small frontmatter for score + P0/P1 counts.
+ * Parses the small frontmatter for score + P0/P1 counts, plus two "design
+ * health" extras: the score trend for the same slug (last 3 runs, with a
+ * direction) and the open [P0] issue titles from the snapshot body — enough
+ * for a session to start design-health-aware without an LLM pass.
  */
 function latestCritique(cwd) {
   try {
@@ -56,13 +59,43 @@ function latestCritique(cwd) {
       const n = Number(v);
       return Number.isFinite(n) ? n : null;
     };
+    const slug = get('slug');
+    // Trend across the last 3 runs for the same slug. Frontmatter written by
+    // critique-storage carries `total_score`; older/hand-written snapshots may
+    // carry `score` — accept either. Best-effort: never let this probe throw.
+    let trend = null;
+    try {
+      if (slug) {
+        const rows = readTrend(slug, { limit: 3, cwd });
+        const scores = rows
+          .map((r) => num(r.total_score ?? r.score))
+          .filter((n) => n !== null);
+        if (scores.length) trend = { scores, direction: trendDirection(scores) };
+      }
+    } catch { /* trend stays null */ }
+    let openP0 = [];
+    try {
+      openP0 = extractIssueLines(text).p0;
+    } catch { /* openP0 stays empty */ }
+    // Frontmatter key fallbacks: context fixtures use score/p0/p1, the
+    // critique flow's MONODESIGN_CRITIQUE_META uses total_score/p0_count/
+    // p1_count. `get` returns null for missing keys; keep null (not 0).
+    const numKey = (...keys) => {
+      for (const k of keys) {
+        const v = get(k);
+        if (v !== null) return num(v);
+      }
+      return null;
+    };
     return {
-      slug: get('slug'),
-      score: num(get('score')),
-      p0: num(get('p0')),
-      p1: num(get('p1')),
+      slug,
+      score: numKey('score', 'total_score'),
+      p0: numKey('p0', 'p0_count'),
+      p1: numKey('p1', 'p1_count'),
       timestamp: get('timestamp'),
       file: path.relative(cwd, path.join(dir, newest)),
+      trend,
+      openP0,
     };
   } catch {
     return null;

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

@@ -1,4 +1,3 @@
-// Pattern adapted from impeccable (Apache-2.0) — rebranded for monomind
 /**
  * Context loader: prints PRODUCT.md (and DESIGN.md if present) as one
  * markdown block on stdout, or prints a `NO_PRODUCT_MD:` message when no

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/critique-storage.mjs

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-// Pattern adapted from impeccable (Apache-2.0) — rebranded for monomind
 /**
  * Critique persistence helper.
  *
@@ -19,6 +18,13 @@
  *   node critique-storage.mjs write <slug> <snapshot-body-file>
  *   node critique-storage.mjs latest <slug>
  *   node critique-storage.mjs trend <slug> [limit]
+ *   node critique-storage.mjs recall <slug> [limit]
+ *
+ * `write` also best-effort mirrors a compact record of the snapshot into
+ * monomind's persistent memory (namespace `design-critique`) so design
+ * health survives across sessions. The mirror is fire-and-forget: if the
+ * monomind CLI is not installed it is skipped silently, and it can be
+ * disabled outright with MONODESIGN_NO_MEMORY=1.
  *
  * Note: there is intentionally no `ignore` subcommand. ignore.md is a plain
  * markdown file; the model reads it directly with its file-read tool. This
@@ -28,6 +34,7 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
+import { spawnSync } from 'node:child_process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { getCritiqueDir } from './lib/monodesign-paths.mjs';
 
@@ -179,6 +186,164 @@ export function readTrend(slug, { limit = 5, cwd = process.cwd() } = {}) {
   return slice.map((file) => parseFrontmatter(fs.readFileSync(file, 'utf-8')));
 }
 
+// ---- Monomind memory mirror --------------------------------------------
+
+const asFiniteNumber = (v) => {
+  const n = Number(v);
+  return Number.isFinite(n) ? n : null;
+};
+
+/**
+ * Locate a locally installed monomind CLI bin by climbing from `cwd`.
+ * Returns null when none is installed — the caller then tries
+ * `npx --no-install`, which also fails fast (and silently) when absent.
+ */
+function resolveMonomindBin(cwd) {
+  const name = process.platform === 'win32' ? 'monomind.cmd' : 'monomind';
+  let dir = path.resolve(cwd);
+  for (;;) {
+    const bin = path.join(dir, 'node_modules', '.bin', name);
+    try {
+      fs.accessSync(bin, fs.constants.X_OK);
+      return bin;
+    } catch { /* keep climbing */ }
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+/**
+ * Best-effort mirror of a snapshot's structured metadata into monomind's
+ * persistent memory (namespace `design-critique`, key `<project>-<slug>`,
+ * upserted), so design health is queryable across sessions via
+ * `monomind memory search`. Never throws and never fails the critique flow:
+ * if the monomind CLI is unavailable the call is skipped silently.
+ * Kill-switch: MONODESIGN_NO_MEMORY=1.
+ */
+export function mirrorToMemory({ slug, meta = {}, filePath, cwd = process.cwd(), now = new Date(), env = process.env }) {
+  if (!slug) return { mirrored: false, reason: 'no-slug' };
+  if (env.MONODESIGN_NO_MEMORY === '1') return { mirrored: false, reason: 'disabled' };
+  try {
+    const record = {
+      score: asFiniteNumber(meta.total_score ?? meta.score),
+      p0: asFiniteNumber(meta.p0_count ?? meta.p0),
+      p1: asFiniteNumber(meta.p1_count ?? meta.p1),
+      date: now.toISOString(),
+      slug,
+      path: filePath ? path.relative(cwd, filePath) : null,
+    };
+    const project = kebab(path.basename(path.resolve(cwd))) || 'project';
+    const key = `${project}-${slug}`;
+    const argv = [
+      'memory', 'store',
+      '--key', key,
+      '--value', JSON.stringify(record),
+      '--namespace', 'design-critique',
+      '--upsert',
+    ];
+    const bin = resolveMonomindBin(cwd);
+    const opts = { cwd, env, stdio: 'ignore', timeout: 15000 };
+    const run = bin
+      ? spawnSync(bin, argv, opts)
+      : spawnSync('npx', ['--no-install', 'monomind', ...argv], { ...opts, shell: process.platform === 'win32' });
+    if (run.error || run.status !== 0) return { mirrored: false, reason: 'cli-unavailable' };
+    return { mirrored: true, key };
+  } catch {
+    return { mirrored: false, reason: 'error' };
+  }
+}
+
+// ---- Recall (latest + trend + open items, one compact block) -----------
+
+/**
+ * Extract open issue titles tagged [P0] / [P1] from a snapshot body.
+ * Matches the critique report's "**[P?] What**: ..." lines, but tolerates
+ * loose formatting: any line containing `[P0]`/`[P1]` counts, with the
+ * title taken from the text after the tag (markdown emphasis stripped).
+ */
+export function extractIssueLines(body, { max = 8 } = {}) {
+  const issues = { p0: [], p1: [] };
+  if (!body || typeof body !== 'string') return issues;
+  // Drop frontmatter so metadata lines never masquerade as issues.
+  const text = body.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, '');
+  for (const line of text.split(/\r?\n/)) {
+    const m = line.match(/\[(P0|P1)\]\s*(.*)/i);
+    if (!m) continue;
+    let title = m[2];
+    // "**[P0] Title**: explanation" → keep just the title.
+    const boldColon = title.indexOf('**:');
+    if (boldColon !== -1) title = title.slice(0, boldColon);
+    title = title.replace(/\*+/g, '').replace(/^[-–—\s]+/, '').replace(/[:\s]+$/, '').trim();
+    if (!title) continue;
+    const bucket = m[1].toUpperCase() === 'P0' ? issues.p0 : issues.p1;
+    if (bucket.length < max && !bucket.includes(title)) bucket.push(title);
+  }
+  return issues;
+}
+
+/**
+ * Direction of the last (up to) 3 finite scores: improving | declining |
+ * flat, or null when fewer than 2 scores exist.
+ */
+export function trendDirection(scores) {
+  const s = (scores || []).map(asFiniteNumber).filter((n) => n !== null).slice(-3);
+  if (s.length < 2) return null;
+  if (s[s.length - 1] > s[0]) return 'improving';
+  if (s[s.length - 1] < s[0]) return 'declining';
+  return 'flat';
+}
+
+/**
+ * Combined latest + trend + open-issue view for `slug`, or null when no
+ * snapshot exists. This backs the `recall` subcommand that polish/critique
+ * consume instead of separate latest+trend calls.
+ */
+export function readRecall(slug, { limit = 5, cwd = process.cwd() } = {}) {
+  const latest = readLatestSnapshot(slug, { cwd });
+  if (!latest) return null;
+  const trend = readTrend(slug, { limit, cwd });
+  const scores = trend.map((t) => asFiniteNumber(t.total_score ?? t.score));
+  return {
+    slug,
+    latest,
+    trend,
+    scores,
+    direction: trendDirection(scores),
+    issues: extractIssueLines(latest.body),
+  };
+}
+
+/** Render a recall result as a compact markdown block. */
+export function formatRecall(recall, { cwd = process.cwd() } = {}) {
+  const { slug, latest, trend, scores, direction, issues } = recall;
+  const meta = latest.meta;
+  const score = asFiniteNumber(meta.total_score ?? meta.score);
+  const p0 = asFiniteNumber(meta.p0_count ?? meta.p0);
+  const p1 = asFiniteNumber(meta.p1_count ?? meta.p1);
+  const lines = [`## Design health: \`${slug}\``];
+  lines.push(
+    `- Latest score: ${score !== null ? `${score}/40` : 'n/a'}`
+    + ` (P0: ${p0 ?? '?'}, P1: ${p1 ?? '?'})`
+    + (meta.timestamp ? ` — ${meta.timestamp}` : ''),
+  );
+  const arrows = scores.map((n) => (n === null ? '?' : n)).join(' → ');
+  lines.push(`- Trend (last ${trend.length}): ${arrows}${direction ? ` (${direction})` : ''}`);
+  if (issues.p0.length) {
+    lines.push('- Open P0:');
+    for (const t of issues.p0) lines.push(`  - ${t}`);
+  }
+  if (issues.p1.length) {
+    lines.push('- Open P1:');
+    for (const t of issues.p1) lines.push(`  - ${t}`);
+  }
+  if (!issues.p0.length && !issues.p1.length) {
+    lines.push('- No open P0/P1 lines found in the latest snapshot.');
+  }
+  lines.push(`- Snapshot: ${path.relative(cwd, latest.path)}`);
+  return lines.join('\n');
+}
+
 // ---- CLI ---------------------------------------------------------------
 
 function main(argv) {
@@ -203,6 +368,8 @@ function main(argv) {
         try { meta = JSON.parse(metaArg); } catch { /* ignore */ }
       }
       const out = writeSnapshot({ slug, meta, body: raw });
+      // Best-effort cross-session mirror; must never break the critique flow.
+      mirrorToMemory({ slug, meta, filePath: out });
       process.stdout.write(`${out}\n`);
       return;
     }
@@ -217,8 +384,14 @@ function main(argv) {
       process.stdout.write(JSON.stringify(rows, null, 2) + '\n');
       return;
     }
+    case 'recall': {
+      const recall = readRecall(args[0], { limit: args[1] ? Number(args[1]) : 5 });
+      if (!recall) { process.exit(2); }
+      process.stdout.write(`${formatRecall(recall)}\n`);
+      return;
+    }
     default:
-      process.stderr.write('usage: critique-storage.mjs <slug|write|latest|trend> [args]\n');
+      process.stderr.write('usage: critique-storage.mjs <slug|write|latest|trend|recall> [args]\n');
       process.exit(1);
   }
 }

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/detect-csp.mjs

@@ -1,4 +1,3 @@
-// Pattern adapted from impeccable (Apache-2.0) — rebranded for monomind
 /**
  * Scan a project tree for Content-Security-Policy signals and classify the
  * shape so the agent knows which patch template to propose.

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

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-// Pattern adapted from impeccable (Apache-2.0) — rebranded for monomind
 
 import fs from 'node:fs';
 import path from 'node:path';

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/detector/browser/injected/index.mjs

@@ -1,4 +1,3 @@
-// Pattern adapted from impeccable (Apache-2.0) — rebranded for monomind
 const IS_BROWSER = typeof window !== 'undefined';
 
 // ─── Section 7: Browser UI (IS_BROWSER only) ────────────────────────────────
@@ -1489,6 +1488,8 @@ if (IS_BROWSER) {
         ...checkElementClippedOverflowDOM(el).map(f => ({ type: f.id, detail: f.snippet })),
         ...checkElementGptBorderShadowDOM(el).map(f => ({ type: f.id, detail: f.snippet })),
         ...checkElementTextOverflowDOM(el).map(f => ({ type: f.id, detail: f.snippet })),
+        ...checkElementImageDimensionsDOM(el).map(f => ({ type: f.id, detail: f.snippet })),
+        ...checkElementSmallTouchTargetDOM(el).map(f => ({ type: f.id, detail: f.snippet })),
         ...checkElementDesignSystemDOM(el, designSystem, designSeen),
       ].filter(f => _ruleOk(f.type));
 
@@ -1548,6 +1549,29 @@ if (IS_BROWSER) {
       addBrowserFindings(groupMap, document.body, creamFindings);
     }
 
+    // Stylesheet-level accessibility rules (focus-visible, hover-only,
+    // dark-scheme). Serialize every same-origin stylesheet to CSS text and
+    // run the shared analyzers — cross-origin sheets throw on cssRules access
+    // and are skipped.
+    let stylesheetCssText = '';
+    for (const sheet of Array.from(document.styleSheets || [])) {
+      let rules;
+      try { rules = sheet.cssRules; } catch { continue; }
+      if (!rules) continue;
+      for (const rule of Array.from(rules)) {
+        try { stylesheetCssText += rule.cssText + '\n'; } catch { /* ignore */ }
+      }
+    }
+    const stylesheetFindings = [
+      ...checkFocusVisible(stylesheetCssText),
+      ...checkHoverOnlyAffordance(stylesheetCssText),
+      ...checkDarkSchemeContrast(stylesheetCssText),
+    ].map(f => ({ type: f.id, detail: f.snippet })).filter(f => _ruleOk(f.type));
+    if (stylesheetFindings.length > 0) {
+      pageLevelFindings.push(...stylesheetFindings);
+      addBrowserFindings(groupMap, document.body, stylesheetFindings);
+    }
+
     // Regex-on-HTML checks (shared with Node)
     // Clone the document and strip monodesign-live overlay nodes before the
     // regex scan, so the inspector's own inline styles (transitions on top/

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

@@ -1,4 +1,3 @@
-// Pattern adapted from impeccable (Apache-2.0) — rebranded for monomind
 import fs from 'node:fs';
 import path from 'node:path';
 

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/detector/design-system.mjs

@@ -1,4 +1,3 @@
-// Pattern adapted from impeccable (Apache-2.0) — rebranded for monomind
 import fs from 'node:fs';
 import path from 'node:path';