opencode-design-lab 0.0.0 → 0.0.2

package/.opencode/plugins/design-lab.js

@@ -1,15 +1,236 @@
-import { z } from "zod";
-import * as fs from "fs";
+import pino from "pino";
 import * as path from "path";
+import * as fs from "fs";
+import { z } from "zod";
 import * as os from "os";
-import { tool } from "@opencode-ai/plugin";
-import pino from "pino";
 
+//#region src/utils/logger.ts
+const logLevel = process.env.LOG_LEVEL || "info";
+const levelNames = {
+	10: "TRACE",
+	20: "DEBUG",
+	30: "INFO",
+	40: "WARN",
+	50: "ERROR",
+	60: "FATAL"
+};
+function formatTimestamp() {
+	const now = /* @__PURE__ */ new Date();
+	return `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}:${String(now.getSeconds()).padStart(2, "0")}.${String(now.getMilliseconds()).padStart(3, "0")}`;
+}
+function createLogStream() {
+	const logPath = path.join(process.cwd(), "design-lab.log");
+	const stream = fs.createWriteStream(logPath, { flags: "a" });
+	return pino.multistream([{
+		level: "trace",
+		stream: { write: (chunk) => {
+			try {
+				const log = JSON.parse(chunk);
+				const timestamp = formatTimestamp();
+				const level = levelNames[log.level] || "UNKNOWN";
+				const message = log.msg || "";
+				stream.write(`[${timestamp}] ${level}: ${message}\n`);
+			} catch (e) {
+				stream.write(chunk + "\n");
+			}
+		} }
+	}]);
+}
+const logger = pino({
+	level: logLevel,
+	timestamp: false
+}, createLogStream());
+
+//#endregion
+//#region src/utils/session-helpers.ts
+/**
+* Maximum time to wait for a session to complete
+*/
+const MAX_POLL_TIME_MS = 600 * 1e3;
+/**
+* Extract short model name from full model string
+* e.g., "zhipuai-coding-plan/glm-4.6" -> "glm-4.6"
+*/
+function getModelShortName(modelName) {
+	const parts = modelName.split("/");
+	return parts[parts.length - 1] || modelName;
+}
+
+//#endregion
+//#region src/agents/index.ts
+const DESIGNER_SUBAGENT_PREFIX = "designer_model_";
+/**
+* Build the agent name for a designer subagent model.
+*/
+function getDesignerSubagentName(model) {
+	return `${DESIGNER_SUBAGENT_PREFIX}${normalizeAgentSuffix(model)}`;
+}
+/**
+* Build the file stem used for design and review markdown files.
+*/
+function getDesignerModelFileStem(model) {
+	return normalizeModelSlug(model);
+}
+/**
+* Create the primary designer agent configuration.
+*/
+function createDesignerPrimaryAgent(options) {
+	return {
+		description: "Design Lab coordinator that orchestrates model subagents.",
+		mode: "primary",
+		model: options.designModels[0]?.model ?? options.reviewModels[0]?.model,
+		prompt: buildDesignerPrimaryPrompt(options),
+		tools: {
+			read: true,
+			bash: true,
+			delegate_task: true,
+			edit: false,
+			task: false,
+			write: false
+		},
+		permission: {
+			bash: "allow",
+			edit: "deny",
+			webfetch: "deny"
+		}
+	};
+}
+/**
+* Create a designer subagent configuration for a specific model.
+*/
+function createDesignerModelAgent(model) {
+	return {
+		description: "Design Lab subagent that writes designs or reviews to files.",
+		mode: "subagent",
+		model,
+		prompt: buildDesignerSubagentPrompt(model),
+		tools: {
+			read: true,
+			write: true,
+			edit: false,
+			bash: false,
+			task: false,
+			delegate_task: false
+		},
+		permission: {
+			bash: "deny",
+			edit: "allow",
+			webfetch: "deny"
+		}
+	};
+}
+function buildDesignerPrimaryPrompt(options) {
+	return `You are the Design Lab primary agent. Your job is to orchestrate model subagents to produce design and review markdown files.
+
+## Available subagents
+
+Design subagents:
+${options.designModels.map((spec) => `- ${spec.agentName} (model: ${spec.model}, file: ${spec.fileStem}.md)`).join("\n")}
+
+Review subagents:
+${options.reviewModels.map((spec) => `- ${spec.agentName} (model: ${spec.model}, file: review-${spec.fileStem}.md)`).join("\n")}
+
+## Workflow
+
+1. Create a new run directory under "${options.baseOutputDir}" using the format:
+   ${options.baseOutputDir}/YYYY-MM-DD-topic/
+   Use a short, lowercase, hyphenated topic derived from the request.
+   Use bash for date generation (e.g., "date +%F") and directory creation.
+2. Create subdirectories:
+   - designs/
+   - reviews/
+3. For each design subagent, delegate a design task sequentially:
+   - Provide the requirements and the exact output_file path:
+     ${options.baseOutputDir}/YYYY-MM-DD-topic/designs/{fileStem}.md
+   - The output_file path is mandatory. If you omit it, the subagent must fail.
+   - Instruct the subagent to write ONLY to the file and NOT to output the design in chat.
+4. After all designs are written, delegate review tasks sequentially:
+   - Provide the list of design file paths.
+   - Provide the exact output_file path:
+     ${options.baseOutputDir}/YYYY-MM-DD-topic/reviews/review-{fileStem}.md
+   - Each reviewer must produce ONE markdown report comparing ALL designs at once.
+5. After all reviews are written, read every review file and produce a short summary:
+   - Which design is recommended overall
+   - Approximate scores per design (from the score table)
+   - Notable disagreements between reviewers
+
+## Output rules
+
+- Never paste design or review content into the main chat.
+- Return only a concise summary with the run directory, file paths, and the review summary.
+- If asked "what agents will you call", list the design subagents by name.
+- If the user asks for parallel execution, explain that you run sequentially for stability.
+- Use only the subagents listed above; do not invent agent names.`;
+}
+function buildDesignerSubagentPrompt(model) {
+	return `You are a Design Lab subagent for model: ${model}.
+
+You only take tasks from the primary designer agent. You must write outputs to files and keep chat responses minimal.
+
+## Global rules
+
+- Use only read and write tools when needed.
+- NEVER output the design or review content in chat.
+- ALWAYS write to the exact output_file path provided.
+- If output_file is missing or unclear, reply with: "FAILED: missing output_file".
+- After writing, reply with: "WROTE: <output_file>".
+- If you cannot complete the task, reply with: "FAILED: <reason>".
+
+## Design tasks
+
+When asked to design:
+- Produce a concise but complete Markdown design document.
+- Use these sections (in this order): Title, Summary, Goals, Non-Goals, Architecture, Components, Data Flow, Tradeoffs, Risks, Open Questions.
+- Write the design to the provided output_file.
+
+## Review tasks
+
+When asked to review:
+- Read all provided design files.
+- Produce ONE Markdown report that compares all designs at once.
+- Use the fixed scoring standard below for ALL reviews.
+- Include sections in this exact order:
+  1. Executive Summary
+  2. Comparison Table
+  3. Strengths
+  4. Weaknesses
+  5. Recommendation
+  6. Open Questions
+  7. Scoring Standard
+- At the very bottom, include a Scores Table that rates EACH design.
+- Write the report to the provided output_file.
+
+## Fixed Scoring Standard
+
+- Scale: 0-10 for each criterion (10 is best).
+- Criteria and weights (total 100%):
+  - Clarity: 20%
+  - Feasibility: 25%
+  - Scalability: 20%
+  - Maintainability: 20%
+  - Completeness: 15%
+- Weighted Total (0-10) = sum(score * weight) / 100.
+
+## Scores Table Format (must be last in the report)
+
+| Design | Clarity (20%) | Feasibility (25%) | Scalability (20%) | Maintainability (20%) | Completeness (15%) | Weighted Total (0-10) |
+|--------|---------------|-------------------|-------------------|-----------------------|--------------------|-----------------------|
+| model-a | 8 | 9 | 7 | 8 | 8 | 8.1 |`;
+}
+function normalizeModelSlug(model) {
+	return getModelShortName(model).toLowerCase().replace(/\//g, "-").replace(/[._\s]+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+}
+function normalizeAgentSuffix(model) {
+	return normalizeModelSlug(model).replace(/-/g, "");
+}
+
+//#endregion
 //#region src/config/schema.ts
 /**
 * Configuration schema for OpenCode Design Lab plugin
 */
 const DesignLabConfigSchema = z.object({
+	"$schema": z.string().optional(),
 	design_models: z.array(z.string()).min(2, "At least 2 design models required"),
 	review_models: z.array(z.string()).optional(),
 	base_output_dir: z.string().default(".design-lab"),
@@ -98,7 +319,7 @@ function deepMerge(base, override) {
 * Parse JSONC (JSON with comments)
 */
 function parseJsonc(content) {
-	const withoutComments = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*/g, "");
+	const withoutComments = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*/gm, "");
 	return JSON.parse(withoutComments);
 }
 /**
@@ -157,843 +378,6 @@ function loadPluginConfig(directory) {
 	return result.data;
 }
 
-//#endregion
-//#region src/agents/index.ts
-/**
-* System prompt for design generation agents
-*/
-const DESIGN_AGENT_SYSTEM_PROMPT = `You are a senior software architect generating a design proposal for a technical system.
-
-## Your Task
-
-You will receive design requirements and must produce a comprehensive design document as structured JSON.
-
-## Critical Rules
-
-1. **Output ONLY valid JSON** - No markdown, no explanations, no code blocks, just pure JSON
-2. **Follow the schema exactly** - All required fields must be present
-3. **Be specific and actionable** - Avoid vague statements
-4. **Consider real-world constraints** - Think about scalability, maintainability, and security
-5. **Identify risks proactively** - Every design has risks, acknowledge them
-6. **List open questions** - What would you need to clarify with stakeholders?
-
-## Required Output Schema
-
-Your response must be a JSON object with this exact structure:
-
-{
-  "title": "Short, descriptive title for the design",
-  "summary": "2-3 paragraph executive summary of the design",
-  "assumptions": ["List of assumptions you're making"],
-  "architecture_overview": "High-level description of the architecture approach",
-  "components": [
-    {
-      "name": "Component name",
-      "description": "What this component does",
-      "responsibilities": ["List of responsibilities"]
-    }
-  ],
-  "data_flow": "Description of how data flows through the system",
-  "tradeoffs": [
-    {
-      "aspect": "What aspect this tradeoff concerns",
-      "options": ["Option 1", "Option 2"],
-      "chosen": "Which option you chose",
-      "rationale": "Why you chose this option"
-    }
-  ],
-  "risks": [
-    {
-      "risk": "Description of the risk",
-      "impact": "low|medium|high",
-      "mitigation": "How to mitigate this risk"
-    }
-  ],
-  "open_questions": ["Questions that need stakeholder input"]
-}
-
-Remember: Your entire response must be valid JSON. No other text.`;
-/**
-* Create a design agent configuration for a specific model
-*/
-function createDesignAgent(model, temperature) {
-	return {
-		model,
-		temperature,
-		mode: "subagent",
-		prompt: DESIGN_AGENT_SYSTEM_PROMPT,
-		tools: {
-			write: false,
-			edit: false,
-			bash: false,
-			task: false,
-			delegate_task: false
-		}
-	};
-}
-/**
-* System prompt for review agents
-*/
-const REVIEW_AGENT_SYSTEM_PROMPT = `You are a senior technical reviewer evaluating software design proposals.
-
-## Your Task
-
-You will receive multiple design proposals for the same requirements. You must:
-1. Analyze each design thoroughly
-2. Compare them objectively
-3. Provide scores for each design
-4. Generate a markdown review with your analysis
-
-## Scoring Criteria (0-10 scale)
-
-- **Clarity**: How well-explained and understandable is the design?
-- **Feasibility**: Can this design be realistically implemented?
-- **Scalability**: Will this design handle growth well?
-- **Maintainability**: Will this design be easy to maintain and evolve?
-- **Completeness**: Does this design address all requirements?
-- **Overall**: Your overall assessment
-
-## Review Format
-
-First, provide a detailed markdown review comparing all designs:
-
-1. Executive summary of each design
-2. Comparative analysis across dimensions
-3. Strengths and weaknesses of each
-4. Your recommendation
-
-Then, provide a score table in markdown like:
-
-| Design | Clarity | Feasibility | Scalability | Maintainability | Completeness | Overall |
-|--------|---------|-------------|-------------|-----------------|--------------|---------|
-| model-name | 8 | 9 | 7 | 8 | 8 | 8 |
-
-## Important
-
-- Be objective and fair
-- Support your scores with reasoning
-- Consider the requirements when scoring
-- Do not be biased by model names`;
-/**
-* Create a review agent configuration for a specific model
-*/
-function createReviewAgent(model, temperature) {
-	return {
-		model,
-		temperature,
-		mode: "subagent",
-		prompt: REVIEW_AGENT_SYSTEM_PROMPT,
-		tools: {
-			write: false,
-			edit: false,
-			bash: false,
-			task: false,
-			delegate_task: false
-		}
-	};
-}
-
-//#endregion
-//#region src/utils/logger.ts
-const logLevel = process.env.LOG_LEVEL || "info";
-const levelNames = {
-	10: "TRACE",
-	20: "DEBUG",
-	30: "INFO",
-	40: "WARN",
-	50: "ERROR",
-	60: "FATAL"
-};
-function formatTimestamp() {
-	const now = /* @__PURE__ */ new Date();
-	return `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}:${String(now.getSeconds()).padStart(2, "0")}.${String(now.getMilliseconds()).padStart(3, "0")}`;
-}
-function createLogStream() {
-	const logPath = path.join(process.cwd(), "design-lab.log");
-	const stream = fs.createWriteStream(logPath, { flags: "a" });
-	return pino.multistream([{
-		level: "trace",
-		stream: { write: (chunk) => {
-			try {
-				const log = JSON.parse(chunk);
-				const timestamp = formatTimestamp();
-				const level = levelNames[log.level] || "UNKNOWN";
-				const message = log.msg || "";
-				stream.write(`[${timestamp}] ${level}: ${message}\n`);
-			} catch (e) {
-				stream.write(chunk + "\n");
-			}
-		} }
-	}]);
-}
-const logger = pino({
-	level: logLevel,
-	timestamp: false
-}, createLogStream());
-
-//#endregion
-//#region src/utils/session-helpers.ts
-/**
-* Poll interval for checking session completion
-*/
-const POLL_INTERVAL_MS = 500;
-/**
-* Maximum time to wait for a session to complete
-*/
-const MAX_POLL_TIME_MS = 600 * 1e3;
-/**
-* Create a new agent session
-*/
-async function createAgentSession(ctx, parentSessionID, title, directory) {
-	logger.info({
-		parentSessionID,
-		title
-	}, "Creating agent session");
-	const createResult = await ctx.client.session.create({
-		body: {
-			parentID: parentSessionID,
-			title
-		},
-		query: { directory }
-	});
-	if (createResult.error) {
-		logger.error({ error: createResult.error }, "Failed to create session");
-		throw new Error(`Failed to create session: ${createResult.error}`);
-	}
-	logger.info({ sessionID: createResult.data.id }, "Session created successfully");
-	return createResult.data.id;
-}
-/**
-* Send a prompt to a session with timeout
-*/
-async function sendPrompt(ctx, sessionID, prompt, tools) {
-	logger.info({
-		sessionID,
-		promptLength: prompt.length,
-		tools
-	}, "Sending prompt");
-	const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("Prompt send timeout after 180 seconds")), 18e4));
-	const sendPromise = ctx.client.session.prompt({
-		path: { id: sessionID },
-		body: {
-			tools: {
-				...tools,
-				task: false,
-				delegate_task: false
-			},
-			parts: [{
-				type: "text",
-				text: prompt
-			}]
-		}
-	});
-	const result = await Promise.race([sendPromise, timeoutPromise]);
-	if (result.error) {
-		logger.error({
-			sessionID,
-			error: result.error
-		}, "Failed to send prompt");
-		throw new Error(`Failed to send prompt: ${result.error}`);
-	}
-	logger.info({ sessionID }, "Prompt sent successfully");
-}
-/**
-* Poll for session completion
-*/
-async function pollForCompletion(ctx, sessionID, abortSignal) {
-	const pollStart = Date.now();
-	let lastMsgCount = 0;
-	let stablePolls = 0;
-	const STABILITY_REQUIRED = 3;
-	let pollCount = 0;
-	logger.info({ sessionID }, "Starting polling for completion");
-	while (Date.now() - pollStart < MAX_POLL_TIME_MS) {
-		pollCount++;
-		if (abortSignal?.aborted) {
-			logger.warn({ sessionID }, "Polling aborted by signal");
-			throw new Error("Task aborted");
-		}
-		await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
-		const sessionStatus = ((await ctx.client.session.status()).data ?? {})[sessionID];
-		if (pollCount % 10 === 0) logger.info({
-			sessionID,
-			status: sessionStatus?.type,
-			pollCount,
-			elapsed: Date.now() - pollStart
-		}, "Polling status check");
-		if (sessionStatus && sessionStatus.type !== "idle") {
-			stablePolls = 0;
-			lastMsgCount = 0;
-			continue;
-		}
-		const messagesCheck = await ctx.client.session.messages({ path: { id: sessionID } });
-		const currentMsgCount = (messagesCheck.data ?? messagesCheck).length;
-		if (currentMsgCount > 0 && currentMsgCount === lastMsgCount) {
-			stablePolls++;
-			logger.debug({
-				sessionID,
-				stablePolls,
-				currentMsgCount
-			}, "Message count stable");
-			if (stablePolls >= STABILITY_REQUIRED) {
-				logger.info({
-					sessionID,
-					totalPolls: pollCount,
-					elapsed: Date.now() - pollStart
-				}, "Session completion confirmed");
-				return;
-			}
-		} else {
-			stablePolls = 0;
-			lastMsgCount = currentMsgCount;
-		}
-	}
-	logger.error({
-		sessionID,
-		totalPolls: pollCount,
-		elapsed: MAX_POLL_TIME_MS
-	}, "Session timed out");
-	throw new Error("Session timed out after 10 minutes");
-}
-/**
-* Extract text content from session messages
-*/
-async function extractSessionOutput(ctx, sessionID) {
-	const messagesResult = await ctx.client.session.messages({ path: { id: sessionID } });
-	if (messagesResult.error) throw new Error(`Failed to get messages: ${messagesResult.error}`);
-	const assistantMessages = messagesResult.data.filter((m) => m.info?.role === "assistant");
-	if (assistantMessages.length === 0) throw new Error("No assistant response found");
-	const extractedContent = [];
-	for (const message of assistantMessages) for (const part of message.parts ?? []) if ((part.type === "text" || part.type === "reasoning") && part.text) extractedContent.push(part.text);
-	return extractedContent.join("\n\n");
-}
-/**
-* Extract JSON from text that may contain markdown code blocks
-*/
-function extractJSON(text) {
-	const jsonBlockMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
-	if (jsonBlockMatch) return JSON.parse(jsonBlockMatch[1].trim());
-	const jsonMatch = text.match(/(\{[\s\S]*\}|\[[\s\S]*\])/);
-	if (jsonMatch) return JSON.parse(jsonMatch[1]);
-	return JSON.parse(text.trim());
-}
-/**
-* Extract short model name from full model string
-* e.g., "zhipuai-coding-plan/glm-4.6" -> "glm-4.6"
-*/
-function getModelShortName(modelName) {
-	const parts = modelName.split("/");
-	return parts[parts.length - 1] || modelName;
-}
-/**
-* Sanitize a string for use in file/directory names
-*/
-function sanitizeForFilename(text) {
-	return text.toLowerCase().replace(/\//g, "-").replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").substring(0, 50);
-}
-
-//#endregion
-//#region src/tools/generate-designs.ts
-/**
-* Create the generate_designs tool
-*/
-function createGenerateDesignsTool(ctx, config) {
-	return tool({
-		description: `Generate multiple independent design proposals for a technical system.
-
-This tool creates design proposals using ${config.design_models.length} different AI models:
-${config.design_models.map((m) => `- ${m}`).join("\n")}
-
-Each model generates a design completely independently, without seeing other models' outputs.
-
-Use this when you want to explore multiple approaches to a design problem and compare them.`,
-		args: {
-			requirements: tool.schema.string().describe("Detailed requirements for the design. Include problem statement, constraints, and non-functional requirements."),
-			topic: tool.schema.string().describe("Optional short topic name (2-4 words) for the design session. If not provided, one will be generated.").optional()
-		},
-		async execute(args, toolContext) {
-			const { requirements, topic: userTopic } = args;
-			const sessionID = toolContext.sessionID;
-			const topic = userTopic ? sanitizeForFilename(userTopic) : await generateTopic(ctx, config, requirements, sessionID);
-			const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-			const labDir = path.join(ctx.directory, config.base_output_dir, `${date}-${topic}`);
-			if (fs.existsSync(labDir)) {
-				logger.warn({ labDir }, "Lab directory already exists, using existing");
-				return `Error: Lab directory already exists at ${labDir}. This may be from a previous attempt. Please check the existing designs or delete the directory to retry.`;
-			}
-			const designsDir = path.join(labDir, "designs");
-			const reviewsDir = path.join(labDir, "reviews");
-			const scoresDir = path.join(labDir, "scores");
-			fs.mkdirSync(designsDir, { recursive: true });
-			fs.mkdirSync(reviewsDir, { recursive: true });
-			fs.mkdirSync(scoresDir, { recursive: true });
-			const taskData = {
-				requirements,
-				topic,
-				created: (/* @__PURE__ */ new Date()).toISOString(),
-				design_models: config.design_models,
-				review_models: config.review_models ?? config.design_models
-			};
-			fs.writeFileSync(path.join(labDir, "task.json"), JSON.stringify(taskData, null, 2));
-			const results = [];
-			for (const model of config.design_models) try {
-				logger.info({ model }, `Starting design generation for model: ${model}`);
-				const design = await generateDesign(ctx, config, model, requirements, sessionID);
-				const validationResult = DesignArtifactSchema.safeParse(design);
-				if (!validationResult.success) {
-					logger.error({
-						model,
-						errors: validationResult.error.issues
-					}, "Design schema validation failed");
-					results.push({
-						model,
-						success: false,
-						error: `Schema validation failed: ${validationResult.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ")}`
-					});
-					continue;
-				}
-				const modelShortName = getModelShortName(model);
-				const designFile = path.join(designsDir, `${sanitizeForFilename(modelShortName)}.json`);
-				fs.writeFileSync(designFile, JSON.stringify(design, null, 2));
-				logger.info({
-					model,
-					designFile
-				}, "Design saved as JSON");
-				const markdownFile = path.join(designsDir, `${sanitizeForFilename(modelShortName)}.md`);
-				const markdown = formatDesignAsMarkdown(design, model);
-				fs.writeFileSync(markdownFile, markdown);
-				logger.info({
-					model,
-					markdownFile
-				}, "Design saved as Markdown");
-				results.push({
-					model,
-					success: true
-				});
-			} catch (err) {
-				const errorMsg = err instanceof Error ? err.message : String(err);
-				logger.error({
-					model,
-					error: errorMsg
-				}, "Design generation failed");
-				results.push({
-					model,
-					success: false,
-					error: errorMsg
-				});
-			}
-			const successCount = results.filter((r) => r.success).length;
-			return `Design generation complete.
-
-**Lab Directory**: ${labDir}
-
-**Results**: ${successCount} successful, ${results.filter((r) => !r.success).length} failed
-
-${results.map((r) => r.success ? `✅ ${r.model}: Generated successfully` : `❌ ${r.model}: ${r.error}`).join("\n")}
-
-${successCount >= 2 ? `\nNext step: Run the review_designs tool to evaluate and compare the designs.` : `\nWarning: At least 2 successful designs are needed for meaningful comparison.`}`;
-		}
-	});
-}
-/**
-* Format a design artifact as markdown for human readability
-*/
-function formatDesignAsMarkdown(design, model) {
-	let md = `# ${design.title}\n\n`;
-	md += `**Model**: ${model}\n\n`;
-	md += `## Summary\n\n${design.summary}\n\n`;
-	md += `## Assumptions\n\n`;
-	design.assumptions.forEach((a) => md += `- ${a}\n`);
-	md += `\n`;
-	md += `## Architecture Overview\n\n${design.architecture_overview}\n\n`;
-	md += `## Components\n\n`;
-	design.components.forEach((c) => {
-		md += `### ${c.name}\n\n${c.description}\n\n**Responsibilities**:\n`;
-		c.responsibilities.forEach((r) => md += `- ${r}\n`);
-		md += `\n`;
-	});
-	md += `## Data Flow\n\n${design.data_flow}\n\n`;
-	md += `## Tradeoffs\n\n`;
-	design.tradeoffs.forEach((t) => {
-		md += `### ${t.aspect}\n\n`;
-		md += `**Options**: ${t.options.join(", ")}\n\n`;
-		md += `**Chosen**: ${t.chosen}\n\n`;
-		md += `**Rationale**: ${t.rationale}\n\n`;
-	});
-	md += `## Risks\n\n`;
-	design.risks.forEach((r) => {
-		md += `### ${r.risk} (Impact: ${r.impact})\n\n`;
-		md += `**Mitigation**: ${r.mitigation}\n\n`;
-	});
-	md += `## Open Questions\n\n`;
-	design.open_questions.forEach((q) => md += `- ${q}\n`);
-	return md;
-}
-/**
-* Generate a topic name from requirements
-*/
-async function generateTopic(ctx, config, requirements, parentSessionID) {
-	config.topic_generator_model || config.design_models[0];
-	const sessionID = await createAgentSession(ctx, parentSessionID, "Topic Generation", ctx.directory);
-	await sendPrompt(ctx, sessionID, `Generate a concise 2-4 word topic name for this design task. Output ONLY the topic name, nothing else.
-
-Requirements:
-${requirements.substring(0, 500)}`, {
-		write: false,
-		edit: false,
-		bash: false
-	});
-	await pollForCompletion(ctx, sessionID);
-	return sanitizeForFilename((await extractSessionOutput(ctx, sessionID)).trim());
-}
-/**
-* Generate a single design using a specific model
-*/
-async function generateDesign(ctx, config, model, requirements, parentSessionID) {
-	const agentConfig = createDesignAgent(model, config.design_agent_temperature);
-	const sessionID = await createAgentSession(ctx, parentSessionID, `Design Generation - ${model}`, ctx.directory);
-	const prompt = `Generate a comprehensive design proposal for the following requirements.
-
-## Requirements
-
-${requirements}
-
-## Instructions
-
-1. Analyze the requirements thoroughly
-2. Consider multiple approaches before deciding
-3. Output your design as valid JSON following the required schema
-4. Be specific and actionable in your design
-
-Remember: Your entire response must be valid JSON with no other text.`;
-	const fullPrompt = `${agentConfig.prompt}\n\n${prompt}`;
-	logger.info({
-		model,
-		sessionID
-	}, "Sending design prompt to agent");
-	await sendPrompt(ctx, sessionID, fullPrompt, agentConfig.tools);
-	logger.info({
-		model,
-		sessionID
-	}, "Polling for completion");
-	await pollForCompletion(ctx, sessionID);
-	logger.info({
-		model,
-		sessionID
-	}, "Extracting session output");
-	const output = await extractSessionOutput(ctx, sessionID);
-	logger.info({
-		model,
-		outputLength: output.length
-	}, "Extracting JSON from output");
-	return extractJSON(output);
-}
-
-//#endregion
-//#region src/tools/review-designs.ts
-/**
-* Create the review_designs tool
-*/
-function createReviewDesignsTool(ctx, config) {
-	const reviewModels = config.review_models ?? config.design_models;
-	return tool({
-		description: `Review and score design proposals using ${reviewModels.length} reviewer models.
-
-Each reviewer analyzes all designs and provides:
-1. A markdown review comparing the designs
-2. Numeric scores (0-10) across dimensions: clarity, feasibility, scalability, maintainability, completeness, overall
-
-Use this after generate_designs to evaluate and compare the generated designs.`,
-		args: { lab_path: tool.schema.string().describe(`Path to the design lab directory (e.g., .design-lab/2024-01-15-api-gateway). If not provided, uses the most recent lab.`).optional() },
-		async execute(args, toolContext) {
-			const sessionID = toolContext.sessionID;
-			const labDir = args.lab_path ? path.resolve(ctx.directory, args.lab_path) : findMostRecentLab$1(ctx.directory, config.base_output_dir);
-			if (!labDir) return "Error: No design lab found. Run generate_designs first.";
-			const designsDir = path.join(labDir, "designs");
-			const reviewsDir = path.join(labDir, "reviews");
-			const scoresDir = path.join(labDir, "scores");
-			const designFiles = fs.readdirSync(designsDir).filter((f) => f.endsWith(".json"));
-			if (designFiles.length === 0) return "Error: No designs found in the lab directory.";
-			const designs = {};
-			for (const file of designFiles) {
-				const designId = file.replace(".json", "");
-				const content = fs.readFileSync(path.join(designsDir, file), "utf-8");
-				designs[designId] = JSON.parse(content);
-			}
-			const taskPath = path.join(labDir, "task.json");
-			const requirements = JSON.parse(fs.readFileSync(taskPath, "utf-8")).requirements;
-			const results = [];
-			for (const model of reviewModels) try {
-				const { review, scores } = await generateReview(ctx, config, model, requirements, designs, sessionID);
-				const reviewFile = path.join(reviewsDir, `review-${sanitizeForFilename(getModelShortName(model))}.md`);
-				fs.writeFileSync(reviewFile, review);
-				logger.info({
-					model,
-					reviewFile
-				}, "Review saved");
-				for (const score of scores) {
-					const validationResult = ScoreSchema.safeParse(score);
-					if (!validationResult.success) console.warn(`Score validation warning for ${score.design_id}:`, validationResult.error);
-					const designShortName = getModelShortName(score.design_id);
-					const reviewerShortName = getModelShortName(model);
-					const scoreFile = path.join(scoresDir, `${sanitizeForFilename(designShortName)}-reviewed-by-${sanitizeForFilename(reviewerShortName)}.json`);
-					fs.writeFileSync(scoreFile, JSON.stringify(score, null, 2));
-				}
-				results.push({
-					model,
-					success: true
-				});
-			} catch (err) {
-				const errorMsg = err instanceof Error ? err.message : String(err);
-				results.push({
-					model,
-					success: false,
-					error: errorMsg
-				});
-			}
-			const successCount = results.filter((r) => r.success).length;
-			return `Review complete.
-
-**Lab Directory**: ${labDir}
-
-**Results**: ${successCount} successful, ${results.filter((r) => !r.success).length} failed
-
-${results.map((r) => r.success ? `✅ ${r.model}: Review generated` : `❌ ${r.model}: ${r.error}`).join("\n")}
-
-**Reviews saved to**: ${reviewsDir}
-**Scores saved to**: ${scoresDir}
-
-${successCount > 0 ? `\nNext step: Run the aggregate_scores tool to generate final rankings.` : ""}`;
-		}
-	});
-}
-/**
-* Find the most recent design lab directory
-*/
-function findMostRecentLab$1(projectDir, baseDir) {
-	const labBaseDir = path.join(projectDir, baseDir);
-	if (!fs.existsSync(labBaseDir)) return null;
-	const labs = fs.readdirSync(labBaseDir).filter((d) => fs.statSync(path.join(labBaseDir, d)).isDirectory()).sort().reverse();
-	if (labs.length === 0) return null;
-	return path.join(labBaseDir, labs[0]);
-}
-/**
-* Generate a review using a specific model
-*/
-async function generateReview(ctx, config, model, requirements, designs, parentSessionID) {
-	const agentConfig = createReviewAgent(model, config.review_agent_temperature);
-	const sessionID = await createAgentSession(ctx, parentSessionID, `Design Review - ${model}`, ctx.directory);
-	const prompt = `Review and compare the following design proposals.
-
-## Original Requirements
-
-${requirements}
-
-## Designs to Review
-
-${Object.entries(designs).map(([id, design]) => `## Design: ${id}\n\n\`\`\`json\n${JSON.stringify(design, null, 2)}\n\`\`\``).join("\n\n---\n\n")}
-
-## Your Task
-
-1. Analyze each design thoroughly
-2. Compare them across dimensions: clarity, feasibility, scalability, maintainability, completeness
-3. Provide a detailed markdown review with your analysis
-4. At the end, include a score table in markdown format
-5. Identify strengths and weaknesses of each design
-
-Be objective and support your assessments with specific observations.`;
-	await sendPrompt(ctx, sessionID, `${agentConfig.prompt}\n\n${prompt}`, agentConfig.tools);
-	await pollForCompletion(ctx, sessionID);
-	const review = await extractSessionOutput(ctx, sessionID);
-	await sendPrompt(ctx, sessionID, `Now output the scores for each design as a JSON array. Each element should have this structure:
-
-{
-  "design_id": "EXACT_DESIGN_ID_FROM_LIST_BELOW",
-  "reviewer_model": "${model}",
-  "scores": {
-    "clarity": 0-10,
-    "feasibility": 0-10,
-    "scalability": 0-10,
-    "maintainability": 0-10,
-    "completeness": 0-10,
-    "overall": 0-10
-  },
-  "justification": "Brief overall justification",
-  "strengths": ["list", "of", "strengths"],
-  "weaknesses": ["list", "of", "weaknesses"],
-  "missing_considerations": ["list", "of", "things", "missing"]
-}
-
-**IMPORTANT**: The "design_id" field MUST be one of these exact values:
-${Object.keys(designs).map((id) => `- "${id}"`).join("\n")}
-
-Output ONLY the JSON array with one score object per design. No other text.`, agentConfig.tools);
-	await pollForCompletion(ctx, sessionID);
-	return {
-		review,
-		scores: extractJSON(await extractSessionOutput(ctx, sessionID))
-	};
-}
-
-//#endregion
-//#region src/tools/aggregate-scores.ts
-/**
-* Create the aggregate_scores tool
-*/
-function createAggregateScoresTool(ctx, config) {
-	return tool({
-		description: `Aggregate scores from all reviewers and generate final rankings.
-
-This tool:
-1. Reads all score files from the reviews
-2. Calculates average scores per design
-3. Computes variance/disagreement metrics
-4. Generates a final ranking with results.md
-
-Use this after review_designs to get the final comparison.`,
-		args: { lab_path: tool.schema.string().describe(`Path to the design lab directory. If not provided, uses the most recent lab.`).optional() },
-		async execute(args) {
-			const labDir = args.lab_path ? path.resolve(ctx.directory, args.lab_path) : findMostRecentLab(ctx.directory, config.base_output_dir);
-			if (!labDir) return "Error: No design lab found. Run generate_designs first.";
-			const scoresDir = path.join(labDir, "scores");
-			const resultsDir = path.join(labDir, "results");
-			if (!fs.existsSync(scoresDir)) return "Error: No scores directory found. Run review_designs first.";
-			fs.mkdirSync(resultsDir, { recursive: true });
-			const scoreFiles = fs.readdirSync(scoresDir).filter((f) => f.endsWith(".json"));
-			if (scoreFiles.length === 0) return "Error: No score files found. Run review_designs first.";
-			const allScores = [];
-			for (const file of scoreFiles) {
-				const content = fs.readFileSync(path.join(scoresDir, file), "utf-8");
-				allScores.push(JSON.parse(content));
-			}
-			const scoresByDesign = {};
-			for (const score of allScores) {
-				if (!scoresByDesign[score.design_id]) scoresByDesign[score.design_id] = [];
-				scoresByDesign[score.design_id].push(score);
-			}
-			const rankings = [];
-			for (const [designId, scores] of Object.entries(scoresByDesign)) {
-				const overallScores = scores.map((s) => s.scores.overall);
-				const avgOverall = overallScores.reduce((a, b) => a + b, 0) / overallScores.length;
-				const variance = overallScores.reduce((sum, s) => sum + Math.pow(s - avgOverall, 2), 0) / overallScores.length;
-				const dimensions = [
-					"clarity",
-					"feasibility",
-					"scalability",
-					"maintainability",
-					"completeness",
-					"overall"
-				];
-				const scoreBreakdown = {};
-				for (const dim of dimensions) {
-					const dimScores = scores.map((s) => s.scores[dim]);
-					scoreBreakdown[dim] = dimScores.reduce((a, b) => a + b, 0) / dimScores.length;
-				}
-				rankings.push({
-					design_id: designId,
-					rank: 0,
-					average_score: avgOverall,
-					score_breakdown: scoreBreakdown,
-					variance,
-					reviewer_count: scores.length
-				});
-			}
-			rankings.sort((a, b) => b.average_score - a.average_score);
-			rankings.forEach((r, i) => {
-				r.rank = i + 1;
-			});
-			fs.writeFileSync(path.join(resultsDir, "ranking.json"), JSON.stringify(rankings, null, 2));
-			const resultsMarkdown = generateResultsMarkdown(rankings, allScores);
-			fs.writeFileSync(path.join(resultsDir, "results.md"), resultsMarkdown);
-			return `Aggregation complete.
-
-**Rankings saved to**: ${path.join(resultsDir, "ranking.json")}
-**Results summary saved to**: ${path.join(resultsDir, "results.md")}
-
-## Final Rankings
-
-${rankings.map((r) => `${r.rank}. **${r.design_id}** - Score: ${r.average_score.toFixed(1)}/10 (variance: ${r.variance.toFixed(2)})`).join("\n")}
-
-View the full results in ${path.join(resultsDir, "results.md")}`;
-		}
-	});
-}
-/**
-* Find the most recent design lab directory
-*/
-function findMostRecentLab(projectDir, baseDir) {
-	const labBaseDir = path.join(projectDir, baseDir);
-	if (!fs.existsSync(labBaseDir)) return null;
-	const labs = fs.readdirSync(labBaseDir).filter((d) => fs.statSync(path.join(labBaseDir, d)).isDirectory()).sort().reverse();
-	if (labs.length === 0) return null;
-	return path.join(labBaseDir, labs[0]);
-}
-/**
-* Generate the results markdown file
-*/
-function generateResultsMarkdown(rankings, allScores) {
-	const dimensions = [
-		"clarity",
-		"feasibility",
-		"scalability",
-		"maintainability",
-		"completeness",
-		"overall"
-	];
-	const reviewers = [...new Set(allScores.map((s) => s.reviewer_model))];
-	let md = `# Design Lab Results
-
-Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
-
-## Summary
-
-| Rank | Design | Avg Score | Variance | Reviewers |
-|------|--------|-----------|----------|-----------|
-${rankings.map((r) => `| ${r.rank} | ${r.design_id} | ${r.average_score.toFixed(1)} | ${r.variance.toFixed(2)} | ${r.reviewer_count} |`).join("\n")}
-
-## Detailed Score Breakdown
-
-### Average Scores by Dimension
-
-| Design | ${dimensions.join(" | ")} |
-|--------|${"---|".repeat(dimensions.length)}
-${rankings.map((r) => `| ${r.design_id} | ${dimensions.map((d) => r.score_breakdown[d].toFixed(1)).join(" | ")} |`).join("\n")}
-
-## Reviewer × Design Matrix
-
-### Overall Scores
-
-| Reviewer | ${rankings.map((r) => r.design_id).join(" | ")} |
-|----------|${"---|".repeat(rankings.length)}
-${reviewers.map((reviewer) => {
-		return `| ${reviewer} | ${rankings.map((r) => {
-			const score = allScores.find((s) => s.design_id === r.design_id && s.reviewer_model === reviewer);
-			return score ? score.scores.overall.toFixed(1) : "N/A";
-		}).join(" | ")} |`;
-	}).join("\n")}
-
-## Key Observations
-
-`;
-	const topDesign = rankings[0];
-	md += `### Winner: ${topDesign.design_id}
-
-- **Average Score**: ${topDesign.average_score.toFixed(1)}/10
-- **Variance**: ${topDesign.variance.toFixed(2)} (${topDesign.variance < 1 ? "high consensus" : topDesign.variance < 2 ? "moderate consensus" : "low consensus"})
-
-`;
-	md += `### Strengths and Weaknesses\n\n`;
-	for (const ranking of rankings.slice(0, 3)) {
-		const designScores = allScores.filter((s) => s.design_id === ranking.design_id);
-		const strengths = [...new Set(designScores.flatMap((s) => s.strengths))].slice(0, 3);
-		const weaknesses = [...new Set(designScores.flatMap((s) => s.weaknesses))].slice(0, 3);
-		md += `#### ${ranking.rank}. ${ranking.design_id}\n\n`;
-		md += `**Strengths**:\n${strengths.map((s) => `- ${s}`).join("\n")}\n\n`;
-		md += `**Weaknesses**:\n${weaknesses.map((w) => `- ${w}`).join("\n")}\n\n`;
-	}
-	return md;
-}
-
 //#endregion
 //#region src/design-lab.ts
 /**
@@ -1003,13 +387,48 @@ ${reviewers.map((reviewer) => {
 * then systematically evaluates, compares, and ranks those designs.
 */
 const DesignLab = async (ctx) => {
-	const config = loadPluginConfig(ctx.directory);
-	return { tool: {
-		generate_designs: createGenerateDesignsTool(ctx, config),
-		review_designs: createReviewDesignsTool(ctx, config),
-		aggregate_scores: createAggregateScoresTool(ctx, config)
+	const pluginConfig = loadPluginConfig(ctx.directory);
+	logger.info("Design Lab Plugin Loaded");
+	return { config: async (config) => {
+		const designModels = uniqueModels(pluginConfig.design_models);
+		const reviewModels = uniqueModels(pluginConfig.review_models ?? pluginConfig.design_models);
+		const allModels = uniqueModels([...designModels, ...reviewModels]);
+		const modelSpecs = new Map(allModels.map((model) => [model, {
+			model,
+			agentName: getDesignerSubagentName(model),
+			fileStem: getDesignerModelFileStem(model)
+		}]));
+		const designSpecs = designModels.map((model) => modelSpecs.get(model)).filter(isModelSpec);
+		const reviewSpecs = reviewModels.map((model) => modelSpecs.get(model)).filter(isModelSpec);
+		const subagentEntries = Array.from(modelSpecs.values()).map((spec) => [spec.agentName, createDesignerModelAgent(spec.model)]);
+		config.agent = {
+			...config.agent ?? {},
+			designer: createDesignerPrimaryAgent({
+				baseOutputDir: pluginConfig.base_output_dir,
+				designModels: designSpecs,
+				reviewModels: reviewSpecs
+			}),
+			...Object.fromEntries(subagentEntries)
+		};
+		const agentKeys = Object.keys(config.agent ?? {});
+		logger.info({
+			designModels,
+			reviewModels,
+			agentsRegistered: agentKeys
+		}, "DesignLab agents registered");
 	} };
 };
+function uniqueModels(models) {
+	const seen = /* @__PURE__ */ new Set();
+	return models.filter((model) => {
+		if (seen.has(model)) return false;
+		seen.add(model);
+		return true;
+	});
+}
+function isModelSpec(spec) {
+	return Boolean(spec);
+}
 
 //#endregion
 export { DesignLab };