@really-knows-ai/foundry 3.6.0 → 3.6.2

package/dist/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [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
+
+- Forge contract enforcement now correctly handles the first forge run with no prior feedback items (empty batch). Previously the contract failed with "forge changed artefacts but did not mark any feedback as actioned", creating a system feedback item that cascaded into an infinite forge loop.
+- Forge history entries now include the actual list of changed files detected by git diff, instead of showing an empty `changed_files: []` for every entry.
+
 ## [3.6.0] - 2026-05-25
 
 ### Added

package/dist/scripts/lib/forge-contract.js

@@ -76,15 +76,24 @@ function checkBatchVersion(items, feedbackStore, cycleId, postVersion, preVersio
 /**
  * Enforce the forge contract on a batch of items presented to forge.
  *
- * Two-level check:
+ * When `items` is not a non-empty array (null, undefined, or []), the
+ * contract passes immediately without side-effects. This covers the
+ * initial forge run where no feedback exists yet.
+ *
+ * Two-level check when items are present:
  * 1. Per-item: every item must end in 'actioned' or 'wont-fix'.
  * 2. Batch-level: artefact version semantics must be consistent.
  *
- * @param {{ items: Array<{id: string}>, preVersion: string, postVersion: string,
- *   feedbackStore: object, cycleId: string }} params
+ * @param {{ items?: Array<{id: string}> | null, preVersion: string,
+ *          postVersion: string, feedbackStore: object, cycleId: string }} params
  * @returns {{ contractPassed: boolean }}
  */
 export function enforceForgeContract({ items, preVersion, postVersion, feedbackStore, cycleId }) {
+  if (!Array.isArray(items) || items.length === 0) {
+    // Empty batch means forge had no prior feedback to respond to.
+    // This is the first forge run or all items were already resolved.
+    return { contractPassed: true };
+  }
   if (!checkPerItemResponse(items, feedbackStore, cycleId, postVersion)) {
     return { contractPassed: false };
   }

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/orchestrate-phases.js

@@ -307,7 +307,9 @@ export async function finaliseStage(args) {
   const iteration = getIteration(historyPath, cycleId, io);
   const openFeedback = computeOpenFeedback(io);
   writeHistoryEntries({
-    historyPath, cycleId, lastStage, iteration, openFeedback, io,
+    historyPath, cycleId,
+    lastStage: { ...lastStage, changedFiles: finalizeResult.changedFiles },
+    iteration, openFeedback, io,
     artefactVersion: postVersion, contractPassed,
   });
   const commitErr = await tryStageCommit(git, lastStage, cycleId, io);

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.0",
+  "version": "3.6.2",
   "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",