studiograph 1.1.2 → 1.2.0-beta.1

package/dist/cli/commands/start.js

@@ -9,11 +9,30 @@ import { getModel } from '@mariozechner/pi-ai';
 import { Workspace } from '../../core/workspace.js';
 import { WorkspaceManager } from '../../core/workspace-manager.js';
 import { MemoryService } from '../../services/memory-service.js';
+import { SchemaRegistry } from '../../core/schema-registry.js';
 import { createGraphTools } from '../../agent/tools/graph-tools.js';
+import { createSyncTools } from '../../agent/tools/sync-tools.js';
+import { createFsTools } from '../../agent/tools/fs-tools.js';
+import { loadSkillIndex, buildSkillIndexPrompt, loadEagerSkills } from '../../agent/skill-loader.js';
+import { createLoadSkillTool } from '../../agent/tools/load-skill.js';
+import { loadCustomTools } from '../../agent/tools/tool-loader.js';
+import { ConnectorManager } from '../../mcp/connector-manager.js';
+import { buildConnectorRegistry, createConnectorTools } from '../../agent/tools/connector-tools.js';
 import { intro, select, text, outro, spinner } from '@clack/prompts';
 import { runPreflight } from '../../utils/preflight.js';
-import { loadUserConfig } from '../../core/user-config.js';
+import { loadUserConfig, saveUserConfig, getAnthropicCredential } from '../../core/user-config.js';
+import { notifyUpdateAvailable } from '../../utils/version-checker.js';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+import { readFileSync, existsSync } from 'fs';
+import { execSync } from 'child_process';
 import * as readline from 'readline';
+import { Markdown } from '@mariozechner/pi-tui';
+import { info, dimText, header, warn, toolRef, renderUserPrompt } from '../colors.js';
+import { box } from 'consola/utils';
+import ora from 'ora';
+import { markdownTheme } from '../theme.js';
 // Model provider configurations
 const MODEL_PROVIDERS = {
     anthropic: {
@@ -91,14 +110,14 @@ export const startCommand = new Command('start')
         return;
     }
     // Load workspace config and user config
-    const config = workspace.loadConfig();
-    const repos = workspace.getRepos();
+    const config = await workspace.loadConfig();
+    const repos = await workspace.getRepos();
     const userConfig = loadUserConfig();
     // Check if model is configured — user config takes precedence over workspace config
     let modelProvider = userConfig.model_provider || config.model_provider;
     let modelId = userConfig.model_id || config.model_id;
-    // API key: user config → workspace.json legacy field → env var (resolved below)
-    let apiKey = userConfig.api_key || config.api_key || config.anthropic_api_key;
+    // API key: user config (oauth token or api key) → workspace.json → env var (resolved below)
+    let apiKey = getAnthropicCredential(userConfig) || config.api_key;
     if (!modelProvider || !modelId) {
         // First-time setup
         intro('🎨 Studiograph Setup');
@@ -143,6 +162,27 @@ export const startCommand = new Command('start')
                 console.log(`✓ Using ${provider.envVar} from environment\n`);
                 apiKey = envKey;
             }
+            else if (modelProvider === 'anthropic') {
+                // Anthropic requires API key from console.anthropic.com
+                const keyInput = await text({
+                    message: 'Enter your Anthropic API key:',
+                    placeholder: 'sk-ant-api03-...',
+                    validate: (value) => {
+                        if (!value || value.length < 10)
+                            return 'API key seems too short';
+                    },
+                });
+                if (typeof keyInput !== 'string') {
+                    outro('Cancelled');
+                    process.exit(0);
+                }
+                apiKey = keyInput;
+                const s = spinner();
+                s.start('Saving configuration...');
+                workspace.setModelConfig(modelProvider, modelId, apiKey);
+                s.stop('Configuration saved ✓');
+                outro(`Model configured: ${provider.name} - ${modelId}\n`);
+            }
             else {
                 const keyInput = await text({
                     message: `Enter your ${provider.name} API key:`,
@@ -157,14 +197,21 @@ export const startCommand = new Command('start')
                     process.exit(0);
                 }
                 apiKey = keyInput;
+                const s = spinner();
+                s.start('Saving configuration...');
+                workspace.setModelConfig(modelProvider, modelId, apiKey);
+                s.stop('Configuration saved ✓');
+                outro(`Model configured: ${provider.name} - ${modelId}\n`);
             }
         }
-        // Save configuration
-        const s = spinner();
-        s.start('Saving configuration...');
-        workspace.setModelConfig(modelProvider, modelId, apiKey);
-        s.stop('Configuration saved ✓');
-        outro(`Model configured: ${provider.name} - ${modelId}\n`);
+        else {
+            // Save configuration (non-Anthropic or key already available)
+            const s = spinner();
+            s.start('Saving configuration...');
+            workspace.setModelConfig(modelProvider, modelId, apiKey);
+            s.stop('Configuration saved ✓');
+            outro(`Model configured: ${provider.name} - ${modelId}\n`);
+        }
     }
     // Validate we have all required config
     if (!modelProvider || !modelId) {
@@ -185,58 +232,162 @@ export const startCommand = new Command('start')
         }
     }
     // Initialize memory service
-    const memoryService = new MemoryService(process.cwd());
+    const memoryService = new MemoryService();
     const recentMemory = memoryService.loadRecentMemory();
-    // Create system prompt with memory context
-    const systemPrompt = createSystemPrompt(config.team_name, repos, recentMemory);
+    // Initialize workspace manager
+    const gitUser = { id: 'cli-user', name: config.team_name, email: 'noreply@studiograph.local' };
+    const cliUser = { id: 'cli-user', name: config.team_name, email: 'noreply@studiograph.local', role: 'admin' };
+    const workspaceManager = new WorkspaceManager(process.cwd(), config, gitUser, cliUser);
+    // Build skill index from user > workspace > bundled directories
+    const startFileDir = dirname(fileURLToPath(import.meta.url));
+    const bundledSkillsDir = join(startFileDir, '../../agent/skills');
+    const userSkillsDir = join(homedir(), '.studiograph', 'skills');
+    const workspaceSkillsDir = join(process.cwd(), '.studiograph', 'skills');
+    const skillIndex = loadSkillIndex([userSkillsDir, workspaceSkillsDir, bundledSkillsDir]);
+    // Load ALL tools: graph + sync + skill loader
+    const tools = [
+        ...createGraphTools(workspaceManager, gitUser, process.cwd()),
+        ...createSyncTools(process.cwd(), config),
+        ...createFsTools(),
+        createLoadSkillTool(skillIndex),
+    ];
+    // Create system prompt with tool reference, skills, and memory
+    const systemPrompt = createSystemPrompt(config.team_name, repos, recentMemory, config.schema_extensions, tools, skillIndex);
     // Initialize agent
     const agent = new Agent({
         getApiKey: () => apiKey,
     });
-    // Set model and system prompt
     const model = getModel(modelProvider, modelId);
     agent.setModel(model);
     agent.setSystemPrompt(systemPrompt);
-    // Load graph tools
-    const gitUser = { id: 'cli-user', name: config.team_name, email: 'noreply@studiograph.local' };
-    const cliUser = { id: 'cli-user', name: config.team_name, email: 'noreply@studiograph.local', role: 'admin' };
-    const workspaceManager = new WorkspaceManager(process.cwd(), config, gitUser, cliUser);
-    const tools = createGraphTools(workspaceManager, gitUser);
     agent.setTools(tools);
-    console.log('🎨 Studiograph agent started');
-    console.log(`📁 Workspace: ${config.team_name}`);
-    console.log(`🤖 Model: ${modelProvider}/${modelId}`);
-    console.log(`💾 Memory loaded: ${memoryService.listMemoryFiles().length} days`);
-    console.log('\nType your message and press Enter. Type "exit" to quit.\n');
+    // Load custom tools and connector tools before starting the chat loop
+    const userToolsDir = join(homedir(), '.studiograph', 'tools');
+    const workspaceToolsDir = join(process.cwd(), '.studiograph', 'tools');
+    let connectorSummary = '';
+    try {
+        const [customTools, connectorTools] = await Promise.all([
+            loadCustomTools([userToolsDir, workspaceToolsDir], { workspaceManager, gitUser }),
+            ConnectorManager.buildTools(ConnectorManager.loadConfigs()),
+        ]);
+        const extra = [...customTools];
+        // Connector tools go through a proxy registry (connector_list + connector_call)
+        // instead of registering hundreds of individual tools
+        if (connectorTools.length > 0) {
+            const registry = buildConnectorRegistry(connectorTools);
+            extra.push(...createConnectorTools(registry));
+            connectorSummary = [...registry.connectors.keys()].join(', ');
+        }
+        if (extra.length > 0) {
+            const existing = agent.state.tools;
+            agent.setTools([...existing, ...extra]);
+        }
+    }
+    catch (err) {
+        // Non-fatal — agent starts with core tools only
+    }
+    // Search index: first-run setup and staleness check
+    await initSearchIndex(workspaceManager, config.repos, process.cwd());
+    const totalTools = agent.state.tools.length;
+    const memoryDays = memoryService.listMemoryFiles().length;
+    console.log(box([
+        `Model:   ${header(modelProvider + '/' + modelId)}`,
+        `Tools:   ${totalTools} registered${connectorSummary ? ` (${connectorSummary})` : ''}`,
+        `Memory:  ${memoryDays} day${memoryDays === 1 ? '' : 's'} loaded`,
+    ].join('\n'), {
+        title: `Studiograph — ${config.team_name}`,
+        style: { borderColor: 'cyan', padding: 1 },
+    }));
+    // Check for updates (non-blocking, cached)
+    await notifyUpdateAvailable();
+    console.log(dimText('Type your message and press Enter. Type "exit" to quit.\n'));
     // Track conversation for memory
     const conversationLog = [];
-    // Track first delta to fix leading spacing
-    let isFirstDelta = false;
-    // Track tool sequence for spacing
+    // Track whether any non-whitespace content has been written this turn
+    let hasWrittenOutput = false;
+    // Track whether we're in a consecutive tool sequence (for spacing)
     let inToolSequence = false;
+    // Markdown rendering state — pi-tui Markdown component for styled output
+    let mdRenderer = new Markdown('', 1, 0, markdownTheme);
+    let fullText = '';
+    let displayedLineCount = 0;
+    let lastRenderedText = '';
+    // Collapse consecutive blank lines in rendered output
+    let lastLineWasBlank = false;
+    // Spinner state for tool execution
+    let toolSpinner = null;
     // Subscribe to agent events
     agent.subscribe((event) => {
         if (event.type === 'message_start') {
-            isFirstDelta = true;
+            // Reset per-turn output tracker but preserve inToolSequence across
+            // message boundaries so text following a tool turn gets a blank line.
+            hasWrittenOutput = false;
+            // Reset markdown rendering state for new message
+            mdRenderer = new Markdown('', 1, 0, markdownTheme);
+            fullText = '';
+            displayedLineCount = 0;
+            lastRenderedText = '';
+            lastLineWasBlank = false;
         }
         else if (event.type === 'message_update') {
             const msgEvent = event.assistantMessageEvent;
-            if (msgEvent.type === 'text_delta') {
+            if (msgEvent && msgEvent.type === 'text_delta') {
                 let output = msgEvent.delta;
-                // Strip both leading newlines from first delta (we already moved cursor)
-                if (isFirstDelta) {
-                    output = output.replace(/^\n\n/, '');
-                    isFirstDelta = false;
+                // Suppress whitespace-only deltas until real content appears.
+                if (!hasWrittenOutput) {
+                    output = output.replace(/^\s+/, '');
+                    if (!output)
+                        return;
                 }
-                // Add blank line before text if we just finished a tool sequence
+                // Add breathing room before text that follows a tool sequence
                 if (inToolSequence) {
                     process.stdout.write('\n');
                     inToolSequence = false;
+                    lastLineWasBlank = true; // prevent double blank after tool gap
+                }
+                hasWrittenOutput = true;
+                // Accumulate text and render complete lines through Markdown
+                fullText += output;
+                const lastNewline = fullText.lastIndexOf('\n');
+                if (lastNewline >= 0) {
+                    const completeText = fullText.substring(0, lastNewline + 1);
+                    if (completeText !== lastRenderedText) {
+                        // Defer rendering while inside an unclosed code fence — pi-tui
+                        // renders code blocks with borders, which shifts line indices
+                        // and causes content to be skipped by the incremental display.
+                        const fenceCount = (completeText.match(/^```/gm) || []).length;
+                        if (fenceCount % 2 === 1)
+                            return;
+                        mdRenderer.setText(completeText);
+                        const width = process.stdout.columns || 80;
+                        const allLines = mdRenderer.render(width);
+                        for (let i = displayedLineCount; i < allLines.length; i++) {
+                            const isBlank = allLines[i].trim() === '';
+                            if (isBlank && lastLineWasBlank)
+                                continue;
+                            lastLineWasBlank = isBlank;
+                            process.stdout.write(allLines[i] + '\n');
+                        }
+                        displayedLineCount = allLines.length;
+                        lastRenderedText = completeText;
+                    }
                 }
-                process.stdout.write(output);
             }
         }
         else if (event.type === 'message_end') {
+            // Render any remaining text (trailing incomplete line)
+            if (fullText && fullText !== lastRenderedText) {
+                mdRenderer.setText(fullText);
+                const width = process.stdout.columns || 80;
+                const allLines = mdRenderer.render(width);
+                for (let i = displayedLineCount; i < allLines.length; i++) {
+                    const isBlank = allLines[i].trim() === '';
+                    if (isBlank && lastLineWasBlank)
+                        continue;
+                    lastLineWasBlank = isBlank;
+                    process.stdout.write(allLines[i] + '\n');
+                }
+            }
             // Message complete - extract text for logging
             const msg = event.message;
             if (msg.role === 'assistant') {
@@ -246,29 +397,43 @@ export const startCommand = new Command('start')
                     .join('');
                 if (textContent) {
                     conversationLog.push(`Assistant: ${textContent}`);
+                    // Reset all formatting, then one blank line before next prompt
+                    process.stdout.write('\x1b[0m\n');
+                    inToolSequence = false;
                 }
-                // Add blank line after assistant response before next prompt
-                process.stdout.write('\n\n');
             }
         }
         else if (event.type === 'tool_execution_start') {
-            // Add blank line between consecutive tools (not before first)
             if (inToolSequence) {
-                process.stdout.write('\n');
+                process.stderr.write('\n');
             }
             else {
                 inToolSequence = true;
             }
-            // Log tool execution
-            process.stdout.write(`🔧 Using tool: ${event.toolName}\n`);
+            toolSpinner = ora({
+                text: info(`Using tool: ${toolRef(event.toolName)}`),
+                stream: process.stderr,
+                color: 'cyan',
+            }).start();
+            hasWrittenOutput = true;
+        }
+        else if (event.type === 'agent_end') {
+            // Agent completely done - fire terminal bell once
+            process.stdout.write('\x07');
         }
         else if (event.type === 'tool_execution_end') {
-            // Log tool execution errors
-            if (event.isError) {
-                process.stdout.write(`⚠️  Tool error (${event.toolName}): Execution failed\n`);
-            }
-            else if (event.result?.details?.success === false) {
-                process.stdout.write(`⚠️  Tool error (${event.toolName}): ${event.result.details.error || 'Unknown error'}\n`);
+            if (toolSpinner) {
+                const toolLabel = info(`Using tool: ${toolRef(event.toolName)}`);
+                if (event.isError) {
+                    toolSpinner.fail(warn(`${toolRef(event.toolName)}: Execution failed`));
+                }
+                else if (event.result?.details?.success === false) {
+                    toolSpinner.fail(warn(`${toolRef(event.toolName)}: ${event.result.details.error || 'Unknown error'}`));
+                }
+                else {
+                    toolSpinner.stopAndPersist({ symbol: info('🔧'), text: toolLabel });
+                }
+                toolSpinner = null;
             }
         }
     });
@@ -278,9 +443,19 @@ export const startCommand = new Command('start')
         output: process.stdout,
         prompt: '> ',
     });
-    rl.prompt();
-    rl.on('line', async (input) => {
-        const message = input.trim();
+    // ── Multiline paste handling ──────────────────────────────────────────────
+    // When text is pasted, readline fires 'line' for each \n in rapid
+    // succession. We collect lines that arrive within a short window and
+    // join them into a single message (like Claude Code).
+    const PASTE_DEBOUNCE_MS = 50;
+    let pasteBuffer = [];
+    let pasteTimer = null;
+    // ── Prompt serialization ──────────────────────────────────────────────────
+    // If the user pastes multiple chunks or types while the agent is busy,
+    // we queue messages and process them one at a time.
+    let agentBusy = false;
+    const messageQueue = [];
+    async function processMessage(message) {
         if (message.toLowerCase() === 'exit') {
             // Save session summary to memory
             if (conversationLog.length > 0) {
@@ -295,13 +470,27 @@ export const startCommand = new Command('start')
             return;
         }
         if (!message) {
+            process.stdout.write('\x1b[0m');
             rl.prompt();
             return;
         }
+        agentBusy = true;
         try {
             conversationLog.push(`User: ${message}`);
-            // Move cursor to where agent response will appear (prevents double-jump)
-            process.stdout.write('\n');
+            // Re-render user input with dark gray background (overwrites readline echo)
+            // Account for multi-line wrapping: calculate how many terminal rows
+            // the readline echo occupied, then move up and clear each one.
+            const cols = process.stdout.columns || 80;
+            const echoLen = 2 + message.length; // "> " prompt + message
+            const wrappedLines = Math.ceil(echoLen / cols) || 1;
+            process.stdout.write(`\x1b[${wrappedLines}A`); // move up N lines
+            for (let i = 0; i < wrappedLines; i++) {
+                process.stdout.write('\x1b[2K'); // clear current line
+                if (i < wrappedLines - 1)
+                    process.stdout.write('\x1b[1B'); // move down
+            }
+            process.stdout.write('\x1b[G'); // move to column 1
+            process.stdout.write(renderUserPrompt(message) + '\n\n');
             // Send message to agent and wait for completion
             await agent.prompt(message);
             await agent.waitForIdle();
@@ -312,7 +501,46 @@ export const startCommand = new Command('start')
                 console.error('Stack trace:', error.stack);
             }
         }
-        rl.prompt();
+        agentBusy = false;
+        // Drain the queue
+        if (messageQueue.length > 0) {
+            const next = messageQueue.shift();
+            process.stdout.write('\x1b[0m');
+            rl.prompt();
+            // Small delay so the prompt renders before processing
+            setImmediate(() => processMessage(next));
+        }
+        else {
+            process.stdout.write('\x1b[0m');
+            rl.prompt();
+        }
+    }
+    function flushPasteBuffer() {
+        pasteTimer = null;
+        const message = pasteBuffer.join('\n').trim();
+        pasteBuffer = [];
+        if (!message) {
+            if (!agentBusy) {
+                process.stdout.write('\x1b[0m');
+                rl.prompt();
+            }
+            return;
+        }
+        if (agentBusy) {
+            messageQueue.push(message);
+        }
+        else {
+            processMessage(message);
+        }
+    }
+    rl.prompt();
+    rl.on('line', (input) => {
+        pasteBuffer.push(input);
+        // Reset the debounce timer — if another line arrives within
+        // PASTE_DEBOUNCE_MS it's part of the same paste operation
+        if (pasteTimer)
+            clearTimeout(pasteTimer);
+        pasteTimer = setTimeout(flushPasteBuffer, PASTE_DEBOUNCE_MS);
     });
     rl.on('close', () => {
         console.log('\n👋 Goodbye!');
@@ -320,62 +548,203 @@ export const startCommand = new Command('start')
     });
 });
 /**
- * Create system prompt with workspace and memory context
+ * Initialize the search index on startup.
+ *
+ * First run: prompts for Voyage AI key (optional), then runs full index.
+ * Subsequent runs: checks git log for commits since last index and re-indexes changed entities.
  */
-function createSystemPrompt(teamName, repos, recentMemory) {
-    return `You are Studiograph, an AI agent that helps creative teams manage their knowledge graphs.
-
-# Workspace: ${teamName}
+async function initSearchIndex(workspaceManager, repos, workspacePath) {
+    const userConfig = loadUserConfig();
+    const dbPath = userConfig.vector_db_path || join(homedir(), '.studiograph', 'vector');
+    const vectorService = workspaceManager.vectorService;
+    // First-run: no repos have been indexed yet
+    const isFirstRun = repos.every(r => !vectorService.getLastIndexedTime(r.name));
+    if (isFirstRun) {
+        // Prompt for Voyage AI key (optional)
+        if (!userConfig.voyage_api_key) {
+            const choice = await select({
+                message: 'Enable semantic search? (optional)',
+                options: [
+                    { value: 'skip', label: 'Skip — use FTS keyword search', hint: 'No setup required' },
+                    { value: 'voyage', label: 'Enable semantic search', hint: 'Voyage AI key required' },
+                ],
+            });
+            if (choice === 'voyage' && typeof choice === 'string') {
+                const keyInput = await text({
+                    message: 'Enter your Voyage AI API key:',
+                    placeholder: 'pa-...',
+                    validate: (v) => (!v || v.length < 10 ? 'Key seems too short' : undefined),
+                });
+                if (typeof keyInput === 'string') {
+                    userConfig.voyage_api_key = keyInput;
+                    saveUserConfig(userConfig);
+                }
+            }
+        }
+        // Full index on first run
+        const s = spinner();
+        s.start('Indexing workspace for search...');
+        let total = 0;
+        for (const repo of repos) {
+            const repoPath = join(workspacePath, repo.path);
+            try {
+                const graph = workspaceManager['graphs'].get(repo.name);
+                if (!graph)
+                    continue;
+                const entities = graph.list();
+                if (entities.length > 0) {
+                    await vectorService.upsertMany(repo.name, entities);
+                    total += entities.length;
+                }
+                vectorService.setLastIndexedTime(repo.name);
+            }
+            catch { /* non-fatal */ }
+        }
+        s.stop(`Search index ready (${total} entities)`);
+        return;
+    }
+    // Subsequent runs: check git log for changes since last index
+    const staleEntities = [];
+    for (const repo of repos) {
+        const lastIndexed = vectorService.getLastIndexedTime(repo.name);
+        if (!lastIndexed)
+            continue;
+        const repoPath = join(workspacePath, repo.path);
+        try {
+            const output = execSync(`git log --since="${lastIndexed}" --name-status --format="" -- "*.md"`, { cwd: repoPath, encoding: 'utf-8', stdio: 'pipe' }).trim();
+            if (!output)
+                continue;
+            for (const line of output.split('\n')) {
+                const match = line.match(/^([AMD])\s+(\w+)\/([^/]+)\.md$/);
+                if (!match)
+                    continue;
+                const [, status, entityType, entityId] = match;
+                staleEntities.push({ repoName: repo.name, entityType, entityId, deleted: status === 'D' });
+            }
+        }
+        catch { /* non-fatal */ }
+    }
+    if (staleEntities.length === 0)
+        return;
+    const s = spinner();
+    s.start(`Updating search index (${staleEntities.length} change${staleEntities.length === 1 ? '' : 's'})...`);
+    for (const item of staleEntities) {
+        try {
+            if (item.deleted) {
+                await vectorService.delete(item.repoName, item.entityType, item.entityId);
+            }
+            else {
+                const graph = workspaceManager['graphs'].get(item.repoName);
+                if (!graph)
+                    continue;
+                const entity = graph.get(item.entityType, item.entityId);
+                await vectorService.upsert(item.repoName, entity);
+            }
+        }
+        catch { /* entity may not exist — skip */ }
+    }
+    for (const repo of repos) {
+        vectorService.setLastIndexedTime(repo.name);
+    }
+    s.stop('Search index updated');
+}
+/**
+ * Create system prompt with workspace context, tool reference, skills, and memory.
+ */
+function createSystemPrompt(teamName, repos, recentMemory, schemaExtensions, tools, skillIndex) {
+    // Load the authoritative system prompt from system.md
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const promptPath = join(__dirname, '../../agent/prompts/system.md');
+    let base = existsSync(promptPath)
+        ? readFileSync(promptPath, 'utf-8')
+        : 'You are Studiograph, an AI agent that helps creative teams manage their knowledge graphs.';
+    // Auto-generate tool reference from registered tools, grouped by category
+    if (tools && tools.length > 0) {
+        const categories = {
+            'Entity Management': [],
+            'Data Sync & Source Config': [],
+            'Enrichment': [],
+            'Workspace Git': [],
+            'External Connectors': [],
+            'Skills': [],
+            'Other': [],
+        };
+        for (const t of tools) {
+            if (t.description?.startsWith('DEPRECATED'))
+                continue;
+            const name = t.name ?? '';
+            if (name.startsWith('sync_'))
+                categories['Data Sync & Source Config'].push(t);
+            else if (name.startsWith('enrich_'))
+                categories['Enrichment'].push(t);
+            else if (name.startsWith('workspace_'))
+                categories['Workspace Git'].push(t);
+            else if (name.startsWith('connector_'))
+                categories['External Connectors'].push(t);
+            else if (name === 'load_skill')
+                categories['Skills'].push(t);
+            else if (['create_entity', 'get_entity', 'update_entity', 'delete_entity', 'search_entities', 'list_entities', 'get_related', 'get_backlinks', 'validate_wikilinks', 'get_workspace_summary', 'list_repos', 'query_dataset', 'append_rows', 'get_entity_schema', 'lint_entities'].includes(name))
+                categories['Entity Management'].push(t);
+            else
+                categories['Other'].push(t);
+        }
+        const toolRef = Object.entries(categories)
+            .filter(([, items]) => items.length > 0)
+            .map(([cat, items]) => `**${cat}:**\n${items.map((t) => `- \`${t.name}\` — ${t.description}`).join('\n')}`)
+            .join('\n\n');
+        base = base.replace('{{TOOL_REFERENCE}}', toolRef);
+    }
+    else {
+        base = base.replace('{{TOOL_REFERENCE}}', '');
+    }
+    const registry = new SchemaRegistry(schemaExtensions);
+    const schemaSection = registry.toPromptSection();
+    const workspaceSection = `## Workspace: ${teamName}
 
 You are working in a Studiograph workspace with the following repositories:
 
-${repos.map(repo => `- ${repo.name} (${repo.type}): ${repo.description || 'No description'}`).join('\n')}
+${repos.map(repo => `- ${repo.name} (${repo.type}): ${repo.description || 'No description'}`).join('\n')}`;
+    const memorySection = recentMemory
+        ? `## Memory Context\n\n${recentMemory}`
+        : '';
+    const outputSection = `## Output Formatting
 
-# Memory Context
+You are running in a CLI terminal. Keep responses **short and scannable**.
 
-${recentMemory}
+**Length rules:**
+- Default to 2-4 sentences for simple answers
+- Use bullet lists for 3+ items — never write items as prose paragraphs
+- Limit tool result summaries to the most relevant 5-10 items
+- Only use headings (##) when the response has 2+ distinct sections
+- If the user asks a yes/no question, lead with the answer
 
-# Your Role
+**Formatting rules:**
+- Use **bold** for emphasis and \`inline code\` for commands, entity types, and field names
+- Use fenced code blocks for multi-line code, YAML, or file contents
+- Use > blockquotes sparingly for callouts
+- NEVER use markdown tables (| pipes) — use bullet lists instead
+- Do NOT repeat information the user already knows
 
-You help the team:
-- Create and manage entities in their knowledge graphs
-- Search and discover relationships between entities
-- Generate presentations and documentation
-- Track decisions and project history
-
-# Entity Types by Repository Type
-
-PROJECT repositories contain:
-- Projects, Clients, People, Meetings, Decisions, Artifacts
-
-FUNCTION repositories contain:
-- Function-specific entities (varies by team)
-
-SHARED_RESOURCE repositories contain:
-- Templates, Standards, Processes, Research, References
-
-# Guidelines
-
-- Be conversational and helpful
-- Ask clarifying questions when needed
-- Suggest related entities and connections
-- Track important decisions and context in memory
-- Always save significant insights to memory for future sessions
-
-# Output Formatting
-
-IMPORTANT: You are running in a CLI (command-line interface). Use plain text formatting:
-- NO markdown syntax: no bold (**text**), italic (*text*), code formatting (\`code\`), headings (# Heading), or tables
-- For section headers, use ALL CAPS on a single line with NO blank line after:
-  Example:
-  MANAGE YOUR KNOWLEDGE
-  - Create entities
-  - Search and discover
-- Use simple bullet points with single hyphens: "- item"
-- For punctuation, use single hyphens (-) not double hyphens (--)
-- Separate different sections with ONE blank line between them
-- Keep responses concise and conversational
-
-Start by greeting the user and asking how you can help them today.`;
+Start by greeting the user briefly and asking how you can help.`;
+    const parts = [base.trim(), workspaceSection];
+    if (memorySection)
+        parts.push(memorySection);
+    if (schemaSection)
+        parts.push(schemaSection);
+    // Inline eager skills directly into the system prompt
+    if (skillIndex) {
+        const eagerContent = loadEagerSkills(skillIndex);
+        if (eagerContent)
+            parts.push(eagerContent);
+    }
+    // Append skill index for on-demand skills
+    if (skillIndex) {
+        const index = buildSkillIndexPrompt(skillIndex);
+        if (index)
+            parts.push(index);
+    }
+    parts.push(outputSection);
+    return parts.join('\n\n');
 }
 //# sourceMappingURL=start.js.map