@shepai/cli 1.165.0 → 1.166.0-pr513.7e8c227

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/prompts/apply-feedback.prompt.js

@@ -0,0 +1,38 @@
+/**
+ * Apply-Feedback Prompt Builder
+ *
+ * Builds a context summary for the apply-feedback node. This is used
+ * internally by the graph to prepare context for the next
+ * prototype-generate iteration — it does NOT call the executor.
+ *
+ * The prompt text produced here serves as a structured summary of
+ * the current feedback and iteration context that the apply-feedback
+ * node stores in state for the next prototype-generate node to consume.
+ */
+/**
+ * Build a context summary for the apply-feedback state transformation.
+ *
+ * Includes:
+ * 1. Current feedback text
+ * 2. Iteration count
+ * 3. Summary of prior feedback history
+ *
+ * This is stored in graph state, not sent to an executor.
+ */
+export function buildApplyFeedbackContext(state, currentFeedback) {
+    const iterationCount = state.iterationCount ?? 0;
+    const feedbackHistory = state.feedbackHistory ?? [];
+    const sections = [];
+    sections.push(`## Feedback Applied — Iteration ${iterationCount + 1}`);
+    sections.push(`**Current feedback:** ${currentFeedback}`);
+    if (feedbackHistory.length > 0) {
+        sections.push(`**Prior feedback rounds:** ${feedbackHistory.length}`);
+        const recentPrior = feedbackHistory.slice(-3);
+        const startIdx = feedbackHistory.length - recentPrior.length;
+        recentPrior.forEach((fb, i) => {
+            const summary = fb.length > 80 ? `${fb.slice(0, 80)}...` : fb;
+            sections.push(`- Iteration ${startIdx + i + 1}: ${summary}`);
+        });
+    }
+    return sections.join('\n');
+}

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/prompts/prototype-generate.prompt.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Prototype-Generate Prompt Builder
+ *
+ * Builds the prompt for exploration mode prototype generation.
+ * Emphasizes quick prototyping, minimal scope, and throwaway quality.
+ * Includes iteration context (feedback history) for subsequent rounds.
+ *
+ * The prompt instructs the executor to produce a working prototype that
+ * demonstrates the idea — prioritizing concept demonstration over
+ * production quality.
+ */
+import type { FeatureAgentState } from '../../state.js';
+/**
+ * Build a feedback history section for the prompt.
+ * Recent feedback (last 3) gets full detail; older entries are summarized.
+ */
+export declare function buildFeedbackHistorySection(feedbackHistory: string[]): string;
+/**
+ * Build the prototype-generate prompt.
+ *
+ * The prompt includes:
+ * 1. Exploration mode instructions (speed over quality)
+ * 2. User's idea/query
+ * 3. Iteration context (feedback history from prior rounds)
+ * 4. CLAUDE.md content (if exists)
+ * 5. Shallow directory listing
+ *
+ * Instructs the executor to produce a quick, working prototype.
+ */
+export declare function buildPrototypeGeneratePrompt(state: FeatureAgentState): string;
+//# sourceMappingURL=prototype-generate.prompt.d.ts.map

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/prompts/prototype-generate.prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prototype-generate.prompt.d.ts","sourceRoot":"","sources":["../../../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/nodes/prompts/prototype-generate.prompt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAgHxD;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,eAAe,EAAE,MAAM,EAAE,GAAG,MAAM,CAwB7E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,CAsF7E"}

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/prompts/prototype-generate.prompt.js

@@ -0,0 +1,240 @@
+/**
+ * Prototype-Generate Prompt Builder
+ *
+ * Builds the prompt for exploration mode prototype generation.
+ * Emphasizes quick prototyping, minimal scope, and throwaway quality.
+ * Includes iteration context (feedback history) for subsequent rounds.
+ *
+ * The prompt instructs the executor to produce a working prototype that
+ * demonstrates the idea — prioritizing concept demonstration over
+ * production quality.
+ */
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import yaml from 'js-yaml';
+import { readSpecFile } from '../node-helpers.js';
+/**
+ * Read a file from the worktree, returning empty string if not found.
+ */
+function readWorktreeFile(worktreePath, filename) {
+    try {
+        return readFileSync(join(worktreePath, filename), 'utf-8');
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Build a shallow directory listing (depth 1-2) of the worktree.
+ * Returns a tree-style string. Skips common noise directories.
+ */
+function buildDirectoryListing(worktreePath) {
+    const SKIP_DIRS = new Set([
+        'node_modules',
+        '.git',
+        '.next',
+        'dist',
+        'build',
+        'coverage',
+        '.turbo',
+        '.cache',
+        '.shep',
+    ]);
+    const lines = [];
+    try {
+        const topLevel = readdirSync(worktreePath);
+        for (const entry of topLevel) {
+            if (SKIP_DIRS.has(entry))
+                continue;
+            const fullPath = join(worktreePath, entry);
+            let isDir = false;
+            try {
+                isDir = statSync(fullPath).isDirectory();
+            }
+            catch {
+                continue;
+            }
+            if (isDir) {
+                lines.push(`${entry}/`);
+                try {
+                    const children = readdirSync(fullPath);
+                    for (const child of children) {
+                        if (SKIP_DIRS.has(child))
+                            continue;
+                        const childPath = join(fullPath, child);
+                        let childIsDir = false;
+                        try {
+                            childIsDir = statSync(childPath).isDirectory();
+                        }
+                        catch {
+                            continue;
+                        }
+                        lines.push(`  ${child}${childIsDir ? '/' : ''}`);
+                    }
+                }
+                catch {
+                    // Cannot read subdirectory — skip
+                }
+            }
+            else {
+                lines.push(entry);
+            }
+        }
+    }
+    catch {
+        return '(unable to list directory)';
+    }
+    return lines.join('\n');
+}
+/**
+ * Extract the user query from spec.yaml's userQuery field.
+ * Falls back to the raw YAML content if parsing fails.
+ */
+function extractUserQuery(specDir) {
+    const specContent = readSpecFile(specDir, 'spec.yaml');
+    if (!specContent) {
+        // For exploration mode, also check feature.yaml for the prompt
+        const featureContent = readSpecFile(specDir, 'feature.yaml');
+        if (!featureContent)
+            return '';
+        try {
+            const data = yaml.load(featureContent);
+            const userQuery = data?.userQuery ?? data?.feature?.description;
+            if (typeof userQuery === 'string' && userQuery.trim()) {
+                return userQuery.trim();
+            }
+        }
+        catch {
+            // Fall through
+        }
+        return featureContent;
+    }
+    try {
+        const data = yaml.load(specContent);
+        const userQuery = data?.userQuery;
+        if (typeof userQuery === 'string' && userQuery.trim()) {
+            return userQuery.trim();
+        }
+    }
+    catch {
+        // Fall through to raw content
+    }
+    return specContent;
+}
+/** Maximum number of recent feedback entries to include in full detail. */
+const MAX_FULL_FEEDBACK_ENTRIES = 3;
+/**
+ * Build a feedback history section for the prompt.
+ * Recent feedback (last 3) gets full detail; older entries are summarized.
+ */
+export function buildFeedbackHistorySection(feedbackHistory) {
+    if (feedbackHistory.length === 0)
+        return '';
+    const sections = [];
+    if (feedbackHistory.length > MAX_FULL_FEEDBACK_ENTRIES) {
+        const older = feedbackHistory.slice(0, -MAX_FULL_FEEDBACK_ENTRIES);
+        sections.push('### Earlier feedback (summarized)');
+        older.forEach((fb, i) => {
+            // Truncate each older entry to a single line summary
+            const summary = fb.length > 100 ? `${fb.slice(0, 100)}...` : fb;
+            sections.push(`- Iteration ${i + 1}: ${summary}`);
+        });
+        sections.push('');
+    }
+    const recent = feedbackHistory.slice(-MAX_FULL_FEEDBACK_ENTRIES);
+    const startIdx = feedbackHistory.length - recent.length;
+    sections.push('### Recent feedback (act on these)');
+    recent.forEach((fb, i) => {
+        sections.push(`**Iteration ${startIdx + i + 1}:** ${fb}`);
+    });
+    return `## Feedback History\n\n${sections.join('\n')}`;
+}
+/**
+ * Build the prototype-generate prompt.
+ *
+ * The prompt includes:
+ * 1. Exploration mode instructions (speed over quality)
+ * 2. User's idea/query
+ * 3. Iteration context (feedback history from prior rounds)
+ * 4. CLAUDE.md content (if exists)
+ * 5. Shallow directory listing
+ *
+ * Instructs the executor to produce a quick, working prototype.
+ */
+export function buildPrototypeGeneratePrompt(state) {
+    const cwd = state.worktreePath || state.repositoryPath;
+    const userQuery = extractUserQuery(state.specDir);
+    const iterationCount = state.iterationCount ?? 0;
+    const feedbackHistory = state.feedbackHistory ?? [];
+    // Read optional context files
+    const claudeMd = readWorktreeFile(cwd, 'CLAUDE.md');
+    const dirListing = buildDirectoryListing(cwd);
+    const isFirstIteration = iterationCount === 0;
+    const sections = [];
+    // Main instruction
+    sections.push(`You are a senior software engineer in EXPLORATION MODE — generating a quick prototype.
+
+## Mode: Exploration (Prototype)
+
+**Priority: SPEED over quality. Show the concept, don't build for production.**
+
+- Generate a working prototype that demonstrates the idea
+- Keep scope minimal — focus on the core concept
+- Skip edge cases, error handling, and production polish
+- Write just enough code to show how the idea would work
+- This is throwaway code — it will be rewritten if the idea is promoted to a real feature`);
+    // User request
+    if (isFirstIteration) {
+        sections.push(`## User's Idea
+
+${userQuery}`);
+    }
+    else {
+        sections.push(`## User's Idea (Original)
+
+${userQuery}
+
+## Current Iteration: ${iterationCount + 1}
+
+This is iteration ${iterationCount + 1} of the prototype. Review the feedback below and update the prototype accordingly.`);
+    }
+    // Feedback history
+    const feedbackSection = buildFeedbackHistorySection(feedbackHistory);
+    if (feedbackSection) {
+        sections.push(feedbackSection);
+    }
+    // Implementation instructions
+    sections.push(`## Implementation Instructions
+
+1. ${isFirstIteration ? 'Create' : 'Update'} the prototype based on ${isFirstIteration ? 'the idea above' : 'the feedback above'}
+2. Make the code functional — it should compile and demonstrate the concept
+3. Commit your work with a conventional commit message (e.g. \`feat(domain): prototype workspace grouping\`)
+4. Do NOT write tests — this is a prototype
+5. Do NOT run linters or builds — speed is the priority
+6. Do NOT push to remote
+
+## Working Directory
+
+${cwd}`);
+    if (claudeMd) {
+        sections.push(`## Project Guidelines (CLAUDE.md)
+
+${claudeMd}`);
+    }
+    if (dirListing && dirListing !== '(unable to list directory)') {
+        sections.push(`## Project Structure
+
+\`\`\`
+${dirListing}
+\`\`\``);
+    }
+    sections.push(`## Constraints
+
+- SPEED is the priority — generate a working prototype quickly
+- Keep changes minimal and focused on demonstrating the concept
+- Do NOT modify any spec YAML files
+- Do NOT enter plan mode — implement directly
+- Do NOT ask questions — make reasonable assumptions and proceed
+- You MUST create or modify actual code files — a plan or summary alone is not acceptable`);
+    return sections.join('\n\n');
+}

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/prototype-generate.node.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Prototype-Generate Node
+ *
+ * Exploration mode node that generates a quick prototype by calling the
+ * agent executor with an exploration-focused prompt. After generation,
+ * interrupts for user feedback. Uses shared utilities (retryExecute,
+ * createNodeLogger) but NOT executeNode() which is coupled to approval gates.
+ *
+ * Follows the same factory pattern as other nodes: takes executor
+ * dependency, returns async (state) => Partial<FeatureAgentState>.
+ */
+import type { IAgentExecutor } from '../../../../../application/ports/output/agents/agent-executor.interface.js';
+import type { FeatureAgentState } from '../state.js';
+/**
+ * Factory that creates the prototype-generate node function.
+ *
+ * @param executor - The agent executor to use for prototype generation
+ * @returns A LangGraph node function
+ */
+export declare function createPrototypeGenerateNode(executor: IAgentExecutor): (state: FeatureAgentState) => Promise<Partial<FeatureAgentState>>;
+//# sourceMappingURL=prototype-generate.node.d.ts.map

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/prototype-generate.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prototype-generate.node.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/nodes/prototype-generate.node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AACpG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAOrD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,cAAc,IAGpD,OAAO,iBAAiB,KAAG,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAuH7E"}

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/prototype-generate.node.js

@@ -0,0 +1,134 @@
+/**
+ * Prototype-Generate Node
+ *
+ * Exploration mode node that generates a quick prototype by calling the
+ * agent executor with an exploration-focused prompt. After generation,
+ * interrupts for user feedback. Uses shared utilities (retryExecute,
+ * createNodeLogger) but NOT executeNode() which is coupled to approval gates.
+ *
+ * Follows the same factory pattern as other nodes: takes executor
+ * dependency, returns async (state) => Partial<FeatureAgentState>.
+ */
+import { interrupt, isGraphBubbleUp } from '@langchain/langgraph';
+import { createNodeLogger, buildExecutorOptions, retryExecute } from './node-helpers.js';
+import { reportNodeStart } from '../heartbeat.js';
+import { recordPhaseStart, recordPhaseEnd } from '../phase-timing-context.js';
+import { updateNodeLifecycle } from '../lifecycle-context.js';
+import { buildPrototypeGeneratePrompt } from './prompts/prototype-generate.prompt.js';
+/**
+ * Factory that creates the prototype-generate node function.
+ *
+ * @param executor - The agent executor to use for prototype generation
+ * @returns A LangGraph node function
+ */
+export function createPrototypeGenerateNode(executor) {
+    const log = createNodeLogger('prototype-generate');
+    return async (state) => {
+        log.activate();
+        const iterationCount = state.iterationCount ?? 0;
+        const maxIterations = state.maxIterations ?? 10;
+        log.info(`Starting prototype generation (iteration ${iterationCount + 1}/${maxIterations})`);
+        reportNodeStart('prototype-generate');
+        await updateNodeLifecycle('prototype-generate');
+        // On resume from interrupt, LangGraph re-executes the node function.
+        // If _approvalAction is set, the worker has resumed us with a user action.
+        // Return early and let the conditional edge route to apply-feedback or END.
+        if (state._approvalAction !== null && state._approvalAction !== undefined) {
+            if (state._approvalAction === 'rejected') {
+                log.info('Resumed with feedback — routing to apply-feedback');
+                return {
+                    currentNode: 'prototype-generate',
+                    explorationStatus: 'applying-feedback',
+                    messages: ['[prototype-generate] Resumed — routing feedback to apply-feedback'],
+                };
+            }
+            else {
+                log.info('Resumed with promote/discard — routing to END');
+                return {
+                    currentNode: 'prototype-generate',
+                    explorationStatus: 'promoting',
+                    messages: ['[prototype-generate] Resumed — routing to END (promote/discard)'],
+                    _approvalAction: null,
+                };
+            }
+        }
+        // Check if max iterations reached — force user to promote or discard
+        if (iterationCount >= maxIterations) {
+            log.info(`Max iterations (${maxIterations}) reached — interrupting for final action`);
+            interrupt({
+                node: 'prototype-generate',
+                message: `Maximum iterations (${maxIterations}) reached. Please promote or discard this exploration.`,
+                iterationCount,
+                maxIterations,
+                forceAction: true,
+            });
+            // If we get here after resume, the graph router will handle the action
+            return {
+                currentNode: 'prototype-generate',
+                explorationStatus: 'waiting-feedback',
+                messages: [
+                    `[prototype-generate] Max iterations reached (${maxIterations}) — awaiting promote/discard`,
+                ],
+            };
+        }
+        const startTime = Date.now();
+        const prompt = buildPrototypeGeneratePrompt(state);
+        const timingId = await recordPhaseStart('prototype-generate', {
+            prompt,
+            modelId: state.model,
+            agentType: executor.agentType,
+        });
+        try {
+            const options = buildExecutorOptions(state, undefined, 'prototype-generate');
+            log.info(`Executing agent at cwd=${options.cwd}`);
+            log.info(`Prompt length: ${prompt.length} chars`);
+            const result = await retryExecute(executor, prompt, options, { logger: log });
+            const durationMs = Date.now() - startTime;
+            const elapsed = (durationMs / 1000).toFixed(1);
+            log.info(`Prototype generated (${result.result.length} chars, ${elapsed}s)`);
+            await recordPhaseEnd(timingId, durationMs, {
+                inputTokens: result.usage?.inputTokens,
+                outputTokens: result.usage?.outputTokens,
+                cacheCreationInputTokens: result.usage?.cacheCreationInputTokens,
+                cacheReadInputTokens: result.usage?.cacheReadInputTokens,
+                costUsd: result.usage?.costUsd,
+                numTurns: result.usage?.numTurns,
+                durationApiMs: result.usage?.durationApiMs,
+                exitCode: 'success',
+            });
+            const newIterationCount = iterationCount + 1;
+            // Interrupt for user feedback
+            log.info(`Interrupting for feedback (iteration ${newIterationCount}/${maxIterations})`);
+            interrupt({
+                node: 'prototype-generate',
+                message: `Prototype iteration ${newIterationCount} complete. Review and provide feedback, promote, or discard.`,
+                iterationCount: newIterationCount,
+                maxIterations,
+                resultSummary: result.result.slice(0, 500),
+            });
+            // After resume, return the updated state
+            return {
+                currentNode: 'prototype-generate',
+                iterationCount: newIterationCount,
+                explorationStatus: 'waiting-feedback',
+                messages: [
+                    `[prototype-generate] Iteration ${newIterationCount} complete (${result.result.length} chars, ${elapsed}s)`,
+                ],
+            };
+        }
+        catch (err) {
+            if (isGraphBubbleUp(err))
+                throw err;
+            const message = err instanceof Error ? err.message : String(err);
+            const durationMs = Date.now() - startTime;
+            const elapsed = (durationMs / 1000).toFixed(1);
+            log.error(`${message} (after ${elapsed}s)`);
+            await recordPhaseEnd(timingId, durationMs, {
+                exitCode: 'error',
+                errorMessage: message.slice(0, 1000),
+            });
+            // Throw so LangGraph does NOT checkpoint this node as "completed"
+            throw new Error(`[prototype-generate] ${message}`);
+        }
+    };
+}

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/state.d.ts

@@ -59,6 +59,10 @@ export declare const FeatureAgentAnnotation: import("@langchain/langgraph").Anno
     ciFixAttempts: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
     ciFixHistory: import("@langchain/langgraph").BinaryOperatorAggregate<CiFixRecord[], CiFixRecord[]>;
     ciFixStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted", "success" | "timeout" | "idle" | "watching" | "fixing" | "exhausted">;
+    iterationCount: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+    maxIterations: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+    feedbackHistory: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    explorationStatus: import("@langchain/langgraph").BinaryOperatorAggregate<"generating" | "waiting-feedback" | "applying-feedback" | "promoting" | "discarding" | undefined, "generating" | "waiting-feedback" | "applying-feedback" | "promoting" | "discarding" | undefined>;
 }>;
 export type FeatureAgentState = typeof FeatureAgentAnnotation.State;
 //# sourceMappingURL=state.d.ts.map

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAEzF;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwHjC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,OAAO,sBAAsB,CAAC,KAAK,CAAC"}
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAEzF;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2IjC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,OAAO,sBAAsB,CAAC,KAAK,CAAC"}

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/state.js

@@ -126,4 +126,21 @@ export const FeatureAgentAnnotation = Annotation.Root({
         reducer: (_prev, next) => next,
         default: () => 'idle',
     }),
+    // --- Exploration mode state channels ---
+    iterationCount: Annotation({
+        reducer: (_prev, next) => next,
+        default: () => 0,
+    }),
+    maxIterations: Annotation({
+        reducer: (_prev, next) => next,
+        default: () => 10,
+    }),
+    feedbackHistory: Annotation({
+        reducer: (prev, next) => [...prev, ...next],
+        default: () => [],
+    }),
+    explorationStatus: Annotation({
+        reducer: (_prev, next) => next,
+        default: () => undefined,
+    }),
 });

package/dist/packages/core/src/infrastructure/services/spec/spec-initializer.service.d.ts

@@ -7,7 +7,7 @@
  */
 import type { ISpecInitializerService, SpecInitializerResult } from '../../../application/ports/output/services/spec-initializer.interface.js';
 export declare class SpecInitializerService implements ISpecInitializerService {
-    initialize(basePath: string, slug: string, featureNumber: number, description: string, mode?: 'fast'): Promise<SpecInitializerResult>;
+    initialize(basePath: string, slug: string, featureNumber: number, description: string, mode?: 'fast' | 'exploration'): Promise<SpecInitializerResult>;
     /**
      * Scan specs/ for existing NNN-* directories and return the next available number.
      * Uses the DB-derived hint as a minimum, but always respects filesystem state.

package/dist/packages/core/src/infrastructure/services/spec/spec-initializer.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spec-initializer.service.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/spec/spec-initializer.service.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EACV,uBAAuB,EACvB,qBAAqB,EACtB,MAAM,mEAAmE,CAAC;AA8P3E,qBAAa,sBAAuB,YAAW,uBAAuB;IAC9D,UAAU,CACd,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO,CAAC,qBAAqB,CAAC;IAqCjC;;;OAGG;YACW,iBAAiB;CAoBhC"}
+{"version":3,"file":"spec-initializer.service.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/spec/spec-initializer.service.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EACV,uBAAuB,EACvB,qBAAqB,EACtB,MAAM,mEAAmE,CAAC;AA8P3E,qBAAa,sBAAuB,YAAW,uBAAuB;IAC9D,UAAU,CACd,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE,MAAM,GAAG,aAAa,GAC5B,OAAO,CAAC,qBAAqB,CAAC;IAwCjC;;;OAGG;YACW,iBAAiB;CAoBhC"}

package/dist/packages/core/src/infrastructure/services/spec/spec-initializer.service.js

@@ -254,10 +254,13 @@ export class SpecInitializerService {
         const timestamp = now.toISOString().replace(/\.\d{3}Z$/, 'Z');
         const vars = { nnn, slug, featureNumber: resolvedNumber, date, timestamp, description };
         // In fast mode, write feature.yaml + spec.yaml (spec.yaml stores the user query
-        // which the fast-implement node reads; no research/plan/tasks needed)
-        const templates = mode === 'fast'
-            ? TEMPLATES.filter(({ filename }) => filename === 'feature.yaml' || filename === 'spec.yaml')
-            : TEMPLATES;
+        // which the fast-implement node reads; no research/plan/tasks needed).
+        // In exploration mode, write only feature.yaml (no SDLC spec artifacts).
+        const templates = mode === 'exploration'
+            ? TEMPLATES.filter(({ filename }) => filename === 'feature.yaml')
+            : mode === 'fast'
+                ? TEMPLATES.filter(({ filename }) => filename === 'feature.yaml' || filename === 'spec.yaml')
+                : TEMPLATES;
         // Write template files
         await Promise.all(templates.map(({ filename, content }) => writeFile(join(specDir, filename), applyTemplate(content, vars), 'utf-8')));
         return { specDir, featureNumber: nnn };

package/dist/src/presentation/cli/commands/feat/feedback.command.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Feature Feedback Command
+ *
+ * Sends feedback on an exploration prototype to iterate on the design.
+ * Resumes the interrupted exploration agent graph with the provided feedback.
+ *
+ * Usage:
+ *   shep feat feedback <id> <feedback-text>
+ */
+import { Command } from 'commander';
+export declare function createFeedbackCommand(): Command;
+//# sourceMappingURL=feedback.command.d.ts.map

package/dist/src/presentation/cli/commands/feat/feedback.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feedback.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/feedback.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASpC,wBAAgB,qBAAqB,IAAI,OAAO,CA+D/C"}

package/dist/src/presentation/cli/commands/feat/feedback.command.js

@@ -0,0 +1,64 @@
+/**
+ * Feature Feedback Command
+ *
+ * Sends feedback on an exploration prototype to iterate on the design.
+ * Resumes the interrupted exploration agent graph with the provided feedback.
+ *
+ * Usage:
+ *   shep feat feedback <id> <feedback-text>
+ */
+import { Command } from 'commander';
+import { container } from '../../../../../packages/core/src/infrastructure/di/container.js';
+import { RejectAgentRunUseCase } from '../../../../../packages/core/src/application/use-cases/agents/reject-agent-run.use-case.js';
+import { FeatureMode, SdlcLifecycle } from '../../../../../packages/core/src/domain/generated/output.js';
+import { colors, messages } from '../../ui/index.js';
+import { getCliI18n } from '../../i18n.js';
+export function createFeedbackCommand() {
+    const t = getCliI18n().t;
+    return new Command('feedback')
+        .description(t('cli:commands.feat.feedback.description'))
+        .argument('<id>', t('cli:commands.feat.feedback.idArgument'))
+        .argument('<feedback>', t('cli:commands.feat.feedback.feedbackArgument'))
+        .action(async (featureId, feedback) => {
+        try {
+            const featureRepo = container.resolve('IFeatureRepository');
+            const runRepo = container.resolve('IAgentRunRepository');
+            const feature = (await featureRepo.findById(featureId)) ?? (await featureRepo.findByIdPrefix(featureId));
+            if (!feature) {
+                throw new Error(`Feature not found: ${featureId}`);
+            }
+            if (feature.mode !== FeatureMode.Exploration ||
+                feature.lifecycle !== SdlcLifecycle.Exploring) {
+                messages.error(t('cli:commands.feat.feedback.notExploration', {
+                    name: feature.name,
+                    mode: feature.mode,
+                    lifecycle: feature.lifecycle,
+                }));
+                process.exitCode = 1;
+                return;
+            }
+            if (!feature.agentRunId) {
+                throw new Error(`Feature "${feature.name}" has no agent run`);
+            }
+            const run = await runRepo.findById(feature.agentRunId);
+            if (!run) {
+                throw new Error(`Agent run not found: ${feature.agentRunId}`);
+            }
+            const rejectUseCase = container.resolve(RejectAgentRunUseCase);
+            const result = await rejectUseCase.execute(run.id, feedback);
+            if (!result.rejected) {
+                throw new Error(result.reason);
+            }
+            messages.newline();
+            messages.success(t('cli:commands.feat.feedback.feedbackSubmitted', { name: feature.name }));
+            console.log(`  ${colors.muted(t('cli:commands.feat.feedback.iterationLabel'))} ${result.iteration}`);
+            console.log(`  ${colors.muted(t('cli:commands.feat.feedback.agentLabel'))}     ${t('cli:commands.feat.feedback.agentIterating')}`);
+            messages.newline();
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            messages.error(t('cli:commands.feat.feedback.failedToSubmit'), err);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/src/presentation/cli/commands/feat/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgBpC;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAgB3C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAkBpC;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAkB3C"}

package/dist/src/presentation/cli/commands/feat/index.js

@@ -24,6 +24,8 @@ import { createLogsCommand } from './logs.command.js';
 import { createAdoptCommand } from './adopt.command.js';
 import { createArchiveCommand } from './archive.command.js';
 import { createUnarchiveCommand } from './unarchive.command.js';
+import { createFeedbackCommand } from './feedback.command.js';
+import { createPromoteCommand } from './promote.command.js';
 /**
  * Create the feat command group
  */
@@ -42,5 +44,7 @@ export function createFeatCommand() {
         .addCommand(createLogsCommand())
         .addCommand(createAdoptCommand())
         .addCommand(createArchiveCommand())
-        .addCommand(createUnarchiveCommand());
+        .addCommand(createUnarchiveCommand())
+        .addCommand(createFeedbackCommand())
+        .addCommand(createPromoteCommand());
 }