jac-coder 0.2.0__tar.gz → 0.2.2__tar.gz

{jac_coder-0.2.0 → jac_coder-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jac-coder
-Version: 0.2.0
+Version: 0.2.2
 Summary: AI coding agent backend for Jac, powered by jac-byllm
 Requires-Python: >=3.12
 Requires-Dist: python-dotenv>=1.0.0

jac_coder-0.2.2/README.md

@@ -0,0 +1,160 @@
+# JacCoder
+
+![JacCoder CLI](assets/cli.png)
+
+AI coding agent for the Jaseci stack, built entirely in [Jac](https://github.com/jaseci-labs/jaseci) using Object-Spatial Programming. Features an orchestrator-worker architecture with compiler-level Jac Intelligence, self-correcting code writes, and in-process SubAgent delegation.
+
+## Architecture
+
+![JacCoder Graph Architecture](assets/graph.png)
+
+## Features
+
+- **Orchestrator-Worker Architecture** — MainAgent (27 tools) handles tasks directly or delegates to focused WorkerAgent / ExplorerAgent walkers
+- **Jac Intelligence** — compiler-level AST analysis via jaclang (`analyze_project`, `find_symbol`)
+- **Skills System** — Claude-Code-compatible `SKILL.md` directories, lazy-loaded so the LLM gets authoritative Jac syntax instead of stale training data
+- **Self-Correcting Writes** — automatic JS-to-Jac sanitization, in-process syntax check, and `.jac-server.log` error monitoring on every write
+- **Browser Validation Loop** — `browser_validate` shells out to agent-browser with cross-turn FAIL escalation (1st: hint → 2nd: warning → 3rd+: mandatory bisect)
+- **In-Process SubAgents** — walkers, not subprocesses; share event stream + cost tracker + graph context
+- **MCP Integration** — built-in `jac-mcp` plus user-added stdio/http/sse servers, configs persisted in the graph
+- **Multi-Provider LLM** — 100+ models via [byllm](https://github.com/jaseci-labs/byllm); per-session model + API-key override is thread-local (no `os.environ` mutation)
+- **Public API** — clean interface for CLI, VS Code extension, JacBuilder, library mode
+- **Context Management** — smart tiered compaction with LLM-summary fallback; mode-aware dynamic prompt assembly
+
+## Prerequisites
+
+- Python 3.12+
+
+```bash
+pip install jac-coder
+# or for development:
+pip install -e .
+```
+
+Dependencies (auto-installed): `jaclang`, `byllm`, `mcp>=1.0.0`, `jac-mcp`, `python-dotenv`.
+
+## Quick Start
+
+```bash
+# Set API key
+export OPENAI_API_KEY="sk-..."
+
+# Interactive REPL
+jac cli.jac
+
+# Single prompt (non-interactive)
+jac cli.jac run "build a hello world jac app at /tmp/myapp"
+
+# Resume a session
+jac cli.jac session <id-prefix>
+```
+
+## Architecture
+
+```
+Root → Session → MainAgent
+                    ├── handles simple tasks directly (read, search, edit, git, browser)
+                    └── spawn_agent() → WorkerAgent (write+run) or ExplorerAgent (read-only)
+                                         └── walker runs in-process, returns result to MainAgent
+```
+
+- **MainAgent (node)** — orchestrator with 27 tools. Handles simple tasks directly, delegates complex work via `spawn_agent`. `max_react_iterations=80`.
+- **WorkerAgent (walker)** — in-process SubAgent with 14 tools (can write/edit/run). For known changes.
+- **ExplorerAgent (walker)** — in-process SubAgent with 10 tools (read-only + web search). For root-cause investigation.
+- **Session (node)** — persistent chat state, history, active files, errors, mode hint.
+- **ProjectMemory (node)** — AST-derived codebase knowledge (nodes, walkers, edges, imports). Backed by `.jaccoder/progress.md` as primary source of truth.
+- **McpRegistry (node)** — persisted MCP server configs.
+
+See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for the full picture.
+
+## Tools
+
+MainAgent has 27 tools, grouped by domain:
+
+| Group | Tool | Description |
+|-------|------|-------------|
+| Reason | `think` | Explicit reasoning step (loop-guarded) |
+| Read | `read_file` | Read files with line numbers and pagination |
+| Read | `list_files` | List directory contents |
+| Read | `grep_search` | Regex search across files |
+| Read | `find_files` | Find files by glob pattern |
+| Read | `analyze_project` | Full AST analysis (nodes, walkers, edges, imports) |
+| Read | `find_symbol` | Find symbol definition, fields, usages, exact import |
+| Read | `load_jac_skill` | Load full body of a Jac skill by name |
+| Write | `write_code` | Write file — anti-pattern blocking, auto sanitize, syntax check |
+| Write | `edit_code` | Find-and-replace with the same self-correcting pipeline |
+| Run | `run_command` | Execute shell commands (permission-guarded, auto-detects servers → background) |
+| Run | `jac_run` | Run `.jac` files |
+| Git | `git_status`, `git_diff`, `git_log`, `git_commit` | First-class git ops (`git_commit` is the only sanctioned way to commit) |
+| Web | `web_fetch`, `web_search` | HTTP fetch + DuckDuckGo search |
+| Browser | `browser_open`, `browser_do`, `browser_state`, `browser_validate`, `browser_close` | Visual QA via agent-browser; `browser_validate` is the primary pass/fail check |
+| Delegate | `spawn_agent` | In-process WorkerAgent / ExplorerAgent walker |
+| Interact | `ask_question`, `update_todos` | User prompt + multi-step task tracking |
+| MCP | `mcp_call` | Call any tool from a connected MCP server |
+
+## Public API
+
+External apps import only from `jac_coder.api`:
+
+```python
+from jac_coder.api import initialize, create_session, chat, close_session
+
+initialize("web")
+session = create_session("/path/to/project", title="My App")
+result = chat(session["session_id"], "build a calculator")
+print(result["response"])
+```
+
+## Configuration
+
+Config sources (highest priority first):
+
+1. Environment: `MODEL`, `TEMPERATURE`, `MAX_TOKENS`, `MAX_REACT_ITERATIONS`
+2. Project: `./jaccoder.json`
+3. Global: `~/.jaccoder/config.json`
+
+## Testing
+
+```bash
+python -m pytest tests/ -v    # 10 unit suites
+```
+
+## Project Structure
+
+```
+jac-code/
+├── cli.jac                       # CLI entry point (REPL + subcommands)
+├── jac_coder/                    # Core package
+│   ├── api.jac                   # Public API — the only module external apps import
+│   ├── server.jac                # JSON-RPC stdio server for the VS Code extension
+│   ├── core/
+│   │   ├── nodes.jac             # MainAgent, WorkerAgent, ExplorerAgent, Session, ProjectMemory
+│   │   └── walkers.jac           # interact, new_session, list_sessions, etc.
+│   ├── lib/
+│   │   └── coder.jac             # JacCoder library-mode class (stateless + service modes)
+│   ├── infra/
+│   │   ├── config.jac            # Multi-source config + SessionAwareModel (thread-local LLM override)
+│   │   └── mcp_manager.jac       # MCP server registry (graph-persisted)
+│   ├── runtime/
+│   │   ├── context.jac           # Tiered compaction with LLM-summary fallback
+│   │   ├── events.jac            # Event bus, doom-loop detection, abort signal
+│   │   ├── memory.jac            # AST-first ProjectMemory (LLM fallback)
+│   │   ├── permission.jac        # Permission rule engine (allow / ask / deny)
+│   │   ├── prompt.jac            # Mode-aware dynamic prompt assembly
+│   │   ├── skills.jac            # SKILL.md registry + listing injection
+│   │   └── cost_tracker.jac      # Opt-in token + USD cost tracking
+│   ├── tool/                     # 28 tools organized by domain
+│   │   ├── meta/                 # think, spawn_agent, update_todos, ask_question, validate
+│   │   ├── read/                 # filesystem, search, jac_analyzer, load_jac_skill
+│   │   ├── write/                # checked (write_code/edit_code), scaffold
+│   │   ├── run/                  # shell, guarded, jac_tools
+│   │   ├── net/                  # web, preview (browser_*)
+│   │   ├── git.jac               # git_status, git_diff, git_log, git_commit
+│   │   └── mcp.jac               # mcp_call
+│   └── skills/                   # Bundled SKILL.md directories (Claude-Code-compatible)
+├── tests/                        # 10 unit suites (pytest wrappers + check_*.jac)
+├── vscode-jac-coder/             # VS Code extension (TypeScript)
+└── docs/                         # ARCHITECTURE, ROADMAP, PROGRESS, LIBRARY_MODE
+```
+
+<img width="2661" height="1091" alt="image" src="https://github.com/user-attachments/assets/a314087f-ae94-4c8b-8899-1e4ff3eb465c" />

{jac_coder-0.2.0 → jac_coder-0.2.2}/jac_coder/api.impl.jac

@@ -107,9 +107,6 @@ impl create_session(directory: str, title: str = "", agent: str = "main") -> dic
         return {"error": "Failed to create session"};
     }
 
-    # Store in registry so background threads can find it
-    _session_registry[session_id] = session_obj;
-
     return {"session_id": session_id, "title": session_title, "status": "created"};
 }
 
@@ -166,7 +163,6 @@ impl close_session(session_id: str) -> dict {
     }
     matches[0].status = "closed";
     matches[0].updated_at = datetime.now().isoformat();
-    _session_registry.pop(session_id, None);
     return {"status": "closed", "id": matches[0].id};
 }
 
@@ -185,15 +181,9 @@ impl chat(
     edit_mode: str = "auto",
     env_overrides: dict = {}
 ) -> dict {
-    # Find session — try registry first (works across threads), then graph
-    session = _session_registry.get(session_id);
-    if not session {
-        matches = [root()-->][?:Session][?id==session_id];
-        if matches {
-            session = matches[0];
-            _session_registry[session_id] = session;
-        }
-    }
+    # Find session — query the graph directly. The graph is shared across pods
+    # via MongoDB persistence, so this works in single-pod and multi-pod alike.
+    session = _find_session(session_id);
     if not session {
         return {"error": "Session not found", "agent": "error"};
     }
@@ -203,7 +193,6 @@ impl chat(
     try {
         _ = session.id;
     } except Exception {
-        _session_registry.pop(session_id, None);
         return {"error": "Session is stale after a server update. Please close this session and open a new one.", "agent": "error"};
     }
 
@@ -220,8 +209,12 @@ impl chat(
     if env_overrides {
         import from jac_coder.infra.config { set_session_llm }
         import logging as _chatlog;
-        _api_key = str(env_overrides.get("OPENAI_API_KEY", env_overrides.get("ANTHROPIC_API_KEY", "")));
         _model_name = str(env_overrides.get("MODEL", ""));
+        if _model_name.startswith("claude-") {
+            _api_key = str(env_overrides.get("ANTHROPIC_API_KEY", ""));
+        } else {
+            _api_key = str(env_overrides.get("OPENAI_API_KEY", env_overrides.get("ANTHROPIC_API_KEY", "")));
+        }
         _chatlog.getLogger("jac_coder.api").info(f"env_overrides received: model={_model_name} has_key={bool(_api_key)}");
         if _api_key or _model_name {
             import from jac_coder.infra.config { llm as _current_llm }
@@ -251,13 +244,6 @@ impl chat(
         # Memory initialization
         _ensure_memory(session, work_dir);
 
-        # Add user message
-        user_msg_record: dict = {"role": "user", "content": message};
-        if images and len(images) > 0 {
-            user_msg_record["has_images"] = True;
-            user_msg_record["image_count"] = len(images);
-        }
-        session.chat_history.append(user_msg_record);
         session.updated_at = datetime.now().isoformat();
 
         # Get MainAgent — always resolve fresh (cached refs go stale in jac start)
@@ -267,15 +253,33 @@ impl chat(
         config = get_config();
         _init_spawn_budget(config.max_react_iterations * 3);
 
-        # Build context
-        ctx_history = build_context(
-            session.chat_history,
-            session.active_files,
-            session.pending_errors,
-            project_summary=session.project_summary or ""
-        );
+        # Per-turn context gets folded into the user message; we can't add
+        # role=system dicts to session.chat_history without them persisting stale.
+        prefix_parts: list[str] = [];
+
+        if session.project_summary {
+            is_progress_file = session.project_summary.lstrip().startswith("#");
+            label = (
+                "Project progress (.jaccoder/progress.md)"
+                if is_progress_file
+                else "Project context"
+            );
+            prefix_parts.append(
+                f"[INTERNAL — do NOT present this to the user unless they ask about the project. This is your background knowledge for making informed decisions.]\n{label}:\n{session.project_summary}"
+            );
+        }
+        if session.active_files {
+            prefix_parts.append("Active files: " + ", ".join(session.active_files));
+        }
+        if session.pending_errors {
+            prefix_parts.append("Pending errors:\n" + "\n".join(session.pending_errors));
+        }
+
+        mcp_msg = _get_mcp_context_msg();
+        if mcp_msg {
+            prefix_parts.append(str(mcp_msg.get("content", "")));
+        }
 
-        # Inject mode-aware workflow modules (dynamic prompt assembly)
         import from jac_coder.runtime.prompt { select_prompt_modules as _select_modules }
         workflow_modules = _select_modules(
             last_mode_hint=session.last_mode_hint,
@@ -284,20 +288,28 @@ impl chat(
             chat_history=session.chat_history
         );
         if workflow_modules {
-            ctx_history.insert(0, {"role": "system", "content": workflow_modules});
+            prefix_parts.append(workflow_modules);
         }
 
-        # Inject agent_context if provided (e.g. from JacBuilder)
         if agent_context {
-            ctx_history.insert(0, {"role": "system", "content": agent_context});
+            prefix_parts.append(agent_context);
         }
 
-        # Inject available MCP tools into context (cached to avoid rebuilding every turn)
-        mcp_msg = _get_mcp_context_msg();
-        if mcp_msg {
-            ctx_history.insert(0, mcp_msg);
+        if edit_mode == "plan" {
+            prefix_parts.append(
+                "You are in PLAN MODE. Your task is to produce a detailed, step-by-step plan "
+                "for the user's request. Do NOT write, edit, or run any files. "
+                "Describe every file you would create or modify, what changes you would make, "
+                "and why. The user will review your plan and click 'Execute Plan' to apply it."
+            );
         }
 
+        composed_message = (
+            "\n\n---\n\n".join(prefix_parts) + "\n\n---\n\n" + message
+            if prefix_parts
+            else message
+        );
+
         # Early exit if already aborted before LLM starts
         if is_abort_requested() {
             tool_end();
@@ -313,24 +325,6 @@ impl chat(
             };
         }
 
-        # Plan mode — inject instruction to write a plan only, no file writes.
-        # The UI will show "Execute Plan" when done; execution reruns with edit_mode="auto".
-        if edit_mode == "plan" {
-            plan_msg: dict = {
-                "role": "system",
-                "content": (
-                    "You are in PLAN MODE. Your task is to produce a detailed, step-by-step plan "
-                    "for the user's request. Do NOT write, edit, or run any files. "
-                    "Describe every file you would create or modify, what changes you would make, "
-                    "and why. The user will review your plan and click 'Execute Plan' to apply it."
-                )
-            };
-            ctx_with_plan: list[dict] = [plan_msg];
-            ctx_with_plan.extend(ctx_history);
-            ctx_history = ctx_with_plan;
-        }
-
-        # Call MainAgent — returns StreamEvent generator with logging enabled
         # If user attached images, convert to byllm Image object and pass as user_image
         user_image = None;
         if images and len(images) > 0 {
@@ -346,7 +340,10 @@ impl chat(
                 sys.stderr.write(f"[api] Failed to create Image from user attachment: {img_err}\n");
             }
         }
-        event_stream = main_agent.respond(message=message, chat_history=ctx_history, user_image=user_image);
+
+        main_agent._conv = session.chat_history;
+
+        event_stream = main_agent.respond(message=composed_message, user_image=user_image);
         stream_result = _consume_llm_stream(event_stream);
 
         response_text = stream_result["content"];
@@ -386,16 +383,22 @@ impl chat(
             }
         }
 
-        # Persist response — skip if aborted (abort note already in chat_history)
+        # byLLM already appended the assistant/tool turns; patch UI metadata
+        # onto the trailing assistant entry. Skip if aborted.
         if not is_abort_requested() {
-            record: dict = {"role": "assistant", "content": response_text, "agent": "main"};
-            if tools_used {
-                record["tools_used"] = tools_used;
-            }
-            if files_modified {
-                record["files_modified"] = files_modified;
+            for idx in range(len(session.chat_history) - 1, -1, -1) {
+                message_entry = session.chat_history[idx];
+                if message_entry.get("role") == "assistant" and "agent" not in message_entry {
+                    message_entry["agent"] = "main";
+                    if tools_used {
+                        message_entry["tools_used"] = tools_used;
+                    }
+                    if files_modified {
+                        message_entry["files_modified"] = files_modified;
+                    }
+                    break;
+                }
             }
-            session.chat_history.append(record);
         }
         session.last_agent = "main";
         session.updated_at = datetime.now().isoformat();
@@ -557,7 +560,7 @@ impl api_mcp_list() -> list {
 
 
 impl abort_session(session_id: str) -> None {
-    session = _session_registry.get(session_id);
+    session = _find_session(session_id);
     if session {
         session.chat_history.append({
             "role": "assistant",
@@ -567,9 +570,14 @@ impl abort_session(session_id: str) -> None {
 }
 
 
-glob _mcp_ctx_cache: dict = {};  # {"msg": dict, "tool_names": set}
+"""Build MCP tools context message for the LLM system prompt.
 
-"""Build MCP tools context message, cached by tool names."""
+Rebuilt every turn — no module-level cache. The previous in-process cache
+(`_mcp_ctx_cache`) was keyed on `frozenset(tool_names)`, so descriptions or
+inputSchemas could change on another pod without invalidating the cache,
+causing stale system prompts. Rebuild cost is ~50us of string formatting,
+dominated by the LLM call that follows.
+"""
 def _get_mcp_context_msg() -> dict | None {
     try {
         mcp_tools = mcp_get_tools();
@@ -579,12 +587,6 @@ def _get_mcp_context_msg() -> dict | None {
     if not mcp_tools {
         return None;
     }
-    # Check if tools changed since last call
-    current_names = frozenset(f"{t['server']}::{t['name']}" for t in mcp_tools);
-    if _mcp_ctx_cache.get("tool_names") == current_names {
-        return _mcp_ctx_cache.get("msg");
-    }
-    # Rebuild
     lines: list = [
         "Available MCP tools — call via mcp_call(server_name, tool_name, arguments_json):",
         "Check each tool's inputSchema for required arguments before calling."
@@ -600,10 +602,7 @@ def _get_mcp_context_msg() -> dict | None {
         }
         lines.append(f"  - server={t['server']}  tool={t['name']}  {t['description']}{schema_hint}");
     }
-    msg: dict = {"role": "system", "content": "\n".join(lines)};
-    _mcp_ctx_cache["msg"] = msg;
-    _mcp_ctx_cache["tool_names"] = current_names;
-    return msg;
+    return {"role": "system", "content": "\n".join(lines)};
 }
 
 

{jac_coder-0.2.0 → jac_coder-0.2.2}/jac_coder/api.jac

@@ -13,7 +13,7 @@ import from jac_coder.util.tool_output { tool_end }
 import from jac_coder.runtime.permission { permission_engine }
 import from jac_coder.util.sandbox { set_sandbox_root, set_browser_exec }
 import from jac_coder.runtime.context { build_context, ContextConfig }
-import from jac_coder.core.walkers { new_session, ensure_main_agent, _consume_llm_stream }
+import from jac_coder.core.walkers { new_session, ensure_main_agent, _consume_llm_stream, _find_session }
 import from jac_coder.infra.mcp_manager {
     mcp_add_server,
     mcp_disconnect_server,
@@ -43,11 +43,6 @@ import from jac_coder.runtime.events {
 }
 
 
-# Thread-safe session registry — graph root() is per-request in jac-cloud,
-# so background threads can't find sessions via [root()-->]. This dict
-# is module-level and accessible from any thread.
-glob _session_registry: dict = {};
-
 """Initialize jac-coder."""
 def initialize(mode: str = "web") -> None;
 

{jac_coder-0.2.0 → jac_coder-0.2.2}/jac_coder/core/nodes.impl.jac

@@ -106,7 +106,17 @@ Respond to what the user is asking RIGHT NOW. Don't recap. Concise by default, d
 
 ## Delegation
 - Simple (1-2 files, questions, git): handle directly.
-- Multi-file or investigation: spawn_agent(task, mode="worker"|"explorer").
+- Multi-file, investigation, or complex: spawn_agent().
+
+SubAgent cannot see this conversation. Every task string must be fully self-contained.
+
+Before spawning worker: use think + read_file + grep_search until you know the exact change needed. Task string must include: file path:line, function/node name, exact problem, what NOT to touch.
+Good: `Fix delegation.impl.jac:112 — has_errs hardcoded False, extract from result.errors. Don't touch above line 108.`
+Bad: `Fix the error tracking bug` / `Based on what you found, fix it`
+
+Mode: `explorer` = root cause unknown → investigate first, then YOU synthesize findings and spawn `worker`. `worker` = exact file and line known → implement directly.
+
+Never delegate understanding. Task strings must prove you already know what to change.
 """;
 
 
@@ -118,6 +128,7 @@ sem WorkerAgent.do_work = """
 
 Expert Jac coder executing a delegated task. Never edit `.jac/` (compiled output).
 
+
 ## Iteration Budget
 Build breadth-first — get all files written and app running before polishing. If a component fails after 2 fix attempts, write a minimal working version and move on. Never spend 10+ iterations on one file.
 

{jac_coder-0.2.0 → jac_coder-0.2.2}/jac_coder/core/nodes.jac

@@ -9,11 +9,10 @@ import from jac_coder.runtime.events { is_abort_requested }
 
 # MainAgent tools — full orchestrator set
 import from jac_coder.tool.meta.think { think }
-import from jac_coder.tool.meta.delegation { spawn_agent }
+import from jac_coder.tool.meta.delegation { spawn_agent, set_iter_count }
 import from jac_coder.tool.meta.todo { update_todos }
 import from jac_coder.tool.read.load_jac_skill { load_jac_skill }
 import from jac_coder.tool.meta.question { ask_question }
-import from jac_coder.tool.write.scaffold { scaffold_project }
 import from jac_coder.tool.net.web { web_fetch, web_search }
 import from jac_coder.tool.run.guarded { run_command }
 import from jac_coder.tool.run.jac_tools { jac_check, jac_run }
@@ -83,6 +82,16 @@ obj SessionLearnings {
 # ---------------------------------------------------------------------------
 node McpRegistry {
     has servers: dict[str, dict] = {};
+    has disconnected_servers: list[str] = []; 
+}
+
+
+# ---------------------------------------------------------------------------
+# UserPermissionRules — persists per-user "always allow" decisions in the graph
+# so they are visible across pods (B3 / horizontal scaling).
+node UserPermissionRules {
+    has user_id: str = "",
+        always_allowed: dict[str, list[str]] = {};
 }
 
 
@@ -146,7 +155,10 @@ node Session {
 # MainAgent — the orchestrator node
 # ---------------------------------------------------------------------------
 node MainAgent {
-    def respond(message: str, chat_history: list[dict], user_image: Image | None = None) -> str by llm(
+    # Bound to Session.chat_history by the walker before each call.
+    has _conv: list[dict] = [];
+
+    def respond(message: str, user_image: Image | None = None) -> str by llm(
         tools=[
             # Think — explicit reasoning before acting or delegating
             think,
@@ -163,7 +175,6 @@ node MainAgent {
             write_code,
             run_command,
             jac_run,
-            scaffold_project,
             # Git — first-class version control
             git_status,
             git_diff,
@@ -186,6 +197,7 @@ node MainAgent {
             # MCP — call tools from connected MCP servers
             mcp_call
         ],
+        conversation=self._conv,
         on_iteration=_iteration_hook,
         max_react_iterations=80,
         temperature=0.2,
@@ -200,8 +212,9 @@ node MainAgent {
 # SubAgent walkers — spawned on MainAgent node for task delegation
 # ---------------------------------------------------------------------------
 
-"""on_iteration callback — checks abort flag between ReAct iterations."""
+"""on_iteration callback — checks abort flag and tracks real iteration count."""
 def _iteration_hook(ctx: IterationContext) -> IterationAction {
+    set_iter_count(ctx.iteration);
     if is_abort_requested() {
         return IterationAction.ABORT;
     }
@@ -217,6 +230,9 @@ walker WorkerAgent {
 
     def do_work(task_str: str) -> str by llm(
         tools=[
+            # Reason
+            think,
+            # Understand
             load_jac_skill,
             analyze_project,
             find_symbol,
@@ -224,26 +240,18 @@ walker WorkerAgent {
             list_files,
             grep_search,
             find_files,
+            # Act
             write_code,
             edit_code,
             run_command,
             jac_run,
-            scaffold_project,
+            # Git — status only, workers don't commit
             git_status,
-            git_diff,
-            git_commit,
-            git_log,
-            web_fetch,
-            web_search,
-            browser_open,
-            browser_do,
-            browser_state,
-            browser_close,
-            browser_validate,
-            mcp_call
+            # Validate
+            browser_validate
         ],
         on_iteration=_iteration_hook,
-        max_react_iterations=60,
+        max_react_iterations=30,
         temperature=0.2,
         max_tokens=8192,
         stream=True,