jac-coder 0.2.1__tar.gz → 0.2.3__tar.gz

{jac_coder-0.2.1 → jac_coder-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jac-coder
-Version: 0.2.1
+Version: 0.2.3
 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.1 → jac_coder-0.2.3}/README.md

@@ -156,3 +156,5 @@ jac-code/
 ├── 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.1 → jac_coder-0.2.3}/jac_coder/api.impl.jac

@@ -244,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)
@@ -260,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,
@@ -277,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 (rebuilt 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();
@@ -306,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 {
@@ -339,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"];
@@ -379,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();
@@ -514,6 +524,28 @@ impl api_get_model() -> dict {
     return _get_model();
 }
 
+impl api_check_local_setup(alias: str) -> dict {
+    runtime: bool = False;
+    try {
+        import llama_cpp;
+        runtime = True;
+    } except ImportError { }
+
+    model: bool = False;
+    valid_alias: bool = False;
+    try {
+        import from byllm.local_runtime { LOCAL_MODELS }
+        import from byllm.model_cache { is_downloaded }
+        spec = LOCAL_MODELS.get(alias);
+        if spec is not None {
+            valid_alias = True;
+            model = is_downloaded(alias, spec);
+        }
+    } except Exception { }
+
+    return {"runtime": runtime, "model": model, "valid_alias": valid_alias};
+}
+
 
 # ---------------------------------------------------------------------------
 # MCP management API

{jac_coder-0.2.1 → jac_coder-0.2.3}/jac_coder/api.jac

@@ -78,6 +78,9 @@ def api_set_model(model: str) -> dict;
 """Get current model info."""
 def api_get_model() -> dict;
 
+"""Check if local model runtime and model weights are ready for a given alias."""
+def api_check_local_setup(alias: str) -> dict;
+
 # --- MCP management API ---
 """Add or update an MCP server."""
 def api_mcp_add(name: str, config: dict) -> dict;

{jac_coder-0.2.1 → jac_coder-0.2.3}/jac_coder/core/nodes.impl.jac

@@ -140,11 +140,19 @@ Build breadth-first — get all files written and app running before polishing.
 ## Workflow
 1. Read .jaccoder/progress.md if it exists, update it as you go.
 2. analyze_project(dir) for existing projects.
-3. jac.toml needs `[plugins.client.vite]` with tailwindcss. Run `jac install` after toml changes.
-4. Build bottom-up: services → styles/global.css → hooks → components → layout.
-5. styles/global.css: `@import "tailwindcss"`, @theme tokens. In main.jac: `cl import ".styles.global.css";`
-6. After all files: jac start --dev main.jac (background=True).
-7. browser_validate(url) → follow FAIL action instructions.
+3. Build bottom-up: services → hooks → components → layout.
+4. **If `components/ui/` exists AND jac.toml has `[jac-shadcn]` (jac-shadcn project):**
+   - Load `jac-shadcn-components` skill BEFORE writing any UI.
+   - Load `jac-cl-styling` for conditional class and cn() patterns.
+   - `styles/global.css` and `jac.toml` are pre-configured — do NOT recreate or modify them.
+   - Import UI from `components/ui/` instead of writing raw primitive components. No inline styles.
+   **Otherwise (standard project):**
+   - jac.toml needs `[plugins.client.vite]` with tailwindcss. Run `jac install` after toml changes.
+   - styles/global.css: `@import "tailwindcss"`, @theme tokens. In main.jac: `cl import ".styles.global.css";`
+   - Load `jac-cl-styling` when writing Tailwind classes or dynamic styles.
+   - Load `jac-npm-packages` when adding third-party npm packages.
+5. After all files: jac start --dev main.jac (background=True).
+6. browser_validate(url) → follow FAIL action instructions.
 
 Load the relevant `load_jac_skill(name)` from `<jac-skills-available>` BEFORE writing Jac. Tools catch obvious anti-patterns — trust BLOCKED messages.
 """;

{jac_coder-0.2.1 → jac_coder-0.2.3}/jac_coder/core/nodes.jac

@@ -82,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]] = {};
 }
 
 
@@ -145,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,
@@ -184,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,

{jac_coder-0.2.1 → jac_coder-0.2.3}/jac_coder/core/walkers.impl.jac

@@ -173,8 +173,7 @@ impl interact.enter_session with Session entry {
         }
     }
 
-    # Append user message and update
-    here.chat_history.append({"role": "user", "content": self.message});
+    # byLLM appends the user message from the `respond(message=...)` arg.
     here.updated_at = datetime.now().isoformat();
     self.chat_history = here.chat_history;
 
@@ -212,28 +211,27 @@ impl _persist_response(
     files_modified: list[str] = [],
     tool_records: list[dict] = []
 ) -> None {
+    # byLLM already appended the user/tool/assistant turns via _conv binding;
+    # we only patch JacCoder UI metadata onto the trailing assistant entry.
     session = _find_session(session_id);
     if not session {
         return;
     }
 
-    for rec in tool_records {
-        session.chat_history.append({
-            "role": "tool",
-            "name": rec.get("tool", ""),
-            "args": rec.get("args", {}),
-            "content": rec.get("result", "")
-        });
+    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"] = agent_mode;
+            if tools_used {
+                message_entry["tools_used"] = tools_used;
+            }
+            if files_modified {
+                message_entry["files_modified"] = files_modified;
+            }
+            break;
+        }
     }
 
-    record: dict = {"role": "assistant", "content": response, "agent": agent_mode};
-    if tools_used {
-        record["tools_used"] = tools_used;
-    }
-    if files_modified {
-        record["files_modified"] = files_modified;
-    }
-    session.chat_history.append(record);
     session.last_agent = agent_mode;
     session.updated_at = datetime.now().isoformat();
 }
@@ -314,45 +312,65 @@ impl _respond_and_persist(agent: MainAgent, ctx: interact) -> None {
     pending_errors = session.pending_errors if session else [];
     project_summary = session.project_summary if session else "";
 
-    # Build compacted context
-    ctx_history = build_context(
-        ctx.chat_history, active_files, pending_errors, project_summary=project_summary
-    );
+    # 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 project_summary {
+        is_progress_file = 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{project_summary}"
+        );
+    }
+    if active_files {
+        prefix_parts.append("Active files: " + ", ".join(active_files));
+    }
+    if pending_errors {
+        prefix_parts.append("Pending errors:\n" + "\n".join(pending_errors));
+    }
 
-    # Inject the available-skills listing (names + descriptions only).
-    # The LLM picks which skills it needs and pulls bodies via load_jac_skill(name).
-    # Inserted FIRST so workflow_modules ends up above it in the final prompt,
-    # keeping the listing closer to the user message where attention is strongest.
     import from jac_coder.runtime.skills { inject_skills_listing }
     skill_listing = inject_skills_listing();
     if skill_listing {
-        ctx_history.insert(0, {"role": "system", "content": skill_listing});
+        prefix_parts.append(skill_listing);
     }
 
-    # Inject mode-aware workflow modules (dynamic prompt assembly)
     import from jac_coder.runtime.prompt { select_prompt_modules }
     workflow_modules = select_prompt_modules(
         last_mode_hint=session.last_mode_hint if session else "",
         message=ctx.message,
         directory=session.directory if session else "",
-        chat_history=ctx.chat_history
+        chat_history=session.chat_history if session else []
     );
     if workflow_modules {
-        ctx_history.insert(0, {"role": "system", "content": workflow_modules});
+        prefix_parts.append(workflow_modules);
     }
 
-    # If agent_context was provided (e.g. from JacBuilder), inject it
     if ctx.agent_context {
-        ctx_history.insert(0, {"role": "system", "content": ctx.agent_context});
+        prefix_parts.append(ctx.agent_context);
     }
 
+    composed_message = (
+        "\n\n---\n\n".join(prefix_parts) + "\n\n---\n\n" + ctx.message
+        if prefix_parts
+        else ctx.message
+    );
+
     # Initialize shared budget for SubAgents
     import from jac_coder.tool.meta.delegation { init_budget }
     config = get_config();
     init_budget(config.max_react_iterations * 3);
 
-    # Call MainAgent — returns StreamEvent generator with logging enabled
-    event_stream = agent.respond(message=ctx.message, chat_history=ctx_history);
+    if session {
+        agent._conv = session.chat_history;
+    }
+
+    event_stream = agent.respond(message=composed_message);
     stream_result = _consume_llm_stream(event_stream);
 
     response_text = stream_result["content"];

{jac_coder-0.2.1 → jac_coder-0.2.3}/jac_coder/infra/config.impl.jac

@@ -99,6 +99,7 @@ impl set_model(model: str) -> dict {
     }
     model_name = model;
     llm.model_name = model;
+    llm.postinit();
     _config.default_model = model;
     return {"status": "ok", "model": model};
 }

{jac_coder-0.2.1 → jac_coder-0.2.3}/jac_coder/infra/config.jac

@@ -87,4 +87,5 @@ with entry {
     # with the hardcoded default before load_config() runs.
     model_name = _config.default_model;
     llm.model_name = model_name;
+    llm.postinit();
 }

{jac_coder-0.2.1 → jac_coder-0.2.3}/jac_coder/infra/mcp_manager.impl.jac

@@ -30,12 +30,20 @@ glob _sessions: dict = {};     # name -> ClientSession (open inside _mgr_loop)
 glob _exit_stacks: dict = {};  # name -> AsyncExitStack (keeps transports alive)
 glob _TOOLS_CACHE_KEY: str = "jc:mcp:tools";
 glob _TOOLS_CACHE_TTL: int = 30;  # seconds before tool list is re-fetched
-glob _builtin_names: set = set();  # names registered via mcp_register_builtin
-glob _disconnected_names: set = set();  # names intentionally disconnected by user
+
+impl _service_mode_active() -> bool {
+    return bool(
+        os.environ.get("JACCODER_WEB_MODE", "")
+        or os.environ.get("JACCODER_IDE_MODE", "")
+    );
+}
 
 
 """Background thread: check PyPI for latest jac-mcp version (3s timeout, fails silently)."""
-def _check_jac_mcp_version() -> None {
+impl _check_jac_mcp_version() -> None {
+    if _service_mode_active() {
+        return;
+    }
     try {
         current: str = version("jac-mcp");
         req = Request(
@@ -65,7 +73,13 @@ def _get_registry() -> Any {
             target_anchor = edge_anchor.target;
             target_anchor.populate();
             if isinstance(target_anchor.archetype, McpRegistry) {
-                return target_anchor.archetype;
+                reg = target_anchor.archetype;
+                # Migration guard: nodes persisted before disconnected_servers was
+                # added to the schema won't have this attribute after deserialization.
+                if not hasattr(reg, "disconnected_servers") {
+                    reg.disconnected_servers = [];
+                }
+                return reg;
             }
         } except Exception { }
     }
@@ -286,31 +300,33 @@ impl mcp_add_server(name: str, config: dict) -> dict {
 }
 
 
-"""Close the connection and remove the server from the registry."""
+"""Close the connection and mark the server disconnected in the graph."""
 impl mcp_disconnect_server(name: str) -> dict {
     # Disconnect only — close the active connection but keep the config.
     # This applies to ALL servers (builtin and user-added) so they stay
     # visible in the list and can be reconnected.
-    global _disconnected_names;
+    # Intent is persisted in McpRegistry.disconnected_servers so it survives
+    # pod restarts and is visible across all pods.
     configs = _load_configs();
     if name not in configs {
         return {"error": f"Server '{name}' not found"};
     }
-    _disconnected_names.add(name);
+    reg = _get_registry();
+    if name not in reg.disconnected_servers {
+        reg.disconnected_servers = list(reg.disconnected_servers) + [name];
+    }
     _submit(_close_connection(name));
     kv_delete(_TOOLS_CACHE_KEY);
-    return {"status": "disconnected", "name": name};
+    return {"status": "disconnected", "name": name}; 
 }
 
 
 """Reconnect a previously-disconnected MCP server."""
 impl mcp_reconnect_server(name: str) -> dict {
-    global _disconnected_names;
     configs = _load_configs();
     if name not in configs {
         return {"error": f"Server '{name}' not found"};
     }
-    _disconnected_names.discard(name);
     # Close any stale connection first, then reconnect via list_tools.
     # Iterate configs to get a typed config value (subscript on untyped dict
     # produces Unknown in the Jac type checker — the for pattern is used
@@ -321,9 +337,14 @@ impl mcp_reconnect_server(name: str) -> dict {
         if n == name {
             try {
                 tools = _submit(_async_list_tools(n, config));
+                # Only remove from disconnected_servers on success — keeps state
+                # consistent if connection fails (server stays disconnected).
+                reg = _get_registry();
+                if name in reg.disconnected_servers {
+                    reg.disconnected_servers = [s for s in reg.disconnected_servers if s != name];
+                }
                 return {"status": "connected", "name": name};
             } except Exception as e {
-                _disconnected_names.add(name);
                 return {"error": f"Failed to reconnect '{name}': {e}"};
             }
         }
@@ -334,15 +355,18 @@ impl mcp_reconnect_server(name: str) -> dict {
 
 impl mcp_delete_server(name: str) -> dict {
     # Permanently remove a user-added server from the registry.
-    # Built-in servers cannot be deleted.
-    if name in _builtin_names {
-        return {"error": f"Built-in server '{name}' cannot be deleted"};
-    }
+    # Built-in servers cannot be deleted — the builtin flag is stored as
+    # config["builtin"]=True inside McpRegistry.servers (graph-persisted),
     configs = _load_configs();
     if name not in configs {
         return {"error": f"Server '{name}' not found"};
     }
-    _submit(_close_connection(name));
+    for (n, cfg) in configs.items() {
+        if n == name and cfg.get("builtin", False) {
+            return {"error": f"Built-in server '{name}' cannot be deleted"};
+        }
+    }
+    _submit(_close_connection(name)); 
     configs.pop(name);
     _save_configs(configs);
     kv_delete(_TOOLS_CACHE_KEY);
@@ -353,6 +377,8 @@ impl mcp_delete_server(name: str) -> dict {
 """Return all registered servers with their connection status and tool counts."""
 impl mcp_list_servers() -> list {
     configs = _load_configs();
+    # Read disconnected intent from the graph — persisted, cross-pod consistent.
+    disconnected = _get_registry().disconnected_servers;
     result: list = [];
     for (name, config) in configs.items() {
         entry: dict = {
@@ -363,7 +389,7 @@ impl mcp_list_servers() -> list {
             "latest_version": _jac_mcp_update_info.get("latest", "") if name == "jac-mcp" else ""
         };
         # Skip auto-connect for servers the user intentionally disconnected
-        if name in _disconnected_names {
+        if name in disconnected {
             entry["status"] = "disconnected";
             entry["tool_count"] = 0;
             entry["tools"] = [];
@@ -388,16 +414,16 @@ impl mcp_list_servers() -> list {
 
 """Save a built-in server to the registry without a connectivity check."""
 impl mcp_register_builtin(name: str, config: dict) -> None {
-    global _builtin_names;
-    _builtin_names.add(name);
     configs = _load_configs();
     # Always update builtin config — the binary path can change between installs
     # (e.g. pipx venv vs workspace venv). Stale paths cause connection errors.
+    # builtin=True is stored in the config dict inside McpRegistry.servers so
+    # it is graph-persisted and cross-pod consistent — no RAM set needed.
     config["builtin"] = True;
     configs[name] = config;
     _save_configs(configs);
     kv_delete(_TOOLS_CACHE_KEY);  # Invalidate cross-pod cache — server set changed
-    if name == "jac-mcp" {
+    if name == "jac-mcp" and not _service_mode_active() {
         threading.Thread(target=_check_jac_mcp_version, daemon=True).start();
     }
 }
@@ -411,8 +437,14 @@ impl mcp_get_tools() -> list {
     }
 
     configs = _load_configs();
+    # Read disconnected intent from the graph so tools from user-disconnected
+    # servers are never surfaced to the agent (bug fix: previously ignored).
+    disconnected = _get_registry().disconnected_servers;
     all_tools: list = [];
     for (name, config) in configs.items() {
+        if name in disconnected {
+            continue;  # Respect user's disconnect intent — skip this server
+        }
         try {
             all_tools.extend(_submit(_async_list_tools(name, config)));
         } except Exception as e {

{jac_coder-0.2.1 → jac_coder-0.2.3}/jac_coder/infra/mcp_manager.jac

@@ -43,3 +43,10 @@ def mcp_call_tool(server_name: str, tool_name: str, arguments: dict) -> str;
 Saves now and tries it on first real tool call.
 """
 def mcp_register_builtin(name: str, config: dict) -> None;
+
+"""Return True when this process is serving multiple end-users (web/IDE).
+Used to gate per-process best-effort tasks that only make sense in CLI."""
+def _service_mode_active() -> bool;
+
+"""Background thread: check PyPI for latest jac-mcp version. No-op in service mode."""
+def _check_jac_mcp_version() -> None;

{jac_coder-0.2.1 → jac_coder-0.2.3}/jac_coder/runtime/cost_tracker.impl.jac

@@ -206,6 +206,12 @@ impl reset() -> None {
 
 
 impl save_to_file(filepath: str = "") -> str {
+    # In web/IDE mode many users share the same server, so writing one user's
+    # cost to a local file would overwrite another user's data. Skip silently.
+    # In CLI mode  the file is safe and useful.
+    if os.environ.get("JACCODER_WEB_MODE", "") or os.environ.get("JACCODER_IDE_MODE", "") {
+        return "";
+    }
     if not filepath {
         filepath = "jaccoder_cost.json";
     }