@renseiai/agentfactory-linear 0.8.0

package/dist/src/defaults/prompts.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Default prompt templates for each work type.
+ *
+ * These provide sensible defaults that can be overridden by consumers.
+ * The Rensei project overrides these with its own prompts.ts.
+ */
+import type { AgentWorkType, SubIssueStatus } from '../types.js';
+export declare const WORK_RESULT_MARKER_INSTRUCTION = "\n\nMANDATORY \u2014 Structured Result Marker:\nYou MUST include exactly one of these HTML comment markers in your final output:\n- On pass: <!-- WORK_RESULT:passed -->\n- On fail: <!-- WORK_RESULT:failed -->\nWithout this marker, the orchestrator CANNOT detect your result and the issue status will NOT be updated. Even if you encounter errors, always emit <!-- WORK_RESULT:failed -->.";
+export declare const READ_ONLY_CONSTRAINT = "\n\nCRITICAL CONSTRAINT \u2014 READ-ONLY ROLE:\nYou are a VALIDATION agent, NOT a development agent. You MUST NOT modify any source code, configuration files, migration files, or project files. Your role is strictly to READ, VALIDATE, and REPORT.\nFORBIDDEN actions: creating files, editing files, writing code, committing changes, patching snapshots, fixing bugs, resolving errors in code.\nALLOWED actions: reading files, running tests, running builds, checking CI status, posting comments, merging PRs (acceptance only), updating Linear status.\nIf you discover issues (missing files, broken builds, failing tests), REPORT them in your result comment and emit WORK_RESULT:failed. Do NOT attempt to fix them.";
+export declare const PR_SELECTION_GUIDANCE = "\n\nPR Selection (Multi-PR Handling):\nIssues may have multiple PRs. Select the correct one:\n1. Check linked PRs in the issue attachments/links for GitHub PR URLs\n2. Filter by state \u2014 prefer OPEN over MERGED over CLOSED: gh pr view NNN --json state\n3. If multiple OPEN PRs, pick the most recently created one\n4. Fallback search by branch: gh pr list --head \"$(git branch --show-current)\" --state open\n5. Last resort search by issue ID: gh pr list --state open --search \"[issue-id]\"\n6. If no PR found, emit WORK_RESULT:failed with explanation";
+/**
+ * Context from the workflow state machine for retry enrichment.
+ * Injected when an issue has been through previous dev-QA-rejected cycles.
+ */
+export interface WorkflowContext {
+    cycleCount: number;
+    strategy: string;
+    failureSummary: string | null;
+    qaAttemptCount?: number;
+}
+/**
+ * Build the failure context block to append to prompts for retries.
+ */
+export declare function buildFailureContextBlock(workType: AgentWorkType, context: WorkflowContext): string;
+/**
+ * Generate a default prompt for a given work type and issue identifier.
+ *
+ * @param identifier - The issue identifier (e.g., "PROJ-123")
+ * @param workType - The type of work to perform
+ * @param mentionContext - Optional additional context from a user mention
+ * @param workflowContext - Optional workflow state context for retry enrichment
+ */
+export declare function defaultGeneratePrompt(identifier: string, workType: AgentWorkType, mentionContext?: string, workflowContext?: WorkflowContext): string;
+/**
+ * Build default QA context for parent issues with sub-issues.
+ */
+export declare function defaultBuildParentQAContext(issueIdentifier: string, subIssueStatuses: SubIssueStatus[]): string;
+/**
+ * Build default acceptance context for parent issues with sub-issues.
+ */
+export declare function defaultBuildParentAcceptanceContext(issueIdentifier: string, subIssueStatuses: SubIssueStatus[]): string;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/src/defaults/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../src/defaults/prompts.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAahE,eAAO,MAAM,8BAA8B,uYAMsI,CAAA;AAEjL,eAAO,MAAM,oBAAoB,2sBAMiI,CAAA;AAElK,eAAO,MAAM,qBAAqB,ijBAS0B,CAAA;AAE5D;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,aAAa,EACvB,OAAO,EAAE,eAAe,GACvB,MAAM,CA0DR;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,aAAa,EACvB,cAAc,CAAC,EAAE,MAAM,EACvB,eAAe,CAAC,EAAE,eAAe,GAChC,MAAM,CAgKR;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,eAAe,EAAE,MAAM,EACvB,gBAAgB,EAAE,cAAc,EAAE,GACjC,MAAM,CAoBR;AAED;;GAEG;AACH,wBAAgB,mCAAmC,CACjD,eAAe,EAAE,MAAM,EACvB,gBAAgB,EAAE,cAAc,EAAE,GACjC,MAAM,CAmBR"}

package/dist/src/defaults/prompts.js

@@ -0,0 +1,310 @@
+/**
+ * Default prompt templates for each work type.
+ *
+ * These provide sensible defaults that can be overridden by consumers.
+ * The Rensei project overrides these with its own prompts.ts.
+ */
+const HUMAN_BLOCKER_INSTRUCTION = `
+
+HUMAN-NEEDED BLOCKERS:
+If you encounter work that requires human action and cannot be resolved autonomously
+(e.g., missing API keys/credentials, infrastructure not provisioned, third-party onboarding,
+manual setup steps, policy decisions, access permissions), create a blocker issue:
+  pnpm af-linear create-blocker <SOURCE-ISSUE-ID> --title "What human needs to do" --description "Detailed steps"
+This creates a tracked issue in Icebox with 'Needs Human' label, linked as blocking the source issue.
+Do NOT silently skip human-needed work or bury it in comments.
+Only create blockers for things that genuinely require a human — not for things you can retry or work around.`;
+export const WORK_RESULT_MARKER_INSTRUCTION = `
+
+MANDATORY — Structured Result Marker:
+You MUST include exactly one of these HTML comment markers in your final output:
+- On pass: <!-- WORK_RESULT:passed -->
+- On fail: <!-- WORK_RESULT:failed -->
+Without this marker, the orchestrator CANNOT detect your result and the issue status will NOT be updated. Even if you encounter errors, always emit <!-- WORK_RESULT:failed -->.`;
+export const READ_ONLY_CONSTRAINT = `
+
+CRITICAL CONSTRAINT — READ-ONLY ROLE:
+You are a VALIDATION agent, NOT a development agent. You MUST NOT modify any source code, configuration files, migration files, or project files. Your role is strictly to READ, VALIDATE, and REPORT.
+FORBIDDEN actions: creating files, editing files, writing code, committing changes, patching snapshots, fixing bugs, resolving errors in code.
+ALLOWED actions: reading files, running tests, running builds, checking CI status, posting comments, merging PRs (acceptance only), updating Linear status.
+If you discover issues (missing files, broken builds, failing tests), REPORT them in your result comment and emit WORK_RESULT:failed. Do NOT attempt to fix them.`;
+export const PR_SELECTION_GUIDANCE = `
+
+PR Selection (Multi-PR Handling):
+Issues may have multiple PRs. Select the correct one:
+1. Check linked PRs in the issue attachments/links for GitHub PR URLs
+2. Filter by state — prefer OPEN over MERGED over CLOSED: gh pr view NNN --json state
+3. If multiple OPEN PRs, pick the most recently created one
+4. Fallback search by branch: gh pr list --head "$(git branch --show-current)" --state open
+5. Last resort search by issue ID: gh pr list --state open --search "[issue-id]"
+6. If no PR found, emit WORK_RESULT:failed with explanation`;
+/**
+ * Build the failure context block to append to prompts for retries.
+ */
+export function buildFailureContextBlock(workType, context) {
+    if (context.cycleCount <= 0)
+        return '';
+    switch (workType) {
+        case 'refinement': {
+            if (context.strategy === 'decompose') {
+                return `\n\n## Decomposition Required (Cycle ${context.cycleCount})
+
+This issue has been through ${context.cycleCount} development-QA cycle(s) and keeps failing.
+Instead of refining, DECOMPOSE this issue into smaller, independently testable pieces.
+
+### Failure History
+${context.failureSummary ?? 'No details recorded.'}
+
+### Decomposition Instructions
+- Break this issue into smaller sub-issues (use --parentId to make them children)
+- Each sub-issue must have clear, unambiguous acceptance criteria
+- Each sub-issue must be testable in isolation
+- Address one specific concern that previous attempts failed on
+- After creating sub-issues, keep the PARENT issue in Icebox for human review`;
+            }
+            return `\n\n## Previous Failure Context
+
+This issue has been through ${context.cycleCount} development-QA cycle(s).
+
+### Failure History
+${context.failureSummary ?? 'No details recorded.'}
+
+### Instructions
+- Read the failure history carefully before making changes
+- Do NOT repeat approaches that already failed
+- If the acceptance criteria are ambiguous, update them to be testable before fixing code
+- Focus on the ROOT CAUSE, not symptoms`;
+        }
+        case 'development':
+        case 'coordination': {
+            return `\n\n## Retry Context
+
+This is retry #${context.cycleCount} for this issue. Previous QA failures:
+${context.failureSummary ?? 'No details recorded.'}
+
+Pay special attention to the areas that failed QA previously.`;
+        }
+        case 'qa':
+        case 'qa-coordination': {
+            if (!context.failureSummary)
+                return '';
+            return `\n\n## Previous QA Results
+This issue has been QA'd ${context.qaAttemptCount ?? context.cycleCount} times previously.
+${context.failureSummary}
+Focus validation on these previously failing areas.`;
+        }
+        default:
+            return '';
+    }
+}
+/**
+ * Generate a default prompt for a given work type and issue identifier.
+ *
+ * @param identifier - The issue identifier (e.g., "PROJ-123")
+ * @param workType - The type of work to perform
+ * @param mentionContext - Optional additional context from a user mention
+ * @param workflowContext - Optional workflow state context for retry enrichment
+ */
+export function defaultGeneratePrompt(identifier, workType, mentionContext, workflowContext) {
+    let basePrompt;
+    switch (workType) {
+        case 'research':
+            basePrompt = `Research and flesh out story ${identifier}. Analyze requirements, identify technical approach, estimate complexity, and update the story description with detailed acceptance criteria. Do NOT implement code.`;
+            break;
+        case 'backlog-creation':
+            basePrompt = `Create backlog issues from the researched story ${identifier}.
+Read the issue description, identify distinct work items, classify each as bug/feature/chore,
+and create appropriately scoped issues in Icebox status (so a human can review before moving to Backlog).
+Choose the correct issue structure based on the work:
+- Sub-issues (--parentId): When work is a single concern with sequential/parallel phases sharing context and dependencies.
+- Independent issues (--type related): When items are unrelated work in different codebase areas with no shared context.
+- Single issue rewrite: When scope is atomic (single concern, few files, no phases). Rewrite source in-place, keep in Icebox.
+When creating multiple issues, always add "related" links between them AND blocking relations where one step depends on another.
+Do NOT wait for user approval - create issues automatically.`;
+            break;
+        case 'development':
+            basePrompt = `Start work on ${identifier}. Implement the feature/fix as specified.`;
+            break;
+        case 'inflight':
+            basePrompt = `Continue work on ${identifier}. Resume where you left off.`;
+            break;
+        case 'qa':
+            basePrompt = `QA ${identifier}. Validate the implementation against acceptance criteria.
+${READ_ONLY_CONSTRAINT}
+${WORK_RESULT_MARKER_INSTRUCTION}
+${PR_SELECTION_GUIDANCE}
+
+Validation Steps:
+1. Find and validate the correct PR (see PR selection above)
+2. Run tests scoped to the affected packages
+3. Verify the build passes
+4. Check deployment status (CI checks on the PR)
+5. Review changes against issue requirements
+6. Post result comment with the structured marker`;
+            break;
+        case 'acceptance':
+            basePrompt = `Process acceptance for ${identifier}. Validate development and QA work is complete, verify PR is ready to merge (CI passing, no conflicts), merge the PR, and clean up local resources.
+${READ_ONLY_CONSTRAINT}
+${WORK_RESULT_MARKER_INSTRUCTION}
+${PR_SELECTION_GUIDANCE}
+
+Acceptance Steps:
+1. Find and validate the correct PR (see PR selection above)
+2. Verify CI is passing and there are no merge conflicts
+3. Confirm QA has passed (check issue status or QA comments)
+4. Merge the PR
+5. Delete the remote branch after successful merge
+6. Post result comment with the structured marker`;
+            break;
+        case 'refinement':
+            basePrompt = `Refine ${identifier} based on rejection feedback. Read comments, update requirements, then return to Backlog.`;
+            break;
+        case 'coordination': {
+            const isRetry = workflowContext && workflowContext.cycleCount > 0;
+            if (isRetry) {
+                basePrompt = `Fix issues found during QA for parent issue ${identifier}.
+
+REWORK MODE — DO NOT re-coordinate sub-issues from scratch.
+All sub-issues are already Finished and a PR already exists. QA failed and specific fixes are needed.
+
+MANDATORY FIRST STEPS:
+1. Read the most recent QA failure comments: pnpm af-linear list-comments ${identifier}
+2. Identify the SPECIFIC fixes needed from the QA failure details below
+3. Apply fixes directly — do NOT re-spawn sub-agents for already-complete work
+4. Commit fixes, push to the existing PR branch
+5. Run full validation: pnpm typecheck && pnpm build && pnpm test
+6. Update parent issue status to Finished
+
+COMMON REWORK FIXES:
+- Missing migration .json snapshots: Find .ts migrations without .json, patch the latest snapshot
+- TypeScript errors: Read the error details, fix the type issues
+- Missing API fields: Update route handlers to include missing fields
+- Build failures: Run pnpm build, diagnose, fix
+
+If the existing PR branch is checked out, work directly on it. Do not create a new branch or PR.`;
+            }
+            else {
+                basePrompt = `Coordinate sub-issue execution for parent issue ${identifier}. Fetch sub-issues with dependency graph, create tasks mapping to each sub-issue, spawn sub-agents for unblocked sub-issues in parallel, monitor completion, and create a single PR with all changes when done.
+
+SUB-ISSUE STATUS MANAGEMENT:
+Update sub-issue statuses in Linear as work progresses:
+- When starting work on a sub-issue: update status to Started
+- When a sub-agent completes a sub-issue: update status to Finished
+- If a sub-agent fails: add a comment explaining the failure
+
+COMPLETION VERIFICATION:
+Before marking the parent issue as complete, verify ALL sub-issues are in Finished status.
+If any sub-issue is not Finished, report the failure and do not mark the parent as complete.`;
+            }
+            break;
+        }
+        case 'qa-coordination':
+            basePrompt = `Coordinate QA across sub-issues for parent issue ${identifier}. Fetch sub-issues, validate each against acceptance criteria, collect pass/fail results, and roll up to parent.
+${READ_ONLY_CONSTRAINT}
+${WORK_RESULT_MARKER_INSTRUCTION}
+${PR_SELECTION_GUIDANCE}
+
+QA Coordination Steps:
+1. Find and validate the correct PR (see PR selection above)
+2. Fetch all sub-issues and verify each is in Finished or later status
+3. Run tests scoped to the affected packages
+4. Verify the build passes (pnpm typecheck && pnpm build)
+5. Review changes against each sub-issue's acceptance criteria
+6. Verify cross-cutting concerns: shared types, API contracts, data flow between sub-issues
+7. Check deployment status (CI checks on the PR)
+
+Pass/Fail:
+- PASS (emit <!-- WORK_RESULT:passed -->): ALL tests pass, build succeeds, all sub-issues implemented, deployment healthy
+- FAIL (emit <!-- WORK_RESULT:failed -->): ANY test failure, build error, missing implementation, deployment failure
+Post a result comment listing per-sub-issue findings, then emit the marker.`;
+            break;
+        case 'acceptance-coordination':
+            basePrompt = `Coordinate acceptance across sub-issues for parent issue ${identifier}. Verify all sub-issues are Delivered, validate the PR, merge it, and bulk-update sub-issues to Accepted.
+${READ_ONLY_CONSTRAINT}
+${WORK_RESULT_MARKER_INSTRUCTION}
+${PR_SELECTION_GUIDANCE}
+
+Acceptance Coordination Steps:
+1. Find and validate the correct PR (see PR selection above)
+2. Verify ALL sub-issues are in Delivered or Accepted status
+3. Verify CI is passing and there are no merge conflicts
+4. Merge the PR
+5. Delete the remote branch after successful merge
+6. Post result comment with per-sub-issue status, then emit the marker
+
+Pass/Fail:
+- PASS (emit <!-- WORK_RESULT:passed -->): All sub-issues Delivered, CI passing, PR merged successfully
+- FAIL (emit <!-- WORK_RESULT:failed -->): Incomplete sub-issues, CI failure, merge conflicts, merge failed
+If ANY issue prevents merging, do NOT attempt to fix it — emit WORK_RESULT:failed with details.`;
+            break;
+        case 'refinement-coordination':
+            basePrompt = `Coordinate refinement across sub-issues for parent issue ${identifier}.
+Read the QA/acceptance failure comments to identify which sub-issues failed and why.
+For each failing sub-issue, update its description with the specific failure feedback and move it back to Backlog.
+Leave passing sub-issues in their current state — do not re-run them.
+Once failing sub-issues are triaged, the orchestrator will move the parent to Backlog for re-coordination.
+
+Refinement Coordination Steps:
+1. Read comments on ${identifier} to find the QA/acceptance failure report
+2. Fetch sub-issues: pnpm af-linear list-sub-issues ${identifier}
+3. For each failing sub-issue: update description with failure details, move to Backlog
+4. Leave passing sub-issues unchanged
+
+IMPORTANT: Do NOT implement fixes yourself — only triage and route feedback to the correct sub-issues.`;
+            break;
+    }
+    basePrompt += HUMAN_BLOCKER_INSTRUCTION;
+    // Inject workflow failure context for retries
+    if (workflowContext) {
+        basePrompt += buildFailureContextBlock(workType, workflowContext);
+    }
+    if (mentionContext) {
+        return `${basePrompt}\n\nAdditional context from the user's mention:\n${mentionContext}`;
+    }
+    return basePrompt;
+}
+/**
+ * Build default QA context for parent issues with sub-issues.
+ */
+export function defaultBuildParentQAContext(issueIdentifier, subIssueStatuses) {
+    const subIssueList = subIssueStatuses
+        .map(s => `- ${s.identifier}: ${s.title} (Status: ${s.status})`)
+        .join('\n');
+    return `QA ${issueIdentifier} (parent issue with ${subIssueStatuses.length} sub-issues).
+
+## Sub-Issues
+${subIssueList}
+
+## Holistic QA Instructions
+This is a parent issue whose work was coordinated across multiple sub-issues.
+Perform holistic validation beyond individual sub-issue checks:
+
+1. **Scope Coverage**: Read each sub-issue description and verify the PR includes implementation for ALL sub-issues.
+2. **Integration Validation**: Check that shared types, API contracts, and data flow between sub-issue implementations are consistent and correct.
+3. **Cross-Cutting Concerns**: Verify consistent error handling, auth patterns, naming conventions, and no orphaned/dead code across all sub-issue changes.
+4. **Sub-Issue Status**: All sub-issues must be in Finished, Delivered, or Accepted status.
+
+Validate the implementation against the parent issue's acceptance criteria as a whole, not just each sub-issue in isolation.`;
+}
+/**
+ * Build default acceptance context for parent issues with sub-issues.
+ */
+export function defaultBuildParentAcceptanceContext(issueIdentifier, subIssueStatuses) {
+    const subIssueList = subIssueStatuses
+        .map(s => `- ${s.identifier}: ${s.title} (Status: ${s.status})`)
+        .join('\n');
+    return `Process acceptance for ${issueIdentifier} (parent issue with ${subIssueStatuses.length} sub-issues).
+
+## Sub-Issues
+${subIssueList}
+
+## Parent Issue Acceptance Requirements
+This is a parent issue with coordinated sub-issues. Before merging:
+
+1. **Sub-Issue Status**: ALL sub-issues must be in **Delivered** or **Accepted** status.
+2. **PR Completeness**: The single PR should contain changes for all sub-issues.
+3. **CI/Deployment**: Verify the combined PR passes CI and deploys successfully.
+
+Validate development and QA work is complete, verify PR is ready to merge (CI passing, no conflicts), merge the PR.
+After merge succeeds, delete the remote branch.`;
+}

package/dist/src/defaults/prompts.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=prompts.test.d.ts.map

package/dist/src/defaults/prompts.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.test.d.ts","sourceRoot":"","sources":["../../../src/defaults/prompts.test.ts"],"names":[],"mappings":""}

package/dist/src/defaults/prompts.test.js

@@ -0,0 +1,263 @@
+import { describe, it, expect } from 'vitest';
+import { buildFailureContextBlock, defaultGeneratePrompt } from './prompts.js';
+describe('buildFailureContextBlock', () => {
+    const baseContext = {
+        cycleCount: 2,
+        strategy: 'context-enriched',
+        failureSummary: '--- Cycle 1, qa (2024-01-01) ---\nTests failed: TypeError in UserService',
+    };
+    describe('refinement work type', () => {
+        it('returns empty string for cycleCount 0', () => {
+            expect(buildFailureContextBlock('refinement', { ...baseContext, cycleCount: 0 })).toBe('');
+        });
+        it('includes failure history for cycle 1+', () => {
+            const result = buildFailureContextBlock('refinement', baseContext);
+            expect(result).toContain('Previous Failure Context');
+            expect(result).toContain('2 development-QA cycle(s)');
+            expect(result).toContain('TypeError in UserService');
+            expect(result).toContain('Do NOT repeat approaches that already failed');
+        });
+        it('includes decomposition instructions for decompose strategy', () => {
+            const decomposeCtx = {
+                ...baseContext,
+                cycleCount: 3,
+                strategy: 'decompose',
+            };
+            const result = buildFailureContextBlock('refinement', decomposeCtx);
+            expect(result).toContain('Decomposition Required');
+            expect(result).toContain('DECOMPOSE this issue');
+            expect(result).toContain('smaller sub-issues');
+            expect(result).not.toContain('Previous Failure Context');
+        });
+        it('handles null failure summary gracefully', () => {
+            const result = buildFailureContextBlock('refinement', { ...baseContext, failureSummary: null });
+            expect(result).toContain('No details recorded');
+        });
+    });
+    describe('development work type', () => {
+        it('returns empty string for cycleCount 0', () => {
+            expect(buildFailureContextBlock('development', { ...baseContext, cycleCount: 0 })).toBe('');
+        });
+        it('includes retry context for cycle 1+', () => {
+            const result = buildFailureContextBlock('development', baseContext);
+            expect(result).toContain('Retry Context');
+            expect(result).toContain('retry #2');
+            expect(result).toContain('TypeError in UserService');
+        });
+    });
+    describe('coordination work type', () => {
+        it('includes retry context same as development', () => {
+            const result = buildFailureContextBlock('coordination', baseContext);
+            expect(result).toContain('Retry Context');
+            expect(result).toContain('retry #2');
+        });
+    });
+    describe('qa-coordination work type', () => {
+        it('returns empty string when no failure summary', () => {
+            expect(buildFailureContextBlock('qa-coordination', { ...baseContext, failureSummary: null })).toBe('');
+        });
+        it('includes previous QA results when failure summary exists', () => {
+            const result = buildFailureContextBlock('qa-coordination', baseContext);
+            expect(result).toContain('Previous QA Results');
+            expect(result).toContain('TypeError in UserService');
+        });
+    });
+    describe('qa work type', () => {
+        it('returns empty string when no failure summary', () => {
+            expect(buildFailureContextBlock('qa', { ...baseContext, failureSummary: null })).toBe('');
+        });
+        it('includes previous QA results when failure summary exists', () => {
+            const qaCtx = {
+                ...baseContext,
+                qaAttemptCount: 2,
+            };
+            const result = buildFailureContextBlock('qa', qaCtx);
+            expect(result).toContain('Previous QA Results');
+            expect(result).toContain('QA\'d 2 times previously');
+            expect(result).toContain('TypeError in UserService');
+        });
+        it('falls back to cycleCount when qaAttemptCount not provided', () => {
+            const result = buildFailureContextBlock('qa', baseContext);
+            expect(result).toContain('QA\'d 2 times previously');
+        });
+    });
+    describe('other work types', () => {
+        it('returns empty string for acceptance', () => {
+            expect(buildFailureContextBlock('acceptance', baseContext)).toBe('');
+        });
+        it('returns empty string for research', () => {
+            expect(buildFailureContextBlock('research', baseContext)).toBe('');
+        });
+        it('returns empty string for backlog-creation', () => {
+            expect(buildFailureContextBlock('backlog-creation', baseContext)).toBe('');
+        });
+    });
+});
+describe('defaultGeneratePrompt with workflowContext', () => {
+    it('does not modify prompt when workflowContext is undefined', () => {
+        const withoutCtx = defaultGeneratePrompt('PROJ-123', 'development');
+        const withUndefined = defaultGeneratePrompt('PROJ-123', 'development', undefined, undefined);
+        expect(withoutCtx).toBe(withUndefined);
+    });
+    it('does not modify prompt when cycleCount is 0', () => {
+        const withoutCtx = defaultGeneratePrompt('PROJ-123', 'development');
+        const withZero = defaultGeneratePrompt('PROJ-123', 'development', undefined, {
+            cycleCount: 0,
+            strategy: 'normal',
+            failureSummary: null,
+        });
+        expect(withoutCtx).toBe(withZero);
+    });
+    it('enriches refinement prompt with failure context', () => {
+        const result = defaultGeneratePrompt('PROJ-123', 'refinement', undefined, {
+            cycleCount: 2,
+            strategy: 'context-enriched',
+            failureSummary: 'Tests failed in UserService',
+        });
+        expect(result).toContain('Refine PROJ-123');
+        expect(result).toContain('Previous Failure Context');
+        expect(result).toContain('Tests failed in UserService');
+    });
+    it('enriches development prompt with retry context', () => {
+        const result = defaultGeneratePrompt('PROJ-123', 'development', undefined, {
+            cycleCount: 1,
+            strategy: 'normal',
+            failureSummary: 'Build error in core package',
+        });
+        expect(result).toContain('Start work on PROJ-123');
+        expect(result).toContain('Retry Context');
+        expect(result).toContain('Build error in core package');
+    });
+    it('preserves mentionContext alongside workflowContext', () => {
+        const result = defaultGeneratePrompt('PROJ-123', 'development', 'Please focus on the API layer', {
+            cycleCount: 1,
+            strategy: 'normal',
+            failureSummary: 'API tests failing',
+        });
+        expect(result).toContain('Retry Context');
+        expect(result).toContain('Please focus on the API layer');
+    });
+});
+describe('defaultGeneratePrompt read-only constraint', () => {
+    const readOnlyWorkTypes = ['qa', 'acceptance', 'qa-coordination', 'acceptance-coordination'];
+    for (const workType of readOnlyWorkTypes) {
+        it(`includes READ-ONLY constraint for ${workType}`, () => {
+            const result = defaultGeneratePrompt('PROJ-123', workType);
+            expect(result).toContain('READ-ONLY ROLE');
+            expect(result).toContain('MUST NOT modify any source code');
+            expect(result).toContain('WORK_RESULT:failed');
+        });
+    }
+    const writableWorkTypes = ['development', 'coordination', 'refinement', 'research', 'backlog-creation', 'inflight'];
+    for (const workType of writableWorkTypes) {
+        it(`does NOT include READ-ONLY constraint for ${workType}`, () => {
+            const result = defaultGeneratePrompt('PROJ-123', workType);
+            expect(result).not.toContain('READ-ONLY ROLE');
+        });
+    }
+});
+describe('defaultGeneratePrompt coordination prompts have steps', () => {
+    it('qa-coordination includes numbered steps and pass/fail criteria', () => {
+        const result = defaultGeneratePrompt('PROJ-100', 'qa-coordination');
+        expect(result).toContain('QA Coordination Steps:');
+        expect(result).toContain('1. Find and validate the correct PR');
+        expect(result).toContain('Pass/Fail:');
+        expect(result).toContain('WORK_RESULT:passed');
+        expect(result).toContain('WORK_RESULT:failed');
+        expect(result).toContain('PR Selection');
+    });
+    it('acceptance-coordination includes numbered steps and pass/fail criteria', () => {
+        const result = defaultGeneratePrompt('PROJ-100', 'acceptance-coordination');
+        expect(result).toContain('Acceptance Coordination Steps:');
+        expect(result).toContain('1. Find and validate the correct PR');
+        expect(result).toContain('Merge the PR');
+        expect(result).toContain('Pass/Fail:');
+        expect(result).toContain('WORK_RESULT:passed');
+        expect(result).toContain('WORK_RESULT:failed');
+        expect(result).toContain('do NOT attempt to fix it');
+        expect(result).toContain('PR Selection');
+    });
+});
+describe('defaultGeneratePrompt coordination retry', () => {
+    it('uses fresh coordination prompt when no workflowContext', () => {
+        const result = defaultGeneratePrompt('PROJ-100', 'coordination');
+        expect(result).toContain('Coordinate sub-issue execution for parent issue PROJ-100');
+        expect(result).toContain('Fetch sub-issues with dependency graph');
+        expect(result).not.toContain('REWORK MODE');
+    });
+    it('uses fresh coordination prompt when cycleCount is 0', () => {
+        const result = defaultGeneratePrompt('PROJ-100', 'coordination', undefined, {
+            cycleCount: 0,
+            strategy: 'normal',
+            failureSummary: null,
+        });
+        expect(result).toContain('Coordinate sub-issue execution for parent issue PROJ-100');
+        expect(result).not.toContain('REWORK MODE');
+    });
+    it('switches to rework mode when cycleCount > 0', () => {
+        const result = defaultGeneratePrompt('PROJ-100', 'coordination', undefined, {
+            cycleCount: 1,
+            strategy: 'context-enriched',
+            failureSummary: '2 migrations missing .json snapshots',
+        });
+        expect(result).toContain('REWORK MODE');
+        expect(result).toContain('Fix issues found during QA for parent issue PROJ-100');
+        expect(result).toContain('DO NOT re-coordinate sub-issues from scratch');
+        expect(result).toContain('pnpm af-linear list-comments PROJ-100');
+        expect(result).not.toContain('Fetch sub-issues with dependency graph');
+    });
+    it('includes common rework fixes in rework mode', () => {
+        const result = defaultGeneratePrompt('PROJ-100', 'coordination', undefined, {
+            cycleCount: 2,
+            strategy: 'context-enriched',
+            failureSummary: 'Build failed',
+        });
+        expect(result).toContain('Missing migration .json snapshots');
+        expect(result).toContain('TypeScript errors');
+        expect(result).toContain('Missing API fields');
+        expect(result).toContain('Build failures');
+    });
+    it('appends failure context block in rework mode', () => {
+        const result = defaultGeneratePrompt('PROJ-100', 'coordination', undefined, {
+            cycleCount: 2,
+            strategy: 'context-enriched',
+            failureSummary: 'Tests failed: missing snapshot for 20260308_migration.ts',
+        });
+        expect(result).toContain('REWORK MODE');
+        expect(result).toContain('Retry Context');
+        expect(result).toContain('retry #2');
+        expect(result).toContain('missing snapshot for 20260308_migration.ts');
+    });
+    it('includes mention context alongside rework mode', () => {
+        const result = defaultGeneratePrompt('PROJ-100', 'coordination', 'Focus on the migration snapshots', {
+            cycleCount: 1,
+            strategy: 'normal',
+            failureSummary: 'Missing .json snapshots',
+        });
+        expect(result).toContain('REWORK MODE');
+        expect(result).toContain('Focus on the migration snapshots');
+    });
+    it('instructs agent to use existing PR branch', () => {
+        const result = defaultGeneratePrompt('PROJ-100', 'coordination', undefined, {
+            cycleCount: 1,
+            strategy: 'normal',
+            failureSummary: null,
+        });
+        expect(result).toContain('Do not create a new branch or PR');
+        expect(result).toContain('push to the existing PR branch');
+    });
+    it('includes sub-issue status management in fresh coordination', () => {
+        const result = defaultGeneratePrompt('PROJ-100', 'coordination');
+        expect(result).toContain('SUB-ISSUE STATUS MANAGEMENT');
+        expect(result).toContain('COMPLETION VERIFICATION');
+    });
+    it('does not include sub-issue status management in rework mode', () => {
+        const result = defaultGeneratePrompt('PROJ-100', 'coordination', undefined, {
+            cycleCount: 1,
+            strategy: 'normal',
+            failureSummary: 'QA failed',
+        });
+        expect(result).not.toContain('SUB-ISSUE STATUS MANAGEMENT');
+        expect(result).not.toContain('COMPLETION VERIFICATION');
+    });
+});

package/dist/src/defaults/work-type-detection.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Default work type detection from prompt keywords.
+ *
+ * Scans prompt text for keywords that map to specific work types,
+ * constrained to the set of valid work types for the current issue status.
+ */
+import type { AgentWorkType } from '../types.js';
+/**
+ * Detect work type from prompt text, constrained to valid options.
+ *
+ * Scans the prompt for keywords and returns the first matching work type
+ * that is also in the set of valid work types for the current issue status.
+ *
+ * @param prompt - The prompt text to scan
+ * @param validWorkTypes - Work types valid for the current issue status
+ * @returns The detected work type, or undefined if no match
+ */
+export declare function defaultDetectWorkTypeFromPrompt(prompt: string, validWorkTypes: AgentWorkType[]): AgentWorkType | undefined;
+//# sourceMappingURL=work-type-detection.d.ts.map

package/dist/src/defaults/work-type-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"work-type-detection.d.ts","sourceRoot":"","sources":["../../../src/defaults/work-type-detection.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAmEhD;;;;;;;;;GASG;AACH,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,aAAa,EAAE,GAC9B,aAAa,GAAG,SAAS,CAe3B"}