modular-studio 1.0.6 → 1.1.0

package/dist-server/server/routes/connectors/slack.js

@@ -0,0 +1,153 @@
+/**
+ * Slack Connector — Channels + Messages
+ * Issue #92
+ */
+import { Router } from 'express';
+import { rateLimitedFetch, connectorError, getApiKey, formatTimestamp } from './shared.js';
+const router = Router();
+const sessionKeys = new Map();
+const SLACK_API = 'https://slack.com/api';
+function slackHeaders(token) {
+    return { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' };
+}
+// ── Test ──
+router.post('/test', async (req, res) => {
+    const { apiKey } = req.body;
+    if (!apiKey) {
+        res.status(400).json({ status: 'error', error: 'Missing bot token' });
+        return;
+    }
+    try {
+        const resp = await rateLimitedFetch(`${SLACK_API}/auth.test`, {
+            method: 'POST', headers: slackHeaders(apiKey),
+        });
+        const data = await resp.json();
+        if (!data.ok) {
+            res.status(401).json({ status: 'error', error: data.error ?? 'Auth failed' });
+            return;
+        }
+        sessionKeys.set('slack', apiKey);
+        res.json({ status: 'ok', data: { user: data.user, team: data.team } });
+    }
+    catch (err) {
+        connectorError(res, 'Slack', err);
+    }
+});
+// ── List Channels ──
+router.post('/channels', async (req, res) => {
+    const body = req.body;
+    const token = getApiKey('slack', body, sessionKeys);
+    if (!token) {
+        res.status(401).json({ status: 'error', error: 'No Slack token.' });
+        return;
+    }
+    try {
+        const resp = await rateLimitedFetch(`${SLACK_API}/conversations.list?types=public_channel,private_channel&limit=200`, { headers: slackHeaders(token) });
+        const data = await resp.json();
+        if (!data.ok)
+            throw new Error(data.error ?? 'Failed to list channels');
+        res.json({
+            status: 'ok',
+            data: (data.channels ?? []).map((ch) => ({
+                id: ch.id,
+                name: ch.name,
+                topic: ch.topic?.value ?? '',
+                memberCount: ch.num_members ?? 0,
+                isPrivate: ch.is_private ?? false,
+            })),
+        });
+    }
+    catch (err) {
+        connectorError(res, 'Slack', err);
+    }
+});
+// ── Fetch Messages ──
+router.post('/fetch', async (req, res) => {
+    const body = req.body;
+    const token = getApiKey('slack', body, sessionKeys);
+    if (!token) {
+        res.status(401).json({ status: 'error', error: 'No Slack token.' });
+        return;
+    }
+    const channelId = body.channelId;
+    const limit = Math.min(body.limit ?? 100, 200);
+    if (!channelId) {
+        res.status(400).json({ status: 'error', error: 'channelId required' });
+        return;
+    }
+    try {
+        const params = new URLSearchParams({ channel: channelId, limit: String(limit) });
+        if (body.oldest)
+            params.set('oldest', String(body.oldest));
+        const resp = await rateLimitedFetch(`${SLACK_API}/conversations.history?${params}`, { headers: slackHeaders(token) });
+        const data = await resp.json();
+        if (!data.ok)
+            throw new Error(data.error ?? 'Failed to fetch messages');
+        const messages = (data.messages ?? []).reverse(); // chronological
+        // Resolve user names (batch)
+        const userIds = [...new Set(messages.map((m) => m.user).filter(Boolean))];
+        const userNames = new Map();
+        for (const uid of userIds.slice(0, 50)) {
+            try {
+                const uResp = await rateLimitedFetch(`${SLACK_API}/users.info?user=${uid}`, { headers: slackHeaders(token) });
+                const uData = await uResp.json();
+                if (uData.ok && uData.user) {
+                    userNames.set(uid, uData.user.real_name ?? uData.user.name ?? uid);
+                }
+            }
+            catch { /* skip */ }
+        }
+        const items = messages.map((m) => ({
+            user: userNames.get(m.user) ?? m.user ?? 'bot',
+            text: m.text ?? '',
+            timestamp: m.ts,
+            threadTs: m.thread_ts,
+            replyCount: m.reply_count ?? 0,
+        }));
+        const markdown = items.map((m) => {
+            const ts = formatTimestamp(parseFloat(m.timestamp) * 1000);
+            const thread = m.replyCount > 0 ? ` (${m.replyCount} replies)` : '';
+            return `**${m.user}** (${ts})${thread}:\n${m.text}`;
+        }).join('\n\n');
+        res.json({
+            status: 'ok',
+            data: { items, markdown, count: items.length, tokens: Math.ceil(markdown.length / 4) },
+        });
+    }
+    catch (err) {
+        connectorError(res, 'Slack', err);
+    }
+});
+// ── Search ──
+router.post('/search', async (req, res) => {
+    const body = req.body;
+    const token = getApiKey('slack', body, sessionKeys);
+    if (!token) {
+        res.status(401).json({ status: 'error', error: 'No Slack token.' });
+        return;
+    }
+    const query = body.query;
+    if (!query) {
+        res.status(400).json({ status: 'error', error: 'query required' });
+        return;
+    }
+    try {
+        const resp = await rateLimitedFetch(`${SLACK_API}/search.messages?query=${encodeURIComponent(query)}&count=20`, { headers: slackHeaders(token) });
+        const data = await resp.json();
+        if (!data.ok)
+            throw new Error(data.error ?? 'Search failed');
+        res.json({
+            status: 'ok',
+            data: (data.messages?.matches ?? []).map((m) => ({
+                text: m.text?.slice(0, 200),
+                user: m.user,
+                channel: m.channel?.name,
+                timestamp: m.ts,
+            })),
+        });
+    }
+    catch (err) {
+        connectorError(res, 'Slack', err);
+    }
+});
+export default router;

package/dist-server/server/routes/cost.d.ts

@@ -0,0 +1,3 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;
+//# sourceMappingURL=cost.d.ts.map

package/dist-server/server/routes/cost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cost.d.ts","sourceRoot":"","sources":["../../../server/routes/cost.ts"],"names":[],"mappings":"AAYA,QAAA,MAAM,MAAM,4CAAW,CAAC;AA2GxB,eAAe,MAAM,CAAC"}

package/dist-server/server/routes/cost.js

@@ -0,0 +1,113 @@
+import { Router } from 'express';
+import { z } from 'zod';
+import { saveCostRecord, getCostHistory, getTotalSpent, getBudgetConfig, setBudgetConfig } from '../services/sqliteStore.js';
+function classifyModel(modelName) {
+    const n = modelName.toLowerCase();
+    if (/haiku|4o-mini|mini|flash|nano/.test(n))
+        return 'haiku';
+    if (/opus|gpt-4\.5|gemini-ultra|r1/.test(n))
+        return 'opus';
+    return 'sonnet';
+}
+const router = Router();
+/* ── GET /:agentId/history ── */
+router.get('/:agentId/history', async (req, res) => {
+    const agentId = String(req.params['agentId'] ?? '');
+    const limit = Math.min(parseInt(String(req.query['limit'] ?? '50'), 10) || 50, 200);
+    try {
+        const records = await getCostHistory(agentId, limit);
+        res.json({ status: 'ok', data: records });
+    }
+    catch (err) {
+        res.status(500).json({ status: 'error', error: err instanceof Error ? err.message : String(err) });
+    }
+});
+/* ── GET /:agentId/summary ── */
+router.get('/:agentId/summary', async (req, res) => {
+    const agentId = String(req.params['agentId'] ?? '');
+    try {
+        const records = await getCostHistory(agentId, 200);
+        const totalSpent = records.reduce((s, r) => s + r.costUsd, 0);
+        const runCount = records.length;
+        const avgCostPerRun = runCount > 0 ? totalSpent / runCount : 0;
+        // Model breakdown
+        const modelBreakdown = {};
+        for (const r of records) {
+            const tier = classifyModel(r.model);
+            modelBreakdown[tier] = modelBreakdown[tier] ?? { count: 0, cost: 0 };
+            modelBreakdown[tier].count += 1;
+            modelBreakdown[tier].cost += r.costUsd;
+        }
+        // Cache hit % (cached tokens / total input tokens)
+        const totalInput = records.reduce((s, r) => s + r.inputTokens, 0);
+        const totalCached = records.reduce((s, r) => s + r.cachedTokens, 0);
+        const cacheHitPct = totalInput > 0 ? totalCached / totalInput : 0;
+        res.json({ status: 'ok', data: { totalSpent, runCount, avgCostPerRun, modelBreakdown, cacheHitPct } });
+    }
+    catch (err) {
+        res.status(500).json({ status: 'error', error: err instanceof Error ? err.message : String(err) });
+    }
+});
+/* ── GET /:agentId/budget ── */
+router.get('/:agentId/budget', async (req, res) => {
+    const agentId = String(req.params['agentId'] ?? '');
+    try {
+        const [config, totalSpent] = await Promise.all([getBudgetConfig(agentId), getTotalSpent(agentId)]);
+        res.json({ status: 'ok', data: { ...config, totalSpent } });
+    }
+    catch (err) {
+        res.status(500).json({ status: 'error', error: err instanceof Error ? err.message : String(err) });
+    }
+});
+/* ── PUT /:agentId/budget ── */
+router.put('/:agentId/budget', async (req, res) => {
+    const agentId = String(req.params['agentId'] ?? '');
+    const { budgetLimit, preferredModel, maxModel } = req.body;
+    try {
+        await setBudgetConfig(agentId, { budgetLimit, preferredModel, maxModel });
+        const config = await getBudgetConfig(agentId);
+        res.json({ status: 'ok', data: config });
+    }
+    catch (err) {
+        res.status(500).json({ status: 'error', error: err instanceof Error ? err.message : String(err) });
+    }
+});
+const recordSchema = z.object({
+    model: z.string().min(1),
+    inputTokens: z.number().int().nonnegative(),
+    outputTokens: z.number().int().nonnegative(),
+    costUsd: z.number().nonnegative(),
+    cachedTokens: z.number().int().nonnegative().optional(),
+});
+const agentIdSchema = z.string().min(1);
+/* ── POST /:agentId/record ── */
+router.post('/:agentId/record', async (req, res) => {
+    const agentIdParsed = agentIdSchema.safeParse(req.params['agentId']);
+    if (!agentIdParsed.success) {
+        res.status(400).json({ status: 'error', error: 'agentId is required' });
+        return;
+    }
+    const agentId = agentIdParsed.data;
+    const bodyParsed = recordSchema.safeParse(req.body);
+    if (!bodyParsed.success) {
+        res.status(400).json({ status: 'error', error: bodyParsed.error.issues.map(i => i.message).join(', ') });
+        return;
+    }
+    const { model, inputTokens, outputTokens, costUsd, cachedTokens } = bodyParsed.data;
+    try {
+        await saveCostRecord({
+            agentId,
+            timestamp: new Date().toISOString(),
+            model,
+            inputTokens,
+            outputTokens,
+            costUsd,
+            cachedTokens: cachedTokens ?? 0,
+        });
+        res.json({ status: 'ok' });
+    }
+    catch (err) {
+        res.status(500).json({ status: 'error', error: err instanceof Error ? err.message : String(err) });
+    }
+});
+export default router;

package/dist-server/server/routes/graph.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Context Graph API — Server Routes
+ *
+ * POST /api/graph/scan    — Full or incremental scan
+ * POST /api/graph/query   — Query → entry points → traverse → pack
+ * GET  /api/graph/status  — Graph stats
+ * GET  /api/graph/file/:id — File detail with symbols + relations
+ */
+declare const router: import("express-serve-static-core").Router;
+export default router;
+//# sourceMappingURL=graph.d.ts.map

package/dist-server/server/routes/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../../server/routes/graph.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,QAAA,MAAM,MAAM,4CAAW,CAAC;AAyNxB,eAAe,MAAM,CAAC"}

package/dist-server/server/routes/graph.js

@@ -0,0 +1,213 @@
+/**
+ * Context Graph API — Server Routes
+ *
+ * POST /api/graph/scan    — Full or incremental scan
+ * POST /api/graph/query   — Query → entry points → traverse → pack
+ * GET  /api/graph/status  — Graph stats
+ * GET  /api/graph/file/:id — File detail with symbols + relations
+ */
+import { Router } from 'express';
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+const router = Router();
+// Lazy-init engine (avoid circular imports at module load)
+let engine = null;
+async function getEngine() {
+    if (!engine) {
+        const { ContextGraphEngine } = await import('../../src/graph/index.js');
+        engine = new ContextGraphEngine();
+    }
+    return engine;
+}
+/**
+ * Recursively list files in a directory.
+ */
+function listFiles(dir, rootDir) {
+    const results = [];
+    const IGNORE = /node_modules|\.git|dist|build|\.next|coverage|\.cache/;
+    const MAX_FILE_SIZE = 500_000; // 500KB max per file
+    try {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            const fullPath = join(dir, entry.name);
+            if (IGNORE.test(entry.name))
+                continue;
+            if (entry.isDirectory()) {
+                results.push(...listFiles(fullPath, rootDir));
+            }
+            else {
+                const ext = entry.name.split('.').pop()?.toLowerCase() ?? '';
+                if (!['ts', 'tsx', 'js', 'jsx', 'py', 'md', 'mdx', 'yml', 'yaml', 'json'].includes(ext))
+                    continue;
+                try {
+                    const stat = statSync(fullPath);
+                    if (stat.size > MAX_FILE_SIZE)
+                        continue;
+                    const content = readFileSync(fullPath, 'utf-8');
+                    results.push({
+                        path: relative(rootDir, fullPath).replace(/\\/g, '/'),
+                        content,
+                        mtime: stat.mtimeMs,
+                    });
+                }
+                catch { /* skip unreadable files */ }
+            }
+        }
+    }
+    catch { /* skip unreadable dirs */ }
+    return results;
+}
+// POST /api/graph/scan
+router.post('/scan', async (req, res) => {
+    const { rootPath } = req.body;
+    if (!rootPath) {
+        res.status(400).json({ status: 'error', error: 'rootPath is required' });
+        return;
+    }
+    // Security: prevent scanning sensitive directories
+    const normalized = rootPath.replace(/\\/g, '/').toLowerCase();
+    if (normalized.includes('.ssh') || normalized.includes('.gnupg') || normalized.includes('.aws') ||
+        normalized.includes('/etc/') || normalized.includes('system32')) {
+        res.status(403).json({ status: 'error', error: 'Access denied: sensitive directory' });
+        return;
+    }
+    try {
+        const eng = await getEngine();
+        const files = listFiles(rootPath, rootPath);
+        const result = eng.scan(rootPath, files);
+        res.json({ status: 'ok', data: result });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        res.status(500).json({ status: 'error', error: msg });
+    }
+});
+// POST /api/graph/scan-sources — scan from pre-loaded content (any source)
+router.post('/scan-sources', async (req, res) => {
+    const { sources } = req.body;
+    if (!sources || !Array.isArray(sources) || sources.length === 0) {
+        res.status(400).json({ status: 'error', error: 'sources array is required' });
+        return;
+    }
+    try {
+        const eng = await getEngine();
+        const result = eng.scan('(mixed sources)', sources);
+        res.json({ status: 'ok', data: result });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        res.status(500).json({ status: 'error', error: msg });
+    }
+});
+// POST /api/graph/query
+router.post('/query', async (req, res) => {
+    const { query, tokenBudget, taskType } = req.body;
+    if (!query?.trim()) {
+        res.status(400).json({ status: 'error', error: 'query is required' });
+        return;
+    }
+    try {
+        const eng = await getEngine();
+        const packed = eng.query(query, tokenBudget ?? 100000, taskType);
+        const graph = eng.getGraph();
+        // Find entry points for the response
+        const { resolveEntryPoints } = await import('../../src/graph/resolver.js');
+        const entryPoints = resolveEntryPoints(query, graph);
+        res.json({
+            status: 'ok',
+            data: {
+                items: packed.items.map((it) => ({
+                    path: it.file.path,
+                    language: it.file.language,
+                    depth: it.depth,
+                    tokens: it.tokens,
+                    relevance: it.relevance,
+                    symbols: it.file.symbols.map((s) => ({ name: s.name, kind: s.kind, exported: s.isExported })),
+                })),
+                totalTokens: packed.totalTokens,
+                budgetUtilization: packed.budgetUtilization,
+                entryPoints: entryPoints.slice(0, 10).map((ep) => ({
+                    fileId: ep.fileId,
+                    symbol: ep.symbolName,
+                    confidence: ep.confidence,
+                    reason: ep.reason,
+                })),
+            },
+        });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        res.status(500).json({ status: 'error', error: msg });
+    }
+});
+// GET /api/graph/data — full graph (nodes + relations) for visualization
+router.get('/data', async (_req, res) => {
+    try {
+        const eng = await getEngine();
+        const graph = eng.getGraph();
+        const nodes = Array.from(graph.nodes.values());
+        const relations = graph.relations;
+        res.json({
+            status: 'ok',
+            data: { nodes, relations },
+        });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        res.status(500).json({ status: 'error', error: msg });
+    }
+});
+// GET /api/graph/status
+router.get('/status', async (_req, res) => {
+    try {
+        const eng = await getEngine();
+        const stats = eng.getStats();
+        res.json({ status: 'ok', data: stats });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        res.status(500).json({ status: 'error', error: msg });
+    }
+});
+// GET /api/graph/file/:id
+router.get('/file/:id', async (req, res) => {
+    try {
+        const eng = await getEngine();
+        const db = eng.getDB();
+        const node = db.getNode(req.params.id);
+        if (!node) {
+            res.status(404).json({ status: 'error', error: 'File not found' });
+            return;
+        }
+        const outgoing = db.getOutgoing(node.id);
+        const incoming = db.getIncoming(node.id);
+        res.json({
+            status: 'ok',
+            data: {
+                id: node.id,
+                path: node.path,
+                language: node.language,
+                tokens: node.tokens,
+                symbols: node.symbols,
+                outgoing: outgoing.map((r) => ({
+                    targetFile: r.targetFile,
+                    targetPath: db.getNode(r.targetFile)?.path,
+                    kind: r.kind,
+                    weight: r.weight,
+                    targetSymbol: r.targetSymbol,
+                })),
+                incoming: incoming.map((r) => ({
+                    sourceFile: r.sourceFile,
+                    sourcePath: db.getNode(r.sourceFile)?.path,
+                    kind: r.kind,
+                    weight: r.weight,
+                    sourceSymbol: r.sourceSymbol,
+                })),
+            },
+        });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        res.status(500).json({ status: 'error', error: msg });
+    }
+});
+export default router;

package/dist-server/server/routes/lessons.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lessons.d.ts","sourceRoot":"","sources":["../../../server/routes/lessons.ts"],"names":[],"mappings":"AAOA,QAAA,MAAM,MAAM,4CAAW,CAAC;AA8DxB,eAAe,MAAM,CAAC"}
+{"version":3,"file":"lessons.d.ts","sourceRoot":"","sources":["../../../server/routes/lessons.ts"],"names":[],"mappings":"AAQA,QAAA,MAAM,MAAM,4CAAW,CAAC;AAiLxB,eAAe,MAAM,CAAC"}

package/dist-server/server/routes/lessons.js

@@ -1,17 +1,106 @@
 import { Router } from 'express';
+import { z } from 'zod';
 import { readConfig } from '../config.js';
 import { detectCorrection } from '../services/correctionDetector.js';
 import { extractLesson } from '../services/lessonExtractor.js';
+import { saveInstinct, getInstincts, updateConfidence, deleteInstinct } from '../services/sqliteStore.js';
 const router = Router();
 function genId() {
     return `lesson-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
+/** GET /api/lessons/:agentId — all instincts for an agent */
+router.get('/:agentId', async (req, res) => {
+    try {
+        const instincts = await getInstincts(String(req.params['agentId'] ?? ''));
+        res.json({ instincts });
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Failed to fetch instincts' });
+    }
+});
+/** GET /api/lessons/:agentId/active — only instincts with confidence >= 0.5 */
+router.get('/:agentId/active', async (req, res) => {
+    try {
+        const all = await getInstincts(String(req.params['agentId'] ?? ''));
+        const active = all.filter((i) => i.confidence >= 0.5 && i.status === 'approved');
+        res.json({ instincts: active });
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Failed to fetch active instincts' });
+    }
+});
+/** PUT /api/lessons/:id/confidence — bump or set confidence */
+router.put('/:id/confidence', async (req, res) => {
+    const { confidence } = req.body;
+    if (typeof confidence !== 'number' || confidence < 0 || confidence > 1) {
+        res.status(400).json({ error: 'confidence must be a number 0–1' });
+        return;
+    }
+    try {
+        await updateConfidence(String(req.params['id'] ?? ''), confidence);
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Failed to update confidence' });
+    }
+});
+/** DELETE /api/lessons/:id — delete an instinct */
+router.delete('/:id', async (req, res) => {
+    try {
+        await deleteInstinct(String(req.params['id'] ?? ''));
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Failed to delete instinct' });
+    }
+});
+/** POST /api/lessons/sync-batch — migrate lessons from localStorage to SQLite (dedup by id) */
+router.post('/sync-batch', async (req, res) => {
+    const { lessons } = req.body;
+    if (!Array.isArray(lessons)) {
+        res.status(400).json({ error: 'lessons must be an array' });
+        return;
+    }
+    let saved = 0;
+    for (const l of lessons) {
+        if (!l.id || !l.agentId)
+            continue;
+        try {
+            const now = new Date().toISOString();
+            await saveInstinct({
+                id: l.id,
+                agentId: l.agentId,
+                trigger: (l.sourceUserMessage ?? '').slice(0, 500),
+                action: l.rule ?? '',
+                confidence: typeof l.confidence === 'number' ? l.confidence : 0.30,
+                domain: l.domain ?? 'general',
+                scope: 'agent',
+                evidence: Array.isArray(l.evidence) ? JSON.stringify(l.evidence) : '[]',
+                status: l.status ?? 'pending',
+                createdAt: l.createdAt ? new Date(l.createdAt).toISOString() : now,
+                lastSeenAt: l.lastSeenAt ?? now,
+            });
+            saved++;
+        }
+        catch { /* skip individual failures */ }
+    }
+    res.json({ ok: true, saved });
+});
+const extractSchema = z.object({
+    userMessage: z.string().min(1),
+    previousAssistant: z.string().optional(),
+    providerId: z.string().min(1),
+    model: z.string().min(1),
+    agentId: z.string().optional(),
+});
+/** POST /api/lessons/extract — extract lesson from correction, save to SQLite */
 router.post('/extract', async (req, res) => {
-    const { userMessage, previousAssistant, providerId, model, agentId } = req.body;
-    if (!userMessage || !providerId || !model) {
-        res.status(400).json({ error: 'Missing required fields' });
+    const parsed = extractSchema.safeParse(req.body);
+    if (!parsed.success) {
+        res.status(400).json({ error: parsed.error.issues.map(i => i.message).join(', ') });
         return;
     }
+    const { userMessage, previousAssistant, providerId, model, agentId } = parsed.data;
     const correction = detectCorrection(userMessage, previousAssistant ?? '');
     if (!correction) {
         res.json({ lesson: null });
@@ -29,14 +118,39 @@ router.post('/extract', async (req, res) => {
             res.json({ lesson: null });
             return;
         }
+        const now = new Date().toISOString();
+        const id = genId();
+        const effectiveAgentId = agentId ?? '';
+        // Save to SQLite
+        await saveInstinct({
+            id,
+            agentId: effectiveAgentId,
+            trigger: userMessage.slice(0, 500),
+            action: extracted.rule,
+            confidence: extracted.confidence ?? 0.30,
+            domain: extracted.domain ?? 'general',
+            scope: 'agent',
+            evidence: JSON.stringify([{ type: 'correction', timestamp: now, description: 'Extracted from user correction' }]),
+            status: 'pending',
+            createdAt: now,
+            lastSeenAt: now,
+        });
         const lesson = {
+            id,
             rule: extracted.rule,
             category: extracted.category,
-            agentId: agentId ?? '',
+            domain: extracted.domain ?? 'general',
+            confidence: extracted.confidence ?? 0.30,
+            agentId: effectiveAgentId,
             sourceUserMessage: userMessage,
             sourcePreviousAssistant: previousAssistant ?? '',
+            createdAt: Date.now(),
+            appliedCount: 0,
+            status: 'pending',
+            evidence: [{ type: 'correction', timestamp: now, description: 'Extracted from user correction' }],
+            lastSeenAt: now,
         };
-        res.json({ lesson: { ...lesson, id: genId(), createdAt: Date.now(), appliedCount: 0, status: 'pending' } });
+        res.json({ lesson });
     }
     catch (err) {
         const message = err instanceof Error ? err.message : 'Extraction failed';

package/dist-server/server/routes/llm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"llm.d.ts","sourceRoot":"","sources":["../../../server/routes/llm.ts"],"names":[],"mappings":"AAKA,QAAA,MAAM,MAAM,4CAAW,CAAC;AAiSxB,eAAe,MAAM,CAAC"}
+{"version":3,"file":"llm.d.ts","sourceRoot":"","sources":["../../../server/routes/llm.ts"],"names":[],"mappings":"AAMA,QAAA,MAAM,MAAM,4CAAW,CAAC;AA2VxB,eAAe,MAAM,CAAC"}