create-walle 0.10.1 → 0.10.2

package/template/coding-task-manager/git-utils.js

@@ -2,6 +2,8 @@
 const { execFile, spawn } = require('child_process');
 const path = require('path');
 const { createSemaphore } = require('./lib/async-semaphore');
+// WP-4: one normal form for a git remote, shared with wall-e and the hub (never re-implemented).
+const { normalizeGitRemote } = require('../shared/git-remote-key');
 
 const DEFAULT_GIT_TIMEOUT_MS = _positiveInt(process.env.CTM_GIT_TIMEOUT_MS, 15000);
 const DEFAULT_WORKTREE_CREATE_TIMEOUT_MS = Math.max(
@@ -628,6 +630,46 @@ function _invalidateGitFactCache() {
 async function resolveMainBranch(cwd) {
   return _mainBranchCache(cwd || '', () => _resolveMainBranchUncached(cwd));
 }
+
+// WP-4 (§6.5 step 2, §9 S-9): the box-side `gitRemoteKey` for /api/projects rows.
+//
+// The SAME cached-promise pattern as resolveMainBranch above — async (never a sync spawn on the
+// main thread), one `git remote get-url origin` per checkout per TTL, and a rejection drops the
+// cache entry instead of pinning an empty key for the whole window. Everything about WHICH string
+// is the key lives in shared/git-remote-key.js (one implementation, both ends); this is only the
+// git read. A non-repo / no-origin / detached cwd resolves to '' — the caller emits the field
+// with an empty value rather than omitting it, so a client can tell "asked and there is no remote"
+// from "this instance is too old to answer".
+const _GIT_REMOTE_KEY_TTL_MS = 30000; // fixed on purpose: no new env var (WP-4 hard rule)
+const _remoteKeyCache = _ttlPromiseCache(_GIT_REMOTE_KEY_TTL_MS);
+
+async function gitRemoteKey(cwd) {
+  const repoPath = String(cwd || '');
+  if (!repoPath) return '';
+  return _remoteKeyCache(repoPath, async () => {
+    const url = await _gitSafe(repoPath, ['remote', 'get-url', 'origin']);
+    return normalizeGitRemote(url);
+  });
+}
+
+/**
+ * Attach `gitRemoteKey` to every project row (in place, returning the same array).
+ *
+ * Bounded concurrency: a projects list is normally < 100 rows and each miss costs one `git`
+ * process, but a shared box can hold hundreds — the pool keeps the fan-out flat instead of
+ * spawning one git per row at once.
+ */
+async function attachGitRemoteKeys(projects) {
+  const rows = Array.isArray(projects) ? projects : [];
+  const concurrency = 8;
+  for (let i = 0; i < rows.length; i += concurrency) {
+    await Promise.all(rows.slice(i, i + concurrency).map(async (row) => {
+      if (!row || typeof row !== 'object') return;
+      row.gitRemoteKey = await gitRemoteKey(row.path);
+    }));
+  }
+  return rows;
+}
 async function _resolveMainBranchUncached(cwd) {
   const originHead = await _gitSafe(cwd, ['symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD']);
   if (originHead) {
@@ -2303,4 +2345,6 @@ module.exports = {
   _invalidateGitFactCache,
   _gitProbeEnv,
   _mapWorktreesBounded, _getGitProbeMetrics, _resetGitProbeMetrics,
+  // WP-4: gitRemoteKey on /api/projects rows (S-9) — the key itself is normalizeGitRemote.
+  gitRemoteKey, attachGitRemoteKeys, normalizeGitRemote,
 };

package/template/coding-task-manager/lib/adopted-host-redial.js

@@ -60,6 +60,10 @@ function _declareHostDead(manager, hostId, attemptNumber) {
     adapter._emitExitOnce({ exitCode: 1, signal: null, hostClosed: true, reason: 'adopted-redial-exhausted' });
   }
   manager._removeHostRecordAsync(hostId);
+  // D-8 (stale-pty-host-evacuation design): a dead host leaves no retry behind --
+  // without its compat entry handoffStale() returns null and never re-arms a
+  // stale retry for a process that is already gone.
+  manager.hostCompatibility?.delete(hostId);
   // I6 (host-readiness design): announce the death so the primary's readiness
   // ledger forgets this hostId -- the ONE terminal path for an adopted host.
   manager.emit?.('host-exit', { hostId, kind: 'adopted' });

package/template/coding-task-manager/lib/agent-presets.js

@@ -188,11 +188,25 @@ const INHERITED_AGENT_ENV_KEYS = [
 // lead, it never drives CTM; interactive sessions (explicitWorkerAgent undefined) keep all four.
 const WORKER_STRIPPED_TOKEN_KEYS = Object.freeze(['WALLE_CTM_TOKEN', 'WALL_E_API_TOKEN', 'CTM_TOKEN', 'CTM_API_TOKEN']);
 
+// D-7 (session-stops-followups-2026-10-24.html §1.3, §5 D-7, §8 WP-4): the same worker branch also
+// must not hold a CTM API ADDRESS. On 2026-10-24 a delegated worker's script loaded Wall-E's CTM
+// client with no base URL; resolveApiBaseUrl (wall-e/memory/ctm-context-client.js:12-17) fell back
+// to the inherited CTM_PORT=3456 and reached PRIMARY. These three names are every alias that
+// resolver reads, so a worker keeps none of them and carries the resolver's existing
+// `WALLE_CTM_API='0'` switch instead: with no explicit URL it resolves '' and calls throw
+// ctm_api_unavailable. buildTelemetryEnv still sets CTM_PORT (the shared session env; interactive
+// hooks read it, a default worker runs none); the address is what must not travel. Least privilege
+// by inheritance (P-5): the orchestrator's addressability is not a worker capability. Interactive
+// sessions keep all of it.
+const WORKER_STRIPPED_CTM_API_KEYS = Object.freeze(['CTM_SESSION_MEMORY_API_BASE_URL', 'CTM_API_BASE_URL', 'CTM_BASE_URL']);
+
 function sanitizeInheritedAgentEnv(env, explicitWorkerAgent) {
   if (!env || typeof env !== 'object') return env;
   for (const key of INHERITED_AGENT_ENV_KEYS) delete env[key];
   if (explicitWorkerAgent === 'claude' || explicitWorkerAgent === 'codex') {
     for (const key of WORKER_STRIPPED_TOKEN_KEYS) delete env[key];
+    for (const key of WORKER_STRIPPED_CTM_API_KEYS) delete env[key];
+    env.WALLE_CTM_API = '0';
     env.CTM_WORKER_AGENT = explicitWorkerAgent;
   }
   return env;
@@ -238,4 +252,5 @@ module.exports = {
   buildTelemetryEnv,
   sanitizeInheritedAgentEnv,
   WORKER_STRIPPED_TOKEN_KEYS,
+  WORKER_STRIPPED_CTM_API_KEYS,
 };

package/template/coding-task-manager/lib/agent-title-apply.js

@@ -0,0 +1,88 @@
+'use strict';
+
+// WP-2 (design doc session-name-agent-title-precedence §5 D-4/D-5/D-9, §6): the inbound applier
+// for a name the CODING AGENT wrote into its own transcript — Claude's `ai-title` / `custom-title`
+// records, captured during ingest (lib/transcript-store.js claudeMessagesFromEntry).
+//
+// Pure SQL on the caller's better-sqlite3 handle. This module is loaded on the ingest path
+// (transcript-store → the db-owner worker, the read pool and the main thread), so it must never
+// require lib/db.js — the domain router owns the handles and passes one in.
+//
+// Contract:
+//   * Tier 1 (`user_renamed=1`) is never rewritten. A drifted agent name only asks for ONE
+//     re-assert outward (`reassert: true`; the caller runs mirrorSessionTitle({force:true})).
+//     `ai-title` alone is never drift — Claude keeps writing ai-titles under a custom title (§1e).
+//   * `custom-title` equal to `title_mirror_value` is CTM's own echo of what it pushed into the
+//     agent, not the agent's name (D-5), so the `ai-title` wins instead.
+//   * A tier-2 write touches ctm_sessions only. The caller (server.js _runTranscriptDeltaPipeline)
+//     moves `startup_tasks.label` through db.updateStartupTaskLabel, which also enqueues the
+//     multi-machine sync outbox row this db.js-free module cannot reach (D-13).
+
+const { normalizeSessionTitle } = require('./session-title-signals');
+const { isUuidLike } = require('./session-title-mirror');
+
+// D-9: these two states mean "a push was attempted and did not land" — a row already sitting at
+// that outcome for the CURRENT title is not re-driven from inbound (exit and relink keep retrying).
+const MIRROR_RETRY_STATES = new Set(['failed', 'unsupported']);
+
+/**
+ * @param {import('better-sqlite3').Database} coreDb handle carrying ctm_sessions + startup_tasks
+ *   (the caller's CORE domain handle — `options.coreDb || db` at the ingest choke point).
+ * @param {{ ctmSessionId: string, provider?: string, customTitle?: string, aiTitle?: string }} o
+ *   `provider` is accepted for call-site symmetry; the provider gate (titleSpec.readsAiTitle) is
+ *   the caller's, because the reason string and the SQL are provider-independent.
+ * @returns {{ applied: 'agent'|'none', reason: string, title?: string, reassert: boolean }}
+ */
+function applyAgentTitleSignals(coreDb, { ctmSessionId, customTitle = '', aiTitle = '' } = {}) {
+  const id = String(ctmSessionId || '').trim();
+  if (!id) return { applied: 'none', reason: 'no_session', reassert: false };
+  const row = coreDb.prepare(
+    'SELECT title, user_renamed, title_mirror_state, title_mirror_value FROM ctm_sessions WHERE id = ?',
+  ).get(id);
+  if (!row) return { applied: 'none', reason: 'no_row', reassert: false };
+
+  const title = normalizeSessionTitle(row.title);
+  const custom = normalizeSessionTitle(customTitle);
+  const ai = normalizeSessionTitle(aiTitle);
+  const mirrorValue = normalizeSessionTitle(row.title_mirror_value);
+  const mirrorState = String(row.title_mirror_state || '');
+
+  if (row.user_renamed) {
+    // C-5/D-9: a tier-1 row nobody has ever tried to push gets exactly one attempt on its first
+    // observation. Checked before the drift vocabulary below — nothing was pushed yet, so the
+    // agent cannot have drifted FROM anything, and naming the real condition is what a diagnosis
+    // should report. Either way the row is never rewritten.
+    if (mirrorState === '') return { applied: 'none', reason: 'tier1_unmirrored', reassert: true };
+    if (custom && custom !== title) {
+      if (MIRROR_RETRY_STATES.has(mirrorState) && mirrorValue === title) {
+        return { applied: 'none', reason: 'tier1_drift', reassert: false };
+      }
+      // Drift is recorded either way: a later batch carrying the CTM name back converges
+      // (`mirrorSessionTitle` persists state='mirrored') and the next observation is quiet.
+      coreDb.prepare('UPDATE ctm_sessions SET title_mirror_state = ? WHERE id = ?').run('drifted', id);
+      return { applied: 'none', reason: 'tier1_drift', reassert: true };
+    }
+    return { applied: 'none', reason: 'tier1', reassert: false };
+  }
+
+  // D-5: the agent's name wins, unless the custom-title is CTM's own echo of title_mirror_value.
+  const name = (custom && custom !== mirrorValue) ? custom : ai;
+  if (!name) return { applied: 'none', reason: 'unchanged', reassert: false };
+  // A provider name that is just the provider's opaque session id names nothing.
+  if (isUuidLike(name)) return { applied: 'none', reason: 'uuid_like', reassert: false };
+  if (name === title) return { applied: 'none', reason: 'unchanged', reassert: false };
+
+  const reason = name === custom ? 'provider_custom_title' : 'provider_ai_title';
+  const updatedAt = new Date().toISOString();
+  // The tier guard lives in the WHERE, so a concurrent rename is never overwritten.
+  const changes = coreDb.prepare(`
+    UPDATE ctm_sessions
+       SET title = ?, title_source = 'provider_title', title_status = 'imported',
+           title_status_reason = ?, title_updated_at = ?, updated_at = datetime('now')
+     WHERE id = ? AND COALESCE(user_renamed, 0) = 0
+  `).run(name, reason, updatedAt, id).changes;
+  if (!changes) return { applied: 'none', reason: 'tier1', reassert: false };
+  return { applied: 'agent', title: name, reason, reassert: false };
+}
+
+module.exports = { applyAgentTitleSignals };

package/template/coding-task-manager/lib/agent-title-backfill-read.js

@@ -0,0 +1,92 @@
+'use strict';
+
+// WP-6 (design doc session-name-agent-title-precedence §§1e/6/8): the READ half of the one-shot
+// agent-title backfill — one bounded page of Claude candidates CTM has never been given an agent
+// name for, plus each row's transcript TAIL (last <=64 KiB, one positional range; never a
+// whole-file read). The apply is the db-owner's (db.js applyAgentTitleBackfillRows ->
+// lib/agent-title-apply.js), so this stays a pure read on the caller's read-only WAL handle.
+// Called by the read-pool worker op 'backfillAgentTitles'; the caller (server/boot.js) owns the
+// page loop and the once-per-install marker.
+
+const transcriptSource = require('./transcript-source');
+
+function readAgentTitleBackfillPage(conn, payload = {}) {
+  const { extractTitleSignalFromRecord } = require('./session-title-signals');
+  // §1e measured the EOF→last title-record distance at p50 3,293 B, p90 19,166 B, max 36,778 B
+  // over n=43; 64 KiB is that bound with headroom and is the hard per-row ceiling.
+  const MAX_ROWS = 20;
+  const TAIL_BYTES = 64 * 1024;
+  const explicitIds = (Array.isArray(payload.ids) ? payload.ids : [])
+    .map((id) => String(id || '').trim()).filter(Boolean).slice(0, MAX_ROWS);
+  const limit = Math.max(1, Math.min(MAX_ROWS, Number(payload.limit) || MAX_ROWS));
+  const tailBytes = Math.max(1024, Math.min(TAIL_BYTES, Number(payload.tailBytes) || TAIL_BYTES));
+  // An explicit id list (bin/repair-resume-echo-titles.js) has already re-stated the row's
+  // tier itself, so those pages drop the tier filters; the default page keeps them.
+  const tierFilter = explicitIds.length ? '' : `
+     AND COALESCE(c.user_renamed, 0) = 0
+     AND COALESCE(c.title_source, '') <> 'provider_title'`;
+  const idFilter = explicitIds.length ? ` AND c.id IN (${explicitIds.map(() => '?').join(',')})` : '';
+  // Run-scoped walk cursor: the caller accumulates the ids this page ALREADY read and hands
+  // them back, so a row whose transcript turns out to carry no title record cannot make the
+  // walk loop forever (rows that DO get a title also leave the candidate set on their own).
+  const skipIds = (Array.isArray(payload.skipIds) ? payload.skipIds : [])
+    .map((id) => String(id || '').trim()).filter(Boolean).slice(0, 4000);
+  const skipFilter = skipIds.length ? ` AND c.id NOT IN (${skipIds.map(() => '?').join(',')})` : '';
+  // "The row's transcript" is the LATEST agent_sessions row, the same rule the display path
+  // uses (db.js getSessionDisplayTitleInfo's ROW_NUMBER() OVER … rn = 1), not MAX(jsonl_path):
+  // a stitched compaction continuation adds a second row, and the freshest file is the one
+  // Claude is still appending ai-titles to.
+  const candidates = conn.prepare(`
+    SELECT c.id AS id, a.jsonl_path AS jsonl_path
+      FROM ctm_sessions c
+      JOIN (
+        SELECT ctm_session_id, jsonl_path, modified_at, updated_at, created_at,
+               ROW_NUMBER() OVER (
+                 PARTITION BY ctm_session_id
+                 ORDER BY COALESCE(NULLIF(modified_at, ''), updated_at, created_at) DESC,
+                   updated_at DESC, created_at DESC
+               ) AS rn
+          FROM agent_sessions
+      ) a ON a.ctm_session_id = c.id AND a.rn = 1
+     WHERE lower(COALESCE(c.provider, '')) = 'claude'
+       AND COALESCE(a.jsonl_path, '') <> ''${tierFilter}${idFilter}${skipFilter}
+     ORDER BY COALESCE(NULLIF(a.modified_at, ''), a.updated_at, a.created_at, '') DESC
+     LIMIT ?
+  `).all(...explicitIds, ...skipIds, limit);
+  const rows = [];
+  const scannedIds = [];
+  for (const candidate of candidates) {
+    const id = String(candidate.id || '');
+    scannedIds.push(id);
+    const jsonlPath = String(candidate.jsonl_path || '');
+    let view = null;
+    try { view = transcriptSource.statTranscriptSync(jsonlPath, { db: conn }); } catch { view = null; /* expected: a transcript rotated away between the row read and the stat — skip the row, never fatal */ }
+    if (!view || view.state === 'missing' || !(Number(view.size) > 0)) continue;
+    const size = Number(view.size);
+    const from = Math.max(0, size - tailBytes);
+    let buf = null;
+    try { buf = transcriptSource.readTranscriptRangeSync(jsonlPath, from, size, { db: conn }); } catch { continue; /* expected: an unreadable/rotating transcript — skip the row */ }
+    // Both records are kept independently (D-4); which one wins is the applier's D-5 decision,
+    // because Claude keeps re-appending ai-titles under a custom title (§1e).
+    const lines = buf.toString('utf8').split('\n');
+    if (from > 0) lines.shift(); // the window started mid-record
+    let customTitle = '';
+    let aiTitle = '';
+    for (const line of lines) {
+      const text = line.trim();
+      if (!text) continue;
+      let entry = null;
+      try { entry = JSON.parse(text); } catch { continue; /* expected: a window-edge partial line or a non-record line */ }
+      const signal = extractTitleSignalFromRecord(entry);
+      if (signal.userTitle) customTitle = signal.userTitle;
+      else if (signal.providerTitle) aiTitle = signal.providerTitle;
+    }
+    if (!customTitle && !aiTitle) continue;
+    // `jsonlPath` is the file this page actually read — the repair script prints it instead of
+    // re-deriving "the row's transcript" and risking a different answer.
+    rows.push({ id, jsonlPath, customTitle, aiTitle, tailBytes: size - from });
+  }
+  return { rows, scanned: candidates.length, scannedIds, limit };
+}
+
+module.exports = { readAgentTitleBackfillPage };

package/template/coding-task-manager/lib/api/host-stats.js

@@ -0,0 +1,98 @@
+'use strict';
+
+// WP-1 (machine-pool-picker-pairing-dashboard-2026-10-24.html §6.1, D-11/D-13): the host-stats
+// read surface. Every CTM samples its own host on the existing 60 s resource tick (no new timer —
+// the record call rides the tick server.js already runs) and keeps 24 h of one-per-minute rows;
+// this route serves them to its own picker and, through the ?machine= proxy, to a hub.
+//
+//   GET /api/host/stats?latest=1     -> { ok:true, instanceId, latest: HostSample|null }
+//   GET /api/host/stats?since=<ms>   -> { ok:true, instanceId, latest, samples: HostSample[] }
+//                                       `since` is clamped to now-24h (the retention window), so
+//                                       `?since=0` means "everything retained", never "everything
+//                                       ever" — a caller cannot ask for a row the purge dropped.
+//
+// Like lib/api/machines.js (and unlike the lib/api/*.js extraction slices) this is NEW surface
+// added by WP-1: the handler body lives here, so there is no legacy handleApi branch to delete and
+// tests-integration/api-router-parity.test.js's no-dual-dispatch rule is satisfied by construction.
+// Auth is NOT evaluated here: lib/auth-rules.js carries the row — read, NOT loopbackOnly (a phone
+// picker reads another machine through the hub), peerControl:true (D-13) — and a route with no rule
+// is 403 auth_rule_missing by design, so the rule row and this registration must land together.
+const { registerApiRoutes } = require('../api-router');
+const remoteMachineProxy = require('../remote-machine-proxy');
+
+// Mirrors lib/host-stats.js's DEFAULT_RETENTION_MS. It is the clamp floor here, so a caller asking
+// for a wider window than the sampler keeps is answered with the rows that actually exist.
+const RETENTION_MS = 24 * 60 * 60 * 1000;
+const ROUTE = 'GET /api/host/stats';
+
+let _deps = null;
+
+function configure({
+  hostStats,
+  sendJsonResponse,
+} = {}) {
+  _deps = { hostStats, sendJsonResponse };
+}
+
+function _send(res, status, payload) {
+  if (_deps && typeof _deps.sendJsonResponse === 'function') return _deps.sendJsonResponse(res, status, payload);
+  const body = JSON.stringify(payload || {});
+  res.writeHead(status, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) });
+  res.end(body);
+}
+
+// This machine's own minted id — the instanceId a hub keys the response by. Read through the
+// accessor (never re-derived here), and '' rather than a throw before boot has primed identity: a
+// 200 with an empty id is a truthful "sampler is up, identity is not yet" answer.
+function _instanceId() {
+  try {
+    const access = require('../instance-identity-access');
+    const identity = access.getInstanceIdentity({ required: false });
+    return (identity && identity.instanceId) || '';
+  } catch {
+    return ''; // expected: instance identity is not ready yet (early boot / pre-initDb)
+  }
+}
+
+// Self-contained on purpose: no countTasks/lastCreateAt here. Those two are injected into
+// lib/host-stats.js by server.js (it owns the live session map and the status bindings), so this
+// handler only reads what the sampler already wrote.
+async function handleHostStats(req, res, url) {
+  const stats = _deps && _deps.hostStats;
+  // ORDER MATTERS: the history read is the slow leg (a DB-owner round trip, ~1 ms alone but seconds
+  // under load), and `latest` is the in-memory sample. Reading `latest` FIRST lets a tick land
+  // mid-read, so the answer carries a row NEWER than the `latest` object beside it — which is exactly
+  // how this file's own assertion `latest === samples[last]` failed once on a saturated host.
+  // Reading history first makes `latest.at >= samples[last].at` hold for the whole answer.
+  const payload = { ok: true, instanceId: _instanceId(), latest: null };
+
+  const sinceRaw = url && url.searchParams ? url.searchParams.get('since') : null;
+  if (sinceRaw != null && sinceRaw !== '') {
+    const now = Date.now();
+    const floor = now - RETENTION_MS;
+    const requested = Number(sinceRaw);
+    const since = Math.min(Math.max(Number.isFinite(requested) ? Math.trunc(requested) : floor, floor), now);
+    payload.samples = stats && typeof stats.history === 'function' ? await stats.history({ sinceMs: since }) : [];
+  }
+  payload.latest = stats && typeof stats.latest === 'function' ? (stats.latest() || null) : null;
+  return _send(res, 200, payload);
+}
+
+// Remote machine hub (§6.1 / S-5): the same wrapper lib/api/misc-ops.js:41 uses. A request naming
+// another machine (?machine= or X-CTM-Machine) is forwarded to that box with the peer bearer and
+// this handler never runs; every other request is answered locally. `url` is passed through so the
+// proxied box sees the caller's own `since`.
+function _machineRouted(route, local) {
+  return (req, res, url) => (remoteMachineProxy.isMachineRouted(req, url)
+    ? remoteMachineProxy.maybeProxyMachineRequest(req, res, url, { route })
+      .then((handled) => (handled ? undefined : local(req, res, url)))
+    : local(req, res, url));
+}
+
+function register() {
+  registerApiRoutes('host-stats', [
+    { method: 'GET', path: '/api/host/stats', handler: _machineRouted(ROUTE, (req, res, url) => handleHostStats(req, res, url)) },
+  ]);
+}
+
+module.exports = { configure, register, handleHostStats };

package/template/coding-task-manager/lib/api/ingress.js

@@ -69,27 +69,50 @@ function collectHook(req, res, onPayload) {
   });
 }
 
-// A lead hears its delegated worker stopped on its next PostToolUse / UserPromptSubmit hook.
+// A lead hears its delegated worker stopped on its next PostToolUse / UserPromptSubmit hook, and --
+// RC-1 (D-1..D-4/D-6) -- on its Stop hook, which is answered synchronously with the drained notices
+// plus a nudge when the lead still owns a live worker and nothing pending will wake it.
 // A notice counts as delivered only once the response carrying it finished (was handed to the
 // socket); a response that closes or errors first re-queues it in memory for the next hook.
-function workerNoticeBody(route, payload, res) {
+function workerNoticeBody(route, payload, res, verdict) {
   const isPrompt = route === 'start' && payload.hook_event_name === 'UserPromptSubmit';
+  const isToolUse = route === 'PostToolUse';
+  const isStop = route === 'stop';
   const leadId = typeof payload.ctm_id === 'string' ? payload.ctm_id : '';
-  if ((route !== 'PostToolUse' && !isPrompt) || !leadId) return undefined;
+  if ((!isToolUse && !isPrompt && !isStop) || !leadId) return undefined;
+  // D-4: the loop guard counts TOOL CALLS, so every PostToolUse advances the epoch even when the
+  // lead has no notice waiting.
+  if (isToolUse) workerNotices.noteLeadToolUse(leadId);
+  // D-6: a Stop that arrived after a newer UserPromptSubmit is stale -- no notices and no nudge.
+  if (isStop && verdict && verdict.stale) return undefined;
   const drained = workerNotices.drainNotices(leadId, { now: Date.now(), dbModule: _deps.dbModule || null, delegateWorker: _deps.delegateWorker || null });
-  if (!drained.notices.length) return undefined;
-  if (res && typeof res.once === 'function') {
-    res.once('finish', () => drained.commit());
-    res.once('close', () => drained.abandon()); // after 'finish' this is a no-op
-    res.once('error', () => drained.abandon());
-  } else drained.commit();
-  return { notices: drained.notices.map((n) => ({ receipt_id: n.receipt_id, text: n.text })) };
+  const nudge = isStop
+    ? workerNotices.stopNudge(leadId, { backgroundTasks: payload.background_tasks, sessionCrons: payload.session_crons })
+    : null;
+  if (!drained.notices.length && !nudge) return undefined;
+  // §7: one session_diagnostics row per nudge, so the RC-1 census can count leads that were held.
+  if (nudge && typeof _deps.recordSessionDiagnostic === 'function') {
+    try { _deps.recordSessionDiagnostic(leadId, 'lead-stop-nudge', { workers: nudge.workers, background_running: false }); }
+    catch (err) { console.error('[worker-notices] lead-stop-nudge diagnostic failed:', err && err.message); }
+  }
+  if (drained.notices.length) {
+    if (res && typeof res.once === 'function') {
+      res.once('finish', () => drained.commit());
+      res.once('close', () => drained.abandon()); // after 'finish' this is a no-op
+      res.once('error', () => drained.abandon());
+    } else drained.commit();
+  }
+  const notices = drained.notices.map((n) => ({ receipt_id: n.receipt_id, text: n.text }));
+  // A nudge is not a receipt-backed notice, so it carries no receipt_id.
+  if (nudge) notices.push({ receipt_id: null, text: nudge.text });
+  return { notices };
 }
 
 function handleClaudeHook(req, res, url) {
   const route = url.pathname.slice('/hook/claude/'.length);
   collectHook(req, res, (payload) => {
-    _deps.telemetryReceiver.hookClaude(route, payload);
+    // D-1/D-6: the Stop verdict says whether this Stop is stale; the notice body needs it.
+    const verdict = _deps.telemetryReceiver.hookClaude(route, payload);
     // WP-1 (native-subagent-sidebar-rows-2026-10-12 §5 D-4, §9 S-8): feed the lead's native
     // subagent lifecycle from the same hook stream. Best-effort -- a runtime failure never fails
     // the hook (the telemetry receiver above already owns the status/background writes).
@@ -100,7 +123,7 @@ function handleClaudeHook(req, res, url) {
     // go through the separate activity adapter and never rewrite resume cwd.
     if (!['PostToolUse', 'PostToolUseFailure', 'CwdChanged'].includes(route)) _deps.observeHookCwd(payload, `claude.${route}`);
     if (typeof _deps.observeWorkspaceActivity === 'function') _deps.observeWorkspaceActivity('claude', route, payload);
-    try { return workerNoticeBody(route, payload, res); } catch { return undefined; /* expected: a notice failure never fails the hook */ }
+    try { return workerNoticeBody(route, payload, res, verdict); } catch { return undefined; /* expected: a notice failure never fails the hook */ }
   });
 }