claude-code-kanban 4.25.0 → 4.26.0

package/README.md

@@ -51,7 +51,7 @@ Tasks, agents, and messages appear on the board automatically — Claude Code wr
 - **Follow & pin** — Follow the latest message live (`Shift+M`), pin the messages that matter
 - **Tool stats & impact** — Per-session tool usage breakdown and file impact
 - **Waiting-for-user indicators** — Amber highlight on sessions needing permission or input
-- **UI approvals (opt-in)** — Allow/deny permission asks and answer questions from the board — [docs](docs/ui-approvals.md)
+- **UI approvals** — Allow/deny permission asks and answer questions from the board; on by default, opt out per config dir — [docs](docs/ui-approvals.md)
 - **Agent teams** — Color-coded team members, owner filtering, member count badges
 - **17 color themes** — Dracula, Nord, Catppuccin, Gruvbox, Tokyo Night, and more — each in light and dark
 - **Storage manager** — Inspect disk usage and clean up stale sessions and tasks

package/install.js

@@ -130,12 +130,27 @@ async function runInstall({ pluginOnly = false } = {}) {
     if (!upd.ok) console.log(`    ${yellow('⚠')} Marketplace refresh failed: ${upd.error}`);
 
     const inst = runCLI('claude plugin install claude-code-kanban@claude-code-kanban', ['already installed', 'already exists']);
+    const alreadyInstalled = inst.idempotent || /already installed/i.test(inst.output || '');
     if (inst.ok) {
-      console.log(`    ${green('✓')} ${inst.idempotent ? 'Already installed' : 'Plugin installed'}`);
+      console.log(`    ${green('✓')} ${alreadyInstalled ? 'Already installed' : 'Plugin installed'}`);
     } else {
       console.log(`    ${red('✗')} Plugin install failed: ${inst.error}`);
       failed = true;
     }
+
+    // `install` is a no-op once the plugin is present — it exits 0 and only says so
+    // on stdout — so a re-copied plugin keeps running from the old cached version
+    // until `update` pulls the new one in. That is how a config dir ends up serving
+    // a plugin older than the board it talks to.
+    if (alreadyInstalled) {
+      const upgrade = runCLI('claude plugin update claude-code-kanban', ['already at the latest']);
+      if (upgrade.ok) {
+        const line = (upgrade.output || '').split('\n').find(l => l.includes('updated from'));
+        console.log(`    ${green('✓')} ${line ? line.replace(/^[^A-Za-z]*/, '') : 'Already at the latest version'}`);
+      } else {
+        console.log(`    ${yellow('⚠')} Plugin update failed: ${upgrade.error}`);
+      }
+    }
   } else {
     console.log(`    ${dim('Skipped')}`);
   }

package/lib/approvals.js

@@ -63,20 +63,51 @@ function isDecisionFile(name) {
 // (PERMISSION_TTL_MS hides the card at 30 min, so waiting longer than the UI
 // can show the ask is strictly worse — D11); keep them in sync with
 // approval-gate.sh.
-const WAIT_SECONDS_DEFAULT = 30;
+const WAIT_SECONDS_DEFAULT = 1800;
 const WAIT_SECONDS_MAX = 1800;
 // Small grace over the gate's own deadline so a race never 410s a live hook
 const LAPSE_GRACE_MS = 5000;
-
 function waitSecondsFrom(cfg) {
   const raw = cfg && cfg.waitSeconds;
   if (Number.isInteger(raw) && raw >= 0) return Math.min(raw, WAIT_SECONDS_MAX);
   return WAIT_SECONDS_DEFAULT;
 }
 
+// Normalizes the `approvals` section of <CCK_DIR>/config.json. The gate is on
+// by default: only an explicit `enabled: false` turns it off, and anything
+// unparseable falls back to defaults — the same parse approval-gate.sh does.
+function approvalsFrom(cfg) {
+  const a = cfg && typeof cfg.approvals === 'object' && cfg.approvals ? cfg.approvals : {};
+  return {
+    enabled: a.enabled !== false,
+    mode: a.mode === 'permission' ? 'permission' : 'permission+question',
+    waitSeconds: waitSecondsFrom(a),
+  };
+}
+
+// Whether the hook waits for a board decision on a marker of this kind
+function isKindGated(kind, approvals) {
+  if (!approvals.enabled) return false;
+  if (kind === 'question') return approvals.mode === 'permission+question';
+  return true;
+}
+
+// Why the board may not answer this marker, or null when it may. Shared by the
+// session list (which hides the buttons) and the respond route (which refuses),
+// so the two can never disagree.
+function boardRefusal(marker, approvals, now = Date.now()) {
+  if (!isKindGated(marker.kind, approvals)) {
+    return { status: 410, error: 'UI approvals are off for this ask — answer it in the terminal' };
+  }
+  if (isLapsed(marker.timestamp, approvals.waitSeconds * 1000, now)) {
+    return { status: 410, error: 'Ask lapsed — answer it in the terminal' };
+  }
+  return null;
+}
+
 function isLapsed(timestamp, waitMs, now = Date.now()) {
   if (!timestamp) return true;
   return now - new Date(timestamp).getTime() > waitMs + LAPSE_GRACE_MS;
 }
 
-module.exports = { sanitizeRequestId, buildDecision, decisionFileName, isDecisionFile, waitSecondsFrom, isLapsed };
+module.exports = { sanitizeRequestId, buildDecision, decisionFileName, isDecisionFile, waitSecondsFrom, approvalsFrom, isKindGated, boardRefusal, isLapsed };

package/lib/parsers.js

@@ -1296,6 +1296,69 @@ function buildAgentProgressMap(jsonlPath) {
   return buildSessionDigest(jsonlPath).progressMap;
 }
 
+const ARTIFACT_URL_RE = /https:\/\/claude\.ai\/\S*artifact\/[A-Za-z0-9_-]+/;
+
+function toolResultText(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content.filter(b => b?.type === 'text' && b.text).map(b => b.text).join('\n');
+}
+
+// Two kinds of line record a published artifact: the `frame-link` entry the
+// viewer writes, which carries the title, and the result of an Artifact publish,
+// which is there even when the artifact was never opened in a frame. Keyed by URL,
+// so the republishes of one page collapse into a single entry. A result counts
+// only when its tool_use_id belongs to a publish call — an artifact URL quoted
+// back by a grep or a file read would otherwise register another session's page as
+// this session's own, and a `read` of someone else's artifact is not a publish.
+function readArtifactLinks(jsonlPath) {
+  const byUrl = new Map();
+  const publishedFileByToolUseId = new Map();
+  const upsert = (url, ts) => {
+    let a = byUrl.get(url);
+    if (!a) {
+      a = { url, title: null, path: null, firstSeen: ts || null };
+      byUrl.set(url, a);
+    }
+    if (ts && (!a.firstSeen || ts < a.firstSeen)) a.firstSeen = ts;
+    return a;
+  };
+  try {
+    const content = readFileSync(jsonlPath, 'utf8');
+    for (const line of content.split('\n')) {
+      if (!line.includes('"frame-link"') && !line.includes('"name":"Artifact"') && !line.includes('claude.ai'))
+        continue;
+      let obj;
+      try { obj = JSON.parse(line); } catch (_) { continue; }
+      if (obj.type === 'frame-link' && obj.frameUrl) {
+        const a = upsert(obj.frameUrl, obj.timestamp);
+        if (obj.title) a.title = obj.title;
+        if (obj.path) a.path = obj.path;
+        continue;
+      }
+      const blocks = obj?.message?.content;
+      if (!Array.isArray(blocks)) continue;
+      for (const b of blocks) {
+        if (b?.type === 'tool_use') {
+          const input = b.name === 'Artifact' ? b.input || {} : null;
+          // The publish action is the default one, so it is spelled by the file it
+          // takes rather than by a name.
+          if (b.id && input?.file_path && (!input.action || input.action === 'publish')) {
+            publishedFileByToolUseId.set(b.id, input.file_path);
+          }
+          continue;
+        }
+        if (b?.type !== 'tool_result' || !publishedFileByToolUseId.has(b.tool_use_id)) continue;
+        const m = toolResultText(b.content).match(ARTIFACT_URL_RE);
+        if (!m) continue;
+        const a = upsert(m[0], obj.timestamp);
+        if (!a.path) a.path = publishedFileByToolUseId.get(b.tool_use_id);
+      }
+    }
+  } catch (_) {}
+  return [...byUrl.values()].sort((x, y) => (x.firstSeen < y.firstSeen ? -1 : x.firstSeen > y.firstSeen ? 1 : 0));
+}
+
 function readCompactSummaries(jsonlPath) {
   const results = [];
   // Inline format: newer Claude Code stores the summary directly in the parent
@@ -1634,6 +1697,7 @@ module.exports = {
   buildAgentProgressMap,
   buildSessionDigest,
   readCompactSummaries,
+  readArtifactLinks,
   findTerminatedTeammates,
   extractPromptFromTranscript,
   extractModelFromTranscript,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-kanban",
-  "version": "4.25.0",
+  "version": "4.26.0",
   "description": "A web-based Kanban board for viewing Claude Code tasks with agent teams support",
   "main": "server.js",
   "bin": {

package/plugin/plugins/claude-code-kanban/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-kanban",
-  "version": "2.11.0",
+  "version": "2.12.0",
   "description": "claude-code-kanban dashboard integration: agent activity tracking, context statusline, skills to drive the board from a session and to follow it",
   "experimental": {
     "monitors": "./monitors.json"

package/plugin/plugins/claude-code-kanban/scripts/approval-gate.sh

@@ -1,13 +1,13 @@
 #!/bin/bash
 # Blocking approval gate: lets the cck board answer a permission ask or an
 # AskUserQuestion. Always writes the _waiting.json marker first (badge behavior
-# is unchanged when the feature is off), then — only when explicitly enabled and
-# the board's server is alive — waits for a decision file written by the server.
+# is unchanged when the feature is off), then — unless config.json opts out, and
+# only while the board's server is alive — waits for a decision file written by the server.
 #
 # Contract (_plans/cck-ui-approvals/decisions.md), rooted at <CLAUDE_CONFIG_DIR or ~/.claude>/.cck:
 #   marker    agent-activity/<sid>/_waiting.json            (D8: + id, cwd, permissionSuggestions)
 #   decision  agent-activity/<sid>/_decision-<id>.json      (server writes it, Phase 3)
-#   config    approvals.json {enabled, mode, waitSeconds}   (D2: fail-open when absent)
+#   config    config.json {approvals: {enabled, mode, waitSeconds}}  (on by default; absent = defaults)
 #   liveness  server.json {port, pid}                       (D1: a dead board costs nothing)
 #
 # First writer wins (D5): a terminal answer deletes the marker via PostToolUse
@@ -61,37 +61,58 @@ echo "$INPUT" | jq -c --arg kind "$KIND" --arg ts "$TS" --arg id "$REQ_ID" '{
 # Every exit below leaves the marker in place for the badge; agent-spy.sh's
 # PostToolUse (or the server's TTL) retires it, exactly as before this feature.
 
-CONFIG="$CCK_DIR/approvals.json"
-[ -f "$CONFIG" ] || exit 0
-ENABLED=""
-eval "$(jq -r '
-  @sh "ENABLED=\(.enabled // false)",
-  @sh "MODE=\(.mode // "permission")",
-  @sh "WAIT_SECONDS=\(.waitSeconds // 30)"
-' < "$CONFIG" 2>/dev/null)"
-[ "$ENABLED" = "true" ] || exit 0
+# Defaults mirror lib/approvals.js — keep in sync. A missing or unparseable
+# config.json means defaults, i.e. the gate is on.
+ENABLED="true"
+MODE="permission+question"
+WAIT_SECONDS=""
+CONFIG="$CCK_DIR/config.json"
+if [ -f "$CONFIG" ]; then
+  eval "$(jq -r '
+    @sh "ENABLED=\(if .approvals.enabled == false then "false" else "true" end)",
+    @sh "MODE=\(.approvals.mode // "permission+question")",
+    @sh "WAIT_SECONDS=\(.approvals.waitSeconds // "")"
+  ' < "$CONFIG" 2>/dev/null)"
+fi
+[ "$ENABLED" = "false" ] && exit 0
 
 if [ "$KIND" = "question" ] && [ "$MODE" != "permission+question" ]; then
   exit 0
 fi
 
-case "$WAIT_SECONDS" in *[!0-9]* | "") WAIT_SECONDS=30 ;; esac
+case "$WAIT_SECONDS" in *[!0-9]* | "") WAIT_SECONDS=1800 ;; esac
 # PERMISSION_TTL_MS hides the card at 30 min — waiting longer than the UI can
 # show the ask is strictly worse than giving up (D11)
 [ "$WAIT_SECONDS" -gt 1800 ] && WAIT_SECONDS=1800
 
 SERVER_INFO="$CCK_DIR/server.json"
-[ -f "$SERVER_INFO" ] || exit 0
-SERVER_PORT=$(jq -r '.port // empty' < "$SERVER_INFO" 2>/dev/null)
-[ -n "$SERVER_PORT" ] || exit 0
+
 # A TCP connect beats a pid probe: it proves the board is actually serving, and
 # it works in the stripped environment Claude Code spawns hooks into, where
-# kill -0 cannot see native Windows pids and ps may be missing from PATH
-(: < "/dev/tcp/127.0.0.1/$SERVER_PORT") 2>/dev/null || exit 0
+# kill -0 cannot see native Windows pids and ps may be missing from PATH. The
+# port is re-read on every probe, not cached: under the hub every sub-app binds
+# an ephemeral port, so a board that restarts mid-wait comes back on a new one.
+# $(<file) and =~ keep the probe free of jq and cat spawns (~280 ms each here).
+board_alive() {
+  local raw port
+  raw=$(<"$SERVER_INFO") 2>/dev/null || return 1
+  [[ $raw =~ \"port\"[[:space:]]*:[[:space:]]*([0-9]+) ]] || return 1
+  port=${BASH_REMATCH[1]}
+  (: < "/dev/tcp/127.0.0.1/$port") 2>/dev/null
+}
 
 DECISION="$DIR/_decision-$REQ_ID.json"
 # EPOCHSECONDS (bash 5) keeps the poll loop free of `date` spawns
 DEADLINE=$((EPOCHSECONDS + WAIT_SECONDS))
+# Probing once up front made one unreachable moment disarm the whole ask, so a
+# board restarting on a new port (every hub-spawned sub-app binds an ephemeral
+# one) took the ask with it. Probe on a cadence instead and only give up once
+# the board has been gone for the whole grace. The terminal prompt stays live
+# throughout either way.
+BOARD_PROBE_SECONDS=5
+BOARD_GRACE_SECONDS=15
+NEXT_PROBE=0
+UNREACHABLE_SINCE=0
 
 while :; do
   if [ -f "$DECISION" ]; then
@@ -136,6 +157,20 @@ while :; do
   IFS= read -r CUR_MARKER < "$MARKER" 2>/dev/null || exit 0
   case "$CUR_MARKER" in *"\"id\":\"$REQ_ID\""*) ;; *) exit 0 ;; esac
 
+  if [ "$EPOCHSECONDS" -ge "$NEXT_PROBE" ]; then
+    NEXT_PROBE=$((EPOCHSECONDS + BOARD_PROBE_SECONDS))
+    # No beacon at all = no board on this config dir, now or a moment ago: give
+    # up at once, exactly as before. A beacon whose port is closed is the
+    # restart window instead, so that one gets the grace.
+    [ -f "$SERVER_INFO" ] || exit 0
+    if board_alive; then
+      UNREACHABLE_SINCE=0
+    else
+      [ "$UNREACHABLE_SINCE" -eq 0 ] && UNREACHABLE_SINCE=$EPOCHSECONDS
+      [ $((EPOCHSECONDS - UNREACHABLE_SINCE)) -ge "$BOARD_GRACE_SECONDS" ] && exit 0
+    fi
+  fi
+
   [ "$EPOCHSECONDS" -ge "$DEADLINE" ] && exit 0
   sleep 0.5
 done

package/public/app.js

@@ -30,6 +30,12 @@ let sessionFilter = FILTER_DEFAULTS.session;
 // Only meaningful while sessionFilter === 'active' (filterBySessions clears it otherwise)
 const activityFilter = new Set(); // kinds: 'waiting' | 'active'
 let sessionLimit = FILTER_DEFAULTS.limit;
+// Narrows the sidebar to the open session only. Kept out of FILTER_DEFAULTS/updateUrl because it
+// is not a filter — it has no select, no summary token, and never reaches the session picker.
+// Persisted in localStorage rather than the URL: the hub recreates each iframe at the app's base
+// URL, so a query string would not survive a hub reload.
+const ZEN_KEY = 'zenMode';
+let zenMode = store.getItem(ZEN_KEY) === 'true';
 let filterProject = FILTER_DEFAULTS.project; // null = all, '__recent__' = last 24h, or project path
 let recentProjects = new Set();
 let projectsCacheDirty = true;
@@ -144,6 +150,9 @@ function resetState() {
   sessionFilter = FILTER_DEFAULTS.session;
   sessionLimit = FILTER_DEFAULTS.limit;
   filterProject = FILTER_DEFAULTS.project;
+  zenMode = false;
+  store.removeItem(ZEN_KEY);
+  renderZenState();
   ownerFilter = '';
   searchQuery = '';
   viewMode = 'all';
@@ -193,7 +202,7 @@ async function fetchSessions(includeTasks = true) {
     if (revealedStorageSessionId) allPinnedIds.add(revealedStorageSessionId);
     // When server filters by activity, the focused session may not be active —
     // include it in pinned so the server still returns it.
-    if (sessionFilter === 'active' && currentSessionId) allPinnedIds.add(currentSessionId);
+    if ((sessionFilter === 'active' || zenMode) && currentSessionId) allPinnedIds.add(currentSessionId);
     const pinnedParam = allPinnedIds.size > 0 ? `&pinned=${[...allPinnedIds].join(',')}` : '';
     const projectParam =
       filterProject && filterProject !== '__recent__' ? `&project=${encodeURIComponent(filterProject)}` : '';
@@ -493,6 +502,7 @@ async function fetchAgents(sessionId) {
       lastWaitingHash = waitHash;
       if (messagePanelOpen && currentMessages.length) renderMessages(currentMessages);
       maybeFollowLatest();
+      maybeAutoOpenWaiting();
     }
   } catch (e) {
     console.error('[fetchAgents]', e);
@@ -2181,6 +2191,10 @@ function isZoomableModalOpen() {
   return document.querySelector('.modal-overlay.visible .modal-zoomable') !== null;
 }
 
+function isAnyModalOpen() {
+  return document.querySelector('.modal-overlay.visible') !== null;
+}
+
 const ZOOM_KEYS = { '+': 0.1, '=': 0.1, NumpadAdd: 0.1, '-': -0.1, _: -0.1, NumpadSubtract: -0.1, 0: 0, Numpad0: 0 };
 
 let _toastTimer = null;
@@ -3167,20 +3181,32 @@ function getFilteredSessions() {
   return filteredSessions;
 }
 
+// A live refresh would replace the zen panel's link-a-file input mid-type, the same way it
+// would swallow a half-typed group name. Off zen there is no panel, so skip the DOM probe.
+function zenPanelIsEditing() {
+  return zenMode && !!sessionsList.querySelector('.linked-doc-input');
+}
+
 function renderSessions() {
   // Rebuilding the list under the pointer cancels an in-flight drop and would swallow a
   // half-typed group name, and the SSE path can fire at any moment — defer instead.
-  if (sgDrag || sgIsEditing()) return;
+  if (sgDrag || sgIsEditing() || zenPanelIsEditing()) return;
   // Update project dropdown
   updateProjectDropdown();
 
-  const filteredSessions = getFilteredSessions();
+  // Zen narrows the rendered list only — the session picker keeps calling getFilteredSessions()
+  // and still offers everything, or there would be no way to switch sessions without leaving zen.
+  const zenSession = zenMode && currentSessionId ? sessions.find((s) => s.id === currentSessionId) : null;
+  const filteredSessions = zenMode ? (zenSession ? [zenSession] : []) : getFilteredSessions();
 
   if (filteredSessions.length === 0) {
     let emptyMsg = 'No sessions found';
     let emptyHint = 'Tasks appear when you use Claude Code';
 
-    if (searchQuery) {
+    if (zenMode) {
+      emptyMsg = 'Zen mode: no session open';
+      emptyHint = 'Press Shift+Z to leave zen mode, then open a session';
+    } else if (searchQuery) {
       emptyMsg = `No results for "${searchQuery}"`;
       emptyHint = 'Try a different search term or clear the search';
     } else if (filterProject && sessionFilter === 'active') {
@@ -3209,9 +3235,7 @@ function renderSessions() {
     const isActive = session.id === currentSessionId && viewMode === 'session';
     const isLive = isSessionLive(session);
     const sessionName = sessionDisplayName(session);
-    const useGrouped = sessionFilter === 'active' && session.project;
-    const primaryName = useGrouped ? sessionName : session.project ? session.project.split('/').pop() : sessionName;
-    const secondaryName = useGrouped ? null : session.project ? sessionName : null;
+    const projectHtml = renderProjectIdentity(session);
 
     const gitBranch = session.gitBranch ? escapeHtml(session.gitBranch) : null;
     const createdDisplay = session.createdAt ? formatDate(session.createdAt) : '';
@@ -3220,7 +3244,9 @@ function renderSessions() {
       session.createdAt && createdDisplay !== modifiedDisplay
         ? `Created ${createdDisplay} · Modified ${modifiedDisplay}`
         : modifiedDisplay;
-    const tooltip = [session.id, timeDisplay, gitBranch ? `Branch: ${gitBranch}` : ''].filter(Boolean).join(' | ');
+    const tooltip = [session.id, session.project, timeDisplay, gitBranch ? `Branch: ${gitBranch}` : '']
+      .filter(Boolean)
+      .join(' | ');
     const isTeam = session.isTeam;
     const memberCount = session.memberCount || 0;
 
@@ -3228,7 +3254,8 @@ function renderSessions() {
     const pinClass = pinState === 'sticky' ? ' sticky' : pinState === 'pinned' ? ' pinned' : '';
     const pinTitle =
       pinState === 'pinned' || pinState === 'sticky' ? 'Unpin session (.)' : 'Pin session (. · > sticky)';
-    const showCtx = !!session.contextStatus;
+    // Zen renders the full context detail below the card, so the compact bar would just repeat it.
+    const showCtx = !!session.contextStatus && !zenMode;
     const linkedDocsCount = getSessionPreviewPaths(session.id).length;
     const bookmarksCount = loadPins(session.id).length;
     const hasScratchpad = !!(store.getItem(_sessionScratchpadKey(session.id)) || '').trim();
@@ -3237,8 +3264,8 @@ function renderSessions() {
     return `
           <button onclick="fetchTasks('${sid}')" draggable="true" data-session-id="${escapeHtml(session.id)}" class="session-item ${isActive ? 'active' : ''} ${session.hasWaitingForUser ? 'permission-pending' : ''} ${tempClass} ${showCtx ? 'has-context' : ''}" title="${escapeHtml(tooltip)}">
             <span class="session-pin-btn${pinClass}" onclick="event.stopPropagation();toggleSessionPin('${sid}')" title="${pinTitle} session">${pinState === 'sticky' ? SESSION_STAR_SVG : SESSION_PIN_SVG}</span>
-            <div class="session-name">${escapeHtml(primaryName)}</div>
-            ${secondaryName ? `<div class="session-secondary">${escapeHtml(secondaryName)}</div>` : ''}
+            <div class="session-name">${escapeHtml(sessionName)}</div>
+            ${projectHtml ? `<div class="session-secondary">${projectHtml}</div>` : ''}
             ${gitBranch ? `<div class="session-branch">${gitBranch}</div>` : ''}
             ${session.planTitle ? `<div class="session-plan">${escapeHtml(session.planTitle)}</div>` : ''}
             ${renderGoalSubtitle(session)}
@@ -3267,6 +3294,21 @@ function renderSessions() {
         `;
   };
 
+  // Zen draws one card and its panel, so it returns before the grouping below — leaving it in
+  // that chain would build the whole list only to discard it.
+  if (zenMode) {
+    sessionsList.innerHTML = `${renderSessionCard(zenSession)}
+      <div class="zen-panel">
+        ${renderContextDetail(zenSession.contextStatus) || '<div class="zen-panel-empty">No context data for this session</div>'}
+        ${renderScratchpadRow(zenSession)}
+        ${renderLinkedDocsHtml(zenSession.id)}
+        ${renderArtifactsHtml(zenSession.id)}
+      </div>`;
+    bindLinkedDocsHandlers(sessionsList.querySelector('.linked-docs-section'), zenSession.id);
+    ensureSessionArtifacts(zenSession.id);
+    return;
+  }
+
   const groupPinned = store.getItem('groupPinnedSessions') !== 'false';
   const pinWeight = (s) => (isPlacedSticky(s.id) ? 2 : isPlacedPinned(s.id) && !isSessionActive(s) ? 1 : 0);
   const pinSort = (a, b) => pinWeight(b) - pinWeight(a);
@@ -3545,7 +3587,7 @@ function renderSession() {
   sessionTitle.textContent = displayName;
 
   // Build meta text with project path and description
-  const projectName = session.project ? session.project.split('/').pop() : null;
+  const projectName = session.project ? pathBasename(session.project) : null;
   const metaParts = [`${currentTasks.length} tasks`];
   if (projectName) {
     metaParts.push(projectName);
@@ -4649,16 +4691,18 @@ function expandActiveGroups({ onlyNew = false } = {}) {
 }
 
 // Drops every collapse key that could hide this session: its project, a named group wrapping
-// the project or the session itself, the pinned sub-sections of both, and — since which section
-// holds it depends on the view — every section header. Returns whether anything changed.
+// the project or the session itself, the pinned sub-section only when the card renders inside
+// it (pinned, not sticky, idle — see renderGroupSessions), and — since which section holds it
+// depends on the view — every section header. Returns whether anything changed.
 function uncollapseFor(session) {
   const project = session.project || '__ungrouped__';
   const group = sgGroupForSession(session);
+  const inPinned = isPlacedPinned(session.id) && !isPlacedSticky(session.id) && !isSessionActive(session);
   const keys = [
     project,
-    pinKey(project),
+    inPinned && pinKey(project),
     group && sgKey(group.id),
-    group && `__pinned_group_${group.id}__`,
+    group && inPinned && `__pinned_group_${group.id}__`,
     SECTION_GROUPS,
     SECTION_PROJECTS,
     SECTION_SESSIONS,
@@ -5194,6 +5238,7 @@ const SHORTCUT_PAIRS = [
         { keys: ['['], label: 'Toggle sidebar' },
         { keys: ['T'], label: 'Toggle theme' },
         { keys: ['Shift', 'S'], combo: true, label: 'Storage manager' },
+        { keys: ['Shift', 'Z'], combo: true, label: 'Zen mode (current session only)' },
         { keys: ['Ctrl', '+'], combo: true, label: 'Larger modal text' },
         { keys: ['Ctrl', '−'], combo: true, label: 'Smaller modal text' },
         { keys: ['Ctrl', '0'], combo: true, label: 'Reset modal text size' },
@@ -5407,7 +5452,7 @@ function _groupByProject(sessionIds) {
 
 function _projectLabel(project) {
   if (project === '(no project)') return '(no project)';
-  return project.split(/[/\\]/).pop() || project;
+  return pathBasename(project);
 }
 
 function _renderProjectGroup(label, meta, innerHtml) {
@@ -5844,7 +5889,7 @@ document.addEventListener('keydown', (e) => {
   }
 
   // Modal guard — only Escape, Shift+M, and msg-detail J/K navigation pass through
-  if (document.querySelector('.modal-overlay.visible')) {
+  if (isAnyModalOpen()) {
     if (e.key === 'Escape') {
       if (_scratchpadModal.classList.contains('visible')) {
         closeScratchpad();
@@ -5929,6 +5974,11 @@ document.addEventListener('keydown', (e) => {
     showStorageManager();
     return;
   }
+  if (e.code === 'KeyZ' && e.shiftKey && !e.ctrlKey && !e.altKey && !e.metaKey) {
+    e.preventDefault();
+    toggleZenMode();
+    return;
+  }
   // Ctrl+Shift+P is the browser's own; only the bare chord opens the picker.
   if (e.code === 'KeyP' && e.shiftKey && !e.ctrlKey && !e.altKey && !e.metaKey) {
     e.preventDefault();
@@ -6476,11 +6526,11 @@ function renderLinkedDocsHtml(sessionId) {
   const body = paths.length
     ? `<ul class="linked-doc-list">${items}</ul>`
     : '<div class="linked-docs-empty">No linked files yet</div>';
-  return `<div class="linked-docs-section" style="margin-bottom:16px;font-size:12px;">
-    <div style="font-size:11px;font-weight:500;color:var(--text-muted);text-transform:uppercase;letter-spacing:0.5px;margin-bottom:6px;display:flex;align-items:center;gap:6px;">
+  return `<div class="linked-docs-section panel-section">
+    <div class="panel-section-header">
       ${linkSvg(12)}
       <span>Linked documents</span>
-      <span style="background:var(--bg-elevated);border:1px solid var(--border);border-radius:10px;padding:0 6px;font-size:10px;color:var(--text-secondary);">${paths.length}</span>
+      <span class="panel-section-count">${paths.length}</span>
       <button type="button" class="linked-docs-add-btn" title="Link a file" aria-label="Link a file">+</button>
     </div>
     <div class="linked-doc-editor-slot"></div>
@@ -6488,6 +6538,63 @@ function renderLinkedDocsHtml(sessionId) {
   </div>`;
 }
 
+// Artifacts are read out of the transcript rather than stored with the session, so
+// the list arrives after the panel is already on screen and the slot — always
+// rendered, empty or not — is patched in place once it does.
+const artifactsBySession = new Map();
+const artifactsInFlight = new Set();
+
+function artifactLabel(a) {
+  if (a.title) return a.title;
+  return a.path ? pathBasename(a.path).replace(/\.html?$/i, '') : 'Artifact';
+}
+
+function artifactsInnerHtml(sessionId) {
+  const list = artifactsBySession.get(sessionId) || [];
+  if (!list.length) return '';
+  const items = list
+    .map(
+      (a) => `<li class="artifact-item">
+        <a class="artifact-link" href="${escapeHtml(a.url)}" target="_blank" rel="noopener" title="${escapeHtml(a.url)}">${escapeHtml(artifactLabel(a))}</a>
+        <span class="row-actions artifact-actions">
+          <button type="button" onclick="copyWithFeedback('${escAttrJs(a.url)}', this)" title="Copy link" aria-label="Copy artifact link">${ICON_COPY}</button>
+        </span>
+      </li>`,
+    )
+    .join('');
+  return `<div class="panel-section-header">
+      ${ICON_OPEN_EXTERNAL}
+      <span>Artifacts</span>
+      <span class="panel-section-count">${list.length}</span>
+    </div>
+    <ul class="artifact-list">${items}</ul>`;
+}
+
+function renderArtifactsHtml(sessionId) {
+  return `<div class="artifacts-section panel-section" data-artifacts-for="${escapeHtml(sessionId)}">${artifactsInnerHtml(sessionId)}</div>`;
+}
+
+// Always asks: the server holds the scan until the transcript grows, so a repeat
+// costs one stat, and an artifact published while the panel is open still appears.
+async function ensureSessionArtifacts(sessionId) {
+  if (!sessionId || artifactsInFlight.has(sessionId)) return;
+  artifactsInFlight.add(sessionId);
+  try {
+    const res = await fetch(`/api/sessions/${sessionId}/artifacts`);
+    if (!res.ok) return;
+    const data = await res.json();
+    artifactsBySession.set(sessionId, data.artifacts || []);
+  } catch (_) {
+    return;
+  } finally {
+    artifactsInFlight.delete(sessionId);
+  }
+  const html = artifactsInnerHtml(sessionId);
+  for (const slot of document.querySelectorAll(`[data-artifacts-for="${CSS.escape(sessionId)}"]`)) {
+    slot.innerHTML = html;
+  }
+}
+
 // One delegated listener per section: the list is re-rendered on every change, so
 // per-row handlers would only be rebound each time anyway.
 function bindLinkedDocsHandlers(container, sessionId) {
@@ -6561,6 +6668,9 @@ async function linkFileByPath(sessionId, raw, slot) {
       fail(data.error || 'File not found');
       return;
     }
+    // Close the editor before the refresh: a sidebar panel defers its re-render while an
+    // input is open, so leaving it up would hide the file that was just linked.
+    if (slot) slot.innerHTML = '';
     setSessionDocLink(sessionId, data.path, false);
     showToast('Linked to session', 'success');
   } catch {
@@ -6884,6 +6994,19 @@ function maybeFollowLatest() {
   }
 }
 
+// A new answerable ask opens its modal on its own, but only onto an empty
+// screen: an open modal means the user is reading something, so the ask stays
+// on the card and the badge until they get to it. Each ask id is offered once,
+// so closing the modal does not bring it back on the next poll.
+let lastAutoOpenedWaitingId = null;
+function maybeAutoOpenWaiting() {
+  if (!isWaitingAnswerable() || !isWaitingFresh()) return;
+  if (currentWaiting.id === lastAutoOpenedWaitingId || isAnyModalOpen()) return;
+  lastAutoOpenedWaitingId = currentWaiting.id;
+  msgDetailFollowLatest = true;
+  maybeFollowLatest();
+}
+
 function isWaitingFresh() {
   if (!currentWaiting?.timestamp) return false;
   return Date.now() - new Date(currentWaiting.timestamp).getTime() < WAITING_TTL_MS;
@@ -7087,6 +7210,24 @@ function sessionDisplayName(session) {
   return SESSION_UUID_RE.test(raw) ? raw.slice(0, 8) : raw;
 }
 
+// Project paths arrive in the OS spelling, so a Windows path is backslash-separated.
+function pathBasename(p) {
+  return p.split(/[/\\]/).filter(Boolean).pop() || p;
+}
+
+// `session.worktree` is resolved server-side from the `.git` pointer file, so it holds for a
+// worktree parked beside its repo as well as one under <repo>/.claude/worktrees/.
+function renderProjectIdentity(session) {
+  if (!session.project) return null;
+  const wt = session.worktree;
+  if (!wt) return escapeHtml(pathBasename(session.project));
+  const repo = pathBasename(wt.repo);
+  // Worktrees beside the repo are conventionally named `<repo>-<branch>`, and repeating the
+  // repo inside a chip that already sits next to it wastes the whole width of the card.
+  const name = wt.name.startsWith(repo) ? wt.name.slice(repo.length).replace(/^[-._]/, '') || wt.name : wt.name;
+  return `${escapeHtml(repo)}<span class="wt-chip" title="Worktree of ${escapeHtml(wt.repo)}">⑂ ${escapeHtml(name)}</span>`;
+}
+
 function formatDate(dateStr) {
   const date = new Date(dateStr);
   const now = new Date();
@@ -7524,6 +7665,24 @@ function renderFilterState() {
   document.getElementById('filter-menu-btn')?.classList.toggle('has-filters', short.length > 0);
 }
 
+function toggleZenMode() {
+  zenMode = !zenMode;
+  store.setItem(ZEN_KEY, String(zenMode));
+  renderZenState();
+  if (zenMode) closeFilterMenu();
+  renderSessions();
+  // The open session may be outside the current server page/filter; refetch pins it in.
+  if (zenMode) fetchSessions(false);
+}
+
+function renderZenState() {
+  const btn = document.getElementById('zen-mode-btn');
+  if (!btn) return;
+  btn.classList.toggle('active', zenMode);
+  btn.setAttribute('aria-pressed', String(zenMode));
+  btn.title = zenMode ? 'Zen mode on — show all sessions (Shift+Z)' : 'Zen mode: current session only (Shift+Z)';
+}
+
 // biome-ignore lint/correctness/noUnusedVariables: used in HTML
 function filterBySessions(value) {
   sessionFilter = value;
@@ -7965,6 +8124,7 @@ async function showSessionInfoModal(sessionId) {
   _planSessionId = sessionId;
   const cachedTasks = currentSessionId === sessionId ? currentTasks : [];
   showInfoModal(session, null, cachedTasks, null, null);
+  ensureSessionArtifacts(sessionId);
 
   const rerender = (teamConfig, tasks, planContent, parentInfo) => {
     if (_planSessionId !== sessionId) return; // user opened a different modal
@@ -8023,7 +8183,20 @@ function updateStickyBtnState() {
 // carry information. The full path stays in the tooltip and the copy button.
 function abbreviateScratchpadDir(dir) {
   const sep = dir.includes('\\') ? '\\' : '/';
-  return ['$tmp', '…', ...dir.split(/[/\\]/).slice(-2)].join(sep);
+  return dir.split(/[/\\]/).slice(-2).join(sep);
+}
+
+function renderScratchpadRow(session) {
+  const dir = session?.scratchpadDir;
+  if (!dir) return '';
+  return `<div class="zen-scratchpad">
+    <span class="zen-scratchpad-label">Scratchpad</span>
+    <span class="zen-scratchpad-path" title="${escapeHtml(dir)}">${escapeHtml(abbreviateScratchpadDir(dir))}</span>
+    <span class="row-actions">
+      <button onclick="copyWithFeedback('${escAttrJs(dir)}', this)" title="Copy">${ICON_COPY}</button>
+      <button data-folder="${escapeHtml(dir)}" onclick="openFolderInEditor(this.dataset.folder)" title="Open in editor">${ICON_OPEN_EXTERNAL}</button>
+    </span>
+  </div>`;
 }
 
 function showInfoModal(session, teamConfig, tasks, planContent, parentInfo) {
@@ -8138,6 +8311,7 @@ function showInfoModal(session, teamConfig, tasks, planContent, parentInfo) {
   }
 
   html += renderLinkedDocsHtml(session.id);
+  html += renderArtifactsHtml(session.id);
 
   // Team info section
   if (teamConfig) {
@@ -9207,6 +9381,7 @@ ownerFilter = urlState.owner || '';
 searchQuery = urlState.search || '';
 
 renderFilterState();
+renderZenState();
 pinnedSessionIds = loadPinnedSessions();
 stickySessionIds = loadStickySessions();
 setupEventSource();

package/public/index.html

@@ -60,6 +60,20 @@
           <span class="section-header-label">Sessions</span>
           <span id="filter-summary" class="filter-summary" title=""></span>
           <span class="section-header-actions">
+            <button
+              id="zen-mode-btn"
+              class="icon-btn section-btn"
+              onclick="event.stopPropagation(); toggleZenMode()"
+              title="Zen mode: current session only (Shift+Z)"
+              aria-label="Zen mode: current session only"
+              aria-pressed="false"
+            >
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+                <circle cx="12" cy="12" r="7"/>
+                <circle cx="12" cy="12" r="2"/>
+                <path d="M12 1v3M12 20v3M1 12h3M20 12h3"/>
+              </svg>
+            </button>
             <button
               id="filter-menu-btn"
               class="icon-btn section-btn"

package/public/style.css

@@ -9,6 +9,9 @@
   --bg-surface: #16181c;
   --bg-elevated: #1e2025;
   --bg-hover: #282a30;
+  /* Selection reads as a recess against the darker surface here, but light theme's deep tone
+     sits within a shade of the sidebar, so there it has to rise instead. */
+  --session-active-bg: var(--bg-deep);
   --border: #363840;
   --text-primary: #f0f1f3;
   --text-secondary: #c2c4c9;
@@ -440,7 +443,8 @@ body::before {
 }
 
 /* Ember only while something is actually filtered — at rest the funnel is just chrome. */
-.icon-btn.section-btn.has-filters {
+.icon-btn.section-btn.has-filters,
+.icon-btn.section-btn.active {
   color: var(--accent-text);
 }
 
@@ -575,17 +579,15 @@ body::before {
   transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1);
 }
 
-/* `.active` is the open session, `.kb-selected` the keyboard cursor. The cursor
-   must win when both land on one card, which is why it is ordered second. */
+/* `.active` is the open session, `.kb-selected` the keyboard cursor. They own different
+   properties — fill and border — so the cursor landing on the open session adds to it
+   instead of replacing how it looks. */
 .session-item.active {
-  background: var(--bg-deep);
-  border-color: var(--accent);
+  background: var(--session-active-bg);
 }
 
 .session-item.kb-selected {
-  background: var(--bg-elevated);
   border-color: var(--accent);
-  box-shadow: 0 0 0 1px var(--accent-dim);
 }
 
 .session-item.stale {
@@ -633,7 +635,8 @@ body::before {
 }
 
 .session-name {
-  font-size: 13px;
+  font-size: 14px;
+  font-weight: 500;
   color: var(--text-primary);
   white-space: nowrap;
   overflow: hidden;
@@ -671,6 +674,26 @@ body::before {
   overflow: hidden;
 }
 
+/* inline-block, not inline-flex: a flex box ignores text-overflow, so a long worktree name
+   ran past the card edge instead of truncating. */
+.wt-chip {
+  display: inline-block;
+  max-width: 60%;
+  margin-left: 5px;
+  padding: 0 5px;
+  border: 1px solid var(--accent-dim);
+  border-radius: 999px;
+  background: var(--accent-dim);
+  color: var(--accent-text);
+  font-family: var(--mono);
+  font-size: 9px;
+  line-height: 14px;
+  vertical-align: middle;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
 .session-branch {
   font-size: 10px;
   color: var(--text-secondary);
@@ -858,6 +881,68 @@ body::before {
   color: var(--text-secondary);
 }
 
+/* Zen view: the sidebar holds one card, so the usage detail that normally lives behind the
+   info modal gets rendered underneath it. */
+.zen-panel {
+  margin-top: 10px;
+  /* No bottom padding: the linked-docs section that always closes the panel carries its own. */
+  padding: 10px 10px 0;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+}
+
+.zen-panel .detail-context {
+  margin-bottom: 0;
+}
+
+.zen-panel .detail-context-stats {
+  gap: 3px 10px;
+}
+
+.zen-panel .linked-docs-section {
+  margin-top: 12px;
+  padding-top: 10px;
+  border-top: 1px solid var(--border);
+}
+
+.zen-panel .artifacts-section {
+  padding-top: 10px;
+  border-top: 1px solid var(--border);
+}
+
+.zen-scratchpad {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-top: 12px;
+  padding-top: 10px;
+  border-top: 1px solid var(--border);
+  font-size: 11px;
+}
+
+.zen-scratchpad-label {
+  font-weight: 500;
+  color: var(--text-muted);
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+  white-space: nowrap;
+}
+
+.zen-scratchpad-path {
+  flex: 1;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-family: var(--font-mono);
+  color: var(--text-secondary);
+}
+
+.zen-panel:hover .row-actions {
+  opacity: 1;
+}
+
 .session-time {
   font-size: 11px;
   font-weight: 450;
@@ -3818,7 +3903,8 @@ body::before {
   color: var(--text-primary);
 }
 
-.linked-doc-list {
+.linked-doc-list,
+.artifact-list {
   list-style: none;
   padding: 0;
   margin: 0;
@@ -3827,14 +3913,16 @@ body::before {
   gap: 4px;
 }
 
-.linked-doc-item {
+.linked-doc-item,
+.artifact-item {
   display: flex;
   align-items: baseline;
   gap: 8px;
   min-width: 0;
 }
 
-.linked-doc-link {
+.linked-doc-link,
+.artifact-link {
   color: var(--accent-text);
   text-decoration: underline;
   text-decoration-style: dotted;
@@ -3855,13 +3943,15 @@ body::before {
 /* Rides on the shared .row-actions group; only the reveal trigger differs — per row
    here, per grid in the session info. margin-left:auto pins the group to the same
    right edge however long the names in between are. */
-.linked-doc-actions {
+.linked-doc-actions,
+.artifact-actions {
   margin-left: auto;
   align-self: center;
   flex-shrink: 0;
 }
 
-.linked-doc-item:hover .linked-doc-actions {
+.linked-doc-item:hover .linked-doc-actions,
+.artifact-item:hover .artifact-actions {
   opacity: 1;
 }
 
@@ -3885,7 +3975,55 @@ body::before {
   text-decoration-style: dashed;
 }
 
-.linked-docs-empty {
+/* A section of the session panel: linked documents, artifacts. */
+.panel-section {
+  margin-bottom: 16px;
+  font-size: 12px;
+}
+
+/* Artifacts are read out of the transcript, so the section renders before the
+   list arrives and stays in the DOM as the patch target when there is none. */
+.artifacts-section:empty {
+  display: none;
+}
+
+.panel-section-header {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  margin-bottom: 6px;
+  font-size: 11px;
+  font-weight: 500;
+  color: var(--text-muted);
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+}
+
+.panel-section-header svg {
+  width: 12px;
+  height: 12px;
+}
+
+.panel-section-count {
+  background: var(--bg-elevated);
+  border: 1px solid var(--border);
+  border-radius: 10px;
+  padding: 0 6px;
+  font-size: 10px;
+  color: var(--text-secondary);
+}
+
+/* The artifact title is a URL away from the reader, so it truncates where a file
+   name, which the linked-doc row shows in full, does not. */
+.artifact-link {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  min-width: 0;
+}
+
+.linked-docs-empty,
+.zen-panel-empty {
   color: var(--text-muted);
   font-size: 11px;
   font-style: italic;
@@ -4122,6 +4260,7 @@ body.light {
   --bg-surface: #efede9;
   --bg-elevated: #fbfaf9;
   --bg-hover: #d2d0cc;
+  --session-active-bg: var(--bg-elevated);
   --border: #cfcbc4;
   --text-primary: #0a0a0a;
   --text-secondary: #444444;
@@ -5450,6 +5589,7 @@ select.form-input option:checked {
     --bg-surface: #efede9;
     --bg-elevated: #fbfaf9;
     --bg-hover: #d2d0cc;
+    --session-active-bg: var(--bg-elevated);
     --border: #cfcbc4;
     --text-primary: #0a0a0a;
     --text-secondary: #444444;

package/server.js

@@ -21,6 +21,7 @@ const {
   readSessionInfoFromJsonl,
   buildSessionDigest,
   readCompactSummaries,
+  readArtifactLinks,
   extractPromptFromTranscript,
   extractModelFromTranscript,
   extractStructuredResultFromTranscript,
@@ -33,7 +34,7 @@ const {
   buildLoopInfoFromState
 } = require('./lib/parsers');
 const { inlineHtmlAssets } = require('./lib/inline-assets');
-const { buildDecision, decisionFileName, isDecisionFile, waitSecondsFrom, isLapsed } = require('./lib/approvals');
+const { buildDecision, decisionFileName, isDecisionFile, approvalsFrom, boardRefusal } = require('./lib/approvals');
 const { getClaudeDir, getArgValue, storageNamespace } = require('./lib/claude-dir');
 
 if (process.argv.includes("--install") || process.argv.includes("--uninstall")) {
@@ -105,12 +106,33 @@ function writePins(pins) {
   writeJsonAtomic(PINS_FILE, pins);
 }
 
-// Port discovery for out-of-process helpers (the postman monitor). The pid rides along
-// so a reader can tell a live server from a file left behind by a crashed one.
+// Port discovery for out-of-process helpers (the postman monitor, approval-gate.sh).
+// The pid rides along so a reader can tell a live server from a file left behind by
+// a crashed one.
 function writeServerInfo(port) {
   writeJsonAtomic(SERVER_INFO_FILE, { port, pid: process.pid });
 }
 
+// A beacon that outlives its server disarms UI approvals silently: approval-gate.sh
+// probes the port, finds it closed and never waits. The hub spawns every sub-app on
+// an ephemeral port, so a stale beacon never comes back on its own — drop ours on
+// the way out. Only when the file is still ours: a newer server on the same config
+// dir has already claimed it.
+function removeServerInfo() {
+  try {
+    const info = JSON.parse(readFileSync(SERVER_INFO_FILE, 'utf8'));
+    if (info.pid === process.pid) unlinkSync(SERVER_INFO_FILE);
+  } catch (_) { /* gone, unreadable, or not ours */ }
+}
+
+process.on('exit', removeServerInfo);
+for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+  process.on(sig, () => {
+    removeServerInfo();
+    process.exit(0);
+  });
+}
+
 // #endregion
 
 // #region TIMINGS
@@ -155,23 +177,30 @@ function persistAgent(dir, agent) {
   fs.appendFile(file, `${JSON.stringify({ ...agent, event: 'server-update' })}\n`, 'utf8').catch(() => {});
 }
 
-// Lapse math lives in lib/approvals (kept in sync with the gate's own parse);
-// this only reads the config, cached so the polled session list doesn't re-read
-// it per hit (marker stays visible for the badge until TTL).
-const APPROVALS_CONFIG_FILE = path.join(CCK_DIR, 'approvals.json');
-let approvalsWaitCache = { ts: 0, ms: 30 * 1000 };
-function approvalsWaitMs() {
-  if (Date.now() - approvalsWaitCache.ts < 10 * 1000) return approvalsWaitCache.ms;
-  let cfg = null;
-  try {
-    cfg = JSON.parse(readFileSync(APPROVALS_CONFIG_FILE, 'utf8'));
-  } catch { /* missing config — gate default */ }
-  approvalsWaitCache = { ts: Date.now(), ms: waitSecondsFrom(cfg) * 1000 };
-  return approvalsWaitCache.ms;
+// <CCK_DIR>/config.json — cck's own settings, per Claude config dir.
+// Normalization lives in lib/approvals (kept in sync with the gate's own parse).
+const CCK_CONFIG_FILE = path.join(CCK_DIR, 'config.json');
+const LEGACY_APPROVALS_FILE = path.join(CCK_DIR, 'approvals.json');
+const cckConfigCache = new Map();
+function approvalsConfig() {
+  return cachedByMtime(cckConfigCache, 'approvals', CCK_CONFIG_FILE,
+    () => approvalsFrom(JSON.parse(readFileSync(CCK_CONFIG_FILE, 'utf8'))), approvalsFrom(null));
 }
 
-function isWaitingLapsed(data) {
-  return isLapsed(data.timestamp, approvalsWaitMs());
+// approvals.json predates config.json (and was opt-in). Fold it into
+// config.json once so an existing opt-in keeps its tuning, then drop it.
+function migrateLegacyApprovalsConfig() {
+  if (!existsSync(LEGACY_APPROVALS_FILE)) return;
+  try {
+    const legacy = JSON.parse(readFileSync(LEGACY_APPROVALS_FILE, 'utf8'));
+    let cfg = {};
+    try { cfg = JSON.parse(readFileSync(CCK_CONFIG_FILE, 'utf8')) || {}; } catch { /* absent */ }
+    if (!cfg.approvals) writeJsonAtomic(CCK_CONFIG_FILE, { ...cfg, approvals: legacy });
+    unlinkSync(LEGACY_APPROVALS_FILE);
+    cckConfigCache.clear();
+  } catch (e) {
+    console.error(`[cck] could not migrate ${LEGACY_APPROVALS_FILE}: ${e.message}`);
+  }
 }
 
 function checkWaitingForUser(agentDir, logMtime) {
@@ -183,7 +212,9 @@ function checkWaitingForUser(agentDir, logMtime) {
       if (age >= PERMISSION_TTL_MS) return null;
       // After grace period, check if session resumed activity (user already responded)
       if (logMtime && age >= WAITING_RESOLVE_GRACE_MS && logMtime > waitTime + WAITING_RESOLVE_GRACE_MS) return null;
-      if (isWaitingLapsed(data)) return { ...data, lapsed: true };
+      // Opted out reads the same as lapsed to the board: the ask is only
+      // answerable in the terminal, so no buttons.
+      if (boardRefusal(data, approvalsConfig())) return { ...data, lapsed: true };
       return data;
     }
   } catch { /* skip — missing or invalid */ }
@@ -246,6 +277,34 @@ function getGitBranch(cwd) {
   return branch;
 }
 
+// A linked worktree's `.git` is a file holding `gitdir: <main>/.git/worktrees/<name>`, so the
+// main checkout is readable without spawning git. Path shape alone would not do: only some
+// worktrees live under `<repo>/.claude/worktrees/`, the rest sit beside the repo.
+// Cached without a TTL, misses included: a directory cannot turn from an ordinary checkout into
+// a linked worktree without being recreated, and a recreated path is a new cache key.
+const worktreeCache = new Map();
+const WORKTREE_CACHE_MAX = 500;
+const GITDIR_WORKTREE_RE = /^gitdir:\s*(.*)[/\\]\.git[/\\]worktrees[/\\]([^/\\]+)[/\\]?$/;
+
+function resolveWorktree(dir) {
+  if (!dir) return null;
+  if (worktreeCache.has(dir)) return worktreeCache.get(dir);
+
+  let worktree = null;
+  try {
+    // An ordinary checkout's `.git` is a directory, so the read throws EISDIR — that is the
+    // answer, and it costs one syscall instead of a stat followed by a read.
+    const m = GITDIR_WORKTREE_RE.exec(readFileSync(path.join(dir, '.git'), 'utf8').trim());
+    if (m) worktree = { repo: m[1], name: m[2] };
+  } catch (_) {}
+
+  worktreeCache.set(dir, worktree);
+  if (worktreeCache.size > WORKTREE_CACHE_MAX) {
+    worktreeCache.delete(worktreeCache.keys().next().value);
+  }
+  return worktree;
+}
+
 // Only spawn git when cwd has diverged from the launch project — that's the
 // only case the JSONL value is wrong. Saves N spawns on a typical list build.
 function resolveSessionGitBranch(meta) {
@@ -1015,12 +1074,30 @@ function getSessionDisplayName(_sessionId, meta) {
   return null;
 }
 
+// The harness spells a project path into a temp/log dir name by replacing every
+// non-alphanumeric character with a dash, drive colon and separators included.
+function encodeProjectDirName(p) {
+  return p.replace(/[^a-zA-Z0-9]/g, '-');
+}
+
 // Derived by convention, not looked up: the harness creates the dir lazily, so a
 // stat here would report "missing" for every session that has not written a temp
 // file yet — and it would put IO on the session-list hot path. Pure string join.
 function getScratchpadDir(id, meta) {
   if (!meta.jsonlPath) return null;
-  return path.join(SCRATCHPAD_ROOT, path.basename(path.dirname(meta.jsonlPath)), id, 'scratchpad');
+  const byProject = path.join(SCRATCHPAD_ROOT, path.basename(path.dirname(meta.jsonlPath)), id, 'scratchpad');
+
+  // A session launched with `claude -w` starts in the main checkout and enters the
+  // worktree afterwards, so the harness keys its scratchpad on the repo while the
+  // transcript ends up filed under the worktree. Neither the project nor any `cwd`
+  // in the log records that, so the two candidates are told apart by which one the
+  // harness actually created. Probed only for worktree sessions, and only until one
+  // of them exists — before that there is nothing to disambiguate and `byProject`,
+  // right for a session started inside the worktree, stands.
+  const wt = resolveWorktree(meta.project);
+  if (!wt || existsSync(byProject)) return byProject;
+  const byRepo = path.join(SCRATCHPAD_ROOT, encodeProjectDirName(wt.repo), id, 'scratchpad');
+  return existsSync(byRepo) ? byRepo : byProject;
 }
 
 function buildSessionObject(id, meta, overrides = {}) {
@@ -1035,6 +1112,7 @@ function buildSessionObject(id, meta, overrides = {}) {
     cwd: meta.cwd || null,
     description: meta.description || null,
     gitBranch: resolveSessionGitBranch(meta),
+    worktree: resolveWorktree(meta.project),
     customTitle: meta.customTitle || null,
     goal: meta.goal || null,
     taskCount: 0,
@@ -1574,6 +1652,32 @@ app.get('/api/sessions/:sessionId/loop', (req, res) => {
   }
 });
 
+// Cold path — a full transcript scan, so the result is held until the file grows.
+// The zen panel asks again on every re-render, which then costs one stat.
+const artifactsByPath = new Map();
+
+function getArtifactLinks(jsonlPath) {
+  let stat;
+  try { stat = statSync(jsonlPath); } catch (_) { return []; }
+  const hit = artifactsByPath.get(jsonlPath);
+  if (hit && hit.mtimeMs === stat.mtimeMs && hit.size === stat.size) return hit.artifacts;
+  const artifacts = readArtifactLinks(jsonlPath);
+  artifactsByPath.set(jsonlPath, { mtimeMs: stat.mtimeMs, size: stat.size, artifacts });
+  return artifacts;
+}
+
+app.get('/api/sessions/:sessionId/artifacts', (req, res) => {
+  try {
+    const metadata = loadSessionMetadata();
+    const meta = metadata[req.params.sessionId] || metadata[resolveSessionId(req.params.sessionId)];
+    if (!meta?.jsonlPath) return res.json({ artifacts: [] });
+    res.json({ artifacts: getArtifactLinks(meta.jsonlPath) });
+  } catch (error) {
+    console.error('Error reading artifacts:', error);
+    res.status(500).json({ error: 'Failed to read artifacts' });
+  }
+});
+
 // API: List workflow scripts for a session. Parses each script's meta for the
 // canonical name + description (cold path — only when the workflow modal opens).
 app.get('/api/sessions/:sessionId/workflows', async (req, res) => {
@@ -2161,9 +2265,8 @@ app.post('/api/sessions/:sessionId/waiting/respond', (req, res) => {
   catch { /* missing or invalid → buildDecision reports 410 */ }
   // The gate stopped polling after waitSeconds — an orphaned decision file would
   // sit unconsumed while the card pretends the click worked.
-  if (marker && isWaitingLapsed(marker)) {
-    return res.status(410).json({ error: 'Ask lapsed — answer it in the terminal' });
-  }
+  const refusal = marker && boardRefusal(marker, approvalsConfig());
+  if (refusal) return res.status(refusal.status).json({ error: refusal.error });
   const result = buildDecision(marker, req.body || {});
   if (result.error) return res.status(result.status).json({ error: result.error });
   try {
@@ -3454,6 +3557,7 @@ async function prewarmCaches() {
     // The port is configurable and falls back to a random one when taken, so the postman
     // monitor cannot assume it -- publish the live one where it can read it.
     writeServerInfo(actualPort);
+    migrateLegacyApprovalsConfig();
     const warning = net.exposureWarning();
     if (warning) console.log(warning);