Merge branch 'main' into cw/agent-details-conflict-1772802863659

# Conflicts:
#	docs/server-api.md

apps/server/trpc/routers/agent.ts

@@ -202,6 +202,17 @@ export function agentProcedures(publicProcedure: ProcedureBuilder) {
         return candidates[0] ?? null;
       }),
 
+    getTaskAgent: publicProcedure
+      .input(z.object({ taskId: z.string().min(1) }))
+      .query(async ({ ctx, input }): Promise<AgentInfo | null> => {
+        const agentManager = requireAgentManager(ctx);
+        const all = await agentManager.list();
+        const matches = all
+          .filter(a => a.taskId === input.taskId)
+          .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+        return matches[0] ?? null;
+      }),
+
     getActiveConflictAgent: publicProcedure
       .input(z.object({ initiativeId: z.string().min(1) }))
       .query(async ({ ctx, input }): Promise<AgentInfo | null> => {
@@ -225,12 +236,15 @@ export function agentProcedures(publicProcedure: ProcedureBuilder) {
 
     getAgentOutput: publicProcedure
       .input(agentIdentifierSchema)
-      .query(async ({ ctx, input }): Promise<string> => {
+      .query(async ({ ctx, input }) => {
         const agent = await resolveAgent(ctx, input);
         const logChunkRepo = requireLogChunkRepository(ctx);
 
         const chunks = await logChunkRepo.findByAgentId(agent.id);
-        return chunks.map(c => c.content).join('');
+        return chunks.map(c => ({
+          content: c.content,
+          createdAt: c.createdAt.toISOString(),
+        }));
       }),
 
     onAgentOutput: publicProcedure

apps/server/trpc/routers/initiative-activity.ts

@@ -9,6 +9,7 @@ export interface ActiveArchitectAgent {
   initiativeId: string;
   mode: string;
   status: string;
+  name?: string;
 }
 
 const MODE_TO_STATE: Record<string, InitiativeActivityState> = {
@@ -30,6 +31,18 @@ export function deriveInitiativeActivity(
   if (initiative.status === 'archived') {
     return { ...base, state: 'archived' };
   }
+
+  // Check for active conflict resolution agent — takes priority over pending_review
+  // because the agent is actively working to resolve merge conflicts
+  const conflictAgent = activeArchitectAgents?.find(
+    a => a.initiativeId === initiative.id
+      && a.name?.startsWith('conflict-')
+      && (a.status === 'running' || a.status === 'waiting_for_input'),
+  );
+  if (conflictAgent) {
+    return { ...base, state: 'resolving_conflict' };
+  }
+
   if (initiative.status === 'pending_review') {
     return { ...base, state: 'pending_review' };
   }
@@ -41,6 +54,7 @@ export function deriveInitiativeActivity(
   // so architect agents (discuss/plan/detail/refine) surface activity
   const activeAgent = activeArchitectAgents?.find(
     a => a.initiativeId === initiative.id
+      && !a.name?.startsWith('conflict-')
       && (a.status === 'running' || a.status === 'waiting_for_input'),
   );
   if (activeAgent) {

apps/server/trpc/routers/initiative.ts

@@ -129,27 +129,42 @@ export function initiativeProcedures(publicProcedure: ProcedureBuilder) {
             : await repo.findAll();
         }
 
-        // Fetch active architect agents once for all initiatives
+        // Fetch active agents once for all initiatives (architect + conflict)
         const ARCHITECT_MODES = ['discuss', 'plan', 'detail', 'refine'];
         const allAgents = ctx.agentManager ? await ctx.agentManager.list() : [];
         const activeArchitectAgents = allAgents
           .filter(a =>
-            ARCHITECT_MODES.includes(a.mode ?? '')
+            (ARCHITECT_MODES.includes(a.mode ?? '') || a.name?.startsWith('conflict-'))
             && (a.status === 'running' || a.status === 'waiting_for_input')
             && !a.userDismissedAt,
           )
-          .map(a => ({ initiativeId: a.initiativeId ?? '', mode: a.mode ?? '', status: a.status }));
+          .map(a => ({ initiativeId: a.initiativeId ?? '', mode: a.mode ?? '', status: a.status, name: a.name }));
+
+        // Batch-fetch projects for all initiatives
+        const projectRepo = ctx.projectRepository;
+        const projectsByInitiativeId = new Map<string, Array<{ id: string; name: string }>>();
+        if (projectRepo) {
+          await Promise.all(initiatives.map(async (init) => {
+            const projects = await projectRepo.findProjectsByInitiativeId(init.id);
+            projectsByInitiativeId.set(init.id, projects.map(p => ({ id: p.id, name: p.name })));
+          }));
+        }
+
+        const addProjects = (init: typeof initiatives[0]) => ({
+          projects: projectsByInitiativeId.get(init.id) ?? [],
+        });
 
         if (ctx.phaseRepository) {
           const phaseRepo = ctx.phaseRepository;
           return Promise.all(initiatives.map(async (init) => {
             const phases = await phaseRepo.findByInitiativeId(init.id);
-            return { ...init, activity: deriveInitiativeActivity(init, phases, activeArchitectAgents) };
+            return { ...init, ...addProjects(init), activity: deriveInitiativeActivity(init, phases, activeArchitectAgents) };
           }));
         }
 
         return initiatives.map(init => ({
           ...init,
+          ...addProjects(init),
           activity: deriveInitiativeActivity(init, [], activeArchitectAgents),
         }));
       }),
@@ -473,6 +488,7 @@ export function initiativeProcedures(publicProcedure: ProcedureBuilder) {
           initiativeId: input.initiativeId,
           baseBranch: initiative.branch,
           branchName: tempBranch,
+          skipPromptExtras: true,
         });
       }),
   };

apps/server/trpc/subscriptions.ts

@@ -70,6 +70,7 @@ export const ALL_EVENT_TYPES: DomainEventType[] = [
   'chat:session_closed',
   'initiative:pending_review',
   'initiative:review_approved',
+  'initiative:changes_requested',
 ];
 
 /**
@@ -102,6 +103,7 @@ export const TASK_EVENT_TYPES: DomainEventType[] = [
   'phase:merged',
   'initiative:pending_review',
   'initiative:review_approved',
+  'initiative:changes_requested',
 ];
 
 /**