bareagent-cli 0.1.0__py3-none-any.whl

bareagent/__init__.py

@@ -0,0 +1,10 @@
+"""BareAgent package."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("bareagent-cli")
+except PackageNotFoundError:  # running from a source tree that was never installed
+    __version__ = "0.0.0+unknown"
+
+__all__ = ["__version__"]

bareagent/concurrency/__init__.py

@@ -0,0 +1,6 @@
+"""Concurrency modules for BareAgent."""
+
+from bareagent.concurrency.background import BackgroundManager
+from bareagent.concurrency.notification import inject_notifications
+
+__all__ = ["BackgroundManager", "inject_notifications"]

bareagent/concurrency/background.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import queue
+import threading
+from collections.abc import Callable
+from typing import Any
+
+
+class BackgroundManager:
+    """Run slow operations in daemon threads and collect completion notifications."""
+
+    def __init__(self) -> None:
+        self._queue: queue.Queue[dict[str, Any]] = queue.Queue()
+        self._threads: dict[str, threading.Thread] = {}
+        self._lock = threading.Lock()
+
+    def notify(self, task_id: str, message: str, *, status: str = "failed") -> None:
+        """Post an external notification onto the same channel as task completions.
+
+        Used by subsystems that have nothing to run in a background thread but
+        still want their event surfaced through the REPL's background-update
+        injection (see ``src/concurrency/notification.py``). MCP disconnect
+        events flow through here so the user sees them between LLM turns even
+        when no MCP tool was in-flight.
+        """
+        self._queue.put(
+            {
+                "task_id": task_id,
+                "status": status,
+                "error": message,
+            }
+        )
+
+    def submit(self, task_id: str, fn: Callable[..., Any], *args: Any) -> str:
+        with self._lock:
+            # Prune dead threads to prevent unbounded growth.
+            self._threads = {tid: t for tid, t in self._threads.items() if t.is_alive()}
+            active_thread = self._threads.get(task_id)
+            if active_thread is not None:
+                raise ValueError(f"Background task already running: {task_id}")
+
+            thread = threading.Thread(
+                target=self._run,
+                args=(task_id, fn, *args),
+                daemon=True,
+            )
+            self._threads[task_id] = thread
+            thread.start()
+            return task_id
+
+    def is_running(self, task_id: str) -> bool:
+        """Return True if a live (not-yet-finished) thread is registered for ``task_id``.
+
+        Read-only liveness probe used by callers that track long-lived background
+        work by id (e.g. team teammates registered as ``team:<session>:<name>``).
+        Mirrors the ``is_alive()`` checks already used by ``submit`` /
+        ``drain_notifications`` without mutating the thread registry.
+        """
+        with self._lock:
+            thread = self._threads.get(task_id)
+            return thread is not None and thread.is_alive()
+
+    def _run(self, task_id: str, fn: Callable[..., Any], *args: Any) -> None:
+        try:
+            result = fn(*args)
+        except Exception as exc:
+            self._queue.put(
+                {
+                    "task_id": task_id,
+                    "status": "failed",
+                    "error": f"{type(exc).__name__}: {exc}",
+                }
+            )
+            return
+
+        self._queue.put(
+            {
+                "task_id": task_id,
+                "status": "done",
+                "result": result,
+            }
+        )
+
+    def drain_notifications(self) -> list[dict[str, Any]]:
+        notifications: list[dict[str, Any]] = []
+        while True:
+            try:
+                notifications.append(self._queue.get_nowait())
+            except queue.Empty:
+                break
+
+        with self._lock:
+            dead = [tid for tid, t in self._threads.items() if not t.is_alive()]
+            for tid in dead:
+                del self._threads[tid]
+
+        return notifications

bareagent/concurrency/notification.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from typing import Any
+
+from bareagent.concurrency.background import BackgroundManager
+from bareagent.core.fileutil import is_tool_result_message, stringify
+
+_NOTIFICATION_PREFIX = "<background-notifications>"
+
+
+def inject_notifications(
+    messages: list[dict[str, Any]],
+    bg_manager: BackgroundManager,
+) -> None:
+    notifications = bg_manager.drain_notifications()
+    if not notifications:
+        return
+
+    lines = ["后台任务更新："]
+    surfaced = 0
+    for notification in notifications:
+        task_id = str(notification.get("task_id", "unknown"))
+        # Workflow runs (task_id ``wf-<id>``) are delivered in full by the
+        # dedicated _drain_workflow_results channel; skip them here so their
+        # summary is not also injected truncated through this generic path.
+        if task_id.startswith("wf-"):
+            continue
+        surfaced += 1
+        status = str(notification.get("status", "unknown"))
+        detail = ""
+        if "result" in notification:
+            result_text = stringify(notification["result"])
+            if result_text:
+                detail = f" - {result_text[:500]}"
+        elif "error" in notification:
+            error_text = stringify(notification["error"])
+            if error_text:
+                detail = f" - {error_text[:500]}"
+        lines.append(f"- Task {task_id}: {status}{detail}")
+
+    # Every notification was a workflow run (delivered elsewhere) -> nothing to
+    # inject here.
+    if surfaced == 0:
+        return
+
+    notification_message = {
+        "role": "system",
+        "content": (
+            f"{_NOTIFICATION_PREFIX}\n"
+            + "\n".join(lines)
+            + "\n</background-notifications>"
+        ),
+    }
+    if messages and messages[-1].get("role") == "user":
+        if is_tool_result_message(messages[-1]):
+            messages.append(notification_message)
+        else:
+            messages.insert(len(messages) - 1, notification_message)
+        return
+
+    messages.append(notification_message)

bareagent/concurrency/scheduler.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+import logging
+import threading
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+from bareagent.core.fileutil import generate_random_id
+
+logger = logging.getLogger(__name__)
+
+# Guard against `/loop 0 ...` hammering the background pool. Intervals below
+# this floor are rejected at `add()` time.
+MIN_INTERVAL_SEC = 5.0
+
+
+class SchedulerError(Exception):
+    """Raised when a scheduled job cannot be created (bad interval / command)."""
+
+
+@dataclass(slots=True)
+class ScheduledJob:
+    """A shell command repeated on a fixed interval until cancelled.
+
+    ``run_count`` is mutated in place by ``Scheduler._fire`` each time the job
+    triggers; it is the only field that changes after creation.
+    """
+
+    job_id: str
+    interval_sec: float
+    command: str
+    run_count: int = field(default=0)
+
+
+class Scheduler:
+    """Fire shell commands on fixed intervals via repeated ``threading.Timer`` arms.
+
+    The scheduler only owns the *timing*: each fire hands the command to the
+    injected ``notifier`` (a ``BackgroundManager``) so execution and result
+    surfacing reuse the existing background-notification channel. The scheduler
+    never touches ``messages`` / ``console`` itself — that separation is what
+    keeps it thread-safe against the blocking REPL main loop.
+    """
+
+    def __init__(
+        self,
+        *,
+        runner: Callable[[str], Any],
+        notifier: Any,
+    ) -> None:
+        # ``runner`` receives a command string and runs it (REPL injects
+        # ``partial(run_bash, cwd=workspace, raise_on_error=True)``).
+        self._runner = runner
+        # ``notifier`` is the BackgroundManager; we only use ``submit``/``notify``.
+        self._notifier = notifier
+        self._lock = threading.Lock()
+        self._jobs: dict[str, ScheduledJob] = {}
+        self._timers: dict[str, threading.Timer] = {}
+
+    def add(self, interval_sec: float, command: str) -> ScheduledJob:
+        if interval_sec < MIN_INTERVAL_SEC:
+            raise SchedulerError(
+                f"Interval must be at least {MIN_INTERVAL_SEC:g} seconds (got {interval_sec:g})."
+            )
+        command = command.strip()
+        if not command:
+            raise SchedulerError("Command must not be empty.")
+        job_id = f"loop-{generate_random_id(6)}"
+        job = ScheduledJob(job_id=job_id, interval_sec=interval_sec, command=command)
+        with self._lock:
+            self._jobs[job_id] = job
+            self._arm(job)
+        return job
+
+    def _arm(self, job: ScheduledJob) -> None:
+        # Caller holds ``self._lock``. ``Timer.start`` only spins up a thread,
+        # so starting it under the lock is cheap and avoids a race where a
+        # concurrent ``cancel`` misses the freshly-armed timer.
+        timer = threading.Timer(job.interval_sec, self._fire, args=(job.job_id,))
+        timer.daemon = True
+        self._timers[job.job_id] = timer
+        timer.start()
+
+    def _fire(self, job_id: str) -> None:
+        # Runs on the Timer thread: nothing here may raise (a dying daemon
+        # thread is a silent debugging trap — see error-handling spec).
+        try:
+            with self._lock:
+                job = self._jobs.get(job_id)
+                if job is None:
+                    # Cancelled between Timer fire and lock acquisition.
+                    return
+                job.run_count += 1
+                run_id = f"{job_id}-{job.run_count}"
+                command = job.command
+                # Re-arm the next fire while still holding the lock so the
+                # repeat schedule is self-perpetuating until cancelled.
+                self._arm(job)
+            # Hand execution to the background pool outside the lock. A unique
+            # run_id per fire avoids BackgroundManager's same-task-id dedup
+            # ValueError; any submit failure is swallowed (surfaced via notify)
+            # so the schedule keeps running.
+            try:
+                self._notifier.submit(run_id, self._runner, command)
+            except Exception as exc:
+                try:
+                    self._notifier.notify(
+                        run_id,
+                        f"Failed to dispatch scheduled command: {type(exc).__name__}: {exc}",
+                        status="failed",
+                    )
+                except Exception:
+                    logger.exception("Scheduler notify failed for job %s", job_id)
+        except Exception:
+            logger.exception("Scheduler fire failed for job %s", job_id)
+
+    def list(self) -> list[ScheduledJob]:
+        with self._lock:
+            return list(self._jobs.values())
+
+    def cancel(self, job_id: str) -> bool:
+        with self._lock:
+            timer = self._timers.pop(job_id, None)
+            job = self._jobs.pop(job_id, None)
+            if timer is not None:
+                timer.cancel()
+            return job is not None
+
+    def cancel_all(self) -> None:
+        # Idempotent: safe to call multiple times (e.g. exit cleanup).
+        with self._lock:
+            for timer in self._timers.values():
+                timer.cancel()
+            self._timers.clear()
+            self._jobs.clear()

bareagent/config.toml

@@ -0,0 +1,299 @@
+# Tip: run `bareagent init` for an interactive provider setup wizard that writes
+# config.local.toml for you (DeepSeek / OpenAI / Anthropic / Qwen / GLM / custom).
+#
+# 配置热重载（ROADMAP 4.3）：改完本文件 / config.local.toml 后，REPL 内 `/reload`
+# 可热重载 `[ui] theme` 与 `[permission] mode/allow/deny`（改完即生效，无需重启）；
+# 其余配置（provider / mcp / lsp / hooks 等 boot 时固化的连接/客户端）仅报告
+# “需重启”，重启 BareAgent 后才生效。改坏 TOML 时 `/reload` 报错并保持当前配置。
+[provider]
+name = "openai"
+model = "gpt-4.1"
+api_key_env = "OPENAI_API_KEY"
+
+[permission]
+mode = "default"
+
+[ui]
+stream = true
+theme = "catppuccin-mocha"
+
+[subagent]
+max_depth = 3
+default_type = "general-purpose"
+# 可续跑前台子代理上下文的软上限（session 级、内存态）。subagent 跑完会注册一份
+# 可续跑上下文，LLM 用返回的 agent id 经 subagent_send 续跑；超过此数按最旧淘汰。
+# 仅前台、isolation="none" 的子代理可续跑（后台 / worktree 不注册）。restart-required。
+max_resumable = 20
+
+[thinking]
+mode = "adaptive"
+budget_tokens = 10000
+
+[debug]
+enabled = false
+log_dir = ".logs"
+viewer_port = 8321
+pretty = true
+
+[tracing]
+# langfuse = false        # 或设 LANGFUSE_PUBLIC_KEY 环境变量自动启用
+# opentelemetry = false   # 或设 OTEL_EXPORTER_OTLP_ENDPOINT 自动启用
+# content_enabled = true  # 是否上报消息内容（PII 敏感场景可关闭）
+
+# --- MCP (Model Context Protocol) ----------------------------------------
+# 在 [[mcp.servers]] 中声明外部 MCP server，BareAgent 启动时会并发拉起并把远端工具
+# 按 `mcp__<name>__<tool>` 命名注入到工具列表；声明 resources capability 的 server
+# 额外得到 `mcp__<name>__resource_list` / `mcp__<name>__resource_read`；prompts 可
+# 通过 REPL slash 命令 `/mcp:<name>:<prompt>` 触发。REPL 命令：`/mcp status|list|reload <name>`。
+[mcp]
+# 单个 server initialize 握手超时（秒）；超时后该 server 标 UNHEALTHY 并跳过，
+# 不阻塞 REPL boot。
+# start_timeout = 10
+# 单次 tool result 文本字节上限（UTF-8），超出会被截断并追加
+# `[truncated, original size: N bytes]` 后缀。256 KiB 对应主流 LLM context 友好范围。
+# max_result_text_bytes = 262144
+# 单个 image / embedded_resource binary 字节上限（base64 解码后估算），超出会被
+# 替换为 `[Resource omitted: too large (N bytes)]` 占位文本。
+# max_result_binary_bytes = 5242880
+
+# 示例 1：stdio 子进程模式（mcp-server-fetch via uvx）。
+# [[mcp.servers]]
+# name = "fetch"
+# transport = "stdio"
+# command = "uvx"
+# args = ["mcp-server-fetch"]
+# # env = { FETCH_USER_AGENT = "BareAgent/0.1" }
+# # cwd = "/path/to/workspace"
+
+# 示例 2：HTTP Streamable (MCP 2025-03-26) 远端服务。
+# [[mcp.servers]]
+# name = "team-knowledge"
+# transport = "http_streamable"
+# url = "https://mcp.example.com/mcp"
+# headers = { Authorization = "Bearer ${KNOWLEDGE_TOKEN}" }
+# # transport 也可设为 "http_legacy"（MCP 2024-11-05 双端点）以兼容旧 server。
+
+# --- LSP (Language Server Protocol) --------------------------------------
+# 通过 multilspy 接入成熟 Language Server。MVP 暴露 4 个 Tier-1 工具：
+# `lsp_outline` / `lsp_definition` / `lsp_references` / `lsp_diagnostics`。需安装可选 extra：
+#   uv pip install -e ".[lsp]"
+# multilspy 0.0.15 内置语言适配：Python → jedi-language-server（非 pyright；jedi 走
+# 符号导航强、类型诊断弱），TypeScript → typescript-language-server，Rust → rust-analyzer。
+# REPL 命令：`/lsp status|list|reload <language>`。
+[lsp]
+# Hybrid auto-diagnostics-on-edit：edit_file / write_file 成功后自动调 LSP
+# 拿最新诊断，与编辑前的快照按 (file, line, col, severity, message) 五元组
+# 做 diff，将**新增**诊断追加到 tool result 末尾，格式：
+#   Newly introduced diagnostics in <file>:
+#   - [pyright Error] Line N:C — <message>
+# 默认 OFF：保持 edit/write 体验与原版一致；启用前请确认 LSP server 已正常
+# 起来（pyright 第一次全项目分析 5-15s）。
+# auto_diagnostics_on_edit = false
+# 单个 server handshake + initial analysis 超时（秒）。超时标 UNHEALTHY 并跳过，
+# 不阻塞 REPL boot。pyright 通常 5-15s，rust-analyzer 项目较大时可能更久。
+# start_timeout = 15.0
+
+# 示例 1：Python（multilspy 默认走 jedi-language-server，不是 pyright）。
+# [[lsp.servers]]
+# language = "python"                # multilspy code_language（→ JediServer）
+# extensions = [".py", ".pyi"]       # 文件扩展名 → 路由到此 server
+# # initialization_options 透传给 LSP server（透传 LSP-specific 配置）：
+# # initialization_options = { python = { pythonPath = ".venv/bin/python" } }
+
+# 示例 2：TypeScript / JavaScript（typescript-language-server）。
+# [[lsp.servers]]
+# language = "typescript"
+# extensions = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"]
+
+# 示例 3：Rust（rust-analyzer）。
+# [[lsp.servers]]
+# language = "rust"
+# extensions = [".rs"]
+
+# --- Persistent Memory ---------------------------------------------------
+# 文件式跨会话记忆：一条记忆 = 一个带 frontmatter 的 .md 文件，MEMORY.md 作索引。
+# 智能体通过单个 `memory` 工具（命令 view/create/str_replace/insert/delete/rename，
+# 契约对齐 Anthropic memory tool，但注册为普通 client tool，全 provider 可用）读写受限的
+# 记忆目录；会话开局把 MEMORY.md 索引 + MEMORY PROTOCOL 注入 system prompt。
+# REPL 命令：`/remember <文本>`、`/forget <文本>`。子代理（explore/plan/code-review）只读。
+[memory]
+# 关闭后不注入记忆、不暴露可用的 memory 工具（调用返回 disabled 错误）。
+enabled = true
+# 记忆根目录。留空 = 每个项目独立目录 ~/.bareagent/projects/<workspace-slug>/memory/
+# （不污染项目 git）。相对路径相对 workspace，绝对路径原样使用。
+# dir = ""
+# 会话开局注入 system prompt 的 MEMORY.md 索引最大行数。
+# max_index_lines = 200
+# 每轮按用户消息相关性召回并注入的记忆条数（0 = 关闭召回，仅保留开局索引注入）。
+# recall_k = 5
+# 语义/向量召回（task 06-08-semantic-memory-recall）：默认 false = 词法召回（行为不变）。
+# 开启后按 embedding 余弦相似度召回（换了措辞也能命中），embedding 不可用时自动回退词法。
+# 走 env 覆盖 BAREAGENT_MEMORY_SEMANTIC_RECALL，restart-required。
+# semantic_recall = false
+# embedding backend：openai（复用 openai client，可指向独立 embeddings 端点）| local（fastembed，需装 [embeddings] extra）。
+# embedding_backend = "openai"
+# 模型，留空 = backend 默认（openai: text-embedding-3-small；local: BAAI/bge-small-en-v1.5）。
+# embedding_model = ""
+# openai backend 的端点/密钥，留空则复用会话 provider 的 base_url / api_key。
+# embedding_base_url = ""
+# embedding_api_key = ""
+
+# --- Hooks (工具调用前后用户自定义钩子) ----------------------------------
+# 在 [[hooks]] 中声明：在工具调用前后触发自定义 shell 命令。仅在主循环触发，
+# 子代理不触发（隔离）。权限闸（PermissionGuard）仍是安全边界，hooks 是用户自配的
+# 便利层（trust-the-config）。每个 hook 收到一行 JSON stdin（字段对齐 Claude Code）：
+#   PreToolUse:  {"event","tool_name","tool_input","session_id","cwd"}
+#   PostToolUse: 追加 {"tool_output","is_error"}
+# 控制协议（exit code，对齐 Claude Code）：
+#   - PreToolUse exit 2 = 拦截：跳过 handler，stderr 作拒绝理由回灌 LLM（error result）。
+#   - exit 0 = 放行；其他非 0 = 非阻塞警告 + 放行。
+#   - PostToolUse 退出码不影响工具结果（仅非 0 时警告）。
+# 失败模式 = fail-open：hook spawn 失败 / 超时 → 警告 + 放行，不挂主循环。
+# 字段：event（必填，PreToolUse|PostToolUse）、command（必填 shell 命令）、
+#       tool（可选，精确工具名；省略 = 匹配所有工具）、timeout（可选，秒，默认 30）。
+# 默认全部注释掉（不启用任何 hook）。
+#
+# 注意：BareAgent 始终用 UTF-8 把 JSON 写入 hook 的 stdin。务必用
+#       json.load(sys.stdin.buffer)（二进制流 + 隐式 UTF-8 解码）读取，不要用
+#       json.load(sys.stdin)——后者按 OS locale 解码（中文 Windows 控制台是 GBK），
+#       会把非 ASCII 的 tool_input（如中文文件路径）解成乱码。
+
+# 示例 1：PreToolUse —— 挡危险，bash 命令含 "rm -rf" 时 exit 2 拦截。
+# [[hooks]]
+# event = "PreToolUse"
+# tool = "bash"
+# command = "python -c \"import sys,json; cmd=json.load(sys.stdin.buffer)['tool_input'].get('command',''); (sys.stderr.write('blocked: rm -rf'), sys.exit(2)) if 'rm -rf' in cmd else sys.exit(0)\""
+
+# 示例 2：PostToolUse —— write_file 之后自动 ruff format 写入的文件。
+# [[hooks]]
+# event = "PostToolUse"
+# tool = "write_file"
+# command = "python -c \"import sys,json,subprocess; d=json.load(sys.stdin.buffer); p=d['tool_input'].get('file_path'); p and subprocess.run(['ruff','format',p])\""
+# timeout = 60
+
+[cost]
+# Token 用量与成本估算（/cost 命令展示当前会话累计）。
+# 默认内置 Claude Opus/Sonnet/Haiku 4.x 的参考价；其余 model 只显 token 不显 $。
+# [cost.prices] 可覆盖内置价或为任意 model 新增价，单位均为「每百万 token 美元」。
+# 价格可能变动，以 [cost.prices] 覆盖为准。
+# [cost.prices."claude-opus-4-8"]
+# input = 15.0
+# output = 75.0
+# [cost.prices."deepseek-chat"]
+# input = 0.27
+# output = 1.10
+
+# --- Retry (LLM 调用重试策略) --------------------------------------------
+# 瞬时性失败（rate limit / 网络超时 / 5xx / overloaded）自动指数退避重试；
+# 不可重试错误（认证失败 / 400 bad request / 模型不存在 / 未知异常）立即上抛，
+# 不掩盖真正的配置错误。app 层（src/core/retry.py）独占重试，已禁用 SDK 自带重试
+# （anthropic / openai client 均 max_retries=0），避免 2×N 复合放大。
+# 可重试状态码：408 / 409 / 429 / 500 / 502 / 503 / 504 / 529 + 连接/超时类异常。
+# 不可重试状态码：400 / 401 / 403 / 404 / 413 / 422 + 未知异常（保守 fail-fast）。
+# 退避：delay = min(max_delay_sec, base_delay_sec × multiplier^(attempt-1))，
+#       jitter=true 时再叠 full jitter（uniform(0, delay)）。
+# 环境变量覆盖：BAREAGENT_RETRY_ENABLED、BAREAGENT_RETRY_MAX_ATTEMPTS。
+[retry]
+# 关闭后完全无重试（含 SDK，因为 client 始终 max_retries=0）。
+enabled = true
+# 总尝试次数（含首次），<=1 等效关闭重试。
+max_attempts = 3
+# 首次重试前的基础等待秒数。
+base_delay_sec = 1.0
+# 单次退避上限秒数（封顶）。
+max_delay_sec = 30.0
+# 指数退避倍率。
+multiplier = 2.0
+# 是否叠加 full jitter（uniform(0, delay)）打散并发重试。
+jitter = true
+
+# --- Prompt caching (Anthropic 显式 cache_control 断点) --------------------
+# 给静态前缀（tools + system）和增长的对话历史前缀打 cache_control 断点，让多轮
+# agent loop 反复重发的大块上下文走缓存读（约 0.1× 输入价），显著降本提速。
+# 命名 provider 中立，但当前仅 Anthropic provider 生效（需显式打断点）；
+# OpenAI/DeepSeek 自动缓存、无请求侧旋钮，此开关对它们为 no-op（其命中量仍计入 /cost）。
+# 关闭（enabled=false）时 Anthropic 请求体与未接缓存前字节级一致（向后兼容）。
+# 注意：Opus 4.5+ 最小可缓存前缀为 4096 token，低于阈值静默 no-op（不报错）。
+# 缓存读写 token 计入 /cost：写 1.25×（5m）、读 0.1×（claude）。
+# 环境变量覆盖：BAREAGENT_CACHE_ENABLED。
+# 改 [cache] 需重启生效（boot 时固化进 provider，不在 /reload 热重载集内）。
+[cache]
+# 是否启用 prompt caching（默认开启）。
+enabled = true
+# 缓存 TTL："5m"（默认，交互式 agent 甜区）或 "1h"（写 2×，适合长时间挂起）。
+ttl = "5m"
+
+[skills]
+# 经验式技能生成：复杂的多轮任务收尾后，agent 自动把工作流起草成可复用 skill
+# 草稿（落 pending 区），用户用 /skill keep 提升到可加载。env 覆盖：
+# BAREAGENT_SKILLS_AUTO_GENERATE。关闭即全链路短路（无额外反思 LLM 调用）。
+auto_generate = true
+# 触发为双条件 AND（自会话开始/上次起草后累计）：工具调用数 + 用户回复数同时达标。
+min_tool_calls = 5
+min_user_replies = 3
+# pending 草稿数量软上限，超出按最旧裁剪（<=0 关闭裁剪）。
+max_pending = 10
+# 生成 skill 根目录覆盖（留空 = ~/.bareagent/projects/<workspace-slug>/skills/，
+# 与仓库 checked-in 的 skills/ 正典分离，项目隔离，不进版本控制）。
+dir = ""
+
+[goal]
+# 完成条件循环：/goal [--max-turns N] <condition> 让 agent 自驱动一轮接一轮地工作，
+# 每轮由一个独立评估器（只看对话 transcript）判定条件是否满足，未达标把理由回灌继续，
+# 达标或触达 max_turns 即停。安全语义：/goal 尊重当前权限模式、绝不自动升级——
+# DEFAULT 下写操作仍每轮弹确认（命令会提示用 /auto 切到无人值守）；循环命令同步阻塞
+# REPL，Esc 可中断。
+# 轮数上限（防止评估器一直判不达标导致无限循环 + 失控成本）。env 覆盖：
+# BAREAGENT_GOAL_MAX_TURNS；行内 --max-turns N 覆盖单次调用。
+max_turns = 25
+# 评估器模型（可选）。留空 = 复用会话 provider/模型（开箱即用、不依赖某家 provider）；
+# 填一个更便宜的 model id（如 claude-haiku-4-5）则经 factory 单独构造评估 provider，
+# 省下每轮用主模型判定"是/否"的开销。boot 固化，改动 restart-required。
+evaluator_model = ""
+
+[workflow]
+# 确定性多智能体编排（task 06-06-workflow-deterministic-orchestration，对标 Claude Code
+# Workflow）：LLM 经一个「主循环专属」的 workflow 工具临场产出一张静态 DAG（nodes +
+# depends_on），相互独立的节点并发跑、依赖就绪才跑，上游产物经 {{node_id}} 占位喂给下游，
+# 收尾把每个节点 done/failed/skipped + 产物结构化聚合回灌 LLM。节点执行复用 run_subagent。
+# 安全语义：节点子代理 fail-closed 无人值守运行（worker 线程不弹确认，与后台子代理 / /loop
+# 一脉相承）——DEFAULT 下写操作被拒、AUTO 下自动放行、PLAN 下只读；workflow 工具不进全局
+# 工具集、子代理拿不到（无嵌套）；同步阻塞调用、Esc 可中断。失败语义：单节点失败 = 其传递
+# 下游 skip、独立分支继续。
+# 扩展（task 06-08-workflow-background-panel-resume-budget）：workflow 工具新增三个可选字段——
+# run_in_background（后台 daemon 跑、立即返回 run id、完成后完整 summary 在下个 turn 回灌 LLM）、
+# resume_from（给上次 run id，复用未变的已完成节点、只重跑变更/失败/新增节点及其下游）、
+# token_budget（软上限，层间检查，超限后剩余节点 skip）。REPL 配套面板 /workflows（list | <run-id>
+# | clear）。run 记录内存级、会话作用域（/new·/resume·/import clear、/compact 保留）。
+# MVP 不做循环/条件/动态 fan-out、不做落盘跨重启 resume、不做取消运行中 workflow、不做
+# worktree per-node 隔离（均为后续扩展位）。
+# 总开关：false 时 workflow 工具压根不注入，整特性短路。env 覆盖：BAREAGENT_WORKFLOW_ENABLED。
+enabled = true
+# 并发上限：同时运行的节点数（每个节点是一个完整子代理，保守取值）。
+max_concurrency = 8
+# 单张 DAG 的节点数上限，防止 LLM 产出超大图打爆线程池。
+max_nodes = 20
+# 缺省 token 预算：workflow 调用未带 token_budget 时的兜底上限，0 = 不限；per-call 字段优先。
+# env 覆盖：BAREAGENT_WORKFLOW_DEFAULT_TOKEN_BUDGET。
+default_token_budget = 0
+# 保留的 run 记录数（面板历史 + resume 来源）上限，FIFO 超出裁剪最旧（优先裁已完成的）。
+# env 覆盖：BAREAGENT_WORKFLOW_MAX_RUNS。
+max_runs = 50
+
+[team]
+# 多智能体队友协调（task 06-06-team-subsystem-completion）：把 team 子系统补到
+# 「LLM 真正能用的协作闭环」。team_send 现在阻塞等队友回复并把回复作为工具结果回灌 LLM
+# （队友未运行 / 目标为 main 则立即返回，不干等超时）；迟到 / 未经请求的回复经邮箱 drain
+# 回灌到下一个 user turn。队友请求处理异常被隔离（回 error response、守护线程存活）；
+# team_shutdown <name> 可单独停一个队友；team_list 经后台线程存活探测反映真实运行状态。
+# 安全语义：队友以 fail-closed 权限无人值守运行（与后台子代理 / /loop 一脉相承）。
+# 两个字段均为 config-only 正数，boot 固化 -> 改动需重启（restart-required）。
+# 队友守护循环空闲时每隔 poll_interval 秒醒来扫一次待办任务（收到消息会立即唤醒）。
+poll_interval = 1.0
+# 阻塞式 team_send 等待队友回复的超时秒数；超时返回提示，迟到回复仍会在后续 turn 浮现。
+response_timeout = 60.0
+# 队友有状态记忆（task 06-08-team-stateful-memory）：开启后队友跨 request 保留对话上下文
+# （连续 team_send 续在同一条会话上，注入 per-teammate Compactor 按 token 阈值压缩防无界增长）；
+# 自认领的 task 仍逐个无状态执行。关掉则回退到逐请求无状态的旧行为。
+# 走 env 覆盖 BAREAGENT_TEAM_MEMORY_ENABLED，boot 固化 -> restart-required。
+memory_enabled = true

bareagent/core/__init__.py

@@ -0,0 +1 @@
+"""Core runtime components for BareAgent."""

bareagent/core/config_paths.py

@@ -0,0 +1,49 @@
+"""Resolution of the bundled config.toml and the user's local override.
+
+config.toml ships *inside* the installed package (``src/bareagent/config.toml``)
+as read-only defaults. The user's ``config.local.toml`` override, however, must
+live somewhere writable:
+
+* For the **bundled default** (read-only, inside the package / site-packages),
+  the override lives in the **current working directory** — so an installed user
+  can ``bareagent init`` / drop a ``config.local.toml`` next to where they run,
+  and a developer running from the repo root keeps picking up the repo's
+  ``config.local.toml``.
+* For an **explicit** ``--config`` / ``BAREAGENT_CONFIG`` path, the override is
+  the ``.local`` sibling of that file (unchanged historical behavior).
+
+This module has no dependency on :mod:`bareagent.main`, so both ``main`` (load +
+mtime watch) and :mod:`bareagent.provider.setup` (``init`` writer) can import it
+without a circular import.
+"""
+
+from __future__ import annotations
+
+from importlib.resources import files
+from pathlib import Path
+
+
+def bundled_config_path() -> Path:
+    """Filesystem path to the config.toml bundled inside the package.
+
+    importlib.resources resolves it for both editable installs (real source
+    tree) and wheel installs (site-packages). BareAgent is never a zipapp, so the
+    resource is always a real on-disk path safe to open later.
+    """
+    return Path(str(files("bareagent").joinpath("config.toml")))
+
+
+DEFAULT_CONFIG_PATH = bundled_config_path()
+
+
+def local_config_path(config_path: Path) -> Path:
+    """Where the ``config.local.toml`` override lives for a given base config.
+
+    Bundled default -> current working directory; explicit path -> its ``.local``
+    sibling.
+    """
+    if config_path == DEFAULT_CONFIG_PATH:
+        return Path.cwd() / "config.local.toml"
+    return config_path.with_suffix("").with_name(
+        config_path.stem + ".local" + config_path.suffix,
+    )