loki-mode 11.8.1 → 11.10.1

package/autonomy/trigger-server.py

@@ -38,6 +38,7 @@ Usage:
 """
 
 import argparse
+import base64
 import collections
 import hashlib
 import hmac
@@ -56,7 +57,7 @@ import sys
 import threading
 import time
 import urllib.parse
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from urllib.request import Request, urlopen
 
@@ -418,6 +419,8 @@ CHILD_ENV_DENYLIST = (
     "SLACK_BOT_TOKEN",
     "LINEAR_WEBHOOK_SECRET",
     "LINEAR_API_KEY",
+    "JIRA_WEBHOOK_SECRET",
+    "TEAMS_SECURITY_TOKEN",
 )
 
 
@@ -583,6 +586,14 @@ def handle_workflow_run_event(payload, dry_run=False):
     return summary, status
 
 
+def brief_start_args(brief):
+    """argv for a delegated PR run. `--brief` forces brief mode so the text is
+    never reclassified as a PRD path or issue URL, and `--pr --detach` are only
+    honored by `loki start` in brief mode because cmd_start routes them through
+    the worktree + PR path."""
+    return ["start", "--brief", brief, "--pr", "--detach"]
+
+
 def handle_job_event(payload, dry_run=False):
     """Handle a remotely-submitted job: loki start <spec> --detach.
 
@@ -594,7 +605,11 @@ def handle_job_event(payload, dry_run=False):
     spec = payload.get("spec")
     if not valid_spec(spec):
         return None, "rejected (invalid spec)"
-    args = ["start", spec.strip(), "--detach"]
+    # Jira/Teams delegation sets pr=True: receipt-gated PR run, never a deploy.
+    if payload.get("pr") is True:
+        args = brief_start_args(spec.strip())
+    else:
+        args = ["start", spec.strip(), "--detach"]
     summary = "job %s: %s" % (payload.get("job_id", "?"), spec.strip())
     # A remote submitter gates CI on this, so report the BUILD's outcome, not
     # merely that a build was launched. "fired" (launched) and "passed" must
@@ -693,6 +708,167 @@ def resolve_chat_secrets(env, secret, api_token, sentry_secret):
     return ("" if slack_bad else slack), ("" if linear_bad else linear)
 
 
+# Jira Cloud and Microsoft Teams delegation. Both enqueue a PR-only run.
+JIRA_KEY_RE = re.compile(r"^[A-Z][A-Z0-9_]*-\d+$")
+JIRA_EVENTS = ("jira:issue_created", "jira:issue_updated")
+JIRA_TRIGGER_FIELDS = ("assignee", "labels")
+DELEGATED_BRIEF_MAX = 1500
+HTML_TAG_RE = re.compile(r"<[^>]*>")
+
+
+def verify_jira_signature(secret, body, signature):
+    """X-Hub-Signature: `sha256=` + hex HMAC-SHA256 of the raw body. Jira sends
+    no timestamp, so replay is bounded by delivery-id dedup in the handler."""
+    if not secret or not signature:
+        return False
+    sig = signature.strip().lower()
+    if not sig.startswith("sha256="):
+        return False
+    expected = hmac.new(secret.encode("utf-8"), body, hashlib.sha256).hexdigest()
+    return constant_time_equals(expected, sig[len("sha256="):])
+
+
+def sign_teams_body(token, body):
+    """Base64 HMAC-SHA256 of the raw body, keyed by the base64-decoded token."""
+    key = base64.b64decode(token, validate=True)
+    return base64.b64encode(hmac.new(key, body, hashlib.sha256).digest()).decode("ascii")
+
+
+def verify_teams_signature(token, body, authorization):
+    """Authorization: `HMAC <base64>`. Fails closed on a bad token or header."""
+    if not token or not authorization:
+        return False
+    scheme, _, value = authorization.strip().partition(" ")
+    if scheme.upper() != "HMAC" or not value.strip():
+        return False
+    try:
+        expected = sign_teams_body(token, body)
+    except ValueError:
+        return False
+    return constant_time_equals(expected, value.strip())
+
+
+def teams_dedup_key(activity):
+    """Dedup key for a Teams activity: activity ids are unique only within a
+    conversation, so scope by conversation id plus serviceUrl and tenant when
+    present. Empty string (never deduplicated) when the activity id is absent."""
+    act_id = activity.get("id")
+    if not isinstance(act_id, str) or not act_id:
+        return ""
+
+    def _s(v):
+        return v if isinstance(v, str) else ""
+
+    conv = activity.get("conversation")
+    conv = conv if isinstance(conv, dict) else {}
+    cdata = activity.get("channelData")
+    tenant = cdata.get("tenant") if isinstance(cdata, dict) else None
+    tenant_id = _s(tenant.get("id")) if isinstance(tenant, dict) else ""
+    tenant_id = tenant_id or _s(conv.get("tenantId"))
+    return "teams:" + json.dumps(
+        [_s(conv.get("id")), _s(activity.get("serviceUrl")), tenant_id, act_id])
+
+
+def teams_fresh(activity, now=None):
+    """The activity's ISO-8601 `timestamp` must be within the skew window."""
+    raw = activity.get("timestamp")
+    if not isinstance(raw, str) or not raw:
+        return False
+    try:
+        dt = datetime.fromisoformat(raw.strip().replace("Z", "+00:00"))
+    except ValueError:
+        return False
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    now = time.time() if now is None else now
+    return abs(now - dt.timestamp()) <= SIGNATURE_MAX_SKEW_S
+
+
+def _csv_set(value):
+    return frozenset(x.strip() for x in value.split(",") if x.strip())
+
+
+def _one_line(text, limit=DELEGATED_BRIEF_MAX):
+    text = " ".join(CONTROL_CHARS_RE.sub(" ", str(text or "")).split())
+    return text.encode("utf-8")[:limit].decode("utf-8", errors="ignore")
+
+
+def jira_trigger_matches(payload, assignees, labels):
+    """True when the issue is assigned to a configured user or carries a
+    configured label. An update only counts if it changed assignee or labels,
+    so unrelated edits never re-fire a run."""
+    issue = payload.get("issue")
+    fields = issue.get("fields") if isinstance(issue, dict) else None
+    if not isinstance(fields, dict):
+        return False
+    if payload.get("webhookEvent") == "jira:issue_updated":
+        items = (payload.get("changelog") or {}).get("items")
+        changed = ({i.get("field") for i in items if isinstance(i, dict)}
+                   if isinstance(items, list) else set())
+        if not changed.intersection(JIRA_TRIGGER_FIELDS):
+            return False
+    who = fields.get("assignee")
+    ids = set()
+    if isinstance(who, dict):
+        for k in ("accountId", "emailAddress", "displayName"):
+            if isinstance(who.get(k), str):
+                ids.add(who[k])
+    if ids.intersection(assignees):
+        return True
+    have = fields.get("labels")
+    return isinstance(have, list) and bool(
+        {x for x in have if isinstance(x, str)}.intersection(labels))
+
+
+def adf_text(node, out=None):
+    """Flatten an Atlassian Document Format tree to its text nodes."""
+    top = out is None
+    out = [] if top else out
+    if isinstance(node, dict):
+        if isinstance(node.get("text"), str):
+            out.append(node["text"])
+        for child in node.get("content") or []:
+            adf_text(child, out)
+    elif isinstance(node, list):
+        for child in node:
+            adf_text(child, out)
+    return " ".join(out) if top else None
+
+
+def build_jira_brief(issue):
+    fields = issue.get("fields") or {}
+    desc = fields.get("description")
+    if isinstance(desc, dict):
+        desc = adf_text(desc)
+    parts = ["Resolve Jira issue %s: %s." % (issue.get("key"), fields.get("summary") or "")]
+    if isinstance(desc, str) and desc.strip():
+        parts.append(desc)
+    parts.append("Reproduce with a regression test, then fix the root cause.")
+    return _one_line(" ".join(parts))
+
+
+def build_teams_brief(activity):
+    text = re.sub(r"<at>.*?</at>", " ", str(activity.get("text") or ""), flags=re.S)
+    return _one_line(HTML_TAG_RE.sub(" ", text))
+
+
+def resolve_delegation_secrets(env, others):
+    """Return (jira_secret, teams_token), blanking any equal to another
+    credential in `others` or to each other."""
+    jira = env.get("JIRA_WEBHOOK_SECRET", "")
+    teams = env.get("TEAMS_SECURITY_TOKEN", "")
+    others = [x for x in others if x]
+    out = []
+    for name, val, peer in (("Jira", jira, teams), ("Teams", teams, jira)):
+        bad = bool(val) and any(constant_time_equals(val, o)
+                                for o in others + ([peer] if peer else []))
+        if bad:
+            logging.error("The %s secret is identical to another credential. "
+                          "They MUST differ; disabling its route.", name)
+        out.append("" if bad else val)
+    return tuple(out)
+
+
 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"),
@@ -798,7 +974,7 @@ def handle_sentry_event(payload, dry_run=False):
     brief = build_sentry_brief(norm)
     if not valid_spec(brief):
         return None, "rejected (invalid brief)"
-    args = ["start", brief, "--pr", "--detach"]
+    args = brief_start_args(brief)
     summary = "sentry issue %s" % norm.get("number", "?")
     success = run_loki_command(args, dry_run=dry_run)
     status = "fired" if success else "error"
@@ -1129,6 +1305,12 @@ class WebhookHandler(http.server.BaseHTTPRequestHandler):
     # distinct from every other credential.
     slack_secret = ""
     linear_secret = ""
+    # Jira webhook secret (/jira), Teams outgoing-webhook token (/teams), and
+    # the Jira trigger filters (assignee ids/emails/names, labels).
+    jira_secret = ""
+    teams_secret = ""
+    jira_assignees = frozenset()
+    jira_labels = frozenset()
     dispatcher = None
     # Ed25519 key that attests receipts, and the retired public keys that keep
     # pre-rotation receipts verifiable. Both default to unconfigured, which
@@ -1414,7 +1596,7 @@ class WebhookHandler(http.server.BaseHTTPRequestHandler):
             return
         self._send_json(202, {"id": job_id, "status": "queued"})
 
-    def _enqueue_job(self, spec, reply_target=None):
+    def _enqueue_job(self, spec, reply_target=None, pr=False):
         """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.
@@ -1422,6 +1604,8 @@ class WebhookHandler(http.server.BaseHTTPRequestHandler):
         """
         job_id = secrets.token_urlsafe(12)
         job = {"spec": spec, "job_id": job_id}
+        if pr:
+            job["pr"] = True
 
         # Record BEFORE enqueueing. A worker can pick the job up the instant
         # submit() returns and write "running"/"fired"; record_job is
@@ -1546,6 +1730,99 @@ class WebhookHandler(http.server.BaseHTTPRequestHandler):
             return
         self._send_json(202, {"id": job_id, "status": "queued"})
 
+    def _handle_jira(self):
+        """POST /jira -- signed Jira Cloud webhook; enqueues a PR-only run."""
+        body = self._read_body()
+        if body is None:
+            return
+        if not self.jira_secret:
+            log_event(JOB_EVENT, "", "", "rejected (no jira webhook secret configured)")
+            self._send_json(503, {"error": "JIRA_WEBHOOK_SECRET not configured"})
+            return
+        if not verify_jira_signature(
+                self.jira_secret, body, self.headers.get("X-Hub-Signature", "")):
+            logging.warning("Invalid Jira signature from %s", self.address_string())
+            log_event(JOB_EVENT, "", "", "rejected (invalid jira 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 (payload.get("webhookEvent") not in JIRA_EVENTS
+                or not jira_trigger_matches(
+                    payload, self.jira_assignees, self.jira_labels)):
+            self._send_json(200, {"status": "skipped"})
+            return
+        issue = payload["issue"]
+        key = issue.get("key")
+        if not isinstance(key, str) or not JIRA_KEY_RE.match(key):
+            self._send_json(400, {"error": "invalid issue key"})
+            return
+        brief = build_jira_brief(issue)
+        if not valid_spec(brief):
+            self._send_json(400, {"error": "invalid brief"})
+            return
+        # Jira has no signed timestamp, and the delivery id header is not covered
+        # by the HMAC, so also dedup on a hash of the signed body: a captured body
+        # cannot be replayed by changing or dropping the header.
+        dup_id = self.dispatcher.seen_delivery(
+            self.headers.get("X-Atlassian-Webhook-Identifier", ""))
+        dup_body = self.dispatcher.seen_delivery(
+            "jira-body:" + hashlib.sha256(body).hexdigest())
+        if dup_id or dup_body:
+            self._send_json(200, {"status": "duplicate"})
+            return
+        job_id = self._enqueue_job(brief, pr=True)
+        if job_id is None:
+            return
+        self._send_json(202, {"id": job_id, "status": "queued"})
+
+    def _handle_teams(self):
+        """POST /teams -- Teams outgoing webhook; enqueues a PR-only run."""
+        body = self._read_body()
+        if body is None:
+            return
+        if not self.teams_secret:
+            log_event(JOB_EVENT, "", "", "rejected (no teams security token configured)")
+            self._send_json(503, {"error": "TEAMS_SECURITY_TOKEN not configured"})
+            return
+        if not verify_teams_signature(
+                self.teams_secret, body, self.headers.get("Authorization", "")):
+            logging.warning("Invalid Teams signature from %s", self.address_string())
+            log_event(JOB_EVENT, "", "", "rejected (invalid teams signature)")
+            self._send_json(401, {"error": "invalid signature"})
+            return
+        try:
+            activity = json.loads(body)
+        except ValueError:
+            self._send_json(400, {"error": "invalid JSON"})
+            return
+        if not isinstance(activity, dict):
+            self._send_json(400, {"error": "payload must be a JSON object"})
+            return
+        if not teams_fresh(activity):
+            log_event(JOB_EVENT, "", "", "rejected (stale teams timestamp)")
+            self._send_json(401, {"error": "stale or missing timestamp"})
+            return
+        brief = build_teams_brief(activity)
+        if not valid_spec(brief):
+            self._send_json(200, {"type": "message",
+                                  "text": "Usage: @loki <brief>. One-line brief, "
+                                          "not starting with '-'."})
+            return
+        if self.dispatcher.seen_delivery(teams_dedup_key(activity)):
+            self._send_json(200, {"type": "message", "text": "Duplicate, already queued."})
+            return
+        job_id = self._enqueue_job(brief, pr=True)
+        if job_id is None:
+            return
+        self._send_json(200, {"type": "message", "text": "Queued loki job %s" % job_id})
+
     def _handle_sentry(self):
         """POST /sentry -- Sentry alert, HMAC-verified, enqueues a fix run."""
         body = self._read_body()
@@ -1597,6 +1874,12 @@ class WebhookHandler(http.server.BaseHTTPRequestHandler):
         if path == "/linear":
             self._handle_linear()
             return
+        if path == "/jira":
+            self._handle_jira()
+            return
+        if path == "/teams":
+            self._handle_teams()
+            return
         if path != "/webhook":
             self._send_json(404, {"error": "not found"})
             return
@@ -1782,6 +2065,11 @@ def main():
     slack_secret, linear_secret = resolve_chat_secrets(
         os.environ, secret, api_token, sentry_secret)
 
+    jira_secret, teams_secret = resolve_delegation_secrets(
+        os.environ, [secret, api_token, sentry_secret, slack_secret, linear_secret])
+    WebhookHandler.jira_assignees = _csv_set(os.environ.get("JIRA_ASSIGNEES", ""))
+    WebhookHandler.jira_labels = _csv_set(os.environ.get("JIRA_LABELS", ""))
+
     # Persist resolved values, but never write the secret to disk.
     config["port"] = port
     config["dry_run"] = dry_run
@@ -1798,6 +2086,8 @@ def main():
     WebhookHandler.sentry_secret = sentry_secret
     WebhookHandler.slack_secret = slack_secret
     WebhookHandler.linear_secret = linear_secret
+    WebhookHandler.jira_secret = jira_secret
+    WebhookHandler.teams_secret = teams_secret
     WebhookHandler.dispatcher = dispatcher
 
     signing_key, signing_kid = load_signing_key(auto_generate=False)
@@ -1854,6 +2144,14 @@ def main():
             "No Linear webhook secret configured: POST /linear is rejected with "
             "503. Set LINEAR_WEBHOOK_SECRET."
         )
+    if not jira_secret:
+        logging.warning(
+            "No Jira webhook secret configured: POST /jira is rejected with "
+            "503. Set JIRA_WEBHOOK_SECRET.")
+    if not teams_secret:
+        logging.warning(
+            "No Teams security token configured: POST /teams is rejected with "
+            "503. Set TEAMS_SECURITY_TOKEN.")
     if not secret:
         logging.warning(
             "No webhook secret configured: ALL webhooks will be rejected with "

package/bin/loki

@@ -794,7 +794,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|slack|queue|issues|answer|undo|verify-pr|completion|__complete)
+    version|--version|-v|status|stats|doctor|provider|memory|rollback|internal|kpis|estimate|trust|proof|receipt|wiki|crash|control|contract|slack|queue|issues|answer|undo|verify-pr|completion|__complete)
         # 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

@@ -56,6 +56,13 @@ function _loki {
                 agent)
                     _loki_agent
                     ;;
+                estimate)
+                    _arguments \
+                        '--json[Output machine-readable JSON]' \
+                        '--model[Model whose rough prior to use]:model:' \
+                        '--provider[Provider whose default model is used]:provider:' \
+                        '--help[Show help]'
+                    ;;
                 status)
                     _arguments \
                         '--json[Output machine-readable JSON]' \
@@ -162,6 +169,27 @@ function _loki {
                 code)
                     _loki_code
                     ;;
+                deploy)
+                    _arguments \
+                        '--dir[Project directory to scan]:directory:_directories' \
+                        '--no-clip[Do not copy the command to the clipboard]' \
+                        '--execute[Run the deploy command if the receipt gate passes]' \
+                        '--canary[With --execute: staged rollout (Vercel promote, Fly canary)]' \
+                        '--allow-unanchored[Proceed when the receipt records no baseline]' \
+                        '--health-url[Health probe URL]:url:' \
+                        '--auto-rollback[Roll back on a failed health probe]' \
+                        '--help[Show help]'
+                    ;;
+                verify)
+                    _arguments \
+                        '--pubkey[Check against this public key only]:key file:_files' \
+                        '--sign-deploy[Sign a loki.deploy/1 deploy record in place]:record:_files' \
+                        '--receipt[Cited receipt file for a deploy record]:receipt:_files' \
+                        '--max-age[Reject a receipt older than DUR]:duration:' \
+                        '--seal-composite[Sign a workspace composite]:run dir:_directories' \
+                        '--help[Show help]' \
+                        '*:receipt or deploy record:_files'
+                    ;;
             esac
             ;;
     esac
@@ -231,7 +259,7 @@ function _loki_commands {
         'plan:Preview the build plan for a spec'
         'report:Reporting commands (cost, kpis, share)'
         'cost:Show cost of recent runs (--detail for cache + trend)'
-        'estimate:Project run cost (requires --iterations N)'
+        'estimate:Estimate run cost from run history (--json, --model, --provider)'
         'kpis:Key performance indicators'
         'stats:Session statistics'
         'preview:Open the running app preview'
@@ -313,6 +341,11 @@ function _loki_start {
     _arguments \
         '--provider[AI provider]:provider name:(claude cline codex aider opencode)' \
         '--parallel[Parallel mode]' \
+        '--brief[Zero-config brief mode]:brief text:' \
+        '--worktree[Git worktree isolation]' \
+        '--pr[Worktree plus auto-create PR]' \
+        '--ship[Worktree plus PR plus auto-merge]' \
+        '--detach[Run in background (implies --worktree)]' \
         '--workspace[Run a loki.yaml workspace for the brief]:workspace name:' \
         '--deploy[Deploy after a VERIFIED run via loki deploy --execute]' \
         '--health-url[With --deploy: health probe URL]:url:' \

package/completions/loki.bash

@@ -27,7 +27,7 @@ _loki_completion() {
 
             # If the word starts with a dash, show flags
             if [[ "$cur" == -* ]]; then
-                local flags="--provider --max-iterations --parallel --background --bg --simple --complex --github --no-dashboard --sandbox --skip-memory --spec --spec-first --yes --budget --attempts --model --isolation --max-cost --no-pr --explain-route --workspace --deploy --health-url --auto-rollback --help"
+                local flags="--provider --max-iterations --parallel --background --bg --simple --complex --github --no-dashboard --sandbox --skip-memory --spec --spec-first --yes --budget --attempts --model --isolation --max-cost --no-pr --explain-route --brief --worktree --pr --ship --detach --workspace --deploy --health-url --auto-rollback --help"
                 COMPREPLY=( $(compgen -W "${flags}" -- "$cur") )
                 return 0
             fi
@@ -120,6 +120,13 @@ _loki_completion() {
             COMPREPLY=( $(compgen -W "${syslog_cmds}" -- "$cur") )
             ;;
 
+        estimate)
+            if [[ "$cur" == -* ]]; then
+                COMPREPLY=( $(compgen -W "--json --model --provider --help" -- "$cur") )
+                return 0
+            fi
+            ;;
+
         status)
             if [[ "$cur" == -* ]]; then
                 COMPREPLY=( $(compgen -W "--json --help" -- "$cur") )
@@ -142,14 +149,14 @@ _loki_completion() {
 
         deploy)
             if [[ "$cur" == -* ]]; then
-                COMPREPLY=( $(compgen -W "--execute --health-url --auto-rollback --dir --no-clip --allow-unanchored --help" -- "$cur") )
+                COMPREPLY=( $(compgen -W "--execute --canary --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 --max-age --hosted --seal-composite --help" -- "$cur") )
+                COMPREPLY=( $(compgen -W "--base --out --block-on --no-llm --json --explain --check-fresh --max-age --hosted --seal-composite --sign-deploy --receipt --pubkey --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.8.1"
+__version__ = "11.10.1"
 
 __all__ = ["__version__"]

package/docs/ARCHITECTURE.md

@@ -209,7 +209,6 @@ memory/                    Memory system (Python package, ~19 modules)
   embeddings.py            Vector embeddings (optional)
   vector_index.py          Vector search index
   cross_project.py         Cross-project knowledge transfer
-  rag_injector.py          RAG context injection into prompts
   knowledge_graph.py       Knowledge graph over memories
   layers/                  Progressive-disclosure loading
 

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.8.1. Do not edit by hand.
+Generated from `loki-ts/src/cli/registry.ts` by `scripts/generate-stale-zero.sh` for v11.10.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/COMPONENTS.md

@@ -132,7 +132,7 @@ across projects.
 - `consolidation.py` - Episodic-to-semantic consolidation pipeline.
 - `token_economics.py` - Discovery vs read token accounting.
 - `embeddings.py`, `vector_index.py` - Optional embedding-based similarity.
-- `cross_project.py`, `knowledge_graph.py`, `rag_injector.py` - Cross-project
+- `cross_project.py`, `knowledge_graph.py` - Cross-project
   recall, knowledge graph, and RAG prompt injection (v7.1.0+).
 - `app_graph.py`, `error_log.py`, `ingest.py`, `namespace.py`, `replay.py`,
   `unified_access.py` - Supporting modules.

package/docs/DEPLOY-PLAN.md

@@ -7,9 +7,19 @@ clean tree, a destructive-op refusal and a policy permission (`.loki/policies.js
 deployed URL after the command. A non-2xx result is recorded as FAILED_HEALTH and exits non-zero;
 with `--auto-rollback` it also runs the provider's documented rollback verb (`vercel rollback`,
 `fly releases rollback <captured version>`; Netlify and Cloudflare print a manual note). With no
-URL, health is recorded as "unchecked", never healthy. The deploy record lives in `.loki/deploys`
-and is not part of the signed receipt. `loki start --deploy [--health-url U] [--auto-rollback]`
-chains the same gated command after a start. Not built: canary or staged rollout, and receipt-bound deploy records.
+URL, health is recorded as "unchecked", never healthy. The deploy record in `.loki/deploys` is a
+signed `loki.deploy/1` attestation bound to the receipt that authorized it (fields: receipt_sha256,
+head_sha, target, command, health_status, health_url, rollback_attempted, rollback_exit,
+started_at, finished_at). It is signed with the existing receipt signer (Ed25519, no new crypto)
+and the receipt itself is unchanged. `loki verify <record.json>` re-checks it offline (also with
+`--pubkey FILE`; `--receipt FILE` names the cited receipt when it is not beside the record). It
+fails closed: a flipped byte is TAMPERED, an unsigned record or an unknown key is UNCHECKED, and a
+cited receipt that is not VERIFIED is never reported as VERIFIED.
+`loki deploy --execute --canary` is a staged rollout using only documented provider verbs: Vercel
+deploys without `--prod`, health-checks the preview URL, then runs `vercel promote <url>` (a failed
+probe never promotes); Fly runs `fly deploy --strategy canary`; Netlify and Cloudflare document no
+staged path and refuse `--canary` with a sentence saying so.
+`loki start --deploy [--health-url U] [--auto-rollback]` chains the same gated command after a start.
 
 Everything below is the original print-only design plan and is kept for history.
 

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.8.1
+**Version:** v11.10.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/WORKSPACES.md

@@ -37,7 +37,7 @@ loki workspace status <run-id>
 - 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. When every repo succeeded, integration did not fail and every child sealed a receipt, the run also seals a signed `composite.json` that binds integration.json and every child receipt (see "Verify a workspace run").
-- `loki workspace infer <name>` prints suggested `after:` edges read from package.json, go.mod and pyproject.toml dependencies on other listed repos. It is print-only and cycle-checked; it never edits loki.yaml. Manifests only: no OpenAPI or import inference.
+- `loki workspace infer <name>` prints suggested `after:` edges read from package.json, go.mod and pyproject.toml dependencies on other listed repos. It also suggests an edge from (1) a source import (TS/JS import or require, Python import, Go import path) of a sibling's package or module name even when the manifest does not declare it, scanning at most 400 source files per repo, and (2) a client generator config (openapitools.json, openapi-generator*.yaml, orval.config.*) whose input spec path lies inside a sibling checkout. Each inferred edge prints its evidence as `file:line`. It is print-only and cycle-checked; it never edits loki.yaml.
 - `plan: true` (or `LOKI_WORKSPACE_PLAN=1`) makes one provider call that decomposes the brief per repo into `<run-dir>/plan.json`. A valid plan gives each listed repo its own task; an invalid one falls back to the generic text and prints the reason.
 - `integration: {per_stage: true}` also runs the integration command after each topological layer. A failing stage SKIPs every later layer, so a broken contract stops before downstream repos build on it.
 - Without `path`, a repo is cloned to `~/.loki/repos/owner__name`.

package/docs/dev/architecture-reference.md

@@ -39,7 +39,7 @@ model explicitly rather than inherit the session model.
 - **Progressive Disclosure**: 3-layer loading (index, timeline, full details)
 - **Token Economics**: Discovery vs read token tracking
 - **Vector Search**: Optional embedding-based similarity (sentence-transformers)
-- **Cross-project + RAG injection**: `memory/cross_project.py`, `memory/rag_injector.py`, `memory/knowledge_graph.py` (added v7.x)
+- **Cross-project index + knowledge graph**: `memory/cross_project.py`, `memory/knowledge_graph.py` (added v7.x)
 - **Managed memory client**: `memory/managed_memory/` -- gated on `LOKI_MANAGED_MEMORY=true`. See `skills/memory.md`.
 - **CLI**: `loki memory index|timeline|consolidate|economics|retrieve|episode|pattern|skill|vectors`
 - **API**: REST endpoints at `/api/memory/*`

package/docs/sentry-intake.md

@@ -23,7 +23,7 @@ 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
+## Slack, Linear, Jira and Teams 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.
 
@@ -43,4 +43,18 @@ Linear (`POST /linear`):
 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.
 
+Jira (`POST /jira`):
+
+1. Set `JIRA_WEBHOOK_SECRET` (the secret on a Jira Cloud webhook) and point the webhook at `/jira`. Set `JIRA_ASSIGNEES` (comma-separated accountId, email or display name) and/or `JIRA_LABELS`. With neither set, every event is skipped.
+2. `X-Hub-Signature` is `sha256=` + hex HMAC-SHA256 of the raw body. Bad or missing signature: 401. Jira signs no timestamp and the `X-Atlassian-Webhook-Identifier` header is not covered by the HMAC, so replay is bounded two ways: a repeated delivery id, or a repeated signed body (sha256 of the raw body, so changing or dropping the header does not help), answers `duplicate` and queues nothing. A replay of a body Jira never sent twice still needs the secret to forge.
+3. `jira:issue_created`, or `jira:issue_updated` whose changelog touches assignee or labels, runs only when the issue is assigned to a configured user or has a configured label. The key, summary and description are folded into a one-line brief (1500 bytes max; an Atlassian Document Format description is flattened to its text) and run as `loki start --brief "<brief>" --pr --detach`. Answers 202 with the job id.
+
+Teams (`POST /teams`):
+
+1. Set `TEAMS_SECURITY_TOKEN` (the base64 token Teams shows when you create the outgoing webhook) and point the webhook at `/teams`.
+2. `Authorization: HMAC <base64>` is the base64 HMAC-SHA256 of the raw body keyed by the base64-decoded token. Bad signature: 401. The activity `timestamp` must be within 300s; a stale or missing one is refused with 401.
+3. The message text (with `<at>` mentions and tags removed) is the brief and runs as `loki start --brief "<brief>" --pr --detach`. Teams gets a synchronous reply whose text starts with "Queued" and ends with the job id. A repeated activity id is not queued twice.
+
+Jira and Teams runs are receipt-gated PR runs only: the server always passes `--pr` and never a deploy argument, so shipping stays a separate gated step. `--brief` forces brief mode, so text that ends in `.md` or contains an issue URL is never reclassified, and `loki start --brief ... --pr/--worktree/--detach` runs in an isolated worktree, detached, and opens a PR carrying the Evidence Receipt (the same machinery as `loki start <issue>`). Sentry alerts use the same form. Neither secret reaches the `loki start` child environment, and both must differ from every other credential. A missing secret answers 503 naming the variable.
+
 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

@@ -101,3 +101,5 @@ Group exit codes: 0 = every unit VERIFIED and the group receipt VERIFIED; 4 = NO
 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`.
+
+Fix units: when group integration stops on a merge conflict or a failing suite, one bounded fix unit runs through the same unit launcher (same scoped env, one slot) from the group branch, then integration restarts once. A conflict fix takes the conflicting unit's place; a suite fix goes last and receives the failing test names and output tail. Max one fix per conflict and 2 per group; `LOKI_GROUP_FIX_UNITS=0` restores stop-and-name. The suite, every unit receipt and the group Seal still decide the verdict, and a failed fix keeps the stop-and-name output (exit 1). A fix unit is stored in `dag.json` and resumes like any unit. Code: `loki-ts/src/features/speed/fix_units.ts`; tests: `loki-ts/tests/engine10/seal_group.test.ts`.