@monoes/monodesign 1.1.1 → 1.2.0

package/skill/scripts/critique-storage.mjs

@@ -18,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
@@ -27,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';
 
@@ -178,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) {
@@ -202,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;
     }
@@ -216,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/skill/scripts/live/session-store.mjs

@@ -2,7 +2,11 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { getLegacyLiveSessionsDir, getLiveSessionsDir } from '../lib/monodesign-paths.mjs';
 
-const COMPLETED_PHASES = new Set(['completed', 'discarded']);
+// steer_done is terminal too: a steer session has no pending work after the
+// agent's reply, and leaving it "active" makes live-status suggest recovery
+// for finished steers forever (the browser's trailing steer checkpoint would
+// also re-stamp phase "steer"; terminal phases ignore late checkpoints).
+const COMPLETED_PHASES = new Set(['completed', 'discarded', 'steer_done']);
 
 export function createLiveSessionStore({ cwd = process.cwd(), sessionId } = {}) {
   const rootDir = getLiveSessionsDir(cwd);

package/src/rules.ts

@@ -1,20 +1,58 @@
 /**
  * Shared design rules — the invariants every monodesign generation must satisfy.
  * These mirror the "Absolute bans" and "Shared design laws" in the skill.
+ *
+ * Where a ban has a corresponding mechanical detector rule in the engine
+ * registry (cli/engine/registry/antipatterns.mjs), its id and description are
+ * pulled from that registry at load time instead of being hand-copied here —
+ * one source of truth, no drift between "what generation avoids" and "what
+ * detection flags". Bans with no `engineRuleId` are composition/judgment
+ * calls the detector cannot mechanically check (holistic layout patterns);
+ * they exist here for generation-time guidance only.
  */
 
-export const ABSOLUTE_BANS = [
+// Typed as plain string so tsc emits a true dynamic import instead of trying
+// to type-resolve the untyped .mjs engine module (matches antipatterns.ts).
+const REGISTRY_SPECIFIER: string = '../cli/engine/registry/antipatterns.mjs';
+
+interface EngineRuleEntry {
+  id: string;
+  name: string;
+  description: string;
+}
+
+let registryPromise: Promise<EngineRuleEntry[] | null> | undefined;
+
+async function loadRegistry(): Promise<EngineRuleEntry[] | null> {
+  registryPromise ??= import(REGISTRY_SPECIFIER).then(
+    (mod) => (mod as { ANTIPATTERNS: EngineRuleEntry[] }).ANTIPATTERNS,
+    () => null,
+  );
+  return registryPromise;
+}
+
+export interface AbsoluteBan {
+  id: string;
+  rule: string;
+  description: string;
+  /** Engine registry rule id this ban is mechanically detected by, if any. */
+  engineRuleId?: string;
+}
+
+const ABSOLUTE_BANS_STATIC: AbsoluteBan[] = [
   {
-    id: 'side-stripe',
+    id: 'side-tab',
     rule: 'No side-stripe borders',
     description:
       'border-left or border-right > 1px as a colored accent on cards/list items/callouts is never intentional. Rewrite with full borders, background tints, leading numbers/icons, or nothing.',
+    engineRuleId: 'side-tab',
   },
   {
     id: 'gradient-text',
     rule: 'No gradient text',
     description:
       'background-clip:text with a gradient is decorative and never meaningful. Use a single solid color; emphasis via weight or size.',
+    engineRuleId: 'gradient-text',
   },
   {
     id: 'glassmorphism-default',
@@ -40,7 +78,26 @@ export const ABSOLUTE_BANS = [
     description:
       'Modals are usually laziness. Exhaust inline / progressive disclosure alternatives first.',
   },
-] as const;
+];
+
+/** Static ban list — id/rule/description as authored here (may drift from the engine registry's wording for bans that also have a detector rule). */
+export const ABSOLUTE_BANS = ABSOLUTE_BANS_STATIC;
+
+/**
+ * Same ban list, with descriptions for detector-backed bans (`engineRuleId`
+ * set) replaced by the live text from the engine registry. Falls back to the
+ * static description when the registry can't be loaded (e.g. package not
+ * fully installed) or the referenced rule id is missing.
+ */
+export async function getAbsoluteBans(): Promise<AbsoluteBan[]> {
+  const registry = await loadRegistry();
+  if (!registry) return ABSOLUTE_BANS_STATIC;
+  const byId = new Map(registry.map((r) => [r.id, r]));
+  return ABSOLUTE_BANS_STATIC.map((ban) => {
+    const engineRule = ban.engineRuleId ? byId.get(ban.engineRuleId) : undefined;
+    return engineRule ? { ...ban, description: engineRule.description } : ban;
+  });
+}
 
 export const COLOR_STRATEGIES = ['restrained', 'committed', 'full-palette', 'drenched'] as const;
 export type ColorStrategy = (typeof COLOR_STRATEGIES)[number];