[codex] Add run liveness continuations (#4083)

## Thinking Path

> - Paperclip orchestrates AI agents for zero-human companies.
> - Heartbeat runs are the control-plane record of each agent execution
window.
> - Long-running local agents can exhaust context or stop while still
holding useful next-step state.
> - Operators need that stop reason, next action, and continuation path
to be durable and visible.
> - This pull request adds run liveness metadata, continuation
summaries, and UI surfaces for issue run ledgers.
> - The benefit is that interrupted or long-running work can resume with
clearer context instead of losing the agent's last useful handoff.

## What Changed

- Added heartbeat-run liveness fields, continuation attempt tracking,
and an idempotent `0058` migration.
- Added server services and tests for run liveness, continuation
summaries, stop metadata, and activity backfill.
- Wired local and HTTP adapters to surface continuation/liveness context
through shared adapter utilities.
- Added shared constants, validators, and heartbeat types for liveness
continuation state.
- Added issue-detail UI surfaces for continuation handoffs and the run
ledger, with component tests.
- Updated agent runtime docs, heartbeat protocol docs, prompt guidance,
onboarding assets, and skills instructions to explain continuation
behavior.
- Addressed Greptile feedback by scoping document evidence by run,
excluding system continuation-summary documents from liveness evidence,
importing shared liveness types, surfacing hidden ledger run counts,
documenting bounded retry behavior, and moving run-ledger liveness
backfill off the request path.

## Verification

- `pnpm exec vitest run packages/adapter-utils/src/server-utils.test.ts
server/src/__tests__/run-continuations.test.ts
server/src/__tests__/run-liveness.test.ts
server/src/__tests__/activity-service.test.ts
server/src/__tests__/documents-service.test.ts
server/src/__tests__/issue-continuation-summary.test.ts
server/src/services/heartbeat-stop-metadata.test.ts
ui/src/components/IssueRunLedger.test.tsx
ui/src/components/IssueContinuationHandoff.test.tsx
ui/src/components/IssueDocumentsSection.test.tsx`
- `pnpm --filter @paperclipai/db build`
- `pnpm exec vitest run server/src/__tests__/activity-service.test.ts
ui/src/components/IssueRunLedger.test.tsx`
- `pnpm --filter @paperclipai/ui typecheck`
- `pnpm --filter @paperclipai/server typecheck`
- `pnpm exec vitest run server/src/__tests__/activity-service.test.ts
server/src/__tests__/run-continuations.test.ts
ui/src/components/IssueRunLedger.test.tsx`
- `pnpm exec vitest run
server/src/__tests__/heartbeat-process-recovery.test.ts -t "treats a
plan document update"`
- `pnpm exec vitest run server/src/__tests__/activity-service.test.ts
server/src/__tests__/heartbeat-process-recovery.test.ts -t "activity
service|treats a plan document update"`
- Remote PR checks on head `e53b1a1d`: `verify`, `e2e`, `policy`, and
Snyk all passed.
- Confirmed `public-gh/master` is an ancestor of this branch after
fetching `public-gh master`.
- Confirmed `pnpm-lock.yaml` is not included in the branch diff.
- Confirmed migration `0058_wealthy_starbolt.sql` is ordered after
`0057` and uses `IF NOT EXISTS` guards for repeat application.
- Greptile inline review threads are resolved.

## Risks

- Medium risk: this touches heartbeat execution, liveness recovery,
activity rendering, issue routes, shared contracts, docs, and UI.
- Migration risk is mitigated by additive columns/indexes and idempotent
guards.
- Run-ledger liveness backfill is now asynchronous, so the first ledger
response can briefly show historical missing liveness until the
background backfill completes.
- UI screenshot coverage is not included in this packaging pass;
validation is currently through focused component tests.

> For core feature work, check [`ROADMAP.md`](ROADMAP.md) first and
discuss it in `#dev` before opening the PR. Feature PRs that overlap
with planned core work may need to be redirected — check the roadmap
first. See `CONTRIBUTING.md`.

## Model Used

- OpenAI Codex, GPT-5.4, local tool-use coding agent with terminal, git,
GitHub connector, GitHub CLI, and Paperclip API access.

## 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)
- [x] I have checked ROADMAP.md and confirmed this PR does not duplicate
planned core work
- [x] I have run tests locally and they pass
- [x] I have added or updated tests where applicable
- [x] 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

Screenshot note: no before/after screenshots were captured in this PR
packaging pass; the UI changes are covered by focused component tests
listed above.

---------

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

server/src/services/heartbeat-stop-metadata.ts

@@ -0,0 +1,119 @@
+export type HeartbeatRunOutcome = "succeeded" | "failed" | "cancelled" | "timed_out";
+
+export type HeartbeatRunStopReason =
+  | "completed"
+  | "timeout"
+  | "cancelled"
+  | "budget_paused"
+  | "paused"
+  | "process_lost"
+  | "adapter_failed";
+
+export interface HeartbeatRunTimeoutPolicy {
+  effectiveTimeoutSec: number | null;
+  effectiveTimeoutMs?: number | null;
+  timeoutConfigured: boolean;
+  timeoutSource: "config" | "default" | "unknown";
+}
+
+export interface HeartbeatRunStopMetadata extends HeartbeatRunTimeoutPolicy {
+  stopReason: HeartbeatRunStopReason;
+  timeoutFired: boolean;
+}
+
+function readFiniteNumber(value: unknown): number | null {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  if (typeof value === "string") {
+    const parsed = Number(value.trim());
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+
+function hasOwn(record: Record<string, unknown>, key: string) {
+  return Object.prototype.hasOwnProperty.call(record, key);
+}
+
+function defaultTimeoutSecForAdapter(adapterType: string) {
+  return adapterType === "openclaw_gateway" ? 120 : 0;
+}
+
+export function resolveHeartbeatRunTimeoutPolicy(
+  adapterType: string,
+  adapterConfig: Record<string, unknown> | null | undefined,
+): HeartbeatRunTimeoutPolicy {
+  const config = adapterConfig ?? {};
+
+  if (adapterType === "http") {
+    const hasTimeoutMs = hasOwn(config, "timeoutMs");
+    const rawTimeoutMs = hasTimeoutMs ? readFiniteNumber(config.timeoutMs) : 0;
+    const timeoutMs = Math.max(0, Math.floor(rawTimeoutMs ?? 0));
+    return {
+      effectiveTimeoutSec: timeoutMs / 1000,
+      effectiveTimeoutMs: timeoutMs,
+      timeoutConfigured: timeoutMs > 0,
+      timeoutSource: hasTimeoutMs ? "config" : "default",
+    };
+  }
+
+  const hasTimeoutSec = hasOwn(config, "timeoutSec");
+  const defaultTimeoutSec = defaultTimeoutSecForAdapter(adapterType);
+  const rawTimeoutSec = hasTimeoutSec ? readFiniteNumber(config.timeoutSec) : defaultTimeoutSec;
+  const timeoutSec = Math.max(0, Math.floor(rawTimeoutSec ?? defaultTimeoutSec));
+
+  return {
+    effectiveTimeoutSec: timeoutSec,
+    timeoutConfigured: timeoutSec > 0,
+    timeoutSource: hasTimeoutSec ? "config" : "default",
+  };
+}
+
+export function inferHeartbeatRunStopReason(input: {
+  outcome: HeartbeatRunOutcome;
+  errorCode?: string | null;
+  errorMessage?: string | null;
+}): HeartbeatRunStopReason {
+  if (input.outcome === "succeeded") return "completed";
+  if (input.outcome === "timed_out") return "timeout";
+  if (input.outcome === "failed" && input.errorCode === "process_lost") return "process_lost";
+  if (input.outcome === "cancelled") {
+    const message = (input.errorMessage ?? "").toLowerCase();
+    if (message.includes("budget")) return "budget_paused";
+    if (message.includes("pause") || message.includes("paused")) return "paused";
+    return "cancelled";
+  }
+  return "adapter_failed";
+}
+
+export function buildHeartbeatRunStopMetadata(input: {
+  adapterType: string;
+  adapterConfig: Record<string, unknown> | null | undefined;
+  outcome: HeartbeatRunOutcome;
+  errorCode?: string | null;
+  errorMessage?: string | null;
+}): HeartbeatRunStopMetadata {
+  const timeoutPolicy = resolveHeartbeatRunTimeoutPolicy(input.adapterType, input.adapterConfig);
+  const stopReason = inferHeartbeatRunStopReason(input);
+  return {
+    ...timeoutPolicy,
+    stopReason,
+    timeoutFired: stopReason === "timeout",
+  };
+}
+
+export function mergeHeartbeatRunStopMetadata(
+  resultJson: Record<string, unknown> | null | undefined,
+  metadata: HeartbeatRunStopMetadata,
+): Record<string, unknown> {
+  return {
+    ...(resultJson ?? {}),
+    stopReason: metadata.stopReason,
+    effectiveTimeoutSec: metadata.effectiveTimeoutSec,
+    timeoutConfigured: metadata.timeoutConfigured,
+    timeoutSource: metadata.timeoutSource,
+    timeoutFired: metadata.timeoutFired,
+    ...(metadata.effectiveTimeoutMs != null ? { effectiveTimeoutMs: metadata.effectiveTimeoutMs } : {}),
+  };
+}