loki-mode 7.129.5 → 8.0.0

package/autonomy/lib/dependency-setup.sh

@@ -0,0 +1,205 @@
+#!/usr/bin/env bash
+
+# Prepare deterministic Node dependencies for Loki-owned verification gates.
+# The model may produce a valid app without installing host dependencies because
+# hosted previews use an isolated Docker volume. Verification must not mistake a
+# missing host node_modules directory for an application defect.
+
+loki_dependency_input_sha256() {
+    local tree="$1"
+    python3 - "$tree/package.json" "$tree/package-lock.json" <<'PYEOF'
+import hashlib
+import sys
+
+digest = hashlib.sha256()
+for path in sys.argv[1:]:
+    with open(path, "rb") as handle:
+        digest.update(handle.read())
+        digest.update(b"\0")
+print(digest.hexdigest())
+PYEOF
+}
+
+loki_dependency_install_fingerprint() {
+    local tree="$1"
+    python3 - "$tree" <<'PYEOF'
+import hashlib
+import json
+import os
+import pathlib
+import subprocess
+import sys
+
+tree = pathlib.Path(sys.argv[1])
+hidden_lock = tree / "node_modules" / ".package-lock.json"
+try:
+    raw = hidden_lock.read_bytes()
+    packages = json.loads(raw).get("packages")
+    if not isinstance(packages, dict):
+        raise ValueError("missing packages map")
+    for name in packages:
+        path = pathlib.PurePosixPath(name)
+        if not name or path.is_absolute() or path.parts[0] != "node_modules" \
+                or any(part in ("", ".", "..") for part in path.parts):
+            raise ValueError("invalid installed package path")
+        if not os.path.lexists(tree.joinpath(*path.parts)):
+            raise ValueError("missing installed package")
+    print("lock:" + hashlib.sha256(raw).hexdigest())
+except FileNotFoundError:
+    result = subprocess.run(
+        ["npm", "ls", "--all", "--json"], cwd=tree,
+        stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, check=False,
+    )
+    if result.returncode:
+        raise SystemExit(1)
+    listing = json.loads(result.stdout)
+    canonical = json.dumps(listing, sort_keys=True, separators=(",", ":")).encode()
+    print("tree:" + hashlib.sha256(canonical).hexdigest())
+except (OSError, TypeError, ValueError, json.JSONDecodeError):
+    raise SystemExit(1)
+PYEOF
+}
+
+loki_publish_dependency_marker() {
+    local marker_file="$1" input_sha="$2" install_sha="$3" temporary
+    temporary="$(mktemp "${marker_file}.tmp.XXXXXX")" || return 1
+    if ! printf 'v1 %s %s\n' "$input_sha" "$install_sha" > "$temporary" \
+        || ! mv -f "$temporary" "$marker_file"; then
+        rm -f "$temporary" 2>/dev/null || true
+        return 1
+    fi
+}
+
+loki_write_dependency_setup_result() {
+    local output="$1" status="$2" command="$3" exit_code="$4" input_sha="$5"
+    _LOKI_DEP_OUT="$output" \
+    _LOKI_DEP_STATUS="$status" \
+    _LOKI_DEP_COMMAND="$command" \
+    _LOKI_DEP_EXIT="$exit_code" \
+    _LOKI_DEP_SHA="$input_sha" \
+    python3 - <<'PYEOF'
+import json
+import os
+import tempfile
+from datetime import datetime, timezone
+
+target = os.environ["_LOKI_DEP_OUT"]
+raw_exit = os.environ.get("_LOKI_DEP_EXIT", "")
+record = {
+    "timestamp": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+    "status": os.environ.get("_LOKI_DEP_STATUS", "failed"),
+    "command": os.environ.get("_LOKI_DEP_COMMAND") or None,
+    "exit_code": int(raw_exit) if raw_exit.isdigit() else None,
+    "input_sha256": os.environ.get("_LOKI_DEP_SHA") or None,
+    "lifecycle_scripts": "disabled",
+}
+directory = os.path.dirname(target)
+os.makedirs(directory, exist_ok=True)
+fd, temporary = tempfile.mkstemp(dir=directory, suffix=".json")
+with os.fdopen(fd, "w", encoding="utf-8") as handle:
+    json.dump(record, handle, indent=2, sort_keys=True)
+    handle.write("\n")
+os.replace(temporary, target)
+PYEOF
+}
+
+loki_prepare_project_dependencies() {
+    local tree="${TARGET_DIR:-.}"
+    local quality_dir="$tree/.loki/quality"
+    local state_dir="$tree/.loki/state"
+    local result_file="$quality_dir/dependency-setup.json"
+    local marker_file="$state_dir/dependency-input.sha256"
+    local command_text="npm ci --ignore-scripts --no-audit --no-fund"
+    mkdir -p "$quality_dir" "$state_dir" || return 1
+
+    if [ ! -f "$tree/package.json" ]; then
+        loki_write_dependency_setup_result "$result_file" \
+            "not_applicable" "" "" ""
+        return 0
+    fi
+
+    if [ ! -f "$tree/package-lock.json" ]; then
+        loki_write_dependency_setup_result "$result_file" \
+            "failed" "$command_text" "1" ""
+        log_warn "Dependency setup requires package-lock.json for reproducible npm verification"
+        return 1
+    fi
+
+    local input_sha
+    input_sha="$(loki_dependency_input_sha256 "$tree" 2>/dev/null)" || input_sha=""
+    if [ -z "$input_sha" ]; then
+        loki_write_dependency_setup_result "$result_file" \
+            "failed" "$command_text" "1" ""
+        log_warn "Dependency setup could not fingerprint package.json and package-lock.json"
+        return 1
+    fi
+
+    local marker_version marker_input_sha marker_install_fingerprint install_fingerprint
+    if [ -f "$marker_file" ]; then
+        read -r marker_version marker_input_sha marker_install_fingerprint < "$marker_file" || true
+        if [ "$marker_version" = "v1" ] \
+            && [ "$marker_input_sha" = "$input_sha" ] \
+            && install_fingerprint="$(loki_dependency_install_fingerprint "$tree" 2>/dev/null)" \
+            && [ "$marker_install_fingerprint" = "$install_fingerprint" ]; then
+            loki_write_dependency_setup_result "$result_file" \
+                "verified" "$command_text" "0" "$input_sha"
+            log_info "Dependency setup: reusing the verified lockfile installation"
+            return 0
+        fi
+    fi
+
+    if ! rm -f "$marker_file"; then
+        loki_write_dependency_setup_result "$result_file" \
+            "failed" "$command_text" "1" "$input_sha"
+        log_warn "Dependency setup could not invalidate its previous verification marker"
+        return 1
+    fi
+
+    if ! command -v npm >/dev/null 2>&1; then
+        loki_write_dependency_setup_result "$result_file" \
+            "failed" "$command_text" "127" "$input_sha"
+        log_warn "Dependency setup requires npm but npm is unavailable"
+        return 1
+    fi
+
+    local setup_timeout="${LOKI_DEPENDENCY_SETUP_TIMEOUT:-60}"
+    case "$setup_timeout" in
+        ''|*[!0-9]*) setup_timeout=60 ;;
+    esac
+    [ "$setup_timeout" -gt 0 ] 2>/dev/null || setup_timeout=60
+
+    local rc=0
+    if type _loki_with_deadline >/dev/null 2>&1; then
+        (cd "$tree" && LOKI_DEADLINE_IDLE_TIMEOUT=0 \
+            _loki_with_deadline "$setup_timeout" npm ci \
+                --ignore-scripts --no-audit --no-fund) || rc=$?
+    else
+        (cd "$tree" && npm ci --ignore-scripts --no-audit --no-fund) || rc=$?
+    fi
+    if [ "$rc" -ne 0 ]; then
+        loki_write_dependency_setup_result "$result_file" \
+            "failed" "$command_text" "$rc" "$input_sha"
+        log_warn "Dependency setup failed with exit $rc"
+        return 1
+    fi
+
+    install_fingerprint="$(loki_dependency_install_fingerprint "$tree" 2>/dev/null)" \
+        || install_fingerprint=""
+    if [ -z "$install_fingerprint" ]; then
+        loki_write_dependency_setup_result "$result_file" \
+            "failed" "$command_text" "1" "$input_sha"
+        log_warn "Dependency setup produced an incomplete npm installation"
+        return 1
+    fi
+    if ! loki_publish_dependency_marker \
+        "$marker_file" "$input_sha" "$install_fingerprint"; then
+        loki_write_dependency_setup_result "$result_file" \
+            "failed" "$command_text" "1" "$input_sha"
+        log_warn "Dependency setup could not publish its verification marker"
+        return 1
+    fi
+    loki_write_dependency_setup_result "$result_file" \
+        "verified" "$command_text" "0" "$input_sha"
+    log_info "Dependency setup: reproducible npm installation verified"
+    return 0
+}

package/autonomy/lib/done-recognition.sh

@@ -50,6 +50,51 @@
 # needs a real command, not a shell function.
 _loki_done_recog_invoke() {
     local prompt="$1"
+
+    # v8 RAW-SDK JUDGE PATH (opt-in LOKI_SDK_DONE_RECOG=1). Runs this one-shot
+    # judge via the pure-HTTPS @anthropic-ai/sdk (no claude binary) through the
+    # loki-ts `internal sdk-judge` bridge. This is the first end-to-end SDK
+    # adoption -- CLAUDE-ONLY site, one prompt -> one schema-constrained JSON
+    # object, already inconclusive-safe. Fail-closed: on ANY miss (flag off, no
+    # ANTHROPIC_API_KEY, bun/entrypoint absent, non-zero, empty) we fall straight
+    # through to the existing claude/deterministic paths below -- zero behavior
+    # change when off or unavailable. Same schema, same output shape (a JSON
+    # object parse_object consumes), so parity holds by construction.
+    if [ "${LOKI_SDK_DONE_RECOG:-0}" = "1" ]; then
+        local _sdk_root _sdk_loki _sdk_schema _sdk_prompt_f _sdk_out _sdk_rc
+        _sdk_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+        _sdk_loki="${_sdk_root}/bin/loki"
+        _sdk_schema="${_sdk_root}/loki-ts/data/done-recognition-schema.json"
+        if [ -x "$_sdk_loki" ] && [ -f "$_sdk_schema" ] && command -v bun >/dev/null 2>&1; then
+            _sdk_prompt_f="$(mktemp 2>/dev/null)" || _sdk_prompt_f=""
+            if [ -n "$_sdk_prompt_f" ]; then
+                printf '%s' "$prompt" > "$_sdk_prompt_f"
+                _sdk_rc=0
+                # OS-level ceiling around the whole bun subprocess (council review:
+                # --timeout-ms only bounds the in-process HTTP call; a bun cold-start
+                # / DNS stall could hang the command substitution otherwise). Mirror
+                # the claude path's `timeout` wrap, with a small buffer over the
+                # in-process budget. Degrade to no-cap only if neither timeout binary
+                # is present.
+                local _sdk_to_s=$(( ${LOKI_DONE_RECOG_TIMEOUT:-180} + 15 ))
+                local _sdk_wrap
+                if command -v timeout >/dev/null 2>&1; then _sdk_wrap="timeout ${_sdk_to_s}"
+                elif command -v gtimeout >/dev/null 2>&1; then _sdk_wrap="gtimeout ${_sdk_to_s}"
+                else _sdk_wrap=""; fi
+                _sdk_out="$($_sdk_wrap "$_sdk_loki" internal sdk-judge \
+                    --prompt-file "$_sdk_prompt_f" --schema-file "$_sdk_schema" \
+                    --model "${LOKI_SDK_JUDGE_MODEL:-claude-haiku-4-5}" --effort low \
+                    --timeout-ms "$(( ${LOKI_DONE_RECOG_TIMEOUT:-180} * 1000 ))" 2>/dev/null)" || _sdk_rc=$?
+                rm -f "$_sdk_prompt_f" 2>/dev/null || true
+                if [ "$_sdk_rc" -eq 0 ] && [ -n "$_sdk_out" ]; then
+                    printf '%s' "$_sdk_out"
+                    return 0
+                fi
+            fi
+        fi
+        # fall through to the claude/deterministic paths (fail-closed)
+    fi
+
     command -v claude >/dev/null 2>&1 || return 1
 
     # STRUCTURED VERDICT (v8.x): when the CLI supports --json-schema, force valid

package/autonomy/lib/efficiency_cost.py

@@ -13,6 +13,7 @@ Behavior contract (preserved from the R1 proof generator):
   - cost.usd is None when NO valid efficiency record was read (cost was never
     collected for this run). A skeptic seeing "$0.00" assumes the artifact is
     fake; "cost not recorded" is the honest signal.
+  - Token counts are also None and available is False when no record exists.
   - A genuine 0.0 (records existed but summed to zero) is preserved as 0.0.
   - usd is rounded to 4 decimals only when records were collected.
 
@@ -76,10 +77,10 @@ def collect_efficiency(loki_dir):
 
     Returns (cost dict, best-effort model name (last non-empty seen)).
 
-    Credibility: cost.usd is set to None when NO valid efficiency record was
-    read (cost was never collected for this run). A skeptic seeing "$0.00" on
-    HN assumes the artifact is fake; "cost not recorded" is the honest signal.
-    A genuine 0.0 (records existed but summed to zero) is preserved as 0.0.
+    Credibility: unavailable cost and token values are None when NO valid
+    efficiency record was read. A skeptic seeing "$0.00" assumes the artifact
+    is fake; "cost not recorded" is the honest signal. A genuine 0.0 from a
+    present record is preserved as 0.0.
     """
     cost = {
         "usd": 0.0,
@@ -87,6 +88,7 @@ def collect_efficiency(loki_dir):
         "output_tokens": 0,
         "cache_read_tokens": 0,
         "cache_creation_tokens": 0,
+        "available": False,
     }
     model = ""
     collected = False
@@ -113,9 +115,14 @@ def collect_efficiency(loki_dir):
         # Round usd to a sane precision but keep it precise (anti-pattern:
         # round suspiciously-clean numbers). 4 decimals preserves odd values.
         cost["usd"] = round(cost["usd"], 4)
+        cost["available"] = True
     else:
-        # No efficiency files were read: cost was not collected for this run.
-        cost["usd"] = None
+        # No record means unavailable, never an observed zero.
+        for key in (
+            "usd", "input_tokens", "output_tokens",
+            "cache_read_tokens", "cache_creation_tokens",
+        ):
+            cost[key] = None
     return cost, model