loki-mode 7.56.0 → 7.58.0

package/README.md

@@ -322,7 +322,7 @@ Loki's autonomy and quality loop are the product; the underlying coding CLI is s
 | Provider | Status | Autonomous Flag | Parallel Agents | Install |
 |----------|--------|:-:|:-:|---------|
 | **Claude Code** | Active (Tier 1, E2E-verified) | `--dangerously-skip-permissions` | Yes (10+) | `npm i -g @anthropic-ai/claude-code` |
-| **Codex CLI** | Experimental (Tier 3) | `--full-auto --skip-git-repo-check` | Sequential | `npm i -g @openai/codex` |
+| **Codex CLI** | Experimental (Tier 3) | `--sandbox workspace-write --skip-git-repo-check` | Sequential | `npm i -g @openai/codex` |
 | **Cline CLI** | Experimental (Tier 2) | `-y` | Sequential | `npm i -g @anthropic-ai/cline` |
 | **Aider** | Experimental (Tier 3) | `--yes-always` | Sequential | `pip install aider-chat` |
 | **Google Gemini CLI** | DEPRECATED v7.5.18 | -- | -- | Upstream deprecated; runtime removed. `LOKI_PROVIDER=gemini` exits with migration message. |

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: Autonomous spec-driven build system with a built-in trust layer. It does not call work done until it is verified (RARV-C closure loop, 8 quality gates, completion council, verified-completion evidence gate). Triggers on "Loki Mode". Takes a spec (PRD, GitHub issue, OpenAPI doc, etc.) to deployed product with minimal human intervention. Provider-agnostic. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v7.56.0
+# Loki Mode v7.58.0
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -406,4 +406,4 @@ See `CHANGELOG.md` entries [7.5.7], [7.5.8], [7.5.13] for the per-fix list and r
 
 ---
 
-**v7.56.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v7.58.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-7.56.0
+7.58.0

package/autonomy/app-runner.sh

@@ -109,11 +109,19 @@ _write_app_state() {
     method_escaped=$(_json_escape "${_APP_RUNNER_METHOD}")
     local url_escaped
     url_escaped=$(_json_escape "${_APP_RUNNER_URL}")
+    # v7.51.x: persist the identified primary web service so app-runner-managed
+    # compose runs expose the SAME field the dashboard's compose-stack discovery
+    # synthesizes (primary_service). Empty for non-compose runs (the global is
+    # only set for compose), which is additive and harmless: the field is present
+    # but blank, never absent, so consumers can read it uniformly.
+    local primary_service_escaped
+    primary_service_escaped=$(_json_escape "${_APP_RUNNER_WEB_SERVICE}")
     cat > "$tmp_file" << APPSTATE_EOF
 {
     "main_pid": ${_APP_RUNNER_PID:-0},
     "process_group": "-${_APP_RUNNER_PID:-0}",
     "method": "${method_escaped}",
+    "primary_service": "${primary_service_escaped}",
     "port": $(echo "${_APP_RUNNER_PORT:-0}" | grep -oE '^[0-9]+$' || echo 0),
     "url": "${url_escaped}",
     "started_at": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
@@ -842,6 +850,82 @@ _app_runner_compose_running_count() {
     return 0
 }
 
+# Read the RUNTIME published host port of the identified primary web service from
+# `docker compose ps` (the live mapping), as opposed to the config-declared port
+# from `docker compose config`. The config port is correct for fixed mappings
+# (e.g. ports: ["8080:80"]) but wrong when the host side is ephemeral/random
+# (ports: ["80"], published: 0, or a range), where Docker assigns the host port
+# only at run time. Parses `docker compose ps --format json` with python3 (we
+# already depend on python3 and on reading `docker compose ps` for health), and
+# echoes the published host port of the web service, or nothing on any failure
+# (caller keeps the recorded port -- no regression). Never hard-fails. Docker's
+# own published mapping is authoritative, so no curl liveness guard is needed
+# here (unlike the non-docker _app_runner_reconcile_port path).
+_app_runner_compose_published_port() {
+    local base="${1:-${TARGET_DIR:-.}}"
+    local service="${2:-}"
+    [ -n "$service" ] || return 0
+    command -v docker >/dev/null 2>&1 || return 0
+    command -v python3 >/dev/null 2>&1 || return 0
+    local compose_dir
+    compose_dir=$(_app_runner_compose_dir "$base")
+    local ps_json
+    # `docker compose ps --format json` emits either a JSON array or one JSON
+    # object per line (NDJSON) depending on the compose version; the parser below
+    # handles both shapes.
+    ps_json=$(cd "$compose_dir" && docker compose ps --format json 2>/dev/null) || return 0
+    [ -n "$ps_json" ] || return 0
+    printf '%s' "$ps_json" | LOKI_WEB_SERVICE="$service" python3 -c '
+import json, os, sys
+svc = os.environ.get("LOKI_WEB_SERVICE", "")
+raw = sys.stdin.read().strip()
+if not raw or not svc:
+    sys.exit(0)
+
+# Accept a JSON array OR newline-delimited JSON objects.
+entries = []
+try:
+    parsed = json.loads(raw)
+    entries = parsed if isinstance(parsed, list) else [parsed]
+except Exception:
+    for line in raw.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            entries.append(json.loads(line))
+        except Exception:
+            pass
+
+def published_for(entry):
+    # docker compose ps json exposes published ports under "Publishers", each a
+    # dict with "PublishedPort" (host port, 0 when not published to the host).
+    ports = []
+    for pub in (entry.get("Publishers") or []):
+        if not isinstance(pub, dict):
+            continue
+        pp = pub.get("PublishedPort")
+        try:
+            pp = int(pp)
+        except (TypeError, ValueError):
+            continue
+        if 1 <= pp <= 65535:
+            ports.append(pp)
+    return ports
+
+for entry in entries:
+    if not isinstance(entry, dict):
+        continue
+    if entry.get("Service") != svc:
+        continue
+    ports = published_for(entry)
+    if ports:
+        print(ports[0])
+        sys.exit(0)
+sys.exit(0)
+' 2>/dev/null || return 0
+}
+
 #===============================================================================
 # Lifecycle
 #===============================================================================
@@ -933,6 +1017,23 @@ app_runner_start() {
         local running_containers
         running_containers=$(_app_runner_compose_running_count "$dir")
         if [ "${running_containers:-0}" -gt 0 ]; then
+            # Reconcile the recorded port with the RUNTIME published host port of
+            # the primary web service (from `docker compose ps`), so the preview
+            # URL and state.json point at the real host port even when the host
+            # side was ephemeral/random in the compose file. The config-declared
+            # port from _detect_port is kept when no valid runtime port is found
+            # (no regression). Docker's published mapping is authoritative, so no
+            # curl liveness guard is needed (cf. _app_runner_reconcile_port).
+            if [ -n "${_APP_RUNNER_WEB_SERVICE:-}" ]; then
+                local _rt_port
+                _rt_port=$(_app_runner_compose_published_port "$dir" "$_APP_RUNNER_WEB_SERVICE")
+                if [ -n "$_rt_port" ] && [[ "$_rt_port" =~ ^[0-9]+$ ]] && \
+                   [ "$_rt_port" != "${_APP_RUNNER_PORT:-}" ]; then
+                    log_info "App Runner: reconciled compose port ${_APP_RUNNER_PORT:-?} -> $_rt_port (runtime published mapping for service $_APP_RUNNER_WEB_SERVICE)"
+                    _APP_RUNNER_PORT="$_rt_port"
+                    _APP_RUNNER_URL="http://localhost:${_rt_port}"
+                fi
+            fi
             _write_app_state "running"
             log_info "App Runner: docker compose started ($running_containers container(s) running)"
             return 0

package/autonomy/lib/prd-enrich.sh

@@ -0,0 +1,437 @@
+#!/usr/bin/env bash
+# prd-enrich.sh -- LLM enrichment post-pass for PRD-parsed task queues.
+#
+# Problem: the python heredoc in run.sh::populate_prd_queue has no model
+# access (json/re/os/sys only). When a PRD section has no body text, the
+# deterministic parser falls back to description == title and a templated
+# constant user_story. The dashboard task modal then shows placeholder junk.
+#
+# This module runs AFTER pending.json is written. For source=="prd" tasks
+# that still carry a stub (description == title, or the templated user_story
+# constant), it builds ONE batched provider call that passes the task titles
+# plus the full PRD context and asks for a JSON array of enriched fields. The
+# response is merged back into pending.json atomically (temp file + mv),
+# preserving the on-disk format (bare list or {"tasks":[...]} wrapper).
+#
+# GRACEFUL FALLBACK: if the provider is unavailable (non-claude provider,
+# PROVIDER_DEGRADED, claude binary absent, the call times out / fails, or the
+# JSON cannot be parsed) the function leaves the deterministic output intact
+# and returns 0. Queue population is NEVER blocked on the LLM.
+#
+# Contract:
+#   loki_prd_enrich <pending_json_path> <prd_file_path>
+#     - returns 0 always (best-effort enrichment; never fails the caller)
+#     - mutates <pending_json_path> in place only on a successful enrichment
+#
+# Indirection (for testability): the actual model call goes through
+#   _loki_prd_enrich_invoke <prompt>   (echoes the raw model response)
+# Tests stub this function to return a fixed JSON array without a real model.
+#
+# No emojis. No em dashes. bash 3.2 safe. Honors `set -uo pipefail`.
+
+# Bound the batched call so a huge PRD or task list cannot run away.
+: "${LOKI_PRD_ENRICH_TIMEOUT:=120}"      # seconds for the single model call
+: "${LOKI_PRD_ENRICH_MAX_TASKS:=40}"     # cap tasks sent in one batch
+: "${LOKI_PRD_ENRICH_MAX_PRD_CHARS:=12000}"  # cap PRD context length
+
+# The single model-call primitive. Kept as its own function so:
+#   1. it is the ONE place that touches the provider, and
+#   2. tests can override it to return canned JSON.
+# Calls `claude -p` directly (not the provider_invoke shell function) because
+# `timeout` needs a real command, not a function. Mirrors the in-tree
+# precedent at autonomy/lib/voter-agents.sh:259.
+_loki_prd_enrich_invoke() {
+    local prompt="$1"
+    command -v claude >/dev/null 2>&1 || return 1
+    local rc=0
+    local out=""
+    if command -v timeout >/dev/null 2>&1; then
+        out=$(CAVEMAN_DEFAULT_MODE=off timeout "${LOKI_PRD_ENRICH_TIMEOUT}" \
+                  claude --dangerously-skip-permissions -p "$prompt" 2>/dev/null) || rc=$?
+    else
+        # No coreutils timeout (e.g. bare macOS). Run without it; the model
+        # call is a one-shot and the caller still tolerates failure.
+        out=$(CAVEMAN_DEFAULT_MODE=off \
+                  claude --dangerously-skip-permissions -p "$prompt" 2>/dev/null) || rc=$?
+    fi
+    [ "$rc" -ne 0 ] && return 1
+    [ -z "$out" ] && return 1
+    printf '%s' "$out"
+    return 0
+}
+
+# Decide whether enrichment should even be attempted. Returns 0 (attempt)
+# only when the active provider is claude and not in degraded mode.
+_loki_prd_enrich_provider_ok() {
+    [ "${LOKI_PROVIDER:-claude}" = "claude" ] || return 1
+    [ "${PROVIDER_DEGRADED:-false}" != "true" ] || return 1
+    command -v claude >/dev/null 2>&1 || return 1
+    return 0
+}
+
+# Deterministic (no-model) enrichment. Replaces the templated user_story
+# constant (run.sh:13614) with a content-derived one, varying by the task's
+# own body text. Description is left to Bug-A (already real where body exists).
+# Pure python (json/re/os only): safe on any provider, offline, or air-gapped.
+# Always atomic (temp + replace), best-effort, returns 0.
+_loki_prd_enrich_deterministic() {
+    local pending_path="${1:-}"
+    [ -n "$pending_path" ] && [ -f "$pending_path" ] || return 0
+    LOKI_PE_PENDING="$pending_path" python3 << 'PE_DET_EOF'
+import json, os, re, sys, tempfile
+
+pending = os.environ.get("LOKI_PE_PENDING", "")
+if not pending or not os.path.isfile(pending):
+    sys.exit(0)
+
+try:
+    with open(pending, "r") as f:
+        data = json.load(f)
+except Exception:
+    sys.exit(0)
+
+if isinstance(data, list):
+    tasks = data
+    wrapper = None
+elif isinstance(data, dict):
+    tasks = data.get("tasks", [])
+    wrapper = data
+else:
+    sys.exit(0)
+
+def is_stub_user_story(s):
+    return isinstance(s, str) and s.endswith("so that the product delivers its core value.")
+
+def first_sentence(text, limit=160):
+    text = re.sub(r"\s+", " ", (text or "").strip())
+    if not text:
+        return ""
+    m = re.search(r"(.+?[.!?])(\s|$)", text)
+    s = m.group(1) if m else text
+    return s[:limit].strip()
+
+changed = 0
+for t in tasks:
+    if not isinstance(t, dict):
+        continue
+    if t.get("source") != "prd":
+        continue
+    if not is_stub_user_story(t.get("user_story")):
+        continue
+    title = (t.get("title") or "").strip()
+    if not title:
+        continue
+    # Derive a benefit clause from the section body (description minus the
+    # leading title line), falling back to the first acceptance criterion.
+    desc = (t.get("description") or "").strip()
+    body = desc
+    if body.startswith(title):
+        body = body[len(title):].strip()
+    benefit = first_sentence(body)
+    if not benefit:
+        ac = t.get("acceptance_criteria")
+        if isinstance(ac, list) and ac:
+            benefit = first_sentence(str(ac[0]))
+    cap = title[:1].lower() + title[1:] if title else title
+    if benefit:
+        t["user_story"] = "As a user, I want %s, so that %s" % (
+            cap.rstrip("."),
+            benefit[:1].lower() + benefit[1:] if benefit else benefit,
+        )
+        if not t["user_story"].endswith("."):
+            t["user_story"] += "."
+    else:
+        # No body text at all: still drop the generic constant for a
+        # capability-specific phrasing.
+        t["user_story"] = "As a user, I want %s, so that I can use this capability." % cap.rstrip(".")
+    changed += 1
+
+if changed == 0:
+    sys.exit(0)
+
+if wrapper is not None:
+    wrapper["tasks"] = tasks
+    output = wrapper
+else:
+    output = tasks
+
+d = os.path.dirname(os.path.abspath(pending)) or "."
+fd, tmp = tempfile.mkstemp(dir=d, prefix=".pending-det-", suffix=".json")
+try:
+    with os.fdopen(fd, "w") as f:
+        json.dump(output, f, indent=2)
+    os.replace(tmp, pending)
+except Exception:
+    try:
+        os.unlink(tmp)
+    except Exception:
+        pass
+    sys.exit(0)
+PE_DET_EOF
+    return 0
+}
+
+loki_prd_enrich() {
+    local pending_path="${1:-}"
+    local prd_path="${2:-}"
+
+    [ -n "$pending_path" ] && [ -f "$pending_path" ] || return 0
+    [ -n "$prd_path" ] && [ -f "$prd_path" ] || return 0
+
+    # Provider gate. On a degraded / non-claude / no-binary provider we still
+    # improve tasks deterministically (content-derived user_story) so even
+    # offline users get informative tasks, then return without a model call.
+    if ! _loki_prd_enrich_provider_ok; then
+        _loki_prd_enrich_deterministic "$pending_path"
+        return 0
+    fi
+
+    # Stage 1 (python): identify stub prd tasks and emit a compact JSON
+    # payload {tasks:[{id,title}], prd:"..."} for the model. If there is
+    # nothing to enrich, emit empty and we return early.
+    local payload
+    payload=$(LOKI_PE_PENDING="$pending_path" LOKI_PE_PRD="$prd_path" \
+              LOKI_PE_MAX_TASKS="${LOKI_PRD_ENRICH_MAX_TASKS}" \
+              LOKI_PE_MAX_PRD="${LOKI_PRD_ENRICH_MAX_PRD_CHARS}" \
+              python3 << 'PE_PAYLOAD_EOF'
+import json, os, sys
+
+pending = os.environ.get("LOKI_PE_PENDING", "")
+prd = os.environ.get("LOKI_PE_PRD", "")
+max_tasks = int(os.environ.get("LOKI_PE_MAX_TASKS", "40") or "40")
+max_prd = int(os.environ.get("LOKI_PE_MAX_PRD", "12000") or "12000")
+
+try:
+    with open(pending, "r") as f:
+        data = json.load(f)
+except Exception:
+    sys.exit(0)
+
+if isinstance(data, list):
+    tasks = data
+elif isinstance(data, dict):
+    tasks = data.get("tasks", [])
+else:
+    sys.exit(0)
+
+# Templated constant produced by run.sh:13614 (the sentinel we replace).
+def is_stub_user_story(s):
+    if not isinstance(s, str):
+        return False
+    return s.endswith("so that the product delivers its core value.")
+
+stubs = []
+for t in tasks:
+    if not isinstance(t, dict):
+        continue
+    if t.get("source") != "prd":
+        continue
+    title = (t.get("title") or "").strip()
+    desc = (t.get("description") or "").strip()
+    us = t.get("user_story") or ""
+    if not title:
+        continue
+    # Stub = description is just the title, OR the templated user_story.
+    if desc == title or is_stub_user_story(us):
+        stubs.append({"id": t.get("id"), "title": title})
+
+if not stubs:
+    sys.exit(0)
+
+stubs = stubs[:max_tasks]
+
+try:
+    with open(prd, "r", errors="replace") as f:
+        prd_text = f.read()
+except Exception:
+    prd_text = ""
+prd_text = prd_text[:max_prd]
+
+print(json.dumps({"tasks": stubs, "prd": prd_text}))
+PE_PAYLOAD_EOF
+)
+
+    # Nothing to enrich, or payload generation failed -> keep deterministic.
+    [ -n "$payload" ] || return 0
+
+    # Stage 2: build the batched prompt and call the model.
+    local task_lines prd_context
+    task_lines=$(printf '%s' "$payload" | python3 -c '
+import json, sys
+try:
+    d = json.load(sys.stdin)
+except Exception:
+    sys.exit(0)
+for t in d.get("tasks", []):
+    print("- id=%s | %s" % (t.get("id"), t.get("title")))
+' 2>/dev/null)
+    prd_context=$(printf '%s' "$payload" | python3 -c '
+import json, sys
+try:
+    d = json.load(sys.stdin)
+except Exception:
+    sys.exit(0)
+sys.stdout.write(d.get("prd", ""))
+' 2>/dev/null)
+
+    [ -n "$task_lines" ] || return 0
+
+    local prompt
+    prompt=$(cat <<PE_PROMPT_EOF
+You are enriching a software task backlog so each task carries real, useful
+information for an engineer. Below is the source PRD followed by a list of
+tasks (each with an id and title) whose descriptions are currently empty or
+generic. For EACH task id, produce informative fields grounded in the PRD.
+
+Return ONLY a JSON array (no prose, no markdown fences). Each element:
+{
+  "id": "<the exact task id given>",
+  "description": "<2-4 concrete sentences describing what to build and why, grounded in the PRD>",
+  "acceptance_criteria": ["<concrete, testable bullet>", "..."],
+  "user_story": "As <specific persona>, I want <capability>, so that <real benefit>."
+}
+Rules: use only ids from the list. Keep descriptions specific to the PRD, not
+boilerplate. 3-6 acceptance_criteria per task. No emojis. No em dashes.
+
+=== PRD ===
+${prd_context}
+
+=== TASKS TO ENRICH ===
+${task_lines}
+PE_PROMPT_EOF
+)
+
+    local response
+    # Model call failed (offline / timeout / non-zero) -> fall back to the
+    # deterministic content-derived enrichment instead of leaving the stub.
+    response=$(_loki_prd_enrich_invoke "$prompt") || { _loki_prd_enrich_deterministic "$pending_path"; return 0; }
+    if [ -z "$response" ]; then
+        _loki_prd_enrich_deterministic "$pending_path"
+        return 0
+    fi
+
+    # Stage 3 (python): parse the model JSON defensively and merge into
+    # pending.json, preserving on-disk format. Write to a temp file and mv
+    # for atomicity. Any failure leaves the original file untouched.
+    LOKI_PE_PENDING="$pending_path" LOKI_PE_RESP="$response" python3 << 'PE_MERGE_EOF'
+import json, os, sys, tempfile
+
+pending = os.environ.get("LOKI_PE_PENDING", "")
+resp = os.environ.get("LOKI_PE_RESP", "")
+
+if not pending or not os.path.isfile(pending):
+    sys.exit(0)
+
+# Defensive parse: slice first '[' to last ']' to tolerate prose/fences.
+def parse_array(text):
+    try:
+        return json.loads(text)
+    except Exception:
+        pass
+    start = text.find("[")
+    end = text.rfind("]")
+    if start == -1 or end == -1 or end <= start:
+        return None
+    try:
+        v = json.loads(text[start:end + 1])
+        return v
+    except Exception:
+        return None
+
+enriched = parse_array(resp)
+if not isinstance(enriched, list) or not enriched:
+    sys.exit(0)
+
+# Index enrichment by id.
+by_id = {}
+for e in enriched:
+    if not isinstance(e, dict):
+        continue
+    eid = e.get("id")
+    if eid:
+        by_id[eid] = e
+
+if not by_id:
+    sys.exit(0)
+
+try:
+    with open(pending, "r") as f:
+        data = json.load(f)
+except Exception:
+    sys.exit(0)
+
+if isinstance(data, list):
+    tasks = data
+    wrapper = None
+elif isinstance(data, dict):
+    tasks = data.get("tasks", [])
+    wrapper = data
+else:
+    sys.exit(0)
+
+def clean_str(v):
+    if not isinstance(v, str):
+        return None
+    v = v.strip()
+    return v or None
+
+merged = 0
+for t in tasks:
+    if not isinstance(t, dict):
+        continue
+    if t.get("source") != "prd":
+        continue
+    tid = t.get("id")
+    e = by_id.get(tid)
+    if not e:
+        continue
+    title = (t.get("title") or "").strip()
+    # description: overwrite only with a real, non-title value.
+    d = clean_str(e.get("description"))
+    if d and d != title:
+        t["description"] = d
+    # acceptance_criteria: accept a non-empty list of non-empty strings.
+    ac = e.get("acceptance_criteria")
+    if isinstance(ac, list):
+        ac = [c.strip() for c in ac if isinstance(c, str) and c.strip()]
+        if ac:
+            t["acceptance_criteria"] = ac[:10]
+    # user_story: overwrite with a real "As ..., I want ..., so that ...".
+    us = clean_str(e.get("user_story"))
+    if us:
+        t["user_story"] = us
+    merged += 1
+
+if merged == 0:
+    sys.exit(0)
+
+if wrapper is not None:
+    wrapper["tasks"] = tasks
+    output = wrapper
+else:
+    output = tasks
+
+# Atomic write: temp file in the same dir, then mv.
+d = os.path.dirname(os.path.abspath(pending)) or "."
+fd, tmp = tempfile.mkstemp(dir=d, prefix=".pending-enrich-", suffix=".json")
+try:
+    with os.fdopen(fd, "w") as f:
+        json.dump(output, f, indent=2)
+    os.replace(tmp, pending)
+except Exception:
+    try:
+        os.unlink(tmp)
+    except Exception:
+        pass
+    sys.exit(0)
+
+print("Enriched %d PRD task(s) via LLM" % merged, file=sys.stderr)
+PE_MERGE_EOF
+
+    # Final deterministic sweep: any task the model did not cover (parse fail,
+    # missing id) still carries the templated user_story constant. Replace it
+    # with a content-derived one so no task is left with placeholder text.
+    _loki_prd_enrich_deterministic "$pending_path"
+
+    return 0
+}