hungry-ghost-hive 0.42.0 → 0.43.0

package/src/cli/commands/manager/auditor-lifecycle.ts

@@ -0,0 +1,109 @@
+// Licensed under the Hungry Ghost Hive License. See LICENSE.
+
+import chalk from 'chalk';
+import { getAgentsByType } from '../../../db/queries/agents.js';
+import { createLog } from '../../../db/queries/logs.js';
+import { getAllTeams } from '../../../db/queries/teams.js';
+import type { ManagerCheckContext } from './types.js';
+
+function verboseLogCtx(ctx: Pick<ManagerCheckContext, 'verbose'>, message: string): void {
+  if (!ctx.verbose) return;
+  console.log(chalk.gray(`  [verbose] ${message}`));
+}
+
+// Module-level state tracking for auditor lifecycle
+let lastAuditorSpawnTime = 0;
+
+/** Reset auditor lifecycle state (for testing). */
+export function resetAuditorLifecycleState(): void {
+  lastAuditorSpawnTime = 0;
+}
+
+/** Get the last auditor spawn timestamp (for testing). */
+export function getLastAuditorSpawnTime(): number {
+  return lastAuditorSpawnTime;
+}
+
+/**
+ * Spawn an auditor agent if conditions are met:
+ * 1. auditor_enabled is true in config
+ * 2. Enough time has passed since last spawn (auditor_interval_ms)
+ * 3. No previous auditor is still running (active in agents table)
+ *
+ * Returns true if an auditor was spawned or skipped (auditor path handled),
+ * false if auditor is disabled (caller should fall back to nudge).
+ */
+export async function spawnAuditorIfNeeded(ctx: ManagerCheckContext): Promise<boolean> {
+  const { config } = ctx;
+
+  if (!config.manager.auditor_enabled) {
+    verboseLogCtx(ctx, 'spawnAuditorIfNeeded: skip=auditor_disabled');
+    return false;
+  }
+
+  const now = Date.now();
+  const intervalMs = config.manager.auditor_interval_ms;
+  const elapsed = now - lastAuditorSpawnTime;
+
+  if (elapsed < intervalMs) {
+    verboseLogCtx(
+      ctx,
+      `spawnAuditorIfNeeded: skip=interval_not_reached elapsedMs=${elapsed} intervalMs=${intervalMs}`
+    );
+    return true;
+  }
+
+  // Check if a previous auditor is still running
+  const hasActiveAuditor = await ctx.withDb(async db => {
+    const auditors = getAgentsByType(db.db, 'auditor');
+    return auditors.some(a => a.status === 'idle' || a.status === 'working');
+  });
+
+  if (hasActiveAuditor) {
+    verboseLogCtx(ctx, 'spawnAuditorIfNeeded: skip=active_auditor_running');
+    return true;
+  }
+
+  // Spawn a new auditor agent
+  try {
+    const agent = await ctx.withDb(async (db, scheduler) => {
+      const teams = getAllTeams(db.db);
+      if (teams.length === 0) {
+        verboseLogCtx(ctx, 'spawnAuditorIfNeeded: skip=no_teams');
+        return null;
+      }
+
+      const team = teams[0];
+      const spawned = await scheduler.spawnAuditor(team.id, team.name, team.repo_path);
+
+      createLog(db.db, {
+        agentId: spawned.id,
+        eventType: 'AGENT_SPAWNED',
+        message: `Spawned auditor agent ${spawned.id} for team ${team.name}`,
+        metadata: {
+          agent_type: 'auditor',
+          team_id: team.id,
+          team_name: team.name,
+        },
+      });
+
+      db.save();
+      return spawned;
+    });
+
+    if (agent) {
+      lastAuditorSpawnTime = now;
+      ctx.counters.auditorsSpawned++;
+      console.log(chalk.green(`  Auditor spawned: ${agent.id}`));
+      verboseLogCtx(ctx, `spawnAuditorIfNeeded: spawned agent=${agent.id}`);
+    }
+  } catch (err) {
+    console.error(chalk.red('  Auditor spawn failed:'), err instanceof Error ? err.message : err);
+    verboseLogCtx(
+      ctx,
+      `spawnAuditorIfNeeded: error=${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+
+  return true;
+}

package/src/cli/commands/manager/auto-assignment.test.ts

@@ -15,7 +15,7 @@ describe('autoAssignPlannedStories', () => {
   });
 
   function makeCtx(options?: {
-    plannedUnassigned?: number;
+    assignableUnassigned?: number;
     assigned?: number;
     errors?: string[];
     verbose?: boolean;
@@ -35,7 +35,7 @@ describe('autoAssignPlannedStories', () => {
     const withDb = vi.fn(async (fn: (db: typeof mockDb, scheduler: any) => unknown) => {
       callCount += 1;
       vi.mocked(queryAll).mockReturnValueOnce([
-        { count: options?.plannedUnassigned ?? 0 },
+        { count: options?.assignableUnassigned ?? 0 },
       ] as never);
       return fn(mockDb, scheduler);
     });
@@ -61,7 +61,7 @@ describe('autoAssignPlannedStories', () => {
 
   it('skips assignment when there are no planned unassigned stories', async () => {
     const { ctx, checkScaling, checkMergeQueue, assignStories, withDb } = makeCtx({
-      plannedUnassigned: 0,
+      assignableUnassigned: 0,
     });
 
     await autoAssignPlannedStories(ctx);
@@ -75,7 +75,7 @@ describe('autoAssignPlannedStories', () => {
 
   it('runs scaling, merge queue check, and assignment when planned stories exist', async () => {
     const { ctx, checkScaling, checkMergeQueue, assignStories, withDb } = makeCtx({
-      plannedUnassigned: 2,
+      assignableUnassigned: 2,
       assigned: 1,
     });
 

package/src/cli/commands/manager/auto-assignment.ts

@@ -20,10 +20,10 @@ async function getAssignableUnassignedStoryCount(ctx: ManagerCheckContext): Prom
 }
 
 export async function autoAssignPlannedStories(ctx: ManagerCheckContext): Promise<void> {
-  const plannedUnassigned = await getAssignableUnassignedStoryCount(ctx);
-  verboseLog(ctx, `autoAssignPlannedStories: assignableUnassigned=${plannedUnassigned}`);
+  const assignableUnassigned = await getAssignableUnassignedStoryCount(ctx);
+  verboseLog(ctx, `autoAssignPlannedStories: assignableUnassigned=${assignableUnassigned}`);
 
-  if (plannedUnassigned === 0) {
+  if (assignableUnassigned === 0) {
     return;
   }
 

package/src/cli/commands/manager/auto-reject-comment-only-reviews.test.ts

@@ -191,6 +191,7 @@ function makeMockCtx(overrides: Partial<ManagerCheckContext> = {}): ManagerCheck
       plannedAutoAssigned: 0,
       jiraSynced: 0,
       featureTestsSpawned: 0,
+      auditorsSpawned: 0,
     },
     escalatedSessions: new Set(),
     agentsBySessionName: new Map(),

package/src/cli/commands/manager/feature-sign-off.test.ts

@@ -87,6 +87,7 @@ function makeCtx(overrides: Partial<ManagerCheckContext> = {}): ManagerCheckCont
       plannedAutoAssigned: 0,
       jiraSynced: 0,
       featureTestsSpawned: 0,
+      auditorsSpawned: 0,
     },
     escalatedSessions: new Set(),
     agentsBySessionName: new Map(),

package/src/cli/commands/manager/index.ts

@@ -83,6 +83,7 @@ import {
   submitManagerNudgeWithVerification,
   updateAgentStateTracking,
 } from './agent-monitoring.js';
+import { spawnAuditorIfNeeded } from './auditor-lifecycle.js';
 import { autoAssignPlannedStories } from './auto-assignment.js';
 import { assessCompletionFromOutput } from './done-intelligence.js';
 import { handleEscalationAndNudge } from './escalation-handler.js';
@@ -928,6 +929,7 @@ async function managerCheck(
       plannedAutoAssigned: 0,
       jiraSynced: 0,
       featureTestsSpawned: 0,
+      auditorsSpawned: 0,
     },
     escalatedSessions: new Set(),
     agentsBySessionName: new Map(),
@@ -1002,7 +1004,11 @@ async function managerCheck(
   verboseLogCtx(ctx, 'Step: spin down idle agents');
   await spinDownIdleAgents(ctx);
   verboseLogCtx(ctx, 'Step: evaluate stuck stories');
-  await nudgeStuckStories(ctx);
+  const auditorHandled = await spawnAuditorIfNeeded(ctx);
+  if (!auditorHandled) {
+    // auditor_enabled is false — fall back to existing nudge behavior
+    await nudgeStuckStories(ctx);
+  }
   verboseLogCtx(ctx, 'Step: notify seniors about unassigned stories');
   await notifyUnassignedStories(ctx);
   await printSummary(ctx);
@@ -3355,6 +3361,7 @@ async function printSummary(ctx: ManagerCheckContext): Promise<void> {
     plannedAutoAssigned,
     jiraSynced,
     featureTestsSpawned,
+    auditorsSpawned,
   } = ctx.counters;
   const summary = [];
 
@@ -3381,6 +3388,7 @@ async function printSummary(ctx: ManagerCheckContext): Promise<void> {
     summary.push(`${plannedAutoAssigned} planned story(ies) auto-assigned`);
   if (jiraSynced > 0) summary.push(`${jiraSynced} synced from Jira`);
   if (featureTestsSpawned > 0) summary.push(`${featureTestsSpawned} feature test(s) spawned`);
+  if (auditorsSpawned > 0) summary.push(`${auditorsSpawned} auditor(s) spawned`);
 
   if (summary.length > 0) {
     console.log(chalk.yellow(`  ${summary.join(', ')}`));

package/src/cli/commands/manager/types.ts

@@ -82,6 +82,7 @@ export interface ManagerCheckContext {
     plannedAutoAssigned: number;
     jiraSynced: number;
     featureTestsSpawned: number;
+    auditorsSpawned: number;
   };
   // Shared state for dedup
   escalatedSessions: Set<string | null>;

package/src/config/schema.ts

@@ -69,6 +69,14 @@ const ModelsConfigSchema = z.object({
     cli_tool: 'claude',
     safety_mode: 'unsafe',
   }),
+  auditor: ModelConfigSchema.default({
+    provider: 'anthropic',
+    model: 'claude-opus-4-6',
+    max_tokens: 16000,
+    temperature: 0.3,
+    cli_tool: 'claude',
+    safety_mode: 'unsafe',
+  }),
 });
 
 // Scaling rules
@@ -233,6 +241,10 @@ const ManagerConfigSchema = z.object({
   tmux_timeout_ms: z.number().int().positive().default(10000), // 10s for tmux commands
   // Tech lead session max age in hours before graceful restart for context freshness
   tech_lead_max_age_hours: z.number().positive().default(6),
+  // How often to spawn an auditor agent (ms, default 5 minutes)
+  auditor_interval_ms: z.number().int().positive().default(300000),
+  // Whether auditor agent is enabled (false falls back to nudge behavior)
+  auditor_enabled: z.boolean().default(true),
 });
 
 // Merge queue configuration
@@ -446,6 +458,14 @@ models:
     # Agent personas can be configured during 'hive init'.
     # Re-run 'hive init --force' to reconfigure.
 
+  auditor:
+    provider: anthropic
+    model: claude-opus-4-6
+    max_tokens: 16000
+    temperature: 0.3
+    cli_tool: claude
+    safety_mode: unsafe
+
 # Team scaling rules
 scaling:
   # Story points threshold before hiring additional senior
@@ -529,6 +549,10 @@ manager:
   gh_timeout_ms: 60000
   # Timeout for tmux operations to prevent manager hangs (ms)
   tmux_timeout_ms: 10000
+  # How often to spawn an auditor agent (ms, default 5 minutes)
+  auditor_interval_ms: 300000
+  # Whether auditor agent is enabled (false falls back to nudge behavior)
+  auditor_enabled: true
 
 # Merge queue configuration
 merge_queue:

package/src/context-files/index.test.ts

@@ -169,6 +169,15 @@ describe('context-files module', () => {
           safety_mode: 'unsafe',
           personas: [],
         },
+        auditor: {
+          provider: 'anthropic',
+          model: 'claude-opus-4-6',
+          max_tokens: 16000,
+          temperature: 0.3,
+          cli_tool: 'claude',
+          safety_mode: 'unsafe',
+          personas: [],
+        },
       },
       scaling: {
         senior_capacity: 20,
@@ -214,6 +223,8 @@ describe('context-files module', () => {
         gh_timeout_ms: 60000,
         tmux_timeout_ms: 10000,
         tech_lead_max_age_hours: 6,
+        auditor_interval_ms: 300000,
+        auditor_enabled: true,
       },
       logging: { level: 'info', retention_days: 30 },
       cluster: {

package/src/db/client.ts

@@ -519,6 +519,38 @@ const MIGRATIONS: MigrationDefinition[] = [
       db.run('PRAGMA foreign_keys = ON');
     },
   },
+  {
+    name: '014-auditor-agent-type.sql',
+    up: db => {
+      // Recreate agents table with updated type CHECK constraint (add 'auditor')
+      db.run('PRAGMA foreign_keys = OFF');
+
+      db.run(`
+        CREATE TABLE agents_new (
+          id TEXT PRIMARY KEY,
+          type TEXT NOT NULL CHECK (type IN ('tech_lead', 'senior', 'intermediate', 'junior', 'qa', 'feature_test', 'auditor')),
+          team_id TEXT REFERENCES teams(id),
+          tmux_session TEXT,
+          model TEXT,
+          status TEXT DEFAULT 'idle' CHECK (status IN ('idle', 'working', 'blocked', 'terminated')),
+          current_story_id TEXT,
+          memory_state TEXT,
+          last_seen TIMESTAMP,
+          worktree_path TEXT,
+          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+          updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+      db.run('INSERT INTO agents_new SELECT * FROM agents');
+      db.run('DROP TABLE agents');
+      db.run('ALTER TABLE agents_new RENAME TO agents');
+
+      db.run('CREATE INDEX IF NOT EXISTS idx_agents_team_id ON agents(team_id)');
+      db.run('CREATE INDEX IF NOT EXISTS idx_agents_status ON agents(status)');
+
+      db.run('PRAGMA foreign_keys = ON');
+    },
+  },
   {
     name: '007-backfill-story-points.sql',
     up: db => {
@@ -721,7 +753,7 @@ export interface TeamRow {
 
 export interface AgentRow {
   id: string;
-  type: 'tech_lead' | 'senior' | 'intermediate' | 'junior' | 'qa' | 'feature_test';
+  type: 'tech_lead' | 'senior' | 'intermediate' | 'junior' | 'qa' | 'feature_test' | 'auditor';
   team_id: string | null;
   tmux_session: string | null;
   model: string | null;

package/src/db/migrations/014-auditor-agent-type.sql

@@ -0,0 +1,3 @@
+-- Migration 014: Add auditor agent type
+-- The CHECK constraint update is handled programmatically in client.ts
+-- (requires table recreation for SQLite CHECK constraint changes)

package/src/db/queries/agents.ts

@@ -6,7 +6,14 @@ import { queryAll, queryOne, run, type AgentRow } from '../client.js';
 
 export type { AgentRow };
 
-export type AgentType = 'tech_lead' | 'senior' | 'intermediate' | 'junior' | 'qa' | 'feature_test';
+export type AgentType =
+  | 'tech_lead'
+  | 'senior'
+  | 'intermediate'
+  | 'junior'
+  | 'qa'
+  | 'feature_test'
+  | 'auditor';
 export type AgentStatus = 'idle' | 'working' | 'blocked' | 'terminated';
 
 export interface CreateAgentInput {
@@ -134,6 +141,12 @@ export function deleteAgent(db: Database, id: string): void {
   run(db, 'DELETE FROM agents WHERE id = ?', [id]);
 }
 
+export function getAgentByTmuxSession(db: Database, tmuxSession: string): AgentRow | undefined {
+  return queryOne<AgentRow>(db, 'SELECT * FROM agents WHERE tmux_session = ? LIMIT 1', [
+    tmuxSession,
+  ]);
+}
+
 export function terminateAgent(db: Database, id: string): void {
   updateAgent(db, id, { status: 'terminated', tmuxSession: null });
 }

package/src/orchestrator/prompt-templates.test.ts

@@ -4,6 +4,7 @@ import { describe, expect, it } from 'vitest';
 import type { StoryRow } from '../db/client.js';
 import {
   formatSeniorSessionName,
+  generateAuditorPrompt,
   generateFeatureTestPrompt,
   generateIntermediatePrompt,
   generateJuniorPrompt,
@@ -645,6 +646,82 @@ describe('Prompt Templates', () => {
     });
   });
 
+  describe('generateAuditorPrompt', () => {
+    const sessionName = 'hive-auditor-1234567890';
+
+    it('should generate prompt with correct agent role', () => {
+      const prompt = generateAuditorPrompt(sessionName, repoPath, repoUrl);
+
+      expect(prompt).toContain('You are a Hive Auditor Agent');
+    });
+
+    it('should include session name', () => {
+      const prompt = generateAuditorPrompt(sessionName, repoPath, repoUrl);
+
+      expect(prompt).toContain(`Your tmux session: ${sessionName}`);
+    });
+
+    it('should include repository information', () => {
+      const prompt = generateAuditorPrompt(sessionName, repoPath, repoUrl);
+
+      expect(prompt).toContain(`Local path: ${repoPath}`);
+      expect(prompt).toContain(`Remote: ${repoUrl}`);
+    });
+
+    it('should include hive CLI commands reference', () => {
+      const prompt = generateAuditorPrompt(sessionName, repoPath, repoUrl);
+
+      expect(prompt).toContain('hive status');
+      expect(prompt).toContain('hive agents list --active');
+      expect(prompt).toContain('hive agents inspect');
+      expect(prompt).toContain('hive stories list');
+      expect(prompt).toContain('hive pr queue');
+      expect(prompt).toContain('hive msg send');
+      expect(prompt).toContain('hive agent self-terminate');
+    });
+
+    it('should include orphaned story detection instructions', () => {
+      const prompt = generateAuditorPrompt(sessionName, repoPath, repoUrl);
+
+      expect(prompt).toContain('Orphaned stories');
+      expect(prompt).toContain('hive stories update');
+      expect(prompt).toContain('--status planned');
+    });
+
+    it('should include stuck agent detection instructions', () => {
+      const prompt = generateAuditorPrompt(sessionName, repoPath, repoUrl);
+
+      expect(prompt).toContain('Plan mode');
+      expect(prompt).toContain('Permission prompts');
+      expect(prompt).toContain('BTab');
+    });
+
+    it('should include escalation instructions', () => {
+      const prompt = generateAuditorPrompt(sessionName, repoPath, repoUrl);
+
+      expect(prompt).toContain('hive msg send hive-tech-lead');
+      expect(prompt).toContain(`--from ${sessionName}`);
+    });
+
+    it('should include self-terminate instruction', () => {
+      const prompt = generateAuditorPrompt(sessionName, repoPath, repoUrl);
+
+      expect(prompt).toContain('hive agent self-terminate');
+    });
+
+    it('should prohibit nudging agents via arbitrary tmux send-keys', () => {
+      const prompt = generateAuditorPrompt(sessionName, repoPath, repoUrl);
+
+      expect(prompt).toContain('Do NOT nudge or interrupt agents');
+    });
+
+    it('should include tmux capture-pane instructions', () => {
+      const prompt = generateAuditorPrompt(sessionName, repoPath, repoUrl);
+
+      expect(prompt).toContain('tmux capture-pane');
+    });
+  });
+
   describe('Target Branch Propagation', () => {
     describe('generateSeniorPrompt with custom target branch', () => {
       it('should include custom target_branch in merge conflict check instructions', () => {

package/src/orchestrator/prompt-templates.ts

@@ -648,3 +648,98 @@ hive msg outbox ${sessionName}
 
 Start by checking out the feature branch and reading the TESTING.md file.`;
 }
+
+/**
+ * Generate prompt for Auditor agent.
+ * The auditor is an ephemeral Opus agent that performs an intelligent audit of all active work.
+ */
+export function generateAuditorPrompt(
+  sessionName: string,
+  repoPath: string,
+  repoUrl: string
+): string {
+  return `You are a Hive Auditor Agent.
+Your tmux session: ${sessionName}
+
+${repositorySection(repoPath, repoUrl)}
+
+## Your Mission
+Perform a rapid, intelligent audit of all active work in this Hive workspace.
+You are an ephemeral agent — complete your audit quickly and self-terminate.
+
+## Available Hive CLI Commands
+\`\`\`
+hive status                        # Overview of all stories, agents, PRs
+hive agents list --active          # List active agents with tmux sessions
+hive agents inspect <agent-id>     # Detailed agent state
+hive stories list                  # List all stories
+hive stories list --status <s>     # Filter stories by status (planned, in_progress, review, qa, merged)
+hive pr queue                      # View pending PRs in the merge queue
+hive msg send <session> "<msg>" --from ${sessionName}  # Send a message to another agent
+hive agent self-terminate          # Terminate yourself when done
+\`\`\`
+
+## Audit Workflow
+
+### 1. Get workspace overview
+\`\`\`bash
+hive status
+\`\`\`
+Review the overall state: stories, agents, PRs.
+
+### 2. Check active agents
+\`\`\`bash
+hive agents list --active --json
+\`\`\`
+For each active agent, note their tmux session and current story.
+
+### 3. Verify tmux sessions are alive
+For each active agent's tmux session, capture the last few lines to check their state:
+\`\`\`bash
+tmux capture-pane -t <session-name> -p -S -30
+\`\`\`
+
+### 4. Detect issues
+
+**Orphaned stories:** Stories with status \`in_progress\` but their assigned agent is terminated or has no live tmux session.
+- Fix: Reset the story status to \`planned\` so the scheduler can reassign it:
+\`\`\`bash
+hive stories update <story-id> --status planned
+\`\`\`
+
+**Stuck agents — Plan mode:** Agent output shows it is in plan mode (e.g., "Plan Mode" prompt, waiting for plan approval).
+- Fix: Send BTab to exit plan mode:
+\`\`\`bash
+tmux send-keys -t <session-name> BTab
+\`\`\`
+
+**Stuck agents — Permission prompts:** Agent output shows a permission/approval prompt (e.g., "Allow?", "Yes/No", tool approval dialogs).
+- Fix: Send Enter or 'y' to approve:
+\`\`\`bash
+tmux send-keys -t <session-name> Enter
+\`\`\`
+
+**Stuck agents — At idle prompt for extended time:** Agent appears to have finished but hasn't signaled completion.
+- Escalate: Cannot fix directly — notify tech lead.
+
+**Other unfixable issues:** Any issue you cannot resolve with the above actions.
+- Escalate to tech lead:
+\`\`\`bash
+hive msg send hive-tech-lead "AUDITOR: <description of issue, including agent id and story id>" --from ${sessionName}
+\`\`\`
+
+### 5. Self-terminate
+After completing your audit:
+\`\`\`bash
+hive agent self-terminate
+\`\`\`
+
+## IMPORTANT Rules
+- Do NOT nudge or interrupt agents by sending arbitrary text via tmux send-keys. Only use tmux send-keys for the specific fixes above (BTab for plan mode, Enter for permission prompts).
+- Use hive CLI commands for all actions — do not modify the database directly.
+- Be concise and efficient — this audit runs every few minutes.
+- Do NOT create branches, PRs, or modify any code.
+- If in doubt about an issue, escalate to the tech lead rather than taking action.
+
+Start by running \`hive status\` to get the workspace overview.`;
+}

package/src/orchestrator/scheduler.ts

@@ -55,6 +55,7 @@ import {
 } from './feature-branch.js';
 import { detectAndRecoverOrphanedStories } from './orphan-recovery.js';
 import {
+  generateAuditorPrompt,
   generateFeatureTestPrompt,
   generateIntermediatePrompt,
   generateJuniorPrompt,
@@ -236,6 +237,7 @@ export class Scheduler {
       const agents = getAgentsByTeam(this.db, teamId).filter(
         a =>
           a.type !== 'qa' &&
+          a.type !== 'auditor' &&
           (a.status === 'idle' || (a.status === 'working' && a.current_story_id === null))
       );
       const activeSeniors = getAgentsByTeam(this.db, teamId).filter(
@@ -893,7 +895,7 @@ export class Scheduler {
    * Handles spawning of all agent types (senior, intermediate, junior, qa)
    */
   private async spawnAgent(
-    type: 'senior' | 'intermediate' | 'junior' | 'qa' | 'feature_test',
+    type: 'senior' | 'intermediate' | 'junior' | 'qa' | 'feature_test' | 'auditor',
     teamId: string,
     teamName: string,
     repoPath: string,
@@ -904,7 +906,11 @@ export class Scheduler {
       e2eTestsPath: string;
     }
   ): Promise<AgentRow> {
-    const sessionName = generateSessionName(type, teamName, index);
+    // Auditor uses a timestamp-based session name since it's ephemeral
+    const sessionName =
+      type === 'auditor'
+        ? `hive-auditor-${Date.now()}`
+        : generateSessionName(type, teamName, index);
 
     // Prevent creating duplicate agents on same tmux session (for senior agents)
     if (type === 'senior') {
@@ -1033,6 +1039,8 @@ export class Scheduler {
           featureTestContext.e2eTestsPath,
           { includeProgressUpdates }
         );
+      } else if (type === 'auditor') {
+        prompt = generateAuditorPrompt(sessionName, worktreePath, team?.repo_url || '');
       } else {
         prompt = generateQAPrompt(
           teamName,
@@ -1135,6 +1143,15 @@ export class Scheduler {
     );
   }
 
+  /**
+   * Spawn an auditor agent for intelligent audit of all active work.
+   * The auditor is ephemeral — it audits the workspace and self-terminates.
+   * Uses a shared worktree from main branch (read-only, does not commit).
+   */
+  async spawnAuditor(teamId: string, teamName: string, repoPath: string): Promise<AgentRow> {
+    return this.spawnAgent('auditor', teamId, teamName, repoPath);
+  }
+
   private async spawnSenior(
     teamId: string,
     teamName: string,

package/src/tmux/manager.ts

@@ -269,16 +269,16 @@ export async function sendToTmuxSession(
   const isMultiLine = text.includes('\n');
 
   if (isMultiLine) {
-    // Multi-line text: write to temp file and paste via $(cat ...) to avoid
-    // the [Pasted text #N] buffering issue in Claude CLI. The shell expands
-    // $(cat file) into a single argument, bypassing tmux's paste-buffer handling.
-    const tempFile = join(
-      tmpdir(),
-      `hive-nudge-${Date.now()}-${sessionName.replace(/[^a-zA-Z0-9-]/g, '_')}.txt`
-    );
-    writeFileSync(tempFile, text, 'utf-8');
-    const catCmd = `$(cat ${tempFile})`;
-    await execa('tmux', ['send-keys', '-t', sessionName, '-l', '--', catCmd]);
+    // Multi-line text: use tmux set-buffer + paste-buffer to deliver the full
+    // text as a single paste event. This works because:
+    // 1. send-keys -l sends characters literally to the app (Claude CLI), NOT
+    //    to a shell, so $(cat ...) is never expanded — it appears verbatim.
+    // 2. paste-buffer uses bracketed paste mode, which tells Claude CLI that
+    //    the incoming text is pasted content, so newlines don't trigger submit.
+    const bufferName = `hive-nudge-${Date.now()}`;
+    await execa('tmux', ['set-buffer', '-b', bufferName, text]);
+    // -d deletes the buffer immediately after pasting (no cleanup needed)
+    await execa('tmux', ['paste-buffer', '-b', bufferName, '-t', sessionName, '-d']);
   } else {
     // Single-line: use send-keys with literal flag directly.
     // '--' signals end of options, preventing text starting with '-' from being parsed as flags.