@yugabytedb/meko-mcp 2.2.0 → 2.5.0

package/assets/hooks-handlers/lib/opencode-normalizer.js

@@ -0,0 +1,145 @@
+/**
+ * CJS mirror of installer/lib/migrate/opencode-normalizer.mjs for capture handler.
+ * Keep logic in sync — golden tests assert byte-equivalent exchanges.
+ */
+
+"use strict";
+
+const SYNTHETIC_PART_TYPES = new Set(["compaction", "subtask", "continuation"]);
+const EXCLUDED_PART_TYPES = new Set([
+  "tool", "tool-invocation", "tool-result", "tool_result", "reasoning",
+  "file", "attachment", "step", "snapshot", "patch",
+]);
+const INTERRUPTED_MARKER =
+  "[Meko capture: assistant response was interrupted before completion.]";
+function normalizeOpenCodeSession(exportShape, opts = {}) {
+  const root = exportShape && typeof exportShape === "object" ? exportShape : {};
+  const info = root.info && typeof root.info === "object" ? root.info : {};
+  const rawMessages = Array.isArray(root.messages) ? root.messages : [];
+  const sessionId = firstString(info.id, info.sessionID, info.sessionId, root.sessionId) || "unknown";
+  const cwd = firstString(info.cwd, info.directory, info.projectPath, root.cwd) || "";
+  const parentSessionId = firstString(info.parentID, info.parentId, info.parentSessionId) || null;
+  const title = firstString(info.title, info.name) || sessionId;
+  const startedAt = firstTimestamp(info.time?.created, info.created, info.startedAt, info.time);
+  const visibleMessages = rawMessages.map(normalizeMessage).filter(Boolean).sort(compareMessageOrder);
+  const exchanges = [];
+  let pendingUser = null;
+  let firstUserText = "";
+  for (const msg of visibleMessages) {
+    if (msg.role === "user") {
+      if (pendingUser) exchanges.push(makeExchange(pendingUser, null, { forceInterrupted: true }));
+      pendingUser = msg;
+      if (!firstUserText && msg.text) firstUserText = msg.text.slice(0, 240);
+    } else if (msg.role === "assistant" && pendingUser) {
+      exchanges.push(makeExchange(pendingUser, msg, {}));
+      pendingUser = null;
+    }
+  }
+  let partial = Boolean(pendingUser);
+  if (pendingUser && opts.emitPendingAsExchange) {
+    // Live-capture mode. Emit the trailing pending user with no assistant
+    // output; the reconciler holds it until a later snapshot completes it,
+    // a later user interrupts it, or MEKO_OPENCODE_SETTLE_MS expires.
+    exchanges.push(makeExchange(pendingUser, null, {}));
+    pendingUser = null;
+    partial = false;
+  } else if (pendingUser && (opts.terminalError || opts.interrupted)) {
+    exchanges.push(makeExchange(pendingUser, null, { ...opts, interrupted: true }));
+    pendingUser = null;
+    partial = false;
+  } else if (!pendingUser && (opts.terminalError || opts.interrupted) && exchanges.length) {
+    markInterrupted(exchanges[exchanges.length - 1]);
+  }
+  return {
+    sessionId, cwd, parentSessionId, title,
+    startedAt: startedAt || visibleMessages[0]?.timestamp || null,
+    firstUserText,
+    exchanges: exchanges.filter((ex) => ex.input || ex.output),
+    partial,
+  };
+}
+function normalizeMessage(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const info = raw.info && typeof raw.info === "object" ? raw.info : raw;
+  const role = firstString(info.role, raw.role)?.toLowerCase();
+  if (role !== "user" && role !== "assistant") return null;
+  const synthetic = Boolean(
+    info.synthetic || info.compaction || info.subtask || info.continuation ||
+    SYNTHETIC_PART_TYPES.has(String(info.type || "").toLowerCase()),
+  );
+  if (synthetic) return null;
+  const parts = Array.isArray(raw.parts) ? raw.parts : [];
+  const text = joinVisibleText(parts);
+  if (!text && role === "assistant") return null;
+  return {
+    role,
+    id: firstString(info.id, raw.id, raw.uuid) || "",
+    timestamp: firstTimestamp(info.time?.created, info.createdAt, info.timestamp, raw.timestamp) || "",
+    text,
+    order: Number.isFinite(Number(info.order)) ? Number(info.order) : null,
+  };
+}
+function joinVisibleText(parts) {
+  const chunks = [];
+  for (const part of parts) {
+    if (!part || typeof part !== "object") continue;
+    if (part.synthetic || part.ignored) continue;
+    const type = String(part.type || "text").toLowerCase();
+    if (EXCLUDED_PART_TYPES.has(type) || SYNTHETIC_PART_TYPES.has(type)) continue;
+    if (type !== "text") continue;
+    const text = typeof part.text === "string" ? part.text : "";
+    if (!text.trim()) continue;
+    chunks.push(text);
+  }
+  return chunks.join("\n");
+}
+function compareMessageOrder(a, b) {
+  const ao = a.order; const bo = b.order;
+  if (ao != null && bo != null && ao !== bo) return ao - bo;
+  if (a.timestamp && b.timestamp && a.timestamp !== b.timestamp) {
+    return a.timestamp < b.timestamp ? -1 : 1;
+  }
+  return String(a.id).localeCompare(String(b.id));
+}
+function makeExchange(userMsg, assistantMsg, opts) {
+  const interrupted = Boolean(opts.interrupted || (!assistantMsg && opts.forceInterrupted));
+  return {
+    userId: userMsg.id || `opencode-user-${hashish(userMsg.text)}`,
+    assistantId: assistantMsg?.id || null,
+    input: userMsg.text,
+    output: interrupted ? INTERRUPTED_MARKER : (assistantMsg?.text || ""),
+    timestamp: assistantMsg?.timestamp || userMsg.timestamp || "",
+    interrupted,
+  };
+}
+function markInterrupted(exchange) {
+  exchange.interrupted = true;
+  exchange.output = exchange.output
+    ? `${exchange.output}\n\n${INTERRUPTED_MARKER}`
+    : INTERRUPTED_MARKER;
+}
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return "";
+}
+function firstTimestamp(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+    if (typeof value === "number" && Number.isFinite(value)) {
+      const date = new Date(value);
+      if (!Number.isNaN(date.getTime())) return date.toISOString();
+    }
+    if (value instanceof Date && !Number.isNaN(value.getTime())) return value.toISOString();
+  }
+  return "";
+}
+function hashish(text) {
+  let h = 0;
+  const s = String(text || "");
+  for (let i = 0; i < s.length; i++) h = ((h << 5) - h + s.charCodeAt(i)) | 0;
+  return Math.abs(h).toString(36);
+}
+
+module.exports = { normalizeOpenCodeSession, INTERRUPTED_MARKER };

package/assets/hooks-handlers/lib/terminal-handoff.js

@@ -359,7 +359,16 @@ async function runWorker(jobFile) {
         ? Math.max(0, dueMs - Date.now())
         : delayMs;
       const remaining = Math.max(0, WORKER_MAX_AGE_MS - (Date.now() - started));
-      await sleep(Math.min(untilDue, remaining));
+      if (untilDue >= remaining) {
+        // The retry falls after this worker's age ceiling (for example a
+        // session parked by --capture-cleanup). Sleeping would only hold a
+        // process for the rest of the day; timer recovery owns the retry.
+        process.stderr.write(
+          `[meko-capture] SessionEnd worker: next retry ${result.next_retry_at} is past the worker ceiling; leaving outbox pending.\n`,
+        );
+        break;
+      }
+      await sleep(untilDue);
       delayMs = Math.min(delayMs * 2, 60_000);
       continue;
     }

package/assets/opencode-plugin/meko.js

@@ -0,0 +1,213 @@
+// Managed by meko installer; reinstall rather than editing.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { randomBytes } from "node:crypto";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+const PLUGIN_DIR = path.dirname(fileURLToPath(import.meta.url));
+const MEKO_ROOT = path.join(PLUGIN_DIR, "..", "meko");
+const ENV_PATH = path.join(MEKO_ROOT, "opencode-hook-env.json");
+const HANDLER_PATH = path.join(MEKO_ROOT, "hooks-handlers", "lib", "opencode-handler.js");
+const MANAGED_MARKER = "Managed by meko installer";
+function readEnv() {
+  try {
+    return JSON.parse(fs.readFileSync(ENV_PATH, "utf8"));
+  } catch {
+    return {};
+  }
+}
+// MEKO-635: staged snapshots live under the durable Capture v2 watermark root
+// (matches skills/hooks-handlers/lib/capture-state.js). This keeps them
+// outside installer-owned runtime and lets uninstall preserve them.
+function resolveStagingDir(env) {
+  const watermarkDir =
+    (typeof env.MEKO_WATERMARK_DIR === "string" && env.MEKO_WATERMARK_DIR) ||
+    path.join(os.homedir(), ".claude", "meko-capture");
+  return path.join(watermarkDir, "opencode-snapshots");
+}
+function safeSegment(value) {
+  return String(value || "unknown").replace(/[^A-Za-z0-9_.-]+/g, "_").slice(0, 120);
+}
+function sanitizeSnapshot(session, messages) {
+  return {
+    info: {
+      id: session?.id,
+      title: session?.title,
+      directory: session?.directory,
+      parentID: session?.parentID,
+      time: session?.time,
+    },
+    messages: (Array.isArray(messages) ? messages : []).map((message) => ({
+      info: {
+        id: message?.info?.id,
+        role: message?.info?.role,
+        type: message?.info?.type,
+        order: message?.info?.order,
+        synthetic: message?.info?.synthetic,
+        compaction: message?.info?.compaction,
+        subtask: message?.info?.subtask,
+        continuation: message?.info?.continuation,
+        time: message?.info?.time,
+        createdAt: message?.info?.createdAt,
+        timestamp: message?.info?.timestamp,
+      },
+      parts: (Array.isArray(message?.parts) ? message.parts : [])
+        .filter((part) => part?.type === "text" && typeof part.text === "string")
+        .map((part) => ({
+          type: "text",
+          text: part.text,
+          synthetic: Boolean(part.synthetic),
+          ignored: Boolean(part.ignored),
+        })),
+    })),
+  };
+}
+function stageSnapshot(sessionId, snapshot, terminalError, stagingDir) {
+  fs.mkdirSync(stagingDir, { recursive: true, mode: 0o700 });
+  // MEKO-635: two events in the same PID and millisecond can race. The 8-byte
+  // random suffix makes both the target and the temp path collision-proof so a
+  // session.error and a session.idle firing back-to-back cannot overwrite each
+  // other (nor let a late pending snapshot clobber one the reconciler is
+  // about to read).
+  const unique = randomBytes(8).toString("hex");
+  const target = path.join(
+    stagingDir,
+    `${safeSegment(sessionId)}.${process.pid}.${Date.now()}.${unique}.json`,
+  );
+  const tmp = `${target}.tmp`;
+  fs.writeFileSync(
+    tmp,
+    JSON.stringify({
+      schema_version: 1,
+      terminalError: Boolean(terminalError),
+      export: snapshot,
+    }),
+    { encoding: "utf8", mode: 0o600 },
+  );
+  fs.renameSync(tmp, target);
+  try { fs.chmodSync(target, 0o600); } catch { /* best effort */ }
+  return target;
+}
+function launchHandler(stagedPath, nodeExecutable, spawnProcess) {
+  if (!nodeExecutable) {
+    throw new Error("MEKO_NODE_EXECUTABLE is missing; reinstall Meko for OpenCode");
+  }
+  const child = spawnProcess(nodeExecutable, [HANDLER_PATH], {
+    detached: false,
+    stdio: ["pipe", "ignore", "ignore"],
+    env: {
+      ...process.env,
+      MEKO_OPENCODE_ENV_FILE: ENV_PATH,
+      MEKO_HOOK_CLIENT: "opencode",
+    },
+  });
+  child.once?.("error", (err) => {
+    console.error(`[meko-opencode] handler launch failed: ${err.message}`);
+  });
+  child.stdin?.on?.("error", () => {});
+  child.stdin?.end?.(JSON.stringify({ snapshotPath: stagedPath }));
+  return new Promise((resolve) => {
+    if (!child || typeof child.once !== "function") {
+      resolve();
+      return;
+    }
+    const done = () => resolve();
+    child.once("exit", done);
+    child.once("close", done);
+  });
+}
+async function captureSession(
+  client,
+  sessionID,
+  terminalError,
+  nodeExecutable,
+  spawnProcess,
+  stagingDir,
+) {
+  if (!sessionID) return;
+  let staged = "";
+  try {
+    const [sessionResponse, messagesResponse] = await Promise.all([
+      client.session.get({ path: { id: sessionID } }),
+      client.session.messages({ path: { id: sessionID } }),
+    ]);
+    const session = sessionResponse?.data;
+    const messages = messagesResponse?.data;
+    if (!session || !Array.isArray(messages)) {
+      throw new Error("OpenCode SDK returned an incomplete session snapshot");
+    }
+    staged = stageSnapshot(
+      session.id || sessionID,
+      sanitizeSnapshot(session, messages),
+      terminalError,
+      stagingDir,
+    );
+    await launchHandler(staged, nodeExecutable, spawnProcess);
+  } catch (err) {
+    console.error(`[meko-opencode] capture failed: ${err.message}`);
+  }
+}
+export default async function MekoPlugin({ client }, options = {}) {
+  const runtimeEnv = readEnv();
+  const nodeExecutable = runtimeEnv.MEKO_NODE_EXECUTABLE;
+  const stagingDir = resolveStagingDir(runtimeEnv);
+  const spawnProcess =
+    typeof options.__mekoSpawn === "function" ? options.__mekoSpawn : spawn;
+  const sessionTails = new Map();
+  function enqueue(sessionID, task) {
+    const key = sessionID || "_";
+    const next = (sessionTails.get(key) || Promise.resolve()).then(task, task);
+    sessionTails.set(key, next);
+    return next;
+  }
+  if (process.env.MEKO_OPENCODE_DISABLE_RECOVERY !== "1") {
+    try {
+      if (!nodeExecutable) {
+        throw new Error("MEKO_NODE_EXECUTABLE is missing; reinstall Meko for OpenCode");
+      }
+      spawnProcess(nodeExecutable, [HANDLER_PATH, "--recovery-scan"], {
+        detached: true,
+        windowsHide: true,
+        stdio: "ignore",
+        env: {
+          ...process.env,
+          MEKO_OPENCODE_ENV_FILE: ENV_PATH,
+          MEKO_HOOK_CLIENT: "opencode",
+        },
+      }).unref();
+    } catch (err) {
+      console.error(`[meko-opencode] recovery scan failed: ${err.message}`);
+    }
+  }
+
+  return {
+    async config(config) {
+      const env = readEnv();
+      const serverName = env.MEKO_MCP_SERVER_NAME || "meko";
+      if (!env.MEKO_MCP_URL) return;
+      const headers = {
+        "User-Agent": env.MEKO_MCP_USER_AGENT || "meko-mcp-installer/1.0",
+      };
+      if (env.MEKO_API_KEY) headers.Authorization = `Bearer ${env.MEKO_API_KEY}`;
+      config.mcp ??= {};
+      config.mcp[serverName] = {
+        type: "remote",
+        url: env.MEKO_MCP_URL,
+        enabled: true,
+        oauth: false,
+        headers,
+      };
+    },
+    async event({ event }) {
+      const sessionID = event.properties?.sessionID;
+      if (event?.type === "session.idle") {
+        await enqueue(sessionID, () =>
+          captureSession(client, sessionID, false, nodeExecutable, spawnProcess, stagingDir));
+      } else if (event?.type === "session.error") {
+        await enqueue(sessionID, () =>
+          captureSession(client, sessionID, true, nodeExecutable, spawnProcess, stagingDir));
+      }
+    },
+  };
+}

package/assets/scripts/meko-statusline.sh

@@ -46,12 +46,18 @@ fi
 
 # --- Derive agent_id from cwd ---
 #
-# Mirrors deriveAgentId() in skills/hooks-handlers/lib/capture.js:51-65:
-#   - basename of cwd, lowercased
+# Mirrors deriveAgentId() + resolveRepoRoot() in
+# skills/hooks-handlers/lib/capture.js:
+#   - walk parents of cwd for a '.git' entry (dir OR file, for worktrees and
+#     submodules); the walk stops at $HOME from below, so a git-tracked home
+#     does not claim every directory beneath it
+#   - basename of that repo root, lowercased
 #   - non-[a-z0-9-]+ → '-'
 #   - trim leading/trailing '-'
 #   - max 64 chars
 #   - prefix with 'claude_code:'
+#   - no repo root found → bare 'claude_code' (NOT 'claude_code:<leaf>'), so
+#     this segment reads the same pin file the hook writes
 #
 # Then mirrors datapackPinSlug() in capture.js:341-348:
 #   - non-[A-Za-z0-9._-]+ → '_'
@@ -74,19 +80,72 @@ if [[ -n "$STDIN_PAYLOAD" ]]; then
   fi
 fi
 
+if [[ -n "${HOME:-}" ]]; then
+  USER_HOME="$(cd -L -- "$HOME" 2>/dev/null && pwd -L)"
+else
+  USER_HOME="$(cd -L -- ~ 2>/dev/null && pwd -L)"
+fi
+
 # MEKO_AGENT_ID overrides the cwd-derived id, matching resolveSessionAgentId() in
 # capture.js (the env override wins verbatim when non-empty).
 if [[ -n "${MEKO_AGENT_ID:-}" ]]; then
   AGENT_ID="$MEKO_AGENT_ID"
+  LEGACY_AGENT_ID="$MEKO_AGENT_ID"
 else
-  BASENAME="$(basename "$CWD")"
-  PROJECT_SLUG="$(printf '%s' "$BASENAME" | tr '[:upper:]' '[:lower:]' | sed -E 's/[^a-z0-9-]+/-/g; s/^-+|-+$//g')"
-  PROJECT_SLUG="${PROJECT_SLUG:0:64}"
+  # Walk up from $CWD for a '.git' entry. $HOME bounds the walk from below.
+  REPO_ROOT=""
+  # Normalize relative paths and '..' before the textual $HOME comparison,
+  # matching path.resolve() for live directories. Unlike JavaScript's lexical
+  # resolution, cd/pwd requires the directory to exist; statusline cwd does.
+  START_DIR="$(cd -L -- "$CWD" 2>/dev/null && pwd -L)"
+  if [[ -z "$START_DIR" ]]; then
+    START_DIR="${CWD%/}"
+    [[ -z "$START_DIR" ]] && START_DIR="$CWD"
+  fi
+  WALK_DIR="$START_DIR"
+  HOME_BOUND="$USER_HOME"
+  while [[ -n "$WALK_DIR" ]]; do
+    # A directory below a git-tracked home must not inherit home's .git.
+    if [[ -n "$HOME_BOUND" && "$WALK_DIR" == "$HOME_BOUND" && "$WALK_DIR" != "$START_DIR" ]]; then
+      break
+    fi
+    if [[ -e "$WALK_DIR/.git" ]]; then
+      REPO_ROOT="$WALK_DIR"
+      break
+    fi
+    # Check home itself for .git, then stop. A non-git home must not inherit
+    # repository state from /Users, /home, or /.
+    if [[ -n "$HOME_BOUND" && "$WALK_DIR" == "$HOME_BOUND" ]]; then
+      break
+    fi
+    PARENT="$(dirname "$WALK_DIR")"
+    [[ "$PARENT" == "$WALK_DIR" ]] && break
+    WALK_DIR="$PARENT"
+  done
 
-  if [[ -z "$PROJECT_SLUG" || "$PROJECT_SLUG" == "-" ]]; then
+  if [[ -z "$REPO_ROOT" ]]; then
+    # Outside any repo: bare client name, matching deriveAgentId().
     AGENT_ID="claude_code"
   else
-    AGENT_ID="claude_code:$PROJECT_SLUG"
+    BASENAME="$(basename "$REPO_ROOT")"
+    PROJECT_SLUG="$(printf '%s' "$BASENAME" | tr '[:upper:]' '[:lower:]' | sed -E 's/[^a-z0-9-]+/-/g; s/^-+|-+$//g')"
+    PROJECT_SLUG="${PROJECT_SLUG:0:64}"
+
+    if [[ -z "$PROJECT_SLUG" || "$PROJECT_SLUG" == "-" ]]; then
+      AGENT_ID="claude_code"
+    else
+      AGENT_ID="claude_code:$PROJECT_SLUG"
+    fi
+  fi
+
+  # Read-only compatibility alias for pins written before MEKO-590.
+  LEGACY_BASENAME="$(basename "$CWD")"
+  LEGACY_SLUG="$(printf '%s' "$LEGACY_BASENAME" | tr '[:upper:]' '[:lower:]' | sed -E 's/[^a-z0-9-]+/-/g; s/^-+|-+$//g')"
+  LEGACY_SLUG="${LEGACY_SLUG:0:64}"
+  if [[ -n "$LEGACY_SLUG" && "$LEGACY_SLUG" != "-" ]]; then
+    LEGACY_AGENT_ID="claude_code:$LEGACY_SLUG"
+  else
+    LEGACY_AGENT_ID="claude_code"
   fi
 fi
 
@@ -96,7 +155,11 @@ PIN_SLUG="$(printf '%s' "$AGENT_ID" | sed -E 's/[^A-Za-z0-9._-]+/_/g; s/^_+|_+$/
 if [[ -z "$PIN_SLUG" ]]; then
   PIN_SLUG="meko_agent"
 fi
-PIN_FILE="${MEKO_WATERMARK_DIR:-$HOME/.claude/meko-capture}/pin-${PIN_SLUG}.json"
+PIN_DIR="${MEKO_WATERMARK_DIR:-$USER_HOME/.claude/meko-capture}"
+PIN_FILE="${PIN_DIR}/pin-${PIN_SLUG}.json"
+LEGACY_PIN_SLUG="$(printf '%s' "$LEGACY_AGENT_ID" | sed -E 's/[^A-Za-z0-9._-]+/_/g; s/^_+|_+$//g')"
+[[ -z "$LEGACY_PIN_SLUG" ]] && LEGACY_PIN_SLUG="meko_agent"
+LEGACY_PIN_FILE="${PIN_DIR}/pin-${LEGACY_PIN_SLUG}.json"
 
 # --- Read the pin file and append the suffix if a valid pin is present ---
 
@@ -105,20 +168,24 @@ if [[ -n "${INNER_OUT:-}" ]]; then
   HAVE_SEGMENT=1
 fi
 
+PIN_NAME=""
 if [[ -f "$PIN_FILE" ]]; then
   # grep -oE isolates the exact "datapack_name":"…" pair before extracting, so a
   # greedy `.*` can't grab a different key that merely ends in datapack_name.
   PIN_NAME="$(grep -oE '"datapack_name"[[:space:]]*:[[:space:]]*"[^"]+"' "$PIN_FILE" | sed -E 's/.*"([^"]+)"$/\1/' | head -n 1)"
-  if [[ -n "$PIN_NAME" ]]; then
-    SUFFIX="Meko: $PIN_NAME"
-    # Add a separator only if the inner command produced output.
-    if [[ "$HAVE_SEGMENT" -eq 1 ]]; then
-      printf ' \xe2\x80\xa2 %s' "$SUFFIX"
-    else
-      printf '%s' "$SUFFIX"
-    fi
-    HAVE_SEGMENT=1
+fi
+if [[ -z "$PIN_NAME" && "$LEGACY_PIN_FILE" != "$PIN_FILE" && -f "$LEGACY_PIN_FILE" ]]; then
+  PIN_NAME="$(grep -oE '"datapack_name"[[:space:]]*:[[:space:]]*"[^"]+"' "$LEGACY_PIN_FILE" | sed -E 's/.*"([^"]+)"$/\1/' | head -n 1)"
+fi
+if [[ -n "$PIN_NAME" ]]; then
+  SUFFIX="Meko: $PIN_NAME"
+  # Add a separator only if the inner command produced output.
+  if [[ "$HAVE_SEGMENT" -eq 1 ]]; then
+    printf ' \xe2\x80\xa2 %s' "$SUFFIX"
+  else
+    printf '%s' "$SUFFIX"
   fi
+  HAVE_SEGMENT=1
 fi
 
 # --- Capture health suffix (Capture V2) ---
@@ -127,10 +194,26 @@ fi
 # nothing. Reads rebuildable capture-health.json (no full watermark scan).
 # Format mirrors statuslineSuffixFromHealth() in capture-notices.js.
 
-WATERMARK_DIR="${MEKO_WATERMARK_DIR:-$HOME/.claude/meko-capture}"
+WATERMARK_DIR="$PIN_DIR"
 HEALTH_FILE="${WATERMARK_DIR}/capture-health.json"
 CAPTURE_SUFFIX=""
-if [[ -f "$HEALTH_FILE" ]]; then
+# Hooks from 2.5.0 store a ready-made "statusline" text in the health cache
+# (statuslineText() in capture-notices.js): needs you, paused, retrying with
+# the next automatic repair, auto-fixed. An empty value means show nothing.
+# Older caches fall back to the status/queued suffix below.
+HAVE_STATUSLINE_FIELD=0
+if [[ -f "$HEALTH_FILE" ]] && grep -qE '"statusline"[[:space:]]*:' "$HEALTH_FILE"; then
+  HAVE_STATUSLINE_FIELD=1
+  CAPTURE_SUFFIX="$(grep -oE '"statusline"[[:space:]]*:[[:space:]]*"[^"]*"' "$HEALTH_FILE" | sed -E 's/^"statusline"[[:space:]]*:[[:space:]]*"(.*)"$/\1/' | head -n 1)"
+  # The text can carry an expiry: after statusline_until (epoch seconds),
+  # show statusline_after instead ("auto-fixed N" fades, "auto-fix at"
+  # becomes "auto-fix soon").
+  UNTIL="$(grep -oE '"statusline_until"[[:space:]]*:[[:space:]]*[0-9]+' "$HEALTH_FILE" | sed -E 's/.*:[[:space:]]*([0-9]+)$/\1/' | head -n 1)"
+  if [[ -n "$UNTIL" && "$(date +%s)" -gt "$UNTIL" ]]; then
+    CAPTURE_SUFFIX="$(grep -oE '"statusline_after"[[:space:]]*:[[:space:]]*"[^"]*"' "$HEALTH_FILE" | sed -E 's/^"statusline_after"[[:space:]]*:[[:space:]]*"(.*)"$/\1/' | head -n 1)"
+  fi
+fi
+if [[ "$HAVE_STATUSLINE_FIELD" -eq 0 && -f "$HEALTH_FILE" ]]; then
   HEALTH_STATUS="$(grep -oE '"status"[[:space:]]*:[[:space:]]*"[^"]+"' "$HEALTH_FILE" | sed -E 's/.*"([^"]+)"$/\1/' | head -n 1)"
   QUEUED="$(grep -oE '"queued_exchanges"[[:space:]]*:[[:space:]]*[0-9]+' "$HEALTH_FILE" | sed -E 's/.*:[[:space:]]*([0-9]+)$/\1/' | head -n 1)"
   QUEUED="${QUEUED:-0}"