@hiveai/core 0.10.1 → 0.10.3

package/dist/index.d.ts

@@ -16,6 +16,56 @@ declare const AnchorSchema: z.ZodObject<{
     paths?: string[] | undefined;
     symbols?: string[] | undefined;
 }>;
+/**
+ * An executable check derived from a memory — the "feedback computational" layer.
+ *
+ * A `gotcha`/`attempt` is normally feedforward (text the agent reads). A sensor turns
+ * that lesson into a deterministic check: when a touched file matches `pattern`, the
+ * memory's warning fires regardless of semantic ranking. This closes the harness loop —
+ * a documented mistake becomes a permanent guardrail.
+ *
+ * Phase 1 implements `kind: "regex"` only. `shell`/`test` are reserved for a later phase
+ * (they require I/O and must run from the CLI, not core).
+ */
+declare const SensorSchema: z.ZodObject<{
+    kind: z.ZodDefault<z.ZodEnum<["regex", "shell", "test"]>>;
+    /** Regex source (for kind=regex), matched against added diff lines / file content. */
+    pattern: z.ZodOptional<z.ZodString>;
+    /** Regex flags (e.g. "i", "m"). Ignored for non-regex kinds. */
+    flags: z.ZodOptional<z.ZodString>;
+    /** Shell/test command to run (for kind=shell|test). Executed by the CLI, never by core. */
+    command: z.ZodOptional<z.ZodString>;
+    /** Glob-ish path prefixes the sensor applies to. Falls back to the memory's anchor paths when empty. */
+    paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** LLM-facing self-correction message: what was done wrong and what to do instead. */
+    message: z.ZodString;
+    /** `warn` surfaces in review; `block` can hard-block the commit (only when the gate opts in). */
+    severity: z.ZodDefault<z.ZodEnum<["warn", "block"]>>;
+    /** True when hAIve generated this sensor automatically (vs. hand-authored). */
+    autogen: z.ZodDefault<z.ZodBoolean>;
+    /** ISO timestamp of the last time this sensor matched a diff. */
+    last_fired: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    paths: string[];
+    kind: "regex" | "shell" | "test";
+    severity: "warn" | "block";
+    autogen: boolean;
+    last_fired: string | null;
+    pattern?: string | undefined;
+    flags?: string | undefined;
+    command?: string | undefined;
+}, {
+    message: string;
+    paths?: string[] | undefined;
+    kind?: "regex" | "shell" | "test" | undefined;
+    pattern?: string | undefined;
+    flags?: string | undefined;
+    command?: string | undefined;
+    severity?: "warn" | "block" | undefined;
+    autogen?: boolean | undefined;
+    last_fired?: string | null | undefined;
+}>;
 declare const MemoryFrontmatterSchema: z.ZodEffects<z.ZodObject<{
     id: z.ZodString;
     scope: z.ZodDefault<z.ZodEnum<["personal", "team", "module", "shared"]>>;
@@ -35,6 +85,46 @@ declare const MemoryFrontmatterSchema: z.ZodEffects<z.ZodObject<{
         paths?: string[] | undefined;
         symbols?: string[] | undefined;
     }>>;
+    /** Optional executable check derived from this memory (feedback computational layer). */
+    sensor: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodDefault<z.ZodEnum<["regex", "shell", "test"]>>;
+        /** Regex source (for kind=regex), matched against added diff lines / file content. */
+        pattern: z.ZodOptional<z.ZodString>;
+        /** Regex flags (e.g. "i", "m"). Ignored for non-regex kinds. */
+        flags: z.ZodOptional<z.ZodString>;
+        /** Shell/test command to run (for kind=shell|test). Executed by the CLI, never by core. */
+        command: z.ZodOptional<z.ZodString>;
+        /** Glob-ish path prefixes the sensor applies to. Falls back to the memory's anchor paths when empty. */
+        paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** LLM-facing self-correction message: what was done wrong and what to do instead. */
+        message: z.ZodString;
+        /** `warn` surfaces in review; `block` can hard-block the commit (only when the gate opts in). */
+        severity: z.ZodDefault<z.ZodEnum<["warn", "block"]>>;
+        /** True when hAIve generated this sensor automatically (vs. hand-authored). */
+        autogen: z.ZodDefault<z.ZodBoolean>;
+        /** ISO timestamp of the last time this sensor matched a diff. */
+        last_fired: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        paths: string[];
+        kind: "regex" | "shell" | "test";
+        severity: "warn" | "block";
+        autogen: boolean;
+        last_fired: string | null;
+        pattern?: string | undefined;
+        flags?: string | undefined;
+        command?: string | undefined;
+    }, {
+        message: string;
+        paths?: string[] | undefined;
+        kind?: "regex" | "shell" | "test" | undefined;
+        pattern?: string | undefined;
+        flags?: string | undefined;
+        command?: string | undefined;
+        severity?: "warn" | "block" | undefined;
+        autogen?: boolean | undefined;
+        last_fired?: string | null | undefined;
+    }>>;
     tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     domain: z.ZodOptional<z.ZodString>;
     author: z.ZodOptional<z.ZodString>;
@@ -73,6 +163,17 @@ declare const MemoryFrontmatterSchema: z.ZodEffects<z.ZodObject<{
     revision_count: number;
     requires_human_approval: boolean;
     module?: string | undefined;
+    sensor?: {
+        message: string;
+        paths: string[];
+        kind: "regex" | "shell" | "test";
+        severity: "warn" | "block";
+        autogen: boolean;
+        last_fired: string | null;
+        pattern?: string | undefined;
+        flags?: string | undefined;
+        command?: string | undefined;
+    } | undefined;
     domain?: string | undefined;
     author?: string | undefined;
     topic?: string | undefined;
@@ -88,6 +189,17 @@ declare const MemoryFrontmatterSchema: z.ZodEffects<z.ZodObject<{
         paths?: string[] | undefined;
         symbols?: string[] | undefined;
     } | undefined;
+    sensor?: {
+        message: string;
+        paths?: string[] | undefined;
+        kind?: "regex" | "shell" | "test" | undefined;
+        pattern?: string | undefined;
+        flags?: string | undefined;
+        command?: string | undefined;
+        severity?: "warn" | "block" | undefined;
+        autogen?: boolean | undefined;
+        last_fired?: string | null | undefined;
+    } | undefined;
     tags?: string[] | undefined;
     domain?: string | undefined;
     author?: string | undefined;
@@ -119,6 +231,17 @@ declare const MemoryFrontmatterSchema: z.ZodEffects<z.ZodObject<{
     revision_count: number;
     requires_human_approval: boolean;
     module?: string | undefined;
+    sensor?: {
+        message: string;
+        paths: string[];
+        kind: "regex" | "shell" | "test";
+        severity: "warn" | "block";
+        autogen: boolean;
+        last_fired: string | null;
+        pattern?: string | undefined;
+        flags?: string | undefined;
+        command?: string | undefined;
+    } | undefined;
     domain?: string | undefined;
     author?: string | undefined;
     topic?: string | undefined;
@@ -134,6 +257,17 @@ declare const MemoryFrontmatterSchema: z.ZodEffects<z.ZodObject<{
         paths?: string[] | undefined;
         symbols?: string[] | undefined;
     } | undefined;
+    sensor?: {
+        message: string;
+        paths?: string[] | undefined;
+        kind?: "regex" | "shell" | "test" | undefined;
+        pattern?: string | undefined;
+        flags?: string | undefined;
+        command?: string | undefined;
+        severity?: "warn" | "block" | undefined;
+        autogen?: boolean | undefined;
+        last_fired?: string | null | undefined;
+    } | undefined;
     tags?: string[] | undefined;
     domain?: string | undefined;
     author?: string | undefined;
@@ -167,6 +301,7 @@ type MemoryScope = z.infer<typeof MemoryScopeSchema>;
 type MemoryStatus = z.infer<typeof MemoryStatusSchema>;
 type MemoryType = z.infer<typeof MemoryTypeSchema>;
 type Anchor = z.infer<typeof AnchorSchema>;
+type Sensor = z.infer<typeof SensorSchema>;
 type MemoryFrontmatter = z.infer<typeof MemoryFrontmatterSchema>;
 interface Memory {
     frontmatter: MemoryFrontmatter;
@@ -939,4 +1074,67 @@ interface RetirementSignal {
 declare function retirementSignal(fm: MemoryFrontmatter, body?: string, now?: Date): RetirementSignal;
 declare function isRetiredMemory(fm: MemoryFrontmatter, body?: string, now?: Date): boolean;
 
-export { AUTOPILOT_DEFAULTS, type Anchor, AnchorSchema, type AntiPatternGate, type AutoPromoteRule, BRIEFING_MARKER_TTL_MS, BRIEFING_PRESET_DEFAULTS, type BreakingChange, type BriefingBudgetNumbers, type BriefingBudgetPreset, type BriefingMarker, type BudgetPart, type BudgetSlice, type BuildCodeMapOptions, CHARS_PER_TOKEN, CODE_MAP_FILE, CONFIG_FILE, type CodeExport, type CodeExportKind, type CodeFileEntry, type CodeMap, type CodeMapQueryOptions, type CollectTimelineOpts, type ConfidenceLevel, type ConfidenceThresholds, type ConflictCandidatePair, type ConflictCandidatesOpts, type ContractDiffResult, type ContractFile, type ContractSnapshot, CrossRepoProvenanceSchema, type CrossRepoReport, type CrossRepoSource, DECAY_DAYS, DEFAULT_AUTO_PROMOTE_RULE, DEFAULT_CONFIDENCE_THRESHOLDS, DEFAULT_CONFIG, type DepChange, type DepTrackResult, type DependencySnapshot, GUESSABLE_THRESHOLD, HAIVE_DIR, type HaiveConfig, type HaivePaths, type LexicalRankResult, type LoadedMemory, MEMORIES_DIR, type Memory, type MemoryFrontmatter, MemoryFrontmatterSchema, type MemoryScope, MemoryScopeSchema, type MemoryStatus, MemoryStatusSchema, type MemoryType, MemoryTypeSchema, type MemoryUsage, PROJECT_CONTEXT_FILE, RUNTIME_JOURNAL_FILENAME, type ResolveProjectInfo, type RetirementSignal, type RuntimeJournalEntry, SESSION_RECAP_TTL_MS, STACK_PACK_TAG, type TimelineEntry, type TopicStatusPair, type TruncateOptions, type TruncateResult, USAGE_FILE, USAGE_LOG_DIR, USAGE_LOG_FILE, type UsageAggregate, type UsageEvent, type UsageIndex, type VerifyOptions, type VerifyResult, aggregateUsage, allocateBudget, antiPatternGateParams, appendRuntimeJournalEntry, appendUsageEvent, briefingMarkerPath, briefingMarkersDir, buildCodeMap, buildFrontmatter, bumpRead, codeMapPath, collectTimelineEntries, configPath, contractLockPath, deriveConfidence, diffContract, emptyUsage, emptyUsageIndex, enforcementDir, estimateTokens, extractActionsBriefBody, extractSnippet, findLexicalConflictPairs, findProjectRoot, findTopicStatusConflictPairs, firstMemoryOneLine, getUsage, globToRegExp, hasRecentBriefingMarker, inferModulesFromPaths, isAutoPromoteEligible, isDecaying, isFreshIsoDate, isGlobPath, isLikelyGuessable, isRetiredMemory, isStackPackSeed, listMarkdownFilesRecursive, literalMatchesAllTokens, literalMatchesAnyToken, loadCodeMap, loadConfig, loadConfigSync, loadMemoriesFromDir, loadMemory, loadUsageIndex, memoryFilePath, memoryMatchesAnchorPaths, newMemoryId, normalizeSessionId, parseMemory, parseSince, pathsOverlap, pickSnippetNeedle, pullCrossRepoSources, queryCodeMap, rankMemoriesLexical, readRecentBriefingMarker, readRuntimeJournalTail, readUsageEvents, recordRejection, relPathFrom, resolveBriefingBudget, resolveHaivePaths, resolveManifestFiles, resolveProjectInfo, retirementSignal, runtimeJournalPath, saveCodeMap, saveConfig, saveUsageIndex, serializeMemory, snapshotContract, specificityScore, stripPrivate, suggestTopicKey, tokenizeQuery, trackDependencies, trackReads, truncateToTokens, usageLogPath, usageLogSize, usagePath, verifyAnchor, watchContracts, writeBriefingMarker };
+/**
+ * Sensors — the feedback *computational* layer of the harness.
+ *
+ * A memory's `sensor` turns a documented lesson (gotcha/attempt) into a deterministic
+ * check. Unlike semantic anti-pattern matching (probabilistic, warmup-sensitive), a
+ * regex sensor fires the same way every time, so a known mistake becomes a permanent
+ * guardrail. Phase 1 supports `kind: "regex"` only — pure, no I/O. `shell`/`test`
+ * sensors are recognized but not executed here (they must run from the CLI).
+ */
+interface SensorHit {
+    /** The memory id whose sensor matched. */
+    memory_id: string;
+    /** The sensor that matched. */
+    sensor: Sensor;
+    /** Project-relative file the match was found in (when known). */
+    file?: string;
+    /** The matched line (trimmed, capped) — useful for review output. */
+    matched_line?: string;
+    /** LLM-facing self-correction message carried from the sensor. */
+    message: string;
+    severity: Sensor["severity"];
+}
+/** A unit of code to scan: a file path plus the text to match against. */
+interface SensorTarget {
+    /** Project-relative path (used for path scoping and reporting). */
+    path: string;
+    /**
+     * Text to scan. For a diff, pass only the added lines (callers should pre-filter)
+     * so a sensor fires on "you introduced the bad pattern", not "you touched a file
+     * that merely mentions it".
+     */
+    content: string;
+}
+/**
+ * Does this sensor apply to `path`? A sensor with no explicit `paths` (and whose
+ * memory has no anchor paths) applies everywhere. Otherwise it applies when the path
+ * starts with, or contains, any configured prefix.
+ */
+declare function sensorAppliesToPath(sensor: Sensor, anchorPaths: string[], path: string): boolean;
+/**
+ * Compile a regex sensor. Returns null when the sensor is not a runnable regex
+ * (wrong kind, missing/invalid pattern) so callers can skip it safely.
+ */
+declare function compileRegexSensor(sensor: Sensor): RegExp | null;
+/**
+ * Run a single regex sensor over one target. Returns the first matching line as a hit,
+ * or null. Deterministic and side-effect-free.
+ */
+declare function runRegexSensor(memoryId: string, sensor: Sensor, target: SensorTarget): SensorHit | null;
+/**
+ * Run every memory's regex sensor against every applicable target.
+ *
+ * Memories without a sensor, or with a non-regex sensor, are skipped (non-regex kinds
+ * are the CLI's responsibility). At most one hit per (memory, file) pair is returned.
+ */
+declare function runSensors(memories: Memory[], targets: SensorTarget[]): SensorHit[];
+/**
+ * Extract the added lines from a unified diff (lines starting with a single `+`,
+ * excluding the `+++` file header). Mirrors the diff-handling already used by the
+ * anti-pattern tokenizer so sensors fire on introductions, not mere mentions.
+ */
+declare function addedLinesFromDiff(diff: string): string;
+
+export { AUTOPILOT_DEFAULTS, type Anchor, AnchorSchema, type AntiPatternGate, type AutoPromoteRule, BRIEFING_MARKER_TTL_MS, BRIEFING_PRESET_DEFAULTS, type BreakingChange, type BriefingBudgetNumbers, type BriefingBudgetPreset, type BriefingMarker, type BudgetPart, type BudgetSlice, type BuildCodeMapOptions, CHARS_PER_TOKEN, CODE_MAP_FILE, CONFIG_FILE, type CodeExport, type CodeExportKind, type CodeFileEntry, type CodeMap, type CodeMapQueryOptions, type CollectTimelineOpts, type ConfidenceLevel, type ConfidenceThresholds, type ConflictCandidatePair, type ConflictCandidatesOpts, type ContractDiffResult, type ContractFile, type ContractSnapshot, CrossRepoProvenanceSchema, type CrossRepoReport, type CrossRepoSource, DECAY_DAYS, DEFAULT_AUTO_PROMOTE_RULE, DEFAULT_CONFIDENCE_THRESHOLDS, DEFAULT_CONFIG, type DepChange, type DepTrackResult, type DependencySnapshot, GUESSABLE_THRESHOLD, HAIVE_DIR, type HaiveConfig, type HaivePaths, type LexicalRankResult, type LoadedMemory, MEMORIES_DIR, type Memory, type MemoryFrontmatter, MemoryFrontmatterSchema, type MemoryScope, MemoryScopeSchema, type MemoryStatus, MemoryStatusSchema, type MemoryType, MemoryTypeSchema, type MemoryUsage, PROJECT_CONTEXT_FILE, RUNTIME_JOURNAL_FILENAME, type ResolveProjectInfo, type RetirementSignal, type RuntimeJournalEntry, SESSION_RECAP_TTL_MS, STACK_PACK_TAG, type Sensor, type SensorHit, SensorSchema, type SensorTarget, type TimelineEntry, type TopicStatusPair, type TruncateOptions, type TruncateResult, USAGE_FILE, USAGE_LOG_DIR, USAGE_LOG_FILE, type UsageAggregate, type UsageEvent, type UsageIndex, type VerifyOptions, type VerifyResult, addedLinesFromDiff, aggregateUsage, allocateBudget, antiPatternGateParams, appendRuntimeJournalEntry, appendUsageEvent, briefingMarkerPath, briefingMarkersDir, buildCodeMap, buildFrontmatter, bumpRead, codeMapPath, collectTimelineEntries, compileRegexSensor, configPath, contractLockPath, deriveConfidence, diffContract, emptyUsage, emptyUsageIndex, enforcementDir, estimateTokens, extractActionsBriefBody, extractSnippet, findLexicalConflictPairs, findProjectRoot, findTopicStatusConflictPairs, firstMemoryOneLine, getUsage, globToRegExp, hasRecentBriefingMarker, inferModulesFromPaths, isAutoPromoteEligible, isDecaying, isFreshIsoDate, isGlobPath, isLikelyGuessable, isRetiredMemory, isStackPackSeed, listMarkdownFilesRecursive, literalMatchesAllTokens, literalMatchesAnyToken, loadCodeMap, loadConfig, loadConfigSync, loadMemoriesFromDir, loadMemory, loadUsageIndex, memoryFilePath, memoryMatchesAnchorPaths, newMemoryId, normalizeSessionId, parseMemory, parseSince, pathsOverlap, pickSnippetNeedle, pullCrossRepoSources, queryCodeMap, rankMemoriesLexical, readRecentBriefingMarker, readRuntimeJournalTail, readUsageEvents, recordRejection, relPathFrom, resolveBriefingBudget, resolveHaivePaths, resolveManifestFiles, resolveProjectInfo, retirementSignal, runRegexSensor, runSensors, runtimeJournalPath, saveCodeMap, saveConfig, saveUsageIndex, sensorAppliesToPath, serializeMemory, snapshotContract, specificityScore, stripPrivate, suggestTopicKey, tokenizeQuery, trackDependencies, trackReads, truncateToTokens, usageLogPath, usageLogSize, usagePath, verifyAnchor, watchContracts, writeBriefingMarker };

package/dist/index.js

@@ -27,6 +27,25 @@ var AnchorSchema = z.object({
   paths: z.array(z.string()).default([]),
   symbols: z.array(z.string()).default([])
 });
+var SensorSchema = z.object({
+  kind: z.enum(["regex", "shell", "test"]).default("regex"),
+  /** Regex source (for kind=regex), matched against added diff lines / file content. */
+  pattern: z.string().optional(),
+  /** Regex flags (e.g. "i", "m"). Ignored for non-regex kinds. */
+  flags: z.string().optional(),
+  /** Shell/test command to run (for kind=shell|test). Executed by the CLI, never by core. */
+  command: z.string().optional(),
+  /** Glob-ish path prefixes the sensor applies to. Falls back to the memory's anchor paths when empty. */
+  paths: z.array(z.string()).default([]),
+  /** LLM-facing self-correction message: what was done wrong and what to do instead. */
+  message: z.string().min(1),
+  /** `warn` surfaces in review; `block` can hard-block the commit (only when the gate opts in). */
+  severity: z.enum(["warn", "block"]).default("warn"),
+  /** True when hAIve generated this sensor automatically (vs. hand-authored). */
+  autogen: z.boolean().default(false),
+  /** ISO timestamp of the last time this sensor matched a diff. */
+  last_fired: z.string().nullable().default(null)
+});
 var IsoDateString = z.union([z.string(), z.date()]).transform((v) => v instanceof Date ? v.toISOString() : v).pipe(z.string().datetime());
 var MemoryFrontmatterSchema = z.object({
   id: z.string().min(1),
@@ -35,6 +54,8 @@ var MemoryFrontmatterSchema = z.object({
   type: MemoryTypeSchema,
   status: MemoryStatusSchema.default("draft"),
   anchor: AnchorSchema.default({ paths: [], symbols: [] }),
+  /** Optional executable check derived from this memory (feedback computational layer). */
+  sensor: SensorSchema.optional(),
   tags: z.array(z.string()).default([]),
   domain: z.string().optional(),
   author: z.string().optional(),
@@ -2442,6 +2463,57 @@ function retirementSignal(fm, body = "", now = /* @__PURE__ */ new Date()) {
 function isRetiredMemory(fm, body = "", now = /* @__PURE__ */ new Date()) {
   return retirementSignal(fm, body, now).retired;
 }
+
+// src/sensors.ts
+function sensorAppliesToPath(sensor, anchorPaths, path15) {
+  const scopes = sensor.paths.length > 0 ? sensor.paths : anchorPaths;
+  if (scopes.length === 0) return true;
+  return scopes.some((p) => path15 === p || path15.startsWith(p) || path15.includes(p));
+}
+function compileRegexSensor(sensor) {
+  if (sensor.kind !== "regex" || !sensor.pattern) return null;
+  try {
+    const flags = new Set(["m", ...(sensor.flags ?? "").split("")].filter(Boolean));
+    return new RegExp(sensor.pattern, [...flags].join(""));
+  } catch {
+    return null;
+  }
+}
+function runRegexSensor(memoryId, sensor, target) {
+  const re = compileRegexSensor(sensor);
+  if (!re) return null;
+  for (const rawLine of target.content.split("\n")) {
+    re.lastIndex = 0;
+    if (re.test(rawLine)) {
+      return {
+        memory_id: memoryId,
+        sensor,
+        file: target.path,
+        matched_line: rawLine.trim().slice(0, 200),
+        message: sensor.message,
+        severity: sensor.severity
+      };
+    }
+  }
+  return null;
+}
+function runSensors(memories, targets) {
+  const hits = [];
+  for (const memory of memories) {
+    const sensor = memory.frontmatter.sensor;
+    if (!sensor || sensor.kind !== "regex") continue;
+    const anchorPaths = memory.frontmatter.anchor.paths;
+    for (const target of targets) {
+      if (!sensorAppliesToPath(sensor, anchorPaths, target.path)) continue;
+      const hit = runRegexSensor(memory.frontmatter.id, sensor, target);
+      if (hit) hits.push(hit);
+    }
+  }
+  return hits;
+}
+function addedLinesFromDiff(diff) {
+  return diff.split("\n").filter((l) => l.startsWith("+") && !l.startsWith("+++")).map((l) => l.slice(1)).join("\n");
+}
 export {
   AUTOPILOT_DEFAULTS,
   AnchorSchema,
@@ -2466,9 +2538,11 @@ export {
   RUNTIME_JOURNAL_FILENAME,
   SESSION_RECAP_TTL_MS,
   STACK_PACK_TAG,
+  SensorSchema,
   USAGE_FILE,
   USAGE_LOG_DIR,
   USAGE_LOG_FILE,
+  addedLinesFromDiff,
   aggregateUsage,
   allocateBudget,
   antiPatternGateParams,
@@ -2481,6 +2555,7 @@ export {
   bumpRead,
   codeMapPath,
   collectTimelineEntries,
+  compileRegexSensor,
   configPath,
   contractLockPath,
   deriveConfidence,
@@ -2536,10 +2611,13 @@ export {
   resolveManifestFiles,
   resolveProjectInfo,
   retirementSignal,
+  runRegexSensor,
+  runSensors,
   runtimeJournalPath,
   saveCodeMap,
   saveConfig,
   saveUsageIndex,
+  sensorAppliesToPath,
   serializeMemory,
   snapshotContract,
   specificityScore,