hungry-ghost-hive 0.3.0

package/dist/utils/timeout.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Timeout and retry utilities for LLM calls
+ */
+export declare class TimeoutError extends Error {
+    readonly timeoutMs: number;
+    constructor(message: string, timeoutMs: number);
+}
+export interface RetryOptions {
+    maxRetries: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+}
+/**
+ * Wraps a promise with a timeout
+ */
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, errorMessage?: string): Promise<T>;
+/**
+ * Retries a function with exponential backoff
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, options: RetryOptions): Promise<T>;
+/**
+ * Combines timeout and retry logic
+ */
+export declare function withTimeoutAndRetry<T>(fn: () => Promise<T>, timeoutMs: number, retryOptions: RetryOptions, errorMessage?: string): Promise<T>;
+//# sourceMappingURL=timeout.d.ts.map

package/dist/utils/timeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../../src/utils/timeout.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,qBAAa,YAAa,SAAQ,KAAK;aACQ,SAAS,EAAE,MAAM;gBAAlD,OAAO,EAAE,MAAM,EAAkB,SAAS,EAAE,MAAM;CAI/D;AAED,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,SAAS,EAAE,MAAM,EACjB,YAAY,SAAwB,GACnC,OAAO,CAAC,CAAC,CAAC,CAgBZ;AAED;;GAEG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAC/B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,CAAC,CAAC,CAoBZ;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,CAAC,EACzC,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,YAAY,EAC1B,YAAY,SAAwB,GACnC,OAAO,CAAC,CAAC,CAAC,CAKZ"}

package/dist/utils/timeout.js

@@ -0,0 +1,57 @@
+/**
+ * Timeout and retry utilities for LLM calls
+ */
+export class TimeoutError extends Error {
+    timeoutMs;
+    constructor(message, timeoutMs) {
+        super(message);
+        this.timeoutMs = timeoutMs;
+        this.name = 'TimeoutError';
+    }
+}
+/**
+ * Wraps a promise with a timeout
+ */
+export function withTimeout(promise, timeoutMs, errorMessage = 'Operation timed out') {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            reject(new TimeoutError(`${errorMessage} after ${timeoutMs}ms`, timeoutMs));
+        }, timeoutMs);
+        promise
+            .then((result) => {
+            clearTimeout(timer);
+            resolve(result);
+        })
+            .catch((err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+}
+/**
+ * Retries a function with exponential backoff
+ */
+export async function withRetry(fn, options) {
+    const { maxRetries, baseDelayMs = 1000, maxDelayMs = 30000 } = options;
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastError = err instanceof Error ? err : new Error(String(err));
+            if (attempt === maxRetries)
+                break;
+            const delay = Math.min(baseDelayMs * Math.pow(2, attempt) * (0.5 + Math.random() * 0.5), maxDelayMs);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+    }
+    throw lastError || new Error('Max retries exceeded');
+}
+/**
+ * Combines timeout and retry logic
+ */
+export async function withTimeoutAndRetry(fn, timeoutMs, retryOptions, errorMessage = 'Operation timed out') {
+    return withRetry(() => withTimeout(fn(), timeoutMs, errorMessage), retryOptions);
+}
+//# sourceMappingURL=timeout.js.map

package/dist/utils/timeout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.js","sourceRoot":"","sources":["../../src/utils/timeout.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,OAAO,YAAa,SAAQ,KAAK;IACQ;IAA7C,YAAY,OAAe,EAAkB,SAAiB;QAC5D,KAAK,CAAC,OAAO,CAAC,CAAC;QAD4B,cAAS,GAAT,SAAS,CAAQ;QAE5D,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC;IAC7B,CAAC;CACF;AAQD;;GAEG;AACH,MAAM,UAAU,WAAW,CACzB,OAAmB,EACnB,SAAiB,EACjB,YAAY,GAAG,qBAAqB;IAEpC,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACxC,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE;YAC5B,MAAM,CAAC,IAAI,YAAY,CAAC,GAAG,YAAY,UAAU,SAAS,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC;QAC9E,CAAC,EAAE,SAAS,CAAC,CAAC;QAEd,OAAO;aACJ,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;YACf,YAAY,CAAC,KAAK,CAAC,CAAC;YACpB,OAAO,CAAC,MAAM,CAAC,CAAC;QAClB,CAAC,CAAC;aACD,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;YACb,YAAY,CAAC,KAAK,CAAC,CAAC;YACpB,MAAM,CAAC,GAAG,CAAC,CAAC;QACd,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAC7B,EAAoB,EACpB,OAAqB;IAErB,MAAM,EAAE,UAAU,EAAE,WAAW,GAAG,IAAI,EAAE,UAAU,GAAG,KAAK,EAAE,GAAG,OAAO,CAAC;IACvE,IAAI,SAA4B,CAAC;IAEjC,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,UAAU,EAAE,OAAO,EAAE,EAAE,CAAC;QACvD,IAAI,CAAC;YACH,OAAO,MAAM,EAAE,EAAE,CAAC;QACpB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,SAAS,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;YAChE,IAAI,OAAO,KAAK,UAAU;gBAAE,MAAM;YAElC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CACpB,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,CAAC,EAChE,UAAU,CACX,CAAC;YACF,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC;QAC7D,CAAC;IACH,CAAC;IAED,MAAM,SAAS,IAAI,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;AACvD,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,EAAoB,EACpB,SAAiB,EACjB,YAA0B,EAC1B,YAAY,GAAG,qBAAqB;IAEpC,OAAO,SAAS,CACd,GAAG,EAAE,CAAC,WAAW,CAAC,EAAE,EAAE,EAAE,SAAS,EAAE,YAAY,CAAC,EAChD,YAAY,CACb,CAAC;AACJ,CAAC"}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "hungry-ghost-hive",
+  "version": "0.3.0",
+  "description": "AI Agent Orchestrator - Manages agile software development teams of AI agents",
+  "type": "module",
+  "bin": {
+    "hive": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "scripts": {
+    "prepare": "husky install",
+    "build": "tsc",
+    "prepack": "npm run build",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "lint": "eslint src/",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nikrich/hungry-ghost-hive.git"
+  },
+  "homepage": "https://github.com/nikrich/hungry-ghost-hive#readme",
+  "bugs": {
+    "url": "https://github.com/nikrich/hungry-ghost-hive/issues"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.24.0",
+    "@types/proper-lockfile": "^4.1.4",
+    "blessed": "^0.1.81",
+    "blessed-contrib": "^4.10.0",
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "execa": "^9.0.0",
+    "nanoid": "^5.0.0",
+    "openai": "^4.0.0",
+    "ora": "^8.0.0",
+    "proper-lockfile": "^4.1.2",
+    "sql.js": "^1.13.0",
+    "yaml": "^2.0.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^18.0.0",
+    "@commitlint/config-conventional": "^18.0.0",
+    "@eslint/js": "^9.39.2",
+    "@types/blessed": "^0.1.0",
+    "@types/node": "^20.0.0",
+    "eslint": "^9.39.2",
+    "husky": "^9.1.7",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0",
+    "typescript-eslint": "^8.54.0",
+    "vitest": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "src",
+    "tsconfig.json"
+  ],
+  "keywords": [
+    "ai",
+    "agents",
+    "orchestrator",
+    "cli",
+    "agile",
+    "development"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/agents/base-agent.ts

@@ -0,0 +1,255 @@
+import type { Database } from 'sql.js';
+import type { LLMProvider, Message } from '../llm/provider.js';
+import { createLog, type EventType } from '../db/queries/logs.js';
+import { updateAgent, type AgentRow, type AgentType, type AgentStatus } from '../db/queries/agents.js';
+import { updateAgentHeartbeat } from '../db/queries/heartbeat.js';
+
+export interface MemoryState {
+  conversationSummary: string;
+  currentTask?: {
+    storyId?: string;
+    phase: string;
+    filesModified: string[];
+    lastAction: string;
+  };
+  context: {
+    codebaseNotes?: string;
+    blockers: string[];
+    decisionsMade: string[];
+  };
+  checkpointTokens: number;
+}
+
+export interface AgentContext {
+  db: Database;
+  provider: LLMProvider;
+  agentRow: AgentRow;
+  workDir: string;
+  config: {
+    maxRetries: number;
+    checkpointThreshold: number;
+    pollInterval: number;
+    llmTimeoutMs: number;
+    llmMaxRetries: number;
+  };
+}
+
+export abstract class BaseAgent {
+  protected db: Database;
+  protected provider: LLMProvider;
+  protected agentId: string;
+  protected agentType: AgentType;
+  protected teamId: string | null;
+  protected workDir: string;
+  protected config: AgentContext['config'];
+  protected messages: Message[] = [];
+  protected memoryState: MemoryState;
+  protected totalTokens = 0;
+  private heartbeatInterval: NodeJS.Timeout | null = null;
+
+  constructor(context: AgentContext) {
+    this.db = context.db;
+    this.provider = context.provider;
+    this.agentId = context.agentRow.id;
+    this.agentType = context.agentRow.type;
+    this.teamId = context.agentRow.team_id;
+    this.workDir = context.workDir;
+    this.config = context.config;
+
+    // Load or initialize memory state
+    if (context.agentRow.memory_state) {
+      this.memoryState = JSON.parse(context.agentRow.memory_state);
+    } else {
+      this.memoryState = {
+        conversationSummary: '',
+        context: {
+          blockers: [],
+          decisionsMade: [],
+        },
+        checkpointTokens: 0,
+      };
+    }
+
+    // Initialize messages with system prompt
+    this.messages = [
+      { role: 'system', content: this.getSystemPrompt() },
+    ];
+
+    // Add memory context if resuming
+    if (this.memoryState.conversationSummary) {
+      this.messages.push({
+        role: 'user',
+        content: `Previous context:\n${this.memoryState.conversationSummary}\n\nContinue from where you left off.`,
+      });
+    }
+
+    // Start heartbeat mechanism for faster failure detection
+    this.startHeartbeat();
+  }
+
+  abstract getSystemPrompt(): string;
+
+  private startHeartbeat(): void {
+    // Send initial heartbeat
+    this.sendHeartbeat();
+
+    // Send heartbeat every 10 seconds
+    this.heartbeatInterval = setInterval(() => {
+      this.sendHeartbeat();
+    }, 10000);
+  }
+
+  private sendHeartbeat(): void {
+    try {
+      updateAgentHeartbeat(this.db, this.agentId);
+    } catch (err) {
+      // Heartbeat failure shouldn't crash the agent
+      console.error(`Heartbeat failed for ${this.agentId}:`, err);
+    }
+  }
+
+  private stopHeartbeat(): void {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+
+  protected log(
+    eventType: EventType,
+    message?: string,
+    metadata?: Record<string, unknown>
+  ): void {
+    createLog(this.db, {
+      agentId: this.agentId,
+      storyId: this.memoryState.currentTask?.storyId,
+      eventType,
+      message,
+      metadata,
+    });
+  }
+
+  protected updateStatus(status: AgentStatus): void {
+    updateAgent(this.db, this.agentId, { status });
+  }
+
+  protected saveMemoryState(): void {
+    this.memoryState.checkpointTokens = this.totalTokens;
+    updateAgent(this.db, this.agentId, {
+      memoryState: JSON.stringify(this.memoryState),
+    });
+  }
+
+  protected async chat(userMessage: string): Promise<string> {
+    this.messages.push({ role: 'user', content: userMessage });
+
+    try {
+      // Apply configured timeout to LLM call
+      const result = await this.provider.complete(this.messages, {
+        timeoutMs: this.config.llmTimeoutMs,
+      });
+
+      this.totalTokens += result.usage.inputTokens + result.usage.outputTokens;
+      this.messages.push({ role: 'assistant', content: result.content });
+
+      // Check if we need to checkpoint
+      if (this.totalTokens > this.config.checkpointThreshold) {
+        await this.checkpoint();
+      }
+
+      return result.content;
+    } catch (err) {
+      // Log timeout/error event
+      this.log('AGENT_TERMINATED', `LLM call failed: ${err instanceof Error ? err.message : String(err)}`, {
+        error: err instanceof Error ? err.stack : String(err),
+      });
+      throw err;
+    }
+  }
+
+  protected async checkpoint(): Promise<void> {
+    // Summarize the conversation
+    const summaryPrompt = `Summarize the key points of our conversation so far in a concise paragraph. Focus on:
+1. What task we're working on
+2. What progress has been made
+3. What decisions were made
+4. What blockers or issues exist
+5. What's the next step
+
+Keep it under 500 words.`;
+
+    this.messages.push({ role: 'user', content: summaryPrompt });
+    const summaryResult = await this.provider.complete(this.messages);
+
+    this.memoryState.conversationSummary = summaryResult.content;
+    this.saveMemoryState();
+
+    this.log('AGENT_CHECKPOINT', 'Checkpoint saved', {
+      totalTokens: this.totalTokens,
+    });
+
+    // Reset messages but keep context
+    this.messages = [
+      { role: 'system', content: this.getSystemPrompt() },
+      { role: 'user', content: `Previous context:\n${this.memoryState.conversationSummary}\n\nContinue from where you left off.` },
+    ];
+    this.totalTokens = 0;
+  }
+
+  protected addDecision(decision: string): void {
+    this.memoryState.context.decisionsMade.push(decision);
+    this.saveMemoryState();
+  }
+
+  protected addBlocker(blocker: string): void {
+    this.memoryState.context.blockers.push(blocker);
+    this.saveMemoryState();
+  }
+
+  protected removeBlocker(blocker: string): void {
+    this.memoryState.context.blockers = this.memoryState.context.blockers.filter(
+      b => b !== blocker
+    );
+    this.saveMemoryState();
+  }
+
+  protected setCurrentTask(storyId: string, phase: string): void {
+    this.memoryState.currentTask = {
+      storyId,
+      phase,
+      filesModified: [],
+      lastAction: '',
+    };
+    this.saveMemoryState();
+  }
+
+  protected updateTaskProgress(lastAction: string, filesModified?: string[]): void {
+    if (this.memoryState.currentTask) {
+      this.memoryState.currentTask.lastAction = lastAction;
+      if (filesModified) {
+        this.memoryState.currentTask.filesModified.push(...filesModified);
+      }
+      this.saveMemoryState();
+    }
+  }
+
+  async run(): Promise<void> {
+    this.updateStatus('working');
+    this.log('AGENT_SPAWNED', `${this.agentType} agent started`);
+
+    try {
+      await this.execute();
+    } catch (err) {
+      this.updateStatus('blocked');
+      this.log('AGENT_TERMINATED', `Error: ${err instanceof Error ? err.message : 'Unknown error'}`, {
+        error: err instanceof Error ? err.stack : String(err),
+      });
+      throw err;
+    } finally {
+      // Stop heartbeat when agent completes or fails
+      this.stopHeartbeat();
+    }
+  }
+
+  abstract execute(): Promise<void>;
+}

package/src/agents/index.ts

@@ -0,0 +1,6 @@
+export { BaseAgent, type MemoryState, type AgentContext } from './base-agent.js';
+export { TechLeadAgent, type TechLeadContext } from './tech-lead.js';
+export { SeniorAgent, type SeniorContext } from './senior.js';
+export { IntermediateAgent, type IntermediateContext } from './intermediate.js';
+export { JuniorAgent, type JuniorContext } from './junior.js';
+export { QAAgent, type QAContext } from './qa.js';

package/src/agents/intermediate.ts

@@ -0,0 +1,161 @@
+import { BaseAgent, type AgentContext } from './base-agent.js';
+import { getTeamById, type TeamRow } from '../db/queries/teams.js';
+import { updateStory, getStoryById, type StoryRow } from '../db/queries/stories.js';
+import { getAgentsByTeam } from '../db/queries/agents.js';
+import { createEscalation } from '../db/queries/escalations.js';
+
+export interface IntermediateContext extends AgentContext {
+  storyId?: string;
+}
+
+export class IntermediateAgent extends BaseAgent {
+  private team: TeamRow | null = null;
+  private story: StoryRow | null = null;
+  private retryCount = 0;
+
+  constructor(context: IntermediateContext) {
+    super(context);
+    if (context.agentRow.team_id) {
+      this.team = getTeamById(this.db, context.agentRow.team_id) || null;
+    }
+    if (context.storyId) {
+      this.story = getStoryById(this.db, context.storyId) || null;
+    } else if (context.agentRow.current_story_id) {
+      this.story = getStoryById(this.db, context.agentRow.current_story_id) || null;
+    }
+  }
+
+  getSystemPrompt(): string {
+    const teamInfo = this.team
+      ? `Team: ${this.team.name}\nRepository: ${this.team.repo_path}`
+      : 'No team assigned';
+
+    const storyInfo = this.story
+      ? `Current Story: ${this.story.id}\nTitle: ${this.story.title}\nStatus: ${this.story.status}`
+      : 'No story assigned';
+
+    return `You are an Intermediate Developer working on assigned stories.
+
+## Your Team
+${teamInfo}
+
+## Assignment
+${storyInfo}
+
+## Your Responsibilities
+1. Implement assigned stories with moderate complexity (4-5 points)
+2. Follow existing code patterns and conventions
+3. Write tests for your code
+4. Create clear commit messages
+5. Request help from Senior when stuck
+
+## Development Guidelines
+- Work on the feature branch assigned to the story
+- Follow TDD when possible
+- Commit frequently with descriptive messages
+- Update progress regularly
+- Escalate after 2 failed attempts
+
+## Current Context
+${this.memoryState.conversationSummary || 'Starting fresh.'}`;
+  }
+
+  async execute(): Promise<void> {
+    if (!this.story) {
+      this.log('STORY_PROGRESS_UPDATE', 'No story assigned, waiting');
+      return;
+    }
+
+    this.setCurrentTask(this.story.id, 'implementation');
+    this.log('STORY_STARTED', `Working on: ${this.story.title}`, { storyId: this.story.id });
+
+    try {
+      await this.implementStory();
+    } catch (err) {
+      this.retryCount++;
+      if (this.retryCount >= this.config.maxRetries) {
+        await this.escalateToSenior(`Failed after ${this.retryCount} attempts: ${err instanceof Error ? err.message : 'Unknown error'}`);
+      } else {
+        this.log('STORY_PROGRESS_UPDATE', `Retry ${this.retryCount}: ${err instanceof Error ? err.message : 'Unknown error'}`, {
+          storyId: this.story.id,
+        });
+        // Retry
+        await this.execute();
+      }
+    }
+  }
+
+  private async implementStory(): Promise<void> {
+    if (!this.story) return;
+
+    const branchName = this.story.branch_name ||
+      `feature/${this.story.id.toLowerCase()}-${this.story.title.toLowerCase().replace(/[^a-z0-9]+/g, '-').substring(0, 30)}`;
+
+    // Update story with branch name if not set
+    if (!this.story.branch_name) {
+      updateStory(this.db, this.story.id, { branchName });
+    }
+
+    const prompt = `Implement this story:
+
+## Story: ${this.story.id}
+**Title:** ${this.story.title}
+
+**Description:**
+${this.story.description}
+
+**Acceptance Criteria:**
+${this.story.acceptance_criteria ? JSON.parse(this.story.acceptance_criteria).join('\n- ') : 'None specified'}
+
+**Branch:** ${branchName}
+
+## Instructions
+1. Checkout or create the feature branch
+2. Read the relevant files to understand the context
+3. Implement the required changes
+4. Write tests
+5. Commit with clear messages
+6. Update me on progress
+
+Begin implementation.`;
+
+    const response = await this.chat(prompt);
+    this.updateTaskProgress('Implementation in progress', []);
+    this.log('STORY_PROGRESS_UPDATE', response.substring(0, 200), { storyId: this.story.id });
+
+    // Continue implementation (simplified - in reality this would be iterative)
+    const continuePrompt = 'Continue with the implementation. Show me the code changes you would make.';
+    await this.chat(continuePrompt);
+    this.log('STORY_PROGRESS_UPDATE', 'Code changes proposed', { storyId: this.story.id });
+
+    // Mark as complete
+    updateStory(this.db, this.story.id, { status: 'review' });
+    this.log('STORY_COMPLETED', 'Implementation complete, ready for review', {
+      storyId: this.story.id,
+      branchName,
+    });
+  }
+
+  private async escalateToSenior(reason: string): Promise<void> {
+    // Find Senior for this team
+    const seniors = getAgentsByTeam(this.db, this.teamId!)
+      .filter(a => a.type === 'senior' && a.status !== 'terminated');
+
+    const seniorId = seniors[0]?.id;
+
+    const escalation = createEscalation(this.db, {
+      storyId: this.story?.id,
+      fromAgentId: this.agentId,
+      toAgentId: seniorId,
+      reason,
+    });
+
+    this.log('ESCALATION_CREATED', reason, {
+      escalationId: escalation.id,
+      toAgent: seniorId,
+    });
+
+    this.updateStatus('blocked');
+    this.addBlocker(`Escalated to Senior: ${reason}`);
+  }
+}