create-walle 0.10.0 → 0.10.2

package/template/coding-task-manager/lib/session-lifecycle.js

@@ -128,9 +128,6 @@ function lifecycleConfigFromEnv(env = process.env) {
     prewarm: envBool(env, 'CTM_PREWARM', false),
     prewarmTtlMs: envInt(env, 'CTM_PREWARM_TTL_MS', 60_000, 1_000),
     prewarmTopK: envInt(env, 'CTM_PREWARM_TOP_K', 1, 1),
-    freezeTier: idlePark && envBool(env, 'CTM_FREEZE_TIER', false),
-    freezeAfterMs: envInt(env, 'CTM_FREEZE_AFTER_MS', 15 * 60_000, 1_000),
-    freezeParkAfterMs: 2 * 60 * 60_000,
     // WP-3: default is derived from host RAM (see defaultSessionRssBudgetMB), so the
     // MemoryBudgetController is live out of the box. `CTM_SESSION_RSS_BUDGET_MB=0`
     // remains the explicit disable — a 0 budget makes observe() inert again.
@@ -147,11 +144,7 @@ function lifecycleConfigFromEnv(env = process.env) {
 
 function automaticParkSweepPolicy(config, options = {}) {
   const pressure = ['warn', 'critical'].includes(options.pressure) ? options.pressure : 'normal';
-  const freezeTier = options.freezeTier === true;
-  const configuredThresholdMs = Math.max(0, Number(config?.idleParkAfterMs) || 0);
-  const idleParkAfterMs = freezeTier
-    ? Math.max(configuredThresholdMs, Number(config?.freezeParkAfterMs) || 0)
-    : configuredThresholdMs;
+  const idleParkAfterMs = Math.max(0, Number(config?.idleParkAfterMs) || 0);
   const disconnectCollapseMs = Math.max(
     idleParkAfterMs,
     Number(config?.disconnectCollapseMs) || 0,
@@ -223,7 +216,7 @@ function normalizeClientKind(value) {
 function evaluatePark(session, host, config) {
   const now = Number(host?.now) || Date.now();
   const protections = [];
-  if (!session || !['live', 'frozen'].includes(session.state)) protections.push('not-live');
+  if (!session || session.state !== 'live') protections.push('not-live');
   if (session?.resumable === false) protections.push('not-resumable'); if (session?.parkable === false) protections.push('not-parkable-class');
   if (session?.liveStatus === 'running' || session?.liveStatus === 'generating' || session?.liveStatus === 'working') protections.push('running');
   if (session?.liveStatus === 'waiting_input' || session?.liveStatus === 'resuming') protections.push('waiting-input');
@@ -490,37 +483,6 @@ function describePressureCause(signals = {}, thresholds = {}, effectiveLevel = '
     || { kind: 'recovering', level, value: null };
 }
 
-function evaluateFreeze(session, host, config) {
-  if (config?.freezeTier !== true) {
-    return { eligible: false, protections: ['disabled'], idleMs: 0, thresholdMs: Number(config?.freezeAfterMs) || 0 };
-  }
-  if (!session || session.state !== 'live') {
-    return { eligible: false, protections: ['not-live'], idleMs: 0, thresholdMs: Number(config?.freezeAfterMs) || 0 };
-  }
-  return evaluatePark(session, host, {
-    ...config,
-    idleParkAfterMs: Number(config.freezeAfterMs) || 15 * 60_000,
-    disconnectCollapseMs: Number(config.freezeAfterMs) || 15 * 60_000,
-  });
-}
-
-function selectFreezeVictim(sessions, host, config) {
-  const eligible = [];
-  for (const session of sessions || []) {
-    const result = evaluateFreeze(session, host, config);
-    if (result.eligible) eligible.push({ session, result });
-  }
-  eligible.sort((a, b) => {
-    const activityDelta = (Number(a.session.lastMeaningfulActivityAt) || 0)
-      - (Number(b.session.lastMeaningfulActivityAt) || 0);
-    if (activityDelta !== 0) return activityDelta;
-    const rssDelta = sessionMemoryMB(b.session) - sessionMemoryMB(a.session);
-    if (rssDelta !== 0) return rssDelta;
-    return String(a.session.id).localeCompare(String(b.session.id));
-  });
-  return eligible[0]?.session || null;
-}
-
 class PressureController {
   constructor() {
     this.level = 'normal';
@@ -766,6 +728,10 @@ function percentile(values, ratio) {
   return sorted[Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * ratio) - 1))];
 }
 
+// WP-3 (§5 D-8): the skip-reason vocabulary lives in its own module (so server.js can name tokens
+// without growing); re-exported here for the existing importers.
+const { WAKE_SKIP_REASONS } = require('./wake-skip-reasons');
+
 class LifecycleDiagnostics {
   constructor({ maxEvents = 200 } = {}) {
     this.maxEvents = Math.max(1, maxEvents);
@@ -773,12 +739,15 @@ class LifecycleDiagnostics {
     this.activationByClient = {};
     this.parkByReason = {};
     this.prewarmByOutcome = {};
-    this.freezeByAction = {};
     this.shadow = { candidates: 0, falsePositives: 0, projectedReclaimMB: 0 };
     this.pressureTransitions = 0;
     this.events = [];
     this.wake = new Map();
     this.wakeOutcomes = {};
+    // WP-3 (§5 D-6): skip-reason counter for the pre-gate deferred-restore bails -- the ones that
+    // precede _wakeStartedAt and so can never be counted by wakeOutcomes ("65 deferred, zero
+    // wakes" was invisible for exactly this reason).
+    this.wakeSkips = {};
   }
 
   _count(target, key) { target[key] = (target[key] || 0) + 1; }
@@ -813,12 +782,6 @@ class LifecycleDiagnostics {
     this._event({ type: 'prewarm', id, outcome: normalized, reason: String(reason || '').slice(0, 48) });
   }
 
-  recordFreeze({ id, action, idleMs = 0, reason = '' }) {
-    const normalized = String(action || 'unknown').slice(0, 32);
-    this._count(this.freezeByAction, normalized);
-    this._event({ type: 'freeze', id, action: normalized, idleMs: Math.max(0, idleMs), reason: String(reason || '').slice(0, 48) });
-  }
-
   recordShadow({ id, action = 'candidate', rssMB = 0, activityAfterMs = 0, reason = '', signals = {} }) {
     if (action === 'candidate') {
       this.shadow.candidates += 1;
@@ -863,6 +826,14 @@ class LifecycleDiagnostics {
     this._event({ type: 'wake-outcome', id, provider, outcome, phases: { ...phases } });
   }
 
+  // WP-3 (§5 D-6/D-8): the sibling of recordWakeOutcome for the pre-gate bails. `reason` is a
+  // WAKE_SKIP_REASONS token (CamelCase, machine-readable — the K8s-condition convention); a
+  // caller that still passes a legacy human string is recorded verbatim rather than dropped.
+  recordWakeSkip({ id = '', provider = 'unknown', reason = 'Unclassified' } = {}) {
+    this._count(this.wakeSkips, reason);
+    this._event({ type: 'wake-skip', id, provider, reason });
+  }
+
   snapshot(extra = {}) {
     const wakeLatency = {};
     for (const [provider, entry] of this.wake) {
@@ -876,10 +847,10 @@ class LifecycleDiagnostics {
       activationByClient: { ...this.activationByClient },
       parkByReason: { ...this.parkByReason },
       prewarmByOutcome: { ...this.prewarmByOutcome },
-      freezeByAction: { ...this.freezeByAction },
       shadow: { ...this.shadow },
       pressureTransitions: this.pressureTransitions,
       wakeOutcomes: { ...this.wakeOutcomes },
+      wakeSkips: { ...this.wakeSkips },
       wakeLatency,
       events: [...this.events],
       ...extra,
@@ -890,6 +861,7 @@ class LifecycleDiagnostics {
 module.exports = {
   ActivationGate,
   LifecycleDiagnostics,
+  WAKE_SKIP_REASONS,
   MemoryBudgetController,
   PressureController,
   automaticParkSweepPolicy,
@@ -901,11 +873,9 @@ module.exports = {
   classifyWakeOutcome,
   derivePressure,
   describePressureCause,
-  evaluateFreeze,
   evaluateManualPark,
   evaluatePark,
   summarizeParkEligibility,
-  selectFreezeVictim,
   selectParkVictim,
   sessionMemoryMB,
 };

package/template/coding-task-manager/lib/session-model-action-preconditions.js

@@ -72,6 +72,28 @@ function parkRefusalDetail(protections) {
   return 'The session could not be restarted right now. Try again in a moment.';
 }
 
+// WP-0 D-10: a refusal code with no hand-written sentence still gets a family sentence that NAMES
+// the code, so no refusal can reach the person as a generic line. Checked after the explicit map and
+// before any caller-supplied message.
+const HISTORY_REFUSAL_FAMILIES = Object.freeze([
+  [/^unsupported_native_/, 'This history carries a record type that has not been qualified for transfer.'],
+  [/^native_world_state_/, 'The native Codex world state could not be replayed safely.'],
+  [/^native_history_/, 'The native Codex history could not be prepared for transfer.'],
+  [/^tool_call_/, 'This history has an incomplete tool exchange, so it cannot be transferred safely.'],
+  [/^history_/, 'The source history could not be verified for this provider change.'],
+  [/^source_/, 'The source session could not be verified for this provider change.'],
+  [/^target_/, 'The target session could not be verified for this provider change.'],
+  [/^fork_/, 'The native fork could not be verified in Codex history.'],
+  [/^native_(?:rpc|process|fork|adapter|readback|initialize)_/, 'The native Codex process could not complete the handoff.'],
+]);
+
+function historyRefusalFamilyMessage(reason, tail) {
+  for (const [pattern, sentence] of HISTORY_REFUSAL_FAMILIES) {
+    if (pattern.test(reason)) return `${sentence} (code: ${reason}) ${tail}`;
+  }
+  return '';
+}
+
 // History checks run before the source is parked. Keep their bounded reason codes useful to the
 // person making the change without exposing scanner records, paths, or provider credentials.
 function historyPreparationMessage(reason, suppliedMessage = '', { postPark = false } = {}) {
@@ -83,10 +105,13 @@ function historyPreparationMessage(reason, suppliedMessage = '', { postPark = fa
       source_checkpoint_changed_after_park: `The source checkpoint changed during handoff verification. ${recovery}`,
       source_config_policy_unqualified: `The captured Codex configuration changed during handoff verification. ${recovery}`,
       native_history_control_failed: `Codex could not create the native history checkpoint. ${recovery}`,
+      native_handoff_inject_failed: `The handoff summary could not be written into the new Codex thread. ${recovery}`,
+      fork_target_handoff_missing: `The new Codex thread does not prove it received the handoff summary for its encrypted history. ${recovery}`,
       fork_readback_unverified: `The native fork could not be verified in Codex history. ${recovery}`,
       fork_journal_owner_changed: `The transition owner changed during handoff. ${recovery}`,
     };
-    return messages[reason] || `The target handoff could not be verified. ${recovery}`;
+    return messages[reason] || historyRefusalFamilyMessage(reason, recovery)
+      || `The target handoff could not be verified. ${recovery}`;
   }
   const messages = {
     native_target_profile_unavailable: 'The native Codex model does not publish the context limits needed to verify this history move. The current session is still running unchanged.',
@@ -100,7 +125,6 @@ function historyPreparationMessage(reason, suppliedMessage = '', { postPark = fa
     // WP-2 (docs/codex-encrypted-history-lead-switch-2026-10-17.html §5/§8): the name stays; the copy
     // now says what the user actually has (an encrypted summary) and what did NOT happen to them.
     encrypted_history_not_portable: 'Earlier history exists only as an encrypted summary that the target model cannot read, so it cannot be carried over. The current session is still running unchanged.',
-    compacted_source_fork_unqualified: 'This source history was compacted, and its active checkpoint cannot yet be verified across providers. The current session is still running unchanged.',
     source_compaction_unqualified: 'The source history is too large for the target, and safely compacting it is not supported yet. The current session is still running unchanged.',
     history_estimate_unknown: 'The source history size could not be verified safely. The current session is still running unchanged.',
     target_compaction_hash_unknown: 'The target profile cannot verify the source history compaction settings. The current session is still running unchanged.',
@@ -109,9 +133,41 @@ function historyPreparationMessage(reason, suppliedMessage = '', { postPark = fa
     unpaired_tool_history: 'This history has an incomplete tool exchange, so it cannot be transferred safely. The current session is still running unchanged.',
     source_origin_unknown: 'The source provider could not be verified. The current session is still running unchanged.',
     source_origin_unsupported: 'This source provider has no qualified history handoff yet. The current session is still running unchanged.',
+    transition_cancelled: 'The history check was cancelled before it finished. The current session is still running unchanged.',
+    history_scan_incomplete: 'The source history scan did not finish, so nothing was moved. The current session is still running unchanged.',
+    source_checkpoint_unknown: 'The source history has no verified checkpoint to carry over. The current session is still running unchanged.',
+    source_previous_model_mismatch: 'The model recorded on the source history does not match the captured source model. The current session is still running unchanged.',
+    source_model_changed: 'The source model changed while the history was being prepared. The current session is still running unchanged.',
+    lead_source_changed: 'The source session this switch started from is no longer the live one. The current session is still running unchanged.',
+    provider_identity_unknown: 'The source or target provider for this history move could not be identified. The current session is still running unchanged.',
+    target_budget_unknown: 'The target model does not publish the context budget needed to carry this history over. The current session is still running unchanged.',
+    history_estimate_evidence_unknown: 'The source history size was measured, but not in a way that can be verified for this move. The current session is still running unchanged.',
+    compaction_hash_mismatch: 'The source and target history compaction settings disagree, so the move cannot be verified safely. The current session is still running unchanged.',
+    native_transition_policy_unknown: 'The Codex permission policy for the source or the target could not be read. The current session is still running unchanged.',
+    native_transition_policy_mismatch: 'The Codex permission policy on the target differs from the source, so the history cannot be moved safely. The current session is still running unchanged.',
+    native_fork_adapter_unqualified: 'This Codex installation or adapter is not qualified to carry this history over. The current session is still running unchanged.',
+    native_policy_override_unqualified: 'This source session uses a Codex policy override that cannot yet be reproduced safely for history transfer. The current session is still running unchanged.',
+    native_token_usage_record_invalid: 'The Codex usage record for this session could not be verified, so the history size cannot be trusted. The current session is still running unchanged.',
+    history_media_not_portable: 'This history contains an image, and the target model cannot receive images. The current session is still running unchanged.',
+    // WP-2 (docs/codex-lead-routed-switch-history-handoff-2026-10-21.html §5 D-5/D-6, §6.5): the
+    // encrypted-compaction path. The source model writes a plaintext handoff before the switch, and
+    // each way that handoff can fail says which one it was.
+    encrypted_compaction_multiple: 'This history holds more than one encrypted compaction, and only one of them can be replaced by a handoff summary. The current session is still running unchanged.',
+    encrypted_compaction_handoff_unavailable: 'This history exists only as an encrypted summary, and the model that wrote it cannot be asked to write a plaintext handoff for this provider change. The current session is still running unchanged.',
+    handoff_fork_failed: 'The handoff summary could not be started from this session\'s history. The current session is still running unchanged.',
+    handoff_turn_failed: 'The source model did not finish writing the handoff summary. The current session is still running unchanged.',
+    handoff_empty: 'The source model returned a handoff summary that is too short to carry this history over. The current session is still running unchanged.',
+    handoff_too_long: 'The source model returned a handoff summary that is too long to carry this history over. The current session is still running unchanged.',
+    handoff_marker_in_text: 'The handoff summary contains text reserved for this move, so it cannot be trusted. The current session is still running unchanged.',
+    handoff_timeout: 'The source model did not finish writing the handoff summary in time. The current session is still running unchanged.',
+    // Raised while the forked target is being written, but the code is enumerated from its own
+    // source file, so it carries a sentence on both paths rather than falling back to the generic one.
+    native_handoff_inject_failed: 'The handoff summary could not be written into the new Codex thread. The current session is still running unchanged.',
   };
   const safe = typeof suppliedMessage === 'string' ? suppliedMessage.trim().slice(0, 240) : '';
-  return messages[reason] || safe || 'History could not be verified for this provider change. The current session is still running unchanged.';
+  return messages[reason]
+    || historyRefusalFamilyMessage(reason, 'The current session is still running unchanged.')
+    || safe || 'History could not be verified for this provider change. The current session is still running unchanged.';
 }
 
 function refusal(status, code, extra) {
@@ -371,6 +427,15 @@ function reconstructSessionModelTransitionSource({ sessionId, source, sourceLaun
       const rebound = require('./launch-model-override').ensureCodexResumeTarget(args, source.providerThreadId);
       if (!rebound.ok) return null;
       args = rebound.args;
+    } else if (agent === 'claude') {
+      // The SAME canonical normalization for a native Claude source: the recorded capture may name its
+      // own thread through an explicit `--session-id` (the identity CTM injected at startup) and may
+      // still carry that launch's original positional prompt. Only the canonical owner's own
+      // `--resume <source thread>` is the source recipe, so the existing extractor below reads a
+      // rebound argv instead of rejecting the capture outright.
+      const rebound = require('./launch-model-override').ensureClaudeResumeTarget(args, source.providerThreadId);
+      if (!rebound.ok) return null;
+      args = rebound.args;
     }
     if ((require('./session-history').extractResumeTarget(agent, args)?.sessionId || '') !== String(source.providerThreadId)) return null;
     return { ...context, args };

package/template/coding-task-manager/lib/session-resource-sampler.js

@@ -79,14 +79,14 @@ function splitAgentDescendantRows(rows, agentPid) {
   const agentRssMB = agentRow ? Math.round(((Number(agentRow.rssKB) || 0) / 1024) * 100) / 100 : 0;
   const pending = [...(byParent.get(agentPid) || [])];
   const seen = new Set();
-  let descendantRssKB = 0, descendantGroupLeaderCount = 0; // D-10: a descendant leading its own process group (a background shell's wrapper)
+  let descendantRssKB = 0, descendantCpuTimeMs = 0, descendantGroupLeaderCount = 0; // D-10: a descendant leading its own process group (a background shell's wrapper)
   while (pending.length) {
     const pid = pending.pop();
     if (seen.has(pid)) continue;
     seen.add(pid);
     const row = byPid.get(pid);
     if (!row) continue;
-    descendantRssKB += Number(row.rssKB) || 0; if (row.pgid === row.pid) descendantGroupLeaderCount += 1;
+    descendantRssKB += Number(row.rssKB) || 0; descendantCpuTimeMs += Number(row.cpuTimeMs) || 0; if (row.pgid === row.pid) descendantGroupLeaderCount += 1;
     pending.push(...(byParent.get(pid) || []));
   }
   return {
@@ -99,7 +99,7 @@ function splitAgentDescendantRows(rows, agentPid) {
     // invisible to a pgid-only rollup).
     descendantPids: [...seen],
     descendantGroupLeaderCount,
-    descendantRssMB: Math.round((descendantRssKB / 1024) * 100) / 100,
+    descendantRssMB: Math.round((descendantRssKB / 1024) * 100) / 100, descendantCpuTimeMs, // WP-0 (bg-shell-liveness): Σ cpuTimeMs of every visited descendant
   };
 }
 
@@ -126,6 +126,33 @@ function parseFootprintJson(text) {
   return results;
 }
 
+// WP-A P-1 (freeze-probes): the CATEGORIZED `footprint -j` document (no `--noCategories`) --
+// { unit, 'bytes per unit', processes: [{ pid, footprint, categories: { name: { dirty, swapped, ... } } }] }.
+// The 4<->9 GB server swing measured 2026-10-21 lives entirely in the "Malloc Large" category, which
+// the --noCategories summary above cannot name. Pure; returns { totalMB, top: [{name,dirtyMB,swappedMB}] }
+// for the FIRST process, null for unparseable input or a non-byte unit (same rules as parseFootprintJson).
+function parseFootprintRegions(text) {
+  let doc;
+  try { doc = JSON.parse(String(text ?? '')); } catch { return null; } // not JSON at all (empty stdout on a failed run)
+  if (!doc || typeof doc !== 'object' || Array.isArray(doc)) return null;
+  if (doc.unit !== 'byte') return null;
+  const bytesPerUnit = Number(doc['bytes per unit']) || 1;
+  const proc = (Array.isArray(doc.processes) ? doc.processes : []).find(entry => entry && typeof entry === 'object');
+  if (!proc) return null;
+  const mb = (bytes) => Math.round((bytes / 1048576) * 10) / 10;
+  const rows = Object.entries(proc.categories && typeof proc.categories === 'object' ? proc.categories : {})
+    .map(([name, region]) => {
+      const dirty = (Number(region?.dirty) || 0) * bytesPerUnit;
+      const swapped = (Number(region?.swapped) || 0) * bytesPerUnit;
+      return { name: String(name).slice(0, 40), dirtyMB: mb(dirty), swappedMB: mb(swapped), total: dirty + swapped };
+    })
+    .sort((a, b) => b.total - a.total);
+  return {
+    totalMB: Number.isFinite(proc.footprint) ? mb(proc.footprint * bytesPerUnit) : null,
+    top: rows.slice(0, 6).map(({ name, dirtyMB, swappedMB }) => ({ name, dirtyMB, swappedMB })),
+  };
+}
+
 // Cleanup never turns an already-decided sample (number or D-3 null) into a rejected sweep.
 function removeTempFileQuietly(file) {
   return fs.promises.rm(file, { force: true }).then(() => true, () => false);
@@ -441,18 +468,28 @@ class SessionResourceSampler {
     return { agentPid: Number(agentPid), descendantPids: split.descendantPids, descendantGroupLeaderCount: split.descendantGroupLeaderCount };
   }
 
+  // D-9 (WP-6, clock-free-tests-followups-2026-10-23 §5 D-9/§8 WP-6): ONE whole-table read a caller
+  // can share across every rollup in one sweep. Same command/args/limits as sampleProcessGroup's own
+  // read, and the same maxBuffer: `ps -axo …` prints ~1.37 MB on this host, above Node's 1 MiB default.
+  async sampleProcessTable() {
+    const psCommand = this.platform === 'darwin' ? '/bin/ps' : 'ps';
+    const { stdout } = await this.exec(psCommand, PS_ARGS, { timeout: 10_000, maxBuffer: 8 * 1024 * 1024 });
+    return parseProcessTable(stdout);
+  }
+
   // D-4: the post-kill census. One ps read; the pgid rollup as before, plus every row whose pid is in
   // `descendantPidsBefore` (and not already in the group). Survivors are merged into pids/procCount/rssMB/cpuPct.
   // A call with no second argument (every pre-existing caller) behaves exactly as before.
-  async sampleProcessGroup(pgid, descendantPidsBefore = []) {
-    const psCommand = this.platform === 'darwin' ? '/bin/ps' : 'ps';
-    const { stdout } = await this.exec(psCommand, PS_ARGS, { timeout: 10_000, maxBuffer: 8 * 1024 * 1024 });
-    const rows = parseProcessTable(stdout);
-    const group = rollupProcessGroup(rows, pgid);
+  // D-9: `{ rows }` lets a sweep hand in the ONE table it already read (sampleProcessTable above) —
+  // then this call execs nothing. The rollup/survivor logic below is shared verbatim by both paths,
+  // so a caller that supplies rows cannot diverge from one that does not.
+  async sampleProcessGroup(pgid, descendantPidsBefore = [], { rows = null } = {}) {
+    const table = Array.isArray(rows) ? rows : await this.sampleProcessTable();
+    const group = rollupProcessGroup(table, pgid);
     const before = new Set((descendantPidsBefore || []).map(Number));
     if (!before.size) return group;
     const have = new Set(group.pids);
-    const survivors = rows.filter(row => before.has(Number(row.pid)) && !have.has(row.pid)).sort((a, b) => a.pid - b.pid);
+    const survivors = table.filter(row => before.has(Number(row.pid)) && !have.has(row.pid)).sort((a, b) => a.pid - b.pid);
     if (!survivors.length) return group;
     const rssKB = survivors.reduce((sum, row) => sum + (Number(row.rssKB) || 0), 0);
     const cpuPct = survivors.reduce((sum, row) => sum + (Number(row.cpuPct) || 0), 0);
@@ -540,6 +577,26 @@ class SessionResourceSampler {
     return results;
   }
 
+  // WP-A P-1: ONE fresh categorized `/usr/bin/footprint -j <tmp> <pid>` for the MAIN pid, every call.
+  // Deliberately NOT the TTL-cached sampleFootprints() path: a stale cache entry cannot name the region
+  // that just grew. Same gate/tmp/limits/cleanup mechanics as _sampleFootprintBatch, minus the cache.
+  // Never rejects: null on non-darwin, on the primary-only gate, or on any failure. Categorized
+  // `footprint` does not suspend its target (measured 2026-10-21), unlike vmmap/sample/leaks.
+  async sampleFootprintRegions(pid) {
+    const key = Number(pid);
+    if (this.platform !== 'darwin' || !(key > 0)) return null;
+    if (this.exec === execFileAsync && !hostIdentityAccessAllowed({ env: this.env })) return null;
+    const tmp = path.join(os.tmpdir(), `ctm-footprint-regions-${process.pid}-${crypto.randomUUID()}.json`);
+    try {
+      await this.exec(FOOTPRINT_BIN, ['-j', tmp, String(key)], { timeout: 10_000, maxBuffer: 4 * 1024 * 1024 });
+      return parseFootprintRegions(await fs.promises.readFile(tmp, 'utf8'));
+    } catch {
+      return null; // footprint missing/denied or temp file unreadable (D-3: null, never a throw)
+    } finally {
+      await removeTempFileQuietly(tmp);
+    }
+  }
+
   // D-1: sweep counterpart to sampleFootprints() (same batch and TTL cache), resolving to
   // `{ footprintMB, sampledAt }` per pid so a consumer can tell how fresh an entry is.
   async sampleFootprintSnapshots({ pids, now } = {}) {
@@ -558,6 +615,7 @@ module.exports = {
   FOOTPRINT_SAMPLE_TTL_MS,
   hostMemoryFromVmStat,
   parseFootprintJson,
+  parseFootprintRegions,
   parseMemoryPressure,
   parsePageouts,
   parseProcessTable,

package/template/coding-task-manager/lib/session-standup.js

@@ -882,6 +882,15 @@ function classifySessionStandup(session, signals = {}, now = Date.now()) {
     resume: session?.resume?.schemaVersion === 2 ? session.resume : null,
     priority: LANE_ORDER.get(lane) ?? 99, backgroundWork: session?.backgroundWork || null, statusReason: session?.statusReason || '',
     verdictAt: Number(session?.verdictAt) || Number(session?.liveStatusAt) || 0,
+    // WP-3 (remote-hub-followups D-9): the machine tag rides the card IFF the input session carries
+    // it. `_buildStandupSnapshot` stamps local standup sessions EMPTY and remote (box) sessions with
+    // the registry values, but ONLY when at least one machine is registered — so a zero-machine hub
+    // adds no key here and its snapshot stays byte-identical to the pre-WP-3 output (AC-3a).
+    ...(session && Object.prototype.hasOwnProperty.call(session, 'machine') ? {
+      machine: String(session.machine == null ? '' : session.machine).trim(),
+      machineName: String(session.machineName == null ? '' : session.machineName).trim(),
+      machineHealth: String(session.machineHealth == null ? '' : session.machineHealth).trim(),
+    } : {}),
   };
   // WP1C: the card's bounded own/null authority fields and its shared model label, applied to THIS card
   // object after it is built (see applyStandupModelAuthority in ./coding-session-model-public).
@@ -970,13 +979,13 @@ function isStandupStartupTaskSeedEnabled(env = process.env) {
 // existing classifier can run through unmodified, so a "seeded" card gets exactly the same
 // lane/priority logic as a live one — just starting from persisted metadata instead of a
 // live stream.
-function startupTaskPlaceholderSession(task) {
+function startupTaskPlaceholderSession(task, titleInfo) {
   if (!task) return null;
   const id = String(task.session_id || task.ctm_session_id || '').trim();
   if (!id) return null;
   const placeholder = {
     id,
-    label: task.label || '',
+    label: String(titleInfo?.title || '').trim() || task.label || '', // D-13/S-26: durable ctm_sessions title; echo only if no row
     cmd: task.cmd || '',
     cwd: task.cwd || '',
     project: task.cwd || '',
@@ -1015,15 +1024,16 @@ function startupTaskPlaceholderSession(task) {
 // a startup task appearing more than once). Callers union the result onto their live session
 // list; kept separate (rather than mutating/returning a merged array) so the server can push
 // each placeholder through the same standupPairs/attention wiring live sessions use.
-function selectUnmatchedStartupTaskPlaceholders(existingSessions, startupTasks) {
+function selectUnmatchedStartupTaskPlaceholders(existingSessions, startupTasks, titlesForIds) {
   const seen = new Set();
   for (const session of existingSessions || []) {
     const id = String(session?.id || session?.sessionId || '').trim();
     if (id) seen.add(id);
   }
+  const titlesById = typeof titlesForIds === 'function' ? titlesForIds((startupTasks || []).map((t) => t?.session_id || t?.ctm_session_id).filter(Boolean)) : null; // D-13/S-26: ONE batched read, never per row
   const placeholders = [];
   for (const task of startupTasks || []) {
-    const placeholder = startupTaskPlaceholderSession(task);
+    const placeholder = startupTaskPlaceholderSession(task, titlesById?.get?.(task?.session_id || task?.ctm_session_id));
     if (!placeholder || seen.has(placeholder.id)) continue;
     seen.add(placeholder.id);
     placeholders.push(placeholder);
@@ -1031,6 +1041,57 @@ function selectUnmatchedStartupTaskPlaceholders(existingSessions, startupTasks)
   return placeholders;
 }
 
+// WP-3 (D-9): the statuses a REMOTE (box) session row can carry that mean its PTY is live. A row
+// whose box reports a parked/exited/stopped look (the sync-mirror or last-good degradation) is not
+// live. The hub never consults a LOCAL PTY helper for these rows — they are not on this host.
+const REMOTE_ROW_LIVE_STATUSES = new Set([
+  'running', 'busy', 'active', 'working', 'thinking',
+  'waiting_input', 'waiting_for_input', 'waiting',
+  'resuming', 'restoring', 'restarting',
+]);
+
+/** The box's own liveness for a remote catalog row (never a local PTY check). */
+function remoteRowTerminalLive(row) {
+  // The row's OWN status decides when it carries one (a live reachable box row, or the at-rest
+  // mirror's 'parked'); the boolean flags are only a fallback for a row that has no status.
+  const status = String(row?.standupStatus || row?.liveStatus || row?.status || row?.lifecycleState || '')
+    .trim().toLowerCase().replace(/[-\s]+/g, '_');
+  if (status) return REMOTE_ROW_LIVE_STATUSES.has(status);
+  return row?.terminalLive === true || row?.terminal_live === true
+    || row?.activeCtmSession === true || row?.active_ctm_session === true
+    || row?.runtimeActive === true || row?.runtime_active === true;
+}
+
+/**
+ * WP-3 (D-9): a session-shaped object for one row of `remoteMachineCatalog.remoteRows()`, ready for
+ * the same `classifySessionStandup` the local sessions map goes through (`summary: null` — a box row
+ * has no local stream summary). Liveness comes from the row's OWN status; no local PTY helper runs.
+ *
+ * @param {object} row a remote catalog row (already machine-tagged by remoteRows())
+ * @param {{instanceId?: string, displayName?: string, health?: string}} [machineFacts] fallback tag
+ */
+function remoteStandupSession(row, machineFacts = {}) {
+  const source = row && typeof row === 'object' ? row : {};
+  const terminalLive = remoteRowTerminalLive(source);
+  const rawStatus = String(source.standupStatus || source.liveStatus || source.status || '').trim();
+  const standupStatus = rawStatus
+    ? rawStatus.toLowerCase().replace(/[-\s]+/g, '_')
+    : (terminalLive ? 'running' : 'parked');
+  return {
+    ...source,
+    machine: String(source.machine || machineFacts.instanceId || '').trim(),
+    machineName: String(source.machineName || machineFacts.displayName || '').trim(),
+    machineHealth: String(source.machineHealth || machineFacts.health || '').trim(),
+    terminalLive,
+    terminal_live: terminalLive,
+    activeCtmSession: terminalLive,
+    active_ctm_session: terminalLive,
+    runtimeActive: terminalLive,
+    runtime_active: terminalLive,
+    standupStatus,
+  };
+}
+
 function buildSessionStandupSnapshot({ sessions = [], summaries = [], statuses = [], now = Date.now() } = {}) {
   const summaryIndex = buildIndex(summaries);
   const statusIndex = buildIndex(statuses);
@@ -1070,6 +1131,8 @@ module.exports = {
   startupTaskPlaceholderSession,
   selectUnmatchedStartupTaskPlaceholders,
   isStandupStartupTaskSeedEnabled,
+  remoteRowTerminalLive,
+  remoteStandupSession,
   _private: {
     normalizeStatus,
     normalizeProvider,

package/template/coding-task-manager/lib/session-status-ledger.js

@@ -72,6 +72,7 @@ const BOUNDARY_CLOSERS = new Set(['end_turn', 'interrupt']);
 const BG_END_STATUSES = new Set(['completed', 'failed', 'killed', 'stopped']);
 // renewal span, and the backstop expiry when no process sample arrives (busy-background-shell design D-3); the CLI has no local cap since 2.1.288
 const BG_SHELL_MAX_MS = 2 * 3600_000 + 5 * 60_000;
+const BG_QUIET_MS = 30 * 60_000;
 const BG_DECLARED_MAX_MS = 6 * 3600_000;
 const BG_LABEL_MAX = 160;
 const BG_VIEW_TASKS_MAX = 8;
@@ -189,6 +190,7 @@ class SessionStatusLedger {
       next.set(n.id, {
         ...n, firstSeenAt, expiresAt: keep ? Math.max(Number(prev.expiresAt) || 0, cap) : cap, source: 'hook', count: 1,
         renewedAt: keep ? (prev.renewedAt || 0) : 0, renewals: keep ? (prev.renewals || 0) : 0, capCrossedAt: keep ? (prev.capCrossedAt || 0) : 0,
+        activeAt: keep ? (prev.activeAt || firstSeenAt) : firstSeenAt, outSize: keep ? (prev.outSize || 0) : 0, outMtimeMs: keep ? (prev.outMtimeMs || 0) : 0,
       });
     }
     let changed = next.size !== before || !this.backgroundDeclared;
@@ -222,6 +224,7 @@ class SessionStatusLedger {
       expiresAt: keep ? Math.max(Number(prev.expiresAt) || 0, computed) : computed,
       source: src, count,
       renewedAt: keep ? (prev.renewedAt || 0) : 0, renewals: keep ? (prev.renewals || 0) : 0, capCrossedAt: keep ? (prev.capCrossedAt || 0) : 0,
+      activeAt: keep ? (prev.activeAt || firstSeenAt) : firstSeenAt, outSize: keep ? (prev.outSize || 0) : 0, outMtimeMs: keep ? (prev.outMtimeMs || 0) : 0,
     };
     if (leaseMs) entry.leased = true;
     this.background.set(n.id, entry);
@@ -234,16 +237,28 @@ class SessionStatusLedger {
     return this.background.size > 0;
   }
 
+  // D-1: quiet = a hook-declared shell with no activity evidence for BG_QUIET_MS. Never kills; only drops park protection.
+  backgroundQuiet(entry, now) {
+    return entry.type === 'shell' && entry.source === 'hook' && now - (entry.activeAt || 0) >= BG_QUIET_MS;
+  }
+
+  backgroundActive(now = Date.now()) {
+    this._bgExpire(now);
+    return [...this.background.values()].some(e => !this.backgroundQuiet(e, now));
+  }
+
   backgroundView(now = Date.now()) {
     this._bgExpire(now);
     if (!this.background.size) return null;
     const live = [...this.background.values()].sort((a, b) => a.firstSeenAt - b.firstSeenAt);
     const types = {};
     let count = 0;
+    let quiet = 0;
+    for (const e of live) { if (this.backgroundQuiet(e, now)) quiet += 1; }
     for (const e of live) { types[e.type] = (types[e.type] || 0) + e.count; count += e.count; }
     return {
-      count, types,
-      tasks: live.slice(0, BG_VIEW_TASKS_MAX).map(e => ({ id: e.id, type: e.type, label: e.label, since: e.firstSeenAt })),
+      count, types, quiet,
+      tasks: live.slice(0, BG_VIEW_TASKS_MAX).map(e => ({ id: e.id, type: e.type, label: e.label, since: e.firstSeenAt, activeAt: e.activeAt || 0, quiet: this.backgroundQuiet(e, now) })),
       observedAt: this.backgroundObservedAt, declared: this.backgroundDeclared,
     };
   }
@@ -257,6 +272,7 @@ class SessionStatusLedger {
       entries.push({
         id: e.id, type: e.type, label: e.label, firstSeenAt: e.firstSeenAt, expiresAt: e.expiresAt, source: e.source, count: e.count,
         renewedAt: e.renewedAt || 0, renewals: e.renewals || 0, capCrossedAt: e.capCrossedAt || 0,
+        activeAt: e.activeAt || 0, outSize: e.outSize || 0, outMtimeMs: e.outMtimeMs || 0,
       });
     }
     return { declared: this.backgroundDeclared, observedAt: this.backgroundObservedAt, entries };
@@ -279,6 +295,7 @@ class SessionStatusLedger {
         firstSeenAt, expiresAt: Math.min(Number(raw.expiresAt), now + bgCapFor(type)),
         source: String(raw.source || 'hook'), count: Math.max(1, Number(raw.count) || 1),
         renewedAt: Number(raw.renewedAt) || 0, renewals: Math.max(0, Number(raw.renewals) || 0), capCrossedAt: Number(raw.capCrossedAt) || 0,
+        activeAt: Number(raw.activeAt) > 0 ? Number(raw.activeAt) : now, outSize: Number(raw.outSize) || 0, outMtimeMs: Number(raw.outMtimeMs) || 0,
       });
       n += 1;
     }
@@ -325,6 +342,28 @@ class SessionStatusLedger {
     return renewed;
   }
 
+  // D-4: silent activity evidence (a process-sample CPU delta). Returns the number of entries whose activeAt moved.
+  markBackgroundActive(predicate, at = Date.now()) {
+    let moved = 0;
+    for (const e of this.background.values()) {
+      if (!predicate(e)) continue;
+      if (at > (e.activeAt || 0)) { e.activeAt = at; moved += 1; }
+    }
+    return moved;
+  }
+
+  // D-4: output-file growth evidence; a never-seen entry counts as growth only when size > 0.
+  observeBackgroundOutput(id, { size = 0, mtimeMs = 0 } = {}, at = Date.now()) {
+    const e = this.background.get(id);
+    if (!e) return false;
+    const seen = (e.outSize || 0) > 0 || (e.outMtimeMs || 0) > 0;
+    const grew = seen ? (size > (e.outSize || 0) || mtimeMs > (e.outMtimeMs || 0)) : size > 0;
+    if (!grew) return false;
+    e.activeAt = Math.max(e.activeAt || 0, at);
+    e.outSize = size; e.outMtimeMs = mtimeMs;
+    return true;
+  }
+
   record(kind, { at = Date.now(), source = '', meta = {} } = {}) {
     const prev = this.verdict(at);
     const bgBefore = this._bgPending.length;
@@ -579,4 +618,4 @@ class SessionStatusLedger {
   }
 }
 
-module.exports = { SessionStatusLedger, EVIDENCE, AGENT_OUTPUT, PROVIDER_STATUS_POLICY, BG_END_STATUSES, BG_SHELL_MAX_MS, BG_DECLARED_MAX_MS, BG_LABEL_MAX, normalizeBackgroundTask };
+module.exports = { SessionStatusLedger, EVIDENCE, AGENT_OUTPUT, PROVIDER_STATUS_POLICY, BG_END_STATUSES, BG_SHELL_MAX_MS, BG_QUIET_MS, BG_DECLARED_MAX_MS, BG_LABEL_MAX, normalizeBackgroundTask };