@snoai/memory 0.0.0-stage → 1.0.1

package/dist/atomic-extraction-reply-BJ9XV_9s.js

@@ -0,0 +1,863 @@
+import { n as readModelReplyJson, t as modelReplyJsonCandidates } from "./model-reply-text-CKopStP2.js";
+import { n as calendarInstructionSchema, t as calculateCalendarTime } from "./calendar-instruction-CzqZbAPG.js";
+import { n as state_vocabulary_default, r as attribute_dictionary_default, t as relations } from "./relation-dictionary-Cev1kyLe.js";
+import { z } from "zod";
+import { createLogger } from "@snoai/utils/logger";
+//#region src/engine/extraction/atomic-progress-boundary.ts
+const log$1 = createLogger("sno-station-mem:atomic-progress-boundary");
+const classificationSchema = z.object({ decisions: z.array(z.object({
+	turn_index: z.number().int().nonnegative(),
+	progress_only: z.boolean()
+})) });
+function parseProgressTurns(value, turns, { salvage = false } = {}) {
+	const expected = new Set(turns.flatMap((turn, index) => turn.role === "user" ? [index] : []));
+	const parsed = classificationSchema.safeParse(value);
+	if (!parsed.success) return null;
+	const indexes = new Set(parsed.data.decisions.map((decision) => decision.turn_index));
+	const invalid = indexes.size !== expected.size || parsed.data.decisions.length !== expected.size || [...indexes].some((index) => !expected.has(index));
+	if (invalid && !salvage) return null;
+	if (invalid) log$1.warn("atomic capture salvaged progress decisions", {
+		gate: 3,
+		ignored_decisions: parsed.data.decisions.filter((decision) => !expected.has(decision.turn_index)).length,
+		missing_turns: [...expected].filter((index) => !indexes.has(index)).length,
+		duplicate_decisions: parsed.data.decisions.length - indexes.size
+	}, {
+		event_name: "memory.atomic_progress_boundary.diagnostic",
+		file: "packages/memory/src/engine/extraction/atomic-progress-boundary.ts",
+		function: "parseProgressTurns",
+		site_id: "extraction.atomic-progress-boundary.salvage_decisions"
+	});
+	const notProgress = new Set(parsed.data.decisions.filter((decision) => !decision.progress_only).map((decision) => decision.turn_index));
+	return new Set(parsed.data.decisions.filter((decision) => decision.progress_only && expected.has(decision.turn_index) && !notProgress.has(decision.turn_index)).map((decision) => decision.turn_index));
+}
+function excludeProgressRecords(records, excluded) {
+	return records.filter((record) => {
+		const index = (record.sourceSpan ?? record.unresolvedSourceSpan)?.turnIndex;
+		return index === void 0 || !excluded.has(index);
+	});
+}
+//#endregion
+//#region config/atomic-extraction-response.schema.json
+var atomic_extraction_response_schema_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://www.sno.ai/schemas/mem-claw/atomic-extraction-response-v1.json",
+	title: "Atomic extraction response v1",
+	type: "object",
+	additionalProperties: false,
+	required: ["claims_found", "records"],
+	properties: {
+		"claims_found": {
+			"type": "array",
+			"items": { "type": "string" },
+			"description": "One short string for each claim the turns this call owns state, in the order they appear; empty when they state none. Written before records so the list is read before the array is opened."
+		},
+		"records": {
+			"type": "array",
+			"items": {
+				"type": "object",
+				"additionalProperties": false,
+				"required": [
+					"kind",
+					"claim_text",
+					"subject",
+					"subject_kind",
+					"attribute",
+					"value",
+					"temporal_phrase",
+					"ends_current",
+					"ended_at_phrase",
+					"importance",
+					"changes_current_state",
+					"todo",
+					"close_reason",
+					"source_span",
+					"relations",
+					"single_claim",
+					"time",
+					"ended_time"
+				],
+				"properties": {
+					"kind": { "enum": ["occurrence", "standing"] },
+					"claim_text": {
+						"type": "string",
+						"minLength": 1
+					},
+					"subject": {
+						"type": "string",
+						"minLength": 1
+					},
+					"subject_kind": { "enum": [
+						"user",
+						"agent",
+						"named_entity",
+						"unresolved"
+					] },
+					"attribute": { "anyOf": [{ "enum": [
+						"ability.awards",
+						"ability.certifications",
+						"ability.creative",
+						"ability.practical",
+						"ability.professional",
+						"ability.technical",
+						"contact.address",
+						"contact.email",
+						"contact.messaging",
+						"contact.phone",
+						"contact.social",
+						"contact.websites",
+						"entity.organization",
+						"entity.person",
+						"entity.place",
+						"finance.budget_style",
+						"finance.investing",
+						"finance.obligations",
+						"goal.career",
+						"goal.family",
+						"goal.financial",
+						"goal.health",
+						"goal.learning",
+						"goal.personal",
+						"goal.project",
+						"goal.travel",
+						"health.accessibility",
+						"health.allergies",
+						"health.conditions",
+						"health.fitness",
+						"health.medications",
+						"health.mental",
+						"health.sleep",
+						"identity.aka",
+						"identity.birth_date",
+						"identity.birth_place",
+						"identity.career_history",
+						"identity.education",
+						"identity.employer",
+						"identity.employment_status",
+						"identity.gender",
+						"identity.hometown",
+						"identity.industry",
+						"identity.institutional_affiliation",
+						"identity.languages",
+						"identity.location",
+						"identity.marital_status",
+						"identity.name",
+						"identity.nationality",
+						"identity.occupation",
+						"identity.project_role",
+						"identity.pronouns",
+						"identity.team_membership",
+						"identity.timezone",
+						"identity.work_location",
+						"interest.arts_culture",
+						"interest.business",
+						"interest.education",
+						"interest.health_wellness",
+						"interest.history",
+						"interest.hobbies",
+						"interest.local",
+						"interest.nature",
+						"interest.philosophy",
+						"interest.politics",
+						"interest.science",
+						"interest.sports",
+						"interest.technology",
+						"personality.self_view",
+						"personality.social_energy",
+						"personality.temperament",
+						"personality.type",
+						"possession.collections",
+						"possession.devices",
+						"possession.home",
+						"possession.subscriptions",
+						"possession.vehicle",
+						"preference.accommodation",
+						"preference.art",
+						"preference.audio",
+						"preference.cooking",
+						"preference.devices",
+						"preference.diet",
+						"preference.dining",
+						"preference.drinks",
+						"preference.entertainment_going_out",
+						"preference.exercise",
+						"preference.fashion",
+						"preference.food",
+						"preference.games",
+						"preference.home",
+						"preference.media_sources",
+						"preference.music",
+						"preference.programming",
+						"preference.reading",
+						"preference.screen",
+						"preference.shopping",
+						"preference.social_media",
+						"preference.tools",
+						"preference.transport",
+						"preference.travel_destinations",
+						"preference.travel_style",
+						"preference.travel",
+						"preference.weather",
+						"relationship.children",
+						"relationship.colleagues",
+						"relationship.friends",
+						"relationship.parents",
+						"relationship.partner",
+						"relationship.pets",
+						"relationship.relatives",
+						"relationship.siblings",
+						"routine.commute",
+						"routine.daily",
+						"routine.habits",
+						"routine.weekly",
+						"trait.collaboration",
+						"trait.communication",
+						"trait.constraint",
+						"trait.environment",
+						"trait.planning",
+						"trait.practice",
+						"trait.privacy",
+						"trait.risk",
+						"trait.schedule",
+						"trait.tooling_habits",
+						"value.causes",
+						"value.ethics",
+						"value.political",
+						"value.priorities",
+						"value.spiritual",
+						"project.budget",
+						"project.timeline",
+						"project.objective",
+						"project.deliverable",
+						"project.lead",
+						"project.stakeholder",
+						"email.purpose",
+						"email.recipient",
+						"email.key_point",
+						"email.action_item",
+						"meeting.attendee",
+						"meeting.agenda_item",
+						"meeting.key_decision",
+						"meeting.next_step"
+					] }, { "type": "null" }] },
+					"value": {
+						"type": "string",
+						"minLength": 1
+					},
+					"temporal_phrase": { "anyOf": [{
+						"type": "string",
+						"minLength": 1
+					}, { "type": "null" }] },
+					"ends_current": { "type": "boolean" },
+					"ended_at_phrase": { "anyOf": [{
+						"type": "string",
+						"minLength": 1
+					}, { "type": "null" }] },
+					"importance": { "enum": [
+						"high",
+						"medium",
+						"low"
+					] },
+					"changes_current_state": { "type": "boolean" },
+					"todo": { "enum": [
+						"open",
+						"done",
+						"removed",
+						"none"
+					] },
+					"close_reason": { "anyOf": [{
+						"type": "string",
+						"minLength": 1
+					}, { "type": "null" }] },
+					"source_span": {
+						"type": "object",
+						"additionalProperties": false,
+						"required": ["turn_index", "quote"],
+						"properties": {
+							"turn_index": {
+								"type": "integer",
+								"minimum": 0
+							},
+							"quote": {
+								"type": "string",
+								"minLength": 1
+							}
+						}
+					},
+					"relations": {
+						"type": "array",
+						"maxItems": 3,
+						"items": {
+							"type": "object",
+							"additionalProperties": false,
+							"required": [
+								"subject",
+								"predicate",
+								"object"
+							],
+							"properties": {
+								"subject": {
+									"type": "string",
+									"minLength": 1
+								},
+								"predicate": { "enum": [
+									"IS_A",
+									"WORKS_ON",
+									"NEEDS",
+									"PREFERS",
+									"FORBIDS",
+									"USES",
+									"DEPENDS_ON",
+									"CAUSED",
+									"FIXED_BY",
+									"DECIDED",
+									"SUPERSEDES",
+									"GOVERNED_BY",
+									"OWNED_BY",
+									"MEMBER_OF",
+									"LOCATED_AT",
+									"HAS_SKILL",
+									"INTERESTED_IN",
+									"HAS_ACCOUNT",
+									"HAS_OCCUPATION",
+									"HAS_METRIC",
+									"WORKS_AT",
+									"ATTENDED",
+									"REPORTS_TO",
+									"COLLABORATES_WITH",
+									"LEARNED_FROM",
+									"ABANDONED",
+									"BLOCKED_BY",
+									"IMPLEMENTED_IN",
+									"OCCURS_UNDER",
+									"CITES",
+									"CREATED",
+									"MENTIONS"
+								] },
+								"object": {
+									"type": "string",
+									"minLength": 1
+								}
+							}
+						}
+					},
+					"single_claim": { "type": "boolean" },
+					"time": { "$ref": "#/$defs/calendarInstruction" },
+					"ended_time": { "$ref": "#/$defs/calendarInstruction" }
+				}
+			}
+		}
+	},
+	$defs: { "calendarInstruction": { "oneOf": [
+		{
+			"type": "object",
+			"properties": { "kind": {
+				"type": "string",
+				"const": "none"
+			} },
+			"required": ["kind"],
+			"additionalProperties": false
+		},
+		{
+			"type": "object",
+			"properties": { "kind": {
+				"type": "string",
+				"const": "unresolved"
+			} },
+			"required": ["kind"],
+			"additionalProperties": false
+		},
+		{
+			"type": "object",
+			"properties": {
+				"kind": {
+					"type": "string",
+					"const": "absolute"
+				},
+				"year": {
+					"type": "integer",
+					"minimum": -9007199254740991,
+					"maximum": 9007199254740991
+				},
+				"month": {
+					"type": "integer",
+					"minimum": 1,
+					"maximum": 12
+				},
+				"day": {
+					"type": "integer",
+					"minimum": 1,
+					"maximum": 31
+				},
+				"precision": {
+					"type": "string",
+					"enum": [
+						"year",
+						"month",
+						"week",
+						"day",
+						"minute"
+					]
+				},
+				"hour": {
+					"type": "integer",
+					"minimum": 0,
+					"maximum": 23
+				},
+				"minute": {
+					"type": "integer",
+					"minimum": 0,
+					"maximum": 59
+				},
+				"timezone": {
+					"type": "string",
+					"minLength": 1,
+					"description": "A valid IANA time zone identifier or fixed UTC offset in +HH:MM or -HH:MM form; never a natural-language abbreviation. Keep hour and minute in that source zone."
+				}
+			},
+			"required": [
+				"kind",
+				"year",
+				"precision"
+			],
+			"additionalProperties": false
+		},
+		{
+			"type": "object",
+			"properties": {
+				"kind": {
+					"type": "string",
+					"const": "relative"
+				},
+				"amount": {
+					"type": "integer",
+					"minimum": -9007199254740991,
+					"maximum": 9007199254740991
+				},
+				"unit": {
+					"type": "string",
+					"enum": [
+						"year",
+						"month",
+						"week",
+						"day",
+						"hour",
+						"minute"
+					]
+				},
+				"precision": {
+					"type": "string",
+					"enum": [
+						"year",
+						"month",
+						"week",
+						"day",
+						"minute"
+					]
+				},
+				"hour": {
+					"type": "integer",
+					"minimum": 0,
+					"maximum": 23
+				},
+				"minute": {
+					"type": "integer",
+					"minimum": 0,
+					"maximum": 59
+				},
+				"timezone": {
+					"type": "string",
+					"minLength": 1,
+					"description": "A valid IANA time zone identifier or fixed UTC offset in +HH:MM or -HH:MM form; never a natural-language abbreviation. Keep hour and minute in that source zone."
+				}
+			},
+			"required": [
+				"kind",
+				"amount",
+				"unit",
+				"precision"
+			],
+			"additionalProperties": false
+		},
+		{
+			"type": "object",
+			"properties": {
+				"kind": {
+					"type": "string",
+					"const": "weekday"
+				},
+				"day_name": {
+					"type": "string",
+					"enum": [
+						"monday",
+						"tuesday",
+						"wednesday",
+						"thursday",
+						"friday",
+						"saturday",
+						"sunday"
+					],
+					"description": "The named day as an English lowercase day name, never a number."
+				},
+				"direction": {
+					"type": "string",
+					"enum": ["previous", "next"]
+				},
+				"precision": {
+					"type": "string",
+					"enum": ["day", "minute"]
+				},
+				"hour": {
+					"type": "integer",
+					"minimum": 0,
+					"maximum": 23
+				},
+				"minute": {
+					"type": "integer",
+					"minimum": 0,
+					"maximum": 59
+				},
+				"timezone": {
+					"type": "string",
+					"minLength": 1,
+					"description": "A valid IANA time zone identifier or fixed UTC offset in +HH:MM or -HH:MM form; never a natural-language abbreviation. Keep hour and minute in that source zone."
+				}
+			},
+			"required": [
+				"kind",
+				"day_name",
+				"direction",
+				"precision"
+			],
+			"additionalProperties": false
+		}
+	] } }
+};
+//#endregion
+//#region src/engine/extraction/atomic-extraction-reply.ts
+/** @file atomic-extraction-reply.ts
+* @purpose Defines and recovers the one atomic extraction reply shape.
+* @boundary Reply validation only; no model calls, persistence, or post-processing judgment.
+*/
+const log = createLogger("sno-station-mem:atomic-extraction-reply");
+const personAttributeSlugs = new Set(attribute_dictionary_default.slugs.map(({ slug }) => slug));
+const thingAttributeSlugs = new Set(state_vocabulary_default.slugs.map(({ slug }) => slug));
+const relationPredicates = /* @__PURE__ */ new Set([...relations.map(({ type }) => type), "MENTIONS"]);
+const relationSchema = z.object({
+	subject: z.string().min(1),
+	predicate: z.string().refine((value) => relationPredicates.has(value)),
+	object: z.string().min(1)
+}).strip();
+const wireTimeSchema = calendarInstructionSchema.catch(() => {
+	log.warn("atomic extraction kept a record with an invalid time judgment", {}, {
+		event_name: "memory.atomic_extraction_reply.diagnostic",
+		file: "packages/memory/src/engine/extraction/atomic-extraction-reply.ts",
+		function: "wireTimeSchema",
+		site_id: "extraction.atomic-extraction-reply.invalid_time"
+	});
+	return { kind: "unresolved" };
+});
+const wireRecordSchema = z.object({
+	kind: z.enum(["occurrence", "standing"]),
+	claim_text: z.string().min(1),
+	subject: z.string().min(1),
+	subject_kind: z.enum([
+		"user",
+		"agent",
+		"named_entity",
+		"unresolved"
+	]),
+	attribute: z.string().nullable(),
+	value: z.string().min(1),
+	temporal_phrase: z.string().min(1).nullable(),
+	time: wireTimeSchema.optional(),
+	ended_time: wireTimeSchema.optional(),
+	ends_current: z.boolean(),
+	ended_at_phrase: z.string().min(1).nullable().optional(),
+	importance: z.enum([
+		"high",
+		"medium",
+		"low"
+	]),
+	changes_current_state: z.boolean(),
+	todo: z.enum([
+		"open",
+		"done",
+		"removed",
+		"none"
+	]),
+	close_reason: z.string().min(1).nullable(),
+	source_span: z.object({
+		turn_index: z.number().int().nonnegative(),
+		quote: z.string().min(1)
+	}).strip(),
+	relations: z.array(relationSchema),
+	single_claim: z.boolean()
+}).strip();
+const envelopeSchema = z.object({ records: z.array(wireRecordSchema) }).strip();
+const arraySchema = z.array(wireRecordSchema);
+const MAX_RELATIONS = 3;
+function projectRecord(record) {
+	const allowedAttributes = record.subject_kind === "user" ? personAttributeSlugs : record.subject_kind === "named_entity" || record.subject_kind === "unresolved" ? thingAttributeSlugs : void 0;
+	const offeredAttribute = record.attribute === null ? null : record.attribute.trim().toLowerCase();
+	const attribute = offeredAttribute !== null && allowedAttributes?.has(offeredAttribute) ? offeredAttribute : null;
+	if (offeredAttribute !== null && attribute === null) log.warn("atomic extraction attribute stored unkeyed", {
+		attribute_length: offeredAttribute.length,
+		subjectKind: record.subject_kind
+	}, {
+		event_name: "memory.atomic_extraction_reply.diagnostic",
+		file: "packages/memory/src/engine/extraction/atomic-extraction-reply.ts",
+		function: "projectRecord",
+		site_id: "extraction.atomic-extraction-reply.projectRecord.327508ac5f"
+	});
+	const endedAtPhrase = record.ends_current ? record.ended_at_phrase ?? null : null;
+	if (record.time === void 0 || record.ends_current && record.ended_time === void 0) log.warn("atomic extraction kept a record with an omitted time judgment", {
+		time_missing: record.time === void 0,
+		ending_time_missing: record.ends_current && record.ended_time === void 0
+	}, {
+		event_name: "memory.atomic_extraction_reply.diagnostic",
+		file: "packages/memory/src/engine/extraction/atomic-extraction-reply.ts",
+		function: "projectRecord",
+		site_id: "extraction.atomic-extraction-reply.omitted_time"
+	});
+	if (!record.ends_current && (record.ended_at_phrase ?? null) !== null) log.warn("atomic extraction dropped an ending time on a claim that does not end", { claim_length: record.claim_text.length }, {
+		event_name: "memory.atomic_extraction_reply.diagnostic",
+		file: "packages/memory/src/engine/extraction/atomic-extraction-reply.ts",
+		function: "projectRecord",
+		site_id: "extraction.atomic-extraction-reply.projectRecord.aac5440fc2"
+	});
+	const closeReason = record.todo === "done" || record.todo === "removed" ? record.close_reason : null;
+	if (record.relations.length > MAX_RELATIONS) log.warn("atomic extraction kept the first relations only", {
+		offered: record.relations.length,
+		kept: MAX_RELATIONS
+	}, {
+		event_name: "memory.atomic_extraction_reply.diagnostic",
+		file: "packages/memory/src/engine/extraction/atomic-extraction-reply.ts",
+		function: "projectRecord",
+		site_id: "extraction.atomic-extraction-reply.projectRecord.b92c90f285"
+	});
+	return {
+		kind: record.kind,
+		claimText: record.claim_text,
+		subject: record.subject,
+		subjectKind: record.subject_kind,
+		attribute,
+		...offeredAttribute !== null && attribute === null ? { refusedAttribute: offeredAttribute } : {},
+		value: record.value,
+		temporalPhrase: record.temporal_phrase,
+		time: record.time ?? { kind: "unresolved" },
+		endedTime: record.ends_current ? record.ended_time ?? { kind: "unresolved" } : { kind: "none" },
+		resolvedTime: null,
+		endsCurrent: record.ends_current,
+		endedAtPhrase,
+		endedAt: null,
+		importance: record.importance,
+		changesCurrentState: record.changes_current_state,
+		todo: record.todo,
+		closeReason,
+		sourceSpan: {
+			turnIndex: record.source_span.turn_index,
+			quote: record.source_span.quote
+		},
+		relations: record.relations.slice(0, MAX_RELATIONS),
+		singleClaim: record.single_claim
+	};
+}
+function validatePayload(value, turnCount) {
+	let records;
+	if (Array.isArray(value)) {
+		const parsed = arraySchema.safeParse(value);
+		if (!parsed.success) return void 0;
+		records = parsed.data;
+	} else {
+		const parsed = envelopeSchema.safeParse(value);
+		if (!parsed.success) return void 0;
+		records = parsed.data.records;
+	}
+	if (records.some((record) => record.source_span.turn_index >= turnCount)) return void 0;
+	return records.map(projectRecord);
+}
+function parsePayload(text, turnCount) {
+	try {
+		return validatePayload(JSON.parse(text), turnCount);
+	} catch {
+		return;
+	}
+}
+/**
+* Reads the one reply shape out of whatever the model wrapped it in.
+*
+* Candidate order and think-stripping belong to `modelReplyJsonCandidates`; the schema decision
+* stays here. The first candidate this file admits wins — the previous rule discarded a reply
+* whenever two candidates validated, which cost real memories every time the model wrote its
+* reasoning as prose before the payload (measured 2026-09-04 on the live Memora run).
+*/
+function parseAtomicExtractionReply(raw, turnCount) {
+	let malformedCandidateCount = 0;
+	for (const candidate of modelReplyJsonCandidates(raw)) {
+		const records = parsePayload(candidate, turnCount);
+		if (records) return {
+			ok: true,
+			records,
+			malformedCandidateCount
+		};
+		malformedCandidateCount += 1;
+	}
+	return {
+		ok: false,
+		reason: "no-schema-payload",
+		malformedCandidateCount
+	};
+}
+const ATOMIC_EXTRACTION_RESPONSE_JSON_SCHEMA = atomic_extraction_response_schema_default;
+const captureFactSchema = wireRecordSchema.pick({
+	subject: true,
+	subject_kind: true,
+	temporal_phrase: true,
+	source_span: true
+}).extend({
+	id: z.number().int().nonnegative(),
+	fact: z.string().min(1),
+	ended_at_phrase: wireRecordSchema.shape.ended_at_phrase.unwrap()
+});
+const captureReplySchema = z.object({
+	claims_found: z.array(z.string().min(1)),
+	decisions: z.array(z.object({
+		turn_index: z.number().int().nonnegative(),
+		progress_only: z.boolean()
+	})),
+	facts: z.array(captureFactSchema)
+});
+const enrichmentSchema = wireRecordSchema.omit({
+	claim_text: true,
+	subject: true,
+	subject_kind: true,
+	temporal_phrase: true,
+	ended_at_phrase: true,
+	source_span: true
+}).extend({
+	id: z.number().int().nonnegative(),
+	time: calendarInstructionSchema,
+	ended_time: calendarInstructionSchema,
+	relations: z.array(relationSchema.extend({ predicate: z.enum(relations.map(({ type }) => type)) })).max(MAX_RELATIONS)
+});
+const enrichmentReplySchema = z.object({ enrichments: z.array(enrichmentSchema) });
+const ATOMIC_CAPTURE_RESPONSE_JSON_SCHEMA = z.toJSONSchema(captureReplySchema);
+const ATOMIC_ENRICHMENT_RESPONSE_JSON_SCHEMA = z.toJSONSchema(enrichmentReplySchema);
+function parseAtomicCaptureReply(raw, turns, { salvage = false, onReject } = {}) {
+	let gate = "unreadable-json";
+	const result = readModelReplyJson(raw, (value) => {
+		const parsed = captureReplySchema.safeParse(value);
+		if (!parsed.success) {
+			if (gate === "unreadable-json") gate = "capture-schema";
+			return;
+		}
+		const { facts, claims_found } = parsed.data;
+		const kept = facts.map((fact, index) => ({
+			...fact,
+			id: index
+		})).filter((fact) => fact.source_span.turn_index < turns.length);
+		if (claims_found.length > 0 && kept.length === 0) {
+			gate = "claims-without-facts";
+			return;
+		}
+		const progressTurns = parseProgressTurns(parsed.data, turns, { salvage });
+		if (progressTurns === null) {
+			gate = "progress-decisions";
+			return;
+		}
+		const wrongIds = facts.filter((fact, index) => fact.id !== index).length;
+		const invalidSpans = facts.filter((fact) => fact.source_span.turn_index >= turns.length).length;
+		if (!salvage && (wrongIds > 0 || invalidSpans > 0)) {
+			gate = wrongIds > 0 ? "fact-ids" : "source-turn-index";
+			return;
+		}
+		if (wrongIds > 0) log.warn("atomic capture salvaged fact ids", {
+			gate: 5,
+			affected_facts: wrongIds
+		}, {
+			event_name: "memory.atomic_extraction_reply.diagnostic",
+			file: "packages/memory/src/engine/extraction/atomic-extraction-reply.ts",
+			function: "parseAtomicCaptureReply",
+			site_id: "extraction.atomic-extraction-reply.salvage_ids"
+		});
+		if (invalidSpans > 0) log.warn("atomic capture dropped facts with invalid source turns", {
+			gate: 6,
+			affected_facts: invalidSpans
+		}, {
+			event_name: "memory.atomic_extraction_reply.diagnostic",
+			file: "packages/memory/src/engine/extraction/atomic-extraction-reply.ts",
+			function: "parseAtomicCaptureReply",
+			site_id: "extraction.atomic-extraction-reply.salvage_spans"
+		});
+		return {
+			facts: kept,
+			progressTurns
+		};
+	});
+	if (result === void 0) onReject?.(gate);
+	return result;
+}
+function warnUnresolvedEnrichmentTime(enrichment, sessionDateTime) {
+	for (const field of ["time", "ended_time"]) {
+		const instruction = enrichment[field];
+		if (instruction.kind === "none" || instruction.kind === "unresolved" || calculateCalendarTime(instruction, sessionDateTime) !== null) continue;
+		const missingComponents = [];
+		if (instruction.kind === "absolute") {
+			if (instruction.precision !== "year" && instruction.month === void 0) missingComponents.push("month");
+			if (instruction.precision !== "year" && instruction.precision !== "month" && instruction.day === void 0) missingComponents.push("day");
+		} else if (sessionDateTime === void 0) missingComponents.push("session_date_time");
+		if (instruction.hour === void 0 && (instruction.minute !== void 0 || instruction.precision === "minute" && instruction.kind !== "relative")) missingComponents.push("hour");
+		log.warn("atomic enrichment time could not be calculated", {
+			fact_id: enrichment.id,
+			field: { name: field },
+			kind: instruction.kind,
+			precision: { unit: instruction.precision },
+			missing_components: missingComponents.map((name) => ({ name }))
+		}, {
+			event_name: "memory.atomic_extraction_reply.diagnostic",
+			file: "packages/memory/src/engine/extraction/atomic-extraction-reply.ts",
+			function: "warnUnresolvedEnrichmentTime",
+			site_id: "extraction.atomic-extraction-reply.unresolved_enrichment_time"
+		});
+	}
+}
+function parseAtomicEnrichmentReply(raw, facts, sessionDateTime) {
+	return readModelReplyJson(raw, (value) => {
+		const parsed = enrichmentReplySchema.safeParse(value);
+		if (!parsed.success) return void 0;
+		const byId = new Map(parsed.data.enrichments.map((entry) => [entry.id, entry]));
+		if (parsed.data.enrichments.length !== facts.length || byId.size !== facts.length || facts.some((fact) => !byId.has(fact.id))) return void 0;
+		const records = [];
+		for (const fact of facts) {
+			const enrichment = byId.get(fact.id);
+			if (enrichment === void 0) return void 0;
+			warnUnresolvedEnrichmentTime(enrichment, sessionDateTime);
+			records.push(projectRecord({
+				...enrichment,
+				...fact,
+				claim_text: fact.fact
+			}));
+		}
+		return records;
+	});
+}
+function fallbackAtomicCapturedFact(fact) {
+	return projectRecord({
+		...fact,
+		claim_text: fact.fact,
+		kind: "occurrence",
+		attribute: null,
+		value: fact.fact,
+		ends_current: false,
+		todo: "none",
+		close_reason: null,
+		changes_current_state: false,
+		importance: "low",
+		single_claim: true,
+		relations: [],
+		time: { kind: "unresolved" },
+		ended_time: { kind: "none" }
+	});
+}
+//#endregion
+export { parseAtomicCaptureReply as a, atomic_extraction_response_schema_default as c, fallbackAtomicCapturedFact as i, excludeProgressRecords as l, ATOMIC_ENRICHMENT_RESPONSE_JSON_SCHEMA as n, parseAtomicEnrichmentReply as o, ATOMIC_EXTRACTION_RESPONSE_JSON_SCHEMA as r, parseAtomicExtractionReply as s, ATOMIC_CAPTURE_RESPONSE_JSON_SCHEMA as t };