@bastani/atomic 0.9.13 → 0.9.14-alpha.1

package/dist/builtin/workflows/src/extension/index.bundle.mjs

@@ -53376,6 +53376,51 @@ function registerWorkflowLifecycleHandlers(pi, deps) {
   });
 }
 
+// dist/builtin/workflows/src/durable/workflow-heartbeat-anchor.ts
+var WORKFLOW_HEARTBEAT_ANCHOR_CHECKPOINT_NAME = "workflow-heartbeat-anchor";
+function asPersistedAnchorOutput(output) {
+  if (typeof output !== "object" || output === null || Array.isArray(output))
+    return;
+  const { anchorAt, intervalMinutes } = output;
+  return {
+    ...typeof anchorAt === "number" ? { anchorAt } : {},
+    ...typeof intervalMinutes === "number" ? { intervalMinutes } : {}
+  };
+}
+function readWorkflowHeartbeatAnchor(backend, workflowId) {
+  const record = asPersistedAnchorOutput(backend.getToolOutput(workflowId, WORKFLOW_HEARTBEAT_ANCHOR_CHECKPOINT_NAME));
+  if (record === undefined)
+    return;
+  const { anchorAt, intervalMinutes } = record;
+  if (anchorAt === undefined || !Number.isFinite(anchorAt))
+    return;
+  return intervalMinutes !== undefined && Number.isFinite(intervalMinutes) && intervalMinutes > 0 ? { anchorAt, intervalMinutes } : { anchorAt };
+}
+async function recordWorkflowHeartbeatAnchor(backend, record) {
+  if (!Number.isFinite(record.anchorAt))
+    return false;
+  if (!Number.isFinite(record.intervalMinutes) || record.intervalMinutes <= 0)
+    return false;
+  const existing = readWorkflowHeartbeatAnchor(backend, record.runId);
+  if (existing !== undefined)
+    return true;
+  if (backend.listCheckpoints(record.runId).length === 0)
+    return false;
+  const checkpoint = {
+    kind: "tool",
+    workflowId: record.runId,
+    checkpointId: WORKFLOW_HEARTBEAT_ANCHOR_CHECKPOINT_NAME,
+    name: WORKFLOW_HEARTBEAT_ANCHOR_CHECKPOINT_NAME,
+    argsHash: WORKFLOW_HEARTBEAT_ANCHOR_CHECKPOINT_NAME,
+    output: { anchorAt: record.anchorAt, intervalMinutes: record.intervalMinutes },
+    completedAt: record.now
+  };
+  const stored = await backend.recordAdditiveCheckpointBestEffort(checkpoint);
+  if (!stored)
+    return false;
+  return readWorkflowHeartbeatAnchor(backend, record.runId) !== undefined;
+}
+
 // dist/builtin/workflows/src/extension/config-loader.ts
 import { isAbsolute, join as join3 } from "node:path";
 import { CONFIG_DIR_NAME, CONFIG_DIR_NAMES, getAgentDir, getAgentDirs, getProjectConfigPaths } from "@bastani/atomic";
@@ -53684,6 +53729,10 @@ import { Type as Type2 } from "typebox";
 import { basename } from "node:path";
 import { fileURLToPath } from "node:url";
 
+// dist/builtin/workflows/src/shared/workflow-heartbeat-contract.ts
+var DEFAULT_WORKFLOW_HEARTBEAT_INTERVAL_MINUTES = 15;
+var WORKFLOW_HEARTBEAT_CUSTOM_TYPE = "workflows:workflow-heartbeat";
+
 // dist/builtin/workflows/src/workflows/identity.ts
 function normalizeWorkflowName(name) {
   if (!name || typeof name !== "string") {
@@ -53777,6 +53826,10 @@ function workflow(spec) {
   if (spec.inputs !== undefined && (spec.inputs === null || typeof spec.inputs !== "object" || Array.isArray(spec.inputs))) {
     throw new TypeError("workflow: inputs must be a schema map");
   }
+  const heartbeatIntervalMinutes = spec.heartbeatIntervalMinutes === undefined ? DEFAULT_WORKFLOW_HEARTBEAT_INTERVAL_MINUTES : spec.heartbeatIntervalMinutes;
+  if (!Number.isFinite(heartbeatIntervalMinutes) || heartbeatIntervalMinutes < 0) {
+    throw new TypeError("workflow: heartbeatIntervalMinutes must be a non-negative finite number");
+  }
   const name = resolveWorkflowName(spec.name);
   const normalizedName = normalizeWorkflowName(name);
   requireNonEmptyString(normalizedName, "normalized name");
@@ -53790,6 +53843,7 @@ function workflow(spec) {
     normalizedName,
     description: spec.description,
     ...spec.autoAttach === true ? { autoAttach: true } : {},
+    heartbeatIntervalMinutes,
     inputs: frozenInputs,
     outputs: frozenOutputs,
     ...inputBindings !== undefined ? { inputBindings } : {},
@@ -54184,6 +54238,7 @@ async function runAdversarialVerification(ctx) {
 var adversarial_verification_default = workflow({
   name: "adversarial-verification",
   description: "Produce a candidate, challenge it with fresh-context rubric-based verifiers, and reduce their evidence through a bounded repair loop.",
+  heartbeatIntervalMinutes: 15,
   inputs: {
     task: Type2.String({ description: "Task whose candidate result must be independently verified." }),
     verifier_count: Type2.Integer({ minimum: 1, maximum: 5, default: 3, description: "Number of independent verifiers per review round." }),
@@ -54337,6 +54392,7 @@ var DEFAULT_ACTION_CATEGORIES = ["analysis", "implementation", "research"];
 var classify_and_act_default = workflow({
   name: "classify-and-act",
   description: "Classify a task with structured confidence, route deterministically to an isolated category action, and ask for human selection when confidence is low.",
+  heartbeatIntervalMinutes: 15,
   inputs: {
     prompt: Type4.String({ description: "Task to classify and execute." }),
     categories: Type4.Array(Type4.String({ minLength: 1 }), {
@@ -54524,6 +54580,7 @@ async function runFanOutAndSynthesize(ctx) {
 var fan_out_and_synthesize_default = workflow({
   name: "fan-out-and-synthesize",
   description: "Partition a task, run bounded independent artifact branches, then synthesize all evidence at an explicit barrier.",
+  heartbeatIntervalMinutes: 15,
   inputs: {
     prompt: Type6.String({ description: "Task to partition, investigate, and synthesize." }),
     max_branches: Type6.Integer({
@@ -54745,6 +54802,7 @@ async function runGenerateAndFilter(ctx) {
 var generate_and_filter_default = workflow({
   name: "generate-and-filter",
   description: "Generate more independent candidates than needed, deduplicate and filter them by rubric, optionally judge them, and return a parent-consumable shortlist.",
+  heartbeatIntervalMinutes: 15,
   inputs: {
     prompt: Type8.String({ description: "Prompt for candidate generation and selection." }),
     num_candidates: Type8.Integer({ minimum: 2, maximum: 20, default: 8, description: "Number of independent candidates to generate." }),
@@ -56039,6 +56097,7 @@ async function runGoalWorkflow(ctx, options) {
 var goal_default = workflow({
   name: "goal",
   description: "Goal Runner workflow with bounded sub-agent orchestration turns, immutable acceptance criteria, ledger artifacts, parallel reviewers, and reducer-gated completion. When launching follow-up goal runs from review findings, pass the ORIGINAL task text as acceptance_criteria so deltas cannot drift from the literal contract. If the task includes submitting a pull request (or MR/review), remove that final action from the objective text and set create_pr=true instead when preparing the workflow inputs.",
+  heartbeatIntervalMinutes: 15,
   inputs: {
     objective: Type10.String({ description: "The objective or delta for this Goal Runner workflow run. Do not include PR/MR submission instructions here; strip them from the task text and request them via create_pr=true instead." }),
     acceptance_criteria: Type10.Optional(Type10.String({ description: "Original immutable task contract this run must remain consistent with. Defaults to objective. Orchestrators launching follow-up runs from reviewer findings should pass the ORIGINAL task text here." })),
@@ -57269,6 +57328,7 @@ async function runOpenClaudeDesignWorkflow(ctx) {
 var open_claude_design_default = workflow({
   name: "open-claude-design",
   description: "AI-powered design workflow: combined discovery/init → design-system/reference research → curated reference discovery → HTML generation → live-driven refinement → rich HTML handoff. The discovery stage asks what to build, the output type, and which references to emulate, then runs impeccable init for PRODUCT.md/DESIGN.md (references take precedence over project context). The user iteratively reviews the generated HTML.",
+  heartbeatIntervalMinutes: 0,
   inputs: {
     prompt: Type12.String({
       description: "What to design (for example, a dashboard, page, component, or prototype). The discovery stage refines this into a confirmed brief and asks for the output type and references."
@@ -57522,6 +57582,7 @@ async function runLoopUntilDone(ctx) {
 var loop_until_done_default = workflow({
   name: "loop-until-done",
   description: "Repeat evidence-producing work and independent completion evaluation against a durable ledger until done or an inspectable iteration-limit failure.",
+  heartbeatIntervalMinutes: 15,
   inputs: {
     prompt: Type14.String({ description: "Objective whose explicit completion condition controls the bounded loop." }),
     max_iterations: Type14.Integer({
@@ -58477,6 +58538,7 @@ Read it before implementation or delegation because it is the primary current im
 var ralph_default = workflow({
   name: "ralph",
   description: "Raw prompt → research-prompt-refinement → research → orchestrate → multi-model parallel review loop with bounded iteration and immutable acceptance criteria. When launching follow-up ralph runs from review findings, pass the ORIGINAL task text as acceptance_criteria so deltas cannot drift from the literal contract. If the task includes submitting a pull request (or MR/review), remove that final action from the prompt text and set create_pr=true instead when preparing the workflow inputs.",
+  heartbeatIntervalMinutes: 15,
   inputs: {
     prompt: Type16.String({ description: "The task or goal to research, execute, and refine. Do not include PR/MR submission instructions here; strip them from the task text and request them via create_pr=true instead." }),
     acceptance_criteria: Type16.Optional(Type16.String({ description: "Original immutable task contract this run must remain consistent with. Defaults to prompt. Orchestrators launching follow-up runs from reviewer findings should pass the ORIGINAL task text here." })),
@@ -58769,6 +58831,7 @@ async function runTournament(ctx) {
 var tournament_default = workflow({
   name: "tournament",
   description: "Run several independent whole-task attempts through a balanced pairwise judging bracket and return an auditable winner.",
+  heartbeatIntervalMinutes: 15,
   inputs: {
     prompt: Type18.String({ description: "Task every competing agent must attempt independently." }),
     num_attempts: Type18.Integer({
@@ -58880,11 +58943,13 @@ __export(exports_sdk_surface, {
   createRegistry: () => createRegistry,
   createCancellationRegistry: () => createCancellationRegistry,
   cancellationRegistry: () => cancellationRegistry,
+  WORKFLOW_HEARTBEAT_CUSTOM_TYPE: () => WORKFLOW_HEARTBEAT_CUSTOM_TYPE,
   NON_INTERACTIVE_WORKFLOW_POLICY: () => NON_INTERACTIVE_WORKFLOW_POLICY,
   KEEP_CONTEXT_OPEN_TAG: () => KEEP_CONTEXT_OPEN_TAG,
   KEEP_CONTEXT_CLOSE_TAG: () => KEEP_CONTEXT_CLOSE_TAG,
   INTERACTIVE_WORKFLOW_POLICY: () => INTERACTIVE_WORKFLOW_POLICY,
-  GraphFrontierTracker: () => GraphFrontierTracker
+  GraphFrontierTracker: () => GraphFrontierTracker,
+  DEFAULT_WORKFLOW_HEARTBEAT_INTERVAL_MINUTES: () => DEFAULT_WORKFLOW_HEARTBEAT_INTERVAL_MINUTES
 });
 
 // dist/builtin/workflows/src/engine/graph-inference.ts
@@ -64889,6 +64954,15 @@ function createDurableStageSessionRecorder(input) {
         await recordRunTimingCheckpointAsync(input.deps.backend, input.runSnapshot, {
           debounce: options?.forceDurable !== true
         });
+        const intervalMinutes = input.heartbeatIntervalMinutes;
+        if (Number.isFinite(intervalMinutes * 60000)) {
+          await recordWorkflowHeartbeatAnchor(input.deps.backend, {
+            runId: input.runId,
+            anchorAt: input.runSnapshot.startedAt,
+            intervalMinutes,
+            now: input.deps.now?.() ?? Date.now()
+          });
+        }
       }
     }
     await input.onStageSession?.(stageRunId, snapshot, options);
@@ -65509,6 +65583,9 @@ async function prepareRuntimeDurableResumable(getBackend, workflowId) {
 }
 
 // dist/builtin/workflows/src/durable/completed-catalog.ts
+function isReservedRunCheckpointHash(argsHash) {
+  return argsHash === RUN_TIMING_CHECKPOINT_NAME || argsHash === WORKFLOW_HEARTBEAT_ANCHOR_CHECKPOINT_NAME;
+}
 function listCompletedFromBackend(backend) {
   return backend.listCompletedWorkflows();
 }
@@ -65625,7 +65702,7 @@ function checkpointDrafts(checkpoints) {
       stageByReplayKey.set(checkpoint.replayKey, mergeStageDraft(existing2, checkpoint, sequence));
       return;
     }
-    if (checkpoint.kind !== "tool" || checkpoint.argsHash === RUN_TIMING_CHECKPOINT_NAME)
+    if (checkpoint.kind !== "tool" || isReservedRunCheckpointHash(checkpoint.argsHash))
       return;
     if (!firstToolSequenceByHash.has(checkpoint.argsHash)) {
       firstToolSequenceByHash.set(checkpoint.argsHash, sequence);
@@ -65736,7 +65813,7 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
     }
   }
   if (candidates.length === 0 && toolCheckpoints.length === 0) {
-    const supportedNonGraphState = checkpoints.every((checkpoint) => checkpoint.kind === "ui" || checkpoint.kind === "tool" && checkpoint.argsHash === RUN_TIMING_CHECKPOINT_NAME);
+    const supportedNonGraphState = checkpoints.every((checkpoint) => checkpoint.kind === "ui" || checkpoint.kind === "tool" && isReservedRunCheckpointHash(checkpoint.argsHash));
     if (policy.failClosed && supportedNonGraphState) {
       return [emptyGraphRun(rootRunId, rootRunName, fallbackCompletedAt)];
     }
@@ -70634,7 +70711,8 @@ async function run(def, inputs, opts = {}) {
     runId,
     deps: durableStageDeps,
     onStageSession: opts.onStageSession,
-    ...opts.parentRun === undefined ? { runSnapshot } : {}
+    ...opts.parentRun === undefined ? { runSnapshot } : {},
+    heartbeatIntervalMinutes: def.heartbeatIntervalMinutes
   });
   const stageOptions = {
     continuation: opts.continuation,
@@ -72299,6 +72377,628 @@ function createStatusWriter(store2, config, opts = {}) {
   };
 }
 
+// dist/builtin/workflows/src/extension/workflow-heartbeat-notice.ts
+var WORKFLOW_HEARTBEAT_TITLE = "WORKFLOW HEARTBEAT";
+var WORKFLOW_HEARTBEAT_GLYPH = "♥";
+var rendererRegisteredHosts5 = new WeakSet;
+function formatWorkflowHeartbeatNoticeText(details) {
+  const workflowName = escapeQuotedText3(details.workflowName);
+  const elapsed = formatWorkflowHeartbeatElapsed(details);
+  const cadence = formatWorkflowHeartbeatCadence(details.intervalMinutes);
+  return `${WORKFLOW_HEARTBEAT_GLYPH} Workflow "${workflowName}" heartbeat (run ${details.runId}) — still running` + `${elapsed === undefined ? "" : ` after ${elapsed}`}, on a ${cadence} cadence. ` + "This is a periodic alignment check, not a failure. Review whether the run is still on goal, then " + "continue, steer it, stop and replace it, or ask the user. " + `Inspect: /workflow status ${details.runId}`;
+}
+function registerWorkflowHeartbeatRenderer(options) {
+  const register = options.registerMessageRenderer;
+  if (typeof register !== "function")
+    return;
+  const host = options.rendererHost ?? register;
+  if (rendererRegisteredHosts5.has(host))
+    return;
+  const renderer = (raw, _options, piTheme) => {
+    const message = raw;
+    if (!message.details)
+      return;
+    return makeWorkflowHeartbeatComponent(message.details, themeFromRenderer3(piTheme));
+  };
+  register(WORKFLOW_HEARTBEAT_CUSTOM_TYPE, renderer);
+  rendererRegisteredHosts5.add(host);
+}
+function makeWorkflowHeartbeatComponent(details, theme) {
+  const text = formatWorkflowHeartbeatNoticeText(details);
+  return {
+    render(width) {
+      return renderWorkflowHeartbeatCard(details, { width, theme, fallbackText: text });
+    },
+    invalidate() {}
+  };
+}
+function renderWorkflowHeartbeatCard(details, opts) {
+  return renderWorkflowNoticeCard({
+    title: WORKFLOW_HEARTBEAT_TITLE,
+    glyph: WORKFLOW_HEARTBEAT_GLYPH,
+    headline: `Workflow "${details.workflowName}" is still running`,
+    tone: "mauve",
+    fields: [
+      { label: "workflow", value: details.workflowName },
+      { label: "run", value: details.runId },
+      { label: "cadence", value: formatWorkflowHeartbeatCadence(details.intervalMinutes), tone: "muted" },
+      { label: "elapsed", value: formatWorkflowHeartbeatElapsed(details), tone: "muted" }
+    ],
+    hints: [`/workflow status ${details.runId}`],
+    fallbackText: opts.fallbackText,
+    width: opts.width,
+    ...opts.theme ? { theme: opts.theme } : {}
+  });
+}
+function formatWorkflowHeartbeatCadence(intervalMinutes) {
+  return `${intervalMinutes}-minute`;
+}
+function formatWorkflowHeartbeatElapsed(details) {
+  const elapsedMs = details.scheduledAt - details.startedAt;
+  if (!Number.isFinite(elapsedMs) || elapsedMs < 0)
+    return;
+  const totalMinutes = Math.floor(elapsedMs / 60000);
+  if (totalMinutes < 1)
+    return `${Math.max(0, Math.floor(elapsedMs / 1000))}s`;
+  if (totalMinutes < 60)
+    return `${totalMinutes}m`;
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  return minutes === 0 ? `${hours}h` : `${hours}h ${minutes}m`;
+}
+function escapeQuotedText3(value2) {
+  return value2.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+function themeFromRenderer3(piTheme) {
+  return piTheme === undefined ? undefined : deriveGraphThemeFromPiTheme(piTheme);
+}
+
+// dist/builtin/workflows/src/extension/workflow-heartbeat-delivery.ts
+var defaultWorkflowHeartbeatTimerApi = {
+  setTimeout: (handler, delayMs) => setTimeout(handler, delayMs),
+  clearTimeout: (handle) => clearTimeout(handle)
+};
+var WORKFLOW_HEARTBEAT_MAX_DELIVERY_ATTEMPTS = 5;
+function createWorkflowHeartbeatDelivery(options) {
+  const retryTimers = new Set;
+  const queue = [];
+  let attempt = 0;
+  let running = false;
+  let active2 = true;
+  let headDiscarded = false;
+  const settleHead = (details, delivered) => {
+    queue.shift();
+    attempt = 0;
+    running = false;
+    headDiscarded = false;
+    options.onSettled(details, delivered);
+    runHead();
+  };
+  const runHead = () => {
+    if (!active2 || running || retryTimers.size > 0)
+      return;
+    const details = queue[0];
+    if (details === undefined)
+      return;
+    if (options.canDeliver !== undefined && !options.canDeliver(details)) {
+      settleHead(details, false);
+      return;
+    }
+    running = true;
+    attempt += 1;
+    const thisAttempt = attempt;
+    const settle = (delivered) => {
+      if (delivered || headDiscarded || thisAttempt >= WORKFLOW_HEARTBEAT_MAX_DELIVERY_ATTEMPTS || !active2) {
+        settleHead(details, delivered);
+        return;
+      }
+      running = false;
+      const handle = options.timers.setTimeout(() => {
+        retryTimers.delete(handle);
+        runHead();
+      }, Math.min(20 * 2 ** (thisAttempt - 1), 1000));
+      handle.unref?.();
+      retryTimers.add(handle);
+    };
+    const result = options.emit(details);
+    if (typeof result === "boolean")
+      settle(result);
+    else
+      result.then(settle);
+  };
+  const deliver = (details) => {
+    if (!active2)
+      return;
+    queue.push(details);
+    runHead();
+  };
+  const discard = (runId) => {
+    const head = queue[0];
+    const headInFlight = running && head !== undefined && head.runId === runId;
+    let discarded = false;
+    for (let index = queue.length - 1;index >= 0; index -= 1) {
+      if (queue[index]?.runId !== runId)
+        continue;
+      if (index === 0 && headInFlight) {
+        headDiscarded = true;
+        continue;
+      }
+      queue.splice(index, 1);
+      discarded = true;
+      if (index > 0)
+        continue;
+      attempt = 0;
+      running = false;
+      for (const handle of retryTimers)
+        options.timers.clearTimeout(handle);
+      retryTimers.clear();
+    }
+    if (discarded)
+      runHead();
+    return discarded;
+  };
+  return {
+    deliver,
+    discard,
+    dispose() {
+      active2 = false;
+      for (const handle of retryTimers)
+        options.timers.clearTimeout(handle);
+      retryTimers.clear();
+      queue.length = 0;
+    }
+  };
+}
+
+// dist/builtin/workflows/src/extension/workflow-heartbeat-scheduler.ts
+var MAX_TIMER_DELAY_MS = 2147483647;
+var MS_PER_MINUTE = 60000;
+function createWorkflowHeartbeatSchedulerState() {
+  return {
+    scheduled: new Map,
+    pending: new Map,
+    awaitingParentPickup: new Map,
+    lastEnqueuedAt: new Map,
+    anchorAt: new Map,
+    anchorPersisted: new Set,
+    anchorWritesPending: new Set,
+    intervalMinutes: new Map
+  };
+}
+function resetWorkflowHeartbeatSchedulerState(state2) {
+  state2.scheduled.clear();
+  state2.pending.clear();
+  state2.awaitingParentPickup.clear();
+  state2.lastEnqueuedAt.clear();
+  state2.anchorAt.clear();
+  state2.anchorPersisted.clear();
+  state2.anchorWritesPending.clear();
+  state2.intervalMinutes.clear();
+}
+var MAX_REPRESENTABLE_WORKFLOW_HEARTBEAT_INTERVAL_MINUTES = Number.MAX_VALUE / MS_PER_MINUTE;
+function nextWorkflowHeartbeatBoundary(startedAt, intervalMinutes, after) {
+  if (!Number.isFinite(intervalMinutes) || intervalMinutes <= 0)
+    return;
+  if (!Number.isFinite(startedAt) || !Number.isFinite(after))
+    return;
+  const intervalMs = intervalMinutes * MS_PER_MINUTE;
+  if (!Number.isFinite(intervalMs) || intervalMs <= 0) {
+    warnWorkflowHeartbeatUnschedulableInterval(intervalMinutes);
+    return;
+  }
+  const boundaryAt = (n) => startedAt + n * intervalMs;
+  const elapsed = after - startedAt;
+  const estimate = elapsed < 0 ? 1 : Math.floor(elapsed / intervalMs) + 1;
+  if (!Number.isFinite(estimate))
+    return;
+  if (boundaryAt(estimate) > after)
+    return finiteBoundaryAfter(boundaryAt(estimate), after);
+  if (boundaryAt(estimate + 1) > after)
+    return finiteBoundaryAfter(boundaryAt(estimate + 1), after);
+  let low = estimate + 1;
+  let high = low;
+  while (boundaryAt(high) <= after) {
+    low = high;
+    high *= 2;
+    if (!Number.isFinite(high))
+      return nextRepresentableAfter(after);
+  }
+  while (high - low > 1) {
+    const mid = Math.floor(low / 2 + high / 2);
+    if (mid <= low || mid >= high)
+      break;
+    if (boundaryAt(mid) > after)
+      high = mid;
+    else
+      low = mid;
+  }
+  return finiteBoundaryAfter(boundaryAt(high), after);
+}
+function finiteBoundaryAfter(scheduledAt, after) {
+  return Number.isFinite(scheduledAt) && scheduledAt > after ? scheduledAt : undefined;
+}
+function nextRepresentableAfter(at) {
+  if (!Number.isFinite(at))
+    return;
+  const view = new DataView(new ArrayBuffer(8));
+  view.setFloat64(0, at);
+  const bits = view.getBigUint64(0);
+  view.setBigUint64(0, at >= 0 ? bits + 1n : bits - 1n);
+  const next = view.getFloat64(0);
+  return Number.isFinite(next) && next > at ? next : undefined;
+}
+function isWorkflowHeartbeatEligibleRun(run2) {
+  if (!isTopLevelWorkflowRun(run2))
+    return false;
+  if (run2.status !== "running")
+    return false;
+  if (run2.pausedAt !== undefined)
+    return false;
+  return !isTerminalRunStatus(effectiveRunStatus(run2));
+}
+function isWorkflowHeartbeatTerminalRun(run2) {
+  return isTerminalRunStatus(run2.status);
+}
+function installWorkflowHeartbeatScheduler(options) {
+  const state2 = options.state ?? createWorkflowHeartbeatSchedulerState();
+  const now = options.now ?? Date.now;
+  const timers = options.timers ?? defaultWorkflowHeartbeatTimerApi;
+  const send = options.sendMessage;
+  const parentAvailabilityReported = options.parentAvailabilityReported === true;
+  const anchorStore = options.anchorStore;
+  let active2 = true;
+  let timerHandle;
+  const emit = (details) => {
+    if (typeof send !== "function")
+      return false;
+    try {
+      const result = send({
+        customType: WORKFLOW_HEARTBEAT_CUSTOM_TYPE,
+        content: formatWorkflowHeartbeatNoticeText(details),
+        display: true,
+        details
+      }, { triggerTurn: true, deliverAs: "steer", persistWhenStreaming: true });
+      if (result === undefined)
+        return true;
+      return Promise.resolve(result).then(() => true, (error) => {
+        warnWorkflowHeartbeatSendFailure(error);
+        return false;
+      });
+    } catch (error) {
+      warnWorkflowHeartbeatSendFailure(error);
+      return false;
+    }
+  };
+  const canDeliverWorkflowHeartbeat = (details) => {
+    const run2 = findRun(readGraphStoreSnapshot(options.store), details.runId);
+    return run2 !== undefined && isWorkflowHeartbeatEligibleRun(run2);
+  };
+  const delivery = createWorkflowHeartbeatDelivery({
+    emit,
+    timers,
+    canDeliver: canDeliverWorkflowHeartbeat,
+    onSettled: (details, delivered) => {
+      const identity = state2.pending.get(details.runId);
+      if (identity?.scheduledAt !== details.scheduledAt)
+        return;
+      if (!delivered) {
+        state2.pending.delete(details.runId);
+        state2.awaitingParentPickup.delete(details.runId);
+        refresh();
+        return;
+      }
+      if (!parentAvailabilityReported) {
+        state2.pending.delete(details.runId);
+        refresh();
+        return;
+      }
+      state2.awaitingParentPickup.set(details.runId, identity);
+      refresh();
+    }
+  });
+  const clearRunHeartbeatState = (runId) => {
+    let cleared = state2.scheduled.delete(runId);
+    cleared = state2.pending.delete(runId) || cleared;
+    cleared = state2.awaitingParentPickup.delete(runId) || cleared;
+    cleared = state2.lastEnqueuedAt.delete(runId) || cleared;
+    cleared = state2.anchorAt.delete(runId) || cleared;
+    cleared = state2.anchorPersisted.delete(runId) || cleared;
+    cleared = state2.anchorWritesPending.delete(runId) || cleared;
+    cleared = state2.intervalMinutes.delete(runId) || cleared;
+    return delivery.discard(runId) || cleared;
+  };
+  const clearWorkflowHeartbeats = (runId) => {
+    if (!clearRunHeartbeatState(runId))
+      return { kind: "already-clear" };
+    arm();
+    return { kind: "cleared" };
+  };
+  const notifyHeartbeatConsumed = (identity) => {
+    if (!active2)
+      return;
+    const held = state2.awaitingParentPickup.get(identity.runId);
+    const pending = state2.pending.get(identity.runId);
+    if (held?.scheduledAt !== identity.scheduledAt || pending?.scheduledAt !== identity.scheduledAt)
+      return;
+    state2.awaitingParentPickup.delete(identity.runId);
+    state2.pending.delete(identity.runId);
+    refresh();
+  };
+  const scheduleWorkflowHeartbeats = (run2, intervalMinutes) => {
+    state2.scheduled.delete(run2.id);
+    if (intervalMinutes <= 0)
+      return { kind: "disabled" };
+    if (run2.status !== "running")
+      return { kind: "disabled" };
+    const floor = Math.max(now(), state2.lastEnqueuedAt.get(run2.id) ?? Number.NEGATIVE_INFINITY);
+    const anchorAt = resolveAnchorAt(run2);
+    const scheduledAt = nextWorkflowHeartbeatBoundary(anchorAt, intervalMinutes, floor);
+    if (scheduledAt === undefined)
+      return { kind: "disabled" };
+    persistLaunchRecordOnce(run2.id, anchorAt, intervalMinutes);
+    state2.scheduled.set(run2.id, {
+      runId: run2.id,
+      scheduledAt,
+      workflowName: run2.name,
+      startedAt: anchorAt,
+      intervalMinutes
+    });
+    return { kind: "scheduled", scheduledAt };
+  };
+  const enqueueWorkflowHeartbeat = (payload) => {
+    if (!active2 || typeof send !== "function")
+      return { kind: "suppressed", reason: "unavailable" };
+    const run2 = findRun(readGraphStoreSnapshot(options.store), payload.runId);
+    if (run2 === undefined)
+      return { kind: "suppressed", reason: "missing" };
+    if (isTerminalRunStatus(effectiveRunStatus(run2)))
+      return { kind: "suppressed", reason: "terminal" };
+    if (!isWorkflowHeartbeatEligibleRun(run2))
+      return { kind: "suppressed", reason: "paused" };
+    if (state2.pending.has(payload.runId))
+      return { kind: "suppressed", reason: "duplicate" };
+    if ((state2.lastEnqueuedAt.get(payload.runId) ?? Number.NEGATIVE_INFINITY) >= payload.scheduledAt) {
+      return { kind: "suppressed", reason: "duplicate" };
+    }
+    const identity = { runId: payload.runId, scheduledAt: payload.scheduledAt };
+    state2.pending.set(payload.runId, identity);
+    state2.lastEnqueuedAt.set(payload.runId, payload.scheduledAt);
+    delivery.deliver(payload);
+    return { kind: "enqueued", identity };
+  };
+  const arm = () => {
+    if (timerHandle !== undefined) {
+      timers.clearTimeout(timerHandle);
+      timerHandle = undefined;
+    }
+    if (!active2)
+      return;
+    const next = earliestScheduled(state2);
+    if (next === undefined)
+      return;
+    const nextAt = next.scheduledAt;
+    const delay2 = Math.min(Math.max(1, Math.ceil(nextAt - now())), MAX_TIMER_DELAY_MS);
+    const handle = timers.setTimeout(() => {
+      timerHandle = undefined;
+      processDue();
+    }, delay2);
+    handle.unref?.();
+    timerHandle = handle;
+  };
+  const refresh = () => {
+    if (!active2 || typeof send !== "function")
+      return;
+    const snapshot = readGraphStoreSnapshot(options.store);
+    const observed = new Set;
+    for (const run2 of snapshot.runs) {
+      if (!isTopLevelWorkflowRun(run2))
+        continue;
+      if (isWorkflowHeartbeatTerminalRun(run2)) {
+        clearWorkflowHeartbeats(run2.id);
+        continue;
+      }
+      observed.add(run2.id);
+      if (state2.pending.has(run2.id) || !isWorkflowHeartbeatEligibleRun(run2)) {
+        state2.scheduled.delete(run2.id);
+        continue;
+      }
+      const owed = state2.scheduled.get(run2.id);
+      if (owed !== undefined && owed.scheduledAt <= now())
+        continue;
+      const launched = readLaunchRecord(run2.id);
+      const intervalMinutes = resolveRunIntervalMinutes(state2, options.resolveIntervalMinutes, run2, launched?.intervalMinutes);
+      if (intervalMinutes === undefined) {
+        state2.scheduled.delete(run2.id);
+        continue;
+      }
+      scheduleWorkflowHeartbeats(run2, intervalMinutes);
+    }
+    for (const runId of trackedRunIds(state2)) {
+      if (!observed.has(runId))
+        clearWorkflowHeartbeats(runId);
+    }
+    arm();
+  };
+  function readLaunchRecord(runId) {
+    try {
+      return anchorStore?.readAnchorAt(runId);
+    } catch {
+      return;
+    }
+  }
+  function resolveAnchorAt(run2) {
+    const cached = state2.anchorAt.get(run2.id);
+    if (cached !== undefined)
+      return Math.min(cached, run2.startedAt);
+    const stored = readLaunchRecord(run2.id)?.anchorAt;
+    const anchorAt = stored === undefined ? run2.startedAt : Math.min(stored, run2.startedAt);
+    state2.anchorAt.set(run2.id, anchorAt);
+    return anchorAt;
+  }
+  function persistLaunchRecordOnce(runId, anchorAt, intervalMinutes) {
+    if (anchorStore === undefined)
+      return;
+    if (state2.anchorPersisted.has(runId) || state2.anchorWritesPending.has(runId))
+      return;
+    state2.anchorWritesPending.add(runId);
+    let write;
+    try {
+      write = Promise.resolve(anchorStore.recordAnchorAt(runId, { anchorAt, intervalMinutes }));
+    } catch {
+      state2.anchorWritesPending.delete(runId);
+      return;
+    }
+    write.then((acknowledged) => {
+      const tracked2 = state2.anchorWritesPending.delete(runId);
+      if (acknowledged && tracked2)
+        state2.anchorPersisted.add(runId);
+    }, () => {
+      state2.anchorWritesPending.delete(runId);
+    });
+  }
+  const processDue = () => {
+    if (!active2)
+      return;
+    const at = now();
+    const due = [...state2.scheduled.values()].filter((details) => details.scheduledAt <= at).sort(compareWorkflowHeartbeatOrder);
+    const snapshot = readGraphStoreSnapshot(options.store);
+    for (const details of due) {
+      state2.scheduled.delete(details.runId);
+      const run2 = findRun(snapshot, details.runId);
+      if (run2 === undefined || !isWorkflowHeartbeatEligibleRun(run2))
+        continue;
+      enqueueWorkflowHeartbeat(details);
+    }
+    refresh();
+  };
+  const unsubscribe = subscribeStoreInvalidation(options.store, refresh);
+  refresh();
+  return {
+    scheduleWorkflowHeartbeats,
+    enqueueWorkflowHeartbeat,
+    clearWorkflowHeartbeats,
+    notifyHeartbeatConsumed,
+    state: state2,
+    dispose() {
+      active2 = false;
+      unsubscribe();
+      if (timerHandle !== undefined) {
+        timers.clearTimeout(timerHandle);
+        timerHandle = undefined;
+      }
+      state2.scheduled.clear();
+      delivery.dispose();
+    }
+  };
+}
+function compareWorkflowHeartbeatOrder(a, b) {
+  if (a.scheduledAt !== b.scheduledAt)
+    return a.scheduledAt - b.scheduledAt;
+  if (a.runId === b.runId)
+    return 0;
+  return a.runId < b.runId ? -1 : 1;
+}
+function earliestScheduled(state2) {
+  let earliest;
+  for (const details of state2.scheduled.values()) {
+    if (earliest === undefined || compareWorkflowHeartbeatOrder(details, earliest) < 0)
+      earliest = details;
+  }
+  return earliest;
+}
+function trackedRunIds(state2) {
+  const ids = new Set([
+    ...state2.scheduled.keys(),
+    ...state2.pending.keys(),
+    ...state2.awaitingParentPickup.keys(),
+    ...state2.lastEnqueuedAt.keys(),
+    ...state2.anchorAt.keys(),
+    ...state2.anchorPersisted,
+    ...state2.anchorWritesPending,
+    ...state2.intervalMinutes.keys()
+  ]);
+  return [...ids];
+}
+function resolveRunIntervalMinutes(state2, resolve14, run2, persistedIntervalMinutes) {
+  const memoized = state2.intervalMinutes.get(run2.id);
+  if (memoized !== undefined)
+    return memoized > 0 ? memoized : undefined;
+  const resolved = persistedIntervalMinutes ?? resolve14(run2.name);
+  if (resolved === undefined || !Number.isFinite(resolved))
+    return;
+  state2.intervalMinutes.set(run2.id, resolved);
+  return resolved > 0 ? resolved : undefined;
+}
+function findRun(snapshot, runId) {
+  return snapshot.runs.find((run2) => run2.id === runId);
+}
+function warnWorkflowHeartbeatSendFailure(error) {
+  if (process.env.ATOMIC_WORKFLOW_DEBUG !== "1")
+    return;
+  const message = error instanceof Error ? error.message : String(error);
+  console.warn("[workflows] workflow heartbeat send failed", message);
+}
+function warnWorkflowHeartbeatUnschedulableInterval(intervalMinutes) {
+  if (process.env.ATOMIC_WORKFLOW_DEBUG !== "1")
+    return;
+  console.warn(`[workflows] heartbeatIntervalMinutes ${intervalMinutes} exceeds the largest representable cadence ` + `(${MAX_REPRESENTABLE_WORKFLOW_HEARTBEAT_INTERVAL_MINUTES} minutes); no boundary can be scheduled for it`);
+}
+function isRecord4(value2) {
+  return typeof value2 === "object" && value2 !== null;
+}
+function asHostMessageEndEvent(event) {
+  if (!isRecord4(event))
+    return;
+  const message = event.message;
+  if (!isRecord4(message))
+    return;
+  const { role, customType, details } = message;
+  if (typeof role !== "string")
+    return;
+  return {
+    message: {
+      role,
+      ...typeof customType === "string" ? { customType } : {},
+      ...isRecord4(details) ? { details } : {},
+      raw: message
+    }
+  };
+}
+var PROTECTED_RECONCILIATION_CUSTOM_TYPE = "atomic:protected-streaming-reconciliation";
+function workflowHeartbeatConsumedIdentity(event, entries) {
+  if (entries === undefined)
+    return;
+  const parsed = asHostMessageEndEvent(event);
+  if (parsed === undefined)
+    return;
+  const { role, customType, details } = parsed.message;
+  if (role !== "custom" || customType !== PROTECTED_RECONCILIATION_CUSTOM_TYPE)
+    return;
+  if (details === undefined)
+    return;
+  const intentEntryId = details.protectedReconciliationOf;
+  if (typeof intentEntryId !== "string")
+    return;
+  const intent = entries.find((entry) => entry.id === intentEntryId);
+  if (intent?.customType !== WORKFLOW_HEARTBEAT_CUSTOM_TYPE)
+    return;
+  if (!isRecord4(intent.details))
+    return;
+  const { runId, scheduledAt } = intent.details;
+  if (typeof runId !== "string" || typeof scheduledAt !== "number")
+    return;
+  return { runId, scheduledAt };
+}
+function workflowHeartbeatContextInvalidation(event, entries, isIdentityOwned) {
+  const identity = workflowHeartbeatConsumedIdentity(event, entries);
+  if (identity === undefined || isIdentityOwned(identity))
+    return;
+  const parsed = asHostMessageEndEvent(event);
+  if (parsed === undefined)
+    return;
+  return { message: { ...parsed.message.raw, excludeFromContext: true } };
+}
+
 // dist/builtin/workflows/src/extension/workflow-model-catalog.ts
 function workflowModelCatalogFromContext(ctx) {
   if (ctx?.modelRegistry === undefined && ctx?.model === undefined)
@@ -72463,6 +73163,29 @@ function workflowReloadDiagnostics(configDiagnostics, discoveryDiagnostics) {
 }
 
 // dist/builtin/workflows/src/extension/extension-runtime-state.ts
+function durableWorkflowHeartbeatAnchorStore() {
+  return {
+    readAnchorAt(runId) {
+      try {
+        return readWorkflowHeartbeatAnchor(getDurableBackend(), runId);
+      } catch {
+        return;
+      }
+    },
+    async recordAnchorAt(runId, record) {
+      try {
+        return await recordWorkflowHeartbeatAnchor(getDurableBackend(), {
+          runId,
+          anchorAt: record.anchorAt,
+          intervalMinutes: record.intervalMinutes ?? 0,
+          now: Date.now()
+        });
+      } catch {
+        return false;
+      }
+    }
+  };
+}
 function createWorkflowExtensionRuntimeState(pi, adapters, resolveCwd = () => pi.sessionManager?.getCwd?.() ?? process.cwd()) {
   const persistenceRef = { current: makePersistencePort(pi, WORKFLOW_CONFIG_DEFAULTS.persistRuns) };
   const mcpPort = makeMcpPort(pi);
@@ -72479,10 +73202,12 @@ function createWorkflowExtensionRuntimeState(pi, adapters, resolveCwd = () => pi
   let statusWriterRef = createStatusWriter(store, runtimeConfigRef.current);
   let lifecycleNotificationsUnsubscribe = null;
   let hilAnswerNotificationsUnsubscribe = null;
+  let workflowHeartbeatScheduler = null;
   let notificationsActive = false;
   let notificationGeneration = 0;
   const lifecycleNotificationState = createWorkflowLifecycleNotificationState();
   const hilAnswerNotificationState = createWorkflowHilAnswerNotificationState();
+  const workflowHeartbeatSchedulerState = createWorkflowHeartbeatSchedulerState();
   const beforeRestoreCompleted = (snapshots) => {
     seedWorkflowLifecycleNotificationState(lifecycleNotificationState, {
       ...readGraphStoreSnapshot(store),
@@ -72495,6 +73220,7 @@ function createWorkflowExtensionRuntimeState(pi, adapters, resolveCwd = () => pi
   const registerMessageRenderer = typeof pi.registerMessageRenderer === "function" ? (event, renderer) => pi.registerMessageRenderer(event, renderer) : undefined;
   registerLifecycleNoticeRenderer({ rendererHost: pi, registerMessageRenderer });
   registerHilAnswerNoticeRenderer({ rendererHost: pi, registerMessageRenderer });
+  registerWorkflowHeartbeatRenderer({ rendererHost: pi, registerMessageRenderer });
   const sendWorkflowNotificationMessage = typeof pi.sendMessage === "function" ? (message, options) => pi.sendMessage(message, options) : undefined;
   const reinstallLifecycleNotifications = () => {
     lifecycleNotificationsUnsubscribe?.();
@@ -72521,6 +73247,38 @@ function createWorkflowExtensionRuntimeState(pi, adapters, resolveCwd = () => pi
       sendMessage: sendWorkflowNotificationMessage
     });
   };
+  const parentAvailabilityReported = typeof pi.on === "function";
+  if (parentAvailabilityReported) {
+    pi.on?.("message_end", (event, ctx) => {
+      const entries = (ctx?.sessionManager ?? pi.sessionManager)?.getEntries?.();
+      const invalidation = workflowHeartbeatContextInvalidation(event, entries, isWorkflowHeartbeatIdentityOwned);
+      if (invalidation !== undefined)
+        return invalidation;
+      const identity = workflowHeartbeatConsumedIdentity(event, entries);
+      if (identity !== undefined)
+        workflowHeartbeatScheduler?.notifyHeartbeatConsumed(identity);
+      return;
+    });
+  }
+  function isWorkflowHeartbeatIdentityOwned(identity) {
+    const pending = workflowHeartbeatSchedulerState.pending.get(identity.runId);
+    const run2 = store.runs().find((candidate) => candidate.id === identity.runId);
+    return pending?.scheduledAt === identity.scheduledAt && run2 !== undefined && !isWorkflowHeartbeatTerminalRun(run2);
+  }
+  const reinstallWorkflowHeartbeatScheduler = () => {
+    workflowHeartbeatScheduler?.dispose();
+    workflowHeartbeatScheduler = null;
+    if (!notificationsActive)
+      return;
+    workflowHeartbeatScheduler = installWorkflowHeartbeatScheduler({
+      store,
+      state: workflowHeartbeatSchedulerState,
+      sendMessage: sendWorkflowNotificationMessage,
+      resolveIntervalMinutes: (workflowName) => runtimeProxy.registry.get(workflowName)?.heartbeatIntervalMinutes,
+      parentAvailabilityReported,
+      anchorStore: durableWorkflowHeartbeatAnchorStore()
+    });
+  };
   const hostStageSessionDir = { current: undefined };
   const resolveDefaultStageSessionDir = () => hostStageSessionDir.current;
   const startupDiscovery = discoverStartupWorkflowsSync();
@@ -72789,6 +73547,7 @@ function createWorkflowExtensionRuntimeState(pi, adapters, resolveCwd = () => pi
     discoveryRef,
     lifecycleNotificationState,
     hilAnswerNotificationState,
+    workflowHeartbeatSchedulerState,
     beforeRestoreCompleted,
     runtimeForContext,
     resetWorkflowDiscoveryForSession,
@@ -72804,6 +73563,9 @@ function createWorkflowExtensionRuntimeState(pi, adapters, resolveCwd = () => pi
       notificationsActive = active2;
       reinstallLifecycleNotifications();
       reinstallHilAnswerNotifications();
+      if (!active2)
+        resetWorkflowHeartbeatSchedulerState(workflowHeartbeatSchedulerState);
+      reinstallWorkflowHeartbeatScheduler();
     },
     updateHostStageSessionDir(sessionManager) {
       try {