create-walle 0.10.1 → 0.10.2

package/template/coding-task-manager/public/js/terminal/runtime-20.js

@@ -265,6 +265,11 @@ function _renderResumeLoadingOverlay(s) {
   if (!s || !s.container) return false;
   const overlay = s.container.querySelector('.snapshot-loading-overlay');
   if (!overlay) return false;
+  // WP-4c (§5 OQ-4 = H-B, §8 WP-4c): the resume-blocked card shares this shell class (index.html
+  // ~3825); its copy is the CARD's, and a loading label written here is what made a stranded card
+  // read as a stuck resume. The card's renderer owns the shell until the server row's
+  // resumeBlocked:false clears the store lifecycle in onSessionsList.
+  if (_presentationStore.getSessionState(_resumeClientSessionId(s))?.lifecycle === 'resume-blocked') return false;
   const lbl = overlay.querySelector('.snapshot-loading-text');
   if (lbl) lbl.textContent = _resumeLoadingText(s);
   const rs = _resumeStateForSession(s);
@@ -770,6 +775,32 @@ function _resumeBlockedAgentLabel(s, msg) {
     || 'The agent';
 }
 
+// D-14: the session a card is about. The label/cwd expressions are the ones the store rebuild already
+// used (WP-6), lifted here so the identity line and the rebuild cannot drift apart.
+function _resumeBlockedSessionLabel(s) {
+  return (s && s.meta && s.meta.title) || (s && s.title) || 'Session';
+}
+
+function _resumeBlockedSessionCwd(s) {
+  return (s && s.meta && (s.meta.cwd || s.meta.projectPath || s.meta.project_path)) || (s && s.cwd) || '';
+}
+
+// D-14/D-12: a folder is shown with the home prefix as `~`, so no absolute path reaches the card.
+function _resumeBlockedFolder(cwd) {
+  return String(cwd || '').replace(/^\/(?:Users|home)\/[^/]+/, '~');
+}
+
+// D-14: `{label} · {agent} · {folder} · last active {date}` — the folder and the date segments are
+// dropped when CTM has nothing to put in them, never rendered empty.
+function _resumeBlockedIdentity(s, msg) {
+  const parts = [_resumeBlockedSessionLabel(s), _resumeBlockedAgentLabel(s, msg)];
+  const folder = _resumeBlockedFolder(_resumeBlockedSessionCwd(s));
+  if (folder) parts.push(folder);
+  const seen = msg && msg.lastSeenAt ? new Date(msg.lastSeenAt) : null;
+  if (seen && !Number.isNaN(seen.getTime())) parts.push(`last active ${seen.toLocaleDateString()}`);
+  return parts.join(' · ');
+}
+
 // Leave the blocked card for the resuming cover (shared by Retry now and Resume from stored history).
 function _enterResumingFromBlocked(s) {
   s._resumeBlocked = false;
@@ -830,8 +861,31 @@ function _formatResumeBlockedBytes(bytes) {
   return `${rounded} ${units[i]}`;
 }
 
+// D-13: ONE "why" sentence, built only from recorded facts, first match wins. It says what CTM knows
+// happened; it never guesses, and it never asks the user to touch a file. Empty when nothing is known.
+function _resumeBlockedWhy(msg, agent) {
+  const m = msg || {};
+  // ` on <date>` only when the recorded date parses: an older manifest without the key never renders "Invalid Date".
+  const on = (x) => { const t = x ? new Date(x) : null; return t && !Number.isNaN(t.getTime()) ? ` on ${t.toLocaleDateString()}` : ''; };
+  if (m.trashReason === 'archived') return `CTM's archiver moved it${on(m.trashedAt)}. CTM no longer does this.`;
+  if (m.trashReason === 'delete-session') return `It was moved to CTM's trash when this session was deleted${on(m.trashedAt)}.`;
+  if (m.localHistory === 'removed') {
+    const size = _formatResumeBlockedBytes(m.lastSeenBytes);
+    const seen = on(m.lastSeenAt);
+    return `CTM last saw it${seen || ' here'}${size ? ` (${size})` : ''}; it was removed outside CTM.`;
+  }
+  if (m.localHistory === 'never_seen') {
+    return 'CTM never saw it on this machine.'
+      + (m.code === 'missing_codex_rollout' ? '' : ' Claude Code deletes transcripts older than its retention period, 30 days by default.');
+  }
+  return '';
+}
+
 // The missing-transcript card is a pure function of the facts on the message (origin,
 // localHistory, resumeRung, storeTurns); see docs/resume-blocked-card-truth-transcript-gone-2026-10-07.html D-2.
+// WP-3 (D-10..D-15): the RUNG picks the headline (localHistory and the trash reason only pick the "why"
+// sentence), every missing-transcript card opens with an identity line, and no path ever reaches the
+// title or the body — the paths live in the collapsed Details row the renderer builds.
 function _resumeBlockedCopyForMsg(s, msg) {
   const code = (msg && msg.code) || '';
   const base = RESUME_BLOCKED_COPY[code];
@@ -839,8 +893,8 @@ function _resumeBlockedCopyForMsg(s, msg) {
   if (!_resumeBlockedIsMissingTranscript(msg)) return base;
   const agent = _resumeBlockedAgentLabel(s, msg);
   const origin = msg.origin || 'unknown';
-  const lh = msg.localHistory;
   const rung = msg.resumeRung || '';
+  const identity = _resumeBlockedIdentity(s, msg);
   // WP-2 (multi-machine R-15): where the transcript lives, keyed on the server's `transcriptState` — a file
   // deleted HERE and a file living on machine X are different truths and must not share a sentence. An
   // older server (no transcriptState on the message) keeps the origin-only copy below, unchanged.
@@ -848,6 +902,7 @@ function _resumeBlockedCopyForMsg(s, msg) {
   if (msg.transcriptState === 'on_other_machine') {
     return {
       tone: 'info',
+      identity,
       title: `This session was created on ${host}.`,
       body: msg.originIsPeer
         ? `Its ${agent} transcript is there. CTM copies it here once the session has exited there.`
@@ -855,55 +910,41 @@ function _resumeBlockedCopyForMsg(s, msg) {
     };
   }
   if (msg.transcriptState === 'copy_pending') {
-    return { tone: 'info', title: `Copying this session's transcript from ${host}…`, body: 'Resume will work once the copy completes.' };
+    return { tone: 'info', identity, title: `Copying this session's transcript from ${host}…`, body: 'Resume will work once the copy completes.' };
   }
   if (msg.transcriptState === 'deleted_after_copy') {
     return {
       tone: 'info',
+      identity,
       title: "This session's transcript was deleted from this machine.",
       body: `It was copied here from ${host}; CTM does not know whether ${host} still has it.`,
     };
   }
   if (!msg.transcriptState && origin === 'other_instance') {
-    return { tone: 'info', title: 'This session was created on another CTM instance.', body: `Its ${agent} transcript lives there.` };
-  }
-  if (lh === 'removed') {
-    const sizeText = _formatResumeBlockedBytes(msg.lastSeenBytes);
-    const dateText = msg.lastSeenAt ? new Date(msg.lastSeenAt).toLocaleString() : 'an earlier time';
-    const seenText = sizeText ? `${sizeText}, last seen ${dateText}` : `last seen ${dateText}`;
-    return {
-      tone: 'info',
-      title: "This session's transcript was deleted from this machine.",
-      body: `CTM read it here (${seenText}) and the file is gone, so ${agent} can't resume it natively.`,
-    };
+    return { tone: 'info', identity, title: 'This session was created on another CTM instance.', body: `Its ${agent} transcript lives there.` };
   }
+  const why = _resumeBlockedWhy(msg, agent);
+  const st = msg.storeTurns || { human: 0, total: 0 };
   if (rung === 'restore' || rung === 'trash') {
-    return {
-      tone: 'info',
-      title: "This session's transcript file is missing.",
-      body: rung === 'restore' ? 'An archived copy exists here.' : "A copy is in CTM's transcript trash.",
-    };
+    let body = `Restore puts it back where ${agent} looks for it and resumes the session.`;
+    if (why) body += ` ${why}`;
+    if (msg.restoreError && msg.restoreError !== 'not_implemented') body += ` The last restore did not finish (${msg.restoreError}).`;
+    return { tone: 'info', identity, title: `${agent} can't find this session's transcript, but CTM kept a copy.`, body };
   }
   if (rung === 'store') {
-    return { tone: 'info', title: "This session's transcript file is missing.", body: `${agent} can't resume it natively.` };
+    const cc = String((msg.coverage && msg.coverage.storeComplete) || '');
+    const coverage = cc === 'yes' || cc === 'no' ? `, ${_resumeStoreCompleteText(cc)}` : '';
+    let body = `CTM saved ${Number(st.human) || 0} prompts (${Number(st.total) || 0} turns) of the conversation; ${agent} can start from them${coverage}.`;
+    if (why) body += ` ${why}`;
+    return { tone: 'info', identity, title: `${agent} can't find this session's transcript, and CTM has no copy of the file.`, body };
   }
   if (rung === '') {
-    // Unknown rung (the ladder could not answer): never the "nothing to resume" copy. Keep the code's title and say what is unknown.
-    const removed = lh === 'removed';
-    const sizeText = _formatResumeBlockedBytes(msg.lastSeenBytes);
-    const dateText = msg.lastSeenAt ? new Date(msg.lastSeenAt).toLocaleString() : 'an earlier time';
-    return {
-      tone: 'info',
-      title: removed ? "This session's transcript was deleted from this machine." : "This session's transcript is gone from this machine.",
-      body: 'CTM could not check what it has stored for this session.' + (removed ? ` CTM read it here (${sizeText ? `${sizeText}, last seen ${dateText}` : `last seen ${dateText}`}) and the file is gone, so ${agent} can't resume it natively.` : ''),
-    };
+    // Unknown rung (the ladder could not answer): never the "nothing to resume" copy.
+    return { tone: 'info', identity, title: "CTM couldn't check this session's history.", body: 'The check did not finish.' };
   }
-  const retention = code === 'missing_codex_rollout' ? '' : ' (Claude Code deletes transcripts older than its retention period, 30 days by default)';
-  return {
-    tone: 'info',
-    title: "This session's transcript is gone from this machine.",
-    body: `The file was removed before CTM stored any of its prompts${retention}. There is nothing to resume; start a fresh session in the same folder.`,
-  };
+  if (rung === 'native') return { tone: 'info', identity, title: "This session's transcript is back.", body: '' };
+  // rung 'fresh' (and any rung CTM does not recognise): nothing was stored, so there is nothing to resume.
+  return { tone: 'info', identity, title: `${agent} can't find this session's transcript, and CTM saved none of it.`, body: why || 'There is nothing to resume.' };
 }
 
 // Session-transcript-storage WP-6 (D-6, D-7, D-13): the missing-transcript card names the rung the
@@ -930,7 +971,7 @@ function _resumeBlockedStoredLine(msg) {
   const tail = coverage && Number.isFinite(Number(coverage.turnsTotal))
     ? `, ${_resumeStoreCompleteText(coverage.storeComplete)}.`
     : '.';
-  return `CTM has ${Number(st.human) || 0} prompts (${total} turns) of this conversation${tail} Open Conversation shows CTM's copy.`;
+  return `CTM has ${Number(st.human) || 0} prompts (${total} turns) of this conversation${tail}`;
 }
 
 function _resumeCheckedRungWord(rung) {
@@ -944,15 +985,55 @@ function _resumeCheckedLine(checkedAt, rung) {
   return `Checked ${time}: ${_resumeCheckedRungWord(rung)}`;
 }
 
+// D-12: the file facts live in ONE collapsed Details row under the buttons, never in the card's title,
+// body or identity line (a path is not something the user should have to read, let alone act on). The
+// row is rendered only when it would hold at least one value; lines are written with textContent only.
+function _resumeBlockedDetailLines(msg, checked) {
+  const m = msg || {};
+  const rung = String(m.resumeRung || '');
+  const lines = [];
+  const transcript = String(m.originalPath || m.storedPath || '');
+  if (transcript) lines.push({ key: 'transcript', text: `Transcript: ${transcript}` });
+  const copyPath = String(m.trashPath || (rung === 'restore' ? 'CTM archive' : ''));
+  if (copyPath) lines.push({ key: 'copy', text: `Copy: ${copyPath}` });
+  if (checked) lines.push({ key: 'checked', text: _resumeCheckedLine(m.checkedAt, rung) });
+  return lines;
+}
+
+function _renderResumeBlockedDetails(overlay, msg, checked) {
+  const lines = _resumeBlockedIsMissingTranscript(msg) ? _resumeBlockedDetailLines(msg, checked) : [];
+  let details = overlay.querySelector('.resume-blocked-details');
+  if (!lines.length) {
+    if (details) details.remove();
+    return null;
+  }
+  if (!details) {
+    details = document.createElement('details');
+    details.className = 'resume-blocked-details';
+    const summary = document.createElement('summary');
+    summary.textContent = 'Details';
+    details.appendChild(summary);
+    overlay.appendChild(details);
+  }
+  for (const child of Array.from(details.children)) if (String(child.tagName || '').toLowerCase() !== 'summary') child.remove(); // HTML tagName is upper-case
+  for (const line of lines) {
+    const el = document.createElement('div');
+    el.className = `resume-blocked-detail-line resume-blocked-detail-${line.key}`;
+    el.textContent = line.text;
+    details.appendChild(el);
+  }
+  return details;
+}
+
 function _resumeBlockedBodyWithStore(body, msg) {
   // D-2/D-4: the stored line rides on any card carrying store-turn facts, not only the missing codes.
   // A card with no ladder facts (storeTurns absent) keeps its body exactly as the code's copy wrote it.
   if (!msg || !msg.storeTurns || msg.storeTurns.known === undefined) return body;
+  // WP-3 (D-10/D-15): on a missing-transcript card the stored coverage is the RUNG's own sentence (the
+  // card copy already wrote it), so nothing is appended here. No card ever names a path or tells the user
+  // to move a file: paths live in the Details row, and "Restore and resume" does the restore itself.
+  if (_resumeBlockedIsMissingTranscript(msg)) return body;
   let text = [body, _resumeBlockedStoredLine(msg)].filter(Boolean).join(' ');
-  if (msg.trashPath) {
-    text += ` A copy is in CTM's transcript trash at ${msg.trashPath} \u2014 move it back to `
-      + `${msg.originalPath || 'its original location'} and press Check again.`;
-  }
   if (msg.restoreError && msg.restoreError !== 'not_implemented') text += '\nRestore failed: ' + msg.restoreError;
   return text;
 }
@@ -993,8 +1074,8 @@ async function _resumeBlockedFromStore(s, msg, btn) {
   const sessionId = _resumeClientSessionId(s);
   if (!s || !sessionId) return;
   const provider = _clientNormalizeAgentType(msg.agentType || _clientAgentTypeForSession(s)) === 'codex' ? 'codex' : 'claude';
-  const cwd = (s.meta && (s.meta.cwd || s.meta.projectPath || s.meta.project_path)) || s.cwd || '';
-  const label = (s.meta && s.meta.title) || s.title || 'Session';
+  const cwd = _resumeBlockedSessionCwd(s);
+  const label = _resumeBlockedSessionLabel(s);
   const idle = btn.textContent;
   btn.disabled = true;
   btn.textContent = 'Starting…';
@@ -1053,43 +1134,50 @@ function _resumeBlockedButton(actions, label, onclick, primary) {
   return btn;
 }
 
+// D-11: the third recovery option is a text link, not a fourth equal button. Same handler map.
+function _resumeBlockedLinkButton(actions, label, onclick) {
+  const btn = document.createElement('button');
+  btn.className = 'resume-blocked-link';
+  btn.textContent = label;
+  btn.onclick = () => onclick(btn);
+  actions.appendChild(btn);
+  return btn;
+}
+
 // Buttons of the card as data: a pure function of the message facts, no DOM (D-3). Missing-transcript
 // cards offer only the actions their rung can honor; D-7 makes the store primary for an oversized Codex rollout.
-// D-4: "Resume from stored history" appears on ANY blocked card whose store holds a human prompt, as a
-// secondary action after the code's own primary.
+// D-4 (session-exit-close-truth): the store rebuild asks the ladder whether the native transcript is
+// gone. It is offered ONLY on a missing-transcript code whose rung is store, fresh or '' (unknown), or
+// when offerStoreFirst is true -- never on a non-missing code and never on rung native, restore or trash.
 function _resumeBlockedActionsFor(msg) {
   const missing = _resumeBlockedIsMissingTranscript(msg);
+  const m = msg || {};
   const fresh = { id: 'fresh', label: 'Start fresh here', primary: false };
+  // D-11: at most two buttons and one text link, exactly one button primary. `link: true` marks the
+  // action the renderer draws AFTER the buttons as a text-styled link (same handler map).
   const conversation = { id: 'conversation', label: 'Open Conversation', primary: false };
+  const conversationLink = { ...conversation, link: true };
   const store = (primary) => ({ id: 'store', label: 'Resume from stored history', primary });
-  const st = msg.storeTurns || { human: 0, total: 0 };
-  const human = Number(st.human) > 0;
-  if (!missing) return [{ id: 'retry', label: 'Retry now', primary: true }, ...(human ? [store(false)] : []), fresh, conversation];
-  if (msg.offerStoreFirst === true) return [store(true), { id: 'retry', label: 'Retry now', primary: false }, fresh, conversation];
-  const rung = String(msg.resumeRung || '');
-  const hasStore = Number(st.total) > 0 || st.known === false;
   const check = { id: 'check', label: 'Check again', primary: false };
+  const st = m.storeTurns || { human: 0, total: 0 };
+  const hasStore = Number(st.total) > 0;
+  // Non-missing codes keep today's list exactly.
+  if (!missing) return [{ id: 'retry', label: 'Retry now', primary: true }, fresh, conversation];
+  if (m.offerStoreFirst === true) return [store(true), { id: 'retry', label: 'Retry now', primary: false }, conversationLink];
+  const rung = String(m.resumeRung || '');
   if (rung === 'restore' || rung === 'trash') {
-    const list = [{ id: 'restore', label: 'Restore and resume', primary: true }];
-    if (Number(st.human) > 0) list.push(store(false));
-    list.push(fresh);
-    if (hasStore) list.push(conversation);
-    list.push(check);
+    // The rung can put the original back itself, so it leads and "Check again" is gone (D-11/I-5).
+    const list = [{ id: 'restore', label: 'Restore and resume', primary: true }, fresh];
+    if (hasStore) list.push(conversationLink);
     return list;
   }
-  if (rung === 'store') return [store(true), fresh, conversation, check];
-  if (rung === '') { // unknown: the answer is a re-check, never "Start fresh" as the lead action
-    const unknown = [{ ...check, primary: true }];
-    if (Number(st.total) > 0) unknown.push(conversation);
-    if (human) unknown.push(store(false));
-    unknown.push(fresh);
-    return unknown;
+  if (rung === 'store') return [store(true), fresh, conversationLink];
+  if (rung === '') { // unknown: the answer is a re-check -- the check itself is what failed
+    return hasStore ? [{ ...check, primary: true }, fresh, conversationLink] : [{ ...check, primary: true }, fresh];
   }
-  const list = [{ ...fresh, primary: true }];
-  if (human) list.push(store(false));
-  if (hasStore) list.push(conversation);
-  list.push(check);
-  return list;
+  // rung native with a missing transcript: the file is back, so resuming leads and the store is gone.
+  if (rung === 'native') return [{ id: 'retry', label: 'Resume', primary: true }, fresh];
+  return [{ ...fresh, primary: true }];
 }
 
 function _appendResumeBlockedActions(actions, s, msg) {
@@ -1103,8 +1191,24 @@ function _appendResumeBlockedActions(actions, s, msg) {
     conversation: () => _openBlockedResumeConversation(s),
     check: (b) => _checkBlockedResumeAgain(s, b),
   };
-  for (const action of _resumeBlockedActionsFor(msg)) {
-    _resumeBlockedButton(actions, action.label, handlers[action.id], action.primary);
+  const list = _resumeBlockedActionsFor(msg);
+  for (const action of list.filter((a) => !a.link)) {
+    const handler = handlers[action.id];
+    // WP-0 (S-9/D-8): every click on a blocked card's button records which button it was before the
+    // handler runs, so a card's outcome is attributable to the action the user actually pressed.
+    const traced = typeof handler !== 'function' ? handler : (...args) => {
+      send({ type: 'client-diag', id: _resumeClientSessionId(s), event: 'resume-blocked-action', details: { action: action.id, code: String(msg.code || '') } });
+      return handler(...args);
+    };
+    _resumeBlockedButton(actions, action.label, traced, action.primary);
+  }
+  for (const action of list.filter((a) => a.link)) {
+    const handler = handlers[action.id];
+    const traced = typeof handler !== 'function' ? handler : (...args) => {
+      send({ type: 'client-diag', id: _resumeClientSessionId(s), event: 'resume-blocked-action', details: { action: action.id, code: String(msg.code || '') } });
+      return handler(...args);
+    };
+    _resumeBlockedLinkButton(actions, action.label, traced);
   }
   if (_resumeBlockedIsMissingTranscript(msg) && msg.restoreError === 'not_implemented') {
     _resumeBlockedNote(s, 'Restore lands with the archive work');
@@ -1144,9 +1248,15 @@ function onResumeRetryNoop(msg) {
   if (!s || !s._resumeCheckPending) return;
   _clearResumeCheckPending(s);
   const overlay = s.container && s.container.querySelector('.snapshot-loading-overlay');
-  const lbl = overlay && overlay.querySelector('.snapshot-loading-text');
-  const line = _resumeCheckedLine(msg.checkedAt, (s._resumeBlockedFacts && s._resumeBlockedFacts.resumeRung) || '');
-  if (lbl) lbl.textContent = String(lbl.textContent || '').replace(/\nChecked [^\n]*$/, '') + '\n' + line;
+  // D-12: the stamp goes in the Details row (written once, replaced in place) -- never into the body.
+  const rendered = s._resumeBlockedMsg || msg;
+  if (overlay) {
+    _renderResumeBlockedDetails(overlay, {
+      ...rendered,
+      resumeRung: rendered.resumeRung || s._resumeBlockedRung || '',
+      checkedAt: msg.checkedAt,
+    }, true);
+  }
   const actions = overlay && overlay.querySelector('.snapshot-loading-actions');
   for (const b of (actions ? Array.from(actions.children) : [])) if (b.textContent === 'Checking\u2026') b.textContent = 'Check again';
 }
@@ -1175,6 +1285,16 @@ function _renderResumeBlockedOverlay(s, msg, opts) {
   clearTimeout(s._loadingOverlayTimer);
   s._loadingOverlayTimer = null;
   _projectSessionLifecycle(s, 'resume-blocked'); // the renderer mounts (or keeps) the shell
+  // WP-0 (S-9/D-8): the card the user actually saw is recorded once per render, with the action list it
+  // offered -- the server side alone cannot say which of the three cards for one code was painted.
+  send({
+    type: 'client-diag', id: _resumeClientSessionId(s), event: 'resume-blocked-card',
+    details: {
+      code: String(msg.code || ''), rung: String(msg.resumeRung || ''),
+      storeHuman: Number(msg.storeTurns && msg.storeTurns.human) || 0,
+      actions: _resumeBlockedActionsFor(msg).map((a) => a.id).join(','),
+    },
+  });
   const overlay = s.container.querySelector('.snapshot-loading-overlay');
   // Off the terminal the renderer withholds the element on purpose: the rail line represents the card.
   if (!overlay) return typeof _terminalLifecycleOverlaySuppressed === 'function' && _terminalLifecycleOverlaySuppressed(s);
@@ -1189,6 +1309,18 @@ function _renderResumeBlockedOverlay(s, msg, opts) {
     overlay.insertBefore(lbl, overlay.firstChild);
   }
   lbl.classList.add('is-static');
+  // D-14: every missing-transcript card names its subject first, in its own dim line above the headline.
+  let ident = overlay.querySelector('.resume-blocked-identity');
+  if (copy.identity) {
+    if (!ident) {
+      ident = document.createElement('div');
+      ident.className = 'resume-blocked-identity';
+      overlay.insertBefore(ident, lbl);
+    }
+    ident.textContent = copy.identity;
+  } else if (ident) {
+    ident.remove();
+  }
   const agentLabel = _resumeBlockedAgentLabel(s, msg);
   const attempts = Math.max(0, Number(msg?.attempts || 0));
   let body = _resumeBlockedBodyWithStore(copy.body, msg);
@@ -1198,10 +1330,11 @@ function _renderResumeBlockedOverlay(s, msg, opts) {
     body = `${agentLabel} is producing output but never painted its screen.`;
   }
   const remount = !!(opts && opts.remount);
+  let checked = false;
   if (!remount && s._resumeCheckPending && _resumeBlockedIsMissingTranscript(msg)) {
-    // A Check again was in flight: this re-render is its answer.
+    // A Check again was in flight: this re-render is its answer. D-12: the stamp lives in Details.
     _clearResumeCheckPending(s);
-    body += '\n' + _resumeCheckedLine(msg.checkedAt, msg.resumeRung);
+    checked = true;
   }
   lbl.textContent = copy.title + (body ? '\n' + body : '');
   let detail = overlay.querySelector('.snapshot-loading-detail');
@@ -1224,10 +1357,14 @@ function _renderResumeBlockedOverlay(s, msg, opts) {
   }
   actions.innerHTML = '';
   _appendResumeBlockedActions(actions, s, msg);
+  if (typeof resumeBlockedOpenOnMachineAction === 'function') resumeBlockedOpenOnMachineAction(msg, actions, s); // hub WP-5
   if (remount && s._resumeCheckPending) {
     // A Check again is still in flight: a surface round trip is not its answer.
     for (const b of Array.from(actions.children)) if (b.textContent === 'Check again') b.textContent = 'Checking\u2026';
   }
+  // D-12: the file facts are the LAST thing on the card, under the buttons -- a collapsed disclosure, not
+  // something the user has to read or act on. Rendered after the actions so the DOM order is the visual order.
+  _renderResumeBlockedDetails(overlay, msg, checked);
   return true;
 }
 

package/template/coding-task-manager/public/js/terminal/runtime-21.js

@@ -222,12 +222,23 @@ function _fitTerminalPreservingViewport(s, sessionId, opts) {
     return;
   }
   if (!opts.force && _terminalInputDisplayHoldActive(s)) {
-    clearTimeout(s._terminalInputDeferredFitTimer);
-    s._terminalInputDeferredFitTimer = setTimeout(() => {
-      s._terminalInputDeferredFitTimer = null;
-      _fitTerminalPreservingViewport(s, sessionId, opts);
-    }, TERMINAL_ACTIVE_INPUT_HOLD_MS);
-    return;
+    // The input display hold keeps a focused draft's repaint stable; it does not pin a
+    // grid the pane no longer has. A local fit proposal whose rows are strictly below the
+    // current term.rows is positive evidence the rendered rows are already clipped, so that
+    // case continues through the normal fit pipeline below (which still owes its own
+    // geometry acceptance). Optional, equal-row, row-growth and invalid proposals keep the
+    // old defer-and-rearm behavior untouched.
+    const proposal = _terminalLocalFitProposal(s);
+    const clippedRows = !!proposal && Number.isFinite(proposal.cols) && proposal.cols > 0
+      && Number.isFinite(proposal.rows) && proposal.rows > 0 && proposal.rows < s.term.rows;
+    if (!clippedRows) {
+      clearTimeout(s._terminalInputDeferredFitTimer);
+      s._terminalInputDeferredFitTimer = setTimeout(() => {
+        s._terminalInputDeferredFitTimer = null;
+        _fitTerminalPreservingViewport(s, sessionId, opts);
+      }, TERMINAL_ACTIVE_INPUT_HOLD_MS);
+      return;
+    }
   }
   if (!opts.force && _claudeTuiResizeHoldActive(s)) {
     _scheduleClaudeDeferredFit(s, sessionId, opts, opts.resizeReason || 'fit-preserving-viewport');
@@ -600,6 +611,8 @@ function _launchResumedAgentSession(provider, agentSessionId, cwd, label, ctmSes
     args: spec.args,
     cwd: cwd || undefined,
     label: (label || 'Resumed session').replace(/^Resume:\s*/i, '').slice(0, 60),
+    // D-13: the desktop fork's name is composed by CTM (or echoed from the row), never user intent.
+    titleIntent: 'default',
   });
 }
 

package/template/coding-task-manager/public/js/terminal/runtime-22.js

@@ -24,3 +24,89 @@ function _focusModalPanel(modalEl) {
   modalEl.focus();
   return true;
 }
+
+// WP-1 (session-exit-close-truth-2026-10-24.html §5 D-3, §8 WP-1): this table moved here verbatim
+// from public/index.html, which is exactly at its file-size ceiling. The freed lines are intentional
+// headroom for WP-3/WP-4. Loaded as a classic script before the dashboard's inline script, so the
+// top-level `const` is a shared global; every reader uses it inside a function that runs later.
+// WI-5: cause-specific, non-alarming copy for the enumerated deterministic resume_blocked reason
+// codes the server can send (see server.js markSessionResumeBlocked / _notifyResumePreflightFailure).
+// Branch ONLY on `msg.code` here — never on message text — so this stays correct even if the
+// human-readable message wording changes server-side. An unrecognized code (contract drift, or a
+// code we haven't special-cased yet) falls back to the same honest red failure banner
+// onSessionRestoreFailed already renders, rather than inventing false calm.
+const RESUME_BLOCKED_COPY = {
+  missing_claude_transcript: {
+    tone: 'info',
+    title: "This session's transcript is gone from this machine.",
+    body: 'The file was removed before CTM stored any of its prompts (Claude Code deletes transcripts older than '
+      + 'its retention period, 30 days by default). There is nothing to resume; start a fresh session in the same folder.',
+  },
+  missing_codex_rollout: {
+    tone: 'info',
+    title: "This session's transcript is gone from this machine.",
+    body: 'The file was removed before CTM stored any of its prompts. There is nothing to resume; '
+      + 'start a fresh session in the same folder.',
+  },
+  agent_cli_not_found: {
+    tone: 'warn',
+    title: 'The agent CLI isn’t available on this host.',
+    body: 'CTM could not find the CLI needed to resume this session on this machine. '
+      + 'Install it (or fix PATH), then reload — or start fresh here.',
+  },
+  resume_exit_loop: {
+    tone: 'warn',
+    title: 'This session could not finish resuming.',
+    body: '',
+  },
+  // WP-1 (D-3): the create path's defensive name for a resume that never became ready but carried
+  // no explicit code (lib/session-create/response.js defer -> deferBlockForExit rule 1). Same truth
+  // as the resume_* entries around it; without this entry the enforcement test in
+  // tests/restore-failed-presentation.test.js found the block had no renderer at all.
+  resume_failed: {
+    tone: 'warn',
+    title: 'This session could not finish resuming.',
+    body: '',
+  },
+  resume_no_frame: {
+    tone: 'warn',
+    title: 'The session never painted a usable screen.',
+    body: '',
+  },
+  resume_no_output: {
+    tone: 'warn',
+    title: 'The agent did not respond while resuming.',
+    body: 'It may be waiting on authentication, blocked by configuration, or unavailable on this host.',
+  },
+  // Mixed-version compatibility: current servers normalize this internal
+  // lifecycle reason to resume_no_output before it reaches the browser.
+  no_provider_output: {
+    tone: 'warn',
+    title: 'The agent did not respond while resuming.',
+    body: 'It may be waiting on authentication, blocked by configuration, or unavailable on this host.',
+  },
+  // Compatibility for a server from before the resume lifecycle became provider-neutral.
+  codex_no_output: {
+    tone: 'warn',
+    title: 'Codex did not respond while resuming.',
+    body: 'It may be waiting on authentication, blocked by configuration, or unavailable on this host.',
+  },
+  restore_retries_exhausted: {
+    tone: 'warn',
+    title: 'CTM could not prepare this session after several tries.',
+    body: 'The launch planner kept timing out. Retry now, or start fresh here.',
+  },
+  // WP-1 (D-3, S-12): the two exit-truth codes `deferBlockForExit` (lib/resume-blocked-wire.js) can
+  // return. Without these the create-path defer fell through to the retryable "Preparing session…"
+  // cover with nothing the user could resolve.
+  session_crash_loop: {
+    tone: 'warn',
+    title: 'This session kept exiting and CTM stopped restarting it.',
+    body: 'The agent exited with an error after automatic restarts. Retry now, or start fresh here.',
+  },
+  session_crashed: {
+    tone: 'warn',
+    title: 'This session exited with an error.',
+    body: 'Retry now, or start fresh here.',
+  },
+};

package/template/coding-task-manager/public/js/terminal-history-viewport.js

@@ -648,7 +648,7 @@
         errorCode: String((error && error.code) || message || 'unknown'),
         httpStatus,
         ms: Date.now() - (Number(startedAt) || Date.now()),
-        attempts: 1,
+        attempts: 1, reason: String((error && (error.reason || error.coverageReason)) || '').slice(0, 64) || null, // source-missing diagnosis: the SERVER's own cause (`coverage.reason`/`meta.reason`, e.g. 'no-source'/'source-unreadable'), which err.reason does not carry for the raw-Codex lane. On this line (not its own): the file is at its size ceiling.
       });
     } catch { /* expected: the entry-failure beacon is best-effort and must never block the failure path */ }
   };