loki-mode 7.129.5 → 8.0.1

package/autonomy/lib/sdk-mode.sh

@@ -0,0 +1,103 @@
+#!/usr/bin/env bash
+# sdk-mode.sh -- v8.1 one-switch SDK activation resolver (bash side).
+#
+# v8 gave every claude judge/text site and the RARV loop an SDK path, each behind
+# its own LOKI_SDK_* flag. This adds ONE operator switch, LOKI_SDK_MODE, that sets
+# the default for all of them at once, so an operator flips the whole engine to the
+# SDK without learning 8 flags.
+#
+#   LOKI_SDK_MODE=off    (default) -- writes NOTHING; every site resolves to its
+#                                     own :-0 default. Byte-identical to v8. INV-OFF.
+#   LOKI_SDK_MODE=judges           -- turn on the 7 one-shot JUDGE/TEXT sites; the
+#                                     RARV loop stays OFF (a behavior change we do
+#                                     NOT ship default this release). Recommended
+#                                     scale tier.
+#   LOKI_SDK_MODE=full             -- all 8 on, including the RARV loop (LOKI_SDK_LOOP).
+#                                     Pre-flight tier; the loop default-flip is a
+#                                     later release.
+#   LOKI_SDK=1  is an alias for LOKI_SDK_MODE=judges; LOKI_SDK=full == full.
+#
+# DESIGN (write-once, zero call-site edits): every existing site reads its flag AT
+# CALL TIME as `[ "${LOKI_SDK_X:-0}" = "1" ]` (bash) / `=== "1"` (TS). So we only
+# need to EXPORT the resolved "0"/"1" into the env ONCE, before the loop runs, and
+# every existing read honors it. We write a var ONLY when it is UNSET (`+set`
+# guard), so an explicit per-site flag ALWAYS wins over the mode (INV-OVERRIDE) --
+# even an explicit `LOKI_SDK_X=0` under `LOKI_SDK_MODE=full`.
+#
+# Call loki_sdk_resolve_mode ONCE, early, after this file is sourced and before any
+# judge lib or the main loop runs.
+#
+# No emojis. No em dashes. bash 3.2 safe.
+
+# The 8 activation vars, in a stable order. LOKI_SDK_LOOP is last (loop tier).
+# Keep this list in sync with loki-ts/src/runner/sdk_mode.ts (parity fixture).
+_LOKI_SDK_JUDGE_VARS="LOKI_SDK_DONE_RECOG LOKI_SDK_COUNCIL_V2 LOKI_SDK_CODE_REVIEW LOKI_SDK_COUNCIL_VOTE LOKI_SDK_VOTER_AGENTS LOKI_SDK_GRILL LOKI_SDK_PRD_ENRICH"
+_LOKI_SDK_LOOP_VAR="LOKI_SDK_LOOP"
+
+# Trim leading/trailing whitespace AND lowercase a value. Kept identical to the
+# TS side's `.trim().toLowerCase()` (sdk_mode.ts) so bash and TS canonicalize a
+# padded env var THE SAME WAY -- an operator who sets `LOKI_SDK_MODE=" full "`
+# (trailing space from a YAML/.env/CI var) must get the same tier on both routes,
+# not off-on-bash / full-on-TS (a real INV-PARITY split the shared fixture cannot
+# catch). bash 3.2 safe: the extglob-free sed strips surrounding [:space:].
+_loki_sdk_trim_lower() {
+    printf '%s' "$1" | sed 's/^[[:space:]]*//; s/[[:space:]]*$//' | tr '[:upper:]' '[:lower:]'
+}
+
+# Normalize LOKI_SDK / LOKI_SDK_MODE to a canonical mode: off | judges | full.
+_loki_sdk_canonical_mode() {
+    local mode
+    mode="$(_loki_sdk_trim_lower "${LOKI_SDK_MODE:-}")"
+    # LOKI_SDK alias (only when LOKI_SDK_MODE is empty/unset): "1"/"on"/"judges"
+    # -> judges; "full" -> full; else ignored.
+    if [ -z "$mode" ] && [ -n "${LOKI_SDK:-}" ]; then
+        case "$(_loki_sdk_trim_lower "$LOKI_SDK")" in
+            1|on|true|yes|judges) mode="judges" ;;
+            full) mode="full" ;;
+            0|off|false|no) mode="off" ;;
+            *) mode="" ;;
+        esac
+    fi
+    case "$mode" in
+        judges) printf 'judges' ;;
+        full)   printf 'full' ;;
+        off|"") printf 'off' ;;
+        *)      printf 'off' ;;  # unknown value -> safe default (off), never on
+    esac
+}
+
+# Write $2 into var $1 ONLY when $1 is unset (so an explicit per-site flag wins).
+_loki_sdk_default_if_unset() {
+    local var="$1" val="$2"
+    # `${!var+set}` is empty only when $var is UNSET (not when it is set-empty).
+    eval "local _cur=\"\${$var+set}\""
+    if [ -z "$_cur" ]; then
+        export "$var=$val"
+    fi
+}
+
+# The resolver. Idempotent + safe to call more than once.
+loki_sdk_resolve_mode() {
+    local mode
+    mode="$(_loki_sdk_canonical_mode)"
+    [ "$mode" = "off" ] && return 0  # INV-OFF: write nothing.
+
+    local v
+    for v in $_LOKI_SDK_JUDGE_VARS; do
+        _loki_sdk_default_if_unset "$v" 1
+    done
+    if [ "$mode" = "full" ]; then
+        _loki_sdk_default_if_unset "$_LOKI_SDK_LOOP_VAR" 1
+    else
+        # judges tier: the loop stays OFF unless the operator set it explicitly.
+        _loki_sdk_default_if_unset "$_LOKI_SDK_LOOP_VAR" 0
+    fi
+    # Observability (opt-in): fanning one switch to 8 vars is action-at-a-distance;
+    # a debug operator should be able to see what got turned on. Off by default so
+    # INV-OFF and normal runs stay silent. Mirrored by sdk_mode.ts.
+    if [ "${LOKI_SDK_MODE_DEBUG:-0}" = "1" ]; then
+        printf 'loki: SDK mode=%s -> judges on, loop=%s\n' \
+            "$mode" "${LOKI_SDK_LOOP:-0}" >&2
+    fi
+    return 0
+}

package/autonomy/lib/secret-scan.sh

@@ -0,0 +1,139 @@
+#!/usr/bin/env bash
+# secret-scan.sh -- RUN-25 iter 21 (Wave D #2): the two-tier secret matcher,
+# extracted to ONE sourceable location so the commit-time gate (autonomy/run.sh)
+# and the completion EVIDENCE gate (autonomy/completion-council.sh) share a
+# single implementation. Previously the matcher lived only in run.sh and ran only
+# on the auto-commit path, so a completion-promise / dirty-tree / non-commit route
+# could ship a leaked credential in a "done" deliverable -- a hole in the exact
+# trust moat Loki sells. Both functions are pure (take a file path); no external
+# state. Patterns are kept in lockstep with autonomy/verify.sh verify_secret_scan_file.
+#
+# No emojis. No em dashes.
+
+_commit_scan_secret_file() {
+    # Two-tier secret matcher. Returns 0 if a high-confidence secret is found in
+    # the file, 1 otherwise. Patterns copied verbatim from the shipped scanner
+    # (autonomy/verify.sh verify_secret_scan_file) so the commit-time gate matches
+    # the verification gate's behavior. Top-level (not nested) so tests can
+    # override it for the mutation/non-vacuity proof.
+    local file="${1:-}"
+    [ -n "$file" ] && [ -f "$file" ] || return 1
+
+    # TEMPLATE / FIXTURE PATHS: a file whose NAME declares it is an example is
+    # not a leak, it is documentation. `.env.example` shipping
+    # `OPENAI_API_KEY=sk-...` is the correct way to show the expected shape, and
+    # generated apps produce these routinely. Without this, the completion gate
+    # blocks a finished, correct app for shipping its own template -- and the
+    # tier1 matcher below deliberately has no deny filter, so the usual
+    # example/placeholder escape hatch never gets a chance to apply.
+    # Scoped narrowly to paths that ANNOUNCE themselves: *.example, *.sample,
+    # *.template, *.dist, and files under a fixtures/ directory. A real secret
+    # in a real path is still caught by both tiers.
+    case "$file" in
+        *.example|*.example.*|*.sample|*.sample.*|*.template|*.template.*|*.dist|*/fixtures/*|*/__fixtures__/*)
+            return 1 ;;
+    esac
+
+    # TIER 1: specific formats. No deny filter -- a format match is a finding.
+    local tier1=(
+        'AKIA[0-9A-Z]{16}'                          # AWS access key id
+        'ASIA[0-9A-Z]{16}'                          # AWS temporary (STS) key id
+        '-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----'     # PEM private key block
+        'gh[pousr]_[A-Za-z0-9]{36,}'                # GitHub token (ghp_/gho_/...)
+        'github_pat_[A-Za-z0-9_]{60,}'              # GitHub fine-grained PAT
+        'xox[baprs]-[A-Za-z0-9-]{10,}'              # Slack token (xoxb-/xoxp-/...)
+        'sk-[A-Za-z0-9]{20,}'                       # OpenAI-style secret key
+        'AIza[0-9A-Za-z_-]{35}'                     # Google API key
+        'glpat-[A-Za-z0-9_-]{20,}'                  # GitLab personal access token
+    )
+    local p
+    for p in "${tier1[@]}"; do
+        # -e terminates option parsing so a pattern beginning with '-' (the PEM
+        # block) is not mistaken for a flag.
+        if LC_ALL=C grep -Eq -e "$p" "$file" 2>/dev/null; then
+            return 0
+        fi
+    done
+
+    # Deny filter for TIER 2: a matched line is IGNORED if it is plainly a
+    # placeholder or an environment-variable reference rather than a literal.
+    local deny='(\$\{|\$[A-Za-z_]|process\.env|os\.(environ|getenv)|%[A-Za-z_]+%|your[-_]|redacted|changeme|change[-_]me|placeholder|example|dummy|sample|fake|<[^>]*>|x{4,}|\*{4,})'
+
+    # TIER 2: generic assignments + bearer tokens + connection-string creds.
+    local tier2='(api[_-]?key|secret|token|password|passwd|access[_-]?key|client[_-]?secret|auth)[A-Za-z0-9_]*[[:space:]]*[:=][[:space:]]*["'"'"']?[A-Za-z0-9_/+.=-]{16,}'
+    local bearer='[Bb]earer[[:space:]]+[A-Za-z0-9_.\-]{20,}'
+    # URI-embedded credentials: scheme://user:password@host. The #1 leak vector
+    # in 12-factor apps (DATABASE_URL=postgres://u:pass@h, mongodb+srv://, redis://).
+    # Runs through the deny filter below, so ${VAR}-ref URIs are correctly ignored.
+    # Username segment is optional (*) so the password-only form redis://:pass@host
+    # (Redis < 6 / Heroku Redis / Redis Cloud emit exactly this) is caught too.
+    local uricred='[a-z][a-z0-9+.\-]*://[^/[:space:]:@]*:[^/[:space:]:@]+@'
+
+    local surviving
+    surviving="$(LC_ALL=C grep -EiI "$tier2|$bearer|$uricred" "$file" 2>/dev/null \
+        | LC_ALL=C grep -Eiv "$deny" 2>/dev/null)"
+    if [ -n "$surviving" ]; then
+        return 0
+    fi
+    return 1
+}
+
+_commit_path_looks_secret() {
+    # Filename/path heuristic. Returns 0 if the path looks like a credential or
+    # secret file ANYWHERE in the tree (basename OR any directory component),
+    # 1 otherwise. This is the PRIMARY commit-time guard: it catches likely-secret
+    # files regardless of where they sit and regardless of how weak the value
+    # inside looks, closing the nested-path gap that a top-level glob (':!credentials*')
+    # and a content-pattern scan both miss (e.g. secrets/credentials.json holding
+    # {"key":"sk-secret"}). The content scan (_commit_scan_secret_file) remains the
+    # complementary layer 2 for strong secrets hiding in non-obvious filenames.
+    #
+    # Safe-default bias: this runs only for the session-end AUTO-commit. A false
+    # positive merely leaves the file uncommitted for the user to commit by hand,
+    # which is acceptable and honest. So we err toward caution.
+    #
+    # Top-level (not nested) so tests can override it for the non-vacuity proof.
+    local p="${1:-}"
+    [ -n "$p" ] || return 1
+    # Case-insensitive match: lower the full path AND the basename, test both.
+    local lower base
+    lower="$(printf '%s' "$p" | tr '[:upper:]' '[:lower:]')"
+    base="${lower##*/}"
+    local cand
+    for cand in "$lower" "$base"; do
+        case "$cand" in
+            # dotenv files (basename or any path component ending in them)
+            .env|.env.*|*/.env|*/.env.*|*.env) return 0 ;;
+            # credential(s) anywhere (basename or any segment): secrets/credentials.json,
+            # aws-credentials, my-credential.txt, .git-credentials
+            *credential*) return 0 ;;
+            # a "secret"/"secrets" segment anywhere: secrets/anything, config/secret.json
+            *secret*) return 0 ;;
+            # private-key / keystore / cert material (extension-anchored so we do
+            # NOT match innocuous names like config.js or monkey.js)
+            *.pem|*.key|*.p12|*.keystore|*.pfx|*.jks|*.ppk) return 0 ;;
+            id_rsa|id_rsa.*|*/id_rsa|*/id_rsa.*) return 0 ;;
+            id_ed25519*|*/id_ed25519*) return 0 ;;
+            # token files: extension (*.token) OR "token" as a whole word/segment
+            # (delimited by /, -, _, or .). Deliberately NOT a bare *token*: that
+            # would flag ubiquitous innocuous frontend/parser names (tokenizer.js,
+            # tokens.css, design-tokens.json), and since the scan aborts the WHOLE
+            # session auto-commit on any single offender, one such file would block
+            # committing all of the user's work. Segment-style still catches real
+            # token files: api.token, auth_token, id-token, github.token, oauth-token.json.
+            *.token) return 0 ;;
+            token|token.*|token-*|token_*) return 0 ;;
+            *-token|*_token|*.token.*) return 0 ;;
+            *-token.*|*_token.*|*/token|*/token.*) return 0 ;;
+            *-token-*|*_token_*|*-token_*|*_token-*) return 0 ;;
+            # package/registry/cloud credential configs
+            .npmrc|*/.npmrc|.pypirc|*/.pypirc|.netrc|*/.netrc) return 0 ;;
+            *.kubeconfig|kubeconfig|*/kubeconfig) return 0 ;;
+            .dockercfg|*/.dockercfg|.docker/config.json|*/.docker/config.json) return 0 ;;
+            # service-account / gcp key json
+            service-account*.json|*/service-account*.json|*serviceaccount*) return 0 ;;
+            gcp-key*.json|*/gcp-key*.json) return 0 ;;
+        esac
+    done
+    return 1
+}

package/autonomy/lib/spec-expand.sh

@@ -0,0 +1,208 @@
+#!/usr/bin/env bash
+# spec-expand.sh -- RUN-25 iter 24 (Wave D #4): turn an API CONTRACT (OpenAPI /
+# GraphQL SDL / Postman collection) passed as the build source into a full,
+# per-operation build checklist instead of letting the raw contract get copied
+# verbatim and then TRUNCATED to the first 4000 bytes of the prompt (a real
+# defect: a 40-operation OpenAPI file loses 21 of 40 ops to `head -c 4000`, so
+# the builder never sees over half the contract).
+#
+# One entry point: spec_maybe_expand_contract <src-file>
+#   - sniffs the file; if it is an OpenAPI/GraphQL/Postman contract, expands it
+#     into .loki/generated-prd.md as a checklist (one `- [ ]` per operation,
+#     keyed by operationId/field/request name) and echoes ".loki/generated-prd.md".
+#   - otherwise echoes NOTHING and touches no state (the caller keeps the raw
+#     path -> existing behavior is byte-identical for non-contract specs).
+#
+# Deterministic, pure-python stdlib (json always; yaml when importable, regex
+# fallback otherwise). No new dependency, no network, no LLM. Not byte-lock
+# gated: it rewrites an INPUT file, it does not change build_prompt() output.
+#
+# No emojis. No em dashes.
+
+# spec_maybe_expand_contract <src>
+# On a recognized contract, writes the per-operation checklist to a TEMP file and
+# echoes that temp path (the caller feeds it to persist_user_prd, which copies it
+# into .loki/generated-prd.md AND writes the source:"user" signature so a later
+# no-file run reuses it exactly like a user PRD -- no duplicated persist logic).
+# Echoes empty and touches no state on anything that is not a contract.
+#
+# For a standalone caller (no persist_user_prd in scope, e.g. the unit test), set
+# LOKI_SPEC_EXPAND_INPLACE=1 to write straight to .loki/generated-prd.md and echo
+# that path instead. The default (temp + persist) is what the runner uses.
+spec_maybe_expand_contract() {
+    local src="$1"
+    [ -n "$src" ] || { echo ""; return 0; }
+    [ -f "$src" ] || { echo ""; return 0; }
+    command -v python3 >/dev/null 2>&1 || { echo ""; return 0; }
+
+    # Never re-expand our own generated PRD.
+    case "$src" in
+        *.loki/generated-prd.md|*.loki/generated-prd.json) echo ""; return 0 ;;
+    esac
+
+    local loki_dir="${TARGET_DIR:-.}/.loki"
+    local inplace="${LOKI_SPEC_EXPAND_INPLACE:-0}"
+    # Default: write a temp checklist the caller persists (writes the signature).
+    # In-place: write the canonical slot directly (standalone/test path).
+    local tmp dest
+    if [ "$inplace" = "1" ]; then
+        mkdir -p "$loki_dir" 2>/dev/null || { echo ""; return 0; }
+        dest="$loki_dir/generated-prd.md"
+        tmp="$loki_dir/.generated-prd.md.expand.$$"
+    else
+        tmp="${TMPDIR:-/tmp}/loki-spec-expand.$$.md"
+        dest="$tmp"
+    fi
+
+    # The python does the sniff + expansion. It writes the checklist to $tmp and
+    # exits 0 ONLY when it actually recognized a contract; any other exit (not a
+    # contract, parse error, empty operation set) leaves state untouched.
+    if _SPEC_EXP_SRC="$src" _SPEC_EXP_OUT="$tmp" python3 - <<'PYEOF'
+import json, os, re, sys
+
+src = os.environ["_SPEC_EXP_SRC"]
+out = os.environ["_SPEC_EXP_OUT"]
+
+try:
+    with open(src, encoding="utf-8", errors="replace") as fh:
+        raw = fh.read()
+except OSError:
+    sys.exit(2)
+
+if not raw.strip():
+    sys.exit(2)
+
+
+def load_structured(text):
+    # Try JSON first (Postman + OpenAPI-json), then YAML if available.
+    try:
+        return json.loads(text)
+    except Exception:
+        pass
+    try:
+        import yaml  # PyYAML present in this env; optional elsewhere.
+        return yaml.safe_load(text)
+    except Exception:
+        return None
+
+
+def norm_id(text, fallback):
+    t = (text or "").strip()
+    if not t:
+        return fallback
+    t = re.sub(r"\s+", " ", t)
+    return t
+
+
+data = load_structured(raw)
+ops = []          # list of (op_id, description)
+kind = None
+
+# ---- OpenAPI / Swagger (structured) ----------------------------------------
+if isinstance(data, dict) and ("openapi" in data or "swagger" in data) and isinstance(data.get("paths"), dict):
+    kind = "OpenAPI"
+    for path, item in data["paths"].items():
+        if not isinstance(item, dict):
+            continue
+        for method, op in item.items():
+            if method.lower() not in ("get", "post", "put", "patch", "delete", "head", "options", "trace"):
+                continue
+            if not isinstance(op, dict):
+                continue
+            opid = op.get("operationId") or "%s %s" % (method.upper(), path)
+            summary = op.get("summary") or op.get("description") or ""
+            desc = "%s %s -- %s" % (method.upper(), path, summary.strip()) if summary else "%s %s" % (method.upper(), path)
+            ops.append((norm_id(opid, "%s %s" % (method.upper(), path)), desc.strip()))
+
+# ---- Postman collection (structured) ---------------------------------------
+elif isinstance(data, dict) and isinstance(data.get("info"), dict) and "item" in data:
+    kind = "Postman"
+
+    def walk(items, prefix=""):
+        for it in items or []:
+            if not isinstance(it, dict):
+                continue
+            name = it.get("name", "request")
+            if isinstance(it.get("item"), list):        # folder
+                walk(it["item"], prefix + name + " / ")
+            elif isinstance(it.get("request"), (dict, str)):
+                req = it["request"]
+                method = req.get("method", "") if isinstance(req, dict) else ""
+                label = (prefix + name).strip()
+                ops.append((label, ("%s %s" % (method, label)).strip()))
+
+    walk(data.get("item"))
+
+# ---- GraphQL SDL (text; not JSON/YAML) -------------------------------------
+if not ops:
+    # Recognize a schema with a Query/Mutation/Subscription type and pull each
+    # field as one operation. Cheap brace-depth scan, no graphql lib needed.
+    if re.search(r"\btype\s+(Query|Mutation|Subscription)\b", raw):
+        kind = "GraphQL"
+        for root in ("Query", "Mutation", "Subscription"):
+            m = re.search(r"\btype\s+" + root + r"\b[^{]*\{", raw)
+            if not m:
+                continue
+            i = m.end()
+            depth = 1
+            body_start = i
+            while i < len(raw) and depth > 0:
+                if raw[i] == "{":
+                    depth += 1
+                elif raw[i] == "}":
+                    depth -= 1
+                i += 1
+            body = raw[body_start:i - 1]
+            # A field line: name(optional args): ReturnType
+            for fm in re.finditer(r"^\s*([A-Za-z_]\w*)\s*(\([^)]*\))?\s*:\s*([^\n#]+)", body, re.M):
+                field = fm.group(1)
+                ret = fm.group(3).strip()
+                ops.append(("%s.%s" % (root, field), "%s %s -> %s" % (root, field, ret)))
+
+if not ops:
+    sys.exit(3)   # nothing recognized -> caller keeps the raw path
+
+# De-dup on op id, preserve order.
+seen = set()
+uniq = []
+for oid, desc in ops:
+    if oid in seen:
+        continue
+    seen.add(oid)
+    uniq.append((oid, desc))
+
+title = os.path.basename(src)
+lines = []
+lines.append("# Build checklist from %s contract: %s" % (kind, title))
+lines.append("")
+lines.append("Source: %s (%s). Each operation below is one build requirement." % (title, kind))
+lines.append("Implement, test, and verify every item. Do not drop any operation.")
+lines.append("")
+lines.append("## Operations (%d)" % len(uniq))
+lines.append("")
+for oid, desc in uniq:
+    lines.append("- [ ] %s: %s" % (oid, desc))
+lines.append("")
+
+try:
+    with open(out, "w", encoding="utf-8") as fh:
+        fh.write("\n".join(lines))
+except OSError:
+    sys.exit(4)
+
+sys.exit(0)
+PYEOF
+    then
+        if [ "$inplace" = "1" ]; then
+            mv -f "$tmp" "$dest" 2>/dev/null || { rm -f "$tmp" 2>/dev/null; echo ""; return 0; }
+            echo ".loki/generated-prd.md"
+        else
+            # tmp == dest here; hand the temp checklist to the caller to persist.
+            echo "$tmp"
+        fi
+        return 0
+    fi
+    rm -f "$tmp" 2>/dev/null
+    echo ""
+    return 0
+}