@dadado/agent-kit-cli 5.15.0 → 5.16.0

package/dist/chunk-KD2MYBB6.js

@@ -0,0 +1,213 @@
+import {
+  HANDOFF_REL
+} from "./chunk-5VCOWTTP.js";
+import {
+  ensureDir
+} from "./chunk-77V75A7O.js";
+
+// src/plan-index/plan-index.ts
+import { readFile, writeFile } from "fs/promises";
+import path from "path";
+var PLAN_INDEX_REL = ".cursor/context/plan-index.json";
+var NONE = /^(none|n\/a|empty|nil)$/i;
+var OPEN_STATUSES = /* @__PURE__ */ new Set(["pending", "in_progress"]);
+var DONE_STATUSES = /* @__PURE__ */ new Set(["completed", "cancelled"]);
+function defaultPlanIndexIo() {
+  return {
+    async readFile(absPath) {
+      try {
+        return await readFile(absPath, "utf8");
+      } catch {
+        return null;
+      }
+    },
+    async writeFile(absPath, body) {
+      await ensureDir(path.dirname(absPath));
+      await writeFile(absPath, body, "utf8");
+    }
+  };
+}
+function extractHandoffNamedPlans(handoffText) {
+  return {
+    active: extractActivePlan(handoffText),
+    backlog: extractPlanBasenames(
+      extractFieldBlock(handoffText, "Backlog plans") ?? extractFieldBlock(handoffText, "Backlog")
+    ),
+    parked: extractPlanBasenames(extractFieldBlock(handoffText, "Parked plans")),
+    runQueue: extractPlanBasenames(extractFieldBlock(handoffText, "Run queue"))
+  };
+}
+function collectNamedPlanBasenames(named) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const file of [named.active, ...named.backlog, ...named.parked, ...named.runQueue]) {
+    if (!file || seen.has(file)) continue;
+    seen.add(file);
+    out.push(file);
+  }
+  return out;
+}
+function namedPlanCandidatePaths(root, basename) {
+  const safe = path.basename(basename);
+  if (!/^[A-Za-z0-9._-]+\.plan\.md$/i.test(safe)) return [];
+  return [
+    path.join(root, ".cursor", "plans", safe),
+    path.join(root, ".cursor", "plans", "archive", safe)
+  ];
+}
+function classifyPlanRole(file, named, openTodos) {
+  if (named.active === file) return "active";
+  if (named.backlog.includes(file)) return "backlog";
+  if (named.parked.includes(file)) return "parked";
+  if (openTodos) return "pending";
+  return null;
+}
+function parsePlanFrontmatter(raw) {
+  const match = raw.replace(/\r\n/g, "\n").match(/^---\n([\s\S]*?)\n---/);
+  if (!match?.[1]) return { todos: [] };
+  const block = match[1];
+  const name = block.match(/^name:\s*(.+)$/m)?.[1]?.trim();
+  const todos = [];
+  let currentId;
+  let currentContent;
+  for (const line of block.split("\n")) {
+    const idMatch = line.match(/^\s*- id:\s*(\S+)/);
+    if (idMatch?.[1]) {
+      currentId = idMatch[1].replace(/^["']|["']$/g, "");
+      currentContent = void 0;
+      continue;
+    }
+    const contentMatch = line.match(/^\s*content:\s*(.+)$/);
+    if (contentMatch?.[1] && currentId) {
+      currentContent = contentMatch[1].trim();
+      continue;
+    }
+    const statusMatch = line.match(/^\s*status:\s*(\S+)/);
+    if (statusMatch?.[1] && currentId) {
+      const todo = { id: currentId, status: statusMatch[1] };
+      if (currentContent !== void 0) todo.content = currentContent;
+      todos.push(todo);
+      currentId = void 0;
+      currentContent = void 0;
+    }
+  }
+  return { name, todos };
+}
+async function buildPlanIndex(root, io = defaultPlanIndexIo(), now = () => /* @__PURE__ */ new Date()) {
+  const handoffPath = path.join(root, HANDOFF_REL);
+  const handoffText = await io.readFile(handoffPath) ?? "";
+  const named = extractHandoffNamedPlans(handoffText);
+  const plans = [];
+  for (const file of collectNamedPlanBasenames(named)) {
+    const text = await readNamedPlanFile(root, file, io);
+    const fm = text ? parsePlanFrontmatter(text) : { todos: [] };
+    const pendingTodoIds = fm.todos.filter((t) => OPEN_STATUSES.has(t.status)).map((t) => t.id);
+    const openTodos = pendingTodoIds.length > 0;
+    const role = classifyPlanRole(file, named, openTodos);
+    if (!role) continue;
+    const exhausted = text !== null && fm.todos.length > 0 && fm.todos.every((t) => DONE_STATUSES.has(t.status));
+    const entry = {
+      file,
+      role,
+      openTodos,
+      pendingTodoIds,
+      exhausted
+    };
+    if (fm.name) entry.name = fm.name;
+    if (!text) entry.missing = true;
+    plans.push(entry);
+  }
+  return {
+    generatedAt: now().toISOString(),
+    source: "handoff-named",
+    plans
+  };
+}
+async function writePlanIndex(root, io = defaultPlanIndexIo(), now = () => /* @__PURE__ */ new Date()) {
+  const index = await buildPlanIndex(root, io, now);
+  const dest = path.join(root, PLAN_INDEX_REL);
+  const write = io.writeFile ?? defaultPlanIndexIo().writeFile;
+  if (write) {
+    await write(dest, `${JSON.stringify(index, null, 2)}
+`);
+  }
+  return index;
+}
+function formatPlanIndexLines(index) {
+  const lines = index.plans.filter((p) => !p.exhausted).map((p) => {
+    const open = p.openTodos ? ` (${p.pendingTodoIds.length} open)` : "";
+    return `- ${p.role}: \`${p.file}\`${open}`;
+  });
+  const exhausted = index.plans.filter((p) => p.exhausted).map((p) => `\`${p.file}\``);
+  if (exhausted.length > 0) lines.push(`- exhausted (retire): ${exhausted.join(", ")}`);
+  return lines;
+}
+function formatPlanIndexSection(index) {
+  if (index.plans.length === 0) return null;
+  return `## Pending plans (index)
+
+${formatPlanIndexLines(index).join("\n")}`;
+}
+async function readNamedPlanFile(root, basename, io) {
+  for (const candidate of namedPlanCandidatePaths(root, basename)) {
+    const text = await io.readFile(candidate);
+    if (text !== null) return text;
+  }
+  return null;
+}
+function extractActivePlan(content) {
+  const match = content.match(/^- \*\*Plan:\*\*\s*(.+)$/m);
+  if (!match?.[1]) return null;
+  let raw = match[1].trim();
+  const tick = raw.match(/^`([^`]+)`/);
+  if (tick?.[1]) raw = tick[1].trim();
+  if (!raw || NONE.test(raw)) return null;
+  return raw.match(/([A-Za-z0-9._-]+\.plan\.md)/i)?.[1] ?? null;
+}
+function extractFieldBlock(content, label) {
+  const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const re = new RegExp(`^- \\*\\*${escaped}:\\*\\*\\s*(.*)$`, "m");
+  const match = content.match(re);
+  if (!match) return null;
+  const chunks = [];
+  const same = (match[1] ?? "").trim();
+  if (same) chunks.push(same);
+  const after = content.slice((match.index ?? 0) + match[0].length);
+  for (const line of after.split("\n")) {
+    if (/^- \*\*[^*:\n]+:\*\*/.test(line)) break;
+    if (!line.trim()) continue;
+    if (/^\s+\S/.test(line)) {
+      chunks.push(line.trim());
+      continue;
+    }
+    break;
+  }
+  return chunks.join("\n").trim() || null;
+}
+function extractPlanBasenames(raw) {
+  if (!raw) return [];
+  const text = raw.trim().replace(/^\[/, "").replace(/\]\s*$/, "");
+  const ids = [];
+  const seen = /* @__PURE__ */ new Set();
+  const ticks = [...text.matchAll(/`([^`]+)`/g)].map((m) => m[1]);
+  const parts = ticks.length > 0 ? ticks : text.split(/[,;\n]/);
+  for (const part of parts) {
+    const cleaned = String(part).replace(/\(.*?\)/g, "").trim().replace(/^-\s*/, "").replace(/^\[/, "").replace(/\]$/, "").replace(/^plans\//, "");
+    if (!cleaned || NONE.test(cleaned)) continue;
+    const base = cleaned.split("/").pop();
+    if (!base || !/\.plan\.md$/i.test(base) || seen.has(base)) continue;
+    seen.add(base);
+    ids.push(base);
+  }
+  return ids;
+}
+
+export {
+  extractHandoffNamedPlans,
+  namedPlanCandidatePaths,
+  parsePlanFrontmatter,
+  writePlanIndex,
+  formatPlanIndexLines,
+  formatPlanIndexSection,
+  extractFieldBlock
+};

package/dist/chunk-KI6ZHBPV.js

@@ -0,0 +1,332 @@
+import {
+  createReadinessReport
+} from "./chunk-PNFF6OU3.js";
+import {
+  KIT_OWNED_IGNORE_PATTERNS,
+  REPOSITORY_PROFILE_REL,
+  REQUIRED_SECRET_PATTERNS,
+  detectGitDirty,
+  runScanner
+} from "./chunk-ZCTSUQRR.js";
+import {
+  CONTEXT_CONFIG_REL,
+  contextConfigPath
+} from "./chunk-NQ7IQ5XT.js";
+import {
+  ensureDir,
+  fileExists,
+  readJson,
+  writeJson
+} from "./chunk-77V75A7O.js";
+
+// src/scanner/safe-fixes.ts
+import { readFile, writeFile } from "fs/promises";
+import path from "path";
+var CONTEXT_CONFIG_REL_POSIX = CONTEXT_CONFIG_REL.replace(/\\/g, "/");
+var ESSENTIAL_DIRECTORIES = [
+  ".cursor",
+  ".cursor/context",
+  ".cursor/context/current",
+  ".cursor/context/backups",
+  ".cursor/plans",
+  ".cursor/memory"
+];
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeMissing(existing, defaults) {
+  if (!isObject(existing) || !isObject(defaults)) return existing ?? defaults;
+  const merged = { ...existing };
+  for (const [key, value] of Object.entries(defaults)) {
+    merged[key] = key in existing ? mergeMissing(existing[key], value) : value;
+  }
+  return merged;
+}
+function jsonEqual(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function relativeEvidence(relativePath, detail) {
+  return [`${relativePath}: ${detail}`];
+}
+function createProfile(scan, report, generatedAt) {
+  const git = {
+    mode: scan.git.mode,
+    workflow: scan.git.workflow,
+    remotes: scan.git.remotes,
+    remoteUrl: scan.git.remoteUrl,
+    remoteName: scan.git.remoteName,
+    currentBranch: scan.git.currentBranch,
+    defaultBranch: scan.git.defaultBranch,
+    isDirty: scan.git.isDirty,
+    hasLocalStaging: scan.git.hasLocalStaging,
+    hasRemoteStaging: scan.git.hasRemoteStaging
+  };
+  if (scan.git.providerConfidence === "high") {
+    git.provider = scan.git.provider;
+    git.providerKind = scan.git.providerKind;
+    git.providerConfidence = scan.git.providerConfidence;
+    git.providerEvidence = scan.git.providerEvidence;
+  }
+  return {
+    schemaVersion: 1,
+    contractVersion: 1,
+    purpose: scan.purpose,
+    stack: scan.stack,
+    git,
+    infra: scan.infra,
+    services: scan.services,
+    context: scan.context,
+    detection: {
+      generatedAt,
+      repositoryFingerprint: report.repositoryFingerprint,
+      providerConfidence: scan.git.providerConfidence,
+      providerEvidence: scan.git.providerEvidence
+    }
+  };
+}
+function createOnboardingState(report, generatedAt, deferredItems = report.deferredChecks) {
+  const validDeferredCheckIds = new Set(
+    deferredItems.filter((item) => item.reason.trim().length > 0).map((item) => item.checkId)
+  );
+  const unresolvedEssential = report.pillars.flatMap((pillar) => pillar.checks).some((check) => {
+    if (!check.essential || check.status === "ready") return false;
+    if (check.status === "blocked") return true;
+    if (!validDeferredCheckIds.has(check.id)) return true;
+    return check.actions.length > 0;
+  });
+  return {
+    contractVersion: 1,
+    status: unresolvedEssential ? "in_progress" : "completed",
+    updatedAt: generatedAt,
+    checks: Object.fromEntries(
+      report.pillars.flatMap((pillar) => pillar.checks).map((check) => [
+        check.id,
+        {
+          status: check.status,
+          essential: check.essential,
+          evidence: check.evidence
+        }
+      ])
+    ),
+    deferredItems
+  };
+}
+function validDeferredItems(value, fallback) {
+  if (!Array.isArray(value)) return fallback;
+  return value.filter(
+    (item) => isObject(item) && typeof item.checkId === "string" && typeof item.reason === "string" && (item.recoveryCommand === void 0 || typeof item.recoveryCommand === "string")
+  );
+}
+function reconcileOnboardingState(report, existingConfig, generatedAt) {
+  const existing = isObject(existingConfig.onboarding) ? existingConfig.onboarding : {};
+  const deferredItems = validDeferredItems(existing.deferredItems, report.deferredChecks);
+  const derived = createOnboardingState(report, generatedAt, deferredItems);
+  const candidate = {
+    ...existing,
+    ...derived
+  };
+  const { updatedAt: _candidateUpdatedAt, ...candidateState } = candidate;
+  const { updatedAt: existingUpdatedAt, ...existingState } = existing;
+  candidate.updatedAt = jsonEqual(candidateState, existingState) && typeof existingUpdatedAt === "string" ? existingUpdatedAt : generatedAt;
+  return candidate;
+}
+function preferenceDefaults(onboarding, onboarded) {
+  return {
+    onboarded: onboarded === true,
+    onboarding,
+    externalPlanReview: {
+      enabled: false,
+      backend: "claude",
+      autoRemediate: false,
+      offerOnExhausted: true,
+      mode: "paste",
+      midBatchAudits: false,
+      preflight: "off"
+    },
+    autoHandoff: false,
+    agentPersona: {
+      default: "autopilot",
+      modes: {
+        "continue-plan": "autopilot",
+        "run-plan": "night-shift",
+        "cli-run-plan": "ghost-runner"
+      }
+    }
+  };
+}
+function mergeIgnorePatterns(existing, patterns) {
+  const activeLines = new Set(
+    existing.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"))
+  );
+  const missing = patterns.filter((pattern) => !activeLines.has(pattern));
+  if (missing.length === 0) return existing;
+  const prefix = existing.length === 0 ? "" : existing.endsWith("\n") ? existing : `${existing}
+`;
+  return `${prefix}${missing.join("\n")}
+`;
+}
+function mergeSecretIgnores(existing) {
+  return mergeIgnorePatterns(existing, REQUIRED_SECRET_PATTERNS);
+}
+function mergeKitOwnedIgnores(existing) {
+  return mergeIgnorePatterns(existing, KIT_OWNED_IGNORE_PATTERNS);
+}
+function recordChange(changes, id, relativePath, changed, dryRun, evidence) {
+  changes.push({
+    id,
+    path: relativePath,
+    status: changed ? dryRun ? "planned" : "applied" : "skipped",
+    evidence
+  });
+}
+function appliedActions(changes) {
+  return changes.filter((change) => change.status === "applied").map((change) => ({
+    id: change.id,
+    status: "ready",
+    recommendation: `Applied safe local change to ${change.path}`,
+    owner: "system"
+  }));
+}
+function withoutGeneratedAtForComparison(profile) {
+  const { generatedAt: _generatedAt, ...detection } = isObject(profile.detection) ? profile.detection : {};
+  return { ...profile, detection };
+}
+function reconcileFreshOverExisting(desired, existing) {
+  const merged = { ...existing };
+  for (const [key, value] of Object.entries(desired)) {
+    const existingValue = existing[key];
+    merged[key] = isObject(value) && isObject(existingValue) ? reconcileFreshOverExisting(value, existingValue) : value;
+  }
+  return merged;
+}
+async function refreshRepositoryProfile(rootDir, options) {
+  const generatedAt = options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const scan = await runScanner(rootDir);
+  const report = createReadinessReport(scan, {
+    generatorVersion: options.generatorVersion,
+    generatedAt
+  });
+  const desiredProfile = createProfile(scan, report, generatedAt);
+  const profilePath = path.join(scan.rootDir, REPOSITORY_PROFILE_REL);
+  const existingProfile = await readJson(profilePath) ?? {};
+  const reconciled = reconcileFreshOverExisting(desiredProfile, existingProfile);
+  const meaningfulChange = !jsonEqual(
+    withoutGeneratedAtForComparison(existingProfile),
+    withoutGeneratedAtForComparison(reconciled)
+  );
+  if (!meaningfulChange) {
+    return { changed: false, profile: existingProfile };
+  }
+  await writeJson(profilePath, reconciled);
+  return { changed: true, profile: reconciled };
+}
+async function executeSafeReadinessFixes(rootDir, options) {
+  const dryRun = options.dryRun ?? false;
+  const generatedAt = options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const beforeScan = await runScanner(rootDir);
+  const before = createReadinessReport(beforeScan, {
+    generatorVersion: options.generatorVersion,
+    generatedAt
+  });
+  const changes = [];
+  for (const relativePath of ESSENTIAL_DIRECTORIES) {
+    const absolutePath = path.join(beforeScan.rootDir, relativePath);
+    const exists = await fileExists(absolutePath);
+    if (!exists && !dryRun) await ensureDir(absolutePath);
+    recordChange(
+      changes,
+      "ensure-agent-kit-directory",
+      relativePath,
+      !exists,
+      dryRun,
+      relativeEvidence(relativePath, exists ? "already exists" : "missing directory")
+    );
+  }
+  const gitignoreRelativePath = ".gitignore";
+  const gitignorePath = path.join(beforeScan.rootDir, gitignoreRelativePath);
+  const existingGitignore = await fileExists(gitignorePath) ? await readFile(gitignorePath, "utf8") : "";
+  const gitignoreAfterSecrets = mergeSecretIgnores(existingGitignore);
+  const secretsChanged = gitignoreAfterSecrets !== existingGitignore;
+  const mergedGitignore = mergeKitOwnedIgnores(gitignoreAfterSecrets);
+  const gitignoreChanged = mergedGitignore !== existingGitignore;
+  const kitOwnedChanged = mergedGitignore !== gitignoreAfterSecrets;
+  if (gitignoreChanged && !dryRun) await writeFile(gitignorePath, mergedGitignore, "utf8");
+  recordChange(
+    changes,
+    "merge-secret-ignores",
+    gitignoreRelativePath,
+    secretsChanged,
+    dryRun,
+    relativeEvidence(
+      gitignoreRelativePath,
+      secretsChanged ? "required secret patterns are missing" : "required patterns are present"
+    )
+  );
+  recordChange(
+    changes,
+    "merge-kit-owned-ignores",
+    gitignoreRelativePath,
+    kitOwnedChanged,
+    dryRun,
+    relativeEvidence(
+      gitignoreRelativePath,
+      kitOwnedChanged ? "kit-owned session/derived paths are missing" : "kit-owned session/derived paths are present"
+    )
+  );
+  const profilePath = path.join(beforeScan.rootDir, REPOSITORY_PROFILE_REL);
+  const existingProfile = await readJson(profilePath) ?? {};
+  const desiredProfile = createProfile(beforeScan, before, generatedAt);
+  const mergedProfile = mergeMissing(existingProfile, desiredProfile);
+  const profileChanged = !jsonEqual(existingProfile, mergedProfile);
+  if (profileChanged && !dryRun) await writeJson(profilePath, mergedProfile);
+  recordChange(
+    changes,
+    "merge-repository-profile",
+    REPOSITORY_PROFILE_REL,
+    profileChanged,
+    dryRun,
+    relativeEvidence(
+      REPOSITORY_PROFILE_REL,
+      profileChanged ? "missing scanner-derived facts" : "existing facts preserved"
+    )
+  );
+  const evidenceScan = dryRun ? beforeScan : await runScanner(beforeScan.rootDir);
+  const evidenceReport = createReadinessReport(evidenceScan, {
+    generatorVersion: options.generatorVersion,
+    generatedAt
+  });
+  const configPath = contextConfigPath(beforeScan.rootDir);
+  const existingContextConfig = await readJson(configPath) ?? {};
+  const onboarding = reconcileOnboardingState(evidenceReport, existingContextConfig, generatedAt);
+  const defaults = preferenceDefaults(onboarding, existingContextConfig.onboarded);
+  const mergedContextConfig = mergeMissing(existingContextConfig, defaults);
+  mergedContextConfig.onboarding = onboarding;
+  const contextConfigChanged = !jsonEqual(existingContextConfig, mergedContextConfig);
+  if (contextConfigChanged && !dryRun) await writeJson(configPath, mergedContextConfig);
+  recordChange(
+    changes,
+    "merge-onboarding-state",
+    CONTEXT_CONFIG_REL_POSIX,
+    contextConfigChanged,
+    dryRun,
+    relativeEvidence(
+      CONTEXT_CONFIG_REL_POSIX,
+      contextConfigChanged ? "missing preferences or onboarding state" : "state already merged"
+    )
+  );
+  const afterScan = contextConfigChanged && !dryRun && evidenceScan.git.mode !== "none" ? {
+    ...evidenceScan,
+    git: { ...evidenceScan.git, isDirty: await detectGitDirty(evidenceScan.rootDir) }
+  } : evidenceScan;
+  const after = createReadinessReport(afterScan, {
+    generatorVersion: options.generatorVersion,
+    generatedAt
+  });
+  after.appliedSafeFixes = appliedActions(changes);
+  return { dryRun, changes, before, after };
+}
+
+export {
+  refreshRepositoryProfile,
+  executeSafeReadinessFixes
+};

package/dist/chunk-MAPOQEA2.js

@@ -0,0 +1,43 @@
+// src/generator/claude-permissions.ts
+var SHARED_DENY_RULES = [
+  "Bash(git push * main)",
+  "Bash(git push * main *)",
+  "Bash(git push *:main*)",
+  "Bash(git push *+main*)",
+  "Bash(git push *refs/heads/main*)",
+  "Bash(git push * master)",
+  "Bash(git push * master *)",
+  "Bash(git push *:master*)",
+  "Bash(git push *+master*)",
+  "Bash(git push *refs/heads/master*)",
+  "Bash(git push * @)",
+  "Bash(git push --force*)",
+  "Bash(git push * --force*)",
+  "Bash(git push -f*)",
+  "Bash(git push * -f*)",
+  "Bash(git push *--no-veri*)",
+  "Bash(git push * +*)",
+  // Any git global option before a push token (-C, -c, -P, --no-pager, --config-env, ...).
+  "Bash(git -* push*)"
+];
+var HEADLESS_ONLY_DENY_RULES = [
+  "Bash(ALLOW_MAIN_PUSH=*)",
+  "Skill(git-prod)",
+  "Skill(kit-prod)",
+  "Edit(.cursor/hooks/**)",
+  "Write(.cursor/hooks/**)",
+  "Edit(.claude/settings.json)",
+  "Write(.claude/settings.json)",
+  "Edit(packages/cli/dist/**)",
+  "Write(packages/cli/dist/**)"
+];
+var HEADLESS_DENY_RULES = [
+  ...SHARED_DENY_RULES,
+  ...HEADLESS_ONLY_DENY_RULES
+];
+var INTERACTIVE_DENY_RULES = [...SHARED_DENY_RULES];
+
+export {
+  HEADLESS_DENY_RULES,
+  INTERACTIVE_DENY_RULES
+};

package/dist/chunk-NQ7IQ5XT.js

@@ -0,0 +1,26 @@
+import {
+  readJson
+} from "./chunk-77V75A7O.js";
+
+// src/lifecycle/context-config.ts
+import path from "path";
+var CONTEXT_CONFIG_REL = path.join(".cursor", "context", "config.json");
+function contextConfigPath(cwd) {
+  return path.join(cwd, CONTEXT_CONFIG_REL);
+}
+async function loadContextConfig(cwd) {
+  return readJson(contextConfigPath(cwd));
+}
+function intervalElapsed(lastCheckedAt, intervalDays) {
+  if (!lastCheckedAt) return true;
+  const last = Date.parse(lastCheckedAt);
+  if (Number.isNaN(last)) return true;
+  return Date.now() - last >= intervalDays * 24 * 60 * 60 * 1e3;
+}
+
+export {
+  CONTEXT_CONFIG_REL,
+  contextConfigPath,
+  loadContextConfig,
+  intervalElapsed
+};