@lumpcode/recipes 0.0.13 → 0.0.15

package/dist/index.cjs

@@ -225,22 +225,188 @@ function assertProjectRelativePath(filePath, label) {
 }
 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');
+    const backlogItemsDir = overrides?.backlogItemsDir ?? path$1.join(lumpPath, 'backlogItems');
+    assertProjectRelativePath(backlogItemsDir, 'backlogItemsDir');
     return {
         lumpPath,
         lumpName,
-        backlogFilePath,
-        doneFilePath,
+        backlogItemsDir,
     };
 }
 
+const CONTEXT_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
+function assertRecord(value, location) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new Error(`Backlog item ${location} must be an object`);
+    }
+}
+function assertStringField(record, field, location) {
+    const value = record[field];
+    if (typeof value !== 'string' || value.trim() === '') {
+        throw new Error(`Backlog item ${location} requires non-empty string field "${field}"`);
+    }
+}
+function assertNumberField(record, field, location) {
+    const value = record[field];
+    if (typeof value !== 'number' || Number.isNaN(value)) {
+        throw new Error(`Backlog item ${location} requires numeric field "${field}"`);
+    }
+}
+/** Validates and normalizes one backlog item; throws on invalid input. */
+function validateBaseBacklogItem(raw, location) {
+    assertRecord(raw, location);
+    assertStringField(raw, 'name', location);
+    assertStringField(raw, 'task', location);
+    assertNumberField(raw, 'priority', location);
+    if (!CONTEXT_NAME_PATTERN.test(raw.name)) {
+        throw new Error(`Backlog item ${location} 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 ${location} field "dependsOn" must be an array`);
+        }
+        for (const dep of raw.dependsOn) {
+            if (typeof dep !== 'string' || dep.trim() === '') {
+                throw new Error(`Backlog item ${location} field "dependsOn" must contain non-empty strings`);
+            }
+        }
+        dependsOn = raw.dependsOn;
+    }
+    return {
+        name: raw.name,
+        task: raw.task,
+        priority: raw.priority,
+        dependsOn,
+    };
+}
+
+async function listTodoFolderNames(todoDir) {
+    try {
+        const entries = await fs.readdir(todoDir, { withFileTypes: true });
+        return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+}
+function folderBacklogContexts({ backlogItemsDir, parseItem, parseContext, }) {
+    return async () => {
+        const todoDir = path$1.join(backlogItemsDir, 'todo');
+        const folderNames = await listTodoFolderNames(todoDir);
+        const discovered = await Promise.all(folderNames.map(async (folderName) => {
+            const descPath = path$1.join(todoDir, folderName, 'desc.yml');
+            let rawText;
+            try {
+                rawText = await fs.readFile(descPath, 'utf-8');
+            }
+            catch (error) {
+                const err = error;
+                if (err.code === 'ENOENT') {
+                    throw new Error(`Backlog item folder "${folderName}" is missing desc.yml at ${descPath}`);
+                }
+                throw error;
+            }
+            const raw = jsYaml.load(rawText);
+            const baseItem = validateBaseBacklogItem(raw, `in folder "${folderName}"`);
+            if (baseItem.name !== folderName) {
+                throw new Error(`Backlog item folder "${folderName}" desc.yml name "${baseItem.name}" must match folder name`);
+            }
+            const item = parseItem ? parseItem(baseItem, folderName, raw) : baseItem;
+            return { item, folderName };
+        }));
+        discovered.sort((a, b) => {
+            if (a.item.priority !== b.item.priority) {
+                return a.item.priority - b.item.priority;
+            }
+            return a.item.name.localeCompare(b.item.name);
+        });
+        const allCtxs = await Promise.all(discovered.map(async ({ item, folderName }) => {
+            const { parsed, ignored } = parseContext
+                ? await parseContext(item, folderName)
+                : { 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 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) => {
+    const nameVarName = input.nameVarName ?? 'TASK_NAME';
+    return {
+        async commandFn({ context, workspacePath }) {
+            const variables = context.variables;
+            const itemsDirRelative = variables[input.itemsDirVarName];
+            const taskName = variables[nameVarName];
+            if (!itemsDirRelative || !taskName) {
+                throw new Error('Backlog items directory and task name are required');
+            }
+            const itemsDir = path$1.join(workspacePath, itemsDirRelative);
+            const fromDir = path$1.join(itemsDir, 'todo', taskName);
+            const toDir = path$1.join(itemsDir, 'completed', taskName);
+            const descPath = path$1.join(fromDir, 'desc.yml');
+            const completedDescPath = path$1.join(toDir, 'desc.yml');
+            if (!(await core.pathExists(fromDir))) {
+                return null;
+            }
+            if (await core.pathExists(toDir)) {
+                console.warn(`[lumpcode/recipes] Cannot move backlog item "${taskName}": already exists at ${toDir}`);
+                return null;
+            }
+            const rawText = await fs.readFile(descPath, 'utf-8');
+            const raw = jsYaml.load(rawText);
+            if (!isPlainObject(raw)) {
+                throw new Error(`Backlog desc.yml at ${descPath} must contain a YAML object`);
+            }
+            const updated = {
+                ...raw,
+                completedAt: new Date().toISOString(),
+            };
+            await fs.mkdir(path$1.join(itemsDir, 'completed'), { recursive: true });
+            await fs.rename(fromDir, toDir);
+            await fs.writeFile(completedDescPath, jsYaml.dump(updated));
+            return {
+                executable: 'cat',
+                args: [completedDescPath],
+            };
+        },
+        continueOnError: true,
+    };
+};
+
+let setTaskDoneDeprecatedWarned = false;
+function warnSetTaskDoneDeprecated() {
+    if (setTaskDoneDeprecatedWarned) {
+        return;
+    }
+    setTaskDoneDeprecatedWarned = true;
+    console.warn('[lumpcode/recipes] setTaskDoneStep is deprecated; use folderSetTaskDoneStep. ' +
+        '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) => {
     return {
         async commandFn({ context, workspacePath }) {
+            warnSetTaskDoneDeprecated();
             const variables = context.variables;
             const { backlogVarName, doneVarName } = input;
             const baseBacklogFilePath = variables[backlogVarName];
@@ -278,62 +444,25 @@ function resolveImplValidateCommand(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}"`);
+let ymlBacklogDeprecatedWarned = false;
+function warnYmlBacklogDeprecated() {
+    if (ymlBacklogDeprecatedWarned) {
+        return;
     }
+    ymlBacklogDeprecatedWarned = true;
+    console.warn('[lumpcode/recipes] ymlBacklogContexts is deprecated; use folderBacklogContexts. ' +
+        'YAML backlog helpers will be removed in a future major version.');
 }
-/** 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 () => {
+        warnYmlBacklogDeprecated();
         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 baseItem = validateBaseBacklogItem(rawItem, `at index ${index}`);
             const item = parseItem ? parseItem(baseItem, index, rawItem) : baseItem;
             const { parsed, ignored } = parseContext
                 ? await parseContext(item, index)
@@ -361,8 +490,8 @@ function defineRecipe(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';
+const BACKLOG_ITEMS_DIR_VAR = 'BACKLOG_ITEMS_DIR';
+const BACKLOG_ITEM_DIR_VAR = 'BACKLOG_ITEM_DIR';
 
 function isIgnoredResolution(resolution) {
     return 'ignored' in resolution && resolution.ignored === true;
@@ -379,27 +508,25 @@ function buildStageSteps(stages, stageName) {
     if (stageDef.completion === 'moveToDone') {
         return [
             ...normalized,
-            setTaskDoneStep({
-                backlogVarName: BACKLOG_FILE_VAR,
-                doneVarName: BACKLOG_DONE_FILE_VAR,
+            folderSetTaskDoneStep({
+                itemsDirVarName: BACKLOG_ITEMS_DIR_VAR,
             }),
         ];
     }
     return normalized;
 }
 function backlog(options) {
-    const { configUrl, backlogFilePath: backlogFilePathOverride, doneFilePath: doneFilePathOverride, stages, parseItem, resolveItem, ...rest } = options;
+    const { configUrl, backlogItemsDir: backlogItemsDirOverride, stages, parseItem, resolveItem, ...rest } = options;
     const paths = resolveBacklogPaths(configUrl, {
-        backlogFilePath: backlogFilePathOverride,
-        doneFilePath: doneFilePathOverride,
+        backlogItemsDir: backlogItemsDirOverride,
     });
     const projectRoot = projectRootFromConfigUrl(configUrl);
-    const absoluteBacklogPath = path$1.join(projectRoot, paths.backlogFilePath);
+    const absoluteBacklogItemsDir = path$1.join(projectRoot, paths.backlogItemsDir);
     return cliUtils.defineConfig({
-        getContextListFn: ymlBacklogContexts({
-            backlogFilePath: absoluteBacklogPath,
+        getContextListFn: folderBacklogContexts({
+            backlogItemsDir: absoluteBacklogItemsDir,
             parseItem,
-            async parseContext(item) {
+            async parseContext(item, folderName) {
                 const resolution = await resolveItem({ item, paths });
                 if (isIgnoredResolution(resolution)) {
                     return { ignored: true };
@@ -409,14 +536,15 @@ function backlog(options) {
                     ...(item.dependsOn ?? []),
                     ...(additionalDependsOnContexts ?? []),
                 ];
+                const backlogItemDir = path$1.join(paths.backlogItemsDir, 'todo', folderName);
                 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_ITEMS_DIR_VAR]: paths.backlogItemsDir,
+                            [BACKLOG_ITEM_DIR_VAR]: backlogItemDir,
                             [BACKLOG_STAGE_VAR]: stage,
                             ...variables,
                         },
@@ -446,19 +574,19 @@ const backlogRecipe = defineRecipe((options) => backlog(options));
 const abstractionBacklog = defineRecipe((options) => {
     const { implValidateCommand, configUrl, implSteps, ...rest } = options;
     const projectRoot = projectRootFromConfigUrl(configUrl);
-    const runImplValidation = resolveImplValidateCommand(implValidateCommand);
+    const runImplValidation = resolveImplValidateCommand(implValidateCommand ?? 'echo "No implementation validation command provided. I say, trust but verify, but well..."');
     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) {
+            const itemReqPath = path$1.join(paths.backlogItemsDir, 'todo', item.name, 'requirements.md');
+            const hasReq = await core.pathExists(path$1.join(projectRoot, itemReqPath));
+            if (!hasReq) {
                 return { ignored: true };
             }
             return {
                 stage: 'implementation',
                 variables: {
-                    PRD_FILE: itemPrdPath,
+                    REQ_FILE: itemReqPath,
                 },
             };
         },
@@ -469,9 +597,9 @@ const abstractionBacklog = defineRecipe((options) => {
                     steps: implSteps ?? [{
                             promptFn({ context: ctx }) {
                                 const vars = ctx.variables;
-                                const { PRD_FILE, TASK_NAME, TASK } = vars;
+                                const { REQ_FILE, TASK_NAME, TASK } = vars;
                                 return `
-                        Implement the abstraction described in @${PRD_FILE}.
+                        Implement the abstraction described in @${REQ_FILE}.
                         
                         Backlog item: ${TASK_NAME}
                         Task summary:
@@ -494,47 +622,48 @@ const abstractionBacklog = defineRecipe((options) => {
 });
 
 const abstractionFinder = defineRecipe((options) => {
-    const { maxPendingAbstractions = 5, scanDirectories, customPrompt, backlogFilePath, prdDirPath, doneFilePath, } = options;
+    const { maxPendingAbstractions = 5, scanDirectories, customPrompt, backlogItemsDir, } = options; // TODO : check if pending abstcations in backlog are less than maxPendingAbstractions
     return cliUtils.defineConfig({
         ...options,
         getContextListFn: ephemeralContextListFn({
             contextCount: maxPendingAbstractions,
             variables: {
-                PRD_DIR_PATH: prdDirPath ?? '',
-                BACKLOG_FILE_PATH: backlogFilePath ?? '',
-                DONE_FILE_PATH: doneFilePath ?? '',
+                BACKLOG_ITEMS_DIR: backlogItemsDir,
             },
         }),
-        steps: buildFinderPrompt({ prdDirPath, backlogFilePath, doneFilePath, scanDirectories, customPrompt }),
+        steps: buildFinderPrompt({ backlogItemsDir, scanDirectories, customPrompt }),
     });
 });
-function buildFinderPrompt({ prdDirPath, backlogFilePath, doneFilePath, scanDirectories, customPrompt, }) {
+function buildFinderPrompt({ backlogItemsDir, 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.
+List existing backlog item names under @${backlogItemsDir}/todo/ and @${backlogItemsDir}/completed/. Do not propose abstractions whose util name already appears in either directory.
 
 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.
+Create exactly one new backlog item folder at @${backlogItemsDir}/todo/<utilName>/ with:
+- desc.yml containing:
+  - name: <utilName> (must match folder name)
+  - task: a concise summary of the repeated pattern, proposed util name, and affected areas
+  - priority: max existing priority in todo/ plus 1 (or 1 if todo/ is empty)
+  - dependsOn: optional list of util names from todo/ or completed/ that must land first (only when clearly needed)
+- requirements.md: an implementation-ready requirements document for the same util name. It 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 create @${backlogItemsDir}/todo/<utilName>/desc.yml and @${backlogItemsDir}/todo/<utilName>/requirements.md.
+
+Do not take too much time looking for every possible abstraction. Once you found a good abstraction, stop and create the backlog item.
     `.trim();
 }
 
-const RESERVED_NAME_SUFFIXES = ['_prd', '_testPlan', '_tests_impl'];
+const RESERVED_NAME_SUFFIXES = ['_req', '_testPlan', '_tests_impl'];
 function assertValidFeatureItemName(name) {
     for (const suffix of RESERVED_NAME_SUFFIXES) {
         if (name.endsWith(suffix)) {
@@ -544,8 +673,8 @@ function assertValidFeatureItemName(name) {
 }
 function featureContextName(itemName, stage) {
     switch (stage) {
-        case 'makePrd':
-            return `${itemName}_prd`;
+        case 'makeReq':
+            return `${itemName}_req`;
         case 'makeTestPlan':
             return `${itemName}_testPlan`;
         case 'testImpl':
@@ -559,17 +688,17 @@ function featureContextName(itemName, stage) {
     }
 }
 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) {
+    const reqFilePath = path$1.join(paths.backlogItemsDir, 'todo', item.name, 'requirements.md');
+    const testPlanFilePath = path$1.join(paths.backlogItemsDir, 'todo', item.name, 'testPlan.md');
+    const hasReq = await core.pathExists(path$1.join(projectRoot, reqFilePath));
+    if (!hasReq) {
+        if (item.manualReq === true) {
             return { ignored: true };
         }
         return {
-            stage: 'makePrd',
-            contextName: featureContextName(item.name, 'makePrd'),
-            variables: { PRD_FILE: prdFilePath },
+            stage: 'makeReq',
+            contextName: featureContextName(item.name, 'makeReq'),
+            variables: { REQ_FILE: reqFilePath },
         };
     }
     const hasTestPlan = await core.pathExists(path$1.join(projectRoot, testPlanFilePath));
@@ -578,7 +707,7 @@ async function resolveFeatureBacklogItem(item, paths, projectRoot, lumpName, bas
             stage: 'makeTestPlan',
             contextName: featureContextName(item.name, 'makeTestPlan'),
             variables: {
-                PRD_FILE: prdFilePath,
+                REQ_FILE: reqFilePath,
                 TEST_PLAN_FILE: testPlanFilePath,
             },
         };
@@ -595,7 +724,7 @@ async function resolveFeatureBacklogItem(item, paths, projectRoot, lumpName, bas
             stage: 'implementation',
             contextName: featureContextName(item.name, 'implementation'),
             variables: {
-                PRD_FILE: prdFilePath,
+                REQ_FILE: reqFilePath,
                 TEST_PLAN_FILE: testPlanFilePath,
             },
         };
@@ -607,53 +736,52 @@ async function resolveFeatureBacklogItem(item, paths, projectRoot, lumpName, bas
         stage: 'testImpl',
         contextName: testsImplContextName,
         variables: {
-            PRD_FILE: prdFilePath,
+            REQ_FILE: reqFilePath,
             TEST_PLAN_FILE: testPlanFilePath,
         },
     };
 }
 const featureBacklog = defineRecipe((options) => {
-    const { configUrl, baseBranch, implValidateCommand, backlogFilePath, doneFilePath, ...rest } = options;
+    const { configUrl, baseBranch, implValidateCommand, backlogItemsDir, ...rest } = options;
     const projectRoot = projectRootFromConfigUrl(configUrl);
-    const runImplValidation = resolveImplValidateCommand(implValidateCommand);
+    const runImplValidation = resolveImplValidateCommand(implValidateCommand ?? 'echo "No implementation validation command provided. I say, trust but verify, but well..."');
     return backlog({
         configUrl,
-        backlogFilePath,
-        doneFilePath,
+        backlogItemsDir,
         baseBranch,
-        parseItem(baseItem, _index, raw) {
+        parseItem(baseItem, _folderName, 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`);
+            if (record.manualReq !== undefined && typeof record.manualReq !== 'boolean') {
+                throw new Error(`Backlog item "${baseItem.name}" field "manualReq" must be a boolean`);
             }
             return {
                 ...baseItem,
-                manualPrd: record.manualPrd === true ? true : undefined,
+                manualReq: record.manualReq === true ? true : undefined,
             };
         },
         async resolveItem({ item, paths }) {
             return resolveFeatureBacklogItem(item, paths, projectRoot, paths.lumpName, baseBranch);
         },
         stages: {
-            makePrd: {
+            makeReq: {
                 completion: 'keepPending',
                 steps: [
                     {
                         promptFn({ context: ctx }) {
                             const vars = ctx.variables;
-                            const { BACKLOG_FILE, TASK_NAME, TASK, PRD_FILE } = vars;
+                            const { BACKLOG_ITEM_DIR, TASK_NAME, TASK, REQ_FILE } = vars;
                             return `
-Write a product requirements document (PRD) for the following Lumpcode backlog item from @${BACKLOG_FILE}.
+Write a requirements document for the following backlog item from @${BACKLOG_ITEM_DIR}/desc.yml.
 
 Task name: ${TASK_NAME}
 
 Task:
 ${TASK}
 
-Save the PRD to @${PRD_FILE}. Do not edit @${BACKLOG_FILE}.
+Save the requirements document to @${REQ_FILE}. Do not edit @${BACKLOG_ITEM_DIR}/desc.yml.
 
-The PRD should be self-contained and implementation-ready. Include:
+The requirements document should be self-contained and implementation-ready. Include:
 - Problem statement and motivation
 - Goals and non-goals
 - User stories / use cases
@@ -662,12 +790,12 @@ The PRD should be self-contained and implementation-ready. Include:
 - 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.
+Do not implement the feature — only create the requirements markdown file.
+The requirements document should not contain any testing strategy details.
                             `.trim();
                         },
                     },
-                    requireArtifactStep('PRD_FILE'),
+                    requireArtifactStep('REQ_FILE'),
                 ],
             },
             makeTestPlan: {
@@ -676,17 +804,17 @@ The PRD should not contain any testing strategy details.
                     {
                         promptFn({ context: ctx }) {
                             const vars = ctx.variables;
-                            const { BACKLOG_FILE, TASK_NAME, TASK, PRD_FILE, TEST_PLAN_FILE } = vars;
+                            const { BACKLOG_ITEM_DIR, TASK_NAME, TASK, REQ_FILE, TEST_PLAN_FILE } = vars;
                             return `
-Write a test plan for the following Lumpcode backlog item from @${BACKLOG_FILE}.
+Write a test plan for the following backlog item from @${BACKLOG_ITEM_DIR}/desc.yml.
 
 Task name: ${TASK_NAME}
 Task:
 ${TASK}
 
-The PRD for this task is @${PRD_FILE}. The test plan should match the requirements of the PRD.
+The requirements for this task are in @${REQ_FILE}. The test plan should match those requirements.
 
-Save the test plan to @${TEST_PLAN_FILE}. Do not edit @${BACKLOG_FILE} nor @${PRD_FILE}.
+Save the test plan to @${TEST_PLAN_FILE}. Do not edit @${BACKLOG_ITEM_DIR}/desc.yml nor @${REQ_FILE}.
 
 The test plan should be self-contained and implementation-ready. Include:
 - Test cases
@@ -705,16 +833,16 @@ The test plan should be self-contained and implementation-ready. Include:
                     {
                         promptFn({ context: ctx }) {
                             const vars = ctx.variables;
-                            const { BACKLOG_FILE, TASK_NAME, TASK, PRD_FILE, TEST_PLAN_FILE } = vars;
+                            const { BACKLOG_ITEM_DIR, TASK_NAME, TASK, REQ_FILE, TEST_PLAN_FILE } = vars;
                             return `
-Write a test implementation for the following Lumpcode backlog item from @${BACKLOG_FILE}.
+Write a test implementation for the following backlog item from @${BACKLOG_ITEM_DIR}/desc.yml.
 
 Task name: ${TASK_NAME}
 Task:
 ${TASK}
 
 Follow the test plan in @${TEST_PLAN_FILE}.
-The PRD for this task is @${PRD_FILE}.
+The requirements for this task are in @${REQ_FILE}.
                             `.trim();
                         },
                     },
@@ -727,9 +855,9 @@ The PRD for this task is @${PRD_FILE}.
                         {
                             promptFn({ context: ctx }) {
                                 const vars = ctx.variables;
-                                const { PRD_FILE, TEST_PLAN_FILE } = vars;
+                                const { REQ_FILE, TEST_PLAN_FILE } = vars;
                                 return `
-Implement the feature described in @${PRD_FILE}.
+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.
                                 `.trim();
@@ -744,8 +872,8 @@ The implementation should make the tests pass. Do not edit any test file.
     });
 });
 
-exports.BACKLOG_DONE_FILE_VAR = BACKLOG_DONE_FILE_VAR;
-exports.BACKLOG_FILE_VAR = BACKLOG_FILE_VAR;
+exports.BACKLOG_ITEMS_DIR_VAR = BACKLOG_ITEMS_DIR_VAR;
+exports.BACKLOG_ITEM_DIR_VAR = BACKLOG_ITEM_DIR_VAR;
 exports.BACKLOG_STAGE_VAR = BACKLOG_STAGE_VAR;
 exports.BACKLOG_TASK_NAME_VAR = BACKLOG_TASK_NAME_VAR;
 exports.BACKLOG_TASK_VAR = BACKLOG_TASK_VAR;
@@ -756,6 +884,8 @@ exports.backlogRecipe = backlogRecipe;
 exports.defineRecipe = defineRecipe;
 exports.ephemeralContextListFn = ephemeralContextListFn;
 exports.featureBacklog = featureBacklog;
+exports.folderBacklogContexts = folderBacklogContexts;
+exports.folderSetTaskDoneStep = folderSetTaskDoneStep;
 exports.getRecursiveSteps = getRecursiveSteps;
 exports.lumpPathAndName = lumpPathAndName;
 exports.normalizeMaybePromGetter = normalizeMaybePromGetter;