issue-flow 0.18.0 → 0.20.0

package/dist/chunk-44RF3VFG.js

@@ -0,0 +1,717 @@
+#!/usr/bin/env node
+import {
+  pullRequestRefSchema,
+  routingConfigInputSchema,
+  webConfigSchema
+} from "./chunk-XNK5UN2D.js";
+
+// src/agents/types.ts
+var AGENT_PROVIDER_IDS = [
+  "claude",
+  "codex",
+  "cursor",
+  "antigravity",
+  "opencode"
+];
+var AGENT_PROVIDER_LIST = AGENT_PROVIDER_IDS.join(", ");
+var AGENT_PHASES = [
+  "analyze",
+  "generate",
+  "prd",
+  "plan",
+  "execute",
+  "review",
+  "pr",
+  "pr-review"
+];
+function isAgentPhase(value) {
+  return AGENT_PHASES.includes(value);
+}
+function isAgentProviderId(value) {
+  return AGENT_PROVIDER_IDS.includes(value);
+}
+var CLAUDE_CAPABILITIES = {
+  extraDirectories: "flag",
+  addDirs: true,
+  toolAllowlist: true,
+  maxTurns: true,
+  osSandbox: false,
+  modelSelection: true,
+  modelDiscovery: false,
+  usage: "tokens-and-cost",
+  reportsUsage: true,
+  reportsCost: true,
+  sessionResume: false,
+  authProbe: "none",
+  bareModelAliases: true,
+  promptChannel: "both",
+  nativeTimeout: false,
+  contextFileName: "CLAUDE.md",
+  contextFileMaxBytes: null,
+  toolNameCase: "CamelCase",
+  readOnlyMode: "native"
+};
+var CODEX_CAPABILITIES = {
+  extraDirectories: "flag",
+  addDirs: true,
+  toolAllowlist: false,
+  maxTurns: false,
+  osSandbox: true,
+  modelSelection: true,
+  modelDiscovery: false,
+  usage: "tokens-only",
+  reportsUsage: true,
+  reportsCost: false,
+  sessionResume: true,
+  authProbe: "exit-code",
+  bareModelAliases: false,
+  promptChannel: "both",
+  nativeTimeout: false,
+  contextFileName: "AGENTS.md",
+  contextFileMaxBytes: 32 * 1024,
+  toolNameCase: "none",
+  readOnlyMode: "sandbox"
+};
+var CURSOR_CAPABILITIES = {
+  extraDirectories: "permission-file",
+  addDirs: false,
+  toolAllowlist: false,
+  maxTurns: false,
+  osSandbox: true,
+  modelSelection: true,
+  modelDiscovery: true,
+  usage: "none",
+  reportsUsage: false,
+  reportsCost: false,
+  sessionResume: true,
+  authProbe: "text",
+  bareModelAliases: false,
+  promptChannel: "argv",
+  nativeTimeout: false,
+  contextFileName: "AGENTS.md",
+  contextFileMaxBytes: null,
+  toolNameCase: "lowercase",
+  readOnlyMode: "native"
+};
+var ANTIGRAVITY_CAPABILITIES = {
+  extraDirectories: "flag",
+  addDirs: true,
+  toolAllowlist: false,
+  maxTurns: false,
+  osSandbox: true,
+  modelSelection: true,
+  modelDiscovery: true,
+  usage: "tokens-only",
+  reportsUsage: true,
+  reportsCost: false,
+  sessionResume: true,
+  authProbe: "none",
+  bareModelAliases: false,
+  promptChannel: "argv",
+  nativeTimeout: true,
+  contextFileName: "AGENTS.md",
+  contextFileMaxBytes: null,
+  toolNameCase: "CamelCase",
+  readOnlyMode: "native"
+};
+var OPENCODE_CAPABILITIES = {
+  extraDirectories: "flag",
+  addDirs: true,
+  toolAllowlist: false,
+  maxTurns: false,
+  osSandbox: false,
+  modelSelection: true,
+  modelDiscovery: true,
+  usage: "tokens-only",
+  reportsUsage: true,
+  reportsCost: false,
+  sessionResume: true,
+  authProbe: "text",
+  bareModelAliases: false,
+  promptChannel: "argv",
+  nativeTimeout: false,
+  contextFileName: "AGENTS.md",
+  contextFileMaxBytes: null,
+  toolNameCase: "lowercase",
+  readOnlyMode: "native"
+};
+var AGENT_SCHEMA_VERSION = 1;
+
+// src/storage/schemas.ts
+import { z as z2 } from "zod";
+
+// src/agents/schemas.ts
+import { z } from "zod";
+var agentProviderIdSchema = z.enum([
+  "claude",
+  "codex",
+  "cursor",
+  "antigravity",
+  "opencode"
+]);
+var codexSandboxSchema = z.enum(["read-only", "workspace-write", "danger-full-access"]);
+var codexReasoningEffortSchema = z.enum(["minimal", "low", "medium", "high", "xhigh"]);
+var claudeSettingsSchema = z.object({
+  ignoreUserConfig: z.boolean(),
+  strictMcpConfig: z.boolean()
+}).partial();
+var codexSettingsSchema = z.object({
+  reasoningEffort: codexReasoningEffortSchema,
+  sandbox: codexSandboxSchema,
+  ignoreUserConfig: z.boolean(),
+  skipGitRepoCheck: z.boolean(),
+  configOverrides: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()]))
+}).partial();
+var cursorSandboxSchema = z.enum(["enabled", "disabled"]);
+var cursorPermissionsFileSchema = z.enum(["global", "project", "none"]);
+var cursorSettingsSchema = z.object({
+  sandbox: cursorSandboxSchema,
+  approveMcps: z.boolean(),
+  permissionsFile: cursorPermissionsFileSchema,
+  minVersion: z.string().min(1),
+  force: z.boolean().refine((value) => value !== false, {
+    message: "agent.cursor.force cannot be false: without --force, Cursor finishes with exit 0 and writes nothing."
+  })
+}).partial();
+var antigravityEffortSchema = z.enum(["low", "medium", "high"]);
+var antigravitySettingsSchema = z.object({
+  effort: antigravityEffortSchema,
+  sandbox: z.boolean(),
+  executeTimeout: z.union([z.number().int(), z.string().min(1), z.null()]),
+  maxPromptBytes: z.number().int().positive(),
+  minVersion: z.string().min(1),
+  skipPermissions: z.boolean().refine((value) => value !== false, {
+    message: "agent.antigravity.skipPermissions cannot be false: without --dangerously-skip-permissions, Antigravity finishes SUCCESS and writes nothing."
+  })
+}).partial();
+var opencodeSettingsSchema = z.object({
+  variant: z.string().min(1),
+  minVersion: z.string().min(1),
+  maxPromptBytes: z.number().int().positive()
+}).partial();
+var agentBlockSchema = z.object({
+  provider: agentProviderIdSchema,
+  model: z.string().min(1).nullable(),
+  claude: claudeSettingsSchema,
+  codex: codexSettingsSchema,
+  cursor: cursorSettingsSchema,
+  antigravity: antigravitySettingsSchema,
+  opencode: opencodeSettingsSchema
+}).partial();
+var agentPhasesSchema = z.object({
+  analyze: agentBlockSchema,
+  generate: agentBlockSchema,
+  prd: agentBlockSchema,
+  plan: agentBlockSchema,
+  execute: agentBlockSchema,
+  review: agentBlockSchema,
+  pr: agentBlockSchema,
+  "pr-review": agentBlockSchema
+}).partial();
+var agentConfigInputSchema = z.object({
+  provider: agentProviderIdSchema,
+  model: z.string().min(1).nullable(),
+  claude: claudeSettingsSchema,
+  codex: codexSettingsSchema,
+  cursor: cursorSettingsSchema,
+  antigravity: antigravitySettingsSchema,
+  opencode: opencodeSettingsSchema,
+  phases: agentPhasesSchema
+}).partial();
+function parsePhasesInput(value, warn) {
+  if (value === void 0 || value === null) return {};
+  if (typeof value !== "object" || Array.isArray(value)) {
+    warn('Ignoring "agent.phases": expected an object.');
+    return {};
+  }
+  const result = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (!AGENT_PHASES.includes(key)) {
+      warn(`Ignoring unknown agent phase "${key}".`);
+      continue;
+    }
+    const parsed = agentBlockSchema.safeParse(raw);
+    if (!parsed.success) {
+      warn(`Ignoring agent.phases.${key}: ${parsed.error.issues[0]?.message ?? "invalid value"}.`);
+      continue;
+    }
+    result[key] = parsed.data;
+  }
+  return result;
+}
+
+// src/storage/schemas.ts
+var STORAGE_SCHEMA_VERSION = 1;
+var userStoryNumberingSourceSchema = z2.enum(["history", "start-us", "none"]);
+var userStoryNumberingDecisionSchema = z2.object({
+  /** The `US-NNN` number the `plan` prompt was told to continue from. */
+  nextNumber: z2.number().int().positive(),
+  source: userStoryNumberingSourceSchema,
+  /** Issue the decision was made for. */
+  issueNumber: z2.string().min(1),
+  decidedAt: z2.string().min(1),
+  /** Human-readable origin, e.g. the previous story id and issue it came from. */
+  detail: z2.string().optional()
+});
+var projectMetadataSchema = z2.object({
+  schemaVersion: z2.number().int().positive(),
+  projectId: z2.string().min(1),
+  root: z2.string().min(1),
+  /** Normalized remote (`host/org/repo`), or null when the project has none. */
+  remoteUrl: z2.string().nullable(),
+  createdAt: z2.string().min(1),
+  updatedAt: z2.string().min(1),
+  /** Null until the project is used by a pipeline run. */
+  lastAttemptAt: z2.string().nullable(),
+  /**
+   * Most recent User Story numbering decision made by `plan` (issue #36).
+   * Absent on a project whose `plan` never ran through the numbering
+   * resolver, or on a `metadata.json` written before the feature existed.
+   */
+  userStoryNumbering: userStoryNumberingDecisionSchema.optional()
+});
+var webShape = webConfigSchema.shape;
+var globalWebConfigSchema = z2.object({
+  port: webShape.port.unwrap(),
+  host: webShape.host.unwrap(),
+  refreshSeconds: webShape.refreshSeconds.unwrap(),
+  logLimit: webShape.logLimit.unwrap()
+}).partial();
+var globalRetryConfigSchema = z2.object({
+  retryLimit: z2.number().int().nonnegative(),
+  retryForever: z2.boolean(),
+  backoffBaseSeconds: z2.number().nonnegative(),
+  backoffMaxSeconds: z2.number().nonnegative()
+}).partial();
+var resilienceProfileSchema = z2.enum([
+  "default",
+  "continuous"
+]);
+var jitterSchema = z2.enum(["none", "full"]);
+var failoverModeSchema = z2.enum([
+  "never",
+  "after_attempts",
+  "immediate"
+]);
+var exhaustedActionSchema = z2.enum(["fail", "block"]);
+var retryPolicyOverrideSchema = z2.object({
+  maxAttempts: z2.number().int().nonnegative(),
+  initialDelayMs: z2.number().nonnegative(),
+  maxDelayMs: z2.number().nonnegative(),
+  backoffFactor: z2.number().min(1),
+  jitter: jitterSchema,
+  retryForever: z2.boolean(),
+  failover: failoverModeSchema,
+  failoverAfterAttempts: z2.number().int().positive(),
+  onExhausted: exhaustedActionSchema
+}).partial();
+var retryOverridesByKind = {
+  network: retryPolicyOverrideSchema,
+  timeout: retryPolicyOverrideSchema,
+  stalled: retryPolicyOverrideSchema,
+  rateLimit: retryPolicyOverrideSchema,
+  providerDown: retryPolicyOverrideSchema,
+  providerCrash: retryPolicyOverrideSchema,
+  authentication: retryPolicyOverrideSchema,
+  configuration: retryPolicyOverrideSchema,
+  repositoryState: retryPolicyOverrideSchema,
+  taskExecution: retryPolicyOverrideSchema,
+  internal: retryPolicyOverrideSchema,
+  unknown: retryPolicyOverrideSchema
+};
+var resilienceRetryConfigSchema = z2.object(retryOverridesByKind).partial();
+var resilienceProvidersConfigSchema = z2.object({
+  failover: z2.boolean(),
+  chain: z2.array(z2.string().min(1)),
+  cooldownMs: z2.number().nonnegative(),
+  maxCooldownMs: z2.number().nonnegative(),
+  failureWindowMs: z2.number().positive(),
+  failuresToTrip: z2.number().int().positive()
+}).partial();
+var providerHealthStatusSchema = z2.enum([
+  "healthy",
+  "degraded",
+  "unavailable",
+  "rate_limited",
+  "auth_failed",
+  "half_open"
+]);
+var providerHealthRecordSchema = z2.object({
+  status: providerHealthStatusSchema.default("healthy"),
+  failures: z2.array(
+    z2.object({
+      at: z2.string(),
+      kind: z2.enum([
+        "network",
+        "timeout",
+        "stalled",
+        "rate_limit",
+        "provider_down",
+        "provider_crash",
+        "authentication",
+        "configuration",
+        "repository_state",
+        "task_execution",
+        "internal",
+        "unknown"
+      ])
+    })
+  ).default([]),
+  consecutiveFailures: z2.number().int().nonnegative().default(0),
+  cooldownLevel: z2.number().int().nonnegative().default(0),
+  cooldownUntil: z2.string().nullable().default(null),
+  lastFailureKind: z2.enum([
+    "network",
+    "timeout",
+    "stalled",
+    "rate_limit",
+    "provider_down",
+    "provider_crash",
+    "authentication",
+    "configuration",
+    "repository_state",
+    "task_execution",
+    "internal",
+    "unknown"
+  ]).nullable().default(null),
+  lastFailureAt: z2.string().nullable().default(null),
+  lastSuccessAt: z2.string().nullable().default(null),
+  probeInFlight: z2.boolean().default(false),
+  probeStartedAt: z2.string().nullable().default(null)
+});
+var providersHealthSchema = z2.object({
+  schemaVersion: z2.literal(1).default(1),
+  providers: z2.record(z2.string(), providerHealthRecordSchema).default({})
+});
+var resilienceQueueConfigSchema = z2.object({
+  onIssueFailure: z2.enum(["stop", "skip", "block"]),
+  maxIssueAttempts: z2.number().int().positive()
+}).partial();
+var resilienceWatchdogConfigSchema = z2.object({
+  inactivityTimeoutMs: z2.number().int().nonnegative()
+}).partial();
+var resilienceJournalConfigSchema = z2.object({
+  enabled: z2.boolean(),
+  maxFileBytes: z2.number().int().positive()
+}).partial();
+var resilienceDecomposeConfigSchema = z2.object({
+  auto: z2.boolean()
+}).partial();
+var resilienceConfigSchema = z2.object({
+  profile: resilienceProfileSchema,
+  /** Whether a credential failure may migrate to another provider. */
+  failoverOnAuth: z2.boolean(),
+  retry: resilienceRetryConfigSchema,
+  providers: resilienceProvidersConfigSchema,
+  queue: resilienceQueueConfigSchema,
+  watchdog: resilienceWatchdogConfigSchema,
+  journal: resilienceJournalConfigSchema,
+  decompose: resilienceDecomposeConfigSchema
+}).partial();
+var telemetryPricingOverrideSchema = z2.object({
+  inputPerMillion: z2.number(),
+  outputPerMillion: z2.number(),
+  cacheReadPerMillion: z2.number(),
+  cacheWritePerMillion: z2.number()
+}).partial();
+var telemetryConfigInputSchema = z2.object({
+  enabled: z2.boolean(),
+  maxExecutions: z2.number().int().positive(),
+  pricing: z2.object({
+    estimate: z2.boolean(),
+    overrides: z2.record(z2.string(), telemetryPricingOverrideSchema)
+  }).partial()
+}).partial();
+var globalCommitConfigSchema = z2.object({
+  signoff: z2.boolean(),
+  conventional: z2.boolean()
+}).partial();
+var storageConfigInputSchema = z2.object({
+  /** Keep legacy JSON as the active driver, for recovery or a staged rollout. */
+  driver: z2.enum(["sqlite", "json"]),
+  /** Number of pre-migration database snapshots to retain. */
+  backupRetention: z2.number().int().nonnegative(),
+  /** Explicit row-retention policy. Omitted values mean retain history. */
+  retention: z2.object({
+    executions: z2.number().int().nonnegative(),
+    events: z2.number().int().nonnegative(),
+    snapshots: z2.number().int().nonnegative(),
+    backups: z2.number().int().nonnegative()
+  }).partial()
+}).partial();
+var globalConfigSchema = z2.object({
+  schemaVersion: z2.number().int().positive(),
+  /** Override for the directory holding `projects/`. */
+  storageDir: z2.string().min(1),
+  storage: storageConfigInputSchema,
+  web: globalWebConfigSchema,
+  retry: globalRetryConfigSchema,
+  commit: globalCommitConfigSchema,
+  resilience: resilienceConfigSchema,
+  agent: agentConfigInputSchema,
+  telemetry: telemetryConfigInputSchema,
+  routing: routingConfigInputSchema
+}).partial();
+var webLockSchema = z2.object({
+  pid: z2.number().int().positive(),
+  port: z2.number().int().positive(),
+  host: z2.string().min(1),
+  startedAt: z2.string().min(1),
+  /** Added in a backward-compatible way: locks from older releases remain valid. */
+  instanceId: z2.string().min(1).optional()
+});
+var runLockSchema = z2.object({
+  pid: z2.number().int().positive(),
+  /** `os.hostname()`. A pid only means something on the host that wrote it. */
+  host: z2.string().min(1),
+  /** The issue (or queue) identifier the owner is running. */
+  target: z2.string().min(1),
+  startedAt: z2.string().min(1),
+  lastHeartbeatAt: z2.string().min(1),
+  /** Absent on a foreground run written before this field existed. */
+  detached: z2.boolean().optional()
+});
+var executionPlanIssueSchema = z2.object({
+  id: z2.string().min(1),
+  number: z2.number().int().positive().nullable(),
+  title: z2.string(),
+  url: z2.string().nullable(),
+  source: z2.string().min(1),
+  position: z2.number().int().positive(),
+  // `blocked` and `skipped` are additive: no plan written before them can
+  // carry one, and a reader that does not know them was never given one.
+  status: z2.enum(["pending", "in_progress", "completed", "failed", "blocked", "skipped"]),
+  origin: z2.enum(["requested", "discovered"]),
+  role: z2.enum(["executable", "container"]).default("executable"),
+  externalDependencies: z2.array(z2.string()).default([]),
+  dependsOn: z2.array(z2.string()).default([]),
+  parent: z2.string().nullable().default(null),
+  priority: z2.enum(["high", "medium", "low"]).nullable().default(null),
+  heuristic: z2.boolean().default(false),
+  failedPhase: z2.string().nullable().default(null),
+  lastError: z2.object({ category: z2.string(), message: z2.string(), at: z2.string() }).nullable().default(null),
+  startedAt: z2.string().nullable().default(null),
+  completedAt: z2.string().nullable().default(null),
+  // Both default, so an execution-plan.json written by an earlier release
+  // parses unchanged and reads as "never attempted, not blocked".
+  attempts: z2.number().int().min(0).default(0),
+  blockedReason: z2.string().nullable().default(null)
+});
+var executionPlanSchema = z2.object({
+  closeIssue: z2.boolean().optional(),
+  closedIssueIds: z2.array(z2.string()).optional(),
+  prReviewCompleted: z2.boolean().optional(),
+  schemaVersion: z2.literal(1),
+  id: z2.string().min(1),
+  project: z2.string().min(1),
+  requested: z2.array(z2.string().min(1)),
+  branchName: z2.string().nullable().default(null),
+  noBranch: z2.boolean().default(false),
+  prReview: z2.boolean().default(false),
+  status: z2.enum(["pending", "in_progress", "completed", "failed"]),
+  createdAt: z2.string().min(1),
+  updatedAt: z2.string().min(1),
+  truncated: z2.boolean().default(false),
+  issues: z2.array(executionPlanIssueSchema),
+  excluded: z2.array(
+    z2.object({
+      id: z2.string().min(1),
+      number: z2.number().int().positive().nullable(),
+      title: z2.string(),
+      url: z2.string().nullable(),
+      reason: z2.string()
+    })
+  ).default([]),
+  pullRequest: pullRequestRefSchema.optional()
+});
+
+// src/storage/lock.ts
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { hostname } from "node:os";
+import { dirname } from "node:path";
+var RUN_LOCK_HEARTBEAT_MS = 1e4;
+var RUN_LOCK_STALE_INTERVALS = 3;
+var CLAIM_RETRIES = 3;
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+async function readRunLock(lockFile) {
+  let raw;
+  try {
+    raw = await readFile(lockFile, "utf-8");
+  } catch {
+    return null;
+  }
+  try {
+    const result = runLockSchema.safeParse(JSON.parse(raw));
+    return result.success ? result.data : null;
+  } catch {
+    return null;
+  }
+}
+async function removeRunLock(lockFile) {
+  try {
+    await rm(lockFile, { force: true });
+  } catch {
+  }
+}
+function isRunLockStale(lock, options = {}) {
+  const heartbeatMs = options.heartbeatMs ?? RUN_LOCK_HEARTBEAT_MS;
+  const staleIntervals = options.staleIntervals ?? RUN_LOCK_STALE_INTERVALS;
+  const now = (options.clock ?? Date.now)();
+  const host = options.host ?? hostname();
+  const beat = Date.parse(lock.lastHeartbeatAt);
+  const silent = Number.isNaN(beat) || now - beat > heartbeatMs * staleIntervals;
+  if (lock.host !== host) return silent;
+  return silent || !isProcessAlive(lock.pid);
+}
+function isSelf(lock, pid, host) {
+  return lock.pid === pid && lock.host === host;
+}
+function describeRunLockOwner(lock) {
+  return `pid ${lock.pid} on ${lock.host} (issue ${lock.target}, started ${lock.startedAt}, last heartbeat ${lock.lastHeartbeatAt})`;
+}
+async function touchRunLock(lockFile, lock, at) {
+  const next = { ...lock, lastHeartbeatAt: at };
+  try {
+    await writeFile(lockFile, `${JSON.stringify(next, null, 2)}
+`, "utf-8");
+  } catch {
+  }
+  return next;
+}
+async function claim(lockFile, lock) {
+  try {
+    await mkdir(dirname(lockFile), { recursive: true });
+    await writeFile(lockFile, `${JSON.stringify(lock, null, 2)}
+`, {
+      encoding: "utf-8",
+      flag: "wx"
+    });
+    return true;
+  } catch (err) {
+    if (err.code === "EEXIST") return false;
+    throw err;
+  }
+}
+async function acquireRunLock(lockFile, options) {
+  const pid = options.pid ?? process.pid;
+  const host = options.host ?? hostname();
+  const heartbeatMs = options.heartbeatMs ?? RUN_LOCK_HEARTBEAT_MS;
+  const clock = options.clock ?? Date.now;
+  const staleness = {
+    heartbeatMs,
+    ...options.staleIntervals === void 0 ? {} : { staleIntervals: options.staleIntervals },
+    clock,
+    pid,
+    host
+  };
+  let reclaimedFrom = null;
+  for (let attempt = 0; attempt <= CLAIM_RETRIES; attempt++) {
+    const at = new Date(clock()).toISOString();
+    const mine = {
+      pid,
+      host,
+      target: options.target,
+      startedAt: at,
+      lastHeartbeatAt: at,
+      ...options.detached === true ? { detached: true } : {}
+    };
+    if (await claim(lockFile, mine)) {
+      return { ok: true, handle: startHandle(lockFile, mine, reclaimedFrom, options) };
+    }
+    const existing = await readRunLock(lockFile);
+    if (existing === null) {
+      await removeRunLock(lockFile);
+      continue;
+    }
+    if (isSelf(existing, pid, host)) {
+      return { ok: true, handle: nestedHandle(existing) };
+    }
+    if (!isRunLockStale(existing, staleness)) {
+      return { ok: false, owner: existing };
+    }
+    reclaimedFrom = existing;
+    try {
+      options.onTakeover?.(existing);
+    } catch {
+    }
+    await removeRunLock(lockFile);
+  }
+  const owner = await readRunLock(lockFile);
+  if (owner !== null) return { ok: false, owner };
+  return {
+    ok: false,
+    owner: {
+      pid: 0,
+      host,
+      target: options.target,
+      startedAt: new Date(clock()).toISOString(),
+      lastHeartbeatAt: new Date(clock()).toISOString()
+    }
+  };
+}
+function startHandle(lockFile, lock, reclaimedFrom, options) {
+  const heartbeatMs = options.heartbeatMs ?? RUN_LOCK_HEARTBEAT_MS;
+  const clock = options.clock ?? Date.now;
+  let current = lock;
+  let timer = null;
+  if (options.heartbeat !== false) {
+    timer = setInterval(() => {
+      void touchRunLock(lockFile, current, new Date(clock()).toISOString()).then((next) => {
+        current = next;
+      });
+    }, heartbeatMs);
+    timer.unref();
+  }
+  return {
+    lock,
+    reclaimedFrom,
+    release: async () => {
+      if (timer !== null) {
+        clearInterval(timer);
+        timer = null;
+      }
+      await removeRunLock(lockFile);
+    }
+  };
+}
+function nestedHandle(lock) {
+  return { lock, reclaimedFrom: null, release: async () => {
+  } };
+}
+
+export {
+  AGENT_PROVIDER_IDS,
+  AGENT_PHASES,
+  isAgentPhase,
+  isAgentProviderId,
+  CLAUDE_CAPABILITIES,
+  CODEX_CAPABILITIES,
+  CURSOR_CAPABILITIES,
+  ANTIGRAVITY_CAPABILITIES,
+  OPENCODE_CAPABILITIES,
+  AGENT_SCHEMA_VERSION,
+  agentConfigInputSchema,
+  parsePhasesInput,
+  STORAGE_SCHEMA_VERSION,
+  projectMetadataSchema,
+  providersHealthSchema,
+  resilienceConfigSchema,
+  telemetryConfigInputSchema,
+  storageConfigInputSchema,
+  globalConfigSchema,
+  webLockSchema,
+  executionPlanSchema,
+  isProcessAlive,
+  readRunLock,
+  isRunLockStale,
+  describeRunLockOwner,
+  acquireRunLock
+};
+//# sourceMappingURL=chunk-44RF3VFG.js.map