loki-mode 7.2.0 → 7.4.8

package/README.md

@@ -49,6 +49,45 @@ Or skip scaffolding and go straight to a quick task:
 loki quick "build a landing page with a signup form"
 ```
 
+---
+
+## Runtime Architecture
+
+Loki Mode is in the middle of a phased migration from a Bash-based runtime to a TypeScript/Bun runtime. The work is happening on the `feat/bun-migration` branch and is being shipped incrementally.
+
+**What ships today:**
+
+- A small set of read-only commands is routed to the Bun runtime when `bun` is on `PATH`. The router lives in `bin/loki` and currently routes: `version`, `--version`, `-v`, `status`, `stats`, `doctor`, `provider` (covers `provider show` and `provider list`), `memory` (covers `memory list` and `memory index`).
+- Every other command continues to execute on the existing Bash CLI (`autonomy/loki`).
+- If `bun` is not on `PATH`, the shim falls through to Bash silently. Existing users without Bun installed see no behavior change.
+
+**Rollback flag:**
+
+Force every command to take the legacy Bash path:
+
+```bash
+LOKI_LEGACY_BASH=1 loki <cmd>
+```
+
+This is the documented escape hatch for any user who hits a regression on the Bun route. The Bash path remains the source of truth through Phase 5.
+
+**Phase 6 (planned, calendar TBD):**
+
+The next major release sunsets the Bash runtime entirely. There is no firm calendar date. Users who need to stay on the Bash route should pin the last v7.x release.
+
+**Cost:**
+
+- Adds a Bun runtime dependency (Bun 1.3.0 or newer recommended; the shim works as long as `bun` resolves).
+- Adds a Bun toolchain to the system (Bun itself is roughly 50 MB installed via `brew install` or the official curl installer). The published `loki-ts/dist/loki.js` bundle inside the npm tarball is approximately 152 KB.
+- Speedup on the ported commands is measured in `.loki/metrics/migration_bench_soak.jsonl` and analysed in [ADR-001](docs/architecture/ADR-001-runtime-migration.md). Recorded soak results show roughly 3x to 5x faster execution on the ported commands (per-command range 2.9x to 5.0x); treat as indicative, not contractual.
+
+**More:**
+
+- [UPGRADING.md](UPGRADING.md) -- per-version upgrade and rollback guidance.
+- [ADR-001: Runtime Migration](docs/architecture/ADR-001-runtime-migration.md) -- design rationale and phase definitions.
+
+---
+
 <details>
 <summary><strong>Other install methods</strong></summary>
 

package/SKILL.md

@@ -3,12 +3,14 @@ name: loki-mode
 description: Multi-agent autonomous startup system. Triggers on "Loki Mode". Takes PRD to deployed product with minimal human intervention. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v7.2.0
+# Loki Mode v7.4.8
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
 **New in v5.0.0:** Multi-provider support (Claude/Codex/Gemini/Cline/Aider), abstract model tiers, degraded mode for non-Claude providers. See `skills/providers.md`.
 
+**Runtime migration in progress:** A bash-to-Bun migration is underway on the `feat/bun-migration` branch. The first phase (shipped in v7.3.0) routes a small set of read-only commands -- `version`, `status`, `stats`, `doctor`, `provider show/list`, `memory list/index` -- through a Bun runtime via `bin/loki`. Every other command remains on the Bash runtime (`autonomy/loki`). Rollback is available with `LOKI_LEGACY_BASH=1`. See `UPGRADING.md` and `docs/architecture/ADR-001-runtime-migration.md` for the full plan.
+
 ---
 
 ## PRIORITY 1: Load Context (Every Turn)
@@ -320,4 +322,4 @@ The following features are documented in skill modules but not yet fully automat
 | Quality gates 3-reviewer system | Implemented (v5.35.0) | 5 specialist reviewers in `skills/quality-gates.md`; execution in run.sh |
 | Benchmarks (HumanEval, SWE-bench) | Infrastructure only | Runner scripts and datasets exist in `benchmarks/`; no published results |
 
-**v7.2.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v7.4.8 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-7.2.0
+7.4.8

package/autonomy/loki

@@ -31,6 +31,13 @@ BOLD='\033[1m'
 DIM='\033[2m'
 NC='\033[0m'
 
+# v7.4.5 (BUG-15 bash route): honor NO_COLOR convention (https://no-color.org/)
+# Mirrors the equivalent fix in loki-ts/src/util/colors.ts. Required for parity
+# when the shim falls through to the bash route (e.g., when bun is missing).
+if [ -n "${NO_COLOR:-}" ]; then
+    RED=''; GREEN=''; YELLOW=''; BLUE=''; CYAN=''; BOLD=''; DIM=''; NC=''
+fi
+
 # Logging functions (portable across bash/zsh)
 log_info()  { echo -e "${GREEN}[INFO]${NC} $*"; }
 log_error() { echo -e "${RED}[ERROR]${NC} $*"; }
@@ -2529,7 +2536,8 @@ if reviews_total > 0:
 if gate_failures:
     failure_parts = [f'{k} ({v})' for k, v in gate_failures.items() if v > 0]
     if failure_parts:
-        print(f'  Gate failures: {', '.join(failure_parts)}')
+        sep = ', '
+        print(f'  Gate failures: {sep.join(failure_parts)}')
 print()
 
 # Efficiency

package/bin/loki

@@ -0,0 +1,87 @@
+#!/usr/bin/env bash
+#===============================================================================
+# Loki Mode shim
+#
+# Routes commands ported in Phase 2 (bash->Bun migration) to the Bun CLI;
+# everything else falls through to autonomy/loki (bash).
+#
+# Set LOKI_LEGACY_BASH=1 to force bash for every command (rollback flag).
+# See docs/architecture/ADR-001-runtime-migration.md and
+# /Users/lokesh/.claude/plans/polished-waddling-stardust.md.
+#===============================================================================
+set -euo pipefail
+
+# Resolve script directory (handles symlinks like the bash CLI does).
+_resolve_path() {
+    local script="$1"
+    if command -v realpath &>/dev/null; then
+        realpath "$script" 2>/dev/null || echo "$script"
+    else
+        while [ -L "$script" ]; do
+            local dir
+            dir=$(dirname "$script")
+            script=$(readlink "$script")
+            [[ "$script" != /* ]] && script="$dir/$script"
+        done
+        echo "$script"
+    fi
+}
+
+SCRIPT_PATH=$(_resolve_path "$0")
+SCRIPT_DIR=$(dirname "$SCRIPT_PATH")
+REPO_ROOT=$(cd "$SCRIPT_DIR/.." 2>/dev/null && pwd)
+BASH_CLI="$REPO_ROOT/autonomy/loki"
+
+# Resolve which Bun entry to use:
+#   1. LOKI_TS_ENTRY=...   -- explicit override (custom builds, tests)
+#   2. BUN_FROM_SOURCE=1   -- prefer src/cli.ts (used by bench --compare-dist
+#                             and during Phase 3 development before dist ships)
+#   3. dist/loki.js exists -- production path (npm/Docker/Homebrew artifact)
+#   4. fall back to src    -- in-repo development before first build
+#
+# v7.4.2 fix (BUG-1): BUN_FROM_SOURCE=1 used to hard-fail on npm/Docker/brew
+# installs because src/ is excluded by .npmignore. Now we warn once and fall
+# back to dist if src/cli.ts is missing.
+if [ -n "${LOKI_TS_ENTRY:-}" ]; then
+    BUN_CLI="$LOKI_TS_ENTRY"
+elif [ "${BUN_FROM_SOURCE:-0}" = "1" ] || [ "${BUN_FROM_SOURCE:-}" = "true" ]; then
+    if [ -f "$REPO_ROOT/loki-ts/src/cli.ts" ]; then
+        BUN_CLI="$REPO_ROOT/loki-ts/src/cli.ts"
+    elif [ -f "$REPO_ROOT/loki-ts/dist/loki.js" ]; then
+        echo "WARN: BUN_FROM_SOURCE set but loki-ts/src/cli.ts missing (typical for npm/Docker/brew installs); using dist/loki.js" >&2
+        BUN_CLI="$REPO_ROOT/loki-ts/dist/loki.js"
+    else
+        echo "ERROR: BUN_FROM_SOURCE set but neither src/cli.ts nor dist/loki.js found; falling through to bash" >&2
+        exec "$BASH_CLI" "$@"
+    fi
+elif [ -f "$REPO_ROOT/loki-ts/dist/loki.js" ]; then
+    BUN_CLI="$REPO_ROOT/loki-ts/dist/loki.js"
+elif [ -f "$REPO_ROOT/loki-ts/src/cli.ts" ]; then
+    BUN_CLI="$REPO_ROOT/loki-ts/src/cli.ts"
+else
+    # Neither dist nor src available; fall through to bash silently.
+    exec "$BASH_CLI" "$@"
+fi
+
+# Force-fall-through to bash when the rollback flag is set.
+if [ "${LOKI_LEGACY_BASH:-0}" = "1" ] || [ "${LOKI_LEGACY_BASH:-}" = "true" ]; then
+    exec "$BASH_CLI" "$@"
+fi
+
+# Bun must be installed for the new path; if it isn't, fall through to bash
+# silently rather than fail. This keeps users on systems without Bun working.
+if ! command -v bun &>/dev/null; then
+    exec "$BASH_CLI" "$@"
+fi
+
+# Commands ported in Phase 2 -- route to Bun. Everything else goes to bash.
+# Two-token routes (provider show/list, memory list/index) match on the first
+# token only; the Bun dispatcher handles subcommand routing internally.
+case "${1:-}" in
+    version|--version|-v|status|stats|doctor|provider|memory)
+        exec bun "$BUN_CLI" "$@"
+        ;;
+    *)
+        exec "$BASH_CLI" "$@"
+        ;;
+esac

package/bin/loki-mode.js

@@ -1,17 +1,22 @@
 #!/usr/bin/env node
 /**
- * Loki Mode CLI wrapper for npm distribution
- * Delegates to the bash CLI
+ * Loki Mode npm wrapper.
+ *
+ * Delegates to bin/loki (the runtime-aware shim) so that ported commands
+ * route through the Bun runtime when bun is on PATH and unported commands
+ * fall through to autonomy/loki (bash). Pre-v7.4.7 this script bypassed
+ * the shim and went straight to bash, which silently disabled the Bun
+ * route for users invoking the `loki-mode` binary instead of `loki`.
  */
 
 const { spawn } = require('child_process');
 const path = require('path');
 
-const lokiScript = path.join(__dirname, '..', 'autonomy', 'loki');
+const shim = path.join(__dirname, 'loki');
 const args = process.argv.slice(2);
 
-const child = spawn(lokiScript, args, {
-  stdio: 'inherit'
+const child = spawn(shim, args, {
+  stdio: 'inherit',
 });
 
 child.on('close', (code) => {
@@ -20,6 +25,6 @@ child.on('close', (code) => {
 
 child.on('error', (err) => {
   console.error('Error running loki:', err.message);
-  console.error('Make sure bash is available on your system');
+  console.error('Make sure bash is available on your system (bin/loki shim requires /bin/bash).');
   process.exit(1);
 });

package/dashboard/__init__.py

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

package/docs/ARM64-VERIFICATION.md

@@ -0,0 +1,76 @@
+# ARM64 Image Verification
+
+This document describes the manual procedure to verify that a published `asklokesh/loki-mode` Docker image actually runs on a real ARM64 host. CI does not exercise the runtime on ARM64; see `docs/UNREACHABLE-TESTS.md` for the rationale.
+
+This procedure should be run by a maintainer (or any contributor with an ARM64 host) after each release that bumps the published image tag.
+
+---
+
+## Prerequisites
+
+- An ARM64 host. Examples:
+  - Apple Silicon Mac (M1, M2, M3, or M4).
+  - AWS Graviton instance.
+  - Raspberry Pi 4 or 5 with a 64-bit OS.
+- Docker Engine or Docker Desktop installed and running.
+- Network access to Docker Hub.
+
+Confirm the host is genuinely ARM64:
+
+```bash
+uname -m
+# expected output: arm64 (macOS) or aarch64 (Linux)
+```
+
+If the output is anything else (`x86_64`, `amd64`), this procedure does not apply -- you need an ARM64 host.
+
+---
+
+## Procedure
+
+Replace `7.X.Y` with the tag you intend to verify.
+
+```bash
+docker run --rm --platform linux/arm64 asklokesh/loki-mode:7.X.Y loki version
+```
+
+The `--platform linux/arm64` flag forces Docker to pull the ARM64 variant of the manifest list even if a multi-arch image is being served. This catches the case where the image was published as x86_64-only by accident.
+
+### Expected output
+
+The command prints the version string of the bundled CLI and exits 0. The exact format follows the bash CLI's `version` command. A non-zero exit, a Python or Bun runtime error, or a missing-binary error all indicate a broken ARM64 build.
+
+### Additional smoke checks
+
+Run a few more commands to surface ARM64-specific runtime issues:
+
+```bash
+docker run --rm --platform linux/arm64 asklokesh/loki-mode:7.X.Y loki doctor
+docker run --rm --platform linux/arm64 asklokesh/loki-mode:7.X.Y loki status
+```
+
+`loki doctor` prints the runtime environment summary (Bun version, Python version, provider CLIs detected). On the published image, the absence of any provider CLI is expected; the doctor command itself should still complete without an internal error.
+
+`loki status` reads `.loki/` state. With no mounted state directory, it should report `stopped` or an equivalent empty state -- not crash.
+
+---
+
+## Recording the result
+
+When verification passes, note it in the release commit body or in the GitHub Release notes under a "Verified channels" section. Include:
+
+- Host architecture (`uname -m` output)
+- Host OS (`uname -s` plus distribution if Linux)
+- Docker version (`docker --version`)
+- Image tag verified
+- Date of verification
+
+When verification fails, open an issue with the same details plus the full output of the failing command. Do not promote the release to "stable" until the failure is fixed.
+
+---
+
+## Why this is manual
+
+The `parity-drift.yml` and image-publish workflows use `buildx` with QEMU emulation, which produces a multi-arch manifest but does not exercise the runtime on real ARM64 silicon. QEMU translation can mask runtime issues that only surface on real hardware (for example, native binary dependencies, mmap layout differences, or timing-sensitive code).
+
+Until the project provisions an ARM64 self-hosted runner, this manual procedure is the only honest verification.

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 The flagship product of [Autonomi](https://www.autonomi.dev/). Complete installation instructions for all platforms and use cases.
 
-**Version:** v7.2.0
+**Version:** v7.4.8
 
 ---
 
@@ -91,6 +91,26 @@ loki setup-skill
 
 ---
 
+## PyPI / Python SDK
+
+**The `loki` CLI is NOT available via `pip install loki-mode`.** PyPI hosts only the
+Python REST client SDK at `loki-mode-sdk` (v7.4.8+). The dashboard, MCP server,
+and orchestrator components ship via npm, Docker, and Homebrew only.
+
+```bash
+# Install the Python REST client only
+pip install loki-mode-sdk
+
+# Install the full CLI (recommended)
+npm install -g loki-mode  # or: brew tap asklokesh/tap && brew install loki-mode
+```
+
+The naming asymmetry (`loki-mode` on npm vs `loki-mode-sdk` on PyPI) is
+intentional: PyPI's `loki-mode` namespace is reserved for a future server
+package, while `loki-mode-sdk` is the thin client.
+
+---
+
 ## Quick Start
 
 ```bash

package/docs/SLO.md

@@ -0,0 +1,52 @@
+# Service Level Objectives
+
+This document records baseline targets for the user-visible behavior of the CLI and the runner. These are honest first-pass targets. **No SLI/SLO infrastructure is shipped yet.** Tracking is manual, via the parity-drift workflow and soak-window observation.
+
+The targets below should be treated as goals, not contracts. They will be revised as measurement infrastructure is built out.
+
+---
+
+## Latency
+
+| Command | Route | p99 target | Source of measurement |
+|---------|-------|------------|----------------------|
+| `loki version` | Bun | < 100 ms | `.loki/metrics/migration_bench_soak.jsonl` (recorded p95 ~30 ms; p99 not recorded but headroom is large) |
+| `loki version` | Bash | < 200 ms | `.loki/metrics/migration_bench_soak.jsonl` (recorded p95 ~141 ms) |
+| `loki status` | either route | < 500 ms | not currently measured in CI; manual observation only |
+
+**Caveats:**
+
+- The soak file records p50 and p95, not p99. The p99 targets above assume modest tail behavior on top of the recorded p95. They should be tightened or loosened once a proper p99 measurement is in place.
+- All numbers are wall-clock cold starts measured via `hyperfine` on developer hardware. Latency on slower machines (low-end CI runners, ARM64 emulated, containers under heavy load) will be worse.
+
+---
+
+## Parity
+
+| Property | Target | Measurement |
+|----------|--------|-------------|
+| Byte-divergence between Bash and Bun routes for the ported commands | 0 divergences | `parity-drift.yml` workflow runs the Bun and Bash routes side by side; any non-empty diff fails the job |
+
+The eight commands currently in scope: `version`, `status`, `stats`, `doctor`, `provider show`, `provider list`, `memory list`, `memory index`.
+
+---
+
+## Reliability
+
+| Metric | Target | Status |
+|--------|--------|--------|
+| `loki start` completion rate on standard PRDs | 99% | aspirational; no automated measurement yet |
+| Dashboard availability when invoked from `loki start` | 99.9% per session | aspirational; no automated measurement yet |
+| Pre-publish tarball validation pass rate before any release | 100% | enforced manually per `CLAUDE.md` "Pre-Publish Validation"; failure blocks release |
+
+The reliability numbers above are explicitly aspirational. The system does not currently emit a "completion / non-completion" signal that could be aggregated into a reliability number across users. The 99% target represents what the maintainer wants to be true, not what is currently measured.
+
+---
+
+## Notes on measurement
+
+- The only continuous SLI shipping today is the parity-drift workflow.
+- Latency measurements are recorded in `.loki/metrics/migration_bench_soak.jsonl` when a benchmark run is performed; they are not collected continuously.
+- Reliability is tracked by manual review during the v7.3.0 soak window.
+
+These are baseline targets. They will be revised when SLI/SLO infrastructure ships.

package/docs/UNREACHABLE-TESTS.md

@@ -0,0 +1,123 @@
+# Unreachable Tests
+
+This document is an honest log of test scenarios that the project cannot exercise in CI today, why each one is blocked, and what (if anything) substitutes for the missing coverage.
+
+The intent is to keep this list short and embarrassing so the gaps stay visible. If a row here can be closed, close it.
+
+---
+
+## Real Claude / Codex / Gemini API calls
+
+**What we cannot test in CI:** end-to-end runs that actually invoke a hosted Claude, OpenAI Codex, or Google Gemini agent loop with real credentials.
+
+**Blocker:**
+
+- Per-call cost. A full PRD run can rack up double-digit dollars per provider; running on every PR is not affordable.
+- Auth. Storing real provider tokens in CI gives any contributor on a fork-PR an attack surface to exfiltrate them. We do not pass secrets to fork PRs by policy.
+- Agent-loop safety. A real provider call has full tool-use authority and can take destructive actions (file writes, shell commands) that are unsafe to run unattended in CI.
+
+**Manual procedure that closes the gap:**
+
+Run the relevant `tests/integration/` script locally with real credentials in a sandbox container or VM.
+
+**Partial substitute we ship:**
+
+- Provider loader unit tests under `tests/test-provider-loader.sh` cover flag selection, model name mapping, and fallback wiring without invoking the provider.
+- The Bun test suite uses recorded fixtures for `build_prompt` and the runner state machine.
+
+---
+
+## Windows runtime
+
+**What we cannot test in CI:** Loki Mode running natively on Windows (PowerShell or cmd, or Windows-native bash).
+
+**Blocker:** No Windows host in the CI pool. The runtime relies heavily on POSIX bash semantics; Windows bash via WSL is the only realistic path and we have not provisioned a runner for it.
+
+**Manual procedure that closes the gap:**
+
+Install on a Windows host with WSL2 + Ubuntu, run `loki doctor` and the smoke commands, file an issue with the output. Document any divergence in `docs/PLATFORM-SUPPORT.md` (file does not exist yet -- create it on first finding).
+
+**Partial substitute we ship:**
+
+None. Windows is not a supported platform today.
+
+---
+
+## Real ARM64 runtime
+
+**What we cannot test in CI:** the published Docker image actually starting up and answering `loki version` on a real ARM64 host.
+
+**Blocker:** GitHub Actions provides ARM64 emulation via QEMU under buildx, but we do not have an ARM64 runner in the pool. Buildx can produce the image; it cannot meaningfully exercise the runtime.
+
+**Manual procedure that closes the gap:**
+
+See `docs/ARM64-VERIFICATION.md` for the manual verification procedure on an Apple Silicon Mac or another ARM64 host.
+
+**Partial substitute we ship:**
+
+- `buildx` produces the multi-arch image and verifies the build does not fail.
+- The same TypeScript/Bun runtime ships unchanged across architectures, so x86_64 unit tests cover most of the runtime logic.
+
+---
+
+## Real PRD end-to-end
+
+**What we cannot test in CI:** a real PRD running through the full RARV loop to completion, with provider calls, code generation, tests, and deploy artifacts.
+
+**Blocker:**
+
+- Cost (see "Real Claude / Codex / Gemini API calls" above).
+- Nondeterminism. The provider's output varies, so an end-to-end pass/fail signal is noisy.
+- Wall-clock duration. A standard PRD takes 30-90 minutes; CI runners time out long before.
+
+**Manual procedure that closes the gap:**
+
+Maintainer runs the templated PRDs under `templates/` against the current build before a release and inspects the output. This is captured in the release checklist informally.
+
+**Partial substitute we ship:**
+
+- Unit tests against recorded provider outputs for the prompt builder and council voter.
+- Smoke tests of the runner state machine that exercise every phase transition without invoking a provider.
+
+---
+
+## 1-hour-plus stress runs
+
+**What we cannot test in CI:** sessions that run for an hour or more to surface memory leaks, file-descriptor leaks, or queue churn under sustained load.
+
+**Blocker:** GitHub-hosted runner minutes. A one-hour test on every PR would consume the project's monthly minute allocation in a few days.
+
+**Manual procedure that closes the gap:**
+
+Run `./benchmarks/run-benchmarks.sh` on a self-hosted machine for the full duration and capture process metrics with `ps`/`top` / a simple sampling script. Record findings under `.loki/metrics/`.
+
+**Partial substitute we ship:**
+
+- The completion council circuit breaker and budget breaker are unit-tested for trigger logic.
+- The dashboard tracks per-iteration cost and context usage; large regressions show up in `.loki/metrics/efficiency/`.
+
+---
+
+## Brew install via the real tap
+
+**What we cannot test in CI:** `brew tap asklokesh/tap && brew install loki-mode` against the real tap and a real macOS host.
+
+**Blocker:**
+
+- Running `brew install` on a CI runner mutates the runner's Homebrew prefix. This interferes with subsequent jobs on the same runner (GitHub-hosted runners are ephemeral, but the side effects still apply for the remainder of the job).
+- Cross-tap mutation in CI risks accidentally publishing a broken formula if the install path is reused for verification.
+
+**Manual procedure that closes the gap:**
+
+Maintainer runs the brew install on a clean macOS host (or a fresh VM) after every release and checks `loki version` plus a smoke command. Verification is captured in the release checklist.
+
+**Partial substitute we ship:**
+
+- The `homebrew-tap` repository's CI lints the formula on every update.
+- Tarball validation in `CLAUDE.md` "Pre-Publish Validation" exercises the npm path, which shares most of the same artifacts.
+
+---
+
+## How to use this document
+
+When you discover a new untestable scenario, add it here. When you close a gap, remove the row. Keep the document short.

package/docs/architecture/ADR-001-runtime-migration.md

@@ -0,0 +1,229 @@
+# ADR-001: Migrate Loki orchestrator off bash
+
+**Status:** Proposed (feature/bun-migration branch)
+**Date:** 2026-04-25
+**Decision driver:** `autonomy/run.sh` is 11,327 lines of bash and `autonomy/loki` is 22,304 lines. Both are fragile, hard to refactor, untyped, and the upstream RARV-C audit (v6.81 plan) flagged them as the single biggest architectural debt.
+
+## Context: facts the user asked me to verify
+
+### 1. Did Anthropic acquire Bun?
+
+**YES, verified.** Anthropic acquired Bun (Oven, Inc.) in December 2025. Bun remains MIT-licensed and open-source. Anthropic is positioning Bun as the runtime infrastructure for Claude Code, the Claude Agent SDK, and future AI coding products.
+
+Sources:
+- [Bun Blog: Bun is joining Anthropic](https://bun.com/blog/bun-joins-anthropic)
+- [Anthropic: Anthropic acquires Bun as Claude Code reaches $1B milestone](https://www.anthropic.com/news/anthropic-acquires-bun-as-claude-code-reaches-usd1b-milestone)
+
+### 2. Is Bun faster than bash for our workload?
+
+**Two-layer answer with REAL benchmarks.**
+
+#### Layer 1: trivial hello-world cold start (hyperfine, 100 runs)
+
+| Runtime | Cold start mean | vs bash |
+|---|---|---|
+| **Go binary** (compiled) | **1.8 ms** | **2.5x faster** |
+| **bash hello-world** | **4.5 ms** | baseline |
+| **Bun binary** (`bun build --compile`) | 6.9 ms | 1.5x slower |
+| **Bun script** (`bun foo.ts`) | 7.6 ms | 1.7x slower |
+| **Python3 script** | 20.3 ms | 4.5x slower |
+| **Node.js script** | 45.2 ms | 10x slower |
+
+For a trivial 1-line script, bash beats Bun by ~3 ms.
+
+#### Layer 2: real Loki workload (50 runs, side-by-side, scripts/bench.ts)
+
+| Runtime | `loki version` mean | vs bash |
+|---|---|---|
+| **bash autonomy/loki version** | **106.71 ms** (min 96.54, max 125.35) | baseline |
+| **bun loki-ts/src/cli.ts version** | **12.36 ms** (min 11.63, max 13.52) | **8.63x FASTER** |
+
+**This is the finding that flips the analysis.** When the bash script is 22,304 lines (the actual `autonomy/loki`), bash re-parses the entire AST every invocation. That parse cost dwarfs Bun's runtime startup cost by ~10x. **Bun is 8.6x faster than actual Loki bash.**
+
+The user's premise ("Bun is faster than bash, no speed compromise") is correct for actual Loki workloads, even though it's false for hello-world.
+
+**Why the gap:** bash has no bytecode cache. Every `loki version` invocation re-parses 22k lines of shell. Bun parses TypeScript once at install (or even at compile time with `--compile`), then executes machine code. The asymmetry grows with script size:
+
+| Script size | Bash startup | Bun startup |
+|---|---|---|
+| 1 line | 4.5 ms | 7.6 ms (1.7x slower) |
+| 22,304 lines (real `autonomy/loki`) | 106.71 ms | 12.36 ms (**8.63x FASTER**) |
+
+So: **for hello-world bash wins; for our actual codebase Bun wins decisively, by an order of magnitude.**
+
+### 3. What about the npm distribution requirement?
+
+User constraint: "people use npm, I want to keep it the same way."
+
+| Runtime | npm distribution path | Complexity |
+|---|---|---|
+| **Bash** (today) | `package.json` `bin` field points to shell script | Trivial; current state |
+| **Bun runtime** | `npm install -g loki-mode` ships TS, requires Bun installed via `npm install -g bun` (peer) OR Bun standalone in postinstall | Medium; peer dependency convention |
+| **Bun compiled binary** | `bun build --compile` → 60 MB binary per platform; npm postinstall downloads correct binary (esbuild model) | Medium; per-platform binaries |
+| **Go binary** | Same model as Bun compiled — npm postinstall downloads platform binary (esbuild, biome, vite-rust, swc all use this) | Medium; mature pattern |
+| **Python** | npm postinstall would shell out to `pip install` or bundle Python — fragile, two package managers | High; do not recommend |
+| **Node.js** | Native — no postinstall needed | Trivial; but Node is 10x slower than bash on cold start |
+
+All three viable options (Bun runtime, Bun compiled, Go binary) keep the `npm install -g loki-mode` UX. Users see no change.
+
+## Three options, honestly compared
+
+### Option A: Go
+
+**Pro:**
+- **Only language that strictly beats bash.** 2.5x faster cold-start (1.8 ms vs 4.5 ms). User's "no speed compromise" requirement is met without caveats.
+- Single static binary, ~2.4 MB (vs 60 MB Bun binary).
+- Mature CLI ecosystem (Docker, kubectl, Terraform, Helm all use Go).
+- Strict typing prevents whole class of bash quoting bugs.
+- Cross-compile to all platforms from any platform.
+
+**Con:**
+- Loki team has zero Go in the codebase today.
+- Anthropic does NOT own Go; less strategic alignment.
+- Rewriting 33,000+ lines of bash to idiomatic Go is a 3-6 month effort.
+- Goroutines/channels are different mental model than bash + Python orchestration.
+
+**Distribution via npm:** Same pattern as esbuild — npm postinstall downloads the right platform binary. Mature, ~5 MB compressed per arch.
+
+### Option B: Bun runtime + TypeScript
+
+**Pro:**
+- **Anthropic owns Bun.** Strategic alignment with the company that owns the model we depend on.
+- Native shell built in (`Bun.$\`echo hello\``) — minimal friction porting bash idioms.
+- Bun's `npm install` is 20-40x faster than npm — every CI run faster.
+- TypeScript: types catch bugs bash can't.
+- Anthropic-funded development means Bun improvements specifically target AI agent workloads.
+- 98% Node.js compatibility — npm packages work directly.
+
+**Con:**
+- **1.7x SLOWER than bash on trivial cold-start** (7.6 ms vs 4.5 ms). The user explicitly said "no speed compromise". This is a genuine compromise, even if 3 ms is humanly invisible.
+- Bun runtime must be installed separately OR shipped via postinstall (60 MB if compiled).
+- Less mature than Node (Bun 1.3 in 2026; some npm packages still hit edge cases).
+
+**Distribution via npm:** Either (a) declare Bun as a peer dep and prompt user `npm install -g bun`; (b) ship `--compile` binary via postinstall.
+
+### Option C: Hybrid (recommended)
+
+**Pro:**
+- Keep tiny scripts in bash (where it wins by 3 ms): `loki version`, `loki status`, anything <100 LOC.
+- Migrate the 11k-line orchestrator (`run.sh`) and 22k-line CLI (`autonomy/loki`) to Bun TypeScript — where compiled+typed wins.
+- Keep `memory/`, `providers/`, `mcp/` in Python — they're already mature, no reason to rewrite.
+- Anthropic alignment via Bun for the parts that matter.
+- No speed regression for trivial commands; large gains for orchestrator.
+
+**Con:**
+- Three runtimes in the codebase (bash + Bun + Python) — operational complexity.
+- Cross-runtime debugging harder than monorepo.
+
+**Distribution:** Bun shipped via npm postinstall as compiled binary; bash remains as-is; Python unchanged.
+
+## Recommendation
+
+**Option B (Bun runtime + TypeScript) — full migration, not hybrid.**
+
+Reasons:
+
+1. **The Layer 2 benchmark inverts the speed argument.** Bun is 8.6x FASTER than actual Loki bash because `autonomy/loki` is 22,304 lines that re-parse every invocation. The user's "no speed compromise" rule is met decisively, with margin.
+2. **Anthropic strategic alignment.** Anthropic owns Bun. Loki uses Claude. Aligning runtime and model owner reduces dependency-versioning friction over time.
+3. **TypeScript pays the maintainability dividend** that 33k lines of bash will never deliver. Type checking catches whole classes of bugs (the kind we hit in v6.81-v7.2 cycles).
+4. **Hybrid is now harder to justify.** When bash loses by 8.6x on the actual workload, keeping it for 3 ms theoretical wins on hello-world is bad engineering.
+5. **Go would still be 2-4x faster than Bun** in absolute cold-start, but: zero existing Go in the codebase, no Anthropic alignment, larger rewrite cost, no JS ecosystem reuse. Unless Loki specifically targets the sub-millisecond CLI category (which it doesn't — every command runs in a multi-second/minute autonomous loop), the absolute speed delta doesn't justify the strategic cost.
+
+**If user explicitly wants the absolute fastest:** Go (Option A) is 2.5x faster than Bun. But for orchestrator-heavy work where most time is spent waiting on Claude API calls, the difference is invisible.
+
+## Migration plan (Option C)
+
+### Phase 1: Scaffold (this branch, no behavior change)
+- Create `loki-ts/` directory parallel to `autonomy/`
+- `package.json` with Bun as engine, TypeScript config
+- Port ONE simple command: `loki ts-version` (proves the toolchain) 
+- Add Bun to CI matrix (alongside existing Node/Python)
+- **No user-visible change.** All existing commands route to bash.
+
+### Phase 2: Sub-commands
+- Migrate read-only commands: `loki provider show`, `loki status`, `loki stats`, `loki memory list`
+- Each migrated command goes through `loki-ts/` with bash as fallback flag
+- Performance benchmark each: must be ≤ 2x bash cold start
+
+### Phase 3: Build/release tooling
+- Replace npm publish with `bun publish` in CI
+- Replace dashboard-ui esbuild with `bun build` (already 4-5x faster)
+- Replace pytest where possible with `bun test` for non-Python tests
+- Measure: full CI wall time, npm install time
+
+### Phase 4: build_prompt + RARV-C migration
+- Port `build_prompt` (the 360-line bash function) to TypeScript
+- Port `run_autonomous` outer loop
+- Keep all Python subprocess invocations untouched (they're already fine)
+- Side-by-side validation: same prompt output character-by-character
+- Fallback flag: `LOKI_LEGACY_BASH=true` reverts
+
+### Phase 5: completion-council + code-review
+- Port `council_should_stop` and `run_code_review` to TypeScript
+- Same validation discipline
+
+### Phase 6: Sunset bash (only after 30 days clean in production)
+- Remove `LOKI_LEGACY_BASH` flag
+- Delete `autonomy/run.sh` and `autonomy/loki` (keep in git history)
+- Bash → Bun migration complete
+
+## What we can do better for releases (Anthropic owns Bun → leverage)
+
+| Today | Tomorrow | Win |
+|---|---|---|
+| `npm publish` (45-60 sec) | `bun publish` | ~5x faster CI publish |
+| `npm install -g loki-mode` for users | Same UX, `bun install` under the hood when available | 20-40x faster install (verified) |
+| Tests via `npm test` (Node 20-25 sec) | `bun test` for non-Python | ~10x faster test runs |
+| Dashboard build with esbuild (122 ms) | `bun build` | 2-4x faster |
+| Per-iteration cold start in run.sh: bash 4.5ms × N | Compiled Bun start once, run 100s | Net negative if iteration count low; net positive for sessions >5 iterations |
+| Python `mcp/server.py` | Stays Python (already good) | No change |
+
+## Risks I'm not hiding
+
+1. **Migration drift:** TS port may behave subtly differently from bash. Mitigation: side-by-side test harness comparing outputs.
+2. **Bun beta-feature churn:** Even though Bun 1.3 is stable, Anthropic may push it in directions that break us. Mitigation: pin Bun version in `package.json` engines.
+3. **60 MB binary** if we ship `--compile`. Half a Loki Docker image. Mitigation: ship runtime peer dep instead of compiled binary in v8.
+4. **Three-runtime codebase** is real cognitive overhead for new contributors. Mitigation: clear `CONTRIBUTING.md` table of "what runtime owns what."
+5. **Bun's npm shipping pattern** is less proven than Go's. Mitigation: keep npm registry as primary distribution; add Homebrew (already exists) as a Bun-bundled alternative.
+
+## Concrete next steps if approved
+
+1. Scaffold `loki-ts/` with `package.json`, `tsconfig.json`, `src/cli.ts` (this PR)
+2. Port `cmd_version` to `loki-ts/src/commands/version.ts` (proof of concept)
+3. Add `bun-test.yml` GitHub workflow alongside existing `test.yml`
+4. Set acceptance criteria: every Phase 2+ command must benchmark within 2x of bash cold-start AND be type-checked via `bun typecheck`
+5. Ship Phase 1 as v8.0.0-alpha.1 (pre-release, opt-in) — does not affect default users
+
+---
+
+## Appendix: real benchmark data captured on this machine
+
+Hyperfine 100 runs, 5 warmup, hello-world equivalent:
+
+```
+bash /tmp/loki-bench-bash.sh         4.5 ± 0.4 ms     baseline
+bun-compiled-binary                  6.9 ± 0.4 ms     1.53x slower
+bun /tmp/loki-bench-bun.ts          7.6 ± 0.4 ms     1.69x slower
+node /tmp/loki-bench-node.js        45.2 ± 1.0 ms    10.04x slower
+python3 /tmp/loki-bench-py.py       20.3 ± 0.5 ms    4.51x slower
+go-compiled-binary                  1.8 ± 0.3 ms     2.5x FASTER
+```
+
+Local versions:
+- bash 5.x (macOS shipped /bin/bash 3.2 + brew bash)
+- Bun 1.3.13
+- Node v25.9.0
+- Python 3.x
+- Go 1.26.1
+
+These are real numbers from this exact Mac, not from a vendor blog. Run hyperfine yourself to reproduce.
+
+**Layer 2** (real Loki workload, 50 runs via `loki-ts/scripts/bench.ts`):
+```
+bash autonomy/loki version             106.71 ms (min 96.54, max 125.35)
+bun loki-ts/src/cli.ts version          12.36 ms (min 11.63, max 13.52)
+
+bun is 8.63x FASTER than bash on the actual Loki entry point
+```
+
+The 22,304-line `autonomy/loki` re-parses every invocation. Bun parses TS once, executes machine code thereafter. The asymmetry is the core argument for migration.

package/loki-ts/dist/loki.js

@@ -0,0 +1,341 @@
+// @bun
+var Q0=Object.defineProperty;var X0=(z)=>z;function Z0(z,Q){this[z]=X0.bind(null,Q)}var r=(z,Q)=>{for(var $ in Q)Q0(z,$,{get:Q[$],enumerable:!0,configurable:!0,set:Z0.bind(Q,$)})};var g=(z,Q)=>()=>(z&&(Q=z(z=0)),Q);var K0=import.meta.require;var P1={};r(P1,{lokiDir:()=>E,homeLokiDir:()=>B1,findSkillDir:()=>B0,findRepoRootForVersion:()=>W1,REPO_ROOT:()=>y});import{resolve as k,dirname as H1}from"path";import{fileURLToPath as H0}from"url";import{existsSync as u}from"fs";import{homedir as x1}from"os";function W0(){let z=L1;for(let Q=0;Q<6;Q++){if(u(k(z,"VERSION"))&&u(k(z,"autonomy/run.sh")))return z;let $=H1(z);if($===z)break;z=$}return k(L1,"..","..","..")}function W1(z){let Q=z;for(let $=0;$<6;$++){if(u(k(Q,"VERSION"))&&u(k(Q,"autonomy/run.sh")))return Q;let X=H1(Q);if(X===Q)break;Q=X}return k(z,"..","..","..")}function E(){return process.env.LOKI_DIR??k(process.cwd(),".loki")}function B1(){return k(x1(),".loki")}function B0(){let z=[y,k(x1(),".claude/skills/loki-mode"),process.cwd()];for(let Q of z)if(u(k(Q,"SKILL.md"))&&u(k(Q,"autonomy/run.sh")))return Q;return null}var L1,y;var h=g(()=>{L1=H1(H0(import.meta.url));y=W0()});var S1={};r(S1,{runOrThrow:()=>J0,run:()=>I,commandVersion:()=>M0,commandExists:()=>R,ShellError:()=>U1});async function I(z,Q={}){let $=Bun.spawn({cmd:[...z],stdout:"pipe",stderr:"pipe",env:Q.env?{...process.env,...Q.env}:process.env,cwd:Q.cwd}),X;if(Q.timeoutMs&&Q.timeoutMs>0)X=setTimeout(()=>$.kill(),Q.timeoutMs);let[Z,H,W]=await Promise.all([new Response($.stdout).text(),new Response($.stderr).text(),$.exited]);if(X)clearTimeout(X);return{stdout:Z,stderr:H,exitCode:W}}async function J0(z,Q={}){let $=await I(z,Q);if($.exitCode!==0)throw new U1(`command failed (${$.exitCode}): ${z.join(" ")}`,$.exitCode,$.stdout,$.stderr);return $}async function R(z){let Q=j0(z),$=await I(["sh","-c",`command -v ${Q}`],{timeoutMs:5000});if($.exitCode===0)return $.stdout.trim()||null;return null}function j0(z){if(!/^[A-Za-z0-9._/-]+$/.test(z))throw Error(`refused to shell-escape suspect token: ${z}`);return z}async function M0(z,Q="--version"){if(!await R(z))return null;let X=await I([z,Q],{timeoutMs:5000});if(X.exitCode!==0)return null;return((X.stdout||X.stderr).split(/\r?\n/)[0]?.trim()??"")||null}var U1;var m=g(()=>{U1=class U1 extends Error{message;exitCode;stdout;stderr;constructor(z,Q,$,X){super(z);this.message=z;this.exitCode=Q;this.stdout=$;this.stderr=X;this.name="ShellError"}}});function N(z){return Y0?"":z}var Y0,S,x,_,A3,G,F,A,K;var p=g(()=>{Y0=(process.env.NO_COLOR??"").length>0;S=N("\x1B[0;31m"),x=N("\x1B[0;32m"),_=N("\x1B[1;33m"),A3=N("\x1B[0;34m"),G=N("\x1B[0;36m"),F=N("\x1B[1m"),A=N("\x1B[2m"),K=N("\x1B[0m")});import{existsSync as P0}from"fs";async function a(){if(t!==void 0)return t;let z="/opt/homebrew/bin/python3.12";if(P0(z))return t=z,z;let Q=await R("python3.12");if(Q)return t=Q,Q;let $=await R("python3");return t=$,$}async function s(z,Q={}){let $=await a();if(!$)return{stdout:"",stderr:"python3 not found",exitCode:127};return I([$,"-c",z],Q)}var t;var Q1=g(()=>{m()});var v1={};r(v1,{runStatus:()=>y0});import{existsSync as L,readFileSync as e,readdirSync as C1,statSync as f1}from"fs";import{resolve as w,basename as E0}from"path";async function N0(){if(await R("jq"))return!0;return process.stdout.write(`${S}Error: jq is required but not installed.${K}
+`),process.stdout.write(`Install with:
+`),process.stdout.write(`  brew install jq    (macOS)
+`),process.stdout.write(`  apt install jq     (Debian/Ubuntu)
+`),process.stdout.write(`  yum install jq     (RHEL/CentOS)
+`),!1}function X1(z){if(!Number.isFinite(z)||z<=0)return!1;try{return process.kill(z,0),!0}catch{return!1}}function Z1(z){if(!L(z))return null;try{let Q=e(z,"utf-8").trim();if(!Q)return null;let $=Number.parseInt(Q,10);return Number.isFinite($)?$:null}catch{return null}}function C0(z){let Q=[],$=Z1(w(z,"loki.pid"));if($!==null&&X1($))Q.push(`global:${$}`);let X=w(z,"sessions");if(L(X)){let Z=[];try{Z=C1(X)}catch{Z=[]}for(let H of Z){let W=w(X,H);try{if(!f1(W).isDirectory())continue}catch{continue}let B=w(W,"loki.pid"),j=Z1(B);if(j!==null&&X1(j))Q.push(`${H}:${j}`)}}if(L(z)){let Z=[];try{Z=C1(z)}catch{Z=[]}for(let H of Z){if(!H.startsWith("run-")||!H.endsWith(".pid"))continue;let W=w(z,H);try{if(!f1(W).isFile())continue}catch{continue}let B=E0(H,".pid").slice(4),j=Z1(W);if(j!==null&&X1(j)){if(!Q.some((T)=>T.startsWith(`${B}:`)))Q.push(`${B}:${j}`)}}}return Q}async function g1(z,Q){let $=await I(["jq","-r",z,Q]);if($.exitCode!==0)return null;return $.stdout.trim()}function y1(z,Q){try{let $=e(z,"utf-8"),Z=JSON.parse($)[Q];if(typeof Z==="number"){if(Q==="budget_used"){let H=Math.round(Z*100)/100;if(Number.isInteger(H))return String(H);return String(H)}return String(Z)}if(Z===void 0||Z===null)return"0";return String(Z)}catch{return"0"}}function h1(z,Q,$){try{let X=e(z,"utf-8"),H=JSON.parse(X)[Q];if(typeof H==="number"&&Number.isFinite(H))return H;return $}catch{return $}}async function f0(){let z=E();if(!await N0())return 1;if(!L(z))return process.stdout.write(`${F}Loki Mode Status${K}
+`),process.stdout.write(`
+`),process.stdout.write(`${_}No active session found.${K}
+`),process.stdout.write(`Loki Mode has not been initialized in this directory.
+`),process.stdout.write(`
+`),process.stdout.write(`To start a session:
+`),process.stdout.write(`  loki start <prd>              - Start with a PRD file
+`),process.stdout.write(`  loki start                    - Start without a PRD
+`),process.stdout.write(`
+`),process.stdout.write(`${A}Current directory: ${process.cwd()}${K}
+`),0;process.stdout.write(`${F}Loki Mode Status${K}
+`),process.stdout.write(`
+`);let Q="",$=w(z,"state","provider");if(L($))try{Q=e($,"utf-8").trim()}catch{Q=""}let X=Q||process.env.LOKI_PROVIDER||"claude",Z="full features";switch(X){case"codex":case"gemini":case"aider":Z="degraded mode";break;case"cline":Z="near-full mode";break;default:Z="full features";break}process.stdout.write(`${G}Provider:${K} ${X} (${Z})
+`),process.stdout.write(`${A}  Switch with: loki provider set <claude|codex|gemini|cline|aider>${K}
+`),process.stdout.write(`
+`);let H=C0(z);if(H.length>0){process.stdout.write(`${x}Active Sessions: ${H.length}${K}
+`);for(let V of H){let U=V.indexOf(":"),Y=U>=0?V.slice(0,U):V,b=U>=0?V.slice(U+1):"";if(Y==="global")process.stdout.write(`  ${G}[global]${K} PID ${b}
+`);else process.stdout.write(`  ${G}[#${Y}]${K} PID ${b}
+`)}process.stdout.write(`
+`),process.stdout.write(`${A}  Stop specific: loki stop <session-id>${K}
+`),process.stdout.write(`${A}  Stop all:      loki stop${K}
+`),process.stdout.write(`
+`)}if(L(w(z,"PAUSE")))process.stdout.write(`${_}Status: PAUSED${K}
+`),process.stdout.write(`${A}  Resume with: loki resume${K}
+`),process.stdout.write(`
+`);else if(L(w(z,"STOP")))process.stdout.write(`${S}Status: STOPPED${K}
+`),process.stdout.write(`${A}  Clear with: loki resume${K}
+`),process.stdout.write(`
+`);let W=w(z,"STATUS.txt");if(L(W)){process.stdout.write(`${G}Session Info:${K}
+`);try{process.stdout.write(e(W,"utf-8"))}catch{}process.stdout.write(`
+`)}let B=w(z,"state","orchestrator.json");if(L(B)){process.stdout.write(`${G}Orchestrator State:${K}
+`);let V=await g1('.currentPhase // "unknown"',B);process.stdout.write(`${V??"unknown"}
+`)}let j=w(z,"queue","pending.json");if(L(j)){let V=await g1('if type == "array" then length elif .tasks then .tasks | length else 0 end',j);process.stdout.write(`${G}Pending Tasks:${K} ${V??"0"}
+`)}let O=w(z,"metrics","budget.json");if(L(O)){let V=y1(O,"budget_limit"),U=y1(O,"budget_used");if(V!=="0")process.stdout.write(`${G}Budget:${K} $${U} / $${V}
+`);else process.stdout.write(`${G}Cost:${K} $${U} (no limit)
+`)}let T=w(z,"state","context-usage.json");if(L(T)){let V=h1(T,"window_size",200000),U=h1(T,"used_tokens",0),Y=0;if(V>0)Y=Math.floor(U*100/V);process.stdout.write(`${G}Context:${K} ${Y}% (${U} / ${V} tokens)
+`)}let P=w(z,"dashboard","dashboard.pid");if(L(P)){let V=Z1(P);if(V!==null&&X1(V)){let U=process.env.LOKI_DASHBOARD_PORT||"57374";process.stdout.write(`${G}Dashboard:${K} http://127.0.0.1:${U}/
+`)}}return process.stdout.write(`
+`),process.stdout.write(`${A}  Tip: loki context show   - detailed token breakdown${K}
+`),process.stdout.write(`${A}  Tip: loki code overview   - codebase intelligence${K}
+`),0}async function g0(){let z=await a();if(!z)return process.stderr.write(`{"error": "Failed to generate JSON status. Ensure python3 is available."}
+`),1;let Q=y,$=E(),X=process.env.LOKI_DASHBOARD_PORT||"57374",Z=process.env.LOKI_PROVIDER||"claude",H=await I([z,"-c",b0,Q,$,X,Z],{timeoutMs:30000});if(H.exitCode!==0)return process.stderr.write(`{"error": "Failed to generate JSON status. Ensure python3 is available."}
+`),1;return process.stdout.write(H.stdout),0}async function y0(z){let Q=[...z];while(Q.length>0){let $=Q[0];if($==="--json")return g0();if($==="--help"||$==="-h")return process.stdout.write(`Usage: loki status [--json]
+`),0;return process.stdout.write(`${S}Unknown flag: ${$}${K}
+`),process.stdout.write(`Usage: loki status [--json]
+`),1}return f0()}var b0=`
+import json, os, sys, time
+
+skill_dir = sys.argv[1]
+loki_dir = sys.argv[2]
+dashboard_port = sys.argv[3]
+env_provider = sys.argv[4]
+result = {}
+
+# Version
+version_file = os.path.join(skill_dir, 'VERSION')
+if os.path.isfile(version_file):
+    with open(version_file) as f:
+        result['version'] = f.read().strip()
+else:
+    result['version'] = 'unknown'
+
+# Check if session exists
+if not os.path.isdir(loki_dir):
+    result['status'] = 'inactive'
+    result['phase'] = None
+    result['iteration'] = 0
+    result['provider'] = env_provider
+    result['dashboard_url'] = None
+    result['pid'] = None
+    result['elapsed_time'] = 0
+    result['task_counts'] = {'total': 0, 'completed': 0, 'failed': 0, 'pending': 0}
+    print(json.dumps(result, indent=2))
+    sys.exit(0)
+
+# Status from signals and session.json
+if os.path.isfile(os.path.join(loki_dir, 'PAUSE')):
+    result['status'] = 'paused'
+elif os.path.isfile(os.path.join(loki_dir, 'STOP')):
+    result['status'] = 'stopped'
+else:
+    session_file = os.path.join(loki_dir, 'session.json')
+    if os.path.isfile(session_file):
+        try:
+            with open(session_file) as f:
+                session = json.load(f)
+            result['status'] = session.get('status', 'unknown')
+        except Exception:
+            result['status'] = 'unknown'
+    else:
+        result['status'] = 'unknown'
+
+# Phase and iteration from dashboard-state.json
+ds_file = os.path.join(loki_dir, 'dashboard-state.json')
+if os.path.isfile(ds_file):
+    try:
+        with open(ds_file) as f:
+            ds = json.load(f)
+        result['phase'] = ds.get('phase', ds.get('currentPhase'))
+        result['iteration'] = ds.get('iteration', ds.get('currentIteration', 0))
+    except Exception:
+        result['phase'] = None
+        result['iteration'] = 0
+else:
+    orch_file = os.path.join(loki_dir, 'state', 'orchestrator.json')
+    if os.path.isfile(orch_file):
+        try:
+            with open(orch_file) as f:
+                orch = json.load(f)
+            result['phase'] = orch.get('currentPhase')
+            result['iteration'] = orch.get('currentIteration', 0)
+        except Exception:
+            result['phase'] = None
+            result['iteration'] = 0
+    else:
+        result['phase'] = None
+        result['iteration'] = 0
+
+# Provider
+provider_file = os.path.join(loki_dir, 'state', 'provider')
+if os.path.isfile(provider_file):
+    with open(provider_file) as f:
+        result['provider'] = f.read().strip()
+else:
+    result['provider'] = env_provider
+
+# PID
+pid_file = os.path.join(loki_dir, 'loki.pid')
+if os.path.isfile(pid_file):
+    try:
+        with open(pid_file) as f:
+            result['pid'] = int(f.read().strip())
+    except (ValueError, Exception):
+        result['pid'] = None
+else:
+    result['pid'] = None
+
+# Elapsed time from session.json
+session_file = os.path.join(loki_dir, 'session.json')
+if os.path.isfile(session_file):
+    try:
+        with open(session_file) as f:
+            session = json.load(f)
+        start_time = session.get('start_time', session.get('startTime'))
+        if start_time:
+            if isinstance(start_time, (int, float)):
+                result['elapsed_time'] = int(time.time() - start_time)
+            else:
+                from datetime import datetime
+                dt = datetime.fromisoformat(start_time.replace('Z', '+00:00'))
+                result['elapsed_time'] = int(time.time() - dt.timestamp())
+        else:
+            result['elapsed_time'] = 0
+    except Exception:
+        result['elapsed_time'] = 0
+else:
+    result['elapsed_time'] = 0
+
+# Dashboard URL
+dashboard_pid_file = os.path.join(loki_dir, 'dashboard', 'dashboard.pid')
+dashboard_url = None
+if os.path.isfile(dashboard_pid_file):
+    try:
+        with open(dashboard_pid_file) as f:
+            dpid = int(f.read().strip())
+        os.kill(dpid, 0)
+        dashboard_url = 'http://127.0.0.1:' + dashboard_port + '/'
+    except (ProcessLookupError, PermissionError, ValueError, Exception):
+        pass
+result['dashboard_url'] = dashboard_url
+
+# Task counts from queue files
+task_counts = {'total': 0, 'completed': 0, 'failed': 0, 'pending': 0}
+queue_dir = os.path.join(loki_dir, 'queue')
+if os.path.isdir(queue_dir):
+    for name, key in [('pending.json', 'pending'), ('completed.json', 'completed'), ('failed.json', 'failed')]:
+        fpath = os.path.join(queue_dir, name)
+        if os.path.isfile(fpath):
+            try:
+                with open(fpath) as f:
+                    data = json.load(f)
+                if isinstance(data, list):
+                    task_counts[key] = len(data)
+                elif isinstance(data, dict) and 'tasks' in data:
+                    task_counts[key] = len(data['tasks'])
+            except Exception:
+                pass
+    task_counts['total'] = task_counts['pending'] + task_counts['completed'] + task_counts['failed']
+result['task_counts'] = task_counts
+
+print(json.dumps(result, indent=2))
+`;var m1=g(()=>{m();Q1();p();h()});var l1={};r(l1,{runStats:()=>c0,computeStats:()=>c1});import{readdirSync as u1,readFileSync as h0,statSync as p1}from"fs";import{join as C}from"path";function l(z){try{if(!p1(z).isFile())return null;return JSON.parse(h0(z,"utf-8"))}catch{return null}}function J1(z){try{return p1(z).isDirectory()}catch{return!1}}function v0(z){if(!J1(z))return[];try{let Q=u1(z).filter(($)=>$.startsWith("iteration-")&&$.endsWith(".json"));return Q.sort(),Q.map(($)=>C(z,$))}catch{return[]}}function d(z){return Math.trunc(z).toLocaleString("en-US")}function q1(z){let Q=Math.trunc(z);if(Q<60)return`${Q}s`;let $=Math.trunc(Q/3600),X=Math.trunc(Q%3600/60),Z=Q%60;if($>0)return`${$}h ${String(X).padStart(2,"0")}m`;return`${X}m ${String(Z).padStart(2,"0")}s`}function f(z,Q=0){let $=Math.pow(10,Q);return Math.round(z*$)/$}function o(z,Q){return z.toFixed(Q)}function G1(z,Q){return z.length>=Q?z:z+" ".repeat(Q-z.length)}function m0(z){let Q="N/A",$=0,X=l(C(z,"state","orchestrator.json"));if(X&&typeof X==="object"){if(typeof X.currentPhase==="string")Q=X.currentPhase;if(typeof X.currentIteration==="number")$=X.currentIteration}let Z=C(z,"metrics","efficiency"),H=v0(Z),W=[];for(let q of H){let M=l(q);if(M&&typeof M==="object")W.push(M)}if(W.length>0)$=Math.max($,W.length);let B=W.reduce((q,M)=>q+(M.input_tokens??0),0),j=W.reduce((q,M)=>q+(M.output_tokens??0),0),O=B+j,T=W.reduce((q,M)=>q+(M.cost_usd??0),0),P=W.reduce((q,M)=>q+(M.duration_seconds??0),0),V=0,U=0,Y=l(C(z,"metrics","budget.json"));if(Y&&typeof Y==="object"){if(typeof Y.budget_limit==="number")V=Y.budget_limit;if(typeof Y.budget_used==="number")U=Y.budget_used}let b=0,z1=0,n=l(C(z,"state","quality-gates.json"));if(n&&typeof n==="object"){if(Array.isArray(n)){for(let q of n)if(z1+=1,q===!0)b+=1;else if(q&&typeof q==="object"){let M=q;if(M.passed===!0||M.status==="passed")b+=1}}else for(let q of Object.values(n))if(typeof q==="boolean"){if(z1+=1,q)b+=1}else if(q&&typeof q==="object"){z1+=1;let M=q;if(M.passed===!0||M.status==="passed")b+=1}}let _1={},$1=l(C(z,"quality","gate-failure-count.json"));if($1&&typeof $1==="object"&&!Array.isArray($1)){let q={};for(let[M,D]of Object.entries($1))if(typeof D==="number")q[M]=D;_1=q}let T1=0,I1=0,w1=0,K1=C(z,"quality");if(J1(K1)){let q=[];try{q=u1(K1)}catch{q=[]}for(let M of q){if(!M.endsWith(".json")||M==="gate-failure-count.json")continue;let D=l(C(K1,M));if(!D||typeof D!=="object")continue;if(!(("verdict"in D)||("approved"in D)||("reviewers"in D)))continue;T1+=1;let F1=(D.verdict??"").toString().toLowerCase();if(D.approved===!0||["approved","approve","pass"].includes(F1))I1+=1;else if(["revision","revise","changes_requested","reject"].includes(F1))w1+=1}}return{phase:Q,iterationCount:$,iterations:W,totalInput:B,totalOutput:j,totalTokens:O,totalCost:T,totalDuration:P,budgetLimit:V,budgetUsed:U,gatesPassed:b,gatesTotal:z1,gateFailures:_1,reviewsTotal:T1,reviewsApproved:I1,reviewsRevision:w1}}function u0(z,Q){let $=z.iterationCount,X={session:{iterations:$,duration_seconds:z.totalDuration,phase:z.phase},tokens:{input:z.totalInput,output:z.totalOutput,total:z.totalTokens,cost_usd:f(z.totalCost,2)},quality:{gates_passed:z.gatesPassed,gates_total:z.gatesTotal,reviews_total:z.reviewsTotal,reviews_approved:z.reviewsApproved,reviews_revision:z.reviewsRevision,gate_failures:z.gateFailures},efficiency:{avg_tokens_per_iteration:$>0?f(z.totalTokens/$,0):0,avg_cost_per_iteration:$>0?f(z.totalCost/$,2):0,avg_duration_per_iteration:$>0?f(z.totalDuration/$,1):0},budget:{used:f(z.budgetUsed,2),limit:z.budgetLimit,percent:z.budgetLimit>0?f(z.budgetUsed/z.budgetLimit*100,1):0}};if(Q)X.iterations=z.iterations.map((W,B)=>({number:B+1,input_tokens:W.input_tokens??0,output_tokens:W.output_tokens??0,cost_usd:f(W.cost_usd??0,2),duration_seconds:W.duration_seconds??0}));let Z=JSON.stringify(X,null,2);function H(W,B){if(!B)return;let j=new RegExp(`("${W}": )(-?\\d+)(,?)$`,"m");Z=Z.replace(j,(O,T,P,V)=>`${T}${P}.0${V}`)}if(H("avg_duration_per_iteration",$>0&&Number.isInteger(X.efficiency.avg_duration_per_iteration)),H("percent",z.budgetLimit>0&&Number.isInteger(X.budget.percent)),H("cost_usd",$>0&&Number.isInteger(X.tokens.cost_usd)),Q)Z=Z.replace(/("cost_usd": )(-?\d+)(,?)$/gm,(W,B,j,O)=>`${B}${j}.0${O}`);return Z}function p0(z,Q){let $=[];if($.push("Loki Mode Session Statistics"),$.push("============================"),$.push(""),$.push("Session"),$.push(`  Iterations completed: ${z.iterationCount}`),$.push(`  Duration: ${q1(z.totalDuration)}`),$.push(`  Current phase: ${z.phase}`),$.push(""),$.push("Token Usage"),z.iterations.length>0)$.push(`  Input tokens:  ${d(z.totalInput)}`),$.push(`  Output tokens: ${d(z.totalOutput)}`),$.push(`  Total tokens:  ${d(z.totalTokens)}`),$.push(`  Estimated cost: $${o(z.totalCost,2)}`);else $.push("  N/A (no iteration metrics found)");if($.push(""),$.push("Quality Gates"),z.gatesTotal>0){let X=Math.round(z.gatesPassed/z.gatesTotal*100);$.push(`  Gates passed: ${z.gatesPassed}/${z.gatesTotal} (${X}%)`)}else $.push("  Gates passed: N/A");if(z.reviewsTotal>0){let X=[];if(z.reviewsApproved>0)X.push(`${z.reviewsApproved} approved`);if(z.reviewsRevision>0)X.push(`${z.reviewsRevision} revision requested`);let Z=X.length>0?X.join(", "):"N/A";$.push(`  Code reviews: ${z.reviewsTotal} (${Z})`)}if(Object.keys(z.gateFailures).length>0){let X=Object.entries(z.gateFailures).filter(([,Z])=>Z>0).map(([Z,H])=>`${Z} (${H})`);if(X.length>0)$.push(`  Gate failures: ${X.join(", ")}`)}if($.push(""),$.push("Efficiency"),z.iterationCount>0&&z.iterations.length>0){let X=Math.round(z.totalTokens/z.iterationCount),Z=z.totalCost/z.iterationCount,H=z.totalDuration/z.iterationCount;$.push(`  Avg tokens/iteration: ${d(X)}`),$.push(`  Avg cost/iteration: $${o(Z,2)}`),$.push(`  Avg duration/iteration: ${q1(H)}`)}else $.push("  N/A (no iteration metrics found)");if($.push(""),$.push("Budget"),z.budgetLimit>0){let X=f(z.budgetUsed/z.budgetLimit*100,1),Z=Number.isInteger(X)?`${X}.0`:`${X}`;$.push(`  Used: $${o(z.budgetUsed,2)} / $${o(z.budgetLimit,2)} (${Z}%)`)}else if(z.budgetUsed>0)$.push(`  Used: $${o(z.budgetUsed,2)} (no limit set)`);else $.push("  N/A");if(Q&&z.iterations.length>0)$.push(""),$.push("Per-Iteration Breakdown"),z.iterations.forEach((X,Z)=>{let H=Z+1,W=G1(d(X.input_tokens??0),10),B=G1(d(X.output_tokens??0),10),j=X.cost_usd??0,O=q1(X.duration_seconds??0),T=G1(`${H}`,3);$.push(`  #${T} input: ${W} output: ${B} cost: $${o(j,2)}  time: ${O}`)});return $.join(`
+`)}function c1(z){let Q=!1,$=!1;for(let W of z)if(W==="--json")Q=!0;else if(W==="--efficiency")$=!0;let X=E();if(!J1(X)){if(Q)return{exitCode:0,stdout:'{"error": "No active session"}'};return{exitCode:0,stdout:`${_}No active session found.${K}
+Start a session with: loki start <prd>`}}let Z=m0(X);return{exitCode:0,stdout:Q?u0(Z,$):p0(Z,$)}}async function c0(z){let Q=c1(z);return console.log(Q.stdout),Q.exitCode}var d1=g(()=>{h();p()});var e1={};r(e1,{runDoctor:()=>$3,httpReachable:()=>A1,checkTool:()=>t1,checkSkills:()=>a1,checkDisk:()=>O1,buildDoctorJson:()=>i1});import{existsSync as l0,lstatSync as d0,readlinkSync as o0,statfsSync as n0}from"fs";import{homedir as n1}from"os";import{resolve as o1}from"path";function t0(z){let Q=z.match(r0);return Q?Q[1]:null}async function a0(z){try{let Q=await I([z,"--version"],{timeoutMs:5000}),$=(Q.stdout||Q.stderr||"").trim();return t0($)}catch{return null}}function r1(z,Q){let $=z.split(".").map((Z)=>parseInt(Z,10)),X=Q.split(".").map((Z)=>parseInt(Z,10));while($.length<2)$.push(0);while(X.length<2)X.push(0);for(let Z=0;Z<2;Z++){let H=$[Z]??0,W=X[Z]??0;if(Number.isNaN(H)||Number.isNaN(W))return 0;if(H!==W)return H-W}return 0}async function t1(z,Q,$,X=null){let Z=await R(Q),H=Z!==null,W=H?await a0(Q):null,B="pass";if(!H)B=$==="required"?"fail":"warn";else if(X&&W){if(r1(W,X)<0)B=$==="required"?"fail":"warn"}return{name:z,command:Q,found:H,version:W,required:$,min_version:X,status:B,path:Z}}function O1(){let z=null;try{let $=n0(n1()),X=Number($.bavail)*Number($.bsize);z=Math.round(X/1073741824*10)/10}catch{z=null}let Q="pass";if(z!==null){if(z<1)Q="fail";else if(z<5)Q="warn"}return{available_gb:z,status:Q}}async function A1(z,Q=2000){try{return(await fetch(z,{signal:AbortSignal.timeout(Q)})).ok}catch{return!1}}async function j1(z,Q=!1){let $=`import ${z}`,X=Q?30000:5000;if(!Q)return(await s($,{timeoutMs:X})).exitCode===0;let Z=await a();if(!Z)return!1;return(await I([Z,"-c",$],{timeoutMs:X})).exitCode===0}function a1(){let z=n1();return s0.map(({name:Q,dir:$})=>{let X=o1(z,$),Z=X,H=o1(X,"SKILL.md");if(l0(H))return{name:Q,path:Z,status:"pass",detail:""};try{if(d0(X).isSymbolicLink()){let B="unknown";try{B=o0(X)}catch{}return{name:Q,path:Z,status:"fail",detail:`(broken symlink -> ${B})`}}}catch{}return{name:Q,path:Z,status:"warn",detail:"(not found - run 'loki setup-skill')"}})}async function s1(){return Promise.all(i0.map(async(z)=>{return{...await t1(z.jsonName,z.cmd,z.required,z.min??null),displayName:z.displayName}}))}async function i1(){let Q=(await s1()).map(({displayName:W,...B})=>B),$=O1(),X=0,Z=0,H=0;for(let W of Q)if(W.status==="pass")X++;else if(W.status==="fail")Z++;else H++;if($.status==="pass")X++;else if($.status==="fail")Z++;else H++;return{checks:Q,disk:$,summary:{passed:X,failed:Z,warnings:H,ok:Z===0}}}function J(z){switch(z){case"pass":return`${x}PASS${K}`;case"fail":return`${S}FAIL${K}`;case"warn":return`${_}WARN${K}`}}function M1(z){let Q=z.version?` (v${z.version})`:"",$=z.displayName;if(!z.found){let X=z.required==="required"?"not found":z.required==="recommended"?"not found (recommended)":"not found (optional)";return`  ${J(z.status)}  ${$} - ${X}`}if(z.min_version&&z.version&&r1(z.version,z.min_version)<0){let X=z.required==="required"?"requires":"recommended";return`  ${J(z.status)}  ${$}${Q} - ${X} >= ${z.min_version}`}return`  ${J(z.status)}  ${$}${Q}`}function Y1(z,Q){if(Q==="pass")z.pass++;else if(Q==="fail")z.fail++;else z.warn++}function e0(){process.stdout.write(`${F}loki doctor${K} - Check system prerequisites
+
+`),process.stdout.write(`Usage: loki doctor [--json]
+
+`),process.stdout.write(`Options:
+`),process.stdout.write(`  --json    Output machine-readable JSON
+
+`),process.stdout.write(`Checks: node, python3, jq, git, curl, bash version,
+`),process.stdout.write(`        claude/codex/gemini CLIs, and disk space.
+`)}async function z3(){process.stdout.write(`${F}Loki Mode Doctor${K}
+
+`),process.stdout.write(`Checking system prerequisites...
+
+`);let z={pass:0,fail:0,warn:0},Q=await s1(),$=new Map(Q.map((U)=>[U.command,U]));process.stdout.write(`${G}Required:${K}
+`);for(let U of["node","python3","jq","git","curl"]){let Y=$.get(U);process.stdout.write(M1(Y)+`
+`),Y1(z,Y.status)}process.stdout.write(`
+`),process.stdout.write(`${G}AI Providers:${K}
+`);let X=["claude","codex","gemini","cline","aider"],Z=!1;for(let U of X){let Y=$.get(U);if(process.stdout.write(M1(Y)+`
+`),Y1(z,Y.status),Y.found)Z=!0}if(!Z)process.stdout.write(`  ${J("fail")}  No AI provider CLI installed -- at least one is required
+`),process.stdout.write(`         ${_}Install: npm install -g @anthropic-ai/claude-code${K}
+`),z.fail++;process.stdout.write(`
+`),process.stdout.write(`${G}API Keys:${K}
+`);let H=$.get("claude").found,W=$.get("codex").found,B=$.get("gemini").found,j=process.env;if(j.ANTHROPIC_API_KEY)process.stdout.write(`  ${J("pass")}  ANTHROPIC_API_KEY is set
+`),z.pass++;else if(H)process.stdout.write(`  ${A}  --  ${K}  ANTHROPIC_API_KEY not set (Claude CLI uses its own login)
+`);if(j.OPENAI_API_KEY)process.stdout.write(`  ${J("pass")}  OPENAI_API_KEY is set
+`),z.pass++;else if(W)process.stdout.write(`  ${A}  --  ${K}  OPENAI_API_KEY not set (Codex CLI uses its own login)
+`);if(j.GOOGLE_API_KEY||j.GEMINI_API_KEY)process.stdout.write(`  ${J("pass")}  GOOGLE_API_KEY is set
+`),z.pass++;else if(B)process.stdout.write(`  ${A}  --  ${K}  GOOGLE_API_KEY not set (Gemini CLI uses its own login)
+`);process.stdout.write(`
+`),process.stdout.write(`${G}Skills:${K}
+`);for(let U of a1())if(U.status==="pass")process.stdout.write(`  ${J("pass")}  ${U.name}  ${A}${U.path}${K}
+`),z.pass++;else if(U.status==="fail")process.stdout.write(`  ${J("fail")}  ${U.name}  ${A}${U.detail}${K}
+`),process.stdout.write(`         ${_}Fix: loki setup-skill${K}
+`),z.fail++;else process.stdout.write(`  ${J("warn")}  ${U.name}  ${A}${U.detail}${K}
+`),z.warn++;if(process.stdout.write(`
+`),process.stdout.write(`${G}Integrations:${K}
+`),await j1("mcp"))process.stdout.write(`  ${J("pass")}  MCP SDK (Python)
+`),z.pass++;else process.stdout.write(`  ${J("warn")}  MCP SDK - not installed (pip3 install mcp)
+`),z.warn++;if(await j1("numpy",!0))process.stdout.write(`  ${J("pass")}  numpy (vector search)
+`),z.pass++;else process.stdout.write(`  ${J("warn")}  numpy - not installed (pip3 install numpy)
+`),z.warn++;if(await j1("sentence_transformers",!0))process.stdout.write(`  ${J("pass")}  sentence-transformers (embeddings)
+`),z.pass++;else process.stdout.write(`  ${J("warn")}  sentence-transformers - not installed (loki memory vectors setup)
+`),z.warn++;if(await A1("http://localhost:8100/api/v2/heartbeat"))process.stdout.write(`  ${J("pass")}  ChromaDB server (port 8100)
+`),z.pass++;else process.stdout.write(`  ${J("warn")}  ChromaDB - not running (docker start loki-chroma)
+`),z.warn++;let O=process.env.LOKI_MIROFISH_URL;if(O)if(await A1(`${O}/health`))process.stdout.write(`  ${J("pass")}  MiroFish server (${O})
+`),z.pass++;else process.stdout.write(`  ${J("warn")}  MiroFish - not running (loki start --mirofish-docker <image>)
+`),z.warn++;if(process.env.LOKI_OTEL_ENDPOINT)process.stdout.write(`  ${J("pass")}  OTEL endpoint: ${process.env.LOKI_OTEL_ENDPOINT}
+`),z.pass++;else process.stdout.write(`  ${J("warn")}  OTEL - not configured (set LOKI_OTEL_ENDPOINT)
+`),z.warn++;process.stdout.write(`
+`),process.stdout.write(`${G}System:${K}
+`);let T=$.get("bash");process.stdout.write(M1(T)+`
+`),Y1(z,T.status);let P=O1(),V=P.available_gb===null?null:Math.floor(P.available_gb);if(V===null)process.stdout.write(`  ${J("warn")}  Disk space: unable to determine
+`),z.warn++;else if(P.status==="fail")process.stdout.write(`  ${J("fail")}  Disk space: ${V}GB available (need >= 1GB)
+`),z.fail++;else if(P.status==="warn")process.stdout.write(`  ${J("warn")}  Disk space: ${V}GB available (low)
+`),z.warn++;else process.stdout.write(`  ${J("pass")}  Disk space: ${V}GB available
+`),z.pass++;if(process.stdout.write(`
+`),process.stdout.write(`${F}Summary:${K} ${x}${z.pass} passed${K}, ${S}${z.fail} failed${K}, ${_}${z.warn} warnings${K}
+
+`),z.fail>0)return process.stdout.write(`${S}Some required prerequisites are missing.${K}
+`),process.stdout.write(`Install missing dependencies and run 'loki doctor' again.
+`),1;if(z.warn>0)return process.stdout.write(`${_}All required checks passed with some warnings.${K}
+`),0;return process.stdout.write(`${x}All checks passed. System is ready for Loki Mode.${K}
+`),0}async function $3(z){let Q=!1;for(let $ of z)if($==="--json")Q=!0;else if($==="--help"||$==="-h")return e0(),0;else return process.stderr.write(`${S}Unknown option: ${$}${K}
+`),process.stderr.write(`Usage: loki doctor [--json]
+`),1;if(Q){let $=await i1();return process.stdout.write(JSON.stringify($,null,2)+`
+`),0}return z3()}var r0,s0,i0;var z0=g(()=>{m();Q1();p();r0=/(\d+\.\d+(?:\.\d+)*)/;s0=[{name:"Claude Code",dir:".claude/skills/loki-mode"},{name:"Codex CLI",dir:".codex/skills/loki-mode"},{name:"Gemini CLI",dir:".gemini/skills/loki-mode"},{name:"Cline CLI",dir:".cline/skills/loki-mode"},{name:"Aider CLI",dir:".aider/skills/loki-mode"}];i0=[{displayName:"Node.js (>= 18)",jsonName:"Node.js",cmd:"node",required:"required",min:"18.0"},{displayName:"Python 3 (>= 3.8)",jsonName:"Python 3",cmd:"python3",required:"required",min:"3.8"},{displayName:"jq",jsonName:"jq",cmd:"jq",required:"required"},{displayName:"git",jsonName:"git",cmd:"git",required:"required"},{displayName:"curl",jsonName:"curl",cmd:"curl",required:"required"},{displayName:"bash (>= 4.0)",jsonName:"bash",cmd:"bash",required:"recommended",min:"4.0"},{displayName:"Claude CLI",jsonName:"Claude CLI",cmd:"claude",required:"optional"},{displayName:"Codex CLI",jsonName:"Codex CLI",cmd:"codex",required:"optional"},{displayName:"Gemini CLI",jsonName:"Gemini CLI",cmd:"gemini",required:"optional"},{displayName:"Cline CLI",jsonName:"Cline CLI",cmd:"cline",required:"optional"},{displayName:"Aider CLI",jsonName:"Aider CLI",cmd:"aider",required:"optional"}]});h();import{readFileSync as U0}from"fs";import{resolve as V0,dirname as q0}from"path";import{fileURLToPath as G0}from"url";var v=null;function k1(){if(v!==null)return v;let z="7.4.8";if(typeof z==="string"&&z.length>0)return v=z,v;try{let Q=q0(G0(import.meta.url)),$=W1(Q);v=U0(V0($,"VERSION"),"utf-8").trim()}catch{v="unknown"}return v}function R1(){return process.stdout.write(`Loki Mode v${k1()}
+`),0}m();p();h();import{readFileSync as A0,existsSync as O0}from"fs";import{resolve as _0}from"path";var T0=["claude","codex","gemini","cline","aider"];function D1(){let z=_0(E(),"state","provider");if(!O0(z))return"";try{return A0(z,"utf-8").trim()}catch{return""}}function I0(z,Q){return z||Q||process.env.LOKI_PROVIDER||"claude"}function w0(z){let Q=D1(),$=I0(z,Q);switch(process.stdout.write(`${F}Current Provider${K}
+`),process.stdout.write(`
+`),process.stdout.write(`${G}Provider:${K} ${$}
+`),$){case"claude":process.stdout.write(`${x}Status:${K}   Full features (subagents, parallel, MCP)
+`);break;case"cline":process.stdout.write(`${x}Status:${K}   Near-full mode (subagents, MCP, 12+ providers)
+`);break;case"codex":case"gemini":case"aider":process.stdout.write(`${_}Status:${K}   Degraded mode (sequential only)
+`);break;default:break}if(Q)process.stdout.write(`${A}(saved in .loki/state/provider)${K}
+`);else process.stdout.write(`${A}(default - not explicitly set)${K}
+`);return process.stdout.write(`
+`),process.stdout.write(`Switch provider: ${G}loki provider set <name>${K}
+`),process.stdout.write(`Available:       ${G}loki provider list${K}
+`),0}async function F0(){let Q=D1()||process.env.LOKI_PROVIDER||"claude";process.stdout.write(`${F}Available Providers${K}
+`),process.stdout.write(`
+`);let $=await Promise.all(T0.map(async(H)=>[H,await R(H)!==null])),X=new Map;for(let[H,W]of $)X.set(H,W?`${x}installed${K}`:`${S}not installed${K}`);let Z=[["claude","claude  - Claude Code (Anthropic)    "],["codex","codex   - Codex CLI (OpenAI)         "],["gemini","gemini  - Gemini CLI (Google)        "],["cline","cline   - Cline (multi-provider)     "],["aider","aider   - Aider (terminal pair prog) "]];for(let[H,W]of Z){let B=Q===H?` ${G}(current)${K}`:"";process.stdout.write(`  ${W} ${X.get(H)}${B}
+`)}return process.stdout.write(`
+`),process.stdout.write(`Set provider: ${G}loki provider set <name>${K}
+`),0}function L0(){return process.stdout.write(`${F}Loki Mode Provider Management${K}
+`),process.stdout.write(`
+`),process.stdout.write(`Usage: loki provider <command>
+`),process.stdout.write(`
+`),process.stdout.write(`Commands:
+`),process.stdout.write(`  show     Show current provider (default)
+`),process.stdout.write(`  set      Set provider for this project
+`),process.stdout.write(`  list     List available providers
+`),process.stdout.write(`  info     Show provider details
+`),process.stdout.write(`  models   Show resolved model configuration for all providers
+`),process.stdout.write(`
+`),process.stdout.write(`Examples:
+`),process.stdout.write(`  loki provider show
+`),process.stdout.write(`  loki provider set claude
+`),process.stdout.write(`  loki provider set codex
+`),process.stdout.write(`  loki provider list
+`),process.stdout.write(`  loki provider info gemini
+`),process.stdout.write(`  loki provider models
+`),0}async function E1(z){let Q=z[0]??"show",$=z.slice(1);switch(Q){case"show":case"current":return w0($[0]);case"list":return F0();case"set":case"info":case"models":return x0(["provider",Q,...$]);default:return L0()}}async function x0(z){let{run:Q}=await Promise.resolve().then(() => (m(),S1)),{resolve:$}=await import("path"),{REPO_ROOT:X}=await Promise.resolve().then(() => (h(),P1)),Z=$(X,"autonomy","loki"),H=await Q([Z,...z],{env:{LOKI_LEGACY_BASH:"1"},timeoutMs:3600000});return process.stdout.write(H.stdout),process.stderr.write(H.stderr),H.exitCode}p();h();Q1();m();import{existsSync as b1,readFileSync as k0}from"fs";import{resolve as c}from"path";import{mkdir as R0}from"fs/promises";var i=c(B1(),"learnings");function V1(z){if(!b1(z))return 0;try{let Q=k0(z,"utf-8"),$=0;for(let X of Q.split(`
+`))if(X.includes('"description"'))$++;return $}catch{return 0}}async function S0(){await R0(i,{recursive:!0});let z=V1(c(i,"patterns.jsonl")),Q=V1(c(i,"mistakes.jsonl")),$=V1(c(i,"successes.jsonl"));return process.stdout.write(`${F}Cross-Project Learnings${K}
+`),process.stdout.write(`
+`),process.stdout.write(`  Patterns:  ${x}${z}${K}
+`),process.stdout.write(`  Mistakes:  ${_}${Q}${K}
+`),process.stdout.write(`  Successes: ${G}${$}${K}
+`),process.stdout.write(`
+`),process.stdout.write(`Location: ${i}
+`),process.stdout.write(`
+`),process.stdout.write(`Use 'loki memory show <type>' to view entries
+`),0}async function D0(z){if(z){let X=`
+try:
+    from memory.layers import IndexLayer
+    layer = IndexLayer('.loki/memory')
+    layer.update([])
+    print('Index rebuilt')
+except ImportError:
+    print('Error: memory.layers module not found')
+except Exception as e:
+    print(f'Error: {e}')
+`.trim(),Z=await s(X,{cwd:y});return process.stdout.write(Z.stdout),0}let Q=c(E(),"memory","index.json");if(!b1(Q))return process.stdout.write(`No index found
+`),0;let $=await s(`import json, sys; sys.stdout.write(json.dumps(json.load(open(${JSON.stringify(Q)})), indent=4) + "\\n")`);if($.exitCode!==0)return process.stdout.write(`No index found
+`),0;return process.stdout.write($.stdout),0}async function N1(z){switch(z[0]??"list"){case"list":case"ls":return S0();case"index":return D0(z[1]==="rebuild");default:{let $=c(y,"autonomy","loki"),X=await I([$,"memory",...z],{env:{LOKI_LEGACY_BASH:"1"},timeoutMs:3600000});return process.stdout.write(X.stdout),process.stderr.write(X.stderr),X.exitCode}}}var $0=`Loki Mode (TypeScript port, Phase 2 of bash->Bun migration)
+
+Usage: loki <command> [args...]
+
+Phase 2 ported (Bun-native, fast):
+  version                Print Loki Mode version
+  status [--json]        Show current orchestrator status
+  stats [--json] [--efficiency]   Session statistics
+  provider show [name]   Show current provider
+  provider list          List available providers and install status
+  memory list            Cross-project learnings counts
+  memory index [rebuild] Show or rebuild memory index
+  doctor [--json]        System prerequisites health check
+
+All other commands fall through to the bash CLI (autonomy/loki).
+Set LOKI_LEGACY_BASH=1 to force the bash CLI for every command.
+`;async function Q3(z){let Q=z[0],$=z.slice(1);switch(Q){case void 0:case"help":case"--help":case"-h":return process.stdout.write($0),0;case"version":case"--version":case"-v":return R1();case"provider":return E1($);case"memory":return N1($);case"status":{let{runStatus:X}=await Promise.resolve().then(() => (m1(),v1));return X($)}case"stats":{let{runStats:X}=await Promise.resolve().then(() => (d1(),l1));return X($)}case"doctor":{let{runDoctor:X}=await Promise.resolve().then(() => (z0(),e1));return X($)}default:return process.stderr.write(`Unknown command: ${Q}
+`),process.stderr.write($0),2}}process.on("SIGINT",()=>process.exit(130));process.on("SIGTERM",()=>process.exit(143));var X3=await Q3(Bun.argv.slice(2));process.exit(X3);
+
+//# debugId=7F3CF7B4F1CA56A864756E2164756E21

package/loki-ts/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@loki-mode/orchestrator",
+  "version": "0.1.0-alpha.1",
+  "description": "Loki Mode TypeScript orchestrator (Bun runtime). Parallel implementation alongside autonomy/run.sh during Phase 1 of the bash->Bun migration. See docs/architecture/ADR-001-runtime-migration.md.",
+  "private": true,
+  "type": "module",
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "scripts": {
+    "version": "bun src/cli.ts version",
+    "typecheck": "bun run --bun tsc --noEmit",
+    "test": "bun test",
+    "bench": "bun run scripts/bench.ts",
+    "build": "bun run scripts/build.ts",
+    "build:binary": "bun build --compile src/cli.ts --outfile=dist/loki-ts"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.6.0"
+  }
+}

package/mcp/__init__.py

@@ -57,4 +57,4 @@ try:
 except ImportError:
     __all__ = ['mcp']
 
-__version__ = '7.2.0'
+__version__ = '7.4.8'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loki-mode",
-  "version": "7.2.0",
+  "version": "7.4.8",
   "description": "Loki Mode by Autonomi - Multi-agent autonomous startup system for Claude Code, Codex CLI, and Gemini CLI",
   "keywords": [
     "agent",
@@ -59,7 +59,7 @@
   "license": "BUSL-1.1",
   "author": "Lokesh",
   "bin": {
-    "loki": "autonomy/loki",
+    "loki": "bin/loki",
     "loki-mode": "bin/loki-mode.js"
   },
   "files": [
@@ -72,6 +72,9 @@
     "references/",
     "docs/**/*.md",
     "bin/",
+    "bin/loki",
+    "loki-ts/dist/",
+    "loki-ts/package.json",
     "api/",
     "events/",
     "memory/",
@@ -100,7 +103,7 @@
   ],
   "scripts": {
     "postinstall": "node bin/postinstall.js",
-    "prepack": "find . -type d -name __pycache__ -exec rm -rf {} + 2>/dev/null; find . -name '*.pyc' -delete 2>/dev/null; true",
+    "prepack": "find . -type d -name __pycache__ -exec rm -rf {} + 2>/dev/null; find . -name '*.pyc' -delete 2>/dev/null; if command -v bun >/dev/null 2>&1; then (cd loki-ts && bun install --production && bun run build) || echo 'WARN: loki-ts build failed, using existing dist if present'; else echo 'WARN: bun not on PATH, skipping loki-ts build (using committed dist if present)'; fi; true",
     "prepublishOnly": "cd dashboard-ui && npm ci && npm run build:all",
     "test": "bash -n autonomy/run.sh && bash -n autonomy/loki && bash -n autonomy/completion-council.sh && bash -n autonomy/app-runner.sh && bash -n autonomy/prd-checklist.sh && bash -n autonomy/playwright-verify.sh && node --test tests/protocols/*.test.js && node --test tests/protocols/a2a/*.test.js && node --test tests/observability/*.test.js && node --test tests/policies/*.test.js && node --test tests/audit/*.test.js && node --test tests/integrations/*.test.js && node --test tests/integrations/jira/*.test.js && node --test tests/integrations/github/*.test.js && node --test tests/integrations/slack/*.test.js && bash tests/managed_memory/test_flag_matrix.sh && bash tests/managed_memory/test_sdk_isolation.sh && bash tests/managed_memory/test_kill_switch.sh && python3 -m unittest tests.managed_memory.test_shadow_write_mock tests.managed_memory.test_retrieve_mock && echo 'All checks passed'",
     "test:visual": "node --experimental-vm-modules node_modules/jest/bin/jest.js dashboard-ui/tests/visual-regression.test.js",
@@ -122,6 +125,9 @@
     "@opentelemetry/sdk-trace-base": "^1.30.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.57.0"
   },
+  "overrides": {
+    "protobufjs": ">=7.5.5"
+  },
   "devDependencies": {
     "@types/node": "^25.2.0",
     "jest": "^29.7.0",