heyio 3.0.2 → 3.0.3

package/src/squad/execution/instance.ts

@@ -1,186 +0,0 @@
-import type { InstanceStatus, Squad } from '@io/shared';
-import { createChildLogger } from '../../logging/logger.js';
-import { getDatabase } from '../../store/db.js';
-import { getEventBus } from '../event-bus.js';
-import { type SquadRuntime, getSquadMembers, getSquadRuntime } from '../manager.js';
-import { type WorktreeInfo, createWorktree, removeWorktree } from './worktree.js';
-
-const logger = () => createChildLogger('instance');
-
-export interface InstanceTask {
-	id: string;
-	description: string;
-	assignedTo: string; // agent role
-	status: 'pending' | 'in_progress' | 'done' | 'failed';
-	result?: string;
-}
-
-export interface Instance {
-	id: string;
-	squadId: string;
-	issueRef?: string;
-	worktree: WorktreeInfo | null;
-	branch: string | null;
-	status: InstanceStatus;
-	tasks: InstanceTask[];
-	meetingLog: string[];
-}
-
-const activeInstances = new Map<string, Instance>();
-
-/**
- * Create a new instance for a squad. Enforces max 3 per squad.
- */
-export async function createInstance(params: {
-	squad: Squad;
-	issueRef?: string;
-	objective: string;
-}): Promise<Instance> {
-	const log = logger();
-	const db = getDatabase();
-
-	// Enforce instance limit
-	const existingResult = await db.execute({
-		sql: "SELECT COUNT(*) as cnt FROM squad_instances WHERE squad_id = ? AND status NOT IN ('complete', 'failed')",
-		args: [params.squad.id],
-	});
-	const count = (existingResult.rows[0]?.cnt as number) ?? 0;
-	if (count >= 3) {
-		throw new Error(`Squad '${params.squad.name}' already has ${count} active instances (max 3)`);
-	}
-
-	const id = crypto.randomUUID();
-
-	// Create worktree if project has git
-	let worktree: WorktreeInfo | null = null;
-	try {
-		worktree = createWorktree({
-			repoPath: params.squad.projectPath,
-			squadName: params.squad.name,
-			instanceId: id,
-		});
-	} catch (err) {
-		log.warn({ err }, 'Could not create worktree, proceeding without isolation');
-	}
-
-	// Persist to DB
-	await db.execute({
-		sql: `INSERT INTO squad_instances (id, squad_id, issue_ref, worktree_path, branch_name, status)
-		      VALUES (?, ?, ?, ?, ?, 'planning')`,
-		args: [
-			id,
-			params.squad.id,
-			params.issueRef ?? null,
-			worktree?.path ?? null,
-			worktree?.branch ?? null,
-		],
-	});
-
-	const instance: Instance = {
-		id,
-		squadId: params.squad.id,
-		issueRef: params.issueRef,
-		worktree,
-		branch: worktree?.branch ?? null,
-		status: 'planning',
-		tasks: [],
-		meetingLog: [],
-	};
-
-	activeInstances.set(id, instance);
-
-	await getEventBus().emit({
-		id: crypto.randomUUID(),
-		timestamp: new Date(),
-		type: 'instance:created',
-		squadId: params.squad.id,
-		instanceId: id,
-		data: { issueRef: params.issueRef, objective: params.objective },
-	});
-
-	log.info({ instanceId: id, squadId: params.squad.id }, 'Instance created');
-	return instance;
-}
-
-/**
- * Transition instance to a new status.
- */
-export async function transitionInstance(
-	instanceId: string,
-	newStatus: InstanceStatus,
-): Promise<void> {
-	const db = getDatabase();
-	const instance = activeInstances.get(instanceId);
-	if (!instance) throw new Error(`Instance ${instanceId} not found`);
-
-	const validTransitions: Record<InstanceStatus, InstanceStatus[]> = {
-		planning: ['meeting', 'failed'],
-		meeting: ['working', 'failed'],
-		working: ['reviewing', 'failed'],
-		reviewing: ['complete', 'working', 'failed'],
-		complete: [],
-		failed: [],
-	};
-
-	const allowed = validTransitions[instance.status];
-	if (!allowed.includes(newStatus)) {
-		throw new Error(`Invalid transition: ${instance.status} → ${newStatus}`);
-	}
-
-	instance.status = newStatus;
-	const completedAt =
-		newStatus === 'complete' || newStatus === 'failed' ? new Date().toISOString() : null;
-
-	await db.execute({
-		sql: 'UPDATE squad_instances SET status = ?, completed_at = COALESCE(?, completed_at) WHERE id = ?',
-		args: [newStatus, completedAt, instanceId],
-	});
-
-	const eventType =
-		newStatus === 'meeting'
-			? 'instance:meeting_started'
-			: newStatus === 'working'
-				? 'instance:work_started'
-				: newStatus === 'complete'
-					? 'instance:complete'
-					: newStatus === 'failed'
-						? 'instance:failed'
-						: ('instance:created' as const);
-
-	await getEventBus().emit({
-		id: crypto.randomUUID(),
-		timestamp: new Date(),
-		type: eventType,
-		squadId: instance.squadId,
-		instanceId,
-		data: { from: instance.status, to: newStatus },
-	});
-}
-
-/**
- * Clean up a completed/failed instance (remove worktree).
- */
-export async function cleanupInstance(instanceId: string, squad: Squad): Promise<void> {
-	const instance = activeInstances.get(instanceId);
-	if (!instance) return;
-
-	if (instance.worktree && instance.branch) {
-		removeWorktree({
-			repoPath: squad.projectPath,
-			worktreePath: instance.worktree.path,
-			branch: instance.branch,
-		});
-	}
-
-	activeInstances.delete(instanceId);
-}
-
-/** Get an active instance */
-export function getInstance(instanceId: string): Instance | undefined {
-	return activeInstances.get(instanceId);
-}
-
-/** Get all active instances for a squad */
-export function getSquadInstances(squadId: string): Instance[] {
-	return [...activeInstances.values()].filter((i) => i.squadId === squadId);
-}

package/src/squad/execution/meeting.ts

@@ -1,191 +0,0 @@
-import { createChildLogger } from '../../logging/logger.js';
-import type { Agent } from '../agent.js';
-import { getEventBus } from '../event-bus.js';
-import type { SquadRuntime } from '../manager.js';
-import type { Instance, InstanceTask } from './instance.js';
-import { transitionInstance } from './instance.js';
-
-const logger = () => createChildLogger('meeting');
-
-export interface MeetingResult {
-	consensus: boolean;
-	tasks: InstanceTask[];
-	log: string[];
-	vetoReason?: string;
-}
-
-const MAX_ROUNDS = 5;
-
-/**
- * Run a round-table meeting for an instance.
- * Protocol:
- * 1. Team Lead presents context
- * 2. Each agent speaks in round-robin order
- * 3. Agents respond to previous speakers
- * 4. Team Lead calls for consensus
- * 5. Veto members can block
- * 6. If blocked, discussion continues (up to MAX_ROUNDS)
- * 7. On consensus, Team Lead formalizes task list
- */
-export async function runMeeting(params: {
-	instance: Instance;
-	runtime: SquadRuntime;
-	objective: string;
-}): Promise<MeetingResult> {
-	const log = logger();
-	const { instance, runtime, objective } = params;
-	const meetingLog: string[] = [];
-
-	await transitionInstance(instance.id, 'meeting');
-
-	await getEventBus().emit({
-		id: crypto.randomUUID(),
-		timestamp: new Date(),
-		type: 'instance:meeting_started',
-		squadId: instance.squadId,
-		instanceId: instance.id,
-		data: { objective },
-	});
-
-	const teamLead = runtime.members.get('team-lead');
-	if (!teamLead) throw new Error('No team lead available for meeting');
-
-	// Get non-lead agents for discussion
-	const participants = [...runtime.members.entries()].filter(([role]) => role !== 'team-lead');
-
-	// Step 1: Team lead presents the objective
-	const presentation = await teamLead.send(
-		`You are starting a round-table meeting. Present the following objective to your team and ask for input:\n\nObjective: ${objective}\n\nProvide a brief summary of the work needed and what expertise is required. Then ask each team member for their perspective.`,
-	);
-	meetingLog.push(`[team-lead] ${presentation}`);
-
-	await emitContribution(instance, 'team-lead', presentation);
-
-	// Step 2-3: Round-robin discussion
-	let round = 0;
-	let consensusReached = false;
-	let vetoReason: string | undefined;
-
-	while (round < MAX_ROUNDS && !consensusReached) {
-		round++;
-		log.info({ instanceId: instance.id, round }, 'Meeting round');
-
-		// Each participant speaks
-		for (const [role, agent] of participants) {
-			const context = meetingLog.slice(-5).join('\n\n');
-			const response = await agent.send(
-				`You are in a team meeting (round ${round}/${MAX_ROUNDS}). Here's the recent discussion:\n\n${context}\n\nProvide your professional input on the objective. Focus on your area of expertise. If you're QA, focus on testing concerns. If you have concerns, state them clearly.`,
-			);
-			meetingLog.push(`[${role}] ${response}`);
-			await emitContribution(instance, role, response);
-		}
-
-		// Step 4: Team lead calls for consensus
-		const consensusCheck = await teamLead.send(
-			`The discussion so far:\n\n${meetingLog.slice(-participants.length - 1).join('\n\n')}\n\nBased on this discussion, do we have consensus to proceed? Consider all concerns raised. Reply with either:\n- "CONSENSUS: <brief summary of agreed plan>"\n- "NEED_DISCUSSION: <what needs to be resolved>"`,
-		);
-		meetingLog.push(`[team-lead] ${consensusCheck}`);
-
-		if (consensusCheck.toUpperCase().includes('CONSENSUS:')) {
-			// Step 5: Check veto members
-			const vetoMembers = [...runtime.members.entries()].filter(([role]) => {
-				const skill = runtime.skills.get(role);
-				return skill?.veto;
-			});
-
-			let vetoed = false;
-			for (const [role, agent] of vetoMembers) {
-				if (role === 'team-lead') continue; // team lead already agreed
-				const vetoCheck = await agent.send(
-					`The team has reached consensus on the following plan:\n\n${consensusCheck}\n\nAs a veto-holding member, do you approve this plan? Reply with:\n- "APPROVE" if you agree\n- "VETO: <reason>" if you have critical concerns that must be addressed`,
-				);
-
-				if (vetoCheck.toUpperCase().includes('VETO:')) {
-					vetoed = true;
-					vetoReason = vetoCheck;
-					meetingLog.push(`[${role}] VETO: ${vetoCheck}`);
-					await emitVeto(instance, role, vetoCheck);
-					break;
-				}
-				meetingLog.push(`[${role}] Approved`);
-			}
-
-			if (!vetoed) {
-				consensusReached = true;
-			}
-		}
-	}
-
-	// Step 7: Formalize task list
-	let tasks: InstanceTask[] = [];
-	if (consensusReached) {
-		const taskPlan = await teamLead.send(
-			`Consensus reached. Now formalize the work into specific tasks. For each task, specify:\n1. A brief description\n2. Which team member role should do it\n\nFormat each task as: "TASK: <description> | ASSIGN: <role>"\n\nList all tasks needed to complete the objective.`,
-		);
-		meetingLog.push(`[team-lead] Task plan: ${taskPlan}`);
-		tasks = parseTaskList(taskPlan, instance.id);
-	}
-
-	await getEventBus().emit({
-		id: crypto.randomUUID(),
-		timestamp: new Date(),
-		type: 'instance:meeting_complete',
-		squadId: instance.squadId,
-		instanceId: instance.id,
-		data: { consensus: consensusReached, taskCount: tasks.length, rounds: round },
-	});
-
-	instance.meetingLog = meetingLog;
-	instance.tasks = tasks;
-
-	log.info(
-		{ instanceId: instance.id, consensus: consensusReached, tasks: tasks.length },
-		'Meeting complete',
-	);
-
-	return { consensus: consensusReached, tasks, log: meetingLog, vetoReason };
-}
-
-/** Parse the team lead's task list into structured tasks */
-function parseTaskList(taskPlan: string, instanceId: string): InstanceTask[] {
-	const tasks: InstanceTask[] = [];
-	const lines = taskPlan.split('\n');
-
-	for (const line of lines) {
-		const match = line.match(/TASK:\s*(.+?)\s*\|\s*ASSIGN:\s*(.+)/i);
-		if (match) {
-			tasks.push({
-				id: crypto.randomUUID(),
-				description: match[1].trim(),
-				assignedTo: match[2].trim().toLowerCase().replace(/\s+/g, '-'),
-				status: 'pending',
-			});
-		}
-	}
-
-	return tasks;
-}
-
-async function emitContribution(instance: Instance, role: string, content: string) {
-	await getEventBus().emit({
-		id: crypto.randomUUID(),
-		timestamp: new Date(),
-		type: 'meeting:contribution',
-		squadId: instance.squadId,
-		instanceId: instance.id,
-		agentRole: role,
-		content: content.slice(0, 500),
-	});
-}
-
-async function emitVeto(instance: Instance, role: string, reason: string) {
-	await getEventBus().emit({
-		id: crypto.randomUUID(),
-		timestamp: new Date(),
-		type: 'meeting:veto',
-		squadId: instance.squadId,
-		instanceId: instance.id,
-		agentRole: role,
-		content: reason,
-	});
-}

package/src/squad/execution/pr.ts

@@ -1,127 +0,0 @@
-import { execSync } from 'node:child_process';
-import { createChildLogger } from '../../logging/logger.js';
-import type { Instance } from './instance.js';
-import { transitionInstance } from './instance.js';
-
-const logger = () => createChildLogger('pr');
-
-export interface PrResult {
-	url: string;
-	number: number;
-}
-
-/**
- * Create a pull request from the instance's worktree branch.
- * Commits any uncommitted changes, pushes the branch, then creates a PR.
- */
-export async function createPullRequest(params: {
-	instance: Instance;
-	title: string;
-	squadName: string;
-}): Promise<PrResult | null> {
-	const log = logger();
-	const { instance, title, squadName } = params;
-
-	if (!instance.worktree || !instance.branch) {
-		log.warn({ instanceId: instance.id }, 'No worktree/branch, skipping PR creation');
-		await transitionInstance(instance.id, 'complete');
-		return null;
-	}
-
-	const cwd = instance.worktree.path;
-
-	try {
-		// Check if there are changes to commit
-		const status = execSync('git status --porcelain', { cwd, encoding: 'utf-8' }).trim();
-		if (!status) {
-			log.info({ instanceId: instance.id }, 'No changes to commit');
-			await transitionInstance(instance.id, 'complete');
-			return null;
-		}
-
-		// Stage and commit all changes
-		execSync('git add -A', { cwd, stdio: 'pipe' });
-
-		const commitMessage = buildCommitMessage(title, instance, squadName);
-		execSync(`git commit -m "${escapeShell(commitMessage)}"`, { cwd, stdio: 'pipe' });
-
-		// Push the branch
-		execSync(`git push -u origin "${instance.branch}"`, { cwd, stdio: 'pipe' });
-
-		// Create the PR using gh CLI
-		const prBody = buildPrBody(instance, squadName);
-		const prOutput = execSync(
-			`gh pr create --title "${escapeShell(title)}" --body "${escapeShell(prBody)}" --head "${instance.branch}"`,
-			{ cwd, encoding: 'utf-8', stdio: 'pipe' },
-		).trim();
-
-		// Parse the PR URL to get the number
-		const prUrl = prOutput;
-		const prNumber = Number.parseInt(prUrl.split('/').pop() ?? '0', 10);
-
-		await transitionInstance(instance.id, 'complete');
-		log.info({ instanceId: instance.id, prUrl, prNumber }, 'PR created');
-
-		return { url: prUrl, number: prNumber };
-	} catch (err) {
-		log.error({ err, instanceId: instance.id }, 'Failed to create PR');
-		await transitionInstance(instance.id, 'failed');
-		return null;
-	}
-}
-
-function buildCommitMessage(title: string, instance: Instance, squadName: string): string {
-	const lines = [`feat: ${title}`, '', `Squad: ${squadName}`, `Instance: ${instance.id}`];
-
-	if (instance.issueRef) {
-		lines.push(`Closes ${instance.issueRef}`);
-	}
-
-	const completedTasks = instance.tasks.filter((t) => t.status === 'done');
-	if (completedTasks.length > 0) {
-		lines.push('', 'Tasks completed:');
-		for (const task of completedTasks) {
-			lines.push(`- ${task.description} (${task.assignedTo})`);
-		}
-	}
-
-	return lines.join('\n');
-}
-
-function buildPrBody(instance: Instance, squadName: string): string {
-	const sections: string[] = [];
-
-	sections.push(`## 🤖 Generated by IO Squad: ${squadName}`);
-	sections.push('');
-
-	if (instance.issueRef) {
-		sections.push(`Closes ${instance.issueRef}`);
-		sections.push('');
-	}
-
-	// Tasks section
-	sections.push('### Tasks Completed');
-	for (const task of instance.tasks) {
-		const icon = task.status === 'done' ? '✅' : task.status === 'failed' ? '❌' : '⏳';
-		sections.push(`${icon} ${task.description} — *${task.assignedTo}*`);
-	}
-
-	// Meeting highlights (last few entries)
-	if (instance.meetingLog.length > 0) {
-		sections.push('');
-		sections.push('<details><summary>Meeting Discussion</summary>');
-		sections.push('');
-		const recentLog = instance.meetingLog.slice(-10);
-		for (const entry of recentLog) {
-			sections.push(`> ${entry.slice(0, 200)}`);
-			sections.push('');
-		}
-		sections.push('</details>');
-	}
-
-	return sections.join('\n');
-}
-
-function escapeShell(str: string): string {
-	return str.replace(/"/g, '\\"').replace(/\n/g, '\\n');
-}

package/src/squad/execution/runner.ts

@@ -1,97 +0,0 @@
-import type { Squad } from '@io/shared';
-import { createChildLogger } from '../../logging/logger.js';
-import { type SquadRuntime, bootSquad, getSquadRuntime } from '../manager.js';
-import {
-	type Instance,
-	type PrResult,
-	cleanupInstance,
-	createInstance,
-	createPullRequest,
-	executeTasks,
-	runMeeting,
-} from './index.js';
-
-const logger = () => createChildLogger('runner');
-
-export interface RunResult {
-	instanceId: string;
-	success: boolean;
-	pr?: PrResult | null;
-	error?: string;
-}
-
-/**
- * Run a full instance lifecycle:
- * 1. Create instance (with worktree)
- * 2. Hold round-table meeting
- * 3. Execute tasks
- * 4. Create PR
- * 5. Clean up
- */
-export async function runInstance(params: {
-	squad: Squad;
-	objective: string;
-	issueRef?: string;
-}): Promise<RunResult> {
-	const log = logger();
-	const { squad, objective, issueRef } = params;
-
-	// Ensure squad is booted
-	let runtime: SquadRuntime | undefined = getSquadRuntime(squad.id);
-	if (!runtime) {
-		runtime = await bootSquad(squad);
-	}
-
-	// 1. Create instance
-	const instance = await createInstance({ squad, issueRef, objective });
-	log.info({ instanceId: instance.id }, 'Starting instance run');
-
-	try {
-		// 2. Run meeting
-		const meetingResult = await runMeeting({ instance, runtime, objective });
-
-		if (!meetingResult.consensus) {
-			log.warn({ instanceId: instance.id }, 'Meeting did not reach consensus');
-			return {
-				instanceId: instance.id,
-				success: false,
-				error: `Meeting failed to reach consensus${meetingResult.vetoReason ? `: ${meetingResult.vetoReason}` : ''}`,
-			};
-		}
-
-		if (instance.tasks.length === 0) {
-			log.warn({ instanceId: instance.id }, 'No tasks generated from meeting');
-			return {
-				instanceId: instance.id,
-				success: false,
-				error: 'Meeting produced no actionable tasks',
-			};
-		}
-
-		// 3. Execute tasks
-		await executeTasks({ instance, runtime });
-
-		// 4. Create PR
-		const prTitle = objective.slice(0, 72);
-		const pr = await createPullRequest({ instance, title: prTitle, squadName: squad.name });
-
-		// 5. Cleanup (if no PR was created — otherwise keep the branch for review)
-		if (!pr) {
-			await cleanupInstance(instance.id, squad);
-		}
-
-		return {
-			instanceId: instance.id,
-			success: true,
-			pr,
-		};
-	} catch (err) {
-		log.error({ err, instanceId: instance.id }, 'Instance run failed');
-		await cleanupInstance(instance.id, squad);
-		return {
-			instanceId: instance.id,
-			success: false,
-			error: err instanceof Error ? err.message : String(err),
-		};
-	}
-}