ticket-to-pr 1.4.0 → 1.4.2

package/README.md

@@ -74,14 +74,17 @@ Execute          Claude creates branch, implements code, commits changes.
 In Progress      Set automatically when the execute agent starts working.
    |
    v
-PR Ready         Branch pushed. PR created on GitHub.
-                 Branch name, cost, and PR link written to ticket.
+Testing          Branch pushed. PR created. QA checklist posted as comment.
+   |             Dev reviews PR, merges, deploys. Tester verifies in prod.
+   v
+Done             Tester drags here after verifying. Comments with feedback.
+                 TicketToPR reads comments, extracts learnings, saves to project memory.
 
 Failed           Agent errored. Error details on ticket.
                  Drag back to Review or Execute to retry.
 ```
 
-The rhythm is **you, AI, you, AI, AI, you** — three human touchpoints, three AI steps. You're always the decision-maker. The AI is always the worker.
+The rhythm is **you, AI, you, AI, AI, you, AI** — human touchpoints at Review, Execute, and Done. You're always the decision-maker. The AI is always the worker.
 
 ### What It's Great At
 
@@ -165,11 +168,15 @@ Create a new **Board view** database in Notion with these properties:
 | `Branch` | Text | Git branch name (written by AI) |
 | `Cost` | Text | USD spent on the Claude run |
 | `PR URL` | URL | GitHub pull request link (written by AI) |
+| `Reviewed At` | Date | When review completed (sort Scored by this) |
+| `Executed At` | Date | When execution completed (sort Testing by this) |
+| `Failed At` | Date | When ticket failed (sort Failed by this) |
+| `Done At` | Date | When feedback processed (sort Done by this) |
 
-Add these **7 status columns**:
+Add these **8 status columns**:
 
 ```
-Backlog | Review | Scored | Execute | In Progress | PR Ready | Failed
+Backlog | Review | Scored | Execute | In Progress | Testing | Done | Failed
 ```
 
 Connect the integration: **"..." menu** on the database page -> **Connections** -> search **TicketToPR** -> add it.
@@ -381,7 +388,7 @@ Learnings are stored in each project directory at `.ticket-to-pr/learnings.md` (
 6. Run `ticket-to-pr --once` and watch it score the ticket
 7. Check Notion — ticket should be in **Scored** with Ease, Confidence, Spec, Impact filled in
 8. Drag to **Execute**, run `ticket-to-pr --once` again
-9. Check Notion — ticket should be in **PR Ready** with Branch, Cost, and PR link
+9. Check Notion — ticket should be in **Testing** with Branch, Cost, and PR link
 
 Typical cost for this test: **~$0.49** ($0.22 review + $0.27 execute).
 
@@ -486,9 +493,37 @@ The execute agent implements the code based on the spec. When the review agent g
 7. All checks pass: pushes branch to origin
 8. Creates a GitHub PR via `gh pr create` targeting the base branch (unless `skipPR` is enabled)
 9. PR URL written back to the Notion ticket
-10. Ticket moves to **PR Ready**
+10. Ticket moves to **Testing**
 11. Any check fails (diff review, build, blocked files): no code is pushed, ticket moves to **Failed**
 
+## Human Feedback Loop
+
+Non-technical team members can test results and give feedback directly in Notion. TicketToPR reads their comments and saves learnings to improve future runs.
+
+### Workflow for testers (PMs, founders, QA)
+
+1. A ticket lands in **Testing** with a QA checklist comment — the dev reviews and merges the PR, deploys
+4. Test the change and **comment on the ticket** with what you found
+5. **Drag the ticket**:
+   - To **Done** if it works
+   - To **Failed** if something's wrong (explain what happened in a comment)
+
+That's it. TicketToPR reads your comments, extracts learnings, and saves them so the AI makes fewer mistakes over time.
+
+### Feedback on Failed tickets
+
+When you drag a ticket to Failed and comment why, the system saves your context alongside the technical error. This is especially valuable because humans often know *why* something failed better than the error log — "this broke because we changed the API last week" or "wrong approach, we use Redis for this."
+
+### What gets saved
+
+Comments are processed by a lightweight AI agent that extracts tagged learnings:
+- `[feedback]` — general observations about the result
+- `[preference]` — style or approach preferences ("put buttons in the header, not sidebar")
+- `[bug]` — things that broke ("this change broke the checkout flow")
+- `[quality]` — performance, UX, or code quality notes
+
+These learnings are injected into future agent prompts for the same project.
+
 ## Costs
 
 TicketToPR itself is free. You pay Anthropic for Claude API usage. Based on real usage:
@@ -614,7 +649,7 @@ Add to `projects.json` (or re-run `ticket-to-pr init`):
 | Build validation fails | Ticket -> Failed with command, directory, and build output (up to 500 chars) |
 | Blocked file violation | Ticket -> Failed with list of matched files and patterns. No code is pushed. |
 | Push fails | Ticket -> Failed, branch remains local |
-| PR creation fails | Ticket still moves to PR Ready (best-effort) |
+| PR creation fails | Ticket still moves to Testing (best-effort) |
 | Duplicate poll trigger | Skipped via in-memory lock per ticket ID |
 | Agent hangs > 30 min | Lock force-released, ticket -> Failed |
 
@@ -673,7 +708,7 @@ Add to `projects.json` (or re-run `ticket-to-pr init`):
 - Authenticate: `gh auth login`
 - Verify: `gh auth status`
 - The project must have a GitHub `origin` remote
-- PR creation is best-effort — the ticket still moves to PR Ready without it
+- PR creation is best-effort — the ticket still moves to Testing without it
 
 </details>
 

package/dist/config.d.ts

@@ -6,7 +6,8 @@ export declare const CONFIG: {
         readonly SCORED: "Scored";
         readonly EXECUTE: "Execute";
         readonly IN_PROGRESS: "In Progress";
-        readonly DONE: "PR Ready";
+        readonly TESTING: "Testing";
+        readonly DONE: "Done";
         readonly FAILED: "Failed";
     };
     readonly REVIEW_BUDGET_USD: 2;
@@ -88,6 +89,8 @@ export interface TicketDetails extends NotionTicket {
     bodyBlocks: string;
     spec?: string;
     impact?: string;
+    ease?: number;
+    confidence?: number;
 }
 export interface ReviewOutput {
     easeScore: number;

package/dist/config.js

@@ -40,7 +40,8 @@ export const CONFIG = {
         SCORED: 'Scored',
         EXECUTE: 'Execute',
         IN_PROGRESS: 'In Progress',
-        DONE: 'PR Ready',
+        TESTING: 'Testing',
+        DONE: 'Done',
         FAILED: 'Failed',
     },
     // Agent budgets

package/dist/index.js

@@ -3,9 +3,9 @@ import { execSync } from 'node:child_process';
 import { join } from 'node:path';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { CONFIG, REVIEW_OUTPUT_SCHEMA, DIFF_REVIEW_SCHEMA, isPro } from './config.js';
-import { sleep, clamp, extractJsonFromOutput, shellEscape, extractNumber, loadEnv, parseEnvFile, createWorktree, removeWorktree, getDefaultBranch, validateNoBlockedFiles, readLearnings, appendLearning } from './lib/utils.js';
+import { sleep, clamp, extractJsonFromOutput, shellEscape, loadEnv, parseEnvFile, createWorktree, removeWorktree, getDefaultBranch, validateNoBlockedFiles, readLearnings, appendLearning } from './lib/utils.js';
 import { getProjectDir, getProjectNames, getBuildCommand, getBaseBranch, getBlockedFiles, getSkipPR, getDevAccess, getEnvFile } from './lib/projects.js';
-import { fetchTicketsByStatus, fetchTicketDetails, writeReviewResults, writeExecutionResults, moveTicketStatus, writeFailure, addComment, } from './lib/notion.js';
+import { fetchTicketsByStatus, fetchTicketDetails, writeReviewResults, writeExecutionResults, moveTicketStatus, writeFailure, addComment, fetchComments, hasFeedbackMarker, hasTestingMarker, trySetDate, } from './lib/notion.js';
 import { PACKAGE_ROOT, CONFIG_DIR } from './lib/paths.js';
 // Load .env.local from the user's working directory
 loadEnv(join(CONFIG_DIR, '.env.local'));
@@ -32,6 +32,8 @@ const DRY_RUN = args.includes('--dry-run');
 const ONCE = args.includes('--once');
 // -- State --
 const activeLocks = new Map();
+const feedbackProcessed = new Set();
+const testingNotified = new Set();
 let shuttingDown = false;
 let activeAgentCount = 0;
 // -- Logging --
@@ -52,6 +54,8 @@ function log(color, label, msg) {
 const reviewPrompt = readFileSync(join(PACKAGE_ROOT, 'prompts', 'review.md'), 'utf-8');
 const executePrompt = readFileSync(join(PACKAGE_ROOT, 'prompts', 'execute.md'), 'utf-8');
 const diffReviewPrompt = readFileSync(join(PACKAGE_ROOT, 'prompts', 'diff-review.md'), 'utf-8');
+const retroPrompt = readFileSync(join(PACKAGE_ROOT, 'prompts', 'retro.md'), 'utf-8');
+const feedbackPrompt = readFileSync(join(PACKAGE_ROOT, 'prompts', 'feedback.md'), 'utf-8');
 // -- Agent Runner --
 async function runReviewAgent(ticket) {
     const projectDir = getProjectDir(ticket.project);
@@ -275,6 +279,278 @@ async function runDiffReviewAgent(worktreeDir, baseBranch, spec, description, af
         cost,
     };
 }
+async function runRetroAgent(projectDir, worktreeDir, baseBranch, ticket, outcome) {
+    try {
+        // Get the diff (may be empty if agent failed before committing)
+        let diff = '';
+        try {
+            diff = execSync(`git diff origin/${shellEscape(baseBranch)}...HEAD`, {
+                cwd: worktreeDir, stdio: 'pipe', timeout: 15_000,
+            }).toString();
+        }
+        catch {
+            // No diff available
+        }
+        // Read existing learnings to avoid repeats
+        const existingLearnings = readLearnings(projectDir);
+        // Build the retro prompt
+        const parts = [
+            retroPrompt,
+            '',
+            `## Ticket: ${ticket.title}`,
+            '',
+            '**Description**:',
+            ticket.description,
+            '',
+            '**Spec**:',
+            ticket.spec ?? '(none)',
+            '',
+            `## Outcome: ${outcome.success ? 'SUCCESS' : 'FAILED'}`,
+        ];
+        if (!outcome.success && outcome.error) {
+            parts.push('', '**Error**:', outcome.error.slice(0, 1000));
+        }
+        if (outcome.diffReviewIssues && outcome.diffReviewIssues.length > 0) {
+            parts.push('', '**Diff Review Issues**:', ...outcome.diffReviewIssues.map(i => `- ${i}`));
+        }
+        if (outcome.buildFailed) {
+            parts.push('', '**Build**: FAILED');
+        }
+        if (diff) {
+            const truncatedDiff = diff.length > 50_000 ? diff.slice(0, 50_000) + '\n...(truncated)' : diff;
+            parts.push('', '## Diff', '```diff', truncatedDiff, '```');
+        }
+        else {
+            parts.push('', '## Diff', 'No diff available (agent may have failed before committing).');
+        }
+        if (existingLearnings) {
+            parts.push('', '## Existing Learnings (do not repeat these)', existingLearnings);
+        }
+        const prompt = parts.join('\n');
+        const messages = query({
+            prompt,
+            options: {
+                model: CONFIG.DIFF_REVIEW_MODEL, // Reuse Haiku config
+                cwd: projectDir,
+                tools: ['Read', 'Glob', 'Grep'],
+                allowedTools: ['Read', 'Glob', 'Grep'],
+                maxTurns: 5,
+                maxBudgetUsd: 0.25,
+                permissionMode: 'bypassPermissions',
+                allowDangerouslySkipPermissions: true,
+                settingSources: ['project'],
+                systemPrompt: { type: 'preset', preset: 'claude_code' },
+                stderr: () => { },
+            },
+        });
+        let output = '';
+        for await (const message of messages) {
+            if (message.type === 'assistant') {
+                const content = message.message?.content;
+                if (Array.isArray(content)) {
+                    for (const block of content) {
+                        if (block.type === 'text')
+                            output = block.text;
+                    }
+                }
+                else if (typeof content === 'string') {
+                    output = content;
+                }
+            }
+            if (message.type === 'result') {
+                if ('result' in message && message.result) {
+                    output = message.result;
+                }
+            }
+        }
+        // Only save if the retro produced something meaningful
+        const trimmed = output.trim();
+        if (trimmed && !trimmed.toLowerCase().includes('no new learnings')) {
+            const header = outcome.success
+                ? `**Retro (success): ${ticket.title}**`
+                : `**Retro (failed): ${ticket.title}**`;
+            appendLearning(projectDir, `${header}\n${trimmed}`);
+            log(DIM, 'RETRO', `Saved ${trimmed.split('\n').filter(l => l.startsWith('-') || l.startsWith('*')).length} learnings`);
+        }
+        else {
+            log(DIM, 'RETRO', 'No new learnings');
+        }
+    }
+    catch (e) {
+        // Retro is best-effort — never block the pipeline
+        log(DIM, 'RETRO', `Skipped: ${e instanceof Error ? e.message : e}`);
+    }
+}
+async function postTestChecklist(ticket) {
+    log(CYAN, 'TESTING', `Posting test checklist for "${ticket.title}"`);
+    try {
+        // Cross-session dedup: check if we already posted a testing checklist
+        const alreadyPosted = await hasTestingMarker(ticket.id);
+        if (alreadyPosted) {
+            log(DIM, 'TESTING', `Checklist already posted for "${ticket.title}", skipping`);
+            return;
+        }
+        // Extract acceptance tests from the spec
+        const spec = ticket.spec ?? '';
+        const description = ticket.description ?? '';
+        let checklist = [];
+        // Parse acceptance tests from spec (format: "## Acceptance Tests\n- GIVEN/WHEN/THEN...")
+        const acceptanceMatch = spec.match(/## Acceptance Tests\n([\s\S]*?)(?:\n##|$)/);
+        if (acceptanceMatch) {
+            checklist = acceptanceMatch[1]
+                .split('\n')
+                .filter(line => line.trim().startsWith('-'))
+                .map(line => {
+                // Convert GIVEN/WHEN/THEN to plain language
+                let text = line.replace(/^-\s*/, '').trim();
+                text = text
+                    .replace(/^GIVEN\s+/i, 'Start with: ')
+                    .replace(/\s*WHEN\s+/i, ' → Do: ')
+                    .replace(/\s*THEN\s+/i, ' → Expect: ');
+                return text;
+            });
+        }
+        // If no acceptance tests, generate a basic checklist from description
+        if (checklist.length === 0) {
+            checklist = [
+                `Verify the change described in the ticket works: "${description.slice(0, 200)}"`,
+                'Check that nothing else looks broken',
+                'Comment on this ticket with what you found',
+            ];
+        }
+        // Build the comment
+        const checklistText = checklist.map((item, i) => `${i + 1}. ${item}`).join('\n');
+        const comment = [
+            `🧪 Ready for Testing`,
+            '',
+            `This ticket has been deployed. Please test the following:`,
+            '',
+            checklistText,
+            '',
+            `When done, comment with what you found and drag to:`,
+            `→ "Done" if it works`,
+            `→ "Failed" if something's wrong (please describe what happened)`,
+        ].join('\n');
+        await addComment(ticket.id, comment);
+        // Executed At is already set when the ticket lands here — no separate timestamp needed
+        log(GREEN, 'TESTING', `Posted checklist for "${ticket.title}" (${checklist.length} items)`);
+    }
+    catch (e) {
+        log(YELLOW, 'TESTING', `Failed to post checklist: ${e instanceof Error ? e.message : e}`);
+    }
+}
+async function runFeedbackRetro(ticket, status) {
+    const projectDir = getProjectDir(ticket.project);
+    if (!projectDir)
+        return;
+    const statusLabel = status === CONFIG.COLUMNS.FAILED ? 'failed' : 'done';
+    log(CYAN, 'FEEDBACK', `Processing feedback for "${ticket.title}" (${statusLabel})`);
+    try {
+        // Cross-session dedup: check if already processed
+        const alreadyProcessed = await hasFeedbackMarker(ticket.id);
+        if (alreadyProcessed) {
+            log(DIM, 'FEEDBACK', `Already processed, skipping "${ticket.title}"`);
+            return;
+        }
+        // Read human comments from the ticket
+        const comments = await fetchComments(ticket.id);
+        if (comments.length === 0) {
+            log(DIM, 'FEEDBACK', 'No human comments found, skipping');
+            // Only mark Done tickets as processed (Failed might get retried with comments later)
+            if (status === CONFIG.COLUMNS.DONE) {
+                await addComment(ticket.id, '🔄 Feedback processed (no human comments found)');
+            }
+            return;
+        }
+        const existingLearnings = readLearnings(projectDir);
+        // Build feedback prompt with status context
+        const parts = [
+            feedbackPrompt,
+            '',
+            `## Ticket: ${ticket.title}`,
+            `## Status: ${status}`,
+            '',
+            '**Description**:',
+            ticket.description,
+            '',
+            '**Spec**:',
+            ticket.spec ?? '(none)',
+            '',
+            '**Impact/Error info**:',
+            ticket.impact ?? '(none)',
+        ];
+        if (status === CONFIG.COLUMNS.FAILED) {
+            parts.push('', '## Context', 'This ticket FAILED. The human comments below describe what went wrong from the user\'s perspective (not just the agent error). Extract learnings about what the AI should do differently.');
+        }
+        else {
+            parts.push('', '## Context', 'This ticket was completed and the human tested the result. Their comments describe what they found.');
+        }
+        parts.push('', '## Human Feedback', ...comments.map(c => `**${c.author}** (${c.createdTime}):\n> ${c.text}`));
+        if (existingLearnings) {
+            parts.push('', '## Existing Learnings (do not repeat these)', existingLearnings);
+        }
+        const prompt = parts.join('\n');
+        const messages = query({
+            prompt,
+            options: {
+                model: CONFIG.DIFF_REVIEW_MODEL, // Haiku — cheap and fast
+                cwd: projectDir,
+                allowedTools: [],
+                maxTurns: 3,
+                maxBudgetUsd: 0.10,
+                permissionMode: 'bypassPermissions',
+                allowDangerouslySkipPermissions: true,
+                systemPrompt: { type: 'preset', preset: 'claude_code' },
+                stderr: () => { },
+            },
+        });
+        let output = '';
+        for await (const message of messages) {
+            if (message.type === 'assistant') {
+                const content = message.message?.content;
+                if (Array.isArray(content)) {
+                    for (const block of content) {
+                        if (block.type === 'text')
+                            output = block.text;
+                    }
+                }
+                else if (typeof content === 'string') {
+                    output = content;
+                }
+            }
+            if (message.type === 'result') {
+                if ('result' in message && message.result) {
+                    output = message.result;
+                }
+            }
+        }
+        // Save learnings if meaningful
+        const trimmed = output.trim();
+        if (trimmed && !trimmed.toLowerCase().includes('no new learnings')) {
+            const tag = status === CONFIG.COLUMNS.FAILED ? 'Feedback (failed)' : 'Feedback';
+            appendLearning(projectDir, `**${tag}: ${ticket.title}**\n${trimmed}`);
+            const count = trimmed.split('\n').filter(l => l.startsWith('-') || l.startsWith('*')).length;
+            log(GREEN, 'FEEDBACK', `Saved ${count} learnings from human feedback`);
+        }
+        else {
+            log(DIM, 'FEEDBACK', 'No new learnings from feedback');
+        }
+        // Mark as processed with a summary comment
+        const feedbackSummary = comments.map(c => `- ${c.author}: "${c.text.slice(0, 100)}${c.text.length > 100 ? '...' : ''}"`).join('\n');
+        const learningNote = trimmed && !trimmed.toLowerCase().includes('no new learnings')
+            ? 'Learnings saved to project memory.'
+            : 'No new learnings extracted.';
+        await addComment(ticket.id, `🔄 Feedback processed\n\nComments analyzed:\n${feedbackSummary}\n\n${learningNote}`);
+        if (status === CONFIG.COLUMNS.DONE) {
+            await trySetDate(ticket.id, 'Done At');
+        }
+        log(GREEN, 'FEEDBACK', `Done processing feedback for "${ticket.title}"`);
+    }
+    catch (e) {
+        // Feedback is best-effort
+        log(YELLOW, 'FEEDBACK', `Failed: ${e instanceof Error ? e.message : e}`);
+    }
+}
 async function runExecuteAgent(ticket) {
     const projectDir = getProjectDir(ticket.project);
     if (!projectDir) {
@@ -303,6 +579,7 @@ async function runExecuteAgent(ticket) {
     createWorktree(projectDir, branchName, worktreeDir, baseBranch);
     let cost = 0;
     let commitCount = 0;
+    let retroOutcome = { success: false };
     try {
         const promptParts = [
             executePrompt,
@@ -402,6 +679,7 @@ async function runExecuteAgent(ticket) {
         const diffReview = await runDiffReviewAgent(worktreeDir, baseBranch, ticket.spec ?? '', ticket.description, []);
         cost += diffReview.cost;
         if (!diffReview.result.approved) {
+            retroOutcome = { success: false, error: 'Diff review rejected the changes', diffReviewIssues: diffReview.result.issues };
             throw new Error(`Diff review failed:\n${diffReview.result.issues.map(i => `  - ${i}`).join('\n')}`);
         }
         log(GREEN, 'REVIEW', `Diff review passed: ${diffReview.result.summary}`);
@@ -459,7 +737,7 @@ async function runExecuteAgent(ticket) {
                     `[View in Notion](https://www.notion.so/${ticket.id.replace(/-/g, '')})`,
                     '',
                     '---',
-                    `Cost: $${cost.toFixed(2)} | Review: Ease ${extractNumber(ticket, 'ease')}/10, Confidence ${extractNumber(ticket, 'confidence')}/10`,
+                    `Cost: $${cost.toFixed(2)} | Review: Ease ${ticket.ease ?? '?'}/10, Confidence ${ticket.confidence ?? '?'}/10`,
                 ].join('\n');
                 const prResult = execSync(`gh pr create --title ${shellEscape(ticket.title)} --body ${shellEscape(prBody)} --base ${shellEscape(baseBranch)} --head ${branchName}`, { cwd: worktreeDir, stdio: 'pipe', timeout: 30_000 });
                 prUrl = prResult.toString().trim();
@@ -472,7 +750,7 @@ async function runExecuteAgent(ticket) {
         }
         // Update Notion
         await writeExecutionResults(ticket.id, { branch: branchName, cost, prUrl });
-        await moveTicketStatus(ticket.id, CONFIG.COLUMNS.DONE);
+        await moveTicketStatus(ticket.id, CONFIG.COLUMNS.TESTING);
         const duration = Math.round((Date.now() - startTime) / 1000);
         // Add success audit trail comment
         const comment = [
@@ -484,11 +762,7 @@ async function runExecuteAgent(ticket) {
             `Cost: $${cost.toFixed(2)} | Duration: ${duration}s`,
         ].join('\n');
         await addComment(ticket.id, comment);
-        appendLearning(projectDir, [
-            `**Execute: ${ticket.title}**`,
-            `Branch: ${branchName}, Commits: ${commitCount}`,
-            `Cost: $${cost.toFixed(2)}`,
-        ].join('\n'));
+        retroOutcome = { success: true };
         log(GREEN, 'EXECUTE', `Done: branch=${branchName} cost=$${cost.toFixed(2)}${prUrl ? ` pr=${prUrl}` : ''}`);
     }
     catch (error) {
@@ -502,13 +776,17 @@ async function runExecuteAgent(ticket) {
             `Cost: $${cost.toFixed(2)} | Duration: ${duration}s`,
         ].join('\n');
         await addComment(ticket.id, comment);
-        appendLearning(projectDir, [
-            `**Failed execute: ${ticket.title}**`,
-            `Error: ${errMsg.slice(0, 200)}`,
-        ].join('\n'));
+        retroOutcome = {
+            success: false,
+            error: errMsg,
+            buildFailed: errMsg.includes('Build validation failed'),
+        };
         throw error;
     }
     finally {
+        // Run retro before cleaning up worktree (so it can read the diff)
+        log(DIM, 'RETRO', 'Running post-execution retrospective...');
+        await runRetroAgent(projectDir, worktreeDir, baseBranch, ticket, retroOutcome);
         // Always clean up the worktree
         removeWorktree(projectDir, worktreeDir);
     }
@@ -589,20 +867,35 @@ async function poll() {
     try {
         // Clear stale locks
         clearStaleLocks();
-        // Fetch tickets in Review and Execute columns
-        const [reviewTickets, executeTickets] = await Promise.all([
+        // Fetch tickets in Review, Execute, Testing, Done, and Failed columns
+        const [reviewTickets, executeTickets, testingTickets, doneTickets, failedTickets] = await Promise.all([
             fetchTicketsByStatus(CONFIG.COLUMNS.REVIEW),
             fetchTicketsByStatus(CONFIG.COLUMNS.EXECUTE),
+            fetchTicketsByStatus(CONFIG.COLUMNS.TESTING),
+            fetchTicketsByStatus(CONFIG.COLUMNS.DONE),
+            fetchTicketsByStatus(CONFIG.COLUMNS.FAILED),
         ]);
         const pendingReview = reviewTickets.filter((t) => !activeLocks.has(t.id));
         const pendingExecute = executeTickets.filter((t) => !activeLocks.has(t.id));
+        const pendingTesting = testingTickets.filter((t) => !testingNotified.has(t.id));
+        // Feedback candidates: Done tickets + Failed tickets (both can have human comments)
+        const pendingFeedback = [
+            ...doneTickets.map(t => ({ ...t, feedbackStatus: CONFIG.COLUMNS.DONE })),
+            ...failedTickets.map(t => ({ ...t, feedbackStatus: CONFIG.COLUMNS.FAILED })),
+        ].filter((t) => !feedbackProcessed.has(t.id));
         if (pendingReview.length > 0) {
             log(CYAN, 'POLL', `Found ${pendingReview.length} ticket(s) to review`);
         }
         if (pendingExecute.length > 0) {
             log(MAGENTA, 'POLL', `Found ${pendingExecute.length} ticket(s) to execute`);
         }
-        if (pendingReview.length === 0 && pendingExecute.length === 0) {
+        if (pendingTesting.length > 0) {
+            log(YELLOW, 'POLL', `Found ${pendingTesting.length} ticket(s) needing test checklists`);
+        }
+        if (pendingFeedback.length > 0) {
+            log(GREEN, 'POLL', `Found ${pendingFeedback.length} ticket(s) to check for feedback`);
+        }
+        if (pendingReview.length === 0 && pendingExecute.length === 0 && pendingTesting.length === 0 && pendingFeedback.length === 0) {
             log(DIM, 'POLL', 'No tickets to process');
         }
         if (DRY_RUN)
@@ -631,6 +924,26 @@ async function poll() {
                 log(RED, 'UNHANDLED', `Unexpected error in ${mode} for "${details.title}": ${err instanceof Error ? err.message : err}`);
             });
         }
+        // Post test checklists for Testing tickets (lightweight, no AI agent)
+        for (const ticket of pendingTesting) {
+            if (shuttingDown)
+                break;
+            testingNotified.add(ticket.id);
+            const details = await fetchTicketDetails(ticket.id);
+            postTestChecklist(details).catch((err) => {
+                log(YELLOW, 'TESTING', `Error posting checklist for "${details.title}": ${err instanceof Error ? err.message : err}`);
+            });
+        }
+        // Process feedback for Done and Failed tickets (lightweight, doesn't count toward concurrency)
+        for (const ticket of pendingFeedback) {
+            if (shuttingDown)
+                break;
+            feedbackProcessed.add(ticket.id);
+            const details = await fetchTicketDetails(ticket.id);
+            runFeedbackRetro(details, ticket.feedbackStatus).catch((err) => {
+                log(YELLOW, 'FEEDBACK', `Error processing feedback for "${details.title}": ${err instanceof Error ? err.message : err}`);
+            });
+        }
     }
     catch (error) {
         const errMsg = error instanceof Error ? error.message : String(error);

package/dist/lib/notion.d.ts

@@ -4,6 +4,10 @@ export declare function extractPlainText(richText: RichTextItemResponse[]): stri
 export declare function extractProjectName(page: PageObjectResponse): string;
 export declare function pageToTicket(page: PageObjectResponse): NotionTicket;
 export declare function blockToMarkdown(block: BlockObjectResponse): string;
+/**
+ * Set a date property on a page (best-effort — skips silently if property doesn't exist).
+ */
+export declare function trySetDate(pageId: string, propertyName: string): Promise<void>;
 /**
  * Fetch all tickets with a given status from the Notion database.
  */
@@ -37,6 +41,17 @@ export declare function writeFailure(pageId: string, error: string): Promise<voi
  * Used for agent audit trail - does not throw if it fails.
  */
 export declare function addComment(pageId: string, text: string): Promise<void>;
+/**
+ * Fetch all comments on a Notion page.
+ * Returns human comments (filters out bot-authored comments from this integration).
+ */
+export declare function fetchComments(pageId: string): Promise<Array<{
+    author: string;
+    text: string;
+    createdTime: string;
+}>>;
+export declare function hasFeedbackMarker(pageId: string): Promise<boolean>;
+export declare function hasTestingMarker(pageId: string): Promise<boolean>;
 export declare function truncate(str: string, maxLen: number): string;
 /** Chunk text into Notion rich_text segments (each max 2000 chars). */
 export declare function chunkRichText(str: string): Array<{

package/dist/lib/notion.js

@@ -26,6 +26,10 @@ function extractRichText(page, name) {
     const prop = getProperty(page, name);
     return prop?.rich_text ? extractPlainText(prop.rich_text) : '';
 }
+function extractNumber(page, name) {
+    const prop = getProperty(page, name);
+    return prop?.number ?? undefined;
+}
 function extractSelect(page, name) {
     const prop = getProperty(page, name);
     return prop?.select?.name ?? '';
@@ -90,6 +94,26 @@ export function blockToMarkdown(block) {
             return text;
     }
 }
+function nowISO() {
+    return new Date().toISOString();
+}
+function dateProperty(iso) {
+    return { date: { start: iso } };
+}
+/**
+ * Set a date property on a page (best-effort — skips silently if property doesn't exist).
+ */
+export async function trySetDate(pageId, propertyName) {
+    try {
+        await notion().pages.update({
+            page_id: pageId,
+            properties: { [propertyName]: dateProperty(nowISO()) },
+        });
+    }
+    catch {
+        // Property might not exist yet — skip silently
+    }
+}
 // -- Exported Functions --
 /**
  * Fetch all tickets with a given status from the Notion database.
@@ -123,6 +147,8 @@ export async function fetchTicketDetails(pageId) {
         bodyBlocks,
         spec: extractRichText(page, 'Spec') || undefined,
         impact: extractRichText(page, 'Impact') || undefined,
+        ease: extractNumber(page, 'Ease'),
+        confidence: extractNumber(page, 'Confidence'),
     };
 }
 /**
@@ -144,15 +170,21 @@ export async function writeReviewResults(pageId, results) {
         Impact: {
             rich_text: chunkRichText(`${results.impactReport}\n\nFiles: ${results.affectedFiles.join(', ')}${results.risks ? `\n\nRisks: ${results.risks}` : ''}`),
         },
+        'Reviewed At': dateProperty(nowISO()),
     };
     try {
         await notion().pages.update({ page_id: pageId, properties });
     }
     catch (e) {
-        // If Confidence property doesn't exist yet, retry without it
         const errMsg = String(e);
+        // If a property doesn't exist yet, retry without it
         if (errMsg.includes('Confidence')) {
             delete properties.Confidence;
+        }
+        if (errMsg.includes('Reviewed At')) {
+            delete properties['Reviewed At'];
+        }
+        if (errMsg.includes('Confidence') || errMsg.includes('Reviewed At')) {
             await notion().pages.update({ page_id: pageId, properties });
         }
         else {
@@ -172,13 +204,26 @@ export async function writeExecutionResults(pageId, results) {
         Cost: {
             rich_text: [{ text: { content: `$${(Math.round(results.cost * 100) / 100).toFixed(2)}` } }],
         },
+        'Executed At': dateProperty(nowISO()),
     };
     if (results.prUrl) {
         properties['PR URL'] = {
             url: results.prUrl,
         };
     }
-    await notion().pages.update({ page_id: pageId, properties });
+    try {
+        await notion().pages.update({ page_id: pageId, properties });
+    }
+    catch (e) {
+        const errMsg = String(e);
+        if (errMsg.includes('Executed At')) {
+            delete properties['Executed At'];
+            await notion().pages.update({ page_id: pageId, properties });
+        }
+        else {
+            throw e;
+        }
+    }
 }
 /**
  * Move a ticket to a new status column.
@@ -195,15 +240,27 @@ export async function moveTicketStatus(pageId, newStatus) {
  * Write error details and move ticket to Failed.
  */
 export async function writeFailure(pageId, error) {
-    await notion().pages.update({
-        page_id: pageId,
-        properties: {
-            Status: { status: { name: CONFIG.COLUMNS.FAILED } },
-            Impact: {
-                rich_text: chunkRichText(`ERROR: ${error}`),
-            },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const properties = {
+        Status: { status: { name: CONFIG.COLUMNS.FAILED } },
+        Impact: {
+            rich_text: chunkRichText(`ERROR: ${error}`),
         },
-    });
+        'Failed At': dateProperty(nowISO()),
+    };
+    try {
+        await notion().pages.update({ page_id: pageId, properties });
+    }
+    catch (e) {
+        const errMsg = String(e);
+        if (errMsg.includes('Failed At')) {
+            delete properties['Failed At'];
+            await notion().pages.update({ page_id: pageId, properties });
+        }
+        else {
+            throw e;
+        }
+    }
 }
 /**
  * Add a comment to a Notion page (best-effort).
@@ -221,6 +278,66 @@ export async function addComment(pageId, text) {
         console.warn(`[NOTION] Failed to add comment to ${pageId}:`, e);
     }
 }
+/**
+ * Fetch all comments on a Notion page.
+ * Returns human comments (filters out bot-authored comments from this integration).
+ */
+export async function fetchComments(pageId) {
+    try {
+        const response = await notion().comments.list({ block_id: pageId });
+        const comments = [];
+        for (const comment of response.results) {
+            // Skip bot-authored comments (our own audit trail)
+            const createdBy = comment.created_by;
+            if (createdBy?.type === 'bot')
+                continue;
+            const text = 'rich_text' in comment
+                ? extractPlainText(comment.rich_text)
+                : '';
+            if (!text.trim())
+                continue;
+            comments.push({
+                author: createdBy?.name || 'Unknown',
+                text: text.trim(),
+                createdTime: comment.created_time,
+            });
+        }
+        return comments;
+    }
+    catch (e) {
+        console.warn(`[NOTION] Failed to fetch comments for ${pageId}:`, e);
+        return [];
+    }
+}
+/**
+ * Check if a ticket already has a specific bot marker comment.
+ * Used for cross-session deduplication.
+ */
+async function hasBotMarker(pageId, marker) {
+    try {
+        const response = await notion().comments.list({ block_id: pageId });
+        for (const comment of response.results) {
+            const createdBy = comment.created_by;
+            if (createdBy?.type !== 'bot')
+                continue;
+            const text = 'rich_text' in comment
+                ? extractPlainText(comment.rich_text)
+                : '';
+            if (text.includes(marker))
+                return true;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+export function hasFeedbackMarker(pageId) {
+    return hasBotMarker(pageId, 'Feedback processed');
+}
+export function hasTestingMarker(pageId) {
+    return hasBotMarker(pageId, 'Ready for Testing');
+}
 export function truncate(str, maxLen) {
     if (str.length <= maxLen)
         return str;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticket-to-pr",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "Drag a Notion ticket, get a pull request. AI-powered dev automation.",
   "type": "module",
   "bin": {

package/prompts/feedback.md

@@ -0,0 +1,34 @@
+You are analyzing human feedback on AI-generated code changes.
+
+## Your Task
+A human (PM, designer, developer, QA tester, or founder) reviewed the result of an AI agent's work and left comments on the Notion ticket. Extract actionable learnings from their feedback that will help future agent runs on this same project. You are writing notes for a future AI agent, not a human.
+
+## What to Look For
+
+### On Success (ticket status: Done)
+- **What the human liked**: patterns, code style, thoroughness that should be repeated
+- **What worked well in production**: successful deployment, no regressions
+- **What could be better**: minor issues that didn't block approval but should be improved next time
+- **Preferences revealed**: the human's style preferences, naming conventions, UX expectations
+
+### On Failure (ticket status: Failed)
+- **What broke from the user's perspective**: not the agent error message, but what the human actually experienced
+- **Root cause insight**: the human often knows WHY something failed better than the error log
+- **What the human expected vs what happened**: gap between intent and implementation
+- **Scope issues**: was the change too big, too small, missing context, or in the wrong place?
+
+### Implicit Signals
+- If the human just says "looks good" or "works" — not much to learn
+- If the human gives detailed feedback — they care about quality, extract everything
+- If multiple people comment — note which role cares about what (PM vs dev vs designer)
+
+## Output Rules
+- Write 1-4 bullet points. Each must be a specific, actionable lesson from the human's perspective.
+- Start each bullet with a category tag: `[feedback]`, `[preference]`, `[bug]`, or `[quality]`
+- Translate vague human feedback into specific technical guidance for the AI agent:
+  - "This doesn't look right" on a UI change → `[preference] Stakeholders in this project prefer X style over Y`
+  - "It broke the login" → `[bug] Changes to auth-related files can break the login flow — always test auth after touching these files`
+  - "Wrong approach" → `[feedback] For this type of change, the preferred pattern is X (not Y)`
+- If the feedback is just "looks good", "approved", "works", or similar with no specific lessons, write: `No new learnings.`
+- Don't repeat lessons that already exist in the project learnings.
+- Be specific to THIS project. Generic advice is useless.

package/prompts/retro.md

@@ -0,0 +1,27 @@
+You are conducting a retrospective on an AI agent's work on a codebase.
+
+## Your Task
+Analyze what happened during this ticket execution and extract lessons that will help future agent runs on this same project. You are writing notes for a future AI agent, not a human.
+
+## What to Look For
+
+### On Success
+- **Conventions discovered**: file naming, import patterns, export style, component structure, API response shapes, error handling patterns
+- **What worked**: approaches or patterns that led to clean implementation
+- **Codebase quirks**: path aliases, custom configs, non-obvious setup requirements, framework-specific patterns
+
+### On Failure
+- **Root cause**: what specifically went wrong and why (not just the error message)
+- **What to do differently**: concrete, actionable advice for next time
+- **Codebase constraints**: things the agent didn't know about that caused the failure
+
+### Always
+- **Capability assessment**: what types of changes are easy/hard in this project
+- **Suggestions**: improvements to the project's CLAUDE.md or configuration that would help future runs
+
+## Output Rules
+- Write 2-5 bullet points. Each must be a specific, actionable lesson.
+- Start each bullet with a category tag: `[convention]`, `[mistake]`, `[capability]`, or `[suggestion]`
+- Be specific to THIS project. "Use TypeScript" is useless. "This project uses strict TypeScript with no implicit any — always add explicit return types on exported functions" is useful.
+- Don't repeat lessons that already exist in the project learnings.
+- If nothing useful was learned (e.g., trivial change, obvious outcome), just write: `No new learnings.`