@voybio/ace-swarm 2.4.3 → 2.4.6

package/dist/helpers/store-resolution.js

@@ -7,18 +7,6 @@ import { isOperationalArtifactPath, operationalArtifactKey, writeOperationalArti
 import { withStoreWriteCoordinatorSync } from "../store/write-coordinator.js";
 import { ACE_ROOT_REL, ACE_SCRIPTS_ROOT_REL, ACE_SKILLS_ROOT_REL, ACE_TASKS_ROOT_REL, AGENT_FILES, AGENT_MANIFEST_FILES, DEFAULTS_ROOT, KERNEL_FILES, STORE_AGENT_FILES, STORE_KERNEL_FILES, STORE_TASK_FILES, TASK_FILES, } from "./constants.js";
 import { currentWorkspaceRoot, isProjectedAceWorkspacePath, mapAceWorkspaceRelativePath, resolveWorkspaceReadPath, resolveWorkspaceWritePath, } from "./path-utils.js";
-const STORE_ONLY_AGENT_STATE_FILES = new Set([
-    "agent-state/AST_GREP_INDEX.json",
-    "agent-state/AST_GREP_INDEX.md",
-    "agent-state/EVIDENCE_LOG.md",
-    "agent-state/STATUS_EVENTS.ndjson",
-    "agent-state/STATUS_EVENTS-archive.ndjson",
-    "agent-state/index-fingerprints.json",
-    "agent-state/index.json",
-    "agent-state/job-locks.json",
-    "agent-state/job-queue.json",
-    "agent-state/scheduler-lease.json",
-]);
 export function formatStorePath(key) {
     return toVirtualStorePath(getWorkspaceStorePath(currentWorkspaceRoot()), key);
 }
@@ -62,6 +50,13 @@ function resolveStoreFallbackKeys(filePath) {
     if (logicalAgentStatePath && isOperationalArtifactPath(logicalAgentStatePath)) {
         keys.add(operationalArtifactKey(logicalAgentStatePath));
     }
+    // Root-level tasks/SWARM_HANDOFF.*.json — not under agent-state/ or
+    // .agents/ACE/, so it previously had no store fallback key at all and
+    // accumulated forever outside `ace cache`'s scan roots.
+    const handoffPayloadMatch = normalized.match(/^tasks\/(SWARM_HANDOFF\..+\.json)$/);
+    if (handoffPayloadMatch) {
+        keys.add(`state/handoffs/payloads/${handoffPayloadMatch[1]}`);
+    }
     if (normalized === "agent-state/ACE_WORKFLOW.md" || canonical === `${ACE_ROOT_REL}/agent-state/ACE_WORKFLOW.md`) {
         keys.add("knowledge/runtime/ACE_WORKFLOW.md");
     }
@@ -117,6 +112,9 @@ function resolveStoreFallbackKeys(filePath) {
     ]);
     if (logicalAgentStatePath?.startsWith("agent-state/")) {
         const rel = logicalAgentStatePath.slice("agent-state/".length);
+        if (rel === "source-edit-events.ndjson") {
+            keys.add("state/source-edit-events.ndjson");
+        }
         if (!rel.startsWith("context-snapshots/")) {
             keys.add(`state/artifacts/agent-state/${rel}`);
         }
@@ -176,6 +174,18 @@ function resolveStoreFallbackKeys(filePath) {
     }
     return [...keys];
 }
+function logicalAgentStatePathFor(normalized, canonical) {
+    return normalized.startsWith("agent-state/")
+        ? normalized
+        : canonical.startsWith(`${ACE_ROOT_REL}/agent-state/`)
+            ? canonical.slice(`${ACE_ROOT_REL}/`.length)
+            : undefined;
+}
+function isAceManagedPath(canonical, logicalAgentStatePath) {
+    return Boolean(logicalAgentStatePath ||
+        canonical === ACE_ROOT_REL ||
+        canonical.startsWith(`${ACE_ROOT_REL}/`));
+}
 export function resolveStoreFallbackKeysForPath(filePath) {
     return resolveStoreFallbackKeys(filePath);
 }
@@ -197,9 +207,22 @@ export function safeRead(filePath) {
             const direct = readVirtualStorePathSync(filePath);
             return typeof direct === "string" ? direct : `[FILE NOT FOUND] ${filePath}`;
         }
+        const storeKeys = resolveStoreFallbackKeys(filePath);
+        const store = readStoreText(storeKeys);
+        const normalized = normalizeRelPath(filePath);
+        const canonical = mapAceWorkspaceRelativePath(normalized);
+        const storeFirst = process.env.ACE_STORE_FIRST !== "0" && !isProjectedAceWorkspacePath(canonical);
         const abs = resolveWorkspaceReadPath(filePath);
+        if (store && storeFirst) {
+            if (existsSync(abs)) {
+                const diskText = readFileSyncUtf8(abs);
+                if (diskText !== store.text) {
+                    console.error(`ace safeRead: store/disk copies differ for '${filePath}' (source=store, key=${store.key}; set ACE_STORE_FIRST=0 for legacy disk precedence)`);
+                }
+            }
+            return store.text;
+        }
         if (!existsSync(abs)) {
-            const store = readStoreText(resolveStoreFallbackKeys(filePath));
             if (store)
                 return store.text;
             return `[FILE NOT FOUND] ${abs}`;
@@ -213,24 +236,13 @@ export function safeRead(filePath) {
 export function safeWrite(filePath, content) {
     const normalized = normalizeRelPath(filePath);
     const canonical = mapAceWorkspaceRelativePath(normalized);
-    const logicalAgentStatePath = normalized.startsWith("agent-state/")
-        ? normalized
-        : canonical.startsWith(`${ACE_ROOT_REL}/agent-state/`)
-            ? canonical.slice(`${ACE_ROOT_REL}/`.length)
-            : undefined;
+    const logicalAgentStatePath = logicalAgentStatePathFor(normalized, canonical);
     const root = currentWorkspaceRoot();
     let storeVirtualPath;
     const storeKeys = resolveStoreFallbackKeys(filePath);
     if (storeKeys.length > 0 && existsSync(getWorkspaceStorePath(root))) {
         storeVirtualPath = withStoreWriteCoordinatorSync(getWorkspaceStorePath(root), () => writeStoreBlobSync(root, storeKeys[0], content), { operation_label: "safeWrite" });
-        const isAcePath = canonical === ACE_ROOT_REL || canonical.startsWith(`${ACE_ROOT_REL}/`);
-        const isStoreOnlyProjection = canonical === `${ACE_ROOT_REL}/ace-hook-context.json` ||
-            logicalAgentStatePath?.startsWith("agent-state/context-snapshots/") ||
-            STORE_ONLY_AGENT_STATE_FILES.has(logicalAgentStatePath ?? "");
-        if (isAcePath && !isProjectedAceWorkspacePath(canonical)) {
-            return storeVirtualPath;
-        }
-        if (isStoreOnlyProjection) {
+        if (isAceManagedPath(canonical, logicalAgentStatePath) && !isProjectedAceWorkspacePath(canonical)) {
             return storeVirtualPath;
         }
     }
@@ -246,11 +258,7 @@ export function safeWrite(filePath, content) {
 export async function safeWriteAsync(filePath, content) {
     const normalized = normalizeRelPath(filePath);
     const canonical = mapAceWorkspaceRelativePath(normalized);
-    const logicalAgentStatePath = normalized.startsWith("agent-state/")
-        ? normalized
-        : canonical.startsWith(`${ACE_ROOT_REL}/agent-state/`)
-            ? canonical.slice(`${ACE_ROOT_REL}/`.length)
-            : undefined;
+    const logicalAgentStatePath = logicalAgentStatePathFor(normalized, canonical);
     const root = currentWorkspaceRoot();
     let storeVirtualPath;
     const storeKeys = resolveStoreFallbackKeys(filePath);
@@ -262,14 +270,7 @@ export async function safeWriteAsync(filePath, content) {
         else {
             storeVirtualPath = await writeStoreBlobQueued(root, storeKey, content, { operation_label: "safeWriteAsync" });
         }
-        const isAcePath = canonical === ACE_ROOT_REL || canonical.startsWith(`${ACE_ROOT_REL}/`);
-        const isStoreOnlyProjection = canonical === `${ACE_ROOT_REL}/ace-hook-context.json` ||
-            logicalAgentStatePath?.startsWith("agent-state/context-snapshots/") ||
-            STORE_ONLY_AGENT_STATE_FILES.has(logicalAgentStatePath ?? "");
-        if (isAcePath && !isProjectedAceWorkspacePath(canonical)) {
-            return storeVirtualPath;
-        }
-        if (isStoreOnlyProjection) {
+        if (isAceManagedPath(canonical, logicalAgentStatePath) && !isProjectedAceWorkspacePath(canonical)) {
             return storeVirtualPath;
         }
     }

package/dist/hermes/session-manager.d.ts

@@ -10,6 +10,9 @@ export interface HermesLocalTurnOptions {
     policy: LocalModelExecutionPolicy;
     toolScope?: string[];
     maxTurns: number;
+    /** Probed context window for the model; falls back to a conservative default. */
+    contextLength?: number;
+    timeoutMs?: number;
 }
 export interface HermesLocalTurnResult {
     result: BridgeResult;
@@ -21,10 +24,12 @@ export interface HermesLocalTurnResult {
         provider: string;
         model: string;
         events: HermesBridgeEvent[];
+        touched_paths: string[];
     };
 }
 export interface HermesLocalExecutor {
     runTurn(options: HermesLocalTurnOptions): Promise<HermesLocalTurnResult>;
+    interrupt?(): void;
 }
 export interface HermesSubprocessExecutorOptions {
     hermesRoot?: string;
@@ -33,10 +38,15 @@ export interface HermesSubprocessExecutorOptions {
     command?: readonly string[];
     launchProfile?: HermesLaunchProfile;
     keepTemp?: boolean;
+    timeoutMs?: number;
+    maxOutputBytes?: number;
 }
 export declare class HermesSubprocessExecutor implements HermesLocalExecutor {
     private options;
+    private readonly activeChildren;
     constructor(options?: HermesSubprocessExecutorOptions);
+    interrupt(): void;
+    private interruptChild;
     runTurn(options: HermesLocalTurnOptions): Promise<HermesLocalTurnResult>;
 }
 //# sourceMappingURL=session-manager.d.ts.map

package/dist/hermes/session-manager.js

@@ -10,7 +10,38 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const DIST_ROOT = resolve(__dirname, "..");
 const PACKAGE_ROOT = resolve(DIST_ROOT, "..");
-const MIN_HERMES_LOCAL_CONTEXT_LENGTH = 65536;
+// Conservative fallback when the model's real context window has not been probed.
+// The prior 65536 default over-promised small models (an 8k gemma/llama was told it
+// had 64k), causing silent server-side truncation. Callers that have a probed value
+// (Ollama /api/show, llama.cpp /props) should pass it via options.contextLength.
+const DEFAULT_HERMES_LOCAL_CONTEXT_LENGTH = 8192;
+// Env vars forwarded to the operator-supplied Hermes Python worker. Forwarding the
+// full parent process.env leaked unrelated API keys/secrets into a third-party
+// process; only transport-relevant variables are allowlisted here.
+const HERMES_ENV_ALLOWLIST_EXACT = new Set([
+    "PATH",
+    "HOME",
+    "TMPDIR",
+    "LANG",
+    "LC_ALL",
+    "OLLAMA_HOST",
+    "OLLAMA_BASE_URL",
+    "OPENAI_BASE_URL",
+    "OPENAI_API_BASE",
+]);
+const HERMES_ENV_ALLOWLIST_PREFIXES = ["HERMES_", "ACE_"];
+function scrubbedHermesEnv(base) {
+    const scrubbed = {};
+    for (const [key, value] of Object.entries(base)) {
+        if (value === undefined)
+            continue;
+        if (HERMES_ENV_ALLOWLIST_EXACT.has(key) ||
+            HERMES_ENV_ALLOWLIST_PREFIXES.some((prefix) => key.startsWith(prefix))) {
+            scrubbed[key] = value;
+        }
+    }
+    return scrubbed;
+}
 function summarizeToolResult(value) {
     if (typeof value === "string")
         return value.slice(0, 500);
@@ -34,15 +65,38 @@ function hermesBaseUrl(provider, baseUrl) {
 }
 export class HermesSubprocessExecutor {
     options;
+    activeChildren = new Set();
     constructor(options = {}) {
         this.options = options;
     }
+    interrupt() {
+        for (const child of this.activeChildren)
+            this.interruptChild(child);
+    }
+    interruptChild(child) {
+        if (child.killed)
+            return;
+        child.kill("SIGTERM");
+        const killTimer = setTimeout(() => {
+            if (this.activeChildren.has(child) && child.exitCode === null && child.signalCode === null) {
+                child.kill("SIGKILL");
+            }
+        }, 1_000);
+        killTimer.unref();
+    }
     async runTurn(options) {
         const sessionId = `hermes-${randomUUID()}`;
         const shadowId = `shadow-${randomUUID()}`;
         const hermesHome = mkdtempSync(resolve(tmpdir(), "ace-hermes-home-"));
         mkdirSync(hermesHome, { recursive: true });
-        const toolScope = options.toolScope ?? [];
+        const toolScope = options.toolScope;
+        if (!toolScope || toolScope.length === 0) {
+            throw new Error("hermes_local requires a non-empty tool scope (reason_code=hermes_empty_tool_scope). " +
+                "This is an upstream configuration bug — toolScope must be populated before reaching the Hermes executor.");
+        }
+        const contextLength = options.contextLength && options.contextLength > 0
+            ? options.contextLength
+            : DEFAULT_HERMES_LOCAL_CONTEXT_LENGTH;
         const cliPath = resolve(DIST_ROOT, "cli.js");
         const baseUrl = hermesBaseUrl(options.runtime.provider, options.runtime.baseUrl ?? options.runtime.ollamaUrl);
         writeFileSync(resolve(hermesHome, "config.yaml"), [
@@ -51,7 +105,7 @@ export class HermesSubprocessExecutor {
             "  provider: custom",
             `  base_url: ${JSON.stringify(baseUrl)}`,
             "  api_key: no-key-required",
-            `  context_length: ${MIN_HERMES_LOCAL_CONTEXT_LENGTH}`,
+            `  context_length: ${contextLength}`,
             "",
             "auxiliary:",
             "  compression:",
@@ -59,7 +113,7 @@ export class HermesSubprocessExecutor {
             "    provider: custom",
             `    base_url: ${JSON.stringify(baseUrl)}`,
             "    api_key: no-key-required",
-            `    context_length: ${MIN_HERMES_LOCAL_CONTEXT_LENGTH}`,
+            `    context_length: ${contextLength}`,
             "",
             "mcp_servers:",
             "  ace_shadow:",
@@ -88,12 +142,13 @@ export class HermesSubprocessExecutor {
         const child = spawn(bin, [...args, workerPath], {
             cwd: PACKAGE_ROOT,
             env: {
-                ...process.env,
+                ...scrubbedHermesEnv(process.env),
                 HERMES_HOME: hermesHome,
                 ACE_WORKSPACE_ROOT: options.runtime.workspaceRoot,
             },
             stdio: ["pipe", "pipe", "pipe"],
         });
+        this.activeChildren.add(child);
         const decoder = new HermesBridgeFrameDecoder();
         const events = [];
         const malformed = [];
@@ -101,25 +156,50 @@ export class HermesSubprocessExecutor {
         let finalText = "";
         let turns = 0;
         let sawError = "";
-        child.stdout.on("data", (chunk) => {
-            for (const frame of decoder.push(chunk)) {
-                if (frame.ok) {
-                    events.push(frame.event);
-                    if (frame.event.type === "final") {
-                        finalText = eventText(frame.event);
-                        const rawTurns = frame.event.turns;
-                        turns = typeof rawTurns === "number" ? rawTurns : turns;
-                    }
-                    if (frame.event.type === "error") {
-                        sawError = eventText(frame.event) || "Hermes bridge error";
-                    }
+        let finalCompleted;
+        let finalCount = 0;
+        let outputBytes = 0;
+        let outputOverflow = false;
+        const maxOutputBytes = this.options.maxOutputBytes ?? 4 * 1024 * 1024;
+        // Single per-frame consumer so the live stream and the post-close tail-flush
+        // (decoder.push(…, true)) extract final/error semantics identically and can never drift.
+        const applyFrame = (frame) => {
+            if (frame.ok) {
+                events.push(frame.event);
+                if (frame.event.type === "final") {
+                    finalCount += 1;
+                    finalText = eventText(frame.event);
+                    const rawCompleted = frame.event.completed;
+                    finalCompleted = typeof rawCompleted === "boolean" ? rawCompleted : true;
+                    const rawTurns = frame.event.turns;
+                    turns = typeof rawTurns === "number" ? rawTurns : turns;
                 }
-                else {
-                    malformed.push(frame.reason);
+                if (frame.event.type === "error") {
+                    sawError = eventText(frame.event) || "Hermes bridge error";
                 }
             }
+            else {
+                malformed.push(frame.reason);
+            }
+        };
+        child.stdout.on("data", (chunk) => {
+            outputBytes += chunk.byteLength;
+            if (outputBytes > maxOutputBytes) {
+                outputOverflow = true;
+                this.interruptChild(child);
+                return;
+            }
+            for (const frame of decoder.push(chunk)) {
+                applyFrame(frame);
+            }
         });
         child.stderr.on("data", (chunk) => {
+            outputBytes += chunk.byteLength;
+            if (outputBytes > maxOutputBytes) {
+                outputOverflow = true;
+                this.interruptChild(child);
+                return;
+            }
             stderr.push(chunk.toString("utf8"));
         });
         const request = {
@@ -135,15 +215,22 @@ export class HermesSubprocessExecutor {
             system_prompt: "You are running inside ACE Hermes-local mode. Use only the imported ACE MCP toolset for tool calls. Do not use plain text as executable authority.",
         };
         child.stdin.end(`${JSON.stringify(request)}\n`);
+        const timeoutMs = options.timeoutMs ?? this.options.timeoutMs ?? 120_000;
+        let timedOut = false;
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            this.interruptChild(child);
+        }, timeoutMs);
+        timeout.unref();
         const exitCode = await new Promise((resolvePromise, reject) => {
             child.on("error", reject);
             child.on("close", resolvePromise);
+        }).finally(() => {
+            clearTimeout(timeout);
+            this.activeChildren.delete(child);
         });
         for (const frame of decoder.push(new Uint8Array(), true)) {
-            if (frame.ok)
-                events.push(frame.event);
-            else
-                malformed.push(frame.reason);
+            applyFrame(frame);
         }
         if (!this.options.keepTemp) {
             rmSync(hermesHome, { recursive: true, force: true });
@@ -156,11 +243,26 @@ export class HermesSubprocessExecutor {
             summary: summarizeToolResult(event.result ?? eventText(event)),
             isError: Boolean(event.is_error),
         }));
-        const status = sawError || malformed.length > 0 || exitCode !== 0 ? "failed" : "completed";
+        const touchedPaths = events
+            .filter((event) => event.type === "tool_start" && event.tool === "write_workspace_file")
+            .map((event) => event.input?.path)
+            .filter((path) => typeof path === "string" && path.trim().length > 0);
+        const finalIndex = events.findIndex((event) => event.type === "final");
+        const protocolIdentityInvalid = events.some((event) => (event.session_id !== undefined && event.session_id !== sessionId) ||
+            (event.turn_id !== undefined && event.turn_id !== request.turn_id));
+        const eventAfterFinal = finalIndex >= 0 && events.slice(finalIndex + 1).some((event) => event.type !== "session_close");
+        const protocolInvalid = protocolIdentityInvalid || eventAfterFinal;
+        const status = sawError || malformed.length > 0 || exitCode !== 0 || timedOut || outputOverflow || finalCount !== 1 || protocolInvalid
+            ? "failed"
+            : finalCompleted === false
+                ? "blocked"
+                : "completed";
         const summary = status === "failed"
             ? sawError ||
-                `Hermes bridge failed${malformed.length ? `; malformed_frames=${malformed.join(",")}` : ""}${stderr.length ? `; stderr=${stderr.join("").slice(0, 500)}` : ""}`
-            : finalText || "Hermes-local turn completed.";
+                `Hermes bridge failed${timedOut ? "; reason_code=hermes_timeout" : ""}${outputOverflow ? "; reason_code=hermes_output_limit" : ""}${finalCount !== 1 ? `; terminal_frames=${finalCount}` : ""}${protocolIdentityInvalid ? "; reason_code=hermes_frame_identity" : ""}${eventAfterFinal ? "; reason_code=hermes_frame_after_final" : ""}${malformed.length ? `; malformed_frames=${malformed.join(",")}` : ""}${stderr.length ? `; stderr=${stderr.join("").slice(0, 500)}` : ""}`
+            : status === "blocked"
+                ? finalText || "Hermes reported completed=false."
+                : finalText || "Hermes-local turn completed.";
         return {
             result: {
                 bridge_id: sessionId,
@@ -170,7 +272,7 @@ export class HermesSubprocessExecutor {
                 turns,
                 tool_calls: toolCalls,
                 child_results: [],
-                evidence_refs: toolCalls.map((tool) => `tool:${tool.tool}`),
+                evidence_refs: touchedPaths,
             },
             metadata: {
                 bridge_protocol_version: HERMES_BRIDGE_PROTOCOL_VERSION,
@@ -180,6 +282,7 @@ export class HermesSubprocessExecutor {
                 provider: options.runtime.provider,
                 model: options.runtime.model,
                 events,
+                touched_paths: touchedPaths,
             },
         };
     }

package/dist/job-scheduler.d.ts

@@ -94,6 +94,12 @@ export interface DispatchJobsInput {
     owner?: string;
     lease_ttl_seconds?: number;
     now_iso?: string;
+    /**
+     * How long a running job may go without a worker heartbeat before the
+     * watchdog reaps it into `unknown_recovery`. Defaults to
+     * DEFAULT_HEARTBEAT_STALE_MS. Set to <=0 to disable reaping for this tick.
+     */
+    heartbeat_stale_seconds?: number;
 }
 export interface DispatchJobsResult {
     ok: boolean;
@@ -111,6 +117,7 @@ export interface DispatchJobsResult {
         running_jobs: number;
         started_jobs: number;
         recovered_jobs: number;
+        reaped_jobs: number;
     };
 }
 export interface DispatchJobNowInput {
@@ -148,6 +155,34 @@ export interface CompleteJobResult {
     retry_scheduled_for?: string;
     error?: string;
 }
+export interface HeartbeatJobInput {
+    job_id: string;
+    owner?: string;
+    now_iso?: string;
+    lease_ttl_seconds?: number;
+}
+export interface HeartbeatJobResult {
+    ok: boolean;
+    queue_path: string;
+    lock_path: string;
+    heartbeat_at?: string;
+    resources?: string[];
+    error?: string;
+}
+export interface ReapStaleRunningJobsInput {
+    owner?: string;
+    now_iso?: string;
+    heartbeat_stale_seconds?: number;
+}
+export interface ReapStaleRunningJobsResult {
+    ok: boolean;
+    queue_path: string;
+    lock_path: string;
+    queue: JobQueueFile;
+    locks: JobLockTableFile;
+    reaped_jobs: number;
+    reaped_job_ids: string[];
+}
 export interface AckJobInput {
     job_id: string;
     action: "accept" | "reject" | "cancel" | "resume";
@@ -167,9 +202,32 @@ export declare function getSchedulerLeasePath(): string;
 export declare function readJobQueue(): JobQueueFile;
 export declare function readJobLockTable(): JobLockTableFile;
 export declare function readSchedulerLease(): SchedulerLeaseFile | undefined;
+/**
+ * Default window a running job may go without a worker heartbeat before the
+ * watchdog presumes the worker is dead and reaps the job into
+ * `unknown_recovery`. A live in-process worker is expected to call
+ * `heartbeatJob` well within this window (see job-worker.ts).
+ */
+export declare const DEFAULT_HEARTBEAT_STALE_MS = 120000;
 export declare function enqueueJob(input: EnqueueJobInput): Promise<EnqueueJobResult>;
 export declare function acknowledgeJob(input: AckJobInput): Promise<AckJobResult>;
 export declare function dispatchJobs(input?: DispatchJobsInput): Promise<DispatchJobsResult>;
 export declare function dispatchJobNow(input: DispatchJobNowInput): Promise<DispatchJobNowResult>;
 export declare function completeJob(input: CompleteJobInput): Promise<CompleteJobResult>;
+/**
+ * Prove liveness for a running job. A live in-process worker calls this
+ * periodically while executing a job body so the heartbeat watchdog does not
+ * reap it. Advances the job's active-lock heartbeats and renews the owner
+ * lease. This is the ONLY path (besides a fresh start) that advances a running
+ * job's heartbeat — the dispatcher deliberately does not, so a missing
+ * heartbeat reliably signals a dead worker.
+ */
+export declare function heartbeatJob(input: HeartbeatJobInput): Promise<HeartbeatJobResult>;
+/**
+ * Standalone heartbeat-watchdog tick: reap stale running jobs without planning
+ * or starting anything. Takes its own scheduler lock. Useful for a dedicated
+ * watchdog cadence separate from dispatch. Does not require lease ownership —
+ * reaping a dead worker's job must not depend on holding the lease.
+ */
+export declare function reapStaleRunningJobsTick(input?: ReapStaleRunningJobsInput): Promise<ReapStaleRunningJobsResult>;
 //# sourceMappingURL=job-scheduler.d.ts.map