loki-mode 8.8.1 → 8.9.0

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 v8.8.1
+# Loki Mode v8.9.0
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -469,4 +469,4 @@ See `CHANGELOG.md` entries [7.5.7], [7.5.8], [7.5.13] for the per-fix list and r
 
 ---
 
-**v8.8.1 | [Autonomi](https://www.autonomi.dev/) flagship product | ~410 lines core**
+**v8.9.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~410 lines core**

package/VERSION

@@ -1 +1 @@
-8.8.1
+8.9.0

package/autonomy/loki

@@ -17629,12 +17629,37 @@ else:
             integrations.append(kw)
 
     # Count database mentions
-    db_keywords = ['postgresql', 'postgres', 'mysql', 'mongodb', 'sqlite',
-                   'dynamodb', 'cassandra', 'redis', 'prisma', 'typeorm',
-                   'sequelize', 'drizzle', 'knex', 'database', 'migration']
-    for kw in db_keywords:
-        if kw in content_lower:
-            databases.append(kw)
+    # Count DISTINCT data stores. This feeds a +1-complexity-for-multiple
+    # rule, so what counts as multiple is load-bearing: it pushed a
+    # 322-word issue from moderate to complex, and complex means 18 iterations
+    # instead of 9.
+    #
+    # Three ways the old flat list over-counted a single-database project:
+    #   1. Aliases. 'postgresql' and 'postgres' were separate entries, so one
+    #      PostgreSQL app scored TWO data stores by itself. That alone tripped
+    #      the rule on a real user's issue.
+    #   2. ORMs. prisma/typeorm/sequelize/drizzle/knex are ACCESS LAYERS, not
+    #      stores. Prisma plus PostgreSQL is one database, not two.
+    #   3. Generic words. 'database' and 'migration' matched any PRD that used
+    #      the words at all, so a migration-to-the-database line scored two.
+    #
+    # Aliases collapse to one canonical name, ORMs and generic terms are gone.
+    db_aliases = {
+        'postgresql': 'postgres', 'postgres': 'postgres', 'psql': 'postgres',
+        'mysql': 'mysql', 'mariadb': 'mysql',
+        'mongodb': 'mongodb', 'mongo': 'mongodb',
+        'sqlite': 'sqlite',
+        'dynamodb': 'dynamodb',
+        'cassandra': 'cassandra',
+        'redis': 'redis',
+        'elasticsearch': 'elasticsearch',
+        'clickhouse': 'clickhouse',
+    }
+    _seen_db = set()
+    for kw, canonical in db_aliases.items():
+        if kw in content_lower and canonical not in _seen_db:
+            _seen_db.add(canonical)
+            databases.append(canonical)
 
     # Count UI components
     ui_keywords = ['dashboard', 'form', 'table', 'modal', 'navbar',
@@ -17717,6 +17742,34 @@ iteration_map = {
 }
 min_iter, max_iter = iteration_map[complexity]
 
+# --- Capability-aware iteration budget ---------------------------------------
+# The map above was written when a model could not hold a whole feature in one
+# pass, so work was chopped into many small iterations. On a frontier tier that
+# is now actively harmful: each iteration boundary is a context reset, and
+# re-planning mid-feature is where a run loses the thread and burns money.
+#
+# A frontier model should be handed the whole job and left to finish it. So the
+# budget is divided by the capability tier the run will actually dispatch,
+# rather than assuming the weakest case for everyone. The floor is 1, never 0.
+#
+# This scales the ESTIMATE and the ceiling, not the work. A run that genuinely
+# needs more iterations still takes them; nothing here forces an early stop.
+_tier_raw = (os.environ.get('LOKI_SESSION_MODEL') or '').strip().lower()
+_frontier = ('high', 'planning', 'opus', 'sol')
+_small = ('small', 'fast', 'haiku', 'luna')
+if _tier_raw in _frontier:
+    # Frontier: one pass for anything short of enterprise scope.
+    min_iter = 1
+    max_iter = max(1, max_iter // 4)
+elif _tier_raw in _small:
+    # Small models genuinely benefit from more, smaller steps.
+    pass
+else:
+    # medium / unset: the common default. Halve the legacy budget -- current
+    # workhorse models complete in far fewer passes than this map assumed.
+    min_iter = max(1, min_iter // 2)
+    max_iter = max(min_iter, max_iter // 2)
+
 # Adjust based on specific counts
 if endpoint_count > 10:
     max_iter = max(max_iter, max_iter + endpoint_count // 5)

package/autonomy/run.sh

@@ -630,6 +630,70 @@ PY
     export LOKI_SPEC_SHA256
 }
 
+# Scoped-change profile: a bug fix or a single feature in an EXISTING repo.
+#
+# Measured on a real user's run: a 322-word GitHub issue against an existing
+# codebase spent 25+ minutes still inside iteration 1. The work itself was
+# genuine, but the build was also running competitor web research, load and
+# performance testing, regression simulation and UAT -- all of which default to
+# true, and none of which a scoped issue fix needs. That is the difference
+# between a 5-minute fix and a 30-minute one.
+#
+# What this NEVER touches: code review, security, tests, E2E, and the
+# completion council all stay on. Speed here comes from not running phases that
+# are irrelevant to the change, never from skipping verification. A greenfield
+# build or a whole-repo refactor does not match this profile and keeps the full
+# suite.
+#
+# Auto-detected rather than another flag the user has to know: an existing git
+# repo with real history, plus a spec that reads as a scoped change. Set
+# LOKI_SCOPED_CHANGE=0 to force the full suite, or =1 to force this profile.
+loki_detect_scoped_change() {
+    # Explicit operator intent always wins, in both directions.
+    case "${LOKI_SCOPED_CHANGE:-}" in
+        0|false) return 1 ;;
+        1|true)  return 0 ;;
+    esac
+
+    # Greenfield is not a scoped change: no repo, or a repo with almost no
+    # history, means we are building something new.
+    local target="${TARGET_DIR:-.}"
+    [ -d "$target/.git" ] || return 1
+    local commits
+    commits="$(git -C "$target" rev-list --count HEAD 2>/dev/null || echo 0)"
+    [ "${commits:-0}" -ge 5 ] || return 1
+
+    # An issue-sourced spec is the canonical scoped change: someone filed a
+    # discrete request against code that already exists.
+    [ -n "${LOKI_ISSUE_REF:-}" ] && return 0
+    case "${LOKI_PRD_FILE:-}" in
+        *prd-issue-*) return 0 ;;
+    esac
+
+    return 1
+}
+
+loki_apply_scoped_change_profile() {
+    loki_detect_scoped_change || return 0
+
+    # Off: cannot affect the correctness of a scoped change to existing code.
+    : "${LOKI_PHASE_WEB_RESEARCH:=false}"
+    : "${LOKI_PHASE_PERFORMANCE:=false}"
+    : "${LOKI_PHASE_REGRESSION:=false}"
+    : "${LOKI_PHASE_UAT:=false}"
+
+    # On: every trust gate, unchanged. These are the moat.
+    : "${LOKI_PHASE_CODE_REVIEW:=true}"
+    : "${LOKI_PHASE_SECURITY:=true}"
+    : "${LOKI_PHASE_UNIT_TESTS:=true}"
+    : "${LOKI_PHASE_E2E_TESTS:=true}"
+
+    export LOKI_PHASE_WEB_RESEARCH LOKI_PHASE_PERFORMANCE LOKI_PHASE_REGRESSION
+    export LOKI_PHASE_UAT LOKI_PHASE_CODE_REVIEW LOKI_PHASE_SECURITY
+    export LOKI_PHASE_UNIT_TESTS LOKI_PHASE_E2E_TESTS
+    export LOKI_SCOPED_CHANGE_ACTIVE=1
+}
+
 loki_apply_build_profile() {
     [ "${LOKI_BUILD_PROFILE:-}" = "simple-web" ] || return 0
     : "${LOKI_PHASE_API_TESTS:=false}"
@@ -772,6 +836,7 @@ print(catalog["providers"]["claude"]["cli_aliases"].get(os.environ["_LOKI_SELECT
     export LOKI_SDK_JUDGE_MODEL LOKI_SDK_PRD_ENRICH_MODEL LOKI_SDK_REVIEW_MODEL
 }
 loki_apply_build_profile
+loki_apply_scoped_change_profile
 
 # Default hang guard for EVERY build, not just simple-web.
 #

package/dashboard/__init__.py

@@ -7,7 +7,7 @@ Modules:
     control: Session control API (start/stop/pause/resume)
 """
 
-__version__ = "8.8.1"
+__version__ = "8.9.0"
 
 # Expose the control app for easy import
 try: