minovative-mind-cli 2.14.1 → 2.14.3

package/dist/services/orchestration/readCache.js

@@ -115,16 +115,19 @@ export class ReadCache {
     /**
      * Invalidates and evicts all cache entries associated with a file path,
      * including full-file reads and any ranged or targeted sub-reads.
+     * Uses case-insensitive and normalized path comparison.
      *
      * @param filePath - The file path that was modified or deleted.
      */
     invalidate(filePath) {
         if (!filePath)
             return;
-        const prefix = `${filePath}::`;
+        const normalizedTarget = filePath.replace(/\\/g, '/').toLowerCase();
+        const prefix = `${normalizedTarget}::`;
         const keysToRemove = [];
         for (const key of this.cache.keys()) {
-            if (key === filePath || key.startsWith(prefix)) {
+            const normKey = key.replace(/\\/g, '/').toLowerCase();
+            if (normKey === normalizedTarget || normKey.startsWith(prefix)) {
                 keysToRemove.push(key);
             }
         }

package/dist/services/orchestration/scopedTools.js

@@ -215,18 +215,37 @@ export async function executeScopedTool(name, args, workspaceRoot, agentId, bus,
                         inlineData: result.inlineData,
                     });
                 }
-                // If a file was modified/written/deleted/renamed, invalidate readCache entries for affected file(s)
-                if (readCache) {
-                    if (name === 'write_file' || name === 'modify_file' || name === 'delete_file') {
-                        if (args?.filePath) {
+                // If a file was modified/written/deleted/renamed, invalidate readCache and investigationCache entries for affected file(s)
+                if (name === 'write_file' || name === 'modify_file' || name === 'delete_file') {
+                    if (args?.filePath) {
+                        if (readCache) {
                             readCache.invalidate(args.filePath);
                         }
+                        import('./investigationCache.js')
+                            .then(({ invalidateFilesFromInvestigationCache }) => {
+                            invalidateFilesFromInvestigationCache(workspaceRoot, [args.filePath]).catch(() => { });
+                        })
+                            .catch(() => { });
                     }
-                    else if (name === 'rename_file') {
-                        if (args?.sourcePath)
+                }
+                else if (name === 'rename_file') {
+                    const affected = [];
+                    if (args?.sourcePath) {
+                        if (readCache)
                             readCache.invalidate(args.sourcePath);
-                        if (args?.targetPath)
+                        affected.push(args.sourcePath);
+                    }
+                    if (args?.targetPath) {
+                        if (readCache)
                             readCache.invalidate(args.targetPath);
+                        affected.push(args.targetPath);
+                    }
+                    if (affected.length > 0) {
+                        import('./investigationCache.js')
+                            .then(({ invalidateFilesFromInvestigationCache }) => {
+                            invalidateFilesFromInvestigationCache(workspaceRoot, affected).catch(() => { });
+                        })
+                            .catch(() => { });
                     }
                 }
                 // If we got a file lock and had context from a previous writer, we should 
@@ -307,10 +326,18 @@ export async function executeScopedTool(name, args, workspaceRoot, agentId, bus,
             targetDesc = String(args.filePath);
             actionDesc = 'Deleted';
         }
-        else if (name === 'run_debug_script') {
+        else if (name === 'run_debug_script' || name === 'run_analysis_script' || name === 'debug_script' || name === 'analysis_script') {
             targetDesc = String(args.language ?? 'node');
-            actionDesc = 'Ran debug script';
-            resultSummary = typeof result === 'object' && result?.error ? result.error : 'Completed debug script';
+            actionDesc = name.includes('analysis') ? 'Ran analysis script' : 'Ran debug script';
+            if (typeof result === 'object' && result?.error) {
+                resultSummary = result.error;
+            }
+            else if (typeof result === 'object' && result?.structuredResult !== undefined) {
+                resultSummary = 'Completed script (structured result)';
+            }
+            else {
+                resultSummary = 'Completed script';
+            }
         }
         else if (name === 'run_fuzz_probe') {
             targetDesc = String(args.language ?? 'node');

package/dist/services/orchestration/subAgent.js

@@ -4,7 +4,7 @@
  * Implements the lifecycle, health monitoring, and tool-loop execution for a single
  * parallelized sub-agent.
  */
-import { ProxyChatSession, getGlobalActiveModel, getModelThinkingLevel } from '../ai.js';
+import { ProxyChatSession, getGlobalActiveModel, getModelThinkingLevel, HISTORICAL_TOOL_OUTPUT_THRESHOLD } from '../ai.js';
 import { GEMINI_MODELS, MAX_OUTPUT_TOKENS } from '../../utils/config.js';
 import { ReadCache } from './readCache.js';
 import { executeScopedTool, getScopedToolDeclarations } from './scopedTools.js';
@@ -99,6 +99,15 @@ export function createCompactToolReference(toolName, output, args) {
         const file = args?.filePath ? `${args.filePath}` : 'file';
         return `[Wrote ${file} - tool execution completed]`;
     }
+    if (toolName === 'delete_file') {
+        const file = args?.filePath ? `${args.filePath}` : 'file';
+        return `[Deleted ${file} - tool execution completed]`;
+    }
+    if (toolName === 'rename_file') {
+        const src = args?.sourcePath || 'source';
+        const tgt = args?.targetPath || 'target';
+        return `[Renamed ${src} to ${tgt} - tool execution completed]`;
+    }
     if (toolName === 'find_dependencies') {
         const file = args?.filePath ? `for ${args.filePath}` : '';
         return `[Dependency trace ${file} completed]`.replace(/\s+/g, ' ');
@@ -237,7 +246,7 @@ export class SubAgentRunner {
             }
         }
         // Also trigger proxy chat session pruning to collapse any remaining long fields
-        this.chat.pruneToolOutputHistory();
+        this.chat.pruneToolOutputHistory(HISTORICAL_TOOL_OUTPUT_THRESHOLD, turnsToKeep);
     }
     /**
      * Executes the sub-agent with a health monitor harness.
@@ -389,6 +398,11 @@ export class SubAgentRunner {
             `DO NOT IMPLEMENT THIS FULL REQUEST. THIS IS JUST FOR CONTEXT.\n\n` +
             `${scopedContext}\n` +
             `</reference_context>\n\n` +
+            `<documentation_and_quality_standards>\n` +
+            `- Comprehensive Documentation: Write documentation for senior engineers: explain the 'why', document edge-cases/private states, use precise types, and avoid restating the code.\n` +
+            `- Provide JSDoc/TSDoc/DocStrings (as appropriate for the language) for all newly added or modified APIs, functions, classes, interfaces, and types (documenting parameters, return values, and behavior).\n` +
+            `- Use clean inline comments to explain complex or non-obvious logic, keeping implementation code highly organized and maintainable.\n` +
+            `</documentation_and_quality_standards>\n\n` +
             `<critical_guidelines>\n` +
             `1. You are ONE worker in a team. Focus EXCLUSIVELY on your specific objective: "${this.intent}".\n` +
             `2. DO NOT attempt to fulfill the entire original user request in the reference context. Other agents handle other tasks.\n` +

package/dist/services/proxyClient.d.ts

@@ -76,6 +76,12 @@ export declare function accumulateTurnUsage(usage: {
     candidatesTokenCount?: number;
     cachedContentTokenCount?: number;
 }, modelName: string): void;
+/**
+ * Detects whether an error message relates to an expired or mismatched Gemini context cache.
+ * When models transition (e.g. Flash to Flash-Lite) or a server cache expires,
+ * this triggers a fast retry to refresh/recreate the cache under the active model.
+ */
+export declare function isCacheMismatchOrExpiredError(errMsg: string | undefined): boolean;
 /**
  * Client service interacting directly with the serverless Gemini proxy endpoint.
  * Ensures authorization via Firebase token passing and parses streamed content.

package/dist/services/proxyClient.js

@@ -82,6 +82,22 @@ export function accumulateTurnUsage(usage, modelName) {
     globalSessionAccumulatedUsage.totalTokenCount += pTokens + cachedTokens + cTokens;
     globalSessionAccumulatedUsage.modelsUsed[modelName] = (globalSessionAccumulatedUsage.modelsUsed[modelName] || 0) + 1;
 }
+/**
+ * Detects whether an error message relates to an expired or mismatched Gemini context cache.
+ * When models transition (e.g. Flash to Flash-Lite) or a server cache expires,
+ * this triggers a fast retry to refresh/recreate the cache under the active model.
+ */
+export function isCacheMismatchOrExpiredError(errMsg) {
+    if (!errMsg)
+        return false;
+    const lower = errMsg.toLowerCase();
+    return (lower.includes('is expired') ||
+        lower.includes('cache content') ||
+        lower.includes('cached content') ||
+        lower.includes('cached_content') ||
+        lower.includes('does not match the model in the cached content') ||
+        lower.includes('model in the inference request'));
+}
 /**
  * Client service interacting directly with the serverless Gemini proxy endpoint.
  * Ensures authorization via Firebase token passing and parses streamed content.
@@ -194,9 +210,9 @@ export class ProxyClient {
             if (!response.ok) {
                 const errorData = await response.json().catch(() => ({}));
                 const errorMsg = JSON.stringify(errorData) || response.statusText;
-                if (errorMsg.includes('is expired') || errorMsg.includes('Cache content')) {
+                if (isCacheMismatchOrExpiredError(errorMsg)) {
                     if (attempt < MAX_RETRIES) {
-                        debugLog(`Gemini Context Cache expired on server. Retrying request to refresh cache (Attempt ${attempt + 1}/${MAX_RETRIES})...`);
+                        debugLog(`Gemini Context Cache expired or mismatched on server. Retrying request to refresh cache (Attempt ${attempt + 1}/${MAX_RETRIES})...`);
                         await delay(500, abortSignal);
                         attempt++;
                         continue retryLoop;
@@ -293,8 +309,7 @@ export class ProxyClient {
                     err.name = 'AbortError';
                     throw err;
                 }
-                const isCacheExpired = streamError.message?.includes('is expired') ||
-                    streamError.message?.includes('Cache content');
+                const isCacheExpired = isCacheMismatchOrExpiredError(streamError.message);
                 if (streamError.message?.includes('429') ||
                     streamError.message?.includes('502') ||
                     streamError.message?.includes('503') ||
@@ -312,7 +327,7 @@ export class ProxyClient {
                         if (isDebugOn()) {
                             process.stdout.write('\n');
                             console.warn(isCacheExpired
-                                ? `Gemini Context Cache expired on server. Refreshing and retrying in ${(delayTime / 1000).toFixed(1)}s... (Attempt ${attempt + 1}/${MAX_RETRIES})`
+                                ? `Gemini Context Cache expired or mismatched on server. Refreshing and retrying in ${(delayTime / 1000).toFixed(1)}s... (Attempt ${attempt + 1}/${MAX_RETRIES})`
                                 : `Server error or rate limit hit during stream. Retrying in ${(delayTime / 1000).toFixed(1)}s... (Attempt ${attempt + 1}/${MAX_RETRIES})`);
                         }
                         await delay(delayTime, abortSignal);
@@ -435,9 +450,9 @@ export class ProxyClient {
                     // ignore parsing error
                 }
                 const errorMsg = errorData.error?.message || JSON.stringify(errorData) || response.statusText;
-                if (errorMsg.includes('is expired') || errorMsg.includes('Cache content')) {
+                if (isCacheMismatchOrExpiredError(errorMsg)) {
                     if (attempt < MAX_RETRIES) {
-                        debugLog(`BYOK Gemini Context Cache expired on server. Retrying request to refresh cache (Attempt ${attempt + 1}/${MAX_RETRIES})...`);
+                        debugLog(`BYOK Gemini Context Cache expired or mismatched on server. Retrying request to refresh cache (Attempt ${attempt + 1}/${MAX_RETRIES})...`);
                         await delay(500, abortSignal);
                         attempt++;
                         continue retryLoop;
@@ -526,8 +541,7 @@ export class ProxyClient {
                         err.name = 'AbortError';
                         throw err;
                     }
-                    const isCacheExpired = streamError.message?.includes('is expired') ||
-                        streamError.message?.includes('Cache content');
+                    const isCacheExpired = isCacheMismatchOrExpiredError(streamError.message);
                     if (streamError.message?.includes('429') ||
                         streamError.message?.includes('502') ||
                         streamError.message?.includes('503') ||
@@ -545,7 +559,7 @@ export class ProxyClient {
                             if (isDebugOn()) {
                                 process.stdout.write('\n');
                                 console.warn(isCacheExpired
-                                    ? `BYOK Gemini Context Cache expired on server. Refreshing and retrying in ${(delayTime / 1000).toFixed(1)}s... (Attempt ${attempt + 1}/${MAX_RETRIES})`
+                                    ? `BYOK Gemini Context Cache expired or mismatched on server. Refreshing and retrying in ${(delayTime / 1000).toFixed(1)}s... (Attempt ${attempt + 1}/${MAX_RETRIES})`
                                     : `Server error or rate limit hit during BYOK stream. Retrying in ${(delayTime / 1000).toFixed(1)}s... (Attempt ${attempt + 1}/${MAX_RETRIES})`);
                             }
                             await delay(delayTime, abortSignal);

package/dist/services/sessionSettings.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @file sessionSettings.ts
+ * @description Manages session-scoped slash command settings and operational toggles.
+ *
+ * Operational toggles scoped to an individual chat session include:
+ * - `autoApprove`  : Whether automatic confirmation is enabled for shell execution commands (/auto-approve)
+ * - `subAgents`    : Whether the MMAAK parallel multi-agent orchestration engine is enabled (/sub-agents)
+ * - `debugMode`    : Whether internal diagnostic telemetry logging is visible (/debug)
+ * - `modelName`    : The generative AI model selected for this session (/models)
+ * - `thinkingLevel`: The reasoning budget allocation level for the active model (/models)
+ *
+ * Safe Lifecycle:
+ * - On new chat sessions or CLI boot, settings automatically reset to safe defaults.
+ * - On resuming a saved session, previous settings are restored and verified.
+ */
+import { type ThinkingLevel } from '../utils/config.js';
+import { type ProxyChatSession } from './ai.js';
+import { type ChatSessionData } from './chatHistoryService.js';
+/**
+ * Session-scoped operational settings container.
+ */
+export interface SessionSettings {
+    /** Whether auto-approval mode is enabled for command execution ('skip-all' vs 'ask'). */
+    autoApprove: boolean;
+    /** Whether MMAAK parallel sub-agent orchestration is enabled. */
+    subAgents: boolean;
+    /** Whether internal telemetry and diagnostic logging is enabled. */
+    debugMode: boolean;
+    /** Active generative AI model identifier for the session. */
+    modelName: string;
+    /** Active thinking/reasoning level for the model. */
+    thinkingLevel: ThinkingLevel;
+}
+/**
+ * Default safe settings used when creating a new chat session or resetting state.
+ */
+export declare const DEFAULT_SESSION_SETTINGS: Readonly<SessionSettings>;
+/**
+ * Applies saved or specified settings to the active environment and chat session.
+ *
+ * @param session - A partial session object or settings container.
+ * @param chat - Optional active ProxyChatSession instance to update.
+ * @returns The resulting applied SessionSettings.
+ */
+export declare function applySessionSettings(session: Partial<ChatSessionData> | Partial<SessionSettings>, chat?: ProxyChatSession): SessionSettings;
+/**
+ * Resets all session operational toggles back to default safe values.
+ *
+ * @param chat - Optional active ProxyChatSession instance to reset.
+ * @returns The default SessionSettings.
+ */
+export declare function resetSessionSettingsToDefault(chat?: ProxyChatSession): SessionSettings;
+/**
+ * Inspects and retrieves the current operational settings across modules.
+ *
+ * @param chat - Optional active ProxyChatSession instance.
+ * @returns The current active SessionSettings.
+ */
+export declare function getCurrentSessionSettings(chat?: ProxyChatSession): SessionSettings;
+/**
+ * Persists current operational settings to the saved session cache if the session exists on disk.
+ *
+ * @param sessionId - The unique identifier of the chat session to update.
+ * @param chat - Optional active ProxyChatSession instance.
+ */
+export declare function syncActiveSessionSettings(sessionId?: string, chat?: ProxyChatSession): Promise<void>;

package/dist/services/sessionSettings.js

@@ -0,0 +1,126 @@
+/**
+ * @file sessionSettings.ts
+ * @description Manages session-scoped slash command settings and operational toggles.
+ *
+ * Operational toggles scoped to an individual chat session include:
+ * - `autoApprove`  : Whether automatic confirmation is enabled for shell execution commands (/auto-approve)
+ * - `subAgents`    : Whether the MMAAK parallel multi-agent orchestration engine is enabled (/sub-agents)
+ * - `debugMode`    : Whether internal diagnostic telemetry logging is visible (/debug)
+ * - `modelName`    : The generative AI model selected for this session (/models)
+ * - `thinkingLevel`: The reasoning budget allocation level for the active model (/models)
+ *
+ * Safe Lifecycle:
+ * - On new chat sessions or CLI boot, settings automatically reset to safe defaults.
+ * - On resuming a saved session, previous settings are restored and verified.
+ */
+import { setApprovalMode, getApprovalMode, isSubAgentsEnabled, setSubAgentsEnabled } from './agent-tools.js';
+import { isDebugOn, setDebugMode } from '../utils/logger.js';
+import { DEFAULT_MODEL, DEFAULT_MODEL_THINKING_LEVELS, } from '../utils/config.js';
+import { getGlobalActiveModel, setGlobalActiveModel, getModelThinkingLevel, setModelThinkingLevel, } from './ai.js';
+import { chatHistoryService } from './chatHistoryService.js';
+/**
+ * Default safe settings used when creating a new chat session or resetting state.
+ */
+export const DEFAULT_SESSION_SETTINGS = Object.freeze({
+    autoApprove: false,
+    subAgents: true,
+    debugMode: false,
+    modelName: DEFAULT_MODEL,
+    thinkingLevel: (DEFAULT_MODEL_THINKING_LEVELS[DEFAULT_MODEL] || 'MEDIUM'),
+});
+/**
+ * Applies saved or specified settings to the active environment and chat session.
+ *
+ * @param session - A partial session object or settings container.
+ * @param chat - Optional active ProxyChatSession instance to update.
+ * @returns The resulting applied SessionSettings.
+ */
+export function applySessionSettings(session, chat) {
+    // 1. Auto-approve mode
+    const autoApprove = session.autoApprove ?? DEFAULT_SESSION_SETTINGS.autoApprove;
+    setApprovalMode(autoApprove ? 'skip-all' : 'ask');
+    // 2. MMAAK sub-agents
+    const subAgents = session.subAgents ?? DEFAULT_SESSION_SETTINGS.subAgents;
+    setSubAgentsEnabled(subAgents);
+    // 3. Debug logging
+    const debugMode = session.debugMode ?? DEFAULT_SESSION_SETTINGS.debugMode;
+    setDebugMode(debugMode);
+    // 4. Model selection
+    const modelName = session.modelName ?? DEFAULT_SESSION_SETTINGS.modelName;
+    setGlobalActiveModel(modelName);
+    if (chat && typeof chat.setModel === 'function') {
+        chat.setModel(modelName);
+    }
+    // 5. Thinking level
+    const targetThinking = session.thinkingLevel ??
+        getModelThinkingLevel(modelName) ??
+        DEFAULT_MODEL_THINKING_LEVELS[modelName] ??
+        DEFAULT_SESSION_SETTINGS.thinkingLevel;
+    setModelThinkingLevel(modelName, targetThinking);
+    if (chat && typeof chat.setThinkingLevel === 'function') {
+        chat.setThinkingLevel(targetThinking);
+    }
+    return {
+        autoApprove,
+        subAgents,
+        debugMode,
+        modelName,
+        thinkingLevel: targetThinking,
+    };
+}
+/**
+ * Resets all session operational toggles back to default safe values.
+ *
+ * @param chat - Optional active ProxyChatSession instance to reset.
+ * @returns The default SessionSettings.
+ */
+export function resetSessionSettingsToDefault(chat) {
+    return applySessionSettings(DEFAULT_SESSION_SETTINGS, chat);
+}
+/**
+ * Inspects and retrieves the current operational settings across modules.
+ *
+ * @param chat - Optional active ProxyChatSession instance.
+ * @returns The current active SessionSettings.
+ */
+export function getCurrentSessionSettings(chat) {
+    const autoApprove = getApprovalMode() === 'skip-all';
+    const subAgents = isSubAgentsEnabled();
+    const debugMode = isDebugOn();
+    const modelName = (chat && typeof chat.getModel === 'function' ? chat.getModel() : undefined) || getGlobalActiveModel();
+    const thinkingLevel = (chat && typeof chat.getThinkingLevel === 'function' ? chat.getThinkingLevel() : undefined) ||
+        getModelThinkingLevel(modelName) ||
+        'MEDIUM';
+    return {
+        autoApprove,
+        subAgents,
+        debugMode,
+        modelName,
+        thinkingLevel,
+    };
+}
+/**
+ * Persists current operational settings to the saved session cache if the session exists on disk.
+ *
+ * @param sessionId - The unique identifier of the chat session to update.
+ * @param chat - Optional active ProxyChatSession instance.
+ */
+export async function syncActiveSessionSettings(sessionId, chat) {
+    if (!sessionId)
+        return;
+    try {
+        const session = chatHistoryService.getSession(sessionId);
+        if (!session)
+            return;
+        const current = getCurrentSessionSettings(chat);
+        session.autoApprove = current.autoApprove;
+        session.subAgents = current.subAgents;
+        session.debugMode = current.debugMode;
+        session.modelName = current.modelName;
+        session.thinkingLevel = current.thinkingLevel;
+        await chatHistoryService.saveSession(session);
+    }
+    catch {
+        // Non-blocking sync failure ignored
+    }
+}

package/dist/services/userProfileService.d.ts

@@ -30,6 +30,19 @@ export interface UserProfileCognitiveTraits {
     debuggingStyle?: string;
     explanationFormat?: string;
 }
+/**
+ * Deep interpersonal, psychological, and conversational personality traits observed by the agent.
+ * Captures how the user speaks to the AI, relationship posture, banter, apology tolerance, and quirks.
+ */
+export interface UserProfileConversationalPersona {
+    relationshipModel?: string;
+    banterAffinity?: string;
+    formalityLevel?: string;
+    apologyTolerance?: string;
+    stressCadence?: string;
+    promptingHabit?: string;
+    conversationalQuirks?: string[];
+}
 /**
  * Technical habits and technology strengths observed by the agent.
  */
@@ -43,6 +56,7 @@ export interface UserProfileTechnicalPreferences {
 export interface UserProfile {
     communicationStyle?: UserProfileCommunicationStyle;
     cognitiveTraits?: UserProfileCognitiveTraits;
+    conversationalPersona?: UserProfileConversationalPersona;
     technicalPreferences?: UserProfileTechnicalPreferences;
     agentNotes: string[];
     lastUpdated?: number;

package/dist/services/userProfileService.js

@@ -50,6 +50,7 @@ export async function loadUserProfile() {
         return {
             communicationStyle: {},
             cognitiveTraits: {},
+            conversationalPersona: { conversationalQuirks: [] },
             technicalPreferences: { strengths: [], conventions: [] },
             agentNotes: [],
             lastUpdated: Date.now(),
@@ -61,6 +62,17 @@ export async function loadUserProfile() {
         return {
             communicationStyle: parsed.communicationStyle || {},
             cognitiveTraits: parsed.cognitiveTraits || {},
+            conversationalPersona: {
+                relationshipModel: parsed.conversationalPersona?.relationshipModel,
+                banterAffinity: parsed.conversationalPersona?.banterAffinity,
+                formalityLevel: parsed.conversationalPersona?.formalityLevel,
+                apologyTolerance: parsed.conversationalPersona?.apologyTolerance,
+                stressCadence: parsed.conversationalPersona?.stressCadence,
+                promptingHabit: parsed.conversationalPersona?.promptingHabit,
+                conversationalQuirks: Array.isArray(parsed.conversationalPersona?.conversationalQuirks)
+                    ? parsed.conversationalPersona.conversationalQuirks
+                    : [],
+            },
             technicalPreferences: {
                 strengths: Array.isArray(parsed.technicalPreferences?.strengths) ? parsed.technicalPreferences.strengths : [],
                 conventions: Array.isArray(parsed.technicalPreferences?.conventions)
@@ -76,6 +88,7 @@ export async function loadUserProfile() {
         return {
             communicationStyle: {},
             cognitiveTraits: {},
+            conversationalPersona: { conversationalQuirks: [] },
             technicalPreferences: { strengths: [], conventions: [] },
             agentNotes: [],
             lastUpdated: Date.now(),
@@ -133,6 +146,8 @@ export async function deleteSideNote(index) {
 export async function clearUserProfile() {
     const emptyProfile = {
         communicationStyle: {},
+        cognitiveTraits: {},
+        conversationalPersona: { conversationalQuirks: [] },
         technicalPreferences: { strengths: [], conventions: [] },
         agentNotes: [],
         lastUpdated: Date.now(),
@@ -153,15 +168,43 @@ export function formatUserProfileForContext(profile) {
         profile.cognitiveTraits?.delegationDepth ||
         profile.cognitiveTraits?.debuggingStyle ||
         profile.cognitiveTraits?.explanationFormat;
+    const hasPersona = profile.conversationalPersona?.relationshipModel ||
+        profile.conversationalPersona?.banterAffinity ||
+        profile.conversationalPersona?.formalityLevel ||
+        profile.conversationalPersona?.apologyTolerance ||
+        profile.conversationalPersona?.stressCadence ||
+        profile.conversationalPersona?.promptingHabit ||
+        (profile.conversationalPersona?.conversationalQuirks && profile.conversationalPersona.conversationalQuirks.length > 0);
     const hasStrengths = profile.technicalPreferences?.strengths && profile.technicalPreferences.strengths.length > 0;
     const hasConventions = profile.technicalPreferences?.conventions && profile.technicalPreferences.conventions.length > 0;
     const hasNotes = profile.agentNotes && profile.agentNotes.length > 0;
-    if (!hasStyle && !hasCognitive && !hasStrengths && !hasConventions && !hasNotes) {
+    if (!hasStyle && !hasCognitive && !hasPersona && !hasStrengths && !hasConventions && !hasNotes) {
         return '';
     }
     let block = '<user_profile>\n';
     block +=
-        'The following are continuous, adaptive insights and preferences learned from past interactions with this user:\n';
+        'The following are continuous, adaptive insights, conversational personality traits, and technical preferences learned from past interactions with this user:\n';
+    if (profile.conversationalPersona?.relationshipModel) {
+        block += `- Teammate & Pairing Dynamic: ${profile.conversationalPersona.relationshipModel}\n`;
+    }
+    if (profile.conversationalPersona?.banterAffinity) {
+        block += `- Banter & Humor Affinity: ${profile.conversationalPersona.banterAffinity}\n`;
+    }
+    if (profile.conversationalPersona?.formalityLevel) {
+        block += `- Speech Formality: ${profile.conversationalPersona.formalityLevel}\n`;
+    }
+    if (profile.conversationalPersona?.apologyTolerance) {
+        block += `- Apology & Error Reaction: ${profile.conversationalPersona.apologyTolerance}\n`;
+    }
+    if (profile.conversationalPersona?.stressCadence) {
+        block += `- Stress & Urgency Cadence: ${profile.conversationalPersona.stressCadence}\n`;
+    }
+    if (profile.conversationalPersona?.promptingHabit) {
+        block += `- Prompting & Input Style: ${profile.conversationalPersona.promptingHabit}\n`;
+    }
+    if (profile.conversationalPersona?.conversationalQuirks && profile.conversationalPersona.conversationalQuirks.length > 0) {
+        block += `- Conversational Quirks & Catchphrases: ${profile.conversationalPersona.conversationalQuirks.join('; ')}\n`;
+    }
     if (profile.communicationStyle?.tonePreference) {
         block += `- Tone & Demeanor: ${profile.communicationStyle.tonePreference}\n`;
     }
@@ -202,7 +245,7 @@ export function formatUserProfileForContext(profile) {
         }
     }
     block +=
-        'Adopt these communication, cognitive, and technical preferences naturally without ever explicitly mentioning this profile block.\n';
+        'Adopt these conversational personality traits, tone, and technical preferences naturally as an intuitive pair programming partner without ever explicitly mentioning this profile block.\n';
     block += '</user_profile>';
     return block;
 }
@@ -314,6 +357,65 @@ AI Response Summary:
                 }
             }
         }
+        // Process conversational persona & teammate dynamics
+        if ((parsed.conversationalPersona && typeof parsed.conversationalPersona === 'object') ||
+            parsed.relationshipModel ||
+            parsed.banterAffinity ||
+            parsed.formalityLevel ||
+            parsed.apologyTolerance ||
+            parsed.stressCadence ||
+            parsed.promptingHabit ||
+            parsed.conversationalQuirks) {
+            currentProfile.conversationalPersona = currentProfile.conversationalPersona || { conversationalQuirks: [] };
+            const sourceObj = (parsed.conversationalPersona && typeof parsed.conversationalPersona === 'object')
+                ? parsed.conversationalPersona
+                : {};
+            const personaKeys = [
+                'relationshipModel',
+                'banterAffinity',
+                'formalityLevel',
+                'apologyTolerance',
+                'stressCadence',
+                'promptingHabit',
+            ];
+            for (const k of personaKeys) {
+                const val = sourceObj[k] || parsed[k];
+                if (typeof val === 'string' && val.trim().length > 0) {
+                    currentProfile.conversationalPersona[k] = val.trim();
+                    changed = true;
+                }
+            }
+            const quirksToAdd = Array.isArray(sourceObj.conversationalQuirks)
+                ? sourceObj.conversationalQuirks
+                : Array.isArray(parsed.conversationalQuirks)
+                    ? parsed.conversationalQuirks
+                    : [];
+            if (quirksToAdd.length > 0) {
+                const existingQuirks = new Set(currentProfile.conversationalPersona.conversationalQuirks || []);
+                for (const q of quirksToAdd) {
+                    if (typeof q === 'string' && q.trim().length > 0) {
+                        existingQuirks.add(q.trim());
+                        changed = true;
+                    }
+                }
+                currentProfile.conversationalPersona.conversationalQuirks = Array.from(existingQuirks).slice(0, 10);
+            }
+            const quirksToRemove = Array.isArray(sourceObj.removeQuirks)
+                ? sourceObj.removeQuirks
+                : Array.isArray(parsed.removeQuirks)
+                    ? parsed.removeQuirks
+                    : [];
+            if (quirksToRemove.length > 0) {
+                if (currentProfile.conversationalPersona.conversationalQuirks) {
+                    const toRemove = new Set(quirksToRemove.map((q) => q.toLowerCase().trim()));
+                    const filtered = currentProfile.conversationalPersona.conversationalQuirks.filter((q) => !toRemove.has(q.toLowerCase().trim()));
+                    if (filtered.length !== currentProfile.conversationalPersona.conversationalQuirks.length) {
+                        currentProfile.conversationalPersona.conversationalQuirks = filtered;
+                        changed = true;
+                    }
+                }
+            }
+        }
         if (Array.isArray(parsed.strengths) && parsed.strengths.length > 0) {
             currentProfile.technicalPreferences = currentProfile.technicalPreferences || { strengths: [], conventions: [] };
             const existing = new Set(currentProfile.technicalPreferences.strengths || []);