@really-knows-ai/foundry 3.5.1 → 3.5.3

package/dist/.opencode/plugins/foundry-tools/config-create-tools.js

@@ -160,7 +160,7 @@ function cycleArgs(s) { return {
   inputs: s.object({
     type: s.enum(['any-of', 'all-of']).describe('Contract type: any-of (at least one) or all-of (all must exist)'),
     artefacts: s.array(s.string()).describe('Artefact type IDs this cycle reads'),
-  }).optional().describe('Input contract for this cycle'),
+  }).optional().describe('Input contract for this cycle. Omit for source cycles that start from the user goal; empty artefacts arrays are invalid.'),
   targets: s.array(s.string()).optional().describe('Downstream cycle IDs this cycle can route to'),
   humanAppraise: s.boolean().optional().describe('Include human-appraise in every iteration'),
   deadlockAppraise: s.boolean().optional().describe('Route to human-appraise on LLM appraiser deadlock'),
@@ -173,7 +173,7 @@ function cycleArgs(s) { return {
     read: s.array(s.string()).describe('Memory store keys this cycle can read'),
     write: s.array(s.string()).describe('Memory store keys this cycle can write'),
   }).optional().describe('Flow memory permissions'),
-  models: s.object({}).optional().describe('Per-stage model overrides (e.g. { forge: "openai/gpt-4o" })'),
+  models: s.object({}).optional().describe('Per-stage model overrides (e.g. { forge: "opencode-go/deepseek-v4-flash", appraise: "opencode-go/qwen3.6-plus" }). Preserve user-selected stage models.'),
   description: s.string().optional().describe('Prose description placed after frontmatter'),
 }; }
 

package/dist/.opencode/plugins/foundry-tools/config-tools.js

@@ -1,13 +1,16 @@
 import { getCycleDefinition, getArtefactType, getLaws, getAppraisers, getFlow } from '../../../scripts/lib/config.js';
 import { makeIO } from './helpers.js';
+import { writeCall } from '../../../scripts/lib/stage-calls.js';
 
-function makeConfigTool(tool, description, argSchema, invoke) {
+function makeConfigTool(tool, description, argSchema, invoke, logName) {
   return tool({
     description,
     args: argSchema,
     async execute(args, context) {
       const io = makeIO(context.worktree);
-      return JSON.stringify(await invoke(args, io));
+      const result = await invoke(args, io);
+      if (logName) writeCall(io, logName);
+      return JSON.stringify(result);
     },
   });
 }
@@ -18,16 +21,19 @@ export function createConfigTools({ tool }) {
       tool, 'Get a cycle definition from foundry config',
       { cycleId: tool.schema.string().describe('Cycle ID') },
       (args, io) => getCycleDefinition('foundry', args.cycleId, io),
+      'foundry_config_cycle',
     ),
     foundry_config_artefact_type: makeConfigTool(
       tool, 'Get an artefact type definition',
       { typeId: tool.schema.string().describe('Artefact type ID') },
       (args, io) => getArtefactType('foundry', args.typeId, io),
+      'foundry_config_artefact_type',
     ),
     foundry_config_laws: makeConfigTool(
       tool, 'Get laws, optionally filtered by artefact type',
       { typeId: tool.schema.string().optional().describe('Artefact type ID') },
       (args, io) => getLaws('foundry', io, { typeId: args.typeId }),
+      'foundry_config_laws',
     ),
     foundry_config_appraisers: makeConfigTool(
       tool, 'List all appraisers',

package/dist/.opencode/plugins/foundry-tools/feedback-tools.js

@@ -3,6 +3,7 @@ import { parseFrontmatter } from '../../../scripts/lib/workfile.js';
 import { requireActiveStage, stageBaseOf } from '../../../scripts/lib/stage-guard.js';
 import { guarded, notFailedGuard } from '../../../scripts/lib/guards.js';
 import { makeIO, branchIoFactory, asyncIoFactory, flowBranchGuard } from './helpers.js';
+import { writeCall } from '../../../scripts/lib/stage-calls.js';
 
 const gateNotFailed = notFailedGuard(makeIO);
 
@@ -170,6 +171,7 @@ async function executeFeedbackList(args, context) {
   }
   try {
     const store = openFeedbackStore('WORK.feedback.yaml', io);
+    writeCall(io, 'foundry_feedback_list');
     const items = store.list()
       .filter(it => !args.file || it.file === args.file)
       .map(it => {

package/dist/.opencode/plugins/foundry-tools/stage-tools.js

@@ -8,10 +8,31 @@ import { syncStore } from '../../../scripts/lib/memory/store.js';
 import { makeIO, makeMemoryIO, branchIoFactory, asyncIoFactory, flowBranchGuard } from './helpers.js';
 import { markWorkfileFailed, readFailedStatus, clearWorkfileFailed } from '../../../scripts/lib/failed-flow.js';
 import { guarded, notFailedGuard } from '../../../scripts/lib/guards.js';
+import { initForgeCallLog, verifyAndClearForgeCallLog } from '../../../scripts/lib/stage-calls.js';
+import { openFeedbackStore } from '../../../scripts/lib/feedback-store.js';
+
+const FORGE_REQUIRED_TOOLS = [
+  'foundry_config_cycle',
+  'foundry_workfile_get',
+  'foundry_config_artefact_type',
+  'foundry_config_laws',
+  'foundry_feedback_list',
+];
+
+function stageBase(stage) { return stage.split(':')[0]; }
 
 const gateNotFailed = notFailedGuard(makeIO);
 
-// -- Helpers for foundry_stage_begin --
+// -- Helpers for forge tool call verification --
+
+function verifyAndManageForgeTools(io, active) {
+  const verified = verifyAndClearForgeCallLog(io, FORGE_REQUIRED_TOOLS);
+  if (!verified.ok) {
+    postMissingToolsFeedback(io, active, verified.missing);
+    return;
+  }
+  resolveSystemFeedback(io, active);
+}
 
 function resolveBaseSha(worktree) {
   try {
@@ -59,9 +80,14 @@ async function executeStageBegin(args, context, pending) {
     startedAt: new Date().toISOString(),
   };
   writeActiveStage(io, active);
+  initForgeIfApplicable(io, active.stage);
   return JSON.stringify({ ok: true, active });
 }
 
+function initForgeIfApplicable(io, stage) {
+  if (stageBase(stage) === 'forge') initForgeCallLog(io);
+}
+
 // -- Helpers for foundry_stage_end --
 
 function markWorkfileFailedSilently(io, msg) {
@@ -82,6 +108,11 @@ async function executeStageEnd(args, context) {
   if (!active) {
     return JSON.stringify({ error: 'foundry_stage_end requires active stage; current: none' });
   }
+
+  if (stageBase(active.stage) === 'forge') {
+    verifyAndManageForgeTools(io, active);
+  }
+
   writeLastStage(io, {
     cycle: active.cycle,
     stage: active.stage,
@@ -101,6 +132,26 @@ async function executeStageEnd(args, context) {
   return JSON.stringify({ ok: true, summary: args.summary });
 }
 
+function postMissingToolsFeedback(io, active, missing) {
+  try {
+    const store = openFeedbackStore('WORK.feedback.yaml', io);
+    store.add({
+      file: '(forge)',
+      tag: 'system:missing-tool-calls',
+      text: `Missing required forge tools: ${missing.join(', ')}`,
+      source: active.stage,
+      cycle: active.cycle,
+    });
+  } catch { /* feedback file not initialised yet; non-critical */ }
+}
+
+function resolveSystemFeedback(io, active) {
+  try {
+    const store = openFeedbackStore('WORK.feedback.yaml', io);
+    store.resolveSystemItems(active.stage, active.cycle);
+  } catch { /* non-critical */ }
+}
+
 // -- Helpers for foundry_stage_retry --
 
 function checkGitWorkingTreeClean(worktree) {

package/dist/.opencode/plugins/foundry-tools/workfile-tools.js

@@ -4,6 +4,7 @@ import { requireNoActiveStage } from '../../../scripts/lib/stage-guard.js';
 import { guarded, notFailedGuard } from '../../../scripts/lib/guards.js';
 import { parseFrontmatter, createWorkfile, enrichStages, parseModelsValue } from '../../../scripts/lib/workfile.js';
 import { makeIO, branchIoFactory, asyncIoFactory, flowBranchGuard } from './helpers.js';
+import { writeCall } from '../../../scripts/lib/stage-calls.js';
 
 const gateNotFailed = notFailedGuard(makeIO);
 
@@ -84,6 +85,7 @@ export function createWorkfileTools({ tool }) {
         const fm = parseFrontmatter(text);
         const goalMatch = text.match(/# Goal\n\n([\s\S]*?)(?=\n\||\n##|$)/);
         const goal = goalMatch ? goalMatch[1].trim() : '';
+        writeCall(makeIO(context.worktree), 'foundry_workfile_get');
         return JSON.stringify({ ...fm, goal });
       },
     }),

package/dist/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [3.5.3] - 2026-05-23
+
+### Added
+
+- Forge tool-call verification: `stage_end` checks that required tools were called and posts system feedback if not, with automatic retry via the existing feedback loop.
+
+### Fixed
+
+- Forge dispatch prompts now include explicit required-tool instructions with the actual output type filled in.
+
+### Changed
+
+- `readForgeFilePatterns` returns `{ patterns, outputType }` instead of a bare array.
+- Build quality gate now writes a seal; `prepublishOnly` verifies the seal instead of re-running lint and tests.
+
+## [3.5.2] - 2026-05-23
+
+### Fixed
+
+- Guide agents to omit empty `inputs` for source cycles and preserve stage-specific model overrides when creating cycles.
+
 ## [3.5.1] - 2026-05-22
 
 ### Fixed

package/dist/scripts/lib/feedback-store.js

@@ -60,14 +60,22 @@ function cloneItem(it) {
   return { ...it, history: it.history.map(h => ({ ...h })) };
 }
 
+function resolveSystemItemsImpl({ items, stage, cycle, timestamp, persist }) {
+  const snapshot = { state: 'resolved', stage, cycle, timestamp: timestamp() };
+  const next = items.map(it =>
+    it.tag === 'system:missing-tool-calls' && it.history[0].state !== 'resolved'
+      ? { ...it, history: [snapshot, ...it.history] }
+      : it
+  );
+  persist(next);
+}
+
 export function openFeedbackStore(path, io) {
   let items = loadItems(path, io);
-
   function persist(nextItems) {
     saveItems(path, nextItems, io);
     items = nextItems;
   }
-
   return {
     list() { return items.map(cloneItem); },
     get(id) {
@@ -89,14 +97,13 @@ export function openFeedbackStore(path, io) {
       });
     },
     writeDeadlockedSnapshotForTest(params) {
-      return storeWriteDeadlockedSnapshot(params, items, {
-        timestamp: nowIso, persist,
-      });
+      return storeWriteDeadlockedSnapshot(params, items, { timestamp: nowIso, persist });
     },
     writeDeadlockedSnapshots(ids, reason, stage, cycle) {
-      return storeWriteDeadlockedSnapshots({ ids, reason, stage, cycle }, items, {
-        timestamp: nowIso, persist,
-      });
+      return storeWriteDeadlockedSnapshots({ ids, reason, stage, cycle }, items, { timestamp: nowIso, persist });
+    },
+    resolveSystemItems(stage, cycle) {
+      resolveSystemItemsImpl({ items, stage, cycle, timestamp: nowIso, persist });
     },
   };
 }

package/dist/scripts/lib/stage-calls.js

@@ -0,0 +1,56 @@
+const LOG_PATH = '.foundry/.forge-tool-calls.jsonl';
+const RETRIES_PATH = '.foundry/.forge-tool-retries';
+
+export function initForgeCallLog(io) {
+  io.writeFile(LOG_PATH, '');
+}
+
+export function writeCall(io, toolName) {
+  if (!io.exists(LOG_PATH)) return;
+  const entry = JSON.stringify({ tool: toolName, ts: Date.now() }) + '\n';
+  const existing = io.readFile(LOG_PATH);
+  io.writeFile(LOG_PATH, existing + entry);
+}
+
+function addCallFromLine(line, called) {
+  try {
+    const rec = JSON.parse(line);
+    if (rec.tool) called.add(rec.tool);
+  } catch { /* skip malformed lines */ }
+}
+
+function readCallSet(io) {
+  const called = new Set();
+  if (!io.exists(LOG_PATH)) return called;
+  const content = io.readFile(LOG_PATH);
+  for (const line of content.split('\n')) {
+    if (line) addCallFromLine(line, called);
+  }
+  return called;
+}
+
+export function verifyAndClearForgeCallLog(io, expected) {
+  const called = readCallSet(io);
+  const missing = expected.filter(t => !called.has(t));
+  io.unlink(LOG_PATH);
+  return missing.length ? { ok: false, missing } : { ok: true, missing: [] };
+}
+
+export function readForgeRetryCount(io) {
+  if (!io.exists(RETRIES_PATH)) return 0;
+  try {
+    return parseInt(io.readFile(RETRIES_PATH).trim(), 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+export function incrementForgeRetryCount(io) {
+  const count = readForgeRetryCount(io) + 1;
+  io.writeFile(RETRIES_PATH, String(count));
+  return count;
+}
+
+export function resetForgeRetryCount(io) {
+  io.unlink(RETRIES_PATH);
+}

package/dist/scripts/orchestrate-cycle.js

@@ -39,7 +39,8 @@ export async function readForgeFilePatterns(cycleId, io) {
   const output = extractOutputType(cd);
   if (!output) return null;
   try {
-    return await fetchFilePatterns(output, io);
+    const patterns = await fetchFilePatterns(output, io);
+    return patterns ? { patterns, outputType: output } : null;
   } catch {
     return null;
   }
@@ -228,9 +229,28 @@ export function buildDispatchMultiResponse(tasks, stage, cycle) {
 // Dispatch prompt rendering (pure utility, used by handleSortResult and exported publicly).
 // ---------------------------------------------------------------------------
 
-export function renderDispatchPrompt({ stage, cycle, token, cwd, filePatterns }) {
+function buildForgePromptLines({ cycle, outputType }) {
+  return [
+    ``,
+    `Before producing output you MUST call these tools to understand the context:`,
+    outputType
+      ? `  - foundry_config_cycle({ cycleId: "${cycle}" }) — to learn the cycle definition, including its output type "${outputType}"`
+      : `  - foundry_config_cycle({ cycleId: "${cycle}" }) — to learn the cycle definition`,
+    outputType
+      ? `  - foundry_config_artefact_type({ typeId: "${outputType}" }) — to learn the artefact type definition and file patterns`
+      : `  - foundry_config_artefact_type({ typeId: "<output type>" }) — to learn the artefact type definition and file patterns`,
+    outputType
+      ? `  - foundry_config_laws({ typeId: "${outputType}" }) — to learn all applicable quality laws`
+      : `  - foundry_config_laws({ typeId: "<output type>" }) — to learn all applicable quality laws`,
+    `  - foundry_workfile_get({}) — to learn the goal`,
+    `  - foundry_feedback_list({}) — to check for existing feedback from prior iterations`,
+  ];
+}
+
+export function renderDispatchPrompt({ stage, cycle, token, cwd, filePatterns, outputType }) {
+  const base = stage.split(':')[0];
   const lines = [
-    `You are a Foundry stage agent. Invoke the ${stage.split(':')[0]} skill and follow its instructions exactly.`,
+    `You are a Foundry stage agent. Invoke the ${base} skill and follow its instructions exactly.`,
     ``,
     `Stage: ${stage}`,
     `Cycle: ${cycle}`,
@@ -240,6 +260,9 @@ export function renderDispatchPrompt({ stage, cycle, token, cwd, filePatterns })
   if (filePatterns && filePatterns.length) {
     lines.push(`File patterns (forge only): ${JSON.stringify(filePatterns)}`);
   }
+  if (base === 'forge') {
+    lines.push(...buildForgePromptLines({ cycle, outputType }));
+  }
   lines.push(
     ``,
     `Your FIRST tool call MUST be foundry_stage_begin({stage, cycle, token}) using the values above.`,

package/dist/scripts/orchestrate-phases.js

@@ -2,8 +2,8 @@
 // Private phase functions used by runOrchestrate.
 
 import {
-  getCycleDefinition,
   getArtefactType,
+  getCycleDefinition,
   getLawsForQuench,
 } from './lib/config.js';
 import { parseFrontmatter, writeFrontmatter } from './lib/workfile.js';
@@ -13,73 +13,40 @@ 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 {
-  readCycleTargets,
   readForgeFilePatterns,
-  readRecentFeedback,
   computeOpenFeedback,
   violation,
   tryCommit,
   synthesizeStages,
   renderDispatchPrompt,
 } from './orchestrate-cycle.js';
+import {
+  doneAction,
+  blockedAction,
+  humanAppraiseAction,
+  missingModelViolation,
+} from './orchestrate-terminals.js';
 
-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;
-}
-
-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) };
-}
-
-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 };
-}
-
-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) {
-  return { stage: route, cycle: cycleId, token, cwd, filePatterns };
+function makeDispatchPayload({ route, cycleId, token, cwd, filePatterns, outputType }) {
+  return { stage: route, cycle: cycleId, token, cwd, filePatterns, outputType };
 }
 
 async function buildDispatchAction(route, model, token, ctx) {
   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)) };
+  let filePatterns = null;
+  let outputType = null;
+  if (base === 'forge') {
+    const result = await readForgeFilePatterns(ctx.cycleId, ctx.io);
+    if (result) {
+      filePatterns = result.patterns;
+      outputType = result.outputType;
+    }
+  }
+  const payload = { route, cycleId: ctx.cycleId, token, cwd: ctx.cwd, filePatterns, outputType };
+  return { action: 'dispatch', stage: route, subagent_type: model,
+    prompt: renderDispatchPrompt(makeDispatchPayload(payload)) };
 }
 
 export function routeDispatch(route) {
@@ -282,7 +249,11 @@ function writeHistoryEntries(ctx) {
 
 async function computeAllowedPatterns(lastStage, cycleId, io) {
   const stageBase = stageBaseOf(lastStage.stage);
-  const forgeFilePatterns = stageBase === 'forge' ? (await readForgeFilePatterns(cycleId, io)) ?? [] : [];
+  let forgeFilePatterns = [];
+  if (stageBase === 'forge') {
+    const result = await readForgeFilePatterns(cycleId, io);
+    forgeFilePatterns = result ? result.patterns : [];
+  }
   return allowedPatternsForStage({ stageBase, forgeFilePatterns });
 }
 

package/dist/scripts/orchestrate-terminals.js

@@ -0,0 +1,49 @@
+import { getCycleDefinition } from './lib/config.js';
+import { getArtefactFiles } from './lib/artefacts.js';
+import { readCycleTargets, readRecentFeedback, violation } from './orchestrate-cycle.js';
+
+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;
+}
+
+export 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) };
+}
+
+export 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 };
+}
+
+export 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) } };
+}
+
+export 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);
+}

package/dist/skills/add-cycle/SKILL.md

@@ -40,6 +40,10 @@ When invoked with pre-filled fields matching the `foundry_config_create_cycle` t
 
 Context fields: `{id, name, outputType, description, inputs?, targets?, humanAppraise?, deadlockAppraise?, deadlockIterations?, maxIterations?, assay?, memory?, models?}`
 
+`inputs` is optional. A source cycle that starts from the user's run goal and has no upstream artefact dependency omits `inputs` entirely. Empty input contracts are invalid: do not pass `inputs: {type: "any-of", artefacts: []}`.
+
+`models` is a map of stage names to model IDs. Preserve user-selected model overrides exactly, for example `{forge: "opencode-go/deepseek-v4-flash", appraise: "opencode-go/qwen3.6-plus"}`.
+
 When invoked with a context:
 - If all required fields are present, skip the Understand phase and proceed to Plan → Confirm → Build.
 - If only some fields are present, ask only for the missing ones.
@@ -80,7 +84,7 @@ If the parent flow or required artefact type is missing and the user's goal clea
 
 **Optional clusters** — After each cluster, ask whether the user wants to configure it; if not, skip:
 
-- **Routing**: `inputs` (input contract: `{type: "any-of"|"all-of", artefacts: string[]}`), `targets` (cycle IDs to route to after completion), `maxIterations` (maximum iterations before forced progression)
+- **Routing**: `inputs` (input contract: `{type: "any-of"|"all-of", artefacts: string[]}`; omit for source cycles with no upstream artefact dependency), `targets` (cycle IDs to route to after completion), `maxIterations` (maximum iterations before forced progression)
 - **Human-appraise**: `humanAppraise` (boolean, default false) — human reviews every iteration; `deadlockAppraise` (boolean, default true) — human is pulled in when LLM appraisers deadlock; `deadlockIterations` (number, default 5) — deadlock threshold. Only applies when either appraise is enabled.
 - **Memory and models**: `assay` (assay configuration), `memory` (memory configuration), `models` (stage-specific model overrides, e.g. `{forge: "openai/gpt-4o", appraise: "openai/gpt-4o"}`). For models, offer each stage (forge, quench, appraise) individually. If the user has no preference, omit the `models` map and use the session defaults.
 
@@ -98,7 +102,7 @@ Ask: "Proceed with this plan?" — wait for user answer before building. If the
 
 1. **Validate**: Call `foundry_config_validate_cycle({ name: "<id>", body: "<assembled markdown>" })`. Assemble the body from the fields using the frontmatter format the tool produces internally. If the result is `{ ok: false, errors: [...] }`, address each error and re-run until `{ ok: true }`. Common issues: missing required frontmatter keys, references to artefact types or flows that do not exist yet.
 
-2. **Create**: Call `foundry_config_create_cycle({ id: "<id>", name: "<name>", outputType: "<type>", description: "<description>", inputs: ..., targets: ..., humanAppraise: ..., deadlockAppraise: ..., deadlockIterations: ..., maxIterations: ..., assay: ..., memory: ..., models: ... })`. The tool:
+2. **Create**: Call `foundry_config_create_cycle({ id: "<id>", name: "<name>", outputType: "<type>", description: "<description>", targets: ..., humanAppraise: ..., deadlockAppraise: ..., deadlockIterations: ..., maxIterations: ..., assay: ..., memory: ..., models: ... })`. Include `inputs` only when the cycle reads upstream artefacts, and include `models` whenever the user selected stage-specific model overrides. The tool:
    - re-validates the body (TOCTOU);
    - writes `foundry/cycles/<id>.md`;
    - produces one git commit on the current `config/*` branch.

package/dist/skills/add-flow/SKILL.md

@@ -69,7 +69,7 @@ Create missing dependencies in validation order:
 
 3. **Appraisers** (may reference models): For each new appraiser, gather `id`, `name`, `description`, and optional `model` preference. Context object: `{id, name, description, model?}`.
 
-4. **Cycles** (reference artefact types, laws, appraisers): For each new cycle, gather `id`, `name`, `outputType`, `description`, and any optional settings (inputs, targets, appraise, assay, memory, models). Context object: `{id, name, outputType, description, inputs?, targets?, humanAppraise?, deadlockAppraise?, deadlockIterations?, maxIterations?, assay?, memory?, models?}`.
+4. **Cycles** (reference artefact types, laws, appraisers): For each new cycle, gather `id`, `name`, `outputType`, `description`, and any optional settings (inputs, targets, appraise, assay, memory, models). Context object: `{id, name, outputType, description, inputs?, targets?, humanAppraise?, deadlockAppraise?, deadlockIterations?, maxIterations?, assay?, memory?, models?}`. For a source cycle that starts from the user's run goal and has no upstream artefact dependency, omit `inputs` entirely; never pass `inputs` with an empty `artefacts` array.
 
 For the haiku example, default to a `haiku` artefact type, `haikus/*.md` file pattern, laws for form, imagery, and mood, a deterministic syllable validator where project dependencies allow it, two or three distinct appraisers, one cycle, and one flow.
 
@@ -92,6 +92,7 @@ Flow: <id> — <name>
     · <id> — <description>
   Cycles:
     · <id> → <outputType> — <description>
+      inputs/models: <omitted or explicit settings>
 ```
 
 Ask "Proceed with this plan?" — do not build anything until the user confirms.
@@ -121,9 +122,11 @@ Build order (dependency order):
 
 4. **Cycles**: For each new cycle, invoke the `add-cycle` protocol with the captured context.
 
-   > Invoke the add-cycle protocol with context: `{id: "haiku-cycle", name: "Haiku Cycle", outputType: "haiku", description: "Generates haiku poems"}`.
+   > Invoke the add-cycle protocol with context: `{id: "haiku-cycle", name: "Haiku Cycle", outputType: "haiku", description: "Generates haiku poems", models: {forge: "opencode-go/deepseek-v4-flash", appraise: "opencode-go/qwen3.6-plus"}}`.
    > If all required fields are present, proceed directly to Build. Otherwise ask for missing required fields only.
 
+   Preserve every user-selected stage model in the cycle context. If the cycle has no upstream artefact input, leave `inputs` absent from the context.
+
 **Build-only mode**: When all required fields for a sub-skill are present in the context, the sub-skill skips Understand, Plan, and Confirm — proceeding directly to validate → create → commit. When only some required fields are present, the sub-skill enters its Understand phase to ask only for those missing required fields, then proceeds to Build (still skipping Plan and Confirm since the parent's combined plan already handled confirmation). Optional fields that are missing are silently skipped.
 
 **Error handling during build**: If a sub-skill's Build phase fails (validation error or tool error), surface the error to the user:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@really-knows-ai/foundry",
-  "version": "3.5.1",
+  "version": "3.5.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",
@@ -58,7 +58,7 @@
     "test:all": "node --test --experimental-test-module-mocks --test-reporter=dot",
     "test:coverage": "node --test --experimental-test-coverage --test-reporter=dot",
     "lint": "eslint src/ tests/ scripts/",
-    "build:full": "pnpm run lint --fix && pnpm run test:all && pnpm run build",
-    "build:all": "pnpm run lint && pnpm run test:all && pnpm run build"
+    "build:full": "pnpm run lint --fix && pnpm run test:all && pnpm run build && node scripts/seal.js",
+    "build:all": "pnpm run lint && pnpm run test:all && pnpm run build && node scripts/seal.js"
   }
 }