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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scios-cli
-Version: 0.3.1
+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.1 → scios_cli-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scios-cli"
-version = "0.3.1"
+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.1 → 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.1 → scios_cli-0.4.0}/scios_cli/ag/local_runner.py

@@ -159,7 +159,7 @@ def _run_node(
     # Match the backend orchestrator's init_args EXACTLY (agent_orchestrator.py):
     # only name + model. Passing the raw node `configuration` collides with fields
     # the primitive __init__ already sets (e.g. `description`) → TypeError.
-    init_args = {"name": agent_name, "model": "gemini-3.5-flash"}
+    init_args = {"name": agent_name, "model": "gemini-3.6-flash"}
 
     node_dir = work_dir / node_id
     node_dir.mkdir(parents=True, exist_ok=True)

scios_cli-0.4.0/scios_cli/ag/plugin.py

@@ -0,0 +1,371 @@
+"""Antigravity Plugin — installs Scios as a global plugin.
+
+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/
+    ├── plugin.json
+    ├── mcp_config.json         (scios-core + scios-maxwell)
+    ├── hooks.json              (ruff format-on-save)
+    ├── skills/
+    │   └── scios/
+    │       ├── SKILL.md
+    │       ├── AGENTS.md
+    │       ├── docs/
+    │       └── resources/
+    ├── rules/
+    │   └── scios-conventions.md
+    └── sidecars/
+        ├── scios-sync/
+        │   └── sidecar.json
+        └── scios-notifier/
+            ├── sidecar.json
+            └── notify.sh
+
+Sidecar config lives at ~/.gemini/config/config.json (user-controlled enable/disable).
+"""
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+from typing import Callable
+
+# 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:
+    """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", {
+        "$schema": "https://antigravity.google/schemas/v1/plugin.json",
+        "name": "scios",
+        "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", {
+        "mcpServers": {
+            "scios-core": {
+                "command": SCIOS_BIN,
+                "args": ["mcp", "core"],
+                "env": {},
+            },
+            "scios-maxwell": {
+                "command": SCIOS_BIN,
+                "args": ["mcp", "maxwell"],
+                "env": {},
+            },
+        }
+    })
+    log("  ✓ mcp_config.json (scios-core + scios-maxwell)")
+
+    # ── hooks.json ──
+    _write_json(plugin_dir / "hooks.json", {
+        "scios-auto-format": {
+            "PostToolUse": [
+                {
+                    "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/SKILL.md ──
+    skill_dir = plugin_dir / "skills" / "scios"
+    skill_dir.mkdir(parents=True, exist_ok=True)
+    (skill_dir / "SKILL.md").write_text(_SKILL_MD)
+    log("  ✓ skills/scios/SKILL.md")
+
+    # ── rules/scios-conventions.md ──
+    rules_dir = plugin_dir / "rules"
+    rules_dir.mkdir(parents=True, exist_ok=True)
+    (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.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",
+        "display_name": "Scios Sync",
+        "command": SCIOS_BIN,
+        "args": ["ag", "sync"],
+        "restart_policy": "on-failure",
+    })
+    log("  ✓ sidecars/scios-sync (auto-sync agent code)")
+
+    # ── 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)
+    _write_json(notifier_dir / "sidecar.json", {
+        "description": "Polls build-execute status every 60s and notifies via agentapi when done",
+        "display_name": "Scios Notifier",
+        "builtin": "schedule",
+        "args": [
+            "*/1 * * * *",
+            "/bin/bash",
+            str(notifier_dir / "notify.sh"),
+        ],
+    })
+    log("  ✓ sidecars/scios-notifier (status polling, opt-in)")
+
+
+def uninstall_plugin(*, log: Callable[[str], None] = print) -> None:
+    """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")
+
+
+def _update_config(
+    *,
+    enable_sync: bool = True,
+    enable_notifier: bool = False,
+    remove: bool = False,
+) -> None:
+    """Update ~/.gemini/config/config.json to enable/disable Scios sidecars."""
+    config: dict = {}
+    if CONFIG_FILE.exists():
+        try:
+            config = json.loads(CONFIG_FILE.read_text())
+        except (json.JSONDecodeError, OSError):
+            config = {}
+
+    sidecars = config.setdefault("sidecars", {})
+
+    if remove:
+        sidecars.pop("scios/scios-sync", None)
+        sidecars.pop("scios/scios-notifier", None)
+    else:
+        sidecars["scios/scios-sync"] = {"enabled": enable_sync}
+        sidecars["scios/scios-notifier"] = {"enabled": enable_notifier}
+
+    CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(json.dumps(config, indent=2) + "\n")
+
+
+def _write_json(path: Path, data: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2) + "\n")
+
+
+# ---------------------------------------------------------------------------
+# Inlined content (used when repo source is not available)
+# ---------------------------------------------------------------------------
+
+_SKILL_MD = """\
+---
+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 — 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 = """\
+# Scios Workspace Conventions
+
+This folder is a **Scios research workspace** projected from the Scios backend by
+the `scios ag` CLI. Treat the backend DB as the single source of truth — these
+files are a synced *view*.
+
+## Folder map
+- `agents/*.py` — vibed agent code. **Two-way synced**: editing a file pushes it
+  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).
+- `datasets/` — inline data, `.url` shortcuts (gs://), or `.metadata.json`.
+- `dashboards/` — generated result dashboards (read-only).
+- `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.
+  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_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 = """\
+#!/usr/bin/env bash
+# Scios status notifier — polls build-execute status, notifies via agentapi when done.
+# Runs as a scheduled sidecar (every 60s). Writes state to $ANTIGRAVITY_EXECUTABLE_DATA_DIR.
+
+set -euo pipefail
+
+STATE_DIR="${ANTIGRAVITY_EXECUTABLE_DATA_DIR:-/tmp/scios-notifier}"
+mkdir -p "$STATE_DIR"
+LAST_STATUS_FILE="$STATE_DIR/last_status"
+
+# Get current status (requires scios.toml in CWD or nearest parent)
+STATUS_JSON=$(scios ag status 2>/dev/null | head -5 || true)
+if [[ -z "$STATUS_JSON" ]]; then
+  exit 0  # No workspace mounted, nothing to do
+fi
+
+# Extract status and score
+CURRENT_STATUS=$(echo "$STATUS_JSON" | grep -oP 'status:\\s*\\K\\S+' || echo "unknown")
+SCORE=$(echo "$STATUS_JSON" | grep -oP 'scios_score:\\s*\\K\\S+' || echo "—")
+LAST_STATUS=$(cat "$LAST_STATUS_FILE" 2>/dev/null || echo "unknown")
+
+# Notify only on state transitions to terminal states
+if [[ "$CURRENT_STATUS" != "$LAST_STATUS" ]]; then
+  echo "$CURRENT_STATUS" > "$LAST_STATUS_FILE"
+  if [[ "$CURRENT_STATUS" == "completed" ]]; then
+    agentapi new-conversation "✅ Scios execution completed — scios_score: $SCORE. Run \\`scios ag explain\\` for details." 2>/dev/null || true
+  elif [[ "$CURRENT_STATUS" == "failed" ]]; then
+    agentapi new-conversation "❌ Scios execution failed. Run \\`scios ag explain\\` to see what went wrong." 2>/dev/null || true
+  fi
+fi
+"""

{scios_cli-0.3.1 → scios_cli-0.4.0}/scios_cli/ag/scaffold.py

@@ -301,16 +301,29 @@ def _write(path: Path, content: str, *, limit: int | None = None) -> None:
 
 
 def scaffold(folder: Path, manifest: Manifest, *, log=print) -> None:
-    """(Re)write all Antigravity + VS Code integration files into `folder`."""
+    """(Re)write all Antigravity + VS Code integration files into `folder`.
+
+    If the global Antigravity plugin is installed (~/.gemini/config/plugins/scios/),
+    skip the .agents/ MCP config, rules, skills, and hooks — the plugin provides
+    those globally. Only write workspace-specific files (workflows + .vscode).
+    """
+    from scios_cli.ag.plugin import plugin_installed
+
     agents_dir = folder / ".agents"
+    has_global_plugin = plugin_installed()
+
+    if has_global_plugin:
+        log("  ℹ Global Antigravity plugin detected — skipping .agents/ MCP/rules/skills (provided by plugin)")
+    else:
+        _write(agents_dir / "mcp_config.json", json.dumps(_mcp_config(manifest), indent=2))
+        _write(agents_dir / "rules" / "scios.md", _RULES, limit=CHAR_LIMIT)
+        _write(agents_dir / "skills" / "scios-workflow" / "SKILL.md", _SKILL)
+        _write(agents_dir / "hooks.json", json.dumps(_hooks(), indent=2))
 
-    _write(agents_dir / "mcp_config.json", json.dumps(_mcp_config(manifest), indent=2))
-    _write(agents_dir / "rules" / "scios.md", _RULES, limit=CHAR_LIMIT)
-    _write(agents_dir / "skills" / "scios-workflow" / "SKILL.md", _SKILL)
+    # Workflows are always workspace-specific (they reference workspace commands)
     _write(agents_dir / "workflows" / "scios-run.md", _WF_RUN, limit=CHAR_LIMIT)
     _write(agents_dir / "workflows" / "scios-optimize.md", _WF_OPTIMIZE, limit=CHAR_LIMIT)
     _write(agents_dir / "workflows" / "scios-explain.md", _WF_EXPLAIN, limit=CHAR_LIMIT)
-    _write(agents_dir / "hooks.json", json.dumps(_hooks(), indent=2))
 
     import shutil