@poetic-ai/poetic 1.42.0

package/dist/chunk-IC7I6YIJ.js

@@ -0,0 +1,301 @@
+import {
+  writeFileAtomic
+} from "./chunk-36PEBZAF.js";
+
+// src/core/providers/opencode/discovery.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import { execa } from "execa";
+var PARENT_ENV_OPENCODE_VENDORS = /* @__PURE__ */ new Set(["amazon-bedrock", "amazonbedrock"]);
+function isParentEnvOpencodeVendor(providerId, sourceLine) {
+  const normalized = providerId.toLowerCase().replace(/[^a-z0-9-]/g, "");
+  if (PARENT_ENV_OPENCODE_VENDORS.has(normalized)) {
+    return true;
+  }
+  if (sourceLine && /amazon\s+bedrock/i.test(sourceLine)) {
+    return true;
+  }
+  return false;
+}
+function credentialProvidersFromAuthList(result) {
+  if (Array.isArray(result.credentialProviders)) {
+    return result.credentialProviders;
+  }
+  return result.providers.filter((provider) => !isParentEnvOpencodeVendor(provider));
+}
+var DISCOVERY_TIMEOUT_MS = 1e4;
+var MODELS_DEV_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var MODELS_DEV_CACHE_FILENAME = "opencode-models-dev.json";
+var MAX_MODELS_DEV_BYTES = 10 * 1024 * 1024;
+function stripAnsi(text) {
+  return text.replace(/\u001b\[[0-9;]*m/g, "");
+}
+function isLikelyModelsDevCatalog(data) {
+  if (!data || typeof data !== "object") {
+    return false;
+  }
+  if (Array.isArray(data)) {
+    return data.every((entry) => entry && typeof entry === "object");
+  }
+  const record = data;
+  if (Array.isArray(record.data)) {
+    return record.data.every((entry) => entry && typeof entry === "object");
+  }
+  return Object.keys(record).length > 0;
+}
+function classifyAuthListSectionHeader(trimmed, withoutBullet) {
+  const headerCandidate = withoutBullet.replace(/[\\/~].*$/, "").trim();
+  if (/^credentials?\b/i.test(withoutBullet) || /^credentials?\b/i.test(headerCandidate)) {
+    return "credentials";
+  }
+  if (/^environment\b/i.test(withoutBullet) || /^environment\b/i.test(headerCandidate)) {
+    return "environment";
+  }
+  if (/^(credentials|environment)$/i.test(trimmed)) {
+    return trimmed.toLowerCase() === "environment" ? "environment" : "credentials";
+  }
+  return null;
+}
+function parseAuthListSections(stdout) {
+  const credentialProviders = [];
+  const environmentProviders = [];
+  const providers = [];
+  const seen = /* @__PURE__ */ new Set();
+  const lines = stripAnsi(stdout).split(/\r?\n/);
+  let section = "unknown";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (/^[\u250C\u2510\u2514\u2518\u2502\u251C\u2524\u2500]/u.test(trimmed)) continue;
+    const withoutBullet = trimmed.replace(/^[\u{2022}*+\-–—\u{25CF}]+\s*/u, "");
+    const sectionHeader = classifyAuthListSectionHeader(trimmed, withoutBullet);
+    if (sectionHeader) {
+      section = sectionHeader;
+      continue;
+    }
+    if (/[\\/]/.test(trimmed) || /~/.test(trimmed) || /\b\w+\.jsonc?\b/i.test(trimmed)) continue;
+    if (/^(name|provider|id|type|auth|key|token|secret)/i.test(trimmed)) continue;
+    if (trimmed.length > 80 || /^[A-Za-z0-9+/=]{40,}$/.test(trimmed)) continue;
+    const firstColumn = withoutBullet.includes("|") ? withoutBullet.split("|")[0]?.trim() ?? "" : withoutBullet;
+    const firstToken = firstColumn.split(/[\s\t,]+/)[0]?.trim().toLowerCase() ?? "";
+    const cleaned = firstToken.replace(/[^\w.-]/g, "");
+    if (cleaned.length >= 2 && cleaned.length <= 64 && /^[a-z0-9][a-z0-9.-]*$/.test(cleaned) && !/^(yes|no|true|false|ok|list|auth|environment|credentials?|variables?|prompt|configured|enabled|disabled|oauth|api)$/.test(
+      cleaned
+    )) {
+      if (seen.has(cleaned)) continue;
+      seen.add(cleaned);
+      providers.push(cleaned);
+      const parentEnvVendor = isParentEnvOpencodeVendor(cleaned, trimmed);
+      if (section === "environment" || parentEnvVendor) {
+        environmentProviders.push(cleaned);
+      } else {
+        credentialProviders.push(cleaned);
+      }
+    }
+  }
+  return { credentialProviders, environmentProviders, providers };
+}
+function parseAuthListStdout(stdout) {
+  return parseAuthListSections(stdout).providers;
+}
+function parseModelsStdout(stdout) {
+  const modelIds = [];
+  const seen = /* @__PURE__ */ new Set();
+  const lines = stripAnsi(stdout).split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (/^(model|id|name|provider|available)/i.test(trimmed) && trimmed.length < 50) continue;
+    const backtickMatches = trimmed.matchAll(/`([^`]+)`/g);
+    for (const m of backtickMatches) {
+      const id = m[1]?.trim();
+      if (id && id.length >= 2 && id.length <= 128 && /^[a-zA-Z0-9][a-zA-Z0-9._/:-]*$/.test(id) && /[/-]/.test(id) && !seen.has(id)) {
+        seen.add(id);
+        modelIds.push(id);
+      }
+    }
+    const tokens = trimmed.split(/[\s\t|,]+/).map((t) => t.trim());
+    for (const token of tokens) {
+      const cleaned = token.replace(/^[-*•]\s*/, "");
+      if (cleaned.length >= 2 && cleaned.length <= 128 && /^[a-zA-Z0-9][a-zA-Z0-9._/:-]*$/.test(cleaned) && !/^(default|legacy|available|models)$/i.test(cleaned) && /[/-]/.test(cleaned)) {
+        if (!seen.has(cleaned)) {
+          seen.add(cleaned);
+          modelIds.push(cleaned);
+        }
+      }
+    }
+  }
+  return modelIds;
+}
+async function listAuthProviders(cliCommand, prefixArgs) {
+  try {
+    const result = await execa(cliCommand, [...prefixArgs ?? [], "auth", "list"], {
+      timeout: DISCOVERY_TIMEOUT_MS,
+      reject: false,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (result.exitCode !== 0) {
+      return {
+        providers: [],
+        credentialProviders: [],
+        environmentProviders: [],
+        rawOk: false,
+        unsupportedMessage: result.stderr?.trim() || `exit code ${result.exitCode}`
+      };
+    }
+    const sections = parseAuthListSections(result.stdout ?? "");
+    return { ...sections, rawOk: true };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    if (/not found|ENOENT|command not found/i.test(msg)) {
+      return {
+        providers: [],
+        credentialProviders: [],
+        environmentProviders: [],
+        rawOk: false,
+        unsupportedMessage: "OpenCode CLI not found"
+      };
+    }
+    return {
+      providers: [],
+      credentialProviders: [],
+      environmentProviders: [],
+      rawOk: false,
+      unsupportedMessage: msg.slice(0, 200)
+    };
+  }
+}
+async function listModels(cliCommand, options) {
+  const args = [...options?.prefixArgs ?? [], "models"];
+  if (options?.provider) args.push(options.provider);
+  if (options?.refresh === true) args.push("--refresh");
+  try {
+    const result = await execa(cliCommand, args, {
+      timeout: DISCOVERY_TIMEOUT_MS,
+      reject: false,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (result.exitCode !== 0) {
+      return {
+        modelIds: [],
+        rawOk: false,
+        unsupportedMessage: result.stderr?.trim() || `exit code ${result.exitCode}`
+      };
+    }
+    const modelIds = parseModelsStdout(result.stdout ?? "");
+    return { modelIds, rawOk: true };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    if (/not found|ENOENT|command not found/i.test(msg)) {
+      return { modelIds: [], rawOk: false, unsupportedMessage: "OpenCode CLI not found" };
+    }
+    return {
+      modelIds: [],
+      rawOk: false,
+      unsupportedMessage: msg.slice(0, 200)
+    };
+  }
+}
+async function getModelsDevCatalog(options) {
+  const cacheDir = options?.cacheDir ?? path.join(process.cwd(), ".poetic", "cache", "opencode");
+  const cachePath = path.join(cacheDir, MODELS_DEV_CACHE_FILENAME);
+  const readCache = async () => {
+    try {
+      const raw = await fs.readFile(cachePath, "utf-8");
+      const entry = JSON.parse(raw);
+      if (entry?.fetchedAt && entry?.data != null) return entry;
+    } catch {
+    }
+    return null;
+  };
+  if (!options?.forceRefresh) {
+    const cached = await readCache();
+    if (cached && Date.now() - cached.fetchedAt < MODELS_DEV_CACHE_TTL_MS) {
+      return { data: cached.data, source: "cache", fetchedAt: cached.fetchedAt };
+    }
+  }
+  try {
+    const res = await fetch("https://models.dev/models.json", {
+      signal: AbortSignal.timeout(8e3)
+    });
+    if (!res.ok) {
+      const cached = await readCache();
+      return cached ? { data: cached.data, source: "cache", fetchedAt: cached.fetchedAt } : null;
+    }
+    const contentLength = Number(res.headers.get("content-length") ?? "");
+    if (Number.isFinite(contentLength) && contentLength > MAX_MODELS_DEV_BYTES) {
+      const cached = await readCache();
+      return cached ? { data: cached.data, source: "cache", fetchedAt: cached.fetchedAt } : null;
+    }
+    const text = await res.text();
+    if (text.length > MAX_MODELS_DEV_BYTES) {
+      const cached = await readCache();
+      return cached ? { data: cached.data, source: "cache", fetchedAt: cached.fetchedAt } : null;
+    }
+    const data = JSON.parse(text);
+    if (!isLikelyModelsDevCatalog(data)) {
+      const cached = await readCache();
+      return cached ? { data: cached.data, source: "cache", fetchedAt: cached.fetchedAt } : null;
+    }
+    try {
+      await writeFileAtomic(
+        cachePath,
+        JSON.stringify({ data, fetchedAt: Date.now() })
+      );
+    } catch {
+    }
+    return { data, source: "network", fetchedAt: Date.now() };
+  } catch {
+    const cached = await readCache();
+    return cached ? { data: cached.data, source: "cache", fetchedAt: cached.fetchedAt } : null;
+  }
+}
+async function discoverOpencode(options) {
+  const cliInstalled = Boolean(options.cliInstalled && options.cliCommand);
+  if (!cliInstalled || !options.cliCommand) {
+    const modelsDev2 = options.includeModelsDev ? await getModelsDevCatalog({ cacheDir: options.modelsDevCacheDir }).catch(() => null) : void 0;
+    return {
+      cliInstalled: Boolean(options.cliInstalled && options.cliCommand),
+      authList: {
+        providers: [],
+        credentialProviders: [],
+        environmentProviders: [],
+        rawOk: false,
+        unsupportedMessage: "OpenCode CLI not available"
+      },
+      models: {
+        modelIds: [],
+        rawOk: false,
+        unsupportedMessage: "OpenCode CLI not available"
+      },
+      modelsDev: modelsDev2
+    };
+  }
+  const [authList, models] = await Promise.all([
+    listAuthProviders(options.cliCommand, options.prefixArgs),
+    listModels(options.cliCommand, {
+      refresh: options.refreshModels,
+      prefixArgs: options.prefixArgs
+    })
+  ]);
+  const modelsDev = options.includeModelsDev ? await getModelsDevCatalog({ cacheDir: options.modelsDevCacheDir }).catch(() => null) : void 0;
+  return {
+    cliInstalled: true,
+    authList,
+    models,
+    modelsDev
+  };
+}
+
+export {
+  isParentEnvOpencodeVendor,
+  credentialProvidersFromAuthList,
+  parseAuthListSections,
+  parseAuthListStdout,
+  parseModelsStdout,
+  listAuthProviders,
+  listModels,
+  getModelsDevCatalog,
+  discoverOpencode
+};
+//# sourceMappingURL=chunk-IC7I6YIJ.js.map

package/dist/chunk-IDCSOZVN.js

@@ -0,0 +1,78 @@
+// src/cli/handlers/shared/readiness-diagnostics.ts
+import { appendFile, mkdir } from "fs/promises";
+import path from "path";
+var ENV_PRESENCE_KEYS = [
+  // Grok-specific (the immediate motivation)
+  "XAI_API_KEY",
+  "GROK_CODE_XAI_API_KEY",
+  "POETIC_GROK_ALLOW_BROWSER_AUTH",
+  "POETIC_GROK_AUTH_PROBE_TIMEOUT_MS",
+  // General readiness/auth bypasses that materially change probe outcomes
+  "POETIC_SKIP_AUTH",
+  "POETIC_SKIP_READINESS",
+  "POETIC_SKIP_TOOLING_CHECKS",
+  "POETIC_E2E_TEST",
+  "POETIC_MOCK_PROVIDERS"
+];
+function buildEnvPresence(env = process.env) {
+  const presence = {};
+  for (const key of ENV_PRESENCE_KEYS) {
+    const value = env[key];
+    presence[key] = typeof value === "string" && value.trim().length > 0;
+  }
+  return presence;
+}
+function resolveLogsDir(poeticRoot) {
+  const now = /* @__PURE__ */ new Date();
+  const year = now.getUTCFullYear().toString().padStart(4, "0");
+  const month = (now.getUTCMonth() + 1).toString().padStart(2, "0");
+  return path.join(poeticRoot, ".poetic", "telemetry", "logs", `${year}-${month}`);
+}
+function buildRecord(readiness, context) {
+  const record = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    event: "readiness_diagnostic",
+    phase: context.phase,
+    provider: readiness.provider,
+    displayName: readiness.displayName,
+    authenticated: readiness.authenticated,
+    ready: readiness.ready,
+    attemptEligible: readiness.attemptEligible === true,
+    envPresence: buildEnvPresence(context.env)
+  };
+  if (context.authProbeMode) record.authProbeMode = context.authProbeMode;
+  if (context.cliProbeMode) record.cliProbeMode = context.cliProbeMode;
+  if (typeof readiness.sandboxCapable === "boolean") {
+    record.sandboxCapable = readiness.sandboxCapable;
+  }
+  if (readiness.sandboxReason) record.sandboxReason = readiness.sandboxReason;
+  if (Array.isArray(readiness.sandboxDeniedPaths) && readiness.sandboxDeniedPaths.length > 0) {
+    record.sandboxDeniedPaths = [...readiness.sandboxDeniedPaths];
+  }
+  if (typeof readiness.installed === "boolean") record.installed = readiness.installed;
+  if (typeof readiness.cliHealthy === "boolean") record.cliHealthy = readiness.cliHealthy;
+  if (readiness.reason) record.reason = readiness.reason;
+  if (readiness.warning) record.warning = readiness.warning;
+  if (readiness.command) record.command = readiness.command;
+  if (Array.isArray(readiness.prefixArgs) && readiness.prefixArgs.length > 0) {
+    record.prefixArgs = [...readiness.prefixArgs];
+  }
+  return record;
+}
+async function recordReadinessDiagnostic(readiness, context) {
+  try {
+    const poeticRoot = context.poeticRoot ?? process.cwd();
+    const logsDir = resolveLogsDir(poeticRoot);
+    await mkdir(logsDir, { recursive: true });
+    const filePath = path.join(logsDir, "readiness-diagnostics.jsonl");
+    const record = buildRecord(readiness, context);
+    await appendFile(filePath, `${JSON.stringify(record)}
+`, "utf8");
+  } catch {
+  }
+}
+
+export {
+  recordReadinessDiagnostic
+};
+//# sourceMappingURL=chunk-IDCSOZVN.js.map

package/dist/chunk-IFCBYECK.js

@@ -0,0 +1,112 @@
+import {
+  normalizePath
+} from "./chunk-ZIPWI2LY.js";
+
+// src/automation/flywheel-stage-targets.ts
+import { access } from "fs/promises";
+import { join } from "path";
+function normalizeExactFileEntries(entries) {
+  if (!Array.isArray(entries) || entries.length === 0) {
+    return [];
+  }
+  return Array.from(
+    new Set(
+      entries.filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => normalizeRepoRelativeStageTarget(value)).filter((value) => value !== null && !value.endsWith("/"))
+    )
+  );
+}
+function collectPromptDeclaredStageTargets(prompt) {
+  if (typeof prompt !== "string" || prompt.trim().length === 0) {
+    return [];
+  }
+  const declared = [];
+  const pattern = /^\s*FILE:\s+(\S+)/gm;
+  let match;
+  while ((match = pattern.exec(prompt)) !== null) {
+    const candidate = normalizePath(match[1] ?? "");
+    if (candidate.length > 0) {
+      declared.push(candidate);
+    }
+  }
+  return Array.from(new Set(declared));
+}
+function normalizeRepoRelativeStageTarget(value) {
+  const normalized = normalizePath(value);
+  if (normalized.length === 0) return null;
+  if (normalized.startsWith("/") || normalized === ".." || normalized.startsWith("../"))
+    return null;
+  if (normalized === "node_modules" || normalized.startsWith("node_modules/")) return null;
+  if (normalized.includes("/node_modules/")) return null;
+  return normalized;
+}
+function shouldFallbackToPromptDeclaredTargets(stage) {
+  if (typeof stage.prompt !== "string" || stage.prompt.trim().length === 0) {
+    return false;
+  }
+  const executionIntent = stage.capabilities?.executionIntent;
+  return stage.capabilities?.modifiesFiles === true || executionIntent === "edit";
+}
+function collectRequiredStageFiles(stage) {
+  return normalizeExactFileEntries(stage.validation?.requiredFiles);
+}
+async function evaluateRequiredStageFiles(options) {
+  const requiredFiles = collectRequiredStageFiles(options.stage);
+  const normalizedChangedFiles = Array.isArray(options.changedFiles) ? new Set(
+    options.changedFiles.filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => normalizePath(value))
+  ) : void 0;
+  const missingFiles = [];
+  const untouchedFiles = [];
+  for (const file of requiredFiles) {
+    try {
+      await access(join(options.worktreePath, file));
+    } catch {
+      missingFiles.push(file);
+      continue;
+    }
+    if (normalizedChangedFiles && !normalizedChangedFiles.has(file)) {
+      untouchedFiles.push(file);
+    }
+  }
+  return {
+    requiredFiles,
+    missingFiles,
+    untouchedFiles,
+    passed: missingFiles.length === 0 && untouchedFiles.length === 0,
+    changedFilesTracked: Boolean(normalizedChangedFiles)
+  };
+}
+function collectDeclaredStageTargets(stage) {
+  const declared = [];
+  if (Array.isArray(stage.allowlist) && stage.allowlist.length > 0) {
+    declared.push(...stage.allowlist);
+  }
+  if (Array.isArray(stage.validation?.requiredFiles) && stage.validation.requiredFiles.length > 0) {
+    declared.push(...stage.validation.requiredFiles);
+  }
+  if (Array.isArray(stage.specHarness?.targetFiles) && stage.specHarness.targetFiles.length > 0) {
+    declared.push(...stage.specHarness.targetFiles);
+  }
+  if (stage.validation?.checks) {
+    for (const check of stage.validation.checks) {
+      if ("path" in check && typeof check.path === "string" && check.path.trim().length > 0) {
+        declared.push(check.path);
+      }
+    }
+  }
+  if (declared.length === 0 && shouldFallbackToPromptDeclaredTargets(stage)) {
+    declared.push(...collectPromptDeclaredStageTargets(stage.prompt));
+  }
+  return Array.from(
+    new Set(
+      declared.filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => normalizeRepoRelativeStageTarget(value)).filter((value) => value !== null)
+    )
+  );
+}
+
+export {
+  normalizeRepoRelativeStageTarget,
+  collectRequiredStageFiles,
+  evaluateRequiredStageFiles,
+  collectDeclaredStageTargets
+};
+//# sourceMappingURL=chunk-IFCBYECK.js.map

package/dist/chunk-IFZCPEY2.js

@@ -0,0 +1,66 @@
+import {
+  getDefaultPaths
+} from "./chunk-UUH2RVKS.js";
+import {
+  resolvePoeticRoot
+} from "./chunk-LEIIWPWQ.js";
+
+// src/utils/storage-access.ts
+import { existsSync } from "fs";
+import path from "path";
+import BetterSqlite3 from "better-sqlite3";
+var STORAGE_ACCESS_ERROR_CODES = /* @__PURE__ */ new Set(["ENOENT", "EACCES", "EPERM"]);
+function resolveConfiguredTelemetryDbPath() {
+  const configuredPath = getDefaultPaths().telemetryDb;
+  if (path.isAbsolute(configuredPath)) {
+    return configuredPath;
+  }
+  return path.join(resolvePoeticRoot(), configuredPath);
+}
+function openConfiguredTelemetryDb(options = {}) {
+  const dbPath = resolveConfiguredTelemetryDbPath();
+  const readonly = options.writable !== true;
+  if (!existsSync(dbPath)) {
+    return {
+      db: null,
+      dbPath,
+      error: describeStorageAccessFailure({ code: "ENOENT" }, "Telemetry database")
+    };
+  }
+  try {
+    const db = new BetterSqlite3(dbPath, { readonly });
+    db.prepare("SELECT 1").get();
+    return { db, dbPath };
+  } catch (error) {
+    return {
+      db: null,
+      dbPath,
+      error: isStorageAccessError(error) ? describeStorageAccessFailure(error, "Telemetry database") : error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function isStorageAccessError(error) {
+  const code = error?.code;
+  return typeof code === "string" && STORAGE_ACCESS_ERROR_CODES.has(code);
+}
+function describeStorageAccessFailure(error, resourceLabel) {
+  const code = error?.code;
+  if (code === "ENOENT") {
+    return `${resourceLabel} not found`;
+  }
+  if (code === "EACCES" || code === "EPERM") {
+    return `${resourceLabel} is not readable`;
+  }
+  if (error instanceof Error && error.message.trim().length > 0) {
+    return `${resourceLabel} is unavailable: ${error.message}`;
+  }
+  return `${resourceLabel} is unavailable`;
+}
+
+export {
+  resolveConfiguredTelemetryDbPath,
+  openConfiguredTelemetryDb,
+  isStorageAccessError,
+  describeStorageAccessFailure
+};
+//# sourceMappingURL=chunk-IFZCPEY2.js.map

package/dist/chunk-IKFP2KUR.js

@@ -0,0 +1,48 @@
+// src/core/providers/dry-run-store.ts
+import fs from "fs";
+import path from "path";
+var DEFAULT_DRY_RUN_TTL_MS = 24 * 60 * 60 * 1e3;
+function resolvePoeticDir(poeticDirOrRepoRoot) {
+  const resolved = path.resolve(poeticDirOrRepoRoot);
+  return path.basename(resolved) === ".poetic" ? resolved : path.join(resolved, ".poetic");
+}
+function resolveDryRunStorePath(poeticDirOrRepoRoot) {
+  return path.join(resolvePoeticDir(poeticDirOrRepoRoot), "state", "provider-dry-runs.json");
+}
+function readStoreFile(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && parsed.providers && typeof parsed.providers === "object") {
+      return { version: 1, providers: parsed.providers };
+    }
+  } catch {
+  }
+  return { version: 1, providers: {} };
+}
+function readDryRunFreshness(providerId, options) {
+  const now = options.now ?? Date.now;
+  const ttlMs = options.ttlMs ?? DEFAULT_DRY_RUN_TTL_MS;
+  const file = readStoreFile(options.filePath);
+  const record = file.providers[providerId];
+  if (!record || typeof record.lastSuccessMs !== "number") {
+    return void 0;
+  }
+  const age = now() - record.lastSuccessMs;
+  return {
+    lastSuccessMs: record.lastSuccessMs,
+    fresh: age >= 0 && age < ttlMs
+  };
+}
+function readProviderDryRunFreshness(providerId, poeticDirOrRepoRoot, options = {}) {
+  return readDryRunFreshness(providerId, {
+    filePath: resolveDryRunStorePath(poeticDirOrRepoRoot),
+    ...options.ttlMs !== void 0 ? { ttlMs: options.ttlMs } : {},
+    ...options.now ? { now: options.now } : {}
+  });
+}
+
+export {
+  readProviderDryRunFreshness
+};
+//# sourceMappingURL=chunk-IKFP2KUR.js.map