npcsh 1.0.11__py3-none-any.whl → 1.0.13__py3-none-any.whl

npcsh/npcsh.py

@@ -10,10 +10,6 @@ import importlib.metadata
 import textwrap
 from typing import Optional, List, Dict, Any, Tuple, Union
 from dataclasses import dataclass, field
-try:
-    from inspect import isgenerator
-except: 
-    pass
 import platform
 try:
     from termcolor import colored
@@ -25,10 +21,11 @@ try:
 except ImportError:
     chromadb = None
 import shutil
-
+import json
+import sqlite3
+import copy
 import yaml
 
-# Local Application Imports
 from npcsh._state import (
     setup_npcsh_config,
     initial_state, 
@@ -39,7 +36,9 @@ from npcsh._state import (
     interactive_commands,
     BASH_COMMANDS,
     start_interactive_session,
-    validate_bash_command
+    validate_bash_command, 
+    normalize_and_expand_flags, 
+
     )
 
 from npcpy.npc_sysenv import (
@@ -47,16 +46,29 @@ from npcpy.npc_sysenv import (
     render_markdown,
     get_locally_available_models,
     get_model_and_provider,
+    lookup_provider
 )
 from npcsh.routes import router
 from npcpy.data.image import capture_screenshot
 from npcpy.memory.command_history import (
     CommandHistory,
     save_conversation_message,
+    load_kg_from_db, 
+    save_kg_to_db, 
 )
 from npcpy.npc_compiler import NPC, Team, load_jinxs_from_directory
-from npcpy.llm_funcs import check_llm_command, get_llm_response, execute_llm_command
+from npcpy.llm_funcs import (
+    check_llm_command,
+    get_llm_response,
+    execute_llm_command,
+    breathe
+)
+from npcpy.memory.knowledge_graph import (
+    kg_initial,
+    kg_evolve_incremental
+)
 from npcpy.gen.embeddings import get_embeddings
+
 try:
     import readline
 except:
@@ -201,7 +213,7 @@ def get_slash_commands(state: ShellState) -> List[str]:
         completion_logger.debug(f"NPC commands: {npc_cmds}")
     
     # Mode switching commands
-    mode_cmds = ['/cmd', '/agent', '/chat', '/ride']
+    mode_cmds = ['/cmd', '/agent', '/chat']
     commands.extend(mode_cmds)
     completion_logger.debug(f"Mode commands: {mode_cmds}")
     
@@ -557,13 +569,107 @@ def handle_bash_command(
     except PermissionError:
         return False, f"Permission denied: {cmd_str}"
 
+def _try_convert_type(value: str) -> Union[str, int, float, bool]:
+    """Helper to convert string values to appropriate types."""
+    if value.lower() in ['true', 'yes']:
+        return True
+    if value.lower() in ['false', 'no']:
+        return False
+    try:
+        return int(value)
+    except (ValueError, TypeError):
+        pass
+    try:
+        return float(value)
+    except (ValueError, TypeError):
+        pass
+    return value
+
+def parse_generic_command_flags(parts: List[str]) -> Tuple[Dict[str, Any], List[str]]:
+    """
+    Parses a list of command parts into a dictionary of keyword arguments and a list of positional arguments.
+    Handles: -f val, --flag val, --flag=val, flag=val, --boolean-flag
+    """
+    parsed_kwargs = {}
+    positional_args = []
+    i = 0
+    while i < len(parts):
+        part = parts[i]
+        
+        if part.startswith('--'):
+            key_part = part[2:]
+            if '=' in key_part:
+                key, value = key_part.split('=', 1)
+                parsed_kwargs[key] = _try_convert_type(value)
+            else:
+                # Look ahead for a value
+                if i + 1 < len(parts) and not parts[i + 1].startswith('-'):
+                    parsed_kwargs[key_part] = _try_convert_type(parts[i + 1])
+                    i += 1 # Consume the value
+                else:
+                    parsed_kwargs[key_part] = True # Boolean flag
+        
+        elif part.startswith('-'):
+            key = part[1:]
+            # Look ahead for a value
+            if i + 1 < len(parts) and not parts[i + 1].startswith('-'):
+                parsed_kwargs[key] = _try_convert_type(parts[i + 1])
+                i += 1 # Consume the value
+            else:
+                parsed_kwargs[key] = True # Boolean flag
+        
+        elif '=' in part and not part.startswith('-'):
+             key, value = part.split('=', 1)
+             parsed_kwargs[key] = _try_convert_type(value)
+        
+        else:
+            positional_args.append(part)
+        
+        i += 1
+        
+    return parsed_kwargs, positional_args
+
+
+def should_skip_kg_processing(user_input: str, assistant_output: str) -> bool:
+    """Determine if this interaction is too trivial for KG processing"""
+    
+    # Skip if user input is too short or trivial
+    trivial_inputs = {
+        '/sq', '/exit', '/quit', 'exit', 'quit', 'hey', 'hi', 'hello', 
+        'fwah!', 'test', 'ping', 'ok', 'thanks', 'ty'
+    }
+    
+    if user_input.lower().strip() in trivial_inputs:
+        return True
+    
+    # Skip if user input is very short (less than 10 chars)
+    if len(user_input.strip()) < 10:
+        return True
+    
+    # Skip simple bash commands
+    simple_bash = {'ls', 'pwd', 'cd', 'mkdir', 'touch', 'rm', 'mv', 'cp'}
+    first_word = user_input.strip().split()[0] if user_input.strip() else ""
+    if first_word in simple_bash:
+        return True
+    
+    # Skip if assistant output is very short (less than 20 chars)
+    if len(assistant_output.strip()) < 20:
+        return True
+    
+    # Skip if it's just a mode exit message
+    if "exiting" in assistant_output.lower() or "exited" in assistant_output.lower():
+        return True
+    
+    return False
+
+
+
 def execute_slash_command(command: str, stdin_input: Optional[str], state: ShellState, stream: bool) -> Tuple[ShellState, Any]:
     """Executes slash commands using the router or checking NPC/Team jinxs."""
-    command_parts = command.split()
-    command_name = command_parts[0].lstrip('/')
-
+    all_command_parts = shlex.split(command)
+    command_name = all_command_parts[0].lstrip('/')
     if command_name in ['n', 'npc']:
-        npc_to_switch_to = command_parts[1] if len(command_parts) > 1 else None
+        npc_to_switch_to = all_command_parts[1] if len(all_command_parts) > 1 else None
         if npc_to_switch_to and state.team and npc_to_switch_to in state.team.npcs:
             state.npc = state.team.npcs[npc_to_switch_to]
             return state, f"Switched to NPC: {npc_to_switch_to}"
@@ -571,38 +677,75 @@ def execute_slash_command(command: str, stdin_input: Optional[str], state: Shell
             available_npcs = list(state.team.npcs.keys()) if state.team else []
             return state, colored(f"NPC '{npc_to_switch_to}' not found. Available NPCs: {', '.join(available_npcs)}", "red")
     handler = router.get_route(command_name)
-    #print(handler)
     if handler:
-        # Prepare kwargs for the handler
+        parsed_flags, positional_args = parse_generic_command_flags(all_command_parts[1:])
+
+        normalized_flags = normalize_and_expand_flags(parsed_flags)
+
         handler_kwargs = {
             'stream': stream,
-            'npc': state.npc, 
             'team': state.team,
             'messages': state.messages,
-            'model': state.chat_model, 
-            'provider': state.chat_provider,
             'api_url': state.api_url,
             'api_key': state.api_key,
+            'stdin_input': stdin_input,
+            'positional_args': positional_args,
+            'plonk_context': state.team.shared_context.get('PLONK_CONTEXT') if state.team and hasattr(state.team, 'shared_context') else None,
+            
+            # Default chat model/provider
+            'model': state.npc.model if isinstance(state.npc, NPC) and state.npc.model else state.chat_model,
+            'provider': state.npc.provider if isinstance(state.npc, NPC) and state.npc.provider else state.chat_provider,
+            'npc': state.npc,
+            
+            # All other specific defaults
+            'sprovider': state.search_provider,
+            'emodel': state.embedding_model,
+            'eprovider': state.embedding_provider,
+            'igmodel': state.image_gen_model,
+            'igprovider': state.image_gen_provider,
+            'vgmodel': state.video_gen_model, 
+            'vgprovider':state.video_gen_provider,
+            'vmodel': state.vision_model,
+            'vprovider': state.vision_provider,
+            'rmodel': state.reasoning_model,
+            'rprovider': state.reasoning_provider,
         }
-        #print(handler_kwargs, command)
-        if stdin_input is not None:
-            handler_kwargs['stdin_input'] = stdin_input
-
+        
+        if len(normalized_flags)>0:
+            kwarg_part = 'with kwargs: \n    -' + '\n    -'.join(f'{key}={item}' for key, item in normalized_flags.items())
+        else:
+            kwarg_part = ''
+
+        # 4. Merge the clean, normalized flags. This will correctly overwrite defaults.
+        render_markdown(f'- Calling {command_name} handler {kwarg_part} ')
+        if 'model' in normalized_flags and 'provider' not in normalized_flags:
+            # Call your existing, centralized lookup_provider function
+            inferred_provider = lookup_provider(normalized_flags['model'])
+            if inferred_provider:
+                # Update the provider that will be used for this command.
+                handler_kwargs['provider'] = inferred_provider
+                print(colored(f"Info: Inferred provider '{inferred_provider}' for model '{normalized_flags['model']}'.", "cyan"))
+        if 'provider' in normalized_flags and 'model' not in normalized_flags:
+            # loop up mhandler_kwargs model's provider
+            current_provider = lookup_provider(handler_kwargs['model'])
+            if current_provider != normalized_flags['provider']:
+                print(f'Please specify a model for the provider: {normalized_flags['provider']}')
+        handler_kwargs.update(normalized_flags)
+        
+        
         try:
-            result_dict = handler(command, **handler_kwargs)
-
+            result_dict = handler(command=command, **handler_kwargs)
+            # add the output model and provider for the print_and_process_stream downstream processing
             if isinstance(result_dict, dict):
                 state.messages = result_dict.get("messages", state.messages)
                 return state, result_dict
             else:
                 return state, result_dict
-
         except Exception as e:
             import traceback
             print(f"Error executing slash command '{command_name}':", file=sys.stderr)
             traceback.print_exc()
             return state, colored(f"Error executing slash command '{command_name}': {e}", "red")
-
     active_npc = state.npc if isinstance(state.npc, NPC) else None
     jinx_to_execute = None
     executor = None
@@ -636,6 +779,7 @@ def execute_slash_command(command: str, stdin_input: Optional[str], state: Shell
 
     return state, colored(f"Unknown slash command or jinx: {command_name}", "red")
 
+
 def process_pipeline_command(
     cmd_segment: str,
     stdin_input: Optional[str],
@@ -648,6 +792,7 @@ def process_pipeline_command(
 
     available_models_all = get_locally_available_models(state.current_path)
     available_models_all_list = [item for key, item in available_models_all.items()]
+
     model_override, provider_override, cmd_cleaned = get_model_and_provider(
         cmd_segment, available_models_all_list
     )
@@ -655,8 +800,11 @@ def process_pipeline_command(
     if not cmd_to_process:
          return state, stdin_input
 
-    exec_model = model_override or state.chat_model
-    exec_provider = provider_override or state.chat_provider
+    npc_model = state.npc.model if isinstance(state.npc, NPC) and state.npc.model else None
+    npc_provider = state.npc.provider if isinstance(state.npc, NPC) and state.npc.provider else None
+
+    exec_model = model_override or npc_model or state.chat_model
+    exec_provider = provider_override or npc_provider or state.chat_provider
 
     if cmd_to_process.startswith("/"):
         return execute_slash_command(cmd_to_process, stdin_input, state, stream_final)
@@ -665,23 +813,25 @@ def process_pipeline_command(
     if not cmd_parts:
         return state, stdin_input
 
-    if validate_bash_command(cmd_parts):
-        command_name = cmd_parts[0]
-        if command_name in interactive_commands:
-            return handle_interactive_command(cmd_parts, state)
-        if command_name == "cd":
-            return handle_cd_command(cmd_parts, state)
+    command_name = cmd_parts[0]
+
+    if command_name == "cd":
+        return handle_cd_command(cmd_parts, state)
+    
+    if command_name in interactive_commands:
+        return handle_interactive_command(cmd_parts, state)
 
+    if validate_bash_command(cmd_parts):
         success, result = handle_bash_command(cmd_parts, cmd_to_process, stdin_input, state)
         if success:
             return state, result
         else:
-            print(colored(f"Bash command failed. Asking LLM for a fix: {result}", "yellow"), file=sys.stderr)
+            print(colored(f"Bash command failed: {result}. Asking LLM for a fix...", "yellow"), file=sys.stderr)
             fixer_prompt = f"The command '{cmd_to_process}' failed with the error: '{result}'. Provide the correct command."
             response = execute_llm_command(
                 fixer_prompt, 
-                model=exec_model, 
-                provider=exec_provider, 
+                model=exec_model,
+                provider=exec_provider,
                 npc=state.npc, 
                 stream=stream_final, 
                 messages=state.messages
@@ -697,8 +847,8 @@ def process_pipeline_command(
 
         llm_result = check_llm_command(
             full_llm_cmd,
-            model=exec_model,
-            provider=exec_provider,
+            model=exec_model,      
+            provider=exec_provider, 
             api_url=state.api_url,
             api_key=state.api_key,
             npc=state.npc,
@@ -707,7 +857,6 @@ def process_pipeline_command(
             images=state.attachments,
             stream=stream_final,
             context=info,
-
         )
         if isinstance(llm_result, dict):
             state.messages = llm_result.get("messages", state.messages)
@@ -716,7 +865,7 @@ def process_pipeline_command(
         else:
             return state, llm_result        
 def check_mode_switch(command:str , state: ShellState):
-    if command in ['/cmd', '/agent', '/chat', '/ride']:
+    if command in ['/cmd', '/agent', '/chat',]:
         state.current_mode = command[1:]
         return True, state     
 
@@ -737,6 +886,10 @@ def execute_command(
     stdin_for_next = None
     final_output = None
     current_state = state 
+    npc_model = state.npc.model if isinstance(state.npc, NPC) and state.npc.model else None
+    npc_provider = state.npc.provider if isinstance(state.npc, NPC) and state.npc.provider else None
+    active_model = npc_model or state.chat_model
+    active_provider = npc_provider or state.chat_provider
 
     if state.current_mode == 'agent':
         for i, cmd_segment in enumerate(commands):
@@ -753,26 +906,25 @@ def execute_command(
 
                 if is_last_command:
                     final_output = output # Capture the output of the last command
-
                 if isinstance(output, str):
                     stdin_for_next = output
-                elif isgenerator(output):
-                    if not stream_this_segment: # If intermediate output is a stream, consume for piping
-                        full_stream_output = "".join(map(str, output))
+                elif not isinstance(output, str):
+                    try:
+                        full_stream_output = print_and_process_stream_with_markdown(output, 
+                                                                                    state.npc.model, 
+                                                                                    state.npc.provider)
                         stdin_for_next = full_stream_output
                         if is_last_command: 
                             final_output = full_stream_output
-                    else: # Final output is a stream, don't consume, can't pipe
-                        stdin_for_next = None
-                        final_output = output
-                elif output is not None: # Try converting other types to string
-                    try: 
-                        stdin_for_next = str(output)
-                    except Exception:
-                        print(f"Warning: Cannot convert output to string for piping: {type(output)}", file=sys.stderr)
-                        stdin_for_next = None
-                else: # Output was None
-                    stdin_for_next = None
+                    except:
+                        if output is not None: # Try converting other types to string
+                            try: 
+                                stdin_for_next = str(output)
+                            except Exception:
+                                print(f"Warning: Cannot convert output to string for piping: {type(output)}", file=sys.stderr)
+                                stdin_for_next = None
+                        else: # Output was None
+                            stdin_for_next = None
 
 
             except Exception as pipeline_error:
@@ -783,7 +935,7 @@ def execute_command(
                 return current_state, error_msg
 
         # Store embeddings using the final state
-        if final_output is not None and not (isgenerator(final_output) and current_state.stream_output):
+        if final_output is not None and isinstance(final_output,str):
             store_command_embeddings(original_command_for_embedding, final_output, current_state)
 
         # Return the final state and the final output
@@ -821,8 +973,8 @@ def execute_command(
         # Otherwise, treat as chat (LLM)
         response = get_llm_response(
             command, 
-            model=state.chat_model, 
-            provider=state.chat_provider, 
+            model=active_model,          
+            provider=active_provider,    
             npc=state.npc,
             stream=state.stream_output,
             messages=state.messages
@@ -833,14 +985,17 @@ def execute_command(
     elif state.current_mode == 'cmd':
 
         response = execute_llm_command(command, 
-                                                 model = state.chat_model, 
-                                                 provider = state.chat_provider, 
+                                        model=active_model,          
+                                        provider=active_provider,  
                                                  npc = state.npc, 
                                                  stream = state.stream_output, 
                                                  messages = state.messages) 
         state.messages = response['messages']     
         return state, response['response']
 
+    """    
+    # to be replaced with a standalone corca mode
+    
     elif state.current_mode == 'ride':
         # Allow bash commands in /ride mode
         cmd_parts = parse_command_safely(command)
@@ -871,379 +1026,8 @@ def execute_command(
 
         # Otherwise, run the agentic ride loop
         return agentic_ride_loop(command, state)
-@dataclass
-class RideState:
-    """Lightweight state tracking for /ride mode"""
-    todos: List[Dict[str, Any]] = field(default_factory=list)
-    constraints: List[str] = field(default_factory=list)
-    facts: List[str] = field(default_factory=list)
-    mistakes: List[str] = field(default_factory=list)
-    successes: List[str] = field(default_factory=list)
-    current_todo_index: int = 0
-    current_subtodo_index: int = 0
-    
-    def get_context_summary(self) -> str:
-        """Generate lightweight context for LLM prompts"""
-        context = []
-        if self.facts:
-            context.append(f"Facts: {'; '.join(self.facts[:5])}")  # Limit to 5 most recent
-        if self.mistakes:
-            context.append(f"Recent mistakes: {'; '.join(self.mistakes[-3:])}")
-        if self.successes:
-            context.append(f"Recent successes: {'; '.join(self.successes[-3:])}")
-        return "\n".join(context)
-
-def interactive_edit_list(items: List[str], item_type: str) -> List[str]:
-    """Interactive REPL for editing lists of items with regeneration options"""
-    while True:
-        print(f"\nCurrent {item_type}:")
-        for i, item in enumerate(items, 1):
-            print(f"{i}. {item}")
-        
-        choice = input(f"\nEdit {item_type} (e<num> to edit, d<num> to delete, a to add, r to regenerate, c to add context, ok to continue): ").strip()
-        
-        if choice.lower() == 'ok':
-            break
-        elif choice.lower() == 'r':
-            print("Regenerating list...")
-            return "REGENERATE"  # Special signal to regenerate
-        elif choice.lower() == 'c':
-            additional_context = input("Add more context: ").strip()
-            if additional_context:
-                return {"ADD_CONTEXT": additional_context, "items": items}
-        elif choice.lower() == 'a':
-            new_item = input(f"Enter new {item_type[:-1]}: ").strip()
-            if new_item:
-                items.append(new_item)
-        elif choice.lower().startswith('e'):
-            try:
-                idx = int(choice[1:]) - 1
-                if 0 <= idx < len(items):
-                    print(f"Current: {items[idx]}")
-                    new_item = input("New version: ").strip()
-                    if new_item:
-                        items[idx] = new_item
-            except ValueError:
-                print("Invalid format. Use e<number>")
-        elif choice.lower().startswith('d'):
-            try:
-                idx = int(choice[1:]) - 1
-                if 0 <= idx < len(items):
-                    items.pop(idx)
-            except ValueError:
-                print("Invalid format. Use d<number>")
-        else:
-            print("Invalid choice. Use: e<num>, d<num>, a, r (regenerate), c (add context), or ok")
-    
-    return items
-def generate_todos(user_goal: str, state: ShellState, additional_context: str = "") -> List[Dict[str, Any]]:
-    """Generate high-level todos for the user's goal"""
-    path_cmd = 'The current working directory is: ' + state.current_path
-    ls_files = 'Files in the current directory (full paths):\n' + "\n".join([os.path.join(state.current_path, f) for f in os.listdir(state.current_path)]) if os.path.exists(state.current_path) else 'No files found in the current directory.'
-    platform_info = f"Platform: {platform.system()} {platform.release()} ({platform.machine()})"
-    info = path_cmd + '\n' + ls_files + '\n' + platform_info 
-
-
-    
-    high_level_planning_instruction = """
-    You are a high-level project planner. When a user asks to work on a file or code,
-    structure your plan using a simple, high-level software development lifecycle:
-    1. First, understand the current state (e.g., read the relevant file).
-    2. Second, make the required changes based on the user's goal.
-    3. Third, verify the changes work as intended (e.g., test the code).
-    Your generated todos should reflect this high-level thinking.
-
-
-    
-    """
-    
-    prompt = f"""
-    {high_level_planning_instruction}
-
-    User goal: {user_goal}
-    
-    {additional_context}
-    
-    Generate a list of 3 todos to accomplish this goal. Use specific actionable language based on the user request. 
-    Do not make assumptions about user needs. 
-    Every todo must be directly sourced from the user's request.     
-    If users request specific files to be incorporated, you MUST include the full path to the file in the todo.
-    Here is some relevant information for the current folder and working directory that may be relevant:
-    {info}
-
-    For example, if the user says "I need to add a new function to calculate the average of a list of numbers my research.py script" and the current working directory is /home/user/projects and one
-     of the available files in the current directory is /home/user/projects/research.py then one of the todos should be:
-    - "Add a new function to /home/user/projects/research.py to calculate the average of a list of numbers"
-    Do not truncate paths. Do not additional paths. Use them exactly as they are provided here.
-    
-    Each todo should be:
-    - Specific and actionable
-    - Independent where possible
-    - Focused on a single major component
-
-    Remember, it is critical to provide as much relevant information as possible. Even if the user only refers to a file or something by a relative path, it is
-    critical for operation that you provide the full path to the file in the todo item.
-
-    Return JSON with format:
-    {{
-        "todos": [
-            todo1, todo2, todo3,
-                    ]
-    }}
-    """
-    
-    response = get_llm_response(
-        prompt,
-        model=state.chat_model,
-        provider=state.chat_provider,
-        npc=state.npc,
-        format="json"
-    )
-    
-    todos_data = response.get("response", {}).get("todos", [])
-    return todos_data
-
-
-def generate_constraints(todos: List[Dict[str, Any]], user_goal: str, state: ShellState) -> List[str]:
-    """Generate constraints and requirements that define relationships between todos"""
-    prompt = f"""
-    User goal: {user_goal}
-    
-    Todos to accomplish:
-    {chr(10).join([f"- {todo}" for todo in todos])}
-    
-    Based ONLY on what the user explicitly stated in their goal, identify any constraints or requirements they mentioned.
-    Do NOT invent new constraints. Only extract constraints that are directly stated or clearly implied by the user's request.
-    
-    Examples of valid constraints:
-    - If user says "without breaking existing functionality" -> "Maintain existing functionality"
-    - If user says "must be fast" -> "Performance must be optimized"
-    - If user says "should integrate with X" -> "Must integrate with X"
-    
-    If the user didn't specify any constraints, return an empty list.
-    
-    Return JSON with format:
-    {{
-        "constraints": ["constraint 1", "constraint 2", ...]
-    }}
-    """
-    
-    response = get_llm_response(
-        prompt,
-        model=state.chat_model,
-        provider=state.chat_provider,
-        npc=state.npc,
-        format="json"
-    )
-    
-    constraints_data = response.get("response", {})
-    
-    if isinstance(constraints_data, dict):
-        constraints = constraints_data.get("constraints", [])
-        # Make sure we're getting strings, not dicts
-        cleaned_constraints = []
-        for c in constraints:
-            if isinstance(c, str):
-                cleaned_constraints.append(c)
-        return cleaned_constraints
-    else:
-        return []
-def should_break_down_todo(todo, state: ShellState) -> bool:
-    """Ask LLM if a todo needs breakdown, then ask user for confirmation"""
-    prompt = f"""
-    Todo: {todo}
-
-        
-    Does this todo need to be broken down into smaller, more atomic components?
-    Consider:
-    - Is it complex enough to warrant breakdown?
-    - Would breaking it down make execution clearer?
-    - Are there multiple distinct steps involved?
-    
-    Return JSON: {{"should_break_down": true/false, "reason": "explanation"}}
-    """
-    
-    response = get_llm_response(
-        prompt,
-        model=state.chat_model,
-        provider=state.chat_provider,
-        npc=state.npc,
-        format="json"
-    )
-    
-    result = response.get("response", {})
-    llm_suggests = result.get("should_break_down", False)
-    reason = result.get("reason", "No reason provided")
-    
-    if llm_suggests:
-        print(f"\nLLM suggests breaking down: '{todo}'")
-        print(f"Reason: {reason}")
-        user_choice = input("Break it down? [y/N]: ").strip().lower()
-        return user_choice in ['y', 'yes']
-    
-    return False
-
-def generate_subtodos(todo, state: ShellState) -> List[Dict[str, Any]]:
-    """Generate atomic subtodos for a complex todo"""
-    prompt = f"""
-    Parent todo: {todo}
-    
-    Break this down into atomic, executable subtodos. Each subtodo should be:
-    - A single, concrete action
-    - Executable in one step
-    - Clear and unambiguous
-    
-    Return JSON with format:
-    {{
-        "subtodos": [
-             "subtodo description",
-            ...
-        ]
-    }}
-    """
-    
-    response = get_llm_response(
-        prompt,
-        model=state.chat_model,
-        provider=state.chat_provider,
-        npc=state.npc,
-        format="json"
-    )
-    
-    return response.get("response", {}).get("subtodos", [])
-def execute_todo_item(todo: Dict[str, Any], ride_state: RideState, shell_state: ShellState) -> bool:
-    """Execute a single todo item using the existing jinx system"""
-    path_cmd = 'The current working directory is: ' + shell_state.current_path
-    ls_files = 'Files in the current directory (full paths):\n' + "\n".join([os.path.join(shell_state.current_path, f) for f in os.listdir(shell_state.current_path)]) if os.path.exists(shell_state.current_path) else 'No files found in the current directory.'
-    platform_info = f"Platform: {platform.system()} {platform.release()} ({platform.machine()})"
-    info = path_cmd + '\n' + ls_files + '\n' + platform_info 
-
-    command = f"""
-
-    General information:
-    {info}
-    
-    Execute this todo: {todo}
-    
-    Constraints to follow:
-    {chr(10).join([f"- {c}" for c in ride_state.constraints])}
-    """
-    
-    print(f"\nExecuting: {todo}")
-    
-
-    result = check_llm_command(
-        command,
-        model=shell_state.chat_model,
-        provider=shell_state.chat_provider,
-        npc=shell_state.npc,
-        team=shell_state.team,
-        messages=[],
-        stream=shell_state.stream_output,
-
-    )
-    
-    output_payload = result.get("output", "")
-    output_str = ""
-
-
-    if isgenerator(output_payload):
-        output_str = print_and_process_stream_with_markdown(output_payload, shell_state.chat_model, shell_state.chat_provider)
-    elif isinstance(output_payload, dict):
-        output_str = output_payload.get('output', str(output_payload))
-        if 'output' in output_str:
-            output_str = output_payload['output']
-        elif 'response' in output_str:
-            output_str = output_payload['response']
-        render_markdown(output_str)
-    elif output_payload:
-        output_str = str(output_payload)
-        render_markdown(output_str)
-
-    user_feedback = input(f"\nTodo completed successfully? [y/N/notes]: ").strip()
-    
-    if user_feedback.lower() in ['y', 'yes']:
-        return True, output_str
-    elif user_feedback.lower() in ['n', 'no']:
-        mistake = input("What went wrong? ").strip()
-        ride_state.mistakes.append(f"Failed {todo}: {mistake}")
-        return False, output_str
-    else:
-        ride_state.facts.append(f"Re: {todo}: {user_feedback}")
-        success = input("Mark as completed? [y/N]: ").strip().lower() in ['y', 'yes']
-        return success, output_str
-
-def agentic_ride_loop(user_goal: str, state: ShellState) -> tuple:
-    """
-    New /ride mode: hierarchical planning with human-in-the-loop control
     """
-    ride_state = RideState()
-    
-    # 1. Generate high-level todos
-    print("🚀 Generating high-level todos...")
-    todos = generate_todos(user_goal, state)
-    
-    # 2. User reviews/edits todos
-    print("\n📋 Review and edit todos:")
-    todo_descriptions = [todo for todo in todos]
-    edited_descriptions = interactive_edit_list(todo_descriptions, "todos")
-    
 
-    ride_state.todos = edited_descriptions
-    
-    # 3. Generate constraints
-    print("\n🔒 Generating constraints...")
-    constraints = generate_constraints(edited_descriptions, user_goal, state)
-    
-    # 4. User reviews/edits constraints
-    print("\n📐 Review and edit constraints:")
-    edited_constraints = interactive_edit_list(constraints, "constraints")
-    ride_state.constraints = edited_constraints
-    
-    # 5. Execution loop
-    print("\n⚡ Starting execution...")
-    
-    for i, todo in enumerate(edited_descriptions):
-        print(f"\n--- Todo {i+1}/{len(todos)}: {todo} ---")
-        
-        def attempt_execution(current_todo):
-            # This inner function handles the execution and retry logic
-            success, output_str = execute_todo_item(current_todo, ride_state, state)
-            if not success:
-                retry = input("Retry this todo? [y/N]: ").strip().lower()
-                if retry in ['y', 'yes']:
-                    success, output_str = execute_todo_item(current_todo, ride_state, state)
-            return success, output_str
-
-        if should_break_down_todo(todo, state):
-            print("Breaking down todo...")
-            subtodos = generate_subtodos(todo, state)
-            subtodo_descriptions = [st for st in subtodos]
-            edited_subtodos = interactive_edit_list(subtodo_descriptions, "subtodos")
-
-            for j, subtodo_desc in enumerate(edited_subtodos):
-                subtodo = {"description": subtodo_desc, "type": "atomic"}
-                success, output = attempt_execution(subtodo)
-                if success:
-                    ride_state.successes.append({"description": subtodo_desc, "output": output})
-                else:
-                    print("Subtodo failed. Continuing to next...")
-        else:
-            success, output = attempt_execution(todo)
-            if success:
-                ride_state.successes.append({"description": todo, "output": output})
-    # 6. Final summary
-    print("\n🎯 Execution Summary:")
-    print(f"Successes: {len(ride_state.successes)}")
-    print(f"Mistakes: {len(ride_state.mistakes)}")
-    print(f"Facts learned: {len(ride_state.facts)}")
-    
-    return state, {
-        "todos_completed": len(ride_state.successes),
-        "ride_state": ride_state,
-        "final_context": ride_state.get_context_summary()
-    }
-# --- Main Application Logic ---
 
 def check_deprecation_warnings():
     if os.getenv("NPCSH_MODEL"):
@@ -1279,6 +1063,7 @@ def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
     os.makedirs(os.path.dirname(db_path), exist_ok=True)
     command_history = CommandHistory(db_path)
 
+
     try:
         history_file = setup_readline()
         atexit.register(save_readline_history)
@@ -1324,7 +1109,7 @@ def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
                 if use_jinxs == "c":
                     global_jinxs_dir = os.path.expanduser("~/.npcsh/npc_team/jinxs")
                     if os.path.exists(global_jinxs_dir):
-                        shutil.copytree(global_jinxs_dir, os.path.join(team_dir, "jinxs"), dirs_exist_ok=True)
+                        shutil.copytree(global_jinxs_dir, team_dir, dirs_exist_ok=True)
                 else:
                     team_ctx_data["use_global_jinxs"] = True
 
@@ -1352,7 +1137,7 @@ def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
                 print(f"Warning: Could not load context file {filename}: {e}")
 
     forenpc_name = team_ctx.get("forenpc", default_forenpc_name)
-    print(f"Using forenpc: {forenpc_name}")
+    #render_markdown(f"- Using forenpc: {forenpc_name}")
 
     if team_ctx.get("use_global_jinxs", False):
         jinxs_dir = os.path.expanduser("~/.npcsh/npc_team/jinxs")
@@ -1364,89 +1149,196 @@ def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
 
     forenpc_obj = None
     forenpc_path = os.path.join(team_dir, f"{forenpc_name}.npc")
-    #print('forenpc_path', forenpc_path)
-    #print('jinx list', jinxs_list)
-    if os.path.exists(forenpc_path):
 
-        forenpc_obj = NPC(file = forenpc_path, jinxs=jinxs_list)
+
+    #render_markdown('- Loaded team context'+ json.dumps(team_ctx, indent=2))
+
+
+    
+    if os.path.exists(forenpc_path):
+        forenpc_obj = NPC(file = forenpc_path, 
+                          jinxs=jinxs_list)
+        if forenpc_obj.model is None:
+            forenpc_obj.model= team_ctx.get("model", initial_state.chat_model)
+        if forenpc_obj.provider is None:
+            forenpc_obj.provider=team_ctx.get('provider', initial_state.chat_provider)
+            
     else:
         print(f"Warning: Forenpc file '{forenpc_name}.npc' not found in {team_dir}.")
 
-    team = Team(team_path=team_dir, forenpc=forenpc_obj, jinxs=jinxs_dict)
+    team = Team(team_path=team_dir, 
+                forenpc=forenpc_obj, 
+                jinxs=jinxs_dict)
+
+    for npc_name, npc_obj in team.npcs.items():
+        if not npc_obj.model:
+            npc_obj.model = initial_state.chat_model
+        if not npc_obj.provider:
+            npc_obj.provider = initial_state.chat_provider
+
+    # Also apply to the forenpc specifically
+    if team.forenpc and isinstance(team.forenpc, NPC):
+        if not team.forenpc.model:
+            team.forenpc.model = initial_state.chat_model
+        if not team.forenpc.provider:
+            team.forenpc.provider = initial_state.chat_provider
+    team_name_from_ctx = team_ctx.get("name")
+    if team_name_from_ctx:
+        team.name = team_name_from_ctx
+    elif team_dir and os.path.basename(team_dir) != 'npc_team':
+        team.name = os.path.basename(team_dir)
+    else:
+        team.name = "global_team" # fallback for ~/.npcsh/npc_team
+
     return command_history, team, forenpc_obj
 
+# In your main npcsh.py file
+
 def process_result(
     user_input: str,
     result_state: ShellState,
     output: Any,
-    command_history: CommandHistory):
+    command_history: CommandHistory
+):
+    # --- Part 1: Save Conversation & Determine Output ---
+    
+    # Define team and NPC names early for consistent logging
+    team_name = result_state.team.name if result_state.team else "__none__"
+    npc_name = result_state.npc.name if isinstance(result_state.npc, NPC) else "__none__"
+    
+    # Determine the actual NPC object to use for this turn's operations
+    active_npc = result_state.npc if isinstance(result_state.npc, NPC) else NPC(
+        name="default", 
+        model=result_state.chat_model, 
+        provider=result_state.chat_provider
+    )
 
-    npc_name = result_state.npc.name if isinstance(result_state.npc, NPC) else result_state.npc
-    team_name = result_state.team.name if isinstance(result_state.team, Team) else result_state.team
     save_conversation_message(
         command_history,
         result_state.conversation_id,
         "user",
         user_input,
         wd=result_state.current_path,
-        model=result_state.chat_model, # Log primary chat model? Or specific used one?
-        provider=result_state.chat_provider,
+        model=active_npc.model,
+        provider=active_npc.provider,
         npc=npc_name,
         team=team_name,
         attachments=result_state.attachments,
     )
-    
-    result_state.attachments = None # Clear attachments after logging user message
+    result_state.attachments = None
 
     final_output_str = None
+    output_content = output.get('output') if isinstance(output, dict) else output
+    model_for_stream = output.get('model', active_npc.model) if isinstance(output, dict) else active_npc.model
+    provider_for_stream = output.get('provider', active_npc.provider) if isinstance(output, dict) else active_npc.provider
+
+    print('\n')
     if user_input =='/help':
-        render_markdown(output)
-        
+        render_markdown(output.get('output'))
     elif result_state.stream_output:
-        
-        if isinstance(output, dict):
-            output_gen = output.get('output')
-            model = output.get('model', result_state.chat_model)
-            provider = output.get('provider', result_state.chat_provider)
-        else:
-            output_gen = output
-            model = result_state.chat_model
-            provider = result_state.chat_provider
-        print('processing stream output with markdown...')
-
-        final_output_str = print_and_process_stream_with_markdown(output_gen, 
-                                                                    model, 
-                                                                    provider)
-                        
-    elif output is not None:
-        final_output_str = str(output)
-        render_markdown( final_output_str)
-    if final_output_str and result_state.messages and result_state.messages[-1].get("role") != "assistant":
-        result_state.messages.append({"role": "assistant", "content": final_output_str})
-
-    #print(result_state.messages)
 
 
+        final_output_str = print_and_process_stream_with_markdown(output_content, model_for_stream, provider_for_stream)
+    elif output_content is not None:
+        final_output_str = str(output_content)
+        render_markdown(final_output_str)
 
     if final_output_str:
+
+        if result_state.messages and (not result_state.messages or result_state.messages[-1].get("role") != "assistant"):
+            result_state.messages.append({"role": "assistant", "content": final_output_str})
         save_conversation_message(
             command_history,
             result_state.conversation_id,
             "assistant",
             final_output_str,
             wd=result_state.current_path,
-            model=result_state.chat_model,
-            provider=result_state.chat_provider,
+            model=active_npc.model,
+            provider=active_npc.provider,
             npc=npc_name,
             team=team_name,
         )
 
+        conversation_turn_text = f"User: {user_input}\nAssistant: {final_output_str}"
+        conn = command_history.conn
+
+        try:
+            if not should_skip_kg_processing(user_input, final_output_str):
+
+                npc_kg = load_kg_from_db(conn, team_name, npc_name, result_state.current_path)
+                evolved_npc_kg, _ = kg_evolve_incremental(
+                    existing_kg=npc_kg, 
+                    new_content_text=conversation_turn_text,
+                    model=active_npc.model, 
+                    provider=active_npc.provider, 
+                    get_concepts=True,
+                    link_concepts_facts = False, 
+                    link_concepts_concepts = False, 
+                    link_facts_facts = False, 
+
+                    
+                )
+                save_kg_to_db(conn,
+                              evolved_npc_kg, 
+                              team_name, 
+                              npc_name, 
+                              result_state.current_path)
+        except Exception as e:
+            print(colored(f"Error during real-time KG evolution: {e}", "red"))
+
+        # --- Part 3: Periodic Team Context Suggestions ---
+        result_state.turn_count += 1
+        if result_state.turn_count > 0 and result_state.turn_count % 10 == 0:
+            print(colored("\nChecking for potential team improvements...", "cyan"))
+            try:
+                summary = breathe(messages=result_state.messages[-20:], 
+                                  npc=active_npc)
+                characterization = summary.get('output')
+
+                if characterization and result_state.team:
+                    team_ctx_path = os.path.join(result_state.team.team_path, "team.ctx")
+                    ctx_data = {}
+                    if os.path.exists(team_ctx_path):
+                        with open(team_ctx_path, 'r') as f:
+                           ctx_data = yaml.safe_load(f) or {}
+                    current_context = ctx_data.get('context', '')
+
+                    prompt = f"""Based on this characterization: {characterization},
+
+                    suggest changes (additions, deletions, edits) to the team's context. 
+                    Additions need not be fully formed sentences and can simply be equations, relationships, or other plain clear items.
+                    
+                    Current Context: "{current_context}". 
+                    
+                    Respond with JSON: {{"suggestion": "Your sentence."
+                    }}"""
+                    response = get_llm_response(prompt, npc=active_npc, format="json")
+                    suggestion = response.get("response", {}).get("suggestion")
+
+                    if suggestion:
+                        new_context = (current_context + " " + suggestion).strip()
+                        print(colored("AI suggests updating team context:", "yellow"))
+                        print(f"  - OLD: {current_context}\n  + NEW: {new_context}")
+                        if input("Apply? [y/N]: ").strip().lower() == 'y':
+                            ctx_data['context'] = new_context
+                            with open(team_ctx_path, 'w') as f:
+                                yaml.dump(ctx_data, f)
+                            print(colored("Team context updated.", "green"))
+                        else:
+                            print("Suggestion declined.")
+            except Exception as e:
+                import traceback
+                print(colored(f"Could not generate team suggestions: {e}", "yellow"))
+                traceback.print_exc()
+                
+
+
 def run_repl(command_history: CommandHistory, initial_state: ShellState):
     state = initial_state
     print_welcome_message()
 
 
-    render_markdown(f'- Using {state.current_mode} mode. Use /agent, /cmd, /chat, or /ride to switch to other modes')
+    render_markdown(f'- Using {state.current_mode} mode. Use /agent, /cmd, or /chat to switch to other modes')
     render_markdown(f'- To switch to a different NPC, type /npc <npc_name> or /n <npc_name> to switch to that NPC.')
     render_markdown('\n- Here are the current NPCs available in your team: ' + ', '.join([npc_name for npc_name in state.team.npcs.keys()]))
 
@@ -1457,23 +1349,68 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
         readline.set_completer(completer)
     except:
         pass
+    session_scopes = set()
 
-    def exit_shell(state):
+
+    def exit_shell(current_state: ShellState):
+        """
+        On exit, iterates through all active scopes from the session and
+        creates/updates the specific knowledge graph for each one.
+        """
         print("\nGoodbye!")
-        # update the team ctx file  to update the context and the preferences 
+        print(colored("Processing and archiving all session knowledge...", "cyan"))
+        
+        conn = command_history.conn
+        integrator_npc = NPC(name="integrator", model=current_state.chat_model, provider=current_state.chat_provider)
 
+        # Process each unique scope that was active during the session
+        for team_name, npc_name, path in session_scopes:
+            try:
+                print(f"  -> Archiving knowledge for: T='{team_name}', N='{npc_name}', P='{path}'")
+                
+                # Get all messages for the current conversation that happened in this specific path
+                convo_id = current_state.conversation_id
+                all_messages = command_history.get_conversations_by_id(convo_id)
+                
+                scope_messages = [
+                    m for m in all_messages 
+                    if m.get('directory_path') == path and m.get('team') == team_name and m.get('npc') == npc_name
+                ]
+                
+                full_text = "\n".join([f"{m['role']}: {m['content']}" for m in scope_messages if m.get('content')])
 
+                if not full_text.strip():
+                    print("     ...No content for this scope, skipping.")
+                    continue
 
+                # Load the existing KG for this specific, real scope
+                current_kg = load_kg_from_db(conn, team_name, npc_name, path)
+                
+                # Evolve it with the full text from the session for this scope
+                evolved_kg, _ = kg_evolve_incremental(
+                    existing_kg=current_kg,
+                    new_content_text=full_text,
+                    model=integrator_npc.model,
+                    provider=integrator_npc.provider, 
+                    get_concepts=True,
+                    link_concepts_facts = True, 
+                    link_concepts_concepts = True, 
+                    link_facts_facts = True, 
 
+                )
+                
+                # Save the updated KG back to the database under the same exact scope
+                save_kg_to_db(conn, evolved_kg, team_name, npc_name, path)
+
+            except Exception as e:
+                import traceback
+                print(colored(f"Failed to process KG for scope ({team_name}, {npc_name}, {path}): {e}", "red"))
+                traceback.print_exc()
 
-        #print('beginning knowledge consolidation')
-        #try:
-        #    breathe_result = breathe(state.messages, state.chat_model, state.chat_provider, state.npc)
-        #    print(breathe_result)
-        #except KeyboardInterrupt:
-        #    print("Knowledge consolidation interrupted. Exiting immediately.")
         sys.exit(0)
 
+
+
     while True:
         try:
             try:
@@ -1482,17 +1419,21 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
             except:
                 pass
 
+            display_model = state.chat_model
+            if isinstance(state.npc, NPC) and state.npc.model:
+                display_model = state.npc.model
+
             if is_windows:
                 cwd_part = os.path.basename(state.current_path)
                 if isinstance(state.npc, NPC):
-                    prompt_end = f":{state.npc.name}> "
+                    prompt_end = f":{state.npc.name}:{display_model}> "
                 else:
                     prompt_end = ":npcsh> "
                 prompt = f"{cwd_part}{prompt_end}"
             else:
                 cwd_colored = colored(os.path.basename(state.current_path), "blue")
                 if isinstance(state.npc, NPC):
-                    prompt_end = f":🤖{orange(state.npc.name)}:{state.chat_model}> "
+                    prompt_end = f":🤖{orange(state.npc.name)}:{display_model}> "
                 else:
                     prompt_end = f":🤖{colored('npc', 'blue', attrs=['bold'])}{colored('sh', 'yellow')}> "
                 prompt = readline_safe_prompt(f"{cwd_colored}{prompt_end}")
@@ -1512,11 +1453,15 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
                     continue
                 else:
                     exit_shell(state)
+            team_name = state.team.name if state.team else "__none__"
+            npc_name = state.npc.name if isinstance(state.npc, NPC) else "__none__"
+            session_scopes.add((team_name, npc_name, state.current_path))
 
-            state.current_path = os.getcwd()
             state, output = execute_command(user_input, state)
-            process_result(user_input, state, output, command_history)
-
+            process_result(user_input, state, 
+                           output, 
+                           command_history)
+        
         except KeyboardInterrupt:
             if is_windows:
                 # On Windows, Ctrl+C cancels the current input line, show prompt again
@@ -1528,8 +1473,6 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
         except EOFError:
             # Ctrl+D: exit shell cleanly
             exit_shell(state)
-
-
 def main() -> None:
     parser = argparse.ArgumentParser(description="npcsh - An NPC-powered shell.")
     parser.add_argument(
@@ -1544,8 +1487,6 @@ def main() -> None:
 
     initial_state.npc = default_npc 
     initial_state.team = team
-    #import pdb 
-    #pdb.set_trace()
 
     # add a -g global command to indicate if to use the global or project, otherwise go thru normal flow
     
@@ -1553,8 +1494,9 @@ def main() -> None:
          state = initial_state
          state.current_path = os.getcwd()
          final_state, output = execute_command(args.command, state)
-         if final_state.stream_output and isgenerator(output):
-              for chunk in output: print(str(chunk), end='')
+         if final_state.stream_output:
+              for chunk in output: 
+                  print(str(chunk), end='')
               print()
          elif output is not None:
               print(output)