codingbuddy 5.1.3 → 5.3.0

package/dist/src/cli/plugin/create-plugin.command.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePluginName = validatePluginName;
+exports.generateMinimalTemplate = generateMinimalTemplate;
+exports.generateFullTemplate = generateFullTemplate;
+exports.runCreatePlugin = runCreatePlugin;
+const fs = require("fs");
+const path = require("path");
+const child_process_1 = require("child_process");
+const console_1 = require("../utils/console");
+const PLUGIN_NAME_REGEX = /^[a-z][a-z0-9-]*$/;
+function validatePluginName(name) {
+    return PLUGIN_NAME_REGEX.test(name);
+}
+function getDefaultAuthor() {
+    try {
+        return (0, child_process_1.execSync)('git config user.name', { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function generateMinimalTemplate(ctx) {
+    const manifest = {
+        name: ctx.name,
+        version: '1.0.0',
+        description: ctx.description,
+        author: ctx.author,
+        provides: {
+            agents: [],
+            rules: [],
+            skills: [],
+            checklists: [],
+        },
+    };
+    const readme = `# ${ctx.name}
+
+${ctx.description}
+
+## Installation
+
+\`\`\`bash
+codingbuddy install ./${ctx.name}
+\`\`\`
+
+## Author
+
+${ctx.author}
+`;
+    const gitignore = `node_modules/
+dist/
+.DS_Store
+`;
+    return {
+        'plugin.json': JSON.stringify(manifest, null, 2),
+        'README.md': readme,
+        '.gitignore': gitignore,
+    };
+}
+function generateFullTemplate(ctx) {
+    const minimalFiles = generateMinimalTemplate(ctx);
+    const manifest = JSON.parse(minimalFiles['plugin.json']);
+    manifest.provides = {
+        agents: ['agents/example-agent.json'],
+        rules: ['rules/example-rule.md'],
+        skills: ['skills/example-skill.md'],
+        checklists: ['checklists/example-checklist.json'],
+    };
+    const exampleAgent = {
+        name: 'Example Agent',
+        description: `Example specialist agent for ${ctx.name}`,
+        role: {
+            title: 'Example Specialist',
+            expertise: ['example-domain'],
+        },
+        activation_message: {
+            formatted: '🤖 example-agent [Example Specialist]',
+        },
+    };
+    const exampleSkill = `# Example Skill
+
+## Purpose
+
+An example skill provided by ${ctx.name}.
+
+## Instructions
+
+Describe the skill instructions here.
+`;
+    const exampleRule = `# Example Rule
+
+## Description
+
+An example rule provided by ${ctx.name}.
+
+## Guidelines
+
+- Guideline 1
+- Guideline 2
+`;
+    const exampleChecklist = {
+        name: 'Example Checklist',
+        description: `Example checklist from ${ctx.name}`,
+        items: [
+            {
+                id: 'example-1',
+                text: 'Check example condition',
+                severity: 'medium',
+            },
+        ],
+    };
+    return {
+        ...minimalFiles,
+        'plugin.json': JSON.stringify(manifest, null, 2),
+        'agents/example-agent.json': JSON.stringify(exampleAgent, null, 2),
+        'skills/example-skill.md': exampleSkill,
+        'rules/example-rule.md': exampleRule,
+        'checklists/example-checklist.json': JSON.stringify(exampleChecklist, null, 2),
+    };
+}
+async function runCreatePlugin(options) {
+    const console = (0, console_1.createConsoleUtils)();
+    if (!validatePluginName(options.name)) {
+        const msg = `Invalid plugin name "${options.name}". Must match /^[a-z][a-z0-9-]*$/`;
+        console.log.error(msg);
+        return { success: false, error: msg };
+    }
+    const pluginDir = path.join(options.outputDir, options.name);
+    if (fs.existsSync(pluginDir)) {
+        const msg = `Directory "${pluginDir}" already exists`;
+        console.log.error(msg);
+        return { success: false, error: msg };
+    }
+    const author = options.author ?? getDefaultAuthor();
+    const description = options.description ?? `A CodingBuddy plugin: ${options.name}`;
+    const ctx = {
+        name: options.name,
+        description,
+        author,
+    };
+    const files = options.template === 'full' ? generateFullTemplate(ctx) : generateMinimalTemplate(ctx);
+    console.log.step('🔧', `Scaffolding plugin "${options.name}" (${options.template} template)...`);
+    for (const [filePath, content] of Object.entries(files)) {
+        const fullPath = path.join(pluginDir, filePath);
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        fs.writeFileSync(fullPath, content, 'utf-8');
+    }
+    console.log.success(`Plugin "${options.name}" created at ${pluginDir}`);
+    return { success: true, pluginDir };
+}
+//# sourceMappingURL=create-plugin.command.js.map

package/dist/src/cli/plugin/install.command.d.ts

@@ -0,0 +1,10 @@
+export interface InstallCommandOptions {
+    source: string;
+    projectRoot: string;
+    force: boolean;
+}
+export interface InstallCommandResult {
+    success: boolean;
+    error?: string;
+}
+export declare function runInstall(options: InstallCommandOptions): Promise<InstallCommandResult>;

package/dist/src/cli/plugin/install.command.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInstall = runInstall;
+const plugin_installer_service_1 = require("../../plugin/plugin-installer.service");
+const console_1 = require("../utils/console");
+async function runInstall(options) {
+    const console = (0, console_1.createConsoleUtils)();
+    const installer = new plugin_installer_service_1.PluginInstallerService();
+    try {
+        const resolved = await installer.resolveSource(options.source);
+        console.log.step('📦', `Installing plugin from ${resolved.source}...`);
+        const result = await installer.install({
+            source: resolved.source,
+            targetRoot: options.projectRoot,
+            force: options.force,
+            version: resolved.version,
+        });
+        if (result.success) {
+            console.log.success(result.summary ?? `Installed ${result.pluginName}`);
+            return { success: true };
+        }
+        console.log.error(result.error ?? 'Installation failed');
+        return { success: false, error: result.error };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.log.error(message);
+        return { success: false, error: message };
+    }
+}
+//# sourceMappingURL=install.command.js.map

package/dist/src/cli/plugin/plugins.command.d.ts

@@ -0,0 +1,9 @@
+export interface PluginsCommandOptions {
+    projectRoot: string;
+}
+export interface PluginsCommandResult {
+    success: boolean;
+    count: number;
+    error?: string;
+}
+export declare function runPlugins(options: PluginsCommandOptions): PluginsCommandResult;

package/dist/src/cli/plugin/plugins.command.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPlugins = runPlugins;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const console_1 = require("../utils/console");
+function formatAssetCounts(provides) {
+    const parts = [];
+    if (provides.agents.length > 0) {
+        parts.push(`${provides.agents.length} agents`);
+    }
+    if (provides.rules.length > 0) {
+        parts.push(`${provides.rules.length} rules`);
+    }
+    if (provides.skills.length > 0) {
+        parts.push(`${provides.skills.length} skills`);
+    }
+    if (provides.checklists.length > 0) {
+        parts.push(`${provides.checklists.length} checklists`);
+    }
+    return parts.length > 0 ? `(${parts.join(', ')})` : '(no assets)';
+}
+function runPlugins(options) {
+    const console = (0, console_1.createConsoleUtils)();
+    const pluginsJsonPath = (0, path_1.join)(options.projectRoot, '.codingbuddy', 'plugins.json');
+    if (!(0, fs_1.existsSync)(pluginsJsonPath)) {
+        console.log.info('No plugins installed.');
+        return { success: true, count: 0 };
+    }
+    let registry;
+    try {
+        const raw = (0, fs_1.readFileSync)(pluginsJsonPath, 'utf-8');
+        registry = JSON.parse(raw);
+    }
+    catch {
+        console.log.error('Failed to read plugins.json. File may be corrupted.');
+        return { success: false, count: 0, error: 'Corrupted plugins.json' };
+    }
+    if (!registry.plugins || registry.plugins.length === 0) {
+        console.log.info('No plugins installed.');
+        return { success: true, count: 0 };
+    }
+    console.log.info('Installed plugins:');
+    for (const plugin of registry.plugins) {
+        const counts = formatAssetCounts(plugin.provides);
+        console.log.step('  ', `${plugin.name} ${plugin.version} ${counts}`);
+    }
+    console.log.info(`\nTotal: ${registry.plugins.length} plugin${registry.plugins.length !== 1 ? 's' : ''}`);
+    return { success: true, count: registry.plugins.length };
+}
+//# sourceMappingURL=plugins.command.js.map

package/dist/src/cli/plugin/search.command.d.ts

@@ -0,0 +1,9 @@
+export interface SearchCommandOptions {
+    query: string;
+}
+export interface SearchCommandResult {
+    success: boolean;
+    count: number;
+    error?: string;
+}
+export declare function runSearch(options: SearchCommandOptions): Promise<SearchCommandResult>;

package/dist/src/cli/plugin/search.command.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSearch = runSearch;
+const registry_client_1 = require("../../plugin/registry-client");
+const console_1 = require("../utils/console");
+function formatProvides(provides) {
+    const parts = [];
+    const agents = provides.agents?.length ?? 0;
+    const rules = provides.rules?.length ?? 0;
+    const skills = provides.skills?.length ?? 0;
+    const checklists = provides.checklists?.length ?? 0;
+    if (agents > 0)
+        parts.push(`${agents} agent${agents !== 1 ? 's' : ''}`);
+    if (rules > 0)
+        parts.push(`${rules} rule${rules !== 1 ? 's' : ''}`);
+    if (skills > 0)
+        parts.push(`${skills} skill${skills !== 1 ? 's' : ''}`);
+    if (checklists > 0)
+        parts.push(`${checklists} checklist${checklists !== 1 ? 's' : ''}`);
+    return parts.length > 0 ? parts.join(', ') : 'no assets';
+}
+function printPlugin(console, plugin) {
+    console.log.step('  ', `${plugin.name} (${plugin.version}) — ${plugin.description}`);
+    if (plugin.tags.length > 0) {
+        console.log.step('  ', `  Tags: ${plugin.tags.join(', ')}`);
+    }
+    console.log.step('  ', `  Provides: ${formatProvides(plugin.provides)}`);
+    console.log.step('  ', `  Install: codingbuddy install ${plugin.name}`);
+}
+async function runSearch(options) {
+    const console = (0, console_1.createConsoleUtils)();
+    const client = new registry_client_1.RegistryClient();
+    try {
+        const results = await client.search(options.query);
+        if (results.length === 0) {
+            console.log.info(`No plugins found matching "${options.query}"`);
+            return { success: true, count: 0 };
+        }
+        console.log.step('🔍', `Search results for "${options.query}":\n`);
+        for (const plugin of results) {
+            printPlugin(console, plugin);
+            process.stdout.write('\n');
+        }
+        console.log.info(`Found ${results.length} plugin${results.length !== 1 ? 's' : ''} matching "${options.query}"`);
+        return { success: true, count: results.length };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.log.error(`Search failed: ${message}`);
+        return { success: false, count: 0, error: message };
+    }
+}
+//# sourceMappingURL=search.command.js.map

package/dist/src/cli/plugin/uninstall.command.d.ts

@@ -0,0 +1,12 @@
+export interface UninstallCommandOptions {
+    pluginName: string;
+    projectRoot: string;
+    yes: boolean;
+}
+export interface UninstallCommandResult {
+    success: boolean;
+    error?: string;
+    confirmationRequired?: boolean;
+    pluginSummary?: string;
+}
+export declare function runUninstall(options: UninstallCommandOptions): UninstallCommandResult;

package/dist/src/cli/plugin/uninstall.command.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runUninstall = runUninstall;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const console_1 = require("../utils/console");
+const ASSET_EXTENSIONS = {
+    agents: '.json',
+    rules: '.md',
+    skills: '.md',
+    checklists: '.md',
+};
+const ASSET_DIRS = ['agents', 'rules', 'skills', 'checklists'];
+function removePluginFiles(aiRulesDir, provides) {
+    let removedCount = 0;
+    for (const dir of ASSET_DIRS) {
+        const names = provides[dir] ?? [];
+        const ext = ASSET_EXTENSIONS[dir];
+        for (const name of names) {
+            const filePath = (0, path_1.join)(aiRulesDir, dir, `${name}${ext}`);
+            if ((0, fs_1.existsSync)(filePath)) {
+                (0, fs_1.unlinkSync)(filePath);
+                removedCount++;
+            }
+        }
+    }
+    return removedCount;
+}
+function buildSummary(plugin) {
+    const parts = [];
+    if (plugin.provides.agents.length > 0)
+        parts.push(`${plugin.provides.agents.length} agents`);
+    if (plugin.provides.rules.length > 0)
+        parts.push(`${plugin.provides.rules.length} rules`);
+    if (plugin.provides.skills.length > 0)
+        parts.push(`${plugin.provides.skills.length} skills`);
+    if (plugin.provides.checklists.length > 0)
+        parts.push(`${plugin.provides.checklists.length} checklists`);
+    return parts.length > 0 ? `Removing ${parts.join(', ')}` : 'No assets to remove';
+}
+function runUninstall(options) {
+    const console = (0, console_1.createConsoleUtils)();
+    const pluginsJsonPath = (0, path_1.join)(options.projectRoot, '.codingbuddy', 'plugins.json');
+    if (!(0, fs_1.existsSync)(pluginsJsonPath)) {
+        console.log.error(`Plugin "${options.pluginName}" not found. No plugins are installed.`);
+        return { success: false, error: 'Plugin not found' };
+    }
+    let registry;
+    try {
+        const raw = (0, fs_1.readFileSync)(pluginsJsonPath, 'utf-8');
+        registry = JSON.parse(raw);
+    }
+    catch {
+        console.log.error('Failed to read plugins.json. File may be corrupted.');
+        return { success: false, error: 'Corrupted plugins.json' };
+    }
+    const plugin = registry.plugins.find(p => p.name === options.pluginName);
+    if (!plugin) {
+        console.log.error(`Plugin "${options.pluginName}" not found in registry.`);
+        return { success: false, error: 'Plugin not found' };
+    }
+    const summary = buildSummary(plugin);
+    console.log.step('📦', `Uninstalling ${plugin.name}@${plugin.version}...`);
+    console.log.step('  ', summary);
+    if (!options.yes) {
+        return {
+            success: false,
+            confirmationRequired: true,
+            pluginSummary: `${plugin.name}@${plugin.version}: ${summary}`,
+        };
+    }
+    const aiRulesDir = (0, path_1.join)(options.projectRoot, '.ai-rules');
+    removePluginFiles(aiRulesDir, plugin.provides);
+    registry.plugins = registry.plugins.filter(p => p.name !== options.pluginName);
+    (0, fs_1.writeFileSync)(pluginsJsonPath, JSON.stringify(registry, null, 2), 'utf-8');
+    console.log.success(`Removed ${plugin.name}`);
+    return { success: true };
+}
+//# sourceMappingURL=uninstall.command.js.map

package/dist/src/cli/plugin/update.command.d.ts

@@ -0,0 +1,11 @@
+export interface UpdateCommandOptions {
+    projectRoot: string;
+    pluginName?: string;
+}
+export interface UpdateCommandResult {
+    success: boolean;
+    checked: number;
+    updated: number;
+    error?: string;
+}
+export declare function runUpdate(options: UpdateCommandOptions): Promise<UpdateCommandResult>;

package/dist/src/cli/plugin/update.command.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runUpdate = runUpdate;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const registry_client_1 = require("../../plugin/registry-client");
+const plugin_installer_service_1 = require("../../plugin/plugin-installer.service");
+const console_1 = require("../utils/console");
+function compareVersions(a, b) {
+    const partsA = a.split('.').map(Number);
+    const partsB = b.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        const diff = (partsA[i] ?? 0) - (partsB[i] ?? 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+}
+async function runUpdate(options) {
+    const console = (0, console_1.createConsoleUtils)();
+    const pluginsJsonPath = (0, path_1.join)(options.projectRoot, '.codingbuddy', 'plugins.json');
+    if (!(0, fs_1.existsSync)(pluginsJsonPath)) {
+        console.log.info('No plugins installed.');
+        return { success: true, checked: 0, updated: 0 };
+    }
+    let registry;
+    try {
+        const raw = (0, fs_1.readFileSync)(pluginsJsonPath, 'utf-8');
+        registry = JSON.parse(raw);
+    }
+    catch {
+        console.log.error('Failed to read plugins.json. File may be corrupted.');
+        return { success: false, checked: 0, updated: 0, error: 'Corrupted plugins.json' };
+    }
+    let pluginsToCheck = registry.plugins;
+    if (options.pluginName) {
+        const found = registry.plugins.find(p => p.name === options.pluginName);
+        if (!found) {
+            console.log.error(`Plugin "${options.pluginName}" is not installed.`);
+            return { success: false, checked: 0, updated: 0, error: 'Plugin not installed' };
+        }
+        pluginsToCheck = [found];
+    }
+    if (pluginsToCheck.length === 0) {
+        console.log.info('No plugins installed.');
+        return { success: true, checked: 0, updated: 0 };
+    }
+    const client = new registry_client_1.RegistryClient();
+    let registryIndex;
+    try {
+        registryIndex = await client.fetchIndex();
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.log.error(`Failed to fetch registry: ${message}`);
+        return { success: false, checked: 0, updated: 0, error: message };
+    }
+    console.log.step('🔍', 'Checking for plugin updates...\n');
+    const outdated = [];
+    for (const installed of pluginsToCheck) {
+        const registryEntry = registryIndex.plugins.find(p => p.name === installed.name);
+        if (!registryEntry) {
+            console.log.warn(`${installed.name}: not found in registry, skipping.`);
+            continue;
+        }
+        if (compareVersions(registryEntry.version, installed.version) > 0) {
+            outdated.push({ installed, latestVersion: registryEntry.version });
+            console.log.step('📦', `${installed.name}: ${installed.version} → ${registryEntry.version}`);
+        }
+    }
+    if (outdated.length === 0) {
+        console.log.success('All plugins are up-to-date.');
+        return { success: true, checked: pluginsToCheck.length, updated: 0 };
+    }
+    const installer = new plugin_installer_service_1.PluginInstallerService();
+    let updatedCount = 0;
+    let hasFailure = false;
+    for (const { installed, latestVersion } of outdated) {
+        console.log.step('⬆️', `Updating ${installed.name} to ${latestVersion}...`);
+        const result = await installer.install({
+            source: installed.source,
+            targetRoot: options.projectRoot,
+            force: true,
+        });
+        if (result.success) {
+            console.log.success(`Updated ${installed.name} to ${latestVersion}`);
+            updatedCount++;
+        }
+        else {
+            console.log.error(`Failed to update ${installed.name}: ${result.error}`);
+            hasFailure = true;
+        }
+    }
+    if (updatedCount > 0) {
+        console.log.info(`Updated ${updatedCount} plugin${updatedCount !== 1 ? 's' : ''}.`);
+    }
+    return {
+        success: !hasFailure,
+        checked: pluginsToCheck.length,
+        updated: updatedCount,
+    };
+}
+//# sourceMappingURL=update.command.js.map

package/dist/src/cli/run-tui.d.ts

@@ -1,3 +1,4 @@
+export declare function resolveHudStateDir(): string;
 export declare function runTui(options?: {
     restart?: boolean;
 }): Promise<void>;

package/dist/src/cli/run-tui.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveHudStateDir = resolveHudStateDir;
 exports.runTui = runTui;
 const path = require("node:path");
 const os = require("node:os");
@@ -7,6 +8,11 @@ const ipc_types_1 = require("../tui/ipc/ipc.types");
 const instance_registry_1 = require("../tui/ipc/instance-registry");
 const restart_tui_1 = require("./restart-tui");
 const CLIENT_SHUTDOWN_TIMEOUT_MS = 3000;
+function resolveHudStateDir() {
+    return (process.env.CODINGBUDDY_HUD_STATE_DIR ??
+        process.env.CLAUDE_PLUGIN_DATA ??
+        path.join(os.homedir(), '.codingbuddy'));
+}
 async function runTui(options = {}) {
     if (options.restart) {
         const result = await (0, restart_tui_1.restartTui)();
@@ -46,7 +52,7 @@ async function runTui(options = {}) {
         const { HudFileBridge } = await Promise.resolve().then(() => require('../tui/events'));
         const sessions = manager.getSessions();
         if (sessions.length > 0) {
-            const hudStatePath = path.join(process.env.CODINGBUDDY_HUD_STATE_DIR ?? path.join(os.homedir(), '.codingbuddy'), 'hud-state.json');
+            const hudStatePath = path.join(resolveHudStateDir(), 'hud-state.json');
             const bridge = new HudFileBridge(sessions[0].eventBus, hudStatePath);
             bridge.start();
             hudBridge = bridge;

package/dist/src/collaboration/council-summary.service.d.ts

@@ -0,0 +1,2 @@
+import type { CouncilInput, CouncilSummary } from './council-summary.types';
+export declare function generateCouncilSummary(inputs: readonly CouncilInput[]): CouncilSummary;

package/dist/src/collaboration/council-summary.service.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCouncilSummary = generateCouncilSummary;
+function generateCouncilSummary(inputs) {
+    const opinions = [];
+    const failedAgents = [];
+    for (const input of inputs) {
+        if (input.opinion !== null) {
+            opinions.push(input.opinion);
+        }
+        else {
+            failedAgents.push(input.agentName);
+        }
+    }
+    const partialFailure = failedAgents.length > 0;
+    const consensus = detectConsensus(opinions);
+    const disagreements = detectDisagreements(opinions);
+    const blockingRisks = extractBlockingRisks(opinions);
+    const nextStep = determineNextStep(opinions, failedAgents, blockingRisks);
+    return {
+        opinions,
+        failedAgents,
+        consensus,
+        disagreements,
+        blockingRisks,
+        nextStep,
+        partialFailure,
+    };
+}
+function detectConsensus(opinions) {
+    if (opinions.length === 0)
+        return [];
+    const points = [];
+    const stances = new Set(opinions.map(o => o.stance));
+    if (stances.size === 1) {
+        const stance = opinions[0].stance;
+        points.push(`All specialists ${stanceVerb(stance)}`);
+    }
+    const sharedChanges = findSharedSuggestedChanges(opinions);
+    for (const change of sharedChanges) {
+        points.push(`Shared recommendation: ${change}`);
+    }
+    return points;
+}
+function findSharedSuggestedChanges(opinions) {
+    const changeCounts = new Map();
+    for (const opinion of opinions) {
+        for (const change of opinion.suggestedChanges) {
+            changeCounts.set(change, (changeCounts.get(change) ?? 0) + 1);
+        }
+    }
+    const shared = [];
+    for (const [change, count] of changeCounts) {
+        if (count >= 2) {
+            shared.push(change);
+        }
+    }
+    return shared;
+}
+function stanceVerb(stance) {
+    switch (stance) {
+        case 'approve':
+            return 'approve';
+        case 'concern':
+            return 'express concerns';
+        case 'reject':
+            return 'reject';
+    }
+}
+function detectDisagreements(opinions) {
+    if (opinions.length < 2)
+        return [];
+    const stances = new Set(opinions.map(o => o.stance));
+    if (stances.size <= 1)
+        return [];
+    const positions = opinions.map(o => ({
+        agentName: o.agentName,
+        stance: o.stance,
+        reasoning: o.reasoning,
+    }));
+    return [
+        {
+            topic: 'Overall assessment',
+            positions,
+        },
+    ];
+}
+function extractBlockingRisks(opinions) {
+    return opinions.filter(o => o.stance === 'reject').map(o => `${o.agentName}: ${o.reasoning}`);
+}
+function determineNextStep(opinions, failedAgents, blockingRisks) {
+    if (opinions.length === 0 && failedAgents.length === 0) {
+        return 'No specialist input available. Run specialist analysis first.';
+    }
+    if (opinions.length === 0 && failedAgents.length > 0) {
+        return `Re-run failed specialists (${failedAgents.join(', ')}) to obtain analysis.`;
+    }
+    if (blockingRisks.length > 0) {
+        return `Address ${blockingRisks.length} blocking risk(s) before proceeding.`;
+    }
+    const concerns = opinions.filter(o => o.stance === 'concern');
+    const parts = [];
+    if (failedAgents.length > 0) {
+        parts.push(`re-run failed specialists (${failedAgents.join(', ')})`);
+    }
+    if (concerns.length > 0) {
+        parts.push(`review ${concerns.length} concern(s)`);
+    }
+    if (parts.length > 0) {
+        return `Proceed with caution: ${parts.join(', ')}.`;
+    }
+    return 'Proceed with implementation — all specialists approve.';
+}
+//# sourceMappingURL=council-summary.service.js.map