if (minutes < 60) return `about ${minutes} minutes`;

const hours = Math.floor(minutes / 60);

const remainingMins = minutes % 60;

if (hours < 24) {

if (hours === 1 && remainingMins < 15) return 'about an hour';

if (hours === 1 && remainingMins >= 15 && remainingMins < 45) return 'about an hour and a half';

if (hours === 1) return 'nearly 2 hours';

if (remainingMins < 15) return `about ${hours} hours`;

if (remainingMins >= 30) return `about ${hours} and a half hours`;

return `about ${hours} hours`;

}

const days = Math.floor(hours / 24);

if (days === 1) return 'over a day';

return `about ${days} days`;

constructor({ config, conversationManager, personaManager, selfManager, jobManager, automationManager, memoryManager, shareQueue, characterManager, brainDB }) {

this.config = config;

this.conversationManager = conversationManager;

this.personaManager = personaManager;

this.selfManager = selfManager || null;

this.jobManager = jobManager;

this.automationManager = automationManager || null;

this.memoryManager = memoryManager || null;

this.shareQueue = shareQueue || null;

this.characterManager = characterManager || null;

this._brainDB = brainDB || null;

this.worldModel = null;

this.feedbackEngine = null;

this.causalMemory = null;

this.behavioralDNA = null;

this.synthesisLoop = null;

this.identityAwareness = null;

this.onboardingManager = null;

this.skillForge = new SkillForge({ agent: this, memoryManager, config });

this._activePersonaMd = null;

this._activeCharacterName = null;

this._activeCharacterId = null;

this._pending = new Map(); // chatId -> pending state

this._pendingOutcomes = new Map(); // jobId -> { timestamp, chatId, userId, characterId }

// Character-scoped conversation keys: prefix chatId with character ID

// so each character has isolated conversation history.

this._chatCallbacks = new Map(); // chatId -> { onUpdate, sendPhoto }

// Orchestrator provider (30s timeout — lean dispatch/summarize calls)

const orchProviderKey = config.orchestrator.provider || 'anthropic';

const orchProviderDef = PROVIDERS[orchProviderKey];

const orchApiKey = config.orchestrator.api_key || (orchProviderDef && process.env[orchProviderDef.envKey]);

this.orchestratorProvider = createProvider({

brain: {

provider: orchProviderKey,

model: config.orchestrator.model,

max_tokens: config.orchestrator.max_tokens,

temperature: config.orchestrator.temperature,

api_key: orchApiKey,

timeout: 30_000,

},

});

// Worker provider uses user's chosen brain

this.workerProvider = createProvider(config);

// Set up job lifecycle event listeners

this._setupJobListeners();

}

/** Build the orchestrator system prompt. */

_getSystemPrompt(chatId, user, temporalContext = null, identityCtx = null) {

const logger = getLogger();

const key = this._chatKey(chatId);

const skillIds = this.conversationManager.getSkills(key);

const skillPrompt = buildSkillPrompt(skillIds);

let userPersona = null;

if (this.personaManager && user?.id) {

userPersona = this.personaManager.getCompactPersona

? this.personaManager.getCompactPersona(user.id, user.username)

: this.personaManager.load(user.id, user.username);

}

let selfData = null;

if (this.behavioralDNA) {

try {

selfData = this.behavioralDNA.buildDNAContext(user?.id || null, this._activeCharacterId || 'default');

} catch (err) {

logger.warn(`[Orchestrator] BehavioralDNA context build failed: ${err.message}`);

}

}

if (!selfData && this.selfManager) {

selfData = this.selfManager.loadAll();

}

// Build memory context block (scope-filtered for non-owner)

let memoriesBlock = null;

if (this.memoryManager) {

let senderType = 'owner';

if (this.identityAwareness && user?.id) {

const sender = this.identityAwareness.getSender(String(user.id));

if (sender) senderType = sender.sender_type;

}

memoriesBlock = this.memoryManager.buildContextBlock(user?.id || null, senderType);

}

// Build share queue block

let sharesBlock = null;

if (this.shareQueue) {

sharesBlock = this.shareQueue.buildShareBlock(user?.id || null);

}

// Build forge expertise profile

const forgeExpertise = this.skillForge.buildExpertiseProfile();

const forgeSkillsSummary = this.skillForge.buildLearnedSkillsSummary();

// Build world model context

let worldContext = null;

if (this.worldModel) {

try {

worldContext = this.worldModel.buildWorldContext(this._activeCharacterId || 'default', user?.id || null);

} catch (err) {

logger.warn(`[Orchestrator] WorldModel context build failed: ${err.message}`);

}

}

// Build task intelligence from causal memory

let taskIntelligence = null;

if (this.causalMemory) {

try {

taskIntelligence = this.causalMemory.buildOrchestratorContext(this._activeCharacterId || 'default');

} catch (err) {

logger.warn(`[Orchestrator] Task intelligence build failed: ${err.message}`);

}

}

// Build feedback adjustments block

let adjustmentsBlock = null;

if (this.feedbackEngine) {

try {

adjustmentsBlock = this.feedbackEngine.buildAdjustmentBlock(

user?.id || null, this._activeCharacterId || 'default'

);

} catch (err) {

logger.warn(`[Orchestrator] Adjustment block build failed: ${err.message}`);

}

}

// Inject user training context from onboarding

if (this.onboardingManager && user?.id) {

try {

const onboardState = this.onboardingManager.getState(user.id);

if (onboardState?.phase === 'complete' && onboardState.training_notes) {

const notes = onboardState.training_notes;

const trainingLines = [];

if (notes.brand_voice) trainingLines.push(`- Brand voice: ${notes.brand_voice}`);

if (notes.workflows) trainingLines.push(`- Workflows: ${notes.workflows}`);

if (notes.custom_instructions) trainingLines.push(`- Instructions: ${notes.custom_instructions}`);

if (notes.tools) trainingLines.push(`- Tools: ${notes.tools}`);

if (trainingLines.length > 0) {

const trainingBlock = `\n## User Training Context\n${trainingLines.join('\n')}`;

userPersona = (userPersona || '') + trainingBlock;

}

}

} catch (err) {

logger.warn(`[Orchestrator] Training context build failed: ${err.message}`);

}

}

logger.debug(`Orchestrator building system prompt for chat ${chatId} | skills=${skillIds.length > 0 ? skillIds.join(',') : 'none'} | persona=${userPersona ? 'yes' : 'none'} | self=${selfData ? 'yes' : 'none'} | memories=${memoriesBlock ? 'yes' : 'none'} | shares=${sharesBlock ? 'yes' : 'none'} | temporal=${temporalContext ? 'yes' : 'none'} | character=${this._activeCharacterId || 'default'} | forge=${forgeExpertise ? 'yes' : 'none'} | world=${worldContext ? 'yes' : 'none'} | adjustments=${adjustmentsBlock ? 'yes' : 'none'} | causal=${taskIntelligence ? 'yes' : 'none'} | identity=${identityCtx ? 'yes' : 'none'}`);

return getOrchestratorPrompt(this.config, skillPrompt || null, userPersona, selfData, memoriesBlock, sharesBlock, temporalContext, this._activePersonaMd, this._activeCharacterName, forgeExpertise, forgeSkillsSummary, worldContext, adjustmentsBlock, taskIntelligence, identityCtx);

}

// ── Multi-skill methods ─────────────────────────────────────────────

/** Toggle a skill on/off for a chat. Returns { added: bool, skills: string[] }. */

toggleSkill(chatId, skillId) {

const key = this._chatKey(chatId);

const current = this.conversationManager.getSkills(key);

if (current.includes(skillId)) {

this.conversationManager.removeSkill(key, skillId);

return { added: false, skills: this.conversationManager.getSkills(key) };

}

const added = this.conversationManager.addSkill(key, skillId);

return { added, skills: this.conversationManager.getSkills(key) };

}

/** Get all active skill IDs for a chat. */

getActiveSkillIds(chatId) {

return this.conversationManager.getSkills(this._chatKey(chatId));

}

/** Get all active skill objects for a chat. */

getActiveSkills(chatId) {

const ids = this.getActiveSkillIds(chatId);

return ids.map(id => getSkillById(id)).filter(Boolean);

}

// Backward-compat aliases

setSkill(chatId, skillId) {

this.conversationManager.setSkill(this._chatKey(chatId), skillId);

}

clearSkill(chatId) {

this.conversationManager.clearSkills(this._chatKey(chatId));

}

getActiveSkill(chatId) {

const skills = this.getActiveSkills(chatId);

return skills.length > 0 ? skills[0] : null;

}

/**

async loadCharacter(characterId) {

const logger = getLogger();

if (!this.characterManager) return;

const ctx = await this.characterManager.buildContext(characterId, { brainDB: this._brainDB });

this._activeCharacterId = characterId;

this._activePersonaMd = ctx.personaMd;

this._activeCharacterName = ctx.profile.name;

this.selfManager = ctx.selfManager;

this.memoryManager = ctx.memoryManager;

this.shareQueue = ctx.shareQueue;

// Initialize WorldModel if BrainDB is available

if (this._brainDB?.isOpen && !this.worldModel) {

try {

const { WorldModel } = await import('./brain/world-model.js');

this.worldModel = new WorldModel(this._brainDB);

logger.info('[Agent] WorldModel initialized');

} catch (err) {

logger.warn(`[Agent] WorldModel init failed: ${err.message}`);

}

}

logger.info(`[Agent] Loaded character: ${ctx.profile.name} (${characterId})`);

return ctx;

}

/**

async switchCharacter(characterId) {

const logger = getLogger();

if (!this.characterManager) throw new Error('CharacterManager not available');

const ctx = await this.loadCharacter(characterId);

this.characterManager.setActiveCharacter(characterId);

logger.info(`[Agent] Switched to character: ${ctx.profile.name} (${characterId})`);

return ctx;

}

/** Get active character info for display. */

getActiveCharacterInfo() {

if (!this.characterManager) return null;

const id = this._activeCharacterId || this.characterManager.getActiveCharacterId();

return this.characterManager.getCharacter(id);

}

/**

_chatKey(chatId) {

if (this._activeCharacterId) {

return `${this._activeCharacterId}:${chatId}`;

}

return String(chatId);

}

/** Clear conversation history for a chat (character-scoped). */

clearConversation(chatId) {

this.conversationManager.clear(this._chatKey(chatId));

}

/** Get message count for a chat (character-scoped). */

getMessageCount(chatId) {

return this.conversationManager.getMessageCount(this._chatKey(chatId));

}

/** Get conversation history for a chat (character-scoped). */

getConversationHistory(chatId) {

return this.conversationManager.getHistory(this._chatKey(chatId));

}

/** Return current worker brain info for display. */

getBrainInfo() {

const { provider, model } = this.config.brain;

const providerDef = PROVIDERS[provider];

const providerName = providerDef ? providerDef.name : provider;

const modelEntry = providerDef?.models.find((m) => m.id === model);

const modelLabel = modelEntry ? modelEntry.label : model;

return { provider, providerName, model, modelLabel };

}

/** Return current orchestrator info for display. */

getOrchestratorInfo() {

const provider = this.config.orchestrator.provider || 'anthropic';

const model = this.config.orchestrator.model;

const providerDef = PROVIDERS[provider];

const providerName = providerDef ? providerDef.name : provider;

const modelEntry = providerDef?.models.find((m) => m.id === model);

const modelLabel = modelEntry ? modelEntry.label : model;

return { provider, providerName, model, modelLabel };

}

/** Switch orchestrator provider/model at runtime. */

async switchOrchestrator(providerKey, modelId) {

const logger = getLogger();

const providerDef = PROVIDERS[providerKey];

if (!providerDef) return `Unknown provider: ${providerKey}`;

const envKey = providerDef.envKey;

const apiKey = process.env[envKey];

if (!apiKey) return envKey;

try {

const testProvider = createProvider({

brain: {

provider: providerKey,

model: modelId,

max_tokens: this.config.orchestrator.max_tokens,

temperature: this.config.orchestrator.temperature,

api_key: apiKey,

timeout: 30_000,

},

});

await testProvider.ping();

this.config.orchestrator.provider = providerKey;

this.config.orchestrator.model = modelId;

this.config.orchestrator.api_key = apiKey;

this.orchestratorProvider = testProvider;

saveOrchestratorToYaml(providerKey, modelId);

logger.info(`Orchestrator switched to ${providerDef.name} / ${modelId}`);

return null;

} catch (err) {

logger.error(`Orchestrator switch failed for ${providerDef.name} / ${modelId}: ${err.message}`);

return { error: err.message };

}

}

/** Finalize orchestrator switch after API key was provided via chat. */

async switchOrchestratorWithKey(providerKey, modelId, apiKey) {

const logger = getLogger();

const providerDef = PROVIDERS[providerKey];

try {

const testProvider = createProvider({

brain: {

provider: providerKey,

model: modelId,

max_tokens: this.config.orchestrator.max_tokens,

temperature: this.config.orchestrator.temperature,

api_key: apiKey,

timeout: 30_000,

},

});

await testProvider.ping();

saveCredential(this.config, providerDef.envKey, apiKey);

this.config.orchestrator.provider = providerKey;

this.config.orchestrator.model = modelId;

this.config.orchestrator.api_key = apiKey;

this.orchestratorProvider = testProvider;

saveOrchestratorToYaml(providerKey, modelId);

logger.info(`Orchestrator switched to ${providerDef.name} / ${modelId} (new key saved)`);

return null;

} catch (err) {

logger.error(`Orchestrator switch failed for ${providerDef.name} / ${modelId}: ${err.message}`);

return { error: err.message };

}

}

/** Return current Claude Code model info for display. */

getClaudeCodeInfo() {

const model = this.config.claude_code?.model || 'claude-opus-4-6';

const providerDef = PROVIDERS.anthropic;

const modelEntry = providerDef?.models.find((m) => m.id === model);

const modelLabel = modelEntry ? modelEntry.label : model;

return { model, modelLabel };

}

/** Switch Claude Code model at runtime. */

switchClaudeCodeModel(modelId) {

const logger = getLogger();

this.config.claude_code.model = modelId;

saveClaudeCodeModelToYaml(modelId);

resetClaudeCodeSpawner();

logger.info(`Claude Code model switched to ${modelId}`);

}

/** Return current Claude Code auth config for display. */

getClaudeAuthConfig() {

const mode = this.config.claude_code?.auth_mode || 'system';

const info = { mode };

if (mode === 'api_key') {

const key = this.config.claude_code?.api_key || process.env.CLAUDE_CODE_API_KEY || '';

info.credential = key ? `${key.slice(0, 8)}...${key.slice(-4)}` : '(not set)';

} else if (mode === 'oauth_token') {

const token = this.config.claude_code?.oauth_token || process.env.CLAUDE_CODE_OAUTH_TOKEN || '';

info.credential = token ? `${token.slice(0, 8)}...${token.slice(-4)}` : '(not set)';

} else {

info.credential = 'Using host system login';

}

return info;

}

/** Set Claude Code auth mode + credential at runtime. */

setClaudeCodeAuth(mode, value) {

const logger = getLogger();

saveClaudeCodeAuth(this.config, mode, value);

resetClaudeCodeSpawner();

logger.info(`Claude Code auth mode set to: ${mode}`);

}

/** Switch worker brain provider/model at runtime. */

async switchBrain(providerKey, modelId) {

const logger = getLogger();

const providerDef = PROVIDERS[providerKey];

if (!providerDef) return `Unknown provider: ${providerKey}`;

const envKey = providerDef.envKey;

const apiKey = process.env[envKey];

if (!apiKey) return envKey;

try {

const testConfig = { ...this.config, brain: { ...this.config.brain, provider: providerKey, model: modelId, api_key: apiKey } };

const testProvider = createProvider(testConfig);

await testProvider.ping();

this.config.brain.provider = providerKey;

this.config.brain.model = modelId;

this.config.brain.api_key = apiKey;

this.workerProvider = testProvider;

saveProviderToYaml(providerKey, modelId);

logger.info(`Worker brain switched to ${providerDef.name} / ${modelId}`);

return null;

} catch (err) {

logger.error(`Brain switch failed for ${providerDef.name} / ${modelId}: ${err.message}`);

return { error: err.message };

}

}

/** Finalize brain switch after API key was provided via chat. */

async switchBrainWithKey(providerKey, modelId, apiKey) {

const logger = getLogger();

const providerDef = PROVIDERS[providerKey];

try {

const testConfig = { ...this.config, brain: { ...this.config.brain, provider: providerKey, model: modelId, api_key: apiKey } };

const testProvider = createProvider(testConfig);

await testProvider.ping();

saveCredential(this.config, providerDef.envKey, apiKey);

this.config.brain.provider = providerKey;

this.config.brain.model = modelId;

this.config.brain.api_key = apiKey;

this.workerProvider = testProvider;

saveProviderToYaml(providerKey, modelId);

logger.info(`Worker brain switched to ${providerDef.name} / ${modelId} (new key saved)`);

return null;

} catch (err) {

logger.error(`Brain switch failed for ${providerDef.name} / ${modelId}: ${err.message}`);

return { error: err.message };

}

}

/** Truncate a tool result. Delegates to shared utility. */

_truncateResult(name, result) {

return truncateToolResult(name, result);

}

async processMessage(chatId, userMessage, user, onUpdate, sendPhoto, opts = {}) {

const logger = getLogger();

logger.info(`Orchestrator processing message for chat ${chatId} from ${user?.username || user?.id || 'unknown'}: "${userMessage.slice(0, 120)}"`);

// Store callbacks so workers can use them later

this._chatCallbacks.set(chatId, { onUpdate, sendPhoto, sendReaction: opts.sendReaction, lastUserMessageId: opts.messageId });

// Handle pending responses (confirmation or credential)

const pending = this._pending.get(chatId);

if (pending) {

this._pending.delete(chatId);

logger.debug(`Orchestrator handling pending ${pending.type} response for chat ${chatId}`);

if (pending.type === 'credential') {

return await this._handleCredentialResponse(chatId, userMessage, user, pending, onUpdate);

}

}

const { max_tool_depth } = this.config.orchestrator;

// Character-scoped conversation key

const convKey = this._chatKey(chatId);

// Detect time gap before adding the new message

let temporalContext = null;

const lastTs = this.conversationManager.getLastMessageTimestamp(convKey);

if (lastTs) {

const gapMs = Date.now() - lastTs;

const gapMinutes = Math.floor(gapMs / 60_000);

if (gapMinutes >= 30) {

const gapText = formatTimeGap(gapMinutes);

temporalContext = `[Time gap detected: ${gapText} since last message. User may be starting a new topic — consider a fresh greeting.]`;

logger.info(`Time gap detected for chat ${chatId}: ${gapText}`);

}

}

// Add user message to persistent history

this.conversationManager.addMessage(convKey, 'user', userMessage);

// Build working messages from compressed history

const messages = [...this.conversationManager.getSummarizedHistory(convKey)];

// If an image is attached, upgrade the last user message to a multimodal content array

if (opts.imageAttachment) {

for (let i = messages.length - 1; i >= 0; i--) {

if (messages[i].role === 'user' && typeof messages[i].content === 'string') {

messages[i] = {

role: 'user',

content: [

{ type: 'image', source: opts.imageAttachment },

{ type: 'text', text: messages[i].content },

],

};

break;

}

}

logger.info(`[Orchestrator] Image attached to message for chat ${chatId} (${opts.imageAttachment.media_type})`);

}

// Classify sender and build identity context

let identityCtx = null;

if (this.identityAwareness && opts.telegramUser) {

try {

this.identityAwareness.classifySender(opts.telegramUser, opts.chatInfo);

identityCtx = this.identityAwareness.buildIdentityContext(

String(user?.id), opts.chatInfo || { type: 'private' },

);

} catch (err) {

logger.warn(`[Orchestrator] Identity classification failed: ${err.message}`);

}

}

logger.debug(`Orchestrator conversation context: ${messages.length} messages, max_depth=${max_tool_depth}`);

const reply = await this._runLoop(chatId, messages, user, 0, max_tool_depth, temporalContext, identityCtx);

logger.info(`Orchestrator reply for chat ${chatId}: "${(reply || '').slice(0, 150)}"`);

// Background persona extraction + self-reflection (log failures for diagnostics)

this._extractPersonaBackground(userMessage, reply, user).catch((err) => {

logger.warn(`[Orchestrator] Background persona extraction failed: ${err.message}`);

});

this._reflectOnSelfBackground(userMessage, reply, user).catch((err) => {

logger.warn(`[Orchestrator] Background self-reflection failed: ${err.message}`);

});

this._extractWorldModelBackground(userMessage, reply, user).catch((err) => {

logger.warn(`[Orchestrator] Background world model extraction failed: ${err.message}`);

});

this._detectFeedbackBackground(userMessage, reply, user, chatId).catch((err) => {

logger.warn(`[Orchestrator] Background feedback detection failed: ${err.message}`);

});

// Check pending task outcomes — if user message references a completed job

this._checkPendingOutcomes(chatId, userMessage);

// Mark pending shares as shared (they were in the prompt, bot wove them in)

if (this.shareQueue && user?.id) {

const pending = this.shareQueue.getPending(user.id, 3);

for (const item of pending) {

this.shareQueue.markShared(item.id, user.id);

}

}

return reply;

}

async _sendUpdate(chatId, text, opts) {

const callbacks = this._chatCallbacks.get(chatId);

if (callbacks?.onUpdate) {

try {

return await callbacks.onUpdate(text, opts);

} catch (err) {

const logger = getLogger();

logger.error(`[Orchestrator] _sendUpdate failed for chat ${chatId}: ${err.message}`);

}

} else {

const logger = getLogger();

logger.warn(`[Orchestrator] _sendUpdate: no callbacks for chat ${chatId}`);

}

return null;

}

async _handleCredentialResponse(chatId, userMessage, user, pending, onUpdate) {

const logger = getLogger();

const value = userMessage.trim();

if (value.toLowerCase() === 'skip' || value.toLowerCase() === 'cancel') {

logger.info(`User skipped credential: ${pending.credential.envKey}`);

return 'Credential skipped. You can provide it later.';

}

saveCredential(this.config, pending.credential.envKey, value);

logger.info(`Saved credential: ${pending.credential.envKey}`);

return `Saved ${pending.credential.label}. You can now try the task again.`;

}

/** Set up listeners for job lifecycle events. */

_setupJobListeners() {

const logger = getLogger();

this.jobManager.on('job:completed', async (job) => {

const chatId = job.chatId;

const convKey = this._chatKey(chatId);

const workerDef = WORKER_TYPES[job.workerType] || {};

const label = workerDef.label || job.workerType;

logger.info(`[Orchestrator] Job completed event: ${job.id} [${job.workerType}] in chat ${chatId} (${job.duration}s) — result length: ${(job.result || '').length} chars, structured: ${!!job.structuredResult}`);

// Track task outcome via feedback engine

if (this.feedbackEngine) {

try {

const taskSummary = job.structuredResult?.summary || (job.result || '').slice(0, 200);

this.feedbackEngine.recordJobCompletion(job.id, job.workerType, taskSummary, job.userId || null, this._activeCharacterId || null);

this._pendingOutcomes.set(job.id, { timestamp: Date.now(), chatId, userId: job.userId || null, characterId: this._activeCharacterId || null });

} catch (err) {

logger.warn(`[FeedbackEngine] Job completion tracking failed: ${err.message}`);

}

}

// Record causal event for the completed job

if (this.causalMemory) {

try {

const sr = job.structuredResult;

const outcomeType = sr?.status === 'success' ? 'success' : sr?.status === 'failed' ? 'failure' : 'partial';

this.causalMemory.recordEvent({

jobId: job.id,

trigger: `User requested: ${(job.task || '').slice(0, 200)}`,

goal: (job.task || '').slice(0, 500),

approach: `${job.workerType} worker`,

toolsUsed: [job.workerType],

outcome: sr?.summary || (job.result || '').slice(0, 500),