@clawhive/openclaw-plugin 0.2.0

package/dist/src/agent-panel/executor.js

@@ -0,0 +1,368 @@
+import { resolveDefaultModelForAgent } from "openclaw/plugin-sdk/agent-runtime";
+import { CLAWHIVE_CHANNEL_ID } from "../config.js";
+import { buildClawHiveSessionKey, indexSession, resolveLocalAgentId, } from "../runtime.js";
+import { buildAssignedWorkPrompt, buildPlanningPrompt, buildRoundOnePrompt, buildRoundTwoPrompt, buildSynthesisPrompt, } from "./prompts.js";
+import { buildFallbackAssignments, parsePanelPlan } from "./plan.js";
+function extractVisibleReplyText(result) {
+    const finalText = result.meta?.finalAssistantVisibleText?.trim();
+    if (finalText)
+        return finalText;
+    const payloadText = (result.payloads ?? [])
+        .filter((payload) => !payload?.isReasoning && !payload?.isError)
+        .map((payload) => payload?.text?.trim() ?? "")
+        .filter((text) => text.length > 0)
+        .join("\n\n")
+        .trim();
+    return payloadText || null;
+}
+function findContribution(contributions, agentId, round) {
+    return contributions.find((item) => item.agentId === agentId && item.round === round) ?? null;
+}
+function findAssignment(assignments, agentId) {
+    return assignments.find((assignment) => assignment.agentId === agentId) ?? null;
+}
+function resolveReadyPanelists(input) {
+    const ready = input.panelists.filter((agent) => {
+        if (input.scheduledAgentIds.has(agent.agentId))
+            return false;
+        const assignment = findAssignment(input.assignments, agent.agentId);
+        const dependsOnAgentIds = assignment?.dependsOnAgentIds ?? [];
+        return dependsOnAgentIds.every((agentId) => input.completedAgentIds.has(agentId));
+    });
+    if (ready.length > 0)
+        return ready;
+    // Break invalid dependency cycles by running the remaining panelists together.
+    return input.panelists.filter((agent) => !input.scheduledAgentIds.has(agent.agentId));
+}
+function replaceContribution(contributions, contribution, patch) {
+    const updated = { ...contribution, ...patch };
+    const found = contributions.some((item) => item.id === contribution.id);
+    if (!found)
+        return [...contributions, updated];
+    return contributions.map((item) => item.id === contribution.id ? updated : item);
+}
+async function withTimeout(promise, timeoutMs) {
+    let timer = null;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`Timed out after ${timeoutMs}ms`)), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+function resolveAgentModelSelection(runtime, localAgentId) {
+    const cfg = runtime.pluginApi.runtime.config.loadConfig();
+    return resolveDefaultModelForAgent({
+        cfg,
+        agentId: localAgentId,
+    });
+}
+async function runLocalAgent(input) {
+    const cfg = input.runtime.pluginApi.runtime.config.loadConfig();
+    const modelSelection = resolveAgentModelSelection(input.runtime, input.localAgentId);
+    const workspaceDir = input.runtime.pluginApi.runtime.agent.resolveAgentWorkspaceDir(cfg, input.localAgentId);
+    const sessionFile = input.runtime.pluginApi.runtime.agent.session.resolveSessionFilePath(input.turn.sessionId, undefined, { agentId: input.localAgentId });
+    const sessionKey = buildClawHiveSessionKey(input.turn.sessionId);
+    const result = await withTimeout(input.runtime.pluginApi.runtime.agent.runEmbeddedPiAgent({
+        runId: input.runId,
+        trigger: "user",
+        sessionId: input.turn.sessionId,
+        sessionKey,
+        agentId: input.localAgentId,
+        messageChannel: CLAWHIVE_CHANNEL_ID,
+        messageTo: sessionKey,
+        senderId: input.turn.userId,
+        currentMessageId: input.turn.userMessageId,
+        sessionFile,
+        workspaceDir,
+        config: cfg,
+        provider: modelSelection.provider,
+        model: modelSelection.model,
+        prompt: input.prompt,
+        timeoutMs: input.timeoutMs,
+    }), input.timeoutMs);
+    return extractVisibleReplyText(result) ?? "";
+}
+async function runPanelistRound(input) {
+    const localAgentId = resolveLocalAgentId(input.runtime, input.agent.agentId) ?? input.agent.openclawAgentId;
+    await input.runtime.api.updatePanelContribution({
+        contributionId: input.contribution.id,
+        status: "running",
+        assignment: input.assignment,
+    });
+    try {
+        const content = await runLocalAgent({
+            runtime: input.runtime,
+            localAgentId,
+            turn: input.turn,
+            runId: `clawhive-panel-${input.turn.id}-r${input.contribution.round}-${input.agent.agentId}`,
+            prompt: input.prompt,
+            timeoutMs: input.timeoutMs,
+        });
+        await input.runtime.api.updatePanelContribution({
+            contributionId: input.contribution.id,
+            status: "completed",
+            content,
+            assignment: input.assignment,
+        });
+        return {
+            ...input.contribution,
+            status: "completed",
+            assignment: input.assignment ?? input.contribution.assignment,
+            content,
+            errorMessage: null,
+        };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        const status = reason.includes("Timed out") ? "timed_out" : "failed";
+        await input.runtime.api.updatePanelContribution({
+            contributionId: input.contribution.id,
+            status,
+            errorMessage: reason,
+            assignment: input.assignment,
+        });
+        return {
+            ...input.contribution,
+            status,
+            assignment: input.assignment ?? input.contribution.assignment,
+            errorMessage: reason,
+        };
+    }
+}
+export async function executePanelTurn(options) {
+    const { runtime, turn } = options;
+    const sessionKey = buildClawHiveSessionKey(turn.sessionId);
+    const moderator = turn.members.find((member) => member.agentId === turn.moderatorAgentId);
+    if (!moderator) {
+        throw new Error(`Panel turn ${turn.id} has no moderator member`);
+    }
+    const moderatorLocalAgentId = resolveLocalAgentId(runtime, moderator.agentId) ?? moderator.openclawAgentId;
+    const binding = {
+        sessionId: turn.sessionId,
+        cloudAgentId: moderator.agentId,
+        localAgentId: moderatorLocalAgentId,
+        userId: turn.userId,
+        sessionKey,
+        lastSeenSequence: 0,
+    };
+    indexSession(runtime, binding);
+    let contributions = [...turn.contributions];
+    const panelists = turn.members.filter((member) => member.role === "panelist");
+    const panelistTimeoutMs = options.panelistTimeoutMs ?? 10 * 60_000;
+    await runtime.api.updatePanelTurn({ turnId: turn.id, status: "planning" });
+    let plan = null;
+    let planFallback = false;
+    let planStatus = "completed";
+    let assignments = [];
+    try {
+        const planningText = await runLocalAgent({
+            runtime,
+            localAgentId: moderatorLocalAgentId,
+            turn,
+            runId: `clawhive-panel-${turn.id}-planning`,
+            prompt: buildPlanningPrompt({
+                userQuestion: turn.userMessageContent,
+                moderator,
+                members: turn.members,
+                recentContext: "",
+            }),
+            timeoutMs: options.moderatorTimeoutMs ?? 10 * 60_000,
+        });
+        const parsed = parsePanelPlan({
+            rawText: planningText,
+            members: turn.members,
+            userQuestion: turn.userMessageContent,
+        });
+        if (parsed.ok) {
+            plan = parsed.plan;
+            assignments = parsed.plan.assignments;
+            await runtime.api.updatePanelTurn({
+                turnId: turn.id,
+                status: "planning",
+                plan,
+                planStatus: "completed",
+                planErrorMessage: parsed.warnings.length ? parsed.warnings.join("; ") : null,
+            });
+        }
+        else {
+            planFallback = true;
+            planStatus = "fallback";
+            assignments = parsed.fallbackAssignments;
+            await runtime.api.updatePanelTurn({
+                turnId: turn.id,
+                status: "planning",
+                plan: null,
+                planStatus: "fallback",
+                planErrorMessage: parsed.errorMessage,
+            });
+        }
+    }
+    catch (error) {
+        planFallback = true;
+        planStatus = "failed";
+        assignments = buildFallbackAssignments({
+            members: turn.members,
+            userQuestion: turn.userMessageContent,
+        });
+        await runtime.api.updatePanelTurn({
+            turnId: turn.id,
+            status: "planning",
+            plan: null,
+            planStatus: "failed",
+            planErrorMessage: error instanceof Error ? error.message : String(error),
+        });
+    }
+    const assignedPanelists = planFallback
+        ? panelists
+        : panelists.filter((agent) => Boolean(findAssignment(assignments, agent.agentId)));
+    async function runRoundOnePanelist(agent) {
+        const contribution = findContribution(contributions, agent.agentId, 1);
+        if (!contribution)
+            return null;
+        const assignment = findAssignment(assignments, agent.agentId);
+        const updated = await runPanelistRound({
+            runtime,
+            turn,
+            agent,
+            contribution,
+            assignment,
+            prompt: assignment && !planFallback
+                ? buildAssignedWorkPrompt({
+                    userQuestion: turn.userMessageContent,
+                    agent,
+                    assignment,
+                    recentContext: "",
+                })
+                : buildRoundOnePrompt({
+                    userQuestion: turn.userMessageContent,
+                    agent,
+                    recentContext: "",
+                }),
+            timeoutMs: panelistTimeoutMs,
+        });
+        contributions = replaceContribution(contributions, contribution, updated);
+        return updated;
+    }
+    const roundOneResults = [];
+    if (assignedPanelists.length > 0) {
+        await runtime.api.updatePanelTurn({ turnId: turn.id, status: "round_1_running" });
+        const scheduledRoundOneAgentIds = new Set();
+        const completedRoundOneAgentIds = new Set();
+        while (scheduledRoundOneAgentIds.size < assignedPanelists.length) {
+            const readyPanelists = resolveReadyPanelists({
+                panelists: assignedPanelists,
+                assignments,
+                scheduledAgentIds: scheduledRoundOneAgentIds,
+                completedAgentIds: completedRoundOneAgentIds,
+            });
+            for (const agent of readyPanelists)
+                scheduledRoundOneAgentIds.add(agent.agentId);
+            const batchResults = await Promise.all(readyPanelists.map(runRoundOnePanelist));
+            for (const result of batchResults) {
+                roundOneResults.push(result);
+                if (result?.status === "completed")
+                    completedRoundOneAgentIds.add(result.agentId);
+            }
+        }
+    }
+    const completedRoundOne = roundOneResults
+        .filter((item) => Boolean(item))
+        .filter((item) => item.status === "completed");
+    const revisionRound = Boolean(plan?.requiresRevisionRound ?? planFallback);
+    if (revisionRound) {
+        await runtime.api.updatePanelTurn({ turnId: turn.id, status: "round_2_running" });
+        await Promise.all(assignedPanelists.map(async (agent) => {
+            let roundTwo = findContribution(contributions, agent.agentId, 2);
+            const ownRoundOne = completedRoundOne.find((item) => item.agentId === agent.agentId);
+            if (!ownRoundOne?.content)
+                return null;
+            const assignment = findAssignment(assignments, agent.agentId);
+            if (!roundTwo) {
+                const created = await runtime.api.createPanelContribution({
+                    turnId: turn.id,
+                    agentId: agent.agentId,
+                    round: 2,
+                    assignment,
+                });
+                roundTwo = created.contribution;
+                contributions = replaceContribution(contributions, roundTwo, roundTwo);
+            }
+            const updated = await runPanelistRound({
+                runtime,
+                turn,
+                agent,
+                contribution: roundTwo,
+                assignment: assignment ?? roundTwo.assignment,
+                prompt: buildRoundTwoPrompt({
+                    userQuestion: turn.userMessageContent,
+                    agent,
+                    ownRoundOne: ownRoundOne.content,
+                    otherRoundOne: completedRoundOne.filter((item) => item.agentId !== agent.agentId),
+                }),
+                timeoutMs: panelistTimeoutMs,
+            });
+            contributions = replaceContribution(contributions, roundTwo, updated);
+            return updated;
+        }));
+    }
+    await runtime.api.updatePanelTurn({ turnId: turn.id, status: "moderating" });
+    try {
+        const failedAgentIds = contributions
+            .filter((item) => item.status === "failed" || item.status === "timed_out")
+            .map((item) => item.agentId);
+        const finalText = await runLocalAgent({
+            runtime,
+            localAgentId: moderatorLocalAgentId,
+            turn,
+            runId: `clawhive-panel-${turn.id}-moderator`,
+            prompt: buildSynthesisPrompt({
+                userQuestion: turn.userMessageContent,
+                recentContext: "",
+                plan,
+                contributions,
+                failedAgentIds,
+                planFallback,
+            }),
+            timeoutMs: options.moderatorTimeoutMs ?? 10 * 60_000,
+        });
+        await runtime.api.writeAgentMessage({
+            pluginNodeId: runtime.pluginNodeId,
+            sessionId: turn.sessionId,
+            agentId: turn.moderatorAgentId,
+            content: finalText,
+            metadata: {
+                panel_turn_id: turn.id,
+                panel_summary: true,
+                plan_status: planStatus,
+                revision_round: revisionRound,
+                participant_count: turn.members.length,
+                completed_contribution_count: contributions.filter((item) => item.status === "completed").length,
+                timed_out_agent_ids: contributions
+                    .filter((item) => item.status === "timed_out")
+                    .map((item) => item.agentId),
+            },
+        });
+        await runtime.api.updatePanelTurn({
+            turnId: turn.id,
+            status: "completed",
+            completedAt: new Date().toISOString(),
+        });
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        await runtime.api.updatePanelTurn({
+            turnId: turn.id,
+            status: "failed",
+            errorMessage: reason,
+            completedAt: new Date().toISOString(),
+        });
+        throw error;
+    }
+}

package/dist/src/agent-panel/plan.d.ts

@@ -0,0 +1,20 @@
+import type { PanelAgentMember, PanelPlan, PanelPlanAssignment } from "./types.js";
+export type ParsePanelPlanInput = {
+    rawText: string;
+    members: PanelAgentMember[];
+    userQuestion: string;
+};
+export type ParsePanelPlanResult = {
+    ok: true;
+    plan: PanelPlan;
+    warnings: string[];
+} | {
+    ok: false;
+    errorMessage: string;
+    fallbackAssignments: PanelPlanAssignment[];
+};
+export declare function buildFallbackAssignments(input: {
+    members: PanelAgentMember[];
+    userQuestion: string;
+}): PanelPlanAssignment[];
+export declare function parsePanelPlan(input: ParsePanelPlanInput): ParsePanelPlanResult;

package/dist/src/agent-panel/plan.js

@@ -0,0 +1,111 @@
+function stripMarkdownFence(rawText) {
+    const trimmed = rawText.trim();
+    const match = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+    return (match?.[1] ?? trimmed).trim();
+}
+function normalizeText(value, fallback) {
+    return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+function normalizePriority(value) {
+    return value === "supporting" ? "supporting" : "primary";
+}
+function normalizeDependsOnAgentIds(input) {
+    if (!Array.isArray(input.value))
+        return [];
+    const seen = new Set();
+    const dependsOn = [];
+    for (const item of input.value) {
+        if (typeof item !== "string" || !item.trim())
+            continue;
+        const dependencyId = item.trim();
+        if (dependencyId === input.agentId) {
+            input.warnings.push(`Ignored self dependency for agent ${input.agentId}`);
+            continue;
+        }
+        if (!input.validPanelistIds.has(dependencyId)) {
+            input.warnings.push(`Ignored dependency on unknown agent ${dependencyId} for agent ${input.agentId}`);
+            continue;
+        }
+        if (seen.has(dependencyId))
+            continue;
+        seen.add(dependencyId);
+        dependsOn.push(dependencyId);
+    }
+    return dependsOn;
+}
+function panelists(members) {
+    return members.filter((member) => member.role === "panelist");
+}
+export function buildFallbackAssignments(input) {
+    return panelists(input.members).map((member) => ({
+        agentId: member.agentId,
+        task: `Provide expert input for this user request: ${input.userQuestion}`,
+        reason: `${member.name} was selected as a panelist for this session.`,
+        priority: "primary",
+        expectedOutput: "Viewpoint, reasoning, risks or uncertainty, and recommendation.",
+        dependsOnAgentIds: [],
+    }));
+}
+export function parsePanelPlan(input) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stripMarkdownFence(input.rawText));
+    }
+    catch (error) {
+        return {
+            ok: false,
+            errorMessage: `Invalid panel plan JSON: ${error instanceof Error ? error.message : String(error)}`,
+            fallbackAssignments: buildFallbackAssignments(input),
+        };
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return {
+            ok: false,
+            errorMessage: "Invalid panel plan JSON: root must be an object",
+            fallbackAssignments: buildFallbackAssignments(input),
+        };
+    }
+    const raw = parsed;
+    const validPanelistIds = new Set(panelists(input.members).map((member) => member.agentId));
+    const seen = new Set();
+    const warnings = [];
+    const assignments = [];
+    for (const item of Array.isArray(raw.assignments) ? raw.assignments : []) {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            continue;
+        const entry = item;
+        const agentId = normalizeText(entry.agentId, "");
+        if (!validPanelistIds.has(agentId)) {
+            warnings.push(`Ignored assignment for unknown agent ${agentId || "(missing)"}`);
+            continue;
+        }
+        if (seen.has(agentId)) {
+            warnings.push(`Ignored duplicate assignment for agent ${agentId}`);
+            continue;
+        }
+        seen.add(agentId);
+        assignments.push({
+            agentId,
+            task: normalizeText(entry.task, `Provide expert input for: ${input.userQuestion}`),
+            reason: normalizeText(entry.reason, "Selected panelist expertise."),
+            priority: normalizePriority(entry.priority),
+            expectedOutput: normalizeText(entry.expectedOutput, "Concise expert findings for the moderator."),
+            dependsOnAgentIds: normalizeDependsOnAgentIds({
+                value: entry.dependsOnAgentIds ?? entry.depends_on_agent_ids,
+                agentId,
+                validPanelistIds,
+                warnings,
+            }),
+        });
+    }
+    return {
+        ok: true,
+        warnings,
+        plan: {
+            summary: normalizeText(raw.summary, input.userQuestion),
+            requiresRevisionRound: raw.requiresRevisionRound === true,
+            synthesisGuidance: normalizeText(raw.synthesisGuidance, "Synthesize the panel outputs into one useful answer."),
+            assignments,
+        },
+    };
+}

package/dist/src/agent-panel/prompts.d.ts

@@ -0,0 +1,38 @@
+import type { PanelAgentMember, PanelContribution, PanelPlan, PanelPlanAssignment } from "./types.js";
+export declare function buildPlanningPrompt(input: {
+    userQuestion: string;
+    moderator: PanelAgentMember;
+    members: PanelAgentMember[];
+    recentContext: string;
+}): string;
+export declare function buildAssignedWorkPrompt(input: {
+    userQuestion: string;
+    agent: PanelAgentMember;
+    assignment: PanelPlanAssignment;
+    recentContext: string;
+}): string;
+export declare function buildSynthesisPrompt(input: {
+    userQuestion: string;
+    recentContext: string;
+    plan: PanelPlan | null;
+    contributions: PanelContribution[];
+    failedAgentIds: string[];
+    planFallback: boolean;
+}): string;
+export declare function buildRoundOnePrompt(input: {
+    userQuestion: string;
+    agent: PanelAgentMember;
+    recentContext: string;
+}): string;
+export declare function buildRoundTwoPrompt(input: {
+    userQuestion: string;
+    agent: PanelAgentMember;
+    ownRoundOne: string;
+    otherRoundOne: PanelContribution[];
+}): string;
+export declare function buildModeratorPrompt(input: {
+    userQuestion: string;
+    recentContext: string;
+    contributions: PanelContribution[];
+    failedAgentIds: string[];
+}): string;

package/dist/src/agent-panel/prompts.js

@@ -0,0 +1,87 @@
+export function buildPlanningPrompt(input) {
+    const panelists = input.members
+        .filter((member) => member.role === "panelist")
+        .map((member) => `- agentId=${member.agentId}; openclawAgentId=${member.openclawAgentId}; name=${member.name}; position=${member.position}`)
+        .join("\n");
+    return [
+        `You are ${input.moderator.name}, the moderator for an expert panel.`,
+        "Analyze the user's request complexity before assigning work.",
+        "If the task is simple and one panelist is clearly best suited, assign only that panelist.",
+        "If no panelist is a good fit or the task is simple enough for you, return assignments: [] and answer during synthesis.",
+        "For complex tasks, assign only the panelists that are genuinely needed.",
+        "Decide which assignments can run in parallel and which must wait for another panelist's result.",
+        "For each assignment, set dependsOnAgentIds to the panelist agent IDs that must complete before this agent starts. Use [] when it can run immediately.",
+        "Return strict JSON only. Do not wrap it in markdown.",
+        "Schema: {\"summary\":\"string\",\"requiresRevisionRound\":boolean,\"synthesisGuidance\":\"string\",\"assignments\":[{\"agentId\":\"string\",\"task\":\"string\",\"reason\":\"string\",\"priority\":\"primary|supporting\",\"expectedOutput\":\"string\",\"dependsOnAgentIds\":[\"agentId\"]}]}",
+        input.recentContext ? `Recent context:\n${input.recentContext}` : "",
+        `Panelists:\n${panelists}`,
+        `User question:\n${input.userQuestion}`,
+    ].filter(Boolean).join("\n\n");
+}
+export function buildAssignedWorkPrompt(input) {
+    return [
+        `You are ${input.agent.name}, participating in an expert panel.`,
+        "Complete your assigned task for the moderator. Do not answer the user directly.",
+        `Task:\n${input.assignment.task}`,
+        `Why you were assigned:\n${input.assignment.reason}`,
+        `Priority: ${input.assignment.priority}`,
+        `Expected output:\n${input.assignment.expectedOutput}`,
+        input.recentContext ? `Recent context:\n${input.recentContext}` : "",
+        `User question:\n${input.userQuestion}`,
+    ].filter(Boolean).join("\n\n");
+}
+export function buildSynthesisPrompt(input) {
+    const completed = input.contributions
+        .filter((item) => item.status === "completed" && item.content?.trim())
+        .map((item) => {
+        const task = item.assignment?.task ? `Assignment: ${item.assignment.task}\n` : "";
+        return `Round ${item.round} agent ${item.agentId}:\n${task}${item.content}`;
+    })
+        .join("\n\n");
+    return [
+        "You are the moderator. Write one clear final answer to the user.",
+        "Synthesize the work; do not dump every contribution.",
+        input.planFallback ? "Planning used fallback generic assignments because structured planning failed." : "",
+        input.plan ? `Plan summary:\n${input.plan.summary}\n\nSynthesis guidance:\n${input.plan.synthesisGuidance}` : "",
+        input.failedAgentIds.length ? `Some panelists did not complete: ${input.failedAgentIds.join(", ")}` : "",
+        input.recentContext ? `Recent context:\n${input.recentContext}` : "",
+        `User question:\n${input.userQuestion}`,
+        completed ? `Panel work:\n${completed}` : "No panelist completed. Answer directly from your own expertise.",
+    ].filter(Boolean).join("\n\n");
+}
+export function buildRoundOnePrompt(input) {
+    return [
+        `You are ${input.agent.name}, participating in an expert panel.`,
+        "Give expert input for the moderator. Do not answer the user directly.",
+        "Use this structure: Viewpoint, Reasoning, Risks or uncertainty, Recommendation.",
+        input.recentContext ? `Recent context:\n${input.recentContext}` : "",
+        `User question:\n${input.userQuestion}`,
+    ].filter(Boolean).join("\n\n");
+}
+export function buildRoundTwoPrompt(input) {
+    const others = input.otherRoundOne
+        .filter((item) => item.content?.trim())
+        .map((item) => `Agent ${item.agentId}:\n${item.content}`)
+        .join("\n\n");
+    return [
+        `You are ${input.agent.name}, revising your expert input after seeing other panelists.`,
+        "Do not repeat your first answer. Add corrections, disagreements, risks, or final recommendation.",
+        `User question:\n${input.userQuestion}`,
+        `Your Round 1:\n${input.ownRoundOne}`,
+        others ? `Other Round 1 contributions:\n${others}` : "No other Round 1 contributions completed.",
+    ].join("\n\n");
+}
+export function buildModeratorPrompt(input) {
+    const completed = input.contributions
+        .filter((item) => item.status === "completed" && item.content?.trim())
+        .map((item) => `Round ${item.round} agent ${item.agentId}:\n${item.content}`)
+        .join("\n\n");
+    return [
+        "You are the moderator. Write one clear final answer to the user.",
+        "Do not dump every contribution. Mention disagreement only when useful.",
+        input.failedAgentIds.length ? `Some panelists did not complete: ${input.failedAgentIds.join(", ")}` : "",
+        input.recentContext ? `Recent context:\n${input.recentContext}` : "",
+        `User question:\n${input.userQuestion}`,
+        completed ? `Panel discussion:\n${completed}` : "No panelist completed. Answer directly from your own expertise.",
+    ].filter(Boolean).join("\n\n");
+}

package/dist/src/agent-panel/types.d.ts

@@ -0,0 +1,45 @@
+export type PanelTurnStatus = "queued" | "planning" | "round_1_running" | "round_2_running" | "moderating" | "completed" | "failed";
+export type PanelContributionStatus = "queued" | "running" | "completed" | "timed_out" | "failed";
+export type PanelAgentMember = {
+    agentId: string;
+    role: "moderator" | "panelist";
+    position: number;
+    openclawAgentId: string;
+    name: string;
+};
+export type PanelPlanAssignment = {
+    agentId: string;
+    task: string;
+    reason: string;
+    priority: "primary" | "supporting";
+    expectedOutput: string;
+    dependsOnAgentIds: string[];
+};
+export type PanelPlan = {
+    summary: string;
+    requiresRevisionRound: boolean;
+    synthesisGuidance: string;
+    assignments: PanelPlanAssignment[];
+};
+export type PanelContribution = {
+    id: string;
+    agentId: string;
+    round: 1 | 2;
+    status: PanelContributionStatus;
+    assignment: PanelPlanAssignment | null;
+    content: string | null;
+    errorMessage: string | null;
+};
+export type ClaimedPanelTurn = {
+    id: string;
+    sessionId: string;
+    userMessageId: string;
+    moderatorAgentId: string;
+    userId: string;
+    userMessageContent: string;
+    members: PanelAgentMember[];
+    contributions: PanelContribution[];
+    plan: PanelPlan | null;
+    planStatus: "pending" | "completed" | "fallback" | "failed";
+    planErrorMessage: string | null;
+};

package/dist/src/agent-panel/types.js

@@ -0,0 +1 @@
+export {};