whitesmith 0.0.1 → 0.0.2

package/src/harnesses/pi.ts

@@ -1,8 +1,26 @@
 import {exec, execSync} from 'node:child_process';
 import * as fs from 'node:fs';
+import {homedir} from 'node:os';
 import * as path from 'node:path';
 import type {AgentHarness, AgentHarnessConfig} from './agent-harness.js';
 
+/** Subset of pi JSON event fields we care about */
+interface PiEvent {
+	type: string;
+	toolName?: string;
+	args?: any;
+	result?: any;
+	isError?: boolean;
+	assistantMessageEvent?: {type: string; delta?: string};
+	reason?: string;
+	attempt?: number;
+	maxAttempts?: number;
+	delayMs?: number;
+	errorMessage?: string;
+	success?: boolean;
+	finalError?: string;
+}
+
 /**
  * Agent harness for @mariozechner/pi-coding-agent.
  *
@@ -31,10 +49,30 @@ export class PiHarness implements AgentHarness {
 			);
 		}
 
+		// Check auth.json exists and has the expected provider
+		const homeDir = process.env.HOME || homedir();
+		const authJsonPath = path.join(homeDir, '.pi', 'agent', 'auth.json');
+		if (fs.existsSync(authJsonPath)) {
+			try {
+				const authData = JSON.parse(fs.readFileSync(authJsonPath, 'utf-8'));
+				const providers = Object.keys(authData);
+				console.log(`Auth file found at ${authJsonPath} with providers: ${providers.join(', ')}`);
+				if (!authData[this.provider]) {
+					console.warn(
+						`WARNING: Provider '${this.provider}' not found in auth.json (has: ${providers.join(', ')})`,
+					);
+				}
+			} catch (e: any) {
+				console.warn(`WARNING: Could not parse auth.json: ${e.message}`);
+			}
+		} else {
+			console.warn(`WARNING: No auth.json found at ${authJsonPath}`);
+		}
+
 		// Validate auth by making a minimal API call
 		try {
 			const result = execSync(
-				`${this.cmd} --print --no-tools --provider ${this.provider} --model ${this.model} "respond with OK"`,
+				`${this.cmd} --print --no-tools --no-session --provider ${this.provider} --model ${this.model} "respond with OK"`,
 				{stdio: 'pipe', timeout: 30_000},
 			);
 			const output = result.toString().trim();
@@ -43,11 +81,17 @@ export class PiHarness implements AgentHarness {
 			}
 			console.log(`Auth check passed (response: ${output.slice(0, 20)})`);
 		} catch (error: any) {
-			const stderr = error.stderr?.toString() || error.message || '';
+			const stderr = error.stderr?.toString() || '';
+			const stdout = error.stdout?.toString() || '';
+			const details =
+				[stderr, stdout].filter(Boolean).join('\n') || error.message || 'unknown error';
 			throw new Error(
 				`Agent auth validation failed. Ensure valid credentials are configured.\n` +
 					`Set ANTHROPIC_API_KEY or configure OAuth via ~/.pi/agent/auth.json\n` +
-					`Details: ${stderr.slice(0, 500)}`,
+					`Auth file path: ${authJsonPath}\n` +
+					`Auth file exists: ${fs.existsSync(authJsonPath)}\n` +
+					`HOME: ${homeDir}\n` +
+					`Details: ${details.slice(0, 800)}`,
 			);
 		}
 	}
@@ -57,13 +101,13 @@ export class PiHarness implements AgentHarness {
 		workDir: string;
 		logFile?: string;
 	}): Promise<{output: string; exitCode: number}> {
-		// Write prompt to a temp file to avoid shell escaping issues
+		// Write prompt to a temp file and use @file syntax so pi reads contents
 		const promptFile = path.join(options.workDir, '.whitesmith-prompt.md');
 		fs.writeFileSync(promptFile, options.prompt, 'utf-8');
 
 		try {
 			const result = await this.exec(
-				`${this.cmd} --prompt-file "${promptFile}" --yes --provider ${this.provider} --model ${this.model}`,
+				`${this.cmd} --print --mode json --no-session --provider ${this.provider} --model ${this.model} @"${promptFile}"`,
 				options.workDir,
 				options.logFile,
 			);
@@ -78,6 +122,43 @@ export class PiHarness implements AgentHarness {
 		}
 	}
 
+	/** Format a pi JSON event as a human-readable log line (null = skip) */
+	private formatEvent(event: PiEvent): string | null {
+		switch (event.type) {
+			case 'agent_start':
+				return '\n🤖 Agent started';
+			case 'agent_end':
+				return '\n🏁 Agent finished';
+			case 'turn_start':
+				return '\n--- turn ---';
+			case 'message_update': {
+				const evt = event.assistantMessageEvent;
+				if (evt?.type === 'text_delta' && evt.delta) return evt.delta;
+				if (evt?.type === 'thinking_delta' && evt.delta) return evt.delta;
+				return null;
+			}
+			case 'tool_execution_start': {
+				const argsStr = JSON.stringify(event.args);
+				const truncArgs = argsStr.length > 200 ? argsStr.slice(0, 200) + '…' : argsStr;
+				return `\n🔧 ${event.toolName}(${truncArgs})`;
+			}
+			case 'tool_execution_end': {
+				const icon = event.isError ? '❌' : '✅';
+				const res = typeof event.result === 'string' ? event.result : JSON.stringify(event.result);
+				const truncRes = res.length > 500 ? res.slice(0, 500) + '…' : res;
+				return `${icon} ${event.toolName} → ${truncRes}`;
+			}
+			case 'compaction_start':
+				return `\n📦 Compaction (${event.reason})`;
+			case 'auto_retry_start':
+				return `\n🔄 Retry ${event.attempt}/${event.maxAttempts}: ${event.errorMessage}`;
+			case 'auto_retry_end':
+				return event.success ? '🔄 Retry succeeded' : `🔄 Retry failed: ${event.finalError}`;
+			default:
+				return null;
+		}
+	}
+
 	private exec(
 		cmd: string,
 		workDir: string,
@@ -90,15 +171,35 @@ export class PiHarness implements AgentHarness {
 				timeout: 30 * 60 * 1000, // 30 minute timeout
 			});
 
+			// Close stdin immediately so pi doesn't hang waiting for piped input
+			child.stdin?.end();
+
 			let output = '';
+			let lineBuffer = '';
 			const logStream = logFile
 				? fs.createWriteStream(path.resolve(workDir, logFile), {flags: 'a'})
 				: null;
 
+			const processLine = (line: string) => {
+				if (!line.trim()) return;
+				try {
+					const event: PiEvent = JSON.parse(line);
+					const formatted = this.formatEvent(event);
+					if (formatted !== null) {
+						process.stdout.write(formatted);
+					}
+				} catch {
+					process.stdout.write(line + '\n');
+				}
+			};
+
 			child.stdout?.on('data', (data: string) => {
 				output += data;
-				process.stdout.write(data);
 				logStream?.write(data);
+				lineBuffer += data;
+				const lines = lineBuffer.split('\n');
+				lineBuffer = lines.pop() ?? '';
+				for (const line of lines) processLine(line);
 			});
 
 			child.stderr?.on('data', (data: string) => {
@@ -108,6 +209,7 @@ export class PiHarness implements AgentHarness {
 			});
 
 			child.on('close', (code) => {
+				if (lineBuffer.trim()) processLine(lineBuffer);
 				logStream?.end();
 				resolve({output, exitCode: code ?? 1});
 			});

package/src/orchestrator.ts

@@ -5,6 +5,7 @@ import type {AgentHarness} from './harnesses/agent-harness.js';
 import {TaskManager} from './task-manager.js';
 import {GitManager} from './git.js';
 import {buildInvestigatePrompt, buildImplementPrompt} from './prompts.js';
+import {isAutoWorkEnabled} from './auto-work.js';
 
 /**
  * Main orchestrator for whitesmith.
@@ -12,7 +13,11 @@ import {buildInvestigatePrompt, buildImplementPrompt} from './prompts.js';
  * The loop:
  * 1. Reconcile — check if any issues with tasks-accepted have all tasks done
  * 2. Investigate — pick an unlabeled issue, generate tasks
- * 3. Implement — pick an available task, implement it
+ * 3. Implement — pick an available task, implement it on the issue/<number> branch
+ *
+ * Implementation uses a single branch per issue (`issue/<number>`). Each task
+ * adds one commit to the branch. When the last task completes, a PR is created
+ * immediately. `reconcile()` is a safety net for crash recovery.
  */
 export class Orchestrator {
 	private config: DevPulseConfig;
@@ -41,13 +46,16 @@ export class Orchestrator {
 		console.log(`Model: ${this.config.model}`);
 		console.log('');
 
-		// Validate agent is available before doing anything
-		await this.agent.validate();
-		console.log('Agent validated successfully.');
-		console.log('');
+		// Skip agent validation and label creation in dry-run mode
+		if (!this.config.dryRun) {
+			// Validate agent is available before doing anything
+			await this.agent.validate();
+			console.log('Agent validated successfully.');
+			console.log('');
 
-		// Ensure labels exist
-		await this.issues.ensureLabels(Object.values(LABELS));
+			// Ensure labels exist
+			await this.issues.ensureLabels(Object.values(LABELS));
+		}
 
 		for (let i = 1; i <= this.config.maxIterations; i++) {
 			console.log('');
@@ -61,10 +69,38 @@ export class Orchestrator {
 			const action = await this.decideAction();
 			console.log(`Action: ${action.type}`);
 
+			if (this.config.dryRun) {
+				switch (action.type) {
+					case 'reconcile':
+						console.log(`Would reconcile issue #${action.issue.number}: ${action.issue.title}`);
+						break;
+					case 'auto-approve':
+						console.log(
+							`Would auto-approve task PR for issue #${action.issue.number}: ${action.issue.title}`,
+						);
+						break;
+					case 'investigate':
+						console.log(`Would investigate issue #${action.issue.number}: ${action.issue.title}`);
+						break;
+					case 'implement':
+						console.log(
+							`Would implement task ${action.task.id}: ${action.task.title} (issue #${action.issue.number})`,
+						);
+						break;
+					case 'idle':
+						console.log('Nothing to do. All issues are either in-progress or completed.');
+						break;
+				}
+				return;
+			}
+
 			switch (action.type) {
 				case 'reconcile':
 					await this.reconcile(action.issue);
 					break;
+				case 'auto-approve':
+					await this.autoApprove(action.issue);
+					break;
 				case 'investigate':
 					await this.investigate(action.issue);
 					break;
@@ -86,6 +122,20 @@ export class Orchestrator {
 		console.log('=== Iteration limit reached ===');
 	}
 
+	/**
+	 * Check whether all tasks for an issue have been completed on the issue branch.
+	 * Works without checking out the branch by inspecting the remote via git ls-tree.
+	 */
+	private async allTasksCompletedOnBranch(issueNumber: number): Promise<boolean> {
+		const branch = `issue/${issueNumber}`;
+		const branchExists = await this.issues.remoteBranchExists(branch);
+		if (!branchExists) return false;
+
+		// Check if any task files remain on the issue branch
+		const hasFiles = await this.git.remotePathHasFiles(`origin/${branch}`, `tasks/${issueNumber}/`);
+		return !hasFiles;
+	}
+
 	/**
 	 * Decide the next action to take
 	 */
@@ -93,18 +143,27 @@ export class Orchestrator {
 		// Priority 1: Reconcile — issues with tasks-accepted where all tasks are done
 		const acceptedIssues = await this.issues.listIssues({labels: [LABELS.TASKS_ACCEPTED]});
 		for (const issue of acceptedIssues) {
-			if (!this.tasks.hasRemainingTasks(issue.number)) {
+			const allDone = await this.allTasksCompletedOnBranch(issue.number);
+			if (allDone) {
 				return {type: 'reconcile', issue};
 			}
 		}
 
-		// Priority 2: Implement — find an available task
+		// Priority 2: Auto-approve — merge task PRs for issues with auto-work enabled
+		const proposedIssues = await this.issues.listIssues({labels: [LABELS.TASKS_PROPOSED]});
+		for (const issue of proposedIssues) {
+			if (isAutoWorkEnabled(this.config, issue)) {
+				return {type: 'auto-approve' as const, issue};
+			}
+		}
+
+		// Priority 3: Implement — find an available task
 		const implementAction = await this.findAvailableTask(acceptedIssues);
 		if (implementAction) {
 			return implementAction;
 		}
 
-		// Priority 3: Investigate — find a new issue (no whitesmith labels)
+		// Priority 4: Investigate — find a new issue (no whitesmith labels)
 		const allDevPulseLabels = Object.values(LABELS);
 		const newIssues = await this.issues.listIssues({noLabels: allDevPulseLabels});
 		if (newIssues.length > 0) {
@@ -117,26 +176,47 @@ export class Orchestrator {
 	}
 
 	/**
-	 * Find an available task to implement
+	 * Find an available task to implement.
+	 *
+	 * Uses task files on `main` as the canonical list of pending tasks.
+	 * If an issue branch exists, checks which task files have been deleted
+	 * on it (= completed) and skips those.
 	 */
 	private async findAvailableTask(
 		acceptedIssues: Issue[],
 	): Promise<{type: 'implement'; task: Task; issue: Issue} | null> {
 		for (const issue of acceptedIssues) {
 			const issueTasks = this.tasks.listTasks(issue.number);
+			if (issueTasks.length === 0) continue;
+
+			// Determine which tasks are already completed on the issue branch
+			const branch = `issue/${issue.number}`;
+			const branchExists = await this.issues.remoteBranchExists(branch);
+			const completedTaskFiles = new Set<string>();
+
+			if (branchExists) {
+				// Check each task file's existence on the remote issue branch
+				for (const task of issueTasks) {
+					const existsOnBranch = await this.git.remoteFileExists(`origin/${branch}`, task.filePath);
+					if (!existsOnBranch) {
+						// Task file deleted on issue branch = completed
+						completedTaskFiles.add(task.filePath);
+					}
+				}
+			}
 
 			for (const task of issueTasks) {
-				// Check dependencies are satisfied
-				if (!this.tasks.areDependenciesSatisfied(task)) {
-					continue;
-				}
+				// Skip completed tasks
+				if (completedTaskFiles.has(task.filePath)) continue;
 
-				// Check if someone is already working on it (branch exists)
-				const branch = `task/${task.id}`;
-				const branchExists = await this.issues.remoteBranchExists(branch);
-				if (branchExists) {
-					continue;
-				}
+				// Check dependencies are satisfied
+				// A dependency is satisfied if its task file is gone from main OR completed on the issue branch
+				const depsOk = task.dependsOn.every((depId) => {
+					const depTask = issueTasks.find((t) => t.id === depId);
+					if (!depTask) return true; // dep not in pending list on main = already merged
+					return completedTaskFiles.has(depTask.filePath);
+				});
+				if (!depsOk) continue;
 
 				return {type: 'implement', task, issue};
 			}
@@ -146,12 +226,36 @@ export class Orchestrator {
 	}
 
 	/**
-	 * Phase 1: Reconcile — mark issue as completed, close it
+	 * Phase 1: Reconcile — mark issue as completed, close it.
+	 * Also serves as safety net: creates PR if all tasks are done but no PR exists
+	 * (e.g. agent crashed after last task push but before PR creation).
 	 */
 	private async reconcile(issue: Issue): Promise<void> {
 		console.log(`Reconciling issue #${issue.number}: ${issue.title}`);
 		console.log('All tasks completed. Marking issue as done.');
 
+		// Safety net: ensure a PR exists for the issue branch
+		const branch = `issue/${issue.number}`;
+		const branchExists = await this.issues.remoteBranchExists(branch);
+		if (branchExists && !this.config.noPush) {
+			const existingPR = await this.issues.getPRForBranch(branch);
+			if (!existingPR) {
+				console.log(`Safety net: creating PR for ${branch} (missed during implement)`);
+				const issueTasks = this.tasks.listTasks(issue.number);
+				const taskSummary =
+					issueTasks.length > 0
+						? issueTasks.map((t) => `- ✅ **${t.id}**: ${t.title}`).join('\n')
+						: '- All tasks completed';
+				const prUrl = await this.issues.createPR({
+					head: branch,
+					base: 'main',
+					title: `feat(#${issue.number}): ${issue.title}`,
+					body: `## Implementation for #${issue.number}\n\n${taskSummary}\n\n---\n*Implemented by whitesmith*\n\nCloses #${issue.number}`,
+				});
+				console.log(`Safety net PR created: ${prUrl}`);
+			}
+		}
+
 		await this.issues.addLabel(issue.number, LABELS.COMPLETED);
 		await this.issues.removeLabel(issue.number, LABELS.TASKS_ACCEPTED);
 		await this.issues.comment(
@@ -163,6 +267,33 @@ export class Orchestrator {
 		console.log(`Issue #${issue.number} closed.`);
 	}
 
+	/**
+	 * Phase 1.5: Auto-approve — merge the task-proposal PR when auto-work is enabled
+	 */
+	private async autoApprove(issue: Issue): Promise<void> {
+		console.log(`Auto-approving task PR for issue #${issue.number}: ${issue.title}`);
+
+		const branch = `investigate/${issue.number}`;
+		const pr = await this.issues.getPRForBranch(branch);
+
+		if (!pr || pr.state !== 'open') {
+			console.log(`No open PR found for branch '${branch}', skipping auto-approve`);
+			return;
+		}
+
+		await this.issues.mergePR(pr.number);
+		console.log(`Merged PR #${pr.number}: ${pr.url}`);
+
+		await this.issues.removeLabel(issue.number, LABELS.TASKS_PROPOSED);
+		await this.issues.addLabel(issue.number, LABELS.TASKS_ACCEPTED);
+		await this.issues.comment(
+			issue.number,
+			`🤖 Task PR #${pr.number} has been auto-approved and merged. Tasks are now on \`main\`.`,
+		);
+
+		console.log(`Issue #${issue.number} transitioned to tasks-accepted.`);
+	}
+
 	/**
 	 * Phase 2: Investigate — generate tasks for a new issue
 	 */
@@ -176,23 +307,47 @@ export class Orchestrator {
 		const issueTasksDir = `tasks/${issue.number}`;
 
 		try {
-			// Create branch from main
+			// Check if a previous attempt already produced work on this branch
+			const remoteBranchExists = await this.issues.remoteBranchExists(branch);
+			let agentNeeded = true;
+
 			await this.git.deleteLocalBranch(branch);
-			await this.git.checkout(branch, {create: true, startPoint: 'origin/main'});
-
-			// Run agent to generate tasks
-			const prompt = buildInvestigatePrompt(issue, issueTasksDir);
-			const {exitCode} = await this.agent.run({
-				prompt,
-				workDir: this.config.workDir,
-				logFile: this.config.logFile,
-			});
-
-			if (exitCode !== 0) {
-				console.error(`Agent failed with exit code ${exitCode}`);
-				await this.issues.removeLabel(issue.number, LABELS.INVESTIGATING);
-				await this.git.checkoutMain();
-				return;
+
+			if (remoteBranchExists) {
+				// Checkout the existing remote branch to inspect it
+				await this.git.checkout(branch, {create: true, startPoint: `origin/${branch}`});
+				const existingTasks = this.tasks.listTasks(issue.number);
+				if (existingTasks.length > 0) {
+					// Previous attempt completed the work — skip the agent
+					console.log(
+						`Branch '${branch}' already exists with ${existingTasks.length} task(s), skipping agent`,
+					);
+					agentNeeded = false;
+				} else {
+					// Branch exists but no task files — start fresh
+					console.log(`Branch '${branch}' exists but has no tasks, starting fresh`);
+					await this.git.deleteLocalBranch(branch);
+					await this.git.checkout(branch, {create: true, startPoint: 'origin/main'});
+				}
+			} else {
+				await this.git.checkout(branch, {create: true, startPoint: 'origin/main'});
+			}
+
+			if (agentNeeded) {
+				// Run agent to generate tasks
+				const prompt = buildInvestigatePrompt(issue, issueTasksDir);
+				const {exitCode} = await this.agent.run({
+					prompt,
+					workDir: this.config.workDir,
+					logFile: this.config.logFile,
+				});
+
+				if (exitCode !== 0) {
+					console.error(`Agent failed with exit code ${exitCode}`);
+					await this.issues.removeLabel(issue.number, LABELS.INVESTIGATING);
+					await this.git.checkoutMain();
+					return;
+				}
 			}
 
 			// Verify task files were created
@@ -213,16 +368,25 @@ export class Orchestrator {
 			if (this.config.noPush) {
 				console.log(`Branch '${branch}' ready (--no-push mode)`);
 			} else {
-				// Push and create PR
-				await this.git.push(branch);
-
-				const taskList = tasks.map((t) => `- [ ] **${t.id}**: ${t.title}`).join('\n');
-				const prUrl = await this.issues.createPR({
-					head: branch,
-					base: 'main',
-					title: `tasks(#${issue.number}): ${issue.title}`,
-					body: `## Generated Tasks for #${issue.number}\n\n${taskList}\n\n---\n*Generated by whitesmith from issue #${issue.number}*`,
-				});
+				// Force push since the branch may exist from a previous failed attempt
+				await this.git.forcePush(branch);
+
+				// Check if a PR already exists for this branch
+				const existingPR = await this.issues.getPRForBranch(branch);
+				let prUrl: string;
+
+				if (existingPR && existingPR.state === 'open') {
+					prUrl = existingPR.url;
+					console.log(`PR already exists: ${prUrl}`);
+				} else {
+					const taskList = tasks.map((t) => `- [ ] **${t.id}**: ${t.title}`).join('\n');
+					prUrl = await this.issues.createPR({
+						head: branch,
+						base: 'main',
+						title: `tasks(#${issue.number}): ${issue.title}`,
+						body: `## Generated Tasks for #${issue.number}\n\n${taskList}\n\n---\n*Generated by whitesmith from issue #${issue.number}*`,
+					});
+				}
 
 				await this.issues.removeLabel(issue.number, LABELS.INVESTIGATING);
 				await this.issues.addLabel(issue.number, LABELS.TASKS_PROPOSED);
@@ -243,31 +407,60 @@ export class Orchestrator {
 	}
 
 	/**
-	 * Phase 3: Implement — implement a task and create a PR
+	 * Phase 3: Implement — implement a task on the issue/<number> branch.
+	 * Each task adds one commit. When all tasks are done, a PR is created immediately.
 	 */
 	private async implement(task: Task, issue: Issue): Promise<void> {
 		console.log(`Implementing task ${task.id}: ${task.title}`);
 		console.log(`For issue #${issue.number}: ${issue.title}`);
 
-		const branch = `task/${task.id}`;
+		const branch = `issue/${issue.number}`;
 
 		try {
-			// Create branch from main
+			// Check if the issue branch already exists (previous tasks may have committed to it)
+			const remoteBranchExists = await this.issues.remoteBranchExists(branch);
+			let agentNeeded = true;
+
 			await this.git.deleteLocalBranch(branch);
-			await this.git.checkout(branch, {create: true, startPoint: 'origin/main'});
-
-			// Run agent to implement
-			const prompt = buildImplementPrompt(task, issue);
-			const {exitCode} = await this.agent.run({
-				prompt,
-				workDir: this.config.workDir,
-				logFile: this.config.logFile,
-			});
-
-			if (exitCode !== 0) {
-				console.error(`Agent failed with exit code ${exitCode}`);
-				await this.git.checkoutMain();
-				return;
+
+			if (remoteBranchExists) {
+				// Continue from existing issue branch (accumulate commits)
+				await this.git.checkout(branch, {create: true, startPoint: `origin/${branch}`});
+
+				// Check if this specific task was already completed on the branch
+				const taskFileExists = this.tasks.taskFileExists(task.filePath);
+				if (!taskFileExists) {
+					console.log(
+						`Task file '${task.filePath}' already deleted on branch '${branch}', skipping agent`,
+					);
+					agentNeeded = false;
+				}
+			} else {
+				await this.git.checkout(branch, {create: true, startPoint: 'origin/main'});
+			}
+
+			if (agentNeeded) {
+				const prompt = buildImplementPrompt(task, issue);
+				const {exitCode} = await this.agent.run({
+					prompt,
+					workDir: this.config.workDir,
+					logFile: this.config.logFile,
+				});
+
+				if (exitCode !== 0) {
+					console.error(`Agent failed with exit code ${exitCode}`);
+					await this.git.checkoutMain();
+					return;
+				}
+
+				// Verify the agent actually deleted the task file
+				if (this.tasks.taskFileExists(task.filePath)) {
+					console.error(
+						`Agent exited successfully but did not delete task file '${task.filePath}'. Treating as incomplete.`,
+					);
+					await this.git.checkoutMain();
+					return;
+				}
 			}
 
 			// Verify we're still on the right branch
@@ -279,17 +472,35 @@ export class Orchestrator {
 			if (this.config.noPush) {
 				console.log(`Branch '${branch}' ready (--no-push mode)`);
 			} else {
-				// Push and create PR
-				await this.git.push(branch);
-
-				const prUrl = await this.issues.createPR({
-					head: branch,
-					base: 'main',
-					title: `feat(#${issue.number}): ${task.title}`,
-					body: `## Task: ${task.title}\n\nImplements task \`${task.id}\` from issue #${issue.number}.\n\n### From the task spec:\n\n${task.content}\n\n---\n*Implemented by whitesmith*\n\nCloses #${issue.number} (if all tasks are complete)`,
-				});
-
-				console.log(`PR created: ${prUrl}`);
+				// Force push since the branch may exist from a previous failed attempt
+				await this.git.forcePush(branch);
+
+				// Check if all tasks for this issue are now complete
+				// (task files deleted on the current working tree = issue branch)
+				const remainingTasks = this.tasks.listTasks(issue.number);
+				if (remainingTasks.length === 0) {
+					// All tasks done — create PR immediately
+					const existingPR = await this.issues.getPRForBranch(branch);
+					let prUrl: string;
+
+					if (existingPR && existingPR.state === 'open') {
+						prUrl = existingPR.url;
+						console.log(`PR already exists: ${prUrl}`);
+					} else {
+						prUrl = await this.issues.createPR({
+							head: branch,
+							base: 'main',
+							title: `feat(#${issue.number}): ${issue.title}`,
+							body: `## Implementation for #${issue.number}\n\nAll tasks completed.\n\n---\n*Implemented by whitesmith*\n\nCloses #${issue.number}`,
+						});
+					}
+
+					console.log(`PR created: ${prUrl}`);
+				} else {
+					console.log(
+						`Task ${task.id} committed. ${remainingTasks.length} task(s) remaining for issue #${issue.number}.`,
+					);
+				}
 			}
 		} catch (error) {
 			console.error('Implementation failed:', error instanceof Error ? error.message : error);

package/src/prompts.ts

@@ -110,5 +110,6 @@ git commit -m "feat(#${issue.number}): ${task.title}"
 - Do NOT modify other task files.
 - You MUST delete \`${task.filePath}\` as part of your commit.
 - If the \`tasks/${task.issue}/\` directory is empty after deletion, remove it.
+- **Always use tool calls to make changes.** Never just describe what you plan to do — actually do it. If you produce a response with no tool calls, the session ends immediately and your work is lost.
 `;
 }