} from "../agents/agent-scope.js";

import { appendCronStyleCurrentTimeLine } from "../agents/current-time.js";

import { resolveEmbeddedSessionLane } from "../agents/embedded-agent-runner/lanes.js";

import { listActiveEmbeddedRunSessionKeys } from "../agents/embedded-agent-runner/run-state.js";

import { formatReasoningMessage } from "../agents/embedded-agent-utils.js";

import { resolveAgentHarnessPolicy } from "../agents/harness/policy.js";

import { resolveModelRefFromString, type ModelRef } from "../agents/model-selection.js";

} from "../auto-reply/heartbeat.js";

import { replaceGenericExternalRunFailureText } from "../auto-reply/reply/agent-runner-failure-copy.js";

import { resolveDefaultModel } from "../auto-reply/reply/directive-handling.defaults.js";

import {

REPLY_OPERATION_RUN_STATE,

type ReplyOperationRunState,

} from "../auto-reply/reply/reply-operation-run-state.js";

import {

listActiveReplyRunSessionKeys,

replyRunRegistry,

getCommandLaneSnapshots?: () => readonly CommandLaneSnapshot[];

isReplyRunActive?: (sessionKey: string) => boolean;

listActiveReplyRunSessionKeys?: () => readonly string[];

listActiveEmbeddedRunSessionKeys?: () => readonly string[];

nowMs?: () => number;

};

return hasQueuedWorkInLaneSnapshots(getSnapshots(), (lane) => laneBelongsToAgent(lane, agentId));

}

function hasActiveReplyRunForAgent(

agentId: string,

listSessionKeys: () => readonly string[],

): boolean {

function hasActiveRunForAgent(agentId: string, listSessionKeys: () => readonly string[]): boolean {

const normalizedAgentId = normalizeAgentId(agentId);

return listSessionKeys().some((sessionKey) => {

const parsed = parseAgentSessionKey(sessionKey);

return parsed ? normalizeAgentId(parsed.agentId) === normalizedAgentId : false;

});

}

function hasActiveRunForSession(

sessionKey: string,

listSessionKeys: () => readonly string[],

): boolean {

const normalizedSessionKey = sessionKey.trim();

return Boolean(normalizedSessionKey) && listSessionKeys().includes(normalizedSessionKey);

}

function resolveHeartbeatChannelPlugin(channel: string): ChannelPlugin | undefined {

const activePlugin = getActivePluginChannelRegistry()?.channels.find(

(entry) => entry.plugin.id === channel,

const shouldHonorActiveReplyRuns = opts.intent !== "immediate" && opts.intent !== "manual";

const listActiveReplyRuns =

opts.deps?.listActiveReplyRunSessionKeys ?? listActiveReplyRunSessionKeys;

const listActiveEmbeddedRuns =

opts.deps?.listActiveEmbeddedRunSessionKeys ?? listActiveEmbeddedRunSessionKeys;

// Scheduled heartbeats are background work, so defer them when any session on

// the same agent is already replying; immediate/manual wakes keep their

// existing semantics for explicit user/system actions.

if (shouldHonorActiveReplyRuns && hasActiveReplyRunForAgent(agentId, listActiveReplyRuns)) {

if (

shouldHonorActiveReplyRuns &&

(hasActiveRunForAgent(agentId, listActiveReplyRuns) ||

hasActiveRunForAgent(agentId, listActiveEmbeddedRuns))

) {

emitHeartbeatEvent({

status: "skipped",

reason: HEARTBEAT_SKIP_REQUESTS_IN_FLIGHT,

const { entry, sessionKey, storePath, suppressOriginatingContext } = preflight.session;

const isReplyRunActive =

opts.deps?.isReplyRunActive ?? ((key: string) => replyRunRegistry.isActive(key));

if (isReplyRunActive(sessionKey)) {

if (isReplyRunActive(sessionKey) || hasActiveRunForSession(sessionKey, listActiveEmbeddedRuns)) {

emitHeartbeatEvent({

status: "skipped",

reason: HEARTBEAT_SKIP_REQUESTS_IN_FLIGHT,

isolatedSessionKey,

isolatedBaseSessionKey,

});

if (isReplyRunActive(isolatedSessionKey)) {

if (

isReplyRunActive(isolatedSessionKey) ||

hasActiveRunForSession(isolatedSessionKey, listActiveEmbeddedRuns)

) {

emitHeartbeatEvent({

status: "skipped",

reason: HEARTBEAT_SKIP_REQUESTS_IN_FLIGHT,

const timeoutOverrideSeconds = resolveHeartbeatTimeoutOverrideSeconds(cfg, heartbeat);

const bootstrapContextMode: "lightweight" | undefined =

heartbeat?.lightContext === true ? "lightweight" : undefined;

const replyOperationRunState: ReplyOperationRunState = {};

const replyOpts = {

isHeartbeat: true,

[REPLY_OPERATION_RUN_STATE]: replyOperationRunState,

...(heartbeatModelOverride ? { heartbeatModelOverride } : {}),

suppressToolErrorWarnings,

...(usesHeartbeatResponseTool ? { enableHeartbeatTool: true, forceHeartbeatTool: true } : {}),

const replyResult = await getReplyFromConfig(ctx, replyOpts, cfg);

const heartbeatToolResponse = resolveHeartbeatToolResponseFromReplyResult(replyResult);

const replyPayload = resolveHeartbeatReplyPayload(replyResult);

if (

!heartbeatToolResponse &&

(!replyPayload || !hasOutboundReplyContent(replyPayload)) &&

replyOperationRunState.admission?.status === "skipped" &&

replyOperationRunState.admission.reason === "active-run"

) {

emitHeartbeatEvent({

status: "skipped",

reason: HEARTBEAT_SKIP_REQUESTS_IN_FLIGHT,

durationMs: Date.now() - startedAt,

});

return { status: "skipped", reason: HEARTBEAT_SKIP_REQUESTS_IN_FLIGHT };

}

const includeReasoning = heartbeat?.includeReasoning === true;

const reasoningPayloads = includeReasoning

? resolveHeartbeatReasoningPayloads(replyResult).filter((payload) => payload !== replyPayload)