snow-flow 3.6.25 → 4.0.0-final-claude

package/.env.example

@@ -0,0 +1,89 @@
+# Closed-source
+OPENAI_API_KEY=
+GOOGLE_API_KEY=
+
+# Gateways / OSS
+OPENROUTER_API_KEY=
+OPENAI_COMPAT_API_KEY=   # voor xAI Grok en DeepSeek (OpenAI-compatible)
+
+# ServiceNow Configuration
+# ===========================================
+
+# ServiceNow Instance URL (without https://)
+# Example: dev12345.service-now.com
+SNOW_INSTANCE=your-instance.service-now.com
+
+# OAuth Client ID from ServiceNow Application Registry
+SNOW_CLIENT_ID=your-oauth-client-id
+
+# OAuth Client Secret from ServiceNow Application Registry
+SNOW_CLIENT_SECRET=your-oauth-client-secret
+
+# ===========================================
+# Snow-Flow Configuration
+# ===========================================
+
+# Enable debug logging (true/false)
+SNOW_FLOW_DEBUG=true
+
+# MAXIMUM DEBUG LEVELS
+DEBUG=*                          # Debug ALLES
+NODE_ENV=development            # Development mode voor extra debug info
+LOG_LEVEL=trace                 # Trace is nog hoger dan debug
+VERBOSE=true                    # Extra verbose output
+MCP_DEBUG=true                  # MCP specific debugging
+MCP_LOG_LEVEL=trace            # MCP trace level logging
+SNOW_FLOW_TRACE=true           # Snow-Flow trace logging
+CLAUDE_CODE_DEBUG=true         # Claude Code debug mode
+HTTP_TRACE=true                # HTTP request/response tracing
+
+# Default coordination strategy
+SNOW_FLOW_STRATEGY=development
+
+# Maximum number of agents
+SNOW_FLOW_MAX_AGENTS=5
+
+# ===========================================
+# Claude Code API Integration (30 minutes)
+# ===========================================
+# API timeout for Claude Code integration - 30 minutes
+# This ensures Snow-Flow works smoothly with Claude Code's extended operation timeouts
+API_TIMEOUT_MS=1800000
+
+# ===========================================
+# Timeout Configuration (v3.0.1+)
+# ===========================================
+# IMPORTANT: Snow-Flow has NO TIMEOUTS by default for maximum reliability.
+# Operations run until completion. Only set timeouts if you specifically need them.
+# All timeout values below are COMMENTED OUT - uncomment only what you need.
+
+# Memory Operations (TodoWrite, etc.)
+# MCP_MEMORY_TIMEOUT=30000      # 30 seconds
+# MCP_MEMORY_TIMEOUT=60000      # 1 minute
+# MCP_MEMORY_TIMEOUT=120000     # 2 minutes
+
+# ServiceNow API Operations
+# SNOW_API_TIMEOUT=60000        # 1 minute - quick operations
+# SNOW_API_TIMEOUT=180000       # 3 minutes - standard operations
+# SNOW_API_TIMEOUT=300000       # 5 minutes - complex queries
+
+# Deployment Operations
+# SNOW_DEPLOYMENT_TIMEOUT=300000  # 5 minutes - simple deployments
+# SNOW_DEPLOYMENT_TIMEOUT=600000  # 10 minutes - complex widgets
+
+# MCP transport timeout (should be higher than SNOW_DEPLOYMENT_TIMEOUT if both set)
+# MCP_DEPLOYMENT_TIMEOUT=360000   # 6 minutes
+# MCP_DEPLOYMENT_TIMEOUT=720000   # 12 minutes
+
+# ===========================================
+# Response Size Limits (v3.4.34+)
+# ===========================================
+# Maximum MCP response size to prevent timeouts
+# Default: 500KB (sufficient for most widgets/flows)
+# MCP_MAX_RESPONSE_SIZE=500000    # 500KB default (recommended)
+# MCP_MAX_RESPONSE_SIZE=1000000   # 1MB for larger artifacts
+# MCP_MAX_RESPONSE_SIZE=2000000   # 2MB for very large responses
+
+# Maximum array items in responses
+# MCP_MAX_ARRAY_ITEMS=500         # 500 items default
+# MCP_MAX_ARRAY_ITEMS=1000        # 1000 for large datasets

package/README.md

@@ -1,14 +1,14 @@
 <div align="center">
   <img src="assets/snow-flow-logo.svg" alt="Snow-Flow Logo" width="200" height="200">
   
-  # ❄️ Snow-Flow v3.6.25 ❄️
+  # ❄️ Snow-Flow v4.0.0 - Final Claude Code CLI Edition ❄️
   
   <p align="center">
     <strong>🚀 Revolutionary ServiceNow Development Framework with AI-Powered Automation</strong>
   </p>
   
   <p align="center">
-    <a href="https://www.npmjs.com/package/snow-flow"><img src="https://img.shields.io/npm/v/snow-flow.svg?style=for-the-badge&logo=npm&color=CB3837" alt="npm version"></a>
+    <a href="https://www.npmjs.com/package/snow-flow"><img src="https://img.shields.io/badge/npm-v4.0.0--final--claude-CB3837?style=for-the-badge&logo=npm" alt="npm version"></a>
     <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-green.svg?style=for-the-badge" alt="License: MIT"></a>
     <a href="https://nodejs.org"><img src="https://img.shields.io/node/v/snow-flow.svg?style=for-the-badge&logo=node.js&color=339933" alt="Node.js Version"></a>
     <a href="https://github.com/groeimetai/snow-flow"><img src="https://img.shields.io/github/stars/groeimetai/snow-flow?style=for-the-badge&logo=github" alt="GitHub Stars"></a>
@@ -21,29 +21,54 @@
 
 ---
 
-## 🎉 What's New in v3.6.25
+## 🚨 Important Announcement: Final Claude Code CLI Edition
+
+<div align="center">
+  <table>
+    <tr>
+      <td align="center">
+        <h3>⚡ This is the Final Claude Code CLI Version ⚡</h3>
+        <p>Snow-Flow v4.0.0 marks the end of an era. This is the last version designed specifically for Claude Code CLI.</p>
+        <p><strong>🔮 What's Coming Next:</strong></p>
+        <ul align="left">
+          <li>🤖 Support for <strong>ANY LLM</strong>: OpenAI, Google Gemini, Anthropic Claude, Ollama, and more</li>
+          <li>🔌 Modular provider system with unified interface</li>
+          <li>💻 Native CLI with interactive chat interface</li>
+          <li>🔄 Seamless switching between LLM providers</li>
+          <li>📊 Same great ServiceNow tools, now LLM-agnostic</li>
+        </ul>
+        <p><strong>Thank you to all Claude Code users who made this journey possible! 🙏</strong></p>
+      </td>
+    </tr>
+  </table>
+</div>
+
+---
+
+## 🎉 What's New in v4.0.0-final-claude
 
 <div align="center">
   <table>
     <tr>
       <td align="center" width="50%">
-        <h3>🚀 Major Features</h3>
+        <h3>🏁 Final Release Features</h3>
         <ul align="left">
-          <li><strong>Catalog UI Policy Deployment</strong><br/>Deploy via unified <code>snow_deploy</code> tool</li>
-          <li><strong>Knowledge Base Verification</strong><br/>Prevents orphaned articles with strict validation</li>
-          <li><strong>Catalog Variable Table Fix</strong><br/>Variables now use correct <code>item_option_new</code></li>
-          <li><strong>Enhanced UI Policy Debugging</strong><br/>Comprehensive reference field debugging</li>
-          <li><strong>18th MCP Server</strong><br/>Local Development Server for artifact syncing</li>
+          <li><strong>🔚 Final Claude Code CLI Version</strong><br/>Last release for Claude Code users</li>
+          <li><strong>📚 Complete Feature Set</strong><br/>All 18 MCP servers, 200+ tools</li>
+          <li><strong>🎯 Catalog UI Policy Support</strong><br/>Deploy via unified <code>snow_deploy</code> tool</li>
+          <li><strong>🔒 Knowledge Base Verification</strong><br/>Prevents orphaned articles</li>
+          <li><strong>✨ Beautiful Documentation</strong><br/>Enhanced README and website</li>
         </ul>
       </td>
       <td align="center" width="50%">
-        <h3>🔧 Critical Fixes</h3>
+        <h3>🚀 Latest Improvements</h3>
         <ul align="left">
-          <li>✅ Catalog variables now visible in ServiceNow</li>
-          <li>✅ UI policy actions reference fields fixed</li>
-          <li>✅ Non-existent KB error handling added</li>
-          <li>✅ MCP transport 3x faster operations</li>
-          <li>✅ Widget coherence validation improved</li>
+          <li>✅ Catalog variables table fix (v3.6.23)</li>
+          <li>✅ UI policy debugging enhanced (v3.6.22)</li>
+          <li>✅ Knowledge validation added (v3.6.25)</li>
+          <li>✅ MCP transport 3x faster</li>
+          <li>✅ ES5 validation throughout</li>
+          <li>🎁 All previous fixes included</li>
         </ul>
       </td>
     </tr>

package/dist/agent/interactive.d.ts

@@ -0,0 +1,11 @@
+import type { SnowFlowConfig } from '../config/llm-config-loader';
+import type { ProviderOptions } from '../llm/providers';
+export interface InteractiveOptions extends ProviderOptions {
+    system?: string;
+    mcp: SnowFlowConfig['mcp'];
+    maxSteps?: number;
+    showReasoning?: boolean;
+    resumeId?: string;
+}
+export declare function runInteractive(opts: InteractiveOptions): Promise<void>;
+//# sourceMappingURL=interactive.d.ts.map

package/dist/agent/interactive.js

@@ -0,0 +1,190 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInteractive = runInteractive;
+const bridge_1 = require("../mcp/bridge");
+const chalk_1 = __importDefault(require("chalk"));
+const boxen_1 = __importDefault(require("boxen"));
+const node_readline_1 = __importDefault(require("node:readline"));
+const store_js_1 = require("../session/store.js");
+const ora_1 = __importDefault(require("ora"));
+async function runInteractive(opts) {
+    const { provider, model, baseURL, apiKeyEnv, system, mcp, maxSteps = 40, showReasoning = true, resumeId } = opts;
+    // Resolve model
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const prov = require('../llm/providers.js');
+    const llm = prov.getModel({ provider, model, baseURL, apiKeyEnv });
+    const sessionId = resumeId || (0, store_js_1.createSessionId)();
+    (0, store_js_1.startSession)({
+        id: sessionId,
+        startedAt: new Date().toISOString(),
+        objective: '(interactive)',
+        provider: { id: String(provider), model: String(model), baseURL },
+        mcp: { cmd: mcp.cmd, args: mcp.args },
+    });
+    process.stdout.write(chalk_1.default.bold(`\nSnow-Flow Interactive (${provider}:${model})`) + "\n");
+    process.stdout.write(chalk_1.default.gray('Tips: ESC ESC = vorige assistant-antwoord | /quit om te stoppen') + "\n\n");
+    // Load tools once with spinner
+    const spinner = (0, ora_1.default)('MCP-tools laden...').start();
+    const { tools, close } = await (0, bridge_1.loadMCPTools)(mcp).finally(() => spinner.stop());
+    const messages = [];
+    if (system)
+        messages.push({ role: 'system', content: system });
+    // Preload previous messages if resuming
+    if (resumeId) {
+        try {
+            const { readSession } = require('../session/store.js');
+            const rec = readSession(resumeId);
+            if (rec?.messages?.length) {
+                const recent = rec.messages.filter((m) => m.role === 'user' || m.role === 'assistant').slice(-20);
+                for (const m of recent)
+                    messages.push({ role: m.role, content: m.content });
+            }
+        }
+        catch { }
+    }
+    // Key handling for ESC ESC
+    node_readline_1.default.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY)
+        process.stdin.setRawMode(true);
+    let lastEsc = 0;
+    let lastAssistant = null;
+    let showTools = true;
+    const onKeypress = (_str, key) => {
+        if (!key)
+            return;
+        if (key.name === 'escape') {
+            const now = Date.now();
+            if (now - lastEsc < 500) {
+                // double ESC
+                if (lastAssistant) {
+                    const box = (0, boxen_1.default)(lastAssistant.slice(0, 1200) + (lastAssistant.length > 1200 ? '…' : ''), { padding: 1, borderColor: 'yellow', title: 'Vorige assistant', titleAlignment: 'center' });
+                    process.stdout.write('\n' + box + '\n');
+                }
+                else {
+                    process.stdout.write(chalk_1.default.gray('\nGeen vorige assistant-respons beschikbaar.') + '\n');
+                }
+            }
+            lastEsc = now;
+        }
+        if (key.name === 't') {
+            showTools = !showTools;
+            process.stdout.write('\n' + (showTools ? chalk_1.default.gray('Tool events: ON') : chalk_1.default.gray('Tool events: OFF')) + '\n');
+        }
+        if (key.name === 'h') {
+            const last = messages.slice(-6);
+            const text = last.map(m => `${m.role}> ${m.content}`).join('\n');
+            const panel = (0, boxen_1.default)(text, { padding: 1, borderColor: 'blue', title: 'History (tail)', titleAlignment: 'center' });
+            process.stdout.write('\n' + panel + '\n');
+        }
+        if (key.name === 's') {
+            const fs = require('fs');
+            const out = (lastAssistant || '').toString();
+            const outPath = `${process.env.HOME || ''}/.snow-flow/sessions/${sessionId}.txt`;
+            try {
+                fs.writeFileSync(outPath, out, 'utf8');
+            }
+            catch { }
+            process.stdout.write(chalk_1.default.gray(`Saved assistant output to ${outPath}`) + '\n');
+        }
+    };
+    process.stdin.on('keypress', onKeypress);
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { streamText } = require('ai');
+    const rl = node_readline_1.default.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+    const ask = (q) => new Promise(resolve => rl.question(q, resolve));
+    try {
+        const onSignal = async () => {
+            try {
+                await close();
+            }
+            catch { }
+            (0, store_js_1.endSession)(sessionId);
+            process.stdout.write('\n' + chalk_1.default.gray('Session ended.') + '\n');
+            process.exit(0);
+        };
+        process.on('SIGINT', onSignal);
+        process.on('SIGTERM', onSignal);
+        // loop
+        while (true) {
+            const input = await ask(chalk_1.default.cyan('You: '));
+            if (!input)
+                continue;
+            if (input.trim() === '/quit')
+                break;
+            const long = input.length > 1200;
+            if (long) {
+                const preview = input.slice(0, 1200) + '…';
+                const box = (0, boxen_1.default)(preview, { padding: 1, borderColor: 'green', title: 'Preview (truncated)', titleAlignment: 'center' });
+                process.stdout.write('\n' + box + '\n');
+                const confirm = await ask(chalk_1.default.gray('Doorgaan met verzenden? [y/N] '));
+                if (!/^y(es)?$/i.test(confirm.trim()))
+                    continue;
+            }
+            messages.push({ role: 'user', content: input });
+            (0, store_js_1.appendMessage)(sessionId, { role: 'user', content: input, timestamp: new Date().toISOString() });
+            const result = await streamText({
+                model: llm,
+                system,
+                messages,
+                tools,
+                maxSteps,
+            });
+            let buffer = '';
+            let inReasoning = false;
+            const write = (s) => {
+                buffer += s;
+                const out = inReasoning && showReasoning ? chalk_1.default.yellow.dim(s) : s;
+                process.stdout.write(out);
+            };
+            if (result.toolCallStream && typeof result.toolCallStream[Symbol.asyncIterator] === 'function') {
+                (async () => {
+                    for await (const ev of result.toolCallStream) {
+                        const name = ev?.toolName || ev?.name || 'tool';
+                        const args = ev?.args ? JSON.stringify(ev.args).slice(0, 180) : '';
+                        if (showTools)
+                            process.stdout.write('\n' + chalk_1.default.cyan(`🔧 Tool → ${name} ${args}`) + '\n');
+                        (0, store_js_1.appendToolEvent)(sessionId, { name, argsPreview: args });
+                    }
+                })().catch(() => { });
+            }
+            if (result.toolResultStream && typeof result.toolResultStream[Symbol.asyncIterator] === 'function') {
+                (async () => {
+                    for await (const ev of result.toolResultStream) {
+                        const name = ev?.toolName || ev?.name || 'tool';
+                        const out = ev?.result ? JSON.stringify(ev.result).slice(0, 180) : '';
+                        if (showTools)
+                            process.stdout.write(chalk_1.default.magenta(`📦 Result ← ${name} ${out}`) + '\n');
+                        (0, store_js_1.appendToolEvent)(sessionId, { name, resultPreview: out });
+                    }
+                })().catch(() => { });
+            }
+            process.stdout.write(chalk_1.default.green('\nAssistant: '));
+            for await (const chunk of result.textStream) {
+                const s = String(chunk);
+                if (showReasoning) {
+                    if (s.includes('```reasoning') || s.toLowerCase().includes('<thinking>') || /\[\s*reasoning\s*\]/i.test(s))
+                        inReasoning = true;
+                    if (s.includes('```') || s.toLowerCase().includes('</thinking>'))
+                        inReasoning = false;
+                }
+                write(s);
+            }
+            process.stdout.write('\n');
+            lastAssistant = buffer;
+            messages.push({ role: 'assistant', content: buffer });
+            (0, store_js_1.appendMessage)(sessionId, { role: 'assistant', content: buffer, timestamp: new Date().toISOString() });
+        }
+    }
+    finally {
+        rl.close();
+        process.stdin.off('keypress', onKeypress);
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(false);
+        await close();
+        (0, store_js_1.endSession)(sessionId);
+    }
+}
+//# sourceMappingURL=interactive.js.map

package/dist/agent/session.d.ts

@@ -0,0 +1,12 @@
+import type { SnowFlowConfig } from '../config/llm-config-loader';
+import type { ProviderOptions } from '../llm/providers';
+export interface AgentRunOptions extends ProviderOptions {
+    system?: string;
+    user: string;
+    mcp: SnowFlowConfig['mcp'];
+    maxSteps?: number;
+    showReasoning?: boolean;
+    saveOutputPath?: string;
+}
+export declare function runAgent(opts: AgentRunOptions): Promise<void>;
+//# sourceMappingURL=session.d.ts.map

package/dist/agent/session.js

@@ -0,0 +1,106 @@
+"use strict";
+// Agent session placeholder to keep build green.
+// Will be replaced with streaming + tool-calling using the AI SDK.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAgent = runAgent;
+const bridge_1 = require("../mcp/bridge");
+const boxen_1 = __importDefault(require("boxen"));
+const chalk_1 = __importDefault(require("chalk"));
+const store_js_1 = require("../session/store.js");
+async function runAgent(opts) {
+    const { mcp, system, user, maxSteps = 40, provider, model, baseURL, apiKeyEnv, showReasoning = true, saveOutputPath } = opts;
+    // Resolve model via provider registry
+    let llm;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const prov = require('../llm/providers.js');
+        llm = prov.getModel({ provider, model, baseURL, apiKeyEnv });
+    }
+    catch (e) {
+        console.error('❌ LLM provider init error:', e instanceof Error ? e.message : String(e));
+        throw e;
+    }
+    // Load MCP tools (if AI SDK MCP client is available)
+    const { tools, close } = await (0, bridge_1.loadMCPTools)(mcp);
+    // Stream using AI SDK
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { streamText } = require('ai');
+        const sessionId = (0, store_js_1.createSessionId)();
+        (0, store_js_1.startSession)({
+            id: sessionId,
+            startedAt: new Date().toISOString(),
+            objective: user,
+            provider: { id: String(provider), model: String(model), baseURL },
+            mcp: { cmd: mcp.cmd, args: mcp.args },
+        });
+        (0, store_js_1.appendMessage)(sessionId, { role: 'user', content: user, timestamp: new Date().toISOString() });
+        const result = await streamText({
+            model: llm,
+            system: system ?? 'You are Snow-Flow, a ServiceNow engineering agent. Be precise. Use tools when helpful.',
+            messages: [{ role: 'user', content: user }],
+            tools,
+            maxSteps,
+        });
+        let buffer = '';
+        let inReasoning = false;
+        const writeChunk = (s) => {
+            buffer += s;
+            const colored = inReasoning && showReasoning ? chalk_1.default.yellow.dim(s) : s;
+            process.stdout.write(colored);
+        };
+        // Optional: stream tool call events if provided by SDK
+        if (result.toolCallStream && typeof result.toolCallStream[Symbol.asyncIterator] === 'function') {
+            (async () => {
+                for await (const ev of result.toolCallStream) {
+                    const name = ev?.toolName || ev?.name || 'tool';
+                    const args = ev?.args ? JSON.stringify(ev.args).slice(0, 200) : '';
+                    process.stdout.write('\n' + chalk_1.default.cyan(`🔧 Tool → ${name} ${args}`) + '\n');
+                    (0, store_js_1.appendToolEvent)(sessionId, { name, argsPreview: args });
+                }
+            })().catch(() => { });
+        }
+        if (result.toolResultStream && typeof result.toolResultStream[Symbol.asyncIterator] === 'function') {
+            (async () => {
+                for await (const ev of result.toolResultStream) {
+                    const name = ev?.toolName || ev?.name || 'tool';
+                    const out = ev?.result ? JSON.stringify(ev.result).slice(0, 200) : '';
+                    process.stdout.write(chalk_1.default.magenta(`📦 Result ← ${name} ${out}`) + '\n');
+                    (0, store_js_1.appendToolEvent)(sessionId, { name, resultPreview: out });
+                }
+            })().catch(() => { });
+        }
+        for await (const chunk of result.textStream) {
+            const str = String(chunk);
+            // Heuristic: detect reasoning blocks (```reasoning, <thinking>, [reasoning])
+            if (showReasoning) {
+                if (str.includes('```reasoning') || str.toLowerCase().includes('<thinking>') || /\[\s*reasoning\s*\]/i.test(str))
+                    inReasoning = true;
+                if (str.includes('```') || str.toLowerCase().includes('</thinking>'))
+                    inReasoning = false;
+            }
+            writeChunk(str);
+        }
+        // Render a boxed summary if output is long
+        if (buffer.length > 4000) {
+            const preview = buffer.slice(0, 1200) + '…';
+            const box = (0, boxen_1.default)(preview, { padding: 1, borderColor: 'green', title: 'Preview (truncated)', titleAlignment: 'center' });
+            process.stdout.write('\n' + box + '\n');
+            process.stdout.write(chalk_1.default.gray(`Full length: ${buffer.length} chars`) + '\n');
+        }
+        if (saveOutputPath) {
+            const fs = require('fs');
+            fs.writeFileSync(saveOutputPath, buffer, 'utf8');
+            process.stdout.write(chalk_1.default.gray(`Saved full output to ${saveOutputPath}`) + '\n');
+        }
+        (0, store_js_1.appendMessage)(sessionId, { role: 'assistant', content: buffer, timestamp: new Date().toISOString() });
+        (0, store_js_1.endSession)(sessionId);
+    }
+    finally {
+        await close();
+    }
+}
+//# sourceMappingURL=session.js.map

package/dist/cli/auth.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerAuthCommands(program: Command): void;
+//# sourceMappingURL=auth.d.ts.map

package/dist/cli/auth.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAuthCommands = registerAuthCommands;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const keys_js_1 = require("../llm/keys.js");
+function registerAuthCommands(program) {
+    const auth = program.command('auth').description('Manage provider API credentials for Snow-Flow');
+    auth
+        .command('login')
+        .description('Interactive login to store API keys for a provider')
+        .option('--provider <provider>', 'Provider id (openai|google|openrouter|openai-compatible|ollama)')
+        .action(async (opts) => {
+        const p = opts.provider || (await inquirer_1.default.prompt([{ name: 'provider', message: 'Provider', type: 'list', choices: ['openai', 'google', 'openrouter', 'openai-compatible', 'ollama'] }])).provider;
+        const existing = (0, keys_js_1.getApiKey)(p);
+        const { apiKey } = await inquirer_1.default.prompt([{ name: 'apiKey', message: `API key for ${p}${existing ? ' (leave blank to keep existing)' : ''}`, type: 'password', mask: '*' }]);
+        if (!apiKey && existing) {
+            console.log(chalk_1.default.yellow('Keeping existing key.'));
+            return;
+        }
+        if (!apiKey) {
+            console.error(chalk_1.default.red('No key entered. Aborting.'));
+            process.exit(1);
+        }
+        (0, keys_js_1.setApiKey)(p, apiKey);
+        console.log(chalk_1.default.green(`Saved API key for ${p}.`));
+    });
+    auth
+        .command('set-key')
+        .description('Set API key non-interactively')
+        .requiredOption('--provider <provider>', 'Provider id')
+        .requiredOption('--api-key <key>', 'API key value')
+        .action((opts) => {
+        (0, keys_js_1.setApiKey)(opts.provider, opts.apiKey);
+        console.log(chalk_1.default.green(`Saved API key for ${opts.provider}.`));
+    });
+    auth
+        .command('show')
+        .description('Show configured providers (keys partially masked)')
+        .action(() => {
+        const entries = (0, keys_js_1.listKeys)();
+        for (const [p, v] of Object.entries(entries)) {
+            const mask = v ? `${v.substring(0, 4)}…${v.substring(v.length - 4)}` : '—';
+            console.log(`${p.padEnd(18)} ${mask}`);
+        }
+    });
+    auth
+        .command('clear')
+        .description('Clear a stored API key')
+        .requiredOption('--provider <provider>', 'Provider id')
+        .action((opts) => {
+        (0, keys_js_1.clearApiKey)(opts.provider);
+        console.log(chalk_1.default.yellow(`Cleared API key for ${opts.provider}.`));
+    });
+}
+//# sourceMappingURL=auth.js.map

package/dist/cli/session.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerSessionCommands(program: Command): void;
+//# sourceMappingURL=session.d.ts.map

package/dist/cli/session.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSessionCommands = registerSessionCommands;
+const chalk_1 = __importDefault(require("chalk"));
+const store_js_1 = require("../session/store.js");
+function registerSessionCommands(program) {
+    const sess = program.command('session').description('Manage and inspect Snow-Flow sessions');
+    sess
+        .command('list')
+        .description('List recent sessions')
+        .action(() => {
+        const rows = (0, store_js_1.listSessions)().slice(0, 30);
+        if (!rows.length)
+            return console.log('No sessions yet.');
+        for (const r of rows) {
+            console.log(`${chalk_1.default.gray(r.startedAt)}  ${chalk_1.default.cyan(r.id)}  ${r.objective}`);
+        }
+    });
+    sess
+        .command('show <id>')
+        .description('Show session details')
+        .action((id) => {
+        const rec = (0, store_js_1.readSession)(id);
+        if (!rec)
+            return console.error(chalk_1.default.red('Session not found.'));
+        console.log(chalk_1.default.cyan(`Session ${rec.id}`));
+        console.log(`${chalk_1.default.gray(rec.startedAt)} → ${chalk_1.default.gray(rec.endedAt ?? '…')}`);
+        console.log('Objective:', rec.objective);
+        console.log('Provider:', `${rec.provider.id} ${rec.provider.model}`);
+        console.log('MCP:', `${rec.mcp.cmd} ${(rec.mcp.args || []).join(' ')}`);
+        console.log('\nMessages:');
+        for (const m of rec.messages) {
+            console.log(`- ${chalk_1.default.yellow(m.role)} ${chalk_1.default.gray(m.timestamp)}\n  ${m.content.slice(0, 400)}${m.content.length > 400 ? '…' : ''}`);
+        }
+        if (rec.toolEvents?.length) {
+            console.log('\nTool events:');
+            for (const ev of rec.toolEvents) {
+                console.log(`  🔧 ${ev.name} ${chalk_1.default.gray(ev.when)} ${ev.argsPreview ? ('args:' + ev.argsPreview) : ''} ${ev.resultPreview ? ('res:' + ev.resultPreview) : ''}`);
+            }
+        }
+    });
+}
+//# sourceMappingURL=session.js.map

package/dist/cli.js

@@ -53,6 +53,11 @@ const agent_detector_js_1 = require("./utils/agent-detector.js");
 const version_js_1 = require("./version.js");
 const logger_js_1 = require("./utils/logger.js");
 const chalk_1 = __importDefault(require("chalk"));
+// New provider-agnostic engine imports (compile-safe placeholders)
+const llm_config_loader_js_1 = require("./config/llm-config-loader.js");
+const interactive_js_1 = require("./agent/interactive.js");
+const auth_js_1 = require("./cli/auth.js");
+const session_js_1 = require("./cli/session.js");
 // Load environment variables
 dotenv_1.default.config();
 // Create CLI logger instance
@@ -62,6 +67,10 @@ program
     .name('snow-flow')
     .description('ServiceNow Multi-Agent Development Framework')
     .version(version_js_1.VERSION);
+// Register auth commands (API key management)
+(0, auth_js_1.registerAuthCommands)(program);
+// Register session inspection commands
+(0, session_js_1.registerSessionCommands)(program);
 // Flow deprecation handler - check for flow-related commands
 function checkFlowDeprecation(command, objective) {
     const flowKeywords = ['flow', 'create-flow', 'xml-flow', 'flow-designer'];
@@ -90,6 +99,18 @@ function checkFlowDeprecation(command, objective) {
 program
     .command('swarm <objective>')
     .description('Execute multi-agent orchestration for a ServiceNow task - één command voor alles!')
+    // New engine selector: defaults to auto (uses config-driven agent when available)
+    .option('--engine <engine>', 'Execution engine (auto|agent|claude)', 'auto')
+    .option('--config <path>', 'Path to snowflow.config file')
+    .option('--show-reasoning', 'Show LLM reasoning in a different color (default)', true)
+    .option('--no-show-reasoning', 'Hide LLM reasoning blocks')
+    .option('--save-output <path>', 'Save full assistant output to a file')
+    .option('--resume <sessionId>', 'Resume an existing interactive session')
+    // Provider overrides (optional, config-driven by default)
+    .option('--provider <provider>', 'LLM provider override')
+    .option('--model <model>', 'Model override')
+    .option('--base-url <url>', 'Base URL override for openai-compatible or gateways')
+    .option('--api-key-env <name>', 'Use specific API key env var')
     .option('--strategy <strategy>', 'Execution strategy (development, _analysis, research)', 'development')
     .option('--mode <mode>', 'Coordination mode (hierarchical, mesh, distributed)', 'hierarchical')
     .option('--max-agents <number>', 'Maximum number of agents', '5')
@@ -266,6 +287,66 @@ program
             cliLogger.info(`🤖 Autonomous Systems: ❌ All Disabled`);
         }
     }
+    // Detect agent engine via config (provider-agnostic) when requested or available
+    const shouldUseAgent = (() => {
+        if (options.engine === 'agent')
+            return true;
+        if (options.engine === 'claude')
+            return false;
+        // auto: use agent when config file is present and valid
+        const cfg = (0, llm_config_loader_js_1.loadSnowFlowConfig)({
+            configPath: options.config,
+            overrides: {
+                llm: {
+                    provider: options.provider || undefined,
+                    model: options.model || undefined,
+                    baseURL: options.baseUrl || options.baseURL || undefined,
+                    apiKeyEnv: options.apiKeyEnv || undefined,
+                },
+            },
+        });
+        return Boolean(cfg && cfg.llm && cfg.llm.provider && cfg.llm.model);
+    })();
+    if (shouldUseAgent) {
+        const cfg = (0, llm_config_loader_js_1.loadSnowFlowConfig)({
+            configPath: options.config,
+            overrides: {
+                llm: {
+                    provider: options.provider || undefined,
+                    model: options.model || undefined,
+                    baseURL: options.baseUrl || options.baseURL || undefined,
+                    apiKeyEnv: options.apiKeyEnv || undefined,
+                },
+            },
+        });
+        if (!cfg) {
+            cliLogger.error('❌ Geen snowflow.config.(json|js|cjs) gevonden. Voeg config toe of gebruik --engine claude.');
+            process.exit(1);
+        }
+        // Basic validation for MVP
+        if (!cfg.llm?.provider || !cfg.llm?.model) {
+            cliLogger.error('❌ Config mist llm.provider of llm.model');
+            process.exit(1);
+        }
+        cliLogger.info('\n🤖 Using provider-agnostic Snow-Flow agent (interactive)');
+        try {
+            await (0, interactive_js_1.runInteractive)({
+                provider: cfg.llm.provider,
+                model: String(cfg.llm.model),
+                baseURL: cfg.llm.baseURL,
+                apiKeyEnv: cfg.llm.apiKeyEnv,
+                mcp: cfg.mcp,
+                system: cfg.agent?.system,
+                maxSteps: cfg.agent?.maxSteps ?? 40,
+                showReasoning: options.showReasoning !== false,
+                resumeId: options.resume || undefined,
+            });
+        }
+        catch (e) {
+            cliLogger.error('❌ Interactive agent error:', e instanceof Error ? e.message : String(e));
+        }
+        return; // end here; skip legacy Claude path
+    }
     // Analyze the objective using intelligent agent detection
     const taskAnalysis = analyzeObjective(objective, parseInt(options.maxAgents));
     // Debug logging to understand task type detection

package/dist/config/llm-config-loader.d.ts

@@ -0,0 +1,31 @@
+export type ProviderId = 'openai' | 'google' | 'openrouter' | 'openai-compatible' | 'ollama' | 'anthropic';
+export interface SnowFlowConfig {
+    profile?: string;
+    mcp: {
+        cmd: string;
+        args?: string[];
+        env?: Record<string, string>;
+    };
+    llm: {
+        provider: ProviderId;
+        model: string;
+        baseURL?: string;
+        apiKeyEnv?: string;
+        extraBody?: Record<string, unknown>;
+    };
+    agent?: {
+        system?: string;
+        maxSteps?: number;
+    };
+    logging?: {
+        level?: 'info' | 'debug' | 'trace';
+    };
+    profiles?: Record<string, Partial<SnowFlowConfig>>;
+}
+export declare function findConfigPath(customPath?: string): string | undefined;
+export declare function loadSnowFlowConfig(opts?: {
+    configPath?: string;
+    profile?: string;
+    overrides?: Partial<SnowFlowConfig>;
+}): SnowFlowConfig | undefined;
+//# sourceMappingURL=llm-config-loader.d.ts.map

package/dist/config/llm-config-loader.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findConfigPath = findConfigPath;
+exports.loadSnowFlowConfig = loadSnowFlowConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function tryLoadModule(modulePath) {
+    // CommonJS require for .js/.cjs; JSON via fs; YAML/TS not supported in MVP
+    const ext = path_1.default.extname(modulePath).toLowerCase();
+    if (ext === '.json') {
+        const raw = fs_1.default.readFileSync(modulePath, 'utf8');
+        return JSON.parse(raw);
+    }
+    if (ext === '.js' || ext === '.cjs') {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const mod = require(modulePath);
+        return mod?.default ?? mod;
+    }
+    if (ext === '.yaml' || ext === '.yml') {
+        throw new Error(`YAML config detected (${ext}). Install 'yaml' and wire parsing, or use JSON/JS/CJS now.`);
+    }
+    if (ext === '.ts') {
+        throw new Error(`TypeScript config detected (.ts). Use JS/CJS/JSON or set up ts-node/tsx runtime.`);
+    }
+    if (ext === '.mjs') {
+        throw new Error(`.mjs config not supported in MVP. Convert to .js/.cjs or use JSON.`);
+    }
+    throw new Error(`Unsupported config extension: ${ext}`);
+}
+function findConfigPath(customPath) {
+    const fromFlag = customPath?.trim();
+    if (fromFlag && fs_1.default.existsSync(fromFlag))
+        return path_1.default.resolve(fromFlag);
+    const fromEnv = process.env.SNOWFLOW_CONFIG?.trim();
+    if (fromEnv && fs_1.default.existsSync(fromEnv))
+        return path_1.default.resolve(fromEnv);
+    const candidates = [
+        'snowflow.config.json',
+        'snowflow.config.js',
+        'snowflow.config.cjs',
+        // reserved for later: yaml/yml/mjs/ts
+    ];
+    for (const name of candidates) {
+        const p = path_1.default.resolve(process.cwd(), name);
+        if (fs_1.default.existsSync(p))
+            return p;
+    }
+    return undefined;
+}
+function loadSnowFlowConfig(opts) {
+    const configPath = findConfigPath(opts?.configPath);
+    if (!configPath)
+        return undefined;
+    const raw = tryLoadModule(configPath);
+    const base = {
+        profile: raw.profile || 'default',
+        mcp: raw.mcp || { cmd: 'node', args: ['dist/mcp/index.js'] },
+        llm: raw.llm,
+        agent: raw.agent || {},
+        logging: raw.logging || { level: 'info' },
+        profiles: raw.profiles || {},
+    };
+    const activeProfile = (opts?.profile || process.env.SNOWFLOW_PROFILE || base.profile || 'default');
+    const profileOverrides = (base.profiles && base.profiles[activeProfile]) || {};
+    // shallow merge base + profile + overrides
+    const merged = {
+        ...base,
+        ...profileOverrides,
+        ...(opts?.overrides || {}),
+        mcp: { ...(base.mcp || {}), ...(profileOverrides.mcp || {}), ...(opts?.overrides?.mcp || {}) },
+        llm: { ...(base.llm || {}), ...(profileOverrides.llm || {}), ...(opts?.overrides?.llm || {}) },
+        agent: { ...(base.agent || {}), ...(profileOverrides.agent || {}), ...(opts?.overrides?.agent || {}) },
+        logging: { ...(base.logging || {}), ...(profileOverrides.logging || {}), ...(opts?.overrides?.logging || {}) },
+    };
+    return merged;
+}
+//# sourceMappingURL=llm-config-loader.js.map

package/dist/dynamic-version.js

@@ -36,7 +36,7 @@ function getDynamicVersion() {
         console.warn('Warning: Could not read version from package.json:', error);
     }
     // Fallback to hardcoded version
-    return '3.6.25';
+    return '4.0.0-final-claude';
 }
 // Export a constant that uses the dynamic version
 exports.VERSION = getDynamicVersion();

package/dist/llm/keys.d.ts

@@ -0,0 +1,5 @@
+export declare function setApiKey(provider: string, value: string): void;
+export declare function getApiKey(provider: string): string | undefined;
+export declare function clearApiKey(provider: string): void;
+export declare function listKeys(): Record<string, string | undefined>;
+//# sourceMappingURL=keys.d.ts.map

package/dist/llm/keys.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setApiKey = setApiKey;
+exports.getApiKey = getApiKey;
+exports.clearApiKey = clearApiKey;
+exports.listKeys = listKeys;
+const conf_1 = __importDefault(require("conf"));
+// Avoid generic type for broader compatibility with shimmed types
+const store = new conf_1.default({ projectName: 'snow-flow' });
+function setApiKey(provider, value) {
+    store.set(`keys.${provider}`, value);
+}
+function getApiKey(provider) {
+    return store.get(`keys.${provider}`);
+}
+function clearApiKey(provider) {
+    store.delete(`keys.${provider}`);
+}
+function listKeys() {
+    const providers = ['openai', 'google', 'openrouter', 'openai-compatible', 'ollama'];
+    const out = {};
+    for (const p of providers)
+        out[p] = getApiKey(p);
+    return out;
+}
+//# sourceMappingURL=keys.js.map

package/dist/llm/providers.d.ts

@@ -0,0 +1,11 @@
+import type { SnowFlowConfig } from '../config/llm-config-loader';
+export type ProviderId = SnowFlowConfig['llm']['provider'];
+export interface ProviderOptions {
+    provider: ProviderId;
+    model: string;
+    baseURL?: string;
+    apiKeyEnv?: string;
+    extraBody?: Record<string, unknown>;
+}
+export declare function getModel(opts: ProviderOptions): unknown;
+//# sourceMappingURL=providers.d.ts.map

package/dist/llm/providers.js

@@ -0,0 +1,77 @@
+"use strict";
+// Compile-safe placeholder registry. Real providers will be wired via AI SDK in a follow-up step.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModel = getModel;
+const keys_js_1 = require("./keys.js");
+function getModel(opts) {
+    const { provider, model, baseURL, apiKeyEnv, extraBody } = opts;
+    const requireOrThrow = (name) => {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            return require(name);
+        }
+        catch (err) {
+            const hint = `Missing dependency ${name}. Run: npm i ai @ai-sdk/openai @ai-sdk/google @openrouter/ai-sdk-provider`;
+            throw new Error(hint);
+        }
+    };
+    switch (provider) {
+        case 'anthropic': {
+            // Prefer AI SDK anthropic provider if installed; otherwise instruct
+            try {
+                // Dynamic require to avoid hard dep
+                const anthropic = require('@ai-sdk/anthropic');
+                const key = process.env[apiKeyEnv || 'ANTHROPIC_API_KEY'] || (0, keys_js_1.getApiKey)('anthropic');
+                if (!key)
+                    throw new Error('Missing ANTHROPIC_API_KEY');
+                return anthropic.anthropic({ apiKey: key, baseURL }).languageModel(model);
+            }
+            catch (e) {
+                throw new Error('Anthropic provider not available. Install @ai-sdk/anthropic or use OpenRouter with an Anthropic model.');
+            }
+        }
+        case 'openai': {
+            const { openai } = requireOrThrow('@ai-sdk/openai');
+            const apiKey = process.env[apiKeyEnv || 'OPENAI_API_KEY'] || (0, keys_js_1.getApiKey)('openai');
+            if (!apiKey)
+                throw new Error('Missing OPENAI_API_KEY');
+            return openai({ apiKey, baseURL }).languageModel(model);
+        }
+        case 'google': {
+            const { google } = requireOrThrow('@ai-sdk/google');
+            const apiKey = process.env[apiKeyEnv || 'GOOGLE_API_KEY']
+                || process.env['GOOGLE_GENERATIVE_AI_API_KEY']
+                || (0, keys_js_1.getApiKey)('google');
+            if (!apiKey)
+                throw new Error('Missing GOOGLE_API_KEY or GOOGLE_GENERATIVE_AI_API_KEY');
+            return google({ apiKey, baseURL }).languageModel(model);
+        }
+        case 'openrouter': {
+            const { createOpenRouter } = requireOrThrow('@openrouter/ai-sdk-provider');
+            const apiKey = process.env[apiKeyEnv || 'OPENROUTER_API_KEY'] || (0, keys_js_1.getApiKey)('openrouter');
+            if (!apiKey)
+                throw new Error('Missing OPENROUTER_API_KEY');
+            const or = createOpenRouter({ apiKey, baseURL, extraBody });
+            return or(model);
+        }
+        case 'openai-compatible': {
+            const { openai } = requireOrThrow('@ai-sdk/openai');
+            const keyName = apiKeyEnv || 'OPENAI_COMPAT_API_KEY';
+            const apiKey = process.env[keyName] || (0, keys_js_1.getApiKey)('openai-compatible');
+            if (!baseURL)
+                throw new Error('openai-compatible requires baseURL');
+            if (!apiKey)
+                throw new Error(`Missing ${keyName}`);
+            return openai({ apiKey, baseURL }).languageModel(model);
+        }
+        case 'ollama': {
+            const { openai } = requireOrThrow('@ai-sdk/openai');
+            const keyName = apiKeyEnv || 'OLLAMA_API_KEY';
+            const apiKey = process.env[keyName] || (0, keys_js_1.getApiKey)('ollama');
+            if (!baseURL)
+                throw new Error('ollama requires baseURL (e.g., http://localhost:11434/v1)');
+            return openai({ apiKey, baseURL }).languageModel(model);
+        }
+    }
+}
+//# sourceMappingURL=providers.js.map

package/dist/mcp/bridge.d.ts

@@ -0,0 +1,10 @@
+export interface MCPStartup {
+    cmd: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export declare function loadMCPTools(start: MCPStartup): Promise<{
+    tools: any[];
+    close: () => Promise<void>;
+}>;
+//# sourceMappingURL=bridge.d.ts.map

package/dist/mcp/bridge.js

@@ -0,0 +1,31 @@
+"use strict";
+// Minimal MCP bridge placeholder. We will hook this into AI SDK tools in a next step.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMCPTools = loadMCPTools;
+async function loadMCPTools(start) {
+    // Prefer using AI SDK's experimental MCP client to yield ready-to-use Tool[]
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { experimental_createMCPClient } = require('ai');
+        // Use SDK-provided stdio transport
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { StdioClientTransport } = require('@modelcontextprotocol/sdk/client/stdio');
+        const client = await experimental_createMCPClient({
+            name: 'snow-flow',
+            transport: new StdioClientTransport({
+                command: start.cmd,
+                args: start.args ?? [],
+                env: start.env ?? {},
+            }),
+        });
+        const tools = await client.tools();
+        return { tools, close: client.close };
+    }
+    catch (err) {
+        // Fallback: no AI SDK available, return empty tools and noop close but with a hint.
+        const hint = 'AI SDK MCP bridge not available. Install "ai" or verify version to enable MCP tools.';
+        console.warn(`[snow-flow] ${hint}`);
+        return { tools: [], close: async () => { } };
+    }
+}
+//# sourceMappingURL=bridge.js.map

package/dist/session/store.d.ts

@@ -0,0 +1,47 @@
+export interface SessionMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    timestamp: string;
+    meta?: Record<string, unknown>;
+}
+export interface SessionRecord {
+    id: string;
+    startedAt: string;
+    endedAt?: string;
+    objective: string;
+    provider: {
+        id: string;
+        model: string;
+        baseURL?: string;
+    };
+    mcp: {
+        cmd: string;
+        args?: string[];
+    };
+    messages: SessionMessage[];
+    toolEvents?: {
+        name: string;
+        when: string;
+        argsPreview?: string;
+        resultPreview?: string;
+    }[];
+    summary?: string;
+}
+export declare function createSessionId(): string;
+export declare function startSession(rec: Omit<SessionRecord, 'messages' | 'toolEvents'> & {
+    messages?: SessionMessage[];
+}): SessionRecord;
+export declare function readSession(id: string): SessionRecord | undefined;
+export declare function listSessions(): {
+    id: string;
+    startedAt: string;
+    objective: string;
+}[];
+export declare function appendMessage(id: string, msg: SessionMessage): void;
+export declare function appendToolEvent(id: string, ev: {
+    name: string;
+    argsPreview?: string;
+    resultPreview?: string;
+}): void;
+export declare function endSession(id: string, summary?: string): void;
+//# sourceMappingURL=store.d.ts.map

package/dist/session/store.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSessionId = createSessionId;
+exports.startSession = startSession;
+exports.readSession = readSession;
+exports.listSessions = listSessions;
+exports.appendMessage = appendMessage;
+exports.appendToolEvent = appendToolEvent;
+exports.endSession = endSession;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+function ensureDir(dir) {
+    if (!fs_1.default.existsSync(dir))
+        fs_1.default.mkdirSync(dir, { recursive: true });
+}
+function sessionsDir() {
+    const dir = path_1.default.join(os_1.default.homedir(), '.snow-flow', 'sessions');
+    ensureDir(dir);
+    return dir;
+}
+function createSessionId() {
+    return `sess_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function sessionPath(id) {
+    return path_1.default.join(sessionsDir(), `${id}.json`);
+}
+function startSession(rec) {
+    const full = { ...rec, messages: rec.messages ?? [], toolEvents: [] };
+    fs_1.default.writeFileSync(sessionPath(rec.id), JSON.stringify(full, null, 2), 'utf8');
+    return full;
+}
+function readSession(id) {
+    const p = sessionPath(id);
+    if (!fs_1.default.existsSync(p))
+        return undefined;
+    return JSON.parse(fs_1.default.readFileSync(p, 'utf8'));
+}
+function listSessions() {
+    const dir = sessionsDir();
+    const files = fs_1.default.readdirSync(dir).filter(f => f.endsWith('.json'));
+    return files.map(f => {
+        const rec = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, f), 'utf8'));
+        return { id: rec.id, startedAt: rec.startedAt, objective: rec.objective };
+    }).sort((a, b) => (a.startedAt < b.startedAt ? 1 : -1));
+}
+function appendMessage(id, msg) {
+    const rec = readSession(id);
+    if (!rec)
+        return;
+    rec.messages.push(msg);
+    fs_1.default.writeFileSync(sessionPath(id), JSON.stringify(rec, null, 2), 'utf8');
+}
+function appendToolEvent(id, ev) {
+    const rec = readSession(id);
+    if (!rec)
+        return;
+    const item = { name: ev.name, when: new Date().toISOString(), argsPreview: ev.argsPreview, resultPreview: ev.resultPreview };
+    (rec.toolEvents = rec.toolEvents || []).push(item);
+    fs_1.default.writeFileSync(sessionPath(id), JSON.stringify(rec, null, 2), 'utf8');
+}
+function endSession(id, summary) {
+    const rec = readSession(id);
+    if (!rec)
+        return;
+    rec.endedAt = new Date().toISOString();
+    if (summary)
+        rec.summary = summary;
+    fs_1.default.writeFileSync(sessionPath(id), JSON.stringify(rec, null, 2), 'utf8');
+}
+//# sourceMappingURL=store.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "3.6.25",
-  "description": "KNOWLEDGE BASE VERIFICATION - v3.6.25 adds critical validation to snow_create_knowledge_article. Now throws error when non-existent knowledge base is specified, preventing orphaned articles. Includes helpful suggestions to create or discover valid knowledge bases.",
+  "version": "4.0.0-final-claude",
+  "description": "FINAL CLAUDE CODE CLI EDITION - This is the last version specifically designed for Claude Code CLI. Future versions will support multiple LLMs (OpenAI, Google, Anthropic, Ollama, etc.) through a modular provider system. Thank you to all Claude Code users!",
   "main": "dist/index.js",
   "type": "commonjs",
   "bin": {
@@ -396,10 +396,15 @@
     "npm": ">=8.0.0"
   },
   "dependencies": {
-    "@tensorflow/tfjs-node": "^4.22.0",
+    "@ai-sdk/anthropic": "^2.0.4",
+    "@ai-sdk/google": "^1.2.22",
+    "@ai-sdk/openai": "^1.3.24",
     "@modelcontextprotocol/sdk": "^1.15.1",
+    "@openrouter/ai-sdk-provider": "^1.1.2",
+    "@tensorflow/tfjs-node": "^4.22.0",
     "@types/node-fetch": "^2.6.12",
     "@types/uuid": "^10.0.0",
+    "ai": "^5.0.14",
     "axios": "^1.10.0",
     "better-sqlite3": "^9.6.0",
     "boxen": "^8.0.1",

package/snowflow.config.json

@@ -0,0 +1,15 @@
+{
+  "profile": "default",
+  "mcp": { "cmd": "node", "args": ["dist/mcp/index.js"] },
+  "llm": {
+    "provider": "openai",
+    "model": "gpt-5",
+    "apiKeyEnv": "OPENAI_API_KEY"
+  },
+  "agent": { "system": "You are Snow-Flow, a precise ServiceNow engineering agent.", "maxSteps": 50 },
+  "logging": { "level": "info" },
+  "profiles": {
+    "dev": { "logging": { "level": "debug" } },
+    "prod": { "agent": { "maxSteps": 60 } }
+  }
+}