loki-mode 6.83.0 → 7.0.1

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: Multi-agent autonomous startup system. Triggers on "Loki Mode". Takes PRD to deployed product with minimal human intervention. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v6.83.0
+# Loki Mode v7.0.1
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -181,23 +181,36 @@ GROWTH ──[continuous improvement loop]──> GROWTH
 
 ## Invocation
 
+**Unified entry point (v6.84.0):** `loki start` auto-detects whether the input is a PRD file, an issue URL, or an issue number. No need to pick between `loki start` and `loki run` -- the single command handles all cases.
+
 ```bash
 # Standard mode (Claude - full features)
 claude --dangerously-skip-permissions
 # Then say: "Loki Mode" or "Loki Mode with PRD at path/to/prd.md" (or .json)
 
-# With provider selection (supports .md and .json PRDs)
-./autonomy/run.sh --provider claude ./prd.md   # Default, full features
-./autonomy/run.sh --provider codex ./prd.json  # GPT-5.3 Codex, degraded mode
-./autonomy/run.sh --provider gemini ./prd.md   # Gemini 3 Pro, degraded mode
-./autonomy/run.sh --provider cline ./prd.md    # Cline CLI, degraded mode
-./autonomy/run.sh --provider aider ./prd.md    # Aider (18+ providers), degraded mode
+# Unified `loki start` -- one command, auto-detected mode
+loki start                                   # no arg: analyze current dir, auto-generate PRD
+loki start ./prd.md                          # PRD mode (.md/.json/.txt/.yaml)
+loki start https://github.com/o/r/issues/42  # ISSUE mode (GitHub URL)
+loki start 123                               # ISSUE mode (GitHub issue in current repo)
+loki start PROJ-456                          # ISSUE mode (Jira)
+loki start owner/repo#789                    # ISSUE mode (GitHub specific repo)
+loki start --prd ./prd.md                    # Explicit PRD mode (overrides detection)
+loki start --issue 123                       # Explicit issue mode (overrides detection)
 
-# Or via CLI wrapper
-loki start --provider codex ./prd.md
+# With provider selection (supports .md and .json PRDs)
+loki start --provider claude ./prd.md        # Default, full features
+loki start --provider codex ./prd.json       # GPT-5.3 Codex, degraded mode
+loki start --provider gemini ./prd.md        # Gemini 3 Pro, degraded mode
+loki start --provider cline ./prd.md         # Cline CLI, degraded mode
+loki start --provider aider ./prd.md         # Aider (18+ providers), degraded mode
 
 # Parallel mode (git worktrees, Claude only)
-./autonomy/run.sh --parallel ./prd.md
+loki start ./prd.md --parallel
+loki start 123 --ship                        # Issue -> PR -> auto-merge
+
+# Legacy: `loki run <issue>` still works but prints a deprecation notice.
+# It is an alias for `loki start <issue>` and will be removed in a future major.
 ```
 
 **Provider capabilities:**
@@ -258,6 +271,44 @@ Auto-detected or force with `LOKI_COMPLEXITY`:
 
 ---
 
+## Managed Agents Integration (v7.0.1)
+
+Opt-in integration with Claude Managed Agents (released Apr 2026). Gives
+Loki cross-project audited memory and real multiagent councils. Features
+are BAKED INTO existing RARV-C and council flows -- no new commands to
+learn.
+
+**All flags default false.** Default behavior is identical to v7.0.1.
+
+| Flag | Purpose | Status |
+|------|---------|--------|
+| `LOKI_MANAGED_AGENTS` | Parent gate; required for every managed path | stable |
+| `LOKI_MANAGED_MEMORY` | REASON augment + REFLECT shadow-write from `.loki/memory/` to Managed Agents store | stable (tested with fakes) |
+| `LOKI_MANAGED_MEMORY_HYDRATE` | Session-boot pull of semantic patterns + skills from store | stable (tested with fakes) |
+| `LOKI_EXPERIMENTAL_MANAGED_AGENTS` | Umbrella for multiagent session path | RESEARCH PREVIEW |
+| `LOKI_EXPERIMENTAL_MANAGED_REVIEW` | Managed code-review council via `callable_agents` | RESEARCH PREVIEW |
+| `LOKI_EXPERIMENTAL_MANAGED_COUNCIL` | Managed completion council via `callable_agents` | RESEARCH PREVIEW |
+
+Fail-fast: child-on + parent-off exits 2 with clear error. API
+unreachable falls back to local path with a `managed_agents_fallback`
+event to `.loki/managed/events.ndjson`. No retry storm.
+
+**Flip-on order (recommended):**
+1. `LOKI_MANAGED_AGENTS=true LOKI_MANAGED_MEMORY=true` (memory mirror).
+2. Add `LOKI_MANAGED_MEMORY_HYDRATE=true` after one-week soak.
+3. Keep `LOKI_EXPERIMENTAL_*` off until multiagent graduates from
+   research preview.
+
+**NOT TESTED against live Anthropic API.** Automated CI uses
+`memory/managed_memory/fakes.py`. Beta header pinned to
+`managed-agents-2026-04-01`. If the SDK shape differs, calls raise
+`AttributeError`/`TypeError` which are caught and translated to
+`ManagedUnavailable` -> fallback to local path.
+
+See `skills/memory.md` for the full integration guide.
+
+---
+
 ## Planned Features
 
 The following features are documented in skill modules but not yet fully automated:
@@ -269,4 +320,4 @@ The following features are documented in skill modules but not yet fully automat
 | Quality gates 3-reviewer system | Implemented (v5.35.0) | 5 specialist reviewers in `skills/quality-gates.md`; execution in run.sh |
 | Benchmarks (HumanEval, SWE-bench) | Infrastructure only | Runner scripts and datasets exist in `benchmarks/`; no published results |
 
-**v6.83.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v7.0.1 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-6.83.0
+7.0.1

package/agents/managed_registry.py

@@ -0,0 +1,246 @@
+"""
+Loki Managed Agents - Agent materialization registry (Phase 2 foundation).
+
+Lazy registry that maps Loki pool names (as declared in agents/types.json)
+to Managed Agent IDs minted via `client.beta.agents.create(...)`. Created
+IDs are cached on disk at .loki/managed/agent_ids.json so subsequent
+iterations re-use the same agent.
+
+Design:
+    - LAZY ONLY: no network calls at import time, no calls on Loki
+      startup. The first call to materialize_agent(pool_name) triggers
+      the single create-or-fetch round trip for that pool.
+    - Uses the shared managed-agents client from providers.managed so
+      the anthropic SDK stays imported from the two allowed files only.
+    - agents/types.json is the single source of truth for pool names,
+      personas, and capabilities. This registry treats the pool entry
+      as opaque and forwards the persona as the agent's system prompt.
+    - Writes to .loki/managed/agent_ids.json are atomic (write-to-temp
+      then rename) so a crash mid-write does not corrupt the cache.
+
+Not wired into autonomy/run.sh directly. Consumers go through
+providers.managed.resolve_agent_ids(pool_names).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+import threading
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+# Single import site for the event emitter -- shared with memory/managed_memory.
+from memory.managed_memory.events import emit_managed_event
+
+
+_CACHE_FILE_REL = ".loki/managed/agent_ids.json"
+_TYPES_FILE_REL = "agents/types.json"
+
+_cache_lock = threading.Lock()
+
+
+# ---------------------------------------------------------------------------
+# Paths
+# ---------------------------------------------------------------------------
+
+
+def _target_dir() -> Path:
+    base = os.environ.get("LOKI_TARGET_DIR") or os.getcwd()
+    return Path(base)
+
+
+def _cache_path() -> Path:
+    return _target_dir() / _CACHE_FILE_REL
+
+
+def _types_path() -> Path:
+    # types.json lives next to this module in the repo layout. The repo
+    # root is the parent of agents/ for the normal install.
+    here = Path(__file__).resolve().parent
+    local = here / "types.json"
+    if local.exists():
+        return local
+    # Fallback to target_dir for relocated installs.
+    return _target_dir() / _TYPES_FILE_REL
+
+
+# ---------------------------------------------------------------------------
+# Cache I/O
+# ---------------------------------------------------------------------------
+
+
+def _load_cache() -> Dict[str, str]:
+    """Load pool_name -> agent_id mapping from disk. {} on any error."""
+    p = _cache_path()
+    if not p.exists():
+        return {}
+    try:
+        with open(p, "r", encoding="utf-8") as f:
+            data = json.load(f)
+    except (OSError, json.JSONDecodeError):
+        return {}
+    if not isinstance(data, dict):
+        return {}
+    return {k: v for k, v in data.items() if isinstance(k, str) and isinstance(v, str)}
+
+
+def _save_cache(cache: Dict[str, str]) -> None:
+    """Atomic write of the cache dict to disk."""
+    p = _cache_path()
+    p.parent.mkdir(parents=True, exist_ok=True)
+    # Use a named temp file in the same directory so os.replace is atomic.
+    tmp_fd, tmp_name = tempfile.mkstemp(
+        prefix=".agent_ids-", suffix=".json.tmp", dir=str(p.parent)
+    )
+    try:
+        with os.fdopen(tmp_fd, "w", encoding="utf-8") as f:
+            json.dump(cache, f, indent=2, sort_keys=True)
+        os.replace(tmp_name, p)
+    except OSError as e:
+        # Best-effort cleanup; swallow the error so the caller can
+        # proceed -- a stale cache is recoverable, a raise here would
+        # break the RARV loop.
+        try:
+            os.unlink(tmp_name)
+        except OSError:
+            pass
+        emit_managed_event(
+            "managed_agents_fallback",
+            {
+                "op": "registry_save_cache",
+                "reason": "cache_write_failed",
+                "detail": str(e),
+            },
+        )
+
+
+# ---------------------------------------------------------------------------
+# types.json lookup
+# ---------------------------------------------------------------------------
+
+
+def _load_types() -> List[Dict[str, Any]]:
+    try:
+        with open(_types_path(), "r", encoding="utf-8") as f:
+            data = json.load(f)
+    except (OSError, json.JSONDecodeError):
+        return []
+    if not isinstance(data, list):
+        return []
+    return [d for d in data if isinstance(d, dict)]
+
+
+def _lookup_type(pool_name: str) -> Optional[Dict[str, Any]]:
+    for entry in _load_types():
+        if entry.get("type") == pool_name or entry.get("name") == pool_name:
+            return entry
+    return None
+
+
+def _persona_for(pool_name: str) -> str:
+    entry = _lookup_type(pool_name) or {}
+    persona = entry.get("persona") or ""
+    cap = entry.get("capabilities") or ""
+    if persona and cap:
+        return f"{persona}\n\nCapabilities: {cap}"
+    return persona or f"Loki pool agent: {pool_name}"
+
+
+def _display_name_for(pool_name: str) -> str:
+    entry = _lookup_type(pool_name) or {}
+    return entry.get("name") or pool_name
+
+
+# ---------------------------------------------------------------------------
+# Materialization via the anthropic SDK
+# ---------------------------------------------------------------------------
+
+
+def _call_create_agent(pool_name: str) -> str:
+    """
+    Invoke the anthropic beta agents.create endpoint for `pool_name`.
+
+    Raises RuntimeError on any SDK shape / network / auth error. Callers
+    translate to a fallback-capable flow.
+    """
+    # Deferred import to keep the module SDK-free at import time.
+    from providers.managed import _get_client  # local import of shared client
+
+    client = _get_client()
+    beta = getattr(client, "beta", None)
+    if beta is None:
+        raise RuntimeError("anthropic SDK missing `beta` namespace")
+
+    agents_ns = getattr(beta, "agents", None)
+    if agents_ns is None or not hasattr(agents_ns, "create"):
+        raise RuntimeError("anthropic.beta.agents.create not available in SDK")
+
+    persona = _persona_for(pool_name)
+    display_name = _display_name_for(pool_name)
+
+    try:
+        created = agents_ns.create(
+            name=display_name,
+            system=persona,
+            metadata={"loki_pool": pool_name},
+        )
+    except (AttributeError, TypeError) as e:
+        raise RuntimeError(f"agents.create shape error: {e}")
+    except Exception as e:
+        raise RuntimeError(f"agents.create failed for {pool_name!r}: {e}")
+
+    agent_id = (
+        getattr(created, "id", None)
+        or (created.get("id") if isinstance(created, dict) else None)
+        or getattr(created, "agent_id", None)
+    )
+    if not agent_id:
+        raise RuntimeError(
+            f"agents.create returned no id for {pool_name!r}: {created!r}"
+        )
+    return str(agent_id)
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def materialize_agent(pool_name: str) -> str:
+    """
+    Return a Managed Agent ID for the given pool name.
+
+    Cache lookup first. On miss, call `client.beta.agents.create(...)`
+    with the persona from agents/types.json and persist the resulting
+    ID to .loki/managed/agent_ids.json.
+
+    Raises RuntimeError on failure (no silent fallback; the caller in
+    providers.managed.resolve_agent_ids translates into ManagedUnavailable).
+    """
+    if not pool_name or not isinstance(pool_name, str):
+        raise RuntimeError(f"invalid pool_name: {pool_name!r}")
+
+    with _cache_lock:
+        cache = _load_cache()
+        cached = cache.get(pool_name)
+        if cached:
+            return cached
+
+        # Create it. Anything that goes wrong raises.
+        agent_id = _call_create_agent(pool_name)
+        cache[pool_name] = agent_id
+        _save_cache(cache)
+        emit_managed_event(
+            "managed_agent_materialized",
+            {"op": "materialize_agent", "pool_name": pool_name, "agent_id": agent_id},
+        )
+        return agent_id
+
+
+__all__ = [
+    "materialize_agent",
+    "_load_cache",
+    "_save_cache",
+]