devops-bot-sdk 1.4.117__tar.gz → 1.4.119__tar.gz

{devops_bot_sdk-1.4.117 → devops_bot_sdk-1.4.119}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.4.117
+Version: 1.4.119
 Summary: DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app
 Author: noumanaziz2128
 License-Expression: LicenseRef-Proprietary

{devops_bot_sdk-1.4.117 → devops_bot_sdk-1.4.119}/devops_bot_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.4.117
+Version: 1.4.119
 Summary: DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app
 Author: noumanaziz2128
 License-Expression: LicenseRef-Proprietary

{devops_bot_sdk-1.4.117 → devops_bot_sdk-1.4.119}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -67,6 +67,7 @@ sdk/models/snapshots.py
 sdk/ui/__init__.py
 sdk/ui/api.py
 sdk/ui/dashboard.py
+sdk/ui/ip_allowlist.py
 sdk/ui/jobs.py
 sdk/ui/runner.py
 sdk/ui/security.py
@@ -78,7 +79,6 @@ sdk/ui/static/app.js
 sdk/ui/static/custom-agents.html
 sdk/ui/static/default-agents.html
 sdk/ui/static/index.html
-sdk/ui/static/prompt-studio.html
 sdk/ui/static/runs.html
 sdk/ui/static/setup.html
 sdk/ui/static/styles.css

{devops_bot_sdk-1.4.117 → devops_bot_sdk-1.4.119}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devops-bot-sdk"
-version = "1.4.117"
+dynamic = ["version"]                 # single source of truth: sdk/__init__.py __version__
 description = "DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app"
 readme = "README.md"
 license = "LicenseRef-Proprietary"
@@ -49,6 +49,9 @@ agentos-ui = "sdk.ui.server:main"           # local web control panel (needs the
 Homepage   = "https://agentos.io"
 Repository = "https://github.com/consultancy-outfit/DevOpsBot-SDK"
 
+[tool.setuptools.dynamic]
+version = { attr = "sdk.__version__" }   # bump sdk/__init__.py → wheel + client + server all follow
+
 [tool.setuptools.packages.find]
 where = ["."]
 include = ["sdk*"]

{devops_bot_sdk-1.4.117 → devops_bot_sdk-1.4.119}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.4.117
+Version: 1.4.119
 
 Public surface:
   BackendClient.from_config()        — create client from ~/.agentos/config.toml
@@ -30,8 +30,8 @@ Rules:
   - All data egress through submit_webhook only
 """
 
-__version__ = "1.4.117"
-__author__  = "AgentOS"
+__version__ = "1.4.119"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__author__  = "AgentOS"   # sdk.client.SDK_VERSION and the UI server version all read this.
 
 from sdk.client import BackendClient
 from sdk.exceptions import (

{devops_bot_sdk-1.4.117 → devops_bot_sdk-1.4.119}/sdk/agentd.py

@@ -15,9 +15,9 @@ See docs/GUIDE_2_Development_Plan_Custom_Agents.md:
     ``sdk/run_auto.py`` (which only ever drives the Jira To-Do queue) into a
     general-purpose daemon with five components:
         1. manifest loader     — ``sdk.agents.manifest.load_agents()``
-        2. registration        — push every loaded PERSONAL manifest to the
-                                  backend (``BackendClient.register_custom_agent``)
-                                  so dashboards/routing stay in sync
+        2. (removed) registration — the daemon no longer pushes local manifests to
+                                  the backend; agents are authored in the web app
+                                  and the SDK is consume-only (local trigger/run).
         3. department pull     — fetch this user's DEPARTMENT default agents
                                   (``BackendClient.list_department_agents()``)
                                   and materialize them alongside personal
@@ -451,12 +451,11 @@ class AgentDaemon:
         department = await self._load_department_agents()
         self._manifests = personal + department
 
+        # Consume-only: the daemon no longer registers/pushes local manifests to
+        # the backend — agents are authored in the web app and written to the
+        # `agents` table. The daemon just schedules + runs them LOCALLY on trigger.
         for m in personal:
             self._schedule_if_cron(m, job_id=m.name)
-            try:
-                await self.client.register_custom_agent(m.model_dump(mode="json"))
-            except Exception as exc:  # noqa: BLE001 — registration is best-effort
-                logger.warning("agentd.register_failed agent=%s err=%s", m.name, exc)
 
         for m in department:
             # "dept:" job-id prefix avoids colliding with a personal agent

{devops_bot_sdk-1.4.117 → devops_bot_sdk-1.4.119}/sdk/agents/prompt_studio.py

@@ -92,6 +92,110 @@ def build_comments_prompt(system_prompt: str) -> str:
     return COMMENTS_INSTRUCTION.replace("__SYSTEM_PROMPT__", system_prompt.strip())
 
 
+# ── Generate: name + type + job → a full system prompt with {{variables}} ────
+# This is the claude_code engine's authoring instruction. It runs LOCALLY in the
+# SDK (run_claude_local); the AI backend calls this SDK endpoint on the VPS.
+
+GENERATE_INSTRUCTION = (
+    "You are an expert prompt engineer. Write the SYSTEM PROMPT for a reusable AI "
+    "agent, given its NAME, TYPE, and main JOB. Produce a single, self-contained "
+    "prompt that follows EXACTLY this structure and Markdown headings:\n"
+    "# Role\nYou are <NAME>, <one-line identity from the type and job>.\n"
+    "## Objective\n<one paragraph: the single outcome this agent must produce>\n"
+    "## Rules\n- <hard constraints and guardrails>\n"
+    "- Never embed secrets; reference credentials as ${ENV_VAR} placeholders.\n"
+    "## Workflow\n1. <ordered steps to do the job>\n"
+    "## Output\n<exactly what the agent returns and in what format>\n\n"
+    "VARIABLE RULE (critical): any value the user must supply AT RUN TIME must "
+    "appear in the prompt text as {{variable_name}} (double curly braces, "
+    "snake_case). Only create a variable when the job genuinely needs a per-run "
+    "input; a self-contained agent may have NONE. Do not invent placeholders for "
+    "things the agent can work out itself.\n"
+    "Return ONLY a single minified JSON object, no prose, of the exact shape:\n"
+    '{"system_prompt":"<full prompt text with \\n line breaks and {{vars}} inline>",'
+    '"variables":[{"name":"","label":"","description":"","type":"string"}]}\n'
+    "Every {{variable}} in system_prompt MUST have a matching entry in variables, "
+    "and vice-versa. If there are none, return \"variables\": [].\n\n"
+    "AGENT NAME: __NAME__\nAGENT TYPE: __TYPE__\nMAIN JOB: __JOB____CONTEXT__"
+)
+
+REGENERATE_INSTRUCTION = (
+    "You are an expert prompt engineer. REGENERATE and improve the EXISTING system "
+    "prompt below. The same rules as a fresh prompt apply: keep the exact structure "
+    "(# Role / ## Objective / ## Rules / ## Workflow / ## Output), keep "
+    "{{variable_name}} placeholders for every per-run input, and keep every "
+    "{{variable}} and the variables list in sync. Preserve the original intent and "
+    "any working variables; fix structure, clarity, missing sections, weak rules, "
+    "and vague output specs. Apply the FEEDBACK if given.\n"
+    "Return ONLY a single minified JSON object of the exact shape:\n"
+    '{"system_prompt":"...","variables":[{"name":"","label":"","description":"","type":"string"}]}\n\n'
+    "__META__FEEDBACK: __FEEDBACK__\n\nEXISTING SYSTEM PROMPT:\n```\n__PROMPT__\n```"
+)
+
+
+def build_generate_prompt(agent_name: str, agent_type: str, job: str,
+                          context: str = "") -> str:
+    ctx = f"\nADDITIONAL CONTEXT: {context.strip()}" if context and context.strip() else ""
+    return (
+        GENERATE_INSTRUCTION
+        .replace("__NAME__", (agent_name or "").strip())
+        .replace("__TYPE__", (agent_type or "").strip())
+        .replace("__JOB__", (job or "").strip())
+        .replace("__CONTEXT__", ctx)
+    )
+
+
+def build_regenerate_prompt(system_prompt: str, feedback: str = "",
+                            agent_name: str = "", agent_type: str = "",
+                            job: str = "") -> str:
+    meta_bits = []
+    if (agent_name or "").strip():
+        meta_bits.append(f"AGENT NAME: {agent_name.strip()}")
+    if (agent_type or "").strip():
+        meta_bits.append(f"AGENT TYPE: {agent_type.strip()}")
+    if (job or "").strip():
+        meta_bits.append(f"MAIN JOB: {job.strip()}")
+    meta = ("\n".join(meta_bits) + "\n") if meta_bits else ""
+    return (
+        REGENERATE_INSTRUCTION
+        .replace("__META__", meta)
+        .replace("__FEEDBACK__", (feedback or "").strip() or "(none — just improve quality)")
+        .replace("__PROMPT__", (system_prompt or "").strip())
+    )
+
+
+def parse_generation(model_output: str) -> dict:
+    """Parse a generate/regenerate model reply into ``{system_prompt, variables}``.
+
+    Placeholders present in the produced prompt are authoritative for the variable
+    LIST (so prompt ↔ schema can't drift); the model's ``variables`` array only
+    supplies each one's label/description/type. Tolerant of fences/prose.
+    """
+    from sdk.agents.prompt_vars import extract_variables
+
+    data = _extract_json(model_output)
+    system_prompt = str(data.get("system_prompt", "")).strip() if isinstance(data, dict) else ""
+
+    meta: dict[str, dict] = {}
+    for v in (data.get("variables", []) if isinstance(data, dict) else []):
+        if isinstance(v, dict) and str(v.get("name", "")).strip():
+            meta[str(v["name"]).strip()] = v
+        elif isinstance(v, str) and v.strip():
+            meta[v.strip()] = {"name": v.strip()}
+
+    variables = []
+    for name in extract_variables(system_prompt):
+        m = meta.get(name, {})
+        vtype = str(m.get("type", "string")).strip() or "string"
+        variables.append({
+            "name": name,
+            "label": str(m.get("label") or name.replace("_", " ").title()).strip(),
+            "description": str(m.get("description", "")).strip(),
+            "type": vtype,
+        })
+    return {"system_prompt": system_prompt, "variables": variables}
+
+
 def _extract_json(model_output: str) -> dict:
     text = (model_output or "").strip()
     if "```" in text:

{devops_bot_sdk-1.4.117 → devops_bot_sdk-1.4.119}/sdk/cli.py

@@ -104,10 +104,10 @@ def _print_usage() -> None:
     print("usage: agentos <configure|agent|integration|default-agents|agentd> ...")
     print()
     print("  agentos configure [--rotate]")
-    print("  agentos agent <new|add PATH|list|run NAME|chat NAME MSG|logs NAME|enable NAME|disable NAME|rm NAME>")
+    print("  agentos agent <list|run NAME|chat NAME MSG|logs NAME|enable NAME|disable NAME|rm NAME>")
     print("  agentos agent <set-key NAME KEY[=VALUE]…|keys NAME|rm-key NAME KEY…>   # persistent API keys (custom agents)")
     print("  agentos integration <add PATH|test NAME|list|rm NAME>")
-    print("  agentos default-agents <list|activate NAME|seed PATH|seed-library [SLUG]|enable NAME|disable NAME|rm NAME> [--department-id UUID]")
+    print("  agentos default-agents list [--department-id UUID]   # read-only; agents are created in the web app")
     print("  agentos agentd <start [--foreground]|status>")
 
 
@@ -117,11 +117,13 @@ def _agent_command(args: list[str]) -> None:
     verb = args[0] if args else None
     rest = args[1:]
 
-    if verb == "new":
-        _agent_new()
-        return
-    if verb == "add" and rest:
-        _agent_add(rest[0])
+    # Agent CREATION (`new` / `add`) is not owned by the SDK anymore — agents are
+    # authored in the web app and written to the backend `agents` table. The CLI is
+    # consume-only: list / run / chat / logs / enable / disable / rm / keys.
+    if verb in ("new", "add"):
+        print("`agentos agent new/add` has been removed — agents are created in the "
+              "web app now. Use `agentos agent list` to see yours and `agentos agent "
+              "run <name>` to run one.")
         return
     if verb == "list":
         _agent_list()
@@ -132,10 +134,6 @@ def _agent_command(args: list[str]) -> None:
     if verb == "chat" and len(rest) >= 2:
         _agent_chat(rest[0], " ".join(rest[1:]))
         return
-    if verb == "template":
-        from sdk.agents.prompt_template import render_system_prompt
-        print(render_system_prompt(name=(rest[0] if rest else "my-agent")))
-        return
     if verb == "logs" and rest:
         _agent_logs(rest[0])
         return
@@ -183,80 +181,6 @@ def _agent_chat(name: str, message: str) -> None:
         sys.exit(1)
 
 
-def _register_agent(manifest) -> None:
-    """Register a validated manifest with the backend — shared by `new` and `add`."""
-    from sdk.client import BackendClient
-
-    resp = asyncio.run(
-        BackendClient.from_config().register_custom_agent(manifest.model_dump(mode="json"))
-    )
-    resp = resp or {}
-    agent_id = resp.get("id") or resp.get("agent_id")
-    status = resp.get("status")
-    print(f"registered '{manifest.name}' with backend — id={agent_id} status={status}")
-
-
-def _agent_new() -> None:
-    from sdk.agents.manifest import AGENTS_DIR, AgentManifest, TriggerSpec
-
-    print("AgentOS — New Agent")
-    print("=" * 40)
-    name = input("Name: ").strip()
-    description = input("Description: ").strip()
-    engine = input("Engine [claude_code]: ").strip() or "claude_code"
-    trigger_type = input("Trigger type (schedule/ticket_label/manual/webhook): ").strip()
-
-    trigger_kwargs: dict = {"type": trigger_type}
-    if trigger_type == "schedule":
-        trigger_kwargs["cron"] = input("Cron string: ").strip()
-    elif trigger_type == "ticket_label":
-        trigger_kwargs["ticket_label"] = input("Ticket label: ").strip()
-    # manual / webhook need no extra prompt
-
-    prompt_text = input("Prompt: ").strip()
-
-    try:
-        trigger = TriggerSpec(**trigger_kwargs)
-        manifest = AgentManifest(
-            name=name,
-            description=description,
-            engine=engine,
-            trigger=trigger,
-            prompt=prompt_text,
-        )
-    except Exception as exc:  # noqa: BLE001 — surface pydantic's validation message plainly
-        print(f"error: invalid agent — {exc}")
-        sys.exit(1)
-
-    AGENTS_DIR.mkdir(parents=True, exist_ok=True)
-    dest = AGENTS_DIR / f"{manifest.name}.yaml"
-    dest.write_text(yaml.safe_dump(manifest.model_dump(mode="json"), sort_keys=False))
-    print(f"saved manifest to {dest}")
-
-    _register_agent(manifest)
-
-
-def _agent_add(path: str) -> None:
-    from sdk.agents.manifest import AGENTS_DIR, AgentManifest
-
-    src = Path(path).expanduser()
-    try:
-        raw_text = src.read_text()
-        data = yaml.safe_load(raw_text) or {}
-        manifest = AgentManifest(**data)
-    except Exception as exc:  # noqa: BLE001 — surface a clear validation/IO error
-        print(f"error: invalid agent manifest '{path}' — {exc}")
-        sys.exit(1)
-
-    AGENTS_DIR.mkdir(parents=True, exist_ok=True)
-    dest = AGENTS_DIR / f"{manifest.name}.yaml"
-    if dest.resolve() != src.resolve():
-        dest.write_text(raw_text)
-        print(f"copied manifest to {dest}")
-
-    _register_agent(manifest)
-
-
 def _agent_list() -> None:
     from sdk.agents.manifest import load_agents
     from sdk.client import BackendClient
@@ -543,201 +467,39 @@ def _default_agents_command(args: list[str]) -> None:
     if verb == "list":
         _default_agents_list(_resolve_department_id(dept_id))
         return
-    if verb == "activate" and tail:
-        _default_agents_activate(_resolve_department_id(dept_id), tail[0])
-        return
-    # ── manager verbs (team_lead+ of the department) ──
-    # Gated client-side by role (employees are refused); the backend also enforces.
-    if verb == "seed" and tail:
-        _require_department_manager(verb)
-        _default_agents_seed(_resolve_department_id(dept_id), tail)
-        return
-    if verb == "seed-library":
-        _require_department_manager(verb)
-        _default_agents_seed_library(_resolve_department_id(dept_id), tail)
-        return
-    if verb in ("enable", "disable") and tail:
-        _require_department_manager(verb)
-        _default_agents_set_status(
-            _resolve_department_id(dept_id), tail[0],
-            "active" if verb == "enable" else "disabled",
-        )
-        return
-    if verb == "rm" and tail:
-        _require_department_manager(verb)
-        _default_agents_rm(_resolve_department_id(dept_id), tail[0])
+
+    # Seeding / activating / managing department defaults is not owned by the SDK
+    # anymore — agents are authored in the web app and written to the backend
+    # `agents` table. The CLI is consume-only.
+    if verb in ("seed", "seed-library", "activate", "enable", "disable", "rm"):
+        print(f"`agentos default-agents {verb}` has been removed — department default "
+              "agents are managed in the web app now. Use `agentos default-agents list`.")
         return
 
-    print(
-        "usage: agentos default-agents "
-        "<list|activate NAME|seed PATH|seed-library [SLUG]|enable NAME|disable NAME|rm NAME> "
-        "[--department-id UUID]"
-    )
-    print("  (seed/enable/disable/rm require department-manager rights)")
+    print("usage: agentos default-agents list [--department-id UUID]")
     sys.exit(1)
 
 
-def _default_agents_seed(department_id: str, tail: list[str]) -> None:
-    """Create/update ONE department default from a manifest YAML (manager only).
-
-    Flags: --min-role-tier TIER, --sort-order N, --system.
-    """
-    import yaml
-
-    path = tail[0]
-    min_tier, sort_order, is_system = "employee", 0, False
-    i = 1
-    while i < len(tail):
-        if tail[i] == "--min-role-tier" and i + 1 < len(tail):
-            min_tier = tail[i + 1]; i += 2; continue
-        if tail[i] == "--sort-order" and i + 1 < len(tail):
-            sort_order = int(tail[i + 1]); i += 2; continue
-        if tail[i] == "--system":
-            is_system = True; i += 1; continue
-        i += 1
-
-    from sdk.agents.manifest import AgentManifest
-    from sdk.client import BackendClient
-
-    try:
-        raw = yaml.safe_load(Path(path).expanduser().read_text()) or {}
-        AgentManifest(**raw)  # validate before sending
-    except Exception as exc:  # noqa: BLE001
-        print(f"error: invalid manifest '{path}' — {exc}")
-        sys.exit(1)
-
-    payload = {
-        "manifest": raw,
-        "min_role_tier": min_tier,
-        "is_system_default": is_system,
-        "sort_order": sort_order,
-    }
-    try:
-        result = asyncio.run(
-            BackendClient.from_config().seed_department_default_agent(department_id, payload)
-        )
-    except Exception as exc:  # noqa: BLE001 — surface 403 (not a manager) clearly
-        print(f"error: {exc}")
-        sys.exit(1)
-    print(f"seeded default agent '{raw.get('name')}' into department {department_id} "
-          f"(id={result.get('agent_id')})")
-
-
-def _default_agents_seed_library(department_id: str, tail: list[str]) -> None:
-    """Seed a whole department's bundled library (manager only). SLUG defaults to 'developers'."""
-    from sdk.agents.library import load_department
-    from sdk.client import BackendClient
-
-    slug = tail[0] if tail else "developers"
-    try:
-        templates = load_department(slug)
-    except KeyError:
-        print(f"error: no library department '{slug}'")
-        sys.exit(1)
-
-    client = BackendClient.from_config()
-    ok = 0
-    for t in templates:
-        payload = {
-            "manifest": t.manifest.model_dump(mode="json"),
-            "min_role_tier": t.min_role_tier,
-            "is_system_default": t.is_system_default,
-            "sort_order": t.sort_order,
-        }
-        try:
-            asyncio.run(client.seed_department_default_agent(department_id, payload))
-            print(f"  seeded {t.manifest.name}")
-            ok += 1
-        except Exception as exc:  # noqa: BLE001
-            print(f"  FAILED {t.manifest.name}: {exc}", file=sys.stderr)
-    print(f"seeded {ok}/{len(templates)} '{slug}' agents into department {department_id}")
-
-
-def _default_agents_set_status(department_id: str, name: str, status: str) -> None:
-    from sdk.client import BackendClient
-    try:
-        asyncio.run(
-            BackendClient.from_config().update_department_default_agent(
-                department_id, name, status
-            )
-        )
-    except Exception as exc:  # noqa: BLE001
-        print(f"error: {exc}")
-        sys.exit(1)
-    print(f"default agent '{name}' set to {status}")
-
-
-def _default_agents_rm(department_id: str, name: str) -> None:
-    from sdk.client import BackendClient
-    try:
-        asyncio.run(
-            BackendClient.from_config().delete_department_default_agent(department_id, name)
-        )
-    except Exception as exc:  # noqa: BLE001
-        print(f"error: {exc}")
-        sys.exit(1)
-    print(f"deleted default agent '{name}' from department {department_id}")
-
-
 def _default_agents_list(department_id: str) -> None:
+    """List the caller's department default agents (read-only, new prompt schema)."""
     from sdk.client import BackendClient
     from sdk.exceptions import BackendFeatureMissing
 
     try:
-        agents = asyncio.run(
-            BackendClient.from_config().list_department_default_agents(department_id)
-        )
+        agents = asyncio.run(BackendClient.from_config().list_department_agents())
     except BackendFeatureMissing as exc:
-        # A 404 here means the endpoint isn't deployed — NOT that the department
-        # has no defaults. Say so, so this isn't mistaken for an empty list.
         print(f"error: {exc}")
         sys.exit(1)
     if not agents:
-        print(f"no default agents seeded for department {department_id} "
-              f"(a manager can add them with `agentos default-agents seed …`).")
+        print(f"no department default agents visible for department {department_id}.")
         return
 
-    print(f"{'NAME':<26}{'ENGINE':<13}{'TRIGGER':<14}{'MIN TIER':<11}{'STATUS'}")
+    print(f"{'NAME':<28}{'STATUS':<10}{'SKILLS':<8}SUMMARY")
     for a in agents:
-        print(
-            f"{a.get('name',''):<26}{a.get('engine',''):<13}"
-            f"{a.get('trigger_type',''):<14}{a.get('min_role_tier',''):<11}{a.get('status','')}"
-        )
-
-
-def _default_agents_activate(department_id: str, name: str) -> None:
-    """Clone a department default into the caller's custom agents + install locally."""
-    import yaml as _yaml
-
-    from sdk.agents.library import find_template
-    from sdk.agents.manifest import AGENTS_DIR, SKILLS_DIR
-    from sdk.client import BackendClient
-
-    result = asyncio.run(
-        BackendClient.from_config().activate_department_default_agent(department_id, name)
-    )
-    manifest = result.get("manifest") or {}
-
-    # Install the manifest locally so agentd / `agent run` can execute it.
-    if manifest:
-        AGENTS_DIR.mkdir(parents=True, exist_ok=True)
-        (AGENTS_DIR / f"{name}.yaml").write_text(
-            _yaml.safe_dump(manifest, sort_keys=False)
-        )
-
-    # Copy any skills the template bundles into ~/.agentos/skills.
-    template = find_template(name)
-    copied_skills: list[str] = []
-    if template and template.skills:
-        SKILLS_DIR.mkdir(parents=True, exist_ok=True)
-        for skill_name, path in template.skills.items():
-            (SKILLS_DIR / f"{skill_name}.md").write_text(path.read_text(encoding="utf-8"))
-            copied_skills.append(skill_name)
-
-    print(f"activated '{name}' — cloned to your custom agents (id={result.get('custom_agent_id')})")
-    print(f"  installed manifest to {AGENTS_DIR / (name + '.yaml')}")
-    if copied_skills:
-        print(f"  installed skills: {', '.join(copied_skills)}")
+        prompt = a.get("prompt") or {}
+        summary = (prompt.get("system_prompt") if isinstance(prompt, dict) else "") or ""
+        print(f"{a.get('name',''):<28}{a.get('status',''):<10}"
+              f"{len(a.get('skills') or []):<8}{summary.strip()[:60]}")
 
 
 # ── agentd ───────────────────────────────────────────────────────────────