create-walle 0.10.2 → 0.10.3

package/template/coding-task-manager/lib/agent-hooks-prune.js

@@ -17,7 +17,17 @@
 // settings object plus counts. A matcher group can be mixed (a CTM hook
 // alongside a user's own hook in the same `hooks: [...]` array) — only the
 // CTM sub-entries inside it are ever touched; the group itself is dropped
-// only once every hook it held is gone. pruneClaudeHooks() is the fully
+// only once every hook it held is gone.
+//
+// OWN-PORT ENTRIES ARE NEVER STALE (D-5): an entry on THIS CTM's own port is
+// its own install, possibly recorded at a path that no longer exists (a repo
+// rename/move). It is kept so the post-prune refresh step
+// (agent-hooks-boot-prune.js refreshOutdatedHooks — which rewrites `outdated`
+// entries only) repairs it to the current path, instead of the prune deleting it
+// and leaving the host with no status hooks at all. Design:
+// docs/remote-session-history-reads-and-box-status-hooks-2026-10-26.html WP-3/D-5.
+//
+// pruneClaudeHooks() is the fully
 // async I/O wrapper that reads the real file, probes real ports over
 // loopback, and writes back atomically only when something actually
 // changed — no sync fs calls anywhere on this path, since it runs on the
@@ -80,14 +90,27 @@ function ctmHooksInGroup(group) {
 /**
  * Pure prune planner. Never touches the filesystem or network — `scriptExists`
  * and `portListening` are injected predicates so this stays unit-testable.
- * Within one matcher group: a CTM hook is removed when `scriptExists(scriptPath)
- * === false`, or when its (non-own) port has `portListening(port) === false`;
- * any non-CTM hook in the same group is never touched. A group that becomes
- * empty is dropped. A group made up ENTIRELY of CTM hooks (no user hook mixed
- * in) is additionally deduped against other such groups with the same
- * matcher + same (command, timeout) hook list, keeping the first. Drops an
- * event key entirely only if every group it held was pure-CTM and all were
- * removed.
+ * Within one matcher group: a CTM hook on an OTHER port is removed when
+ * `scriptExists(scriptPath) === false` or `portListening(port) === false`; any
+ * non-CTM hook in the same group is never touched. A group that becomes empty is
+ * dropped. A group made up ENTIRELY of CTM hooks (no user hook mixed in) is
+ * additionally deduped against other such groups with the same matcher + same
+ * (command, timeout) hook list, keeping the first. Drops an event key entirely
+ * only if every group it held was pure-CTM and all were removed.
+ *
+ * OWN-PORT RULE: a hook whose `port === ownPort` is never stale — not even when
+ * its script path is gone. Such an entry is this CTM's OWN install, recorded at
+ * some earlier path, and `agent-hooks-installer.js` `isOwnClaudeHook()` treats
+ * ANY checkout's claude-hook.js on this port as ours ("one CTM per port, last
+ * installer wins"), so `hookStatus` classifies it `outdated`, never foreign.
+ * Deleting it here is what incident 3 (2026-10-19) did after the repo rename
+ * `claude-task-manager -> coding-task-manager`: the prune removed all ten
+ * own-port entries, the state flipped to `missing`, and the post-prune
+ * `refreshOutdatedHooks` (which only rewrites `outdated`) then had nothing left
+ * to repair — `~/.claude/settings.json` ended at `"hooks": {}`. Keeping the
+ * entry lets that existing refresh step rewrite it to the current path, so every
+ * future path move self-repairs at the next boot. See design
+ * docs/remote-session-history-reads-and-box-status-hooks-2026-10-26.html WP-3 / D-5.
  */
 function planPruneClaudeHooks(data, { scriptExists, portListening, ownPort }) {
   let removedStale = 0;
@@ -119,8 +142,11 @@ function planPruneClaudeHooks(data, { scriptExists, portListening, ownPort }) {
         const info = classifySingleHook(hk);
         if (!info) { sawNonCtm = true; survivingHooks.push(hk); continue; }
         sawCtm = true;
-        const isStale = scriptExists(info.scriptPath) === false
-          || (info.port !== ownPort && portListening(info.port) === false);
+        // D-5: an OTHER-port entry is stale on a missing script or a dead port; an own-port
+        // entry is this CTM's own install at a possibly-old path and is left for the
+        // post-prune refresh to rewrite (see the own-port rule above). Never mark it stale.
+        const isStale = info.port !== ownPort
+          && (scriptExists(info.scriptPath) === false || portListening(info.port) === false);
         if (isStale) { removedStale++; changed = true; removed.push({ event: eventName, command: hk.command, reason: 'stale' }); continue; }
         survivingHooks.push(hk);
       }

package/template/coding-task-manager/lib/agent-hooks-shim.js

@@ -0,0 +1,105 @@
+// Per-port POSIX sh shim that Codex's `~/.codex/config.toml` names as its hook command.
+//
+// Why a shim and not the script path: Codex pins hook trust to a sha256 of the exact `command`
+// text (design docs/codex-hook-stable-shim-trust-safe-self-repair-2026-11-01.html §3). A repo move
+// that rewrites that text flips the hook to "Modified", Codex skips it, and every hosted Codex TUI
+// shows a "Hooks need review" prompt — which the next move repeats. So the config names a path that
+// never moves (`<home>/.walle/bin/ctm-hook-<port>`) and CTM rewrites only the shim BODY at each
+// primary boot. Codex hashes the command text, which stays byte-identical.
+//
+// POSIX sh, not node: the failure this fixes is node printing MODULE_NOT_FOUND before any CTM code
+// runs, so the `[ -f ]` check has to happen before node is involved.
+//
+// Exit 0, never 1, when the target is missing: Codex reports any non-zero exit other than 2 as
+// "Hook failed" on every tool call (post_tool_use.rs:281), and this hook is a passive bridge
+// (bin/codex-workspace-hook.js: "tracking never blocks coding"). Drift is reported by hookStatus and
+// one stderr line, never by breaking the TUI.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const HOOK_BIN_DIR = path.join(path.resolve(__dirname, '..'), 'bin');
+
+/** The two Codex bins CTM installs (the writers live in lib/agent-hooks-codex-toml.js). */
+const SHIM_TARGETS = Object.freeze(['codex-workspace-hook', 'codex-notify']);
+
+/** Absolute shim path for a port. `homeDir` defaults to `os.homedir()`, resolved at CALL time, so a
+ *  test that swaps `process.env.HOME` in `before()` resolves under the temp home. */
+function hookShimPath(port, { homeDir = os.homedir() } = {}) {
+  return path.join(homeDir, '.walle', 'bin', `ctm-hook-${port}`);
+}
+
+/** POSIX single-quote quoting: every interpolated value goes through this before it lands in the body. */
+const sq = (value) => `'${String(value).replace(/'/g, "'\\''")}'`;
+
+/** Escape for a double-quoted shell string (the two diagnostics lines only). */
+const dq = (value) => String(value).replace(/[\\"$`]/g, (c) => `\\${c}`);
+
+/** Exact shim body. `binDir` = absolute CTM bin dir; `nodePath` = `process.execPath`. Pure. */
+function renderHookShim({ port, binDir, nodePath }) {
+  const name = `ctm-hook-${dq(port)}`;
+  return [
+    '#!/bin/sh',
+    `# Written by CTM (port ${dq(port)}) at each primary boot. Do not edit; the config.toml hook names`,
+    "# this file so a CTM checkout move never changes Codex's trusted hook command.",
+    `BIN=${sq(binDir)}`,
+    `NODE=${sq(nodePath)}`,
+    `case "$1" in ${SHIM_TARGETS.join('|')}) ;; *) echo "${name}: unknown target $1" >&2; exit 0;; esac`,
+    'SCRIPT="$BIN/$1.js"; shift',
+    `[ -f "$SCRIPT" ] || { echo "${name}: $SCRIPT missing; CTM refreshes this shim at its next boot" >&2; exit 0; }`,
+    '[ -x "$NODE" ] || NODE=node',
+    'exec "$NODE" "$SCRIPT" "$@"',
+    '',
+  ].join('\n');
+}
+
+/** Read the shim body, or null when it does not exist. */
+function readShimBody(target) {
+  try { return fs.readFileSync(target, 'utf8'); }
+  catch (e) {
+    if (e.code === 'ENOENT') return null; // expected: the shim may not have been written yet
+    throw e; // RETHROW: an unreadable shim is not "missing" — never treat it as absent
+  }
+}
+
+/**
+ * Write the shim iff its body differs (atomic tmp+rename, mode 0755, `mkdir -p` the dir).
+ * Returns `{ path, changed }`. Throws on I/O failure (RETHROW: `install()` must not write a
+ * config.toml that names a shim it could not create).
+ */
+function ensureHookShim({ port, binDir = HOOK_BIN_DIR, nodePath = process.execPath, homeDir } = {}) {
+  const target = hookShimPath(port, { homeDir });
+  const body = renderHookShim({ port, binDir, nodePath });
+  if (readShimBody(target) === body) return { path: target, changed: false };
+  const tmpPath = `${target}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  try {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(tmpPath, body, { mode: 0o755 });
+    fs.renameSync(tmpPath, target);
+  } catch (error) {
+    // RETHROW: clean up the orphaned tmp file, then surface the original error.
+    try { fs.unlinkSync(tmpPath); } catch { /* expected: tmp file may already be gone */ }
+    throw error;
+  }
+  fs.chmodSync(target, 0o755);
+  return { path: target, changed: true };
+}
+
+/** `'current' | 'stale' | 'missing'` — compares the on-disk body to `renderHookShim()`. */
+function hookShimState({ port, binDir = HOOK_BIN_DIR, nodePath = process.execPath, homeDir } = {}) {
+  const body = readShimBody(hookShimPath(port, { homeDir }));
+  if (body === null) return 'missing';
+  return body === renderHookShim({ port, binDir, nodePath }) ? 'current' : 'stale';
+}
+
+/** Remove the shim (uninstall). Returns true when a file was removed. */
+function removeHookShim({ port, homeDir } = {}) {
+  try { fs.unlinkSync(hookShimPath(port, { homeDir })); return true; }
+  catch (e) {
+    if (e.code === 'ENOENT') return false; // expected: the shim was never written, or is already gone
+    throw e; // RETHROW: report a shim we could not remove
+  }
+}
+
+module.exports = { hookShimPath, renderHookShim, ensureHookShim, hookShimState, removeHookShim, SHIM_TARGETS };

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

@@ -5,6 +5,11 @@
 //   - agent detection (command matching)
 // Port of /tmp/clideck/agent-presets.json, adapted for CTM and the CTM_PORT env var.
 
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { agentTypeFromCommandWord } = require('../public/js/agent-command');
+
 /**
  * @typedef {Object} AgentPreset
  * @property {string}  presetId      - stable identifier ('claude-code', 'codex', 'gemini-cli')
@@ -134,10 +139,15 @@ const PRESETS = {
   },
 };
 
+// S-4 (D-5): the detector's agent type maps to a preset id; the loop below stays the fallback.
+const PRESET_BY_AGENT = { claude: 'claude-code', codex: 'codex', gemini: 'gemini-cli', opencode: 'opencode', cursor: 'cursor' };
+
 /** Detect which preset applies to a given spawn command (same contract as server.js's detectAgentType). */
 function detectPresetId(cmd) {
   if (!cmd) return null;
   const s = String(cmd);
+  const byWord = PRESET_BY_AGENT[agentTypeFromCommandWord(s)];
+  if (byWord && PRESETS[byWord]) return byWord;
   for (const [id, p] of Object.entries(PRESETS)) {
     if (p.commandRegex.test(s) || s.includes(p.presetId === 'claude-code' ? 'claude' : p.presetId === 'gemini-cli' ? 'gemini' : p.presetId)) {
       return id;
@@ -200,10 +210,19 @@ const WORKER_STRIPPED_TOKEN_KEYS = Object.freeze(['WALLE_CTM_TOKEN', 'WALL_E_API
 // 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']);
 
+// WP-14 (docs/deepseek-harness-acp-agent-2026-10-28.html C-8/W-7, T-26): a delegated worker whose
+// CLI is the DeepSeek Harness (`dsh`, an ACP child, not a PTY) is a worker like any other -- it
+// returns a report to its lead and never drives CTM -- so it inherits the same strip. Its launch env
+// carries the mark (`CTM_WORKER_AGENT: 'dsh'`, resolve-launch-params.js), and the dsh create path
+// builds the child env from the create request's own resolved launch env
+// (server.js `buildLaunchEnv` -> lib/session-create/dsh-session.js), which IS this object, so the
+// strip is reached without a server.js change.
+const WORKER_AGENT_TYPES = Object.freeze(['claude', 'codex', 'dsh']);
+
 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') {
+  if (WORKER_AGENT_TYPES.includes(explicitWorkerAgent)) {
     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';
@@ -245,12 +264,76 @@ function buildTelemetryEnv(ctmSessionId, cmd, port, baseEnv = process.env) {
   return env;
 }
 
+// ── Claude renderer choice (WP-2, restore-seed-alt-screen-trap-2026-10-27.html R-4) ──
+// Claude Code 2.1.312 has a "fullscreen boot canary": several fullscreen starts that die
+// before becoming healthy make it write `fullscreenAutoDisabled` to ~/.claude.json, after
+// which every later Claude renders inline. CTM's crash-restore storms can trip that canary
+// through no fault of the user's — and it silently flips the renderer the user chose. Claude
+// names its own override: with CLAUDE_CODE_NO_FLICKER truthy the canary is bypassed and the
+// fullscreen renderer is used outright. CTM therefore restates the user's own choice through
+// that override, and only when the user's settings already say fullscreen. CTM never writes
+// any Claude config.
+
+/**
+ * The renderer env for a resolved Claude user setting.
+ * @param {{ tui?: unknown }|null|undefined} claudeSettings  parsed user Claude settings, or null
+ * @returns {{ CLAUDE_CODE_NO_FLICKER?: '1' }}  {CLAUDE_CODE_NO_FLICKER:'1'} iff
+ *   claudeSettings.tui === 'fullscreen' (exact match), else {}
+ */
+function claudeRendererEnv(claudeSettings) {
+  if (claudeSettings && typeof claudeSettings === 'object'
+      && !Array.isArray(claudeSettings) && claudeSettings.tui === 'fullscreen') {
+    return { CLAUDE_CODE_NO_FLICKER: '1' };
+  }
+  return {};
+}
+
+/**
+ * Parsed Claude user settings for a CHILD env, or null on any error.
+ * The path is `<env.CLAUDE_CONFIG_DIR || <env.HOME || os.homedir()>/.claude>/settings.json`
+ * — the Claude process reads its config from its own env, so the caller passes the child env.
+ * @param {NodeJS.ProcessEnv|Object} env
+ * @returns {Object|null}
+ */
+function readClaudeUserSettings(env) {
+  try {
+    const e = env && typeof env === 'object' ? env : {};
+    const configDir = e.CLAUDE_CONFIG_DIR || path.join(e.HOME || os.homedir(), '.claude');
+    const parsed = JSON.parse(fs.readFileSync(path.join(configDir, 'settings.json'), 'utf8'));
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
+    return parsed;
+  } catch {
+    /* expected: a missing/unreadable/corrupt Claude settings file is normal — the renderer is Claude's call */
+    return null;
+  }
+}
+
+/**
+ * The env additions for spawning `cmd` with child env `env`.
+ *   - {} unless the command is Claude Code;
+ *   - {} when `env` already defines CLAUDE_CODE_NO_FLICKER (any value, even '' or '0' — an
+ *     explicit user/launch env always wins);
+ *   - else claudeRendererEnv(readClaudeUserSettings(env)).
+ * @param {string} cmd
+ * @param {NodeJS.ProcessEnv|Object} env
+ * @returns {{ CLAUDE_CODE_NO_FLICKER?: '1' }}
+ */
+function buildClaudeRendererLaunchEnv(cmd, env) {
+  if (detectPresetId(cmd) !== 'claude-code') return {};
+  const e = env && typeof env === 'object' ? env : {};
+  if (Object.prototype.hasOwnProperty.call(e, 'CLAUDE_CODE_NO_FLICKER')) return {};
+  return claudeRendererEnv(readClaudeUserSettings(e));
+}
+
 module.exports = {
   PRESETS,
   detectPresetId,
   getPreset,
   buildTelemetryEnv,
   sanitizeInheritedAgentEnv,
+  buildClaudeRendererLaunchEnv,
+  readClaudeUserSettings,
+  claudeRendererEnv,
   WORKER_STRIPPED_TOKEN_KEYS,
   WORKER_STRIPPED_CTM_API_KEYS,
 };

package/template/coding-task-manager/lib/agent-upgrade-jobs.js

@@ -178,6 +178,8 @@ function _logJobEnd(opts, job, onJobEnd) {
     `version=${versions}`,
     `durationMs=${Math.max(0, (job.finishedAt || Date.now()) - job.startedAt)}`,
     `outcome=${job.outcome || 'none'}`,
+    // AC-4d: 0 unless the plan named live sessions for a live-sensitive install mode.
+    `liveSessions=${Number(job.liveSessions) || 0}`,
     `error=${job.error || 'none'}`,
   ].join(' '));
   if (typeof onJobEnd !== 'function') return;
@@ -187,11 +189,18 @@ function _logJobEnd(opts, job, onJobEnd) {
 }
 
 function createJobRunner({ getAgentVersionStatus, buildUpgradePlan, onJobEnd }) {
-  async function startUpgradeJob(agentId, opts = {}) {
+  async function startUpgradeJob(agentId, opts = {}, { confirmLive = false } = {}) {
     _pruneUpgradeJobs();
     // Re-check first so "before" is never from a stale cache.
     const status = opts.statusPayload || await getAgentVersionStatus({ ...opts, force: true });
     const plan = buildUpgradePlan(agentId, status);
+    // WP-4 (D-9): a live-sensitive install replaces files a running session executes from. The
+    // automatic tick defers for this reason; a click must say so out loud first. The refusal starts
+    // no job, so nothing is written to the job map and no updater is spawned.
+    const liveSessions = Array.isArray(plan.liveSessions) ? plan.liveSessions : [];
+    if (liveSessions.length && confirmLive !== true) {
+      return { ok: false, error: 'upgrade_live_sessions', liveSessions };
+    }
     const existing = _findRunningUpgradeJob(plan.agent);
     if (existing) {
       const snapshot = _upgradeJobSnapshot(existing);
@@ -211,6 +220,8 @@ function createJobRunner({ getAgentVersionStatus, buildUpgradePlan, onJobEnd })
       command: plan.command,
       args: plan.args.slice(),
       plan,
+      // AC-4d: the count the plan saw at start, so a broken session is attributable after the fact.
+      liveSessions: liveSessions.length,
       pid: 0,
       startedAt: now,
       updatedAt: now,

package/template/coding-task-manager/lib/agent-version-service.js

@@ -8,11 +8,16 @@ const { execFile } = require('child_process');
 const agentCliCache = require('./agent-cli-cache');
 const { detectInstallSource, classifyInstall, resolveUpgrade } = require('./agent-upgrade-planner');
 const { AGENT_DEFINITIONS, DEFAULT_AGENT_IDS } = require('./agent-definitions');
+// WP-4 (S-13): the live-sensitive install modes, shared with the automatic-update tick.
+const { LIVE_SENSITIVE_MODES } = require('./agent-auto-update');
 const jobs = require('./agent-upgrade-jobs');
 const { redactOutput, getUpgradeJob, listUpgradeJobs, _upgradeJobs, _upgradeEnv } = jobs;
 
-// 4: rows carry qualification / installedQualification (WP-2 of the Codex harness qualification design).
-const CACHE_VERSION = 4;
+// History: 4 added per-row qualification fields, 5 added a qualification-table revision stamp so a
+// moved table recomputed a cached row. 6 removes both (docs/codex-upgrades-without-version-approval-2026-10-28.html
+// WP-1/D-3): a row carries no per-version approval state, so a schema-4/5 cache -- including one
+// still holding qualification rows -- is recomputed and can never be served.
+const CACHE_VERSION = 6;
 const DEFAULT_TTL_MS = 6 * 60 * 60 * 1000;
 const DEFAULT_REGISTRY_BASE_URL = 'https://registry.npmjs.org';
 const DEFAULT_VERSION_TIMEOUT_MS = 2500;
@@ -36,10 +41,8 @@ function _writeJson(filePath, payload) {
   try { fs.chmodSync(filePath, 0o600); } catch {}
 }
 
-// normalizeSemver/compareSemver live in the leaf module lib/semver-compare.js (shared with the
-// Codex qualified-version table, which this service reads back for its status row).
+// normalizeSemver/compareSemver live in the leaf module lib/semver-compare.js.
 const { normalizeSemver, compareSemver } = require('./semver-compare');
-const { codexQualification } = require('./codex-harness-qualification');
 
 function parseVersionText(stdout, stderr) {
   const primary = String(stdout || '');
@@ -210,8 +213,21 @@ function _deriveStatus(installedVersion, latestVersion, available) {
   return { status: 'current', hasUpdate: false };
 }
 
+// WP-12 (AC-12a): a definition may name the install it owns (`def.installIdentity`). Path discovery is
+// name-based, and one of these names is not unique on this host -- homebrew/core's `dsh` is the
+// unrelated "Dancer's shell" -- so an entry whose realpath (or path) is outside the owning package is
+// NOT this CLI. Such an entry reads as not installed, which also keeps its `--version` unprobed: the
+// wrong tool's version must never render as this agent's row. The rule is the one
+// lib/hermetic-agent-launch-guard.js applies to the dsh entrypoint.
+function _installIdentityHolds(def, entry) {
+  if (!def.installIdentity || !entry || !entry.available) return true;
+  // The realpath decides when discovery resolved one: a symlink's own path proves nothing.
+  return def.installIdentity.test(String(entry.realpath || entry.path || ''));
+}
+
 async function _checkAgent(def, availability, opts) {
-  const entry = availability && availability.agents ? availability.agents[def.cli] : null;
+  const discovered = availability && availability.agents ? availability.agents[def.cli] : null;
+  const entry = _installIdentityHolds(def, discovered) ? discovered : null;
   const available = !!(entry && entry.available && !entry.stale);
   let versionResult = { ok: false, stdout: '', stderr: '', error: '' };
   let installedVersion = '';
@@ -251,10 +267,6 @@ async function _checkAgent(def, availability, opts) {
     manual: upgrade.manual,
     versionError: available && !installedVersion ? (versionResult.error || 'version_parse_failed') : '',
     latestError: latest.error || '',
-    // WP-2 (D-6): why a Codex version may not be switchable as a lead (the row says so in the UI);
-    // every other agent is not gated by the table.
-    qualification: def.cli === 'codex' ? codexQualification(latest.version) : { state: 'not_applicable' },
-    installedQualification: def.cli === 'codex' ? codexQualification(installedVersion) : { state: 'not_applicable' },
   };
 }
 
@@ -297,6 +309,8 @@ async function getAgentVersionStatus(opts = {}) {
   const ttlMs = Number(opts.ttlMs) || DEFAULT_TTL_MS;
   if (!opts.force && opts.cacheFile) {
     const cached = _readJson(opts.cacheFile);
+    // A hit is schema + TTL + agents only: nothing in this status is pinned to a build-time table,
+    // so there is no second stamp to compare (a schema-5 row recomputes below on `version`).
     if (cached && cached.version === CACHE_VERSION && cached.generatedAt && now - cached.generatedAt < ttlMs && cached.agents) {
       return { ...cached, cached: true };
     }
@@ -316,7 +330,39 @@ function _getDefinition(agentId) {
   return def;
 }
 
-function buildUpgradePlan(agentId, statusPayload) {
+// WP-4 (D-9): the live-session predicate the auto tick already uses, injected by server.js from the
+// same derivation (lib/agent-auto-update.js liveAgentIds/liveSessionsFor). Uninjected (a dev
+// instance, a unit test) reads as "no live sessions", which is the pre-WP-4 plan exactly.
+let _liveSessions = {
+  liveSessionAgents: () => new Set(),
+  liveSessionsFor: () => [],
+};
+
+/** server.js injects `{ liveSessionAgents, liveSessionsFor }`; no argument restores the no-op default. */
+function configureLiveSessions(deps) {
+  _liveSessions = {
+    liveSessionAgents: typeof (deps && deps.liveSessionAgents) === 'function' ? deps.liveSessionAgents : () => new Set(),
+    liveSessionsFor: typeof (deps && deps.liveSessionsFor) === 'function' ? deps.liveSessionsFor : () => [],
+  };
+}
+
+/** `[{ id, title, agent }]` for the live sessions of this agent; `[]` when nothing is live. */
+function _liveSessionsFor(def, deps) {
+  const live = deps || _liveSessions;
+  let agents;
+  // HANDLE: naming the sessions is advisory — a broken session reader must never fail the plan.
+  try { agents = live.liveSessionAgents(); } catch (e) { return []; }
+  if (!agents || typeof agents.has !== 'function' || !agents.has(def.id)) return [];
+  try {
+    const sessions = live.liveSessionsFor(def.id);
+    return Array.isArray(sessions) ? sessions : [];
+  } catch (e) {
+    // HANDLE: same — an unreadable session list degrades to "nothing to name".
+    return [];
+  }
+}
+
+function buildUpgradePlan(agentId, statusPayload, liveDeps) {
   const def = _getDefinition(agentId);
   const row = statusPayload && statusPayload.agents ? statusPayload.agents[def.id] : null;
   if (!row || !row.available) throw new Error('agent_not_available');
@@ -331,6 +377,9 @@ function buildUpgradePlan(agentId, statusPayload) {
   const args = exec.args.slice();
   const commandKind = row.upgradeMode || '';
   const commandLabel = row.upgradeCommand || '';
+  // WP-4 (D-9): an install mode whose upgrade replaces files a running session executes from.
+  const liveSensitive = LIVE_SENSITIVE_MODES.has(commandKind);
+  const liveSessions = liveSensitive ? _liveSessionsFor(def, liveDeps) : [];
   return {
     ok: true,
     agent: def.id,
@@ -345,6 +394,8 @@ function buildUpgradePlan(agentId, statusPayload) {
     args,
     commandKind,
     commandLabel,
+    liveSensitive,
+    liveSessions,
     changes: [
       { description: row.latestVersion ? `Upgrade ${def.name} from ${row.installedVersion || 'unknown'} to ${row.latestVersion}` : `Run ${def.name}'s updater to check for the latest version` },
       { description: `Command: ${commandLabel || [path.basename(command)].concat(args).join(' ')}` },
@@ -352,9 +403,20 @@ function buildUpgradePlan(agentId, statusPayload) {
   };
 }
 
+/** WP-4 (D-9): the shared refusal shape for a live-sensitive upgrade the caller has not confirmed. */
+function _liveSessionsRefusal(plan) {
+  const liveSessions = Array.isArray(plan.liveSessions) ? plan.liveSessions : [];
+  if (!liveSessions.length) return null;
+  return { ok: false, error: 'upgrade_live_sessions', liveSessions };
+}
+
 async function upgradeAgentVersion(agentId, opts = {}) {
   const status = opts.statusPayload || await getAgentVersionStatus({ ...opts, force: false });
   const plan = buildUpgradePlan(agentId, status);
+  if (opts.confirmLive !== true) {
+    const refusal = _liveSessionsRefusal(plan);
+    if (refusal) return refusal;
+  }
   const result = await runCommand(plan.command, plan.args, {
     execFileImpl: opts.execFileImpl,
     timeoutMs: opts.upgradeTimeoutMs || DEFAULT_UPGRADE_TIMEOUT_MS,
@@ -398,6 +460,7 @@ module.exports = {
   checkAgentVersions,
   getAgentVersionStatus,
   buildUpgradePlan,
+  configureLiveSessions,
   upgradeAgentVersion,
   startUpgradeJob,
   setUpgradeJobEndHandler,

package/template/coding-task-manager/lib/all-sessions-query.js

@@ -50,7 +50,9 @@ function queryAllSessionsData(d) {
       CASE
         WHEN LOWER(COALESCE(a.provider, '')) = 'walle'
           THEN ''
-        ELSE COALESCE(NULLIF(a.modified_at, ''), a.updated_at, a.created_at, '')
+        ELSE COALESCE(NULLIF(a.modified_at, ''),
+          strftime('%Y-%m-%dT%H:%M:%SZ', a.updated_at),
+          strftime('%Y-%m-%dT%H:%M:%SZ', a.created_at), '')
       END as last_message_at
       ${startupSelect}
     FROM ctm_sessions c
@@ -101,7 +103,9 @@ function queryAllSessionsData(d) {
       CASE
         WHEN LOWER(COALESCE(a.provider, '')) = 'walle'
           THEN ''
-        ELSE COALESCE(NULLIF(a.modified_at, ''), a.updated_at, a.created_at, '')
+        ELSE COALESCE(NULLIF(a.modified_at, ''),
+          strftime('%Y-%m-%dT%H:%M:%SZ', a.updated_at),
+          strftime('%Y-%m-%dT%H:%M:%SZ', a.created_at), '')
       END as last_message_at
     FROM agent_sessions a
     ORDER BY