blun-king-cli 9.1.587 → 9.1.588

package/bin/editable-tool-approval-runtime.cjs

@@ -1,99 +0,0 @@
-'use strict';
-
-const {
-  canonicalEditedToolInputJson,
-  validateEditedToolInputObject,
-} = require('./editable-tool-approval-policy.cjs');
-
-class EditableToolReprepareError extends Error {
-  constructor(code, message) {
-    super(message);
-    this.name = 'EditableToolReprepareError';
-    this.code = code;
-  }
-}
-
-function fail(code, message) {
-  throw new EditableToolReprepareError(code, message);
-}
-
-function buildEditedToolCallPlan({
-  step,
-  call,
-  editedArgs,
-  editCount,
-  preflightToolCall,
-} = {}) {
-  if (editCount !== 0) {
-    fail('EDITED_REPREPARE_ALREADY_EDITED', 'A tool call may be edited at most once.');
-  }
-  if (call?.kind !== 'runnable' || call.toolCall === null || typeof call.toolCall !== 'object' || typeof call.toolCall.id !== 'string' || typeof call.toolCall.name !== 'string') {
-    fail('EDITED_REPREPARE_CALL_INVALID', 'Only a runnable tool call can be re-prepared.');
-  }
-  if (!Array.isArray(step?.toolCalls) || typeof preflightToolCall !== 'function') {
-    fail('EDITED_REPREPARE_CONTEXT_INVALID', 'Edited re-preparation requires the active ordered tool-call list and preflight function.');
-  }
-
-  const matchingIndexes = [];
-  for (let index = 0; index < step.toolCalls.length; index += 1) {
-    if (step.toolCalls[index]?.id === call.toolCall.id) matchingIndexes.push(index);
-  }
-  if (matchingIndexes.length === 0) {
-    fail('EDITED_REPREPARE_IDENTITY_MISSING', 'The edited tool call is absent from the active ordered call list.');
-  }
-  if (matchingIndexes.length !== 1) {
-    fail('EDITED_REPREPARE_IDENTITY_AMBIGUOUS', 'The edited tool-call ID is not unique in the active call list.');
-  }
-  const position = matchingIndexes[0];
-  if (step.toolCalls[position] !== call.toolCall || call.toolName !== call.toolCall.name) {
-    fail('EDITED_REPREPARE_IDENTITY_CHANGED', 'The active tool-call identity changed before re-preparation.');
-  }
-
-  const safeEditedArgs = validateEditedToolInputObject(editedArgs);
-  const patchedToolCall = Object.freeze({
-    ...call.toolCall,
-    id: call.toolCall.id,
-    name: call.toolCall.name,
-    arguments: canonicalEditedToolInputJson(safeEditedArgs),
-  });
-  const patchedToolCalls = step.toolCalls.slice();
-  patchedToolCalls[position] = patchedToolCall;
-  const editedStep = {
-    ...step,
-    toolCalls: Object.freeze(patchedToolCalls),
-  };
-  const repreflight = preflightToolCall(editedStep, patchedToolCall);
-  if (repreflight === null || typeof repreflight !== 'object') {
-    fail('EDITED_REPREPARE_PREFLIGHT_INVALID', 'Edited tool preflight returned no result.');
-  }
-  if (repreflight.toolCall?.id !== call.toolCall.id || repreflight.toolCall?.name !== call.toolCall.name || repreflight.toolName !== call.toolName) {
-    fail('EDITED_REPREPARE_IDENTITY_CHANGED', 'Edited preflight changed the immutable tool identity.');
-  }
-  if (repreflight.kind === 'rejected') {
-    return Object.freeze({
-      kind: 'rejected',
-      step: editedStep,
-      call: repreflight,
-      editCount: 1,
-      output: repreflight.output,
-    });
-  }
-  if (repreflight.kind !== 'runnable') {
-    fail('EDITED_REPREPARE_PREFLIGHT_INVALID', 'Edited preflight returned an unsupported call state.');
-  }
-  if (repreflight.tool !== call.tool) {
-    fail('EDITED_REPREPARE_REGISTRY_CHANGED', 'The authoritative tool registry entry changed during edited approval.');
-  }
-  return Object.freeze({
-    kind: 'runnable',
-    step: editedStep,
-    call: repreflight,
-    editCount: 1,
-  });
-}
-
-module.exports = Object.freeze({
-  EditableToolReprepareError,
-  buildEditedToolCallPlan,
-});
-

package/bin/effective-system-prompt-cache-policy.cjs

@@ -1,33 +0,0 @@
-'use strict';
-
-function joinSystemPrompt(base, append) {
-  if (append.length === 0) return base;
-  return base.length === 0 ? append : `${base}\n\n${append}`;
-}
-
-function createEffectiveSystemPromptResolver(joinPrompts = joinSystemPrompt) {
-  if (typeof joinPrompts !== 'function') {
-    throw new TypeError('joinPrompts must be a function');
-  }
-
-  let initialized = false;
-  let cachedBase = '';
-  let cachedAppend = '';
-  let cachedPrompt = '';
-
-  return function resolveEffectiveSystemPrompt(base, append) {
-    if (initialized && base === cachedBase && append === cachedAppend) {
-      return cachedPrompt;
-    }
-
-    cachedPrompt = joinPrompts(base, append);
-    cachedBase = base;
-    cachedAppend = append;
-    initialized = true;
-    return cachedPrompt;
-  };
-}
-
-module.exports = {
-  createEffectiveSystemPromptResolver,
-};

package/bin/error-memory-performance-policy.cjs

@@ -1,113 +0,0 @@
-'use strict';
-
-const ERROR_MEMORY_MAX_CHARS = 2_800;
-const ERROR_MEMORY_MAX_PATTERNS = 6;
-const CORE_PATTERN_NUMBERS = new Set([4, 9, 10, 11]);
-const STOP_WORDS = new Set([
-  'aber', 'alle', 'alles', 'auch', 'belegt', 'beweis', 'echt', 'echte', 'echten',
-  'echter', 'eine', 'einem', 'einen', 'einer', 'das', 'den', 'fuer', 'gegen',
-  'haben', 'hier', 'immer',
-  'jetzt', 'kann', 'machen', 'mehr', 'nicht', 'noch', 'oder', 'pruefe', 'pruefen',
-  'pruefung', 'sein', 'sind', 'soll', 'und', 'vollstaendig', 'vollstaendige',
-  'wenn', 'werden', 'with', 'that',
-  'this', 'from', 'have', 'into', 'your', 'you', 'the', 'and', 'for', 'are',
-]);
-
-function normalizedTerms(value) {
-  return [...new Set(String(value || '')
-    .normalize('NFKD')
-    .replace(/\p{M}/gu, '')
-    .toLowerCase()
-    .match(/[\p{L}\p{N}_-]{3,}/gu) || [])]
-    .filter((term) => !STOP_WORDS.has(term));
-}
-
-function fieldMatchesTerm(fieldTerms, term) {
-  return fieldTerms.some((fieldTerm) => (
-    fieldTerm === term
-    || (term.length >= 6 && fieldTerm.includes(term))
-    || (fieldTerm.length >= 6 && term.includes(fieldTerm))
-  ));
-}
-
-function selectRelevantErrorMemoryPatterns(patterns, query, options = {}) {
-  const maxPatterns = Math.max(1, Number(options.maxPatterns) || ERROR_MEMORY_MAX_PATTERNS);
-  const source = Array.isArray(patterns) ? patterns.filter(Boolean) : [];
-  if (source.length <= maxPatterns) return source;
-
-  const queryTerms = normalizedTerms(query);
-  const ranked = source.map((pattern, index) => {
-    const title = normalizedTerms(pattern.title);
-    const rule = normalizedTerms(pattern.rule);
-    const check = normalizedTerms(pattern.check);
-    let score = 0;
-    for (const term of queryTerms) {
-      if (fieldMatchesTerm(title, term)) score += 4;
-      if (fieldMatchesTerm(rule, term)) score += 2;
-      if (fieldMatchesTerm(check, term)) score += 1;
-    }
-    return { index, pattern, score };
-  });
-  const selectedIndexes = new Set(ranked
-    .filter(({ pattern }) => CORE_PATTERN_NUMBERS.has(Number(pattern.number)))
-    .map(({ index }) => index));
-  ranked
-    .filter(({ index, score }) => !selectedIndexes.has(index) && score > 0)
-    .sort((left, right) => right.score - left.score || left.index - right.index)
-    .slice(0, Math.max(0, maxPatterns - selectedIndexes.size))
-    .forEach(({ index }) => selectedIndexes.add(index));
-
-  if (selectedIndexes.size === 0) {
-    source.slice(-Math.min(2, maxPatterns)).forEach((pattern) => {
-      selectedIndexes.add(source.indexOf(pattern));
-    });
-  }
-  return source.filter((pattern, index) => selectedIndexes.has(index)).slice(0, maxPatterns);
-}
-
-function buildCompactErrorMemoryReminder(patterns) {
-  const lines = [
-    '<error-memory-check>',
-    'Vor Abschluss jede Regel pruefen; Verletzungen korrigieren oder offen benennen.',
-  ];
-
-  for (const pattern of patterns) {
-    const check = pattern.check ? ` | Pruefung: ${pattern.check}` : '';
-    lines.push(`${pattern.number}. ${pattern.rule}${check}`);
-  }
-
-  lines.push(
-    'Arbeitsweise: 3-7 sichtbare Schritte; Werkzeuge proaktiv; nach zwei gleichen Fehlern Ansatz wechseln; Schritte erst nach echtem Nachweis abschliessen; nach Zielerreichung stoppen; Teilerfolg oder Scheitern mit Grund und naechstem Schritt offen melden.',
-    '</error-memory-check>',
-  );
-  return lines.join('\n');
-}
-
-function compactLegacyErrorMemoryReminder(text) {
-  const source = String(text);
-  if (!source.includes('<error-memory-check>') || !source.includes('  Regel: ')) return source;
-
-  const lines = source.split(/\r?\n/u);
-  const patterns = [];
-  for (let index = 0; index + 1 < lines.length; index += 1) {
-    const title = lines[index].match(/^\s*(\d+)\.\s+(.+)$/u);
-    const rule = lines[index + 1].match(/^\s*Regel:\s*(.+)$/u);
-    if (!title || !rule) continue;
-    const check = lines[index + 2]?.match(/^\s*Pruefung:\s*(.+)$/u);
-    patterns.push({
-      number: Number(title[1]),
-      title: title[2],
-      rule: rule[1],
-      check: check?.[1],
-    });
-  }
-  return patterns.length > 0 ? buildCompactErrorMemoryReminder(patterns) : source;
-}
-
-module.exports = {
-  ERROR_MEMORY_MAX_PATTERNS,
-  ERROR_MEMORY_MAX_CHARS,
-  buildCompactErrorMemoryReminder,
-  compactLegacyErrorMemoryReminder,
-  selectRelevantErrorMemoryPatterns,
-};

package/bin/file-observation-policy.cjs

@@ -1,133 +0,0 @@
-'use strict';
-
-function versionFromStat(stat) {
-  if (!stat || typeof stat !== 'object') return null;
-  return [
-    stat.stDev ?? null,
-    stat.stIno ?? null,
-    stat.stSize ?? null,
-    stat.stMtime ?? null,
-  ].join(':');
-}
-
-function isNotFoundError(error) {
-  return error?.code === 'ENOENT' || error?.code === 'ENOTDIR';
-}
-
-function createFileObservationPolicy(options = {}) {
-  const caseInsensitive = options.pathClass === 'win32';
-  const observations = new Map();
-
-  function key(filePath) {
-    const normalized = String(filePath).replaceAll('\\', '/');
-    return caseInsensitive ? normalized.toLowerCase() : normalized;
-  }
-
-  function recordPresent(filePath, stat) {
-    const version = versionFromStat(stat);
-    if (version === null) throw new TypeError('recordPresent requires a file stat');
-    observations.set(key(filePath), { kind: 'present', version });
-  }
-
-  function recordAbsent(filePath) {
-    observations.set(key(filePath), { kind: 'absent' });
-  }
-
-  function verifyStableRead(filePath, before, after) {
-    const beforeVersion = versionFromStat(before);
-    const afterVersion = versionFromStat(after);
-    if (beforeVersion === null || afterVersion === null || beforeVersion !== afterVersion) {
-      return {
-        allowed: false,
-        code: 'FS_STALE_VERSION',
-        error: `File changed while reading "${filePath}". Read it again before editing or overwriting it.`,
-      };
-    }
-    recordPresent(filePath, after);
-    return { allowed: true, version: afterVersion };
-  }
-
-  function authorizeEdit(filePath, currentStat) {
-    const prior = observations.get(key(filePath));
-    if (currentStat === null) {
-      return {
-        allowed: false,
-        code: prior?.kind === 'absent' ? 'FS_NOT_FOUND' : 'FS_NOT_OBSERVED',
-        error: prior?.kind === 'absent'
-          ? `Cannot edit "${filePath}": the last Read confirmed that it does not exist.`
-          : `Edit requires reading "${filePath}" first. Read the exact target path, then retry.`,
-      };
-    }
-    if (prior === undefined) {
-      return {
-        allowed: false,
-        code: 'FS_NOT_OBSERVED',
-        error: `Edit requires reading "${filePath}" first. Read the exact target path, then retry.`,
-      };
-    }
-    if (prior.kind !== 'present' || prior.version !== versionFromStat(currentStat)) {
-      return {
-        allowed: false,
-        code: 'FS_STALE_VERSION',
-        error: `"${filePath}" changed since the last Read. Read it again, then retry the Edit.`,
-      };
-    }
-    return { allowed: true, version: prior.version };
-  }
-
-  function authorizeWrite(filePath, currentStat) {
-    const prior = observations.get(key(filePath));
-    if (currentStat === null) {
-      if (prior?.kind === 'present') {
-        return {
-          allowed: false,
-          code: 'FS_STALE_VERSION',
-          error: `"${filePath}" disappeared since the last Read. Read it again before recreating it.`,
-        };
-      }
-      return { allowed: true, version: null, create: true };
-    }
-    if (prior === undefined) {
-      return {
-        allowed: false,
-        code: 'FS_NOT_OBSERVED',
-        error: `Write would replace or append to existing file "${filePath}" without a prior Read. Read it first, then retry.`,
-      };
-    }
-    if (prior.kind !== 'present' || prior.version !== versionFromStat(currentStat)) {
-      return {
-        allowed: false,
-        code: 'FS_STALE_VERSION',
-        error: `"${filePath}" changed since the last Read. Read it again, then retry the Write.`,
-      };
-    }
-    return { allowed: true, version: prior.version, create: false };
-  }
-
-  function verifyUnchanged(filePath, expectedVersion, currentStat) {
-    const currentVersion = versionFromStat(currentStat);
-    if (expectedVersion === currentVersion) return { allowed: true };
-    return {
-      allowed: false,
-      code: 'FS_STALE_VERSION',
-      error: expectedVersion === null
-        ? `"${filePath}" appeared before the new file could be created. Read it before deciding whether to overwrite it.`
-        : `"${filePath}" changed before the mutation was written. Read it again, then retry.`,
-    };
-  }
-
-  return {
-    authorizeEdit,
-    authorizeWrite,
-    recordAbsent,
-    recordPresent,
-    verifyStableRead,
-    verifyUnchanged,
-  };
-}
-
-module.exports = {
-  createFileObservationPolicy,
-  isNotFoundError,
-  versionFromStat,
-};

package/bin/foreground-output-capture-policy.cjs

@@ -1,41 +0,0 @@
-'use strict';
-
-const MAX_FOREGROUND_CAPTURE_BYTES = 16 * 1024 * 1024;
-
-function utf8PrefixWithinBytes(text, maxBytes) {
-  if (maxBytes <= 0 || text.length === 0) return '';
-  if (Buffer.byteLength(text, 'utf8') <= maxBytes) return text;
-
-  let low = 0;
-  let high = text.length;
-  while (low < high) {
-    const middle = Math.ceil((low + high) / 2);
-    if (Buffer.byteLength(text.slice(0, middle), 'utf8') <= maxBytes) low = middle;
-    else high = middle - 1;
-  }
-  if (low > 0 && low < text.length) {
-    const last = text.charCodeAt(low - 1);
-    if (last >= 0xD800 && last <= 0xDBFF) low -= 1;
-  }
-  return text.slice(0, low);
-}
-
-function captureForegroundOutputChunk(text, capturedBytes, maxBytes = MAX_FOREGROUND_CAPTURE_BYTES) {
-  const observedBytes = Buffer.byteLength(text, 'utf8');
-  const remainingBytes = Math.max(0, maxBytes - Math.max(0, capturedBytes));
-  const capturedText = utf8PrefixWithinBytes(text, remainingBytes);
-  const newCapturedBytes = Buffer.byteLength(capturedText, 'utf8');
-  return {
-    capturedText,
-    observedBytes,
-    capturedBytes: newCapturedBytes,
-    droppedBytes: observedBytes - newCapturedBytes,
-    capped: newCapturedBytes < observedBytes,
-  };
-}
-
-module.exports = {
-  MAX_FOREGROUND_CAPTURE_BYTES,
-  captureForegroundOutputChunk,
-  utf8PrefixWithinBytes,
-};

package/bin/generated-source-health.cjs

@@ -1,142 +0,0 @@
-'use strict';
-
-const path = require('node:path');
-
-const JAVASCRIPT_LIKE_EXTENSIONS = new Set([
-  '.cjs',
-  '.cts',
-  '.js',
-  '.jsx',
-  '.mjs',
-  '.mts',
-  '.ts',
-  '.tsx',
-]);
-const DEFAULT_MIN_REPEATS = 8;
-
-function findDegenerateGeneratedStatementRun(filePath, content, options = {}) {
-  if (!JAVASCRIPT_LIKE_EXTENSIONS.has(path.extname(filePath).toLowerCase())) return null;
-  if (typeof content !== 'string' || content.length === 0) return null;
-
-  const minRepeats = Number.isSafeInteger(options.minRepeats) && options.minRepeats >= 2
-    ? options.minRepeats
-    : DEFAULT_MIN_REPEATS;
-  let state = 'code';
-  let quote = '';
-  let escaped = false;
-  let line = 1;
-  let statementStart = 0;
-  let statementStartLine = 1;
-  let parenDepth = 0;
-  let bracketDepth = 0;
-  let previous = null;
-  let runCount = 0;
-  let runLine = 1;
-
-  const resetBoundary = (nextStart) => {
-    statementStart = nextStart;
-    statementStartLine = line;
-  };
-  const recordStatement = (end) => {
-    const raw = content.slice(statementStart, end);
-    const rawStartLine = statementStartLine;
-    resetBoundary(end);
-    const leading = raw.match(/^\s*/u)?.[0] ?? '';
-    const statementLine = rawStartLine + (leading.match(/\n/gu)?.length ?? 0);
-    const normalized = raw.replace(/\s+/gu, ' ').trim();
-    if (normalized.length === 0 || !/[A-Za-z_$]/u.test(normalized)) {
-      previous = null;
-      runCount = 0;
-      return null;
-    }
-    if (normalized === previous) runCount += 1;
-    else {
-      previous = normalized;
-      runCount = 1;
-      runLine = statementLine;
-    }
-    if (runCount < minRepeats) return null;
-    return {
-      count: runCount,
-      line: runLine,
-      preview: normalized.slice(0, 160),
-    };
-  };
-
-  for (let index = 0; index < content.length; index += 1) {
-    const current = content[index] ?? '';
-    const next = content[index + 1] ?? '';
-
-    if (state === 'line-comment') {
-      if (current === '\n') {
-        line += 1;
-        state = 'code';
-      }
-      continue;
-    }
-    if (state === 'block-comment') {
-      if (current === '\n') line += 1;
-      if (current === '*' && next === '/') {
-        state = 'code';
-        index += 1;
-      }
-      continue;
-    }
-    if (state === 'quote') {
-      if (current === '\n') line += 1;
-      if (escaped) {
-        escaped = false;
-        continue;
-      }
-      if (current === '\\') {
-        escaped = true;
-        continue;
-      }
-      if (current === quote) {
-        state = 'code';
-        quote = '';
-      }
-      continue;
-    }
-
-    if (current === '\n') {
-      line += 1;
-      continue;
-    }
-    if (current === '/' && next === '/') {
-      state = 'line-comment';
-      index += 1;
-      continue;
-    }
-    if (current === '/' && next === '*') {
-      state = 'block-comment';
-      index += 1;
-      continue;
-    }
-    if (current === "'" || current === '"' || current === '`') {
-      state = 'quote';
-      quote = current;
-      escaped = false;
-      continue;
-    }
-    if (current === '(') parenDepth += 1;
-    else if (current === ')') parenDepth = Math.max(0, parenDepth - 1);
-    else if (current === '[') bracketDepth += 1;
-    else if (current === ']') bracketDepth = Math.max(0, bracketDepth - 1);
-    else if ((current === '{' || current === '}') && parenDepth === 0 && bracketDepth === 0) {
-      previous = null;
-      runCount = 0;
-      resetBoundary(index + 1);
-    } else if (current === ';' && parenDepth === 0 && bracketDepth === 0) {
-      const finding = recordStatement(index + 1);
-      if (finding !== null) return finding;
-    }
-  }
-
-  return null;
-}
-
-module.exports = {
-  DEFAULT_MIN_REPEATS,
-  findDegenerateGeneratedStatementRun,
-};

package/bin/glob-pattern-policy.cjs

@@ -1,13 +0,0 @@
-"use strict";
-
-function quotedPattern(pattern) {
-  return `'${pattern.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
-}
-
-function globPatternError(pattern) {
-  if (typeof pattern !== "string") return "Invalid glob pattern";
-  if (!pattern.replaceAll("\\", "/").split("/").includes("..")) return undefined;
-  return `Path traversal not allowed in glob pattern ${quotedPattern(pattern)}`;
-}
-
-module.exports = { globPatternError };

package/bin/goal-completion-evidence-policy.cjs

@@ -1,120 +0,0 @@
-'use strict';
-
-const {
-  completionCriterionRef,
-  normalizeVerificationProof,
-} = require('./cognitive-action-checkpoint.cjs');
-
-function hasCompletionCriterion(goal) {
-  return typeof goal?.completionCriterion === 'string'
-    && goal.completionCriterion.trim().length > 0;
-}
-
-function successfulRuntimeEvidence(checkpoint) {
-  const successfulTools = Number(checkpoint?.evidenceReceipt?.successfulTools);
-  return Number.isSafeInteger(successfulTools) && successfulTools > 0;
-}
-
-function verificationProofGaps(checkpoint, criterion, expectedProducerRef) {
-  if (!checkpoint?.verificationProof) {
-    return ['Bind the completion claim to a successful verification tool from the checkpoint turn.'];
-  }
-  try {
-    const proof = normalizeVerificationProof(
-      checkpoint.verificationProof,
-      checkpoint.evidenceReceipt,
-      { allowLegacy: true },
-    );
-    if (proof.criterionRef !== completionCriterionRef(criterion)) {
-      return ['Bind the completion proof to the active completion criterion.'];
-    }
-    if (expectedProducerRef !== undefined && proof.producerRef === undefined) {
-      return ['Bind the completion proof to the runtime that produced its measurement.'];
-    }
-    if (expectedProducerRef !== undefined && proof.producerRef !== expectedProducerRef) {
-      return ['The completion proof was produced by a different agent session; preserve it as an external report instead of relabelling it as local verification.'];
-    }
-    return [];
-  } catch (error) {
-    if (/verifier proof requires a sharpnessProof|sharpnessProof must name a distinct verification call/u
-      .test(String(error?.message ?? ''))) {
-      return ['A verifier completion needs a distinct current-turn counterexample or mutation call.'];
-    }
-    if (/sharpnessProof must match a successful current-turn verification call/u
-      .test(String(error?.message ?? ''))) {
-      return ['The verifier sharpness proof does not match a successful current-turn verification call.'];
-    }
-    if (/(?:verificationProof|sharpnessProof) kind must match the successful current-turn verification call/u
-      .test(String(error?.message ?? ''))) {
-      return ['The completion proof kind exceeds what its exact verification call measured.'];
-    }
-    if (/(?:verificationProof|sharpnessProof) scope must match the successful current-turn verification call target/u
-      .test(String(error?.message ?? ''))) {
-      return ['Bind the completion proof scope to the exact target measured by its successful current-turn verification call.'];
-    }
-    if (/action-only tool/u.test(String(error?.message ?? ''))) {
-      return ['The completion proof names an action-only tool, not a verification tool.'];
-    }
-    if (/successful current-turn (?:tool|verification call)/u.test(String(error?.message ?? ''))) {
-      return ['The completion proof does not match a successful verification call from the checkpoint turn.'];
-    }
-    return ['The completion verification proof is malformed.'];
-  }
-}
-
-function evaluateGoalCompletionEvidence(goal, options = {}) {
-  if (!hasCompletionCriterion(goal)) {
-    return {
-      required: false,
-      allPassed: true,
-      result: 'satisfied',
-      gaps: [],
-    };
-  }
-
-  const checkpoint = goal?.actionCheckpoint;
-  if (!checkpoint || typeof checkpoint !== 'object' || Array.isArray(checkpoint)) {
-    return {
-      required: true,
-      allPassed: false,
-      result: 'needs_revision',
-      gaps: ['Save a verify-phase action checkpoint before completing the goal.'],
-    };
-  }
-
-  const gaps = [];
-  if (checkpoint.phase !== 'verify') {
-    gaps.push('The latest action checkpoint must be in the verify phase.');
-  }
-  if (checkpoint.evidenceBasis !== 'runtime_tool') {
-    gaps.push('The completion proof must come from a runtime tool.');
-  }
-  if (checkpoint.epistemicState !== 'verified') {
-    gaps.push('The completion proof must be classified as verified.');
-  }
-  const hasRuntimeEvidence = successfulRuntimeEvidence(checkpoint);
-  if (!hasRuntimeEvidence) {
-    gaps.push('The runtime evidence receipt must contain at least one successful tool result.');
-  }
-  if (checkpoint.phase === 'verify'
-      && checkpoint.evidenceBasis === 'runtime_tool'
-      && checkpoint.epistemicState === 'verified'
-      && hasRuntimeEvidence) {
-    gaps.push(...verificationProofGaps(
-      checkpoint,
-      goal.completionCriterion,
-      options.expectedProducerRef,
-    ));
-  }
-
-  return {
-    required: true,
-    allPassed: gaps.length === 0,
-    result: gaps.length === 0 ? 'satisfied' : 'needs_revision',
-    gaps,
-  };
-}
-
-module.exports = {
-  evaluateGoalCompletionEvidence,
-};