@lumpcode/recipes 0.0.15 → 0.0.17

package/README.md

@@ -19,6 +19,8 @@ npm install @lumpcode/recipes
 | **abstractionFinder** | `abstractionFinder` | Ephemeral contexts that scan for duplicated CLI utils and append one backlog item + requirements doc per run |
 | **abstractionBacklog** | `abstractionBacklog` | Folder backlog items with requirements — implement abstraction with verify-until-green, then move item to completed/ |
 
+Recipe factories and variable-carrying kit helpers accept the same dual generics as `defineConfig` from `@lumpcode/cli-utils`: `<V extends LumpVariables, SV extends StepVariables>`, with defaults equal to the unbound bags. Pass explicit type args when refining preset contracts; omit them for classic untyped configs.
+
 ## Backlog layout
 
 The backlog recipes (`backlog`, `featureBacklog`, `abstractionBacklog`) use a folder backlog under `backlogItems/`:
@@ -39,8 +41,8 @@ The backlog recipes (`backlog`, `featureBacklog`, `abstractionBacklog`) use a fo
 
 Flat helpers under `src/kit/` (re-exported from the package root):
 
-- `backlog` recipe helpers — `resolveBacklogPaths`, `validateBaseBacklogItem`, `requireArtifactStep`, `projectRootFromConfigUrl`
-- `getRecursiveSteps` — agent step(s) + validation command, retry until pass
+- `backlog` recipe helpers — `resolveBacklogPaths`, `validateBaseBacklogItem`, `requireArtifactStep` (artifact `ValidationCommandFn`), `projectRootFromConfigUrl`
+- `getRecursiveSteps` — agent step(s) + validation command, retry until pass (retries via `postCommandExecFn` returned steps)
 - `retryUntilGreen` — opinionated wrapper over `getRecursiveSteps` with default fix prompt
 - `ephemeralContextListFn` — N fresh synthetic contexts per run (`contextCount`, index-aware names)
 - `folderBacklogContexts` — `getContextListFn` from `backlogItems/todo/` with optional per-item parsing
@@ -80,26 +82,30 @@ Context variables injected by `backlog`: `TASK_NAME`, `TASK`, `BACKLOG_ITEMS_DIR
 
 ```ts
 // .lumpcode/lumps/backlog/config.ts
-import { LumpJsConfig } from '@lumpcode/cli-types';
+import {
+    type CursorPresetLumpVariables,
+    type CursorPresetStepVariables,
+} from '@lumpcode/cli-utils';
 import { featureBacklog } from '@lumpcode/recipes';
 
-export default {
-    ...featureBacklog({
-        baseBranch: 'dev',
-        command: 'cursor',
-        configUrl: import.meta.url,
-        registerCommands: ['cursor'],
-        maximumNumberOfConcurrentBranches: 5,
-        verbose: true,
-        keepHistory: true,
-        lumpVariables: { model: 'composer-2.5' },
-        discoveryBranch: 'dev',
-        implValidateCommand: [
-            'npm run build -w=@lumpcode/cli',
-            'npm run test -w=@lumpcode/cli',
-        ].join(' && '),
-    }),
-} satisfies LumpJsConfig;
+export default featureBacklog<
+    CursorPresetLumpVariables,
+    CursorPresetStepVariables
+>({
+    baseBranch: 'dev',
+    command: 'cursor',
+    configUrl: import.meta.url,
+    registerCommands: ['cursor'],
+    maximumNumberOfConcurrentBranches: 5,
+    verbose: true,
+    keepHistory: true,
+    lumpVariables: { model: 'composer-2.5' },
+    discoveryBranch: 'dev',
+    implValidateCommand: [
+        'npm run build -w=@lumpcode/cli',
+        'npm run test -w=@lumpcode/cli',
+    ].join(' && '),
+});
 ```
 
 ### abstractionFinder + abstractionBacklog
@@ -108,45 +114,53 @@ Two-lump pipeline: finder tops up the implementer backlog; implementer runs item
 
 ```ts
 // .lumpcode/lumps/abstractionFinder/config.ts
-import { LumpJsConfig } from '@lumpcode/cli-types';
+import {
+    type CursorPresetLumpVariables,
+    type CursorPresetStepVariables,
+} from '@lumpcode/cli-utils';
 import { abstractionFinder } from '@lumpcode/recipes';
 
-export default {
-    ...abstractionFinder({
-        maxPendingAbstractions: 5,
-        scanDirectories: ['packages/apps/cli'],
-        backlogItemsDir: '.lumpcode/lumps/abstractionImplementer/backlogItems',
-        command: 'cursor',
-        lumpVariables: { model: 'composer-2.5' },
-        discoveryBranch: 'dev',
-    }),
-} satisfies LumpJsConfig;
+export default abstractionFinder<
+    CursorPresetLumpVariables,
+    CursorPresetStepVariables
+>({
+    maxPendingAbstractions: 5,
+    scanDirectories: ['packages/apps/cli'],
+    backlogItemsDir: '.lumpcode/lumps/abstractionImplementer/backlogItems',
+    command: 'cursor',
+    lumpVariables: { model: 'composer-2.5' },
+    discoveryBranch: 'dev',
+});
 ```
 
 ```ts
 // .lumpcode/lumps/abstractionImplementer/config.ts
-import { LumpJsConfig } from '@lumpcode/cli-types';
+import {
+    type CursorPresetLumpVariables,
+    type CursorPresetStepVariables,
+} from '@lumpcode/cli-utils';
 import { abstractionBacklog } from '@lumpcode/recipes';
 
-export default {
-    ...abstractionBacklog({
-        baseBranch: 'dev',
-        command: 'cursor',
-        configUrl: import.meta.url,
-        registerCommands: ['cursor'],
-        maximumNumberOfConcurrentBranches: 3,
-        verbose: true,
-        keepHistory: true,
-        lumpVariables: { model: 'composer-2.5' },
-        discoveryBranch: 'dev',
-    }),
-} satisfies LumpJsConfig;
+export default abstractionBacklog<
+    CursorPresetLumpVariables,
+    CursorPresetStepVariables
+>({
+    baseBranch: 'dev',
+    command: 'cursor',
+    configUrl: import.meta.url,
+    registerCommands: ['cursor'],
+    maximumNumberOfConcurrentBranches: 3,
+    verbose: true,
+    keepHistory: true,
+    lumpVariables: { model: 'composer-2.5' },
+    discoveryBranch: 'dev',
+});
 ```
 
 ### Custom config with kit helpers
 
 ```ts
-import { defineConfig } from '@lumpcode/cli-types';
+import { defineConfig } from '@lumpcode/cli-utils';
 import { retryUntilGreen, shellCommand } from '@lumpcode/recipes';
 
 export default defineConfig({

package/dist/index.cjs

@@ -57,18 +57,16 @@ function ephemeralContextListFn(options = {}) {
     };
 }
 
-const GET_RECURSIVE_STEPS_IS_OK_FLAG_KEY = '__getRecursiveSteps_isOk__';
 function stepIndexDepth(stepIndex) {
     return Array.isArray(stepIndex) ? stepIndex.length : 1;
 }
 /** Agent prompt(s) followed by a validation command, retried until checks pass or `maxIterations` is reached. */
-function getRecursiveSteps({ maxIterations = 5, validationCommandFn = () => null, isValidationCommandResultOk = ({ commandSucceeded }) => commandSucceeded, getFirstSteps = () => [], currentIteration = 0, prevValidateCommandResult = null, prevValidateCommandDescriptor = null, contextRunStateIsOkFlagKey = GET_RECURSIVE_STEPS_IS_OK_FLAG_KEY, }) {
+function getRecursiveSteps({ maxIterations = 5, validationCommandFn = () => null, isValidationCommandResultOk = ({ commandSucceeded }) => commandSucceeded, getFirstSteps = () => [], currentIteration = 0, prevValidateCommandResult = null, prevValidateCommandDescriptor = null, }) {
     const firstSteps = getFirstSteps({
         currentIteration,
         prevValidateCommandResult,
         prevValidateCommandDescriptor,
     });
-    let thisIterValidateCommandResult = null;
     let thisIterValidateCommandDescriptor = null;
     return [
         ...cliUtils.normalizeSteps({
@@ -83,43 +81,35 @@ function getRecursiveSteps({ maxIterations = 5, validationCommandFn = () => null
                         args: ['Loop limit reached'],
                     };
                 }
-                if (!input.contextRunState[contextRunStateIsOkFlagKey]) {
-                    const validateCommandDescriptor = await validationCommandFn({
-                        ...input,
-                        currentIteration,
-                        prevValidateCommandResult,
-                        contextRunStateIsOkFlagKey,
-                    });
-                    thisIterValidateCommandDescriptor = validateCommandDescriptor || null;
-                    return validateCommandDescriptor;
-                }
-                return null;
-            },
-            postCommandExecFn(input) {
-                thisIterValidateCommandResult = input.commandResult;
-                input.contextRunState[contextRunStateIsOkFlagKey] = isValidationCommandResultOk({
+                const validateCommandDescriptor = await validationCommandFn({
                     ...input,
                     currentIteration,
+                    prevValidateCommandResult,
                 });
+                thisIterValidateCommandDescriptor = validateCommandDescriptor || null;
+                return validateCommandDescriptor;
             },
-            continueOnError: currentIteration < maxIterations,
-        },
-        ({ contextRunState, stepIndex }) => {
-            if (stepIndexDepth(stepIndex) > maxIterations) {
-                return [];
-            }
-            return !contextRunState[contextRunStateIsOkFlagKey]
-                ? getRecursiveSteps({
+            async postCommandExecFn(input) {
+                if (stepIndexDepth(input.stepIndex) > maxIterations) {
+                    return;
+                }
+                if (isValidationCommandResultOk({
+                    ...input,
+                    currentIteration,
+                })) {
+                    return;
+                }
+                return getRecursiveSteps({
                     maxIterations,
                     validationCommandFn,
                     isValidationCommandResultOk,
                     getFirstSteps,
                     currentIteration: currentIteration + 1,
-                    prevValidateCommandResult: thisIterValidateCommandResult,
+                    prevValidateCommandResult: input.commandResult,
                     prevValidateCommandDescriptor: thisIterValidateCommandDescriptor,
-                    contextRunStateIsOkFlagKey,
-                })
-                : [];
+                });
+            },
+            continueOnError: currentIteration < maxIterations,
         },
     ];
 }
@@ -163,17 +153,16 @@ function defaultFixSteps(input) {
     ];
 }
 /** Work steps, validation command, and optional fix steps — retried until checks pass or `maxIterations`. */
-function retryUntilGreen({ steps, fixSteps, validationCommandFn, isValidationCommandResultOk, contextRunStateIsOkFlagKey, maxIterations, }) {
+function retryUntilGreen({ steps, fixSteps, validationCommandFn, isValidationCommandResultOk, maxIterations, }) {
     return getRecursiveSteps({
         maxIterations,
         validationCommandFn,
         isValidationCommandResultOk,
-        contextRunStateIsOkFlagKey,
         getFirstSteps({ currentIteration, prevValidateCommandResult, prevValidateCommandDescriptor }) {
             if (currentIteration === 0) {
                 return steps;
             }
-            return (fixSteps ?? defaultFixSteps)({
+            return (fixSteps ?? (defaultFixSteps))({
                 currentIteration,
                 prevValidateCommandResult,
                 prevValidateCommandDescriptor,
@@ -197,24 +186,26 @@ function projectRootFromConfigUrl(configUrl) {
     return path$1.resolve(configDir, '../../..');
 }
 
-/** Fails the context when the artifact referenced by a context variable was not created. */
+/** Validation command that fails when the artifact referenced by a context variable was not created. */
 function requireArtifactStep(artifactPathVarName) {
-    return {
-        async commandFn({ context, workspacePath }) {
-            const artifactPath = context.variables[artifactPathVarName];
-            if (typeof artifactPath !== 'string' || artifactPath.trim() === '') {
-                throw new Error(`Missing context variable ${artifactPathVarName}`);
-            }
-            const fullPath = path$1.join(workspacePath, artifactPath);
-            const exists = await core.pathExists(fullPath);
-            if (!exists) {
-                throw new Error(`Expected artifact at ${artifactPath} was not created`);
-            }
+    return async ({ context, workspacePath }) => {
+        const artifactPath = context.variables[artifactPathVarName];
+        if (typeof artifactPath !== 'string' || artifactPath.trim() === '') {
+            throw new Error(`Missing context variable ${artifactPathVarName}`);
+        }
+        const fullPath = path$1.join(workspacePath, artifactPath);
+        const exists = await core.pathExists(fullPath);
+        if (!exists) {
+            const message = `Expected artifact at ${artifactPath} was not created`;
             return {
                 executable: 'node',
-                args: ['-e', 'process.exit(0)'],
+                args: ['-e', `console.error(${JSON.stringify(message)}); process.exit(1)`],
             };
-        },
+        }
+        return {
+            executable: 'node',
+            args: ['-e', 'process.exit(0)'],
+        };
     };
 }
 
@@ -350,7 +341,7 @@ function isPlainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 /** Moves a finished backlog item folder from todo/ to completed/ after the context completes. */
-const folderSetTaskDoneStep = (input) => {
+function folderSetTaskDoneStep(input) {
     const nameVarName = input.nameVarName ?? 'TASK_NAME';
     return {
         async commandFn({ context, workspacePath }) {
@@ -391,7 +382,7 @@ const folderSetTaskDoneStep = (input) => {
         },
         continueOnError: true,
     };
-};
+}
 
 let setTaskDoneDeprecatedWarned = false;
 function warnSetTaskDoneDeprecated() {
@@ -403,7 +394,7 @@ function warnSetTaskDoneDeprecated() {
         'YAML backlog helpers will be removed in a future major version.');
 }
 /** Moves a finished backlog item from BACKLOG.yml to DONE.yml after the context completes. */
-const setTaskDoneStep = (input) => {
+function setTaskDoneStep(input) {
     return {
         async commandFn({ context, workspacePath }) {
             warnSetTaskDoneDeprecated();
@@ -432,7 +423,7 @@ const setTaskDoneStep = (input) => {
         },
         continueOnError: true,
     };
-};
+}
 
 function resolveImplValidateCommand(implValidateCommand) {
     if (typeof implValidateCommand === 'function') {
@@ -483,6 +474,7 @@ function ymlBacklogContexts({ backlogFilePath, parseItem, parseContext, }) {
     };
 }
 
+/** Identity helper — must preserve a generic `<V, SV>` function signature. */
 function defineRecipe(recipe) {
     return recipe;
 }
@@ -569,12 +561,13 @@ function backlog(options) {
         ...rest,
     });
 }
-const backlogRecipe = defineRecipe((options) => backlog(options));
+const backlogRecipe = defineRecipe(backlog);
 
-const abstractionBacklog = defineRecipe((options) => {
+const abstractionBacklog = defineRecipe(function abstractionBacklog(options) {
     const { implValidateCommand, configUrl, implSteps, ...rest } = options;
     const projectRoot = projectRootFromConfigUrl(configUrl);
-    const runImplValidation = resolveImplValidateCommand(implValidateCommand ?? 'echo "No implementation validation command provided. I say, trust but verify, but well..."');
+    const runImplValidation = resolveImplValidateCommand(implValidateCommand ??
+        'echo "No implementation validation command provided. I say, trust but verify, but well..."');
     return backlog({
         configUrl,
         async resolveItem({ item, paths }) {
@@ -621,7 +614,7 @@ const abstractionBacklog = defineRecipe((options) => {
     });
 });
 
-const abstractionFinder = defineRecipe((options) => {
+const abstractionFinder = defineRecipe(function abstractionFinder(options) {
     const { maxPendingAbstractions = 5, scanDirectories, customPrompt, backlogItemsDir, } = options; // TODO : check if pending abstcations in backlog are less than maxPendingAbstractions
     return cliUtils.defineConfig({
         ...options,
@@ -741,10 +734,11 @@ async function resolveFeatureBacklogItem(item, paths, projectRoot, lumpName, bas
         },
     };
 }
-const featureBacklog = defineRecipe((options) => {
+const featureBacklog = defineRecipe(function featureBacklog(options) {
     const { configUrl, baseBranch, implValidateCommand, backlogItemsDir, ...rest } = options;
     const projectRoot = projectRootFromConfigUrl(configUrl);
-    const runImplValidation = resolveImplValidateCommand(implValidateCommand ?? 'echo "No implementation validation command provided. I say, trust but verify, but well..."');
+    const runImplValidation = resolveImplValidateCommand(implValidateCommand ??
+        'echo "No implementation validation command provided. I say, trust but verify, but well..."');
     return backlog({
         configUrl,
         backlogItemsDir,
@@ -766,12 +760,13 @@ const featureBacklog = defineRecipe((options) => {
         stages: {
             makeReq: {
                 completion: 'keepPending',
-                steps: [
-                    {
-                        promptFn({ context: ctx }) {
-                            const vars = ctx.variables;
-                            const { BACKLOG_ITEM_DIR, TASK_NAME, TASK, REQ_FILE } = vars;
-                            return `
+                steps: retryUntilGreen({
+                    steps: [
+                        {
+                            promptFn({ context: ctx }) {
+                                const vars = ctx.variables;
+                                const { BACKLOG_ITEM_DIR, TASK_NAME, TASK, REQ_FILE } = vars;
+                                return `
 Write a requirements document for the following backlog item from @${BACKLOG_ITEM_DIR}/desc.yml.
 
 Task name: ${TASK_NAME}
@@ -791,21 +786,42 @@ The requirements document should be self-contained and implementation-ready. Inc
 - Acceptance criteria
 
 Do not implement the feature — only create the requirements markdown file.
+Do not wait the user to answer any questions — make the best assumptions and just write the requirements document.
 The requirements document should not contain any testing strategy details.
-                            `.trim();
+                                `.trim();
+                            },
                         },
-                    },
-                    requireArtifactStep('REQ_FILE'),
-                ],
+                    ],
+                    validationCommandFn: requireArtifactStep('REQ_FILE'),
+                    fixSteps: ({ prevValidateCommandResult }) => [
+                        {
+                            promptFn({ context: ctx }) {
+                                const vars = ctx.variables;
+                                const { BACKLOG_ITEM_DIR, REQ_FILE } = vars;
+                                return `
+The requirements document was not created at @${REQ_FILE}.
+
+Create it now at that exact path. Do not edit @${BACKLOG_ITEM_DIR}/desc.yml.
+Do not implement the feature — only write the requirements markdown file.
+The requirements document should not contain any testing strategy details.
+
+Verification output:
+${prevValidateCommandResult ?? '(no output captured)'}
+                                `.trim();
+                            },
+                        },
+                    ],
+                }),
             },
             makeTestPlan: {
                 completion: 'keepPending',
-                steps: [
-                    {
-                        promptFn({ context: ctx }) {
-                            const vars = ctx.variables;
-                            const { BACKLOG_ITEM_DIR, TASK_NAME, TASK, REQ_FILE, TEST_PLAN_FILE } = vars;
-                            return `
+                steps: retryUntilGreen({
+                    steps: [
+                        {
+                            promptFn({ context: ctx }) {
+                                const vars = ctx.variables;
+                                const { BACKLOG_ITEM_DIR, TASK_NAME, TASK, REQ_FILE, TEST_PLAN_FILE } = vars;
+                                return `
 Write a test plan for the following backlog item from @${BACKLOG_ITEM_DIR}/desc.yml.
 
 Task name: ${TASK_NAME}
@@ -821,11 +837,29 @@ The test plan should be self-contained and implementation-ready. Include:
 - Test data
 - Test expectations
 - Test implementation details
-                            `.trim();
+                                `.trim();
+                            },
                         },
-                    },
-                    requireArtifactStep('TEST_PLAN_FILE'),
-                ],
+                    ],
+                    validationCommandFn: requireArtifactStep('TEST_PLAN_FILE'),
+                    fixSteps: ({ prevValidateCommandResult }) => [
+                        {
+                            promptFn({ context: ctx }) {
+                                const vars = ctx.variables;
+                                const { BACKLOG_ITEM_DIR, REQ_FILE, TEST_PLAN_FILE } = vars;
+                                return `
+The test plan was not created at @${TEST_PLAN_FILE}.
+
+Create it now at that exact path. Match the requirements in @${REQ_FILE}.
+Do not edit @${BACKLOG_ITEM_DIR}/desc.yml nor @${REQ_FILE}.
+
+Verification output:
+${prevValidateCommandResult ?? '(no output captured)'}
+                                `.trim();
+                            },
+                        },
+                    ],
+                }),
             },
             testImpl: {
                 completion: 'keepPending',
@@ -837,6 +871,8 @@ The test plan should be self-contained and implementation-ready. Include:
                             return `
 Write a test implementation for the following backlog item from @${BACKLOG_ITEM_DIR}/desc.yml.
 
+The new tests should be skipped in order to not break the whole test suite.
+
 Task name: ${TASK_NAME}
 Task:
 ${TASK}
@@ -859,7 +895,8 @@ The requirements for this task are in @${REQ_FILE}.
                                 return `
 Implement the feature described in @${REQ_FILE}.
 The tests have already been implemented according to the test plan in @${TEST_PLAN_FILE}.
-The implementation should make the tests pass. Do not edit any test file.
+Unskip all the tests that were skipped in the tests implementation.
+The implementation should make the tests pass. Do not edit any test file except to unskip them or if absolutely necessary.
                                 `.trim();
                             },
                         },

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { CommandDescriptor, MaybePromise, PostCommandExecFn, Step } from '@lumpcode/core';
-import { GetContextListFnInput, GetContextListFn, CommandFn, LumpJsConfig, LumpJsConfigSteps, LumpVariables, MaybePromise as MaybePromise$1, Context } from '@lumpcode/cli-utils';
+import { LumpVariables, GetContextListFnInput, GetContextListFn, StepVariables, CommandFn, LumpJsConfig, LumpJsConfigSteps, MaybePromise as MaybePromise$1, Context } from '@lumpcode/cli-utils';
 
 /** Run a shell script via `sh -c` (portable on Unix-like systems and Git Bash on Windows). */
 declare function shellCommand(script: string): CommandDescriptor;
@@ -9,8 +9,8 @@ declare function normalizeMaybePromGetter<T, P = void>(maybePromGetter: MaybePro
 declare function normalizeMaybePromGetter<T, P = void>(maybePromGetter: MaybePromGetter<T, P> | undefined, defaultValue: T): (input?: P) => MaybePromise<T>;
 
 type ContextVariables = Record<string, string | number | boolean>;
-type EphemeralContextListFnOptions = {
-    contextCount?: MaybePromGetter<number, GetContextListFnInput>;
+type EphemeralContextListFnOptions<V extends LumpVariables = LumpVariables> = {
+    contextCount?: MaybePromGetter<number, GetContextListFnInput<V>>;
     contextName?: MaybePromGetter<string, {
         index: number;
         count: number;
@@ -21,16 +21,15 @@ type EphemeralContextListFnOptions = {
         count: number;
     }>;
 };
-declare function ephemeralContextListFn(options?: EphemeralContextListFnOptions): GetContextListFn;
+declare function ephemeralContextListFn<V extends LumpVariables = LumpVariables>(options?: EphemeralContextListFnOptions<V>): GetContextListFn<V>;
 
 type StepIndex = number | number[];
-type ValidationCommandFnInput = Parameters<CommandFn>[0] & {
+type ValidationCommandFnInput<V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables> = Parameters<CommandFn<V, SV>>[0] & {
     currentIteration: number;
     prevValidateCommandResult: string | null;
-    contextRunStateIsOkFlagKey: string;
 };
-type ValidationCommandFn = (input: ValidationCommandFnInput) => MaybePromise<CommandDescriptor | null | undefined>;
-type IsValidationCommandResultOkInput = Parameters<PostCommandExecFn>[0] & {
+type ValidationCommandFn<V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables> = (input: ValidationCommandFnInput<V, SV>) => MaybePromise<CommandDescriptor | null | undefined>;
+type IsValidationCommandResultOkInput<V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables> = Parameters<PostCommandExecFn<V, SV>>[0] & {
     currentIteration: number;
 };
 type GetFirstStepsInput = {
@@ -38,38 +37,35 @@ type GetFirstStepsInput = {
     prevValidateCommandResult: string | null;
     prevValidateCommandDescriptor: CommandDescriptor | null;
 };
-type GetRecursiveStepsOptions = {
+type GetRecursiveStepsOptions<V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables> = {
     maxIterations?: number;
-    validationCommandFn?: ValidationCommandFn;
-    isValidationCommandResultOk?: (input: IsValidationCommandResultOkInput) => boolean;
-    getFirstSteps?: (input: GetFirstStepsInput) => LumpJsConfig['steps'];
+    validationCommandFn?: ValidationCommandFn<V, SV>;
+    isValidationCommandResultOk?: (input: IsValidationCommandResultOkInput<V, SV>) => boolean;
+    getFirstSteps?: (input: GetFirstStepsInput) => LumpJsConfig<V, SV>['steps'];
     currentIteration?: number;
     prevValidateCommandResult?: string | null;
     prevValidateCommandDescriptor?: CommandDescriptor | null;
-    contextRunStateIsOkFlagKey?: string;
 };
 /** Agent prompt(s) followed by a validation command, retried until checks pass or `maxIterations` is reached. */
-declare function getRecursiveSteps({ maxIterations, validationCommandFn, isValidationCommandResultOk, getFirstSteps, currentIteration, prevValidateCommandResult, prevValidateCommandDescriptor, contextRunStateIsOkFlagKey, }: GetRecursiveStepsOptions): LumpJsConfigSteps;
-
-declare function defaultFixSteps(input: GetFirstStepsInput): LumpJsConfig['steps'];
-interface RetryUntilGreenInput {
-    steps: LumpJsConfig['steps'];
-    fixSteps?: typeof defaultFixSteps;
-    validationCommandFn: ValidationCommandFn;
-    isValidationCommandResultOk?: (input: IsValidationCommandResultOkInput) => boolean;
-    contextRunStateIsOkFlagKey?: GetRecursiveStepsOptions['contextRunStateIsOkFlagKey'];
-    maxIterations?: GetRecursiveStepsOptions['maxIterations'];
+declare function getRecursiveSteps<V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables>({ maxIterations, validationCommandFn, isValidationCommandResultOk, getFirstSteps, currentIteration, prevValidateCommandResult, prevValidateCommandDescriptor, }: GetRecursiveStepsOptions<V, SV>): LumpJsConfigSteps<V, SV>;
+
+interface RetryUntilGreenInput<V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables> {
+    steps: LumpJsConfig<V, SV>['steps'];
+    fixSteps?: (input: GetFirstStepsInput) => LumpJsConfig<V, SV>['steps'];
+    validationCommandFn: ValidationCommandFn<V, SV>;
+    isValidationCommandResultOk?: (input: IsValidationCommandResultOkInput<V, SV>) => boolean;
+    maxIterations?: GetRecursiveStepsOptions<V, SV>['maxIterations'];
 }
 /** Work steps, validation command, and optional fix steps — retried until checks pass or `maxIterations`. */
-declare function retryUntilGreen({ steps, fixSteps, validationCommandFn, isValidationCommandResultOk, contextRunStateIsOkFlagKey, maxIterations, }: RetryUntilGreenInput): LumpJsConfigSteps;
+declare function retryUntilGreen<V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables>({ steps, fixSteps, validationCommandFn, isValidationCommandResultOk, maxIterations, }: RetryUntilGreenInput<V, SV>): LumpJsConfigSteps<V, SV>;
 
 declare function lumpPathAndName(configUrl: string | URL): [lumpPath: string, lumpName: string];
 
 /** Resolves git project root from a lump `config.ts` module URL. */
 declare function projectRootFromConfigUrl(configUrl: string | URL): string;
 
-/** Fails the context when the artifact referenced by a context variable was not created. */
-declare function requireArtifactStep(artifactPathVarName: string): Step;
+/** Validation command that fails when the artifact referenced by a context variable was not created. */
+declare function requireArtifactStep<V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables>(artifactPathVarName: string): ValidationCommandFn<V, SV>;
 
 type BacklogPaths = {
     lumpPath: string;
@@ -80,8 +76,9 @@ declare function resolveBacklogPaths(configUrl: string | URL, overrides?: {
     backlogItemsDir?: string;
 }): BacklogPaths;
 
-type Recipe<Options, V extends LumpVariables = LumpVariables> = (options: Options) => LumpJsConfig<V>;
-declare function defineRecipe<Options, V extends LumpVariables = LumpVariables>(recipe: Recipe<Options, V>): Recipe<Options, V>;
+type Recipe<Options, V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables> = (options: Options) => LumpJsConfig<V, SV>;
+/** Identity helper — must preserve a generic `<V, SV>` function signature. */
+declare function defineRecipe<R extends (options: never) => LumpJsConfig>(recipe: R): R;
 
 type BaseBacklogItem = {
     name: string;
@@ -101,22 +98,22 @@ type FolderBacklogContextsOptions<Item extends BaseBacklogItem = BaseBacklogItem
         ignored?: boolean;
     }>;
 };
-declare function folderBacklogContexts<Item extends BaseBacklogItem = BaseBacklogItem>({ backlogItemsDir, parseItem, parseContext, }: FolderBacklogContextsOptions<Item>): GetContextListFn;
+declare function folderBacklogContexts<Item extends BaseBacklogItem = BaseBacklogItem, V extends LumpVariables = LumpVariables>({ backlogItemsDir, parseItem, parseContext, }: FolderBacklogContextsOptions<Item>): GetContextListFn<V>;
 
 /** Moves a finished backlog item folder from todo/ to completed/ after the context completes. */
-declare const folderSetTaskDoneStep: (input: {
+declare function folderSetTaskDoneStep<V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables>(input: {
     itemsDirVarName: string;
     nameVarName?: string;
-}) => Step;
+}): Step<V, SV>;
 
 /** Moves a finished backlog item from BACKLOG.yml to DONE.yml after the context completes. */
-declare const setTaskDoneStep: (input: {
+declare function setTaskDoneStep<V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables>(input: {
     backlogVarName: string;
     doneVarName: string;
-}) => Step;
+}): Step<V, SV>;
 
-type ImplValidateCommand = string | CommandDescriptor | ValidationCommandFn;
-declare function resolveImplValidateCommand(implValidateCommand: ImplValidateCommand): ValidationCommandFn;
+type ImplValidateCommand<V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables> = string | CommandDescriptor | ValidationCommandFn<V, SV>;
+declare function resolveImplValidateCommand<V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables>(implValidateCommand: ImplValidateCommand<V, SV>): ValidationCommandFn<V, SV>;
 
 type YmlBacklogContextsOptions<Item extends BaseBacklogItem = BaseBacklogItem> = {
     backlogFilePath: string;
@@ -126,29 +123,29 @@ type YmlBacklogContextsOptions<Item extends BaseBacklogItem = BaseBacklogItem> =
         ignored?: boolean;
     }>;
 };
-declare function ymlBacklogContexts<Item extends BaseBacklogItem = BaseBacklogItem>({ backlogFilePath, parseItem, parseContext, }: YmlBacklogContextsOptions<Item>): GetContextListFn;
+declare function ymlBacklogContexts<Item extends BaseBacklogItem = BaseBacklogItem, V extends LumpVariables = LumpVariables>({ backlogFilePath, parseItem, parseContext, }: YmlBacklogContextsOptions<Item>): GetContextListFn<V>;
 
 /** Validates and normalizes one backlog item; throws on invalid input. */
 declare function validateBaseBacklogItem(raw: unknown, location: string): BaseBacklogItem;
 
-type AbstractionBacklogOptions = {
-    implValidateCommand?: ValidationCommandFn | string;
+type AbstractionBacklogOptions<V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables> = {
+    implValidateCommand?: ValidationCommandFn<V, SV> | string;
     /** Lump config module URL — pass `import.meta.url` from `config.ts`. */
     configUrl: string | URL;
-    implSteps?: LumpJsConfig['steps'];
-} & Omit<LumpJsConfig, 'contextListJson' | 'contextMatchFn' | 'getContextListFn' | 'prompt' | 'steps'>;
-declare const abstractionBacklog: Recipe<AbstractionBacklogOptions>;
+    implSteps?: LumpJsConfig<V, SV>['steps'];
+} & Omit<LumpJsConfig<V, SV>, 'contextListJson' | 'contextMatchFn' | 'getContextListFn' | 'prompt' | 'steps'>;
+declare const abstractionBacklog: <V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables>(options: AbstractionBacklogOptions<V, SV>) => LumpJsConfig<V, SV>;
 
-type AbstractionFinderOptions = {
+type AbstractionFinderOptions<V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables> = {
     scanDirectories?: string[];
     customPrompt?(): string;
     maxPendingAbstractions?: number;
     backlogItemsDir: string;
-} & LumpJsConfig;
-declare const abstractionFinder: Recipe<AbstractionFinderOptions>;
+} & LumpJsConfig<V, SV>;
+declare const abstractionFinder: <V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables>(options: AbstractionFinderOptions<V, SV>) => LumpJsConfig<V, SV>;
 
-type BacklogStageDefinition = {
-    steps: NonNullable<LumpJsConfig['steps']>;
+type BacklogStageDefinition<V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables> = {
+    steps: NonNullable<LumpJsConfig<V, SV>['steps']>;
     completion: 'keepPending' | 'moveToDone';
 };
 type BacklogItemResolution<StageName extends string> = {
@@ -156,10 +153,11 @@ type BacklogItemResolution<StageName extends string> = {
 } | {
     stage: StageName;
     contextName?: string;
+    /** Context variables (not lump/step variable bags). */
     variables?: LumpVariables;
     additionalDependsOnContexts?: string[];
 };
-type BacklogOptions<Item extends BaseBacklogItem, Stages extends Record<string, BacklogStageDefinition>> = {
+type BacklogOptions<Item extends BaseBacklogItem, V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables, Stages extends Record<string, BacklogStageDefinition<V, SV>> = Record<string, BacklogStageDefinition<V, SV>>> = {
     configUrl: string | URL;
     backlogItemsDir?: string;
     stages: Stages;
@@ -168,15 +166,15 @@ type BacklogOptions<Item extends BaseBacklogItem, Stages extends Record<string,
         item: Item;
         paths: BacklogPaths;
     }): MaybePromise<BacklogItemResolution<Extract<keyof Stages, string>>>;
-} & Omit<LumpJsConfig, 'contextListJson' | 'contextMatchFn' | 'getContextListFn' | 'prompt' | 'steps'>;
+} & Omit<LumpJsConfig<V, SV>, 'contextListJson' | 'contextMatchFn' | 'getContextListFn' | 'prompt' | 'steps'>;
 declare const BACKLOG_STAGE_VAR = "BACKLOG_STAGE";
 declare const BACKLOG_TASK_NAME_VAR = "TASK_NAME";
 declare const BACKLOG_TASK_VAR = "TASK";
 declare const BACKLOG_ITEMS_DIR_VAR = "BACKLOG_ITEMS_DIR";
 declare const BACKLOG_ITEM_DIR_VAR = "BACKLOG_ITEM_DIR";
 
-declare function backlog<Item extends BaseBacklogItem, Stages extends Record<string, BacklogStageDefinition>>(options: BacklogOptions<Item, Stages>): LumpJsConfig;
-declare const backlogRecipe: Recipe<BacklogOptions<BaseBacklogItem, Record<string, BacklogStageDefinition>>>;
+declare function backlog<Item extends BaseBacklogItem, V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables, Stages extends Record<string, BacklogStageDefinition<V, SV>> = Record<string, BacklogStageDefinition<V, SV>>>(options: BacklogOptions<Item, V, SV, Stages>): LumpJsConfig<V, SV>;
+declare const backlogRecipe: typeof backlog;
 
 type FeatureBacklogItem = BaseBacklogItem & {
     manualReq?: boolean;
@@ -191,14 +189,14 @@ type FeatureBacklogContextVariables = {
     REQ_FILE?: string;
     TEST_PLAN_FILE?: string;
 };
-type FeatureBacklogOptions = {
+type FeatureBacklogOptions<V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables> = {
     configUrl: string | URL;
     baseBranch: string;
-    implValidateCommand?: ValidationCommandFn | string;
+    implValidateCommand?: ValidationCommandFn<V, SV> | string;
     backlogItemsDir?: string;
-} & Omit<LumpJsConfig, 'contextListJson' | 'contextMatchFn' | 'getContextListFn' | 'prompt' | 'steps' | 'baseBranch'>;
+} & Omit<LumpJsConfig<V, SV>, 'contextListJson' | 'contextMatchFn' | 'getContextListFn' | 'prompt' | 'steps' | 'baseBranch'>;
 declare function resolveFeatureBacklogItem(item: FeatureBacklogItem, paths: BacklogPaths, projectRoot: string, lumpName: string, baseBranch: string): Promise<BacklogItemResolution<FeatureBacklogStage>>;
-declare const featureBacklog: Recipe<FeatureBacklogOptions>;
+declare const featureBacklog: <V extends LumpVariables = LumpVariables, SV extends StepVariables = StepVariables>(options: FeatureBacklogOptions<V, SV>) => LumpJsConfig<V, SV>;
 
 export { BACKLOG_ITEMS_DIR_VAR, BACKLOG_ITEM_DIR_VAR, BACKLOG_STAGE_VAR, BACKLOG_TASK_NAME_VAR, BACKLOG_TASK_VAR, abstractionBacklog, abstractionFinder, backlog, backlogRecipe, defineRecipe, ephemeralContextListFn, featureBacklog, folderBacklogContexts, folderSetTaskDoneStep, getRecursiveSteps, lumpPathAndName, normalizeMaybePromGetter, projectRootFromConfigUrl, requireArtifactStep, resolveBacklogPaths, resolveFeatureBacklogItem, resolveImplValidateCommand, retryUntilGreen, setTaskDoneStep, shellCommand, validateBaseBacklogItem, ymlBacklogContexts };
 export type { AbstractionBacklogOptions, AbstractionFinderOptions, BacklogItemResolution, BacklogOptions, BacklogPaths, BacklogStageDefinition, BaseBacklogItem, DoneBacklogItem, EphemeralContextListFnOptions, FeatureBacklogContextVariables, FeatureBacklogItem, FeatureBacklogOptions, FeatureBacklogStage, FolderBacklogContextsOptions, GetFirstStepsInput, GetRecursiveStepsOptions, ImplValidateCommand, IsValidationCommandResultOkInput, MaybePromGetter, Recipe, RetryUntilGreenInput, StepIndex, ValidationCommandFn, ValidationCommandFnInput, YmlBacklogContextsOptions };

package/dist/index.js

@@ -55,18 +55,16 @@ function ephemeralContextListFn(options = {}) {
     };
 }
 
-const GET_RECURSIVE_STEPS_IS_OK_FLAG_KEY = '__getRecursiveSteps_isOk__';
 function stepIndexDepth(stepIndex) {
     return Array.isArray(stepIndex) ? stepIndex.length : 1;
 }
 /** Agent prompt(s) followed by a validation command, retried until checks pass or `maxIterations` is reached. */
-function getRecursiveSteps({ maxIterations = 5, validationCommandFn = () => null, isValidationCommandResultOk = ({ commandSucceeded }) => commandSucceeded, getFirstSteps = () => [], currentIteration = 0, prevValidateCommandResult = null, prevValidateCommandDescriptor = null, contextRunStateIsOkFlagKey = GET_RECURSIVE_STEPS_IS_OK_FLAG_KEY, }) {
+function getRecursiveSteps({ maxIterations = 5, validationCommandFn = () => null, isValidationCommandResultOk = ({ commandSucceeded }) => commandSucceeded, getFirstSteps = () => [], currentIteration = 0, prevValidateCommandResult = null, prevValidateCommandDescriptor = null, }) {
     const firstSteps = getFirstSteps({
         currentIteration,
         prevValidateCommandResult,
         prevValidateCommandDescriptor,
     });
-    let thisIterValidateCommandResult = null;
     let thisIterValidateCommandDescriptor = null;
     return [
         ...normalizeSteps({
@@ -81,43 +79,35 @@ function getRecursiveSteps({ maxIterations = 5, validationCommandFn = () => null
                         args: ['Loop limit reached'],
                     };
                 }
-                if (!input.contextRunState[contextRunStateIsOkFlagKey]) {
-                    const validateCommandDescriptor = await validationCommandFn({
-                        ...input,
-                        currentIteration,
-                        prevValidateCommandResult,
-                        contextRunStateIsOkFlagKey,
-                    });
-                    thisIterValidateCommandDescriptor = validateCommandDescriptor || null;
-                    return validateCommandDescriptor;
-                }
-                return null;
-            },
-            postCommandExecFn(input) {
-                thisIterValidateCommandResult = input.commandResult;
-                input.contextRunState[contextRunStateIsOkFlagKey] = isValidationCommandResultOk({
+                const validateCommandDescriptor = await validationCommandFn({
                     ...input,
                     currentIteration,
+                    prevValidateCommandResult,
                 });
+                thisIterValidateCommandDescriptor = validateCommandDescriptor || null;
+                return validateCommandDescriptor;
             },
-            continueOnError: currentIteration < maxIterations,
-        },
-        ({ contextRunState, stepIndex }) => {
-            if (stepIndexDepth(stepIndex) > maxIterations) {
-                return [];
-            }
-            return !contextRunState[contextRunStateIsOkFlagKey]
-                ? getRecursiveSteps({
+            async postCommandExecFn(input) {
+                if (stepIndexDepth(input.stepIndex) > maxIterations) {
+                    return;
+                }
+                if (isValidationCommandResultOk({
+                    ...input,
+                    currentIteration,
+                })) {
+                    return;
+                }
+                return getRecursiveSteps({
                     maxIterations,
                     validationCommandFn,
                     isValidationCommandResultOk,
                     getFirstSteps,
                     currentIteration: currentIteration + 1,
-                    prevValidateCommandResult: thisIterValidateCommandResult,
+                    prevValidateCommandResult: input.commandResult,
                     prevValidateCommandDescriptor: thisIterValidateCommandDescriptor,
-                    contextRunStateIsOkFlagKey,
-                })
-                : [];
+                });
+            },
+            continueOnError: currentIteration < maxIterations,
         },
     ];
 }
@@ -161,17 +151,16 @@ function defaultFixSteps(input) {
     ];
 }
 /** Work steps, validation command, and optional fix steps — retried until checks pass or `maxIterations`. */
-function retryUntilGreen({ steps, fixSteps, validationCommandFn, isValidationCommandResultOk, contextRunStateIsOkFlagKey, maxIterations, }) {
+function retryUntilGreen({ steps, fixSteps, validationCommandFn, isValidationCommandResultOk, maxIterations, }) {
     return getRecursiveSteps({
         maxIterations,
         validationCommandFn,
         isValidationCommandResultOk,
-        contextRunStateIsOkFlagKey,
         getFirstSteps({ currentIteration, prevValidateCommandResult, prevValidateCommandDescriptor }) {
             if (currentIteration === 0) {
                 return steps;
             }
-            return (fixSteps ?? defaultFixSteps)({
+            return (fixSteps ?? (defaultFixSteps))({
                 currentIteration,
                 prevValidateCommandResult,
                 prevValidateCommandDescriptor,
@@ -195,24 +184,26 @@ function projectRootFromConfigUrl(configUrl) {
     return path$1.resolve(configDir, '../../..');
 }
 
-/** Fails the context when the artifact referenced by a context variable was not created. */
+/** Validation command that fails when the artifact referenced by a context variable was not created. */
 function requireArtifactStep(artifactPathVarName) {
-    return {
-        async commandFn({ context, workspacePath }) {
-            const artifactPath = context.variables[artifactPathVarName];
-            if (typeof artifactPath !== 'string' || artifactPath.trim() === '') {
-                throw new Error(`Missing context variable ${artifactPathVarName}`);
-            }
-            const fullPath = path$1.join(workspacePath, artifactPath);
-            const exists = await pathExists(fullPath);
-            if (!exists) {
-                throw new Error(`Expected artifact at ${artifactPath} was not created`);
-            }
+    return async ({ context, workspacePath }) => {
+        const artifactPath = context.variables[artifactPathVarName];
+        if (typeof artifactPath !== 'string' || artifactPath.trim() === '') {
+            throw new Error(`Missing context variable ${artifactPathVarName}`);
+        }
+        const fullPath = path$1.join(workspacePath, artifactPath);
+        const exists = await pathExists(fullPath);
+        if (!exists) {
+            const message = `Expected artifact at ${artifactPath} was not created`;
             return {
                 executable: 'node',
-                args: ['-e', 'process.exit(0)'],
+                args: ['-e', `console.error(${JSON.stringify(message)}); process.exit(1)`],
             };
-        },
+        }
+        return {
+            executable: 'node',
+            args: ['-e', 'process.exit(0)'],
+        };
     };
 }
 
@@ -348,7 +339,7 @@ function isPlainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 /** Moves a finished backlog item folder from todo/ to completed/ after the context completes. */
-const folderSetTaskDoneStep = (input) => {
+function folderSetTaskDoneStep(input) {
     const nameVarName = input.nameVarName ?? 'TASK_NAME';
     return {
         async commandFn({ context, workspacePath }) {
@@ -389,7 +380,7 @@ const folderSetTaskDoneStep = (input) => {
         },
         continueOnError: true,
     };
-};
+}
 
 let setTaskDoneDeprecatedWarned = false;
 function warnSetTaskDoneDeprecated() {
@@ -401,7 +392,7 @@ function warnSetTaskDoneDeprecated() {
         'YAML backlog helpers will be removed in a future major version.');
 }
 /** Moves a finished backlog item from BACKLOG.yml to DONE.yml after the context completes. */
-const setTaskDoneStep = (input) => {
+function setTaskDoneStep(input) {
     return {
         async commandFn({ context, workspacePath }) {
             warnSetTaskDoneDeprecated();
@@ -430,7 +421,7 @@ const setTaskDoneStep = (input) => {
         },
         continueOnError: true,
     };
-};
+}
 
 function resolveImplValidateCommand(implValidateCommand) {
     if (typeof implValidateCommand === 'function') {
@@ -481,6 +472,7 @@ function ymlBacklogContexts({ backlogFilePath, parseItem, parseContext, }) {
     };
 }
 
+/** Identity helper — must preserve a generic `<V, SV>` function signature. */
 function defineRecipe(recipe) {
     return recipe;
 }
@@ -567,12 +559,13 @@ function backlog(options) {
         ...rest,
     });
 }
-const backlogRecipe = defineRecipe((options) => backlog(options));
+const backlogRecipe = defineRecipe(backlog);
 
-const abstractionBacklog = defineRecipe((options) => {
+const abstractionBacklog = defineRecipe(function abstractionBacklog(options) {
     const { implValidateCommand, configUrl, implSteps, ...rest } = options;
     const projectRoot = projectRootFromConfigUrl(configUrl);
-    const runImplValidation = resolveImplValidateCommand(implValidateCommand ?? 'echo "No implementation validation command provided. I say, trust but verify, but well..."');
+    const runImplValidation = resolveImplValidateCommand(implValidateCommand ??
+        'echo "No implementation validation command provided. I say, trust but verify, but well..."');
     return backlog({
         configUrl,
         async resolveItem({ item, paths }) {
@@ -619,7 +612,7 @@ const abstractionBacklog = defineRecipe((options) => {
     });
 });
 
-const abstractionFinder = defineRecipe((options) => {
+const abstractionFinder = defineRecipe(function abstractionFinder(options) {
     const { maxPendingAbstractions = 5, scanDirectories, customPrompt, backlogItemsDir, } = options; // TODO : check if pending abstcations in backlog are less than maxPendingAbstractions
     return defineConfig({
         ...options,
@@ -739,10 +732,11 @@ async function resolveFeatureBacklogItem(item, paths, projectRoot, lumpName, bas
         },
     };
 }
-const featureBacklog = defineRecipe((options) => {
+const featureBacklog = defineRecipe(function featureBacklog(options) {
     const { configUrl, baseBranch, implValidateCommand, backlogItemsDir, ...rest } = options;
     const projectRoot = projectRootFromConfigUrl(configUrl);
-    const runImplValidation = resolveImplValidateCommand(implValidateCommand ?? 'echo "No implementation validation command provided. I say, trust but verify, but well..."');
+    const runImplValidation = resolveImplValidateCommand(implValidateCommand ??
+        'echo "No implementation validation command provided. I say, trust but verify, but well..."');
     return backlog({
         configUrl,
         backlogItemsDir,
@@ -764,12 +758,13 @@ const featureBacklog = defineRecipe((options) => {
         stages: {
             makeReq: {
                 completion: 'keepPending',
-                steps: [
-                    {
-                        promptFn({ context: ctx }) {
-                            const vars = ctx.variables;
-                            const { BACKLOG_ITEM_DIR, TASK_NAME, TASK, REQ_FILE } = vars;
-                            return `
+                steps: retryUntilGreen({
+                    steps: [
+                        {
+                            promptFn({ context: ctx }) {
+                                const vars = ctx.variables;
+                                const { BACKLOG_ITEM_DIR, TASK_NAME, TASK, REQ_FILE } = vars;
+                                return `
 Write a requirements document for the following backlog item from @${BACKLOG_ITEM_DIR}/desc.yml.
 
 Task name: ${TASK_NAME}
@@ -789,21 +784,42 @@ The requirements document should be self-contained and implementation-ready. Inc
 - Acceptance criteria
 
 Do not implement the feature — only create the requirements markdown file.
+Do not wait the user to answer any questions — make the best assumptions and just write the requirements document.
 The requirements document should not contain any testing strategy details.
-                            `.trim();
+                                `.trim();
+                            },
                         },
-                    },
-                    requireArtifactStep('REQ_FILE'),
-                ],
+                    ],
+                    validationCommandFn: requireArtifactStep('REQ_FILE'),
+                    fixSteps: ({ prevValidateCommandResult }) => [
+                        {
+                            promptFn({ context: ctx }) {
+                                const vars = ctx.variables;
+                                const { BACKLOG_ITEM_DIR, REQ_FILE } = vars;
+                                return `
+The requirements document was not created at @${REQ_FILE}.
+
+Create it now at that exact path. Do not edit @${BACKLOG_ITEM_DIR}/desc.yml.
+Do not implement the feature — only write the requirements markdown file.
+The requirements document should not contain any testing strategy details.
+
+Verification output:
+${prevValidateCommandResult ?? '(no output captured)'}
+                                `.trim();
+                            },
+                        },
+                    ],
+                }),
             },
             makeTestPlan: {
                 completion: 'keepPending',
-                steps: [
-                    {
-                        promptFn({ context: ctx }) {
-                            const vars = ctx.variables;
-                            const { BACKLOG_ITEM_DIR, TASK_NAME, TASK, REQ_FILE, TEST_PLAN_FILE } = vars;
-                            return `
+                steps: retryUntilGreen({
+                    steps: [
+                        {
+                            promptFn({ context: ctx }) {
+                                const vars = ctx.variables;
+                                const { BACKLOG_ITEM_DIR, TASK_NAME, TASK, REQ_FILE, TEST_PLAN_FILE } = vars;
+                                return `
 Write a test plan for the following backlog item from @${BACKLOG_ITEM_DIR}/desc.yml.
 
 Task name: ${TASK_NAME}
@@ -819,11 +835,29 @@ The test plan should be self-contained and implementation-ready. Include:
 - Test data
 - Test expectations
 - Test implementation details
-                            `.trim();
+                                `.trim();
+                            },
                         },
-                    },
-                    requireArtifactStep('TEST_PLAN_FILE'),
-                ],
+                    ],
+                    validationCommandFn: requireArtifactStep('TEST_PLAN_FILE'),
+                    fixSteps: ({ prevValidateCommandResult }) => [
+                        {
+                            promptFn({ context: ctx }) {
+                                const vars = ctx.variables;
+                                const { BACKLOG_ITEM_DIR, REQ_FILE, TEST_PLAN_FILE } = vars;
+                                return `
+The test plan was not created at @${TEST_PLAN_FILE}.
+
+Create it now at that exact path. Match the requirements in @${REQ_FILE}.
+Do not edit @${BACKLOG_ITEM_DIR}/desc.yml nor @${REQ_FILE}.
+
+Verification output:
+${prevValidateCommandResult ?? '(no output captured)'}
+                                `.trim();
+                            },
+                        },
+                    ],
+                }),
             },
             testImpl: {
                 completion: 'keepPending',
@@ -835,6 +869,8 @@ The test plan should be self-contained and implementation-ready. Include:
                             return `
 Write a test implementation for the following backlog item from @${BACKLOG_ITEM_DIR}/desc.yml.
 
+The new tests should be skipped in order to not break the whole test suite.
+
 Task name: ${TASK_NAME}
 Task:
 ${TASK}
@@ -857,7 +893,8 @@ The requirements for this task are in @${REQ_FILE}.
                                 return `
 Implement the feature described in @${REQ_FILE}.
 The tests have already been implemented according to the test plan in @${TEST_PLAN_FILE}.
-The implementation should make the tests pass. Do not edit any test file.
+Unskip all the tests that were skipped in the tests implementation.
+The implementation should make the tests pass. Do not edit any test file except to unskip them or if absolutely necessary.
                                 `.trim();
                             },
                         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumpcode/recipes",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "description": "Lumpcode lump recipes and kit helpers",
   "keywords": [
     "lumpcode",
@@ -44,8 +44,8 @@
     "test:watch": "vitest watch"
   },
   "dependencies": {
-    "@lumpcode/cli-utils": "^0.0.12",
-    "@lumpcode/core": "^0.0.12",
+    "@lumpcode/cli-utils": "^0.0.14",
+    "@lumpcode/core": "^0.0.14",
     "js-yaml": "^5.0.0"
   },
   "devDependencies": {