@really-knows-ai/foundry 3.4.0 → 3.5.1

package/dist/scripts/lib/attestation/attest.js

@@ -7,7 +7,6 @@
 import path from 'node:path';
 import { load as loadYaml } from 'js-yaml';
 import { parseFrontmatter } from '../workfile.js';
-import { parseArtefactsTable } from '../artefacts.js';
 import { parseAllHistoryEntries } from '../history.js';
 import { sha256Buffer } from './hash.js';
 import { buildAttestationPayload } from './payload.js';
@@ -21,19 +20,11 @@ function readWorkFiles(cwd, io) {
 
   return {
     workText: io.readFile(workPath),
-    historyText: io.fileExists(historyPath) ? io.readFile(historyPath) : '',
-    feedbackText: io.fileExists(feedbackPath) ? io.readFile(feedbackPath) : '',
+    historyText: io.exists(historyPath) ? io.readFile(historyPath) : '',
+    feedbackText: io.exists(feedbackPath) ? io.readFile(feedbackPath) : '',
   };
 }
 
-function checkBlockedArtefacts(artefacts) {
-  const blocked = artefacts.filter(a => a.status === 'blocked');
-  if (blocked.length > 0) {
-    return `foundry_attest: cycle has blocked artefact(s): ${blocked.map(a => a.file).join(', ')}`;
-  }
-  return null;
-}
-
 function checkMissingStages(frontmatter, historyText) {
   const entries = parseAllHistoryEntries(historyText);
   const completed = new Set(entries.map(e => e.stage));
@@ -54,10 +45,7 @@ function checkUnresolvedFeedback(feedbackText) {
   return null;
 }
 
-function findCycleError(frontmatter, artefacts, historyText, feedbackText) {
-  const blockedError = checkBlockedArtefacts(artefacts);
-  if (blockedError) return blockedError;
-
+function findCycleError(frontmatter, historyText, feedbackText) {
   const missingError = checkMissingStages(frontmatter, historyText);
   if (missingError) return missingError;
 
@@ -73,7 +61,9 @@ function computeDiffSha(execGit, baseBranch) {
 
 export async function buildAttestation({
   cwd,
+  foundryDir,
   baseBranch,
+  branchBaseSha,
   goalText,
   archiveBranch,
   archiveTipSha,
@@ -82,20 +72,22 @@ export async function buildAttestation({
 }) {
   const { workText, historyText, feedbackText } = readWorkFiles(cwd, io);
   const frontmatter = parseFrontmatter(workText);
-  const artefacts = parseArtefactsTable(workText);
 
-  const cycleError = findCycleError(frontmatter, artefacts, historyText, feedbackText);
+  const cycleError = findCycleError(frontmatter, historyText, feedbackText);
   if (cycleError) {
     return { ok: false, error: cycleError };
   }
 
   const diffSha = computeDiffSha(execGit, baseBranch);
 
-  const payload = buildAttestationPayload({
+  const payload = await buildAttestationPayload({
     cwd,
+    foundryDir: foundryDir ?? 'foundry',
     goalText,
     archiveBranch,
     archiveTipSha,
+    baseBranch,
+    branchBaseSha,
     io,
   });
 

package/dist/scripts/lib/attestation/payload.js

@@ -5,26 +5,29 @@
  */
 
 import { readFileSync, existsSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
 import path from 'node:path';
 import { parseFrontmatter } from '../workfile.js';
-import { parseArtefactsTable } from '../artefacts.js';
+import { getArtefactFiles } from '../artefacts.js';
+import { getCycleDefinition } from '../config.js';
 import { parseAllHistoryEntries } from '../history.js';
 import { sha256Text, sortPaths } from './hash.js';
 
-function defaultIo() {
+function defaultIo(cwd) {
   return {
     readFile: (filePath) => readFileSync(filePath, 'utf8'),
-    fileExists: (filePath) => existsSync(filePath),
+    exists: (filePath) => existsSync(filePath),
+    exec: (args) => execFileSync(args[0], args.slice(1), { cwd, encoding: 'utf8' }),
   };
 }
 
 function readWorkFiles(cwd, io) {
-  const { readFile, fileExists } = io ?? defaultIo();
+  const { readFile, exists } = io ?? defaultIo(cwd);
 
   return {
     workText: readFile(path.join(cwd, 'WORK.md')),
-    historyText: fileExists(path.join(cwd, 'WORK.history.yaml')) ? readFile(path.join(cwd, 'WORK.history.yaml')) : '',
-    feedbackText: fileExists(path.join(cwd, 'WORK.feedback.yaml')) ? readFile(path.join(cwd, 'WORK.feedback.yaml')) : '',
+    historyText: exists(path.join(cwd, 'WORK.history.yaml')) ? readFile(path.join(cwd, 'WORK.history.yaml')) : '',
+    feedbackText: exists(path.join(cwd, 'WORK.feedback.yaml')) ? readFile(path.join(cwd, 'WORK.feedback.yaml')) : '',
   };
 }
 
@@ -85,11 +88,34 @@ function buildGovernance(frontmatter, workText, historyText, feedbackText) {
   };
 }
 
-export function buildAttestationPayload({ cwd, goalText, archiveBranch, archiveTipSha, io }) {
-  const { workText, historyText, feedbackText } = readWorkFiles(cwd, io);
+async function discoverCycleOutputs(resolvedFd, cycleId, resolvedIo, options) {
+  try {
+    const cfm = (await getCycleDefinition(resolvedFd, cycleId, resolvedIo)).frontmatter;
+    const outputType = cfm && cfm['output-type'];
+    if (outputType) return getArtefactFiles(resolvedFd, outputType, resolvedIo, options);
+  } catch {
+    // If cycle definition is missing, outputs remain empty
+  }
+  return [];
+}
+
+export async function buildAttestationPayload(
+  { cwd, foundryDir: fd, goalText, archiveBranch, archiveTipSha, baseBranch, branchBaseSha, io },
+) {
+  const resolvedIo = io || defaultIo(cwd);
+  const resolvedFd = fd || 'foundry';
+  const { workText, historyText, feedbackText } = readWorkFiles(cwd, resolvedIo);
 
   const frontmatter = parseFrontmatter(workText);
-  const artefacts = parseArtefactsTable(workText);
+
+  // Discover artefact outputs from branch changes
+  let outputs = [];
+  const cycleId = frontmatter.cycle;
+  if (cycleId) {
+    outputs = await discoverCycleOutputs(resolvedFd, cycleId, resolvedIo, { baseBranch, branchBaseSha });
+  }
+
+  const outputEntries = outputs.map(({ file, state }) => ({ path: file, state }));
 
   const sortedEntries = parseAndSortHistoryEntries(historyText);
   const stages = buildStagesFromEntries(sortedEntries);
@@ -97,7 +123,7 @@ export function buildAttestationPayload({ cwd, goalText, archiveBranch, archiveT
   return {
     contract: buildContract(frontmatter),
     governance: buildGovernance(frontmatter, workText, historyText, feedbackText),
-    outputs: artefacts.map(row => ({ path: row.file, status: row.status })),
+    outputs: outputEntries,
     process: { stages },
     request: { goal_text: goalText },
     schema: 'foundry-attestation/v1',

package/dist/scripts/lib/finalize.js

@@ -49,7 +49,7 @@ function classifyFiles(files, allowedPatterns) {
   return { matched, unexpected };
 }
 
-export function finalizeStage({ cwd, baseSha, stageBase, cycleDef, artefactTypes, registerArtefact, io }) {
+export function finalizeStage({ cwd, baseSha, stageBase, cycleDef, artefactTypes, io }) {
   if (!io?.exec) {
     throw new Error('finalizeStage: io.exec is required');
   }
@@ -62,9 +62,9 @@ export function finalizeStage({ cwd, baseSha, stageBase, cycleDef, artefactTypes
   // For non-forge stages, matched files are tool-managed side effects
   // (e.g. assay's memory writes) that should not become artefacts.
   if (stageBase !== 'forge') return { ok: true, artefacts: [], changedFiles: sortedFiles };
-  const artefacts = sortedFiles.map(file => {
-    registerArtefact({ file, type: cycleDef.outputArtefactType, status: 'draft' });
-    return { file, type: cycleDef.outputArtefactType, status: 'draft' };
-  });
+  const artefacts = sortedFiles.map(file => ({
+    file,
+    type: cycleDef.outputArtefactType,
+  }));
   return { ok: true, artefacts, changedFiles: sortedFiles };
 }

package/dist/scripts/lib/validation.js

@@ -76,12 +76,14 @@ export async function getValidationPatterns(foundryDir, typeId, io) {
  * Run validation commands for an artefact type deterministically.
  *
  * Accepts an IO interface and foundryDir directly (no plugin context
- * dependency). Returns a plain result object.
+ * dependency). When `artefacts` is provided, the `{files}` substitution
+ * uses non-deleted files from the artefact list instead of expanding
+ * patterns across the worktree.
  *
- * @param {{ typeId: string, io: object, foundryDir: string }} params
+ * @param {{ typeId: string, io: object, foundryDir: string, artefacts?: Array<{file: string, state: string}> }} params
  * @returns {Promise<{ ok: boolean, validatorsRun: number, items: Array, errors: Array }>}
  */
-export async function performValidation({ typeId, io, foundryDir }) {
+export async function performValidation({ typeId, io, foundryDir, artefacts }) {
   let patterns;
   try {
     patterns = await getValidationPatterns(foundryDir, typeId, io);
@@ -96,15 +98,27 @@ export async function performValidation({ typeId, io, foundryDir }) {
   if (!laws?.length) {
     return { ok: true, validatorsRun: 0, items: [], errors: [] };
   }
-  return runValidatorsAndReport(laws, patterns, foundryDir);
+  return runValidatorsAndReport(laws, patterns, foundryDir, artefacts);
 }
 
 /**
  * Run validators for a set of laws and build the aggregated result.
+ *
+ * When `artefacts` is provided, the `{files}` substitution uses non-deleted
+ * files from the artefact list. Otherwise patterns are expanded across the
+ * worktree (backwards compatibility for callers like `foundry_validate_run`).
  */
-export async function runValidatorsAndReport(laws, patterns, foundryDir) {
+export async function runValidatorsAndReport(laws, patterns, foundryDir, artefacts) {
   const worktree = dirname(foundryDir);
-  const expandedFiles = await expandPatterns(patterns, worktree);
+  let expandedFiles;
+  if (artefacts) {
+    expandedFiles = artefacts
+      .filter(({ state }) => state !== 'deleted')
+      .map(({ file }) => file)
+      .sort();
+  } else {
+    expandedFiles = await expandPatterns(patterns, worktree);
+  }
   const substitutions = {
     pattern: patterns.map(shellQuote).join(' '),
     files: expandedFiles.map(shellQuote).join(' '),

package/dist/scripts/lib/workfile.js

@@ -127,8 +127,5 @@ export function createWorkfile(frontmatter, goal) {
 # Goal
 
 ${goal}
-
-| File | Type | Cycle | Status |
-|------|------|-------|--------|
 `;
 }

package/dist/scripts/orchestrate-cycle.js

@@ -5,21 +5,12 @@ import {
   getCycleDefinition,
   getArtefactType,
 } from './lib/config.js';
-import { parseArtefactsTable, setArtefactStatus } from './lib/artefacts.js';
 import { openFeedbackStore } from './lib/feedback-store.js';
 
 // ---------------------------------------------------------------------------
 // Public helpers (re-exported by orchestrate.js for tests).
 // ---------------------------------------------------------------------------
 
-export function findCycleOutputArtefact(cycleId, io) {
-  if (!io.exists('WORK.md')) return null;
-  const content = io.readFile('WORK.md');
-  const rows = parseArtefactsTable(content);
-  const match = rows.find(r => r.cycle === cycleId);
-  return match ? { file: match.file, type: match.type, status: match.status } : null;
-}
-
 export async function readCycleTargets(cycleId, io) {
   try {
     const cd = await getCycleDefinition('foundry', cycleId, io);
@@ -47,7 +38,11 @@ export async function readForgeFilePatterns(cycleId, io) {
   }
   const output = extractOutputType(cd);
   if (!output) return null;
-  return fetchFilePatterns(output, io);
+  try {
+    return await fetchFilePatterns(output, io);
+  } catch {
+    return null;
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -148,31 +143,7 @@ export function tryCommit(git, message, allowedPatterns, phase) {
   }
 }
 
-function findCycleRow(cycleId, rows) {
-  return rows.find(r => r.cycle === cycleId);
-}
-
-function writeBlockedStatus(content, row, io) {
-  try {
-    io.writeFile('WORK.md', setArtefactStatus(content, row.file, 'blocked'));
-    return { ok: true };
-  } catch (e) {
-    return { ok: false, error: e?.message || String(e) };
-  }
-}
-
-export function markArtefactBlocked(cycleId, io) {
-  if (!io.exists('WORK.md')) return { ok: true };
-  const content = io.readFile('WORK.md');
-  const rows = parseArtefactsTable(content);
-  const row = findCycleRow(cycleId, rows);
-  if (!row) return { ok: true };
-  return writeBlockedStatus(content, row, io);
-}
 
-export function formatBlockNote(blockResult) {
-  return blockResult.ok ? '' : ` (also: failed to mark artefact blocked: ${blockResult.error})`;
-}
 
 // ---------------------------------------------------------------------------
 // Stage synthesis (pure utility, used by setupWorkfile and exported publicly).

package/dist/scripts/orchestrate-phases.js

@@ -13,38 +13,62 @@ import { stageBaseOf } from './lib/stage-guard.js';
 import { allowedPatternsForStage } from './lib/git-policy.js';
 import { loadExtractor } from './lib/assay/loader.js';
 import { checkExtractorAgainstCycle } from './lib/assay/permissions.js';
+import { getArtefactFiles } from './lib/artefacts.js';
 import {
-  findCycleOutputArtefact,
   readCycleTargets,
   readForgeFilePatterns,
   readRecentFeedback,
   computeOpenFeedback,
   violation,
   tryCommit,
-  markArtefactBlocked,
-  formatBlockNote,
   synthesizeStages,
   renderDispatchPrompt,
 } from './orchestrate-cycle.js';
 
-async function doneAction(cycleId, io) {
-  const art = findCycleOutputArtefact(cycleId, io);
-  return { action: 'done', cycle: cycleId, artefact_file: art?.file ?? null, next_cycles: await readCycleTargets(cycleId, io) };
+async function findOutputArtefacts(cfm, io, foundryDir, baseBranch) {
+  const outputType = cfm ? cfm['output-type'] : undefined;
+  if (!outputType) return null;
+  const artefacts = await getArtefactFiles(foundryDir, outputType, io, { baseBranch });
+  return artefacts.find(a => a.state !== 'deleted') || null;
 }
 
-function blockedAction(cycleId, io, details) {
-  const art = findCycleOutputArtefact(cycleId, io);
-  return { action: 'blocked', cycle: cycleId, artefact_file: art?.file ?? null, reason: details ?? 'iteration limit reached with unresolved feedback' };
+async function doneAction(cycleId, io, foundryDir, baseBranch) {
+  const fd = foundryDir || 'foundry';
+  const base = baseBranch || 'main';
+  const cfm = (await getCycleDefinition(fd, cycleId, io)).frontmatter;
+  const artefact = await findOutputArtefacts(cfm, io, fd, base);
+  const artefactFile = artefact ? artefact.file : null;
+  return { action: 'done', cycle: cycleId, artefact_file: artefactFile, next_cycles: await readCycleTargets(cycleId, io) };
 }
 
-function humanAppraiseAction(route, token, cycleId, io) {
-  const art = findCycleOutputArtefact(cycleId, io);
-  return { action: 'human_appraise', stage: route, token, context: { cycle: cycleId, artefact_file: art?.file ?? null, recent_feedback: readRecentFeedback(io) } };
+async function blockedAction(cycleId, io, details, foundryDir, baseBranch) {
+  const fd = foundryDir || 'foundry';
+  const base = baseBranch || 'main';
+  const cfm = (await getCycleDefinition(fd, cycleId, io)).frontmatter;
+  const artefact = await findOutputArtefacts(cfm, io, fd, base);
+  const artefactFile = artefact ? artefact.file : null;
+  const reason = details || 'iteration limit reached with unresolved feedback';
+  return { action: 'blocked', cycle: cycleId, artefact_file: artefactFile, reason };
 }
 
-function missingModelViolation(cycleId, route, io) {
-  const art = findCycleOutputArtefact(cycleId, io);
-  return violation(`cycle ${cycleId} stage ${route} has no model declared in cycle definition`, [art?.file].filter(Boolean));
+async function humanAppraiseAction(route, token, ctx) {
+  const { cycleId, io, baseBranch } = ctx;
+  const fd = ctx.foundryDir || 'foundry';
+  const base = baseBranch || 'main';
+  const cfm = (await getCycleDefinition(fd, cycleId, io)).frontmatter;
+  const artefact = await findOutputArtefacts(cfm, io, fd, base);
+  const artefactFile = artefact ? artefact.file : null;
+  return { action: 'human_appraise', stage: route, token, context: { cycle: cycleId, artefact_file: artefactFile, recent_feedback: readRecentFeedback(io) } };
+}
+
+async function missingModelViolation(cycleId, route, io, foundryDir, baseBranch) {
+  const fd = foundryDir || 'foundry';
+  const base = baseBranch || 'main';
+  const cfm = (await getCycleDefinition(fd, cycleId, io)).frontmatter;
+  const outputType = cfm ? cfm['output-type'] : undefined;
+  const artefacts = outputType ? await getArtefactFiles(fd, outputType, io, { baseBranch: base }) : [];
+  const affectedFiles = artefacts.filter(a => a.state !== 'deleted').map(a => a.file);
+  return violation(`cycle ${cycleId} stage ${route} has no model declared in cycle definition`, affectedFiles);
 }
 
 function makeDispatchPayload(route, cycleId, token, cwd, filePatterns) {
@@ -52,7 +76,7 @@ function makeDispatchPayload(route, cycleId, token, cwd, filePatterns) {
 }
 
 async function buildDispatchAction(route, model, token, ctx) {
-  if (!model) return missingModelViolation(ctx.cycleId, route, ctx.io);
+  if (!model) return missingModelViolation(ctx.cycleId, route, ctx.io, ctx.foundryDir, ctx.baseBranch ?? 'main');
   const base = route.split(':')[0];
   const filePatterns = base === 'forge' ? await readForgeFilePatterns(ctx.cycleId, ctx.io) : null;
   return { action: 'dispatch', stage: route, subagent_type: model, prompt: renderDispatchPrompt(makeDispatchPayload(route, ctx.cycleId, token, ctx.cwd, filePatterns)) };
@@ -63,26 +87,27 @@ export function routeDispatch(route) {
 }
 
 async function handleTerminalRoute(route, sortResult, ctx) {
-  if (route === 'done') return doneAction(ctx.cycleId, ctx.io);
-  if (route === 'blocked') return blockedAction(ctx.cycleId, ctx.io, sortResult.details);
-  return violation(sortResult.details ?? 'sort returned violation');
+  const baseBranch = ctx.baseBranch || 'main';
+  if (route === 'done') return doneAction(ctx.cycleId, ctx.io, ctx.foundryDir, baseBranch);
+  if (route === 'blocked') return blockedAction(ctx.cycleId, ctx.io, sortResult.details, ctx.foundryDir, baseBranch);
+  const details = sortResult.details || 'sort returned violation';
+  return violation(details);
 }
 
 function isTerminalRoute(route) {
   return route === 'done' || route === 'blocked' || route === 'violation';
 }
 
+function getRouteBase(route) {
+  return routeDispatch(route);
+}
+
 export async function handleSortResult(sortResult, ctx) {
   const { route, model, token } = sortResult;
-  if (isTerminalRoute(route)) {
-    return handleTerminalRoute(route, sortResult, ctx);
-  }
-  if (routeDispatch(route) === 'quench' || routeDispatch(route) === 'appraise') {
-    return violation(`${routeDispatch(route)} route reached handleSortResult — should have been handled upstream in orchestrate.js`);
-  }
-  if (routeDispatch(route) === 'human-appraise') {
-    return humanAppraiseAction(route, token, ctx.cycleId, ctx.io);
-  }
+  const routeBase = getRouteBase(route);
+  if (isTerminalRoute(route)) return handleTerminalRoute(route, sortResult, ctx);
+  if (routeBase === 'quench' || routeBase === 'appraise') return violation(routeBase + ' route reached handleSortResult');
+  if (routeBase === 'human-appraise') return humanAppraiseAction(route, token, ctx);
   return buildDispatchAction(route, model, token, ctx);
 }
 
@@ -243,12 +268,11 @@ function readOriginalState(io) {
   return { workMd: io.readFile('WORK.md'), history: io.exists('WORK.history.yaml') ? io.readFile('WORK.history.yaml') : null };
 }
 
-function buildFinalizeViolation(finalizeResult, blockResult) {
-  const blockNote = formatBlockNote(blockResult);
+function buildFinalizeViolation(finalizeResult) {
   if (finalizeResult.error === 'unexpected_files') {
-    return violation(`unexpected files written by subagent: ${(finalizeResult.files || []).join(', ')}${blockNote}`, finalizeResult.files || []);
+    return violation(`unexpected files written by subagent: ${(finalizeResult.files || []).join(', ')}`, finalizeResult.files || []);
   }
-  return violation(`stage_finalize error: ${finalizeResult.error}${blockNote}`, []);
+  return violation(`stage_finalize error: ${finalizeResult.error}`, []);
 }
 
 function writeHistoryEntries(ctx) {
@@ -291,9 +315,8 @@ export async function finaliseStage(args) {
   }
   const finalizeResult = await finalize({ cycleId, stage: lastStage.stage, baseSha: lastStage.baseSha, io });
   if (!finalizeResult.ok) {
-    const blockResult = markArtefactBlocked(cycleId, io);
     clearStageState(activeStage, null, io);
-    return buildFinalizeViolation(finalizeResult, blockResult);
+    return buildFinalizeViolation(finalizeResult);
   }
   const historyPath = 'WORK.history.yaml';
   const iteration = getIteration(historyPath, cycleId, io);
@@ -310,12 +333,12 @@ export async function finaliseStage(args) {
 }
 
 export function handleViolation(args) {
-  const { lastResult, activeStage, lastStage, cycleId, io } = args;
+  const { lastResult, activeStage, lastStage } = args;
   const failedStage = activeStage || lastStage;
   if (!failedStage) { return violation('lastResult.ok=false but no stage recorded — orphaned state'); }
-  const blockResult = markArtefactBlocked(cycleId, io);
-  clearStageState(activeStage, lastStage, io);
-  const art = findCycleOutputArtefact(cycleId, io);
-  const blockNote = formatBlockNote(blockResult);
-  return violation(`subagent dispatch failed: ${lastResult.error || 'unknown error'}${blockNote}`, [art?.file].filter(Boolean));
+  clearStageState(activeStage, lastStage, args.io);
+  return violation(
+    `subagent dispatch failed: ${lastResult.error || 'unknown error'}`,
+    lastResult.affected_files || [],
+  );
 }

package/dist/scripts/orchestrate.js

@@ -8,14 +8,12 @@ import { readActiveStage, readLastStage, writeActiveStage, clearActiveStage } fr
 import { stageBaseOf } from './lib/stage-guard.js';
 import { ulid as defaultUlid } from './lib/ulid.js';
 import {
-  findCycleOutputArtefact,
   readCycleTargets,
   readForgeFilePatterns,
   renderDispatchPrompt,
   synthesizeStages,
   violation,
   computeOpenFeedback,
-  markArtefactBlocked,
   DISPATCH_MULTI_ACTION,
   validateDispatchMulti,
   buildDispatchMultiResponse,
@@ -36,7 +34,7 @@ export {
   DISPATCH_MULTI_ACTION, validateDispatchMulti, buildDispatchMultiResponse,
 };
 export { gatherAppraiseContext, consolidateAppraise };
-export { findCycleOutputArtefact, readCycleTargets, readForgeFilePatterns };
+export { readCycleTargets, readForgeFilePatterns };
 export { handleSortResult as __handleSortResultForTest };
 
 export function needsSetup(workMdContent) {
@@ -121,7 +119,7 @@ function buildSortArgs(args, now) {
 }
 
 function buildSortContext(cycleId, args, io) {
-  return { cycleId, cwd: args.cwd ?? process.cwd(), io };
+  return { cycleId, cwd: args.cwd ?? process.cwd(), io, foundryDir: args.foundryDir ?? 'foundry', baseBranch: args.baseBranch ?? 'main' };
 }
 
 function buildSetupArgs(cycleResult, args, io) {
@@ -162,6 +160,7 @@ function buildQuenchContext(cycleId, args, io) {
   const stageId = `quench:${cycleId}`;
   return { cycleId, stageId, io, git: args.git, finalize: buildFinalizeWrapper(cycleId, args, io),
     now: args.now, ulid: args.ulid, mint: args.mint, foundryDir: 'foundry', defaultModel: args.defaultModel,
+    baseBranch: args.baseBranch ?? 'main',
     feedback: buildFeedback(cycleId, stageId, io) };
 }
 
@@ -169,6 +168,7 @@ function buildAppraiseCtx(cycleId, args, io) {
   const stageId = `appraise:${cycleId}`;
   return { cycleId, io, git: args.git, finalize: buildFinalizeWrapper(cycleId, args, io),
     foundryDir: 'foundry', defaultModel: args.defaultModel,
+    baseBranch: args.baseBranch ?? 'main',
     activeStage: readActiveStage(io), lastStage: readLastStage(io),
     feedback: buildFeedback(cycleId, stageId, io) };
 }
@@ -211,7 +211,6 @@ async function handleAppraiseConsolidateRoute(sortResult, preCheck, args, io) {
   const ctx = buildAppraiseCtx(preCheck.cycleId, args, io);
   const result = await consolidateAppraise(ctx, args.lastResults);
   if (result.action === 'violation') {
-    markArtefactBlocked(preCheck.cycleId, io);
     clearActiveStage(io);
     return result;
   }

package/dist/scripts/quench-module.js

@@ -1,13 +1,15 @@
 /**
  * Quench module — deterministic validation run entirely within the orchestrator.
  *
- * The module runs validators for each draft artefact in the current cycle,
- * posts feedback for each validation item, resolves prior quench feedback,
- * and finalises the stage. No LLM involvement.
+ * The module discovers artefact changes via branch-based artefact discovery,
+ * runs validators for each artefact change, posts feedback for each validation
+ * item, resolves prior quench feedback, and finalises the stage. No LLM
+ * involvement.
  */
 
 import { readActiveStage } from './lib/state.js';
-import { getArtefactsForCycle, setArtefactStatus } from './lib/artefacts.js';
+import { getArtefactFiles } from './lib/artefacts.js';
+import { getCycleDefinition } from './lib/config.js';
 import { performValidation } from './lib/validation.js';
 
 /**
@@ -22,20 +24,37 @@ export async function runQuench(ctx) {
     return { ok: false, error: 'No active stage found' };
   }
 
-  const artefacts = getArtefactsForCycle(ctx.cycleId, ctx.io);
+  const cycleDef = await getCycleDefinition(ctx.foundryDir, ctx.cycleId, ctx.io);
+  const outputType = cycleDef.frontmatter['output-type'];
+  if (!outputType) {
+    return { ok: false, error: `Cycle ${ctx.cycleId} has no output-type` };
+  }
+
+  const discovery = await discoverArtefacts(ctx, outputType);
+  if (!discovery.ok) return discovery;
+  const artefacts = discovery.artefacts;
 
   if (artefacts.length === 0) {
     return await handleNoArtefacts(ctx, activeStageRecord);
   }
 
-  return await processArtefacts(ctx, artefacts, activeStageRecord);
+  return await processArtefacts(ctx, artefacts, activeStageRecord, outputType);
+}
+
+async function discoverArtefacts(ctx, outputType) {
+  try {
+    const artefacts = await getArtefactFiles(ctx.foundryDir, outputType, ctx.io, { baseBranch: ctx.baseBranch ?? 'main' });
+    return { ok: true, artefacts };
+  } catch (err) {
+    return { ok: false, error: `Failed to discover artefacts: ${err.message}` };
+  }
 }
 
 /**
  * Handle the case where no artefacts exist for this cycle.
  */
 async function handleNoArtefacts(ctx, activeStageRecord) {
-  const summary = 'SKIP: no artefacts';
+  const summary = 'SKIP: no files';
   await ctx.finalize({
     lastStage: { stage: ctx.stageId, summary, baseSha: activeStageRecord.baseSha },
     activeStage: activeStageRecord,
@@ -46,16 +65,17 @@ async function handleNoArtefacts(ctx, activeStageRecord) {
 /**
  * Process each artefact: run validation, post feedback, handle errors.
  */
-async function processArtefacts(ctx, artefacts, activeStageRecord) {
+async function processArtefacts(ctx, artefacts, activeStageRecord, outputType) {
   const perArtefact = [];
   const currentFeedback = [];
   let allOk = true;
 
   for (const artefact of artefacts) {
     const result = await performValidation({
-      typeId: artefact.type,
+      typeId: outputType,
       io: ctx.io,
       foundryDir: ctx.foundryDir,
+      artefacts: [artefact],
     });
 
     const outcome = handleArtefactResult(ctx, artefact, result, currentFeedback);
@@ -89,12 +109,10 @@ function handleArtefactResult(ctx, artefact, result, currentFeedback) {
   }
 
   if (result.error) {
-    markArtefactBlocked(ctx.io, artefact.file);
     return { ok: false, text: `${artefact.file}: ${result.error}` };
   }
 
   if (isAllErrors(result)) {
-    markArtefactBlocked(ctx.io, artefact.file);
     const messages = result.errors.map(e => e.message).join('; ');
     return { ok: false, text: `${artefact.file}: ${messages}` };
   }
@@ -142,12 +160,3 @@ function resolvePriorFeedback(ctx, currentFeedback) {
     ctx.feedback.resolve(prior.id, decision);
   }
 }
-
-/**
- * Mark an artefact as blocked in the artefacts table.
- */
-function markArtefactBlocked(io, file) {
-  const workText = io.readFile('WORK.md');
-  const updated = setArtefactStatus(workText, file, 'blocked');
-  io.writeFile('WORK.md', updated);
-}

package/dist/scripts/sort.js

@@ -275,7 +275,6 @@ export function runSort(args = {}, io = defaultIO) {
 // Exports (for testing) — keep main() private
 // ---------------------------------------------------------------------------
 
-export { parseArtefactsTable } from './lib/artefacts.js';
 export { loadHistory } from './lib/history.js';
 export { parseFrontmatter } from './lib/workfile.js';
 export {