loki-mode 11.17.1 → 11.17.5

package/autonomy/lib/voter-agents.sh

@@ -110,6 +110,11 @@ complexity = os.environ.get("_VA_COMPLEXITY", "standard")
 _effort_bump = {"low": "medium", "medium": "high", "high": "xhigh"}
 def _effort(base):
     return _effort_bump.get(base, base) if complexity == "complex" else base
+# Cost S7: the three base voters run on haiku for small/standard work; the
+# complex tier keeps the original opus/sonnet roster. haiku takes no effort knob.
+_lean = complexity != "complex"
+def _model(default):
+    return "haiku" if _lean else default
 prd_clause = (
     f"PRD at {prd}. Read it for ground-truth requirements."
     if prd else
@@ -118,8 +123,7 @@ prd_clause = (
 agents = {
     "requirements-verifier": {
         "description": "Verifies the iteration delivered the PRD-required behavior.",
-        "model": "opus",
-        "effort": _effort("high"),
+        "model": _model("opus"),
         "tools": ["Read", "Grep", "Bash"],
         "prompt": (
             f"You are the requirements-verifier for iteration {iter_n}. "
@@ -131,8 +135,7 @@ agents = {
     },
     "test-auditor": {
         "description": "Audits test coverage and pass status for the iteration.",
-        "model": "sonnet",
-        "effort": _effort("high"),
+        "model": _model("sonnet"),
         "tools": ["Read", "Grep", "Bash"],
         "prompt": (
             f"You are the test-auditor for iteration {iter_n}. "
@@ -144,8 +147,7 @@ agents = {
     },
     "convergence-voter": {
         "description": "Checks code churn and progress signals to judge convergence.",
-        "model": "sonnet",
-        "effort": _effort("medium"),
+        "model": _model("sonnet"),
         "tools": ["Read", "Grep", "Bash"],
         "prompt": (
             f"You are the convergence-voter for iteration {iter_n} on tier {tier}. "
@@ -156,6 +158,9 @@ agents = {
         ),
     },
 }
+if not _lean:
+    for _k, _b in (("requirements-verifier", "high"), ("test-auditor", "high"), ("convergence-voter", "medium")):
+        agents[_k]["effort"] = _effort(_b)
 print(json.dumps(agents, separators=(",", ":")))
 '
     return 0
@@ -289,6 +294,13 @@ loki_council_dispatch_agents() {
     local prompt
     prompt=$(printf 'Loki council iteration %s. Run each declared agent against the current workspace, return one finding per agent matching the provided JSON Schema. Be terse, be honest.' "$iteration")
 
+    # Cost S7: hand the council the PRD path so voters stop reporting "No PRD was
+    # provided". A missing/unreadable PRD adds nothing; voters then vote
+    # CANNOT_VALIDATE, which never approves.
+    if [ -n "$prd_path" ] && [ -r "$prd_path" ]; then
+        prompt="${prompt} PRD file: ${prd_path} (read it for ground-truth requirements)."
+    fi
+
     # Shared dispatch state (declared once, before either the SDK or claude arm).
     local response=""
     local rc=0
@@ -375,11 +387,54 @@ loki_council_dispatch_agents() {
     # (which has its own timeout + conservative defaults).
     _LOKI_PERM_ARGV=(--dangerously-skip-permissions)
     ! type _loki_claude_permission_argv >/dev/null 2>&1 || _loki_claude_permission_argv
+    # Cost S7 lean child: council role flags (no hooks/MCP/tools on the main
+    # child) and --output-format json so usage lands in the child ledger. The
+    # envelope is unwrapped back to the {findings:[...]} object below.
+    local _va_lean=() _va_lf
+    if type loki_lean_child_flags >/dev/null 2>&1; then
+        while IFS= read -r _va_lf; do
+            [ -n "$_va_lf" ] && _va_lean+=("$_va_lf")
+        done < <(loki_lean_child_flags council 2>/dev/null)
+    fi
+    local _va_fmt=()
+    if loki_claude_flag_supported "--output-format"; then
+        _va_fmt=(--output-format json)
+    fi
     response=$(timeout "${LOKI_COUNCIL_REVIEW_TIMEOUT:-600}" \
                       env CAVEMAN_DEFAULT_MODE=off claude "${_LOKI_PERM_ARGV[@]}" \
+                      ${_va_lean[@]+"${_va_lean[@]}"} \
+                      ${_va_fmt[@]+"${_va_fmt[@]}"} \
                       -p "$prompt" \
                       --agents "$agents_json" \
                       --json-schema "$schema_content" 2>"$stderr_log") || rc=$?
+    if [ "$rc" -eq 0 ] && [ -n "$response" ] && [ "${#_va_fmt[@]}" -gt 0 ]; then
+        if type loki_child_ledger_append >/dev/null 2>&1; then
+            loki_child_ledger_append council "$response" >/dev/null 2>&1 || true
+        fi
+        local _va_unwrapped _va_upy
+        if _va_upy="$(_loki_snapshot_py_tool)"; then
+            # Unwrap the CLI envelope: structured_output, else a JSON string in
+            # result. A bare {findings:[...]} object passes through unchanged. Any
+            # other shape leaves the response as-is, so the parser fails closed.
+            _va_unwrapped=$(printf '%s' "$response" | "$_va_upy" -I -S -c 'import sys; sys.path[:] = [p for p in sys.path if p not in ("", ".")]; import json
+try:
+    e = json.load(sys.stdin)
+    if isinstance(e, dict) and "findings" in e:
+        p = e
+    else:
+        p = e.get("structured_output") if isinstance(e, dict) else None
+        if not isinstance(p, dict):
+            r = e.get("result") if isinstance(e, dict) else None
+            p = json.loads(r) if isinstance(r, str) else None
+    if isinstance(p, dict):
+        sys.stdout.write(json.dumps(p))
+    else:
+        sys.exit(1)
+except Exception:
+    sys.exit(1)' 2>/dev/null) || _va_unwrapped=""
+            if [ -n "$_va_unwrapped" ]; then response="$_va_unwrapped"; fi
+        fi
+    fi
     fi  # end claude-dispatch guard (SDK path skips it, already has $response)
 
     # Shared fail-closed check for BOTH paths: any non-zero exit (claude/SDK

package/autonomy/lib/wiki-generator.py

@@ -260,8 +260,10 @@ def _data_flow_diagram(index, modules, entries):
     return "\n".join(lines)
 
 
-def _llm_prose(section, context, fallback):
-    """Get prose for a section from the LLM, or use the deterministic fallback."""
+def _llm_prose(section, context, fallback, prose=None):
+    """Prose for a section: pre-batched text if given, else the LLM, else fallback."""
+    if prose is not None:
+        return prose if prose.strip() else fallback
     prompt = (
         "You are documenting a software project for a team wiki. Write a clear, "
         "factual " + section + " section in markdown. Be concise (under 250 words). "
@@ -275,6 +277,48 @@ def _llm_prose(section, context, fallback):
     return fallback
 
 
+_BATCH_KEYS = ("architecture overview", "key modules summary", "data flow")
+_BATCH_MARK = "=== SECTION: "
+
+
+def _batch_prose(context):
+    """One LLM call for all three sections. Returns {key: prose}; missing keys
+    are absent so callers use their deterministic fallback (never a second call).
+    Output without any marker is taken as the overview only."""
+    prompt = (
+        "You are documenting a software project for a team wiki. Write three "
+        "clear, factual markdown sections, each under 250 words, in this exact "
+        "format. Each section starts on its own line with a marker line, then "
+        "prose:\n"
+        + "\n".join(_BATCH_MARK + k + " ===" for k in _BATCH_KEYS)
+        + "\nDo NOT use emojis. Do NOT use em dashes or en dashes. Do NOT "
+        "invent file paths. Output ONLY the three marked sections with prose "
+        "(no headings, no citations).\n\nPROJECT CONTEXT:\n" + context
+    )
+    out = invoke_llm(prompt, lean=True)
+    if not out or not out.strip():
+        return {}
+    found = {}
+    key = None
+    for line in out.splitlines():
+        t = line.strip()
+        if t.startswith(_BATCH_MARK) and t.endswith("==="):
+            name = t[len(_BATCH_MARK):-3].strip()
+            key = name if name in _BATCH_KEYS else None
+            if key:
+                found[key] = []
+        elif key:
+            found[key].append(line)
+    prose = {k: "\n".join(v).strip() for k, v in found.items() if "".join(v).strip()}
+    if not prose:
+        prose = {_BATCH_KEYS[0]: out.strip()}
+    missing = [k for k in _BATCH_KEYS if k not in prose]
+    if missing:
+        print("warning: wiki batched call missing sections (using fallback): "
+              + ", ".join(missing), file=sys.stderr)
+    return prose
+
+
 def _build_context(root, index, modules, entries):
     name = Path(root).name
     lines = [
@@ -296,14 +340,15 @@ def _build_context(root, index, modules, entries):
     return "\n".join(lines)
 
 
-def _section_overview(root, index, modules, entries, context):
+def _section_overview(root, index, modules, entries, context, batch=None):
     name = Path(root).name
     fallback = (
         "%s is a software project with %d indexed source files. "
         "Entry points: %s. The largest modules by size are listed below."
         % (name, len(index["files"]), ", ".join(entries) or "not detected")
     )
-    prose = _llm_prose("architecture overview", context, fallback)
+    prose = _llm_prose("architecture overview", context, fallback,
+                       None if batch is None else batch.get("architecture overview", ""))
     # Code-derived citations: the entry points + top modules (real files).
     citations = []
     for e in entries[:3]:
@@ -318,7 +363,7 @@ def _section_overview(root, index, modules, entries, context):
             "body": prose, "citations": citations, "diagram": diagram}
 
 
-def _section_modules(root, modules, context):
+def _section_modules(root, modules, context, batch=None):
     fallback_lines = ["The following modules carry most of the codebase:"]
     citations = []
     body_parts = []
@@ -326,6 +371,7 @@ def _section_modules(root, modules, context):
         "key modules summary",
         context,
         "Key modules of this project, with their primary definitions:",
+        None if batch is None else batch.get("key modules summary", ""),
     )
     body_parts.append(prose)
     body_parts.append("")
@@ -342,13 +388,14 @@ def _section_modules(root, modules, context):
             "body": "\n".join(body_parts), "citations": citations}
 
 
-def _section_data_flow(root, index, modules, entries, context):
+def _section_data_flow(root, index, modules, entries, context, batch=None):
     fallback = (
         "Execution begins at the entry point(s) (%s) and flows through the "
         "key modules. Trace a request from the entry file into the modules it "
         "imports to follow the data path." % (", ".join(entries) or "not detected")
     )
-    prose = _llm_prose("data flow", context, fallback)
+    prose = _llm_prose("data flow", context, fallback,
+                       None if batch is None else batch.get("data flow", ""))
     citations = [{"file": e, "line": 1} for e in entries[:4]]
     if not citations and index["files"]:
         citations = [{"file": index["files"][0], "line": 1}]
@@ -444,10 +491,11 @@ def main(argv=None):
     context = _build_context(root, index, modules, entries)
 
     log("generating sections (%d files indexed) ..." % len(index["files"]))
+    batch = _batch_prose(context)
     sections = [
-        _section_overview(root, index, modules, entries, context),
-        _section_modules(root, modules, context),
-        _section_data_flow(root, index, modules, entries, context),
+        _section_overview(root, index, modules, entries, context, batch),
+        _section_modules(root, modules, context, batch),
+        _section_data_flow(root, index, modules, entries, context, batch),
     ]
 
     # Enforce the grounding contract: validate every citation against disk.

package/autonomy/lib/wiki_llm.py

@@ -22,11 +22,48 @@ import subprocess
 from pathlib import Path
 
 
-def invoke_llm(prompt, timeout=120):
+_LEAN_FLAGS = (
+    ("--setting-sources", ["project"]),
+    ("--strict-mcp-config", []),
+    ("--mcp-config", ['{"mcpServers":{}}']),
+    ("--disable-slash-commands", []),
+    ("--tools=", []),
+)
+
+
+def lean_claude_flags():
+    """Flags for a one-shot text-only claude child (cost lever L1).
+
+    --bare only when an API key is present (OAuth-only hosts would fail auth);
+    otherwise narrowed setting sources. A flag the installed claude does not
+    list in --help is dropped, never passed. Returns [] when claude is absent.
+    """
+    claude = _which("claude")
+    if not claude:
+        return []
+    try:
+        help_txt = subprocess.run(
+            [claude, "--help"], capture_output=True, text=True, timeout=15,
+            stdin=subprocess.DEVNULL,
+        ).stdout
+    except (OSError, subprocess.SubprocessError):
+        return []
+    if os.environ.get("ANTHROPIC_API_KEY") and "--bare" in help_txt:
+        return ["--bare", "--tools="] if "--tools" in help_txt else ["--bare"]
+    flags = []
+    for name, vals in _LEAN_FLAGS:
+        if name.rstrip("=") in help_txt:
+            flags.append(name)
+            flags.extend(vals)
+    return flags
+
+
+def invoke_llm(prompt, timeout=120, lean=False):
     """Return the LLM completion string, or None if unavailable.
 
     Honors LOKI_WIKI_LLM_STUB for CI. Otherwise shells out to the configured
-    provider, mirroring loki docs `_docs_invoke_provider`.
+    provider, mirroring loki docs `_docs_invoke_provider`. lean=True adds the
+    lean child flags for the claude provider.
     """
     stub = os.environ.get("LOKI_WIKI_LLM_STUB")
     if stub is not None:
@@ -64,6 +101,8 @@ def invoke_llm(prompt, timeout=120):
     base = cmds.get(provider)
     if base is None or not _which(base[0]):
         return None
+    if lean and provider == "claude":
+        base = ["claude", "-p"] + lean_claude_flags() + [prompt]
     cmd = ([timeout_cmd, str(timeout)] + base) if timeout_cmd else base
     try:
         out = subprocess.run(