hungry-ghost-hive 0.40.3 → 0.41.1

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

@@ -43,6 +43,7 @@ import {
   updatePullRequest,
 } from '../../../db/queries/pull-requests.js';
 import { getStoriesByStatus, getStoryById, updateStory } from '../../../db/queries/stories.js';
+import { getPullRequestComments, getPullRequestReviews } from '../../../git/github.js';
 import { Scheduler } from '../../../orchestrator/scheduler.js';
 import { AgentState } from '../../../state-detectors/types.js';
 import {
@@ -979,6 +980,8 @@ async function managerCheck(
   await batchMarkMessagesRead(ctx);
   verboseLogCtx(ctx, 'Step: notify QA about queued PRs');
   await notifyQAOfQueuedPRs(ctx);
+  verboseLogCtx(ctx, 'Step: auto-reject comment-only reviews');
+  await autoRejectCommentOnlyReviews(ctx);
   verboseLogCtx(ctx, 'Step: handle rejected PRs');
   await handleRejectedPRs(ctx);
   verboseLogCtx(ctx, 'Step: recover unassigned qa_failed stories');
@@ -1555,7 +1558,33 @@ async function recoverStaleReviewingPRs(ctx: ManagerCheckContext): Promise<void>
       const state = parsed.state?.toUpperCase();
       const url = parsed.url || null;
 
-      if (state === 'OPEN') continue;
+      if (state === 'OPEN') {
+        // PR is still open on GitHub but stale in 'reviewing' — the QA agent
+        // may have missed the original nudge. Re-nudge if QA agent is idle.
+        if (candidate.reviewedBy) {
+          const qaAgent = ctx.agentsBySessionName.get(candidate.reviewedBy);
+          if (qaAgent && qaAgent.status === 'idle') {
+            const githubLine = candidate.repoSlug
+              ? `\n# GitHub: https://github.com/${candidate.repoSlug}/pull/${candidate.githubPrNumber}`
+              : '';
+            await sendManagerNudge(
+              ctx,
+              candidate.reviewedBy,
+              `# [REMINDER] You are assigned PR review ${candidate.id} (${candidate.storyId || 'no-story'}).${githubLine}
+# This PR has been waiting for review. Execute now:
+#   hive pr show ${candidate.id}
+#   hive pr approve ${candidate.id}
+# or reject:
+#   hive pr reject ${candidate.id} -r "reason"`
+            );
+            verboseLogCtx(
+              ctx,
+              `recoverStaleReviewingPRs: re-nudged idle QA ${candidate.reviewedBy} for stale pr=${candidate.id}`
+            );
+          }
+        }
+        continue;
+      }
       if (state === 'MERGED') {
         mergedResults.push({
           candidate,
@@ -1876,10 +1905,19 @@ async function scanAgentSessions(ctx: ManagerCheckContext): Promise<void> {
   // Phase 2: Per-session processing (tmux/AI outside lock, DB writes under brief locks)
   for (const session of ctx.hiveSessions) {
     if (session.name === 'hive-manager') continue;
-    activeSessionNames.add(session.name);
 
     const agent = ctx.agentsBySessionName.get(session.name);
-    const agentCliTool = (agent?.cli_tool || 'claude') as CLITool;
+
+    // Skip sessions not registered in our DB (cross-project sessions).
+    // This prevents escalation noise from sessions belonging to other
+    // teams/projects sharing the same tmux server.
+    if (!agent) {
+      verboseLogCtx(ctx, `Skipping ${session.name}: no agent registered in DB (cross-project)`);
+      continue;
+    }
+
+    activeSessionNames.add(session.name);
+    const agentCliTool = (agent.cli_tool || 'claude') as CLITool;
     const safetyMode = getAgentSafetyMode(ctx.config, agent);
     verboseLogCtx(
       ctx,
@@ -2230,6 +2268,193 @@ async function notifyQAOfQueuedPRs(ctx: ManagerCheckContext): Promise<void> {
   }
 }
 
+/**
+ * Auto-reject PRs where the QA agent posted review comments/feedback on GitHub
+ * but never formally approved or rejected via `hive pr approve/reject`.
+ *
+ * Detection: PR is in 'reviewing' status, the assigned QA agent is idle,
+ * and there are GitHub comments or CHANGES_REQUESTED reviews on the PR.
+ *
+ * Action: Auto-reject the PR with the QA's feedback as the rejection reason,
+ * which triggers the standard qa_failed flow back to the developer agent.
+ */
+export async function autoRejectCommentOnlyReviews(ctx: ManagerCheckContext): Promise<void> {
+  // Phase 1: Identify reviewing PRs with idle QA agents (brief lock)
+  const candidates = await ctx.withDb(async db => {
+    const reviewingPRs = getPullRequestsByStatus(db.db, 'reviewing').filter(
+      pr => pr.github_pr_number && pr.team_id && pr.reviewed_by
+    );
+
+    verboseLogCtx(ctx, `autoRejectCommentOnlyReviews: reviewingWithQA=${reviewingPRs.length}`);
+    if (reviewingPRs.length === 0) return [];
+
+    // Only consider PRs whose QA agent is idle (finished reviewing but didn't approve/reject)
+    const idlePRs = reviewingPRs.filter(pr => {
+      const qaAgent = ctx.agentsBySessionName.get(pr.reviewed_by!);
+      if (!qaAgent) return false;
+      // Check if the QA agent is idle or if their session shows idle state
+      const qaState = agentStates.get(pr.reviewed_by!);
+      return qaAgent.status === 'idle' || qaState?.lastState === AgentState.IDLE_AT_PROMPT;
+    });
+
+    verboseLogCtx(ctx, `autoRejectCommentOnlyReviews: idleQACandidates=${idlePRs.length}`);
+    if (idlePRs.length === 0) return [];
+
+    const { getAllTeams } = await import('../../../db/queries/teams.js');
+    const teams = getAllTeams(db.db);
+    const teamsById = new Map(teams.map(team => [team.id, team]));
+
+    return idlePRs
+      .map(pr => {
+        const team = teamsById.get(pr.team_id!);
+        if (!team?.repo_path) return null;
+        return {
+          id: pr.id,
+          storyId: pr.story_id,
+          teamId: pr.team_id!,
+          branchName: pr.branch_name,
+          githubPrNumber: pr.github_pr_number!,
+          reviewedBy: pr.reviewed_by!,
+          submittedBy: pr.submitted_by,
+          repoDir: `${ctx.root}/${team.repo_path}`,
+        };
+      })
+      .filter(Boolean) as Array<{
+      id: string;
+      storyId: string | null;
+      branchName: string;
+      githubPrNumber: number;
+      reviewedBy: string;
+      submittedBy: string | null;
+      teamId: string;
+      repoDir: string;
+    }>;
+  });
+
+  if (candidates.length === 0) return;
+
+  // Phase 2: Check GitHub for comments/reviews on each candidate (no lock)
+  const toReject: Array<{
+    candidate: (typeof candidates)[number];
+    reason: string;
+  }> = [];
+
+  for (const candidate of candidates) {
+    try {
+      // Fetch both reviews and comments from GitHub
+      const [reviews, comments] = await Promise.all([
+        getPullRequestReviews(candidate.repoDir, candidate.githubPrNumber).catch(
+          (): Array<{ author: string; state: string; body: string }> => []
+        ),
+        getPullRequestComments(candidate.repoDir, candidate.githubPrNumber).catch(
+          (): Array<{ author: string; body: string; createdAt: string }> => []
+        ),
+      ]);
+
+      // If there's a formal APPROVED review, skip (QA approved via GitHub directly)
+      const hasApproval = reviews.some(r => r.state === 'APPROVED');
+      if (hasApproval) {
+        verboseLogCtx(
+          ctx,
+          `autoRejectCommentOnlyReviews: pr=${candidate.id} has GitHub approval, skipping`
+        );
+        continue;
+      }
+
+      // Check for CHANGES_REQUESTED reviews
+      const changesRequested = reviews.filter(r => r.state === 'CHANGES_REQUESTED');
+
+      // Check for substantive issue comments (filter out bot noise and very short comments)
+      const substantiveComments = comments.filter(c => {
+        if (c.body.length < 20) return false;
+        // Skip known bot comments (Ellipsis, etc.)
+        if (c.body.includes('Looks good to me') && c.body.length < 100) return false;
+        return true;
+      });
+
+      // If there are review feedback items, auto-reject
+      if (changesRequested.length > 0 || substantiveComments.length > 0) {
+        // Build rejection reason from the feedback
+        const feedbackParts: string[] = [];
+        for (const review of changesRequested) {
+          if (review.body) feedbackParts.push(review.body);
+        }
+        for (const comment of substantiveComments) {
+          feedbackParts.push(comment.body);
+        }
+        const reason =
+          feedbackParts.length > 0
+            ? feedbackParts.join('\n---\n').slice(0, 2000)
+            : 'QA posted review feedback on GitHub without formal approval. See PR comments.';
+
+        toReject.push({ candidate, reason });
+        verboseLogCtx(
+          ctx,
+          `autoRejectCommentOnlyReviews: pr=${candidate.id} has ${changesRequested.length} changes_requested + ${substantiveComments.length} comments, will auto-reject`
+        );
+      }
+    } catch (err) {
+      verboseLogCtx(
+        ctx,
+        `autoRejectCommentOnlyReviews: skip pr=${candidate.id} github_check_failed=${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+
+  if (toReject.length === 0) return;
+
+  // Phase 3: Reject PRs in DB (brief lock)
+  await ctx.withDb(async db => {
+    for (const { candidate, reason } of toReject) {
+      await withTransaction(
+        db.db,
+        () => {
+          updatePullRequest(db.db, candidate.id, {
+            status: 'rejected',
+            reviewNotes: reason,
+          });
+          if (candidate.storyId) {
+            updateStory(db.db, candidate.storyId, { status: 'qa_failed' });
+          }
+          createLog(db.db, {
+            agentId: 'manager',
+            eventType: 'PR_REJECTED',
+            message: `Auto-rejected PR ${candidate.id}: QA posted review comments without formal approve/reject`,
+            storyId: candidate.storyId || undefined,
+            metadata: { pr_id: candidate.id, auto_rejected: true },
+          });
+        },
+        () => db.save()
+      );
+      console.log(
+        chalk.yellow(
+          `  Auto-rejected PR ${candidate.id} (story: ${candidate.storyId || '-'}): QA left review comments without approving`
+        )
+      );
+    }
+  });
+
+  // Phase 4: Notify developer agents via tmux (no lock)
+  for (const { candidate, reason } of toReject) {
+    if (candidate.submittedBy) {
+      const devSession = ctx.hiveSessions.find(s => s.name === candidate.submittedBy);
+      if (devSession) {
+        await sendManagerNudge(
+          ctx,
+          devSession.name,
+          `# ⚠️ PR AUTO-REJECTED - QA REVIEW FEEDBACK ⚠️
+# Story: ${candidate.storyId || 'Unknown'}
+# QA agent (${candidate.reviewedBy}) posted review feedback without formally approving.
+# Feedback:
+# ${reason.split('\n').slice(0, 10).join('\n# ')}
+#
+# Fix the issues and resubmit: hive pr submit -b ${candidate.branchName} -s ${candidate.storyId || 'STORY-ID'} --from ${devSession.name}`
+        );
+      }
+    }
+  }
+}
+
 async function handleRejectedPRs(ctx: ManagerCheckContext): Promise<void> {
   // Phase 1: Read rejected PRs and update DB (brief lock)
   const rejectedPRData = await ctx.withDb(async db => {

package/src/cli/wizard/init-wizard.test.ts

@@ -138,12 +138,13 @@ describe('Init Wizard', () => {
       mockSelect.mockResolvedValueOnce('none');
       mockSelect.mockResolvedValueOnce('full');
       mockSelect.mockResolvedValueOnce('claude');
-      vi.mocked(confirm).mockResolvedValueOnce(false);
+      // personas=no, E2E=no
+      vi.mocked(confirm).mockResolvedValueOnce(false).mockResolvedValueOnce(false);
 
       const result = await runInitWizard();
 
       expect(mockSelect).toHaveBeenCalledTimes(4);
-      expect(confirm).toHaveBeenCalledTimes(1);
+      expect(confirm).toHaveBeenCalledTimes(2);
       expect(result).toEqual({
         integrations: {
           source_control: { provider: 'github' },
@@ -160,7 +161,8 @@ describe('Init Wizard', () => {
       mockSelect.mockResolvedValueOnce('none');
       mockSelect.mockResolvedValueOnce('full');
       mockSelect.mockResolvedValueOnce('claude');
-      vi.mocked(confirm).mockResolvedValueOnce(true);
+      // personas=no, E2E=yes
+      vi.mocked(confirm).mockResolvedValueOnce(false).mockResolvedValueOnce(true);
       vi.mocked(input).mockResolvedValueOnce('./e2e');
 
       const result = await runInitWizard();
@@ -174,7 +176,8 @@ describe('Init Wizard', () => {
       mockSelect.mockResolvedValueOnce('none');
       mockSelect.mockResolvedValueOnce('full');
       mockSelect.mockResolvedValueOnce('claude');
-      vi.mocked(confirm).mockResolvedValueOnce(false);
+      // personas=no, E2E=no
+      vi.mocked(confirm).mockResolvedValueOnce(false).mockResolvedValueOnce(false);
 
       const result = await runInitWizard();
 
@@ -187,7 +190,8 @@ describe('Init Wizard', () => {
       mockSelect.mockResolvedValueOnce('jira');
       mockSelect.mockResolvedValueOnce('partial');
       mockSelect.mockResolvedValueOnce('codex');
-      vi.mocked(confirm).mockResolvedValueOnce(false);
+      // personas=no, E2E=no
+      vi.mocked(confirm).mockResolvedValueOnce(false).mockResolvedValueOnce(false);
 
       const mockInput = vi.mocked(input);
       mockInput.mockResolvedValueOnce('test-client-id');
@@ -224,7 +228,8 @@ describe('Init Wizard', () => {
       mockSelect.mockResolvedValueOnce('none');
       mockSelect.mockResolvedValueOnce('full');
       mockSelect.mockResolvedValueOnce('claude');
-      vi.mocked(confirm).mockResolvedValueOnce(false);
+      // personas=no, E2E=no
+      vi.mocked(confirm).mockResolvedValueOnce(false).mockResolvedValueOnce(false);
 
       // Mock registry to return available providers
       vi.mocked(registry.listSourceControlProviders).mockReturnValueOnce(['github']);
@@ -242,7 +247,8 @@ describe('Init Wizard', () => {
       mockSelect.mockResolvedValueOnce('none');
       mockSelect.mockResolvedValueOnce('full');
       mockSelect.mockResolvedValueOnce('claude');
-      vi.mocked(confirm).mockResolvedValueOnce(false);
+      // personas=no, E2E=no
+      vi.mocked(confirm).mockResolvedValueOnce(false).mockResolvedValueOnce(false);
 
       // Mock registry to return available providers
       vi.mocked(registry.listProjectManagementProviders).mockReturnValueOnce(['jira']);
@@ -263,7 +269,8 @@ describe('Init Wizard', () => {
       mockSelect.mockResolvedValueOnce('none');
       mockSelect.mockResolvedValueOnce('full');
       mockSelect.mockResolvedValueOnce('claude');
-      vi.mocked(confirm).mockResolvedValueOnce(false);
+      // personas=no, E2E=no
+      vi.mocked(confirm).mockResolvedValueOnce(false).mockResolvedValueOnce(false);
 
       await runInitWizard();
 
@@ -283,7 +290,8 @@ describe('Init Wizard', () => {
       mockSelect.mockResolvedValueOnce('none');
       mockSelect.mockResolvedValueOnce('full');
       mockSelect.mockResolvedValueOnce('claude');
-      vi.mocked(confirm).mockResolvedValueOnce(false);
+      // personas=no, E2E=no
+      vi.mocked(confirm).mockResolvedValueOnce(false).mockResolvedValueOnce(false);
 
       await runInitWizard();
 
@@ -297,6 +305,51 @@ describe('Init Wizard', () => {
         { name: 'Codex', value: 'codex' },
       ]);
     });
+
+    it('should configure personas when user opts in', async () => {
+      const mockSelect = vi.mocked(select);
+      mockSelect.mockResolvedValueOnce('github');
+      mockSelect.mockResolvedValueOnce('none');
+      mockSelect.mockResolvedValueOnce('full');
+      mockSelect.mockResolvedValueOnce('claude');
+      // personas=yes, E2E=no
+      vi.mocked(confirm).mockResolvedValueOnce(true).mockResolvedValueOnce(false);
+      const mockInput = vi.mocked(input);
+      // tech_lead: 1 persona
+      mockInput.mockResolvedValueOnce('1');
+      mockInput.mockResolvedValueOnce('Ava');
+      mockInput.mockResolvedValueOnce('Strategic thinker');
+      // senior: 0
+      mockInput.mockResolvedValueOnce('0');
+      // intermediate: 0
+      mockInput.mockResolvedValueOnce('0');
+      // junior: 0
+      mockInput.mockResolvedValueOnce('0');
+      // qa: 0
+      mockInput.mockResolvedValueOnce('0');
+      // feature_test: 0
+      mockInput.mockResolvedValueOnce('0');
+
+      const result = await runInitWizard();
+
+      expect(result.personas).toEqual({
+        tech_lead: [{ name: 'Ava', persona: 'Strategic thinker' }],
+      });
+    });
+
+    it('should not include personas when user declines', async () => {
+      const mockSelect = vi.mocked(select);
+      mockSelect.mockResolvedValueOnce('github');
+      mockSelect.mockResolvedValueOnce('none');
+      mockSelect.mockResolvedValueOnce('full');
+      mockSelect.mockResolvedValueOnce('claude');
+      // personas=no, E2E=no
+      vi.mocked(confirm).mockResolvedValueOnce(false).mockResolvedValueOnce(false);
+
+      const result = await runInitWizard();
+
+      expect(result.personas).toBeUndefined();
+    });
   });
 
   describe('e2e_tests non-interactive', () => {

package/src/cli/wizard/init-wizard.ts

@@ -6,7 +6,7 @@ import { existsSync } from 'fs';
 import { join, resolve } from 'path';
 import { startJiraOAuthFlow, storeJiraTokens } from '../../auth/jira-oauth.js';
 import { TokenStore } from '../../auth/token-store.js';
-import type { E2ETestsConfig, IntegrationsConfig } from '../../config/schema.js';
+import type { E2ETestsConfig, IntegrationsConfig, PersonaConfig } from '../../config/schema.js';
 import { bootstrapConnectors } from '../../connectors/bootstrap.js';
 import { registry } from '../../connectors/registry.js';
 import { openBrowser } from '../../utils/open-browser.js';
@@ -29,6 +29,7 @@ export interface InitWizardResult {
   integrations: IntegrationsConfig;
   agent_runtime: AgentRuntime;
   e2e_tests?: E2ETestsConfig;
+  personas?: Record<string, PersonaConfig[]>;
 }
 
 export async function runInitWizard(options: InitWizardOptions = {}): Promise<InitWizardResult> {
@@ -100,7 +101,63 @@ export async function runInitWizard(options: InitWizardOptions = {}): Promise<In
     default: 'claude',
   });
 
-  // Step 5: E2E testing configuration (optional)
+  // Step 5: Agent personas (optional)
+  const agentTypes: { key: string; label: string }[] = [
+    { key: 'tech_lead', label: 'Tech Lead' },
+    { key: 'senior', label: 'Senior Developer' },
+    { key: 'intermediate', label: 'Intermediate Developer' },
+    { key: 'junior', label: 'Junior Developer' },
+    { key: 'qa', label: 'QA Engineer' },
+    { key: 'feature_test', label: 'Feature Test Agent' },
+  ];
+
+  let personas: Record<string, PersonaConfig[]> | undefined;
+
+  const wantsPersonas = await confirm({
+    message: 'Configure agent personas?',
+    default: false,
+  });
+
+  if (wantsPersonas) {
+    personas = {};
+    for (const { key, label } of agentTypes) {
+      const countStr = await input({
+        message: `How many personas for ${label}? (0 to skip)`,
+        default: '0',
+        validate: (value: string) => {
+          const n = parseInt(value, 10);
+          if (isNaN(n) || n < 0 || !Number.isInteger(n)) {
+            return 'Enter a non-negative integer';
+          }
+          return true;
+        },
+      });
+
+      const count = parseInt(countStr, 10);
+      if (count > 0) {
+        const agentPersonas: PersonaConfig[] = [];
+        for (let i = 1; i <= count; i++) {
+          const name = await input({
+            message: `Name for ${label} persona #${i}`,
+            validate: (value: string) => (value.length > 0 ? true : 'Name is required'),
+          });
+          const persona = await input({
+            message: `Personality description for ${name}`,
+            validate: (value: string) => (value.length > 0 ? true : 'Description is required'),
+          });
+          agentPersonas.push({ name, persona });
+        }
+        personas[key] = agentPersonas;
+      }
+    }
+
+    // Only keep personas if at least one agent type has entries
+    if (Object.keys(personas).length === 0) {
+      personas = undefined;
+    }
+  }
+
+  // Step 6: E2E testing configuration (optional)
   const wantsE2E = await confirm({
     message: 'Configure E2E testing?',
     default: false,
@@ -138,7 +195,8 @@ export async function runInitWizard(options: InitWizardOptions = {}): Promise<In
     autonomy as 'full' | 'partial',
     agentRuntime as AgentRuntime,
     options,
-    e2eTestPath
+    e2eTestPath,
+    personas
   );
 }
 
@@ -227,7 +285,8 @@ async function buildResult(
   autonomy: 'full' | 'partial',
   agentRuntime: AgentRuntime,
   options: InitWizardOptions = {},
-  e2eTestPath?: string
+  e2eTestPath?: string,
+  personas?: Record<string, PersonaConfig[]>
 ): Promise<InitWizardResult> {
   const integrations: IntegrationsConfig = {
     source_control: { provider: sourceControl },
@@ -314,5 +373,8 @@ async function buildResult(
   if (e2eTestPath) {
     result.e2e_tests = { path: e2eTestPath };
   }
+  if (personas) {
+    result.personas = personas;
+  }
   return result;
 }

package/src/config/schema.ts

@@ -2,6 +2,12 @@
 
 import { z } from 'zod';
 
+// Persona configuration for agent personality
+const PersonaSchema = z.object({
+  name: z.string(),
+  persona: z.string(),
+});
+
 // Model configuration for each agent type
 const ModelConfigSchema = z.object({
   provider: z.enum(['anthropic', 'openai']),
@@ -10,6 +16,7 @@ const ModelConfigSchema = z.object({
   temperature: z.number().min(0).max(2).default(0.5),
   cli_tool: z.enum(['claude', 'codex', 'gemini']).optional().default('claude'),
   safety_mode: z.enum(['safe', 'unsafe']).optional().default('unsafe'),
+  personas: z.array(PersonaSchema).optional().default([]),
 });
 
 // Models configuration for all agent types
@@ -324,6 +331,7 @@ export const HiveConfigSchema = z.object({
 });
 
 // Export types
+export type PersonaConfig = z.infer<typeof PersonaSchema>;
 export type ModelConfig = z.infer<typeof ModelConfigSchema>;
 export type ModelsConfig = z.infer<typeof ModelsConfigSchema>;
 export type ScalingConfig = z.infer<typeof ScalingConfigSchema>;
@@ -385,6 +393,8 @@ models:
     cli_tool: claude
     # Runtime safety policy (safe = approval prompts, unsafe = full automation)
     safety_mode: unsafe
+    # Agent personas can be configured during 'hive init'.
+    # Re-run 'hive init --force' to reconfigure.
 
   senior:
     provider: anthropic
@@ -393,6 +403,8 @@ models:
     temperature: 0.5
     cli_tool: claude
     safety_mode: unsafe
+    # Agent personas can be configured during 'hive init'.
+    # Re-run 'hive init --force' to reconfigure.
 
   intermediate:
     provider: anthropic
@@ -401,6 +413,8 @@ models:
     temperature: 0.3
     cli_tool: claude
     safety_mode: unsafe
+    # Agent personas can be configured during 'hive init'.
+    # Re-run 'hive init --force' to reconfigure.
 
   junior:
     provider: anthropic
@@ -409,6 +423,8 @@ models:
     temperature: 0.2
     cli_tool: claude
     safety_mode: unsafe
+    # Agent personas can be configured during 'hive init'.
+    # Re-run 'hive init --force' to reconfigure.
 
   qa:
     provider: anthropic
@@ -417,6 +433,8 @@ models:
     temperature: 0.2
     cli_tool: claude
     safety_mode: unsafe
+    # Agent personas can be configured during 'hive init'.
+    # Re-run 'hive init --force' to reconfigure.
 
   feature_test:
     provider: anthropic
@@ -425,6 +443,8 @@ models:
     temperature: 0.3
     cli_tool: claude
     safety_mode: unsafe
+    # Agent personas can be configured during 'hive init'.
+    # Re-run 'hive init --force' to reconfigure.
 
 # Team scaling rules
 scaling:

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

@@ -122,6 +122,7 @@ describe('context-files module', () => {
           temperature: 0.7,
           cli_tool: 'claude',
           safety_mode: 'unsafe',
+          personas: [],
         },
         senior: {
           provider: 'anthropic',
@@ -130,6 +131,7 @@ describe('context-files module', () => {
           temperature: 0.5,
           cli_tool: 'claude',
           safety_mode: 'unsafe',
+          personas: [],
         },
         intermediate: {
           provider: 'anthropic',
@@ -138,6 +140,7 @@ describe('context-files module', () => {
           temperature: 0.3,
           cli_tool: 'claude',
           safety_mode: 'unsafe',
+          personas: [],
         },
         junior: {
           provider: 'anthropic',
@@ -146,6 +149,7 @@ describe('context-files module', () => {
           temperature: 0.3,
           cli_tool: 'claude',
           safety_mode: 'unsafe',
+          personas: [],
         },
         qa: {
           provider: 'anthropic',
@@ -154,6 +158,7 @@ describe('context-files module', () => {
           temperature: 0.2,
           cli_tool: 'claude',
           safety_mode: 'unsafe',
+          personas: [],
         },
         feature_test: {
           provider: 'anthropic',
@@ -162,6 +167,7 @@ describe('context-files module', () => {
           temperature: 0.3,
           cli_tool: 'claude',
           safety_mode: 'unsafe',
+          personas: [],
         },
       },
       scaling: {