ruvnet-brain 4.7.16 → 4.7.18

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

@@ -60,7 +60,7 @@ const TRANSCRIPT_TAIL_BYTES = 2 * 1024 * 1024;
 const STEP_TIMEOUT_MS = 60_000;
 export const RECEIPTS_MAX_BYTES = 256 * 1024;
 export const TURN_STATUS_FRESH_MS /* ✓ only when the newest receipt is verified and younger */ = 24 * 3_600_000;
-const RUFLO_ENV = { RUFLO_DAEMON_AUTOSTART: '0' };
+const RUFLO_ENV = { RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_AUTO_UPDATE: 'false' };
 
 function textOf(content) {
   if (typeof content === 'string') return content;
@@ -239,20 +239,18 @@ export function launchDetached(steps, { receipts, brainHome, projectDir, env = p
   return { launched: true, pid: child.pid };
 }
 
-function readTurnState(stateFile) {
-  try { return JSON.parse(fs.readFileSync(stateFile, 'utf8')) || {}; } catch { return {}; }
-}
+const readTurnState = (stateFile) => { try { return JSON.parse(fs.readFileSync(stateFile, 'utf8')) || {}; } catch { return {}; } };
+
+/** The newest store receipt for this exact key, while the receipt tail still holds it. */
+const storeReceipt = (receipts, key) => { try { return readTail(receipts, 128 * 1024).flatMap((l) => { try { return [JSON.parse(l)]; } catch { return []; } }).findLast((r) => r.kind === 'store' && r.key === key) || null; } catch { return null; } };
+const verifiedReceipt = (r) => r?.status === 0 && r.verified === true;
 
 function sameTurnSeen(stateFile, sessionKey, fingerprint, receipts) {
   const previous = readTurnState(stateFile)[sessionKey];
   if (previous?.fingerprint !== fingerprint) return false;
-  try {
-    const rows = readTail(receipts, 128 * 1024).flatMap((line) => { try { return [JSON.parse(line)]; } catch { return []; } });
-    const receipt = rows.findLast((r) => r.kind === 'store' && r.key === previous.key);
-    if (receipt) return receipt.status === 0 && receipt.verified === true;
-  } catch { /* queued worker has no receipt yet */ }
-  // An in-flight worker gets a bounded grace period; a killed/lost worker cannot consume the turn forever.
-  return Date.now() - previous.at < 2 * STEP_TIMEOUT_MS + 10_000;
+  const receipt = storeReceipt(receipts, previous.key);
+  // No receipt yet: an in-flight worker gets a bounded grace period; a killed/lost worker cannot consume the turn forever.
+  return receipt ? verifiedReceipt(receipt) : Date.now() - previous.at < 2 * STEP_TIMEOUT_MS + 10_000;
 }
 
 function markTurnQueued(stateFile, sessionKey, fingerprint, key) {
@@ -266,9 +264,8 @@ function markTurnQueued(stateFile, sessionKey, fingerprint, key) {
 }
 
 /**
- * Capture this turn's outcome (Stop) and/or queue distillation (SessionEnd, PreCompact).
- * Returns a plain report; `queued` means a worker request, never proof the store committed.
- * `skipped` / `distill.skipped` carry the reason whenever nothing is requested.
+ * Capture this turn's outcome (Stop) and/or start distillation (SessionEnd, PreCompact). Returns a plain report:
+ * `queued` means a request, never proof the store committed; `skipped` / `distill.skipped` carry the reason.
  */
 export function captureTurnOutcome({
   projectDir, event, payload = {}, host = 'claude',
@@ -322,10 +319,12 @@ export function captureTurnOutcome({
       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');
+      const key = `turn-${project}-${digest(`${identity}:${fingerprint}`).slice(0, 40)}`;
       if (sameTurnSeen(stateFile, identity, fingerprint, receipts)) report.skipped = 'same turn outcome already queued or verified';
+      // Proven at Stop already: SessionEnd/PreCompact must not re-send it (2026-10-19/20: each re-send was an "append rejected" row).
+      else if (verifiedReceipt(storeReceipt(receipts, key))) report.skipped = 'turn key already verified at an earlier boundary';
       else {
         const at = now();
-        const key = `turn-${project}-${digest(`${identity}:${fingerprint}`).slice(0, 40)}`;
         dedupe = { stateFile, identity, fingerprint, key };
         const value = buildTurnRecord({ turn, project, host, session: payload.session_id, at });
         steps.push({ ...binding, kind: 'store', ruflo, args: ['memory', 'store', '--key', key, '--value', value, '--namespace', TURN_NAMESPACE,
@@ -444,13 +443,14 @@ export function runSteps({ steps = [], receipts, event = '' } = {}, { run: suppl
       delete options.env.CLAUDE_FLOW_MEMORY_PATH;
       const r = run(invocation.executable, invocation.args, options);
       status = Number.isInteger(r.status) ? r.status : 1;
-      if (kind === 'store' && !verified && status === 0) verified = read({ ruflo, db, key, run, options }) === value;
-      if (verified) status = 0;
+      const duplicate = kind === 'store' && status !== 0 && /already exists/i.test(captureFailureReason(r, status)); // append-only refusal
+      if (kind === 'store' && (status === 0 || duplicate)) { verified = read({ ruflo, db, key, run, options }) === value; if (verified) status = 0; } // identical bytes = success
       if (kind === 'distill' && status === 0) {
         const match = /(?:^|\n)\s*skipped:\s*([^\n]+)/i.exec(String(r.stdout || '').replace(/\x1b\[[0-9;]*m/g, ''));
         if (match) skipped = redactText(match[1]).slice(0, 300);
       }
-      if (!verified && (r.error || status !== 0)) error = captureFailureReason(r, status);
+      if (!verified && duplicate) error = 'duplicate turn key holds different content';
+      else if (!verified && (r.error || status !== 0)) error = captureFailureReason(r, status);
       else if (kind === 'store' && !verified) { status = 1; error = 'exact turn key/content readback failed'; }
     } catch (e) { status = 1; error = redactText(e.message).slice(0, 300); }
     if (error) error = maskExcludedPaths(error, privacyPatterns, projectDir);

package/scripts/agentdb-fleet-doctor.mjs

@@ -35,7 +35,7 @@ function ruflo(cwd, args) {
   // live: ~/.npm-global/lib/node_modules/ruflo/node_modules/@claude-flow/cli/dist/src/services/
   // daemon-autostart.js:85) — this doctor walks a whole fleet of project dirs and must not leave
   // one daemon running per project as a side effect of asking each one a question.
-  const r = spawnSync(RUFLO, args, { cwd, encoding: 'utf8', timeout: 120000, env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0' } });
+  const r = spawnSync(RUFLO, args, { cwd, encoding: 'utf8', timeout: 120000, env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_AUTO_UPDATE: 'false' } });
   return { out: (r.stdout || '') + (r.stderr || ''), status: r.status };
 }
 

package/scripts/corpus-dispatch-decision.mjs

@@ -21,7 +21,7 @@
 
 //
 // THE RETRY SLOT (2026-10-20). Measured on 38 nights: 24 failed, most on one transient blip, and nothing
-// retried until the next calendar day. The dispatcher now also fires at RETRY_CRON (11:17 UTC, four hours
+// retried until the next calendar day. The dispatcher now also fires at RETRY_CRON (09:17 UTC since 2026-10-24, four hours
 // after the night's first slot) and asks decideRetry(): re-dispatch ONLY when every corpus run of the
 // night so far ended `failed` (or reached no outcome), none is still running, none ended published /
 // no-change / superseded / canary-rejected (those are answers, not weather), and fewer than
@@ -37,9 +37,10 @@ import { pathToFileURL } from 'node:url';
 
 export const MIN_PIPELINE_VERSION = '4.3.38'; // sync-version-ignore: a fixed pipeline floor, not the current version
 /** The dispatcher's second schedule entry; corpus-nightly-dispatch.yml's `on.schedule` must carry exactly this line. */
-export const RETRY_CRON = '17 11 * * *';
-/** How far back the retry slot looks for the night's runs: past the 07:17 UTC first slot, never into yesterday. */
-export const RETRY_WINDOW_MS = 10 * 3_600_000;
+export const RETRY_CRON = '17 9 * * *';
+/** How far back the retry slot looks for the night's runs: past the 05:17 UTC first slot (with room for GitHub's late
+ * schedule starts), never into yesterday's slot or an evening manual dispatch. */
+export const RETRY_WINDOW_MS = 8 * 3_600_000;
 export const MAX_CORPUS_RUNS_PER_NIGHT = 2;
 // `unknown` (every job green, no outcome) is retried only when the run itself did NOT conclude success: a green
 // run that reached no outcome is a workflow defect the terminal-outcome job already fails loudly, not weather.

package/scripts/corpus-watchdog.mjs

@@ -400,6 +400,31 @@ export function failedStage(run) {
   return stage ? STAGE_NAMES[stage] || stage : `an unnamed job (conclusion ${run?.conclusion || 'unknown'})`;
 }
 
+/** A night's scheduled dispatches (the 07:36Z run and its retry slot) sit within this span; a day earlier is last night. */
+const NIGHT_SPAN_MS = 12 * HOUR;
+/**
+ * How many protected-release corpus runs belong to THIS night. Measured 2026-10-22: a manual workflow_dispatch proving
+ * run at 10:36Z Oct 21 and a stood-down retry slot at 11:25Z Oct 21 made ONE scheduled night read "attempt 2; 1 retried".
+ * The night is anchored on the newest `schedule` dispatcher that dispatched a run, plus scheduled dispatchers within
+ * NIGHT_SPAN_MS before it; a run counts only from that start and never when its dispatcher was a manual
+ * workflow_dispatch. A stood-down retry slot created no run, so it never counts. `runs` is newest-first, in window.
+ */
+export function nightAttempts(runs, dispatchers) {
+  const dispatchKey = (d) => `corpus-${d.id}-${d.attempt ?? 1}`;
+  const runKey = (run) => CORPUS_RUN_TITLE.exec(String(run.title || ''))?.[1];
+  const byKey = new Map(dispatchers.map((d) => [dispatchKey(d), d]));
+  const manual = (run) => byKey.get(runKey(run))?.event === 'workflow_dispatch';
+  const [newest] = runs;
+  if (manual(newest)) return ' (1 attempt; manual dispatch)';
+  const scheduled = dispatchers.filter((d) => !d.event || d.event === 'schedule'); // an undated event is read as the schedule
+  const anchor = scheduled.find((d) => runs.some((run) => runKey(run) === dispatchKey(d)));
+  const nightStart = anchor
+    ? Math.min(...scheduled.filter((d) => ms(d.createdAt) <= ms(anchor.createdAt) && ms(anchor.createdAt) - ms(d.createdAt) <= NIGHT_SPAN_MS).map((d) => ms(d.createdAt)))
+    : ms(newest.createdAt);
+  const count = runs.filter((run) => ms(run.createdAt) >= nightStart && !manual(run)).length || 1;
+  return count > 1 ? ` (attempt ${count} of the night; ${count - 1} retried)` : ' (1 attempt)';
+}
+
 /**
  * THE ONE LINE the owner reads first: what the night did, result first, in Eastern time. `input` is
  * gatherCorpusHealthInput's; the night is the newest corpus run of the last 24h and every retry of it.
@@ -410,9 +435,10 @@ export function summarizeNight(input, now) {
   const inWindow = (iso) => { const t = ms(iso); return t !== null && t <= at && at - t <= TONIGHT_WINDOW_MS; };
   const runs = (input?.corpusRuns || []).filter((run) => inWindow(run.createdAt))
     .map((run) => ({ ...run, outcome: run.outcome ?? classifyCorpusRun(run) })).sort((a, b) => ms(b.createdAt) - ms(a.createdAt));
-  const dispatcher = (input?.dispatcherRuns || []).filter((d) => inWindow(d.createdAt)).sort((a, b) => ms(b.createdAt) - ms(a.createdAt))[0];
+  const dispatchers = (input?.dispatcherRuns || []).filter((d) => inWindow(d.createdAt)).sort((a, b) => ms(b.createdAt) - ms(a.createdAt));
+  const [dispatcher] = dispatchers;
   const latest = input?.latestRelease;
-  const attempts = runs.length > 1 ? ` (attempt ${runs.length} of the night; ${runs.length - 1} retried)` : '';
+  const attempts = runs.length ? nightAttempts(runs, dispatchers) : '';
   const keep = latest ? `customers keep ${latest.tag} (${hours(Math.max(0, at - (ms(latest.generation || latest.publishedAt) ?? at)))} old)` : 'no promoted generation is observed';
   if (!runs.length) {
     if (!dispatcher) return { outcome: 'no-run', line: `night: no corpus run in the last 24h (no dispatcher run either); ${keep}` };

package/scripts/distill-project.mjs

@@ -48,7 +48,7 @@ const HOME = os.homedir();
 // install whose npm prefix is not the owner's (Homebrew, nvm, Volta, plain `npm -g`) was told its
 // tool was missing while ruflo sat on their PATH. One resolver, shared — see ruflo-bin.mjs.
 const RUFLO = resolveRuflo();
-const RUFLO_ENV = { ...process.env, RUFLO_DAEMON_AUTOSTART: '0' };
+const RUFLO_ENV = { ...process.env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_AUTO_UPDATE: 'false' };
 
 const argv = process.argv.slice(2);
 const arg = (f, d) => { const i = argv.indexOf(f); return i >= 0 && argv[i + 1] ? argv[i + 1] : d; };

package/scripts/falsify.mjs

@@ -179,7 +179,7 @@ export const CHECKS = [
       const rufloBin = resolveRuflo();
       const r = rufloBin
         ? spawnSync(rufloBin, ['memory', 'search', '-q', 'nightly job supervision heartbeat receipts'], {
-          cwd: ROOT, encoding: 'utf8', timeout: 120_000, env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0' },
+          cwd: ROOT, encoding: 'utf8', timeout: 120_000, env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_AUTO_UPDATE: 'false' },
         })
         : { error: new Error(RUFLO_MISSING), stdout: '' };
       const recalled = /Found\s+\d+\s+results/.test(r.stdout || '') && !/Found\s+0\s+results/.test(r.stdout || '');

package/scripts/health-repair.mjs

@@ -54,7 +54,7 @@ const PROJECT = learningContext({ cwd: requestedProject || process.env.RUVNET_BR
  * that one global binary is rather than assuming a path.
  */
 const RUFLO = resolveRuflo();
-const RUFLO_ENV = { ...process.env, RUFLO_DAEMON_AUTOSTART: '0' };
+const RUFLO_ENV = { ...process.env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_AUTO_UPDATE: 'false' };
 
 const sqlite = (db, sql) => execFileSync('sqlite3', [db, sql], { encoding: 'utf8', timeout: 120_000 }).trim();
 

package/scripts/learning-replay-execution.mjs

@@ -32,7 +32,7 @@ const MUTATING_SUBCOMMANDS = new Set([
 // node_modules/@claude-flow/cli/dist/src/services/daemon-autostart.js:85). Applied here, once, so
 // every caller of spawnRuflo() gets it regardless of whether it passed its own `env`.
 function spawnRuflo(bin, args, options = {}) {
-  const opts = { ...options, env: { ...(options.env || process.env), RUFLO_DAEMON_AUTOSTART: '0' } };
+  const opts = { ...options, env: { ...(options.env || process.env), RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_AUTO_UPDATE: 'false' } };
   return /\.[cm]?js$/i.test(bin)
     ? spawnSync(process.execPath, [bin, ...args], opts)
     : spawnSync(bin, args, opts);
@@ -120,7 +120,7 @@ export function executeProducedCommand(cmd, {
     .find((value) => MUTATING_SUBCOMMANDS.has(value));
   if (mutating) return reject(`refused mutating subcommand "${mutating}"`, { argv: ['ruflo', ...args] });
 
-  const env = { ...process.env, RUFLO_DAEMON_AUTOSTART: '0' };
+  const env = { ...process.env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_AUTO_UPDATE: 'false' };
   delete env.CLAUDE_FLOW_DB_PATH;
   delete env.CLAUDE_FLOW_MEMORY_PATH;
   const result = spawnRuflo(ruflo, args, {
@@ -151,7 +151,7 @@ export function verifyRufloFlag(bin = RUFLO_BIN) {
   const result = spawnSync(bin, ['memory', 'search', '--help'], {
     encoding: 'utf8',
     timeout: 30_000,
-    env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0' },
+    env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_AUTO_UPDATE: 'false' },
   });
   const output = `${result.stdout || ''}${result.stderr || ''}`;
   if (result.status !== 0 && !output) return { ok: false, why: `help exited ${result.status} empty` };

package/scripts/learning-replay-fixture.mjs

@@ -32,6 +32,9 @@ const sh = (cmd, args, options = {}) => {
     encoding: 'utf8',
     timeout: 120_000,
     ...options,
+    // A ruflo started here would auto-start a daemon and run its in-cwd self-update (`npm install @claude-flow/cli`,
+    // 1.3 GB measured 2026-10-22) in the fixture project; a caller's own env still wins.
+    env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_AUTO_UPDATE: 'false', ...(options.env || {}) },
   });
 };
 const remove = (target) => {

package/scripts/lesson-migrate-agentdb.mjs

@@ -96,7 +96,7 @@ function rufloJson(args) {
   const tmp = path.join(SCRATCH_DIR, `call-${callCounter++}.json`);
   const fd = fs.openSync(tmp, 'w');
   try {
-    execFileSync(RUFLO, args, { stdio: ['ignore', fd, 'ignore'], timeout: CLI_TIMEOUT_MS, env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0' } });
+    execFileSync(RUFLO, args, { stdio: ['ignore', fd, 'ignore'], timeout: CLI_TIMEOUT_MS, env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_AUTO_UPDATE: 'false' } });
   } catch (e) {
     if (e.signal || e.code === 'ETIMEDOUT') {
       throw new Error(`ruflo ${args.join(' ')} did not finish within ${CLI_TIMEOUT_MS}ms (killed with ${e.signal || e.code}) — likely lock contention from a concurrent writer on this shared machine. Re-run.`);

package/scripts/nightly-wrapper.sh

@@ -150,10 +150,10 @@ fi
 # Memory distillation (ADR-174) had gone stale 3 days — same silent-death pattern as everything
 # else tonight. Independent of rebuild success/failure: mine raw memory_entries into structured
 # episodes/reasoning_patterns on every nightly run. Best-effort, never blocks the real job.
-RUFLO_DAEMON_AUTOSTART=0 ~/.npm-global/bin/ruflo memory distill run --path "$RUVNET_PROJECT_MEMORY_DB" >> "$LOG" 2>&1 || true
+RUFLO_DAEMON_AUTOSTART=0 CLAUDE_FLOW_AUTO_UPDATE=false ~/.npm-global/bin/ruflo memory distill run --path "$RUVNET_PROJECT_MEMORY_DB" >> "$LOG" 2>&1 || true
 # Durability: was a one-off manual snapshot before tonight. Now recurring — WAL-safe, rotates
 # automatically (keeps last 14), zero risk to the live DB (reads only).
-RUFLO_DAEMON_AUTOSTART=0 ~/.npm-global/bin/ruflo memory backup --db "$RUVNET_PROJECT_MEMORY_DB" --keep 14 >> "$LOG" 2>&1 || true
+RUFLO_DAEMON_AUTOSTART=0 CLAUDE_FLOW_AUTO_UPDATE=false ~/.npm-global/bin/ruflo memory backup --db "$RUVNET_PROJECT_MEMORY_DB" --keep 14 >> "$LOG" 2>&1 || true
 
 # LESSON BRIDGE (ADR-066, 2026-08-10) — carry newly-tagged machine-wide lessons into the store the
 # hooks actually read. Without this the bridge is a command someone has to remember, and a learning

package/scripts/proxy/claude-proxied.sh

@@ -26,6 +26,7 @@ set -euo pipefail
 # daemon-autostart.js:85). This script only checks/starts the proxy — it has no business leaving a
 # swarm daemon running as a side effect.
 export RUFLO_DAEMON_AUTOSTART=0
+export CLAUDE_FLOW_AUTO_UPDATE=false
 
 TOKEN_FILE="$HOME/.ruflo/proxy-token"
 

package/scripts/proxy/proxy-revert.sh

@@ -13,6 +13,7 @@ set -uo pipefail
 # live: ~/.npm-global/lib/node_modules/ruflo/node_modules/@claude-flow/cli/dist/src/services/
 # daemon-autostart.js:85). A teardown script has no business leaving one running.
 export RUFLO_DAEMON_AUTOSTART=0
+export CLAUDE_FLOW_AUTO_UPDATE=false
 
 echo "Reverting the Meta LLM Proxy trial..."
 echo

package/scripts/proxy/proxy-up.sh

@@ -11,6 +11,7 @@ set -uo pipefail
 # daemon-autostart.js:85). Installing/starting the proxy has no business leaving a swarm daemon
 # running as a side effect.
 export RUFLO_DAEMON_AUTOSTART=0
+export CLAUDE_FLOW_AUTO_UPDATE=false
 
 REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
 

package/scripts/proxy/proxy-verify.mjs

@@ -60,7 +60,7 @@ try {
     // Every `ruflo` invocation auto-starts a project background daemon unless this is set
     // (verified live: ~/.npm-global/lib/node_modules/ruflo/node_modules/@claude-flow/cli/dist/src/
     // services/daemon-autostart.js:85) — a health-check probe must not leave one running.
-    env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0' },
+    env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_AUTO_UPDATE: 'false' },
   });
   doctorOk = /Summary:.*passed/.test(doctorOut) && !/\b\d+ failed/.test(doctorOut);
 } catch (err) {

package/scripts/record-lesson.mjs

@@ -71,7 +71,7 @@ const ruflo = (args) => {
   const invocation = rufloInvocation(RUFLO, args);
   return execFileSync(invocation.executable, invocation.args, {
     cwd: dir, encoding: 'utf8', timeout: 60000, shell: false,
-    env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0' },
+    env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_AUTO_UPDATE: 'false' },
   });
 };
 

package/scripts/selfcheck.mjs

@@ -613,7 +613,7 @@ export function runSecurityScan({ cwd = process.cwd(), timeoutMs = 20000, env =
   // Every `ruflo` invocation auto-starts a project background daemon unless this is set (verified
   // live against the installed CLI: ~/.npm-global/lib/node_modules/ruflo/node_modules/@claude-flow/cli/dist/src/services/daemon-autostart.js:85).
   // A read-only version probe + two scan subcommands have no business leaving a daemon running.
-  env = { ...env, RUFLO_DAEMON_AUTOSTART: '0' };
+  env = { ...env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_AUTO_UPDATE: 'false' };
   const probe = spawnSync('ruflo', ['--version'], { encoding: 'utf8', timeout: 5000, env });
   if (probe.error || probe.status !== 0) {
     return { available: false, reason: 'ruflo not found on PATH — MCP surface not scanned (install: npm i -g ruflo)' };

package/scripts/single-source-check.mjs

@@ -240,7 +240,7 @@ const checks = [
     run: () => { const s = readAbs(path.join(HOME, '.claude/settings.json')); return { ok: !/agentdb-autocapture/.test(s), detail: /agentdb-autocapture/.test(s) ? 'global agentdb-autocapture still registered alongside the plugin session-snapshot' : 'single writer' }; } },
 
   { id: 'E3', area: 'hooks', scope: 'machine', title: 'Lessons live in one store (no .swarm lesson-* rows outside the plugin lesson store)',
-    run: () => { const r = spawnSync('ruflo', ['memory', 'list', '--path', path.join(HOME, 'Code/ruvnet-brain/.swarm/memory.db'), '--limit', '500'], { encoding: 'utf8', timeout: 60000, env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0' } });
+    run: () => { const r = spawnSync('ruflo', ['memory', 'list', '--path', path.join(HOME, 'Code/ruvnet-brain/.swarm/memory.db'), '--limit', '500'], { encoding: 'utf8', timeout: 60000, env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_AUTO_UPDATE: 'false' } });
       const n = (r.stdout.match(/lesson-/g) || []).length; return { ok: n === 0, detail: `${n} lesson-* rows in project .swarm (plugin store: ~/.config/ruvnet-brain/lessons.json)` }; } },
   { id: 'E4', area: 'hooks', scope: 'machine', title: 'One session-start continuity restorer (global hook stands down when the plugin is enabled)',
     run: () => { const s = readAbs(path.join(HOME, '.claude/hooks/agentdb-ensure.sh')); return { ok: s.includes('SINGLE CONTINUITY OWNER'), detail: 'agentdb-ensure.sh must stand down its project-state recall' }; } },

package/scripts/stack-sync.mjs

@@ -37,7 +37,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { runDeveloperUpdate, readDeveloperUpdateConfig } from '../plugin/scripts/developer-update.mjs';
-import { FAMILY, PLUGIN_MARKETPLACES, cmpVersion, pickTargetTag, normalizeNpmDistTags } from '../plugin/scripts/developer-update-policy.mjs';
+import { FAMILY, PLUGIN_MARKETPLACES, cmpVersion, pickTargetTag, normalizeNpmDistTags, normalizeNpmTimes, needsPublishTimes, wantedTag } from '../plugin/scripts/developer-update-policy.mjs';
 export { FAMILY, PLUGIN_MARKETPLACES, cmpVersion, pickTargetTag, normalizeNpmDistTags } from '../plugin/scripts/developer-update-policy.mjs';
 
 const HOME = os.homedir();
@@ -193,6 +193,13 @@ function registryTags(pkg) {
   try { return normalizeNpmDistTags(JSON.parse(r.stdout)); } catch { return null; }
 }
 
+// Publish times, so an abandoned pre-release tag is not reported as "behind" (same rule as the updater).
+function registryTimes(pkg) {
+  const r = spawnSync('npm', ['view', pkg, 'time', '--json'], { encoding: 'utf8', timeout: 30000 });
+  if (r.status !== 0 || !r.stdout) return null;
+  try { return normalizeNpmTimes(JSON.parse(r.stdout)); } catch { return null; }
+}
+
 // A second copy of a stack package in the npx cache can only ever SHADOW the global one.
 // It is never useful. This is how "two ruflos" happens.
 export function findShadows(npxCache = NPX_CACHE, lib = GLOBAL_LIB) {
@@ -228,11 +235,12 @@ export function classify(pkgs, { channel = readDeveloperUpdateConfig().channel }
     if (p.source === 'plugin') {
       return { ...p, tag: 'plugin', target: null, state: p.installed ? 'INSTALLED_UNVERIFIED' : 'BROKEN', evidence: 'local install record only; marketplace revision not checked' };
     }
-    const want = p.name === '@pacphi/agentic-kit' ? 'next' : channel === 'alpha' && FAMILY.test(p.name) ? 'alpha' : DEFAULT_TAG;
+    const want = wantedTag(p.name, channel);
     const tags = registryTags(p.name);
     // Newest of {policy tag, latest} — see pickTargetTag: "track @alpha" alone pinned the core behind
     // @latest on 2026-07-18. A package with no alpha tag falls through to latest.
-    const { tag, target } = pickTargetTag(tags, want);
+    const published = needsPublishTimes(tags, want) ? (registryTimes(p.name) || {}) : null;
+    const { tag, target } = pickTargetTag(tags, want, 'latest', { published });
     let state;
     if (!p.installed) state = 'BROKEN';
     else if (!target) state = 'UNRESOLVED';