jac-coder 0.2.7__tar.gz → 0.2.8__tar.gz

{jac_coder-0.2.7 → jac_coder-0.2.8}/PKG-INFO

@@ -1,11 +1,10 @@
 Metadata-Version: 2.4
 Name: jac-coder
-Version: 0.2.7
+Version: 0.2.8
 Summary: AI coding agent backend for Jac, powered by jac-byllm
 Requires-Python: >=3.12
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: jaclang
-Requires-Dist: byllm
 Requires-Dist: mcp>=1.0.0
 Requires-Dist: jac-mcp
 Requires-Dist: rich>=13.0

{jac_coder-0.2.7 → jac_coder-0.2.8}/jac_coder/api.impl.jac

@@ -339,7 +339,7 @@ impl chat(
         user_image = None;
         if images and len(images) > 0 {
             try {
-                import from byllm.lib { Image }
+                import from jaclang.byllm.lib { Image }
                 ;
                 first_img = images[0];
                 data_url = first_img.get("data_url", "") if isinstance(first_img, dict) else str(first_img);
@@ -358,6 +358,7 @@ impl chat(
 
         response_text = stream_result["content"];
         tools_used = stream_result["tools_used"];
+        tool_records = stream_result.get("tool_records", []);
 
         # Finalize turn — get accumulated file/error data from tool internals
         tool_end();
@@ -421,6 +422,14 @@ impl chat(
         import from jac_coder.runtime.prompt { infer_mode_hint as _infer_hint }
         session.last_mode_hint = _infer_hint(tools_used, files_modified);
 
+        # Guaranteed end-of-turn struggle reflection (work turns only).
+        if not is_abort_requested() {
+            import from jac_coder.runtime.struggle_report { reflect_and_log }
+            reflect_and_log(
+                main_agent, tool_records, files_modified, has_errors, response_text
+            );
+        }
+
         return {
             "response": response_text,
             "agent": "main",
@@ -552,8 +561,8 @@ impl api_check_local_setup(alias: str) -> dict {
     model: bool = False;
     valid_alias: bool = False;
     try {
-        import from byllm.local_runtime { LOCAL_MODELS }
-        import from byllm.model_cache { is_downloaded }
+        import from jaclang.byllm.local_runtime { LOCAL_MODELS }
+        import from jaclang.byllm.model_cache { is_downloaded }
         spec = LOCAL_MODELS.get(alias);
         if spec is not None {
             valid_alias = True;

{jac_coder-0.2.7 → jac_coder-0.2.8}/jac_coder/core/nodes.impl.jac

@@ -87,10 +87,14 @@ sem MainAgent.respond = "Respond to the user's coding request.";
 # ---------------------------------------------------------------------------
 # SubAgent walkers — sem annotations and entry ability implementations
 # ---------------------------------------------------------------------------
-sem WorkerAgent.do_work = "Execute the delegated coding task.";
+sem WorkerAgent.do_work = "Execute the delegated coding task as a pure implementer. When .jaccoder/ui_spec.json exists, treat it as a binding UI contract — never change style, theme, base_color, nav_pattern, or pages (those belong to UIDesignerAgent). If a mechanical implementation need arises for a component not in primitive_components (e.g. a spinner), add it to primitive_components in ui_spec.json first, then run jac add --shadcn. Never make freestyle design decisions.";
 
 sem ExplorerAgent.do_work = "Investigate the codebase and report findings.";
 
+sem UIDesignerAgent = "UI design authority — produces or updates .jaccoder/ui_spec.json, the living design contract for the application.";
+sem UIDesignerAgent.do_work = "Write or update .jaccoder/ui_spec.json. Create mode (no UISpec in task): analyse project from scratch and produce a full spec. Update mode (current UISpec JSON provided in task): apply the user's change request to only the affected fields, preserve everything else.";
+sem UIDesignerAgent.task = "Input context in one of two forms. Create: project path + directory listing + jac.toml + user request. Update: project path + current UISpec JSON + user request.";
+
 
 """Consume a SubAgent's by llm() stream, forward events, and return results."""
 def _consume_subagent_stream(event_stream: Any, prefix: str, track_files: bool = False) -> dict {
@@ -134,6 +138,11 @@ def _consume_subagent_stream(event_stream: Any, prefix: str, track_files: bool =
             }
         } elif event.event_type == "steps_done" {
             emit_event("llm_steps_done", dict(event.data));
+        } elif event.event_type == "stream_reset" {
+            # byllm retried a transient mid-stream drop; drop the partial subagent
+            # reply so the regenerated text isn't doubled.
+            content = "";
+            emit_event("llm_stream_reset", dict(event.data));
         } elif event.event_type == "chunk" {
             content += event.data.get("content", "");
         } elif event.event_type == "usage" {
@@ -169,3 +178,11 @@ impl ExplorerAgent.execute with MainAgent entry {
     self.result_files = [];
     self.result_errors = list(result["errors"]);
 }
+
+
+impl UIDesignerAgent.execute with MainAgent entry {
+    result = _consume_subagent_stream(
+        self.do_work(task_str=self.task), "sub:designer"
+    );
+    self.result_content = str(result["content"]);
+}

{jac_coder-0.2.7 → jac_coder-0.2.8}/jac_coder/core/nodes.jac

@@ -3,7 +3,7 @@ import sys;
 
 import from uuid { uuid4 }
 import from datetime { datetime }
-import from byllm.types { IterationAction, IterationContext }
+import from jaclang.byllm.types { IterationAction, IterationContext }
 import from jac_coder.infra.config { llm, get_config }
 import from jac_coder.runtime.events { is_abort_requested }
 
@@ -24,8 +24,8 @@ import from jac_coder.tool.read.jac_analyzer { analyze_project, find_symbol }
 import from jac_coder.tool.net.preview { browser_open, browser_do, browser_state, browser_close, browser_validate }
 import from jac_coder.tool.mcp { mcp_call }
 import from jac_coder.runtime.compaction { jaccoder_compaction }
-import from jac_coder.runtime.prompt { compose_system_prompt }
-import from byllm.lib { Image }
+import from jac_coder.runtime.prompt { compose_system_prompt, compose_system_prompt_filtered }
+import from jaclang.byllm.lib { Image }
 
 
 
@@ -64,6 +64,43 @@ sem SubAgentResult.tools_used = "Tools called during execution";
 sem SubAgentResult.iterations_used = "Number of ReAct iterations consumed";
 
 
+# Controlled vocabulary for the struggle's root cause. A fixed enum (not a free
+# string) so categories stay consistent across users and the admin portal can
+# group/triage them. Each value maps to an improvement action: skills_gap -> write
+# a skill doc, upstream_bug -> file a Jaseci issue, environment_issue -> fix the
+# sandbox, etc.
+enum StruggleCategory {
+    SKILLS_GAP = "skills_gap",
+    UPSTREAM_BUG = "upstream_bug",
+    SYNTAX_ERROR = "syntax_error",
+    FRAMEWORK_API = "framework_api",
+    ENVIRONMENT_ISSUE = "environment_issue",
+    TOOLING_LIMITATION = "tooling_limitation",
+    LOGIC_ERROR = "logic_error",
+    AMBIGUITY = "ambiguity",
+    NONE = "none"
+}
+
+
+obj TurnReflection {
+    has issue: str = "",
+        root_cause: str = "",
+        resolution: str = "",
+        code_before: str = "",
+        code_after: str = "",
+        smoothness: float = 0.7,
+        category: StruggleCategory = StruggleCategory.NONE;
+}
+
+sem TurnReflection.issue = "The single biggest sticking point this turn and WHERE it was (file / function / component). 1-2 sentences.";
+sem TurnReflection.root_cause = "The concrete underlying cause: the exact error, the API you misunderstood, the wrong assumption. Be specific, not generic.";
+sem TurnReflection.resolution = "How you fixed it, in one sentence, or 'unresolved' if you did not fix it.";
+sem TurnReflection.code_before = "The minimal broken code (just the few key lines), if it was a code problem. Empty otherwise.";
+sem TurnReflection.code_after = "Those same lines, fixed. Empty otherwise.";
+sem TurnReflection.smoothness = "0.0 (fought it for many iterations or left it unresolved) to 1.0 (effortless). Ground it in the effort the digest shows - a long unresolved struggle is LOW.";
+sem TurnReflection.category = "Pick the ONE category that best fits the struggle's root cause. skills_gap: you lacked the right Jac pattern and the skills/docs did not cover it. upstream_bug: a real bug or limitation in Jac/Jaseci/jac-cloud itself, not your own mistake. syntax_error: Jac or cl.jac syntax you got wrong. framework_api: you misunderstood a Jac/jac-cloud API or concept (persistence, walkers, nodes/edges, routing, auth). environment_issue: sandbox, deployment, install, or server/tooling environment problem. tooling_limitation: a JacCoder tool itself fell short (edit match failed, browser, etc.). logic_error: your own application logic/reasoning bug. ambiguity: the user request was unclear or underspecified. none: no significant struggle this turn.";
+
+
 obj ProjectScan {
     has architecture: str;
     has file_map: dict[str, str];
@@ -271,6 +308,29 @@ node MainAgent {
         stream=True,
         logging=True
     );
+
+    """You ARE the coding agent, reflecting on the turn you just finished, for an
+    internal quality log the user never sees. The digest below is the turn: your own
+    think reasoning, every tool call (failures and functional/app problems are
+    flagged), the code you changed, and the cost (how many calls).
+
+    Find the SINGLE most significant struggle - the one that cost the most effort or
+    stayed unresolved, NOT the tidiest one-liner. A functional bug you debugged over
+    many iterations (e.g. the app showing wrong data, a "not found" that kept failing)
+    matters far more than a quick procedural realization. Weight by effort and whether
+    it was resolved, not by how cleanly you can state it.
+
+    Then report it concretely: `issue` (what + WHERE), `root_cause` (the real
+    underlying cause), `resolution` (how you fixed it, or "unresolved"), and if it was
+    a code problem, a MINIMAL `code_before`/`code_after` (just the few key lines).
+    Set `smoothness` from the effort the digest shows: a long or unresolved struggle
+    is LOW (0.2-0.4), a smooth turn is high. Choose the `category` that best matches
+    the root cause from the allowed values. If the turn
+    really was smooth, say so briefly with high smoothness and empty code fields."""
+    def reflect_on_turn(turn_digest: str) -> TurnReflection by llm(
+        temperature=0.3,
+        max_tokens=700
+    );
 }
 
 
@@ -288,6 +348,84 @@ def _iteration_hook(ctx: IterationContext) -> IterationAction {
 }
 
 
+glob DESIGNER_SKILLS: set[str] = {"jac-shadcn-components", "jac-shadcn-blocks"};
+
+
+glob JACCODER_DESIGNER_SYSTEM: str = """
+# UIDesignerAgent — UI Design Authority
+
+Produce or update `.jaccoder/ui_spec.json` — the UI design contract. You do NOT write application code, run commands, or build anything.
+
+## Two operating modes
+
+### Create mode (no UISpec in task)
+Task: project path + directory listing + jac.toml + user request. Analyse from scratch and produce a complete UISpec.
+1. Load `jac-shadcn-blocks` skill — `### Section headers` give valid block names.
+2. Load `jac-shadcn-components` skill — Component Selection table gives primitive names; § Theming gives valid theming values.
+3. Write the full JSON to `<project_dir>/.jaccoder/ui_spec.json` using `write_code`.
+
+### Update mode (current UISpec provided in task)
+Task: project path + current UISpec JSON + user request. Update ONLY the relevant fields — preserve everything else.
+1. Load `jac-shadcn-blocks` (if change involves pages or blocks).
+2. Load `jac-shadcn-components` (if change involves theme, style, font, or primitive_components).
+3. Apply only the requested changes. Write the complete JSON back (full file, not a patch).
+
+Changes → fields: visual redesign ("more attractive", "production-level", "like Linear/Notion") → `style/theme/base_color/font/radius/menu_accent`; nav change → `nav_pattern` + page `blocks`; add/remove page → `pages[]` + `primitive_components`; component addition → `primitive_components`.
+
+## Output — `.jaccoder/ui_spec.json`
+Single raw JSON object (no markdown fences, no comments). All fields required.
+
+```
+{
+  "app_type": "landing | dashboard | saas | ecommerce | blog | portfolio | tool",
+  "auth_required": true | false,
+  "backend_required": true | false,
+  "nav_pattern": "sidebar | topnav | bottomnav | none",
+  "pages": [
+    {
+      "name": "Human-readable page name",
+      "route": "/path",
+      "blocks": ["block_name_1"],
+      "auth_protected": true | false,
+      "title": "HTML page title"
+    }
+  ],
+  "primitive_components": ["button", "card"],
+  "style": "nova | vega | maia | lyra | mira",
+  "base_color": "neutral | stone | zinc | gray",
+  "theme": "rose | indigo | emerald | amber | blue | violet | teal | green",
+  "font": "figtree | inter | geist | dm-sans | roboto",
+  "radius": "default | none | small | medium | large",
+  "menu_accent": "subtle | bold",
+  "confidence": 0.0,
+  "assumption": "One sentence describing the biggest assumption made.",
+  "remove_from_template": []
+}
+```
+
+Note: `theme` and `font` show the most common values — see jac-shadcn-components § Theme reference and § Font reference for the full lists with descriptions.
+
+## Field guidance
+
+**app_type**: match to user's domain.
+**auth_required**: DEFAULT is `false`. Set `true` ONLY if the user's message contains explicit words like "login", "signup", "sign in", "user accounts", "authentication", or "protected pages". Do NOT infer from app type — "habit tracker", "todo app", "notes app", "dashboard" do NOT imply auth. When in doubt → `false`.
+**backend_required**: `true` if server endpoints, a database, or per-user data needed.
+**pages[].blocks**: exact snake_case names from jac-shadcn-blocks skill only — auth_card, app_shell_sidebar, data_table, stats_row, pricing_grid, cta_banner, empty_state, marketing_section. Do not invent names.
+**primitive_components**: exact lowercase names from jac-shadcn-components Component Selection table — passed to `jac add --shadcn` (e.g. "button", "card", "sidebar", "badge", "table", "input", "dialog", "select", "avatar", "chart"). No custom names like "HabitCard". List primaries only — peer deps auto-resolve.
+**style**: visual language — `nova` (neutral professional B2B), `vega` (vibrant modern consumer), `maia` (warm approachable/health), `lyra` (data-focused minimal), `mira` (creative expressive). See jac-shadcn-components § Theming.
+**base_color**: gray palette for backgrounds/borders/muted text. NOT a hex color. `neutral` (default/most apps), `stone` (warm/organic), `zinc` (cool/technical), `gray` (mid). See jac-shadcn-components § baseColor vs theme.
+**theme**: accent/brand color name. NOT "light"/"dark"/"system". See jac-shadcn-components § Theme reference for full list (e.g. `indigo`=enterprise, `emerald`=health/wellness, `rose`=lifestyle, `amber`=e-commerce).
+**font**: see jac-shadcn-components § Font reference for full list and tone descriptions. Default `figtree` (warm/friendly). `inter` for professional, `geist` for technical.
+**radius**: `default` for most apps. `none`/`small` for enterprise/data. `medium`/`large` for consumer/mobile.
+**menu_accent**: `subtle` (muted, low distraction — Notion/GitHub style). `bold` (primary-colored — Linear/Vercel style).
+**remove_from_template**: only files confirmed present in directory listing. Set `[]` when uncertain.
+**confidence**: 0.0-1.0. Create mode: how well the request maps to a complete spec. Update mode: how well the changes match the user's request.
+
+## After writing the file
+Confirm the write succeeded. Your task is done — do not build, run commands, or write any application code.
+""";
+
+
 glob JACCODER_WORKER_SYSTEM: str = """
 # WorkerAgent — Jac Coding SubAgent
 
@@ -302,20 +440,58 @@ Build breadth-first — get all files written and app running before polishing.
 ## UI (mandatory)
 Build responsive, mobile-first UIs: fluid flex/grid layouts, Tailwind responsive prefixes (sm:/md:/lg:), no fixed widths that overflow small screens. A desktop-only layout that breaks on mobile is a bug. After browser_validate PASS, also check the layout at a narrow/mobile width.
 
+## Pre-flight — PATH A setup (run BEFORE writing any code files)
+If `.jaccoder/ui_spec.json` exists, these two commands MUST run before you write or edit any code file:
+
+**1. Install primitives:**
+`jac add --shadcn <primitive_components from UISpec>` — use the exact list, nothing more.
+
+**2. Apply theme:**
+```
+jac retheme --style <style> --baseColor <base_color> --theme <theme> --font <font> --radius <radius> --menuAccent <menu_accent>
+```
+All 6 flags are required — never omit any, even when the value is the default (e.g. `--radius default`). UISpec uses snake_case; flags are camelCase (`base_color`→`--baseColor`, `menu_accent`→`--menuAccent`). This overwrites `global.css` wholesale.
+
+Run both before touching services, components, or any other file.
+
 ## Workflow
 1. Read .jaccoder/progress.md if it exists, update it as you go.
 2. analyze_project(dir) for existing projects.
-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.
+3. For PATH B/C: build bottom-up — services → hooks → components → layout. For PATH A, follow steps a–d below (page-first, not service-first).
+4. **Choose your build path:**
+
+### PATH A — UISpec present (`.jaccoder/ui_spec.json` exists)
+Pre-flight already done above. Then:
+
+a) **Remove unwanted template files** listed in `remove_from_template` early, before writing new pages. Re-verify each file exists before deleting.
+
+b) **For each page in `pages`**:
+   - Load `jac-shadcn-blocks` skill. Use the listed `blocks` in order to build the page.
+   - Load `jac-shadcn-components` for shared UI primitives.
+   - Register the route in the app router.
+
+c) **Auth — detect and ensure** based on `auth_required`:
+   - If `true`:
+     - **Frontend check**: Does `pages/LoginPage.cl.jac` exist AND does `index.cl.jac` (or router file) contain `AuthGuard`?
+       - If MISSING: load `jac-shadcn-blocks` (use `auth_card` block) + `jac-cl-auth` skill. Build `pages/LoginPage.cl.jac` and wrap protected routes with `<AuthGuard redirect="/login">` in the router.
+       - If EXISTS: keep it.
+     - **Backend check**: Does `jac.toml` contain `[plugins.server]` OR does a `services/` dir exist?
+       - If MISSING: load `jac-sv-auth` + `jac-sv-endpoints` skills. Add `[plugins.server]` section to `jac.toml`. Create `services/appService.jac` with a minimal skeleton. Run `jac install`.
+       - If EXISTS: keep it.
+     - Note: jac-scale auto-provides `/user/login` and `/user/register` — do NOT write custom auth walkers.
+   - If `false`: delete `pages/LoginPage.cl.jac` if it exists; remove `AuthGuard` wrapper from router if present.
+
+d) **Backend — detect and ensure** based on `backend_required` (independent of auth):
+   - If `true` and no backend present (same check as above): load `jac-sv-endpoints`, add `[plugins.server]` to `jac.toml`, create `services/appService.jac` skeleton, run `jac install`.
+   - If `false`: leave any existing backend untouched.
+
+
+### PATH B — jac-shadcn project, no UISpec
+Check: `components/ui/` exists OR `jac.toml` has `[jac-shadcn]`. Load `jac-shadcn-components` + `jac-shadcn-blocks` skills and build based on the task description. Apply sensible design defaults. Do NOT create or modify `styles/global.css` or `jac.toml` (pre-configured by jac-shadcn).
+
+### PATH C — Standard project (no jac-shadcn)
+Load `jac-cl-styling` and build with plain Tailwind. `jac.toml` needs `[plugins.client.vite]` with tailwindcss. Run `jac install` after toml changes. `styles/global.css`: `@import "tailwindcss"`. Load `jac-npm-packages` when adding third-party packages.
+
 5. After all files: jac start --dev main.jac (background=True).
 6. browser_validate(url) and follow its instructions.
 """;
@@ -405,3 +581,27 @@ walker ExplorerAgent {
     );
     can execute with MainAgent entry;
 }
+
+
+walker UIDesignerAgent {
+    has task: str;
+    has result_content: str = "";
+
+    def do_work(task_str: str) -> str by llm(
+        system_prompt=compose_system_prompt_filtered(JACCODER_DESIGNER_SYSTEM, DESIGNER_SKILLS),
+        tools=[
+            think,
+            load_jac_skill,
+            list_files,
+            read_file,
+            write_code
+        ],
+        on_iteration=_iteration_hook,
+        max_react_iterations=15,
+        temperature=0.1,
+        max_tokens=8192,
+        stream=True,
+        logging=True
+    );
+    can execute with MainAgent entry;
+}

{jac_coder-0.2.7 → jac_coder-0.2.8}/jac_coder/core/walkers.impl.jac

@@ -4,6 +4,7 @@
 
 glob _PROGRESS_DIR: str = ".jaccoder";
 glob _PROGRESS_FILE: str = "progress.md";
+glob _UI_SPEC_FILE: str = "ui_spec.json";
 
 
 """Read .jaccoder/progress.md from the project directory. Returns content or empty string."""
@@ -30,6 +31,20 @@ def _read_progress(project_dir: str) -> str {
 }
 
 
+def _read_ui_spec(project_dir: str) -> str {
+    spec_path = os.path.join(project_dir, _PROGRESS_DIR, _UI_SPEC_FILE);
+    if not os.path.isfile(spec_path) {
+        return "";
+    }
+    try {
+        with open(spec_path, "r", encoding="utf-8") as f {
+            return f.read();
+        }
+    } except Exception {
+        return "";
+    }
+}
+
 impl ensure_main_agent() -> MainAgent {
     agents = [root()-->][?:MainAgent];
     if agents {
@@ -256,6 +271,15 @@ impl _consume_llm_stream(event_stream: Any) -> dict {
             emit_event("llm_tool_result", dict(event.data));
         } elif event.event_type == "steps_done" {
             emit_event("llm_steps_done", dict(event.data));
+        } elif event.event_type == "stream_reset" {
+            # byllm retried a transient drop: discard the partial reply (so the
+            # regenerated text isn't doubled) and forward the signal to the UI.
+            if event.data.get("scope") == "answer" {
+                response_text = "";
+            } else {
+                thought_text = "";
+            }
+            emit_event("llm_stream_reset", dict(event.data));
         } elif event.event_type == "chunk" {
             chunk_content = event.data.get("content", "");
             response_text += chunk_content;
@@ -319,6 +343,19 @@ impl _respond_and_persist(agent: MainAgent, ctx: interact) -> None {
         );
     }
 
+    if work_dir {
+        ui_spec_json = _read_ui_spec(work_dir);
+        if ui_spec_json {
+            prefix_parts.append(
+                "<ui-spec>\n"
+                "UISpec produced by UIDesignerAgent. "
+                "WorkerAgent MUST follow it when building or modifying pages.\n\n"
+                + ui_spec_json
+                + "\n</ui-spec>"
+            );
+        }
+    }
+
     if project_summary {
         prefix_parts.append(
             "[INTERNAL — background context from .jaccoder/progress.md. "
@@ -431,6 +468,12 @@ impl _respond_and_persist(agent: MainAgent, ctx: interact) -> None {
         emit_previewable();
     }
 
+    # Guaranteed end-of-turn struggle reflection (work turns only).
+    if not is_abort_requested() {
+        import from jac_coder.runtime.struggle_report { reflect_and_log }
+        reflect_and_log(agent, tool_records, files_modified, has_errors, response_text);
+    }
+
     report {
         "response": response_text,
         "agent": "main",

{jac_coder-0.2.7 → jac_coder-0.2.8}/jac_coder/core/walkers.jac

@@ -8,13 +8,13 @@ import from jac_coder.infra.config { llm, get_config }
 import from jaclang.runtimelib.builtin { restspec }
 import from jac_coder.runtime.context { build_context, ContextConfig }
 import from jac_coder.runtime.events { reset_steps, start_turn, emit_turn_summary, emit_event, clear_abort, is_abort_requested, emit_phase_change, emit_previewable }
-import from byllm.types { StreamEvent }
+import from jaclang.byllm.types { StreamEvent }
 import from jac_coder.runtime.memory {
     find_or_create_memory,
     _init_memory,
     update_memory_from_session
 }
-import from jac_coder.core.nodes { Session, MainAgent }
+import from jac_coder.core.nodes { Session, MainAgent, UIDesignerAgent }
 
 
 def ensure_main_agent() -> MainAgent;

{jac_coder-0.2.7 → jac_coder-0.2.8}/jac_coder/infra/config.jac

@@ -4,7 +4,7 @@ import threading;
 import from contextlib { suppress }
 import from pathlib { Path }
 import from dotenv { load_dotenv }
-import from byllm.lib { Model }
+import from jaclang.byllm.lib { Model }
 
 
 obj JacCoderConfig {

{jac_coder-0.2.7 → jac_coder-0.2.8}/jac_coder/runtime/prompt.impl.jac

@@ -6,6 +6,15 @@ impl compose_system_prompt(base_prompt: str) -> str {
     return (prompt + "\n\n" + listing) if listing else prompt;
 }
 
+impl compose_system_prompt_filtered(base_prompt: str, allowed_skills: set[str]) -> str {
+    skills_block = inject_skills_listing_filtered(allowed_skills);
+    return (base_prompt + "\n\n" + skills_block) if skills_block else base_prompt;
+}
+
+impl smells_like_build(message: str) -> bool {
+    return _smells_like_build(message);
+}
+
 # ---------------------------------------------------------------------------
 # infer_mode_hint — classify what the agent did from ground truth
 # ---------------------------------------------------------------------------

{jac_coder-0.2.7 → jac_coder-0.2.8}/jac_coder/runtime/prompt.jac

@@ -11,7 +11,7 @@ Signal chain per turn:
 """
 
 import os;
-import from jac_coder.runtime.skills { inject_skills_listing }
+import from jac_coder.runtime.skills { inject_skills_listing, inject_skills_listing_filtered }
 
 # ---------------------------------------------------------------------------
 # Mode hint constants — stored as strings for graph persistence safety
@@ -53,6 +53,17 @@ You have limited iterations. Prioritize a WORKING app over a perfect one:
 
 ## Build Workflow
 0. **Inspect the workspace** (per Step 0 above) — decide EXTEND vs CREATE before anything else.
+0.5. **UIDesignerAgent — UI design authority** (UIDesignerAgent owns ALL UI design decisions):
+
+  **Condition A — `.jaccoder/ui_spec.json` does NOT exist** (first build): Run UIDesignerAgent now, before any skill loading or file writing:
+  `spawn_agent(mode='designer', task="Design UISpec for <abs_path>\n\nDirectory listing:\n<paste list_files output>\n\nProject config (jac.toml):\n<paste jac.toml content, or 'not present'>\n\nUser request: <user_message>")`
+  Pass the directory listing and jac.toml you already read — UIDesignerAgent will use them directly. Wait for it to complete, then proceed to step 1.
+
+  **Condition B — `.jaccoder/ui_spec.json` EXISTS and the request involves UI design changes**: UI design changes include: visual redesign ("more attractive", "production-level", "like X"), theme/style/font changes, navigation structure changes, adding or removing pages, layout changes. Run UIDesignerAgent in update mode:
+  `spawn_agent(mode='designer', task="Update UISpec for <abs_path>\n\nCurrent UISpec:\n<paste .jaccoder/ui_spec.json content>\n\nUser request: <user_message>")`
+  Wait for UIDesignerAgent to update `ui_spec.json`, then spawn WorkerAgent to implement the changes.
+
+  **Condition C — `.jaccoder/ui_spec.json` EXISTS and request is feature or code only**: Bug fixes, logic changes, backend features, content changes. Skip UIDesignerAgent. Proceed to step 1 and spawn WorkerAgent.
 1. Load skills from `<jac-skills-available>` via `load_jac_skill(name)`: **always start with `jac-core-cheatsheet`**, then load the task-specific skills (fullstack + anything the task touches).
 2. Plan briefly, then create/update `.jaccoder/progress.md` with the plan. Keep planning SHORT: make each choice ONCE and move on — never re-litigate the same decision and don't restate the plan in chat. The plan lives in progress.md, not in long prose.
 3. Backend services (.sv.jac), then a minimal main.jac that renders a real layout (not a stub) — your live-preview shell; it grows as you wire in components.
@@ -197,3 +208,9 @@ No emojis in generated UI (headings, buttons, labels, empty states, toasts) or i
 """Build an agent's full system prompt: base persona + shared static context
 that belongs in the cached prompt prefix (currently the skills listing)."""
 def compose_system_prompt(base_prompt: str) -> str;
+
+"""Like compose_system_prompt but only includes skills listed in `allowed_skills`. Used by per-agent prompts."""
+def compose_system_prompt_filtered(base_prompt: str, allowed_skills: set[str]) -> str;
+
+"""Public wrapper for the private _smells_like_build check."""
+def smells_like_build(message: str) -> bool;

{jac_coder-0.2.7 → jac_coder-0.2.8}/jac_coder/runtime/skills.impl.jac

@@ -123,6 +123,27 @@ impl inject_skills_listing() -> str {
 }
 
 
+impl inject_skills_listing_filtered(allowed: set[str]) -> str {
+    reg = get_default_registry();
+    lines: list[str] = [];
+    for name in allowed {
+        if name in reg.skills {
+            meta = reg.skills[name];
+            lines.append(f"- {meta.name}: {meta.description}");
+        }
+    }
+    if not lines {
+        return "";
+    }
+    body = "\n".join(lines);
+    return (
+        "<jac-skills-available>\n"
+        + body
+        + "\n</jac-skills-available>"
+    );
+}
+
+
 # ---------------------------------------------------------------------------
 # Private helpers
 # ---------------------------------------------------------------------------

{jac_coder-0.2.7 → jac_coder-0.2.8}/jac_coder/runtime/skills.jac

@@ -89,3 +89,6 @@ def get_default_registry() -> SkillRegistry;
 """Render the available-skills listing as a single system-message string.
 Returns empty string when no skills are installed."""
 def inject_skills_listing() -> str;
+
+"""Render only skills whose names are in `allowed`. No cache — used for per-agent filtered prompts."""
+def inject_skills_listing_filtered(allowed: set[str]) -> str;