@hiveai/core 0.10.2 → 0.10.4

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;
@@ -191,6 +326,7 @@ declare function buildFrontmatter(input: {
     topic?: string;
     status?: MemoryFrontmatter["status"];
     relatedIds?: string[];
+    sensor?: Sensor;
 }): MemoryFrontmatter;
 
 declare const HAIVE_DIR = ".ai";
@@ -939,4 +1075,82 @@ 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 only to the
+ * exact file or directory prefix. Use an explicit directory path (`src/foo/`) when a
+ * sensor should cover a whole subtree.
+ */
+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[];
+/** Split a unified diff into per-file targets containing only added lines. */
+declare function sensorTargetsFromDiff(diff: string): SensorTarget[];
+/**
+ * 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;
+
+interface SensorSuggestionOptions {
+    /** Extra paths to put on the sensor. Defaults to the memory anchor paths. */
+    paths?: string[];
+}
+/**
+ * Conservatively suggest a regex sensor from a gotcha/attempt body.
+ *
+ * This helper intentionally returns null more often than it guesses. Autogenerated
+ * sensors start as `warn`, never `block`; humans can promote them after seeing them fire.
+ */
+declare function suggestSensorFromMemory(body: string, anchorPaths: string[], options?: SensorSuggestionOptions): Sensor | null;
+
+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 SensorSuggestionOptions, 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, sensorTargetsFromDiff, serializeMemory, snapshotContract, specificityScore, stripPrivate, suggestSensorFromMemory, 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(),
@@ -127,6 +148,7 @@ function buildFrontmatter(input) {
     created_at: now.toISOString(),
     expires_when: null,
     topic: input.topic,
+    sensor: input.sensor,
     revision_count: 0,
     related_ids: input.relatedIds ?? []
   });
@@ -2442,6 +2464,203 @@ 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 normalizeProjectPath(value) {
+  return value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^[ab]\//, "").replace(/\/+$/g, "");
+}
+function sensorAppliesToPath(sensor, anchorPaths, path15) {
+  const scopes = sensor.paths.length > 0 ? sensor.paths : anchorPaths;
+  if (scopes.length === 0) return true;
+  const target = normalizeProjectPath(path15);
+  return scopes.some((rawScope) => {
+    const scope = normalizeProjectPath(rawScope);
+    if (!scope) return false;
+    return target === scope || target.startsWith(`${scope}/`);
+  });
+}
+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 sensorTargetsFromDiff(diff) {
+  const targets = [];
+  let currentPath = null;
+  let added = [];
+  const flush = () => {
+    if (!currentPath || added.length === 0) return;
+    targets.push({ path: currentPath, content: added.join("\n") });
+    added = [];
+  };
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("diff --git ")) {
+      flush();
+      currentPath = null;
+      continue;
+    }
+    if (line.startsWith("+++ ")) {
+      flush();
+      const raw = line.slice(4).trim();
+      currentPath = raw === "/dev/null" ? null : normalizeProjectPath(raw);
+      continue;
+    }
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      if (!currentPath) currentPath = "";
+      added.push(line.slice(1));
+    }
+  }
+  flush();
+  return targets;
+}
+function addedLinesFromDiff(diff) {
+  const targets = sensorTargetsFromDiff(diff);
+  if (targets.length > 0) return targets.map((target) => target.content).join("\n");
+  return diff.split("\n").filter((l) => l.startsWith("+") && !l.startsWith("+++")).map((l) => l.slice(1)).join("\n");
+}
+
+// src/sensor-suggest.ts
+var CODE_TOKEN_RE = /`([^`\n]{3,80})`|["']([A-Za-z0-9_.:-]{3,80})["']|\b([A-Za-z][A-Za-z0-9_.:-]{2,79})\b/g;
+var SENSOR_STOPWORDS = /* @__PURE__ */ new Set([
+  "about",
+  "after",
+  "again",
+  "agent",
+  "always",
+  "anchor",
+  "approach",
+  "because",
+  "before",
+  "break",
+  "broken",
+  "cannot",
+  "change",
+  "code",
+  "commit",
+  "correct",
+  "could",
+  "default",
+  "detect",
+  "direct",
+  "directory",
+  "does",
+  "error",
+  "failed",
+  "fails",
+  "file",
+  "files",
+  "future",
+  "instead",
+  "memory",
+  "never",
+  "project",
+  "recorded",
+  "repo",
+  "return",
+  "should",
+  "source",
+  "status",
+  "string",
+  "this",
+  "tried",
+  "true",
+  "type",
+  "undefined",
+  "value",
+  "when",
+  "where",
+  "which",
+  "with",
+  "without"
+]);
+function suggestSensorFromMemory(body, anchorPaths, options = {}) {
+  const paths = options.paths ?? anchorPaths;
+  if (paths.length === 0) return null;
+  const negativeText = body.split(/\*\*Instead,\s*use:\*\*|^##\s+Instead\b/im)[0] ?? body;
+  const token = pickDistinctiveToken(negativeText);
+  if (!token) return null;
+  return {
+    kind: "regex",
+    pattern: escapeRegExp(token),
+    paths,
+    message: sensorMessageFromBody(body, token),
+    severity: "warn",
+    autogen: true,
+    last_fired: null
+  };
+}
+function pickDistinctiveToken(text) {
+  const candidates = /* @__PURE__ */ new Map();
+  for (const match of text.matchAll(CODE_TOKEN_RE)) {
+    const raw = (match[1] ?? match[2] ?? match[3] ?? "").trim();
+    const token = raw.replace(/^[^\w.-]+|[^\w.-]+$/g, "");
+    const isCodeLike = Boolean(match[1] ?? match[2]);
+    if (!isDistinctiveToken(token, isCodeLike)) continue;
+    const key = token.toLowerCase();
+    const codeSpanBonus = match[1] ? 20 : match[2] ? 8 : 0;
+    const shapeBonus = /[-_.:]/.test(token) ? 3 : /[A-Z]/.test(token.slice(1)) ? 2 : /\d/.test(token) ? 1 : 0;
+    const score = token.length + codeSpanBonus + shapeBonus;
+    const existing = candidates.get(key);
+    if (!existing || score > existing.score) candidates.set(key, { raw: token, score });
+  }
+  const best = [...candidates.values()].sort((a, b) => b.score - a.score)[0];
+  return best?.raw ?? null;
+}
+function isDistinctiveToken(token, isCodeLike) {
+  if (token.length < 4 || token.length > 80) return false;
+  if (/^https?:\/\//i.test(token)) return false;
+  if (/^\d+$/.test(token)) return false;
+  const lower = token.toLowerCase();
+  if (SENSOR_STOPWORDS.has(lower)) return false;
+  if (!/[A-Za-z]/.test(token)) return false;
+  const shaped = /[-_.:\d]/.test(token) || /[A-Z]/.test(token.slice(1));
+  return shaped || isCodeLike;
+}
+function sensorMessageFromBody(body, token) {
+  const instead = body.match(/\*\*Instead,\s*use:\*\*\s*([^\n]+)/i)?.[1]?.trim();
+  if (instead) return `Avoid ${token}; ${instead}`;
+  const firstGuidance = body.split("\n").map((line) => line.replace(/^#+\s*/, "").trim()).find((line) => line.length > 0 && !line.startsWith("---"));
+  return firstGuidance?.slice(0, 180) || `Avoid ${token}; this matched an autogenerated hAIve sensor.`;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 export {
   AUTOPILOT_DEFAULTS,
   AnchorSchema,
@@ -2466,9 +2685,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 +2702,7 @@ export {
   bumpRead,
   codeMapPath,
   collectTimelineEntries,
+  compileRegexSensor,
   configPath,
   contractLockPath,
   deriveConfidence,
@@ -2536,14 +2758,19 @@ export {
   resolveManifestFiles,
   resolveProjectInfo,
   retirementSignal,
+  runRegexSensor,
+  runSensors,
   runtimeJournalPath,
   saveCodeMap,
   saveConfig,
   saveUsageIndex,
+  sensorAppliesToPath,
+  sensorTargetsFromDiff,
   serializeMemory,
   snapshotContract,
   specificityScore,
   stripPrivate,
+  suggestSensorFromMemory,
   suggestTopicKey,
   tokenizeQuery,
   trackDependencies,