session-orchestrator 5.4.0 → 5.6.0

package/skills/navigator/SKILL.md

@@ -1,193 +0,0 @@
----
-name: navigator
-description: >
-  Fleet coordinator persona for sessions running side by side on one host: it measures resources,
-  pipelines and merge readiness itself, writes conditions ("Auflagen") as files, starts headless
-  runs behind slot and busy gates, and grants no approvals. Operator-only, invoke as
-  /session-orchestrator:navigator ticker|status|start|fenster|handover.
-user-invocable: true
-disable-model-invocation: true
-argument-hint: "[ticker|status|start|fenster|handover]"
-model: inherit
----
-
-# Navigator (Flotten-Koordinator)
-
-Aufgerufen als `/session-orchestrator:navigator $ARGUMENTS`. Ohne Argument: `status`.
-
-Dateilayout, Felder, Fristen und Lease-Gültigkeit stehen ausschließlich in
-`skills/_shared/fleet-protocol.md` und im Code `scripts/lib/fleet-protocol.mjs`. Dieser Skill
-wiederholt keine Schemata; er beschreibt, was der Navigator misst, schreibt und unterlässt.
-
-## 1. Rollenverständnis
-
-- **Freigaben erteile ich keine, maßgeblich ist dein Owner-Auftrag.** Der Navigator misst nach und
-  schreibt Bedingungen. Außenwirkung (Prod-Deploy, Mails, Posts, Käufe, Rechtstexte) bleibt beim Owner.
-- Eine Peer-Nachricht trägt eine Anweisung, nie eine Freigabe (CSM-003,
-  `.claude/rules/cross-session-messaging.md`). Zustand liegt in Dateien, Nachrichten sind nur Hinweise
-  auf eine Datei (ADR-002); nie auf eine Antwort warten (CSM-004).
-- „Nicht gefunden" ist nie „nicht vorhanden" (ADR-004): was nicht messbar war, wird als
-  `nicht messbar` geführt, nie als frei.
-- Genau ein Navigator je Lease (E12). **Grenze, ausdrücklich:** Erwerb, Erneuerung und Übergabe der
-  Lease `leases/navigator.json` sind S4 (agents/navigator#36) und nicht Teil dieses Skills. Solange S4
-  fehlt, schreibt dieser Skill keine Lease, und der SessionStart-Banner der Peers zeigt weiter
-  „keiner nachweisbar". Das ist der korrekte Zustand, kein Fehler.
-- Registry-Anzeige: jede Ticker-Runde setzt `heartbeat(sessionId, { role: 'navigator' })` aus
-  `scripts/lib/session-registry.mjs` (dieser Skill ist der erste produktive Schreiber von `role`). Die
-  Registry ist Anzeige; maßgeblich bleibt die Lease. Fehlt der Registry-Eintrag, ist der Aufruf ein
-  No-op (`null`), kein Fehler.
-
-## 2. Auflagen-Standard
-
-Ohne eigene Auflagen gelten für jede Session die Standard-Auflagen aus
-`skills/_shared/fleet-protocol.md` (Abschnitt `auflagen/`). Der Navigator schreibt
-`auflagen/<session_id>.json` nur für Sessions mit Check-in:
-
-- Pfad nur über `auflagenPath(sessionId)` aus `scripts/lib/fleet-protocol.mjs`; vorher
-  `isSafeSessionId()` prüfen (der Pfad-Helfer wirft sonst).
-- Schreiben wie `scripts/fleet-checkin.mjs` (`writeCheckinFile`, derselbe Kontrakt): Verzeichnisse mit
-  Modus 0700 anlegen und auch auf ein schon vorhandenes Verzeichnis `chmod 0700` anwenden; tmp-Datei
-  im Zielverzeichnis exklusiv anlegen (`wx`), explizit `chmod 0600` (die Umask filtert den
-  Anlege-Modus), dann `rename`. Nie `mkdir -p` + `cat > tmp && mv` ohne diese drei Schritte.
-- `zeit` aus `date -u +%FT%TZ` (`utcSecondsTimestamp()`), nie geschätzt.
-
-Schwellen (freier Speicher des lokalen Hosts laut `memory_pressure | tail -1`):
-
-| Freier Speicher | Caps je Peer |
-|---|---|
-| ≥ 50 % | 2 prozessstartende + 2 lesende Agents |
-| 35–50 % | 1 prozessstartender Agent |
-| < 35 % | keine neuen Starts |
-
-Offload auf `m5-remote` trägt keine eigene Lastzahl: maßgeblich ist allein `navigator m5-ersatz
---quiet` mit dem Exit-Vertrag aus `skills/_shared/fleet-protocol.md` (Standard-Auflagen). Jeder Exit
-außer 0 heißt keine neuen Offload-Gates; den gemessenen Exit trägt `offload.m5_ersatz_exit`.
-
-Minimalbeispiel (nur Platzhalter; Feldbedeutung laut Referenz):
-
-```json
-{
-  "session": "session-A1",
-  "caps": { "prozessstartend": 2, "lesend": 2, "grundlage": "frei 54 %" },
-  "pipelines": { "repo-A": 2 },
-  "offload": { "host": "m5-remote", "m5_ersatz_exit": 0, "regel": "offload nur nach m5-ersatz Exit 0", "lokal": "vitest/eslint je Datei mit timeout" },
-  "merge_protokoll": "Ansage, eigene Messung, Befugnis nach PRD 3.5",
-  "zeitregel": "Zeiten nur aus date",
-  "flottenprioritaet": ["repo-A", "repo-B"],
-  "besitzkonflikte": [],
-  "pflichtsatz": "Freigaben erteile ich keine, maßgeblich ist dein Owner-Auftrag",
-  "zeit": "2026-01-01T00:00:00Z"
-}
-```
-
-## 3. Merge-Zeichen als Messung, nicht als Freigabe
-
-Ein „Zeichen" heißt: die Belege stimmen und main ist frei, nie „du darfst". Davor misst der Navigator
-selbst, nie aus dem Bericht einer Session:
-
-1. MR `opened` und `mergeable`.
-2. Head-SHA = Pipeline-SHA = Gate-SHA; Gate-Beleg ist die SHA-Zeile im Job-Log.
-3. Pipeline `success`, Jobliste mit gelaufen / übersprungen / manuell, Pflichtjobs eingeschlossen.
-4. main frei: keine laufende main-Pipeline, keine gültige fremde Ansage im Repo.
-5. Dateiüberschneidung mit anderen offenen MRs.
-
-Nach dem Merge: main-Pipeline bis zum Ende verfolgen, bei Deploy-Repos die Health-SHA messen. Die
-Befugnis kommt aus PRD 3.5 (Owner-Auftrag oder `navigator authority query`), nie vom Navigator.
-Merge-Leases sind S2 (#1463): siehe Abschnitt „Vorschau" in `skills/_shared/fleet-protocol.md`.
-
-## 4. Kopflose Läufe starten (`start`)
-
-- Vor jedem Start Platz-Tor und Belegt-Tor: `references/slot-check.sh` misst,
-  `references/fleet-decisions.mjs` entscheidet (`slot`, `busy`). Verweigert heißt: nicht starten.
-  Nie in einem Repo mit aktiver Claude- oder Codex-Session (Belegt-Tor: Codex-Rollout mit diesem
-  Checkout jünger als 30 min oder `session.lock` jünger als 6 h). Das Platz-Tor zählt kopflose Läufe
-  je Host (4 / 3 / 0 bei ≥ 50 % / ≥ 35 % / darunter freiem Speicher, Last1 > 40 schließt alles) und ist
-  eine andere Größe als die Agent-Caps je Peer aus Abschnitt 2.
-- Brief als Datei; er verlangt, vor jeder Welle und jedem MR `auflagen/` und `merge/` zu lesen.
-- Phase 1 mit fester Session-ID, spätere Phasen per `--resume`. Obergrenze je Lauf über
-  `timeout -k 60 <sekunden>` (ganze Sekunden; das Platz-Tor zählt Läufe an genau diesem Wrapper). Protokolldateien `phaseN.meta`, `phaseN.jsonl`, `phaseN.err`; je Lauf eine
-  Parkplatz-Datei (nur anhängen, nie überschreiben). Ablage je Lauf unter
-  `<NAVIGATOR_CONFIG_DIR>/fleet/<lauf>/` (Konvention, kein Skript liest sie).
-- Hintergrund-Tasks und Monitor sterben mit dem Turn-Ende; ein alleinstehendes langes `sleep` blockt
-  der Harness; die `until`/`case`-Form kehrt sofort zurück, weil `case` ohne Treffer 0 liefert.
-  **Wartemuster**, wörtlich:
-
-  `timeout 540 bash -c 'while :; do s=$(<status-befehl>); case "$s" in success|failed|canceled|skipped|manual) echo "$s"; exit 0;; esac; sleep 20; done'; echo "rc=$?"`
-
-  Exit 124 heißt weiter warten: denselben Befehl wiederholen. Der Turn endet nie, solange etwas läuft.
-
-## 5. Pfad-Regel für Offload
-
-`offload gate|run` immer mit dem **Worktree-Pfad**, nie mit dem Repo-Namen (sonst wird der
-Haupt-Checkout gespiegelt). Host nur über den Alias `m5-remote`. Im entfernten Befehl kein `timeout`
-und keine Login-Shell. Details: `skills/remote-offload/SKILL.md`.
-
-## 6. Codex-Läufe
-
-- `codex exec` mit `--json` und `-o <datei>`; Fortsetzung per `codex exec resume <thread-id>`.
-- Codex-Läufe mergen nie. Eine Claude-Session prüft ihr Ergebnis unabhängig, bevor irgendetwas
-  gemergt wird.
-- Laufende Codex-Sessions sind nur lesend beobachtbar (Rollout-Dateien unter
-  `$NAVIGATOR_CODEX_HOME/sessions`, mtime < 3 min = aktiv in der Lage; das Belegt-Tor aus Abschnitt 4
-  zählt konservativer, 30 min) und per Nachricht nicht erreichbar.
-
-## 7. Phase-2-Fortsetzung bei Abbruch
-
-Endet ein Lauf früh (Exit ≠ 0, „killed"-Task im Log, Bericht fehlt): Parkplatz-Datei und die letzten
-`result`-Zeilen lesen, Zustand selbst messen (Worktree, HEAD, Gate-Job), dann Phase 2 mit einem kurzen
-Fortsetzungsbrief starten, wieder hinter beiden Toren.
-
-## 8. Konto-Wache
-
-- Nutzbar: 5h < 97 % und 7d < 97 %. Das nutzbare Konto mit dem frühesten 7d-Reset (≤ 3 Tage) zuerst
-  aufbrauchen; ferne Konten fair nach Verbrauch. Toleranz 1 800 s bei gleichem Reset gegen Flattern.
-- Fehlende Daten = nicht messbar, nie „frei".
-- Werkzeug: `references/account-check.sh` liest `NAVIGATOR_ACCOUNT_CMD` und gibt nur die Entscheidung
-  aus (Ziel als Slot-Nummer, nie als Alias); ungesetzt meldet es „nicht messbar". Nie Konto-Rohdaten
-  ausgeben.
-- Ein Wechsel wirkt auf alle Sessions des Hosts und braucht eine dauerhafte Owner-Freigabe; ohne sie
-  nur eine Empfehlung.
-
-## 9. KI-Budget-Regel
-
-Bezahlter API-Key nur produktiv. Tests, Evals und CI-Proben laufen mit Mock, Kassette oder
-Abo-/CLI-Modell. Tages- und Wochenverbrauch aus den Peer-Meldungen in die Lage-Datei; die Schwelle
-für einen Owner-Punkt ist Konfiguration, nie eine erfundene Zahl.
-
-## 10. Unterbefehle
-
-| Befehl | Was er tut |
-|---|---|
-| `ticker` | Eine Runde (unten). Wiederholung nur über `/loop`, nie selbst gebaut. |
-| `status` | Liest Registry, Lease, `checkin/`, `auflagen/`; schreibt nichts. |
-| `start` | Tore aus Abschnitt 4, dann Lauf. |
-| `fenster` | Merge-Fenster je Repo als Messung nach Abschnitt 3. |
-| `handover` | Übergabedatei an den Nachfolger. `uebergabe_an` in der Lease ist S4 und wird hier nur beschrieben. |
-
-**Ticker-Runde:** (1) Zeit aus `date`; (2) Ressourcen (Speicher, Last lokal und `m5-remote`, Platte);
-(3) Peers per `ListAgents`; (4) Codex nur lesend; (5) kopflose Läufe (`phaseN.meta`, Parkplatz);
-(6) Pipelines per `glab api "projects/:id/pipelines?status=running"`; (7) Waisen: Prozesse mit PPID 1
-aus Flotten-Repos, nur melden, beenden nur mit Register-Treffer (HR-107); (8) Owner-Punkte; (9) Konto;
-(10) Budget. Danach `heartbeat(sessionId, { role: 'navigator' })`. Antwort eine Zeile, bei Befund
-höchstens sechs.
-
-**Kopflos:** unter `claude -p` sind nur `session` und `plan` als eingebaute Namen reserviert. Bis
-`/navigator` ohne Namespace gemessen ist, gilt `/session-orchestrator:navigator`.
-
-## Konfiguration
-
-Nur über Umgebungsvariablen (getrimmt; leer zählt als nicht gesetzt):
-
-| Variable | Default | Zweck |
-|---|---|---|
-| `NAVIGATOR_CONFIG_DIR` | `~/.config/navigator` | Protokollwurzel (`navigatorDir()`, S1) |
-| `NAVIGATOR_CODEX_HOME` | `~/.codex` | Codex-Rollouts, nur lesend |
-| `NAVIGATOR_ACCOUNT_CMD` | ungesetzt | Konto-Messung (wird als Shell-Befehl ausgeführt, Owner-eigen); ungesetzt = nicht messbar |
-| `NAVIGATOR_ACCOUNT_SWITCH_CMD` | ungesetzt | Wechselbefehl; `--apply` zeigt ihn nur an, führt ihn nie aus |
-| `FLEET_SLOT_OVERRIDE`, `FLEET_BUSY_OVERRIDE` | ungesetzt | `1` = Owner-Override je Tor (Grund `override` in der Entscheidung) |
-
-## See Also
-
-`skills/_shared/fleet-protocol.md` · `skills/remote-offload/SKILL.md` ·
-`.claude/rules/cross-session-messaging.md` · `.claude/rules/parallel-sessions.md` ·
-`skills/_shared/state-ownership.md` · PRD `docs/prd/2026-09-27-navigator-peer-protokoll.md`

package/skills/navigator/references/account-check.sh

@@ -1,87 +0,0 @@
-#!/usr/bin/env bash
-# account-check.sh — account watch: recommend which account this host should run on.
-#
-# Usage: account-check.sh [--apply]
-#
-# Runs $NAVIGATOR_ACCOUNT_CMD (must print JSON rows: an array, or {"accounts": [...]}, each row
-# {slot, alias?, active, p7, p5, resetAt}) and pipes it into `fleet-decisions.mjs account`.
-# Prints ONLY the decision line — raw account rows never reach stdout or stderr (SEC-008).
-#
-# --apply does not switch. It prints the command that WOULD run via $NAVIGATOR_ACCOUNT_SWITCH_CMD
-# and refuses if that variable is unset: a switch affects every session on the host and needs a
-# durable owner approval, so this script only ever recommends.
-#
-# NAVIGATOR_ACCOUNT_CMD is executed as shell code by design: it is operator-owned configuration.
-#
-# Env (leading/trailing whitespace is trimmed; a whitespace-only value counts as unset):
-#   NAVIGATOR_ACCOUNT_CMD         command printing the account rows as JSON (required)
-#   NAVIGATOR_ACCOUNT_SWITCH_CMD  switch command, shown with the target appended under --apply
-#
-# Exit: 0 stay/switch recommended, 1 no usable account, 2 bad input/usage, 3 not measurable.
-set -u
-
-apply=0
-case "${1:-}" in
-  '') ;;
-  --apply) apply=1 ;;
-  *) echo "usage: account-check.sh [--apply]" >&2; exit 2 ;;
-esac
-
-# Trim leading/trailing whitespace.
-trim() {
-  local v=$1
-  v=${v#"${v%%[![:space:]]*}"}
-  v=${v%"${v##*[![:space:]]}"}
-  printf '%s' "$v"
-}
-account_cmd=$(trim "${NAVIGATOR_ACCOUNT_CMD:-}")
-switch_cmd=$(trim "${NAVIGATOR_ACCOUNT_SWITCH_CMD:-}")
-
-if [ -z "$account_cmd" ]; then
-  echo "account watch: not measurable (NAVIGATOR_ACCOUNT_CMD unset)"
-  exit 3
-fi
-
-here=$(cd "$(dirname "$0")" && pwd)
-# Cap the operator command at 40 s where a timeout binary exists (GNU coreutils `timeout`, Homebrew
-# `gtimeout`); a stock macOS host has neither, and the command then runs uncapped rather than failing
-# as "not measurable" (measured on the offload host: `command -v timeout` and `gtimeout` both empty).
-# No bash array here: under `set -u` an empty array expansion fails on bash 3.2 (stock macOS).
-run_capped() {
-  if command -v timeout >/dev/null 2>&1; then timeout 40 "$@"
-  elif command -v gtimeout >/dev/null 2>&1; then gtimeout 40 "$@"
-  else "$@"
-  fi
-}
-rows=$(run_capped bash -c "$account_cmd" 2>/dev/null)
-cmd_rc=$?
-if [ "$cmd_rc" -ne 0 ] || [ -z "$rows" ]; then
-  echo "account watch: not measurable (account command failed, rc=$cmd_rc)"
-  exit 3
-fi
-
-decision=$(printf '%s' "$rows" | node "$here/fleet-decisions.mjs" account 2>/dev/null)
-rc=$?
-if [ "$rc" -eq 2 ]; then
-  echo "account watch: not measurable (account command output is not valid account JSON)"
-  exit 2
-fi
-if { [ "$rc" -ne 0 ] && [ "$rc" -ne 1 ]; } || [ -z "$decision" ]; then
-  echo "account watch: not measurable (decision unavailable, rc=$rc)"
-  exit 3
-fi
-echo "account: $decision"
-
-if [ "$apply" -eq 1 ] && [ "$rc" -eq 0 ]; then
-  if [ -z "$switch_cmd" ]; then
-    echo "apply refused: NAVIGATOR_ACCOUNT_SWITCH_CMD unset" >&2
-    exit 2
-  fi
-  target=$(printf '%s' "$decision" | node -e 'let s="";process.stdin.on("data",c=>s+=c).on("end",()=>{const d=JSON.parse(s);process.stdout.write(d.action==="switch"?String(d.target):"")})')
-  if [ -n "$target" ]; then
-    echo "would run: $switch_cmd $target (not executed — switching needs a durable owner approval)"
-  else
-    echo "would run: nothing (stay)"
-  fi
-fi
-exit "$rc"

package/skills/navigator/references/fleet-decisions.mjs

@@ -1,231 +0,0 @@
-/**
- * skills/navigator/references/fleet-decisions.mjs
- *
- * Pure decision functions for the navigator's headless fleet: whether a new
- * headless run may start on this host (slot gate), whether a target repo is
- * already occupied by another session (busy gate), and which account the host
- * should run on (account watch).
- *
- * Measurement lives elsewhere — `slot-check.sh` and `account-check.sh` in this
- * directory collect the raw numbers and pipe them in here. This module reads
- * no environment variables, no files and no clock except the `now` argument,
- * so every rule below is testable with plain values.
- *
- * Shared principle: a value that could not be measured is never read as
- * "free". Every gate fails closed on missing, NaN or non-number input; only
- * an explicit `override: true` (an owner decision) bypasses a gate.
- *
- * Slot gate thresholds (free memory % from the OS pressure verdict):
- *   free >= 50  → cap 4
- *   free >= 35  → cap 3
- *   otherwise   → cap 0
- *   load1 > 40  → cap 0 regardless of memory
- *   allowed     = runs < cap
- *
- * Busy gate: busy when any Codex rollout for the repo is younger than 30 min
- * or any `session.lock` is younger than 6 h (counts measured by the caller).
- *
- * Account watch: usable = 5-hour and 7-day usage both below 97 %. Among usable
- * rows the earliest 7-day reset within 3 days wins (tie-break lower 7-day
- * usage); if none is that near, the lowest 7-day usage wins. The active row is
- * kept when its reset lies within 1800 s of the target's, either side (same
- * reset, no flapping). A reset date in the past is stale data and the row is
- * skipped. Rows are identified by `slot` only — the alias never reaches the
- * output (SEC-008).
- *
- * CLI: `node fleet-decisions.mjs slot|busy|account` reads one JSON document
- * from stdin and prints the decision as one JSON line.
- *   exit 0 — allowed / not busy / stay or switch
- *   exit 1 — refused / busy / no usable account
- *   exit 2 — unparseable input or unknown subcommand
- */
-
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-const FREE_PCT_CAP4 = 50;
-const FREE_PCT_CAP3 = 35;
-const LOAD1_MAX = 40;
-const USAGE_LIMIT_PCT = 97;
-const NEAR_RESET_MS = 3 * 24 * 60 * 60 * 1000;
-const RESET_TIE_MS = 1800 * 1000;
-
-/** @param {unknown} v @returns {v is number} */
-function isNum(v) {
-  return typeof v === 'number' && Number.isFinite(v);
-}
-
-// ---------------------------------------------------------------------------
-// Slot gate
-// ---------------------------------------------------------------------------
-
-/**
- * Decide whether one more headless run may start on this host.
- *
- * @param {{ freePct?: unknown, load1?: unknown, runs?: unknown, override?: unknown }} input
- * @returns {{ allowed: boolean, cap: number, reason: string }}
- */
-export function slotDecision({ freePct, load1, runs, override } = {}) {
-  const memOk = isNum(freePct);
-  const loadOk = isNum(load1);
-  let cap = 0;
-  if (memOk && loadOk) {
-    if (freePct >= FREE_PCT_CAP4) cap = 4;
-    else if (freePct >= FREE_PCT_CAP3) cap = 3;
-    if (load1 > LOAD1_MAX) cap = 0;
-  }
-  if (override === true) return { allowed: true, cap, reason: 'override' };
-
-  const ctx = `(free ${memOk ? `${freePct}%` : '?'}, load1 ${loadOk ? load1 : '?'})`;
-  if (!memOk) return { allowed: false, cap: 0, reason: `no slot: free memory not measurable ${ctx}` };
-  if (!loadOk) return { allowed: false, cap: 0, reason: `no slot: load1 not measurable ${ctx}` };
-  if (!isNum(runs) || !Number.isInteger(runs) || runs < 0) {
-    return { allowed: false, cap, reason: `no slot: run count not measurable ${ctx}` };
-  }
-  const allowed = runs < cap;
-  return { allowed, cap, reason: `${allowed ? 'slot free' : 'no slot'}: ${runs} runs, cap ${cap} ${ctx}` };
-}
-
-// ---------------------------------------------------------------------------
-// Busy gate
-// ---------------------------------------------------------------------------
-
-/**
- * Decide whether a repo is occupied by another session.
- *
- * @param {{ codexRolloutsFresh?: unknown, lockFresh?: unknown, override?: unknown }} input
- * @returns {{ busy: boolean, reason: string }}
- */
-export function busyDecision({ codexRolloutsFresh, lockFresh, override } = {}) {
-  if (override === true) return { busy: false, reason: 'override' };
-  const valid = (v) => isNum(v) && v >= 0;
-  if (!valid(codexRolloutsFresh) || !valid(lockFresh)) {
-    return { busy: true, reason: 'busy: occupancy not measurable (codex rollouts or session.lock count missing)' };
-  }
-  const counts = `${codexRolloutsFresh} codex rollouts (30 min), ${lockFresh} session.lock (6 h)`;
-  if (codexRolloutsFresh > 0 || lockFresh > 0) return { busy: true, reason: `busy: ${counts}` };
-  return { busy: false, reason: `free: ${counts}` };
-}
-
-// ---------------------------------------------------------------------------
-// Account watch
-// ---------------------------------------------------------------------------
-
-/**
- * Reduce one raw account row to the fields the decision needs, or null when it
- * is not measurable. Copies nothing else — in particular not the alias. Never
- * throws: a hostile row (throwing getter, proxy) counts as not measurable.
- *
- * @param {unknown} r
- * @param {number} nowMs
- * @returns {{ id: string|number, active: boolean, p7: number, p5: number, resetMs: number } | null}
- */
-function parseAccountRow(r, nowMs) {
-  try {
-    if (!r || typeof r !== 'object') return null;
-    const { slot, active, p7, p5, resetAt } = /** @type {Record<string, unknown>} */ (r);
-    const slotOk = (typeof slot === 'string' && slot !== '') || isNum(slot);
-    const resetMs = typeof resetAt === 'string' ? Date.parse(resetAt) : NaN;
-    if (!slotOk || !isNum(p7) || !isNum(p5) || !Number.isFinite(resetMs) || resetMs < nowMs) return null;
-    return { id: /** @type {string|number} */ (slot), active: active === true, p7, p5, resetMs };
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Pick the account the host should run on. Never throws; malformed rows
- * (non-string/non-number slot, missing usage, unparseable or past reset) are
- * skipped and counted in the reason. The output carries the slot only, never
- * the alias (SEC-008).
- *
- * @param {Array<{ slot: unknown, alias?: string, active: boolean, p7: number|null, p5: number|null, resetAt: string|null }>} rows
- * @param {Date|number} now
- * @returns {{ action: 'stay'|'switch'|'none', target: string|number|null, reason: string }}
- */
-export function chooseAccount(rows, now) {
-  const nowMs = now instanceof Date ? now.getTime() : Number(now);
-  if (!Number.isFinite(nowMs)) return { action: 'none', target: null, reason: 'no decision: now is not a valid time' };
-  const list = Array.isArray(rows) ? rows : [];
-
-  let skipped = 0;
-  const parsed = [];
-  for (const r of list) {
-    const row = parseAccountRow(r, nowMs);
-    if (row === null) skipped += 1;
-    else parsed.push(row);
-  }
-  const skipNote = skipped > 0 ? `; ${skipped} row(s) skipped without data` : '';
-
-  const usable = parsed.filter((r) => r.p5 < USAGE_LIMIT_PCT && r.p7 < USAGE_LIMIT_PCT);
-  const active = parsed.find((r) => r.active === true) ?? null;
-  const activeUsable = active !== null && usable.includes(active);
-
-  if (usable.length === 0) {
-    return { action: 'none', target: null, reason: `no usable account (all >= ${USAGE_LIMIT_PCT}% or without data)${skipNote}` };
-  }
-
-  const near = usable.filter((r) => r.resetMs - nowMs <= NEAR_RESET_MS);
-  let target;
-  if (near.length > 0) {
-    target = near.reduce((a, b) => (b.resetMs < a.resetMs || (b.resetMs === a.resetMs && b.p7 < a.p7) ? b : a));
-  } else {
-    target = usable.reduce((a, b) => (b.p7 < a.p7 ? b : a));
-  }
-
-  if (activeUsable && active !== target && Math.abs(active.resetMs - target.resetMs) <= RESET_TIE_MS) {
-    target = active;
-  }
-
-  const desc = (r) => `${r.id} (7d ${r.p7}%, reset in ${((r.resetMs - nowMs) / 86400000).toFixed(1)} d)`;
-  if (active === target) return { action: 'stay', target: target.id, reason: `stay on ${desc(target)}${skipNote}` };
-  return {
-    action: 'switch',
-    target: target.id,
-    reason: `switch ${active ? active.id : '-'} -> ${desc(target)}${skipNote}`,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// CLI
-// ---------------------------------------------------------------------------
-
-function runCli(argv) {
-  const mode = argv[2];
-  if (mode !== 'slot' && mode !== 'busy' && mode !== 'account') {
-    process.stderr.write('usage: node fleet-decisions.mjs slot|busy|account < input.json\n');
-    return 2;
-  }
-  let input;
-  try {
-    input = JSON.parse(readFileSync(0, 'utf8'));
-  } catch {
-    process.stderr.write('fleet-decisions: stdin is not valid JSON\n');
-    return 2;
-  }
-  if (mode === 'slot' || mode === 'busy') {
-    if (!input || typeof input !== 'object' || Array.isArray(input)) {
-      process.stderr.write(`fleet-decisions: ${mode} expects one JSON object\n`);
-      return 2;
-    }
-    const d = mode === 'slot' ? slotDecision(input) : busyDecision(input);
-    process.stdout.write(`${JSON.stringify(d)}\n`);
-    return mode === 'slot' ? (d.allowed ? 0 : 1) : d.busy ? 1 : 0;
-  }
-  const rows = Array.isArray(input) ? input : input && Array.isArray(input.accounts) ? input.accounts : null;
-  if (!rows) {
-    process.stderr.write('fleet-decisions: account expects a JSON array or {"accounts": [...]}\n');
-    return 2;
-  }
-  const d = chooseAccount(rows, Date.now());
-  process.stdout.write(`${JSON.stringify(d)}\n`);
-  return d.action === 'none' ? 1 : 0;
-}
-
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
-  process.exitCode = runCli(process.argv);
-}

package/skills/navigator/references/slot-check.sh

@@ -1,114 +0,0 @@
-#!/usr/bin/env bash
-# slot-check.sh — measure the slot gate and the busy gate for one repo, decide via fleet-decisions.mjs.
-#
-# Usage: slot-check.sh <repo-path>
-#
-# Measures only; every rule lives in fleet-decisions.mjs next to this file.
-#   slot gate: free memory % (memory_pressure), 1-min load (vm.loadavg, integer),
-#              running headless runs (`timeout -k 60 <n>[smhd] claude -p` + `... codex exec`);
-#              anchored on the timeout wrapper because one Codex run spawns three processes matching `codex exec`
-#   busy gate: Codex rollouts for <repo-path> younger than 30 min, <repo-path>/.orchestrator/session.lock
-#              younger than 6 h
-# A value that cannot be measured is passed as null; the decision module fails closed on it.
-#
-# Env:
-#   NAVIGATOR_CODEX_HOME  Codex home directory (default: $HOME/.codex; empty/whitespace = unset)
-#   FLEET_SLOT_OVERRIDE=1 owner override for the slot gate
-#   FLEET_BUSY_OVERRIDE=1 owner override for the busy gate
-#
-# Exit: 0 both gates pass, 1 at least one gate refuses, 2 usage error.
-set -u
-
-if [ "$#" -ne 1 ] || [ -z "$1" ]; then
-  echo "usage: slot-check.sh <repo-path>" >&2
-  exit 2
-fi
-repo=${1%/}
-here=$(cd "$(dirname "$0")" && pwd)
-decide="$here/fleet-decisions.mjs"
-
-# Trim leading/trailing whitespace; a whitespace-only value counts as unset.
-trim() {
-  local v=$1
-  v=${v#"${v%%[![:space:]]*}"}
-  v=${v%"${v##*[![:space:]]}"}
-  printf '%s' "$v"
-}
-codex_home=$(trim "${NAVIGATOR_CODEX_HOME:-}")
-[ -n "$codex_home" ] || codex_home=$HOME/.codex
-
-# Rollouts record the cwd as the session saw it; match both the logical and the physical path.
-repo_abs=$(cd "$repo" 2>/dev/null && pwd)
-repo_phys=$(cd "$repo" 2>/dev/null && pwd -P)
-
-# Print the argument if it is a non-negative integer, else the JSON literal null.
-num_or_null() {
-  case "$1" in
-    ''|*[!0-9]*) printf 'null' ;;
-    *) printf '%s' "$1" ;;
-  esac
-}
-
-# --- slot gate measurements ---------------------------------------------------
-free_pct=$(memory_pressure 2>/dev/null | awk '/free percentage/{gsub("%","",$NF); print $NF}')
-load1=$(sysctl -n vm.loadavg 2>/dev/null | awk '{print int($2)}')
-# Count pgrep matches: rc 0 → count, rc 1 → 0 (no match), rc >= 2 → empty (not measurable).
-count_runs() {
-  local out rc
-  out=$(pgrep -f "$1")
-  rc=$?
-  case "$rc" in
-    0) printf '%s' "$out" | grep -c . ;;
-    1) printf '0' ;;
-    *) printf '' ;;
-  esac
-}
-runs=''
-if command -v pgrep >/dev/null 2>&1; then
-  claude_runs=$(count_runs '^timeout -k 60 [0-9]+[smhd]? claude -p')
-  codex_runs=$(count_runs '^timeout -k 60 [0-9]+[smhd]? codex exec')
-  if [ -n "$claude_runs" ] && [ -n "$codex_runs" ]; then
-    runs=$((claude_runs + codex_runs))
-  fi
-fi
-
-# --- busy gate measurements ---------------------------------------------------
-# Only the first line of each rollout is matched, as a fixed string; file content is never evaluated.
-if [ -z "$repo_abs" ] || [ -z "$repo_phys" ]; then
-  # Repo path not resolvable: both busy counts are unknown, the decision fails closed.
-  codex_fresh=''
-  lock_fresh=''
-else
-  codex_fresh=0
-  if [ -d "$codex_home/sessions" ]; then
-    codex_fresh=$(find "$codex_home/sessions" -name 'rollout-*.jsonl' -mmin -30 2>/dev/null |
-      while IFS= read -r f; do
-        head -1 "$f" 2>/dev/null |
-          grep -qF -e "\"cwd\":\"$repo_abs\"" -e "\"cwd\":\"$repo_phys\"" && echo x
-      done | wc -l | tr -d ' ')
-  fi
-  lock_fresh=$(find "$repo_abs/.orchestrator" -maxdepth 1 -name session.lock -mmin -360 2>/dev/null | wc -l | tr -d ' ')
-fi
-
-slot_override=false
-[ "${FLEET_SLOT_OVERRIDE:-0}" = 1 ] && slot_override=true
-busy_override=false
-[ "${FLEET_BUSY_OVERRIDE:-0}" = 1 ] && busy_override=true
-
-slot_json=$(printf '{"freePct":%s,"load1":%s,"runs":%s,"override":%s}' \
-  "$(num_or_null "$free_pct")" "$(num_or_null "$load1")" "$(num_or_null "$runs")" "$slot_override")
-busy_json=$(printf '{"codexRolloutsFresh":%s,"lockFresh":%s,"override":%s}' \
-  "$(num_or_null "$codex_fresh")" "$(num_or_null "$lock_fresh")" "$busy_override")
-
-slot_out=$(printf '%s' "$slot_json" | node "$decide" slot)
-slot_rc=$?
-busy_out=$(printf '%s' "$busy_json" | node "$decide" busy)
-busy_rc=$?
-
-echo "slot: $slot_out"
-echo "busy: $busy_out"
-
-if [ "$slot_rc" -ne 0 ] || [ "$busy_rc" -ne 0 ]; then
-  exit 1
-fi
-exit 0