scios-cli 0.3.2__tar.gz → 0.4.0__tar.gz

{scios_cli-0.3.2 → scios_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scios-cli
-Version: 0.3.2
+Version: 0.4.0
 Summary: Scios unified CLI — dev environment, deployment, database, logs, and more
 Author: Scios Team
 License: Apache-2.0

{scios_cli-0.3.2 → scios_cli-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scios-cli"
-version = "0.3.2"
+version = "0.4.0"
 description = "Scios unified CLI — dev environment, deployment, database, logs, and more"
 readme = "README.md"
 license = {text = "Apache-2.0"}

{scios_cli-0.3.2 → scios_cli-0.4.0}/scios_cli/ag/create_flow.py

@@ -86,9 +86,17 @@ def create_and_build(
     max_wall_clock_min: int,
     wait: bool,
     launch: bool,
+    build: bool = False,
     log: Callable[[str], None] = print,
 ) -> dict:
-    """Full cold-start. Returns {idea_id, folder, status}."""
+    """Cold-start: create workspace + refine goal + idea.
+
+    When build=False (default for `scios ag create`): stops after creating the
+    idea. The scientist reviews the refined goal and idea before proceeding.
+    When build=True (used by `scios ag go`): also kicks off build-execute.
+
+    Returns {idea_id, folder, status}.
+    """
     from scios_cli.ag import scaffold as scaffold_mod
     from scios_cli.ag import sync_core
 
@@ -101,11 +109,8 @@ def create_and_build(
     log(f"   workspace {workspace_id}")
 
     log(f"② Refining the goal (AI auto-amend, same as /dashboard/plan) …")
-    # Use Maxwell's suggest-all-fields to turn the raw prompt into a structured
-    # goal (clean title, measurable target metrics, methodology, constraints) —
-    # exactly what the web /dashboard/plan page does. Fall back to the raw prompt
-    # only if the refinement call is unavailable.
-    title, description, target, details = goal[:120], goal, None, None
+    title, description, target_metrics, details = goal[:120], goal, None, None
+    methodology, constraints = None, None
     try:
         sess = client.maxwell_create_session(workspace_id=workspace_id)
         session_id = sess.get("id") or sess.get("sessionId") or sess.get("session_id")
@@ -113,7 +118,7 @@ def create_and_build(
             sug = client.suggest_all_fields(session_id, research_context=goal)
             title = sug.get("title") or title
             description = sug.get("description") or description
-            target = sug.get("targetMetrics") or sug.get("target_metrics") or None
+            target_metrics = sug.get("targetMetrics") or sug.get("target_metrics") or None
             methodology = sug.get("methodology")
             constraints = sug.get("constraints")
             parts = [p for p in (
@@ -121,14 +126,14 @@ def create_and_build(
                 (f"## Constraints\n{constraints}" if constraints else None),
             ) if p]
             details = "\n\n".join(parts) or None
-            log(f"   ✨ refined → \"{title}\"" + (f"  |  target: {target[:60]}" if target else ""))
+            log(f"   ✨ refined → \"{title}\"" + (f"  |  target: {target_metrics[:60]}" if target_metrics else ""))
     except SciosAPIError as e:
         log(f"   (auto-amend unavailable: {e}; using raw prompt)")
 
     log(f"③ Creating research goal …")
     rg = client.create_research_goal(
         workspace_id=workspace_id, title=title, description=description,
-        target=target, details=details, original_prompt=goal,
+        target=target_metrics, details=details, original_prompt=goal,
     )
     goal_id = rg.get("id") or rg.get("goalId")
     log(f"   goal {goal_id}")
@@ -141,31 +146,52 @@ def create_and_build(
         raise SystemExit(1)
     log(f"   idea {idea_id}")
 
+    # Write manifest + idea.md so the scientist can review
+    target_folder = Path(folder).expanduser().resolve() if folder else (Path.cwd() / f"scios-{name}")
+    target_folder.mkdir(parents=True, exist_ok=True)
+
+    host = endpoint.rstrip("/").removesuffix("/api/v1").rstrip("/")
+    m = Manifest(
+        idea_id=idea_id, endpoint=endpoint, token="",
+        execution=ExecutionConfig(mode="local", host_url=host),
+    )
+    m.budget.compute_scale = scale
+    m.budget.optimizer_iterations = budget_iterations
+    m.budget.max_wall_clock_min = max_wall_clock_min
+    save(target_folder, m)
+
+    # Write idea.md for the scientist to review
+    _write_idea_md(target_folder, idea_id=idea_id, workspace_id=workspace_id,
+                   goal_id=goal_id, title=title, description=description,
+                   target_metrics=target_metrics, methodology=methodology,
+                   constraints=constraints, host=host)
+
+    if not build:
+        # ── Stage-by-stage mode (default for `scios ag create`) ──
+        # Stop here. The scientist reviews idea.md, then says "run it" to
+        # kick off build-execute via `scios ag run`.
+        log(f"")
+        log(f"✨ Idea created: {idea_id}")
+        log(f"   Folder: {target_folder}")
+        log(f"   Review: {target_folder / 'idea.md'}")
+        log(f"")
+        log(f"   Next steps:")
+        log(f"   • Review idea.md — the AI-refined research goal")
+        log(f"   • scios ag status   — check build progress")
+        log(f"   • scios ag run      — kick off build-execute")
+        log(f"   • scios ag explain  — see scores after completion")
+        return {"idea_id": idea_id, "folder": str(target_folder), "status": "created"}
+
+    # ── Full pipeline mode (used by `scios ag go`) ──
     log(f"⑤ Kicking off build-execute (scale={scale}, iterations={budget_iterations}) …")
     stage_config = _build_stage_config(scale, budget_iterations, max_wall_clock_min)
     client.trigger_build_execute(idea_id, stage_config=stage_config)
 
-    target = Path(folder).expanduser().resolve() if folder else (Path.cwd() / f"scios-{name}")
-
     if not wait:
-        # Nothing to project yet — the workflow is built asynchronously. Write a
-        # minimal manifest so `ag status`/`ag mount` work once it's ready, and
-        # tell the user how to resume. (Mounting now would 404: no workflow yet.)
-        host = endpoint.rstrip("/").removesuffix("/api/v1").rstrip("/")
-        m = Manifest(
-            idea_id=idea_id, endpoint=endpoint, token="",
-            execution=ExecutionConfig(mode="local", host_url=host),
-        )
-        m.budget.compute_scale = scale
-        m.budget.optimizer_iterations = budget_iterations
-        m.budget.max_wall_clock_min = max_wall_clock_min
-        target.mkdir(parents=True, exist_ok=True)
-        save(target, m)
         log(f"✨ Build-execute started for idea {idea_id} (scale={scale}).")
-        log(f"   Manifest written → {target / 'scios.toml'}")
-        log(f"   Track progress:  scios ag status --folder {target}")
-        log(f"   When ready:      scios ag mount {idea_id} --folder {target}")
-        return {"idea_id": idea_id, "folder": str(target), "status": "building"}
+        log(f"   Track progress:  scios ag status --folder {target_folder}")
+        log(f"   When ready:      scios ag mount {idea_id} --folder {target_folder}")
+        return {"idea_id": idea_id, "folder": str(target_folder), "status": "building"}
 
     log("⑤ Waiting for build-execute to finish …")
 
@@ -179,26 +205,51 @@ def create_and_build(
         final = {"status": "unknown"}
     log(f"   build-execute {final.get('status')} (scios_score={final.get('scios_score')})")
 
-    log(f"⑥ Mounting → {target}")
-    sync_core.mount(client, idea_id, target, log=log)
+    log(f"⑥ Mounting → {target_folder}")
+    sync_core.mount(client, idea_id, target_folder, log=log)
+    save(target_folder, m)
+    scaffold_mod.scaffold(target_folder, m, log=log)
 
-    host = endpoint.rstrip("/").removesuffix("/api/v1").rstrip("/")
-    m = Manifest(
-        idea_id=idea_id, endpoint=endpoint, token="",
-        execution=ExecutionConfig(mode="local", host_url=host),
-    )
-    m.budget.compute_scale = scale
-    m.budget.optimizer_iterations = budget_iterations
-    m.budget.max_wall_clock_min = max_wall_clock_min
-    save(target, m)
-    scaffold_mod.scaffold(target, m, log=log)
-
-    log(f"✨ Ready: {target}")
-    log(f"   Open in Antigravity: antigravity {target}")
+    log(f"✨ Ready: {target_folder}")
+    log(f"   Open in Antigravity: antigravity {target_folder}")
     if launch:
-        _launch_editor(target, log)
-
-    return {"idea_id": idea_id, "folder": str(target), "status": "created"}
+        _launch_editor(target_folder, log)
+
+    return {"idea_id": idea_id, "folder": str(target_folder), "status": "created"}
+
+
+def _write_idea_md(
+    folder: Path, *, idea_id: str, workspace_id: str, goal_id: str,
+    title: str, description: str, target_metrics: str | None,
+    methodology: str | None, constraints: str | None, host: str,
+) -> None:
+    """Write idea.md for the scientist to review before proceeding."""
+    lines = [
+        f"# {title}",
+        "",
+        f"**Idea ID:** `{idea_id}`",
+        f"**Workspace:** `{workspace_id}`",
+        f"**Goal:** `{goal_id}`",
+        f"**View on Scios:** [{host}/ideas/{idea_id}]({host}/ideas/{idea_id})",
+        "",
+        "## Description",
+        description or "(no description)",
+    ]
+    if target_metrics:
+        lines += ["", "## Target Metrics", target_metrics]
+    if methodology:
+        lines += ["", "## Methodology", methodology]
+    if constraints:
+        lines += ["", "## Constraints", constraints]
+    lines += [
+        "",
+        "---",
+        "*Review this goal. When ready, tell the agent to proceed:*",
+        "- **\"run it\"** → kicks off the full build-execute pipeline",
+        "- **\"architect it\"** → step-by-step control (architect → convert → vibe → run)",
+        "- **\"status\"** → check current progress",
+    ]
+    (folder / "idea.md").write_text("\n".join(lines) + "\n")
 
 
 def _launch_editor(folder: Path, log: Callable[[str], None]) -> None:

{scios_cli-0.3.2 → scios_cli-0.4.0}/scios_cli/ag/plugin.py

@@ -1,8 +1,11 @@
-"""Antigravity Plugin — installs Scios as a global plugin at ~/.gemini/config/plugins/scios/.
+"""Antigravity Plugin — installs Scios as a global plugin.
 
-Provides MCP servers, skills, rules, and sidecars that work across all workspaces
-without per-workspace `.agents/` duplication. Per the Antigravity plugin spec
-(docs/integrations/antigravity/antigravity-docs-cache/markdown/plugins.md).
+Two install modes:
+  1. From repo: copies packages/scios-skills/ (the canonical plugin source)
+     to both ~/.gemini/config/plugins/scios/ (IDE) and
+     ~/.gemini/antigravity-cli/plugins/scios/ (CLI).
+  2. From pip install (no repo): generates plugin files inline with the same
+     content.
 
 Plugin layout:
     ~/.gemini/config/plugins/scios/
@@ -10,14 +13,16 @@ Plugin layout:
     ├── mcp_config.json         (scios-core + scios-maxwell)
     ├── hooks.json              (ruff format-on-save)
     ├── skills/
-    │   └── scios-workflow/
-    │       └── SKILL.md
+    │   └── scios/
+    │       ├── SKILL.md
+    │       ├── AGENTS.md
+    │       ├── docs/
+    │       └── resources/
     ├── rules/
-    │   └── scios.md
+    │   └── scios-conventions.md
     └── sidecars/
         ├── scios-sync/
-        │   ├── sidecar.json
-        │   └── sync.sh
+        │   └── sidecar.json
         └── scios-notifier/
             ├── sidecar.json
             └── notify.sh
@@ -31,42 +36,103 @@ import shutil
 from pathlib import Path
 from typing import Callable
 
-PLUGIN_DIR = Path.home() / ".gemini" / "config" / "plugins" / "scios"
+# Both Antigravity surfaces get the same plugin content
+PLUGIN_DIRS = [
+    Path.home() / ".gemini" / "config" / "plugins" / "scios",        # IDE
+    Path.home() / ".gemini" / "antigravity-cli" / "plugins" / "scios",  # CLI
+]
+# Primary dir for backward compat with code that reads PLUGIN_DIR
+PLUGIN_DIR = PLUGIN_DIRS[0]
 CONFIG_FILE = Path.home() / ".gemini" / "config" / "config.json"
 
 SCIOS_BIN = shutil.which("scios") or "scios"
 
+# Items to skip when copying plugin source
+_SKIP = {"node_modules", ".git", "bin", "package.json", "package-lock.json", ".npmignore", "README.md"}
+
 
 def plugin_installed() -> bool:
     """Check if the global Antigravity plugin is installed."""
     return (PLUGIN_DIR / "plugin.json").exists()
 
 
+def _find_plugin_source() -> Path | None:
+    """Find the canonical plugin source in the repo."""
+    # Walk up from this file to find packages/scios-skills/
+    here = Path(__file__).resolve()
+    for parent in [here.parent.parent.parent.parent, here.parent.parent.parent.parent.parent]:
+        candidate = parent / "packages" / "scios-skills"
+        if (candidate / "plugin.json").exists():
+            return candidate
+    return None
+
+
+def _copy_tree(src: Path, dest: Path) -> None:
+    """Recursively copy src to dest, skipping npm/git metadata."""
+    dest.mkdir(parents=True, exist_ok=True)
+    for item in src.iterdir():
+        if item.name in _SKIP:
+            continue
+        target = dest / item.name
+        if item.is_dir():
+            _copy_tree(item, target)
+        else:
+            target.write_bytes(item.read_bytes())
+
+
 def install_plugin(
     *,
     enable_notifier: bool = False,
     log: Callable[[str], None] = print,
 ) -> None:
-    """Write all plugin files and update config.json to enable sidecars."""
+    """Install the Scios plugin to all Antigravity plugin directories."""
+
+    plugin_src = _find_plugin_source()
+
+    for plugin_dir in PLUGIN_DIRS:
+        # Clean old install to remove stale files from previous versions
+        if plugin_dir.exists():
+            shutil.rmtree(plugin_dir)
+
+        if plugin_src:
+            # Mode 1: Copy from repo source (canonical, always current)
+            _copy_tree(plugin_src, plugin_dir)
+            log(f"  ✓ Copied plugin from repo → {plugin_dir}")
+        else:
+            # Mode 2: Generate inline (pip-installed CLI without repo)
+            _generate_plugin_inline(plugin_dir, log=log)
+
+        # Add sidecars (not in the npm package — they need absolute paths)
+        _install_sidecars(plugin_dir, log=log)
+
+    # Update config.json to enable sidecars
+    _update_config(enable_sync=True, enable_notifier=enable_notifier)
+    log(f"  ✓ config.json (sync: enabled, notifier: {'enabled' if enable_notifier else 'disabled — use --enable-notifier'})")
+
+    log(f"\n✓ Scios plugin installed → {len(PLUGIN_DIRS)} location(s)")
+
+
+def _generate_plugin_inline(plugin_dir: Path, *, log: Callable[[str], None] = print) -> None:
+    """Generate plugin files from inline content (no repo available)."""
 
     # ── plugin.json ──
-    _write_json(PLUGIN_DIR / "plugin.json", {
+    _write_json(plugin_dir / "plugin.json", {
+        "$schema": "https://antigravity.google/schemas/v1/plugin.json",
         "name": "scios",
-        "displayName": "Scios Research Platform",
-        "description": "Drive autonomous scientific research — stage-by-stage pipeline, MCP tools, Maxwell assistant.",
+        "description": "Scios autonomous scientific research platform — create ideas, build multi-agent workflows, run experiments, optimize iteratively, and audit results. Powered by the Scios API.",
     })
 
     # ── mcp_config.json ──
-    _write_json(PLUGIN_DIR / "mcp_config.json", {
+    _write_json(plugin_dir / "mcp_config.json", {
         "mcpServers": {
             "scios-core": {
                 "command": SCIOS_BIN,
-                "args": ["ag", "mcp", "core"],
+                "args": ["mcp", "core"],
                 "env": {},
             },
             "scios-maxwell": {
                 "command": SCIOS_BIN,
-                "args": ["ag", "mcp", "maxwell"],
+                "args": ["mcp", "maxwell"],
                 "env": {},
             },
         }
@@ -74,32 +140,44 @@ def install_plugin(
     log("  ✓ mcp_config.json (scios-core + scios-maxwell)")
 
     # ── hooks.json ──
-    _write_json(PLUGIN_DIR / "hooks.json", {
-        "hooks": {
-            "afterFileEdit": [
+    _write_json(plugin_dir / "hooks.json", {
+        "scios-auto-format": {
+            "PostToolUse": [
                 {
-                    "command": "sh -c 'command -v ruff >/dev/null 2>&1 && ruff format \"$FILE\" || true'",
-                    "glob": "agents/*.py",
+                    "matcher": "edit_file",
+                    "hooks": [
+                        {
+                            "type": "command",
+                            "command": "sh",
+                            "args": ["-c", "command -v ruff >/dev/null 2>&1 && ruff format \"$ANTIGRAVITY_TOOL_ARG_TARGET_FILE\" 2>/dev/null || true"],
+                            "timeout": 10,
+                            "description": "Auto-format Python agent files with ruff after edits",
+                        }
+                    ]
                 }
             ]
         }
     })
     log("  ✓ hooks.json (ruff format-on-save)")
 
-    # ── skills/scios-workflow/SKILL.md ──
-    skill_dir = PLUGIN_DIR / "skills" / "scios-workflow"
+    # ── skills/scios/SKILL.md ──
+    skill_dir = plugin_dir / "skills" / "scios"
     skill_dir.mkdir(parents=True, exist_ok=True)
-    (skill_dir / "SKILL.md").write_text(_WORKFLOW_SKILL)
-    log("  ✓ skills/scios-workflow/SKILL.md")
+    (skill_dir / "SKILL.md").write_text(_SKILL_MD)
+    log("  ✓ skills/scios/SKILL.md")
 
-    # ── rules/scios.md ──
-    rules_dir = PLUGIN_DIR / "rules"
+    # ── rules/scios-conventions.md ──
+    rules_dir = plugin_dir / "rules"
     rules_dir.mkdir(parents=True, exist_ok=True)
-    (rules_dir / "scios.md").write_text(_RULES)
-    log("  ✓ rules/scios.md")
+    (rules_dir / "scios-conventions.md").write_text(_RULES)
+    log("  ✓ rules/scios-conventions.md")
+
+
+def _install_sidecars(plugin_dir: Path, *, log: Callable[[str], None] = print) -> None:
+    """Install sidecar definitions (need absolute paths, can't be in npm package)."""
 
     # ── sidecars/scios-sync/ ──
-    sync_dir = PLUGIN_DIR / "sidecars" / "scios-sync"
+    sync_dir = plugin_dir / "sidecars" / "scios-sync"
     sync_dir.mkdir(parents=True, exist_ok=True)
     _write_json(sync_dir / "sidecar.json", {
         "description": "Auto-sync: watches agents/*.py and pushes edits to the Scios backend",
@@ -111,7 +189,7 @@ def install_plugin(
     log("  ✓ sidecars/scios-sync (auto-sync agent code)")
 
     # ── sidecars/scios-notifier/ ──
-    notifier_dir = PLUGIN_DIR / "sidecars" / "scios-notifier"
+    notifier_dir = plugin_dir / "sidecars" / "scios-notifier"
     notifier_dir.mkdir(parents=True, exist_ok=True)
     (notifier_dir / "notify.sh").write_text(_NOTIFIER_SCRIPT)
     (notifier_dir / "notify.sh").chmod(0o755)
@@ -127,18 +205,13 @@ def install_plugin(
     })
     log("  ✓ sidecars/scios-notifier (status polling, opt-in)")
 
-    # ── config.json (enable sidecars) ──
-    _update_config(enable_sync=True, enable_notifier=enable_notifier)
-    log(f"  ✓ config.json (sync: enabled, notifier: {'enabled' if enable_notifier else 'disabled — use --enable-notifier'})")
-
-    log(f"\n✓ Scios plugin installed → {PLUGIN_DIR}")
-
 
 def uninstall_plugin(*, log: Callable[[str], None] = print) -> None:
-    """Remove the plugin directory and config entries."""
-    if PLUGIN_DIR.exists():
-        shutil.rmtree(PLUGIN_DIR)
-        log(f"✓ Removed {PLUGIN_DIR}")
+    """Remove the plugin from all directories and config entries."""
+    for plugin_dir in PLUGIN_DIRS:
+        if plugin_dir.exists():
+            shutil.rmtree(plugin_dir)
+            log(f"✓ Removed {plugin_dir}")
     _update_config(remove=True)
     log("✓ Removed sidecar config from config.json")
 
@@ -176,48 +249,62 @@ def _write_json(path: Path, data: dict) -> None:
 
 
 # ---------------------------------------------------------------------------
-# Inlined content (avoids reading from skill files at install time)
+# Inlined content (used when repo source is not available)
 # ---------------------------------------------------------------------------
 
-_WORKFLOW_SKILL = """\
+_SKILL_MD = """\
 ---
-name: scios-workflow
-description: Runs, optimizes, and explains Scios research workflows in this workspace. Use when the user asks to run the workflow, iterate on an agent, check scores or build-execute progress, optimize, or understand why an execution failed. Applies to any Scios workspace containing scios.toml and an agents/ folder.
+name: scios
+description: >
+  Drive the Scios autonomous scientific research platform. Use this skill
+  whenever the user asks to do research, run experiments, or explore scientific
+  questions. The skill runs a stage-by-stage pipeline: create idea → architect
+  → convert to workflow → generate agent code → execute → explain scores →
+  optimize.
 ---
 
-# Scios Workflow Skill
-
-This workspace is a Scios research project. Use the `scios-core` MCP tools and the
-`scios` CLI to drive it.
-
-## Common tasks
-- **Run the workflow**: call the `scios_run` tool, or run `scios ag run`. Respect
-  the `mode` in `scios.toml` (local vs cloud). For a one-off cloud run use
-  `scios ag run --mode cloud`.
-- **Check status / scores**: call `scios_status` or run `scios ag status`. Report
-  the `scios_score` and the current build-execute stage.
-- **Explain results**: run `scios ag explain` for scores, per-node trace, and
-  failure diagnostics. This is the most important command after a run.
-- **Edit an agent**: open the relevant file in `agents/`, make the change, save.
-  The sync sidecar pushes it to the backend automatically.
-- **Optimize**: run `scios ag optimize --iterations N` (rides the existing
-  optimizer settings). Larger `compute_scale` in `scios.toml` sizes runs bigger.
-- **Explain a failure**: call `scios_explain` or read `execution/trace_summary.md`
-  and `execution/logs.json`.
-- **Diff after optimize**: run `scios ag diff` to see what the optimizer changed.
-
-## Guidance
-- The backend is the source of truth; files are a view. Don't hand-edit read-only
-  folders (`execution/`, `workflows/`, `datasets/`, `dashboards/`).
-- Prefer the MCP tools for structured results; fall back to the CLI for anything
-  not exposed as a tool.
+# Scios — Research Pipeline Skill
+
+## Architecture
+
+The skill delegates exclusively to the `scios` CLI for all backend interactions.
+There are no fallback scripts — the CLI is the single source of truth.
+
+Agents can also use the **scios-core** and **scios-maxwell** MCP tools bundled
+with this plugin for structured tool-call interactions.
+
+## Quick Start
+
+```bash
+scios ag go "Your research question here"
+```
+
+## Stage-by-Stage
+
+| # | Command | Purpose |
+|---|---------|---------|
+| 1 | `scios ag create "<goal>"` | Create workspace + idea |
+| 2 | `scios ag architect` | Refine hypothesis & methodology |
+| 3 | `scios ag convert` | Build workflow DAG |
+| 4 | `scios ag vibe` | Generate agent code |
+| 5 | `scios ag run` | Execute workflow |
+| 6 | `scios ag explain` | Scores, traces, failures |
+| 7 | `scios ag optimize [-n N]` | Improve iteratively |
+| 8 | `scios ag diff` | See what optimizer changed |
+
+## Auth
+
+1. `SCIOS_API_TOKEN` env var (first priority)
+2. `~/.scios/credentials.json` (written by `scios login`)
+
+## Hard Rules
+
+- Run one stage, report, STOP. Never chain without user asking.
+- Never present unaudited results — always show verified scores.
+- If something fails, report root cause. No fallbacks, no retries.
 """
 
 _RULES = """\
----
-trigger: always_on
----
-
 # Scios Workspace Conventions
 
 This folder is a **Scios research workspace** projected from the Scios backend by
@@ -226,7 +313,7 @@ files are a synced *view*.
 
 ## Folder map
 - `agents/*.py` — vibed agent code. **Two-way synced**: editing a file pushes it
-  to the backend (via the sync sidecar or `scios ag push-code`). The first line
+  to the backend (via `scios ag push-code` or `scios ag sync`). The first line
   `# AGENT_ID: <uuid>` is the sync key — **never delete or edit it**.
 - `workflows/definition.json` — the workflow DAG (read-only projection).
 - `execution/` — metrics.json, trace_summary.md, logs.json (read-only).
@@ -235,18 +322,19 @@ files are a synced *view*.
 - `scios.toml` — the only local-authoritative file (idea_id, endpoint, mode, budget).
 
 ## How to work here
-- To change an agent's behaviour, edit its file in `agents/` and save. The
-  sync sidecar pushes it automatically, or use `scios ag push-code <file>`.
+- To change an agent's behaviour, edit its file in `agents/` and save.
+  Push with `scios ag push-code <file>` or use `scios ag sync` for auto-push.
 - To run the workflow: `scios ag run` (mode from `scios.toml`).
 - To check progress/scores: `scios ag status` or `scios ag explain`.
-- Prefer the `scios-core` MCP tools (`scios_run`, `scios_status`, `scios_logs`,
-  `scios_explain`) and the `scios-maxwell` assistant over shelling out manually.
+- Prefer the `scios-core` MCP tools (`scios_run`, `scios_status`, `scios_explain`)
+  and the `scios-maxwell` MCP assistant over shelling out manually.
 
 ## Hard rules
 - Never edit files under `execution/`, `workflows/`, `datasets/`, `dashboards/`
   by hand — they are overwritten on the next sync.
 - Never remove the `# AGENT_ID:` header from an agent file.
 - Do not invent new API endpoints; the CLI already wraps the backend.
+- After editing agents, push code before running. After optimize, pull code before editing.
 """
 
 _NOTIFIER_SCRIPT = """\

{scios_cli-0.3.2 → scios_cli-0.4.0}/scios_cli/commands/ag.py

@@ -287,16 +287,22 @@ def create(
     scale: str = typer.Option("small", "--scale", help="compute_scale: small|medium|large"),
     budget_iterations: int = typer.Option(3, "--budget-iterations", help="Optimizer iterations"),
     max_wall_clock_min: int = typer.Option(60, "--max-wall-clock-min", help="Wall-clock budget (minutes)"),
-    wait: bool = typer.Option(True, "--wait/--no-wait", help="Wait for build-execute to finish, then mount"),
+    wait: bool = typer.Option(False, "--wait/--no-wait", help="Wait for build-execute to finish, then mount (default: no-wait)"),
     launch: bool = typer.Option(False, "--launch/--no-launch", help="Open the folder when done"),
 ):
-    """Create a workspace+goal+idea, kick off build-execute, then mount the result."""
+    """Create a workspace+goal+idea. Does NOT kick off build-execute by default.
+
+    The scientist reviews the refined goal (idea.md) before deciding to proceed.
+    Use `scios ag run` to kick off build-execute after review.
+    Use `scios ag go` for the full pipeline in one shot.
+    """
     from scios_cli.ag.create_flow import create_and_build
 
     create_and_build(
         goal=goal, folder=folder, endpoint=endpoint, token=_resolve_token(token),
         scale=scale, budget_iterations=budget_iterations,
         max_wall_clock_min=max_wall_clock_min, wait=wait, launch=launch,
+        build=False,
         log=lambda x: console.print(x),
     )
 
@@ -759,6 +765,7 @@ def go(
         token=_resolve_token(token),
         scale=scale, budget_iterations=budget_iterations,
         max_wall_clock_min=max_wall_clock_min, wait=True, launch=False,
+        build=True,
         log=lambda x: console.print(x),
     )
 

{scios_cli-0.3.2 → scios_cli-0.4.0}/scios_cli/commands/run.py

@@ -2,7 +2,9 @@
 from __future__ import annotations
 
 import os
+from pathlib import Path
 import secrets
+import shutil
 import subprocess
 
 import typer
@@ -309,36 +311,64 @@ def _get_lsb_codename() -> str:
     return r.stdout.strip() if r.returncode == 0 else "rodete"
 
 
+def _is_glinux() -> bool:
+    """Check if running on gLinux (Rodete/Debian-derived Google desktop OS)."""
+    if os.path.exists("/etc/glinux") or os.path.exists("/etc/glinux_version"):
+        return True
+    if shutil.which("glinux-add-repo") or os.path.exists("/usr/sbin/glinux-add-repo") or os.path.exists("/usr/bin/glinux-add-repo"):
+        return True
+    try:
+        if os.path.exists("/etc/os-release"):
+            content = Path("/etc/os-release").read_text()
+            if "go/glinux" in content or "glinux" in content.lower():
+                return True
+        if os.path.exists("/etc/lsb-release"):
+            content = Path("/etc/lsb-release").read_text()
+            if "GOOGLE_ID=Goobuntu" in content or "GOOGLE_CODENAME=" in content:
+                return True
+    except Exception:
+        pass
+    return False
+
+
 def _ensure_docker_access() -> None:
     """Check that the current user can access Docker without sudo.
 
-    If Docker is not installed on gLinux, offers to install it.
-    If the docker socket is not accessible, guides the user to fix it.
+    If Docker is not installed or not working on gLinux, offers to install/configure it.
+    If the docker socket is not accessible, guides the user to fix permissions.
     """
-    # Check if docker daemon is actually running
-    r = subprocess.run(["docker", "info"], capture_output=True, text=True)
-    if r.returncode == 0:
-        return  # Docker is accessible
+    is_glinux = _is_glinux()
 
-    stderr = (r.stderr or "").lower()
-    is_glinux = os.path.exists("/etc/glinux_version") or os.path.exists("/usr/bin/glinux-add-repo")
+    # Check if docker binary exists on PATH
+    if not shutil.which("docker"):
+        if is_glinux:
+            _install_docker_glinux()
+        else:
+            console.print("[error]Docker is not installed or not in PATH.[/error]")
+            console.print("[muted]Install Docker: https://docs.docker.com/engine/install/[/muted]")
+            raise typer.Exit(1)
 
-    # Docker daemon not installed/running (socket missing or daemon not running)
-    daemon_missing = ("no such file" in stderr
-                      or "is the docker daemon running" in stderr
-                      or ("connect:" in stderr and "docker.sock" in stderr))
-    if daemon_missing:
+    # Check if docker daemon is reachable
+    try:
+        r = subprocess.run(["docker", "info"], capture_output=True, text=True)
+    except FileNotFoundError:
         if is_glinux:
             _install_docker_glinux()
         else:
-            console.print("[error]Docker daemon is not running.[/error]")
+            console.print("[error]Docker is not installed or not in PATH.[/error]")
             console.print("[muted]Install Docker: https://docs.docker.com/engine/install/[/muted]")
             raise typer.Exit(1)
 
+    if r.returncode == 0:
+        return  # Docker is accessible
+
+    stderr = (r.stderr or "").lower()
+
+    # Check for permission denied error
     if "permission denied" in stderr:
-        # Check if user is configured in docker group (even if shell hasn't refreshed)
         import getpass
         import grp
+
         username = getpass.getuser()
         try:
             docker_group = grp.getgrnam("docker")
@@ -347,7 +377,6 @@ def _ensure_docker_access() -> None:
             in_group_configured = False
 
         if in_group_configured:
-            # User is in docker group but current shell session hasn't picked it up
             console.print("[warning]⚠ Docker permission denied — your shell hasn't picked up the 'docker' group yet.[/warning]")
             console.print()
             console.print("  Run one of these to fix it:")
@@ -366,7 +395,10 @@ def _ensure_docker_access() -> None:
 
         raise typer.Exit(1)
 
-    # Docker exists but some other error
+    # If docker info failed for any other reason on gLinux (daemon stopped, socket missing, etc.)
+    if is_glinux:
+        _install_docker_glinux()
+
     console.print(f"[error]Docker is not available: {r.stderr.strip()}[/error]")
     console.print("[muted]Check Docker installation — see go/installdocker[/muted]")
     raise typer.Exit(1)

{scios_cli-0.3.2 → scios_cli-0.4.0}/scios_cli/commands/setup.py

@@ -101,21 +101,22 @@ _SKILL_TARGETS = None  # lazy
 
 
 def _get_skill_targets():
-    """Global agent skill directories."""
+    """Global agent skill directories (non-Antigravity platforms)."""
     global _SKILL_TARGETS
     if _SKILL_TARGETS is None:
         from pathlib import Path
         home = Path.home()
         _SKILL_TARGETS = [
-            ("Antigravity / Cline / Roo", home / ".agents" / "skills" / "scios"),
-            ("Claude Code",               home / ".claude" / "skills" / "scios"),
-            ("OpenCode",                   home / ".config" / "opencode" / "skills" / "scios"),
+            ("Cline / Roo",  home / ".agents" / "skills" / "scios"),
+            ("Claude Code",  home / ".claude" / "skills" / "scios"),
+            ("OpenCode",     home / ".config" / "opencode" / "skills" / "scios"),
         ]
     return _SKILL_TARGETS
 
 
 def _find_skill_source():
     """Find skill source directory (repo or None)."""
+    # The canonical source is packages/scios-skills/skills/scios/
     for candidate in [
         REPO_ROOT / "packages" / "scios-skills" / "skills" / "scios",
         REPO_ROOT / ".agents" / "skills" / "scios",
@@ -126,10 +127,12 @@ def _find_skill_source():
 
 
 def ensure_skill_updated(*, quiet: bool = False) -> bool:
-    """Ensure the global scios skill is installed and up-to-date.
+    """Ensure the global scios skill is installed to non-Antigravity agent platforms.
 
-    Called automatically after `scios login` and available via `scios setup skill`.
+    For Antigravity, the plugin install (ensure_plugin_updated) handles everything.
+    This function handles Cline, Claude Code, OpenCode etc. which only read SKILL.md.
 
+    Called automatically after `scios login` and available via `scios setup skill`.
     Returns True if the skill was installed/updated, False if skipped.
     """
     targets = _get_skill_targets()

{scios_cli-0.3.2 → scios_cli-0.4.0}/scios_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scios-cli
-Version: 0.3.2
+Version: 0.4.0
 Summary: Scios unified CLI — dev environment, deployment, database, logs, and more
 Author: Scios Team
 License: Apache-2.0