@lumenflow/cli 3.14.0 → 3.15.0

package/dist/chunk-QFSTL4J3.js

@@ -0,0 +1,276 @@
+import {
+  DEFAULT_HALF_LIFE_MS,
+  computeDecayScore
+} from "./chunk-ZE473AO6.js";
+import {
+  MEMORY_FILE_NAME,
+  loadMemory,
+  loadMemoryAll
+} from "./chunk-DFR4DJBM.js";
+import {
+  LUMENFLOW_MEMORY_PATHS
+} from "./chunk-4N74J3UT.js";
+import {
+  ErrorCodes,
+  createError
+} from "./chunk-RXRKBBSM.js";
+
+// ../memory/dist/decay/archival.js
+import fs from "fs/promises";
+import path from "path";
+var DEFAULT_DECAY_THRESHOLD = 0.1;
+var ARCHIVED_STATUS = "archived";
+var PROTECTED_LIFECYCLE = "project";
+function isArchived(node) {
+  return node.metadata?.status === ARCHIVED_STATUS;
+}
+function isProtected(node) {
+  return node.lifecycle === PROTECTED_LIFECYCLE;
+}
+function markAsArchived(node, score, threshold, now) {
+  const timestamp = new Date(now).toISOString();
+  return {
+    ...node,
+    metadata: {
+      ...node.metadata,
+      status: ARCHIVED_STATUS,
+      archived_at: timestamp,
+      decay: {
+        ...node.metadata?.decay,
+        score,
+        reason: `Score ${score.toFixed(4)} below threshold ${threshold}`,
+        computed_at: timestamp
+      }
+    }
+  };
+}
+async function writeMemoryFile(baseDir, nodes) {
+  const filePath = path.join(baseDir, MEMORY_FILE_NAME);
+  const content = nodes.map((n) => JSON.stringify(n)).join("\n") + (nodes.length > 0 ? "\n" : "");
+  await fs.writeFile(filePath, content, { encoding: "utf-8" });
+}
+async function archiveByDecay(baseDir, options = {}) {
+  const { threshold = DEFAULT_DECAY_THRESHOLD, now = Date.now(), halfLifeMs = DEFAULT_HALF_LIFE_MS, dryRun = false } = options;
+  const memory = await loadMemory(baseDir, { includeArchived: true });
+  const archivedIds = [];
+  const retainedIds = [];
+  const skippedIds = [];
+  const updatedNodes = memory.nodes.map((node) => {
+    if (isArchived(node)) {
+      skippedIds.push(node.id);
+      return node;
+    }
+    if (isProtected(node)) {
+      skippedIds.push(node.id);
+      return node;
+    }
+    const score = computeDecayScore(node, { now, halfLifeMs });
+    if (score < threshold) {
+      archivedIds.push(node.id);
+      return markAsArchived(node, score, threshold, now);
+    }
+    retainedIds.push(node.id);
+    return node;
+  });
+  if (!dryRun && archivedIds.length > 0) {
+    await writeMemoryFile(baseDir, updatedNodes);
+  }
+  return {
+    archivedIds,
+    retainedIds,
+    skippedIds,
+    totalProcessed: memory.nodes.length,
+    ...dryRun ? { dryRun: true } : {}
+  };
+}
+
+// ../memory/dist/mem-cleanup-core.js
+import fs2 from "fs/promises";
+import path2 from "path";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var ms = require2("ms");
+var LIFECYCLE_POLICY = {
+  /** Ephemeral nodes are always removed - scratch pad data */
+  ephemeral: { alwaysRemove: true, requiresSummarized: false },
+  /** Session nodes removed when session is closed */
+  session: { alwaysRemove: false, requiresSummarized: true },
+  /** WU nodes removed only when summarized_into is set */
+  wu: { alwaysRemove: false, requiresSummarized: true },
+  /** Project nodes are never removed - architectural knowledge */
+  project: { alwaysRemove: false, requiresSummarized: false, protected: true }
+};
+var SENSITIVE_FLAG = "sensitive";
+var ACTIVE_SESSION_STATUS = "active";
+function parseTtl(ttlString) {
+  if (!ttlString || typeof ttlString !== "string") {
+    throw createError(ErrorCodes.INVALID_DURATION, "Invalid TTL format: TTL string is required");
+  }
+  const trimmed = ttlString.trim();
+  if (!trimmed) {
+    throw createError(ErrorCodes.INVALID_DURATION, "Invalid TTL format: TTL string is required");
+  }
+  const result = ms(trimmed);
+  if (result == null || result <= 0) {
+    throw createError(ErrorCodes.INVALID_DURATION, `Invalid TTL format: "${ttlString}" is not a valid duration`);
+  }
+  return result;
+}
+function isNodeExpired(node, ttlMs, now = Date.now()) {
+  if (!node.created_at) {
+    return false;
+  }
+  const createdAt = new Date(node.created_at).getTime();
+  if (Number.isNaN(createdAt)) {
+    return false;
+  }
+  const age = now - createdAt;
+  return age > ttlMs;
+}
+function isActiveSession(node) {
+  if (node.type !== "session") {
+    return false;
+  }
+  if (!node.metadata) {
+    return false;
+  }
+  return node.metadata.status === ACTIVE_SESSION_STATUS;
+}
+function hasSensitiveFlag(node) {
+  if (!node.metadata) {
+    return false;
+  }
+  return Object.hasOwn(node.metadata, SENSITIVE_FLAG) && node.metadata[SENSITIVE_FLAG] === true;
+}
+function getLifecyclePolicy(lifecycle) {
+  if (!Object.hasOwn(LIFECYCLE_POLICY, lifecycle)) {
+    return void 0;
+  }
+  return LIFECYCLE_POLICY[lifecycle];
+}
+function shouldRemoveNode(node, options = {}) {
+  const { sessionId, ttlMs, now = Date.now() } = options;
+  if (isActiveSession(node)) {
+    return { remove: false, reason: "active-session-protected" };
+  }
+  if (hasSensitiveFlag(node)) {
+    return { remove: false, reason: "sensitive-retained" };
+  }
+  const policy = getLifecyclePolicy(node.lifecycle);
+  if (!policy) {
+    return { remove: false, reason: "unknown-lifecycle" };
+  }
+  if (policy.protected) {
+    return { remove: false, reason: "protected-lifecycle" };
+  }
+  if (ttlMs && isNodeExpired(node, ttlMs, now)) {
+    return { remove: true, reason: "ttl-expired" };
+  }
+  if (policy.alwaysRemove) {
+    return { remove: true, reason: "ephemeral-cleanup" };
+  }
+  if (node.lifecycle === "session" && sessionId && node.session_id === sessionId) {
+    return { remove: true, reason: "session-closed" };
+  }
+  if (policy.requiresSummarized && node.metadata?.summarized_into) {
+    return { remove: true, reason: "summarized-archived" };
+  }
+  return { remove: false, reason: "policy-retained" };
+}
+function estimateNodeBytes(node) {
+  return JSON.stringify(node).length + 1;
+}
+function getCompactionRatio(removedCount, totalCount) {
+  if (totalCount === 0) {
+    return 0;
+  }
+  return removedCount / totalCount;
+}
+var REASON_TO_BREAKDOWN_KEY = {
+  "ephemeral-cleanup": "ephemeral",
+  "session-closed": "session",
+  "summarized-archived": "wu",
+  "sensitive-retained": "sensitive",
+  "ttl-expired": "ttlExpired",
+  "active-session-protected": "activeSessionProtected"
+};
+function updateBreakdown(breakdown, decision) {
+  const key = REASON_TO_BREAKDOWN_KEY[decision.reason];
+  if (key && Object.hasOwn(breakdown, key)) {
+    breakdown[key]++;
+  }
+}
+async function writeRetainedNodes(memoryDir, retainedNodes) {
+  const filePath = path2.join(memoryDir, MEMORY_FILE_NAME);
+  const content = retainedNodes.map((n) => JSON.stringify(n)).join("\n") + (retainedNodes.length > 0 ? "\n" : "");
+  await fs2.writeFile(filePath, content, { encoding: "utf-8" });
+}
+async function cleanupMemory(baseDir, options = {}) {
+  const { dryRun = false, sessionId, ttl, ttlMs: providedTtlMs, now = Date.now(), decay = false, decayThreshold = DEFAULT_DECAY_THRESHOLD, halfLifeMs = DEFAULT_HALF_LIFE_MS } = options;
+  const memoryDir = path2.join(baseDir, LUMENFLOW_MEMORY_PATHS.MEMORY_DIR);
+  let ttlMs = providedTtlMs;
+  if (ttl && !ttlMs) {
+    ttlMs = parseTtl(ttl);
+  }
+  let decayResult;
+  if (decay) {
+    decayResult = await archiveByDecay(memoryDir, {
+      threshold: decayThreshold,
+      now,
+      halfLifeMs,
+      dryRun
+    });
+  }
+  const memory = await loadMemoryAll(memoryDir);
+  const removedIds = [];
+  const retainedIds = [];
+  const retainedNodes = [];
+  let bytesFreed = 0;
+  const breakdown = {
+    ephemeral: 0,
+    session: 0,
+    wu: 0,
+    sensitive: 0,
+    ttlExpired: 0,
+    activeSessionProtected: 0,
+    decayArchived: decayResult?.archivedIds.length ?? 0
+  };
+  for (const node of memory.nodes) {
+    const decision = shouldRemoveNode(node, { sessionId, ttlMs, now });
+    if (decision.remove) {
+      removedIds.push(node.id);
+      bytesFreed += estimateNodeBytes(node);
+    } else {
+      retainedIds.push(node.id);
+      retainedNodes.push(node);
+    }
+    updateBreakdown(breakdown, decision);
+  }
+  const compactionRatio = getCompactionRatio(removedIds.length, memory.nodes.length);
+  const baseResult = {
+    success: true,
+    removedIds,
+    retainedIds,
+    bytesFreed,
+    compactionRatio,
+    breakdown
+  };
+  if (ttlMs) {
+    baseResult.ttlMs = ttlMs;
+  }
+  if (decayResult) {
+    baseResult.decayResult = decayResult;
+  }
+  if (dryRun) {
+    return { ...baseResult, dryRun: true };
+  }
+  if (removedIds.length > 0) {
+    await writeRetainedNodes(memoryDir, retainedNodes);
+  }
+  return baseResult;
+}
+
+export {
+  archiveByDecay,
+  cleanupMemory
+};

package/dist/chunk-QLGDFMFX.js

@@ -0,0 +1,212 @@
+import {
+  MEMORY_PATTERNS,
+  loadMemory
+} from "./chunk-DFR4DJBM.js";
+import {
+  LUMENFLOW_MEMORY_PATHS
+} from "./chunk-4N74J3UT.js";
+import {
+  ErrorCodes,
+  createError
+} from "./chunk-RXRKBBSM.js";
+
+// ../memory/dist/mem-recover-core.js
+import fs from "fs/promises";
+import path from "path";
+import { parse as parseYaml } from "yaml";
+var DEFAULT_MAX_SIZE = 8192;
+var NODE_TYPE_CHECKPOINT = "checkpoint";
+var CONSTRAINTS_FILENAME = "constraints.md";
+var TIMESTAMP_UNKNOWN = "unknown";
+var MAX_ACCEPTANCE_ITEMS = 8;
+var MAX_CODE_PATH_ITEMS = 10;
+var ERROR_MESSAGES = {
+  WU_ID_REQUIRED: "wuId is required",
+  WU_ID_EMPTY: "wuId cannot be empty",
+  WU_ID_INVALID: "Invalid WU ID format. Expected pattern: WU-XXX (e.g., WU-1234)"
+};
+var SECTION_HEADERS = {
+  RECOVERY_TITLE: "POST-COMPACTION RECOVERY",
+  LAST_CHECKPOINT: "Last Checkpoint",
+  ACCEPTANCE_CRITERIA: "Acceptance Criteria",
+  CODE_PATHS: "Code Paths",
+  FILES_CHANGED: "Files Changed",
+  CRITICAL_RULES: "Critical Rules (DO NOT FORGET)",
+  CLI_COMMANDS: "CLI Commands",
+  NEXT_ACTION: "Next Action"
+};
+var ESSENTIAL_CLI_COMMANDS = `| Command | Purpose |
+|---------|---------|
+| pnpm wu:status --id WU-XXX | Check WU status and location |
+| pnpm wu:brief --id WU-XXX | Generate fresh agent handoff prompt |
+| pnpm gates | Run quality gates before completion |
+| pnpm mem:checkpoint | Save progress checkpoint |`;
+var FALLBACK_CONSTRAINTS = `1. **Worktree Discipline**: Work only in worktrees, treat main as read-only
+2. **WUs Are Specs**: Respect code_paths boundaries, no feature creep
+3. **Docs-Only vs Code**: Documentation WUs use --docs-only gates
+4. **LLM-First Inference**: Use LLMs for semantic tasks, no brittle regex
+5. **Gates Required**: Run pnpm gates before wu:done
+6. **Safety & Governance**: No secrets in code, stop-and-ask for sensitive ops
+7. **Test Ratchet**: NEW test failures block, pre-existing show warning only`;
+function validateWuId(wuId) {
+  if (wuId == null) {
+    throw createError(ErrorCodes.VALIDATION_ERROR, ERROR_MESSAGES.WU_ID_REQUIRED);
+  }
+  if (wuId === "") {
+    throw createError(ErrorCodes.VALIDATION_ERROR, ERROR_MESSAGES.WU_ID_EMPTY);
+  }
+  if (!MEMORY_PATTERNS.WU_ID.test(wuId)) {
+    throw createError(ErrorCodes.INVALID_WU_ID, ERROR_MESSAGES.WU_ID_INVALID);
+  }
+}
+async function getLastCheckpoint(baseDir, wuId) {
+  const memoryDir = path.join(baseDir, LUMENFLOW_MEMORY_PATHS.MEMORY_DIR);
+  try {
+    const memory = await loadMemory(memoryDir);
+    const wuNodes = memory.byWu.get(wuId) ?? [];
+    const checkpoints = wuNodes.filter((node) => node.type === NODE_TYPE_CHECKPOINT).sort((a, b) => {
+      const aTime = new Date(a.created_at).getTime();
+      const bTime = new Date(b.created_at).getTime();
+      return bTime - aTime;
+    });
+    if (checkpoints.length === 0) {
+      return null;
+    }
+    const latest = checkpoints[0];
+    if (!latest)
+      return null;
+    return {
+      content: latest.content,
+      timestamp: latest.created_at,
+      progress: latest.metadata?.progress,
+      nextSteps: latest.metadata?.nextSteps,
+      gitDiffStat: latest.metadata?.gitDiffStat
+    };
+  } catch {
+    return null;
+  }
+}
+async function loadCompactConstraints(baseDir) {
+  const constraintsPath = path.join(baseDir, LUMENFLOW_MEMORY_PATHS.BASE, CONSTRAINTS_FILENAME);
+  try {
+    const content = await fs.readFile(constraintsPath, "utf-8");
+    const rules = [];
+    const sectionPattern = /### (\d+)\. ([^\n]+)\n\n\*\*Rule:\*\* ([^\n]+)/g;
+    let match;
+    while ((match = sectionPattern.exec(content)) !== null) {
+      const [, num, title, rule] = match;
+      rules.push(`${num}. **${title}**: ${rule}`);
+    }
+    if (rules.length > 0) {
+      return rules.join("\n");
+    }
+    return FALLBACK_CONSTRAINTS;
+  } catch {
+    return FALLBACK_CONSTRAINTS;
+  }
+}
+async function loadWuMetadata(baseDir, wuId) {
+  const wuYamlPath = path.join(baseDir, "docs", "04-operations", "tasks", "wu", `${wuId}.yaml`);
+  try {
+    const content = await fs.readFile(wuYamlPath, "utf-8");
+    const doc = parseYaml(content);
+    const acceptance = Array.isArray(doc.acceptance) ? doc.acceptance.filter((s) => typeof s === "string") : [];
+    const codePaths = Array.isArray(doc.code_paths) ? doc.code_paths.filter((s) => typeof s === "string") : [];
+    if (acceptance.length === 0 && codePaths.length === 0) {
+      return null;
+    }
+    return { acceptance, codePaths };
+  } catch {
+    return null;
+  }
+}
+function formatRecoveryPrompt(wuId, checkpoint, constraints, cliRef, wuMetadata, maxSize) {
+  const header = `# ${SECTION_HEADERS.RECOVERY_TITLE}
+
+You are resuming work after context compaction. Your previous context was lost.
+**WU:** ${wuId}
+
+`;
+  const checkpointSection = checkpoint ? `## ${SECTION_HEADERS.LAST_CHECKPOINT}
+- **Progress:** ${checkpoint.content}
+- **Timestamp:** ${checkpoint.timestamp}
+${checkpoint.nextSteps ? `- **Next Steps:** ${checkpoint.nextSteps}` : ""}
+
+` : `## ${SECTION_HEADERS.LAST_CHECKPOINT}
+No checkpoint found for this WU.
+
+`;
+  const acceptanceItems = wuMetadata?.acceptance.slice(0, MAX_ACCEPTANCE_ITEMS) ?? [];
+  const acceptanceTruncated = (wuMetadata?.acceptance.length ?? 0) > MAX_ACCEPTANCE_ITEMS;
+  const acceptanceSection = acceptanceItems.length > 0 ? `## ${SECTION_HEADERS.ACCEPTANCE_CRITERIA}
+${acceptanceItems.map((ac) => `- [ ] ${ac}`).join("\n")}${acceptanceTruncated ? `
+- ... (${(wuMetadata?.acceptance.length ?? 0) - MAX_ACCEPTANCE_ITEMS} more \u2014 run wu:brief for full list)` : ""}
+
+` : "";
+  const codePathItems = wuMetadata?.codePaths.slice(0, MAX_CODE_PATH_ITEMS) ?? [];
+  const codePathsTruncated = (wuMetadata?.codePaths.length ?? 0) > MAX_CODE_PATH_ITEMS;
+  const codePathsSection = codePathItems.length > 0 ? `## ${SECTION_HEADERS.CODE_PATHS}
+${codePathItems.map((cp) => `- ${cp}`).join("\n")}${codePathsTruncated ? `
+- ... (${(wuMetadata?.codePaths.length ?? 0) - MAX_CODE_PATH_ITEMS} more)` : ""}
+
+` : "";
+  const gitDiffSection = checkpoint?.gitDiffStat ? `## ${SECTION_HEADERS.FILES_CHANGED}
+\`\`\`
+${checkpoint.gitDiffStat}
+\`\`\`
+
+` : "";
+  const constraintsSection = constraints ? `## ${SECTION_HEADERS.CRITICAL_RULES}
+${constraints}
+
+` : "";
+  const cliSection = cliRef ? `## ${SECTION_HEADERS.CLI_COMMANDS}
+${cliRef}
+
+` : "";
+  const footer = `## ${SECTION_HEADERS.NEXT_ACTION}
+Continue working on the WU using the acceptance criteria and code paths above.
+If you need full context: \`pnpm wu:brief --id ${wuId}\`
+`;
+  const fixedContent = header + acceptanceSection + codePathsSection + gitDiffSection + constraintsSection + cliSection + footer;
+  const fixedSize = Buffer.byteLength(fixedContent, "utf-8");
+  if (fixedSize > maxSize) {
+    const minimal = `# ${SECTION_HEADERS.RECOVERY_TITLE}
+WU: ${wuId}
+Run: pnpm wu:brief --id ${wuId}
+`;
+    return { context: minimal, truncated: true };
+  }
+  const remainingBudget = maxSize - fixedSize;
+  const checkpointSize = Buffer.byteLength(checkpointSection, "utf-8");
+  if (checkpointSize <= remainingBudget) {
+    const fullContext = header + checkpointSection + acceptanceSection + codePathsSection + gitDiffSection + constraintsSection + cliSection + footer;
+    return { context: fullContext, truncated: false };
+  }
+  const truncatedCheckpoint = `## ${SECTION_HEADERS.LAST_CHECKPOINT}
+- **Progress:** (truncated - run mem:ready --wu ${wuId} for details)
+- **Timestamp:** ${checkpoint?.timestamp ?? TIMESTAMP_UNKNOWN}
+
+`;
+  const context = header + truncatedCheckpoint + acceptanceSection + codePathsSection + gitDiffSection + constraintsSection + cliSection + footer;
+  return { context, truncated: true };
+}
+async function generateRecoveryContext(options) {
+  const { wuId, baseDir = ".", maxSize = DEFAULT_MAX_SIZE, includeConstraints = true, includeCLIRef = true, includeWuMetadata = true } = options;
+  validateWuId(wuId);
+  const checkpoint = await getLastCheckpoint(baseDir, wuId);
+  const constraints = includeConstraints ? await loadCompactConstraints(baseDir) : "";
+  const cliRef = includeCLIRef ? ESSENTIAL_CLI_COMMANDS : "";
+  const wuMetadata = includeWuMetadata ? await loadWuMetadata(baseDir, wuId) : null;
+  const { context, truncated } = formatRecoveryPrompt(wuId, checkpoint, constraints, cliRef, wuMetadata, maxSize);
+  return {
+    success: true,
+    context,
+    size: Buffer.byteLength(context, "utf-8"),
+    truncated
+  };
+}
+
+export {
+  generateRecoveryContext
+};

package/dist/chunk-RIAAGL2E.js

@@ -0,0 +1,13 @@
+// ../memory/dist/mem-id.js
+import { createHash } from "crypto";
+var MEM_ID_PREFIX = "mem-";
+var HEX_SUFFIX_LENGTH = 4;
+function generateMemId(content) {
+  const hash = createHash("sha256").update(content, "utf-8").digest("hex");
+  const suffix = hash.slice(0, HEX_SUFFIX_LENGTH);
+  return `${MEM_ID_PREFIX}${suffix}`;
+}
+
+export {
+  generateMemId
+};

package/dist/chunk-RWO5XMZ6.js

@@ -0,0 +1,86 @@
+import {
+  ensureMemoryDir
+} from "./chunk-ND6MY37M.js";
+import {
+  generateMemId
+} from "./chunk-RIAAGL2E.js";
+import {
+  MEMORY_PATTERNS,
+  appendNode
+} from "./chunk-DFR4DJBM.js";
+import {
+  ErrorCodes,
+  createError
+} from "./chunk-RXRKBBSM.js";
+
+// ../memory/dist/mem-checkpoint-core.js
+var ERROR_MESSAGES = {
+  NOTE_REQUIRED: "note is required",
+  NOTE_EMPTY: "note cannot be empty",
+  WU_ID_INVALID: "Invalid WU ID format. Expected pattern: WU-XXX (e.g., WU-123)"
+};
+var NODE_TYPE_CHECKPOINT = "checkpoint";
+var LIFECYCLE_SESSION = "session";
+function isValidWuId(wuId) {
+  if (!wuId)
+    return true;
+  return MEMORY_PATTERNS.WU_ID.test(wuId);
+}
+function generateCheckpointContent(note) {
+  return `Checkpoint: ${note}`;
+}
+async function createCheckpoint(baseDir, options) {
+  const { note, sessionId, wuId, progress, nextSteps, trigger, gitDiffStat } = options;
+  if (note == null) {
+    throw createError(ErrorCodes.VALIDATION_ERROR, ERROR_MESSAGES.NOTE_REQUIRED);
+  }
+  if (note === "") {
+    throw createError(ErrorCodes.VALIDATION_ERROR, ERROR_MESSAGES.NOTE_EMPTY);
+  }
+  if (wuId && !isValidWuId(wuId)) {
+    throw createError(ErrorCodes.INVALID_WU_ID, ERROR_MESSAGES.WU_ID_INVALID);
+  }
+  const memoryDir = await ensureMemoryDir(baseDir);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const content = generateCheckpointContent(note);
+  const idContent = `${content}-${timestamp}`;
+  const id = generateMemId(idContent);
+  const metadata = {};
+  if (progress) {
+    metadata.progress = progress;
+  }
+  if (nextSteps) {
+    metadata.nextSteps = nextSteps;
+  }
+  if (trigger) {
+    metadata.trigger = trigger;
+  }
+  if (gitDiffStat) {
+    metadata.gitDiffStat = gitDiffStat;
+  }
+  const checkpointNode = {
+    id,
+    type: NODE_TYPE_CHECKPOINT,
+    lifecycle: LIFECYCLE_SESSION,
+    content,
+    created_at: timestamp
+  };
+  if (wuId) {
+    checkpointNode.wu_id = wuId;
+  }
+  if (sessionId) {
+    checkpointNode.session_id = sessionId;
+  }
+  if (Object.keys(metadata).length > 0) {
+    checkpointNode.metadata = metadata;
+  }
+  await appendNode(memoryDir, checkpointNode);
+  return {
+    success: true,
+    checkpoint: checkpointNode
+  };
+}
+
+export {
+  createCheckpoint
+};