create-walle 0.9.26 → 0.9.28

package/template/claude-task-manager/public/js/activation-render-check.js

@@ -20,16 +20,48 @@
 (function (global) {
   'use strict';
 
-  // shouldScheduleCheck({ enabled, renderStableSince, timerPending }) -> boolean
+  function normalizeStableKey(value) {
+    if (value == null) return value == null ? null : value;
+    var t = typeof value;
+    if (t === 'number') return Number.isFinite(value) ? value : null;
+    if (t === 'string' || t === 'boolean') return value;
+    if (Array.isArray(value)) return value.map(normalizeStableKey);
+    if (t === 'object') {
+      var out = {};
+      Object.keys(value).sort().forEach(function (key) {
+        var normalized = normalizeStableKey(value[key]);
+        if (normalized !== undefined) out[key] = normalized;
+      });
+      return out;
+    }
+    return null;
+  }
+
+  function stableKeysEqual(a, b) {
+    try {
+      return JSON.stringify(normalizeStableKey(a)) === JSON.stringify(normalizeStableKey(b));
+    } catch (_) {
+      return false;
+    }
+  }
+
+  // shouldScheduleCheck({ enabled, renderStableSince, timerPending, stableKey, currentKey }) -> boolean
   //  - enabled: the CTM_ACTIVATION_RENDER_CHECK flag (default on).
   //  - renderStableSince: latch timestamp; truthy => already confirmed good for this
   //    activation and nothing has changed since, so the proactive check is redundant.
   //  - timerPending: a check is already armed for this activation (coalesce to one).
+  //  - stableKey/currentKey: optional render-state key. When present, the latch suppresses
+  //    only if it was recorded for the same activation/restoration/content state.
   function shouldScheduleCheck(opts) {
     var o = opts || {};
     if (!o.enabled) return false;
     if (o.timerPending) return false;
-    if (o.renderStableSince) return false;
+    if (o.renderStableSince) {
+      if (Object.prototype.hasOwnProperty.call(o, 'currentKey')) {
+        return !stableKeysEqual(o.stableKey, o.currentKey);
+      }
+      return false;
+    }
     return true;
   }
 
@@ -43,11 +75,17 @@
   function markUnstable() {
     return 0;
   }
+  function markStableKey(currentKey) {
+    return normalizeStableKey(currentKey);
+  }
 
   var api = {
     shouldScheduleCheck: shouldScheduleCheck,
     markStable: markStable,
     markUnstable: markUnstable,
+    markStableKey: markStableKey,
+    normalizeStableKey: normalizeStableKey,
+    stableKeysEqual: stableKeysEqual,
   };
   global.ActivationRenderCheck = api;
   // Dual-environment: node tests require this same file.

package/template/claude-task-manager/public/js/session-phase.js

@@ -0,0 +1,370 @@
+'use strict';
+
+/*
+ * session-phase.js — the single source of truth for "what phase is this session in?"
+ *
+ * Redesign goal (see docs/session-status-redesign.html): replace the patch-on-patch
+ * web of ~40 heuristics across 5 engines with ONE model:
+ *
+ *   1. Raw signals are mapped to independent CONDITIONS, each carrying a CONFIDENCE
+ *      tier ({value, at, source, confidence}). buildSessionConditions() does this.
+ *   2. derivePhase() is the ONLY producer of a phase string. It ranks conditions by
+ *      confidence, never letting a weaker signal demote a stronger one.
+ *
+ * Two design rules encode the operator's guidance:
+ *   - "Rank signals by confidence; don't trust a signal 100% if unsure." → CONFIDENCE
+ *     tiers; PTY-silence and the garble-prone Codex "Working" footer are LOW.
+ *   - "Don't miss events." → an authoritative `idle` (e.g. a Stop hook) may still be
+ *     PROMOTED by strictly-newer liveness evidence, and every such promotion is logged
+ *     via opts.log so a genuinely-missed lifecycle event can be learned from later.
+ *
+ * Isomorphic: same dual node/browser export as session-status-precedence.js, so the
+ * server and the client derive phases from identical code.
+ */
+
+(function initSessionPhase(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.SessionPhase = factory();
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : this, function buildSessionPhase() {
+  // ---- confidence tiers ---------------------------------------------------
+  const CONFIDENCE = { HIGH: 3, MEDIUM: 2, LOW: 1 };
+
+  // ---- freshness windows (one home for every TTL) -------------------------
+  const AUTHORITATIVE_STATUS_TTL_MS = 120000; // hook/telemetry verdict trusted for 2m
+  const SERVER_WORKING_TTL_MS = 10000;
+  const STREAM_STATUS_TTL_MS = 60000;
+  const RECENT_OUTPUT_TTL_MS = 5000;
+  const RECENT_INPUT_TTL_MS = 3000;
+  const CODEX_RUNNING_HOLD_MS = 15000;
+  const ACTIVE_TURN_MAX_QUIET_MS = 45 * 60 * 1000;
+  const WAITING_INPUT_STALE_MS = 30 * 60 * 1000;
+  const OBSERVED_TIME_FUTURE_SKEW_MS = 60 * 1000;
+
+  // ---- phases -------------------------------------------------------------
+  // Strength = priority WITHIN one confidence tier. An actionable prompt outranks
+  // an in-progress turn, which outranks a transient resume, etc.
+  const PHASE_STRENGTH = { needs_you: 5, resuming: 4, running: 3, review: 2, idle: 1 };
+  const PHASE_TEXT = {
+    running: 'Running',
+    needs_you: 'Needs You',
+    resuming: 'Resuming',
+    review: 'Review',
+    idle: 'Idle',
+    exited: 'Exited',
+  };
+  // Legacy status class the existing UI/CSS understands.
+  const PHASE_TO_CLS = {
+    running: 'running',
+    needs_you: 'waiting',
+    resuming: 'resuming',
+    review: 'review',
+    idle: 'idle',
+    exited: 'exited',
+  };
+  const LIVENESS_PHASES = new Set(['running', 'needs_you', 'resuming']);
+
+  function phaseToCls(phase) { return PHASE_TO_CLS[phase] || ''; }
+
+  // ---- time helpers (shared with the legacy module's semantics) -----------
+  function parseTimeMs(value, fallback = 0, parser) {
+    if (value == null || value === '') return fallback || 0;
+    if (typeof parser === 'function') {
+      const parsed = parser(value);
+      if (parsed) return parsed;
+    }
+    if (typeof value === 'number' && Number.isFinite(value)) return value;
+    const parsed = Date.parse(String(value));
+    return Number.isFinite(parsed) ? parsed : (fallback || 0);
+  }
+
+  function normalizeObservedTimeMs(value, fallback = 0, parser, now = Date.now()) {
+    const parsed = parseTimeMs(value, fallback, parser);
+    if (!parsed) return 0;
+    if (parsed > now + OBSERVED_TIME_FUTURE_SKEW_MS) return 0; // impossible future → ignore
+    return parsed > now ? now : parsed; // small skew clamps to now
+  }
+
+  function isFresh(at, now, ttl) {
+    return Boolean(at && at <= now && (now - at) < ttl);
+  }
+
+  function isBlockingWaitingReason(reason) {
+    const text = String(reason || '').toLowerCase();
+    return text === 'approval' || text === 'choice' || text === 'plan' ||
+      /\bapproval\b/.test(text) || /\bpermission\b/.test(text);
+  }
+
+  function normalizeStreamPhase(status) {
+    const text = String(status || '').toLowerCase().replace(/[-\s]+/g, '_');
+    if (!text) return '';
+    if (text === 'busy' || text === 'active' || text === 'thinking' || text === 'running') return 'running';
+    if (text === 'restoring' || text === 'resuming' || text === 'restarting') return 'resuming';
+    if (text === 'waiting' || text === 'waiting_input' || text === 'waiting_for_input') return 'needs_you';
+    if (text === 'idle') return 'idle';
+    if (text === 'review' || text === 'ready_review') return 'review';
+    if (text === 'exited') return 'exited';
+    return '';
+  }
+
+  // ------------------------------------------------------------------------
+  // derivePhase — the ONLY place a phase is decided.
+  // ------------------------------------------------------------------------
+  function condition(phase, confidence, at, source, extra) {
+    return Object.assign({ phase, confidence, at: at || 0, source: source || phase }, extra || {});
+  }
+
+  function stronger(a, b) {
+    // returns the dominant of two conditions (higher confidence, then phase
+    // strength, then freshest evidence).
+    if (!a) return b;
+    if (!b) return a;
+    if (a.confidence !== b.confidence) return a.confidence > b.confidence ? a : b;
+    const sa = PHASE_STRENGTH[a.phase] || 0;
+    const sb = PHASE_STRENGTH[b.phase] || 0;
+    if (sa !== sb) return sa > sb ? a : b;
+    return (a.at || 0) >= (b.at || 0) ? a : b;
+  }
+
+  function derivePhase(conditions, options = {}) {
+    const now = options.now || Date.now();
+    const log = typeof options.log === 'function' ? options.log : null;
+    const list = (conditions || []).filter(Boolean);
+
+    // Terminal state is absolute.
+    const exited = list.find((c) => c.phase === 'exited');
+    if (exited) {
+      return { phase: 'exited', source: exited.source, confidence: exited.confidence, at: exited.at, reason: 'exited' };
+    }
+    if (!list.length) {
+      return { phase: '', source: 'none', confidence: 0, at: 0, reason: 'no-conditions' };
+    }
+
+    let best = null;
+    for (const c of list) best = stronger(best, c);
+
+    let winner = best;
+    let reason = best.source;
+
+    // "Don't miss events": an authoritative idle (Stop hook etc.) must not bury a
+    // genuinely-newer sign of life. Promote — but only upward, only when strictly
+    // newer — and log it, because if events were complete this should not happen.
+    if (best.phase === 'idle') {
+      let promotion = null;
+      for (const c of list) {
+        if (!LIVENESS_PHASES.has(c.phase)) continue;
+        if ((c.at || 0) <= (best.at || 0)) continue; // must be strictly newer than the idle
+        promotion = stronger(promotion, c);
+      }
+      if (promotion) {
+        winner = promotion;
+        reason = `idle-promoted:${promotion.source}`;
+        if (log) {
+          log({
+            event: 'phase:idle-promoted',
+            from: { phase: best.phase, source: best.source, confidence: best.confidence, at: best.at },
+            to: { phase: promotion.phase, source: promotion.source, confidence: promotion.confidence, at: promotion.at },
+            now,
+            note: 'newer liveness evidence overrode an authoritative idle — possible missed lifecycle event',
+          });
+        }
+      }
+    }
+
+    return {
+      phase: winner.phase,
+      source: winner.source,
+      confidence: winner.confidence,
+      at: winner.at,
+      reason,
+    };
+  }
+
+  // ------------------------------------------------------------------------
+  // buildSessionConditions — map raw signals to confidence-ranked conditions.
+  // Accepts the same flat signal shape both server and client can produce.
+  // ------------------------------------------------------------------------
+  function buildSessionConditions(signals = {}, options = {}) {
+    const now = options.now || Date.now();
+    const parser = options.parseTimeMs;
+    const withBaseline = options.baseline !== false;
+    const at = (v, fb = 0) => normalizeObservedTimeMs(v, fb, parser, now);
+    const out = [];
+
+    if (signals.exited) {
+      out.push(condition('exited', CONFIDENCE.HIGH, now, 'exited'));
+      return out;
+    }
+
+    // Wall-E chat tabs have no PTY — their state is fully owned by us (HIGH).
+    if (signals.metaType === 'walle') {
+      if (signals.wallePendingPermission) {
+        out.push(condition('needs_you', CONFIDENCE.HIGH, now, 'walle:pending-permission', { blocking: true }));
+      } else if (signals.walleWaitingInput) {
+        out.push(condition('needs_you', CONFIDENCE.HIGH, now, 'walle:waiting-input', { blocking: true }));
+      } else if (signals.walleGenerating) {
+        out.push(condition('running', CONFIDENCE.HIGH, now, 'walle:generating'));
+      } else {
+        out.push(condition('idle', CONFIDENCE.HIGH, now, 'walle:idle'));
+      }
+      return out;
+    }
+
+    // --- AwaitingInput -----------------------------------------------------
+    if (signals.waitingForInput) {
+      const waitingAt = at(signals.waitingForInputAt, now);
+      const blocking = isBlockingWaitingReason(signals.waitingReason) || !!signals.waitingHasUnsubmittedInput;
+      const staleMs = Math.max(0, Number(signals.waitingInputStaleMs) || WAITING_INPUT_STALE_MS);
+      if (blocking) {
+        // A real approval/permission prompt is sticky — never ages out on its own.
+        out.push(condition('needs_you', CONFIDENCE.HIGH, waitingAt, `waiting:${signals.waitingReason || 'blocking'}`, { blocking: true }));
+      } else if (!waitingAt || (now - waitingAt) <= staleMs) {
+        out.push(condition('needs_you', CONFIDENCE.MEDIUM, waitingAt, `waiting:${signals.waitingReason || 'input'}`));
+      }
+      // stale non-blocking prompt → omitted → ages back to idle
+    }
+
+    // --- Restoring ---------------------------------------------------------
+    if (signals.restoreStarting || signals.restoreResuming || normalizeStreamPhase(signals.restoreStatus) === 'resuming') {
+      out.push(condition('resuming', CONFIDENCE.HIGH, at(signals.restoreStartedAt, now), 'restore'));
+    }
+
+    // --- Authoritative hook / telemetry verdict ----------------------------
+    if (signals.authoritativeSource) {
+      const authAt = at(signals.authoritativeStatusAt);
+      if (isFresh(authAt, now, AUTHORITATIVE_STATUS_TTL_MS)) {
+        if (signals.working) {
+          out.push(condition('running', CONFIDENCE.HIGH, authAt, `authoritative:${signals.authoritativeSource}`));
+        } else {
+          out.push(condition('idle', CONFIDENCE.HIGH, authAt, `authoritative:${signals.authoritativeSource}`));
+        }
+      }
+    }
+
+    // --- TurnOpen (hook/detector-driven) -----------------------------------
+    if (signals.activeTurnOpen) {
+      const started = at(signals.activeTurnStartedAt);
+      const lastEvidence = at(signals.activeTurnLastEvidenceAt);
+      const evidenceAt = Math.max(started, lastEvidence);
+      const maxQuiet = Math.max(0, Number(signals.activeTurnMaxQuietMs) || ACTIVE_TURN_MAX_QUIET_MS);
+      if (evidenceAt && maxQuiet && (now - evidenceAt) <= maxQuiet) {
+        const authoritative = signals.activeTurnSource === 'hook' || signals.activeTurnSource === 'telemetry';
+        out.push(condition('running', authoritative ? CONFIDENCE.HIGH : CONFIDENCE.MEDIUM, evidenceAt,
+          `turn-open:${signals.activeTurnSource || 'evidence'}`));
+      }
+    }
+
+    // --- SessionStateBus ---------------------------------------------------
+    const busPhase = normalizeStreamPhase(signals.busState);
+    if (busPhase === 'running') {
+      out.push(condition('running', CONFIDENCE.MEDIUM, at(signals.busStateAt, now), 'bus:running'));
+    } else if (busPhase === 'resuming') {
+      out.push(condition('resuming', CONFIDENCE.HIGH, at(signals.busStateAt, now), 'bus:resuming'));
+    } else if (busPhase === 'needs_you') {
+      out.push(condition('needs_you', CONFIDENCE.MEDIUM, at(signals.busStateAt, now), 'bus:waiting-input'));
+    }
+
+    // --- Server-observed working signal ------------------------------------
+    const serverWorkingAt = at(signals.serverWorkingAt);
+    if (serverWorkingAt && (now - serverWorkingAt) < SERVER_WORKING_TTL_MS) {
+      out.push(condition('running', CONFIDENCE.MEDIUM, serverWorkingAt, 'server-working'));
+    }
+
+    // --- SessionStream status ----------------------------------------------
+    const streamPhase = normalizeStreamPhase(signals.streamStatus);
+    const streamAt = at(signals.streamStatusAt);
+    if (streamPhase && isFresh(streamAt, now, STREAM_STATUS_TTL_MS)) {
+      out.push(condition(streamPhase, CONFIDENCE.MEDIUM, streamAt, 'stream'));
+    }
+
+    // --- Codex "Working" terminal footer (garble-prone → LOW) --------------
+    if (signals.terminalBusyStatus) {
+      out.push(condition('running', CONFIDENCE.LOW, at(signals.terminalBusyStatusAt, now), 'terminal-busy'));
+    }
+
+    // --- Running holds (inference bridging output bursts → LOW) -------------
+    const holdAt = at(signals.codexRunningEvidenceAt);
+    if (signals.codexRunningHold && holdAt && (now - holdAt) < CODEX_RUNNING_HOLD_MS) {
+      out.push(condition('running', CONFIDENCE.LOW, holdAt, 'codex-running-hold'));
+    }
+    const providerHoldAt = at(signals.providerRunningEvidenceAt);
+    if (signals.providerRunningHold && providerHoldAt && (now - providerHoldAt) < CODEX_RUNNING_HOLD_MS) {
+      out.push(condition('running', CONFIDENCE.LOW, providerHoldAt, 'provider-running-hold'));
+    }
+
+    // --- Recent PTY output (silence-inference → LOW) -----------------------
+    const lastOut = Math.max(at(signals.lastOutputAt), at(signals.metaLastPtyActivity));
+    if (lastOut && (now - lastOut) < RECENT_OUTPUT_TTL_MS) {
+      out.push(condition('running', CONFIDENCE.LOW, lastOut, 'recent-output'));
+    }
+
+    // --- Optimistic local input echo (client-only → LOW) -------------------
+    const lastInput = at(signals.lastInputAt);
+    if (lastInput && (now - lastInput) < RECENT_INPUT_TTL_MS) {
+      out.push(condition('running', CONFIDENCE.LOW, lastInput, 'recent-input'));
+    }
+
+    // --- Activation-preserved running (tab-switch bridge → LOW) -------------
+    if (normalizeStreamPhase(signals.activationPreservedStatus) === 'running') {
+      const until = parseTimeMs(signals.activationPreservedStatusUntil, 0, parser);
+      if (until > now) {
+        out.push(condition('running', CONFIDENCE.LOW, at(signals.activationPreservedStatusCapturedAt, now), 'activation-preserved'));
+      }
+    }
+
+    // --- Baseline idle -----------------------------------------------------
+    // The weakest possible floor so a session with no positive evidence reads idle
+    // instead of unknown. Suppressed with {baseline:false} when the server wants to
+    // explicitly defer ("no opinion") to a downstream consumer.
+    if (withBaseline) {
+      out.push(condition('idle', CONFIDENCE.LOW, lastOut || at(signals.lastInputAt) || 0, 'default-idle'));
+    }
+
+    return out;
+  }
+
+  // ------------------------------------------------------------------------
+  // resolve — convenience wrapper returning the legacy {cls,text,...} contract.
+  // ------------------------------------------------------------------------
+  function resolve(signals = {}, options = {}) {
+    const conditions = buildSessionConditions(signals, options);
+    const derived = derivePhase(conditions, options);
+    const phase = derived.phase || 'idle';
+    return {
+      cls: phaseToCls(phase),
+      text: PHASE_TEXT[phase] || 'Idle',
+      phase,
+      source: derived.source,
+      confidence: derived.confidence,
+      reason: derived.reason,
+      conditions,
+    };
+  }
+
+  return {
+    CONFIDENCE,
+    PHASE_STRENGTH,
+    PHASE_TEXT,
+    PHASE_TO_CLS,
+    AUTHORITATIVE_STATUS_TTL_MS,
+    SERVER_WORKING_TTL_MS,
+    STREAM_STATUS_TTL_MS,
+    RECENT_OUTPUT_TTL_MS,
+    RECENT_INPUT_TTL_MS,
+    CODEX_RUNNING_HOLD_MS,
+    ACTIVE_TURN_MAX_QUIET_MS,
+    WAITING_INPUT_STALE_MS,
+    OBSERVED_TIME_FUTURE_SKEW_MS,
+    phaseToCls,
+    isBlockingWaitingReason,
+    normalizeObservedTimeMs,
+    normalizeStreamPhase,
+    parseTimeMs,
+    condition,
+    derivePhase,
+    buildSessionConditions,
+    resolve,
+  };
+});

package/template/claude-task-manager/public/js/setup.js

@@ -122,6 +122,9 @@ async function tryOtherMicrosoftLoginProvider() {
 var _microsoftTunnelAccessMode = 'ctm_authenticated';
 var _microsoftTunnelAccessModeTouched = false;
 var _activeDeviceClaim = null;
+var _recommendedPhoneCopiedValue = '';
+var _recommendedPhoneCopiedUntil = 0;
+var _recommendedPhoneCopyTimer = null;
 var _deviceClaimScopeUpdateTimer = null;
 var _deviceClaimScopeUpdateSeq = 0;
 var _deviceScopeControlsBound = false;
@@ -2459,6 +2462,49 @@ function _phoneOriginEmptyHint(method) {
   return 'Sign in to Tailscale to generate a phone URL';
 }
 
+function _recommendedPhoneUrlIsCopyable(value) {
+  return /^https?:\/\//i.test(String(value || '').trim());
+}
+
+function _renderRecommendedPhoneCopy(value) {
+  var button = document.getElementById('setup-phone-best-copy');
+  var label = document.getElementById('setup-phone-best-copy-label');
+  if (!button && !label) return;
+  var text = String(value || '').trim();
+  var copyable = _recommendedPhoneUrlIsCopyable(text);
+  var copied = copyable
+    && text === _recommendedPhoneCopiedValue
+    && Date.now() < _recommendedPhoneCopiedUntil;
+  if (button) {
+    button.disabled = !copyable;
+    button.classList.toggle('is-copied', copied);
+    button.setAttribute('data-copy-value', copyable ? text : '');
+    button.setAttribute('aria-label', copyable ? ('Copy phone URL ' + text) : 'No phone URL available to copy');
+  }
+  if (label) label.textContent = copied ? 'Copied' : 'Copy';
+}
+
+async function _writeTextToClipboard(text) {
+  if (navigator.clipboard && typeof navigator.clipboard.writeText === 'function') {
+    await navigator.clipboard.writeText(text);
+    return;
+  }
+  var area = document.createElement('textarea');
+  area.value = text;
+  area.setAttribute('readonly', '');
+  area.style.position = 'fixed';
+  area.style.left = '-9999px';
+  area.style.top = '0';
+  document.body.appendChild(area);
+  area.select();
+  try {
+    var ok = document.execCommand && document.execCommand('copy');
+    if (!ok) throw new Error('Copy command failed');
+  } finally {
+    area.remove();
+  }
+}
+
 function _renderRecommendedPhoneOrigin(origin, method) {
   // Until /api/setup/network resolves, _lastNetworkSettings is null and we
   // cannot know the real origin yet — show an explicit loading state instead
@@ -2470,11 +2516,13 @@ function _renderRecommendedPhoneOrigin(origin, method) {
     ? (walleReady ? 'Walle Remote URL' : 'Walle Remote status')
     : (method === 'cloudflare' ? 'Recommended Cloudflare URL' : (method === 'microsoft' ? 'Microsoft tunnel URL' : 'Recommended Tailscale URL'));
   var best = document.getElementById('setup-phone-best-url');
-  if (best) best.textContent = !loaded
+  var bestText = !loaded
     ? 'Resolving…'
     : (method === 'walle'
       ? (walleReady ? _walleRemoteUsableMobileUrl(_lastNetworkSettings || {}) : 'Hosted relay unavailable')
       : (origin ? origin.replace(/\/+$/, '') + '/m/' : (method === 'microsoft' ? 'Start tunnel first' : '')));
+  if (best) best.textContent = bestText;
+  _renderRecommendedPhoneCopy(bestText);
   var phoneInput = document.getElementById('setup-device-origin');
   if (phoneInput) phoneInput.placeholder = origin
     ? ''
@@ -3785,6 +3833,7 @@ async function loadNetworkSettings() {
     // the Pairing Origin field doesn't stay stuck on it. Let the user type one.
     var bestUrl = document.getElementById('setup-phone-best-url');
     if (bestUrl && bestUrl.textContent === 'Resolving…') bestUrl.textContent = 'Unavailable';
+    _renderRecommendedPhoneCopy((bestUrl && bestUrl.textContent) || 'Unavailable');
     var phoneInput = document.getElementById('setup-device-origin');
     if (phoneInput && phoneInput.placeholder === 'Resolving phone URL…') {
       phoneInput.placeholder = 'Enter your phone URL manually';
@@ -5053,6 +5102,29 @@ async function copyDeviceClaimUrl() {
   }
 }
 
+async function copyRecommendedPhoneUrl() {
+  var button = document.getElementById('setup-phone-best-copy');
+  var best = document.getElementById('setup-phone-best-url');
+  var text = String((button && button.getAttribute('data-copy-value')) || (best && best.textContent) || '').trim();
+  if (!_recommendedPhoneUrlIsCopyable(text)) {
+    _renderRecommendedPhoneCopy(text);
+    return;
+  }
+  try {
+    await _writeTextToClipboard(text);
+    _recommendedPhoneCopiedValue = text;
+    _recommendedPhoneCopiedUntil = Date.now() + 1800;
+    _renderRecommendedPhoneCopy(text);
+    if (_recommendedPhoneCopyTimer) clearTimeout(_recommendedPhoneCopyTimer);
+    _recommendedPhoneCopyTimer = setTimeout(function() {
+      _renderRecommendedPhoneCopy(text);
+    }, 1850);
+    setupToast('Phone URL copied');
+  } catch (_) {
+    setupToast('Copy failed', 'error');
+  }
+}
+
 // ── MCP Integrations ────────────────────────────────────────────────
 var MCP_ICONS = {
   'Claude Code': '\uD83E\uDD16',
@@ -6419,6 +6491,7 @@ SETUP.removeDeviceConnection = removeDeviceConnection;
 SETUP.revokeDevice = revokeDevice;
 SETUP.createDeviceClaim = createDeviceClaim;
 SETUP.copyDeviceClaimUrl = copyDeviceClaimUrl;
+SETUP.copyRecommendedPhoneUrl = copyRecommendedPhoneUrl;
 SETUP.loadWalleRemoteStatus = loadWalleRemoteStatus;
 SETUP.createWalleRemoteClaim = createWalleRemoteClaim;
 SETUP.copyWalleRemoteClaimUrl = copyWalleRemoteClaimUrl;

package/template/claude-task-manager/public/js/stream-view.js

@@ -1221,6 +1221,56 @@ function populateConversationView(container, events) {
   container.scrollTop = container.scrollHeight;
 }
 
+function _conversationRenderYield() {
+  return new Promise((resolve) => {
+    if (typeof requestAnimationFrame === 'function') requestAnimationFrame(() => resolve());
+    else setTimeout(resolve, 0);
+  });
+}
+
+async function populateConversationViewChunked(container, events, opts) {
+  opts = opts || {};
+  container.textContent = '';
+  if (container.dataset) container.dataset.turnMode = container.dataset.turnMode || 'conversation';
+  const sessionId = container.dataset?.sessionId || '';
+  if (!events || events.length === 0) {
+    _renderConversationState(container, 'No transcript messages found for this session.');
+    container.scrollTop = container.scrollHeight;
+    return true;
+  }
+  const isCurrent = typeof opts.isCurrent === 'function' ? opts.isCurrent : () => true;
+  const batchSize = Math.max(10, Number(opts.batchSize) || 80);
+  const budgetMs = Math.max(4, Number(opts.budgetMs) || 12);
+  let batchStartedAt = Date.now();
+  for (let i = 0; i < events.length; i += 1) {
+    if (!isCurrent()) return false;
+    const evt = events[i];
+    if (_isPromptTurnContainer(container)) {
+      if (_appendConversationEventToTurns(container, evt, { expandPrompt: false, collapseExisting: false, expandSetup: false })) {
+        _markConversationEventSeen(sessionId, evt);
+      }
+    } else if (_applyStructuredToolEvent(container, evt)) {
+      _markConversationEventSeen(sessionId, evt);
+    } else {
+      const el = renderConversationEvent(evt);
+      if (el) {
+        if (evt.data?.parentUuid) _assignConversationParentUuid(el, evt.data.parentUuid);
+        if (!_mergeConsecutiveToolGroups(container, el)) container.appendChild(el);
+        _markConversationEventSeen(sessionId, evt);
+      }
+    }
+    if ((i + 1) % batchSize === 0 || (Date.now() - batchStartedAt) >= budgetMs) {
+      await _conversationRenderYield();
+      batchStartedAt = Date.now();
+    }
+  }
+  if (!isCurrent()) return false;
+  _linkConversationDocumentReferences(container, container);
+  if (_isPromptTurnContainer(container)) _refreshLatestPromptTurnStatus(container.dataset?.sessionId || '', container);
+  container.scrollTop = container.scrollHeight;
+  return true;
+}
+
 // --- WS Integration ---
 
 function subscribeToStream(ws, sessionId) {
@@ -2295,7 +2345,7 @@ async function _fetchConversationPage(sessionId, offset, opts) {
   let firstEmptyPage = null;
   for (const candidate of candidates) {
     let url = `/api/session/messages?id=${encodeURIComponent(candidate.id)}`
-      + `&offset=${offset}&limit=${CONVERSATION_TURN_PAGE_SIZE}&mode=turns`;
+      + `&offset=${offset}&limit=${CONVERSATION_TURN_PAGE_SIZE}&mode=turns&compact=conversation`;
     if (candidate.projectEntry) url += `&project=${encodeURIComponent(candidate.projectEntry)}`;
     if (opts.fresh && offset === 0) url += '&nocache=1';
     const resp = await fetch(url, { cache: 'no-store' });
@@ -2449,7 +2499,10 @@ async function _primeConversationView(sessionId, convView, opts) {
       _hydrateLatestAnswerFromConversationMessages(sessionId, page.messages, 'conversation-tab');
       _syncPromptNavFromConversationMessages(sessionId, page);
       const events = _messagesToEvents(page.messages);
-      populateConversationView(convView, events);
+      const rendered = await populateConversationViewChunked(convView, events, {
+        isCurrent: () => _primeStillCurrent(sessionId, token, convView),
+      });
+      if (!rendered) return;
 
       // Seed the parentUuid dedup set from the primed history so live
       // stream-events that cover the same turns don't re-append.
@@ -2656,6 +2709,7 @@ if (typeof module !== 'undefined' && module.exports) {
     _fetchConversationPage,
     renderConversationEvent,
     populateConversationView,
+    populateConversationViewChunked,
     _mergeConsecutiveToolGroups,
     _captureConversationScrollAnchor,
     _restoreConversationScrollAnchor,