loki-mode 11.7.1 → 11.8.1

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: An autonomous software factory that knows what it is supposed to deliver, and proves it did. Use when the user says Loki Mode or asks to build, fix or verify software autonomously.
 ---
 
-# Loki Mode v11.7.1
+# Loki Mode v11.8.1
 
 **Current entry points (Loki 10 engine):** `loki "<task>"`, `loki owner/repo#N` and `loki quick "<task>"` run the Loki 10 engine and end with a signed receipt (`loki verify`). `loki backlog owner/repo --all` runs many issues in parallel. Guide: `docs/v10/GUIDE.md`. The skill instructions below, and `loki start`, describe the previous bash loop. PRD-file starts (`loki start ./prd.md`) and the opencode provider still run on it until FC38-SWEEP ports them; the legacy-engine command and the LOKI_ENGINE switch remain removed. Prefer `loki owner/repo#N` for issues.
 
@@ -483,4 +483,4 @@ See `CHANGELOG.md` entries [7.5.7], [7.5.8], [7.5.13] for the per-fix list and r
 
 ---
 
-**v11.7.1 | [Autonomi](https://www.autonomi.dev/) flagship product | core skill**
+**v11.8.1 | [Autonomi](https://www.autonomi.dev/) flagship product | core skill**

package/VERSION

@@ -1 +1 @@
-11.7.1
+11.8.1

package/autonomy/lib/backlog.py

@@ -195,7 +195,8 @@ def load_dag(path, group):
         if task.lstrip().startswith("-"):
             raise ValueError("unit %s task text starts with '-' and would be read as an option" % uid)
         units.append({"n": n, "id": uid, "deps": deps[uid], "write_set": list(u.get("writeSet") or []),
-                      "task": task})
+                      "task": task, "done": u.get("done") is True,
+                      "spec": u["spec"] if isinstance(u.get("spec"), str) and os.path.isabs(u["spec"]) else ""})
     return group, units
 
 
@@ -313,7 +314,10 @@ def main(argv):
                    "cmd": [launcher, u["task"], "--no-pr"],
                    "deps": [key_of[d] for d in u["deps"]],
                    "env": {"LOKI_GROUP_ID": group, "LOKI_UNIT_ID": u["id"], "LOKI_UNIT_N": str(u["n"]),
-                           "LOKI_UNIT_DEPS": ",".join(u["deps"]), "LOKI_UNIT_WRITE_SET": "\n".join(u["write_set"])}}
+                           "LOKI_UNIT_DEPS": ",".join(u["deps"]), "LOKI_UNIT_WRITE_SET": "\n".join(u["write_set"])},
+                   "done": u["done"]}
+        if u["spec"]:  # frozen group acceptance for unit_mode (wall.ts)
+            spec[k]["env"].update(LOKI_UNIT_SPEC=u["spec"], LOKI_SPEED="1")
     state = {k: {"status": "queued", "ok": None, "cost": None, "ran": False} for k in spec}
     for k in state:
         say("backlog: %s queued" % spec[k]["label"])
@@ -331,6 +335,32 @@ def main(argv):
     signal.signal(signal.SIGTERM, stop_children)
     signal.signal(signal.SIGINT, stop_children)
 
+    def harvest(k, wt):
+        """Copy the newest unit receipt and events into the group dir before the worktree goes."""
+        gid = spec[k]["env"].get("LOKI_GROUP_ID")
+        uid = spec[k]["env"].get("LOKI_UNIT_ID")
+        if not (spec[k]["unit"] and gid and uid):
+            return
+        try:
+            runs = os.path.join(wt, ".loki", "runs")
+            cands = [os.path.join(runs, d) for d in os.listdir(runs)
+                     if not os.path.islink(os.path.join(runs, d))
+                     and os.path.isfile(os.path.join(runs, d, "receipt.json"))]
+            if not cands:
+                return
+            src_dir = max(cands, key=lambda d: os.path.getmtime(os.path.join(d, "receipt.json")))
+            dst_dir = os.path.join(top, ".loki", "groups", gid, "group", "units", uid)
+            os.makedirs(dst_dir, mode=0o700, exist_ok=True)
+            for name in ("receipt.json", "events.jsonl"):
+                src, dst = os.path.join(src_dir, name), os.path.join(dst_dir, name)
+                if os.path.islink(src) or os.path.islink(dst) or not os.path.isfile(src):
+                    continue
+                tmp = dst + ".tmp%d" % os.getpid()
+                shutil.copyfile(src, tmp)
+                os.replace(tmp, dst)
+        except OSError:
+            pass
+
     def finish(k):
         nonlocal unmeasured
         p, log, wt = running.pop(k)
@@ -348,6 +378,7 @@ def main(argv):
             add_spend(usd)
         state[k].update(status=status, ok=ok, cost=usd)
         say("backlog: %s %s" % (spec[k]["label"], status))
+        harvest(k, wt)
         if ok:
             git("worktree", "remove", "--force", wt, cwd=top)
             if not spec[k]["unit"]:  # a passing unit branch is kept for the integrator
@@ -414,6 +445,10 @@ def main(argv):
             k = next_ready()
             if k is None:
                 break
+            if spec[k].get("done"):
+                state[k].update(status="VERIFIED (resumed)", ok=True)
+                say("backlog: %s VERIFIED (resumed)" % spec[k]["label"])
+                continue
             launch(k)
         if running:
             time.sleep(0.2)

package/autonomy/lib/chat.sh

@@ -47,7 +47,7 @@ Loki chat commands:
   /attach            attach to the current or most recent loki start run in this repo
   /quick <task>      loki quick
   /edit <change>     apply one change (build mode for this turn)
-  /verify            loki verify
+  /verify [path] [--max-age 7d]  loki verify (a receipt path, group receipt, or age limit)
   /receipt           loki receipt
   /model <id>        set model for this session
   /provider <name>   switch provider (claude, codex, cline, aider, opencode)
@@ -351,7 +351,8 @@ Question: $line" || true
             /edit)
                 [ -n "$rest" ] || { echo "usage: /edit <change>"; continue; }
                 _chat_send build "$rest" ;;
-            /verify) _chat_do "$loki" verify ;;
+            /verify) # shellcheck disable=SC2086
+                _chat_do "$loki" verify $rest ;;
             /receipt) _chat_do "$loki" receipt ;;
             /cost) _chat_do "$loki" cost ;;
             /undo) # shellcheck disable=SC2086

package/autonomy/loki

@@ -18134,7 +18134,7 @@ cmd_verify() {
     # verified by the engine10 verifier directly; bin/loki sends a bare verify back here.
     for _pk_arg in "$@"; do
         case "$_pk_arg" in
-            composite.json|*/composite.json|--seal-composite|--seal-composite=*)
+            composite.json|*/composite.json|--seal-composite|--seal-composite=*|--max-age|--max-age=*|.loki/groups/*/receipt.json|*/.loki/groups/*/receipt.json)
                 _loki_bun_delegate engine10 verify "$@"
                 return $? ;;
         esac

package/autonomy/trigger-server.py

@@ -55,8 +55,10 @@ import subprocess
 import sys
 import threading
 import time
+import urllib.parse
 from datetime import datetime
 from pathlib import Path
+from urllib.request import Request, urlopen
 
 # Receipt attestation. Imported by path because trigger-server.py runs as a
 # script from an arbitrary cwd, so a bare `import receipt_jwt` would depend on
@@ -412,6 +414,10 @@ CHILD_ENV_DENYLIST = (
     "LOKI_API_TOKEN_FILE",
     "LOKI_SENTRY_WEBHOOK_SECRET",
     "SENTRY_CLIENT_SECRET",
+    "SLACK_SIGNING_SECRET",
+    "SLACK_BOT_TOKEN",
+    "LINEAR_WEBHOOK_SECRET",
+    "LINEAR_API_KEY",
 )
 
 
@@ -622,6 +628,110 @@ def validate_sentry_signature(secret, body, signature_header):
     return constant_time_equals(expected, signature_header.strip().lower())
 
 
+# Slack and Linear delegation. Same signed-body contract as
+# loki-ts/src/contrib/slack_inbound.ts (signSlackBody/verifySlackSignature).
+SIGNATURE_MAX_SKEW_S = 300
+SLACK_REPLY_PREFIX = "https://hooks.slack.com/"
+LINEAR_API_URL = "https://api.linear.app/graphql"
+LINEAR_IDENTIFIER_RE = re.compile(r"^[A-Za-z][A-Za-z0-9]*-\d+$")
+NOTIFY_TIMEOUT_SECONDS = 10
+NOTIFY_TEXT_MAX = 1000
+
+
+def sign_slack_body(secret, timestamp, body):
+    """`v0=` + hex HMAC-SHA256 over `v0:<timestamp>:<raw body>` (bytes)."""
+    base = b"v0:" + str(timestamp).encode("utf-8") + b":" + body
+    return "v0=" + hmac.new(secret.encode("utf-8"), base, hashlib.sha256).hexdigest()
+
+
+def verify_slack_signature(secret, timestamp, body, signature, now=None):
+    """Fail closed: no secret, header, numeric timestamp or fresh window -> False."""
+    if not secret or not timestamp or not signature:
+        return False
+    if not re.fullmatch(r"[0-9]+", timestamp):
+        return False
+    now = time.time() if now is None else now
+    if abs(now - int(timestamp)) > SIGNATURE_MAX_SKEW_S:
+        return False
+    return constant_time_equals(sign_slack_body(secret, timestamp, body), signature)
+
+
+def verify_linear_signature(secret, body, signature):
+    """Linear-Signature: hex HMAC-SHA256 of the raw body. Freshness is checked
+    separately against the signed body's webhookTimestamp (linear_fresh)."""
+    if not secret or not signature:
+        return False
+    expected = hmac.new(secret.encode("utf-8"), body, hashlib.sha256).hexdigest()
+    return constant_time_equals(expected, signature.strip().lower())
+
+
+def linear_fresh(payload, now=None):
+    ts_val = payload.get("webhookTimestamp")
+    if isinstance(ts_val, bool) or not isinstance(ts_val, (int, float)):
+        return False
+    secs = ts_val / 1000.0 if ts_val > 1e11 else float(ts_val)
+    now = time.time() if now is None else now
+    return abs(now - secs) <= SIGNATURE_MAX_SKEW_S
+
+
+def resolve_chat_secrets(env, secret, api_token, sentry_secret):
+    """Return (slack_secret, linear_secret), blanking any that equals another
+    credential: each authenticates a different party and MUST differ."""
+    slack = env.get("SLACK_SIGNING_SECRET", "")
+    linear = env.get("LINEAR_WEBHOOK_SECRET", "")
+    others = [x for x in (secret, api_token, sentry_secret) if x]
+    slack_bad = bool(slack) and any(
+        constant_time_equals(slack, o) for o in others + ([linear] if linear else []))
+    linear_bad = bool(linear) and any(
+        constant_time_equals(linear, o) for o in others + ([slack] if slack else []))
+    if slack_bad:
+        logging.error("The Slack secret is identical to another credential. "
+                      "They MUST differ; disabling /slack.")
+    if linear_bad:
+        logging.error("The Linear secret is identical to another credential. "
+                      "They MUST differ; disabling /linear.")
+    return ("" if slack_bad else slack), ("" if linear_bad else linear)
+
+
+def _post_json(url, data, headers):
+    """POST JSON with a bounded timeout. Raises on any failure; callers log."""
+    req = Request(url, data=json.dumps(data).encode("utf-8"),
+                  headers=dict(headers, **{"Content-Type": "application/json"}),
+                  method="POST")
+    with urlopen(req, timeout=NOTIFY_TIMEOUT_SECONDS) as resp:
+        resp.read()
+
+
+def notify_job_complete(target, job_id, status, summary):
+    """Send a completion summary to a reply target captured after verification.
+
+    Never raises: a notifier failure must not fail the job. The Slack URL is
+    re-checked here as defense in depth.
+    """
+    if not isinstance(target, dict):
+        return
+    text = ("loki job %s finished: %s. %s" % (job_id, status, summary or "")).strip()
+    text = CONTROL_CHARS_RE.sub(" ", text)[:NOTIFY_TEXT_MAX]
+    try:
+        if target.get("kind") == "slack":
+            url = target.get("response_url", "")
+            if not (isinstance(url, str) and url.startswith(SLACK_REPLY_PREFIX)):
+                return
+            _post_json(url, {"response_type": "in_channel", "text": text}, {})
+        elif target.get("kind") == "linear":
+            key = os.environ.get("LINEAR_API_KEY", "")
+            issue_id = target.get("issue_id", "")
+            if not key or not isinstance(issue_id, str) or not issue_id:
+                return
+            _post_json(LINEAR_API_URL, {
+                "query": "mutation($i:String!,$b:String!){commentCreate(input:"
+                         "{issueId:$i,body:$b}){success}}",
+                "variables": {"i": issue_id, "b": text},
+            }, {"Authorization": key})
+    except Exception as e:  # notifier errors never fail a job
+        logging.warning("Completion notify for job %s failed: %s", job_id, e)
+
+
 def normalize_sentry_payload(payload):
     """Run the existing normalize_sentry_json over a Sentry webhook payload.
 
@@ -750,6 +860,9 @@ class Dispatcher:
         self._job_max = max(1, job_history)
         self._jobs = collections.OrderedDict()
         self._jobs_lock = threading.Lock()
+        # Reply targets (Slack response_url / Linear issue) keyed by job_id,
+        # written only by the verified /slack and /linear handlers.
+        self._reply_targets = collections.OrderedDict()
         # Proof-attribution bookkeeping. The proof pointer is global to the
         # working directory, so a receipt only identifies a job when that job
         # was the only build that could have written it. All three are updated
@@ -887,6 +1000,17 @@ class Dispatcher:
             if summary:
                 entry["summary"] = summary
 
+    def set_reply_target(self, job_id, target):
+        """Store a verified reply target server side, bounded like _jobs."""
+        with self._jobs_lock:
+            self._reply_targets[job_id] = target
+            while len(self._reply_targets) > self._job_max:
+                self._reply_targets.popitem(last=False)
+
+    def pop_reply_target(self, job_id):
+        with self._jobs_lock:
+            return self._reply_targets.pop(job_id, None)
+
     def get_job(self, job_id):
         """Return a copy of the job record, or None if unknown/evicted.
 
@@ -980,6 +1104,9 @@ class Dispatcher:
                 )
                 if job_id:
                     self.record_job(job_id, status, summary or "")
+                    target = self.pop_reply_target(job_id)
+                    if target is not None:
+                        notify_job_complete(target, job_id, status, summary)
             finally:
                 self.queue.task_done()
 
@@ -998,6 +1125,10 @@ class WebhookHandler(http.server.BaseHTTPRequestHandler):
     api_token = ""
     # Sentry integration client secret for /sentry. Distinct from both above.
     sentry_secret = ""
+    # Slack signing secret (/slack) and Linear webhook secret (/linear), each
+    # distinct from every other credential.
+    slack_secret = ""
+    linear_secret = ""
     dispatcher = None
     # Ed25519 key that attests receipts, and the retired public keys that keep
     # pre-rotation receipts verifiable. Both default to unconfigured, which
@@ -1278,8 +1409,19 @@ class WebhookHandler(http.server.BaseHTTPRequestHandler):
             self._send_json(400, {"error": "invalid spec"})
             return
 
+        job_id = self._enqueue_job(spec.strip())
+        if job_id is None:
+            return
+        self._send_json(202, {"id": job_id, "status": "queued"})
+
+    def _enqueue_job(self, spec, reply_target=None):
+        """Record and enqueue one validated job; shared by /jobs, /slack, /linear.
+
+        Returns the job id, or None after sending 429 when the queue is full.
+        reply_target must come from an already-verified request.
+        """
         job_id = secrets.token_urlsafe(12)
-        job = {"spec": spec.strip(), "job_id": job_id}
+        job = {"spec": spec, "job_id": job_id}
 
         # Record BEFORE enqueueing. A worker can pick the job up the instant
         # submit() returns and write "running"/"fired"; record_job is
@@ -1288,6 +1430,8 @@ class WebhookHandler(http.server.BaseHTTPRequestHandler):
         # forever. On the 429 path below the record is unreachable (no id is
         # handed out) and the store is bounded, so nothing leaks.
         self.dispatcher.record_job(job_id, "queued", job["spec"])
+        if reply_target is not None:
+            self.dispatcher.set_reply_target(job_id, reply_target)
 
         # Enforce the existing queue bound so a submit storm cannot fork
         # unbounded builds. 429 (not a silent drop) tells the client to retry.
@@ -1295,11 +1439,111 @@ class WebhookHandler(http.server.BaseHTTPRequestHandler):
             logging.warning(
                 "Queue full; shedding job submit from %s", self.address_string()
             )
+            self.dispatcher.pop_reply_target(job_id)
             log_event(JOB_EVENT, "", "", "rejected (queue full)")
             self._send_json(429, {"error": "server busy, retry later"})
-            return
+            return None
 
         log_event(JOB_EVENT, "", job["spec"], "queued")
+        return job_id
+
+    def _handle_slack(self):
+        """POST /slack -- signed slash command; enqueues a job, ephemeral reply."""
+        body = self._read_body()
+        if body is None:
+            return
+        if not self.slack_secret:
+            log_event(JOB_EVENT, "", "", "rejected (no slack signing secret configured)")
+            self._send_json(503, {"error": "SLACK_SIGNING_SECRET not configured"})
+            return
+        if not verify_slack_signature(
+                self.slack_secret,
+                self.headers.get("X-Slack-Request-Timestamp", ""),
+                body, self.headers.get("X-Slack-Signature", "")):
+            logging.warning("Invalid Slack signature from %s", self.address_string())
+            log_event(JOB_EVENT, "", "", "rejected (invalid slack signature)")
+            self._send_json(401, {"error": "invalid signature"})
+            return
+        # Verified from here on.
+        ctype = (self.headers.get("Content-Type", "") or "").lower()
+        if "json" in ctype:
+            try:
+                data = json.loads(body)
+            except ValueError:
+                self._send_json(400, {"error": "invalid JSON"})
+                return
+            if isinstance(data, dict) and data.get("type") == "url_verification":
+                self._send_json(200, {"challenge": str(data.get("challenge", ""))})
+                return
+            self._send_json(400, {"error": "unsupported slack payload"})
+            return
+        form = urllib.parse.parse_qs(body.decode("utf-8", errors="replace"))
+        text = (form.get("text") or [""])[0]
+        if not valid_spec(text):
+            log_event(JOB_EVENT, "", "", "rejected (invalid slack spec)")
+            self._send_json(200, {"response_type": "ephemeral",
+                                  "text": "Usage: /loki <spec>. Spec must be a "
+                                          "one-line brief or ref, not starting with '-'."})
+            return
+        response_url = (form.get("response_url") or [""])[0]
+        target = {"kind": "slack"}
+        if response_url.startswith(SLACK_REPLY_PREFIX):
+            target["response_url"] = response_url
+        job_id = self._enqueue_job(text.strip(), target)
+        if job_id is None:
+            return
+        self._send_json(200, {"response_type": "ephemeral",
+                              "text": "Queued loki job %s" % job_id})
+
+    def _handle_linear(self):
+        """POST /linear -- signed Linear issue webhook; enqueues linear:<identifier>."""
+        body = self._read_body()
+        if body is None:
+            return
+        if not self.linear_secret:
+            log_event(JOB_EVENT, "", "", "rejected (no linear webhook secret configured)")
+            self._send_json(503, {"error": "LINEAR_WEBHOOK_SECRET not configured"})
+            return
+        if not verify_linear_signature(
+                self.linear_secret, body, self.headers.get("Linear-Signature", "")):
+            logging.warning("Invalid Linear signature from %s", self.address_string())
+            log_event(JOB_EVENT, "", "", "rejected (invalid linear signature)")
+            self._send_json(401, {"error": "invalid signature"})
+            return
+        try:
+            payload = json.loads(body)
+        except ValueError:
+            self._send_json(400, {"error": "invalid JSON"})
+            return
+        if not isinstance(payload, dict):
+            self._send_json(400, {"error": "payload must be a JSON object"})
+            return
+        if not linear_fresh(payload):
+            log_event(JOB_EVENT, "", "", "rejected (stale linear timestamp)")
+            self._send_json(401, {"error": "stale or missing webhookTimestamp"})
+            return
+        data = payload.get("data")
+        if (payload.get("type") != "Issue" or payload.get("action") != "create"
+                or not isinstance(data, dict)):
+            self._send_json(200, {"status": "skipped"})
+            return
+        ident = data.get("identifier")
+        if not isinstance(ident, str) or not LINEAR_IDENTIFIER_RE.match(ident):
+            self._send_json(400, {"error": "invalid issue identifier"})
+            return
+        if self.dispatcher.seen_delivery(self.headers.get("Linear-Delivery", "")):
+            self._send_json(200, {"status": "duplicate"})
+            return
+        spec = "linear:%s" % ident
+        if not valid_spec(spec):
+            self._send_json(400, {"error": "invalid spec"})
+            return
+        issue_id = data.get("id")
+        target = {"kind": "linear",
+                  "issue_id": issue_id if isinstance(issue_id, str) else ""}
+        job_id = self._enqueue_job(spec, target)
+        if job_id is None:
+            return
         self._send_json(202, {"id": job_id, "status": "queued"})
 
     def _handle_sentry(self):
@@ -1347,6 +1591,12 @@ class WebhookHandler(http.server.BaseHTTPRequestHandler):
         if path == "/sentry":
             self._handle_sentry()
             return
+        if path == "/slack":
+            self._handle_slack()
+            return
+        if path == "/linear":
+            self._handle_linear()
+            return
         if path != "/webhook":
             self._send_json(404, {"error": "not found"})
             return
@@ -1527,6 +1777,11 @@ def main():
         )
         sentry_secret = ""
 
+    # Slack/Linear secrets: env only. Each must differ from every other
+    # credential, since each authenticates a different party.
+    slack_secret, linear_secret = resolve_chat_secrets(
+        os.environ, secret, api_token, sentry_secret)
+
     # Persist resolved values, but never write the secret to disk.
     config["port"] = port
     config["dry_run"] = dry_run
@@ -1541,6 +1796,8 @@ def main():
     WebhookHandler.secret = secret
     WebhookHandler.api_token = api_token
     WebhookHandler.sentry_secret = sentry_secret
+    WebhookHandler.slack_secret = slack_secret
+    WebhookHandler.linear_secret = linear_secret
     WebhookHandler.dispatcher = dispatcher
 
     signing_key, signing_kid = load_signing_key(auto_generate=False)
@@ -1587,6 +1844,16 @@ def main():
             "No Sentry secret configured: POST /sentry is rejected with 503. "
             "Set LOKI_SENTRY_WEBHOOK_SECRET or SENTRY_CLIENT_SECRET."
         )
+    if not slack_secret:
+        logging.warning(
+            "No Slack signing secret configured: POST /slack is rejected with "
+            "503. Set SLACK_SIGNING_SECRET."
+        )
+    if not linear_secret:
+        logging.warning(
+            "No Linear webhook secret configured: POST /linear is rejected with "
+            "503. Set LINEAR_WEBHOOK_SECRET."
+        )
     if not secret:
         logging.warning(
             "No webhook secret configured: ALL webhooks will be rejected with "

package/autonomy/verify.sh

@@ -2588,6 +2588,11 @@ OPTIONS:
                        Seal a workspace run into one signed composite receipt
                        (composite.json). `loki verify <composite.json>` then
                        re-checks it offline. Routed to the engine10 verifier.
+    --max-age <DUR>    With a receipt path: refuse a receipt whose signed issue
+                       time is older than DUR (Ns, Nm, Nh, Nd or seconds), has
+                       no signed issue time, or is more than 300s in the
+                       future. Exits 2 (UNCHECKED). Routed to the engine10
+                       verifier.
     -h, --help         Show this help.
 
 GATES (deterministic, reproducible by construction):

package/completions/loki.bash

@@ -142,14 +142,14 @@ _loki_completion() {
 
         deploy)
             if [[ "$cur" == -* ]]; then
-                COMPREPLY=( $(compgen -W "--execute --health-url --auto-rollback --help" -- "$cur") )
+                COMPREPLY=( $(compgen -W "--execute --health-url --auto-rollback --dir --no-clip --allow-unanchored --help" -- "$cur") )
                 return 0
             fi
             ;;
 
         verify)
             if [[ "$cur" == -* ]]; then
-                COMPREPLY=( $(compgen -W "--base --out --block-on --no-llm --json --explain --check-fresh --hosted --seal-composite --help" -- "$cur") )
+                COMPREPLY=( $(compgen -W "--base --out --block-on --no-llm --json --explain --check-fresh --max-age --hosted --seal-composite --help" -- "$cur") )
                 return 0
             fi
             ;;

package/dashboard/__init__.py

@@ -7,6 +7,6 @@ Modules:
     control: Session control helpers (status, atomic writes, origin check)
 """
 
-__version__ = "11.7.1"
+__version__ = "11.8.1"
 
 __all__ = ["__version__"]

package/docs/CLI-REFERENCE.md

@@ -1,6 +1,6 @@
 # CLI reference
 
-Generated from `loki-ts/src/cli/registry.ts` by `scripts/generate-stale-zero.sh` for v11.7.1. Do not edit by hand.
+Generated from `loki-ts/src/cli/registry.ts` by `scripts/generate-stale-zero.sh` for v11.8.1. Do not edit by hand.
 Hidden and legacy-only commands are omitted; see `docs/v10/CLI-MODERN.md` for the full inventory.
 
 | Command | Description |

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 Loki Mode, by [Autonomi](https://www.autonomi.dev/), turns a spec or an issue into a verified pull request with a receipt you can check. This page covers installing it, a first run, and the options around it.
 
-**Version:** v11.7.1
+**Version:** v11.8.1
 
 **Engine note:** `loki start` is the primary command. `loki start`, `loki "<task>"`, `loki owner/repo#N` and `loki quick` all run the Loki 10 engine, whatever the flag order or input form (PRD file, issue ref, task or one-word brief). The previous loop runs only on `--engine legacy`, `LOKI_ENGINE=legacy`, or for one call when a flag Loki 10 cannot honor is present. See the [user guide](v10/GUIDE.md) and the [5-minute quickstart](QUICKSTART.md).
 

package/docs/sentry-intake.md

@@ -22,3 +22,25 @@ The token is sent only to the Sentry host through a curl config on stdin, never
 
 The output is a receipt-gated PR only, never a deploy. Whether the PR opens is still decided by the policy file (`autonomy`).
 
+
+## Slack and Linear delegation
+
+`loki trigger` server setup for delegating a job from chat or a tracker. Both routes enqueue through the same job queue and runner as `POST /jobs`; a completion summary goes back to the origin. Nothing unauthenticated can start a job or choose a reply URL.
+
+Secrets are env only and must differ from each other, the GitHub webhook secret, the API token and the Sentry secret (an equal secret disables its route at startup). A missing secret answers 503 naming the variable, and the server logs a startup warning. None of them reach the `loki start` child environment.
+
+Slack (`POST /slack`):
+
+1. Set `SLACK_SIGNING_SECRET`. Point a `/loki` slash command (and Events URL verification) at `/slack`.
+2. The signature is `v0=` + hex HMAC-SHA256 over `v0:<X-Slack-Request-Timestamp>:<raw body>`, window 300s, the same contract as `loki-ts/src/contrib/slack_inbound.ts`. Bad, stale or missing signature: 401, nothing queued.
+3. The command text is the spec (one line, not starting with `-`) and runs as `loki start <text> --detach`. Slack gets an ephemeral reply carrying the job id.
+4. On completion the summary is posted to the request's `response_url`, only if it starts with `https://hooks.slack.com/`. Any other host is never contacted.
+
+Linear (`POST /linear`):
+
+1. Set `LINEAR_WEBHOOK_SECRET`. Point a Linear issue webhook at `/linear`.
+2. `Linear-Signature` is the hex HMAC-SHA256 of the raw body, and the signed `webhookTimestamp` must be within 300s. Otherwise 401.
+3. A created issue enqueues `loki start linear:<identifier> --detach` and answers 202 with the job id. Other events are skipped.
+4. If `LINEAR_API_KEY` is set, a comment with the result is posted on the issue through `https://api.linear.app/graphql`. Without it nothing is posted.
+
+Reply targets are stored server side keyed by job id, captured only after verification. Notifier errors are logged and never fail the job. Poll status with `GET /jobs/<id>`.

package/docs/v10/D61-SPEED.md

@@ -89,3 +89,15 @@ With `LOKI_SPEED=1` (default off), intake no longer waits on the cheap-model alr
 ## D82-FLAGS status: default on
 
 Per the D82 founder directive, `LOKI_SPEED` is on unless set to `0` (decomposer routing, warm engine on a unix socket, stage prefix, deferred already-done check, lean keyword fallback, unit mode when `LOKI_UNIT_SPEC` is set). `LOKI_SPEED=0` restores the previous behaviour byte for byte. The other D82 opt-outs are `LOKI_VISUAL_EVIDENCE=0`, `LOKI_CONTRACT=0`, `LOKI_SLACK_INBOUND=0` (Slack stays inert until its credential is configured), `LOKI_CONTROL=0` and `LOKI_WORKSPACES=0`. Test: `loki-ts/tests/features/d82_default_on.test.ts`.
+
+## Missions and group Seal (v11.8.0)
+
+Missions: a spec with two or more milestones runs milestone by milestone. Format: `## Milestone N[: title]` headings (the body is everything up to the next milestone heading), or a top-level `milestones:` list of `- title` lines. Fewer than 2 milestones is not a mission and takes the normal path unchanged. Parsing is `parseMilestones` in `loki-ts/src/features/decompose.ts`; the loop is in `maybeRunGroup` (`loki-ts/src/features/speed/route.ts`), reached from `loki start` and from chat `/run` through the same supervisor call.
+
+Each milestone prints `loki: milestone k/N: <title>`, is decomposed on its own, and runs as its own group with its own frozen contract and group Seal. One-unit groups and sequential providers are allowed for milestones (the normal fewer-than-2-units and slot fallbacks do not apply). The mission stops at the first non-zero result, prints `loki: milestone k/N failed (exit X); rerun the same loki start to resume`, and returns that code; later milestones never start. All milestones exit 0 returns 0.
+
+Group exit codes: 0 = every unit VERIFIED and the group receipt VERIFIED; 4 = NOT PROVEN (integrated, but no checked group receipt); 1 = failures.
+
+Resume: rerun the same `loki start`. Each milestone group is found again by the hash of its body, so finished milestones re-verify and return 0 fast and the run continues at the failed one. No extra state is kept. `LOKI_GROUP_RESUME=0` disables auto-resume and starts every group fresh. Check any group receipt with `loki verify .loki/groups/<gid>/receipt.json`.
+
+Test command precedence: `LOKI_GROUP_TEST_CMD` (whitespace split) wins over the repo's own test script. Test: `loki-ts/tests/engine10/route_group.test.ts`.

package/docs/v10/PROGRESS.md

@@ -2337,3 +2337,13 @@ The swarm is stopped: .loki/V10-STOP exists, the loop has no wake-ups, and the c
 - 10.6.6 (456058bae): scope control, Control Plane v0, train-cycle fix, docs. All green. Published.
 - 10.6.7 (bfce1db12): D60 sprint, all gates, Release, Post-Release Smoke and Promote success. latest and next at 10.6.7.
 - Open at handoff: real-repo gate not wired into promote.yml and needs operator provider auth; no end-to-end exit 3 run of the cost cap; root action.yml still uses loki start --simple; about 43 worktrees under .claude/worktrees (cap 15); never push backup/train-67..70 or backup/main-pre-rebuild.
+
+## 2026-10-15T20:05Z (CoS) 11.7.1 published, v11.8.0 train started
+- 11.7.0 (8b22e5fba): Tests red on tests/test-help-changelog-drift.sh (three flags missing from help/completion) and tests/test-sigpipe-guard.sh (count 1743 over ceiling 1742). Not published.
+- 11.7.1 (a01a22740): Release and Tests completed/success (gh run watch log, runs 38794589410 and 38794589637); npm dist-tags next=11.7.1, latest=11.6.0.
+- v11.8.0 train (workflow wf_e6306e08-008): group Seal, group resume, multi-milestone missions, Slack and Linear delegation on the trigger server, receipt --max-age, deploy completion and pulse ID_RE fixes.
+
+## 2026-10-15T20:45Z (CoS) v11.8.0 failed CI, v11.8.1 fix-forward
+- v11.8.0 (b5191b999): Tests run 38800796458 and Release failed on line budgets (core engine10 5020, features 3190), the D66 fence (run_group.ts value-imported seal and verify_cmd), two unclassified checkouts in the L2 registry, macOS-first stat in tests/test-backlog-units.sh:162, and a `loki help verify` mismatch. Not published.
+- Fix 1d734e6ba (Opus HIGH review APPROVED, 162 pass 0 fail on five suites), merged as 1788db60b. The pulse ID_RE item (E-121) was not in the train and stays open.
+- Local guards on the merged tree, all rc=0: test-help-changelog-drift, test-sigpipe-guard, test-help-and-log-cap, test-backlog-units, structural-checks, test-ci-only-divergence, test-platform-infra; bun test budget, l2_destructive_registry, route_group, seal_group: 117 pass 0 fail.