mindforge-cc 11.8.2 → 11.9.0

package/.mindforge/dynamic-workflows/scripts/ux-heuristic-audit.js

@@ -10,113 +10,111 @@ export const meta = {
   ],
 };
 
-export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
-  const HEURISTIC_SCHEMA = {
-    type: 'object',
-    properties: {
-      heuristic: { type: 'string' },
-      violations: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            component: { type: 'string' },
-            severity: { type: 'string', enum: ['critical', 'high', 'medium', 'low'] },
-            description: { type: 'string' },
-            recommendation: { type: 'string' },
-          },
-          required: ['severity', 'description', 'recommendation'],
+const HEURISTIC_SCHEMA = {
+  type: 'object',
+  properties: {
+    heuristic: { type: 'string' },
+    violations: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          component: { type: 'string' },
+          severity: { type: 'string', enum: ['critical', 'high', 'medium', 'low'] },
+          description: { type: 'string' },
+          recommendation: { type: 'string' },
         },
+        required: ['severity', 'description', 'recommendation'],
       },
-      score: { type: 'number' },
     },
-    required: ['heuristic', 'violations', 'score'],
-  };
+    score: { type: 'number' },
+  },
+  required: ['heuristic', 'violations', 'score'],
+};
 
-  const RANK_SCHEMA = {
-    type: 'object',
-    properties: {
-      rankedViolations: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            rank: { type: 'number' },
-            heuristic: { type: 'string' },
-            description: { type: 'string' },
-            severity: { type: 'string', enum: ['critical', 'high', 'medium', 'low'] },
-            impactScore: { type: 'number' },
-          },
-          required: ['rank', 'heuristic', 'description', 'severity', 'impactScore'],
+const RANK_SCHEMA = {
+  type: 'object',
+  properties: {
+    rankedViolations: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          rank: { type: 'number' },
+          heuristic: { type: 'string' },
+          description: { type: 'string' },
+          severity: { type: 'string', enum: ['critical', 'high', 'medium', 'low'] },
+          impactScore: { type: 'number' },
         },
+        required: ['rank', 'heuristic', 'description', 'severity', 'impactScore'],
       },
-      overallUsabilityScore: { type: 'number' },
     },
-    required: ['rankedViolations', 'overallUsabilityScore'],
-  };
+    overallUsabilityScore: { type: 'number' },
+  },
+  required: ['rankedViolations', 'overallUsabilityScore'],
+};
 
-  const BRIEF_SCHEMA = {
-    type: 'object',
-    properties: {
-      summary: { type: 'string' },
-      criticalFixes: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            issue: { type: 'string' },
-            heuristic: { type: 'string' },
-            fix: { type: 'string' },
-            effort: { type: 'string', enum: ['low', 'medium', 'high'] },
-          },
-          required: ['issue', 'heuristic', 'fix', 'effort'],
+const BRIEF_SCHEMA = {
+  type: 'object',
+  properties: {
+    summary: { type: 'string' },
+    criticalFixes: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          issue: { type: 'string' },
+          heuristic: { type: 'string' },
+          fix: { type: 'string' },
+          effort: { type: 'string', enum: ['low', 'medium', 'high'] },
         },
+        required: ['issue', 'heuristic', 'fix', 'effort'],
       },
-      quickWins: { type: 'array', items: { type: 'string' } },
     },
-    required: ['summary', 'criticalFixes', 'quickWins'],
-  };
+    quickWins: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['summary', 'criticalFixes', 'quickWins'],
+};
 
-  const target = args || 'current codebase (run from repo root)';
+const target = args || 'current codebase (run from repo root)';
 
-  phase('Scope');
-  log(`UX heuristic audit target: ${target}`);
+phase('Scope');
+log(`UX heuristic audit target: ${target}`);
 
-  const HEURISTICS = [
-    { label: 'visibility-of-status', prompt: `Evaluate Nielsen Heuristic #1 "Visibility of System Status" for: "${target}". Check: Does the UI always keep users informed about what is going on? Are loading states shown? Is progress communicated? Are confirmations displayed after actions? Score 0-100 (100=perfect) and list all violations with severity.` },
-    { label: 'match-real-world', prompt: `Evaluate Nielsen Heuristic #2 "Match Between System and the Real World" for: "${target}". Check: Does the UI use language and concepts familiar to users? Are metaphors and icons intuitive? Is information ordered naturally? Score 0-100 and list violations.` },
-    { label: 'user-control', prompt: `Evaluate Nielsen Heuristic #3 "User Control and Freedom" for: "${target}". Check: Can users undo/redo actions? Is there a clear exit from every state? Are emergency exits clearly marked? Can users cancel ongoing operations? Score 0-100 and list violations.` },
-    { label: 'consistency', prompt: `Evaluate Nielsen Heuristic #4 "Consistency and Standards" for: "${target}". Check: Do similar actions have similar appearance and behavior? Are platform conventions followed? Are labels consistent across screens? Score 0-100 and list violations.` },
-    { label: 'error-prevention', prompt: `Evaluate Nielsen Heuristic #5 "Error Prevention" for: "${target}". Check: Are good error-prone conditions eliminated? Are confirmation dialogs shown for destructive actions? Is inline validation used? Are form constraints visible before submission? Score 0-100 and list violations.` },
-    { label: 'recognition-over-recall', prompt: `Evaluate Nielsen Heuristic #6 "Recognition Rather Than Recall" for: "${target}". Check: Are options visible rather than remembered? Are instructions visible in context? Are recently used items surfaced? Are tooltips and help text available? Score 0-100 and list violations.` },
-    { label: 'flexibility', prompt: `Evaluate Nielsen Heuristic #7 "Flexibility and Efficiency of Use" for: "${target}". Check: Are there keyboard shortcuts for expert users? Can users customize frequent actions? Are there accelerators for power users? Does the UI serve both novice and expert? Score 0-100 and list violations.` },
-    { label: 'aesthetic-minimalism', prompt: `Evaluate Nielsen Heuristic #8 "Aesthetic and Minimalist Design" for: "${target}". Check: Does every element serve a purpose? Is irrelevant information removed? Are visual hierarchies clear? Is there excessive decoration or noise? Score 0-100 and list violations.` },
-    { label: 'error-recognition', prompt: `Evaluate Nielsen Heuristic #9 "Help Users Recognize, Diagnose, and Recover from Errors" for: "${target}". Check: Are error messages in plain language (not error codes)? Do they precisely indicate the problem? Do they constructively suggest solutions? Score 0-100 and list violations.` },
-    { label: 'help-docs', prompt: `Evaluate Nielsen Heuristic #10 "Help and Documentation" for: "${target}". Check: Is help easy to search? Is documentation focused on user tasks? Are concrete steps listed? Is context-sensitive help available? Score 0-100 and list violations.` },
-  ];
+const HEURISTICS = [
+  { label: 'visibility-of-status', prompt: `Evaluate Nielsen Heuristic #1 "Visibility of System Status" for: "${target}". Check: Does the UI always keep users informed about what is going on? Are loading states shown? Is progress communicated? Are confirmations displayed after actions? Score 0-100 (100=perfect) and list all violations with severity.` },
+  { label: 'match-real-world', prompt: `Evaluate Nielsen Heuristic #2 "Match Between System and the Real World" for: "${target}". Check: Does the UI use language and concepts familiar to users? Are metaphors and icons intuitive? Is information ordered naturally? Score 0-100 and list violations.` },
+  { label: 'user-control', prompt: `Evaluate Nielsen Heuristic #3 "User Control and Freedom" for: "${target}". Check: Can users undo/redo actions? Is there a clear exit from every state? Are emergency exits clearly marked? Can users cancel ongoing operations? Score 0-100 and list violations.` },
+  { label: 'consistency', prompt: `Evaluate Nielsen Heuristic #4 "Consistency and Standards" for: "${target}". Check: Do similar actions have similar appearance and behavior? Are platform conventions followed? Are labels consistent across screens? Score 0-100 and list violations.` },
+  { label: 'error-prevention', prompt: `Evaluate Nielsen Heuristic #5 "Error Prevention" for: "${target}". Check: Are good error-prone conditions eliminated? Are confirmation dialogs shown for destructive actions? Is inline validation used? Are form constraints visible before submission? Score 0-100 and list violations.` },
+  { label: 'recognition-over-recall', prompt: `Evaluate Nielsen Heuristic #6 "Recognition Rather Than Recall" for: "${target}". Check: Are options visible rather than remembered? Are instructions visible in context? Are recently used items surfaced? Are tooltips and help text available? Score 0-100 and list violations.` },
+  { label: 'flexibility', prompt: `Evaluate Nielsen Heuristic #7 "Flexibility and Efficiency of Use" for: "${target}". Check: Are there keyboard shortcuts for expert users? Can users customize frequent actions? Are there accelerators for power users? Does the UI serve both novice and expert? Score 0-100 and list violations.` },
+  { label: 'aesthetic-minimalism', prompt: `Evaluate Nielsen Heuristic #8 "Aesthetic and Minimalist Design" for: "${target}". Check: Does every element serve a purpose? Is irrelevant information removed? Are visual hierarchies clear? Is there excessive decoration or noise? Score 0-100 and list violations.` },
+  { label: 'error-recognition', prompt: `Evaluate Nielsen Heuristic #9 "Help Users Recognize, Diagnose, and Recover from Errors" for: "${target}". Check: Are error messages in plain language (not error codes)? Do they precisely indicate the problem? Do they constructively suggest solutions? Score 0-100 and list violations.` },
+  { label: 'help-docs', prompt: `Evaluate Nielsen Heuristic #10 "Help and Documentation" for: "${target}". Check: Is help easy to search? Is documentation focused on user tasks? Are concrete steps listed? Is context-sensitive help available? Score 0-100 and list violations.` },
+];
 
-  phase('Audit');
-  const auditResults = await parallel(
-    HEURISTICS.map(h => () => agent(h.prompt, { schema: HEURISTIC_SCHEMA, label: `heuristic:${h.label}`, phase: 'Audit' }))
-  );
+phase('Audit');
+const auditResults = await parallel(
+  HEURISTICS.map(h => () => agent(h.prompt, { schema: HEURISTIC_SCHEMA, label: `heuristic:${h.label}`, phase: 'Audit' }))
+);
 
-  phase('Rank');
-  const allViolations = auditResults.filter(Boolean).flatMap(r => (r.violations || []).map(v => ({ heuristic: r.heuristic, ...v })));
-  log(`${allViolations.length} violations found across 10 heuristics — ranking by severity`);
+phase('Rank');
+const allViolations = auditResults.filter(Boolean).flatMap(r => (r.violations || []).map(v => ({ heuristic: r.heuristic, ...v })));
+log(`${allViolations.length} violations found across 10 heuristics — ranking by severity`);
 
-  const violationSummary = allViolations.slice(0, 30).map(v => `[${v.severity}] ${v.heuristic || 'unknown'}: ${v.description}`).join('\n');
-  const ranked = await agent(
-    `Rank these UX violations by impact on user experience for: "${target}"\n\nViolations:\n${violationSummary}\n\nRank each by impact score (1-10), assign a rank number starting from 1 (most critical). Calculate an overall usability score (0-100) across all heuristics.`,
-    { schema: RANK_SCHEMA, label: 'rank' }
-  );
-  if (!ranked) { log('Warning: agent returned null for ranked, skipping'); return { target, error: 'agent-null' }; }
+const violationSummary = allViolations.slice(0, 30).map(v => `[${v.severity}] ${v.heuristic || 'unknown'}: ${v.description}`).join('\n');
+const ranked = await agent(
+  `Rank these UX violations by impact on user experience for: "${target}"\n\nViolations:\n${violationSummary}\n\nRank each by impact score (1-10), assign a rank number starting from 1 (most critical). Calculate an overall usability score (0-100) across all heuristics.`,
+  { schema: RANK_SCHEMA, label: 'rank' }
+);
+if (!ranked) { log('Warning: agent returned null for ranked, skipping'); return { target, error: 'agent-null' }; }
 
-  phase('Brief');
-  const topViolations = (ranked.rankedViolations || []).slice(0, 10).map(v => `[Rank ${v.rank}/${v.severity}] ${v.heuristic}: ${v.description}`).join('\n');
-  const brief = await agent(
-    `Create a UX fix brief for: "${target}"\n\nOverall usability score: ${ranked.overallUsabilityScore}/100\n\nTop violations:\n${topViolations}\n\nFor each critical/high violation provide: specific fix with design recommendation, implementation effort (low/medium/high). Also list quick wins (low effort, high impact fixes). Write a 2-3 sentence executive summary.`,
-    { schema: BRIEF_SCHEMA, label: 'brief' }
-  );
+phase('Brief');
+const topViolations = (ranked.rankedViolations || []).slice(0, 10).map(v => `[Rank ${v.rank}/${v.severity}] ${v.heuristic}: ${v.description}`).join('\n');
+const brief = await agent(
+  `Create a UX fix brief for: "${target}"\n\nOverall usability score: ${ranked.overallUsabilityScore}/100\n\nTop violations:\n${topViolations}\n\nFor each critical/high violation provide: specific fix with design recommendation, implementation effort (low/medium/high). Also list quick wins (low effort, high impact fixes). Write a 2-3 sentence executive summary.`,
+  { schema: BRIEF_SCHEMA, label: 'brief' }
+);
 
-  return { target, audits: auditResults.filter(Boolean), ranked, brief };
-}
+return { target, audits: auditResults.filter(Boolean), ranked, brief };

package/.mindforge/dynamic-workflows/scripts/verification-loop.js

@@ -0,0 +1,138 @@
+export const meta = {
+  name: 'verification-loop',
+  description: 'Implementer vs. scorer loop: one agent revises an artifact each round, a separate agent scores it against a fixed metric, and the implementer keeps re-attempting until the score is maxed or a round cap is hit',
+  whenToUse: 'When a task has a single well-defined quality metric worth pushing as high as possible, rather than a single fixed-count review pass — e.g. tightening a prompt, hardening a config, polishing a spec, or any "keep improving this until the score stops moving" task',
+  phases: [
+    { title: 'Scope', detail: 'pin the artifact, the metric, and the target/max-round cap' },
+    { title: 'Round', detail: 'implementer revises, scorer grades — repeats until target hit, score plateaus, or cap reached' },
+    { title: 'Report', detail: 'round-by-round score history and the final artifact' },
+  ],
+};
+
+const SCORE_SCHEMA = {
+  type: 'object',
+  properties: {
+    score: { type: 'number', description: '0-100. Same metric every round — do not silently redefine what "good" means between rounds.' },
+    breakdown: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          criterion: { type: 'string' },
+          points: { type: 'number' },
+          maxPoints: { type: 'number' },
+          note: { type: 'string' },
+        },
+        required: ['criterion', 'points', 'maxPoints', 'note'],
+      },
+    },
+    topFixes: {
+      type: 'array',
+      items: { type: 'string' },
+      description: 'the highest-leverage concrete changes that would raise the score next round, ordered by impact — not a full audit, just what to fix next',
+    },
+  },
+  required: ['score', 'breakdown', 'topFixes'],
+};
+
+const REVISE_SCHEMA = {
+  type: 'object',
+  properties: {
+    artifact: { type: 'string', description: 'the full revised artifact — not a diff, not a description of changes, the complete thing so the next scorer round has the real content' },
+    changesThisRound: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['artifact', 'changesThisRound'],
+};
+
+function parseArgs(raw) {
+  if (raw && typeof raw === 'string') {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith('{')) {
+      try {
+        return JSON.parse(trimmed);
+      } catch {
+        // Not valid JSON despite looking like it — fall through and treat as a plain task string.
+      }
+    }
+    return trimmed;
+  }
+  return raw || {};
+}
+
+const input = parseArgs(args);
+const task = typeof input === 'string' ? input : input.task;
+const metric = typeof input === 'string' ? null : input.metric;
+const targetScore = (typeof input === 'object' && input.targetScore) || 95;
+const maxRounds = (typeof input === 'object' && input.maxRounds) || 8;
+const plateauRounds = (typeof input === 'object' && input.plateauRounds) || 2;
+
+if (!task) {
+  throw new Error(
+    'verification-loop requires args = { task, metric, targetScore?, maxRounds?, plateauRounds? } ' +
+    'or args = "<task description that fully states the scoring metric>". ' +
+    'task = what to build/revise. metric = the exact rubric the scorer must grade against (if omitted, the scorer infers one from task and reports it every round for consistency). ' +
+    'targetScore default 95. maxRounds default 8. plateauRounds default 2 (stop early if score does not improve for this many consecutive rounds).'
+  );
+}
+
+phase('Scope');
+log(`Task: ${task}`);
+log(`Metric: ${metric || '(scorer will state and hold a fixed rubric)'}`);
+log(`Target: ${targetScore}/100, max ${maxRounds} rounds, stop after ${plateauRounds} flat rounds`);
+
+const scoreHistory = [];
+let currentArtifact = null;
+let roundsFlat = 0;
+
+phase('Round');
+for (let round = 1; round <= maxRounds; round++) {
+  if (budget.total && budget.remaining() < 20_000) {
+    log(`Stopping at round ${round - 1}: token budget nearly exhausted (${Math.round(budget.remaining() / 1000)}k left)`);
+    break;
+  }
+
+  const revisePrompt = currentArtifact
+    ? `Task: ${task}\n${metric ? `Metric the scorer grades against: ${metric}\n` : ''}\nCurrent artifact (round ${round - 1} score: ${scoreHistory.at(-1)?.score}):\n${currentArtifact}\n\nScorer feedback from last round, ordered by impact:\n${scoreHistory.at(-1)?.topFixes.map((f, i) => `${i + 1}. ${f}`).join('\n')}\n\nRevise the artifact to address as many of these as you genuinely can without breaking anything the scorer already gave points for. Return the complete revised artifact, not a diff.`
+    : `Task: ${task}\n${metric ? `Metric the scorer will grade against: ${metric}\n` : 'State the metric you are optimizing for, then '}Produce a first complete attempt at the artifact.`;
+
+  const revision = await agent(revisePrompt, { label: `implement:r${round}`, phase: 'Round', schema: REVISE_SCHEMA });
+  currentArtifact = revision.artifact;
+
+  const scorePrompt = `Score this artifact against the task's metric. Be strict and consistent with how you'd score any round of this same task — same rubric every time, do not grade on a curve relative to the previous round.\n\nTask: ${task}\n${metric ? `Metric: ${metric}\n` : ''}\nArtifact:\n${currentArtifact}`;
+  const scored = await agent(scorePrompt, { label: `score:r${round}`, phase: 'Round', schema: SCORE_SCHEMA });
+
+  scoreHistory.push(scored);
+  log(`Round ${round}: score ${scored.score}/100`);
+
+  if (scored.score >= targetScore) {
+    log(`Target ${targetScore} reached at round ${round} — stopping.`);
+    break;
+  }
+
+  const prevScore = scoreHistory.length > 1 ? scoreHistory[scoreHistory.length - 2].score : -Infinity;
+  if (scored.score <= prevScore) {
+    roundsFlat++;
+    if (roundsFlat >= plateauRounds) {
+      log(`Score has not improved for ${plateauRounds} consecutive rounds — stopping (diminishing returns, not a bug).`);
+      break;
+    }
+  } else {
+    roundsFlat = 0;
+  }
+}
+
+phase('Report');
+const finalScore = scoreHistory.at(-1);
+log(`Final score: ${finalScore.score}/100 across ${scoreHistory.length} round(s)`);
+
+return {
+  task,
+  metric: metric || '(scorer-inferred, see round 1 breakdown for the rubric it held)',
+  finalArtifact: currentArtifact,
+  finalScore: finalScore.score,
+  scoreHistory: scoreHistory.map((s, i) => ({ round: i + 1, score: s.score, topFixes: s.topFixes })),
+  stoppedBecause:
+    finalScore.score >= targetScore ? 'target-reached' :
+    roundsFlat >= plateauRounds ? 'plateaued' :
+    'max-rounds',
+};

package/.mindforge/dynamic-workflows/scripts/workflow-optimizer.js

@@ -0,0 +1,136 @@
+export const meta = {
+  name: 'workflow-optimizer',
+  description: 'Builder + scorer + a distinct process-optimizer role: each round scores the OUTPUT, but a separate optimizer agent reviews the round and proposes structural changes to the PROCESS itself (extra phases, different builder count, a corrected rubric) — the next round runs under the revised process, so the comparison is whether the workflow is getting better at producing good outputs, not just whether one artifact beat another',
+  whenToUse: 'When you want to improve a repeatable PROCESS across attempts, not just polish one output — e.g. "this review workflow keeps missing X, fix the workflow, not just this one review" or tuning how a builder+scorer pipeline should be structured before locking it in as a reusable workflow',
+  phases: [
+    { title: 'Scope', detail: 'pin the task family, the outcome metric, and any prior round history supplied by the caller' },
+    { title: 'Cycle', detail: 'builder runs under the current process -> scorer grades the output -> a separate process-optimizer proposes structural changes to the process for next round' },
+    { title: 'Report', detail: 'process-change history alongside the score trend, so a rising score can be attributed to real structural improvements' },
+  ],
+};
+
+const BUILD_SCHEMA = {
+  type: 'object',
+  properties: {
+    output: { type: 'string', description: 'the complete artifact produced this round' },
+    processFollowed: { type: 'string', description: 'plainly describe the steps you actually took to produce this — this is read by the process-optimizer, not the scorer, so be concrete about HOW you worked, not just what you made' },
+  },
+  required: ['output', 'processFollowed'],
+};
+
+const SCORE_SCHEMA = {
+  type: 'object',
+  properties: {
+    score: { type: 'number', description: '0-100 against the fixed outcome metric — same metric every round, this is what lets rounds be compared' },
+    gaps: { type: 'array', items: { type: 'string' }, description: 'specific shortfalls in THIS output, for context — not process suggestions, that is the optimizer\'s job' },
+  },
+  required: ['score', 'gaps'],
+};
+
+const OPTIMIZE_SCHEMA = {
+  type: 'object',
+  properties: {
+    expectFurtherGains: { type: 'boolean', description: 'false if you believe this process has converged and further optimization rounds would just be noise — this is the signal that ends the loop early, use it honestly' },
+    structuralChanges: {
+      type: 'array',
+      items: { type: 'string' },
+      description: 'concrete edits to the WORKFLOW\'s own steps/roles/gates for next round, each one sentence. Not edits to the artifact itself.',
+    },
+    diagnosis: { type: 'string', description: 'ONE sentence: why the process (not the artifact) produced this result.' },
+    revisedRubricNotes: { type: 'string', description: 'one sentence on anything the scorer should additionally weigh next round, or empty string if the rubric is fine as-is' },
+    revisedBuilderPrompt: { type: 'string', description: 'the complete next-round builder instructions, incorporating the structural changes above — self-contained, not a diff. Put this field LAST since it is the longest.' },
+  },
+  required: ['expectFurtherGains', 'structuralChanges', 'diagnosis', 'revisedRubricNotes', 'revisedBuilderPrompt'],
+};
+
+function parseArgs(raw) {
+  if (raw && typeof raw === 'string') {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith('{')) {
+      try {
+        return JSON.parse(trimmed);
+      } catch {
+        // Not valid JSON despite looking like it — fall through and treat as a plain taskFamily string.
+      }
+    }
+    return trimmed;
+  }
+  return raw || {};
+}
+
+const input = parseArgs(args);
+const taskFamily = typeof input === 'string' ? input : input.taskFamily;
+const metric = typeof input === 'object' ? input.metric : null;
+const maxRounds = (typeof input === 'object' && input.maxRounds) || 5;
+const priorHistory = (typeof input === 'object' && Array.isArray(input.priorHistory)) ? input.priorHistory : [];
+
+if (!taskFamily) {
+  throw new Error(
+    'workflow-optimizer requires args = { taskFamily, metric, maxRounds?, priorHistory? } or a plain string taskFamily. ' +
+    'taskFamily = the repeatable kind of task this process handles (not one single input — describe the CLASS of task, since the optimizer is improving a reusable process, not one artifact). ' +
+    'metric = the fixed outcome rubric every round is scored against. maxRounds default 5. ' +
+    'priorHistory = optional array of {round, structuralChanges, score} objects from a PREVIOUS invocation of this workflow, if you are resuming optimization across sessions — this script has no filesystem access, so true cross-session history must be passed back in by the caller from a prior run\'s returned processHistory.'
+  );
+}
+
+phase('Scope');
+log(`Task family: ${taskFamily}`);
+log(`Metric: ${metric || '(optimizer will state and hold a fixed metric)'}`);
+if (priorHistory.length) log(`Resuming with ${priorHistory.length} prior round(s) of history supplied by caller`);
+
+const processHistory = [...priorHistory];
+let currentBuilderPrompt = `Task family: ${taskFamily}\n${metric ? `You will be scored against: ${metric}\n` : ''}\nProduce a complete attempt. Also describe the process you followed to produce it.`;
+let currentRubricNotes = '';
+
+phase('Cycle');
+const startRound = processHistory.length + 1;
+const lastRound = processHistory.length + maxRounds;
+for (let round = startRound; round <= lastRound; round++) {
+  if (budget.total && budget.remaining() < 25_000) {
+    log(`Stopping at round ${round - 1}: token budget nearly exhausted (${Math.round(budget.remaining() / 1000)}k left)`);
+    break;
+  }
+
+  const build = await agent(currentBuilderPrompt, { label: `build:r${round}`, phase: 'Cycle', schema: BUILD_SCHEMA });
+
+  const scorePrompt = `Score this output against the task family's fixed metric — same rubric every round, do not adjust for effort or process, only the outcome.\n\nTask family: ${taskFamily}\n${metric ? `Metric: ${metric}\n` : ''}${currentRubricNotes ? `Additional weighting from process-optimizer review: ${currentRubricNotes}\n` : ''}\nOutput:\n${build.output}`;
+  const scored = await agent(scorePrompt, { label: `score:r${round}`, phase: 'Cycle', schema: SCORE_SCHEMA });
+
+  log(`Round ${round}: score ${scored.score}/100`);
+
+  const optimizePrompt = `You are the process-optimizer. Your job is NOT to improve this one output — a separate builder will do that next round using instructions you write. Your job is to diagnose WHY the current PROCESS produced this result, and propose structural changes to the process itself.\n\nTask family: ${taskFamily}\n${metric ? `Metric: ${metric}\n` : ''}\nCurrent builder instructions:\n${currentBuilderPrompt}\n\nThis round's process, as the builder described it:\n${build.processFollowed}\n\nThis round's score: ${scored.score}/100\nGaps identified: ${scored.gaps.join('; ')}\n\n${processHistory.length ? `Prior rounds' structural changes and scores:\n${processHistory.map(h => `Round ${h.round}: score ${h.score} — changed: ${h.structuralChanges.join('; ')}`).join('\n')}\n` : ''}\nPropose structural changes to the WORKFLOW (not the artifact) for the next round, and write the complete revised builder instructions that incorporate them.`;
+  const optimized = await agent(optimizePrompt, { label: `optimize:r${round}`, phase: 'Cycle', schema: OPTIMIZE_SCHEMA });
+
+  processHistory.push({
+    round,
+    score: scored.score,
+    gaps: scored.gaps,
+    diagnosis: optimized.diagnosis,
+    structuralChanges: optimized.structuralChanges,
+  });
+
+  log(`Round ${round} optimizer: ${optimized.structuralChanges.length} structural change(s) proposed for next round`);
+
+  if (!optimized.expectFurtherGains) {
+    log(`Optimizer judges the process has converged after round ${round} — stopping early rather than burning further rounds on noise.`);
+    break;
+  }
+
+  currentBuilderPrompt = optimized.revisedBuilderPrompt;
+  currentRubricNotes = optimized.revisedRubricNotes || currentRubricNotes;
+}
+
+phase('Report');
+const scoreTrend = processHistory.map(h => h.score);
+const improved = scoreTrend.length >= 2 && scoreTrend.at(-1) > scoreTrend[0];
+log(`Score trend across ${processHistory.length} round(s): ${scoreTrend.join(' -> ')}`);
+
+return {
+  taskFamily,
+  metric: metric || '(optimizer-held, see round 1 diagnosis for the rubric it used)',
+  processHistory,
+  finalBuilderPrompt: currentBuilderPrompt,
+  scoreTrend,
+  processImprovedOutcome: improved,
+  note: 'Pass this run\'s processHistory back in as args.priorHistory on a future invocation to continue optimizing the same process across sessions — this script holds no state of its own between runs.',
+};

package/.mindforge/dynamic-workflows/scripts/writer-reviewer.js

@@ -9,77 +9,75 @@ export const meta = {
   ],
 };
 
-export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
-  const IMPL_SCHEMA = {
-    type: 'object',
-    properties: {
-      description: { type: 'string' },
-      filesChanged: { type: 'array', items: { type: 'string' } },
-      approach: { type: 'string' },
-      diff: { type: 'string' },
-      testingDone: { type: 'string' },
-    },
-    required: ['description', 'filesChanged', 'approach', 'diff'],
-  };
+const IMPL_SCHEMA = {
+  type: 'object',
+  properties: {
+    description: { type: 'string' },
+    filesChanged: { type: 'array', items: { type: 'string' } },
+    approach: { type: 'string' },
+    diff: { type: 'string' },
+    testingDone: { type: 'string' },
+  },
+  required: ['description', 'filesChanged', 'approach', 'diff'],
+};
 
-  const REVIEW_SCHEMA = {
-    type: 'object',
-    properties: {
-      verdict: { type: 'string', enum: ['approve', 'request-changes', 'comment'] },
-      summary: { type: 'string' },
-      issues: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            severity: { type: 'string', enum: ['blocker', 'major', 'minor', 'nit'] },
-            location: { type: 'string' },
-            issue: { type: 'string' },
-            suggestion: { type: 'string' },
-          },
-          required: ['severity', 'location', 'issue', 'suggestion'],
+const REVIEW_SCHEMA = {
+  type: 'object',
+  properties: {
+    verdict: { type: 'string', enum: ['approve', 'request-changes', 'comment'] },
+    summary: { type: 'string' },
+    issues: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          severity: { type: 'string', enum: ['blocker', 'major', 'minor', 'nit'] },
+          location: { type: 'string' },
+          issue: { type: 'string' },
+          suggestion: { type: 'string' },
         },
+        required: ['severity', 'location', 'issue', 'suggestion'],
       },
-      positives: { type: 'array', items: { type: 'string' } },
-      approvalConditions: { type: 'array', items: { type: 'string' } },
     },
-    required: ['verdict', 'summary', 'issues'],
-  };
+    positives: { type: 'array', items: { type: 'string' } },
+    approvalConditions: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['verdict', 'summary', 'issues'],
+};
 
-  const task = args || 'No task specified — describe the implementation task in args.';
+const task = args || 'No task specified — describe the implementation task in args.';
 
-  phase('Implement');
-  log(`Writer implementing: ${task.slice(0, 80)}`);
-  const implementation = await agent(
-    `Implement this task in the current codebase: "${task}"\n\nWrite the complete implementation. After implementing, provide: (1) description of what you built, (2) list of files changed, (3) your implementation approach and key decisions, (4) a diff-style summary of changes (show old → new for key parts), (5) testing done or test commands to run.`,
-    { schema: IMPL_SCHEMA, label: 'writer' }
-  );
-  if (!implementation) { log('Warning: agent returned null for implementation, skipping'); return { task, error: 'agent-null' }; }
-  log(`Writer: ${implementation.description} | Changed: ${implementation.filesChanged.join(', ')}`);
+phase('Implement');
+log(`Writer implementing: ${task.slice(0, 80)}`);
+const implementation = await agent(
+  `Implement this task in the current codebase: "${task}"\n\nWrite the complete implementation. After implementing, provide: (1) description of what you built, (2) list of files changed, (3) your implementation approach and key decisions, (4) a diff-style summary of changes (show old → new for key parts), (5) testing done or test commands to run.`,
+  { schema: IMPL_SCHEMA, label: 'writer' }
+);
+if (!implementation) { log('Warning: agent returned null for implementation, skipping'); return { task, error: 'agent-null' }; }
+log(`Writer: ${implementation.description} | Changed: ${implementation.filesChanged.join(', ')}`);
 
-  phase('Review');
-  const diffContext = `TASK: ${task}\n\nCHANGES MADE:\n${implementation.diff}\n\nFILES CHANGED: ${implementation.filesChanged.join(', ')}\n\nTESTING: ${implementation.testingDone || 'not specified'}`;
-  const review = await agent(
-    `You are a senior code reviewer. Review this code change with fresh eyes — you were NOT involved in the implementation.\n\n${diffContext}\n\nReview for: correctness (does it actually solve the task?), edge cases (null/empty/large inputs), security (injection, auth, secrets), performance (N+1, unbounded loops), maintainability (naming, complexity, DRY). Give a verdict: approve / request-changes / comment. For each issue: severity (blocker/major/minor/nit), exact location, what's wrong, specific suggestion.`,
-    { schema: REVIEW_SCHEMA, label: 'reviewer' }
-  );
-  if (!review) { log('Warning: agent returned null for review, skipping'); return { task, implementation, error: 'agent-null' }; }
-  log(`Reviewer verdict: ${review.verdict} | ${review.issues.length} issues (${review.issues.filter(i => i.severity === 'blocker').length} blockers)`);
+phase('Review');
+const diffContext = `TASK: ${task}\n\nCHANGES MADE:\n${implementation.diff}\n\nFILES CHANGED: ${implementation.filesChanged.join(', ')}\n\nTESTING: ${implementation.testingDone || 'not specified'}`;
+const review = await agent(
+  `You are a senior code reviewer. Review this code change with fresh eyes — you were NOT involved in the implementation.\n\n${diffContext}\n\nReview for: correctness (does it actually solve the task?), edge cases (null/empty/large inputs), security (injection, auth, secrets), performance (N+1, unbounded loops), maintainability (naming, complexity, DRY). Give a verdict: approve / request-changes / comment. For each issue: severity (blocker/major/minor/nit), exact location, what's wrong, specific suggestion.`,
+  { schema: REVIEW_SCHEMA, label: 'reviewer' }
+);
+if (!review) { log('Warning: agent returned null for review, skipping'); return { task, implementation, error: 'agent-null' }; }
+log(`Reviewer verdict: ${review.verdict} | ${review.issues.length} issues (${review.issues.filter(i => i.severity === 'blocker').length} blockers)`);
 
-  phase('Verdict');
-  const blockers = review.issues.filter(i => i.severity === 'blocker');
-  const majors = review.issues.filter(i => i.severity === 'major');
+phase('Verdict');
+const blockers = review.issues.filter(i => i.severity === 'blocker');
+const majors = review.issues.filter(i => i.severity === 'major');
 
-  return {
-    task,
-    implementation,
-    review,
-    verdict: {
-      decision: review.verdict,
-      blockerCount: blockers.length,
-      majorCount: majors.length,
-      approved: review.verdict === 'approve',
-      requiredFixes: blockers.concat(majors).map(i => `[${i.severity.toUpperCase()}] ${i.location}: ${i.suggestion}`),
-    },
-  };
-}
+return {
+  task,
+  implementation,
+  review,
+  verdict: {
+    decision: review.verdict,
+    blockerCount: blockers.length,
+    majorCount: majors.length,
+    approved: review.verdict === 'approve',
+    requiredFixes: blockers.concat(majors).map(i => `[${i.severity.toUpperCase()}] ${i.location}: ${i.suggestion}`),
+  },
+};

package/.mindforge/memory/sync-manifest.json

@@ -1,6 +1,6 @@
 {
   "pattern-library.jsonl": {
-    "lastSync": "2026-07-01T06:53:59.643Z",
+    "lastSync": "2026-07-28T09:19:09.269Z",
     "localCount": 1
   }
 }