The code behind it

459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483

/* FEASIBILITY — the aggregate question, asked before any per-item detail.    */
/* "Does this fit at all?" is answered by arithmetic, not by a schedule: sum  */
/* the sessions required before a deadline, and compare with the sessions     */
/* that exist between now and then. If the sum exceeds the supply, no amount  */
/* of clever ordering rescues it, and the honest thing is to say so.          */
/* ------------------------------------------------------------------------ */
function feasibility(ITEMS, LANES, today, deadline, capacity = {}, effortOverride = {}) {
  const weeks = Math.max(0, diff(deadline, today) / 7);
  const need = {}, supply = {};
  for (const [k, v] of Object.entries(LANES)) {
    if (v.floor || v.agentPool) continue;
    supply[k] = (capacity[k] ?? v.cap) * weeks;
    need[k] = 0;
  }
  for (const it of ITEMS) {
    /* Count EVERY declared owner session, not only `task` rows. Agent reviews,
       the rehearsal, the reserve and the milestones carry real hours; counting
       only tasks left roughly a third of the Osiris lane's supply out of the
       headline "does it fit" answer. A shared sitting is counted once. */
    if (!it.due || diff(deadline, it.due) < 0) continue;
    if (it.sharesSitting) continue;
    const lane = ownerLane(it);
    if (!(lane in need)) continue;
    need[lane] += (effortOverride[it.id] ?? it.effort) || 0;
  }

56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

/* ⚠️ 2026-08-10 — IT HAPPENED A THIRD TIME, AND THE ALLOWLIST IS WHY.
   `edits`, `lanes` and `tags` were added to the client's MARK_MAPS and never
   here. Restoring his marks after the functions outage posted `tags` with one
   new tag; this list did not recognise the key, the `else` branch replaced the
   whole map, and 15 tags were destroyed in one call — which returned
   `ok: true`. They came back only because the export being restored happened
   to be a superset. It would not always be.

   So the rule is inverted below: ANY PLAIN OBJECT MERGES, and only scalars and
   arrays replace. An allowlist has to be updated in two repositories at once to
   stay safe, and three times running it was not — the list itself is the defect
   generator, not the people forgetting it. Removal has always been the explicit
   `clear` channel, so merging by default cannot strand a deletion. MAPS is kept
   below only as documentation of what the client sends. */
const isMap = v => v && typeof v === "object" && !Array.isArray(v);

2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021

  //  ⚖️ TWO CLASSES — owner ruling 2026-08-01 (the decoupling).
  //  Every gate is classified EXPLICITLY below. There is no default class: a new
  //  gate must be added to GATE_CLASS or the build refuses to run (see the
  //  completeness check after the gates). That is deliberate — a gate that
  //  silently inherits "freshness" would be a hole in the ironclad design.
  //
  //   • INTEGRITY — failing proves THE DATA WOULD BE WRONG. Stays FATAL: the
  //     build writes NOTHING and exits 1. Unchanged from the original design.
  //   • FRESHNESS — failing proves only THE RECORD IS BEHIND, while everything
  //     that would be displayed is still TRUE. Prints a loud warning, writes
  //     normally, exits 0, and the warning is carried to the publish-status line
  //     so it can never be silent.

2055
2056

  let ok = true;              // INTEGRITY only — this alone decides the write
  const freshness = [];       // FRESHNESS warnings — loud, but never withhold

21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

  try {
    const baked = window.OLYMPUS_DATA;
    const raw = localStorage.getItem(window.OLYMPUS_LIVE_KEY);
    if (!raw) return;
    const stored = JSON.parse(raw);
    // minimal shape check — a corrupt payload must never boot the app
    if (!stored || !stored.meta || !stored.meta.built_at
        || !Array.isArray(stored.ticks) || !Array.isArray(stored.lanes)) {
      localStorage.removeItem(window.OLYMPUS_LIVE_KEY);
      return;
    }
    // STRICTLY NEWER wins (ISO stamps compare lexically). A deploy that bakes
    // fresher data beats the stored copy — which is then junk; drop it.
    if (baked && baked.meta && baked.meta.built_at
        && stored.meta.built_at <= baked.meta.built_at) {
      localStorage.removeItem(window.OLYMPUS_LIVE_KEY);
      return;
    }
    window.OLYMPUS_DATA = stored;
  } catch { /* storage/parse trouble → the baked data stands */ }

250
251
252
253

  if (off) { log(`${stamp} ${slot}: OFF switch present (${OFF_FILE()}) — sent nothing`); return 0; }
  if (test) return sendTest(slot, x, payload, stamp, log);
  if (sent[sentKey]) { log(`${stamp} ${slot}: ${sentKey} already sent at ${sent[sentKey].at} — skipped (never twice)`); return 0; }
  if (!slotWindowOK(slot, now())) { log(`${stamp} ${slot}: outside its send window — skipped (a late timer must not send a wrong-day message)`); return 0; }

258
259
260

  // record BEFORE sending: a crash mid-send must never lead to a second copy
  sent[sentKey] = { at: new Date().toISOString(), feet: x.feet, overall: x.overall, results: 'sending' };
  saveJSON(SENT_FILE(), sent);

47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

  # Is a netlify deploy in this segment? Any leading path, any npx form, whole word only.
  printf '%s' "$SEG" | grep -qE '(^| )([^ ]*/)?netlify(-cli)?(@[^ ]*)? +deploy( |$)' || continue

  # Is it PRODUCTION? -p is netlify's own short flag for --prod, and --prod-if-unlocked
  # publishes too. Missing -p is how an earlier version of the WRAPPER called a production
  # deploy a draft and shipped it with no reason, no site check, no budget and no log row.
  printf '%s' "$SEG" | grep -qE '(^| )(--prod(uction)?|--prod-if-unlocked|--prodIfUnlocked|-p)( |=|$)' || continue

  # Allowed only if THIS SEGMENT invokes the wrapper before the netlify token.
  BEFORE="$(printf '%s' "$SEG" | sed -E 's/(^| )([^ ]*\/)?netlify(-cli)?(@[^ ]*)? +deploy.*/\1/')"
  printf '%s' "$BEFORE" | grep -q 'safe-deploy\.sh' && continue

  VERDICT=2
done
[ "$VERDICT" -eq 2 ] || exit 0

70
71
72
73

    n="$NAME"; i=2
    while have "$n"; do n="$NAME~$i"; i=$((i+1)); done
    # No -A. That flag is the whole bug this file exists to remove.
    exec tmux new-session -s "$n" -c "$DIR" bash -lic "$CMD"

157
158
159
160
161
162
163
164
165
166

# 3. PUSH only when actually ahead. Nothing to say otherwise — a log line every
#    10 minutes saying "nothing happened" is a log nobody reads.
if [ -n "$(git log origin/main..HEAD --oneline 2>/dev/null)" ]; then
  # plain push only. never -f, never --force-with-lease. A rejection is
  # information, not something to overpower.
  if git push --quiet origin main; then
    echo "$(date '+%F %T')  pushed $(git rev-parse --short HEAD)" >> "$LOG"
  else
    echo "$(date '+%F %T')  PUSH REJECTED — human needed" >> "$LOG"
  fi

41
42
43
44
45
46
47
48

# Guard the one mistake this design cannot otherwise catch: a caller passing a
# bare condition with no command would paste prose into the box and submit it as
# an ordinary prompt — the goal would never arm, and nothing would look wrong.
head -c 40 "$LINEFILE" | grep -q '^/' || {
  echo "refusing: $LINEFILE does not begin with a slash command." >&2
  echo "pass the full line from: queue-read.mjs <page> --index N" >&2
  exit 1
}

643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659

def cmd_send(d, text, wait_typing=1.5, now=False, v5=False):   # short: the core retries and tells him it is waiting
    text = text.strip()
    if not text:
        out({"ok": False, "why": "empty"}); return
    # Typing guard: never paste on top of anything. Wait (up to wait_typing s) for an empty box.
    # now=True (v4 "Send now"): he chose to send while the session works. The CLI takes typed input
    # while busy and holds it in its OWN queue, so the busy check is skipped (the typing guard stays).
    t0 = time.time()
    while True:
        s = state(d)
        if s["busy"] and not now:
            out({"ok": False, "why": "busy"}); return
        if not s["typing"] and not s["picker"]:
            break
        if time.time() - t0 > wait_typing:
            out({"ok": False, "why": "typing", "typed": s["typed"]}); return
        time.sleep(0.5)

55
56
57
58
59
60
61
62
63
64
65
66
67
68

if prefs.get("read", "full") == "full":
    HINT = FULL
HINT += ASK.get(prefs.get("ask", "risky"), ASK["risky"])
# Batch 2 (DRIVING MODE, owner): while it is on, he is at the wheel and listening by ear only.
# 29 Sep (owner): driving mode is a SCREEN setting only, used for driving AND for plain hands-free talk,
# so it no longer changes how the agent answers. Kept here, switched off, in case he wants it back.
if False and prefs.get("driving"):
    HINT += (" HE IS DRIVING right now and can only listen, not read. Keep every reply short and easy to follow by ear:"
             " the answer first, a few plain sentences, no lists or detail he would need to look at."
             " If there is more, say so in one sentence and offer it for later.")
# The mark is looked for near the start, not only AT the start: a long paste can arrive
# wrapped in the CLI's <pasted_content> tags.
if "🎙" in str(p.get("prompt", ""))[:300]:
    print(json.dumps({"hookSpecificOutput": {"hookEventName": "UserPromptSubmit", "additionalContext": HINT}}))

868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886

# Every line that is spoken (or sent to the phone to speak) is remembered for 3 minutes; a transcript whose word pairs are
# mostly (>= 60 %) word pairs of those lines is the reply coming back through the mic, and is NOT sent. Short phrases
# (under 4 words: "stop", "yes", "go ahead") are never judged, so commands always work. "that was me" still sends it.
ECHO_SECS, ECHO_LINE = 180, 0.6
_spoken = []                                   # [(time, line)]
def note_spoken(line):
    now = time.time()
    _spoken.append((now, str(line or "")))
    while _spoken and (now - _spoken[0][0] > ECHO_SECS or len(_spoken) > 80): _spoken.pop(0)
def _echo_words(t): return re.findall(r"[a-z0-9']+", str(t or "").lower())
def echo_score(text, spoken=None):
    """Share of the transcript's word pairs that were in a recently spoken reply (0..1), or None if too short to judge."""
    w = _echo_words(text)
    if len(w) < 4: return None
    now = time.time()
    said = [x for at, ln in (spoken if spoken is not None else _spoken) if now - at <= ECHO_SECS for x in _echo_words(ln) + ["\x00"]]
    if not said: return 0.0
    pairs, spk = list(zip(w, w[1:])), set(zip(said, said[1:]))
    return round(sum(1 for p in pairs if p in spk) / len(pairs), 3)

53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

    // the loop guard: true = this activation may go ahead (and is counted)
    func mayActivate(_ now: Date) -> Bool {
        activations = activations.filter { now.timeIntervalSince($0) < Self.activationWindow }
        if activations.count >= Self.maxActivations { refused += 1; return false }
        activations.append(now)
        return true
    }
    var recentActivations: Int { activations.count }

    func mediaReset(_ s: TalkSnap, now: Date) -> [TalkStep] {
        if now.timeIntervalSince(lastReset) < Self.resetWindow { resetsMerged += 1; return [.ignore("the same reset again (merged)")] }
        lastReset = now; resetsHandled += 1
        var steps: [TalkStep] = [.prepareCategory, .dropDeadEngine]
        guard s.on else { return steps + [.note("reset handled: Talk not running in the background")] }
        steps += [.activate("media services reset"), .startEngine("media services reset")]
        steps.append(s.busy ? .note("mic rebuilt, gated: a reply is still coming") : .listen)
        return steps
    }

44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

    // A TLS challenge from the box's address → accept only if the certificate is valid for the box's name.
    // Anything else (another host, another kind of challenge) → nil = iOS's normal handling.
    static func trust(_ challenge: URLAuthenticationChallenge) -> (URLSession.AuthChallengeDisposition, URLCredential?)? {
        let ps = challenge.protectionSpace
        guard ps.authenticationMethod == NSURLAuthenticationMethodServerTrust, ps.host == boxIP || ps.host == boxName, let t = ps.serverTrust else { return nil }
        SecTrustSetPolicies(t, SecPolicyCreateSSL(true, boxName as CFString))
        // NEXT-FIXES-17 item 8: the SAME certificate that passed the full check in the last hour is accepted at once — the full
        // check (SecTrustEvaluateWithError) can wait on the network (revocation), and it ran for every new connection.
        let leaf = (SecTrustCopyCertificateChain(t) as? [SecCertificate])?.first.map { SecCertificateCopyData($0) as Data }
        if let leaf, cache.withLock({ $0.leaf == leaf && Date() < $0.until }) { return (.useCredential, URLCredential(trust: t)) }
        var err: CFError?
        if SecTrustEvaluateWithError(t, &err) {
            if let leaf { cache.withLock { $0 = (leaf, Date().addingTimeInterval(3600)) } }
            if !trustOKLogged { trustOKLogged = true; report(["ev": "net-trust", "ok": true, "host": ps.host, "chain": SecTrustGetCertificateCount(t)]) }
            return (.useCredential, URLCredential(trust: t))
        }
        lastTrustFail = Date()
        report(["ev": "net-trust", "ok": false, "host": ps.host, "chain": SecTrustGetCertificateCount(t), "why": err.map { String(String(describing: $0).prefix(300)) } ?? "?"])
        return (.cancelAuthenticationChallenge, nil)
    }