@really-knows-ai/foundry 3.5.3 → 3.5.4

package/dist/.opencode/plugins/foundry-tools/orchestrate-tool.js

@@ -87,18 +87,28 @@ async function injectDispatchPromptExtras(result, cwd) {
   result.prompt = `${result.prompt}\n\n${extras}`;
 }
 
+function buildOrchestrateArgs(tool) {
+  return {
+    lastResult: tool.schema.object({
+      ok: tool.schema.boolean(),
+      error: tool.schema.string().optional(),
+    }).optional().describe('Result of a single-subagent dispatch or human-appraise stage'),
+    lastResults: tool.schema.array(tool.schema.object({
+      ok: tool.schema.boolean(),
+      output: tool.schema.string().optional(),
+      error: tool.schema.string().optional(),
+    })).optional().describe('Results of a dispatch_multi (appraise) — one entry per completed appraiser task'),
+    cycleDef: tool.schema.string().optional().describe('Test-mode cycle definition override (path to cycle file)'),
+    baseBranch: tool.schema.string().optional().describe('Git base branch for artefact diff comparison (default "main")'),
+    defaultModel: tool.schema.string().optional().describe('Fallback model for stages with no explicit model in the cycle definition (e.g. "opencode-go/deepseek-v4-flash")'),
+  };
+}
+
 export function createOrchestrateTool({ tool, pending }) {
   return {
     foundry_orchestrate: tool({
-      description: 'Run the next step of the current cycle. Call with no args on first invocation; call with lastResult={ok,error?} after a dispatch/human_appraise completes. Returns {action, ...} describing what the caller should do next.',
-      args: {
-        lastResult: tool.schema.object({
-          ok: tool.schema.boolean(),
-          error: tool.schema.string().optional(),
-        }).optional(),
-        cycleDef: tool.schema.string().optional().describe('Test-mode cycle definition override (path to cycle file)'),
-        defaultModel: tool.schema.string().optional().describe('Fallback model for stages with no explicit model in the cycle definition (e.g. "opencode-go/deepseek-v4-flash")'),
-      },
+      description: 'Run the next step of the current cycle. Call with no args on first invocation. After a dispatch or human_appraise, pass lastResult={ok,error?}. After a dispatch_multi (appraise), pass lastResults as an array of {ok,output?,error?} — one entry per completed task. Returns {action, ...} describing what the caller should do next.',
+      args: buildOrchestrateArgs(tool),
 
       async execute(args, context) {
         const { runOrchestrate } = await import('../../../scripts/orchestrate.js');
@@ -107,21 +117,9 @@ export function createOrchestrateTool({ tool, pending }) {
         const secret = readOrCreateSecret(context.worktree);
 
         try {
-          // Branch guard. Kept inline because the orchestrate tool surfaces all errors through its violation
-          // envelope (see comment on the failed-flow guard below). A
-          // wrong-branch refusal is a more fundamental error than failed
-          // flow, so it runs first.
           const branchGuard = requireOnFlowBranch({ exec: makeExec(cwd) });
           if (!branchGuard.ok) return JSON.stringify({ error: `foundry_orchestrate: ${branchGuard.error}` });
 
-          // Failed-flow guard. Kept inline to preserve the violation envelope.
-          // because requireNotFailed parses WORK.md frontmatter, which throws
-          // on malformed YAML. The surrounding try/catch (line 30) converts
-          // that throw into a violation-shaped envelope per the contract
-          // exercised by tests/plugin/orchestrate-wrapper.test.js. A guarded()
-          // wrapper would let the throw escape to a plain { error } envelope
-          // and break that contract. orchestrate-tool is the one Phase 1.5
-          // exception to the inline-gate refactor.
           const failedGuard = requireNotFailed(io);
           if (!failedGuard.ok) return JSON.stringify({ error: `foundry_orchestrate: ${failedGuard.error}` });
 
@@ -132,7 +130,9 @@ export function createOrchestrateTool({ tool, pending }) {
           const result = await runOrchestrate({
             cwd, cycleDef: args.cycleDef, git, mint, finalize,
             now: () => Date.now(),
-            lastResult: args.lastResult ?? null,
+            lastResult: args.lastResult,
+            lastResults: args.lastResults,
+            baseBranch: args.baseBranch,
             defaultModel: args.defaultModel,
           }, io);
 

package/dist/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [3.5.4] - 2026-05-23
+
+### Fixed
+
+- `lastResults` was handled by the orchestration engine but invisible to the tool interface — the schema, description, and execute bridge all omitted it, making the appraise consolidation path unreachable through `foundry_orchestrate`.
+- `baseBranch` was computed by the engine but dropped at the tool boundary.
+
+### Changed
+
+- Clarified the commit model in the add-flow skill so agents do not re-check whether config file edits were committed.
+
 ## [3.5.3] - 2026-05-23
 
 ### Added

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

@@ -103,6 +103,8 @@ If the user rejects the plan, return to the Understand phase and adjust.
 
 For each dependency, invoke the sub-skill's protocol with the captured context object. The context object for each sub-skill matches the args of the corresponding `foundry_config_create_*` tool, with fields populated from the Understand and Gather phases.
 
+Each `foundry_config_create_*` tool commits every pending change under `foundry/`, not just the file it creates. If you edit a config file directly between tool calls (for example, to add appraiser configuration to an artefact type after those appraisers are created), the next `foundry_config_create_*` call picks it up. After the final tool call `git status` is always clean — no further checks are needed.
+
 Build order (dependency order):
 
 1. **Artefact types**: For each new artefact type, invoke the `add-artefact-type` protocol with the captured context. Example:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@really-knows-ai/foundry",
-  "version": "3.5.3",
+  "version": "3.5.4",
   "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",