iranti 0.2.2 → 0.2.4

package/dist/scripts/iranti-mcp.js

@@ -144,7 +144,7 @@ async function main() {
     await ensureDefaultAgent(iranti);
     const server = new mcp_js_1.McpServer({
         name: 'iranti-mcp',
-        version: '0.2.2',
+        version: '0.2.4',
     });
     server.registerTool('iranti_handshake', {
         description: `Initialize or refresh an agent's working-memory brief for the current task.

package/dist/scripts/seed.js

@@ -15,7 +15,7 @@ const STAFF_ENTRIES = [
         entityId: 'librarian',
         key: 'operating_rules',
         valueRaw: {
-            version: '0.2.2',
+            version: '0.2.4',
             rules: [
                 'All writes from external agents go through the Librarian — never directly to the database',
                 'Check for existing entries before every write',
@@ -39,7 +39,7 @@ const STAFF_ENTRIES = [
         entityId: 'attendant',
         key: 'operating_rules',
         valueRaw: {
-            version: '0.2.2',
+            version: '0.2.4',
             rules: [
                 'Assigned one-per-external-agent — serve the agent, not the user',
                 'On handshake: read AGENTS.md and MCP config, query Librarian for relevant rules and task context',
@@ -61,7 +61,7 @@ const STAFF_ENTRIES = [
         entityId: 'archivist',
         key: 'operating_rules',
         valueRaw: {
-            version: '0.2.2',
+            version: '0.2.4',
             rules: [
                 'Run on schedule or when conflict flags exceed threshold — not on every write',
                 'Scan for expired, low-confidence, flagged, and duplicate entries',
@@ -82,7 +82,7 @@ const STAFF_ENTRIES = [
         entityType: 'system',
         entityId: 'library',
         key: 'schema_version',
-        valueRaw: { version: '0.2.2' },
+        valueRaw: { version: '0.2.4' },
         valueSummary: 'Current Library schema version.',
         confidence: 100,
         source: 'seed',
@@ -95,7 +95,7 @@ const STAFF_ENTRIES = [
         key: 'initialization_log',
         valueRaw: {
             initializedAt: new Date().toISOString(),
-            seedVersion: '0.2.2',
+            seedVersion: '0.2.4',
         },
         valueSummary: 'Record of when and how this Library was initialized.',
         confidence: 100,
@@ -108,7 +108,7 @@ const STAFF_ENTRIES = [
         entityId: 'ontology',
         key: 'core_schema',
         valueRaw: {
-            version: '0.2.2',
+            version: '0.2.4',
             states: ['candidate', 'provisional', 'canonical'],
             coreEntityTypes: [
                 'person',
@@ -156,7 +156,7 @@ const STAFF_ENTRIES = [
         entityId: 'ontology',
         key: 'extension_registry',
         valueRaw: {
-            version: '0.2.2',
+            version: '0.2.4',
             namespaces: {
                 education: {
                     status: 'provisional',
@@ -187,7 +187,7 @@ const STAFF_ENTRIES = [
         entityId: 'ontology',
         key: 'candidate_terms',
         valueRaw: {
-            version: '0.2.2',
+            version: '0.2.4',
             terms: [],
         },
         valueSummary: 'Staging area for ontology terms detected repeatedly but not yet promoted.',
@@ -201,7 +201,7 @@ const STAFF_ENTRIES = [
         entityId: 'ontology',
         key: 'promotion_policy',
         valueRaw: {
-            version: '0.2.2',
+            version: '0.2.4',
             candidateToProvisional: {
                 minSeenCount: 3,
                 minDistinctAgents: 2,
@@ -237,7 +237,7 @@ const STAFF_ENTRIES = [
         entityId: 'ontology',
         key: 'change_log',
         valueRaw: {
-            version: '0.2.2',
+            version: '0.2.4',
             events: [
                 {
                     at: new Date().toISOString(),

package/dist/src/api/server.js

@@ -69,7 +69,7 @@ app.use(express_1.default.json({ limit: process.env.IRANTI_MAX_BODY_BYTES ?? '25
 app.get(ROUTES.health, (_req, res) => {
     res.json({
         status: 'ok',
-        version: '0.2.2',
+        version: '0.2.4',
         provider: process.env.LLM_PROVIDER ?? 'mock',
     });
 });

package/dist/src/chat/index.d.ts

@@ -0,0 +1,8 @@
+export type ChatSessionOptions = {
+    agentId?: string;
+    provider?: string;
+    model?: string;
+    cwd?: string;
+};
+export declare function startChatSession(options?: ChatSessionOptions): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/chat/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/chat/index.ts"],"names":[],"mappings":"AA+FA,MAAM,MAAM,kBAAkB,GAAG;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAwOF,wBAAsB,gBAAgB,CAAC,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6XtF"}

package/dist/src/chat/index.js

@@ -0,0 +1,565 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startChatSession = startChatSession;
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const promises_2 = __importDefault(require("readline/promises"));
+const llm_1 = require("../lib/llm");
+const router_1 = require("../lib/router");
+const runtimeEnv_1 = require("../lib/runtimeEnv");
+const resolutionist_1 = require("../resolutionist");
+class ApiClient {
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    async request(method, route, body) {
+        const response = await fetch(`${this.baseUrl}${route}`, {
+            method,
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Iranti-Key': this.apiKey,
+            },
+            body: body === undefined ? undefined : JSON.stringify(body),
+        });
+        const text = await response.text();
+        const payload = text ? JSON.parse(text) : null;
+        if (!response.ok) {
+            const error = typeof payload?.error === 'string' ? payload.error : `API error ${response.status}`;
+            throw new Error(error);
+        }
+        return payload;
+    }
+    handshake(agentId) {
+        return this.request('POST', '/memory/handshake', {
+            agent: agentId,
+            task: 'Interactive chat session',
+            recentMessages: [],
+        });
+    }
+    attend(agentId, currentContext, latestMessage) {
+        return this.request('POST', '/memory/attend', {
+            agentId,
+            currentContext,
+            latestMessage,
+        });
+    }
+    observe(agentId, currentContext) {
+        return this.request('POST', '/memory/observe', {
+            agentId,
+            currentContext,
+        });
+    }
+    query(entity, key) {
+        const [entityType, entityId] = splitEntity(entity);
+        return this.request('GET', `/kb/query/${entityType}/${entityId}/${encodeURIComponent(key)}`);
+    }
+    queryAll(entity) {
+        const [entityType, entityId] = splitEntity(entity);
+        return this.request('GET', `/kb/query/${entityType}/${entityId}`);
+    }
+    history(entity, key) {
+        const [entityType, entityId] = splitEntity(entity);
+        return this.request('GET', `/kb/history/${entityType}/${entityId}/${encodeURIComponent(key)}`);
+    }
+    async search(query) {
+        const search = new URLSearchParams({ query });
+        const payload = await this.request('GET', `/kb/search?${search.toString()}`);
+        return payload.results;
+    }
+    write(agentId, entity, key, value, summary, confidence, source = 'iranti_chat') {
+        return this.request('POST', '/kb/write', {
+            entity,
+            key,
+            value,
+            summary,
+            confidence,
+            source,
+            agent: agentId,
+        });
+    }
+    relate(params) {
+        return this.request('POST', '/kb/relate', params);
+    }
+    related(entity) {
+        const [entityType, entityId] = splitEntity(entity);
+        return this.request('GET', `/kb/related/${entityType}/${entityId}`);
+    }
+}
+function splitEntity(entity) {
+    const trimmed = entity.trim();
+    const separator = trimmed.indexOf('/');
+    if (separator <= 0 || separator === trimmed.length - 1) {
+        throw new Error(`Invalid entity format: "${entity}". Expected entityType/entityId.`);
+    }
+    return [trimmed.slice(0, separator), trimmed.slice(separator + 1)];
+}
+function isStrictEntity(value) {
+    if (!value)
+        return false;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return false;
+    const parts = trimmed.split('/');
+    return parts.length === 2 && parts[0].length > 0 && parts[1].length > 0;
+}
+function tokenizeCommand(input) {
+    const matches = input.match(/"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|[^\s]+/g);
+    if (!matches)
+        return [];
+    return matches.map((token) => {
+        if ((token.startsWith('"') && token.endsWith('"')) || (token.startsWith('\'') && token.endsWith('\''))) {
+            return token.slice(1, -1);
+        }
+        return token;
+    });
+}
+function parseLooseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function formatJson(value) {
+    return typeof value === 'string' ? value : JSON.stringify(value);
+}
+function buildMemoryBlock(fact) {
+    return `[MEMORY: ${fact.entityKey}] ${fact.summary} | value=${formatJson(fact.value)} | confidence=${fact.confidence} | source=${fact.source}`;
+}
+function formatConversation(history) {
+    return history.map((turn) => `${turn.role.toUpperCase()}: ${turn.content}`).join('\n');
+}
+function buildPreamble(agentId, brief) {
+    const workingMemory = brief.workingMemory.length === 0
+        ? '- none loaded'
+        : brief.workingMemory
+            .slice(0, 10)
+            .map((entry) => `- ${entry.entityKey}: ${entry.summary} (${entry.confidence}, ${entry.source})`)
+            .join('\n');
+    return [
+        `You are chatting through Iranti.`,
+        `Agent ID: ${agentId}`,
+        `Inferred task: ${brief.inferredTaskType}`,
+        `Operating rules: ${brief.operatingRules}`,
+        'Known working memory:',
+        workingMemory,
+    ].join('\n');
+}
+function normalizeProvider(raw) {
+    const trimmed = raw?.trim().toLowerCase();
+    return trimmed && trimmed.length > 0 ? trimmed : undefined;
+}
+function resolveDefaultModel() {
+    return (0, router_1.getAllProfiles)().summarization.model;
+}
+function buildSummary(key, value) {
+    const raw = formatJson(value);
+    return `${key}: ${raw.length > 96 ? `${raw.slice(0, 93)}...` : raw}`;
+}
+function formatDate(value) {
+    if (!value)
+        return 'now';
+    return value.slice(0, 10);
+}
+function formatHistoryStatus(entry) {
+    if (entry.isCurrent)
+        return 'current';
+    if (entry.archivedReason)
+        return entry.archivedReason;
+    return 'historical';
+}
+function line(width) {
+    return '-'.repeat(width);
+}
+function resolveEscalationRoot() {
+    return path_1.default.resolve(process.env.IRANTI_ESCALATION_DIR ?? path_1.default.join(os_1.default.homedir(), '.iranti', 'escalation'));
+}
+async function hasPendingEscalations(root) {
+    const activeDir = path_1.default.join(root, 'active');
+    try {
+        const entries = await promises_1.default.readdir(activeDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith('.md')) {
+                continue;
+            }
+            const content = await promises_1.default.readFile(path_1.default.join(activeDir, entry.name), 'utf-8');
+            if (content.includes('**Status:** PENDING')) {
+                return true;
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+function printHelp() {
+    console.log('/memory                          show all memory facts for this session');
+    console.log('/search <query>                  search facts by keyword or concept');
+    console.log('/inject <entity> <key>           inject a specific fact into the next turn');
+    console.log('/write <key> <value> [conf]      write a fact to session memory');
+    console.log('/observe                         manually pull memory from conversation history');
+    console.log('/history <entity> <key>          show temporal history for a fact');
+    console.log('/relate <from> <to> <type>       create a relationship between two entities');
+    console.log('/related <entity>                show all relationships for an entity');
+    console.log('/resolve                         walk through pending conflict escalations');
+    console.log('/confidence <entity> <key> <n>   update confidence score for a fact (0-100)');
+    console.log('/clear                           clear conversation history');
+    console.log('/provider <name> [model]         switch LLM provider for this session');
+    console.log('/exit                            quit');
+}
+async function startChatSession(options = {}) {
+    (0, runtimeEnv_1.loadRuntimeEnv)({ cwd: options.cwd ?? process.cwd() });
+    const baseUrl = (process.env.IRANTI_URL ?? '').trim();
+    const apiKey = (process.env.IRANTI_API_KEY ?? '').trim();
+    if (!baseUrl) {
+        throw new Error('IRANTI_URL is required. Load .env.iranti or set IRANTI_URL before running iranti chat.');
+    }
+    if (!apiKey) {
+        throw new Error('IRANTI_API_KEY is required. Load .env.iranti or set IRANTI_API_KEY before running iranti chat.');
+    }
+    const supportedProviders = (0, llm_1.getSupportedProviders)();
+    const initialProvider = normalizeProvider(options.provider ?? process.env.LLM_PROVIDER) ?? 'mock';
+    if (!supportedProviders.includes(initialProvider)) {
+        throw new Error(`Unsupported provider "${initialProvider}". Available: ${supportedProviders.join(', ')}`);
+    }
+    process.env.LLM_PROVIDER = initialProvider;
+    const agentId = options.agentId?.trim() || 'iranti_chat';
+    const sessionEntity = `session/${agentId}`;
+    const client = new ApiClient(baseUrl.replace(/\/+$/, ''), apiKey);
+    let provider = initialProvider;
+    let model = options.model?.trim() || resolveDefaultModel();
+    let manualInjections = [];
+    const history = [];
+    const brief = await client.handshake(agentId);
+    console.log(`Iranti Chat — provider: ${provider}, model: ${model}`);
+    console.log('Type /help for commands. Ctrl+C to exit.');
+    if (brief.workingMemory.length > 0) {
+        console.log(`Loaded ${brief.workingMemory.length} memory entries.`);
+    }
+    const createInterface = () => promises_2.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    let rl = createInterface();
+    let closing = false;
+    const closeHandler = () => {
+        if (closing)
+            return;
+        closing = true;
+        console.log('\nExiting chat.');
+        rl.close();
+    };
+    process.on('SIGINT', closeHandler);
+    try {
+        while (!closing) {
+            const input = (await rl.question('> ')).trim();
+            if (!input) {
+                continue;
+            }
+            if (input.startsWith('/')) {
+                const parts = tokenizeCommand(input);
+                const command = parts[0]?.toLowerCase();
+                if (command === '/help') {
+                    printHelp();
+                    continue;
+                }
+                if (command === '/memory') {
+                    const facts = await client.queryAll(sessionEntity);
+                    if (facts.length === 0) {
+                        console.log('No memory entries for this session.');
+                        continue;
+                    }
+                    for (const fact of facts) {
+                        console.log(`${fact.key} | ${fact.summary} | ${fact.confidence} | ${fact.source}`);
+                    }
+                    continue;
+                }
+                if (command === '/search') {
+                    const query = input.replace(/^\/search\s*/i, '').trim();
+                    if (!query) {
+                        console.log('Usage: /search <query>');
+                        continue;
+                    }
+                    const results = await client.search(query);
+                    if (results.length === 0) {
+                        console.log('No search results.');
+                        continue;
+                    }
+                    for (const result of results) {
+                        console.log(`${result.entity} | ${result.key} | ${result.summary} | ${result.score.toFixed(3)}`);
+                    }
+                    continue;
+                }
+                if (command === '/inject') {
+                    if (parts.length < 3) {
+                        console.log('Usage: /inject <entity> <key>');
+                        continue;
+                    }
+                    const entity = parts[1];
+                    const key = parts[2];
+                    const fact = await client.query(entity, key);
+                    if (!fact.found) {
+                        console.log(`No fact found for ${entity}/${key}.`);
+                        continue;
+                    }
+                    manualInjections.push({
+                        entityKey: `${entity}/${key}`,
+                        summary: fact.summary ?? buildSummary(key, fact.value),
+                        value: fact.value,
+                        confidence: fact.confidence ?? 0,
+                        source: fact.source ?? 'unknown',
+                    });
+                    console.log(`Injected: [${entity}/${key}] ${fact.summary ?? buildSummary(key, fact.value)}`);
+                    continue;
+                }
+                if (command === '/write') {
+                    if (parts.length < 3) {
+                        console.log('Usage: /write <key> <value> [confidence]');
+                        continue;
+                    }
+                    const key = parts[1];
+                    const maybeConfidence = parts.length >= 4 ? Number.parseInt(parts[parts.length - 1], 10) : NaN;
+                    const hasConfidence = Number.isFinite(maybeConfidence);
+                    const rawValue = hasConfidence
+                        ? parts.slice(2, -1).join(' ')
+                        : parts.slice(2).join(' ');
+                    const confidence = hasConfidence ? maybeConfidence : 75;
+                    const value = parseLooseJson(rawValue);
+                    const result = await client.write(agentId, sessionEntity, key, value, buildSummary(key, value), confidence);
+                    console.log(`${result.action} | ${result.reason}`);
+                    continue;
+                }
+                if (command === '/observe') {
+                    const observed = await client.observe(agentId, formatConversation(history));
+                    if (observed.facts.length === 0) {
+                        console.log('Nothing to inject.');
+                        continue;
+                    }
+                    manualInjections = [...manualInjections, ...observed.facts];
+                    console.log(`Queued ${observed.facts.length} memory facts for the next turn.`);
+                    continue;
+                }
+                if (command === '/history') {
+                    if (parts.length < 3) {
+                        console.log('Usage: /history <entity> <key>');
+                        continue;
+                    }
+                    const entity = parts[1];
+                    const key = parts[2];
+                    if (!isStrictEntity(entity)) {
+                        console.log('Invalid entity format. Use entityType/entityId (e.g. project/acme).');
+                        continue;
+                    }
+                    try {
+                        const entries = await client.history(entity, key);
+                        if (entries.length === 0) {
+                            console.log(`No history found for ${entity}/${key}.`);
+                            continue;
+                        }
+                        const ordered = [...entries].sort((left, right) => left.validFrom.localeCompare(right.validFrom));
+                        console.log(`History: ${entity} -> ${key}`);
+                        console.log(line(53));
+                        ordered.forEach((entry, index) => {
+                            console.log(`  ${index + 1}. [${formatDate(entry.validFrom)} -> ${formatDate(entry.validUntil)}] ${formatJson(entry.value)}   conf:${entry.confidence}  source:${entry.source}  ${formatHistoryStatus(entry)}`);
+                        });
+                        console.log(line(53));
+                        console.log(`${ordered.length} interval${ordered.length === 1 ? '' : 's'}`);
+                    }
+                    catch (error) {
+                        console.log(error instanceof Error ? error.message : String(error));
+                    }
+                    continue;
+                }
+                if (command === '/relate') {
+                    if (parts.length < 4) {
+                        console.log('Usage: /relate <from> <to> <type>');
+                        continue;
+                    }
+                    const fromEntity = parts[1];
+                    const toEntity = parts[2];
+                    const relationshipType = parts.slice(3).join(' ').trim();
+                    if (!isStrictEntity(fromEntity) || !isStrictEntity(toEntity)) {
+                        console.log('Invalid entity format. Use entityType/entityId (e.g. project/acme).');
+                        continue;
+                    }
+                    if (!relationshipType) {
+                        console.log('Usage: /relate <from> <to> <type>');
+                        continue;
+                    }
+                    try {
+                        await client.relate({
+                            fromEntity,
+                            toEntity,
+                            relationshipType,
+                            createdBy: agentId,
+                        });
+                        console.log(`Related: ${fromEntity} -> ${toEntity} [${relationshipType}]`);
+                    }
+                    catch (error) {
+                        console.log(error instanceof Error ? error.message : String(error));
+                    }
+                    continue;
+                }
+                if (command === '/related') {
+                    if (parts.length < 2) {
+                        console.log('Invalid entity format. Use entityType/entityId (e.g. project/acme).');
+                        continue;
+                    }
+                    const entity = parts[1];
+                    if (!isStrictEntity(entity)) {
+                        console.log('Invalid entity format. Use entityType/entityId (e.g. project/acme).');
+                        continue;
+                    }
+                    try {
+                        const relationships = await client.related(entity);
+                        if (relationships.length === 0) {
+                            console.log(`No relationships found for ${entity}.`);
+                            continue;
+                        }
+                        console.log(`Related entities: ${entity}`);
+                        console.log(line(33));
+                        for (const relationship of relationships) {
+                            const arrow = relationship.direction === 'outbound' ? '->' : '<-';
+                            console.log(`  ${relationship.relationshipType} ${arrow} ${relationship.entityType}/${relationship.entityId}`);
+                        }
+                        console.log(line(33));
+                        console.log(`${relationships.length} relationship${relationships.length === 1 ? '' : 's'}`);
+                    }
+                    catch (error) {
+                        console.log(error instanceof Error ? error.message : String(error));
+                    }
+                    continue;
+                }
+                if (command === '/resolve') {
+                    try {
+                        const escalationRoot = resolveEscalationRoot();
+                        if (!(await hasPendingEscalations(escalationRoot))) {
+                            console.log('No pending escalations.');
+                            continue;
+                        }
+                        console.log(line(48));
+                        console.log('Resolutionist');
+                        console.log(line(48));
+                        rl.close();
+                        await (0, resolutionist_1.resolveInteractive)(escalationRoot);
+                        if (!closing) {
+                            rl = createInterface();
+                            console.log(line(48));
+                            console.log('Back in chat');
+                            console.log(line(48));
+                        }
+                    }
+                    catch (error) {
+                        if (!closing) {
+                            rl = createInterface();
+                        }
+                        console.log(error instanceof Error ? error.message : String(error));
+                    }
+                    continue;
+                }
+                if (command === '/confidence') {
+                    if (parts.length < 4) {
+                        console.log('Usage: /confidence <entity> <key> <new_value>');
+                        continue;
+                    }
+                    const entity = parts[1];
+                    const key = parts[2];
+                    const nextConfidence = Number.parseInt(parts[3], 10);
+                    if (!isStrictEntity(entity)) {
+                        console.log('Invalid entity format. Use entityType/entityId (e.g. project/acme).');
+                        continue;
+                    }
+                    if (!Number.isInteger(nextConfidence) || nextConfidence < 0 || nextConfidence > 100) {
+                        console.log('Confidence must be an integer between 0 and 100.');
+                        continue;
+                    }
+                    try {
+                        const current = await client.query(entity, key);
+                        if (!current.found) {
+                            console.log(`No fact found for ${entity}/${key}.`);
+                            continue;
+                        }
+                        const oldConfidence = current.confidence ?? 0;
+                        const value = current.value;
+                        const summary = current.summary ?? buildSummary(key, value);
+                        const result = await client.write(agentId, entity, key, value, summary, nextConfidence, current.source ?? 'iranti_chat');
+                        console.log(`confidence updated: ${oldConfidence} -> ${nextConfidence} | ${result.action}`);
+                    }
+                    catch (error) {
+                        console.log(error instanceof Error ? error.message : String(error));
+                    }
+                    continue;
+                }
+                if (command === '/clear') {
+                    history.length = 0;
+                    manualInjections = [];
+                    console.log('Conversation history cleared.');
+                    continue;
+                }
+                if (command === '/provider') {
+                    const nextProvider = normalizeProvider(parts[1]);
+                    if (!nextProvider) {
+                        console.log(`Usage: /provider <${supportedProviders.join('|')}> [model]`);
+                        continue;
+                    }
+                    if (!supportedProviders.includes(nextProvider)) {
+                        console.log(`Unsupported provider "${nextProvider}". Available: ${supportedProviders.join(', ')}`);
+                        continue;
+                    }
+                    provider = nextProvider;
+                    process.env.LLM_PROVIDER = nextProvider;
+                    model = parts[2]?.trim() || resolveDefaultModel();
+                    console.log(`Switched to provider: ${provider} (${model})`);
+                    continue;
+                }
+                if (command === '/exit' || command === '/quit') {
+                    closeHandler();
+                    continue;
+                }
+                console.log(`Unknown command: ${command}. Type /help for available commands.`);
+                continue;
+            }
+            const currentContext = formatConversation(history);
+            const attended = await client.attend(agentId, currentContext, input);
+            const autoBlocks = attended.shouldInject ? attended.facts.map(buildMemoryBlock) : [];
+            const manualBlocks = manualInjections.map(buildMemoryBlock);
+            const memoryBlocks = [...manualBlocks, ...autoBlocks];
+            manualInjections = [];
+            if (memoryBlocks.length > 0) {
+                console.log(`Injecting ${memoryBlocks.length} memory fact(s).`);
+            }
+            const messages = [
+                { role: 'user', content: buildPreamble(agentId, brief) },
+                ...history.map((turn) => ({ role: turn.role, content: turn.content })),
+                {
+                    role: 'user',
+                    content: [
+                        memoryBlocks.join('\n'),
+                        input,
+                    ].filter(Boolean).join('\n\n'),
+                },
+            ];
+            const response = await (0, llm_1.completeWithFallback)(messages, {
+                preferredProvider: provider,
+                model,
+            });
+            console.log(response.text.trim());
+            history.push({ role: 'user', content: input });
+            history.push({ role: 'assistant', content: response.text.trim() });
+            // observe() is retrieval-only in the current codebase; this background call just warms the next-turn memory path.
+            void client.observe(agentId, formatConversation(history)).catch(() => undefined);
+        }
+    }
+    finally {
+        process.off('SIGINT', closeHandler);
+        rl.close();
+    }
+}
+//# sourceMappingURL=index.js.map