bardgent 1.0.0__py3-none-any.whl

bardgent/__init__.py

@@ -0,0 +1,3 @@
+"""BardGent - a small terminal coding agent."""
+
+__version__ = "1.0.0"

bardgent/__main__.py

@@ -0,0 +1,5 @@
+"""Allow `python -m bardgent` (and the scheduler daemon spawn) to work."""
+from bardgent.main import main
+
+if __name__ == '__main__':
+    main()

bardgent/checkpoints.py

@@ -0,0 +1,132 @@
+"""
+Silent, git-backed project checkpoints. Every applied Write/Edit inside a
+git repo gets snapshotted onto a side ref (refs/bardgent/checkpoints) via a
+throwaway index file, so it never touches the user's real HEAD, branch, or
+staged changes. /checkpoints lists them, /restore <n> rolls the working
+tree back to one.
+"""
+
+import os
+import json
+import time
+import subprocess
+
+from bardgent import config
+from bardgent.config import log_event
+
+
+def _git_root(path):
+    try:
+        result = subprocess.run(
+            ['git', 'rev-parse', '--show-toplevel'],
+            cwd=os.path.dirname(os.path.abspath(path)) or '.',
+            capture_output=True, text=True, timeout=5,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except (OSError, subprocess.SubprocessError):
+        pass
+    return None
+
+
+def _load_checkpoint_log():
+    if config.CHECKPOINT_LOG.exists():
+        try:
+            return json.loads(config.CHECKPOINT_LOG.read_text(encoding='utf-8'))
+        except (OSError, json.JSONDecodeError):
+            return []
+    return []
+
+
+def _save_checkpoint_log(entries):
+    try:
+        config.PERMISSIONS_DIR.mkdir(exist_ok=True)
+        config.CHECKPOINT_LOG.write_text(json.dumps(entries, indent=2), encoding='utf-8')
+    except OSError as e:
+        log_event(f"CHECKPOINT LOG SAVE FAILED: {e}")
+
+
+def make_git_checkpoint(path, message):
+    root = _git_root(path)
+    if not root:
+        return None
+    try:
+        env = os.environ.copy()
+        env['GIT_INDEX_FILE'] = str(config.CHECKPOINT_INDEX_FILE)
+        subprocess.run(['git', 'add', '-A'], cwd=root, env=env, capture_output=True, text=True, timeout=20)
+        tree = subprocess.run(['git', 'write-tree'], cwd=root, env=env, capture_output=True, text=True, timeout=20)
+        if tree.returncode != 0:
+            log_event(f"CHECKPOINT write-tree failed: {tree.stderr.strip()}")
+            return None
+        tree_hash = tree.stdout.strip()
+
+        parent_args = []
+        parent = subprocess.run(['git', 'rev-parse', config.CHECKPOINT_REF], cwd=root, capture_output=True, text=True, timeout=5)
+        if parent.returncode == 0:
+            parent_args = ['-p', parent.stdout.strip()]
+        else:
+            head = subprocess.run(['git', 'rev-parse', 'HEAD'], cwd=root, capture_output=True, text=True, timeout=5)
+            if head.returncode == 0:
+                parent_args = ['-p', head.stdout.strip()]
+
+        commit = subprocess.run(
+            ['git', 'commit-tree', tree_hash, *parent_args, '-m', message],
+            cwd=root, env=env, capture_output=True, text=True, timeout=20,
+        )
+        if commit.returncode != 0:
+            log_event(f"CHECKPOINT commit-tree failed: {commit.stderr.strip()}")
+            return None
+        commit_hash = commit.stdout.strip()
+
+        upd = subprocess.run(['git', 'update-ref', config.CHECKPOINT_REF, commit_hash], cwd=root, capture_output=True, text=True, timeout=10)
+        if upd.returncode != 0:
+            log_event(f"CHECKPOINT update-ref failed: {upd.stderr.strip()}")
+            return None
+
+        entries = _load_checkpoint_log()
+        entries.append({
+            'time': time.strftime('%Y-%m-%d %H:%M:%S'),
+            'message': message,
+            'commit': commit_hash,
+            'root': root,
+        })
+        entries = entries[-100:]
+        _save_checkpoint_log(entries)
+        log_event(f"CHECKPOINT {commit_hash[:10]} ({message})")
+        return commit_hash
+    except (OSError, subprocess.SubprocessError) as e:
+        log_event(f"CHECKPOINT failed: {type(e).__name__}: {e}")
+        return None
+
+
+def list_checkpoints():
+    entries = _load_checkpoint_log()
+    if not entries:
+        return '(no checkpoints yet. checkpoints are created automatically on Write/Edit inside a git repo)'
+    lines = []
+    for i, e in enumerate(entries, 1):
+        lines.append(f"{i}. {e['time']}  {e['commit'][:10]}  {e['message']}")
+    return '\n'.join(lines)
+
+
+def restore_checkpoint(index):
+    entries = _load_checkpoint_log()
+    try:
+        idx = int(index)
+    except (TypeError, ValueError):
+        return f"Invalid checkpoint index: {index!r}"
+    if idx < 1 or idx > len(entries):
+        return f"No checkpoint at index {idx}. Use /checkpoints to see valid indices."
+    entry = entries[idx - 1]
+    root, commit = entry['root'], entry['commit']
+    try:
+        result = subprocess.run(
+            ['git', 'checkout', commit, '--', '.'],
+            cwd=root, capture_output=True, text=True, timeout=30,
+        )
+        if result.returncode != 0:
+            return f"Restore failed: {result.stderr.strip()}"
+    except (OSError, subprocess.SubprocessError) as e:
+        return f"Restore failed: {type(e).__name__}: {e}"
+    log_event(f"RESTORED checkpoint #{idx} ({commit[:10]})")
+    return f"Working tree in {root} restored to checkpoint #{idx} ({entry['time']}, {commit[:10]}). Your git branch/HEAD/index are untouched. only file contents were overwritten."

bardgent/commands.py

@@ -0,0 +1,335 @@
+"""Slash commands (/model, /clear, /resume, /plan, ...) and mode switching."""
+import datetime
+from rich.panel import Panel
+from rich.markup import escape
+from pathlib import Path
+
+from bardgent import config, skills, scheduler
+from bardgent.config import console, log_event
+from bardgent.state import ask_approval
+from bardgent.session import (
+    session_file_name, do_summary_and_compact, resume_session, list_sessions,
+)
+from bardgent.checkpoints import list_checkpoints, restore_checkpoint
+from bardgent.telegram import discover_telegram_chat_id, send_telegram_message, _save_telegram_chat_id
+from bardgent.skills import install_skill_from_github
+from bardgent.system_prompt import refresh_system_message
+
+COMMANDS = {
+    '/help': 'List all slash commands',
+    '/summary': 'Summarize the current conversation',
+    '/model': 'Show the current model, or switch: /model <name>',
+    '/clear': 'Clear history and start a new session',
+    '/resume': 'Pick a past session and resume it',
+    '/telegram': 'Toggle sending the agent\'s final answers to Telegram',
+    '/plan': 'Switch to PLAN mode (read-only exploration, agent proposes a plan)',
+    '/normal': 'Switch to NORMAL mode (approve each action, default)',
+    '/auto': 'Switch to AUTO mode (auto-approve everything except dangerous commands)',
+    '/mode': 'Show the current mode',
+    '/skills': 'List installed skills (auto-detected capability packs)',
+    '/skill install': 'Install a skill from GitHub: /skill install <github_url>',
+    '/checkpoints': 'List recent git checkpoints (auto-created on Write/Edit)',
+    '/restore': 'Restore the working tree to a checkpoint: /restore <n>',
+    '/schedule': 'Create a scheduled task: /schedule <spec> :: <prompt>. Manage: /schedule pause|resume|delete|run <id> | daemon status|start|stop',
+    '/schedules': 'List scheduled tasks (next/last run, status) and daemon state',
+    '/init': 'Analyze current project (files, structure, key configs) and generate/update AGENTS.md',
+    '/exit': 'Quit Bardgent',
+}
+
+MODE_CYCLE = ['normal', 'auto', 'plan']
+_MODE_COLOR = {'plan': 'cyan', 'normal': 'white', 'auto': 'bold red'}
+
+SCHEDULE_HELP = (
+    "Usage: /schedule <spec> :: <prompt>\n"
+    "  Specs:\n"
+    "    every 30m | every 2h | every 1d   (recurring interval, min 60s)\n"
+    "    daily 09:00 | daily 6pm            (once a day)\n"
+    "    weekly mon 09:00                   (once a week)\n"
+    "    once 2026-07-20 09:00              (a single one-off run)\n"
+    "    cron */15 * * * *                  (standard 5-field cron)\n"
+    "  Example:\n"
+    "    /schedule daily 09:00 :: Summarize my unread Slack messages from the last 24 hours\n"
+    "  Manage existing tasks:\n"
+    "    /schedules                (list all + daemon status)\n"
+    "    /schedule pause <id>\n"
+    "    /schedule resume <id>\n"
+    "    /schedule delete <id>\n"
+    "    /schedule run <id>        (run it right now, on demand)\n"
+    "  Daemon (survives closing the terminal):\n"
+    "    /schedule daemon status\n"
+    "    /schedule daemon start\n"
+    "    /schedule daemon stop\n"
+    "  Note: tasks keep firing after you quit Bardgent as long as the daemon is\n"
+    "  running. A full machine reboot stops the daemon until Bardgent starts again."
+)
+
+
+def switch_mode(state, new_mode, announce=True):
+    """Single source of truth for changing state.mode, used by /plan,
+    /normal, /auto, and the shift+tab shortcut alike."""
+    old_mode = state.mode
+    if new_mode == old_mode:
+        if announce:
+            console.print(f'[dim]Already in {new_mode} mode.[/dim]')
+        return
+    state.mode = new_mode
+    if announce:
+        color = _MODE_COLOR.get(new_mode, 'white')
+        # console.print(f'[{color}]Mode switched: {old_mode} -> {new_mode}[/{color}]')
+        # if new_mode == 'plan':
+        #     console.print('[dim]Only read-only tools are allowed until you switch back with /normal or /auto.[/dim]')
+        # elif new_mode == 'auto':
+        #     console.print('[dim]Non-dangerous actions will be auto-approved without asking. '
+        #                   'Dangerous commands (rm, sudo, chmod, kill, ...) still always ask.[/dim]')
+    log_event(f"[{state.name}] MODE {old_mode} -> {new_mode}")
+    try:
+        from bardgent.status_bar import draw_status_bar
+        draw_status_bar(state, force=True)
+    except Exception:
+        pass
+
+
+def handle_command(user_input, state):
+    cmd = user_input.strip().lower()
+
+    if cmd in ('/help', '/?'):
+        lines = [f"  [bold cyan]{name}[/bold cyan]  {desc}" for name, desc in COMMANDS.items()]
+        console.print(Panel('\n'.join(lines), title='[bold cyan]Commands', border_style='cyan'))
+        return 'handled'
+
+    if cmd == '/model' or cmd.startswith('/model '):
+        parts = user_input.strip().split(maxsplit=1)
+        if len(parts) == 1:
+            console.print(f'Current model: [bold cyan]{config.MODEL}[/bold cyan]')
+        else:
+            new_model = parts[1].strip()
+            try:
+                available = [m.id for m in config.client.models.list().data]
+            except Exception as e:
+                available = None
+                console.print(f'[dim]Could not reach server to verify model list: {e}[/dim]')
+            if available and new_model not in available:
+                console.print(f"[yellow]Warning: '{new_model}' was not found on the server.[/yellow]")
+                console.print(f"[dim]Available: {', '.join(available)}[/dim]")
+                if not ask_approval(state, 'model_switch_unverified', "Switch to it anyway?"):
+                    return 'handled'
+            config.MODEL = new_model
+            console.print(f'[bold green]Model switched to {config.MODEL}.[/bold green]')
+        return 'handled'
+
+    if cmd == '/clear':
+        from bardgent.ui import print_welcome  # local import: avoids a circular import with main.py
+        del state.messages[1:]
+        state.session_file = config.SESSION_DIR / session_file_name()
+        state.last_prompt_tokens = None
+        refresh_system_message(state)
+        console.clear()
+        print_welcome()
+        console.print("[bold green]New session started.[/bold green]")
+        return 'handled'
+
+    if cmd == '/resume':
+        resume_session(state)
+        return 'handled'
+
+    if cmd in ('/plan', '/normal', '/auto'):
+        switch_mode(state, cmd[1:])
+        return 'handled'
+
+    if cmd == '/mode':
+        console.print(f'Current mode: [bold cyan]{state.mode}[/bold cyan]')
+        return 'handled'
+
+    if cmd == '/skills':
+        skills.refresh_skills()
+        console.print(Panel(escape(skills.list_skills_text()), title='[bold cyan]Installed skills', border_style='cyan'))
+        return 'handled'
+
+    if cmd == '/checkpoints':
+        console.print(Panel(escape(list_checkpoints()), title='[bold cyan]Git checkpoints', border_style='cyan'))
+        return 'handled'
+
+    if cmd == '/restore' or cmd.startswith('/restore '):
+        parts = user_input.strip().split(maxsplit=1)
+        if len(parts) == 1:
+            console.print('[yellow]Usage: /restore <n>  (see /checkpoints for indices)[/yellow]')
+            return 'handled'
+        if not ask_approval(state, 'restore_checkpoint',
+                            f"This overwrites files in the working tree to match checkpoint #{parts[1].strip()}. Continue?"):
+            console.print('[yellow]Restore cancelled.[/yellow]')
+            return 'handled'
+        console.print(restore_checkpoint(parts[1].strip()))
+        return 'handled'
+
+    if cmd == '/schedules':
+        console.print(Panel(escape(scheduler.list_tasks_text()), title='[bold cyan]Scheduled tasks', border_style='cyan'))
+        return 'handled'
+
+    if cmd == '/schedule' or cmd.startswith('/schedule '):
+        rest = user_input.strip()[len('/schedule'):].strip()
+        if not rest:
+            console.print(Panel(SCHEDULE_HELP, title='[bold cyan]/schedule help', border_style='cyan'))
+            return 'handled'
+
+        first_word = rest.split(maxsplit=1)[0].lower()
+        if first_word == 'daemon':
+            parts = rest.split(maxsplit=1)
+            action = parts[1].strip().lower() if len(parts) > 1 else 'status'
+            if action in ('status', ''):
+                st = scheduler.daemon_status()
+                if st['running']:
+                    console.print(
+                        f'[green]Scheduler daemon running[/green] (pid {st["pid"]}). '
+                        f'Tasks keep firing after you close the terminal. '
+                        f'Log: ~/.bardgent/scheduler.log'
+                    )
+                else:
+                    console.print(
+                        '[yellow]Scheduler daemon is not running.[/yellow] '
+                        'Start it with /schedule daemon start (or just open Bardgent).'
+                    )
+            elif action == 'start':
+                ok, msg = scheduler.ensure_daemon_running()
+                console.print(f'[green]{msg}[/green]' if ok else f'[red]{msg}[/red]')
+            elif action == 'stop':
+                ok, msg = scheduler.stop_daemon()
+                console.print(f'[green]{msg}[/green]' if ok else f'[red]{msg}[/red]')
+            else:
+                console.print('[yellow]Usage: /schedule daemon status|start|stop[/yellow]')
+            return 'handled'
+
+        if first_word in ('pause', 'resume', 'delete', 'remove', 'cancel', 'run'):
+            parts = rest.split(maxsplit=1)
+            if len(parts) < 2:
+                console.print(f'[yellow]Usage: /schedule {first_word} <id>  (see /schedules for ids)[/yellow]')
+                return 'handled'
+            task_id = parts[1].strip()
+
+            if first_word == 'pause':
+                ok = scheduler.set_enabled(task_id, False)
+                console.print(f'[green]Paused {task_id}.[/green]' if ok else f'[red]No scheduled task with id {task_id}.[/red]')
+            elif first_word == 'resume':
+                ok = scheduler.set_enabled(task_id, True)
+                console.print(f'[green]Resumed {task_id}.[/green]' if ok else f'[red]No scheduled task with id {task_id}.[/red]')
+            elif first_word in ('delete', 'remove', 'cancel'):
+                ok = scheduler.remove_task(task_id)
+                console.print(f'[green]Deleted {task_id}.[/green]' if ok else f'[red]No scheduled task with id {task_id}.[/red]')
+            elif first_word == 'run':
+                task = scheduler.get_task(task_id)
+                if not task:
+                    console.print(f'[red]No scheduled task with id {task_id}.[/red]')
+                elif scheduler.is_task_running(task_id):
+                    console.print(f'[yellow]{task_id} ("{task["name"]}") is already running - not starting a second one.[/yellow]')
+                else:
+                    console.print(f'[cyan]Running {task_id} ("{task["name"]}") now in the background...[/cyan]')
+                    scheduler.run_task_in_background(task_id)
+            return 'handled'
+
+        if '::' not in rest:
+            console.print(Panel(SCHEDULE_HELP, title='[bold cyan]/schedule help', border_style='cyan'))
+            return 'handled'
+
+        spec_part, prompt_part = rest.split('::', 1)
+        task, err = scheduler.add_task(prompt_part.strip(), spec_part.strip())
+        if err:
+            console.print(f'[bold red]Could not create scheduled task:[/bold red] {err}')
+        else:
+            nr_text = scheduler.format_dt(task.get('next_run'))
+            console.print(f'[bold green]Scheduled task created:[/bold green] {task["id"]}  (next run: {nr_text})')
+            st = scheduler.daemon_status()
+            if st['running']:
+                console.print(
+                    f'[dim]Daemon running (pid {st["pid"]}) — this task will still fire if you close the terminal.[/dim]'
+                )
+            else:
+                console.print(
+                    '[yellow]Warning: scheduler daemon is not running. '
+                    'Use /schedule daemon start so tasks fire after you quit.[/yellow]'
+                )
+            if not config.TELEGRAM_BOT_TOKEN:
+                console.print('[dim]Note: no TELEGRAM_BOT_TOKEN configured, results will only be visible via /schedules, not delivered to Telegram.[/dim]')
+            elif not state.telegram_chat_id:
+                console.print('[dim]Note: Telegram isn\'t linked yet - run /telegram once to link it so results get delivered there too.[/dim]')
+        return 'handled'
+
+    if cmd == '/init':
+        console.print('[bold cyan]Starting deep codebase analysis using the agent...[/bold cyan]')
+        
+        analysis_prompt = f"""You are an expert coding agent initializing this project.
+
+**Task**: Thoroughly explore the codebase and create/update `AGENTS.md` in the root with high-quality project context.
+
+Current working directory: {Path.cwd()}
+
+**Steps you must follow:**
+1. Use `Glob("**/*")`, `Glob("*.py")`, `Glob("**/*.md")` etc. to map the structure.
+2. Read key files: `README.md`, `pyproject.toml`, `requirements.txt`, main entry files, config files.
+3. Use `Grep` to find architecture clues, main functions, TODOs, important patterns.
+4. Summarize:
+   - Project purpose
+   - Tech stack
+   - Architecture
+   - Coding conventions
+   - Important files and their roles
+5. Write the final `AGENTS.md` using the `Write` tool.
+
+Make `AGENTS.md` professional, specific to this codebase, and useful for future sessions. Do not be generic."""
+
+        # Use Task via dispatch (correct way)
+        from bardgent.tool_schemas import dispatch_tool
+        result = dispatch_tool('Task', {'prompt': analysis_prompt}, state)
+        
+        console.print(Panel(str(result), title="✅ /init completed - Agent Analysis", border_style="green"))
+        return 'handled'    
+
+    if cmd == '/exit':
+        console.print('Goodbye!')
+        import sys
+        sys.exit(0)
+
+    if cmd == '/summary':
+        do_summary_and_compact(state)
+        return 'handled'
+
+    if cmd == '/telegram':
+        if not config.TELEGRAM_BOT_TOKEN:
+            console.print('[bold red]No TELEGRAM_BOT_TOKEN found (check your .env file). Cannot enable Telegram.[/bold red]')
+            return 'handled'
+
+        if state.telegram_enabled:
+            state.telegram_enabled = False
+            console.print('[yellow]Telegram messaging turned off.[/yellow]')
+            log_event("TELEGRAM disabled")
+            return 'handled'
+
+        if not state.telegram_chat_id:
+            chat_id = discover_telegram_chat_id()
+            if not chat_id:
+                console.print('[bold red]No message received from the bot in time. '
+                              'Message your bot on Telegram, then run /telegram again.[/bold red]')
+                return 'handled'
+            state.telegram_chat_id = chat_id
+            _save_telegram_chat_id(chat_id)
+            console.print(f'[bold green]Telegram linked (chat_id={chat_id}).[/bold green]')
+            log_event(f"TELEGRAM linked chat_id={chat_id}")
+
+        state.telegram_enabled = True
+        console.print('[bold green]Telegram messaging turned on, final answers will be sent there too.[/bold green]')
+        log_event("TELEGRAM enabled")
+        return 'handled'
+
+    if cmd == '/skill install' or cmd.startswith('/skill install '):
+        parts = user_input.strip().split(maxsplit=2)
+        if len(parts) < 3:
+            console.print('[yellow]Usage: /skill install <github_url>[/yellow]')
+            console.print('[dim]Example: /skill install https://github.com/alirezarezvani/claude-skills[/dim]')
+            return 'handled'
+        
+        github_url = parts[2].strip()
+        console.print(f'[cyan]Installing skill from {github_url}...[/cyan]')
+        result = install_skill_from_github(github_url)
+        console.print(result)
+        skills.refresh_skills()
+        return 'handled'
+
+    return None

bardgent/config.py

@@ -0,0 +1,190 @@
+"""
+Central place for constants, paths, the OpenAI-compatible client, logging,
+and anything else every other module needs.
+
+IMPORTANT: `MODEL` is mutated at runtime (via /model). Other modules must
+always read it as `config.MODEL` (attribute access) rather than
+`from bardgent.config import MODEL`, or they'll keep a stale copy.
+"""
+
+import os
+import sys
+import platform
+import logging
+import threading
+import datetime
+import re
+from pathlib import Path
+
+from openai import OpenAI
+from rich.console import Console
+from dotenv import load_dotenv
+
+load_dotenv()
+load_dotenv(Path.expanduser(Path("~/.bardgent/.env")))
+
+console = Console()
+console_lock = threading.RLock()
+
+python_path = sys.executable
+operating_system = platform.platform()
+working_directory = os.getcwd()
+home_directory = os.path.expanduser('~')
+
+client = OpenAI(
+    base_url='https://integrate.api.nvidia.com/v1',
+    api_key=os.environ.get('GEMINI_API_KEY', '')
+)
+
+MODEL = 'nvidia/nemotron-3-ultra-550b-a55b'
+TEMPERATURE = 0.2
+MAX_ITERATIONS = 100
+# Tool loops produce 2 messages per call (assistant tool_calls + tool result).
+# 30 was far too low and mid-turn trims wiped the whole conversation.
+MAX_HISTORY_MESSAGES = 120
+# Always keep at least this many non-system messages after a trim.
+MIN_HISTORY_MESSAGES = 6
+MAX_TOOL_OUTPUT = 24_000
+BASH_TIMEOUT_SECONDS = 60
+# Default wait when the model calls Await() without a timeout.
+BASH_AWAIT_DEFAULT_SECONDS = 30
+# Hard cap on Await waits so a hung process cannot block the agent forever.
+BASH_AWAIT_MAX_SECONDS = 600
+# Default Read() window when limit is omitted but offset is set, and max lines
+# returned in one Read call to keep tool results manageable.
+READ_DEFAULT_LIMIT = 2_000
+READ_MAX_LIMIT = 5_000
+RESPONSE_TOKEN_RESERVE = 8_192
+MAX_HISTORY_TOKENS = 180_000
+AUTO_SUMMARY_TOKEN_THRESHOLD = 140_000
+CONTEXT_WINDOW_TOKENS = 1_000_000
+
+# Retry schedule for transient API failures.
+MODEL_MAX_RETRIES = 10
+MODEL_RETRY_DELAYS = [3, 5, 8, 13, 21, 30, 45, 60, 60, 60]
+
+from openai import (  # noqa: E402  (kept together with the retry schedule above)
+    APIError,
+    APIConnectionError,
+    APITimeoutError,
+    RateLimitError,
+    InternalServerError,
+    BadRequestError,
+    AuthenticationError,
+    PermissionDeniedError,
+    NotFoundError,
+    UnprocessableEntityError,
+)
+
+# Transient / server-side only. 4xx client errors (bad history, bad schema,
+# auth, etc.) must not be retried — they will fail the same way every time.
+RETRYABLE_ERRORS = (APIConnectionError, APITimeoutError, RateLimitError, InternalServerError, APIError)
+NON_RETRYABLE_ERRORS = (
+    BadRequestError,
+    AuthenticationError,
+    PermissionDeniedError,
+    NotFoundError,
+    UnprocessableEntityError,
+)
+
+# ---------------------------------------------------------------------------
+# Modes: plan / normal / auto (Claude Code style)
+# ---------------------------------------------------------------------------
+VALID_MODES = ('plan', 'normal', 'auto')
+READONLY_TOOLS = {
+    'Read', 'Glob', 'Grep', 'WebSearch', 'Fetch',
+    'read_memory', 'list_memory', 'Skill', 'list_skills',
+    # Observe background jobs without mutating the project.
+    'ListJobs', 'Await',
+    # Observing scheduled tasks doesn't mutate anything either.
+    'ListScheduledTasks',
+}
+
+# ---------------------------------------------------------------------------
+# Directories
+# ---------------------------------------------------------------------------
+GLOBAL_DIR = Path.home() / '.bardgent'
+GLOBAL_DIR.mkdir(exist_ok=True)
+
+PERMISSIONS_DIR = Path.cwd() / '.bardgent'
+
+SESSION_DIR = GLOBAL_DIR / "sessions"
+SESSION_DIR.mkdir(exist_ok=True)
+SESSION_PREFIX = "session_"
+SUMMARY_PREFIX = '[Conversation summary so far]: '
+
+BACKUP_DIR = GLOBAL_DIR / "backups"
+BACKUP_DIR.mkdir(exist_ok=True)
+last_backup = {}
+
+MEMORY_FILE = GLOBAL_DIR / 'Bardgent.md'
+
+# Background job log files (Bash run_in_background=true) live here. Must be
+# defined after GLOBAL_DIR, since it's a subdirectory of it.
+JOBS_DIR = GLOBAL_DIR / 'jobs'
+JOBS_DIR.mkdir(exist_ok=True)
+
+CHECKPOINT_REF = 'refs/bardgent/checkpoints'
+CHECKPOINT_LOG = PERMISSIONS_DIR / 'checkpoints.json'
+CHECKPOINT_INDEX_FILE = PERMISSIONS_DIR / 'checkpoint.index'
+
+# ---------------------------------------------------------------------------
+# Telegram
+# ---------------------------------------------------------------------------
+TELEGRAM_BOT_TOKEN = os.environ.get('TELEGRAM_BOT_TOKEN', '')
+TELEGRAM_API_BASE = f'https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}'
+TELEGRAM_CHATID_FILE = GLOBAL_DIR / 'telegram_chat_id.json'
+TELEGRAM_MAX_LEN = 4000
+
+# ---------------------------------------------------------------------------
+# Logging
+# ---------------------------------------------------------------------------
+LOG_FILE = GLOBAL_DIR / 'bardgent.log'
+logging.basicConfig(
+    filename=LOG_FILE,
+    level=logging.INFO,
+    format='%(asctime)s [%(levelname)s] %(message)s',
+)
+
+
+def log_event(msg):
+    logging.info(msg)
+
+
+# ---------------------------------------------------------------------------
+# <thought>/<think> tag stripping
+# ---------------------------------------------------------------------------
+THOUGHT_TAG_RE = re.compile(r"<(?:thought|think)>.*?</(?:thought|think)>", re.DOTALL | re.IGNORECASE)
+THOUGHT_OPEN_RE = re.compile(r"<(?:thought|think)>", re.IGNORECASE)
+
+
+def remove_thoughts(text):
+    if not text:
+        return text
+    text = THOUGHT_TAG_RE.sub("", text)
+    m = THOUGHT_OPEN_RE.search(text)
+    if m:
+        text = text[:m.start()]
+    return text.strip()
+
+
+# ---------------------------------------------------------------------------
+# Misc runtime constants
+# ---------------------------------------------------------------------------
+CWD_MARKER = '__BARDGENT_CWD__'
+IS_WARP = os.environ.get('TERM_PROGRAM') == 'WarpTerminal'
+
+DATETIME = datetime.datetime.now().astimezone()
+
+
+def get_system_info():
+    """Fresh system info for system prompts (CWD can change via Bash)."""
+    return f"""[CRITICAL SYSTEM INFO]:
+- Python Executable Path: {python_path}
+- Operating System: {operating_system}
+- Current Working Directory: {os.getcwd()}
+- User Home Directory: {home_directory}"""
+
+
+# Kept for backward compatibility; prefer get_system_info() in prompts.
+SYSTEM_INFO = get_system_info()