ruvnet-brain 4.7.20 → 4.7.22

package/plugin/scripts/session-start-core.mjs

@@ -36,6 +36,7 @@ import { surfaceSignals } from './session-start-signals.mjs';
 import { failureLine, FAILURE_LINE_PREFIX } from './hook-failures.mjs';
 import { brainState, health, knowledgeCurrency, mcpReadiness, KNOWLEDGE_LINE_PREFIX } from './session-start-health.mjs';
 import { stableSpine, heartbeat, knowledgeAutoUpdate, footprintCheck } from './session-start-update-plane.mjs';
+import { CODEX_OVERNIGHT_PREFIX } from './codex-overnight-notice.mjs';
 import { FOOTPRINT_LINE_PREFIX } from './brain-confirmation.mjs';
 import { describeLifecycleHooks, readHookContracts } from './session-start-hook-description.mjs';
 import { createStageTracer } from './session-start-trace.mjs';
@@ -43,6 +44,7 @@ import { sessionStartDeadlineAt, STAGE_BUDGETS_MS } from './session-start-budget
 import { loadSettings } from './user-settings.mjs';
 import { sessionStartProofRecorder } from './session-start-proof.mjs';
 import { ALIAS_NOTICE, probeCodexConsoleAlias, readSessionSource } from './codex-console-alias.mjs';
+import { isDirectInvocation } from './entrypoint.mjs';
 
 // Re-exported for callers/tests that import the entitlement check directly from this file's own
 // long-standing public surface (tests/unit/session-start-core-parity.test.mjs).
@@ -116,7 +118,9 @@ export async function runSessionStart({
       || s.startsWith(FOOTPRINT_LINE_PREFIX)
       || s.startsWith('[RuvNet Brain — OPEN ISSUES')
       || s.startsWith('[RuvNet Brain — NTFY:')
+      || s.startsWith('[RuvNet Brain — JOBS:')
       || s.startsWith('[RuvNet Brain — TURN CAPTURE]')
+      || s.startsWith(CODEX_OVERNIGHT_PREFIX)
       || /\bopen issue\(s\)/i.test(s)
       || /^\[RuvNet Brain — external signal/i.test(s)
       || (s.startsWith('Workflow ') && !/\b(Say it plainly|offer to look|ask only|run:|invoke)\b/i.test(s))
@@ -210,7 +214,8 @@ export async function runSessionStart({
     const continuity = await Promise.race([Promise.resolve().then(() => restoreContinuity({ env, cwd,
       deadlineAt: restoreDeadlineAt, signal: restoreController.signal })), expired]);
     if (Date.now() >= restoreDeadlineAt) throw new Error('restore deadline exceeded');
-    restoreFailed = continuity?.status === 'unknown' || continuity?.brief?.status === 'unknown';
+    const bad = ['unknown', 'partial', 'refused'];
+    restoreFailed = bad.includes(continuity?.status) || bad.includes(continuity?.brief?.status);
     if (continuity?.context) emit(continuity.context);
   } catch (error) {
     restoreController.abort();
@@ -452,21 +457,7 @@ export async function runSessionStart({
   return { ok: true, outputBytes: Buffer.byteLength(output, 'utf8'), platform };
 }
 
-// Entry-point guard. Compares REALPATHS on both sides: path.resolve() normalizes a path but does
-// NOT follow symlinks, while import.meta.url IS symlink-resolved by Node. Through a symlink (npm bin
-// shims, wrapper scripts, and every os.tmpdir() path on macOS) the two sides disagree, so main()
-// never runs -- and because nothing throws, the process exits 0. A silent exit 0 is indistinguishable
-// from "ran, found nothing". Reproduced live 2026-07-27; pinned by tests/unit/entrypoint-symlink.test.mjs.
-function isDirectInvocation() {
-  try {
-    if (!process.argv[1]) return false;
-    return fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(import.meta.url));
-  } catch {
-    return false;
-  }
-}
-
-const direct = isDirectInvocation();
+const direct = isDirectInvocation(import.meta.url);
 if (direct) {
   const sessionSource = await readSessionSource();
   runSessionStart({ sessionSource, startedAt: performance.timeOrigin }).catch((error) => {

package/plugin/scripts/session-start-health.mjs

@@ -14,7 +14,7 @@ import { json, exists, mtimeMs, read } from './session-start-fsutil.mjs';
 import { unmountedNotice } from './brain-location.mjs';
 import { assessMoveLeftovers } from './footprint-io.mjs';
 import {
-  describeFailedRefreshRun, readNightlyRegistration, refreshHistory, updateOwnedByAgenticKit,
+  describeFailedRefreshRun, developerRunHealth, readNightlyRegistration, refreshHistory, updateOwnedByAgenticKit,
 } from './nightly-scheduler.mjs';
 
 export const brainState = (env, home) => {
@@ -93,7 +93,7 @@ export const autoUpdatePaths = (brainHome) => ({
   checkFile: path.join(brainHome, 'corpus-check.json'),
   checkResultFile: path.join(brainHome, '.last-kb-check-result.json'),
 });
-export const AUTO_UPDATE_LOCK_STALE_MS = 35 * 60_000; // detach TTL (30 min) + slack
+export const AUTO_UPDATE_LOCK_STALE_MS = 160 * 60_000; // detach TTL (session-start-update-plane ttlSec, 155 min) + slack
 
 /** The inputs every currency decision reads — one reader, shared by the line and the auto-update. */
 export const knowledgeFacts = ({ env = process.env, home, now = Date.now() } = {}) => {
@@ -108,7 +108,9 @@ export const knowledgeFacts = ({ env = process.env, home, now = Date.now() } = {
   const auto = autoUpdatePaths(brainHome);
   const provenWithin = (h) => Boolean((history.lastSuccess && hours(history.lastSuccess.at) <= h)
     || (check?.currencyVerdict === 'CURRENT' && Number.isFinite(checkMs) && hours(checkMs) <= h));
-  return { brainHome, kbDir, source, builtMs, history, hours, provenWithin, auto,
+  // brain-confirmation.mjs SIGNATURE_RECORD (not imported: that module imports this one).
+  const installedAtMs = Date.parse(json(path.join(brainHome, 'knowledge-signature.json'))?.verifiedAt || '');
+  return { brainHome, kbDir, source, builtMs, history, hours, provenWithin, auto, installedAtMs,
     attempt: json(auto.attemptFile), corpusCheck: json(auto.checkFile),
     lockMs: Date.parse(json(auto.lockFile)?.at || '') || mtimeMs(auto.lockFile) };
 };
@@ -146,15 +148,87 @@ export const autoUpdateOptOut = ({ env = process.env, home, facts }) => {
  * installed tree carries no generation stamp) and that tag is not what SOURCE.json now names. A check
  * recorded before the update landed therefore stops reading as pending the moment B is installed.
  */
+const SEMVER_TAG = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/;
+/** Semver order of two release tags (>0 a newer, <0 older, 0 same); null when either is not semver. */
+export const compareReleaseTags = (a, b) => {
+  const A = SEMVER_TAG.exec(String(a ?? '')), B = SEMVER_TAG.exec(String(b ?? ''));
+  if (!A || !B) return null;
+  for (let i = 1; i <= 3; i++) if (Number(A[i]) !== Number(B[i])) return Number(A[i]) > Number(B[i]) ? 1 : -1;
+  if ((A[4] || '') === (B[4] || '')) return 0;
+  if (!A[4]) return 1;
+  if (!B[4]) return -1;
+  // Semver §11.4: dot-separated identifiers left to right; numeric ones numerically (alpha.10 > alpha.9),
+  // numeric below alphanumeric, alphanumeric in ASCII order; a longer set wins when all before it are equal.
+  const X = A[4].split('.'), Y = B[4].split('.');
+  for (let i = 0; i < Math.max(X.length, Y.length); i++) {
+    if (X[i] === undefined) return -1;
+    if (Y[i] === undefined) return 1;
+    const xn = /^\d+$/.test(X[i]), yn = /^\d+$/.test(Y[i]);
+    if (xn && yn) { if (Number(X[i]) !== Number(Y[i])) return Number(X[i]) > Number(Y[i]) ? 1 : -1; continue; }
+    if (xn !== yn) return xn ? -1 : 1;
+    if (X[i] !== Y[i]) return X[i] > Y[i] ? 1 : -1;
+  }
+  return 0;
+};
+
 export const newerCorpusPending = (facts) => {
   const c = facts.corpusCheck;
   if (!c?.candidateTag || !['UPDATE_AVAILABLE', 'UNKNOWN'].includes(c.verdict)) return null;
   const installed = [facts.source?.corpusReleaseTag, facts.source?.releaseTag].filter(Boolean);
   if (installed.includes(c.candidateTag)) return null;
+  // #401: a different tag is not a newer one. When both are semver release tags, order decides: a
+  // retained check naming v4.5.7 must never call an installed v4.5.9 out of date, and a v4.5.10
+  // candidate still reads as pending however recently something was installed.
+  const order = compareReleaseTags(c.candidateTag, facts.source?.releaseTag);
+  if (order !== null) { if (order <= 0) return null; }
+  else {
+    // Opaque (non-orderable) identities: a check recorded before the installed bytes were
+    // signature-verified is stale evidence the install superseded, not proof of a newer corpus.
+    const checkedMs = Date.parse(c.checkedAt || c.launchedAt || '');
+    if (Number.isFinite(facts.installedAtMs) && Number.isFinite(checkedMs) && checkedMs < facts.installedAtMs) return null;
+  }
   return { tag: c.candidateTag, installed: installed[0] || null, checkedAt: c.checkedAt || c.launchedAt || null, outcome: c.outcome };
 };
 const shortTag = (tag) => (tag && tag.length > 28 ? `${tag.slice(0, 26)}…` : tag || 'unknown');
 
+/**
+ * Issue #391 / closure gap G-015: a FAILED run whose `update` phase PASSED left the knowledge current
+ * (the ledger stops at the first required failure, so every corpus phase before it passed too). When
+ * host-convergence is the ONLY failed phase, the host plugin sync is what did not finish: a host
+ * problem, not a knowledge failure, and it is reported as one. Any other failed phase (cleanup-pending,
+ * retention recovery-required) keeps its own reason through describeFailedRefreshRun.
+ * Returns { state, why } from the host-convergence evidence, or null for any other receipt.
+ */
+export const hostSyncOnlyFailure = (receipt) => {
+  if (receipt?.status !== 'FAILED' || !Array.isArray(receipt.phases)) return null;
+  if (!receipt.phases.some((entry) => entry?.phase === 'update' && entry.status === 'PASS')) return null;
+  const failed = receipt.phases.filter((entry) => entry?.status === 'FAIL');
+  if (failed.length !== 1 || failed[0].phase !== 'host-convergence') return null;
+  const host = failed[0];
+  const state = host?.evidence?.state || null;
+  const why = String(host?.evidence?.error || state || '').split('\n')[0].trim().slice(0, 200);
+  return { state, why: why || 'no reason recorded (run npx ruvnet-brain --doctor)' };
+};
+
+/**
+ * A coordinated (developer-suite) nightly reports in nightly-suite-update.json, never in refresh-runs, so a failing or stale
+ * suite stayed silent while the knowledge was current (AuditC #26). One line then; '' when it is healthy, never ran, or absent.
+ */
+const coordinatedSuiteLine = ({ brainHome, now, builtMs, age }) => {
+  let health;
+  try {
+    const registration = readNightlyRegistration({ brainHome });
+    if (!registration.ok || registration.record.mode !== 'developer-suite') return '';
+    health = developerRunHealth({ brainHome, registration: registration.record, now });
+  } catch { return ''; }
+  if (!['failed', 'stale'].includes(health.state)) return '';
+  const what = health.state === 'stale' ? `has not completed in ${Math.round(health.ageHours)}h`
+    : `FAILED${Number.isFinite(health.ageHours) ? ` ${age(now - health.ageHours * 3_600_000)}` : ''}: ${String(health.evidence || 'no reason recorded').split('\n')[0].slice(0, 200)}`;
+  return `${KNOWLEDGE_LINE_PREFIX}CURRENT, NIGHTLY SUITE ${health.state === 'stale' ? 'STALE' : 'FAILING'}] knowledge base built `
+    + `${Number.isFinite(builtMs) ? age(builtMs) : 'at an UNKNOWN time'} and current; the coordinated nightly update ${what}. `
+    + `Details: ${path.join(brainHome, 'scheduler', 'last-suite-attempt.json')} (verify: npx ruvnet-brain --doctor).`;
+};
+
 export const knowledgeCurrency = ({ env = process.env, home, now = Date.now(), windowHours = 48 } = {}) => {
   const facts = knowledgeFacts({ env, home, now });
   const { brainHome, builtMs, history, hours, attempt } = facts;
@@ -169,7 +243,8 @@ export const knowledgeCurrency = ({ env = process.env, home, now = Date.now(), w
   const autoAbandoned = attempt?.outcome === 'launched' && !autoRunning;
   const autoFailed = Number.isFinite(launchedMs) && (attempt.outcome === 'failed' || autoAbandoned)
     && !(history.latest && history.latest.at >= launchedMs);
-  const failing = latest?.status === 'FAILED' || autoFailed;
+  const hostOnly = hostSyncOnlyFailure(latest);
+  const failing = (latest?.status === 'FAILED' && !hostOnly) || autoFailed;
   const ageKnown = Number.isFinite(builtMs);
   const pending = newerCorpusPending(facts);
   if (!failing && pending && (proven || (ageKnown && hours(builtMs) <= windowHours))) {
@@ -181,8 +256,19 @@ export const knowledgeCurrency = ({ env = process.env, home, now = Date.now(), w
     return `${KNOWLEDGE_LINE_PREFIX}UPDATE PENDING] a newer corpus ${shortTag(pending.tag)} is published `
       + `(this machine has ${shortTag(pending.installed)}, built ${ageKnown ? age(builtMs) : 'at an UNKNOWN time'}); ${what}.`;
   }
-  if (!failing && proven) return '';
-  if (!failing && ageKnown && hours(builtMs) <= windowHours) return '';
+  const fresh = proven || (ageKnown && hours(builtMs) <= windowHours);
+  if (!failing && hostOnly && fresh) {
+    const restart = hostOnly.state === 'host-restart-required';
+    return `${KNOWLEDGE_LINE_PREFIX}CURRENT, HOST ${restart ? 'RESTART' : 'SYNC'} PENDING] `
+      + `knowledge base built ${ageKnown ? `${day(builtMs)} (${age(builtMs)})` : 'at an UNKNOWN time'}; `
+      + `the last refresh (${latest.action || 'unknown'}) ${age(history.latest.at)} passed its knowledge update phase, `
+      + `only the host plugin sync after it did not finish: ${hostOnly.why}. `
+      // A restart writes no refresh receipt, so this line stays until the next refresh records the sync.
+      // The host sync alone is what did not finish, so the fix is the host-sync-only repair, not the full knowledge update (#391).
+      + (restart ? 'Fix: restart Claude Code or Codex (`claude --continue` keeps a Claude conversation), then record it: npx ruvnet-brain@latest --update --host-sync-only.'
+        : 'Fix: npx ruvnet-brain@latest --update --host-sync-only (verify: npx ruvnet-brain --doctor).');
+  }
+  if (!failing && fresh) return coordinatedSuiteLine({ brainHome, now, builtMs, age });
   const kit = agenticKitUpdates({ home, facts });
   const agentKit = kit === 'delivering';
   // An agentic-kit machine must never be told to also --enable-nightly (one owner per machine).
@@ -190,17 +276,19 @@ export const knowledgeCurrency = ({ env = process.env, home, now = Date.now(), w
   const parts = [ageKnown ? `knowledge base built ${day(builtMs)} (${age(builtMs)})`
     : 'knowledge base age UNKNOWN (SOURCE.json missing or unreadable)'];
   if (autoFailed) {
-    const why = autoAbandoned ? 'it never recorded an outcome (killed at its 30-minute limit, or the machine slept)'
+    const why = autoAbandoned ? 'it never recorded an outcome (killed at its time limit, or the machine slept)'
       : `exit ${attempt.code ?? 'unknown'}: ${attempt.reason || 'no reason recorded'}`;
     parts.push(`automatic update launched ${age(launchedMs)} FAILED — ${why}`);
+  } else if (hostOnly) {
+    parts.push(`last refresh (${latest.action || 'unknown'}) passed its knowledge update phase ${age(history.latest.at)} but its host sync did not finish: ${hostOnly.why}`);
   } else if (latest?.status === 'FAILED') {
     const why = describeFailedRefreshRun(latest) || 'failed';
     parts.push(`last refresh (${latest.action || 'unknown'}) FAILED ${age(history.latest.at)}: ${why}`);
   }
   if (autoRunning) parts.push(`an automatic update is running now (started ${age(facts.lockMs)})`);
-  parts.push(history.receipts
-    ? `${history.failuresSinceSuccess} failed run(s) since the last success (${history.lastSuccess ? day(history.lastSuccess.at) : 'none recorded'})`
-    : 'no refresh has ever run on this machine');
+  parts.push(!history.receipts ? 'no refresh has ever run on this machine'
+    : history.lastSuccess ? `${history.failuresSinceSuccess} failed run(s) since the last success (${day(history.lastSuccess.at)})`
+      : `${history.failuresSinceSuccess} failed run(s) and no successful run on record`);
   if (kit === 'not-delivering') {
     parts.push(`agentic-kit claims updates (kit.json ruvnetBrain:true) but no update is proven in ${AGENTIC_KIT_PROOF_HOURS}h, so the Brain's own self-heal runs instead`);
   }

package/plugin/scripts/session-start-issue-alert.mjs

@@ -84,6 +84,7 @@ export function surfaceIssuePointer({ stateDir, emit, now, env, home, platform,
 export function surfaceNtfyAlerts({ stateDir, emit, env, home, platform, cwd, now = Date.now() }) {
   try {
     if (!maintainerIssueEntitlement(env, home, 'stuinfla/ruvnet-brain', platform) || !isMaintainerRepo(cwd)) return;
+    surfaceJobHealth({ stateDir, emit, now, cwd });
     // The reader writes a few-byte summary (scripts/ntfy-inbox.mjs writeSummary) so a large alert list can never
     // push this banner past its read limit; the detailed list is only a fallback for an older reader.
     let total = 0; let kinds = {};
@@ -117,3 +118,65 @@ export function surfaceNtfyAlerts({ stateDir, emit, env, home, platform, cwd, no
     emit(`[RuvNet Brain — NTFY: ${total} open alert(s) (${summaryText || 'none listed'})${over}${age}. Details: node scripts/ntfy-inbox.mjs --open]`);
   } catch { /* advisory only */ }
 }
+
+const WATCHDOG_LABEL = 'com.ruvnet.nightly-watchdog';
+const WATCHDOG_MAX_AGE_H = 30;
+const MAX_RECEIPTS = 64;
+const MAX_RECEIPT_BYTES = 64 * 1024;
+
+/** The job labels config/scheduled-jobs.json registers, found by walking up from the session's project directory (the
+ *  maintainer gate already requires this checkout to be the repo), or null when there is no readable registry. */
+export function registeredJobLabels(cwd) {
+  if (!cwd) return null;
+  let dir = path.resolve(cwd);
+  for (let depth = 0; depth < 8; depth++) {
+    const file = path.join(dir, 'config', 'scheduled-jobs.json');
+    try {
+      if (fs.statSync(file).size <= MAX_STATUS_BYTES) {
+        const jobs = json(file)?.jobs;
+        if (Array.isArray(jobs)) return new Set(jobs.map((j) => j?.label).filter((l) => typeof l === 'string'));
+      }
+    } catch { /* not here: look one level up */ }
+    const up = path.dirname(dir);
+    if (up === dir) break;
+    dir = up;
+  }
+  return null;
+}
+
+/**
+ * WHO WATCHES THE WATCHDOG (4.7.21). nightly-watchdog.mjs cannot judge its own run, and a watchdog that stopped
+ * firing would be silent by construction. This reads the local heartbeat receipts (scripts/job-heartbeat.sh) —
+ * no network, bounded file count and size — and says ONE line when any receipt is failed/killed or the
+ * watchdog's own receipt is older than 30 h. Machines without heartbeats (every end user) get nothing.
+ * Only receipts of jobs the registry still lists count (review fix): a retired job's last failed receipt left in the
+ * heartbeat directory must not read as "failing" forever. Without a readable registry every receipt counts.
+ */
+export function surfaceJobHealth({ stateDir, emit, now = Date.now(), cwd }) {
+  try {
+    const dir = path.join(stateDir, 'heartbeats');
+    let names;
+    try { names = fs.readdirSync(dir).filter((n) => n.endsWith('.json')).slice(0, MAX_RECEIPTS); } catch { return; }
+    if (!names.length) return;
+    const registered = registeredJobLabels(cwd);
+    const red = [];
+    let watchdogAt = null;
+    for (const name of names) {
+      const file = path.join(dir, name);
+      try { if (fs.statSync(file).size > MAX_RECEIPT_BYTES) continue; } catch { continue; }
+      const r = json(file);
+      if (!r || typeof r !== 'object') continue;
+      const label = name.slice(0, -'.json'.length);
+      if (registered && !registered.has(label)) continue;
+      if (r.state === 'failed' || r.state === 'killed') red.push(label);
+      if (label === WATCHDOG_LABEL) watchdogAt = Date.parse(r.ended_at || r.started_at || '');
+    }
+    const parts = [];
+    if (red.length) parts.push(`${red.length} scheduled job(s) failing (${red.slice(0, 3).join(', ')}${red.length > 3 ? ', …' : ''})`);
+    if (watchdogAt !== null) {
+      const ageH = Number.isFinite(watchdogAt) ? (now - watchdogAt) / 3_600_000 : Infinity;
+      if (ageH > WATCHDOG_MAX_AGE_H) parts.push(`the nightly watchdog last ran ${Number.isFinite(ageH) ? `${Math.floor(ageH)}h ago` : 'at an unreadable time'}`);
+    }
+    if (parts.length) emit(`[RuvNet Brain — JOBS: ${parts.join('; ')}. Details: node scripts/nightly-watchdog.mjs --no-push]`);
+  } catch { /* advisory only */ }
+}

package/plugin/scripts/session-start-update-plane.mjs

@@ -11,6 +11,8 @@ import { read, write, exists, json, firstVersion, dispatchDetached, mtimeMs } fr
 import { KNOWLEDGE_LINE_PREFIX, AUTO_UPDATE_LOCK_STALE_MS, autoUpdateOptOut, knowledgeFacts } from './session-start-health.mjs';
 import { inventoryFootprint } from './brain-footprint.mjs';
 import { confirm, footprintAlarm } from './brain-confirmation.mjs';
+import { claimCodexOvernightNotice } from './codex-overnight-notice.mjs';
+import { developerCoordinatorOwner } from './developer-update-owner.mjs';
 
 /**
  * KNOWLEDGE SELF-HEAL (owner invariant 2026-09-30: no brain may ever be more than 48h old) AND
@@ -31,7 +33,9 @@ import { confirm, footprintAlarm } from './brain-confirmation.mjs';
  * (plugin/mcp/server.mjs, announce:false so it never consumes the once-per-session line). The outcome is
  * recorded by the worker and spoken by the NEXT session's knowledge line.
  */
-export const AUTO_UPDATE_POLICY = Object.freeze({ staleHours: 24, retryHours: 6, offlineRetryMinutes: 30, ttlSec: 1800, checkMinutes: 60 });
+// ttlSec sits above host-update.mjs's knowledge limit (150 min), which sits above the coordinator's installer limit
+// (135 min = the 90-minute bundle download deadline plus the apply): each kill lands on a level that records an outcome.
+export const AUTO_UPDATE_POLICY = Object.freeze({ staleHours: 24, retryHours: 6, offlineRetryMinutes: 30, ttlSec: 9300, checkMinutes: 60 });
 export const corpusCheckMinutes = (env = {}) => {
   const raw = env.RUVNET_CORPUS_CHECK_MINUTES;
   const n = Number(raw);
@@ -159,6 +163,8 @@ export const compareVersions = (a, b) => {
 };
 
 export const stableSpine = ({ env, hookDir, stateDir, home, pluginVersion, emit, now }) => {
+  const overnight = claimCodexOvernightNotice(stateDir); // the unattended nightly's deferred Codex reload, said once
+  if (overnight) emit(overnight);
   const activeFile = path.join(stateDir, 'active.json');
   const stamp = path.join(stateDir, '.last-update-check');
   let seedDispatched = false;
@@ -240,6 +246,14 @@ export const heartbeat = ({ env, hookDir, stateDir, home, running, seedDispatche
     for (let i = 0; i < 3 && active; i += 1) { if ((r[i] || 0) !== (a[i] || 0)) { newer = (r[i] || 0) > (a[i] || 0); break; } }
     if (active && !newer) return;
   } catch { /* unknown active generation: keep the existing announcement */ }
+  let coordinated = false;
+  try { coordinated = developerCoordinatorOwner({ home, brainHome: env.RUVNET_BRAIN_HOME || path.join(home, '.cache', 'ruvnet-brain') }).active; } catch { /* legacy path */ }
+  if (coordinated) {
+    // Coordinated machines install new code only in the scheduled nightly; saying "installing now" would be false.
+    emit(`[RuvNet Brain — v${remoteVersion} is published; this machine's coordinated nightly update installs it at its next scheduled run]`);
+    emit('');
+    return;
+  }
   if (pref === 'yes' && exists(path.join(hookDir, 'host-update.mjs'))) {
     dispatchDetached(hookDir, 600, path.join(stateDir, '.last-auto-update.log'),
       process.execPath, [path.join(hookDir, 'host-update.mjs')], env);

package/plugin/scripts/signal-watch.mjs

@@ -60,6 +60,7 @@ import os from 'node:os';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { parseHookEvent, toolName, commandOf, findInvocations, rawToolResponse, readStdinBounded } from './hook-input.mjs';
+import { isDirectInvocation } from './entrypoint.mjs';
 
 const MANAGED_TOOLS = ['gh', 'vercel', 'netlify', 'npm', 'git'];
 
@@ -183,7 +184,7 @@ async function main() {
 }
 
 function isMain() {
-  try { return process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url); }
+  try { return isDirectInvocation(import.meta.url); }
   catch { return false; }
 }
 

package/plugin/scripts/spend-guard.mjs

@@ -47,6 +47,7 @@
  */
 import fs from 'node:fs';
 import { fileURLToPath } from 'node:url';
+import { isDirectInvocation } from './entrypoint.mjs';
 
 /** Env vars that bill per token. OPENROUTER is deliberately absent — see below. */
 export const METERED_KEYS = ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY'];
@@ -113,7 +114,7 @@ export function check(command, env = process.env) {
 }
 
 const isMain = (() => {
-  try { return process.argv[1] && fs.realpathSync(process.argv[1]) === fileURLToPath(import.meta.url); }
+  try { return isDirectInvocation(import.meta.url); }
   catch { return false; }
 })();
 

package/plugin/scripts/substitution-wall.mjs

@@ -28,6 +28,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { isDirectInvocation } from './entrypoint.mjs';
 
 export const RUV_TOOL = 'ruflo memory store|retrieve|search (or `ruflo hooks session-end|post-task`)';
 /** Repo-relative scope: our own executable code. Tests and fixtures are never in scope. */
@@ -197,7 +198,7 @@ function repoRootOf(file) {
 }
 
 function isMain() {
-  try { return Boolean(process.argv[1]) && fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(import.meta.url)); } catch { return false; }
+  try { return isDirectInvocation(import.meta.url); } catch { return false; }
 }
 if (isMain()) {
   let code = 0;

package/plugin/scripts/turn-outcome-capture.mjs

@@ -42,7 +42,7 @@ import { fileURLToPath } from 'node:url';
 import { nativeTurnLines } from './native-turn-transcript.mjs';
 import { resolveRuflo, rufloInvocation, rufloCwdFor, rufloScratchRoot } from './ruflo-bin.mjs';
 import { redactText } from './continuity-events.mjs';
-import { resolveProjectStore, globalEnrollmentAllowed } from './project-store-resolver.mjs';
+import { resolveProjectStore, globalEnrollmentAllowed, storeEncryptedAtRest, ENCRYPTED_STORE_REASON } from './project-store-resolver.mjs';
 import { recordHookFailure } from './hook-failures.mjs';
 
 const digest = (value) => crypto.createHash('sha256').update(String(value)).digest('hex');
@@ -53,6 +53,7 @@ function appendReceipt(file, row) {
 }
 const flagValue = (args, flag) => { const i = args.indexOf(flag); return i >= 0 ? args[i + 1] : undefined; };
 import { contentPathExcludes, pathIsExcluded, privateTurn, maskExcludedPaths, captureFailureReason, firstTurnCaptureNotice } from './turn-capture-privacy.mjs';
+import { isDirectInvocation } from './entrypoint.mjs';
 
 export const TURN_NAMESPACE = 'turns';
 export const MIN_OUTCOME_CHARS = 200;
@@ -315,7 +316,8 @@ export function captureTurnOutcome({
     if (!sessionKey) report.skipped = 'no session identity in the host payload';
     else if (turn.finalText.length < MIN_OUTCOME_CHARS && !turn.files.length) {
       report.skipped = turn.excludedResource ? 'turn content withheld: explicitly excluded resource' : host === 'codex' && !message ? 'codex payload carried no last_assistant_message' : 'trivial turn';
-    } else {
+    } else if (storeEncryptedAtRest(db)) report.skipped = loud(`${ENCRYPTED_STORE_REASON}; turn not written (opt out: RUVNET_TURN_CAPTURE=off)`, db); // #439: no ruflo spawn that can only be refused
+    else {
       const fingerprint = crypto.createHash('sha256').update(JSON.stringify([turn.finalText, turn.files])).digest('hex');
       const stateFile = path.join(brainHome, 'turn-capture', 'last-turn.json');
       const identity = crypto.createHash('sha256').update(`${host}:${db}:${sessionKey}`).digest('hex');
@@ -402,6 +404,7 @@ export function runSteps({ steps = [], receipts, event = '' } = {}, { run: suppl
         const data = { key: flagValue(queued.args, '--key'), value: flagValue(queued.args, '--value'), db: flagValue(queued.args, '--path') };
         if (typeof data.key !== 'string' || typeof data.value !== 'string') throw new Error('invalid turn store step');
         if (data.db !== db) throw new Error('foreign turn store rejected');
+        if (storeEncryptedAtRest(db)) throw new Error(ENCRYPTED_STORE_REASON);
         if (queued.brainHome !== brainHome) throw new Error('turn consent settings differ from trusted caller');
         binding = queued;
         key = data.key; value = maskExcludedPaths(redactText(data.value), target.contentPathExcludes, target.capturePath);
@@ -471,6 +474,7 @@ export function turnRecordingStatus({ projectDir = process.cwd(), env = process.
   let target;
   try { target = resolveTurnDb({ projectDir, brainHome }); } catch { return { state: 'unknown', line: 'turn recording unavailable: canonical store resolution failed' }; }
   if (String(env.RUVNET_TURN_CAPTURE || '').toLowerCase() === 'off' || target.skipped) return { state: 'unknown', line: `turn recording n/a — ${target.skipped || 'RUVNET_TURN_CAPTURE=off'}` };
+  if (storeEncryptedAtRest(target.db)) return { state: 'warn', line: `turn recording off for this store — ${ENCRYPTED_STORE_REASON}. Keep this project's store unencrypted, or set RUVNET_TURN_CAPTURE=off to stop trying` };
   const notice = noticeOnFirstUse ? firstTurnCaptureNotice({ target, brainHome, policyFile: turnCapturePolicyFile(brainHome), env }) : null;
   const status = (value) => ({ ...value, ...(notice ? { notice } : {}) });
   let rows = [];
@@ -494,7 +498,7 @@ export function turnRecordingStatus({ projectDir = process.cwd(), env = process.
     : { state: 'unknown', line: 'turn recording not yet proven — no exact readback receipt' });
 }
 
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url) && process.argv[2] === '--run-steps') {
+if (isDirectInvocation(import.meta.url) && process.argv[2] === '--run-steps') {
   try { runSteps(JSON.parse(process.argv[3] || '{}')); } catch { /* a detached worker has no one to report to */ }
   process.exit(0);
 }

package/plugin/scripts/unprompted-runtime.mjs

@@ -89,6 +89,7 @@ import { spawnSync } from 'node:child_process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { readStdinBounded, isHarnessGenerated } from './hook-input.mjs';
 import { resolveBash } from './hook-shim-bash.mjs';
+import { ADVISORY_CONTRACT } from './advisory-contract.mjs';
 
 // WHERE THIS FILE'S SIBLINGS LIVE. Resolved from THIS file's own location so it is correct under the
 // Stable Spine (an immutable versions/<gen> tree) and in a dev checkout alike — hook-shim.mjs has
@@ -127,6 +128,17 @@ const MAX_BUFFER = 1 << 20;
 
 const VALID_CHANNELS = new Set(['advocacy', 'promotion', 'lesson', 'alarm']);
 const VALID_EFFECTS = new Set(['advisory', 'block']);
+// QUIET BY DEFAULT, ENFORCED HERE (4.7.21 review F1). Unless RUVNET_STOP_NUDGES=full, this run is narrowed
+// to lesson + alarm: lesson producers still run and deliver, advocacy/promotion producers are never spawned.
+// The shim also exports RUVNET_UNPROMPTED_CHANNELS, but the shim is boot-frozen and this body is hot-updated,
+// so the quiet promise must not depend on which shim generation happens to dispatch it. An explicit
+// RUVNET_UNPROMPTED_CHANNELS still wins (the shim's own narrowing, or a caller that names channels).
+const QUIET_DEFAULT_CHANNELS = 'lesson,alarm';
+const NUDGES_FULL = String(process.env.RUVNET_STOP_NUDGES || '').toLowerCase() === 'full';
+const CHANNEL_LIST = process.env.RUVNET_UNPROMPTED_CHANNELS || (NUDGES_FULL ? '' : QUIET_DEFAULT_CHANNELS);
+const ALLOWED_CHANNELS = CHANNEL_LIST
+  ? new Set(CHANNEL_LIST.split(',').map((c) => c.trim()).filter((c) => VALID_CHANNELS.has(c)))
+  : VALID_CHANNELS;
 
 /** Exit 0 with byte-empty stdout — the fail-safe and the "nothing to say" path. */
 function silent() { process.exit(0); }
@@ -242,7 +254,7 @@ if (!event) silent();
   if (typeof promptText === 'string' && isHarnessGenerated(promptText)) silent();
 }
 
-const producers = resolveProducers(EVENT);
+const producers = resolveProducers(EVENT).filter((p) => p.channels.some((c) => ALLOWED_CHANNELS.has(c)));
 if (!producers.length) silent();   // unknown event, or nothing wired for it — never speak on a guess
 
 // ── Spawn producers as CAPTURED children, collect candidate lines ──────────────────────────────────
@@ -299,6 +311,7 @@ for (const { s, channels } of rawLines) {
   try { c = JSON.parse(s); } catch { continue; }              // not JSON → drop (a rogue's raw line)
   if (!c || typeof c !== 'object' || Array.isArray(c)) continue;
   if (!VALID_CHANNELS.has(c.channel)) continue;               // unknown/absent channel → drop
+  if (!ALLOWED_CHANNELS.has(c.channel)) continue;             // narrowed by the shim's quiet default → drop
   if (!channels.includes(c.channel)) continue;                // ANTI-SPOOF (GPT-5.6-Sol): this producer is
                                                               // not authorised for this channel → drop
   if (!VALID_EFFECTS.has(c.effect)) continue;                 // unknown/absent effect → drop
@@ -471,9 +484,13 @@ const hookEventName = EVENT ? EVENT.split('-')[0] : 'UserPromptSubmit';
 
 // SYNCHRONOUS write — the truncation fix on the byte-owner itself (see the block path above).
 if (!advisories.length) silent();
-const additionalContext = advisories.map((a) => a.copy).join('\n\n');
+// #489: optional recommendations carry the advisory contract into the model-visible context, once,
+// so a suggestion is never promoted into a question/approval dialog. Alarms and lessons are not offers.
+const delivered = advisories.some((a) => a.channel === 'advocacy')
+  ? [...advisories, { copy: ADVISORY_CONTRACT, channel: 'advisory-contract' }] : advisories;
+const additionalContext = delivered.map((a) => a.copy).join('\n\n');
 try { fs.writeSync(1, process.env.RUVNET_HOOK_CONTEXT_BUDGET === '1'
-  ? emitOwnedContext(contextFrame('unprompted-speech', hookEventName, advisories.map((a) => contextBlock(a.copy, { id: a.channel, critical: a.channel === 'alarm' }))))
+  ? emitOwnedContext(contextFrame('unprompted-speech', hookEventName, delivered.map((a) => contextBlock(a.copy, { id: a.channel, critical: a.channel === 'alarm' }))))
   : JSON.stringify({ hookSpecificOutput: { hookEventName, additionalContext } })); }
 catch { /* if even the final write fails, silence is the fail-safe */ }
 process.exit(0);