@shepai/cli 1.151.1 → 1.151.2-pr438.6135e39

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

@@ -0,0 +1,493 @@
+/**
+ * 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, homedir } from 'node:os';
+import { mkdir, rm, readFile } 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'];
+const MAX_AGENT_RUN_DETAILS = 10;
+const MAX_WORKER_LOG_CHARS = 50_000;
+const MAX_PROMPT_CHARS = 10_000;
+const MAX_RESULT_CHARS = 10_000;
+const MAX_CONVERSATION_CHARS = 20_000;
+const MAX_PLAN_CHARS = 20_000;
+// ---------------------------------------------------------------------------
+// Use Case
+// ---------------------------------------------------------------------------
+let DoctorDiagnoseUseCase = class DoctorDiagnoseUseCase {
+    agentRunRepo;
+    versionService;
+    issueService;
+    repoService;
+    prService;
+    agentExecutorProvider;
+    execFile;
+    featureRepo;
+    phaseTimingRepo;
+    constructor(agentRunRepo, versionService, issueService, repoService, prService, agentExecutorProvider, execFile, featureRepo, phaseTimingRepo) {
+        this.agentRunRepo = agentRunRepo;
+        this.versionService = versionService;
+        this.issueService = issueService;
+        this.repoService = repoService;
+        this.prService = prService;
+        this.agentExecutorProvider = agentExecutorProvider;
+        this.execFile = execFile;
+        this.featureRepo = featureRepo;
+        this.phaseTimingRepo = phaseTimingRepo;
+    }
+    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) {
+        let resolvedFeatureId;
+        let featureName;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let feature;
+        if (featureId) {
+            feature =
+                (await this.featureRepo.findById(featureId)) ??
+                    (await this.featureRepo.findByIdPrefix(featureId));
+            if (feature) {
+                resolvedFeatureId = feature.id;
+                featureName = feature.name;
+            }
+        }
+        // Fetch all runs once — used for both failed summaries and enrichment
+        const allRuns = await this.agentRunRepo.list();
+        const [failedRunSummaries, systemInfo, cliVersion] = await Promise.all([
+            Promise.resolve(this.filterFailedRuns(allRuns, resolvedFeatureId)),
+            this.collectSystemInfo(),
+            Promise.resolve(this.versionService.getVersion().version),
+        ]);
+        const report = {
+            userDescription,
+            failedRunSummaries,
+            systemInfo,
+            cliVersion,
+            featureId: resolvedFeatureId,
+            featureName,
+        };
+        // Enrich with feature-scoped data when a feature is resolved
+        if (feature) {
+            report.featureLifecycle = feature.lifecycle;
+            report.featureBranch = feature.branch;
+            report.featureDescription = feature.description;
+            report.featureWorkflowConfig = JSON.stringify({
+                fast: feature.fast,
+                push: feature.push,
+                openPr: feature.openPr,
+                approvalGates: feature.approvalGates,
+            });
+            if (feature.messages?.length) {
+                const serialized = JSON.stringify(feature.messages);
+                report.conversationMessages = this.truncate(serialized, MAX_CONVERSATION_CHARS).text;
+            }
+            if (feature.plan) {
+                const serialized = JSON.stringify(feature.plan);
+                report.featurePlan = this.truncate(serialized, MAX_PLAN_CHARS).text;
+            }
+            // Parallel async enrichments
+            const featureRuns = allRuns.filter((r) => r.featureId === resolvedFeatureId);
+            const [specYamls, workerLogs, phaseTimings] = await Promise.all([
+                this.collectSpecYamls(feature.specPath),
+                this.collectWorkerLogs(featureRuns),
+                this.collectPhaseTimings(resolvedFeatureId),
+            ]);
+            Object.assign(report, specYamls);
+            report.workerLogs = workerLogs.length > 0 ? workerLogs : undefined;
+            report.phaseTimings = phaseTimings;
+            report.agentRunDetails = this.buildAgentRunDetails(featureRuns);
+        }
+        return report;
+    }
+    filterFailedRuns(allRuns, featureId) {
+        let filtered = allRuns.filter((run) => run.status === AgentRunStatus.failed);
+        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,
+        };
+    }
+    // -------------------------------------------------------------------------
+    // Enrichment helpers
+    // -------------------------------------------------------------------------
+    truncate(content, maxChars) {
+        if (content.length <= maxChars) {
+            return { text: content, truncated: false };
+        }
+        return {
+            text: `${content.slice(0, maxChars)}\n... [truncated, ${content.length} chars total]`,
+            truncated: true,
+            originalLength: content.length,
+        };
+    }
+    async collectSpecYamls(specPath) {
+        if (!specPath)
+            return {};
+        const files = [
+            'spec.yaml',
+            'research.yaml',
+            'plan.yaml',
+            'tasks.yaml',
+            'feature.yaml',
+        ];
+        const keys = [
+            'specYaml',
+            'researchYaml',
+            'planYaml',
+            'tasksYaml',
+            'featureStatusYaml',
+        ];
+        const results = {};
+        const reads = await Promise.all(files.map((f) => this.readFileSafe(path.join(specPath, f))));
+        for (let i = 0; i < files.length; i++) {
+            if (reads[i]) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                results[keys[i]] = reads[i];
+            }
+        }
+        return results;
+    }
+    async collectWorkerLogs(featureRuns) {
+        const logDir = path.join(homedir(), '.shep', 'logs');
+        const entries = [];
+        for (const run of featureRuns) {
+            const logPath = path.join(logDir, `worker-${run.id}.log`);
+            const content = await this.readFileSafe(logPath);
+            if (content) {
+                const { text, truncated, originalLength } = this.truncate(content, MAX_WORKER_LOG_CHARS);
+                entries.push({
+                    agentRunId: run.id,
+                    agentName: run.agentName,
+                    content: text,
+                    truncated,
+                    originalLength,
+                });
+            }
+        }
+        return entries;
+    }
+    async collectPhaseTimings(featureId) {
+        try {
+            const timings = await this.phaseTimingRepo.findByFeatureId(featureId);
+            return timings.length > 0 ? JSON.stringify(timings) : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    buildAgentRunDetails(featureRuns) {
+        if (featureRuns.length === 0)
+            return undefined;
+        return featureRuns.slice(0, MAX_AGENT_RUN_DETAILS).map((run) => ({
+            agentType: run.agentType,
+            agentName: run.agentName,
+            prompt: this.truncate(run.prompt, MAX_PROMPT_CHARS).text,
+            result: run.result ? this.truncate(run.result, MAX_RESULT_CHARS).text : undefined,
+            error: run.error ?? undefined,
+            timestamp: run.createdAt instanceof Date ? run.createdAt.toISOString() : String(run.createdAt),
+        }));
+    }
+    async readFileSafe(filePath) {
+        try {
+            return await readFile(filePath, 'utf-8');
+        }
+        catch {
+            return undefined;
+        }
+    }
+    // -------------------------------------------------------------------------
+    // 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}`);
+            if (report.featureLifecycle)
+                sections.push(`- **Lifecycle:** ${report.featureLifecycle}`);
+            if (report.featureBranch)
+                sections.push(`- **Branch:** ${report.featureBranch}`);
+            if (report.featureDescription)
+                sections.push(`- **Description:** ${report.featureDescription}`);
+            if (report.featureWorkflowConfig)
+                sections.push(`- **Workflow Config:** ${report.featureWorkflowConfig}`);
+        }
+        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('');
+            }
+        }
+        if (report.agentRunDetails?.length) {
+            sections.push('\n## Agent Run Details\n');
+            for (const detail of report.agentRunDetails) {
+                sections.push(`<details><summary>Agent: ${detail.agentName} (${detail.agentType})</summary>\n`);
+                sections.push(`### Prompt\n\`\`\`\n${detail.prompt}\n\`\`\`\n`);
+                if (detail.result) {
+                    sections.push(`### Result\n\`\`\`\n${detail.result}\n\`\`\`\n`);
+                }
+                if (detail.error) {
+                    sections.push(`### Error\n\`\`\`\n${detail.error}\n\`\`\`\n`);
+                }
+                sections.push('</details>\n');
+            }
+        }
+        if (report.conversationMessages) {
+            const msgCount = (report.conversationMessages.match(/"id"/g) ?? []).length;
+            sections.push('\n## Conversation History\n');
+            sections.push(`<details><summary>Messages (${msgCount} messages)</summary>\n`);
+            sections.push(`\`\`\`json\n${report.conversationMessages}\n\`\`\`\n`);
+            sections.push('</details>\n');
+        }
+        if (report.featurePlan) {
+            sections.push('\n## Feature Plan\n');
+            sections.push('<details><summary>Plan & Tasks</summary>\n');
+            sections.push(`\`\`\`json\n${report.featurePlan}\n\`\`\`\n`);
+            sections.push('</details>\n');
+        }
+        // Spec files
+        const specEntries = [
+            ['spec.yaml', report.specYaml],
+            ['research.yaml', report.researchYaml],
+            ['plan.yaml', report.planYaml],
+            ['tasks.yaml', report.tasksYaml],
+            ['feature.yaml', report.featureStatusYaml],
+        ];
+        const hasSpecs = specEntries.some(([, v]) => v);
+        if (hasSpecs) {
+            sections.push('\n## Spec Files\n');
+            for (const [name, content] of specEntries) {
+                if (content) {
+                    sections.push(`<details><summary>${name}</summary>\n`);
+                    sections.push(`\`\`\`yaml\n${content}\n\`\`\`\n`);
+                    sections.push('</details>\n');
+                }
+            }
+        }
+        if (report.workerLogs?.length) {
+            sections.push('\n## Worker Logs\n');
+            for (const log of report.workerLogs) {
+                const suffix = log.truncated ? ` (truncated, ${log.originalLength} chars total)` : '';
+                sections.push(`<details><summary>Worker log: ${log.agentName} (${log.agentRunId})${suffix}</summary>\n`);
+                sections.push(`\`\`\`\n${log.content}\n\`\`\`\n`);
+                sections.push('</details>\n');
+            }
+        }
+        if (report.phaseTimings) {
+            sections.push('\n## Phase Timings\n');
+            sections.push('<details><summary>Phase timing data</summary>\n');
+            sections.push(`\`\`\`json\n${report.phaseTimings}\n\`\`\`\n`);
+            sections.push('</details>\n');
+        }
+        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')),
+    __param(8, inject('IPhaseTimingRepository')),
+    __metadata("design:paramtypes", [Object, Object, Object, Object, Object, Object, Function, Object, Object])
+], DoctorDiagnoseUseCase);
+export { DoctorDiagnoseUseCase };

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",
@@ -1652,6 +1656,187 @@ 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;
+};
+/**
+ * Detailed agent run information including prompt and result for diagnostic reporting
+ */
+export type AgentRunDetail = {
+    /**
+     * Type of agent (e.g. claude-code, gemini-cli)
+     */
+    agentType: string;
+    /**
+     * Name/identifier of the agent run
+     */
+    agentName: string;
+    /**
+     * Input prompt sent to the agent executor
+     */
+    prompt: string;
+    /**
+     * Final result output from the agent (if available)
+     */
+    result?: string;
+    /**
+     * Error message if the run failed
+     */
+    error?: string;
+    /**
+     * ISO 8601 timestamp of the run
+     */
+    timestamp: string;
+};
+/**
+ * Worker log entry for a specific agent run
+ */
+export type WorkerLogEntry = {
+    /**
+     * Agent run ID this log belongs to
+     */
+    agentRunId: string;
+    /**
+     * Name of the agent that produced this log
+     */
+    agentName: string;
+    /**
+     * Full log file content (may be truncated)
+     */
+    content: string;
+    /**
+     * Whether the content was truncated due to size limits
+     */
+    truncated: boolean;
+    /**
+     * Original character count before truncation (only set when truncated)
+     */
+    originalLength?: number;
+};
+/**
+ * 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;
+    /**
+     * Feature lifecycle phase (e.g. Implementation, Review)
+     */
+    featureLifecycle?: string;
+    /**
+     * Feature git branch name
+     */
+    featureBranch?: string;
+    /**
+     * Feature description
+     */
+    featureDescription?: string;
+    /**
+     * JSON-serialized feature workflow configuration (fast, push, openPr, approvalGates)
+     */
+    featureWorkflowConfig?: string;
+    /**
+     * Raw spec.yaml content
+     */
+    specYaml?: string;
+    /**
+     * Raw research.yaml content
+     */
+    researchYaml?: string;
+    /**
+     * Raw plan.yaml content
+     */
+    planYaml?: string;
+    /**
+     * Raw tasks.yaml content
+     */
+    tasksYaml?: string;
+    /**
+     * Raw feature.yaml (status tracking) content
+     */
+    featureStatusYaml?: string;
+    /**
+     * Detailed agent run information including prompts and results
+     */
+    agentRunDetails?: AgentRunDetail[];
+    /**
+     * JSON-serialized conversation messages (Feature.messages[])
+     */
+    conversationMessages?: string;
+    /**
+     * JSON-serialized feature plan (Feature.plan)
+     */
+    featurePlan?: string;
+    /**
+     * Worker execution logs for agent runs associated with this feature
+     */
+    workerLogs?: WorkerLogEntry[];
+    /**
+     * JSON-serialized phase timing records
+     */
+    phaseTimings?: string;
+};
 export declare enum AgentStatus {
     Idle = "Idle",
     Running = "Running",