@ashlr/hub 3.13.0 → 3.14.0

package/dist/core/vision/leader.js

@@ -19,12 +19,18 @@
  *
  *   SEAT: leader-seat.ts — grok first, then local; Claude only for the weekly
  *   deep run inside Mason's reserve; no seat ⇒ `no-seat`, never a cloud
- *   fallback.
+ *   fallback. 3.14: a run walks a CHAIN of router-approved seats (grok → fast
+ *   local → large local → opt-in Claude) with per-attempt timeouts, and the
+ *   memo records every attempt (leader-seat.ts planLeaderSeats,
+ *   leader-run-chain.ts).
  *
  *   CADENCE: daily at 06:30 local, plus runs triggered by 10 fleet merges, any
  *   revert, a seat window resetting, or a high-severity reasoning insight —
- *   skipped when the evidence digest is unchanged, and at most 3 model runs
- *   per local day.
+ *   skipped when the evidence digest is unchanged, and at most 3 full model
+ *   runs per local day. 3.14 (leader-cadence.ts): a failed full run retries
+ *   (bounded, backed off), and a cheap advisory check-in may run every
+ *   `foundry.leader.checkinHours` (default 2) in working hours when the
+ *   evidence changed materially — at most 8 model runs a day in total.
  *
  *   ACCOUNTABILITY: each move's expectedDelta is graded against the measured
  *   metric once 7 days have passed and its own deadline has come; the grades
@@ -41,8 +47,14 @@ import { ensurePrivateDirectory, readPrivateFileCapped, writePrivateFileAtomic }
 import { LEADER_ACTION_KINDS, LEADER_LIMITS, } from './leader-types.js';
 import { LEADER_MEMO_SCHEMA_TEXT, LEADER_METRICS, actionIdFor, cleanModelText, isLeaderMetric, leaderRoot, materializeHypotheses, newMemoId, parseLeaderMemoOutput, readRecentMemos, summarizeMemo, writeLeaderMemo, } from './leader-memo.js';
 import { applyDueLeaderActions, enactLeaderActions, isLeaderDryRun, listLeaderActions, loadDefaultLeaderDeps, readLeaderDirectives, readStandards, } from './leader-apply.js';
-import { loadDefaultLeaderSeatDeps, resolveLeaderSeat } from './leader-seat.js';
+import { loadDefaultLeaderSeatDeps, planLeaderSeats } from './leader-seat.js';
 import { suggestLeaderCloudBacklog } from './leader-cloud.js';
+import { readLeaderOperatorContext } from './leader-operator.js';
+import { buildLeaderGoalEvidence } from './leader-goal-evidence.js';
+import { LEADER_CHECKIN_SUFFIX, LEADER_MAX_RETRY_ATTEMPTS, LEGACY_LEADER_CADENCE, checkinWindowOpen, materialEvidenceDigest, resolveLeaderCadence, retryDelayMs, } from './leader-cadence.js';
+import { runLeaderSeatChain } from './leader-run-chain.js';
+import { buildLeaderHealth } from './leader-health.js';
+import { isOpenGoal } from '../goals/open-goals.js';
 // ---------------------------------------------------------------------------
 // Persona
 // ---------------------------------------------------------------------------
@@ -171,26 +183,11 @@ export async function gatherLeaderEvidence(sources, nowMs, state) {
         })),
     })).sort((a, b) => a.seatId.localeCompare(b.seatId)) : null;
     const goalRead = attempt('goals', () => sources.goals());
-    const goals = goalRead && goalRead.complete ? (() => {
-        const open = goalRead.goals.filter((g) => g.status === 'active' || g.status === 'planning');
-        const shown = [...open, ...goalRead.goals.filter((g) => g.status === 'paused')].slice(0, 40);
-        return {
-            open: open.length,
-            total: goalRead.goals.length,
-            focusLimit: LEADER_LIMITS.maxActiveGoals,
-            items: shown.map((g) => ({
-                id: g.id,
-                objective: cleanModelText(g.objective, 200) ?? '',
-                status: g.status,
-                repo: g.project ? g.project.split(/[\\/]/).pop() ?? null : null,
-                milestonesDone: g.milestones.filter((m) => m.status === 'done').length,
-                milestones: g.milestones.length,
-                updatedOn: day(g.updatedAt) ?? '',
-            })),
-        };
-    })() : null;
+    // An incomplete read is a LOWER BOUND with its caveat, never null: null read
+    // as "zero goals" to the model while 21 were open (leader-goal-evidence.ts).
+    const goals = goalRead ? buildLeaderGoalEvidence(goalRead) : null;
     if (goalRead && !goalRead.complete)
-        unknown.push('goals');
+        unknown.push('goals-partial');
     const facts = await ledgerFacts((o) => sources.readLedger(o), nowMs);
     if (!facts)
         unknown.push('ledger');
@@ -219,6 +216,8 @@ export async function gatherLeaderEvidence(sources, nowMs, state) {
     }
     const directives = readLeaderDirectives();
     const actions = listLeaderActions(200);
+    // 3.14 operator input (additive): unreadable is reported, never read as "no guidance".
+    const operator = attempt('operator', () => readLeaderOperatorContext(nowMs));
     return {
         grant,
         budget,
@@ -238,6 +237,7 @@ export async function gatherLeaderEvidence(sources, nowMs, state) {
         hitRate: computeHitRate(state.outcomes, nowMs),
         recentVetoes: actions.filter((a) => a.status === 'vetoed').slice(0, 5).map((a) => ({ summary: a.summary, note: a.vetoNote })),
         directives: directives ? { grokLanes: directives.grokLanes, codexEnabled: directives.codexEnabled, routerTuning: directives.routerTuning } : null,
+        ...(operator ? { operator } : {}),
         unknown: [...new Set(unknown)].sort(),
     };
 }
@@ -260,6 +260,22 @@ function untrustedBlock(label, value) {
         .replace(/\u2029/gu, '\\u2029');
     return `=== BEGIN UNTRUSTED DATA: ${label} ===\n${serialized}\n=== END UNTRUSTED DATA: ${label} ===`;
 }
+/**
+ * 3.14: Mason's standing directives and answers — the one TRUSTED block in
+ * the memo prompt. Serialized like the data blocks (JSON, line separators
+ * escaped) so its text cannot fake a delimiter. It steers judgement only:
+ * the grant and the policy check still bound every action.
+ */
+function operatorBlock(operator) {
+    const serialized = (JSON.stringify(operator.trusted) ?? 'null')
+        .replace(/\u0085/gu, '\\u0085')
+        .replace(/\u2028/gu, '\\u2028')
+        .replace(/\u2029/gu, '\\u2029');
+    return `=== OPERATOR DIRECTIVES FROM MASON (trusted: the owner's own words) ===
+${serialized}
+=== END OPERATOR DIRECTIVES ===
+Honor every directive above in the bottleneck, the move, the kill list and every action; when evidence conflicts with a directive, follow the directive and say why in notes. Answers are Mason's replies to your earlier questions (joined by questionId to the data block below); approvals are actions he endorsed. None of this widens the standing grant — the policy check still classifies every action.`;
+}
 export function buildLeaderPrompt(evidence, opts) {
     const blocks = [
         untrustedBlock('STANDING GRANT (null = none: every action is a dry run)', evidence.grant),
@@ -274,6 +290,10 @@ export function buildLeaderPrompt(evidence, opts) {
         untrustedBlock('YOUR STANDING DIRECTIVES', evidence.directives),
         untrustedBlock('UNKNOWN SECTIONS (sources that failed — not zero)', evidence.unknown),
     ];
+    if (evidence.operator) {
+        blocks.unshift(operatorBlock(evidence.operator));
+        blocks.push(untrustedBlock('YOUR EARLIER WORDING THAT MASON ANSWERED OR APPROVED', evidence.operator.untrusted));
+    }
     const openGoals = evidence.goals?.open ?? null;
     const focus = openGoals !== null && openGoals > LEADER_LIMITS.maxActiveGoals
         ? `\nFOCUS FIRST: ${openGoals} goals are open; at most ${LEADER_LIMITS.maxActiveGoals} may be. Pause or archive the rest (priorityChanges or goal.pause / goal.archive actions) before anything else.`
@@ -300,12 +320,20 @@ export function readLeaderRunState() {
         const parsed = JSON.parse(read.text);
         if (parsed.v !== 1)
             return emptyState();
+        const obj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
         return {
             ...emptyState(),
             ...parsed,
             runDays: typeof parsed.runDays === 'object' && parsed.runDays !== null ? parsed.runDays : {},
             baselines: typeof parsed.baselines === 'object' && parsed.baselines !== null ? parsed.baselines : {},
             outcomes: Array.isArray(parsed.outcomes) ? parsed.outcomes : [],
+            checkinDays: obj(parsed.checkinDays) ? parsed.checkinDays : {},
+            retry: obj(parsed.retry) && typeof parsed.retry.at === 'string' && Number.isInteger(parsed.retry.attempt) ? parsed.retry : null,
+            // Absent (a pre-3.14 file) stays undefined: health then reads the last run's outcome.
+            consecutiveFailures: Number.isInteger(parsed.consecutiveFailures) && parsed.consecutiveFailures >= 0 ? parsed.consecutiveFailures : undefined,
+            lastFailure: obj(parsed.lastFailure) ? parsed.lastFailure : null,
+            lastAttempts: Array.isArray(parsed.lastAttempts) ? parsed.lastAttempts.filter(obj).slice(0, 20) : [],
+            lastServed: obj(parsed.lastServed) ? parsed.lastServed : null,
         };
     }
     catch {
@@ -318,11 +346,22 @@ function writeLeaderRunState(state) {
     const runDays = {};
     for (const d of keepDays)
         runDays[d] = state.runDays[d];
+    const checkinDays = {};
+    for (const d of Object.keys(state.checkinDays ?? {}).sort().slice(-14))
+        checkinDays[d] = state.checkinDays[d];
     const memoIds = Object.keys(state.baselines).sort().slice(-300);
     const baselines = {};
     for (const id of memoIds)
         baselines[id] = state.baselines[id];
-    writePrivateFileAtomic(leaderStatePath(), `${JSON.stringify({ ...state, runDays, baselines, outcomes: state.outcomes.slice(-300) })}\n`);
+    writePrivateFileAtomic(leaderStatePath(), `${JSON.stringify({ ...state, runDays, checkinDays, baselines, outcomes: state.outcomes.slice(-300) })}\n`);
+}
+/** Check-in runs on the local day of `ms` (3.14). */
+export function checkinsOnDay(state, ms) {
+    return state.checkinDays?.[localDay(ms)] ?? 0;
+}
+/** Full (non-check-in) runs on the local day of `ms` — what the 3-a-day cap counts. */
+export function fullRunsOnDay(state, ms) {
+    return Math.max(0, runsOnDay(state, ms) - checkinsOnDay(state, ms));
 }
 /** Local calendar day (the cadence and the 3-runs-a-day cap are local). */
 export function localDay(ms) {
@@ -351,16 +390,30 @@ export function scheduleSlots(nowMs) {
     today = next;
     return { previous, next: today };
 }
-/** Pure: is a Leader run due now, and why. */
-export function leaderRunDue(nowMs, state, signals) {
+/**
+ * Pure: is a Leader run due now, and why. `cadence` (3.14) adds the bounded
+ * retry and the working-hours check-in; without it this is the 3.10 cadence
+ * (no check-ins, 3 runs a day) — retries still apply, inside that cap.
+ */
+export function leaderRunDue(nowMs, state, signals, cadence = LEGACY_LEADER_CADENCE) {
     const slots = scheduleSlots(nowMs);
     const nextRunAt = new Date(slots.next).toISOString();
-    if (runsOnDay(state, nowMs) >= LEADER_LIMITS.maxRunsPerDay) {
-        return { due: false, trigger: null, reason: `The Leader already ran ${LEADER_LIMITS.maxRunsPerDay} times today.`, nextRunAt };
+    const capped = `The Leader already ran ${cadence.maxRunsPerDay} times today.`;
+    if (runsOnDay(state, nowMs) >= cadence.maxRunsPerDayTotal) {
+        return { due: false, trigger: null, reason: `The Leader already ran ${cadence.maxRunsPerDayTotal} times today.`, nextRunAt };
+    }
+    if (fullRunsOnDay(state, nowMs) >= cadence.maxRunsPerDay) {
+        // Full runs are spent for today; only a check-in may still run.
+        if (checkinWindowOpen(nowMs, state, cadence))
+            return { due: true, trigger: 'checkin', reason: 'A working-hours check-in is due.', nextRunAt };
+        return { due: false, trigger: null, reason: capped, nextRunAt };
     }
     const lastMs = state.lastRun ? Date.parse(state.lastRun.at) : -Infinity;
     if (lastMs < slots.previous)
         return { due: true, trigger: 'schedule', reason: 'The daily 06:30 run is due.', nextRunAt };
+    if (state.retry && Date.parse(state.retry.at) <= nowMs) {
+        return { due: true, trigger: 'retry', reason: `Retry ${state.retry.attempt} of ${LEADER_MAX_RETRY_ATTEMPTS} after a failed run.`, nextRunAt };
+    }
     if (signals.revertsSinceLastRun !== null && signals.revertsSinceLastRun > 0) {
         return { due: true, trigger: 'revert', reason: 'A fleet merge was reverted.', nextRunAt };
     }
@@ -371,8 +424,31 @@ export function leaderRunDue(nowMs, state, signals) {
         return { due: true, trigger: 'seat-reset', reason: 'A seat window reset.', nextRunAt };
     if (signals.highInsightSinceLastRun)
         return { due: true, trigger: 'insight', reason: 'A high-severity reasoning insight appeared.', nextRunAt };
+    if (checkinWindowOpen(nowMs, state, cadence))
+        return { due: true, trigger: 'checkin', reason: 'A working-hours check-in is due.', nextRunAt };
     return { due: false, trigger: null, reason: 'Nothing new since the last memo.', nextRunAt };
 }
+/**
+ * PURE and cheap (state file only — no ledger, no evidence): could a tick run
+ * the Leader now for a TIME reason — the daily slot not yet run, a retry
+ * that came due, or an open check-in window? The comms poller (every 3 min,
+ * no daemon needed) uses it to decide whether to start `ashlr leader tick
+ * --wait` in the background; the tick then applies the real rules.
+ * Event triggers (merges, reverts, …) are left to the daily ticks.
+ */
+export function leaderWakeDue(nowMs, state, cadence) {
+    if (runsOnDay(state, nowMs) >= cadence.maxRunsPerDayTotal)
+        return { due: false, why: 'daily cap reached' };
+    const fullRoom = fullRunsOnDay(state, nowMs) < cadence.maxRunsPerDay;
+    const lastMs = state.lastRun ? Date.parse(state.lastRun.at) : -Infinity;
+    if (fullRoom && lastMs < scheduleSlots(nowMs).previous)
+        return { due: true, why: 'the daily run has not happened' };
+    if (fullRoom && state.retry && Date.parse(state.retry.at) <= nowMs)
+        return { due: true, why: `retry ${state.retry.attempt} is due` };
+    if (checkinWindowOpen(nowMs, state, cadence))
+        return { due: true, why: 'a check-in window is open' };
+    return { due: false, why: 'nothing is due' };
+}
 export async function gatherTriggerSignals(sources, state, nowMs) {
     const lastIso = state.lastRun?.at ?? new Date(nowMs - 86_400_000).toISOString();
     const lastMs = Date.parse(lastIso);
@@ -413,7 +489,8 @@ export async function measureLeaderMetric(metric, sources, nowMs) {
         switch (metric) {
             case 'active-goals': {
                 const read = sources.goals();
-                return read.complete ? read.goals.filter((g) => g.status === 'active' || g.status === 'planning').length : null;
+                // Grading needs the exact count: a lower bound is not a measurement.
+                return read.complete ? read.goals.filter(isOpenGoal).length : null;
             }
             case 'proposals-7d':
                 return sources.quality7d().proposalsCreated;
@@ -487,7 +564,7 @@ export async function loadDefaultLeaderRunDeps(cfg) {
             capacity: () => budgetStore.readCapacitySnapshot(),
             goals: () => {
                 const read = goalsStore.listGoalsDetailed();
-                return { goals: read.goals, complete: read.complete || read.sourceState === 'missing' };
+                return { goals: read.goals, complete: read.complete || read.sourceState === 'missing', unreadable: read.unreadableFiles };
             },
             readLedger: (opts) => ledger.readLedger(opts),
             holds: () => quarantine.listRepoHolds(),
@@ -569,13 +646,32 @@ async function runLeaderOnce(deps, trigger, opts) {
     const nowMs = deps.now();
     const nowIso = new Date(nowMs).toISOString();
     const state = readLeaderRunState();
-    if (runsOnDay(state, nowMs) >= LEADER_LIMITS.maxRunsPerDay) {
-        return { outcome: 'skipped-unchanged', reason: `The Leader already ran ${LEADER_LIMITS.maxRunsPerDay} times today.`, memo: null };
+    const cadence = resolveLeaderCadence(deps.cfg);
+    const mode = trigger === 'checkin' ? 'checkin' : 'full';
+    // Full runs keep the 3-a-day cap; check-ins have their own room under the total cap.
+    if (mode === 'full' && fullRunsOnDay(state, nowMs) >= cadence.maxRunsPerDay) {
+        return { outcome: 'skipped-unchanged', reason: `The Leader already ran ${cadence.maxRunsPerDay} times today.`, memo: null };
+    }
+    if (runsOnDay(state, nowMs) >= cadence.maxRunsPerDayTotal) {
+        return { outcome: 'skipped-unchanged', reason: `The Leader already ran ${cadence.maxRunsPerDayTotal} times today.`, memo: null };
     }
     const evidence = await gatherLeaderEvidence(deps.sources, nowMs, state);
     const digest = evidenceDigest(evidence);
+    const material = materialEvidenceDigest(evidence);
+    if (mode === 'checkin' && !opts.force && (state.lastMaterialDigest ?? null) === material) {
+        // Nothing material: no model call, and the next look is a recheck interval away.
+        state.lastRun = { at: nowIso, outcome: 'skipped-unchanged', reason: 'Check-in: nothing material changed since the last memo.', memoId: null, trigger };
+        state.lastCheckinEvalAt = nowIso;
+        writeLeaderRunState(state);
+        return { outcome: 'skipped-unchanged', reason: state.lastRun.reason, memo: null };
+    }
     if (!opts.force && state.lastEvidenceDigest === digest) {
         state.lastRun = { at: nowIso, outcome: 'skipped-unchanged', reason: 'The evidence has not changed since the last memo.', memoId: null, trigger };
+        if (mode === 'checkin')
+            state.lastCheckinEvalAt = nowIso;
+        // A retry whose evidence a later run already consumed has nothing left to do.
+        if (trigger === 'retry')
+            state.retry = null;
         writeLeaderRunState(state);
         return { outcome: 'skipped-unchanged', reason: state.lastRun.reason, memo: null };
     }
@@ -588,65 +684,120 @@ async function runLeaderOnce(deps, trigger, opts) {
         }
     })();
     const dryRun = isLeaderDryRun(policy);
-    const prompt = buildLeaderPrompt(evidence, { dryRun, nowIso });
-    const deep = trigger === 'schedule'
+    const basePrompt = buildLeaderPrompt(evidence, { dryRun, nowIso });
+    const prompt = mode === 'checkin' ? `${basePrompt}\n\n${LEADER_CHECKIN_SUFFIX}` : basePrompt;
+    // A retry of the 06:30 run is still that run (deep-eligible).
+    const scheduled = trigger === 'schedule' || (trigger === 'retry' && state.retry?.of === 'schedule');
+    const deep = scheduled
         && (state.lastDeepRunAt === null || nowMs - Date.parse(state.lastDeepRunAt) >= 7 * 86_400_000);
     const memoId = newMemoId(nowMs);
     const memo = emptyMemo(memoId, nowIso, trigger, digest, dryRun);
-    const seat = await resolveLeaderSeat(deps.seat, { deep, promptChars: LEADER_SYSTEM_PROMPT.length + prompt.length });
+    memo.mode = mode;
+    // Check-ins in reserve mode stay on free local models.
+    const budgetMode = (() => {
+        try {
+            return deps.sources.budgetPolicy().mode;
+        }
+        catch {
+            return null;
+        }
+    })();
+    const plan = await planLeaderSeats(deps.seat, {
+        deep,
+        promptChars: LEADER_SYSTEM_PROMPT.length + prompt.length,
+        mode,
+        localOnly: mode === 'checkin' && budgetMode === 'reserve',
+    });
+    let servedDeep = false;
+    let attempts = [];
     const finish = (outcome, reason, countsAsRun) => {
         memo.status = outcome;
         memo.statusReason = reason === null ? null : scrubPrivateText(reason).slice(0, 400);
+        memo.attempts = attempts.map((a) => ({ ...a, reason: a.reason === null ? null : scrubPrivateText(a.reason).slice(0, 300) }));
         writeLeaderMemo(memo);
         recordMemoOnLedger(deps, memo);
         const fresh = readLeaderRunState();
         fresh.lastRun = { at: nowIso, outcome, reason: memo.statusReason, memoId, trigger };
         fresh.lastMemoAt = nowIso;
+        const today = localDay(nowMs);
         if (countsAsRun)
-            fresh.runDays[localDay(nowMs)] = (fresh.runDays[localDay(nowMs)] ?? 0) + 1;
-        // A failed run does not consume the evidence: the next trigger may retry it.
-        if (outcome === 'ok')
+            fresh.runDays[today] = (fresh.runDays[today] ?? 0) + 1;
+        if (countsAsRun && mode === 'checkin')
+            fresh.checkinDays = { ...(fresh.checkinDays ?? {}), [today]: (fresh.checkinDays?.[today] ?? 0) + 1 };
+        fresh.lastAttempts = memo.attempts;
+        fresh.lastAttemptsAt = nowIso;
+        if (outcome === 'ok') {
+            // A failed run does not consume the evidence: the next trigger may retry it.
             fresh.lastEvidenceDigest = digest;
-        if (outcome === 'ok' && memo.seatId && seat.ok && seat.choice.deep)
-            fresh.lastDeepRunAt = nowIso;
+            fresh.lastMaterialDigest = material;
+            fresh.lastSuccessAt = nowIso;
+            fresh.consecutiveFailures = 0;
+            fresh.lastFailure = null;
+            fresh.retry = null;
+            fresh.lastServed = memo.seatId ? { seatId: memo.seatId, model: memo.model, at: nowIso } : null;
+            if (memo.seatId && servedDeep)
+                fresh.lastDeepRunAt = nowIso;
+        }
+        else {
+            fresh.consecutiveFailures = (fresh.consecutiveFailures ?? 0) + 1;
+            fresh.lastFailure = { at: nowIso, outcome, reason: memo.statusReason };
+            if (mode === 'full') {
+                // A bounded retry instead of waiting for tomorrow's slot. A check-in
+                // does not retry: the next check-in window is its retry.
+                const attempt = trigger === 'retry' ? (fresh.retry?.attempt ?? 0) + 1 : 1;
+                const delay = retryDelayMs(attempt);
+                fresh.retry = delay === null ? null : {
+                    attempt,
+                    at: new Date(nowMs + delay).toISOString(),
+                    of: trigger === 'retry' ? fresh.retry?.of ?? 'schedule' : trigger,
+                    reason: memo.statusReason,
+                };
+            }
+        }
         writeLeaderRunState(fresh);
         return { outcome, reason: memo.statusReason, memo };
     };
-    if (!seat.ok)
-        return finish('no-seat', seat.reason, false);
-    memo.seatId = seat.choice.seatId;
-    memo.model = seat.choice.model;
-    let raw;
-    try {
-        raw = await seat.complete(LEADER_SYSTEM_PROMPT, prompt);
-    }
-    catch (err) {
-        return finish('failed', `The ${seat.choice.engine} call failed: ${err instanceof Error ? err.message : 'error'}`, true);
+    if (!plan.ok) {
+        attempts = plan.skipped;
+        return finish('no-seat', plan.reason, false);
     }
-    let parsed = parseLeaderMemoOutput(raw, { nowMs });
-    // One retry, on FREE seats only — a paid retry would double the spend of a memo.
-    if (!parsed.ok && seat.choice.engine === 'local') {
-        try {
-            raw = await seat.complete(LEADER_SYSTEM_PROMPT, `${prompt}\n\nYour previous reply could not be parsed (${parsed.reason}). Reply with ONLY the JSON object.`);
-            parsed = parseLeaderMemoOutput(raw, { nowMs });
-        }
-        catch { /* keep the first failure */ }
-    }
-    if (!parsed.ok)
-        return finish('parse-failed', parsed.reason, true);
-    const draft = parsed.draft;
+    const chain = await runLeaderSeatChain(plan.steps, {
+        system: LEADER_SYSTEM_PROMPT,
+        user: prompt,
+        parse: (raw) => parseLeaderMemoOutput(raw, { nowMs }),
+        reask: (why) => `${prompt}\n\nYour previous reply could not be parsed (${why}). Reply with ONLY the JSON object.`,
+    }, () => deps.now());
+    attempts = [...chain.attempts, ...plan.skipped];
+    const step = chain.ok ? chain.step : chain.lastStep;
+    memo.seatId = step?.choice.seatId ?? null;
+    memo.model = step?.choice.model ?? null;
+    if (!chain.ok)
+        return finish(chain.outcome, chain.reason, true);
+    servedDeep = chain.step.choice.deep;
+    const draft = chain.draft;
     memo.bottleneck = draft.bottleneck;
     memo.move = draft.move;
     memo.killList = draft.killList;
+    memo.questionsForMason = draft.questionsForMason;
+    memo.status = 'ok';
+    memo.statusReason = draft.notes.length > 0 ? draft.notes.join('; ').slice(0, 400) : null;
+    if (mode === 'checkin') {
+        // ADVISORY: a check-in's goals, hypotheses, standards and actions are
+        // never enacted (a cheap model every two hours does not act; the daily
+        // memo does). Its move is not graded either (gradeLeaderOutcomes).
+        const dropped = draft.actions.length + draft.goals.length + draft.hypotheses.length + draft.standards.length;
+        if (dropped > 0) {
+            memo.statusReason = [memo.statusReason, `Check-in: ${dropped} proposal(s) not enacted (check-ins are advisory).`]
+                .filter((n) => typeof n === 'string' && n.length > 0).join('; ').slice(0, 400);
+        }
+        return finish('ok', memo.statusReason, true);
+    }
     memo.goals = draft.goals;
     memo.priorityChanges = draft.priorityChanges;
     memo.standards = draft.standards;
     memo.critiques = draft.critiques;
     memo.seatPlan = draft.seatPlan;
-    memo.questionsForMason = draft.questionsForMason;
     memo.hypotheses = materializeHypotheses(memoId, draft.hypotheses, nowIso);
-    memo.status = 'ok';
-    memo.statusReason = draft.notes.length > 0 ? draft.notes.join('; ').slice(0, 400) : null;
     // Written BEFORE the actions run: experiment.start reads its hypothesis from this file.
     writeLeaderMemo(memo);
     // Register the memo's hypotheses with U9's harness registry as OPEN (Growth
@@ -722,10 +873,16 @@ export async function runLeader(deps, trigger, opts = {}) {
         return { outcome: 'skipped-unchanged', reason: 'A Leader run is already in progress.', memo: null };
     const job = (async () => {
         ensurePrivateDirectory(leaderRoot());
+        // Cross-process single flight: the lock is reclaimed only from a dead
+        // owner (pid + start identity), never on a timer, so a slow local memo
+        // keeps it for as long as it runs.
         const lock = acquireLocalStoreLock(join(leaderRoot(), '.run.lock'), 0);
         if (!lock)
             return { outcome: 'skipped-unchanged', reason: 'Another process is running the Leader.', memo: null };
         try {
+            if (opts.expectLastRunAt !== undefined && (readLeaderRunState().lastRun?.at ?? null) !== opts.expectLastRunAt) {
+                return { outcome: 'skipped-unchanged', reason: 'Another process ran the Leader since this run was scheduled.', memo: null };
+            }
             return await runLeaderOnce(deps, trigger, { force: opts.force === true });
         }
         finally {
@@ -747,7 +904,8 @@ export async function gradeLeaderOutcomes(deps) {
     const graded = new Set(state.outcomes.map((o) => o.memoId));
     const fresh = [];
     for (const memo of readRecentMemos(60)) {
-        if (memo.status !== 'ok' || graded.has(memo.id))
+        // Check-ins are advisory (3.14): their moves are not graded into the hit-rate.
+        if (memo.status !== 'ok' || memo.mode === 'checkin' || graded.has(memo.id))
             continue;
         const due = gradeDueAt(memo);
         const expected = memo.move?.expectedDelta;
@@ -797,11 +955,15 @@ export async function leaderTick(deps, opts = {}) {
     }
     catch { /* retried next tick */ }
     const state = readLeaderRunState();
+    const cadence = resolveLeaderCadence(deps.cfg);
+    rememberCadence(state, cadence);
     const signals = await gatherTriggerSignals(deps.sources, state, nowMs);
-    const due = leaderRunDue(nowMs, state, signals);
+    const due = leaderRunDue(nowMs, state, signals, cadence);
     if (!due.due || !due.trigger || runInFlight)
         return { applied, graded, due, started: false, run: null };
-    const job = runLeader(deps, due.trigger);
+    // The CAS token: if the daemon's tick and the comms poller's tick both saw
+    // this run as due, only the first to take the lock runs it.
+    const job = runLeader(deps, due.trigger, { expectLastRunAt: state.lastRun?.at ?? null });
     if (opts.awaitRun)
         return { applied, graded, due, started: true, run: await job };
     void job.catch(() => undefined);
@@ -810,12 +972,49 @@ export async function leaderTick(deps, opts = {}) {
 // ---------------------------------------------------------------------------
 // State for the API / UI
 // ---------------------------------------------------------------------------
-export function buildLeaderState(nowMs) {
+/**
+ * The cadence the last tick ran under, kept in the state file so the read
+ * path (GET /api/verse/leader, which has no config in hand) reports the same
+ * check-in interval the runs use. Written only when it changed.
+ */
+function rememberCadence(state, cadence) {
+    const stored = state.cadence;
+    if (stored && stored.checkinHours === cadence.checkinHours
+        && stored.workingHours.start === cadence.workingHours.start && stored.workingHours.end === cadence.workingHours.end)
+        return;
+    try {
+        const fresh = readLeaderRunState();
+        fresh.cadence = { checkinHours: cadence.checkinHours, workingHours: { ...cadence.workingHours } };
+        writeLeaderRunState(fresh);
+    }
+    catch { /* the health read falls back to the defaults */ }
+}
+function cadenceFor(state, cfg) {
+    if (cfg)
+        return resolveLeaderCadence(cfg);
+    const stored = state.cadence;
+    if (!stored)
+        return resolveLeaderCadence(undefined);
+    return resolveLeaderCadence({ foundry: { leader: { checkinHours: stored.checkinHours, workingHours: stored.workingHours } } });
+}
+export function buildLeaderState(nowMs, cfg) {
     const state = readLeaderRunState();
     const memos = readRecentMemos(30);
     const outcomeByMemo = new Map(state.outcomes.map((o) => [o.memoId, o]));
     const timeline = memos.map((m) => summarizeMemo(m, outcomeByMemo.get(m.id) ?? null));
     const latest = memos.find((m) => m.status === 'ok') ?? memos[0] ?? null;
+    const lastOk = memos.find((m) => m.status === 'ok') ?? null;
+    const health = buildLeaderHealth({
+        ...state,
+        // Pre-3.14 state files: the newest ok memo is the last success.
+        lastSuccessAt: state.lastSuccessAt ?? lastOk?.at ?? null,
+        lastServed: state.lastServed ?? (lastOk?.seatId ? { seatId: lastOk.seatId, model: lastOk.model, at: lastOk.at } : null),
+    }, nowMs, {
+        cadence: cadenceFor(state, cfg),
+        nextScheduledAt: scheduleSlots(nowMs).next,
+        runsToday: runsOnDay(state, nowMs),
+        checkinsToday: checkinsOnDay(state, nowMs),
+    });
     return {
         v: 1,
         generatedAt: new Date(nowMs).toISOString(),
@@ -828,6 +1027,7 @@ export function buildLeaderState(nowMs) {
         hitRate: computeHitRate(state.outcomes, nowMs),
         standards: readStandards(),
         directives: readLeaderDirectives(),
+        health,
     };
 }
 //# sourceMappingURL=leader.js.map