claude-code-kanban 4.25.0 → 4.27.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/inline-assets.js

@@ -235,4 +235,4 @@ async function inlineHtmlAssets(html, absHtmlPath) {
   return { html: out, bytes: ctx.spent, skipped: ctx.skipped };
 }
 
-module.exports = { inlineHtmlAssets, MAX_ASSET_BYTES };
+module.exports = { inlineHtmlAssets, MIME_BY_EXT, MAX_ASSET_BYTES };

package/lib/parsers.js

@@ -185,6 +185,14 @@ function pushUserMessage(messages, text, timestamp, sysLabel, extras) {
     label = base + formatTaskUsage(notif.usage);
     safeText = notif.result || base;
   }
+  // A subagent, teammate or peer session handing work back through SendMessage is
+  // also model output, not user input. Callers on the `origin` path pass the parts
+  // ready-made; the text paths (type:'user', queued enqueue) parse the envelope.
+  const agentMsg = extras?.agent || (notif ? null : parseAgentMessage(safeText));
+  if (agentMsg) {
+    label = agentMsg.label;
+    safeText = agentMsg.body;
+  }
   const truncated = safeText.length > USER_TEXT_MAX;
   const msg = {
     type: 'user',
@@ -200,12 +208,26 @@ function pushUserMessage(messages, text, timestamp, sysLabel, extras) {
     if (notif.taskId) msg.taskId = notif.taskId;
     if (notif.status) msg.taskStatus = notif.status;
   }
+  if (agentMsg) {
+    msg.agentMessage = true;
+    if (agentMsg.from) msg.agentFrom = agentMsg.from;
+  }
   if (extras) {
     if (extras.uuid) msg.uuid = extras.uuid;
     if (extras.images && extras.images.length) msg.images = extras.images;
     if (extras.toolResultRefs && extras.toolResultRefs.length) msg.toolResultRefs = extras.toolResultRefs;
     if (extras.queued) msg.queued = true;
   }
+  // One agent message reaches the log twice: the queued enqueue record and the
+  // delivered one right after it. Keep the first and drop the twin here, so no
+  // renderer has to know about the double write.
+  if (agentMsg) {
+    const prev = messages[messages.length - 1];
+    if (prev?.agentMessage && (prev.agentFrom || null) === (msg.agentFrom || null) && prev.text === msg.text) {
+      if (!msg.queued) delete prev.queued;
+      return;
+    }
+  }
   messages.push(msg);
 }
 
@@ -587,6 +609,43 @@ function parseTaskNotification(text) {
   };
 }
 
+// A message another agent sent into this session (a subagent hand-back, a teammate
+// or a peer session using SendMessage) is model output, not user input. Turn the
+// sender and the raw body into the chip label plus the body alone, so it never
+// renders under a person icon.
+function agentMessageParts(from, rawBody, handback) {
+  let body = (rawBody || '').trimEnd();
+  // A hand-back frames the report with the harness note that it carries no user
+  // authority, and indents every line of the report by two spaces so a forged
+  // frame at column zero is impossible. Strip the frame and that indent.
+  const framed = body.match(/^\[Subagent hand-back\][\s\S]*?report follows:\n([\s\S]*)$/);
+  if (framed) body = framed[1].replace(/^ {2}/gm, '').trim();
+  const handBack = !!framed || !!handback;
+  const kind = handBack ? 'Subagent hand-back' : 'Agent message';
+  // Harness agent ids are long hex; a named sender ("code-review") is shown whole.
+  const short = from && /^[0-9a-f]{12,}$/i.test(from) ? from.slice(0, 8) : from;
+  return { from: from || null, handBack, label: short ? `${kind} · ${short}` : kind, body };
+}
+
+// The text delivery paths carry the body inside an <agent-message from="..."> envelope,
+// with the harness notes outside it. The envelope must open the message (after the
+// harness preamble, if any): prose that merely quotes the tag is a user message.
+// The body is unescaped agent text that can quote the envelope it describes, so the
+// real closing tag is the last one.
+function parseAgentMessage(text) {
+  if (typeof text !== 'string' || !text.includes('<agent-message')) return null;
+  const start = text.indexOf('<agent-message');
+  const preamble = text.slice(0, start).trim();
+  if (preamble && !/^Another Claude session sent a message[^\n]*:$/.test(preamble)) return null;
+  const gt = text.indexOf('>', start);
+  const end = text.lastIndexOf('</agent-message>');
+  if (gt === -1 || end < gt) return null;
+  const from = (text.slice(start, gt).match(/from="([^"]*)"/) || [])[1] || null;
+  let bodyStart = gt + 1;
+  while (text[bodyStart] === '\n') bodyStart++;
+  return agentMessageParts(from, text.slice(bodyStart, end));
+}
+
 function getSystemMessageLabel(text) {
   const taskMatch = text.match(/<summary>([^<]+)<\/summary>/);
   if (taskMatch) return taskMatch[1].trim();
@@ -801,6 +860,15 @@ function readRecentMessages(jsonlPath, limit = 10) {
                 messages.push(msg);
               }
             }
+          } else if (obj.type === 'user' && obj.origin?.kind === 'peer') {
+            // Claude Code >= 2.1 files the delivered copy as isMeta (dropped by the
+            // branch below) and repeats the envelope's fields on `origin`. That
+            // record is always written; the queued enqueue is not, so read it from
+            // here and let pushUserMessage drop whichever twin arrives second.
+            pushUserMessage(messages, '', obj.timestamp, null, {
+              uuid: obj.uuid,
+              agent: agentMessageParts(obj.origin.from, obj.origin.body, obj.origin.handback)
+            });
           } else if (obj.type === 'user' && obj.message?.role === 'user' && !obj.isMeta) {
             if (obj.isCompactSummary) {
               // Surface the compaction summary as a single expandable "Compacted"
@@ -1296,6 +1364,112 @@ 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));
+}
+
+const SCRATCH_NEW_RE = /\bscratch new\b/;
+// `scratch new` reports where it put the pad; the two spaces are the CLI's own column
+// padding, which is what makes the prefilter below narrow enough to be worth having.
+const SCRATCH_MANIFEST_RE = /^\s*manifest\s*:\s*(.+?)\s*$/m;
+// The name must sit immediately after `new`, and the bare-word branch must refuse a
+// leading `-`, so that a flag or a flag's value cannot be read as the name.
+const SCRATCH_NAME_RE = /\bscratch\s+new\s+(?:"([^"]+)"|'([^']+)'|(?!-)(\S+))/;
+
+// The `scratch new` calls in a transcript, `{ ts, path, name }` per call. `path` is null
+// whenever the command piped the CLI's output away — the common case, not an edge one:
+// the manifest is the 4th of ~13 printed lines, so any `| tail -N` cuts it off. `name`
+// stands in because it is what the manifest stores as its own `name`; the path is not
+// recovered from the command, which would mean tracking the `cd` and a relative `--dir`.
+function readScratchpadCreations(jsonlPath) {
+  const calls = new Map();
+  try {
+    const content = readFileSync(jsonlPath, 'utf8');
+    for (const line of content.split('\n')) {
+      // Substring reject before JSON.parse: transcripts reach tens of megabytes and
+      // only a handful of lines can ever match.
+      const isCall = line.includes('scratch new');
+      if (!isCall && !line.includes('manifest  :')) continue;
+      let obj;
+      try { obj = JSON.parse(line); } catch (_) { continue; }
+      const blocks = obj?.message?.content;
+      if (!Array.isArray(blocks)) continue;
+      const ts = Date.parse(obj.timestamp);
+      for (const b of blocks) {
+        if (b?.type === 'tool_use' && b.name === 'Bash' && SCRATCH_NEW_RE.test(b.input?.command || '')) {
+          if (b.id && Number.isFinite(ts)) {
+            const named = SCRATCH_NAME_RE.exec(b.input.command);
+            calls.set(b.id, { ts, path: null, name: named?.slice(1).find(Boolean) ?? null });
+          }
+        } else if (b?.type === 'tool_result' && calls.has(b.tool_use_id)) {
+          const m = SCRATCH_MANIFEST_RE.exec(toolResultText(b.content));
+          if (m) calls.get(b.tool_use_id).path = m[1];
+        }
+      }
+    }
+  } catch (_) {}
+  return [...calls.values()];
+}
+
 function readCompactSummaries(jsonlPath) {
   const results = [];
   // Inline format: newer Claude Code stores the summary directly in the parent
@@ -1621,6 +1795,7 @@ module.exports = {
   parseSessionsIndex,
   parseJsonlLine,
   parseTaskNotification,
+  parseAgentMessage,
   getSystemMessageLabel,
   readSessionInfoFromJsonl,
   readRecentMessages,
@@ -1634,6 +1809,8 @@ module.exports = {
   buildAgentProgressMap,
   buildSessionDigest,
   readCompactSummaries,
+  readArtifactLinks,
+  readScratchpadCreations,
   findTerminatedTeammates,
   extractPromptFromTranscript,
   extractModelFromTranscript,

package/lib/scratch-files.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const fs = require('node:fs').promises;
+const path = require('node:path');
+const { isContained } = require('./contain');
+
+// Resolves a folder inside a session's scratchpad dir from the path the client sends
+// back — the absolute path a listing handed out, or one relative to the root. Returns
+// null when it escapes the root (`..`, another dir, a symlink out), so the endpoint
+// never lists anything the root did not hand out.
+function resolveScratchSubdir(root, sub) {
+  if (!sub) return root;
+  if (typeof sub !== 'string') return null;
+  const full = path.resolve(root, sub);
+  return isContained(full, root) ? full : null;
+}
+
+// One level of a scratchpad dir, newest first whatever the kind. Not recursive on
+// purpose: sessions drop clones and build output in here, and the client asks for a
+// folder's children only when the user opens it.
+async function listScratchDir(dir) {
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch (_) {
+    return [];
+  }
+  const rows = await Promise.all(
+    entries
+      .filter((entry) => entry.isFile() || entry.isDirectory())
+      .map(async (entry) => {
+        const full = path.join(dir, entry.name);
+        try {
+          const { mtimeMs } = await fs.stat(full);
+          return { name: entry.name, path: full, kind: entry.isDirectory() ? 'dir' : 'file', mtimeMs };
+        } catch (_) {
+          return null;
+        }
+      }),
+  );
+  return rows
+    .filter(Boolean)
+    .sort((a, b) => b.mtimeMs - a.mtimeMs)
+    .map(({ mtimeMs, ...row }) => ({ ...row, modifiedAt: new Date(mtimeMs).toISOString() }));
+}
+
+module.exports = { resolveScratchSubdir, listScratchDir };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-kanban",
-  "version": "4.25.0",
+  "version": "4.27.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