codymaster 4.8.0 → 7.0.0

package/dist/mcp-context-server.js

@@ -3,7 +3,7 @@
 /**
  * CodyMaster MCP Context Server
  *
- * Exposes 13 tools over JSON-RPC 2.0 / stdio (Content-Length framing):
+ * Exposes 18 tools over JSON-RPC 2.0 / stdio (Content-Length framing):
  *   cm_query         — FTS5 search across learnings + decisions
  *   cm_resolve       — resolve a cm:// URI at L0/L1/L2
  *   cm_bus_read      — read context bus state
@@ -11,6 +11,7 @@
  *   cm_budget_check  — check token budget for a category
  *   cm_memory_decay  — TTL cleanup for learnings
  *   cm_index_refresh — regenerate L0 indexes
+ *   cm_advisory_report / cm_advisory_metrics / cm_advisory_handoff — advisory loop JSON surfaces
  *   cm_plan / cm_review / cm_qa / cm_deploy / cm_search / cm_memory_query — engineering kit bridge
  *
  * Usage (stdio MCP):
@@ -39,6 +40,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmAdvisoryReport = cmAdvisoryReport;
+exports.cmAdvisoryMetrics = cmAdvisoryMetrics;
+exports.cmAdvisoryHandoff = cmAdvisoryHandoff;
 const path_1 = __importDefault(require("path"));
 const context_db_1 = require("./context-db");
 const uri_resolver_1 = require("./uri-resolver");
@@ -46,6 +50,9 @@ const context_bus_1 = require("./context-bus");
 const token_budget_1 = require("./token-budget");
 const l0_indexer_1 = require("./l0-indexer");
 const mcp_skills_tools_1 = require("./mcp-skills-tools");
+const storage_backend_1 = require("./storage-backend");
+const advisory_report_1 = require("./advisory-report");
+const advisory_handoff_1 = require("./advisory-handoff");
 // ─── Config ──────────────────────────────────────────────────────────────────
 const SERVER_NAME = 'cm-context';
 const SERVER_VERSION = '1.0.0';
@@ -132,6 +139,84 @@ function cmBudgetCheck(args) {
         suggestion: check.suggestion,
     };
 }
+function autoDetectCategory(content) {
+    const c = content.toLowerCase();
+    if (/\b(decided|architecture|we chose|design decision|chose to)\b/.test(c))
+        return 'arch_decision';
+    if (/\b(bug|fixed|caused by|root cause|crash)\b/.test(c))
+        return 'bug_fix';
+    if (/\b(prefer|always use|never use|avoid|convention|standard)\b/.test(c))
+        return 'user_pref';
+    if (/\b(function|pattern|approach|method|implementation)\b/.test(c))
+        return 'code_pattern';
+    return 'context';
+}
+function cmMemoryWrite(args) {
+    var _a;
+    const { content, scope = 'project', category, ttl_days, importance = 'medium' } = args;
+    if (!(content === null || content === void 0 ? void 0 : content.trim()))
+        throw new Error('content is required');
+    const detectedCategory = category || autoDetectCategory(content);
+    const defaultTtl = { session: 30, project: 90, global: 365 };
+    const ttl = (_a = ttl_days !== null && ttl_days !== void 0 ? ttl_days : defaultTtl[scope]) !== null && _a !== void 0 ? _a : 90;
+    const now = new Date().toISOString();
+    const id = `nli-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+    const dbPath = (0, context_db_1.getDbPath)(PROJECT_PATH);
+    (0, context_db_1.insertLearning)(dbPath, {
+        id,
+        what_failed: content,
+        why_failed: detectedCategory,
+        how_to_prevent: `importance:${importance}`,
+        scope,
+        ttl,
+        reinforce_count: 0,
+        status: 'active',
+        created_at: now,
+        updated_at: now,
+        agent: 'cm_natural',
+    });
+    return { ok: true, id, content, category: detectedCategory, scope, ttl_days: ttl, importance };
+}
+const NLI_PATTERNS = [
+    { pattern: /\b(remember|save|note)\s+that\s+/i, action: 'write', scope: 'project' },
+    { pattern: /\b(remember|save)\s+this[:\s]/i, action: 'write', scope: 'project' },
+    { pattern: /\bimportant[:\s]+/i, action: 'write', scope: 'project', importance: 'high' },
+    { pattern: /\b(forget|remove|ignore)\s+(about\s+)?/i, action: 'decay' },
+    { pattern: /\bwhat\s+did\s+we\s+(learn|know)\b/i, action: 'query' },
+    { pattern: /\bwhat\s+do\s+we\s+know\b/i, action: 'query' },
+    { pattern: /\blessons?\s+learned\b/i, action: 'query' },
+    { pattern: /\b(search|find|look\s+up)\b/i, action: 'query' },
+];
+function cmNatural(args) {
+    var _a, _b, _c;
+    const { text } = args;
+    if (!(text === null || text === void 0 ? void 0 : text.trim()))
+        throw new Error('text is required');
+    for (const rule of NLI_PATTERNS) {
+        const match = text.match(rule.pattern);
+        if (!match)
+            continue;
+        const extracted = text.slice(((_a = match.index) !== null && _a !== void 0 ? _a : 0) + match[0].length).trim();
+        if (rule.action === 'write') {
+            const result = cmMemoryWrite({
+                content: extracted || text,
+                scope: (_b = rule.scope) !== null && _b !== void 0 ? _b : 'project',
+                importance: (_c = rule.importance) !== null && _c !== void 0 ? _c : 'medium',
+            });
+            return Object.assign(Object.assign({}, result), { matched_pattern: rule.pattern.source, routed_to: 'cm_memory_write' });
+        }
+        if (rule.action === 'decay') {
+            const result = cmMemoryDecay({ dry_run: false });
+            return Object.assign(Object.assign({}, result), { matched_pattern: rule.pattern.source, routed_to: 'cm_memory_decay' });
+        }
+        // query / search
+        const result = cmQuery({ query: extracted || text, scope: 'all', limit: 10 });
+        return Object.assign(Object.assign({}, result), { matched_pattern: rule.pattern.source, routed_to: 'cm_query' });
+    }
+    // No pattern matched — default to search
+    const result = cmQuery({ query: text, scope: 'all', limit: 10 });
+    return Object.assign(Object.assign({}, result), { matched_pattern: null, routed_to: 'cm_query (default)' });
+}
 function cmMemoryDecay(args) {
     const { dry_run = false } = args;
     const dbPath = (0, context_db_1.getDbPath)(PROJECT_PATH);
@@ -188,6 +273,55 @@ function cmIndexRefresh(args) {
     }
     throw new Error(`Unknown target: ${target}. Valid: learnings, skeleton, all`);
 }
+function cmAdvisoryReport(args) {
+    var _a;
+    const backend = (0, storage_backend_1.getBackend)(PROJECT_PATH);
+    backend.initialize();
+    try {
+        const limit = Math.max(1, (_a = args.limit) !== null && _a !== void 0 ? _a : 10);
+        const analyses = (0, advisory_report_1.buildAdvisoryReportData)(backend, { limit });
+        return {
+            count: analyses.length,
+            analyses,
+            generated_at: new Date().toISOString(),
+        };
+    }
+    finally {
+        backend.close();
+    }
+}
+function cmAdvisoryMetrics(args) {
+    var _a;
+    const backend = (0, storage_backend_1.getBackend)(PROJECT_PATH);
+    backend.initialize();
+    try {
+        const limit = Math.max(1, (_a = args.limit) !== null && _a !== void 0 ? _a : 10);
+        const metrics = (0, advisory_report_1.buildAdvisoryMetricsData)(backend, { limit });
+        return {
+            count: metrics.length,
+            metrics,
+            generated_at: new Date().toISOString(),
+        };
+    }
+    finally {
+        backend.close();
+    }
+}
+function cmAdvisoryHandoff(args) {
+    const backend = (0, storage_backend_1.getBackend)(PROJECT_PATH);
+    backend.initialize();
+    try {
+        return (0, advisory_handoff_1.buildAdvisoryHandoff)(backend, {
+            consumer: args.consumer,
+            analysisId: args.analysis_id,
+            skill: args.skill,
+            searchLimit: args.limit,
+        });
+    }
+    finally {
+        backend.close();
+    }
+}
 // ─── Tool Registry ─────────────────────────────────────────────────────────────
 const TOOLS = [
     {
@@ -297,6 +431,53 @@ const TOOLS = [
             },
         },
     },
+    {
+        name: 'cm_advisory_report',
+        description: 'Return recent advisory analyses as structured JSON for agent consumption.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: { type: 'number', description: 'Max analyses to return (default: 10)' },
+            },
+        },
+    },
+    {
+        name: 'cm_advisory_metrics',
+        description: 'Return aggregated skill metrics and quality weights as structured JSON.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: { type: 'number', description: 'Max skills to return (default: 10)' },
+            },
+        },
+    },
+    {
+        name: 'cm_advisory_handoff',
+        description: 'Build a structured advisory handoff for cm-skill-health or cm-skill-evolution.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                consumer: {
+                    type: 'string',
+                    enum: ['cm-skill-health', 'cm-skill-evolution'],
+                    description: 'Which self-healing skill should consume the handoff',
+                },
+                analysis_id: {
+                    type: 'string',
+                    description: 'Optional analysis id prefix (defaults to latest advisory analysis)',
+                },
+                skill: {
+                    type: 'string',
+                    description: 'Optional skill override when the target skill should be forced',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'How many recent analyses to search while resolving analysis_id (default: 50)',
+                },
+            },
+            required: ['consumer'],
+        },
+    },
     {
         name: 'cm_plan',
         description: 'Sprint + context bus snapshot: pipeline state, next skill hint, artifact paths.',
@@ -342,6 +523,44 @@ const TOOLS = [
             required: ['query'],
         },
     },
+    {
+        name: 'cm_memory_write',
+        description: 'Write a new memory/learning to persistent storage. Use to save knowledge, decisions, preferences, or patterns for future sessions.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                content: { type: 'string', description: 'What to remember (the memory content)' },
+                scope: {
+                    type: 'string',
+                    enum: ['session', 'project', 'global'],
+                    description: 'Memory scope: session=30d, project=90d, global=365d (default: project)',
+                },
+                category: {
+                    type: 'string',
+                    enum: ['code_pattern', 'arch_decision', 'bug_fix', 'user_pref', 'context'],
+                    description: 'Category (auto-detected from content if omitted)',
+                },
+                ttl_days: { type: 'number', description: 'Override TTL in days' },
+                importance: {
+                    type: 'string',
+                    enum: ['low', 'medium', 'high'],
+                    description: 'Importance level (default: medium)',
+                },
+            },
+            required: ['content'],
+        },
+    },
+    {
+        name: 'cm_natural',
+        description: 'Natural language memory interface. Understands "remember that...", "forget about...", "what did we learn about...", "find...". Routes to appropriate memory operation automatically.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                text: { type: 'string', description: 'Freeform natural language instruction or question' },
+            },
+            required: ['text'],
+        },
+    },
 ];
 // ─── MCP stdio protocol (JSON-RPC 2.0, Content-Length framing) ───────────────
 function sendMessage(msg) {
@@ -391,6 +610,12 @@ function handleRequest(msg) {
                     result = cmMemoryDecay(a);
                 else if (name === 'cm_index_refresh')
                     result = cmIndexRefresh(a);
+                else if (name === 'cm_advisory_report')
+                    result = cmAdvisoryReport(a);
+                else if (name === 'cm_advisory_metrics')
+                    result = cmAdvisoryMetrics(a);
+                else if (name === 'cm_advisory_handoff')
+                    result = cmAdvisoryHandoff(a);
                 else if (name === 'cm_plan')
                     result = (0, mcp_skills_tools_1.cmPlanTool)(PROJECT_PATH);
                 else if (name === 'cm_review')
@@ -403,6 +628,10 @@ function handleRequest(msg) {
                     result = (0, mcp_skills_tools_1.cmSearchTool)(PROJECT_PATH, a);
                 else if (name === 'cm_memory_query')
                     result = (0, mcp_skills_tools_1.cmMemoryQueryTool)(PROJECT_PATH, a);
+                else if (name === 'cm_memory_write')
+                    result = cmMemoryWrite(a);
+                else if (name === 'cm_natural')
+                    result = cmNatural(a);
                 else
                     throw new Error(`Unknown tool: ${name}`);
                 respond(id, {

package/dist/middleware/metrics.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.incMetric = incMetric;
+exports.setMetric = setMetric;
+exports.metricsHandler = metricsHandler;
+const metrics = {
+    cm_tasks_running: 0,
+    cm_dispatch_total: 0,
+    cm_dispatch_duration_seconds_sum: 0,
+    cm_dispatch_duration_seconds_count: 0,
+    cm_backend_errors_total: 0,
+    cm_requests_total: 0,
+};
+function incMetric(name, value = 1) {
+    if (name in metrics) {
+        metrics[name] += value;
+    }
+}
+function setMetric(name, value) {
+    metrics[name] = value;
+}
+function metricsHandler(_req, res) {
+    let output = '';
+    for (const [key, value] of Object.entries(metrics)) {
+        output += `# TYPE ${key} counter\n`;
+        output += `${key} ${value}\n`;
+    }
+    res.setHeader('Content-Type', 'text/plain; version=0.0.4');
+    res.send(output);
+}

package/dist/middleware/security-headers.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.securityHeaders = securityHeaders;
+function securityHeaders() {
+    return (_req, res, next) => {
+        res.setHeader('X-Content-Type-Options', 'nosniff');
+        res.setHeader('X-Frame-Options', 'DENY');
+        res.setHeader('X-XSS-Protection', '1; mode=block');
+        res.setHeader('Referrer-Policy', 'strict-origin-when-cross-origin');
+        res.setHeader('Permissions-Policy', 'camera=(), microphone=(), geolocation=()');
+        res.setHeader('Content-Security-Policy', "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self';");
+        next();
+    };
+}

package/dist/realtime/event-bus.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventBus = exports.EventBus = void 0;
+const events_1 = require("events");
+class EventBus extends events_1.EventEmitter {
+    emit(event, data) {
+        return super.emit(event, data);
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    off(event, listener) {
+        return super.off(event, listener);
+    }
+    emitTask(event) {
+        this.emit('task', event);
+        this.emit(event.type, event);
+    }
+    emitActivity(event) {
+        this.emit('activity', event);
+        this.emit(event.type, event);
+    }
+    emitAgent(event) {
+        this.emit('agent', event);
+        this.emit(event.type, event);
+    }
+}
+exports.EventBus = EventBus;
+exports.eventBus = new EventBus();

package/dist/realtime/ws-hub.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.broadcastToProject = broadcastToProject;
+exports.broadcastAll = broadcastAll;
+exports.initWsHub = initWsHub;
+const ws_1 = require("ws");
+const event_bus_1 = require("./event-bus");
+const HEARTBEAT_INTERVAL = 15000;
+const MAX_BUFFER = 100;
+const clients = new Set();
+function send(client, event) {
+    if (client.ws.readyState !== ws_1.WebSocket.OPEN)
+        return;
+    client.buffer.push(event);
+    if (client.buffer.length > MAX_BUFFER) {
+        client.buffer.shift();
+    }
+    client.ws.send(JSON.stringify(event));
+}
+function broadcastToProject(projectId, event) {
+    for (const client of clients) {
+        if (client.projectId === projectId) {
+            send(client, event);
+        }
+    }
+}
+function broadcastAll(event) {
+    for (const client of clients) {
+        send(client, event);
+    }
+}
+function initWsHub(server) {
+    const wss = new ws_1.WebSocketServer({ server, path: '/ws' });
+    wss.on('connection', (ws) => {
+        const client = { ws, buffer: [], alive: true };
+        clients.add(client);
+        ws.on('message', (raw) => {
+            let msg;
+            try {
+                msg = JSON.parse(raw.toString());
+            }
+            catch (_a) {
+                return;
+            }
+            if (msg.action === 'subscribe' && msg.projectId) {
+                client.projectId = msg.projectId;
+                ws.send(JSON.stringify({ type: 'subscribed', projectId: msg.projectId }));
+            }
+            else if (msg.action === 'unsubscribe') {
+                client.projectId = undefined;
+                ws.send(JSON.stringify({ type: 'unsubscribed' }));
+            }
+        });
+        ws.on('pong', () => {
+            client.alive = true;
+        });
+        ws.on('close', () => {
+            clients.delete(client);
+        });
+        ws.on('error', () => {
+            clients.delete(client);
+        });
+    });
+    const heartbeat = setInterval(() => {
+        for (const client of clients) {
+            if (!client.alive) {
+                client.ws.terminate();
+                clients.delete(client);
+                continue;
+            }
+            client.alive = false;
+            client.ws.ping();
+        }
+    }, HEARTBEAT_INTERVAL);
+    wss.on('close', () => {
+        clearInterval(heartbeat);
+    });
+    event_bus_1.eventBus.on('task', (event) => {
+        if ('projectId' in event) {
+            broadcastToProject(event.projectId, event);
+        }
+    });
+    event_bus_1.eventBus.on('activity', (event) => {
+        if ('activity' in event && event.activity.projectId) {
+            broadcastToProject(event.activity.projectId, event);
+        }
+    });
+    event_bus_1.eventBus.on('agent', (event) => {
+        broadcastAll(event);
+    });
+}

package/dist/schemas/task-schema.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProjectSchema = exports.autoSyncSchema = exports.updateTaskSchema = exports.createTaskSchema = void 0;
+exports.createTaskSchema = {
+    type: 'object',
+    required: ['projectId', 'title'],
+    properties: {
+        projectId: { type: 'string', minLength: 1 },
+        title: { type: 'string', minLength: 1 },
+        description: { type: 'string' },
+        column: { type: 'string', enum: ['backlog', 'in-progress', 'review', 'done'] },
+        priority: { type: 'string', enum: ['low', 'medium', 'high', 'urgent'] },
+        agent: { type: 'string' },
+        skill: { type: 'string' },
+    },
+    additionalProperties: false,
+};
+exports.updateTaskSchema = {
+    type: 'object',
+    properties: {
+        title: { type: 'string', minLength: 1 },
+        description: { type: 'string' },
+        priority: { type: 'string', enum: ['low', 'medium', 'high', 'urgent'] },
+    },
+    additionalProperties: false,
+    minProperties: 1,
+};
+exports.autoSyncSchema = {
+    type: 'object',
+    required: ['conversationId', 'title'],
+    properties: {
+        conversationId: { type: 'string', minLength: 1 },
+        title: { type: 'string', minLength: 1 },
+        status: { type: 'string' },
+        column: { type: 'string', enum: ['backlog', 'in-progress', 'review', 'done'] },
+    },
+    additionalProperties: true,
+};
+exports.createProjectSchema = {
+    type: 'object',
+    required: ['name'],
+    properties: {
+        name: { type: 'string', minLength: 1 },
+        path: { type: 'string' },
+        agents: { type: 'array', items: { type: 'string' } },
+    },
+    additionalProperties: false,
+};

package/dist/schemas/validate.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBody = validateBody;
+const ajv_1 = __importDefault(require("ajv"));
+const ajv = new ajv_1.default();
+function validateBody(schema) {
+    const validate = ajv.compile(schema);
+    return (req, res, next) => {
+        if (!validate(req.body)) {
+            res.status(400).json({ error: 'Validation failed', details: validate.errors });
+            return;
+        }
+        next();
+    };
+}

package/dist/skill-chain.js

@@ -4,6 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.matchChain = matchChain;
+exports.scoreStepRelevance = scoreStepRelevance;
+exports.selectTopSkills = selectTopSkills;
 exports.listChains = listChains;
 exports.findChain = findChain;
 exports.createChainExecution = createChainExecution;
@@ -17,6 +19,8 @@ exports.getCurrentSkill = getCurrentSkill;
 const crypto_1 = __importDefault(require("crypto"));
 const builtin_1 = require("./chains/builtin");
 const context_bus_1 = require("./context-bus");
+const execution_analyzer_1 = require("./execution-analyzer");
+const storage_backend_1 = require("./storage-backend");
 // ─── Chain Matching ─────────────────────────────────────────────────────────
 // TRIZ #10: Preliminary Action — analyze task BEFORE dispatching
 /**
@@ -43,6 +47,53 @@ function matchChain(taskTitle) {
     }
     return bestMatch;
 }
+// ─── Intelligent Skill Selection (SkillsBench: 2-3 skills = +18.6pp) ────────
+// TRIZ #1: Segmentation — select only relevant sub-components
+/**
+ * Score a single chain step's relevance to the given task title.
+ * Mandatory steps (optional=false, condition='always') receive a +100 base bonus
+ * to ensure they are always prioritised over optional ones.
+ */
+function scoreStepRelevance(taskTitle, step) {
+    const taskTokens = new Set(taskTitle.toLowerCase().split(/\W+/).filter(t => t.length > 2));
+    const descTokens = step.description.toLowerCase().split(/\W+/).filter(t => t.length > 2);
+    const overlap = descTokens.filter(t => taskTokens.has(t)).length;
+    const mandatoryBonus = (!step.optional && step.condition === 'always') ? 100 : 0;
+    return overlap + mandatoryBonus;
+}
+/**
+ * Select the most relevant skills for a task, capped at maxSkills.
+ *
+ * Rules:
+ * - Mandatory steps (optional=false AND condition='always') are ALWAYS included,
+ *   even if their count exceeds maxSkills (safety > optimisation).
+ * - Remaining slots are filled with the highest-scoring optional steps.
+ * - If mandatory count > maxSkills, a performance warning is emitted.
+ */
+function selectTopSkills(taskTitle, chain, maxSkills = 3, options = {}) {
+    const mandatory = chain.steps.filter(s => !s.optional && s.condition === 'always');
+    const optional = chain.steps.filter(s => s.optional || s.condition !== 'always');
+    if (mandatory.length > maxSkills) {
+        process.stderr.write(`[CodyMaster] Chain "${chain.name}" has ${mandatory.length} mandatory steps (>${maxSkills}). ` +
+            `Consider splitting this chain. (SkillsBench: 2-3 skills = +18.6pp)\n`);
+        return mandatory; // include all mandatory — cannot safely drop them
+    }
+    const remaining = maxSkills - mandatory.length;
+    const scoredOptional = optional
+        .map(step => {
+        var _a, _b;
+        const relevance = scoreStepRelevance(taskTitle, step);
+        const metric = (_b = (_a = options.getSkillMetric) === null || _a === void 0 ? void 0 : _a.call(options, step.skill)) !== null && _b !== void 0 ? _b : null;
+        const quality = (0, execution_analyzer_1.qualityWeight)(metric);
+        return { step, score: relevance + quality, relevance, quality };
+    })
+        .sort((a, b) => b.score - a.score)
+        .slice(0, remaining)
+        .map(({ step }) => step);
+    // Preserve original chain order
+    const selected = new Set([...mandatory, ...scoredOptional]);
+    return chain.steps.filter(s => selected.has(s));
+}
 /**
  * List all available chains (built-in + user-defined in the future).
  */
@@ -62,7 +113,18 @@ function findChain(chainId) {
  */
 function createChainExecution(chain, projectId, taskTitle, agent, projectPath) {
     const now = new Date().toISOString();
-    const steps = chain.steps.map((step, index) => ({
+    const backend = projectPath ? (0, storage_backend_1.getBackend)(projectPath) : undefined;
+    let selectedSteps;
+    backend === null || backend === void 0 ? void 0 : backend.initialize();
+    try {
+        selectedSteps = selectTopSkills(taskTitle, chain, 3, {
+            getSkillMetric: backend ? (skill) => backend.getSkillMetric(skill) : undefined,
+        });
+    }
+    finally {
+        backend === null || backend === void 0 ? void 0 : backend.close();
+    }
+    const steps = selectedSteps.map((step, index) => ({
         index,
         skill: step.skill,
         description: step.description,