@sensigo/realm-cli 0.28.0 → 0.30.0

package/dist/agent/providers/llm-provider.d.ts

@@ -27,6 +27,14 @@ export declare abstract class LlmProvider {
  * Extend this class if your provider can drive tool-enabled workflow steps.
  */
 export declare abstract class ToolCapableLlmProvider extends LlmProvider {
+    /**
+     * issue #217 provider contract: every executor invocation MUST produce an entry in
+     * `toolCalls`, including failed/timed-out calls — the drive's schema-repair gate relies on
+     * `toolCalls.length === 0 ⇒ executor never invoked`. A custom `--provider-module` that violates
+     * this (e.g. swallows a failed call without recording it) is a trusted-injector residual — the
+     * repair gate would then wrongly treat a tool-using attempt as tool-free and repair it (cross-
+     * ref #224).
+     */
     abstract callStepWithTools(prompt: string, tools: ToolDefinition[], executor: ToolExecutor, options: {
         inputSchema?: Record<string, unknown>;
         maxToolCalls?: number;

package/dist/agent/providers/llm-provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"llm-provider.d.ts","sourceRoot":"","sources":["../../../src/agent/providers/llm-provider.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAElG;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;GAGG;AACH,8BAAsB,WAAW;IAC/B,gEAAgE;IAChE,QAAQ,CAAC,QAAQ,CACf,MAAM,EAAE,MAAM,EACd,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACrC,wBAAwB,CAAC,EAAE,MAAM,GAChC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEnC,6DAA6D;IAC7D,YAAY,IAAI,oBAAoB;CAGrC;AAED;;;GAGG;AACH,8BAAsB,sBAAuB,SAAQ,WAAW;IAC9D,QAAQ,CAAC,iBAAiB,CACxB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,cAAc,EAAE,EACvB,QAAQ,EAAE,YAAY,EACtB,OAAO,EAAE;QACP,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACtC,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,wBAAwB,CAAC,EAAE,MAAM,CAAC;KACnC,GACA,OAAO,CAAC,mBAAmB,CAAC;CAChC;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,WAAW,GAAG,QAAQ,IAAI,sBAAsB,CAEvF;AAED,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,WAAW,CAAC;AAElD;;;GAGG;AACH,wBAAsB,eAAe,CACnC,YAAY,EAAE,YAAY,GAAG,SAAS,EACtC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,WAAW,CAAC,CAmCtB"}
+{"version":3,"file":"llm-provider.d.ts","sourceRoot":"","sources":["../../../src/agent/providers/llm-provider.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAElG;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;GAGG;AACH,8BAAsB,WAAW;IAC/B,gEAAgE;IAChE,QAAQ,CAAC,QAAQ,CACf,MAAM,EAAE,MAAM,EACd,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACrC,wBAAwB,CAAC,EAAE,MAAM,GAChC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEnC,6DAA6D;IAC7D,YAAY,IAAI,oBAAoB;CAGrC;AAED;;;GAGG;AACH,8BAAsB,sBAAuB,SAAQ,WAAW;IAC9D;;;;;;;OAOG;IACH,QAAQ,CAAC,iBAAiB,CACxB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,cAAc,EAAE,EACvB,QAAQ,EAAE,YAAY,EACtB,OAAO,EAAE;QACP,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACtC,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,wBAAwB,CAAC,EAAE,MAAM,CAAC;KACnC,GACA,OAAO,CAAC,mBAAmB,CAAC;CAChC;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,WAAW,GAAG,QAAQ,IAAI,sBAAsB,CAEvF;AAED,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,WAAW,CAAC;AAElD;;;GAGG;AACH,wBAAsB,eAAe,CACnC,YAAY,EAAE,YAAY,GAAG,SAAS,EACtC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,WAAW,CAAC,CAmCtB"}

package/dist/agent/providers/llm-provider.js.map

@@ -1 +1 @@
-{"version":3,"file":"llm-provider.js","sourceRoot":"","sources":["../../../src/agent/providers/llm-provider.ts"],"names":[],"mappings":"AAiBA;;;GAGG;AACH,MAAM,OAAgB,WAAW;IAQ/B,6DAA6D;IAC7D,YAAY;QACV,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;IAC7B,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAgB,sBAAuB,SAAQ,WAAW;CAa/D;AAED;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,QAAqB;IACjD,OAAO,QAAQ,YAAY,sBAAsB,CAAC;AACpD,CAAC;AAID;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,YAAsC,EACtC,SAA6B,EAC7B,WAAoB;IAEpB,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,KAAK,SAAS,CAAC;IAC9D,MAAM,YAAY,GAAG,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC,KAAK,SAAS,CAAC;IAEpE,IAAI,CAAC,SAAS,IAAI,CAAC,YAAY,EAAE,CAAC;QAChC,MAAM,IAAI,KAAK,CACb,+EAA+E,CAChF,CAAC;IACJ,CAAC;IAED,MAAM,QAAQ,GAAG,YAAY,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;IAEtE,IAAI,WAAW,KAAK,SAAS,IAAI,QAAQ,KAAK,WAAW,EAAE,CAAC;QAC1D,MAAM,IAAI,KAAK,CACb,wFAAwF;YACtF,wFAAwF,CAC3F,CAAC;IACJ,CAAC;IAED,IAAI,QAAQ,KAAK,QAAQ,EAAE,CAAC;QAC1B,8EAA8E;QAC9E,sEAAsE;QACtE,+EAA+E;QAC/E,qDAAqD;QACrD,MAAM,gBAAgB,GAAG,WAAW,CAAC;QACrC,IAAI,SAAS,KAAK,SAAS,IAAI,gBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;YAChE,MAAM,EAAE,uBAAuB,EAAE,GAAG,MAAM,MAAM,CAAC,gCAAgC,CAAC,CAAC;YACnF,OAAO,IAAI,uBAAuB,CAAC,SAAS,CAAC,CAAC;QAChD,CAAC;QACD,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM,MAAM,CAAC,sBAAsB,CAAC,CAAC;QAChE,OAAO,IAAI,cAAc,CAAC,SAAS,IAAI,QAAQ,EAAE,WAAW,CAAC,CAAC;IAChE,CAAC;SAAM,CAAC;QACN,MAAM,EAAE,iBAAiB,EAAE,GAAG,MAAM,MAAM,CAAC,yBAAyB,CAAC,CAAC;QACtE,OAAO,IAAI,iBAAiB,CAAC,SAAS,IAAI,mBAAmB,CAAC,CAAC;IACjE,CAAC;AACH,CAAC"}
+{"version":3,"file":"llm-provider.js","sourceRoot":"","sources":["../../../src/agent/providers/llm-provider.ts"],"names":[],"mappings":"AAiBA;;;GAGG;AACH,MAAM,OAAgB,WAAW;IAQ/B,6DAA6D;IAC7D,YAAY;QACV,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;IAC7B,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAgB,sBAAuB,SAAQ,WAAW;CAqB/D;AAED;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,QAAqB;IACjD,OAAO,QAAQ,YAAY,sBAAsB,CAAC;AACpD,CAAC;AAID;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,YAAsC,EACtC,SAA6B,EAC7B,WAAoB;IAEpB,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,KAAK,SAAS,CAAC;IAC9D,MAAM,YAAY,GAAG,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC,KAAK,SAAS,CAAC;IAEpE,IAAI,CAAC,SAAS,IAAI,CAAC,YAAY,EAAE,CAAC;QAChC,MAAM,IAAI,KAAK,CACb,+EAA+E,CAChF,CAAC;IACJ,CAAC;IAED,MAAM,QAAQ,GAAG,YAAY,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;IAEtE,IAAI,WAAW,KAAK,SAAS,IAAI,QAAQ,KAAK,WAAW,EAAE,CAAC;QAC1D,MAAM,IAAI,KAAK,CACb,wFAAwF;YACtF,wFAAwF,CAC3F,CAAC;IACJ,CAAC;IAED,IAAI,QAAQ,KAAK,QAAQ,EAAE,CAAC;QAC1B,8EAA8E;QAC9E,sEAAsE;QACtE,+EAA+E;QAC/E,qDAAqD;QACrD,MAAM,gBAAgB,GAAG,WAAW,CAAC;QACrC,IAAI,SAAS,KAAK,SAAS,IAAI,gBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;YAChE,MAAM,EAAE,uBAAuB,EAAE,GAAG,MAAM,MAAM,CAAC,gCAAgC,CAAC,CAAC;YACnF,OAAO,IAAI,uBAAuB,CAAC,SAAS,CAAC,CAAC;QAChD,CAAC;QACD,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM,MAAM,CAAC,sBAAsB,CAAC,CAAC;QAChE,OAAO,IAAI,cAAc,CAAC,SAAS,IAAI,QAAQ,EAAE,WAAW,CAAC,CAAC;IAChE,CAAC;SAAM,CAAC;QACN,MAAM,EAAE,iBAAiB,EAAE,GAAG,MAAM,MAAM,CAAC,yBAAyB,CAAC,CAAC;QACtE,OAAO,IAAI,iBAAiB,CAAC,SAAS,IAAI,mBAAmB,CAAC,CAAC;IACjE,CAAC;AACH,CAAC"}

package/dist/agent/run-agent.d.ts

@@ -42,6 +42,16 @@ export interface AgentDeps {
      * `crypto.randomUUID()` is minted independently for EVERY step-attempt in the loop below.
      */
     mintWriterNonce?: boolean;
+    /**
+     * Budget for issue #217's in-drive schema-feedback repair loop: how many times the drive
+     * re-prompts an `execution: 'agent'` step after its output/input is rejected by
+     * output_schema/input_schema validation, appending the validator's errors to the prompt.
+     * Threaded exactly like `mintWriterNonce` above (agent.ts's `--schema-retries` flag → both
+     * runAgent call sites → this field). Default `2` when omitted (mirrors the CLI flag's own
+     * default) — `0` disables the loop entirely, reproducing today's single-attempt behavior
+     * byte-for-byte.
+     */
+    schemaRetries?: number;
 }
 export interface AgentRunOptions {
     /** Path to workflow.yaml file. Required when definition is not provided. */

package/dist/agent/run-agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-agent.d.ts","sourceRoot":"","sources":["../../src/agent/run-agent.ts"],"names":[],"mappings":"AAIA,OAAO,EAUL,KAAK,QAAQ,EACb,KAAK,kBAAkB,EAEvB,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EAEpB,KAAK,gBAAgB,EACtB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAG/D,OAAO,KAAK,EAAE,SAAS,EAAgC,MAAM,yBAAyB,CAAC;AAGvF,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,QAAQ,CAAC;AAEpD,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,QAAQ,CAAC;IAChB,aAAa,EAAE,iBAAiB,CAAC;IACjC,QAAQ,EAAE,WAAW,CAAC;IACtB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B;;;;OAIG;IACH,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE;;;OAGG;IACH,gBAAgB,CAAC,EAAE,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,SAAS,CAAC;IACnF;;;;OAIG;IACH,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAcD,MAAM,WAAW,eAAe;IAC9B,4EAA4E;IAC5E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gFAAgF;IAChF,UAAU,CAAC,EAAE,kBAAkB,CAAC;IAChC;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,8GAA8G;IAC9G,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AA0ED;;;;GAIG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CAqajG"}
+{"version":3,"file":"run-agent.d.ts","sourceRoot":"","sources":["../../src/agent/run-agent.ts"],"names":[],"mappings":"AAIA,OAAO,EAYL,KAAK,QAAQ,EACb,KAAK,kBAAkB,EAEvB,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EAEpB,KAAK,gBAAgB,EAEtB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAG/D,OAAO,KAAK,EAAE,SAAS,EAAgC,MAAM,yBAAyB,CAAC;AAGvF,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,QAAQ,CAAC;AAEpD,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,QAAQ,CAAC;IAChB,aAAa,EAAE,iBAAiB,CAAC;IACjC,QAAQ,EAAE,WAAW,CAAC;IACtB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B;;;;OAIG;IACH,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE;;;OAGG;IACH,gBAAgB,CAAC,EAAE,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,SAAS,CAAC;IACnF;;;;OAIG;IACH,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;;;;OAQG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAcD,MAAM,WAAW,eAAe;IAC9B,4EAA4E;IAC5E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gFAAgF;IAChF,UAAU,CAAC,EAAE,kBAAkB,CAAC;IAChC;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,8GAA8G;IAC9G,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AA6FD;;;;GAIG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CA+iBjG"}

package/dist/agent/run-agent.js

@@ -2,7 +2,7 @@
 // Exports runAgent(), AgentDeps, AgentRunOptions, and AgentRunResult.
 // All Slack-specific gate notification logic lives in slack-gate-notifier.ts.
 import { join } from 'node:path';
-import { loadWorkflowFromFile, findEligibleSteps, classifyInProgressClaims, executeChain, buildNextActions, findCapabilityBlockedSteps, unmetCapabilities, capabilityWarning, WorkflowError, } from '@sensigo/realm';
+import { loadWorkflowFromFile, findEligibleSteps, classifyInProgressClaims, executeChain, buildNextActions, findCapabilityBlockedSteps, unmetCapabilities, capabilityWarning, buildFailedAttemptRecord, WorkflowError, DEFAULT_VALIDATION_EXHAUSTION_THRESHOLD, } from '@sensigo/realm';
 import { setAdditionalRedactionValues } from './providers/agent-utils.js';
 import { isToolCapable } from './providers/llm-provider.js';
 import { McpClient as McpClientImpl } from './mcp/mcp-client.js';
@@ -79,6 +79,24 @@ async function pollUntilGateResolved(store, runId, gateId, intervalMs, signal) {
             break;
     }
 }
+/**
+ * Renders one whitelisted Ajv-error summary entry (issue #217, core's
+ * `buildFailedAttemptRecord(...).validation_error_summary`) as a single human-readable line for
+ * the schema-repair prompt trailer. Key NAMES only — the summary entry already strips value
+ * echoes (see failed-attempt-record.ts's `summarizeAjvErrors`), so nothing rendered here can leak
+ * a submitted or schema-declared VALUE (e.g. `enum.allowedValues`).
+ */
+function renderValidationSummaryEntry(entry) {
+    const path = entry.instancePath !== '' ? entry.instancePath : '(root)';
+    let line = `- ${path}: ${entry.message} [${entry.keyword}]`;
+    if (entry.additional_property !== undefined) {
+        line += ` (additional property: '${entry.additional_property}')`;
+    }
+    if (entry.missing_property !== undefined) {
+        line += ` (missing property: '${entry.missing_property}')`;
+    }
+    return line;
+}
 /**
  * Runs a workflow to completion using the provided dependencies.
  * Returns 'completed' when the run finishes normally; 'failed' otherwise.
@@ -92,6 +110,9 @@ export async function runAgent(deps, options) {
     // tool-execution errors serialized by the provider loop get these values masked
     // alongside process.env values.
     setAdditionalRedactionValues(deps.redactionValues ?? []);
+    // issue #217: resolved once per run (not per call, unlike shouldMintWriterNonce — there is no
+    // env-var strict-flip counterpart here). `0` disables the repair loop entirely.
+    const schemaRetries = deps.schemaRetries ?? 2;
     // Load or use provided definition.
     const definition = options.definition !== undefined
         ? options.definition
@@ -205,166 +226,278 @@ export async function runAgent(deps, options) {
             }
             const stepName = eligible[0];
             const stepDef = definition.steps[stepName];
-            let stepInput;
+            // issue #217: the in-drive schema-feedback repair loop. `stepInput`/`toolCallsForMeta`/
+            // `result` are re-assigned on every attempt inside the `for` loop below; `repairsUsed`/
+            // `lastRejection` persist ACROSS attempts within this one step, and are fresh (0/undefined)
+            // for every new step. The loop body is exactly the former single-pass step-execution region
+            // (the agent/auto branch bodies + the executeChain call) — an auto step's
+            // `execution !== 'agent'` means the repair gate's conjunct (iii) can never hold for it, so
+            // it structurally can never iterate more than once: the loop is a no-op wrapper for every
+            // pre-existing (non-repair) case.
+            let stepInput = {};
             let toolCallsForMeta;
-            if (stepDef.execution === 'agent') {
-                // Resolve template-expanded prompt via buildNextActions so {{ context.resources.* }}
-                // references are substituted before the LLM call.
-                const nextActions = buildNextActions(definition, currentRun);
-                const nextAction = nextActions.find((a) => a.instruction !== null &&
-                    a.instruction.call_with['command'] === stepName) ?? nextActions[0];
-                const prompt = nextAction?.prompt ?? stepDef.description;
-                // #robust-anthropic-provider Part 1: route the schema the ENGINE validates output against
-                // (output_schema, execution-loop.ts validateOutputSchema) ahead of the execute_step-param
-                // schema (input_schema / nextAction.input_schema) the provider was fed until now. Both-
-                // declared-and-divergent degrades to a clean recoverable VALIDATION_*_SCHEMA error downstream,
-                // not a parse-strand — see the Part 6 loader warning for the authoring-time signal.
-                const inputSchema = stepDef.output_schema ??
-                    nextAction?.input_schema ??
-                    stepDef.input_schema;
-                const agentProfileInstructions = stepDef.agent_profile !== undefined
-                    ? definition.resolved_profiles?.[stepDef.agent_profile]?.content
-                    : undefined;
-                const descPreview = stepDef.description.slice(0, 80);
-                console.log(`\n→ [agent] ${stepName}`);
-                console.log(`  ${descPreview}${stepDef.description.length > 80 ? '…' : ''}`);
-                if (stepDef.tools && stepDef.tools.length > 0 && mcpClient) {
-                    // Tools path: build tool definitions, call callStepWithTools.
-                    const byServer = new Map();
-                    for (const entry of stepDef.tools) {
-                        const [serverId, toolName] = entry.split(':');
-                        if (!byServer.has(serverId))
-                            byServer.set(serverId, []);
-                        byServer.get(serverId).push(toolName);
+            let result;
+            let repairsUsed = 0;
+            let lastRejection;
+            for (;;) {
+                toolCallsForMeta = undefined;
+                // issue #217 conjunct (vi) ground truth — captured FRESH at the top of EVERY attempt
+                // (including the first), never once per step: a per-step capture is stale across the
+                // whole provider LLM call, so any concurrent writer (a second drive, a gate `respond`, a
+                // parallel-step settle) landing during that call would silently forfeit a legitimate
+                // repair. See the repair-gate comment below for the full discriminator rationale. Cost:
+                // one extra store read per attempt — accepted.
+                const versionBeforeAttempt = (await deps.store.get(runId)).version;
+                if (stepDef.execution === 'agent') {
+                    // Resolve template-expanded prompt via buildNextActions so {{ context.resources.* }}
+                    // references are substituted before the LLM call. Pure w.r.t. `definition`/`currentRun`,
+                    // both unchanged across repair attempts — a rejected attempt no longer leaves
+                    // `currentRun` itself stale relative to what's persisted (issue #220: countRejection DOES
+                    // persist a bounded rejection counter on a counted rejection — "nothing is ever
+                    // persisted on a rejected attempt" is FALSE as of #220), but `currentRun`/`definition`
+                    // are still safe to recompute per iteration here regardless, since neither is read from
+                    // again until the NEXT step (this step's own next_actions/prompt derivation never
+                    // consults `validation_rejections`).
+                    const nextActions = buildNextActions(definition, currentRun);
+                    const nextAction = nextActions.find((a) => a.instruction !== null &&
+                        a.instruction.call_with['command'] === stepName) ?? nextActions[0];
+                    // PRISTINE original prompt — never mutated across repair attempts. The prompt actually
+                    // sent to the provider (`promptForAttempt` below) is always derived FRESH from this,
+                    // plus at most the LATEST rejection's feedback — never accumulated, never stale.
+                    const prompt = nextAction?.prompt ?? stepDef.description;
+                    const promptForAttempt = lastRejection !== undefined
+                        ? `${prompt}\n\nYour previous output was rejected by the ${lastRejection.kind} schema validator:\n${lastRejection.summary}\nEmit corrected JSON only, matching the schema exactly.`
+                        : prompt;
+                    // #robust-anthropic-provider Part 1: route the schema the ENGINE validates output against
+                    // (output_schema, execution-loop.ts validateOutputSchema) ahead of the execute_step-param
+                    // schema (input_schema / nextAction.input_schema) the provider was fed until now. Both-
+                    // declared-and-divergent degrades to a clean recoverable VALIDATION_*_SCHEMA error downstream,
+                    // not a parse-strand — see the Part 6 loader warning for the authoring-time signal.
+                    const inputSchema = stepDef.output_schema ??
+                        nextAction?.input_schema ??
+                        stepDef.input_schema;
+                    const agentProfileInstructions = stepDef.agent_profile !== undefined
+                        ? definition.resolved_profiles?.[stepDef.agent_profile]?.content
+                        : undefined;
+                    if (repairsUsed === 0) {
+                        const descPreview = stepDef.description.slice(0, 80);
+                        console.log(`\n→ [agent] ${stepName}`);
+                        console.log(`  ${descPreview}${stepDef.description.length > 80 ? '…' : ''}`);
+                        // issue #220 deliverable 7 — drive-time coherence warn: once per step (gated on the
+                        // same `repairsUsed === 0` this banner uses), warn when the repair budget itself
+                        // (schemaRetries + 1 attempts) exceeds the engine's own exhaustion threshold for this
+                        // step — operator intent would be silently truncated mid-loop (the drive keeps
+                        // repairing past the point the engine terminalizes the step with VALIDATION_EXHAUSTED).
+                        const exhaustionThreshold = stepDef.validation_exhaustion?.threshold ?? DEFAULT_VALIDATION_EXHAUSTION_THRESHOLD;
+                        if (schemaRetries + 1 > exhaustionThreshold) {
+                            console.error(`  ⚠ --schema-retries ${schemaRetries} (repair budget ${schemaRetries + 1} attempts) ` +
+                                `exceeds step '${stepName}''s validation-exhaustion threshold ` +
+                                `(${exhaustionThreshold}) — the engine will terminalize this step before the ` +
+                                `repair loop's own budget is exhausted.`);
+                        }
                     }
-                    let toolsResult;
-                    try {
-                        const toolDefs = [];
-                        const barenameOwner = new Map(); // bareName → serverId of first registration
-                        for (const [serverId, allowList] of byServer) {
-                            const mcpTools = await mcpClient.getTools(serverId, allowList);
-                            const returnedNames = new Set(mcpTools.map((t) => t.name));
-                            for (const name of allowList) {
-                                if (!returnedNames.has(name)) {
-                                    throw new WorkflowError(`Step '${stepName}' declares tool '${serverId}:${name}' which is not exposed by MCP server '${serverId}'. ` +
-                                        `Check the tool name against the server's published tool list.`, {
-                                        code: 'MCP_TOOL_NOT_FOUND',
-                                        category: 'ENGINE',
-                                        agentAction: 'stop',
-                                        retryable: false,
-                                    });
+                    if (stepDef.tools && stepDef.tools.length > 0 && mcpClient) {
+                        // Tools path: build tool definitions, call callStepWithTools. Rebuilt every attempt
+                        // (issue #217) — safe: repair only ever follows a ZERO-toolCall attempt, so no budget
+                        // was spent and nothing can duplicate.
+                        const byServer = new Map();
+                        for (const entry of stepDef.tools) {
+                            const [serverId, toolName] = entry.split(':');
+                            if (!byServer.has(serverId))
+                                byServer.set(serverId, []);
+                            byServer.get(serverId).push(toolName);
+                        }
+                        let toolsResult;
+                        try {
+                            const toolDefs = [];
+                            const barenameOwner = new Map(); // bareName → serverId of first registration
+                            for (const [serverId, allowList] of byServer) {
+                                const mcpTools = await mcpClient.getTools(serverId, allowList);
+                                const returnedNames = new Set(mcpTools.map((t) => t.name));
+                                for (const name of allowList) {
+                                    if (!returnedNames.has(name)) {
+                                        throw new WorkflowError(`Step '${stepName}' declares tool '${serverId}:${name}' which is not exposed by MCP server '${serverId}'. ` +
+                                            `Check the tool name against the server's published tool list.`, {
+                                            code: 'MCP_TOOL_NOT_FOUND',
+                                            category: 'ENGINE',
+                                            agentAction: 'stop',
+                                            retryable: false,
+                                        });
+                                    }
                                 }
-                            }
-                            for (const mcpTool of mcpTools) {
-                                const firstOwner = barenameOwner.get(mcpTool.name);
-                                if (firstOwner !== undefined) {
-                                    throw new WorkflowError(`Tool name collision in step '${stepName}': '${mcpTool.name}' is exposed by both '${firstOwner}' and '${serverId}'. ` +
-                                        `Tool names must be unique across all connected servers within a step.`, {
-                                        code: 'MCP_TOOL_NAME_COLLISION',
-                                        category: 'ENGINE',
-                                        agentAction: 'stop',
-                                        retryable: false,
+                                for (const mcpTool of mcpTools) {
+                                    const firstOwner = barenameOwner.get(mcpTool.name);
+                                    if (firstOwner !== undefined) {
+                                        throw new WorkflowError(`Tool name collision in step '${stepName}': '${mcpTool.name}' is exposed by both '${firstOwner}' and '${serverId}'. ` +
+                                            `Tool names must be unique across all connected servers within a step.`, {
+                                            code: 'MCP_TOOL_NAME_COLLISION',
+                                            category: 'ENGINE',
+                                            agentAction: 'stop',
+                                            retryable: false,
+                                        });
+                                    }
+                                    barenameOwner.set(mcpTool.name, serverId);
+                                    toolDefs.push({
+                                        id: `${serverId}:${mcpTool.name}`,
+                                        serverId,
+                                        name: mcpTool.name,
+                                        description: mcpTool.description,
+                                        inputSchema: mcpTool.inputSchema,
                                     });
                                 }
-                                barenameOwner.set(mcpTool.name, serverId);
-                                toolDefs.push({
-                                    id: `${serverId}:${mcpTool.name}`,
-                                    serverId,
-                                    name: mcpTool.name,
-                                    description: mcpTool.description,
-                                    inputSchema: mcpTool.inputSchema,
-                                });
                             }
-                        }
-                        const baseExecutor = async (namespacedName, args) => {
-                            const [serverId, toolName] = namespacedName.split(':');
-                            return mcpClient.call(serverId, toolName, args);
-                        };
-                        // Wrap the executor to enforce max_fan_out when set.
-                        // Counts calls to start_run and start_run_batch (regardless of server prefix).
-                        let fanOutCallCount = 0;
-                        const maxFanOut = stepDef.max_fan_out;
-                        const executor = async (namespacedName, args) => {
-                            const toolName = namespacedName.includes(':')
-                                ? namespacedName.split(':')[1]
-                                : namespacedName;
-                            if (toolName === 'start_run' || toolName === 'start_run_batch') {
-                                fanOutCallCount += 1;
-                                if (maxFanOut !== undefined && fanOutCallCount > maxFanOut) {
-                                    throw new WorkflowError(`max_fan_out of ${maxFanOut} reached for step '${stepName}'. ` +
-                                        `No further start_run or start_run_batch calls are permitted in this step.`, {
-                                        code: 'VALIDATION_BATCH_TOO_LARGE',
-                                        category: 'VALIDATION',
-                                        agentAction: 'provide_input',
-                                        retryable: false,
-                                    });
+                            const baseExecutor = async (namespacedName, args) => {
+                                const [serverId, toolName] = namespacedName.split(':');
+                                return mcpClient.call(serverId, toolName, args);
+                            };
+                            // Wrap the executor to enforce max_fan_out when set.
+                            // Counts calls to start_run and start_run_batch (regardless of server prefix).
+                            let fanOutCallCount = 0;
+                            const maxFanOut = stepDef.max_fan_out;
+                            const executor = async (namespacedName, args) => {
+                                const toolName = namespacedName.includes(':')
+                                    ? namespacedName.split(':')[1]
+                                    : namespacedName;
+                                if (toolName === 'start_run' || toolName === 'start_run_batch') {
+                                    fanOutCallCount += 1;
+                                    if (maxFanOut !== undefined && fanOutCallCount > maxFanOut) {
+                                        throw new WorkflowError(`max_fan_out of ${maxFanOut} reached for step '${stepName}'. ` +
+                                            `No further start_run or start_run_batch calls are permitted in this step.`, {
+                                            code: 'VALIDATION_BATCH_TOO_LARGE',
+                                            category: 'VALIDATION',
+                                            agentAction: 'provide_input',
+                                            retryable: false,
+                                        });
+                                    }
                                 }
+                                return baseExecutor(namespacedName, args);
+                            };
+                            if (!isToolCapable(deps.provider)) {
+                                throw new Error('invariant: provider lost tool capability between startup and step execution');
                             }
-                            return baseExecutor(namespacedName, args);
-                        };
-                        if (!isToolCapable(deps.provider)) {
-                            throw new Error('invariant: provider lost tool capability between startup and step execution');
+                            // #robust-anthropic-provider Part 1: same output-over-input precedence as the callStep
+                            // path above.
+                            const toolsEffectiveOutputSchema = stepDef.output_schema ??
+                                stepDef.input_schema;
+                            toolsResult = await deps.provider.callStepWithTools(promptForAttempt, toolDefs, executor, {
+                                ...(toolsEffectiveOutputSchema !== undefined
+                                    ? { inputSchema: toolsEffectiveOutputSchema }
+                                    : {}),
+                                maxToolCalls: stepDef.max_tool_calls ?? 20,
+                                ...(stepDef.max_fan_out !== undefined ? { maxFanOut: stepDef.max_fan_out } : {}),
+                                toolTimeoutMs: (stepDef.tool_timeout ?? 30) * 1000,
+                                ...(agentProfileInstructions !== undefined ? { agentProfileInstructions } : {}),
+                            });
+                        }
+                        catch (err) {
+                            console.error(`\n✗ Step '${stepName}' (tools) failed: ${err instanceof Error ? err.message : String(err)}`);
+                            return 'failed';
                         }
-                        // #robust-anthropic-provider Part 1: same output-over-input precedence as the callStep
-                        // path above.
-                        const toolsEffectiveOutputSchema = stepDef.output_schema ??
-                            stepDef.input_schema;
-                        toolsResult = await deps.provider.callStepWithTools(prompt, toolDefs, executor, {
-                            ...(toolsEffectiveOutputSchema !== undefined
-                                ? { inputSchema: toolsEffectiveOutputSchema }
-                                : {}),
-                            maxToolCalls: stepDef.max_tool_calls ?? 20,
-                            ...(stepDef.max_fan_out !== undefined ? { maxFanOut: stepDef.max_fan_out } : {}),
-                            toolTimeoutMs: (stepDef.tool_timeout ?? 30) * 1000,
-                            ...(agentProfileInstructions !== undefined ? { agentProfileInstructions } : {}),
-                        });
+                        stepInput = toolsResult.output;
+                        toolCallsForMeta = toolsResult.toolCalls;
                     }
-                    catch (err) {
-                        console.error(`\n✗ Step '${stepName}' (tools) failed: ${err instanceof Error ? err.message : String(err)}`);
-                        return 'failed';
+                    else {
+                        // Retry the LLM call once on failure before giving up.
+                        let callError;
+                        stepInput = {};
+                        for (let attempt = 0; attempt < 2; attempt++) {
+                            try {
+                                stepInput = await deps.provider.callStep(promptForAttempt, inputSchema, agentProfileInstructions);
+                                callError = undefined;
+                                break;
+                            }
+                            catch (err) {
+                                callError = err;
+                                console.warn(`  ⚠  LLM call attempt ${attempt + 1} failed: ${err instanceof Error ? err.message : String(err)}`);
+                            }
+                        }
+                        if (callError !== undefined) {
+                            console.error(`\n✗ Step '${stepName}' LLM call failed after 2 attempts`);
+                            return 'failed';
+                        }
                     }
-                    stepInput = toolsResult.output;
-                    toolCallsForMeta = toolsResult.toolCalls;
                 }
                 else {
-                    // Retry the LLM call once on failure before giving up.
-                    let callError;
+                    // Auto step — the engine dispatches to the service adapter directly.
+                    console.log(`→ [auto] ${stepName}`);
                     stepInput = {};
-                    for (let attempt = 0; attempt < 2; attempt++) {
-                        try {
-                            stepInput = await deps.provider.callStep(prompt, inputSchema, agentProfileInstructions);
-                            callError = undefined;
-                            break;
-                        }
-                        catch (err) {
-                            callError = err;
-                            console.warn(`  ⚠  LLM call attempt ${attempt + 1} failed: ${err instanceof Error ? err.message : String(err)}`);
-                        }
-                    }
-                    if (callError !== undefined) {
-                        console.error(`\n✗ Step '${stepName}' LLM call failed after 2 attempts`);
-                        return 'failed';
-                    }
                 }
+                result = await executeChain(deps.store, definition, {
+                    runId,
+                    command: stepName,
+                    input: stepInput,
+                    dispatcher: async () => stepInput,
+                    registry: deps.registry,
+                    ...(deps.traceBufferStore !== undefined
+                        ? { traceBufferStore: deps.traceBufferStore }
+                        : {}),
+                    ...(toolCallsForMeta !== undefined ? { stepMeta: { toolCalls: toolCallsForMeta } } : {}),
+                    // issue #197 PR-2: a FRESH nonce per step-attempt — resolved per call, never cached, so
+                    // the strict-flip (checked inside shouldMintWriterNonce) is honored even if the env var
+                    // changes mid-process (tests flip it). Also fresh per issue #217 repair attempt, since
+                    // this call sits inside the repair loop.
+                    ...(shouldMintWriterNonce(deps) ? { writerNonce: crypto.randomUUID() } : {}),
+                });
+                // issue #217: the in-drive schema-feedback repair gate. Fires ONLY when ALL SIX conjuncts
+                // hold — see plans/issue-217/design-v2.md §Mechanism for the rationale on (i)-(v).
+                //
+                // Conjunct (vi) — CORRECTED from the design record's literal `result.command === stepName`
+                // (flagged as a divergence in the implementation report): the record's premise was that
+                // executeChain "returns the DEEPER step's own envelope" on a chain-replacement error,
+                // citing execution-loop.ts:2855-2859/:3015 (executeChainInternal's recursive early-return,
+                // which DOES set `command` to the deeper step). But run-agent.ts calls the PUBLIC
+                // `executeChain` wrapper, not executeChainInternal directly — and that wrapper
+                // unconditionally overwrites the returned envelope's `command` back to the TOP-LEVEL
+                // requested command on every call (execution-loop.ts:3094, `command: options.command`),
+                // confirmed empirically against the built engine. So `result.command` always equals
+                // `stepName` here and can never discriminate a deeper chained step's error from this step's
+                // own — the literal conjunct is vacuously true and provides zero protection.
+                //
+                // The corrected, structurally-sound discriminator: a pre-claim validation rejection is
+                // write-free (no run-record version bump — see execute-step.ts:77-80 / execution-loop.ts's
+                // Step 2b/2c, both before claimStep). So if `result.run_version` has advanced past
+                // `versionBeforeAttempt` (captured fresh at the top of each repair attempt), something
+                // committed to the run BEFORE this error occurred — e.g. THIS step's own claim+settle,
+                // followed by a DEEPER chained step's pre-claim rejection — so the error cannot be this
+                // step's own output/input. A concurrent external writer bumping the run mid-attempt also
+                // lands here — the gate then fails CLOSED (repair forfeited, today's failure path). See
+                // run-agent.test.ts's "chained-auto no-false-repair" and concurrent-writer tests.
+                //
+                // issue #220 (SHIPPED): countRejection now persists a bounded rejection counter via a
+                // real CAS write on a counted rejection — rejected attempts are NO LONGER write-free w.r.t.
+                // the run record. What keeps this conjunct sound anyway is bump-and-report: the write's
+                // return value is discarded, and the rejection's own ENVELOPE keeps reporting the
+                // PRE-write version (the Step-1 `run`), so `result.run_version` still equals
+                // `versionBeforeAttempt` here across repairs 2..N. Pin (a) (bump-and-report) guards this
+                // invariant — see execution-loop.ts's countRejection for the mechanism, and
+                // packages/core/src/engine/validation-exhaustion.test.ts's pin (a) for the pin.
+                if (result.status === 'error' &&
+                    (result.error_code === 'VALIDATION_OUTPUT_SCHEMA' ||
+                        result.error_code === 'VALIDATION_INPUT_SCHEMA') &&
+                    stepDef.execution === 'agent' &&
+                    (toolCallsForMeta === undefined || toolCallsForMeta.length === 0) &&
+                    repairsUsed < schemaRetries &&
+                    result.run_version === versionBeforeAttempt) {
+                    repairsUsed++;
+                    const record = buildFailedAttemptRecord({
+                        run_id: runId,
+                        workflow_id: definition.id,
+                        step_id: stepName,
+                        ts: new Date().toISOString(),
+                        error_code: result.error_code,
+                        ajv_errors: result.error_details?.['errors'] ?? [],
+                        params: stepInput,
+                        trace_entry_count: 0,
+                    });
+                    lastRejection = {
+                        kind: result.error_code === 'VALIDATION_OUTPUT_SCHEMA' ? 'output' : 'input',
+                        summary: record.validation_error_summary.map(renderValidationSummaryEntry).join('\n'),
+                    };
+                    console.error(`  ⚠ output rejected (${result.error_code}); repairing (attempt ${repairsUsed}/${schemaRetries})`);
+                    continue;
+                }
+                break;
             }
-            else {
-                // Auto step — the engine dispatches to the service adapter directly.
-                console.log(`→ [auto] ${stepName}`);
-                stepInput = {};
-            }
-            const result = await executeChain(deps.store, definition, {
-                runId,
-                command: stepName,
-                input: stepInput,
-                dispatcher: async () => stepInput,
-                registry: deps.registry,
-                ...(deps.traceBufferStore !== undefined ? { traceBufferStore: deps.traceBufferStore } : {}),
-                ...(toolCallsForMeta !== undefined ? { stepMeta: { toolCalls: toolCallsForMeta } } : {}),
-                // issue #197 PR-2: a FRESH nonce per step-attempt — resolved per call, never cached, so
-                // the strict-flip (checked inside shouldMintWriterNonce) is honored even if the env var
-                // changes mid-process (tests flip it).
-                ...(shouldMintWriterNonce(deps) ? { writerNonce: crypto.randomUUID() } : {}),
-            });
             if (result.status === 'error') {
                 // #134: a NOT-REGISTERED handler/adapter settles RECOVERABLY — the run is NOT failed, the step
                 // is parked awaiting a capable runner. Detect structurally via error_code (not message text) and
@@ -372,6 +505,9 @@ export async function runAgent(deps, options) {
                 // (no 'blocked' AgentRunResult variant, by design) — the distinction lives in the message.
                 const isCapabilityBlock = result.error_code === 'ENGINE_HANDLER_NOT_REGISTERED' ||
                     result.error_code === 'ENGINE_ADAPTER_NOT_REGISTERED';
+                // issue #217: append the repair count ONLY when at least one repair actually ran — never
+                // "after 0 schema-repair attempts".
+                const repairSuffix = repairsUsed > 0 ? ` after ${repairsUsed} schema-repair attempts` : '';
                 if (isCapabilityBlock) {
                     currentRun = await deps.store.get(runId);
                     const block = findCapabilityBlockedSteps(currentRun).find((b) => b.step === stepName);
@@ -384,7 +520,7 @@ export async function runAgent(deps, options) {
                         `The run is NOT failed — add ${need} and re-attach (\`realm agent --run-id ${runId}\`).`);
                 }
                 else {
-                    console.error(`\n✗ Step '${stepName}' failed: ${result.errors.join(', ')}`);
+                    console.error(`\n✗ Step '${stepName}' failed: ${result.errors.join(', ')}${repairSuffix}`);
                 }
                 return 'failed';
             }