loki-mode 10.6.8 → 10.6.9

package/autonomy/lib/workspace_comment.py

@@ -0,0 +1,91 @@
+"""Post the workspace integration result as one PR comment per repo PR (D51-B11).
+
+No LLM. Uses the `gh` CLI with the caller's own environment, so GH_TOKEN or
+GITHUB_TOKEN is read by gh itself and never placed in argv, the comment body
+or any log line. Commenting is best effort: it never raises and never changes
+the run's exit code. Opt out with LOKI_WORKSPACE_COMMENT=0.
+"""
+import os
+import re
+import subprocess
+import tempfile
+
+GH_TIMEOUT_S = 60
+
+
+def verdict(ev):
+    """Map integration evidence to a label. Only a clean exit 0 reads as PASSED."""
+    status = ev.get("status")
+    if "timeout" in str(ev.get("note") or "").lower():
+        return "TIMEOUT"
+    if status == "passed" and ev.get("exit_code") == 0:
+        return "PASSED"
+    if status == "not_configured":
+        return "NOT CONFIGURED"
+    return "FAILED"
+
+
+def render(ws_name, run_id, repo, ev):
+    heads = ev.get("heads") or {}
+    lines = ["Loki workspace `%s` run `%s`" % (ws_name, run_id), "",
+             "Integration: **%s** (exit code %s)" % (verdict(ev), ev.get("exit_code")), "",
+             "| Repo | Outcome | Head SHA |", "| --- | --- | --- |"]
+    outcomes = ev.get("outcomes") or {}
+    for r in sorted(heads.keys() | outcomes.keys()):
+        out = outcomes.get(r, "unknown")
+        out = "ok" if out == "ok" else str(out).replace("|", "/")
+        mark = " (this PR)" if r == repo else ""
+        lines.append("| %s%s | %s | %s |" % (r, mark, out, heads.get(r) or "none"))
+    if ev.get("log_sha256"):
+        lines += ["", "Integration log sha256: `%s`" % ev["log_sha256"]]
+    lines += ["", "Integration evidence is not part of the Seal."]
+    return "\n".join(lines) + "\n"
+
+
+def _gh(args, cwd):
+    return subprocess.run(["gh"] + args, cwd=cwd, stdin=subprocess.DEVNULL, capture_output=True,
+                          text=True, timeout=GH_TIMEOUT_S)
+
+
+def _branch(wt):
+    r = subprocess.run(["git", "-C", wt, "rev-parse", "--abbrev-ref", "HEAD"], capture_output=True, text=True,
+                       timeout=GH_TIMEOUT_S)
+    b = r.stdout.strip()
+    return b if r.returncode == 0 and b and b != "HEAD" else None
+
+
+def post_comments(ws_name, run_id, run_dir, worktrees, ev, say):
+    """One comment per repo that has an open PR on its run branch. Never raises."""
+    if os.environ.get("LOKI_WORKSPACE_COMMENT") == "0":
+        return 0
+    posted = 0
+    try:
+        for repo, wt in sorted(worktrees.items()):
+            try:
+                branch = _branch(wt)
+                if not branch:
+                    continue
+                r = _gh(["pr", "list", "--repo", repo, "--head", branch, "--state", "open",
+                         "--json", "number", "--jq", ".[0].number"], wt)
+                num = r.stdout.strip()
+                if r.returncode != 0 or not re.fullmatch(r"\d+", num):
+                    continue
+                fd, body = tempfile.mkstemp(prefix="comment-", suffix=".md", dir=run_dir)  # mode 0600
+                try:
+                    with os.fdopen(fd, "w") as f:
+                        f.write(render(ws_name, run_id, repo, ev))
+                    c = _gh(["pr", "comment", num, "--repo", repo, "--body-file", body], wt)
+                finally:
+                    try:
+                        os.unlink(body)
+                    except OSError:
+                        pass
+                if c.returncode == 0:
+                    posted += 1
+                else:
+                    say("workspace: comment on %s#%s failed (gh exit %d)" % (repo, num, c.returncode))
+            except (OSError, subprocess.SubprocessError, ValueError) as e:
+                say("workspace: comment for %s skipped (%s)" % (repo, type(e).__name__))
+    except Exception as e:  # never fail the run because commenting failed
+        say("workspace: commenting skipped (%s)" % type(e).__name__)
+    return posted

package/autonomy/loki

@@ -1630,7 +1630,7 @@ show_help() {
     echo "  start [SPEC]     Start a build (PRD file, GitHub/GitLab/Jira/Azure issue, or no arg)"
     echo "  plan <PRD-file>  Dry-run analysis: complexity, cost, execution plan"
     echo "  backlog <owner/repo> --all|--label X|--issues N,N   Run every matching open issue, N in parallel"
-    echo "  workspace list | run <name> <ref>   Multi-repo runs from loki.yaml workspaces (LOKI_WORKSPACES=1)"
+    echo "  workspace list | run <name> <ref>   Multi-repo runs from loki.yaml workspaces (LOKI_WORKSPACES=0 disables)"
     echo "  quickstart [idea]  Guided first build: setup, idea, template, plan, go"
     echo ""
     echo "Session:"
@@ -1783,7 +1783,7 @@ show_help() {
     echo "  syslog telemetry template test tour trigger trust trust-metrics"
     echo "  ultracode update verify version voice watch watchdog web welcome why"
     echo "  wiki worktree (wt)"
-    echo "  control (preview, needs LOKI_CONTROL=1)"
+    echo "  control"
     echo ""
     echo "Any command: loki <command> --help"
     echo ""
@@ -1897,7 +1897,74 @@ _loki_dashboard_port_is_ours() {
     return 1
 }
 
+# C3: the Control Plane is the default UI. Prints a live loopback URL from
+# ~/.loki/control/instance.json (pid alive, http loopback only, /health says
+# service=loki-control), or starts `loki control serve` detached and waits for
+# it to publish one. Returns 1 when the caller should fall back to the old
+# dashboard (LOKI_CONTROL_DEFAULT=0, no bun, no python3, server did not start).
+_loki_control_live_url() {
+    local inst="${HOME}/.loki/control/instance.json" fields pid url health
+    [ -f "$inst" ] || return 1
+    fields=$(python3 - "$inst" 2>/dev/null <<'PY'
+import json, sys, urllib.parse
+d = json.load(open(sys.argv[1]))
+pid, url = d.get("pid"), d.get("url")
+if not isinstance(pid, int) or isinstance(pid, bool) or not isinstance(url, str):
+    sys.exit(1)
+u = urllib.parse.urlparse(url)
+if u.scheme != "http" or u.hostname not in ("127.0.0.1", "localhost", "::1"):
+    sys.exit(1)
+if u.path not in ("", "/") or u.query or u.fragment or u.params or "@" in u.netloc or "?" in url or "#" in url:
+    sys.exit(1)
+print(pid, url.rstrip("/"))
+PY
+) || return 1
+    pid="${fields%% *}"; url="${fields#* }"
+    kill -0 "$pid" 2>/dev/null || return 1
+    health=$(curl -g -s --max-time 2 "${url}/health" 2>/dev/null) || return 1
+    case "$health" in *'"service"'*'"loki-control"'*) ;; *) return 1 ;; esac
+    printf '%s\n' "$url"
+}
+
+_loki_control_ui() {
+    [ "${LOKI_CONTROL_DEFAULT:-1}" = "0" ] && return 1
+    local url="" open_it=1 arg i
+    for arg in "$@"; do [ "$arg" = "--no-open" ] && open_it=0; done
+    if [ "${LOKI_HEADLESS:-0}" = "1" ] || [ "${LOKI_NO_BROWSER:-0}" = "1" ]; then open_it=0; fi
+    command -v python3 >/dev/null 2>&1 || return 1
+    url=$(_loki_control_live_url) || url=""
+    if [ -z "$url" ]; then
+        if ! command -v bun >/dev/null 2>&1; then
+            echo "loki: the Control Plane needs bun (https://bun.sh); using the classic dashboard." >&2
+            return 1
+        fi
+        local cli="$SKILL_DIR/loki-ts/dist/loki.js" cdir="${HOME}/.loki/control" spid
+        [ -f "$cli" ] || cli="$SKILL_DIR/loki-ts/src/cli.ts"
+        mkdir -p "$cdir" && chmod 700 "$cdir" 2>/dev/null || true
+        LOKI_CONTROL=1 LOKI_NO_BROWSER=1 nohup bun "$cli" control serve >"$cdir/serve.log" 2>&1 </dev/null &
+        spid=$!
+        echo "$spid" > "$cdir/serve.pid" 2>/dev/null || true
+        for i in $(seq 1 100); do
+            url=$(_loki_control_live_url) && break
+            url=""
+            kill -0 "$spid" 2>/dev/null || break
+            sleep 0.1
+        done
+        if [ -z "$url" ]; then
+            echo "loki: the Control Plane did not start (see $cdir/serve.log); using the classic dashboard." >&2
+            return 1
+        fi
+    fi
+    if [ "$open_it" = "1" ]; then
+        loki_open_url "$url" || echo "$url"
+    else
+        echo "$url"
+    fi
+    return 0
+}
+
 cmd_ui() {
+    _loki_control_ui "$@" && return 0
     local port="" pid=""
     if [ -f "$DASHBOARD_PID_FILE" ]; then
         pid=$(cat "$DASHBOARD_PID_FILE" 2>/dev/null)
@@ -7325,16 +7392,15 @@ _loki_dashboard_bind_is_safe() {
 cmd_dashboard() {
     local subcommand="${1:-}"
 
-    # LOKI_CONTROL_DEFAULT=1 (off by default): open the Control Plane instead of the old dashboard.
-    # The old dashboard stays available when the flag is unset, and via `loki dashboard stop|status|url`.
-    if [ "${LOKI_CONTROL_DEFAULT:-0}" = "1" ]; then
-        case "$subcommand" in
-            ""|start|open)
-                echo "LOKI_CONTROL_DEFAULT=1: starting the Control Plane (unset it to use the old dashboard)"
-                LOKI_CONTROL=1 exec "$0" control serve
-                ;;
-        esac
-    fi
+    # The Control Plane is the default UI; LOKI_CONTROL_DEFAULT=0 restores the classic dashboard.
+    # Only the bare forms are taken over; `start --port ...` and friends keep the classic server.
+    case "$subcommand" in
+        ""|start|open)
+            if [ $# -le 1 ] || { [ $# -eq 2 ] && [ "$2" = "--no-open" ]; }; then
+                _loki_control_ui "${@:2}" && return 0
+            fi
+            ;;
+    esac
 
     # If no subcommand provided, show help (backward compatible with old behavior)
     if [ -z "$subcommand" ]; then
@@ -12921,10 +12987,10 @@ cmd_config_schema() {
     loki_config_generate_schema
 }
 
-# D65: multi-repo workspaces (D51 Phase B). Gated by LOKI_WORKSPACES=1.
+# D65: multi-repo workspaces (D51 Phase B). On by default; LOKI_WORKSPACES=0 disables.
 cmd_workspace() {
-    if [ "${LOKI_WORKSPACES:-}" != "1" ]; then
-        echo -e "${RED}loki workspace is disabled.${NC} Set LOKI_WORKSPACES=1 to use it." >&2
+    if [ "${LOKI_WORKSPACES:-}" = "0" ]; then
+        echo -e "${RED}loki workspace is disabled.${NC} Unset LOKI_WORKSPACES (it is set to 0)." >&2
         return 2
     fi
     command -v python3 >/dev/null 2>&1 || { echo -e "${RED}loki workspace: python3 is required${NC}" >&2; return 2; }
@@ -18714,10 +18780,12 @@ with open(manifest_path, 'w') as f:
 # usable.
 # ---------------------------------------------------------------------------
 cmd_verify() {
-    # D48: --pubkey verifies a receipt against a given public key (v10 engine, no ~/.loki needed).
+    # D48: --pubkey FILE or --pubkey=FILE (any position) verifies a receipt against a given public key (v10 engine, no ~/.loki needed).
     local _pk_arg
     for _pk_arg in "$@"; do
-        [ "$_pk_arg" = "--pubkey" ] && LOKI_ENGINE=v10 exec "$_LOKI_SCRIPT_DIR/../bin/loki" verify "$@"
+        case "$_pk_arg" in
+            --pubkey|--pubkey=*) LOKI_ENGINE=v10 exec "$_LOKI_SCRIPT_DIR/../bin/loki" verify "$@" ;;
+        esac
     done
     # --fast: deterministic checks only, in milliseconds. Measured on this repo
     # (1,932 tracked files): 298 ms cold, 87 ms warm, 19 ms diff-scoped, against

package/bin/loki

@@ -354,12 +354,12 @@ case "${LOKI_ENGINE:-$_loki_engine_default}" in
             # `loki <ref>`; any other start call (PRD file, flags first, one word) stays legacy.
             start)
                 case "${2:-}" in
-                    */*\#[0-9]*|http*://*/issues/*|http*://*/browse/*|*" "*) _e10=1; _e10_args=("${@:2}") ;;
+                    */*\#[0-9]*|http*://*/issues/*|http*://*/browse/*|jira:*|linear:*|https://linear.app/*/issue/*|*" "*) _e10=1; _e10_args=("${@:2}") ;;
                     *) _e10=0 ;;
                 esac
                 ;;
             # http*://*/issues/* also covers GitLab's /-/issues/ URLs.
-            */*\#[0-9]*|http*://*/issues/*|http*://*/browse/*) _e10=1 ;;
+            */*\#[0-9]*|http*://*/issues/*|http*://*/browse/*|jira:*|linear:*|https://linear.app/*/issue/*) _e10=1 ;;
             *" "*) _e10=1 ;;
             # ponytail: a one-word argument stays on the legacy CLI. The telemetry
             # allowlist is not a command registry (estimate, intent, outcomes are
@@ -567,7 +567,7 @@ fi
 # 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|rollback|internal|kpis|trust|proof|receipt|wiki|crash|control|contract)
+    version|--version|-v|status|stats|doctor|provider|memory|rollback|internal|kpis|trust|proof|receipt|wiki|crash|control|contract|slack|answer)
         # v7.5.2: rollback added (wires loki-ts/src/commands/rollback.ts).
         # v7.5.3: internal added for autonomy/run.sh phase1-hooks calls.
         # v7.5.28: kpis added (Phase K MVP: read-only KPI snapshot).

package/completions/_loki

@@ -206,6 +206,7 @@ function _loki_commands {
         'crash:Crash report management'
         'otel:OpenTelemetry management'
         'wiki:Wiki commands'
+        'answer:Resume a BLOCKED run with an answer'
         'control:Control plane (preview, LOKI_CONTROL=1)'
         'workspace:Multi-project workspaces (preview, LOKI_WORKSPACES=1)'
         'backlog:Run every matching open issue, N in parallel'

package/completions/loki.bash

@@ -5,7 +5,7 @@ _loki_completion() {
     _init_completion || return
 
     # Main subcommands (must match autonomy/loki main case statement)
-    local main_commands="start backlog quick monitor demo tour welcome init stop pause resume steer status next ship dashboard web serve api sandbox notify import github issue intent config provider reset memory compound checkpoint council dogfood projects enterprise secrets cockpit secure own handoff doctor watchdog audit metrics syslog onboard share proof receipt outcomes explain plan report cost estimate kpis stats test ci watch telemetry agent context ctx code run export review optimize heal modernize migrate cluster worktree wt trigger failover remote deploy docker mcp magic assets analyze compliance crash control workspace open otel preview quickstart rc rollback self-update sentrux setup-skill spec state template trust trust-metrics ultracode update verify voice why wiki bench cleanup logs grill docs cp version completions help keys"
+    local main_commands="start backlog quick monitor demo tour welcome init stop pause resume steer status next ship dashboard web serve api sandbox notify import github issue intent config provider reset memory compound checkpoint council dogfood projects enterprise secrets cockpit secure own handoff doctor watchdog audit metrics syslog onboard share proof receipt outcomes explain plan report cost estimate kpis stats test ci watch telemetry agent context ctx code run export review optimize heal modernize migrate cluster worktree wt trigger failover remote deploy docker mcp magic assets analyze compliance crash control workspace open otel preview quickstart rc rollback self-update sentrux setup-skill spec state template trust trust-metrics ultracode update verify voice why wiki bench cleanup logs grill docs cp version completions help keys answer"
 
     # 1. If we are on the first argument (subcommand)
     if [[ $cword -eq 1 ]]; then

package/dashboard/__init__.py

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

package/dashboard/api_start.py

@@ -21,6 +21,7 @@ import os
 import re
 import shutil
 import subprocess
+import sys
 import threading
 import time
 import urllib.error
@@ -156,6 +157,25 @@ def _project_dir() -> str:
     return os.environ.get("LOKI_PROJECT_DIR") or os.getcwd()
 
 
+def _autonomy_lib():
+    lib = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "autonomy", "lib")
+    if lib not in sys.path:
+        sys.path.insert(0, lib)
+
+
+def _workspaces_enabled() -> bool:
+    """Same rule as `loki workspace`: on by default, LOKI_WORKSPACES=0 disables."""
+    _autonomy_lib()
+    import workspace
+    return workspace.enabled()
+
+
+def _worktree_prep():
+    _autonomy_lib()
+    import worktree_prep
+    return worktree_prep
+
+
 def _prepare_workdir(repo: str, number: int, token: str) -> str:
     """One git worktree per issue, off the repo's default branch."""
     env = dict(os.environ, GH_TOKEN=token, GIT_TERMINAL_PROMPT="0")
@@ -180,7 +200,12 @@ def _prepare_workdir(repo: str, number: int, token: str) -> str:
     stamp = time.strftime("%Y%m%d%H%M%S")
     wt = _home() / "worktrees" / slug / ("issue-%d-%s" % (number, stamp))
     wt.parent.mkdir(parents=True, exist_ok=True)
-    _git("worktree", "add", "-b", "loki/backlog-%d-%s" % (number, stamp), str(wt), start, cwd=base)
+    branch = "loki/backlog-%d-%s" % (number, stamp)
+    if _workspaces_enabled():
+        # Shared worktree prep (D51-B06): same per-base lock and dep copy as backlog and workspace runs.
+        _worktree_prep().prepare_worktree(base, str(wt), branch, base=start)
+        return str(wt)
+    _git("worktree", "add", "-b", branch, str(wt), start, cwd=base)
     return str(wt)
 
 

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 The flagship product of [Autonomi](https://www.autonomi.dev/). Loki Mode is a spec-driven autonomous builder with a built-in trust layer that takes any spec to a deployed product and verifies completion with evidence (quality gates plus a completion council), not just a "done" claim. Complete installation instructions for all platforms and use cases.
 
-**Version:** v10.6.8
+**Version:** v10.6.9
 
 **Engine note:** `loki "<task>"`, `loki owner/repo#N` and `loki quick` run the Loki 10 engine. `loki start` still routes to the legacy engine, which is being removed (planned work resumes 2026-10-07); prefer `loki owner/repo#N`. See [docs/v10/GUIDE.md](v10/GUIDE.md).
 

package/docs/WORKSPACES.md

@@ -1,6 +1,6 @@
 # Workspaces: one issue across several repos
 
-Experimental, off by default. Set `LOKI_WORKSPACES=1` to enable. Design: `docs/v10/D51-PHASE-B.md`.
+On by default. Set `LOKI_WORKSPACES=0` to disable. Design: `docs/v10/D51-PHASE-B.md`.
 
 Define a group of repos once in `loki.yaml`:
 
@@ -13,17 +13,24 @@ workspaces:
     integration: {command: "make e2e", timeout_s: 900}
 ```
 
+Repos with no pending `after` run in parallel, at most `concurrency` at a time (default 2; set `LOKI_WORKSPACE_CONCURRENCY` to change it).
+
 Then:
 
 ```bash
-LOKI_WORKSPACES=1 loki workspace list
-LOKI_WORKSPACES=1 loki workspace run shop acme/api#12
+loki workspace list
+loki workspace show shop
+loki workspace run shop acme/api#12
+loki workspace status            # every recorded run, one row per repo
+loki workspace status <run-id>
 ```
 
 - Each repo gets its own git worktree on a `loki/ws-<run-id>-N` branch and its own engine run. Your checkouts are not touched.
 - `after` orders repos: a repo starts once its predecessors succeed. If a predecessor fails, its dependents are SKIPPED.
-- A failing repo does not stop the others (continue and report). The command exits 0 only when every repo succeeded and the integration step did not fail; otherwise 1.
+- A failing repo does not stop the others (continue and report). The command exits 0 only when every repo succeeded and the integration step did not fail. It exits 3 when the only non-ok outcomes are budget stops (a child exited 3, or a dependent was skipped behind one), and 1 for any other failure. Ctrl-C (SIGINT) stops the recorded child process groups like SIGTERM.
 - The repo that owns the issue ref gets the ref; other repos get a task text naming the ref and the sibling worktree paths as read-only context.
 - After all repos finish, the `integration` command runs once from the run directory with `LOKI_WS_DIR_<OWNER>_<REPO>` pointing at each worktree. A timeout counts as failed. With no integration configured the status is `not_configured`.
 - Evidence is written to `.loki/workspaces/<name>/<run-id>/integration.json`: head SHA per repo, exit code, log sha256. It is not part of the Seal.
 - Without `path`, a repo is cloned to `~/.loki/repos/owner__name`.
+- After the integration step, a PR comment is posted on each repo PR that exists for its run branch, showing the integration status (PASSED, FAILED, TIMEOUT or NOT CONFIGURED) and every head SHA. It uses your own `gh` login or GH_TOKEN, skips silently when there is no PR, never fails the run, and is disabled with `LOKI_WORKSPACE_COMMENT=0`.
+- Backlog (`loki backlog`) and dashboard starts now share the workspace worktree prep: a per-repo lock, a clean start point and copied dependencies. `LOKI_WORKSPACES=0` restores the previous worktree creation (D51-B05, D51-B06).

package/docs/control-plane-container.md

@@ -4,14 +4,17 @@ The Control Plane (run ingest API plus UI) ships as its own small image built
 from `Dockerfile.control-plane`. It serves on port 47821, stores its SQLite
 database under `/data`, runs as a non-root user and contains no secrets.
 
-The server has no authentication of its own. Keep it on a private network or
-behind an authenticating proxy; do not expose it publicly.
+The image binds 0.0.0.0, so `LOKI_CONTROL_TOKEN` is required at run time. Without
+it the server exits 2 before listening. Every `/v1/*` call then needs
+`Authorization: Bearer <token>`. The token is never baked into the image. Set
+`LOKI_CONTROL_ALLOW_INSECURE_BIND=1` only on a trusted private network; the
+server prints a warning when you do.
 
 ## Docker
 
 ```bash
 docker build -f Dockerfile.control-plane -t loki-control-plane .
-docker run -d -p 47821:47821 -v loki-control:/data loki-control-plane
+docker run -d -p 47821:47821 -e LOKI_CONTROL_TOKEN="$(openssl rand -hex 32)" -v loki-control:/data loki-control-plane
 LOKI_CONTROL_URL=http://localhost:47821 loki control status
 ```
 
@@ -42,4 +45,6 @@ EFS volume, secrets from Secrets Manager ARNs).
 | --- | --- | --- |
 | `PORT` | 47821 | listen port |
 | `LOKI_CONTROL_HOST` | 0.0.0.0 | bind address (outside the image: 127.0.0.1) |
+| `LOKI_CONTROL_TOKEN` | none (required) | bearer token for `/v1/*`; required on a non-loopback bind |
+| `LOKI_CONTROL_ALLOW_INSECURE_BIND` | unset | `1` accepts a tokenless non-loopback bind (not recommended) |
 | `LOKI_CONTROL_DB` | /data/control.db | SQLite path |

package/docs/dashboard-guide.md

@@ -482,3 +482,7 @@ Useful for:
 - [Agent Types](../references/agent-types.md) - Agent role definitions
 - [Quality Control](../references/quality-control.md) - Quality gates system
 - [Memory System](../references/memory-system.md) - Memory architecture
+
+## Control Plane by default
+
+Bare `loki` and `loki dashboard` (also `start` or `open` with no other flags) open the Control Plane. If `~/.loki/control/instance.json` names a live loopback server whose `/health` reports `service=loki-control`, that URL is reused; otherwise `loki control serve` is started detached and its PID is recorded in `~/.loki/control/serve.pid`. With `LOKI_HEADLESS=1`, `LOKI_NO_BROWSER=1` or `--no-open` the URL is printed and no browser is opened. Without bun, Loki prints one line naming bun and uses the classic dashboard. Set `LOKI_CONTROL_DEFAULT=0` to always use the classic dashboard. Multi-repo `loki workspace` is on by default; `LOKI_WORKSPACES=0` disables it.

package/docs/exit-codes.md

@@ -104,6 +104,7 @@ never the local JWKS. Exits: 0 VERIFIED, 1 TAMPERED, 2 UNCHECKED (kid does not
 match the key, or the key file is unusable), 3 UNSIGNED (a receipt with no
 signature is refused even with `--allow-unsigned`, because the caller asked for a
 signature check), 4 run outcome not verified (checked before UNSIGNED).
+`--pubkey` may come before or after the run-id and may be written `--pubkey=FILE`; `--pubkey` with no file or an empty `--pubkey=`, a repeated `--pubkey`, an unknown option, or more than one run-id exits 2.
 
 An early draft spec listed `1=BLOCKED, 2=CONCERNS`. That ordering was rejected:
 it is not used anywhere, it has no consumers, and it inverts the

package/docs/slack.md

@@ -1,9 +1,10 @@
-# Two-way Slack (preview)
+# Two-way Slack
 
-Off by default. Set `LOKI_SLACK_INBOUND=1` to enable the inbound handler.
+On by default. Set `LOKI_SLACK_INBOUND=0` to disable the inbound handler (`loki slack serve` then exits 2).
+
+Without `SLACK_BOT_TOKEN` or `SLACK_SIGNING_SECRET`, `loki slack serve` prints one line naming both and exits 2 without binding a port.
 
 ```bash
-export LOKI_SLACK_INBOUND=1
 export SLACK_BOT_TOKEN=...        # from env only, never stored by Loki
 export SLACK_SIGNING_SECRET=...
 loki slack serve --port 3000      # binds 127.0.0.1 unless --host is given
@@ -13,10 +14,17 @@ Point the Slack Events API request URL at this server through a tunnel or revers
 
 ## What it does
 
-- `@loki <issue ref or task text>` in a channel starts a Loki 10 run (the same entry as `loki "<task>"`) and replies in the thread with the run id.
+- `@loki <issue ref or task text>` in a channel starts a Loki 10 run (it launches `bin/loki "<task>"`; the text must be at least two words and must not start with `-`, otherwise the bot replies asking you to describe the task, so a lone word like `reset` can never reach a legacy subcommand) and replies in the thread with the run id.
 - When the run ends BLOCKED, the question is posted in the same thread. A reply in that thread starts a follow-up run with your answer added to the original task (v10 has no in-place resume, BLOCKED is terminal).
+- Runs are launched through the repo `bin/loki` with the two Slack secrets removed from the child environment and `LOKI_NO_BROWSER=1` set. A failed Slack post logs one redacted line to stderr.
 - Every request is verified with the Slack signature (HMAC sha256 over `v0:timestamp:body`, constant-time compare, timestamps older than 5 minutes are rejected). Retried events are deduplicated.
 
+## Who can start a run
+
+Set `LOKI_SLACK_ALLOWED_USERS` to a comma-separated list of Slack user IDs (for example `U012ABC,U034DEF`). A mention or a BLOCKED-thread answer from any other user is rejected with a short thread reply and nothing is spawned. When it is unset, anyone who can mention the bot can start a run, and `loki slack serve` prints one startup line saying so.
+
+Limits: task text over 64 KB is rejected with "task too long" and no run starts. If a run cannot be launched, the thread gets a generic message and the detail (which may include local paths) is logged to stderr only. `--port` must be a whole number (an empty value exits 2).
+
 ## App manifest scopes
 
 Bot token scopes: `app_mentions:read`, `chat:write`, `channels:history` (and `groups:history` for private channels, `im:history` for DMs).

package/docs/trackers.md

@@ -0,0 +1,27 @@
+# Jira and Linear intake
+
+Loki 10 can start a run from a Jira or Linear issue. This is intake only: the issue is fetched once, before any model runs, and normalized into the same `issue.json` GitHub intake writes (with a `source` field of `jira` or `linear`). Loki does not write back to the tracker or sync status.
+
+```bash
+loki jira:PROJ-123
+loki linear:ENG-42
+```
+
+## Credentials (environment only)
+
+- Jira: `JIRA_EMAIL`, `JIRA_API_TOKEN` and `JIRA_BASE_URL` (for example `https://acme.atlassian.net`). `JIRA_BASE_URL` may be omitted when you pass an `atlassian.net` browse URL.
+- Linear: `LINEAR_API_KEY`.
+
+A missing variable stops the run with an error that names it. A Linear HTTP 401, or a GraphQL response with errors and no data, also names `LINEAR_API_KEY`.
+
+## Self-hosted Jira
+
+`<JIRA_BASE_URL>/browse/KEY` is accepted as a ref only when its origin equals the origin of `JIRA_BASE_URL`. A browse URL on any other host is not treated as a tracker ref.
+
+## Kill switch
+
+`LOKI_TRACKER_INTAKE=0` disables Jira and Linear refs entirely; they are then treated as ordinary text.
+
+## Safety
+
+Issue text is untrusted input. It is passed to the run as data and never grants tool authority.