@shepai/cli 1.19.0 → 1.20.0

package/dist/src/infrastructure/services/agents/feature-agent/nodes/schemas/research.schema.js

@@ -0,0 +1,24 @@
+import { requireString, requireArrayOfShape, requireNonEmptyArray, } from './validation.js';
+export function validateResearch(data) {
+    const errors = [];
+    if (!data || typeof data !== 'object') {
+        errors.push('YAML parsed to null or non-object');
+        return { valid: false, errors };
+    }
+    const d = data;
+    requireString(d, 'name', errors);
+    requireString(d, 'summary', errors);
+    requireString(d, 'content', errors);
+    requireArrayOfShape(d, 'decisions', errors, (item, idx, errs) => {
+        const decision = item;
+        if (!decision || typeof decision !== 'object') {
+            errs.push(`decisions[${idx}] must be an object`);
+            return;
+        }
+        requireString(decision, 'title', errs, `decisions[${idx}].`);
+        requireString(decision, 'chosen', errs, `decisions[${idx}].`);
+        requireNonEmptyArray(decision, 'rejected', errs, `decisions[${idx}].`);
+        requireString(decision, 'rationale', errs, `decisions[${idx}].`);
+    });
+    return { valid: errors.length === 0, errors };
+}

package/dist/src/infrastructure/services/agents/feature-agent/nodes/schemas/spec.schema.d.ts

@@ -0,0 +1,4 @@
+import { type ValidationResult } from './validation.js';
+export declare function validateSpecAnalyze(data: unknown): ValidationResult;
+export declare function validateSpecRequirements(data: unknown): ValidationResult;
+//# sourceMappingURL=spec.schema.d.ts.map

package/dist/src/infrastructure/services/agents/feature-agent/nodes/schemas/spec.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec.schema.d.ts","sourceRoot":"","sources":["../../../../../../../../src/infrastructure/services/agents/feature-agent/nodes/schemas/spec.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuC,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AA4B7F,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,gBAAgB,CAInE;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,OAAO,GAAG,gBAAgB,CAqBxE"}

package/dist/src/infrastructure/services/agents/feature-agent/nodes/schemas/spec.schema.js

@@ -0,0 +1,50 @@
+import { requireString, requireNonEmptyArray } from './validation.js';
+const VALID_SIZE_ESTIMATES = ['S', 'M', 'L', 'XL'];
+function validateBaseSpec(data, errors) {
+    if (!data || typeof data !== 'object') {
+        errors.push('YAML parsed to null or non-object');
+        return false;
+    }
+    const d = data;
+    requireString(d, 'name', errors);
+    requireString(d, 'oneLiner', errors);
+    requireString(d, 'summary', errors);
+    requireString(d, 'phase', errors);
+    requireString(d, 'content', errors);
+    requireNonEmptyArray(d, 'technologies', errors);
+    if (typeof d.sizeEstimate === 'string' && !VALID_SIZE_ESTIMATES.includes(d.sizeEstimate)) {
+        errors.push(`Field 'sizeEstimate' must be one of ${VALID_SIZE_ESTIMATES.join(', ')}, got '${d.sizeEstimate}'`);
+    }
+    else if (typeof d.sizeEstimate !== 'string') {
+        requireString(d, 'sizeEstimate', errors);
+    }
+    return true;
+}
+export function validateSpecAnalyze(data) {
+    const errors = [];
+    validateBaseSpec(data, errors);
+    return { valid: errors.length === 0, errors };
+}
+export function validateSpecRequirements(data) {
+    const errors = [];
+    if (!validateBaseSpec(data, errors))
+        return { valid: false, errors };
+    const d = data;
+    if (!('openQuestions' in d)) {
+        errors.push("Missing required field 'openQuestions'");
+    }
+    else if (Array.isArray(d.openQuestions)) {
+        for (let i = 0; i < d.openQuestions.length; i++) {
+            const q = d.openQuestions[i];
+            if (!q || typeof q !== 'object') {
+                errors.push(`openQuestions[${i}] must be an object`);
+                continue;
+            }
+            requireString(q, 'question', errors, `openQuestions[${i}].`);
+        }
+    }
+    else {
+        errors.push("Field 'openQuestions' must be an array");
+    }
+    return { valid: errors.length === 0, errors };
+}

package/dist/src/infrastructure/services/agents/feature-agent/nodes/schemas/validation.d.ts

@@ -0,0 +1,8 @@
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+export declare function requireString(data: Record<string, unknown>, field: string, errors: string[], prefix?: string): void;
+export declare function requireNonEmptyArray(data: Record<string, unknown>, field: string, errors: string[], prefix?: string): unknown[] | null;
+export declare function requireArrayOfShape(data: Record<string, unknown>, field: string, errors: string[], itemChecker: (item: unknown, index: number, errors: string[]) => void, prefix?: string): void;
+//# sourceMappingURL=validation.d.ts.map

package/dist/src/infrastructure/services/agents/feature-agent/nodes/schemas/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../../../../../src/infrastructure/services/agents/feature-agent/nodes/schemas/validation.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EAAE,EAChB,MAAM,SAAK,GACV,IAAI,CASN;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EAAE,EAChB,MAAM,SAAK,GACV,OAAO,EAAE,GAAG,IAAI,CAelB;AAED,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EAAE,EAChB,WAAW,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,IAAI,EACrE,MAAM,SAAK,GACV,IAAI,CAMN"}

package/dist/src/infrastructure/services/agents/feature-agent/nodes/schemas/validation.js

@@ -0,0 +1,36 @@
+export function requireString(data, field, errors, prefix = '') {
+    const val = data[field];
+    if (val === undefined || val === null) {
+        errors.push(`Missing required string field '${prefix}${field}'`);
+    }
+    else if (typeof val !== 'string') {
+        errors.push(`Field '${prefix}${field}' must be a string, got ${typeof val}`);
+    }
+    else if (val.trim() === '') {
+        errors.push(`Field '${prefix}${field}' must not be empty`);
+    }
+}
+export function requireNonEmptyArray(data, field, errors, prefix = '') {
+    const val = data[field];
+    if (val === undefined || val === null) {
+        errors.push(`Missing required array field '${prefix}${field}'`);
+        return null;
+    }
+    if (!Array.isArray(val)) {
+        errors.push(`Field '${prefix}${field}' must be an array, got ${typeof val}`);
+        return null;
+    }
+    if (val.length === 0) {
+        errors.push(`Field '${prefix}${field}' must not be empty`);
+        return null;
+    }
+    return val;
+}
+export function requireArrayOfShape(data, field, errors, itemChecker, prefix = '') {
+    const arr = requireNonEmptyArray(data, field, errors, prefix);
+    if (!arr)
+        return;
+    for (let i = 0; i < arr.length; i++) {
+        itemChecker(arr[i], i, errors);
+    }
+}

package/dist/src/infrastructure/services/agents/feature-agent/nodes/validate.node.d.ts

@@ -0,0 +1,12 @@
+import type { FeatureAgentState } from '../state.js';
+import type { ValidationResult } from './schemas/validation.js';
+type SchemaValidator = (data: unknown) => ValidationResult;
+/**
+ * Factory that creates a validate node for a specific YAML file.
+ *
+ * On success: resets validationRetries to 0, clears errors.
+ * On failure: increments validationRetries, sets errors for repair node.
+ */
+export declare function createValidateNode(filename: string, schema: SchemaValidator): (state: FeatureAgentState) => Promise<Partial<FeatureAgentState>>;
+export {};
+//# sourceMappingURL=validate.node.d.ts.map

package/dist/src/infrastructure/services/agents/feature-agent/nodes/validate.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.node.d.ts","sourceRoot":"","sources":["../../../../../../../src/infrastructure/services/agents/feature-agent/nodes/validate.node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAGhE,KAAK,eAAe,GAAG,CAAC,IAAI,EAAE,OAAO,KAAK,gBAAgB,CAAC;AAE3D;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,eAAe,GACtB,CAAC,KAAK,EAAE,iBAAiB,KAAK,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAsDnE"}

package/dist/src/infrastructure/services/agents/feature-agent/nodes/validate.node.js

@@ -0,0 +1,58 @@
+import { readSpecFile, safeYamlLoad, createNodeLogger } from './node-helpers.js';
+/**
+ * Factory that creates a validate node for a specific YAML file.
+ *
+ * On success: resets validationRetries to 0, clears errors.
+ * On failure: increments validationRetries, sets errors for repair node.
+ */
+export function createValidateNode(filename, schema) {
+    const log = createNodeLogger(`validate:${filename}`);
+    return async (state) => {
+        log.info(`Validating ${filename}`);
+        const content = readSpecFile(state.specDir, filename);
+        if (!content) {
+            const errors = [`File '${filename}' not found or empty in ${state.specDir}`];
+            log.error(errors[0]);
+            return {
+                lastValidationTarget: filename,
+                lastValidationErrors: errors,
+                validationRetries: state.validationRetries + 1,
+                messages: [`[validate:${filename}] FAIL: ${errors[0]}`],
+            };
+        }
+        // Try to parse
+        let parsed;
+        try {
+            parsed = safeYamlLoad(content);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            const errors = [`YAML parse error in ${filename}: ${msg}`];
+            log.error(errors[0]);
+            return {
+                lastValidationTarget: filename,
+                lastValidationErrors: errors,
+                validationRetries: state.validationRetries + 1,
+                messages: [`[validate:${filename}] FAIL: parse error`],
+            };
+        }
+        // Run schema validation
+        const result = schema(parsed);
+        if (result.valid) {
+            log.info('Validation passed');
+            return {
+                lastValidationTarget: filename,
+                lastValidationErrors: [],
+                validationRetries: 0,
+                messages: [`[validate:${filename}] PASS`],
+            };
+        }
+        log.error(`Validation failed: ${result.errors.join('; ')}`);
+        return {
+            lastValidationTarget: filename,
+            lastValidationErrors: result.errors,
+            validationRetries: state.validationRetries + 1,
+            messages: [`[validate:${filename}] FAIL: ${result.errors.length} error(s)`],
+        };
+    };
+}

package/dist/src/infrastructure/services/agents/feature-agent/phase-timing-context.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Phase Timing Context
+ *
+ * Module-level singleton that provides phase timing recording
+ * to executeNode() without changing its public API.
+ *
+ * The worker calls setPhaseTimingContext() once after DI init.
+ * Node helpers call recordPhaseStart/End() during graph execution.
+ * Errors are swallowed so timing never blocks graph execution.
+ */
+import type { IPhaseTimingRepository } from '../../../../application/ports/output/agents/phase-timing-repository.interface.js';
+/**
+ * Set the phase timing context. Called once by the worker after DI init.
+ */
+export declare function setPhaseTimingContext(runId: string, repository: IPhaseTimingRepository): void;
+/**
+ * Clear the phase timing context. Useful for testing.
+ */
+export declare function clearPhaseTimingContext(): void;
+/**
+ * Record the start of a phase. Returns the timing record ID (for later update)
+ * or null if context is not set or save fails.
+ */
+export declare function recordPhaseStart(phase: string): Promise<string | null>;
+/**
+ * Record the end of a phase. Updates the timing record with completedAt and durationMs.
+ * No-op if timingId is null (phase start was skipped or failed).
+ */
+export declare function recordPhaseEnd(timingId: string | null, durationMs: number): Promise<void>;
+//# sourceMappingURL=phase-timing-context.d.ts.map

package/dist/src/infrastructure/services/agents/feature-agent/phase-timing-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phase-timing-context.d.ts","sourceRoot":"","sources":["../../../../../../src/infrastructure/services/agents/feature-agent/phase-timing-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wEAAwE,CAAC;AAKrH;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,sBAAsB,GAAG,IAAI,CAG7F;AAED;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,IAAI,CAG9C;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAmB5E;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAW/F"}

package/dist/src/infrastructure/services/agents/feature-agent/phase-timing-context.js

@@ -0,0 +1,68 @@
+/**
+ * Phase Timing Context
+ *
+ * Module-level singleton that provides phase timing recording
+ * to executeNode() without changing its public API.
+ *
+ * The worker calls setPhaseTimingContext() once after DI init.
+ * Node helpers call recordPhaseStart/End() during graph execution.
+ * Errors are swallowed so timing never blocks graph execution.
+ */
+import { randomUUID } from 'node:crypto';
+let contextRunId;
+let contextRepository;
+/**
+ * Set the phase timing context. Called once by the worker after DI init.
+ */
+export function setPhaseTimingContext(runId, repository) {
+    contextRunId = runId;
+    contextRepository = repository;
+}
+/**
+ * Clear the phase timing context. Useful for testing.
+ */
+export function clearPhaseTimingContext() {
+    contextRunId = undefined;
+    contextRepository = undefined;
+}
+/**
+ * Record the start of a phase. Returns the timing record ID (for later update)
+ * or null if context is not set or save fails.
+ */
+export async function recordPhaseStart(phase) {
+    if (!contextRunId || !contextRepository)
+        return null;
+    const id = randomUUID();
+    const now = new Date();
+    try {
+        await contextRepository.save({
+            id,
+            agentRunId: contextRunId,
+            phase,
+            startedAt: now,
+            createdAt: now,
+            updatedAt: now,
+        });
+        return id;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Record the end of a phase. Updates the timing record with completedAt and durationMs.
+ * No-op if timingId is null (phase start was skipped or failed).
+ */
+export async function recordPhaseEnd(timingId, durationMs) {
+    if (!timingId || !contextRepository)
+        return;
+    try {
+        await contextRepository.update(timingId, {
+            completedAt: new Date(),
+            durationMs: BigInt(durationMs),
+        });
+    }
+    catch {
+        // Swallow — timing update failure is non-fatal
+    }
+}

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

@@ -1,3 +1,4 @@
+import type { ApprovalGates } from '../../../../domain/generated/output.js';
 /**
  * State annotation for the feature-agent graph.
  *
@@ -32,8 +33,11 @@ export declare const FeatureAgentAnnotation: import("@langchain/langgraph").Anno
         Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
     };
     error: import("@langchain/langgraph").BinaryOperatorAggregate<string | null, string | null>;
-    approvalMode: import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+    approvalGates: import("@langchain/langgraph").BinaryOperatorAggregate<ApprovalGates | undefined, ApprovalGates | undefined>;
     messages: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    validationRetries: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
+    lastValidationTarget: import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+    lastValidationErrors: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
 }>;
 export type FeatureAgentState = typeof FeatureAgentAnnotation.State;
 //# sourceMappingURL=state.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../../../src/infrastructure/services/agents/feature-agent/state.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBjC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,OAAO,sBAAsB,CAAC,KAAK,CAAC"}
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../../../src/infrastructure/services/agents/feature-agent/state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAElE;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BjC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,OAAO,sBAAsB,CAAC,KAAK,CAAC"}

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

@@ -16,7 +16,7 @@ export const FeatureAgentAnnotation = Annotation.Root({
         reducer: (prev, next) => (next !== undefined ? next : prev),
         default: () => null,
     }),
-    approvalMode: Annotation({
+    approvalGates: Annotation({
         reducer: (prev, next) => next ?? prev,
         default: () => undefined,
     }),
@@ -24,4 +24,17 @@ export const FeatureAgentAnnotation = Annotation.Root({
         reducer: (prev, next) => [...prev, ...next],
         default: () => [],
     }),
+    // --- Validation state channels (for validate/repair loops) ---
+    validationRetries: Annotation({
+        reducer: (_prev, next) => next,
+        default: () => 0,
+    }),
+    lastValidationTarget: Annotation({
+        reducer: (_prev, next) => next,
+        default: () => '',
+    }),
+    lastValidationErrors: Annotation({
+        reducer: (_prev, next) => next,
+        default: () => [],
+    }),
 });

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

@@ -0,0 +1,12 @@
+/**
+ * Feature Approve Command
+ *
+ * Approves a feature waiting for human approval, resuming
+ * the agent to continue with the next phase.
+ *
+ * Usage:
+ *   shep feat approve [id]
+ */
+import { Command } from 'commander';
+export declare function createApproveCommand(): Command;
+//# sourceMappingURL=approve.command.d.ts.map

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

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

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

@@ -0,0 +1,48 @@
+/**
+ * Feature Approve Command
+ *
+ * Approves a feature waiting for human approval, resuming
+ * the agent to continue with the next phase.
+ *
+ * Usage:
+ *   shep feat approve [id]
+ */
+import { Command } from 'commander';
+import { container } from '../../../../infrastructure/di/container.js';
+import { ApproveAgentRunUseCase } from '../../../../application/use-cases/agents/approve-agent-run.use-case.js';
+import { resolveWaitingFeature } from './resolve-waiting-feature.js';
+import { colors, messages } from '../../ui/index.js';
+export function createApproveCommand() {
+    return new Command('approve')
+        .description('Approve a feature waiting for review')
+        .argument('[id]', 'Feature ID (auto-resolves if omitted)')
+        .action(async (featureId) => {
+        try {
+            const featureRepo = container.resolve('IFeatureRepository');
+            const runRepo = container.resolve('IAgentRunRepository');
+            const repoPath = process.cwd();
+            const { feature, run } = await resolveWaitingFeature({
+                featureId,
+                repoPath,
+                featureRepo,
+                runRepo,
+            });
+            const approveUseCase = container.resolve(ApproveAgentRunUseCase);
+            const result = await approveUseCase.execute(run.id);
+            if (!result.approved) {
+                throw new Error(result.reason);
+            }
+            const phase = run.result?.startsWith('node:') ? run.result.slice(5) : 'unknown';
+            messages.newline();
+            messages.success(`Approved: ${feature.name}`);
+            console.log(`  ${colors.muted('Phase:')}    ${colors.success(phase)} approved`);
+            console.log(`  ${colors.muted('Agent:')}    resumed`);
+            messages.newline();
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            messages.error('Failed to approve feature', 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;AAOpC;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAQ3C"}
+{"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;AAUpC;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAW3C"}

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

@@ -15,6 +15,9 @@ import { createLsCommand } from './ls.command.js';
 import { createShowCommand } from './show.command.js';
 import { createDelCommand } from './del.command.js';
 import { createResumeCommand } from './resume.command.js';
+import { createReviewCommand } from './review.command.js';
+import { createApproveCommand } from './approve.command.js';
+import { createRejectCommand } from './reject.command.js';
 /**
  * Create the feat command group
  */
@@ -25,5 +28,8 @@ export function createFeatCommand() {
         .addCommand(createLsCommand())
         .addCommand(createShowCommand())
         .addCommand(createDelCommand())
-        .addCommand(createResumeCommand());
+        .addCommand(createResumeCommand())
+        .addCommand(createReviewCommand())
+        .addCommand(createApproveCommand())
+        .addCommand(createRejectCommand());
 }

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

@@ -1 +1 @@
-{"version":3,"file":"ls.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/ls.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAsGpC,wBAAgB,eAAe,IAAI,OAAO,CAqDzC"}
+{"version":3,"file":"ls.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/ls.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA+GpC,wBAAgB,eAAe,IAAI,OAAO,CAqDzC"}

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

@@ -15,7 +15,7 @@ import { Command } from 'commander';
 import { container } from '../../../../infrastructure/di/container.js';
 import { ListFeaturesUseCase } from '../../../../application/use-cases/features/list-features.use-case.js';
 import { colors, symbols, messages, renderListView } from '../../ui/index.js';
-/** Map graph node names to human-readable phase labels. */
+/** Map graph node names to human-readable phase labels (active). */
 const NODE_TO_PHASE = {
     analyze: 'Analyzing',
     requirements: 'Requirements',
@@ -23,6 +23,14 @@ const NODE_TO_PHASE = {
     plan: 'Planning',
     implement: 'Implementing',
 };
+/** Map graph node names to approval action labels. */
+const NODE_TO_APPROVE = {
+    analyze: 'Approve Analysis',
+    requirements: 'Approve PRD',
+    research: 'Approve Research',
+    plan: 'Approve Plan',
+    implement: 'Approve Merge',
+};
 /**
  * Derive the display status from the agent run.
  * Returns the current graph node as a phase label with an activity indicator.
@@ -33,9 +41,8 @@ function formatStatus(feature, run) {
         return `${colors.muted(symbols.dotEmpty)} ${colors.muted(feature.lifecycle)}`;
     }
     const isRunning = run.status === 'running' || run.status === 'pending';
-    const phase = run.result?.startsWith('node:')
-        ? (NODE_TO_PHASE[run.result.slice(5)] ?? run.result.slice(5))
-        : feature.lifecycle;
+    const nodeName = run.result?.startsWith('node:') ? run.result.slice(5) : undefined;
+    const phase = nodeName ? (NODE_TO_PHASE[nodeName] ?? nodeName) : feature.lifecycle;
     if (isRunning) {
         // Check PID liveness for running agents
         if (run.pid && !isProcessAlive(run.pid)) {
@@ -50,7 +57,8 @@ function formatStatus(feature, run) {
         return `${colors.error(symbols.error)} ${colors.error('Failed')}`;
     }
     if (run.status === 'waiting_approval') {
-        return `${colors.warning(symbols.warning)} ${colors.warning(phase)}`;
+        const action = nodeName ? (NODE_TO_APPROVE[nodeName] ?? phase) : phase;
+        return `${colors.warning(symbols.warning)} ${colors.warning(action)}`;
     }
     if (run.status === 'interrupted') {
         return `${colors.error(symbols.error)} ${colors.error('Interrupted')}`;

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

@@ -1 +1 @@
-{"version":3,"file":"new.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/new.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CA+C1C"}
+{"version":3,"file":"new.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/new.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgBpC;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAiE1C"}

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

@@ -10,9 +10,12 @@
  * $ shep feat new "Add login page" --repo /path/to/project
  */
 import { Command } from 'commander';
+import { createHash } from 'node:crypto';
+import { join } from 'node:path';
 import { container } from '../../../../infrastructure/di/container.js';
 import { CreateFeatureUseCase } from '../../../../application/use-cases/features/create-feature.use-case.js';
 import { colors, messages, spinner } from '../../ui/index.js';
+import { SHEP_HOME_DIR } from '../../../../infrastructure/services/filesystem/shep-directory.service.js';
 /**
  * Create the feat new command
  */
@@ -21,7 +24,6 @@ export function createNewCommand() {
         .description('Create a new feature')
         .argument('<description>', 'Feature description')
         .option('-r, --repo <path>', 'Repository path (defaults to current directory)')
-        .option('--interactive', 'Require approval after every agent step')
         .option('--allow-prd', 'Auto-approve through requirements, pause after')
         .option('--allow-plan', 'Auto-approve through planning, pause at implementation')
         .option('--allow-all', 'Run fully autonomous (no approval pauses)')
@@ -29,29 +31,46 @@ export function createNewCommand() {
         try {
             const useCase = container.resolve(CreateFeatureUseCase);
             const repoPath = options.repo ?? process.cwd();
-            // Determine approval mode from flags (last one wins if multiple specified)
-            let approvalMode;
-            if (options.interactive)
-                approvalMode = 'interactive';
+            // Build approval gates from flags (default: pause after every phase)
+            let approvalGates = { allowPrd: false, allowPlan: false };
             if (options.allowPrd)
-                approvalMode = 'allow-prd';
+                approvalGates = { ...approvalGates, allowPrd: true };
             if (options.allowPlan)
-                approvalMode = 'allow-plan';
+                approvalGates = { allowPrd: true, allowPlan: true };
             if (options.allowAll)
-                approvalMode = 'allow-all';
-            const feature = await spinner('Thinking', () => useCase.execute({
+                approvalGates = undefined; // no gates = fully autonomous
+            const result = await spinner('Thinking', () => useCase.execute({
                 userInput: description,
                 repositoryPath: repoPath,
-                approvalMode,
+                approvalGates,
             }));
+            const { feature, warning } = result;
+            const repoHash = createHash('sha256').update(repoPath).digest('hex').slice(0, 16);
+            const wtSlug = feature.branch.replace(/\//g, '-');
+            const worktreePath = join(SHEP_HOME_DIR, 'repos', repoHash, 'wt', wtSlug);
             messages.newline();
+            if (warning) {
+                messages.warning(warning);
+            }
             messages.success('Feature created');
-            console.log(`  ${colors.muted('ID:')}     ${colors.accent(feature.id)}`);
-            console.log(`  ${colors.muted('Name:')}   ${feature.name}`);
-            console.log(`  ${colors.muted('Branch:')} ${colors.accent(feature.branch)}`);
-            console.log(`  ${colors.muted('Status:')} ${feature.lifecycle}`);
+            console.log(`  ${colors.muted('ID:')}       ${colors.accent(feature.id)}`);
+            console.log(`  ${colors.muted('Name:')}     ${feature.name}`);
+            console.log(`  ${colors.muted('Branch:')}   ${colors.accent(feature.branch)}`);
+            console.log(`  ${colors.muted('Status:')}   ${feature.lifecycle}`);
+            console.log(`  ${colors.muted('Worktree:')} ${worktreePath}`);
+            if (feature.specPath) {
+                console.log(`  ${colors.muted('Spec:')}     ${feature.specPath}`);
+            }
             if (feature.agentRunId) {
-                console.log(`  ${colors.muted('Agent:')}  ${colors.success('spawned')} (run ${feature.agentRunId.slice(0, 8)})`);
+                console.log(`  ${colors.muted('Agent:')}    ${colors.success('spawned')} (run ${feature.agentRunId.slice(0, 8)})`);
+            }
+            if (approvalGates) {
+                const hint = !approvalGates.allowPrd
+                    ? 'pause after every phase'
+                    : !approvalGates.allowPlan
+                        ? 'auto-approve through requirements, pause after'
+                        : 'auto-approve through planning, pause at implementation';
+                console.log(`  ${colors.muted('Review:')}   ${hint}`);
             }
             messages.newline();
         }

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

@@ -0,0 +1,12 @@
+/**
+ * Feature Reject Command
+ *
+ * Rejects a feature waiting for human approval, cancelling
+ * the agent run with an optional reason.
+ *
+ * Usage:
+ *   shep feat reject [id] [--reason <text>]
+ */
+import { Command } from 'commander';
+export declare function createRejectCommand(): Command;
+//# sourceMappingURL=reject.command.d.ts.map

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

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