loki-mode 11.73.0 → 11.74.1

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: Runs an autonomous software factory that knows what it is supposed to deliver and proves it did, with a signed receipt. Use when the user says Loki Mode or asks to build, fix or verify software autonomously.
 ---
 
-# Loki Mode v11.73.0
+# Loki Mode v11.74.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.
 
@@ -476,4 +476,4 @@ Implemented, planned and deprecated items, with the version each landed in: `ski
 
 ---
 
-**v11.73.0 | [Autonomi](https://www.autonomi.dev/) flagship product | core skill**
+**v11.74.1 | [Autonomi](https://www.autonomi.dev/) flagship product | core skill**

package/VERSION

@@ -1 +1 @@
-11.73.0
+11.74.1

package/autonomy/company-seats.json

@@ -0,0 +1,82 @@
+[
+  {
+    "name": "chief-of-staff",
+    "cron_expr": "1,16,31,46 * * * *",
+    "action": "seat chief-of-staff",
+    "args": [],
+    "enabled": true,
+    "last_run": null
+  },
+  {
+    "name": "release-reliability-lead",
+    "cron_expr": "4,19,34,49 * * * *",
+    "action": "seat release-reliability-lead",
+    "args": [],
+    "enabled": true,
+    "last_run": null
+  },
+  {
+    "name": "verification-scientist",
+    "cron_expr": "7,37 * * * *",
+    "action": "seat verification-scientist",
+    "args": [],
+    "enabled": true,
+    "last_run": null
+  },
+  {
+    "name": "platform-lead",
+    "cron_expr": "11,41 * * * *",
+    "action": "seat platform-lead",
+    "args": [],
+    "enabled": true,
+    "last_run": null
+  },
+  {
+    "name": "security-lead",
+    "cron_expr": "14,44 * * * *",
+    "action": "seat security-lead",
+    "args": [],
+    "enabled": true,
+    "last_run": null
+  },
+  {
+    "name": "cto",
+    "cron_expr": "22 * * * *",
+    "action": "seat cto",
+    "args": [],
+    "enabled": true,
+    "last_run": null
+  },
+  {
+    "name": "developer-experience-lead",
+    "cron_expr": "27 * * * *",
+    "action": "seat developer-experience-lead",
+    "args": [],
+    "enabled": true,
+    "last_run": null
+  },
+  {
+    "name": "product-growth-lead",
+    "cron_expr": "33 * * * *",
+    "action": "seat product-growth-lead",
+    "args": [],
+    "enabled": true,
+    "last_run": null
+  },
+  {
+    "name": "research-harness-scientist",
+    "cron_expr": "39 * * * *",
+    "action": "seat research-harness-scientist",
+    "args": [],
+    "enabled": true,
+    "last_run": null
+  },
+  {
+    "name": "research-outcomes-scientist",
+    "cron_expr": "52 * * * *",
+    "action": "seat research-outcomes-scientist",
+    "args": [],
+    "enabled": true,
+    "last_run": null
+  }
+]

package/autonomy/loki

@@ -21326,9 +21326,15 @@ print(json.loads(p.read_text()).get('port', 7373) if p.exists() else 7373)
             python3 "$trigger_schedule_script" remove "$name"
             ;;
         daemon)
-            local dry_run_flag=""
-            [[ "${1:-}" == "--dry-run" ]] && dry_run_flag="--dry-run"
-            python3 "$trigger_schedule_script" daemon $dry_run_flag
+            local daemon_flag=""
+            [[ "${1:-}" == "--dry-run" ]] && daemon_flag="--dry-run"
+            [[ "${1:-}" == "--loop" ]] && daemon_flag="--loop"
+            python3 "$trigger_schedule_script" daemon $daemon_flag
+            ;;
+        install|uninstall)
+            # Always-on company seats: LaunchAgent running the daemon loop
+            LOKI_BIN="${LOKI_BIN:-$(readlink -f "${BASH_SOURCE[0]}")}" \
+                python3 "$trigger_schedule_script" "$subcmd" "$@"
             ;;
         test)
             local event_type="${1:-issues}"
@@ -21439,7 +21445,11 @@ for line in sys.stdin:
             echo "  add schedule <name> <cron_expr> <action> [args...]"
             echo "                        Add a cron-based schedule trigger"
             echo "  remove <name>         Remove a schedule trigger"
-            echo "  daemon [--dry-run]    Run one pass of schedule checks (call from cron)"
+            echo "  daemon [--dry-run|--loop]"
+            echo "                        Run one pass of schedule checks (call from cron), or loop once a minute"
+            echo "  install [--no-load]   Seed the ten company-seat schedules and install the always-on"
+            echo "                        LaunchAgent (dev.autonomi.loki-company; macOS)"
+            echo "  uninstall [--no-load] Remove the always-on LaunchAgent"
             echo "  test <event-type> [--repo owner/repo] [--issue NUM]"
             echo "                        Send a test webhook event (event-types: issues, pull_request, workflow_run)"
             echo "  logs [--tail N]       Show recent trigger event log (default: last 50)"

package/autonomy/trigger-schedule.py

@@ -19,18 +19,30 @@ Supported actions:
     run <issue-ref>     - Run loki run on an issue/ref
     status              - Run loki status
     quality-review      - Run loki review
+    seat <name>         - One headless tick of company seat <name>
+                          (.claude/agents/<name>.md), see tick_seat()
 
 Usage:
     python3 autonomy/trigger-schedule.py [--once] [--dry-run]
+    python3 autonomy/trigger-schedule.py daemon [--loop]
+    python3 autonomy/trigger-schedule.py tick <seat>
+    python3 autonomy/trigger-schedule.py seed | install | uninstall
 """
 
 import argparse
+import fcntl
 import json
 import logging
 import os
+import plistlib
+import re
+import shlex
+import shutil
+import signal
 import subprocess
 import sys
-from datetime import datetime, timezone
+import time
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 
 
@@ -183,10 +195,23 @@ def build_loki_args(schedule):
         return action.split() + list(args)
 
 
+def build_seat_command(schedule):
+    """argv that runs one seat tick in a detached child of this script."""
+    seat = schedule.get("action", "").split(None, 1)[1].strip()
+    return [sys.executable, os.path.abspath(__file__), "tick", seat]
+
+
+def is_seat_action(schedule):
+    return schedule.get("action", "").split(None, 1)[:1] == ["seat"] and \
+        len(schedule.get("action", "").split()) == 2
+
+
 def run_schedule(schedule, dry_run=False):
     """Execute a scheduled loki command."""
-    loki_args = build_loki_args(schedule)
-    cmd = ["loki"] + loki_args
+    if is_seat_action(schedule):
+        cmd = build_seat_command(schedule)
+    else:
+        cmd = ["loki"] + build_loki_args(schedule)
     name = schedule.get("name", "unnamed")
 
     if dry_run:
@@ -195,10 +220,12 @@ def run_schedule(schedule, dry_run=False):
 
     logging.info("Schedule '%s' firing: %s", name, " ".join(cmd))
     try:
+        extra = {"start_new_session": True} if is_seat_action(schedule) else {}
         proc = subprocess.Popen(
             cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
+            stdout=subprocess.DEVNULL if extra else subprocess.PIPE,
+            stderr=subprocess.DEVNULL if extra else subprocess.PIPE,
+            **extra
         )
         logging.info("Schedule '%s' started pid=%d", name, proc.pid)
         return True
@@ -207,6 +234,351 @@ def run_schedule(schedule, dry_run=False):
         return False
 
 
+# ---------------------------------------------------------------------------
+# Company seats: always-on headless ticks of .claude/agents/<name>.md
+# ---------------------------------------------------------------------------
+
+SEAT_NAME_RE = re.compile(r"^[a-z0-9][a-z0-9-]*$")
+LEADER_SEATS = ("chief-of-staff", "release-reliability-lead")
+DEFAULT_MAX_LOAD = 28.0
+DEFAULT_SEAT_TIMEOUT_SECS = 1200
+GOVERNOR_CACHE_SECS = 300
+TERM_GRACE_SECS = 15
+LAUNCHAGENT_LABEL = "dev.autonomi.loki-company"
+
+SEAT_TICK_PROMPT = (
+    "Run one iteration of your standing loop from your agent file. "
+    "Read the pulse (bash scripts/v10-pulse.sh) and docs/v10/BOARD.md. "
+    "Act only within your decision rights. "
+    "Write a short outcome to .loki/company/{seat}/last.json "
+    "(fields: ts, seat, outcome, actions, evidence) and append one line to "
+    ".loki/company/{seat}/log.jsonl. Then stop."
+)
+
+
+def company_root():
+    return os.path.realpath(os.environ.get("LOKI_COMPANY_ROOT") or os.getcwd())
+
+
+def _now_iso():
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _pid_alive(pid):
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    except OSError:
+        return False
+    return True
+
+
+def _read_pid(path):
+    """First run of digits on line 1 (the v10-leader / lock format), else None."""
+    try:
+        with open(path) as f:
+            m = re.match(r"\s*(\d+)", f.readline())
+    except OSError:
+        return None
+    return int(m.group(1)) if m else None
+
+
+def acquire_seat_lock(lock_path):
+    """Per-seat flock on the lockfile; our PID is written into it for the cockpit.
+
+    Returns (file, holder_pid). The lock dies with the process, so a crashed
+    tick never leaves a stale lock. Caller closes the file to release.
+    """
+    f = open(lock_path, "a+")
+    try:
+        fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except OSError:
+        f.seek(0)
+        m = re.match(r"\s*(\d+)", f.readline())
+        f.close()
+        return None, int(m.group(1)) if m else None
+    f.seek(0)
+    f.truncate()
+    f.write("%d\n" % os.getpid())
+    f.flush()
+    return f, os.getpid()
+
+
+def governor_max_engineers():
+    """max_engineers_next_hour from the usage governor, or None if unknown.
+
+    Same source and key the pulse reads (scripts/usage-governor.py --json,
+    report["governor"]["max_engineers_next_hour"]). Cached for a few minutes
+    so ten seats do not each rescan the transcripts.
+    """
+    root = company_root()
+    cache = os.path.join(root, ".loki", "company", "governor-cache.json")
+    cmd_env = os.environ.get("LOKI_COMPANY_GOVERNOR_CMD") or os.environ.get("PULSE_GOVERNOR_CMD")
+    if not cmd_env:
+        cmd = [sys.executable, os.path.join(root, "scripts", "usage-governor.py"), "--json"]
+        if not os.path.exists(cmd[1]):
+            return None
+    else:
+        cmd = shlex.split(cmd_env)
+    try:
+        c = json.load(open(cache))
+        if cmd_env is None and time.time() - c["at"] < GOVERNOR_CACHE_SECS:
+            return c["max"]
+    except (OSError, ValueError, KeyError, TypeError):
+        pass
+    try:
+        out = subprocess.run(cmd, cwd=root, capture_output=True, text=True, timeout=90).stdout
+        val = (json.loads(out).get("governor") or {}).get("max_engineers_next_hour")
+    except (OSError, ValueError, AttributeError, subprocess.TimeoutExpired):
+        return None
+    if not isinstance(val, int):
+        return None
+    if cmd_env is None:
+        try:
+            with open(cache, "w") as f:
+                json.dump({"at": time.time(), "max": val}, f)
+        except OSError:
+            pass
+    return val
+
+
+def _append_log(seat_dir, seat, outcome, detail=""):
+    entry = {"ts": _now_iso(), "seat": seat, "outcome": outcome}
+    if detail:
+        entry["detail"] = detail
+    with open(os.path.join(seat_dir, "log.jsonl"), "a") as f:
+        f.write(json.dumps(entry) + "\n")
+
+
+def tick_seat(name):
+    """Run one headless tick of seat `name`. Returns (status, detail).
+
+    status is "ran", "skipped" or "error". Guards, in order: PAUSE file,
+    1-min load average, live v10-leader (chief-of-staff and
+    release-reliability-lead only), per-seat PID lock, usage governor.
+    """
+    root = company_root()
+    if not SEAT_NAME_RE.match(name or "") or \
+            not os.path.isfile(os.path.join(root, ".claude", "agents", name + ".md")):
+        return "error", "unknown seat: %s" % name
+    cdir = os.path.join(root, ".loki", "company")
+    seat_dir = os.path.join(cdir, name)
+    os.makedirs(seat_dir, exist_ok=True)
+
+    def skip(why):
+        _append_log(seat_dir, name, "skipped", why)
+        return "skipped", why
+
+    if os.path.exists(os.path.join(cdir, "PAUSE")):
+        return skip("paused")
+    max_load = float(os.environ.get("LOKI_COMPANY_MAX_LOAD") or DEFAULT_MAX_LOAD)
+    load1 = os.getloadavg()[0]
+    if load1 > max_load:
+        return skip("load %.1f above %.1f" % (load1, max_load))
+    if name in LEADER_SEATS:
+        leader = _read_pid(os.path.join(root, ".loki", "v10-leader"))
+        if leader is not None and leader != os.getpid() and _pid_alive(leader):
+            return skip("live leader pid %d holds .loki/v10-leader" % leader)
+    lock, holder = acquire_seat_lock(os.path.join(seat_dir, "lock"))
+    if lock is None:
+        return skip("lock held by pid %s" % holder)
+    try:
+        if governor_max_engineers() == 0:
+            return skip("governor max engineers is 0")
+        return _run_claude_tick(root, name, seat_dir)
+    finally:
+        lock.truncate(0)
+        lock.close()
+
+
+def _run_claude_tick(root, name, seat_dir):
+    timeout = float(os.environ.get("LOKI_SEAT_TIMEOUT_SECS") or DEFAULT_SEAT_TIMEOUT_SECS)
+    argv = [os.environ.get("LOKI_CLAUDE_BIN") or "claude", "-p", "--agent", name,
+            "--dangerously-skip-permissions", "--output-format", "json",
+            SEAT_TICK_PROMPT.format(seat=name)]
+    last = os.path.join(seat_dir, "last.json")
+    started = time.time()
+    try:
+        # Own session so a timeout can stop the tick's whole process group
+        # (claude spawns children) by the group id we created, never by name.
+        with open(os.path.join(seat_dir, "last.out"), "w") as out:
+            proc = subprocess.Popen(argv, cwd=root, stdin=subprocess.DEVNULL, stdout=out,
+                                    stderr=subprocess.STDOUT, start_new_session=True)
+    except OSError as e:
+        _append_log(seat_dir, name, "error", "cannot start claude: %s" % e)
+        return "error", "cannot start claude: %s" % e
+    outcome, detail = "ok", ""
+    try:
+        proc.wait(timeout=timeout)
+        if proc.returncode != 0:
+            outcome, detail = "error", "claude rc=%d" % proc.returncode
+    except subprocess.TimeoutExpired:
+        # TERM, grace, then ALWAYS KILL the group: a grandchild (bun test)
+        # can ignore TERM and outlive the leader.
+        try:
+            os.killpg(proc.pid, signal.SIGTERM)
+            proc.wait(timeout=TERM_GRACE_SECS)
+        except (ProcessLookupError, PermissionError, subprocess.TimeoutExpired):
+            pass
+        try:
+            os.killpg(proc.pid, signal.SIGKILL)
+        except (ProcessLookupError, PermissionError):
+            proc.kill()  # not a group leader: at least stop the PID we started
+        proc.wait()
+        outcome, detail = "timeout", "exceeded %ds" % int(timeout)
+    fresh = os.path.exists(last) and os.path.getmtime(last) >= started - 1
+    if outcome != "ok" or not fresh:
+        if outcome == "ok":
+            outcome, detail = "no-report", "seat did not write last.json"
+        with open(last, "w") as f:
+            json.dump({"ts": _now_iso(), "seat": name, "outcome": outcome,
+                       "actions": [], "evidence": detail}, f)
+        _append_log(seat_dir, name, outcome, detail)
+    return "ran", ("%s: %s" % (outcome, detail) if detail else outcome)
+
+
+def default_seat_schedules():
+    """Shipped default cadence for the ten company seats."""
+    path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "company-seats.json")
+    with open(path) as f:
+        return json.load(f)
+
+
+def seed_default_schedules():
+    """Add default seat schedules missing from schedules.json. Returns count added."""
+    schedules = load_schedules()
+    have = {s.get("name") for s in schedules}
+    added = 0
+    for d in default_seat_schedules():
+        if d["name"] not in have:
+            schedules.append(dict(d))
+            added += 1
+    if added:
+        save_schedules(schedules)
+    return added
+
+
+def _fire_minutes(cron_expr, start, span_minutes):
+    t = start
+    for _ in range(span_minutes):
+        if cron_matches(cron_expr, t):
+            yield t
+        t += timedelta(minutes=1)
+
+
+def interval_minutes(cron_expr):
+    """Smallest gap in minutes between consecutive fires (None if fewer than 2 in 8 days)."""
+    fires = list(_fire_minutes(cron_expr, datetime(2026, 1, 5, 0, 0), 8 * 1440))
+    gaps = [int((b - a).total_seconds() // 60) for a, b in zip(fires, fires[1:])]
+    return min(gaps) if gaps else None
+
+
+def next_fire(cron_expr, after):
+    """First fire strictly after `after` (naive datetime), within 8 days, else None."""
+    start = after.replace(second=0, microsecond=0) + timedelta(minutes=1)
+    return next(_fire_minutes(cron_expr, start, 8 * 1440), None)
+
+
+def launchagent_path(home):
+    return os.path.join(home, "Library", "LaunchAgents", LAUNCHAGENT_LABEL + ".plist")
+
+
+def write_launchagent(home, repo, loki_bin):
+    """Write the LaunchAgent plist under `home`. Does not load it."""
+    logs = os.path.join(home, ".loki", "logs")
+    os.makedirs(logs, exist_ok=True)
+    plist = {
+        "Label": LAUNCHAGENT_LABEL,
+        "ProgramArguments": [loki_bin, "trigger", "daemon", "--loop"],
+        "WorkingDirectory": repo,
+        "EnvironmentVariables": {
+            "LOKI_COMPANY_ROOT": repo,
+            "PATH": os.environ.get("PATH", "/usr/local/bin:/usr/bin:/bin"),
+            "HOME": home,
+        },
+        "RunAtLoad": True,
+        "KeepAlive": True,
+        "ThrottleInterval": 30,
+        "StandardOutPath": os.path.join(logs, "company.out.log"),
+        "StandardErrorPath": os.path.join(logs, "company.err.log"),
+    }
+    path = launchagent_path(home)
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with os.fdopen(os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), "wb") as f:
+        plistlib.dump(plist, f)
+    os.chmod(path, 0o600)
+    return path
+
+
+def remove_launchagent(home):
+    path = launchagent_path(home)
+    if not os.path.exists(path):
+        return False
+    os.unlink(path)
+    return True
+
+
+def systemd_unit(repo, loki_bin):
+    return "\n".join([
+        "[Unit]",
+        "Description=Loki Mode company seats (schedule daemon)",
+        "",
+        "[Service]",
+        "WorkingDirectory=%s" % repo,
+        "Environment=LOKI_COMPANY_ROOT=%s" % repo,
+        "ExecStart=%s trigger daemon --loop" % loki_bin,
+        "Restart=always",
+        "RestartSec=30",
+        "",
+        "[Install]",
+        "WantedBy=default.target",
+        "",
+    ])
+
+
+def _launchctl(*args):
+    return subprocess.run(["launchctl"] + list(args), capture_output=True, text=True)
+
+
+def install_company(no_load=False):
+    home = os.path.expanduser("~")
+    repo = company_root()
+    loki_bin = os.environ.get("LOKI_BIN") or shutil.which("loki") or "loki"
+    added = seed_default_schedules()
+    print("Seeded %d default seat schedule(s) into .loki/triggers/schedules.json" % added)
+    if sys.platform != "darwin":
+        print("NOT SUPPORTED: launchd install is macOS only. Equivalent systemd user unit "
+              "(~/.config/systemd/user/loki-company.service):\n")
+        print(systemd_unit(repo, loki_bin))
+        return 0
+    path = write_launchagent(home, repo, loki_bin)
+    print("Wrote %s" % path)
+    if not no_load:
+        dom = "gui/%d" % os.getuid()
+        _launchctl("bootout", dom, path)
+        r = _launchctl("bootstrap", dom, path)
+        if r.returncode != 0:
+            print("launchctl bootstrap failed: %s" % (r.stderr.strip() or r.stdout.strip()))
+            return 1
+        print("Loaded %s" % LAUNCHAGENT_LABEL)
+    return 0
+
+
+def uninstall_company(no_load=False):
+    home = os.path.expanduser("~")
+    if sys.platform != "darwin":
+        print("NOT SUPPORTED: nothing to remove (launchd is macOS only).")
+        return 0
+    path = launchagent_path(home)
+    if not no_load and os.path.exists(path):
+        _launchctl("bootout", "gui/%d" % os.getuid(), path)
+    print("Removed %s" % path if remove_launchagent(home) else "Not installed: %s" % path)
+    return 0
+
+
 def log_event(name, action_desc, status):
     """Log schedule fire to events.log."""
     log_path = get_loki_dir() / "events.log"
@@ -249,6 +621,20 @@ def run_daemon(dry_run=False, once=False):
     return True
 
 
+def run_daemon_loop(max_passes=None):
+    """Always-on mode: one pass at the top of every minute (launchd KeepAlive)."""
+    passes = 0
+    while max_passes is None or passes < max_passes:
+        try:
+            run_daemon(once=True)
+        except Exception:  # keep the always-on loop alive across a bad pass
+            logging.exception("daemon pass failed")
+        passes += 1
+        if max_passes is not None and passes >= max_passes:
+            break
+        time.sleep(60 - time.time() % 60)
+
+
 def list_schedules():
     """Print all configured schedules."""
     schedules = load_schedules()
@@ -321,6 +707,15 @@ def main():
     # daemon - run one pass
     daemon_parser = subparsers.add_parser("daemon", help="Run one pass of schedule checks")
     daemon_parser.add_argument("--dry-run", action="store_true", help="Preview without running")
+    daemon_parser.add_argument("--loop", action="store_true", help="Keep running, one pass per minute")
+    daemon_parser.add_argument("--max-passes", type=int, default=None, help=argparse.SUPPRESS)
+
+    tick_parser = subparsers.add_parser("tick", help="Run one headless tick of a company seat")
+    tick_parser.add_argument("seat")
+    subparsers.add_parser("seed", help="Add default company-seat schedules")
+    for cmd_name in ("install", "uninstall"):
+        ip = subparsers.add_parser(cmd_name, help="%s the always-on company LaunchAgent" % cmd_name.capitalize())
+        ip.add_argument("--no-load", action="store_true", help="Write/remove the plist without launchctl")
 
     # list
     subparsers.add_parser("list", help="List configured schedules")
@@ -347,7 +742,20 @@ def main():
 
     if args.command == "daemon" or args.command is None:
         dry_run = getattr(args, "dry_run", False)
-        run_daemon(dry_run=dry_run, once=True)
+        if getattr(args, "loop", False):
+            run_daemon_loop(getattr(args, "max_passes", None))
+        else:
+            run_daemon(dry_run=dry_run, once=True)
+    elif args.command == "tick":
+        status, detail = tick_seat(args.seat)
+        print("%s: %s" % (status, detail))
+        sys.exit(1 if status == "error" else 0)
+    elif args.command == "seed":
+        print("Added %d default seat schedule(s)" % seed_default_schedules())
+    elif args.command == "install":
+        sys.exit(install_company(args.no_load))
+    elif args.command == "uninstall":
+        sys.exit(uninstall_company(args.no_load))
     elif args.command == "list":
         list_schedules()
     elif args.command == "add":

package/completions/loki.bash

@@ -115,6 +115,11 @@ _loki_completion() {
             COMPREPLY=( $(compgen -W "${telemetry_cmds}" -- "$cur") )
             ;;
 
+        trigger)
+            local trigger_cmds="start stop status list add remove daemon install uninstall test logs help --dry-run --loop --no-load"
+            COMPREPLY=( $(compgen -W "${trigger_cmds}" -- "$cur") )
+            ;;
+
         agent)
             local agent_cmds="list info run start help"
             COMPREPLY=( $(compgen -W "${agent_cmds}" -- "$cur") )

package/dashboard/__init__.py

@@ -7,6 +7,6 @@ Modules:
     control: Session control helpers (status, atomic writes, origin check)
 """
 
-__version__ = "11.73.0"
+__version__ = "11.74.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.73.0. Do not edit by hand.
+Generated from `loki-ts/src/cli/registry.ts` by `scripts/generate-stale-zero.sh` for v11.74.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.73.0
+**Version:** v11.74.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/v10/FAILURE-CLASSES.md

@@ -2016,3 +2016,10 @@ L0 review rule (ENGINE-LAWS.md L0): a fix that adds an `if` or a regex about the
 - Siblings swept: every MAIN_REF consumer (Main CI, unreleased-merge age, release cadence, moat baseline, unevidenced-claim scan, release-on-red) shares one resolved ref; the `gh --branch` streak call keeps the branch name `main`.
 - Mechanism: one resolution in scripts/v10-pulse.sh. PULSE_MAIN_REF unset and local main a strict ancestor of refs/remotes/origin/main: MAIN_REF becomes the remote-tracking ref and STALE_MAIN_REF fires with N. Diverged: STALE_MAIN_REF says diverged and the ref is unchanged. An explicit PULSE_MAIN_REF wins. No fetch.
 - Fixture: tests/test-v10-pulse.sh "RQ-98" (behind by 2, equal, diverged, explicit pin; two mutants).
+
+## FC-VERDICT-FROM-UNKNOWN-INPUT The pulse emitted `VIOLATION: TRAIN_LATE` at main 530b63296 off a merged-but-unreleased count (stale local tag v11.70.4) that the same run had already marked UNKNOWN against npm next 11.74.0
+- User-visible vs raw: user-visible. Main was fully released (`git log -1 main` = "release: v11.74.0"), yet the pulse told the operator to push a release train.
+- Law broken: a verdict is never computed from an input the same run already marked UNKNOWN; it reports UNKNOWN.
+- Siblings swept: every reader of `unreleased` in scripts/v10-pulse.sh: TRAIN_LATE (fixed, was gated only on `unreleased is None`), D44 green-unreleased RELEASE_CADENCE (fixed, same gap), release cadence D37 and merged-not-released stale (already gated, now via the shared helper).
+- Mechanism: one helper `_unreleased_count_unknown()` in scripts/v10-pulse.sh (check failed OR local tag disagrees with npm next); every check reading `unreleased` returns None (UNKNOWN) when it is true.
+- Fixture: tests/test-v10-pulse.sh "FC-VERDICT-FROM-UNKNOWN-INPUT" (tag v9.54.2 vs npm next 9.55.0, push 26 min old: UNKNOWN line, no TRAIN_LATE).