[codex] Harden execution reliability and heartbeat tooling (#3679)

## Thinking Path

> - Paperclip orchestrates AI agents for zero-human companies
> - Reliable execution depends on heartbeat routing, issue lifecycle
semantics, telemetry, and a fast enough local verification loop to keep
regressions visible
> - The remaining commits on this branch were mostly server/runtime
correctness fixes plus test and documentation follow-ups in that area
> - Those changes are logically separate from the UI-focused
issue-detail and workspace/navigation branches even when they touch
overlapping issue APIs
> - This pull request groups the execution reliability, heartbeat,
telemetry, and tooling changes into one standalone branch
> - The benefit is a focused review of the control-plane correctness
work, including the follow-up fix that restored the implicit
comment-reopen helpers after branch splitting

## What Changed

- Hardened issue/heartbeat execution behavior, including self-review
stage skipping, deferred mention wakes during active execution, stranded
execution recovery, active-run scoping, assignee resolution, and
blocked-to-todo wake resumption
- Reduced noisy polling/logging overhead by trimming issue run payloads,
compacting persisted run logs, silencing high-volume request logs, and
capping heartbeat-run queries in dashboard/inbox surfaces
- Expanded telemetry and status semantics with adapter/model fields on
task completion plus clearer status guidance in docs/onboarding material
- Updated test infrastructure and verification defaults with faster
route-test module isolation, cheaper default `pnpm test`, e2e isolation
from local state, and repo verification follow-ups
- Included docs/release housekeeping from the branch and added a small
follow-up commit restoring the implicit comment-reopen helpers that were
dropped during branch reconstruction

## Verification

- `pnpm vitest run
server/src/__tests__/issue-comment-reopen-routes.test.ts
server/src/__tests__/issue-telemetry-routes.test.ts`
- `pnpm vitest run server/src/__tests__/http-log-policy.test.ts
server/src/__tests__/heartbeat-run-log.test.ts
server/src/__tests__/health.test.ts`
- `server/src/__tests__/activity-service.test.ts`,
`server/src/__tests__/heartbeat-comment-wake-batching.test.ts`, and
`server/src/__tests__/heartbeat-process-recovery.test.ts` were attempted
on this host but the embedded Postgres harness reported
init-script/data-dir problems and skipped or failed to start, so they
are noted as environment-limited

## Risks

- Medium: this branch changes core issue/heartbeat routing and
reopen/wakeup behavior, so regressions would affect agent execution flow
rather than isolated UI polish
- Because it also updates verification infrastructure, reviewers should
pay attention to whether the new tests are asserting the right failure
modes and not just reshaping harness behavior

## Model Used

- OpenAI Codex coding agent (GPT-5-class runtime in Codex CLI; exact
deployed model ID is not exposed in this environment), reasoning
enabled, tool use and local code execution enabled

## Checklist

- [x] I have included a thinking path that traces from project context
to this change
- [x] I have specified the model used (with version and capability
details)
- [ ] I have run tests locally and they pass
- [x] I have added or updated tests where applicable
- [ ] If this change affects the UI, I have included before/after
screenshots
- [x] I have updated relevant documentation to reflect my changes
- [x] I have considered and documented any risks above
- [x] I will address all Greptile and reviewer comments before
requesting merge

---------

Co-authored-by: Paperclip <noreply@paperclip.ing>

server/src/vite-html-renderer.ts

@@ -0,0 +1,86 @@
+import fs from "node:fs";
+import path from "node:path";
+
+type ViteWatcherEvent = "add" | "change" | "unlink";
+
+export interface ViteWatcherHost {
+  watcher?: {
+    on?: (event: ViteWatcherEvent, listener: (file: string) => void) => unknown;
+    off?: (event: ViteWatcherEvent, listener: (file: string) => void) => unknown;
+  };
+}
+
+export interface CachedViteHtmlRenderer {
+  render(_url: string): Promise<string>;
+  dispose(): void;
+}
+
+const WATCHER_EVENTS: ViteWatcherEvent[] = ["add", "change", "unlink"];
+const MAIN_ENTRY_TAG = '<script type="module" src="/src/main.tsx"></script>';
+const VITE_CLIENT_TAG = '<script type="module" src="/@vite/client"></script>';
+const REACT_REFRESH_PREAMBLE = `<script type="module">
+import { injectIntoGlobalHook } from "/@react-refresh";
+injectIntoGlobalHook(window);
+window.$RefreshReg$ = () => {};
+window.$RefreshSig$ = () => (type) => type;
+</script>`;
+
+function injectViteDevPreamble(html: string): string {
+  let injectedHtml = html;
+  if (!injectedHtml.includes('"/@react-refresh"') && !injectedHtml.includes("'/@react-refresh'")) {
+    injectedHtml = injectedHtml.includes("</head>")
+      ? injectedHtml.replace("</head>", `    ${REACT_REFRESH_PREAMBLE}\n  </head>`)
+      : `${REACT_REFRESH_PREAMBLE}\n${injectedHtml}`;
+  }
+  if (injectedHtml.includes(VITE_CLIENT_TAG)) return injectedHtml;
+  if (injectedHtml.includes(MAIN_ENTRY_TAG)) {
+    return injectedHtml.replace(MAIN_ENTRY_TAG, `${VITE_CLIENT_TAG}\n    ${MAIN_ENTRY_TAG}`);
+  }
+  return injectedHtml.replace("</body>", `    ${VITE_CLIENT_TAG}\n  </body>`);
+}
+
+export function createCachedViteHtmlRenderer(opts: {
+  vite: ViteWatcherHost;
+  uiRoot: string;
+  brandHtml?: (html: string) => string;
+}): CachedViteHtmlRenderer {
+  const uiRoot = path.resolve(opts.uiRoot);
+  const templatePath = path.resolve(uiRoot, "index.html");
+  const brandHtml = opts.brandHtml ?? ((html: string) => html);
+  let cachedHtml: string | null = null;
+
+  function loadHtml(): string {
+    if (cachedHtml === null) {
+      const rawTemplate = fs.readFileSync(templatePath, "utf-8");
+      cachedHtml = injectViteDevPreamble(brandHtml(rawTemplate));
+    }
+    return cachedHtml;
+  }
+
+  function invalidate(): void {
+    cachedHtml = null;
+  }
+
+  function onWatchEvent(filePath: string): void {
+    const resolvedPath = path.resolve(filePath);
+    if (resolvedPath === templatePath || resolvedPath.startsWith(`${uiRoot}${path.sep}`)) {
+      invalidate();
+    }
+  }
+
+  for (const eventName of WATCHER_EVENTS) {
+    opts.vite.watcher?.on?.(eventName, onWatchEvent);
+  }
+
+  return {
+    render(): Promise<string> {
+      return Promise.resolve(loadHtml());
+    },
+
+    dispose(): void {
+      for (const eventName of WATCHER_EVENTS) {
+        opts.vite.watcher?.off?.(eventName, onWatchEvent);
+      }
+    },
+  };
+}