@shepai/cli 1.19.0 → 1.20.1

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 { CreateFeatureUseCase } from '../../../../application/use-cases/features/create/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"}

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

@@ -0,0 +1,50 @@
+/**
+ * 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';
+import { container } from '../../../../infrastructure/di/container.js';
+import { RejectAgentRunUseCase } from '../../../../application/use-cases/agents/reject-agent-run.use-case.js';
+import { resolveWaitingFeature } from './resolve-waiting-feature.js';
+import { colors, messages } from '../../ui/index.js';
+export function createRejectCommand() {
+    return new Command('reject')
+        .description('Reject a feature waiting for review')
+        .argument('[id]', 'Feature ID (auto-resolves if omitted)')
+        .option('--reason <text>', 'Rejection reason')
+        .action(async (featureId, options) => {
+        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 rejectUseCase = container.resolve(RejectAgentRunUseCase);
+            const result = await rejectUseCase.execute(run.id, options.reason);
+            if (!result.rejected) {
+                throw new Error(result.reason);
+            }
+            messages.newline();
+            messages.warning(`Rejected: ${feature.name}`);
+            if (options.reason) {
+                console.log(`  ${colors.muted('Reason:')} ${options.reason}`);
+            }
+            console.log(`  ${colors.muted('Agent:')}  cancelled`);
+            messages.newline();
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            messages.error('Failed to reject feature', err);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/src/presentation/cli/commands/feat/resolve-waiting-feature.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Resolve Waiting Feature Helper
+ *
+ * Shared helper for feat review/approve/reject commands.
+ * Given an optional feature ID and repo path, resolves the target
+ * feature that is currently waiting for human approval.
+ */
+import type { Feature, AgentRun } from '../../../../domain/generated/output.js';
+import type { IFeatureRepository } from '../../../../application/ports/output/repositories/feature-repository.interface.js';
+import type { IAgentRunRepository } from '../../../../application/ports/output/agents/agent-run-repository.interface.js';
+export interface ResolveWaitingFeatureOptions {
+    featureId?: string;
+    repoPath: string;
+    featureRepo: IFeatureRepository;
+    runRepo: IAgentRunRepository;
+}
+export interface ResolvedWaitingFeature {
+    feature: Feature;
+    run: AgentRun;
+}
+/**
+ * Resolve the target feature waiting for approval.
+ *
+ * If featureId is provided, looks it up directly.
+ * Otherwise, lists features for the repo and finds the single waiting one.
+ *
+ * @throws When feature not found, not waiting, or ambiguous (0 or 2+)
+ */
+export declare function resolveWaitingFeature(options: ResolveWaitingFeatureOptions): Promise<ResolvedWaitingFeature>;
+//# sourceMappingURL=resolve-waiting-feature.d.ts.map

package/dist/src/presentation/cli/commands/feat/resolve-waiting-feature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-waiting-feature.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/resolve-waiting-feature.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,wCAAwC,CAAC;AAEhF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mFAAmF,CAAC;AAC5H,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+EAA+E,CAAC;AAEzH,MAAM,WAAW,4BAA4B;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,kBAAkB,CAAC;IAChC,OAAO,EAAE,mBAAmB,CAAC;CAC9B;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,EAAE,QAAQ,CAAC;CACf;AAED;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,sBAAsB,CAAC,CAOjC"}

package/dist/src/presentation/cli/commands/feat/resolve-waiting-feature.js

@@ -0,0 +1,57 @@
+/**
+ * Resolve Waiting Feature Helper
+ *
+ * Shared helper for feat review/approve/reject commands.
+ * Given an optional feature ID and repo path, resolves the target
+ * feature that is currently waiting for human approval.
+ */
+import { AgentRunStatus } from '../../../../domain/generated/output.js';
+/**
+ * Resolve the target feature waiting for approval.
+ *
+ * If featureId is provided, looks it up directly.
+ * Otherwise, lists features for the repo and finds the single waiting one.
+ *
+ * @throws When feature not found, not waiting, or ambiguous (0 or 2+)
+ */
+export async function resolveWaitingFeature(options) {
+    const { featureId, repoPath, featureRepo, runRepo } = options;
+    if (featureId) {
+        return resolveExplicit(featureId, featureRepo, runRepo);
+    }
+    return resolveAuto(repoPath, featureRepo, runRepo);
+}
+async function resolveExplicit(featureId, featureRepo, runRepo) {
+    const feature = (await featureRepo.findById(featureId)) ?? (await featureRepo.findByIdPrefix(featureId));
+    if (!feature) {
+        throw new Error(`Feature not found: "${featureId}"`);
+    }
+    if (!feature.agentRunId) {
+        throw new Error(`Feature "${feature.name}" has no agent run`);
+    }
+    const run = await runRepo.findById(feature.agentRunId);
+    if (!run || run.status !== AgentRunStatus.waitingApproval) {
+        throw new Error(`Feature "${feature.name}" is not waiting for approval (status: ${run?.status ?? 'unknown'})`);
+    }
+    return { feature, run };
+}
+async function resolveAuto(repoPath, featureRepo, runRepo) {
+    const features = await featureRepo.list({ repositoryPath: repoPath });
+    const waiting = [];
+    for (const feature of features) {
+        if (!feature.agentRunId)
+            continue;
+        const run = await runRepo.findById(feature.agentRunId);
+        if (run && run.status === AgentRunStatus.waitingApproval) {
+            waiting.push({ feature, run });
+        }
+    }
+    if (waiting.length === 0) {
+        throw new Error('No features waiting for approval in this repository');
+    }
+    if (waiting.length > 1) {
+        const names = waiting.map((w) => `  - ${w.feature.name} (${w.feature.id.slice(0, 8)})`);
+        throw new Error(`Multiple features waiting for approval. Specify one:\n${names.join('\n')}`);
+    }
+    return waiting[0];
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Feature Review Command
+ *
+ * Shows the current state of a feature waiting for approval,
+ * including which phase triggered the interrupt and generated content.
+ *
+ * Usage:
+ *   shep feat review [id]
+ */
+import { Command } from 'commander';
+export declare function createReviewCommand(): Command;
+//# sourceMappingURL=review.command.d.ts.map

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

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

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

@@ -0,0 +1,49 @@
+/**
+ * Feature Review Command
+ *
+ * Shows the current state of a feature waiting for approval,
+ * including which phase triggered the interrupt and generated content.
+ *
+ * Usage:
+ *   shep feat review [id]
+ */
+import { Command } from 'commander';
+import { container } from '../../../../infrastructure/di/container.js';
+import { resolveWaitingFeature } from './resolve-waiting-feature.js';
+import { colors, messages } from '../../ui/index.js';
+export function createReviewCommand() {
+    return new Command('review')
+        .description('Review a feature waiting for approval')
+        .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 phase = run.result?.startsWith('node:') ? run.result.slice(5) : 'unknown';
+            messages.newline();
+            messages.info(`Feature waiting for approval: ${colors.accent(feature.name)}`);
+            console.log(`  ${colors.muted('ID:')}     ${feature.id.slice(0, 8)}`);
+            console.log(`  ${colors.muted('Phase:')}  ${colors.warning(phase)}`);
+            console.log(`  ${colors.muted('Branch:')} ${colors.accent(feature.branch)}`);
+            if (feature.specPath) {
+                console.log(`  ${colors.muted('Specs:')}  ${feature.specPath}`);
+            }
+            messages.newline();
+            console.log(`  ${colors.muted('To approve:')} shep feat approve ${feature.id.slice(0, 8)}`);
+            console.log(`  ${colors.muted('To reject:')}  shep feat reject ${feature.id.slice(0, 8)}`);
+            messages.newline();
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            messages.error('Failed to review feature', err);
+            process.exitCode = 1;
+        }
+    });
+}

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

@@ -1 +1 @@
-{"version":3,"file":"show.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/show.command.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA4DpC,wBAAgB,iBAAiB,IAAI,OAAO,CAyE3C"}
+{"version":3,"file":"show.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/show.command.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAuEpC,wBAAgB,iBAAiB,IAAI,OAAO,CAkH3C"}