@doingdev/opencode-claude-manager-plugin 0.1.46 → 0.1.49

package/dist/src/manager/persistent-manager.js

@@ -17,7 +17,7 @@ export class PersistentManager {
      * Creates a new session if none exists.
      */
     async sendMessage(cwd, message, options, onEvent) {
-        const result = await this.sessionController.sendMessage(cwd, message, options, onEvent);
+        const result = await this.sessionController.sendMessage(message, options, onEvent);
         if (result.sessionId && result.events.length > 0) {
             await this.transcriptStore.appendEvents(cwd, result.sessionId, result.events);
         }
@@ -35,8 +35,8 @@ export class PersistentManager {
     /**
      * Get the current git diff.
      */
-    async gitDiff() {
-        return this.gitOps.diff();
+    async gitDiff(options = {}) {
+        return this.gitOps.diff(options);
     }
     /**
      * Commit all current changes.
@@ -44,6 +44,18 @@ export class PersistentManager {
     async gitCommit(message) {
         return this.gitOps.commit(message);
     }
+    /**
+     * Get git status summary.
+     */
+    async gitStatus() {
+        return this.gitOps.status();
+    }
+    /**
+     * Get recent commit log.
+     */
+    async gitLog(count = 5) {
+        return this.gitOps.log(count);
+    }
     /**
      * Hard reset to discard all uncommitted changes.
      */
@@ -59,14 +71,14 @@ export class PersistentManager {
     /**
      * Clear the active session. Next send creates a fresh one.
      */
-    async clearSession(cwd) {
-        return this.sessionController.clearSession(cwd);
+    async clearSession() {
+        return this.sessionController.clearSession();
     }
     /**
      * Compact the current session to free context.
      */
     async compactSession(cwd, onEvent) {
-        const result = await this.sessionController.compactSession(cwd, onEvent);
+        const result = await this.sessionController.compactSession(onEvent);
         if (result.sessionId && result.events.length > 0) {
             await this.transcriptStore.appendEvents(cwd, result.sessionId, result.events);
         }
@@ -108,7 +120,7 @@ export class PersistentManager {
         await this.stateStore.saveRun(runRecord);
         await onProgress?.(runRecord);
         try {
-            const result = await this.sessionController.sendMessage(cwd, task, options, async (event) => {
+            const result = await this.sessionController.sendMessage(task, options, async (event) => {
                 // Update run record with progress events
                 const currentRun = await this.stateStore.getRun(cwd, runId);
                 if (currentRun) {
@@ -155,12 +167,6 @@ export class PersistentManager {
             return { run: failedRun };
         }
     }
-    /**
-     * Try to restore session state from disk on startup.
-     */
-    async tryRestore(cwd) {
-        return this.sessionController.tryRestore(cwd);
-    }
     listRuns(cwd) {
         return this.stateStore.listRuns(cwd);
     }

package/dist/src/manager/session-controller.d.ts

@@ -5,9 +5,11 @@ export declare class SessionController {
     private readonly sdkAdapter;
     private readonly contextTracker;
     private readonly sessionPrompt;
+    private readonly wrapperType;
+    private readonly worktree;
     private readonly modePrefixes;
     private activeSessionId;
-    constructor(sdkAdapter: ClaudeAgentSdkAdapter, contextTracker: ContextTracker, sessionPrompt: string, modePrefixes?: {
+    constructor(sdkAdapter: ClaudeAgentSdkAdapter, contextTracker: ContextTracker, sessionPrompt: string | undefined, wrapperType: string, worktree: string, modePrefixes?: {
         plan: string;
         free: string;
     });
@@ -17,28 +19,23 @@ export declare class SessionController {
      * Send a message to the persistent session. Creates one if none exists.
      * Returns the session result including usage data.
      */
-    sendMessage(cwd: string, message: string, options?: {
+    sendMessage(message: string, options?: {
         model?: string;
         effort?: 'low' | 'medium' | 'high' | 'max';
         mode?: SessionMode;
+        sessionSystemPrompt?: string;
         abortSignal?: AbortSignal;
     }, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
     /**
      * Send /compact to the current session to compress context.
      */
-    compactSession(cwd: string, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
+    compactSession(onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
     /**
      * Clear the current session. The next sendMessage will create a fresh one.
      */
-    clearSession(cwd: string): Promise<string | null>;
+    clearSession(): Promise<string | null>;
     /**
      * Get current context tracking snapshot.
      */
     getContextSnapshot(): SessionContextSnapshot;
-    /**
-     * Try to restore active session from persisted state on startup.
-     */
-    tryRestore(cwd: string): Promise<boolean>;
-    private persistActiveSession;
-    private removeActiveSession;
 }

package/dist/src/manager/session-controller.js

@@ -1,19 +1,20 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-const ACTIVE_SESSION_FILE = '.claude-manager/active-session.json';
 export class SessionController {
     sdkAdapter;
     contextTracker;
     sessionPrompt;
+    wrapperType;
+    worktree;
     modePrefixes;
     activeSessionId = null;
-    constructor(sdkAdapter, contextTracker, sessionPrompt, modePrefixes = {
+    constructor(sdkAdapter, contextTracker, sessionPrompt, wrapperType, worktree, modePrefixes = {
         plan: '',
         free: '',
     }) {
         this.sdkAdapter = sdkAdapter;
         this.contextTracker = contextTracker;
         this.sessionPrompt = sessionPrompt;
+        this.wrapperType = wrapperType;
+        this.worktree = worktree;
         this.modePrefixes = modePrefixes;
     }
     get isActive() {
@@ -26,12 +27,12 @@ export class SessionController {
      * Send a message to the persistent session. Creates one if none exists.
      * Returns the session result including usage data.
      */
-    async sendMessage(cwd, message, options, onEvent) {
+    async sendMessage(message, options, onEvent) {
         const mode = options?.mode ?? 'free';
         const prefix = this.modePrefixes[mode];
         const prompt = prefix ? `${prefix}\n\n${message}` : message;
         const input = {
-            cwd,
+            cwd: this.worktree,
             prompt,
             persistSession: true,
             permissionMode: mode === 'plan' ? 'plan' : 'acceptEdits',
@@ -46,8 +47,8 @@ export class SessionController {
             input.resumeSessionId = this.activeSessionId;
         }
         else {
-            // New session — use the base session prompt (project context is in the wrapper)
-            input.systemPrompt = this.sessionPrompt;
+            // New session — prefer dynamically constructed prompt from wrapper, fall back to static default
+            input.systemPrompt = options?.sessionSystemPrompt ?? this.sessionPrompt;
             input.model ??= 'claude-opus-4-6';
             input.effort ??= 'high';
         }
@@ -65,29 +66,26 @@ export class SessionController {
             outputTokens: result.outputTokens,
             contextWindowSize: result.contextWindowSize,
         });
-        // Persist active session state
-        await this.persistActiveSession(cwd);
         return result;
     }
     /**
      * Send /compact to the current session to compress context.
      */
-    async compactSession(cwd, onEvent) {
+    async compactSession(onEvent) {
         if (!this.activeSessionId) {
             throw new Error('No active session to compact');
         }
-        const result = await this.sendMessage(cwd, '/compact', undefined, onEvent);
+        const result = await this.sendMessage('/compact', undefined, onEvent);
         this.contextTracker.recordCompaction();
         return result;
     }
     /**
      * Clear the current session. The next sendMessage will create a fresh one.
      */
-    async clearSession(cwd) {
+    async clearSession() {
         const clearedId = this.activeSessionId;
         this.activeSessionId = null;
         this.contextTracker.reset();
-        await this.removeActiveSession(cwd);
         return clearedId;
     }
     /**
@@ -96,52 +94,4 @@ export class SessionController {
     getContextSnapshot() {
         return this.contextTracker.snapshot();
     }
-    /**
-     * Try to restore active session from persisted state on startup.
-     */
-    async tryRestore(cwd) {
-        const filePath = join(cwd, ACTIVE_SESSION_FILE);
-        try {
-            const raw = await readFile(filePath, 'utf-8');
-            const state = JSON.parse(raw);
-            if (state.sessionId && state.cwd === cwd) {
-                this.activeSessionId = state.sessionId;
-                this.contextTracker.restore(state);
-                return true;
-            }
-        }
-        catch {
-            // File doesn't exist or is corrupt — start fresh
-        }
-        return false;
-    }
-    async persistActiveSession(cwd) {
-        if (!this.activeSessionId) {
-            return;
-        }
-        const snap = this.contextTracker.snapshot();
-        const state = {
-            sessionId: this.activeSessionId,
-            cwd,
-            startedAt: new Date().toISOString(),
-            totalTurns: snap.totalTurns,
-            totalCostUsd: snap.totalCostUsd,
-            estimatedContextPercent: snap.estimatedContextPercent,
-            contextWindowSize: snap.contextWindowSize,
-            latestInputTokens: snap.latestInputTokens,
-        };
-        const filePath = join(cwd, ACTIVE_SESSION_FILE);
-        await mkdir(dirname(filePath), { recursive: true });
-        await writeFile(filePath, JSON.stringify(state, null, 2));
-    }
-    async removeActiveSession(cwd) {
-        const filePath = join(cwd, ACTIVE_SESSION_FILE);
-        try {
-            const { unlink } = await import('node:fs/promises');
-            await unlink(filePath);
-        }
-        catch {
-            // File doesn't exist — that's fine
-        }
-    }
 }

package/dist/src/manager/team-orchestrator.d.ts

@@ -0,0 +1,50 @@
+import type { ClaudeSessionEventHandler } from '../claude/claude-agent-sdk-adapter.js';
+import type { ClaudeSessionService } from '../claude/claude-session.service.js';
+import type { TeamStateStore } from '../state/team-state-store.js';
+import type { TranscriptStore } from '../state/transcript-store.js';
+import type { DiscoveredClaudeFile, EngineerName, EngineerTaskResult, EngineerWorkMode, SynthesizedPlanResult, TeamRecord } from '../types/contracts.js';
+interface DispatchEngineerInput {
+    teamId: string;
+    cwd: string;
+    engineer: EngineerName;
+    mode: EngineerWorkMode;
+    message: string;
+    model?: string;
+    abortSignal?: AbortSignal;
+    onEvent?: ClaudeSessionEventHandler;
+}
+export declare class TeamOrchestrator {
+    private readonly sessions;
+    private readonly teamStore;
+    private readonly transcriptStore;
+    private readonly engineerSessionPrompt;
+    private readonly projectClaudeFiles;
+    constructor(sessions: ClaudeSessionService, teamStore: TeamStateStore, transcriptStore: TranscriptStore, engineerSessionPrompt: string, projectClaudeFiles: DiscoveredClaudeFile[]);
+    getOrCreateTeam(cwd: string, teamId: string): Promise<TeamRecord>;
+    listTeams(cwd: string): Promise<TeamRecord[]>;
+    recordWrapperSession(cwd: string, teamId: string, engineer: EngineerName, wrapperSessionId: string): Promise<void>;
+    recordWrapperExchange(cwd: string, teamId: string, engineer: EngineerName, wrapperSessionId: string, mode: EngineerWorkMode, assignment: string, result: string): Promise<void>;
+    getWrapperSystemContext(cwd: string, teamId: string, engineer: EngineerName): Promise<string | null>;
+    findTeamByWrapperSession(cwd: string, wrapperSessionId: string): Promise<{
+        teamId: string;
+        engineer: EngineerName;
+    } | null>;
+    dispatchEngineer(input: DispatchEngineerInput): Promise<EngineerTaskResult>;
+    planWithTeam(input: {
+        teamId: string;
+        cwd: string;
+        request: string;
+        leadEngineer: EngineerName;
+        challengerEngineer: EngineerName;
+        model?: string;
+        abortSignal?: AbortSignal;
+    }): Promise<SynthesizedPlanResult>;
+    private updateEngineer;
+    private reserveEngineer;
+    private getEngineerState;
+    private normalizeTeamRecord;
+    private buildSessionSystemPrompt;
+    private buildEngineerPrompt;
+    private mapWorkModeToSessionMode;
+}
+export {};

package/dist/src/manager/team-orchestrator.js

@@ -0,0 +1,360 @@
+import { createEmptyEngineerRecord, createEmptyTeamRecord } from '../team/roster.js';
+import { ContextTracker } from './context-tracker.js';
+export class TeamOrchestrator {
+    sessions;
+    teamStore;
+    transcriptStore;
+    engineerSessionPrompt;
+    projectClaudeFiles;
+    constructor(sessions, teamStore, transcriptStore, engineerSessionPrompt, projectClaudeFiles) {
+        this.sessions = sessions;
+        this.teamStore = teamStore;
+        this.transcriptStore = transcriptStore;
+        this.engineerSessionPrompt = engineerSessionPrompt;
+        this.projectClaudeFiles = projectClaudeFiles;
+    }
+    async getOrCreateTeam(cwd, teamId) {
+        const existing = await this.teamStore.getTeam(cwd, teamId);
+        if (existing) {
+            return this.normalizeTeamRecord(existing);
+        }
+        const created = createEmptyTeamRecord(teamId, cwd);
+        await this.teamStore.saveTeam(created);
+        return created;
+    }
+    async listTeams(cwd) {
+        const teams = await this.teamStore.listTeams(cwd);
+        return teams.map((team) => this.normalizeTeamRecord(team));
+    }
+    async recordWrapperSession(cwd, teamId, engineer, wrapperSessionId) {
+        await this.updateEngineer(cwd, teamId, engineer, (entry) => ({
+            ...entry,
+            wrapperSessionId,
+        }));
+    }
+    async recordWrapperExchange(cwd, teamId, engineer, wrapperSessionId, mode, assignment, result) {
+        const timestamp = new Date().toISOString();
+        await this.updateEngineer(cwd, teamId, engineer, (entry) => ({
+            ...entry,
+            wrapperSessionId,
+            wrapperHistory: appendWrapperHistoryEntries(entry.wrapperHistory, [
+                { timestamp, type: 'assignment', mode, text: summarizeText(assignment, 320) },
+                { timestamp, type: 'result', mode, text: summarizeText(result, 320) },
+            ]),
+            lastMode: mode,
+            lastTaskSummary: summarizeMessage(assignment),
+            lastUsedAt: timestamp,
+        }));
+    }
+    async getWrapperSystemContext(cwd, teamId, engineer) {
+        const team = await this.getOrCreateTeam(cwd, teamId);
+        const state = this.getEngineerState(team, engineer);
+        if (state.wrapperHistory.length === 0) {
+            return null;
+        }
+        const historyLines = state.wrapperHistory.map((entry) => {
+            const modeLabel = entry.mode ? ` [${entry.mode}]` : '';
+            return `- ${entry.type}${modeLabel}: ${entry.text}`;
+        });
+        return [
+            `Persistent wrapper memory for ${engineer} in CTO team ${teamId}:`,
+            'Use this only to improve delegation quality and continuity.',
+            'Prefer the current assignment when it conflicts with older context.',
+            ...historyLines,
+        ].join('\n');
+    }
+    async findTeamByWrapperSession(cwd, wrapperSessionId) {
+        const teams = await this.listTeams(cwd);
+        for (const team of teams) {
+            for (const engineer of team.engineers) {
+                if (engineer.wrapperSessionId === wrapperSessionId) {
+                    return {
+                        teamId: team.id,
+                        engineer: engineer.name,
+                    };
+                }
+            }
+        }
+        return null;
+    }
+    async dispatchEngineer(input) {
+        const team = await this.getOrCreateTeam(input.cwd, input.teamId);
+        const engineerState = this.getEngineerState(team, input.engineer);
+        await this.reserveEngineer(input.cwd, input.teamId, input.engineer);
+        try {
+            const tracker = new ContextTracker();
+            if (engineerState.context.sessionId) {
+                tracker.restore({
+                    sessionId: engineerState.context.sessionId,
+                    totalTurns: engineerState.context.totalTurns,
+                    totalCostUsd: engineerState.context.totalCostUsd,
+                    estimatedContextPercent: engineerState.context.estimatedContextPercent,
+                    contextWindowSize: engineerState.context.contextWindowSize,
+                    latestInputTokens: engineerState.context.latestInputTokens,
+                });
+            }
+            const result = await this.sessions.runTask({
+                cwd: input.cwd,
+                prompt: this.buildEngineerPrompt(input.mode, input.message),
+                systemPrompt: engineerState.claudeSessionId
+                    ? undefined
+                    : this.buildSessionSystemPrompt(input.engineer, input.mode),
+                resumeSessionId: engineerState.claudeSessionId ?? undefined,
+                persistSession: true,
+                includePartialMessages: true,
+                permissionMode: this.mapWorkModeToSessionMode(input.mode) === 'plan' ? 'plan' : 'acceptEdits',
+                model: input.model,
+                effort: input.mode === 'implement' ? 'high' : 'medium',
+                settingSources: ['user'],
+                abortSignal: input.abortSignal,
+            }, input.onEvent);
+            tracker.recordResult({
+                sessionId: result.sessionId,
+                turns: result.turns,
+                totalCostUsd: result.totalCostUsd,
+                inputTokens: result.inputTokens,
+                outputTokens: result.outputTokens,
+                contextWindowSize: result.contextWindowSize,
+            });
+            if (result.sessionId && result.events.length > 0) {
+                await this.transcriptStore.appendEvents(input.cwd, result.sessionId, result.events);
+            }
+            const context = tracker.snapshot();
+            await this.updateEngineer(input.cwd, input.teamId, input.engineer, (entry) => ({
+                ...entry,
+                claudeSessionId: result.sessionId ?? engineerState.claudeSessionId,
+                busy: false,
+                lastMode: input.mode,
+                lastTaskSummary: summarizeMessage(input.message),
+                lastUsedAt: new Date().toISOString(),
+                context,
+            }));
+            return {
+                teamId: input.teamId,
+                engineer: input.engineer,
+                mode: input.mode,
+                sessionId: result.sessionId,
+                finalText: result.finalText,
+                turns: result.turns,
+                totalCostUsd: result.totalCostUsd,
+                inputTokens: result.inputTokens,
+                outputTokens: result.outputTokens,
+                contextWindowSize: result.contextWindowSize,
+                context,
+            };
+        }
+        catch (error) {
+            await this.updateEngineer(input.cwd, input.teamId, input.engineer, (engineer) => ({
+                ...engineer,
+                busy: false,
+            }));
+            throw error;
+        }
+    }
+    async planWithTeam(input) {
+        if (input.leadEngineer === input.challengerEngineer) {
+            throw new Error('Choose two different engineers for plan synthesis.');
+        }
+        const [leadDraft, challengerDraft] = await Promise.all([
+            this.dispatchEngineer({
+                teamId: input.teamId,
+                cwd: input.cwd,
+                engineer: input.leadEngineer,
+                mode: 'explore',
+                message: buildPlanDraftRequest('lead', input.request),
+                model: input.model,
+                abortSignal: input.abortSignal,
+            }),
+            this.dispatchEngineer({
+                teamId: input.teamId,
+                cwd: input.cwd,
+                engineer: input.challengerEngineer,
+                mode: 'explore',
+                message: buildPlanDraftRequest('challenger', input.request),
+                model: input.model,
+                abortSignal: input.abortSignal,
+            }),
+        ]);
+        const drafts = [
+            { ...leadDraft, request: input.request },
+            { ...challengerDraft, request: input.request },
+        ];
+        const synthesisResult = await this.sessions.runTask({
+            cwd: input.cwd,
+            prompt: buildSynthesisPrompt(input.request, drafts),
+            systemPrompt: buildSynthesisSystemPrompt(),
+            persistSession: false,
+            includePartialMessages: false,
+            permissionMode: 'plan',
+            model: input.model,
+            effort: 'high',
+            settingSources: ['user'],
+            abortSignal: input.abortSignal,
+        });
+        const parsedSynthesis = parseSynthesisResult(synthesisResult.finalText);
+        return {
+            teamId: input.teamId,
+            request: input.request,
+            leadEngineer: input.leadEngineer,
+            challengerEngineer: input.challengerEngineer,
+            drafts,
+            synthesis: parsedSynthesis.synthesis,
+            recommendedQuestion: parsedSynthesis.recommendedQuestion,
+            recommendedAnswer: parsedSynthesis.recommendedAnswer,
+        };
+    }
+    async updateEngineer(cwd, teamId, engineerName, update) {
+        await this.getOrCreateTeam(cwd, teamId);
+        await this.teamStore.updateTeam(cwd, teamId, (team) => {
+            const normalized = this.normalizeTeamRecord(team);
+            const existing = this.getEngineerState(normalized, engineerName);
+            return {
+                ...normalized,
+                updatedAt: new Date().toISOString(),
+                engineers: normalized.engineers.map((engineer) => engineer.name === engineerName ? update(existing) : engineer),
+            };
+        });
+    }
+    async reserveEngineer(cwd, teamId, engineerName) {
+        await this.getOrCreateTeam(cwd, teamId);
+        await this.teamStore.updateTeam(cwd, teamId, (team) => {
+            const normalized = this.normalizeTeamRecord(team);
+            const engineer = this.getEngineerState(normalized, engineerName);
+            if (engineer.busy) {
+                throw new Error(`${engineerName} is already working on another assignment.`);
+            }
+            return {
+                ...normalized,
+                updatedAt: new Date().toISOString(),
+                engineers: normalized.engineers.map((entry) => entry.name === engineerName
+                    ? {
+                        ...entry,
+                        busy: true,
+                    }
+                    : entry),
+            };
+        });
+    }
+    getEngineerState(team, engineerName) {
+        return (team.engineers.find((engineer) => engineer.name === engineerName) ??
+            createEmptyEngineerRecord(engineerName));
+    }
+    normalizeTeamRecord(team) {
+        const engineerMap = new Map(team.engineers.map((engineer) => [engineer.name, engineer]));
+        return {
+            ...team,
+            engineers: createEmptyTeamRecord(team.id, team.cwd).engineers.map((engineer) => engineerMap.get(engineer.name) ?? engineer),
+        };
+    }
+    buildSessionSystemPrompt(engineer, mode) {
+        const claudeFileSection = this.projectClaudeFiles.length
+            ? `\n\nProject Claude Files:\n${this.projectClaudeFiles
+                .map((file) => `## ${file.relativePath}\n${file.content}`)
+                .join('\n\n')}`
+            : '';
+        return [
+            this.engineerSessionPrompt,
+            '',
+            `Assigned engineer: ${engineer}.`,
+            `Current work mode: ${mode}.`,
+            claudeFileSection,
+        ]
+            .join('\n')
+            .trim();
+    }
+    buildEngineerPrompt(mode, message) {
+        return `${buildModeInstruction(mode)}\n\n${message}`;
+    }
+    mapWorkModeToSessionMode(mode) {
+        return mode === 'explore' ? 'plan' : 'free';
+    }
+}
+function buildModeInstruction(mode) {
+    switch (mode) {
+        case 'explore':
+            return 'Work in planning mode. Investigate, reason, and write the plan inline. Do not make file edits.';
+        case 'implement':
+            return 'Work in implementation mode. Make the changes, verify them, and report clearly.';
+        case 'verify':
+            return 'Work in verification mode. Run the narrowest useful checks first, then broaden only if needed.';
+    }
+}
+function summarizeMessage(message) {
+    const compact = message.replace(/\s+/g, ' ').trim();
+    return compact.length > 120 ? `${compact.slice(0, 117)}...` : compact;
+}
+function summarizeText(text, limit) {
+    const compact = text.replace(/\s+/g, ' ').trim();
+    return compact.length > limit ? `${compact.slice(0, limit - 3)}...` : compact;
+}
+function appendWrapperHistoryEntries(existing, nextEntries) {
+    return [...existing, ...nextEntries].slice(-12);
+}
+function buildPlanDraftRequest(perspective, request) {
+    const posture = perspective === 'lead'
+        ? 'Propose the most direct workable plan.'
+        : 'Challenge weak assumptions, find missing decisions, and propose a stronger alternative if needed.';
+    return [
+        posture,
+        '',
+        'Return exactly these sections:',
+        '1. Objective',
+        '2. Proposed approach',
+        '3. Files or systems likely involved',
+        '4. Risks and open questions',
+        '5. Verification',
+        '6. Step-by-step plan',
+        '',
+        `User request: ${request}`,
+    ].join('\n');
+}
+function buildSynthesisSystemPrompt() {
+    return [
+        'You are the CTO synthesis engine.',
+        'Combine two independent engineering plans into one better plan.',
+        'Prefer the clearest, simplest, highest-leverage path.',
+        'If one user decision is still required, surface exactly one recommended question and one recommended answer.',
+        'Use this output format exactly:',
+        '## Synthesis',
+        '<combined plan>',
+        '## Recommended Question',
+        '<question or NONE>',
+        '## Recommended Answer',
+        '<answer or NONE>',
+    ].join('\n');
+}
+function buildSynthesisPrompt(request, drafts) {
+    return [
+        `User request: ${request}`,
+        '',
+        `Lead engineer (${drafts[0].engineer}) draft:`,
+        drafts[0].finalText,
+        '',
+        `Challenger engineer (${drafts[1].engineer}) draft:`,
+        drafts[1].finalText,
+    ].join('\n');
+}
+function parseSynthesisResult(text) {
+    const synthesis = extractSection(text, 'Synthesis') ?? text.trim();
+    const recommendedQuestion = normalizeOptionalSection(extractSection(text, 'Recommended Question'));
+    const recommendedAnswer = normalizeOptionalSection(extractSection(text, 'Recommended Answer'));
+    return {
+        synthesis,
+        recommendedQuestion,
+        recommendedAnswer,
+    };
+}
+function extractSection(text, heading) {
+    const regex = new RegExp(`## ${escapeRegExp(heading)}\\n([\\s\\S]*?)(?=\\n## |$)`);
+    const match = text.match(regex);
+    return match?.[1]?.trim() ?? null;
+}
+function normalizeOptionalSection(value) {
+    if (!value) {
+        return null;
+    }
+    return value.toUpperCase() === 'NONE' ? null : value;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}