@lumpcode/recipes 0.0.12

package/dist/index.cjs

@@ -0,0 +1,775 @@
+'use strict';
+
+var cliUtils = require('@lumpcode/cli-utils');
+var core = require('@lumpcode/core');
+var url = require('url');
+var path = require('path');
+var path$1 = require('node:path');
+var node_url = require('node:url');
+var fs = require('fs/promises');
+var jsYaml = require('js-yaml');
+
+/** Run a shell script via `sh -c` (portable on Unix-like systems and Git Bash on Windows). */
+function shellCommand(script) {
+    return {
+        executable: 'sh',
+        args: ['-c', script],
+    };
+}
+
+function normalizeMaybePromGetter(maybePromGetter, defaultValue) {
+    if (typeof maybePromGetter === 'function') {
+        return maybePromGetter;
+    }
+    const value = maybePromGetter ?? defaultValue;
+    return () => value;
+}
+
+async function resolveContextName(index, count, contextName) {
+    return normalizeMaybePromGetter(contextName, (new Date()).toISOString().slice(0, 23).replace(/:/g, '').replace('.', '-'))({
+        index,
+        count,
+    });
+}
+function ephemeralContextListFn(options = {}) {
+    return async (input) => {
+        const count = await (normalizeMaybePromGetter(options.contextCount, 1)(input));
+        if (count <= 0) {
+            return [];
+        }
+        const contextNamesSet = new Set();
+        return Promise.all(Array.from({ length: count }, async (_, index) => {
+            let name = await resolveContextName(index, count, options.contextName);
+            if (contextNamesSet.has(name)) {
+                name = `${name}-${index}`;
+            }
+            contextNamesSet.add(name);
+            const variables = await (normalizeMaybePromGetter(options.variables, {})({
+                contextName: name,
+                index,
+                count,
+            }));
+            return {
+                name,
+                variables,
+            };
+        }));
+    };
+}
+
+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, }) {
+    const firstSteps = getFirstSteps({
+        currentIteration,
+        prevValidateCommandResult,
+        prevValidateCommandDescriptor,
+    });
+    let thisIterValidateCommandResult = null;
+    let thisIterValidateCommandDescriptor = null;
+    return [
+        ...cliUtils.normalizeSteps({
+            prompt: undefined,
+            jsSteps: firstSteps,
+        }),
+        {
+            async commandFn(input) {
+                if (stepIndexDepth(input.stepIndex) > maxIterations) {
+                    return {
+                        executable: 'echo',
+                        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({
+                    ...input,
+                    currentIteration,
+                });
+            },
+            continueOnError: currentIteration < maxIterations,
+        },
+        ({ contextRunState, stepIndex }) => {
+            if (stepIndexDepth(stepIndex) > maxIterations) {
+                return [];
+            }
+            return !contextRunState[contextRunStateIsOkFlagKey]
+                ? getRecursiveSteps({
+                    maxIterations,
+                    validationCommandFn,
+                    isValidationCommandResultOk,
+                    getFirstSteps,
+                    currentIteration: currentIteration + 1,
+                    prevValidateCommandResult: thisIterValidateCommandResult,
+                    prevValidateCommandDescriptor: thisIterValidateCommandDescriptor,
+                    contextRunStateIsOkFlagKey,
+                })
+                : [];
+        },
+    ];
+}
+
+function formatVerificationCommand(descriptor) {
+    if (!descriptor) {
+        return '(no verification command recorded)';
+    }
+    if (descriptor.executable === 'sh' && descriptor.args[0] === '-c' && descriptor.args.length === 2) {
+        return descriptor.args[1];
+    }
+    const command = [descriptor.executable, ...descriptor.args.map(core.shellSingleQuote)].join(' ');
+    if (!descriptor.env || Object.keys(descriptor.env).length === 0) {
+        return command;
+    }
+    const envPrefix = Object.entries(descriptor.env)
+        .map(([key, value]) => `${key}=${core.shellSingleQuote(value)}`)
+        .join(' ');
+    return `${envPrefix} ${command}`;
+}
+function defaultFixPrompt({ prevValidateCommandResult, prevValidateCommandDescriptor }) {
+    return [
+        'The verification step failed. Fix the issues and try again.',
+        '',
+        'Verification command:',
+        '',
+        formatVerificationCommand(prevValidateCommandDescriptor),
+        '',
+        'Verification output:',
+        '',
+        prevValidateCommandResult ?? '(no output captured)',
+    ].join('\n');
+}
+function defaultFixSteps(input) {
+    return [
+        {
+            promptFn() {
+                return defaultFixPrompt(input);
+            },
+        },
+    ];
+}
+/** Work steps, validation command, and optional fix steps — retried until checks pass or `maxIterations`. */
+function retryUntilGreen({ steps, fixSteps, validationCommandFn, isValidationCommandResultOk, contextRunStateIsOkFlagKey, maxIterations, }) {
+    return getRecursiveSteps({
+        maxIterations,
+        validationCommandFn,
+        isValidationCommandResultOk,
+        contextRunStateIsOkFlagKey,
+        getFirstSteps({ currentIteration, prevValidateCommandResult, prevValidateCommandDescriptor }) {
+            if (currentIteration === 0) {
+                return steps;
+            }
+            return (fixSteps ?? defaultFixSteps)({
+                currentIteration,
+                prevValidateCommandResult,
+                prevValidateCommandDescriptor,
+            });
+        },
+    });
+}
+
+function lumpPathAndName(configUrl) {
+    const lumpName = path.basename(path.dirname(url.fileURLToPath(configUrl)));
+    const lumpPath = path.join('.lumpcode', 'lumps', lumpName);
+    return [
+        lumpPath,
+        lumpName,
+    ];
+}
+
+/** Resolves git project root from a lump `config.ts` module URL. */
+function projectRootFromConfigUrl(configUrl) {
+    const configDir = path$1.dirname(node_url.fileURLToPath(configUrl));
+    return path$1.resolve(configDir, '../../..');
+}
+
+/** Fails the context 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 {
+                executable: 'node',
+                args: ['-e', 'process.exit(0)'],
+            };
+        },
+    };
+}
+
+function assertProjectRelativePath(filePath, label) {
+    if (path$1.isAbsolute(filePath)) {
+        throw new Error(`${label} must be project-root-relative, not absolute: ${filePath}`);
+    }
+}
+function resolveBacklogPaths(configUrl, overrides) {
+    const [lumpPath, lumpName] = lumpPathAndName(configUrl);
+    const backlogFilePath = overrides?.backlogFilePath ?? path$1.join(lumpPath, 'BACKLOG.yml');
+    const doneFilePath = overrides?.doneFilePath ?? path$1.join(lumpPath, 'DONE.yml');
+    assertProjectRelativePath(backlogFilePath, 'backlogFilePath');
+    assertProjectRelativePath(doneFilePath, 'doneFilePath');
+    return {
+        lumpPath,
+        lumpName,
+        backlogFilePath,
+        doneFilePath,
+    };
+}
+
+/** Moves a finished backlog item from BACKLOG.yml to DONE.yml after the context completes. */
+const setTaskDoneStep = (input) => {
+    return {
+        async commandFn({ context, workspacePath }) {
+            const variables = context.variables;
+            const { backlogVarName, doneVarName } = input;
+            const baseBacklogFilePath = variables[backlogVarName];
+            const baseDoneFilePath = variables[doneVarName];
+            if (!baseBacklogFilePath || !baseDoneFilePath) {
+                throw new Error(`Backlog and done file paths are required`);
+            }
+            const backlogFilePath = path.join(workspacePath, baseBacklogFilePath);
+            const doneFilePath = path.join(workspacePath, baseDoneFilePath);
+            const backlog = await cliUtils.readYamlList(backlogFilePath);
+            const finishedItem = backlog.find((item) => item.name === variables.TASK_NAME);
+            if (finishedItem) {
+                const remaining = backlog.filter((item) => item.name !== variables.TASK_NAME);
+                await fs.writeFile(backlogFilePath, jsYaml.dump(remaining));
+                const done = await cliUtils.readYamlList(doneFilePath);
+                done.push({ ...finishedItem, completedAt: new Date().toISOString() });
+                await fs.writeFile(doneFilePath, jsYaml.dump(done));
+            }
+            return {
+                executable: 'cat',
+                args: [doneFilePath],
+            };
+        },
+        continueOnError: true,
+    };
+};
+
+function resolveImplValidateCommand(implValidateCommand) {
+    if (typeof implValidateCommand === 'function') {
+        return implValidateCommand;
+    }
+    if (typeof implValidateCommand === 'string') {
+        return (_input) => shellCommand(implValidateCommand);
+    }
+    return (_input) => implValidateCommand;
+}
+
+const CONTEXT_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
+function assertRecord(value, index) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new Error(`Backlog item at index ${index} must be an object`);
+    }
+}
+function assertStringField(record, field, index) {
+    const value = record[field];
+    if (typeof value !== 'string' || value.trim() === '') {
+        throw new Error(`Backlog item at index ${index} requires non-empty string field "${field}"`);
+    }
+}
+function assertNumberField(record, field, index) {
+    const value = record[field];
+    if (typeof value !== 'number' || Number.isNaN(value)) {
+        throw new Error(`Backlog item at index ${index} requires numeric field "${field}"`);
+    }
+}
+/** Validates and normalizes one YAML backlog row; throws on invalid input. */
+function validateBaseBacklogItem(raw, index) {
+    assertRecord(raw, index);
+    assertStringField(raw, 'name', index);
+    assertStringField(raw, 'task', index);
+    assertNumberField(raw, 'priority', index);
+    if (!CONTEXT_NAME_PATTERN.test(raw.name)) {
+        throw new Error(`Backlog item at index ${index} has invalid name "${raw.name}" (expected ^[a-zA-Z0-9_-]+$)`);
+    }
+    let dependsOn;
+    if (raw.dependsOn !== undefined) {
+        if (!Array.isArray(raw.dependsOn)) {
+            throw new Error(`Backlog item at index ${index} field "dependsOn" must be an array`);
+        }
+        for (const dep of raw.dependsOn) {
+            if (typeof dep !== 'string' || dep.trim() === '') {
+                throw new Error(`Backlog item at index ${index} field "dependsOn" must contain non-empty strings`);
+            }
+        }
+        dependsOn = raw.dependsOn;
+    }
+    return {
+        name: raw.name,
+        task: raw.task,
+        priority: raw.priority,
+        dependsOn,
+    };
+}
+
+function ymlBacklogContexts({ backlogFilePath, parseItem, parseContext, }) {
+    return async () => {
+        const raw = await fs.readFile(backlogFilePath, 'utf-8');
+        const doc = jsYaml.load(raw);
+        if (!Array.isArray(doc)) {
+            throw new Error(`Backlog file ${backlogFilePath} must contain a YAML list`);
+        }
+        const allCtxs = await Promise.all(doc.map(async (rawItem, index) => {
+            const baseItem = validateBaseBacklogItem(rawItem, index);
+            const item = parseItem ? parseItem(baseItem, index, rawItem) : baseItem;
+            const { parsed, ignored } = parseContext
+                ? await parseContext(item, index)
+                : { parsed: undefined, ignored: false };
+            if (ignored)
+                return null;
+            return {
+                name: item.name,
+                options: {
+                    priority: item.priority,
+                    dependsOnContexts: item.dependsOn,
+                },
+                variables: parsed?.variables ?? {},
+                ...parsed,
+            };
+        }));
+        return allCtxs.filter((ctx) => !!ctx);
+    };
+}
+
+function defineRecipe(recipe) {
+    return recipe;
+}
+
+const BACKLOG_STAGE_VAR = 'BACKLOG_STAGE';
+const BACKLOG_TASK_NAME_VAR = 'TASK_NAME';
+const BACKLOG_TASK_VAR = 'TASK';
+const BACKLOG_FILE_VAR = 'BACKLOG_FILE';
+const BACKLOG_DONE_FILE_VAR = 'DONE_FILE';
+
+function isIgnoredResolution(resolution) {
+    return 'ignored' in resolution && resolution.ignored === true;
+}
+function buildStageSteps(stages, stageName) {
+    const stageDef = stages[stageName];
+    if (!stageDef) {
+        return [];
+    }
+    const normalized = cliUtils.normalizeSteps({
+        prompt: undefined,
+        jsSteps: stageDef.steps,
+    });
+    if (stageDef.completion === 'moveToDone') {
+        return [
+            ...normalized,
+            setTaskDoneStep({
+                backlogVarName: BACKLOG_FILE_VAR,
+                doneVarName: BACKLOG_DONE_FILE_VAR,
+            }),
+        ];
+    }
+    return normalized;
+}
+function backlog(options) {
+    const { configUrl, backlogFilePath: backlogFilePathOverride, doneFilePath: doneFilePathOverride, stages, parseItem, resolveItem, ...rest } = options;
+    const paths = resolveBacklogPaths(configUrl, {
+        backlogFilePath: backlogFilePathOverride,
+        doneFilePath: doneFilePathOverride,
+    });
+    const projectRoot = projectRootFromConfigUrl(configUrl);
+    const absoluteBacklogPath = path$1.join(projectRoot, paths.backlogFilePath);
+    return cliUtils.defineConfig({
+        getContextListFn: ymlBacklogContexts({
+            backlogFilePath: absoluteBacklogPath,
+            parseItem,
+            async parseContext(item) {
+                const resolution = await resolveItem({ item, paths });
+                if (isIgnoredResolution(resolution)) {
+                    return { ignored: true };
+                }
+                const { stage, contextName, variables, additionalDependsOnContexts, } = resolution;
+                const dependsOnContexts = [
+                    ...(item.dependsOn ?? []),
+                    ...(additionalDependsOnContexts ?? []),
+                ];
+                return {
+                    parsed: {
+                        name: contextName ?? item.name,
+                        variables: {
+                            [BACKLOG_TASK_NAME_VAR]: item.name,
+                            [BACKLOG_TASK_VAR]: item.task,
+                            [BACKLOG_FILE_VAR]: paths.backlogFilePath,
+                            [BACKLOG_DONE_FILE_VAR]: paths.doneFilePath,
+                            [BACKLOG_STAGE_VAR]: stage,
+                            ...variables,
+                        },
+                        options: {
+                            priority: item.priority,
+                            dependsOnContexts: dependsOnContexts.length > 0 ? dependsOnContexts : undefined,
+                        },
+                    },
+                };
+            },
+        }),
+        steps: [
+            ({ context }) => {
+                const ctx = context;
+                const stageName = ctx.variables[BACKLOG_STAGE_VAR];
+                if (typeof stageName !== 'string') {
+                    return [];
+                }
+                return buildStageSteps(stages, stageName);
+            },
+        ],
+        ...rest,
+    });
+}
+const backlogRecipe = defineRecipe((options) => backlog(options));
+
+const DEFAULT_IMPL_VALIDATE_COMMAND = [
+    'npm run build -w=@lumpcode/cli',
+    'npm run test -w=@lumpcode/cli',
+].join(' && ');
+const abstractionBacklog = defineRecipe((options) => {
+    const { implValidateCommand = DEFAULT_IMPL_VALIDATE_COMMAND, configUrl, ...rest } = options;
+    const projectRoot = projectRootFromConfigUrl(configUrl);
+    const runImplValidation = resolveImplValidateCommand(implValidateCommand);
+    return backlog({
+        configUrl,
+        async resolveItem({ item, paths }) {
+            const itemPrdPath = path$1.join(paths.lumpPath, 'prds', `${item.name}.prd.md`);
+            const hasPrd = await core.pathExists(path$1.join(projectRoot, itemPrdPath));
+            if (!hasPrd) {
+                return { ignored: true };
+            }
+            return {
+                stage: 'implementation',
+                variables: {
+                    PRD_FILE: itemPrdPath,
+                },
+            };
+        },
+        stages: {
+            implementation: {
+                completion: 'moveToDone',
+                steps: retryUntilGreen({
+                    steps: [{
+                            promptFn({ context: ctx }) {
+                                const vars = ctx.variables;
+                                const { PRD_FILE, TASK_NAME, TASK } = vars;
+                                return `
+                        Implement the abstraction described in @${PRD_FILE}.
+                        
+                        Backlog item: ${TASK_NAME}
+                        Task summary:
+                        ${TASK}
+                        
+                        Requirements:
+                        - Materialize the abstraction as a new util under packages/apps/cli/src/utils/<utilName>/ following existing conventions: main.ts (implementation), index.ts (re-export), unit.test.ts (unit tests), and a barrel export from packages/apps/cli/src/utils/index.ts.
+                        - Refactor all call sites in packages/apps/cli to import the new util.
+                        - Net line count must go down after the refactor (removed duplication minus new util code, excluding the new unit test file). Do not extract one-off logic or move code without deleting repetition.
+                        - Include unit tests in unit.test.ts (match sibling utils in packages/apps/cli/src/utils/).
+                        `.trim();
+                            },
+                        }],
+                    validationCommandFn: runImplValidation,
+                }),
+            },
+        },
+        ...rest,
+    });
+});
+
+const abstractionFinder = defineRecipe((options) => {
+    const { maxPendingAbstractions = 5, scanDirectories, customPrompt, backlogFilePath, prdDirPath, doneFilePath, } = options;
+    return cliUtils.defineConfig({
+        ...options,
+        getContextListFn: ephemeralContextListFn({
+            contextCount: maxPendingAbstractions,
+            variables: {
+                PRD_DIR_PATH: prdDirPath ?? '',
+                BACKLOG_FILE_PATH: backlogFilePath ?? '',
+                DONE_FILE_PATH: doneFilePath ?? '',
+            },
+        }),
+        steps: buildFinderPrompt({ prdDirPath, backlogFilePath, doneFilePath, scanDirectories, customPrompt }),
+    });
+});
+function buildFinderPrompt({ prdDirPath, backlogFilePath, doneFilePath, scanDirectories, customPrompt, }) {
+    return customPrompt ? customPrompt() : `
+Scan ${(scanDirectories || []).map((dir) => `@${dir}`).join(' and ') || 'the codebase'} for duplicated logic that appears in multiple places (same pattern, not merely similar file structure).
+
+Read @${backlogFilePath} and @${doneFilePath}. Do not propose abstractions whose util name already appears in either file.
+
+Pick exactly one new abstraction that:
+- Has a clear util name matching ^[a-zA-Z0-9_-]+$ that describes the pattern it captures.
+- Would materialize as a new util under packages/apps/cli/src/utils/<utilName>/.
+- Would shrink the codebase: refactoring all call sites in packages/apps/cli should reduce net line count (excluding new unit tests).
+
+Add exactly one entry to @${backlogFilePath} with:
+- task: a concise summary of the repeated pattern, proposed util name, and affected areas
+- priority: max existing priority in BACKLOG.yml plus 1 (or 1 if the backlog is empty)
+- dependsOn: optional list of util names from BACKLOG.yml or DONE.yml that must land first (only when clearly needed)
+
+Write an implementation-ready PRD to @${prdDirPath}/<utilName>.prd.md for the same util name. The PRD should be self-contained and include:
+- Problem statement and repeated pattern
+- Goals and non-goals
+- Proposed util API and affected files
+- Acceptance criteria (including net line reduction and unit tests)
+
+Do not implement code. Only edit @${backlogFilePath} (append one item) and create the PRD file.
+    `.trim();
+}
+
+const RESERVED_NAME_SUFFIXES = ['_prd', '_testPlan', '_tests_impl'];
+function assertValidFeatureItemName(name) {
+    for (const suffix of RESERVED_NAME_SUFFIXES) {
+        if (name.endsWith(suffix)) {
+            throw new Error(`Backlog item name must not end with reserved suffix ${suffix}: ${name}`);
+        }
+    }
+}
+function featureContextName(itemName, stage) {
+    switch (stage) {
+        case 'makePrd':
+            return `${itemName}_prd`;
+        case 'makeTestPlan':
+            return `${itemName}_testPlan`;
+        case 'testImpl':
+            return `${itemName}_tests_impl`;
+        case 'implementation':
+            return itemName;
+        default: {
+            const _exhaustive = stage;
+            return _exhaustive;
+        }
+    }
+}
+async function resolveFeatureBacklogItem(item, paths, projectRoot, lumpName, baseBranch) {
+    const prdFilePath = path$1.join(paths.lumpPath, 'prds', `${item.name}.prd.md`);
+    const testPlanFilePath = path$1.join(paths.lumpPath, 'testPlans', `${item.name}.test.md`);
+    const hasPrd = await core.pathExists(path$1.join(projectRoot, prdFilePath));
+    if (!hasPrd) {
+        if (item.manualPrd === true) {
+            return { ignored: true };
+        }
+        return {
+            stage: 'makePrd',
+            contextName: featureContextName(item.name, 'makePrd'),
+            variables: { PRD_FILE: prdFilePath },
+        };
+    }
+    const hasTestPlan = await core.pathExists(path$1.join(projectRoot, testPlanFilePath));
+    if (!hasTestPlan) {
+        return {
+            stage: 'makeTestPlan',
+            contextName: featureContextName(item.name, 'makeTestPlan'),
+            variables: {
+                PRD_FILE: prdFilePath,
+                TEST_PLAN_FILE: testPlanFilePath,
+            },
+        };
+    }
+    const testsImplContextName = featureContextName(item.name, 'testImpl');
+    const testsImplStatus = await cliUtils.getContextStatus({
+        projectRoot,
+        contextName: testsImplContextName,
+        lumpName,
+        baseBranch,
+    });
+    if (testsImplStatus === 'finished') {
+        return {
+            stage: 'implementation',
+            contextName: featureContextName(item.name, 'implementation'),
+            variables: {
+                PRD_FILE: prdFilePath,
+                TEST_PLAN_FILE: testPlanFilePath,
+            },
+        };
+    }
+    if (testsImplStatus === 'branchPushed') {
+        return { ignored: true };
+    }
+    return {
+        stage: 'testImpl',
+        contextName: testsImplContextName,
+        variables: {
+            PRD_FILE: prdFilePath,
+            TEST_PLAN_FILE: testPlanFilePath,
+        },
+    };
+}
+const featureBacklog = defineRecipe((options) => {
+    const { configUrl, baseBranch, implValidateCommand, backlogFilePath, doneFilePath, ...rest } = options;
+    const projectRoot = projectRootFromConfigUrl(configUrl);
+    const runImplValidation = resolveImplValidateCommand(implValidateCommand);
+    return backlog({
+        configUrl,
+        backlogFilePath,
+        doneFilePath,
+        baseBranch,
+        parseItem(baseItem, _index, raw) {
+            assertValidFeatureItemName(baseItem.name);
+            const record = raw;
+            if (record.manualPrd !== undefined && typeof record.manualPrd !== 'boolean') {
+                throw new Error(`Backlog item "${baseItem.name}" field "manualPrd" must be a boolean`);
+            }
+            return {
+                ...baseItem,
+                manualPrd: record.manualPrd === true ? true : undefined,
+            };
+        },
+        async resolveItem({ item, paths }) {
+            return resolveFeatureBacklogItem(item, paths, projectRoot, paths.lumpName, baseBranch);
+        },
+        stages: {
+            makePrd: {
+                completion: 'keepPending',
+                steps: [
+                    {
+                        promptFn({ context: ctx }) {
+                            const vars = ctx.variables;
+                            const { BACKLOG_FILE, TASK_NAME, TASK, PRD_FILE } = vars;
+                            return `
+Write a product requirements document (PRD) for the following Lumpcode backlog item from @${BACKLOG_FILE}.
+
+Task name: ${TASK_NAME}
+
+Task:
+${TASK}
+
+Save the PRD to @${PRD_FILE}. Do not edit @${BACKLOG_FILE}.
+
+The PRD should be self-contained and implementation-ready. Include:
+- Problem statement and motivation
+- Goals and non-goals
+- User stories / use cases
+- Docs updates (if relevant)
+- Proposed behavior and UX (for CLI work, include command syntax where relevant)
+- Technical approach and affected packages or docs
+- Acceptance criteria
+
+Do not implement the feature — only create the PRD markdown file.
+The PRD should not contain any testing strategy details.
+                            `.trim();
+                        },
+                    },
+                    requireArtifactStep('PRD_FILE'),
+                ],
+            },
+            makeTestPlan: {
+                completion: 'keepPending',
+                steps: [
+                    {
+                        promptFn({ context: ctx }) {
+                            const vars = ctx.variables;
+                            const { BACKLOG_FILE, TASK_NAME, TASK, PRD_FILE, TEST_PLAN_FILE } = vars;
+                            return `
+Write a test plan for the following Lumpcode backlog item from @${BACKLOG_FILE}.
+
+Task name: ${TASK_NAME}
+Task:
+${TASK}
+
+The PRD for this task is @${PRD_FILE}. The test plan should match the requirements of the PRD.
+
+Save the test plan to @${TEST_PLAN_FILE}. Do not edit @${BACKLOG_FILE} nor @${PRD_FILE}.
+
+The test plan should be self-contained and implementation-ready. Include:
+- Test cases
+- Test data
+- Test expectations
+- Test implementation details
+                            `.trim();
+                        },
+                    },
+                    requireArtifactStep('TEST_PLAN_FILE'),
+                ],
+            },
+            testImpl: {
+                completion: 'keepPending',
+                steps: [
+                    {
+                        promptFn({ context: ctx }) {
+                            const vars = ctx.variables;
+                            const { BACKLOG_FILE, TASK_NAME, TASK, PRD_FILE, TEST_PLAN_FILE } = vars;
+                            return `
+Write a test implementation for the following Lumpcode backlog item from @${BACKLOG_FILE}.
+
+Task name: ${TASK_NAME}
+Task:
+${TASK}
+
+Follow the test plan in @${TEST_PLAN_FILE}.
+The PRD for this task is @${PRD_FILE}.
+                            `.trim();
+                        },
+                    },
+                ],
+            },
+            implementation: {
+                completion: 'moveToDone',
+                steps: retryUntilGreen({
+                    steps: [
+                        {
+                            promptFn({ context: ctx }) {
+                                const vars = ctx.variables;
+                                const { PRD_FILE, TEST_PLAN_FILE } = vars;
+                                return `
+Implement the feature described in @${PRD_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.
+                                `.trim();
+                            },
+                        },
+                    ],
+                    validationCommandFn: runImplValidation,
+                }),
+            },
+        },
+        ...rest,
+    });
+});
+
+exports.BACKLOG_DONE_FILE_VAR = BACKLOG_DONE_FILE_VAR;
+exports.BACKLOG_FILE_VAR = BACKLOG_FILE_VAR;
+exports.BACKLOG_STAGE_VAR = BACKLOG_STAGE_VAR;
+exports.BACKLOG_TASK_NAME_VAR = BACKLOG_TASK_NAME_VAR;
+exports.BACKLOG_TASK_VAR = BACKLOG_TASK_VAR;
+exports.abstractionBacklog = abstractionBacklog;
+exports.abstractionFinder = abstractionFinder;
+exports.backlog = backlog;
+exports.backlogRecipe = backlogRecipe;
+exports.defineRecipe = defineRecipe;
+exports.ephemeralContextListFn = ephemeralContextListFn;
+exports.featureBacklog = featureBacklog;
+exports.getRecursiveSteps = getRecursiveSteps;
+exports.lumpPathAndName = lumpPathAndName;
+exports.normalizeMaybePromGetter = normalizeMaybePromGetter;
+exports.projectRootFromConfigUrl = projectRootFromConfigUrl;
+exports.requireArtifactStep = requireArtifactStep;
+exports.resolveBacklogPaths = resolveBacklogPaths;
+exports.resolveFeatureBacklogItem = resolveFeatureBacklogItem;
+exports.resolveImplValidateCommand = resolveImplValidateCommand;
+exports.retryUntilGreen = retryUntilGreen;
+exports.setTaskDoneStep = setTaskDoneStep;
+exports.shellCommand = shellCommand;
+exports.validateBaseBacklogItem = validateBaseBacklogItem;
+exports.ymlBacklogContexts = ymlBacklogContexts;