blun-king-cli 9.1.587 → 9.1.589

package/bin/validated-learning-insight-policy.cjs

@@ -1,58 +0,0 @@
-'use strict';
-
-const CANDIDATE_ID = /^vl-[a-f0-9]{32}$/iu;
-const COMMAND_HASH = /^[a-f0-9]{64}$/iu;
-const TOOL_NAME = /^[a-z0-9._ -]{1,64}$/iu;
-
-function safeLatestCandidate(candidate) {
-  const id = typeof candidate?.id === 'string' && CANDIDATE_ID.test(candidate.id)
-    ? candidate.id
-    : 'unknown';
-  const toolName = typeof candidate?.verification?.toolName === 'string'
-      && TOOL_NAME.test(candidate.verification.toolName)
-    ? candidate.verification.toolName
-    : 'unknown';
-  const commandHash = typeof candidate?.verification?.commandHash === 'string'
-      && COMMAND_HASH.test(candidate.verification.commandHash)
-    ? candidate.verification.commandHash.slice(0, 12)
-    : 'unknown';
-  return { id, toolName, commandHash };
-}
-
-function buildValidatedLearningInsight(candidates) {
-  const insight = {
-    pending: 0,
-    recorded: 0,
-    expired: 0,
-    latestPending: null,
-  };
-  let latestCandidate = null;
-  let latestTime = Number.NEGATIVE_INFINITY;
-
-  for (const candidate of Array.isArray(candidates) ? candidates : []) {
-    if (!candidate || typeof candidate !== 'object') continue;
-    if (candidate.status === 'recorded') {
-      insight.recorded += 1;
-      continue;
-    }
-    if (candidate.status === 'expired') {
-      insight.expired += 1;
-      continue;
-    }
-    if (candidate.status !== 'pending') continue;
-
-    insight.pending += 1;
-    const candidateTime = Date.parse(candidate.createdAt);
-    if (latestCandidate === null || (Number.isFinite(candidateTime) && candidateTime >= latestTime)) {
-      latestCandidate = candidate;
-      latestTime = Number.isFinite(candidateTime) ? candidateTime : latestTime;
-    }
-  }
-
-  if (latestCandidate !== null) insight.latestPending = safeLatestCandidate(latestCandidate);
-  return insight;
-}
-
-module.exports = {
-  buildValidatedLearningInsight,
-};

package/bin/validated-learning-outcome-trace.cjs

@@ -1,107 +0,0 @@
-'use strict';
-
-const crypto = require('node:crypto');
-const fs = require('node:fs');
-const path = require('node:path');
-
-const SCHEMA_VERSION = 1;
-const MAX_LESSONS = 5;
-const MAX_HEADING_CHARS = 160;
-const MAX_SEMANTIC_MATCHES = 6;
-const CANDIDATE_ID = /^vl-[a-f0-9]{32}$/u;
-
-function cleanText(value, maxChars) {
-  const text = String(value ?? '')
-    .replace(/[\u0000-\u001f\u007f]+/gu, ' ')
-    .replace(/\s+/gu, ' ')
-    .trim();
-  return text.slice(0, maxChars);
-}
-
-function lessonKey(reference, heading) {
-  return crypto.createHash('sha256')
-    .update(`${String(reference ?? '')}\0${heading}`)
-    .digest('hex')
-    .slice(0, 24);
-}
-
-function normalizeLessons(value) {
-  if (!Array.isArray(value)) return [];
-  const lessons = [];
-  const seen = new Set();
-  for (const item of value) {
-    const heading = cleanText(item?.heading, MAX_HEADING_CHARS);
-    if (!heading) continue;
-    const key = lessonKey(item?.reference, heading);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    const semanticMatches = [...new Set(
-      (Array.isArray(item?.semanticMatches) ? item.semanticMatches : [])
-        .map((tag) => cleanText(tag, 48))
-        .filter(Boolean),
-    )].sort().slice(0, MAX_SEMANTIC_MATCHES);
-    lessons.push({
-      lessonKey: key,
-      heading,
-      ...(semanticMatches.length > 0 ? { semanticMatches } : {}),
-    });
-    if (lessons.length >= MAX_LESSONS) break;
-  }
-  return lessons;
-}
-
-function atomicCreate(filePath, value) {
-  const temporary = `${filePath}.${process.pid}.${crypto.randomBytes(8).toString('hex')}.tmp`;
-  fs.writeFileSync(temporary, `${JSON.stringify(value)}\n`, { encoding: 'utf8', mode: 0o600 });
-  try {
-    fs.linkSync(temporary, filePath);
-    return true;
-  } catch (error) {
-    if (error?.code !== 'EEXIST') throw error;
-    return false;
-  } finally {
-    fs.rmSync(temporary, { force: true });
-  }
-}
-
-function readTrace(filePath) {
-  try {
-    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-function recordValidatedLearningOutcomeTrace(candidate, selectedLessons, options = {}) {
-  if (candidate?.source !== 'current_turn'
-    || candidate.status !== 'pending'
-    || !CANDIDATE_ID.test(String(candidate.id ?? ''))
-    || typeof candidate.filePath !== 'string'
-    || !candidate.filePath) return null;
-  const lessons = normalizeLessons(selectedLessons);
-  if (lessons.length === 0) return null;
-
-  const directory = path.dirname(candidate.filePath);
-  const filePath = path.join(directory, `${candidate.id}.lesson-exposure.jsonl`);
-  const trace = {
-    schemaVersion: SCHEMA_VERSION,
-    type: 'lesson_exposure_red_green',
-    status: 'observed',
-    candidateId: candidate.id,
-    outcome: 'validated_red_green',
-    causalAttribution: false,
-    lessons,
-    recordedAt: new Date((options.now || Date.now)()).toISOString(),
-  };
-  const created = atomicCreate(filePath, trace);
-  return {
-    created,
-    filePath,
-    trace: created ? trace : readTrace(filePath),
-  };
-}
-
-module.exports = {
-  normalizeLessons,
-  recordValidatedLearningOutcomeTrace,
-};

package/bin/validated-learning-performance-policy.cjs

@@ -1,53 +0,0 @@
-'use strict';
-
-const {
-  isLowInformationPersonalMemoryQuery,
-} = require('./personal-memory-performance-policy.cjs');
-
-function isRealUserMessage(message) {
-  if (message?.role !== 'user') return false;
-  const kind = message.origin?.kind;
-  return kind !== 'injection' && kind !== 'compaction_summary' && kind !== 'system_trigger';
-}
-
-function textFromMessage(message) {
-  if (typeof message?.content === 'string') return message.content.trim();
-  if (!Array.isArray(message?.content)) return '';
-  return message.content
-    .filter((part) => part?.type === 'text' && typeof part.text === 'string')
-    .map((part) => part.text.trim())
-    .filter(Boolean)
-    .join('\n');
-}
-
-function directMessageText(value) {
-  let text = value.trim();
-  const marker = /^#?\s*\[tg\s+dm\b[^\]]*\]\s*/iu;
-  if (!marker.test(text)) return text;
-  text = text.replace(marker, '');
-  text = text.replace(/^[^\r\n]{1,160}\s+schrieb:\s*/iu, '');
-  return text.replace(/\r?\nWeiter-Signal:\s*[\s\S]*$/iu, '').trim();
-}
-
-function hasToolActivityAfter(history, userIndex) {
-  return history.slice(userIndex + 1).some((message) => (
-    message?.role === 'tool'
-    || (message?.role === 'assistant'
-      && (Array.isArray(message.toolCalls) || Array.isArray(message.tool_calls))
-      && (message.toolCalls?.length > 0 || message.tool_calls?.length > 0))
-  ));
-}
-
-function shouldSyncValidatedLearningCandidate(history) {
-  if (!Array.isArray(history)) return true;
-  const userIndex = history.findLastIndex(isRealUserMessage);
-  if (userIndex < 0 || hasToolActivityAfter(history, userIndex)) return true;
-  const message = history[userIndex];
-  if (Array.isArray(message.content)) {
-    const hasAttachment = message.content.some((part) => part?.type !== 'text' && part?.type !== 'think');
-    if (hasAttachment) return true;
-  }
-  return !isLowInformationPersonalMemoryQuery(directMessageText(textFromMessage(message)));
-}
-
-module.exports = { shouldSyncValidatedLearningCandidate };

package/bin/validated-learning-signal.cjs

@@ -1,463 +0,0 @@
-'use strict';
-
-const crypto = require('node:crypto');
-const fs = require('node:fs');
-const path = require('node:path');
-
-const CANDIDATE_TTL_MS = 24 * 60 * 60 * 1000;
-const SCHEMA_VERSION = 1;
-const TERMINAL_CANDIDATE_MAX = 200;
-const TERMINAL_CANDIDATE_TRIM_TO = 100;
-
-const COMMAND_TOOLS = new Set([
-  'bash',
-  'command',
-  'exec_command',
-  'shell',
-]);
-
-const VERIFICATION_COMMAND = /(?:^|(?:&&|\|\||;|\s))(?:(?:node\s+--(?:test|check))|(?:(?:npm|pnpm|yarn)\s+(?:test|(?:run\s+)?(?:test|lint|check|typecheck|build)))|(?:python(?:3)?\s+-m\s+pytest)|(?:pytest)|(?:go\s+test)|(?:cargo\s+test)|(?:dotnet\s+test)|(?:npx\s+)?(?:tsc|eslint|biome\s+check))\b/iu;
-
-function isRealUserMessage(message) {
-  if (message?.role !== 'user') return false;
-  const kind = message.origin?.kind;
-  return kind !== 'injection' && kind !== 'compaction_summary' && kind !== 'system_trigger';
-}
-
-function currentUserTurn(history) {
-  if (!Array.isArray(history)) return [];
-  for (let index = history.length - 1; index >= 0; index -= 1) {
-    if (isRealUserMessage(history[index])) return history.slice(index + 1);
-  }
-  return [];
-}
-
-function parseArguments(value) {
-  if (value && typeof value === 'object') return value;
-  if (typeof value !== 'string') return null;
-  try {
-    const parsed = JSON.parse(value);
-    return parsed && typeof parsed === 'object' ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-
-function normalizeCommand(value) {
-  return typeof value === 'string' ? value.trim().replace(/\s+/gu, ' ') : '';
-}
-
-function describeVerificationCall(call) {
-  const toolName = typeof call?.name === 'string' ? call.name : '';
-  if (!COMMAND_TOOLS.has(toolName.toLowerCase())) return null;
-  const args = parseArguments(call.arguments);
-  const command = normalizeCommand(args?.command ?? args?.cmd);
-  if (!command || !VERIFICATION_COMMAND.test(command)) return null;
-  return { toolName, command };
-}
-
-function toolCallsFrom(message) {
-  if (message?.role !== 'assistant') return [];
-  if (Array.isArray(message.toolCalls)) return message.toolCalls;
-  if (Array.isArray(message.tool_calls)) return message.tool_calls;
-  return [];
-}
-
-function detectValidatedLearningSignal(history) {
-  const turn = currentUserTurn(history);
-  const calls = new Map();
-  const failures = new Map();
-  let signal = null;
-
-  for (const message of turn) {
-    for (const call of toolCallsFrom(message)) {
-      if (typeof call?.id !== 'string') continue;
-      const verification = describeVerificationCall(call);
-      calls.set(call.id, {
-        toolName: typeof call.name === 'string' ? call.name : '',
-        verification,
-      });
-    }
-
-    if (message?.role !== 'tool' || typeof message.toolCallId !== 'string') continue;
-    const call = calls.get(message.toolCallId);
-    if (!call) continue;
-
-    if (call.toolName.toLowerCase() === 'mistakerecord' && message.isError !== true) {
-      signal = null;
-      failures.clear();
-      continue;
-    }
-
-    if (!call.verification) continue;
-    const key = `${call.verification.toolName.toLowerCase()}\0${call.verification.command}`;
-    if (message.isError === true) {
-      failures.set(key, message.toolCallId);
-      signal = null;
-      continue;
-    }
-
-    const failedToolCallId = failures.get(key);
-    if (!failedToolCallId) continue;
-    signal = {
-      toolName: call.verification.toolName,
-      command: call.verification.command,
-      failedToolCallId,
-      successfulToolCallId: message.toolCallId,
-    };
-  }
-
-  return signal;
-}
-
-function profileKey(value) {
-  const normalized = typeof value === 'string' ? value.trim() : '';
-  return (normalized || 'default').replace(/[^a-z0-9._-]/giu, '_').slice(0, 64);
-}
-
-function normalizedRemote(value) {
-  let remote = typeof value === 'string' ? value.trim() : '';
-  if (!remote) return '';
-  remote = remote.replace(/^git@([^:]+):/iu, 'ssh://git@$1/');
-  try {
-    const parsed = new URL(remote);
-    const host = parsed.hostname.toLowerCase();
-    const pathname = parsed.pathname.replace(/^\/+|\/+$/gu, '').replace(/\.git$/iu, '').toLowerCase();
-    return host && pathname ? `${host}/${pathname}` : '';
-  } catch {
-    return remote.replace(/\\/gu, '/').replace(/\.git$/iu, '').toLowerCase();
-  }
-}
-
-function gitConfigPath(dotGitPath) {
-  try {
-    const stat = fs.lstatSync(dotGitPath);
-    if (stat.isDirectory()) return path.join(dotGitPath, 'config');
-    if (!stat.isFile()) return '';
-    const pointer = fs.readFileSync(dotGitPath, 'utf8').match(/^gitdir:\s*(.+)$/imu)?.[1]?.trim();
-    if (!pointer) return '';
-    const gitDir = path.resolve(path.dirname(dotGitPath), pointer);
-    const commonPointerPath = path.join(gitDir, 'commondir');
-    if (fs.existsSync(commonPointerPath)) {
-      const commonPointer = fs.readFileSync(commonPointerPath, 'utf8').trim();
-      if (commonPointer) return path.join(path.resolve(gitDir, commonPointer), 'config');
-    }
-    return path.join(gitDir, 'config');
-  } catch {
-    return '';
-  }
-}
-
-function originRemote(configPath) {
-  if (!configPath) return '';
-  try {
-    const stat = fs.statSync(configPath);
-    if (!stat.isFile() || stat.size > 1024 * 1024) return '';
-    const lines = fs.readFileSync(configPath, 'utf8').split(/\r?\n/gu);
-    let inOrigin = false;
-    for (const line of lines) {
-      const section = line.match(/^\s*\[([^\]]+)\]\s*$/u)?.[1]?.trim();
-      if (section !== undefined) {
-        inOrigin = /^remote\s+"origin"$/iu.test(section);
-        continue;
-      }
-      if (!inOrigin) continue;
-      const url = line.match(/^\s*url\s*=\s*(.+?)\s*$/iu)?.[1];
-      if (url) return normalizedRemote(url);
-    }
-  } catch {
-    return '';
-  }
-  return '';
-}
-
-function resolveValidatedLearningProject(projectDir) {
-  const requested = typeof projectDir === 'string' ? projectDir.trim() : '';
-  if (!requested) return { scope: 'global', projectId: '' };
-  let current;
-  try {
-    current = fs.realpathSync(path.resolve(requested));
-  } catch {
-    return { scope: 'global', projectId: '' };
-  }
-  for (let depth = 0; depth < 64; depth += 1) {
-    const dotGitPath = path.join(current, '.git');
-    if (fs.existsSync(dotGitPath)) {
-      const remote = originRemote(gitConfigPath(dotGitPath));
-      const identity = remote ? `remote:${remote}` : `path:${current.toLowerCase()}`;
-      return {
-        scope: 'project',
-        projectId: crypto.createHash('sha256').update(identity).digest('hex').slice(0, 16),
-      };
-    }
-    const parent = path.dirname(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  return { scope: 'global', projectId: '' };
-}
-
-function candidateDirectory(homeDir, profile, projectId = '') {
-  const base = path.join(
-    path.resolve(homeDir),
-    'self-improvement',
-    'validated-learning',
-    profileKey(profile),
-  );
-  return projectId ? path.join(base, 'projects', projectId) : base;
-}
-
-function atomicCreate(filePath, value) {
-  fs.mkdirSync(path.dirname(filePath), { mode: 0o700, recursive: true });
-  const temporary = `${filePath}.${process.pid}.${crypto.randomBytes(8).toString('hex')}.tmp`;
-  fs.writeFileSync(temporary, `${JSON.stringify(value)}\n`, { encoding: 'utf8', mode: 0o600 });
-  try {
-    fs.linkSync(temporary, filePath);
-    return true;
-  } catch (error) {
-    if (error?.code !== 'EEXIST') throw error;
-    return false;
-  } finally {
-    fs.rmSync(temporary, { force: true });
-  }
-}
-
-function statusMarker(filePath, status) {
-  return `${filePath}.${status}`;
-}
-
-function readCandidate(filePath) {
-  try {
-    const candidate = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-    for (const status of ['recorded', 'expired']) {
-      const markerPath = statusMarker(filePath, status);
-      if (!fs.existsSync(markerPath)) continue;
-      const marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
-      return { ...candidate, ...marker, filePath };
-    }
-    return { ...candidate, filePath };
-  } catch {
-    return null;
-  }
-}
-
-function readValidatedLearningCandidates(options = {}) {
-  const homeDir = typeof options.homeDir === 'string' ? options.homeDir.trim() : '';
-  if (!homeDir) return [];
-  const project = resolveValidatedLearningProject(options.projectDir);
-  const directory = candidateDirectory(homeDir, options.profile, project.projectId);
-  try {
-    return fs.readdirSync(directory, { withFileTypes: true })
-      .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
-      .map((entry) => readCandidate(path.join(directory, entry.name)))
-      .filter(Boolean)
-      .sort((left, right) => Date.parse(left.createdAt) - Date.parse(right.createdAt));
-  } catch {
-    return [];
-  }
-}
-
-function pruneTerminalValidatedLearningCandidates(options = {}) {
-  const candidates = Array.isArray(options.candidates)
-    ? options.candidates
-    : readValidatedLearningCandidates(options);
-  const terminal = candidates.filter((candidate) => (
-    candidate.status === 'recorded' || candidate.status === 'expired'
-  ));
-  if (terminal.length <= TERMINAL_CANDIDATE_MAX) return { deleted: 0, failed: 0 };
-
-  const victims = terminal.slice(0, terminal.length - TERMINAL_CANDIDATE_TRIM_TO);
-  let deleted = 0;
-  let failed = 0;
-  for (const candidate of victims) {
-    if (typeof candidate.filePath !== 'string' || candidate.filePath.length === 0) {
-      failed += 1;
-      continue;
-    }
-    try {
-      fs.rmSync(candidate.filePath, { force: true });
-      fs.rmSync(statusMarker(candidate.filePath, 'recorded'), { force: true });
-      fs.rmSync(statusMarker(candidate.filePath, 'expired'), { force: true });
-      deleted += 1;
-    } catch {
-      failed += 1;
-    }
-  }
-  return { deleted, failed };
-}
-
-function successfulMistakeRecordCandidateIds(history) {
-  const calls = new Map();
-  const candidateIds = new Set();
-  for (const message of currentUserTurn(history)) {
-    for (const call of toolCallsFrom(message)) {
-      if (typeof call?.id === 'string' && String(call.name).toLowerCase() === 'mistakerecord') {
-        const args = parseArguments(call.arguments);
-        calls.set(call.id, typeof args?.candidateId === 'string' ? args.candidateId.trim() : '');
-      }
-    }
-    if (message?.role === 'tool'
-      && typeof message.toolCallId === 'string'
-      && calls.get(message.toolCallId)
-      && message.isError !== true) {
-      candidateIds.add(calls.get(message.toolCallId));
-    }
-  }
-  return candidateIds;
-}
-
-function newestPending(candidates) {
-  for (let index = candidates.length - 1; index >= 0; index -= 1) {
-    if (candidates[index].status === 'pending') return candidates[index];
-  }
-  return null;
-}
-
-function markCandidate(candidate, status, nowIso) {
-  if (!candidate?.filePath) return;
-  atomicCreate(statusMarker(candidate.filePath, status), {
-    resolvedAt: nowIso,
-    status,
-  });
-}
-
-function verificationCommandHash(signal) {
-  return crypto.createHash('sha256').update(signal.command).digest('hex');
-}
-
-function pendingCandidateForSignal(candidates, signal) {
-  const commandHash = verificationCommandHash(signal);
-  for (let index = candidates.length - 1; index >= 0; index -= 1) {
-    const candidate = candidates[index];
-    if (candidate.status === 'pending'
-      && candidate.verification?.commandHash === commandHash) {
-      return candidate;
-    }
-  }
-  return null;
-}
-
-function createCandidate(signal, options, nowIso) {
-  const profile = profileKey(options.profile);
-  const projectId = typeof options.projectId === 'string' ? options.projectId : '';
-  const commandHash = verificationCommandHash(signal);
-  const digest = crypto.createHash('sha256').update([
-    profile,
-    projectId,
-    commandHash,
-    signal.failedToolCallId,
-    signal.successfulToolCallId,
-  ].join('\0')).digest('hex').slice(0, 32);
-  const id = `vl-${digest}`;
-  const filePath = path.join(candidateDirectory(options.homeDir, profile, projectId), `${id}.json`);
-  atomicCreate(filePath, {
-    schemaVersion: SCHEMA_VERSION,
-    id,
-    type: 'validated_red_green',
-    status: 'pending',
-    profile,
-    scope: projectId ? 'project' : 'global',
-    ...(projectId ? { projectId } : {}),
-    verification: {
-      toolName: signal.toolName,
-      commandHash,
-    },
-    evidence: {
-      failedToolCallId: signal.failedToolCallId,
-      successfulToolCallId: signal.successfulToolCallId,
-    },
-    createdAt: nowIso,
-  });
-  return readCandidate(filePath);
-}
-
-function syncValidatedLearningCandidate(history, options = {}) {
-  const signal = detectValidatedLearningSignal(history);
-  const homeDir = typeof options.homeDir === 'string' ? options.homeDir.trim() : '';
-  const project = resolveValidatedLearningProject(options.projectDir);
-  if (!homeDir) {
-    return signal === null ? null : {
-      ...signal,
-      source: 'current_turn',
-      status: 'pending',
-    };
-  }
-
-  const nowMs = (options.now || Date.now)();
-  const nowIso = new Date(nowMs).toISOString();
-  try {
-    let candidates = readValidatedLearningCandidates({
-      homeDir,
-      profile: options.profile,
-      projectDir: options.projectDir,
-    });
-    const recordedCandidateIds = successfulMistakeRecordCandidateIds(history);
-    for (const candidateId of recordedCandidateIds) {
-      const candidate = candidates.find((item) => (
-        item.id === candidateId && item.status === 'pending'
-      ));
-      markCandidate(candidate, 'recorded', nowIso);
-    }
-    if (recordedCandidateIds.size > 0) {
-      candidates = readValidatedLearningCandidates({
-        homeDir,
-        profile: options.profile,
-        projectDir: options.projectDir,
-      });
-    }
-    let expiredCandidate = false;
-    for (const candidate of candidates) {
-      if (candidate.status !== 'pending') continue;
-      if (nowMs - Date.parse(candidate.createdAt) >= CANDIDATE_TTL_MS) {
-        markCandidate(candidate, 'expired', nowIso);
-        expiredCandidate = true;
-      }
-    }
-    if (expiredCandidate) {
-      candidates = readValidatedLearningCandidates({
-        homeDir,
-        profile: options.profile,
-        projectDir: options.projectDir,
-      });
-    }
-    const retention = pruneTerminalValidatedLearningCandidates({ candidates });
-    if (retention.deleted > 0) {
-      candidates = readValidatedLearningCandidates({
-        homeDir,
-        profile: options.profile,
-        projectDir: options.projectDir,
-      });
-    }
-    if (signal !== null) {
-      const duplicate = pendingCandidateForSignal(candidates, signal);
-      if (duplicate !== null) {
-        return { ...duplicate, source: 'current_turn' };
-      }
-      return {
-        ...createCandidate(signal, {
-          homeDir,
-          profile: options.profile,
-          projectId: project.projectId,
-        }, nowIso),
-        source: 'current_turn',
-      };
-    }
-    const pending = newestPending(candidates);
-    return pending === null ? null : { ...pending, source: 'persisted' };
-  } catch {
-    return signal === null ? null : {
-      ...signal,
-      source: 'current_turn',
-      status: 'pending',
-    };
-  }
-}
-
-module.exports = {
-  detectValidatedLearningSignal,
-  normalizeCommand,
-  pruneTerminalValidatedLearningCandidates,
-  readValidatedLearningCandidates,
-  resolveValidatedLearningProject,
-  syncValidatedLearningCandidate,
-};