loki-mode 10.6.7 → 10.6.9

package/autonomy/loki

@@ -1630,6 +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=0 disables)"
     echo "  quickstart [idea]  Guided first build: setup, idea, template, plan, go"
     echo ""
     echo "Session:"
@@ -1782,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 ""
@@ -1896,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)
@@ -7324,6 +7392,16 @@ _loki_dashboard_bind_is_safe() {
 cmd_dashboard() {
     local subcommand="${1:-}"
 
+    # 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
         cmd_dashboard_help
@@ -12909,6 +12987,16 @@ cmd_config_schema() {
     loki_config_generate_schema
 }
 
+# D65: multi-repo workspaces (D51 Phase B). On by default; LOKI_WORKSPACES=0 disables.
+cmd_workspace() {
+    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; }
+    python3 "$_LOKI_SCRIPT_DIR/lib/workspace.py" "$@"
+}
+
 # D51: headless backlog runner. One v10 issue-mode run per open issue, each in
 # its own worktree and branch, at most N in parallel (loki.yaml concurrency).
 cmd_backlog() {
@@ -18692,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
@@ -21922,6 +22012,9 @@ main() {
         backlog)
             cmd_backlog "$@"
             ;;
+        workspace)
+            cmd_workspace "$@"
+            ;;
         config)
             cmd_config "$@"
             ;;

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)
+    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,7 +206,9 @@ 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'
         'explain:Explain Loki concepts'
         'optimize:Optimization commands'

package/completions/loki.bash

@@ -5,8 +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 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 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 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 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.7"
+__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.7
+**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/WANG-PRINCIPLES-PLAN.md

@@ -53,7 +53,7 @@ Measured on this machine, not asserted.
 | **1 Systems Thinking** | STRONG | 8 quality gates, RARV-C loop, council, Evidence Receipt, dual-route parity enforced by test |
 | **2 Speed** | MEASURED, UNOPTIMISED | agent call = **980s = 96%** of iteration; all gates together = 44s |
 | **3 Reliability** | STRONG, newly so | 73 mutation-proven trust invariants; four gates were shipping broken until v8.38.0 |
-| **4 Extensibility** | STRONG | 5 providers, agent type registry, MCP (36 tools), plugin marketplace |
+| **4 Extensibility** | STRONG | 5 providers, agent type registry, MCP (39 tools), plugin marketplace |
 | **5 Feedback Loops / Evals** | **BROKEN** | `cost_usd == 0` on **3 of 5** efficiency records; no eval score for our own harness |
 
 **Principle 5 is the gap, and it is the one Wang weights highest.** He states the

package/docs/WORKSPACES.md

@@ -0,0 +1,36 @@
+# Workspaces: one issue across several repos
+
+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`:
+
+```yaml
+workspaces:
+  shop:
+    repos:
+      - {repo: acme/api, path: ~/src/api, setup: "npm ci"}
+      - {repo: acme/web, path: ~/src/web, after: [acme/api]}
+    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 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. 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/alternative-installations.md

@@ -84,11 +84,13 @@ jobs:
 |-------|---------|-------------|
 | `mode` | `review` | `review`, `fix`, or `test` |
 | `provider` | `claude` | `claude` (recommended), `cline`, `codex`, `aider`, or `opencode`. `gemini` was REMOVED in v7.5.18. |
-| `budget_limit` | `5.00` | Max cost in USD |
+| `budget_limit` | `5.00` | Max cost in USD (passed to the Loki 10 engine as `--max-cost`) |
 | `max_iterations` | `3` | Max RARV cycles |
 | `github_token` | (required) | GitHub token for PR comments |
 | `prd_file` | | Path to PRD file (for fix/test modes) |
 
+**Engine:** every mode runs the Loki 10 engine through `loki start "<task>" --no-pr --provider <name> --max-cost <usd>` (the same path as `loki start owner/repo#N`), with `LOKI_ENGINE=v10`. The PRD file or PR diff is folded into the task text. The action never opens a PR itself (Rule of Two). A run that crosses the cap ends BUDGET_STOP (exit 3). The legacy `--simple` path is no longer used.
+
 **Modes:**
 
 | Mode | Description |

package/docs/control-plane-container.md

@@ -0,0 +1,50 @@
+# Run the Control Plane in a container
+
+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 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 -e LOKI_CONTROL_TOKEN="$(openssl rand -hex 32)" -v loki-control:/data loki-control-plane
+LOKI_CONTROL_URL=http://localhost:47821 loki control status
+```
+
+Health: `/health` (liveness) and `/ready` (database check).
+
+## Helm
+
+```bash
+helm install loki-control ./deploy/helm/control-plane \
+  --namespace loki --create-namespace \
+  --set image.repository=<your-registry>/loki-control-plane \
+  --set existingSecret=autonomi-secrets \
+  --set 'secretKeys={ANTHROPIC_API_KEY}'
+```
+
+Provider keys are read from an existing Kubernetes Secret you name with
+`existingSecret`; nothing is stored in values. Ingress is off by default
+(`ingress.enabled=true` to turn it on). Keep `replicas: 1` (single SQLite volume).
+
+## ECS
+
+See `deploy/ecs/README.md` and `deploy/ecs/control-plane-task.json` (Fargate,
+EFS volume, secrets from Secrets Manager ARNs).
+
+## Configuration
+
+| Variable | Default in image | Meaning |
+| --- | --- | --- |
+| `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/dev/architecture-reference.md

@@ -97,3 +97,7 @@ Default-on in the Bun runner (see `CHANGELOG.md` v7.x entries; documented in `sk
 - `LOKI_HANDOFF_MD` -- write a structured handoff doc before iteration close.
 
 These knobs together implement the RARV-C (closure) loop: findings -> override council -> learnings -> handoff. Reference: `skills/quality-gates.md`, `CHANGELOG.md` entries from v7.x for default-on flip and override-council semantics.
+
+## Worktree substrate (autonomy/lib/worktree_prep.py)
+
+`prepare_worktree(source_repo, dest, branch, setup=None, base=None)` creates an isolated git worktree and returns `{path, base_sha, deps, left_out_changes}`. The start point is `origin/HEAD` after a fetch (when a remote exists), else HEAD. Uncommitted edits in the source checkout are never carried or stashed; their count is reported as `left_out_changes`. An fcntl lock at `~/.loki/repos/<slug>.lock` covers fetch and worktree add. Dependencies: a `setup` command run in the worktree, else a copy-on-write copy of ignored top-level `node_modules`, `.venv`, `venv`, `vendor` (refused as "copy unsafe, declare setup" if it holds absolute symlinks or editable finders), else `none`. CLI: `python3 autonomy/lib/worktree_prep.py SRC DEST BRANCH [--setup CMD] [--base REF]` prints the result as JSON. Not yet wired into backlog or the UI.

package/docs/dev/project-structure.md

@@ -91,7 +91,7 @@ Line counts approximate; re-run `wc -l` for exact.
 | `memory/storage.py` | ~2,000 | File-based memory backend |
 | `memory/engine.py` | ~1,600 | Memory orchestrator |
 | `memory/consolidation.py` | ~1,100 | Episodic-to-semantic pipeline |
-| `mcp/server.py` | ~2,700 | MCP server (36 tools: 28 in-file + 7 magic + 1 gated managed; +3 resources, 2 prompts) |
+| `mcp/server.py` | ~2,700 | MCP server (39 tools: 31 in-file + 7 magic + 1 gated managed; +3 resources, 2 prompts) |
 | `providers/loader.sh` | ~185 | Provider loader |
 
 ### Key Function Lookup

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

@@ -0,0 +1,34 @@
+# Two-way Slack
+
+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 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
+```
+
+Point the Slack Events API request URL at this server through a tunnel or reverse proxy you control.
+
+## What it does
+
+- `@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).
+
+Subscribe to bot events: `app_mention`, `message.channels` (plus `message.groups` for private channels).
+
+Outbound notifications (PR opened, BLOCKED, finished) are separate and use `LOKI_SLACK_WEBHOOK_URL`.

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.