@lumenflow/cli 3.12.6 → 3.12.8

package/dist/chunk-QFSTL4J3.js

@@ -1,276 +0,0 @@
-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

@@ -1,212 +0,0 @@
-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

@@ -1,13 +0,0 @@
-// ../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

@@ -1,86 +0,0 @@
-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
-};