@shepai/cli 1.14.2 → 1.15.1

package/dist/src/application/use-cases/features/create-feature.use-case.js

@@ -0,0 +1,166 @@
+/**
+ * Create Feature Use Case
+ *
+ * Creates a new feature entity with a git worktree for isolated development,
+ * initializes the spec directory with YAML templates, then spawns the
+ * feature agent to begin autonomous SDLC processing.
+ *
+ * Business Rules:
+ * - AI generates slug/name/description from user's free-text input
+ * - Falls back to regex-based slug if AI fails
+ * - Full user input is preserved as-is in spec.yaml
+ * - Slug must be unique within the repository
+ * - A git worktree is created at ~/.shep/repos/HASH/wt/SLUG/
+ * - Spec YAML files are scaffolded at WORKTREE/specs/NNN-SLUG/
+ * - Feature agent is spawned with the spec dir path
+ * - specPath is persisted on the Feature record
+ * - Initial lifecycle is Requirements
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { injectable, inject } from 'tsyringe';
+import { randomUUID } from 'node:crypto';
+import { SdlcLifecycle } from '../../../domain/generated/output.js';
+import { AgentRunStatus } from '../../../domain/generated/output.js';
+import { getSettings } from '../../../infrastructure/services/settings.service.js';
+/** Maximum characters of user input sent to the AI for metadata generation. */
+const MAX_INPUT_FOR_AI = 500;
+let CreateFeatureUseCase = class CreateFeatureUseCase {
+    featureRepo;
+    worktreeService;
+    agentProcess;
+    runRepository;
+    specInitializer;
+    executorFactory;
+    constructor(featureRepo, worktreeService, agentProcess, runRepository, specInitializer, executorFactory) {
+        this.featureRepo = featureRepo;
+        this.worktreeService = worktreeService;
+        this.agentProcess = agentProcess;
+        this.runRepository = runRepository;
+        this.specInitializer = specInitializer;
+        this.executorFactory = executorFactory;
+    }
+    async execute(input) {
+        const metadata = await this.generateMetadata(input.userInput);
+        const slug = metadata.slug;
+        const branch = `feat/${slug}`;
+        const existing = await this.featureRepo.findBySlug(slug, input.repositoryPath);
+        if (existing) {
+            throw new Error(`Feature with slug "${slug}" already exists in this repository`);
+        }
+        // Determine next feature number for this repo
+        const existingFeatures = await this.featureRepo.list({
+            repositoryPath: input.repositoryPath,
+        });
+        const featureNumber = existingFeatures.length + 1;
+        const now = new Date();
+        const runId = randomUUID();
+        // Create git worktree for isolated development
+        const worktreePath = this.worktreeService.getWorktreePath(input.repositoryPath, branch);
+        await this.worktreeService.create(input.repositoryPath, branch, worktreePath);
+        // Initialize spec directory — full user input goes into spec.yaml as-is
+        const { specDir } = await this.specInitializer.initialize(worktreePath, slug, featureNumber, input.userInput);
+        const feature = {
+            id: randomUUID(),
+            name: metadata.name,
+            slug,
+            description: metadata.description,
+            repositoryPath: input.repositoryPath,
+            branch,
+            lifecycle: SdlcLifecycle.Requirements,
+            messages: [],
+            relatedArtifacts: [],
+            agentRunId: runId,
+            specPath: specDir,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.featureRepo.create(feature);
+        // Create agent run record and spawn background worker
+        const settings = getSettings();
+        const agentRun = {
+            id: runId,
+            agentType: settings.agent.type,
+            agentName: 'feature-agent',
+            status: AgentRunStatus.pending,
+            prompt: input.userInput,
+            threadId: randomUUID(),
+            featureId: feature.id,
+            repositoryPath: input.repositoryPath,
+            ...(input.approvalMode ? { approvalMode: input.approvalMode } : {}),
+            createdAt: now.toISOString(),
+            updatedAt: now.toISOString(),
+        };
+        await this.runRepository.create(agentRun);
+        this.agentProcess.spawn(feature.id, runId, input.repositoryPath, specDir, worktreePath, input.approvalMode ? { approvalMode: input.approvalMode } : undefined);
+        return feature;
+    }
+    async generateMetadata(userInput) {
+        try {
+            const settings = getSettings();
+            const executor = this.executorFactory.createExecutor(settings.agent.type, settings.agent);
+            const truncated = userInput.length > MAX_INPUT_FOR_AI
+                ? `${userInput.slice(0, MAX_INPUT_FOR_AI)}...`
+                : userInput;
+            const prompt = `Generate feature metadata from this user request:
+"${truncated}"
+
+Return ONLY a JSON object with these fields:
+- slug: kebab-case identifier, 2-4 words max (e.g., "github-oauth-login")
+- name: short human-readable title (e.g., "GitHub OAuth Login")
+- description: refined 1-2 sentence description
+
+JSON only, no markdown fences.`;
+            const result = await executor.execute(prompt, {
+                maxTurns: 1,
+                allowedTools: [],
+            });
+            const parsed = JSON.parse(result.result);
+            if (!parsed.slug || !parsed.name || !parsed.description) {
+                throw new Error('Missing required fields in AI response');
+            }
+            return {
+                slug: this.toSlug(parsed.slug),
+                name: parsed.name,
+                description: parsed.description,
+            };
+        }
+        catch {
+            // Fallback to regex-based slug generation
+            return {
+                slug: this.toSlug(userInput),
+                name: userInput,
+                description: userInput,
+            };
+        }
+    }
+    toSlug(text) {
+        return text
+            .toLowerCase()
+            .replace(/[^a-z0-9\s-]/g, '')
+            .replace(/\s+/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-|-$/g, '');
+    }
+};
+CreateFeatureUseCase = __decorate([
+    injectable(),
+    __param(0, inject('IFeatureRepository')),
+    __param(1, inject('IWorktreeService')),
+    __param(2, inject('IFeatureAgentProcessService')),
+    __param(3, inject('IAgentRunRepository')),
+    __param(4, inject('ISpecInitializerService')),
+    __param(5, inject('IAgentExecutorFactory')),
+    __metadata("design:paramtypes", [Object, Object, Object, Object, Object, Object])
+], CreateFeatureUseCase);
+export { CreateFeatureUseCase };

package/dist/src/application/use-cases/features/delete-feature.use-case.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Delete Feature Use Case
+ *
+ * Orchestrates feature deletion including:
+ * - Cancelling any running/pending agent runs
+ * - Removing the git worktree
+ * - Deleting the feature record
+ *
+ * Business Rules:
+ * - Throws if the feature does not exist
+ * - Cancels running/pending agent runs before deletion
+ * - Gracefully handles worktree removal failures
+ */
+import type { Feature } from '../../../domain/generated/output.js';
+import type { IFeatureRepository } from '../../ports/output/repositories/feature-repository.interface.js';
+import type { IWorktreeService } from '../../ports/output/services/worktree-service.interface.js';
+import type { IFeatureAgentProcessService } from '../../ports/output/agents/feature-agent-process.interface.js';
+import type { IAgentRunRepository } from '../../ports/output/agents/agent-run-repository.interface.js';
+export declare class DeleteFeatureUseCase {
+    private readonly featureRepo;
+    private readonly worktreeService;
+    private readonly processService;
+    private readonly runRepo;
+    constructor(featureRepo: IFeatureRepository, worktreeService: IWorktreeService, processService: IFeatureAgentProcessService, runRepo: IAgentRunRepository);
+    execute(featureId: string): Promise<Feature>;
+}
+//# sourceMappingURL=delete-feature.use-case.d.ts.map

package/dist/src/application/use-cases/features/delete-feature.use-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-feature.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/application/use-cases/features/delete-feature.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qCAAqC,CAAC;AAEnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iEAAiE,CAAC;AAC1G,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2DAA2D,CAAC;AAClG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,8DAA8D,CAAC;AAChH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6DAA6D,CAAC;AAEvG,qBACa,oBAAoB;IAEC,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC9B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAE5D,OAAO,CAAC,QAAQ,CAAC,cAAc;IACA,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAJR,WAAW,EAAE,kBAAkB,EACjC,eAAe,EAAE,gBAAgB,EAE7D,cAAc,EAAE,2BAA2B,EACZ,OAAO,EAAE,mBAAmB;IAGxE,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAyCnD"}

package/dist/src/application/use-cases/features/delete-feature.use-case.js

@@ -0,0 +1,83 @@
+/**
+ * Delete Feature Use Case
+ *
+ * Orchestrates feature deletion including:
+ * - Cancelling any running/pending agent runs
+ * - Removing the git worktree
+ * - Deleting the feature record
+ *
+ * Business Rules:
+ * - Throws if the feature does not exist
+ * - Cancels running/pending agent runs before deletion
+ * - Gracefully handles worktree removal failures
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { injectable, inject } from 'tsyringe';
+import { AgentRunStatus } from '../../../domain/generated/output.js';
+let DeleteFeatureUseCase = class DeleteFeatureUseCase {
+    featureRepo;
+    worktreeService;
+    processService;
+    runRepo;
+    constructor(featureRepo, worktreeService, processService, runRepo) {
+        this.featureRepo = featureRepo;
+        this.worktreeService = worktreeService;
+        this.processService = processService;
+        this.runRepo = runRepo;
+    }
+    async execute(featureId) {
+        // 1. Find feature (exact or prefix match)
+        const feature = (await this.featureRepo.findById(featureId)) ??
+            (await this.featureRepo.findByIdPrefix(featureId));
+        if (!feature) {
+            throw new Error(`Feature not found: "${featureId}"`);
+        }
+        // 2. Cancel running/pending agent run if present
+        if (feature.agentRunId) {
+            const run = await this.runRepo.findById(feature.agentRunId);
+            if (run && (run.status === AgentRunStatus.running || run.status === AgentRunStatus.pending)) {
+                // Kill the OS process if still alive
+                if (run.pid && this.processService.isAlive(run.pid)) {
+                    try {
+                        process.kill(run.pid);
+                    }
+                    catch {
+                        // Process may have already exited
+                    }
+                }
+                await this.runRepo.updateStatus(run.id, AgentRunStatus.cancelled);
+            }
+        }
+        // 3. Remove worktree (ignore errors if already removed)
+        const worktreePath = this.worktreeService.getWorktreePath(feature.repositoryPath, feature.branch);
+        try {
+            await this.worktreeService.remove(worktreePath);
+        }
+        catch {
+            // Worktree might already be removed - that's fine
+        }
+        // 4. Delete feature record
+        await this.featureRepo.delete(feature.id);
+        return feature;
+    }
+};
+DeleteFeatureUseCase = __decorate([
+    injectable(),
+    __param(0, inject('IFeatureRepository')),
+    __param(1, inject('IWorktreeService')),
+    __param(2, inject('IFeatureAgentProcessService')),
+    __param(3, inject('IAgentRunRepository')),
+    __metadata("design:paramtypes", [Object, Object, Object, Object])
+], DeleteFeatureUseCase);
+export { DeleteFeatureUseCase };

package/dist/src/application/use-cases/features/list-features.use-case.d.ts

@@ -0,0 +1,17 @@
+/**
+ * List Features Use Case
+ *
+ * Retrieves features with optional filtering by repository path or lifecycle.
+ *
+ * Business Rules:
+ * - Returns all features when no filters are provided
+ * - Filters are passed through to the repository
+ */
+import type { Feature } from '../../../domain/generated/output.js';
+import type { IFeatureRepository, FeatureListFilters } from '../../ports/output/repositories/feature-repository.interface.js';
+export declare class ListFeaturesUseCase {
+    private readonly featureRepo;
+    constructor(featureRepo: IFeatureRepository);
+    execute(filters?: FeatureListFilters): Promise<Feature[]>;
+}
+//# sourceMappingURL=list-features.use-case.d.ts.map

package/dist/src/application/use-cases/features/list-features.use-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-features.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/application/use-cases/features/list-features.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qCAAqC,CAAC;AACnE,OAAO,KAAK,EACV,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,iEAAiE,CAAC;AAEzE,qBACa,mBAAmB;IAG5B,OAAO,CAAC,QAAQ,CAAC,WAAW;gBAAX,WAAW,EAAE,kBAAkB;IAG5C,OAAO,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;CAGhE"}

package/dist/src/application/use-cases/features/list-features.use-case.js

@@ -0,0 +1,37 @@
+/**
+ * List Features Use Case
+ *
+ * Retrieves features with optional filtering by repository path or lifecycle.
+ *
+ * Business Rules:
+ * - Returns all features when no filters are provided
+ * - Filters are passed through to the repository
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { injectable, inject } from 'tsyringe';
+let ListFeaturesUseCase = class ListFeaturesUseCase {
+    featureRepo;
+    constructor(featureRepo) {
+        this.featureRepo = featureRepo;
+    }
+    async execute(filters) {
+        return this.featureRepo.list(filters);
+    }
+};
+ListFeaturesUseCase = __decorate([
+    injectable(),
+    __param(0, inject('IFeatureRepository')),
+    __metadata("design:paramtypes", [Object])
+], ListFeaturesUseCase);
+export { ListFeaturesUseCase };

package/dist/src/application/use-cases/features/resume-feature.use-case.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Resume Feature Use Case
+ *
+ * Resumes an interrupted, failed, or waiting_approval feature agent run.
+ * Creates a new AgentRun record and spawns a worker with --resume flag.
+ */
+import type { Feature, AgentRun } from '../../../domain/generated/output.js';
+import type { IFeatureRepository } from '../../ports/output/repositories/feature-repository.interface.js';
+import type { IAgentRunRepository } from '../../ports/output/agents/agent-run-repository.interface.js';
+import type { IFeatureAgentProcessService } from '../../ports/output/agents/feature-agent-process.interface.js';
+import type { IWorktreeService } from '../../ports/output/services/worktree-service.interface.js';
+export interface ResumeFeatureResult {
+    feature: Feature;
+    newRun: AgentRun;
+}
+export declare class ResumeFeatureUseCase {
+    private readonly featureRepo;
+    private readonly runRepo;
+    private readonly processService;
+    private readonly worktreeService;
+    constructor(featureRepo: IFeatureRepository, runRepo: IAgentRunRepository, processService: IFeatureAgentProcessService, worktreeService: IWorktreeService);
+    execute(featureId: string): Promise<ResumeFeatureResult>;
+}
+//# sourceMappingURL=resume-feature.use-case.d.ts.map

package/dist/src/application/use-cases/features/resume-feature.use-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resume-feature.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/application/use-cases/features/resume-feature.use-case.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AAE7E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iEAAiE,CAAC;AAC1G,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6DAA6D,CAAC;AACvG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,8DAA8D,CAAC;AAChH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2DAA2D,CAAC;AAQlG,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,QAAQ,CAAC;CAClB;AAED,qBACa,oBAAoB;IAG7B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAE5B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAExB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAE/B,OAAO,CAAC,QAAQ,CAAC,eAAe;gBANf,WAAW,EAAE,kBAAkB,EAE/B,OAAO,EAAE,mBAAmB,EAE5B,cAAc,EAAE,2BAA2B,EAE3C,eAAe,EAAE,gBAAgB;IAG9C,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;CAwE/D"}

package/dist/src/application/use-cases/features/resume-feature.use-case.js

@@ -0,0 +1,100 @@
+/**
+ * Resume Feature Use Case
+ *
+ * Resumes an interrupted, failed, or waiting_approval feature agent run.
+ * Creates a new AgentRun record and spawns a worker with --resume flag.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { injectable, inject } from 'tsyringe';
+import { randomUUID } from 'node:crypto';
+import { AgentRunStatus } from '../../../domain/generated/output.js';
+const RESUMABLE_STATUSES = new Set([
+    AgentRunStatus.interrupted,
+    AgentRunStatus.failed,
+    AgentRunStatus.waitingApproval,
+]);
+let ResumeFeatureUseCase = class ResumeFeatureUseCase {
+    featureRepo;
+    runRepo;
+    processService;
+    worktreeService;
+    constructor(featureRepo, runRepo, processService, worktreeService) {
+        this.featureRepo = featureRepo;
+        this.runRepo = runRepo;
+        this.processService = processService;
+        this.worktreeService = worktreeService;
+    }
+    async execute(featureId) {
+        // Resolve feature by exact ID or prefix
+        const feature = (await this.featureRepo.findById(featureId)) ??
+            (await this.featureRepo.findByIdPrefix(featureId));
+        if (!feature) {
+            throw new Error(`Feature not found: ${featureId}`);
+        }
+        // Load the most recent agent run
+        if (!feature.agentRunId) {
+            throw new Error(`No agent run found for feature "${feature.name}"`);
+        }
+        const lastRun = await this.runRepo.findById(feature.agentRunId);
+        if (!lastRun) {
+            throw new Error(`No agent run found for feature "${feature.name}"`);
+        }
+        // Validate the run is in a resumable state
+        if (lastRun.status === AgentRunStatus.running) {
+            throw new Error('Agent is still running — stop it first before resuming');
+        }
+        if (lastRun.status === AgentRunStatus.completed) {
+            throw new Error('Agent already completed successfully');
+        }
+        if (!RESUMABLE_STATUSES.has(lastRun.status)) {
+            throw new Error(`Agent run is not in a resumable state (status: ${lastRun.status})`);
+        }
+        // Create a new agent run record that continues the same thread
+        const now = new Date();
+        const newRunId = randomUUID();
+        const newRun = {
+            id: newRunId,
+            agentType: lastRun.agentType,
+            agentName: lastRun.agentName,
+            status: AgentRunStatus.pending,
+            prompt: lastRun.prompt,
+            threadId: lastRun.threadId, // Same thread for checkpoint continuity
+            featureId: feature.id,
+            repositoryPath: feature.repositoryPath,
+            approvalMode: lastRun.approvalMode,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.runRepo.create(newRun);
+        // Update feature to reference the new run
+        await this.featureRepo.update({
+            ...feature,
+            agentRunId: newRunId,
+            updatedAt: now,
+        });
+        // Derive worktree path and spawn resume worker
+        const worktreePath = this.worktreeService.getWorktreePath(feature.repositoryPath, feature.branch);
+        this.processService.spawn(feature.id, newRunId, feature.repositoryPath, worktreePath, worktreePath, { resume: true, approvalMode: lastRun.approvalMode });
+        return { feature, newRun };
+    }
+};
+ResumeFeatureUseCase = __decorate([
+    injectable(),
+    __param(0, inject('IFeatureRepository')),
+    __param(1, inject('IAgentRunRepository')),
+    __param(2, inject('IFeatureAgentProcessService')),
+    __param(3, inject('IWorktreeService')),
+    __metadata("design:paramtypes", [Object, Object, Object, Object])
+], ResumeFeatureUseCase);
+export { ResumeFeatureUseCase };

package/dist/src/application/use-cases/features/show-feature.use-case.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Show Feature Use Case
+ *
+ * Retrieves a single feature by its ID.
+ *
+ * Business Rules:
+ * - Throws if the feature does not exist
+ * - Error message includes the requested ID for debugging
+ */
+import type { Feature } from '../../../domain/generated/output.js';
+import type { IFeatureRepository } from '../../ports/output/repositories/feature-repository.interface.js';
+export declare class ShowFeatureUseCase {
+    private readonly featureRepo;
+    constructor(featureRepo: IFeatureRepository);
+    execute(featureId: string): Promise<Feature>;
+}
+//# sourceMappingURL=show-feature.use-case.d.ts.map

package/dist/src/application/use-cases/features/show-feature.use-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"show-feature.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/application/use-cases/features/show-feature.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qCAAqC,CAAC;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iEAAiE,CAAC;AAE1G,qBACa,kBAAkB;IAG3B,OAAO,CAAC,QAAQ,CAAC,WAAW;gBAAX,WAAW,EAAE,kBAAkB;IAG5C,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAUnD"}

package/dist/src/application/use-cases/features/show-feature.use-case.js

@@ -0,0 +1,43 @@
+/**
+ * Show Feature Use Case
+ *
+ * Retrieves a single feature by its ID.
+ *
+ * Business Rules:
+ * - Throws if the feature does not exist
+ * - Error message includes the requested ID for debugging
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { injectable, inject } from 'tsyringe';
+let ShowFeatureUseCase = class ShowFeatureUseCase {
+    featureRepo;
+    constructor(featureRepo) {
+        this.featureRepo = featureRepo;
+    }
+    async execute(featureId) {
+        // Try exact match first, then prefix match for short IDs (e.g. from `feat ls`)
+        const feature = (await this.featureRepo.findById(featureId)) ??
+            (await this.featureRepo.findByIdPrefix(featureId));
+        if (!feature) {
+            throw new Error(`Feature not found: "${featureId}"`);
+        }
+        return feature;
+    }
+};
+ShowFeatureUseCase = __decorate([
+    injectable(),
+    __param(0, inject('IFeatureRepository')),
+    __metadata("design:paramtypes", [Object])
+], ShowFeatureUseCase);
+export { ShowFeatureUseCase };

package/dist/src/application/use-cases/settings/initialize-settings.use-case.d.ts

@@ -10,7 +10,7 @@
  * - Idempotent: safe to call multiple times
  */
 import type { Settings } from '../../../domain/generated/output.js';
-import type { ISettingsRepository } from '../../ports/output/settings.repository.interface.js';
+import type { ISettingsRepository } from '../../ports/output/repositories/settings.repository.interface.js';
 /**
  * Use case for initializing global settings.
  *

package/dist/src/application/use-cases/settings/initialize-settings.use-case.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initialize-settings.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/application/use-cases/settings/initialize-settings.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AACpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qDAAqD,CAAC;AAG/F;;;;;;;;GAQG;AACH,qBACa,yBAAyB;IAGlC,OAAO,CAAC,QAAQ,CAAC,kBAAkB;gBAAlB,kBAAkB,EAAE,mBAAmB;IAG1D;;;;OAIG;IACG,OAAO,IAAI,OAAO,CAAC,QAAQ,CAAC;CAgBnC"}
+{"version":3,"file":"initialize-settings.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/application/use-cases/settings/initialize-settings.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AACpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kEAAkE,CAAC;AAG5G;;;;;;;;GAQG;AACH,qBACa,yBAAyB;IAGlC,OAAO,CAAC,QAAQ,CAAC,kBAAkB;gBAAlB,kBAAkB,EAAE,mBAAmB;IAG1D;;;;OAIG;IACG,OAAO,IAAI,OAAO,CAAC,QAAQ,CAAC;CAgBnC"}

package/dist/src/application/use-cases/settings/load-settings.use-case.d.ts

@@ -10,7 +10,7 @@
  * - Read-only operation (no mutations)
  */
 import type { Settings } from '../../../domain/generated/output.js';
-import type { ISettingsRepository } from '../../ports/output/settings.repository.interface.js';
+import type { ISettingsRepository } from '../../ports/output/repositories/settings.repository.interface.js';
 /**
  * Use case for loading existing settings.
  *

package/dist/src/application/use-cases/settings/load-settings.use-case.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load-settings.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/application/use-cases/settings/load-settings.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AACpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qDAAqD,CAAC;AAE/F;;;;;;;GAOG;AACH,qBACa,mBAAmB;IAG5B,OAAO,CAAC,QAAQ,CAAC,kBAAkB;gBAAlB,kBAAkB,EAAE,mBAAmB;IAG1D;;;;;OAKG;IACG,OAAO,IAAI,OAAO,CAAC,QAAQ,CAAC;CASnC"}
+{"version":3,"file":"load-settings.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/application/use-cases/settings/load-settings.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AACpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kEAAkE,CAAC;AAE5G;;;;;;;GAOG;AACH,qBACa,mBAAmB;IAG5B,OAAO,CAAC,QAAQ,CAAC,kBAAkB;gBAAlB,kBAAkB,EAAE,mBAAmB;IAG1D;;;;;OAKG;IACG,OAAO,IAAI,OAAO,CAAC,QAAQ,CAAC;CASnC"}

package/dist/src/application/use-cases/settings/update-settings.use-case.d.ts

@@ -10,7 +10,7 @@
  * - Returns updated settings after persistence
  */
 import type { Settings } from '../../../domain/generated/output.js';
-import type { ISettingsRepository } from '../../ports/output/settings.repository.interface.js';
+import type { ISettingsRepository } from '../../ports/output/repositories/settings.repository.interface.js';
 /**
  * Use case for updating existing settings.
  *

package/dist/src/application/use-cases/settings/update-settings.use-case.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update-settings.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/application/use-cases/settings/update-settings.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AACpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qDAAqD,CAAC;AAE/F;;;;;;;GAOG;AACH,qBACa,qBAAqB;IAG9B,OAAO,CAAC,QAAQ,CAAC,kBAAkB;gBAAlB,kBAAkB,EAAE,mBAAmB;IAG1D;;;;;OAKG;IACG,OAAO,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;CAOrD"}
+{"version":3,"file":"update-settings.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/application/use-cases/settings/update-settings.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AACpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kEAAkE,CAAC;AAE5G;;;;;;;GAOG;AACH,qBACa,qBAAqB;IAG9B,OAAO,CAAC,QAAQ,CAAC,kBAAkB;gBAAlB,kBAAkB,EAAE,mBAAmB;IAG1D;;;;;OAKG;IACG,OAAO,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;CAOrD"}

package/dist/src/domain/generated/output.d.ts

@@ -525,6 +525,14 @@ export type Feature = BaseEntity & {
      * Generated documents and artifacts attached to this feature
      */
     relatedArtifacts: Artifact[];
+    /**
+     * Associated agent run ID for process tracking (optional)
+     */
+    agentRunId?: string;
+    /**
+     * Absolute path to the feature spec directory inside the worktree
+     */
+    specPath?: string;
 };
 /**
  * Open question that may need resolution before implementation
@@ -945,7 +953,8 @@ export declare enum AgentRunStatus {
     completed = "completed",
     failed = "failed",
     interrupted = "interrupted",
-    cancelled = "cancelled"
+    cancelled = "cancelled",
+    waitingApproval = "waiting_approval"
 }
 /**
  * Agent execution run record
@@ -999,6 +1008,22 @@ export type AgentRun = BaseEntity & {
      * Error message if execution failed (optional)
      */
     error?: string;
+    /**
+     * Associated feature ID for feature agent runs (optional)
+     */
+    featureId?: string;
+    /**
+     * Repository path for context scoping (optional)
+     */
+    repositoryPath?: string;
+    /**
+     * Approval mode for human-in-the-loop: interactive, allow-prd, allow-plan, allow-all (optional)
+     */
+    approvalMode?: string;
+    /**
+     * Current approval status: pending, waiting, approved, rejected (optional)
+     */
+    approvalStatus?: string;
 };
 /**
  * Streaming event emitted during agent execution