@hivelore/core 0.57.4 → 0.57.5

package/dist/index.d.ts

@@ -304,6 +304,16 @@ declare const MemoryFrontmatterSchema: z.ZodEffects<z.ZodObject<{
      * Lets a human distinguish reviewed knowledge from AI/auto-trusted knowledge.
      */
     validated_by: z.ZodDefault<z.ZodNullable<z.ZodEnum<["human", "agent", "auto"]>>>;
+    /**
+     * Does this memory describe code that EXISTS today, or a decision not yet built? Orthogonal to
+     * `confidence`/`status`: a `planned` decision can be fully trusted AS a decision while being false
+     * AS a description of the current code. Surfaced distinctly in briefings so an agent does not write
+     * code against a cookie/route/Node version that was only decided, never implemented (field report §3.3).
+     *   applied   — reflected in the code now (the default when omitted)
+     *   planned   — decided/intended, NOT yet implemented
+     *   abandoned — considered and rejected; kept so it is not re-attempted
+     */
+    lifecycle: z.ZodOptional<z.ZodEnum<["applied", "planned", "abandoned"]>>;
 }, "strip", z.ZodTypeAny, {
     type: "convention" | "decision" | "gotcha" | "architecture" | "glossary" | "skill" | "attempt" | "session_recap";
     status: "draft" | "proposed" | "validated" | "deprecated" | "stale" | "rejected";
@@ -351,6 +361,7 @@ declare const MemoryFrontmatterSchema: z.ZodEffects<z.ZodObject<{
     domain?: string | undefined;
     author?: string | undefined;
     topic?: string | undefined;
+    lifecycle?: "applied" | "planned" | "abandoned" | undefined;
 }, {
     type: "convention" | "decision" | "gotcha" | "architecture" | "glossary" | "skill" | "attempt" | "session_recap";
     id: string;
@@ -398,6 +409,7 @@ declare const MemoryFrontmatterSchema: z.ZodEffects<z.ZodObject<{
     revision_count?: number | undefined;
     requires_human_approval?: boolean | undefined;
     validated_by?: "human" | "agent" | "auto" | null | undefined;
+    lifecycle?: "applied" | "planned" | "abandoned" | undefined;
 }>, {
     type: "convention" | "decision" | "gotcha" | "architecture" | "glossary" | "skill" | "attempt" | "session_recap";
     status: "draft" | "proposed" | "validated" | "deprecated" | "stale" | "rejected";
@@ -445,6 +457,7 @@ declare const MemoryFrontmatterSchema: z.ZodEffects<z.ZodObject<{
     domain?: string | undefined;
     author?: string | undefined;
     topic?: string | undefined;
+    lifecycle?: "applied" | "planned" | "abandoned" | undefined;
 }, {
     type: "convention" | "decision" | "gotcha" | "architecture" | "glossary" | "skill" | "attempt" | "session_recap";
     id: string;
@@ -492,6 +505,7 @@ declare const MemoryFrontmatterSchema: z.ZodEffects<z.ZodObject<{
     revision_count?: number | undefined;
     requires_human_approval?: boolean | undefined;
     validated_by?: "human" | "agent" | "auto" | null | undefined;
+    lifecycle?: "applied" | "planned" | "abandoned" | undefined;
 }>;
 declare const CrossRepoProvenanceSchema: z.ZodOptional<z.ZodObject<{
     source_name: z.ZodString;
@@ -542,6 +556,7 @@ declare function buildFrontmatter(input: {
     relatedIds?: string[];
     sensor?: Sensor;
     activation?: Activation;
+    lifecycle?: MemoryFrontmatter["lifecycle"];
 }): MemoryFrontmatter;
 
 declare const HAIVE_DIR = ".ai";
@@ -2624,8 +2639,10 @@ declare function isRetiredMemory(fm: MemoryFrontmatter, body?: string, now?: Dat
 /**
  * Is a regex sensor pattern brittle — over-fit to incident-specific literals that rot when code
  * shifts (hardcoded line numbers / ranges like `1131-1186`)? High-precision by design: digits that
- * live inside a character class (`[0-9]`) or quantifier (`{2,}`) generalize and are NOT flagged, so
- * durable patterns like `v[0-9]+\.[0-9]+` or `:\s*any\b` stay clean. Returns a short reason or null.
+ * live inside a character class (`[0-9]`) or quantifier (`{2,}`), regex escapes (`\d`, `\w`, `\s`),
+ * or a dotted-quad IP / version literal (`127\.0\.0\.1`, `1\.2\.3`) all GENERALIZE and are NOT
+ * flagged — so durable patterns like `v[0-9]+\.[0-9]+`, `:\s*any\b`, or `https?://127\.0\.0\.1:\d+`
+ * stay clean. Returns a short reason naming the offending token, or null.
  *
  * Used to keep brittle legacy sensors from being counted as real protection or promoted to `block`.
  */

package/dist/index.js

@@ -135,7 +135,17 @@ var MemoryFrontmatterSchema = z.object({
    * null when the memory is not yet validated, or on legacy memories written before this field.
    * Lets a human distinguish reviewed knowledge from AI/auto-trusted knowledge.
    */
-  validated_by: z.enum(["human", "agent", "auto"]).nullable().default(null)
+  validated_by: z.enum(["human", "agent", "auto"]).nullable().default(null),
+  /**
+   * Does this memory describe code that EXISTS today, or a decision not yet built? Orthogonal to
+   * `confidence`/`status`: a `planned` decision can be fully trusted AS a decision while being false
+   * AS a description of the current code. Surfaced distinctly in briefings so an agent does not write
+   * code against a cookie/route/Node version that was only decided, never implemented (field report §3.3).
+   *   applied   — reflected in the code now (the default when omitted)
+   *   planned   — decided/intended, NOT yet implemented
+   *   abandoned — considered and rejected; kept so it is not re-attempted
+   */
+  lifecycle: z.enum(["applied", "planned", "abandoned"]).optional()
 }).refine(
   (data) => data.scope !== "module" || !!data.module,
   { message: "module name is required when scope is 'module'", path: ["module"] }
@@ -153,15 +163,30 @@ var CrossRepoProvenanceSchema = z.object({
 
 // src/parser.ts
 import matter from "gray-matter";
+import "zod";
 var PRIVATE_BLOCK_RE = /<private>[\s\S]*?<\/private>/g;
 function stripPrivate(body) {
   return body.replace(PRIVATE_BLOCK_RE, "").trimEnd();
 }
+function formatFrontmatterError(err) {
+  const issue = err.issues[0];
+  if (!issue) return "invalid frontmatter";
+  const field = issue.path.length > 0 ? issue.path.join(".") : "frontmatter";
+  if (issue.code === "invalid_enum_value") {
+    const got = JSON.stringify(issue.received);
+    const allowed = issue.options.join(" | ");
+    return `invalid ${field}: ${got} is not a supported value \u2014 expected one of: ${allowed}`;
+  }
+  return `invalid ${field}: ${issue.message}`;
+}
 function parseMemory(raw) {
   const parsed = matter(raw);
-  const frontmatter = MemoryFrontmatterSchema.parse(parsed.data);
+  const result = MemoryFrontmatterSchema.safeParse(parsed.data);
+  if (!result.success) {
+    throw new Error(formatFrontmatterError(result.error));
+  }
   return {
-    frontmatter,
+    frontmatter: result.data,
     body: stripPrivate(parsed.content.trim())
   };
 }
@@ -210,6 +235,7 @@ function buildFrontmatter(input) {
     topic: input.topic,
     sensor: input.sensor,
     activation: input.activation,
+    lifecycle: input.lifecycle,
     revision_count: 0,
     related_ids: input.relatedIds ?? []
   });
@@ -1752,9 +1778,13 @@ function generateBridges(memories, sensors, opts) {
 
 // src/sensors.ts
 function sensorPatternBrittleness(pattern) {
-  const literal = pattern.replace(/\[[^\]]*\]/g, "").replace(/\{[^}]*\}/g, "");
-  if (/\d{2,}\s*-\s*\d{2,}/.test(literal)) return "hardcoded line/number range \u2014 rots when code shifts";
-  if (/\d{3,}/.test(literal)) return "hardcoded numeric literal (likely a line number) \u2014 rots when code shifts";
+  const literal = pattern.replace(/\\[a-zA-Z]/g, " ").replace(/\[[^\]]*\]/g, " ").replace(/\{[^}]*\}/g, " ").replace(/\b\d{1,3}(?:\s*\\?\.\s*\d{1,3}){2,3}\b/g, " ");
+  const range = literal.match(/\d{2,}\s*-\s*\d{2,}/);
+  if (range) return `hardcoded line/number range "${range[0].replace(/\s+/g, "")}" \u2014 rots when code shifts`;
+  const numeric = literal.match(/\d{3,}/);
+  if (numeric) {
+    return `hardcoded numeric literal "${numeric[0]}" (likely a line number) \u2014 rots when code shifts; if it is a real constant, put it in a character class ([0-9]) or anchor it to a stable token`;
+  }
   return null;
 }
 function normalizeProjectPath(value) {