@really-knows-ai/foundry 3.6.1 → 3.6.3

package/dist/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [3.6.3] - 2026-05-26
+
+### Fixed
+
+- Validator script crashes now surface a single clear error ("Validator produced no valid output — check the script for syntax errors") instead of 20+ individual "Invalid JSON" parse errors from the stack trace.
+
+## [3.6.2] - 2026-05-25
+
+### Fixed
+
+- `captureForgeContext` now only captures unresolved feedback items (`open`/`rejected`) instead of all items. Previously it captured resolved items too, causing `enforceForgeContract` to reject them and `revertAll` to force-reopen the entire batch — creating an infinite forge loop.
+- Extracted validation guard functions into `src/scripts/lib/orchestrate-guards.js` to stay within the `max-lines` limit.
+- Fixed a missing `isDuplicateConsolidation` function that was referenced but never defined.
+
 ## [3.6.1] - 2026-05-25
 
 ### Fixed

package/dist/scripts/lib/orchestrate-guards.js

@@ -0,0 +1,67 @@
+// Foundry v2.3.0 orchestrate guards: validation guards for cycle orchestration.
+
+import { parseFrontmatter } from './workfile.js';
+import { stageBaseOf } from './stage-guard.js';
+import { violation } from '../orchestrate-cycle.js';
+
+function isDuplicateConsolidation(lastStage, activeStage) {
+  return lastStage && lastStage.stage === activeStage.stage;
+}
+
+export function guardNoWorkMd(io) {
+  if (!io.exists('WORK.md')) return violation('no WORK.md; flow skill must create it first');
+  return null;
+}
+
+export function guardMissingCycleId(io) {
+  const workContent = io.readFile('WORK.md');
+  const fm = parseFrontmatter(workContent);
+  if (!fm.cycle) return violation('WORK.md frontmatter missing cycle field', ['WORK.md']);
+  return { cycleId: fm.cycle, workContent };
+}
+
+export function guardSetupInconsistent(lastResult) {
+  if (lastResult) return violation('inconsistent state: lastResult provided but WORK.md still needs setup', ['WORK.md']);
+  return null;
+}
+
+export function guardOrphanedStage(activeStage, lastResult) {
+  if (activeStage && !lastResult) {
+    return violation(
+      `prior stage ${activeStage.stage} orphaned — no lastResult provided but active stage exists. ` +
+      `Likely cause: previous orchestrate call returned dispatch but caller did not follow up.`,
+      [],
+    );
+  }
+  return null;
+}
+
+export function guardMissingLastStage(lastStage) {
+  if (!lastStage) return violation('lastResult provided but no last stage recorded — orphaned state');
+  return null;
+}
+
+function checkLastResultsConflict(args) {
+  if (args.lastResult !== undefined && args.lastResults !== undefined) return violation('lastResult and lastResults are mutually exclusive');
+  return null;
+}
+
+function checkLastResultsShape(args) {
+  if (args.lastResults === undefined) return null;
+  if (!Array.isArray(args.lastResults)) return violation('lastResults must be an array');
+  return null;
+}
+
+function checkLastResultsStageContext(args, activeStage, lastStage) {
+  if (args.lastResults === undefined) return null;
+  if (!activeStage) return violation('lastResults provided but no active stage exists');
+  if (stageBaseOf(activeStage.stage) !== 'appraise') return violation(`lastResults provided but active stage "${activeStage.stage}" is not an appraise stage`);
+  if (isDuplicateConsolidation(lastStage, activeStage)) return violation(`duplicate lastResults: consolidation already completed for this appraise stage "${activeStage.stage}"`);
+  return null;
+}
+
+export function guardLastResults(args, activeStage, lastStage) {
+  return checkLastResultsConflict(args)
+    ?? checkLastResultsShape(args)
+    ?? checkLastResultsStageContext(args, activeStage, lastStage);
+}

package/dist/scripts/lib/validation.js

@@ -197,6 +197,23 @@ export function collectValidatorResult(parseResult, lawId, validatorId, results)
   }
 }
 
+/**
+ * If every line of output was unparseable, the validator script itself is
+ * broken (syntax error, runtime crash, etc.). Replace the noise of 20+
+ * individual "Invalid JSON" errors with a single actionable message.
+ */
+export function checkForValidatorCrash(result) {
+  if (result.items.length === 0 && result.parseErrors.length > 0) {
+    return {
+      ...result,
+      parseErrors: [
+        `Validator produced no valid output (${result.parseErrors.length} unparseable lines). Check the validator script for syntax errors.`,
+      ],
+    };
+  }
+  return result;
+}
+
 /**
  * Execute a validator command and parse its JSONL output.
  */
@@ -209,14 +226,18 @@ export async function executeValidator(expanded, worktree, patterns) {
     });
     const { Readable } = await import('stream');
     const stream = Readable.from([output]);
-    return await parseValidatorJsonl(stream, patterns);
+    return checkForValidatorCrash(
+      await parseValidatorJsonl(stream, patterns),
+    );
   } catch (err) {
     // Validator command failed — prefer stdout for JSONL
     // (tools like rg exit 1 with results on stdout)
     const output = (err.stdout || err.stderr || err.message || '').trim();
     const { Readable } = await import('stream');
     const stream = Readable.from([output]);
-    return await parseValidatorJsonl(stream, patterns);
+    return checkForValidatorCrash(
+      await parseValidatorJsonl(stream, patterns),
+    );
   }
 }
 

package/dist/scripts/orchestrate.js

@@ -3,7 +3,6 @@
 // into a single entry point the LLM drives via a 3-line loop.
 
 import { runSort } from './sort.js';
-import { parseFrontmatter } from './lib/workfile.js';
 import matter from 'gray-matter';
 import { readActiveStage, readLastStage, writeActiveStage, clearActiveStage } from './lib/state.js';
 import { stageBaseOf } from './lib/stage-guard.js';
@@ -32,6 +31,7 @@ import {
 import { runQuench } from './quench-module.js';
 import { gatherAppraiseContext, consolidateAppraise } from './appraise-module.js';
 import { openFeedbackStore } from './lib/feedback-store.js';
+import { guardNoWorkMd, guardMissingCycleId, guardSetupInconsistent, guardOrphanedStage, guardMissingLastStage, guardLastResults } from './lib/orchestrate-guards.js';
 
 export {
   renderDispatchPrompt, synthesizeStages, computeOpenFeedback,
@@ -50,68 +50,6 @@ export function needsSetup(workMdContent) {
 // Main entry point
 // ---------------------------------------------------------------------------
 
-function guardNoWorkMd(io) {
-  if (!io.exists('WORK.md')) return violation('no WORK.md; flow skill must create it first');
-  return null;
-}
-
-function guardMissingCycleId(io) {
-  const workContent = io.readFile('WORK.md');
-  const fm = parseFrontmatter(workContent);
-  if (!fm.cycle) return violation('WORK.md frontmatter missing cycle field', ['WORK.md']);
-  return { cycleId: fm.cycle, workContent };
-}
-
-function guardSetupInconsistent(lastResult) {
-  if (lastResult) return violation('inconsistent state: lastResult provided but WORK.md still needs setup', ['WORK.md']);
-  return null;
-}
-
-function guardOrphanedStage(activeStage, lastResult) {
-  if (activeStage && !lastResult) {
-    return violation(
-      `prior stage ${activeStage.stage} orphaned — no lastResult provided but active stage exists. ` +
-      `Likely cause: previous orchestrate call returned dispatch but caller did not follow up.`,
-      [],
-    );
-  }
-  return null;
-}
-
-function guardMissingLastStage(lastStage) {
-  if (!lastStage) return violation('lastResult provided but no last stage recorded — orphaned state');
-  return null;
-}
-
-function checkLastResultsConflict(args) {
-  if (args.lastResult !== undefined && args.lastResults !== undefined) return violation('lastResult and lastResults are mutually exclusive');
-  return null;
-}
-
-function checkLastResultsShape(args) {
-  if (args.lastResults === undefined) return null;
-  if (!Array.isArray(args.lastResults)) return violation('lastResults must be an array');
-  return null;
-}
-
-function isDuplicateConsolidation(lastStage, activeStage) {
-  return lastStage && lastStage.stage === activeStage.stage;
-}
-
-function checkLastResultsStageContext(args, activeStage, lastStage) {
-  if (args.lastResults === undefined) return null;
-  if (!activeStage) return violation('lastResults provided but no active stage exists');
-  if (stageBaseOf(activeStage.stage) !== 'appraise') return violation(`lastResults provided but active stage "${activeStage.stage}" is not an appraise stage`);
-  if (isDuplicateConsolidation(lastStage, activeStage)) return violation(`duplicate lastResults: consolidation already completed for this appraise stage "${activeStage.stage}"`);
-  return null;
-}
-
-function guardLastResults(args, activeStage, lastStage) {
-  return checkLastResultsConflict(args)
-    ?? checkLastResultsShape(args)
-    ?? checkLastResultsStageContext(args, activeStage, lastStage);
-}
-
 function buildSortArgs(args, now) {
   return {
     cycleDef: args.cycleDef ?? null, mint: args.mint,
@@ -196,9 +134,16 @@ async function captureForgeContext(sortResult, args, preCheck, io) {
   const fgResult = await readForgeFilePatterns(preCheck.cycleId, io);
   if (!fgResult) return;
   const preVersion = await computeArtefactVersion('foundry', fgResult.outputType, io, args.cwd);
-  const items = openFeedbackStore('WORK.feedback.yaml', io).list();
+  const allItems = openFeedbackStore('WORK.feedback.yaml', io).list();
+  // Only capture unresolved items (open/rejected) — resolved items are terminal
+  // and presenting them to forge causes the contract to fail and revert them.
+  const unresolvedItems = allItems.filter(item => {
+    const state = item.history?.[0]?.state ?? 'open';
+    return state === 'open' || state === 'rejected';
+  });
   if (!io.exists('.foundry')) io.mkdir('.foundry');
-  io.writeFile(FORGE_CTX, JSON.stringify({ forgePreVersion: preVersion, forgeItems: items.map(i => ({ id: i.id })) }));
+  const ctx = { forgePreVersion: preVersion, forgeItems: unresolvedItems.map(i => ({ id: i.id })) };
+  io.writeFile(FORGE_CTX, JSON.stringify(ctx));
 }
 
 function countConsecutiveForgeFailures(io, cycleId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@really-knows-ai/foundry",
-  "version": "3.6.1",
+  "version": "3.6.3",
   "description": "A skill-driven framework for governed artefact generation with AI coding tools. Define your own artefact types, laws, and flows — Foundry handles the forge → quench → appraise pipeline with deterministic routing, quality gates, and iterative refinement.",
   "type": "module",
   "main": "dist/.opencode/plugins/foundry.js",