loki-mode 7.92.0 → 7.94.0

package/autonomy/run.sh

@@ -13383,7 +13383,7 @@ except (json.JSONDecodeError, KeyError, TypeError, OSError):
                         ITERATION_COUNT=0
                     fi
                     ;;
-                failed|max_iterations_reached|max_retries_exceeded|exited|council_approved|council_force_approved|completion_promise_fulfilled)
+                failed|max_iterations_reached|max_retries_exceeded|exited|council_approved|council_force_approved|completion_promise_fulfilled|reuse_already_satisfied)
                     log_info "Previous session ended with status: $prev_status. Resetting for new session."
                     RETRY_COUNT=0
                     ITERATION_COUNT=0
@@ -14859,6 +14859,40 @@ if os.path.exists(pending_path):
 existing_ids = {t.get("id") for t in existing if isinstance(t, dict)}
 added = 0
 
+# Reuse done-recognition (v7.94.0): if a satisfied-requirements manifest exists
+# AND its prd_sha matches THIS PRD's hash, skip any feature whose title is
+# already satisfied, so an incremental reuse run rebuilds ONLY the gap. A stale
+# or absent manifest is ignored (full build -- the safe default). The sha is
+# computed over the SAME PRD file bytes the gate hashed (hashlib.sha256), so the
+# guard matches byte-for-byte. Title match is normalized (case-insensitive, with
+# a leading "feature:/requirement:/epic:/story:" heading prefix stripped) so a
+# model-returned title like "User login" matches the parser's heading title
+# "Feature: User login". bash 3.2 safe: all normalization happens in python.
+def _dr_norm_title(s):
+    s = (s or "").strip().lower()
+    for _pfx in ("feature:", "requirement:", "epic:", "story:", "user story:"):
+        if s.startswith(_pfx):
+            s = s[len(_pfx):].strip()
+            break
+    return s
+
+_dr_satisfied = set()
+try:
+    import hashlib
+    _dr_manifest = ".loki/state/satisfied-requirements.json"
+    if os.path.isfile(_dr_manifest):
+        with open(_dr_manifest, "r") as _mf:
+            _dr_data = json.load(_mf)
+        _dr_manifest_sha = (_dr_data.get("prd_sha") or "").strip()
+        with open(prd_path, "rb") as _pf:
+            _dr_cur_sha = hashlib.sha256(_pf.read()).hexdigest()
+        if _dr_manifest_sha and _dr_manifest_sha == _dr_cur_sha:
+            for _t in _dr_data.get("satisfied", []):
+                if isinstance(_t, str) and _t.strip():
+                    _dr_satisfied.add(_dr_norm_title(_t))
+except Exception:
+    _dr_satisfied = set()
+
 # BUG-V63-001 fix: extract audience once with flag to break both loops
 audience = "a user"
 audience_found = False
@@ -14878,6 +14912,12 @@ for i, feat in enumerate(features):
     if task_id in existing_ids:
         continue
 
+    # Skip features the done-recognition gate verified as already satisfied
+    # (manifest-driven, title-keyed, normalized match). Only unmet requirements
+    # become tasks, so the RARV loop works only the gap.
+    if _dr_satisfied and _dr_norm_title(feat.get("title")) in _dr_satisfied:
+        continue
+
     criteria = extract_acceptance_criteria(feat["section"], sections)
 
     # Build a rich description
@@ -15238,6 +15278,39 @@ except Exception:
     load_state
     local retry=$RETRY_COUNT
 
+    # Reuse done-recognition gate (v7.94.0). On a no-PRD run that is REUSING an
+    # already-generated PRD, model-verify whether the codebase already satisfies
+    # that spec BEFORE rebuilding a task queue and re-running the RARV loop.
+    # Routes to one of three outcomes (the verdict is the model's, grounded in
+    # re-run tests + code; the only deterministic shortcut is NEGATIVE -> build):
+    #   done        -> refresh the verified-completion record, finalize, return 0
+    #                  so the queue/loop is skipped and main()'s terminal block
+    #                  finishes the run (no wasted iterations, no stray delegate
+    #                  branch -- this runs BEFORE the start-sha/delegate block).
+    #   incomplete  -> write .loki/state/satisfied-requirements.json so
+    #                  populate_prd_queue builds ONLY the unsatisfied items, then
+    #                  fall through to the (now incremental) build.
+    #   inconclusive-> fall through to the normal full build (safe default).
+    # Default-on; LOKI_DONE_RECOGNITION=0 disables it. Armed only on a reuse of
+    # an existing generated PRD; `update` (stale PRD) may never fast-stop as done.
+    case "${GENERATED_PRD_ACTION:-}" in
+        reuse|user_owned|update)
+            local _done_recog_lib="$SCRIPT_DIR/lib/done-recognition.sh"
+            if [ -f "$_done_recog_lib" ]; then
+                # shellcheck source=lib/done-recognition.sh
+                source "$_done_recog_lib" 2>/dev/null || true
+                if declare -f reuse_done_recognition_gate >/dev/null 2>&1; then
+                    if reuse_done_recognition_gate "$prd_path"; then
+                        # done verdict: the gate finalized; main()'s terminal
+                        # block (run_autonomous's caller) runs the COMPLETED
+                        # marker, proof-of-run, and HANDOFF.md.
+                        return 0
+                    fi
+                fi
+            fi
+            ;;
+    esac
+
     # Capture run-start SHA for the evidence hard gate (v7.19.1).
     # Fresh-run-aware: recapture HEAD when ITERATION_COUNT==0 (fresh invocation,
     # reset, or corrupted/missing baseline); preserve only on a genuine resume

package/dashboard/__init__.py

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

package/dashboard/server.py

@@ -667,7 +667,14 @@ async def _push_loki_state_loop() -> None:
                             "running_agents": running_agents,
                             "pending_tasks": len(pending) if isinstance(pending, list) else 0,
                             "current_task": in_prog[0].get("payload", {}).get("action", "") if isinstance(in_prog, list) and in_prog else "",
-                            "version": raw.get("version", ""),
+                            # Version reflects the RUNNING engine, not the project's
+                            # stored state. raw.get("version") is whatever engine
+                            # last wrote dashboard-state.json for THIS project (can
+                            # be an old version, e.g. a project first built under
+                            # 7.7.29), which made the displayed version flip between
+                            # this stale value and the live one from the fallback
+                            # path below. Always use the live engine version.
+                            "version": _version,
                         }
                         await manager.broadcast({
                             "type": "status_update",
@@ -705,14 +712,10 @@ async def _push_loki_state_loop() -> None:
                                 pass
 
                         if _sk_fresh:
-                            # Read version from VERSION file
-                            _sk_version = ""
-                            _vf = _Path(os.path.dirname(os.path.dirname(__file__))) / "VERSION"
-                            if _vf.is_file():
-                                try:
-                                    _sk_version = _vf.read_text().strip()
-                                except OSError:
-                                    pass
+                            # Version reflects the running engine (single source of
+                            # truth), the same value the dashboard-state path uses
+                            # above, so the displayed version never flips.
+                            _sk_version = _version
 
                             # Read orchestrator state
                             _sk_phase = ""
@@ -1106,17 +1109,10 @@ async def get_status() -> StatusResponse:
     loki_dir = _get_loki_dir()
     uptime = (datetime.now(timezone.utc) - start_time).total_seconds()
 
-    # Read VERSION file early (independent of .loki/ dir)
-    version = "unknown"
-    dashboard_dir = os.path.dirname(__file__)
-    project_root = os.path.dirname(dashboard_dir)
-    version_file = os.path.join(project_root, "VERSION")
-    if os.path.isfile(version_file):
-        try:
-            with open(version_file) as vf:
-                version = vf.read().strip()
-        except (OSError, IOError) as e:
-            logger.warning(f"Failed to read VERSION file: {e}")
+    # Version reflects the running engine (single source of truth: the package
+    # __version__, same value every status path uses) so the displayed version is
+    # always the live engine, never a stale per-project value.
+    version = _version
 
     # If .loki/ directory doesn't exist, return idle status immediately
     if not loki_dir.is_dir():
@@ -8784,6 +8780,157 @@ def _reconcile_app_runner_liveness(state):
     return state
 
 
+# Per-probe TCP connect timeout (seconds) for the single-process port probe.
+# Kept short so a stopped/firewalled port fails fast and the status endpoint
+# stays responsive for the dashboard's 3-5s pollers.
+_APP_RUNNER_PORT_PROBE_TIMEOUT = 1.0
+
+
+def _port_is_serving(port):
+    """True only if a TCP connection to 127.0.0.1:<port> genuinely succeeds.
+
+    Honest by construction: this proves *something* is accepting connections on
+    the recorded port right now, never fabricates a result. Any failure (refused,
+    timeout, bad port, OS error) returns False so the caller degrades to an
+    honest non-running state. Synchronous; the caller offloads it to a worker
+    thread so the event loop is never blocked by the connect.
+    """
+    try:
+        port = int(port)
+    except (TypeError, ValueError):
+        return False
+    if port <= 0 or port > 65535:
+        return False
+    import socket
+    for host in ("127.0.0.1", "::1"):
+        sock = None
+        try:
+            family = socket.AF_INET6 if ":" in host else socket.AF_INET
+            sock = socket.socket(family, socket.SOCK_STREAM)
+            sock.settimeout(_APP_RUNNER_PORT_PROBE_TIMEOUT)
+            if sock.connect_ex((host, port)) == 0:
+                return True
+        except OSError:
+            continue
+        finally:
+            if sock is not None:
+                try:
+                    sock.close()
+                except OSError:
+                    pass
+    return False
+
+
+def _dashboard_self_port():
+    """The TCP port this dashboard process itself is bound to, or None.
+
+    The user's app can never listen on the port the dashboard already occupies,
+    so this is used to exclude a self-hit from the single-process probe (a stale
+    recorded port that happens to equal the dashboard's port would otherwise
+    probe-succeed against the dashboard and be misreported as the app running).
+    Reads LOKI_DASHBOARD_PORT (the same env run_server binds), defaulting to the
+    well-known 57374. Returns an int or None.
+    """
+    try:
+        return int(os.environ.get("LOKI_DASHBOARD_PORT", "57374"))
+    except (TypeError, ValueError):
+        return 57374
+
+
+def _recorded_app_port(state):
+    """Best-effort recorded port for the single-process app, or None.
+
+    Reads the port the app-runner/CLI already recorded for THIS project, never a
+    guessed value: first state.json's own `port`, then the app-runner
+    detection.json the engine writes (`.loki/app-runner/detection.json`). Returns
+    an int in the valid range or None. Pairing the probe to a *recorded* port is
+    what keeps the result honest -- we never sweep arbitrary common ports.
+
+    Honesty guards:
+      - A docker-compose detection.json is ignored here; a compose stack is the
+        compose-discovery path's domain (which verifies the container belongs to
+        the project), so feeding its port into the single-process probe would
+        risk a false positive against an unrelated local service.
+      - The dashboard's own port is never returned, since the user's app cannot
+        bind it and a stale recorded value equal to it would self-hit the probe.
+    """
+    self_port = _dashboard_self_port()
+
+    def _ok(p):
+        try:
+            p = int(p)
+        except (TypeError, ValueError):
+            return None
+        if not (0 < p <= 65535):
+            return None
+        if self_port is not None and p == self_port:
+            return None
+        return p
+
+    if isinstance(state, dict):
+        p = _ok(state.get("port"))
+        if p is not None:
+            return p
+    try:
+        det_file = _get_loki_dir() / "app-runner" / "detection.json"
+        if det_file.is_file():
+            det = json.loads(det_file.read_text())
+            if isinstance(det, dict) and not det.get("is_docker"):
+                p = _ok(det.get("port"))
+                if p is not None:
+                    return p
+    except (OSError, ValueError, TypeError, json.JSONDecodeError):
+        pass
+    return None
+
+
+def _discover_single_process_app_runner_state(state):
+    """Detect a genuinely-running single-process app via a recorded-port probe.
+
+    A SKILL/CLI-built project (e.g. one started with `npm run dev` outside
+    app-runner.sh, or whose orchestrator has since exited) leaves a state.json
+    with status "stopped"/"stale" and main_pid 0, even while the app itself is
+    still serving. The dashboard would then report "not running" for a live app.
+
+    Resolution (all probe-verified, never fabricated):
+      - Find the RECORDED port (state.json.port or non-docker detection.json) --
+        never a guessed port, and never the dashboard's own port.
+      - Probe 127.0.0.1:<port>. Only if the connection genuinely succeeds do we
+        synthesize a "running" state using the recorded url/port.
+      - Otherwise (no recorded port, or recorded port not reachable) return None;
+        the caller keeps the honest reconciled state, which already carries
+        positive evidence (the writer's settled "stopped", or a pid_gone /
+        recycled / health_stale downgrade). "Unknown" would be less honest than
+        that evidence, so we never override it here.
+
+    Synchronous and self-contained; the caller offloads it onto a worker thread.
+    Never raises.
+    """
+    try:
+        port = _recorded_app_port(state)
+        if not port:
+            return None
+        if not _port_is_serving(port):
+            return None
+        url = ""
+        if isinstance(state, dict):
+            url = state.get("url") or ""
+        if not url:
+            url = "http://localhost:{}".format(port)
+        return {
+            "status": "running",
+            "url": url,
+            "port": int(port),
+            "method": (state.get("method") if isinstance(state, dict) else "") or "",
+            "source": "probe",
+            "externally_managed": True,
+            "last_health": {"ok": True},
+        }
+    except Exception:
+        # Fail open: never let the probe break the status endpoint.
+        return None
+
+
 # =============================================================================
 # Docker-compose app-runner discovery
 #
@@ -9191,6 +9338,10 @@ async def get_app_runner_status():
         discovered = await asyncio.to_thread(_discover_compose_app_runner_state)
         if discovered is not None:
             return discovered
+        # No state.json at all and no compose stack: there is no recorded port to
+        # probe, so the single-process probe can only ever return an honest
+        # "unknown" here. Keep returning not_initialized (the project has never
+        # had an app-runner record) rather than overstating with "unknown".
         return {"status": "not_initialized"}
 
     try:
@@ -9208,6 +9359,14 @@ async def get_app_runner_status():
     discovered = await asyncio.to_thread(_discover_compose_app_runner_state)
     if discovered is not None:
         return discovered
+
+    # Still nothing from compose: a SKILL/CLI-built project may be serving on its
+    # recorded port even though no live app-runner.sh process owns it (main_pid 0
+    # / orchestrator exited). Probe the RECORDED port and only report running when
+    # the port genuinely answers; otherwise keep the honest reconciled state.
+    probed = await asyncio.to_thread(_discover_single_process_app_runner_state, state)
+    if isinstance(probed, dict) and probed.get("status") == "running":
+        return probed
     return reconciled