agentxchain 2.128.0 → 2.130.0

package/src/lib/mission-plans.js

@@ -10,6 +10,8 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from
 import { randomUUID } from 'crypto';
 import { join } from 'path';
 import { loadChainReport } from './chain-reports.js';
+import { readBarriers, readCoordinatorHistory } from './coordinator-state.js';
+import { loadCoordinatorConfig } from './coordinator-config.js';
 
 // ── Plan artifact directory ──────────────────────────────────────────────────
 
@@ -140,20 +142,81 @@ export function validatePlannerOutput(output) {
 
 // ── Plan artifact creation ───────────────────────────────────────────────────
 
+// ── Coordinator phase alignment ─────────────────────────────────────────────
+
+/**
+ * Validate that plan workstream phases align with coordinator config phases.
+ * Returns { ok: true } or { ok: false, errors: string[] }.
+ */
+export function validatePlanCoordinatorPhaseAlignment(workstreams, coordinatorConfig) {
+  if (!coordinatorConfig) return { ok: true };
+
+  const errors = [];
+  const coordinatorPhases = coordinatorConfig.routing
+    ? new Set(Object.keys(coordinatorConfig.routing))
+    : new Set(['planning', 'implementation', 'qa']);
+
+  for (let i = 0; i < workstreams.length; i++) {
+    const ws = workstreams[i];
+    if (!Array.isArray(ws.phases)) continue;
+    for (const phase of ws.phases) {
+      if (!coordinatorPhases.has(phase)) {
+        errors.push(
+          `workstreams[${i}] ("${ws.workstream_id}"): phase "${phase}" is not defined in coordinator config. ` +
+          `Valid phases: ${[...coordinatorPhases].join(', ')}`,
+        );
+      }
+    }
+  }
+
+  return errors.length > 0 ? { ok: false, errors } : { ok: true };
+}
+
+/**
+ * Build coordinator_scope metadata for a plan artifact.
+ */
+function buildCoordinatorScope(mission, coordinatorConfig) {
+  if (!mission.coordinator || !coordinatorConfig) return null;
+
+  const repoIds = coordinatorConfig.repos ? Object.keys(coordinatorConfig.repos) : [];
+  const phases = coordinatorConfig.routing
+    ? Object.keys(coordinatorConfig.routing)
+    : ['planning', 'implementation', 'qa'];
+  const coordinatorWorkstreams = coordinatorConfig.workstreams
+    ? Object.keys(coordinatorConfig.workstreams)
+    : [];
+
+  return {
+    super_run_id: mission.coordinator.super_run_id || null,
+    repo_ids: repoIds,
+    phases,
+    coordinator_workstream_ids: coordinatorWorkstreams,
+    bound_at: new Date().toISOString(),
+  };
+}
+
 /**
  * Create a plan artifact from validated planner output.
  *
  * @param {string} root - project root
  * @param {object} mission - mission artifact (must have mission_id, goal)
- * @param {object} options - { constraints, roleHints, plannerOutput }
+ * @param {object} options - { constraints, roleHints, plannerOutput, coordinatorConfig }
  * @returns {{ ok: boolean, plan?: object, errors?: string[] }}
  */
-export function createPlanArtifact(root, mission, { constraints = [], roleHints = [], plannerOutput }) {
+export function createPlanArtifact(root, mission, { constraints = [], roleHints = [], plannerOutput, coordinatorConfig = null }) {
   const validation = validatePlannerOutput(plannerOutput);
   if (!validation.ok) {
     return { ok: false, errors: validation.errors };
   }
 
+  // Validate phase alignment with coordinator when mission is coordinator-bound
+  if (coordinatorConfig) {
+    const phaseCheck = validatePlanCoordinatorPhaseAlignment(validation.workstreams, coordinatorConfig);
+    if (!phaseCheck.ok) {
+      return { ok: false, errors: phaseCheck.errors };
+    }
+  }
+
   const missionId = mission.mission_id;
   const existingPlans = loadAllPlans(root, missionId);
   const supersedes = existingPlans[0] || null;
@@ -173,6 +236,8 @@ export function createPlanArtifact(root, mission, { constraints = [], roleHints
     launch_status: Array.isArray(ws.depends_on) && ws.depends_on.length > 0 ? 'blocked' : 'ready',
   }));
 
+  const coordinatorScope = buildCoordinatorScope(mission, coordinatorConfig);
+
   const plan = {
     plan_id: planId,
     mission_id: missionId,
@@ -189,6 +254,7 @@ export function createPlanArtifact(root, mission, { constraints = [], roleHints
       mode: 'llm_one_shot',
       model: 'configured mission planner',
     },
+    ...(coordinatorScope ? { coordinator_scope: coordinatorScope } : {}),
     workstreams,
     launch_records: [],
   };
@@ -314,7 +380,7 @@ export function buildPlanProgressSummary(plan) {
   const workstreamStatusCounts = getWorkstreamStatusSummary(plan);
   const completedCount = workstreamStatusCounts.completed || 0;
 
-  return {
+  const summary = {
     plan_id: plan.plan_id,
     mission_id: plan.mission_id,
     status: plan.status,
@@ -336,6 +402,14 @@ export function buildPlanProgressSummary(plan) {
       ? 0
       : Math.round((completedCount / workstreams.length) * 100),
   };
+
+  if (plan.coordinator_scope) {
+    summary.coordinator_bound = true;
+    summary.coordinator_repo_count = (plan.coordinator_scope.repo_ids || []).length;
+    summary.coordinator_phases = plan.coordinator_scope.phases || [];
+  }
+
+  return summary;
 }
 
 // ── Workstream launch ───────────────────────────────────────────────────────
@@ -349,6 +423,303 @@ export function didChainFinishSuccessfully(chainReport) {
   return lastRun?.status === 'completed';
 }
 
+function getCoordinatorCompletionBarrierId(workstreamId) {
+  return `${workstreamId}_completion`;
+}
+
+function getAcceptedRepoIdsFromHistory(history, workstreamId) {
+  return [
+    ...new Set(
+      history
+        .filter((entry) => entry?.type === 'acceptance_projection' && entry.workstream_id === workstreamId && entry.repo_id)
+        .map((entry) => entry.repo_id),
+    ),
+  ];
+}
+
+function getLatestLaunchRecord(plan, workstreamId) {
+  const records = Array.isArray(plan.launch_records) ? plan.launch_records : [];
+  for (let i = records.length - 1; i >= 0; i--) {
+    if (records[i]?.workstream_id === workstreamId) {
+      return records[i];
+    }
+  }
+  return null;
+}
+
+function getLatestCoordinatorLaunchRecord(plan, workstreamId) {
+  const records = Array.isArray(plan.launch_records) ? plan.launch_records : [];
+  for (let i = records.length - 1; i >= 0; i--) {
+    if (records[i]?.workstream_id === workstreamId && records[i]?.dispatch_mode === 'coordinator') {
+      return records[i];
+    }
+  }
+  return null;
+}
+
+function clonePlan(plan) {
+  return JSON.parse(JSON.stringify(plan));
+}
+
+function readRepoLocalState(repoPath) {
+  if (!repoPath) return null;
+  try {
+    return JSON.parse(readFileSync(join(repoPath, '.agentxchain', 'state.json'), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function readRepoLocalHistory(repoPath) {
+  if (!repoPath) return [];
+  try {
+    const content = readFileSync(join(repoPath, '.agentxchain', 'history.jsonl'), 'utf8').trim();
+    if (!content) return [];
+    return content.split('\n').map((line) => JSON.parse(line));
+  } catch {
+    return [];
+  }
+}
+
+function isAcceptedRepoHistoryEntry(entry) {
+  return Boolean(entry?.accepted_at) || entry?.status === 'accepted';
+}
+
+const REPO_FAILURE_STATUSES = new Set(['failed_acceptance', 'failed', 'rejected', 'retrying', 'conflicted']);
+
+function getLatestRepoDispatches(launchRecord) {
+  const latestByRepo = new Map();
+  for (const dispatch of launchRecord?.repo_dispatches || []) {
+    if (dispatch?.repo_id) {
+      latestByRepo.set(dispatch.repo_id, dispatch);
+    }
+  }
+  return [...latestByRepo.values()];
+}
+
+function classifyRepoDispatchOutcome(repoPath, repoTurnId) {
+  const repoState = readRepoLocalState(repoPath);
+  const activeTurn = repoState?.active_turns?.[repoTurnId] || null;
+  if (activeTurn) {
+    if (REPO_FAILURE_STATUSES.has(activeTurn.status)) {
+      return {
+        status: 'failed',
+        source: 'repo_state',
+        failure_status: activeTurn.status,
+        failure_reason: activeTurn.failure_reason || activeTurn.last_rejection?.reason || null,
+      };
+    }
+    return { status: 'in_flight', source: 'repo_state', failure_status: null, failure_reason: null };
+  }
+
+  const repoHistory = readRepoLocalHistory(repoPath);
+  const matchingEntries = repoHistory.filter((entry) => entry?.turn_id === repoTurnId);
+  if (matchingEntries.some((entry) => isAcceptedRepoHistoryEntry(entry))) {
+    return { status: 'accepted', source: 'repo_history', failure_status: null, failure_reason: null };
+  }
+
+  for (let i = matchingEntries.length - 1; i >= 0; i--) {
+    const entry = matchingEntries[i];
+    if (REPO_FAILURE_STATUSES.has(entry?.status)) {
+      return {
+        status: 'failed',
+        source: 'repo_history',
+        failure_status: entry.status,
+        failure_reason: entry.failure_reason || entry.reason || entry.summary || null,
+      };
+    }
+  }
+
+  return { status: 'unknown', source: 'repo_state', failure_status: null, failure_reason: null };
+}
+
+function buildCoordinatorRepoFailures(coordinatorConfig, launchRecord) {
+  const failures = [];
+  for (const dispatch of getLatestRepoDispatches(launchRecord)) {
+    const repoPath = coordinatorConfig?.repos?.[dispatch.repo_id]?.resolved_path || null;
+    const outcome = classifyRepoDispatchOutcome(repoPath, dispatch.repo_turn_id);
+    if (outcome.status !== 'failed') {
+      continue;
+    }
+
+    failures.push({
+      repo_id: dispatch.repo_id,
+      repo_turn_id: dispatch.repo_turn_id,
+      role: dispatch.role || null,
+      failure_status: outcome.failure_status,
+      failure_reason: outcome.failure_reason,
+      detected_from: outcome.source,
+    });
+  }
+  return failures;
+}
+
+function buildCoordinatorWorkstreamProgress(coordinatorConfig, history, barriers, workstreamId) {
+  const coordinatorWorkstream = coordinatorConfig?.workstreams?.[workstreamId];
+  if (!coordinatorWorkstream) {
+    return null;
+  }
+
+  const acceptedRepoIds = getAcceptedRepoIdsFromHistory(history, workstreamId);
+  const allRepos = Array.isArray(coordinatorWorkstream.repos) ? coordinatorWorkstream.repos : [];
+  const pendingRepoIds = allRepos.filter((repoId) => !acceptedRepoIds.includes(repoId));
+  const barrierId = getCoordinatorCompletionBarrierId(workstreamId);
+  const barrier = barriers?.[barrierId] || null;
+
+  return {
+    repo_ids: allRepos,
+    repo_count: allRepos.length,
+    accepted_repo_ids: acceptedRepoIds,
+    accepted_repo_count: acceptedRepoIds.length,
+    pending_repo_ids: pendingRepoIds,
+    completion_barrier_id: barrierId,
+    completion_barrier_type: coordinatorWorkstream.completion_barrier || barrier?.type || null,
+    completion_barrier_status: barrier?.status || (pendingRepoIds.length === 0 ? 'satisfied' : 'pending'),
+  };
+}
+
+function synchronizeCoordinatorWorkstreamStatuses(root, plan, coordinatorConfig, history, barriers) {
+  let changed = false;
+
+  for (const ws of plan.workstreams || []) {
+    const progress = buildCoordinatorWorkstreamProgress(coordinatorConfig, history, barriers, ws.workstream_id);
+    if (!progress) {
+      continue;
+    }
+
+    const launchRecord = getLatestCoordinatorLaunchRecord(plan, ws.workstream_id);
+    const repoFailures = launchRecord
+      ? buildCoordinatorRepoFailures(coordinatorConfig, launchRecord)
+      : [];
+    if (launchRecord) {
+      launchRecord.accepted_repo_ids = [...progress.accepted_repo_ids];
+      launchRecord.pending_repo_ids = [...progress.pending_repo_ids];
+      launchRecord.repo_count = progress.repo_count;
+      launchRecord.accepted_repo_count = progress.accepted_repo_count;
+      launchRecord.repo_failures = repoFailures;
+      launchRecord.completion_barrier = {
+        barrier_id: progress.completion_barrier_id,
+        type: progress.completion_barrier_type,
+        status: progress.completion_barrier_status,
+      };
+    }
+
+    if (progress.completion_barrier_status === 'satisfied') {
+      if (ws.launch_status !== 'completed') {
+        ws.launch_status = 'completed';
+        changed = true;
+      }
+      if (launchRecord && launchRecord.status !== 'completed') {
+        launchRecord.status = 'completed';
+        launchRecord.completed_at = launchRecord.completed_at || new Date().toISOString();
+        changed = true;
+      }
+      continue;
+    }
+
+    if (repoFailures.length > 0) {
+      if (ws.launch_status !== 'needs_attention') {
+        ws.launch_status = 'needs_attention';
+        changed = true;
+      }
+      if (launchRecord && launchRecord.status !== 'needs_attention') {
+        launchRecord.status = 'needs_attention';
+        changed = true;
+      }
+      if (plan.status !== 'needs_attention') {
+        plan.status = 'needs_attention';
+        changed = true;
+      }
+      continue;
+    }
+
+    if ((launchRecord?.repo_dispatches?.length || 0) > 0 || progress.accepted_repo_count > 0) {
+      if (ws.launch_status !== 'launched') {
+        ws.launch_status = 'launched';
+        changed = true;
+      }
+      if (launchRecord && launchRecord.status !== 'launched') {
+        launchRecord.status = 'launched';
+        changed = true;
+      }
+    }
+  }
+
+  for (const ws of plan.workstreams || []) {
+    if (ws.launch_status !== 'blocked') {
+      continue;
+    }
+    const stillBlocked = checkDependencySatisfaction(plan, ws, root);
+    if (stillBlocked.length === 0) {
+      ws.launch_status = 'ready';
+      changed = true;
+    }
+  }
+
+  const allCompleted = Array.isArray(plan.workstreams) && plan.workstreams.length > 0
+    && plan.workstreams.every((ws) => ws.launch_status === 'completed');
+  if (allCompleted && plan.status !== 'completed') {
+    plan.status = 'completed';
+    changed = true;
+  } else if (plan.status === 'needs_attention' && !(plan.workstreams || []).some((ws) => ws.launch_status === 'needs_attention')) {
+    plan.status = 'approved';
+    changed = true;
+  }
+
+  if (changed) {
+    plan.updated_at = new Date().toISOString();
+  }
+
+  return changed;
+}
+
+export function synchronizeCoordinatorPlanState(root, mission, plan) {
+  if (!mission?.coordinator?.workspace_path || !plan?.coordinator_scope) {
+    return { ok: true, plan };
+  }
+
+  const workspacePath = mission.coordinator.workspace_path;
+  const history = readCoordinatorHistory(workspacePath);
+  const barriers = readBarriers(workspacePath);
+  const coordinatorConfigResult = loadCoordinatorConfig(workspacePath);
+  if (!coordinatorConfigResult.ok) {
+    return { ok: false, error: `Coordinator config validation failed at ${workspacePath}: ${(coordinatorConfigResult.errors || []).join('; ')}` };
+  }
+  const coordinatorConfig = coordinatorConfigResult.config;
+
+  const persistedPlan = clonePlan(plan);
+  const changed = synchronizeCoordinatorWorkstreamStatuses(root, persistedPlan, coordinatorConfig, history, barriers);
+  if (changed) {
+    writePlanArtifact(root, mission.mission_id, persistedPlan);
+  }
+
+  const enrichedPlan = clonePlan(persistedPlan);
+  for (const ws of enrichedPlan.workstreams || []) {
+    const progress = buildCoordinatorWorkstreamProgress(coordinatorConfig, history, barriers, ws.workstream_id);
+    if (!progress) {
+      continue;
+    }
+    const launchRecord = getLatestCoordinatorLaunchRecord(enrichedPlan, ws.workstream_id);
+    const repoFailures = launchRecord?.repo_failures || [];
+    ws.coordinator_progress = progress;
+    ws.coordinator_progress.failed_repo_ids = repoFailures.map((failure) => failure.repo_id);
+    ws.coordinator_progress.repo_failure_count = repoFailures.length;
+    if (repoFailures.length > 0) {
+      ws.coordinator_progress.repo_failures = repoFailures;
+    }
+    if (launchRecord) {
+      launchRecord.coordinator_progress = progress;
+      launchRecord.coordinator_progress.failed_repo_ids = ws.coordinator_progress.failed_repo_ids;
+      launchRecord.coordinator_progress.repo_failure_count = repoFailures.length;
+      if (repoFailures.length > 0) {
+        launchRecord.coordinator_progress.repo_failures = repoFailures;
+      }
+    }
+  }
+
+  return { ok: true, plan: enrichedPlan, changed };
+}
+
 /**
  * Check whether a workstream's dependencies are satisfied.
  * A dependency is satisfied when its launch_record exists AND the bound chain's
@@ -361,11 +732,22 @@ export function checkDependencySatisfaction(plan, workstream, root) {
   if (!Array.isArray(workstream.depends_on)) return unsatisfied;
 
   for (const depId of workstream.depends_on) {
+    const dependencyWorkstream = (plan.workstreams || []).find((candidate) => candidate.workstream_id === depId);
+    if (dependencyWorkstream?.launch_status === 'completed') {
+      continue;
+    }
+
     const depRecord = (plan.launch_records || []).find((r) => r.workstream_id === depId);
     if (!depRecord) {
       unsatisfied.push(depId);
       continue;
     }
+    if (depRecord.dispatch_mode === 'coordinator') {
+      if (depRecord.status !== 'completed') {
+        unsatisfied.push(depId);
+      }
+      continue;
+    }
     // Check that the dependency chain actually completed
     const chainReport = loadChainReport(root, depRecord.chain_id);
     if (!didChainFinishSuccessfully(chainReport)) {
@@ -421,6 +803,7 @@ export function launchWorkstream(root, missionId, planId, workstreamId, options
   const now = new Date().toISOString();
   const launchRecord = {
     workstream_id: workstreamId,
+    dispatch_mode: 'chain',
     chain_id: chainId,
     launched_at: now,
     status: 'launched',
@@ -438,6 +821,89 @@ export function launchWorkstream(root, missionId, planId, workstreamId, options
   return { ok: true, plan, workstream: ws, chainId, launchRecord };
 }
 
+export function launchCoordinatorWorkstream(root, mission, planId, workstreamId, dispatchResult, coordinatorConfig) {
+  const plan = loadPlan(root, mission.mission_id, planId);
+  if (!plan) {
+    return { ok: false, error: `Plan not found: ${planId}` };
+  }
+  if (!mission?.coordinator?.super_run_id) {
+    return { ok: false, error: 'Mission is not bound to a coordinator run.' };
+  }
+
+  const allowNeedsAttention = dispatchResult?.allowNeedsAttention === true;
+  if (plan.status !== 'approved' && !(allowNeedsAttention && plan.status === 'needs_attention')) {
+    return {
+      ok: false,
+      error: `Plan ${planId} is not approved (status: "${plan.status}"). Approve the plan before launching workstreams.`,
+    };
+  }
+
+  const ws = plan.workstreams.find((candidate) => candidate.workstream_id === workstreamId);
+  if (!ws) {
+    return { ok: false, error: `Workstream not found: ${workstreamId}` };
+  }
+  if (ws.launch_status === 'completed') {
+    return { ok: false, error: `Workstream ${workstreamId} is already completed.` };
+  }
+
+  const coordinatorWorkstream = coordinatorConfig?.workstreams?.[workstreamId];
+  if (!coordinatorWorkstream) {
+    return { ok: false, error: `Coordinator config does not declare workstream ${workstreamId}.` };
+  }
+
+  const unsatisfied = checkDependencySatisfaction(plan, ws, root);
+  if (unsatisfied.length > 0) {
+    return {
+      ok: false,
+      error: `Workstream ${workstreamId} has unsatisfied dependencies: ${unsatisfied.join(', ')}. Launch and complete those workstreams first.`,
+    };
+  }
+
+  const now = new Date().toISOString();
+  let launchRecord = getLatestCoordinatorLaunchRecord(plan, workstreamId);
+  if (!launchRecord || launchRecord.status === 'completed' || launchRecord.status === 'failed') {
+    launchRecord = {
+      workstream_id: workstreamId,
+      dispatch_mode: 'coordinator',
+      super_run_id: mission.coordinator.super_run_id,
+      launched_at: now,
+      status: 'launched',
+      completion_barrier: {
+        barrier_id: getCoordinatorCompletionBarrierId(workstreamId),
+        type: coordinatorWorkstream.completion_barrier || null,
+      },
+      repo_dispatches: [],
+    };
+    if (!Array.isArray(plan.launch_records)) {
+      plan.launch_records = [];
+    }
+    plan.launch_records.push(launchRecord);
+  }
+
+  launchRecord.status = 'launched';
+  if (!Array.isArray(launchRecord.repo_dispatches)) {
+    launchRecord.repo_dispatches = [];
+  }
+  launchRecord.repo_dispatches.push({
+    repo_id: dispatchResult.repo_id,
+    repo_turn_id: dispatchResult.turn_id,
+    role: dispatchResult.role,
+    dispatched_at: now,
+    bundle_path: dispatchResult.bundle_path,
+    context_ref: dispatchResult.context_ref || null,
+  });
+
+  ws.launch_status = 'launched';
+  if (plan.status === 'needs_attention') {
+    plan.status = 'approved';
+  }
+  plan.updated_at = now;
+  writePlanArtifact(root, mission.mission_id, plan);
+
+  const synced = synchronizeCoordinatorPlanState(root, mission, plan);
+  return { ok: true, plan: synced.ok ? synced.plan : plan, workstream: ws, launchRecord };
+}
+
 /**
  * Record the outcome of a launched workstream after its chain completes.
  *
@@ -529,6 +995,7 @@ export function retryWorkstream(root, missionId, planId, workstreamId, options =
   const now = new Date().toISOString();
   const launchRecord = {
     workstream_id: workstreamId,
+    dispatch_mode: 'chain',
     chain_id: chainId,
     launched_at: now,
     status: 'launched',
@@ -579,9 +1046,16 @@ export function getWorkstreamStatusSummary(plan) {
 
 /**
  * Build the system+user prompt for the mission planner LLM call.
+ *
+ * @param {object} mission - mission artifact
+ * @param {string[]} constraints - user constraints
+ * @param {string[]} roleHints - available role names
+ * @param {object} [coordinatorConfig] - coordinator config when mission is multi-repo
  */
-export function buildPlannerPrompt(mission, constraints, roleHints) {
-  const systemPrompt = `You are a mission decomposition planner for AgentXchain, a governed multi-agent software delivery system.
+export function buildPlannerPrompt(mission, constraints, roleHints, coordinatorConfig = null) {
+  const isMultiRepo = !!coordinatorConfig;
+
+  let systemPrompt = `You are a mission decomposition planner for AgentXchain, a governed multi-agent software delivery system.
 
 Given a mission goal, optional constraints, and optional role hints, produce a JSON object with a single "workstreams" array.
 
@@ -599,7 +1073,24 @@ Rules:
 - Do NOT include chain_id — chain IDs are runtime artifacts.
 - Keep workstream count between 2 and 8.
 - Each workstream should be a meaningful delivery slice, not a single task.
-- Use concrete, testable acceptance checks.
+- Use concrete, testable acceptance checks.`;
+
+  if (isMultiRepo) {
+    const validPhases = coordinatorConfig.routing
+      ? Object.keys(coordinatorConfig.routing)
+      : ['planning', 'implementation', 'qa'];
+    const repoIds = coordinatorConfig.repos ? Object.keys(coordinatorConfig.repos) : [];
+
+    systemPrompt += `
+
+Multi-repo coordinator context:
+- This mission spans multiple repositories: ${repoIds.join(', ')}.
+- Valid phases are: ${validPhases.join(', ')}. Use ONLY these phases in workstream phase arrays.
+- Workstreams should account for cross-repo coordination needs (interface alignment, shared decisions, phased rollout).
+- Prefer workstreams that map cleanly to coordinator barrier types (all_repos_accepted, interface_alignment, named_decisions).`;
+  }
+
+  systemPrompt += `
 
 Respond with ONLY valid JSON. No markdown, no explanation.`;
 
@@ -611,6 +1102,19 @@ Respond with ONLY valid JSON. No markdown, no explanation.`;
     parts.push(`Available roles: ${roleHints.join(', ')}`);
   }
 
+  if (isMultiRepo) {
+    const repoEntries = Object.entries(coordinatorConfig.repos || {});
+    if (repoEntries.length > 0) {
+      const repoLines = repoEntries.map(([id, repo]) => `- ${id}: ${repo.path || id}`);
+      parts.push(`Repos in coordinator scope:\n${repoLines.join('\n')}`);
+    }
+    const wsEntries = Object.entries(coordinatorConfig.workstreams || {});
+    if (wsEntries.length > 0) {
+      const wsLines = wsEntries.map(([id, ws]) => `- ${id} (phase: ${ws.phase}, repos: ${(ws.repos || []).join(', ')})`);
+      parts.push(`Coordinator workstreams (reference — plan workstreams may differ):\n${wsLines.join('\n')}`);
+    }
+  }
+
   const userPrompt = parts.join('\n\n');
   return { systemPrompt, userPrompt };
 }