@zerwiz/ymir 0.1.16 → 0.1.18

package/.pi/shared/extensions/syn-turnend-guard.ts

@@ -0,0 +1,683 @@
+import { spawn, spawnSync, type ChildProcess } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  classifyRoddCurrentOperationalText,
+  encodeRoddOperationalInput,
+} from "./lib/rodd-operational-input.ts";
+
+let guardFollowupActive = false;
+
+type LockOwnership = "owned" | "missing" | "other";
+
+const extensionFile = fileURLToPath(import.meta.url);
+const extensionDir = dirname(extensionFile);
+const root = resolve(extensionDir, "../..");
+const fmHome = process.env.BROKK_HOME || process.env.BROKK_ROOT_OVERRIDE || root;
+const state = process.env.BROKK_STATE_OVERRIDE || `${fmHome}/state`;
+const marker = `${state}/.pi-turnend-extension-loaded`;
+const extensionVersion = `sha256:${createHash("sha256").update(readFileSync(extensionFile)).digest("hex")}`;
+
+function parentPid(pid: string): string {
+  const result = spawnSync("ps", ["-o", "ppid=", "-p", pid], { encoding: "utf8" });
+  if (result.status !== 0) return "";
+  return result.stdout.trim();
+}
+
+// Liveness that actually sees death: a zombie (killed but unreaped) or a
+// recycled pid must not pass for a live lock holder. /proc/<pid>/stat field 3
+// is the state character (Z/X = zombie/dead); when /proc is unavailable we
+// fall back to kill(0).
+function pidAlive(pid: string): boolean {
+  if (/^[0-9]+$/.test(pid) && pid !== "1") {
+    try {
+      const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+      const close = stat.lastIndexOf(")");
+      if (close >= 0) {
+        const state = stat.slice(close + 2).trim().split(/\s+/)[0];
+        if (state === "Z" || state === "X") return false;
+      }
+    } catch {
+      // no /proc (non-Linux) — rely on kill(0)
+    }
+  }
+  try {
+    process.kill(Number(pid), 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// The resolved session-lock path (machine-global for the primary, per-home for
+// an Eindri-home). gleipnir-lock-lib.sh records it in state/.lock-path; a
+// pre-contract session still lives at the legacy state/.lock.
+function resolvedLockPath(): string {
+  try {
+    const pointer = readFileSync(`${state}/.lock-path`, "utf8").trim();
+    if (pointer) return pointer;
+  } catch {
+    // no pointer yet — pre-machine-lock session
+  }
+  return `${state}/.lock`;
+}
+
+function lockOwnership(): LockOwnership {
+  let lockPid = "";
+  try {
+    lockPid = readFileSync(resolvedLockPath(), "utf8").trim();
+  } catch {
+    return "missing";
+  }
+  if (!/^[0-9]+$/.test(lockPid) || lockPid === "1") return "other";
+  let pid = String(process.pid);
+  for (let i = 0; i < 8; i += 1) {
+    if (pid === lockPid) return "owned";
+    pid = parentPid(pid);
+    if (!pid || pid === "1") break;
+  }
+  return pidAlive(lockPid) ? "other" : "missing";
+}
+
+function markLoaded(): void {
+  if (!existsSync(state) || lockOwnership() === "other") return;
+  writeFileSync(marker, `${extensionVersion}\n${process.pid}\n`);
+}
+
+// Pi's session_start reasons are startup | reload | new | resume | fork, and a
+// separate session_compact event fires after a compaction. "new" is Pi's /new
+// while reload, resume, and fork all keep prior context.
+const sessionstartDeliveryBytes = 512 * 1024;
+
+type SessionStartContext = {
+  sessionManager?: {
+    getHeader?: () => { timestamp?: unknown } | null | undefined;
+    getSessionId?: () => unknown;
+  };
+};
+
+function restoredSessionEvidence(ctx: SessionStartContext): boolean {
+  try {
+    const timestamp = ctx.sessionManager?.getHeader?.()?.timestamp;
+    const createdAt = typeof timestamp === "string" ? Date.parse(timestamp) : Number.NaN;
+    return Number.isFinite(createdAt) && createdAt < performance.timeOrigin;
+  } catch {
+    return false;
+  }
+}
+
+function startupRebuildSource(ctx: SessionStartContext): "resume" | "fork" | undefined {
+  const args = process.argv.slice(2);
+  const restored = restoredSessionEvidence(ctx);
+  for (const arg of args) {
+    if (arg === "--fork" || arg.startsWith("--fork=")) return "fork";
+    if (
+      restored && (
+        arg === "-c" || arg === "--continue" ||
+        arg === "-r" || arg === "--resume" ||
+        arg === "--session" || arg.startsWith("--session=") ||
+        arg === "--session-id" || arg.startsWith("--session-id=")
+      )
+    ) return "resume";
+  }
+  return undefined;
+}
+const sessionstartTruncatedMarker =
+  "\n\nPI SESSION-START DELIVERY TRUNCATED - the digest exceeded 512 KiB. " +
+  "Treat omitted context as unread and inspect the named files directly before acting on it.";
+const sessionstartManualFallback =
+  "Run `bin/saga-session-start.sh` now, exactly once, before executing any other instructions.";
+const sessionstartIneligibleExit = 3;
+const sessionstartRetireTimeoutMs = 1000;
+
+// One active generation owns native startup from child launch through context
+// claim. Replacement activates first, serially retires every predecessor, and
+// lets only the matching session id claim one persistent provider prerequisite.
+type SessionstartSource = "startup" | "clear" | "resume" | "fork" | "compact";
+type SessionstartResult =
+  | { kind: "ready"; raw: string }
+  | { kind: "empty" | "failed" | "ineligible" | "cancelled" };
+type SessionstartMessage = {
+  customType: "brokk-sessionstart-nudge";
+  content: string;
+  display: false;
+  details: { kind: "session-start" };
+};
+type SessionstartGeneration = {
+  id: number;
+  sessionId: string;
+  source: SessionstartSource;
+  stopping: boolean;
+  delivered: boolean;
+  child: ChildProcess | null;
+  processGroupId: number | null;
+  childClosed: boolean;
+  childClose: Promise<void> | null;
+  stopPromise: Promise<void> | null;
+  result: Promise<SessionstartResult>;
+};
+
+let nextSessionstartGenerationId = 0;
+let activeSessionstartGeneration: SessionstartGeneration | null = null;
+
+function sessionIdFromContext(ctx: SessionStartContext): string {
+  try {
+    return String(ctx.sessionManager?.getSessionId?.() ?? "");
+  } catch {
+    return "";
+  }
+}
+
+function sessionstartGenerationIsLive(generation: SessionstartGeneration): boolean {
+  return activeSessionstartGeneration === generation && !generation.stopping;
+}
+
+function signalSessionstartChild(child: ChildProcess, signal: NodeJS.Signals): void {
+  const pid = child.pid;
+  if (!pid) return;
+  if (process.platform === "win32") {
+    const args = ["/pid", String(pid), "/t"];
+    if (signal === "SIGKILL") args.push("/f");
+    spawnSync("taskkill", args, { stdio: "ignore" });
+    return;
+  }
+  try {
+    process.kill(-pid, signal);
+  } catch {
+    try {
+      child.kill(signal);
+    } catch {
+    }
+  }
+}
+
+function sessionstartProcessGroupAlive(processGroupId: number): boolean {
+  try {
+    process.kill(-processGroupId, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function waitForSessionstartProcessGroupExit(
+  processGroupId: number,
+  timeoutMs: number,
+): Promise<void> {
+  return new Promise((resolveWait) => {
+    const startedAt = Date.now();
+    const poll = (): void => {
+      if (!sessionstartProcessGroupAlive(processGroupId) || Date.now() - startedAt >= timeoutMs) {
+        resolveWait();
+        return;
+      }
+      setTimeout(poll, 10);
+    };
+    poll();
+  });
+}
+
+function waitForSessionstartClose(generation: SessionstartGeneration, timeoutMs: number): Promise<void> {
+  if (generation.childClosed || !generation.childClose) return Promise.resolve();
+  return new Promise((resolveWait) => {
+    const timer = setTimeout(resolveWait, timeoutMs);
+    void generation.childClose?.then(() => {
+      clearTimeout(timer);
+      resolveWait();
+    });
+  });
+}
+
+function stopSessionstartGeneration(generation: SessionstartGeneration): Promise<void> {
+  if (generation.stopPromise) return generation.stopPromise;
+  generation.stopping = true;
+  generation.stopPromise = (async () => {
+    const child = generation.child;
+    if (process.platform === "win32") {
+      if (!child || generation.childClosed) {
+        await generation.result;
+        return;
+      }
+      signalSessionstartChild(child, "SIGTERM");
+      await waitForSessionstartClose(generation, sessionstartRetireTimeoutMs);
+      if (!generation.childClosed) {
+        signalSessionstartChild(child, "SIGKILL");
+        await waitForSessionstartClose(generation, sessionstartRetireTimeoutMs);
+      }
+      return;
+    }
+    const processGroupId = generation.processGroupId;
+    if (!child || !processGroupId) {
+      await generation.result;
+      return;
+    }
+    try {
+      process.kill(-processGroupId, "SIGTERM");
+    } catch {
+    }
+    await waitForSessionstartProcessGroupExit(processGroupId, sessionstartRetireTimeoutMs);
+    if (sessionstartProcessGroupAlive(processGroupId)) {
+      try {
+        process.kill(-processGroupId, "SIGKILL");
+      } catch {
+      }
+      await waitForSessionstartProcessGroupExit(processGroupId, sessionstartRetireTimeoutMs);
+    }
+  })();
+  return generation.stopPromise;
+}
+
+function runSessionstartHook(generation: SessionstartGeneration): Promise<SessionstartResult> {
+  return new Promise((resolveResult) => {
+    let settled = false;
+    let closeChild: () => void = () => {};
+    const settle = (result: SessionstartResult): void => {
+      if (settled) return;
+      settled = true;
+      resolveResult(result);
+    };
+    const supervised = process.platform !== "win32";
+    const runner = `${root}/bin/saga-sessionstart-run.sh`;
+    let child: ChildProcess;
+    try {
+      child = spawn(
+        supervised ? "node" : runner,
+        supervised
+          ? [
+              `${extensionDir}/lib/vordr-sessionstart-supervisor.mjs`,
+              runner,
+              "--source",
+              generation.source,
+              "--pi-prerequisite",
+            ]
+          : ["--source", generation.source, "--pi-prerequisite"],
+        {
+          detached: supervised,
+          stdio: supervised
+            ? ["ignore", "pipe", "ignore", "ipc"]
+            : ["ignore", "pipe", "ignore"],
+          env: {
+            ...process.env,
+            BROKK_SESSION_PID: String(process.pid),
+          },
+        },
+      );
+    } catch {
+      settle(generation.stopping ? { kind: "cancelled" } : { kind: "failed" });
+      return;
+    }
+    generation.child = child;
+    generation.processGroupId = child.pid ?? null;
+    generation.childClose = new Promise<void>((resolveClose) => {
+      closeChild = resolveClose;
+    });
+    const chunks: Buffer[] = [];
+    let observedBytes = 0;
+    let retainedBytes = 0;
+    let truncated = false;
+    let pendingCompletion: { code: number | null; bytes: number } | null = null;
+    const unrefSupervisor = (): void => {
+      if (!supervised) return;
+      child.unref();
+      child.channel?.unref?.();
+      const stdout = child.stdout as (NodeJS.ReadableStream & { unref?: () => void }) | null;
+      stdout?.unref?.();
+    };
+    const markClosed = (): void => {
+      if (generation.childClosed) return;
+      generation.childClosed = true;
+      if (generation.child === child) generation.child = null;
+      generation.processGroupId = null;
+      closeChild();
+    };
+    const complete = (code: number | null): void => {
+      unrefSupervisor();
+      if (generation.stopping) {
+        settle({ kind: "cancelled" });
+        return;
+      }
+      if (code === sessionstartIneligibleExit) {
+        settle({ kind: "ineligible" });
+        return;
+      }
+      if (code !== 0) {
+        settle({ kind: "failed" });
+        return;
+      }
+      const raw = Buffer.concat(chunks).toString("utf8").trim();
+      if (!raw) {
+        settle({ kind: "empty" });
+        return;
+      }
+      settle({
+        kind: "ready",
+        raw: truncated ? `${raw}${sessionstartTruncatedMarker}` : raw,
+      });
+    };
+    const completePending = (): void => {
+      if (!pendingCompletion || observedBytes < pendingCompletion.bytes) return;
+      complete(pendingCompletion.code);
+      pendingCompletion = null;
+    };
+    child.stdout?.on("data", (chunk: Buffer) => {
+      observedBytes += chunk.length;
+      if (retainedBytes >= sessionstartDeliveryBytes) {
+        truncated = true;
+        completePending();
+        return;
+      }
+      const remaining = sessionstartDeliveryBytes - retainedBytes;
+      const retained = chunk.length <= remaining ? chunk : chunk.subarray(0, remaining);
+      chunks.push(retained);
+      retainedBytes += retained.length;
+      if (retained.length !== chunk.length) truncated = true;
+      completePending();
+    });
+    if (supervised) {
+      child.on("message", (message: unknown) => {
+        const result = message as { type?: unknown; code?: unknown; bytes?: unknown };
+        if (result.type !== "result" ||
+            (typeof result.code !== "number" && result.code !== null) ||
+            typeof result.bytes !== "number") return;
+        pendingCompletion = { code: result.code, bytes: result.bytes };
+        completePending();
+      });
+    }
+    child.on("error", () => {
+      markClosed();
+      settle(generation.stopping ? { kind: "cancelled" } : { kind: "failed" });
+    });
+    child.on("close", (code) => {
+      markClosed();
+      if (supervised) {
+        settle(generation.stopping ? { kind: "cancelled" } : { kind: "failed" });
+        return;
+      }
+      complete(code);
+    });
+  });
+}
+
+function createSessionstartGeneration(
+  source: SessionstartSource,
+  sessionId: string,
+): SessionstartGeneration {
+  const previous = activeSessionstartGeneration;
+  const generation: SessionstartGeneration = {
+    id: ++nextSessionstartGenerationId,
+    sessionId,
+    source,
+    stopping: false,
+    delivered: false,
+    child: null,
+    processGroupId: null,
+    childClosed: false,
+    childClose: null,
+    stopPromise: null,
+    result: Promise.resolve({ kind: "cancelled" }),
+  };
+  activeSessionstartGeneration = generation;
+  generation.result = (async (): Promise<SessionstartResult> => {
+    if (previous) await stopSessionstartGeneration(previous);
+    if (!sessionstartGenerationIsLive(generation)) return { kind: "cancelled" };
+    return runSessionstartHook(generation);
+  })();
+  return generation;
+}
+
+function sessionstartMessage(
+  generation: SessionstartGeneration,
+  result: SessionstartResult,
+): SessionstartMessage | undefined {
+  let raw = result.kind === "ready" ? result.raw : "";
+  if (!raw && result.kind === "failed") {
+    raw = sessionstartManualFallback;
+  } else if (!raw && ["startup", "clear", "compact"].includes(generation.source) &&
+      result.kind === "empty") {
+    raw = sessionstartManualFallback;
+  }
+  if (!raw) return undefined;
+  try {
+    // The wrapper already returns an encoded nudge on a context-preserving
+    // open, so only an unencoded digest or fallback needs the marker added.
+    const content = classifyRoddCurrentOperationalText(raw)
+      ? raw
+      : encodeRoddOperationalInput("session-start", raw);
+    return {
+      customType: "brokk-sessionstart-nudge",
+      content,
+      display: false,
+      details: { kind: "session-start" },
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+async function claimSessionstartMessage(
+  generation: SessionstartGeneration,
+  ctx?: SessionStartContext,
+): Promise<SessionstartMessage | undefined> {
+  const result = await generation.result;
+  if (!sessionstartGenerationIsLive(generation) || generation.delivered) return undefined;
+  const currentSessionId = ctx ? sessionIdFromContext(ctx) : "";
+  if (generation.sessionId && currentSessionId && generation.sessionId !== currentSessionId) {
+    return undefined;
+  }
+  generation.delivered = true;
+  return sessionstartMessage(generation, result);
+}
+
+function runGuard(): Promise<{ code: number; stderr: string }> {
+  return new Promise((resolveResult) => {
+    const child = spawn(`${root}/bin/syn-turnend-guard.sh`, {
+      stdio: ["pipe", "ignore", "pipe"],
+    });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", () => resolveResult({ code: 0, stderr: "" }));
+    child.on("close", (code) => resolveResult({ code: code ?? 0, stderr }));
+    child.stdin.end('{"stop_hook_active":false}');
+  });
+}
+
+// PreToolUse seatbelts (bin/syn-arm-pretool-check.sh, docs/arm-pretool-check.md;
+// bin/syn-cd-pretool-check.sh, docs/cd-guard.md). Both piggyback on this same
+// extension file rather than separate ones so no extra Pi -e flag is needed at
+// launch - the primary already loads this file for the turn-end guard, and
+// pi.on("tool_call", ...) can block (verified 2026-07-09 against pi 0.80.5:
+// returning {block: true} prevents the bash command from running). Each owner
+// script owns its own decision and is inert outside the real primary checkout.
+function runChecker(script: string, command: string): Promise<{ code: number; stderr: string }> {
+  return new Promise((resolveResult) => {
+    const child = spawn(`${root}/bin/${script}`, ["--command", command], {
+      stdio: ["ignore", "ignore", "pipe"],
+    });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", () => resolveResult({ code: 0, stderr: "" }));
+    child.on("close", (code) => resolveResult({ code: code ?? 0, stderr }));
+  });
+}
+
+function runPretoolCheck(command: string): Promise<{ code: number; stderr: string }> {
+  return runChecker("syn-arm-pretool-check.sh", command);
+}
+
+function runCdCheck(command: string): Promise<{ code: number; stderr: string }> {
+  return runChecker("syn-cd-pretool-check.sh", command);
+}
+
+// Asset seatbelt (bin/syn-asset-pretool-check.sh): a governed path may not be
+// edited until its owning asset has been read this session. The read itself is
+// recorded through the same script, so the gate is self-contained.
+function runAssetCheck(path: string): Promise<{ code: number; stderr: string }> {
+  return new Promise((resolveResult) => {
+    const child = spawn(`${root}/bin/syn-asset-pretool-check.sh`, ["--path", path], {
+      stdio: ["ignore", "ignore", "pipe"],
+    });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", () => resolveResult({ code: 0, stderr: "" }));
+    child.on("close", (code) => resolveResult({ code: code ?? 0, stderr }));
+  });
+}
+
+function noteAssetRead(path: string): void {
+  try {
+    const child = spawn(`${root}/bin/syn-asset-pretool-check.sh`, ["--note", path], {
+      stdio: ["ignore", "ignore", "ignore"],
+    });
+    child.on("error", () => undefined);
+  } catch {
+    // The note is best-effort; never break a read over it.
+  }
+}
+
+export default function (pi: ExtensionAPI) {
+  let sessionstartGeneration: SessionstartGeneration | null = null;
+  let sessionstartExitListenerRegistered = false;
+  const cleanupSessionstartOnProcessExit = (): void => {
+    const generation = sessionstartGeneration;
+    if (!generation) return;
+    if (process.platform === "win32") {
+      if (generation.child) signalSessionstartChild(generation.child, "SIGKILL");
+      return;
+    }
+    const processGroupId = generation.processGroupId;
+    if (!processGroupId) {
+      if (generation.child) signalSessionstartChild(generation.child, "SIGKILL");
+      return;
+    }
+    try {
+      process.kill(-processGroupId, "SIGKILL");
+    } catch {
+    }
+  };
+  const registerSessionstartExitListener = (): void => {
+    if (sessionstartExitListenerRegistered) return;
+    process.once("exit", cleanupSessionstartOnProcessExit);
+    sessionstartExitListenerRegistered = true;
+  };
+  const removeSessionstartExitListener = (): void => {
+    if (!sessionstartExitListenerRegistered) return;
+    process.removeListener("exit", cleanupSessionstartOnProcessExit);
+    sessionstartExitListenerRegistered = false;
+  };
+  registerSessionstartExitListener();
+
+  pi.on?.("session_start", (event, ctx) => {
+    const reason = String((event as { reason?: unknown }).reason ?? "");
+    const source = reason === "startup"
+      ? startupRebuildSource(ctx) ?? "startup"
+      : { new: "clear", resume: "resume", fork: "fork" }[reason];
+    markLoaded();
+    if (!source) return;
+    registerSessionstartExitListener();
+    sessionstartGeneration = createSessionstartGeneration(
+      source as SessionstartSource,
+      sessionIdFromContext(ctx),
+    );
+  });
+
+  pi.on?.("before_agent_start", async (_event, ctx) => {
+    const generation = sessionstartGeneration;
+    if (!generation) return;
+    const message = await claimSessionstartMessage(generation, ctx);
+    return message ? { message } : undefined;
+  });
+
+  // Pi's compaction equivalent. Manual compaction is idle and auto-compaction
+  // may retry without another before_agent_start, so the event keeps its
+  // existing delivery path while sharing generation ownership and cancellation.
+  pi.on?.("session_compact", async (_event, ctx) => {
+    registerSessionstartExitListener();
+    const generation = createSessionstartGeneration("compact", sessionIdFromContext(ctx));
+    sessionstartGeneration = generation;
+    const message = await claimSessionstartMessage(generation, ctx);
+    if (!message || !sessionstartGenerationIsLive(generation)) return;
+    try {
+      pi.sendMessage(message);
+    } catch {
+      generation.delivered = false;
+    }
+  });
+
+  pi.on?.("session_shutdown", async () => {
+    const generation = sessionstartGeneration;
+    try {
+      if (generation) await stopSessionstartGeneration(generation);
+    } finally {
+      if (sessionstartGeneration === generation) sessionstartGeneration = null;
+      removeSessionstartExitListener();
+    }
+  });
+
+  pi.on("tool_call", async (event) => {
+    if (event.type !== "tool_call") return {};
+
+    // Reading an asset records it, which unlocks editing the governed path.
+    if (event.toolName === "read") {
+      const readPath = String((event.input as { path?: unknown })?.path ?? "");
+      if (readPath.includes("/assets/")) noteAssetRead(readPath.replace(/^\.\//, ""));
+      return {};
+    }
+
+    // A governed path may not be edited until its owning asset was loaded.
+    if (event.toolName === "edit" || event.toolName === "write") {
+      const editPath = String((event.input as { path?: unknown })?.path ?? "");
+      if (editPath) {
+        const assetResult = await runAssetCheck(editPath);
+        if (assetResult.code === 2) {
+          return { block: true, reason: assetResult.stderr.trim() || "denied by the governed-path asset seatbelt" };
+        }
+      }
+      return {};
+    }
+
+    if (event.toolName !== "bash") return {};
+    const command = String((event.input as { command?: unknown })?.command ?? "");
+    if (!command) return {};
+    const cdResult = await runCdCheck(command);
+    if (cdResult.code === 2) {
+      return { block: true, reason: cdResult.stderr.trim() || "denied by the cd-guard PreToolUse seatbelt" };
+    }
+    const result = await runPretoolCheck(command);
+    if (result.code !== 2) return {};
+    return { block: true, reason: result.stderr.trim() || "denied by the watcher-arm PreToolUse seatbelt" };
+  });
+
+  pi.on("agent_settled", async () => {
+    if (guardFollowupActive) {
+      guardFollowupActive = false;
+      return;
+    }
+
+    const result = await runGuard();
+    if (result.code !== 2) return;
+
+    guardFollowupActive = true;
+    try {
+      const content = encodeRoddOperationalInput(
+        "turn-end-guard",
+        "TURN WOULD END BLIND - supervision is off. " +
+          "The watcher cycle is missing, failed, or unhealthy. Follow the harness recovery instruction below before ending the turn.\n\n" +
+          result.stderr,
+      );
+      await pi.sendUserMessage(content, { deliverAs: "followUp" });
+    } catch {
+      guardFollowupActive = false;
+    }
+  });
+
+  markLoaded();
+}