@shepai/cli 1.136.0-pr417.01aebe9 → 1.136.0-pr438.9e52ee5

package/dist/packages/core/src/application/use-cases/doctor/doctor-diagnose.use-case.js

@@ -0,0 +1,294 @@
+/**
+ * Doctor Diagnose Use Case
+ *
+ * Orchestrates the shep doctor workflow:
+ * 1. Collect diagnostic context (failed agent runs, version, system info)
+ * 2. Create a structured GitHub issue on shep-ai/cli
+ * 3. Optionally attempt a fix via AI agent
+ * 4. Open a PR with the fix (direct push for maintainers, fork for contributors)
+ *
+ * Following Clean Architecture: all external operations are injected via interfaces.
+ */
+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 { tmpdir } from 'node:os';
+import { mkdir, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { AgentRunStatus } from '../../../domain/generated/output.js';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const SHEP_REPO = 'shep-ai/cli';
+const MAX_FAILED_RUNS = 10;
+const ISSUE_LABELS = ['bug', 'shep-doctor'];
+// ---------------------------------------------------------------------------
+// Use Case
+// ---------------------------------------------------------------------------
+let DoctorDiagnoseUseCase = class DoctorDiagnoseUseCase {
+    agentRunRepo;
+    versionService;
+    issueService;
+    repoService;
+    prService;
+    agentExecutorProvider;
+    execFile;
+    featureRepo;
+    constructor(agentRunRepo, versionService, issueService, repoService, prService, agentExecutorProvider, execFile, featureRepo) {
+        this.agentRunRepo = agentRunRepo;
+        this.versionService = versionService;
+        this.issueService = issueService;
+        this.repoService = repoService;
+        this.prService = prService;
+        this.agentExecutorProvider = agentExecutorProvider;
+        this.execFile = execFile;
+        this.featureRepo = featureRepo;
+    }
+    async execute(input) {
+        // Step 1: Collect diagnostics
+        const diagnosticReport = await this.collectDiagnostics(input.description, input.featureId);
+        // Step 2: Create GitHub issue
+        const issueTitle = this.formatIssueTitle(input.description);
+        const issueBody = this.formatIssueBody(diagnosticReport);
+        const { url: issueUrl, number: issueNumber } = await this.issueService.createIssue(SHEP_REPO, issueTitle, issueBody, ISSUE_LABELS);
+        // Step 3: If no fix requested, return early
+        if (!input.fix) {
+            return {
+                diagnosticReport,
+                issueUrl,
+                issueNumber,
+                cleanedUp: false,
+            };
+        }
+        // Step 4: Attempt fix
+        return this.attemptFix(input, diagnosticReport, issueUrl, issueNumber);
+    }
+    // -------------------------------------------------------------------------
+    // Diagnostic Collection (Task 10)
+    // -------------------------------------------------------------------------
+    async collectDiagnostics(userDescription, featureId) {
+        // Resolve feature context if featureId is provided
+        let resolvedFeatureId;
+        let featureName;
+        if (featureId) {
+            const feature = (await this.featureRepo.findById(featureId)) ??
+                (await this.featureRepo.findByIdPrefix(featureId));
+            if (feature) {
+                resolvedFeatureId = feature.id;
+                featureName = feature.name;
+            }
+        }
+        const [failedRunSummaries, systemInfo, cliVersion] = await Promise.all([
+            this.collectFailedRuns(resolvedFeatureId),
+            this.collectSystemInfo(),
+            Promise.resolve(this.versionService.getVersion().version),
+        ]);
+        return {
+            userDescription,
+            failedRunSummaries,
+            systemInfo,
+            cliVersion,
+            featureId: resolvedFeatureId,
+            featureName,
+        };
+    }
+    async collectFailedRuns(featureId) {
+        const allRuns = await this.agentRunRepo.list();
+        let filtered = allRuns.filter((run) => run.status === AgentRunStatus.failed);
+        // When a feature ID is provided, scope to runs associated with that feature
+        if (featureId) {
+            filtered = filtered.filter((run) => run.featureId === featureId);
+        }
+        return filtered.slice(0, MAX_FAILED_RUNS).map((run) => this.sanitizeRunSummary(run));
+    }
+    sanitizeRunSummary(run) {
+        return {
+            agentType: run.agentType,
+            agentName: run.agentName,
+            error: run.error ?? 'Unknown error',
+            timestamp: run.createdAt instanceof Date ? run.createdAt.toISOString() : String(run.createdAt),
+        };
+    }
+    async collectSystemInfo() {
+        let ghVersion = 'unknown';
+        try {
+            const { stdout } = await this.execFile('gh', ['--version']);
+            ghVersion = stdout.trim();
+        }
+        catch {
+            // gh not installed or not available — use fallback
+        }
+        return {
+            nodeVersion: process.version,
+            platform: process.platform,
+            arch: process.arch,
+            ghVersion,
+        };
+    }
+    // -------------------------------------------------------------------------
+    // Issue Formatting (Task 11)
+    // -------------------------------------------------------------------------
+    formatIssueTitle(description) {
+        const firstLine = description.split('\n')[0].trim();
+        const truncated = firstLine.length > 60 ? `${firstLine.slice(0, 60)}...` : firstLine;
+        return `[shep doctor] ${truncated}`;
+    }
+    formatIssueBody(report) {
+        const sections = [];
+        sections.push('## Problem Description\n');
+        sections.push(report.userDescription);
+        if (report.featureId) {
+            sections.push('\n## Feature Context\n');
+            sections.push(`- **Feature ID:** ${report.featureId}`);
+            if (report.featureName) {
+                sections.push(`- **Feature Name:** ${report.featureName}`);
+            }
+        }
+        sections.push('\n## Environment\n');
+        sections.push(`- **shep CLI version:** ${report.cliVersion}`);
+        sections.push(`- **Node.js:** ${report.systemInfo.nodeVersion}`);
+        sections.push(`- **Platform:** ${report.systemInfo.platform} (${report.systemInfo.arch})`);
+        sections.push(`- **gh CLI:** ${report.systemInfo.ghVersion}`);
+        if (report.failedRunSummaries.length > 0) {
+            const heading = report.featureId
+                ? '\n## Failed Agent Runs (feature-scoped)\n'
+                : '\n## Recent Failed Agent Runs\n';
+            sections.push(heading);
+            for (const run of report.failedRunSummaries) {
+                sections.push(`### ${run.agentName} (${run.agentType})`);
+                sections.push(`- **Error:** ${run.error}`);
+                sections.push(`- **Timestamp:** ${run.timestamp}`);
+                sections.push('');
+            }
+        }
+        sections.push('\n---\n');
+        sections.push('_Reported via `shep doctor`_');
+        return sections.join('\n');
+    }
+    // -------------------------------------------------------------------------
+    // Fix Workflow (Task 11)
+    // -------------------------------------------------------------------------
+    async attemptFix(input, diagnosticReport, issueUrl, issueNumber) {
+        const isUserWorkdir = !!input.workdir;
+        const workdir = input.workdir ?? path.join(tmpdir(), `shep-doctor-${randomUUID()}`);
+        // Use a mutable result object so finally block can update cleanedUp
+        const result = {
+            diagnosticReport,
+            issueUrl,
+            issueNumber,
+            cleanedUp: false,
+        };
+        try {
+            // Ensure working directory exists
+            await mkdir(workdir, { recursive: true });
+            // Check push access (fall back to contributor flow on error)
+            let hasPushAccess = false;
+            try {
+                hasPushAccess = await this.repoService.checkPushAccess(SHEP_REPO);
+            }
+            catch {
+                // NFR-9: fall back to fork path on any detection failure
+            }
+            const flowType = hasPushAccess ? 'maintainer' : 'contributor';
+            result.flowType = flowType;
+            // Clone repository (direct or via fork)
+            let repoToClone = SHEP_REPO;
+            if (flowType === 'contributor') {
+                const { nameWithOwner } = await this.repoService.forkRepository(SHEP_REPO);
+                repoToClone = nameWithOwner;
+            }
+            await this.repoService.cloneRepository(repoToClone, workdir, undefined);
+            // Create fix branch
+            const branchName = `doctor/fix-${issueNumber}`;
+            await this.execFile('git', ['checkout', '-b', branchName], {
+                cwd: workdir,
+            });
+            // Invoke AI agent
+            try {
+                const executor = await this.agentExecutorProvider.getExecutor();
+                const prompt = this.buildFixPrompt(diagnosticReport, issueNumber);
+                await executor.execute(prompt, { cwd: workdir });
+            }
+            catch (agentError) {
+                result.error = `Fix attempt failed: ${agentError.message}`;
+                return result;
+            }
+            // Check if agent produced changes
+            const hasChanges = await this.prService.hasUncommittedChanges(workdir);
+            if (!hasChanges) {
+                result.error = 'Fix attempt produced no changes';
+                return result;
+            }
+            // Commit, push, and create PR
+            await this.prService.commitAll(workdir, `fix: address issue #${issueNumber} reported via shep doctor`);
+            await this.prService.push(workdir, branchName, true);
+            const prResult = await this.prService.createPrFromArgs(workdir, {
+                title: `fix: address shep doctor issue #${issueNumber}`,
+                body: `## Summary\n\nAutomated fix attempt for #${issueNumber}.\n\nThis PR was created by \`shep doctor\` after diagnosing a reported issue.\n\nRelates to #${issueNumber}`,
+                labels: ['shep-doctor'],
+                base: 'main',
+                repo: flowType === 'contributor' ? SHEP_REPO : undefined,
+            });
+            result.prUrl = prResult.url;
+            return result;
+        }
+        finally {
+            // Cleanup temp directory (unless user specified --workdir)
+            if (!isUserWorkdir) {
+                try {
+                    await rm(workdir, { recursive: true, force: true });
+                    result.cleanedUp = true;
+                }
+                catch {
+                    // Best-effort cleanup
+                }
+            }
+        }
+    }
+    buildFixPrompt(report, issueNumber) {
+        const lines = [];
+        lines.push(`You are fixing issue #${issueNumber} in the shep-ai/cli codebase.`);
+        lines.push('');
+        lines.push('## Problem Description');
+        lines.push(report.userDescription);
+        lines.push('');
+        if (report.failedRunSummaries.length > 0) {
+            lines.push('## Error Context');
+            for (const run of report.failedRunSummaries) {
+                lines.push(`- Agent: ${run.agentName} (${run.agentType})`);
+                lines.push(`  Error: ${run.error}`);
+            }
+            lines.push('');
+        }
+        lines.push('## Instructions');
+        lines.push('1. Analyze the codebase to identify the root cause');
+        lines.push('2. Implement a fix for the identified issue');
+        lines.push('3. Run tests to verify the fix works');
+        lines.push('4. Keep changes minimal and focused');
+        return lines.join('\n');
+    }
+};
+DoctorDiagnoseUseCase = __decorate([
+    injectable(),
+    __param(0, inject('IAgentRunRepository')),
+    __param(1, inject('IVersionService')),
+    __param(2, inject('IGitHubIssueService')),
+    __param(3, inject('IGitHubRepositoryService')),
+    __param(4, inject('IGitPrService')),
+    __param(5, inject('IAgentExecutorProvider')),
+    __param(6, inject('ExecFunction')),
+    __param(7, inject('IFeatureRepository')),
+    __metadata("design:paramtypes", [Object, Object, Object, Object, Object, Object, Function, Object])
+], DoctorDiagnoseUseCase);
+export { DoctorDiagnoseUseCase };

package/dist/packages/core/src/application/use-cases/features/adopt-branch.use-case.d.ts

@@ -6,17 +6,14 @@
  * and persists a Feature entity. Branches with an open PR get lifecycle=Review
  * (shown as "REVIEW" in the UI); all others get lifecycle=Maintain (completed).
  *
- * As of feature 071 (adopted-branch-agent-runs), this use case also creates an
- * AgentRun record and initializes a spec directory, enabling adopted features to
- * support agent execution (start, resume, reject) just like created features.
+ * This is a standalone use case — it does NOT extend or modify CreateFeatureUseCase.
+ * It needs only three dependencies: IFeatureRepository, IRepositoryRepository, and IWorktreeService.
  */
 import type { Feature } from '../../../domain/generated/output.js';
 import type { IFeatureRepository } from '../../ports/output/repositories/feature-repository.interface.js';
 import type { IRepositoryRepository } from '../../ports/output/repositories/repository-repository.interface.js';
 import type { IWorktreeService } from '../../ports/output/services/worktree-service.interface.js';
 import type { IGitPrService } from '../../ports/output/services/git-pr-service.interface.js';
-import type { IAgentRunRepository } from '../../ports/output/agents/agent-run-repository.interface.js';
-import type { ISpecInitializerService } from '../../ports/output/services/spec-initializer.interface.js';
 export interface AdoptBranchInput {
     branchName: string;
     repositoryPath: string;
@@ -29,9 +26,7 @@ export declare class AdoptBranchUseCase {
     private readonly repositoryRepo;
     private readonly worktreeService;
     private readonly gitPrService;
-    private readonly agentRunRepo;
-    private readonly specInitializer;
-    constructor(featureRepo: IFeatureRepository, repositoryRepo: IRepositoryRepository, worktreeService: IWorktreeService, gitPrService: IGitPrService, agentRunRepo: IAgentRunRepository, specInitializer: ISpecInitializerService);
+    constructor(featureRepo: IFeatureRepository, repositoryRepo: IRepositoryRepository, worktreeService: IWorktreeService, gitPrService: IGitPrService);
     execute(input: AdoptBranchInput): Promise<AdoptBranchResult>;
     /**
      * Resolve the git ref to use for worktree creation.

package/dist/packages/core/src/application/use-cases/features/adopt-branch.use-case.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adopt-branch.use-case.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/application/use-cases/features/adopt-branch.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAOH,OAAO,KAAK,EAAE,OAAO,EAAe,MAAM,qCAAqC,CAAC;AAEhF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iEAAiE,CAAC;AAC1G,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oEAAoE,CAAC;AAChH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2DAA2D,CAAC;AAClG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yDAAyD,CAAC;AAC7F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6DAA6D,CAAC;AACvG,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,2DAA2D,CAAC;AAIzG,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;CAClB;AAKD,qBACa,kBAAkB;IAG3B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAE5B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAE/B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAEhC,OAAO,CAAC,QAAQ,CAAC,YAAY;IAE7B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAE7B,OAAO,CAAC,QAAQ,CAAC,eAAe;gBAVf,WAAW,EAAE,kBAAkB,EAE/B,cAAc,EAAE,qBAAqB,EAErC,eAAe,EAAE,gBAAgB,EAEjC,YAAY,EAAE,aAAa,EAE3B,YAAY,EAAE,mBAAmB,EAEjC,eAAe,EAAE,uBAAuB;IAGrD,OAAO,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAkJlE;;;;OAIG;YACW,gBAAgB;IAiB9B;;;;OAIG;YACW,iBAAiB;IA4B/B;;;OAGG;YACW,iBAAiB;CAuBhC"}
+{"version":3,"file":"adopt-branch.use-case.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/application/use-cases/features/adopt-branch.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAe,MAAM,qCAAqC,CAAC;AAEhF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iEAAiE,CAAC;AAC1G,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oEAAoE,CAAC;AAChH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2DAA2D,CAAC;AAClG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yDAAyD,CAAC;AAG7F,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;CAClB;AAKD,qBACa,kBAAkB;IAG3B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAE5B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAE/B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAEhC,OAAO,CAAC,QAAQ,CAAC,YAAY;gBANZ,WAAW,EAAE,kBAAkB,EAE/B,cAAc,EAAE,qBAAqB,EAErC,eAAe,EAAE,gBAAgB,EAEjC,YAAY,EAAE,aAAa;IAGxC,OAAO,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAyFlE;;;;OAIG;YACW,gBAAgB;IAiB9B;;;;OAIG;YACW,iBAAiB;IA4B/B;;;OAGG;YACW,iBAAiB;CAuBhC"}

package/dist/packages/core/src/application/use-cases/features/adopt-branch.use-case.js

@@ -6,9 +6,8 @@
  * and persists a Feature entity. Branches with an open PR get lifecycle=Review
  * (shown as "REVIEW" in the UI); all others get lifecycle=Maintain (completed).
  *
- * As of feature 071 (adopted-branch-agent-runs), this use case also creates an
- * AgentRun record and initializes a spec directory, enabling adopted features to
- * support agent execution (start, resume, reject) just like created features.
+ * This is a standalone use case — it does NOT extend or modify CreateFeatureUseCase.
+ * It needs only three dependencies: IFeatureRepository, IRepositoryRepository, and IWorktreeService.
  */
 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;
@@ -24,11 +23,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { injectable, inject } from 'tsyringe';
 import { randomUUID } from 'node:crypto';
-// Phase 2 imports - will be used for AgentRun creation and spec directory detection
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { SdlcLifecycle, PrStatus, AgentRunStatus } from '../../../domain/generated/output.js';
-import { getSettings } from '../../../infrastructure/services/settings.service.js';
+import { SdlcLifecycle, PrStatus } from '../../../domain/generated/output.js';
 import { deriveName, deriveSlug } from './branch-name-utils.js';
 /** Branches that must not be adopted as features. */
 const PROTECTED_BRANCHES = new Set(['main', 'master']);
@@ -37,15 +32,11 @@ let AdoptBranchUseCase = class AdoptBranchUseCase {
     repositoryRepo;
     worktreeService;
     gitPrService;
-    agentRunRepo;
-    specInitializer;
-    constructor(featureRepo, repositoryRepo, worktreeService, gitPrService, agentRunRepo, specInitializer) {
+    constructor(featureRepo, repositoryRepo, worktreeService, gitPrService) {
         this.featureRepo = featureRepo;
         this.repositoryRepo = repositoryRepo;
         this.worktreeService = worktreeService;
         this.gitPrService = gitPrService;
-        this.agentRunRepo = agentRunRepo;
-        this.specInitializer = specInitializer;
     }
     async execute(input) {
         const { branchName, repositoryPath } = input;
@@ -70,65 +61,25 @@ let AdoptBranchUseCase = class AdoptBranchUseCase {
         const branchRef = await this.resolveBranchRef(branchName, repositoryPath);
         // --- Resolve or create repository entity ---
         const repository = await this.resolveRepository(repositoryPath);
-        // --- Calculate feature number for spec directory ---
-        // Use existing feature count as hint; SpecInitializerService.resolveNextNumber()
-        // will scan filesystem to determine actual next available number
-        const effectiveRepoPath = repository.path;
-        const existingFeatures = await this.featureRepo.list({
-            repositoryPath: effectiveRepoPath,
-        });
-        const featureNumber = existingFeatures.length;
         // --- Create or reuse worktree ---
         const worktreePath = this.worktreeService.getWorktreePath(repositoryPath, slug);
         const worktreeExists = await this.worktreeService.exists(repositoryPath, branchName);
         if (!worktreeExists) {
             await this.worktreeService.addExisting(repositoryPath, branchRef, worktreePath);
         }
-        // --- Initialize or detect spec directory ---
-        // Check if spec directory already exists (e.g., from previous /shep-kit:new-feature work)
-        // If exists, preserve it. If not, initialize with empty YAMLs.
-        const nnn = String(featureNumber).padStart(3, '0');
-        const expectedSpecDir = join(worktreePath, 'specs', `${nnn}-${slug}`);
-        let specDir;
-        if (existsSync(expectedSpecDir)) {
-            // Spec directory already exists — use it without modification
-            specDir = expectedSpecDir;
-        }
-        else {
-            // No spec directory — initialize with empty YAMLs
-            const result = await this.specInitializer.initialize(worktreePath, slug, featureNumber, '(adopted from existing branch)');
-            specDir = result.specDir;
-        }
-        // --- Create AgentRun record (following CreateFeatureUseCase pattern lines 156-210) ---
-        const runId = randomUUID();
-        const settings = getSettings();
-        const now = new Date();
-        const agentRun = {
-            id: runId,
-            agentType: settings.agent.type,
-            agentName: 'feature-agent',
-            status: AgentRunStatus.pending,
-            prompt: '(adopted from existing branch)',
-            threadId: randomUUID(), // New UUID for LangGraph checkpoint isolation
-            featureId: '', // Will be set after Feature creation, but we need runId first
-            repositoryPath: effectiveRepoPath,
-            ...(settings.models?.default ? { modelId: settings.models.default } : {}),
-            createdAt: now.toISOString(),
-            updatedAt: now.toISOString(),
-        };
         // --- Detect open PR for this branch ---
         const prData = await this.detectPrForBranch(branchName, repositoryPath);
         // --- Derive feature metadata ---
         const name = deriveName(branchName);
+        const now = new Date();
         const hasOpenPr = prData !== undefined;
         // If the branch has an open (not yet merged) PR, place the feature in
         // Review so the node shows "REVIEW" instead of "COMPLETED". Only truly
         // finished branches (no PR, merged PR, or closed PR) get Maintain.
         const lifecycle = prData?.status === PrStatus.Open ? SdlcLifecycle.Review : SdlcLifecycle.Maintain;
-        // --- Construct Feature entity ---
-        const featureId = randomUUID();
+        // --- Persist feature ---
         const feature = {
-            id: featureId,
+            id: randomUUID(),
             name,
             slug,
             description: '',
@@ -147,18 +98,11 @@ let AdoptBranchUseCase = class AdoptBranchUseCase {
                 allowMerge: false,
             },
             worktreePath,
-            specPath: specDir,
-            agentRunId: runId,
             repositoryId: repository.id,
             pr: prData,
             createdAt: now,
             updatedAt: now,
         };
-        // --- Persist AgentRun before Feature (respects referential integrity) ---
-        // Set featureId now that we have it
-        agentRun.featureId = featureId;
-        await this.agentRunRepo.create(agentRun);
-        // --- Persist Feature (after AgentRun exists) ---
         await this.featureRepo.create(feature);
         return { feature };
     }
@@ -239,8 +183,6 @@ AdoptBranchUseCase = __decorate([
     __param(1, inject('IRepositoryRepository')),
     __param(2, inject('IWorktreeService')),
     __param(3, inject('IGitPrService')),
-    __param(4, inject('IAgentRunRepository')),
-    __param(5, inject('ISpecInitializerService')),
-    __metadata("design:paramtypes", [Object, Object, Object, Object, Object, Object])
+    __metadata("design:paramtypes", [Object, Object, Object, Object])
 ], AdoptBranchUseCase);
 export { AdoptBranchUseCase };

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

@@ -417,6 +417,10 @@ export type WorkflowConfig = {
      * Hide CI status badges from UI (default: true)
      */
     hideCiStatus?: boolean;
+    /**
+     * Maximum number of doctor fix attempts before giving up (default: 1)
+     */
+    doctorMaxFixAttempts?: number;
 };
 export declare enum AgentType {
     ClaudeCode = "claude-code",
@@ -1606,6 +1610,77 @@ export type Evidence = {
      */
     taskRef?: string;
 };
+/**
+ * Summary of a failed agent run for diagnostic reporting
+ */
+export type FailedRunSummary = {
+    /**
+     * Type of agent that failed (e.g. claude-code, gemini-cli)
+     */
+    agentType: string;
+    /**
+     * Name/identifier of the agent run
+     */
+    agentName: string;
+    /**
+     * Error message from the failed run
+     */
+    error: string;
+    /**
+     * ISO 8601 timestamp when the failure occurred
+     */
+    timestamp: string;
+};
+/**
+ * System environment information for diagnostic reporting
+ */
+export type SystemInfo = {
+    /**
+     * Node.js version (e.g. v20.11.0)
+     */
+    nodeVersion: string;
+    /**
+     * Operating system platform (e.g. darwin, linux, win32)
+     */
+    platform: string;
+    /**
+     * CPU architecture (e.g. x64, arm64)
+     */
+    arch: string;
+    /**
+     * gh CLI version string
+     */
+    ghVersion: string;
+};
+/**
+ * Structured diagnostic report collected by shep doctor for issue creation
+ */
+export type DoctorDiagnosticReport = {
+    /**
+     * User-provided description of the problem
+     */
+    userDescription: string;
+    /**
+     * Summaries of recent failed agent runs
+     */
+    failedRunSummaries: FailedRunSummary[];
+    /**
+     * System environment information
+     */
+    systemInfo: SystemInfo;
+    /**
+     * Current shep CLI version
+     */
+    cliVersion: string;
+    /**
+     * Feature ID when diagnosing a specific feature (optional)
+     */
+    featureId?: string;
+    /**
+     * Feature name when diagnosing a specific feature (optional)
+     */
+    featureName?: string;
+};
 export declare enum AgentStatus {
     Idle = "Idle",
     Running = "Running",